DOS API Aufrufe

Heute bringen die meisten Programmiersprachen “alles” mit, was notwendig ist um alle möglichen Formen von Programmen, UIs und Spielen zu bauen. Doch zu DOS Zeiten, war man auf die C Standardbibliothek und einfache Text Ein- und Ausgaben beschränkt.

Den Spielraum konnte man sich mit direkten Aufrufen von Interrupt Service-Routinen erweitern, darunter vor allem der int 21h mit allen DOS Funktionen.

Leider war das alles andere als “standardisiert” und trotzdem verfolgten die Sprachen ähnlichen Ansätze.

Integration von Inline-Assembler

C und Pascal Compiler erlaubten im normalen Programmfluss Assembler Codes einzuschleusen. Man öffnete einen asm Block und schrieb dort die Intel Syntax der X86 Anweisungen, oder sogar direkt den Bytecode des Prozessors.

Doch diese Non-Standard Erweiterung änderte sich stets und vor allem die Interaktion zwischen Variablen und Konstanten der eigentlichen Sprache war unterschiedlich. Ich weiß bis heute nicht auswendig, wo man nun Variablen in eckige Klammen setzen muss und wo nicht, oder ob Stack-Variablen und globale anders behandelt werden mussten.

Und wenn dann noch Turbo C den Code an den externen Turbo Assembler auslagerte, war fraglich, ob der überhaupt installiert war.

Aufruf von Interrupts über Standard-Funktionen

Ein Alternative musste her, und diese war eine spezielle Funktion, die die Assembler-Magie im Hintergrund durchführte. Man befüllte eine Struktur deren Member die CPU-Register abbildeten und rief ebendiese Funktion auf, die DOS oder andere Interrupt nutzte und das Ergebnis war ein neuer Satz an Register-Variablen in der zurückgegebenen Struktur.

In den nachfolgenden Beispielen nutze ich die DOS Funktion ah=0x30, die die DOS-Version im Register AX zurückgibt, und zwar AL mit der Hauptversion und AH mit der Nebenversion:

Turbo C, OpenWatcom

Im dos.h Header befindet sich die Funktion intdos(in_regs, out_regs) um DOS Funktionen mit union REGS Parametern aufzurufen.
Zusätzlich existiert noch int86(int_nr, in_regs, out_regs) um jeden beliebigen Softwareinterrupt aufzurufen.

 #include <dos.h>
 
 void getDOSversion(int* major, int* minor)
 {
   union REGS in_regs, out_regs;
   in_regs.h.ah = 0x30;
   in_regs.h.al = 0x00;
   /*in_regs.x.ax = 0x3000;*/
   intdos(&in_regs, &out_regs);
  *major = (int)out_regs.h.al;
  *minor = (int)out_regs.h.ah;
}

int main()
{
  int major, minor;
  getDOSversion(&major, &minor);
  printf("DOS v%d.%d\n", major, minor);
  return 0;
}

Turbo Pascal

Turbo Pascal stellte in seinem DOS Modul die Funktion MsDos(regs) für DOS Funktionen bereit und mit Intr(intNo, regs) kann man jeden beliebigen Interrupt nutzen. Hier gibt es nur einen Registers-Parameter, der gleichzeitig Input ist und danach zum Output wird.

 PROGRAM dosver;
 USES dos;
 
 PROCEDURE getDOSversion(var major: WORD; var minor: WORD);
 VAR
   regs: REGISTERS;
 BEGIN
   regs.ah := $30;
   regs.al := $00;
  {regs.ax := $3000;}
  MsDos(regs);
  major := regs.al;
  minor := regs.ah;
END;

VAR
  maj, min: WORD;
  text: STRING;
BEGIN
  getDOSversion(maj, min);
  write('DOS v');
  str(maj, text);
  write(text);
  write('.');
  str(min, text);
  writeln(text);
END.

QuickBasic DOS Interrupt Aufruf

Startet man QuickBasic (4.5+) mit QB.EXE /L, stehen Zusatzbibliotheken zur Verfügung, die man über das Metakommando
REM $INCLUDE: 'file' einbinden kann.
Und QB.BI definiert die Funktion INTERRUPT und den RegType Typ, der Registerzustände an die Funktion leiten soll, die wiederum einen Softwareinterrupt damit aufruft. So kann man jeden Interrupt aufrufen, und natürlich auch 21h.

 REM $INCLUDE: 'QB.BI'
 DECLARE SUB getDOSversion (major AS INTEGER, minor AS INTEGER)
 
 DIM major AS INTEGER
 DIM minor AS INTEGER
 
 getDOSversion major, minor
 
 PRINT "DOS v";
PRINT USING "#"; major;
PRINT ".";
PRINT USING "#"; minor

SUB getDOSversion (major AS INTEGER, minor AS INTEGER)
  DIM inreg AS RegType
  DIM outreg AS RegType
  inreg.ax = &H3000
  CALL INTERRUPT(&H21, inreg, outreg)
  major = outreg.ax AND &HFF
  minor = CINT(outreg.ax / 256)
END SUB

Der mit DOS mitgelieferte QBASIC.EXE Interpreter unterstützt CALL INTERRUPT nicht. Theoretisch gäbe es aber die Möglichkeit mit POKE Assembler-Bytes in den Speicher zu schreiben und dann per
CALL ABSOLUTE die Funktion aufzurufen … aber soviel DOS-Hackerei tut sich heute keiner mehr an.

Fazit

Der große Nachteil dieser direkten Interrupt-Aufrufe liegt in der Unmöglichkeit der Portierbarkeit. Denn die Register sehen ja auf jeder CPU anders aus.
Definierte APIs sind die Lösung und davon haben wir heute nur 2 große Vertreter: die WinAPI und POSIX parallel zur C-stdlib.

Tja, deshalb brauche ich eine Zeitmaschine, um mein heutiges Wissen 25 Jahre in die Vergangenheit zu senden. Denn oft habe ich mühsam ganze Programme in Assembler verfasst, nur weil ich ein paar Interrupt bzw. DOS Funktionen aufrufen wollte. Dass man das auch einfacher tun kann, lernte ich erst, als ich DOS nicht mehr wirklich brauchte und auch nicht mehr damit programmierte.

Aber … Wissen schadet nicht.
Im Gegenteil, es ist interessant zu sehen, wie sehr sich die 3 “Hauptsprachen” C, Pascal und Basic ähneln was Interrupts unter DOS anbelangt.