Power Basic vs. Quick Basic. (2)

Na het eerst deel van deze reeks ben ik door enkele leden,vanwege een domme fout, op de vingers getikt. En terecht. Ik druk hieronder een groot deel van een reactie af. Daarmee wordt dan duidelijk waar ik in de fout ben gegaan.
-----------------------------------------------------------------------------
Hoi Sjef,

Ik zit zojuist je vergelijking tussen QB en PB te lezen in de BASIC gg nieuwsbrief. Wat ik nogal vreemd vond waren al je DIM voorbeelden.

DIM a% AS STRING

geeft bijvoorbeeld bij mij toch echt een foutmelding. Ik zou ook niet weten wat het zou moeten doen, een variable die integer is maar toch string?

Nog een kleine opmerking: PowerBASIC ondersteund alleen integer constanten terwijl QB constanten van alle typen ondersteund. In ieder geval in de versie die ik heb (3.20).

Verder geeft het tot nu toe een goed overzicht op de verschillen, ik neem aan dat je in de volgende nieuwsbrief gaat vertellen dat PowerBASIC programma's ongeveer 25x zo snel zijn en dat het inline assembly ondersteund?:)
Marcel Veldhuizen
-----------------------------------------------------------------------------
Dat is dan duidelijk. Marcel heeft dus gelijk. Achter een niet array gebonden dimensionering kan geen procenttenken staan. Als je dat weglaat zal er geen foutmelding plaats vinden. Wat de constanten in Power Basic betreft, wil ik nog even opmerken dat alleen integers met het procentteken ervoor als constanten gezien worden.  Met het procentteken erachter is het een gewone integervariabel.
Ik zie bovenstaande reactie, mede vanwege de verdere opmerkingen, dan ook als een bijdrage voor deze nieuwsbrief. Hij kan dus rekenen op een gratis toezending van de diskette van dit kwartaal.
*****************************************************************************

En nu het vervolg van de serie. Dit keer worden de metastatemens van Power Basic behandeld en waar mogelijk vergeleken met de vergelijkbare switches van Quick Basic. Het komt er in dit deel eigenlijk op neer dat in hoofdzaak -in alphabetische volgorde- over Power Basic  wordt geschreven. Sommige metastatements staan op zichzelf, bij andere is het mogelijk om uit verschillende opties te kiezen, waarbij maar een mogelijkheid toegestaan is. Sommige woorden zijn begrijpelijker in de engelse taal dan in het nederlands. Daar heb ik dus geen poging gedaan om ze te vertalen.
* * * * *

$ALIAS 
Hiermee is het mogelijk om een segment in een externe .OBJ module te   "renamen". Power Basic verwacht het data segment als DATA.
	Syntax:  $ALIAS DATA AS  "external segment name".
Naar mijn weten er geen vergelijkbare switch in Quick Basic voor dit metastatement.
* * * * *

$CODE 
Met dit metastatement wordt de code segment-naam voor een unit gespecificeerd.
	Syntax:  $CODE SEG  "naam".
Power Basic combineert alle codes van units, libraries en .OBJ object modules in een of meer segmenten, gebaseerd op hun segmentnaam. De programeur geeft de naam van de object module meteen aan in de assembly source code. $CODE SEG mag alleen maar in een unit source code voorkomen.
* * * * *

$COM [size]
Reserveert geheugen voor de serie-eele poort buffer. De rechthoekige haakjes geven aan dat de grootte niet persee hoeft worden aangegeven. Die mag dus naar believen weggelaten worden. Dit metastatement bepaalt de grootte van alle communicatiebuffers. Ze kunnen dus niet apart gezet worden. De grootte kan van 0 tot 32767 gezet worden en wordt altijd naar een veelvoud van  16 bytes naar boven afgerond. Als de grootte niet wordt aangegeven wordt die standaard op 256 bytes gezet.
De compiler switch voor QB is /C
* * * * *

