Este é o comando bwbasic que pode ser executado no provedor de hospedagem gratuita OnWorks usando uma de nossas várias estações de trabalho online gratuitas, como Ubuntu Online, Fedora Online, emulador online do Windows ou emulador online do MAC OS
PROGRAMA:
NOME
bwbasic - interpretador / shell Bywater BASIC
Bywater BASIC Interpreter / Shell, versão 2.10
---------------------------------------------
Direitos autorais (c) 1993, Ted A. Campbell
para bwBASIC versão 2.10, 11 de outubro de 1993
CONTEÚDO:
1. DESCRIÇÃO
2. TERMOS DE USO
3. LISTA DE REFERÊNCIA RÁPIDA DE COMANDOS E FUNÇÕES
4. NOTAS GERAIS SOBRE O USO
5. REFERÊNCIA AMPLIADA PARA COMANDOS E FUNÇÕES
6. VARIÁVEIS PREDEFINIDAS
7. FUNÇÕES E COMANDOS NÃO IMPLEMENTADOS
e AGENDA DE DESENVOLVIMENTO
8. A HISTÓRIA DO BÁSICO DE ÁGUAS
9. COMUNICAÇÕES
O autor deseja expressar seus agradecimentos ao Sr. David MacKenzie,
que auxiliou no desenvolvimento de instalação e configuração do Unix
para esta versão.
1. DESCRIÇÃO
O Bywater BASIC Interpreter (bwBASIC) implementa um grande
superconjunto do Padrão ANSI para BASIC mínimo (X3.60-1978)
e um subconjunto significativo do padrão ANSI para Full BASIC
(X3.113-1987) em C. Ele também oferece recursos de programação de shell
como uma extensão do BASIC. bwBASIC busca ser tão portátil
quanto possível.
bwBASIC pode ser configurado para emular recursos, comandos e
funções disponíveis em diferentes tipos de intérpretes BASIC;
consulte o arquivo INSTALL para obter mais informações sobre a instalação.
O intérprete é bastante lento. Sempre que confrontado com uma escolha
entre clareza conceitual e velocidade, tenho escolhido consistentemente
o antigo. O intérprete é o design mais simples disponível,
e não utiliza nenhum sistema de código intermediário, o que agilizaria
consideravelmente seu funcionamento. Como está, cada linha é interpretada
novamente conforme o intérprete chega a ele.
bwBASIC implementa um recurso não disponível no BASIC anterior
intérpretes: um comando shell pode ser inserido interativamente no
prompt bwBASIC, e o interpretador irá executá-lo sob um
shell de comando. Por exemplo, o comando "dir * .bas" pode ser
inserido em bwBASIC (no DOS, ou "ls -l * .bas" no UNIX) e
ele será executado a partir da linha de comando do sistema operacional.
Os comandos shell também podem ser dados em linhas numeradas em um bwBASIC
programa, de modo que bwBASIC pode ser usado como uma programação de shell
língua. Implementação do bwBASIC do RMDIR, CHDIR, MKDIR,
Comandos e funções NAME, KILL, ENVIRON e ENVIRON $ ()
oferecem mais recursos de processamento de shell.
2. TERMOS DE USO:
Esta versão do Bywater BASIC é lançada sob os termos do
GNU General Public License (GPL), que é distribuída com este
software no arquivo "COPYING". A GPL especifica os termos
sob o qual os usuários podem copiar e usar o software nesta distribuição.
Uma licença separada está disponível para distribuição comercial,
para informações sobre as quais você deve entrar em contato com o autor.
3. LISTA DE REFERÊNCIA RÁPIDA DE COMANDOS E FUNÇÕES
Esteja ciente de que muitos desses comandos e funções não serão
disponível a menos que você tenha definido certas sinalizações nos arquivos de cabeçalho
(consulte a seção de referência expandida abaixo para dependências).
ABS (número)
ASC (string $)
ATN (número)
Nome da sub-rotina CALL
CASE ELSE | Expressão parcial IF | constante
CHAIN [MERGE] nome do arquivo [, número da linha] [, TODOS]
Nome do caminho CHDIR
CHR $ (número)
CINT (número)
LIMPAR
FECHAR [[#] número do arquivo] ...
CLS
Variável COMUM [, variável ...]
COS (número)
CSNG (número)
CVD (string $)
CVI (string $)
CVS (string $)
Constante de DADOS [, constante] ...
DATA $
DEF FNname (arg ...)] = expressão
Carta DEFDBL [-bola] (, carta [-bola]) ...
DEFINT carta [-bola] (, carta [-bola]) ...
DEFSNG letter [-letter] (, letter [-letter]) ...
DEFSTR carta [-bola] (, carta [-bola]) ...
DELETE linha [-line]
Variável DIM (elementos ...) [variável (elementos ...)] ...
DO NUM | UNNUM
DO [expressão WHILE]
EDITAR
ELSE
ELSEIF
END IF | FUNÇÃO | SELECT | SUB
String de variável ENVIRON = string
ENVIRON $ (string variável)
EOF (número do dispositivo)
Variável ERASE [, variável] ...
ERL
ERR
Número de ERROR
EXP (número)
FIELD [#] número do dispositivo, número AS variável da string [, número AS da variável da string ...]
FILES filespec $
FUNÇÃO
FOR contador = começar PARA terminar [incremento STEP]
OBTER [#] número do dispositivo [, número do registro]
Linha GOSUB | rótulo
Linha GOTO | rótulo
HEX $ (número)
Expressão IF THEN [instrução [instrução ELSE]]
INKEY $
INPUT [# device-number] | [;] ["prompt string";] lista de variáveis
INSTR ([posição inicial,] string pesquisada $, padrão de string $)
INT (número)
KILL nome do arquivo
LEFT $ (string $, número de espaços)
LEN (string $)
Variável LET = expressão
LINE INPUT [[#] número do dispositivo,] ["prompt string";] string-variável $
LIST linha [-line]
CARREGAR nome do arquivo
LOC (número do dispositivo)
LOCALIZAR linha, coluna
LOF (número do dispositivo)
LOG (número)
LOOP [expressão UNTIL]
LSET string-variável $ = expressão
MERGE nome do arquivo
MID $ (string $, posição inicial na string [, número de espaços])
MKD $ (número)
Nome do caminho MKDIR
MKI $ (número)
MKS $ (número)
NAME nome-do-arquivo-antigo AS nome-do-arquivo-novo
NOVAS
PRÓXIMO [contador]
OCT $ (número)
Variável ON GOTO | GOSUB linha [, linha, linha, ...]
NA linha GOSUB ERRO
ABRIR "O" | "I" | "R", [#] número do dispositivo, nome do arquivo [, comprimento do registro]
nome do arquivo PARA ENTRADA | SAÍDA | ANEXAR COMO [#] número do dispositivo [LEN = comprimento do registro]
Número da OPÇÃO BASE
POS
IMPRIMIR [# número do dispositivo,] [USANDO string de formato $;] expressões ...
PUT [#] número do dispositivo [, número do registro]
SAIR
RANDOMIZE número
READ variável [, variável] ...
String REM
RESTORE linha
RETORNO
RIGHT $ (string $, número de espaços)
Nome do caminho RMDIR
RND (número)
Variável de string RSET $ = expressão
RUN [linha] [nome do arquivo]
SALVAR nome do arquivo
SELECIONE a expressão CASE
SGN (número)
SIN (número)
SPACE $ (número)
SPC (número)
SQR (número)
STOP
STR $ (número)
STRING $ (número, valor ascii | string $)
SUB subrotina-nome
Variável SWAP, variável
SISTEMA
TAB (número)
TAN (número)
TIME $
CRONÔMETRO
TROF
TRON
VAL (string $)
FIM
Expressão WHILE
WIDTH [# número do dispositivo,] número
ESCREVER [# número do dispositivo,] elemento [, elemento] ....
4. NOTAS GERAIS SOBRE O USO:
4.a. Ambiente Interativo
Um ambiente interativo é fornecido se o sinalizador INTERACTIVE
é definido como TRUE em bwbasic.h, de modo que uma linha com um
o número da linha pode ser inserido no prompt bwBASIC e será
adicionado ao programa na memória.
Os números de linha não são estritamente obrigatórios, mas são úteis se o
ambiente interativo é usado para programação. Por mais tempo
entrada do programa, pode-se preferir usar um editor de texto ASCII, e
neste caso, as linhas podem ser inseridas sem números. Pode-se usar
DO NUM e DO UNNUM para numerar ou não numerar as linhas. Veja também o
documentação abaixo para o pseudo-comando EDIT.
4.b. Convenções de Nomenclatura
Nomes de comandos e nomes de funções não diferenciam maiúsculas de minúsculas,
de modo que "Run" e "RUN" e "run" sejam equivalentes e "abs ()"
e "ABS ()" e "Abs ()" são equivalentes. NO ENTANTO, variável
nomes SÃO sensíveis a maiúsculas e minúsculas em bwbASIC, de modo que "d $" e "D $"
são variáveis diferentes. Isso difere de alguns BASIC
implementações em que os nomes das variáveis não diferenciam maiúsculas de minúsculas.
Nomes de variáveis podem usar quaisquer caracteres alfabéticos, o período
e caracteres de sublinhado e dígitos decimais (mas não no
primeira posição). Eles podem ser encerrados com '#' ou '!' para
permitir nomes de tipo Microsoft, embora a precisão seja
irrelevante para bwBASIC.
4.c. Constantes Numéricas
As constantes numéricas podem começar com um dígito 0-9 (decimal), com
o "& H" ou "& h" (hexadecimal) ou o "& o" ou "& O" (octal).
Os números decimais podem terminar com 'E', 'e', 'D' ou 'd'
seguido por um número expoente para denotar a notação exponencial.
As constantes decimais também podem ser encerradas com '#' ou '!'
para estar em conformidade com terminadores de precisão estilo Microsoft, embora
a precisão especificada será irrelevante para bwBASIC.
4.d. Execução de linha de comando
Um nome de arquivo pode ser especificado na linha de comando e será
CARREGADO e EXECUTADO imediatamente, para que a linha de comando
bwbasic prog.bas
irá carregar e executar "prog.bas".
4.e. Armazenamento de programa
Todos os programas são armazenados como arquivos de texto ASCII.
4.f. Verdadeiro e falso
TRUE é definido como -1 e FALSE é definido como 0 no padrão
distribuição de bwBASIC. Essas definições podem ser alteradas por
aqueles compilando bwBASIC (veja o arquivo BWBASIC.H).
4.g. atribuições
A atribuição deve ser feita a variáveis. Isso difere de alguns
implementações de BASIC onde a atribuição pode ser feita a um
função. Implicação: "INSTR (3, x $, y $) = z $" não
trabalhar sob bwBASIC.
4.h. Operadores e precedência
bwBASIC reconhece os seguintes operadores, com seu nível
de precedência fornecida (1 = mais alto):
^ 1 exponenciação
* 2 multiplicação
/ 2 divisão
3 divisões inteiras
+ 5 adição
- 5 subtração
= 6 igualdade ou atribuição
Módulo MOD 4 (resto) aritmética
<> 7 desigualdade
<8 menos que
> 9 maior que
<= 10 menor ou igual a
= <10 menor ou igual a
> = 11 maior ou igual a
=> 11 maior ou igual a
NÃO 12 negação
E 13 conjunção
OR 14 disjunção
XOR 15 exclusivo ou
Implicação 16
Equivalência EQV 17
4.h. Precisão Numérica (NÃO)
bwBASIC utiliza números com apenas um nível de precisão. Se
o sinalizador NUMBER_DOUBLE é definido como TRUE em bwbasic.h, o
a precisão implementada será a do tipo de dados C "duplo";
caso contrário (padrão) a precisão será a do C "flutuante"
modelo. Em vários pontos, existem comandos (ou pseudo-
comandos) que parecem reconhecer a precisão ao estilo da Microsoft
distinções, mas na maioria das vezes são apenas soluções
apelidos para permitir a execução de programas no estilo da Microsoft.
5. REFERÊNCIA AMPLIADA PARA COMANDOS E FUNÇÕES
As "Dependências" listadas nos seguintes materiais de referência
refere-se a sinalizadores que devem ser definidos como TRUE em bwbasic.h para o
comando ou função associada a ser implementada. Essas bandeiras
são como segue:
(núcleo) Comandos e funções em qualquer implementação de
bwBASIC; estes são o núcleo ANSI mínimo BASIC
Comandos INTERATIVOS que apoiam a programação interativa
meio Ambiente
Comandos COMMON_CMDS além do ANSI mínimo BASIC que são comuns
para Full ANSI BASIC e Microsoft BASICs
COMMON_FUNCS Funções além do núcleo ANSI Minimal BASIC, mas
comum para ANSI Full BASIC e estilo Microsoft
Variedades BÁSICAS
Comandos UNIX_CMDS que requerem diretório de estilo Unix e
rotinas de ambiente não especificadas em C
STRUCT_CMDS Comandos relacionados à programação estruturada; tudo
destes são parte do padrão Full ANSI BASIC
ANSI_FUNCS Funções exclusivas para ANSI Full BASIC
Comandos MS_CMDS exclusivos para Microsoft BASICs
MS_FUNCS Funções exclusivas para Microsoft BASICs
------------------------------------------
Função: ABS (número)
Descrição: ABS retorna o valor absoluto do argumento 'número'.
Dependências: (núcleo)
------------------------------------------
Função: ASC (string $)
Descrição: ASC retorna o código ASCII para a primeira letra em
o argumento string $.
Dependências: MS_FUNCS
------------------------------------------
Função: ATN (número)
Descrição: ATN retorna o valor do arco tangente do argumento 'número'
em radianos.
Dependências: (núcleo)
------------------------------------------
Comando: CALL sub-rotina-nome
Descrição: CALL chama uma sub-rotina nomeada (consulte SUB e END SUB).
Dependências: STRUCT_CMDS
------------------------------------------
Comando: CASE ELSE | Expressão parcial IF | constante
Descrição: CASE apresenta um elemento de uma instrução SELECT CASE
(veja SELECIONE CASO). CASE IF introduz um condicional
Elemento SELECT CASE e CASE ELSE apresenta um
elemento padrão SELECT CASE.
Dependências: STRUCT_CMDS
------------------------------------------
Comando: CHAIN [MERGE] nome do arquivo [, número da linha] [, ALL]
Descrição: CHAIN passa o controle para outro programa BASIC.
Variáveis declaradas COMUM (qv) serão passadas
para o novo programa.
Dependências: COMMON_CMDS
------------------------------------------
Comando: CHDIR pathname $
Descrição: CHDIR muda o diretório atual para aquele indicado
pelo argumento pathname $.
Dependências: UNIX_CMDS
------------------------------------------
Função: CHR $ (número)
Descrição: CHR $ retorna uma string de um caractere com o caractere
correspondente ao código ASCII indicado pelo argumento
'número'.
Dependências: COMMON_FUNCS
------------------------------------------
Função: CINT (número)
Descrição: CINT retorna o número inteiro truncado para o argumento
'número'.
Dependências: MS_FUNCS
------------------------------------------
Comando: CLEAR
Descrição: CLEAR define todas as variáveis numéricas para 0, e todas
variáveis de string para nulo.
Dependências: COMMON_CMDS
------------------------------------------
Comando: CLOSE [[#] file-number] ...
Descrição: CLOSE fecha o arquivo indicado pelo número do arquivo
(veja ABRIR).
Dependências: COMMON_CMDS
------------------------------------------
Comando: CLS
Descrição: CLS limpa a tela de exibição (IBM e compatíveis
apenas a partir da versão 2.10).
Dependências: IMP_IQC e IMP_CMDLOC
------------------------------------------
Comando: CMDS
Descrição: CMDS é um comando de depuração que imprime uma lista
de todos os comandos bwBASIC implementados.
Dependências: DEBUG
------------------------------------------
Comando: variável COMUM [, variável ...]
Descrição: COMMON designa variáveis a serem passadas para um CHAINed
programa (veja CHAIN).
Dependências: COMMON_CMDS
------------------------------------------
Função: COS (número)
Descrição: COS retorna o cosseno do argumento 'número'
em radianos.
Dependências: (núcleo)
------------------------------------------
Função: CSNG (número)
Descrição: CSNG é uma pseudo-função que não tem efeito sob
bwBASIC. Ele replica um comando do tipo Microsoft
isso converteria o 'número' em precisão simples.
Dependências: MS_FUNCS
------------------------------------------
Função: CVD (string $)
Descrição: CVD converte a string de argumento $ em um bwBASIC
número (a precisão é irrelevante em bwBASIC desde
Os números bwBASIC têm apenas uma precisão).
Notas específicas de implementação:
CVD (), CVI (), CVS (), MKI $ (), MKD $ (), MKS $ (): Estas funções
são implementados, mas dependem de a) os tamanhos do inteiro,
flutuação e valores duplos em sistemas específicos, eb) como
versões particulares de C armazenam esses valores numéricos. o
implicação é que os arquivos de dados criados usando essas funções
em um microcomputador baseado em DOS pode não ser traduzido corretamente
por bwBASIC rodando em um computador baseado em Unix. Da mesma forma, dados
arquivos criados por bwBASIC compilados por uma versão de C não podem ser
legível por bwBASIC compilado por outra versão de C (mesmo em
o mesmo sistema operacional). Portanto, tome cuidado com eles.
Dependências: MS_FUNCS
------------------------------------------
Função: CVI (string $)
Descrição: CVI converte a string de argumento $ em um bwBASIC
número (a precisão é irrelevante em bwBASIC desde
Os números bwBASIC têm apenas uma precisão; Veja também
a nota sobre CVD).
Dependências: MS_FUNCS
------------------------------------------
Função: CVS (string $)
Descrição: CVI converte a string de argumento $ em um bwBASIC
número (a precisão é irrelevante em bwBASIC desde
Os números bwBASIC têm apenas uma precisão; Veja também
a nota sobre CVD).
Dependências: MS_FUNCS
------------------------------------------
Comando: constante DATA [, constante] ...
Descrição: DATA armazena constantes numéricas e de string para serem
acessado por READ (qv).
Dependências: (núcleo)
------------------------------------------
Função: DATE $
Descrição: DATE $ retorna a data atual com base no computador
relógio interno como uma string no formato "AAAA-MM-DD".
Conforme implementado em bwBASIC, DATE $ não pode ser usado para
atribuição (ou seja, para definir a data do sistema).
Nota: bwBASIC atualmente (v2.10) não permite atribuição
para uma função.
Dependências: COMMON_FUNCS
------------------------------------------
Comando: DEF FNname (arg ...)] = expressão
Descrição: DEF define uma função escrita pelo usuário. Esta função
corresponde à implementação do tipo Microsoft, embora
em bwBASIC DEF é um equivalente funcional de FUNCTION.
Dependências: (núcleo)
------------------------------------------
Comando: DEFDBL letter [-letter] (, letter [-letter]) ...
Descrição: DEFDBL declara variáveis com nomes de uma única letra
como variáveis numéricas (a precisão é irrelevante em
bwBASIC).
Dependências: MS_CMDS
------------------------------------------
Comando: DEFINT letra [- letra] (, letra [- letra]) ...
Descrição: DEFINT declara variáveis com nomes de uma única letra
como variáveis numéricas (a precisão é irrelevante em
bwBASIC).
Dependências: MS_CMDS
------------------------------------------
Comando: DEFSNG letter [-letter] (, letter [-letter]) ...
Descrição: DEFSNG declara variáveis com nomes de uma única letra
como variáveis numéricas (a precisão é irrelevante em
bwBASIC).
Dependências: MS_CMDS
------------------------------------------
Comando: DEFSTR letter [-letter] (, letter [-letter]) ...
Descrição: DEFSTR declara variáveis com nomes de uma única letra
como variáveis de string.
Dependências: MS_CMDS
------------------------------------------
Comando: DELETE linha [-line]
Descrição: DELETE exclui as linhas do programa indicadas pelo
argumento (s). Se você quiser usar DELETE para
programas numerados, primeiro use DO NUM, depois DELETE,
em seguida, FAÇA UNNUM.
Dependências: INTERACTIVE
------------------------------------------
Comando: variável DIM (elementos ...) [variável (elementos ...)] ...
Descrição: DIM especifica variáveis que têm mais de um
elemento em uma única dimensão, ou seja, em matriz
variáveis.
Nota: Conforme implementado em bwBASIC, DIM aceita apenas
parênteses como delimitadores para campos variáveis.
(Alguns BASICs permitem o uso de colchetes.)
Dependências: (núcleo)
------------------------------------------
Comando: DO NUM | UNNUM
Descrição: DO NUM numera todas as linhas de um programa. O primeiro
linha recebe o número 10 e as linhas subsequentes
são numerados consecutivamente em múltiplos de 10. DO
UNNUM remove todos os números de linha de um programa.
NOTE que essas funções não fazem nada para alinhar
números, por exemplo, seguindo uma instrução GOSUB ou GOTO;
esses comandos não podem ser usados como substitutos para
RENUM (disponível em alguns sistemas, mas não em bwBASIC).
Com esses comandos, no entanto, pode-se desenvolver
programas não numerados, inserindo novas linhas com números,
em seguida, executando DO UNNUM para remover os números das linhas.
Juntamente com LOAD e SAVE (qv), pode-se usar
bwBASIC como um editor de texto primitivo.
Dependências: INTERACTIVE
------------------------------------------
Comando: DO [expressão WHILE]
Descrição: DO implementa várias formas de loops de programa.
DO ... LOOP simplesmente faz um loop; a única saída é por
SAÍDA; DO WHILE ... LOOP faz loops enquanto "expressão" é
verdadeiro (isto é equivalente ao antigo WHILE-WEND
loop, também implementado em bwBASIC); FAÇA ... LOOP ATÉ
faz um loop até que a expressão após UNTIL seja verdadeira.
Dependências: STRUCT_CMDS
------------------------------------------
Comando: EDIT
Descrição: EDIT é um pseudo-comando que chama o editor de texto
especificado na variável BWB.EDITOR $ para editar o
programa na memória. Após a ligação para o editor de texto,
o programa (editado) é recarregado na memória. O usuário
normalmente deve especificar um caminho e nome de arquivo válidos em
BWB.EDITOR $ antes deste comando será útil.
Dependências: COMMON_CMDS
------------------------------------------
Comando: ELSE
Descrição: ELSE introduz uma condição padrão em um IF multilinhas
declaração.
Dependências: STRUCT_CMDS
------------------------------------------
Comando: ELSEIF
Descrição: ELSEIF introduz uma condição secundária em uma
declaração de linha IF.
Dependências: STRUCT_CMDS
------------------------------------------
Comando: END IF | FUNÇÃO | SELECT | SUB
Descrição: END IF termina uma instrução IF de várias linhas. FUNÇÃO FINAL
termina uma definição de função multilinhas. END SELECT
termina uma instrução SELECT CASE. END SUB termina um multi-
definição de sub-rotina de linha.
Dependências: STRUCT_CMDS
------------------------------------------
Comando: ENVIRON variável-string $ = string $
Descrição: ENVIRON define a variável de ambiente identificada por
variável-string $ para string $.
Pode-se notar que isso difere da implementação
do ENVIRON em algumas versões do BASIC, mas o ENVIRON do bwBASIC
permite que variáveis BASIC sejam usadas em ambos os lados dos iguais
sinal. Observe que a função ENVIRON $ () é diferente da
comando e esteja ciente do fato de que em alguns sistemas operacionais
uma variável de ambiente definida dentro de um programa não será passada
para seu shell pai.
Dependências: UNIX_CMDS
------------------------------------------
Função: ENVIRON $ (string $)
Descrição: ENVIRON $ retorna a variável de ambiente associada a
o nome variável-string $.
Dependências: MS_FUNCS
------------------------------------------
Função: EOF (número do dispositivo)
Descrição: EOF retorna TRUE (-1) se o dispositivo associado a
o número do dispositivo está no final do arquivo, caso contrário,
retorna FALSE (0).
Dependências: MS_FUNCS
------------------------------------------
Comando: ERASE variável [, variável] ...
Descrição: ERASE elimina variáveis em array de um programa.
Dependências: COMMON_CMDS
------------------------------------------
Função: ERL
Descrição: ERL retorna o número da linha do erro mais recente.
Dependências: MS_FUNCS
------------------------------------------
Função: ERR
Descrição: ERR retorna o número do erro mais recente.
Observe que se PROG_ERRORS foi definido quando bwBASIC é
compilado, a variável ERR não será definida corretamente no
erros. Ele só funciona quando mensagens de erro padrão são usadas.
Dependências: MS_FUNCS
------------------------------------------
Comando: ERROR number
Descrição: ERROR simula um erro, ou seja, exibe a mensagem
apropriado para esse erro. Este comando é útil
por escrito, rotinas ON ERROR GOSUB que podem identificar
alguns erros para tratamento especial e, em seguida, ERROR ERR
(ou seja, tratamento padrão) para todos os outros.
Dependências: COMMON_CMDS
------------------------------------------
Comando: SAIR [PARA]
Descrição: EXIT por si só sai de um loop DO ... LOOP;
EXIT FOR sai de um loop FOR ... NEXT.
Dependências: STRUCT_CMDS
------------------------------------------
Função: EXP (número)
Descrição: EXP retorna o valor exponencial de 'número'.
Dependências: (núcleo)
------------------------------------------
Comando: FIELD [#] número do dispositivo, número AS variável da string $ [, número AS variável da string $ ...]
Descrição: FIELD aloca espaço em um buffer de arquivo aleatório para o dispositivo
indicado pelo número do dispositivo, alocando 'número' bytes
e atribuir os bytes nesta posição à variável
variável de string $.
Dependências: COMMON_CMDS
------------------------------------------
Comando: FILES filespec $
Descrição: FILES é um pseudocomando que invoca o programa de diretório
especificado na variável BWB.FILES $ com o argumento
filespec $. Normalmente, o usuário deve definir esta variável
antes que FILES possa ser usado. Por exemplo, para computadores do tipo PC,
BWB.FILES $ = "DIR"
funcionará, para máquinas Unix,
BWB.FILES $ = "ls -l"
etc.
Dependências: COMMON_CMDS
------------------------------------------
Comando: FNCS
Descrição: CMDS é um comando de depuração que imprime uma lista
de todas as funções bwBASIC predefinidas.
Dependências: DEBUG
------------------------------------------
Comando: FUNCTION
Descrição: FUNCTION apresenta uma definição de função, normalmente
terminando com END FUNCTION. Em bwBASIC, FUNCTION e
DEF são equivalentes de trabalho, então qualquer um pode ser usado
com definições de função de linha única ou com
definições de linha terminadas por END FUNCTION.
Dependências: STRUCT_CMDS
------------------------------------------
Comando: FOR contador = começar PARA terminar [incremento STEP]
Descrição: FOR inicia um loop FOR-NEXT com a variável
'contador' inicialmente definido para 'iniciar' e incrementar
em etapas de 'incremento' (o padrão é 1) até 'contador'
é igual a 'terminar'.
Dependências: (núcleo)
------------------------------------------
Comando: GET [#] número do dispositivo [, número do registro]
Descrição: GET lê o próximo registro de um arquivo de acesso aleatório
ou dispositivo no buffer associado a esse arquivo.
Se o número do registro for especificado, o comando GET lê o
registro especificado.
Dependências: COMMON_CMDS
------------------------------------------
Comando: linha GOSUB | rótulo
Descrição: GOSUB inicia uma chamada de sub-rotina para a linha (ou rótulo)
Especificadas. A sub-rotina deve terminar com RETURN.
Dependências: (core), mas STRUCT_CMDS para rótulos
------------------------------------------
Comando: linha GOTO | rótulo
Descrição: GOTO desvia a execução do programa para a linha especificada
(ou rótulo).
Dependências: (core), mas STRUCT_CMDS para rótulos
------------------------------------------
Função: HEX $ (número)
Descrição: HEX $ retorna uma string que fornece o hexadecimal (base 16)
valor para o 'número'.
Dependências: MS_FUNCS
------------------------------------------
Comando: IF expressão THEN [instrução [instrução ELSE]]
Descrição: IF avalia a 'expressão' e realiza o THEN
declaração se for verdadeira ou (opcionalmente) o
Instrução ELSE se for FALSE. Se STRUCT_CMDS
é definido como TRUE, bwBASIC permite IF multilinhas
declarações com casos ELSE e ELSEIF, terminando
com END IF.
Dependências: (núcleo), STRUCT_CMDS para instruções IF de várias linhas
------------------------------------------
Função: INKEY $
Descrição: INKEY $ lê o status do teclado e um único
pressionamento de tecla, se disponível. Se um pressionamento de tecla não estiver disponível,
então INKEY $ retorna imediatamente uma string nula ("").
Atualmente (v2.10) implementado em bwx_iqc.c apenas.
Dependências: IMP_IQC e IMP_CMDLOC
------------------------------------------
Comando: INPUT [# device-number] | [;] ["prompt string";] lista de variáveis
Descrição: INPUT permite a entrada do terminal ou de um dispositivo
especificado pelo número do dispositivo. Se for terminal, o "prompt
string "é a saída e a entrada é atribuída ao
variáveis apropriadas especificadas.
bwBASIC não suporta o recurso opcional de INPUT
que suprime o retorno de carro e avanço de linha no final
da entrada. Isso ocorre porque C sozinho não fornece qualquer
meios de entrada diferentes das cadeias terminadas em CR-LF.
Dependências: (núcleo)
------------------------------------------
Função: INSTR ([posição inicial,] string-pesquisada $, string-padrão $)
Descrição: INSTR retorna a posição em que o padrão de string $
ocorre em $ pesquisado por string, começando na posição inicial.
Conforme implementado em bwBASIC, INSTR não pode ser usado para
atribuições.
Nota: bwBASIC atualmente (v2.10) não permite atribuição
para uma função.
Dependências: MS_FUNCS
------------------------------------------
Função: INT (número)
Descrição: INT retorna o maior número inteiro menor ou igual a
o argumento 'número'. NOTE que este não é um "truncado"
função inteira, para a qual consulte CINT.
Dependências: (núcleo)
------------------------------------------
Comando: KILL file-name $
Descrição: KILL exclui o arquivo especificado pelo nome de arquivo $.
Dependências: UNIX_CMDS
------------------------------------------
Função: LEFT $ (string $, número de espaços)
Descrição: LEFT $ retorna uma substring de uma string $ com número de espaços
da esquerda (início) da string). Conforme implementado
sob bwBASIC, ele não pode ser usado para atribuição.
Dependências: MS_FUNCS
------------------------------------------
Função: LEN (string $)
Descrição: LEN retorna o comprimento em bytes da string $.
Dependências: COMMON_FUNCS
------------------------------------------
Comando: variável LET = expressão
Descrição: LET atribui o valor de 'expressão' à variável.
Conforme implementado atualmente, bwBASIC suporta LET implícito
declarações (por exemplo, "X = 4.5678" no início de
uma linha ou segmento de linha, mas não suporta atribuição
para várias variáveis (por exemplo, "x, y, z = 3.141596").
Dependências: (núcleo)
------------------------------------------
Comando: LINE INPUT [[#] número do dispositivo,] ["prompt string";] string-variável $
Descrição: LINE INPUT lê a linha inteira do teclado ou de um arquivo
ou dispositivo na variável de string $. Se a entrada for do
teclado (stdin), então "linha de prompt" será impressa
primeiro. Ao contrário de INPUT, LINE INPUT lê uma linha inteira,
não parando para itens de dados delimitados por vírgulas.
Dependências: COMMON_CMDS
------------------------------------------
Comando: LIST linha [-line]
Descrição: LIST lista as linhas do programa conforme especificado em seu argumento.
Dependências: INTERACTIVE
------------------------------------------
Comando: LOAD file-name
Descrição: LOAD carrega um programa ASCII BASIC na memória.
Dependências: INTERACTIVE
------------------------------------------
Função: LOC (número do dispositivo)
Descrição: LOC retorna o próximo registro que contém as instruções GET ou PUT
usará.
Dependências: MS_FUNCS
------------------------------------------
Comando: LOCATE linha, coluna
Descrição: LOCATE endereça o curor a uma linha especificada e
coluna. Atualmente (v2.10) implementado em bwx_iqc.c apenas.
Dependências: IMP_IQC e IMP_CMDLOC
------------------------------------------
Função: LOF (número do dispositivo)
Descrição: LOF retorna o comprimento de um arquivo (especificado pelo número do dispositivo)
em bytes.
Dependências: MS_FUNCS
------------------------------------------
Função: LOG (número)
Descrição: LOG retorna o logaritmo natural do argumento 'número'.
Dependências: (núcleo)
------------------------------------------
Comando: LOOP [expressão UNTIL]
Descrição: LOOP termina um loop de programa: consulte DO.
Dependências: STRUCT_CMDS
------------------------------------------
Comando: LSET string-variable $ = expression
Descrição: LSET transfere dados da 'expressão' para a mão esquerda
lado de uma variável de string ou campo de buffer de acesso aleatório.
Dependências: COMMON_CMDS
------------------------------------------
Comando: MERGE nome do arquivo
Descrição: MERGE adiciona linhas de programa de 'nome de arquivo' ao programa
em memória. Ao contrário de LOAD, ele não limpa o programa
atualmente na memória.
Dependências: COMMON_CMDS
------------------------------------------
Função: MID $ (string $, posição inicial na string [, número de espaços])
Descrição: MID $ retorna uma substring da string $ começando em
posição inicial na string e continuando para
bytes de número de espaços.
Dependências: MS_FUNCS
------------------------------------------
Comando: MKDIR pathname $
Descrição: MKDIR cria um novo caminho de diretório conforme especificado por
pathname $.
Dependências: UNIX_CMDS
------------------------------------------
Função: MKD $ (número)
Descrição: MKD $, MKI $ e MKS $ são todos equivalentes em bwBASIC.
Eles convertem o valor numérico 'número' em uma string
que pode ser armazenado de uma forma mais compactada em um arquivo
(especialmente para acesso aleatório a arquivos). Uma vez que bwBASIC faz
não reconhecem diferenças de precisão, esses comandos
são efetivamente equivalentes.
Dependências: MS_FUNCS
------------------------------------------
Função: MKI $ (número)
Descrição: Equivalente a MKD $ (qv)
Dependências: MS_FUNCS
------------------------------------------
Função: MKS $ (número)
Descrição: Equivalente a MKD $ (qv).
Dependências: MS_FUNCS
------------------------------------------
Comando: NAME nome do arquivo antigo AS nome do arquivo novo
Descrição: NAME renomeia um arquivo existente (nome de arquivo antigo) como
nome-do-novo-arquivo.
Dependências: UNIX_CMDS
------------------------------------------
Comando: NOVO
Descrição: NEW exclui o programa da memória e limpa todos
variáveis.
Dependências: INTERACTIVE
------------------------------------------
Comando: NEXT [contra-variável]
Descrição: NEXT vem no final de um loop FOR-NEXT; veja PARA.
Dependências: (núcleo)
------------------------------------------
Função: OCT $ (número)
Descrição: OCT $ retorna uma string que fornece o octal (base 8)
representação de 'número'.
Dependências: MS_FUNCS
------------------------------------------
Comando: ON variável GOTO | GOSUB linha [, linha, linha, ...]
Descrição: ON qualquer branch (GOTO) ou chama uma sub-rotina
(GOSUB) com base no valor arredondado da variável;
se for 1, a primeira linha é chamada, se 2, a segunda
linha é chamada, etc.
Dependências: (núcleo)
------------------------------------------
Comando: ON ERROR GOSUB line | label
Descrição: ON ERROR configura uma sub-rotina de tratamento de erros. Ver
também ERROR.
Dependências: COMMON_CMDS, STRUCT_CMDS para rótulos
------------------------------------------
Comando: OPEN "O" | "I" | "R", [#] número do dispositivo, nome do arquivo [, comprimento do registro]
nome do arquivo PARA ENTRADA | SAÍDA | ANEXAR COMO [#] número do dispositivo [LEN = comprimento do registro]
Descrição: OPEN aloca memória de acesso aleatório para acesso a um disco
arquivo ou outro dispositivo. Observe que duas formas bastante diferentes
da instrução OPEN são suportados. Na primeira forma,
"O" (observe que essas letras devem ser colocadas entre aspas
marcas) denota saída sequencial, "I" denota sequencial
entrada e "R" denota entrada e saída de acesso aleatório.
Uma vez ABERTO, qualquer número de operações pode ser executado
em um dispositivo (consulte WRITE #, INPUT #, PRINT #, etc.).
Dependências: COMMON_CMDS
------------------------------------------
Comando: Número da OPÇÃO BASE
Descrição: OPTION BASE define o valor mais baixo para os subscritos da matriz,
0 ou 1.
Dependências: (núcleo)
------------------------------------------
Função: POS
Descrição: POS retorna a posição atual do cursor na linha.
Dependências: COMMON_FUNCS
------------------------------------------
Comando: PRINT [# device-number,] [USING format-string $;] expressões ...
Descrição: PRINT envia texto para a tela ou para um arquivo ou dispositivo
especificado pelo número do dispositivo. Na implementação atual
de bwBASIC, as expressões a serem impressas devem ser separadas por
a vírgula (saída tabulada), o ponto e vírgula (imediato
saída sequencial) ou o sinal de mais (sequencial imediato
saída por concatenação de string). Expressões separadas
por espaços em branco ou guias não são suportados. Se USING for especificado,
várias marcas de formatação podem aparecer no formato
corda:
! imprime o primeiro caractere de uma string
\ imprime 2 + x caracteres de uma string, onde x =
o número de espaços entre as barras invertidas
& campo de string de comprimento variável
# representa um único dígito no formato de saída para
um número
. ponto decimal em um número
+ sinal de um número (resultará em + ou -)
- seguido de menos após um número
** preencha os espaços iniciais com asteriscos
$$ output cifrão na frente de um número
^^ número de saída em formato exponencial
_ saída do próximo caractere literalmente
Conforme implementado atualmente, o formato exponencial
será aquele usado pelo compilador C.
Dependências: (núcleo), COMMON_FUNCS para USING
------------------------------------------
Comando: PUT [#] número do dispositivo [, número do registro]
Descrição: PUT gera o próximo registro disponível ou o registro
especificado por número de registro para o arquivo ou dispositivo
denotado pelo número do dispositivo.
Dependências: COMMON_CMDS
------------------------------------------
Comando: QUIT
Descrição: QUIT é sinônimo de SYSTEM; com INTERACTIVE
ambiente, ele sai do programa para o
sistema operacional (ou o programa de chamada).
Dependências: INTERACTIVE
------------------------------------------
Comando: RANDOMIZE número
Descrição: RANDOMIZE semeia o gerador de números aleatórios (consulte RND).
Em bwBASIC, a função TIMER (qv) pode ser usada
para fornecer uma semente de 'número' para o número aleatório
gerador.
Dependências: (núcleo)
------------------------------------------
Comando: READ variável [, variável] ...
Descrição: READ lê valores de instruções DATA e atribui-os
valores para as variáveis nomeadas. Tipos de variáveis em um READ
declaração deve corresponder aos tipos de dados em declarações DATA
à medida que ocorrem. Veja também DATA e RESTORE.
Dependências: (núcleo)
------------------------------------------
Comando: string REM
Descrição: REM permite que comentários sejam incluídos em um programa. Como
atualmente implementado, toda a linha seguindo
REM é ignorado pelo intérprete (assim, mesmo se
MULTISEG_LINES está definido, uma linha REM não será capaz
para encontrar um delimitador de segmento (":") seguido por outro
segmento de linha com comando. bwBASIC atualmente não
implementar o uso de aspas simples no estilo Microsoft
marque para denotar observações.
Dependências: (núcleo)
------------------------------------------
Comando: linha RESTORE
Descrição: RESTORE redefine os contadores de linha e posição para DATA
e instruções READ no início do arquivo do programa ou
para o início da linha especificada. (Atualmente este
deve ser um número de linha.)
Dependências: (núcleo)
------------------------------------------
Comando: RETURN
Descrição: RETURN conclui uma sub-rotina chamada por GOSUB.
Dependências: (núcleo)
------------------------------------------
Função: RIGHT $ (string $, número de espaços)
Descrição: RIGHT $ retorna uma substring de uma string $ com número de espaços
da direita (final) da corda). Conforme implementado
sob bwBASIC, ele não pode ser usado para atribuição.
Dependências: MS_FUNCS
------------------------------------------
Comando: nome do caminho RMDIR
Descrição: RMDIR exclui o caminho do diretório indicado pelo nome do caminho.
Dependências: UNIX_CMDS
------------------------------------------
Função: RND (número)
Descrição: RND retorna um número pseudo-aleatório. O valor 'numérico'
é ignorado por bwBASIC se fornecido. O RANDOMIZE
comando (qv) propaga novamente o gerador de números aleatórios.
Dependências: (núcleo)
------------------------------------------
Comando: variável de string RSET $ = expressão
Descrição: RSET transfere dados da 'expressão' para a mão direita
lado de uma variável de string ou campo de buffer de acesso aleatório.
Dependências: COMMON_CMDS
------------------------------------------
Comando: RUN [linha] [nome do arquivo $]
Descrição: RUN executa o programa na memória. Se um nome de arquivo $ é
fornecido, então o arquivo especificado é carregado na memória
e executado. Se um número de linha for fornecido, a execução
começa nessa linha.
Dependências: INTERACTIVE
------------------------------------------
Comando: SALVAR nome do arquivo $
Descrição: SAVE salva o programa na memória para o nome de arquivo $. bwBASIC
salva apenas arquivos no formato ASCII.
Dependências: INTERACTIVE
------------------------------------------
Comando: SELECIONE a expressão CASE
Descrição: SELECT CASE apresenta uma seleção condicional de várias linhas
demonstração. A expressão fornecida como argumento para SELECT
CASE será avaliado pelas instruções CASE a seguir. o
A instrução SELECT CASE termina com um END SELECT
declaração.
Conforme implementado atualmente, as instruções CASE podem ser seguidas
por valores de string, mas, neste caso, apenas comparações simples
(igual, não igual) pode ser executado.
Dependências: STRUCT_CMDS
------------------------------------------
Função: SGN (número)
Descrição: SGN retorna o sinal do argumento 'número', +1
para números positivos, 0 para 0 e -1 para números negativos.
Dependências: (núcleo)
------------------------------------------
Função: SIN (número)
Descrição: SIN retorna o seno do argumento 'número'
em radianos.
Dependências: (núcleo)
------------------------------------------
Função: SPACE $ (número)
Descrição: SPACE $ retorna uma string de espaços em branco 'número'
bytes de comprimento.
Dependências: MS_FUNCS
------------------------------------------
Função: SPC (número)
Descrição: SPC retorna uma string de espaços em branco 'número'
bytes de comprimento.
Dependências: MS_FUNCS
------------------------------------------
Função: SQR (número)
Descrição: SQR retorna a raiz quadrada do argumento 'número'.
Dependências: (núcleo)
------------------------------------------
Comando: STOP
Descrição: STOP interrompe a execução do programa. Conforme implementado em
bwBASIC, STOP emite um sinal SIGINT.
Dependências: (núcleo)
------------------------------------------
Função: STR $ (número)
Descrição: STR $ retorna uma string fornecendo o decimal (base 10)
representação do argumento 'número'.
Dependências: COMMON_FUNCS
------------------------------------------
Função: STRING $ (número, valor ascii | string $)
Descrição: STRING $ retorna uma string 'número' bytes de comprimento consistindo
do primeiro caractere da string $ ou do caractere
respondendo ao valor ASCII valor ascii.
Dependências: MS_FUNCS
------------------------------------------
Comando: SUB sub-nome-da-rotina
Descrição: SUB introduz uma sub-rotina nomeada de várias linhas. o
a sub-rotina é chamada por uma instrução CALL e conclui
com uma instrução END SUB.
Dependências: STRUCT_CMDS
------------------------------------------
Comando: variável SWAP, variável
Descrição: SWAP troca os valores de duas variáveis. As duas variáveis
deve ser do mesmo tipo (numérico ou string).
Dependências: COMMON_CMDS
------------------------------------------
Comando: SYSTEM
Descrição: SYSTEM sai de bwBASIC para o programa de chamada ou
(mais comumente) o sistema operacional.
Dependências: INTERACTIVE
------------------------------------------
Função: TAB (número)
Descrição: TAB gera espaços até a coluna indicada por
'número' foi alcançado.
Dependências: (núcleo)
------------------------------------------
Função: TAN (número)
Descrição: TAN retorna a tangente do argumento 'número'
em radianos.
Dependências: (núcleo)
------------------------------------------
Função: TIME $
Descrição: TIME $ retorna a hora atual com base na hora do computador
relógio interno como uma string na forma "HH-MM-SS".
Conforme implementado em bwBASIC, TIME $ não pode ser usado para
atribuição (ou seja, para definir a hora do sistema).
Nota: bwBASIC atualmente (v2.10) não permite atribuição
para uma função.
Dependências: COMMON_FUNCS
------------------------------------------
Função: TIMER
Descrição: TIMER retorna a hora no relógio do sistema em segundos
decorrido desde a meia-noite.
Dependências: MS_FUNCS
------------------------------------------
Comando: TROFF
Descrição: curvas TROFF da facilidade de rastreamento; veja TRON.
Dependências: COMMON_CMDS
------------------------------------------
Comando: TRON
Descrição: TRON ativa o recurso de rastreamento. Esta instalação irá imprimir
cada número de linha entre colchetes, pois o programa é
executado. Isso é útil para depurar programas com
números de linha. Para depurar um programa não numerado com
TRON, ligue para DO NUM primeiro, mas lembre-se de ligar para DO UNNUM
antes de salvar o programa mais tarde.
Dependências: COMMON_CMDS
------------------------------------------
Função: VAL (string $)
Descrição: VAL retorna o valor numérico da string $.
Dependências: COMMON_FUNCS
------------------------------------------
Comando: VARS
Descrição: VARS é um comando de depuração que imprime uma lista de
todas as variáveis definidas que têm escopo global.
Dependências: DEBUG
------------------------------------------
Comando: WEND
Descrição: WEND conclui um loop WHILE-WEND; veja ENQUANTO.
Dependências: COMMON_CMDS
------------------------------------------
Comando: expressão WHILE
Descrição: WHILE inicia um loop WHILE-WEND. O loop termina com
WEND, e a execução é repetida através do loop como
contanto que a 'expressão' seja TRUE (-1).
Dependências: COMMON_CMDS
------------------------------------------
Comando: WIDTH [# device-number,] number
Descrição: WIDTH define a tela ou saída do dispositivo para 'número'
colunas. device-number especifica o dispositivo
ou arquivo para saída.
Dependências: COMMON_CMDS
------------------------------------------
Comando: WRITE [# device-number,] element [, element] ....
Descrição: WRITE gera variáveis para a tela ou para um arquivo
ou dispositivo especificado pelo número do dispositivo. Vírgulas
são inseridos entre a saída de expressões e strings
estão entre aspas.
Dependências: COMMON_CMDS
------------------------------------------
6. VARIÁVEIS PREDEFINIDAS
BWB.EDITOR $
BWB.FILES $
BWB.PROMPT $
BWB.IMPLEMENTAÇÃO $
Os comandos EDIT e FILES são pseudo-comandos que iniciam
programas shell nomeados nas variáveis BWB.EDITOR $ e BWB.FILES $,
respectivamente. Os valores padrão para essas variáveis podem
ser alterado em bwbasic.h (DEF_EDITOR e DEF_FILES), ou eles
pode ser alterado rapidamente pelo usuário. Uma ideia pode ser
inicialize essas variáveis em "profile.bas" para
implementações; por exemplo, BWB.FILES $ pode ser definido como
"ls -l" em sistemas Unix ou "dir" em sistemas DOS.
A variável predefinida BWB.PROMPT $ pode ser usada para definir o prompt
string para bwBASIC. Novamente, é sugerido que um usuário
prompt selecionado pode ser configurado em um "profile.bas" para ser
inicializado cada vez que o bwBASIC é iniciado. Observe que especial
caracteres podem ser adicionados à string de prompt, por exemplo,
BWB.PROMPT $ = "Ok" + CHR $ (10)
apresentará um prompt "Ok" seguido por um avanço de linha.
A variável predefinida BWB.IMPLEMENTATION $ retornará "TTY" para
a implementação bwx_tty e retornará "IQC" para o
IBM PC ou compatível com implementação QuickC (bwx_iqc).
Isso pode ser útil para determinar quais comandos e funções
(especificamente CLS, LOCATE e INKEY $) podem estar disponíveis.
7. FUNÇÕES E COMANDOS NÃO IMPLEMENTADOS e AGENDA DE DESENVOLVIMENTO
Alguns itens não implementados há tanto tempo
uma parte dos BASICs padrão que sua ausência parecerá surpreendente.
Em cada caso, porém, sua implementação exigiria operação
funções específicas do sistema ting ou funções específicas do terminal
que não pode ser fornecido universalmente. Alguns exemplos específicos:
CLOAD depende das convenções CP / M ou MSDOS para binários
arquivos executáveis.
CONT Veja RESUME abaixo (ignorância do programador?).
DEF USR depende das convenções CP / M ou MSDOS para binários
arquivos executáveis.
FRE () A capacidade de relatar a quantidade de memória livre
restante é específico do sistema devido a padrões variáveis
de alocação de memória e acesso; conseqüentemente isso
capacidade não está presente em ANSI ou versões anteriores
de C e esta função não está disponível em bwBASIC.
INPUT $ () C por si só não é capaz de ler teclado sem eco
entrada, e pode ler a entrada do teclado somente após um
O retorno de carro foi inserido.
INP chamadas para portas de hardware, como linguagem de máquina
rotinas, são altamente específicas do sistema e não podem
ser implementado em C sozinho.
LLIST Veja LPRINT abaixo.
LPOS Consulte LPRINT abaixo.
LPRINT e LLIST, etc., requerem acesso a um dispositivo de impressora,
e isso varia de um sistema para outro. Comercial
pode tentar ABRIR o dispositivo da impressora por conta própria
sistema operacional (por exemplo, "/ dev / lp" em sistemas Unix,
ou "PRN" no DOS) e veja se a impressão pode ser feita
do bwBASIC desta forma.
NULL Neste caso, estou convencido de que NULL não é mais
necessário, uma vez que muito poucas impressoras agora exigem NULLs
no final das linhas.
OUT Veja INP acima (chamadas para portas de hardware).
PEEK () PEEK e POKE habilitaram BASICs anteriores para endereçar
localizações de memória particulares. Embora bwBASIC
poderia possivelmente implementar este comando (POKE) e
esta função (PEEK ()), a limitação seria
altamente limitado pelos diferentes sistemas para
acesso à memória em diferentes sistemas.
POKE veja PEEK () acima.
RENUM Uma vez que as linhas não numeradas podem ser inseridas e
executado sob bwBASIC, não seria
possível implementar uma rotina RENUM.
Em vez disso, bwBASIC usa DO NUM e DO UNNUM.
RESUME Isso é possível em C? Se sim, eu
simplesmente não conseguiram descobrir isso ainda.
Mea culpa (mas não máxima).
USR Ver CALL e DEF USR acima (linguagem de máquina
sub-rotinas).
VARPTR Veja PEEK e POKE acima.
WAIT Veja INP e OUT acima.
Existem outros comandos, funções e detalhes de implementação
que estou trabalhando, e que estão na lista da agenda para o futuro
versões de bwBASIC. Essa agenda inclui:
PARACT ou seja, a capacidade de executar AÇÕES PARALELAS. Esse
é descrito em ANSI BASIC, embora eu não tenha visto isso
implementado antes. Ele oferecerá um aspecto aproximado, não
forma preventiva de multitarefa dentro do escopo
de um programa BASIC. Os programadores notarão os pontos nos quais
já existem ganchos para PARACT em bwBASIC.
Os computadores do tipo PC XMEM precisam ser capazes de usar
memória. Se pudéssemos usar memória estendida para o programa
linhas, variáveis e definições de funções, poderíamos
escrever programas muito mais longos. Isso implicaria,
no entanto, uma reescrita bastante séria do programa
para utilizar identificadores de memória para esses recursos de armazenamento
em vez de ponteiros diretos de memória.
Windows A adição de alças de memória além do
execução não preemptiva das linhas do programa (em um
forma bruta, já presente) tornará possível
para desenvolver implementações para Windows e talvez
para outras interfaces gráficas do usuário. Mas que forma
isso deve levar? Tenho em mente atualmente um BASIC
que seria executado em segundo plano, aparecendo apenas
como um ícone no espaço da GUI, com editores pop-up
e janelas de saída. Assim, a linguagem interpretada
serviria a um propósito como 'cron' (uma tarefa
programador) em sistemas Unix. Você pode ter algum
reflexões que me ajudariam nisso.
Gráficos Aqui, enfrentamos diferenças bastante críticas em diferentes
estilos e implementações de gráficos, por exemplo, entre
GWBASIC, ANSI BASIC, VisualBASIC, etc. Mas é
possível que comandos e funções de gráficos possam
ser adicionado. Tudo isso seria específico da implementação.
O padrão ANSI para BASIC completo não especifica qual particular
comandos ou funções devem ser implementados, e de fato o padrão
é muito robusto. Talvez nenhuma implementação do BASIC jamais
incluem todos os itens, mas alguns comandos e funções ANSI que
permanecem não implementados são:
ACESSO
Ângulo
ÁREA
ARITMÉTICA
ARRAY
ASK
BSTR
BVAL
TETO
CÉLULAS
CLIP
COLLATE
CONECTAR
COSH
DATA
DEBUG
DECIMAL
DECLARAR
GRAUS
DISPOSITIVO
DESCONECTAR
DISPLAY
DOT
DESENHAR
ERASE
EVENTO
EXCEÇÃO
GRÁFICO
MANIPULADOR
IMAGEM
KEY
LCASE
LINHAS
LOG10
LOG2
MAT
MIX
MULTIPONTO
EM
SAÍDA
PARACTO
CENÁRIO
PIXEL
ENREDO
PONTOS
RADIANOS
RECEBER
RENUMERAR
REESCREVER
GIRAR
ROUND
APROVEITAR
ENVIAR
DESLOCAMENTO
SINH
TANH
TIMEOUT
TRACE
TRANSFORMAR
TRUNCAR
UBOUND
UCASE
JANELA DE EXIBIÇÃO
ESPERAR
JANELA DE EXIBIÇÃO
LARGURA DE ZONA
8. A HISTÓRIA DO BÁSICO DE ÁGUAS
Este programa foi originalmente iniciado em 1982 por minha avó, a Sra.
Verda Spell of Beaumont, TX. Ela estava escrevendo o programa usando
um compilador ANSI C em um computador Osborne I CP / M e embora meu
avô (Lockwood Spell) comprou um IBM PC com 256k de
RAM minha avó não usaria, parafraseando George Herbert
no sentido de que "Quem não pode no programa de 64k, não pode em 512k."
Ela tinha usado o Microsoft BASIC e embora não tivesse nada contra
ela disse várias vezes que não entendia por que o digital
A pesquisa não "processou a Microsoft" para a versão 1.0
do MSDOS e, portanto, acho que ela esperava minar o da Microsoft
todo o mercado e, eventualmente, construir um novo império de software em
o extremo norte de Beaumont. Seus esforços de programação foram cortados
tragicamente curta quando foi jogada de Beaumont para o Porto
Trem suburbano Arthur no verão de 1986. Eu encontrei a fonte
codificar para bwBASIC em um disquete Osborne de densidade única em seu tricô
saco e, eventualmente, conseguiu ter tudo copiado para um PC
disquete. Eu o revisei um pouco antes deste lançamento. Vocês
deveria saber, porém, que eu mesmo sou um historiador, não um programador.
9. COMUNICAÇÕES:
o email: [email protegido]
11 de outubro de 1993 BWBASIC(1)
Use bwbasic online usando serviços onworks.net
