3. Glossário Explicativo de Termos e Definições

VISÃO GERAL

As sessenta páginas a seguir podem ser consideradas como um espécie de atlas alfabético do meu compilador e do cérebro. Se você fez o seu dever de casa (o nosso programa de exemplo), você deve ser capaz de lê-lo do início ao fim e saber do que estou falando. Mas vamos revisar, por precaução:

Espero que seus programas consistam em arquivos de texto armazenados em uma única pasta. Um desses arquivos deve ser uma cópia do o cérebro. Não importa em qual ordem os os arquivos estão. O nome do arquivo não importa, desde que o arquivo não possua nenhuma extensão, isto é, nenhum ponto.

Você pode invoca o compilador dentro do bloco de notas (o editor de arquivos). Apenas abra qualquer arquivo de texto dentro da pasta que você deseje compilar e use o comando Executar. Para encerrar um programa problemático, dê um Alt+Tab volte para a tela do compilador e use o comando Parar.

O arquivo executável será salvo na mesma pasta do arquivo que foi compilado. O nome do arquivo executável será o mesmo nome da pasta em que ele estiver. Você pode renomear, modificar e distribuir seus arquivos executáveis do jeito que você quiser. Eles são livres de direitos autorais e não precisam de dll's para serem executados.

Os arquivos podem conter comentários e três tipos de definições: tipos, variáveis globais e rotinas. Em qualquer ordem que você achar melhor. Você pode usar letras maiúsculas, minúsculas, misturar tudo, tanto faz. As rotinas podem conter dois tipos de comandos: CONDICIONAIS e IMPERATIVOS. Se você está ficando confuso tentando ler esta seção do começo ao fim, tente pesquisar os tópicos acima no restante do documento, e aí sim volte para o glossário.

Um aviso importante. O compilador não permite o uso de comandos condicionais aninhados. (Ou seja, um Se dentro de outro). O compilador não permite o uso de comandos de repetição aninhados. (Ou seja, um loop dentro de outro). O compilador também não trabalha com números reais, equações, ou qualquer outro tipo de número que não seja inteiro ou racional. Basicamente o objetivo é utilizar a menor quantidade possível de matemática nos programas, assim como você faz na vida real.

ARITMÉTICA

O compillador tabalha com aritmética básica. O compilador mantém um registo do que está no arquivo o cérebro. Se possível, dê uma olhada com calma no arquivo. É um arquivo longo mas vale a pena. Para resumir a história, a essência e o poder do compilador reside no fato dele ser capaz de entender declarações do tipo:

ADICIONE isso Nisto.

SUBTRAIA isso Daquilo.

MULTIPLIQUE isso POR aquilo.

DIVIDA isso POR aquilo.

Caso você precise fazer uma divisão com resto, você pode utilizar o comando:

DIVIDA isto POR aquilo RETORNANDO o quociente E o resto.

Além disso, o compilador é capaz de:

ARREDONDAR algum número/variável PARA CIMA ATÉ ATINGIR O MÚLTIPLO MAIS PRÓXIMO DE outro número/variável.

ARREDONDAR algum número/variável PARA BAIXO ATÉ ATINGIR O MÚLTIPLO MAIS PRÓXIMO DE outro número/variável.

O compilador também é capaz de:

REMOVER O SINAL de um número/variável (extrair o módulo do número).

INVERTER O SINAL de um número/variável.

O compilador é capaz de até mesmo de:

REDUZIR uma fração (razão/proporção).

Você pode usar mais de uma operação aritmética no mesmo comando, usando as seguintes palavras chave: MAIS, MENOS, VEZES e DIVIDIDO POR. Você pode ler mais sobre esses operadores na seção Expressões Aritméticas deste glossário.

TABELA ASCII

Este é o Código Padrão Americano para o Intercâmbio de Informação (Extended ASCII) extendido, mais conhecido como Windows-1252 ou CP-1252. Devido a facilidade de implementação e ao fato do código ASCII cobrir a maior parte dos caracteres da língua portuguesa, ele foi escolhido comoo padrão para converter bytes em caracteres legíveis. Não é a melhor opção, já que existe o Unicode mas é uma das codificações de texto mais amplamente aceitas do planeta.

O compilador possui variáveis globais com nomes como o byte de vírgula para cada elemento da tabela, assim você não precise trabalhar diretamente com os números deles. Você pode encontrar todas essas variáveis procurando a frase é um byte igual à no arquivo o cérebro.

Caracteres de controle ASCII (código de caractere 0-31)

Os 32 primeiros caracteres na tabela ASCII são códigos de controle “não imprimíveis” e usados principalmente para controle de periféricos, como impressoras.

`DEC`	`OCT`	`HEX`	`BIN`	`Símbolo`	`Número HTML`	`Descrição`
`0`	`000`	`00`	`00000000`	`NUL`	``	`Caractere Nulo`
`1`	`001`	`01`	`00000001`	`SOH`	``	`Início do Cabeçalho`
`2`	`002`	`02`	`00000010`	`STX`	``	`Início do Texto`
`3`	`003`	`03`	`00000011`	`ETX`	``	`Final do Texto`
`4`	`004`	`04`	`00000100`	`EOT`	``	`Final da Transmissão`
`5`	`005`	`05`	`00000101`	`ENQ`	``	`Consulta`
`6`	`006`	`06`	`00000110`	`ACK`	``	`Confirmação`
`7`	`007`	`07`	`00000111`	`BEL`	``	`Sino`
`8`	`010`	`08`	`00001000`	`BS`	``	`Voltar (Back Space)`
`9`	`011`	`09`	`00001001`	`HT`	` `	`Tab Horizontal`
`10`	`012`	`0A`	`00001010`	`LF`	` `	`Linha Feed`
`11`	`013`	`0B`	`00001011`	`VT`	``	`Tab Vertical`
`12`	`014`	`0C`	`00001100`	`FF`	``	`Formulário Feed`
`13`	`015`	`0D`	`00001101`	`CR`	` `	`Mudança de Linha`
`14`	`016`	`0E`	`00001110`	`SO`	``	`Shift Out / X-On`
`15`	`017`	`0F`	`00001111`	`SI`	``	`Shift In / X-Off`
`16`	`020`	`10`	`00010000`	`DLE`	``	`Data Line Escape`
`17`	`021`	`11`	`00010001`	`DC1`	``	`Controle de Dispositivo 1 (oft. XON)`
`18`	`022`	`12`	`00010010`	`DC2`	``	`Controle de Dispositivo 2`
`19`	`023`	`13`	`00010011`	`DC3`	``	`Controle de Dispositivo 3 (oft. XOFF)`
`20`	`024`	`14`	`00010100`	`DC4`	``	`Controle de Dispositivo 4`
`21`	`025`	`15`	`00010101`	`NAK`	``	`Afirmação Negativa`
`22`	`026`	`16`	`00010110`	`SYN`	``	`Ocioso Síncrono`
`23`	`027`	`17`	`00010111`	`ETB`	``	`Final do Bloco de Transmissão`
`24`	`030`	`18`	`00011000`	`CAN`	``	`Cancelar`
`25`	`031`	`19`	`00011001`	`EM`	``	`Final do Meio`
`26`	`032`	`1A`	`00011010`	`SUB`	``	`Sbustituir`
`27`	`033`	`1B`	`00011011`	`ESC`	``	`Escapar`
`28`	`034`	`1C`	`00011100`	`FS`	``	`Separador de Arquivo`
`29`	`035`	`1D`	`00011101`	`GS`	``	`Separador de Grupo`
`30`	`036`	`1E`	`00011110`	`RS`	``	`Separador de Gravação`
`31`	`037`	`1F`	`00011111`	`US`	``	`Separador de unidade`

Caracteres imprimíveis ASCII (código de caractere 32-127)

Os códigos 32-127 são comuns para todas as diferentes variações da tabela ASCII, são chamados caracteres imprimíveis, representam letras, dígitos, sinais de pontuação e alguns símbolos diversificados. Nela você encontra quase todos os caracteres do seu teclado que são em comum com outros idiomas, no caso do Português, temos alguns caracteres que estarão na Tabela Extendida, logo abaixo desta:

* O caractere 127 representa o comando DEL.