$COMPILE (MEMORY | EXE ["naam" | CHAIN ["naam"] | UNIT ["naam"])
Als dit metastatement niet gebruikt wordt zal altijd een .EXE-file worden aangemaakt. Met $COMPILE MEMORY is dat niet het geval. Dan wordt het programma direct in de IDE uitgevoerd. Met de toevoegingen EXE, CHAIN of UNIT kan eventueel een eigen gekozen naam gegeven worden. Staat er geen naam achter een van deze drie toevoegingen dan wordt de naam van source code toegekent. Bent u pas begonnen en u heeft vergeten een naam aan uw programma te geven ontstaat er logischerwijs een NONAME.EXE.
* * * * *

$CPU ( 8086 | 80286 | 80386 )   
Hiermee kunt u bepalen voor welke microprcessor uw progrmma gemaakt is. Als het programma niet geschikt is voor een 8086 microprosessor dan zult u minstens $CPU 80286 voor in uw programma moeten zetten. Als u dit metastatement weglaat is het programma voor elk systeem toegankelijk. Indien uw programma alleen maar kan draaien op een 80386-systeem of hoger dan kiest u voor $CPU 80386. Het programma zal alleen maar geschikt zijn voor een syteem met een 80386-microprosessor of hoger. Een Pentium-systeem valt hier dus ook onder.
* * * * *

$DEBUG   
Hiermee wordt debuginformatie gegenereerd. Voor het gebruik hiervan kunt u kiezen uit vier verschillende mogelijkheden en bijbehorende opties:
	$DEBUG) MAP 	( ON | OFF )
	$DEBUG PBDEBUG	( ON | OFF )
	$DEBUG PATH	( ON | OFF )
	$DEBUG UNIT	( ON | OFF )
Desgewenst mag u voor ON het plusteken (+) gebruiken en voor OFF het minteken (-). $DEBUG MAP + is dus ook legaal.
De compiler switch voor QB is /D
* * * * *
   
$DIM ( ALL | ARRAY | NONE ) 
Met dit metastatement wordt u gedwongen om te dimensoneren, behalve met de optie NONE. $DIM NONE is standaard. Het programma wordt gecompileerd alsof dit metastatement er niet staat. Met deze optie heeft het geen nut. Wel echter met bijvoorbeeld $DIM ARRAY. Als u dat voor in uw programma heeft opgenomen zult u alle array's moeten dimensioneren, ook als u het commando REDIM gebruikt . Normaal is het is BASIC mogelijk om tot elf velden (0 t/m 10) in te vullen, zonder dat er een foutmelding verschijnt. In Power Basic wordt dus ook automatisch gedimensioneerd.  Niet echter met $DIM ARRAY. Als u hierna probeert om bijvoorbeeld A$ (5) =  "Test" als naam te geven, krijgt u beslist een foutmelding. Het is echter toch wel nuttig. Stel dat u in een adressenprogramma een array netjes dimensioneert met FamilienaaM$ (n), en u tikt per abuis FamilienaaN$ (4) = "Jeeminee" in. Het verschil is slechts een letter op het eind (de hoofdletter), maar Power Basic geeft bij het compileren gelijk een foutmelding. Dat gebeurt uiteraard niet als u dit metastatement weglaat. Power Basic dimensioneert dan automatisch een nieuwe array met elf velden. Als het een groot programma is, kan het lang duren voor u de fout gevonden hebt. Nog een kleinigheid. Er kleeft een klein nadeel aan $DIM ALL. U moet in dat geval niet alleen alle array's dimensioneren maar zelfs de meest eenvoudige variabele. Bijvoorbeeld: DIM a AS LOCAL INTEGER, of DIM d AS DOUBLE.
* * * * *

$DYNAMIC 
Hiermee wordt geheugen reserveerd voor de nog te dimensioneren array's. Zonder dit metastatement zijn de toekomstige array's STATIC. Dat is standaard in Power Basic. Ruimte in het geheugen wordt pas gereserveerd bij uitvoering van het programma (in run time) en kan weer vrijgemaakt worden met ERASE. Dit in tegenstelling tot STATIC gedeclareerde array's. Daarvoor wordt al tijdens het compileren geheugen gereserveerd. (In compile time.) Het kan ook zijn dat een array-type STATIC is zonder dat u dat in de gaten heeft. Bij weglating van $DYNAMIC, zal een met nummerieke waarden gedimensioneerde array altijd van het type STATIC zijn. Echter niet als u inplaats van getallen variabelen gebruikt. Enkele voorbeelden ter verduidelijking: 

