Programm erstellen ohne Vorkenntnisse

[drzeissler]

Moin,

ich möchte eine Programm erstellen und habe keine Vorkenntnisse im Programmieren. In meinem Kopf ist nur ein Konzept wie es aussehen soll und was es können muss. Es handelt sich um eine Art Menusystem welches mit Tastaturcommandos laufen soll.

Beschreibung:
- Das Programm soll in DOS laufen.
- Es soll vollständig Tastaturbedient sein.
- Es besteht aus nur 2 Masken/Seiten
- Es soll kombiniert Text und Grafik dargestellt werden. Die Auflösung sollte 640x350 oder 640x480 sein.
- Es werden Unterverzeichnisse auf bestimmte Dateien ausgelesen.
- Man kann mittels F1-F9 verschiedene Kataloge (sprich Unterverzeichnisse) auswählen.
- Man kann mittels Cursortasten durch die Image-Dateien der gewählten Unterverzeichnisse browsen.
- Bei alle sichtbaren Image-Dateien, werden zusätzliche Informationen angezeigt.
- Bei der Datei wo der Cursor steht, wird das passende Bild angezeigt.
- Weitere Dateien erhält man, wenn der Cursor nach rechts fährt.
- Mittels (ENTER) wird eine weitere Maske angezeigt, wo die zuvor gewählte Datei mittels 3 verschiedenen Programmen auf Diskette zurückgeschrieben werden kann.
- Neben dem automatischen Zurückschreiben, sollen später auch Optionen für die Tools zum Zurückschreiben angeboten werden.
- Durch wählen des Programms zum Zurückschreiben wird das Imageprogramm aufgerufen und das Image über das Floppy zurückgeschrieben.
- Die Programme zum Zurückschreiben (MakeDisk, STDisk) sind vorhanden.

Fragen:
Welche Programmiersprache ist für sowas sinnvoll ?

Als Anhaltspunkt mal beispielsweise eine Auswahl des Automation-Katalogs (AUTO)
http://atari.h2nob.de/menus.php?c=auto&s=0&e=10
Im Prinzip soll das so ähnlich sein und die Möglichkeit bieten, neben der Auswahl auch gleich die Option zum zurückschreiben zu bieten.

Mein erster Konzeptentwurf sieht so aus.

Beste Grüße
Euer Doc

[Dosenware]

Gibt es nur 9 Unterverzeichnisse?
Wo sind die Zusatzdaten (Bild/Text) zu den Dateien?
Farbtiefe?
Die Menüpics: Verzeichnis, oder Dateiabhängig?
Beim letzten Bild: sind In den *.St Dateien die einzelnen Spiele? Sprich: müssen die St-Dateien vom Programm selbst ausgelesen werden, oder sind diese Informationen in den Zusatzdaten?

Würde Pascal nehmen, ist recht einfach.

[drzeissler]

1. Gibt es nur 9 Unterverzeichnisse?
2. Wo sind die Zusatzdaten (Bild/Text) zu den Dateien?
3. Farbtiefe?
4. Die Menüpics: Verzeichnis, oder Dateiabhängig?
5. Beim letzten Bild: sind In den *.St Dateien die einzelnen Spiele? Sprich: müssen die St-Dateien vom Programm selbst ausgelesen werden, oder sind diese Informationen in den Zusatzdaten?

Würde Pascal nehmen, ist recht einfach.

1. u.U. können es noch mehr sein, das Dateikonzept ist noch nicht ganz zuende gedacht.
2. Die Disk-Images liegen in *.ST oder *.MSA vor. Dazu gäbe es eine GIF für jedes Image, die genau so heist wie das Image und entweder eine einzelne Textdatei die die Inhalte der *.ST bzw. *.MSA Dateien enthält, oder eine Datei, die alle Inhalte des Gesamtkatalogs (bspw. Automation) als Textdatei hat.
3. Die Bilder haben 16 Farben, aber nicht die EGA Palette, ich schlage daher 640x480 mit 256 Farben vor.
4. Die Menu-PIC 8Bit-BMP's sind Dateiabhängig (siehe Automation-Link)
5. Nein, die Informationen, welche Spiele in den *.ST oder *.MSA Images sind liegen in Textform vor (siehe Punkt 2)