`DEC`	`OCT`	`HEX`	`BIN`	`Símbolo`	`Número HTML`	`Nome HTML`	`Descrição`
`32`	`040`	`20`	`00100000`		` `		`Espaço`
`33`	`041`	`21`	`00100001`	`!`	`!`		`Ponto de exclamação`
`34`	`042`	`22`	`00100010`	`“`	`"`	`"`	`Aspas dupla`
`35`	`043`	`23`	`00100011`	`#`	`#`		`Cerquilha`
`36`	`044`	`24`	`00100100`	`$`	`$`		`Dolar`
`37`	`045`	`25`	`00100101`	`%`	`%`		`Porcentagem`
`38`	`046`	`26`	`00100110`	`&`	`&`	`&`	`E comercial`
`39`	`047`	`27`	`00100111`	`‘`	`'`		`Aspas simples`
`40`	`050`	`28`	`00101000`	`(`	`(`		`Abre parenteses`
`41`	`051`	`29`	`00101001`	`)`	`)`		`Fecha parenteses`
`42`	`052`	`2A`	`00101010`	`*`	`*`		`Asterísco`
`43`	`053`	`2B`	`00101011`	`+`	`+`		`Mais`
`44`	`054`	`2C`	`00101100`	`,`	`,`		`Vírgula`
`45`	`055`	`2D`	`00101101`	`–`	`-`		`Hífem`
`46`	`056`	`2E`	`00101110`	`.`	`.`		`Ponto`
`47`	`057`	`2F`	`00101111`	`/`	`/`		`Barra`
`48`	`060`	`30`	`00110000`	`0`	`0`		`Zero`
`49`	`061`	`31`	`00110001`	`1`	`1`		`Um`
`50`	`062`	`32`	`00110010`	`2`	`2`		`Dois`
`51`	`063`	`33`	`00110011`	`3`	`3`		`Três`
`52`	`064`	`34`	`00110100`	`4`	`4`		`Quatro`
`53`	`065`	`35`	`00110101`	`5`	`5`		`Cinco`
`54`	`066`	`36`	`00110110`	`6`	`6`		`Seis`
`55`	`067`	`37`	`00110111`	`7`	`7`		`Sete`
`56`	`070`	`38`	`00111000`	`8`	`8`		`Oito`
`57`	`071`	`39`	`00111001`	`9`	`9`		`Nove`
`58`	`072`	`3A`	`00111010`	`:`	`:`		`Dois pontos`
`59`	`073`	`3B`	`00111011`	`;`	`;`		`Ponto e vírgula`
`60`	`074`	`3C`	`00111100`	`<`	`<`	`<`	`Menor que`
`61`	`075`	`3D`	`00111101`	`=`	`=`		`Igual`
`62`	`076`	`3E`	`00111110`	`>`	`>`	`>`	`Maior que`
`63`	`077`	`3F`	`00111111`	`?`	`?`		`Interrogação`
`64`	`100`	`40`	`01000000`	`@`	`@`		`Arroba`
`65`	`101`	`41`	`01000001`	`A`	`A`		`A Maiúsculo`
`66`	`102`	`42`	`01000010`	`B`	`B`		`B Maiúsculo`
`67`	`103`	`43`	`01000011`	`C`	`C`		`C Maiúsculo`
`68`	`104`	`44`	`01000100`	`D`	`D`		`D Maiúsculo`
`69`	`105`	`45`	`01000101`	`E`	`E`		`E Maiúsculo`
`70`	`106`	`46`	`01000110`	`F`	`F`		`F Maiúsculo`
`71`	`107`	`47`	`01000111`	`G`	`G`		`G Maiúsculo`
`72`	`110`	`48`	`01001000`	`H`	`H`		`H Maiúsculo`
`73`	`111`	`49`	`01001001`	`I`	`I`		`I Maiúsculo`
`74`	`112`	`4A`	`01001010`	`J`	`J`		`J Maiúsculo`
`75`	`113`	`4B`	`01001011`	`K`	`K`		`K Maiúsculo`
`76`	`114`	`4C`	`01001100`	`L`	`L`		`L Maiúsculo`
`77`	`115`	`4D`	`01001101`	`M`	`M`		`M Maiúsculo`
`78`	`116`	`4E`	`01001110`	`N`	`N`		`N Maiúsculo`
`79`	`117`	`4F`	`01001111`	`O`	`O`		`O Maiúsculo`
`80`	`120`	`50`	`01010000`	`P`	`P`		`P Maiúsculo`
`81`	`121`	`51`	`01010001`	`Q`	`Q`		`Q Maiúsculo`
`82`	`122`	`52`	`01010010`	`R`	`R`		`R Maiúsculo`
`83`	`123`	`53`	`01010011`	`S`	`S`		`S Maiúsculo`
`84`	`124`	`54`	`01010100`	`T`	`T`		`T Maiúsculo`
`85`	`125`	`55`	`01010101`	`U`	`U`		`U Maiúsculo`
`86`	`126`	`56`	`01010110`	`V`	`V`		`V Maiúsculo`
`87`	`127`	`57`	`01010111`	`W`	`W`		`W Maiúsculo`
`88`	`130`	`58`	`01011000`	`X`	`X`		`X Maiúsculo`
`89`	`131`	`59`	`01011001`	`Y`	`Y`		`Y Maiúsculo`
`90`	`132`	`5A`	`01011010`	`Z`	`Z`		`Z Maiúsculo`
`91`	`133`	`5B`	`01011011`	`[`	`[`		`Abre Colchete`
`92`	`134`	`5C`	`01011100`	`\`	`\`		`Barra invertida`
`93`	`135`	`5D`	`01011101`	`]`	`]`		`Fecha Colchete`
`94`	`136`	`5E`	`01011110`	`^`	`^`		`Circunflexo`
`95`	`137`	`5F`	`01011111`	`_`	`_`		`Sublinhado`
`96`	`140`	`60`	`01100000`	`	```		`Acento grave`
`97`	`141`	`61`	`01100001`	`a`	`a`		`a Minúsculo`
`98`	`142`	`62`	`01100010`	`b`	`b`		`b Minúsculo`
`99`	`143`	`63`	`01100011`	`c`	`c`		`c Minúsculo`
`100`	`144`	`64`	`01100100`	`d`	`d`		`d Minúsculo`
`101`	`145`	`65`	`01100101`	`e`	`e`		`e Minúsculo`
`102`	`146`	`66`	`01100110`	`f`	`f`		`f Minúsculo`
`103`	`147`	`67`	`01100111`	`g`	`g`		`g Minúsculo`
`104`	`150`	`68`	`01101000`	`h`	`h`		`h Minúsculo`
`105`	`151`	`69`	`01101001`	`i`	`i`		`i Minúsculo`
`106`	`152`	`6A`	`01101010`	`j`	`j`		`j Minúsculo`
`107`	`153`	`6B`	`01101011`	`k`	`k`		`k Minúsculo`
`108`	`154`	`6C`	`01101100`	`l`	`l`		`l Minúsculo`
`109`	`155`	`6D`	`01101101`	`m`	`m`		`m Minúsculo`
`110`	`156`	`6E`	`01101110`	`n`	`n`		`n Minúsculo`
`111`	`157`	`6F`	`01101111`	`o`	`o`		`o Minúsculo`
`112`	`160`	`70`	`01110000`	`p`	`p`		`p Minúsculo`
`113`	`161`	`71`	`01110001`	`q`	`q`		`q Minúsculo`
`114`	`162`	`72`	`01110010`	`r`	`r`		`r Minúsculo`
`115`	`163`	`73`	`01110011`	`s`	`s`		`s Minúsculo`
`116`	`164`	`74`	`01110100`	`t`	`t`		`t Minúsculo`
`117`	`165`	`75`	`01110101`	`u`	`u`		`u Minúsculo`
`118`	`166`	`76`	`01110110`	`v`	`v`		`v Minúsculo`
`119`	`167`	`77`	`01110111`	`w`	`w`		`w Minúsculo`
`120`	`170`	`78`	`01111000`	`x`	`x`		`x Minúsculo`
`121`	`171`	`79`	`01111001`	`y`	`y`		`y Minúsculo`
`122`	`172`	`7A`	`01111010`	`z`	`z`		`z Minúsculo`
`123`	`173`	`7B`	`01111011`	`{`	`{`		`Abre Chaves`
`124`	`174`	`7C`	`01111100`	`\`		`\|`
`125`	`175`	`7D`	`01111101`	`}`	`}`		`Fecha Chaves`
`126`	`176`	`7E`	`01111110`	`~`	`~`		`Til`
`127`	`177`	`7F`	`01111111`		``		`Deletar`

Tabela de códigos ASCII extendida (código de caractere 128-255)

Existem diferentes variações da tabela ASCII de 8 bits. A tabela abaixo está de acordo com o Windows-1252 (CP-1252), que é um superconjunto da ISO 8859-1, também chamado ISO Latina-1.

`DEC`	`OCT`	`HEX`	`BIN`	`Símbolo`	`Número HTML`	`Nome HTML`	`Descrição`
`128`	`200`	`80`	`10000000`	`€`	``	`€`	`Sinal do Euro`
`129`	`201`	`81`	`10000001`
`130`	`202`	`82`	`10000010`	`‚`	``	`&sbquo;`	`Aspas inferiores`
`131`	`203`	`83`	`10000011`	`ƒ`	``	`&fnof;`	`Letra Latina f Minúscula`
`132`	`204`	`84`	`10000100`	`„`	``	`&bdquo;`	`Aspas dupla inferiores`
`133`	`205`	`85`	`10000101`	`…`	``	`…`	`Reticências horizontal`
`134`	`206`	`86`	`10000110`	`†`	``	`&dagger;`	`Punhal`
`135`	`207`	`87`	`10000111`	`‡`	``	`&Dagger;`	`Punhal duplo`
`136`	`210`	`88`	`10001000`	`ˆ`	``	`&circ;`	`Circunflexo`
`137`	`211`	`89`	`10001001`	`‰`	``	`&permil;`	`Símbolo de por milha`
`138`	`212`	`8A`	`10001010`	`Š`	``	`&Scaron;`	`Letra Latina S com caron`
`139`	`213`	`8B`	`10001011`	`‹`	``	`&lsaquo;`	`Sinal menor que`
`140`	`214`	`8C`	`10001100`	`Œ`	``	`&OElig;`	`Letra Latina ligatura OE`
`141`	`215`	`8D`	`10001101`
`142`	`216`	`8E`	`10001110`	`Ž`	``		`Letra Latina maiúscula Z com caron`
`143`	`217`	`8F`	`10001111`
`144`	`220`	`90`	`10010000`
`145`	`221`	`91`	`10010001`	`‘`	``	`‘`	`Aspa única à esquerda`
`146`	`222`	`92`	`10010010`	`’`	``	`’`	`Aspa única à direita`
`147`	`223`	`93`	`10010011`	`“`	``	`“`	`Aspa dupla à esquerda`
`148`	`224`	`94`	`10010100`	`”`	``	`”`	`Aspa única à direita`
`149`	`225`	`95`	`10010101`	`•`	``	`•`	`Ponto médio`
`150`	`226`	`96`	`10010110`	`–`	``	`–`	`Traço médio`
`151`	`227`	`97`	`10010111`	`—`	``	`—`	`Travessão`
`152`	`230`	`98`	`10011000`	`˜`	``	`&tilde;`	`Til Minúsculo`
`153`	`231`	`99`	`10011001`	`™`	``	`™`	`Símbolo Trade mark`
`154`	`232`	`9A`	`10011010`	`š`	``	`&scaron;`	`Letra Latina Minúscula S com Caron`
`155`	`233`	`9B`	`10011011`	`›`	``	`&rsaquo;`	`Símbolo Maior que`
`156`	`234`	`9C`	`10011100`	`œ`	``	`&oelig;`	`Letra Latina Minúscula ligatura oe`
`157`	`235`	`9D`	`10011101`
`158`	`236`	`9E`	`10011110`	`ž`	``		`Letra Latina Minúscula z com caron`
`159`	`237`	`9F`	`10011111`	`Ÿ`	``	`&Yuml;`	`Letra Latina Maiúscula Y com trema`
`160`	`240`	`A0`	`10100000`		` `	` `	`Espaço em branco`
`161`	`241`	`A1`	`10100001`	`¡`	`¡`	`¡`	`Ponto de Exclamação Invertido`
`162`	`242`	`A2`	`10100010`	`¢`	`¢`	`¢`	`Símbolo de Centavo`
`163`	`243`	`A3`	`10100011`	`£`	`£`	`£`	`Símbolo da Libra`
`164`	`244`	`A4`	`10100100`	`¤`	`¤`	`¤`	`Símbolo de Moeda`
`165`	`245`	`A5`	`10100101`	`¥`	`¥`	`¥`	`Símbolo do Yen`
`166`	`246`	`A6`	`10100110`	`¦`	`¦`	`¦`	`Barra vertical quebrada`
`167`	`247`	`A7`	`10100111`	`§`	`§`	`§`	`Símbolo de Sessão`
`168`	`250`	`A8`	`10101000`	`¨`	`¨`	`¨`	`Trema`
`169`	`251`	`A9`	`10101001`	`©`	`©`	`©`	`Copyright`
`170`	`252`	`AA`	`10101010`	`ª`	`ª`	`ª`	`Indicador ordinal feminino`
`171`	`253`	`AB`	`10101011`	`«`	`«`	`«`	`Ângulo Duplo para Esquerda`
`172`	`254`	`AC`	`10101100`	`¬`	`¬`	`¬`	`Sinal de negação`
`173`	`255`	`AD`	`10101101`		``	``	`Hífen`
`174`	`256`	`AE`	`10101110`	`®`	`®`	`®`	`Trade mark registrada`
`175`	`257`	`AF`	`10101111`	`¯`	`¯`	`¯`	`Macron – overline`
`176`	`260`	`B0`	`10110000`	`°`	`°`	`°`	`Símbolo de grau`
`177`	`261`	`B1`	`10110001`	`±`	`±`	`±`	`Simbolo mais-menos`
`178`	`262`	`B2`	`10110010`	`²`	`²`	`²`	`Número 2 sobrescrito`
`179`	`263`	`B3`	`10110011`	`³`	`³`	`³`	`Número 2 sobrescrito`
`180`	`264`	`B4`	`10110100`	`´`	`´`	`´`	`acento agudo`
`181`	`265`	`B5`	`10110101`	`µ`	`µ`	`µ`	`Sinal de Micro`
`182`	`266`	`B6`	`10110110`	`¶`	`¶`	`¶`	`Paragráfo`
`183`	`267`	`B7`	`10110111`	`·`	`·`	`·`	`Ponto no Meio`
`184`	`270`	`B8`	`10111000`	`¸`	`¸`	`¸`	`Espaçador de Cedilha`
`185`	`271`	`B9`	`10111001`	`¹`	`¹`	`¹`	`Número 1 sobrescrito`
`186`	`272`	`BA`	`10111010`	`º`	`º`	`º`	`Indicador Ordinal Masculino`
`187`	`273`	`BB`	`10111011`	`»`	`»`	`»`	`Aspas angulares direita`
`188`	`274`	`BC`	`10111100`	`¼`	`¼`	`¼`	`Fração um quarto`
`189`	`275`	`BD`	`10111101`	`½`	`½`	`½`	`Fração um e meio`
`190`	`276`	`BE`	`10111110`	`¾`	`¾`	`¾`	`Fração três quartos`
`191`	`277`	`BF`	`10111111`	`¿`	`¿`	`¿`	`Interrogação invertida`
`192`	`300`	`C0`	`11000000`	`À`	`À`	`À`	`Letra Latina Maiúscula A com grave`
`193`	`301`	`C1`	`11000001`	`Á`	`Á`	`Á`	`Letra Latina Maiúscula A com acento`
`194`	`302`	`C2`	`11000010`	`Â`	`Â`	`Â`	`Letra Latina Maiúscula A com circunflexo`
`195`	`303`	`C3`	`11000011`	`Ã`	`Ã`	`Ã`	`Letra Latina Maiúscula A com til`
`196`	`304`	`C4`	`11000100`	`Ä`	`Ä`	`Ä`	`Letra Latina Maiúscula A com trema`
`197`	`305`	`C5`	`11000101`	`Å`	`Å`	`Å`	`Letra Latina Maiúscula A com anel acima`
`198`	`306`	`C6`	`11000110`	`Æ`	`Æ`	`Æ`	`Letra Latina Maiúscula AE`
`199`	`307`	`C7`	`11000111`	`Ç`	`Ç`	`Ç`	`Letra Latina Maiúscula C com cedilha`
`200`	`310`	`C8`	`11001000`	`È`	`È`	`È`	`Letra Latina Maiúscula E com grave`
`201`	`311`	`C9`	`11001001`	`É`	`É`	`É`	`Letra Latina Maiúscula E com acento`
`202`	`312`	`CA`	`11001010`	`Ê`	`Ê`	`Ê`	`Letra Latina Maiúscula E com circunflexo`
`203`	`313`	`CB`	`11001011`	`Ë`	`Ë`	`Ë`	`Letra Latina Maiúscula E com trema`
`204`	`314`	`CC`	`11001100`	`Ì`	`Ì`	`Ì`	`Letra Latina Maiúscula I com grave`
`205`	`315`	`CD`	`11001101`	`Í`	`Í`	`Í`	`Letra Latina Maiúscula I com acento`
`206`	`316`	`CE`	`11001110`	`Î`	`Î`	`Î`	`Letra Latina Maiúscula I com circunflexo`
`207`	`317`	`CF`	`11001111`	`Ï`	`Ï`	`Ï`	`Letra Latina Maiúscula I com trema`
`208`	`320`	`D0`	`11010000`	`Ð`	`Ð`	`Ð`	`Letra Latina Maiúscula ETH`
`209`	`321`	`D1`	`11010001`	`Ñ`	`Ñ`	`Ñ`	`Letra Latina Maiúscula N com til`
`210`	`322`	`D2`	`11010010`	`Ò`	`Ò`	`Ò`	`Letra Latina Maiúscula O com grave`
`211`	`323`	`D3`	`11010011`	`Ó`	`Ó`	`Ó`	`Letra Latina Maiúscula O com acento`
`212`	`324`	`D4`	`11010100`	`Ô`	`Ô`	`Ô`	`Letra Latina Maiúscula O com circunflexo`
`213`	`325`	`D5`	`11010101`	`Õ`	`Õ`	`Õ`	`Letra Latina Maiúscula O com til`
`214`	`326`	`D6`	`11010110`	`Ö`	`Ö`	`Ö`	`Letra Latina Maiúscula O com trema`
`215`	`327`	`D7`	`11010111`	`×`	`×`	`×`	`Sinal de Multiplicação`
`216`	`330`	`D8`	`11011000`	`Ø`	`Ø`	`Ø`	`Letra Latina Maiúscula O com barra`
`217`	`331`	`D9`	`11011001`	`Ù`	`Ù`	`Ù`	`Letra Latina Maiúscula U com grave`
`218`	`332`	`DA`	`11011010`	`Ú`	`Ú`	`Ú`	`Letra Latina Maiúscula U com acento`
`219`	`333`	`DB`	`11011011`	`Û`	`Û`	`Û`	`Letra Latina Maiúscula U com circunflexo`
`220`	`334`	`DC`	`11011100`	`Ü`	`Ü`	`Ü`	`Letra Latina Maiúscula U com trema`
`221`	`335`	`DD`	`11011101`	`Ý`	`Ý`	`Ý`	`Letra Latina Maiúscula Y com acento`
`222`	`336`	`DE`	`11011110`	`Þ`	`Þ`	`Þ`	`Letra Latina Maiúscula THORN`
`223`	`337`	`DF`	`11011111`	`ß`	`ß`	`ß`	`Letra Latina Minúscula sharp s – ess-zed`
`224`	`340`	`E0`	`11100000`	`à`	`à`	`à`	`Letra Latina Minúscula a com grave`
`225`	`341`	`E1`	`11100001`	`á`	`á`	`á`	`Letra Latina Minúscula a with acento`
`226`	`342`	`E2`	`11100010`	`â`	`â`	`â`	`Letra Latina Minúscula a com circunflexo`
`227`	`343`	`E3`	`11100011`	`ã`	`ã`	`ã`	`Letra Latina Minúscula a til`
`228`	`344`	`E4`	`11100100`	`ä`	`ä`	`ä`	`Letra Latina Minúscula a com trema`
`229`	`345`	`E5`	`11100101`	`å`	`å`	`å`	`Letra Latina Minúscula a com círculo acima`
`230`	`346`	`E6`	`11100110`	`æ`	`æ`	`æ`	`Letra Latina Minúscula ae`
`231`	`347`	`E7`	`11100111`	`ç`	`ç`	`ç`	`Letra Latina Minúscula c com cedilha`
`232`	`350`	`E8`	`11101000`	`è`	`è`	`è`	`Letra Latina Minúscula e com grave`
`233`	`351`	`E9`	`11101001`	`é`	`é`	`é`	`Letra Latina Minúscula e com acento`
`234`	`352`	`EA`	`11101010`	`ê`	`ê`	`ê`	`Letra Latina Minúscula e com circunflexo`
`235`	`353`	`EB`	`11101011`	`ë`	`ë`	`ë`	`Letra Latina Minúscula e com trema`
`236`	`354`	`EC`	`11101100`	`ì`	`ì`	`ì`	`Letra Latina Minúscula i com grave`
`237`	`355`	`ED`	`11101101`	`í`	`í`	`í`	`Letra Latina Minúscula i com acento`
`238`	`356`	`EE`	`11101110`	`î`	`î`	`î`	`Letra Latina Minúscula i com circunflexo`
`239`	`357`	`EF`	`11101111`	`ï`	`ï`	`ï`	`Letra Latina Minúscula i com trema`
`240`	`360`	`F0`	`11110000`	`ð`	`ð`	`ð`	`Letra Latina Minúscula eth`
`241`	`361`	`F1`	`11110001`	`ñ`	`ñ`	`ñ`	`Letra Latina Minúscula n com til`
`242`	`362`	`F2`	`11110010`	`ò`	`ò`	`ò`	`Letra Latina Minúscula o com grave`
`243`	`363`	`F3`	`11110011`	`ó`	`ó`	`ó`	`Letra Latina Minúscula o com acento`
`244`	`364`	`F4`	`11110100`	`ô`	`ô`	`ô`	`Letra Latina Minúscula o com circunflexo`
`245`	`365`	`F5`	`11110101`	`õ`	`õ`	`õ`	`Letra Latina Minúscula o com til`
`246`	`366`	`F6`	`11110110`	`ö`	`ö`	`ö`	`Letra Latina Minúscula o com trema`
`247`	`367`	`F7`	`11110111`	`÷`	`÷`	`÷`	`Sinal de Divisão`
`248`	`370`	`F8`	`11111000`	`ø`	`ø`	`ø`	`Letra Latina Minúscula o com barra`
`249`	`371`	`F9`	`11111001`	`ù`	`ù`	`ù`	`Letra Latina Minúscula u com grave`
`250`	`372`	`FA`	`11111010`	`ú`	`ú`	`ú`	`Letra Latina Minúscula u com acento`
`251`	`373`	`FB`	`11111011`	`û`	`û`	`û`	`Letra Latina Minúscula u com circunflexo`
`252`	`374`	`FC`	`11111100`	`ü`	`ü`	`ü`	`Letra Latina Minúscula u com trema`
`253`	`375`	`FD`	`11111101`	`ý`	`ý`	`ý`	`Letra Latina Minúscula y com acento`
`254`	`376`	`FE`	`11111110`	`þ`	`þ`	`þ`	`Letra Latina Minúscula thorn`
`255`	`377`	`FF`	`11111111`	`ÿ`	`ÿ`	`ÿ`	`Letra Latina Minúscula y com trema`

HABILIDADES BÁSICAS

Eu não acho que eu esteja me gabando quando digo que o compilador é rápido e preciso. Sem falar que a linguagem possui um âmbito de aplicação bem amplo. Por exemplo, para zerar o valor interno de alguma variável, basta usar o comando:

LIMPE a variável.

O compilador também é capaz de entender instruções do tipo:

COLOQUE isso DENTRO disso.

Ou ainda:

TROQUE isto POR isso.

O compilador é capaz de criar cópias de variáveis dinamicamente alocadas, como figuras e polígonos, usando comandos como:

COPIE isto PRA DENTRO disso.

E também:

CONVERTA uma coisa EM outra coisa.

Às vezes até implicitamente. Digamos, por exemplo, que você queriaadicionar uma fração no final de uma sequência de caracteres, usando uma expressão como esta:

uma sequência de caracteres seguida de uma proporção

O compilador é esperto o bastante para usar automaticamente a rotina de CONVERTER uma proporção EM um texto antes de efetuar a junção usando a rotina de ADICIONAR um texto NO FINAL DE outro texto. Fantástico. SIm, nós pensamos em tudo (ou quase!).

BITS

Um "bit", como definido no arquivo o cérebro, é uma unidade de medida. É usado em comandos como 1 bit ou alguns bits. Você provavelmente não vai precisar dele a menos que você seja um ned que goste de passar o tempo manipulando bits usando comandos como:

CONJUNCIONE este valor COM este valor.(AND)

DISJUNCIONE este valor COM este valor.(OR)

DISJUNCIONE EXCLUSIVAMENTE este valor COM este valor.(XOR)

Em cada um destes casos, o primeiro argumento informado é o que é modificado pelo conectivo lógico.

Também é possível efetuar as seguintes operações lógicas:

DESLOQUE este valor alguns bits PARA A ESQUERDA.

DESLOQUE este valor alguns bits PARA A DIREITA.

Ou ainda:

SEPARE este valor EM um valor E em outro valor.

Como por exemplo, um byte em pedaços de 4 bits, ou 4 bits em pedaços contendo dois bytes, etc. Creio que raramente você precisará fazer isso.

Agora, se você não tem mínima idéia do que estou falando aqui, você não é um nerd e não deve se preocupar com isso. Você provavelmente não vai querer saber.

Mas se você entender o que eu estou dizendo, tenho certeza que você também vai curtir o tópico Windows bem no final, e a parte sobre literais nibles dentro do tópico Literais. Sem mencionar a questão do Possessivo, e os Imperativos. Além de todas as rotinas de baixo nível do compilador que usam a instrução INTEL e/ou o registro EAX.

CAIXAS

Um dos aspectos chave do compilador é a forma que ele trabalha com caixas. Uma caixa é uma variável do tipo record. O código da caixa é basicamente assim:

Um lado é uma coordenada.

Uma caixa tem
Um lado esquerdo, 
Um lado de cima, 
Um lado direito, 
Um lado de baixo,
Um canto no canto superior esquerdo e
Um segundo canto no canto inferior direito.

Esta é uma imagem de uma caixa, com todas as partes acima identificadas. Note que estou usando os apelidos dos campos aqui, como você provavelmente usará em seus programas.

DIREITA ESQUERDA

CIMA

BAIXO

SUPERIOR ESQUERDO

INFERIOR DIREITO

O compilador consegue fazer caixas a partir de especificações de largura e altura, ou apenas usando um par de pontos de coordenadas. Tudo o que você tem que fazer é escrever algo assim:

FAÇA uma caixa COM tal largura E tal altura.
FAÇA uma caixa COM essa coordenada E essa outra coordenada.
FAÇA uma caixa USANDO esse lado esquerdo E essa parte de cima E esse lado direito E essa parte de baixo.

O compilador consegue criar uma caixa. Bem como obter a largura, altura o ponto central entre outras coisas. Ele também consegue dizer se uma caixa ESTÁ DENTRO ou se ela ESTÁ TOCANDO outra caixa. E se um ponto está DENTRO, FORA ou na BORDA da caixa. Sem mencionar todas as outras "Transformações Gráficas" as quais você pode saber mais em outra parte mais abaixo neste glossário.

TIPOS PREDEFINIDOS/EMBUTIDOS

O compilador tabalha com 6 espécies de tipos de dados primitivos: BYTE, WYRD, NÚMERO, PONTEIRO, FLAG e RECORD.

Bytes. Bytes, como você já sabe, nada mais são do que 8 bits de dados binários sequenciais. O compilador trabalha no formato decimal, logo valor de um byte vai de 0 até 255. O compilador usa a tabela ASCII sempre que é necessário converter um byte para uma caractere.

Wyrds. As wyrds são necessárias para comunicação com o Windows/Processador. Eles têm 16 bits de comprimento sendo que o valor mínimo corresponde a -32768 e o valor máximo corresponde a +32767. Os bits dentro de cada byte são armazenados da esquerda para a direita, mas os bytes em si são armazenadas da direita pra esquerda. Infelizmente essa é uma das coisas que não é possível alterar.

Números. O compilador trabalha números inteiros. Ou seja, números positivos e negativos. Eles têm 32 bits de comprimento com o valor mínimo sendo -2147483648 e o valor máximo sendo +2147483647. São armazenados da direita para a esquerda.

Pointers. OS endereços de memória são armazenados em ponteiros de 32 bits de comprimento, da direita para a esquerda. Os ponteiros possuem o mesmo intervalo que os NÚMEROS inteiros, mas os números negativos são reservados para uso do Windows. O endereço 0 é inválido e é chamado de NIL. Para fazer com que um ponteiro fique vazio (NIL) é só usar o comando ESVAZIAR.

Flags. Apesar de ocuparem 32 bits na memória apenas o bit mais significativo da direita é utilizado. Na verdade, são os 8 primeiros bits começando a partir da esquerda, mas na prática é como se fosse o que eu falei antes. Dessa forma, o valor 0 é interpretado como "não" ou "falso" e 1 como "sim" ou "verdadeiro". Qualquer outro valor é inválido. Você pode LIMPAR uma flag para indicar "não" ou DEFINIR uma flag para indicar "sim".

Records. O último dos meus tipos embutidos é o record. O protótipo inicial ocupa zero bits na memória, mas você pode definir records de qualquer comprimento adicionando "campos" para o registro protótipo. Estes campos podem ser baseados em qualquer um dos tipos primitivos, incluindo outros records que você tenha definido anteriormente.

CORES

Uma cor tem uma matiz, uma saturação e um brilho. Minha paleta padrão inclui clores claras, brancos, pretos, sete cinzas não saturados e oitenta e quatro cores totalmente saturadas com diferentes graus de claridade, como mostrado aqui:

O compilador possui uma variável global para cada uma dessas cores no arquivo o cérebro. "A cor cinza mutio claro", por exemplo, ou "a cor azul escura". Você deve omitir o adjetivo em tons normais, como em "a cor vermelha".

Você também pode inventar suas próprias cores como esta:

FAÇA uma cor USANDO uma tonalidade E uma saturação E um brilho.

Matizes variam de 0 a 3600. O compilador usa múltiplos de 300 na paleta, começando com a cor vermelha no valor 0. Saturação e brilho podem ter qualquer valor entre 0 e 1000.

lightest lighter light normal dark darker darkest

cinza
vermelho
laranja
amarelo
lima
verde
azul
ciano
céu
azul
roxo
magenta
violeta

COMENTÁRIOS

Existem 3 tipos de comentários disponíveis no compilador. Aqui está uma descrição exata de cada um.

Um "comentário" é qualquer coisa entre o uma barra invertida e o final de uma linha:

\este é um comentário que termina com o byte CR

O editor de texto exibe comentários na cor do azul claro para que sejam fáceis de encontrar. Caso você deseje alterar a cor dos comentários, será necessário recompilar o programa, mudando a seguinte linha de código: Utilize a cor azul claro como cor dos comentários.

Os comentários podem começar em qualquer lugar da linha, mas terminam quando a linha termina. No entanto, você pode incluir ou excluir blocos inteiros do código selecionado usando os comandos Comentar e Descomentar no meu editor.

Existe outro tipo de comentário que é chamado de "observação. Ele não possui uma cor diferenciada nem é afetado pelos comandos mencionados acima. Exemplo:

[ bytes imprimíveis ]

Onde "imprimível" significa qualquer byte da tabela ASCII, exceto caracteres com valores de 0 a 31, o byte de exclusão, e os bytes indefinidos 129, 141, 143, 144, 157.

Observações podem ser colocadas em qualquer lugar, mesmo no meio de uma frase. Mas a fim de evitar erros, as observações também não podem ocupar mais de uma linha. Conforme dito antes, elas não são realçadas. Então use como observação e não como comentário.

O termo "ruído", se refere a todos os caracteres da tabela ASCII cujo valor esteja entre 0 e 31, o byte de espaço, o byte de exclusão, os bytes indefinidos 129, 141, 143, 144, 157, e o byte de espaço rígido. O compilador reconhece estes bytes como separadores, claro, mas, fora isso, não faz nada com eles.

CONDIÇÕES

Uma declaração "condicional" é uma declaração com duas partes. A primeira parte determina as condições sob as quais a segunda parte poderá ser executada. Aqui estão alguns exemplos:

Se a coordenada não estiver dentro da caixa, alerte o usuário.
Se o número for maior que 3, diga "Isso é muito"; saia.
Se o botão esquerdo do mouse estiver sendo pressionado, coloque a coordenada do ponteiro em uma coordenada; repita.

O formato geral é:

Se isso acontecer, faça isso; isto; aquilo.

A palavra SE é necessária. "Isso" representa uma chamada implícita para uma rotina decisora. Se a rotina retornar um "sim", todos os comandos após a vírgula serão executados. Se a rotina retornar um "não", o programa executará a próxima linha.

Observe que os comandos imperativos nos comandos condicionais são separados por ponto e vírgula, e não por pontos, porque o primeiro ponto encontrado indica o fim da instrução. A nãos er que o ponto esteja num comentário ou dentro de aspas duplas, é claro.

Observe também que se você utilizar palavras negativas na chamada implícita do decidor, essas palavras serão descartadas ou serão modificadas adequadamente. Nesse caso o decisor que será chamado é o que não contém as palavras negativas, a única coisa que acontece é que o valor de retorno dele será invertido. Por exemplo, digamos que você use o seguinte comando:

Se a coordenada não estiver dentro da caixa, [...]

Primeiramente, o compilador vai descartar o não. Logo em seguida, ele vai decidir se a coordenada está na caixa. A resposta obtida será então invertida (Se a resposta for sim, então o retorno será um não e vice-versa). Eu sei que parece complicado, mas na verdade não é. E até onde testamos, tem funcionado muito bem, já que os decisores apenas retornam sim ou não. Consulte o tópico Decisores para mais informações.

Por último, lembre-se: o compilador não aceita o aninhamento de declarações condicionais. A filosofia da linguagem entende que esse tipo de declaração acaba por ser sempre desnecessário (por poder ser expresso de outra forma) e quase sempre incerto (gerando resultados indesejados). Não há nenhuma declaração condicional aninhada em todas as mais de 25 mil linhas de código deste projeto. E se você parar pra pensar que este é o compilador de língua portuguesa mais avançado do mundo, verá que elas realmente não são nenhum pouco necessárias. Na verdade, cada uma das declarações condicionais do compilador cabe numa linha só. Pense nisso.

O CONSOLE

Um "console" é uma interface de texto puro, com a qual você pode interagir de forma limitada. O console padrão parece mais ou menos com a imagem abaixo:

Seja bem-vindo ao PAL - Portuguese Compiler And Linker. Qual é o seu nome?
> Dr. Gerry
Bom dia, Dr. Gerry. Estou pronto para a minha primeira lição.

O console pode ser ativado a qualquer momento. Ele ocupa toda a tela e usa a fonte padrão na cor preta no fundo cinza muito claro.

Você pode conversar com o usuário no console usando instruções como estas:

LEIA algo USANDO O CONSOLE PADRÃO. MOSTRE algo NO CONSOLE PADRÃO.

Você também pode escrever no console sem avançar para a próxima linha:

MOSTRE algo NO CONSOLE PADRÃO SEM PULAR LINHAS.

Que é útil para "prompts", como o símbolo > no exemplo acima.

O console padrão está sempre disponível, mas ele vai aparecer na tela somente quando você precisar informar alguma coisa para ele ou exibir alguma coisa nele. Uma vez exibido, o console permanecerá visível até que você mande o programa exibir outra coisa e atualizar a tela.

O console lembra tudo o que ele exibe e rola automaticamente para cima quando a parte inferior da tela é alcançada. Você pode usar as teclas Home, End, Page Up, Page Down, e o botão direito do mouse para rolar manualmente.

CONSERTANDO FALHAS E ERROS

Uma dos princípios que regem a linguagem da Sociedade Osmosiana é: Depuradores são coisa de frangotes.

Se você precisa de uma ferramenta especial para ajudá-lo a consertar seu código, algo está seriamente errado. Ou você está esquecendo de testar seu programa conforme vai acrescentando as funções nele, ou o seu código está irremediavelmente complexo. Ou talvez você esteja na profissão errada.

Dir-vos-ei agora o que fazem os Mestres Osmosianos quando confrontados com um erro na execução do código.

Antes de tudo, eles oram ao bom Deus solicitando sua orientação. Em seguida, eles consideram excluit totalmente a funcionalidade problemática, dessa forma eles se livram de uma vez do problema, e evitam o famoso Feature creep. Em seguida, eles estudam o código, esperando conseguir "discernir" qual é o problema. Se o bug não foi encontrado, eles escolhem um local que seja apropriado para que o programa emita um som de alerta. Se eles não ouvirem o som durante a execução do programa, então tem algo errado na rotina, e eles verificam. Caso eles escutem o som, o comando é movido para próxima rotina, ou para o próximo comando da rotina. O console também pode ajudar muito.

Nos raríssimos casos, em que várias repetições dos procedimento descrito acima falham em providenciar uma conclusão aceitável, os Mestres da Sociedade OSmosiana escolhem outro lugar no código e inserem o seguinte comando:

ANALISE isso.

Onde "isso" pode ser uma caixa, byte, cor, bandeira, fonte, linha, número, par de coordenadas, ponteiro, proporção, local, texto ou wyrd. Quando eles executam o código modificado, a caixa de mensagem do Windows aparece contendo uma pista. A aparência horrenda da caixa os motiva a rezar mais e renovar a determinação de resolver o problema, E assim armados, eles voltam ao primeiro passo.

Ofereço a minha própria existência como prova da suficiência destas técnicas. E estou confiante que todos os futuros erros — exceto talvez, um inesperado Ciclo infinito de Mobius - poderão ser gerenciados da mesma forma.

DECISORES

Um decisor nada mais é do que uma rotina que retorna "sim" ou "não" para determinados comandos. Exemplo:

Para decidir se uma coordenada está dentro de uma caixa:
Para decidir se um número é maior que outro número:
Para decidir se algo está selecionado em um texto:

As rotinas decisoras sempre começam com as mesmas três palavras. O formato é:

PARA DECIDIR SE alguma coisa:

Esse "alguma coisa" deve seguir as regras existentes para nomes de rotina e tipicamente incluirá um verbo como o É, ESTÁ, PODE, FAZ, DEVE, ETC. Perceba que a conjugação dos verbos não importa muito.

O ideal é sempre criar decisores "positivos". Ou seja, se você quiser evitar dores de cabeça no futuro usar as palavras NÃO, NUNCA, NENHUM, NADA e similares. Não se preocupe, caso seja realmente necessário utilizar tais temos, você pode. Mas na prática o compilador vai meio que desfazer tudo que você fez.

Por exemplo, se você criar uma rotina que "decide se uma coordenada está dentro de uma caixa", o compilador automaticamente vai saber dizer se "uma coordenada NÃO está dentro de uma caixa. Isso funciona pra quelauqer tipo de rotina decisora. Para saber mais, procure os exemplos disponíveis nos arquivos de código fonte.

Os decisores funcionam basicamente da mesma forma que as rotinas condicionais e imperativas. No entanto você não pode usar o comando SAIA em um decisor, por motivos óbvios, bem como qualquer outra forma que faça você sair sem dar alguma resposta. Um decisor sempre deve terminar com as palavras "DIGA SIM" ou "DIGA NÃO".

LISTA DE DECISORES DISPONÍVEIS NO SISTEMA

Decisores são uma boa forma de deixar o seu programa (e o compilador) mais inteligente. Você pode (e deve) integrá-los ao sistema. Existem 138 decisores no sistema. Neste exato momento, com certeza devem haver bem mais. Eis uma amostra dos principais decisores:

Alguns desses funcionam com apenas um tipo de dado, é claro, mas outros trabalham com muitos. E se você leu o tópico Decisor, você sabe que o compilador também aceita as variantes negativas desses mesmos decisores. Por favor, não tente memorizá-los. Essa não é a ideia. Apenas diga o que você quer dizer em seu programa, e se o compilador não entender, adicione o decisor à coleção de rotinas e me deixe o compilador mais inteligente.

É
É ALFANUMÉRICO
É ALGUMA CONSOANTE
É ALGUM DÍGITO
É ALGUMA LETRA
É ALGUM SÍMBOLO
É ALGUMA TECLA NUMÉRICA
É ALGUMA TECLA ALFABÉTICA
É ALGUMA TECLA DE COMANDO
É ALGUMA TECLA DO TECLADO NUMÉRICO
É ALGUMA TECLA DE SÍMBOLOS
É ALGUMA VOGAL
ESTÁ ENTRE
ESTÁ EM BRANCO
É INEXISTENTE
ESTÁ FECHADO
ESTÁ SENDO PRESSIONADO
ESTÁ VAZIA
É PAR
É DIVISÍVEL INTEIRAMENTE POR
É MAIOR [DO] QUE
É MAIOR [DO] [QUE] OU IGUAL A
ESTÁ DENTRO
É MENOR DO QUE
É MENOR [DO QUE] OU IGUAL A
É COMO
É NEGATIVO
É RUÍDO
É ÍMPAR
ESTÁ LIGADO
É IMPRIMÍVEL
ESTÁ MARCADO COMO SOMENTE LEITURA
ESTÁ DEFINIDO [FLAGS]
É SIMBÓLICO
ESTÁ TOCANDO
ESTÁ ACIMA [DE]
É MUITO ESCURO
É MUITO CLARO
É UM ESPAÇO EM BRANCO
ESTÁ ENTRE

DESENHANDO

Você pode dizer ao compilador coisas como:

DESENHE uma coisa.
DESENHE uma coisa USANDO uma cor.
DESENHE uma coisa USANDO uma cor na borda E uma cor no preenchimento.
DESENHE uma coisa DENTRO DE uma caixa USANDO uma fonte E uma cor.
DESENHE uma coisa NO CENTRO DE uma caixa USANDO uma determinada fonte E uma cor.

E o compilador irá renderizar tudo numa "tela virtual", ou seja, uma tela invisível do mesmo tamanho e formato que a tela do monitor. Dessa forma, quando você utilizar o comando:

ATUALIZE A TELA.

O compilador irá substituir o conteudo da tela pelo conteúdo da tela virtual em um piscar de olhos. Na verdade, mais rápido que isso. Quer dizer, às vezes não. Se você usar o comando:

ATUALIZA A TELA USANDO [o conteúdo de] uma caixa.

O compliador vai transferir apenas os pixels que estiverem dentro da caixa.

As regras para impressão funcionam de forma diferente. Nesse caso, o compilador usa "a tela da impressora" e envia os desenhos para um dispositivo de impressão assim que você finaliza página. Consulte a seção "Imprimindo" para mais detalhes.

Para ajustar suas coordenadas, você pode:

DEFINIR uma coordenada COMO ORIGEM DO DESENHO.

Você também pode evitar o desenho em certas áreas da tela usando o recurso de "fita crepe". Consulte o tópico "Fita Crepe" para descobrir como fazer isso.

ELIPSES

Infelizmente o Windows não permite círculos nem elipses — ele só desenha retângulos redondos dentro de caixas sem bordas. O que explica essa definição incomum de "elipse" que está presente no cérebro:

Uma elipse tem uma caixa.

Esta é uma imagem de uma elipse, com suas partes identificadas. Note que você pode obter os campos individuais da caixa da elipse usando o meu recurso de acesso aos "campos profundos", recurso este que é descrito sob o tema "Possessivos" neste glossário.

DIREITA ESQUERDA

CIMA

BAIXO

SUPERIOR ESQUERDO

INFERIOR DIREITO

CAIXA

O compilador pode fazer elipses de várias maneiras diferentes. Usando especificações de largura e altura. Ou usando um par de coordenadas. Ou todas as quatro coordenadas. Tudo o que você tem que fazer é escrever algo assim:

FAÇA uma elipse USANDO tal valor na largura E tal valor para a altura.
FAÇA uma elipse USANDO essa coordenada E essa outra coordenada.
FAÇA uma caixa USANDO esse lado esquerdo E essa parte de cima E esse lado direito E essa parte de baixo.

Assim como caixas, o compilador consegue DESENHAR uma elipse. Bem como obter a largura, altura o ponto central entre outras coisas. Inclusive detectar se uma coordenada ESTÁ DENTRO (ou fora) de uma elipse ou se a coordenada ESTÁ na borda de uma elipse. Sem mencionar todas as outras "Transformações Gráficas" as quais você pode saber mais em outra parte mais abaixo neste glossário.

EVENTOS/COMANDOS RECEBIDOS PELO SISTEMA

O Windows insiste que usemos seu modelo complicado e não processual juntamente com as suas centenas de mensagens e códigos absurdos. Felizmente, o compilador inclui definições que reduzem essa monstruosidade a apenas dez simples eventos que podem ser tratados de uma forma puramente processual. Eis o código:

Um evento é uma coisa com 
uma categoria,
um detector de shift, uma detector de ctrl, uma detector de alt,
uma coordenada,
uma tecla e um byte.

Categoria nada mais é do que uma das seguintes palavras:

ATUALIZAÇÃO DE TELA — Esse tipo de evento informa que é hora de redesenhar a tela. Culpe o Windows por isso. MOVIMENTO DE CURSOR — O cursor se moveu. Esse tipo de evento é muito usado para redimensionar formas e objetos. PRESSIONAMENTO DE TECLA — O usuário digitou algo. Acho que nem preciso explicar nada. CLIQUE ESQUERDO (ou apenas CLIQUE) — O botão esquerdo do mouse acabou de ser presssionado. Muito usado em botões e componentes similares. CLIQUE DUPLO — O usuário clicou duas vezes. Se você usa o Windows então já sabe que geralmente esse comando é utilizado para abrir ou executar arquivos. CLIQUE DIREITO — O botão direito do mouse acabou de ser pressionado. No compilador, esse é o comando que inicia a rolagem da página. CLIQUE DIREITO DUPLO — O usuário deve ter clicado por engano. Que tal colocar darmos a ele ovo de páscoa para celebrar? DESATIVAÇÃO — O usuário mudou para outra janela. O compilador lida com isso internamente. ATIVAÇÃO — O usuário retornou para o seu programa. O compilador lida com isso internamente. ENCERRAMENTO — Informa que o programa está sendo encerrado. Inserido internamente. Você não deveria ver esse tipo de evento.

Os detectores de ctrl e alt e shift indicam o estado das teclas correspondentes no momento do evento (o detector é acionado se a tecla for pressionada).

A coordenada é a posição do mouse no momento do evento.

A tecla e seu byte ASCII equivalente (se houver) aplicam-se apenas à Teclas Pressionadas.

PROGRAMAÇÃO ORIENTADA A EVENTOS

Esta é a estrutura de um programa orientado a eventos:

Se não houver eventos sendo executados, a rotina de "desenfileirar" continuará verificando a situação junto ao Windows até que o seu usuário distraído faça alguma coisa. Para encerrar o programa, você deve utilizar um dos seguintes comandos:

RENUNCIAR AO CONTROLE.
DELEGAR O CONTROLE.
ENTREGAR O CONTROLE.
ABANDONAR O CONTROLE.
LARGAR O CONTROLE.

Em algum lugar do seu código. Geralmente em um dos seus gerenciadores de eventos. Esta rotina configura as coisas para que o próximo evento que você "desenfileirar" seja nulo, terminando o seu loop de gerenciamento de eventos.

Para que o programa seja executado:
Inicie o programa.
Gerencie os comandos do usuário.
Feche o programa.

Para gerenciar os comandos do usuário:
Remova o evento da fila.
Se o evento não existir, ignore-o.
Gerencie o comando.
Repita.

Para gerenciar um comando:
Se a categoria do evento é "atualização de tela", [encaminhe a atualização] saia.
Se a categoria do evento é "pressionamento de tecla", [encaminhe a atualização] saia.
Se a categoria do evento é "clique do mouse", [encaminhe a atualização] saia.
[ · · · ]

seu programa

EXPRESSÕES

Uma "expressão" é como uma oração subordinada em uma frase complexa. É uma frase que deve ser reduzida, separadamente, antes que a instrução que a contém possa ser totalmente compreendida. Se você, por exemplo, dizer:

Coloque a altura menos 1 vez a contagem em um número.

O compilador converte a frase a altura menos 1 vez a contagem para algo muito mais simples antes de pensar em colocar qualquer coisa em qualquer lugar. O compilador considera como expressão qualquer frase com uma ou mais das seguintes palavras:

MAIS, MENOS, VEZES, DIVIDIDO POR, ou EM SEGUIDA.

Os quatro primeiros são operadores aritméticos padrão, mas você pode aplicá-los a outras coisas também. O último é usado principalmente para unir palavras e textos. Deixe-me explicar como o compilador simplifica expressões com alguns exemplos.

Digamos que o compilador encontre a palavra MAIS entre a palavra couve e a palavra flor. Ele busca por uma rotina que diga como adicionar uma couve a uma flor, e então usa essa rotina para reduzir a expressão. Se ele encontrar uma couve MENOS uma flor, ele procura uma rotina para subtrair uma flor de uma couve. Para calcular um couve VEZES uma flor, ele usa a rotina para multiplicar uma couve por uma flor. E para poder calcular uma couve DIVIDIDO POR uma flor, ele busca e usa a rotina para dividir um couve por uma flor.

O compilador lida com o último operador um pouco diferente, já que o objetivo neste caso é sempre para anexar uma texto no final de outro texto. Então, por exemplo, se o compilador encontrar a expressão EM SEGUIDA entre, digamos, uma palavra e um número, o compilador busca por uma rotina para converter um número em um texto, aplica a rotina no número e então adiciona o número convertido ao final do texto.

É claro que é possível extender essa capacidade. Mas use com moderação.

CAMPOS

Um record é uma coleção de itens que contém dados intimamente relacionados. Cada item é considerado um "campo". Campos são definidos como parte do record que os contém, e podem ser separada por vírgulas, ponto e vírgula ou pelas palavras E e OU. Consulte o exemplo abaixo:

Uma pessoa é algo com 
um nome e
um endereço postal;
um byte chamado gênero ou
um byte chamado sexo no gênero;
32 bytes, e
um cônjuge (referência).

O primeiro campo é definido com apenas um artigo indefinido, UM e um tipo, NOME. Pense neste campo como o nome da pessoa.

O segundo campo inclui um ENDEREÇO POSTAL, que é nada mais do que uma variável do tipo texto. Logo, em algum lugar do seu código você precisará acrescentar a definição:

Um endereço postal é um texto.

O terceiro campo é definido da mesma forma que o primeiro campo, mas com um nome imposto a ele devido a cláusula CHAMADO. Esse campo é o gênero da pessoa. Normalmente, você só usará esssa forma quando o tipo de um campo não tiver nada a ver com o nome do tipo (Ninguém costuma pensar em gênero em termos de bytes).

O quarto campo usa a palavra chave NO para redefinir o terceiro campo, dando-lhe um novo nome. Asobreposição de tipos de dados deve ser compatível para que coisas como esta funcionem.

O quinto campo é enchimento. Ele não tem nome e não pode ser acessado diretamente.

O último campo é parecido com o segundo, onde se assume que a variável CÔNJUGE é um tipo definido em outro lugar. A tag (REFERÊNCIA) serve para informar que o termo CÔNJUGE não faz "parte" da pessoa e não deve ser destruído automaticamente quando a pessoa for.

ARQUIVOS

O sistema de arquivos do Windows é uma coisa de beleza insuperável, se igualando a uma obra de arte... Brincadeirinha. Na verdade o sistema de arquivos do Windows é uma verdadeira bagunça. Só pra você ter uma idéia:

Um endereço completo é um texto. \ nome completo do arquivo = c:\pasta1\subpasta2\arquivo.exe
Um endereço de unidade é um texto. \ letra da unidade seguido dois pontos e barra invertida. Exemplo -> c:\
Um endereço de pasta é um endereço completo. \ Exemplo -> c:\pasta1\pasta2\
Um nome de pasta é um texto.\ apenas o nome da pasta em si seguido da barra invertida = pasta2\ 
Um nome completo de arquivo é um texto.\ nome do arquivo após a última barra invertida até o fim da extensão. Exemplo: aquivo.exe
Uma extensão de arquivo com ponto é um texto.\ Exemplo: .ext
Um designador é um texto.\ nome da pasta ou nome do arquivo`