DIM x (20,20)		' x = static

 a = 20 : b = 20
DIM y (a , b+1)		' y = dynamic

DIM z (100)
COMMON z ( )		' z = dynamic
* * * * *

$ERROR test [ status ] , test [ status ], enz.
Voor test kan BOUNDS, NUMERIC, OVERFLOW, STACK of ALL worden ingevuld. Status wil zeggen ON of OFF. Voor deze kan respectievelijk ook + of - gebruikt worden. Het beste kan $ERROR ALL ON te gebruiken terwijl u programmeert. Als alle bugs verholpen zijn kan dan voor de eindcompilatie $ERROR ALL OFF gezet worden.
Nog even een voorbeeld van een combinatie:
	$ERROR BOUNDS+, NUMMERIC OFF, STACK-
	' schakel bounds-test in en schakel nummeric- en stack-test uit.
De compiler switch voor QB is /E
* * * * *

$EVENT ( ON | OFF )
Desgewenst mag u voor ON het plusteken (+) gebruiken en voor OFF het minteken (-). $EVENT genereert event-trapping code. Als uw programma een event-trap bevat van een of andere soort, bijvoorbeeld ON COM ( n ), dan zal de compiler een event-checking-code genereren. Deze code zorgt, tijdens uivoering van het programma, voor controlle op event-trapping bij, in dit voorbeeld , COM port input, enz. Event-checking-code zal uw programma echter wel vertragen.
* * * * *

$FLOAT (NPX | EMULATE | PROCEDURE )
Een programma dat gecompileerd wordt met dit metastatement en de toevoeging NPX zal alleen kunnen draaien op een systeem met een co-prosessor (8087, 80287, 80387), of een computer met een 80486-CPU of hoger. Met een van de beide andere opties zal de compiler een co-prosessor emuleren als die niet aanwezig is. Een programa dat op deze wijze is gecompileerd, zal echter niet draaien op een syteem waaraan op bovengenoemde voorwaardes niet is voldaan.
* * * * *

$HUGE 
Na dit metastatement zijn de nog te dimensioneren array's HUGE en kunnen groter zijn dan de normale maximum grootte van 64k. De array's zijn STATIC, behalve als anders wordt aangegeven. $HUGE kan teniet gedaan worden met sleutelwoorden DYNAMIC, STATIC en HUGE. Dit laatst commando is dan een onderdeel van een dimensionering.
De compiler switch voor QB is /Ah
* * * * *

$IF/$ELSE/$ENDIF
Bij het gebruik hiervan zal het deel dat van deze metastatements is voorzien gecompileerd worden als aan bepaalde condities is voldaan. Begint dit IF blok dus met $IF 0, dan zal dit hele gedeelte t/m $ENDIF, bij het compileren, overgeslagen worden. Dat is bijvoorbeeld handig voor het geven van toelichting, zonder daarvoor de remark-komma te gebruiken. In dat geval kan $ELSE uiteraard overgeslagen worden. Vanaf versie 3.5 is ook nog $ELSEIF toegevoegd. Let op dat $ELSEIF aan elkaar is geschreven, evenals $ENDIF, dit laatste in tegenstelling tot het normale IF-blok, waar END IF wel twee woorden zijn.
* * * * *

$INCLUDE  "Programma-naam"
Hiermee is het mogelijk om modulair te programmeren. Dat wil zeggen dat u onderdelen van een programma, bijvoorbeeld een reeks procedures of functies, los van het hoofdprogramma kunt maken en het met bovenstaand metastatement in kunt voegen. Als u geen extensie hieraan toevoegt neemt Power Basic aan dat het de extensie .BAS is.
* * * * *

