Integer BASIC - Integer BASIC

Integer BASIC é um interpretador BASIC escrito por Steve Wozniak para os computadores Apple I e Apple II . Originalmente disponível em fita cassete para o Apple I em 1976, depois incluído na ROM do Apple II desde seu lançamento em 1977, foi a primeira versão do BASIC usada por muitos dos primeiros proprietários de computadores domésticos .

A linguagem suportava matemática usando inteiros , sem suporte de ponto flutuante . O uso de inteiros permitia que os números fossem armazenados em um formato de 16 bits muito mais compacto, que poderia ser lido e processado mais rapidamente do que os formatos de ponto flutuante de 32 ou 40 bits encontrados na maioria dos BASICs da época. No entanto, isso limitou sua aplicabilidade como uma linguagem de propósito geral.

Outra diferença com outros BASICs da época é que Integer BASIC tratava strings como arrays de caracteres, semelhante ao sistema em C ou Fortran 77 . Substrings foram acessados ​​usando o corte de matriz em vez de funções de string. Este estilo foi introduzido no HP Time-Shared BASIC e também pode ser encontrado em outros BASICs contemporâneos padronizados na HP, como North Star BASIC e Atari BASIC . Ele contrastava com o estilo encontrado em BASICs derivados de DEC , incluindo Microsoft BASIC .

A linguagem foi inicialmente desenvolvida com o nome de GAME BASIC e referida simplesmente como Apple BASIC quando foi introduzida no Apple I. Ela se tornou Integer BASIC quando foi portada para o Apple II e enviada junto com o Applesoft BASIC , uma versão do Microsoft BASIC que incluído suporte de ponto flutuante. O Integer BASIC foi descontinuado em favor do Applesoft BASIC, começando com o Apple II Plus em 1979.

História

No último ano do ensino médio , o professor de eletrônica de Steve Wozniak providenciou para que os principais alunos da classe tivessem estágios em empresas locais de eletrônicos. Wozniak foi enviado para a Sylvania, onde programou em FORTRAN em um IBM 1130 . Naquele mesmo ano, a General Electric instalou um terminal na escola que estava conectado a um de seus mainframes executando o serviço BASIC de compartilhamento de tempo, que eles estavam promovendo fortemente na época. Após três dias de acesso, os alunos foram solicitados a escrever cartas explicando por que a escola deveria receber um terminal permanentemente, mas seus esforços foram infrutíferos.

Alguns anos depois, Wozniak estava trabalhando na Hewlett-Packard (HP) executando simulações de projetos de chips e layout lógico para calculadoras. A HP fez grandes incursões no mercado de minicomputadores com suas máquinas HP série 2000 executando uma versão de compartilhamento de tempo personalizada do BASIC . Por aproximadamente US $ 100.000, pode-se construir uma máquina razoavelmente equipada que possa suportar entre 16 e 32 usuários executando programas BASIC. Embora caro, ainda era uma fração do custo das máquinas mainframe e, para usuários pesados, menos do que os serviços de compartilhamento de tempo. A HP seguiu isso com o HP 9830 , uma máquina do tamanho de um desktop por US $ 10.000 (equivalente a US $ 67.000 em 2020) que também executava o BASIC, ao qual Wozniak tinha acesso.

Em janeiro de 1975, o Altair 8800 foi anunciado e deu início à revolução do microcomputador . Em março, Wozniak participou da primeira reunião do Homebrew Computer Club e começou a formular o design de seu próprio computador. Um dos softwares mais importantes para o Altair, e um dos mais pirateados , foi o Altair BASIC da recém-formada Microsoft . Wozniak concluiu que sua máquina teria que ter um BASIC próprio, que seria, esperançosamente, o primeiro para o processador MOS Technology 6502 . Como a linguagem precisava de 4 kB de RAM, ele tornou essa memória o mínimo para o projeto.

