bwbasic – Online in der Cloud

PROGRAMM:

NAME/FUNKTION

bwbasic – Bywater BASIC-Interpreter/Shell

Bywater BASIC Interpreter/Shell, Version 2.10
---------------------------------------------

Copyright (c) 1993, Ted A. Campbell
für bwBASIC Version 2.10, 11. Oktober 1993

INHALT:

1. BESCHREIBUNG
2. NUTZUNGSBEDINGUNGEN
3. KURZE REFERENZLISTE DER BEFEHLE UND FUNKTIONEN
4. ALLGEMEINE ANWENDUNGSHINWEISE
5. ERWEITERTE REFERENZ FÜR BEFEHLE UND FUNKTIONEN
6. VORDEFINIERTE VARIABLEN
7. NICHT UMSETZTE BEFEHLE UND FUNKTIONEN
und AGENDA FÜR ENTWICKLUNG
8. DIE GESCHICHTE VON BYWATER BASIC
9. KOMMUNIKATION

Der Autor möchte Herrn David MacKenzie seinen Dank aussprechen,
der bei der Entwicklung der Unix-Installation und -Konfiguration geholfen hat
für diese Version.

1. BESCHREIBUNG

Der Bywater BASIC Interpreter (bwBASIC) implementiert eine große
Obermenge des ANSI-Standards für Minimal BASIC (X3.60-1978)
und eine wesentliche Teilmenge des ANSI-Standards für Full BASIC
(X3.113-1987) in C. Es bietet auch Shell-Programmierfunktionen
als Erweiterung von BASIC. bwBASIC möchte möglichst portabel sein
wie möglich.

bwBASIC kann so konfiguriert werden, dass es Funktionen, Befehle usw. emuliert
Funktionen, die auf verschiedenen Arten von BASIC-Interpretern verfügbar sind;
Weitere Installationsinformationen finden Sie in der Datei INSTALL.

Der Dolmetscher ist ziemlich langsam. Immer wenn man vor einer Wahl steht
Zwischen konzeptioneller Klarheit und Geschwindigkeit habe ich mich konsequent entschieden
das Vorherige. Der Interpreter ist das einfachste verfügbare Design.
und verwendet kein System von Zwischencode, das die Geschwindigkeit beeinträchtigen würde
seinen Betrieb erheblich steigern. So wie es ist, wird jede Zeile interpretiert
immer wieder, wenn der Dolmetscher darauf kommt.

bwBASIC implementiert eine Funktion, die im vorherigen BASIC nicht verfügbar war
Interpreter: Ein Shell-Befehl kann interaktiv eingegeben werden
bwBASIC-Eingabeaufforderung, und der Interpreter führt sie unter a aus
Befehlsshell. Beispielsweise kann der Befehl „dir *.bas“ lauten
in bwBASIC eingegeben (unter DOS, bzw. „ls -l *.bas“ unter UNIX) und
Es wird über die Befehlszeile des Betriebssystems ausgeführt.
Shell-Befehle können auch in nummerierten Zeilen in einem bwBASIC eingegeben werden
Programm, so dass bwBASIC als Shell-Programmierung genutzt werden kann
Sprache. bwBASICs Implementierung von RMDIR, CHDIR, MKDIR,
Befehle und Funktionen NAME, KILL, ENVIRON und ENVIRON$()
bieten weitere Möglichkeiten zur Schalenbearbeitung.

2. NUTZUNGSBEDINGUNGEN:

Diese Version von Bywater BASIC wird unter den Bedingungen veröffentlicht
GNU General Public License (GPL), die hiermit verteilt wird
Software in der Datei „KOPIEREN“. Die GPL legt die Bedingungen fest
unter denen Benutzer die Software in dieser Distribution kopieren und verwenden dürfen.

Für den kommerziellen Vertrieb steht eine separate Lizenz zur Verfügung,
Für weitere Informationen wenden Sie sich bitte an den Autor.

3. KURZE REFERENZLISTE DER BEFEHLE UND FUNKTIONEN

Beachten Sie, dass viele dieser Befehle und Funktionen nicht verfügbar sind
verfügbar, es sei denn, Sie haben bestimmte Flags in den Header-Dateien gesetzt
(Abhängigkeiten finden Sie im erweiterten Referenzabschnitt unten).

