Il s'agit de la commande bwbasic qui peut être exécutée dans le fournisseur d'hébergement gratuit OnWorks en utilisant l'un de nos multiples postes de travail en ligne gratuits tels que Ubuntu Online, Fedora Online, l'émulateur en ligne Windows ou l'émulateur en ligne MAC OS
PROGRAMME:
Nom
bwbasic - Interpréteur/shell Bywater BASIC
Bywater BASIC Interprète/Shell, version 2.10
---------------------------------------------
Droit d'auteur (c) 1993, Ted A. Campbell
pour bwBASIC version 2.10, 11 octobre 1993
SOMMAIRE:
1. DESCRIPTIF
2. CONDITIONS D'UTILISATION
3. LISTE DE RÉFÉRENCE RAPIDE DES COMMANDES ET FONCTIONS
4. REMARQUES GÉNÉRALES SUR L'UTILISATION
5. RÉFÉRENCE ÉLARGIE POUR LES COMMANDES ET FONCTIONS
6. VARIABLES PRÉDÉFINIES
7. COMMANDES ET FONCTIONS NON IMPLEMENTEES
et AGENDA POUR LE DEVELOPPEMENT
8. L'HISTOIRE DE BYWATER BASIC
9. COMMUNICATION
L'auteur tient à exprimer ses remerciements à M. David MacKenzie,
qui a aidé au développement, à l'installation et à la configuration d'Unix
pour cette version.
1. DESCRIPTIF
Le Bywater BASIC Interpreter (bwBASIC) met en œuvre un grand
surensemble de la norme ANSI pour Minimal BASIC (X3.60-1978)
et un sous-ensemble important de la norme ANSI pour le BASIC complet
(X3.113-1987) en C. Il offre également des fonctionnalités de programmation shell
comme une extension de BASIC. bwBASIC cherche à être aussi portable
que possible.
bwBASIC peut être configuré pour émuler des fonctionnalités, des commandes et
fonctions disponibles sur différents types d'interpréteurs BASIC ;
voir le fichier INSTALL pour plus d'informations sur l'installation.
L'interprète est assez lent. A chaque fois qu'il est confronté à un choix
entre clarté conceptuelle et rapidité, j'ai toujours choisi
l'ancien. L'interprète est la conception la plus simple disponible,
et n'utilise aucun système de code intermédiaire, ce qui accélérerait
considérablement son fonctionnement. En l'état, chaque ligne est interprétée
à nouveau au fur et à mesure que l'interprète y vient.
bwBASIC implémente une fonctionnalité non disponible dans le précédent BASIC
interpréteurs : une commande shell peut être saisie de manière interactive au
bwBASIC, et l'interpréteur l'exécutera sous un
shell de commande. Par exemple, la commande "dir *.bas" peut être
saisi dans bwBASIC (sous DOS, ou "ls -l *.bas" sous UNIX) et
il sera exécuté à partir de la ligne de commande du système d'exploitation.
Les commandes shell peuvent également être données sur des lignes numérotées dans un bwBASIC
programme, de sorte que bwBASIC peut être utilisé comme une programmation shell
Langue. Mise en œuvre par bwBASIC des RMDIR, CHDIR, MKDIR,
Commandes et fonctions NAME, KILL, ENVIRON et ENVIRON$()
offrent des capacités de traitement shell supplémentaires.
2. CONDITIONS D'UTILISATION :
Cette version de Bywater BASIC est publiée sous les termes de la
GNU General Public License (GPL), qui est distribué avec ce
logiciel dans le fichier "COPYING". La GPL précise les termes
sous lequel les utilisateurs peuvent copier et utiliser le logiciel dans cette distribution.
Une licence distincte est disponible pour la distribution commerciale,
pour des informations sur lesquelles vous devez contacter l'auteur.
3. LISTE DE RÉFÉRENCE RAPIDE DES COMMANDES ET FONCTIONS
Sachez que bon nombre de ces commandes et fonctions ne seront pas
disponible sauf si vous avez défini certains indicateurs dans les fichiers d'en-tête
(voir la section de référence étendue ci-dessous pour les dépendances).
ABS( nombre )
ASC( chaîne$ )
ATN( numéro )
CALL nom-sous-routine
CAS AUTRE | IF expression-partielle | constant
CHAIN [MERGE] nom de fichier [, numéro de ligne] [, ALL]
Chemin d'accès CHDIR
CHR$( nombre )
CINT( nombre )
#
FERMER [[#]numéro-fichier]...
CLS
Variable COMMUNE [, variable...]
COS( nombre )
CSNG( nombre )
CVD( chaîne$ )
CVI( chaîne$ )
CVS( chaîne$ )
DATA constante[,constante]...
DATE$
DEF FNname(arg...)] = expression
DEFDBL lettre[-lettre](, lettre[-lettre])...
DEFINT lettre[-lettre](, lettre[-lettre])...
DEFSNG lettre[-lettre](, lettre[-lettre])...
DEFSTR lettre[-lettre](, lettre[-lettre])...
SUPPRIMER ligne[-ligne]
DIM variable(éléments...)[variable(éléments...)]...
FAIRE NUM|UNNUM
FAIRE [PENDANT l'expression]
EDIT
AUTRE
AUTREMENT
FIN SI | FONCTION | SÉLECTIONNER | SOUS
ENVIRON chaîne_variable = chaîne
ENVIRON$( chaîne_variable )
EOF( numéro-périphérique )
EFFACER variable[, variable]...
ERL
ERR
Numéro d'ERREUR
EXP( nombre )
FIELD [#] numéro d'appareil, numéro AS chaîne-variable [, numéro AS chaîne-variable...]
FICHIERS spécif_fichier$
FONCTION
Compteur FOR = début A fin [incrément STEP]
GET [#] numéro d'appareil [, numéro d'enregistrement]
ligne GOSUB | étiqueter
ligne GOTO | étiqueter
HEX$( nombre )
IF expression THEN [instruction [instruction ELSE]]
INKEY $
INPUT [# device-number]|[;]["prompt string";]liste des variables
INSTR( [position de départ,] chaîne recherchée$, chaîne-motif$ )
INT( nombre )
KILL nom-fichier
LEFT$( string$, nombre-d'espaces )
LEN( chaîne$ )
variable LET = expression
LINE INPUT [[#] numéro-périphérique,]["chaîne d'invite";] variable-chaîne$
LISTE ligne[-ligne]
LOAD nom-fichier
LOC( numéro-de-périphérique )
LOCATE ligne, colonne
LOF( numéro-périphérique )
LOG( nombre )
BOUCLE [JUSQU'À l'expression]
LSET variable-chaîne$ = expression
MERGE nom-fichier
MID$( string$, start-position-in-string[, nombre-d'espaces ] )
MKD$( nombre )
Nom de chemin MKDIR
MKI$( nombre )
MKS$( nombre )
NAME ancien-nom-fichier AS nouveau-nom-fichier
NOUVEAU
SUIVANT [compteur]
OCT$( nombre )
ON variable GOTO|GOSUB ligne[,ligne,ligne,...]
ON ERROR ligne GOSUB
OPEN "O"|"I"|"R", [#]numéro de périphérique, nom de fichier [,longueur d'enregistrement]
nom-fichier FOR INPUT|OUTPUT|APPEND AS [#]numéro-périphérique [LEN = longueur d'enregistrement]
Numéro de la BASE OPTION
POS
PRINT [# numéro-de-périphérique,][USING chaîne-format$;] expressions...
PUT [#] numéro de périphérique [, numéro d'enregistrement]
QUITTER
RANDOMISER le nombre
LIRE variable[, variable]...
chaîne REM
ligne RESTAURATION
RETOUR
RIGHT$( string$, nombre-d'espaces )
Chemin d'accès RMDIR
RND( nombre )
RSET chaîne-variable$ = expression
RUN [ligne][nom-fichier]
ENREGISTRER le nom du fichier
SÉLECTIONNER l'expression CASE
SGN (numéro)
NAS( nombre )
ESPACE$( nombre )
SPC( nombre )
SQR( nombre )
STOP
STR$( nombre )
STRING$( nombre, valeur-ascii|string$ )
nom du sous-programme SUB
variable d'échange, variable
SYSTÈME
TAB( nombre )
TAN( nombre )
TEMPS$
MINUTEUR
TROFF
TRON
VAL( chaîne$ )
WEND
PENDANT que l'expression
WIDTH [# périphérique-numéro,] numéro
ÉCRIRE [# numéro-périphérique,] élément [, élément ]....
4. REMARQUES GÉNÉRALES SUR L'UTILISATION :
4.a. Environnement interactif
Un environnement interactif est fourni si le drapeau INTERACTIF
est défini comme TRUE dans bwbasic.h, de sorte qu'une ligne avec un
le numéro de ligne peut être entré à l'invite bwBASIC et il sera
ajouté au programme en mémoire.
Les numéros de ligne ne sont pas strictement requis, mais sont utiles si le
environnement interactif est utilisé pour la programmation. Pour longtemps
entrée de programme, on peut préférer utiliser un éditeur de texte ASCII, et
dans ce cas, les lignes peuvent être saisies sans chiffres. On peut utiliser
DO NUM et DO UNNUM pour numéroter ou dénuméroter des lignes. Voir aussi le
documentation ci-dessous pour la pseudo-commande EDIT.
4.b. Conventions de nommage
Les noms de commande et les noms de fonction ne sont pas sensibles à la casse,
pour que "Run" et "RUN" et "run" soient équivalents et "abs()"
et "ABS()" et "Abs()" sont équivalents. CEPENDANT, variable
les noms SONT sensibles à la casse dans bwbASIC, de sorte que "d$" et "D$"
sont des variables différentes. Cela diffère de certains BASIC
implémentations où les noms de variables ne sont pas sensibles à la casse.
Les noms de variables peuvent utiliser n'importe quel caractère alphabétique, le point
et soulignez les caractères et les chiffres décimaux (mais pas dans le
première position). Ils peuvent être terminés par '#' ou '!' à
autoriser les noms de type Microsoft, même si la précision est
sans rapport avec bwBASIC.
4.c. Constantes numériques
Les constantes numériques peuvent commencer par un chiffre 0-9 (décimal), avec
le "&H" ou "&h" (hexadécimal) ou le "&o" ou "&O" (octal).
Les nombres décimaux peuvent se terminer par 'E', 'e', 'D' ou 'd'
suivi d'un numéro d'exposant pour indiquer la notation exponentielle.
Les constantes décimales peuvent également se terminer par le '#' ou '!'
pour se conformer aux terminateurs de précision de style Microsoft, bien que
la précision spécifiée ne sera pas pertinente pour bwBASIC.
4.d. Exécution de la ligne de commande
Un nom de fichier peut être spécifié sur la ligne de commande et sera
LOADed et RUN immédiatement, de sorte que la ligne de commande
programme bwbasic.bas
chargera et exécutera "prog.bas".
4.e. Stockage du programme
Tous les programmes sont stockés sous forme de fichiers texte ASCII.
4.f. Vrai et faux
TRUE est défini comme -1 et FALSE est défini comme 0 par défaut
distribution de bwBASIC. Ces définitions peuvent être modifiées par
ceux qui compilent bwBASIC (voir fichier BWBASIC.H).
4.g. Devoirs
L'affectation doit être faite aux variables. Cela diffère de certains
implémentations de BASIC où l'affectation peut être faite à un
fonction. Implication : " INSTR( 3, x$, y$ ) = z$" ne
travailler sous bwBASIC.
4.h. Opérateurs et priorité
bwBASIC reconnaît les opérateurs suivants, avec leur niveau
de priorité donnée (1 = la plus élevée) :
^ 1 exponentiation
* 2 multiplications
/ 2 divisions
3 divisions entières
+ 5 ajouts
- 5 soustractions
= 6 égalité ou affectation
arithmétique MOD 4 module (reste)
<> 7 inégalité
< 8 de moins que
> 9 supérieur à
<= 10 inférieur ou égal à
=< 10 inférieur ou égal à
>= 11 supérieur ou égal à
=> 11 supérieur ou égal à
PAS 12 négation
ET 13 conjonction
OU 14 disjonction
XOR 15 exclusif ou
Conséquences IMP 16
Équivalence EQV 17
4.h. Précision numérique (PAS)
bwBASIC utilise des nombres avec un seul niveau de précision. Si
le drapeau NUMBER_DOUBLE est défini comme TRUE dans bwbasic.h, le
la précision mise en oeuvre sera celle du type de données C "double" ;
sinon (par défaut) la précision sera celle du "float" C
taper. A plusieurs endroits, il y a des commandes (ou pseudo-
commandes) qui semblent reconnaître la précision de style Microsoft
distinctions, mais pour la plupart ce ne sont que des solutions de contournement
alias pour permettre l'exécution de programmes de style Microsoft.
5. RÉFÉRENCE ÉLARGIE POUR LES COMMANDES ET FONCTIONS
Les « dépendances » répertoriées dans les documents de référence suivants
fait référence aux indicateurs qui doivent être définis sur TRUE dans bwbasic.h pour le
commande ou fonction associée à mettre en œuvre. Ces drapeaux
sont les suivants:
(principales) Commandes et fonctions dans toute mise en œuvre de
bwBASIC; ce sont le noyau ANSI Minimal BASIC
Commandes INTERACTIVES supportant la programmation interactive
sûr, heureux et sain
COMMON_CMDS Commandes au-delà de ANSI Minimal BASIC qui sont communes
aux BASIC complets ANSI et Microsoft BASIC
COMMON_FUNCS Fonctions au-delà du noyau ANSI Minimal BASIC, mais
commun à la fois à l'ANSI Full BASIC et au style Microsoft
Variétés BASIC
UNIX_CMDS Commandes qui nécessitent un répertoire de style Unix et
routines d'environnement non spécifiées en C
STRUCT_CMDS Commandes liées à la programmation structurée ; tous
d'entre eux font partie de la norme Full ANSI BASIC
ANSI_FUNCS Fonctions uniques à ANSI Full BASIC
Commandes MS_CMDS uniques aux BASIC Microsoft
MS_FUNCS Fonctions uniques aux BASIC Microsoft
------------------------------------------
Fonction: ABS (numéro)
Description : ABS renvoie la valeur absolue de l'argument 'nombre'.
Dépendances : (noyau)
------------------------------------------
Fonction : ASC( chaîne$ )
Description : ASC renvoie le code ASCII de la première lettre de
la chaîne d'arguments $.
Dépendances : MS_FUNCS
------------------------------------------
Fonction : ATN (numéro)
Description : ATN renvoie la valeur arctangente de l'argument 'nombre'
en radians.
Dépendances : (noyau)
------------------------------------------
Commande : CALL nom-sous-routine
Description : CALL appelle un sous-programme nommé (voir SUB et END SUB).
Dépendances : STRUCT_CMDS
------------------------------------------
Commande : CASE ELSE | IF expression-partielle | constant
Description : CASE introduit un élément d'une instruction SELECT CASE
(voir SÉLECTIONNER UN CAS). CAS SI introduit une condition
SELECT CASE élément et CASE ELSE introduit un
élément SELECT CASE par défaut.
Dépendances : STRUCT_CMDS
------------------------------------------
Commande : CHAIN [MERGE] nom de fichier [, numéro de ligne] [, ALL]
Description : CHAIN passe le contrôle à un autre programme BASIC.
Les variables déclarées COMMON (qv) seront passées
au nouveau programme.
Dépendances : COMMON_CMDS
------------------------------------------
Commande : CHDIR pathname$
Description : CHDIR remplace le répertoire courant par celui indiqué
par l'argument pathname$.
Dépendances : UNIX_CMDS
------------------------------------------
Fonction : CHR$( nombre )
Description : CHR$ renvoie une chaîne d'un caractère avec le caractère
correspondant au code ASCII indiqué par l'argument
'numéro'.
Dépendances : COMMON_FUNCS
------------------------------------------
Fonction : CINT (numéro)
Description : CINT renvoie l'entier tronqué pour l'argument
'numéro'.
Dépendances : MS_FUNCS
------------------------------------------
Commande : EFFACER
Description : CLEAR définit toutes les variables numériques sur 0, et toutes
variables de chaîne à null.
Dépendances : COMMON_CMDS
------------------------------------------
Commande : FERMER [[#]numéro-fichier]...
Description : FERMER ferme le fichier indiqué par le numéro de fichier
(voir OUVERT).
Dépendances : COMMON_CMDS
------------------------------------------
Commande : CLS
Description : CLS efface l'écran d'affichage (IBM et compatibles
uniquement à partir de la version 2.10).
Dépendances : IMP_IQC et IMP_CMDLOC
------------------------------------------
Commande : CMDS
Description : CMDS est une commande de débogage qui imprime une liste
de toutes les commandes bwBASIC implémentées.
Dépendances : DEBUG
------------------------------------------
Commande : variable COMMUNE [, variable...]
Description : COMMON désigne les variables à passer à un CHAINed
programme (voir CHAINE).
Dépendances : COMMON_CMDS
------------------------------------------
Fonction : COS (numéro)
Description : COS renvoie le cosinus de l'argument 'nombre'
en radians.
Dépendances : (noyau)
------------------------------------------
Fonction : CSNG (numéro)
Description : CSNG est une pseudo-fonction qui n'a aucun effet sous
bwBASIC. Il réplique une commande de type Microsoft
cela convertirait le « nombre » en simple précision.
Dépendances : MS_FUNCS
------------------------------------------
Fonction : CVD( chaîne$ )
Description : CVD convertit la chaîne d'argument $ en un bwBASIC
nombre (la précision n'a pas d'importance dans bwBASIC car
Les nombres bwBASIC n'ont qu'une seule précision).
Notes spécifiques à la mise en œuvre :
CVD(), CVI(), CVS(), MKI$(), MKD$(), MKS$() : Ces fonctions
sont implémentées, mais dépendent a) des tailles des nombres entiers,
float et doubler les valeurs sur des systèmes particuliers, et b) comment
des versions particulières de C stockent ces valeurs numériques. Les
l'implication est que les fichiers de données créés à l'aide de ces fonctions
sur un micro-ordinateur basé sur DOS peut ne pas être traduit correctement
par bwBASIC s'exécutant sur un ordinateur Unix. De même, les données
les fichiers créés par bwBASIC compilés par une version de C peuvent ne pas être
lisible par bwBASIC compilé par une autre version de C (même sous
même système d'exploitation). Soyez donc prudent avec ceux-ci.
Dépendances : MS_FUNCS
------------------------------------------
Fonction : CVI( chaîne$ )
Description : CVI convertit l'argument string$ en un bwBASIC
nombre (la précision n'a pas d'importance dans bwBASIC car
Les nombres bwBASIC n'ont qu'une seule précision ; voir également
la note sur les CVD).
Dépendances : MS_FUNCS
------------------------------------------
Fonction : CVS( chaîne$ )
Description : CVI convertit l'argument string$ en un bwBASIC
nombre (la précision n'a pas d'importance dans bwBASIC car
Les nombres bwBASIC n'ont qu'une seule précision ; voir également
la note sur les CVD).
Dépendances : MS_FUNCS
------------------------------------------
Commande : DATA constant[,constant]...
Description : DATA stocke les constantes numériques et de chaîne à
accédé par READ (qv).
Dépendances : (noyau)
------------------------------------------
Fonction : DATE$
Description : DATE$ renvoie la date actuelle en fonction de l'ordinateur
horloge interne sous forme de chaîne sous la forme "AAAA-MM-JJ".
Comme implémenté sous bwBASIC, DATE$ ne peut pas être utilisé pour
affectation (c'est-à-dire pour régler la date du système).
Remarque : bwBASIC actuellement (v2.10) ne permet pas l'affectation
à une fonction.
Dépendances : COMMON_FUNCS
------------------------------------------
Commande : DEF FNname(arg...)] = expression
Description : DEF définit une fonction écrite par l'utilisateur. Cette fonction
correspond à une implémentation de type Microsoft, bien que
dans bwBASIC DEF est un équivalent fonctionnel de FUNCTION.
Dépendances : (noyau)
------------------------------------------
Commande : DEFDBL lettre[-lettre](, lettre[-lettre])...
Description : DEFDBL déclare des variables avec des noms à une seule lettre
comme variables numériques (la précision n'a pas d'importance dans
bwBASIC).
Dépendances : MS_CMDS
------------------------------------------
Commande : DEFINT lettre[-lettre](, lettre[-lettre])...
Description : DEFINT déclare des variables avec des noms à une seule lettre
comme variables numériques (la précision n'a pas d'importance dans
bwBASIC).
Dépendances : MS_CMDS
------------------------------------------
Commande : DEFSNG lettre[-lettre](, lettre[-lettre])...
Description : DEFSNG déclare des variables avec des noms à une seule lettre
comme variables numériques (la précision n'a pas d'importance dans
bwBASIC).
Dépendances : MS_CMDS
------------------------------------------
Commande : DEFSTR lettre[-lettre](, lettre[-lettre])...
Description : DEFSTR déclare des variables avec des noms à une seule lettre
comme variables de chaîne.
Dépendances : MS_CMDS
------------------------------------------
Commande : SUPPRIMER ligne[-ligne]
Description : DELETE supprime les lignes de programme indiquées par le
arguments). Si vous souhaitez utiliser DELETE pour des
programmes numérotés, utilisez d'abord DO NUM, puis DELETE,
puis FAIRE UNNUM.
Dépendances : INTERACTIVE
------------------------------------------
Commande : DIM variable(éléments...)[variable(éléments...)]...
Description : DIM spécifie des variables qui ont plusieurs
élément dans une seule dimension, c'est-à-dire en réseau
variables.
Remarque : Comme implémenté sous bwBASIC, DIM accepte uniquement
parenthèses comme délimiteurs pour les champs variables.
(Certains BASIC autorisent l'utilisation de crochets.)
Dépendances : (noyau)
------------------------------------------
Commande : DO NUM|UNNUM
Description : DO NUM numérote toutes les lignes d'un programme. La première
la ligne reçoit le numéro 10, et les lignes suivantes
sont numérotés consécutivement par multiples de 10. FAIRE
UNNUM supprime tous les numéros de ligne d'un programme.
NOTEZ que ces fonctions ne font rien pour aligner
nombres, par exemple, suivant une instruction GOSUB ou GOTO ;
ces commandes ne peuvent pas être utilisées en remplacement de
RENUM (disponible sur certains systèmes, mais pas sur bwBASIC).
Avec ces commandes, cependant, on peut développer
programmes non numérotés en entrant de nouvelles lignes avec des numéros,
puis exécutez DO UNNUM pour supprimer les numéros de ligne.
Avec LOAD et SAVE (qv), on peut utiliser
bwBASIC comme éditeur de texte primitif.
Dépendances : INTERACTIVE
------------------------------------------
Commande : DO [WHILE expression]
Description : DO implémente un certain nombre de formes de boucles de programme.
DO...LOOP boucle simplement ; la seule issue est de
SORTIR; DO WHILE...LOOP boucle pendant que "expression" est
true (cela équivaut à l'ancien WHILE-WEND
boucle, également implémentée dans bwBASIC); FAIRE... BOUCLE JUSQU'A
boucle jusqu'à ce que l'expression qui suit UNTIL soit vraie.
Dépendances : STRUCT_CMDS
------------------------------------------
Commande : MODIFIER
Description : EDIT est une pseudo-commande qui appelle l'éditeur de texte
spécifié dans la variable BWB.EDITOR$ pour éditer le
programme en mémoire. Après l'appel à l'éditeur de texte,
le programme (édité) est rechargé en mémoire. L'utilisateur
doit normalement spécifier un chemin et un nom de fichier valides dans
BWB.EDITOR$ avant cette commande sera utile.
Dépendances : COMMON_CMDS
------------------------------------------
Commande : AUTRE
Description : ELSE introduit une condition par défaut dans un SI multiligne
déclaration.
Dépendances : STRUCT_CMDS
------------------------------------------
Commande : ELSEIF
Description : ELSEIF introduit une condition secondaire dans un multi-
instruction IF de ligne.
Dépendances : STRUCT_CMDS
------------------------------------------
Commande : FIN SI | FONCTION | SÉLECTIONNER | SOUS
Description : END IF termine une instruction IF multiligne. FONCTION FIN
termine une définition de fonction multiligne. FIN SELECTION
termine une instruction SELECT CASE. END SUB termine un multi-
définition de sous-programme de ligne.
Dépendances : STRUCT_CMDS
------------------------------------------
Commande : ENVIRON variable-chaîne$ = chaîne$
Description : ENVIRON définit la variable d'environnement identifiée par
chaîne_variable$ en chaîne$.
On peut noter que cela diffère de la mise en œuvre
d'ENVIRON dans certaines versions de BASIC, mais ENVIRON de bwBASIC
permet aux variables BASIC d'être utilisées de chaque côté des égaux
signe. Notez que la fonction ENVIRON$() est différente de la
commande, et soyez conscient du fait que dans certains systèmes d'exploitation
une variable d'environnement définie dans un programme ne sera pas transmise
à sa coquille parent.
Dépendances : UNIX_CMDS
------------------------------------------
Fonction : ENVIRON$( variable-chaîne$ )
Description : ENVIRON$ renvoie la variable d'environnement associée à
le nom chaîne_variable$.
Dépendances : MS_FUNCS
------------------------------------------
Fonction : EOF (numéro de périphérique)
Description : EOF renvoie TRUE (-1) si le périphérique associé à
le numéro de périphérique est à la fin du fichier, sinon il
renvoie FAUX (0).
Dépendances : MS_FUNCS
------------------------------------------
Commande : EFFACER variable[, variable]...
Description : ERASE élimine les variables en tableau d'un programme.
Dépendances : COMMON_CMDS
------------------------------------------
Fonction: ERL
Description : ERL renvoie le numéro de ligne de l'erreur la plus récente.
Dépendances : MS_FUNCS
------------------------------------------
Fonction : ERR
Description : ERR renvoie le numéro d'erreur de l'erreur la plus récente.
Notez que si PROG_ERRORS a été défini lorsque bwBASIC est
compilé, la variable ERR ne sera pas définie correctement lors
les erreurs. Cela ne fonctionne que lorsque des messages d'erreur standard sont utilisés.
Dépendances : MS_FUNCS
------------------------------------------
Commande : numéro d'ERREUR
Description : ERROR simule une erreur, c'est-à-dire affiche le message
approprié pour cette erreur. Cette commande est utile
en écrivant ON ERROR des routines GOSUB qui peuvent identifier
quelques erreurs pour traitement particulier puis ERREUR ERR
(c'est-à-dire la gestion par défaut) pour tous les autres.
Dépendances : COMMON_CMDS
------------------------------------------
Commande : QUITTER [POUR]
Description : EXIT par lui-même sort d'une boucle DO...LOOP ;
EXIT FOR sort d'une boucle FOR...NEXT.
Dépendances : STRUCT_CMDS
------------------------------------------
Fonction : EXP( nombre )
Description : EXP renvoie la valeur exponentielle de « nombre ».
Dépendances : (noyau)
------------------------------------------
Commande : FIELD [#] numéro d'appareil, nombre AS variable-chaîne$ [, nombre AS variable-chaîne$...]
Description : FIELD alloue de l'espace dans un tampon de fichier aléatoire pour le périphérique
indiqué par le numéro de périphérique, allouant des octets « numéro »
et en affectant les octets à cette position à la variable
variable-chaîne$.
Dépendances : COMMON_CMDS
------------------------------------------
Commande : FICHIERS spécfichier$
Description : FILES est une pseudo-commande qui appelle le programme d'annuaire
spécifié dans la variable BWB.FILES$ avec l'argument
spécif_fichier$. Normalement, l'utilisateur doit définir cette variable
avant de pouvoir utiliser FILES. Par exemple, pour les ordinateurs de type PC,
BWB.FILES$ = "DIR"
fonctionnera, pour les machines Unix,
BWB.FILES$ = "ls -l"
et ainsi de suite
Dépendances : COMMON_CMDS
------------------------------------------
Commandement : FNCS
Description : CMDS est une commande de débogage qui imprime une liste
de toutes les fonctions bwBASIC prédéfinies.
Dépendances : DEBUG
------------------------------------------
Commande : FONCTION
Description : FUNCTION introduit une définition de fonction, normalement
se terminant par END FUNCTION. Dans bwBASIC, FUNCTION et
DEF sont des équivalents de travail, donc l'un ou l'autre peut être utilisé
avec des définitions de fonction sur une seule ligne ou avec
définitions de ligne terminées par END FUNCTION.
Dépendances : STRUCT_CMDS
------------------------------------------
Commande : compteur FOR = début pour terminer [incrément STEP]
Description : FOR initie une boucle FOR-NEXT avec la variable
'counter' initialement réglé sur 'start' et incrémenté
par étapes "incrémentées" (la valeur par défaut est 1) jusqu'à ce que "compteur"
équivaut à « finir ».
Dépendances : (noyau)
------------------------------------------
Commande : GET [#] numéro de périphérique [, numéro d'enregistrement]
Description : GET lit l'enregistrement suivant à partir d'un fichier à accès aléatoire
ou périphérique dans la mémoire tampon associée à ce fichier.
Si le numéro d'enregistrement est spécifié, la commande GET lit le
enregistrement spécifié.
Dépendances : COMMON_CMDS
------------------------------------------
Commande : ligne GOSUB | étiqueter
Description : GOSUB lance un appel de sous-programme vers la ligne (ou l'étiquette)
spécifié. Le sous-programme doit se terminer par RETURN.
Dépendances : (noyau), mais STRUCT_CMDS pour les étiquettes
------------------------------------------
Commande : ligne GOTO | étiqueter
Description : GOTO branche l'exécution du programme à la ligne spécifiée
(ou étiquette).
Dépendances : (noyau), mais STRUCT_CMDS pour les étiquettes
------------------------------------------
Fonction : HEX$( nombre )
Description : HEX$ renvoie une chaîne donnant l'hexadécimal (base 16)
valeur pour le 'nombre'.
Dépendances : MS_FUNCS
------------------------------------------
Commande : IF expression THEN [instruction [instruction ELSE]]
Description : IF évalue 'expression' et exécute THEN
déclaration si elle est vraie ou (éventuellement) la
instruction ELSE si elle est FALSE. Si STRUCT_CMDS
est défini sur TRUE, bwBASIC autorise les SI multilignes
instructions avec les cas ELSE et ELSEIF, se terminant
avec FIN SI.
Dépendances : (noyau), STRUCT_CMDS pour les instructions IF multilignes
------------------------------------------
Fonction : INKEY$
Description : INKEY$ lit l'état du clavier, et un seul
appuyez sur une touche, si disponible. Si une touche n'est pas disponible,
alors INKEY$ renvoie immédiatement une chaîne nulle ("").
Actuellement (v2.10) implémenté dans bwx_iqc.c uniquement.
Dépendances : IMP_IQC et IMP_CMDLOC
------------------------------------------
Commande : INPUT [# device-number]|[;]["prompt string";]list of variables
Description : INPUT permet l'entrée depuis le terminal ou un appareil
spécifié par le numéro de périphérique. Si terminal, le "invite
string" est sortie et l'entrée est affectée à la
variables appropriées spécifiées.
bwBASIC ne prend pas en charge la fonctionnalité optionnelle de INPUT
qui supprime le retour chariot et le saut de ligne à la fin
de l'entrée. C'est parce que C seul ne fournit aucun
moyens d'entrée autres que les chaînes terminées par CR-LF.
Dépendances : (noyau)
------------------------------------------
Fonction : INSTR( [position de départ,] recherche de chaîne$, motif de chaîne$ )
Description : INSTR renvoie la position à laquelle string-pattern$
apparaît dans la chaîne $ recherchée, en commençant à la position de départ.
Comme implémenté dans bwBASIC, INSTR ne peut pas être utilisé pour
missions.
Remarque : bwBASIC actuellement (v2.10) ne permet pas l'affectation
à une fonction.
Dépendances : MS_FUNCS
------------------------------------------
Fonction : INT (numéro)
Description : INT renvoie le plus grand entier inférieur ou égal à
l'argument « nombre ». NOTEZ qu'il ne s'agit pas d'un "tronqué"
fonction entière, pour laquelle voir CINT.
Dépendances : (noyau)
------------------------------------------
Commande : KILL nom-fichier$
Description : KILL supprime le fichier spécifié par nom-fichier$.
Dépendances : UNIX_CMDS
------------------------------------------
Fonction : LEFT$( string$, nombre-d'espaces )
Description : LEFT$ renvoie une sous-chaîne d'une chaîne$ avec un nombre d'espaces
à partir de la gauche (début) de la chaîne). Tel que mis en œuvre
sous bwBASIC, il ne peut pas être utilisé pour l'affectation.
Dépendances : MS_FUNCS
------------------------------------------
Fonction : LEN( chaîne$ )
Description : LEN renvoie la longueur en octets de la chaîne $.
Dépendances : COMMON_FUNCS
------------------------------------------
Commande : LET variable = expression
Description : LET affecte la valeur de 'expression' à la variable.
Tel qu'il est actuellement implémenté, bwBASIC prend en charge le LET implicite
déclarations (par exemple, "X = 4.5678" au début de
une ligne ou un segment de ligne, mais ne prend pas en charge l'affectation
à plusieurs variables (par exemple, "x, y, z = 3.141596").
Dépendances : (noyau)
------------------------------------------
Commande : LINE INPUT [[#] numéro-périphérique,]["chaîne d'invite" ;] variable-chaîne$
Description : LINE INPUT lit la ligne entière à partir du clavier ou d'un fichier
ou périphérique en string-variable$. Si l'entrée provient du
clavier (stdin), puis "chaîne d'invite" sera imprimée
premier. Contrairement à INPUT, LINE INPUT lit une ligne entière,
ne s'arrête pas pour les éléments de données délimités par des virgules.
Dépendances : COMMON_CMDS
------------------------------------------
Commande : LIST ligne[-ligne]
Description : LIST répertorie les lignes de programme comme spécifié dans son argument.
Dépendances : INTERACTIVE
------------------------------------------
Commande : LOAD nom-fichier
Description : LOAD charge un programme ASCII BASIC en mémoire.
Dépendances : INTERACTIVE
------------------------------------------
Fonction : LOC (numéro d'appareil)
Description : LOC renvoie le prochain enregistrement que les instructions GET ou PUT
utilisera.
Dépendances : MS_FUNCS
------------------------------------------
Commande : LOCATE ligne, colonne
Description : LOCATE adresse le curseur à une ligne spécifiée et
colonne. Actuellement (v2.10) implémenté dans bwx_iqc.c uniquement.
Dépendances : IMP_IQC et IMP_CMDLOC
------------------------------------------
Fonction : LOF (numéro d'appareil)
Description : LOF renvoie la longueur d'un fichier (spécifiée par le numéro de périphérique)
en octets.
Dépendances : MS_FUNCS
------------------------------------------
Fonction : LOG (numéro)
Description : LOG renvoie le logarithme népérien de l'argument 'nombre'.
Dépendances : (noyau)
------------------------------------------
Commande : BOUCLE [expression UNTIL]
Description : LOOP termine une boucle de programme : voir DO.
Dépendances : STRUCT_CMDS
------------------------------------------
Commande : LSET variable-chaîne$ = expression
Description : LSET transfère les données de « expression » vers la gauche
côté d'une variable de chaîne ou d'un champ de tampon d'accès aléatoire.
Dépendances : COMMON_CMDS
------------------------------------------
Commande : MERGE nom-fichier
Description : MERGE ajoute des lignes de programme de 'file-name' au programme
en mémoire. Contrairement à LOAD, il n'efface pas le programme
actuellement en mémoire.
Dépendances : COMMON_CMDS
------------------------------------------
Fonction : MID$( string$, start-position-in-string[, number-of-spaces ] )
Description : MID$ renvoie une sous-chaîne de chaîne$ commençant à
position de début dans la chaîne et continue pendant
nombre d'octets d'espaces.
Dépendances : MS_FUNCS
------------------------------------------
Commande : nom de chemin MKDIR$
Description : MKDIR crée un nouveau chemin de répertoire comme spécifié par
chemin$.
Dépendances : UNIX_CMDS
------------------------------------------
Fonction : MKD$( nombre )
Description : MKD$, MKI$ et MKS$ sont tous équivalents dans bwBASIC.
Ils convertissent la valeur numérique 'nombre' en une chaîne
qui peut être stocké sous une forme plus compressée dans un fichier
(en particulier pour l'accès aléatoire aux fichiers). Étant donné que bwBASIC ne
pas reconnaître les différences de précision, ces commandes
sont effectivement équivalents.
Dépendances : MS_FUNCS
------------------------------------------
Fonction : MKI$( nombre )
Description : équivalent à MKD$ (qv)
Dépendances : MS_FUNCS
------------------------------------------
Fonction : MKS$( nombre )
Description : équivalent à MKD$ (qv).
Dépendances : MS_FUNCS
------------------------------------------
Commande : NAME ancien-nom-fichier AS nouveau-nom-fichier
Description : NAME renomme un fichier existant (ancien nom de fichier) en
nouveau-nom-de-fichier.
Dépendances : UNIX_CMDS
------------------------------------------
Commande : NOUVEAU
Description : NOUVEAU supprime le programme en mémoire et efface tout
variables.
Dépendances : INTERACTIVE
------------------------------------------
Commande : SUIVANT [variable de compteur]
Description : NEXT vient à la fin d'une boucle FOR-NEXT ; voir pour.
Dépendances : (noyau)
------------------------------------------
Fonction : OCT$( nombre )
Description : OCT$ renvoie une chaîne donnant l'octal (base 8)
représentation du « nombre ».
Dépendances : MS_FUNCS
------------------------------------------
Commande : ON variable GOTO|GOSUB ligne[,ligne,ligne,...]
Description : ON branche (GOTO) ou appelle un sous-programme
(GOSUB) basé sur la valeur arrondie de la variable ;
si c'est 1, la première ligne est appelée, si 2, la seconde
la ligne est appelée, etc.
Dépendances : (noyau)
------------------------------------------
Commande : ON ERROR GOSUB line|label
Description : ON ERROR configure un sous-programme de gestion des erreurs. Voir
aussi ERREUR.
Dépendances : COMMON_CMDS, STRUCT_CMDS pour les étiquettes
------------------------------------------
Commande : OUVRIR "O"|"I"|"R", [#]numéro d'appareil, nom de fichier [,longueur d'enregistrement]
nom-fichier FOR INPUT|OUTPUT|APPEND AS [#]numéro-périphérique [LEN = longueur d'enregistrement]
Description : OPEN alloue de la mémoire vive pour l'accès à un disque
fichier ou autre périphérique. Notez que deux formes assez différentes
de l'instruction OPEN sont pris en charge. Dans la première forme,
"O" (notez que ces lettres doivent être mises entre guillemets
marques) indique une sortie séquentielle, "I" indique une sortie séquentielle
entrée, et "R" désigne l'entrée et la sortie à accès aléatoire.
Une fois OUVERT, n'importe quel nombre d'opérations peut être effectué
sur un périphérique (voir WRITE #, INPUT #, PRINT #, etc.).
Dépendances : COMMON_CMDS
------------------------------------------
Commande : numéro OPTION BASE
Description : OPTION BASE définit la valeur la plus faible pour les indices de tableau,
soit 0 ou 1.
Dépendances : (noyau)
------------------------------------------
Fonction : POS
Description : POS renvoie la position actuelle du curseur dans la ligne.
Dépendances : COMMON_FUNCS
------------------------------------------
Commande : PRINT [# numéro-de-périphérique,][USING chaîne-format$;] expressions...
Description : IMPRIMER affiche du texte à l'écran ou dans un fichier ou un périphérique
spécifié par le numéro de périphérique. Dans la mise en œuvre actuelle
de bwBASIC, les expressions à imprimer doivent être séparées par
la virgule (sortie tabulée), le point-virgule (immédiat
sortie séquentielle) ou le signe plus (séquentiel immédiat
sortie par concaténation de chaînes). Expressions séparées
par des blancs ou des tabulations ne sont pas pris en charge. Si USING est spécifié,
un certain nombre de marques de formatage peuvent apparaître dans le format
chaîne:
! imprime le premier caractère d'une chaîne
\ imprime 2+x caractères d'une chaîne, où x =
le nombre d'espaces entre les barres obliques inverses
& champ de chaîne de longueur variable
# représente un seul chiffre dans le format de sortie pour
un numéro
. point décimal dans un nombre
+ signe d'un nombre (affichera + ou -)
- moins après un nombre
** remplir les espaces de début avec des astérisques
$$ produit un signe dollar devant un nombre
^^ nombre de sortie au format exponentiel
_ affiche le caractère suivant littéralement
Tel qu'il est actuellement mis en œuvre, le format exponentiel
sera celui utilisé par le compilateur C.
Dépendances : (noyau), COMMON_FUNCS pour USING
------------------------------------------
Commande : PUT [#] numéro d'appareil [, numéro d'enregistrement]
Description : PUT sort le prochain enregistrement disponible ou l'enregistrement
spécifié par le numéro d'enregistrement du fichier ou du périphérique
désigné par le numéro de périphérique.
Dépendances : COMMON_CMDS
------------------------------------------
Commande : QUITTER
Description : QUIT est un synonyme de SYSTEM ; avec INTERACTIF
l'environnement, il quitte le programme vers le
système d'exploitation (ou le programme appelant).
Dépendances : INTERACTIVE
------------------------------------------
Commande : nombre RANDOMIZE
Description : RANDOMIZE amorce le générateur de nombres aléatoires (voir RND).
Sous bwBASIC, la fonction TIMER (qv) peut être utilisée
pour fournir une graine 'nombre' pour le nombre aléatoire
générateur.
Dépendances : (noyau)
------------------------------------------
Commande : LIRE variable[, variable]...
Description : READ lit les valeurs des instructions DATA et les affecte
valeurs aux variables nommées. Types de variables dans un READ
l'instruction doit correspondre aux types de données dans les instructions DATA
au fur et à mesure qu'ils se produisent. Voir aussi DATA et RESTORE.
Dépendances : (noyau)
------------------------------------------
Commande : chaîne REM
Description : REM permet d'inclure des remarques dans un programme. Comme
actuellement mis en œuvre, toute la ligne suivant
REM est ignoré par l'interpréteur (ainsi, même si
MULTISEG_LINES est défini, une ligne REM ne pourra pas
pour trouver un délimiteur de segment (":") suivi d'un autre
segment de ligne avec la commande. bwBASIC ne fonctionne pas actuellement
implémenter l'utilisation à la Microsoft du guillemet simple
marque pour indiquer les remarques.
Dépendances : (noyau)
------------------------------------------
Commande : ligne RESTORE
Description : RESTORE réinitialise les compteurs de ligne et de position pour DATA
et les instructions READ en haut du fichier programme ou
au début de la ligne spécifiée. (Actuellement ce
doit être un numéro de ligne.)
Dépendances : (noyau)
------------------------------------------
Commande : RETOUR
Description : RETURN termine un sous-programme appelé par GOSUB.
Dépendances : (noyau)
------------------------------------------
Fonction : RIGHT$( string$, nombre-d'espaces )
Description : RIGHT$ renvoie une sous-chaîne une chaîne$ avec un nombre d'espaces
à partir de la droite (fin) de la chaîne). Tel que mis en œuvre
sous bwBASIC, il ne peut pas être utilisé pour l'affectation.
Dépendances : MS_FUNCS
------------------------------------------
Commande : nom de chemin RMDIR
Description : RMDIR supprime le chemin du répertoire indiqué par pathname.
Dépendances : UNIX_CMDS
------------------------------------------
Fonction : RND (numéro)
Description : RND renvoie un nombre pseudo-aléatoire. La valeur 'nombre'
est ignoré par bwBASIC s'il est fourni. Le RANDOMISE
La commande (qv) réinitialise le générateur de nombres aléatoires.
Dépendances : (noyau)
------------------------------------------
Commande : RSET string-variable$ = expression
Description : RSET transfère les données de « expression » vers la partie droite
côté d'une variable de chaîne ou d'un champ de tampon d'accès aléatoire.
Dépendances : COMMON_CMDS
------------------------------------------
Commande : RUN [ligne][nom-fichier$]
Description : RUN exécute le programme en mémoire. Si un nom de fichier$ est
fourni, le fichier spécifié est chargé en mémoire
et exécuté. Si un numéro de ligne est fourni, alors l'exécution
commence à cette ligne.
Dépendances : INTERACTIVE
------------------------------------------
Commande : SAVE nom-fichier$
Description : SAVE enregistre le programme en mémoire sous nom-fichier$. bwBASIC
enregistre uniquement les fichiers au format ASCII.
Dépendances : INTERACTIVE
------------------------------------------
Commande : expression SELECT CASE
Description : SELECT CASE introduit une sélection conditionnelle multiligne
déclaration. L'expression donnée en argument à SELECT
CASE sera évalué par les déclarations CASE suivantes. Les
L'instruction SELECT CASE se termine par un END SELECT
déclaration.
Telles qu'elles sont actuellement mises en œuvre, les instructions CASE peuvent être suivies
par valeurs de chaîne, mais dans ce cas uniquement des comparaisons simples
(égal, non égal) peut être exécuté.
Dépendances : STRUCT_CMDS
------------------------------------------
Fonction : SGN (numéro)
Description : SGN renvoie le signe de l'argument 'nombre', +1
pour les nombres positifs, 0 pour 0 et -1 pour les nombres négatifs.
Dépendances : (noyau)
------------------------------------------
Fonction : SIN (numéro)
Description : SIN renvoie le sinus de l'argument 'nombre'
en radians.
Dépendances : (noyau)
------------------------------------------
Fonction : SPACE$( nombre )
Description : SPACE$ renvoie une chaîne d'espaces vides « nombre »
octets de long.
Dépendances : MS_FUNCS
------------------------------------------
Fonction : SPC (numéro)
Description : SPC renvoie une chaîne d'espaces vides « nombre »
octets de long.
Dépendances : MS_FUNCS
------------------------------------------
Fonction : SQR (numéro)
Description : SQR renvoie la racine carrée de l'argument « nombre ».
Dépendances : (noyau)
------------------------------------------
Commande : ARRÊTER
Description : STOP interrompt l'exécution du programme. Comme mis en œuvre sous
bwBASIC, STOP émet un signal SIGINT.
Dépendances : (noyau)
------------------------------------------
Fonction : STR$( nombre )
Description : STR$ renvoie une chaîne donnant la décimale (base 10)
représentation de l'argument 'nombre'.
Dépendances : COMMON_FUNCS
------------------------------------------
Fonction : STRING$( nombre, valeur ascii|string$ )
Description : STRING$ renvoie une chaîne 'nombre' d'octets composée de
soit du premier caractère de la chaîne$ soit du caractère
répondant à la valeur ASCII valeur ascii.
Dépendances : MS_FUNCS
------------------------------------------
Commande : SUB nom-sous-routine
Description : SUB introduit un sous-programme multiligne nommé. Les
le sous-programme est appelé par une instruction CALL et se termine
avec une instruction END SUB.
Dépendances : STRUCT_CMDS
------------------------------------------
Commande : variable SWAP, variable
Description : SWAP échange les valeurs de deux variables. Les deux variables
doit être du même type (soit numérique, soit chaîne).
Dépendances : COMMON_CMDS
------------------------------------------
Commande : SYSTÈME
Description : SYSTEM quitte bwBASIC vers le programme appelant ou
(plus généralement) le système d'exploitation.
Dépendances : INTERACTIVE
------------------------------------------
Fonction : TAB (numéro)
Description : TAB génère des espaces jusqu'à la colonne indiquée par
'numéro' a été atteint.
Dépendances : (noyau)
------------------------------------------
Fonction : TAN (numéro)
Description : TAN renvoie la tangente de l'argument 'nombre'
en radians.
Dépendances : (noyau)
------------------------------------------
Fonction : TEMPS$
Description : TIME$ renvoie l'heure actuelle en fonction de l'ordinateur
horloge interne sous forme de chaîne sous la forme "HH-MM-SS".
Comme implémenté sous bwBASIC, TIME$ ne peut pas être utilisé pour
affectation (c'est-à-dire pour régler l'heure du système).
Remarque : bwBASIC actuellement (v2.10) ne permet pas l'affectation
à une fonction.
Dépendances : COMMON_FUNCS
------------------------------------------
Fonction: MINUTERIE
Description : TIMER renvoie l'heure dans l'horloge système en secondes
écoulé depuis minuit.
Dépendances : MS_FUNCS
------------------------------------------
Commande : TROFF
Description : tours TROFF de l'installation de traçage ; voir TRON.
Dépendances : COMMON_CMDS
------------------------------------------
Commandement : TRON
Description : TRON active la fonction de traçage. Cette installation imprimera
chaque numéro de ligne entre crochets pendant que le programme est
réalisé. Ceci est utile pour déboguer des programmes avec
numéros de ligne. Pour déboguer un programme non numéroté avec
TRON, appelez DO NUM d'abord, mais n'oubliez pas d'appeler DO UNNUM
avant de sauvegarder le programme plus tard.
Dépendances : COMMON_CMDS
------------------------------------------
Fonction : VAL( chaîne$ )
Description : VAL renvoie la valeur numérique de la chaîne$.
Dépendances : COMMON_FUNCS
------------------------------------------
Commandement : VARS
Description : VARS est une commande de débogage qui imprime une liste de
toutes les variables définies qui ont une portée globale.
Dépendances : DEBUG
------------------------------------------
Commandement : WEND
Description : WEND termine une boucle WHILE-WEND ; voir PENDANT.
Dépendances : COMMON_CMDS
------------------------------------------
Commande : expression WHILE
Description : WHILE initie une boucle WHILE-WEND. La boucle se termine par
WEND, et l'exécution réitère à travers la boucle comme
tant que l''expression' est VRAI (-1).
Dépendances : COMMON_CMDS
------------------------------------------
Commande : WIDTH [# numéro d'appareil,] numéro
Description : WIDTH définit la sortie de l'écran ou de l'appareil sur « numéro »
Colonnes. numéro-de-périphérique spécifie le périphérique
ou un fichier pour la sortie.
Dépendances : COMMON_CMDS
------------------------------------------
Commande : WRITE [# numéro-de-périphérique,] élément [, élément ]....
Description : WRITE sort des variables à l'écran ou dans un fichier
ou périphérique spécifié par le numéro de périphérique. virgules
sont insérés entre la sortie des expressions et les chaînes
sont entre guillemets.
Dépendances : COMMON_CMDS
------------------------------------------
6. VARIABLES PRÉDÉFINIES
BWB.EDITEUR$
BWB.FILES$
BWB.PROMPT$
MISE EN UVRE BWB$
Les commandes EDIT et FICHIERS sont des pseudo-commandes qui lancent
les programmes shell nommés dans les variables BWB.EDITOR$ et BWB.FILES$,
respectivement. Les valeurs par défaut de ces variables peuvent
être modifiés dans bwbasic.h (DEF_EDITOR et DEF_FILES), ou ils
peut être modifié à la volée par l'utilisateur. Une idée pourrait être de
initialiser ces variables dans "profile.bas" pour des
implémentations; par exemple, BWB.FILES$ peut être défini comme
"ls -l" sur les systèmes Unix ou "dir" sur les systèmes DOS.
La variable prédéfinie BWB.PROMPT$ peut être utilisée pour définir l'invite
chaîne pour bwBASIC. Encore une fois, il est suggéré qu'un utilisateur-
l'invite sélectionnée peut être configurée dans un "profile.bas" pour être
initialisé à chaque démarrage de bwBASIC. Notez que spécial
des caractères peuvent être ajoutés à la chaîne d'invite, par exemple,
BWB.PROMPT$ = "Ok"+CHR$(10)
donnera une invite "Ok" suivie d'un saut de ligne.
La variable prédéfinie BWB.IMPLEMENTATION$ renverra "TTY" pour
l'implémentation bwx_tty et renverra "IQC" pour le
Implémentation IBM PC ou Compatibles avec QuickC (bwx_iqc).
Cela peut être utile pour déterminer quelles commandes et fonctions
(en particulier CLS, LOCATE et INKEY$) peuvent être disponibles.
7. COMMANDES ET FONCTIONS NON MISE EN OEUVRE, et AGENDA POUR LE DEVELOPPEMENT
Il y a des éléments non implémentés qui ont été si longs
une partie des BASIC standards que leur absence paraîtra surprenante.
Dans chaque cas, cependant, leur mise en œuvre nécessiterait une opération
fonctions spécifiques au système ou fonctions spécifiques au terminal
qui ne peuvent pas être fournis universellement. Quelques exemples précis :
CLOAD Repose sur les conventions CP/M ou MSDOS pour le binaire
fichiers exécutables.
SUITE Voir RESUME ci-dessous (ignorance du programmeur ?).
DEF USR Repose sur les conventions CP/M ou MSDOS pour le binaire
fichiers exécutables.
FRE() La possibilité de signaler la quantité de mémoire libre
le reste est spécifique au système en raison de modèles variables
de l'allocation et de l'accès à la mémoire ; par conséquent ce
la capacité n'est pas présente dans ANSI ou les versions antérieures
de C et cette fonction n'est pas disponible dans bwBASIC.
INPUT$() C par lui-même n'est pas capable de lire le clavier sans écho
entrée et ne peut lire l'entrée du clavier qu'après un
Le retour chariot a été saisi.
INP Appels vers les ports matériels, comme le langage machine
routines, sont hautement spécifiques au système et ne peuvent
être implémenté en C seul.
LLIST Voir LPRINT ci-dessous.
LPOS Voir LPRINT ci-dessous.
LPRINT et LLIST, etc., nécessitent l'accès à un périphérique d'impression,
et cela varie d'un système à l'autre. Utilisateurs
peuvent essayer d'OUVRIR le périphérique d'impression par eux-mêmes
système d'exploitation (par exemple, "/dev/lp" sur les systèmes Unix,
ou "PRN" sous DOS) et voyez si l'impression peut être effectuée
de bwBASIC de cette manière.
NULL Dans ce cas, je suis convaincu que NULL n'est plus
nécessaire, car très peu d'imprimantes nécessitent maintenant des valeurs NULL
à la fin des lignes.
OUT Voir INP ci-dessus (appels vers les ports matériels).
PEEK() PEEK et POKE ont permis aux BASIC antérieurs d'adresser
emplacements de mémoire particuliers. Bien que bwBASIC
pourrait éventuellement implémenter cette commande (POKE) et
cette fonction (PEEK()), la limitation serait
fortement limité par les différents systèmes de
accès à la mémoire dans différents systèmes.
POKE voir PEEK() ci-dessus.
RENUM Puisque des lignes non numérotées peuvent être saisies et
exécuté sous bwBASIC, il ne serait pas
possible d'implémenter une routine RENUM.
Au lieu de cela, bwBASIC utilise DO NUM et DO UNNUM.
RESUME Est-ce possible sous C? Si oui, je
n'ont tout simplement pas encore réussi à le comprendre.
Mea culpa (mais pas maxima).
USR Voir CALL et DEF USR ci-dessus (langage machine
sous-programmes).
VARPTR Voir PEEK et POKE ci-dessus.
WAIT Voir INP et OUT ci-dessus.
Il existe d'autres commandes, fonctions et détails d'implémentation
sur lesquels je travaille et qui sont à l'ordre du jour des prochaines
versions de bwBASIC. Ces agendas comprennent :
PARACT, c'est-à-dire la capacité d'exécuter des ACTIONS PARallèles. Cette
est décrit dans ANSI BASIC, bien que je ne l'aie pas vu
mis en œuvre auparavant. Il offrira un rugueux, non-
forme préventive de multitâche dans le cadre
d'un programme BASIC. Les programmeurs noteront les points auxquels
il y a déjà des crochets pour PARACT dans bwBASIC.
Les ordinateurs de type PC XMEM doivent pouvoir utiliser des
Mémoire. Si nous pouvions utiliser la mémoire étendue pour le programme
des lignes, des variables et des définitions de fonctions, nous pourrions
écrire des programmes beaucoup plus longs. Cela impliquerait,
cependant, une réécriture assez sérieuse du programme
d'utiliser des descripteurs de mémoire pour ces fonctionnalités de stockage
au lieu de pointeurs de mémoire directs.
Windows L'ajout de descripteurs de mémoire en plus du
exécution non préemptive des lignes de programme (dans un
forme brute, déjà présente) permettra
développer des implémentations pour Windows et peut-être
pour d'autres interfaces utilisateur graphiques. Mais quelle forme
cela devrait-il prendre? J'ai en tête actuellement un BASIC
qui s'exécuterait en arrière-plan, n'apparaissant que
sous forme d'icône dans l'espace GUI, avec des éditeurs contextuels
et des fenêtres de sortie. Ainsi, le langage interprété
servirait à quelque chose comme 'cron' (une tâche
planificateur) sous les systèmes Unix. Vous pouvez en avoir
réflexions qui m'aideraient en cela.
Graphiques Ici, nous sommes confrontés à des différences assez critiques dans les différents
styles et implémentations de graphiques, par exemple, entre
GWBASIC, ANSI BASIC, VisualBASIC, etc. Mais c'est
possible que les commandes et fonctions graphiques
être ajouté. Celles-ci seraient toutes spécifiques à la mise en œuvre.
La norme ANSI pour le BASIC complet ne spécifie pas
des commandes ou des fonctions doivent être implémentées, et en fait la norme
est très robuste. Peut-être qu'aucune implémentation de BASIC ne serait jamais
inclure tous les éléments, mais certaines commandes et fonctions ANSI qui
restent non mis en œuvre sont :
ACCÈS
ANGLE
Réservé
ARITHMÉTIQUE
TABLEAU
ASK
BSTR
BVAL
PLAFOND
CELLULES
CLIP
COLLATE
CONNECTEZ-VOUS
COSH
DATE
DEBUG
DÉCIMAL
DÉCLARER
DEGRÉS
DISPOSITIF
DÉCONNECTER
DISPLAY
DOT
DESSINER
EFFACER
EVENT
EXCEPTION
GRAPHIQUE
MANIPULATEUR
IMAGE
clé - KEY
CASE
LIGNES
LOG10
LOG2
MAT
MIX
MULTIPOINTS
SORTIR
SORTIE
PARACTE
IMAGE
PIXEL
TERRAIN
POINTS
RADIANS
RECEVOIR
RENUMEROTER
RÉCRIRE
ROTATION
ROUND
S'EMPARER DE
ENVOYER
SHIFT
SINH
TANH
TIMEOUT
TRACE
TRANSFORMER
TRONQUER
UBOUND
UCAS
VISUALISATION
TAILLES
VISUALISATION
LARGEUR DE ZONE
8. L'HISTOIRE DE BYWATER BASIC
Ce programme a été lancé à l'origine en 1982 par ma grand-mère, Mme.
Verda Sort de Beaumont, TX. Elle écrivait le programme en utilisant
un compilateur ANSI C sur un ordinateur Osborne I CP/M et bien que mon
grand-père (Lockwood Spell) avait acheté un PC IBM avec 256k de
RAM ma grand-mère ne l'utiliserait pas, paraphrasant George Herbert
à l'effet que "Celui qui ne peut pas programmer en 64k, ne peut pas en 512k."
Elle avait utilisé Microsoft BASIC et bien qu'elle n'ait rien contre
elle a répété à plusieurs reprises qu'elle ne comprenait pas pourquoi Digital
La recherche n'a pas "poursuivi en justice Microsoft" pour la version 1.0
de MSDOS et j'estime donc qu'elle espérait saper celle de Microsoft
l'ensemble du marché et éventuellement construire un nouvel empire du logiciel sur
l'extrémité nord de Beaumont. Ses efforts de programmation ont été coupés
tragiquement courte lorsqu'elle fut jetée d'un Beaumont à Port
Arthur train de banlieue à l'été 1986. J'ai trouvé la source
code à bwBASIC sur une disquette Osborne simple densité dans son tricot
sac et a finalement réussi à tout copier sur un PC
disquette. Je l'ai légèrement révisé avant cette version. Tu
Je devrais savoir, cependant, que je suis moi-même un historien, pas un programmeur.
9. COMMUNICATION :
Courriel: [email protected]
11 octobre 1993 BWBASIQUE(1)
Utiliser bwbasic en ligne en utilisant les services onworks.net