As referências de Wozniak para BASIC foram uma cópia de 101 BASIC Computer Games e um manual HP BASIC. Ele não sabia que o BASIC da HP era muito diferente da variedade DEC BASIC usada nos 101 Games , que também era a base do Microsoft BASIC para o Altair. Com base nessas fontes, Wozniak começou a esboçar um gráfico de sintaxe para a linguagem. O design inicialmente incluía suporte de ponto flutuante, mas ainda esperando que ele pudesse publicar o primeiro BASIC no 6502 e se tornar "uma estrela", ele decidiu abandonar o ponto flutuante e escrever um sistema matemático inteiro separado para economizar algumas semanas de programação.

Wozniak mais tarde descreveria sua linguagem como "destinada principalmente a jogos e usos educacionais". Referindo-se a ele durante o desenvolvimento como "JOGO BÁSICO", Wozniak escreveu o código à mão, traduzindo as instruções do código assembler em seus equivalentes de código de máquina e, em seguida, enviando o resultado para seu computador. Sem nenhum treinamento sobre como escrever uma linguagem de computador, ele usou sua experiência com a calculadora HP para implementar uma máquina de pilha para interpretar expressões. Uma vez que as rotinas básicas estavam instaladas e funcionando, ele trabalhou nos outros comandos um por um de forma modular. A cada visita ao clube Homebrew, ele demonstrou mais alguns recursos adicionados no mês passado.

Anúncio do computador Apple I observando a política da Apple de fornecer software gratuito ou barato para seus computadores.

No início de 1976, anúncios de seu computador Apple I , a Apple Inc afirmou que "nossa filosofia é fornecer software para nossas máquinas gratuitamente ou a um custo mínimo" e "sim pessoal, o Apple BASIC é gratuito". Isso foi publicado logo após a infame Carta Aberta para Hobbyists de Bill Gates , que sugeria que as pessoas o estavam roubando copiando versões do Altair BASIC .

Wozniak ajudou Jobs, que trabalhava para a Atari , com uma reformulação do Breakout . Mais tarde, ele decidiu ver se era possível escrever o jogo em BASIC. Ele adicionou comandos para ler os controladores de remo e, ao longo de uma série de edições rápidas, tinha uma versão do jogo instalada e funcionando. Para melhorar a jogabilidade, ele adicionou um alto-falante para fazer cliques quando a bola atingisse as coisas. Enquanto o mostrava para Steve Jobs , Wozniak demonstrou que podia mudar rapidamente as cores que seu jogo usava, apenas alterando o código-fonte . Mais tarde, Wozniak escreveu que provou que "o software era muito mais flexível do que o hardware" e que ele e Jobs perceberam que "agora qualquer pessoa pode criar jogos de arcade sem ter que projetá-los no hardware".

Wozniak completou uma biblioteca de ponto flutuante para o 6502 e publicou-a na edição de agosto de 1976 do Dr. Dobb . Posteriormente, essa biblioteca foi incluída nas ROMs do Apple II . Wozniak começou a trabalhar no back-port do código de ponto flutuante para o Apple BASIC, mas se desviou na tarefa de projetar um controlador de disquete para o que se tornou o Disk II . Mike Markkula disse que a empresa iria ao Consumer Electronics Show em Las Vegas se o sistema de disco estivesse pronto a tempo, então Wozniak e Randy Wigginton trabalharam sem parar durante o feriado de 1977.

Quando voltou ao tópico de ponto flutuante no BASIC, Jobs reclamou que estava demorando muito. Sem que Wozniak soubesse, a empresa já havia conseguido uma licença com a Microsoft para receber sua versão 6502 recém-concluída do código Altair. Examinando o código MS, Wozniak decidiu que era mais fácil adicionar suporte gráfico a seu código do que adicionar seu próprio BASIC de ponto flutuante, já que o posterior exigia correção manual do código de máquina original enquanto o MS era escrito em assembler e mais facilmente modificado. O desenvolvimento do BASIC da Apple terminou em favor do que se tornou o Applesoft BASIC . Wozniak observou mais tarde, "Minha maior decepção foi para as funções de string terríveis como LEFT $ (VAR, 5) e MID $ (VAR2,5,3) em vez das minhas próprias".

