Lazarus Free Pascal

Zusätzliche Online-
Daten zum Buch

Software:
Free Pascal ist ein moderner und plattformunabhängiger Compiler für die
Programmiersprache Object Pascal. Er bildet auch die Unterlage für die
plattformübergreifende grafische Entwicklungsumgebung Lazarus.
Buch:
Zu Free Pascal gibt es im Internet eine mehrtausendseitige Dokumentation, die für diese autori-
sierte deutsche Fassung übersetzt und ediert wurde. Diese deutsche Version
enthält in teilweise gestraffter und ergänzter Form das Benutzerhandbuch, die komplette Sprach-
beschreibung, die Erläuterung aller Kommandozeilenschalter und Metabefehle sowie die Beschrei-
bung der Codeerzeugung, die für die Optimierung von Programmen und das Verständnis des
Compilers unumgänglich ist. Weiterhin enthält das Buch die Übersetzung der Referenz der wich-
tigsten Units der Laufzeitbibliothek von Free Pascal.
Autor:
Michaël Van Canneyt ist langjähriger Free-Pascal-Core-Entwickler und zeichnet, außer daß er der
ursprüngliche Maintainer der Linux-Version ist und sich heute vorwiegend
um die Klassenbibliotheken kümmert, auch für die Dokumentation des Projekts
verantwortlich. Die vorliegende Dokumentation, die im englischen Original mehrere Tausend Sei-
ten umfaßt, entstand im Laufe mehrerer Jahre und wird ständig an die neuen Funktionen des
Compilers angepaßt.
Der Autor ist Belgier, professioneller Software-Entwickler und lebt mit seiner Familie in Leuven. In
seiner knapp bemessenen Freizeit schreibt er außer Software auch Fachbeiträge für die Zeitschrift
freeX und widmet sich Buchprojekten. Er versteht außer
Flämisch, Französisch, Englisch und Russisch auch ausgezeichnet Deutsch.
Free Pascal 2
2. aktualisierte Ausgabe
Online-Daten
Michaël Van Canneyt
Übersetzung aus dem Englischen von

Jörg Braun, Michael Keßler, Florian Klämpfl, Christopher Özbek
und Rosa Riebl
Bibliographische Information der Deutschen Nationalbibliothek
Die Deutsche Nationalbibliothek verzeichnet diese Publikation in der
Deutschen Nationalbibliografie; detaillierte bibliographische Daten sind
im Internet über http://dnb.d-nb.de abrufbar.
Alle Rechte vorbehalten. Ohne ausdrückliche, schriftliche Genehmigung des

Herausgebers ist es nicht gestattet, das Buch oder Teile daraus in irgendeiner Form
durch Fotokopie, Mikrofilm oder ein anderes Verfahren zu vervielfältigen
oder zu verbreiten. Dasselbe gilt für das Recht der öffentlichen Wiedergabe.
Der Verlag macht darauf aufmerksam, daß die genannten Firmen- und
Markenzeichen sowie Produktbezeichnungen in der Regel marken-, patent-,
oder warenzeichenrechtlichem Schutz unterliegen.
Die Herausgeber übernehmen keine Gewähr für die Funktions-
fähigkeit beschriebener Verfahren, Programme oder Schaltungen.
1. Auflage 2012
© 2012 by C&L Computer und Literaturverlag

Zavelsteiner Straße 20, 71034 Böblingen
E-Mail: info@cul.de
WWW: http://www.CuL.de
Coverdesign: Hawa & Nöh, Neu-Eichenberg

Satz: C&L-Verlag
Druck: PUT i RB DROGOWIEC
Printed in Poland
Dieses Buch wurde auf chlorfrei gebleichtem Papier gedruckt
ISBN 978-3-936546-72-9
INHALTSVERZEICHNIS
Kapitel 4
Referenz der RTL (Online-Daten)
Seite 7
4.10 Die Manager-Units........................................................................8

4.10.1 Der Locale-Manager (clocale) ......................................................... 8
4.10.2 Der Memory-Manager (cmem)........................................................ 8
4.10.3 Der Thread-Manager (cthreads)...................................................... 9
4.10.4 Der WideString-Manager (cwstring)................................................. 9
4.11 Unit Math.....................................................................................10
4.11.1 Konstanten, Typen, Variablen........................................................ 10
4.11.2 Prozeduren und Funktionen .......................................................... 12
4.12 Unit dynlibs..................................................................................34
4.13 Unit GetOpts................................................................................36
4.14 Unit HeapTrc................................................................................39
4.15 Unit Lineinfo ................................................................................43
4.16 Unit Lnfodwrf ...............................................................................44
4.17 Unit DOS ......................................................................................44
4.18 Unit Strings ..................................................................................59
4.19 Unit Sockets .................................................................................66
4.20 Unit ipc.........................................................................................93
O6 Inhalt
4.21 Unit Video ..................................................................................108

4.21.1 Schreiben eines eigenen Bildschirmtreibers..................................110
4.21.2 Konstanten, Typen, Variablen ......................................................113
4.21.3 Prozeduren und Funktionen.........................................................118
4.22 Unit Mouse .................................................................................125
4.23 Unit Keyboard ...........................................................................131
4.23.1 Spezielle Hinweise zu Unix...........................................................131
4.23.2 Tastaturtreiber schreiben .............................................................132
Stichwortverzeichnis........................................149
KAPITEL 4 (ERGÄNZUNG)
REFERENZ DER RTL (ONLINE-DATEN)
4. REFERENZ DER RTL (ONLINE-D ATEN )

Die folgenden Abschnitte enthalten die Dokumentation der Units Math, dynlibs, Get-
Opts, HeapTrc, LineInfo, Lnfodwarf, clocale, cmem, cthreads, cwstrings, DOS, Strings,
IPC, Sockets, Keyboard, Video und Mouse von Free Pascal 2.x. Dieses Dokument ist eine
Ergänzung zu den Daten des gedruckten Buchs und wie dieses urheberrechtlich geschützt.
Die Datei wird als Probe- und Referenzabschnitt vom C&L-Verlag exklusiv auf seinen
Webseiten zur Verfügung gestellt und darf nicht an anderer Stelle ohne vorherige schrift-
liche Genehmigung des Verlags zur Verfügung gestellt werden.
Beschrieben werden zuerst jeweils die vordefinierten Konstanten und Variablen, an-
schließend die Funktionen und Prozeduren mit ihren jeweiligen Parametern und Beispie-
len. Optionale Parameter stehen immer in eckigen Klammern. Teilweise sind Beispielpro-
gramme gezeigt, die in einem Editor eingegeben und mit Free Pascal kompiliert werden
können.
O8 Kapitel 4 Referenz der RTL (Online-Daten)
4.10 Die Manager-Units
Die in diesem Abschnitt vorgestellten Units clocale, cmem, cthread und cwstring enthalten
Verwaltungsroutinen und keine APIs. Sie initialisieren die jeweilige POSIX-kompatiblen
Manager, die von der C-Bibliothek des unterliegenden POSIX-kompatiblen Unix- oder
Linux-Systems bereitgestellt werden. Dazu braucht die jeweilige Unit nur manuell als eine
der ersten Units in das Programm eingebunden werden, die restliche Arbeit erledigt au-
tomatisch der Initialisierungsbereich der Unit.
Wichtig: Das Einbinden dieser Units führt in jedem Fall dazu, daß das Programm gegen
die C-Bibliothek des Betriebssystems gelinkt wird. Weil es sinnlos ist, diese Units auf
einem Nicht-POSIX-Betriebssystem wie Windows, OS/2 oder DOS einzubinden, sollten
sie immer mit einem $ifdef-Statement zur bedingten Kompilierung kombiniert werden:
program myprogram;
uses
{$ifdef unix} UNITNAME,{$endif} classes, sysutils;
...
4.10.1 Der Locale-Manager (clocale)

clocale initialisiert die I18N-Einstellungen der Unit SysUtils mit den in der C-Bibliothek
des Systems vorgefundenen Werten. Die Unit braucht dafür nur in die Uses-Anweisung
des Programms eingefügt zu werden, die Arbeiten werden in ihrem Initialisierungsteil
durchgeführt. Das Einbinden muß wie bei allen vier Manager-Units über ein {$ifdef Unix}
gesteuert werden.
clocale exportiert keine Prozeduren, Funktionen oder Datentypen.
4.10.2 Der Memory-Manager (cmem)
Der Speichermanager in der Unic cmem setzt die Speicherverwaltung auf einen C-basierte
Version: Alle Speicherverwaltungsaufrufe werden über Malloc, Free und ReAlloc an den
C-Speichermanager weitergeleitet. Aus diesem Grund muß auch die Unit cmem als erste
in der Uses-Anweisung des Programms eingetragen werden.
Die Unit bietet auch das direkte Aufrufen der C-Speicherbefehle als externe Deklaratio-
nen aus der C-Bibliothek an, es wird allerdings dringend empfohlen, die normalen Free-
Pascal-Routinen zu nutzen.
Konstanten
LibName = ’c’;
LibName ist der Name der aktuell eingebunden Bibliothek, auf den meisten Systemen
wird das libc.so sein.
Prozeduren und Funktionen
CALLOC
function CAlloc(UnitSize: PtrUInt; UnitCount: PtrUInt): Pointer;
CAlloc belegt Speicher, um UnitCount Einheiten von jeweils der Größe UnitSize aufzu-
nehmen. Der Speicher ist insgesamt ein Block.
Die Funktion gibt den Zeiger auf den neu angelegten Speicherblock zurück.
Siehe auch: Malloc, Free und ReAlloc.
FREE
procedure Free(P: Pointer);
Free gibt den Speicherblock, auf den P zeigt, dem System zurück. Nach dem Aufruf von
Free ist der Zeiger P nicht mehr gültig.
Siehe auch: Malloc und ReAlloc.
(C) 2012 C&L - Computer- und Literaturverlag GmbH
Kapitel 4.10 Die Manager-Units – Malloc O9
MALLOC
function Malloc(Size: PtrUInt): Pointer;
Malloc ist die externe Deklaration des malloc-Aufrufs der C-Bibliothek. Die Funktion
besitzt einen Parameter zum Übermittlung der gewünschten Größe und gibt einen Zeiger
auf einen Zeiger auf einen Speicherbereich der gewünschten Größe oder NIL zurück,
wenn kein Speicher belegt werden konnte.
Siehe auch: Free und ReAlloc.
REALLOC
function ReAlloc(P: Pointer; Size: PtrUInt): Pointer;
ReAlloc fordert einen Speicherbereich, auf den P zeigt, erneut an. Der neue Bereich wird
die Größe Size haben und so viele Daten enthalten, wie verfügbar waren oder wie von der
alten in die neue Speicherposition kopiert werden konnten.
Siehe auch: Malloc und Free.
4.10.3 Der Thread-Manager (cthreads)
Die Unit CThreads initialisiert mit dem Aufruf von SetCThreadManager (siehe unten)
den Record System.ThreadManager und damit die Threadverwaltung der Unit System.
Basis ist die Implementation der POSIX-Thread-Routinen der C-Bibliothek. Dies ge-
schieht automatisch nach dem Einbinden der Unit (möglichst als erste) in die Uses-
Anweisung des Programms.
Weil es sinnlos ist, diese Unit auf einem Nicht-POSIX-System wie Windows, OS/2 oder
DOS einzubinden, sollte der Aufruf immer in einer ifdef-Bedingung stehen. Die Lazarus-
IDE fügt die bedingte Kompilierung automatisch bei jedem neu begonnenen Programm
ein.
SETCTHREADMANAGER
procedure SetCThreadManager;
SetCThreadManager setzt den Thread-Manager auf den C-Thread-Manager. Dieser Auf-
ruf darf manuell erfolgen, wenn während der Lebenszeit des Programmes aus beliebigen
Gründen zwischenzeitlich ein anderen Thread-Manager aktiviert wurde.
4.10.4 Der WideString-Manager (cwstring)
Die Unit cwstring initialisiert den WideString-Manager der Unit System mit einer Imple-
mentation auf der Basis der Sortier- und Umwandlungsfunktionen, die von der C-
Bibliothek des unterliegenden POSIX-kompatiblen Unix- oder Linux-Systems bereitge-
stellt werden. Dazu braucht die Unit cwstring nur manuell als eine der ersten Units in das
Programm eingebunden zu werden, die restliche Arbeit führt automatisch der Initialisie-
rungsbereich der Unit durch.
SETCWIDESTRINGMANAGER
procedure SetCWideStringManager;
SetCWideStringManager setzt den WideString-Manager-Record der Unit System. Diese
Prozedur wird automatisch im Initialisierungsteil der Unit aufgerufen.
Download nur für den Eigenbedarf, die Weiterverbreitung der Daten ist nicht gestattet
4.11 Unit Math
Die Unit Math wurde ursprünglich von Florian Klämpfl geschrieben. Sie deckt mathema-
tische Funktionen ab, die nicht in der Unit System enthalten sind. Folgendes muß beim
Aufrufen der Funktionen und Prozeduren aus dieser Unit beachtet werden:
– Die Unit ist im Object-Pascal-Modus kompiliert, weshalb alle Integer-Werte 32 Bit
lang sind (das gilt auch für den 64-Bit-Modus).
– Einige Funktionen sind für Datenarrays und Gleitkommazahlen überladen. Wenn
mit dem Adreßoperator @ gearbeitet wird, um solchen Funktionen ein Datenarray zu
übergeben, muß unbedingt darauf geachtet werden, daß die Adresse auf den richti-
gen Typ weist oder man schaltet die Compileroption des typisierten Adressenopera-
tors mit {$T+} oder {$TYPEDADDRESS ON} ein. Wird das nicht beachtet, kann der
Compiler nicht die gewünschte Funktion finden.
4.11.1 Konstanten, Typen, Variablen
Konstanten
EqualsValue = 0;
Die Werte sind identisch.
GreaterThanValue = High(TValueRelationship);
Der erste Wert ist größer als der zweite.
Infinity = 1.0 / 0.0;
Der Wert ist unendlich.
LessThanValue = Low(TValueRelationship);
Der erste Wert ist niedriger als der zweite.
MaxExtended = 1.1e + 4932;
Der Maximalwert des Datentyps Extended.
MaxFloat = MaxExtended;
Der Maximalwert des Datentyps Float.
MinExtended = 3.4e - 4932;
Minimaler Wert (am nächsten an Null) des Datentyps Extended.
MinFloat = MinExtended;
Minimaler Wert (am nächsten an Null) des Datentyps Float.
NaN = 0.0 / 0.0;
Der Wert ist keine Zahl.
NegativeValue = Low(TValueSign);
Der Wert ist negativ.
NegInfinity = -1.0 / 0.0;
Der Wert ist minus Unendlich.
PositiveValue = High(TValueSign);
Der Wert ist positiv.
ZeroValue = 0;
Der Wert ist 0.
Float = Extended;
PFloat = ^Float;
Alle Berechnungen werden mit dem Datentyp Float durchgeführt. Das erlaubt es, die Unit
mit unterschiedlichen Float-Typen zu kompilieren, um die jeweils gewünschte Genauig-
keit einzustellen. Der Zeigertyp PFloat, ein Zeiger auf den Datentyp Float, wird in Funk-
tionen benötigt, die ein beliebig großes Array von Werten akzeptieren.
Kapitel 4.11 Unit Math – Konstanten, Typdeklarationen, Variablen O11
PInteger = ObjPas.PInteger;
Zeiger auf den Datentyp Integer.
TFPUException = (exInvalidOp, exDenormalized, exZeroDivide, exOverflow,
exUnderflow, exPrecision);
Dieser Datentyp beschreibt die Gleitkommaprozessor-Exceptions.
KONSTANTEN, TYPDEKLARATIONEN, VARIABLEN
Wert Fehler
exDenormalizedexInvalidOp Ungültige Operation.
exOverflow Gleitkommaüberlauf.
exPrecision Genauigkeitsfehler.
exUnderflow Gleitkommaunterlauf.
exZeroDivide Division durch Null.
Tabelle O4.1: Die Werte des Aufzählungstyps für TFPUException
TFPUExceptionMask = set of (exDenormalized, exInvalidOp, exOverflow,

exPrecision, exUnderflow, exZeroDivide);
Typ zum Setzen der Exception-Maske der Gleitkommaeinheit.
TFPUPrecisionMode = (pmSingle, pmReserved, pmDouble, pmExtended);
Dieser Datentyp legt die voreingestellte Genauigkeit des Gleitkommaprozessors fest. Siehe
auch Tabelle O4.2.
Wert Datentyp/Genauigkeit
pmDouble Double
pmExtended Extended
pmReserved ?
pmSingle Single
Tabelle O4.2: Aufzählungswerte für den Datentyp TFPUPrecisionMode
TFPURoundingMode = (rmNearest, rmDown, rmUp, rmTruncate)

Der Datentyp beschreibt den Rundungsmodus der Gleitkommaeinheit.
Wert Beschreibung
rmDown Abrunden zum größten Integer, der kleiner als der Wert ist.
rmNearest Runden zum nächsten ganzzahligen Wert.
rmTruncate Bruchteil abschneiden.
rmUp Aufrunden zum kleinsten Integer, der größer als der Wert ist.
Tabelle O4.3: Aufzählungswerte für den Datentyp TFPURoundingMode
TPaymentTime = (ptEndOfPeriod, ptStartOfPeriod);

Datentyp für monetäre (Zins-)Berechnungen. Siehe auch Tabelle O4.4.
Wert Erläuterung
ptendofperiod Ende des Zeitraums.
ptstartofperiod Beginn des Zeitraums.
Tabelle O4.4: Aufzählungswerte für den Datentyp TPaymenttime
TRoundToRange = -37..37;
TRoundToRange ist der Bereich der gültigen Ziffern in der Funktion RoundTo.
TValueRelationship = -1..1;
Der Typ beschreibt die relative Reihenfolge (kleiner als, gleich, größer als) von Werten.
TValueSign = -1..1;
Der Typ beschreibt das Vorzeichen eines Werts.
4.11.2 Prozeduren und Funktionen
ARCCOS
function ArcCos(x: Float): Float;
ArcCos liefert den inversen Cosinus für den Parameter x. x sollte zwischen -1 und 1 sein
(Grenzen eingeschlossen).
Fehler: Ist der Parameter nicht im erlaubten Bereich, wird eine Ausnahme des Typs EIn-
validArgument ausgelöst.
Siehe auch: ArcSin, ArcosH, ArSinH und ArTanH.
program Example1; (* mathex/ex1.pp, Beispiel für die Funktion arccos *)
uses Math;
procedure WriteRadDeg(X: Float);

begin
WriteLn(X:8:5, ’ rad = ’, RadToDeg(x):8:5, ’ degrees.’)
end;
begin
WriteRadDeg(ArcCos(1));
WriteRadDeg(ArcCos(Sqrt(3) / 2));
WriteRadDeg(ArcCos(Sqrt(2) / 2));
WriteRadDeg(ArcCos(1/2));
WriteRadDeg(ArcCos(0));
WriteRadDeg(ArcCos(-1));
end.
ARCCOSH
function ArcCosH(x: Float): Float;
ArcCosH liefert den inversen Cosinus Hyberbolicus für den Parameter x. Diese Funktion
ist ein Alias für die Funktion ArcosH und für die Delphi-Kompatibilität vorhanden.
Siehe auch: ArcosH.
ARCOSH
function ArcosH(x: Float): Float;
ArcosH gibt den inversen Cosinus Hyperbolicus des Parameters x zurück. Der Parameter
muß größer als 1 sein. Die Variante ArcCosH ist für die Delphi-Kompatibilität implemen-
tiert und gleichwertig.
Fehler: Ist der Parameter x außerhalb des erlaubten Bereichs, wird eine Ausnahme des
Typs EInvalidArgument ausgelöst.
Siehe auch: CosH, SinH, ArcSin, ArSinH, ArTanH und TanH.
program Example3; (* mathex/ex3.pp, Beispiel für die Funktion ArcosH *)
uses Math;
begin
WriteLn(ArcosH(1));
WriteLn(ArcosH(2));
end.

Kapitel 4.11 Unit Math – ArcSin O13
ARCSIN
function ArcSin(x: Float): Float;
Arcsin ergibt den inversen Sinus für den Parameter x. x muß zwischen -1 und 1 sein.
Fehler: Ist der Parameter x außerhalb des erlaubten Bereichs, wird eine Ausnahme des
Typs EInvalidArgument ausgelöst.
Siehe auch: ArcCos, ArcosH, ArSinH und ArTanH.
program Example1; (* mathex/ex2.pp, Beispiel für die Funktion ArcSin *)
uses
Math;
procedure WriteRadDeg(X : Float);

begin
WriteLn(X:8:5, ’ rad = ’, RadToDeg(x):8:5, ’ degrees.’)
end;
begin
WriteRadDeg(ArcSin(1));
WriteRadDeg(ArcSin(Sqrt(3) / 2));
WriteRadDeg(ArcSin(Sqrt(2) / 2));
WriteRadDeg(ArcSin(1/2));
WriteRadDeg(ArcSin(0));
WriteRadDeg(ArcSin(-1));
end.
ARCSINH
function ArcSinH(x: Float): Float;
ArcSinH liefert den inversen Sinus Hyperbolicus für den Parameter x. Diese Funktion ist
ein Alias für ArSinH und wegen der Delphi-Kompatibilität vorhanden.
Siehe auch: ArSinH.
ARCTAN2
function ArcTan2(y: Float; x: Float): Float;
ArcTan2 berechnet arctan(y/x) und gibt einen Winkel im richtigen Quadraten zurück.
Der zurückgegebene Winkel bewegt sich im Bereich -π bis π rad. Die Werte von x müssen
zwischen -264 und 264 liegen, weiterhin muß x ungleich 0 sein. Auf Intel-Systemen ist diese
Funktion mit der nativen Intel-Funktion fpatan implementiert.
Fehler: Wird für x der Wert 0 angeben, kommt es zu einem Überlauf.
Siehe auch: ArcCos, ArCosH, ArSinH und ArTanH.
program Example6; (* mathex/ex6.pp Beispiel für die Funktion ArcTan2 *)
uses
Math;
procedure WriteRadDeg(X : Float);

begin
WriteLn(X:8:5,’ Rad = ’, RadToDeg(x):8:5, ’ Grad.’)
end;
begin
WriteRadDeg(ArcTan2(1, 1));
end.
ARCTANH
function ArcTanH(x: Float): Float;
ArcSinH gibt den inversen Tangens Hyperbolicus für den Parameter x zurück. Diese
Funktion ist ein Alias für ArTanH und wird wegen der Delphi-Kompatibilität bereitge-
stellt.
Siehe auch: ArTanH.
ARSINH
function ArSinH(x: Float): Float;
ArSinH ergibt den inversen Sinus Hyperbolicus für den Parameter x. Die Variante Arc-
SinH ist aus Gründen der Delphi-Kompatibilität implementiert.
Siehe auch: ArcosH, ArcCos, ArcSin und ArTanH.
program Example4; (* mathex/ex4.pp, Beispiel für die Funktion ArSinH *)
uses
Math;
begin
WriteLn(ArSinH(0));
WriteLn(ArSinH(1));
end.
ARTANH
function ArTanH(x: Float): Float;
ArTanH ergibt den inversen Tangens Hyperbolicus von x, wobei x zwischen -1 und 1 sein
muß. Die Variante ArcTanH dieser Funktion ist aus Gründen der Delphi-Kompatibilität
verfügbar und funktional identisch.
Fehler: Ist x außerhalb des gültigen Bereichs von -1 bis 1, wird eine Ausnahme des Typs
EInvalidArgument ausgelöst.
Siehe auch: ArcosH, ArcCos, ArcSin und ArTanH.
program Example5; (* mathex/ex5.pp, Beispiel für die Funktion ArTanH *)
uses
Math;
begin
WriteLn(ArTanH(0));
WriteLn(ArTanH(0.5));
end.
CEIL
function Ceil(x: Float): Integer;
Ceil ergibt die niedrigste ganze Zahl, die größer oder gleich x ist. Der absolute Wert von x
muß kleiner als MaxInt sein.
Fehler: Falls der absolute Wert von x größer als MaxInt ist, tritt ein Überlauffehler auf.
Siehe auch: Floor.
program Example7; (* mathex/ex7.pp, Beispiel für die Funktion Ceil *)
uses
Math;
begin
WriteLn(Ceil(-3.7)); // sollte -3 sein
WriteLn(Ceil(3.7)); // sollte 4 sein
end.

Kapitel 4.11 Unit Math – ClearExceptions O15
CLEAR EXCEPTIONS
procedure ClearExceptions(RaisePending: Boolean);
Löscht noch ausstehende Ausnahmen der Gleitkommaeinheit. Wenn RaisePending den
Wert True besitzt, werden diese Ausnahmen nicht gelöscht, sondern ausgelöst.
COMPAREVALUE
function CompareValue(const A: Integer; const B: Integer): TValueRelationship;
function CompareValue(const A: Int64; const B: Int64): TValueRelationship;
function CompareValue(const A: QWord; const B: QWord): TValueRelationship;
function CompareValue(const A: Extended; const B: Extended;
delta: Extended): TValueRelationship;
CompareValue vergleicht zwei ganzzahligge oder Gleitkommawerte A und B gibt -1, wenn
A < B, 0, wenn A = B und -1, wenn A > B ist zurück.
Siehe auch: TValueRelationship.
COSECANT
function CoSecant(x: Float): Float;
CoSecant berechnet die Cosekante (1/sin(x)) für den Parameter x.
Fehler: Wird 0° oder 180° angegeben, wird eine Ausnahme ausgelöst.
Siehe auch: Secant.
COSH
function CosH(x: Float): Float;
CosH gibt den Cosinus Hyperbolicus des Parameters x zurück.
Siehe auch: ArcosH, SinH und ArSinH.
program Example8; (* mathex/ex8.pp, Beispiel für die Funktion CosH *)
uses Math;
begin
WriteLn(CosH(0)); WriteLn(CosH(1));
end.
COT
function Cot(x: Float): Float;
Cot ist ein Alias für die Funktion Cotan.
Siehe auch: Cotan.
COTAN
function Cotan(x: Float) : Float
Cotan gibt den Cotangens für den Parameter x zurück. x sollte ungleich 0 sein.
Fehler: Falls für x Null angeben wird, kommt ein Überlauffehler.
Siehe auch: TanH.
program Example9; (* mathex/ex9.pp, Beispiel für die Funktion Cotan *)
uses
Math;
begin
WriteLn(Cotan(pi / 2)); WriteLn(Cotan(pi / 3)); WriteLn(Cotan(pi / 4));
end.
CSC
function csc(x: Float): Float;
csc ist ein Alias für die Function Cosecant.
Siehe auch: Cosecant.
CYCLETORAD
function CycleToRad(cycle: Float): Float;
Cycletorad wandelt den Parameter cycle (Vollwinkel) in das Bogenmaß (1 Vollwinkel = 2π
rad).
Siehe auch: DegToGrad, DegToRad, RadToDeg, RadToGrad und RadToCycle.
program Example10; (* mathex/ex10.pp, Beispiel für die Funktion CycleToRad *)
uses
Math;
begin
WriteLn(Cos(CycleToRad(1 / 6))); // sollte 1/2 ergeben
WriteLn(Cos(CycleToRad(1 / 8))); // sollte Sqrt(2)/2 sein
end.
DEGTOGRAD
function DegToGrad(deg: Float): Float;
DegToGrad wandelt den Parameter deg (einen Winkel in Grad) in Gon um (90° sind
100 gon).
Siehe auch: CycleToRad, DegToRad, RadToDeg, RadToGrad und RadToCycle.
program Example11; (* mathex/ex11.pp, Beispiel für die Funktion DegToGrad *)
uses
Math;
begin
WriteLn(DegToGrad(90)); // 100
WriteLn(DegToGrad(180)); // 200
WriteLn(DegToGrad(270)) // 300
end.
DEGTORAD
function DegToRad(deg: Float): Float;
Degtorad wandelt den Parameter deg (einen Winkel in Grad) in das Bogenmaß um
(π * rad = 180°).
Siehe auch: CycleToRad, DegToGrad, RadToDeg, RadToGrad und RadToCycle.
program Example12; (* mathex/ex12.pp, Beispiel für die Funktion DegToRad *)
uses
Math;
begin
WriteLn(DegToRad(45));
end.
DIVMOD
procedure DivMod(Dividend: Integer; Divisor: Word; var Result: Word; var Remainder: Word);
procedure DivMod(Dividend: Integer; Divisor: Word; var Result: SmallInt;
var Remainder: SmallInt);
procedure DivMod(Dividend: DWord; Divisor: DWord; var Result: DWord;
var Remainder: DWord);
procedure DivMod(Dividend: Integer; Divisor: Integer; var Result: Integer;
var Remainder: Integer);
DivMod gibt Dividend div Divisor in Result und Dividend mod Divisor in Remainder zu-
rück.

Kapitel 4.11 Unit Math – EnsureRange O17
ENSURERANGE
function EnsureRange(const AValue: Integer; const AMin: Integer;
const AMax: Integer): Integer; Overload;
function EnsureRange(const AValue: Int64; const AMin: Int64; const AMax: Int64): Int64;
Overload;
EnsureRange ergibt Value, wenn AValue sich im Bereich AMin bis AMax befindet. Die
Funktion ergibt AMin, wenn der Wert kleiner ist als AMin, und AMax, wenn er größer ist
als AMax.
Siehe auch: InRange.
FLOOR
function Floor(x: Float): Integer;
Floor ergibt die größte ganze Zahl, die kleiner oder gleich x ist. Der absolute Wert von x
muß kleiner als MaxInt sein.
Fehler: Ist x größer als MaxInt, erfolgt ein Überlauf.
Siehe auch: Ceil.
program Example13; (* mathex/ex13.pp, Beispiel für die Funktion Floor *)
uses Math;
begin
WriteLn(Ceil(3.7)); // sollte 3 sein
end.
FREXP
procedure Frexp(X: Float; var Mantissa: Float; var Exponent: Integer);
Frexp gibt Mantisse und Exponent von x in den Parametern Mantissa und Exponent zu-
rück.
program Example14; (* mathex/ex14.pp, Beispiel für die Prozedur Frexp *)
uses
Math;
procedure dofrexp(const X : Extended);

var
man: Extended;
Exp: LongInt;
begin
man := 0; Exp := 0;
Frexp(x, man, Exp);
Write(x, ’ has ’);
WriteLn(’Mantisse ’, man, ’ und Exponent ’, Exp);
end;
begin
// dofrexp(1.00);
dofrexp(1.02e-1);
dofrexp(1.03e-2);
dofrexp(1.02e1);
dofrexp(1.03e2);
end.
GETEXCEPTIONMASK
function GetExceptionMask: TFPUExceptionMask;
Lesen der Exception-Maske der Gleitkommaeinheit.
GETPRECISIONMODE
function GetPrecisionMode: TFPUPrecisionMode;
Lesen des Genauigkeitsmodus der Gleitkommeinheit.
GETROUNDMODE
function GetRoundMode: TFPURoundingMode;
Lesen des Rundungsmodus der Gleitkommeinheit.
GRADTODEG
function GradToDeg(grad: Float): Float;
GradToDeg wandelt den Parameter grad (einen Winkel in Gon) in normale Gradangaben
um (100 Gon sind 90 Grad).
Siehe auch: CycleToRad, DegToGrad, RadToDeg, RadToGrad, RadToCycle und GradToRad.
program Example15; (* mathex/ex15.pp, Beispiel für die Funktion GradToDeg *)
uses
Math;
begin
WriteLn(GradToDeg(100));
end.
GRADTORAD
function GradToRad(grad: Float): Float;
GradtoRad konvertiert den Parameter grad (einen Winkel in Gon) in einen Winkel im
Bogenmaß (200 gon sind π rad).
Siehe auch: CycleToRad, DegToGrad, RadToDeg, RadToGrad, RadToCycle und GradToDeg.
program Example16; (* mathex/ex16.pp, Beispiel für die Funktion GradToRad *)
uses
Math;
begin
WriteLn(GradToRad(100));
end.
HYPOT
function Hypot(x: Float; y: Float): Float;
Hypot liefert die Hypotenuse des rechtwinkligen Dreiecks mit den beiden Seitenlängen x
und y. Die Funktion basiert auf dem pythagoräischen Lehrsatz.
program Example17; (* mathex/ex17.pp, Beispiel für die Funktion Hypot *)
uses Math;
begin
WriteLn(Hypot(3, 4)); // sollte 5 ergeben
end.
IFTHEN
function ifthen(val: Boolean; const iftrue : Integer; const iffalse: Integer): Integer;
function ifthen(val: Boolean; const iftrue : Int64; const iffalse: Int64): Int64;
function ifthen(val: Boolean; const iftrue : Double; const iffalse: Double): Double;
function ifthen(val: Boolean; const iftrue : String; const iffalse: String): String;
ifthen ergibt iftrue, wenn val zutrifft (also True ist), und iffalse, wenn val nicht zutrifft
(also False ist). Diese Funktion kann in Ausdrücken eingesetzt werden.
Kapitel 4.11 Unit Math – InRange O19
INRANGE
function InRange(const AValue: Integer; const AMin : Integer;
const AMax : Integer): Boolean;
function InRange(const AValue: Int64; const AMin : Int64;
const AMax : Int64): Boolean;
InRange ergibt True, wenn AValue sich im Bereich von AMin bis AMax befindet, und
False, wenn Value außerhalb des angegebenen Bereichs liegt.
Siehe auch: EnsureRange.
INTPOWER
function IntPower(base: Float; const Exponent: Integer): Float;
Intpower ergibt base hoch exponent, wobei der Exponent eine ganze Zahl ist.
Fehler: Hat base den Wert 0 und ist der Exponent negativ, erfolgt ein Überlauf.
Siehe auch: Power.
program Example18; (* mathex/ex18.pp, Beispiel für die Funktion IntPower *)
uses
Math;
procedure DoIntpower(X: Extended; Pow: Integer);

