Quick-Basic (QB71)

Palavras Chaves Quick-Basic: Página em edição.
Este trabalho tem por objetivo inicializar estudantes para o entendimento das novas versões do BASIC.
Para baixar o QBX (QB71) clique nesta imagem da direita, marque a caixa QB e clique em Baixar; você receberá uma pasta zipada. Faça a descompactação onde você desejar (HD, Pen drive, etc.). Para rodar o Quick-Basic basta entrar na Pasta QB e clicar no programa QBX.EXE ou Quick-Basic.EXE ou a partir de uma janela COMMAND.COM ou CMD.EXE (no menu iniciar do windows) e digitar: QBX/L/AH. O Quick-Basic possui todas as instruções necessárias à programação no Menu-Help do próprio Editor/Compilador.
Obs.: O Windows-7 e posteriores não aceitam comandos gráficos nem instruções de tela além do SCREEN 0.


┌─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┐
ABCDEFGHI-JKLMNOPQRSTUVWX-Y-Z
└─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┘
ABS (Função)
Devolve o valor absoluto de uma expressão numérica.
Sintaxe:
ABS(expressão_numérica)
Observações:
expressão_numérica é qualquer expressão numérica.
ABS sempre devolve um valor positivo, independentemente do resultado da expressão ser positivo ou negativo.
ABS devolve um valor do mesmo tipo que expressão_numérica (inteiro, inteiro longo, precisão dupla e assim por diante).
Exemplo:

PRINT "O valor absoluto de -3 * 5 é"; ABS(-3 * 5)
PRINT "O valor absoluto de 3 * 5 é"; ABS(3 * 5)

A execução deste programa produz a seguinte saída:

O valor absoluto de -3 * 5 é 15
O valor absoluto de 3 * 5 é 15

Absolute (Palavra-Chave)
Transfere o controle para um procedimento em linguagem de máquina inclusa na Livraria QBX.QLB e QBX.LIB.
Sintaxe:
CALL Absolute ([argumentlist,] integervariable%)
Observações:
argumentlist são argumentos passados para o procedimento em linguagem-de-máquina, deslocamento do corrente segmento de dado.
integervariable% é o deslocamento do segmento de código corrente, definido por DEF SEG, para o local do procedimento de partida.
Veja também: CALL, CALLS (Não-BASIC) para uma maneira mais simples de chamar procedimentos de linguagem assembly do BASIC.

ACCESS (Palavra-Chave)
Especifica o tipo de acesso que os usuários têm para um arquivo aberto.
ACCESS {READ | WRITE | READ WRITE}
■ READ: Abre um arquivo somente para a leitura.
■ WRITE: Abre um arquivo somente para a gravaçao.
■ READ WRITE: Abre um arquivo tanto para a leitura quanto para a gravaçao. O modo READ WRITE é valido somente para acesso aleatório e modo binário, e arquivos abertos para APPEND (acesso sequencial).
Consulte também: OPEN.

ALIAS (Palavra-Chave)
ALIAS “nome-in-Quick-Library”
A cláusula ALIAS em uma instrução DECLARE anuncia ao Quick-Basic que o nome de um procedimento em uma biblioteca rápida é diferente do nome que você vai usar em seu programa para chamar esse procedimento.
Consulte também: DECLARE (Não-BASIC).

AND (Operador-Booleano)
Operadores booleanos realizam manipulações de bit, operações booleanas ou testes em relações múltiplas. Estes retornam um valor verdadeiro (diferente de zero) ou falso (zero) a ser usado ao se tomar uma decisão.
resultado = expressão1 operador_booleano expressao2
Cada operador retorna resultados como indicado na seguinte tabela.
T = verdadeiro (true – diferente de zero); F = falso (false – igual a zero):

Expressao1 Expressao2 NOT negação AND união OR inclusão XOR exclusão EQV equivalência IMP implicação
T T F T T F T T
T F F F T T F F
F T T F T T F T
F F T F F F T T

Operações booleanas são executadas após operações aritméticas e relacionais em ordem de precedência.
Expressoes sao convertidas em inteiros ou inteiros longos antes da execução da operação booleana.
Se o resultado de uma expressão for 0 ou -1, a operação Booleana retorna 0 ou -1 como resultado. Como operadores booleanos calculam por bit, a utilização de valores diferentes de 0 para falso e -1 para verdadeiro podem produzir resultados inesperados.

ANY (Palavra-Chave)
Desabilita a verificação do tipo de variável em declarações FUNCTION ou SUB, como: nome_variável AS tipo.
ANY aceita todos os tipos: nome_variável AS ANY

APPEND (Palavra-Chave)
As palavras-chave APPEND, BINARY, INPUT, OUTPUT, RANDOM sao usadas na instrução OPEN para especificar os modos de abertura de arquivo. INPUT, OUTPUT, RANDOM sao também usados na instrução OPEN COM.
APPEND especifica que o arquivo será aberto como saída sequencial e posiciona o ponteiro no final do arquivo. Uma instrução PRINT # ou WRITE # irá então estender (acrescentar) o arquivo.
BINARY especifica um modo de arquivo binário. Em um modo binário, você pode ler ou gravar informações para qualquer posição do byte no arquivo usando as instruções GET ou PUT.
INPUT especifica que o arquivo é aberto para entrada sequencial.
OUTPUT especifica que o arquivo é aberto para saída sequencial.
RANDOM especifica que o arquivo é aberto em modo de arquivo aleatório. RANDOM é o modo de arquivo padrão.
Consulte também: OPEN; OPEN COM; PRINT; LPRINT; WRITE.

AS (Palavra-Chave)
Realiza diferentes ações quando parte de instruções diferentes:
■ Especifica um tipo de variável quando usado nas instruções COMMON, DECLARE, DEF FN, DIM, FUNCTION, REDIM, SHARED, STATIC, e SUB.
■ Especifica um tipo de elemento em um tipo de dado definido pelo usuário quando usado na instrução TYPE.
■ Designa um número de arquivo à um arquivo ou dispositivo quando usado na instrução OPEN.
■ Especifica um nome de um campo quando usado na instruçao FIELD.
■ Especifica um novo nome de arquivo quando usado na instrução NAME.
Consulte também: COMMON; DECLARE; DEF FN; DIM; REDIM; FIELD; FUNCTION; NAME; OPEN; SHARED; STATIC; SUB; TYPE.

ASC (Função)
Devolve o valor numérico do código ASCII para o primeiro caractere de uma expressão string.
Sintaxe:
ASC(expressão_string)
Observações:
expressão_string é qualquer expressão string.
Exemplo:

stringvar$ = "ABC"
PRINT ASC(stringvar$)
PRINT ASC("abc")
PRINT ASC(RIGHT$(stringvar$, 2))

A execução deste programa produz a seguinte saída:

65
97
66

Função relacionada: CHR$

ATN (Função)
Devolve o arco tangente de um ângulo especificado.
Sintaxe:
ATN(ângulo)
Observações:
ângulo é um ângulo para o qual você deseja achar o arco tangente.
Você pode expressar um ângulo tanto em graus quanto em radianos. As rotinas trigonométricas do Quick-Basic suportam apenas radianos. Para converter graus em radianos, use a seguinte equação: radianos = 3.141593 * (graus/180)
Exemplo:

angulo = 45
PRINT "O Arcotangente de"; angulo; "graus é"; ATN(3.141593 * (angulo / 180))

A execução deste programa produz a seguinte saída:

O Arcotangente de 45 graus é .6657738

Funções relacionadas: COS; SIN; TAN


┌─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┐
ABCDEFGHI-JKLMNOPQRSTUVWX-Z
└─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┘
BEEP (Comando)
Emite um som no alto-falante interno do computador.
Sintaxe:
BEEP
Observações:
BEEP cria um breve som que é útil para chamar a atenção do usuário. BEEP não afeta a saída no vídeo.
Exemplo:

BEEP
PRINT "Erro no acesso ao arquivo VENDAS.DAT"

A execução deste programa produz a seguinte saída:

(Bip do altofalante) Erro no acesso ao arquivo VENDAS.DAT

BINARY (Palavra-Chave)
As palavras-chave APPEND, BINARY, INPUT, OUTPUT, e RANDOM são usadas na instrução OPEN para especificar os modos de arquivo. INPUT, OUTPUT, e RANDOM; sao também usadas na instrução OPEN COM.
■ APPEND especifica que o arquivo será aberto como saída sequencial e posiciona o ponteiro no final do arquivo. Uma instrução PRINT # ou WRITE # irá então estender (acrescentar) o arquivo.
■ BINARY especifica um modo de arquivo binário. Em um modo binário, você pode ler ou gravar informações para qualquer posição do byte no arquivo usando as instruções GET ou PUT.
■ INPUT especifica que o arquivo é aberto para entrada sequencial.
■ OUTPUT especifica que o arquivo é aberto para saída sequencial.
■ RANDOM especifica que o arquivo é aberto em modo de arquivo aleatório. RANDOM é o modo de arquivo padrão.
Consulte também: OPEN; OPEN COM; PRINT, LPRINT; WRITE; PUT; GET.

BLOAD (Comando)
Carrega um arquivo de imagem da memória criado pelo comando BSAVE na localização de memório especificada.
Sintaxe:
BLOAD nome_arquivo[, deslocamento]
Observações:
nome_arquivo é uma expressão string que especifica o arquivo contendo a imagem a ser carregada.
deslocamento é o deslocamento opcional em relação ao início do segmento de dados (ou último DEF SEG), indicado onde a imagem deve ser carregada.
BLOAD e BSAVE trabalham juntos para oferecer a você um meio rápido e conveniente para carregar valores de matrizes ou imagens gráficas.
Não use BLOAD com arquivos criados pelo BASICA. Quick-Basic e BASICA armazenam itens de forma diferente na memória.
Exemplo:

'Cria uma matriz chamada VENDAS
DIM vendas(1 TO 500)
'Define o endereço do segmento de dados como o início de VENDAS
DEF SEG = VARSEG(vendas(1))
'Carrega a matriz usando BLOAD
BLOAD "VENDAS.DAT" VARPTR(vendas(1))
'Volta para o segmento de dados do BASIC
DEF SEG

Funções relacionadas: VARPTR; VARSEG
Comandos relacionados: BSAVE; DEF SEG

BSAVE (Comando)
Copia o conteúdo de uma região de memória para um arquivo ou periférico.
Sintaxe:
BSAVE nome_arquivo, deslocamento, tamanho
Observações:
nome_arquivo é uma expressão string que especifica o arquivo ou periférico para o qual o conteúdo da memória será transferido.
deslocamento é o endereço do primeiro byte que você deseja copiar, relativo ao segmento corrente.
tamanho é o número de bytes a ser copiado (de 0 a 65535).
Exemplo:

'Cria uma matriz com 500 elementos
DIM vendas(1 TO 500)
'Inicializa a matriz com valores de 1 a 500
DIM vendas(1 to 500)
FOR i = 1 to 500
  vendas(i) = i
NEXT i
'Define o endereço do segmento para o início de vendas
DEF SEG = VARSEG(vendas(1))
'Grava a matriz usando BSAVE
BSAVE "VENDAS.DAT", VARPTR(vendas(1)), 2000
'Volta para o segmento de dados do BASIC
DEF SEG

Funções relacionadas: VARPTR; VARSEG
Comandos relacionados: BLOAD; DEF SEG

BYVAL (Palavra-Chave)(Cláusula)
BYVAL variável [AS tipo]
O atributo BYVAL na lista de parâmetros de uma instrução DECLARE causa o valor da variável especificada para ser passado para o procedimento, em vez de endereço da variável. BYVAL só pode ser utilizado em instruções DECLARE para os procedimentos não-Basic, e não pode ser aplicado a parâmetros de cadeia.
Consulte também: CALLS ou CALL (não-Basic).


┌─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┐
ABCDEFGHI-JKLMNOPQRSTUVWX-Z
└─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┘
CALL (Comando)(Procedimentos BASIC)
Transfere o controle da execução para um subprograma BASIC.
CALL nome_subprograma [(lista_argumentos)]
ou
nome_subprograma [lista_argumentos]
Observações:
nome_subprograma é o nome de um subprograma BASIC criado usando um comando SUB.
lista_argumentos é uma lista de parâmetros separados por vírgulas. O subprograma pode alterar o valor dos parâmetros.
Você pode chamar subprogrtamas com ou sem a palavra reservada CALL, não coloque os argumentos dentro de parênteses. Ainda, se você omitir CALL, deve usar o comando DECLARE.
Para evitar que um subprograma altere o valor de um parâmetro, simplesmente coloque o parâmetro entre parênteses:
CALL TEST (a, b, (c))
Neste caso, o subprograma pode alterar os valores dos parâmetros a e b, mas não de c.
Exemplo:

a = 1
b = 2
CALL SwapVal(a, b)
PRINT a; b
END
SUB SwapVal(x, y)
temp = x
x = y
y = temp
END SUB

A execução deste programa produz a seguinte saída:

2 1

Funções relacionadas: CALL; CALLS; CALL ABSOLUTE; CHAIN; DECLARE

CALL, CALLS (Comandos)(Procedimentos não-BASIC)
Transfere o controle da execução para um procedimento escrito em liguagem de programação diferente do BASIC.
Sintaxe:
CALL procedimento [(lista_parâmetros)]
ou
CALLS procedimento [(lista_parâmetros)]
ou
procedimento [(lista_parâmetros)]
Observações:
procedimento é o nome do procedimento a ser chamado.
Lista_parâmetro é uma lista opcional de parâmetros, separados por vírgulas.
Quick-BASIC permite que você preceda cada parâmetro em um comando CALL com uma das palavras-chave BYVAL ou SEG.
BYVAL indica ao Quick-BASIC que o parâmetro deve ser passado por valor, o que evita que a sub-rotina possa alterar o parâmetro. SEG indica ao Quick-BASIC que deve passar o parâmetro como um endereço com o segmento.
Você não pode usar as palavras-chave BYVAL e SEG com o comando CALLS.
Lembre-se de que rotinas escritas em C tratam parâmetros da direita para esquerda, ao contrário da ordem utilizada em BASIC, PASCAL e FORTRAN.
Exemplo:

DECLARE SUB Test CDECL(BYVAL valor AS INTEGER)
a = 5
CALL Test(a)
END
/* arquivo compilado separadamente em C */
/* compilado com modelo de memória grande */
void test(int a)
{
  printf("O valor é %d\n", a);
}

Funções relacionadas: CALL; CALL ABSOLUTE; CHAIN; DECLARE

CALL ABSOLUTE (Comando)
Transfere o controle da execução para uma sub-rotina escrita em linguagem de máquina.
Sintaxe:
CALL ABSOLUTE([lista_parâmetro,] deslocamento)
Obeservações:
lista_parâmetros é uma lista opcional de parâmetros, separados por vírgulas.
deslocamento é o endereço do início do código do procedimento no segmento de código.
Para usar CALL ABSOLUTE, você deve usar a biblioteca QB.LIB ou a biblioteca Quick QB.QLB.
Exemplo:

'Cria um procedimento em linguagem de máquina e o chama usando CALL ABSOLUTE
'Matriz para armazenar o código de máquina
DIM asmroutine(1 TO 6) AS INTEGER
'Dados contendo a rotina em linguagem de máquina
DATA &H55                'PUSH BP
DATA &H8B, &HEC          'MOV BP,SP
DATA &HB4, 2             'MOV AH,2
DATA &HB2, 65            'MOV DL,65
DATA &HCD, &H21          'INT 21H
DATA &H5D                'POP BP
DATA &HCB, 0             'RET
'Obtém o endereço da matriz
offset = VARPTR(asmroutine(1))
'Altera o segmento para o início da matriz
DEF SEG = VARSEG(asmroutine(1))
'Preenche a matriz com o código de máquina
FOR i = 0 to 11
  READ asmcode
  POKE (offset + i), asmcode
NEXT i
'Chama a rotina e restaura o segmento
CALL ABSOLUTE(VARPTR(asmroutine(1)))
DEF SEG

Funções relacionadas: CALL, CALLS

CALL INT86OLD (Comando)
Chama um serviço oferecido internamente pelo DOS.
Sintaxe:
CALL INT86OLD(número_interrupção, matriz_entrada( ), matriz_saída( ))
Obsrvações:
O DOS proporciona um conjunto completo de serviços utilitários que seus programas podem acessar. MS-DOS Functions de Ray Duncan (Microsoft Press, 1988) descreve estes serviços em detalhes.
número_interrupção é um número (0 a 255) que corresponde ao serviço do DOS desejado.
matriz_entrada é uma matriz inteira de 8 elementos, contendo os valores dos registradores na ordem AX, BX, CX, DX, BP, SI, DI e FLAGS (matriz_entrada(x) = AX, matriz_entrada(x+1) = BX e assim por diante).
matriz_saída é uma matriz de 8 elementos contendo os valores dos registradores no momento em que o serviço do DOS está completo.
Para usar CALL INT86OLD, você deve usar a biblioteca Quick QB.QLB.
Exemplo:

'Cria um arquivo chamado TEST.DAT usando interrupção 21H função 3CH
DIM matrizentrada(1 TO 8) AS INTEGER
DIM matrizsaida(1 TO 8) AS INTEGER
arquivo$ = "TEST.DAT" + CHR$(0)
matrizentrada(1) = &H3c00                             'serviço do DOS em AX
matrizentrada(3) = 0                                  'atributo do arquivo em CX
matrizentrada(4) = SADD(arquivo$)                     'string ASCIIZ em DX
CALL INT86OLD (&H21, matrizentrada( ), matrizsaida( ))

Comandos relacionados: CALL INT86XOLD; CALL INTERRUPT; CALL INTERRUPTX

CALL INT86XOLD (Comando)
Chama um serviço oferecido internamente pelo DOS.
Sintaxe:
CALL INT86OLD(número_interrupção, matriz_entrada( ), matriz_saída( ))
Obsrvações:
Embora funcionalmente similar a INT86OLD, INT86XOLD suporta uma matriz de 10 elementos que armazena os registradores AX, BX, CX, DX, BP, SI, DI, FLAGS, DS e ES.
Muitos serviços do DOS requerem valores para os registradores DS e ES. O comando CALL INT86XOLD permite que você forneça estes valores.
Para usar CALL INT86XOLD, você deve usar a biblioteca QB.LIB ou a biblioteca Quick QB.QLB.
Exemplo:
Veja CALL INT86OLD (Comando).
Comandos relacionados: CALL INT86OLD; CALL INTERRUPT; CALL INTERRUPTX

CALL INTERRUPT (Comando)
Chama um serviço oferecido internamente pelo DOS usando um registro definido pelo usuário.
Sintaxe:
CALL INTERRUPT(número_interrupção, reg_entrada, reg_saída)
Observações:
número_interrupção é um número (de 0 a 255) que corresponde ao serviço do DOS desejado.
reg_entrada e reg_saída são variáveis do tipo RegType definido pelo usuário.
O arquivo QB.BI define o tipo RegType, o qual contém elementos correspondentes aos registradores do 8086.

Type RegType
  ax    AS INTEGER
  bx    AS INTEGER
  cx    AS INTEGER
  dx    AS INTEGER
  bp    AS INTEGER
  si    AS INTEGER
  di    AS INTEGER
  flags AS INTEGER
END TYPE

Para chamar um serviço do DOS, atribua os valores correspondentes aos registradores aos elementos de reg_entrada.
Quando o serviço é encerrado, CALL INTERRUPT atribui os valores finais dos registradores aos elementos de reg_saída.
Para usar CALL INTERRUPT, você deve usar a biblioteca QB.LIB ou a biblioteca Quick QB.QLB.
Exemplo:

'Cria um arquivo chamado TEST.DAT usando interrupção 21H função 3CH
'$INCLUDE: QB.BI
DIM regentrada AS RegType, regsaida AS RegType
arquivo$ = "TEST.DAT" + CHR$(0)
reg_entrada.ax = &H3C00                    'serviço do DOS
reg_entrada.cx = 0                         'atributo do arquivo
reg_entrada.dx = SADD(arquivo$)            'deslocamento do nome do arquivo
CALL INTERRUPT(&H21, regentrada, regsaida)

Comandos relacionados: CALL INT86OLD; CALL INT86XOLD; CALL INTERRUPTX

CALL INTERRUPTX (Comando)
Chama um serviço oferecido internamente pelo DOS usando um registro definido pelo usuário.
Sintaxe:
CALL INTERRUPTX(número_interrupção, reg_entrada, reg_saída)
Observações:
Apesar de ser funcionalmente similar a CALL INTERRUPT, CALL INTERRUPTX permite que você especifique valores para os registradores DS e ES.
Veja o tipo RegTypeX no arquivo de inclusão QB.BI.
Para usar CALL INTERRUPTX você deve usar a biblioteca QB.LIB ou a biblioteca Quick QB.QLB.
Exemplo:
Veja CALL INTERRUPT (Comando).
Comandos relacionados: CALL INT86OLD; CALL INT86XOLD; CALL INTERRUPT

CASE (Palavra-Chave)
Executa um de diversos blocos de instruções dependendo do valor de uma expressão.
Sintaxe:
SELECT CASE expressão-teste
  CASE lista-expressões-1
    [bloco-instruções-1]
  [CASE lista-expressões-2
    [bloco-instruções-2]]…
  [CASE ELSE
     [bloco-instruções-n]]
END SELECT
Observações:
expressao-teste é qualquer expressão numérica ou sequência de caracteres.
lista-expressoes-1 é uma ou mais expressões compatíveis com a expressão-teste.
lista-expressoes-2 A palavra-chave IS deve preceder quaisquer operadores relacionais em uma expressão.
bloco-instruções-1 é uma ou mais instruções em uma ou mais linhas.
bloco-instru‡oes-2
bloco-instru‡oes-n
Os argumentos da lista de expressoes podem ter uma dessas formas ou uma combinação das mesmas, separadas por vírgulas:
expressao[,expressao]…
expressao TO expressao
IS operador-relacional expressao
expressao é qualquer expressão numérica ou alfabética compatível com a expressão-teste.
operador-relacional é um dos seguintes operadores relacionais:

<  Menor que
<= Menor ou igual a
>  maior que
>= Maior ou igual a
<> Diferente de
=  Igual a

Exemplo:

INPUT "Entre com o nível de risco aceitável (1-5):"; Total
SELECT CASE Total
    CASE IS >= 5
      PRINT "Máximo risco e retorno potencial."
      PRINT "Escolha de investimento em ações."
    CASE 2 TO 4
      PRINT "Moderado à alto risco e retorno potencial."
      PRINT "Escolha de mútuo fundos ou bônus incorporados."
    CASE 1
      PRINT "Nenhum risco, baixo retorno."
      PRINT "Escolha de Caderneta de Poupança."
END SELECT

Consulte também: IF…THEN…ELSE

CCUR (Função)
converte um valor numérico ou expressão de no máximo 15 dígitos significativos, para um valor monetário, arredondado para o máximo de quatro casas decimais.
Sintaxe:
CCUR(expressão_numérica)
Observações:
expressão_numérica é qualquer expressão numérica.
CCUR arredonda, não tuca. Se a quinta casa decimal for menor que 5, a quarta casa permanecerá inalterada. Se a quinta casa for maior ou igual a 5, arredondará a quarta casa decimal para cima (+ .0001). Após isso, as casas, além das quatro, são trucadas.
CCUR é equivalente a seguinte equação: X = INT(expressão_numérica * 10000 + .5) / 10000 onde X assumirá o valor de expressão_numérica arredondado para 4 casas decimais caso haja cinco ou mais casas.
CCUR não completa com zeros (0) as casas decimais que faltarem para completar as quatro casas.
Exemplo:

PRINT CCUR (123.456789)
PRINT INT(123.456789 * 10000 + .5) / 10000
PRINT CCUR (1.12305)
PRINT INT(1.12305 * 10000 + .5) / 10000
PRINT CCUR (1.12315)
PRINT INT(1.12315 * 10000 + .5) / 10000

A execução deste programa produz a seguinte saída:

123.4568
123.4568
1.123
1.123
1.1231
1.1231

Funções relacionadas: CINT; CSNG; CDBL; CLNG.

CDBL (Função)
Converte uma expressão numérica para um valor de dupla precisão.
Sintaxe:
CDBL(expressão_numérica)
Observações:
expressão_numérica é qualquer expressão numérica.
Usar CDBL é equivalente a atribuir a expressão a uma variável de dupla precisão.
Valores de precisão simples possuem 7 dígitos significativos. Valores de dupla precisão possuem 15 dígitos significativos.
Exemplo:

PRINT 5 / 6
PRINT CDBL(5 / 6)

A execução deste programa produz a seguinte saída:

.8333333
.8333333333333334

Funções relacionadas: CINT; CLNG; CSNG; FIX; INT

CDECL (Palavra-Chave)
Em uma declaração DECLARE que declara um procedimento não-BASIC, CDECL indica que o procedimento declarado usa a odrem de argumentos para linguagem C. Basic passa os argumentos na lista de argumentos da direita para a esquerda, e não da esquerda para a direita como é a convenção BASIC habitual.
Veja também: CALL; CALLS (Não-BASIC); DECLARE (Não-BASIC)

CHAIN (Comando)
Transfere o controle da execução de um programa Quick-BASIC para outro.
Sintaxe:
CHAIN nome_arquivo
Observações:
nome_arquivo é uma expressão string contendo o nome do arquivo do programa para o qual o controle da execução será passado.
Se seu programa está sendo executado dentro do ambiente Quick-BASIC, o arquivo deve ser um arquivo BASIC fonte; se seu programa está sendo executado fora do ambiente Quick-BASIC, o arquivo deve ser um arquivo executável.
Para trocar informações entre programas encadeados, você deve usar o comando COMMON.
COMMON requer o módulo BRT (executável) nos programas compilados e encadeados com CHAIN.
Após transferir o controle da execução para outro programa usando CHAIN, o programa que chamou CHAIN não voltará a ser executado após o término do programa chamado.
Exemplo:

CHAIN "TEST.BAS"  'Chama o programa TEST.BAS em ambiente interpretável Quick-Basic
CHAIN "TEST.EXE"  'Chama o programa executável TEST.EXE a partir deste programa BASIC depois de compilado

Comandos relacionados: CALL; COMMON; RUN

CHDIR (Comando)
Altera o diretório corrente para um determinado disco.
Sintaxe:
CHDIR nome-diretório
Observações:
nome-diretório é uma expressão string que contém o nome do diretório desejado. Ele deve ter menos que 64 caracteres.
Para alterar o diretório corrente para um disco diferente do disco corrente, o nome do diretório deve ser precedido com a letra do disco e dois pontos.
CHDIR não muda o disco corrente. Você não pode abreviar CHDIR.
Exemplo:

'Troca o diretório corrente no disco C para \DOS
CHDIR "C:\DOS"

Comandos relacionados: MKDIR; RMDIR

CHDRIVE

CHR$ (Função)
Devolve uma string de um caractere, contendo o caractere correspondente ao valor ASCII especificado.
Sintaxe:
CHR$(valor_ascii)
Observações:
valor_ascii é o código ASCII do caractere desejado.
CHR$ é comumente usada para fazer soar o beep do computador (CHR$(7)), e para terminar uma string ASCIIZ que possa ser usada na chamada de serviços do DOS (CHR$(0)).
O padrão ASCII usa valores variando de 0 a 127; os valores de 128 até 255 são caracteres estendidos que servem para formar gráficos simples e outros símbolos ou caracteres acentuados.
Exemplo:

'Mostra os caracteres definidos no ASCII e no ASCII estendido
FOR i = 0 TO 255
  PRINT i, CHR$(i)
NEXT i

Funções relacionadas: ASC

CINT (Função)
Arredonda uma expressão numérica para um valor inteiro.
Sintaxe:
CINT(expressão_numérica)
Observações:
expressão_numérica deve resultar em um valor entre -32.768 e 32.767. Se a expressão estiver fora destes limites, ocorrerá um erro em tempo de execução.
CINT arredonda para o inteiro mais proximo; ela não trunca.
Exemplo:

PRINT CINT(34.51)
PRINT CINT(34.49)

A execução deste programa produz a seguinte saída:

35
34

Funções relacionadas: CDBL; CLNS; CSNG; FIX; INT

CIRCLE (Comando)
Desenha um circulo ou uma elipse com raio e centro especificados.
Sintaxe:
CIRCLE [STEP] (x,y) raio [,[cor][ângulo_início][,[ângulo_fim][,razão_visual]]]]
Observações:
STEP é uma palavra-chave opcional que, se presente, indica que os valores x e y são relativos à posição corrente do cursor gráfico.
x,y são as coordenadas do centro do círculo.
raio é o raio do círculo no sistema de coordenadas corrente.
cor é a cor da circunferência. O círculo não é preenchido.
ângulo_início é o ângulo inicial para o arco, em radianos. Se omitido, será 0 (zero).
ângulo_fim é o ângulo final para o arco, em radianos. Se omitido, será 2π.
razão_visual é a razão entre o comprimento do eixo y e o comprimento do eixo x. Trocando a razão visual, você pode criar elipses.
Exemplo:

'Preenche a tela com círculos aleatórios
SCREEN 1
FOR i = 1 TO 100
  x = INT(320 * RND)
  y = INT(200 * RND)
  raio = INT(100 * RND)
  CIRCLE (X,Y), raio
NEXT i
SCREEN 0

Funções relacionadas: POINT
Comandos relacionados: COLOR; DRAW; LINE; PRESET; PSET; SCREEN

CLEAR (Comando)
Inicializa todas as variáveis do programa, fecha todos os arquivos e opcionalmente define o tamanho da pilha.
Sintaxe:
CLEAR [,, tamanho_pilha]
Observações:
CLEAR fecha todos os arquivos abertos, zera todas as variáveis numéricas e matrizes e deixa todas as variáveis string com comprimento zero.
Se seu programa usa recursão ou executa bastante níveis de chamadas a sub-rotinas, você poderá precisar aumentar o tamanho da pilha do programa.
tamanho_pilha é o tamanho da pilha em bytes. O tamanho da pilha deve ser precedido por duas vírgulas, como mostrado.
Não execute CLEAR dentro de uma sub-rotina.
Exemplo:

'Inicializa variáveis e cria uma pilha de 4.096 bytes
CLEAR,, 4096

CLNG (Função)
Arredonda uma expressão numérica para um inteiro longo mais próximo (4 bytes).
Sintaxe:
CLNG(expressão_numérica)
Observações:
expressão_numérica deve resultar em um valor entre -2.147.483.648 a 2.147.483.647. Se o resultado estiver fora destes limites, ocorrerá um erro em tempo de execução.
Exeemplo:

PRINT CLNG(338457.8)
PRINT CLNG(2147358.28)

A execução deste programa produz a seguinte saída:

338458
2147358

Funções relacionadas: CDBL; CINT; CSNG; FIX; INT