Quando o Apple II foi lançado no verão de 1977, o Integer BASIC foi fornecido em ROM, enquanto o Applesoft BASIC foi enviado em fita cassete. Isso mudou com a introdução do Apple II Plus em 1979, quando a Applesoft foi incluída na ROM.

Descrição

Edição de programa

Como a maioria das implementações BASIC da época, Integer BASIC atuou tanto como o intérprete da linguagem quanto como o ambiente de edição de linha. Quando o BASIC estava em execução, um > prompt de comando foi exibido onde o usuário pode inserir instruções. Ao contrário das plataformas de computadores domésticos posteriores , o BASIC não era o ambiente padrão quando o Apple I começou, ele normalmente era iniciado no monitor . BASIC foi iniciado pressionando Ctrl+ BReturn.

As instruções inseridas com números iniciais são inseridas no armazenamento do programa para "execução adiada", seja como novas linhas ou substituindo qualquer uma que possa ter o mesmo número anteriormente. As instruções inseridas sem um número de linha eram chamadas de comandos e executadas imediatamente. Os números das linhas podem ser de 0 a 32.767 e as linhas podem conter até 128 caracteres.

Integer BASIC também incluiu o AUTOcomando para inserir automaticamente números de linha em um determinado número inicial AUTO 100, como , adicionando 10 ao último número a cada nova linha. AUTO 300,5começaria a numerar na linha 300 por cinco; 300, 305, etc. A numeração automática foi desligada digitando MAN.

Um recurso interessante do editor era que uma seção da tela poderia ser separada como a "janela", onde as atualizações ao vivo ocorriam. Normalmente, era a tela inteira, mas poderia ser limitada a uma área menor POKEinserindo valores nos locais de memória 32 a 35. Esse recurso poderia ser usado para criar uma área de texto editável enquanto o resto da tela estava no modo gráfico.

Depurando

Como na maioria dos BASICs, os programas eram iniciados com o RUNcomando e, como era comum, podiam ser direcionados a um número de linha específico como RUN 300. A execução pode ser interrompida a qualquer momento usando Ctrl+ Ce reiniciada com CONtinue, ao contrário do mais típico CONT.

Para execução passo a passo, a TRACEinstrução pode ser usada no prompt de comando ou colocada no próprio programa. Quando estava ligado, os números das linhas eram impressos para cada linha que o programa visitava. O recurso pode ser desativado novamente com NOTRACE.

Um recurso um tanto incomum era o DSPcomando (para "exibir"). Quando encontrado em um programa, daquele ponto em diante, qualquer alteração no valor de uma variável seria exibida. Por exemplo, DSP Xexibiria o valor de X toda vez que ele mudasse, junto com o número da linha onde a mudança ocorreu. Tal como acontece com o TRACE, o DSP foi desligado com NODSP.

Nomes de variáveis

Onde Dartmouth BASIC e HP-BASIC limitavam nomes de variáveis ​​a no máximo dois caracteres (uma única letra ou uma letra seguida por um dígito), e onde MS-BASIC permitia uma letra seguida por uma letra ou dígito opcional (ignorando os caracteres subsequentes), Integer BASIC era incomum no suporte a qualquer nome de variável de comprimento (por exemplo, SUM, GAMEPOINTS, PLAYER2). A única ressalva era que os nomes das variáveis ​​não podiam conter palavras reservadas; por exemplo, THISCOLOR e COLORFUL eram nomes de variáveis ​​inválidos porque continham a palavra-chave COLOR, um comando do sistema. Além disso, as linhas eram limitadas a 128 caracteres, de modo que os nomes das variáveis ​​não podiam exceder esse comprimento.

Matemática

Integer BASIC, como o próprio nome indica, usa inteiros como base para seu pacote matemático. Eles foram armazenados internamente como um número de 16 bits, little-endian (assim como o 6502). Isso permitia um valor máximo para qualquer cálculo entre -32767 e 32767; embora o formato também possa armazenar o valor -32768, o BASIC não pode exibir esse número. Cálculos que resultaram em valores fora desse intervalo produziram a >32767 ERR.