Mesmo com tanta cofusão, o compilador consegue:

EXTRAIR qualquer uma dos itens acima USANDO um endereço completo.

Ou ainda:

GRAVAR um endereço completo NO SISTEMA DE ARQUIVOS. SUBSTITUIR um endereço completo POR outro endereço completo NO SISTEMA DE ARQUIVOS. EXCLUIR um endereço completo NO SISTEMA DE ARQUIVOS. CRIAR UMA CÓPIA DE um endereço completo EM outro endereço completo NO SISTEMA DE ARQUIVOS.

Ou, se você preferir:

COLOCAR um endereço completo DENTRO DE um texto. GRAVAR um texto EM um endereço completo.

Se algo der errado, o erro de entrada/saída irá conter uma descrição do problema, adequada para exibição ao usuário. Você não precisa limpar o erro de entrada/saída antes de uma invocar uma dessas funções, mas deve verifica o erro depois de chamar a função para ter certeza que ele está em branco.

ARQUIVOS (continuação)

Se você precisar acessar uma ou mais pastas do sistema de arquivos, você pode usar um comando como esse:

Para percorrer todos os itens em um endereço completo:
Obtenha um item do do endereço completo.
Se o item não for encontrado, sair.
[faça algo com o item]
Repita.

seu programa

O termo "Item" é definido da seguinte forma no compilador:

