Unterschiede

Hier werden die Unterschiede zwischen zwei Versionen angezeigt.

--- software:diy:assembler:kkurs [22/12/2005 10:12] – 8088
+++ software:diy:assembler:kkurs [12/11/2024 21:11] (aktuell) – [Teil 2: Prozessorregister und Befehlssatz (aus PofoInfo 3/97)] bttr
@@ Zeile 8: / Zeile 8: @@
 Doch jetzt zur Sache. Bekanntlich tut im Portfolio ein Intel-Prozessor namens 8088 seinen Dienst. Das Faszinierende an dieser 1979 mit dem 8086 (16-Bit-Datenbus, sonst wie 8088) eingeführten Architektur ist, daß sie uns bis in heutige PCs verfolgt. Wenn man aus einem Pentium-PC das Letzte herausholen möchte, ist deshalb auch heute das Erlernen der 8086-Maschinensprache durchaus noch aktuell.
 ==== Maschinensprache und Assembler ====
@@ Zeile 17: / Zeile 18: @@
 In den Zeiten als die Programme noch kurz, Disketten Luxus und Mailboxen die Domäne von Hackern waren, wurden Listings ja gern in so einer Form gedruckt. Zur Programmentwicklung ist diese Darstellung jedoch denkbar ungeeignet. Um sich nicht für jeden Maschinenbefehl eine Zahl merken zu müssen, bedient man sich einer anderen Schreibweise. Für alle Maschinenbefehle des Prozessors existieren eingängige Abkürzungen, die meist aus drei Buchstaben bestehen und Mnemonics genannt werden. Ein Assemblerquelltext besteht hauptsächlich aus diesen Mnemonics und den zum jeweiligen Maschinenbefehl gehörenden Parametern. Dabei beginnt man für jeden Befehl eine neue Zeile, läßt links Platz für Sprungmarken und fügt eventuell rechts nach einem Strichpunkt einen Kommentar an. Obiges Beispiel stellt sich damit wie folgt dar:
-            mov dx,8020h  ; Portadresse
+<code asm>
-            xor ax,ax     ; Zähler auf 0
+        mov dx,8020h  ; Portadresse
-    Marke:  out dx,al     ; Ton erzeugen
+        xor ax,ax     ; Zähler auf 0
-            dec ax        ; Zähler -1
+Marke:  out dx,al     ; Ton erzeugen
-            jnz Marke     ; Schleife
+        dec ax        ; Zähler -1
-            mov ax,4c80h
+        jnz Marke     ; Schleife
-            out dx,al     ; Ton aus
+        mov ax,4c80h
-            int 21h       ; beenden
+        out dx,al     ; Ton aus
+        int 21h       ; beenden
+</code>
 ==== Unser Handwerkszeug ====
@@ Zeile 30: / Zeile 33: @@
 Dieser Quelltext muß nun in zwei Schritten mit einem Assembler und einem Linker in ein lauffähiges Programm übersetzt werden. Man kann diese zwei Schritte mit einem Batchprogramm zusammenfassen. Die bekanntesten Assembler sind MASM von Microsoft (zugehöriger Linker: LINK), TASM (Linker: TLINK) von Borland sowie der Sharewareassembler A86. Ich selbst benutze Borlands Turbo Assembler, jedoch scheint mir A86 den einfachsten Einstieg zu ermöglichen, denn dieser kann ohne externen Linker obigen Beispielquelltext direkt in ein .com-Programm übersetzen. Zudem ist er mit 23kB (Version 3.22) mit Abstand der kleinste Vertreter seiner Gattung und läuft damit sogar direkt auf dem Portfolio. A86.COM befand sich auf der Begleitdiskette zur ersten Ausgabe der Pofoinfo, ist aber auch auf der Club-CD, in der Club-Mailbox und in vielen Shareware-Archiven vorhanden. Turbo-Pascal (6.0ff) wartet mit einem integrierten Assembler auf. Allerdings bettet es den damit erzeugten Code in ein unhandliches EXE-Programm ein. Wer noch keines dieser Programme besitzt, kann zum Experimentieren vorerst auf DEBUG zurückgreifen.
