5.10. Parameterr�ckgabe mit dem Inline-ASM
    -------------------------------------------
    Im Gegensatz zum reinem Assembler l„uft die R�ckgabe einer Variablen
    im PowerBASIC Inline-Assembler leicht anders ab. PowerBASIC 3.0 ge-
    stattet z.B. nicht die direkte šbergabe aus dem Inline-Assembler an
    die FUNCTION, dies ist nur �ber einen kleinen Trick m”glich.
     
    Beispiel: 
            High% = &h1234
            Low%  = &h4578
            PRINT HEX$(Demo1&(High%, Low%))
 
            FUNCTION Demo1&(BYVAL High%, BYVAL Low%)
                    LOCAL Dummy&
                    ! mov dx, High%
                    ! mov ax, Low%
                    ! mov Dummy&[02], dx
                    ! mov Dummy&[00], ax
                    Demo1& = Dummy&
            END FUNCTION
 
    Ab PowerBASIC 3.1 k”nnen Sie den R�ckgabewert aber direkt an die
    FUNCTION �bergeben, nur bei 32bit (und gr”áeren) Werten m�ssen Sie
    wieder einen kleinen Kniff anwenden:
     
    Beispiel:
            High% = &h1234
            Low%  = &h4578
            PRINT HEX$(Demo2&(High%, Low%))
 
            FUNCTION Demo2&(BYVAL High%, BYVAL Low%)
                    ! mov dx, High%
                    ! mov ax, Low%
                    ! mov FUNCTION[02], dx
                    ! mov FUNCTION[00], ax
            END FUNCTION
 
 
    5.11. Variablen�bergabe in Interrupt-Prozeduren
    ------------------------------------------------
    Sehr schwierig ist die šbergabe von Variablen innerhalb einer eigenen
    Interruptroutine, da sie davon ausgehen k”nnen, das das Datensegment
    mit hoher Sicherheit nicht dem ben”tigtem Datensegment von PowerBASIC
    entspricht. Allerdings auch hier haben uns die Entwickler von PowerBASIC
    eine groáe Hintert�r offen gelassen. Die Adressierung �ber das Code-
    segment, welches in der Regel immer gleich ist! Allerdings klappt dieser
    Trick nur im Inline-Assembler, zur šbergabe von/zu reinen PowerBASIC
    Routinen m�ssen sie diese Variable umkopieren.
 
    Beispiel:
            ! mov ax, &h1234
            ! mov Demo, ax
            ! mov bx, Demo            
            ! retn
            
            Demo:
            ! dw 0
 
    Sollten Sie sich diese Sache unter einem Debuger ansehen, so werden sie
    feststellen das PowerBASIC vor dem Variablenzugriff das Pr„fix &h2E
    (Adressierung �ber das Codesegment) voranstellt und das '! dw 0'-Feld
    den Wert &h1234 angenommen hat.
 
 
    5.12. Erstellen von 32bit-Zeigern
    ----------------------------------
    Oft werden 32bit Zeiger ben”tigt um eigene Interrupt-Prozeduren, alte
    Interrupt-Handler oder auch Ger„tetreiber wie CTVDSK/CT-VOICE und
    HIMEM/MSCDEX aufzurufen. Da die Erstellung des 32bit Zeigers in einem
    der vorangegangenden Abs„tze beschrieben wurde, hier nur noch der
    eigentliche Syntax:
    
    Beispiel: 
            ! jmp dword Demo&
            ! jmp dword ptr Demo&
            ! call dword Demo&
            ! call dword ptr Demo&
 
    Die Zeiger k”nnen ebenfalls dem Codesegment entnommen werden!
 
 
    5.13. Konvertierung von REG nach Inline-ASM
    -------------------------------------------
    Ebenfalls recht einfach l„uft die Umsetzung von REG- nach Inline-
    Assemblersourcen ab. Im Gegensatz zum REG-Befehl, welcher die Inhalte
    der Prozessorregister in einem internen REG-Array zwischenpuffert, be-
    wirkt ein Zugriff �ber den Inline-Assembler sofort eine direkte Mani-
    pulierung der Prozessorregister. Der REG-Befehl �bergibt die REG-Werte
    erst beim Aufruf von CALL INTERRUPT. Bitte beachten Sie diesen Unter-
    schied und Sie werden weniger Probleme haben.
    Ansonsten k”nnen Sie zum Beispiel folgende Befehle 1:1 umsetzen:
    
    Beispiele:
            REG 1, &h12345           -> ! mov ax, &h1234
            REG 2, &hFF              -> ! mov bl, &hFF
            REG 3, &h22 * 256        -> ! mov ch, &h22
            REG 4, &hAABB            -> ! mov dh, &hAA
                                        ! mov dl, &hBB
            REG 9, Demo%             -> ! mov es, Demo%
            CALL INTERRUPT &h21      -> ! int &h21
            Low?? = REG(1) AND 255   -> ! mov low??, al
            High?? = REG(1) \ 256    -> ! mov High??, ah


    5.14. Konvertierung von A86 nach Inline-ASM
    -------------------------------------------
    Prinzipiell ohne Probleme l„uft eine Umsetzung von A86-Sourcen ab. Ent-
    fernen Sie einfach den Stackrahmen und binden Sie die Assemblerzeilen
    einfach in Ihren Inline-Assembler ein. Am besten ist es, wenn Sie dazu
    einen Funktionsaufruf erstellen, der die Variablen immer BYVAL �bergibt,
    den Rest erledigt PowerBASIC.