Um item tem
uma categoria,
um endereço completo, um endereço de pasta, um designador, uma extensão,
um tamanho,
um win32finddata e um número identificador.

O campo categoria é uma variável do tipo texto. O conteúdo dessa variável pode ser pasta ou arquivo para cada item encontrado. Os campos extensão e tamanho serão preenchidos apenas se a categoria for arquivo. Os campos win32finddata e número identificador são necessários que o compilador funcione no Windows. Você também pode usar os seguintes comandos:

OBTENHA uma contagem de ITENS EM um endereço completo no SISTEMA DE ARQUIVOS.
OBTENHA um tamanho USANDO um endereço completo no SISTEMA DE ARQUIVOS.

Note que os contadores e tamanhos de arquivo, incluindo o tamanho no registro de nome Item, são limitados a 2147483647, que é o maior número permitido pelo compilador no momento.

FONTES

No Windows, uma fonte é definida com quatorze parâmetros distintos. Complicado demais. O compilador usa uma definição bem mais simplicada:

Uma fonte tem um nome e uma altura.

O nome da fonte é o nome real armazenado em um arquivo de fonte. Ele pode ou não ser o mesmo que o nome do arquivo. Você provavelmente está familiarizado com nomes de fonte como Arial, Times New Roman e Courier New.

A altura da fonte pode ser especificada em qualquer unidade de medida conveniente. O caderno utiliza valores como 1/4 de polegada para poder se harmonizar com a função de alinhamento yank.

A fonte padrão" do compilador é chamada de Osmosian como homenagem aos criadores do projeto. O código hexadecimal da fonte está presente no noodle. O CAL "instala" a fonte na inicialização e deleta no encerramento. Ela mede 1/4 de polegada. Você está vendo uma amostra neste momento.

Para configurar uma fonte, basta utilizar o comando:

COLOQUE um nome E uma altura EM uma fonte.

Então, quando você estiver exibindo os itens na dela, informe que quer usar sua fonte:

Escreva "Olá, mundo!" no centro da caixa de seleção usando a fonte.

Se as suas fontes apareceram diferente do esperado, você provavelmente errou o nome da fonte. Lembre-se, um nome de fonte não é necessariamente o nome do arquivo na pasta "fonte" do Windows. Em vez disso, você deve usar o nome do typeface exibido na caixa de visualização que aparece quando você clica duas vezes em um desses arquivos de fontes.

FUNÇÕES

Uma "função" é uma rotina que extrai, calcula ou deriva algo usando uma variável. Alguns exemplos são:

Para colocar a linha inferior de uma caixa em uma linha:
Para colocar a altura de um polígono em uma altura:
Para colocar a posição do mouse em uma posição:

Há dois formatos muito semelhantes para funções. O primeiro é:

PARA COLOCAR UM nome DO tipo EM um nome DE tipo:

E o segundo é:

PARA COLOCAR UM nome DO nome EM um nome DE tipo:

Ambas as formas são facilmente reconhecidas porque elas incluem as palavras COLOCAR e EM com um possessivo entre elas. O primeiro formato é o mais comum e é usado com tipos e variáveis normais. O segundo é usado com variáveis únicas globais e pseudo-variáveis.

O que é especial sobre funções é que você pode usar suas partes possessivas como se elas fizerem referência a campos reais em um registro. Por exemplo, dadas as funções acima, você pode obter a linha inferior da caixa como se ela já tivesse sido definida no tipo de registro da caixa. Você pode solicitar a altura do polígono e veremos que ela é calculada quando você precisar. E você pode dizer a localização do mouse e o compilador busca a lozalização para você, mesmo que a variável mouse não tenha nenhum item localização dentro dela.

Nem preciso dizer o quão útil é essa função. Mas tente não abusar dela. Seja sábio.

Consulte o tópico Possessivos para mais informações.

VARIÁVEIS GLOBAIS

Uma variável "global" é uma variável que é visível para todas as rotinas, e que portanto pode ser usada por qualquer rotina em um programa. As variáveis globais podem ser definidos através de várias maneiras, mas suas definições sempre começam com um artigo definido (O, A, OS, AS). Eis alguns exemplos:

A seta do mouse é um cursor.
A tecla backspace é uma tecla igual a 8.
O maior número é [um número igual a] 2147483647.

A seta do mouse será inicializado com o valor 0 (indefinido). A tecla backspace foi inicializada com um tipo explícito (tecla) e com o valor 8. A terceira variável usa um tipo implícito (colocado em colchetes como observação). Portanto, as formas gerais são:

O *nome da variável aqui* É UM *nome de tipo da variável aqui*.
O *nome da variável aqui* É UM *nome de tipo da variável aqui*IGUAL A *valor da variável aqui*.
O *nome da variável aqui* É *valor da variável aqui*.

Uma variável global "única" é um tipo especial de variável global que inclui a definição de de um tipo dentro dela. Exemplo:

O mouse tem uma tecla chamada botão esquerdo e uma tecla chamada botão direito.

Como só existe um mouse, não há necessidade de definir um registro chamado mouse. Em vez disso, a variável global e seu tipo podem ser definidos em uma única linha. Há duas formas que podem ser utilizadas para definir uma variável global de tipo único. A primeira cria um novo tipo de registro, enquanto a segunda estende um registro já existente:

O *insira o nome da variável aqui* TEM *insira os campos aqui*.
O *insira o nome da variável aqui* É UM *insira o tipo da variável aqui* COM *insira os campos aqui*.