-Neben einem Assembler sollten zur Grundausstattung aber auch Nachschlagewerke zu den Themen Prozessorarchitektur, Befehlssatz und Betriebssystem gehören, denn eine ausführliche Behandlung im Rahmen dieses Kurses ist kaum möglich. Eine große Hilfe ist hier eine Online-Referenz, wie z.B. das Shareware-Programm HelpPC für DOS von David Jurgens, das alle genannten Themenkomplexe abdeckt (Quelle z.B.: ftp://ftp.simtel.net/pub/simtelnet/msdos/info/helppc21.zip, Größe ca. 255K)
+Neben einem Assembler sollten zur Grundausstattung aber auch Nachschlagewerke zu den Themen Prozessorarchitektur, Befehlssatz und Betriebssystem gehören, denn eine ausführliche Behandlung im Rahmen dieses Kurses ist kaum möglich. Eine große Hilfe ist hier eine Online-Referenz, wie z.B. das Shareware-Programm HelpPC für DOS von David Jurgens, das alle genannten Themenkomplexe abdeckt (Quelle: z.B. [[ftp://ftp.simtel.net/pub/simtelnet/msdos/info/helppc21.zip]], Größe ca. 255 KiB).
 ==== Das erste Programm ====
@@ Zeile 91: / Zeile 94: @@
 Der klassische Weg vom Quelltext zum Code führt über die sogenannte Objektdatei. Sie wird vom Assembler aus dem Quelltext erzeugt und enthält einen Mix aus Symbolen und Code. Erst durch das anschließende Linken gelangt man zum ausführbaren Programm. Dieses Verfahren ist zwar vielseitiger (man kann z.B. mehrere Objektdateien zusammenlinken), für den Einsteiger allerdings erst einmal umständlicher als die direkte Methode von A86. Damit aber nicht genug: Der Quelltext bedarf noch ein paar Ergänzungen:
-    .model tiny
+<code asm>
-    .code
+.model tiny
-    ORG 100h
+.code
-    Start:  mov dx,8020h  ; Portadresse
+ORG 100h
-            xor ax,ax     ; Zähler auf 0
+Start:  mov dx,8020h  ; Portadresse
-    Marke:  out dx,al     ; Ton erzeugen
+        xor ax,ax     ; Zähler auf 0
-            dec ax        ; Zähler -1
+Marke:  out dx,al     ; Ton erzeugen
-            jnz Marke     ; Schleife
+        dec ax        ; Zähler -1
-            mov ax,4c80h
+        jnz Marke     ; Schleife
-            out dx,al     ; Ton aus
+        mov ax,4c80h
-            int 21h       ; beenden
+        out dx,al     ; Ton aus
-    END Start
+        int 21h       ; beenden
+END Start
+</code>
 Die hinzugekommenen Assemblerdirektiven machen Angaben über das Speichermodell, den Beginn des Codesegments und die Einsprungadresse. Die hier verwendeten Minimaleinstellungen dürften für jedes Portfolioprogramm ausreichend sein und können jedesmal so übernommen werden. Hat man TON.ASM wie oben ergänzt, kann die Assemblierung folgen (hier auf dem Desktop-PC):
@@ Zeile 128: / Zeile 133: @@
 Das umständlichste - pardon professionellste - Werkzeug stammt, wie sollte es anders sein, aus dem Hause Microsoft. Die hier verwendete MASM-Version 1.25 ist allerdings schon leicht in die Jahre gekommen, so daß das Beispiel eventuell nicht mit aktuelleren Versionen nachvollziehbar ist. Trotzdem hier der angepaßte Quelltext:
-    code    SEGMENT
+<code asm>
-            ASSUME CS:code
+code    SEGMENT
+        ASSUME CS:code
             ORG 100h
-    Start:  mov dx,8020h  ; Portadresse
+Start:  mov dx,8020h  ; Portadresse
-            xor ax,ax     ; Zähler auf 0
+        xor ax,ax     ; Zähler auf 0
-    Marke:  out dx,al     ; Ton erzeugen
+Marke:  out dx,al     ; Ton erzeugen
-            dec ax        ; Zähler -1
+        dec ax        ; Zähler -1
-            jnz Marke     ; Schleife
+        jnz Marke     ; Schleife
-            mov ax,4c80h
+        mov ax,4c80h
-            out dx,al     ; Ton aus
+        out dx,al     ; Ton aus
-            int 21h       ; beenden
+        int 21h       ; beenden
-    code    ENDS
+code    ENDS
-    END Start
+END Start
+</code>
 Bis zum Endprodukt sind jetzt drei Schritte erforderlich. Zunächst wie beim Borland-Produkt die Assemblierung und das Linken. LINK erzeugt allerdings eine ausführbare Datei im .EXE-Format (783 Bytes), die danach noch ins COM-Format konvertiert werden muß:
@@ Zeile 178: / Zeile 185: @@
 Mit der Anweisung ASM lassen sich Assemblerbefehle auch in ein Pascalprogramm einbauen. Dabei ist zu beachten, daß Labels mit dem Klammeraffen beginnen müssen und Kommentare in geschweifte Klammern gestellt werden müssen:
-    begin
+<code asm>
-      ASM
+begin
-            mov dx,8020h {Portadresse  }
+  ASM
-            xor ax,ax    {Zähler auf 0 }
+        mov dx,8020h {Portadresse  }
-    @Marke: out dx,al    {Ton erzeugen }
+        xor ax,ax    {Zähler auf 0 }
-            dec ax       {Zähler -1    }
+@Marke: out dx,al    {Ton erzeugen }
-            jnz @Marke   {Schleife     }
+        dec ax       {Zähler -1    }
-            mov ax,4c80h
+        jnz @Marke   {Schleife     }
-            out dx,al    {Ton aus      }
+        mov ax,4c80h
-            int 21h      {beenden      }
+        out dx,al    {Ton aus      }
-      end;
+        int 21h      {beenden      }
-    end.
+  end;
+end.
+</code>
 Kompiliert mit TP 6.0 ergibt dieser Quelltext ein 1488 Bytes langes .EXE-Programm. Da der Befehl int 21h das Programm vorzeitig beendet, sollte man diese Zeile besser weglassen. Es ist aber auch möglich (z.B. mit DEBUG), unsere 15 Bytes aus dem .EXE Programm herauszuschneiden und als .COM-Programm zu speichern. Der betreffende Abschnitt reicht übrigens vom 16. bis zum 30. der 1488 Bytes.
@@ Zeile 202: / Zeile 211: @@
 Von Jan Laitenberger gibt es den __Freeware-Assembler__ JASMIN, der unkomprimiert nur knapp 20 KByte groß ist und speziell für den Einsatz auf dem Portfolio konzipiert wurde. Der begrenzte Funktionsumfang (keine Makros, nur 8086/88, nur COM-Programme) ermöglicht eine sehr einfache Bedienung, so daß JASMIN besonders für Einsteiger gut geeignet ist. Trotz seiner Eigenheiten (Labels müssen mit @ beginnen, Speicherzugriffe sind durch eckige Klammern kenntlich zu machen) ist dieser Assembler ein Muß für Portfolio-Fans! (Bezugsquelle: http://www.franksteinberg.de/ZIPS/JASMIN16.ZIP)
+**Update 12.11.2024:** Robert Riebisch hat dem PofoWiki die Datei {{:software:diy:assembler:jasmin16s.zip}}, die auch den JASMIN-Quellcode für Turbo Pascal 6.0 enthält, zur Verfügung gestellt.
+Auszug aus ''jasmin.txt'':
+   Seit dem 7.10.2006 ist fuer dieses Programm auch der Source-Code
+   beigefuegt. Dieser darf in nicht-kommerziellen Programmen verwendet
+   werden. Jegliche kom[m]erzielle Verwendung des Sourcecodes im Ganzen oder
+   in Teilen bedarf der schriftlichen Einwilligung des Autors!
 Vielleicht wartet der eine oder andere Leser bereits ungeduldig darauf, endlich die ersten 8086-Befehle (der 8088 ist bekanntlich kompatibel) zu lernen, um selbst ein Assemblerprogramm zu "stricken". Und in der Tat ist man mit einem Dutzend gelernten Befehlen schon ganz brauchbar gerüstet. Zunächst sollte der Neuling jedoch die (zugegebenermaßen etwas chaotische) Architektur des Prozessors kennenlernen:
@@ Zeile 223: / Zeile 241: @@
 Abgesehen von SP und IP dürfen auch diese Register nach Belieben verwendet werden. Insbesondere eignen sie sich aber zur indirekten Adressierung und für die sog. Stringbefehle.
-^ Register ^ Name/Funktion                     ^  Typische Operation  ^
+^ Register ^ Name/Funktion                     ^ Typische Operation  ^
-|    IP    | Instruction Pointer (Finger weg!) |                      |
+|    IP    | Instruction Pointer (Finger weg!) |                     |
-|    SP    | Stackpointer (Finger weg!)        |  PUSH, POP           |
+|    SP    | Stackpointer (Finger weg!)        | PUSH, POP           |
-|    BP    | Basepointer                       |                      |
+|    BP    | Basepointer                       |                     |
-|    SI    | Sourceindex                       |  LODSB               |
+|    SI    | Sourceindex                       | LODSB               |
-|    DI    | Destination index                 |  STOSB               |
+|    DI    | Destination index                 | STOSB               |
@@ Zeile 235: / Zeile 253: @@
 Die Segmentregister haben eine spezielle Funktion, die später noch genauer erklärt wird. Nur ES steht zur freien Verfügung.
-^ Register ^ Name/Funktion             ^  Typische Operation                             ^
+^ Register ^ Name/Funktion             ^ Typische Operation                              ^
 |    CS    | Codesegment (Finger weg!) |                                                 |
-|    DS    | Datensegment (Vorsicht!)  | ndern des Datensegments: MOV DS,AX             |
+|    DS    | Datensegment (Vorsicht!)  | Ändern des Datensegments: MOV DS,AX             |
-|    SS    | Stacksegment (Vorsicht!)  | Adressierung mit Segment-Prfix: MOV AL,[SS:BX] |
+|    SS    | Stacksegment (Vorsicht!)  | Adressierung mit Segment-Präfix: MOV AL,[SS:BX] |
 |    ES    | Extrasegment              | STOSB                                           |
@@ Zeile 250: / Zeile 268: @@
 Wie die Namen der Segmentregister vermuten lassen, ist es vorgesehen, für Programmcode, Daten und den Stack (Zwischenspeicher für Unterprogramme) jeweils ein eigenes Segment zu spendieren. Für uns spielt das aber keine Rolle, weil das Betriebssystem bei COM-Programmen die drei Segmentregister CS, DS und SS mit dem selben Wert initialisiert. Es besteht also zum Glück kaum die Chance, einen Befehl zu verwenden, der sich nicht auf das gewünschte Segment bezieht. Allerdings muß sich ein COM-Programm deshalb mit höchstens 64 KByte begnügen, was aber für die meisten Portfolio-Programme mehr als ausreichend ist. Zudem sind compilierte Assemblerprogramme so kompakt, daß ihre Größe in der Regel nur etwa 1/10 von der des Quelltexts beträgt.
 ==== Eine handvoll Befehle ====
@@ Zeile 259: / Zeile 278: @@
 Der vielseitigste und meist genutzte Assemblerbefehl ist sicherlich der MOV-Befehl (move). Er überträgt ein Datenwort z.B. aus dem Speicher in ein Register oder aus einem Register in ein anderes. Zudem unterstützt dieser Befehl verschiedene Adressierungsarten für Speicherzugriffe. Hierzu eine Auswahl an Beispielen:
+<code asm>
     mov al,2      ; Lädt das Register al mit dem Wert 2
     mov al,[2]    ; Lädt al mit dem Byte-Wert, der an der
@@ Zeile 265: / Zeile 286: @@
     mov al,[bx]   ; Lädt al mit dem Byte-Wert, der an der Speicherstelle
                   ; bx im Datensegment steht (indirekte Adressierung)
-    mov cl,[si+3] ; Lädt al mit dem Byte-Wert, der an der Speicherstelle
+    mov cl,[si+3] ; Lädt cl mit dem Byte-Wert, der an der Speicherstelle
                   ; si+3 im Datensegment steht (indirekte indizierte Adr.)
     mov [7],dh    ; Speichert dh an der Speicherstelle 7 im Datensegment
+</code>
 Diese Beispiele wickeln den Datenaustausch mit dem Speicher nur über die 8-Bit-"Halbregister" ab, wodurch genau 1 Byte im Speicher angesprochen wird. Es sind aber auch 16-Bit-Speicherzugriffe möglich. Dabei ist es oft hilfreich zu wissen, daß gemäß Intel-Konvention an der angegebenen Speicherstelle das niederwertige Byte (Lowbyte) und an der darauffolgenden Speicherstelle das höherwertige Byte (Highbyte) angesiedelt ist.
 Wer sich mit DEBUG einmal den Maschinencode für obige Varianten des MOV-Befehls ansieht, kann feststellen, daß wir es hier eigentlich mit verschiedenen Maschinenbefehlen zu tun haben:
+<code asm>
     B002      MOV   AL,02
     A00200    MOV   AL,[0002]
@@ Zeile 278: / Zeile 301: @@
 A4C03    MOV   CL,[SI+03]
     88360700  MOV   [0007],DH
+</code>
 Besonders effizient codiert wurden die ersten beiden Zeilen: Die Befehlscodes (OP-Codes) bestehen dort aus einem einzigen Byte (B0 bzw. A0), gefolgt von einem bzw. zwei Bytes für den zweiten Parameter. Man sieht auch, daß die 16-Bit-Konstante 0002 im Format Lowbyte/Highbyte gespeichert ist. Die anderen vier - etwas weniger gebräuchlichen - Varianten benötigen jeweils 2 Bytes für den OP-Code und bis zu zwei weitere Bytes für Konstanten.
@@ Zeile 304: / Zeile 328: @@
 Dieser Befehl ruft die durch Nummer spezifizierte Interruptroutine auf. Der INT-Befehl stellt die Schnittstelle zum Betriebssystem dar, denn sowohl BIOS als auch DOS belegen etliche Interruptvektoren mit Routinen, die von Anwendungsprogrammen genutzt werden können (und sollen). Je nach Funktion müssen zuvor diverse Parameter in bestimmten Registern abgelegt werden. Beispiel:
+<code asm>
     mov ah,7   ; 7=Zeicheneingabe nach al
     int 21h    ; 21=wichtigster DOS-Interrupt
@@ Zeile 309: / Zeile 334: @@
     mov ah,6   ; 6=Zeichenausgabe (dl=ASCII)
     int 21h
+</code>
 Übrigens lautet der Maschinencode für Int 21h 'CD 21' (dezimal 205, 33) und dürfte eine der häufigsten Bytekombinationen in DOS-Programmen darstellen.
@@ Zeile 316: / Zeile 342: @@
 Eine wichtige Eigenart der 80x86-Prozessorfamilie sind die Portadressen. Parallel zum Arbeitsspeicher existiert ein 64 KByte großer Adreßraum, über den Peripheriebausteine (z.B. paralleles Interface) angesprochen werden. Der Prozessorbefehl IN liest einen 8-Bit- oder 16-Bit-Wert von der Portadresse dx ein. Folgendes Beispiel übernimmt den Zustand der Statusleitungen des Druckerports in das Register al:
+<code asm>
     mov dx,807Ah
     in al,dx ; nur dx möglich!
+</code>
 **OUT dx,Register**
@@ Zeile 328: / Zeile 356: @@
 Addiert zum Operand1 den Operand2. Falls das Ergebnis zu groß für Operand1 ist, wird das Carry-Flag gesetzt (Abfrage z.B. über den bedingten Sprungbefehl JC - jump if carry), welches somit das im Ergebnis fehlende höchste Bit repräsentiert. Beispiel:
+<code asm>
     mov cx,1997   ; cx=1997
     add cx,3      ; cx=2000
+</code>
 **SUB Operand1,Operand2**
@@ Zeile 335: / Zeile 365: @@
 Subtraktion analog zu ADD. Beispiel:
+<code asm>
     mov bx,0605h  ; bh=6, bl=5
     sub bl,bh     ; bl=FFh
+</code>
 Hier wird das Carry-Flag gesetzt, was bedeutet, daß FFh als -1 zu interpretieren ist.
@@ Zeile 344: / Zeile 376: @@
 Der pure Luxus: Strukturierte Programmierung in Maschinensprache durch Unterprogramme!  CALL springt an den Anfang des Unterprogramms und sichert automatisch die Rücksprungadresse auf dem Stack. RET beendet das Unterprogramm, indem es die Rücksprungadresse wieder vom Stack holt, um das Programm mit dem Befehl hinter 'CALL' fortzusetzen. Ein anständiges Unterprogramm sichert zunächst alle verwendeten Register mit PUSH auf dem Stack und stellt sie am Ende mit POP wieder her (Diese Befehle sind allerdings - wie auch CALL und RET - mit etwa 20 Takten recht langsam). Beispiel:
+<code asm>
              ...
              call PortAus
@@ Zeile 355: / Zeile 388: @@
              pop dx       ; Reihenfolge
              ret
+</code>
 **Weitere Prozessorbefehle**
@@ Zeile 366: / Zeile 400: @@
 |  LOOP            | Schleife mit cx als Zähler        |
 |  SHL,SHR ROL,ROR | Bitweises Schieben und Rotieren   |
-|  LODSB, STOSB    | Stringbefehle (Laden/Speichern von Bytes mit automatischer Indexerhhung |
+|  LODSB, STOSB    | Stringbefehle (Laden/Speichern von Bytes mit automatischer Indexerhöhung |
 ==== Ein Wort zur Ausführungsgeschwindigkeit ====
@@ Zeile 433: / Zeile 467: @@
     Summe: DW ? ; wird 900
-Die meisten Assembler unterstützen für die hier auftretenden Speicherreferenzen eine spezielle Form von Labels ohne Doppelpunkt, mit der sich das vorangehende Beispiel deutlich über sichtlicher darstellen läßt:
+Die meisten Assembler unterstützen für die hier auftretenden Speicherreferenzen eine spezielle Form von Labels ohne Doppelpunkt, mit der sich das vorangehende Beispiel deutlich übersichtlicher darstellen läßt:
           mov ax,Zahl1
@@ Zeile 445: / Zeile 479: @@
 ==== Auf Nummer sicher ====
-Dank der "Pseudo-Initialisierung" mit "?" sind die beiden Arrays nicht Bestandteil des COM- Programms. Allerdings ist nun nicht mehr sichergestellt, daß DOS einen Programmstart verhindert, wenn nicht genügend Speicher zur Verfügung steht. Natürlich könnte man argumentieren, daß eine Speichererschöpfung bei einem sehr kurzen Programm mit womöglich nur wenigen uninitialisierten Bytes in der Praxis kaum vorkommt, aber auf solch unkalkulierbare Risiken sollte sich niemand einlassen.
+Dank der "Pseudo-Initialisierung" mit "?" sind die beiden Arrays nicht Bestandteil des COM-Programms. Allerdings ist nun nicht mehr sichergestellt, daß DOS einen Programmstart verhindert, wenn nicht genügend Speicher zur Verfügung steht. Natürlich könnte man argumentieren, daß eine Speichererschöpfung bei einem sehr kurzen Programm mit womöglich nur wenigen uninitialisierten Bytes in der Praxis kaum vorkommt, aber auf solch unkalkulierbare Risiken sollte sich niemand einlassen.
-Eine einfache Möglichkeit, den "Speicherfllstand" während der Laufzeit zu testen besteht in der Auswertung des Stackpointers (Register SP). Beim Programmstart wird SP von DOS nämlich so hoch initialisiert, wie es die Menge des freien Speichers gestattet (jedoch maximal 0FFFEh, weil das der letzte 16-Bit-Speicherplatz im gemeinsamen Code-/Daten-/Stack-Segment ist). Da der Stapel abwärts dem Programmcode entgegenwächst, muß ein gewisser Sicherheitsabstand (200 Bytes sollten es schon sein) zum letzten verwendeten Speicherplatz vorhanden sein. In unserem Beispiel würde man prüfen, ob die Differenz von SP und Offset Dummy mindestens 200 beträgt.
+Eine einfache Möglichkeit, den "Speicherfüllstand" während der Laufzeit zu testen besteht in der Auswertung des Stackpointers (Register SP). Beim Programmstart wird SP von DOS nämlich so hoch initialisiert, wie es die Menge des freien Speichers gestattet (jedoch maximal 0FFFEh, weil das der letzte 16-Bit-Speicherplatz im gemeinsamen Code-/Daten-/Stack-Segment ist). Da der Stapel abwärts dem Programmcode entgegenwächst, muß ein gewisser Sicherheitsabstand (200 Bytes sollten es schon sein) zum letzten verwendeten Speicherplatz vorhanden sein. In unserem Beispiel würde man prüfen, ob die Differenz von SP und Offset Dummy mindestens 200 beträgt.
 Noch nobler ist es aber, dem Betriebssystem zur Laufzeit mitzuteilen, wieviel Speicher das Programm tatsächlich benötigt. Die Speicherverwaltung von DOS gibt dann den überschüssigen Speicher wieder frei, was beim Portfolio den Vorteil hat, daß sich dann meist die internen Applikationen parallel nutzen lassen. Ein universeller Programmanfang, der diese sogenannte Anpassung der Segmentlänge vornimmt, gestaltet sich wie folgt:
@@ Zeile 763: / Zeile 797: @@
 [7]    Assembler-Routine "PutPixel" auf meiner WWW-Seite