begin
WriteLn(X:8:4, ’^’, Pow:2, ’ = ’, IntPower(X, Pow):8:4);
end;
begin
DoIntpower( 0.0, 0);
DoIntpower( 2.0, -1);
DoIntpower( 2.0, -2);
DoIntpower(-2.0, 4);
DoIntpower(-4.0, 3);
end.
ISINFINITE
function IsInfinite(const d: Double): Boolean;
IsInfinite gibt True, wenn der Double-Wert d unendlich ist.
Siehe auch: IsZero und IsInfinite.
ISNAN
function IsNan(const d: Single): Boolean; Overload;
function IsNan(const d: Extended): Boolean; Overload;
IsNan ergibt True, wenn der Double d keine Zahl (»Not A Number«) enthält, also einen
Wert, der nicht korrekt mit dem Datentyp Double dargestellt werden kann.
Siehe auch: IsZero und IsInfinite.
ISZERO
function IsZero(const A: Single; Epsilon: Single): Boolean; Overload;
function IsZero(const A: Single): Boolean; Overload;
function IsZero(const A: Extended; Epsilon: Extended): Boolean; Overload;
function IsZero(const A: Extended): Boolean; Overload;
IsZero prüft, ob der Gleitkommawert A Null ist, wobei eine Genauigkeit bis zu Epsilon
berücksichtigt wird. Die Funktion ergibt True, wenn Abs(A) kleiner ist als Epsilon.
Die Voreinstellung für Epsilon hängt vom Datentyp des Parameters ab und ist bei Gleit-
kommawerten des Datentyps Float auf MinFloat gesetzt.
Siehe auch: IsNan, IsInfinite und SameValue.
LDEXP
function LdExp(x: Float; const p: Integer): Float;
LdExp gibt 2p mal x zurück.
Siehe auch: lnxp1, Log10, Log2 und LogN.
program Example19; (* mathex/ex19.pp, Beispiel für die Funktion LdExp *)
uses
Math;
begin
WriteLn(LdExp(2, 4):8:4);
WriteLn(LdExp(0.5, 3):8:4);
end.
LNXP1
function lnxp1(x: Float): Float;
Lnxp1 ergibt den natürlichen Logarithmus von 1+X. Das Ergebnis ist bei kleineren Wer-
ten von x genauer, x muß größer als -1 sein.
Fehler: Falls für x der Wert -1 angegeben ist, wird eine Ausnahme des Typs EInvalid-
Argument ausgelöst.
Siehe auch: ldexp, Log10, Log2 und LogN.
program Example20; (* mathex/ex20.pp, Beispiel für die Funktion lnxp1 *)
uses
Math;
begin
WriteLn(lnxp1(0));
WriteLn(lnxp1(0.5));
WriteLn(lnxp1(1));
end.
LOG10
function Log10(x: Float): Float;
Log10 ergibt den dekadischen Logarithmus von x.
Fehler: Ist x kleiner oder gleich 0, wird ein Fehler »Invalid fpu Operation« ausgelöst.
Siehe auch: ldexp, lnxp1, Log2 und LogN.
program Example21; (* mathex/ex21.pp, Beispiel für die Funktion Log10 *)
uses
Math;
begin
WriteLn(Log10(10):8:4);
WriteLn(Log10(0.1):8:4);
WriteLn(Log10(0.001):8:4);
end.
LOG2
function Log2(x: Float): Float;
Log2 ergibt den Zweierlogarithmus von X.

Kapitel 4.11 Unit Math – LogN O21
Siehe auch: LdExp, LnXp1, Log10 und LogN.
program Example22; (* mathex/ex22.pp, Beispiel für die Funktion Log2 *)
uses
Math;
begin
end.
LOGN
function LogN(n: Float; x: Float): Float;
LogN ergibt den Logarithmus auf Basis n von x.
Siehe auch: LdExp, LnXp1, Log10 und Log2.
program Example23; (* mathex/ex23.pp, Beispiel für die Funktion LogN *)
uses
Math;
begin
WriteLn(LogN(3, 4):8:4);
WriteLn(LogN(Exp(1), Exp(1)):8:4);
WriteLn(LogN(0.5, 1):8:4);
WriteLn(LogN(0.25, 3):8:4);
WriteLn(LogN(0.125, 5):8:4);
end.
MAX
function Max(a: Integer; b: Integer): Integer; Overload;
function Max(a: Int64; b: Int64): Int64; Overload;
function Max(a: Extended; b: Extended): Extended; Overload;
Max ergibt das Maximum von Int1 und Int2.
Siehe auch: Min, MaxIntValue und MaxValue.
program Example24; (* mathex/ex24.pp, Beispiel für die Funktion Max *)
uses Math;
var
A, B: Cardinal;
begin
A := 1; B := 2;
WriteLn(Max(a, b));
end.
MAXINTVALUE
function MaxIntValue(const Data: array of Integer): Integer;
MaxIntValue liefert den größten Integerwert aus dem Array Data.
Diese Funktion ist nur aus Gründen der Delphi-Kompatibilität verfügbar, besser ist an-
stelle dieser Funktion das flexiblere MaxValue (siehe unten).
Siehe auch: MaxValue, MinValue und MinIntValue.
program Example25; (* mathex/ex25.pp, Beispiel für die Funktion MaxIntValue *)
(* Sicherstellen, daß Integer-Werte 32 Bit groß sind: *)
{$mode objfpc}
uses
Math;
type
TExArray = array[1..100] of Integer;
var
I : Integer;
ExArray: TExArray;
begin
Randomize;
for I := Low(ExArray) to High(ExArray) do ExArray[i] := Random(I) - Random(100);
WriteLn(MaxIntValue(ExArray));
end.
MAXVALUE
function maxvalue(const data: array of Extended): Extended;
function maxvalue(const data: PExtended; const N: Integer): Extended;
function maxvalue(const data: array of Integer): Integer;
function maxvalue(const data: PInteger;const N: Integer): Integer;
MaxValue ergibt den größten Wert im Array Data, das Integer- oder Gleitkommazahlen
enthalten kann. Der Rückgabewert ist vom gleichen Typ wie die Elemente im Array. Die
dritte und vierte Variante nehmen einen Zeiger auf ein Array mit N Integer- oder Gleit-
kommawerten entgegen.
Siehe auch: MaxIntValue, MinValue und MinIntValue.
program Example26; (* mathex/ex26.pp, Beispiel für die Funktion MaxValue *)
{$mode objfpc} (* Sicherstellen, daß Integer-Werte 32 Bit groß sind: *)
uses
Math;
var
i : 1..100;
f_array : array[1..100] of Float;
i_array : array[1..100] of Integer;
Pf_array: PFloat;
PI_array: PInteger;
begin
Randomize;
Pf_array := @f_array[1];
Pi_array := @i_array[1];
for i := Low(f_array) to High(f_array) do f_array[i] := (Random - Random) * 100;
for i := Low(i_array) to High(i_array) do i_array[i] := Random(I) - Random(100);
WriteLn(’Max Float : ’, MaxValue(f_array):8:4);

WriteLn(’Max Float (b) : ’, MaxValue(Pf_array,100):8:4);
WriteLn(’Max Integer : ’, MaxValue(i_array):8);
WriteLn(’Max Integer (b) : ’, MaxValue(Pi_array,100):8);
end.
MEAN
function Mean(const Data: array of Extended): Float;
function Mean(const Data: PExtended; const N: LongInt): Float;
Mean liefert den Durchschnittswert von Data. Die zweite Form nimmt einen Zeiger auf
ein Array mit N Werten entgegen.
Siehe auch: MeanAndStdDev, MomentSkewKurtosis und Sum.

Kapitel 4.11 Unit Math – MeanAndStdDev O23
program Example27; (* mathex/ex27.pp, Beispiel für die Funktion Mean *)
uses
Math;
type
TExArray = array[1..100] of Float;
var
I : Integer;
ExArray: TExArray;
begin
Randomize;
for I:=Low(ExArray) to High(ExArray) do ExArray[i] := (Random - Random) * 100;
WriteLn(’Max : ’,MaxValue(ExArray):8:4);
WriteLn(’Min : ’,MinValue(ExArray):8:4);
WriteLn(’Mean : ’,Mean(ExArray):8:4);
WriteLn(’Mean (b) : ’,Mean(@ExArray[1],100):8:4);
end.
MEANANDSTDDEV
procedure MeanAndStdDev(const Data: array of Extended;
var Mean: Float; var StdDev: Float);
procedure MeanAndStdDev(const Data: PExtended; const N: LongInt
var Mean: Float; var StdDev: Float);
MeanAndStdDev berechnet den Durchschnitt und die Standardabweichung von Data und
gibt die jeweiligen Ergebnisse in Mean und StdDev zurück. StdDev ist 0, wenn das Array
nur einen Wert enthält. Die zweite Form nimmt einen Zeiger auf ein Array mit N Werten
entgegen.
Siehe auch: Mean, Sum, SumOfSquares und MomentSkewKurtosis.
program Example28; (* mathex/ex28.pp, Beispiel für die Funktion MeanAndStdDev *)
uses
Math;
type
TExArray = array[1..100] of Extended;
var
I : Integer;
ExArray: TExArray;
Mean, StdDev: Extended;
begin
Randomize;
for I := Low(ExArray) to High(ExArray) do ExArray[i] := (Random - Random) * 100;
MeanAndStdDev(ExArray, Mean, StdDev);
WriteLn(’Mean : ’, Mean:8:4);
WriteLn(’StdDev : ’, StdDev:8:4);
MeanAndStdDev(@ExArray[1], 100, Mean, StdDev);
WriteLn(’Mean (b) : ’, Mean:8:4);
WriteLn(’StdDev (b) : ’, StdDev:8:4);
end.
MIN
function Min(a: Integer; b: Integer): Integer; Overload;
function Min(a: Int64; b: Int64): Int64; Overload;
function Min(a: Extended; b: Extended): Extended; Overload;
Min liefert den kleineren Wert von Int1 und Int2.
Siehe auch: Max.
program Example29; (* mathex/ex29.pp, Beispiel für die Funktion Min *)
uses
Math;
var
A, B: Cardinal;
begin
A := 1; B := 2;
WriteLn(Min(a, b));
end.
MININTVALUE
function MinIntValue(const Data: array of Integer): Integer;
MinIntvalue liefert den kleinsten Wert im Array Data. Die Funktion ist aus Gründen der
Delphi-Kompatibilität implementiert, es sollte besser die flexiblere Funktion MinValue
(siehe unten) genommen werden.
Siehe auch: MinValue, MaxIntValue und MaxValue.
program Example30; (* mathex/ex30.pp, Beispiel für die Funktion MinIntValue *)
{$mode objfpc} (* Sicherstellen, daß Integer-Werte 32 Bit groß sind: *)
uses
Math;
type
TExArray = array[1..100] of Integer;
var
i : Integer;
ExArray: TExArray;
begin
Randomize;
for i := Low(ExArray) to High(ExArray) do ExArray[i] := Random(i) - Random(100);
WriteLn(MinIntValue(ExArray));
end.
MINVALUE
function MinValue(const data: array of Extended): Extended;
function MinValue(const data: PExtended; const N: Integer): Extended;
function MinValue(const data: array of Integer): Integer;
function MinValue(const Data: PInteger; const N: Integer): Integer;
MinValue liefert den kleinsten Wert im Array Data mit Integer- oder Gleitkomma-
werten. Der Rückgabewert hat den selben Typ wie die Elemente im Array. Einige Vari-
anten nehmen einen Zeiger auf ein Array mit N Integer- oder Gleitkommawerten an.
Siehe auch: MaxIntValue, MaxValue und MinIntValue.
program Example31; (* mathex/ex31.pp, Beispiel für die Funktion MinValue *)
(* Sicherstellen, daß Integer-Werte 32 Bit groß sind: *)
{$mode objfpc}
uses
Math;
var
i : 1..100;
f_array : array[1..100] of Float;
i_array : array[1..100] of Integer;
Pf_array: PFloat;
PI_array: PInteger;
begin
Randomize;
Pf_array := @f_array[1];
Pi_array := @i_array[1];
for i := Low(f_array) to High(f_array) do f_array[i] := (Random - Random) * 100;
for i := Low(i_array) to High(i_array) do i_array[i] := Random(I) - Random(100);
WriteLn(’Min Float : ’, MinValue(f_array):8:4);

Kapitel 4.11 Unit Math – MomentSkewKurtosis O25
WriteLn(’Min Float (b) : ’, MinValue(Pf_array, 100):8:4);
WriteLn(’Min Integer : ’, MinValue(i_array):8);
WriteLn(’Min Integer (b) : ’, MinValue(Pi_array, 100):8);
end.
MOMENTSKEWKURTOSIS
procedure MomentSkewKurtosis(const Data: Array of Extended; out m1: Float;
out m2: Float; out m3: Float; out m4: Float;
out skew: Float; out kurtosis: Float);
procedure MomentSkewKurtosis(const Data: PExtended; const N: Integer; out m1: Float;
out m2: Float; out m3: Float; out m4: Float;
out skew: Float; out kurtosis: Float);
MomentSkewKurtosis berechnet die ersten vier Momente der Verteilung der Werte in
Data und gibt sie in m1, m2, m3 und m4 zurück und berechnet außerdem auch Skew
(Schiefe) und Kurtosis (Wölbung).
Siehe auch: Mean und MeanAndStdDev.
program Example32; (* mathex/ex32.pp, Beispiel für die Funktion MomentSkewKurtosis *)
uses
Math;
var
distarray: array[1..1000] of Float;
I : LongInt;
m1, m2, m3, m4, skew, kurtosis: Float;
begin
Randomize;
for I := Low(distarray) to High(distarray) do
distarray[i] := Random;
MomentSkewKurtosis(DistArray, m1, m2, m3, m4, skew, kurtosis);
WriteLn(’1st moment : ’, m1:8:6);
WriteLn(’2nd moment : ’, m2:8:6);
WriteLn(’3rd moment : ’, m3:8:6);
WriteLn(’4th moment : ’, m4:8:6);
WriteLn(’Skew : ’, skew:8:6);
WriteLn(’Kurtosis : ’, kurtosis:8:6);
end.
NORM
function Norm(const Data: array of Extended): Float;
function Norm(const Data: PExtended; const N: Integer): Float;
Norm berechnet die euklidische Norm des Datenarrays. Dies entspricht der Formel
Sqrt(SumOfSquares(data)). Die zweite Variante nimmt einen Zeiger auf N Werte entge-
gen.
Siehe auch: SumOfSquares.
program Example33; (* mathex/ex33.pp, Beispiel für die Funktion Norm *)
uses
Math;
var
v: array[1..10] of Float;
I: 1..10;
begin
for I := Low(v) to High(v) do v[I] := Random;
WriteLn(Norm(v));
end.
POPNSTDDEV
function PopNStdDev(const Data: array of Extended): Float;
function PopNStdDev(const Data: PExtended; const N: Integer): Float;
PopNStdDev liefert die Quadratwurzel der Streuung der Werte im Array Data. Mit nur
einem Wert im Array liefert die Funktion 0. Die zweite Version der Funktion nimmt
einen Zeiger auf ein Array mit N Werten entgegen.
Siehe auch: PopNVariance, Mean, MeanAndStdDev, StdDev und MomentSkewKurtosis.
program Example35; (* mathex/ex35.pp, Beispiel für die Funktion PopnStdDev*)
uses
Math;
type
var
I : Integer;
ExArray: TExArray;
begin
Randomize;
WriteLn(’Max : ’, MaxValue(ExArray):8:4);
WriteLn(’Min : ’, MinValue(ExArray):8:4);
WriteLn(’Pop. StdDev. : ’, PopNStdDev(ExArray):8:4);
WriteLn(’Pop. StdDev. (b) : ’, PopNStdDev(@ExArray[1], 100):8:4);
end.
POPNVARIANCE
function PopnVariance(const data: PExtended; const N: Integer): Float;
function PopnVariance(const data: array of Extended): Float;
PopNVariance ergibt die Verteilungsvarianz der Werte im Array Data und ergibt 0, wenn
sich nur ein Wert im Array befindet. Die zweite Form der Funktion nimmt einen Zeiger
auf ein Array mit N Werten entgegen.
Siehe auch: PopNStdDev, Mean, MeanAndStdDev, Stddev und MomentSkewkurtosis.
program Example36 ; (* mathex/ex36.pp, Beispiel für PopNVariance *)
uses math ;
var
I : Integer ;
ExArray: array[1..100] of Float ;
begin
Randomize ;
WriteLn(’Pop. var. : ’, PopnVariance(ExArray):8:4);
Writeln(’Pop. var. (b) : ’, PopnVariance(@ExArray[1], 100):8:4);
end.
POWER
function Power(Base: Float; Exponent: Float): Float;
Power ergibt Base hoch Exponent. Diese Funktion ist identisch zur Berechnung von
Exp(Power * Ln(base)). Aus diesem Grund darf base nicht negativ sein.
Siehe auch: IntPower.
program Example34; (* mathex/ex34.pp, Beispiel für die Funktion Power *)
uses
Math;

Kapitel 4.11 Unit Math – RadToCycle O27
procedure DoPower(x, y: Float);
begin
WriteLn(x:8:6, ’^’, y:8:6, ’ = ’, Power(x, y):8:6)
end;
begin
DoPower(2, 2);
DoPower(2,-2);
DoPower(2, 0.0);
end.
RADTOCYCLE
function RadToCycle(rad: Float): Float;
Radtocycle konvertiert den Parameter rad (einen Winkel im Bogenmaß) in einen Winkel
in Vollkreisen (1 Vollkreis = 2π rad).
Siehe auch: DegToGrad, DegToRad, RadToDeg, RadToGrad und CycleToRad.
program Example37; (* mathex/ex37.pp, Beispiel für die Funktion RadToCycle *)
uses
Math;
begin
WriteLn(RadToCycle(2 * pi):8:6);
WriteLn(RadToCycle(pi):8:6);
WriteLn(RadToCycle(pi / 2):8:6);
end.
RADTODEG
function RadToDeg(rad: Float): Float;
RadToDeg wandelt den Parameter rad (einen Winkel im Bogenmaß) in einen Winkel in
Grad um (180° entsprechen π rad).
Siehe auch: DegToGrad, DegToRad, RadToCycle, RadToGrad und CycleToRad.
program Example38; (* mathex/ex38.pp, Beispiel für die Funktion RadToDeg *)
uses
Math;
begin
WriteLn(RadToDeg(2 * pi):8:6);
WriteLn(RadToDeg(pi):8:6);
WriteLn(RadToDeg(pi / 2):8:6);
end.
RADTOGRAD
function RadToGrad(rad: Float): Float;
RadToGrad wandelt den Parameter rad (einen Winkel im Bogenmaß) in einen Winkel in
Gon um (200 Gon entsprechen π rad).
Siehe auch: DegToGrad, DegToRad, RadToCycle, RadToDeg und CycleToRad.
program Example39; (* mathex/ex39.pp, Beispiel für die Funktion RadToGrad *)
uses
Math;
begin
WriteLn(RadToGrad(2 * pi):8:6);
WriteLn(RadToGrad(pi):8:6);
WriteLn(RadToGrad(pi / 2):8:6);
end.
RANDG
function RandG(Mean: Float; StdDev: Float): Float;
RandG liefert eine Zufallszahl, die, wenn in großer Zahl produziert, eine Gaußsche Nor-
malverteilung mit dem Durchschnitt Mean und eine Standardabweichung StdDev besitzt.
Siehe auch: Mean, Stddev und MeanAndStdDev.
program Example40; (* mathex/ex40.pp, Beispiel für die Funktion RandG *)
uses Math;
var
i : Integer;
ExArray : array[1..10000] of Float;
Mean, StdDev: Float;
begin
Randomize;
for i := Low(ExArray) to High(ExArray) do ExArray[i] := RandG(1, 0.2);
MeanAndStdDev(ExArray, Mean, StdDev);
WriteLn(’Mean : ’, Mean:8:4);
WriteLn(’StdDev : ’, StdDev:8:4);
end.
RANDOMFROM
function RandomFrom(const AValues: array of Double): Double; Overload;
function RandomFrom(const AValues: array of Integer): Integer; Overload;
function RandomFrom(const AValues: array of Int64): Int64; Overload;
RandomFrom liefert ein Zufallselement aus dem Array AValues. Der Rückgabewert ist
vom selben Type wie die Elemente des Arrays.
Siehe auch System.Random und RandomRange.
RANDOMRANGE
function RandomRange(const aFrom: Integer; const aTo: Integer): Integer;
function RandomRange(const aFrom: Int64; const aTo: Int64): Int64;
RandomRange liefert ein zufälliges Element aus dem Bereich AFrom bis ATo. Die beiden
Bereiche brauchen nicht in aufsteigender Reihe zu sein, die Obergrenze ist nicht im gene-
rierten Wert enthalten, die Untergrenze kann es aber sein.
Siehe auch: System.Random und RandomFrom.
ROUNDTO
function RoundTo(const AVAlue: Extended; const Digits: TRoundToRange): Extended;
RoundTo rundet den angegebenen Gleitkommawert AVAlue auf die angegebene Zahl von
Stellen und gibt das Ergebnis zurück, das auf 10Digits genau ist. Es wird dazu die Standard-
routine Round aufgerufen.
Siehe auch: TRoundToRange und SimpleRoundTo.
SAMEVALUE
function SameValue(const A: Extended; const B: Extended): Boolean; Overload;
function SameValue(const A: Single; const B: Single): Boolean; Overload;
function SameValue(const A: Extended; const B: Extended;
Epsilon: Extended): Boolean; Overload;
function SameValue(const A: Single; const B: Single; Epsilon: Single): Boolean; Overload;
SameValue gibt True zurück, wenn die Gleitkommawerte A und B identisch sind, das
heißt, wenn ihre absoluten Werte kleiner als Epsilon sind. Ist der Unterschied größer,
wird False zurückgegeben. Die Voreinstellung von Epsilon hängt vom Datentyp der Pa-
rameter ab und ist beim Gleitkommatyp Float auf MinFloat voreingestellt.
Siehe auch: MinFloat und IsZero.
Kapitel 4.11 Unit Math – Sec O29
SEC
Function Sec(x: Float): Float;
Sec ist ein Alias für die Funktion Secant.
Siehe auch: Secant.
SECANT
function Secant(x: Float): Float;
Secant berechnet die Sekante (1/cos(x)) für den Parameter x.
Fehler: Bei Angabe eines Werts von 90° oder 270° wird eine Ausnahme ausgelöst.
Siehe auch: CoSecant.
SETEXCEPTIONMASK
function SetExceptionMask(const Mask: TFPUExceptionMask): TFPUExceptionMask;
Setzt die Exception-Maske der Gleitkommaeinheit.
SETPRECISIONMODE
function SetPrecisionMode(const Precision: TFPUPrecisionMode): TFPUPrecisionMode;
Setzt den Genauigkeitsmodus der Gleitkommeinheit.
SETROUNDMODE
function SetRoundMode(const RoundMode: TFPURoundingMode): TFPURoundingMode;
Setzt den Rundungsmodus der Gleitkommeinheit.
SIGN
function Sign(const AValue: Integer) : TValueSign; Overload;
function Sign(const AValue: Int64) : TValueSign; Overload;
function Sign(const AValue: Double) : TValueSign; Overload;
function Sign(const AValue: Extended): TValueSign; Overload;
Sign gibt das Vorzeichen des Parameters aus, der ein 32-/64-Bit-Integer oder ein Gleit-
kommawert sein kann. Der Rückgabewert ist eine Integerzahl und entweder -1, 0 oder 1.
Damit können dann weitere Berechnungen durchgeführt werden.
SIMPLEROUNDTO
function SimpleRoundTo(const AValue: Extended; const Digits: TRoundToRange): Extended;
SimpleRoundTo rundet den Wert AValue auf die in Digits angegebene Zahl von Stellen,
rundet dabei aber auf und gibt dann das Ergebnis zurück. Dieses Ergebnis stimmt auf bis
zu 10Digits Stellen. Dafür wird die Standardroutine Round aufgerufen.
Siehe auch: TRoundToRange und RoundTo.
SINCOS
procedure SinCos(theta: Float; out sinus: Float; out cosinus: Float);
SinCos berechnet den Sinus und den Cosinus des Winkels theta und gibt das Ergebnis in
den Parameter sinus und cosinus zurück. Auf Intel-Hardware ist diese Funktion schneller
als die getrennte Berechnung von Sinus und Cosinus.
Siehe auch: ArcSin und ArcCos.
program Example41; (* mathex/ex41.pp, Beispiel für die Funktion SinCos *)
uses
Math;
procedure DoSinCos(Angle: Float);

var
Sine, Cosine: Float;
begin
SinCos(Angle, Sine, Cosine);
Write(’Winkel: ’, Angle:8:6);
Write(’ Sinus: ’, Sine:8:6);
Write(’ Kosinus: ’, Cosine:8:6);
end;
begin
DoSinCos(pi);
DoSinCos(pi / 2);
DoSinCos(pi / 3);
DoSinCos(pi / 4);
DoSinCos(pi / 6);
end.
SINH
function SinH(x: Float): Float;
SinH liefert den Sinus Hyperbolicus für den Parameter x.
Siehe auch: CosH, ArsinH, TanH und ArtanH.
program Example42; (* mathex/ex42.pp, Beispiel für die Funktion SinH *)
uses
Math;
begin
WriteLn(SinH(0));
WriteLn(SinH(1));
WriteLn(SinH(-1));
end.
STDDEV
function StdDev(const Data: array of Extended): Float;
function StdDev(const Data: PExtended; const N: Integer): Float;
Stddev liefert die Standardabweichung für die Werte in Data. Enthält das Array nur einen
Wert, ist das Ergebnis Null. Die zweite Version der Funktion übernimmt einen Zeiger auf
ein Array mit N Werten.
Siehe auch: Mean, MeanAndStdDev, Variance und TotalVariance.
program Example40; (* mathex/ex43.pp, Beispiel für die Funktion StdDev *)
uses
Math;
var
I : Integer;
ExArray: array[1..10000] of Float;
begin
Randomize;
for I := Low(ExArray) to High(ExArray) do
ExArray[i] := RandG(1, 0.2);
WriteLn(’StdDev : ’, StdDev(ExArray):8:4);
WriteLn(’StdDev (b): ’, StdDev(@ExArray[0], 10000):8:4);
end.
SUM
function Sum(const Data: array of Extended): Float;
function Sum(const Data: PExtended; const N: LongInt): Float;
Sum liefert die Summe der Werte im Array data. Die zweite Version der Funktion über-
nimmt einen Zeiger auf ein Array mit N Werten.
Siehe auch: SumOfSquares, SumsAndSquares, TotalVariance und Variance.
Kapitel 4.11 Unit Math – SumInt O31
program Example44; (* mathex/ex44.pp, Beispiel für die Funktion Sum *)
uses Math;
var
I : 1..100;
begin
Randomize;
WriteLn(’Max : ’,MaxValue(ExArray):8:4);
WriteLn(’Min : ’,MinValue(ExArray):8:4);
WriteLn(’Sum : ’,Sum(ExArray):8:4);
WriteLn(’Sum (b) : ’,Sum(@ExArray[1], 100):8:4);
end.
SUMINT
function SumInt(const Data: PInt64; const N: LongInt): Int64;
function SumInt(const Data: array of Int64): Int64;
SumInt liefert die Summe der N Integerzahlen im Array Data, das ein offenes Array oder
ein Zeiger auf ein Array sein kann.
Fehler: Es kann ein Überlauf auftreten.
SUMOFSQUARES
function SumOfSquares(const Data: array of Extended): Float;
function SumOfSquares(const Data: PExtended; const N: Integer): Float;
SumOfSquares berechnet die Summe der Quadrate der Werte im Array Data.
Die zweite Version der Funktion übernimmt einen Zeiger auf ein Array mit N Werten.
Siehe auch: Sum, SumsAndSquares, TotalVariance und Variance.
program Example45; (* mathex/ex45.pp, Beispiel für die Funktion SumOfSquares *)
uses
Math;
var
I : 1..100;
begin
Randomize;
WriteLn(’Sum squares : ’, SumOfSquares(ExArray):8:4);
WriteLn(’Sum squares (b) : ’, SumOfSquares(@ExArray[1], 100):8:4);
end.
SUMSANDSQUARES
procedure SumsAndSquares(const Data: array of Extended;
var sum: Float; var SumOfSquares: Float);
procedure SumsAndSquares(const Data: PExtended; const N: Integer;
var sum: Float; var SumOfSquares: Float);
SumsAndSquares berechnet die Summe der Werte und die Summe der Quadrate der
Werte im Array Data und gibt die Ergebnisse in den Parametern sum und SumOfSquares
zurück.
Siehe auch: Sum, SumOfSquares, TotalVariance und Variance.
program Example45; (* mathex/ex46.pp, Beispiel für die Funktion SumOfSquares *)
uses
Math;
var
I : 1..100;
s, ss : Float;
begin
Randomize;
SumsAndSquares(ExArray, S, SS);
WriteLn(’Sum : ’, S:8:4);
WriteLn(’Sum squares : ’, SS:8:4);
SumsAndSquares(@ExArray[1], 100, S, SS);
WriteLn(’Sum (b) : ’, S:8:4);
WriteLn(’Sum squares (b) : ’, SS:8:4);
end.
TAN
function Tan(x: Float): Float;
Tan berechnet den Tangens von x.
Fehler: Falls x (normalisiert) π/2 oder 3π/2 ergibt, kommt es zum Überlauf.
Siehe auch: TanH, ArcSin, SinCos und ArcCos.
program Example47; (* mathex/ex47.pp, Beispiel für die Funktion Tan *)
uses
Math;
procedure DoTan(Angle: Float);

begin
Write(’Angle: ’, RadToDeg(Angle):8:6);
WriteLn(’ Tangent: ’, Tan(Angle):8:6);
end;
begin
DoTan(0);
DoTan(Pi);
DoTan(Pi / 3);
DoTAn(Pi / 4);
DoTan(Pi / 6);
end.
TANH
function TanH(x: Float): Float;
TanH berechnet den Tangens Hyperbolicus von x.
Siehe auch: ArcSin, SincCos und ArcCos.
program Example48; (* mathex/ex48.pp, Beispiel für die Funktion TanH *)
uses
Math;
begin
WriteLn(TanH(0));
WriteLn(TanH(1));
WriteLn(TanH(-1));
end.
TOTALVARIANCE
function TotalVariance(const Data: array of Extended): Float;
function TotalVariance(const Data: PExtended; const N: Integer): Float;

Kapitel 4.11 Unit Math – Variance O33
TotalVariance liefert die Gesamtvarianz der Werte im Array Data. Die Funktion liefert 0,
wenn das Array nur einen Wert enthält.
Siehe auch: Variance, StdDev und Mean.
program Example49; (* mathex/ex49.pp, Beispiel für die Funktion TotalVariance *)
uses
Math;
type
var
I : Integer;
ExArray: TExArray;
TV : Float;
begin
Randomize;
for I := 1 to 100 do ExArray[i] := (Random - Random) * 100;
TV := TotalVariance(ExArray);
WriteLn(’Total variance : ’, TV:8:4);
TV := TotalVariance(@ExArray[1], 100);
WriteLn(’Total Variance (b) : ’, TV:8:4);
end.
VARIANCE
function Variance(const Data: array of Extended): Float;
function Variance(const Data: PExtended; const N: Integer): Float;
Variance liefert die Varianz der Werte im Array Data. Die Funktion liefert 0, wenn das
Array nur einen Wert enthält. Die zweite Version der Funktion übernimmt einen Zeiger
auf ein Array mit N Werten.
Siehe auch: TotalVariance, StdDev und Mean.
program Example50; (* mathex/ex50.pp, Beispiel für die Funktion Variance *)
uses
Math;
var
I : 1..100;
V : Float;
begin
Randomize;
V := Variance(ExArray);
WriteLn(’Variance : ’, V:8:4);
V:=Variance(@ExArray[1], 100);
WriteLn(’Variance (b) : ’, V:8:4);
end.
EINVALIDARGUMENT
Die Ausnahme, die ausgelöst wird, wenn einer mathematischen Funktion ein ungültiger
Parameter übergeben wird.
Operatoren
Die Unit Math erweitert den Operator ** (siehe Unit System) um die Kompatibilität zu
Float und Int64.onstanten, Typen, Variablen
4.12 Unit dynlibs
Die Unit dynlibs stellt die Unterstützung für das dynamische Laden von Bibliotheksrouti-
nen aus DLLs (Windows, OS/2) und Shared Libraries (Linux und unixartige Plattformen)
zur Verfügung. Sie ist nur auf Plattformen mit dynamischen Bibliotheken verfügbar, also
Windows/Windows CE, OS/2, Netware, Darwin und den unixartigen Plattformen. Die
Funktionalität, die in dieser Unit zur Verfügung gestellt wird, kann aber, damit die Porta-
bilität gewahrt bleibt, nur einen Teil des kompletten Leistungsumfangs der jeweiligen
Einzelplattform umfassen. Auf Unix-Derivaten bedeutet das Einbinden dieser Unit, daß
das Programm gegen die C-Laufzeitbibliothek gelinkt wird, da die meisten Shared Libra-
ries und auch der dynamische Linker in C geschrieben sind.
Konstanten
NilHandle = TLibHandle(0);
NilHandle ist der richtig zugewiesene NIL-Handle, der bei einem Fehler von LoadLibrary
zurückgegeben wird. Je nach Plattform kann die Definition der Konstante leicht abwei-
chen, unter Windows sieht sie beispielsweise so aus: NilHandle = 0.
Die Definition erfolgt in der den Betriebssystemen zugeordneten dynlibs.inc-Dateien:
SharedSuffix = ’so’;
Die Endung für Shared Objects. Sie hängt von der Plattform ab, auf der die Dokumentati-
on erzeugt wurde. Die komplette Definition in der Datei dynlibs.pas sieht so aus:
const
{$ifdef Windows}
SharedSuffix = ’dll’;
{$else}
{$ifdef Darwin} // Darwin gilt genauso für OS X
SharedSuffix = ’dylib’;
{$else}
{$ifdef OS2}
SharedSuffix = ’dll’;
{$else}
SharedSuffix = ’so’;
{$endif}
{$endif}
{$endif}
Typdeklarationen
HModule = TLibHandle;
Ein Alias für den Datentyp TLibHandle.
TLibHandle = PtrInt;
TLibHandle sollte ein opaker Datentypen sein, er ist auf den verschiedenen Plattformen
unterschiedlich definiert. Die hier gezeigte Definition hängt davon ab, auf welcher Platt-
form die (englische) Dokumentation generiert wurde. Die jeweils für die Plattform gültige
Definition befindet sich in der Datei dynlibs.inc, die es für folgende Plattformen/Ver-
zeichnisse gibt:
netwlibc TLibHandle = Pointer;

