Das deutsche QBasic- und FreeBASIC-Forum

[s@m]

Hallo
Hab n kleines Problem mit der Einbindung einer selbsterstellten Bibliothek.
irgendwie funktioniert bei mir der befehl....nicht ,

[jb]

Damit bindest du nur die Deklarationen ein...
Du musst deinen Lib-Code auch zu einer Lib kompilieren, und zwar unter Ausführen -> Bibliothek erstellen.
Als Dateiendung gibst du dann .QLB an. Um die soeben erstellte Lib auch benutzen zu können, gehst du
(unter Windows) auf Eigenschaften von QB.EXE und schreibst hinter der Befehlszeile noch ein /L + deine Lib.QLB.
Die Lib muss dann im gleichen Verzeichnis wie die QB.EXE sein.

Steht aber auch alles in der MonsterFAQ...

jb

[Thomas Antoni]

Dazu habe ich mir Folgendes für die QB-MonsterFAQ vorgemerkt:

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

Frage deutsch
~~~~~~~~~~~~~~
Was sind Bibliotheken und wie gehe ich damit um?


Antwort 1
~~~~~~~~~~
[ von Andre Klein ( www.iconsoft.de), ergänzt von Thomas Antoni, 22.1.2004 - 7.5.2004 ]

+-------------------------------------------------------------------------------
| Bibliotheken in Qbasic
| Autor: Andre Klein
+-------------------------------------------------------------------------------

*** Was ist eine Bibliothek?
--------------------------------------------------------------------------------
Eine Bibliothek ist eine Sammlung von SUB's, FUNCTION's und/oder TYPE's die in
einer externen Datei gespeichert sind. Diese Datei nennt man Bibliothek (engl.
"Library"). Bibliotheken kann man nur in QuickBASIC (z.B. V4.5), nicht in QBasic
1.1 verwenden.

Bei QuickBASIC gibt es zwei Arten von Bibliotheken: "Normale Bibliotheken
(Dateiendung .LIB) und Quick-Bibliotheken (.QLB).

Die Unterschiede zwischen QLB- und LIB-Bibliotheken kannst Du gelegentlich im
Eintrag "Was ist der Unterschied zwischen LIB- und QLB-Bibliotheken?" nachlesen.
Wir wollen uns hier zunächst nur mit den QLB-Bibliotheken (engl. "QuickLibries")
befassen.



*** Warum sollte ich eine Bibliothek benutzen?
--------------------------------------------------------------------------------
Bibliotheken kann man einsetzen wenn man z.B. sehr viele SUB's geschrieben hat
die man sehr oft auch in anderen Programmen benötigt. Ohne Bibliothek müßtest Du
immer wieder alle SUB's in Dein neues Programm schreiben oder eine "Blanko"-
Datei haben. Das kostet jede Menge Zeit und ist aufwendig! Wenn Du aber eine
Bibliothek hast, in der diese ganzen SUB's drin stehen, dann brauchst Du diese
nur einmal laden und kannst dann alle SUB's benutzen die dort gespeichert sind!
Und das ist doch viel bequemer oder?

Ein weiterer Grund für den Einsatz von Bibliotheken wäre der, das Du vieleicht
Dein e SUB's an Freunde, Bekannte und Unbekannte weitergeben möchtest. Und da ist
eine Bibliothek besser als ein Quellcode-Programm, aus dem sich derjenige dann
die ganzen SUB's rauskopieren müßte! Ein weiterer Vorteil ist der, dass der
Quellcode selber in einer Bibliothek nicht erkennbar ist! Das heißt, Du schreibst
jetzt z.B. eine Super-SUB und möchtest anderen die Funkion zeigen. Da Du aber
willst, dass keiner wissen soll, wie Du das gemacht hast, gibst Du natürlich nur
die Bibliothek weiter, weil dort der Quellcode ja nicht mehr erkennbar ist!
Anwendungen für Bibliotheken sind z.B. GRAFIK-SUB's, SOUND-SUB's etc. Also
solche SUB's die man wirklich nur einmal schreibt und dann immer wieder
unverändert benutzt.