CLOSE (Comando)
Fecha um ou mais arquivos abertos pelo comando OPEN.
Sintaxe:
CLOSE [[#]nr_arquivo [,[#]nr_arquivo]]…
nr_arquivo é um número de arquivo associado com um arquivo específico por meio do comando OPEN.
Você pode especificar mais de um número de arquivo em um mesmo comando CLOSE.
CLOSE, sem especificar nenhum número de arquivo, fecha todos os arquivos abertos.
Uma vez que você fechou um número de arquivo, não poderá mais usar o número de arquivo para operações de leitura ou gravação até que abra um novo arquivo.
Os comandos CLEAR, END, RESET, RUN e SYSTEM fecham os arquivos automaticamente. Contudo, para manter os programas coerentes, você deve emitir um comando CLOSE para cada comando OPEN em seu programa.
Exemplo:

OPEN "TESTE.DAT" FOR OUTPUT AS #1
OPEN "NOMES.DAT" FOR OUTPUT AS #2
PRINT #1, "Isto é um teste"
PRINT #2, "José Maria"
CLOSE #1, #2

Comandos relacionados: OPEN; RESET

CLS (Comando)
Limpa a tela.
Sintaxe:
CLS [{0|1|2}]
Observações:
Dependendo da região da tela que você deseja limpar, CLS permite quatro opções:
Comando Resultado
CLS    
Limpa a região ativa de texto ou gráfico.
CLS 0   Limpa a tela de texto e gráfico inteira.
CLS 1   Limpa apenas a região ativa gráfica.
CLS 2   Limpa apenas a região ativa de texto, deixando a última linha da tela inalterada.
Comandos relacionados: VIEW; VIEW PRINT; WINDOW

COLOR (Comando)
Define a cor da tela.

Sintaxe:
COLOR [cor_ativa][,cor_fundo][,moldura]
COLOR [cor_ativa][,paleta]
COLOR [cor_ativa][,cor_fundo]
COLOR [cor_ativa]

(Modo de tela 0)
(Modo de tela 1)
(Modo de tela 7-10)
(Modo de tela 12-13)

Observações:
O comando COLOR permite que você defina as cores ativa e de fundo no modo texto, bem como paletas de cores no modo gráfico.
Veja o comando SCREEN para detalhes sobre cada modo de tela.
No modo de tela 0, você pode definir a cor ativa para texto como uma de 16 cores (0 a 15). Para usar a versão piscante da cor, adicione o valor 16 à cor, resultando um valor entre 16 e 31. A moldura da tela background deve ser um valor de cor de 0 a 15.
No modo de tela 1, você pode especificar um valor de paleta no intervalo de 0 a 255. A paleta determina qual de dois conjuntos de cores usar no modo gráfico.
Nos modos de tela 7 a 10, a cor ativa é um número de atributo e a cor de fundo é um número de cor.
Nos modos de tela 12 a 13, a cor ativa é um número de atributo. Você não pode especificar a cor de fundo.
Exemplo:

SCREEN 0
FOR icolor% = 0 TO 31
  COLOR icolor%
  PRINT "A cor ativa é:"; icolor%
  espera$ = INPUT$(1)
NEXT icolor%

Funções relacionadas: SCREEN
Comandos relacionados: PAINT; PALETTE

COM (Comando)
Habilita ou desabilita a intercepção de eventos relativos à comunicação de dados em uma determinada porta.
Sintaxe:
COM(n) ON
ou
COM(n) OFF
ou
COM(n) STOP
Observações:
n é o número da prota de comunicação (1 ou 2).
COM ON habilita a intercepção de eventos relativos à comunicação de dados. Se um caractere chega à porta, seu programa executará a sub-rotina definida pelo comando ON COM.
COM OFF desabilita a intercepção de eventos relativos à comunicação de dados. Caracteres que chegarem à porta serão ignorados.
COM STOP evita a intercepção de eventos relativos à comunicação de dados até que o programa execute um comando COM ON. Os eventos serão processados uma vez que a intercepção esteja habilitada.
Exemplo:

'Habilita intercepção de eventos na porta 1
COM(1) ON

Comandos relacionados: ON event GOSUB

COMMAND$ (Função)
Devolve uma string contendo a parte excedente da linha de comando usada para chamar o programa.
Sintaxe:
COMMAND$
Observações:
COMMAND$ devolve a parte da linha de comando que segue o nome do seu programa. COMMAND$ elimina espaços em branco e converte todas as letras minúsculas em maiúsculas.
O menu Run do Quick-BASIC permite que você especifique uma linha de comando para ser usada enquanto estiver no ambiente Quick-BASIC (ambiente interpretado). COMMAND$ é útil para repassar dados entre programas encadeados com SHELL.
Exemplo:

'Código para o programa compilado (TESTE-1.EXE) que chamará outro (TESTE-2.EXE), repassando dados (brasileiro)
CLS                                            'Limpa a tela
PRINT "Eu sou ";                               'Exibe a string "Eu sou"
SHELL "TESTE-2.EXE brasileiro"                  'Chama o segundo programa (TESTE-2.EXE) levando o complemento "brasileiro"
'Código para o programa (TESTE-2.EXE) que completará o serviço do programa que o chamou
a$ = COMMAND$                                  'A variável a$ assume a parte excedente da linha de comando  
PRINT a$                                       'O conteúdo da variável a$ é exibido
PRINT "Pressione qualquer tecla pra continuar" 'Exibe uma mensagem de aviso ao operador
b$ = INPUT$(1)                                 'Aguarda uma tecla ser pressionada 

A execução do primeiro programa (TESTE-1.EXE) produz a seguinte saída:

Eu sou BRASILEIRO
Pressione qualquer tecla pra continuar

A execução somente do segundo programa (TESTE-2.EXE) produz a seguinte saída:


Pressione qualquer tecla pra continuar

COMMON (comando)
Define variáveis para serem globais (compartilhadas) dentro de um módulo ou entre programas encadeados. COMMON requer o módulo BRT (Bus Rapid Transit) nos programas compilados não Stand-Alone (autônomo) e encadeados com CHAIN.
COMMON não compartilha dados entre programas compilados no modo Stand-Alone (autônomo).
Sintaxe:
COMMON [SHARED] [/nome_bloco-common/] lista _variáveis
Observações:
A palavra reservada SHARED indica que as variáveis especificadas serão compartilhadas por todos os subprogramas e funções de um módulo.
nome_bloco_common permite que você agrupe variáveis relacionadas em um bloco com nome. Para acessar uma variável, uma rotina deve conhecer o nome do bloco. Você pode usar blocos com nome para encadeamento de programas.
lista_variáveis é a lista de variáveis globais, com os nomes das variáveis separados por vírgulas. Quick-BASIC permite que você especifique variáveis como:
nome_variável[( )][AS tipo]
Comandos COMMON devem aparecer antes de qualquer comando executável em seu programa. Quick-BASIC associa as variáveis em um bloco pela sua posição, não pelo nome.
Quick-BASIC permite que você coloque os seguintes comandos não executáveis antes de um comando COMMON:
COMMON, CONST, DATA, DECLARE, DEFtype, DIM (matrizes estáticas), OPTION BASE, REM, SHARED, STATIC, TYPE…ENDTYPE
Exemplo:

'Código para o programa TESTE-1.BAS que chamará o programa TESTE-2.BAS, repassando os dados das variáveis a, b, c 
COMMON a, b, c              'Indica as variáveis cujos conteúdos são compartilhados. O conteúdo de d não será compartilhado
a = 1: b = 2: c = 3: d = 4  'Dá valores para as variáveis
CHAIN "TESTE-2.BAS"         'Chama o programa TESTE-2.BAS encadeado com CHAIN
'Código para "TESTE-2.BAS" (quando chamado por TESTE-1.BAS não receberá o conteúdo para a variável k)
COMMON x, y, z, k           'Receberá o compartilhamento para as variáveis indicadas
PRINT x; y; z; k            'A variável k será zero quando TESTE-2.BAS for chamado por TESTE-1.BAS

A execução deste programa produz a seguinte saída:

1 2 3 0

CONST (Comando)
Define uma constante simbólica.
Sintaxe:
CONST nome_símbolo = expressão[, nome_símbolo = expressão]…
Observações:
Constantes permitem que seus programas usem nomes simbólicos no lugar de números ou strings.
nome_símbolo é o nome que a constante terá ao longo de seu programa. Você não pode trocar o valor de uma constante uma vez que ela tenha sido definida.
expressão é uma expressão numérica ou string atribuída à constante. Você não pode usar variáveis ou funções na expressão.
Constantes definidas em um subprograma ou função são locais (estão presas) ao subprograma ou função.
CONST é semelhante a LET, sendo que em CONST não precisamos definir o tipo de variável.
Exemplo:

CONST nome = "Maria"
CONST verdadeiro = 1
CONST diasporsemana = 7
DIM dias(diasporsemana)

COS (Função)
Devolve o co-seno do ângulo especificado.
Sintaxe:
COS(ângulo)
Observações:
ângulo é o ângulo para o qual você quer achar o co-seno.
Você pode expressar um ângulo em graus ou radianos. As rotinas trigonométricas do Quick-BASIC suportam apenas radianos. Para converter graus em radianos, use a seguinte equação: radianos = 3.141593 * (graus / 180)
Exemplo:

angulo = 785
PRINT "O co-seno de"; angulo; "radianos é"; COS(angulo)

A execução deste programa produz a seguinte saída:

O co-seno de 785 radianos é .9217746

Funções relacionadas: ATN; SIN; TAN

CSNG (Função)
Converte uma expressão numérica para um valor de precisão simples.
Sintaxe:
CSNG(expressão_numérica)
Observações:
expressão_numérica é qualquer expressão numérica.
Usar CSNG é equivalente a atribuir a expressão a uma variável de precisão simples.
Valores de precisão simples possuem sete dígitos significativos.
Exemplo:

a# = 6
b# = 7
PRINT a# / b#
PRINT CSNG(a# / b#)

A execução deste programa produz a seguinte saída:

.857142857142857
.8571429

Funções relacionadas: CDBL; CINT; CLNG; FIX; INT

CSRLIN (Função)
Devolve o número da linha da posição do cursor.
Sintaxe:
CSRLIN
Observações:
CSRLIN devolve o número da linha da posição do cursor. POS retorna o número da coluna do cursor.
Exemplo:

'Salva linha e coluna do cursor
salvalinha = CSRLIN
salvacoluna = POS(0)
'Move o cursor para linha 10 e coluna 20
LOCATE 10, 20: PRINT "Mensagem em 10,20"
'Restaura a posição anterior do cursor
LOCATE salvalinha, salvacoluna

Funções relacionadaas: POS
Comandos relacionados: LOCATE

CURDIR$()

CURRENCY (Palavra-Chave)
Especifica uma variável de valor numérico monetário para declaração de variáveis ou lista de parâmetros… Veja DOUBLE.

CVC (Função)
Converte uma string de 8 bytes (criada por MKC$) em um valor monetário com até 4 casas decimais.
Sintaxe:
CVC(string_oito_bytes)
Exemplo:

BUF% = FREEFILE
OPEN "FOLHAPAG.DAT" FOR RANDOM SHARED AS #BUF% LEN = 40
FIELD #BUF%, 24 AS nome$, 8 AS diaria$, 8 as valor$
GET #BUF%, 1
PRINT "Empregado: "; nome$
PRINT "Quantidade de diárias:"; CVC(diaria$)
PRINT "Valor da diária:"; CVC(valor$)
PRINT "Valor total:"; CVC(diaria$) * CVC(valor$) 
CLOSE #BUF%

Funções relacionadas: CVD; CVI; CVL; CVS; MKC$

CVD (Função)
Converte uma string de 8 bytes (criada por MKD$) em um valor de dupla precisão.
CVD(string_oito_bytes)
Exemplo:
Veja CVC (Função)
Funções relacionadas: CVC; CVI; CVL; CVS; MKD$

CVI (Função)
Converte uma string de 2 bytes (criada por MKI$) em um valor inteiro de -32.768 até 32.767.
Sintaxe:
CVI(string_dois_bytes)
Exemplo:
Veja CVC (Função)
Funções relacionadas: CVC; CVD; CVL; CVS; MKI$

CVL (Função)
Converte uma string de 4 bytes (criada por MKL$) em um valor inteiro longo de -2.147.483.648 até 2.147.483.648.
CVL(string_quatro_bytes)
Exemplo:
Veja CVC (Função)
Funções relacionadas: CVC; CVD; CVI; CVS; MKL$

CVS (Função)
Converte uma string de 4 bytes (criada por MKS$) em um valor de precisão simples com 7 dígitos significativos.
CVS(string_quatro_bytes)
Exemplo:
Veja CVC (Função)
Funções relacionadas: CVC; CVD; CVI; CVL; MKS$


┌─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┐
ABCDEFGHI-JKLMNOPQRSTUVWX-Z
└─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┘
DATA (Comando)
Armazena constantes numéricas ou strings a serem lidas com o comando READ. Do inglês, DATA significa “DADOS”.
Sintaxe:
DATA constante[, constante]…
constante é uma constante numérica ou string colocada no corpo do programa, fazendo parte do script (codificação).
O comando READ acessa os comandos DATA na ordem em que eles aparecerem em seu programa. O comando RESTORE permite que seu programa releia comandos DATA quando necessário.
O tipo da variável em um comando READ deve coincidir com o tipo da constante no comando DATA.
DATA poderá ser colocado em qualquer parte do programa principal, mas não poderá ser colocado em subprogramas (SUB) ou funções (FUNCTION). O comando READ pode ser colocado em SUB ou FUNCTION, e lerá DATA do programa principal.
Exemplo:

DATA 1, 2.2345, "ANO", "2015"
READ a%, b#, c$, d$
PRINT a%; b#; c$; "-"; d$

A execução deste programa produz a seguinte saída:

1   2.2345 ANO-2015

Comandos relacionados: READ; RESTORE

DATE$ (Função)
Devolve uma string contendo a data atual no formato mm-dd-aaaa.
Sintaxe:
DATE$
Observações:
A função DATE$ devolve a data correntre. O comando DATE$ define (atualiza) a data do sistema (computador).
DATE$ devolve a data no formato MÊS-DIA-ANO. Para exibir no formato brasileiro use LEFT$, MID$, RIGHT$.
Exemplo:

PRINT DATE$                                                    'Exibe a data lida do calendário eletrônico do computador
hoje$ = MID$(DATE$, 4, 3) + LEFT$(DATE$, 3) + RIGHT$(DATE$, 4) 'A variável hoje$ assume a data no formato brasileiro
PRINT hoje$                                                    'Exibe a data no formato brasileiro

A execução deste programa produz a seguinte saída:

08-30-2015
30-08-2015

Comandos relacionados: DATE$

DATE$ (Comando)
Define (determina) a data do sistema (computador) no formato MÊS-DIA-ANO.
Sintaxe:
DATE$ = string_com_a_data
Observações:
string_com_a_data é uma string contendo a data desejada no formato “mm-dd-aaaa”, onde “mm” é o mês (1 a 12), “dd” é o dia (1 a 31), e “aaaa” é o ano (1980 a 2099).
Se você especificar apenas os últimos dois dígitos do ano, DATE$ assume que os primeiros dois algarismos são “19” (1900 + os dois dígitos (XX) especificados).
DATE$ permite que você use tanto hífens (-) como barras (/) para separar os campos da data.
Exemplo

DATE$ = "12-25-89"
DATE$ = "05-14-2015"
DATE$ = "08/31/1995"

Funções relacionadas: DATE$

DECLARE (Comando)
Declara um procedimento e determina ao compilador que faça a verificação de tipos para cada parâmetro.
Sintaxe:
DECLARE {FUNCTION|SUB} nome_rotina [CDECL][ALIAS “nome_alias”] [([lista_argumentos])]
Observações:
O comando DECLARE determina ao compilador que garanta que os tipos dos parâmetros passados a um procedimento coincidam com os tipos esperados pelo procedimento.
DECLARE é necessário apenas quando você não usa CALL ou quando chama uma função definida em outro módulo.
A palavra reservada FUNCTION indica que a rotina é uma função; analogamente, SUB indica um subprograma.
nome_rotina é o nome da função ou subprograma.
A palavra reservada CDECL indica que a rotina usa a convenção de chamada de C.
A palavra reservada ALIAS indica que a rotina tem um nome diferente – nome_alias – dentro do arquivo objeto.
lista_argumentos é uma lista opcional de parâmetros separados por vírgulas. Para que o compilador verifique os tipos, especifique os argumentos da seguinte forma: nome_variável [AS tipo]
Você pode especificar BYVAL em uma lista de argumentos para passar o parâmetro por valor ou SEG para passar o parâmetro usando endereços distantes.
Tipos válidos incluem INTEGER, LONG, SINGLE, DOUBLE, STRING, ANY, ou um tipo definido pelo usuário. ANY permite qualquer tipo para o parâmetro.
Exemplo:
Veja comandos CALL; CALLS
Comandos relacionados CALL; CALLS

DEF FN (Comando)
Define uma função.
Sintaxe:
DEF FNnome [(lista_argumentos)] = expressão
ou
DEF FNnome [(lista_argumentos)]
    FNnome = expressão
    [EXIT DEF]
END DEF
Observações:
Nomes de funções definidas devem começar com FN e podem conter até 40 caracteres. O símbolo (%, &, !, #, $) no fim do nome da função indica o tipo (inteira, inteiro longo, precisão simples, precisão dupla, string) do valor que a função devolve:
Para que uma função devolva um valor, a mesma deve atribuir seu resultado para o nome da função.
lista_argumentos é uma lista dos parâmetros da função separados por vírgulas, como: nome_argumento [AS tipo]
Você não pode usar uma função antes que seu programa a defina, nem usar função DEF FN recursivamente.
Exemplo:

DEF FNsum$ (a AS INTEGER, b AS INTEGER) = STR$(a) + " +" + STR$(b) + " =" + STR$(a + b)
DEF FNmax (a AS INTEGER, b AS INTEGER, c AS INTEGER)
  IF a > b THEN max = a ELSE max = b
  IF max > c THEN FNmax = max ELSE FNmax = c
END DEF
PRINT FNsum$(3, 5)
a% = 4: b% = 5: c% = 3
PRINT "Entre"; a%; b%; c%; "o maior é"; FNmax(a%, b%, c%)

A execução deste programa produz a seguinte saída:

3 + 5 = 8
Entre 4 5 3 o maior é 5

Comandos relacionados: EXIT; FUNCTION; STATIC

DEF SEG (Comando)
Define o endereço do segmento corrente para os usos subseqüente da função PEEK e dos comandos BLOAD, BSAVE, CALL ABSOLUTE e POKE.
Sintaxe:
DEF SEG [= endereço]
observações:
endereço é uma expressão inteira no intervalo de 0 a 65.535. Se você omitir endereço, Quick-BASIC usa o segmento de dados BASIC.
Exemplo:
Veja o comando CALL ABSOLUTE (Comando), ou o exemplo abaixo.

'Copia uma região da tela-texto e cola posteriormente
DECLARE SUB TELA(I, L1, C1, L2, C2, TL$)
RANDOMIZE TIMER                     'Inicializa a função RND pelo relógio. garante aleatoriedade
FOR I = 1 TO 2000
  COLOR INT(RND * 15), INT(RND * 7) 'Seleciona cores aleatórias
  PRINT CHR$(32 + RND * 125);       'Preenche a tela com caracteres aleatorios
NEXT
CALL TELA(0, 1, 1, 25, 80, TL$)     'Copia o conteúdo da tela
SLEEP 5: CLS: SLEEP 5               'Limpa a tela, dá um tempo para visualização
CALL TELA(1, 1, 1, 25, 80, TL$)     'Cola o conteúdo anteriormente copiado
SUB TELA (I, L1, C1, L2, C2, TL$) 'Subprograma que copia e cola imagens da tela texto (SCREEN 0)
'I=0 copia; I=1 cola; L1=linha-sup.; C1=coluna-esq.; L2=linha-inf.; C2=coluna-dir.; TL$=assume a imagem da tela
DEF SEG = &HB800 'Define o segmento da memória de vídeo (&HB800)
X% = 0: IF I = 0 THEN IL% = (L1 - 1) * 160 - 1: FL% = IL% + (C2 * 2): IL% = IL% + (C1 * 2 - 1): TL$ = STRING$((FL% - IL% + 1) * (L2 - L1 + 1), 32)
FOR L% = L1 TO L2 'Copia/Recoloca a Janela
  IL% = (L% - 1) * 160 - 1: FL% = IL% + (C2 * 2): IL% = IL% + (C1 * 2 - 1)
  FOR C% = IL% TO FL%
    X% = X% + 1: IF I = 0 THEN MID$(TL$, X%, 1) = CHR$(PEEK(C%)) ELSE POKE C%, ASC(MID$(TL$, X%, 1))
  NEXT
NEXT: DEF SEG 'Retorna ao segmento corrente
END SUB

Funções relacionadas: PEEK
Comandos relacionados: BLOAD; BSAVE; CALL ABSOLUTE; POKE

DEFDBL (Comando)
Define dupla precisão como o tipo de dados a ser usado para variáveis cujos nomes comecem com uma letra no intervalo especificado, quando o tipo não for especificado explicitamente.
Sintaxe:
DEFDBL letra[-última_letra][, letra[-última_letra]]…
Observações:
letra e última_letra são um intervalo de letras a ser associado a um tipo. Quic-Basic não faz distinção entre variáveis com letras maiúsculas e minúsculas.
Se o nome da variável incluir %, &, !, #, $, Quick-Basic ignorará o tipo de dados indicado por DEFDBL.
Exemplo:

DEFDBL a-j

Comandos relacionados: DEFCUR; DEFINT; DEFLNG; DEFSNG; DEFSTR

DEFINT (Comando)
Define inteiro como o tipo de dados a ser usado para variáveis cujos nomes comecem com uma letra no intervalo especificado, quando o tipo não for especificado explicitamente.
Sintaxe:
DEFINT letra[-última_letra][, letra[-última_letra]]…
Observações:
Veja DEFDBL.
Exemplo:

DEFINT x-z

Comandos relacionados: DEFDBL; DEFCUR; DEFLNG; DEFSNG; DEFSTR

DEFLNG (Comando)
Define inteiro longo como o tipo de dados a ser usado para variáveis cujos nomes comecem com uma letra no intervalo especificado, quando o tipo não for especificado explicitamente.
Sintaxe:
DEFLNG letra[-última_letra][, letra[-última_letra]]…
Observações:
Veja DEFDBL.
Exemplo:

DEFLNG k-n, p-q

Comandos relacionados: DEFDBL; DEFCUR; DEFINT; DEFSNG; DEFSTR

DEFSNG (Comando)
Define precisão simples como o tipo de dados a ser usado para variáveis cujos nomes comecem com uma letra no intervalo especificado, quando o tipo não for especificado explicitamente.
Sintaxe:
DEFSNG letra[-última_letra][, letra[-última_letra]]…
Observações:
Veja DEFDBL.
Exemplo:

DEFSNG t-w

Comandos relacionados: DEFDBL; DEFINT; DEFLNG; DEFCUR; DEFSTR

DEFSTR (Comando)
Define string como o tipo de dados a ser usado para variáveis cujos nomes comecem com uma letra no intervalo especificado, quando o tipo não for especificado explicitamente.
Sintaxe:
DEFSTR letra[-última_letra][, letra[-última_letra]]…
Observações:
Veja DEFDBL.
Exemplo:

'As variáveis começadas com "d" e "h" serão strings
DEFSTR d, h
dia = MID$(DATE$, 4, 3) + LEFT$(DATE$, 3) + RIGHT$(DATE$, 4)
hora = TIME$
PRINT "Estamos no dia: "; dia; ", às: "; hora; " horas."

A execução deste programa produz a seguinte saída:

Estamos no dia: 01-09-2015, às: 15:21:51 horas.

Comandos relacionados: DEFCUR; DEFDBL; DEFINT; DEFLNG; DEFSNG;

DEFCUR
Define valores monetário, com precisão de até 15 dígitos significativos e o máximo de 4 casas decimais, como o tipo de dados a ser usado para variáveis cujos nomes comecem com uma letra no intervalo especificado, quando o tipo não for especificado explicitamente.
Sintaxe:
DEFCUR letra[-última_letra][, letra[-última_letra]]…
Observações:
Veja DEFDBL.
Exemplo:

DEFCUR s-u

Comandos relacionados: DEFDBL; DEFINT; DEFLNG; DEFSNG DEFSTR

DIM (Comando)
Declara uma matriz e aloca memória para ela.
Sintaxe:
DIM [SHARED] nome_variável[(índices)][AS tipo][,nome_variável[(índices)][AS tipo]]
Observações:
A palavra reservada SHARED permite aos subprogramas e funções compartilhar a mesma variável sem a passagem da mesma como parâmetros.
nome_variável é o nome da matriz.
índices são as dimensões da matriz. Caso você não os indique, Quick-Basic usa índices de 0 a 10. Você pode determinar o limite superior e inferior para cada variável, como mostrado aqui:

DIM A(0 TO 8)
DIM B(1 TO 10)

Se você especificar apenas um índice, Quick-Basic assume que ele é o limite superior e usa 0 como limite inferior, a menos que se inclua um comando OPTION BASE.
Para dimensionar várias matrizes, você poderá usar apenas um comando DIM e separar as variáveis com vírgulas.
Para matrizes multidimensionais, simplesmente separe os índices de cada dimensão da matriz com vírgulas:

DIM casa$(10), quarto(10), valor(10) 'Cria 3 matrizes com 11 elementos (0 a 10) para cada matriz 
DIM caixa(3, 3)                      'Cria uma matriz bidimensional de 16 elementos (4 em cada dimensão)
DIM caixagrande(1 to 10, 1 to 10)    'Cria uma matriz bidimensional de 100 elementos (10 em cada dimensão)

O número máximo de dimensões para uma matriz é 60.
Tipos válidos incluem INTEGER, LONG, SINGLE, DOUBLE, STRING.

DIM a(25 TO 100)
DIM b(1 TO 10, 1 TO 5) AS DOUBLE
TYPE tarefa
  dia AS STRING * 10
  horas AS INTEGER
END TYPE
DIM diatrabalho AS tarefa

Comandos relacionados: OPTION BASE

DIR$ (Função)
Devolve o(s) nome(s) de arquivo(s) que corresponda ao padrão especificado.
Sintaxe:
DIR$ [(especificação_de_arquivo$)]
Observações:
especificação_de_arquivo$ é uma string que especifica o caminho e/ou nome de arquivo.
O caminho e o nome do arquivo podem incluir um drive e caracteres_curingas (:, \, *, /…) do DOS.
Uma vez que DIR$(especificação_de_arquivo$) seja executado, o ponteiro de leitura buscará e irá ler sequencialmente cada um dos nomes de arquivo até o último, cada vez que a instrução DIR$, sem mais a especificação_de_arquivo, for executada.
O argumento (especificação_de_arquivo$) é o que faz o ponteiro de leitura sempre reiniciar a leitura a partir do começo.
Exemplo:

DIRET$ = "C:\*.*"                  'String com o caminho para a pasta (diretório)
NOMES$ = ""                        'Limpa a variável que acumulará os nomes dos arquivos
QUANT% = 0                         'Zera o acumulador de contagem de quantidade de arquivos
A$ = DIR$(DIRET$)                  'Acha o caminho e lê o primeiro arquivo
DO UNTIL A$ = ""                   'Executa o loop enquanto tiver arquivos pra ser identificado
  NOMES$ = NOMES$ + A$ + CHR$(32)  'Acumula os nomes dos arquivos na variável NOMES$
  QUANT% = QUANT% + 1              'Conta a quantidade de arquivos identificados
  A$ = DIR$                        'Lê cada um dos nomes de arquivos. Retornará vazio ao final
LOOP                               'Fecha o loop enquanto a variável A$ retornar não vazia
PRINT NOMES$                       'Exibe os nomes dos arquivos separados por um espaço branco
PRINT QUANT%; "ARQUIVOS"           'Exibe a quantidade de arquivos no diretório especificado

A execução deste programa irá listar no vídeo todos os arquivos da raiz do disco “C:” e ao final exibirá a quantidade de arquivos.
Funções relacionadas: CHDIR; CHDRIVE; CURDIR$; FILES MKDIR; RMDIR;

DO [UNTIL] (Comando)
Repete um conjunto de instruções até que uma condição se torne verdadeira.
Sintaxe:
DO
  comandos
LOOP UNTIL expressão_booleana
ou
DO UNTIL expressão_booleana
  comandos
LOOP
Observações:
expressão_booleana é uma expressão que resulta em verdadeiro ou falso, tal como 1 > 100.
A primeira forma do comando testa primeiro a expressão booleana. Se a expressão é verdadeira, Quick-Basic pula os comandos dentro da repetição e continua a execução no primeiro comando após o mesmo. Se a expressão é falsa, Quick-Basic executa os comandos dentro da repetição até que a expressão seja verdadeira.
A segunda forma do comando executa primeiro os comandos dentro da repetição e então testa a expressão booleana. Se a expressão é verdadeira, Quick-Basic continua a execução no primeiro comando após a repetição.
Exemplo:

i = 0
DO
  PRINT i;
  i = i + 1
LOOP UNTIL i = 100

A execução deste programa produz a seguinte saída:

0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21
22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41
42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61
62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81
82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99

Comando relacionado: DO WHILE

DO WHILE (Comando)
Repete um conjunto de instruções enquanto uma determinada condição for satisfeita.
Sintaxe:
DO WHILE expressão_booleana
  comandos
LOOP
ou
DO
  comandos
LOOP WHILE expressão_booleana
Observações:
expressão_booleana é uma expressão que resulta em verdadeiro ou falso, tal como N$ = “SAIR”.
A primeira forma do comando testa primeiro a expressão booleana. Se a expressão é verdadeira, Quick-Basic executa os comandos dentro da repetição até que a expressão seja falsa. Quando a expressão é falsa, o programa continua sua execução no primeiro comando após a repetição.
A segunda forma do comando executa primeiro os comandos dentro da repetição e então testa a expressão booleana. Se a expressão é verdadeira, Quick-Basic repetirá os comandos; caso contrário, a execução continua no primeiro comando após a repetição.
Exemplo:

i = 0
DO WHILE i < 100
  PRINT I
  i = i + 1
LOOP

Comando relacionado: DO UNTIL

DOUBLE (Especificador de tipo)
Especifica o tipo de variável numérica como sendo de dupla precisão.
Os tipos de variáveis são: INTEGER, LONG, SINGLE, DOUBLE, STRING, CURRENCY, ou um tipo definido pelo usuário com o comando TYPE.
INTEGER: Uma variável numérica de valor inteiro (sem ponto flutuante), de 16-bit (2 bytes) entre -32768 a +32767.
LONG: Uma variável numérica de valor inteiro-longo (sem ponto flutuante), de 32-bit (4 bytes) entre -2147483648 a +2147483648.
SINGLE: Uma variável numérica de simples precisão com ponto flutuante, de 32 bit (4 bytes) com até 7 dígitos significativos.
DOUBLE: Uma variável numérica de dupla precisão com ponto flutuante, de 64 bit (8 bytes) com até 15 dígitos significativos.
STRING: Uma variável string (alfanumérica) com até 32767 caracteres.
CURRENCY: Uma variável numérica de valor monetário com ponto flutuante de até 4 casas decimais, de 64 bit (8 bytes) com até 15 dígitos significativos.
Veja também: AS; COMMON; DECLARE; DEF FN; DIM; FUNCTION; SHARED; STATIC; SUB; TYPE

DRAW (Comando)
Desenha um determinado objeto dado por uma expressão string.
Sintaxe:
DRAW expressão_string
Observações:
DRAW usa uma string contendo comandos gráficos para desenhar um objeto. A string pode conter comandos de cursor, cor e escala.
Comandos de movimentação do cursor são os seguintes:
Comando Descrição
U [n]   n unidades para cima
D [n]   n unidades para baixo
L [n]   n unidades para esquerda
R [n]   n unidades para direita
E [n]   n unidades para cima e para direita
F [n]   n unidades para baixo e para direita
G [n]   n unidades para baixo e para esquerda
H [n]   n unidades para cima e para esquerda
M x,y   Movimenta para x,y

DRAW permite que as funções de movimentação do cursor sejam precedidas por B e N:
Comando  Descrição
B       Movimenta o cursor, mas não desenha pontos
N       Movimenta o cursor, mas retorna à posição original quando estiver pronto o
        desenho

Comandos de ângulo, cor e escala são os seguintes:
Comando        Descrição
A rotação      Define um ângulo de rotação em graus:
               0 = 0º, 1 = 90º, 2 = 180º, 3 = 270º
TA graus       Gira um ângulo (-360º a 360º)
C  cor         Define a cor
S  n           Define o fator de escala para as unidades
P  cor,limite  Preenche o interior do objeto delimitado pela cor limite com a cor cor

Exemplo:

'Desenha uma caixa e a preenche
SCREEN 1             'seleciona a tela gráfica-1
DRAW "C3"            'define a cor ciano
DRAW "L2OU20R20D20"  'desenha a caixa
DRAW "BH10"          'movimenta para dentro da caixa
DRAW "P2,3           'preenche de amarelo a caixa delimitada por ciano 


┌─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┐
ABCDEFGHI-JKLMNOPQRSTUVWX-Z
└─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┘

ELSEIFVeja o comando IF

END IFVeja o comando IF

END (Comando)
Finaliza um programa Quick-Basic.
Sintaxe:
END
Observações:
O comando END é usado com DEF, FUNCTION, IF, SELECT, SUB e TYPE. Esta formas de END serão discutidas nos comandos apropriados.
END sozinho finaliza seu programa e fecha todos os arquivos.
Exemplo:

FOR I = 1 TO 10
  PRINT I;
NEXT I
END

Comandos relacionados: SYSTEM

ENVIRON (Comando)
Muda um item ou coloca um novo no ambiente do DOS.
Sintaxe:
ENVIRON expressão_string
Observações:
O comando ENVIRON espera uma expressão string no mesmo formato que o comando SET do DOS: entry=valor.
A mudança da tabela de ambiente é válida apenas durante a execução do programa.
Exemplo:

ENVIRON "PROGRAMA=TESTE"

A execução deste programa produz a seguinte saída:

TESTE

Função relacionada: ENVIRON$

ENVIRON$ (Função)
Devolve um item do ambiente do DOS.
ENVIRON$(string_item)
ou
ENVIRON$(n)
Observações:
O comando SET do DOS permite que você defina e mostre strings de ambiente da linha de comando do DOS.
A primeira forma de ENVIRON$ permite que seu programa acesse o valor de uma variável de ambiente. string_item é o nome da variável de ambiente desejada.
A segunda forma de ENVIRON$ permite ao seu programa acessar a nésima string string do ambiente.
Se o item especificado não existir, ENVIRON$ devolve uma string vazia.
Exemplo:

PRINT ENVIRON$("PATH")
I = 1
DO WHILE ENVIRON$(I) <> ""
  PRINT ENVIRON$(I)
  I = I + 1
LOOP

Comando relacionado: ENVIRON

EOF (Função)
(End Off File) Testa a condição de fim de arquivo.
Sintaxe:
EOF(número_arquivo)
Observações:
EOF devolve verdadeiro se for atingido o fim do arquivo associado com o número do arquivo especificado; caso contrário, EOF devolve falso.
número_arquivo é o número atribuído para o arquivo no comando OPEN.
Exemplo:

OPEN "\CONFIG.SYS" FOR INPUT AS #1
DO UNTIL EOF(1)
  LINE INPUT #1, IDATA$
  PRINT IDATA$
LOOP
CLOSE #1

Comandos relacionados: CLOSE; OPEN.

EQV (Operador lógico)
Operador lógico de Equivalência.
EQV compara bit a bit duas expressões e devolve um valor em cujo, cada bit corresponde ao resultado da operação conforme a tabela abaixo:

X EQV Y = Z
1     1   1
1     0   0
0     1   0
0     0   1

Operadores relacionados: IMP; AND; OR; NOT; XOR;

ERASE (Comando)
Reinicializa os elementos de uma matriz estática ou desaloca matrizes dinâmicas.
Sintaxe:
ERASE matriz[,matriz]…
Observações:
matriz é o nome da matriz a ser reinicializada ou desalocada.
Para matrizes numéricas estáticas, ERASE atribui 0 a cada elemento; para matrizes string estáticas, ERASE atribui a string vazia a cada elemento.
Para matrizes dinâmicas, ERASE libera a memória utilizada pela matriz especificada.
Exemplo:

DIM A(100)
FOR I = 1 TO 100
  A(I) = I
NEXT I
ERASE A
FOR I = 1 TO 100
  PRINT A(I);
NEXT I

Comandos relacionados: DIM; REDIM

ERDEV (Função)
Devolve um código de erro inteiro do último dispositivo que declarou um erro.
Sistaxe:
ERDEV
Observações:
A rotina de erros críticos do DOS define o valor para ERDEV. O byte menos significativo contém o código do erro (0 a 12); o byte mais significativo contém os bits da palavra de atributos do dispositivo.
Exemplo:

ON ERROR GOTO Handler
:
Handler:
  PRINT "Erro no acesso ao dispositivo ";ERDEV$
  PRINT "Código do erro "; ERDEV
  :

Funções elacionadas: ERDEV$; ERL; ERR
Comandos relacionados: ON ERROR

ERDEV$ (Função)
Devolve uma string contendo o nome do dispositivo que gerou um erro crítico.
Sintaxe:
ERDEV$
Observações:
A rotina de erros críticos do DOS define o valor de ERDEV$
Exemplo:
Veja ERDEV
Funções relacionadas: ERDEV; ERL; ERR
Comandos relacionados: ON ERROR

ERL (Função)
Devolve o número da linha que precede a linha que causa um erro.
Sintaxe:
ERL
Observações:
ERL devolve apenas o número da linha. Ela não retorna rótulos de linha. Se você não estiver usando numeros de linhas, ERL devolve 0.
Exemplo:

1000 handler:
1010 PRINT "Erro de processamento na linha"; ERL
1020 PRINT "Erro número"; ERR
1030 RESUME

Funções relacionadas: ERDEV; ERR
Comandos relacionados: ERROR; ON ERROR; RESUME

ERR (Função)
Devolve o código do último erro que ocorreu.
Sitaxe:
ERR

Observações:
Código Descrição do Erro Código Descrição do Erro
2 Erro de sintaxe 53 Arquivo não encontrado
3 RETURN sem GOSUB 54 Modo de arquivo errado
4 Comando DATA insuficientes 55 Arquivo já aberto
5 Chamada ilegal de função 56 Comando FIELD ativo
6 Estouro numérico 57 Erro de E/S no dispositivo
7 Memória insuficiente 58 Arquivo já existe
9 Índice fora dos limites 59 Comprimento errado de registro
11 Divisão por Zero 61 Disco lotado
13 Conflito de tipos 62 Leitura após o fim de arquivo
14 Espaço insuficiente para strings 63 Número de registro errado
16 Fórmula muito complexa 64 Nome de arquivo errado
19 Falta RESUME 67 Arquivos em excesso
20 Tempo do dispositivo esgotado 68 Dispositivo não disponível
24 Falha no dispositivo 69 Estouro no buffer de comunicação
25 Impressora não corresponde 70 Permissão negada
27 Sem papel 71 Disco não está pronto
39 CASE ELSE esperado 72 Erro na mídia do disco
40 Requer variável 73 Recurso avançado não disponível
50 Estoura de campo (field) 74 Mudança de nome c/discos diferentes
51 Erro interno 75 Erro de acesso de diretório/arquivo
52 Nome ou número de arquivo errado 76 Diretório não encontrado

Exemplo:
Veja ERL.
Funções relacionadas: ERDEV; ERR
Comandos relacionados: ERROR; ON ERROR; RESUME

ERROR (Comando)
Simula a ocorrência de erro do número especificado. Permite ao programador definir seus próprios códigos de erro.
Sintaxe:
ERROR expressão_numérica
Observações:
expressão_numérica é um valor inteiro no intervalo de 0 a 255.
Veja o comando ERR para uma lista dos códigos de erro predefinidos. Para definir seus próprios erro, use um valor de erro não definido.
O comando ERROR atribui o valor do erro específicado para ERR e passa o controle para a rotina de erro.
Exemplo:

ON ERROR GOTO TRATAERRO                                           'desvia para TRATAERRO a qualquer ocorrência de erro
ERROR 222                                                         'Testa a rotina de tratamento de erro com o erro 222
PRINT "Estamos de volta ao fluxo do programa"                     'mensagem exibida após o retorno de TRATAERRO  
END                                                               'Finda o programa
TRATAERRO:                                                        'sub-rotina de tratamento de erro
  PRINT "Esta é a rotina de tratamento de erro, com o erro"; ERR  'avisa ao operador que ocorreu um erro
  LINE INPUT "Tecle ENTER para continuar"; A$                     'mensagem ao operador de como proceder
  RESUME NEXT                                                     'retorna para a próxima instrução

Funções relacionadas: ERDEV; ERL; ERR
Comandos relacionados: ON ERROR; RESUME

EVENT

EXIT (Comando)
Sair de uma repetição <DO ou FOR, função (FUNCTION) ou subprograma (SUB).
Sintaxe: ou EXIT DEF ou EXIT DO ou EXIT FOR ou EXIT FUNCTION ou EXIT SUB
Observações:
Para repetições DO e FOR, a execução continua no primeiro comando após a repetição.
Para funções e subprogramas, a execução continua no comando seguinte ao comando que chamou a função ou sub-rotina.
Exemplo:

J = 30
FOR I = 1 TO 50
  IF I = J THEN EXIT FOR
NEXT I
PRINT "Valor final é"; I

A execução deste programa produz a seguinte saída:

Valor final é 30

EXP (Função)
Devolve a exponencial de uma expressão.
Sintaxe:
EXP(expressão_numérica)
Observações:
EXP devolve a base dos logaritmos naturais (e) elevada à potência determinada pela expressão_numérica.
expressão_numérica deve ser menor ou igual a 88.02969; caso contrário, EXP resulta em um erro de estouro.
Exemplo:

PRINT "Novo salário:"; exp(pagamento)

Função relacionada: LOG


┌─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┐
ABCDEFGHI-JKLMNOPQRSTUVWX-Z
└─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┘
FIELD (Comando)
Define um buffer de arquivo de acesso aleatório.
Sintaxe:
FIELD [#]número_arquivo, tamanho_campo AS variável_str[, tamanho_campo AS variável_str]…
Observações:
número_arquivo é o número definido para o arquivo em seu comando OPEN.
tamanho é o número de caracteres no respectivo campo.
variável_str é o nome da variável string a ser usada na leitura e gravação no arquivo.
Um nome de variável que conste em um comando FIELD não deve aparecer em comandos INPUT ou no lado esquerdo de um operador de atribuição. Se aparecer, a variável deixará de referenciar um buffer de arquivo de acesso aleatório.
A soma dos tamanhos dos campos no comando FIELD não poderá ultrapassar ao tamanho do registro declarado no comando LEN por ocasião da abertura do arquivo (OPEN); entretanto poderá ser menor, deixando com reserva de campo para futuras utilizações.
O uso de variáveis tipo registro é geralmente mais conveniente do que usar o comando FIELD.
Exemplo

OPEN "PRODUTO.DAT" FOR RANDOM SHARED AS #1 LEN = 80
FIELD #1, 76 AS NOME$, 4 AS PRECO$
LSET NOME$ = "CIMENTO POTY": LSET PRECO$ = MKS$(25.30)
PUT #1, 1
LSET NOME$ = "TIJOLO ALVENARIA": LSET PRECO$ = MKS$(.53)
PUT #1, 2
CLOSE #1

A execução deste programa salva no arquivo PRODUTO.DAT a descrição e o preço do CIMENTO no registro Nº1, e do TIJOLO no registro Nº2.
Comandos relacionados: GET; LSET; OPEN; PUT; RSET;

FILEATTR (Função)
Devolve o modo do arquivo ou o indicador do arquivo no DOS de um arquivo aberto.
Sintaxe:
FILEATTR(número_arquivo, info_arquivo)
Observações:
número_arquivo é o número do arquivo, definido em seu comando OPEN.
info_arquivo (1 ou 2) determina a informação devolvida por FILEATTR.

Se info_arquivo é 1, FILEATTR devolve um valor correspondente ao modo de acesso conforme a tabela abaixo:
Valor Modo Valor Modo Valor Modo Valor Modo Valor Modo Valor Modo
1 Entrada 2 Saída 4 Aleatório 8 Append 32 Binário 64 ISAM
Se info_arquivo é 2, FILEATTR devolve o indicador (Alça) do arquivo no DOS.

Exemplo:

OPEN "PRODUTOS.dat" FOR APPEND AS #1
OPEN "CLIENTES.dat" FOR RANDOM AS #2
PRINT " N. Alça Modo"
PRINT 1; TAB(5); FILEATTR(1, 2); TAB(10); FILEATTR(1, 1)
PRINT 2; TAB(5); FILEATTR(2, 2); TAB(10); FILEATTR(2, 1)
CLOSE #1, #2

A execução deste programa produz a seguinte saída:

N. Alça Modo
 1    5      8
 2    6      4

FILES (Comando)
Mostra os nomes dos arquivos no diretório corrente ou em outro especificado.
Sintaxe:
FILES[expressão_string]
Observações:
expressão_string é a expressão string que contém a especificação de arquivos do DOS a serem mostrados. Podem ser usadas especificações ambíguas.
Se você omitir uma especificação de arquivos, FILES mostrará os arquivos do diretório corrente.
Exemplo:

FILES          'Lista todos os arquivos da pasta
FILES "*.BAS"  'Lista todos os qrquivos ".BAS"
FILES "A:"     'Lista todos os arquivos da raiz do drive "A"

FIX (Função)
Devolve a parte inteira de uma expressão de ponto flutuante.
Sintaxe:
FIX(expressão_numérica)
Observações:
expressão_numérica é qualquer expressão numérica. Existem diferenças significativas entre: FIX, INT, CINT.
Exemplo:

PRINT FIX(-10.99); FIX(-10.1)
PRINT INT(-10.99); INT(-10.1)
PRINT CINT(-10.99); CINT(-10.1)

A execução deste programa produz a seguinte saída:

-10 -10
-11 -11
-11 -10

Funções relacionadas: CINT; INT

FOR (Comando)
Repete um conjunto de instruções dentro do loop (laço) FOR-NEXT, tantas vezes quantas especificada no comando FOR.
Sintaxe:
FOR variável_controle = valor_início TO valor_fim [STEP incremento]

conjunto de instruções

NEXT [variável_controle][, variável_controle]…
Observações:
variável_controle é uma variável que é incrementada a cada interação da repetição FOR. Ela controla se a repetição continuará ou será abandonada.
valor_início é o valor inicial que Quick-Basic atribui para a variável_controle.
valor_fim é o valor que a variável_controle deve alcançar antes que a repetição termine.
incremento é a quantidade (passo-a-passo) que Quick_Basic adiciona à variável_controle a cada repetição. O incremento pode ser um valor positivo ou negativo. Se omitir incremento, ele será +1.
O comando NEXT indica ao Quick-Basic que deve incrementar a variável de controle e testar se a mesma é maior que o valor_fim. Se não o for, a execução continua no primeiro comando dentro da repetição; caso contrário, a execução continua no primeiro comando após o comando NEXT.
Exemplo:

'Colhe o alfabeto invertido, ordena e exibe. A 3ª etapa de 2 loop aninhados ordena qualquer desordem
CLS : X = 26: DIM ALFABETO$(1 TO X)                                     'Reserva variável indexada
FOR I = X TO 1 STEP -1                                                  'Loop para
  ALFABETO$(X + 1 - I) = CHR$(64 + I)                                   'colher o alfabeto
NEXT                                                                    'de forma invertida
PRINT "Alfabeto invertido: ";
FOR I = 1 TO X                                                          'Loop para exibir
  PRINT ALFABETO$(I);                                                   'o alfabeto colhido
NEXT                                                                    'anteriormente (invertido)
FOR I = 1 TO X - 1                                                      '◄┬Duplo loop
  FOR J = I + 1 TO X                                                    '◄┘ordenador alfabético
    IF ALFABETO$(I) > ALFABETO$(J) THEN SWAP ALFABETO$(I), ALFABETO$(J) 'ordena
  NEXT                                                                  'fecha o laço J
NEXT                                                                    'fecha o laço I
PRINT : PRINT "Alfabeto ordenado: ";
FOR I = 1 TO X                                                          'Loop para exibir
  PRINT ALFABETO$(I);                                                   'o alfabeto ordenado
NEXT

A execução deste programa produz a seguinte saída:

Alfabeto invertido: ZYXWVUTSRQPONMLKJIHGFEDCBA
Alfabeto ordenado: ABCDEFGHIJKLMNOPQRSTUVWXYZ

Comandos relacionados: EXIT FOR

FRE (Função)
Devolve a quantidade de espaço disponível na pilha, espaço para strings ou memória.
Sintaxe:
FREE(expressão_numérica)
ou
FREE(expressão_string)
Observações:
Se o argumento para FRE é -1, FRE devolve o tamanho em bytes da maior matriz que você pode criar. Se o argumento é -2, FRE devolve o espaço disponível na pilha. Para qualquer outro argumento numérico, FRE devolve a quantidade de espaço disponível para strings.
Se o argumento para FRE é uma expressão string, FRE compacta o espaço livre de strings para um único bloco e devolve o espaço disponível para strings.
Exemplo:

PRINT "Espaço de string"; FRE(" ")
PRINT "Espaço da pilha"; FRE(-2)
PRINT "Espaço de matriz"; FRE(-1)

A execução deste programa produz a seguinte saída:

Espaço de string 65438
Espaço da pilha 2062
Espaço de matriz 265760

FREEFILE (Função)
Devolve o próximo número de arquivo disponível.
Sintaxe:
FREEFILE
Observações:
FREEFILE elimina a necessidade de codificar o número do arquivo literalmente no programa e, consequentemente, o risco de usar um número de arquivo já em uso.
Exemplo:

NA% = FREEFILE
OPEN "CIDADES.DAT" FOR OUTPUT AS #NA%
PRINT #NA%, "Fortaleza"
PRINT #NA%, "Rio de Janeiro"
CLOSE #NA%
SHELL "TYPE CIDADES.DAT"

A execução deste programa produz a seguinte saída:

Fortaleza
Rio de Janeiro

FUNCTION (Comando)
Declara uma função definida pelo usuário.
Sintaxe:
FUNCTION nome_função [(argumentos)] [STATIC]

nome_função = expressão

END FUNCTION
Observações:
nome_função é o nome da função definida pelo usuário. O nome pode terminar com um caractere de declaração de tipo (%,&,!,#m$) para indicar o tipo do valor que ele devolve.
argumentos é uma lista opcional de parâmetros, separados por vírgulas, a serem passados à função.
Para especificar o tipo de cada variável, use a seguinte forma: variável[( )] AS tipo
A palavra reservada STATIC indica ao Quick-Basic que deve manter os valores das variáveis locais da função entre chamadas da função.
Para a função devolver um valor, ela deve atribuir uma expressão ao nome da função em algum ponto.
Exemplo:

DECLARE FUNCTION MIN% (A AS INTEGER, B AS INTEGER)
PRINT "Ninimo de 5 e 3 é"; MIN%(5, 3)
FUNCTION MIN% (A AS INTEGER, B AS INTEGER)
  IF (A < B) THEN
    MIN% = A
  ELSE
    MIN% = B
  END IF
END FUNCTION

A execução deste programa produz a seguinte saída:

Ninimo de 5 e 3 é 3

Comandos relacionados: DECLARE; DEF FN; EXIT; FUNCTION; STATIC; SUB


┌─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┐
ABCDEFGHI-JKLMNOPQRSTUVWX-Z
└─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┘
GET (Comando)(E/S de Arquivo)
Lê um registro de um arquivo de acesso aleatório (randômico).
Sintaxe:
GET [#]número_arquivo[,[número_registro][,variável]]
Observações:
número_arquivo é o número atribuído para o arquivo em seu comando OPEN.
número_registro é o número do registro desejado, de 1 a 2.147.483.647. Se você omitir o número do registro, GET lerá o próximo registro.
variável é o nome da variável na qual GET fornece os dados. Normalmente é usada uma variável tipo registro definida pelo usuário.
Exemplo:

TYPE RegSalario
  nome AS STRING * 20
  salario AS SINGLE
END TYPE
DIM empregado AS RegSalario
OPEN "SALARIO.DAT" FOR RANDOM SHARED AS #1 LEN = LEN(empregado)
GET #1, 1, empregado
PRINT empregado.nome; empregado.salario
CLOSE #1

Funções relacionadas: CVC; CVD; CVI; CVL; CVS; MKC$; MKD$; MKI$; MKL$; MKS$;
Comandos relacionados: FIELD; INPUT; LINE INPUT; LSET PUT; RSET

GET (Comando)(Gráficos)
Armazena uma imagem da tela gráfica em uma matriz.
Sintaxe:
GET [STEP](xesq,ycima)-[STEP](xdir,ybaixo),matriz-[(índice)]
Observações:
GET armazena a imagem da tela contida em um determinado retângulo.
A palavra reservada STEP indica que as coordenadas são deslocamentos relativos ao último ponto desenhado.
matriz é o nome da matriz na qual GET deve armazenar a imagem.
índice é o índice da matriz na qual deve começar o armazenamento da imagem.
Para determinar o número de bytes necessários, use a seguinte fórmula:
4 + INT(((xdir – xesq + 1) * (bits_por_pixel) + 7) / 8) * plano * ((ycima – ybaixo) +1)
O número de bits por pixel e o número de planos dependem da tela em uso, conforme tabela abaixo:

Modo Tela Bit/
Pixel
Plano |
|
Modo Tela Bit/
Pixel
Plano |
|
Modo Tela Bit/
Pixel
Plano |
|
Modo Tela Bit/
Pixel
Plano |
|
Modo Tela Bit/
Pixel
Plano
1 2 1 | 7 1 4 | 9 1 * | 11 1 1 | 13 8 1
2 1 1 | 8 1 4 | 10 1 2 | 12 1 4 |

Exemplo:

GET (10, 20) - (20, 50), MAPA

Comandos relacionados: PUT (Gráficos); SCREEN

GOSUB Comando
Desvia provisoriamente a execução do programa para uma sub-rotina que faz parte do mesmo bloco de programação. As sub-rotinas tem início em uma etiqueta (número_de_linha ou rótulo) e finda quando a lógica de programação encontra um comando RETURN, mesmo que este retorno (RETURN) pertença a outra sub-rotina que fora chamada a partir de um GOTO.
Sintaxe:
GOSUB local
Observações:
local é um número_de_linha ou um rótulo (etiqueta, label) para o qual a execução do programa deve ser desviada.
O desvio provisório se encerra ao encontrar o comando RETURN, retornando à instrução seguinte ao comando GOSUB que chamou, ou para uma etiqueta (números_de_linha ou rótulos) especificada no comando RETURN. O comando GOSUB coloca na PILHA do Quick-Basic o endereço de retomada de retorno, e por isso cada chamada GOSUB necessita encontrar um comando RETURN para desfazer a PILHA que ficará pendente. Se uma sub-rotina chamada por GOSUB chamar outra sub-rotina com mais um GOSUB, a PILHA será incrementada e ficarão pendentes tantos RETURN quantos GOSUB forem executados. Obs.: É comum programadores errarem nessa questão e o programa tomar rumos inesperados, principalmente quando a sub-rotina tem comando GOTO.
GOSUB assemelha-se aos comandos SUB e CALL que dão mais segurança ao programador; entretanto, como GOSUB é desviado para etiquetas no mesmo módulo de programação, participa do conteúdo dos arquivos abertos e de todas as variáveis assim como reconhece todas as demais etiquetas do mesmo módulo. As etiquetas (números_de_linha ou rótulos) não podem ser duplicadas, mesmo que estejam em módulos SUB ou FUNCTION diferentes. GOSUB não reconhece etiquetas de outros módulos.
Exemplo:

PRINT "Eu sou ";
GOSUB 10
END

10 PRINT "brasileiro ";
GOSUB CONTINUA
RETURN

CONTINUA:
PRINT "e gosto de futebol."
RETURN

A execução deste programa produz a seguinte saída:

Eu sou brasileiro e gosto de futebol.

Comandos relacionados: RETURN; SUB

GOTO (Comando
Desvia definitivamente a execução do programa para um determinado número de linha ou rótulo.
Sintaxe:
GOTO local
Observações:
local é o numero_de_linha ou rótulo no qual a execução deve continuar.
GOTO obedece as mesmas regras do comando GOSUB porém, não tem retorno. O desvio é definitivo.
No passado, quando as versões do Basic não possuíam comandos de repetições e seleções bem elaborados, GOTO foi muito utilizado. Este comando dificulta a depuração do programa por parte de terceiros, e por isso deve ser restringido ao mínimo possível.
Exemplo:

10  CLS  'Este programa converte valores decimais em valores binários
15  PRINT "Para terminar digite FIM ou tecle Ctrl+Pause"
20  INPUT "Cálculo do Valor-Binario... Qual o Valor-Decimal"; A$
25  IF UCASE$(A$) = "FIM" THEN END
30  B& = VAL(A$)
35  B$ = ""
40  B$ = LTRIM$(STR$(B& - INT(B& / 2) * 2)) + B$
45  B& = INT(B& / 2)
50  IF B& > 0 THEN GOTO 40
55  PRINT "Valor Binario: "; B$
60  B% = INT(LEN(B$) / 8) + ABS(LEN(B$) / 8 > INT(LEN(B$) / 8))
65  PRINT "Este valor ocupa"; B%; "Byte(s) de 8 bit"
70  PRINT "Ficaria assim: ";
75  B& = VAL(A$): B$ = ""
80  FOR I% = 1 TO B% * 8
85    B$ = LTRIM$(STR$(B& - INT(B& / 2) * 2)) + B$
90    B& = INT(B& / 2)
95    IF I% / 8 = INT(I% / 8) THEN B$ = " " + B$
100 NEXT
105 PRINT B$
110 PRINT
115 GOTO 15

A execução deste programa produz a seguinte saída, se o operador digitar “1234567890” como no exemplo abaixo:

Para terminar digite FIM ou tecle Ctrl+Pause
Cálculo do Valor-Binario… Qual o Valor-Decimal? 1234567890
Valor Binario: 1001001100101100000001011010010
Este valor ocupa 4 Byte(s) de 8 bit
Ficaria assim: 01001001 10010110 00000010 11010010

Para terminar digite FIM ou tecle Ctrl+Pause
Cálculo do Valor-Binario… Qual o Valor-Decimal?

Comandos relacionados: DO; IF; SELECT CASE


┌─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┐
ABCDEFGHI-JKLMNOPQRSTUVWX-Z
└─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┘
HEX$ (Função)
Devolve uma string contendo a representação hexadecimal de um valor.
Sintaxe:
HEX$(expressão_numérica)
Observações:
Notação hexadecimal é o sistema de numeração em base 16. Ela utiliza números de 0 a 9 e letras de A a F. Para armazenar a representação hexadecimal de um número, você deve usar uma variável string. Praticamente todas as atividades que envolvem processamentos de dados utilizam a notação hexadecimal, por exemplo: O código RGB para definir cores em páginas da internet, o endereçamento de memória em linguagem assembly, etc.
Exemplo:

CLS 'Mostra valores em binário, octal, decimal e hexadecimal de 0 a 255
FOR I = 0 TO 255
  IF I / 20 = INT(I / 20) THEN
    IF I > 0 THEN
      INPUT "Tecle ENTER para continuar!", A$
      LOCATE CSRLIN - 1: PRINT STRING$(46, 196)
    END IF
    PRINT "Binario", "Octal", " Decimal", "Hexa"
    PRINT STRING$(46, 45)
  END IF
  B = I: B$ = ""
  FOR J% = 1 TO 8
    B$ = LTRIM$(STR$(B - INT(B / 2) * 2)) + B$
    B = INT(B / 2)
  NEXT
  PRINT B$, OCT$(I), I, HEX$(I)
NEXT

A execução deste programa produz a seguinte saída:


Binario       Octal          Decimal      Hexa
—————————————————————————————————————————————–
00000000      0              0            0
00000001      1              1            1
00000010      2              2            2
00000011      3              3            3
00000100      4              4            4
00000101      5              5            5
00000110      6              6            6
00000111      7              7            7
00001000      10             8            8
00001001      11             9            9
00001010      12             10           A
00001011      13             11           B
00001100      14             12           C
00001101      15             13           D
00001110      16             14           E
00001111      17             15           F
00010000      20             16           10
00010001      21             17           11
00010010      22             18           12
00010011      23             19           13
Tecle ENTER para continuar!

Função relacionada: OCT$


┌─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┐
ABCDEFGHI-JKLMNOPQRSTUVWX-Z
└─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┘
IF (Comando)
Permite a execução de um procedimento, se (IF) a condição de uma expressão for satisfeita.
Sintaxe:
IF expressão THEN (expressão=Verdadeiro)execução1 [ELSE (expressão=Falso)execução2]
ou
IF expressão1 THEN
  (expressão1=Verdadeiro)execução1
[ELSEIF (expressão1=falso)expressão2 THEN
  (expressão2=Verdadeiro)execução2]
[ELSE
  (expressão2=Falso)execução3]
END IF
Observações:
A primeira forma do comando IF permite escrever em apenas uma linha de programação e colocar as expressões e condições tanto verdadeiras quanto falsas. A linha de programa permite colocar vários comandos separados por dois_pontos (:), tanto para a condição verdadeira quanto para a falsa; também permite que se coloque outros comandos IF na mesma linha.
A segunda forma do comando IF permite que você coloque vários comandos, funções, chamadas e desvios, em linhas diferentes, desde que estejam limitados pelas instruçãoes IF…END IF; estas linhas são semelhantes a sub-rotinas que serão executadas ou não dependendo do resultado de cada expressão. Vários ELSE e ELSEIF podem ser colocados mas, cada ELSE ou ELSEIF estará subordinado ao resultado da expressão do IF ou ELSEIF anterior. Ainda, esta sintaxe permite criar outras condições e desvios para dentro ou para fora do limite IF…END IF. A preocupação do programador deve ser a de não quebrar a lógica.
Exemplo:

CLS    'Ordena os valores entrados, e explica o porque
DO
  INPUT "Entre com dois valores separados por virgula ou 0,0 para Fim: ", X, Y
  IF X = 0 AND Y = 0 THEN
    END
  ELSE
    Z = X: K = Y: IF X > Y THEN SWAP X, Y
    PRINT "O primeiro"; : IF Z = X THEN PRINT " nao";
    PRINT " trocou com o segundo pois o primeiro eh ";
    IF Z = K THEN
      PRINT "igual ao";
    ELSEIF Z > K THEN
      PRINT "maior que o";
    ELSE
      PRINT "menor que o";
    END IF
    PRINT " segundo": PRINT "Agora os valores sao:"; X; "e"; Y: PRINT
  END IF
LOOP

A execução deste programa produz a seguinte saída:

Entre com dois valores separados por virgula ou 0,0 para Fim: 15,13
O primeiro trocou com o segundo pois o primeiro eh maior que o segundo
Agora os valores sao: 13 e 15

Entre com dois valores separados por virgula ou 0,0 para Fim:

Comandos relacionados: SELECT CASE

IMP (Operador lógico)
Operador lógico de Implicação.
IMP compara bit a bit duas expressões e devolve um valor em cujo, cada bit corresponde ao resultado da operação conforme a tabela abaixo:

X IMP Y = Z
1     1   1
1     0   0
0     1   1
0     0   1

Operadores relacionados: EQV; AND; OR; NOT; XOR;

INKEY$ (Função)
Lê um caractere do teclado.
Sintaxe:
INKEY$
Observações:
INKEY$ varre o buffer do teclado, captura o código ASCII correspondente a primeira tecla na espera, e prossegue sem esperar.
INKEY$ devolve uma string vazia se não houver nenhum caractere, uma string de 1 byte para teclas ASCII, ou uma string de 2 bytes para teclas especiais. Geralmente esta função é colocada dentro de um loop que repassa por INKEY$ n vezes até obter algum conteúdo não vazio.
Para teclas especiais, o primeiro caractere é um caractere nulo (ASCII=0) e o segundo é o código físico da tecla.
INKEY$ não mostra o caractere na tela.
Exemplo:

CLS  'Exibe nomes no video em forma de menu com a tarja no item selecionado
LOCATE 10, 10
PRINT "Tecle " + CHR$(18) + " ou ESC ou ENTER"
X = 1: Y = 5
DIM NOME$(1 TO Y)
NOME$(1) = "RIO DE JANEIRO"
NOME$(2) = "RECIFE"
NOME$(3) = "RIO GRANDE DO SUL"
NOME$(4) = "FORTALEZA"
NOME$(5) = "SANTA CATARINA"
DO
  FOR I = 1 TO Y
    IF I = X THEN COLOR 15, 2 ELSE COLOR 0, 7
    LOCATE 10 + I, 10
    PRINT LEFT$(" " + NOME$(I) + STRING$(22, 32), 23)
  NEXT
  A$ = INKEY$
  X = X + (A$ = CHR$(0) + "H" AND X > 1)
  X = X + ABS(A$ = CHR$(0) + "P" AND X < Y)
LOOP UNTIL A$ = CHR$(27) OR A$ = CHR$(13)
LOCATE 17, 10: COLOR 15, 0: PRINT "O nome selecionado foi: "; NOME$(X)

A execução deste programa produz a saída abaixo, e o operador deve teclar seta abaixo, seta acima, ESC ou ENTER.

Tecle ↕ ou ESC ou ENTER
RIO DE JANEIRO
RECIFE
RIO GRANDE DO SUL
 FORTALEZA               
SANTA CATARINA

O nome selecionado foi: FORTALEZA

INP (Função)
Devolve um byte lido de uma porta de E/S (Entrada e Saída), como: alto-falante, mouse, teclado, etc.
Sintaxe:
INP (número_da_porta)
Observações:
número_da_porta é o número associado à porta desejada. Ele deve estar no intervalo de 0 a 65535.
Exemplo:

'Liga o alto-falante através da porta 97. Obs.: O Windows-7 e posteriores nem sempre aceitam esta função.
PRINT "PRESSIONE QUALQUER TECLA PARA FIM"
A% = INP(97)                 'Lê a porta
OUT 97, A% + 3               'Liga o alto-falante
DO: LOOP UNTIL INKEY$ <> ""  'Aguarda uma tecla ser pressionada 
OUT 97, A%                   'Devolve o estado anterior da porta

Comando relacionado: OUT

INPUT (Comando)
Lê uma entrada do Teclado.
Sintaxe:
INPUT [;][“mensagem_prompt”,|;] variável, [variável, …]
Observações:
mensagem_prompt é uma mensagem opcional que INPUT mostra na tela antes de esperar a entrada, posicionando o cursor imediatamente após.
O ponto e vírgula imediatamente após INPUT [INPUT ;] mantém o cursor na mesma linha e coluna da posição que for teclado ENTER.
INPUT aceita até 255 caracteres. Todos os caracteres digitados que estejam exibidos serão aceitos independente da posição do cursor dentro do campo. INPUT elimina todos os caracteres em branco (caractere ASCII 32) à esquerda e à direita dos limites dos demais caracteres digitados.
O ponto e vírgula após a mensagem_prompt indica que INPUT deve mostrar um ponto de interrogação anterior ao cursor, na entrada.
Uma vírgula após a mensagem_prompt indica que INPUT não deve mostrar um ponto de interrogação anterior ao cursor, na entrada.
Variável é uma ou várias variáveis separadas por vírgulas, e que receberão o conteúdo das entradas digitados. No caso de mais de uma variável, o operador deve digitar cada uma das entradas, também separadas por vírgulas.
Se o usuário entrar com um valor (conteúdo digitado) diferente do tipo (numérico/alfanumérico) esperado por INPUT, será mostrado a mensagem “Redo from start, e o usuário deve redigitar todos os dados.
Obs.: Um programa mais bem elaborado requer a criação de uma rotina específica para captação de dados do teclado, já que os recursos de INPUT, no tocante ao layout de tela e controle do teclado, são muito limitados.
Exemplo:

CLS
'Com interrogação
INPUT A$
PRINT A$; B%
INPUT "Qual seu nome e idade"; A$, B%
PRINT A$; B%

'Sem interrogação
INPUT "Entre com seu nome e idade: ", A$, B%
PRINT A$; B%

'Deixando o cursor na mesma linha e coluna do cursor
INPUT ; "Entre com seu nome e idade: ", A$, B%
PRINT A$; B%

A execução deste programa produz a seguinte saída depois de digitado as entradas solicitadas:

? ANTONIO
ANTONIO
Qual seu nome e idade? MARIA,30
MARIA 30
Entre com seu nome e idade: PEDRO,20
PEDRO 20
Entre com seu nome e idade: NAZARENO,45NAZARENO 45

Função relacionada: INPUT$
Comando relacionado: INPUT #

INPUT # (Comando)
Lê dados de um arquivo sequencial.
Sintaxe:
INPUT #número_de_arquivo, variável[, variável…]
Observações:
número_de_arquivo é o número atribuído ao arquivo sequencial em seu comando OPEN.
variável é a lista de variáveis, separadas por vírgulas, na qual os dados do arquivo serão armazenados.
INPUT #x colhe dados de uma arquivo sequencial (x) aberto, da mesma forma que INPUT colhe dados do teclado.
Exemplo:

OPEN "SALÁRIO.DAT" FOR INPUT AS #1
DO WHILE NOT EOF(1)
  INPUT #1, NOME$, VALOR
  PRINT NOME$; VALOR
LOOP
CLOSE #1

Funções relacionadas: INPUT$
Comandos relacionados: INPUT

INPUT$ (Função)
Lê um determinado número de caracteres de um arquivo aberto ou do teclado.
Sintaxe:
INPUT$(número_de_caracteres, número_do_arquivo)
Observações:
número_de_caracteres é o número de caracteres que INPUT$ deve ler. Ele deve ser menor ou igual ao tamanho do registro do arquivo, o qual é 128 se não for indicado.
número_do_arquivo é o número atribuído ao arquivo aberto no comando OPEN. Se o número de arquivo for omitido, INPUT$ lerá do teclado.
INPUT$ considera completa sua tarefa quando a quantidade de caracteres indicados se completam, e o programa continua na próxima instrução sem aviso nem interrupções. Ainda, INPUT$ lê qualquer tipo de caractere, inclusive os caracteres de controle de hardware, tais como: retorno do carro, alimentação de linha, bel (caractere 7=beep), etc.
Exemplo:

CLS 'Salva duas frase no arquivo TESTE.DAT
OPEN "TESTE.DAT" FOR OUTPUT AS #1
A$ = "DEUS AMA O PECADOR"
B$ = "MAS NAO SUPORTA O PECADO"
PRINT #1, A$                        'Salva a primeira frase. | Obs.: No fim de cada gravação são
PRINT #1, B$                        'Salva a segunda frase   |       colocados automaticamente dois 
PRINT #1, CHR$(7)                   'Salva um beep (bel)     |       caracteres: 13=Return e 10=Line-feed
CLOSE #1
'Exibe Um-a-Um os caracteres de um arquivo
BUF% = FREEFILE
OPEN "TESTE.DAT" FOR INPUT AS #BUF%
DO UNTIL EOF(BUF%)
  C$ = INPUT$(1, BUF%)              'Lê um a um cada caracteres no arquivo aberto em BUF%
  PRINT C$;                         'Exibe um após outro (concatenado) cada caractere lido
LOOP
CLOSE #BUF%

A execução deste programa produz a seguinte saída:

DEUS AMA O PECADOR

MAS NAO SUPORTA O PECADO

Observe que a duas frases estão em linhas diferentes e separadas por uma linha intermediária apesar do programa indicar que todos os caracteres lidos estariam concatenados (um após outro). Isso aconteceu porque ao final de cada gravação (PRINT #1) Quick-Basic coloca um caractere 13 (retorno do carro) e um caractere 10 (alimentação de linha) para que o Quick-Basic saiba identificar quando termina cada registro no caso do arquivo ser lido com INPUT ou LINE INPUT, e não com INPUT$.
Comandos relacionados: INPUT; INPUT#

INSTR (Função)
Devolve a localização da primeira ocorrência de uma string dentro de outra string.
Sintaxe:
INSTR([posição_inicial,] string_pesquisada, string_procurada)
Observações:
INSTR devolve a posição em quantidade de caracteres a partir do início da string_pesquisada, quando a string_procurada é encontrada dentro, ou zero (0) se a ocorrência não for verdadeira.
posição_inicial é a posição em quantidade de caracteres da string_pesquisada que INSTR iniciará a busca de uma ocorrência da string_procurada dentro da string_pesquisada. Se posição_inicial for omitido, INSTR começa na posição 1. Independente de onde a busca é iniciada, INSTR devolverá sempre a posição a partir do início da string_pesquisada onde o primeiro caractere da string_procurada estiver, ou zero (0) se não houver ocorrência.
INSTR diferencia entre maiúsculas e minúsculas, assim como entre caracteres acentuados e não acentuados. Para resolver o problema das maiúsculas e minúsculas utilize as funções UCASE$ e LCASE$
Exemplo:

CLS  'Buscas sucessivas de uma string em outra digitada anteriormente
INPUT "Qual a string para ser pesquisada"; A$
DO
  CLS
  COLOR 7
  PRINT "Tecle ENTER com campo vazio para Finalizar."
  PRINT A$
  COLOR 14
  IF X% THEN
    LOCATE CSRLIN - 1
    COLOR 14
    LOCATE , X%: PRINT MID$(A$, X%, LEN(B$))
    PRINT "local na string:"; X%
  ELSE
    PRINT
  END IF
  INPUT "Qual a string procurada"; B$
  X% = INSTR(UCASE$(A$), UCASE$(B$))
LOOP UNTIL B$ = ""

A execução deste programa produz a seguinte saída:

Tecle ENTER com campo vazio para Finalizar.
O Mercado Mundial está em crise.
local na string: 11
Qual a string procurada? mundial

Comandos relacionados: LEFT$; LEN; MID$; RIGHT$

INT (Função)
Devolve o maior valor (absoluto) inteiro que é menor ou igual a expressão numérica especificada.
Sintaxe:
INT(expressão_numérica)
Observações:
expressão_numérica é qualquer expressão numérica.
Exemplo:

PRINT INT(99.8); INT(99.1); INT(-99.2)

A execução deste programa produz a seguinte saída:

99 99 -100

Funções relacionadas: CINT; FIX

IOCTL (Comando)
Transmite uma string de controle de dispositivo para um controlador de dispositivo.
Sintaxe:
IOCTL [#]número_arquivo, string_controle
Observações:
numero_arquivo é o número do arquivo atribuído ao dispositivo em seu comando OPEN.
string_controle é uma expressão string que determina o comando a ser enviado ao dispositivo para que este dispositivo devolva uma resposta. Cada hardware tem em sua documentação uma lista de string_controle a serem enviados para que possam dar uma resposta à solicitação feita.
Exemplo:

OPEN "\DEV\ENGINE" FOR OUTPUT AS #1
IOCTL #1, "RAW"                 'Pergunta se o dispositivo ainda tem dados não processados
IF IOCTL$(1) = 0 THEN CLOSE #1  'Se não tiver mais nenhum dado a processar, fecha o arquivo

Função relacionada: IOCTL$

IOCTL$ (Função)
Devolve uma string de controle de controlador de dispositivo.
Sintaxe:
IOCTL$([#]número_arquivo)
Observações:
número_arquivo é o número do arquivo atribuído ao dispositivo em seu comando OPEN.
A informação que IOCTL$ devolve é dependente do dispositivo. Para maiores informações, veja seu manual de referência do hardware.
Exemplo
Veja IOCTL
Comandos relacionados: IOCTL

IS (Palavra-chave)
Serve como a parte anterior a um operador relacional (menor ou igual a, maior que, Maior ou igual a, Diferente de, Igual a) no comando SELECT CASE, na cláusula CASE IS <= 5 por exemplo… Veja a palavra chave CASE.

ISAM (Palavra-Chave)
■ O Compilador Quick-Basic inclui o conjunto ISAM (Indexed Sequential Access Method) para os programas de gerenciamento de escrita de dados. Consulte Capítulo 10 (Database Programming with ISAM) no “BASIC Programmer’s Guide” para obter mais informações sobre como usar o ISAM.
■ A instrução OPEN usada com a Palavra-Chave ISAM abre uma tabela de Banco-de-Dados ISAM onde já existe ou cria uma nova tabela.
Comandos relacionados:
BEGINTRANS:
BOF:
CHECKPOINT:
CLOSE:
COMMITTRANS:
CREATEINDEX:
DELETE:
DELETEINDEX:
DELETETABLE:
EOF:
FILEATTR:
GETINDEX$:
INSERT:
LOF:
MOVEdest:
OPEN:
RETRIEVE:
ROLLBACK:
SAVEPOINT:
SEEKoperand:
SETINDEX:
TEXTCOMP:
TYPE:
UPDATE:


┌─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┐
ABCDEFGHI-JKLMNOPQRSTUVWX-Z
└─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┘
KEY (Comando)
Atribui valores string para as teclas de função F1 a F12. Opcionalmente, mostra o valor de cada tecla.
Sintaxe:
KEY tecla_de_função, expressão_string
KEY LIST
KEY ON
KEY OFF
Observações:
tecla_de_função é o número da tecla de função desejada. 1 corresponde a F110 corresponde a F1030 corresponde a F11 e 31 corresponde a F12.
expressão_string é uma string de até 15 caracteres que você deseja associar à tecla de função.
Uma vez definida uma string para a tecla, cada vez que o usuário pressionar a respectiva tecla de função a string será devolvida como se ela fosse digitada a partir do teclado.
KEY LIST mostra a partir da posição do cursor uma listagem vertical com os 15 caracteres atribuídos a cada tecla de função.
KEY ON mostra horizontalmente na última linha da tela, os seis primeiros caracteres atribuídos as dez primeiras teclas de função.
KEY OFF desliga KEY ON deixando de exibir na última linha, mas os conteúdos já atribuídos às teclas de funções continuam.
Exemplo:

CLS
'Define string para F1 e F5
KEY 1, "Brasil"
KEY 5, "Chile"
'Mostra as atribuiþ§es Ós teclas
KEY LIST
KEY ON
INPUT "Pressione qualquer tecla de funþÒo:", A$
PRINT A$

A execução deste programa produz a seguinte saída:


F1  Brasil
F2
F3
F4
F5  Chile
F6
F7
F8
F9
F10
F11
F12
Pressione qualquer tecla de função:
1Brasil_2_______3_______4_______5Chile__6_______7_______8_______9_______10_______

KEY (n) (Comando)
Habilita ou desabilita a intercepção de determinadas teclas do teclado.
Sintaxe:
KEY(n) ON
KEY(n) OFF
KEY(n) STOP
KEY n, CHR$(flag_teclado) + CHR$(código_físico)
Observações:
(n) é o número associado com a tecla de função, uma tecla de movimentação do cursor ou uma tecla definida pelo usuário.
n é o número a ser associado com a tecla definida pelo usuário (15 a 25).
flag_teclado é um dos valores conforme a tabela abaixo para teclas definidas pelo usuário.
código_físico é o código físico da tecla desejada.

Teclas Convencionais Teclas definidas pelo usuário
Valor de (n) Significado Flag Significado
1 a 10 Teclas de Funções F1 a F10 0 Nenhum flag de Teclado
11 Seta para cima 1 a 3 Qualquer tecla shift
12 Seta para esquerda 4 Tecla Ctrl
13 Seta para direita 8 Tecla Alt
14 Seta para baixo 32 Tecla Num Lock
15 a 25 Teclas definidas pelo usuário 64 Tecla Caps Lock
30 e 31 Teclas de Função F11 e F12 128 Teclado de 101 teclas

KEY(n) ON habilita a intercepção do evento de ser digitada a tecla determinada.
KEY(n) OF desabilita a intercepção do evento de ser digitada a tecla determinada. Quick-Basic não cria uma fila com eventos que ocorram.
KEY(n) STOP inibe a intercepção do evento de ser digitada a tecla determinada. Resultados serão processados uma vez que a intercepção tenha sido habilitada.
Depois de especificar a intercepção de eventos do teclado para uma tecla específica, o comando ON evento habilita a intercepção das teclas.
Para declarar uma tecla definida pelo usuário, use quarta (ultima) forma do comando KEY especificado acima.
A intercepção de teclas não faz distinção entre as teclas Shift esquerda e direita.
Você pode adicionar os valores para testar múltiplos flags simultaneamente.
Exemplo:

CLS
ON KEY(10) GOSUB FINAL
KEY(10) ON
DO
  LOCATE 1
  PRINT "Pressione F10 para Fim"
  PRINT "Data: "; DATE$
  PRINT "Hora: "; TIME$
LOOP
FINAL:
END

A execução deste programa exibe a frase especificada, a data e hora atualizada continuamente, e somente ao pressionar a tecla F10 o processo findará.
Comando relacionado: ON evento GOSUB

KILL (Comando)
Apaga um ou vários arquivos com o nome ou especificações ambíguas, e local (caminho) caso não esteja na pasta vigente.
Sintaxe:
KILL especificação_de_arquivo
Observações:
especificação_de_arquivo é uma expressão string especificando o arquivo a ser apagado. A string pode conter os caracteres ? e * de especificação ambígua do sistema operacional DOS.
Exemplo:

KILL "TESTE.DAT"                'Apaga o arquivo "TESTE.DAT" na pasta vigente
A$ = "E:\ARQUIVO\TESTE.DAT"
KILL A$                         'Apaga o arquivo "TESTE.DAT" da subpasta "ARQUIVO" no drive "E"
A$ = "..\TEMPORAL\CLIENTES.*"   'Este caminho retroage uma pasta e depois avança uma pasta a frente (paralela à vigente)
IF DIR$(A$) <> "" THEN KILL A$  'se existir: Apaga todos arquivos "CLIENTES.*" com qualquer terminação, da subpasta "TEMPORAL" paralela à pasta vigente. 

Comandos relacionados: FILES; NAME; CHDIR


┌─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┐
ABCDEFGHI-JKLMNOPQRSTUVWX-Z
└─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┘
LBOUND (Função)
Devolve o menor índice da matriz para a dimensão especificada de uma matriz.
Sintaxe:
LBOUND(nome-matriz[,dimensão])
Observações:
nome_matriz é o nome da matriz de interesse.
dimensão é um número que indica a dimensão de interesse para matrizes multidimensionais. Se omitida, valerá 1. Matrizes multidimensionais são reconhecidas por LBOUND na sequência: 1ª dimensão = 1, 2ª dimensão = 2, e assim por diante.
Exemplo:

DIM A(50 TO 100) AS INTEGER                     'Define uma dimensão para a variável indexada "A"
DIM CAIXA(1 TO 3, 3 TO 6, 10 TO 20) AS INTEGER  'Define três dimensões para a variável indexada "CAIXA"
PRINT LBOUND(A)                          'Solicita o menor índice definido para a variável indexada "A" 
PRINT LBOUND(CAIXA, 1); LBOUND(CAIXA, 3) 'Solicita o menor índice definido para a 1ª e para a 3ª dimensão da variável indexada "CAIXA"

A execução deste programa produz a seguinte saída:

50
1 10

Função relacionada: UBOUND
Comando relacionado: DIM

LCASE$ (Função)
Devolve em minúsculas as letras de uma expressão string.
Sintaxe:
LCASE$(expressão_string)
Observações
expressão_string é qualquer expressão string.
LCASE$ não converte o conteúdo da variável em minúsculas, mas somente devolve o conteúdo em letras minúsculas.
Exemplo:

INPUT "Digite uma string:", A$
PRINT LCASE$(A$)

Função relacionada: UCASE$

LEFT$ (Função)
Devolve um determinado número de caracteres de uma string, começando do caractere mais à esquerda da string.
Sintaxe:
LEFT$(expressão_string, número_caracteres)
Observações:
expressão_string é qualquer expressão string.
número_caracteres é o número de caracteres a extrair da string. Ele deve estar no intervalo de 0 a 32.767.
Exemplo:

A$ = "TESTE DE STRING"
FOR I% = 1 TO LEN(A$)
  PRINT LEFT$(A$, I%)
NEXT

A execução deste programa produz a seguinte saída:

T
TE
TES
TEST
TESTE
TESTE
TESTE D
TESTE DE
TESTE DE
TESTE DE S
TESTE DE ST
TESTE DE STR
TESTE DE STRI
TESTE DE STRIN
TESTE DE STRING

Funções relacionadas: MID$; RIGHT$

LEN (Função)
Devolve o número de caracteres em uma string ou o número de bytes usados para armazenar uma variável.
Sintaxe:
LEN(expressão_string)
LEN(variável)
Observações:
expressão_string é qualquer expressão string (variável string ou constante explicitada no programa).
variável é qualquer variável de tipo diferente de string (INTEGER, LONG, SINGLE, DOUBLE, CURRENCY). Estas variáveis são armazenadas na memória em padrões de:
2 Bytes para: Inteiro (INTEGER);
4 Bytes para: Inteiro-Longo (LONG), e Simples-Precisão (SINGLE) de ponto flutuante;
8 Bytes para: Dupla-Precisão (DOUBLE) de ponto flutuante com até 15 dígitos, e Valor-Monetário (CURRENCY) de até 15 dígitos com até 4 casas decimais.
Para estas variáveis não string, LEN devolve o tamanho destes respectivos campos padronizados por Quick-Basic, independentemente do valor que elas contenham.
Exemplo:

DIM X AS INTEGER, Y AS LONG
A$ = "Esta variavel tem 32 caracteres:"
PRINT A$; LEN(A$); "bytes"
PRINT "O tamanho desta constante:"; LEN("O tamanho desta constante:"); "bytes" 
PRINT "Inteiro:"; LEN(X); "bytes"
PRINT "Inteiro longo:"; LEN(Y); "bytes"
PRINT "Simples precisão:"; LEN(MKS$(0)); "bytes"
PRINT "Dupla precisão:"; LEN(MKD$(5)); "bytes"
PRINT "Moeda corrente:"; LEN(MKC$(34858.324)); "bytes"

A execução deste programa produz a seguinte saída:

Esta variavel tem 32 caracteres: 32 bytes
O tamanho desta constante: 25 bytes
Inteiro: 2 bytes
Inteiro longo: 4 bytes
Simples precisão: 4 bytes
Dupla precisão: 8 bytes
Moeda corrente: 8 bytes

LET (Comando)
Atribui um valor a uma variável.
LET variável = expressão
Observações:
LET é uma palavra reservada opcional usada em comandos de atribuição para atribuir um valor a uma variável.
Exemplo:

LET A = 5         'Atribuição usando LET
B = 5             'Atribuição equivalente sem usar LET
LET A$ = "VENDAS" 'Atribuição usando LET
B$ = "VENDAS"     'Atribuição equivalente sem usar LET

LINE (Comando)
Desenha uma linha ou quadro na tela.
Sintaxe:
LINE [STEP] (x1, y1) – [STEP] (x2, y2)[, cor][, B[F]][, estilo_linha]
Observações:
LINE desenha tanto uma linha, usando o par de coordenadas (x1,y1)-(x2,y2), como pontos finais, ou um quadro, com (x1,y1) como um canto e (x2,y2) o canto oposto.
A palavra reservada STEP faz com que LINE use as coordenadas como um deslocamento em relação ao último ponto desenhado, em vez de considerá-la coordenadas físicas.
cor é a cor da linha ou do quadro.
B indica a LINE que deve desenhar um quadro e não uma linha.
F indica a LINE que deve preencher o quadro com a cor especificada.
estilo_linha é um valor de 16 bits que determina quais pixels serão desenhados ou não. Trocando este valor, você pode trocar o estilo das linhas em sua tela.
Exemplo:

'Preenche a tela com quadros aleatórios
SCREEN 1
FOR I = 1 TO 1000
  X1 = RND * 320
  Y1 = RND * 200
  X2 = RND * 320
  Y2 = RND * 200
  COR = RND * 4
  LINE (X1,Y1)-(X2,Y2), COR, BF
NEXT I

Comandos relacionados: SCREEN

LINE INPUT (Comando)
Lê uma string de até 255 caracteres.
Sintaxe:
LINE INPUT [;] [“mensagem”;|,] variável_string
LINE INPUT [#]número_arquivo, variável_string
Observações:
Embora o comando INPUT interprete uma vírgula como um separador entre duas entradas, o comando LINE INPUT não o faz (para LINE INPUT uma vírgula é apenas mais um caractere da string). O comando LINE INPUT lê todos os caracteres até o ENTER (ASCII=13) e então os atribui para uma variável.
Se um ponto e vírgula estiver presente imediatamente após a palavra reservada INPUT, significa que LINE INPUT deixará o cursor na mesma linha após o usuário pressionar ENTER.
mensagem é uma mensagem opcional que será exibida na tela indicando ao usuário que deve entrar com dados pelo teclado.
variável_string é uma variável string à qual LINE INPUT atribuirá a informação lida.
número_arquivo é o número de arquivo associado ao arquivo aberto através do comando OPEN, e nesse caso LINE INPUT lerá dados do (arquivo) aberto em um determinado dispositivo, e não do teclado.
LINE INPUT não exibe uma interrogação, a menos que a interrogação esteja na mensagem.
LINE INPUT não aceita atribuição para variáveis numéricas. LINE INPUT aceita somente strings. Os valores numéricos lidos dos arquivos, devem estar formatados para esse fim através dos comandos: MKI$, MKL$, MKS$, MKD$, MKC$.
Exemplo:

LINE INPUT "Entre com uma oração e tecle ENTER: ", A$
PRINT A$ 
LINE INPUT ; B$
PRINT B$
LINE INPUT C$
PRINT C$

Comandos relacionados: INPUT

LIST (Palavra-Chave)Veja o comando KEY

LOC (Função)
Devolve o deslocamento (ponteiro) ou número de registro corrente dentro de um arquivo.
Sintaxe:
LOC(número_arquivo)
Observações:
número_arquivo é o número do arquivo associado ao arquivo desejado através do comando OPEN.
Para arquivos binários, LOC retorna o deslocamento em bytes no arquivo. Para arquivos de acesso aleatório, LOC devolve o número do registro corrente. Para arquivos sequenciais, LOC devolve o deslocamento, dividido por 128, Para um dispositivo COM, LOC devolve o número de bytes na fila de entrada.
Exemplo:

IF LOC(1) > 100 THEN CALL LEIA(MES%, SALARIO)

Comandos relacionados: SEEK

LOCAL (Palavra-Chave)
Palavra chave usada no comando ON LOCAL ERROR… dentro de subprogramas para indicar que o tratamento com erros está restrito ao módulo vigente e não ao módulo raiz. Cada subprograma pode ter seu próprio tratamento de erros, mas deverá conter esta palavra-chave (LOCAL).
O comando ON ERROR… do módulo raiz (não subprograma) atua em todos os sub-programas exceto no subprograma que contiver sua própria rotina de tratamento de erros e o comando ON LOCAL ERROR….
Exemplo:

DECLARE SUB CALCULE (X, Y)
ON ERROR GOTO 10
CLS : X = 5: Y = 0
CALL CALCULE(X, Y)
PRINT "Aqui, no programa principal, ocorre o segundo erro. RETURN sem GOSUB"; : RETURN
END
10
PRINT
INPUT "Pressione qualquer tecla para continuar: ", A$
RESUME NEXT

SUB CALCULE (X, Y)
ON LOCAL ERROR GOTO ERRO
PRINT "Aqui, no subprograma, ocorre o primeiro erro. Um numero dividido por zero"; X / Y
EXIT SUB
ERRO:
PRINT
INPUT "Pressione qualquer tecla para continuar: ", A$
RESUME NEXT
END SUB

A execução deste programa produz a seguinte saída:

Aqui, no subprograma, ocorre o primeiro erro. Um numero dividido por zero
Pressione qualquer tecla para continuar:
Aqui, no programa principal, ocorre o segundo erro. RETURN sem GOSUB
Pressione qualquer tecla para continuar:

Veja também o comando ON ERROR…

LOCATE (Comando)
Move o cursor para uma determinada posição da tela e, opcionalmente, define o tamanho do cursor.
Sintaxe:
LOCATE [linha][, coluna][, visível][, início_cursor][, final_cursor]
Observações:
linha é o número da linha desejada.
coluna é o número da coluna desejada.
visível, quando verdadeiro (1), faz o cursor ficar visível; quando falso (0), esconde o cursor.
início_cursor é um inteiro especificando a primeira linha de varredura do cursor (0 a 31).
final_cursor é um inteiro especificando a última linha de varredura do cursor (0 a 31).
linha de varredura do cursor é cada linha dentro do retângulo correspondente ao espaço onde se aloja um caractere
Para especificar argumentos posteriores a argumentos omitidos, coloque vírgulas até alcançar o argumento desejado.
Mediante a troca das linhas de varredura do cursor, você pode mudar o tamanho do cursor.
Exemplo:

CLS
DO
  LOCATE 10, 35, 1, X, 7
  PRINT X;
  SLEEP 1
  X = (X + 1) MOD 8
LOOP UNTIL INKEY$ <> ""
END

A execução deste programa exibirá na linha 10 e coluna 35 da tela o valor da variável X com um cursor visível em todos os tamanhos a começar da linha de varredura 0-7 até a linha de varredura 7-7 do cursor.
Funções relacionadas: CSRLIN; POS

LOCK (Comando)
Bloqueia o acesso de terceiros ao arquivo inteiro ou a uma porções determinadas, em um processo de compartilhamento (rede ou multiusuário).
Sintaxe:
LOCK [#]número_arquivo
LOCK [#]número_arquivo, registro
LOCK [#]número_arquivo, registro_início TO registro_fim
Observações:
número_arquivo é o número do arquivo associado ao arquivo desejado através do comando OPEN.
registro é o número do registro nos arquivo de acesso randômico, ou um byte nos arquivos de acesso binário;
registro_início TO registro_fim é a porção (intervalo) de registros a serem bloqueados nos arquivos de acesso randômico ou binário.
Para arquivos de acesso aleatório, LOCK bloqueia um registro específico ou um intervalo de registros, Para arquivos binários, LOCK bloqueia um byte específico ou um intervalo de bytes. Para arquivos sequenciais, LOCK bloqueia o arquivo inteiro.
LOCK é necessário apenas em ambiente onde os arquivos são compartilhados e mais de um usuário pode tentar manipular o arquivo ao mesmo tempo, gerando conflito. Se um programa tentar acessar um registro ou byte bloqueado, Quick-Basic gera um erro. Programas que acessam arquivos com possibilidades de serem bloqueados devem ter rotinas de tratamento de erros que reconheçam o bloqueio e tomem a decisão de insistir com o comando RESUME ou pular a etapa de acesso com o comando RESUME NEXT ou abortar o procedimento até que o acesso seja desbloqueado com o comando UNLOKC da parte do BUFFER que o bloqueou. O Bloqueio (LOCK) impedirá o acesso ao arquivo ou registro a todos os outros BUFFER DO MESMO ARQUIVO ABERTO que tentarem acessar o respectivo arquivo ou registro, mas não ao BUFFER que o bloqueou.
Exemplo:

'Abre um arquivo num buffer e bloqueia-o, depois tenta ler em outro Buffer. 
DECLARE SUB TESTE (X%, C%)                              'Declara que existe um subprograma de nome TESTE             
CLS                                                     'Limpa a tela
X% = 1: C% = 0                                          'Inicializa as variáveis: Nº do Registro, e Contador de tentativas de leitura
BUF% = FREEFILE                                         'Solicita um número de buffer disponível e deposita em BUF%
OPEN "CLIENTE.DAT" FOR RANDOM SHARED AS #BUF% LEN = 38  'Abre o arquivo no buffer BUF%
FIELD #BUF%, 30 AS NOME$, 8 AS DEBITO$                  'Preestabelece o tamanho dos campos
LOCK #BUF%, X%                                          'Bloqueia o Registro X% do arquivo que está no buffer BUF% para fazer alterações
LSET NOME$ = "PEDRO CAVALCANTE SOUZA"                   'Atribui o nome do cliente ao campo (variável) "NOME$"
LSET DEBITO$ = MKD$(358.25)                             'Atribui o débito do cliente ao campo (variável) "DEBITO$"
PUT #BUF%, X%                                           'Salva o Registro X% (X% = 1) que é composto por Nome e Débito
CALL TESTE(X%, C%)                                      'Chama subprograma que tentará ler o registro X% noutro buffer, mas está bloqueado
UNLOCK #BUF%, X%                                        'Desbloqueia o Registro X%
CALL TESTE(X%, C%)                                      'Chama subprograma que tentará ler o registro X% noutro buffer, e conseguirá
CLOSE #BUF%                                             'Fecha o arquivo que está no buffer BUF%
END                                                     'Termina o programa

SUB TESTE (X%, C%)                                      'Subprograma que abrirá o arquivo "CLIENTE.DAT" em outro buffer
C% = C% + 1                                             'Incrementa o contador de tentativas de leitura
PRINT C%; "TENTATIVA"                                   'Envia uma mensagem informando as tentativas de leituras
ON LOCAL ERROR GOTO TRATAERRO                           'Aciona a rotina de tratamento de erros
FLAG% = 0                                               'Zera protetor de erro ao decodificar (CVD) caso não consiga ler o registro
B% = FREEFILE                                           'Solicita um buffer disponível e deposita em B%
OPEN "CLIENTE.DAT" FOR RANDOM SHARED AS #B% LEN = 38    'Abre o arquivo no buffer B%
FIELD #B%, 30 AS N$, 8 AS D$                            'Preestabelece o tamanho dos campos
GET #B%, X%                                             'Tenta ler o Registro X% (X% = 1). Na primeira vez não conseguirá pois estará bloqueado
IF FLAG% = 0 THEN                                       'Se não houve erros a variável FLAG% estará em zero (0)
  PRINT "NOME: "; N$                                    'Imprime o nome do cliente                 
  PRINT "DEBITO:"; CVD(D$)                              'Imprime o débito do cliente               
END IF
CLOSE #B%                                               'Fecha o arquivo "CLIENTE.DAT" que foi aberto no buffer B%
EXIT SUB                                                'Sai do subprograma evitando repetir a sub-rotina TRATAERRO
TRATAERRO:                                              'Sub-rotina de tratamento de erros
FLAG% = ERR                                             'Coloca o código do erro na variável FLAG%
PRINT "OCORREU ERRO"; FLAG%; "PRESSIONE QUALQUER TECLA" 'Exibe o código do erro e aguarda uma tecla pressionada
SLEEP                                                   'Dá um tempo até que uma tecla seja pressionada
RESUME NEXT                                             'Diz ao Quick-Basic para continuar no comando após o erro
END SUB                                                 'Indica o fim do subprograma

A execução deste programa produz a seguinte saída:

1 TENTATIVA
OCORREU ERRO 70 PRESSIONE QUALQUER TECLA
2 TENTATIVA
NOME: PEDRO CAVALCANTE SOUZA
DEBITO: 358.25

Comando relacionado: UNLOCK

LOF (Função)
Devolve o número de bytes (tamanho) de um arquivo.
Sintaxe:
LOF(número_arquivo)
Observações:
número_arquivo é o número do arquivo associado ao arquivo aberto através do comando OPEN.
Você não pode usar LOF com dispositivos de comunicação (portas) aberto com o comando OPEN.
Exemplo:

OPEN "\CONFIG.SYS" FOR INPUT AS #1
PRINT "Tamanho do arquivo em bytes:"; LOF(1)
CLOSE #1

LOG (Função)
Devolve o logaritmo natural de uma expressão numérica.
Sintaxe:
LOG(expressão_numérica)
Observações:
expressão_numérica é qualquer expressão numérica maior que 0.
O logaritimo natural é o logaritmo na base e.
Exemplo:

INPUT "Digite um numero: ", NUM
IF NUM >0 THEN
  PRINT "LOG de"; NUM; "eh" LOG(NUM)
ELSE
  PRINT "O valor deve ser maior que zero"
END IF

Função relacionada: EXP

LONG (Palavra-Chave)
Especifica uma variável de valor numérico inteiro-longo para declaração de variáveis ou lista de parâmetros… Clique aqui para mais detalhes.

LOOP (Palavra-Chave)
Ordena a repetição de um conjunto de instrução a partir do comando DO.
Sintaxe:
LOOP [UNTIL expressão_booleana]
Observação:
LOOP ordena a repetição incondicional ou condicionado pela Palavra-Chave UNTIL até que a expressão_booleana seja satisfeita.
UNTIL é uma Palavra-chave para indicar que LOOP (laço, repetição) não será executado caso expressão_booleana seja verdade.
expressão_booleana é qualquer expressão. Cada expressão_booleana gera uma flag (bandeira) que sinaliza como Verdadeiro ou Falso.
Para detalhe e exemplo, veja: DO [UNTIL] e DO WHILE

LPOS (Função)
Devolve a posição corrente da cabeça de impressão dentro de um buffer de impressão.
Sintaxe:
LPOS (número_impressora)
Observações:
número_impressora é o número da impressora de interesse: 1 é LPT1, 2 é LPT2 e assim por diante.
Nem todas as impressoras suportam LPOS.
Exemplo:

FOR I% = 1 TO 100              'Executa um Loop FOR-NEXT de 100 repetições
  LPRINT I%;                   'Imprime números na mesma linha (concatenados com ";")
  IF LPOS(1) > 50 THEN LPRINT  '◄┬Quando a cabeça de impressão passar do 50º caractere
NEXT I%                        ' └quebra a concatenação e pula para próxima linha

LPRINT (Comando)
Imprime na impressora LPT1.
Sintaxe:
LPRINT [lista_saída] [;|,]
Observações:
lista_saída é uma lista de expressões numéricas ou string a serem impressas. Expressões devem estar separadas por vírgulas ou ponto e vírgula.
Um ponto e vírgula após a lista de saída deixa a cabeça de impressão posicionada no próximo caractere; uma vírgula deixa a cabeça de impressão na próxima posição de tabulação. LPRINT sem nenhum argumento faz o carro da impressora pular uma linha. LPRINT aceita enviar caracteres de comando de impressora. Se não houver concatenação nem tabulação, LPRINT envia um retorno do carro (ASCII=13) e uma alimentação de linha (ASCII=10) no final de cada lista_saída. LPRINT tem comportamento na impressora semelhante ao comando PRINT na tela.
Exemplo

LPRINT "Isto é a linha 1"
LPRINT "Isto está na";
LPRINT " linha 2"

A execução deste programa produz a seguinte saída:

Isto é a linha 1
Isto está na linha 2

Comandos relacionados: LPRINT USING; PRINT; PRINT USING; WIDTH

LPRINT USING (Comando)
Imprime saída formatada na impressora LPT1
Sintaxe:
LPRINT USING string_formato; lista_saída[;|,]
Observações:
string_formato é o formato de saída. Veja PRINT USING para uma lista de caracteres de formatação.
lista_saída é uma lista de expressões numéricas e string a serem impressas. Expressões devem estar separadas por vírgulas ou ponto e vírgulas.
Um ponto de vírgula após a lista_saída deixa a cabeça de impressão posicionada no próximo caractere. Uma vírgula deixa a cabeça de impressão na próxima posição de tabulação.
Tanto string_formato quanto lista_saída podem ser expressos através de variáveis.
Exemplo:

'Imprime na LPT1 quatro nomes e quatro valores formatados por USING 
X% = 4
FORMATO$ = "##&& **$###.##"
FOR I% = 1 TO X%
  READ NOME$, VALOR
  LPRINT USING FORMATO$; I%; "-"; LEFT$(NOME$ + STRING$(15, 32), 15); VALOR
NEXT I%
DATA "ANTONIO MARIA",1527.346
DATA "PAULO HENRIQUE",3415.1
DATA "MANOEL SATIRO",821
DATA "TEREZINHA",2321

A execução deste programa produz a seguinte saída na LPT1:

1-ANTONIO MARIA *$1527.35
2-PAULO HENRIQUE *$3415.10
3-MANOEL SATIRO **$821.00
4-TEREZINHA *$2321.00

Comandos relacionados: LPRINT; PRINT USING; WIDTH

LSET (Comando)
Move dados justificando (alinhamento) pela esquerda, para uma variável_campo de registro num buffer de arquivo aberto para acesso aleatório.
Sintaxe:
LSET variável_campo = expressão_string
Observações:
variável_campo é uma variável vinculada a um campo específico no buffer de registro em um arquivo aberto para acesso aleatório (randômico).
Se à uma variável_campo for atribuído qualquer valor sem os comandos LSET ou RSET, esta variável deixará de compor os campos do registro do arquivo cujo comando FIELD está vinculado, ficando o respectivo campo sem possibilidade de receber novos dados e mantendo-o com o último dado atribuído, a menos que outro comando FIELD vincule a variável_campo novamente.
Várias variável_campo podem compor o mesmo campo de registro de um mesmo arquivo aberto, desde que outros comandos FIELD vinculado ao mesmo buffer, atribuam outras variável_campo.
expressão_string é qualquer expressão string (variável ou constante).
Exemplo

'Abre um arquivo, move dados para os campos de cada registro, grava-os, 
'depois lê os registros de forma invertida e utilizando variáveis_campo diferentes
'Em ambos foram utilizados campos e maneiras diferentes para operar o mesmo arquivo
CLS: X% = 5: BUF% = FREEFILE
OPEN "TESTE.DAT" FOR RANDOM SHARED AS #BUF% LEN = 15
FIELD #BUF%, 2 AS DIA$, 9 AS MES$, 4 AS ANO$
FIELD #BUF%, 11 AS DM$, 4 AS AN$
FIELD #BUF%, 15 AS DADO$
FOR I% = 1 TO X%
  READ D%, M$, A&
  IF I% < 3 THEN
    LSET DIA$ = MKI$(D%)
    LSET MES$ = M$
    LSET ANO$ = MKL$(A&)
  ELSE
    LSET DM$ = MKI$(D%) + M$
    LSET AN$ = MKL$(A&)
  END IF
  PUT #BUF%, I%
NEXT I%
FOR I% = X% TO 1 STEP -1
  GET #BUF%, I%
  IF I% < 3 THEN
    PRINT CVI(DIA$); MES$; CVL(ANO$)
  ELSEIF I% < 5 THEN
    PRINT CVI(DM$); RIGHT$(DM$, 9); CVL(AN$)
  ELSE
    PRINT CVI(DADO$); MID$(DADO$, 3, 9); CVL(RIGHT$(DADO$, 4))
  END IF
NEXT I%
CLOSE #BUF%
DATA 1,JANEIRO,1945
DATA 6,FEVEREIRO,2350
DATA 12,ABRIL,2006
DATA 15,MAIO,10105
DATA 30,NOVEMBRO,1990

A execução deste programa produz a seguinte saída:

30 NOVEMBRO 1990
15 MAIO 10105
12 ABRIL 2006
6 FEVEREIRO 2350
1 JANEIRO 1945

Comandos relacionados: RSET

LTRIM$ (Função)
Remove todos caracteres brancos do início de uma expressão string.
Sintaxe:
LTRIM$(expressão_string)
Observações:
expressão_string é qualquer expressão string.
Se uma string somente contiver caracteres banco (ASCII=32), LTRIM$ devolverá uma string vazia.
Exemplo:

CLS
A$ = "   "                       'Variável composta por apenas três espaços brancos
B$ = "   Teste de Trim"          'Variável com três espaços esquerdos brancos
PRINT 1; A$; "..."               'Três caracteres brancos serão impressos seguidos dos três pontos
PRINT 2; B$; "..."               'Esta variável inclusivo os três espaços esquerdos brancos serão impressos seguida de três pontos
PRINT 3; LTRIM$(A$); "..."       'Esta variável é composta por apenas 3 caracteres brancos, serão eliminados e nada será impresso mas somente os três pontos
PRINT 4; LTRIM$(B$); "..."       'Todos espaços brancos esquerdos são eliminados na impressão
PRINT 5; LTRIM$(A$ + B$); "..."  'As variáveis A$ e B$ são concatenados e todos espaçaos eliminados na impressão

A execução deste programa produz a seguinte saída:

1       …
2       Teste de Trim…
3 …
4 Teste de Trim…
5 Teste de Trim…

Função relacionada: RTRIM$


┌─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┐
ABCDEFGHI-JKLMNOPQRSTUVWX-Z
└─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┘
MID$ (Função)
Devolve a parte intermediária de uma expressão string a começar pela posição determinada até alcançar o tamanho determinado.
Sintaxe:
MID$(expressão_string, posição_inicial[, comprimento])
Observações:
expressão_string é qualquer expressão que seja uma string.
posição_inicial é a posição do primeiro caractere a partir do qual será devolvido todos caracteres que componham o comprimento.
comprimento é a quantidade de caracteres que serão devolvidos a partir da posição_inicial. Se comprimento for omitido ou tiver um valor que ultrapasse o limite da expressão_string, MID$ devolverá todos os caractgeres desde a posição_inicial até o fim da expressão_string.
Exemplo:

CLS
A$ = "AbcdEfghIjklmnOpqrstUvwxyz"
B$ = "DEFGHIJKLMNOP"
PRINT A$
PRINT B$
PRINT STRING$(26, 196)
PRINT MID$(A$, 1, 5)
PRINT MID$(A$, 4, 3)
PRINT MID$(B$, 6)
X% = INSTR(LCASE$(A$), LCASE$(B$))
IF X% THEN
  FOR I% = 1 TO LEN(A$)
    IF (I% >= X%) AND (I% < X% + LEN(B$)) THEN COLOR 2 ELSE COLOR 7
    PRINT MID$(A$, I%, 1);
  NEXT
  COLOR 7: PRINT
  PRINT TAB(X%); B$
END IF

A execução deste programa produz a seguinte saída:

AbcdEfghIjklmnOpqrstUvwxyz
DEFGHIJKLMNOP
──────────────────────────
AbcdE
dEf>
IJKLMNOP
AbcdEfghIjklmnOpqrstUvwxyz
   DEFGHIJKLMNOP

Funções relacionadas: LEFT$; LEN; RIGHT$
Comando relacionado: MID$

MID$ (Comando)
Troca uma porção intermediária de uma string por outra porção string.
Sintaxe:
MID$(variável_string, posição_inicial[, quantidade_caracteres]) = expressão_string
Observações:
variável_string é a variável string que terá uma porção modificada por expressão_string.
posição_inicial é a posição do primeiro caractere da variável_string a ser trocado.
quantidade_caracteres é a quantidade de caracteres da variável_string a partir da posição_inicial que será trocada; se esta quantidade for omitida, MID$ entenderá que é a quantidade de expressão_string e trocará todos. Se a expressão_string for maior que a quantidade_caracteres, MID$ eliminará (trunca) o restante. Se expressão_string for menor que a quantidade_caracteres, MID$ trocará a parte da porção por todos os caracteres de expressão_string e mantrá o restante da porção dos caracteres originais de variável_string.
O tamanho (LEN) da variável_string jamais será alterado, nem para mais nem para menos.
Exemplo:

A$ = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
B$ = "123456789"

C$ = A$
MID$(C$, 10, 9) = B$
PRINT C$

C$ = A$
MID$(C$, 10, 9) = "123"
PRINT C$

C$ = A$
MID$(C$, 10, 5) = B$
PRINT C$

A execução deste programa produz a seguinte saída:

ABCDEFGHI123456789STUVWXYZ
ABCDEFGHI123MNOPQRSTUVWXYZ
ABCDEFGHI12345OPQRSTUVWXYZ

Função relacionada: MID$

MKC$ (Função)
Converte um valor monetário com até 15 dígitos significativos e até 4 casas decimais, para uma string de 8 bytes, para saída em um arquivo de acesso aleatório através do comando PUT.
Sintaxe:
MKC$(expressão_numérica)
Observações:
expressão_numérica é um expressão numérica geralmente referente a um valor monetário.
Exemplo:
Veja MKD$
Funções relacionadas: CVC; CVD; CVI; CVL; CVS; MKD$; MKI$; MKL$; MKS$

MKD$ (Função)
Converte um valor de dupla precisão para uma string de 8 bytes, para saída em um arquivo de acesso aleatório através do comando PUT.
Sintaxe:
MKD$(expressão_numérica)
Observações:
expressão_numérica é um expressão numérica de dupla precisão.
Exemplo:

CLS
OPEN "TESTE.DAT" FOR RANDOM SHARED AS #1 LEN = 28
FIELD #1, 20 AS NOME$, 8 AS SALARIO$
LSET NOME$ = "PEDRO ALVARES CABRAL": LSET SALARIO$ = MKD$(16345.62): PUT #1, 1
LSET NOME$ = "PRINCESA ISABEL": LSET SALARIO$ = MKD$(7962.25): PUT #1, 2
LSET NOME$ = "DEODORO DA FONSECA": LSET SALARIO$ = MKD$(4526): PUT #1, 3
FOR I% = 1 TO 3
  GET #1, I%
  PRINT USING "& ########.##"; NOME$; CVD(SALARIO$)
NEXT
CLOSE #1

A execução deste programa produz a seguinte saída:

PEDRO ALVARES CABRAL   16345.62
PRINCESA ISABEL         7962.25
DEODORO DA FONSECA      4526.00

Funções relacionadas: CVC; CVD; CVI; CVL; CVS; MKC$; MKI$; MKL$; MKS$

MKDIR (Comando)
Cria um determinado subdiretório no DOS.
Sintaxe:
MKDIR nome_diretório
Observações:
nome_diretório é uma expressão string que determina o nome do subdiretório a ser criado.
Exemplo:

CLS
ON ERROR GOTO TRATAERRO
NOME$ = "PASTADIR"
MKDIR NOME$
CHDIR NOME$
FILES
PRINT
PRINT "ESTAMOS NO NOVO DIRETORIO CRIADO"
PRINT "Pressione qualquer tecla para continuar"
SLEEP
CLS
CHDIR ".."
FILES
PRINT
PRINT "ESTAMOS DE VOLTA AO DIRETORIO DE ORIGEM"
PRINT "Pressione qualquer tecla para continuar"
SLEEP
END
TRATAERRO:
IF ERR = 75 THEN PRINT "O DIRETORIO JAH EXISTE"
RESUME NEXT

Na primeira execução deste programa, irá criar um subdiretório de nome “PASTADIR”, e as demais execuções enviarão a mensagem “O DIRETORIO JAH EXISTE”. Em todas as execuções o programa navegará para dentro do novo diretório criado, listará os arquivos nele existente (a princípio não existirá nenhum arquivo), aguardará uma tecla ser pressionada, voltará ao diretório de origem e listará os arquivos nele existente e aguardará uma tecla ser pressionada.
Funções relacionadas: ERDEV; ERL; ERR
Comandos relacionados: ON ERROR; RESUME

MKDMBF$ (Função)
Converte uma valor de dupla precisão armazenado no formato IEEE para uma string de 8 bytes contendo um valor no formato binário Microsoft, para saída em um arquivo de acesso aleatório através de PUT.
Sintaxe:
MKDMBF$(expressão_numérica)
Observações:
expressão_numérica é uma expressão numérica de dupla precisão.
Exemplo:
Veja MKSMBF$
Funções relacionadas: CVDMBF; CVSMBF; MKSMBF$

MKI$ (Função)
Converte um valor inteiro em uma string de 2 bytes para saída em um arquivo de acesso aleatório através de PUT.
Sintaxe:
MKI$(expressão_numérica)
Observações:
expressão_numérica é uma expressão numérica inteira.
Exemplo:
Veja MKD$.
Funções relacionadas: CVC; CVD; CVI; CVL; CVS; MKC$; MKD$; MKL$; MKS$

MKL$ (Função)
Converte um valor inteiro longo em uma string de 4 bytes para saída em um arquivo de acesso aleatório através de PUT.
Sintaxe:
MKL$(expressão_numérica)
Observações:
expressão_numérica é uma expressão numérica de valor inteiro longo.
Exemplo:
Veja MKD$.
Funções relacionadas: CVD; CVI; CVL; CVS; MKD$; MKI$; MKS$

MKS$ (Função)
Converte um valor de precisão simples em uma string de 4 bytes para saída em um arquivo de acesso aleatório através de PUT.
Sintaxe:
MKS$(expressão_numérica)
Observações
expressão_numérica é uma expressão numérica inteira.
Exemplo:
Veja MKD$
Funções relacionadas: CVD; CVI; CVL; CVS; MKD$; MKI$; MKL$

MKSMBF$ (Função)
Converte um valor de precisão simples armazenado no formato IEEE para uma string de 4 bytes contendo um valor em formato binário Microsoft, para saida em um arquivo de acesso aleatório através de PUT.
Sintaxe:
MKSMBF$(expressão_numérica)
Observações:
expressão_numérica é uma expressão numérica de precisão simples.
Exemplo

CLS
TYPE EmpRec
  nome AS STRING * 20
  salario AS STRING * 4
END TYPE
DIM empregado AS EmpRec
BUF% = FREEFILE
OPEN "SALARIO.DAT" FOR RANDOM SHARED AS #BUF%
empregado.nome = "Pedro"
empregado.salario = MKSMBF$(6500)
PUT #BUF%, 1, empregado
empregado.nome = ""
empregado.salario = MKSMBF$(0)
PRINT "Nome: "; empregado.nome
PRINT "Salario:"; CVSMBF(empregado.salario)
GET #BUF%, 1, empregado
PRINT "Nome: "; empregado.nome
PRINT "Salario:"; CVSMBF(empregado.salario)
CLOSE #BUF%

A execução deste programa produz a seguinte saída:

Nome:
Salario: 0
Nome: Pedro
Salario: 6500

Funções relacionadas: CVDMBF; CVSMBF; MKDMBF$

MOD (Função)
Retorna um número inteiro que é o resto da divisão de um número por outro, depois destes números (dividendo e divisor) serem arredondados para um inteiro mais próximo (.0 até .5 arredonda para .0 e .6 até .9 arredonda para 1).
Sintaxe:
primeiro_número MOD segundo_número
Observações:
primeiro_número e segundo_número são expressões numéricas quaisquer. MOD executa a divisão entre duas expressões numéricas até antes de atingir a parte fracionária do quociente, e devolve o resto da divisão. Um dividendo menor que o divisor, sequer chega a ser dividido, e MOD devolve o dividendo como sendo o resto.
Exemplo

CLS
PRINT "7 MOD 5 ="; 7 MOD 5
PRINT "19 MOD 6.4 ="; 19 MOD 6.4
PRINT "19 MOD 6.5 ="; 19 MOD 6.5
PRINT "19 MOD 6.6 ="; 19 MOD 6.6
PRINT "19 MOD 6.7 ="; 19 MOD 6.7
PRINT "19 MOD 6.8 ="; 19 MOD 6.8
PRINT
X = 0
FOR I% = 1 TO 40
  X = (X + 1) MOD 10
  PRINT X;
  IF X = 0 THEN PRINT
NEXT

A execução deste programa produz a seguinte saída:

7 MOD 5 = 2
19 MOD 6.4 = 1
19 MOD 6.5 = 1
19 MOD 6.6 = 5
19 MOD 6.7 = 5
19 MOD 6.8 = 5

1 2 3 4 5 6 7 8 9 0
1 2 3 4 5 6 7 8 9 0
1 2 3 4 5 6 7 8 9 0
1 2 3 4 5 6 7 8 9 0


┌─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┐
ABCDEFGHI-JKLMNOPQRSTUVWX-Z
└─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┘
NAME (Comando)
Muda o nome de um arquivo ou diretório (pasta) em um unidade de memória qualquer.
Sintaxe:
NAME nome_velho AS nome_novo
Observações:
nome_velho é uma expressão string contendo o nome de um arquivo ou nome de diretório (pasta) existente.
nome_novo é uma expressão string contendo o nome desejado de arquivo ou diretório (pasta). Não deve existir outro arquivo ou diretório com este mesmo nome no mesmo diretório em que se esteja mudando o nome.
NAME não aceita ambiguidades. NAME é equivalente ao comando RENAME e REN do DOS.
Exemplo:

NAME "VELHO.DAT" AS "NOVO.DAT"

Comando relacionado: FILES; KILL

NEXT (Palavra-Chave)
Ordena a execução da próxima instrução do programa em caso de erro, ou ordena a repetição de um laço (loop) FOR…NEXT.
Sintaxe:
RESUME NEXT
ou
NEXT [variável_contadora][, variável_contadora]…
Observações
variável_contadora é uma variável definida no comando FOR, e que irá incrementar ou decrementar de um passo (STEP) a cada NEXT encontrado no programa.
A primeira forma de NEXT, ordena ao Quick-Basic ignorar o erro ocorrido e executar a próxima instrução do programa.
A segunda forma de NEXT, ordena repetir o laço (loop) a partir do comando FOR correspondente, até que a variável_contadora atinja o limite determinado na instrução do comando FOR.
Exemplo:

CLS     'Lê e ordena alfabeticamente 10 nomes
ON ERROR GOTO TRATAERRO
X% = 10
DIM A$(1 TO X%)
FOR I% = 1 TO X%
  READ A$(I%)
NEXT
FOR I% = 1 TO (X% - 1)
  FOR J% = I% + 1 TO X%
    IF A$(I%) > A$(J%) THEN SWAP A$(I%), A$(J%)
NEXT J%, I%
FOR I% = 1 TO X% + 1    'Aqui ocorrerá um erro de subscrito fora da dimensão (1 TO 10)
  PRINT A$(I%); " - ";  'mas os 10 nomes já estarão exibidos
NEXT
PRINT "Esta mensagem estah depois do erro ocorrido no loop fora do intervalo."
DATA "MARIA","ANA","PAULO","BRUNO","TADEU","CARLOS","ZILDA","BRENO","FLORA","JUDAS"
END
TRATAERRO:
PRINT
PRINT "Ocorreu erro Nº"; ERR;
IF ERR = 9 THEN PRINT "Subscrito fora do intervalo"
RESUME NEXT

A execução deste programa produz a seguinte saída:

ANA – BRENO – BRUNO – CARLOS – FLORA – JUDAS – MARIA – PAULO – TADEU – ZILDA –
Ocorreu erro Nº 9 Subscrito fora do intervalo
Esta mensagem estah depois do erro ocorrido no loop fora do intervalo.

Comandos relacionados: ON ERROR; FOR

NOT (Operador-Booleano)
Devolve o complemento de uma expressão numérica como negação do valor à expressão original.
Sintaxe:
resultado = NOT expressão
Observações:
resultado é o valor devolvido por NOT.
expressão é qualquer expressão numérica ou string.
O operador booleano NOT avalia cada bit em expressão_numérica E devolve o valor de cada bit invertido (negado): 0 é negado tornando-se 1, e 1 = é negado tornando-se 0. Valor falso é representado por 0 e valor verdadeiro é representado por 1; o valor verdadeiro acompanha o sinal negativo (-) oriundo do último bit do byte de status, de operação bem sucedida (1).
Exemplo:

CLS
PRINT NOT 0
PRINT NOT -1
PRINT NOT "Maria" = "Maria"
PRINT NOT "Paulo" <> "Paulo"
PRINT NOT "Maria" = "Paulo"

A execução deste programa produz a seguinte saída:

-1
0
0
-1
-1

Veja também: AND (Operador-Booleano)


┌─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┐
ABCDEFGHI-JKLMNOPQRSTUVWX-Z
└─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┘
OCT$ (Função)
Devolve uma string contendo a representação octal de uma expressão inteira.
Sintaxe:
OCT$(expressão_numérica)
Observações:
Octal é o sistema de numeração de base 8.
expressão_numérica é qualquer expressão numérica.
Exemplo:
Veja HEX$.
Fução relacionada: HEX$

OFF

ON

ON ERROR GOTO (Comando)
Habilita o tratamento de erros e determina a primeira linha de programação da para a qual o programa será desviado caso ocorra um erro.
Sintaxe:
ON ERROR GOTO local
Observações:
Veja ERR para uma lista de possíveis erros.
local é um número de linha ou rótulo (etiqueta) da primeira linha da rotina de tratamento de erro. Um número de linha 0 (zero) desabilita o tratamento de erros. Se o tratamento de erros estiver desabilitado, a ocorrência de qualquer erro resultará em uma mensagem de erro emitido incondicionalmente e o encerramento do programa.
Exemplo

CLS
ON ERROR GOTO TRATAERRO
Y = 5: X = 0
PRINT Y; "/"; X; "="; Y / X 'Aqui ocorrerá um erro n.11: "DIVISÃO POR ZERO" 
RETURN                      'Aqui ocorrerá um erro n.3: "RETURN SEM GOSUB"
END
TRATAERRO:
IF ERR = 11 THEN
  PRINT "... OCORREU DIVISAO POR ZERO": X = X + 1: RESUME
ELSE
  PRINT "OCORREU ERRO N."; ERR: RESUME NEXT
END IF

A execução deste programa produz a seguinte saída:

5 / 0 =… OCORREU DIVISAO POR ZERO
5 / 1 = 5
OCORREU ERRO N. 3

Funções relacionadas: ERRDEV; ERL; ERR
Comandos relacionados: RESUME

ON evento GOSUB (Comando)
Especifica a primeira linha de uma sub-rotina de tratamento de evento.
Sintaxe:
ON COM(n) GOSUB local
ON KEY(n) GOSUB local
ON PEN(n) GOSUB local
ON PLAY(tamanho_fila) GOSUB local
ON STRIG(n) GOSUB local
ON TIMER(n) GOSUB local
ON UEVENT GOSUB local
Observações:
O comando ON COM(n) GOSUB desvia para a sub-rotina sempre que são recebidos caracteres em uma determinada porta serial.
O comando ON KEY(n) GOSUB local desvia para a sub-rotina sempre que uma tecla associada com um determinado número seja pressionada.
O comando ON PEN(n) GOSUB local desvia para a sub-rotina sempre que uma caneta ótica for ativada.
O comando ON PLAY(tamanho_fila) GOSUB local desvia para a sub-rotina sempre que o número de notas em um buffer de música vai de tamanho_fila para tamanho_fila1. tamanho_fila deve estar no intervalo de 1 a 32.
O comando ON STRIG(n) GOSUB local desvia para a sub-rotina sempre que o botão de um deterrminado joystick for pressionado. Veja o comando STRIG para valores válidos para n.
O comando ON TIMER(n) GOSUB local desvia para a sub-rotina sempre que um número determinado de segundos houver transcorrido. O número de segundos deve estar no intervalo de 1 e 86400.
O comando ON UEVENT GOSUB local desvia para a sub-rotina sempre que um evento definido pelo usuário ocorrer.
Exemplo:

ON KEY(10) GOSUB MostraAjuda
KEY(10) ON
PRINT "Pressione F10 para ajuda"
DO
  INPUT "Digite seu nome"; n$
  PRINT n$
LOOP UNTIL UCASE$(n$) = "SAIR"
END
MostraAjuda:
PRINT "Digite SAIR em vez do nome"
RETURN

Comandos relacionados: COM(n); KEY(n); PEN; PLAY (Intercepção de eventos); STRIG; TIMER

ON expressão DESVIOS (Comando)
Desvia para um entre vários locais baseado no valor de uma expressão.
Sintaxe:
ON expressão_numérica GOSUB local[, local]…
ON expressão_numérica GOTO local[, local]…
Observações:
expressão_numérica é qualquer expressão numérica no intervalo de 0 a 255. Se necessário, Quick-Basic arredonda a expressão para um valor inteiro.
local é uma lista de números de linhas ou rótulos para os quais será efetuado o desvio. Se o resuldado da expressão numérica é 1, a execução desvia para o primeiro local. Se a expressão é 2, desvia para o segundo local, e assim por diante. Se o valor de expressão_numérica for zero (0) ou não possuir rótulo correspondente, a execução continua no comando seguinte.
Exemplo:

CLS
FOR I% = 1 TO 3
  ON I% GOSUB UM, 100, TRES
NEXT
END
UM: PRINT "Estou em"; I%: RETURN
100 PRINT "Estou em"; I%: RETURN
TRES: PRINT "Estou em"; I%: RETURN

A execução deste programa produz a seguinte saída:

Estou em 1
Estou em 2
Estou em 3

OPEN (Comando)
Abre um arquivo ou dispositivo para operações de entrada e/ou saída.
Sintaxe:
OPEN nome_arquivo [FOR modo_acesso] [ACCESS acesso_rede] [tipo_lock] AS [#]número_arquivo [LEN = tamanho_registro]
OPEN modo, [#]número_arquivo, nome_arquivo[, tamanho_registro]
OPEN “COMn: com_básico com_específico” [FOR modo_acesso] AS [#]número_arquivo [LEN = tamanho_registro]
Observações:
nome_arquivo é uma expressão string contendo o nome de um arquivo ou dispositivo a ser aberto.
modo_acesso especifica como o arquivo deve ser usado: INPUT, OUTPUT, APPEND, RANDOM ou BINARY.
modo_rede proporciona maiores detalhes sobre como o arquivo deve ser usado em ambiente de rede com arquivos compartilhados: READ, WRITE ou READ WRITE.
tipo_lock é o tipo de bloqueio de arquivo usado em ambiente de arquivo compartilhado: SHARED,LOCK READ, LOCK WRITE ou LOCK READ WRITE.
número_arquivo é um número inteiro associado ao arquivo para operações de leitura, gravação e fechamento.
tamanho_registro é o número de bytes em cada registro. Para arquivos sequenciais, se omitido, é usado 512; para arquivos de acesso aleatório, se omitido, este valor será 128. Este valor jamais poderá exceder 32767 bytes.
modo é usado para programas BASIC antigo. Esta string de uma letra especifica o modo de acesso: A=Append; B=Binário; I=Entrada(input); O=Saída(output); R=Randômico(aleatório).
n é o número da porta de comunicação a ser aberta, tanto 1 ou 2.
com_básico representa os parâmetros básicos de comunicação de dados, separados por vírgulas, na seguinte forma:
[baund][,paridade][,bits_dados][,bits_parada]
baund é a taxa de transmissão usada pelo dispositivo: 75, 110, 150, 300, 600, 1200, 1800. 2400, 4800, 9600 ou 19200.
paridade é a paridade usada pelo dispositivo: N=Nenhum; E=par; O=ímpar; S=espaço; M=marca.
bits_dados é o número de bits em cada palavra de dados: 5; 6; 7 ou 8.
bits_parada é o número de bits de parada transmitidos para cada palavra de dados: 1; 1,5 ou 2.
com_específico é uma lista de dados específicos da comunicação de dados, separados por vírgulas:
ASC Abre dispositivo em modo ASCII;
BIN Abre dispositivo em modo binário;
CD[milissegundos] Especifica tempo máximo a aguardar pelo sinal de recepção de dados;
CS[milissegundos] Especifica tempo máximo a aguardar pelo sinal de pronto para transmissão;
DS[milissegundos] Especifica tempo máximo a aguardar pelo sinal de dados recebidos;
LF Envia uma mudança de linha após cada retorno de carro;
OP[milissegundos] especifica tempo máximo a aguardar para a execução do comando OPEN;
RB[bytes] Determina o tamanho do buffer de recepção;
RS Suprime a detecção do sinal de solicitação de transmissão (RTS);
TB[bytes] Determina o tamanho do buffer de transmissão.
Exemplo:

OPEN "TESTE.DAT" FOR INPUT AS #1
OPEN "COM1:4800,E,8,1,BIN" AS #2
OPEN "MALA.DAT" FOR OUTPUT AS #3
BUF% = FREEFILE: OPEN "NOVO.DAT" FOR RANDOM SHARED AS #BUF% LEN = 80
CLOSE

Função relacionada: FREEFILE
Comando relacionado: CLOSE; FIELD; GET; INPUT$(x, BUF%); LINE INPUT #; PRINT #; PUT; WRITE #

OPTION BASE (Comando)
Define o limite inferior para os índices de matrizes declaradas sem este limite.
Sintaxe:
OPTION BASE 0
OPTION BASE 1

Observações:
Se você não especificar um limite inferior com este comando, Quick-Basic usa 0 (zero).
Você pode usar apenas um comando OPTION BASE em cada módulo de programa.
OPTION BASE serve apenas para definir se as próximas instruções DIM iniciarão do 0 (zero) ou do 1 (um).
Para maior flexibilidade use a cláusula TO no comando DIM em vez de OPTION BASE.
Exemplo:

CLS
OPTION BASE 1
DIM A(5 TO 20)
DIM B(20)
PRINT "Limites da variavel A: Inferior:"; LBOUND(A), "Superior:"; UBOUND(A)
PRINT "Limites da variavel B: Inferior:"; LBOUND(B), "Superior:"; UBOUND(B)

A execução deste programa produz a seguinte saída:

Limites da variavel A: Inferior: 5   Superior: 20
Limites da variavel B: Inferior: 1   Superior: 20

Funções relacionadas: LBOUND; UBOUND; TO
Comandos relacionados: DIM

OR (Operador Booleano)… Veja AND – Operador Booleano.

OUT (Comando)
Envia um byte para uma determinada porta.
Sintaxe:
OUT número_porta, valor_byte
Observações:
número_porta é uma expressão inteira no intervalo de 0 a 65535 que identifica a porta.
valor_byte é uma expressão inteira no intervalo de 0 a 255 a ser enviada para a porta.
Exemplo:
Veja INP
Função relacionada: INP

OUTPUT (Palavra-Chave)
Palavra chave na abertura de arquivos sequenciais no modo de acesso para entrada de dados… Veja: OPEN e APPEND.


┌─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┐
ABCDEFGHI-JKLMNOPQRSTUVWX-Z
└─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┘
PAINT (Comando)
Preenche uma imagem gráfica da tela com uma cor ou padrão específico.
Sintaxe:
PAINT [STEP] (x, y)[, cor][, cor_borda][, cor_fundo]
Observações:
A palavra reservada STEP indica que x e y são deslocamentos em relação à posição gráfica corrente, e não coordenadas físicas.
x e y é um conjunto de coordenadas dentro da imagem gráfica.
cor é a cor de preenchimento desejada. Se você omitir cor, PAINT usará a cor ativa corrente.
cor_borda é a cor do controno da imagem gráfica. Se você omitir, PAINT usará cor.
cor_fundo é uma string que determina a cor de fundo do contorno. Se você omitir cor_fundo, PAINT usará 0.
Exemplo:

SCREEN 1
LINE (10, 10)-(50, 50), 1, B
PAINT (11, 11), 2, 1

Comandos relacionados: circle; color; line; screen

PALETTE, PALETTE USING (Comando)
Troca uma ou mais cores da paleta de cores.
Sintaxe:
PALETTE [cor_a_trocar, nova_cor]
PALETTE USING matriz[(índice)]
Observações:
cor_a_trocar é o atributo de cor a ser trocado.
nova_cor é a nova cor a ser definida para o atributo.
matriz é o índice do primeiro elemento da matriz a ser usado na definição da paleta.
Se você omitir todos os argumentos, PALETTE restaura os valores originais das cores.
Exemplo:

PALETTE 0, 1

Comandos relacionados: COLOR; SCREEN

PCOPY (Comando)
Copia uma página de vídeo para outra.
Sintaxe:
PCOPY página_fonte, página_destino
Observações:
página_fonte é uma expressão inteira que especifica a página de vídeo a ser copiada.
página_destino é uma expressão inteira que especifica a página de vídeo para a qual deverá ser feita a cópia.
O número disponível de páginas de vídeo depende do tamanho da memória de vídeo e do modo de vídeo, que podem ser: 0, 1, 2, 3, 4, 7, 8, 9, 10, 11, 12, 13.
A página 0 (zero) é não gráfica e somente caracteres textos podem ser exibidos nela. As demais páginas são gráficas e nem sempre são aceitas quando operando em ambiente Windows. Mesmo quando não exibindo páginas gráficas, os comandos PCOPY serão executados em ambiente Windows.
Exemplo:

'Salva uma pagina de video e recupera-a depois de apagada 
FOR I% = 1 TO 100
 PRINT I%;
NEXT I%
PCOPY 0, 1
CLS
PCOPY 1, 0

A execução deste programa recuperará a tela apagada com o comando CLS.

PEEK (Função)
Devolve o byte armazenado em um determinado deslocamento de memória.
Sintaxe:
PEEK(deslocamento)
Observações:
deslocamento é uma expressão inteira (no intervalo de 0 a 65535) que determina um deslocamento dentro do segmento corrente.
O comando DEF SEG define o endereço do segmento corrente.
Exemplo:

'Salva o conteúdo da tela na variavel indexada CT()
DIM CT(3999) AS INTERGER
DEF SEG &HB800
FOR I% = 0 TO 3999
  CT(I%) = PEEK(I%)
NEXT
DEF SEG

Comandos relacionados: DEF SEG; POKE

PEN (Função)
Devolve as coordenadas da caneta ótica.
Sintaxe:
PEN(expressão_numérica)
Observações:
expressão_numérica é um valor inteiro, no intervalo de 0 a 9, que determina a informação que PEN devolve:
PEN(0) devolve -1 se a caneta for usada desde a última chamada; devolve 0 se a caneta não for usada desde a última chamada.
PEN(1) devolve a coordenada X do ponto da tela em que a caneta foi usada pela última vez.
PEN(2) devolve a coordenada Y do ponto da tela em que a caneta foi usada pela última vez.
PEN(3) devolve o uso atual: -1 = posicionada; 0 = afastada.
PEN(4) último valor conhecido da coordenada X.
PEN(5) último valor conhecido da coordenada Y.
PEN(6) linha de caracteres onde a caneta foi pressionada pela última vez.
PEN(7) coluna de caracteres onde a caneta foi pressionada pela última vez.
PEN(8) último valor conhecido para a linha de caractere.
PEN(9) último valor conhecido para a coluna de caractere.
Exemplo:

LINHA% = PEN(6)
COLUNA% = PEN(7)

PEN (Comando)
Habilita ou desabilita o tratamento dos eventos gerados pela caneta ótica.
SintaxeS:
PEN ON
PEN OFF
PEN STOP
Observações:
O comando PEN ON habilita o tratamento dos eventos gerados pela caneta ótica.
O comando PEN OFF desabilita o tratamento dos eventos da caneta ótica. Todos os eventos da caneta serão ignorados.
O comando PEN STOP suspende temporariamente o tratamento dos eventos da caneta. Todos os eventos ocorridos durante este período serão processados uma vez que o tratamento seja reabilitado.
Exemplo:

'Exibe o status da caneta otica atraves de ON PEN GOSUB que repassa o controle
'para a sub-rotina CANETA sempre que ocorrer um evento na caneta otica.
'Nota: Em algumas versoes ocorrerão conflitos entre o mouse e a caneta ótica
COLOR 0, 7: CLS     'Limpa a tela
PEN ON              'Habilita a caneta otica
ON PEN GOSUB CANETA 'Se houver evento na caneta, desvia para sub-rotina CANETA
DO
  LOCATE 23, 12: PRINT "Pressione a caneta otica contra a tela para ver um relatório."
  LOCATE 24, 17: PRINT "Pressione a barra de espaço para encerrar o programa;
LOOP UNTIL INKEY$ = " "
PEN OFF            'Desabilita a caneta otica.
COLOR 7, 0: CLS    'Limpa a tela
END                'Encerra o programa
CANETA:            'Sub-rotina que gera o relatório do status da caneta otica
DO
  P = PEN(3)
  'Reporta o status da caneta otica e captura as coordenadas X e Y
  LOCATE 10, 27: PRINT "Um evento na caneta otica ocorreu"
  LOCATE 24, 17: PRINT "Pressione qualquer tecla para sair desta reportagem";
  LOCATE 12, 30: PRINT "A caneta otica estah ";
  IF P THEN PRINT "pressionada": X = PEN(4): Y = PEN(5) ELSE PRINT "Afastada": X = 0: Y = 0
  'Reporta a posição X e Y da caneta otica
  LOCATE 14, 22: PRINT "Posiçao X ="; X; "   "
  LOCATE 14, 40: PRINT "Posiçao Y ="; Y; "   "
LOOP WHILE INKEY$ = ""
RETURN

Função relacionada: PEN
Comando relacionado: ON evento GOSUB

PLAY (Função)
Devolve o número de notas na fila de música de fundo.
Sintaxe:
PLAY(argumento_qualquer)
Observação
argumento_qualquer é qualquer argumento numérico. Ele simplesmente distingue a função PLAY do comando PLAY.
PLAY devolve 0 (zero) quando a música estiver no modo ativo.
Exemplo:

NOTA% = PLAY(0)

Comandos relacionados: ON evento GOSUB; PALY

PLAY (Comando)
Enute o som determinado pela expressão estring.
Sintaxe:
PLLAY expressão_string
Observações:
expressão_string é uma expressão string contendo um ou mais dos comandos seguintes:
Comandos de oitava:
> Incrementa em 1 a oitava até o máximo de 6.
< Decrementa em 1 a oitava até o mínomo de 0.
Onível Define a oitava corrente; nível tem de estar no intervalo de 0 a 6. Se não for definido, a oitava corrente será 4.
Comandos de duração:
Ltiponota define a duração de cada nota de 1 a 64. 1 é breve, 2 é semibreve e assim por diante. Se omitido, será 4.
ML Define legato entre notas.
MN Define música normal.
MS Define nota staccato.
Comandos de modo:
MF Define música como ativa (caso normal).
MB Define música como fundo (Até 32 notas podem ser tocadas enquanto executa o programa).
Comandos de tempo:
Pduração Especifica uma pausa de 1 a 64. 1 é breve, 2 é semibreve e assim por diante. Se omitido, a duração será 4.
Tnotas Define o tempo de 32 a 255. Se omitido, é usado 120.
Comando de som:
A-G Toca a nota específicada.
Nnota Toca uma nota de 0 a 84. 0 é uma pausa.
Comandos de sufixo:
# ou + Muda a nota para sustenido.
– Muda a nota para bemol.
. Toca a nota com duração de 3/2 da especificada.
A expressão string “X” + VARPTR$(string) executa a música contida na substring string.
Exemplo:

'Toca a escala em 7 diferentes oitavas
ESCALA$ = "CDEFGAB"
PLAY "L16"
FOR I = 0 TO 6
  PLAY "O" + LTRIM$(STR$(I))
  PLAY "X" + VARPTR$(ESCALA$)
NEXT I

Comandos relacionados: ON evento GOSUB; PLAY

PMAP()

POINT()

POKE

POS

PRESET

PRINT

PSET


┌─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┐
ABCDEFGHI-JKLMNOPQRSTUVWX-Z
└─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┘
QBX environment limits


┌─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┐
ABCDEFGHI-JKLMNOPQRSTUVWX-Z
└─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┘
RANDOM

RANDOMIZE

READ

REDIM

REM

RESET

RESTORE

RESUME

RETURN

RIGHT$()

RMDIR

RND()

RSET

RTRIM$()

RUN


┌─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┐
ABCDEFGHI-JKLMNOPQRSTUVWX-Z
└─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┘
SADD()

SCREEN()

SEEK()

SEG

SELECT

SETMEM()

SGN()

SHARED

SHELL

SIGNAL()

SIN()

SINGLE

SLEEP

SOUND

SPACE$()

SPC()

SQR()

SSEG()

SSEGADD()

STACK()

STATIC

STEP

STICK()

STOP

STR$()

STRING

STRING$()

SUB

SWAP

SYSTEM


┌─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┐
ABCDEFGHI-JKLMNOPQRSTUVWX-Z
└─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┘
TAB()

TAN()

THEN

TIME$()

TIMER()

TO

TYPE


┌─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┐
ABCDEFGHI-JKLMNOPQRSTUVWX-Z
└─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┘
UBOUND()

UCASE$()

UEVENT

UNLOCK

UNTIL

UPDATE

USING


┌─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┐
ABCDEFGHI-JKLMNOPQRSTUVWX-Z
└─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┘
VAL()

VARPTR()

VARPTR$()

VIEW


┌─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┐
ABCDEFGHI-JKLMNOPQRSTUVWX-Z
└─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┘
WAIT

WEND

WHILE

WIDTH

WINDOW

WRITE


┌─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┐
ABCDEFGHI-JKLMNOPQRSTUVWX-Z
└─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┘
XOR

Anúncios