Operadores de infix incluídos +(adição), -(subbração), *(multiplicação), /(divisão), MOD (resto) e expoente usando o ^caractere. Operadores binários incluídos AND, ORe NOT. Comparações binárias incluído o conjunto padrão de =, >, <, >=, <=, <>e o HP-inspirado #, que era equivalente a <>.

Apenas matrizes unidimensionais eram permitidas, com tamanho limitado apenas pela memória disponível. As funções matemáticas eram esparsas; apenas ABS(valor absoluto), SGN(sinal) e RND(número aleatório) eram suportados. Em contraste com as versões derivadas do MS, onde o parâmetro era ignorado e RNDsempre retornava um valor 0 .. <1, Integer BASIC usava o parâmetro; RND(6)retornou um número inteiro de 0 a 5.

Cordas

O manuseio de strings do Integer BASIC foi baseado no sistema em HP BASIC. Isso tratava as variáveis ​​de string como matrizes de caracteres que precisavam ser DIMeditadas antes do uso. Isso é semelhante ao modelo em C ou Fortran 77 . Isso contrasta com os BASICs semelhantes a MS, em que as strings são um tipo intrínseco de comprimento variável. Antes que os BASICs derivados do MS se tornassem o padrão de fato , esse estilo não era incomum; North Star BASIC e Atari BASIC usaram o mesmo conceito, assim como outros.

Strings em Integer Basic usavam uma quantidade fixa de memória, independentemente do número de caracteres usados ​​nelas, até um máximo de 255 caracteres. Isso tinha a vantagem de evitar a necessidade de coleta de lixo do heap que era notoriamente lento no MS BASIC, mas significava que strings menores do que o comprimento declarado eram desperdiçadas.

O acesso à substring foi fornecido por meio da sintaxe de divisão de matriz . Por exemplo, PRINT A$(0,5)imprimiu os primeiros seis caracteres de A $, caracteres de 0 a 5. A concatenação foi fornecida usando o mesmo sistema, A$(5)="ABC"substituiu quaisquer caracteres começando na posição 5 pela string "ABC". Isso contrasta com o tratamento de string no estilo DEC / MS, que usa funções de string, como MID$acessar substrings e +concatenação.

Como muitos dos recursos que seriam fornecidos pelas funções de string foram, em vez disso, fornecidos por fracionamento de matriz, a seleção de funções de string foi reduzida. LENretornou o comprimento de uma string e ASCo código numérico ASCII da primeira letra de uma string. Faltou um equivalente ao CHR$que retornou o caractere ASCII com um determinado código numérico.

Gráficos e som

Quando lançado, o único controlador de jogo para a Apple era o controlador de remo , que tinha dois controladores em um único conector. A posição do controlador pode ser lida usando a PDLfunção, passando o número do controlador, 0 ou 1, assim , retornando um valor entre 0 e 255. A=PDL(0):PRINT A

As máquinas da Apple não incluíam hardware de som dedicado, apenas um simples "bip". A produção de sons foi realizada por meio PEEKda localização mapeada em memória do alto-falante, -16336. PEEKing repetidamente aquele valor produzia tons, e o manual sugeria o uso de uma expressão matemática para fazer isso, como . S=PEEK(-16336)-PEEK(-16336)-PEEK(-16336)-PEEK(-16336)-PEEK(-16336)

O suporte para gráficos foi mais detalhado. O modo gráfico foi ativado com a GRinstrução e desativado com TEXT. O desenho era modal e normalmente começava emitindo um comando para alterar a cor, o que era realizado definindo uma pseudo-variável; COLOR=12definiria a cor do desenho para 12, verde claro. Pode-se então PLOT 10,10produzir um único ponto daquela cor, HLIN 0,39 AT 20desenhar uma linha horizontal na linha 20 que abrange a tela ou VLIN 5,15 AT 7desenhar uma linha vertical mais curta na coluna 7. A=SCRN X,Yretorna a cor da tela em X, Y.