Es gibt im Internet auch jede Menge guter Bibliotheken, die Du in Deinen
Programmen verwenden kannst und die Dir viel Programmierarbeit abnehmen. Da gibt
es z.B. Multimedia-Bibliotheken mit Grafik- und Sound-Funktionen für den
Spieleentwickler sowie Toolboxen für die Programmierung allgemeiner Anwendungen.


*** Wie lade ich eine QLB-Bibliothek?
--------------------------------------------------------------------------------
Eine Bibliothek kann erst ab der QuickBASIV-Version 4.0 geladen werden. Um eine
Bibliothek zu laden ruft man QB einfach mit der Option /L auf (L = Library, zu
deutsch Bibliothek). Die ganze Befehlszeile sieht dann so aus:

QB.exe /L namederbibliothek.QLB

Bei diesem Aufruf muß man darauf achten, dass sich die Bibliothek (die QLB-
Datei) im aktuellem Verzeichnis befindet oder der Pfad zur Bibliothek angegeben
wird. Ansonsten kommt die Fehlermeldung, dass die Bibliothek nicht gefunden
wurde. Wenn man QB /L ohne den Namen einer Bibliothek eingibt, dann nimmt QB
automatisch die QB.QLB die sich im QB-Hauptverzeichnis befindet. Dort sind die
SUB's CALL ABSOLUTE, CALL INTERRUPT und CALL INTERRUPTX definiert.


*** Wie benutze ich SUB'S wenn ich die Bibliothek geladen habe?
--------------------------------------------------------------------------------
Nach dem Start von QB.EXE mit dem obenstehenden Kommando siehst Du ein leeres
QB-Editorfenster.

Wenn Du jetzt eine SUB aus Dein er Bibliothek aufrufen willst dann machst Du das
mit dem gleichen Befehl mit dem Du auch SUB's aufrufst die direkt in Dein em QB-
Programm enthalten sind. Also mit CALL.

z.B. CALL meinsub (option1%, option2%, wert1%)

WICHTIG: Wenn Du NUR die QLB-Datei geladen hast, dann mußt Du IMMER ein CALL für
alle QLB-SUBs benutzen!!! Und FUNCTION's funktionieren leider auch nicht. Damit
Du kein CALL brauchst und FUNCTION's funktionieren mußt Du sie korrekt am
Programmanfang mit den Übergabeparametern deklarieren. Oder Du fügst eine "BI"-
Datei ein, die die erforderlichen Deklarationen enthält.


*** Was ist eine BI-Datei?
--------------------------------------------------------------------------------
Wenn Du ein QB-Programm schreibst und SUB's anlegst, dann schreibt QB automatisch
an den Anfang Dein es Programmes einige DECLARE-Anweisungen. Das gleiche passiert
auch bei FUNCTION's. Und eine BI-Datei enthält nichts anderes als diese DECLARE-
Anweisungen, und wenn man sie braucht auch TYPE's. Ansonsten keinerlei Quellcode.

Bei fertigen Bibliotheken, die Du im Internet herunterladen kannst, wird die
.BI-Datei häufig mundgerecht mitgeliefert.


*** Wie lade ich eine BI-Datei?
--------------------------------------------------------------------------------
um eine BI-Datei zu laden musst Du in Dein em QUELLCODE-Programm Folgendes
schreiben:

REM $INCLUDE: 'namederbidatei.BI'

Diese Datei muss sich im aktuellen Verzeichnis befinden, oder es muß der Pfad zu
der Datei mit angegeben werden. Wenn eine BI-Datei zusätzlich zu der
dazugehörigen QLB geladen wird, brauchst Du auch kein CALL mehr vor Dein e SUB-
Aufrufe schreiben und FUNCTION's funktionieren dann auch problemlos. Ein
Beispiel für eine BI-Datei ist die QB.BI im QB-Hauptverzeichnis.