Uma variável global única é algo raro. Provavelmente porque são únicas. Mas respondem à velha pergunta "Quem veio primeiro, o ovo ou a galinha?". A galinha, claro.

TRANSFORMAÇÕES GRÁFICAS

O compilador possui uma série de rotinas para manipulação gráfica. Os objetos gráficos podem ser manipulados de diversas formas. Por exemplo, você pode usar os comandos:

MOVA alguma coisa PARA CIMA tantos pixels. 
MOVA alguma coisa PARA BAIXO tantos pixels. 
MOVA alguma coisa PARA A ESQUERDA tantos pixels.
MOVA alguma coisa PARA A DIREITA tantos pixels.
MOVA alguma coisa USANDO um valor x E um valor y.
MOVA algo PARA um ponto na tela.

O último comando MOVA usa o canto superior esquerdo do ponto informado para efetuar o alinhamento do objeto. O compilador também aceita os seguinte comandos:

CENTRALIZE algo EM um ponto na tela.
CENTRALIZE algo EM uma caixa.

Álém dos comandos de posicionamento, existem comandos de transformação de objetos. Por exemplo:

INVERTA algo. ESPELHE algo. ROTACIONE algo.

O comando INVERTA inverte objetos verticalmente. O comando ESPELHE faz a mesma coisa, mas na horizontal. No momento o comando ROTACIONE só consegue rotacionar objetos em intervalos de 90 graus. Além disso o comando não funciona com textos. Essa á uma rotina que ainda está sendo aprimorada.

As últimas rotinas de transformação de objetos gráficos são:

REDIMENSIONE algo USANDO uma proporção. 
REDIMENSIONE algo USANDO uma porcentagem.

Consulte os tópicos Desenhando e Máscara para informações adicionais.

IMPERATIVOS

Um comando "imperativo" é um comando não condicional dentro do corpo de uma rotina. Aqui estão alguns imperativos de amostra retirados do compilador:

Alerte o usuário. Subtraia 1 da quantia. Remova o último pedaço do texto. Coloque a altura da fonte do texto multiplicada por 2 no x da grade.

Os imperativos normalmente começam com um verbo e terminam com um ponto. Mas no meio, entra quase qualquer coisa. Literais. Termos. Expressões. Frases preposicionais. Tudo junto e misturado.

Para criar um imperativo, basta digitar o que você está pensando. Se houver uma rotina que consiga lidar efetuar o comando, o compilador irá executar a mesma. Caso contrário, o compilador exibirá uma mensagem de erro, exigindo que você mesmo crie a rotina.

Eis os onze imperativos básicos presentes no compilador:

DIGA. Este imperativo é utilizado dentro de rotinas decisoras. Para mais informações, consulte o tópico Decisores.

PERCORRA, REPITA, PARE e SAIA. Esses comandos s]ao usado em laços de repetição. Consulte a seção Laços.

CHAMAR e APONTAR. Usado para chamar bibliotecas e funções do Windows. Consulte a seçãoWindows.

EMPLOY, PUSH e INTEL. Comandos que espero que você nunca precise utilizar. Consulte Imperativos Especiais.

PRIVATIZE. Usado somente com "Parâmetros".

Já que os imperativos são apenas palavras que chamam rotinas, você também deve conferir as páginas Rotinas, Procedimentos, Decisores, Funções e Nomes.

FLUXO PADRÃO DE ENTRADA E SAÍDA

Você pode trabalhar diretamente com o mouse usando instruções como estas:

ARMAZENE a posição do mouse EM uma localização. SE o botão esquerdo do mouse FOR PRESSIONADO, ... SE o botão direito do mouse FOR LIBERADO, ...

Mas você provavelmente não vai precisar, a menos que esteja monitorando o mouse, enquanto o usuário arrasta alguma coisa pela tela. Na maioria das vezes, você simplesmente irá responder aos vários eventos do tipo "clique" que são enviados para o seu gerenciador de eventos.

Você pode trabalhar diretamente com o teclado usando instruções como:

SE a tecla Esc FOR PRESSIONADA, ...
SE a tecla Shift FOR LIBERADA, ...

Mas novamente, você provavelmente não vai precisar usar esses comandos, porque o Windows funciona melhor se você apenas responder aos eventos de "tecla pressionada" que forem enviados para seu gerenciador de eventos. Você pode encontrar todas as teclas globais procurando por "é uma tecla igual a".

Você pode trabalhar diretamente com a tela usando a variável quadro da tela e essa é uma variável global única:

A tela tem uma caixa, uma altura de pixel e uma largura de pixel.

Mas você não deveria. Em vez disso, é melhor que você use a tela virtual, para aí sim passar o conteúdo da tela virtual para a tela real usando o comando:

ATUALIZE A TELA.

Consulte o tópico Desenhando para obter mais informações. Mas não hesite em usar a caixa da tela e todos os campos da tela ao inicializar suas coisas.

INTERNET

Essas são as variáveis que você precisará usar para obter arquivos da internet:

Uma URL é um texto.

Um texto de requisição é um texto.

Um URL é um Localizador Universal de Recursos, por exemplo <a href="http://www.osmosian.com">http://www.osmosian.com</a>, que como você pode ver é apenas uma seqüência de caracteres que segue uma convenção complicada para nomes. Essa convenção foi baseada na tecnologia de análise disponível na época, e que fazia muito sucesso há uns 50 anos.

Umtexto de requisição ou "query string" é um texto com alguns dos seus bytes convertidos em codificações absurdas consistentes com os padrões da internet. Um espaço, por exemplo, se torna uma %20, e uma vírgula se torna %2C.

Você pode converter um texto comum em um texto de requisição usando o comando a seguir:

CONVERTA um texto EM UM texto de requisição.

Você pode acessar um recurso da internet usando o seguinte comando:

COLOQUE uma URL DENTRO DE um texto.

Aqui está um código do nosso programa de exemplo para te lembrar como funcionaque você lembre-se de como funciona

Coloque "http://images.google.com/images?q=" em uma URL.

