MULTIPLICANDO DOIS INTEIROS
registrador A (acumulador - ACC)
registrador B (valor fixo)
registrador C (contador decrescente - variável de controle)
registrador Z (indicador de resultado zero - FLAG ZR do PSW:ProgramStatusWord)
Sub-rotina em linguagem de montador (ASSEMBLY) para multiplicar 2 inteiros - etapas:
a) Inicialização das variáveis
b) Somar o valor de B com o de A e gravar o resultado em A
c) Decrementar C
Se a atualização de Z não fosse automática, o próximo passo seria atualizar Z segundo o resultado em C
d) Pular para f) se Z indicar condição zero
e) Pular para b)
f) Voltar à rotina chamadora externa (RET)
Outra alternativa seria:
a)...
b)...
c)...
d) Pular para b) se Z indicar condição diferente de zero
e) Voltar à rotina chamadora externa (RET)
Supondo que cada instrução ocupa uma posição de memória, o seguinte exemplo genérico de sub-rotina
multiplica o valor m por n deixando o resultado no acumulador
00 MOV B, m ;carregar B com o valor fixo, no caso, com o valor m
01 MOV C, n ;carregar C com o valor inicial da variável de controle, no caso, com o valor n
02 MOV A, 0 ;zerar o acumulador
03 ADD A, B ;somar B com A deixando o resultado em A
04 DEC C ;subtrair 1 do valor em C
05 JZ 07 ;pular para fora da sub-rotina se já foram somadas n parcelas m
06 JMP 03 ;voltar ao ínicio do laço da sub-rotina se ainda não foram somadas n parcelas m
07 RET ;retornar à rotina chamadora externa
ou
00 MOV B, m ;carregar B com o valor fixo, no caso, com o valor m
01 MOV C, n ;carregar C com o valor inicial da variável de controle, no caso, com o valor n
02 MOV A, 0 ;zerar o acumulador
03 ADD A, B ;somar B com A deixando o resultado em A
04 DEC C ;subtrair 1 do valor em C
05 JNZ 03 ;voltar ao ínicio do laço da sub-rotina se ainda não foram somadas n parcelas m
06 RET ;retornar à rotina chamadora externa, já que foram somadas n parcelas m
Exemplo numérico - multiplicar 13 por 7 deixando o resultado no acumulador
00 MOV B, 13 ;carregar B com o valor fixo, no caso, com o valor 13
01 MOV C, 7 ;carregar C com o valor inicial da variável de controle, no caso, com o valor 7
02 MOV A, 0 ;zerar o acumulador
03 ADD A, B ;somar B com A deixando o resultado em A
04 DEC C ;subtrair 1 do valor em C
05 JNZ 03 ;voltar ao ínicio do laço da sub-rotina se ainda não foram somadas 7 parcelas 13
06 RET ;retornar à rotina chamadora externa, já que foram somadas 7 parcelas 13
Se x e y representassem ENDEREÇOS de memória para os valores m e n,
00 MOV [x], m ;carregar a célula x com o valor fixo, no caso, com o valor m
01 MOV [y], n ;carregar a célula y com o valor inicial da variável de controle, no caso, com o valor n
02 MOV B, [x] ;carregar B com o valor que está na célula de memória x
03 MOV C, [y] ;carregar C com o valor que está na célula de memória y
04 MOV A, 0 ;zerar o acumulador
05 ADD A, B ;somar B com A deixando o resultado em A
06 DEC C ;subtrair 1 do valor em C
07 JZ 09 ;pular para fora da sub-rotina se já foram somadas y parcelas x
08 JMP 05 ;voltar ao ínicio do laço da sub-rotina se ainda não foram somadas y parcelas x
09 RET ;retornar à rotina chamadora externa
Exemplo numérico - multiplicar 13 por 7 deixando o resultado no acumulador
00 MOV [x], 13 ;carregar a célula x com o valor fixo, no caso, com o valor 13
01 MOV [y], 7 ;carregar a célula y com o valor inicial da variável de controle, no caso, com o valor 7
02 MOV B, [x] ;carregar B com o valor que está na célula de memória x, no caso, com o valor 13
03 MOV C, [y] ;carregar C com o valor que está na célula de memória y, no caso, com o valor 7
04 MOV A, 0 ;zerar o acumulador
05 ADD A, B ;somar B com A deixando o resultado em A
06 DEC C ;subtrair 1 do valor em C
07 JZ 09 ;pular para fora da sub-rotina se já foram somadas y parcelas x
08 JMP 05 ;voltar ao ínicio do laço da sub-rotina se ainda não foram somadas y parcelas x
09 RET ;retornar à rotina chamadora externa
(ATENÇÃO! o flag ZR=1 significa SIM, 'resultado zero' e ZR=0 significa NÃO, 'resultado não-zero')
Conhecendo as funções dos registradores da CPU (IP, RI, PSW-ZR, ACC, etc.),
dos barramentos (ENDEREÇOS, DADOS, CONTROLE) e das células de memória, temos,
no ciclo BUSCA-ATUALIZA-EXECUTA-BUSCA-ATUALIZA-EXECUTA-etc.:
00 MOV B, 13 ;carregar B com o valor fixo, no caso, com o valor 13
01 MOV C, 7 ;carregar C com o valor inicial da variável de controle, no caso, com o valor 7
02 MOV A, 0 ;zerar o acumulador
03 ADD A, B ;somar B com A deixando o resultado em A
04 DEC C ;subtrair 1 do valor em C
05 JNZ 03 ;voltar ao ínicio do laço da sub-rotina se ainda não foram somadas 7 parcelas 13
06 RET ;retornar à rotina chamadora externa, já que foram somadas 7 parcelas 13
.IP:00 ZR:? RI:? A:? B:? C:?
. RI:/MOV B, 13/ busca instrução no endereço 00 e a coloca em RI
.IP:01 atualiza IP para 01 & decodifica instrução em RI
. B:13 executa instrução decodificada
. RI:/MOV C, 7/ busca instrução no endereço 01 e a coloca em RI
.IP:02 atualiza IP para 02 & decodifica instrução em RI
. C:7 executa instrução decodificada
. RI:/MOV A, 0/ busca instrução no endereço 02 e a coloca em RI
.IP:03 atualiza IP para 03 & decodifica instrução em RI
. A:0 executa instrução decodificada
. RI:/ADD A, B/ busca instrução no endereço 03 e a coloca em RI
.IP:04 atualiza IP para 04 & decodifica instrução em RI
. A:13 executa instrução decodificada
. RI:/DEC C/ busca instrução no endereço 04 e a coloca em RI
.IP:05 atualiza IP para 05 & decodifica instrução em RI
. ZR:0 C:6 executa instrução decodificada
. RI:/JNZ 03/ busca instrução no endereço 05 e a coloca em RI
.IP:06 atualiza IP para 06 & decodifica instrução em RI
.IP:03 executa instrução decodificada
. RI:/ADD A, B/ busca instrução no endereço 03 e a coloca em RI
.IP:04 atualiza IP para 04 & decodifica instrução em RI
. A:26 executa instrução decodificada
. RI:/DEC C/ busca instrução no endereço 04 e a coloca em RI
.IP:05 atualiza IP para 05 & decodifica instrução em RI
. ZR:0 C:5 executa instrução decodificada
. RI:/JNZ 03/ busca instrução no endereço 05 e a coloca em RI
.IP:06 atualiza IP para 06 & decodifica instrução em RI
.IP:03 executa instrução decodificada
. RI:/ADD A, B/ busca instrução no endereço 03 e a coloca em RI
.IP:04 atualiza IP para 04 & decodifica instrução em RI
. A:39 executa instrução decodificada
. RI:/DEC C/ busca instrução no endereço 04 e a coloca em RI
.IP:05 atualiza IP para 05 & decodifica instrução em RI
. ZR:0 C:4 executa instrução decodificada
. RI:/JNZ 03/ busca instrução no endereço 05 e a coloca em RI
.IP:06 atualiza IP para 06 & decodifica instrução em RI
.IP:03 executa instrução decodificada
. RI:/ADD A, B/ busca instrução no endereço 03 e a coloca em RI
.IP:04 atualiza IP para 04 & decodifica instrução em RI
. A:52 executa instrução decodificada
. RI:/DEC C/ busca instrução no endereço 04 e a coloca em RI
.IP:05 atualiza IP para 05 & decodifica instrução em RI
. ZR:0 C:3 executa instrução decodificada
. RI:/JNZ 03/ busca instrução no endereço 05 e a coloca em RI
.IP:06 atualiza IP para 06 & decodifica instrução em RI
.IP:03 executa instrução decodificada
. RI:/ADD A, B/ busca instrução no endereço 03 e a coloca em RI
.IP:04 atualiza IP para 04 & decodifica instrução em RI
. A:65 executa instrução decodificada
. RI:/DEC C/ busca instrução no endereço 04 e a coloca em RI
.IP:05 atualiza IP para 05 & decodifica instrução em RI
. ZR:0 C:2 executa instrução decodificada
. RI:/JNZ 03/ busca instrução no endereço 05 e a coloca em RI
.IP:06 atualiza IP para 06 & decodifica instrução em RI
.IP:03 executa instrução decodificada
. RI:/ADD A, B/ busca instrução no endereço 03 e a coloca em RI
.IP:04 atualiza IP para 04 & decodifica instrução em RI
. A:78 executa instrução decodificada
. RI:/DEC C/ busca instrução no endereço 04 e a coloca em RI
.IP:05 atualiza IP para 05 & decodifica instrução em RI
. ZR:0 C:1 executa instrução decodificada
. RI:/JNZ 03/ busca instrução no endereço 05 e a coloca em RI
.IP:06 atualiza IP para 06 & decodifica instrução em RI
.IP:03 executa instrução decodificada
. RI:/ADD A, B/ busca instrução no endereço 03 e a coloca em RI
.IP:04 atualiza IP para 04 & decodifica instrução em RI
. A:91 executa instrução decodificada
. RI:/DEC C/ busca instrução no endereço 04 e a coloca em RI
.IP:05 atualiza IP para 05 & decodifica instrução em RI
. ZR:1 C:0 executa instrução decodificada
. RI:/JNZ 03/ busca instrução no endereço 05 e a coloca em RI
.IP:06 atualiza IP para 06 & decodifica instrução em RI
. executa instrução decodificada
. RI:/RET/ busca instrução no endereço 06 e a coloca em RI
.IP:07 atualiza IP para 07 & decodifica instrução em RI
.IP:nn executa instrução decodificada
INSTALANDO COMPILADORES PARA OS EXERCÍCIOS
Máquinas Windows (para Mac-OSX e Linux, use o gcc - Gnu C Compiler - e o gpc - Gnu Pascal Compiler - diretamente na linha de comando)
Compilador Pascal (Dev-Pascal programa livre - GPL)
http://www.bloodshed.net/dev/devpas192.exe
Compilador C/C++ (Dev-C++ programa livre - GPL-3)
https://sourceforge.net/projects/orwelldevcpp/files/latest/download
Baixe e instale os compiladores dev-c e dev-pas nos locais (diretórios) que o programa instalador sugerir.
Siga as orientações do instalador e não altere as opções (default) sugeridas.
Crie um diretório (pasta) de trabalho sob o diretório raiz (p.ex.: C:\SI2011 Windows, ou sob seu diretório Linux /home/seu_login/SI2011).
Digitar no bloco de notas (notepad) ou qualquer editor de texto simples (em Linux, 'nano', 'gedit', 'Emacs')
e salvar como exemploc.c no diretorio de trabalho o seguinte texto (PROGRAMA escrito em C):
int main(){printf("Programa C COMPILADO e EXECUTADO\n");return 0;}
Digitar no bloco de notas (notepad) ou qualquer editor de texto simples (em Linux, 'nano', 'gedit', 'Emacs')
e salvar como exemplop.pas no diretorio de trabalho o seguinte texto(PROGRAMA escrito em PASCAL):
Program a;begin Writeln('Programa Pascal COMPILADO e EXECUTADO') end.
ATENCAO PARA AS ASPAS DUPLAS OU SIMPLES, segundo o caso.
Compilacao atraves da interface grafica (Windows GUI):
Os arquivos-fonte exemplop.pas e exemploc.c devem ser abertos com dev-pascal e dev-c, respectivamente
(se dev-pascal e dev-c estiverem instalados, basta clicar nos arquivos-fonte respectivos, e o ambiente
vai abrir com uma janela contendo o fonte).
Com o texto na janela do ambiente, acione a opcao COMPILE do menu EXECUTE. O seu diretorio de trabalho
(verifique a pasta de trabalho) deve conter agora, alem dos arquivos-fonte, os executaveis, no caso:
exemploc.exe e exemplop.exe. Esses executaveis nao realizam qualquer tarefa util, a nao ser indicar que os compiladores funcionaram.
Teste de execucao atraves da interface grafica (Windows GUI):
Ao ser clicado exemploc.exe ou exemplop.exe, o sistema responde com a abertura e o fechamento rapido de uma janela preta (janela de terminal).
A janela se abre por um tempo demasiado curto para que se possa ler alguma coisa nela.
Se nao foi este o seu resultado, anote as mensagens e descreva detalhadamente o que aconteceu.
Teste de execucao atraves do prompt de linha de comando (Command prompt):
Abra o prompt de linha de comando do Windows (tela preta, command prompt, janela de terminal).
Ha muitas maneiras de se fazer isso. Por exemplo:
.clicar INICIAR (START) > EXECUTAR (RUN)
e digitar (para W7, VISTA, XP, W2000): CMD
ou digitar (para W95, W98, ME): COMMAND
.ou clicar no icone (por exemplo, no W98 versao em portugues)
INICIAR > PROGRAMAS > PROMPT_MSDOS
.ou clicar no icone (por exemplo, no XP versao em ingles)
START > ALL_PROGRAMS > ACCESSORIES > COMMAND_PROMPT
Navegue para o seu diretorio de trabalho que voce criou (C:\SI2011), digitando no prompt:
CD C:\SI2011
Para executar o programa Pascal compilado, digite:
exemplop.exe (ou apenas: exemplop).
Para executar o programa C compilado, digite:
exemploc.exe (ou apenas: exemploc).
Agora voce deve poder ler na tela os textos produzidos pelo codigo de cada programa. Se nao foi este o
seu resultado, anote as mensagens e descreva detalhadamente o que aconteceu.
Compilacao atraves do prompt de linha de comando (janela terminal):
Numa instalacao padrao, gcc.exe (arquivo executavel do compilador C) deve estar no caminho C:\DEV-CPP\BIN\ ,
e fpc.exe (arquivo executavel do compilador Pascal) deve estar no caminho C:\PP\BIN\WIN32. Se nao estiverem,
procure (menu LOCALIZAR, ou SEARCH do Windows) o diretorio (pasta) onde se encontra o executavel de cada
compilador (gcc.exe, para o C; fpc.exe para o PASCAL) e anote os caminhos.
Para compilar os fontes (em C e em Pascal) que voce salvou na sua pasta de trabalho, eh necessario que
o sistema operacional possa localizar os arquivos executaveis dos compiladores.
Para indicar ao sistema operacional a localizacao daqueles executaveis, digite no prompt:
PATH=%PATH%;C:\DEV-CPP\BIN\;C:\PP\BIN\WIN32
Se voce ainda nao fez isso, navegue para o seu diretorio de trabalho (C:\SI2011), digitando no prompt:
CD C:\SI2011
Agora voce pode compilar exemploc.c digitando no prompt:
gcc -o exemploc.exe exemploc.c
A opcao -o indica que voce deseja que o programa executavel de saida (output) seja colocado no arquivo exemploc.exe
Voce pode compilar exemplop.pas digitando no prompt:
fpc exemplop.pas
Isto gera o executavel exemplop.exe no seu diretorio de trabalho.
Agora, para executar os programas compilados, basta digitar os nomes dos executaveis no prompt.
Para o programa Pascal, digite:
exemplop.exe (ou apenas: exemplop).
Para o programa C, digite:
exemploc.exe (ou apenas: exemploc).
Voce deve poder ler na tela os textos produzidos pelo codigo de cada programa.
Se nao foi este o seu resultado, anote as mensagens e descreva detalhadamente o que aconteceu.
7 COMANDOS MUITO USADOS (MS-DOS)
ver http://www.computerhope.com/msdos.htm
cd dir
copy del
edit move
ren
exemplos:
----------------------------------------------
CD \
CD\
CD ..
CD..
CD [destino]
CD /?
----------------------------------------------
DIR
DIR /P
DIR /S
DIR /S /P
DIR /?
----------------------------------------------
COPY arquivo1.txt arquivo2.txt
COPY /?
----------------------------------------------
DEL arquivo2.txt
----------------------------------------------
EDIT arquivo.txt
----------------------------------------------
MOVE arquivo.txt pasta1
MOVE pasta1\arquivo.txt pasta2
----------------------------------------------
REN arquivo1.txt arquivo2.txt
REN pasta1 pasta2
----------------------------------------------
.. (dois pontos) referenciam o diretorio (pasta) pai
. (um ponto) referencia o diretorio (pasta) corrente
\ (uma barra invertida) referencia o diretorio (pasta)
[qualquer comando] seguido de /? apresenta pequena ajuda para o comando
experimente tambem, COM CUIDADO:
rd (remove directory)
md (make directory)
Para abrir uma janela de linha de comando ("ms-dos") clique INICIAR (START), em seguida EXECUTAR (RUN); digite:
COMMAND.COM (basta digitar COMMAND) para win95/98, ME, ou
CMD.EXE (basta digitar CMD) para win2000, XP, Vista, Windows7
Va para o diretorio desejado digitando no prompt o comando: CD [diretorio_desejado]
Por exemplo, se existir um diretorio C:\meu_dir\sisinfo\trabalho\, digite:
CD \meu_dir\sisinfo\trabalho
Conteúdo salvo nos arquivos
exemploc.c e exemplop.pas
Codigos ASCII representados em hexadecimal:
69 6E 74 20 6D 61 69 6E 28 29 7B 70 72 69 6E 74
66 28 22 50 72 6F 67 72 61 6D 61 20 43 20 43 4F
4D 50 49 4C 41 44 4F 20 65 20 45 58 45 43 55 54
41 44 4F 5C 6E 22 29 3B 72 65 74 75 72 6E 20 30
3B 7D 0D 0A
que correspondem aos caracteres digitados no teclado:
i n t m a i n ( ) { p r i n t
f ( " P r o g r a m a C C O
M P I L A D O e E X E C U T
A D O \ n " ) ; r e t u r n 0
; } £ ¢
Codigos ASCII representados em hexadecimal:
50 72 6F 67 72 61 6D 20 61 3B 62 65 67 69 6E 20
57 72 69 74 65 6C 6E 28 27 50 72 6F 67 72 61 6D
61 20 50 61 73 63 61 6C 20 43 4F 4D 50 49 4C 41
44 4F 20 65 20 45 58 45 43 55 54 41 44 4F 27 29
20 65 6E 64 2E 0D 0A
que correspondem aos caracteres digitados no teclado:
P r o g r a m a ; b e g i n
W r i t e l n ( ' P r o g r a m
a P a s c a l C O M P I L A
D O e E X E C U T A D O ' )
e n d . £ ¢
nota: £ e ¢ não são “imagens” de caracteres, mas estão aqui
apenas para marcar o lugar dos caracteres “invisíveis”
<LF> (LineFeed) e <CR> (CarriageReturn)
Confira os códigos na TABELA ASCII
IMAGENS podem ser codificadas, por exemplo, no formato BitMaP, ou DIB (DeviceIndependentBitmap), e
armazenadas em arquivos com a extensão '.bmp' ou '.dib'.
Abaixo, os 582 bytes (= 246 hexa) de um arquivo BMP (em bytes separados e linhas numeradas para fácil inspeção.
NÃO fazem parte do arquivo os espaços, pula-linhas, ou numeração na primeira coluna)
000 42 4D 46 02 00 00 00 00-00 00 36 00 00 00 28 00
010 00 00 0F 00 00 00 0B 00-00 00 01 00 18 00 00 00
020 00 00 10 02 00 00 C4 0E-00 00 C4 0E 00 00 00 00
030 00 00 00 00 00 00 FF FF-00 FF FF 00 FF FF 00 FF
040 FF 00 FF FF 00 FF FF 00-00 00 00 80 80 80 80 80
050 80 80 80 80 80 80 80 80-80 80 80 80 80 80 80 80
060 80 80 80 00 00 00 FF FF-00 FF FF 00 FF FF 00 FF
070 FF 00 FF FF 00 FF FF 00-00 00 00 80 80 80 80 80
080 80 80 80 80 80 80 80 80-80 80 80 80 80 80 80 80
090 80 80 80 00 00 00 FF FF-00 FF FF 00 FF FF 00 FF
0A0 FF 00 FF FF 00 FF FF 00-00 00 00 80 80 80 80 80
0B0 80 80 80 80 80 80 80 80-80 80 80 80 80 80 80 80
0C0 80 80 80 00 00 00 FF FF-00 FF FF 00 FF FF 00 FF
0D0 FF 00 FF FF 00 FF FF 00-00 00 00 80 80 80 80 80
0E0 80 80 80 80 80 80 80 80-80 80 80 80 80 80 80 80
0F0 80 80 80 00 00 00 FF FF-00 FF FF 00 FF FF 00 FF
100 FF 00 FF FF 00 FF FF 00-00 00 00 80 80 80 80 80
110 80 80 80 80 80 80 80 80-80 80 80 80 80 80 80 80
120 80 80 80 00 00 00 FF FF-00 FF FF 00 FF FF 00 FF
130 FF 00 FF FF 00 FF FF 00-00 00 00 80 80 80 80 80
140 80 80 80 80 80 80 80 80-80 80 80 80 80 80 80 80
150 80 80 80 00 00 00 FF FF-00 FF FF 00 FF FF 00 FF
160 FF 00 FF FF 00 FF FF 00-00 00 00 80 80 80 80 80
170 80 80 80 80 80 80 80 80-80 80 80 80 80 80 80 80
180 80 80 80 00 00 00 FF FF-00 FF FF 00 FF FF 00 FF
190 FF 00 FF FF 00 FF FF 00-00 00 00 00 00 00 00 00
1A0 00 00 00 00 00 00 00 00-00 00 00 00 00 00 00 00
1B0 00 00 00 00 00 00 FF FF-00 FF FF 00 FF FF 00 FF
1C0 FF 00 FF FF 00 FF FF 00-FF FF 00 00 00 00 00 00
1D0 80 00 00 80 00 00 80 00-00 80 00 00 80 00 00 80
1E0 00 00 80 00 00 00 FF FF-00 FF FF 00 FF FF 00 FF
1F0 FF 00 FF FF 00 FF FF 00-FF FF 00 FF FF 00 00 00
200 00 00 00 80 00 00 80 00-00 80 00 00 80 00 00 80
210 00 00 80 00 00 00 FF FF-00 FF FF 00 FF FF 00 FF
220 FF 00 FF FF 00 FF FF 00-FF FF-00 FF FF 00 FF FF
230 00 00 00 00 00 00 80 00-00 80 00 00 80 00 00 80
240 00 00 80 00 00 00
Organização de um arquivo .bmp (.dib) de 24 bits:
000 ASSIN TAMANHO-ARQ RESER-RESER TAM-CAB-ARQ TAM-C
010 AB-IM NUM-PIX-HOR NUM-PIX-VER N-PLN BITPP COMPR
020 ESSÃO TAM-IMG-BMP PIX-HOR-PMT PIX-HOR-PMT NUM-C
030 ORES CORES-IMPOR B G R B G R B G R B.
040 G R B G R B G R B G R B G R B G.
050 R B G R B G R B G R B G R B G R.
060 B G R 00 00 00 [fim-da-linha]
3 bytes ZEROS: bytes-por-linha múltiplo de 4
(a linha de 45 bytes é gravada como 45+3 = 48 bytes)
O arquivo .bmp (.dib) de 24 bits do exemplo tem os valores:
B M 00000246 0000 0000 00000036 000
000 42 4D 46 02 00 00 00 00-00 00 36 00 00 00 28 00
00028 0000000F 0000000B 0001 0018 000
010 00 00 0F 00 00 00 0B 00-00 00 01 00 18 00 00 00
00000 00000210 00000EC4 00000EC4 000
020 00 00 10 02 00 00 C4 0E-00 00 C4 0E 00 00 00 00
00000 00000000
030 00 00 00 00 00 00 FF FF-00 FF FF 00 FF FF 00 FF
040 FF 00 FF FF 00 FF FF 00 00 00 00 80 80 80 80 80
050 80 80 80 80 80 80 80 80-80 80 80 80 80 80 80 80
060 80 80 80 00 00 00 FF FF-00 FF FF 00 FF FF 00 FF
(...)
Desenhe e edite um arquivo bitmap (.bmp) de 24 bits.
Depois de criar e salvar o bitmap (no Paint, Gimp, ou qualquer editor de imagem) edite com o HxD (Windows), shed (Linux), Hex Fiend (Mac OSX) ou
qualquer outro visualizador/editor hexadecimal.
A sequência hexadecimal abaixo representa o conteúdo do arquivo exemplificado:
424D460200000000000036000000280000000F0000000B000000010018000000000010020000C40E0000C40E00000000000000000000FFFF00FFFF00FFFF00FFFF00FFFF00FFFF00000000808080808080808080808080808080808080808080808080000000FFFF00FFFF00FFFF00FFFF00FFFF00FFFF00000000808080808080808080808080808080808080808080808080000000FFFF00FFFF00FFFF00FFFF00FFFF00FFFF00000000808080808080808080808080808080808080808080808080000000FFFF00FFFF00FFFF00FFFF00FFFF00FFFF00000000808080808080808080808080808080808080808080808080000000FFFF00FFFF00FFFF00FFFF00FFFF00FFFF00000000808080808080808080808080808080808080808080808080000000FFFF00FFFF00FFFF00FFFF00FFFF00FFFF00000000808080808080808080808080808080808080808080808080000000FFFF00FFFF00FFFF00FFFF00FFFF00FFFF00000000808080808080808080808080808080808080808080808080000000FFFF00FFFF00FFFF00FFFF00FFFF00FFFF00000000000000000080000080000080000000FFFF00FFFF00FFFF00FFFF00FFFF00FFFF00FFFF00FFFF00FFFF00000000000080000080000080000080000080000000000000000000000000000000000000000000000000000FFFF00FFFF00FFFF00FFFF00FFFF00FFFF00FFFF00000000000080000080000080000080000080000080000080000000FFFF00FFFF00FFFF00FFFF00FFFF00FFFF00FFFF00FFFF00000000000080000080000080000
Se você copiar/colar/salvar esse conteúdo (aqui escrito propositalmente sem pula-linhas) para um arquivo-texto, o arquivo NÃO conterá os binários do
arquivo bitmap, mas sim uma sequência codificada (por exemlo, em ASCII) de cada CARACTER hexadecimal. O arquivo conterá os valores binários
00110100 00110010 00110100 01000100 etc., correspondentes às letras '4' '2' '4' 'D' etc. (e não os valores 0100 0010 0100 1101 etc., que deve ser o
conteúdo do .bmp visualizável da imagem).
É necessário, portanto, converter o arquivo-texto (de caracteres codificados) para o arquivo-imagem correspondente. Isto é, o padrão '00110100' que é
o código ASCII da 'letra' '4', deve aparecer no arquivo-imagem como '0100', que é a representação binária do número 4; o padrão '01000100' que é o
código ASCII da 'letra' 'D', deve aparecer no arquivo-imagem como '1101', que é a representação binária do número 13 (D hexa); e assim por diante.
Se você quiser visualizar a imagem como exercício, faça o seguinte:
1) Copie, cole e salve o padrão hexadecimal acima para um arquivo-texto simples com o nome 'texto_bmp.txt' (tem que ter esse nome, sem as aspas). Não
devem aparecer pula-linhas, isto é, a sequência de caracteres não tem quebras de linha.
2) Copie o texto abaixo (que é um código-fonte Pascal) para um arquivo (com o nome, por exemplo, 'parhexa2byte.pas') no mesmo diretório do
'texto_bmp.txt' que você salvou anteriormente.
3) Compile 'parhexa2byte.pas' (assim como fez anteriormente para os testes dos compiladores) gerando um arquivo executável, digamos, 'parhexa2byte.exe'.
4) Execute o programa e abra o arquivo-bitmap resultante ('minha_imagem.bmp') em um visualizador de imagem.
{PROGRAMA PARHEXA2BYTE}
{Programa que converte para bytes uma sequencia de pares de caracteres }
{hexadecimais codificados em ASCII –arquivo de entrada: 'texto_bmp.txt'}
{*******arquivo de saida (no formato bitmap): 'minha_imagem.bmp'*******}
{'parhexa2byte.pas' le cada par de letras do arquivo-texto de entrada, }
{*****escrevendo no arquivo de saida o byte que corresponde ao par*****}
program parhexa2byte;
var entratxt,saibin:TEXT;
baite,nibble0,nibble1:integer;
letra0, letra1:char;
begin
assign(entratxt,'texto_bmp.txt');
assign(saibin,'minha_imagem.bmp');
reset(entratxt);
rewrite(saibin);
while not eof(entratxt) do
begin
read(entratxt,letra1);
if not eof(entratxt) then
begin
read(entratxt,letra0);
if letra0>Chr(64) then letra0:=Chr(Ord(letra0)-7);
if letra1>Chr(64) then letra1:=Chr(Ord(letra1)-7);
nibble0:= Ord(letra0)-48;
nibble1:=(Ord(letra1)-48)*16;
baite:=nibble1+nibble0;
write(saibin,Char(baite))
end
end;
close(entratxt);
close(saibin)
end.
{***********************fim de parhexa2byte.pas************************}
Exemplo codigo de montador -LETRAS.COM - escreve na tela caracteres do teclado
1F73:0100 EB24 JMP 0126
1F73:0102 BA00B8 MOV DX,B800
1F73:0105 8EDA MOV DS,DX
1F73:0107 8907 MOV [BX],AX
1F73:0109 C3 RET
1F73:010A 90 NOP
1F73:010B 90 NOP
1F73:010C BA4000 MOV DX,0040
1F73:010F 8EDA MOV DS,DX
1F73:0111 8B3E1C00 MOV DI,[001C]
1F73:0115 8B361C00 MOV SI,[001C]
1F73:0119 39FE CMP SI,DI
1F73:011B 74F8 JZ 0115
1F73:011D 8A0D MOV CL,[DI]
1F73:011F 893E1C00 MOV [001C],DI
1F73:0123 C3 RET
1F73:0124 90 NOP
1F73:0125 90 NOP
1F73:0126 BB0004 MOV BX,0400
1F73:0129 B41F MOV AH,1F
1F73:012B E8DEFF CALL 010C
1F73:012E 80F91B CMP CL,1B
1F73:0131 740A JZ 013D
1F73:0133 88C8 MOV AL,CL
1F73:0135 E8CAFF CALL 0102
1F73:0138 83C302 ADD BX,+02
1F73:013B EBEE JMP 012B
1F73:013D C3 RET
1F73:013E 90 NOP
1F73:013F 90 NOP
Se você quiser executar esse código de montador do programa 'LETRAS.COM', que escreve na tela caracteres do teclado, faça o seguinte.
1) Copie a coluna abaixo (Lista AsSeMbler - que começa com um 'A' e termina com 1 'Q') para um arquivo texto (Vamos chamá-lo de 'meuasm.txt').
Atencao na digitacao: espaco, pula-linha, colchetes, tudo EXATAMENTE como na listagem abaixo.
Salve o arquivo texto com um pula-linha (tecla <ENTER>) ao final.
2) Usar (Windows) com o programa DEBUG.EXE no prompt de comando. Não é difícil baixar o programa,
se você já não o tiver instalado junto com a sua versão do Windows.
2.1) Tendo problemas de compatibilidade, experimente executar o DEBUG.EXE sob uma maquina virtual Dos/Windows (por exemplo, baixe e instale uma
versao do VirtualBox compatível com o seu Sistema Operacional de http://www.virtualbox.org/wiki/Downloads e instale um sistema Dos/Windows
compatível com a versão do programa DEBUG.EXE).
3) Digite no prompt de comando (tela preta) 'DEBUG < meuasm.txt' (sem as aspas).
4) Depois, basta chamar LETRAS.COM, digitando o nome do programa (i.e., LETRAS.COM) no prompt,
ou, alternativamente, digitando no prompt 'DEBUG LETRAS.COM' e, logo após, digitando 'g <ENTER>' (sem as aspas)
Para sair do programa LETRAS.COM, aperte a tecla ESCAPE
Lista AsSeMbler - salve em 'meuasm.txt'
---------------------------------------
A
JMP 0126
MOV DX,B800
MOV DS,DX
MOV [BX],AX
RET
NOP
NOP
MOV DX,0040
MOV DS,DX
MOV DI,[001C]
MOV SI,[001C]
CMP SI,DI
JZ 0115
MOV CL,[DI]
MOV [001C],DI
RET
NOP
NOP
MOV BX,0400
MOV AH,1F
CALL 010C
CMP CL,1B
JZ 013D
MOV AL,CL
CALL 0102
ADD BX,+02
JMP 012B
RET
NOP
NOP
RCX
40
NLETRAS.COM
W
Q
Q
---------------------------------------
PROGRAMAÇÃO PROCEDURAL – PASCAL & C
Copie, cole e salve em um arquivo-texto na sua pasta de trabalho com a extensão apropriada (.c para C e .pas para Pascal) cada um dos exemplos abaixo.
Trabalhe progressivamente. Compile e execute cada exemplo. Experimente alterar o código nas partes que julgar entender.
{*****************************************************}
Program abrefecha; //declaracao do programa em Pascal
begin //inicio do bloco do corpo principal do programa
end. //fim do bloco do corpo principal do programa
{*****************************************************}
/*****************************************************/
int main() //funcao principal do programa em C
{ //chave inicial do corpo da funcao
return 0; //retorno da funcao principal
} //chave final do corpo da funcao
/*****************************************************/
{*****************************************************}
Program abrefecha; //declaracao do programa em Pascal
begin //inicio do bloco do corpo principal do programa
writeln('Arquivo nao pode ser aberto') //ecoar mensagem no canal de saida padrao
end. //fim do bloco do corpo principal do programa
{*****************************************************}
/*****************************************************/
int main() //funcao principal do programa em C
{ //chave inicial do corpo da funcao
printf("Arquivo nao pode ser aberto\n");
/*ecoar mensagem em stdout (tela)*/
return 0; //retorno da funcao principal
} //chave final do corpo da funcao
/*****************************************************/
/*****************************************************/
/* Programa em c (console) que abre e fecha o arquivo `arquivo.txt' para leitura */
/* Sem critica ou mensagens */
#include <stdio.h> //inclusao de cabecalho para preprocessamento
int main() //funcao principal
{ //chave inicial do corpo da funcao
FILE *cfPtr;
/*declaracao do ponteiro para arquivo texto (dispositivo caracter)*/
cfPtr = fopen("arquivo.txt", "r");
/*atribui a ponteiro resultado da abertura (arquivo-texto, so-leitura)*/
fclose(cfPtr); //fechar arquivo (identif ponteiro)
return 0; //retorno da funcao principal
} //chave final do corpo da funcao
/*****************************************************/
{*****************************************************}
{ Programa em pascal (console) que abre e fecha o arquivo `arquivo.txt' para leitura }
{Sem critica ou mensagens}
Program abrefecha; {declaracao do programa}
var
{palavra reservada declarada antes do bloco de definicao de variaveis}
ArqLe:TEXT; {declaracao da variavel de arquivo texto (dispositivo caracter)}
begin {inicio do bloco do corpo principal do programa}
assign(ArqLe,'arquivo.txt');
{vinculacao (variavel , nome externo) - nome externo = nome para o sistema de arquivos do Sistema Operacional)}
reset(ArqLe); {preparacao do arquivo para leitura}
close(ArqLe); {fechar arquivo (variavel de arquivo)}
end. {fim do bloco do corpo principal do programa}
{*****************************************************}
/***********************************************/
/* Programa em c (console) que abre e fecha o arquivo `arquivo.txt' para leitura */
/* com critica e mensagens - ATENCAO: o arquivo `arquivo.txt' deve existir*/
#include <stdio.h> //inclusao de cabecalho para preprocessamento
int main() //funcao principal
{ //chave inicial do corpo da funcao
FILE *cfPtr; //declaracao do ponteiro para arquivo texto (dispositivo caracter)
if ((cfPtr = fopen("arquivo.txt", "r")) == NULL) //se erro (fopen igual a NULL)
printf("Arquivo nao pode ser aberto\n"); //ecoar mensagem em stdout (tela)
else { //senao (chave interna do senao)
printf("Abri arquivo\n"); //ecoar mensagem em stdout
fclose(cfPtr); //fechar arquivo (identif ponteiro)
printf("Fechei arquivo\n"); //ecoar mensagem em stdout
} //chave interna do senao
return 0; //retorno da funcao principal
} //chave final do corpo da funcao
/***********************************************/
{*******************************}
{ Programa em pascal (console) que abre e fecha o arquivo `arquivo.txt' para leitura }
{ com critica e mensagens - ATENCAO: o arquivo `arquivo.txt' deve existir }
Program abrefecha; {declaracao do programa}
var {palavra reservada declarada antes do bloco de definicao de variaveis}
ArqLe:TEXT; {declaracao da variavel de arquivo texto (dispositivo caracter)}
begin {inicio do bloco do corpo principal do programa}
assign(ArqLe,'arquivo.txt'); {vinculacao (variavel , nome externo) - nome externo = nome para o sistema de arquivos do Sistema Operacional)}
{$I-} {diretiva de para o precompilador - compilar com opcao de NAO verificar erro de E/S pelo Sistema Operacional}
reset(ArqLe); {preparacao do arquivo para leitura - a opcao de verificacao de erro do Sistema Operacional esta desligada}
{$I+} {diretiva de para o precompilador - religar opcao de verificar erro de E/S pelo Sistema Operacional}
if IOresult<>0 then {se variavel de ambiente `IOresult' nao e zero entao (sistema nao conseguiu preparar arquivo para leitura)}
writeln('Arquivo nao pode ser aberto') {ecoar mensagem no canal de saida padrao}
else {senao}
begin {inicio do bloco `else'}
writeln('Abri arquivo'); {ecoar mensagem no canal de saida padrao}
close(ArqLe); {fechar arquivo (variavel de arquivo)}
writeln('Fechei arquivo') {ecoar mensagem no canal de saida padrao}
end {fim do bloco `else'}
end. {fim do bloco do corpo principal do programa}
{*******************************}
/***********************************************/
/* Programa em c (console) que abre (cria) e fecha o arquivo `arquivo.txt' para escritura */
/* com critica e mensagens */
#include <stdio.h> //inclusao de cabecalho para preprocessamento
int main() //funcao principal
{ //chave inicial do corpo da funcao
FILE *cfPtr; //declaracao do ponteiro para arquivo texto (dispositivo caracter)
if ((cfPtr = fopen("arquivo.txt", "w")) == NULL) //se erro (fopen igual a NULL)
printf("Arquivo nao pode ser aberto\n"); //ecoar mensagem em stdout (tela)
else { //senao (chave interna do senao)
printf("Abri arquivo\n"); //ecoar mensagem em stdout
fclose(cfPtr); //fechar arquivo (identif ponteiro)
printf("Fechei arquivo\n"); //ecoar mensagem em stdout
} //chave interna do senao
return 0; //retorno da funcao principal
} //chave final do corpo da funcao
/***********************************************/
{***********************************************}
{ Programa em pascal (console) que abre (cria) e fecha o arquivo `arquivo.txt' para escritura }
{ com critica e mensagens }
Program abrefecha; {declaracao do programa}
var {palavra reservada declarada antes do bloco de definicao de variaveis}
ArqLe:TEXT; {declaracao da variavel de arquivo texto (dispositivo caracter)}
begin {inicio do bloco do corpo principal do programa}
assign(ArqLe,'arquivo.txt'); {vinculacao (variavel , nome externo) - nome externo = nome para o sistema de arquivos do Sistema Operacional)}
{$I-} {diretiva de para o precompilador - compilar com opcao de NAO verificar erro de E/S pelo Sistema Operacional}
rewrite(ArqLe); {preparacao do arquivo para escritura - a opcao de verificacao de erro do Sistema Operacional esta desligada}
{$I+} {diretiva de para o precompilador - religar opcao de verificar erro de E/S pelo Sistema Operacional}
if IOresult<>0 then {se variavel de ambiente `IOresult' nao e zero entao (sistema nao conseguiu preparar arquivo para escritura)}
writeln('Arquivo nao pode ser aberto') {ecoar mensagem no canal de saida padrao}
else {senao}
begin {inicio do bloco `else'}
writeln('Abri arquivo'); {ecoar mensagem no canal de saida padrao}
close(ArqLe); {fechar arquivo (variavel de arquivo)}
writeln('Fechei arquivo') {ecoar mensagem no canal de saida padrao}
end {fim do bloco `else'}
end. {fim do bloco do corpo principal do programa}
{***********************************************}
/***********************************************/
/* Programa em c (console) que abre (cria) o arquivo `arquivo.txt' para escritura, escreve e fecha */
/* com critica e mensagens */
#include <stdio.h> //inclusao de cabecalho para preprocessamento
int main() //funcao principal
{ //chave inicial do corpo da funcao
FILE *cfPtr; //declaracao do ponteiro para arquivo texto (dispositivo caracter)
if ((cfPtr = fopen("arquivo.txt", "w")) == NULL) //se erro (fopen igual a NULL)
printf("Arquivo nao pode ser aberto\n"); //ecoar mensagem em stdout (tela)
else { //senao (chave interna do senao)
printf("Abri arquivo\n"); //ecoar mensagem em stdout
fputc(65,cfPtr); //gravar arquivo (codigo ASCII inteiro decimal, identif ponteiro)
printf("Escrevi no arquivo\n"); //ecoar mensagem em stdout
fclose(cfPtr); //fechar arquivo (identif ponteiro)
printf("Fechei arquivo\n"); //ecoar mensagem em stdout
} //chave interna do senao
return 0; //retorno da funcao principal
} //chave final do corpo da funcao
/***********************************************/
{***********************************************}
{ Programa em pascal (console) que abre (cria) o arquivo `arquivo.txt' para escritura, escreve e fecha }
{ com critica e mensagens }
Program abrefecha; {declaracao do programa}
var {palavra reservada declarada antes do bloco de definicao de variaveis}
ArqLe:TEXT; {declaracao da variavel de arquivo texto (dispositivo caracter)}
begin {inicio do bloco do corpo principal do programa}
assign(ArqLe,'arquivo.txt'); {vinculacao (variavel , nome externo) - nome externo = nome para o sistema de arquivos do Sistema Operacional)}
{$I-} {diretiva de para o precompilador - compilar com opcao de NAO verificar erro de E/S pelo Sistema Operacional}
rewrite(ArqLe); {preparacao do arquivo para escritura - a opcao de verificacao de erro do Sistema Operacional esta desligada}
{$I+} {diretiva de para o precompilador - religar opcao de verificar erro de E/S pelo Sistema Operacional}
if IOresult<>0 then {se variavel de ambiente `IOresult' nao e zero entao (sistema nao conseguiu preparar arquivo para escritura)}
writeln('Arquivo nao pode ser aberto') {ecoar mensagem no canal de saida padrao}
else {senao}
begin {inicio do bloco `else'}
writeln('Abri arquivo'); {ecoar mensagem no canal de saida padrao}
write(ArqLe,'A'); {gravar arquivo (variavel de arquivo, caracter)}
writeln('Escrevi no arquivo'); {ecoar mensagem no canal de saida padrao}
close(ArqLe); {fechar arquivo (variavel de arquivo)}
writeln('Fechei arquivo') {ecoar mensagem no canal de saida padrao}
end {fim do bloco `else'}
end. {fim do bloco do corpo principal do programa}
{***********************************************}
/***********************************************/
/* Programa em c (console) que abre (cria) o arquivo `arquivo.txt' para escritura, */
/* escreve a letra ASCII 65 N vezes e fecha */
/* com critica e mensagens */
#include <stdio.h> //inclusao de cabecalho para preprocessamento
#define N 10 //definicao de substituicao do simbolo a esquerda pelo a direita pelo preprocessador
int main() //funcao principal
{ //chave inicial do corpo da funcao
int i; //declaracao de variavel auxiliar tipo inteiro
FILE *cfPtr; //declaracao do ponteiro para arquivo texto (dispositivo caracter)
if ((cfPtr = fopen("arquivo.txt", "w")) == NULL) //se erro (fopen igual a NULL)
printf("Arquivo nao pode ser aberto\n"); //ecoar mensagem em stdout (tela)
else { //senao e chave interna do senao
printf("Abri arquivo\n"); //ecoar mensagem em stdout
for(i=0;i<N;i++) //laco para iterar N vezes o(s) comando(s) seguinte(s)
fputc(65,cfPtr); //gravar arquivo (codigo ASCII inteiro decimal, identif ponteiro)
printf("Escrevi no arquivo\n"); //ecoar mensagem em stdout
fclose(cfPtr); //fechar arquivo (identif ponteiro)
printf("Fechei arquivo\n"); //ecoar mensagem em stdout
} //chave interna do senao
return 0; //retorno da funcao principal
} //chave final do corpo da funcao
/***********************************************/
{***********************************************}
{ Programa em pascal (console) que abre (cria) o arquivo `arquivo.txt' para escritura,}
{escreve a letra 'A' N vezes e fecha }
{ com critica e mensagens }
Program abrefecha; {declaracao do programa}
const
N=10; {constante a esquerda de = sera substituida em cada instancia pelo valor a direita de =}
var {palavra reservada declarada antes do bloco de definicao de variaveis}
i:integer; {declaracao de variavel auxiliar tipo inteiro}
ArqLe:TEXT; {declaracao da variavel de arquivo texto (dispositivo caracter)}
begin {inicio do bloco do corpo principal do programa}
assign(ArqLe,'arquivo.txt');{vinculacao (variavel , nome externo) - nome externo = nome para o sist de arquivos do Sist Operacional)}
{$I-} {diretiva de para o precompilador - compilar com opcao de NAO verificar erro de E/S pelo Sistema Operacional}
rewrite(ArqLe); {preparacao do arquivo para escritura - a opcao de verificacao de erro do Sistema Operacional esta desligada}
{$I+} {diretiva de para o precompilador - religar opcao de verificar erro de E/S pelo Sistema Operacional}
if IOresult<>0 then {se variavel de ambiente `IOresult' nao e zero entao (sistema nao conseguiu preparar arquivo para escritura)}
writeln('Arquivo nao pode ser aberto') {ecoar mensagem no canal de saida padrao}
else {senao}
begin {inicio do bloco `else'}
writeln('Abri arquivo'); {ecoar mensagem no canal de saida padrao}
for i:=1 to N do {laco para iterar N vezes o(s) comando(s) seguinte(s)}
write(ArqLe,'A'); {gravar arquivo (variavel de arquivo, caracter)}
writeln('Escrevi no arquivo'); {ecoar mensagem no canal de saida padrao}
close(ArqLe); {fechar arquivo (variavel de arquivo)}
writeln('Fechei arquivo') {ecoar mensagem no canal de saida padrao}
end {fim do bloco `else'}
end. {fim do bloco do corpo principal do programa}
{***********************************************}
/***********************************************/
/* Programa em c (console) que abre (cria) o arquivo `arquivo.txt' para escritura, */
/* repete a gravacao da letra ASCII 65, ate a condicao [iteracoes == N] ser satisfeita no final do laco, e fecha */
/* com critica e mensagens */
#include <stdio.h> //inclusao de cabecalho para preprocessamento
#define N 10 //definicao de substituicao do simbolo a esquerda pelo a direita pelo preprocessador
int main() //funcao principal
{ //chave inicial do corpo da funcao
int i=0; //declaracao e inicializacao de variavel de controle tipo inteiro para acumular o numero de iteracoes
FILE *cfPtr; //declaracao do ponteiro para arquivo texto (dispositivo caracter)
if ((cfPtr = fopen("arquivo.txt", "w")) == NULL) //se erro (fopen igual a NULL)
printf("Arquivo nao pode ser aberto\n"); //ecoar mensagem em stdout (tela)
else { //senao (chave interna do senao)
printf("Abri arquivo\n"); //ecoar mensagem em stdout
do //inicio do laco que se repete ate a condicao [i==N] ser satisfeita - teste no final do laco
fputc(65,cfPtr); //gravar arquivo (codigo ASCII inteiro decimal, identif ponteiro)
while(++i<N); //incremento e teste da variavel de controle i
printf("Escrevi no arquivo\n"); //ecoar mensagem em stdout
fclose(cfPtr); //fechar arquivo (identif ponteiro)
printf("Fechei arquivo\n"); //ecoar mensagem em stdout
} //chave interna do senao
return 0; //retorno da funcao principal
} //chave final do corpo da funcao
/***********************************************/
{***********************************************}
{ Programa em pascal (console) que abre (cria) o arquivo `arquivo.txt' para escritura,}
{repete a gravacao da letra 'A', ate a condicao [iteracoes = N] ser satisfeita no final do laco, e fecha }
{ com critica e mensagens }
Program abrefecha; {declaracao do programa}
const
N=10; {constante a esquerda que sera substituida em cada instancia pelo valor a direita}
var {palavra reservada declarada antes do bloco de definicao de variaveis}
i:integer; {declaracao de variavel auxiliar tipo inteiro}
ArqLe:TEXT; {declaracao da variavel de arquivo texto (dispositivo caracter)}
begin {inicio do bloco do corpo principal do programa}
assign(ArqLe,'arquivo.txt');{vinculacao (variavel , nome para o sistema de arquivos do Sistema Operacional)}
{$I-} {diretiva de para o precompilador - compilar com opcao de NAO verificar erro de E/S pelo Sistema Operacional}
rewrite(ArqLe); {preparacao do arquivo para escritura - a opcao de verificacao de erro do Sistema Operacional esta desligada}
{$I+} {diretiva de para o precompilador - religar opcao de verificar erro de E/S pelo Sistema Operacional}
if IOresult<>0 then {se variavel de ambiente `IOresult' nao e zero entao (sistema nao conseguiu preparar arquivo para escritura)}
writeln('Arquivo nao pode ser aberto') {ecoar mensagem no canal de saida padrao}
else {senao}
begin {inicio do bloco `else'}
writeln('Abri arquivo'); {ecoar mensagem no canal de saida padrao}
i:=0; {inicializacao da variável de controle}
repeat {inicio do laco que se repete ate a condicao [i=N] ser satisfeita - teste no final do laco }
begin
write(ArqLe,'A'); {gravar arquivo (variavel de arquivo, caracter)}
i:=i+1 {incremento da variável de controle}
end
until(i=N); {teste da variavel de controle i }
writeln('Escrevi no arquivo'); {ecoar mensagem no canal de saida padrao}
close(ArqLe); {fechar arquivo (variavel de arquivo)}
writeln('Fechei arquivo') {ecoar mensagem no canal de saida padrao}
end {fim do bloco `else'}
end. {fim do bloco do corpo principal do programa}
{***********************************************}
/***********************************************/
/* Programa em c (console) que abre (cria) o arquivo `arquivo.txt' para escritura, */
/* escreve as letras ASCII [65 A vezes, 66 B vezes, 90 Z vezes, 13, 10] N vezes e fecha */
/* com critica e mensagens */
#include <stdio.h> //inclusao de cabecalho para preprocessamento
#define A 5 //definicoes de substituicao dos simbolos a esquerda pelos a direita pelo preprocessador
#define B 2
#define Z 3
#define N 10
int main() //funcao principal
{ //chave inicial do corpo da funcao
int i,j,k,l; //declaracao de variavel auxiliar tipo inteiro
FILE *cfPtr; //declaracao do ponteiro para arquivo texto (dispositivo caracter)
if ((cfPtr = fopen("arquivo.txt", "w")) == NULL) //se erro (fopen igual a NULL)
printf("Arquivo nao pode ser aberto\n"); //ecoar mensagem em stdout (tela)
else { //senao (chave interna do senao)
printf("Abri arquivo\n"); //ecoar mensagem em stdout
for(i=0;i<N;i++) { //laco para iterar N vezes os comandos seguintes
for (j=0;j<A;j++)
fputc(65,cfPtr); //gravar arquivo (codigo ASCII inteiro decimal, identif ponteiro)
for (k=0;k<B;k++)
fputc(66,cfPtr);
for (l=0;l<Z;l++)
fputc(90,cfPtr);
fputc(13,cfPtr);
fputc(10,cfPtr);
}
printf("Escrevi no arquivo\n"); //ecoar mensagem em stdout
fclose(cfPtr); //fechar arquivo (identif ponteiro)
printf("Fechei arquivo\n"); //ecoar mensagem em stdout
} //chave interna do senao
return 0; //retorno da funcao principal
} //chave final do corpo da funcao
/***********************************************/
{***********************************************}
{ Programa em pascal (console) que abre (cria) o arquivo `arquivo.txt' para escritura,}
{escreve o padrão de letras ['A' A vezes, 'B' B vezes, 'Z' Z vezes, CR, LF] N vezes e fecha }
{ com critica e mensagens }
Program abrefecha; {declaracao do programa}
const
A=5; {constantes a esquerda que serao substituidas em cada instancia pelo valor a direita}
B=2;
Z=3;
N=10;
CR=Chr(13);
LF=Chr(10);
var {palavra reservada declarada antes do bloco de definicao de variaveis}
i,j,k,l:integer; {declaracao de variavel auxiliar tipo inteiro}
ArqLe:TEXT; {declaracao da variavel de arquivo texto (dispositivo caracter)}
begin {inicio do bloco do corpo principal do programa}
assign(ArqLe,'arquivo.txt'); {vinculacao (variavel , nome externo para o sistema de arquivos do Sistema Operacional)}
{$I-} {diretiva de para o precompilador - compilar com opcao de NAO verificar erro de E/S pelo Sistema Operacional}
rewrite(ArqLe); {preparacao do arquivo para escritura - a opcao de verificacao de erro do Sistema Operacional esta desligada}
{$I+} {diretiva de para o precompilador - religar opcao de verificar erro de E/S pelo Sistema Operacional}
if IOresult<>0 then {se variavel de ambiente `IOresult' nao e zero entao (sistema nao conseguiu preparar arquivo para escritura)}
writeln('Arquivo nao pode ser aberto') {ecoar mensagem no canal de saida padrao}
else {senao}
begin {inicio do bloco `else'}
writeln('Abri arquivo'); {ecoar mensagem no canal de saida padrao}
for i:=1 to N do {laco para iterar N vezes o(s) comando(s) seguinte(s)}
begin
for j:=1 to A do
write(ArqLe,'A'); {gravar arquivo (variavel de arquivo, caracter)}
for k:=1 to B do
write(ArqLe,'B');
for l:=1 to Z do
write(ArqLe,'Z');
write(ArqLe,CR);
write(ArqLe,LF)
end;
writeln('Escrevi no arquivo'); {ecoar mensagem no canal de saida padrao}
close(ArqLe); {fechar arquivo (variavel de arquivo)}
writeln('Fechei arquivo') {ecoar mensagem no canal de saida padrao}
end {fim do bloco `else'}
end. {fim do bloco do corpo principal do programa}
{***********************************************}
/***********************************************/
/* Programa em c (console) que abre e fecha o arquivo `arquivo.txt' para leitura */
/* copia `arquivo.txt' para `novoarq.txt' substituindo cada codigo ASCII 66 pelo 67, */
/* ecoa ao final da leitura, em stdout, o numero total de substituicoes efetuadas, */
/* e fecha `arquivo.txt' e `novoarq.txt', com critica e mensagens */
#include <stdio.h> //inclusao de cabecalho para preprocessamento
#define LetrAntiga 66
#define LetraNova 67
int main() //funcao principal
{ //chave inicial do corpo da funcao
FILE *cfPtr; //declaracao de ponteiro para arquivo texto (dispositivo caracter)
FILE *dfPtr;
char letra;
int total=0;
if ((cfPtr = fopen("arquivo.txt", "r")) == NULL) //se erro (fopen igual a NULL)
printf("Arquivo de leitura nao pode ser aberto\n"); //ecoar mensagem em stdout (tela)
else
if ((dfPtr = fopen("novoarq.txt", "w")) == NULL) { //se erro (fopen igual a NULL)
fclose(cfPtr);
printf("Abri e fechei sem ler arquivo de leitura\n");
printf("Arquivo de escritura nao pode ser aberto\n"); //ecoar mensagem em stdout (tela)
}
else { //senao (chave interna do senao)
printf("Abri arquivos\n"); //ecoar mensagem em stdout
while((letra=fgetc(cfPtr))!=EOF) {
if (letra==LetrAntiga) {letra=LetraNova; total++;}
fputc(letra,dfPtr);
}
fclose(cfPtr); //fechar arquivo (identif ponteiro)
fclose(dfPtr);
printf("Total de substituicoes de %c por %c : %d\n",LetrAntiga,LetraNova,total);
printf("Fechei arquivos\n"); //ecoar mensagem em stdout
} //chave interna do senao
return 0; //retorno da funcao principal
} //chave final do corpo da funcao
/***********************************************/
{***********************************************}
{ Programa em pascal (console) que abre o arquivo `arquivo.txt' para leitura, }
{ copia `arquivo.txt' para `novoarq.txt' substituindo cada letra 'B' pela letra 'C', }
{ ecoa ao final da leitura, em stdout, o numero total de substituicoes efetuadas,}
{ e fecha `arquivo.txt' e `novoarq.txt', com critica e mensagens }
Program abrefecha;
const
LetrAntiga = 'B';
LetraNova = 'C';
var
ArqLe, ArqEscreve:TEXT;
letra:char;
total:integer;
begin
assign(ArqLe,'arquivo.txt');
{$I-}
reset(ArqLe);
{$I+}
if IOresult<>0 then
writeln('Arquivo nao pode ser aberto para leitura')
else
assign(ArqEscreve,'novoarq.txt');
{$I-}
rewrite(ArqEscreve);
{$I+}
if IOresult<>0 then
begin
close(ArqLe);
writeln('Abri e fechei sem ler arquivo de leitura');
writeln('Arquivo nao pode ser aberto para escritura')
end
else
begin
writeln('Abri arquivos');
total:=0;
while not eof(ArqLe) do
begin
read(ArqLe,letra);
if (letra=LetrAntiga) then
begin
letra:=LetraNova;
total:=total+1
end;
write(ArqEscreve, letra)
end;
close(ArqEscreve);
writeln('Total de substituicoes de ',LetrAntiga,' por ',LetraNova,': ',total);
writeln('Fechei arquivos')
end
end.
{***********************************************}
Os números são identificadores de linha para os exercícios seguintes e não fazem parte do código.
00 {******************************************************************************}
01 {Programa em pascal (console) que copia `arquivop.txt' para `novoarq.txt' }
02 {substituindo uma sequencia de letras por outra sequencia, }
03 {ecoa ao final da leitura, em stdout, o numero total de sequencias substituidas}
04 Program substitui;
05 const
06 SeqOriginal = 'ABCDE';
07 SeqSubstit = 'abcdef';
08 N = 5; {tamanho da sequencia original}
09 M = 6; {tamanho da sequencia substituta}
10 var
11 ArqLe, ArqEscreve:TEXT;
12 letra, sequencia:array [0..N-1] of char;
13 substituta:array [0..M-1] of char;
14 total, i, j:integer;
15 difere: boolean;
16 begin
17 assign(ArqLe,'arquivop.txt');
18 {$I-} reset(ArqLe); {$I+}
19 if IOresult<>0 then
20 writeln('Arquivo nao pode ser aberto para leitura')
21 else
22 assign(ArqEscreve,'novoarqp.txt');
23 {$I-} rewrite(ArqEscreve); {$I+}
24 if IOresult<>0 then
25 begin
26 close(ArqLe);
27 writeln('Abri e fechei sem ler arquivo de leitura');
28 writeln('Arquivo nao pode ser aberto para escritura')
29 end
30 else {realiza o processamento principal}
31 begin
32 writeln('Abri arquivos');
33 total:=0; i:=0; difere:=FALSE; sequencia:=SeqOriginal; substituta:=SeqSubstit;
34 while not eof(ArqLe) do {COMECO DO LACO PRINCIPAL}
35 begin
36 read(ArqLe,letra[i]);
37 i:=i+1;
38 if i=N then
39 begin
40 for i:=0 to N-1 do if letra[i]<>sequencia[i] then difere:=TRUE;
41 if difere then
42 begin
43 write(ArqEscreve, letra[0]);
44 difere:=FALSE;
45 for i:=1 to N-1 do letra[i-1]:=letra[i]
46 end
47 else
48 begin
49 for i:=M-1 downto 0 do write(ArqEscreve, substituta[M-1-i]);
50 total:=total+1
51 end
52 end
53 end; {FIM DO LACO PRINCIPAL}
54 for j:=i downto 1 do write(ArqEscreve, letra[i-j]);
55 close(ArqLe);
56 close(ArqEscreve);
57 writeln('Total de substituicoes de ',SeqOriginal,' por ',SeqSubstit,': ',total);
58 writeln('Fechei arquivos')
59 end; {fim do processamento principal}
60 readln {comando opcional de espera}
61 end.
62 {***este programa NAO CONTA o numero de caracteres diferentes na janela lida***}
00 /***********************************************************************************/
01 /* Programa em c (console) que abre e fecha o arquivo `arquivo.txt' para leitura e*/
02 /* copia `arquivo.txt' para `novoarq.txt', substituindo cada sequencia SeqOriginal */
03 /* por SeqSubstit - o numero de caracteres das sequencias deve ser fornecido.*/
04 /* Ecoa em stdout ao final da leitura o numero total de sequencias substituidas */
05 /* e fecha `arquivo.txt' e `novoarq.txt', com critica e mensagens */
06 #include <stdio.h> //inclusao de cabecalho para preprocessamento
07 #define SeqOriginal "ABCDE"
08 #define SeqSubstit "abcdef"
09 #define N 5 //numero de caracteres da sequencia original
10 #define M 6 //numero de caracteres da sequencia substituta
11 int main()
12 {
13 FILE *cfPtr;
14 FILE *dfPtr;
15 char letra[N]="", *sequencia=SeqOriginal, *substituta=SeqSubstit;
16 int total=0, i=0, j=0, difere=0;
17 if ((cfPtr = fopen("arquivo.txt", "r")) == NULL)
18 printf("Arquivo de leitura nao pode ser aberto\n");
19 else
20 if ((dfPtr = fopen("novoarq.txt", "w")) == NULL) {
21 fclose(cfPtr);
22 printf("Abri e fechei sem ler arquivo de leitura\n");
23 printf("Arquivo de escritura nao pode ser aberto\n");
24 }
25 else { //realiza o processamento principal
26 printf("Abri arquivos\n");
27 /******COMECO DO LACO PRINCIPAL*********/
28 while((letra[i]=fgetc(cfPtr))!=EOF)
29 if (i++==(N-1)) //se i=N-1 (ultimo elemento do vetor de caracteres)
30 {for(i=0;i<N;i++)difere+=(letra[i]!=sequencia[i]);
31 if (difere){
32 fputc(letra[0],dfPtr);
33 difere=0;
34 for(i=0;i<(N-1);i++)letra[i]=letra[i+1]; //i=N-1
35 }
36 else {for(i=M;i>0;i--)fputc(substituta[M-i],dfPtr); //i=0
37 total++;
38 }
39 }
40 /******FIM DO LACO PRINCIPAL**********/
41 for(j=i;j>0;j--) fputc(letra[i-j],dfPtr); //escritura do residuo
42 fclose(cfPtr);
43 fclose(dfPtr);
44 printf("Total de substituicoes de %s por %s : %d\n",SeqOriginal,SeqSubstit,total);
45 printf("Fechei arquivos\n");
46 } //fim do processamento principal
47 system("PAUSE"); //comando opcional de espera
48 return 0;
49 }
50 /********este programa CONTA o numero de caracteres diferentes na janela lida********/
-Supondo que o texto do modelo em C será a entrada para o programa do modelo em C;
-Supondo que o texto do modelo em Pascal será a entrada para o programa do modelo em Pascal;
-Modifique os programas segundo as indicações abaixo e explique o que ocorrerá;
-Experimente com textos de entrada diferentes.
Considere:
==========================================================================================
x nlinha codigo1 > codigo2 =trocar na linha nlinha codigo1 por codigo2
- nlinha =eliminar linha nlinha
+ nlinha1/nlinha2 codigo1 =acrescentar codigo1 em nova linha entre nlinha1 e nlinha2
==========================================================================================
Voce pode testar, se quiser, os exercícios em casa, compilando o código modificado para cada caso.
Os arquivos-texto de entrada sempre serão os mesmos: arquivo.txt para o C, arquivop.txt para o Pascal.
O conteúdo de cada arquivo-texto corresponde, respectivamente, ao código dos modelos distribuídos em sala.
Sugestão: copie, com nomes diferentes, seis arquivos-fonte idênticos ao modelo em Pascal
e doze arquivos-fonte idênticos ao modelo em C.
Por exemplo, c0.c, c1.c, c2.c, etc., com conteúdos idênticos ao modelo em c;
e p0.pas, p1.pas, p2.pas, etc., com conteúdos idênticos ao modelo em pascal.
Aplique as mudanças propostas no exercício, um arquivo-fonte para cada caso, compile, execute,
verifique as mensagens e o arquivo-texto de saída.
Para cada caso, experimente com arquivos-texto de entrada diferentes, analisando os efeitos nas saídas.
CASOS EM PASCAL
==================================================
caso 1 PASCAL
--------------------------------------------------
x 06 'ABCDE'; > 'Programa';
--------------------------------------------------
caso 2 PASCAL
--------------------------------------------------
x 09 6; > 3;
--------------------------------------------------
caso 3 PASCAL
--------------------------------------------------
x 15 difere: boolean; > difere: integer;
x 33 difere:=FALSE; > difere:=0;
x 40 difere:=TRUE; > difere:=difere+1;
x 41 if difere then > if difere > 1 then
x 44 difere:=FALSE; > difere:=0;
--------------------------------------------------
caso 4 PASCAL
--------------------------------------------------
x 33 difere:=FALSE; > difere:=TRUE;
--------------------------------------------------
caso 5 PASCAL
--------------------------------------------------
- 37
x 38 i=N > i=N-1
x 52 end > end else i:=i+1
==================================================
CASOS EM C
==================================================
caso 1 C
--------------------------------------------------
x 07 "ABCDE" > "total"
--------------------------------------------------
caso 2 C
--------------------------------------------------
x 16 total=0 > total=1
--------------------------------------------------
caso 3 C
--------------------------------------------------
x 15 letra[N]="" > letra[N]="12345"
x 16 i=0 > i=4
--------------------------------------------------
caso 4 C
--------------------------------------------------
x 16 j=0 > j=999
--------------------------------------------------
caso 5 C
--------------------------------------------------
x 16 difere=0 > difere=1
--------------------------------------------------
caso 6 C
--------------------------------------------------
+ 16/17 int contador=0;
+ 28/29 {
+ 39/40 contador++;}
--------------------------------------------------
caso 7 C
--------------------------------------------------
- 41
--------------------------------------------------
caso 8 C
--------------------------------------------------
x 28 letra[i] > letra[i++]
x 29 i++==(N-1) > i==N
--------------------------------------------------
caso 9 C
--------------------------------------------------
x 31 (difere) > (difere > 1)
--------------------------------------------------
caso 10 C
--------------------------------------------------
- 33
--------------------------------------------------
caso 11 C
--------------------------------------------------
x 36 dfPtr); > dfPtr);}
- 38
==================================================
Experimente agora os arquivos de entrada 'arquivo.txt'
ABCDEFGABCDefgabctotalDEFGBCDEFABCDEABCDEBCDEABCDA
BCDE A totatototalBCDE AB CDE ABC DE ABCD E ABCDEBCDE
para o programa em C, e o arquivo de entrada idêntico 'arquivop.txt'
ABCDEFGABCDefgabctotalDEFGBCDEFABCDEABCDEBCDEABCDA
BCDE A totatototalBCDE AB CDE ABC DE ABCD E ABCDEBCDE
para o programa em Pascal.
Quais seriam as saídas para cada exercício?
==================================================
TABELA DE POTÊNCIAS DE 2
2^0 = 1 = 16^0
2^1 = 2
2^2 = 4
2^3 = 8
2^4 = 16 = 16^1
2^5 = 32
2^6 = 64
2^7 = 128
2^8 = 256 = 16^2
2^9 = 512
2^10 = 1 024
2^11 = 2 048
2^12 = 4 096 = 16^3
2^13 = 8 192
2^14 = 16 384
2^15 = 32 768
2^16 = 65 536 = 16^4
2^17 = 131 072
2^18 = 262 144
2^19 = 524 288
2^20 = 1 048 576 = 16^5
2^21 = 2 097 152
2^22 = 4 194 304
2^23 = 8 388 608
2^24 = 16 777 216 = 16^6
2^25 = 33 554 432
2^26 = 67 108 864
2^27 = 134 217 728
2^28 = 268 435 456 = 16^7
2^29 = 536 870 912
2^30 = 1 073 741 824
2^31 = 2 147 483 648
2^32 = 4 294 967 296 = 16^8
2^33 = 8 589 934 592
2^34 = 17 179 869 184
2^35 = 34 359 738 368
2^36 = 68 719 476 736 = 16^9
2^37 = 137 438 953 472
2^38 = 274 877 906 944
2^39 = 549 755 813 888
2^40 = 1 099 511 627 776 = 16^10
início acima anterior próximo