Mein erster Gedanke war auch TP, aber der Rechner ist ein P2-300 und damit von dem Runtime-Error 200 betroffen; angeblich soll es aber in der Programmierung Umgehungslösungen geben.

Da die Spiele zum Teil in verschiedenen Katalogen (Automation, DBug, etc) enthalten sind, wäre die Suchfunktion eine echte Herausforderung. Normalerweise soll man mit den F1-F9 auf der ersten Seite den Katalog wählen. Bei der Suchfunktion sollen die Treffer aber nebeneinaber angezeigt werden. Bspw. sucht man "TestDrive" und erhält 3 Treffer nebeneinander.

Wie gesagt, es muss nicht so sein, jede Verbesserung ist willkommen.
Das zurückschreiben eines Images, erfolgt dann mittels externer Dossoftware (MakeDisk14, Makedisk15, STDisk) und den dazugehörigen Flags.

Danke
Doc

[DOSferatu]

Kleine Anmerkung: Der RTE200 tritt in TP nur auf, wenn man die Unit CRT verwendet. Diese ist aber eigentlich nicht nötig, da man diese ganzen Dinge auch recht unkompliziert selbst programmieren kann.
Und: Programme (EXE), die in TP mit CRT programmiert sind, kann man nachträglich patchen. (Es sei denn, der Befehl DELAY wird auch wirklich benötigt.)

[drzeissler]

Ich habe hier schonmal angefangen; das sieht nützlich aus: http://www.hadels.com/programmit/TPi.html

Die Verzeichnisstruktur steht in meinem Kopf, ich bin nicht mehr sicher, ob die Katalogauswahl mit F1-F9 die beste ist, da es anscheinend sehr viele Compelations für den Atari-ST gibt.

Doc

[Dosenware]

Und: Programme (EXE), die in TP mit CRT programmiert sind, kann man nachträglich patchen. (Es sei denn, der Befehl DELAY wird auch wirklich benötigt.)

bzw. vorsorglich Patchen - so dass der Compiler bereits ein Funktionierendes Delay vorliegen hat (dürfte hier noch den Patch haben)

ich bin nicht mehr sicher, ob die Katalogauswahl mit F1-F9

Idee: F1 ruft entweder das Erste Verzeichnis auf oder schiebt das Auswahlmenü um N Verzeichnisse zurück, F9 macht das dann in die Gegenrichtung.
Alternativ ginge noch eine Liste mit Scrollfunktion (Cursortasten) - das würde dann wegen der Übersichtlichkeit nur nach Oben/unten gehen.

PS. wenn du wirklich alles selbst progammieren willst, nimm 8Bit Bitmaps - solange du keine angepassten Farbpaletten verwendest, musst du nur im Header den Startoffset auslesen und kannst dann das Bild direkt auf den Bildschirm klatschen.

[drzeissler]

Ganz alleine wird das sicher nichts...vielleicht können wir Schnipsel zusammentragen.
Wie gesagt bisher 0,0 Plan vom Programmieren.

Ich stelle mir daher als erstes die Frage, wie ich den Bildschirm auf 640x480 Grafikmodus mit 256 Farben schalte.
Da gibt es sicher einen VESA-Modus den man direkt Anwählen kann...

Ich stehe ganz am Anfang...

[drzeissler]

Danke für den Tipp mit den 8Bit BMP's!

Doc


PS: 101h : 640x480 256-colour

[Dosenware]

jepp,

asm
mov ax,$4F02
mov bx,$0101
int $10
end

und schon bist du drin - wenn du es ganz korrekt haben willst müsstest du erst ermitteln ob die Karte überhaupt Vesa kann (Int $10, $4F00), sie deinen Videomodus beherrscht - und wenn nicht, die Unterstützten Videomodi abklappern, ob sie dem gewünschten entsprechen (Int $10, 4F02) - oder du vertraust einfach darauf, dass sich die Karten an die Vesaspezifikation halten