os2 TLibHandle = LongInt;
unix TLibHandle = PtrInt;
win TLibHandle = LongInt;
wince TLibHandle = LongInt;
Kapitel 4.12 Unit dynlibs – FreeLibrary O35
FREELIBRARY
function FreeLibrary(Lib: TLibHandle): Boolean;
FreeLibrary stellt die selbe Funktionalität wie die Funktion UnloadLibrary zur Verfügung
und ist wegen der Delphi-Kompatibilität verfügbar.
Siehe auch: UnloadLibrary.
GETPROCADDRESS
function GetProcAddress(Lib: TLibHandle; const ProcName: AnsiString): Pointer;
GetProcAddress stellt die selbe Funktionalität wie die Funktion GetProcedureAddress zur
Verfügung und ist wegen der Delphi-Kompatibilität verfügbar.
Siehe auch: GetProcedureAddress.
GETPROCEDUREADDRESS
function GetProcedureAddress(Lib: TLibHandle; const ProcName: AnsiString): Pointer;
GetProcedureAddress gibt einen Zeiger auf die Speicherstelle des Symbols ProcName in
der dynamisch geladenen Bibliothek zurück, die im Handle Lib angegeben ist. Wird das
Symbol nicht gefunden oder ist das Handle ungültig, meldet die Funktion den Wert NIL.
Unter Windows können nur explizit exportierte Prozeduren oder Funktionen untersucht
werden. Auf unixartigen Plattformen kann jedes exportierte Symbol angefordert werden.
Fehler: Kann das Symbol nicht gefunden werden, ergibt die Funktion NIL.
Siehe auch: LoadLibrary, UnLoadLibrary.
LOADLIBRARY
function LoadLibrary(const Name: AnsiString): TLibHandle;
LoadLibrary lädt die dynamische Bibliothek Name und gibt einen Handle auf sie zurück.
Kann die Bibliothek nicht in den Speicher geladen werden, wird NilHandle gemeldet. Es
können keine Voraussagen über den Speicherplatz getroffen werden, an dem sich die
geladene Bibliothek befindet, wenn ein relativer Pfadname angegeben wird. Das Verhal-
ten ist hier plattformabhängig. Deshalb ist es am besten, wenn mit absoluten Pfadnamen
gearbeitet werden kann.
Fehler: Beim Auftreten eines Fehlers wird die Konstante NilHandle gemeldet.
Siehe auch: UnloadLibrary, GetProcedureAddress.
SAFELOADLIBRARY
function SafeLoadLibrary(const Name: AnsiString): TLibHandle;
SafeLoadLibary sichert das FPU-Steuerwort und ruft dann LoadLibrary mit dem Biblio-
theksnamen Name auf. Nachdem die Funktion zurückgekehrt ist, wird das FPU-Steuerwort
wieder gesichert. Diese Funktion gibt es nur auf CPUs der Intel-i386-Familie.
Siehe auch: LoadLibrary.
UNLOADLIBRARY
function UnloadLibrary(Lib: TLibHandle): Boolean
UnloadLibrary entfernt eine vorher geladene Bibliothek, deren Handle in Lib angegeben
ist, wieder aus dem Speicher. Der Aufruf ergibt True, wenn diese Arbeit erfolgreich
durchgeführt werden konnte.
Fehler: Tritt beim Entfernen der Bibliothek aus dem Speicher ein Fehler auf, wird False
zurückgemeldet.
Siehe auch: LoadLibrary, GetProcedureAddress.
4 KONSTANTE N, TYPE N, VARIABLEN
4.13 Unit GetOpts
Die Unit Getopts von Free Pascal wurde ursprünglich für Linux entwickelt und ist für alle
unterstützten Plattformen verfügbar. Sie stellt einen zu GNU getopts vergleichbaren Me-
chanismus für die strukturierte Verarbeitung von Kommandozeilenoptionen zur Verfü-
gung. Er erlaubt die Definition gültiger Optionen, extrahiert diese aus der Parameterliste
eines Programmaufrufs und gibt gegebenenfalls Fehler aus.
Konstanten
EndOfOptions = #255;
Wird von getopt zurückgegeben, wenn keine weiteren Optionen zur Verfügung stehen.
No_Argument = 0;
Gibt an, daß eine lange Option keine Parameter benötigt.
Optional_Argument = 2;
Gibt an, daß eine lange Option einen optionalen Parameter besitzen darf.
OptSpecifier: set of Char = [’-’];
Zeichen für das Erkennen von Optionen auf der Kommandozeile.
Required_Argument = 1;
Gibt an, daß eine lange Option einen Parameter benötigt.
Typdeklarationen
Orderings = (require_order, permute, return_in_order);
Die Aufzählungswerte für den Datentyp Orderings bedeuten:
Wert Beschreibung
permute Die Kommandozeilenoptionen werden geändert.
require_order Die Kommandozeilenoptionen dürfen nicht angetastet werden.
return_in_order Optionen in der richtigen Reihenfolge zurückgeben.
Tabelle O4.5: Die Optionen zur Kommandozeilensortierung
type
TOption = record
Name : String;
Has_arg: Integer;
Flag : PChar;
Value : Char;
end;
POption = ^TOption;
Der Typ TOptions übergibt lange Optionen an die Routine GetLongOpts. Das Feld Name
enthält den Namen der Option, in Has_arg kann angegeben werden, ob die Option einen
Parameter erwartet, und Flag verweist auf das Zeichen Value, wenn Flag von NIL ver-
schieden ist. POption ist ein Zeiger auf einen TOption-Record und wird als Parameter an
die GetLongOpts-Funktion übergeben.
Variablen
OptArg: String;
Besitzt eine Option einen zusätzlichen Parameter, enthält diese Variable nach einem Auf-
ruf von GetLongOpts beziehungsweise GetOpt dessen Wert.
OptErr: Boolean;
Die Variable bestimmt, ob getopt() Fehlermeldungen ausgibt oder nicht.
Kapitel 4.13 Unit GetOpts – GetLongOpts O37
OptInd: LongInt;
Der Index des aktuellen Paramstr(). Wenn alle Optionen verarbeitet worden sind, ist
Optind der Index des ersten Parameters, der keine Option ist. Die Variable ist kann nur
gelesen werden und kann den Wert ParamCount + 1 annehmen.
OptOpt: Char;
Die Variable enthält beim Auftreten eines Fehlers das Zeichen, das den Fehler auslöste.
GETLONGOPTS
function GetLongOpts(ShortOpts: String; LongOpts: POption; var Longind: LongInt): Char;
Die Funktion gibt die nächste Option, die auf der Kommandozeile gefunden wurde,
unter Berücksichtigung von langen Optionen zurück. Werden keine weiteren Optio-
nen gefunden, wird EndOfOptions zurückgeliefert. Besitzt die Option einen Parameter,
wird dieser in der Variable OptArg abgelegt. ShortOpts ist eine Zeichenfolge mit allen
möglichen Ein-Buchstabenoptionen (siehe Getopt für Beschreibung und Gebrauch).
LongOpts ist ein Zeiger auf das erste Element eines Arrays von TOption-Records, des-
sen letzter Record ein Namensfeld mit leerem String enthalten muß. Die Funktion
versucht, Namen teilweise anzupassen (liegt beispielsweise eine Funktion namens
Append vor, wird --app als ihr Kürzel interpretiert), wird aber bei Zweideutigkeiten
einen Fehler melden. Falls die Option einen Parameter verlangt, setzen Sie das Feld
Has_arg des jeweiligen TOption-Records auf Required_argument; falls die Option op-
tionalen Parameter besitzen soll, setzen Sie Has_arg auf Optional_argument. Falls die
Option keine Parameter benötigt, setzen Sie Has_arg auf Null. Auf der Kommandozeile
können Optionen, die einen Parameter erwarten, in zweierlei Schreibweisen angegeben
werden:
– Durch Gleichzeichen an die Option angefügt: --option=value
– Als gesonderter Parameter : --option value
Optionale Parameter können nur durch die erste Methode beschrieben werden.
Fehler, siehe: Getopt, getopt
Siehe auch: Getopt
GETOPT
function GetOpt(ShortOpts: String): Char;
Getopt gibt die nächste Option zurück, die auf der Kommandozeile gefunden wurde.
Wenn keine weiteren Optionen gefunden werden, wird EndOfOptions zurückgegeben.
Falls mit der Option ein Parameter übergeben wurde, wird dieser in der OptArg-
Variablen abgelegt. ShortOptions ist eine Zeichenkette mit allen gültigen Ein-
Buchstabenoptionen. Steht hinter einem Zeichen ein Doppelpunkt, erwartet die Option
einen Parameter. Stehen hinter einem Zeichen zwei Doppelpunkte, besitzt die Option
einen optionalen Parameter. Falls das erste Zeichen des Shortopts-Strings ein »+« ist,
werden alle Optionen, die auf eine Option folgen, die nicht in Shortopts enthalten ist, als
sogenannte »Nicht-Optionen« angesehen. Falls die Zeichenkette mit einem »-« eingeleitet
wird, werden alle Nicht-Optionen behandelt, als wären sie Parameter einer Option mit
dem Zeichen #0. Dies ist nützlich bei Anwendungen, die ihre Optionen in der exakten
Reihenfolge des Auftretens benötigen. Falls das erste Zeichen von Shortopts keine der
oben genannten Möglichkeiten ist, werden Optionen und Nicht-Optionen so umsortiert,
daß zuerst alle Optionen und dann alle Nicht-Optionen stehen. Aus diesem Grund ist es
möglich, daß Optionen und Nicht-Optionen in zufälliger Reihenfolge auf der Komman-
dozeile stehen.
Fehler: Fehler werden durch Rückgabe des Zeichens »?« gemeldet. OptOpt liefert dann das
Zeichen, das den Fehler verursachte. Falls OptErr gleich true ist, schreibt getopt eine Feh-
lermeldung an die Standardausgabe.
Siehe auch: GetLongOpts, getopt
program testopt; (* optex/optex.pp, Beispiel für die Funktion getopts *)
(* Gültige Aufrufe an dieses Programm sind
optex --verbose --addme --delete you
optex --append --create child
optex -ab -c me -d you und so weiter
*)
uses
getopts;
var
c : Char;
optionindex: LongInt;
theopts : array[1..7] of TOption;
begin
with theopts[1] do begin
name := ’add’;
has_arg := 1;
flag := NIL;
value := #0;
end;

name := ’append’;
has_arg := 0;
flag := NIL;
value := #0;
end;

name := ’delete’;
has_arg := 1;
flag := NIL;
value := #0;
end;

name := ’verbose’;
has_arg := 0;
flag := NIL;
value := #0;
end;

name := ’create’;
has_arg := 1;
flag := NIL;
value := ’c’
end;
name := ’file’;
has_arg := 1;
flag := NIL;
value := #0;

Kapitel 4.14 Unit HeapTrc – GetOpt O39
end;

name := ’’;
has_arg := 0;
flag := NIL;
end;
c := #0;
repeat
c := GetLongOpts(’abc:d:012’, @theopts[1], OptionIndex);
case c of
’1’, ’2’, ’3’, ’4’, ’5’, ’6’, ’7’, ’8’, ’9’: begin
WriteLn(’Erhalten Optind: ’, c)
end;
#0: begin
Write(’Lange Option:’, theopts[optionindex].name);
if theopts[optionindex].has_arg > 0 then
WriteLn(’Mit Wert: ’, optarg)
else
WriteLn
end;
’a’: WriteLn(’Option a.’);

’b’: WriteLn(’Option b.’);
’c’: WriteLn(’Option c: ’, optarg);
’d’: WriteLn(’Option d: ’, optarg);
’?’, ’:’: WriteLn(’Fehler bei Option: ’, Optopt);
end;
until c = EndOfOptions;
if optind <= ParamCount then begin

Write(’Keine Optionen:’);
while Optind <= ParamCount do begin
Write(ParamStr(optind),’ ’);
Inc(Optind)
end;
WriteLn
end
end.
4.14 Unit HeapTrc

Die Unit Heaptrc ist systemunabhängig und hilft bei der Fehlersuche bei Speicherzuwei-
sungen und -freigaben. Sie führt Buch über die Aufrufe von Getmem/Freemem und
schließt auch New und Dispose mit in die Überwachung ein.
Wenn ein Programm beendet wird oder eine direkte Anweisung dafür vorliegt, wird der
gesamte belegte Speicher angezeigt und anschließend eine Liste aller Speicherblöcke aus-
gegeben, die zwar reserviert, aber nicht wieder freigegeben wurden, außerdem wird der
Ort ausgegeben, an dem der Speicher reserviert wurde.
Bei Inkonsistenzen wie beispielsweise der zweimaligen Freigabe eines Speicherblocks oder
bei Speicherblöcken, die nicht vollständig oder mit einer falschen Größenangabe freigege-
ben wurden, werden Informationen ausgegeben.
Die Informationen, die gespeichert und angezeigt werden, können durch ein paar Kon-
stanten auf die persönlichen Bedürfnisse angepaßt werden.
Die Unit HeapTrc wird mit der Umgebungsvariable HEAPTRC gesteuert, wobei der In-
halt dieser Variable die Startwerte einiger Konstanten der Unit kontrolliert. Sie enthält
eine oder mehrere der folgenden Zeichenketten, die durch Leerzeichen voneinander ge-
trennt werden:
keepreleased Ist dieser String angegeben, wird die Variable KeepReleased auf True
gesetzt.
disabled Ist dieser String angegeben, wird die Variable UseHeapTrace auf False
gesetzt und die Heapverfolgung ausgeschaltet. Es ist wirkungslos, diese
Angabe mit anderen Werten zu kombinieren.
nohalt Ist dieser String gesetzt, wird die Variable HaltOnError auf False gesetzt,
was dazu führt, daß das Programm auch beim Auftreten eines Heapfehlers
fortgesetzt wird.
log=filename Ist dieser String definiert, wird die Ausgabe von HeapTrc in die anschlie-
ßend angegebene Datei geschrieben (siehe auch SetHeapTraceOutput).
KONSTANTEN, TYPEN, VARIABLEN
Die folgenden Werte sind für die Variable HEAPTRC gültig:
HEAPTRC=disabled
HEAPTRC=”keepreleased log=heap.log”
HEAPTRC=”log=myheap.log nohalt”
Zu beachten ist, daß sowohl der Name der Variable wie auch die Definitionen die Groß-
/Kleinschreibung beachtet. Prinzipiell ist die einzige Änderung des Quelltextes zur Aktivie-
rung der Fehlersuche das Einfügen der Unit Heaptrc in den uses-Abschnitt des Programms.
Es muß sichergestellt werden, daß Heaptrc die erste Unit im uses-Abschnitt ist, weil sonst
Speicherreservierungen in den Initialisierungsabschnitten von vorangehenden Units nicht
registriert werden können und damit zu fehlerhaften Ergebnissen führen.
Wird der Compiler mit dem Schalter -gh aufgerufen, fügt er die Unit selbständig ein, sie
muß gar nicht erst in die Uses-Anweisung aufgenommen werden. Als Ergebnis des Test-
programms, das auf Seite O42 abgedruckt ist, wird der folgende Speicherinhalt ausgegeben:
Marked memory at 0040FA50 invalid
Wrong size : 128 allocated 64 freed
0x00408708
0x0040CB49
0x0040C481
Call trace for block 0x0040FA50 size 128
0x0040CB3D
0x0040C481
Wird auch die Unit lineinfo eingebunden (oder der Schalter -gl gesetzt), gibt HeapTrc
auch die Dateinamen und Zeilennummerninformation in der Rückverfolgung aus:
Marked memory at 00410DA0 invalid
Wrong size : 128 allocated 64 freed
0x004094B8
0x0040D8F9 main, line 25 of heapex.pp
0x0040D231
Call trace for block 0x00410DA0 size 128
0x0040D8ED main, line 23 of heapex.pp
0x0040D231
Falls hier Zeilen ohne Dateiname/Zeilennummer auftauchen, enthält die entsprechende
Unit keine Debuginformationen.
Kapitel 4.14 Unit HeapTrc – Konstanten, Typen, Variablen O41
Konstanten
add_tail: Boolean = True;
Falls add_tail auf True gesetzt ist (die Voreinstellung), erstreckt sich die Prüfung auch auf
den Speicher direkt hinter dem belegten Speicher.
HaltOnError: Boolean = True;
Falls HaltOnError auf True gesetzt wird, wird ein unzulässiger Aufruf von FreeMem den
Speichermanager veranlassen, eine halt-Anweisung auszuführen. Im Standardfall ist diese
Konstante auf True gesetzt.
HaltOnNotReleased: Boolean = False;
HaltOnNotReleased kann auf True gesetzt werden, um die DumpHeap-Prozedur anzuhal-
ten (Exitcode 203), falls vom Programm beim Ausführen des Speicherdumps noch nicht
sämtlicher Speicher freigegeben wurde. Falls die typisierte Konstante auf False gesetzt ist
(Voreinstellung), kehrt DumpHeap einfach zurück.
keepreleased: Boolean = False;
Wenn KeepReleased auf true gesetzt wird, führt Heaptrc eine Liste des bereits freigegebe-
nen Speichers. Diese Option ist nützlich, falls ein Speicherblock zweimal gelöscht wird.
Da diese Option sehr speicherintensiv ist, sollte sie nur im Notfall angewandt werden.
quicktrace: Boolean = True;
Quicktrace bestimmt, ob der Speichermanager überprüfen soll, ob ein Speicherblock, der
gerade gelöscht werden soll, korrekt durch GetMem reserviert wurde. Dies ist ein sehr
zeitaufwendiger Prozeß und verlangsamt die Programmausführung erheblich. Quicktrace
ist dennoch standardmäßig auf True gesetzt (im Gegensatz zum alten FPC 1.0).
tracesize = 8;
tracesize gibt an, wie viele Ebenen von Aufrufen des Aufrufstacks während einer Ausgabe
durch die DumpHead-Anweisung angezeigt werden sollen. Wird keepreleased := true
gesetzt, wird die Hälfte von tracesize für den GetMem-Aufrufstack und die andere Hälfte
für den FreeMem-Aufrufstack reserviert.
Ein Beispiel: Der Standardwert 8 für tracesize bewirkt die Ausgabe von acht Ebenen des
Aufrufsrahmens des GetMem-Befehls, falls KeepReleased false ist. Falls KeepReleased true
ist, werden vier Ebenen für GetMem und vier Ebenen für FreeMem ausgegegeben. Soll
dieser Wert geändert werden, muß die Unit Heaptrc mit einem neuen Wert für die Kon-
stante kompiliert werden.
usecrc: Boolean = True;
Falls usecrc eingeschaltet ist (Voreinstellung), werden die Speicherstellen vor und nach dem
Speicheranfordern CRC-geprüft, was beim Erkennen des Überschreibens von Speicher hilft.
useheaptrace: Boolean = True;
Diese Variable muß beim Programmstart gesetzt sein, damit die Umgebungsvariable
ausgewertet wird.
Typdeklarationen
TDisplayExtraInfoProc = procedure(var ptext: Text; p: Pointer)
TDisplayExtraInfo ist ein prozeduraler Typ, der im Aufruf von SetHeapExtraInfo einen
Speicherbereich anzeigt, der vorher mit TFillExtraInfoProc gefüllt wurde.
TFillExtraInfoProc = procedure(p: Pointer);
TFillExtraInfoProc ist ein prozeduraler Typ, der in der Routine SetExtraInfo einen Spei-
cherbereich mit zusätzlichen Daten für die Anzeige von Daten belegt.
DUMPHEAP
procedure DumpHeap;
DumpHeap gibt eine Aufstellung der Speicherbelegung an die Standardausgabe aus. Der
Befehl wird automatisch von der Unit Heaptrc aufgerufen, wenn das Programm beendet
wird (dies geschieht durch Installation einer Exit-Prozedur), aber die Prozedur kann auch
an jeder anderen Stelle aufgerufen werden.
Siehe auch: MarkHeap.
SETHEAPEXTRAINFO
procedure SetHeapExtraInfo(size: PtrUInt; Fillproc: TFillExtraInfoProc;
DisplayProc: TDisplayExtraInfoProc);
SetExtraInfo speichert Extrainformationen in den Blöcken, die die Unit Heaptrc belegt,
wenn GetMem-Aufrufe verfolgt werden. Size gibt die Größe (in Byte) an, die der Überwa-
chungsmechanismus für die Informationen reservieren soll. Bei jedem Aufruf von Get-
Mem wird func ausgeführt und liefert einen Zeiger auf den reservierten Speicher.
Wenn die Zusammenfassung der Speicherdaten angezeigt wird, werden die Extra-
informationen als LongInt-Werte mit ausgegeben.
Fehler: SetExtraInfo kann nur dann aufgerufen werden, wenn bisher noch kein Speicher
zugewiesen wurde. Falls schon vor SetExtraInfo Speicher zugewiesen wurde, wird ein
Fehler in der Standardfehlerausgabe angezeigt und DumpHeap ausgeführt.
Siehe auch: DumpHeap, SetHeapTraceOutput.
program heapex; (* heapex/setinfo.pp, Beispiel für die Unit HeapTrc *)
uses
HeapTrc;
var
P1 : ^LongInt;
P2 : Pointer;
I : LongInt;
Marker: LongInt;
procedure SetMarker(P: Pointer);

type
PLongInt = ^LongInt;
begin
PLongInt(P)^ := Marker;
end;
procedure Part1;
begin
// Blocks allocated here are marked with $FFAAFFAA = -5570646
Marker := $FFAAFFAA;
New(P1); New(P1);
Dispose(P1);
for I := 1 to 10 do begin
GetMem(P2, 128);
if (I mod 2) = 0 then
FreeMem(P2, 128);
end;
GetMem(P2, 128);
end;

Kapitel 4.15 Unit Lineinfo – SetHeapTraceOutput O43
procedure Part2;
begin
// Blocks allocated here are marked with $FAFAFAFA = -84215046
Marker := $FAFAFAFA;
New(P1); New(P1);
Dispose(P1);
for I := 1 to 10 do begin
GetMem(P2, 128);
if (I mod 2) = 0 then
FreeMem(P2,128);
end;
GetMem(P2, 128);
end;
begin
SetExtraInfo(SizeOf(Marker), @SetMarker);
Writeln(’Part 1’); Part1;
Writeln(’Part 2’); Part2;
end.
SETHEAPTRACEOUTPUT
procedure SetHeapTraceOutput(const name: String);
SetHeapTraceOutput legt den Dateinamen, in den die Informationen zur Heapverfolgung
geschrieben werden, fest. In der Voreinstellung werden die Daten auf die Standardausga-
be geschrieben, diese Prozedur erlaubt es, die Daten in eine Datei mit dem vollständigen
Namen name zu schreiben.
Fehler: Wenn die Datei nicht geschrieben werden kann, treten beim Schreiben der Nach-
verfolgung Fehler auf.
Siehe auch: SetHeapExtraInfo.
4.15 Unit Lineinfo

Die Unit Lineinfo stellt eine Routine zur Verfügung, um die Debuginformationen aus
einer ausführbaren Datei auszulesen (falls diese Debuginformationen enthält) und Quell-
textinformationen zu dieser Adresse zu erfahren. Sie arbeitet mit Stabs-Debug-
informationen.
Um Debuginformationen vom Typ DWARF auszulesen, muß statt Lineinfo die Unit
LnfoDwrf eingebunden werden.
GETLINEINFO
function GetLineInfo(addr: ptruint; var func: String; var source: String;
var line: LongInt): Boolean;
GetLineInfo liefert die Quelltextzeileninformation zur Adresse addr. Diese Daten werden
in der Stabs-Debuginformation in der Binärdatei gesucht. Wurde die Datei ohne Debu-
ginformationen kompiliert, wird nichts zurückgemeldet. Bei einer erfolgreichen Suche
meldet die Funktion den Wert True und füllt den Parameter func mit dem Namen der
Funktion, in der sich die Adresse befindet. Der Parameter source enthält den Namen der
Datei, in der die Funktion implementiert wurde, und line die Zeilennummer in der Datei
von addr.
Fehler: Wurden keine Debuginformationen gefunden, gibt die Funktion den Wert False
zurück.
4.16 Unit Lnfodwrf
Die Unit LnfoDwrf stellt eine Routine zur Verfügung, die die Debuginformationen aus
einer ausführbaren Datei ausliest (falls diese Debuginformationen enthält) und Quelltext-
informationen zu dieser Adresse zurückgibt. Sie arbeitet mit DWARF-Debuginfor-
mationen.
Für Debuginformationen vom Typ Stabs muß die Unit lineinfo eingebunden werden.
GETLINEINFO
function GetLineInfo(addr: ptruint; var func: String; var source: String;
var line: LongInt): Boolean;
GetLineInfo gibt die Quellzeileninformationen zur Adresse addr zurück. Die Funktion
sucht diese Information in den DWARF-Debuginformationen in der Binärdatei. Falls die
Datei ohne Debuginformationen kompiliert wurde, wird nichts zurückgegeben.
Nach dem erfolgreichen Ermitteln der Debuginformationen wird True zurückgegeben
und der Parameter func meldet den Namen der Funktion, die zur Adresse gehört. Der
Parameter source enthält den Namen der Datei, in der die Funktion implementiert wurde,
und line die Zeilennummer in der Datei zu addr.
Fehler: Wurden keine Debuginformationen gefunden, gibt die Funktion den Wert False
zurück.
4.17 Unit DOS

Die Unit DOS bietet den Zugriff auf eine Reihe betriebssystemspezifischer Aufrufe für
Dateien, auf das Dateisystem, sowie Datum und Uhrzeit. Mit der Ausnahme von PalmOS
ist diese Unit auf allen von Free Pascal unterstützten Plattformen verfügbar.
Die Unit wurde ursprünglich von Florian Klämpfl für DOS geschrieben, von Mark May
auf Linux portiert und von Michaël Van Canneyt erweitert. Der (inzwischen veraltete)
Amiga-Port wurde von Nils Sjoholm geschrieben.
Bei anderen Betriebssystemen als DOS geht ein Teil der Funktionalität der Unit verloren,
da die Routinen entweder nicht implementiert werden können oder nutzlos sind. Sind die
Funktionen tatsächlich implementiert – und nicht nur als Prozedurrumpf aus Gründen
der Abwärtskompatibilität –, verhalten sie sich auf den verschiedenen Betriebssystemen
gleich.
Die Unit DOS dient der Kompatibilität zum veralteten 16-Bit Turbo-Pascal-Compiler
und wird nicht mehr aktiv weiterentwickelt; das Interface ist eingefroren und die Funk-
tionen und Prozeduren werden nur noch für das Portieren alter Turbo-Pascal-Routinen
gepflegt. Für das Entwickeln neuer und moderner Programme wird dringend empfohlen,
anstelle dieser Unit die neuere Unit SysUtils einzubinden.
Die Unit DOS bindet die Unit BaseUnix ein.
Konstanten
DATEIMODUS-KONSTANTEN
Die folgenden Konstanten werden im Feld Mode des Record TextRec benötigt. Sie geben
Auskunft über den Dateimodus der Textein- und Textausgabe (siehe Tabelle O4.6).

Kapitel 4.17 Unit DOS – Dateiattribute O45
Konstante Beschreibung Wert
fmclosed Datei ist geschlossen. 0D7B0h
fminput Datei ist nur zum Lesen. 0D7B1h
fmoutput Datei ist nur zum Schreiben. 0D7B2h
fminout Datei darf gelesen und geschrieben werden. 0D7B3h
Tabelle O4.6: Die Dateimodus-Konstanten
DATEIATTRIBUTE
Die Dateiattribute-Konstanten werden in FindFirst und FindNext für die Definition benö-
tigt, nach welchen Dateitypen zusätzlich zu normalen Dateien (solchen ohne Attribute)
gesucht werden soll. Diese Flags gelten außerdem in den Routinen SetFAttr und GetFAttr
für das Setzen und Auslesen der Attribute von Dateien. Zusammengestellt sind sie in
Tabelle O4.7.
Konstante Beschreibung Wert

readonly Schreibschutzattribut. 01h
hidden Attribut für versteckte Datei. 02h
sysfile Attribut für Systemdatei. 04h
volumeid Datei ist das Volume Label (Datenträgerkennung). 08h
directory Attribut für Verzeichnisse. 10h
archive Archivattribut. 20h
anyfile Attribut, das auf alle Dateien paßt. 3Fh
Tabelle O4.7: Mögliche Dateiattribute
LÄNGENBESCHREIBUNGEN
Die Unit DOS enthält einige Beschreibungen für Längenangaben:
Konstante Wert Beschreibung

filerecnamelength 255 Maximallänge des Dateinamensanteils im Record FileRec
FileNameLen 255 Maximale Länge eines Dateinamens
TextRecBufSize 256 Größe des voreingestellten Puffers in TextRec.
TextRecNameLength 256 Maximale Länge eines Dateinamens in TextRec.
CPU-FLAGS
Die in der Unit definierten CPU-Flags werden nicht verwendet und sind nur auf Kompa-
tibilitätsgründen zu alten 16-Bit-Programmen definiert:
Konstante Wert Bedeutung (Flag)

fauxiliary 0010h Auxiliary Flag
fcarry 0001h Carry Flag
foverflow 0800h Overflow Flag
fparity 0004h Parity Flag
fsign 0080h Sign
fzero 0040h Zero Flag
TYPDEKLARATIONEN
Typdeklarationen
Die folgenden Stringtypen sind für die Vereinfachung des Umgangs mit Dateinamen
deklariert. Bei den modernen Betriebssystemen mit langen Dateinamen sind in der Datei
dos.h.inc die Längenangaben auf die Konstante FileNameLen gesetzt, die auf 255 im Hea-
der der Datei festgelegt ist. Damit wird die alte Deklaration von Free Pascal 1.x und Turbo
Pascal überschrieben:
ComStr = String[127]; // Für Befehlszeilen
PathStr = String[79]; // Für komplette Pfade von Dateinamen
DirStr = String[67]; // Für Verzeichnisse und (DOS-)Laufwerksbezeichnungen
NameStr = String[8]; // Für Dateinamen
ExtStr = String[4]; // Für Dateierweiterungen
Werden Dateien auf der Festplatte gesucht, wird der folgende Record mit Daten gefüllt:
SearchRec = packed record
SearchPos : TOff;
SearchNum : LongInt;
DirPtr : Pointer;
SearchType : Byte;
SearchAttr : Byte;
Mode : Word;
Fill : array[1..1] of Byte;
Attr : Byte;
Time : LongInt;
Size : LongInt;
Reserved : Word;
Name : String;
SearchSpec : String;
NamePos : Word;
end;
FileRec ist für die interne Repräsentation von typisierten und untypisierten Dateien. Text-
dateien werden in den folgenden Typen gespeichert:
const
filerecnamelength = 255;
type
FileRec = packed record
Handle,
Mode : LongInt;
RecSize : SizeInt;
_private: array[1..3 * SizeOf(SizeInt) + 5 * SizeOf(Pointer)] of Byte;
UserData: array[1..32] of Byte;
name : array[0..filerecnamelength] of Char;
end;
Die Definition des Textpuffers:
const
TextRecNameLength = 256;
TextRecBufSize = 256;
type
TextBuf = array[0..TextRecBufSize - 1] of Char;
TextRec = packed record
Handle : THandle;
Mode : LongInt;
bufsize : SizeInt;
_private : SizeInt;
bufpos : SizeInt;
bufend : SizeInt;

Kapitel 4.17 Unit DOS – Typdeklarationen O47
bufptr : ^Textbuf;
openfunc : Pointer;
inoutfunc: Pointer;
flushfunc: Pointer;
closefunc: Pointer;
UserData : array[1..32] of Byte;
name : array[0..TextRecNameLength - 1] of Char;
buffer : TextBuf;
end;
Hinweis: Diese Deklaration ist nicht binärkompatibel zu ihrem Gegenstück aus Turbo
Pascal, da sich die Größe der einzelnen Felder geändert hat.
Dies ist der Record der CPU-Register für den Aufruf der Prozedur MsDos:
{$IFDEF CPUI386}
{$IFNDEF HAS_REGISTERS}
Registers = packed record
case i: Integer of
0 : (ax, f1, bx, f2, cx, f3, dx, f4, bp, f5, si, f51, di, f6, ds, f7,
es, f8, flags,fs,gs: Word);
1 : (al, ah, f9, f10, bl, bh, f11, f12, cl, ch, f13, f14, dl, dh: Byte);
2 : (eax, ebx, ecx, edx, ebp, esi, edi: LongInt);
end;
{$ENDIF HAS_REGISTERS}
{$ENDIF CPUI386}
Der Typ DateTime wird in PackTime und UnPackTime benutzt, um das Dateidatum mit
GetFTime und SetFTime setzen oder ermitteln zu können:
DateTime = record
Year : Word;
Month: Word;
Day : Word;
Hour : Word;
Min : Word;
Sec : Word;
end;
Variablen
DosError: Integer;
In der Variable DosError wird von den Prozeduren in der Unit DOS ein Fehler gespei-
chert. DosError kann die folgenden Werte annehmen:
Wert Bedeutung
2 Datei nicht gefunden.
3 Pfad nicht gefunden.
5 Zugriff verweigert.
6 Ungültiges Handle.
8 Nicht genügend Speicher.
10 Ungültige Umgebung.
11 Ungültiges Format.
18 Zu viele Dateien.
Tabelle O4.8: Fehlerkennungen in der Unit DOS
Andere Werte sind möglich, aber nicht dokumentiert.
ADDDISK
function AddDisk(const path: String): Byte;
AddDisk fügt einen Dateinamen path zur internen Laufwerksliste hinzu und ist nur unter
Linux implementiert. Die Laufwerksliste bestimmt, welches Laufwerk in den Befehlen Disk-
Free und DiskSize benutzt wird. DiskFree und DiskSize benötigen eine Datei auf dem ausge-
wählten Laufwerk, es wird beim Aufruf der Systemfunktion statfs benötigt. Die Namen wer-
den aufeinanderfolgend hinzugefügt. Die vier ersten Einträge sind vordefiniert:
– ».« für das aktuelle Laufwerk,
– »/fd0/.« für das erste Floppy-Laufwerk.
– »/fd1/.« für das zweite Floppy-Laufwerk.
– »/« für die erste Festplatte.
Der erste Aufruf von AddDisk fügt deshalb einen Namen für die zweite Festplatte der
Liste hinzu, der zweite Aufruf für das dritte Laufwerk und so weiter, bis 23 Laufwerke
hinzugefügt wurden (entsprechend Laufwerke »D:« bis »Z:«).
Siehe auch: DiskFree, DiskSize
DISKFREE
function DiskFree(drive: Byte): Int64;
DiskFree liefert die Anzahl der freien Byte auf dem Laufwerk. Der Parameter Drive gibt
an, welches Laufwerk untersucht werden soll. Dieser Parameter entspricht 1 für Laufwerk
»a:«, 2 für Laufwerk »b:« und so weiter. Der Wert 0 als Parameter übergeben, gibt den
freien Speicher des aktuellen Laufwerks zurück. Normalerweise ist der freie Speicher die
Größe der Festplattenblöcke multipliziert mit der Anzahl der freien Blöcke auf der Fest-
platte.
Nur für Linux:
DiskFree und DiskSize benötigen eine Datei auf dem ausgewählten Laufwerk, dies verlangt die
Systemfunktion statfs. Vier Dateinamen werden von der Unit DOS vorinitialisiert:
Es können jedoch bis zu 26 verschiedene Laufwerke angegeben werden. Ein weiteres nicht
vordefiniertes Laufwerk fügt die Prozedur AddDisk hinzu.
Fehler: Es wird -1 zurückgegeben, wenn ein Fehler auftritt oder eine falsche Laufwerks-
nummer zurückgegeben wurde.
program Example6; (* dosex/ex6.pp, Beispiel für die Funktionen DiskSize und DiskFree *)
uses
Dos;
begin
WriteLn(’Die Partition ist ’, DiskSize(0), ’ Byte groß.’);
WriteLn(’Aktuell sind ’, DiskFree(0), ’ Byte frei.’);
end.
DISKSIZE
function DiskSize(drive: Byte): Int64;
DiskSize liefert die absolute Größe eines Laufwerks in Byte. Der Parameter Drive gibt das
zu untersuchende Laufwerk an. Dieser Parameter ist 1 für Laufwerk a:, 2 für Laufwerk b:
und so weiter. Der Wert 0 liefert den Speicher des aktuellen Laufwerks.

