8. Tip's bei der Konvertierung von Sourcen von PDS nach PowerBASIC 3.x

(von Mark Junker@2:2437/47.21 / mjs@prg.hannover.sgh-net.de)

English


Generell kann man sagen, daß PDS-Sourcen in PB3-Sourcen konvertiert werden können. Ausnahmen sind z.B. Sourcen, die auf Fremd-Bibliotheken zurückgreifen oder in einer TYPE-Struktur dimensionierte Elemente benutzen.

Also, folgendes verhindert eine Umsetzung:
        - Fremd-Bibliotheken
          (wie z.B. die VESA-LIB und was es sonst noch so gibt ...)

        - In einer TYPE-Struktur dimensionierte Elemente
          Beispiel:
                  TYPE tTest
                          TestElement1         AS LONG
                          TestElement2(2 to 7) AS INTEGER
                          TestElement3         AS LONG
                  END TYPE

        - Es darf kein COMMON vorkommen, wohl aber alle Varianten des
          COMMON SHARED- Befehls.
          Ausnahmen:
                  - Wenn COMMON benutzt wird, um Parameter an eine mit CHAIN
                    aufgerufene Datei zu uebergeben.
                  - Wenn es egal ist, wenn die hinter COMMON angegebenen
                    Variablen in allen Prozeduren verfügbar sind.

        - Arrays mit mehr als 8 Dimensionen
        - es gibt noch kein ausreichend flexibles REDIM PRESERVE
        - Mehr als 16 Parameter bei Aufruf einer Prozedur