PS. Gezeichnet wird dann in den Addressbereich $A000-AFFF

allerdings musst du, um den gesamten Bildschirm vollzuschreiben, Bankswitching betreiben d.h. du musst Rechnen:

Z:=Y*Max_X(bei dir 640)+X
Bank:=Z div 65536
Z:=Z-Bank*65536 (so erhälst du die relative Adresse deines Pixels)

AX:=$4F05 (wechseln der Bank)
BX:=0
DX:=Bank
Int $10

[A000:Z]:=Pixelfarbe (schreiben des Pixels)

[drzeissler]

Thx, schön wenn schonmal was funzt, auch wenn es 0,001% sind der Gesamtarbeit sind.

Const
Titel = '-- CompactDiskWirter for ATARI-Compilations --';
begin
asm
mov ax,$4F02
mov bx,$0101
int $10
end;
writeLn(Titel);
writeLn('ENTER drücken zum Beenden!');
readLn;
writeLn('That''s all!');
end.

[freecrac]

Moin.

Ich glaube so etwas wird dafür benötigt:
Hier ist eine Subroutine zum Starten eines anderen externen Programms aus einem "Eltern"-Programm heraus. Nach Beendigung des anderen Programms erfolgt ein Rücksprung zum Eltern-Programm, dessen Auführung danach wieder weiter fortgesetzt wird.

Zum Ansprungen der Subroutine mit dem Befehl "call EXEPRG" müssen vorher die Register DS:DX mit der Adresse des zu startenden Programmnamens und die Register DS:SI mit der Adresse der Kommandozeile davon geladen werden.

Code: Alles auswählen

.code

START:       ; Markiert den Anfang des Haupt-Programms und darüber kann man die Position
             ;  von Befehlen im Codesegment z.B. auf gerade Adressen, oder durch 16, 32,
             ;  oder xbeliebige Bytes ausrichten.

          mov ax, DATA
          mov ds, ax             ; Laden der Segmentadresse vom Programmnamen und der Kommandozeile
          mov dx, OFFSET PRGNAM  ; Laden der Offsetadresse vom Programmnamen
          mov si, OFFSET KOMMZ   ; Laden der Offsetadresse der Kommandozeile für das Programm
          call EXEPRG            ; Ansprung der Subroutine zum Starten des externen Programms

; weitere Befehle die nach der Beendigung des externen Programms ausgeführt werden

;──────────────────────Subroutine───────────────────────────────────────────────
;-- EXEPRG           Ein anderes Programm aufrufen
;-- Eingabe  DS:DX = Adresse des Programmnamen
;--          DS:SI = Adresse der Kommandozeile
;-- Programmname und Kommandozeile müssen als ASCII-String
;-- vorliegen und durch den ASCII-Code 0 abgeschlossen werden
;   die übergebene Kommmandozeile in eigenen Puffer übertragen
;   und dabei die Zeichen zählen
;────────────────────────────────────────────────────────────────────────────
 org START + ((($-START)/16)*16)+16    ; Code-Ausrichtung
;---------------------------------------------------------------------------
EXEPRG:   mov     di, OFFSET COMLINE+1 ; Adresse der Zeichen in der Kommandoz.
          xor     bl, bl               ; Zeichenzähler auf 0 setzen
; - - - - - - - - - - - - -
COPYPARA: mov     al, [si]             ; ein Zeichen auslesen
          inc     si
          and     al, al               ;  ist es der NUL-Code (Ende) ?
          jz  short COPYENDE           ; JA --> genug kopiert
          inc     bl                   ; Zeichenzähler inkrementieren
          mov     cs:[di], al          ; Ascii im neuen Puffer abspeichern
          inc     di
          cmp     bl, 7Eh              ;  Maximum erreicht ?
          jnz COPYPARA                 ; NEIN --> weitermachen
; - - - - - - - - - - - - -
COPYENDE: mov     cs:COMLINE, bl       ; Anzahl der Zeichen speichern
          mov    BYTE PTR cs:[di], Cr  ; Kommandozeile abschließen