``Converta o texto do campo de texto em um texto de pesquisa.`

Coloque o texto de pesquisa no fim da URL.

COLOQUE a URL DENTRO DE um texto.

Lembra? Não tem nem como esquecer. O compilador analisou o texto, pintou o quadro, atualizou a tela, gerando uma verdadeira Obra de arte.

PALAVRAS-CHAVE

A maioria das linguagens de programação tem longas listas de palavras chave anômalas, cabalistas, enigmáticas, inescrutáveis, ofuscantes, "reservadas", tais como:

ABSTRACT, PROTECTED, SYNCHRONIZED, TRANSIENT, e VOLATILE.

Essa linguagem funciona de forma diferente. As palavras-chave são termos comuns. Artigos como:

UM, UMA, UNS, UMAS, O, A, OS, AS, etc.

Verbos usados frequentemente:

SER, ESTAR, PODER, FAZER, DEVER, POSSUIR e TER.

Algumas conjunções:

E, AMBOS(AS), MAS, QUALQUER, QUAISQUER, NENHUM(A), NEM e OU.

E muitas preposições:

EM CIMA, COMO, EM, ANTES, ENTRE, VIA, EMBAIXO, POR, DE e várias outras.

Alguns operadores aritméticos:

MAIS, MENOS, VEZES, DIVIDIDO POR, EM SEGUIDA, NULO, SIM, NÃO, CHAMADO e IGUAL.

Por último, palavras negativas:

NÃO, NEM, NENHUM, NADA, NUNCA, JAMAIS e similares.

Espero não ter esquecido nada importante. Na dúvida, consulte o código fonte para exemplos de uso.

O WINDOWS

Se você por acaso precisar utilizar bibliotecas e funções internas do Windows, você pode utilizar comandos semelhantes a este:

CHAME "NomeDaDll.dll" "NomeDafunção" COM parâmetro E RETORNE algo.

As cláusulas COM e RETORNANDO são opcionais. Você deve diferenciar maiúsculas e minúsculas no nome da função, usando o mesmo nome que o nome da dll do Windows ou da sua pasta. Textos devem ser passadas por endereço e, em muitos casos, devem terminar com o byte NUL. Use "o primeiro byte do texto" para o endereço, e a rotina a seguir para adicionar um byte nulo no final do texto:

ADICIONE O BYTE NULO no final de um texto.

Em outros casos, o Windows nos fornece não nome de uma função, mas o endereço dela. Você pode chamar essas funções usando uma sintaxe similar:

CHAME um endereço COM esse parâmetro E RETORNE algo.

Às vezes, o Windows precisa que nós forneçamos o endereço de uma de nossas rotinas para que ele possa interromper nosso previsível fluxo processual em algum momento. Você pode usar esta sintaxe para obter o endereço de uma rotina:

APONTE um ponteiro PARA ROTINA nome de rotina.

Mas se você for passar o endereço para o Windows, certifique-se de que o cabeçalho da rotina inclua a palavra-chave COMPATIVELMENTE logo após PARA, assim:

PARA COMPATIVELMENTE ...

Se você está trabalhando neste nível ridiculamente baixo, você vai querer verificar as seções "Bits", "Imperativos Especiais" e meu o código fonte para mais informações e exemplos.

LINHAS

Uma "linha" é um objeto gráfico que começa em um lugar e termina em outro lugar. Mas você já sabia disso. Eis a definição de linha:

Uma linha tem um ponto inicial e um ponto final.

E aqui está uma imagem de uma linha, com suas partes identificadas:

O compilador consegue fazer linhas a partir de dois pontos ou usando quatro coordenadas separadas (2 x e 2 y):

FAÇA uma linha USANDO essa coordenada E essa outra coordenada. FAÇA uma linha COM este x E este Y E aquele x E aquele Y.

O compilador também tem quatro funções que colocarão uma LINHA ESQUERDA DA caixa ou uma LINHA SUPERIOR de uma caixa ou uma LINHA DO LADO DIREITO de uma caixa ou uma LINHA INFERIOR da caixa em uma linha.

O compilador consegue CRIAR uma linha. Ou encontrar o CENTRO de uma linha. O compilador é capaz de até mesmo de:

DIVIDIR uma linha EM uma linha E outra linha.

Bem no meio. Ele consegue detectar se um ponto está em cima de uma linha. Além de conseguir realizar todas as Transformações Gráficas habituais em linhas, também.

Consulte o tópico Spots para mais informações sobre esses pontos finais.

PONTO INICIAL

PONTO FINAL

•

LISTAGEM

Se você é um fã de compiladores, você vai gostar disso. Se você não for, vire a página.

Você pode produzir uma lista criptografada de todas as definições do compilador utilizando o comando Listar. A listagem é salva como texto na pasta de origem recebe o nome dessa pasta junto com a extensão .lst. A interpretação deste arquivo é deixada para você como um exercício.

Mas vou dar-lhe algumas pistas. E algum incentivo.

A listagem consiste em doze seções distintas com os seguintes títulos: tipos, globais, literais, rotinas, tipo índice, índice global, índice literal, índice de rotina índice, índice de utilidade, importações, arquivos fonte e temporizadores. Cada título é seguido de dois pontos para que você possa pular para qualquer seção usando o comando Encontrar. Aqui está uma pequena amostra da seção rotina:

/routine/create [picture]/yes/no/no/no//4/0/00470A48/
/variable/parameter/yes/picture/picture/picture/picture/00000008/no/1/no////
/fragment/prolog/////00000000/00470A48/558BEC/
/fragment/loop/////00000000/00470A4B//
/fragment/push address/picture////00000000/00470A4B/8B950800000052/
/fragment/call internal///allocate memory for [picture]//00000000/00470A52/E8BDA70400/
/fragment/finalize/////00000000/00470A57//
/fragment/epilog/////00000000/00470A57/8BE55DC204000000/

Eu recomendo que você estude a rotina listar no compilador antes. Faça um pequeno programa, use o comando listar, e consulte o resultado. Adicione uma linha ou duas, e repita.

Passemos agora ao incentivo.

Se você encontrar algum erro no compilador, mande um email para os criadores e eles lhe enviarão algo bacana como uma camiseta em branco. Se você consegue descobrir como tornar o compilador mais simples sem deixar mais lento, eles vão te enviar uma camiseta personalizada. E se você puder criar uma maneira de fazer o compilador menor, mais rápido e mais poderosa tudo de uma só vez, tenho certeza que eles te enviarão uma camiseta sem manga bordada.

LITERAIS

Um valor "literal" é um valor constante em um programa. O compilador entende sete tipos diferentes de literais, cada um com um formato específico.

Um "número" literal são dígitos, com um sinal opcional, mas sem espaços ou observações:

Exemplos: 0, -2147483648, +2147483647

Uma "Proporção literal" é um número, uma barra e um número sem sinal:

Exemplos: 335/113, 25946/9545, -19601/13860

Um "literal misto" é um literal numérico, um traço e uma proporção sem sinal.

Exemplos: 1-1/2, -2-2/3, 3-3/4

Um texto literal é uma série de caracteres entre aspas duplas. Se você precisar de uma aspa dupla dentro de uma string, coloque duas ao redor dela e pronto. Assim:

"Este é um texto literal com ""aspas duplas em torno disto"" mas não disto"

O único "ponteiro literal" é a palavra-chave NIL. Ele indica um ponteiro vazio ou inválido. Para fazer com que um ponteiro fique vazio (NIL) é só usar o comando ESVAZIAR.

Uma bandeira literal é uma das palavras-chave SIM ou NÂO. Você pode definir uma bandeira para colocar SIM nela, e você pode LIMPAR uma bandeira para colocar NÃO nela.

Um nibble literal é um $ seguido de dígitos hexadecimais. Provavelmente você não precisará utilizá-los. Aqui está uma amostra, de qualquer forma:

$DED0FEDE

VARIÁVEIS LOCAIS

Uma "variável local" é uma variável que é propriedade privada de uma rotina. Variáveis locais não podem ser vistas ou modificadas por qualquer outra rotina. A menos que, claro, você as passe para outras rotinas como parâmetros.

O compilador cria uma nova cópia de cada variável local, a cada vez que uma rotina é chamada. A variável é inicializada com o valor 0. O que significa que uma rotina pode chamar a si mesa e tudo ainda vai funcionar. Isto é chamado de "recursão", e se você não sabe o que isso significa, não precisa disso. O compilador se lira das variáveis locais à medida que cada rotina é completada, para que elas não ocupem memória à toa.

Você cria uma nova variável local em uma rotina sempre que usa um artigo indefinido (A, AN, ANOTHER ou SOME) em um comando. Por exemplo:

Coloque a localização do mouse em outra localização. Coloque a coordenada esquerda da tela em uma coordenada esquerda da caixa. Coloque 101 em outro número de curso.

No primeiro exemplo, a frase uma localização faz com que eu faça uma nova variável local chamada "a localização". Em seguida, o compilador põe a localização atual do mouse na variável.

O segundo exemplo coloca a coordenada esquerda da tela em uma nova coordenada esquerda da caixa. O restante das coordenadas da caixa — superior, direita e inferior — estão definidas como zero.

O terceiro exemplo coloca um literal 101 em uma nova variável local do tipo número. Esta variável é definida com adjetivos anteriores ao nome do tipo, então ela pode ser referenciada pelo seu nome completo, O outro número de curso, ou por apelido, o outro curso. Você pode ler mais sobre nomes sob o tópico Nomes.

Consulte também a página Laços, onde uma variável local e um decisor nos permite fazer laços contados sem adicionar novas palavras-chave ao compilador.

LAÇOS

Os comandos específicos para laços são PERCORRA, REPITA, INTERROMPA e SAIA.

O comando PERCORRA não faz nada a não ser indicar o começo do laço. O comando REPITA volta para o comando PERCORRA, se houver um. Se não houver, o comando volta para o topo da rotina. O comando INTERROMPA sai do LAÇO e prossegue para o comando logo após o último comando REPITA. Se não houver nenhum comando REPITA, o comando vai fazer a mesma coisa que o comando SAIA. Você só pode usar um comando PERCORRA em cada rotina, mas não há limites para a quantidade de REPITA, INTERROMPA ou SAIA.

O comando que começa com "Se um contador tiver passado do máximo" chama um decisor especial que avança o conrador e verifica o mesmo logo após. Como o contador é uma nova variável local, quando a rotina é iniciada ele começa valendo zero.

Observe que você pode utilizar os comandos PERCORRA, REPITA e INTERROMPA em um decisor, mas você não pode usar o comando SAIA porque isso interrompe o fluxo de decisão da rotina. Por isso você precisa tomar cuidado para não sair sem querer de um decisor, também. Para sair de um decisor, utilize os comandos DIGA SIM ou DIGA NÃO.

Para fazer um laço em torno de um número máximo:
\ coisas que você quer fazer antes do loop
Percorra.
\ coisas que você deseja fazer pelo menos uma vez
Se um contador tiver passado do valor máximo, pare.
Se [queremos saltar para fora do laço], pare.
Se [queremos saltar de toda a rotina], saia.
\ coisas que você pode querer fazer ou não
Repita.
\ coisas que você quer fazer depois do loop

seu programa

FITA CREPE

Os pintores da vida real geralmente usam fita crepe, dessa forma eles não pintam onde não querem. Da mesma forma que os artistas, você pode usar as rotinas de "máscara" do compilador para restringir a rotina de desenho do compilador. Os comandos são esses:

PROTEJA O INTERIOR disso. PROTEJA A PARTE DE DENTRO disso. PROTEJA A PARTE INTERNA disso. PROTEJA O EXTERIOR disso. PROTEJA A PARTE DE FORA disso. PROTEJA A PARTE EXTERNA disso.

Onde disSo podem ser caixas, elipses, polígonos ou caixas arredondadas. Perceba, no entanto, que a infelizmente só conseguimos usar uma "fita boa" em caixas. Em todos os outros lugares só conseguimos usar uma fita ruim, então não espere perfeição com nada a não ser caixas.

Qualquer fita que você aplica permanece aplicada, então depois você provavelmente vai querer usar um desses comandos:

DESPROTEJA O INTERIOR disso. DESPROTEJA A PARTE DE DENTRO disso. DESPROTEJA A PARTE INTERNA disso. REMOVA A PROTEÇÃO DO INTERIOR disso. REMOVA A PROTEÇÃO DA PARTE DE DENTRO disso. REMOVA A PROTEÇÃO DA PARTE INTERNA disso. DESPROTEJA O EXTERIOR disso. DESPROTEJA A PARTE DE FORA disso. DESPROTEJA A PARTE EXTERNA disso. REMOVA A PROTEÇÃO DO EXTERIOR disso. REMOVA A PROTEÇÃO DA PARTE DE FORA disso. REMOVA A PROTEÇÃO DA PARTE EXTERNA disso.

Ou para agilizar o serviço:

DESPROTEJA TUDO. REMOVA A PROTEÇÃO DE TUDO.

para começar do zero. Para conveniência, você pode remover toda a fita existente e colocar uma nova fita ao mesmo tempo com instruções como as seguintes. Acredite se quiser, estas são as que são mais frequentemente usadas:

PROTEJA SOMENTE O INTERIOR disso. PROTEJA SOMENTE A PARTE DE DENTRO disso. PROTEJA SOMENTE A PARTE INTERNA disso. PROTEJA SOMENTE O EXTERIOR disso. PROTEJA SOMENTE A PARTE DE FORA disso. PROTEJA SOMENTE A PARTE EXTERNA disso.

Note que se você estiver desenhando e nada estiver aparecendo, isso provavelmente está acontecendo porque você está usando a fita crepe onde não quer, ou você esqueceu de ATUALIZAR A TELA conforme descrito no tópico Desenhar.

GERENCIAMENTO DE MEMÓRIA

O compiladorgerencia toda a memória necessária para os tipos de dados estáticos — como bytes, wyrds, números, ponteiros, bandeiras e a maioria dos registros. O compilador também gerencia as strings (texto), uma vez que elas são usadas com frequência e seu comportamento é previsível.

Mas quando você define um tipo dinâmico de dados, como uma "coisa", você se torna o único responsável por qualquer memória usada pelo tipo.

Normalmente, você vai programar uma rotina CRIAR para inicializar cada tipo dinâmico que você definir. Nessa rotina, você atribuirá memória para a coisa. O esquema de funcionamento é mostrado abaixo:

ALOQUE MEMÓRIA PARA algo. ALOJE MEMÓRIA PARA algo. ATRIBUA MEMÓRIA PARA algo. RESERVE MEMÓRIA PARA algo. SEPARE MEMÓRIA PARA algo.

Você também pode codificar uma rotina DESTRUIR para cada tipo, com uma linha como:

DESALOQUE A MEMÓRIA DE algo. DESALOJE A MEMÓRIA DE algo. REMOVA A MEMÓRIA DE algo. LIMPE A MEMÓRIA DE algo. ESVAZIE A MEMÓRIA DE algo.

Mas se você não quiser, pode usar a rotina padrão do sistema. Apesar da rotina não ser ececutada automaticamente, ela existe, basta usar o comando certo. As rotinas DESTRUA que podem ser chamadas desta maneira:

DESTRUA algo.

Observe quea rotina DESTRUA não só destrói a coisa em si, mas também quaisquer outras coisas que estejam dentro da coisa, como campos e listas. A menos que, que você defina esses campos como "(REFERÊNCIA)".

Um bom exemplo pode ser encontrado no caderno onde uma "página" é definida como uma coisa com algumas "formas" nela. Voce encontrará rotinas que criam páginas e formas, mas não encontrará nenhuma rotina específica para destruí-las. Elas são parte do compilador. Entao, quando destruímos uma página, nós destruímos todas as formas dentro dela ao mesmo tempo. Exceto, é claro, para a "forma de edição", que é uma referência.

NOMES

Ao contrário dos compiladores de era neandertal, as regras para nomes são amplas e flexíveis.

Em geral, um nome pode ser uma palavra ou vároas, e pode começar com letras, dígitos e qualquer símbolo que eu não sejam sinais de pontuação, como um ponto, uma vírgula, um ponto e vírgula ou dois pontos. Um nome é geralmente um substantivo, ou um substantivo com um ou mais adjetivos. Você não deve usar artigos, verbos, conjunções ou preposições em nomes.

Nomes de tipo geralmente contém de uma a três palavras. Como byte ou nome do arquivo.

Os nomes dos campos geralmente são apenas um nome de tipo. Como número ou texto. Mas eles também podem incluir adjetivos como número total ou texto do primeiro nome. A parte do adjetivo pode ser usada como um apelido se não causar ambiguidade.

Nomes globais são frequentemente um tipo seguido por um adjetivo: a tecla shift.

Nomes de parâmetros parecem nomes de campo. Um tipo, com ou sem adjetivos. Uma caixa, por exemplo, ou uma cor de borda. Também neste caso o apelido funciona.

Os nomes de procedimentos iniciam com um verbo. Em seguida, uma série de parâmetros (com artigos indefinidos), frases e talvez um qualificador no final. Tal como remova o último byte de um texto ou centralize um ponto em uma caixa (horizontalmente).

Nomes de função sempre começam com PONHA e terminam com EM/DENTRO e um nome de tipo. Com uma frase possessiva no meio. Como coloque a linha do topo que faz parte da caixa em uma linha.

Nomes de decisores parecem nomes de procedimentos, exceto pelo fato do verbo normalmente aparecer em algum lugar no meio. Como em, um número É menor que outro número.

Os nomes de variáveis locais seguem o padrão de parâmetro. O compilador cria uma variável local sempre que encontra um nome com um artigo indefinido na frente de todo o corpo de uma rotina.

PARÂMETROS

Uma variável se torna um "parâmetro" quando ela é passada para uma rotina. Para utilizar os parâmetros em uma rotina, você precisa informar a quantidade e os tipos de parâmetros no cabeçalho da rotina. Eis alguns cabeçalhos de rotina de amostra:

Para adicionar um número a outro número:
Para decidir se uma localização está dentro de alguns polígonos:
Para colocar o centro de uma elipse em uma localização:

A primeira rotina é um procedimento que espera dois parâmetros: um número e outro número. O primeiro é um parâmetro entrada; o segundo também é um parâmetro de entrada mas será devolvido na saída da rotina.

A segunda rotina é apenas um decisor comum. Ela também espera dois parâmetros, uma localização e alguns polígonos. Ambos os parâmetros são somente de entrada.

A terceira rotina é uma função com dois parâmetros: uma elipse e uma localização. A elipse é o parâmetro de entrada e a localização é o parâmetro de saída.

As definições de parâmetros são fáceis de identificar porque sempre começam com um artigo indefinido (UM, UMA, UNS, UMAS ou ALGUM, ALGUMA, ALGUNS, ALGUMAS) seguido por um substantivo. Você pode ler mais sobre nomes sob o tópico Nomes.

Observe que quando parâmetros são passados para rotinas, o compilador passa o parâmetro original, e não cópias. É por isso que você pode usá-las na entradas, saída ou nos dois. Às vezes, no entanto, você queira manipular o valor de um parâmetro sem afetar a variavel original. Neste caso, você pode utilizar o seguinte comando:

PRIVATIZE um parâmetro.

E o compilador fará uma cópia do parâmetro para você. Conforme explicado anteriormente, você continuará utilizando o mesmo nome do parâmetro, já que a variável original será renomeada apenas temporariamente. A variável original receberá o sufixo original no nome dela, para que você ainda possa acessá-la se precisar.

IMAGENS

Uma "imagem", para o compilador, é uma imagem feita de pixels. Geralmente, milhões de pixels. Imagens são um tipo de dado muito difícil de se trabalhar. Existem dezenas de formatos e padrões. Felizmente, o compilador já tem rotinas para lidar com os formatos mais comuns como png e jpg. Eis a definição:

Uma imagem é uma coisa [com coisas que você não quer saber].

Aqui estão duas imagens de amostra:

Peço desculpa pela qualidade destas imagens. Eu as descobri nos antigos arquivos quando eu estava pesquisando sobre a fundação da Sociedade Osmosiana.

Você pode criar uma imagem de várias maneiras. Você pode carregar um a partir de um endereço que contenha uma imagem BMP, JPG, GIF ou alguma outra imagem no formato padrão. Você pode colocar uma imagem em um depósito (buffer) e usar esse buffer como a fonte para sua imagem. Ou você pode pegar uma foto na internet através de uma URL. Você também pode criar uma imagem desenhando alguma coisa e, em seguida, "extraindo" a parte que você quer. Este é o formato geral:

CRIE uma imagem DE algo.

Assim que você tiver uma imagem, você pode DESENHÁ-la Ou aplicar as Transformações Gráficas nela. Ou usá-la como um modelo para uma verdadeira obra de arte, como fizemos com o programa de exemplo como pintar.

POLÍGONOS

Existem duas definições importantes sobre polígonos no compilador:

Um polígono é uma coisa com alguns vértices. Um vértice é uma coisa com uma coordenada x, uma coordenada y, e uma localização na coordenada x.

Polígonos e vértices são "coisas" e, portanto, ao contrário dos outros objetos gráficos, eles têm que ser criados e destruídos. Você também precisa acrescentar os seus vértices aos seus polígonos. Exemplos:

CRIE um polígono. CRIE um vértice A PARTIR DE uma localização. ACRESCENTE um vértice A um polígono. DESTRUA um polígono.

Ao usar o comando DESTRUA um polígogo, o compilador se livra tanto do polígono quanto dos vértices associados a ele.

Uma vez que você criar um polígono, você poderá DESENHÁ-lo. Você também pode realizar todas as habituais Transformações Gráficas nele. Você também pode usar o comando SUAVIZAR, e o compilador vai tentar arredondar o seu polígono, transformando cantos em curvas. Aqui está um polígono de amostra, com a versão normal e a suavizada:

Muito bem! Dessa forma fica fácil desenhar ondas sinoidais e outras formas geométricas sem usar um número real sequer. Eu gostaria que o Leopold estivesse aqui pra ver isso.

VÉRTICE

VÉRTICE

VÉRTICE

•

•

 •

•
VÉRTICE

DEPOIS

SUAVIZADO

POSSESSIVOS

Os Possessivos são normalmente usados para acessar campos nos registros. Conforme o exemplo abaixo:

*nome do campo* QUE FAZ PARTE DO *nome do registro*.

Mas eles também podem ser usados para fazer referência a uma função:

*nome da função* QUE FAZ PARTE DO *nome da coisa*.

Se o compilador não conseguir encontrar o campo dentro do primeiro nível registro, ele verifica se existe algum campo do registro que também seja um registro. E se encontrar, usa esse campo.

Mas a primeira coisa o compilador faz ao encontrar um possessivo é verificar a existência de três termos específicos. O primeiro é o seguinte:

um ALVO que faz parte de um ponteiro

Este forma é usado apenas com ponteiros. Isso diz que você quer saber para que item o ponteiro aponta. "Um ponteiro de byte", por exemplo, refere-se ao endereço de um byte. "O alvo que faz parte do ponteiro de byte" se refere aos dados no byte.

Os outros possessivos especiais retornam "meta-dados" — dados a respeito dos dados. Um deles lhe traz o tamanho, em bytes, e o outro lhe traz o endereço:

*MAGNITUDE* que faz parte do *nome da variável*.
*PARADEIRO* que faz parte do *nome da variável*.

Você provavelmente não precisará destes com muita frequência, por isso que esses nomes esquisitos foram escolhidos.

IMPRIMINDO

A rotina de impressão precisa ser aprimorada. Eis alguns detalhes da implementação:

O compilador sempre envia o trabalho de impressão para a impressora padrão do sistema;
O compilador faz uso das rotinas habituais de desenho.
O compilador verifica se o texto que aparece na página de impressão é igual ao conteúdo que está na tela.

Aqui está uma rotina típica de impressão:

Para imprimir coisas:
Inicie a impressão.
Percorra.
Inicie uma página.
[desenhe coisas aqui]
Apronte a página.
Se [ faltar alguma coisa], repita.
Termine de imprimir.

seu programa

O comando Inicie uma página define o quadro (área de desenho) atual como o quadro da impressora. O comando Apronte a página coloca o conteúdo da página de volta ao quadro da tela virtual. Então posicione quaisquer mensagens de status que você desejar exibir antes ou após essas chamadas.

Você pode usar o comando inicie uma página vertical para ser mais explícito, e você pode iniciar uma página horizontal para trabalhar em modo paisagem. As várias páginas são na verdade caixas, inicializadas pela rotina inicie, que você pode usar para posicionar suas coisas.

Basicamente é só isso.

PROCEDIMENTOS

Um "procedimento" é uma rotina que faz algo para você. Eis alguns cabeçalhos de procedimento de amostra:

Para converter um número em um texto: Para centralizar uma caixa dentro de outra caixa (horizontalmente): Para ocultar o cursor:

O formato geral é:

PARA fazer alguma coisa:

Os cabeçalhos de procedimento sempre começam com a palavra PARA, e sempre terminam com de dois-pontos. O alguma coisa entre elas segue as regras normais para nomes de rotina.

O conteúdo do corpo dos procedimentos são compostos por declarações: condicionais e imperativas, incluindo os imperativos internos como PRIVATIZE, PERCORRA, REPITA, PARE, e SAIA. No entanto, não se pode utilizar os comandos DIGA SIM e DIGA NÃO num procedimento.

O primeiro cabeçalho de amostra acima inclui um verbo, uma preposição e dois parâmetros. O verbo é converter e a preposição é em. Os parâmetros são um número e um texto.

O segundo procedimento é parecido com o primeiro, mas existe um qualificador: "(horizontalmente)".

A terceira rotina é um verbo seguido de um substantivo: o cursor.

Quando um substantivo estiver acompanhado de um artigo definido em um cabeçalho de rotina, ele geralmente será interpretado como uma variável global única, como por exemplo o comando desenhe a barra que está dentro do arquivo ambiente de trabalho. Mas eles também podem ser utilizados para se referir a uma pseudo-variável que não está definida precisamente no seu código. Como o cursor no exemplo acima, ou o último byte na rotina remova o último byte de um texto.

NÚMEROS ALEATÓRIOS

"Para fazer um sorteio são lançados os dados, mas quem determina o reultado é o Senhor." Provérbios 16:33 Então, eu acho que teremos que desistir dessa ideia de números aleatórios e nos contentar com números pseudo-aleatórios. Que é o que esse consegue gerar (não só esse, mas a maioria dos compiladores).

Na verdade, o compilador gera a mesma sequência de números "aleatórios" toda vez, a não ser que você semeie o gerador de números aleatórios com um valor inicial diferente (esse comportamento também se repete em outros compiladores). Enfim, para semear o gerador de números aleatórios, use o comando:

SEMEIE O GERADOR DE NÚMERO ALEATÓRIOS.

Mas não pense que você vai sempre ter certeza do resultado. Ninguém sabe. Exceto o Senhor, é claro.

A rotina de números aleatórios mais básica é esta:

ESCOLHA um número.

O que retorna um número entre 0 e 2147483647. Você também pode fazer assim:

ESCOLHA um número ENTRE o número mínimo E o número máximo.
ESCOLHA um número ENTRE uma quantidade DE outro número.
(Por exemplo: Escolha um número entre 6 de 60).

Você também pode usar a aleatoriedade ao escolher posições na tela:

ESCOLHA um lugar em QUALQUER LUGAR dentro de uma caixa.
ESCOLHA uma localização NO RAIO DE uma distância DE outra localização.

Rotinas como essa estão sempre sendo adicionadas e aperfeiçoadas então é sempre bom dar uma olhada no código fonte do compilador. Basta procurar por "escolha" e você provavelmente encontrará a maioria deles.

E se você não tiver certeza qual usar, tente o cara ou coroa.

REGISTROS

Um record é uma coleção de itens que contém dados intimamente relacionados. Cada item é considerado um "campo". Os campos são descritos em sua própria página. Mas aqui estão alguns exemplos de registros:

Uma caixa tem
uma coordenada esquerda, uma coordenada superior, um coordenada direita, uma coordenada inferior,
um canto superior esquerdo na coordenada esquerda, e um canto inferior direito na coordenada direita.

Uma caixa arredondada é uma caixa que tem
uma coordenada esquerda, uma coordenada superior, um coordenada direita, uma coordenada inferior,
um canto superior esquerdo na coordenada esquerda, e um canto inferior direito na coordenada direita e um raio.

Um polígono é uma coisa com alguns vértices.

O primeiro registro de amostra, caixa, tem seis campos. Mas os dois últimos são na verdade "reinterpretações" dos primeiros quatro. Este tipo de coisa só funciona, é claro, quando as estruturas físicas de dados correspondem. Observe que a palavra tem é uma abreviação do termo é um registro com, que também pode ser usado.

O segundo registro, caixa arredondada, é uma extensão da caixa. Tem os mesmos campos que uma caixa, e mais um novo campo chamado de raio. É compatível com a caixa, e é possível usar todas as rotinas que funcionam nas caixas normais para manipulár as caixas arredondadas — a menos que uma rotina específica para caixas arredondadas tenha sido criada.

O terceiro registro, polígono, não tem nada além de uma lista de vértices. Como o polígono é definido como uma coisa, o compilador considera o polígono como uma estrutura dinâmica de dados (ao invés de uma estrutura estática). Isto significa que você é responsável por alocar e lidar com a memória usada por ele. Consulte o tópico Gerenciamento de Memória e a página sobre Polígonos para obter mais informações.

PERCORREDORES

Um "percorredor" é um registro usado para analisar texto. Para entendê-lo, você deve estar confortável com o modo de funcionamento do tipo texto (strings) e subtextos (substrings). Se você não estiver familiarizado com estes termos, procure-os neste glossário e analise as manipulações de texto que fizemos no nosso programa de exemplo.

Eis a definição de "percorredor":

Um percorredor possui
um subtexto original,
uma subtexto fonte e
uma caractere de subtexto.

Eis o que acontece quando o comando abaixo é invocado:

COLOQUE um percorredor em um texto.

O compilador define o subtexto original e o subtexto fonte de forma que eles possam abranger todo o texto. Então ele posiciona o caractere de subtexto no subtexto fonte — o que faz com que o subtexto fonte comece com valorem branco, mas pronto para receber um novo valor. Depois de colocar um percorredor no texto, você pode usar o seguinte comando:

AVANCE um percorredor.

O compilador adiciona um no primeiro byte do subtexto fonte e mais um no último byte do subtexto fonte. Isso faz com que o subtexto fonte fique mais curto enquanto que o caractere de subtexto fica mais longo, permitindo que você processe o texto um byte de cada vez. Quando você quiser limpar o caractere de subtexto antigo e começar um novo, você só precisa utilizar o comando:

POSICIONE o caractere de subtexto do percorredor no subtexto fonte do percorredor.

Você também pode escrever suas próprias rotinas para MOVER um percorredor mais de um byte por vez, assim como acontece nas rotinas de "verificação ortográfica" e de "quebra de linha", sem mencionar as rotinas de análise de código-fonte. Pesquise para mover um percorredor para encontrar os exemplos.

CAIXAS ARREDONDADAS

Uma "caixa arredondada" é uma caixa com cantos arredondados. O compilador usa essas caixas arredondadas no ambiente de trabalho, nos menus, abas e muitos outros lugares. Aqui está a definição:

Uma caixa arredondada é uma caixa que tem 
uma coordenada esquerda, uma coordenada superior, um coordenada direita, uma coordenada inferior,  
um canto superior esquerdo na coordenada esquerda, e um canto inferior direito na coordenada direita e
um raio.

Esta é uma imagem de uma caixa arredondada, com todas as partes acima identificadas. Observe que estou usando os apelidos dos campos aqui, da mesma forma que você provavelmente irá usar em seus programas.

DIREITA ESQUERDA

TOPO

BASE

CANTO SUPERIOR ESQUERDO

CANTO INFERIOR DIREITO

•

RAIO

O compilador consegue fazer caixas arredondadas a partir de especificações de largura e altura, ou apenas usando um par de pontos de coordenadas. O compilador consegue criar uma caixa arredondada até mesmo usando outra caixa como base. O esquema de funcionamento é mostrado abaixo:

FAÇA uma caixa arredondada com tantas polegadas de largura POR tantas polegadas de altura COM um raio de tantas polegadas. FAÇA uma caixa arredondada USANDO esta localização E esta outra localização E este raio. FAÇA uma caixa arredondada USANDO esta coordenada esquerda E esta coordenada superior E esta coordenada direita E esta coordenada inferior E este raio. FAÇA uma caixa arredondada USANDO esta caixa E este raio.

O compilador consegue DESENHAR uma caixa arredondada. Bem como obter a largura, altura o ponto central entre outras coisas. E se um ponto está DENTRO, FORA ou na BORDA da caixa. Sem mencionar todas as Transformações Gráficas de costume.

ROTINAS

Uma rotina é um pedaço de código que manipula uma ou mais variáveis em algumas formas bem definidas. As variáveis passadas para uma rotina são chamadas de "parâmetros", podendo ser apenas parâmetros de entrada, parâmetros de saída ou ambos. As variáveis definidas dentro de uma rotina são chamadas de "variáveis locaos" e não podem ser vistas fora da rotina (a menos que sejam passados como parâmetros). As variáveis que são acessíveis a todas as rotinas são chamadas de "variáveis globais".

Cada rotina tem duas partes, cabeçalho e corpo. O cabeçalho diz o que a rotina faz e define os parâmetros com os quais ele funciona. O corpo contém uma ou mais afirmações que fazem a rotina realmente funcionar. Declarações podem ser "condicionais" ou "imperativas". Existem três tipos de rotinas.

Um "procedimento" é uma rotina que simplesmente faz algo — um procedimento pode ser longo ou curto, grande ou pequeno, fácil ou difícil. Os cabeçalhos de procedimento sempre se parecem com isto:

PARA fazer alguma coisa:

Um "decisor" é uma rotina que diz "sim" ou "não" sobre algo, geralmente depois de examinar os parâmetros passados para ele. Um cabeçalhos de decisão é assim:

PARA DECIDIR SE alguma coisa:

Uma "função" é uma rotina que extrai, calcula ou deriva algo usando uma variável. Cabeçalhos de função assumem este formato:

PARA POR algo QUE FAZ PARTE DE algo EM uma variável temporária:

Ao contrário dos procedimentos e dos decisores, as funções não são normalmente chamadas directamente. Em vez disso, o "algo que faz parte de algo" é utilizado como se fosse um campo em um registro. Como um "centro que está dentro da caixa", que você não encontrará no registro "caixa", porque ele é calculado por uma função automaticamente.

SONS

Você pode reproduzir sons usando comandos como este:

REPRODUZA um arquivo wave.
TOQUE um arquivo wave E AGUARDE.

O "arquivo wave" deve estar no formato ".wav". Se você tocar e não utilizar o comando aguarde/espere, o seu programa continuará sendo executado enquanto o som é reproduzido. Se você utilizar o comando aguarde/espere, o fluxo de execução do seu programa vai parar até que o som tenha terminado de tocar.

Você também pode usar os seguintes comandos:

APITE.
CACAREJE (alerte o usuário).
ASSOVIE (susurre).

O primeiro comando toca o som de erro padrão do Windows. O "cacarejo" é o som de notificação padrão do compilador, codificado em formato hexadecimal no compilador, basta pesquisar por "cluck". O terceiro som é o som de erro da CPU e não permite que o programa continue a ser executado até que termine de ser tocado, tornando-se a escolha ideal para testes. Consulte Depuração para obter mais informações.

Você também pode falar no seu computador, com as trinta e nove funções esotéricas de "gerenciamento de fala" do Windows, ou usando um desses três comandos a seguir:

DIGA um texto.
DIGA um texto E AGUARDE.
AGUARDE ATÉ QUE A FALA TERMINE.

Para silenciar a conversa (mas não os outros sons), ative "a bandeira silenciosa".

IMPERATIVOS ESPECIAIS

Os três "imperativos especiais" do compilador provavelmente estão mais para "imperativos usados para propósitos especiais". Talvez você chegue a usar um deles. Esperamos, em última análise, eliminá-lo completamente. Os outros dois são para nerds.

Um imperativo de "emprego" deve ser a única declaração em uma rotina. Esse tipo de imperativo faz com que o compilador utilize outra rotina no lugar da que foi chamada. Só funciona quando os parâmetros de ambas as rotinas estão na mesma ordem e são do mesmo tipo. Para encontrar exemplos, basta progurar por ": employ". Você pode dar mais de um nome para uma rotina, usando ponto e vírgula no lugar de dois pontos, assim:

PARA limpar a tela; 
PARA apagar a tela; 
Para deixar a tela em branco: 
[código aqui]

Um imperativo "push" avalia uma expressão e coloca o resultado — que deve ser um valor contendo um, dois ou quatro bytes — na pilha do sistema. Você provavelmente não vai precisar usar ele. Nem eu uso isso. Isso é um resquício dos dias em que o comando CHAMAR ainda estava em desenvolvimento (Consulte o tópico Windows para maiores informações sobre esse comando). Só pra você saber, o formato geral do comando é:

PUSH uma expressão.

Um imperativo "Intel" insere código de máquina no seu arquivo executável. É possível encontrar exemplos complexos em vários lugares do compilador. É uma pena que o Intel não é uma máquina de pilha. O formato é trivial:

INTEL nibble literal.

Se você está se perguntando por que razão o compilador não possui um assembler (montador) integrado, a resposta é simplesmente porque não é necessário. Na verdade, há muito pouca linguagem da máquina no meu compilador, e conforme novas funções vão sendo adicionadas, mais e mais desses comandos vão sendo substituídos por português simples. Além disso, um dos princípios dos Mestres da Sociedade Osmosiana é que o melhor assembler sempre foi e sempre será a sua cabeça. É uma forma de manter seu cérebro em dia.

LOCALIZAÇÕES

Uma "localização" ou "posição" ou ainda "ponto na tela" é um dos objetos gráficos mais básicos do compilador. Esta não é bem a melhor definição pra agora vai servir:

Uma localização é um registro que tem uma coordenada x e uma coordenada y.

Esta é uma imagem de uma localização, com as partes acima identificadas. Note que estou usando os apelidos dos campos aqui, como você provavelmente usará em seus programas.

COORDENADA X •

COORDENADA Y •

Localizações são feitas a partir de um x e um y, ou você pode obter uma de outro lugar:

FAÇA uma localização USANDO isto E aquilo. ARMAZENE a posição do mouse EM uma localização.

O compilador consegue DESENHAR uma localização. Mas não espere que seja rápido o suficiente para ser útil. O processamento de vídeo do Windows é uma das suas piores características. E já que ele só oferece recursos ruins, isso não é lá muito encorajador.

Posições são usadas principalmente como componentes de outros objetos gráficos. Como caixas, linhas, vértices e polígonos. Às vezes, elas são usados como coordenadas abstratas sem representação visível, como "a localização do mouse" no exemplo acima. Consulte a página "Unidades de medida" para uma discussão completa sobre coordenadas.

O compilador possui rotinas que podem identificar se uma localização ESTÁ DENTRO ou NA BORDA de qualquer outro objeto gráfico (na borda significa em cima). Quando você vê se algo está DENTRO, isso inclui as bordas. As rotinas que identificam se algo está na borda são usadas pelo caderno e incluem uma margem de erro de 3 pixels para ficar mais fácil de clicar nas formas. Você pode copiar essas rotinas e retirar essas margens de tolerância, se quiser.

TEXTO

O compilador armazena "strings" em duas partes: um registro integrado que contém dois ponteiros de byte. O primeiro e o último. Além de armzenar os bytes de cada letra, assim:

16 27 H E L L O W O R L D!

primeiro último 161718192021222324252627

Os números do diagrama, caso você não tenha percebido, são apenas endereços fictícios. Um texto está em branco se o primeiro ponteiro de byte estiver vazio (sem memória alocada nele ainda), ou se o último ponteiro de byte for menor que o primeiro (o que permite a pré-alocação de memória). Observeque mesmo que a parte de dados de um texto seja dinamicamente alocada, você nunca tem que criar ou destruir a string. O compilador toma conta de tudo isso, assim você pode usar comandos como:

COLOQUE algo EM um texto. ADICIONE algo NO FINAL DE um texto ADICIONE algo A um texto ANTES de um byte#. REMOVA O PRIMEIRO BYTE DE um texto. REMOVA O ÚLTIMOO BYTE DE um texto. PREENCHA um texto USANDO um byte A PARTIR DE uma contagem<.code> REMOVA OS BYTES INICIAIS DE um texto USANDO uma contagem. REMOVA OS BYTES FINAIS DE um texto USANDO uma contagem. REMOVA OS BYTES DE um texto USANDO um subtexto.`