Wenn diese Bedingungen erfüllt sind, dann sind folgende Dinge bei einer Konvertierung zu beachten:
    Basic PDS:                       |PowerBASIC 3:
    -------------------------------------------------------------------------
    SSEG                             |STRSEG
    SADD                             |STRPTR
    SSEGADD                          |STRPTR32
                                     |STRPTR32 gibt es erst ab PB3.2
    VARSEG/VARPTR                    |ACHTUNG: PB3 liefert VORZEICHENLOSE
                                     |Werte zurück, PDS dagegen VORZEICHEN-
                                     |BEHAFTETE.
                                     |Dies kann per $OPTION SIGNED OFF
                                     |geändert werden.
    -------------------------------------------------------------------------
    Offset bei einer per OPEN ge-    |In PB fängt eine Datei - je nach
    öffneten Datei fängt bei '1' an! |Wahl - bei Null (Standard) oder bei
                                     |Eins an. Dieses kann mit folgendem
                                     |Befehl eingestellt werden:
                                     |OPTION BINARY BASE 1
                                     |für den Anfang bei '1'
    -------------------------------------------------------------------------
    DIM SHARED VarName%              |Dieser Befehl kann auf zweifache
                                     |Art und Weise umgesetzt werden:
                                     |- DIM VarName%
                                     |  SHARED VarName%
                                     |- DIM VarName AS SHARED INTEGER
    -------------------------------------------------------------------------
    SHARED VarName() AS STRING*3     |Hier tritt das Problem
                                     |mit den Strings fester Laenge auf, wenn
                                     |sie nicht im Haupt-Programm geSHARED
                                     |werden koennen.
                                     |Hinter SHARED dürfen zu Variablen
                                     |keine Typen-Angaben ('AS xxx') stehen.
                                     |Also:    SHARED VarName as string
                                     |Wird zu: SHARED VarName$
                                     |   oder: SHARED VarName :'in SUBs !
                                     |
                                     |Bei FIXED-LENGTH-STRING-Arrays kann
                                     |man sie SHAREn, indem man folgenden
                                     |Befehl benutzt:
                                     |DIM VarName(MIN,DimNum) AS STRING*3
                                     |oder
                                     |DIM VarName(MAX,DimNum) AS STRING*3
                                     |wobei 'DimNum' die Anzahl der
                                     |Dimensionen des Arrays ist und im
                                     |Source direkt eine Zahl eingetragen
                                     |sein muß.
    -------------------------------------------------------------------------
    COMMON SHARED /Block/ VarN%      |Alle drei Varianten des COMMON-
    COMMON SHARED VarN%              |Befehls muessen leider im Haupt-
                                     |Programm durch ein PUBLIC und in dem
                                     |externen Modul (unter PB: UNIT) durch
                                     |ein EXTERNAL ersetzt werden. Dabei muß
                                     |beachtet werden, daß die Variablen-
                                     |Namen eindeutig sein MÜSSEN. Sie sind
                                     |also UNABHÄNGIG vom DATENTYP !!!
                                     |Alle Typen-Angaben 'AS xxx' sind in
                                     |PB3 unzuläßig.
                                     |Die Block-Angabe (/Block/) fällt bei
                                     |PB weg, da hier alles Namens-Abhängig
                                     |ist. (-> Inkompatibilität !)
    -------------------------------------------------------------------------
    COMMON VarN%                     |Kann nur dann umgesetzt werden, wenn
                                     |die hinter COMMON angegebene Variable
                                     |an ein, mit dem CHAIN-Befehl,
                                     |aufgerufenes Programm uebergeben werden
                                     |soll oder aber das COMMON i.E. auch
                                     |ein COMMON SHARED sein könnte.
                                     |Es sind hier, wie auch bei COMMON
                                     |SHARED alle Typen-Angaben ('AS xxx')
                                     |zu einer Variable zu entfernen.
    -------------------------------------------------------------------------
    '$INCLUDE: 'filename.ext'        |$INCLUDE "filename.ext"
    '$DYNAMIC                        |$DYNAMIC
    '$STATIC                         |$STATIC
    -------------------------------------------------------------------------
    CONST VarName$ = "xyz"           |Hier muß im Programm direkt
    CONST VarName# = 1.23            |überall der Variablen-Name
    CONST VarName! = 1.23            |durch den dazugehörigen Wert er-
    CONST VarName@ = 1.23            |setzt werden.
    -------------------------------------------------------------------------
    CONST VarName% = 123             |Wird beidemale zu:
    CONST VarName& = 123             |%VarName = 123
                                     |Wird ein Konstanten-Name doppelt, aber
                                     |mit unterschiedlichem Datentypen
                                     |verwendet so ist im gesamten Source
                                     |einer der beiden Namen zu ändern.
                                     |Im Programm muss dann auch ueberall
                                     |'VarName%' oder 'VarName&' durch
                                     |'%VarName' ersetzt werden.
    -------------------------------------------------------------------------
    IF x THEN : ' Test               |In PB braucht nur der ':' entfernt zu
     irgendwas                       |werden und schon läßt es sich hier
    END IF                           |problemlos kompilieren.
    -------------------------------------------------------------------------
    DIM x AS STRING*3                |Dieser FIXED-LENGTH-STRING kann
    CALL Test(x)                     |in PB nicht problemlos an eine
    END                              |Prozedur uebergeben werden, da
    SUB Test(x$)                     |PB hier einen VARIABLE-LENGTH-
    END SUB                          |STRING erwartet oder im Kopf der
                                     |SUB-Prozedur anstelle des 'x$'
                                     |ein 'x AS STRING*3'. Man muß
                                     |hier bei PB also ggf. den Umweg
                                     |über einen temporaeren String gehen:
                                     |dummy$=x
                                     |CALL Test(dummy$)
                                     |x=dummy$
    -------------------------------------------------------------------------
Ideal ist es, für das Problem der Konstanten-Konvertierung einen Konverter zu schreiben, denn dies dürfte den Löwen-Anteil bei der Konvertierung großer Programme ausmachen. Im gleichen Zuge kann man natürlich auch die Sache mit den COMMON SHAREDs und den DIM SHAREDs und natürlich auch den META-Statements, sowie SSEG/SADD/SSEGADD ersetzen.

Wenn Interrupt-Aufrufe mit einem CALL INTERRUPT oder CALL INTERRUPTX gemacht werden, so kann man entweder in ASM die Routine 'INTERRUPTX' nachbilden und alle Aufrufe von 'INTERRUPT' nach 'INTERRUPTX' konvertieren oder man setzt es direkt in INLINE-ASM um oder aber man benutzt die PowerBASIC-eigene 'CALL INTERRUPT'-Routine, wobei man dann alle Registerzuweisungen konvertieren muß ...


(c) 1995/2007 by Thomas Gohel & Mark Junker, All rights and bug's reserved