; - - - - - - - - - - - - - - - - - - -
          mov     cs:MERKSS, ss        ; SS und SP müssen in Variablen im
          mov     cs:MERKSP, sp        ; Code-Segment gespeichert werden
; - - - - - - - - - - - - -
          mov     ax, cs
          mov     bx, OFFSET PARBLOCK  ; ES:BX zeigt auf Parameter-Block
          mov     es, ax
          mov     ax, 4B00h            ; Funktionsnummer für EXEC-Funktion
          sti                          ; Interrupts an
          int   21h                    ; DOS-Funktion aufrufen
; - - - - - - - - - - - - -
          cli                          ; Interrupts aus
          mov     ss, cs:MERKSS        ; Stacksegment und Stackpointer wieder
          mov     sp, cs:MERKSP        ; auf ihre alten Werte setzen
; - - - - - - - - - - - - - - - - - - -
DATUM:    mov     ax, DATEN            ; Datensegment
          mov     ds, ax
          ret
;──────────────────────────────────────
 org START + ((($-START)/32)*32)+32    ; Code/Daten-Ausrichtung
          DW ?
;--------------------------------------
PARBLOCK  equ THIS WORD                ; Parameter-Block für die EXEC-Funktion

          DW 0                         ; gleicher Environment-Block
          DW OFFSET COMLINE            ; Offset- und Segmentadresse der
          DW SEG CODE                  ;      Kommandozeile
          DD 0                         ; keine Daten in PSP #1
          DD 0                         ; keine Daten in PSP #2

COMLINE   DB 80h dup (0)               ; Kommandozeile
; - - - - - - - - - - - - - - - - - - -
MERKSS    DW ?                         ; nimmt SS während Programmaufruf auf
MERKSP    DW ?                         ; nimmt SP während Programmaufruf auf
;---------------------------------------------------------------------------

; weitere Subroutinen

;--------------Datenbereich-------------------------------------------------------------
.DATA
PRGNAM DB "MakeDisk.exe ", 0         ; ggf. zusätzlich Laufwerk und Pfad vor dem Namen mit angeben
KOMMZ DB "/LFW:A /IMG:floppy.img", 0 ; dient nur als Beispiel, die richtigen Parameter kenne ich nicht

RBIL->inter61b.zip->INTERRUP.G

Code: Alles auswählen