Kapitel 4.17 Unit DOS – DosExitCode O49
Nur für unixartige Betriebssysteme:
Diskfree und Disksize benötigen eine Datei auf dem ausgewählten Laufwerk, da dies von
der Systemfunktion statfs verlangt wird. Vier Dateinamen werden von der Unit DOS
vorinitialisiert:
Es können jedoch bis zu 26 verschiedene Laufwerke angegeben werden. Um ein weiteres
nicht vordefiniertes Laufwerk hinzuzufügen, wird AddDisk aufgerufen.
Fehler: -1, wenn ein Fehler auftritt oder eine falsche Laufwerksnummer zurückgegeben
wird.
Ein Beispiel ist unter DiskFree zu finden.
Siehe auch: DiskFree und AddDisk.
DOSEXITCODE
function DosExitCode: Word;
DosExitCode enthält im niederwertigen Byte den Exitcode eines Programms, das mit dem
Exec-Befehl ausgeführt wurde.
Siehe auch: Exec.
program Example5; (* dosex/ex5.pp, Beispiel für die Funktionen Exec und DosExitCode *)
uses
Dos;
begin
{$ifdef Unix}
WriteLn(’Starte /bin/ls -la’);
Exec(’/bin/ls’, ’-la’);
{$else}
WriteLn(’Starte Dir’);
Exec(GetEnv(’COMSPEC’), ’/C dir’);
{$endif}
WriteLn(’Programme endete mit ExitCode ’, Lo(DosExitCode));
end.
DOSVERSION
function DosVersion: Word;
DosVersion gibt die Versionsnummer des Betriebssystems oder die Kernelversion zurück.
Das höherwertige Byte enthält die jeweilige Unter- und das niederwertige Byte die Haupt-
versionsnummer.
Hinweis: Auf Systemen, deren Version mehr als zwei Zahlen enthalten, werden nur die
ersten beiden zurückgegeben. Unter Linux finden beispielsweise nur die ersten beiden
Nummern Anwendung, so daß beispielsweise eine Linuxversion 2.6.24 nur 2.6 ausgibt.
Bei Betriebssystemen, die keinen speziellen Systemaufruf besitzen, um die Kernelversion
mitzuteilen, erhält man eine Versionsnummer von 0.
program Example1; (* dosex/ex1.pp, Beispiel für die Funktion DosVersion *)
uses
Dos;
var
OS: String[32];
Version: Word;
begin
{$ifdef LINUX} OS := ’Linux’; {$endif}
{$ifdef FreeBSD} OS := ’FreeBSD’; {$endif}
{$ifdef NetBSD} OS := ’NetBSD’; {$endif}
{$ifdef Solaris} OS := ’Solaris’; {$endif}
{$ifdef DOS} OS := ’Dos’; {$endif}
(* Die Liste in diesem Beispiel ist nicht vollständig! *)
Version := DosVersion;
WriteLn(’Current ’, OS, ’ version is ’, Lo(Version), ’.’, Hi(Version));
end.
DTTOUNIXDATE
function DTToUnixDate(DT: DateTime): LongInt;
DTToUnixDate wandelt den DOS-DateTime DT in einen Unix-Zeitstempel um. DTTo-
UnixDate ist eine interne Funktion für Unix-Plattformen, sie sollte in der Anwendungs-
entwicklung keine Anwendung finden.
Siehe auch: UnixDateToDT, PackTime, UnpackTime, GetTime und SetTime.
ENVCOUNT
function EnvCount: LongInt;
EnvCount ermittelt die Anzahl der Umgebungsvariablen.
Siehe auch: EnvStr und GetEnv.
ENVSTR
function EnvStr(Index: LongInt): String;
EnvStr gibt das Name=Wert-Paar an der Position Index aus der Liste der Umgebungs-
variablen zurück. Der Index des ersten Paares ist Null.
Fehler: Die Länge ist auf 255 Zeichen begrenzt..
Siehe auch: EnvCount und GetEnv.
program Example13; (* dosex/ex13.pp, Beispiel für die Funktionen EnvCount und EnvStr *)
uses Dos;
var
i : LongInt;
begin
WriteLn(’Current Environment is:’);
for i := 1 to EnvCount do WriteLn(EnvStr(i));
end.
EXEC
procedure Exec(const path: PathStr; const comline: ComStr);
Exec führt das Program in Path mit den Optionen, die in ComLine gegeben sind, aus.
Nachdem das Program beendet wurde, kehrt die Prozedur zurück. Der Exit-Code kann
durch die Funktion DosExitCode bestimmt werden.
Fehler: Fehler werden in DosError ausgegeben.
Ein Beispiel ist bei der Erläuterung zu DosExitCode gezeigt.
Siehe auch: DosExitCode.
FEXPAND
function FExpand(const path: PathStr): PathStr;
Beschreibung: FExpand erweitert den Parameter path zu einer absoluten Pfadangabe,
bestehend aus Laufwerksbuchstabe (unter DOS, Windows, OS/2), Pfadangabe und Datei-
name. Auf Dateisystemen, die zwischen Groß- und Kleinschreibung unterscheiden (wie
Linux und Unix), bleiben die Dateinamen unverändert, sonst werden sie in Großbuchsta-
ben konvertiert.
Siehe auch: FSplit.

Kapitel 4.17 Unit DOS – FindClose O51
program Example11; (* dosex/ex11.pp, Beispiel für die Funktion FExpand *)
uses
Dos;
begin
WriteLn(’Der vollständige Name dieses Programms ist ’,
FExpand(ParamStr(0)));
end.
FINDCLOSE
procedure FindClose(var f: SearchRec);
FindClose gibt alle zum Suchrecord f gehörenden Ressourcen frei. Der Aufruf gibt die von
den Aufrufen FindFirst und/oder FindNext belegten Ressourcen wieder frei, wozu die
Unix-Implementation der Unit DOS eine Tabelle mit offenen Verzeichnissen bereitstellt.
Wenn die Tabelle voll ist, wird eines der Verzeichnisse geschlossen und ein weiteres ge-
öffnet. Dieses System funktioniert gut und ist im Grund vergleichbar mit der ursprüngli-
chen DOS-Implementation, ist aber verhältnismäßig langsam, wenn eine große Zahl von
Suchrecords geöffnet wird.
Deshalb wurde, um das FindFirst/FindNext-System zu beschleunigen, der FindClose-
Befehl implementiert, der einen nicht mehr benötigten Suchvorgang abschließt und das
zugehörige Verzeichnis schließt. Wenn man einen SearchRec also nicht mehr benötigt,
teilt man das der Unit DOS mit dem Aufruf FindClose mit, womit der SearchRec geschlos-
sen und der Tabellenslot freigegeben wird.
Hinweis: Es wird empfohlen, unter Linux nach Dateien mit dem Befehl Glob zu suchen.
Fehler: Fehler werden über DosError bekanntgegeben.
Siehe auch: FindFirst und FindNext.
FINDFIRST
procedure FindFirst(const path: PathStr; attr: Word; var f: SearchRec);
FindFirst leitet die Suche nach der durch path spezifizierten Datei mit den Attributen Attr
ein. Die Prozedur speichert alle benötigten Daten, um die Suche weiterzuführen, im Re-
cord f. Path kann Wildcard-Zeichen (das Zeichen * entspricht einer beliebig langen Folge
von beliebigen Zeichen, ? entspricht einem einzigen beliebigen Zeichen) enthalten. Wird
eine den Angaben entsprechende Datei gefunden, wird diese in F gespeichert und 0 in
DosError gespeichert. Eine mit FindFirst initialisierte Suche kann mit FindNext fortgesetzt
und FindClose beendet werden.
Unter OS/2 können keine zwei unterschiedlichen FindFirst-Aufruf parallel gestartet wer-
den. Es muß immer zuerst der eine Suchlauf beendet werden, bevor der zweite gestartet
werden kann. Hält man sich nicht an diese Regel, wird ein Laufzeitfehler Nummer 6 (un-
gültiger Dateihandle) ausgelöst.
Fehler: Fehler werden in DosError gemeldet.
Siehe auch: FindNext, FindClose, SysUtils.FindFirst, SysUtils.FindNext, SysUtils.FindClose.
program Example7; (* dosex/ex7.pp Beispiel für die Funktionen FindFirst und FindNext *)
uses (* ältere Variante mit der Unit Dos! *)
Dos;
var
Dir: SearchRec;
begin
FindFirst(’*.*’, archive, Dir);
WriteLn(’FileName’ + Space(32), ’FileSize’: 9);
while DosError = 0 do begin
Writeln(Dir.Name + Space(40 - Length(Dir.Name)), Dir.Size:9);
FindNext(Dir);
end;
FindClose(Dir);
end.
FINDNEXT
procedure FindNext(var f: SearchRec);
FindNext erhält als Argument einen SearchRec-Record, der durch einen FindFirst-Befehl
initialisiert wurde, und versucht die nächste Datei zu finden, die mit den dem FindFirst-
Befehl übergebenen Kriterien übereinstimmt. Falls DosError von Null verschieden ist,
wurde keine andere die Kriterien erfüllende Datei gefunden.
Fehler: DosError meldet Fehler.
Ein Beispiel befindet sich unter FindFirst.
Siehe auch: FindFirst, FindClose, SysUtils.FindFirst, SysUtils.FindNext, SysUtils.FindClose.
FSEARCH
function FSearch(path: PathStr; dirlist: String): PathStr;
FSearch sucht die Datei Path in allen Verzeichnissen, die in DirList angeführt werden. Die
vollständige Pfadangabe der gefundenen Datei wird zurückgeliefert. DirList muß eine
Liste von Verzeichnissen sein, die durch Strichpunkte getrennt werden. Falls keine Datei
gefunden wurde, wird eine leere Zeichenfolge zurückgeliefert.
Hinweis: Unter unixartigen Systemen kann als Trenner in DirList auch der dort für Pfad-
trennungen übliche Doppelpunkt angegeben werden.
Siehe auch: FExpand.
program Example10; (* dosex/ex10.pp, Beispiel für die Funktion FSearch *)
uses
Dos;
var
s: PathStr;
begin
s := FSearch(ParamStr(1), GetEnv(’PATH’));
if s = ’’ then
WriteLn(ParamStr(1),’ nicht im Suchpfad gefunden’)
else
Writeln(ParamStr(1),’ im Suchpfad befinden unter ’, s);
end.
FSPLIT
procedure FSplit(path: PathStr; var dir: DirStr; var name: NameStr; var ext: ExtStr);
FSplit zerlegt einen vollständigen Dateinamen path in die drei Teile Pfad (dir), Dateiname
(name) und Suffix (ext). Unter Linux gilt als Endung die Folge der Buchstaben, die hinter
dem letzten Punkt (».«) stehen. Bei DOS gibt es eine Ausnahme, wenn LFNSupport=False
ist, denn dann ist die Endung alles hinter dem ersten Punkt.
Siehe auch: FSearch.
program Example12; (* dosex/ex12.pp, Beispiel für die Funktion FSplit *)
uses
Dos;
var
dir : DirStr;
name: NameStr;
ext: ExtStr;
begin
FSplit(ParamStr(1), dir, name, ext);
WriteLn(’Gesplittet wird ’, ParamStr(1), ’ in’);

Kapitel 4.17 Unit DOS – GetCBreak O53
WriteLn(’Pfad : ’, dir);
WriteLn(’Name : ’, name);
WriteLn(’Endung: ’, ext);
end.
GETCBREAK
procedure GetCBreak(var breakvalue: Boolean);
GetCBreak ermittelt den Status der [Strg]-[Pause]-Prüfung unter DOS.
Wenn BreakValue False ist, wird nur während E/A-Operationen auf die Eingabe von
[Strg]-[Pause] getestet. Falls BreakValue True ist, findet eine solche Überprüfung bei
jedem Systemaufruf statt. Auf allen anderen Plattformen ergibt BreakValue immer den
Wert True.
Siehe auch: SetCBreak.
GETDATE
procedure GetDate(var year: Word; var month: Word; var mday: Word; var wday: Word);
GetDate liest das Systemdatum aus. Year ist eine Zahl im Bereich von 1980 bis 2099,
Month gibt die Zahl des Monats an, während mday den Tag im Monat beschreibt. Der
Wochentag des aktuellen Datums wird in wday zurückgegeben, wobei der Sonntag als
Tag 0, Montag als Tag 1 und so weiter zählen.
Siehe auch: GetTime und SetDate.
program Example2; (* dosex/ex2.pp, Beispiel für die Funktion GetDate *)
uses
Dos;
const
DayStr : array[0.. 6] of String[3] = (’Son’, ’Mon’, ’Die’,
’Mit’, ’Don’, ’Fre’, ’Sam’);
MonthStr: array[1..12] of String[3] = (’Jan’, ’Feb’, ’Mrz’, ’Apr’,
’Mai’, ’Jun’, ’Jul’, ’Aug’,
’Sep’, ’Okt’, ’Nov’, ’Dez’);
var
Year, Month, Day, WDay: Word;
begin
GetDate(Year, Month, Day, WDay);
WriteLn(’Aktuelles Datum’);
WriteLn(DayStr[WDay], ’, ’, Day, ’. ’, MonthStr[Month], ’ ’, Year, ’.’);
end.
GETENV
function GetEnv(envvar: String): String;
GetEnv liefert den Wert der Umgebungsvariablen EnvVar. Unter Linux muß EnvVar
unter Berücksichtigung der Klein- und Großschreibung angegeben werden. Wenn die
Umgebungsvariable EnvVar nicht definiert ist, wird ein leerer String zurückgegeben.
Bei einigen Betriebssystemen wie beispielsweise Unix muß die Groß- und Kleinschrei-
bung bei der Suche nach EnvVar beachtet werden.
Siehe auch: EnvCount und EnvStr.
program Example14; (* dosex/ex14.pp, Beispiel für die Funktion GetEnv *)
uses
Dos;
begin
WriteLn(’Der aktuelle PATH ist ’, GetEnv(’PATH’));
end.
GETFATTR
procedure GetFAttr(var f; var attr: Word);
GetFAttr ermittelt die Dateiattribute der Dateivariable F. Diese kann eine typisierte, unty-
pisierte oder Textdatei sein, die zugewiesen sein muß, aber nicht geöffnet sein darf. Die
Attribute können mit den folgenden Konstanten überprüft werden:
– ReadOnly = $01
– Hidden = $02
– SysFile = $04
– VolumeId = $08
– Directory = $10
– Archive = $20
Linux/Unix kennt die folgenden Attribute:
– Directory
– ReadOnly (falls der aktuelle Prozeß keinen Zugriff auf die Datei hat).
– Hidden (für Dateinamen, die mit einem Punkt beginnen).
Siehe auch: SetFAttr.
program Example8; (* dosex/ex8.pp, Beispiel für die Funktion GetFAttr *)
uses
Dos;
var
Attr: Word;
f : File;
begin
Assign(f, ParamStr(1));
GetFAttr(f, Attr);
WriteLn(’File ’, ParamStr(1), ’ besitzt die Attribute ’, Attr);
if (Attr and archive) <> 0 then WriteLn(’- Archive’);
if (Attr and directory) <> 0 then WriteLn(’- Directory’);
if (Attr and readonly) <> 0 then WriteLn(’- Read-Only’);
if (Attr and sysfile) <> 0 then WriteLn(’- System’);
if (Attr and hidden) <> 0 then WriteLn(’- Hidden’);
end.
GETFTIME
procedure GetFTime(var f; var time: LongInt);
GetFTime ermittelt die Uhrzeit der letzten Dateiänderung. Die Funktion UnPackTime
entschlüsselt die Zeit aus dem LongInt-Format. F muß eine Dateivariable sein, die zuge-
wiesen und geöffnet wurde.
Siehe auch: SetFTime, PackTime und UnPackTime.
program Example9; (* dosex/ex9.pp, Beispiel für die Funktion GetFTime *)
uses
Dos;
function L0(w: Word): String;

var
s: String;
begin
Str(w, s);
if w < 10 then L0 := ’0’ + s else L0 := s;
end;

Kapitel 4.17 Unit DOS – GetIntVec O55
var
f : File;
Time : LongInt;
DT : DateTime;
begin
if Paramcount > 0 then Assign(f, ParamStr(1)) else Assign(f, ’ex9.pp’);
Reset(f);
GetFTime(f, Time);
Close(f);
UnPackTime(Time, DT);
Write(’Die Datei ’, ParamStr(1), ’ wurde letztmalig geändert am ’);
Writeln(L0(DT.Month), ’.’, L0(DT.Day), ’.’, DT.Year,
’ um ’, L0(DT.Hour), ’:’, L0(DT.Min));
end.
GETINTVEC
procedure GetIntVec(intno: Byte; var vector: Pointer);
GetIntVec liefert die Adresse des Interruptvektors IntNo.
Dieser Aufruf macht gar nichts und ist nur aus Gründen der Abwärtskompatibilität vor-
handen, moderne Betriebssysteme erlauben diesen direkten Zugriff auf die Hardware nicht.
Siehe auch: SetIntVec.
GETLONGNAME
function GetLongName(var p: String): Boolean;
Diese Funktion ist nur in den Versionen für Go32v2 und Win32 von Free Pascal verfüg-
bar. GetLongName ändert den Dateinamen p in einen langen Dateinamen. Das Ergebnis
des API-Aufrufs ist der lange Dateiname des kurzen Dateinamens p. Die Funktion ergibt
True, wenn der Aufruf erfolgreich war. Die Funktion wird nur beim DOS-Extender unter
Windows 95 und höher benötigt.
Fehler: Kann der API-Aufruf nicht erfolgreich ausgeführt werden, meldet die Funktion
False zurück.
Siehe auch: GetShortName.
GETMSCOUNT
function GetMsCount: Int64;
GetMSCount liefert eine Zahl von Millisekunden seit einem bestimmten Zeitpunkt. Dieser
Zeitpunkt ist implementationsabhängig. Wird für Timingoperationen benötigt, die Sub-
traktion zweier aufeinanderfolgender Aufrufe ergibt die Zahl der Millisekunden zwischen
den beiden Aufrufen.
Diese Funktion ist nicht sehr genau, es werden stattdessen systemspezifische Aufrufe für
Timerabfragen empfohlen.
Siehe auch: GetTime.
GETSHORTNAME
function GetShortName(var p: String): Boolean;
Diese Funktion ist nur in den Versionen für GO32V2 und Win32 von Free Pascal enthalten.
GetShortName ändert die Dateinamensangabe in p über einen API-Aufruf in dessen 8+3-
Gegenstück. Ergebnis ist der kurze Dateiname zum langen Dateinamen in p.
Die Funktion gibt True zurück, wenn der API-Aufruf erfolgreich war.
Diese Funktion wird nur beim DOS-Extender unter Windows 95 und höher benötigt.
Fehler: Ist der API-Aufruf nicht erfolgreich, meldet die Funktion False zurück.
Siehe auch: GetLongName.
GETTIME
procedure GetTime(var hour: Word; var minute: Word; var second: Word; var sec100: Word);
GetTime liefert die Systemzeit. Hour wird im 24-Stunden-System angegeben. Die Minuten
werden in minute, die Sekunden in second und die Hundertstelsekunden in sec100 zu-
rückgegeben.
Hinweis: Bestimmte Betriebssysteme wie beispielsweise Amiga OS setzen das Feld sec100
immer auf Null.
Siehe auch: GetDate und SetTime.
program Example3; (* dosex/ex3.pp, Beispiel für die Funktion GetTime *)
uses Dos;
function L0(w: Word): String;

var
s: String;
begin
Str(w, s);
if w < 10 then L0 := ’0’ + s else L0 :=s;
end;
var
Hour, Min, Sec, HSec: Word;
begin
GetTime(Hour,Min,Sec,HSec);
WriteLn(’Die aktuelle Uhrzeit:’);
WriteLn(L0(Hour), ’:’, L0(Min), ’:’, L0(Sec));
end.
GETVERIFY
procedure GetVerify(var Verify: Boolean);
GetVerify liefert den Status des DOS-Flags Verify. Ist es True, überprüft DOS Daten, die
auf die Festplatte geschrieben werden, indem sie nach jedem Schreibzugriff unmittelbar
erneut gelesen und die Prüfsummen verglichen werden. Ist Verify False, werden die Daten
nicht überprüft.
Hinweis: Auf Nicht-DOS-Systemen (ausgenommen OS/2-Anwendungen unter reinem
DOS), ist Verify immer True.
Siehe auch: SetVerify.
INTR
procedure Intr(IntNo: Byte; var Regs: Registers);
Intr führt einen Softwareinterrupt mit der Nummer IntNo (zwischen 0 und 255) aus,
indem die Prozessorregister auf Regs gesetzt werden. Der Inhalt der Register vor Rück-
kehr der Interruptprozedur wird in Regs gespeichert.
Hinweise: Unten Nicht-DOS-System macht dieser Aufruf nichts.
Siehe auch: MsDos.
MSDOS
procedure MSDos(var Regs: Registers);
MSDos führt einen Betriebssystemaufruf aus. Die Prozedur entspricht einem Aufruf des
Intr-Befehls mit der Interruptnummer für den Betriebssystemaufruf.
Hinweis: Bei Nicht-DOS-Betriebssystemen macht dieser Aufruf gar nichts, unter DOS
wird der Interrupt 21h aufgerufen.
Siehe auch: Intr.
Kapitel 4.17 Unit DOS – PackTime O57
PACKTIME
procedure PackTime(var t: DateTime; var p: LongInt);
PackTime konvertiert das Datum und die Zeit, die in T gespeichert sind, in ein gepacktes
Format, das an die Datei SetFTime als Parameter übergeben werden kann.
Siehe auch: SetFTime, FindFirst, FindNext und UnPackTime.
program Example4; (* dosex/ex4.pp, Beispiel für die Funktionen PackTime und UnPackTime *)
uses
Dos;
var
DT : DateTime;
Time : LongInt;
begin
with DT do begin
Year := 2012;
Month := 11;
Day := 11;
Hour := 11;
Min := 11;
Sec := 11;
end;
PackTime(DT, Time);
WriteLn(’Gepackte Zeit: ’,Time);
UnPackTime(Time, DT);
WriteLn(’Wieder ausgepackt:’);
with DT do begin
WriteLn(’Jahr ’, Year);
WriteLn(’Monat ’, Month);
WriteLn(’Tag ’, Day);
WriteLn(’Stunde ’, Hour);
WriteLn(’Minute ’, Min);
WriteLn(’Sekunde ’, Sec);
end;
end.
SETCBREAK
procedure SetCBreak(BreakValue: Boolean);
SetCBreak setzt den Status der Überprüfung der Eingabe von [Strg]-[Pause]. Wenn
BreakValue False ist, wird nur bei E/A-Operationen der Zustand von [Strg]-[Pause] über-
prüft, ansonsten bei jedem Systembefehl.
Dieser Aufruf ist nur unter DOS verfügbar, bei anderen Betriebssystemen macht er nichts.
Siehe auch: GetCBreak.
SETDATE
procedure SetDate(year: Word; month: Word; day: Word);
SetDate legt das systeminterne Datum fest, wobei Year eine Zahl zwischen 1980 und 2099
ist. Auf Linux werden für diesen Aufruf Administrator-Rechte benötigt. Auf anderen
Unix-Systemen ist der Aufruf derzeit wirkungslos.
Siehe auch: GetDate und SetTime.
SETFATTR
procedure SetFAttr(var f; attr: Word);
SetFAttr setzt die Dateiattribute der Dateivariable F, die eine typisierte, untypisierte oder
Textdatei sein kann. F muß zugewiesen, darf aber nicht geöffnet sein. Die Attribute kön-
nen eine Summe der folgenden Konstanten sein:
– ReadOnly = 01h
– Hidden = 02h
– SysFile = 04h
– VolumeId = 08h
– Directory = 10h
– Archive = 20h
– AnyFile = 3fh
Bei unixartigen Dateisystemen wie Linux ist die Prozedur zwar implementiert, bewirkt
aber nichts.
Siehe auch: GetFAttr.
SETFTIME
procedure SetFTime(var f; Time: LongInt);
SetFTime stellt die Zeit der letzten Änderung der Datei f auf Time ein. Die Zeit muß im
gepackten Zeitformat von DOS vorliegen, das durch PackTime erzeugt werden kann. F
muß zugewiesen, aber darf nicht geöffnet sein. Bei unixartigen Dateisystemen wie Linux
ist die Prozedur zwar implementiert, macht aber nichts.
Siehe auch: GetFTime, PackTime und UnPackTime.
SETINTVEC
procedure SetIntVec(intno: Byte; vector: Pointer);
SetIntVec setzt den Interruptvektor IntNo auf die Interrupt-Prozedur, auf die Vector ver-
weist. Diese Prozedur ist zwar aus Gründen der Abwärtskompatibilität implementiert, sie
ist aber wirkungslos.
Siehe auch: GetIntVec.
SETTIME
procedure SetTime(hour: Word; minute: Word; second: Word; sec100: Word);
SetTime setzt die Zeit der internen Systemuhr. Der Parameter hour wird im 24-Stunden-
System ausgelesen. minute, second und sec100 enthalten die Minuten, Sekunden und
Hundertstel einer Sekunde der zu setzenden Zeitangaben.
Unter Linux benötigt dieser Aufruf root-Rechte, bei anderen unixartigen Betriebssyste-
men macht der Aufruf nichts.
Siehe auch: GetTime und SetDate.
SETVERIFY
procedure SetVerify(Verify: Boolean);
SetVerify setzt oder entfernt das DOS-Flag Verify. Wenn Verify True ist, prüft DOS Daten,
die auf die Festplatte geschrieben wurden, indem es sie wieder einliest und die Prüfsum-
men vergleicht. Falls Verify False ist, werden die geschriebenen Daten nicht überprüft.
Hinweis: Auf Nicht-DOS-Systemen (ausgenommen OS/2-Anwendungen unter reinem
DOS), ist Verify immer True.
Siehe auch: SetVerify.
SWAPVECTORS
procedure SwapVectors;
SwapVectors vertauscht den Inhalt der internen Interruptvektorentabelle mit dem aktuel-
len Inhalt der Interruptvektoren. Der Befehl sollte vor und nach einem Exec-Aufruf aus-
Kapitel 4.18 Unit Strings – StrAlloc O59
geführt werden, damit dem aufgerufenen Programm die standardmäßigen Interruptvek-
toren zur Verfügung stehen.
Hinweis: Bei diversen Betriebssystemen ist diese Prozedur nur als leerer Rumpf imple-
mentiert.
Siehe auch: Exec und SetIntVec.
STRA LLOC
UNIXDATETODT
procedure UnixDateToDt(SecsPast: LongInt; var Dt: DateTime);
DTToUnixDate konvertiert den Unix-Zeitstempel in SecsPast in eine gültige DateTime in
DT. Dies ist eine interne Funktion, die auf Unix-Plattformen implementiert ist und nicht
verwendet werden sollte.
Siehe auch: DTToUnixDate, PackTime, UnpackTime, GetTime und SetTime.
UNPACKTIME
procedure UnpackTime(p: LongInt;var t: DateTime);
UnPackTime konvertiert die Zeit der letzten Änderung einer Datei p in einen DateTime-
Datensatz. Die Zeit der letzten Dateiänderung finden die Funktionen GetFTime, FindFirst
und FindNext.
Ein Beispiel ist bei PackTime gezeigt
Siehe auch: GetFTime, FindFirst, FindNext und PackTime.
WEEKDAY
function Weekday(y: LongInt; m: LongInt; d: LongInt): LongInt;
WeekDay gibt die Nummer des Wochentags zurück, auf den das Datum d/m/y fällt.
Sonntag ergibt dabei den Wert 0 und Samstag den Wert 6.
Fehler: Bei einem Fehler wird der Wert -1 zurückgegeben.
Siehe auch: PackTime, UnpackTime, GetTime und SetTime.
4.18 Unit Strings

Die Unit Strings von Free Pascal ist systemunabhängig und funktioniert auf allen unter-
stützten Plattformen. Alle Funktionen dieser Unit sind in erweiterten Varianten auch in
der Unit SysUtils verfügbar, wobei die Syntax der Funktionen dann immer gleich ist. Das
zeigt sich auch in den Beispielen, bei denen nur der Import anders lautet.
Die Routinen in dieser Unit kennen weder AnsiStrings noch WideStrings und auch keine
nationalen Sonderzeichen. Alle Strings sind klassische Pascal-ShortStrings mit einer Län-
ge von maximal 255 Zeichen. Für AnsiStrings und WideStrings muß auf die entsprechen-
den Routinen der Unit SysUtils gewechselt werden. In dieser Unit sind bei Längenanga-
ben Definitionen des Datentyps SizeInt implementiert. Dieser Datentyp, der in der Unit
System definiert ist, ist auf 32-Bit-Systemen ein Synonym für LongInt, auf 64-Bit-Syste-
men für Int64. Bei Strings sollte immer mit SizeInt gearbeitet werden.
STRALLOC
function StrAlloc(L: SizeInt): PChar;
StrAlloc reserviert Speicher für den String mit der Länge Len auf dem Heap, das abschlie-
ßende ASCII-#0 ist in dieser Längenangabe enthalten. Dann wird ein Zeiger auf den Spei-
cherplatz zurückgegeben.
Fehler: Ist nicht genug Speicher für die Operation auf dem Heap vorhanden, wird ein
Laufzeitfehler ausgelöst.
Hinweis: Strings.StrAlloc und SysUtils.StrAlloc (siehe dort) sind nicht kompatibel.
Siehe auch: StrNew, StrPCopy und SysUtils.StrAlloc.
STRCAT
function StrCat(dest: PChar; source: PChar): PChar;
Hängt Source an Dest und gibt Dest zurück.
Fehler: Keine (es findet keine Längenüberprüfung statt).
Siehe auch: StrLCat und SysUtils.StrCat.
program Example11; (* stringex/ex11.pp, Beispiel für die Funktion StrCat *)
uses
Strings;
const
P1: PChar = ’Das ist ein PChar-String.’;
var
P2: PChar;
begin
P2 := StrAlloc(StrLen(P1) * 2 + 1);
StrMove(P2, P1, StrLen(P1) + 1); (* P2 = P1 *)
StrCat(P2, P1); (* P2 noch einmal anhängen *)
WriteLn(’P2: ’, P2);
StrDispose(P2);
end.
STRCOMP
function StrComp(Str1: PChar; Str2: PChar): SizeInt;
Vergleicht die beiden nullterminierten Strings Str1 und Str2. Das Ergebnis ist
– ein negativer SizeInt, wenn Str1 kleiner als Str2 ist.
– 0, wenn Str1 und Str2 identisch sind.
– Ein positiver SizeInt, wenn Str1 größer als Str2 ist.
Ein Beispiel ist bei der Funktion StrLComp gezeigt.
Siehe auch: StrLComp, StrIComp und StrLIComp.
STRCOPY
function StrCopy(Dest: PChar; Source: PChar): PChar;
Kopiert den nullterminierten String in Source nach Dest und gibt einen Zeiger auf Dest
zurück. Dest muß genug freien Speicher reserviert haben, um Source aufnehmen zu kön-
nen, mindestens aber StrLen(Source) + 1 Byte.
Fehler: Es wird keine Längenüberprüfung durchgeführt.
Siehe auch: StrPCopy, StrLCopy, StrECopy und SysUtils.StrCopy.
program Example4; (* stringex/ex4.pp, Beispiel für die Funktion StrCopy *)
uses
Strings;
const
P: PChar = ’Das ist ein PChar-String.’;
var
PP: PChar;
begin
PP: = StrAlloc(StrLen(P) + 1);
StrCopy(PP, P);
if StrComp(PP, P) <> 0 then WriteLn(’Oh-oh, Probleme ...’)
else WriteLn(’Alles funktioniert: PP=’, PP);
StrDispose(PP);
end.