Entrada / saída

Integer BASIC não tinha nenhum comando de entrada / saída personalizado e também não tinha a DATAinstrução e o associado READ. Para inserir e retirar dados de um programa, a funcionalidade de entrada / saída foi redirecionada para um slot de cartão selecionado com o PR#xe IN#x, que redirecionou a saída ou entrada (respectivamente) para o slot numerado. A partir de então, os dados podem ser enviados para o cartão usando PRINTcomandos convencionais e lidos usando INPUT.

Outras notas

O BASIC inteiro incluía um TABrecurso que posicionava o cursor em uma determinada coluna de 0 a 39. Ele diferia das versões encontradas na maioria dos BASICs por ser um comando com um número a seguir, em oposição a uma função com o valor entre parênteses; alguém moveria o cursor para a coluna 10 usando TAB 10em Integer BASIC enquanto que em MS isso seria PRINT TAB(10). Além disso, o VTABcomando funcionou de forma semelhante, TABmas acrescentou espaços verticais em vez de horizontais. Por razões inexplicáveis, neste caso as coordenadas eram de 1 a 24, em vez de 0 a 23.

O BASIC inteiro inclui um POPcomando para sair dos loops. Isso retirou o primeiro item da pilha FOR. O Atari BASIC também suportava o mesmo comando, enquanto o North Star BASIC o usava EXIT.

O Integer BASIC ROMs também incluiu um monitor de código de máquina , "mini- assembler ", e disassembler para criar e depurar programas em linguagem assembly . Wozniak montou manualmente o monitor como o primeiro programa do Apple II e o usou para escrever Integer BASIC.

Palavras reservadas

Apple BASIC

O Apple BASIC tinha os seguintes comandos:

AUTO val1, val2
CLR [CLEAR]
DEL val1, val2
LIST val1, val2
RUN val1
SCR [SCRATCH / NEW]
HIMEM = expr
LOMEM = expr
(LET) var = expr
INPUT (prompt,) var1, var2 ...
PRINT item(s)
TAB expr
FOR var = expr1 TO expr2 STEP expr3
NEXT var
IF expr THEN statement
IF expr THEN line number
GOTO expr
GOSUB expr
RETURN
DIM var1(expr1), var2(expr2) ...
REM text
END
POKE expr1, expr2
CALL expr
Functions: ABS(), SGN(), PEEK(), RND(), LEN()

BÁSICO INTEIRO

BASIC inteiro adicionado o seguinte:

COLOR = expr
CON [CONTINUE]
DSP
GR
HLIN expr1, expr2 AT expr3
MAN
NEW [replaces SCR]
NOTRACE
PLOT expr1, expr2
POP
TEXT
TRACE
VLIN expr1, expr2 AT expr3
Function: ASC(), PDL(), SCRN(X,Y)

Implementação

O BASIC inteiro lê as linhas digitadas pelo usuário em um buffer e as executa por meio de um analisador que produz uma série de tokens . Como parte desse processo, erros simples de sintaxe foram detectados e listados. Se a análise foi bem-sucedida, o número da linha (se presente) foi convertido do formato decimal ASCII em um inteiro de 16 bits e quaisquer palavras-chave em um token de inteiro de 7 bits.

Algumas palavras-chave foram representadas por vários tokens; por exemplo, onde o Microsoft BASIC tinha um token para a palavra-chave PRINT, Integer BASIC tinha três tokens: um se a palavra-chave não fosse seguida por nenhum argumento, um se fosse seguida por uma expressão aritmética e um se fosse seguido por um literal de string.

Literais numéricos, como o valor 500, foram convertidos em sua representação binária de 16 bits (dois bytes), neste caso, $ 01F4 hexadecimal . Para indicar que era um valor e não uma palavra-chave, um único byte entre $ B0 e $ B9 foi inserido na frente do valor de dois bytes. Literais de string, como "HELLO WORLD", foram convertidos configurando o bit mais alto de cada caractere para que Afosse armazenado como $ C1. Os nomes das variáveis ​​foram convertidos da mesma maneira, com as letras convertidas para ter o bit mais alto ativado e quaisquer dígitos no nome representados pelos $ B0 até $ B9 correspondentes, de modo que a variável A5fosse marcada como $ C1B5.

