Este es el comando renum que se puede ejecutar en el proveedor de alojamiento gratuito de OnWorks utilizando una de nuestras múltiples estaciones de trabajo en línea gratuitas, como Ubuntu Online, Fedora Online, emulador en línea de Windows o emulador en línea de MAC OS.
PROGRAMA:
NOMBRE
bwbasic - intérprete / intérprete BÁSICO de Bywater
Intérprete / Shell BÁSICO de Bywater, versión 2.10
---------------------------------------------
Derechos de autor (c) 1993, Ted A. Campbell
para bwBASIC versión 2.10, 11 de octubre de 1993
CONTENIDOS:
1. DESCRIPCIÓN
2. TÉRMINOS DE USO
3. LISTA DE REFERENCIA RÁPIDA DE COMANDOS Y FUNCIONES
4. NOTAS GENERALES SOBRE EL USO
5. REFERENCIA AMPLIADA PARA COMANDOS Y FUNCIONES
6. VARIABLES PREDEFINIDAS
7. COMANDOS Y FUNCIONES NO IMPLEMENTADOS
y AGENDA PARA EL DESARROLLO
8. LA HISTORIA DEL BYWATER BASIC
9. COMUNICACIONES
El autor desea expresar su agradecimiento al Sr. David MacKenzie.
que ayudó en el desarrollo de la instalación y configuración de Unix
para esta versión.
1. DESCRIPCIÓN
El intérprete BÁSICO de Bywater (bwBASIC) implementa una gran
superconjunto del estándar ANSI para mínimo básico (X3.60-1978)
y un subconjunto significativo del estándar ANSI para BASIC completo
(X3.113-1987) en C. También ofrece funciones de programación de shell
como una extensión de BASIC. bwBASIC busca ser tan portátil
como sea posible.
bwBASIC se puede configurar para emular funciones, comandos y
funciones disponibles en diferentes tipos de intérpretes BASIC;
consulte el archivo INSTALAR para obtener más información sobre la instalación.
El intérprete es bastante lento. Siempre que se enfrente a una elección
entre la claridad conceptual y la velocidad, siempre he elegido
el primero. El intérprete es el diseño más simple disponible,
y no utiliza ningún sistema de código intermedio, lo que aceleraría
Ha aumentado considerablemente su funcionamiento. Como está, cada línea se interpreta
de nuevo cuando llegue el intérprete.
bwBASIC implementa una característica no disponible en BASIC anterior
intérpretes: se puede ingresar un comando de shell de forma interactiva en el
bwBASIC y el intérprete lo ejecutará bajo un
shell de comando. Por ejemplo, el comando "dir * .bas" puede ser
ingresado en bwBASIC (bajo DOS, o "ls -l * .bas" bajo UNIX) y
se ejecutará desde la línea de comandos del sistema operativo.
Los comandos de shell también se pueden dar en líneas numeradas en un bwBASIC
programa, de modo que bwBASIC se puede utilizar como un programa de shell
idioma. Implementación de bwBASIC de RMDIR, CHDIR, MKDIR,
Comandos y funciones NAME, KILL, ENVIRON y ENVIRON $ ()
ofrecen más capacidades de procesamiento de shell.
2. TÉRMINOS DE USO:
Esta versión de Bywater BASIC se publica bajo los términos del
Licencia pública general GNU (GPL), que se distribuye con esta
software en el archivo "COPIA". La GPL especifica los términos
bajo el cual los usuarios pueden copiar y usar el software en esta distribución.
Una licencia separada está disponible para distribución comercial,
para obtener información sobre la que debe comunicarse con el autor.
3. LISTA DE REFERENCIA RÁPIDA DE COMANDOS Y FUNCIONES
Tenga en cuenta que muchos de estos comandos y funciones no se
disponible a menos que haya establecido ciertas banderas en los archivos de encabezado
(consulte la sección de referencia ampliada a continuación para conocer las dependencias).
ABS (número)
ASC (cadena $)
ATN (número)
CALL subrutina-nombre
CASO ELSE | IF expresión-parcial | constante
CADENA [FUSIÓN] nombre-archivo [, número-línea] [, TODOS]
Nombre de ruta CHDIR
CHR $ (número)
CINT (número)
CLEAR
CERRAR [[#] número de archivo] ...
CLS
Variable COMÚN [, variable ...]
COS (número)
CSNG (número)
CVD (cadena $)
CVI (cadena $)
CVS (cadena $)
Constante de DATOS [, constante] ...
FECHA $
DEF FNname (arg ...)] = expresión
DEFDBL letra [-letra] (, carta [-letra]) ...
DEFINT carta [-letra] (, carta [-letra]) ...
DEFSNG carta [-letra] (, carta [-letra]) ...
DEFSTR carta [-letra] (, carta [-letra]) ...
BORRAR línea [-line]
Variable DIM (elementos ...) [variable (elementos ...)] ...
HACER NUM | UNNUM
DO [WHILE expresión]
EDITAR
ELSE
ELSEIF
END IF | FUNCION | SELECCIONAR | SUB
ENVIRON cadena-variable = cadena
ENVIRON $ (cadena-variable)
EOF (número de dispositivo)
BORRAR variable [, variable] ...
ERL
ERR
Numero erroneo
EXP (número)
CAMPO [#] número-dispositivo, número AS variable-cadena [, número AS variable-cadena ...]
ARCHIVOS especificación de archivo $
FUNCIÓN
PARA el contador = comenzar HASTA terminar [incremento de PASO]
OBTENER [#] número-dispositivo [, número-registro]
Línea GOSUB | etiqueta
Línea GOTO | etiqueta
HEX $ (número)
IF expresión ENTONCES [declaración [declaración ELSE]]
INKEY $
INPUT [# device-number] | [;] ["prompt string";] lista de variables
INSTR ([posición de inicio,] búsqueda de cadena $, patrón de cadena $)
INT (número)
KILL nombre de archivo
IZQUIERDA $ (cadena $, número de espacios)
LEN (cadena $)
LET variable = expresión
ENTRADA DE LÍNEA [[#] número-dispositivo,] ["cadena de solicitud";] variable-cadena $
LIST línea [-line]
LOAD nombre-archivo
LOC (número de dispositivo)
LOCATE línea, columna
LOF (número de dispositivo)
LOG (número)
LOOP [HASTA expresión]
LSET variable de cadena $ = expresión
MERGE nombre-archivo
MID $ (cadena $, posición-inicio-en-cadena [, número-de-espacios])
MKD $ (número)
Nombre de ruta MKDIR
MKI $ (número)
MKS $ (número)
NOMBRE nombre-archivo-antiguo AS nombre-archivo-nuevo
NUEVO
SIGUIENTE [contador]
OCT $ (número)
ON variable GOTO | GOSUB línea [, línea, línea, ...]
ON ERROR línea GOSUB
OPEN "O" | "I" | "R", [#] número de dispositivo, nombre de archivo [, longitud de registro]
nombre-archivo PARA ENTRADA | SALIDA | ANEXO COMO [#] número-dispositivo [LEN = longitud-registro]
Número de OPCIÓN BASE
TPV
PRINT [# número-dispositivo,] [USANDO formato-cadena $;] expresiones ...
PUT [#] número-dispositivo [, número-registro]
DEJAR
Número aleatorio
LEER variable [, variable] ...
Secuencia REM
RESTAURAR línea
DEVOLUCION
DERECHA $ (cadena $, número de espacios)
Nombre de ruta de RMDIR
RND (número)
Variable de cadena RSET $ = expresión
EJECUTAR [línea] [nombre de archivo]
GUARDAR nombre de archivo
Expresión SELECT CASE
SGN (número)
SIN (número)
ESPACIO $ (número)
SPC (número)
SQR (número)
STOP
STR $ (número)
STRING $ (número, valor ascii | cadena $)
SUB nombre-subrutina
Cambio variable, variable
LITE PARA TECHOS PLANOS
TAB (número)
TAN (número)
HORA $
MINUTERO
TROFF
TRON
VAL (cadena $)
ENCAMINARSE A
MIENTRAS expresión
WIDTH [# device-number,] número
ESCRIBIR [# número-dispositivo,] elemento [, elemento] ....
4. NOTAS GENERALES SOBRE EL USO:
4.a. Entorno interactivo
Se proporciona un entorno interactivo si la bandera INTERACTIVA
se define como TRUE en bwbasic.h, de modo que una línea con un
El número de línea se puede ingresar en el indicador bwBASIC y será
agregado al programa en la memoria.
Los números de línea no son estrictamente obligatorios, pero son útiles si el
El entorno interactivo se utiliza para la programación. A lo largo
entrada de programa, uno podría preferir usar un editor de texto ASCII, y
en este caso, las líneas se pueden ingresar sin números. Uno puede usar
HACER NUM y HACER UNNUM para numerar o no numerar líneas. Ver también el
documentación a continuación para el pseudocomando EDIT.
4.b. Convenciones de nombres
Los nombres de los comandos y las funciones no distinguen entre mayúsculas y minúsculas,
de modo que "Ejecutar" y "EJECUTAR" y "Ejecutar" sean equivalentes y "abs ()"
y "ABS ()" y "Abs ()" son equivalentes. SIN EMBARGO, variable
los nombres SON sensibles a mayúsculas y minúsculas en bwbASIC, de modo que "d $" y "D $"
son diferentes variables. Esto difiere de algunos BÁSICOS
implementaciones donde los nombres de las variables no distinguen entre mayúsculas y minúsculas.
Los nombres de las variables pueden utilizar cualquier carácter alfabético, el punto
y caracteres de subrayado y dígitos decimales (pero no en el
primera posición). Pueden terminar con '#' o '!' para
permitir nombres de tipo Microsoft, aunque la precisión es
irrelevante para bwBASIC.
4.c. Constantes numéricas
Las constantes numéricas pueden comenzar con un dígito 0-9 (decimal), con
el "& H" o "& h" (hexadecimal) o el "& o" o "& O" (octal).
Los números decimales pueden terminar con 'E', 'e', 'D' o 'd'
seguido de un número de exponente para denotar la notación exponencial.
Las constantes decimales también pueden terminar con '#' o '!'
para cumplir con terminadores de precisión estilo Microsoft, aunque
la precisión especificada será irrelevante para bwBASIC.
4.d. Ejecución de la línea de comandos
Se puede especificar un nombre de archivo en la línea de comando y será
CARGADO y EJECUTADO inmediatamente, de modo que la línea de comando
bwbasic prog.bas
cargará y ejecutará "prog.bas".
4.e. Almacenamiento de programas
Todos los programas se almacenan como archivos de texto ASCII.
4.f. Verdadero y falso
VERDADERO se define como -1 y FALSO se define como 0 en el valor predeterminado
distribución de bwBASIC. Estas definiciones se pueden cambiar por
los que compilan bwBASIC (ver archivo BWBASIC.H).
4.g. Asignaciones
La asignación debe realizarse a variables. Esto difiere de algunos
implementaciones de BASIC donde la asignación se puede hacer a un
función. Implicación: "INSTR (3, x $, y $) = z $" no
trabajar bajo bwBASIC.
4.h. Operadores y precedencia
bwBASIC reconoce a los siguientes operadores, con su nivel
de precedencia dada (1 = más alta):
^ 1 exponenciación
* 2 multiplicación
/ 2 división
3 división de enteros
+ 5 suma
- 5 resta
= 6 igualdad o asignación
MOD 4 módulo (resto) aritmética
<> 7 desigualdad
<8 menos que
> 9 mayor que
<= 10 menor o igual que
= <10 menor o igual que
> = 11 mayor o igual que
=> 11 mayor o igual que
NO 12 negación
Y 13 conjunción
O 14 disyunción
XOR 15 exclusivo o
Implicación IMP 16
Equivalencia EQV 17
4.h. Precisión numérica (NO)
bwBASIC utiliza números con un solo nivel de precisión. Si
el indicador NUMBER_DOUBLE se define como TRUE en bwbasic.h, el
la precisión implementada será la del tipo de datos C "doble";
de lo contrario (predeterminado) la precisión será la del "flotador" de C
escribe. En varios puntos hay comandos (o pseudo-
comandos) que parecen reconocer la precisión al estilo de Microsoft
distinciones, pero en su mayor parte son solo soluciones
alias para permitir la ejecución de programas al estilo de Microsoft.
5. REFERENCIA AMPLIADA PARA COMANDOS Y FUNCIONES
Las "dependencias" enumeradas en los siguientes materiales de referencia
hace referencia a los indicadores que deben establecerse en TRUE en bwbasic.h para
comando asociado o función a implementar. Estas banderas
son los siguientes:
(core) Comandos y funciones en cualquier implementación de
bwBASIC; estos son el núcleo ANSI Mínimo BÁSICO
Comandos INTERACTIVOS que apoyan la programación interactiva
entorno
COMMON_CMDS Comandos más allá de ANSI Mínimo BASIC que son comunes
a ANSI BASIC completo y Microsoft BASIC
COMMON_FUNCS Funciones más allá del núcleo ANSI Mínimo BASIC, pero
común a ANSI Full BASIC y estilo Microsoft
Variedades BÁSICAS
Comandos UNIX_CMDS que requieren un directorio estilo Unix y
rutinas ambientales no especificadas en C
STRUCT_CMDS Comandos relacionados con la programación estructurada; todos
de estos son parte del estándar ANSI BASIC completo
ANSI_FUNCS Funciones exclusivas de ANSI Full BASIC
Comandos MS_CMDS exclusivos de Microsoft BASIC
Funciones de MS_FUNCS exclusivas de Microsoft BASIC
------------------------------------------
Función: ABS (número)
Descripción: ABS devuelve el valor absoluto del argumento 'número'.
Dependencias: (núcleo)
------------------------------------------
Función: ASC (string $)
Descripción: ASC devuelve el código ASCII de la primera letra en
el argumento cadena $.
Dependencias: MS_FUNCS
------------------------------------------
Función: ATN (número)
Descripción: ATN devuelve el valor arcotangente del argumento 'número'
en radianes.
Dependencias: (núcleo)
------------------------------------------
Comando: CALL subrutina-nombre
Descripción: CALL llama a una subrutina con nombre (consulte SUB y END SUB).
Dependencias: STRUCT_CMDS
------------------------------------------
Comando: CASE ELSE | IF expresión-parcial | constante
Descripción: CASE introduce un elemento de una instrucción SELECT CASE
(ver SELECCIONAR CASO). CASE IF introduce un condicional
SELECT CASE elemento, y CASE ELSE introduce un
elemento SELECT CASE predeterminado.
Dependencias: STRUCT_CMDS
------------------------------------------
Comando: CADENA [FUSIÓN] nombre-archivo [, número-línea] [, TODO]
Descripción: CHAIN pasa el control a otro programa BÁSICO.
Se pasarán las variables declaradas COMÚN (qv)
al nuevo programa.
Dependencias: COMMON_CMDS
------------------------------------------
Comando: nombre de ruta CHDIR $
Descripción: CHDIR cambia el directorio actual al indicado
por el argumento nombre de ruta $.
Dependencias: UNIX_CMDS
------------------------------------------
Función: CHR $ (número)
Descripción: CHR $ devuelve una cadena de un carácter con el carácter
correspondiente al código ASCII indicado por argumento
'número'.
Dependencias: COMMON_FUNCS
------------------------------------------
Función: CINT (número)
Descripción: CINT devuelve el entero truncado para el argumento
'número'.
Dependencias: MS_FUNCS
------------------------------------------
Comando: BORRAR
Descripción: CLEAR establece todas las variables numéricas en 0 y todas
variables de cadena a nulo.
Dependencias: COMMON_CMDS
------------------------------------------
Comando: CERRAR [[#] número-archivo] ...
Descripción: CLOSE cierra el archivo indicado por número de archivo
(ver ABIERTO).
Dependencias: COMMON_CMDS
------------------------------------------
Comando: CLS
Descripción: CLS borra la pantalla de visualización (IBM y compatibles
solo a partir de la versión 2.10).
Dependencias: IMP_IQC e IMP_CMDLOC
------------------------------------------
Comando: CMDS
Descripción: CMDS es un comando de depuración que imprime una lista
de todos los comandos bwBASIC implementados.
Dependencias: DEBUG
------------------------------------------
Comando: variable COMÚN [, variable ...]
Descripción: COMMON designa las variables que se pasarán a un CHAINed
programa (ver CADENA).
Dependencias: COMMON_CMDS
------------------------------------------
Función: COS (número)
Descripción: COS devuelve el coseno del argumento 'número'
en radianes.
Dependencias: (núcleo)
------------------------------------------
Función: CSNG (número)
Descripción: CSNG es una pseudo-función que no tiene efecto bajo
bwBASIC. Replica un comando tipo Microsoft
eso convertiría el 'número' en precisión simple.
Dependencias: MS_FUNCS
------------------------------------------
Función: CVD (string $)
Descripción: CVD convierte la cadena de argumentos $ en un bwBASIC
número (la precisión es irrelevante en bwBASIC ya que
Los números bwBASIC tienen solo una precisión).
Notas específicas de implementación:
CVD (), CVI (), CVS (), MKI $ (), MKD $ (), MKS $ (): estas funciones
se implementan, pero dependen de a) los tamaños para enteros,
valores flotantes y dobles en sistemas particulares, yb) cómo
versiones particulares de C almacenan estos valores numéricos. los
La implicación es que los archivos de datos creados con estas funciones
en un microordenador basado en DOS puede que no se traduzca correctamente
por bwBASIC ejecutándose en una computadora basada en Unix. Del mismo modo, los datos
Los archivos creados por bwBASIC compilados por una versión de C pueden no ser
legible por bwBASIC compilado por otra versión de C (incluso bajo
el mismo sistema operativo). Así que ten cuidado con estos.
Dependencias: MS_FUNCS
------------------------------------------
Función: CVI (string $)
Descripción: CVI convierte la cadena de argumentos $ en un bwBASIC
número (la precisión es irrelevante en bwBASIC ya que
Los números bwBASIC tienen una sola precisión; ver también
la nota sobre CVD).
Dependencias: MS_FUNCS
------------------------------------------
Función: CVS (string $)
Descripción: CVI convierte la cadena de argumentos $ en un bwBASIC
número (la precisión es irrelevante en bwBASIC ya que
Los números bwBASIC tienen una sola precisión; ver también
la nota sobre CVD).
Dependencias: MS_FUNCS
------------------------------------------
Comando: Constante de DATOS [, constante] ...
Descripción: DATA almacena constantes numéricas y de cadena que se
accedido por READ (qv).
Dependencias: (núcleo)
------------------------------------------
Función: DATE $
Descripción: DATE $ devuelve la fecha actual basada en la
reloj interno como una cadena con el formato "AAAA-MM-DD".
Tal como se implementó en bwBASIC, DATE $ no se puede utilizar para
asignación (es decir, para establecer la fecha del sistema).
Nota: bwBASIC actualmente (v2.10) no permite la asignación
a una función.
Dependencias: COMMON_FUNCS
------------------------------------------
Comando: DEF FNname (arg ...)] = expresión
Descripción: DEF define una función escrita por el usuario. Esta función
corresponde a la implementación tipo Microsoft, aunque
en bwBASIC DEF es un equivalente funcional de FUNCTION.
Dependencias: (núcleo)
------------------------------------------
Comando: DEFDBL letra [-letra] (, letra [-letra]) ...
Descripción: DEFDBL declara variables con nombres de una sola letra
como variables numéricas (la precisión es irrelevante en
bwBÁSICO).
Dependencias: MS_CMDS
------------------------------------------
Comando: DEFINT letra [-letra] (, letra [-letra]) ...
Descripción: DEFINT declara variables con nombres de una sola letra
como variables numéricas (la precisión es irrelevante en
bwBÁSICO).
Dependencias: MS_CMDS
------------------------------------------
Comando: DEFSNG letra [-letra] (, letra [-letra]) ...
Descripción: DEFSNG declara variables con nombres de una sola letra
como variables numéricas (la precisión es irrelevante en
bwBÁSICO).
Dependencias: MS_CMDS
------------------------------------------
Comando: DEFSTR letra [-letra] (, letra [-letra]) ...
Descripción: DEFSTR declara variables con nombres de una sola letra
como variables de cadena.
Dependencias: MS_CMDS
------------------------------------------
Comando: BORRAR línea [-line]
Descripción: DELETE elimina las líneas de programa indicadas por el
argumento (s). Si desea utilizar DELETE para no
programas numerados, primero use DO NUM, luego DELETE,
luego HAGA UNNUM.
Dependencias: INTERACTIVO
------------------------------------------
Comando: variable DIM (elementos ...) [variable (elementos ...)] ...
Descripción: DIM especifica variables que tienen más de una
elemento en una sola dimensión, es decir, en matriz
variables.
Nota: Tal como se implementa en bwBASIC, DIM solo acepta
paréntesis como delimitadores de campos variables.
(Algunos BÁSICOS permiten el uso de corchetes).
Dependencias: (núcleo)
------------------------------------------
Comando: DO NUM | UNNUM
Descripción: DO NUM numera todas las líneas de un programa. El primero
A la línea se le asigna el número 10, y las líneas siguientes
están numerados consecutivamente en múltiplos de 10. HACER
UNNUM elimina todos los números de línea de un programa.
TENGA EN CUENTA que estas funciones no hacen nada para alinear
números, por ejemplo, siguiendo una instrucción GOSUB o GOTO;
estos comandos no se pueden utilizar como reemplazo de
RENUM (disponible en algunos sistemas, pero no en bwBASIC).
Con estos comandos, sin embargo, uno puede desarrollar
programas sin numerar ingresando nuevas líneas con números,
luego ejecutando DO UNNUM para eliminar los números de línea.
Junto con LOAD y SAVE (qv) se puede utilizar
bwBASIC como editor de texto primitivo.
Dependencias: INTERACTIVO
------------------------------------------
Comando: HACER [MIENTRAS expresión]
Descripción: DO implementa varias formas de bucles de programa.
HACER ... LOOP simplemente repite; la única salida es por
SALIDA; DO WHILE ... LOOP se repite mientras "expresión" es
verdadero (esto es equivalente al antiguo WHILE-WEND
loop, también implementado en bwBASIC); HACER ... BUCLE HASTA
se repite hasta que la expresión que sigue a UNTIL sea verdadera.
Dependencias: STRUCT_CMDS
------------------------------------------
Comando: EDITAR
Descripción: EDIT es un pseudocomando que llama al editor de texto.
especificado en la variable BWB.EDITOR $ para editar el
programa en la memoria. Después de la llamada al editor de texto,
el programa (editado) se vuelve a cargar en la memoria. El usuario
normalmente debe especificar una ruta y un nombre de archivo válidos en
BWB.EDITOR $ antes de este comando será útil.
Dependencias: COMMON_CMDS
------------------------------------------
Comando: ELSE
Descripción: ELSE introduce una condición predeterminada en un IF de varias líneas
.
Dependencias: STRUCT_CMDS
------------------------------------------
Comando: ELSEIF
Descripción: ELSEIF introduce una condición secundaria en un
instrucción IF de línea.
Dependencias: STRUCT_CMDS
------------------------------------------
Comando: END IF | FUNCION | SELECCIONAR | SUB
Descripción: END IF finaliza una instrucción IF de varias líneas. FUNCIÓN FINAL
finaliza una definición de función de varias líneas. FIN SELECCIONAR
finaliza una sentencia SELECT CASE. END SUB finaliza un
definición de subrutina de línea.
Dependencias: STRUCT_CMDS
------------------------------------------
Comando: ENVIRON variable-string $ = string $
Descripción: ENVIRON establece la variable de entorno identificada por
cadena-variable $ a cadena $.
Cabe señalar que esto difiere de la implementación
de ENVIRON en algunas versiones de BASIC, pero ENVIRON de bwBASIC
permite que las variables BÁSICAS se utilicen a ambos lados de los iguales
firmar. Tenga en cuenta que la función ENVIRON $ () es diferente de la
comando, y tenga en cuenta el hecho de que en algunos sistemas operativos
una variable de entorno establecida dentro de un programa no se pasará
a su shell padre.
Dependencias: UNIX_CMDS
------------------------------------------
Función: ENVIRON $ (variable-string $)
Descripción: ENVIRON $ devuelve la variable de entorno asociada con
el nombre cadena-variable $.
Dependencias: MS_FUNCS
------------------------------------------
Función: EOF (número de dispositivo)
Descripción: EOF devuelve VERDADERO (-1) si el dispositivo asociado con
El número de dispositivo está al final del archivo; de lo contrario,
devuelve FALSO (0).
Dependencias: MS_FUNCS
------------------------------------------
Comando: BORRAR variable [, variable] ...
Descripción: ERASE elimina las variables en matriz de un programa.
Dependencias: COMMON_CMDS
------------------------------------------
Función: ERL
Descripción: ERL devuelve el número de línea del error más reciente.
Dependencias: MS_FUNCS
------------------------------------------
Función: ERR
Descripción: ERR devuelve el número de error del error más reciente.
Tenga en cuenta que si se ha definido PROG_ERRORS cuando bwBASIC es
compilado, la variable ERR no se configurará correctamente al
errores. Solo funciona cuando se utilizan mensajes de error estándar.
Dependencias: MS_FUNCS
------------------------------------------
Comando: número de ERROR
Descripción: ERROR simula un error, es decir, muestra el mensaje
apropiado para ese error. Este comando es útil
por escrito ON ERROR GOSUB rutinas que pueden identificar
algunos errores por tratamiento especial y luego ERROR ERR
(es decir, manejo predeterminado) para todos los demás.
Dependencias: COMMON_CMDS
------------------------------------------
Comando: SALIR [PARA]
Descripción: EXIT por sí mismo sale de un bucle DO ... LOOP;
EXIT FOR sale de un bucle FOR ... NEXT.
Dependencias: STRUCT_CMDS
------------------------------------------
Función: EXP (número)
Descripción: EXP devuelve el valor exponencial de 'número'.
Dependencias: (núcleo)
------------------------------------------
Comando: CAMPO [#] número-dispositivo, número AS variable-cadena $ [, número AS variable-cadena $ ...]
Descripción: FIELD asigna espacio en un búfer de archivo aleatorio para el dispositivo
indicado por número de dispositivo, asignando 'número' bytes
y asignando los bytes en esta posición a la variable
variable de cadena $.
Dependencias: COMMON_CMDS
------------------------------------------
Comando: ARCHIVOS especificación de archivo $
Descripción: FILES es un pseudocomando que invoca el programa de directorio
especificado en la variable BWB.FILES $ con el argumento
especificaciónarchivo $. Normalmente, el usuario debe configurar esta variable
antes de que se puedan utilizar ARCHIVOS. Por ejemplo, para computadoras tipo PC,
BWB.FILES $ = "DIR"
funcionará, para máquinas Unix,
BWB.FILES $ = "ls -l"
etc.
Dependencias: COMMON_CMDS
------------------------------------------
Comando: FNCS
Descripción: CMDS es un comando de depuración que imprime una lista
de todas las funciones bwBASIC predefinidas.
Dependencias: DEBUG
------------------------------------------
Comando: FUNCIÓN
Descripción: FUNCTION introduce una definición de función, normalmente
terminando en FUNCIÓN FINAL. En bwBASIC, FUNCTION y
DEF son equivalentes de trabajo, por lo que se pueden usar
con definiciones de función de una sola línea o con múltiples
definiciones de línea terminadas por END FUNCTION.
Dependencias: STRUCT_CMDS
------------------------------------------
Comando: PARA contador = inicio PARA finalizar [incremento de PASO]
Descripción: FOR inicia un bucle FOR-NEXT con la variable
'contador' inicialmente establecido en 'inicio' y aumentando
en pasos de 'incremento' (el valor predeterminado es 1) hasta 'contador'
es igual a 'acabado'.
Dependencias: (núcleo)
------------------------------------------
Comando: OBTENER [#] número-dispositivo [, número-registro]
Descripción: GET lee el siguiente registro de un archivo de acceso aleatorio
o dispositivo en el búfer asociado con ese archivo.
Si se especifica el número de registro, el comando GET lee el
registro especificado.
Dependencias: COMMON_CMDS
------------------------------------------
Comando: línea GOSUB | etiqueta
Descripción: GOSUB inicia una llamada de subrutina a la línea (o etiqueta)
especificado. La subrutina debe terminar con RETURN.
Dependencias: (núcleo), pero STRUCT_CMDS para etiquetas
------------------------------------------
Comando: GOTO línea | etiqueta
Descripción: GOTO bifurca la ejecución del programa a la línea especificada
(o etiqueta).
Dependencias: (núcleo), pero STRUCT_CMDS para etiquetas
------------------------------------------
Función: HEX $ (número)
Descripción: HEX $ devuelve una cadena que da el hexadecimal (base 16)
valor para el 'número'.
Dependencias: MS_FUNCS
------------------------------------------
Comando: IF expresión THEN [instrucción [instrucción ELSE]]
Descripción: IF evalúa 'expresión' y realiza el ENTONCES
declaración si es verdadera o (opcionalmente) la
Instrucción ELSE si es FALSE. Si STRUCT_CMDS
está configurado en TRUE, bwBASIC permite IF multilínea
declaraciones con casos ELSE y ELSEIF, terminando
con END IF.
Dependencias: (núcleo), STRUCT_CMDS para declaraciones IF de varias líneas
------------------------------------------
Función: INKEY $
Descripción: INKEY $ lee el estado del teclado y un solo
pulsación de tecla, si está disponible. Si una pulsación de tecla no está disponible,
luego INKEY $ devuelve inmediatamente una cadena nula ("").
Actualmente (v2.10) implementado solo en bwx_iqc.c.
Dependencias: IMP_IQC e IMP_CMDLOC
------------------------------------------
Comando: INPUT [# número-dispositivo] | [;] ["cadena de solicitud";] lista de variables
Descripción: INPUT permite la entrada desde el terminal o un dispositivo
especificado por número de dispositivo. Si es terminal, el mensaje "
string "es la salida y la entrada se asigna al
variables apropiadas especificadas.
bwBASIC no admite la función opcional de INPUT
que suprime el retorno de carro y el salto de línea al final
de la entrada. Esto se debe a que C por sí solo no proporciona ninguna
medios de entrada que no sean cadenas terminadas en CR-LF.
Dependencias: (núcleo)
------------------------------------------
Función: INSTR ([posición de inicio,] cadena de búsqueda $, cadena de patrón $)
Descripción: INSTR devuelve la posición en la que el patrón de cadena $
ocurre en $ de búsqueda de cadena, comenzando en la posición de inicio.
Tal como se implementó en bwBASIC, INSTR no se puede utilizar para
asignaciones
Nota: bwBASIC actualmente (v2.10) no permite la asignación
a una función.
Dependencias: MS_FUNCS
------------------------------------------
Función: INT (número)
Descripción: INT devuelve el entero más grande menor o igual que
el argumento 'número'. TENGA EN CUENTA que esto no es un "truncado"
función entera, para la cual vea CINT.
Dependencias: (núcleo)
------------------------------------------
Comando: KILL nombre-archivo $
Descripción: KILL elimina el archivo especificado por nombre de archivo $.
Dependencias: UNIX_CMDS
------------------------------------------
Función: IZQUIERDA $ (cadena $, número de espacios)
Descripción: LEFT $ devuelve una subcadena una cadena $ con número de espacios
desde la izquierda (principio) de la cadena). Como implementado
bajo bwBASIC, no se puede utilizar para asignación.
Dependencias: MS_FUNCS
------------------------------------------
Función: LEN (string $)
Descripción: LEN devuelve la longitud en bytes de la cadena $.
Dependencias: COMMON_FUNCS
------------------------------------------
Comando: LET variable = expresión
Descripción: LET asigna el valor de 'expresión' a la variable.
Tal como se implementa actualmente, bwBASIC admite LET implícito
declaraciones (por ejemplo, "X = 4.5678" al comienzo de
una línea o segmento de línea, pero no admite la asignación
a múltiples variables (por ejemplo, "x, y, z = 3.141596").
Dependencias: (núcleo)
------------------------------------------
Comando: ENTRADA DE LÍNEA [[#] número-dispositivo,] ["cadena de solicitud";] variable-cadena $
Descripción: LINE INPUT lee la línea completa desde el teclado o un archivo
o dispositivo en variable de cadena $. Si la entrada es del
teclado (stdin), luego se imprimirá la "cadena de solicitud"
primero. A diferencia de INPUT, LINE INPUT lee una línea completa,
sin detenerse para elementos de datos delimitados por comas.
Dependencias: COMMON_CMDS
------------------------------------------
Comando: LISTA línea [-line]
Descripción: LIST enumera las líneas de programa como se especifica en su argumento.
Dependencias: INTERACTIVO
------------------------------------------
Comando: LOAD nombre-archivo
Descripción: LOAD carga un programa ASCII BASIC en la memoria.
Dependencias: INTERACTIVO
------------------------------------------
Función: LOC (número de dispositivo)
Descripción: LOC devuelve el siguiente registro que GET o PUT declaraciones
utilizará.
Dependencias: MS_FUNCS
------------------------------------------
Comando: LOCATE línea, columna
Descripción: LOCATE se dirige a través de la corriente a una línea especificada y
columna. Actualmente (v2.10) implementado solo en bwx_iqc.c.
Dependencias: IMP_IQC e IMP_CMDLOC
------------------------------------------
Función: LOF (número de dispositivo)
Descripción: LOF devuelve la longitud de un archivo (especificado por número de dispositivo)
en bytes.
Dependencias: MS_FUNCS
------------------------------------------
Función: LOG (número)
Descripción: LOG devuelve el logaritmo natural del argumento 'número'.
Dependencias: (núcleo)
------------------------------------------
Comando: LOOP [HASTA expresión]
Descripción: LOOP termina un bucle de programa: consulte DO.
Dependencias: STRUCT_CMDS
------------------------------------------
Comando: LSET cadena-variable $ = expresión
Descripción: LSET transfiere datos de 'expresión' a la izquierda
lado de una variable de cadena o campo de búfer de acceso aleatorio.
Dependencias: COMMON_CMDS
------------------------------------------
Comando: FUSIONAR nombre de archivo
Descripción: MERGE agrega líneas de programa de 'nombre de archivo' al programa
en memoria. A diferencia de LOAD, no borra el programa.
actualmente en la memoria.
Dependencias: COMMON_CMDS
------------------------------------------
Función: MID $ (cadena $, posición-inicio-en-cadena [, número-de-espacios])
Descripción: MID $ devuelve una subcadena de la cadena $ que comienza en
start-position-in-string y continuando por
bytes de número de espacios.
Dependencias: MS_FUNCS
------------------------------------------
Comando: nombre de ruta MKDIR $
Descripción: MKDIR crea una nueva ruta de directorio según lo especificado por
nombre de ruta $.
Dependencias: UNIX_CMDS
------------------------------------------
Función: MKD $ (número)
Descripción: MKD $, MKI $ y MKS $ son todos equivalentes en bwBASIC.
Convierten el valor numérico 'número' en una cadena
que se puede almacenar en una forma más comprimida en un archivo
(especialmente para acceso aleatorio a archivos). Dado que bwBASIC hace
no reconocen las diferencias en la precisión, estos comandos
son efectivamente equivalentes.
Dependencias: MS_FUNCS
------------------------------------------
Función: MKI $ (número)
Descripción: Equivalente a MKD $ (qv)
Dependencias: MS_FUNCS
------------------------------------------
Función: MKS $ (número)
Descripción: Equivalente a MKD $ (qv).
Dependencias: MS_FUNCS
------------------------------------------
Comando: NOMBRE nombre-archivo-antiguo COMO nombre-archivo-nuevo
Descripción: NAME cambia el nombre de un archivo existente (nombre de archivo antiguo) como
nombre-nuevo-archivo.
Dependencias: UNIX_CMDS
------------------------------------------
Comando: NUEVO
Descripción: NUEVO borra el programa en la memoria y borra todos los
variables.
Dependencias: INTERACTIVO
------------------------------------------
Comando: SIGUIENTE [contra-variable]
Descripción: NEXT viene al final de un bucle FOR-NEXT; ver por.
Dependencias: (núcleo)
------------------------------------------
Función: OCT $ (número)
Descripción: OCT $ devuelve una cadena que da el octal (base 8)
representación de 'número'.
Dependencias: MS_FUNCS
------------------------------------------
Comando: ON variable GOTO | GOSUB línea [, línea, línea, ...]
Descripción: ON bifurca (GOTO) o llama a una subrutina
(GOSUB) basado en el valor redondeado de la variable;
si es 1, se llama a la primera línea, si es 2, a la segunda
se llama a la línea, etc.
Dependencias: (núcleo)
------------------------------------------
Comando: ON ERROR GOSUB línea | etiqueta
Descripción: ON ERROR configura una subrutina de manejo de errores. Ver
también ERROR.
Dependencias: COMMON_CMDS, STRUCT_CMDS para etiquetas
------------------------------------------
Comando: OPEN "O" | "I" | "R", [#] número de dispositivo, nombre de archivo [, longitud de registro]
nombre-archivo PARA ENTRADA | SALIDA | ANEXO COMO [#] número-dispositivo [LEN = longitud-registro]
Descripción: OPEN asigna memoria de acceso aleatorio para acceder a un disco
archivo u otro dispositivo. Tenga en cuenta que dos formas bastante diferentes
de la declaración OPEN son compatibles. En la primera forma,
"O" (tenga en cuenta que estas letras deben ir entre comillas
marcas) denota salida secuencial, "I" denota secuencial
entrada y "R" denota entrada y salida de acceso aleatorio.
Una vez ABIERTO, se puede realizar cualquier cantidad de operaciones
en un dispositivo (consulte WRITE #, INPUT #, PRINT #, etc.).
Dependencias: COMMON_CMDS
------------------------------------------
Comando: OPCIÓN número BASE
Descripción: OPTION BASE establece el valor más bajo para los subíndices de matriz,
ya sea 0 o 1.
Dependencias: (núcleo)
------------------------------------------
Función: POS
Descripción: POS devuelve la posición actual del cursor en la línea.
Dependencias: COMMON_FUNCS
------------------------------------------
Comando: PRINT [# número-dispositivo,] [USANDO cadena-formato $;] expresiones ...
Descripción: PRINT envía texto a la pantalla oa un archivo o dispositivo
especificado por número de dispositivo. En la implementación actual
de bwBASIC, las expresiones a imprimir deben estar separadas por
la coma (salida con pestañas), el punto y coma (inmediato
salida secuencial) o el signo más (secuencial inmediata
salida por concatenación de cadenas). Expresiones separadas
por espacios en blanco o pestañas no son compatibles. Si se especifica USING,
Es posible que aparezcan varias marcas de formato en el formato.
cuerda:
! imprime el primer carácter de una cadena
\ imprime 2 + x caracteres de una cadena, donde x =
el número de espacios entre las barras invertidas
& campo de cadena de longitud variable
# representa un solo dígito en formato de salida para
un número
. punto decimal en un número
+ signo de un número (generará + o -)
- menos después de un número
** rellene los espacios iniciales con asteriscos
$$ muestra el signo de dólar delante de un número
^^ número de salida en formato exponencial
_ salida del siguiente carácter literalmente
Tal como se implementa actualmente, el formato exponencial
será el utilizado por el compilador de C.
Dependencias: (núcleo), COMMON_FUNCS para USAR
------------------------------------------
Comando: PUT [#] número-dispositivo [, número-registro]
Descripción: PUT genera el siguiente registro disponible o el registro
especificado por número de registro al archivo o dispositivo
denotado por número de dispositivo.
Dependencias: COMMON_CMDS
------------------------------------------
Comando: SALIR
Descripción: QUIT es un sinónimo de SYSTEM; con INTERACTIVO
entorno, sale del programa al
sistema operativo (o el programa de llamada).
Dependencias: INTERACTIVO
------------------------------------------
Comando: RANDOMIZE número
Descripción: RANDOMIZE siembra el generador de números aleatorios (ver RND).
En bwBASIC, se puede utilizar la función TIMER (qv)
para proporcionar una semilla de 'número' para el número aleatorio
generador
Dependencias: (núcleo)
------------------------------------------
Comando: LEER variable [, variable] ...
Descripción: READ lee los valores de las declaraciones de DATOS y los asigna
valores a las variables nombradas. Tipos de variables en un READ
declaración debe coincidir con los tipos de datos en declaraciones de DATOS
a medida que se producen. Consulte también DATOS y RESTAURAR.
Dependencias: (núcleo)
------------------------------------------
Comando: cadena REM
Descripción: REM permite incluir comentarios en un programa. Como
implementado actualmente, toda la línea siguiendo
REM es ignorado por el intérprete (por lo tanto, incluso si
MULTISEG_LINES está configurado, una línea REM no podrá
para encontrar un delimitador de segmento (":") seguido de otro
segmento de línea con comando. bwBASIC actualmente no
Implementar el uso al estilo de Microsoft de la cotización única.
marcar para indicar comentarios.
Dependencias: (núcleo)
------------------------------------------
Comando: RESTAURAR línea
Descripción: RESTORE restablece los contadores de línea y posición para DATA
y READ declaraciones en la parte superior del archivo de programa o
al principio de la línea especificada. (Actualmente este
debe ser un número de línea.)
Dependencias: (núcleo)
------------------------------------------
Comando: VOLVER
Descripción: RETURN concluye una subrutina llamada por GOSUB.
Dependencias: (núcleo)
------------------------------------------
Función: DERECHA $ (cadena $, número de espacios)
Descripción: RIGHT $ devuelve una subcadena una cadena $ con número de espacios
desde la derecha (final) de la cadena). Como implementado
bajo bwBASIC, no se puede utilizar para asignación.
Dependencias: MS_FUNCS
------------------------------------------
Comando: nombre de ruta RMDIR
Descripción: RMDIR elimina la ruta de directorio indicada por el nombre de ruta.
Dependencias: UNIX_CMDS
------------------------------------------
Función: RND (número)
Descripción: RND devuelve un número pseudoaleatorio. El valor del 'número'
bwBASIC lo ignora si se proporciona. El RANDOMIZE
El comando (qv) reinicia el generador de números aleatorios.
Dependencias: (núcleo)
------------------------------------------
Comando: RSET cadena-variable $ = expresión
Descripción: RSET transfiere datos de 'expresión' a la derecha
lado de una variable de cadena o campo de búfer de acceso aleatorio.
Dependencias: COMMON_CMDS
------------------------------------------
Comando: EJECUTAR [línea] [nombre-archivo $]
Descripción: RUN ejecuta el programa en memoria. Si un nombre de archivo $ es
suministrado, el archivo especificado se carga en la memoria
y ejecutado. Si se proporciona un número de línea, la ejecución
comienza en esa línea.
Dependencias: INTERACTIVO
------------------------------------------
Comando: GUARDAR nombre de archivo $
Descripción: SAVE guarda el programa en la memoria con el nombre de archivo $. bwBASIC
solo guarda archivos en formato ASCII.
Dependencias: INTERACTIVO
------------------------------------------
Comando: expresión SELECT CASE
Descripción: SELECT CASE introduce una selección condicional de varias líneas
declaración. La expresión dada como argumento para SELECT
CASE será evaluado por las siguientes declaraciones CASE. los
La sentencia SELECT CASE concluye con END SELECT
.
Tal como se implementa actualmente, se pueden seguir las declaraciones CASE
por valores de cadena, pero en este caso solo comparaciones simples
(iguales, no iguales) se pueden realizar.
Dependencias: STRUCT_CMDS
------------------------------------------
Función: SGN (número)
Descripción: SGN devuelve el signo del argumento 'número', +1
para números positivos, 0 para 0 y -1 para números negativos.
Dependencias: (núcleo)
------------------------------------------
Función: SIN (número)
Descripción: SIN devuelve el seno del argumento 'número'
en radianes.
Dependencias: (núcleo)
------------------------------------------
Función: ESPACIO $ (número)
Descripción: SPACE $ devuelve una cadena de espacios en blanco 'número'
bytes de longitud.
Dependencias: MS_FUNCS
------------------------------------------
Función: SPC (número)
Descripción: SPC devuelve una cadena de espacios en blanco 'número'
bytes de longitud.
Dependencias: MS_FUNCS
------------------------------------------
Función: SQR (número)
Descripción: SQR devuelve la raíz cuadrada del argumento 'número'.
Dependencias: (núcleo)
------------------------------------------
Comando: DETENER
Descripción: STOP interrumpe la ejecución del programa. Como se implementó en
bwBASIC, STOP emite una señal SIGINT.
Dependencias: (núcleo)
------------------------------------------
Función: STR $ (número)
Descripción: STR $ devuelve una cadena con el decimal (base 10)
representación del argumento 'número'.
Dependencias: COMMON_FUNCS
------------------------------------------
Función: STRING $ (número, valor ascii | cadena $)
Descripción: STRING $ devuelve una cadena 'número' bytes de longitud que consta de
del primer carácter de la cadena $ o del carácter
respondiendo al valor ASCII valor ascii.
Dependencias: MS_FUNCS
------------------------------------------
Comando: SUB nombre-subrutina
Descripción: SUB introduce una subrutina multilínea con nombre. los
La subrutina es llamada por una sentencia CALL y concluye
con una sentencia END SUB.
Dependencias: STRUCT_CMDS
------------------------------------------
Comando: SWAP variable, variable
Descripción: SWAP intercambia los valores de dos variables. Las dos variables
debe ser del mismo tipo (numérico o de cadena).
Dependencias: COMMON_CMDS
------------------------------------------
Comando: SISTEMA
Descripción: SYSTEM sale de bwBASIC al programa de llamada o
(más generalmente) el sistema operativo.
Dependencias: INTERACTIVO
------------------------------------------
Función: TAB (número)
Descripción: TAB genera espacios hasta la columna indicada por
'número' ha sido alcanzado.
Dependencias: (núcleo)
------------------------------------------
Función: TAN (número)
Descripción: TAN devuelve la tangente del argumento 'número'
en radianes.
Dependencias: (núcleo)
------------------------------------------
Función: TIME $
Descripción: TIME $ devuelve la hora actual en función de la
reloj interno como una cadena con el formato "HH-MM-SS".
Tal como se implementó en bwBASIC, TIME $ no se puede utilizar para
asignación (es decir, para establecer la hora del sistema).
Nota: bwBASIC actualmente (v2.10) no permite la asignación
a una función.
Dependencias: COMMON_FUNCS
------------------------------------------
Función: TIMER
Descripción: TIMER devuelve la hora en el reloj del sistema en segundos.
transcurrido desde la medianoche.
Dependencias: MS_FUNCS
------------------------------------------
Comando: TROFF
Descripción: TROFF gira de la instalación de rastreo; ver TRON.
Dependencias: COMMON_CMDS
------------------------------------------
Comando: TRON
Descripción: TRON enciende la función de rastreo. Esta instalación imprimirá
cada número de línea entre corchetes ya que el programa es
ejecutado. Esto es útil para depurar programas con
Línea de números. Para depurar un programa sin numerar con
TRON, primero llame a DO NUM, pero recuerde llamar a DO UNNUM
antes de guardar el programa más tarde.
Dependencias: COMMON_CMDS
------------------------------------------
Función: VAL (string $)
Descripción: VAL devuelve el valor numérico de la cadena $.
Dependencias: COMMON_FUNCS
------------------------------------------
Comando: VARS
Descripción: VARS es un comando de depuración que imprime una lista de
todas las variables definidas que tienen alcance global.
Dependencias: DEBUG
------------------------------------------
Comando: WEND
Descripción: WEND concluye un bucle WHILE-WEND; ver MIENTRAS.
Dependencias: COMMON_CMDS
------------------------------------------
Comando: WHILE expresión
Descripción: WHILE inicia un bucle WHILE-WEND. El bucle termina con
WEND, y la ejecución se reitera a través del bucle como
siempre que la 'expresión' sea VERDADERA (-1).
Dependencias: COMMON_CMDS
------------------------------------------
Comando: WIDTH [# device-number,] número
Descripción: WIDTH establece la salida de la pantalla o del dispositivo en 'número'
columnas. número de dispositivo especifica el dispositivo
o archivo de salida.
Dependencias: COMMON_CMDS
------------------------------------------
Comando: ESCRIBIR [# número-dispositivo,] elemento [, elemento] ....
Descripción: WRITE envía variables a la pantalla oa un archivo
o dispositivo especificado por número de dispositivo. Comas
se insertan entre la salida de expresiones y cadenas
están entre comillas.
Dependencias: COMMON_CMDS
------------------------------------------
6. VARIABLES PREDEFINIDAS
BWB.EDITOR $
BWB.FILES $
BWB.PROMPT $
IMPLEMENTACIÓN BWB $
Los comandos EDITAR y ARCHIVOS son pseudocomandos que se lanzan
programas de shell nombrados en las variables BWB.EDITOR $ y BWB.FILES $,
respectivamente. Los valores predeterminados para estas variables pueden
cambiarse en bwbasic.h (DEF_EDITOR y DEF_FILES), o
el usuario puede cambiarlo sobre la marcha. Una idea podría ser
inicialice estas variables en "profile.bas" para
implementaciones; por ejemplo, BWB.FILES $ podría definirse como
"ls -l" en sistemas Unix o "dir" en sistemas DOS.
La variable preestablecida BWB.PROMPT $ se puede utilizar para configurar el indicador
cadena para bwBASIC. Nuevamente, se sugiere que un usuario
El mensaje seleccionado se puede configurar en un "profile.bas" para ser
inicializado cada vez que se inicia bwBASIC. Tenga en cuenta que especial
Se pueden agregar caracteres a la cadena de solicitud, por ejemplo,
BWB.PROMPT $ = "Aceptar" + CHR $ (10)
dará un mensaje "Ok" seguido de un salto de línea.
La variable predeterminada BWB.IMPLEMENTATION $ devolverá "TTY" para
la implementación de bwx_tty y devolverá "IQC" para el
IBM PC o compatibles con la implementación de QuickC (bwx_iqc).
Esto puede resultar útil para determinar qué comandos y funciones
(específicamente CLS, LOCATE e INKEY $) pueden estar disponibles.
7. COMANDOS Y FUNCIONES NO IMPLEMENTADOS, y PROGRAMA DE DESARROLLO
Hay algunos elementos que no se implementaron y que han estado tanto tiempo
una parte de los BASIC estándar que su ausencia parecerá sorprendente.
En cada caso, sin embargo, su implementación requeriría operaciones
funciones específicas del sistema de ting o funciones específicas del terminal
que no se puede proporcionar universalmente. Algunos ejemplos específicos:
CLOAD Se basa en convenciones CP / M o MSDOS para binarios.
archivos ejecutables.
CONT Ver RESUME a continuación (¿ignorancia del programador?).
DEF USR Se basa en convenciones CP / M o MSDOS para binarios
archivos ejecutables.
FRE () La capacidad de informar la cantidad de memoria libre
restante es específico del sistema debido a patrones variables
de asignación de memoria y acceso; en consecuencia este
La capacidad no está presente en ANSI o versiones anteriores.
de C y esta función no está disponible en bwBASIC.
INPUT $ () C por sí solo no puede leer el teclado sin eco
entrada, y puede leer la entrada del teclado sólo después de una
Se ha introducido el retorno de carro.
INP Llamadas a puertos de hardware, como lenguaje de máquina
rutinas, son altamente específicas del sistema y no pueden
implementarse solo en C.
LLIST Consulte LPRINT a continuación.
LPOS Consulte LPRINT a continuación.
LPRINT y LLIST, etc., requieren acceso a un dispositivo de impresión,
y esto varía de un sistema a otro. Usuarios
podría intentar ABRIR el dispositivo de la impresora por su cuenta
sistema operativo (por ejemplo, "/ dev / lp" en sistemas Unix,
o "PRN" en DOS) y vea si se puede imprimir
de bwBASIC de esta manera.
NULL En este caso, estoy convencido de que NULL ya no es
necesario, ya que muy pocas impresoras ahora requieren NULL
al final de las líneas.
OUT Vea INP arriba (llamadas a puertos de hardware).
PEEK () PEEK y POKE habilitaron BÁSICOS anteriores para abordar
ubicaciones de memoria particulares. Aunque bwBASIC
posiblemente podría implementar este comando (POKE) y
esta función (PEEK ()), la limitación sería
muy limitado por los diferentes sistemas para
acceso a la memoria en diferentes sistemas.
POKE ver PEEK () arriba.
RENUM Dado que se pueden introducir líneas no numeradas y
ejecutado bajo bwBASIC, no sería
posible implementar una rutina RENUM.
En su lugar, bwBASIC utiliza DO NUM y DO UNNUM.
RESUMEN ¿Es esto posible bajo C? Si es así, yo
simplemente no he podido resolverlo todavía.
Mea culpa (pero no máxima).
USR Consulte CALL y DEF USR arriba (lenguaje de máquina
subrutinas).
VARPTR Vea PEEK y POKE arriba.
ESPERE Vea INP y OUT arriba.
Hay otros comandos, funciones y detalles de implementación.
en las que estoy trabajando y que están en la lista de la agenda para el futuro
versiones de bwBASIC. Esta agenda incluye:
PARACT, es decir, la capacidad de ejecutar ACCIONES PARALELAS. Esta
se describe en ANSI BASIC, aunque no lo he visto
implementado antes. Ofrecerá un tosco, no
forma preventiva de multitarea dentro del alcance
de un programa BÁSICO. Los programadores notarán los puntos en los que
ya hay ganchos para PARACT en bwBASIC.
Los equipos de tipo PC XMEM deben poder utilizar
memoria. Si pudiéramos usar memoria extendida para el programa
líneas, variables y definiciones de funciones, podríamos
escribir programas mucho más largos. Esto implicaría,
sin embargo, una reescritura bastante seria del programa
utilizar identificadores de memoria para estas funciones de almacenamiento
en lugar de punteros de memoria directos.
Windows La adición de identificadores de memoria además de
ejecución no preventiva de líneas de programa (en una
forma cruda, ya presente) lo hará posible
para desarrollar implementaciones para Windows y tal vez
para otras interfaces gráficas de usuario. Pero que forma
debería tomar esto? Tengo en mente actualmente un BÁSICO
que se ejecutaría en segundo plano, apareciendo solo
como un icono en el espacio de la GUI, con editores emergentes
y ventanas de salida. Así, el lenguaje interpretado
serviría para un propósito similar a 'cron' (una tarea
planificador) en sistemas Unix. Puede que tengas algunos
reflexiones que me ayudarían en esto.
Gráficos Aquí nos enfrentamos a diferencias bastante críticas en diferentes
estilos e implementaciones de gráficos, por ejemplo, entre
GWBASIC, ANSI BASIC, VisualBASIC, etc. Pero es
posible que los comandos y funciones de gráficos
ser agregado. Todos estos serían específicos de la implementación.
El estándar ANSI para BASIC completo no especifica qué particular
deben implementarse comandos o funciones, y de hecho el estándar
es muy robusto. Quizás ninguna implementación de BASIC nunca
incluir todos los elementos, pero algunos comandos y funciones ANSI que
quedan sin implementar son:
ACCESO
ÁNGULO
Reservada
ARITMÉTICA
FORMACIÓN
PREGÚNTELES
Bstr
BVAL
HACER TECHO
CÉLULAS
CLIP
INTERCALAR
CONECTARSE
COSH
FECHA
DEBUG
DECIMAL
DECLARAR
Grados
DISPOSITIVO
DESCONECTAR
DISPLAY
DOT
DIBUJAR
ERASE
EVENT
EXCEPCIÓN
GRAFICO
MANIPULADOR
IMAGEN
VENTAJAS
LCASO
LÍNEAS
LOG10
LOG2
MAT
MIX
MULTIPUNTO
SALIR EN
SALIDA
PARACTO
IMAGEN
PIXEL
TRAMA
CLAVE
RADIANS
RECIBE
VOLVER A NUMERAR
VOLVER A ESCRIBIR
GIRAR
REDONDA
APROVECHAR
ENVIAR
BASICO
SINH
TANH
TIMEOUT
TRACE
TRANSFORMA
TRUNCAR
SUBIR
UCASO
MIRADOR
ESPERE
MIRADOR
ANCHO DE ZONA
8. LA HISTORIA DEL BYWATER BASIC
Este programa fue iniciado originalmente en 1982 por mi abuela, la Sra.
Verda Spell de Beaumont, TX. Ella estaba escribiendo el programa usando
un compilador ANSI C en una computadora Osborne I CP / M y aunque mi
abuelo (Lockwood Spell) había comprado una PC IBM con 256k de
RAM mi abuela no lo usaría, parafraseando a George Herbert
en el sentido de que "El que no puede en un programa de 64k, no puede en 512k".
Ella había usado Microsoft BASIC y aunque no tenía nada en contra
dijo repetidamente que no entendía por qué Digital
La investigación no "demandó a Microsoft" por la versión 1.0
de MSDOS y, por lo tanto, creo que esperaba socavar la de Microsoft
todo el mercado y eventualmente construir un nuevo imperio de software en
el extremo norte de Beaumont. Sus esfuerzos de programación fueron cortados
trágicamente corta cuando fue arrojada de un Beaumont a Port
Tren de cercanías Arthur en el verano de 1986. Encontré la fuente
código a bwBASIC en un disquete de Osborne de densidad única en su tejido
bolsa y, finalmente, logró que todo se copiara a una PC
disquete. Lo he revisado un poco antes de este lanzamiento. usted
Sin embargo, debería saber que yo mismo soy un historiador, no un programador.
9. COMUNICACIONES:
email: [email protected]
October 11, 1993 BWBASICO(1)
Use renum en línea usando los servicios de onworks.net