Der Metabefehl $INCLUDE bewirkt, dass der Inhalt der angegebenen Datei quasi in
den Quelltext eingefügt ("inkludiert") wird.


*** Wie erstelle ich eine Bibliothek?
--------------------------------------------------------------------------------
Um eine Bibliothek erstellen zu können, brauchst Du theoretisch mindestens QB
V4.0. QB V4.0 kann zwar Bibliotheken erstellen, produziert bei mir aber immer
einen Fehler. Deshalb benutze ich QB V4.5. Vorgangsweise:

1. schreibe ein QB-Programm mit allen SUB's, FUNCTION's und TYPE's die Du später
in Dein er Bibliothek haben möchtest.

2. wenn Du das gemacht hast und alles funtioniert, dann gehe auf AUSFÜHREN und
dann auf BIBLIOTHEK erstellen.

3. Gib einen Namen für die Bibliothek ein. z.B. "TEST" . Die Bibliothek heißt
dann TEST.QLB.

4. Das Kreuz bei DEBUG-CODE ERSTELLEN kannst, musst Du aber nicht machen. Das
dient nur zur Fehlerbehandlung in Dein er Bibliothek während der Testphase.

5. Wenn das erledigt ist, gehst Du auf BIBLIOTHEK ERSTELLEN oder auf BIBLIOTHEK
ERSTELLEN UND BEENDEN und drückst ENTER.

6. Jetzt kommt ein schwarzer Bildschirm mit jeder Menge Informationen über das
Erstellen der Bibliothek. Dort zeigt QB dir auch an, ob irgendwelche Fehler
aufgetreten sind.

7. Wenn QB keine Fehler gefunden hat und alles geklappt hat, dann müsste sich
jetzt im Verzeichnis eine TEST.QLB und eine TEST.LIB befinden. Die QLB-Datei ist
Dein e fertige Bibliothek. Die LIB-Datei ist eine Art Zwischencode, in der zwar
alle SUBS usw. drinstehen, aber QB kann sie nicht benutzen. Sie erfüllt einen
anderen Zweck, zu dem ich später noch kommen werde. Damit ist die Bibliothek
fertig.

Was wir jetzt noch brauchen ist eine BI-Datei für unsere Bibliothek.


*** Wie erstelle ich eine BI-Datei?
--------------------------------------------------------------------------------
um eine BI-Datei zu erstellen, markierst Du in Dein em QB-Programm alle DECLARE-
und TYPE-Anweisungen. Gehst auf BEARBEITEN und KOPIEREN. Dann gehst Du auf DATEI
und NEU. Dort fügst Du die soeben kopierten DECLARE-Anweisungen ein. Dann DATEI
-> SPEICHERN UNTER. Dort gibst Du den Namen für Dein e BI-Datei ein und
speicherst das ganze. WICHTIG: schreibe .bi unbedingt dazu sonst speichert QB es
als BAS-Datei. Das wars dann auch schon. Jetzt hast Du eine fertige QLB-Datei
mit der dazugehörigen BI-Datei. Diese kannst Du jetzt wie bei "Wie lade ich eine
Bibliothek?" beschrieben in Dein em Programm verwenden.


*** Was hat es mit der LIB-Datei auf sich?
--------------------------------------------------------------------------------
Eine LIB-Datei entsteht wenn man mit QB eine Bibliothek erstellt. In ihr sind,
genauso wie in der QLB-Datei, auch alle SUB's und FUNCTION's gespeichert. Aber
QB kann mit einer LIB nichts anfangen, da eine LIB-Datei soetwas wie einen
Zwischencode enhält. Aber man kann mit ihr eine schöne andere Sache machen!

Beispiel:
Du hast eine Bibliothek erstellt die nur Grafik-SUB's enthält und eine 2.
Bibliothek die nur Sound-Subs enthält. Du hast jetzt folgende Dateien:
grafik.QLB, grafik.LIB, sound.QLB, sound.LIB So, und jetzt möchtest Du ein
Programm schreiben das sowohl Grafik als auch Sound benutzt und müßtest
eigentlich 2 Bibliotheken laden. ABER: Das Problem ist das man immer nur 1
Bibliothek laden kann. Also müßte man irgendwie aus 2 Bibliotheken 1 machen. Und
dafür sind die LIB-Dateien da. Denn man kann aus mehreren LIB-Dateien eine neue
QLB-Datei machen.