Kapitel 4.18 Unit Strings – StrDispose O61
STRDISPOSE
procedure StrDispose(P: PChar);
Entfernt den String, auf den P zeigt, vom Heap und gibt den Speicher wieder frei.
Siehe auch: StrNew und SysUtils.StrDispose.
program Example17; (* stringex/ex17.pp, Beispiel für die Funktion StrDispose *)
uses
Strings;
const
var
P2: PChar;
begin
P2 := StrNew(P1);
WriteLn(’P2: ’, P2);
StrDispose(P2);
end.
STRECOPY
function StrECopy(Dest: PChar; Source: PChar): PChar;
Kopiert den nullterminierten String in Source nach Dest und gibt einen Zeiger auf das
Stringende (also das terminierende ASCII #0) des kopierten Strings zurück.
Fehler: Es wird keine Längenüberprüfung durchgeführt.
Siehe auch: StrLCopy, StrCopy und SysUtils.StrECopy.
program Example6; (* stringex/ex6.pp, Beispiel für die Funktion StrECopy *)
uses
Strings;
const
var
PP: PChar;
begin
PP := StrAlloc(StrLen(P) + 1);
if SizeInt(StrECopy(PP, P)) - SizeInt(PP) <> StrLen(P) then
WriteLn(’Hier ist was falsch!’)
else
WriteLn(’PP= ’, PP);
StrDispose(PP);
end.
STREND
function StrEnd(p: PChar): PChar;
Liefert einen Zeiger auf das Ende von p, also auf das terminierende ASCII-#0-Zeichen.
Siehe auch: StrLen und SysUtils.StrEnd.
program Example6; (* stringex/ex7.pp, Beispiel für die Funktion StrEnd *)
uses
Strings;
const
P: PChar = ’Das ist ein PChar-String’;
begin
if SizeInt(StrEnd(P)) - SizeInt(P) <> StrLen(P) then
WriteLn(’Da ist was falsch!’)
else
WriteLn(’Alles in Ordnung.’);
end.
STRICOMP
function StrIComp(Str1: PChar; Str2: PChar): SizeInt;
Vergleicht die beiden nullterminierten Strings Str1 und Str2 und ignoriert dabei die
Groß- und Kleinschreibung. Das Ergebnis ist
– ein negativer SizeInt, wenn Str1 kleiner als Str2 ist.
– 0, wenn die beiden Zeichenketten gleich sind.
– Ein positiver SizeInt, wenn Str1 größer als Str2 ist.
Siehe auch: StrLComp, StrComp, StrLIComp und SysUtils.StrIComp.
program Example8; (* stringex/ex8.pp, Beispiel für die Funktion StrlComp *)
uses
Strings;
const
P1: PChar = ’Das ist der erste String.’;
P2: PChar = ’Das ist der zweite String.’;
var
L: SizeInt;
begin
Write(’P1 und P2 sind ’);
if StrComp(P1, P2) <> 0 then Write(’NICHT ’);
Write(’gleich. Der erste ’);
L := 1;
while StrLComp(P1, P2, L) = 0 do
Inc(L);
Dec(l);
WriteLn(l, ’ Zeichen sind gleich’);
end.
STRLCAT
function StrLCat(Dest: PChar; Source: PChar; l: SizeInt): PChar;
Fügt L Zeichen an von Source an Dest an und dann das abschließende ASCII-#0-Zeichen.
Die Funktion gibt Dest zurück.
Siehe auch: StrCat und SysUtils. StrLCat.
program Example12; (* stringex/ex12.pp, Beispiel für die Funktion StrLCat *)
uses
Strings;
const
P1: PChar = ’1234567890’;
var
P2: PChar;
begin
P2: = StrAlloc(StrLen(P1) * 2 + 1);
P2^ := #0; // Länge Null
StrCat(P2, P1);
StrLCat(P2, P1, 5);
WriteLn(’P2 = ’, P2);
StrDispose(P2);
end.
STRLCOMP
function StrLComp(Str1: PChar; Str2: PChar; L: SizeInt): SizeInt;
Vergleicht maximal L Zeichen der beiden nullterminierten Strings Str1 und Str2.
Das Ergebnis ist ein negativer SizeInt, wenn Str1 < Str2, 0, wenn Str1 = Str2 und ein posi-
tiver SizeInt, wenn Str1 > Str2.
Siehe auch: StrComp, StrIComp, StrLIComp und SysUtils.StrLComp.
Kapitel 4.18 Unit Strings – StrLCopy O63
program Example8; (* stringex/ex8.pp, Beispiel für die Funktion StrLComp *)
uses
Strings;
const
P1: PChar = ’Das ist der erste String.’;
P2: PChar = ’Das ist der zweite String.’;
var
L: SizeInt;
begin
Write(’P1 und P2 sind ’);
if StrComp(P1, P2) <> 0 then Write(’NICHT’);
Write(’ gleich. Die ersten ’);
L := 1;
while StrLComp(P1, P2, L) = 0 do Inc(L);
Dec(L);
WriteLn(l, ’ Zeichen sind identisch.’);
end.
STRLCOPY
function StrLCopy(Dest: PChar; Source: PChar; MaxLen: SizeInt): PChar;
Kopiert MaxLen Zeichen von Source nach Dest und macht aus Dest einen nullterminier-
ten String.
Fehler: Keine (es findet keine Längenüberprüfung statt).
Siehe auch: StrCopy, StrECopy und SysUtils.StrLCopy.
program Example5; (* stringex/ex5.pp, Beispiel für die Funktion StrLCopy *)
uses
Strings;
const
P: PChar = ’123456789ABCDEF’;
var
PP: PChar;
begin
PP := StrAlloc(11);
WriteLn(’Die ersten 10 Zeichen von P: ’, StrLCopy(PP, P, 10));
StrDispose(PP);
end.
STRLEN
function StrLen(p: PChar): SizeInt;
Liefert die Länge des nullterminierten Strings p.
Siehe auch: StrNew und SysUtils.StrLen.
program Example1; (* stringex/ex1.pp, Beispiel für die Funktion StrLen *)
uses
Strings;
const
P: PChar = ’Das ist ein PChar-Stringkonstante’;
begin
WriteLn(’P: ’, p);
WriteLn(’Länge(P): ’, StrLen(P));
end.
STRLICOMP
function StrLIComp(Str1: PChar; Str2: PChar; L: SizeInt): SizeInt;
Vergleicht maximal L Zeichen der nullterminierten Strings Str1 und Str2 und ignoriert
dabei die Groß- und Kleinschreibung.
Das Ergebnis ist
– eine negative SizeInt-Zahl, wenn Str1 < Str2.
– 0, wenn Str1 und Str2 gleich sind.
– Ein positiver SizeInt, wenn Str1 > Str2.
– Ein Beispiel ist bei der Funktion StrIComp gezeigt.
Siehe auch: StrLComp, StrComp, StrIComp und SysUtils.StrLIComp.
STRLOWER
function StrLower(p: PChar): PChar;
Konvertiert p in Kleinbuchstaben. Das Funktionsergebnis ist p.
Siehe auch: StrUpper und SysUtils.StrLower.
program Example14; (* stringex/ex14.pp, Beispiel für StrLower und StrUpper *)
uses
Strings; { oder: SysUtils }
const
P1: PChar = ’DAS IST EIN PCHAR-STRING IN GROSSBUCHSTABEN.’;
P2: PChar = ’das ist ein pchar-string in kleinbuchstaben’;
begin
WriteLn(’Großschreibung: ’, StrUpper(P2));
StrLower(P1);
WriteLn(’Kleinschreibung: ’, P1);
end.
STRMOVE
function StrMove(Dest: PChar; Source: PChar; L: SizeInt): PChar;
Kopiert L Zeichen von Source nach Dest. Dabei wird kein terminierendes Nullzeichen
übertragen. Die Funktion gibt Dest zurück.
Siehe auch: StrLCopy, StrCopy und SysUtils.StrMove.
program Example10; (* stringex/ex10.pp, Beispiel für die Funktion StrMove *)
uses
Strings;
const
P1: PChar = ’Das ist ein PChar-String.’;
var
P2: PChar;
begin
P2 := StrAlloc(StrLen(P1) + 1);
StrMove(P2, P1, StrLen(P1) + 1); // P2 := P1
WriteLn(’ P2 = ’, P2);
StrDispose(P2);
end.
STRNEW
function StrNew(p: PChar): PChar;
Kopiert p auf den Heap und gibt einen Zeiger auf die Kopie zurück.
Fehler: Die Funktion gibt NIL zurück, wenn nicht genug Speicher für die Kopie verfügbar
ist.
Siehe auch: StrCopy, StrDispose und SysUtils.StrNew.
program Example16; (* stringex/ex16.pp, Beispiel für die Funktion StrNew *)
uses
Strings;
const
P1: PChar = ’ Das ist ein PChar-String’;

Kapitel 4.18 Unit Strings – StrPas O65
var
P2: PChar;
begin
P2 := StrNew(P1);
if P1 = P2 then WriteLn(’Das kann nicht passieren ...’) else WriteLn(’P2: ’, P2);
StrDispose(P2);
end.
STRPAS
function StrPas(p: PChar): ShortString;
Konvertiert den nullterminierten String p in einen Pascal-String um und gibt ihn als
Funktionsergebnis zurück. Der Ergebnisstring wird bei einer Länge von 255 Zeichen
abgeschnitten.
Siehe auch: StrPCopy und SysUtils.StrPas.
program Example3; (* stringex/ex3.pp, Beispiel für die Funktion StrPas *)
uses
Strings;
const
P: PChar = ’Das ist ein PChar-String’;
var
S: String;
begin
S := StrPas(P);
WriteLn(’S: ’, S);
end.
STRPCOPY
function StrPCopy(d: PChar; const s: String): PChar;
Konvertiert den Pascal-String in s in einen nullterminierten String und kopiert ihn nach
d. d muß groß genug sein, um den String aufnehmen zu können, das heißt, eine Größe
von Length(s) + 1 besitzen.
Fehler: Es wird keine Längenprüfung durchgeführt.
Siehe auch: StrPas und SysUtils.StrPCopy.
program Example2; (* stringex/ex2.pp, Beispiel für die Funktion StrPCopy *)
uses
Strings;
const
S = ’das ist ein normaler String.’;
var
P: PChar;
begin
P := StrAlloc(Length(S) + 1);
if StrPCopy (P, S) <> P then WriteLn(’Das ist unmöglich!!’) else WriteLn(P);
StrDispose(P);
end.
STRPOS
function StrPos(Str1: PChar; Str2: PChar): PChar;
Gibt einen Zeiger auf das erste Vorkommen von Str2 in Str1 zurück. Enthält Str1 den
gesuchten Teilstring nicht, wird NIL zurückgegeben.
Siehe auch: StrScan, StrRScan und SysUtils.StrPos.
program Example15; (* stringex/ex15.pp, Beispiel für die Funktion StrPos *)
uses
Strings; (* oder: SysUtils! *)
const
S: PChar = ’ist’;
begin
WriteLn(’Position von ”ist” in P: ’, SizeInt(StrPos(P, S)) - SizeInt(P));
end.
STRRSCAN
function StrRScan(p: PChar; c: Char): PChar;
Gibt einen Zeiger auf das letzte Vorkommen des Zeichens c im nullterminierten String p
zurück. Wird c nicht gefunden, liefert die Funktion den Wert NIL.
Ein Beispiel befindet sich bei der Funktion StrScan.
Siehe auch: StrScan, StrPos und SysUtils.StrRScan.
STRSCAN
function StrScan(p: PChar; c: Char): PChar;
Gibt einen Zeiger auf das erste Vorkommen des Zeichens c im nullterminierten String p
zurück. Falls c nicht gefunden wird, liefert die Funktion den Wert NIL.
Siehe auch: StrRScan, StrPos und SysUtils.StrScan.
program Example13; { stringex/ex13.pp, Beispiel für die Funktionen StrScan und StrRScan }
uses
Strings;
const
s: Char = ’s’;
begin
Writeln(’P ab dem ersten ”s”: ’, StrScan(P, s));
Writeln(’P ab dem letzten ”s”: ’, StrRScan(P, s));
end.
STRUPPER
function StrUpper(p: PChar): PChar;
Konvertiert p in Großbuchstaben. Die Funktion gibt p zurück.
Ein Beispiel ist bei der Funktion StrLower gezeigt.
Siehe auch: StrLower und SysUtils.StrUpper.
4.19 Unit Sockets

Die Unit Sockets ruft folgende Units auf:
– baseunix
– UnixType
Konstanten
Die folgenden Konstanten bestimmen die Socket-Domain, sie stehen im Aufruf von Socket:
Konstante Wert Adreßfamilie
AF_UNSPEC 0 Nicht angegeben.
AF_LOCAL 1 Unix-Sockets.
AF_UNIX 1 Unix-Domain-Sockets.
AF_INET 2 Internet-IP-Protokoll.
AF_AX25 3 Amateur-Radio AX.25.

Kapitel 4.19 Unit Sockets – Konstanten, Typen, Variablen O67
Konstante Wert Adreßfamilie
AF_IPX 4 Novell IPX.
AF_APPLETALK 5 Appletalk DDP.
AF_NETROM 6 Amateur-Radio NetROM.
AF_BRIDGE 7 Multiprotocol Bridge.
AF_ATMPVC 8 ATM-PVCs.
AF_X25 9 Reserviert für das X.25-Projekt.
AF_INET6 10 IP Version 6.
AF_ROSE 11 Amateur-Radio X.25 PLP.
AF_DECnet 12 Reserviert für das DECnet-Project.
AF_NETBEUI 13 Reserviert für das 802.2LLC-Project.
AF_SECURITY 14 Sicherheits-Callback Pseudo AF.
AF_KEY 15 PF_KEY Key Management API.
AF_NETLINK 16 ?
AF_ROUTE AF_NETLINK Alias zum Emulieren von 4.4BSD.
AF_PACKET 17 Packet-Familie.
AF_ASH 18 Ash.
AF_ECONET 19 Acorn Econet.
AF_ATMSVC 20 ATM SVCs.
AF_SNA 22 Linux SNA-Projekt.
AF_IRDA 23 IRDA-Sockets.
AF_PPPOX 24 PPPoX-Sockets.
AF_WANPIPE 25 Wanpipe-API-Sockets.
AF_LLC 26 Linux LLC.
AF_TIPC 30 TIPC-Sockets.
AF_BLUETOOTH 31 Bluetooth-Sockets.
AF_MAX 32 Maximalwert.
Die Unit definiert die folgenden Fehlerkonstanten (sind alles Alias-Angaben):
Fehlercode Wert Bedeutung

EsockEACCESS ESysEAcces Zugriff verboten.
EsockEBADF EsysEBADF Alias: Ungültiger Dateideskriptor.
EsockEFAULT EsysEFAULT Alias: Es ist ein Fehler aufgetreten.
EsockEINTR EsysEINTR Alias: Operation abgebrochen.
EsockEINVAL EsysEINVAL Alias: Ungültiger Wert angegeben.
EsockEMFILE ESysEmfile Fehlercode?
EsockEMSGSIZE ESysEMsgSize Fehlerhafte Meldungsgröße.
EsockENOBUFS ESysENoBufs Kein Pufferspeicher verfügbar.
EsockENOTCONN ESysENotConn Nicht verbunden.
EsockENOTSOCK ESysENotSock Dateideskriptor ist kein Socket.
EsockEPROTONOSUPPORT ESysEProtoNoSupport Protokoll wird nicht unterstützt.
EsockEWOULDBLOCK ESysEWouldBlock Operation würde blockieren.
Die folgenden Konstanten sind spezielle IP-Adressen, die häufig benötigt werden, wenn
ein Socket an eine Schnittstelle auf der lokalen Maschine gebunden werden soll:

INADDR_ANY = Cardinal(0) Undokumentiert?
INADDR_NONE = Cardinal($FFFFFFFF) Undokumentiert?
Die folgenden Konstanten definieren die Protokolle:

IPPROTO_HOPOPTS 0 IPv6 Hop-by-Hop-Optionen.
IPPROTO_IP 0 Dummy-Protokoll für TCP.
IPPROTO_ICMP 1 Internet Control Message Protocol.
IPPROTO_IGMP 2 Internet Group Management Protocol.
IPPROTO_IPIP 4 IPIP-Tunnel (ältere KA9Q-Tunnel verwenden 94).
IPPROTO_TCP 6 Transmission Control Protocol.
IPPROTO_EGP 8 Exterior Gateway Protocol.
IPPROTO_PUP 12 PUP-Protokoll.
IPPROTO_UDP 17 User Datagram Protocol.
IPPROTO_IDP 22 XNS IDP Protokoll.
IPPROTO_TP 29 SO Transport Protocol Class 4.
IPPROTO_IPV6 41 IPv6-Header.
IPPROTO_ROUTING 43 IPv6-Routing-Header.
IPPROTO_FRAGMENT 44 IPv6 Fragmentation Header.
IPPROTO_RSVP 46 Reservation Protocol.
IPPROTO_GRE 47 General Routing Encapsulation.
IPPROTO_ESP 50 Encapsulating Security Payload.
IPPROTO_AH 51 Authentifizierungs-Header.
IPPROTO_ICMPV6 58 ICMPv6.
IPPROTO_NONE 59 IPv6, kein nächster Header.
IPPROTO_DSTOPTS 60 IPv6-Zieloptionen.
IPPROTO_MTP 92 Multicast Transport Protocol.
IPPROTO_ENCAP 98 Encapsulation Header.
IPPROTO_PIM 103 Protocol Independent Multicast.
IPPROTO_COMP 108 Compression Header Protocol.
IPPROTO_SCTP 132 Stream Control Transmission Protocol.
IPPROTO_MAX 255 Maximalwert für IPPROTO-Optionen.
IPPROTO_RAW 255 Rohe IP-Pakete.
Die folgenden Konstanten sind größtenteils undokumentierte Optionen für GetSockOpt

und SetSockOpt. Alle vom Autor irgendwo als dokumentiert gefundenen Werte sind hier
dokumentiert. Wer nach ihnen googelt, landet unweigerlich wieder in der Dokumentati-
on von Free Pascal:

IPV6_ADDRFORM 1 Siehe http://linux.die.net/man/7/ipv6
IPV6_ADD_MEMBERSHIP IPV6_JOIN_GROUP Siehe http://linux.die.net/man/7/ipv6
IPV6_AUTHHDR 10 Siehe http://linux.die.net/man/7/ipv6
IPV6_CHECKSUM 7 Undokumentierte Getsockopt-Option?
IPV6_DROP_MEMBERSHIP IPV6_LEAVE_GROUP Siehe http://linux.die.net/man/7/ipv6
IPV6_DSTOPTS 4 Siehe http://linux.die.net/man/7/ipv6
IPV6_HOPLIMIT 8 Siehe http://linux.die.net/man/7/ipv6
IPV6_HOPOPTS 3 Undokumentierte Getsockopt-Option?
IPV6_IPSEC_POLICY 34 Undokumentierte Getsockopt-Option?
IPV6_JOIN_ANYCAST 27 Undokumentierte Getsockopt-Option?
IPV6_JOIN_GROUP 20 Undokumentierte Getsockopt-Option?
IPV6_LEAVE_ANYCAST 28 Undokumentierte Getsockopt-Option?
IPV6_LEAVE_GROUP 21 Undokumentierte Getsockopt-Option?
IPV6_MTU 24 Siehe http://linux.die.net/man/7/ipv6
IPV6_MTU_DISCOVER 23 Siehe http://linux.die.net/man/7/ipv6
IPV6_MULTICAST_HOPS 18 Siehe http://linux.die.net/man/7/ipv6
IPV6_MULTICAST_IF 17 Siehe http://linux.die.net/man/7/ipv6
IPV6_MULTICAST_LOOP 19 Siehe http://linux.die.net/man/7/ipv6
IPV6_NEXTHOP 9 Undokumentierte Getsockopt-Option?
IPV6_PKTINFO 2 Siehe http://linux.die.net/man/7/ipv6
IPV6_PKTOPTIONS 6 Undokumentierte Getsockopt-Option?
IPV6_PMTUDISC_DO 2 Immer DF.
IPV6_PMTUDISC_DONT 0 Nie DF-Frames senden
IPV6_PMTUDISC_WANT 1 Use per route hints.
IPV6_RECVERR 25 Siehe http://linux.die.net/man/7/ipv6
IPV6_ROUTER_ALERT 22 Siehe http://linux.die.net/man/7/ipv6
IPV6_RTHDR 5 Siehe http://linux.die.net/man/7/ipv6
IPV6_RTHDR_LOOSE 0 Hop muß kein Nachbar sein.
IPV6_RTHDR_STRICT 1 Hop muß ein Nachbar sein.
IPV6_RTHDR_TYPE_0 0 IPv6-Routing-Header Typ 0.
IPV6_RXDSTOPTS IPV6_DSTOPTS Undokumentierte Getsockopt-Option?
IPV6_RXHOPOPTS IPV6_HOPOPTS Undokumentierte Getsockopt-Option?
IPV6_RXSRCRT IPV6_RTHDR Undokumentierte Getsockopt-Option?
IPV6_UNICAST_HOPS 16 Siehe http://linux.die.net/man/7/ipv6
IPV6_V6ONLY 26 Undokumentierte Getsockopt-Option?
IPV6_XFRM_POLICY 35 Undokumentierte Getsockopt-Option?
Für die folgende Liste von Konstanten gilt das selbe wie für die letzte Tabelle:

IP_ADD_MEMBERSHIP 35 IP-Gruppen-Mitgliedschaft hinzufügen.
IP_ADD_SOURCE_MEMBERSHIP 39 Der Quellgruppe beitreten.
IP_BLOCK_SOURCE 38 Daten von der Quelle blockieren.
IP_DEFAULT_MULTICAST_LOOP 1 Undokumentiert?
IP_DEFAULT_MULTICAST_TTL 1 Undokumentiert?
IP_DROP_MEMBERSHIP 36 IP-Gruppen-Mitgliedschaft verwerfen.
IP_DROP_SOURCE_MEMBERSHIP 40 Quellgruppe verlassen.
IP_HDRINCL 3 Header ist mit Daten enthalten.
IP_MAX_MEMBERSHIPS 20 Undokumentiert?
IP_MSFILTER 41 Undokumentiert?
IP_MTU_DISCOVER 10 Undokumentiert?
IP_MULTICAST_IF 32 set/get IP-Multicast-i/f.
IP_MULTICAST_LOOP 34 set/get IP-Multicast-Loopback.
IP_MULTICAST_TTL 33 set/get IP-Multicast-TTL.
IP_OPTIONS 4 IP-pro-Paket.
IP_PKTINFO 8 Undokumentiert?
IP_PKTOPTIONS 9 Undokumentiert?
IP_PMTUDISC 10 Undokumentiert?
IP_PMTUDISC_DO 2 Immer DF.
IP_PMTUDISC_DONT 0 Nie DF-Frames senden.
IP_PMTUDISC_WANT 1 Use per route hints.
IP_RECVERR 11 Undokumentiert?
IP_RECVOPTS 6 Alle IP-Optionen mit Datagram empfangen.
IP_RECVRETOPTS IP_RETOPTS IP-Optionen für Antwort empfangen.
IP_RECVTOS 13 Undokumentiert?
IP_RECVTTL 12 Undokumentiert?
IP_RETOPTS 7 Set/get-Optionen für IP pro Packet.
IP_ROUTER_ALERT 5 Undokumentiert?
IP_TOS 1 Type of Service und Precedence.
IP_TTL 2 TTL der IP (time to live).
IP_UNBLOCK_SOURCE 37 Daten von Quelle entblockieren.
Die folgenden Konstanten sind Multicast-Gruppenoptionen:

MCAST_EXCLUDE 0 Undokumentiert?
MCAST_INCLUDE 1 Undokumentiert?
MCAST_JOIN_GROUP 42 Quellgruppe beitreten.
MCAST_BLOCK_SOURCE 43 Block from given group
MCAST_UNBLOCK_SOURCE 44 Unblock from given group
MCAST_LEAVE_GROUP 45 Quellgruppe verlassen.
MCAST_JOIN_SOURCE_GROUP 46 Join source-spec group.
MCAST_LEAVE_SOURCE_GROUP 47 Leave source-spec group.
MCAST_MSFILTER 48 Undokumentiert?

Die folgenden Konstanten sind Optionen für das Senden und Empfangen von Messages
mit Datagrammen:

MSG_CONFIRM $0800 Send flags: Confirm connection.
MSG_CTRUNC $0008 Receive flags: Control Data was discarded
(buffer too small).
MSG_DONTROUTE $0004 Send flags: don't use gateway.
MSG_DONTWAIT $0040 Receive flags: Non-blocking operation request.
MSG_EOF MSG_FIN Alias for MSG_FIN.
MSG_EOR $0080 Receive flags: End of record.
MSG_ERRQUERE $2000 Receive flags: ?
MSG_FIN $0200 Receive flags: ?
MSG_MORE $8000 Receive flags: ?
MSG_NOSIGNAL $4000 Receive flags: Suppress SIG_PIPE signal.
MSG_OOB $0001 Receive flags: receive out-of-band data.
MSG_PEEK $0002 Receive flags: peek at data, don't remove from
buffer.
MSG_PROXY $0010 Receive flags: ?
MSG_RST $1000 Receive flags: ?
MSG_SYN $0400 Receive flags: ?
MSG_TRUNC $0020 Receive flags: packet Data was discarded
(buffer too small).
MSG_TRYHARD MSG_DONT- Receive flags: ?
ROUTE
MSG_WAITALL $0100 Receive flags: Wait until operation completed.
Die folgenden typisierten Konstanten stellen besondere Internet-Adressen dar:
Konstante/Datentyp/Vorbelegung Beschreibung
NoAddress: in_addr = ( s_addr:0 ); Konstante, die eine ungültige (keine) Netzwerk-
adresse mitteilt.
NoAddress6: in6_addr = ( Konstante, die eine ungültige (keine) IPv6-
u6_addr16: ( 0, 0, 0, 0, 0, 0, 0, 0 ) Netzwerkadresse mitteilt.
);
NoNet: in_addr = (s_addr:0 ); Konstante, die eine ungültige (keine) Netzwerk-
adresse mitteilt.
NoNet6: in6_addr = ( u6_addr16: Konstante, die eine ungültige (keine) IPv6-
( 0, 0, 0, 0, 0, 0, 0, 0 ) Netzwerkadresse mitteilt.
);
Die folgenden Konstanten legen die Protokollfamilie fest. Sie werden im Aufruf von der
Prozedur Socket benötigt:
Konstante Wert Protokollfamilie

PF_APPLETALK AF_APPLETALK Appletalk DDP
PF_ASH AF_ASH Ash
PF_ATMPVC AF_ATMPVC ATM PVCs
PF_ATMSVC AF_ATMSVC ATM SVCs
PF_AX25 AF_AX25 Amateur Radio AX.25
PF_BLUETOOTH AF_BLUETOOTH Bluetooth Sockets
PF_BRIDGE AF_BRIDGE Multiprotocol Bridge
PF_DECnet AF_DECnet DECNET-Projekt
PF_ECONET AF_ECONET Acorn Econet
PF_INET AF_INET Internet IP-Protokoll
PF_INET6 AF_INET6 IP Version 6
PF_IPX AF_IPX Novell IPX
PF_IRDA AF_IRDA IRDA sockets
PF_KEY AF_KEY Key Management API
PF_LLC AF_LLC Linux LLC
PF_LOCAL AF_LOCAL Unix socket
PF_MAX AF_MAX Maximalwert
PF_NETBEUI AF_NETBEUI Reserviert für das 802.2LLC-Projekt
PF_NETLINK AF_NETLINK ?
PF_NETROM AF_NETROM Amateur-Radio NetROM
PF_PACKET AF_PACKET Packet-Familie
PF_PPPOX AF_PPPOX PPPoX-Sockets
PF_ROSE AF_ROSE Amateur-Radio X.25 PLP
PF_ROUTE AF_ROUTE ?
PF_SECURITY AF_SECURITY Sicherheitscallback Pseudo-PF
PF_SNA AF_SNA Linux SNA-Projekt
PF_TIPC AF_TIPC TIPC-Sockets
PF_UNIX AF_UNIX Unix Domain Sockets
PF_UNSPEC AF_UNSPEC Unspezifiziert
PF_WANPIPE AF_WANPIPE Wanpipe API-Sockets
PF_X25 AF_X25 Reserviert für das X.25-Projekt
Die folgenden Konstanten sind Optionen für das Datagram SendMsg:

SCM_SRCRT IPV6_RXSRCRT Undokumentierte Getsockopt-Option?
SCM_TIMESTAMP SO_TIMESTAMP Socket-Option: ?
Die folgenden Konstanten steuern das Herunterfahren von Sockets:

SHUT_RD 0 Leseanteil des Voll-Duplex-Sockets herunterfahren.
SHUT_WR 1 Schreibanteil des Voll-Duplex-Sockets herunterfahren.
SHUT_RDWR 2 Lese- und Schreibanteil des Voll-Duplex-Sockets herunterfahren.

Die folgenden Konstanten identifizieren verschiedene Socket-Typen, wie sie für die Rou-
tine Socket benötigt werden:

SOCK_STREAM 1 Socket-Typ: Stream (Verbindungs-) Sockettyp(TCP).
SOCK_DGRAM 2 Socket-Typ: Datagram (verbindungsloser) Socket (UDP).
SOCK_RAW 3 Socket-Typ: Roh-Socket.
SOCK_RDM 4 Socket-Typ: Nachricht wurde tatsächlich ausgeliefert.
SOCK_SEQPACKET 5 Socket-Typ: Sequentieller Packet-Socket.
SOCK_MAXADDRLEN 255 Maximale Socketadreßlänge für den Aufruf von Bind.
Die folgenden Konstanten sind Werte für die Socket-Optionen:

SOL_IP 0 Undokumentiert?
SOL_SOCKET 1 Socketoptionsebene: Socketebene.
SOL_IPV6 41 Socketebenen-Werte für IPv6: IPV6.
SOL_ICMPV6 58 Socketebenen-Werte für IPv6: ICMPV6.
Die folgende Konstante beschreibt ein System-Limit:

SOMAXCONN 128 Maximum queue length specifiable by listen.
Die folgenden Konstanten beschreiben Socket-Optionen:

S_IN 0 Eingabesocket im Socket-Paar.
S_OUT 1 Ausgabesocket im Socket-Paar.
SO_DEBUG 1 Socketoptionenebene: Debug.
SO_REUSEADDR 2 Socket-Option: Adresse wiederverwenden.
SO_TYPE 3 Socket-Option: Typ.
SO_ERROR 4 Socket-Option: Fehler.
SO_DONTROUTE 5 Socket-Option: Nicht routen.
SO_BROADCAST 6 Socket-Option: Broadcast.
SO_SNDBUF 7 Socket-Option: Puffer senden.
SO_RCVBUF 8 Socket-Option: Puffer empfangen.
SO_KEEPALIVE 9 Socket-Option: Keep-Alive.
SO_OOBINLINE 10 Socket-Option: ?
SO_NO_CHECK 11 Socket-Option: ?
SO_PRIORITY 12 Socket-Option: ?
SO_LINGER 13 Socket-Option: ?
SO_BSDCOMPAT 14 Socket-Option: ?
SO_PASSCRED 16 Socket-Option: ?
SO_PEERCRED 17 Socket-Option: ?
SO_RCVLOWAT 18 Socket-Option: ?

SO_SNDLOWAT 19 Socket-Option: ?
SO_RCVTIMEO 20 Socket-Option: ?
SO_SNDTIMEO 21 Socket-Option: ?
SO_SECURITY_AUTHENTICA- 22 Socket-Option: ?
TION
SO_SECURITY_ENCRYPTION_- 23 Socket-Option: ?
TRANSPORT
SO_SECURITY_ENCRYPTION_- 24 Socket-Option: ?
NETWORK
SO_BINDTODEVICE 25 Socket-Option: ?
SO_ATTACH_FILTER 26 Socket-Option: ?
SO_DETACH_FILTER 27 Socket-Option: ?
SO_PEERNAME 28 Socket-Option: ?
SO_TIMESTAMP 29 Socket-Option: ?
SO_ACCEPTCONN 30 Socket-Option: ?
Die folgenden Konstanten sind Werte für TCP-Socketoptionen und nicht weiter be-
schrieben:

TCP_NODELAY 1 ?
TCP_MAXSEG 2 ?
TCP_CORK 3 ?
TCP_KEEPIDLE 4 ?
TCP_KEEPINTVL 5 ?
TCP_KEEPCNT 6 ?
TCP_SYNCNT 7 ?
TCP_LINGER2 8 ?
TCP_DEFER_ACCEPT 9 ?
TCP_WINDOW_CLAMP 10 ?
TCP_INFO 11 ?
TCP_QUICKACK 12 ?
TCP_CONGESTION 13 ?
TCP_MD5SIG 14 ?
Die folgenden Konstanten sind Werte für UDP-Socketoptionen und nicht weiter be-
schrieben:

UDP_CORK 1 ?
UDP_ENCAP_ESPINUDP_NON_IKE 1 ?
UDP_ENCAP_ESPINUDP 2 ?
UDP_ENCAP_L2TPINUDP 3 ?
UDP_ENCAP 100 ?

Typdeklarationen
Die Unit definiert eine ganze Reihe spezialisierter Datentypen.
in6_addr = packed record
case Byte of
0: (u6_addr8 : array[0..15] of Byte);
1: (u6_addr16: array[0.. 7] of Word);
2: (u6_addr32: array[0.. 3] of Cardinal);
3: (s6_addr8 : array[0..15] of ShortInt);
4: (s6_addr : array[0..15] of ShortInt);
5: (s6_addr16: array[0.. 7] of SmallInt);
6: (s6_addr32: array[0.. 3] of LongInt);
end;
in6_addr ist ein Record für das Beschreiben einer allgemeinen IPv6-Adresse.
in_addr = packed record
case Boolean of
true: (s_addr : cuint32); // inaddr_t=cuint32
false: (s_bytes: packed array[1..4] of Byte);
end;
in_addr erfaßt die allgemeine Internet-Socket-Adresse.
linger = packed record
l_onoff : cint;
l_linger : cint;
end;
Dieser Record wird im Aufruf von setsockopt benötigt, um Linger-Optionen zu definieren.
PIn6Addr = pin6_addr;
Zeiger auf den Datentyp in6_addr.
pin6_addr = ^in6_addr;
Zeiger auf den Datentyp Tin6_addr.
PInAddr = pin_addr
Ein Alias für pin_addr
PInetSockAddr = psockaddr_in
Zeiger auf den Datentyp sockaddr_in.
PInetSockAddr6 = psockaddr_in6
Zeiger auf den Datentyp sockaddr_in6 type.
pin_addr = ^in_addr
Zeiger auf den Record in_addr
plinger = ^linger
Zeiger auf den Datentyp linger.
psockaddr = ^sockaddr
Zeiger auf eine TSockAddr.
psockaddr_in = ^sockaddr_in
Zeiger auf den sockaddr_in.
psockaddr_in6 = ^sockaddr_in6
Zeiger auf sockaddr_in6.
psockaddr_un = ^sockaddr_un
Zeiger auf sockaddr_un.
sa_family_t = cushort
Datentyp für die Adreßfamilie.
sockaddr = packed record
// if sa_len is defined, sa_family_t is smaller
{$ifdef SOCK_HAS_SINLEN}
sa_len: cuchar;
{$endif}
case Integer of
0: (sa_family : sa_family_t;
sa_data : packed array[0..13] of cuint8);
1: (sin_family: sa_family_t;
sin_port : cushort;
sin_addr : in_addr;
sin_zero : packed array[0..7] of cuint8);
end;
In sockaddr ist eine allgemeine Socketadresse für Bind, Recv und Send gespeichert.
sockaddr_in = packed record
case boolean of
false: (
{$ifdef SOCK_HAS_SINLEN}sin_len: cuchar;{$endif}
sin_family: sa_family_t;
sin_port : cushort;
sin_addr : in_addr;
xpad : array[0..7] of Char;// to get to the size of sockaddr...
);
true: (
{$ifdef SOCK_HAS_SINLEN}len: cuchar;{$endif}
family: sa_family_t;
port : cushort;
addr : cardinal;
pad : array[0..7] of Char; { to get to the size of sockaddr... }
);
end;
sockaddr_in speichert eine INET-Socket-Adresse für die Aufrufe Bind, Recv und Send.
sockaddr_in6 = packed record
Sin6_family : sa_family_t;
Sin6_port : cuint16;
Sin6_flowinfo : cuint32;
Sin6_addr : in6_addr;
Sin6_scope_id : cuint32;
end;
Ein Alias für sockaddr_in6.
sockaddr_un = packed record
sun_family: sa_family_t;
sun_path : array[0..107] of Char;
end;
sockaddr_un speichert eine Unix-Socket-Adresse für die Aufrufe Bind, Recv und Send.
TIn6Addr = in6_addr
Alias für den Datentyp in6_addr.
Tin6_addr = in6_addr
Alias für den Datentyp sockaddr_in6.
TInAddr = in_addr
Alias für den Record-Datentyp in_addr.
TInetSockAddr = sockaddr_in
Alias für den Datentyp sockaddr_in.

Kapitel 4.19 Unit Sockets – Accept O77
TInetSockAddr6 = sockaddr_in6
Alias für den Datentyp sockaddr_in6.
TIn_addr = in_addr
Alias für den Record-Datentyp in_addr.
TLinger = linger
Alias für den Datentyp linger.
TSockAddr = sockaddr
Alias für sockaddr.
TSockArray = array[1..2] of LongInt;
Datentyp, der vom Aufruf SocketPair zurückgegeben wird.
TSocket = LongInt
Alias für einfachere Kylix-Portierung.
TSockPairArray = array[0..1] of LongInt;
Ein Socket-Array für den Aufruf SocketPair.
TUnixSockAddr = packed record
family: sa_family_t;
path : array[0..107] of Char;
end;
Alias für den Datentyp sockaddr_un.
ACCEPT
function Accept(Sock: LongInt; var Addr; var Addrlen: LongInt): LongInt;
function Accept(Sock: LongInt; var addr: TInetSockAddr;
var SockIn: File; var SockOut: File): Boolean;
function Accept(Sock: LongInt; var addr: TInetSockAddr;
var SockIn: Text; var SockOut: Text) : Boolean;
function Accept(Sock: LongInt; var addr: String;
var SockIn: Text; var SockOut: Text): Boolean;
function Accept(Sock: LongInt; var addr: String;
Accept nimmt die Verbindung von einem Socket Sock an, der auf eine Verbindung wartet.
Falls eine Verbindung akzeptiert wird, wird ein Dateideskriptor zurückgeliefert, bei einem
Fehler -1. Über den zurückgegebenen Socket dürfen keine weiteren Verbindungen ange-
nommen werden. Der übergebene Socket bleibt geöffnet. Der Accept-Befehl speichert die
Adresse des verbindenden Puffers (entity) in Addr und seine Länge in Addrlen. Vor dem
Aufruf sollte Addr auf genügend Speicher verweisen und Addrlen sollte die Größe dieses
Speichers vor dem Aufruf enthalten. Die anderen Varianten des Aufrufs von Accept mit den
Text- und File-Parametern sind Kombinationen aus der normalen Funktion Accept und an-
schließenden Aufrufen der Funktionen Sock2Text beziehungsweise Sock2File. Diese erwei-
terten Funktionen liefern bei erfolgreicher Ausführung ein True und sonst den Wert False.
Fehler: Bei einem Fehler wird von der einfachen Variante der Funktion der Wert -1 zu-
rückgeliefert und SocketError auf einen der folgenden Werte gesetzt:
SYS_EBADF Der Socketdeskriptor ist ungültig.

SYS_ENOTSOCK Der Deskriptor ist kein Socket.
SYS_EOPNOTSUPP Der Socket-Typ unterstützt keine Listen-Operation.
SYS_EFAULT Addr zeigt auf einen Bereich außerhalb des Adreßraums.
SYS_EWOULDBLOCK Die angefragte Operation würde den Prozeß blockieren.
Siehe auch: Listen, Connect und Bind.
program server; (* sockex/socksvr.pp *)
(*
program to test Sockets unit by Michaël van Canneyt and Peter Vreman
Server Version, First Run sock_svr to let it create a socket and then
sock_cli to connect to that socket
*)
uses Sockets;
var
FromName : String;
Buffer : String[255];
S : LongInt;
Sin, Sout: Text;
SAddr : TInetSockAddr;
procedure perror(const S: String);

begin
WriteLn(S, SocketError);
Halt(100);
end;
begin
S := Socket(AF_INET, SOCK_STREAM, 0);
if SocketError <> 0 then perror(’Server: Socket: ’);
SAddr.Sin_family := AF_INET;
(* port 50000 in network order: *)
SAddr.Sin _port := htons(50000);
SAddr.Sin_addr.s_addr := 0;
if not Bind(S, SAddr, SizeOf(saddr)) then PError(’Server: Bind: ’);
if not Listen(S, 1) then PError(’Server: Listen: ’);
WriteLn(’Waiting for Connect from Client, run now sock_cli in another tty’);
if not Accept(S, FromName, Sin, Sout) then PError(’Server: Accept: ’ + fromname);
Reset(Sin);
ReWrite(Sout);
WriteLn(Sout, ’Message From Server’);
Flush(Sout);
while not EoF(Sin) do begin
ReadLn(Sin, Buffer);
WriteLn(’Server: Read: ’, buffer);
end;
end.
BIND
function Bind(Sock: LongInt; const Addr; AddrLen: LongInt): Boolean;
function Bind(Sock: LongInt; const addr: String): Boolean;
Bind verbindet den Socket Sock mit der Adresse Addr, die die Länge Addrlen hat. Die
Funktion liefert True, falls sie erfolgreich war, ansonsten False. Die Variante des Bind-
Befehls mit der TUnixSockAddr ist gleichwertig zum nacheinander folgenden Aufruf von
Str2UnixSockAddr und der normalen Bind-Function. Die Funktion meldet True, wenn sie
erfolgreich ausgeführt wurde, beim Auftreten eines Fehlers False.
Fehler werden in SocketError gespeichert. Es sind folgende Fehlercodes vorgesehen:

SYS_EINVAL Der Socket ist bereits mit einer Adresse verbunden.
SYS_EACCESS Die Adresse ist geschützt, das Progamm besitzt nicht die Berechtigung,
sie zu öffnen.
Kapitel 4.19 Unit Sockets – CloseSocket O79
Weitere mögliche Fehler können in den Unix-Manpages nachgelesen werden.
Siehe auch: Socket.
CLOSESOCKET
function CloseSocket(Sock: LongInt): LongInt;
CloseSocket schließt ein Socket-Handle. Die Funktion liefert 0 zurück, wenn der Socket
erfolgreich geschlossen wurde.
Fehler: Bei einem Fehler wird der Wert -1 zurückgegeben.
Siehe auch: Socket.
CONNECT
function Connect(Sock: LongInt; const Addr; Addrlen: LongInt): Boolean;
function Connect(Sock: LongInt; const addr: TInetSockAddr;
function Connect(Sock: LongInt; const addr: TInetSockAddr;
function Connect(Sock: LongInt; const addr: String;
function Connect(Sock: LongInt; const addr: String;
Connect öffnet eine Verbindung zu einem Peer, dessen Adresse durch Addr beschrieben
wird. AddrLen enthält die Länge der Adresse. Der Typ von Addr hängt von der Art der
Verbinung ab, die zu etablieren versucht wird. Im allgemeinem ist der Typ jedoch TSok-
kAddr oder TUnixSockAddr. Diese reguläre Connect-Funktion liefert einen Dateideskrip-
tor, falls der Aufruf erfolgreich war.
Die anderen Varianten des Aufrufs von Connect mit den Text- und File-Parametern sind
Kombinationen aus der normalen Funktion Connect und anschließenden Aufrufen der
Funktionen Sock2Text beziehungsweise Sock2File. Diese erweiterten Funktionen liefern
bei erfolgreicher Ausführung ein True und sonst den Wert False.
Fehler: Bei einem Fehler der normalen Funktion wird -1 zurückgeliefert und ein Fehler-
code in SocketError gespeichert.
Siehe auch: Listen, Bind und Accept.
program Client; (* sockex/sockcli.pp *)
(*
Program to test Sockets unit by Michael van Canneyt and Peter Vreman
Client Version, First Run sock_svr to let it create a socket and then
sock_cli to connect to that socket
*)
uses
Sockets;
procedure PError(const S: String);

begin
WriteLn(S, SocketError);
Halt(100);
end;
var
SAddr : TInetSpckAddr;
Buffer : String[255];
S : LongInt;
Sin, Sout: Text;
i : Integer;
begin
S := Socket(AF_UNIX, SOCK_STREAM, 0);
if SocketError <> 0 then Perror(’Client: Socket: ’);
SAddr.Sin_family := AF_INET;
{ port 50000 in network order }
SAddr.Sin_port := htons(50000);
{ localhost: 127.0.0.1 in network order }
SAddr.Sin_addr.s_addr := HostToNet((127 shl 24) or 1);
if not Connect(S, SAddr, Sin, Sout) then PError(’Client : Connect : ’);
Reset(Sin);
ReWrite(Sout);
Buffer := ’This is a textstring sent by the Client.’;
for i := 1 to 10 do WriteLn(Sout, Buffer);
Flush(Sout);
Readln(SIn,Buffer);
WriteLn(Buffer);
Close(Sout);
end.
program pfinger; (* sockex/pfinger.pp *)
uses
Sockets, Errors;
var
Addr : TInetSockAddr;
S : LongInt;
Sin, Sout: Text;
Line : String;
begin
Addr.family := AF_INET;
{ port 79 in network order }
Addr.Sin_port := 79 shl 8;
{ localhost : 127.0.0.1 in network order }
Addr.Sin_addr.s_addr := ((1 shl 24) or 127);
S := Socket(AF_INET, SOCK_STREAM, 0);
if not Connect(S, Addr, Sin, Sout) then begin
WriteLn(’Couldn’’t connect to localhost’);
WriteLn(’Socket error : ’, strerror(SocketError));
Halt(1);
end;
ReWrite(Sout);
Reset(Sin);
WriteLn(Sout, ParamStr(1));
Flush(Sout);
while not EoF(Sin) do begin
ReadLn(Sin, line);
WriteLn(line);
end;
Close(Sin);
Close(Sout);
end.
FPACCEPT
function fpAccept(s: cint; Addrx: psockaddr; Addrlen: PSocklen): cint;
fpAccept nimmt eine Verbindung vom Socket s entgegen, der auf eine Verbindung ge-
lauscht hat. Wird eine Verbindung akzeptiert, wird ein Dateideskriptor (eine positive
Zahl) zurückgegeben, beim Auftreten eines Fehlers der Wert -1. Über den zurückgegebe-
nen Socket dürfen keine weiteren Verbindungen angenommen werden. Für diesen Zweck
bleibt der Original-Socket geöffnet.
Kapitel 4.19 Unit Sockets – fpBind O81
Der Aufruf fpAccept füllt die Adresse in Addrx und setzt die Länge in Addrlen. Addrx
sollte auf einen Bereich mit genügend Platz zeigen, Addrlen sollte auf die Größe des an
dieser Stelle vor dem Aufruf befindlichen freien Speichers gesetzt werden.
Fehler: Bei einem Fehler werden -1 und der Fehler in SocketError zurückgegeben. Die
folgenden Fehlerwerte können auftreten:
SYS_EBADF Der Socket-Deskriptor ist ungültig.

SYS_EOPNOTSUPP Der Sockettyp unterstützt die Operation Listen nicht.
SYS_EFAULT Addr zeigt aus dem gültigen Adreßbereich heraus.
SYS_EWOULDBLOCK Die angeforderte Operation würde den Prozeß blockieren.
Siehe auch: fpListen, fpConnect und fpBind.

Für ein Listingbeispiel siehe sockex/socksvr.pp bei der Funktion Accept.
FPBIND
function fpBind(s: cint; Addrx: PSockaddr; Addrlen: TSocklen): cint;
fpBind bindet den Socket s an die Adresse Addrx. Addrx besitzt die Größe Addrlen. Die
Funktion meldet 0, wenn sie erfolgreich ausgeführt wurde, und -1, wenn nicht.
Fehler: Fehler werden in SocketError zurückgegeben und enthalten die folgenden Werte:

SYS_EINVAL Der Socket ist bereits an eine Adresse gebunden.
SYS_EACCESS Die Adresse ist geschützt und das Programm hat nicht das Recht, sie zu
öffnen.
Weitere mögliche Fehler stehen in den Unix-Manpages.

Siehe auch: Socket.
FPCONNECT
function fpConnect(s: cint; name: PSockaddr; Namelen: TSocklen): cint;
fpConnect öffnet eine Verbindung zu einer Gegenstelle, deren Adresse in Name angege-
ben ist. NameLen enthält die Länge der Adresse. Der Typ von Name hängt von der Art
der Verbindung, die zu öffnen versucht wird, ab und ist grundsätzlich entweder vom Typ
TSockAddr oder TUnixSockAddr. Die Funktion Connect gibt bei Erfolg einen Datei-
deskriptor zurück.
Fehler: Bei einem Fehler ergibt die Funktion den Wert -1, Fehler werden in SocketError
übergeben.
Siehe auch: fpListen, fpBind und fpAccept.
Listingbeispiele hierzu sind sockex/sockcli.pp und sockex/pfinger.pp bei der Funktion connect.
FPGETPEERNAME
function fpGetPeerName(s: cint; name: PSockaddr; Namelen: psocklen): cint;
fpGetPeerName gibt den Namen der an den angegebenen Socket S angebundenen Einheit
zurück. Der Socket muß, damit dieser Aufruf funktioniert, verbunden sein.
Name sollte auf einen Speicherplatz zeigen, der groß genug ist, den Namen aufzunehmen,
der verfügbare Platz wird in Namelen übergeben. Wurde die Funktion erfolgreich ausge-
führt, enthält Name den Namen und Namelen dessen Länge.

SYS_ENOBUFS Das System besitzt nicht genug Puffer, um die Operation durchführen zu
können.
SYS_EFAULT Addr zeigt aus dem gültigen Adreßbereich heraus.
SYS_ENOTCONN Der Socket ist nicht verbunden.
Siehe auch: fpConnect, fpSocket.

FPGETSOCKNAME
function fpGetSockName(s: cint; name: psockaddr; namelen: psocklen): cint;
fpGetSockName gibt den aktuellen Namen des angegebenen Sockets s zurück. Name sollte
auf einen Speicherplatz mit ausreichend viel Platz zeigen, um den Namen aufnehmen zu
können, die Größe des freien Speicherplatzes sollte in Namelen angegeben werden.
Kehrt die Funktion erfolgreich zurück, enthält Name den Namen und Namelen dessen
Länge.

SYS_ENOBUFS Das System besitzt nicht genug Puffer, um die Operation durchführen zu
können.
SYS_EFAULT Addr zeigt auf einen Bereich außerhalb des eigenen Adreßbereichs.
Siehe auch: fpBind.

FPGETSOCKOPT
function fpGetSockOpt(s: cint; Level: cint; Optname: cint;
Optval: Pointer; Optlen: PSocklen): cint;
fpGetSockOpt erhält die VerbindungoptionOptname für den Socket S. Der Socket kann
auf unterschiedlichen Ebenen erlangt werden, die durch den Parameter Level festgelegt
werden, der einen der folgendenWerte annehmen kann:
SOL_SOCKET Vom Socket selbst.

XXX Setzt Level auf XXX, die Protokollnummer des Protokolls, das die Opti-
on interpretieren soll.
Die Optionen werden an der in Optval angegebenen Speicherstelle abgelegt. Optlen sollte
die ursprüngliche Länge von Optval enthalten und enthält bei der Rückkehr der Funktion
die tatsächliche Größe der abgelegten Daten.
Bei Erfolg gibt die Funktion 0 zurück, bei einem Fehler den Wert -1.
Fehler: Fehler werden in SocketError gespeichert. Es sind folgende Fehlercodes vorgese-
hen:

SYS_EFAULT OptVal zeigt auf einen Bereich außerhalb des eigenen Adreßbereichs.
Siehe auch: fpSetSockOpt.

Kapitel 4.19 Unit Sockets – fpListen O83
FPLISTEN
function fpListen(s: cint; backlog: cint): cint;
fpListen lauscht auf bis zu backlog Verbindungen von Socket s. Der Socket s muß entwe-
der vom Typ SOCK_STREAM oder vom Typ Sock_SEQPACKET sein.
Die Funktion gibt 0 zurück, wenn eine Verbindung angenommen wurde, -1 beim Auftre-
ten eines Fehlers.

SYS_EOPNOTSUPP Der Socket unterstützt die Operation Listen nicht.
Siehe auch: fpSocket, fpBind und fpConnect.

FPRECV
function fpRecv(s: cint; buf: Pointer; len: size_t; Flags: cint): ssize_t;
fpRecv liest maximal len Byte aus dem Socket s an die Adresse buf. Der Socket muß in
einem verbundenen Status sein. Flags kann einer der folgenden Werte sein:
1 Daten außerhalb des Bands verarbeiten (Out-of band Data).

4 Das Routing soll umgangen und eine direkte Schnittstelle verwendet
werden.
?? Warte auf die vollständige Anfrage oder generiere eine Fehlermeldung.
Die Funktion gibt die Zahl der aktuell aus dem Socket gelesenen Byte aus oder -1, wenn
ein erkennbarer Fehler auftrat.
Fehler werden in SocketError gespeichert. Folgende Fehlercodes sind vorgesehen:

SYS_EFAULT Die Adresse ist außerhalb des eigenen Adreßbereichs.
SYS_EMSGSIZE Die Meldung konnte nicht atomar gesendet werden.
SYS_ENOBUFS Das System besitzt nicht genug freie Puffer, um die Operation durch-
führen zu können.
Siehe auch: Send.

FPRECVFROM
function fpRecvFrom(s: cint;buf: Pointer; len: size_t; flags: cint;
from: PSockaddr; Fromlen: PSocklen): ssize_t;
fpRecvFrom empfängt aus dem Socket s Daten mit der maximalen Länge Len in den Puffer
Buf. Der Empfang wird von den Optionen in Flags gesteuert. Der Speicherplatz, auf den
from zeigt, wird mit der Adresse vom Sender gefüllt und die Länge in Fromlen. Die Funk-
tion gibt die Zahl der empfangenen Byte aus.
Fehler: Tritt ein Fehler auf, wird -1 zurückgegeben.
Siehe auch: fpSocket und fprecv.
FPSEND
function fpSend(s: cint; msg: pointer; len: size_t; flags: cint): ssize_t;
fpSend sendet Len Byte ab der Adresse Msg an den Socket s. s muß dazu verbunden sein.
Optionen können der Verbindung in Flags übergeben werden.
Die Funktion gibt die Zahl der gesendeten Byte zurück und -1, wenn ein erkennbarer
Fehler auftrat. flags kann einer der folgenden Werte sein:
1 Daten außerhalb des Bandes verarbeiten (Out-of-band Data).

4 Das Routing soll umgangen und eine direkte Schnittstelle angespro-
chen werden.

SYS_EMSGSIZE Die Meldung konnte nicht atomar gesendet werden.
SYS_ENOBUFS Das System besitzt nicht genug freien Puffer, um die Operation
durchführen zu können.
Siehe auch: fpRecv.

FPSENDTO
function fpSendTo(s: cint; msg: pointer; len: size_t; flags: cint;
tox: psockaddr; tolen: tsocklen): ssize_t;
fpSendTo sendet Daten aus dem Puffer Msg mit der Länge len durch den Socket s mit der
Option Flags. Die Daten werden an die Adresse tox gesandt, die die Länge toLen besitzt.
Fehler: Beim Auftreten eines Fehlers gibt die Funktion den Wert -1 zurück.
Siehe auch: fpSocket, fpSend und fpRecvFrom.
FPSETSOCKOPT
function fpSetSockOpt(s: cint; level: cint; optname: cint;
optval: pointer; optlen: tsocklen): cint;
fpSetSockOpt setzt die Verbindungsoptionen für den Socket s. Der Socket kann auf ver-
schiedenen Ebenen verändert werden, wie im Parameter level angegeben. level kann einen
der folgenden Werte annehmen:
SOL_SOCKET Um den Socket selbst zu manipulieren.

XXX Setzt Level auf XXX, die Nummer des Protokolls, das die Option
interpretieren soll.
Die aktuelle Option wird im Puffer, auf den optval zeigt, gespeichert. Seine Länge wird
mit optlen festgelegt.
Weitere Informationen zu diesem Aufruf erhält man in der Unix-Magepage zu setsockopt.
Fehler werden in SocketError gespeichert.

Kapitel 4.19 Unit Sockets – fpShutDown O85
Es sind folgende Fehlercodes vorgesehen:

Siehe auch: fpGetSockOpt.

FPSHUTDOWN
function fpShutDown(s: cint; how: cint): cint;
fpShutDown schließt das eine Ende der zweiseitigen Verbindung in s. Der Parameter how
beschreibt, wie die Verbindung heruntergefahren wird, und kann einer der folgenden
Werte sein:
0 Weiterer Empfang ist nicht erlaubt.

1 Weiteres Senden ist nicht erlaubt.
2 Senden und Empfangen ist verboten.
Bei Erfolg gibt die Funktion den Wert 0 zurück, bei einem Fehler -1.

Siehe auch: fpSocket und fpConnect.

FPSOCKET
function fpSocket(domain: cint; xtype: cint; protocol: cint): cint;
fpSocket erzeugt einen neuen Socket vom Typ xType mit dem Protokoll Protocol in der
Domain domain. Domain, Socket-Typ und Protokoll können mit vordefinierten Konstan-
ten belegt werden (siehe dazu den Abschnitt über Konstanten in diesem Kapitel ab Seite
O66). Wird die Funktion erfolgreich abgeschlossen, liefert sie einen Socket-Deskriptor,
der an einen nachfolgenden Aufruf von fpBind übergeben werden kann, beim Auftreten
eines Fehlers gibt die Funktion -1 zurück.
Ein Beispiel ist bei der Funktion Accept gezeigt.
SYS_EPROTONOSUPPORT Der Protokolltyp oder das angebene Protokoll wird in dieser

Domain nicht unterstützt.
SYS_EMFILE Die prozeßbezogene Deskriptortabelle ist voll.
SYS_ENFILE Die Dateitabelle des Systems ist voll.
SYS_EACCESS Die Adresse ist geschützt und das Programm hat nicht das Recht,
sie zu öffnen.
SYS_ENOBUFS Das System besitzt nicht genug freie Puffer, um die Operation
durchführen zu können.
Siehe auch: SocketPair.
FPSOCKETPAIR
function fpSocketPair(d: cint; xtype: cint; protocol: cint; sv: pcint): cint;
fpSocketPair erzeugt zwei Sockets in der Domain D vom Typ xType mit dem Protokoll
Protocol. Das Paar wird in sv zurückgegeben, die beiden Sockets unterscheiden sich nicht
voneinander. Die Funktion gibt bei einem Fehler den Wert -1 zurück, geht alles glatt,
meldet sie den Wert 0.
Fehler: Fehler werden in SocketError gespeichert, es sind die selben Codes wie bei der
Funktion Socket.
Siehe auch: Str2UnixSockAddr.
GETPEERNAME
function GetPeerName(Sock: LongInt; var Addr; var Addrlen: LongInt): LongInt;
GetPeerName liefert den Namen der Einheit, die mit dem Socket Sock verbunden ist.
Damit dieser Aufruf gelingt, muß der Socket verbunden sein. Addr sollte auf genügend
Speicher verweisen, um den Namen speichern zu können. Die Größe des Speichers, auf
den Addr zeigt, sollte von Addrlen festgelegt werden. War die Funktion erfolgreich, wird
Addr mit dem Namen gefüllt und Addrlen wird zur Länge von Addr gesetzt.
Fehler werden in SocketError gespeichert und können die folgenden Werte annehmen:

SYS_ENOBUFS Das System hat nicht genügend Pufferspeicher, um die Operation
auszuführen.
Siehe auch: Connect, Socket und connect.

GETSOCKETNAME
function GetSocketName(Sock: LongInt; var Addr; var Addrlen: LongInt) : LongInt
Hinweis: Diese Funktion ist veraltet.
GetSockName liefert den aktuellen Namen des angegebenen Sockets Sock zurück. Addr
sollte auf genügend Speicher verweisen, um den Namen aufnehmen zu können. Die Grö-
ße des Speichers, auf den verwiesen wird, sollte in Addrlen angegeben werden. Wenn die
Funktion erfolgreich war, wird Addr auf den Namen und Addrlen auf die Länge von Addr
gesetzt.
Fehler: Fehler werden in SocketError gespeichert und können die folgenden Werte an-
nehmen:

SYS_ENOBUFS Das System hat nicht genügend Pufferspeicher, um die Operation aus-
zuführen.
Siehe auch: Bind.

Kapitel 4.19 Unit Sockets – GetSocketOptions O87
GETSOCKETOPTIONS
function GetSocketOptions(Sock: LongInt; Level: LongInt; OptName: LongInt;
var OptVal; var optlen: LongInt): LongInt;
GetSocketOptions liefert die Verbindungsoptionen für den Socket Sock. Diese Optionen
können von verschiedenen Levels gewonnen werden. Der dafür vorgesehene Parameter
level kann die folgenden Werte annehmen:
SOL_SOCKET Der Socket selbst soll die Optionen bereitstellen.

XXX Setzen Sie Level auf die Nummer des Protokolls, das die Option inter-
pretieren soll.
Um mehr Informationen über diesen Befehl zu erhalten, schlagen Sie in den Unix-
Manpages unter getsockopt nach.
Fehler: Fehler werden in SocketError gespeichert.
Folgende Werte sind möglich:

Siehe auch: SetSocketOptions.

HOSTADDRTOSTR
function HostAddrToStr(Entry: in_addr): AnsiString;
HostAddrToStr wandelt die Hostadresse in Entry in einen menschenlesbaren String mit
Punkttrennern um. Dabei handelt es sich prinzipiell um die selbe Funktion wie Ne-
tAddrToStr, aber mit den Byte in korrekter Reihenfolge.
Siehe auch: NetAddrToStr, StrToHostAddr und StrToNetAddr.
HOSTADDRTOSTR6
function HostAddrToStr6(Entry: Tin6_addr): AnsiString;
HostAddrToStr6 wandelt die IPV6-Hostadresse in Entry in einen menschenlesbaren
String mit Punkttrennern um. Dabei handelt es sich prinzipiell um die selbe Funktion wie
NetAddrToStr6, aber mit den Byte in korrekter Reihenfolge.
Siehe auch: NetAddrToStr, StrToHostAddr, StrToNetAddr und StrToHostAddr6.
HOSTTONET
function HostToNet(Host: in_addr): in_addr;
function HostToNet(Host: LongInt): LongInt;
HostToNet wandelt eine Hostadresse in eine Netzwerkadresse, wobei die Endianness der
Hostmaschine berücksichtigt wird. Die Adresse kann mit Anführungszeichen und Punkt-
rennern oder als LongInt angegeben werden.
Siehe auch: NetToHost, NToHS, HToNS, ShortHostToNet und ShortNetToHost.
HTONL
function htonl(host: LongInt): LongInt;
htonl sorgt dafür, daß die Byte in host für den Versand über das Netzwerk in der richtigen
Reihenfolge stehen und gibt das richtig sortierte Ergebnis zurück.
Siehe auch: htons, ntohl und ntohs.
HTONS
function htons(host: Word): Word;
htons sorgt dafür, daß die Byte in host für den Versand über das Netzwerk in der richtigen
Reihenfolge stehen und gibt das richtig sortierte Ergebnis zurück.
Siehe auch: htonl, ntohl und ntohs.
LISTEN
function Listen(Sock: LongInt; MaxConnect: LongInt): Boolean;
Listen wartet auf maximal MaxConnect Verbindungen vom Socket Sock, der vom Typ
SOCK_STREAM oder Sock_SEQPACKET sein muß. Die Funktion liefert true, falls eine
Verbindung angenommen wurde, false bei einem Fehler.
Fehler: Fehler werden in SocketError gespeichert. Folgende Werte sind möglich:

SYS_EOPNOTSUPP Der Socket-Typ unterstützt keine Listen-Operation.
Siehe auch: Socket, Bind und Connect.

NETADDRTOSTR
function NetAddrToStr(Entry: in_addr): AnsiString;
NetAddrToStr in einen menschenlesbaren String mit Punkttrennern um.
Siehe auch: HostAddrToStr, StrToNetAddr und StrToHostAddr
NETADDRTOSTR6
function NetAddrToStr6(Entry: Tin6_addr): AnsiString;
NetAddrToStr6 wandelt die IPV6-Netzwerkadresse in Entry in einen lesbaren String um.
Vom Grunde her ist das dasselbe wie NetAddrToStr6, allerdings sind hier die Daten in der
richtigen Reihenfolge.
Siehe auch: NetAddrToStr, StrToHostAddr, StrToNetAddr und StrToHostAddr6.
NETTOHOST
function NetToHost(Net: in_addr): in_addr;
function NetToHost(Net: LongInt): LongInt;
NetToHost wandelt eine Netzwerkadresse in eine Hostadresse um, wobei die Endianness
der Hostmaschine berücksichtigt wird. Die Adresse kann als punktgetrennter Block oder
als LongInt-Zahl angegeben sein.
Siehe auch: HostToNet, NToHS, HToNS, ShortHostToNet und ShortNetToHost.
NTOHL
function NToHl(Net: LongInt): LongInt;
ntohs stellt sicher, daß die Bytes in Net, die aus dem Netzwerk erhalten wurden, in der
richtigen Reihenfolge für die Verarbeitung auf der Hostmaschine sind, und gibt das Er-
gebnis in richtiger Reihenfolge aus.
Siehe auch: htonl, htons und ntohs.

Kapitel 4.19 Unit Sockets – NToHs O89
NTOHS
function NToHs(Net: Word): Word;
ntohs stellt sicher, daß die Byte in Net, die aus dem Netzwerk erhalten wurden, in der
richtigen Reihenfolge für die Verarbeitung auf der Hostmaschine sind, und gibt das Er-
gebnis in richtiger Reihenfolge aus.
Siehe auch: htonl, htons und ntohl.
RECV
function Recv(Sock: LongInt; var Buf; BufLen: LongInt; Flags: LongInt): LongInt;
Recv liest höchstens Addrlen Byte vom Socket Sock in die Adresse Addr ein. Es muß eine
Verbindung zum Socket bestehen. Flags kann folgende Werte annehmen:
1 Daten außerhalb des Bands verarbeiten (Process out-of band data).

4 Routing umgehen und eine direkte Schnittstelle ansprechen.
?? Auf eine vollständige Anfrage oder die Meldung eines Fehlers warten.
Die Funktionen liefern die Anzahl an Byte, die tatsächlich vom Socket gelesen werden,
oder -1, falls ein Fehler bemerkt wurde.
Fehler: Fehler werden in SocketError gespeichert. Es können folgende Werte auftreten:

SYS_EFAULT Die angegebene Adresse ist außerhalb der Adreßraums.
SYS_EMSGSIZE Die Meldung kann nicht atomar (atomically) sein.
SYS_EWOULDBLOCK Die angefragte Operation würde die Applikation blockieren.
SYS_ENOBUFS Dem System steht nicht genug freier Pufferspeicher zur Verfügung.
Siehe auch: Send.

RECVFROM
function RecvFrom(Sock: LongInt; var Buf; Buflen: LongInt; Flags: LongInt;
var Addr; var AddrLen: LongInt): LongInt;
RecvFrom empfängt Daten aus dem Socket Sock in den Puffer Buf mit der Maximallänge
BufLen. Der Empfang wird mit den Optionen in Flags kontrolliert. In Addr wird die
Adresse des Senders eingetragen, die die Länge AddrLen haben darf. Die Funktion gibt die
Zahl der empfangenen Byte oder bei einem Fehler den Wert -1 zurück.
Siehe auch: Socket, recv und Send.
SEND
Send sendet AddrLen Byte beginnend bei der Adresse Addr an den Socket Sock. Es muß
eine Verbindung zum Socket bestehen. Die Funktion liefert die Anzahl der gesendeten
Byte oder -1, falls ein Fehler bemerkt wurde. Flags kann folgende Werte annehmen:
1 Daten außerhalb des Bandes verarbeiten (Process out-of band data).

4 Routing umgehen und eine direkte Schnittstelle verwenden.
Fehler: Fehler werden im SocketError gespeichert. Es gibt folgende Fehler:

SYS_EFAULT Die angegebene Adresse ist außerhalb der Adreßraums.
SYS_EMSGSIZE Die Meldung kann nicht atomar (atomically) sein.
SYS_EWOULDBLOCK Die angefragte Operation würde die Applikation blockieren.
SYS_ENOBUFS Dem System steht nicht genug freier Pufferspeicher zur Verfügung.
Siehe auch: recv.

SENDTO
function SendTo(Sock: LongInt; const Buf; BufLen: LongInt;
Flags: LongInt; var Addr; AddrLen: LongInt): LongInt;
SendTo sendet Data aus dem Puffer Buf mit der Länge BufLen durch den Socket Sock mit
den Optionen Flags. Die Daten werden an die Adresse Addr gesandt, die die Länge
AddrLen hat.
Fehler: Bei einem Fehler wird der Wert -1 zurückgemeldet.
Siehe auch: Socket, Send und RecvFrom.
SETSOCKETOPTIONS
function SetSocketOptions(Sock: LongInt; Level: LongInt; OptName: LongInt;
const OptVal; optlen: LongInt): LongInt;
SetSocketOptions legt die Verbindungsoptionen für den Socket Sock fest. Der Socket kann
auf verschiedenen Levels geändert werden. Der Parameter Level bestimmt dies und kann
folgende Werte annehmen:
SOL_SOCKET Um den Socket selbst zu ändern.

XXX Setzen Sie Level auf die Nummer des Protokolls, das die Optionen
interpretieren soll. Weitere Informationen über diesen Befehl stehen in
den Unix-Manpages unter setsockopt.
Fehler werden in SocketError gespeichert, wobei folgende Fehlercodes möglich sind:

SYS_EFAULT OptVal verweist auf Speicher außerhalb des Adreßraums.
Siehe auch: GetSocketOptions

SHORTHOSTTONET
function ShortHostToNet(Host: Word): Word;
ShortHostToNet wandelt eine Host-Portnummer in eine Netzwerk-Portnummer um.
Dabei wird die Endianness der Hostmaschine berücksichtigt.
Siehe auch: ShortNetToHost, HostToNet, NToHS und HToNS.
SHORTNETTOHOST
function ShortNetToHost(Net: Word): Word;
ShortNetToHost wandelt eine Netzwerk-Portnummer in eine Host-Portnummer um.
Dabei wird auf die Endianness der Hostmaschine Rücksicht genommen.
Siehe auch: ShortNetToHost, HostToNet, NToHS und HToNS.
Kapitel 4.19 Unit Sockets – Shutdown O91
SHUTDOWN
Shutdown(Sock: LongInt; How: LongInt): LongInt;
Shutdown beendet eine bidirektionale Verbindung, die durch Sock beschrieben wird.
How legt fest, wie die Verbindung beendet wird:
0 Weiterer Empfang ist untersagt.

1 Weiteres Senden ist untersagt.
2 Weder Senden noch Empfangen sind erlaubt.
War die Funktion erfolgreich, wird 0, bei einem Fehler -1 zurückgeliefert.

Fehler: SocketError zur Fehlermeldung enthält das folgende:

Siehe auch: Socket und Connect

SOCK2FILE
procedure Sock2File(Sock: LongInt; var SockIn: File; var SockOut: File);
Sock2File wandelt den Socket Sock in zwei Pascal-Dateideskriptoren des Typs File um,
einen zum Lesen (SockIn) und einen für das Schreiben in den Socket (SockOut).
Siehe auch: Socket und Sock2Text.
SOCK2TEXT
procedure Sock2Text(Sock: LongInt; var SockIn: Text; var SockOut: Text);
Sock2Text wandelt den Socket Sock in zwei Pascal-Dateideskriptoren des Typs Text um, ei-
nen zum Lesen aus dem Socket (SockIn) und einen zum Schreiben in den Socket (SockOut).
Siehe auch: Socket und Sock2File.
SOCKET
function Socket(Domain: LongInt; SocketType: LongInt; Protocol: LongInt): LongInt;
Socket erstellt einen neuen Socket in der Domain Domain vom Typ SocketType anhand
des Protokolls Protocol. Die Domain, der Sockettyp und das Protokoll können anhand der
vorgegebenen Konstanten (siehe Abschnitt zu den Konstanten, um geeignete Konstanten
zu finden) festgelegt werden. War die Funktion erfolgreich, liefert sie einen Socket-
deskriptor, der an einen nachfolgenden Bind-Befehl übermittelt werden kann. Falls die
Funktion fehlgeschlagen ist, wird -1 zurückgeliefert.
Fehler: Fehler werden in SocketError gemeldet. Es gibt die folgenden Fehlermeldungen:
SYS_EPROTONOSUPPORT Der Protokolltyp oder das festgelegte Protokoll wird von dieser
Domäne nicht unterstützt.
SYS_EMFILE Die Deskriptortabelle dieses Prozesses ist voll.
SYS_ENFILE Die Systemdateitabelle ist voll.
SYS_EACCESS Es fehlen die Zugriffsrechte, um einen neuen Socket des festge-
legten Typs und/oder Protokolls zu anzulegen.
SYS_ENOBUFS Nicht genügend Pufferspeicher. Der Socket kann nicht erstellt
werden, bis genügend Ressourcen vorhanden sind.
Siehe auch: SocketPair, Socket (Unix-Handbuch).
Zum Beispiel siehe: Accept.
SOCKETERROR
function socketerror: cint;
SocketError enthält den Fehlercode der letzten Socket-Operation. Frägt den letzten Sok-
ket-Fehler ab.
SOCKETPAIR
function SocketPair(Domain: LongInt; SocketType: LongInt;
Protocol: LongInt; var Pair: TSockArray): LongInt;
SocketPair erstellt zwei Sockets in der Domäne Domain vom Typ SocketType und ver-
wendet das Protokoll Protocol. Die beiden werden in Pair zurückgegeben und sind unver-
einbar. Die Funktion liefert -1 bei einem Fehler und 0 bei Erfolg zurück.
Fehler: Fehler werden in SocketError gemeldet und sind die gleichen wie in Socket
Siehe auch: Str2UnixSockAddr.
STR2UNIXSOCKADDR
procedure Str2UnixSockAddr(const addr: String; var t: TUnixSockAddr; var len: LongInt);
Str2UnixSockAddr ändert eine Unix-Socket-Adresse in einen String einer Struktur TU-
nixSockAddr, die an eine Bind-Anweisung übermittelt werden kann.
Siehe auch: Socket und Bind.
STRTOHOSTADDR
function StrToHostAddr(IP: AnsiString): in_addr;
StrToHostAddr wandelt den String in IP in eine Hostadresse um und gibt diese zurück.
Fehler: Bei einem Fehler wird die Hostadresse mit Nullen gefüllt.
Siehe auch: NetAddrToStr, HostAddrToStr und StrToNetAddr.
STRTOHOSTADDR6
function StrToHostAddr6(IP: String): Tin6_addr;
StrToHostAddr6 wandelt den String in IP in eine IPv6-Hostadresse um und gibt diese
zurück.
Fehler: Bei einem Fehler wird die Hostadresse mit Nullen gefüllt.
Siehe auch: NetAddrToStr6, HostAddrToStr6 und StrToHostAddr.
STRTONETADDR
function StrToNetAddr(IP: AnsiString): in_addr;
StrToNetAddr wandelt den String in IP in eine Netzwerkadresse um und gibt diese zu-
rück.
Fehler: Bei einem Fehler wird die Netzwerkadresse mit Nullen gefüllt.
Siehe auch: NetAddrToStr, HostAddrToStr und StrToHostAddr
STRTONETADDR6
function StrToNetAddr6(IP: AnsiString): Tin6_addr;
StrToNetAddr wandelt den String in IP in eine IPv6-Netzwerkadresse um und gibt diese
zurück.
Fehler: Bei einem Fehler wird die Netzwerkadresse mit Nullen gefüllt.
Siehe auch: NetAddrToStr6, HostAddrToStr6 und StrToHostAddr6.

Kapitel 4.20 Unit ipc – Konstanten, Typen, Variablen O93
4.20 Unit ipc
Die Interprozeßkommunikations-Unit IPC stellt die komplette Funktionalität der Inter-
prozeßkommunikation von Unix System V zur Verfügung: Shared Memory (gemeinsam
genutzter Speicher), Semaphoren (Signalübermittlung) und Messages (Nachrichten).
Diese Unit funktioniert nur auf Linux. Eine große Zahl von Konstanten sind in diesem
Buch nur der Vollständigkeit halber aufgeführt und sollten unter normalen Umständen
vom Programmierer nicht benötigt werden.
Die Unit ipc ruft die folgenden Units auf:
– BaseUnix,
– UnixType.
Variablen
IPCerror: LongInt;
Die IPCerror-Variable wird für die Fehlermeldung aller Befehle herangezogen.
Konstanten
Diese Konstanten sind für das Erstellen von IPC-Nachrichten vorhanden:
IPC_CREAT = 1 shl 9 Erstellt, wenn der Schlüssel nicht existiert.
IPC_EXCL = 2 shl 9 Scheitert, wenn der Schlüssel existiert.
IPC_NOWAIT = 4 shl 9 Fehler melden, wenn gewartet werden muß.
Diese Konstanten werden für die verschiedenartigen xxxget-Befehle benutzt:
IPC_RMID =0 Ressource entfernen.

IPC_SET =1 ipc_perm-Optionen setzen.
IPC_STAT =2 ipc_perm-Optionen auslesen.
IPC_INFO =3 IPCs anzeigen.
Diese Konstanten können an die verschiedenen xxxctl-Befehle übermittelt werden. Dabei

handelt es sich um interne Steuercodes, die nicht verwendet werden sollten:
MSGMAX = 4056 Interner Message-Steuercode. Nicht verwenden!

MSGMNB = 16384 Interner Message-Steuercode. Nicht verwenden!
MSGMNI = 128 Interner Message-Steuercode. Nicht verwenden!
MSG_EXCEPT = 2 shl 12 Interner Message-Steuercode. Nicht verwenden!
MSG_NOERROR = 1 shl 12 Interner Message-Steuercode. Nicht verwenden!
Konstanten für Semaphore:
SEM_GETALL = 13 Semaphor-Operation: Alle Semaphorenwerte lesen.

SEM_GETNCNT = 14 Semaphor-Operation: Zahl der Prozesse, die auf die Res-
source warten, ermitteln.
SEM_GETPID = 11 Semaphor-Operation: Prozeß-ID der letzten Operation
ermitteln.
SEM_GETVAL = 12 Semaphor-Operation: Aktuellen Wert der Semophore lesen.
SEM_GETVAL = 12 Semaphor-Operation: Aktuellen Wert der Semophore lesen.
SEM_GETZCNT = 15 Semaphor-Operation: Zahl der Prozesse ermitteln, die darauf

warten, daß die Semaphore den Wert 0 erreichen.
SEM_SEMMNI = 128 Semaphor-Operation: ?
SEM_SEMMNS=(SEM_SEMMNI Semaphor-Operation: ?
* SEM_SEMMSL
SEM_SEMMSL = 32 Semaphor-Operation: ?
SEM_SEMOPM = 32 Semaphor-Operation: ?
SEM_SEMVMX = 32767 Semaphor-Operation: ?
SEM_SETALL = 17 Semaphor-Operation: Alle Semaphorenwerte setzen.
SEM_SETVAL = 16 Semaphor-Operation: Semaphorenwert setzen.
SEM_UNDO = $1000 Konstante für semop.
Die folgenden Konstanten für den shmctl-Befehl sind nicht weiter beschrieben:
SHM_LOCK = 11;
SHM_R = 4 shl 6;
SHM_RDONLY = 1 shl 12;
SHM_REMAP = 4 shl 12;
SHM_RND = 2 shl 12;
SHM_UNLOCK = 12;
SHM_W = 2 shl 6;
Typdeklarationen
TKey = cint;
TKey ist der durch die schlüsselerzeugende Funktion ftok zurückgegebene Typ.
key_t = TKey;
Alias für den Datentyp TKey.
msglen_t = culong;
Typ für die Längendefinition von Nachrichten.
msgqnum_t = culong;
Typ für die Numerierung von Message-Queues.
PSHMinfo = ^TSHMinfo;
TIPC_Perm = record
key : TKey;
uid : uid_t;
gid : gid_t;
cuid: uid_t;
cgid: gid_t;
mode: mode_t;
seq : cushort;
end;
Die Struktur TIPC_Perm legt in allen IPC-Systemen Zugriffsrechte fest. Sie darf niemals
direkt aufgerufen werden.
TMSG = record
msg_next : PMSG;
msg_type : LongInt;
msg_spot : PChar;
msg_stime: LongInt;
msg_ts : Integer;
end;
Der TMSG-Record ist für das Handling von Botschafts-Warteschlangen implementiert.
Der Programmierer benötigt nie Zugriff auf diese Daten.

Kapitel 4.20 Unit ipc – Konstanten, Typen, Variablen O95
TMSGbuf = record
mtype: clong;
mtext: array[0..0] of Char;
end;
Der Record TMSGbuf enthält Daten über eine Botschaft. Dieser Record sollte niemals
direkt angewandt werden, stattdessen besser ein eigener Record, der die Struktur des
Records TMSGbuf aufweist und groß genug ist, um die Botschaft aufzunehmen. Das Feld
mtype sollte immer vorhanden sein und einen gültigen Wert enthalten.
TMSGinfo = record
msgpool: cint;
msgmap : cint;
msgmax : cint;
msgmnb : cint;
msgmni : cint;
msgssz : cint;
msgtql : cint;
msgseg : cushort;
end;
Der Record TMSGinfo ist für das Handling von Botschafts-Warteschlangen implemen-
tiert und sollte nie direkt benutzt werden.
TMSQid_ds = record
msg_perm : TIPC_Perm;
msg_first : PMSG;
msg_last : PMSG;
msg_stime : time_t;
msg_rtime : time_t;
msg_ctime : time_t;
msg_cbytes: Word;
msg_qnum : Word;
msg_qbytes: Word;
msg_lspid : ipc_pid_t;
msg_lrpid : ipc_pid_t;
end;
Der Record TMSQid_ds wird von der Routine msgctl zurückgegeben und enthält alle
Daten über die Botschafts-Warteschlange. Er sollte nie direkt aufgerufen werden, da es ein
interner Kernel-Record ist, dessen Felder jederzeit geändert werden können.
TSEMbuf = record
sem_num: cushort;
sem_op : cshort;
sem_flg: cshort;
end;
TSEMbuf wird im Befehl semop benötigt und gibt die auszuführenden Operationen an.
TSEMid_ds = record
sem_perm : TIPC_Perm;
sem_otime : time_t;
sem_ctime : time_t;
sem_base : Pointer;
sem_pending : Pointer;
sem_pending_last: Pointer;
undo : Pointer;
sem_nsems : cushort;
end;
Der Record TSEMid_ds wird vom Befehl semctl zurückgeliefert und enthält alle Daten, die
sich auf die Signalübertragung (Semaphore) beziehen.
TSEMinfo = record
semmap: cint;
semmni: cint;
semmns: cint;
semmnu: cint;
semmsl: cint;
semopm: cint;
semume: cint;
semusz: cint;
semvmx: cint;
semaem: cint;
end;
Der TSEMinfo-Record wird vom Signalübertragungssystem verwendet und sollte nicht
direkt benutzt werden.
PSEMun = ^TSEMun;
TSEMun = record
case LongInt of
0: (val : LongInt);
1: (buf : PSEMid_ds);
2: (arr : PWord);
3: (padbuf: PSeminfo);
4: (padpad: Pointer);
end;
Der variante Record TSEMun (eigentlich eine C-Union) wird im semctl-Befehl verwendet.
TShmid_ds = record
shm_perm : TIPC_Perm;
shm_segsz : cint;
shm_atime : time_t;
shm_dtime : time_t;
shm_ctime : time_t;
shm_cpid : ipc_pid_t;
shm_lpid : ipc_pid_t;
shm_nattch: Word;
shm_npages: Word;
shm_pages : Pointer;
attaches : Pointer;
end;
Die Struktur TSHMid_ds ermittelt oder setzt im Befehl shmctl die Einstellungen, die sich
auf den gemeinsam genutzten Speicher beziehen.
TSHMinfo = record
shmmax: cint;
shmmin: cint;
shmmni: cint;
shmseg: cint;
shmall: cint;
end;
Der TSHMinfo-Record wird intern im System des gemeinsam nutzbaren Speichers ver-
wendet, der Programmierer darf nicht direkt auf einen solchen Record zugreifen.
Die Unit enthält außerdem eine ganze Reihe vorgefertigter Zeiger auf die zusammenge-
setzten Datentypen:
PIPC_Perm = ^TIPC_Perm;
Zeiger auf den Record TIPC_Perm.
PMSG = ^TMSG;
Zeiger auf den Record TMSG.

Kapitel 4.20 Unit ipc – ftok O97
PMSGbuf = ^TMSGbuf;
Zeiger auf den Record TMsgBuf .
PMSGinfo = ^TMSGinfo;
Zeiger auf den Record TMSGinfo.
PMSQid_ds = ^TMSQid_ds;
Zeiger auf TMSQid_ds.
PSEMbuf = ^TSEMbuf;
Zeiger auf den Record TSembuf.
PSEMid_ds = ^TSEMid_ds;
Zeiger auf den Record TSEMid_ds.
PSEMinfo = ^TSEMinfo;
Zeiger auf den Record TSEMinfo.
PSEMun = ^TSEMun;
Zeiger auf den Record TSEMun.
PShmid_DS = ^TShmid_ds;
Zeiger auf den Record TSHMid_ds.
FTOK
function ftok(Path: PChar; ID: cint): TKey;
ftok gibt einen Schlüssel zurück, der in einem semget-, shmget- oder msgget-Befehl auf
eine neue oder bereits vorhandene IPC-Ressource zugreifen kann. Path ist der Name
einer Datei im Dateisystem, ID ist ein beliebiges Zeichen. ftok bewirkt das gleiche wie sein
Gegenstück in C; ein Pascalprogramm und ein C-Programm greifen auf die gleichen
Ressourcen zu, falls sie den gleichen Pfad und die gleiche ID benutzen.
Fehler: ftok gibt -1 zurück, falls die Datei in Path nicht vorhanden ist.
Siehe auch: semget, shmget und msgget.
Beispiele für die Funktion sind bei msgctl, semctl und shmctl gezeigt.
MSGCTL
function msgctl(msqid: cint; cmd: cint; buf: PMSQid_ds): cint;
msgctl führt verschiedene Operationen in der Botschafts-Warteschlange mit der ID msqid
aus. Die Operation hängt vom cmd-Parameter ab, der folgende Werte annehmen kann:
IPC_STAT Die Funktion msgctl füllt den Record TMSQid_ds mit Informationen über die
Botschafts-Warteschlange, wenn der cmd-Parameter IPC_STAT entspricht.
IPC_SET Wenn cmd den Wert IPC_SET enthält, wird buf als Zeiger auf einen Record vom
Typ ipc_perm interpretiert und setzt die Rechte der Warteschlange entsprechend
dem Inhalt des Records.
IPC_RMID Die Botschafts-Warteschlange wird aus dem System entfernt, wenn IPC_RMDIR
als Wert des Parameters übergeben wird.
buf enthält die jeweils geforderten Daten. Wenn die Warteschlange entfernt werden soll,
kann der Parameter NIL sein, da keine zusätzlichen Daten benötigt werden.
Die Funktion liefert true, falls erfolgreich, ansonsten false.
Fehler: Bei einem Fehler wird false zurückgegeben und IPCerror entsprechend gesetzt.
Siehe auch: msgget, msgsnd und msgrcv.
program msgtool; (* ipcex/msgtool.pp *)
uses
ipc, baseunix;
type
PMyMsgBuf = ^TMyMsgBuf;
TMyMsgBuf = record
mtype: LongInt;
mtext: String[255];
end;
procedure DoError(const Msg: String);

begin
WriteLn(msg, ’ returned an error: ’, fpgeterrno);
Halt(1);
end;
procedure SendMessage(Id: LongInt; var Buf: TMyMsgBuf;

MType: LongInt; const MText: String);
begin
WriteLn(’Sending message.’);
Buf.mtype := mtype;
Buf.Mtext := mtext;
if msgsnd(Id, PMsgBuf(@Buf), 256, 0) = -1 then DoError(’msgsnd’);
end;
procedure ReadMessage(ID: LongInt; var Buf: TMyMsgBuf; MType: LongInt);

begin
WriteLn(’Reading message.’);
Buf.MType := MType;
if msgrcv(ID, PMSGBuf(@Buf), 256, mtype, 0) <> -1 then
WriteLn(’type: ’, buf.mtype, ’ Text: ’, buf.mtext)
else
DoError(’msgrcv’);
end;
procedure RemoveQueue(ID: LongInt);

begin
if msgctl(id, IPC_RMID, NIL) <> -1 then
WriteLn(’Removed Queue with id ’, Id);
end;
procedure ChangeQueueMode(ID, mode: LongInt);

var
QueueDS: TMSQid_ds;
begin
if msgctl(Id, IPC_STAT, @QueueDS) = -1 then DoError(’msgctl: stat’);
WriteLn(’Old permissions: ’, QueueDS.msg_perm.mode);
QueueDS.msg_perm.mode := Mode;
if msgctl(ID, IPC_SET, @QueueDS) = 0 then
WriteLn(’New permissions: ’, QueueDS.msg_perm.mode)
else
DoError(’msgctl: IPC_SET’);
end;
procedure Usage;
begin
WriteLn(’Usage: msgtool s(end) <type> <text> (max 255 characters)’);
WriteLn(’ r(eceive) <type>’);

Kapitel 4.20 Unit ipc – msgget O99
WriteLn(’ d(elete)’);
WriteLn(’ m(ode) <decimal mode>’);
Halt(1);
end;
function StrToInt(S: String): LongInt;

var
M: LongInt;
C: Integer;
begin
Val(S, M, C);
if C <> 0 then DoError(’StrToInt: ’ + S);
StrToInt := M;
end;
var
Key: TKey;
ID : LongInt;
Buf: TMyMsgBuf;
const
ipckey = ’.’#0;
begin
if ParamCount < 1 then Usage;
key := Ftok(@ipckey[1], Ord(’M’));
ID := msgget(key, IPC_CREAT or 438);
if ID < 0 then DoError(’MsgGet’);
case Upcase(Paramstr(1)[1]) of
’S’: if ParamCount <> 3 then Usage else
SendMessage(id, Buf, StrToInt(Paramstr(2)), Paramstr(3));
’R’: if ParamCount <> 2 then Usage else
ReadMessage(id, buf, StrToInt(Paramstr(2)));
’D’: if ParamCount <> 1 then Usage else
RemoveQueue(ID);
’M’: if ParamCount <> 2 then Usage else
ChangeQueueMode(id, StrToInt(Paramstr(2)));
else Usage
end;
end.
MSGGET
function msgget(key: TKey; msgflg: cint): cint;
msgget gibt die ID der Meldungswarteschlange zurück, die von TKey beschrieben wird.
Abhängig von den Flags in msgflg wird eine neue Warteschleife erzeugt.
msgflg kann einen oder mehrere der folgenden Werte besitzen (mit OR verknüpft):
IPC_CREAT Die Warteschlange wird erzeugt, falls sie nicht schon angelegt ist.
IPC_EXCL Wenn das Flag in Verbindung mit IPC_CREAT benutzt wird und die Warte-
schlange schon vorhanden ist, wird der Befehl abgebrochen. Das Flag
kann nicht für sich allein stehen.
Optional können die Flags mit Zugriffsrechten über OR verknüpft werden. Die Zugriffs-
rechte kennen die gleichen Werte wie das Dateisystem.
Fehler: Bei einem Fehler wird -1 zurückgeliefert und IPCError wird gesetzt.
Siehe auch: ftok, msgsnd, msgrcv, msgctl, semget
Ein Beispiel ist bei msgctl gezeigt.
MSGRCV
function msgrcv(msqid: cint; msgp: PMSGbuf; msgsz: size_t;
msgtyp: cint; msgflg: cint): cint;
msgrcv ruft eine Botschaft des Typs msgtyp aus der Botschafts-Warteschlange mit der ID
msqid ab. msgtyp enthält den Typ, den die Botschaft besitzen soll, entspricht also dem
mtype-Feld des TMSGbuf-Records. Die Botschaft wird in der durch msgp angegebenen
MSGbuf-Struktur gespeichert.
Der Parameter msgflg kann zu Steuerung des Verhaltens des msgrcv-Befehls herangezogen
werden. Der Parameter kann aus einer OR-Verknüpfung der folgenden Werte bestehen:
0 Keine besondere Bedeutung.

IPC_NOWAIT Falls keine Meldungen verfügbar sind, erzeugt der Befehl sofort einen
ENOMSG-Fehler.
MSG_NOERROR Falls die Botschaft zu groß ist, wird kein Fehler erzeugt, sondern die
Botschaft gekürzt. Normalerweise liefert der Befehl in solchen Fällen
einen Fehler (E2BIG).
Die Funktion liefert true, wenn die Botschaft korrekt empfangen wurde, ansonsten false.
Fehler: Bei einem Fehler wird false zurückgegeben und IPCerror gesetzt.
Siehe auch: msgget, msgsnd, msgctl.
Zum Beispiel siehe msgctl.
MSGSND
function msgsnd(msqid: cint; msgp: PMSGbuf;
msgsz: size_t;
msgflg: cint): cint;
msgsnd sendet eine Botschaft mit der ID msqid an die Botschaftswarteschlange. msgp
akzeptiert einen Zeiger auf einen Message-Record, der auf dem Typ TMsgBuf basieren
sollte. msgsiz ist die Größe der Botschaft (nicht des gesamten Message-Records!).
Die Variable msgflg kann aus folgenden Werten zusammengesetzt sein (Verknüpfung mit
OR):
0 Hat keine spezielle Bedeutung. Die Botschaft wird an die Warteschlange an-
gehängt. Falls die Warteschlange voll ist, wird der aufrufende Prozeß blockiert,
bis die Warteschlange wieder Botschaften aufnehmen kann.
IPC_NOWAIT Falls die Warteschlange voll ist, wird die Botschaft verworfen und der Befehl
kehrt sofort zurück.
Die Funktion liefert true, falls die Meldung erfolgreich gesendet wurde, ansonsten false.
Fehler: Bei einem Fehler liefert der Befehl false und IPCerror wird gesetzt.
Siehe auch: msgget, msgrcv, seefmsgctl
Ein Beispiel befindet sich unterhalb zur Erklärung zu msgctl.
SEMCTL
function semctl(semid: cint; semnum: cint; cmd: cint; var arg: TSEMun): cint;
semctl führt verschiedene Operationen auf die Nachricht semnum im Signalsystem mit
der ID semid aus.
Der Parameter arg wird je nach auszuführender Operation verschieden interpretiert. Es
gibt folgende Darstellungen des varianten Records:

Kapitel 4.20 Unit ipc – semctl O101
type
TSEMun = record
case LongInt of
0: (val : LongInt);
1: (buf : PSEMid_ds);
2: (arr : PWord);
3: (padbuf: PSeminfo);
4: (padpad: Pointer);
end;
Welche Operation ausgeführt wird, hängt vom Parameter cmd ab, der einen der folgen-
den Werte annehmen kann:
IPC_STAT In diesem Fall sollte das Feld buf des Parameters arg gesetzt sein und die
Adresse eines TSEMid_ds-Records enthalten. Der Befehl semctl füllt diese Struk-
tur TSEMid_ds mit Informationen über das Signalsystem.
IPC_SET In diesem Fall sollte wiederum das Feld buf von arg die Adresse eines TSE-
Mid_ds-Records enthalten. Die Zugriffsrechte des Signalsystems werden gemäß
den Angaben im ipc_perm-Record festgelegt.
IPC_RMID Mit diesem Kommando wird das Signalsystem entfernt.
GETALL In diesem Fall sollte das Feld arr von arg auf einen Speicherbereich verweisen,
in dem die Werte der Signale gespeichert werden. Die Größe dieses Speicher-
bereiches ist »SizeOf(Word) * Anzahl der Signale im System«. Dieser Aufruf füllt
dann das Array mit den Werten der Signale.
GETNCNT Das Feld val des varianten Records ist bei diesem Befehl gültig und enthält
nach dem Aufruf die Anzahl der Prozesse, die auf Ressourcen warten.
GETPID semctl gibt die Prozeß-ID des Prozesses zurück, der den letzten semop-Befehl
ausführte.
GETVAL semctl gibt den Wert des Signals mit der Nummer semnum zurück.
GETZCNT semctl gibt die Anzahl der Prozesse zurück, die darauf warten, daß Signale den
Wert Null erreichen.
SETALL In diesem Fall sollte das Feld arr von arg auf einen Speicherbereich verweisen,
in dem die neuen Werte der Signale gespeichert sind. Diese Werte überschrei-
ben bei Angabe von SETALL dann die bisherigen Einstellungen. Die Größe des
Speicherbereichs kann zu »SizeOf(Word) * Anzahl der Signale im System« er-
mittelt werden.
SETVAL Der Wert des Signals Nummer semnum wird auf den Wert des Feldes val des
Parameters arg gesetzt.
Fehler: Bei einem Fehler liefert die Funktion -1 und IPCerror wird entsprechend gesetzt.
Siehe auch: semget und semop.
program semtool; (* ipcex/semtool.pp *)
(* program to demonstrate the use of semaphores *)
uses
ipc, baseunix;
const
MaxSemValue = 5;
procedure DoError(const Msg: String);

begin
WriteLn(’Error: ’,msg,’ Code: ’, fpgeterrno);
Halt(1);
end;
function getsemval(ID, Member: LongInt): LongInt;
var
S: TSEMun;
begin
GetSemVal := SemCtl(id, Member, SEM_GETVAL, S);
end;
procedure DispVal(ID, Member: LongInt);

begin
WriteLn(’Value for Member ’, Member, ’ is ’, GetSemVal(ID, Member));
end;
function GetMemberCount(ID: LongInt): LongInt;

var
opts : TSEMun;
semds: TSEMid_ds;
begin
opts.buf := @semds;
if semctl(Id, 0, IPC_STAT,opts) <> -1 then
GetMemberCount := semds.sem_nsems
else
GetMemberCount := -1;
end;
function OpenSem(Key: TKey): LongInt;

begin
OpenSem := semget(Key, 0, 438);
if OpenSem = -1 then DoError(’OpenSem’);
end;
function CreateSem(Key: TKey; Members: LongInt): LongInt;

var
Count : LongInt;
Semopts: TSemun;
begin
// the semmsl constant seems kernel specific
if Members > semmsl then
DoError(’Sorry, maximum number of semaphores in set exceeded’);
WriteLn(’Trying to create a new semaphore set with ’, Members, ’ Members.’);
CreateSem := semget(key, Members, IPC_CREAT or IPC_Excl or 438);
if CreateSem = -1 then DoError(’Semaphore set already exists.’);
Semopts.Val := MaxSemValue;
// Initial value of semaphores
for Count := 0 to Members - 1 do semctl(CreateSem,count,SEM_SETVAL,semopts);
end;
procedure lockSem(ID, Member: LongInt);

var
lock: TSEMbuf;
begin
with lock do begin
sem_num := 0;
sem_op := -1;
sem_flg := IPC_NOWAIT;
end;
if (Member < 0) or (Member > GetMemberCount(ID) - 1) then
DoError(’semaphore Member out of range’);
if getsemval(ID, Member) = 0 then DoError(’Semaphore resources exhausted (no lock)’);
lock.sem_num := Member;
Kapitel 4.20 Unit ipc – semctl O103
WriteLn(’Attempting to lock Member ’, Member, ’ of semaphore ’, ID);
if semop(Id, @lock, 1) = -1 then
DoError(’Lock failed’)
else
WriteLn(’Semaphore resources decremented by one’);
dispval(ID,Member);
end;
procedure UnlockSem(ID, Member: LongInt);

var
Unlock: TSEMbuf;
begin
with Unlock do begin
sem_num := 0;
sem_op := 1;
sem_flg := IPC_NOWAIT;
end;
if (Member < 0) or (Member > GetMemberCount(ID) - 1) then
DoError(’semaphore Member out of range’);
if getsemval(ID,Member) = MaxSemValue then DoError(’Semaphore not locked’);
Unlock.sem_num := Member;
WriteLn(’Attempting to unlock Member ’,
Member, ’ of semaphore ’, ID);
if semop(Id, @unlock, 1) = -1 then DoError(’Unlock failed’)
else
WriteLn(’Semaphore resources incremented by one’);
dispval(ID,Member);
end;
procedure RemoveSem(ID: LongInt);

var
S: TSemun;
begin
if semctl(Id, 0, IPC_RMID, s) <> -1 then WriteLn(’Semaphore removed’)
else DoError(’Couldn’’t remove semaphore’);
end;
procedure ChangeMode(ID, Mode: LongInt);

var
rc : LongInt;
opts : TSEMun;
semds: TSEMid_ds;
begin
opts.buf := @semds;
if not semctl(Id, 0, IPC_STAT, opts) <> -1 then DoError(’Couldn’’t stat semaphore’);
WriteLn(’Old permissions were: ’, semds.sem_perm.mode);
semds.sem_perm.mode := mode;
if semctl(id, 0, IPC_SET, opts) <> -1 then WriteLn(’Set permissions to ’, mode)
else DoError(’Couldn’’t set permissions’);
end;
procedure PrintSem(ID: LongInt);

var
I, cnt: LongInt;
begin
cnt := getMembercount(ID);
WriteLn(’Semaphore ’, ID,’ has ’, cnt, ’ Members’);
for I := 0 to cnt - 1 do DispVal(id,i);
end;
procedure Usage;
begin
WriteLn(’Usage: semtool c(reate) <count>’);
WriteLn(’ l(ock) <Member>’);
WriteLn(’ u(nlock) <Member>’);
WriteLn(’ m(ode) <mode>’);
Halt(1);
end;
function StrToInt(S: String): LongInt;

var
M: LongInt;
C: Integer;
begin
Val(S, M, C);
if C <> 0 then DoError(’StrToInt: ’ + S);
StrToInt := M;
end;
var
Key: TKey;
ID : LongInt;
const
ipckey=’.’#0;
begin
key := ftok(@ipckey[1], Ord(’s’));
case UpCase(Paramstr(1)[1]) of
’C’: begin
if ParamCount <> 2 then Usage;
CreateSem(key, StrToInt(ParamStr(2)));
end;
’L’: begin
ID := OpenSem(key);
LockSem(ID, StrToInt(ParamStr(2)));
end;
’U’: begin
ID := OpenSem(key);
UnLockSem(ID, StrToInt(ParamStr(2)));
end;
’M’: begin
ID := OpenSem(key);
ChangeMode(ID, StrToInt(ParamStr(2)));
end;
’D’: Begin
ID := OpenSem(Key);
RemoveSem(Id);
end;
’P’: begin
ID := OpenSem(Key);
PrintSem(Id);
end;
else Usage
end;
end.

Kapitel 4.20 Unit ipc – semget O105
SEMGET
function semget(key: TKey; nsems: cint; semflg: cint): cint;
semget gibt die ID des durch key beschriebenen Signalsystems zurück. In Abhängigkeit
vom Inhalt des Parameters semfls können die folgenden Aktionen durchgeführt werden
(Verknüpfung über OR möglich):
IPC_CREAT Das System wird angelegt, falls es noch nicht vorhanden ist.
IPC_EXCL Dieses Flag kann nur zusätzlich zur IPC_CREAT-Option angegeben werden
und bewirkt einen Fehler, wenn das Signalsystem bereits vorhanden ist.
Die Flags können mit Zugriffsrechten über OR verknüpft werden, die die gleichen Werte
wie ihre Pendants im Dateisystem haben.
Falls ein neues Signalsystem erzeugt wurde, kann dieses nsems Signale aufnehmen.
Fehler: Bei einem Fehler wird -1 zurückgegeben und IPCError wird gesetzt.
Siehe auch: ftok, semop und semctl.
SEMOP
function semop(semid: cint; sops: PSEMbuf; nsops: cuint): cint;
semop führt eine Reihe von Operationen auf verschiedene Signale durch. sops zeigt auf ein
Array vom Typ TSEMbuf. Das Array sollte nsops Elemente enthalten.
Das Feld einer TSEMbuf-Struktur
TSEMbuf = record
sem_num : Word;
sem_op : Integer;
sem_flg : Integer;
end;
sollte mit folgenden Werten gefüllt sein:
sem_num Die Nummer des Signals im System, auf die die Operation durchgeführt werden
soll.
sem_op Die auszuführende Operation. Sie kann folgende Werte annehmen:
1 Eine positive Zahl wird zum aktuellen Wert des Signals addiert.
2 Falls 0 (Null) angegeben wurde, wird der Prozeß angehalten, bis das spezifi-
zierte Signal den Wert Null erreicht hat.
3 Falls eine negative Zahl angegeben ist, wird sie vom aktuellen Wert des Signals
subtrahiert. Wenn der Wert des Signals dabei negativ wird, wird der Prozeß
angehalten, bis der Wert wieder groß genug wird. Mit Angabe des
IPC_NOWAIT-Flags in sem_flg kann dieses Verhalten umgangen werden.
sem_flg Falls IPC_NOWAIT angegeben wurde, wird der aufrufende Prozeß nie angehalten.
Die Funktion liefert True, falls die Operationen erfolgreich waren, ansonsten False.
Fehler: Bei einem Fehler wird False zurückgeliefert und IPCerror wird gesetzt.
Siehe auch: semget und semctl.
SHMAT
function shmat(ShmID: cint; shmaddr: Pointer; shmflg: cint): Pointer;
shmat bindet einen gemeinsam nutzbaren Speicherblock mit der ID shmid an den aktuel-
len Prozeß und gibt einen Zeiger auf diesen zurück. Falls shmaddr gleich NIL ist, wählt
das System einen bisher nicht zugeteilten Speicherbereich aus, der sich so hoch wie mög-
lich im Adreßraum befindet. Falls shmaddr verschieden von NIL ist und SHM_RND in
shmflg angegeben ist, wird shmaddr auf SHMLBA abgerundet. Falls SHM_RND nicht
angegeben wurde, muß shmaddr an Seitengrenzen ausgerichtet sein.
Der Parameter shmflg kann das Verhaltens von shmat steuern und folgende Werte an-
nehmen (Verknüpfung mit OR):
SHM_RND Die angegebene Adresse in shmaddr wird zu SHMLBA abgerundet.

SHM_RDONLY Es besteht nur Lesezugriff auf den Speicherblock, wenn diese Option ange-
geben wurde, ansonsten wird der Speicher für Lesen und Schreiben hinzuge-
fügt. Die Applikation braucht Lese- und Schreibzugriff, um den geteilten
Speicher zu verwalten.
Fehler: Bei einem Fehler wird -1 zurückgeliefert und IPCError wird gesetzt.
Siehe auch: shmget, shmdt, shmctl.
Zum Beispiel siehe shmctl.
SHMCTL
function ShmCtl(ShmID: cint; cmd: cint; buf: PShmid_DS): cint;
shmctl führt verschiedene Operationen auf den gemeinsam nutzbaren Speicherblock aus,
der durch die ID shmid identifiziert wird.
Der Parameter buf zeigt auf einen TSHMid_ds-Record, der für die Operation verwendet
werden soll. Der Parameter cmd bestimmt, welche Operation ausgeführt werden soll.
Folgende Werte sind möglich:
IPC_STAT shmctl füllt den TSHMid_ds-Record, auf den buf verweist, mit Informationen
über den gemeinsam genutzten Speicherblock.
IPC_SET shmctl wendet die Werte im ipc_perm-Record auf den Speicherblock an.
IPC_RMID shmctl entfernt den Speicherblock aus dem System (nachdem alle Prozesse sich
von ihm abgekoppelt haben). Falls erfolgreich, liefert die Funktion True, anson-
sten False.
Fehler: Bei einem Fehler wird false zurückgeliefert und IPCError wird gesetzt.
Siehe auch: shmget, shmat und shmdt.
program shmtool; (* ipcex/shmtool.pp *)
uses
ipc, Strings, Baseunix;
const
SegSize = 100;
var
key : TKey;
ShmID, cntr: LongInt;
SegPtr : PChar;
procedure Usage;
begin
WriteLn(’Usage: shmtool w(rite) text’);
WriteLn(’ r(ead)’);
WriteLn(’ m(ode change) mode’);
Halt(1);
end;

Kapitel 4.20 Unit ipc – shmctl O107
procedure Writeshm(ID: LongInt; ptr: PChar; S: String);
begin
StrCopy(ptr, s);
end;
procedure ReadSHM(ID: LongInt; ptr: PChar);

begin
WriteLn(’Read: ’,ptr);
end;
procedure RemoveSHM(ID: LongInt);

begin
ShmCtl(ID, IPC_RMID, NIL);
WriteLn(’Shared memory marked for deletion’);
end;
procedure ChangeMode(ID: LongInt; mode: String);

var
m : Word;
code: Integer;
data: TSHMid_ds;
begin
Val(mode, m, code);
if code <> 0 then Usage;
if ShmCtl(ShmID, IPC_STAT, @data) = -1 then begin
WriteLn(’Error: ShmCtl: ’, fpgeterrno);
Halt(1);
end;
WriteLn(’Old permissions: ’, data.shm_perm.mode);
data.shm_perm.mode := m;
if ShmCtl(ShmID, IPC_SET, @data) = -1 then begin
WriteLn(’Error: ShmCtl :’, fpgeterrno);
Halt(1);
end;
WriteLn(’New permissions: ’, data.shm_perm.mode);
end;
const
ftokpath = ’.’#0;
begin
key := ftok(PChar(@ftokpath[1]), Ord(’S’));
ShmID := shmget(key, segsize, IPC_CREAT or IPC_EXCL or 438);
if ShmID = -1 then begin
WriteLn(’Shared memory exists. Opening as client’);
ShmID := shmget(key, segsize, 0);
if ShmID = -1 then begin
WriteLn(’shmget: Error!’, fpgeterrno);
Halt(1);
end
end else
WriteLn(’Creating new shared memory segment.’);
SegPtr := shmat(ShmID, NIL, 0);
if LongInt(SegPtr) = -1 then begin
WriteLn(’Shmat: error!’, fpgeterrno);
Halt(1);
end;
case Upcase(ParamStr(1)[1]) of
’W’: writeshm(ShmID, SegPtr, ParamStr(2));
’R’: ReadSHM(ShmID, SegPtr);
’D’: RemoveSHM(ShmID);
’M’: ChangeMode(ShmID, ParamStr(2));
else
WriteLn(ParamStr(1));
Usage;
end;
end.
SHMDT
function shmdt(shmaddr: Pointer): cint;
shmdt trennt den Speicher der Adresse shmaddr vom Prozeß ab. Dieser Speicherblock ist
für den aktuellen Prozeß nicht mehr zugänglich, bis er durch einen shmat-Befehl wieder
angefügt wird.
Die Funktion liefert true, falls der Speicherblock erfolgreich abgetrennt wurde, sonst False.
Fehler: Bei einem Fehler wird False zurückgeliefert und IPCError wird gesetzt.
Siehe auch: shmget, shmat, shmctl
SHMGET
function shmget(key: TKey; size: size_t; flag: cint): cint;
shmget liefert die ID des gemeinsam nutzbaren Speicherblocks, der durch key beschrieben
wird. Abhängig von den Flags in flag wird ein neuer Speicherblock erstellt.
flag kann einen oder mehreren der folgenden Werte annehmen (Kombination mit OR):
IPC_CREAT Die Warteschlange wird angelegt, falls sie nicht schon vorhanden ist.
IPC_EXCL Kann nur in Kombination mit IPC_CREAT angegeben werden und führt zu
einem Fehler, falls der Speicherblock bereits vorhanden ist.
Optional können die Flags noch mit Zugriffsrechten verknüpft werden, deren Werte den
Zugriffsrechten von Dateien entsprechen.
Wird ein neuer Speicherblock erstellt, hat er die Größe Size.
Fehler: Bei einem Fehler wird -1 zurückgegeben und IPCError gesetzt.
Siehe auch: shmat, shmdt, shmctl
4.21 Unit Video

Die Unit Video stellte eine systemunabhängige Zwischenschicht für den Zugriff auf den
Bildschirm zur Verfügung, weshalb auf allen Plattformen, für die die Unit zur Verfügung
gestellt ist, einheitlich auf den Textbildschirm geschrieben werden kann.
Die Arbeitsweise der Bildschirmroutinen ist sehr einfach. Nach dem Aufruf von InitVideo
enthält das Array VideoBuf eine Zwischenspeicherung des Bildschirms der Größe
ScreenWidth*ScreenHeight und zwar von links nach recht und oben nach unten, wenn man
die Elemente des Arrays durchläuft. VideoBuf[0] enthält damit das Zeichen und den Farb-
code der obersten linken Ecke des Bildschirms und VideoBuf[ScreenWidth] die Daten für
die Zeichen in der ersten Spalte in der zweiten Reihe auf dem Bildschirm und so weiter.
Um in diesen »Bildschirm« zu schreiben, muß der Text in das Array VideoBuf geschrie-
ben werden. Der Aufruf von UpdateScreen kopiert dann den Text in möglichst idealer
Form in den Bildschirm, was in diesem Kapitel auch noch an einem Beispiel gezeigt wird.
Das Attribut für die Farbe ist eine Kombination aus Vordergrund- und Hintergrundfarbe,
ergänzt um das Blinkbit. Die folgenden Bitangaben beschreiben die diversen Farbkombi-
nationen:

Kapitel 4.21 Unit Video – Allgemeines O109
Bit 0-3 Die Vordergrundfarbe, hierfür können alle Farbkonstanten eingesetzt werden.
Bit 4-6 Die Hintergrundfarbe, sie kann auf einen Teilbereich der dunklen Farben der Farb-
konstanten gesetzt werden.
Bit 7 Das Blinkbit. Ist es gesetzt, blinkt das Zeichen auf dem Bildschirm.
ALLGEMEINES
Jede mögliche Farbe hat eine zugeordnete Konstante, die alle in der Liste der Konstanten
ab Seite O113 aufgeführt sind. Die Vordergrund- und die Hintergrundfarbe können auch
direkt zu einem Farbattribut verschmolzen werden:
Attr := ForeGroundColor + (BackGroundColor shl 4);
Außerdem kann das Farbattribut auch über ein logisches OR mit dem Blinkattribut zu-
sammengefügt werden, um ein blinkendes Zeichen zu erreichen:
Attr := Attr or blink;
Es darf aber nicht unerwähnt bleiben, daß diese Optionen nicht von allen Treibern unter-
stützt werden.
Der Inhalt des Arrays VideoBuf kann verändert werden. Das entspricht einem »Schrei-
ben« auf den Bildschirm. Sind alle Daten in diesen virtuellen Bildschirm geschrieben,
wird der Bildschirmpuffer wieder mit dem bereits erwähnten UpdateScreen in den wirkli-
chen Bildschirmspeicher übertragen.
Die Aktualisierung des Bildschirms kann, um die Arbeit zu beschleunigen, verboten wer-
den. Dafür ist die Funktion LockScreenUpdate vorgesehen, die einen internen Zähler erhöht.
Solange er größer als 0 ist, bewirkt der Aufruf von UpdateScreen nichts. Der Zähler wird mit
UnlockScreenUpdate wieder verringert. Hat er den Wert 0 erreicht, aktualisiert der nächste
Aufruf von UpdateScreen die Bildschirmdaten. Dies ist vor allem dann sinnvoll, wenn ver-
schachtelte Funktionen eine große Zahl von Bildschirmausgaben tätigen.
Die Unit Video besitzt auch eine Schnittstelle, um eigene Bildschirmtreiber zu schreiben.
Damit ist es möglich, den voreingestellten Bildschirmtreiber mit einem eigenen zu über-
schreiben. Wie das geht, ist bei der Funktion SetVideoDriver erläutert. Der aktuelle Bild-
schirmtreiber kann mit GetVideoDriver ermittelt werden.
Hinweis: Die Unit Video sollte nicht gleichzeitig mit der veralteten an Turbo Pascal ange-
lehnten Unit Crt verwendet werden. Das führt zu recht seltsamem Programm- und Bild-
schirmverhalten und Abstürze sind wahrscheinlich.
Die Beispiele in diesem Abschnitt rufen außer der Unit Video auch die Unit VidUtil auf,
die als einzige Routine die Prozedur TextOut enthält. Sie schreibt einen Text an der ange-
gebenen Stelle auf den Bildschirm und sieht folgendermaßen aus:
unit vidutil;
interface
uses
video;
procedure TextOut(X, Y: Word; const S: String);
implementation
procedure TextOut(X, Y: Word; const S : String);

var
W, P, I, M: Word;
begin
P := ((X-1) + (Y-1) * ScreenWidth);
M := Length(S);
if P + M > ScreenWidth * ScreenHeight then
M := ScreenWidth*ScreenHeight - P;
for I := 1 to M do VideoBuf^[P + I - 1] := Ord(S[i]) + ($07 shl 8);
end;
end.
4.21.1 Schreiben eines eigenen Bildschirmtreibers

Das Schreiben eines eigenen Bildschirmtreibers ist gar nicht kompliziert und bedeutet
eigentlich nur, daß eine Reihe von Funktionen, die mit SetVideoDriver registriert werden,
geschrieben werden müssen. Die verschiedenen zur Implementierung zur Verfügung
stehenden Funktionen sind im Record TVideoDriver enthalten:
TVideoDriver = record
InitDriver : procedure;
DoneDriver : procedure;
UpdateScreen : procedure(Force: Boolean);
ClearScreen : procedure;
SetVideoMode : function(const Mode: TVideoMode): Boolean;
GetVideoModeCount: function: Word;
GetVideoModeData : function(Index : Word; var Data: TVideoMode): Boolean;
SetCursorPos : procedure(NewCursorX, NewCursorY: Word);
GetCursorType : function: Word;
SetCursorType : procedure(NewType: Word);
GetCapabilities : function: Word;
end;
Es müssen allerdings nicht alle diese Funktionen neu implementiert werden, notwendig
ist nur UpdateScreen. Die allgemeinen Funktionen in der Unit Video prüfen, welche
Funktionalität der Treiber zur Verfügung stellt. Die Funktionalität dieser Aufrufe ist die
selbe wie bei den in diesem Kapitel beschriebenen Aufrufen der Unit Video, womit das
erwartete Verhalten aus den Beschreibungen in diesem Abschnitt erschlossen werden
kann. Einige der Aufrufe benötigen allerdings ein paar zusätzliche Hinweise:
InitDriver Diese Prozedur wird von InitVideo aufgerufen. Sie sollte alle Daten-
strukturen, die für die Funktionsfähigkeit des Treibers benötigt werden,
bereitstellen und möglicherweise auch die Bildschirminitialisierungen.
Es muß dafür gesorgt sein, daß die Prozedur garantiert nur einmal
aufgerufen wird, ein erneuter Aufruf darf nur nach einem DoneVideo
erfolgen. Die Variablen ScreenWidth und ScreenHeight sollten nach
einem Aufruf dieser Prozedur richtig initialisiert sein, da InitVideo die
beiden Bildschirmpuffer VideoBuf und OldVideoBuf auf den Werten
dieser Variablen initialisiert.
DoneDriver Diese Prozedur sollte alle von InitDriver aufgebauten Strukturen wieder
freigeben. Außerdem sollte möglichst auch der Bildschirm auf die
Werte vor der Initialisierung des Treibers zurückgesetzt werden.
Die beiden Arrays VideoBuf und OldVideoBuf werden vom allgemeinen
Aufruf DoneVideo wieder freigegeben.
UpdateScreen Die einzige unbedingt notwendige Funktion des Treibers. Sie sollte den
Bildschirm auf Basis des Inhalts des Arrays VideoBuf aktualisieren.
Dieser Vorgang wird optimiert, indem die Werte gegen die des Arrays
OldVideoBuf abgeglichen werden.
Nach dem Aktualisieren des Bildschirms muß die Prozedur Update-
Screen den Puffer OldVideoBuf eigenständig aktualisieren.
Ist der Parameter Force auf True gesetzt, wird der gesamte Bildschirm
aktualisiert, nicht nur die geänderten Werte.

Kapitel 4.21 Unit Video – Allgemeines O111
ClearScreen Wenn es eine schnellere Möglichkeit gibt, den Bildschirm zu löschen,
als alle Zeichenzellen mit Leerzeichen zu überschreiben, kann das an
dieser Stelle eingebaut werden. Ist diese Funktion im Treiber nicht
implementiert, schreibt die allgemeine Routine Leerzeichen in alle
Bildschirmzellen und ruft anschließend die Prozedur Update-
Screen(True) auf.
SetVideoMode Diese Funktion setzt, falls sie verfügbar ist, den gewünschten Bild-
schirmmodus. Sie sollte True zurückgeben, wenn der Bildschirmmodus
gesetzt werden konnte und False, wenn nicht.
GetVideoModeCount Sollte die Zahl der unterstützten Bildschirmmodi melden. Falls keine
unterschiedlichen Bildschirmmodi erkannt werden, sollte diese Funktion
nicht implementiert werden, die allgemeine Routine gibt 1 zurück (was
für den aktuellen Modus steht).
GetVideoModeData Diese Funktion sollte die Daten für den Modus mit dem angegebenen
Index melden. Index ist nullbasiert. Die Funktion sollte True zurückge-
ben, wenn die Daten richtig gemeldet wurden, und False, wenn in
Index ein ungültiger Wert angegeben wurde.
Ist diese Funktion nicht implementiert, gibt die allgemeine Routine die
Daten des aktuellen Bildschirmmodus zurück, wenn für Index der Wert
0 angegeben ist.
GetCapabilities Ist diese Funktion nicht implementiert, wird von der allgemeinen Funk-
tion 0 (das heißt, keine Fähigkeiten) zurückgegeben.
Die folgende Unit zeigt, wie ein Bildschirmtreiber mit einem Treiber, der Debuginforma-
tionen in eine Datei ausgibt, überschrieben wird. Die Unit kann in Beispielprogramme
eingebunden werden, indem sie einfach der Uses-Klausel hinzugefügt wird. Das Setzen
von DetailedVideoLogging auf True erzeugt ein detailliertes Protokoll, bremst dabei aber
das Programm stark ab.
unit viddbg;
interface
uses
video;
procedure StartVideoLogging;
procedure StopVideoLogging;
function IsVideoLogging: Boolean;
procedure SetVideoLogFileName(FileName: String);
const
DetailedVideoLogging: Boolean = False;
implementation
uses
sysutils, keyboard;
var
NewVideoDriver,
OldVideoDriver : TVideoDriver;
Active,Logging : Boolean;
LogFileName : String;
VideoLog : Text;
function TimeStamp: String;
begin
TimeStamp := FormatDateTime(’hh:nn:ss’, Time());
end;
procedure StartVideoLogging;
begin
Logging := true;
WriteLn(VideoLog, ’Start logging video operations at: ’, TimeStamp);
end;
procedure StopVideoLogging;
begin
WriteLn(VideoLog, ’Stop logging video operations at: ’, TimeStamp);
Logging := false;
end;
function IsVideoLogging: Boolean;

begin
IsVideoLogging := Logging;
end;
var
ColUpd, RowUpd: array[0..1024] of Integer;
procedure DumpScreenStatistics(Force: Boolean);

var
I, Count: Integer;
begin
if Force then Write(VideoLog, ’forced ’);
WriteLn(VideoLog, ’video update at ’, TimeStamp, ’ : ’);
FillChar(Colupd, SizeOf(ColUpd), #0);
FillChar(Rowupd, SizeOf(RowUpd), #0);
Count := 0;
for I := 0 to VideoBufSize div SizeOf(TVideoCell) do begin
if VideoBuf^[i] <> OldVideoBuf^[i] then begin
Inc(Count);
Inc(ColUpd[I mod ScreenWidth]);
Inc(RowUpd[I div ScreenHeight]);
end;
end;
Write(VideoLog, Count, ’ videocells differed divided over ’);
Count := 0;
for I := 0 to ScreenWidth - 1 do
if ColUpd[I] <> 0 then Inc(Count);
Write(VideoLog, Count, ’ columns and ’);
Count := 0;
for I := 0 to ScreenHeight - 1 do if RowUpd[I] <> 0 then Inc(Count);
WriteLn(VideoLog,Count,’ rows.’);
if DetailedVideoLogging then begin
for I:=0 to ScreenWidth - 1 do
if ColUpd[I] <> 0 then
Writeln(VideoLog, ’Col ’, i, ’ : ’, ColUpd[I]:3, ’ rows changed’);
for I := 0 to ScreenHeight - 1 do
if RowUpd[I] <> 0 then
WriteLn(VideoLog, ’Row ’, i, ’ : ’, RowUpd[I]:3, ’ colums changed’);
end;
end;

Kapitel 4.21 Unit Video – Konstanten, Typen und Variablen O113
procedure LogUpdateScreen(Force: Boolean);

begin
if Logging then DumpScreenStatistics(Force);
OldVideoDriver.UpdateScreen(Force);
end;
procedure LogInitVideo;
begin
OldVideoDriver.InitDriver;
Assign(VideoLog, logFileName);
Rewrite(VideoLog);
Active := true;
StartVideoLogging;
end;
procedure LogDoneVideo;
begin
StopVideoLogging;
Close(VideoLog);
Active := false;
OldVideoDriver.DoneDriver;
end;
procedure SetVideoLogFileName(FileName: String);

begin
if not Active then LogFileName := FileName;
end;
initialization
GetVideoDriver(OldVideoDriver);
NewVideoDriver := OldVideoDriver;
NewVideoDriver.UpdateScreen := @LogUpdateScreen;
NewVideoDriver.InitDriver := @LogInitVideo;
NewVideoDriver.DoneDriver := @LogDoneVideo;
LogFileName := ’Video.log’;
Logging := false;
SetVideoDriver(NewVideoDriver);
end.

Konstanten
Die folgenden Angaben stehen für die Farben des Textbildschirms:
KONSTANTEN, TYPEN UND VARIABLEN
Black = 0 Schwarz
Blue = 1 Blau
Green = 2 Grün
Cyan = 3 Türkis
Red = 4 Rot
Magenta = 5 Purpur
Brown = 6 Braun
LightGray = 7 Hellgrau
DarkGray = 8 Dunkelgrau
LightBlue = 9 Hellblau
LightGreen = 10 Hellgrün
LightCyan = 11 Helltürkis
LightRed = 12 Hellrot
LightMagenta = 13 Hellpurpur
Yellow = 14 Gelb
White = 15 Weiß
Blink = 128 Blinkend, falls der Treiber es erlaubt
Die Angaben von 0 bis 15 und 128 können nur für den Textvordergrund gewählt werden,
für den Hintergrund sind nur die Konstanten mit den Werten 0 bis 7 möglich.
Die nächsten Konstanten dienen der Abfrage der Möglichkeit des Bildschirmtreibers:
cpUnderLine = $0001 Bildschirmtreiber erlaubt unterstrichenen Text.

cpBlink = $0002 Bildschirmtreiber erlaubt blinkenden Text.
cpColor = $0004 Bildschirmtreiber ist farbfähig.
cpChangeFont = $0008 Bildschirmtreiber unterstützt das Austauschen der Schriftart.
cpChangeMode = $0010 Bildschirmtreiber erlaubt das Ändern des Bildschirmmodus.
cpChangeCursor = $0020 Bildschirmtreiber erlaubt das Ändern des Aussehens des
Textcursors.
Die folgenden Konstanten definieren das Aussehen des Text-Eingabecursors:
crHidden =0 Cursor ausgeblendet.

crUnderLine =1 Cursor nur unten (unterstrichen).
crBlock =2 Blockcursor.
crHalfBlock =3 Halber Blockcursor.
Fehlerkonstanten:
errOk =0 Kein Fehler

vioOK =0 Kein Fehler aufgetreten
ErrorCode: LongInt = ErrOK Der von der letzten Operation zurückgemeldete Fehlercode.
Der Fehlerhandler:
ErrorHandler: TErrorHandler = Die Variable ErrorHandler kann auf eine einige Fehlerbe-
@DefaultErrorHandler handlungsroutine gesetzt werden. Der Zeiger wird in der
Voreinstellung auf die Funktion DefaultErrorHandler ge-
setzt.
ErrorInfo : Pointer = nil Zeiger auf die erweiterten Fehlerinformationen.
Allgemeine Fehlerkonstanten:
errVioBase = 1000 Der Grundwert für Videofehler.

errVioInit = errVioBase +1 Bildschirmtreiber-Initialisierung ist fehlgeschla-
gen.
errVioNotSupported = errVioBase + 2 Nicht unterstützte Bildschirmfunktion.
errVioNoSuchMode = errVioBase + 3 Ungültiger Bildschirmmodus.
Kapitel 4.21 Unit Video – Konstanten, Typen und Variablen O115
Die Unit arbeitet auch mit unterschiedlichen Schriften, dafür sind die Codepages einmal
allgemein und einmal als VGA-Codepages definiert:
iso_codepages = iso_codepages ist eine Aufzählung mit allen Codepages

[iso01, iso02, iso03, iso04, iso05, basierend auf der ISO-Codierung.
iso06, iso07, iso08, iso09, iso10,
iso13, iso14, iso15]
vga_codepages = vga_codepages ist eine Aufzählung mit allen Codepages,
[cp437, cp850, cp852, cp866] bei denen mit normaler VGA-Karte ein VGA-Font ausge-
wählt werden kann. Zu beachten ist, daß dabei die Grafik-
zeichen an falschen Stellen in der Tabelle sind.
Einschränkungen des Zeichensatzes:
LowAscii = true Auf einigen Systemen sind die unteren 32 Zeichen (0 bis
31) der DOS-Codepage für die ASCII-Steuerzeichen erfor-
derlich und können von Programmen nicht angezeigt
werden.
Ist LowAscii auf True gesetzt, können die unteren 32 ASCII-
Zeichen genutzt werden, ist der Wert auf False gesetzt,
sollten sie vermieden werden.
LowAscii kann je nach Bedarf als Konstante, Variable oder
Property definiert werden, es darf aber unter keinen Um-
ständen erwartet werden, daß LowAscii geschrieben wer-
den kann oder die Adresse geholt werden kann.
NoExtendedFrame = false Der VT100-Zeichensatz kennt nur Linienzeichen mit einer
einfachen Linie. Ist dieser Wert auf True gesetzt, werden die
Zeichen zum Zeichnen von Linien automatisch immer auf
die einfachen Linien gesetzt und die doppelten Linienzei-
chen werden automatisch konvertiert.
NoExtendedFrame kann je nach Bedarf als Konstante,
Variable oder Property definiert werden, es darf aber unter
keinen Umständen erwartet werden, daß NoExtendedFra-
me geschrieben werden oder die Adresse geholt werden
kann.
Bildschirmdaten:
ScreenHeight: Word = 0 Die aktuelle Bildschirmhöhe, mit 0 vorbelegt.

ScreenWidth : Word = 0 Die aktuelle Bildschirmbreite, mit 0 vorbelegt.
FVMaxWidth = 132 Die größtmögliche Bildschirmpufferbreite in Zeichen.
Typdeklarationen
PVideoBuf = ^TVideoBuf;
Zeiger auf TVideoBuf.
PVideoCell = ^TVideoCell;
Zeiger auf TVideoCell.
PVideoMode = ^TVideoMode;
Zeiger auf den Record TVideoMode.
TEncoding = (cp437, cp850, cp852, cp866, koi8r, iso01, iso02, iso03, iso04, iso05,
iso06, iso07, iso08, iso09, iso10, iso13, iso14, iso15);
Dieser Datentyp ist nur auf unixartigen Betriebssystemen verfügbar.
Wert Beschreibung
cp437 Codepage 437 (Englisch, US-amerikanischer Standard)
cp850 Codepage 850 (Westeuropa, Eingabeaufforderungen bei deutscher Windows-
Version)
cp852 Codepage 852 (Mitteleuropa)
cp866 Codepage 866 (Russisch)
iso01 ISO 8859-1 (Latin 1, Mittel-/Westeuropa ohne Euro-Symbol)
iso02 ISO 8859-2 (Latin 2, Mitteleuropa, beispielsweise Polen)
iso03 ISO 8859-3 (Latin 3, Südeuropa)
iso04 ISO 8859-4 (Latin 4, Baltikum)
iso05 ISO 8859-5 (Kyrillisch)
iso06 ISO 8859-6 (Arabisch)
iso07 ISO 8859-7 (Griechisch)
iso08 ISO 8859-8 (Hebräisch)
iso09 ISO 8859-9 (Latin 5, Türkisch)
iso10 ISO 8859-10 (Latin 6, Nordisch)
iso13 ISO 8859-13 (Latin 7, Baltikum)
iso14 ISO 8859-14 (Latin 8, Westeuropa)
iso15 ISO 8859-15 (Latin 9, ISO 8859-1 mit Euro-Symbol, Mitteleuropa)
koi8r Codepage KOI8-R
Tabelle O4.9: Aufzählungswerte für den Datentyp TEncoding (Teil 2 von 2)
TErrorHandler = function(Code: LongInt;

Sprache

Lazarus Free Pascal

Hochgeladen von

Dokumentinformationen

Copyright

Verfügbare Formate

Dieses Dokument teilen

Dokument teilen oder einbetten

Freigabeoptionen

Stufen Sie dieses Dokument als nützlich ein?

Sind diese Inhalte unangemessen?

Copyright:

Verfügbare Formate

Lazarus Free Pascal

Hochgeladen von

Copyright:

Verfügbare Formate

Zusätzliche Online-

Daten zum Buch

Übersetzung aus dem Englischen von

Alle Rechte vorbehalten. Ohne ausdrückliche, schriftliche Genehmigung des

© 2012 by C&L Computer und Literaturverlag

Coverdesign: Hawa & Nöh, Neu-Eichenberg

Dieses Buch wurde auf chlorfrei gebleichtem Papier gedruckt

4.10 Die Manager-Units........................................................................8

4.21 Unit Video ..................................................................................108

4. REFERENZ DER RTL (ONLINE-D ATEN )

4.10.1 Der Locale-Manager (clocale)

TFPUExceptionMask = set of (exDenormalized, exInvalidOp, exOverflow,

TFPURoundingMode = (rmNearest, rmDown, rmUp, rmTruncate)

TPaymentTime = (ptEndOfPeriod, ptStartOfPeriod);

procedure WriteRadDeg(X: Float);

(C) 2012 C&L - Computer- und Literaturverlag GmbH

procedure WriteRadDeg(X : Float);

procedure WriteRadDeg(X : Float);

(C) 2012 C&L - Computer- und Literaturverlag GmbH

(C) 2012 C&L - Computer- und Literaturverlag GmbH

procedure dofrexp(const X : Extended);

procedure DoIntpower(X: Extended; Pow: Integer);

(C) 2012 C&L - Computer- und Literaturverlag GmbH

WriteLn(’Max Float : ’, MaxValue(f_array):8:4);

(C) 2012 C&L - Computer- und Literaturverlag GmbH

(C) 2012 C&L - Computer- und Literaturverlag GmbH

(C) 2012 C&L - Computer- und Literaturverlag GmbH

procedure DoSinCos(Angle: Float);

procedure DoTan(Angle: Float);

(C) 2012 C&L - Computer- und Literaturverlag GmbH

netwlibc TLibHandle = Pointer;

with theopts[2] do begin

with theopts[3] do begin

with theopts[4] do begin

with theopts[5] do begin

(C) 2012 C&L - Computer- und Literaturverlag GmbH

with theopts[7] do begin

’a’: WriteLn(’Option a.’);

if optind <= ParamCount then begin

4.14 Unit HeapTrc

procedure SetMarker(P: Pointer);

(C) 2012 C&L - Computer- und Literaturverlag GmbH

4.15 Unit Lineinfo

4.17 Unit DOS

(C) 2012 C&L - Computer- und Literaturverlag GmbH

Konstante Beschreibung Wert

Konstante Wert Beschreibung

Konstante Wert Bedeutung (Flag)

(C) 2012 C&L - Computer- und Literaturverlag GmbH

Andere Werte sind möglich, aber nicht dokumentiert.

(C) 2012 C&L - Computer- und Literaturverlag GmbH

(C) 2012 C&L - Computer- und Literaturverlag GmbH

(C) 2012 C&L - Computer- und Literaturverlag GmbH

function L0(w: Word): String;

(C) 2012 C&L - Computer- und Literaturverlag GmbH

function L0(w: Word): String;

4.18 Unit Strings

(C) 2012 C&L - Computer- und Literaturverlag GmbH

(C) 2012 C&L - Computer- und Literaturverlag GmbH

4.19 Unit Sockets

(C) 2012 C&L - Computer- und Literaturverlag GmbH

Die Unit definiert die folgenden Fehlerkonstanten (sind alles Alias-Angaben):

Fehlercode Wert Bedeutung