--------D-214B-------------------------------
INT 21 - DOS 2+ - "EXEC" - LOAD AND/OR EXECUTE PROGRAM
	AH = 4Bh
	AL = type of load
	    00h load and execute
	    01h load but do not execute
	    03h load overlay (see #01591)
	    04h load and execute in background (European MS-DOS 4.0 only)
		"Exec & Go" (see also AH=80h)
	DS:DX -> ASCIZ program name (must include extension)
	ES:BX -> parameter block (see #01590,#01591,#01592)
	CX = mode (subfunction 04h only)
		0000h child placed in zombie mode after termination
		0001h child's return code discarded on termination
Return: CF clear if successful
	    BX,DX destroyed
	    if subfunction 01h, process ID set to new program's PSP; get with
		INT 21/AH=62h
	CF set on error
	    AX = error code (01h,02h,05h,08h,0Ah,0Bh) (see #01680 at AH=59h)
Notes:
              ....Fortsetzung davon bitte im RBIL nachlesen, weil es ist doch etwas umfangreicher...

Dirk

[Dosenware]

@freeac
Pascal kennt dafür den Befehl Exec.

[drzeissler]

Könnt Ihr mir ein Buch für TP70 empfehlen, oder habt Ihr eine Internetquelle die das auf Deutsch erklärt.

Danke!

[freecrac]

PS: 101h : 640x480 256-colour

Seit VBE 2 kann man sich aber nicht mehr wirklich darauf verlassen, das diese Nummer bei jedem VBE2-Bios, oder VBE3-Bios für die Auflösung von 640x480 mit 256 Farben vorhanden ist, oder ob eine andere Nummen dafür verwendet werden muss, um diese Auflösung von 640x480 mit 256 Farben zu bekommen.

Weil seit VBE2 hat das VBE-Bios eine eigene Modeliste mit Modenummern die man Nummer für Nummer auslesen kann und mit der man mit der jeweiligen Nummer die Video-Mode spezifischen Informationen abrufen kann, um herauszufinden welche Eigenschaften der jeweilge Video-Mode hat und ob er z.B. die gewünsachte Auflösung mitbringt. Auf diese Weise kann man die Mode-Nummern jeweils überprüfen, bis man die gewünschte Auflösung gefunden hat.

Nun können wir mit der gefundenen Nummen den Videomode einschalten.

Hier habe ich ein kleines Programm (bzw. den vollständigen Quelltext davon) womit alle Modenummern eines VBE2- und VBE3-Bios ausgelesen und am Bildschirm (im Textmode bleibend) aufgelistet und ausgegeben werden.
Dafür wird zunächst Funktion 0 aufgerufen, um dort den Zeiger auf die Modeliste zu holen und darüber die Modenummen zu bekommen und dann wird mit jeder Nummer Funktion 1 aufgerufen, um die Eigenschaften(nur einige davon) des jeweiligen Mode auszulesen und am Bildschirm auszugeben.

Code: Alles auswählen

.MODEL SMALL                          ; Programm möglichst klein halten
.386
  CODE SEGMENT use16 'CODE'
 assume cs:CODE,ds:DATEN,ss:STAPEL
 org 100h
START: mov      ax, DATEN           ; Segmentadresse vom Datenbereich
	  mov      ds, ax              ;  in das DS-Segmentregister laden
	  mov      es, ax              ;  in das ES-Segmentregister laden
	  mov      di, OFFSET VINF     ; OFFSET für ausgewählten Datenbereich (512 Bytes)
	  mov      ax, 4F00h           ; Vesa Funktionsnummer 0 Vesa-Bios-Info
	  int 10h                      ;  holt 512 Bytes nach es:di (Datensegment:VINF)
	  cmp      ax, 4Fh             ; Wenn Rückgabewert "4F", dann war Funktion erfolgreich
	  jnz NOVESA                   ;  sonst FEHLER: Kein Vesabios vorhanden

	  mov      dl, [di+5]          ; Major version number of Vesa über ds:di+5 in das dl-Register holen
	  cmp      dl, 2               ;  kleiner als Version 2 ?
	  jb  VESA1                    ;  wenn ja FEHLER: Keine Modeliste vorhanden.

     mov      dx, OFFSET HEADER
     mov      ah, 9
     int 21h

	  lfs      si, [di+0Eh]        ; Pointer der Modeliste über ds:di+E ins fs-Segmentregister und si-Offsetregister laden

MODE:  mov      cx, fs:[si]         ; Modenummern über fs:si ins cx-register holen
	  add      si, 2               ; Qell-Adresszeiger(Offset) erhöhen
	  cmp      cx, 0FFFFh          ;  Ende der Liste erreicht?
	  jz  MEND
          
     mov      ax, cx
     call HEXOUT16                ; Modenummer ausgeben

	  mov      ax, 4F01h           ; Modus spezifische Info holen
     mov      di, OFFSET MINF
	  int 10h                      ; es:di 256 byte
	  cmp      ax, 4Fh
	  jnz short NOVESA             ; FEHLER: wird nicht unterstützt

	  mov      ax, [di+12h]        ; MaxX
     call DEZOUT16

     mov      dx, OFFSET X
     mov      ah, 9
     int 21h

	  mov      ax, [di+14h]        ; MaxY
     call DEZOUT16

     mov      dx, OFFSET X
     mov      ah, 9
     int 21h

     xor      ax, ax
     mov      al, [di+19h]        ; Bit per pixel?
     call DEZOUT16

     mov      dx, OFFSET SPACE
     mov      ah, 9
     int 21h

	  and      BYTE PTR[di], 80h   ;  linear access enable ?
     jz  short NOLIN
     mov      eax, [di+28h]       ;  linearer Bild-Offset vorhanden ?
     call HEXOUT32

NOLIN:    mov      dx, OFFSET CRLF
          mov      ah, 9
          int 21h
          jmp MODE
;-------------------------------------
 org START + ((($-START)/16)*16)+16   ; Code-Ausrichtung
;-------------------------------------
NOVESA:   mov      dx, OFFSET T1
          mov      ah, 9
          int 21h
          mov      cl, 0FFh
          jmp short ERREND
;-------------------------------------
 org START + ((($-START)/16)*16)+16   ; Code-Ausrichtung
;-------------------------------------
VESA1:    mov      dx, OFFSET T2
          mov      ah, 9
          int 21h
          mov      cl, 1
          jmp short ERREND
;-------------------------------------
 org START + ((($-START)/16)*16)+16   ; Code-Ausrichtung
;-------------------------------------
MEND:     xor      cl, cl
ERREND:   mov      al, cl             ; ERRORLEVEL holen
          mov      ah, 4Ch            ; Rücksprung zu DOS, Programm-Ende
          int 21h
;----------------------------------------------------------------------------
; AX nach fünf dezimalen ASCII's wandeln und im Daten-Bereich ablegen
;----------------------------------------------------------------------------
 org START + ((($-START)/16)*16)+16   ; Code-Ausrichtung
;-------------------------------------
DEZOUT16: pusha
          mov      di, OFFSET DEZ16
          mov      cl, 5              ; fünf dezimale ASCII's
          mov      bx, 10000
WANDEL:   xor      dx, dx
          div      bx
          add      al, 30h            ; nach ASCII wandeln
          mov      si, dx             ; Rest retten
          mov      [di], al           ; Ziffer retten
          inc      di                 ; Zeiger erhöhen
          mov      ax, bx
          mov      bx, 0Ah
          xor      dx, dx
          div      bx
          mov      bx, ax
          mov      ax, si
          dec      cl
          jnz WANDEL
;-------------------------------------
          mov      si, OFFSET DEZ16 -1 ; erste(n) Null(en) überlesen
          mov      dx, si
          inc      dx
NULL:     inc      si
          cmp     BYTE PTR[si], "0"
          jz  NULL
          sub      si, 5
          cmp      si, dx
          jz  short AUSG              ; keine null vorhanden !
          add      si, 5
          mov      dx, si
AUSG:     mov      ah, 9              ; dezimale Zahl ausgeben
          int 21h
          popa
          ret
;----------------------------------------------------------------------------
; EAX nach acht hexadezimale ASCII's wandeln und im Daten-Bereich ablegen
;----------------------------------------------------------------------------
 org START + ((($-START)/16)*16)+16   ; Code-Ausrichtung
;-------------------------------------
HEXOUT32: pusha
          mov      di, OFFSET HEX32   ; Doppel-Word nach Hex-Ziffern wandeln
          mov      cl, 8              ; 8 Ziffern
A:        rol      eax, 4             ; 1 Nibble weiter
          mov      bl, al
          and      bl, 0Fh            ; nur low-Nibble
          add      bl, 30h            ; nach ASCII wandeln
          cmp      bl, 39h            ;  größer als Ziffer neun ?
          jna short B
          add      bl, 7              ; dann Buchstabe von "A" bis "F"
B:        mov      [di], bl           ; ASCII retten
          inc      di                 ; Zeiger erhöhen
          dec      cl                 ; Ziffer-Anzahl verringern
          jnz A
;-------------------------------------
          mov      dx, OFFSET HEX32
          mov      ah, 9              ; hexadezimale Zahl ausgeben
          int 21h
          popa
          ret
;----------------------------------------------------------------------------
; AX nach vier hexadezimale ASCII's wandeln und im Daten-Bereich ablegen
;----------------------------------------------------------------------------
 org START + ((($-START)/16)*16)+16   ; Code-Ausrichtung
;-------------------------------------
HEXOUT16: pusha
          mov      di, OFFSET HEX16   ; Word nach Hex-Ziffern wandeln
          mov      cl, 4              ; 4 Ziffern
C:        rol      ax, 4              ; 1 Nibble weiter
          mov      bl, al
          and      bl, 0Fh            ; nur low-Nibble
          add      bl, 30h            ; nach ASCII wandeln
          cmp      bl, 39h            ;  größer als Ziffer neun ?
          jna short D
          add      bl, 7              ; dann Buchstabe von "A" bis "F"
D:        mov      [di], bl           ; ASCII retten
          inc      di                 ; Zeiger erhöhen
          dec      cl                 ; Ziffer-Anzahl verringern
          jnz C
;-------------------------------------
          mov      dx, OFFSET HEX16
          mov      ah, 9              ; hexadezimale Zahl ausgeben
          int 21h
          popa
          ret
  CODE ends
;----------------------------------------------------------------------------
  DATEN SEGMENT use32 'DATA'
;-------------------------------------
VINF      DB 512 dup (0AAh)            ; Vesa-Info(4F00)
MINF      DB 512 dup (44h)             ; Mode-Info(4F01)
DEZ16     DB "00000","$"
HEX32     DB "00000000 ","$"
HEX16     DB "0000 ","$"
HEADER    DB "Vesamode,XRes,YRes,Bits per Pixel,Adresse des Framebuffer",0Dh,0Ah,"$"
CRLF      DB 0Dh,0Ah,"$"
X         DB "x","$"
SPACE     DB " ","$"
T1        DB "Kein Vesabios vorhanden.", 0Dh, 0Ah, "$"
T2        DB "Keine Modeliste vorhanden.", 0Dh, 0Ah, "$"
  DATEN ends
;----------------------------------------------------------------------------
  STAPEL SEGMENT use16 STACK 'STACK'
       DB 100h dup (88h)
  STAPEL ends
 end

Edit: Genauere Angaben findet man im "vbe3.pdf" von vesa.org. Ein Registrieren und/oder Einloggen ist aber erforderlich, da die Seite mit den "public documents" erst zur Laufzeit neu generiert wird und nur für eine gewisse Dauer existiert und sich für einen permanenten Link daher nicht mehr eignet und ältere Links dahin ungültig wurden.
Es gibt aber auch Kopien davon im internet (vermutlich ohne Rechte zur Verbreitung dafür).

Edit2:

Function 00h - Return VBE Controller Information
Input: AX = 4F00h Return VBE Controller Information
ES:DI = Pointer to buffer in which to place
VbeInfoBlock structure
(VbeSignature should be set to 'VBE2' when
function is called to indicate VBE 3.0 information
is desired and the information block is 512 bytes in
size.)
Output: AX = VBE Return Status

Code: Alles auswählen

he VbeInfoBlock information block 
size is 256
bytes for VBE 1.x, and 512 bytes for VBE 2.0+.
The information block has the following structure:
VbeInfoBlock struc
VbeSignature db 'VESA' ; VBE Signature
VbeVersion dw 0300h ; VBE Version
OemStringPtr dd ? ; VbeFarPtr to OEM String
Capabilities db 4 dup (?) ; Capabilities of graphics controller
VideoModePtr dd ? ; VbeFarPtr to VideoModeList
TotalMemory dw ? ; Number of 64kb memory blocks
; Added for VBE 2.0+
OemSoftwareRev dw ? ; VBE implementation Software revision
OemVendorNamePtr dd ? ; VbeFarPtr to Vendor Name String
OemProductNamePtr dd ? ; VbeFarPtr to Product Name String
OemProductRevPtr dd ? ; VbeFarPtr to Product Revision String
Reserved db 222 dup (?) ; Reserved for VBE implementation scratch
; area
OemData db 256 dup (?) ; Data Area for OEM Strings
VbeInfoBlock ends.

------------------------------------------------------------------------------------

Mit der Modenummer und Funktion 1 Mode speziefische Informationen abrufen
Dafür benötigen wir 256 Bytes.

Function 01h - Return VBE Mode Information
Input: AX = 4F01h Return VBE mode information
CX = Mode number
ES:DI = Pointer to ModeInfoBlock structure
Output: AX = VBE Return Status
Note: All other registers are preserved.
This required function returns extended information about a specific VBE display
mode from the mode list returned by VBE Function 00h. This function fills the mode information
block, ModeInfoBlock, structure with technical details on the requested mode.
The ModeInfoBlock structure is provided by the application with a fixed size of 256 bytes.
Information can be obtained for all listed modes in the VideoModeList returned in Function 00h.
If the requested mode cannot be used or is unavailable, a bit will be set in the ModeAttributes
field to indicate that the mode is not supported in the current configuration.

Code: Alles auswählen

ModeInfoBlock struc
; Mandatory information for all VBE revisions
ModeAttributes dw ? ; mode attributes
WinAAttributes db ? ; window A attributes
WinBAttributes db ? ; window B attributes
WinGranularity dw ? ; window granularity
WinSize dw ? ; window size
WinASegment dw ? ; window A start segment
WinBSegment dw ? ; window B start segment
WinFuncPtr dd ? ; real mode pointer to window function
BytesPerScanLine dw ? ; bytes per scan line
; Mandatory information for VBE 1.2 and above
XResolution dw ? ; horizontal resolution in pixels or characters
3
YResolution dw ? ; vertical resolution in pixels or characters
XCharSize db ? ; character cell width in pixels
YCharSize db ? ; character cell height in pixels
NumberOfPlanes db ? ; number of memory planes
BitsPerPixel db ? ; bits per pixel
NumberOfBanks db ? ; number of banks
3 Pixels in graphics modes, characters in text modes..VBE Function Reference
VBE CORE FUNCTIONS VERSION 3.0 Page 31
MemoryModel db ? ; memory model type
BankSize db ? ; bank size in KB
NumberOfImagePages db ? ; number of images
Reserved db 1 ; reserved for page function
; Direct Color fields (required for direct/6 and YUV/7 memory models)
RedMaskSize db ? ; size of direct color red mask in bits
RedFieldPosition db ? ; bit position of lsb of red mask
GreenMaskSize db ? ; size of direct color green mask in bits
GreenFieldPosition db ? ; bit position of lsb of green mask
BlueMaskSize db ? ; size of direct color blue mask in bits
BlueFieldPosition db ? ; bit position of lsb of blue mask
RsvdMaskSize db ? ; size of direct color reserved mask in bits
RsvdFieldPosition db ? ; bit position of lsb of reserved mask
DirectColorModeInfo db ? ; direct color mode attributes
; Mandatory information for VBE 2.0 and above
PhysBasePtr dd ? ; physical address for flat memory frame buffer
Reserved dd 0 ; Reserved - always set to 0
Reserved dw 0 ; Reserved - always set to 0
; Mandatory information for VBE 3.0 and above
LinBytesPerScanLine dw ? ; bytes per scan line for linear modes
BnkNumberOfImagePages db ? ; number of images for banked modes
LinNumberOfImagePages db ? ; number of images for linear modes
LinRedMaskSize db ? ; size of direct color red mask (linear modes)
LinRedFieldPosition db ? ; bit position of lsb of red mask (linear modes)
LinGreenMaskSize db ? ; size of direct color green mask (linear modes)
LinGreenFieldPositiondb ? ; bit position of lsb of green mask (linear modes)
LinBlueMaskSize db ? ; size of direct color blue mask (linear modes)
LinBlueFieldPosition db ? ; bit position of lsb of blue mask (linear modes)
LinRsvdMaskSize db ? ; size of direct color reserved mask (linear modes)
LinRsvdFieldPosition db ? ; bit position of lsb of reserved mask (linear modes)
MaxPixelClock dd ? ; maximum pixel clock (in Hz) for graphics mode
Reserved db 189 dup (?) ; remainder of ModeInfoBlock
ModeInfoBlock ends

Es fehlen noch weitere Tabellen und eine Erklärung dafür.

Dirk

[freecrac]

@freeac
Pascal kennt dafür den Befehl Exec.

Ok, das wird denn doch einfacher den Befehl auch zu verwenden.

Dirk