*** EXE-Programm erstellen, das eine Bibliothek benutzt
--------------------------------------------------------------------------------
Auch zum Erstellen einer EXE-Datei wird die .LIB-Datei benötigt. Hierzu reicht
die QLB-QuickLibrary nicht aus: Um ein in Verbindung mit einer .QLB Quick-
Bibliothek lauffähiges Programm kompilieren zu können, muss zusätzlich eine
Bibliothek gleichen Namens mit der Endung .LIB vorhanden sein. Diese
Bibliotheken werden vom Linker in das Programm eingebunden.


*** Wie erstelle ich eine QLB-Datei aus einer oder mehreren LIB-Dateien?
--------------------------------------------------------------------------------
Bei QuickBASIC 4.4 musst Du diesen Befehl in der Befehlszeile eingeben:

LINK.EXE /QU erste.LIB + zweite.LIB + ... , namederneuenqlb.QLB, NUL, BQLB45

Wenn Du nur eine LIB-Datei hast, dann lässt Du "+zweite.LIB + ..." natürlich weg.

Bei QuickBASIC 7.1/PDS lautet der letzte Eintrag anders. Gib dort folgendes
ein:

LINK.EXE /QU erste.LIB + zweite.LIB + ... , namederneuenqlb.QLB, NUL, QBXQLB.LIB


Und schon hast Du eine Bibliothek die sich aus mehreren LIB's zusammensetzt.

Wenn Du statt "NUL" einen beliebigen Dateinamen eingibst, z.B. log.txt, so
erhältst Du eine Textdatei mit einem Protokoll über den Linkvorgang.

TIPP: wenn Du Speicher sparen möchtest kannst Du Dein e ganzen SUB's in einzelne
LIB's tun und ein Programm schreiben das je nach Bedarf die jeweiligen
LIB's/SUB's zu einer QLB-Datei zusammenfügt. Das nennt man dann ein
Baukastenprinzip!

Mehrere QLB-Bibliotheken kannst Du übrigens nicht direkt zu einer
zusammenfassen. Du benötigts dazu immer die zu Grunde liegenden LIB-Dateien, die
Du dann nach dem oben stehenden Schema zusammenfügen kannst.


*** Eine Bibliothek in einer anderen Programmiersprache erstellen
--------------------------------------------------------------------------------
Du kannst eine Bibliothek statt mit QB auch in einer anderen Programmiersprache
erstellen. Viele im Internet erhältliche QB-Bibliotheken sind z.B. in Assembler
oder in C geschrieben. Dabei muss man die QB-Konventionen bei der
Parameterübergabe einhalten, worauf ich aber jetzt nicht näher eingehen will.


*** Abschließende Worte.
--------------------------------------------------------------------------------
So ich hoffe das war ausführlich und verständlich genug. Wenn Du weitere Fragen
hast oder ich irgend etwas falsch beschrieben habe, dann sende mir bitte eine
Mail an webmaster@iconsoft.de.de .

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

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

Frage deutsch
~~~~~~~~~~~~~~
Was ist der Unterschied zwischen LIB- und QLB-Bibliotheken?


Question english
~~~~~~~~~~~~~~~~
What's the difference between LIB and QLB libraries?

Antwort 1
~~~~~~~~~
[ von Thomas Antoni, 25.3.2004 - 10.4.2004 ]

((aus dem Buch Das große QuickBASIC Buch", Seite 39; weitere Infos zu Bibliotheken
gibt es dort ab Seite 335. Diese Dinge evtl noch in die nächste Frage einfügen.
))