Se a linha foi inserida sem um número de linha, o código foi executado diretamente do buffer. Se tivesse um número de linha, era copiado do buffer para a área de armazenamento do programa.

O interpretador de tempo de execução usou duas pilhas para execução: uma para palavras-chave de instrução e outra para avaliar os parâmetros. Cada declaração recebeu duas prioridades: uma que indicava onde deveria ocorrer em uma operação de várias etapas, como uma sequência de operações matemáticas para fornecer a ordem das operações , e outra que sugeria quando a avaliação deveria ocorrer, por exemplo, calculando os valores internos de um fórmula de parênteses. Quando as variáveis ​​foram encontradas, seus nomes foram analisados ​​e pesquisados ​​na área de armazenamento de variáveis. Se não foi encontrado, foi adicionado ao final da lista. O endereço de armazenamento da variável, talvez criado recentemente, foi então colocado na pilha de avaliação.

Detalhes da ROM

DOCE 16

Além do Integer BASIC, os ROMs da Apple continham uma linguagem montadora personalizada conhecida como SWEET16 . O SWEET16 é baseado em bytecodes executados em uma máquina virtual simples de 16 bits . Este modelo foi usado para que a memória pudesse ser endereçada através de ponteiros indiretos de 16 bits e funções matemáticas de 16 bits calculadas sem a necessidade de traduzi-los para o código 6502 de 8 bits multi-instrução subjacente. Toda a máquina virtual foi escrita em apenas 300 bytes. O código pode chamar SWEET16 emitindo uma chamada de sub - rotina e, em seguida, retornar ao código 6502 normal quando as operações de 16 bits forem concluídas.

O SWEET16 não foi usado pelo código BASIC principal, mas foi usado posteriormente para implementar vários utilitários. Entre elas, destaca-se a rotina de renumeração de linha, incluída na ROM do Programmer's Aid # 1, adicionada a modelos Apple II posteriores e disponível para instalação do usuário em exemplos anteriores.

Ponto flutuante

Embora Integer BASIC contivesse suas próprias rotinas matemáticas, as ROMs do Apple II também incluíam uma biblioteca completa de ponto flutuante localizada na memória ROM entre $ F425-F4FB e $ F63D-F65D. O código-fonte foi incluído no manual do Apple II. Programas BASIC que requerem cálculos de ponto flutuante podem CALLser incluídos nessas rotinas.

atuação

Como o Integer BASIC processou mais do código-fonte original em tokens, o tempo de execução foi mais rápido do que as versões que exigiam análise de tempo de execução adicional. Para comparação, o Tiny BASIC tokenizou apenas o número da linha, enquanto o MS BASICs tokenizou apenas as palavras-chave. Assim, por exemplo, enquanto Integer BASIC converteria a linha 100 GOTO 200inteiramente em tokens que poderiam ser imediatamente lidos e executados, em MS BASIC apenas o número da linha e GOTO seriam tokenizados, o "100" foi deixado em seu formato original e teve que ser refeito -parseado em um inteiro de 16 bits sempre que a linha era encontrada.

Além disso, trabalhar apenas com matemática de inteiros fornece outro grande aumento na velocidade. Isso se deve tanto ao formato menor de 16 bits que exige menos acessos à memória, quanto à remoção da necessidade de mover o decimal de vírgula flutuante após os cálculos. Como muitos benchmarks de computador da época eram pequenos e freqüentemente executavam matemática simples que não exigia ponto flutuante, Integer BASIC derrotou a maioria dos outros BASICs.