Você também pode COLOCAR TODO O TEXTO EM LETRAS MAIÚSCULAS, MINÚSCULAS, ou COLOCAR APENAS O PRIMEIRO BYTE EM LETRAS MAIÚSCULAS. Além de obter o COMPRIMENTO de um texto, em bytes. Sem mencionar o comando:

OBTENHA uma largura USANDO um texto E uma fonte.

Além disso, você pode concatenar (unir, juntar) um texto com outro — ou com outros tipos de dados — usando os operadores ENTÃO, EM SEGUIDA ou JUNTO COM . Consulte o tópico "Expressões" para uma descrição da implementação dessa rotina.

SUBTEXTO

Uma "substring" ou subtexto faz parte de um texto. Subtextos são implementadoss através um registro embutido que se parece como um texto — um subtexto tem um par de ponteiros de bytes chamado primeiro e último — o que os torna compatíveis com o texto. Se, por exemplo, isso fosse um texto:

16 27 H E L L O W O R L D!

primeiro último 161718192021222324252627

Isto poderia ser um subtexto (a parte "WORLD"):

22 26

primeiro último

Você pode usar o comando abaixo:

COLOQUE um subtexto EM um texto.

Para fazer com que o compilador defina o primeiro byte do subtexto e o último byte do subtexto abarquem completamente o texto. Isso permite que você consiga avançar ou retroceder dentro do texto ao adicionar algo ao primeiro byte ou removendo algum item do último byte. Você também pode usar o comando:

POSICIONE um subtexto EM um texto.

O que define o primeiro byte, mas não o último byte, do subtexto, deixando-o inicialmente em branco mas pronto para manipulação — ao adicionar o pultimo byte você pode "adicionar" o texto original no seu subtexto um byte por vez.

Procure por "subtexto" no código fonte para obter exemplos.

No entanto, o uso principal dos subtextos ocorre nos "percorredores", que são discutidos no neste glossário sob o tópico de mesmo nome.

TERMOS

Um "termo" é uma referência a um pedaço de dados. Os termos são usados tanto em expressões quanto em instruções condicionais e imperativas para indicar o que deve ser operado. Os termos têm muitas variedades:

Um "termo literal" é um número, proporção, combinação, texto, ponteiro, bandeira ou um nibble literal. Consulte "Literais" para informações sobre como formular cada um deles.

Um "termo local" é uma variável definida dentro de uma rotina e que geralmente fica confinado dentro dela. Consulte "Variáveis Locais" para obter mais informações.

Um "termo global" é o nome de uma variável global. Consulte "Variáveis globais".

Um "termo sinalizado" (assinalado) é qualquer termo com um sinal de mais ou menos na frente dele. Um espaço é necessário após o sinal, para que o compilador não a confunda com a parte de um nome.

O "termo de proporção" é uma proporção feita a partir de outros termos, ao invés de números literais. Espaços são necessários ao redor da barra, como em "um valor de altura / um valor de largura".

Um "termo possessivo" é qualquer termo seguido por uma frase possessiva, como "o comprimento de dentro do texto" ou "magnitude que faz parte do polígono". Consulte a seção "Possessivos" para mais detalhes.

Um "termo coagido" é um termo cujo tipo você deseja mudar à força. O compilador sempre tratará um ponteiro, por exemplo, como um ponteiro — a menos que você coaga-o a ser outra coisa, como neste exemplo: "o ponteiro COMO UM NÚMERO". Normalmente você não vai precisar deste recurso, a menos que você seja uma pessoa que ama objetos e tenha definido um monte de coisas que são extensões de outras coisas.

Agora sei que isto parece complicado, e realmente é. Mas você não precisa pensar sobre nada disso, assim como você não precisa pensar em substantivos e verbos para falar português apropriadamente. Digite o que você está pensando e deixe o compilador tentar fazer o resto.

O CAMPO DE TEXTO

Existe um componente chamado "campo de texto". Ele é utilizado para implementar campos editáveis de texto, sejam eles grandes ou pequenos. Diálogos, por exemplo. Ou formas de texto em páginas. O editor de código, na verdade, é na maior parte apenas uma grande caixa de texto. Eis a definição:

Um campo de texto é algo com
uma caixa, uma origem,
uma cor de caneta, uma fonte, um alinhamento,
algumas linhas,
uma margem,
uma proporção de escala,
uma bandeira de embrulho,
uma bandeira de rolagem horizontal,
uma bandeira de rolagem vertical,
uma seleção,
uma bandeira modificada,
uma última operação,
alguns textos chamados desfazimentos, e
alguns textos chamados refazimentos.

Como você pode ver, esta não é uma definição trivial. Felizmente o compilador lida com a paior parte dos detalhes ra você. Normalmente, você não fará muito mais do que usar os seguintes comandos:

CRIE um campo de texto. DESENHE um campo de texto. DESTRUA um campo de texto.

Você deve inicializar a caixa do campo de texto, a caneta, a fonte, o alinhamento, a margem e as bandeiras depois de criá-lo. E você terá que passar todos os eventos relacionados à sua caixa de texto para o compilador, obviamente, para que ele possa cuidar de todas as coisas difíceis para você. Os manipuladores de eventos do campo de texto estão documentados nas duas páginas a seguir.

GERENCIADORES DE CAMPOS DE TEXTO

Conforme dito na página anterior, o compilador gerencia a maior parte dos eventos ou comandos que são enviados ao campo de texto, desde que você use os comandos apropriados:

GERENCIE um evento USANDO um campo de texto (tecla backspace). GERENCIE um evento USANDO um campo de texto (tecla delete). GERENCIE um evento USANDO um campo de texto (tecla seta para baixo). GERENCIE um evento USANDO um campo de texto (tecla end). GERENCIE um evento USANDO um campo de texto (tecla enter). GERENCIE um evento USANDO um campo de texto (tecla esc). GERENCIE um evento USANDO um campo de texto (tecla home). GERENCIE um evento USANDO um campo de texto (clique duplo). GERENCIE um evento USANDO um campo de texto (seta esquerda). GERENCIE um evento USANDO um campo de texto (tecla page down). GERENCIE um evento USANDO um campo de texto (tecla page up). GERENCIE um evento USANDO um campo de texto (tecla imprimível). GERENCIE um evento USANDO um campo de texto (seta direita). GERENCIE um evento USANDO um campo de texto (tecla tab). GERENCIE um evento USANDO um campo de texto (seta para cima).

Eu sei que pode parecer um incômodo despachar todos estes eventos separadamente, mas é exatamente isso o que torna o campo de texto geralmente útil. Por exemplo:

Se você tiver uma caixa de texto com apenas uma linha, provavelmente vai querer ignorar e as teclas de seta para cima e para baixo, enquanto que se você usar caixas de texto com várias linhas você vai querer utilizar essas teclas para mover o cursor de texto.

Se você estiver usando uma caixa de texto como uma caixa de diálogo, você provavelmente cancelará a operação quando a tecla Esc for pressionada, bem como você irá querer executar a operação ao pressionar a tecla Enter. Em um campo de texto normal, provavelmente você utilizará a tecla Enter para inserir uma quebra de linha por exemplo.

Entendeu o que eu quis dizer? Você está no comando. Portanto, é você que tem que emitir as ordens.

CONTINUAÇÃO

O compilador também gerencia de uma série de outras operações de texto de alto nível para você:

RECORTE O TEXTO DE um campo de texto. COPIE O TEXTO DE um campo de texto. COLE O TEXTO DE um campo de texto.

SELECIONE TODO O TEXTO DE um campo de texto.

GERENCIE A ALTURA DA FONTE usando um campo de texto e um valor de altura de fonte. GERENCIE O NOME DA FONTE usando um campo de texto e um nome de fonte.

GERENCIE A COR DO TEXTO usando um campo de texto e uma cor.

GERENCIE O RECUO DO TEXTO usando um campo de texto. GERENCIE O AVANÇO DO TEXTO usando um campo de texto.

TRANSFORME O TEXTO DE um campo de texto EM LETRAS MAIÚSCULAS. TRANSFORME O TEXTO DE um campo de texto EM LETRAS MINÚSCULAS.

Ou, se você preferir:

DESFAÇA A OPERAÇÃO EM um campo de texto. REFAÇA A OPERAÇÃO EM um campo de texto.

Você sempre pode usar os comandos acima. O máximo de vezes que você pode desfazer ou refazer uma operação é de 32.

Se você quiser ter uma noção boa de como funciona o campo de texto, eu sugiro que você experimente o "console" por um tempo. e então confira o código fonte do console. Depois disso, você pode querer dar uma olhada no editor de código. Mas se você realmente quer ver o campo texto em ação, dê uma olhada no caderno. Finalmente, gaste alguns minutos com as caixas de diálogo no ambiente de trabalho.

COISAS

Uma das palavras mais imporantes do compilador é a palavra "coisa". Sempre que o compilador lê a palavra coisa, ele cria um registro especial de tamanho dinâmico, além de criar um registro especial de lista encadeada, assim você pode criar uma lista de coisas. No nosso programa de exemplo, usamos o seguinte comando:

Uma obra de arte é uma coisa que tem uma URL e uma pintura.

Mas a definição pode ser expandida para ficar assim:

Uma obra de arte é um ponteiro para um registro de obra de arte. Uma registro de obra de arte é um registro que tem uma próxima obra de arte, uma URL e uma pintura. Algumas obras de arte são algumas coisas que têm uma primeira obra de arte e uma última obra de arte.

Obviamente você não sabia disso. De qualquer forma, isso permite que você utilize os comandos:

ADICIONE uma coisa NO FINAL de algumas coisas. ADICIONE algumas coisas NO FINAL de outras coisas. INSIRA uma coisa DEPOIS de outra coisa DENTRO DE algumas coisas. INSIRA uma coisa ANTES de outra coisa DENTRO DE algumas coisas. INSIRA algumas coisas DEPOIS de outras coisas DENTRO DE uma coisa. INSIRA algumas coisas ANTES de outras coisas DENTRO DE uma coisa. MOVA uma coisa DE algumas coisas PARA outras coisas. MOVA algumas coisas PARA outras coisas. ADICIONE uma coisa NO INÍCIO de algumas coisas. ADICIONE algumas coisas NO INÍCIO de outras coisas. REMOVA uma coisa DE outras coisas. INVERTA algumas coisas.

Existe também uma função que permite que você "coloque a quantidade de algumas coisas" em uma contagem. Tudo o que você precisa lembrar é de CRIAR e DESTRUIR cada uma de suas coisas. Consulte "Gerenciamento de memória" para mais informações.

TEMPORIZADORES

Um tique dura aproximadamente 1 milissegundo. "A contagem de tiques do sistema" é o número de milissegundos desde a última reinicialização. Ele reseta a cada 24,8 dias aproximadamente. O que se passa nessa altura é desconhecido,já que nenhum Windows ficou tanto tempo ligado sem dar pau.

Quando quiser, você pode:

AGUARDAR tantos milissegundos.

O compilador também entende unidades maiores como "minutos" ou "segundos".

O compilador possui uma variável chamada de temporizador que permite que você utilize os seguintes comandos:

ZERE o temporizador.
REINICIE um temporizador.
INICIE um temporizador.
PARE um temporizador.

REINICIE um temporizador.
INICIE um temporizador.
PARE um temporizador.
```
O compilador utiliza esses cronômetros para verificar o tempo de recompilação, por exemplo (que atualmente é cerca de 3 segundos, dependendo do hardware).
Procure a seção `listagem` para ver todos os temporizadores. Você pode usá-los para tornar seus programas mais rápidos.

Os tempos podem ser cronometrados simplesmente inserindo os comandos `inicie um temporizador` e `pare o temporizador` nos pontos apropriados no seu código.

Tempos cumulativos podem ser acumulados usando o comando `zerar` uma vez e `reiniciar` logo em seguida juntamente com o comando "parar".

Existe uma função no compilador que permite que você obtenha o texto de um temporizador a qualquer momento — mesmo durante sua execução. Você também pode utilizar as operações de concatenação de strings neles.

## TIPOS

Um "tipo" é uma categoria ou espécie de coisa — um substantivo. Uma "instância" é uma coisa real de um tipo específico — um substantivo próprio. Globais, locais e parâmetros são instâncias concretas de tipos abstratos. Isso é o que o compilador entende sobre tipos:

Em primeiro lugar, existem seis tipos "embutidos" primitivos no meu compilador: BYTE, WYRD, NUMBER, POINTER, FLAG e RECORD. Consulte "Tipos Integrados".

Em seguida, há "subconjunto de tipos" que representam algumas das instâncias de algum outro tipo. O compilador, por exemplo, inclui muitos tipos de subconjunto, como estes:

```
Um número é contador.
Um nome é um texto.
```

Em terceiro lugar, o compilador reconhece "tipos de unidade de medida". Assim ele pode converter um tipo de unidade em outro. Exemplos:

```
Um pé tem 12 polegadas.
Uma hora é 60 minutos.
```

O compilador também entende tipos de "registro". Consulte a seção `Registros` para mais detalhes.

E não vamos nos esquecer dos "tipos de ponteiro", embora você raramente precise usá-los diretamente. O compilador sabe, por exemplo, que "um ponteiro de bytes é um ponteiro para um byte" e ele uso ponteiros de bytes para gerenciar suas strings. Consulte `Strings`, `Substrings`, `Percorredores`, e `Possessivos` para obter mais informações.

Por último, o compilador reconhece todos os tipos de "coisa". Existem várias no compilador, incluindo console, evento, imagem, polígono e vértice, todas elas são discutidas em outros lugares neste glossário. E também pode definir as suas próprias coisas. Consulte o tópico sobre `Coisas`, e tente se lembrar das "obras de arte" do programa de exemplo.

## UNIDADES DA MEDIDA

A unidade de medida básica para objetos gráficos é a "twip", que é 1/20 de um ponto de impressora, ou 1/1440 de uma polegada. Todas as coordenadas são expressas diretamente em twips, ou são convertidas para twips. Eis a definição:

`Um coordenada é alguns twips.`

Agora, ao contrário do modelo matemático — que considera coordenadas como invisíveis abstrações indimensionadas — o modelo do compilador entende coordenadas como pontos reais em um dispositivo, como uma tela ou uma página. Valores grande de x e y vão além da tela ou página. Aqui, por exemplo temos uma caixa com o canto superior esquerdo em `2-1` e inferior direito, em `5-3`:

0 1 2 3 4 5

0 1 2 3 4 5 6 7

· · · · · · · ·

Conte os pontos e note que a largura desta caixa é de quatro, não três, unidades. E que são três, e não duas unidades de altura. Medir desta forma faz com que o compilador desenhe bem — outra caixa entre `5-1` e `6-3`, por exemplo, irá sobrepor corretamente esta caixa ao longo de sua borda esquerda. No entanto, você pode obter a largura e a altura desta caixa na forma "matemática" — que correspondem, cada uma, a uma unidade a menos, e são inúteis para desenho. Use as funções X-EXTENT e Y-EXTENT.

Outras unidades de medida que você vai encontrar são: milissegundos, segundos, minutos e horas; polegadas e pés; kilobytes, megabytes, e gigabytes; e "porcento", que geralmente é convertido para uma proporção com 100 no denominador.

# Índice

## ÍNDICE

```
alt-tab, 5, 21, 23, 56 
aritmética, 11, 57, 59, 74, 85 
artigo, 11, 20, 80, 85 
ascii, 58 
at, 75 
habilidade básicas, 59 
bits, 60 
caixas, 61 
interrompa, 11, 82, 91 
tipos integrados, 62 
byte, 58, 62 call, 82, 86 
o comando chamado, 11, 75, 85 
quadro da tela, 24, 25 
cores, 28, 63 
comentários, 18, 19, 56, 64 
compativelmente, 86 
compiler, 4, 9 
conditionais, 11, 56, 65, 100 
conjunções, 11, 85 
console, 66 
contrações, 68, 85 
coordenatas, 118 
cursor, 5, 22, 37, 39, 44, 72, 80, 83 
depuração, 67 
decisores, 11, 68, 69, 91, 105 
artigos definidos, 11, 80 
o ambiente de trabalho, 4, 5 
pasta, 6, 15, 56 
documento, 6 
desenhar, 24, 25, 70 
dump, 6 
editor, 4, 7 
elipse, 71 
emprego, 82, 107 
igual, 11, 85 
equações, 12 
esc, 6, 7 
eventos, 17, 20, 22, 72, 73 
exe, 9, 56 exit, 11, 68, 82, 91 
expressões, 11, 57, 59, 74, 85 
campos, 75, 98 
arquivos, 76, 77 
localizador, 4, 6
localizando, 7
flags, 62, 85, 89
flicker, 24
fontes, 78
fórmulas, 12
funções, 79, 105
globais, 11, 56, 80
Deus, em todo lugar
gráficos, 81
se, 11, 65, 68
imperativos, 11, 56, 82, 100
artigo indefinido, 11, 90, 95
infix operators, 11, 57, 59, 74, 85
instalação, 4
intel, 82, 107
interface, 5, 14
internet, 40, 45, 84
teclado, 38-39, 83
palavras chave, 85
Windows, 4, 16, 82, 86
matrizes, 12, 97
linhas, 87
listas, 88
literais, 11, 89
variáveis locais, 90
loops, 11, 21, 82, 91
magnitude, 98
máscara (fita crepe), 92
memória, 26, 27, 93
mouse, 83
nomes, 11, 94
palavras negativas, 68, 85
aninhamento de se, 12, 65
aninhamento de loops, 12, 91
nibbles, 89, 107
nil, 62, 85, 89
o cérebro, 4, 9, 10, 56
números, 62, 89
objetos, 12
parâmetros, 95
imagens, 96
ponto, 86
ponteiro, 62, 82, 89
polígonos, 97
possessivos, 98
preposições, 11, 85
imprimindo, 53, 99
privatize, 49, 82, 95
procedimentos, 100, 105
projetos, 15, 56
pontuação, 11
push, 82, 108
qualificadores, 19
encerrando, 23, 27, 73
números aleatórios, 101
razões e proporções, 57, 89
números reais, 12
registros, 62, 75, 102
referência, 75, 93
atualização de tela, 24, 25, 70, 72, 83
observações, 18, 19, 56, 64
repetições, 11, 82, 91
percorredores, 46, 48, 103
caxas arredondadas, 104
rotinas, 11, 56, 100, 105
executando, 9, 16, 73
diga, 11, 68, 91
tela, 24, 25, 83
atalhos, 5, 23
ordenação classificação, 17
souns, 106
código fonte, 56
fala, 106
pontos na tela, localizações, posições, 87, 108
parando, 21
strings, 27, 89, 109
substrings, 110
alvo, 98
termos, 111
arquivos de texo, 6, 15, 56
campos de texto, 36-37, 112-114
coisas, 41, 115
temporizadores, 116
tipos, 11, 56, 117
unidades de medida, 118
verbos, 11, 68, 85
esvaziar, 62, 89
paradeiro, 98
caderno (writer), 4, 8
wyrd, 62
```

A Ordem Osmosiana de Programadores

http://www.osmosian.com

3. Glossário Explicativo de Termos e Definições

VISÃO GERAL

ARITMÉTICA

TABELA ASCII

Caracteres de controle ASCII (código de caractere 0-31)

Caracteres imprimíveis ASCII (código de caractere 32-127)

Tabela de códigos ASCII extendida (código de caractere 128-255)

HABILIDADES BÁSICAS

BITS

CAIXAS

TIPOS PREDEFINIDOS/EMBUTIDOS

CORES

COMENTÁRIOS

CONDIÇÕES

O CONSOLE

CONSERTANDO FALHAS E ERROS

DECISORES

LISTA DE DECISORES DISPONÍVEIS NO SISTEMA

DESENHANDO

ELIPSES

EVENTOS/COMANDOS RECEBIDOS PELO SISTEMA

PROGRAMAÇÃO ORIENTADA A EVENTOS

EXPRESSÕES

CAMPOS

ARQUIVOS

ARQUIVOS (continuação)

FONTES

FUNÇÕES

VARIÁVEIS GLOBAIS

TRANSFORMAÇÕES GRÁFICAS

IMPERATIVOS

FLUXO PADRÃO DE ENTRADA E SAÍDA

INTERNET

PALAVRAS-CHAVE

O WINDOWS

LINHAS

LISTAGEM

LITERAIS

VARIÁVEIS LOCAIS

LAÇOS

FITA CREPE

GERENCIAMENTO DE MEMÓRIA

NOMES

PARÂMETROS

IMAGENS

POLÍGONOS

POSSESSIVOS

IMPRIMINDO

PROCEDIMENTOS

NÚMEROS ALEATÓRIOS

REGISTROS

PERCORREDORES

CAIXAS ARREDONDADAS

ROTINAS

SONS

IMPERATIVOS ESPECIAIS

LOCALIZAÇÕES

TEXTO

SUBTEXTO

TERMOS

O CAMPO DE TEXTO

GERENCIADORES DE CAMPOS DE TEXTO

CONTINUAÇÃO

COISAS

TEMPORIZADORES

Clone this wiki locally