Bibliotheken sind fertig kompilierte QB-Programmteile oder auch kompilierte bzw.
assemblierte Programmroutinen aus anderen Programmiersprachen, z.N. C oder
Assembler. Eine Bibliothek enthält in der Regel eine Reihe von SUBs und
FUNCTIONs, die in gewohnter Weise im Anwenderprogramm aufgerufen werden können.
Bei QuickBASIC liegen Bibliotheken in zwei verschiedenen Formen vor: als .LIB-
und als .QLB-Dateien.

Die Bibliotheken mit der Endung .QLB sind so genannte Quick-Bibliotheken
(englisch "QuickLibraries"). Diese können innerhalb der QuickBASIC-
Programmierumgebung vom QuickBASIC-Interpreter genutzt werden, wenn sie beim
Laden von QB mitgeladen wurden. Das Laden erfolgt durch das Starten von QB.EXE
mit dem Kommando "QB /L <Bibliotheksname>.QLB" . Dies ist eine super-praktische
Sache und eine hervorstechende Fähigkeit von QuickBASIC gegenüber anderen BASIC-
Dialekten! Es erleichtert enorm das Austesten von Programmen im
Interpretermodus.

Allerdings kann immer nur eine Quick-Bibliothek (.QLB) mit dem Interpreter
verwendet werden, im Gegensatz zu den "normalen" Bibliotheken (.LIB). Man kann
aber zwei Quick-Bibliotheken zu einer einzigen zusammenfassen. Siehe dazu den
entsprechenden Beitrag.

Die aus der Bibliothek genutzten SUBs und FUNCTIONs müssen im Anwenderprogramm
mit ihren Übergabeparametern korrekt deklariert werden. Um dem Anwender darin zu
unterstützen, wird zusammen mit der Bibliothek häufig eine gleichnamige
Quellsprache-Datei mit der Namenserweiterung .BI mitgeliefert. Die .BI-Datei
lässt sich dann die per $INCLUDE Anweisung am Beginn des Programms mit

'$INCLUDE: 'bibliotheksname.BI'

einbinden und enthält alle erforderlichen DECLARE-Befehle.


Um ein in Verbindung mit einer .QLB Quick-Bibliothek lauffähiges Programm
kompilieren zu können, muss zusätzlich eine Bibliothek gleichen Namens mit der
Endung .LIB vorhanden sein. Diese Bibliotheken werden vom Linker in das Programm
eingebunden.


QLB-Bibliotheken sind meist nur in Verbindung mit der Compilerversion lauffähig,
mit der sie erzeugt wurden. So ist eine QLB-Bibliothek, die mit der englischen
Version von QuickBASIC 4.5 erzeugt wurde, oftmals nicht unter der deutschen
Version und unter QuickBASIC 7.1/PDS lauffähig.

Wie Du aus einer LIB- eine QLB-Bibliothek erzeugen kannst, erfährst Du im
Eintrag "Was sind Bibliotheken und wie gehe ich damit um?".


Im Lieferumfang der QuickBASIC-Entwicklungsumgebung befinden sich die beiden
Bibliotheken QB.QLB und QB.LIB. Mit diesen Bibliotheken lassen sich Zugriffe auf
das DOS-Betriebssystem und auf die BIOS-Funktionen programmieren. Dazu dienen
die Befehle CALL ABSOLUTE, CALL INTERRUPT und CALL INTERRUPTX. Bei Programmen,
die diese Befehle verwenden, z.B. bei einigen Mausroutinen, muss QuickBASIC mit
dem Kommando "QB /L" gestartet werden. Der häufigste Anfängerfehler besteht
darin, das "/L" wegzulassen. Das hat gelegentlich zur Folge, dass ein Programm,
das unter QBasic problemlos läuft, sich unter QuickBASIC ums Verrecken nicht
starten lässt.


--------------------------------------------------------------------------------
_________________
+++ Die beliebte QBasic CD-ROM von QBasic.de - 670 MB QBasic-Stuff mit komfortabler HTML-Oberfläche. Für nur 5 EUR bestellbar auf www.antonis.de/qbcdueb.htm +++

[s@m]

danke...wirklich vielen dank...