Em um dos primeiros benchmarks de microcomputador conhecidos, os benchmarks Rugg / Feldman , Integer BASIC foi duas vezes mais rápido que Applesoft BASIC na mesma máquina. No Byte Sieve , onde a matemática era menos importante, mas o acesso à matriz e o desempenho de looping dominavam, Integer BASIC levou 166 segundos, enquanto Applesoft levou 200. Ele não apareceu no Creative Computing Benchmark , que foi publicado pela primeira vez em 1983, quando o Integer BASIC não era mais fornecido por padrão.

A seguinte série de testes, tirada de ambos os artigos originais de Rugg / Feldman, mostra o desempenho de Integer em relação ao BASIC derivado de MS na mesma plataforma.

Código de amostra

A seguir está uma versão de Breakout escrita na versão de 1977 do Integer BASIC para o Apple II, que foi listada no Apple II Mini Manual. Existem vários bugs conhecidos nesta versão.

O programa começa definindo a exibição para TEXTe, em seguida, CALL -936para limpar a tela. As linhas 20 a 27 e as sub-rotinas associadas nas linhas 100 e 200 são o código de seleção de cores que Wozniak demonstrou para Jobs. A linha 30 configura a janela de texto com POKE 32,20e, em seguida, usa uma série de instruções COLORe VLINpara desenhar o campo de jogo e a exibição da pontuação na janela de texto. Todo o loop principal vai da linha 40 a 90 com sub-rotinas associadas. Outra grande quantidade de código perto do final do programa diz respeito à impressão da pontuação final. Outras notas de interesse incluem as #comparações (não iguais) na linha 20, a produção de um som de alta frequência usando uma corda de PEEKs na linha 65 em comparação com um tom de baixa frequência usando um loop na linha 70 e a mistura de gráficos e texto em uma única tela.

