SHOW_CMD: Zeig mir Deine Command Line!

Manchmal möchte man einem Programm Parameter übergeben, weiss aber nicht, in welcher Form. Ein anderes Programm übergibt die Parameter richtig. Nun müsste es doch eine Möglichkeit geben, herauszufinden, was dieses Programm übergibt...

Diese Möglichkeit gibt es auch. Man braucht einfach nur ein Programm, das die erhaltenen Parameter auf dem Monitor ausgibt. Wie geschieht das? Ganz einfach: Beim Starten eines Programmes mit Hilfe von Pexec(), und damit startet auch das Desktop die Programme, kann man Parameter übergeben. Die sogenannte Command Line steht ab Position $80 in der Basepage, dem Teil des Programmes, das das GEMDOS erzeugt und in dem alle Informationen zu Programmlänge und Sektoraufteilung stehen. Das Byte mit dem Offset $80 am Beginn der Basepage gibt die Anzahl der Zeichen an, die übergeben werden; danach kommt gleich die eigentliche Command Line. Bleibt nur noch ungeklärt, wie man an die Anfangsadresse der Basepage kommt. Nichts leichter als das: Sie liegt auf dem Stack. Man braucht sie sich also nur zu holen und weiß dann die Anzahl und die Adresse der auszugebenden Zeichen. Diese kann man mit der GEMDOS-Funktion Conout auf den Bildschirm schreiben. Das folgende Programm SHOW_CMD tut genau das. Es folgt noch ein Zeilenvorschub und es wird auf einen Tastendruck gewartet, damit man genug Zeit hat, die ausgegebene Command Line auch zu lesen. Ist die Anzahl der auszugebenden Zeichen gleich 0, wird das Programm sofort beendet. Somit läßt sich leicht feststellen, ob überhaupt Parameter übergeben wurden. Soweit zur Arbeitsweise des Programms.

Ich habe das nachfolgende Listing mit dem Assembler von Metacomco übersetzt, aber auch mit anderen Assemblern dürfte es keine Probleme geben, notfalls müssen vor die Direktiven text und end ein Punkt. Ist das Programm abgetippt und assembliert, sollte man ihm den Namen des Programmes geben, das die Parameter erhält. Wird SHOW_CMD dann von dem Parameter-übergebenden Programm aufgerufen, kann man die Command Line auf dem Bildschirm ablesen. Es dürfte jetzt kein Problem mehr sein, selber eine entsprechende Command Line zu basteln, ein Aufruf aus eigenen Programmen ist möglich. Bleibt mir nur noch, viel Spaß beim eigenen Experimentieren zu wünschen!

**************************************************
*                                                *
*    SHOW_CMD - zeigt die übergebene Command Line*
*                                                *
*    geschrieben von:   Oliver Kuhn              *
*                       Heinrich-Heine-Str. 28   *
*                       3550 Marburg             *
*                                                *
*    Version vom 10.10.88                        *
*    (c) MAXON Computer GmbH 1990                *
**************************************************

        text                ; Programm benutzt nur
                            ; Textsegment
        move.l  4(sp),a6    ; Anfangsadresse Basepage 
                            ; -> a6

        lea     $80{a6),a5  ; Anfangsadresse
                            ; Command Line -> a5 
        clr.w   d7          ; d7 löschen, damit oberes 
                            ; Byte 0 ist 
        move.b  (a5)+,d7    ; Anzahl der Zeichen
                            ; -> d7
        tst.b   d7          ; Sind überhaupt Zeichen
                            ; auszugeben ? 
        beq     ende        ; wenn nicht, beenden
        subq.w  #1,d7       ; d7 für dbra um 1 
                            ; verringern

aus:                        ; hier beginnt die
                            ; Ausgabeschleife 
        clr.w   d0          ; d0 löschen, damit oberes 
                            ; Byte 0 ist 
        move.b  (a5)+,d0    ; Zeichen in d0
                            ; zwischenspeichern 
        move.w  d0,-(sp)    ; Zeichen für Ausgabe 
                            ; auf Stack legen 
        move.w  #2,-(sp)    ; Funktionscode 'Conout'
                            ; auf Stack legen 
        trap    #1          ; GEMDOS aufrufen
        addq.l  #4,sp       ; Stack restaurieren
        dbra    d7,aus      ; wenn noch Zeichen
                            ; auszugeben sind nach 
                            ; aus springen

        move.w  #$D,-(sp)   ; CR (Carriage Return)
                            ; auf Stack legen
        move.w  #$2,-(sp)   ; Funktionscode 'Conout'
                            ; auf Stack legen
        trap    #1          ; GEMDOS aufrufen
        addq.l  #4,sp       ; Stack restaurieren

        move.w  #$A,-(sp)   ; LF (Linefeed) auf
                            ; Stack legen 
        move.w  #$2,-(sp)   ; Funktionscode 'Conout'
                            ; auf Stack legen 
        trap    #1          ; GEMDOS aufrufen
        addq.l  #4,sp       ; Stack restaurieren

        move.w  #7,-(sp)    ; Funktionscode
                            ; 'Direct Con Without Echo'
                            ; auf Stack legen 
        trap    #1          ; GEMDOS aufrufen
        addq.l  #2,sp       ; Stack restaurieren


ende    clr.w   -(sp)       ; Funktionscode 'Term' auf 
                            ; Stack legen 
        trap    #1          ; mit GEMDOS-Aufruf
                            ; Programm beenden

        end