$INLINE byte list
Dit metastatement voegt een machienetaalprogramma in op de plaats waar dit staat. Dat kan dus overal in uw programma zijn. Een voorbeeld, overgenomen uit de reference guide:

	SUB Shriek INLINE
	    $INLINE &HBA, &H00, &H07, &HE4, &H61, &H24
	    $INLINE &HFC, &H34, &H03, &HE6, &H61, &HB9
	    $INLINE &H40, &H01, &HE2, &HFE, &H4A, &H74
	    $INLINE &H02, &HEB, &HF2
	END SUB
	CALL Shriek
* * * * *

$LIB Libraryname [status], Libraryname [status], enz.
$LIB voegt  "library" code toe aan uw programma. Libraryname is een van de volgend opties:
+------------------------------------------------------+
| Library Name		| Contains functions for       |
|-----------------------|------------------------------|
| COM			| Serial communications        |
| LPT			| Printer                      |
| GRAPH			| All graphics                 |
| CGA			| CGA graphics                 |
| EGA			| EGA graphics                 |
| VGA			| VGA graphics		       |
| HERC			| Hercules graphics	       |
| FULLFLOAT		| Full floating-point emulator |
| IPRINT		| Interpreted print            |
| ALL			| All libraries                |
+------------------------------------------------------+

De HERC optie komt in versie 3.5 niet meer voor.
* * * * *

$LINK  "Programmanaam"
Hiermee wordt een verbinding gemaakt met object module(.OBJ file), unit(.PBU file), of een library(.PBL file). Dit metastatement kan alleen maar in het hoofdprogramma voorkomen, dus nooit in een unit. Een $LINK statement kan maar van n programmanaam voorzien worden en moet voorzien zijn van een extensie. Het kan meerdere malen in een programma voorkomen.
* * * * *

$OPTIMIZE ( size | speed )
Met $OPTIMIZE size genereert de compiler een kleinere .exe file. Met $OPTIMIZE speed wordt een sneller programma gecre-eerd. Het is het een of het ander.
* * * * *

$OPTION ( CNTLBREAK | GOSUB | SIGNED )[ status ]
Hiermee bepaalt u welke compiler optie aan of uit staat. Bij afwezigheid van een of andere status wordt altijd ON verondersteld. Wat status inhoud is al enkele malen uitgelegd. De meest gebruikte zal waarschijnlijk $OPTION CNTLBREAK  ON zijn. Als u deze gebruikt kan het programma willekeurig onderbroken worden. Met de toevoeging OFF is dat uiteraard niet mogelijk. 
* * * * *

$SEGMENT 
Dit metastatement is handig om grotere programma's in meerdere delen te aan te maken.
* * * * *

$SOUND size 
Hiermee wordt de grootte van de "PLAY statement's background buffer" bepaald. De toevoeging size is numeriek, kan een waarde hebben van 1 tot 4096. Iedere noot vraagt 8 bytes. De standaardcapaciteit (2048) is 32 muzieknoten of 256 karakters.
* * * * *

$STACK size
Dit metastatement bepaalt de grootte van de STACK (tijdens run time) en moet tussen 1536 en 32752 (bytes) liggen. De standaard en minimum STACK is 1536 groot. Dat is gelijk aan 600 hex. Als u denkt dat de STACK te klein is, kunt u die hiermee vergroten.
De compiler switch voor QB is /Stack
* * * * *

$STATIC
In principe gelden hier de zelfde regels als bij het $DYNAMIC metastatement.
* * * * *

$STRING ( 1 |2 | 4 | 8 | 16 | 32 ) 
Hiermee wordt de grootte van het STRING segment vastgelegd. De getallen achter het metastatement geeft de grootte in kilobytes aan. Hiervan zijn 18 bytes nodig voor de zogenaamde   "overhead". Met $STRING 4 zet u de maximumlengte van elke string vast op 4078 bytes (4096-18). 
* * * * *

Ik heb al deze metastatemens slechts globaal besproken. Had ik dat volledig gedaan dan was het te lang geworden voor plaatsing. Het is bedoeld om aan te geven waar het, in vergelijking met Quick Basic, een toegevoegde waarde heeft. Diegene die Power Basic gebruiken kunnen zelf hun boek opslaan voor meer informatie. 