5 TEXT: CALL -936: VTAB 4: TAB 10: PRINT "*** BREAKOUT GAME ***": PRINT
7 PRINT "  OBJECT IS TO DESTROY ALL BRICKS WITH 5 BALLS": FOR N=1 TO 7000: NEXT N
10 DIM A$(20),B$(20): GR: PRINT: INPUT "HI, WHAT'S YOUR NAME? ",A$:A=1:B=13:C=9:D=6:E=15: PRINT "STANDARD COLORS,"; A$;
20 INPUT "? ",B$: IF B$#"N" AND B$#"NO" THEN 30: FOR I=0 TO 39: COLOR=I/2*(I<32): VLIN 0,39 AT I
25 NEXT I: POKE 34,20: PRINT: PRINT: PRINT: FOR I=0 TO 15: VTAB 21+I MOD 2: TAB I+I+1: PRINT I;: NEXT I: POKE 34,22: VTAB 24: PRINT: PRINT "BACKGROUND";
27 GOSUB 100: A=E: PRINT "EVEN BRICK";: GOSUB 100: B=E: PRINT "ODD BRICK";: GOSUB 100: C=E: PRINT "PADDLE";: GOSUB 100: D=E : PRINT "BALL";: GOSUB 100
30 POKE34,20:COLOR=A:FORI=0TO39:VLIN0,39ATI:NEXTI:FOR I=20TO34STEP2:TAB I+1:PRINT I/2-9;:COLOR=B:VLIN 0,39 AT I:COLOR=C:FOR J=I MOD 4 TO 39 STEP4
35 VLIN J,J+1 AT I: NEXT J,I: TAB 5: PRINT "SCORE = 0": PRINT: PRINT: POKE 34,21: S=0: P=S: L=S: X=19: Y=19: X=19
40 COLOR=A:PLOTX,Y/3:X=19:Y=RND(120):V=-1:W=RND(5)-2:L=L+1:IFL>5THEN140:TAB6:PRINT"BALL #";L:PRINT:FORI=1TO100:GOSUB200:NEXTI:M=1:N=0
50 J=Y+W: IF J>=0 AND J<120 THEN 60: W=-W: J=Y: FOR I=1 TO 6: K=PEEK(-16336): NEXT I
55 IF PEEK(-16287)>127 THEN SW=1-SW
60 I=X+V: IF I<0 THEN 400: GOSUB 200: COLOR=A: K=J/3: IF I>39 THEN 70: IF SCRN(I,K)=A THEN 90: IF I THEN 120: N=N+1: V=(N>9)+1: W=(K-P)*2-5:M=1
65 Z = PEEK(-16336)-PEEK(-16336)-PEEK(-16336)-PEEK(-16336)-PEEK(-16336)-PEEK(-16336)-PEEK(-16336): GOTO 90
70 FOR I=1 TO 6: M=PEEK(-16336): NEXT I: I=X: M=0
80 V=-V
90 PLOT X,Y/3: COLOR=E: PLOT I,K: X=I: Y=J: GOTO 50
99 PRINT "INVALID.  REENTER";
100 INPUT " COLOR (0 TO 15)",E: IF E<0 OR E>15 THEN 99: RETURN
120 IF M THEN V=ABS(V): VLIN K/2*2,K/2*2+1 AT I: S=S+I/2-9: VTAB 21: TAB 13: PRINT S
123 Q = PEEK(-16336)-PEEK(-16336)-PEEK(-16336)-PEEK(-16336)-PEEK(-16336)-PEEK(-16336)-PEEK(-16336)-PEEK(-16336)-PEEK(-16336)-PEEK(-16336)
124 IF S<720 THEN 80
130 PRINT "CONGRATULATIONS, YOU WIN.": GOTO 150
140 PRINT "YOUR SCORE OF ";S;" IS ";: GOTO 141+S/100
141 PRINT "TERRIBLE!": GOTO 150
142 PRINT "LOUSY.": GOTO 150
143 PRINT "POOR.": GOTO 150
144 PRINT "FAIR.": GOTO 150
145 PRINT "GOOD.": GOTO 150
146 PRINT "VERY GOOD.": GOTO 150
147 PRINT "EXCELLENT.": GOTO 150
148 PRINT "NEARLY PERFECT."
150 PRINT "SAME COLORS";: GOTO 20
200 IF SW THEN 220: Q=(PDL(0)-5)/6: IF Q<0 THEN Q=0
205 IF Q>=34 THEN Q=34: COLOR=D: VLIN Q,Q+5 AT 0: COLOR=A: IF P>Q THEN 210: IF Q THEN VLIN 0,Q-1 AT 0: P=Q: RETURN
210 IF P=Q THEN RETURN: IF Q#34 THEN VLIN Q+6,39 AT 0: P=Q: RETURN
220 Q=(Y-5)/3+RND(3)*SGN(W)*(X<10 AND V<0): IF Q<0 THEN Q=0: GOTO 205
400 FOR I=1 TO 80: Q=PEEK(-16336): NEXT I: GOTO 40

Notas

Referências

Citações

Bibliografia

• Mini manual do Apple II . Maçã. 1977.
• Hertzfeld, Andy (junho de 1985). “A triste história de MacBasic” . Folclore .
• Helmers, Carl (março de 1978). "Um Apple para Byte" . Byte . pp. 18–24, 30–32, 35, 40–46.
• Raskin, Jef (1978). Manual de programação BASIC do Apple II (PDF) . Computador Apple.
• Weyhrich, Steven (12 de dezembro de 2001). "História parte 3: O Apple II" . Página visitada em 2007-09-16 .
• Wozniak, Steven (maio de 1977). "Descrição do sistema / Apple-II" . Byte . pp. 34–43.
• Williams, Gregg; Moore, Rob (dezembro de 1984). "The Apple Story / Part 1: Early History" . Byte . pp. A67 – A71 . Retirado em 23 de outubro de 2013 .
• Wozniak, Steven (1 de maio de 2014). "Como Steve Wozniak escreveu o BASIC para o Apple Original do Scratch" . Gizmodo .
• Wozniak, Steven (3 de janeiro de 2018). "Apple BASIC" . Woz.org .

links externos

• Apple II Integer Basic Disassembly , versão descompilada manualmente por Paul Santa-Maria
• Referência INTEGER BASIC - Do site "Apple II Programmer's Reference" de Landsnail.com
• Placa de firmware Apple-1 BASIC projetada por John Calande, esquema incluído