ABS(Anzahl)
ASC( string$ )
ATN(Nummer)
CALL-Unterprogrammname
FALL SONST | IF Teilausdruck | Konstante
CHAIN ​​[MERGE] Dateiname [, Zeilennummer] [, ALL]
CHDIR-Pfadname
CHR$( Zahl )
CINT( Zahl)
CLEAR
SCHLIESSEN [[#]Dateinummer]...
CLS
GEMEINSAME Variable [, Variable...]
COS( Zahl )
CSNG( Zahl)
CVD( string$ )
CVI( string$ )
CVS( string$ )
DATEN Konstante[,Konstante]...
DATUM$
DEF FNname(arg...)] = Ausdruck
DEFDBL Buchstabe[-Buchstabe](, Buchstabe[-Buchstabe])...
DEFINT Buchstabe[-Buchstabe](, Buchstabe[-Buchstabe])...
DEFSNG Buchstabe[-Buchstabe](, Buchstabe[-Buchstabe])...
DEFSTR Buchstabe[-Buchstabe](, Buchstabe[-Buchstabe])...
Zeile[-Zeile] löschen
DIM-Variable(Elemente...)[Variable(Elemente...)]...
DO NUM|UNNUM
DO [WHILE-Ausdruck]
BEARBEITEN
ELSE
SONST
ENDE WENN | FUNKTION | AUSWÄHLEN | SUB
ENVIRON variable-string = string
ENVIRON$( Variablenzeichenfolge )
EOF(Gerätenummer)
Variable[, Variable] LÖSCHEN...
ERL
ERR
Fehlernummer
EXP( Zahl)
FELD [#] Gerätenummer, Nummer AS-String-Variable [, Nummer AS-String-Variable ...]
DATEIEN Dateispezifikation$
AUFGABE
FOR-Zähler = Start BIS Ende [STEP-Inkrement]
GET [#] Gerätenummer [, Datensatznummer]
GOSUB-Linie | Etikett
GOTO-Zeile | Etikett
HEX$( Zahl )
IF-Ausdruck THEN [Anweisung [ELSE-Anweisung]]
INKEY$
INPUT [# Gerätenummer]|[;]["prompt string";]Liste der Variablen
INSTR( [start-position,] string-searched$, string-pattern$ )
INT( Zahl )
KILL-Dateiname
LEFT$( string$, Anzahl der Leerzeichen)
LEN( string$ )
LET-Variable = Ausdruck
LINE INPUT [[#] Gerätenummer,]["prompt string";] string-variable$
LIST-Zeile[-Zeile]
LOAD-Dateiname
LOC(Gerätenummer)
LOCATE Zeile, Spalte
LOF(Gerätenummer)
LOG( Zahl )
LOOP [UNTIL-Ausdruck]
LSET-Stringvariable$ = Ausdruck
MERGE-Dateiname
MID$( string$, start-position-in-string[, number-of-spaces ] )
MKD$( Zahl )
MKDIR-Pfadname
MKI$( Zahl )
MKS$( Zahl )
NAME alter Dateiname AS neuer Dateiname
NEUEN!
WEITER [Zähler]
OCT$( Zahl )
ON-Variable GOTO|GOSUB Zeile[,Zeile,Zeile,...]
ON ERROR GOSUB-Zeile
OPEN „O“|“I“|“R“, [#]Gerätenummer, Dateiname [,Datensatzlänge]
Dateiname FOR INPUT|OUTPUT|APPEND AS [#]Gerätenummer [LEN = Datensatzlänge]
OPTION BASE-Nummer
POS
PRINT [# Gerätenummer,][USING Format-String$;] Ausdrücke ...
PUT [#] Gerätenummer [, Datensatznummer]
QUIT
RANDOMIZE-Nummer
Variable[, Variable] LESEN...
REM-String
RESTORE-Zeile
RÜCKKEHR
RIGHT$( string$, Anzahl der Leerzeichen)
RMDIR-Pfadname
RND( Zahl)
RSET String-Variable$ = Ausdruck
RUN [Zeile][Dateiname]
Dateiname SPEICHERN
SELECT CASE-Ausdruck
SGN(Nummer)
SIN( Zahl)
SPACE$( Zahl )
SPC(Nummer)
SQR(Anzahl)
STOP
STR$( Zahl )
STRING$( Zahl, ASCII-Wert|String$ )
SUB Unterprogrammname
SWAP-Variable, variabel
SYSTEM
TAB( Zahl)
TAN(Nummer)
ZEIT$
TIMER
TROFF
TRON
VAL( string$ )
WENDE
WHILE-Ausdruck
WIDTH [# Gerätenummer,] Nummer
WRITE [# Gerätenummer,] Element [, Element]...

4. ALLGEMEINE ANWENDUNGSHINWEISE:

4.a. Interaktive Umgebung

Eine interaktive Umgebung wird bereitgestellt, wenn das Flag INTERACTIVE gesetzt ist
ist in bwbasic.h als TRUE definiert, so dass eine Zeile mit a
Die Zeilennummer kann am bwBASIC-Prompt eingegeben werden und wird angezeigt
dem Programm im Speicher hinzugefügt.

Zeilennummern sind nicht unbedingt erforderlich, aber nützlich, wenn die
Für die Programmierung wird eine interaktive Umgebung verwendet. Für länger
Für den Programmeintrag empfiehlt es sich möglicherweise, einen ASCII-Texteditor zu verwenden
in diesem Fall können Zeilen ohne Nummern eingegeben werden. Kann man nutzen
DO NUM und DO UNNUM dienen zum Nummerieren bzw. Entnummerieren von Zeilen. Siehe auch die
Dokumentation unten für den Pseudobefehl EDIT.

4.b. Regeln der Namensgebung

Bei Befehlsnamen und Funktionsnamen wird die Groß-/Kleinschreibung nicht beachtet.
so dass „Run“ und „RUN“ und „run“ gleichwertig sind und „abs()“
und „ABS()“ und „Abs()“ sind gleichwertig. JEDOCH variabel
Bei Namen wird in bwbASIC zwischen Groß- und Kleinschreibung unterschieden, sodass „d$“ und „D$“
sind verschiedene Variablen. Dies unterscheidet sich von einigen BASIC
Implementierungen, bei denen bei Variablennamen die Groß-/Kleinschreibung nicht beachtet wird.

Variablennamen können beliebige alphabetische Zeichen und den Punkt verwenden
und Unterstriche und Dezimalziffern (jedoch nicht in der
erster Platz). Sie können mit „#“ oder „!“ abgeschlossen werden. Zu
Erlauben Sie Namen vom Typ Microsoft, auch wenn die Genauigkeit stimmt
irrelevant für bwBASIC.

4.c. Numerische Konstanten

Numerische Konstanten können mit einer Ziffer zwischen 0 und 9 (dezimal) beginnen
das „&H“ oder „&h“ (hexadezimal) oder das „&o“ oder „&O“ (oktal).
Dezimalzahlen können mit „E“, „e“, „D“ oder „d“ abgeschlossen werden.
gefolgt von einer Exponentenzahl, um die Exponentialschreibweise zu kennzeichnen.
Dezimalkonstanten können auch mit „#“ oder „!“ abgeschlossen werden.
um jedoch den Präzisionsterminatoren im Microsoft-Stil zu entsprechen
Die angegebene Genauigkeit ist für bwBASIC irrelevant.

4.d. Befehlszeilenausführung

In der Befehlszeile kann ein Dateiname angegeben werden
Sofort geladen und ausgeführt, damit die Befehlszeile angezeigt wird

bwbasic prog.bas

lädt „prog.bas“ und führt es aus.

4.e. Programmspeicher

Alle Programme werden als ASCII-Textdateien gespeichert.

4.f. Richtig und falsch

Im Standard ist TRUE als -1 und FALSE als 0 definiert
Vertrieb von bwBASIC. Diese Definitionen können von geändert werden
diejenigen, die bwBASIC kompilieren (siehe Datei BWBASIC.H).

4.g. Zuordnungen

Die Zuweisung muss an Variablen erfolgen. Dies unterscheidet sich von einigen
Implementierungen von BASIC, bei denen eine Zuweisung erfolgen kann
Funktion. Implikation: „INSTR( 3, x$, y$ ) = z$“ wird nicht
Arbeiten unter bwBASIC.

4.h. Operatoren und Vorrang

bwBASIC erkennt die folgenden Operatoren mit ihrem Level
angegebene Priorität (1 = höchste):

^ 1 Potenzierung
* 2 Multiplikation
/ 2 Abteilung
3 ganzzahlige Division
+ 5 Zusatz
- 5 Subtraktion
= 6 Gleichheit oder Zuordnung
MOD 4-Modul (Rest)-Arithmetik
<> 7 Ungleichheit
< 8 weniger als
> 9 größer als
<= 10 kleiner oder gleich
=< 10 kleiner oder gleich
>= 11 größer oder gleich
=> 11 größer oder gleich
NICHT 12 Verneinungen
UND 13 Konjunktion
ODER 14 Disjunktion
XOR 15 exklusiv oder
Implikation von IMP 16
EQV 17-Äquivalenz

4.h. Numerische Präzision (NICHT)

bwBASIC verwendet Zahlen mit nur einer Genauigkeitsstufe. Wenn
Das Flag NUMBER_DOUBLE ist in bwbasic.h als TRUE definiert
Die implementierte Genauigkeit entspricht der des C-Datentyps „double“.
andernfalls (Standard) entspricht die Genauigkeit der des C-„Floats“.
Typ. An einer Reihe von Stellen gibt es Befehle (oder Pseudo-Befehle).
Befehle), die scheinbar die Präzision im Microsoft-Stil erkennen
Unterscheidungen, aber in den meisten Fällen handelt es sich dabei nur um Umgehungslösungen
Aliase, um die Ausführung von Programmen im Microsoft-Stil zu ermöglichen.

5. ERWEITERTE REFERENZ FÜR BEFEHLE UND FUNKTIONEN

Die in den folgenden Referenzmaterialien aufgeführten „Abhängigkeiten“.
bezieht sich auf Flags, die in bwbasic.h für den auf TRUE gesetzt werden müssen
zugehöriger Befehl oder Funktion, die implementiert werden soll. Diese Fahnen
sind wie folgt:

(Kern-)Befehle und Funktionen in jeder Implementierung von
bwBASIC; Dies sind die ANSI Minimal BASIC-Kerne

INTERAKTIV Befehle zur Unterstützung der interaktiven Programmierung
-Umgebung

COMMON_CMDS Befehle über ANSI Minimal BASIC hinaus, die häufig vorkommen
zu Full ANSI BASIC und Microsoft BASICs

COMMON_FUNCS Funktionen, die über den ANSI Minimal BASIC-Kern hinausgehen, aber
sowohl im ANSI Full BASIC als auch im Microsoft-Stil üblich
BASIC-Sorten

UNIX_CMDS-Befehle, die ein Verzeichnis im Unix-Stil erfordern und
Umgebungsroutinen, die nicht in C angegeben sind

STRUCT_CMDS Befehle im Zusammenhang mit strukturierter Programmierung; alle
davon sind Teil des Full ANSI BASIC-Standards

ANSI_FUNCS Funktionen, die nur für ANSI Full BASIC gelten

MS_CMDS-Befehle, die nur für Microsoft BASICs gelten

MS_FUNCS Funktionen, die nur für Microsoft BASICs gelten

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

Funktion: ABS (Nummer)

Beschreibung: ABS gibt den absoluten Wert des Arguments „Zahl“ zurück.

Abhängigkeiten: (Kern)

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

Funktion: ASC( string$ )

Beschreibung: ASC gibt den ASCII-Code für den ersten Buchstaben in zurück
das Argument string$.

Abhängigkeiten: MS_FUNCS

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

Funktion: ATN(Nummer)

Beschreibung: ATN gibt den Arkustangenswert des Arguments „Zahl“ zurück.
im Bogenmaß.

Abhängigkeiten: (Kern)

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

Befehl: CALL Unterprogrammname

Beschreibung: CALL ruft ein benanntes Unterprogramm auf (siehe SUB und END SUB).

Abhängigkeiten: STRUCT_CMDS

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

Befehl: CASE ELSE | IF Teilausdruck | Konstante

Beschreibung: CASE leitet ein Element einer SELECT CASE-Anweisung ein
(siehe SELECT CASE). CASE IF führt eine Bedingung ein
SELECT CASE-Element und CASE ELSE führt ein ein
Standardelement SELECT CASE.

Abhängigkeiten: STRUCT_CMDS

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

Befehl: CHAIN ​​[MERGE] Dateiname [, Zeilennummer] [, ALL]

Beschreibung: CHAIN ​​übergibt die Kontrolle an ein anderes BASIC-Programm.
Als COMMON (siehe auch) deklarierte Variablen werden übergeben
zum neuen Programm.

Abhängigkeiten: COMMON_CMDS

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

Befehl: CHDIR Pfadname$

Beschreibung: CHDIR ändert das aktuelle Verzeichnis in das angegebene
durch das Argument Pfadname$.

Abhängigkeiten: UNIX_CMDS

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

Funktion: CHR$( Zahl )

Beschreibung: CHR$ gibt eine einstellige Zeichenfolge mit dem Zeichen zurück
entsprechend dem durch das Argument angegebenen ASCII-Code
'Nummer'.

Abhängigkeiten: COMMON_FUNCS

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

Funktion: CINT( Zahl)

Beschreibung: CINT gibt die gekürzte Ganzzahl für das Argument zurück
'Nummer'.

Abhängigkeiten: MS_FUNCS

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

Befehl: CLEAR

Beschreibung: CLEAR setzt alle numerischen Variablen auf 0 und alle
String-Variablen auf null setzen.

Abhängigkeiten: COMMON_CMDS

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

Befehl: CLOSE [[#]Dateinummer]...

Beschreibung: CLOSE schließt die durch die Dateinummer angegebene Datei
(siehe OFFEN).

Abhängigkeiten: COMMON_CMDS

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

Befehl: CLS

Beschreibung: CLS löscht den Bildschirm (IBM und kompatible).
erst ab Version 2.10).

Abhängigkeiten: IMP_IQC und IMP_CMDLOC

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

Befehl: CMDS

Beschreibung: CMDS ist ein Debugging-Befehl, der eine Liste druckt
aller implementierten bwBASIC-Befehle.

Abhängigkeiten: DEBUG

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

Befehl: COMMON-Variable [, Variable...]

Beschreibung: COMMON bezeichnet Variablen, die an CHAINed übergeben werden sollen
Programm (siehe CHAIN).

Abhängigkeiten: COMMON_CMDS

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

Funktion: COS( Zahl )

Beschreibung: COS gibt den Kosinus des Arguments „Zahl“ zurück
im Bogenmaß.

Abhängigkeiten: (Kern)

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

Funktion: CSNG( Zahl )

Beschreibung: CSNG ist eine Pseudofunktion, die unter keine Wirkung hat
bwBASIC. Es repliziert einen Befehl vom Typ Microsoft
das würde die „Zahl“ in eine einfache Genauigkeit umwandeln.

Abhängigkeiten: MS_FUNCS

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

Funktion: CVD( string$ )

Beschreibung: CVD konvertiert das Argument string$ in ein bwBASIC
Zahl (Genauigkeit spielt in bwBASIC keine Rolle, da
bwBASIC-Zahlen haben nur eine Genauigkeit).

Implementierungsspezifische Hinweise:

CVD(), CVI(), CVS(), MKI$(), MKD$(), MKS$(): Diese Funktionen
sind implementiert, hängen aber ab von a) den Größen für Ganzzahl,
Float- und Double-Werte auf bestimmten Systemen und b) wie
bestimmte Versionen von C speichern diese numerischen Werte. Der
Dies bedeutet, dass mit diesen Funktionen erstellte Datendateien erstellt werden
auf einem DOS-basierten Mikrocomputer möglicherweise nicht korrekt übersetzt
von bwBASIC, das auf einem Unix-basierten Computer ausgeführt wird. Ebenso Daten
Dateien, die von bwBASIC erstellt und mit einer Version von C kompiliert wurden, sind möglicherweise nicht der Fall
lesbar mit bwBASIC, kompiliert mit einer anderen Version von C (sogar unter
das gleiche Betriebssystem). Seien Sie also vorsichtig mit diesen.

Abhängigkeiten: MS_FUNCS

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

Funktion: CVI( string$ )

Beschreibung: CVI konvertiert das Argument string$ in ein bwBASIC
Zahl (Genauigkeit spielt in bwBASIC keine Rolle, da
bwBASIC-Zahlen haben nur eine Genauigkeit; siehe auch
der Hinweis zu CVD).

Abhängigkeiten: MS_FUNCS

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

Funktion: CVS( string$ )

Beschreibung: CVI konvertiert das Argument string$ in ein bwBASIC
Zahl (Genauigkeit spielt in bwBASIC keine Rolle, da
bwBASIC-Zahlen haben nur eine Genauigkeit; siehe auch
der Hinweis zu CVD).

Abhängigkeiten: MS_FUNCS

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

Befehl: DATA konstant[,konstante]...

Beschreibung: DATA speichert numerische und String-Konstanten
Zugriff durch READ (siehe dort).

Abhängigkeiten: (Kern)

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

Funktion: DATE$

Beschreibung: DATE$ gibt das aktuelle Datum basierend auf dem Computerdatum zurück
interne Uhr als String in der Form „JJJJ-MM-TT“.
Wie unter bwBASIC implementiert, kann DATE$ nicht für verwendet werden
Zuweisung (z. B. zum Festlegen des Systemdatums).

Hinweis: bwBASIC (v2.10) erlaubt derzeit keine Zuweisung
zu einer Funktion.

Abhängigkeiten: COMMON_FUNCS

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

Befehl: DEF FNname(arg...)] = Ausdruck

Beschreibung: DEF definiert eine vom Benutzer geschriebene Funktion. Diese Funktion
entspricht jedoch einer Implementierung im Microsoft-Stil
in bwBASIC DEF ist ein funktionierendes Äquivalent von FUNCTION.

Abhängigkeiten: (Kern)

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

Befehl: DEFDBL Buchstabe[-Buchstabe](, Buchstabe[-Buchstabe])...

Beschreibung: DEFDBL deklariert Variablen mit aus einem Buchstaben bestehenden Namen
als numerische Variablen (Präzision spielt dabei keine Rolle).
bwBASIC).

Abhängigkeiten: MS_CMDS

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

Befehl: DEFINT Buchstabe[-Buchstabe](, Buchstabe[-Buchstabe])...

Beschreibung: DEFINT deklariert Variablen mit einbuchstabigen Namen
als numerische Variablen (Präzision spielt dabei keine Rolle).
bwBASIC).

Abhängigkeiten: MS_CMDS

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

Befehl: DEFSNG Buchstabe[-Buchstabe](, Buchstabe[-Buchstabe])...

Beschreibung: DEFSNG deklariert Variablen mit aus einem Buchstaben bestehenden Namen
als numerische Variablen (Präzision spielt dabei keine Rolle).
bwBASIC).

Abhängigkeiten: MS_CMDS

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

Befehl: DEFSTR Buchstabe[-Buchstabe](, Buchstabe[-Buchstabe])...

Beschreibung: DEFSTR deklariert Variablen mit einbuchstabigen Namen
als String-Variablen.

Abhängigkeiten: MS_CMDS

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

Befehl: DELETE Zeile[-Zeile]

Beschreibung: DELETE löscht Programmzeilen, die durch gekennzeichnet sind
Argumente). Wenn Sie DELETE für nicht verwenden möchten
nummerierte Programme, verwenden Sie zuerst DO NUM, dann DELETE,
dann DO UNNUM.

Abhängigkeiten: INTERAKTIV

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

Befehl: DIM Variable(Elemente...)[Variable(Elemente...)]...

Beschreibung: DIM gibt Variablen an, die mehr als eine haben
Element in einer einzigen Dimension, also in einem Array
Variablen.

Hinweis: Wie unter bwBASIC implementiert, akzeptiert DIM nur
Klammern als Trennzeichen für Variablenfelder.
(Einige BASICs erlauben die Verwendung von eckigen Klammern.)

Abhängigkeiten: (Kern)

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

Befehl: DO NUM|UNNUM

Beschreibung: DO NUM nummeriert alle Zeilen in einem Programm. Der erste
Die Zeile erhält die Nummer 10 und die folgenden Zeilen
werden in Vielfachen von 10 fortlaufend nummeriert. DO
UNNUM entfernt alle Zeilennummern aus einem Programm.
Beachten Sie, dass diese Funktionen nichts mit der Linie zu tun haben
Zahlen, z. B. nach einer GOSUB- oder GOTO-Anweisung;
Diese Befehle können nicht als Ersatz für verwendet werden
RENUM (in einigen Systemen verfügbar, jedoch nicht in bwBASIC).
Mit diesen Befehlen kann man sich jedoch weiterentwickeln
nicht nummerierte Programme durch Eingabe neuer Zeilen mit Nummern,
Führen Sie dann DO UNNUM aus, um die Zeilennummern zu entfernen.
Zusammen mit LOAD und SAVE (siehe dort) kann man verwenden
bwBASIC als primitiver Texteditor.

Abhängigkeiten: INTERAKTIV

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

Befehl: DO [WHILE-Ausdruck]

Beschreibung: DO implementiert eine Reihe von Formen von Programmschleifen.
DO...LOOP führt einfach eine Schleife durch; Der einzige Ausweg ist vorbei
AUSFAHRT; DO WHILE...LOOP durchläuft eine Schleife, während „expression“ ist
true (dies entspricht dem älteren WHILE-WEND
Schleife, auch in bwBASIC implementiert); DO...LOOP BIS
Durchläuft eine Schleife, bis der Ausdruck nach UNTIL wahr ist.

Abhängigkeiten: STRUCT_CMDS

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

Befehl: BEARBEITEN

Beschreibung: EDIT ist ein Pseudobefehl, der den Texteditor aufruft
in der Variablen BWB.EDITOR$ angegeben, um die zu bearbeiten
Programm im Speicher. Nach dem Aufruf des Texteditors,
das (bearbeitete) Programm wird wieder in den Speicher geladen. Der Benutzer
Normalerweise müssen ein gültiger Pfad und Dateiname angegeben werden
BWB.EDITOR$ vor diesem Befehl ist hilfreich.

Abhängigkeiten: COMMON_CMDS

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

Befehl: ELSE

Beschreibung: ELSE führt eine Standardbedingung in einem mehrzeiligen IF ein
Aussage.

Abhängigkeiten: STRUCT_CMDS

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

Befehl: ELSEIF

Beschreibung: ELSEIF führt eine sekundäre Bedingung in einem Multi-
Zeile IF-Anweisung.

Abhängigkeiten: STRUCT_CMDS

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

Befehl: END IF | FUNKTION | AUSWÄHLEN | SUB

Beschreibung: END IF beendet eine mehrzeilige IF-Anweisung. ENDFUNKTION
beendet eine mehrzeilige Funktionsdefinition. ENDE AUSWÄHLEN
beendet eine SELECT CASE-Anweisung. END SUB beendet einen Multi-
Zeilenunterprogrammdefinition.

Abhängigkeiten: STRUCT_CMDS

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

Befehl: ENVIRON variable-string$ = string$

Beschreibung: ENVIRON legt die Umgebungsvariable fest, die durch identifiziert wird
variable-string$ zu string$.

Es ist zu beachten, dass dies von der Implementierung abweicht
von ENVIRON in einigen Versionen von BASIC, aber ENVIRON von bwBASIC
ermöglicht die Verwendung von BASIC-Variablen auf beiden Seiten der Gleichheit
Zeichen. Beachten Sie, dass sich die Funktion ENVIRON$() von der unterscheidet
Befehl, und beachten Sie, dass dies in einigen Betriebssystemen der Fall ist
Eine innerhalb eines Programms festgelegte Umgebungsvariable wird nicht übergeben
zu seiner übergeordneten Shell.

Abhängigkeiten: UNIX_CMDS

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

Funktion: ENVIRON$( variable-string$ )

Beschreibung: ENVIRON$ gibt die zugehörige Umgebungsvariable zurück
der Name variable-string$.

Abhängigkeiten: MS_FUNCS

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

Funktion: EOF(Gerätenummer)

Beschreibung: EOF gibt TRUE (-1) zurück, wenn das Gerät mit verknüpft ist
Die Gerätenummer steht am Ende der Datei, andernfalls
gibt FALSE (0) zurück.

Abhängigkeiten: MS_FUNCS

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

Befehl: ERASE Variable[, Variable]...

Beschreibung: ERASE entfernt Array-Variablen aus einem Programm.

Abhängigkeiten: COMMON_CMDS

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

Funktion: ERL

Beschreibung: ERL gibt die Zeilennummer des letzten Fehlers zurück.

Abhängigkeiten: MS_FUNCS

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

Funktion: ERR

Beschreibung: ERR gibt die Fehlernummer des letzten Fehlers zurück.

Beachten Sie, dass PROG_ERRORS definiert wurde, während bwBASIC definiert ist
Beim Kompilieren wird die ERR-Variable nicht korrekt gesetzt
Fehler. Es funktioniert nur, wenn Standardfehlermeldungen verwendet werden.

Abhängigkeiten: MS_FUNCS

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

Befehl: ERROR-Nummer

Beschreibung: ERROR simuliert einen Fehler, dh zeigt die Meldung an
für diesen Fehler geeignet. Dieser Befehl ist hilfreich
beim Schreiben von ON ERROR GOSUB-Routinen, die identifizieren können
ein paar Fehler zur Sonderbehandlung und dann ERROR ERR
(d. h. Standardbehandlung) für alle anderen.

Abhängigkeiten: COMMON_CMDS

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

Befehl: EXIT [FOR]

Beschreibung: EXIT allein verlässt eine DO...LOOP-Schleife;
EXIT FOR verlässt eine FOR...NEXT-Schleife.

Abhängigkeiten: STRUCT_CMDS

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

Funktion: EXP( Zahl )

Beschreibung: EXP gibt den Exponentialwert von „Zahl“ zurück.

Abhängigkeiten: (Kern)

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

Befehl: FIELD [#] Gerätenummer, Nummer AS String-Variable$ [, Nummer AS String-Variable$...]

Beschreibung: FIELD weist dem Gerät Speicherplatz in einem zufälligen Dateipuffer zu
wird durch die Gerätenummer angegeben und weist „Anzahl“-Bytes zu
und Zuweisen der Bytes an dieser Position zur Variablen
String-Variable$.

Abhängigkeiten: COMMON_CMDS

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

Befehl: FILES filespec$

Beschreibung: FILES ist ein Pseudobefehl, der das Verzeichnisprogramm aufruft
in der Variablen BWB.FILES$ mit dem Argument angegeben
Dateispezifikation$. Normalerweise muss der Benutzer diese Variable festlegen
bevor FILES verwendet werden kann. Beispielsweise für PC-Computer,

BWB.FILES$ = "DIR"

wird funktionieren, für Unix-Maschinen,

BWB.FILES$ = "ls -l"

usw.

Abhängigkeiten: COMMON_CMDS

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

Befehl: FNCS

Beschreibung: CMDS ist ein Debugging-Befehl, der eine Liste druckt
aller vordefinierten bwBASIC-Funktionen.

Abhängigkeiten: DEBUG

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

Befehl: FUNKTION

Beschreibung: FUNCTION führt normalerweise eine Funktionsdefinition ein
endet mit END FUNCTION. In bwBASIC, FUNCTION und
DEF sind funktionierende Äquivalente, sodass beide verwendet werden können
mit einzeiligen Funktionsdefinitionen oder mit mehrzeiligen
Zeilendefinitionen, die durch END FUNCTION beendet werden.

Abhängigkeiten: STRUCT_CMDS

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

Befehl: FOR Counter = Start TO Finish [STEP Inkrement]

Beschreibung: FOR initiiert eine FOR-NEXT-Schleife mit der Variablen
„Zähler“ ist zunächst auf „Start“ eingestellt und wird inkrementiert
in 'Inkrement'-Schritten (Standard ist 1) bis 'Zähler'
entspricht „Fertig stellen“.

Abhängigkeiten: (Kern)

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

Befehl: GET [#] Gerätenummer [, Datensatznummer]

Beschreibung: GET liest den nächsten Datensatz aus einer Datei mit wahlfreiem Zugriff
oder Gerät in den mit dieser Datei verknüpften Puffer.
Wenn Datensatznummer angegeben ist, liest der GET-Befehl die
angegebenen Datensatz.

Abhängigkeiten: COMMON_CMDS

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

Befehl: GOSUB-Zeile | Etikett

Beschreibung: GOSUB initiiert einen Unterprogrammaufruf für die Zeile (oder das Label)
angegeben. Das Unterprogramm muss mit RETURN enden.

Abhängigkeiten: (Kern), aber STRUCT_CMDS für Labels

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

Befehl: GOTO-Zeile | Etikett

Beschreibung: GOTO verzweigt die Programmausführung zur angegebenen Zeile
(oder Etikett).

Abhängigkeiten: (Kern), aber STRUCT_CMDS für Labels

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

Funktion: HEX$( Zahl )

Beschreibung: HEX$ gibt eine Zeichenfolge zurück, die den Hexadezimalwert (Basis 16) angibt.
Wert für die 'Nummer'.

Abhängigkeiten: MS_FUNCS

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

Befehl: IF-Ausdruck THEN [Anweisung [ELSE-Anweisung]]

Beschreibung: IF wertet „Ausdruck“ aus und führt THEN aus
Aussage, ob sie wahr ist oder (optional) die
ELSE-Anweisung, wenn sie FALSE ist. Wenn STRUCT_CMDS
auf TRUE gesetzt ist, erlaubt bwBASIC mehrzeiliges IF
Anweisungen mit ELSE- und ELSEIF-Fällen, endend
mit END IF.

Abhängigkeiten: (Kern), STRUCT_CMDS für mehrzeilige IF-Anweisungen

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

Funktion: INKEY$

Beschreibung: INKEY$ liest den Status der Tastatur und einen einzelnen
Tastendruck, falls verfügbar. Wenn kein Tastendruck verfügbar ist,
dann gibt INKEY$ sofort eine Nullzeichenfolge („“) zurück.
Derzeit (v2.10) nur in bwx_iqc.c implementiert.

Abhängigkeiten: IMP_IQC und IMP_CMDLOC

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

Befehl: INPUT [# Gerätenummer]|[;]["prompt string";]Liste der Variablen

Beschreibung: INPUT ermöglicht die Eingabe vom Terminal oder einem Gerät
wird durch die Gerätenummer angegeben. Bei einem Terminal wird die Eingabeaufforderung „prompt
string“ wird ausgegeben und die Eingabe wird dem zugewiesen
entsprechende Variablen angegeben.

bwBASIC unterstützt die optionale Funktion von INPUT nicht
Dadurch werden der Wagenrücklauf und der Zeilenvorschub am Ende unterdrückt
der Eingabe. Dies liegt daran, dass C allein keine vorsieht
andere Eingabemittel als CR-LF-terminierte Strings.

Abhängigkeiten: (Kern)

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

Funktion: INSTR( [start-position,] string-searched$, string-pattern$ )

Beschreibung: INSTR gibt die Position zurück, an der string-pattern$
kommt in string-searched$ vor, beginnend an der Startposition.
Wie in bwBASIC implementiert, kann INSTR nicht für verwendet werden
Zuordnungen.

Hinweis: bwBASIC (v2.10) erlaubt derzeit keine Zuweisung
zu einer Funktion.

Abhängigkeiten: MS_FUNCS

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

Funktion: INT( Zahl )

Beschreibung: INT gibt die größte Ganzzahl zurück, die kleiner oder gleich ist
das Argument 'Nummer'. Beachten Sie, dass es sich hierbei nicht um eine „abgeschnittene“
Integer-Funktion, siehe CINT.

Abhängigkeiten: (Kern)

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

Befehl: KILL Dateiname$

Beschreibung: KILL löscht die durch Dateiname$ angegebene Datei.

Abhängigkeiten: UNIX_CMDS

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

Funktion: LEFT$( string$, Anzahl der Leerzeichen)

Beschreibung: LEFT$ gibt einen Teilstring, einen String$ mit der Anzahl der Leerzeichen, zurück
von links (Anfang) der Zeichenfolge). Wie implementiert
unter bwBASIC kann es nicht zur Zuweisung verwendet werden.

Abhängigkeiten: MS_FUNCS

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

Funktion: LEN( string$ )

Beschreibung: LEN gibt die Länge von string$ in Bytes zurück.

Abhängigkeiten: COMMON_FUNCS

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

Befehl: LET-Variable = Ausdruck

Beschreibung: LET weist der Variablen den Wert von „Ausdruck“ zu.
In der aktuellen Implementierung unterstützt bwBASIC implizites LET
Anweisungen (z. B. „X = 4.5678“ am Anfang von
eine Linie oder ein Liniensegment, unterstützt jedoch keine Zuweisung
auf mehrere Variablen (z. B. „x, y, z = 3.141596“).

Abhängigkeiten: (Kern)

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

Befehl: LINE INPUT [[#] Gerätenummer,]["prompt string";] string-variable$

Beschreibung: LINE INPUT liest die gesamte Zeile von der Tastatur oder eine Datei
oder Gerät in String-Variable$. Wenn die Eingabe von der stammt
Tastatur (stdin), dann wird „prompt string“ gedruckt
Erste. Im Gegensatz zu INPUT liest LINE INPUT eine ganze Zeile,
stoppt nicht für durch Kommas getrennte Datenelemente.

Abhängigkeiten: COMMON_CMDS

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

Befehl: LIST Zeile[-Zeile]

Beschreibung: LIST listet Programmzeilen auf, wie in ihrem Argument angegeben.

Abhängigkeiten: INTERAKTIV

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

Befehl: Dateiname laden

Beschreibung: LOAD lädt ein ASCII-BASIC-Programm in den Speicher.

Abhängigkeiten: INTERAKTIV

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

Funktion: LOC(Gerätenummer)

Beschreibung: LOC gibt den nächsten Datensatz mit GET- oder PUT-Anweisungen zurück
wird benutzen.

Abhängigkeiten: MS_FUNCS

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

Befehl: LOCATE Zeile, Spalte

Beschreibung: LOCATE adressiert den Cursor auf eine bestimmte Zeile und
Spalte. Derzeit (v2.10) nur in bwx_iqc.c implementiert.

Abhängigkeiten: IMP_IQC und IMP_CMDLOC

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

Funktion: LOF(Gerätenummer)

Beschreibung: LOF gibt die Länge einer Datei zurück (angegeben durch Gerätenummer)
in Bytes.

Abhängigkeiten: MS_FUNCS

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

Funktion: LOG( Zahl )

Beschreibung: LOG gibt den natürlichen Logarithmus des Arguments „Zahl“ zurück.

Abhängigkeiten: (Kern)

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

Befehl: LOOP [UNTIL-Ausdruck]

Beschreibung: LOOP beendet eine Programmschleife: siehe DO.

Abhängigkeiten: STRUCT_CMDS

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

Befehl: LSET string-variable$ = Ausdruck

Beschreibung: LSET überträgt Daten von „Ausdruck“ nach links
Seite einer Zeichenfolgenvariablen oder eines Pufferfelds mit wahlfreiem Zugriff.

Abhängigkeiten: COMMON_CMDS

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

Befehl: MERGE-Dateiname

Beschreibung: MERGE fügt dem Programm Programmzeilen aus „Dateiname“ hinzu
in Erinnerung. Im Gegensatz zu LOAD wird das Programm nicht gelöscht
derzeit im Speicher.

Abhängigkeiten: COMMON_CMDS

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

Funktion: MID$( string$, start-position-in-string[, number-of-spaces ] )

Beschreibung: MID$ gibt einen Teilstring von string$ zurück, beginnend bei
Startposition in der Zeichenfolge und Fortsetzung für
Anzahl der Leerzeichen Bytes.

Abhängigkeiten: MS_FUNCS

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

Befehl: MKDIR Pfadname$

Beschreibung: MKDIR erstellt einen neuen Verzeichnispfad, wie von angegeben
Pfadname$.

Abhängigkeiten: UNIX_CMDS

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

Funktion: MKD$( Zahl )

Beschreibung: MKD$, MKI$ und MKS$ sind in bwBASIC alle gleichwertig.
Sie wandeln den Zahlenwert „Zahl“ in einen String um
die in einer stärker komprimierten Form in einer Datei gespeichert werden kann
(insbesondere für zufälligen Dateizugriff). Da bwBASIC das tut
Unterschiede in der Präzision dieser Befehle sind nicht erkennbar
sind effektiv gleichwertig.

Abhängigkeiten: MS_FUNCS

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

Funktion: MKI$( Zahl )

Beschreibung: Entspricht MKD$ (siehe auch)

Abhängigkeiten: MS_FUNCS

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

Funktion: MKS$( Zahl )

Beschreibung: Entspricht MKD$ (siehe).

Abhängigkeiten: MS_FUNCS

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

Befehl: NAME alter Dateiname AS neuer Dateiname

Beschreibung: NAME benennt eine vorhandene Datei (alter Dateiname) um in
Neuer-Dateiname.

Abhängigkeiten: UNIX_CMDS

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

Befehl: NEU

Beschreibung: NEW löscht das Programm im Speicher und löscht alles
Variablen.

Abhängigkeiten: INTERAKTIV

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

Befehl: NEXT [Zählervariable]

Beschreibung: NEXT steht am Ende einer FOR-NEXT-Schleife; siehe.

Abhängigkeiten: (Kern)

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

Funktion: OCT$( Zahl )

Beschreibung: OCT$ gibt einen String zurück, der das Oktal (Basis 8) angibt.
Darstellung von „Zahl“.

Abhängigkeiten: MS_FUNCS

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

Befehl: ON-Variable GOTO|GOSUB Zeile[,Zeile,Zeile,...]

Beschreibung: ON verzweigt entweder (GOTO) oder ruft ein Unterprogramm auf
(GOSUB) basierend auf dem gerundeten Wert der Variablen;
ist es 1, wird die erste Zeile aufgerufen, bei 2 die zweite
Leitung aufgerufen wird usw.

Abhängigkeiten: (Kern)

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

Befehl: ON ERROR GOSUB Zeile|Label

Beschreibung: ON ERROR richtet eine Unterroutine zur Fehlerbehandlung ein. Sehen
auch FEHLER.

Abhängigkeiten: COMMON_CMDS, STRUCT_CMDS für Labels

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

Befehl: OPEN "O"|"I"|"R", [#]Gerätenummer, Dateiname [,Datensatzlänge]
Dateiname FOR INPUT|OUTPUT|APPEND AS [#]Gerätenummer [LEN = Datensatzlänge]

Beschreibung: OPEN weist Direktzugriffsspeicher für den Zugriff auf eine Festplatte zu
Datei oder ein anderes Gerät. Beachten Sie, dass es sich um zwei völlig unterschiedliche Formen handelt
der OPEN-Anweisung werden unterstützt. In der ersten Form
„O“ (beachten Sie, dass diese Buchstaben in Anführungszeichen gesetzt werden müssen
Markierungen) bezeichnet die sequentielle Ausgabe, „I“ bezeichnet die sequentielle Ausgabe
Eingabe und „R“ bezeichnet Eingabe und Ausgabe mit wahlfreiem Zugriff.
Sobald es geöffnet ist, können beliebig viele Vorgänge ausgeführt werden
auf einem Gerät (siehe WRITE #, INPUT #, PRINT # usw.).

Abhängigkeiten: COMMON_CMDS

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

Befehl: OPTION BASE-Nummer

Beschreibung: OPTION BASE legt den niedrigsten Wert für Array-Indizes fest.
entweder 0 oder 1.

Abhängigkeiten: (Kern)

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

Funktion: POS

Beschreibung: POS gibt die aktuelle Cursorposition in der Zeile zurück.

Abhängigkeiten: COMMON_FUNCS

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

Befehl: PRINT [# Gerätenummer,][USING Format-String$;] Ausdrücke ...

Beschreibung: PRINT gibt Text auf dem Bildschirm oder in einer Datei oder einem Gerät aus
wird durch die Gerätenummer angegeben. In der aktuellen Implementierung
von bwBASIC müssen auszugebende Ausdrücke durch getrennt werden
das Komma (Tab-Ausgabe), das Semikolon (sofort).
sequentielle Ausgabe) oder das Pluszeichen (sofortige sequentielle Ausgabe).
Ausgabe durch String-Verkettung). Ausdrücke getrennt
durch Leerzeichen oder Tabulatoren werden nicht unterstützt. Wenn USING angegeben ist,
Im Format können mehrere Formatierungszeichen vorkommen
Zeichenfolge:

! gibt das erste Zeichen einer Zeichenfolge aus

\ gibt 2+x Zeichen einer Zeichenfolge aus, wobei x =
die Anzahl der Leerzeichen zwischen den Backslashes

& Zeichenfolgenfeld variabler Länge

# steht für eine einzelne Ziffer im Ausgabeformat für
eine Zahl

. Dezimalpunkt in einer Zahl

+ Vorzeichen einer Zahl (gibt + oder - aus)

- nachgestelltes Minus nach einer Zahl

** Füllen Sie führende Leerzeichen mit Sternchen

$$ gibt ein Dollarzeichen vor einer Zahl aus

^^ Zahl im Exponentialformat ausgeben

_ nächstes Zeichen wörtlich ausgeben

Wie derzeit implementiert, das exponentielle Format
wird das vom C-Compiler verwendete sein.

Abhängigkeiten: (Kern), COMMON_FUNCS für USING

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

Befehl: PUT [#] Gerätenummer [, Datensatznummer]

Beschreibung: PUT gibt den nächsten verfügbaren Datensatz oder den Datensatz aus
wird durch die Datensatznummer der Datei oder dem Gerät angegeben
gekennzeichnet durch die Gerätenummer.

Abhängigkeiten: COMMON_CMDS

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

Befehl: BEENDEN

Beschreibung: QUIT ist ein Synonym für SYSTEM; mit INTERAKTIV
Umgebung, es verlässt das Programm zum
Betriebssystem (oder das aufrufende Programm).

Abhängigkeiten: INTERAKTIV

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

Befehl: RANDOMIZE-Zahl

Beschreibung: RANDOMIZE setzt den Zufallszahlengenerator (siehe RND).
Unter bwBASIC kann die TIMER-Funktion (siehe dort) verwendet werden
um einen „Zahlen“-Seed für die Zufallszahl bereitzustellen
Generator.

Abhängigkeiten: (Kern)

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

Befehl: Variable[, Variable] LESEN...

Beschreibung: READ liest Werte aus DATA-Anweisungen und weist diese zu
Werte zu den benannten Variablen. Variablentypen in einem READ
Die Anweisung muss mit den Datentypen in DATA-Anweisungen übereinstimmen
wie sie geschehen sind. Siehe auch DATA und RESTORE.

Abhängigkeiten: (Kern)

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

Befehl: REM-Zeichenfolge

Beschreibung: REM ermöglicht das Einfügen von Bemerkungen in ein Programm. Als
derzeit implementiert, die gesamte Zeile folgt
REM wird vom Interpreter ignoriert (also auch wenn
Wenn MULTISEG_LINES gesetzt ist, ist eine REM-Leitung nicht möglich
um ein Segmenttrennzeichen (:“) zu finden, gefolgt von einem anderen
Liniensegment mit Befehl. bwBASIC funktioniert derzeit nicht
Implementieren Sie die Verwendung des einfachen Anführungszeichens im Microsoft-Stil
Markierung, um Bemerkungen zu kennzeichnen.

Abhängigkeiten: (Kern)

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

Befehl: RESTORE-Zeile

Beschreibung: RESTORE setzt die Zeilen- und Positionszähler für DATA zurück
und READ-Anweisungen an den Anfang der Programmdatei oder
an den Anfang der angegebenen Zeile. (Derzeit ist dies
muss eine Zeilennummer sein.)

Abhängigkeiten: (Kern)

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

Befehl: ZURÜCK

Beschreibung: RETURN schließt ein von GOSUB aufgerufenes Unterprogramm ab.

Abhängigkeiten: (Kern)

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

Funktion: RIGHT$( string$, Anzahl der Leerzeichen)

Beschreibung: RIGHT$ gibt einen Teilstring, einen String$ mit der Anzahl der Leerzeichen, zurück
von rechts (Ende) der Zeichenfolge). Wie implementiert
unter bwBASIC kann es nicht zur Zuweisung verwendet werden.

Abhängigkeiten: MS_FUNCS

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

Befehl: RMDIR-Pfadname

Beschreibung: RMDIR löscht den durch Pfadname angegebenen Verzeichnispfad.

Abhängigkeiten: UNIX_CMDS

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

Funktion: RND( Zahl)

Beschreibung: RND gibt eine Pseudozufallszahl zurück. Der Wert „Zahl“.
wird von bwBASIC ignoriert, falls angegeben. Die RANDOMISIERUNG
Der Befehl (siehe dort) setzt den Zufallszahlengenerator neu.

Abhängigkeiten: (Kern)

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

Befehl: RSET string-variable$ = Ausdruck

Beschreibung: RSET überträgt Daten von „Ausdruck“ nach rechts
Seite einer Zeichenfolgenvariablen oder eines Pufferfelds mit wahlfreiem Zugriff.

Abhängigkeiten: COMMON_CMDS

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

Befehl: RUN [Zeile][Dateiname$]

Beschreibung: RUN führt das Programm im Speicher aus. Wenn ein Dateiname$ ist
angegeben, dann wird die angegebene Datei in den Speicher geladen
und hingerichtet. Wenn eine Zeilennummer angegeben wird, erfolgt die Ausführung
beginnt in dieser Zeile.

Abhängigkeiten: INTERAKTIV

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

Befehl: Dateiname$ SPEICHERN

Beschreibung: SAVE speichert das Programm im Speicher unter Dateiname$. bwBASIC
Speichert Dateien nur im ASCII-Format.

Abhängigkeiten: INTERAKTIV

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

Befehl: SELECT CASE-Ausdruck

Beschreibung: SELECT CASE führt eine mehrzeilige bedingte Auswahl ein
Stellungnahme. Der als Argument für SELECT angegebene Ausdruck
CASE wird durch die folgenden CASE-Anweisungen ausgewertet. Der
Die SELECT CASE-Anweisung endet mit einem END SELECT
Aussage.

In der derzeit implementierten Form können CASE-Anweisungen befolgt werden
durch String-Werte, in diesem Fall jedoch nur einfache Vergleiche
(gleich, ungleich) durchgeführt werden.

Abhängigkeiten: STRUCT_CMDS

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

Funktion: SGN(Nummer)

Beschreibung: SGN gibt das Vorzeichen des Arguments „Zahl“ zurück, +1
für positive Zahlen, 0 für 0 und -1 für negative Zahlen.

Abhängigkeiten: (Kern)

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

Funktion: SIN( Zahl)

Beschreibung: SIN gibt den Sinus des Arguments „Zahl“ zurück
im Bogenmaß.

Abhängigkeiten: (Kern)

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

Funktion: SPACE$( Zahl )

Beschreibung: SPACE$ gibt eine Zeichenfolge aus Leerzeichen „Nummer“ zurück
Bytes lang.

Abhängigkeiten: MS_FUNCS

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

Funktion: SPC(Nummer)

Beschreibung: SPC gibt eine Zeichenfolge mit Leerzeichen „Nummer“ zurück
Bytes lang.

Abhängigkeiten: MS_FUNCS

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

Funktion: SQR(Zahl)

Beschreibung: SQR gibt die Quadratwurzel des Arguments „Zahl“ zurück.

Abhängigkeiten: (Kern)

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

Befehl: STOP

Beschreibung: STOP unterbricht die Programmausführung. Wie unten implementiert
bwBASIC, STOP gibt ein SIGINT-Signal aus.

Abhängigkeiten: (Kern)

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

Funktion: STR$( Zahl )

Beschreibung: STR$ gibt einen String zurück, der die Dezimalzahl (Basis 10) angibt.
Darstellung des Arguments „Zahl“.

Abhängigkeiten: COMMON_FUNCS

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

Funktion: STRING$( Zahl, ASCII-Wert|String$ )

Beschreibung: STRING$ gibt eine Zeichenfolge mit einer Länge von 'Anzahl' Bytes zurück
entweder des ersten Zeichens von string$ oder des Zeichens
Antwort auf den ASCII-Wert ASCII-Wert.

Abhängigkeiten: MS_FUNCS

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

Befehl: SUB Unterprogrammname

Beschreibung: SUB führt eine benannte, mehrzeilige Unterroutine ein. Der
Die Unterroutine wird durch eine CALL-Anweisung aufgerufen und abgeschlossen
mit einer END SUB-Anweisung.

Abhängigkeiten: STRUCT_CMDS

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

Befehl: SWAP-Variable, Variable

Beschreibung: SWAP tauscht die Werte zweier Variablen. Die beiden Variablen
muss vom gleichen Typ sein (entweder numerisch oder Zeichenfolge).

Abhängigkeiten: COMMON_CMDS

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

Befehl: SYSTEM

Beschreibung: SYSTEM verlässt bwBASIC zum aufrufenden Programm oder
(häufiger) das Betriebssystem.

Abhängigkeiten: INTERAKTIV

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

Funktion: TAB( Zahl)

Beschreibung: TAB gibt Leerzeichen aus, bis die durch angegebene Spalte erreicht ist
'Anzahl' wurde erreicht.

Abhängigkeiten: (Kern)

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

Funktion: TAN( Zahl )

Beschreibung: TAN gibt den Tangens des Arguments „Zahl“ zurück
im Bogenmaß.

Abhängigkeiten: (Kern)

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

Funktion: TIME$

Beschreibung: TIME$ gibt die aktuelle Uhrzeit basierend auf der des Computers zurück
interne Uhr als String in der Form „HH-MM-SS“.
Wie unter bwBASIC implementiert, kann TIME$ nicht verwendet werden
Zuweisung (z. B. zum Einstellen der Systemzeit).

Hinweis: bwBASIC (v2.10) erlaubt derzeit keine Zuweisung
zu einer Funktion.

Abhängigkeiten: COMMON_FUNCS

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

Funktion: TIMER

Beschreibung: TIMER gibt die Zeit in der Systemuhr in Sekunden zurück
seit Mitternacht vergangen.

Abhängigkeiten: MS_FUNCS

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

Befehl: TROFF

Beschreibung: TROFF schaltet die Trace-Einrichtung ab; siehe TRON.

Abhängigkeiten: COMMON_CMDS

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

Befehl: TRON

Beschreibung: TRON schaltet die Trace-Funktion ein. Diese Funktion wird gedruckt
jede Zeilennummer in eckigen Klammern, wie das Programm lautet
hingerichtet. Dies ist beim Debuggen von Programmen nützlich
Linien Nummern. Zum Debuggen eines nicht nummerierten Programms mit
TRON, rufen Sie zuerst DO NUM an, aber denken Sie daran, DO UNNUM anzurufen
bevor Sie das Programm später speichern.

Abhängigkeiten: COMMON_CMDS

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

Funktion: VAL( string$ )

Beschreibung: VAL gibt den numerischen Wert der Zeichenfolge $ zurück.

Abhängigkeiten: COMMON_FUNCS

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

Befehl: VARS

Beschreibung: VARS ist ein Debugging-Befehl, der eine Liste von ausgibt
Alle definierten Variablen mit globalem Gültigkeitsbereich.

Abhängigkeiten: DEBUG

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

Befehl: WEND

Beschreibung: WEND schließt eine WHILE-WEND-Schleife ab; siehe WHILE.

Abhängigkeiten: COMMON_CMDS

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

Befehl: WHILE-Ausdruck

Beschreibung: WHILE leitet eine WHILE-WEND-Schleife ein. Die Schleife endet mit
WEND, und die Ausführung wiederholt sich durch die Schleife als
solange der 'Ausdruck' TRUE (-1) ist.

Abhängigkeiten: COMMON_CMDS

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

Befehl: WIDTH [# Gerätenummer,] Nummer

Beschreibung: WIDTH setzt die Bildschirm- oder Geräteausgabe auf „Zahl“.
Säulen. Gerätenummer gibt das Gerät an
oder Datei zur Ausgabe.

Abhängigkeiten: COMMON_CMDS

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

Befehl: WRITE [# Gerätenummer,] Element [, Element]...

Beschreibung: WRITE gibt Variablen auf dem Bildschirm oder in einer Datei aus
oder Gerät angegeben durch Gerätenummer. Kommas
werden zwischen ausgegebenen Ausdrücken und Zeichenfolgen eingefügt
werden in Anführungszeichen gesetzt.

Abhängigkeiten: COMMON_CMDS

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

6. VORDEFINIERTE VARIABLEN

BWB.EDITOR$
BWB.FILES$
BWB.PROMPT$
BWB.IMPLEMENTATION$

Die Befehle EDIT und FILES sind Pseudobefehle, die gestartet werden
Shell-Programme, die in den Variablen BWB.EDITOR$ und BWB.FILES$ benannt sind,
bzw. Die Standardwerte für diese Variablen können sein
in bwbasic.h geändert werden (DEF_EDITOR und DEF_FILES), oder sie
kann vom Benutzer im laufenden Betrieb geändert werden. Eine Idee könnte sein
Initialisieren Sie diese Variablen in „profile.bas“ für bestimmte Zwecke
Implementierungen; Beispielsweise könnte BWB.FILES$ definiert sein als
„ls -l“ auf Unix-Systemen oder „dir“ auf DOS-Systemen.

Zur Einstellung der Eingabeaufforderung kann die voreingestellte Variable BWB.PROMPT$ verwendet werden
Zeichenfolge für bwBASIC. Auch hier wird empfohlen, dass ein Benutzer-
Die ausgewählte Eingabeaufforderung kann in einer „profile.bas“ eingerichtet werden
Wird bei jedem Start von bwBASIC initialisiert. Beachten Sie das Besondere
Der Eingabeaufforderungszeichenfolge können Zeichen hinzugefügt werden, z. B.

BWB.PROMPT$ = "Ok"+CHR$(10)

gibt eine „Ok“-Eingabeaufforderung aus, gefolgt von einem Zeilenvorschub.

Die voreingestellte Variable BWB.IMPLEMENTATION$ gibt „TTY“ zurück für
die bwx_tty-Implementierung und gibt „IQC“ für die zurück
IBM PC oder kompatible mit QuickC (bwx_iqc) Implementierung.
Dies kann bei der Bestimmung der Befehle und Funktionen hilfreich sein
(insbesondere CLS, LOCATE und INKEY$) sind möglicherweise verfügbar.

7. NICHT UMSETZTE BEFEHLE UND FUNKTIONEN sowie AGENDA FÜR DIE ENTWICKLUNG

Es gibt einige Elemente, die schon so lange nicht implementiert wurden
ein Teil der Standard-BASICs, so dass ihr Fehlen überraschend erscheinen wird.
In jedem Fall würde ihre Umsetzung jedoch operative Eingriffe erfordern.
tingsystemspezifische Funktionen oder terminalspezifische Funktionen
das kann nicht allgemein gegeben werden. Einige konkrete Beispiele:

CLOAD Basiert auf CP/M- oder MSDOS-Konventionen für Binärdateien
ausführbare Dateien.

WEITER Siehe LEBENSLAUF unten (Unkenntnis des Programmierers?).

DEF USR Basiert auf CP/M- oder MSDOS-Konventionen für Binärdateien
ausführbare Dateien.

FRE() Die Möglichkeit, die Menge des freien Speichers zu melden
Der verbleibende Wert ist aufgrund unterschiedlicher Muster systemspezifisch
der Speicherzuteilung und des Speicherzugriffs; folglich dies
Die Funktion ist in ANSI oder früheren Versionen nicht vorhanden
von C und diese Funktion ist in bwBASIC nicht verfügbar.

INPUT$() C allein ist nicht in der Lage, die Tastatur ohne Echo zu lesen
Eingabe und kann Tastatureingaben erst nach a lesen
Carriage-Return wurde eingegeben.

INP-Aufrufe an Hardware-Ports, wie Maschinensprache
Routinen sind stark systemspezifisch und können dies nicht
allein in C implementiert werden.

LLIST Siehe LPRINT unten.

LPOS Siehe LPRINT unten.

LPRINT und LLIST usw. erfordern Zugriff auf ein Druckergerät.
und das ist von System zu System unterschiedlich. Benutzer
Versuchen Sie möglicherweise, das Druckergerät selbst zu ÖFFNEN
Betriebssystem (z. B. „/dev/lp“ auf Unix-Systemen,
oder „PRN“ unter DOS) und prüfen Sie, ob das Drucken möglich ist
von bwBASIC auf diese Weise.

NULL In diesem Fall bin ich überzeugt, dass NULL nicht mehr ist
notwendig, da mittlerweile nur noch sehr wenige Drucker NULL-Werte benötigen
am Ende der Zeilen.

OUT Siehe INP oben (Aufrufe an Hardware-Ports).

PEEK() PEEK und POKE ermöglichten die Adressierung früherer BASICs
bestimmte Speicherorte. Obwohl bwBASIC
könnte möglicherweise diesen Befehl (POKE) implementieren und
Diese Funktion (PEEK()) wäre die Einschränkung
durch die unterschiedlichen Systeme stark eingeschränkt
Speicherzugriff in verschiedenen Systemen.

POKE siehe PEEK() oben.

RENUM Da nicht nummerierte Zeilen eingegeben werden können und
unter bwBASIC ausgeführt würde, wäre es nicht
möglich, eine RENUM-Routine zu implementieren.
Stattdessen verwendet bwBASIC DO NUM und DO UNNUM.

RESUME Ist das unter C möglich? Wenn ja, ich
Ich habe es einfach noch nicht herausgefunden.
Mea culpa (aber nicht maxima).

USR Siehe CALL und DEF USR oben (Maschinensprache).
Unterprogramme).

VARPTR Siehe PEEK und POKE oben.

WARTEN Siehe INP und OUT oben.

Es gibt weitere Befehle, Funktionen und Implementierungsdetails
an denen ich arbeite und die für die Zukunft auf der Agenda stehen
Versionen von bwBASIC. Diese Tagesordnung umfasst:

PARACT, also die Fähigkeit, PARallele AKTIONEN auszuführen. Das
ist in ANSI BASIC beschrieben, obwohl ich es nicht gesehen habe
schon einmal umgesetzt. Es bietet eine grobe, nicht-
präventive Form des Multitasking im Rahmen
eines BASIC-Programms. Programmierer werden Punkte notieren, an denen
In bwBASIC gibt es bereits Hooks für PARACT.

XMEM-PC-Computer müssen in der Lage sein, erweitert zu werden
Speicher. Wenn wir erweiterten Speicher für das Programm verwenden könnten
Linien, Variablen und Funktionsdefinitionen könnten wir
viel längere Programme schreiben. Dies würde bedeuten,
jedoch eine ziemlich ernsthafte Neufassung des Programms
um Speicherhandles für diese Speicherfunktionen zu verwenden
anstelle von direkten Speicherzeigern.

Windows Das Hinzufügen von Speicherhandles zusätzlich zu
nicht-präventive Ausführung von Programmzeilen (in a
Rohform, bereits vorhanden) wird es möglich machen
Implementierungen für Windows zu entwickeln und vielleicht
für andere grafische Benutzeroberflächen. Aber welche Form
Sollte das dauern? Ich denke derzeit an ein BASIC
das würde im Hintergrund laufen und nur angezeigt werden
als Symbol im GUI-Bereich mit Popup-Editoren
und Ausgabefenster. Also die interpretierte Sprache
würde einem Zweck dienen, so etwas wie „cron“ (eine Aufgabe).
Scheduler) unter Unix-Systemen. Vielleicht haben Sie welche
Überlegungen, die mir dabei helfen würden.

Grafiken Hier sehen wir uns mit ziemlich kritischen Unterschieden in verschiedenen Bereichen konfrontiert
Stile und Implementierungen von Grafiken, z. B. zwischen
GWBASIC, ANSI BASIC, VisualBASIC usw. Aber es ist so
möglich, dass Grafikbefehle und -funktionen könnten
hinzugefügt werden. Diese wären alle umsetzungsspezifisch.

Der ANSI-Standard für vollständiges BASIC legt nicht fest, welche Einzelheiten
Befehle oder Funktionen müssen implementiert werden, und zwar der Standard
ist sehr robust. Vielleicht würde es nie eine Implementierung von BASIC geben
enthalten alle Elemente, aber einige ANSI-Befehle und -Funktionen, die
Nicht umgesetzt bleiben sind:

ACCESS
ANGLE
Bereich
ARITHMETIK
ARRAY
ASK
BSTR
BVAL
Decke
ZELLEN
CLIP
COLLATE
FOLGE UNS
COSH
DATE
DEBUGGEN
DEZIMAL
ERKLÄREN
GRAD
DEVICE
TRENNEN
DISPLAY
DOT
ZEICHNEN
ERASE
EVENT
AUSNAHME
GRAPH
HANDEL
IMAGE
SCHLÜSSEL
LCASE
LINES
LOG10
LOG2
MAT
Mixoged One
MEHRPUNKT
OUTIN
AUSGABE
PARAKT
BILD
PIXEL
GRUNDSTÜCK
PUNKTE
Radianer
ERHALTEN
RENUMMER
UMSCHREIBEN
DREHEN
ROUND
ERGREIFEN
SENDEN
SHIFT
SINH
TANH
TIMEOUT
SPUR
TRANS
KÜRZEN
UBOUND
UCASE
ANSICHTSPORT
WARTEN
ANSICHTSPORT
ZONENBREITE

8. DIE GESCHICHTE VON BYWATER BASIC

Dieses Programm wurde ursprünglich 1982 von meiner Großmutter, Mrs., ins Leben gerufen.
Verda-Zauber von Beaumont, TX. Sie schrieb das Programm mit
ein ANSI-C-Compiler auf einem Osborne I CP/M-Computer und obwohl mein
Großvater (Lockwood Spell) hatte einen IBM-PC mit 256k gekauft
RAM, meine Großmutter würde es nicht benutzen, um George Herbert zu paraphrasieren
in dem Sinne: „Wer nicht in 64k programmieren kann, kann auch nicht in 512k programmieren.“
Sie hatte Microsoft BASIC verwendet und obwohl sie nichts dagegen hatte
Dabei sagte sie immer wieder, dass sie nicht verstehe, warum Digital
Die Forschung hat Microsoft für Version 1.0 nicht „aus den Socken gehauen“.
von MSDOS und ich schätze, dass sie hoffte, die von Microsoft zu unterbieten
den gesamten Markt zu erobern und schließlich ein neues Software-Imperium aufzubauen
das nördliche Ende von Beaumont. Ihr Programmieraufwand wurde gekürzt
tragisch kurz, als sie von einem Beaumont nach Port geworfen wurde
Arthur-S-Bahn im Sommer 1986. Ich habe die Quelle gefunden
Code für bwBASIC auf einer Single-Density-Osborne-Diskette in ihrem Strick
Tasche und schaffte es schließlich, alles auf einen PC zu kopieren
Diskette. Ich habe es vor dieser Veröffentlichung leicht überarbeitet. Du
Ich sollte allerdings wissen, dass ich selbst Historiker und kein Programmierer bin.

9. KOMMUNIKATION:

E-Mail: [E-Mail geschützt]

11. Oktober 1993 BWBASIC(1)

Nutzen Sie bwbasic online über die Dienste von onworks.net