Tarefa

Construo de um compilador de MiniPascal para CLR
usando Objective Caml
Hugo Gustavo Valin Oliveira da Cunha

hugog.valin@gmail.com
Faculdade de Computao
Universidade Federal de Uberlndia
28 de novembro de 2017
Lista de Listagens
1.1 nano1.pas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8
1.2 nano1.cs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8
1.3 nano1.il . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8
1.4 nano2.pas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9
1.5 nano2.cs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9
1.6 nano2.il . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10
1.7 nano3.pas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10
1.8 nano3.cs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11
1.9 nano1.il . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11
1.10 nano4.pas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12
1.11 nano1.cs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12
1.12 nano1.il . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12
1.13 nano5.pas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13
1.14 nano5.cs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13
1.15 nano1.il . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13
1.16 nano6.pas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14
1.17 nano6.cs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15
1.18 nano6.il . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15
1.19 nano7.pas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 16
1.20 nano7.cs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 16
1.21 nano7.il . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 16
1.22 nano8.pas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 17
1.23 nano8.cs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 18
1.24 nano8.il . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 18
1.25 teste1_9.pas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 19
1.26 teste1_9.cs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 19
1.27 teste1_9.il . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 20
1.28 nano10.pas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21
1.29 nano10.cs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21
1.30 nano10.il . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21
1.31 nano11.pas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 23
1.32 nano11.cs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 23
1.33 nano11.il . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 23
1.34 nano12.pas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 24
1.35 nano12.cs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 25
1.36 nano12.il . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 25
1.37 micro01.pas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 27
1.38 micro01.cs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 27
1.39 micro01.il . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 27
1.40 micro02.pas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 29
2
1.41 micro02.cs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 29
1.42 micro02.il . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 30
1.43 micro03.pas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 32
1.44 micro03.cs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 33
1.45 micro03.il . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 33
1.46 micro04.pas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 35
1.47 micro04.cs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 35
1.48 micro04.il . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 36
1.49 micro05.pas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 38
1.50 micro05.cs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 38
1.51 micro05.il . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 39
1.52 micro06.pas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 41
1.53 micro06.cs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 41
1.54 micro06.il . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 42
1.55 micro07.pas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 44
1.56 micro02.cs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 44
1.57 micro07.il . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 45
1.58 micro08.pas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 47
1.59 micro08.cs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 47
1.60 micro08.il . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 48
1.61 micro09.pas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 49
1.62 micro09.cs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 50
1.63 micro09.il . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 51
1.64 micro10.pas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 53
1.65 micro10.cs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 53
1.66 micro10.il . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 54
1.67 micro11.pas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 55
1.68 micro11.cs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 56
1.69 micro11.il . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 57
2.1 lexico.mll . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 60
3.1 sintatico.mly . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 63
3.2 ast.ml . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 67
3.3 tast.ml . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 68
4.1 sast.ml . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 69
4.2 semantico.ml . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 69
5.1 interprete.ml . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 78
Sumrio
1 Introduo 5
1.1 Linha de comando . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5
1.2 Linguagem Assembly . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6
1.3 Cdigos de programas em Pascal . . . . . . . . . . . . . . . . . . . . . . . . 8
2 Analisador Lxico 60
3 Analisador Sinttico 63
4 Analisador Semntico 69
5 Interprete 78
4
Captulo 1
Introduo
A Common Language Runtime (CLR) o componente de mquina virtual da plata-

forma .NET da Microsoft que gerencia a execuo de programas .NET. Um processo co-
nhecido como compilao just-in-time (JIT) converte o cdigo compilado em linguagem e
mquina que a CPU do computador executa. A CLR fornece servios adicionais, incluindo
gerenciamento de memria, segurana de tipagem, tratamento de exceo, garbage colec-
tor, gerenciamento de thread e segurana. A CLR implementa o Virtual Exection System
(VES), como definido no padro da infraestrutura de linguagem comum (CLI), inicialmente
desenvolvida pela Microsoft. Um padro pblico define a especificao da infraestrutura de
linguagem comum.
A especificao do CLI permite que rodemos aplicaes escritas em uma linguagem de

alto nvel em diferentes sistemas sem a necessidade de se reescrever as aplicaes levando em
conta as especificaes tcnicas de cada um. Alm disso o CLI descreve o cdigo exeutvel e
o ambiente de execuo que forma o ncleo do Framework .NET da Microsoft, do MONO e
Portable.NET sendo os dois ultimo implementaes gratuitas e de cdigo aberto da mesma.
A Common Languagem Runtime a implementao da CLI peloa Microsoft, isto , uma
mquina virtual que segue o padro internacional para a criao e execuo de ambiente de
desenvolvimento.
1.1 Linha de comando
Para essa primeira parte do projeto utilizei os seguintes componentes:
Sistema Operacional Linux Desktop 4.10.0-32-generic 36 16.04.1-Ubuntu i686 i686 i686

GNU/Linux.
Mono JIT compiler version 4.2.1 (Debian 4.2.1.102+dfsg2-7ubuntu4) Copyright (C)

2002-2014 Novell, Inc, Xamarin Inc and Contributors.
Linguagem de programao interpretada, multi-paragdima, C, desenvolvida pela Mi-

crosoft como parta da plataforma .NET.
5
1.2
Para fazer a instalao do sistema utilizei o seguintes comandos no terminal dentro do

sistema Linux:
> sudo apt-get install mono-runtime monodevelop
Para fazer a compilao do cdigo fonte para o arquivo executvel usado o seguinte
comando no terminal Linux:
> mcs /out:nomeExecutavel.exe arquivoCodigoFonte.cs
J para fazer o desassembly utilizei o seguinte comando:

> monodis --output=arquivoCodigoAssembly.il nomeExecutavel.exe
1.2 Linguagem Assembly
O assembly da plataforma CLR um conjuntode instrues baseado em pilha e orientado

a objetos que so listadas a seguir:
add: retira os dois elementos do topo da pilha e coloca o resultado no topo.
add.ovf: retira os dois elementos do topo da pilha e coloca o resultado no topo, verifi-
cando overflow.
and: retira os dois elementos do topo da pilha, faz a operao and bit a bit e coloca o
resultado no topo da pilha.
arglist: retorna o identificador da lista de argumentos para o mtodo atual.
beq pula para o endereo se os elementos topo da pilha so iguais
bge: pula para o endereo se o topo da pilha menor que o seu antecesso.
bge.un. : igual ao bge, mas a comparao feita sem sinal.
bgt: pular para o endereo se o segundo elemento da pilha maior que o topo.
ble: pula para o endereo se o topo menor ou igual ao seu antecessor.
ble.un: igual ao ble, mas a comparao feita sem sinal.
blt : pula pra o endereo se o o topo menor que seu antecessor.
blt.un: igual ao blt, mas a comparao feita sem sinal.
bne: pula para o endereo se o topo no for igual ou no ordenada.
bne.un: igual ao bne, mas a comparao feita sem sinal.
br: salto incondicional
break: instruo de breakpoint

1.2
brfalse: pula para o endereco se falso, nulo, ou zero.
brtrue: pula para o endereo se verdadeiro, diferente de zero, ou no nulo.
call: chamada de mtodo.
calli: chamada de mtodo indireto.
ceq: compara se igual
cgt: compara se maior que.
cgt.un: igual ao cgt, mas a comparao feita sem sinal.
clt: compara se menor que
clt.un igual ao clt, mas a comparao feita sem sinal.
conv : converso de dados.
conv.ovf: igual ao conv, mas com sinalizao de overflow.
conv.ovf.un: igual ao conv.of, mas a comparao feita sem sinal.
cpbllc: copia dados da memria para a memria.
div: diviso.
div.un: igual ao div, mas a comparao feita sem sinal.
dup: duplica o valor da pilha.
jmp: pula para um mtodo.
jmpi: pular para um ponteiro de mtodo.
ldarg: carrega um argumento na pilha.
ldarga: carrega um argumento a partir de um endereo.
ldc: carrega uma constante numrica.
Idelem: carrega um elemento do vetor no index para topo da pilha.
Idelema: carrega o endereco do vetor na posicao index na pilha.
Idstr: poe no topo da pilha a string.
mul: multiplica os dois valores de cima da pilha e empilha o resultado.
mul.ovf: igual ao mul, mas feita sinalizao de overflow.
neg: altera o sinal do elemento do topo da pilha.
newarr: cria um array com o tipo definido onde seu tamanho est no topo da pilha.
not: inverte os bits do elemento do topo da pilha.
r: faz um ou lgico bit a bit dos elementos do topo, empilhando o resultado.

1.3
pop: desempilha a pilha.
rem: computa o resto da diviso do elemento abaixo do topo, pelo topo, e empilha o
resultado.
rem.un: igual ao rem, mas a comparao feita sem sinal.
shl: deslocamento de bits a esquerda.
shr: deslocamento de bits a direita.
starg: retira o elemento do topo da pilha e coloca em um argumento.
sizeof: carrega o tamanho em bits do topo na pilha.
sub: subtrai o segundo valor do primeiro e empilha o resultado.
sub.ovf: igual ao sub, mas com a sinalizao de overflow.
xor: executaa a operao XOR(bit a bit) entre dois elementos da pilha colocando seu
resultado na mesma.
1.3 Cdigos de programas em Pascal
Para introduzir a listagem do cdigo no documento existem pelo menos duas formas
bsicas, ambas usando o pacote listings:
1. Nano1
Listagem 1.1: nano1.pas
1 PROGRAM NANO1;
2 BEGIN
3 END.
Listagem 1.2: nano1.cs

1 class nano1 {
2 public static void Main(){
3 }
4 }
Listagem 1.3: nano1.il

1 .assembly extern mscorlib
2 {
3 .ver 4:0:0:0
4 .publickeytoken = (B7 7A 5C 56 19 34 E0 89 ) // .z\V.4..
5 }
6 .assembly 'nano1'
7 {
8 .custom instance void class [mscorlib]System.Runtime.
CompilerServices.RuntimeCompatibilityAttribute::'.ctor'() = (
1.3
9 01 00 01 00 54 02 16 57 72 61 70 4E 6F 6E 45 78 // ....T..
WrapNonEx
10 63 65 70 74 69 6F 6E 54 68 72 6F 77 73 01 ) //
ceptionThrows.
11
12 .hash algorithm 0x00008004
13 .ver 0:0:0:0
14 }
15 .module nano1.exe // GUID = {5ED09DB1-FA20-4D85-8F38-87FF39FA9BE5}
16
17
18 .class private auto ansi beforefieldinit nano1
19 extends [mscorlib]System.Object
20 {
21
22 // method line 1
23 .method public hidebysig specialname rtspecialname
24 instance default void '.ctor' () cil managed
25 {
26 // Method begins at RVA 0x2050
27 // Code size 7 (0x7)
28 .maxstack 8
29 IL_0000: ldarg.0
30 IL_0001: call instance void object::'.ctor'()
31 IL_0006: ret
32 } // end of method nano1::.ctor
33
34 // method line 2
35 .method public static hidebysig
36 default void Main () cil managed
37 {
39 .entrypoint
40 // Code size 1 (0x1)
41 .maxstack 8
42 IL_0000: ret
43 } // end of method nano1::Main
44
45 } // end of class nano1
2. Nano2
1 PROGRAM NANO2;
2 VAR
3 n: integer;
4
5 BEGIN
6 END.

1 class nano2 {
3 int n;
4 }
5 }
1.3

2 {
3 .ver 4:0:0:0
5 }
6 .assembly 'nano2'
7 {
9 01 00 01 00 54 02 16 57 72 61 70 4E 6F 6E 45 78 // ....T..
WrapNonEx
10 63 65 70 74 69 6F 6E 54 68 72 6F 77 73 01 ) //
ceptionThrows.
11

13 .ver 0:0:0:0
14 }
15 .module nano2.exe // GUID = {5EE07A5F-D6EC-4659-8DB3-6EA69D6FF499}
16
17

20 {
21
22 // method line 1
25 {
27 // Code size 7 (0x7)
28 .maxstack 8
29 IL_0000: ldarg.0
31 IL_0006: ret
33
34 // method line 2
37 {
39 .entrypoint
40 // Code size 1 (0x1)
41 .maxstack 0
42 .locals init (
43 int32 V_0)
44 IL_0000: ret
46
3. Nano3
1 PROGRAM NANO3;
2 VAR
3 n: integer;
1.3
4
5 BEGIN
6 n := 1;
7 END.

1 class nano3 {
3 int n;
4 n = 1;
5 }
6 }

2 {
3 .ver 4:0:0:0
5 }
6 .assembly 'nano3'
7 {
9 01 00 01 00 54 02 16 57 72 61 70 4E 6F 6E 45 78 // ....T..
WrapNonEx
10 63 65 70 74 69 6F 6E 54 68 72 6F 77 73 01 ) //
ceptionThrows.
11
13 .ver 0:0:0:0
14 }
15 .module nano3.exe // GUID = {F99E8C54-DFCD-4C5D-8EED-0AF7A1C379E0}
16
17
20 {
21
22 // method line 1
25 {
27 // Code size 7 (0x7)
28 .maxstack 8
29 IL_0000: ldarg.0
31 IL_0006: ret
33
34 // method line 2
37 {
39 .entrypoint
40 // Code size 3 (0x3)
1.3
41 .maxstack 1
42 .locals init (
43 int32 V_0)
44 IL_0000: ldc.i4.1
45 IL_0001: stloc.0
46 IL_0002: ret
48
4. Nano4
1 PROGRAM NANO4;
2 VAR
3 n: integer;
4
5 BEGIN
6 n := 1 + 2;
7 END.

1 class nano4 {
3 int n;
4 n = 1 + 2;
5 }
6 }

2 {
3 .ver 4:0:0:0
5 }
6 .assembly 'nano4'
7 {
9 01 00 01 00 54 02 16 57 72 61 70 4E 6F 6E 45 78 // ....T..
WrapNonEx
10 63 65 70 74 69 6F 6E 54 68 72 6F 77 73 01 ) //
ceptionThrows.
11
13 .ver 0:0:0:0
14 }
15 .module nano4.exe // GUID = {5F14DDC1-9CCB-493A-8830-645816D38F8C}
16
17
20 {
21
22 // method line 1
1.3

25 {
27 // Code size 7 (0x7)
28 .maxstack 8
29 IL_0000: ldarg.0
31 IL_0006: ret
33
34 // method line 2
37 {
39 .entrypoint
40 // Code size 3 (0x3)
41 .maxstack 1
42 .locals init (
43 int32 V_0)
44 IL_0000: ldc.i4.3
45 IL_0001: stloc.0
46 IL_0002: ret
48
5. Nano5
1 PROGRAM NANO5;
2 VAR
3 n: integer;
4
5 BEGIN
6 n := 2;
7 write(n);
8 END.

1 using System;
2
3 class nano5 {
5 int n;
6 n = 2;
7 Console.Write(n);
8 }
9 }

2 {
3 .ver 4:0:0:0
1.3

5 }
6 .assembly 'nano5'
7 {
9 01 00 01 00 54 02 16 57 72 61 70 4E 6F 6E 45 78 // ....T..
WrapNonEx
10 63 65 70 74 69 6F 6E 54 68 72 6F 77 73 01 ) //
ceptionThrows.
11
13 .ver 0:0:0:0
14 }
15 .module nano5.exe // GUID = {5C4F22FE-7630-4D87-80C5-32E6619B62E4}
16
17
20 {
21
22 // method line 1
25 {
27 // Code size 7 (0x7)
28 .maxstack 8
29 IL_0000: ldarg.0
31 IL_0006: ret
33
34 // method line 2
37 {
39 .entrypoint
40 // Code size 9 (0x9)
41 .maxstack 1
42 .locals init (
43 int32 V_0)
44 IL_0000: ldc.i4.2
45 IL_0001: stloc.0
46 IL_0002: ldloc.0
47 IL_0003: call void class [mscorlib]System.Console::Write(int32)
48 IL_0008: ret
50
6. Nano6
1 PROGRAM NANO6;
2 VAR
3 n: integer;
1.3
4
5 BEGIN
6 n := 1 - 2;
7 write(n);
8 END.

1 using System;
2
3 class nano5 {
5 int n;
6 n = 1 - 2;
7 Console.Write(n);
8 }
9 }

2 {
3 .ver 4:0:0:0
5 }
6 .assembly 'nano6'
7 {
9 01 00 01 00 54 02 16 57 72 61 70 4E 6F 6E 45 78 // ....T..
WrapNonEx
10 63 65 70 74 69 6F 6E 54 68 72 6F 77 73 01 ) //
ceptionThrows.
11
13 .ver 0:0:0:0
14 }
15 .module nano6.exe // GUID = {F9105CC6-2B0A-4822-8D27-285E4054F305}
16
17
20 {
21
22 // method line 1
25 {
27 // Code size 7 (0x7)
28 .maxstack 8
29 IL_0000: ldarg.0
31 IL_0006: ret
33
34 // method line 2
1.3
37 {
39 .entrypoint
40 // Code size 9 (0x9)
41 .maxstack 1
42 .locals init (
43 int32 V_0)
44 IL_0000: ldc.i4.m1
45 IL_0001: stloc.0
46 IL_0002: ldloc.0
48 IL_0008: ret
50
7. Nano7
1 PROGRAM NANO7;
2 VAR
3 n: integer;
4
5 BEGIN
6 n := 1;
7 if ( n = 1) then
8 begin
9 write(n);
10 end;
11 END.

1 using System;
2
3 class nano7 {
5 int n;
6 n = 1;
7 if ( n == 1)
8 Console.Write(n);
9 }
10 }

2 {
3 .ver 4:0:0:0
5 }
6 .assembly 'nano7'
7 {
9 01 00 01 00 54 02 16 57 72 61 70 4E 6F 6E 45 78 // ....T..
WrapNonEx
1.3
10 63 65 70 74 69 6F 6E 54 68 72 6F 77 73 01 ) //
ceptionThrows.
11
13 .ver 0:0:0:0
14 }
15 .module nano7.exe // GUID = {F3A7240D-AC0D-4B6E-A4F3-49D6B8F53EB8}
16
17
20 {
21
22 // method line 1
25 {
27 // Code size 7 (0x7)
28 .maxstack 8
29 IL_0000: ldarg.0
31 IL_0006: ret
33
34 // method line 2
37 {
39 .entrypoint
40 // Code size 16 (0x10)
41 .maxstack 2
42 .locals init (
43 int32 V_0)
44 IL_0000: ldc.i4.1
45 IL_0001: stloc.0
46 IL_0002: ldloc.0
47 IL_0003: ldc.i4.1
48 IL_0004: bne.un IL_000f
49
50 IL_0009: ldloc.0
51 IL_000a: call void class [mscorlib]System.Console::Write(int32)
52 IL_000f: ret
54
8. Nano8
1 PROGRAM NANO8;
2 VAR
3 n: integer;
4
5 BEGIN
6 n := 1;
7 if ( n = 1) then
1.3
8 begin
9 write(n);
10 end;
11 else
12 begin
13 write(0);
14 end;
15 END.

1 using System;
2
3 class nano8 {
5 int n;
6 n = 1;
7 if ( n == 1)
8 Console.Write(n);
9 else
10 Console.Write(0);
11 }
12 }

2 {
3 .ver 4:0:0:0
5 }
6 .assembly 'nano8'
7 {
9 01 00 01 00 54 02 16 57 72 61 70 4E 6F 6E 45 78 // ....T..
WrapNonEx
10 63 65 70 74 69 6F 6E 54 68 72 6F 77 73 01 ) //
ceptionThrows.
11
13 .ver 0:0:0:0
14 }
15 .module nano8.exe // GUID = {3859264A-95A3-4151-B928-CD463DDDF935}
16
17
20 {
21
22 // method line 1
25 {
27 // Code size 7 (0x7)
28 .maxstack 8
29 IL_0000: ldarg.0
1.3
31 IL_0006: ret
33
34 // method line 2
37 {
39 .entrypoint
40 // Code size 27 (0x1b)
41 .maxstack 2
42 .locals init (
43 int32 V_0)
44 IL_0000: ldc.i4.1
45 IL_0001: stloc.0
46 IL_0002: ldloc.0
47 IL_0003: ldc.i4.1
48 IL_0004: bne.un IL_0014
49
50 IL_0009: ldloc.0
52 IL_000f: br IL_001a
53
54 IL_0014: ldc.i4.0
56 IL_001a: ret
58
9. Teste1_9
Listagem 1.25: teste1_9.pas
1 PROGRAM TESTE1_9;
2 VAR
3 n: real;
4
5 BEGIN
6 n := 1 + 1 / 2;
7 if ( n = 1) then
8 begin
9 write(n);
10 end;
11 else
12 begin
13 write(0);
14 end;
15 END.
Listagem 1.26: teste1_9.cs

1 using System;
2
3 class teste1_9{
5 int n;
6 n = 1 + 1 / 2;
7 if ( n == 1)
1.3
8 Console.Write(n);
9 else
11 }
12 }
Listagem 1.27: teste1_9.il

2 {
3 .ver 4:0:0:0
5 }
6 .assembly 'teste1_9'
7 {
9 01 00 01 00 54 02 16 57 72 61 70 4E 6F 6E 45 78 // ....T..
WrapNonEx
10 63 65 70 74 69 6F 6E 54 68 72 6F 77 73 01 ) //
ceptionThrows.
11

13 .ver 0:0:0:0
14 }
15 .module teste1_9.exe // GUID = {A30CCD6F-42E2-4A48-9B76-2F0EC5BCE1CC}
16
17
18 .class private auto ansi beforefieldinit teste1_9

20 {
21
22 // method line 1
25 {
27 // Code size 7 (0x7)
28 .maxstack 8
29 IL_0000: ldarg.0
31 IL_0006: ret
32 } // end of method teste1_9::.ctor
33
34 // method line 2
37 {
39 .entrypoint
41 .maxstack 2
42 .locals init (
43 int32 V_0)
44 IL_0000: ldc.i4.1
45 IL_0001: stloc.0
46 IL_0002: ldloc.0
47 IL_0003: ldc.i4.1
48 IL_0004: bne.un IL_0014
1.3
49
50 IL_0009: ldloc.0
52 IL_000f: br IL_001a
53
54 IL_0014: ldc.i4.0
56 IL_001a: ret
57 } // end of method teste1_9::Main
58
59 } // end of class teste1_9
10. Nano10
1 PROGRAM NANO10;
2 VAR
3 n,m: integer;
4
5 BEGIN
6 n := 1;
7 m := 2;
8 if ( n = m ) then
9 begin
10 write(n);
11 end;
12 else
13 begin
14 write(0);
15 end;
16 END.

1 using System;
2
3 class nano10{
5 int n, m;
6 n = 1;
7 m = 2;
8
9 if ( n == m)
10 Console.Write(n);
11 else
13 }
14 }

2 {
3 .ver 4:0:0:0
5 }
6 .assembly 'nano10'
1.3
7 {
9 01 00 01 00 54 02 16 57 72 61 70 4E 6F 6E 45 78 // ....T..
WrapNonEx
10 63 65 70 74 69 6F 6E 54 68 72 6F 77 73 01 ) //
ceptionThrows.
11
13 .ver 0:0:0:0
14 }
15 .module nano10.exe // GUID = {CEB6B741-839A-4CCC-BBBB-33314E97341A}
16
17
20 {
21
22 // method line 1
25 {
27 // Code size 7 (0x7)
28 .maxstack 8
29 IL_0000: ldarg.0
31 IL_0006: ret
33
34 // method line 2
37 {
39 .entrypoint
40 // Code size 29 (0x1d)
41 .maxstack 2
42 .locals init (
43 int32 V_0,
44 int32 V_1)
45 IL_0000: ldc.i4.1
46 IL_0001: stloc.0
47 IL_0002: ldc.i4.2
48 IL_0003: stloc.1
49 IL_0004: ldloc.0
50 IL_0005: ldloc.1
51 IL_0006: bne.un IL_0016
52
53 IL_000b: ldloc.0
54 IL_000c: call void class [mscorlib]System.Console::Write(int32)
55 IL_0011: br IL_001c
56
57 IL_0016: ldc.i4.0
59 IL_001c: ret
61

1.3
11. Nano11
1 PROGRAM NANO11;
2 VAR
3 n,m,x: integer;
4
5 BEGIN
6 n := 1;
7 m := 2;
8 x := 5;
9 while ( x > n ) do
10 begin
11 n := n + m;
12 write(n);
13 end;
14
15 END.

1 using System;
2
3 class nano11 {
5 int n, m, x;
6 n = 1;
7 m = 2;
8 x = 5;
9
10 while ( x > n){
11 n = n + m;
13 }
14 }
15 }

2 {
3 .ver 4:0:0:0
5 }
7 {
9 01 00 01 00 54 02 16 57 72 61 70 4E 6F 6E 45 78 // ....T..
WrapNonEx
10 63 65 70 74 69 6F 6E 54 68 72 6F 77 73 01 ) //
ceptionThrows.
11
13 .ver 0:0:0:0
14 }
15 .module nano11.exe // GUID = {8E5BE46C-821E-4AA1-9EBD-0BEC8D85CCCE}
16
1.3
17
20 {
21
22 // method line 1
25 {
27 // Code size 7 (0x7)
28 .maxstack 8
29 IL_0000: ldarg.0
31 IL_0006: ret
33
34 // method line 2
37 {
39 .entrypoint
41 .maxstack 2
42 .locals init (
43 int32 V_0,
44 int32 V_1,
45 int32 V_2)
46 IL_0000: ldc.i4.1
47 IL_0001: stloc.0
48 IL_0002: ldc.i4.2
49 IL_0003: stloc.1
50 IL_0004: ldc.i4.5
51 IL_0005: stloc.2
52 IL_0006: br IL_0015
53
54 IL_000b: ldloc.0
55 IL_000c: ldloc.1
56 IL_000d: add
57 IL_000e: stloc.0
58 IL_000f: ldloc.0
60 IL_0015: ldloc.2
61 IL_0016: ldloc.0
62 IL_0017: bgt IL_000b
63
64 IL_001c: ret
66
12. Nano12
1 PROGRAM NANO12;
2 VAR
3 n,m,x: integer;
1.3
4
5 BEGIN
6 n := 1;
7 m := 2;
8 x := 5;
9 while ( x > n ) do
10 begin
11 if ( n = m ) then
12 begin
13 write(n);
14 end;
15 else
16 begin
17 write(0);
18 end;
19 x := x - 1;
20 end;
21
22 END.

1 using System;
2
3 class nano12 {
5 int n, m, x;
6 n = 1;
7 m = 2;
8 x = 5;
9
10 while ( x > n){
11 if ( n == m)
13 else
15 x = x - 1;
16 }
17 }
18 }

2 {
3 .ver 4:0:0:0
5 }
7 {
9 01 00 01 00 54 02 16 57 72 61 70 4E 6F 6E 45 78 // ....T..
WrapNonEx
10 63 65 70 74 69 6F 6E 54 68 72 6F 77 73 01 ) //
ceptionThrows.
11

13 .ver 0:0:0:0
1.3
14 }
15 .module nano12.exe // GUID = {47B286E8-BC25-4510-B8F3-7840D64B7D28}
16
17

20 {
21
22 // method line 1
25 {
27 // Code size 7 (0x7)
28 .maxstack 8
29 IL_0000: ldarg.0
31 IL_0006: ret
33
34 // method line 2
37 {
39 .entrypoint
40 // Code size 47 (0x2f)
41 .maxstack 2
42 .locals init (
43 int32 V_0,
44 int32 V_1,
45 int32 V_2)
46 IL_0000: ldc.i4.1
47 IL_0001: stloc.0
48 IL_0002: ldc.i4.2
49 IL_0003: stloc.1
50 IL_0004: ldc.i4.5
51 IL_0005: stloc.2
52 IL_0006: br IL_0027
53
54 IL_000b: ldloc.0
55 IL_000c: ldloc.1
56 IL_000d: bne.un IL_001d
57
58 IL_0012: ldloc.0
60 IL_0018: br IL_0023
61
62 IL_001d: ldc.i4.0
63 IL_001e: call void class [mscorlib]System.Console::Write(int32)
64 IL_0023: ldloc.2
65 IL_0024: ldc.i4.1
66 IL_0025: sub
67 IL_0026: stloc.2
68 IL_0027: ldloc.2
69 IL_0028: ldloc.0
70 IL_0029: bgt IL_000b
71
72 IL_002e: ret
1.3

74
13. Micro01
Listagem 1.37: micro01.pas
1 PROGRAM MICRO01;
2 VAR
3 cel, fahr : real;
4
5 BEGIN
6 writeln('Tabela de converso: Celsius -> Fahrenhiet');
7 write('Digite a temperatura em Celsius: ');
8 readln(cel);
9 fahr := (9*cel+160)/5;
10 writeln('A nova temperatura : ', fahr, ' F');
11
12 END.
Listagem 1.38: micro01.cs

1 using System;
2
3 class micro01 {
5 double cel, far;
6 Console.WriteLine("Tabela de converso: Celsius -> Fahrenheit");
7 Console.Write("Digite a temperatura em Celsius: ");
8 cel = Convert.ToDouble(Console.ReadLine());
9 far = (9*cel+160)/5;
10 Console.WriteLine("A nova temperatura " + far + " F");
11 }
12 }
Listagem 1.39: micro01.il

2 {
3 .ver 4:0:0:0
5 }
6 .assembly 'micro01'
7 {
9 01 00 01 00 54 02 16 57 72 61 70 4E 6F 6E 45 78 // ....T..
WrapNonEx
10 63 65 70 74 69 6F 6E 54 68 72 6F 77 73 01 ) //
ceptionThrows.
11
13 .ver 0:0:0:0
14 }
15 .module micro01.exe // GUID = {41846A18-08BE-4F54-813D-8E35D731BA58}
16
17
1.3
18 .class private auto ansi beforefieldinit micro01

20 {
21
22 // method line 1
25 {
27 // Code size 7 (0x7)
28 .maxstack 8
29 IL_0000: ldarg.0
31 IL_0006: ret
32 } // end of method micro01::.ctor
33
34 // method line 2
37 {
39 .entrypoint
40 // Code size 90 (0x5a)
41 .maxstack 3
42 .locals init (
43 float64 V_0,
44 float64 V_1)
45 IL_0000: ldstr bytearray (
46 54 00 61 00 62 00 65 00 6c 00 61 00 20 00 64 00 // T.a.b.e.l.a. .d
.
47 65 00 20 00 63 00 6f 00 6e 00 76 00 65 00 72 00 // e. .c.o.n.v.e.r
.
48 73 00 e3 00 6f 00 3a 00 20 00 43 00 65 00 6c 00 // s...o.:. .C.e.l
.
49 73 00 69 00 75 00 73 00 20 00 2d 00 3e 00 20 00 // s.i.u.s. .-.>.
.
50 46 00 61 00 68 00 72 00 65 00 6e 00 68 00 65 00 // F.a.h.r.e.n.h.e
.
51 69 00 74 00 01 ) // i.t..
52
53 IL_0005: call void class [mscorlib]System.Console::WriteLine(

string)
54 IL_000a: ldstr "Digite a temperatura em Celsius: "
55 IL_000f: call void class [mscorlib]System.Console::Write(string)
56 IL_0014: call string class [mscorlib]System.Console::ReadLine()
57 IL_0019: call float64 class [mscorlib]System.Convert::ToDouble(
string)
58 IL_001e: stloc.0
59 IL_001f: ldc.r8 9.
60 IL_0028: ldloc.0
61 IL_0029: mul
62 IL_002a: ldc.r8 160.
63 IL_0033: add
64 IL_0034: ldc.r8 5.
65 IL_003d: div
66 IL_003e: stloc.1
67 IL_003f: ldstr bytearray (
68 41 00 20 00 6e 00 6f 00 76 00 61 00 20 00 74 00 // A. .n.o.v.a. .t
.
1.3
69 65 00 6d 00 70 00 65 00 72 00 61 00 74 00 75 00 // e.m.p.e.r.a.t.u
.
70 72 00 61 00 20 00 e9 00 20 00 01 ) // r.a. ... ..
71
72 IL_0044: ldloc.1
73 IL_0045: box [mscorlib]System.Double
74 IL_004a: ldstr " F"
75 IL_004f: call string string::Concat(object, object, object)
string)
77 IL_0059: ret
78 } // end of method micro01::Main
79
80 } // end of class micro01
14. Micro02
1 PROGRAM MICRO02;
2 VAR
3 num1, num2 : integer;
4
5 BEGIN
6 write('Digite o primeiro nmero: ');
7 readln(num1);
8 write('Digeite o segundo nmero: ');
9 readln(num2);
10 if ( num1 > num2 ) then
11 begin
12 write('O primeiro nmero ', num1, ' maior que o segundo ',
num2);
13 end;
14 else
15 begin
16 write('O segundo nmero ', num2, ' maior que o primeiro ',
num1);
17 end;
18
19 END.

1 using System;
2
3 class micro02 {
5 int num1, num2;
6 Console.Write("Digite o primeiro nmero: ");
7 num1 = Convert.ToInt32(Console.ReadLine());
8 Console.Write("Digite o segundo nmero: ");
9 num2 = Convert.ToInt32(Console.ReadLine());
10 if ( num1 > num2)
11 Console.Write("O primeiro nmero " + num1 + " maior que o
segundo " + num2);
12 else
13 Console.Write("O segundo nmero " + num2 + " maior que o
primeiro" + num2);
14 }
1.3
15 }

2 {
3 .ver 4:0:0:0
5 }
7 {
9 01 00 01 00 54 02 16 57 72 61 70 4E 6F 6E 45 78 // ....T..
WrapNonEx
10 63 65 70 74 69 6F 6E 54 68 72 6F 77 73 01 ) //
ceptionThrows.
11
13 .ver 0:0:0:0
14 }
15 .module micro02.exe // GUID = {9BB4814A-ACA4-4BAF-8941-7BBDBD6078CA}
16
17
20 {
21
22 // method line 1
25 {
27 // Code size 7 (0x7)
28 .maxstack 8
29 IL_0000: ldarg.0
31 IL_0006: ret
33
34 // method line 2
37 {
39 .entrypoint
40 // Code size 155 (0x9b)
41 .maxstack 4
42 .locals init (
43 int32 V_0,
44 int32 V_1)
46 44 00 69 00 67 00 69 00 74 00 65 00 20 00 6f 00 // D.i.g.i.t.e. .o
.
47 20 00 70 00 72 00 69 00 6d 00 65 00 69 00 72 00 // .p.r.i.m.e.i.r
.
48 6f 00 20 00 6e 00 fa 00 6d 00 65 00 72 00 6f 00 // o. .n...m.e.r.o
.
49 3a 00 20 00 01 ) // :. ..
1.3
50
51 IL_0005: call void class [mscorlib]System.Console::Write(string)
52 IL_000a: call string class [mscorlib]System.Console::ReadLine()
53 IL_000f: call int32 class [mscorlib]System.Convert::ToInt32(string
)
54 IL_0014: stloc.0
56 44 00 69 00 67 00 69 00 74 00 65 00 20 00 6f 00 // D.i.g.i.t.e. .o
.
57 20 00 73 00 65 00 67 00 75 00 6e 00 64 00 6f 00 // .s.e.g.u.n.d.o
.
58 20 00 6e 00 fa 00 6d 00 65 00 72 00 6f 00 3a 00 // .n...m.e.r.o
.:.
59 20 00 01 ) // ..
60
61 IL_001a: call void class [mscorlib]System.Console::Write(string)
62 IL_001f: call string class [mscorlib]System.Console::ReadLine()
63 IL_0024: call int32 class [mscorlib]System.Convert::ToInt32(string
)
64 IL_0029: stloc.1
65 IL_002a: ldloc.0
66 IL_002b: ldloc.1
67 IL_002c: ble IL_0068
68
69 IL_0031: ldc.i4.4
70 IL_0032: newarr [mscorlib]System.Object
71 IL_0037: dup
72 IL_0038: ldc.i4.0
74 4f 00 20 00 70 00 72 00 69 00 6d 00 65 00 69 00 // O. .p.r.i.m.e.i
.
75 72 00 6f 00 20 00 6e 00 fa 00 6d 00 65 00 72 00 // r.o. .n...m.e.r
.
76 6f 00 20 00 01 ) // o. ..
77
78 IL_003e: stelem.ref
79 IL_003f: dup
80 IL_0040: ldc.i4.1
81 IL_0041: ldloc.0
82 IL_0042: box [mscorlib]System.Int32
83 IL_0047: stelem.ref
84 IL_0048: dup
85 IL_0049: ldc.i4.2
86 IL_004a: ldstr bytearray (
87 20 00 e9 00 20 00 6d 00 61 00 69 00 6f 00 72 00 // ... .m.a.i.o.r
.
88 20 00 71 00 75 00 65 00 20 00 6f 00 20 00 73 00 // .q.u.e. .o. .s
.
89 65 00 67 00 75 00 6e 00 64 00 6f 00 20 00 01 ) // e.g.u.n.d.o. ..
90
91 IL_004f: stelem.ref
92 IL_0050: dup
93 IL_0051: ldc.i4.3
94 IL_0052: ldloc.1
97 IL_0059: call string string::Concat(object[])
98 IL_005e: call void class [mscorlib]System.Console::Write(string)
99 IL_0063: br IL_009a
1.3
100
101 IL_0068: ldc.i4.4
102 IL_0069: newarr [mscorlib]System.Object
103 IL_006e: dup
104 IL_006f: ldc.i4.0
106 4f 00 20 00 73 00 65 00 67 00 75 00 6e 00 64 00 // O. .s.e.g.u.n.d
.
107 6f 00 20 00 6e 00 fa 00 6d 00 65 00 72 00 6f 00 // o. .n...m.e.r.o
.
108 20 00 01 ) // ..
109
111 IL_0076: dup
112 IL_0077: ldc.i4.1
113 IL_0078: ldloc.1
115 IL_007e: stelem.ref
116 IL_007f: dup
117 IL_0080: ldc.i4.2
119 20 00 e9 00 20 00 6d 00 61 00 69 00 6f 00 72 00 // ... .m.a.i.o.r
.
120 20 00 71 00 75 00 65 00 20 00 6f 00 20 00 70 00 // .q.u.e. .o. .p
.
121 72 00 69 00 6d 00 65 00 69 00 72 00 6f 00 01 ) // r.i.m.e.i.r.o..
122
124 IL_0087: dup
125 IL_0088: ldc.i4.3
126 IL_0089: ldloc.1
127 IL_008a: box [mscorlib]System.Int32
128 IL_008f: stelem.ref
129 IL_0090: call string string::Concat(object[])
131 IL_009a: ret
133
15. Micro03
1 PROGRAM MICRO03;
2 VAR
3 numero: integer;
4
5 BEGIN
6 write('Digite um nmero: ');
7 readln(numero);
8 if ( numero >= 100 ) then
9 begin
10 if ( numero <= 200 ) then
11 begin
12 writeln('O nmero est no intervalo entre 100 e 200');
13 end;
14 else
15 begin
1.3
16 writeln('O nmero no est no intervalo entre 100 2 200');

17 end;
18 end;
19 else
20 begin
21 writeln('O nmero no est no intervalo entre 100 e 200');
22 end;
23 END.

1 using System;
2
3 class micro03 {
5 int numero;
6 Console.Write("Digite um nmero: ");
7 numero = Convert.ToInt32(Console.ReadLine());
8 if ( numero >= 100){
9 if ( numero <= 200)
10 Console.WriteLine("O nmero no intervalor entre 100 e 200");
11 else Console.WriteLine("O nmero no est no intervalo entre
100 e 200");
12 }
13 else
14 Console.WriteLine("O nmero no est no intervalo entre 100 e
200");
15 }
16 }

2 {
3 .ver 4:0:0:0
5 }
7 {
9 01 00 01 00 54 02 16 57 72 61 70 4E 6F 6E 45 78 // ....T..
WrapNonEx
10 63 65 70 74 69 6F 6E 54 68 72 6F 77 73 01 ) //
ceptionThrows.
11
13 .ver 0:0:0:0
14 }
15 .module micro03.exe // GUID = {99769FA4-0AA3-469F-AC61-1FB064653E86}
16
17
20 {
21
22 // method line 1
1.3
25 {
27 // Code size 7 (0x7)
28 .maxstack 8
29 IL_0000: ldarg.0
31 IL_0006: ret
33
34 // method line 2
37 {
39 .entrypoint
40 // Code size 81 (0x51)
41 .maxstack 2
42 .locals init (
43 int32 V_0)
45 44 00 69 00 67 00 69 00 74 00 65 00 20 00 75 00 // D.i.g.i.t.e. .u
.
46 6d 00 20 00 6e 00 fa 00 6d 00 65 00 72 00 6f 00 // m. .n...m.e.r.o
.
47 3a 00 20 00 01 ) // :. ..
48
)
52 IL_0014: stloc.0
53 IL_0015: ldloc.0
54 IL_0016: ldc.i4.s 0x64
55 IL_0018: blt IL_0046
56
57 IL_001d: ldloc.0
58 IL_001e: ldc.i4 200
59 IL_0023: bgt IL_0037
60
62 4f 00 20 00 6e 00 fa 00 6d 00 65 00 72 00 6f 00 // O. .n...m.e.r.o
.
63 20 00 6e 00 6f 00 20 00 69 00 6e 00 74 00 65 00 // .n.o. .i.n.t.e
.
64 72 00 76 00 61 00 6c 00 6f 00 72 00 20 00 65 00 // r.v.a.l.o.r. .e
.
65 6e 00 74 00 72 00 65 00 20 00 31 00 30 00 30 00 // n.t.r.e.
.1.0.0.
66 20 00 65 00 20 00 32 00 30 00 30 00 01 ) // .e. .2.0.0..
67
68 IL_002d: call void class [mscorlib]System.Console::WriteLine(
string)
69 IL_0032: br IL_0041
70
72 4f 00 20 00 6e 00 fa 00 6d 00 65 00 72 00 6f 00 // O. .n...m.e.r.o
.
73 20 00 6e 00 e3 00 6f 00 20 00 65 00 73 00 74 00 // .n...o. .e.s.t
.
1.3
74 e1 00 20 00 6e 00 6f 00 20 00 69 00 6e 00 74 00 // .. .n.o. .i.n.t
.
75 65 00 72 00 76 00 61 00 6c 00 6f 00 20 00 65 00 // e.r.v.a.l.o. .e
.
76 6e 00 74 00 72 00 65 00 20 00 31 00 30 00 30 00 // n.t.r.e.
.1.0.0.
77 20 00 65 00 20 00 32 00 30 00 30 00 01 ) // .e. .2.0.0..
78
79 IL_003c: call void class [mscorlib]System.Console::WriteLine(
string)
80 IL_0041: br IL_0050
81
83 4f 00 20 00 6e 00 fa 00 6d 00 65 00 72 00 6f 00 // O. .n...m.e.r.o
.
84 20 00 6e 00 e3 00 6f 00 20 00 65 00 73 00 74 00 // .n...o. .e.s.t
.
85 e1 00 20 00 6e 00 6f 00 20 00 69 00 6e 00 74 00 // .. .n.o. .i.n.t
.
86 65 00 72 00 76 00 61 00 6c 00 6f 00 20 00 65 00 // e.r.v.a.l.o. .e
.
87 6e 00 74 00 72 00 65 00 20 00 31 00 30 00 30 00 // n.t.r.e.
.1.0.0.
88 20 00 65 00 20 00 32 00 30 00 30 00 01 ) // .e. .2.0.0..
89
90 IL_004b: call void class [mscorlib]System.Console::WriteLine(
string)
91 IL_0050: ret
93
16. Micro04
1 PROGRAM MICRO04;
2 VAR
3 x, num, intervalo : integer;
4
5 BEGIN
6 intervalo := 0;
7 for x := 1 to 5 do
8 begin
10 readln(num);
11 if ( num >= 10 ) then
12 begin
13 if ( num <= 150 ) then
14 begin
15 intervalo := intervalo + 1;
16 end;
17 end;
18 end;
19 writeln('Ao total, foram digitados ', intervalo, ' nmeros no
intervalor 10 e 150');
20 END.
1.3

1 using System;
2
3 class micro04 {
5 int x, num, intervalo;
6
7 intervalo = 0;
8
9 for ( x = 1; x <= 5; x++){

11 num = Convert.ToInt32(Console.ReadLine());
12 if ( num >= 10 )
13 if ( num <= 150 )
14 intervalo = intervalo + 1;
15 }
16
17 Console.WriteLine("Ao total, foram digitados " + intervalo + " n
meros no intervalo entre 10 e 150");
18
19 }
20 }

2 {
3 .ver 4:0:0:0
5 }
7 {
9 01 00 01 00 54 02 16 57 72 61 70 4E 6F 6E 45 78 // ....T..
WrapNonEx
10 63 65 70 74 69 6F 6E 54 68 72 6F 77 73 01 ) //
ceptionThrows.
11

13 .ver 0:0:0:0
14 }
15 .module micro04.exe // GUID = {D8580E0E-2548-4BD1-ACDC-356151188BA6}
16
17

20 {
21
22 // method line 1
25 {
27 // Code size 7 (0x7)
28 .maxstack 8
29 IL_0000: ldarg.0
31 IL_0006: ret
1.3

33
34 // method line 2
37 {
39 .entrypoint
41 .maxstack 3
42 .locals init (
43 int32 V_0,
44 int32 V_1,
45 int32 V_2)
46 IL_0000: ldc.i4.0
47 IL_0001: stloc.2
48 IL_0002: ldc.i4.1
49 IL_0003: stloc.0
50 IL_0004: br IL_0039
51
53 44 00 69 00 67 00 69 00 74 00 65 00 20 00 75 00 // D.i.g.i.t.e. .u
.
54 6d 00 20 00 6e 00 fa 00 6d 00 65 00 72 00 6f 00 // m. .n...m.e.r.o
.
55 3a 00 20 00 01 ) // :. ..
56
57 IL_000e: call void class [mscorlib]System.Console::Write(string)
)
60 IL_001d: stloc.1
61 IL_001e: ldloc.1
62 IL_001f: ldc.i4.s 0x0a
63 IL_0021: blt IL_0035
64
65 IL_0026: ldloc.1
66 IL_0027: ldc.i4 150
67 IL_002c: bgt IL_0035
68
69 IL_0031: ldloc.2
70 IL_0032: ldc.i4.1
71 IL_0033: add
72 IL_0034: stloc.2
73 IL_0035: ldloc.0
74 IL_0036: ldc.i4.1
75 IL_0037: add
76 IL_0038: stloc.0
77 IL_0039: ldloc.0
78 IL_003a: ldc.i4.5
79 IL_003b: ble IL_0009
80
81 IL_0040: ldstr "Ao total, foram digitados "

82 IL_0045: ldloc.2
84 IL_004b: ldstr bytearray (
85 20 00 6e 00 fa 00 6d 00 65 00 72 00 6f 00 73 00 // .n...m.e.r.o.s
.
86 20 00 6e 00 6f 00 20 00 69 00 6e 00 74 00 65 00 // .n.o. .i.n.t.e
1.3
.
87 72 00 76 00 61 00 6c 00 6f 00 20 00 65 00 6e 00 // r.v.a.l.o. .e.n
.
88 74 00 72 00 65 00 20 00 31 00 30 00 20 00 65 00 // t.r.e. .1.0. .e
.
89 20 00 31 00 35 00 30 00 01 ) // .1.5.0..
90
91 IL_0050: call string string::Concat(object, object, object)
string)
93 IL_005a: ret
95
17. Micro05
1 PROGRAM MICRO05;
2 VAR
3
4 nome, sexo : char;

5 x, h, m : integer;
6
7
8 BEGIN
9 h := 0;
10 m := 0;
11
12 for x:=1 to 5 do
13 begin
14 write('Digite o nome: ');
15 readln(nome);
16 write('H - Homem ou M - Mulher: ');
17 readln(sexo);
18 case sexo of
19 'H': h := h + 1;
20 'M': m := m + 1;
21 otherwise writeln('Sexo s pode ser H ou M!');
22 end;
23 end;
24
25 writeln ('Foram inseridos ', h, ' Homens');
26 writeln ('Foram inseridos ', m, ' Mulheres');
27
28 END.

1 using System;
2
3 class micro05 {
5 string nome;
6 char sexo;
7 int x, h, m;
8
9 h = 0;
1.3
10 m = 0;
11
12 for ( x = 1; x <= 5; x++){
13 Console.Write("Digite o nome: ");
14 nome = Console.ReadLine();
15 Console.Write("H - Homem ou M - Mulher: ");
16 sexo = Convert.ToChar(Console.Read());
17 switch (sexo){
18 case 'H': h = h + 1; break;
19 case 'M': m = m + 1; break;
20 default: Console.WriteLine("Sexo s pode ser H ou M!"); break
;
21 }
22 }
23
24 Console.WriteLine("Foram inseridos " + h + " Homens");
25 Console.WriteLine("Foram inseridos " + m + " Mulheres");
26 }
27 }

2 {
3 .ver 4:0:0:0
5 }
7 {
9 01 00 01 00 54 02 16 57 72 61 70 4E 6F 6E 45 78 // ....T..
WrapNonEx
10 63 65 70 74 69 6F 6E 54 68 72 6F 77 73 01 ) //
ceptionThrows.
11
13 .ver 0:0:0:0
14 }
15 .module micro05.exe // GUID = {A462B327-FFA9-4CD0-9C0A-BF08B62E1F38}
16
17
20 {
21
22 // method line 1
25 {
27 // Code size 7 (0x7)
28 .maxstack 8
29 IL_0000: ldarg.0
31 IL_0006: ret
33
34 // method line 2
1.3

37 {
39 .entrypoint
40 // Code size 170 (0xaa)
41 .maxstack 3
42 .locals init (
43 string V_0,
44 char V_1,
45 int32 V_2,
46 int32 V_3,
47 int32 V_4)
48 IL_0000: ldc.i4.0
49 IL_0001: stloc.3
50 IL_0002: ldc.i4.0
51 IL_0003: stloc.s 4
52 IL_0005: ldc.i4.1
53 IL_0006: stloc.2
54 IL_0007: br IL_006d
55
56 IL_000c: ldstr "Digite o nome: "
59 IL_001b: stloc.0
60 IL_001c: ldstr "H - Homem ou M - Mulher: "
62 IL_0026: call int32 class [mscorlib]System.Console::Read()
63 IL_002b: call char class [mscorlib]System.Convert::ToChar(int32)
64 IL_0030: stloc.1
65 IL_0031: ldloc.1
66 IL_0032: ldc.i4.s 0x48
67 IL_0034: beq IL_0046
68
69 IL_0039: ldloc.1
70 IL_003a: ldc.i4.s 0x4d
71 IL_003c: beq IL_004f
72
73 IL_0041: br IL_005a
74
75 IL_0046: ldloc.3
76 IL_0047: ldc.i4.1
77 IL_0048: add
78 IL_0049: stloc.3
79 IL_004a: br IL_0069
80
81 IL_004f: ldloc.s 4
82 IL_0051: ldc.i4.1
83 IL_0052: add
84 IL_0053: stloc.s 4
85 IL_0055: br IL_0069
86
87 IL_005a: ldstr bytearray (

88 53 00 65 00 78 00 6f 00 20 00 73 00 f3 00 20 00 // S.e.x.o. .s...
.
89 70 00 6f 00 64 00 65 00 20 00 73 00 65 00 72 00 // p.o.d.e. .s.e.r
.
90 20 00 48 00 20 00 6f 00 75 00 20 00 4d 00 21 00 // .H. .o.u. .M
.!.
1.3
91 01 ) // .
92
93 IL_005f: call void class [mscorlib]System.Console::WriteLine(
string)
94 IL_0064: br IL_0069
95
96 IL_0069: ldloc.2
97 IL_006a: ldc.i4.1
98 IL_006b: add
99 IL_006c: stloc.2
100 IL_006d: ldloc.2
101 IL_006e: ldc.i4.5
102 IL_006f: ble IL_000c
103
104 IL_0074: ldstr "Foram inseridos "
105 IL_0079: ldloc.3
107 IL_007f: ldstr " Homens"
string)
110 IL_008e: ldstr "Foram inseridos "
111 IL_0093: ldloc.s 4
113 IL_009a: ldstr " Mulheres"
114 IL_009f: call string string::Concat(object, object, object)
115 IL_00a4: call void class [mscorlib]System.Console::WriteLine(
string)
116 IL_00a9: ret
118
18. Micro06
1 PROGRAM MICRO06;
2 VAR
3 numero : integer;
4
5 BEGIN
6 write('Digite um nmero de 1 a 5: ');
7 readln(numero);
8 case numero of
9 1 : writeln('Um');
10 2 : writeln('Dois');
11 3 : writeln('Trs');
12 4 : writeln('Quatro');
13 5 : writeln('Cinco');
14 otherwise writeln('Nmero Invlido!!!');
15 end;
16 END.

1 using System;
2
3 class micro06 {
1.3

5 int numero;
6
7 Console.Write("Digite um nmero de 1 a 5: ");
9 switch(numero){
10 case 1: Console.WriteLine("Um"); break;
11 case 2: Console.WriteLine("Dois"); break;
12 case 3: Console.WriteLine("Trs"); break;
13 case 4: Console.WriteLine("Quatro"); break;
14 case 5: Console.WriteLine("Cinco"); break;
15 default: Console.WriteLine("Nmero Invlido!!!"); break;
16 }
17 }
18 }

2 {
3 .ver 4:0:0:0
5 }
7 {
9 01 00 01 00 54 02 16 57 72 61 70 4E 6F 6E 45 78 // ....T..
WrapNonEx
10 63 65 70 74 69 6F 6E 54 68 72 6F 77 73 01 ) //
ceptionThrows.
11
13 .ver 0:0:0:0
14 }
15 .module micro06.exe // GUID = {391E3A29-66A6-47DB-9887-756DA4470E40}
16
17
20 {
21
22 // method line 1
25 {
27 // Code size 7 (0x7)
28 .maxstack 8
29 IL_0000: ldarg.0
31 IL_0006: ret
33
34 // method line 2
37 {
1.3
39 .entrypoint
40 // Code size 145 (0x91)
41 .maxstack 2
42 .locals init (
43 int32 V_0)
45 44 00 69 00 67 00 69 00 74 00 65 00 20 00 75 00 // D.i.g.i.t.e. .u
.
46 6d 00 20 00 6e 00 fa 00 6d 00 65 00 72 00 6f 00 // m. .n...m.e.r.o
.
47 20 00 64 00 65 00 20 00 31 00 20 00 61 00 20 00 // .d.e. .1. .a.
.
48 35 00 3a 00 20 00 01 ) // 5.:. ..
49
)
53 IL_0014: stloc.0
54 IL_0015: ldloc.0
55 IL_0016: ldc.i4.1
56 IL_0017: sub
57 IL_0018: switch (
58 IL_0036,
59 IL_0045,
60 IL_0054,
61 IL_0063,
62 IL_0072)
63 IL_0031: br IL_0081
64
65 IL_0036: ldstr "Um"
66 IL_003b: call void class [mscorlib]System.Console::WriteLine(
string)
67 IL_0040: br IL_0090
68
69 IL_0045: ldstr "Dois"
70 IL_004a: call void class [mscorlib]System.Console::WriteLine(
string)
71 IL_004f: br IL_0090
72

74 54 00 72 00 ea 00 73 00 01 ) // T.r...s..
75
string)
77 IL_005e: br IL_0090
78
79 IL_0063: ldstr "Quatro"
string)
81 IL_006d: br IL_0090
82
83 IL_0072: ldstr "Cinco"

string)
85 IL_007c: br IL_0090
86
88 4e 00 fa 00 6d 00 65 00 72 00 6f 00 20 00 49 00 // N...m.e.r.o. .I
1.3
.
89 6e 00 76 00 e1 00 6c 00 69 00 64 00 6f 00 21 00 // n.v...l.i.d.o
.!.
90 21 00 21 00 01 ) // !.!..
91
string)
93 IL_008b: br IL_0090
94
95 IL_0090: ret
97
19. Micro07
1 PROGRAM MICRO07;
2 VAR
3 programa, numero : integer;
4 opc : char;
5
6 BEGIN
7 programa := 1;
8 while ( programa = 1 ) do
9 begin
11 readln(numero);
12 if ( numero > 0 ) then
13 begin
14 writeln('Positivo');
15 end;
16 else
17 begin
18 if ( numero = 0 ) then
19 begin
20 writeln('O nmero igual a 0');
21 end;
22 if ( numero < 0 ) then
23 begin
24 writeln('Negativo');
25 end;
26 end;
27 write('Deseja finalizar? (S/N) ');
28 readln(opc);
29 if ( opc = 'S' ) then
30 begin
31 programa := 0;
32 end;
33 end;
34 END.

1 using System;
2
3 class micro07 {
1.3
5 int programa, numero;

6 char opc;
7
8 programa = 1;
9 while ( programa == 1 ){
10 Console.WriteLine("Digite um nmero: ");
12 if ( numero > 0 )
13 Console.WriteLine("Positivo");
14 else {
15 if ( numero == 0 )
16 Console.WriteLine("O nmero igual a 0");
17 if ( numero < 0 )
18 Console.WriteLine("Negativo");
19 }
20
21 Console.Write("Desja finalizar? (S/N) ");

22 opc = Convert.ToChar(Console.ReadLine());
23 if ( opc == 'S' )
24 programa = 0;
25 }
26 }
27 }

2 {
3 .ver 4:0:0:0
5 }
7 {
9 01 00 01 00 54 02 16 57 72 61 70 4E 6F 6E 45 78 // ....T..
WrapNonEx
10 63 65 70 74 69 6F 6E 54 68 72 6F 77 73 01 ) //
ceptionThrows.
11
13 .ver 0:0:0:0
14 }
15 .module micro07.exe // GUID = {32D940C1-DA44-415F-BC9E-3FA07BAF935B}
16
17
20 {
21
22 // method line 1
25 {
27 // Code size 7 (0x7)
28 .maxstack 8
29 IL_0000: ldarg.0
1.3
31 IL_0006: ret
33
34 // method line 2
37 {
39 .entrypoint
40 // Code size 122 (0x7a)
41 .maxstack 2
42 .locals init (
43 int32 V_0,
44 int32 V_1,
45 char V_2)
46 IL_0000: ldc.i4.1
47 IL_0001: stloc.0
48 IL_0002: br IL_0072
49
51 44 00 69 00 67 00 69 00 74 00 65 00 20 00 75 00 // D.i.g.i.t.e. .u
.
52 6d 00 20 00 6e 00 fa 00 6d 00 65 00 72 00 6f 00 // m. .n...m.e.r.o
.
53 3a 00 20 00 01 ) // :. ..
54
string)
)
58 IL_001b: stloc.1
59 IL_001c: ldloc.1
60 IL_001d: ldc.i4.0
61 IL_001e: ble IL_0032
62
63 IL_0023: ldstr "Positivo"
string)
65 IL_002d: br IL_0053
66
67 IL_0032: ldloc.1
68 IL_0033: brtrue IL_0042
69
71 4f 00 20 00 6e 00 fa 00 6d 00 65 00 72 00 6f 00 // O. .n...m.e.r.o
.
72 20 00 e9 00 20 00 69 00 67 00 75 00 61 00 6c 00 // ... .i.g.u.a.l
.
73 20 00 61 00 20 00 30 00 01 ) // .a. .0..
74
string)
76 IL_0042: ldloc.1
77 IL_0043: ldc.i4.0
78 IL_0044: bge IL_0053
79
80 IL_0049: ldstr "Negativo"
81 IL_004e: call void class [mscorlib]System.Console::WriteLine(
1.3
string)
82 IL_0053: ldstr "Desja finalizar? (S/N) "
84 IL_005d: call string class [mscorlib]System.Console::ReadLine()
85 IL_0062: call char class [mscorlib]System.Convert::ToChar(string)
86 IL_0067: stloc.2
87 IL_0068: ldloc.2
88 IL_0069: ldc.i4.s 0x53
89 IL_006b: bne.un IL_0072
90
91 IL_0070: ldc.i4.0
92 IL_0071: stloc.0
93 IL_0072: ldloc.0
94 IL_0073: ldc.i4.1
95 IL_0074: beq IL_0007
96
97 IL_0079: ret
99
20. Micro08
1 PROGRAM MICRO08;
2 VAR
3 numero : integer;
4
5 BEGIN
6 numero := 1;
7 while ( numero <> 0 ) do
8 begin
10 readln(numero);
11
12 if ( numero > 10 ) then
13 begin
14 writeln('O nmero ', numero, ' maior que 10');
15 end;
16 else
17 begin
18 writeln('O nmero ', numero, ' menor que 10');
19 end;
20 end;
21 END.

1 using System;
2
3 class micro08 {
5 int numero;
6
7 numero = 1;
8 while ( numero != 0 ) {
1.3
11 if ( numero > 10 )
12 Console.WriteLine("O nmero " + numero + " maior que 10");
13 else
14 Console.WriteLine("O nmero " + numero + " menor que 10");
15 }
16 }
17 }

2 {
3 .ver 4:0:0:0
5 }
7 {
9 01 00 01 00 54 02 16 57 72 61 70 4E 6F 6E 45 78 // ....T..
WrapNonEx
10 63 65 70 74 69 6F 6E 54 68 72 6F 77 73 01 ) //
ceptionThrows.
11
13 .ver 0:0:0:0
14 }
15 .module micro08.exe // GUID = {70B027DE-8DAE-4497-B999-CB56BE1D776F}
16
17
20 {
21
22 // method line 1
25 {
27 // Code size 7 (0x7)
28 .maxstack 8
29 IL_0000: ldarg.0
31 IL_0006: ret
33
34 // method line 2
37 {
39 .entrypoint
40 // Code size 100 (0x64)
41 .maxstack 3
42 .locals init (
43 int32 V_0)
44 IL_0000: ldc.i4.1
45 IL_0001: stloc.0
46 IL_0002: br IL_005d
1.3
47
49 44 00 69 00 67 00 69 00 74 00 65 00 20 00 75 00 // D.i.g.i.t.e. .u
.
50 6d 00 20 00 6e 00 fa 00 6d 00 65 00 72 00 6f 00 // m. .n...m.e.r.o
.
51 3a 00 20 00 01 ) // :. ..
52
53 IL_000c: call void class [mscorlib]System.Console::Write(string)
)
56 IL_001b: stloc.0
57 IL_001c: ldloc.0
58 IL_001d: ldc.i4.s 0x0a
59 IL_001f: ble IL_0043
60
62 4f 00 20 00 6e 00 fa 00 6d 00 65 00 72 00 6f 00 // O. .n...m.e.r.o
.
63 20 00 01 ) // ..
64
65 IL_0029: ldloc.0
67 IL_002f: ldstr bytearray (
68 20 00 e9 00 20 00 6d 00 61 00 69 00 6f 00 72 00 // ... .m.a.i.o.r
.
69 20 00 71 00 75 00 65 00 20 00 31 00 30 00 01 ) // .q.u.e. .1.0..
70
string)
73 IL_003e: br IL_005d
74

76 4f 00 20 00 6e 00 fa 00 6d 00 65 00 72 00 6f 00 // O. .n...m.e.r.o
.
77 20 00 01 ) // ..
78
79 IL_0048: ldloc.0
81 IL_004e: ldstr bytearray (
82 20 00 e9 00 20 00 6d 00 65 00 6e 00 6f 00 72 00 // ... .m.e.n.o.r
.
83 20 00 71 00 75 00 65 00 20 00 31 00 30 00 01 ) // .q.u.e. .1.0..
84

string)
87 IL_005d: ldloc.0
88 IL_005e: brtrue IL_0007
89
90 IL_0063: ret
92
21. Micro09
1.3

1 PROGRAM MICRO09;
2 VAR
3 preco, venda, novo_preco : real;
4
5 BEGIN
6 write('Digite o preco: ');
7 readln(preco);
8 write('Digite a venda: ');
9 readln(venda);
10
11 if ((venda < 500) or (preco < 30)) then
12 begin
13 novo_preco := preco + 10/100 * preco;
14 end;
15 else
16 begin
17 if (((venda >= 500) and (venda < 1200)) or ((preco >= 30) and (
preco < 80))) then
18 begin
19 novo_preco := preco + 15/100 * preco;
20 end;
21 else
22 begin
23 if ((venda >= 1200) or (preco >= 80)) then
24 begin
25 novo_preco := preco - 20/100 * preco;
26 end;
27 end;
28 end;
29 writeln('O novo preco ', novo_preco);
30 END.

1 using System;
2
3 class micro09 {
5 double preco, venda, novo_preco;
6
7 novo_preco = 0;
8
9 Console.Write("Digite o preco: ");
10 preco = Convert.ToDouble(Console.ReadLine());
11 Console.Write("Digite a venda: ");
12 venda = Convert.ToDouble(Console.ReadLine());
13
14 if ( (venda < 500) || ( preco < 30 ) )
15 novo_preco = preco + 10/100 * preco;
16 else if ( (venda >= 500 && venda < 1200) || (preco >= 30 && preco
< 80) )
17 novo_preco = preco + 15/100 * preco;
18 else if ( venda >= 1200 || preco >= 80 )
19 novo_preco = preco - 20/100 * preco;
20
21 Console.Write("O novo preco e " + novo_preco);
22 }
23 }
1.3

2 {
3 .ver 4:0:0:0
5 }
7 {
9 01 00 01 00 54 02 16 57 72 61 70 4E 6F 6E 45 78 // ....T..
WrapNonEx
10 63 65 70 74 69 6F 6E 54 68 72 6F 77 73 01 ) //
ceptionThrows.
11
13 .ver 0:0:0:0
14 }
15 .module micro09.exe // GUID = {FDD43407-255F-4D04-9C33-05E9E89CD03D}
16
17
20 {
21
22 // method line 1
25 {
27 // Code size 7 (0x7)
28 .maxstack 8
29 IL_0000: ldarg.0
31 IL_0006: ret
33
34 // method line 2
37 {
39 .entrypoint
40 // Code size 246 (0xf6)
41 .maxstack 3
42 .locals init (
43 float64 V_0,
44 float64 V_1,
45 float64 V_2)
46 IL_0000: ldc.r8 0.
47 IL_0009: stloc.2
48 IL_000a: ldstr "Digite o preco: "
49 IL_000f: call void class [mscorlib]System.Console::Write(string)
51 IL_0019: call float64 class [mscorlib]System.Convert::ToDouble(
string)
1.3
52 IL_001e: stloc.0
53 IL_001f: ldstr "Digite a venda: "
56 IL_002e: call float64 class [mscorlib]System.Convert::ToDouble(
string)
57 IL_0033: stloc.1
58 IL_0034: ldloc.1
59 IL_0035: ldc.r8 500.
60 IL_003e: blt IL_0052
61
62 IL_0043: ldloc.0
63 IL_0044: ldc.r8 30.
64 IL_004d: bge.un IL_0065
65
66 IL_0052: ldloc.0
67 IL_0053: ldc.r8 0.
68 IL_005c: ldloc.0
69 IL_005d: mul
70 IL_005e: add
71 IL_005f: stloc.2
72 IL_0060: br IL_00e0
73
74 IL_0065: ldloc.1
75 IL_0066: ldc.r8 500.
76 IL_006f: blt.un IL_0083
77
78 IL_0074: ldloc.1
79 IL_0075: ldc.r8 1200.
80 IL_007e: blt IL_00a1
81
82 IL_0083: ldloc.0
83 IL_0084: ldc.r8 30.
84 IL_008d: blt.un IL_00b4
85
86 IL_0092: ldloc.0
87 IL_0093: ldc.r8 80.
88 IL_009c: bge.un IL_00b4
89
90 IL_00a1: ldloc.0
91 IL_00a2: ldc.r8 0.
92 IL_00ab: ldloc.0
93 IL_00ac: mul
94 IL_00ad: add
95 IL_00ae: stloc.2
96 IL_00af: br IL_00e0
97
98 IL_00b4: ldloc.1
99 IL_00b5: ldc.r8 1200.
100 IL_00be: bge IL_00d2
101
102 IL_00c3: ldloc.0
103 IL_00c4: ldc.r8 80.
104 IL_00cd: blt.un IL_00e0
105
106 IL_00d2: ldloc.0
107 IL_00d3: ldc.r8 0.
108 IL_00dc: ldloc.0
109 IL_00dd: mul
1.3
110 IL_00de: sub

111 IL_00df: stloc.2
112 IL_00e0: ldstr "O novo preco e "
113 IL_00e5: ldloc.2
114 IL_00e6: box [mscorlib]System.Double
115 IL_00eb: call string string::Concat(object, object)
116 IL_00f0: call void class [mscorlib]System.Console::Write(string)
117 IL_00f5: ret
119
22. Micro10
1 PROGRAM MICRO10;
2 VAR
3 numero : integer;
4 fat : integer;
5
6 FUNCTION fatorial( numero : integer) : integer;
7 begin
8 if ( numero <= 0) then
9 begin
10 fatorial := 1;
11 end;
12
13 else
14 begin
15 fatorial := numero * fatorial(numero-(1));
16 end;
17 end;
18
19 BEGIN
21 readln(numero);
22 fat := fatorial(numero);
23 write('O fatorial de ');
24 write(numero);
25 write(' ');
26 writeln(fat);
27 END.

1 using System;
2
3 class micro10 {
4 public static int fatorial (int n){
5 if ( n <= 0)
6 return 1;
7 else
8 return n * fatorial(n-1);
9 }
10
12 int numero, fat;
13
1.3

16 fat = fatorial(numero);
17
18 Console.Write("O fatorial de ");

19 Console.Write(numero);
20 Console.Write(" ");
21 Console.WriteLine(fat);
22 }
23 }

2 {
3 .ver 4:0:0:0
5 }
7 {
9 01 00 01 00 54 02 16 57 72 61 70 4E 6F 6E 45 78 // ....T..
WrapNonEx
10 63 65 70 74 69 6F 6E 54 68 72 6F 77 73 01 ) //
ceptionThrows.
11
13 .ver 0:0:0:0
14 }
15 .module micro10.exe // GUID = {39967959-DCDD-4DFC-BC91-99FC03A7AB34}
16
17
20 {
21
22 // method line 1
25 {
27 // Code size 7 (0x7)
28 .maxstack 8
29 IL_0000: ldarg.0
31 IL_0006: ret
33
34 // method line 2
36 default int32 fatorial (int32 n) cil managed
37 {
39 // Code size 20 (0x14)
40 .maxstack 8
41 IL_0000: ldarg.0
42 IL_0001: ldc.i4.0
43 IL_0002: bgt IL_0009
1.3
44
45 IL_0007: ldc.i4.1
46 IL_0008: ret
47 IL_0009: ldarg.0
48 IL_000a: ldarg.0
49 IL_000b: ldc.i4.1
50 IL_000c: sub
51 IL_000d: call int32 class micro10::fatorial(int32)
52 IL_0012: mul
53 IL_0013: ret
54 } // end of method micro10::fatorial
55
56 // method line 3
59 {
61 .entrypoint
63 .maxstack 1
64 .locals init (
65 int32 V_0,
66 int32 V_1)
68 44 00 69 00 67 00 69 00 74 00 65 00 20 00 75 00 // D.i.g.i.t.e. .u
.
69 6d 00 20 00 6e 00 fa 00 6d 00 65 00 72 00 6f 00 // m. .n...m.e.r.o
.
70 3a 00 20 00 01 ) // :. ..
71
)
75 IL_0014: stloc.0
76 IL_0015: ldloc.0
77 IL_0016: call int32 class micro10::fatorial(int32)
78 IL_001b: stloc.1
79 IL_001c: ldstr "O fatorial de "
81 IL_0026: ldloc.0
83 IL_002c: ldstr bytearray (
84 20 00 e9 00 20 00 01 ) // ... ..
85
87 IL_0036: ldloc.1
88 IL_0037: call void class [mscorlib]System.Console::WriteLine(int32
)
89 IL_003c: ret
91
23. Micro11
1 PROGRAM MICRO11;
1.3
2 VAR
3 numero : integer;
4 x : integer;
5
6 FUNCTION verifica ( n : integer ): integer;

7 var
8 res : integer;
9 begin
10 if ( n > 0 ) then
11 begin
12 res := 1;
13 end;
14
15 if ( n < 0 ) then
16 begin
17 res := -1;
18 end;
19
20 else
21 begin
22 res := 0;
23 end;
24 verifica := res;
25 end;
26
27 BEGIN
29 readln(numero);
30 x := verifica(numero);
31 if ( x = 1) then
32 begin
33 writeln('Numero positivo');
34 end;
35 else
36 begin
37 if ( x = 0 ) then
38 begin
39 writeln ('Zero');
40 end;
41 else
42 begin
43 writeln('Nmero negativo');
44 end;
45 end;
46 END.

1 using System;
2
3 class micro11 {
4 public static int verifica(int n){
5 int res;
6 if ( n > 0 )
7 res = 1;
8 else if ( n < 0)
9 res = -1;
10 else
11 res = 0;
1.3
12 return res;
13 }
14
16 int numero, x;
17
20 x = verifica(numero);
21 if ( x == 1 )
22 Console.WriteLine("Numero positivo");
23 else if ( x == 0)
24 Console.WriteLine("Zero");
25 else Console.WriteLine("Numero negativo");
26 }
27 }

2 {
3 .ver 4:0:0:0
5 }
7 {
9 01 00 01 00 54 02 16 57 72 61 70 4E 6F 6E 45 78 // ....T..
WrapNonEx
10 63 65 70 74 69 6F 6E 54 68 72 6F 77 73 01 ) //
ceptionThrows.
11
13 .ver 0:0:0:0
14 }
15 .module micro11.exe // GUID = {62078E8D-54BD-4D4B-B6AB-49F59AB55B10}
16
17

20 {
21
22 // method line 1
25 {
27 // Code size 7 (0x7)
28 .maxstack 8
29 IL_0000: ldarg.0
31 IL_0006: ret
33
34 // method line 2
36 default int32 verifica (int32 n) cil managed
37 {
1.3

39 // Code size 32 (0x20)
40 .maxstack 2
41 .locals init (
42 int32 V_0)
43 IL_0000: ldarg.0
44 IL_0001: ldc.i4.0
45 IL_0002: ble IL_000e
46
47 IL_0007: ldc.i4.1
48 IL_0008: stloc.0
49 IL_0009: br IL_001e
50
51 IL_000e: ldarg.0
52 IL_000f: ldc.i4.0
53 IL_0010: bge IL_001c
54
55 IL_0015: ldc.i4.m1
56 IL_0016: stloc.0
57 IL_0017: br IL_001e
58
59 IL_001c: ldc.i4.0
60 IL_001d: stloc.0
61 IL_001e: ldloc.0
62 IL_001f: ret
63 } // end of method micro11::verifica
64
65 // method line 3
68 {
70 .entrypoint
71 // Code size 82 (0x52)
72 .maxstack 2
73 .locals init (
74 int32 V_0,
75 int32 V_1)
77 44 00 69 00 67 00 69 00 74 00 65 00 20 00 75 00 // D.i.g.i.t.e. .u
.
78 6d 00 20 00 6e 00 fa 00 6d 00 65 00 72 00 6f 00 // m. .n...m.e.r.o
.
79 3a 00 20 00 01 ) // :. ..
80
)
84 IL_0014: stloc.0
85 IL_0015: ldloc.0
86 IL_0016: call int32 class micro11::verifica(int32)
87 IL_001b: stloc.1
88 IL_001c: ldloc.1
89 IL_001d: ldc.i4.1
90 IL_001e: bne.un IL_0032
91
92 IL_0023: ldstr "Numero positivo"
1.3
string)
94 IL_002d: br IL_0051
95
96 IL_0032: ldloc.1
97 IL_0033: brtrue IL_0047
98
99 IL_0038: ldstr "Zero"
string)
101 IL_0042: br IL_0051
102
103 IL_0047: ldstr "Numero negativo"
string)
105 IL_0051: ret
107
Captulo 2
Analisador Lxico
Anlise lxica (scanning) o primeiro estgio de um processo em trs partes que o com-
pilador utiliza para entender o programa de entrada. O scanner, ou analisador lxico, l um
fluxo de caracteres e produz um fluxo de palavras. Ele agrega caracteres para formar pala-
vras e aplica um conjunto de regras para determinar se cada uma delas uma palavra vlida
na linguagem-fonte. Se a palavra vlida, o scanner atribui-lhe uma categoria sinttica, ou
classe gramatical. Eis o analisador lxico em Ocaml da linguagem Pascal:
Listagem 2.1: lexico.mll
1 {
2 open Lexing
3 open Printf
4 open Sintatico
5
6 exception Erro of string
7
8 let incr_num_linha lexbuf =
9 let pos = lexbuf.lex_curr_p in
10 lexbuf.lex_curr_p <-
11 { pos with pos_lnum = pos.pos_lnum + 1;
12 pos_bol = pos.pos_cnum
13 }
14
15 let pos_atual lexbuf = lexbuf.lex_start_p
16
17 }
18
19 let digito = ['0' - '9']

20 let letra = ['a' - 'z' 'A' - 'Z']
21 let ponto = "."
22 let inteiro = '-'?(digito)+
23 let real = ( digito )+ ponto (digito)+
24
25
26 let identificador = letra ( letra | digito | '_')*
27
28 let brancos = [' ' '\t']+
29 let novalinha = '\r' | '\n' | "\r\n"
30
31 let comentario = "//" [^ '\r' '\n' ]*

32
60
2.0
33 rule token = parse

34 brancos { token lexbuf }
35 | novalinha { incr_num_linha lexbuf; token lexbuf }
36 | comentario { token lexbuf }
37 | "(*" { comentario_bloco 0 lexbuf }
38 | '+' { MAIS (pos_atual lexbuf) }
39 | '-' { MENOS (pos_atual lexbuf) }
40 | '*' { MULTIPLICACAO (pos_atual lexbuf) }
41 | '/' { DIVISAO (pos_atual lexbuf) }
42 | '=' { IGUAL (pos_atual lexbuf) }
43 | "<>" { DIFERENTE (pos_atual lexbuf) }
44 | '>' { MAIOR (pos_atual lexbuf) }
45 | '<' { MENOR (pos_atual lexbuf) }
46 | '.' { PONTO (pos_atual lexbuf) }
47 | ';' { PONTO_VIRGULA (pos_atual lexbuf) }
48 | '(' { ABRE_PARENTESE (pos_atual lexbuf) }
49 | ')' { FECHA_PARENTESE (pos_atual lexbuf) }
50 | ':' { DOIS_PONTOS (pos_atual lexbuf) }
51 | "<=" { MENOR_IGUAL (pos_atual lexbuf) }
52 | ">=" { MAIOR_IGUAL (pos_atual lexbuf) }
53 | ":=" { ATRIBUICAO (pos_atual lexbuf) }
54 | ',' { VIRGULA (pos_atual lexbuf) }
55 | "AND" { AND (pos_atual lexbuf) }
56 | "and" { AND (pos_atual lexbuf) }
57 | "BEGIN" { BEGIN (pos_atual lexbuf) }
58 | "begin" { BEGIN (pos_atual lexbuf) }
59 | "CASE" { CASE (pos_atual lexbuf) }
60 | "case" { CASE (pos_atual lexbuf) }
61 | "CHAR" { CHAR (pos_atual lexbuf) }
62 | "char" { CHAR (pos_atual lexbuf) }
63 | "DO" { DO (pos_atual lexbuf) }
64 | "do" { DO (pos_atual lexbuf) }
65 | "ELSE" { ELSE (pos_atual lexbuf) }
66 | "else" { ELSE (pos_atual lexbuf) }
67 | "END" { END (pos_atual lexbuf) }
68 | "end" { END (pos_atual lexbuf) }
69 | "FOR" { FOR (pos_atual lexbuf) }
70 | "for" { FOR (pos_atual lexbuf) }
71 | "FUNCTION" { FUNCTION (pos_atual lexbuf) }
72 | "function" { FUNCTION (pos_atual lexbuf) }
73 | "IF" { IF (pos_atual lexbuf) }
74 | "if" { IF (pos_atual lexbuf) }
75 | "INTEGER" { INTEGER (pos_atual lexbuf) }
76 | "integer" { INTEGER (pos_atual lexbuf) }
77 | "MOD" { MOD (pos_atual lexbuf) }
78 | "mod" { MOD (pos_atual lexbuf) }
79 | "NOT" { NOT (pos_atual lexbuf) }
80 | "not" { NOT (pos_atual lexbuf) }
81 | "OF" { OF (pos_atual lexbuf) }
82 | "of" { OF (pos_atual lexbuf) }
83 | "OR" { OR (pos_atual lexbuf) }
84 | "or" { OR (pos_atual lexbuf) }
85 | "OTHERWISE" { OTHERWISE (pos_atual lexbuf) }
86 | "otherwise" { OTHERWISE (pos_atual lexbuf) }
87 | "PROGRAM" { PROGRAM (pos_atual lexbuf) }
88 | "program" { PROGRAM (pos_atual lexbuf) }
89 | "REAL" { REAL (pos_atual lexbuf) }
90 | "real" { REAL (pos_atual lexbuf) }
91 | "READLN" { READLN (pos_atual lexbuf) }
2.0
92 | "readln" { READLN (pos_atual lexbuf) }

93 | "THEN" { THEN (pos_atual lexbuf) }
94 | "then" { THEN (pos_atual lexbuf) }
95 | "TO" { TO (pos_atual lexbuf) }
96 | "to" { TO (pos_atual lexbuf) }
97 | "VAR" { VAR (pos_atual lexbuf) }
98 | "var" { VAR (pos_atual lexbuf) }
99 | "WHILE" { WHILE (pos_atual lexbuf) }
100 | "while" { WHILE (pos_atual lexbuf) }
101 | "WRITE" { WRITE (pos_atual lexbuf) }
102 | "write" { WRITE (pos_atual lexbuf) }
103 | "WRITELN" { WRITELN (pos_atual lexbuf) }
104 | "writeln" { WRITELN (pos_atual lexbuf) }
105 | eof { EOF }
106 | inteiro as num { let numero = int_of_string num in
107 LITERAL_INTEGER (numero, pos_atual lexbuf) }
108 | real as num { let numero = float_of_string num in
109 LITERAL_REAL (numero,pos_atual lexbuf) }
110 | identificador as id { IDENTIFICADOR(id, pos_atual lexbuf) }
111 | '"' { let pos = lexbuf.lex_curr_p in
112 let lin = pos.pos_lnum
113 and col = pos.pos_cnum - pos.pos_bol - 1 in
114 let buffer = Buffer.create 1 in
115 let str = leia_string lin col buffer lexbuf in
116 LITERAL_STRING (str,pos_atual lexbuf) }
117
118 | '\'' { let pos = lexbuf.lex_curr_p in
121 let buffer = Buffer.create 1 in
122 let str = leia_string lin col buffer lexbuf in
123 LITERAL_STRING (str,pos_atual lexbuf) }
124 | _ {raise (Erro ("Caracter desconhecido: "^Lexing.lexeme lexbuf )) }
125 | eof { EOF }
126
127 and comentario_bloco n = parse
128 "(*" { if n=0 then token lexbuf
129 else comentario_bloco (n-1) lexbuf }
130 | "*)" { comentario_bloco (n+1) lexbuf }
131 | _ { comentario_bloco n lexbuf }
132 | eof { raise (Erro "Comentrio no terminado") }
133
134 and leia_string lin col buffer = parse
135 '"' { Buffer.contents buffer}
136 | ''' { Buffer.contents buffer}
137 | "\\t" { Buffer.add_char buffer '\t'; leia_string lin col buffer
lexbuf }
138 | "\\n" { Buffer.add_char buffer '\n'; leia_string lin col buffer
lexbuf }
139 | '\\' '"' { Buffer.add_char buffer '"'; leia_string lin col buffer lexbuf
}
140 | '\\' '\'' { Buffer.add_char buffer '\''; leia_string lin col buffer
lexbuf }
141 | '\\' '\\' { Buffer.add_char buffer '\\'; leia_string lin col buffer
lexbuf }
142 | _ as c { Buffer.add_char buffer c; leia_string lin col buffer lexbuf
}
143 | eof { raise (Erro "A string no foi fechada")}
Captulo 3
Analisador Sinttico
A anlise sinttica (parsing) o segundo estgio do front-end do compilador. O parser

trabalha com o programa transformado pelo scanner; ele v um fluxo de palavras, onde
cada palavra est associada a uma categoria sinttica (semelhante sua classe gramatical).
Ele deriva uma estrutura sinttica para o programa, encaixando as palavras em um modelo
gramatical da linguagem de programao-fonte. Se o parser determina que o fluxo de entrada
um programa vlido, constri um modelo concreto do programa para uso pelas ltimas
fases da compilao. Caso contrrio, ele informa o problema e a informao de diagnstico
apropriada ao usurio. Eis o programa em Ocaml do analisador sinttico:
Listagem 3.1: sintatico.mly
1
2 %{
3
4 open Lexing
5 open Ast
6 open Sast
7
8 %}
9
10 %token<Lexing.position> DO
11 %token<Lexing.position> DOIS_PONTOS
12 %token<Lexing.position> FOR
13 %token<Lexing.position> FUNCTION
14 %token<Lexing.position> OF
15 %token<Lexing.position> PONTO_VIRGULA
16 %token<Lexing.position> PONTO
17 %token<Lexing.position> TO
18 %token<Lexing.position> VAR
19 %token<Lexing.position> VIRGULA
20 %token<Lexing.position> WHILE
21
22
23 %token<int * Lexing.position> LITERAL_INTEGER
24 %token<float * Lexing.position> LITERAL_REAL
25 %token<string * Lexing.position> LITERAL_STRING
26 %token<bool * Lexing.position> LITERAL_BOOLEAN
27 %token<string * Lexing.position> IDENTIFICADOR
28
29 %token<Lexing.position> INTEGER REAL STRING BOOLEAN CHAR
63
3.0
30
31 %token<Lexing.position> PROGRAM
32 %token<Lexing.position> BEGIN
33 %token<Lexing.position> END
34
35 %token<Lexing.position> IF THEN ELSE
36 %token<Lexing.position> CASE
37 %token<Lexing.position> OTHERWISE
38 %token<Lexing.position> READLN
39 %token<Lexing.position> WRITE WRITELN
40 %token<Lexing.position> ATRIBUICAO
41
42 %token<Lexing.position> OR
43 %token<Lexing.position> AND
44 %token<Lexing.position> NOT
45 %token<Lexing.position> IGUAL
46 %token<Lexing.position> DIFERENTE
47 %token<Lexing.position> MAIOR
48 %token<Lexing.position> MAIOR_IGUAL
49 %token<Lexing.position> MENOR
50 %token<Lexing.position> MENOR_IGUAL
51
52 %token<Lexing.position> MAIS
53 %token<Lexing.position> MENOS
54 %token<Lexing.position> MULTIPLICACAO
55 %token<Lexing.position> DIVISAO
56 %token<Lexing.position> MOD
57
58
59 %token<Lexing.position> ABRE_PARENTESE FECHA_PARENTESE
60 %token EOF
61
62 %right NOT
63 %left OR
64 %left AND
65 %left IGUAL DIFERENTE MAIOR MENOR MAIOR_IGUAL MENOR_IGUAL
66 %left MULTIPLICACAO DIVISAO MOD
67 %left MAIS MENOS
68
69 %start <Sast.expressao Ast.programa> programa
70
71 %%
72
73 programa: PROGRAM identificador=IDENTIFICADOR PONTO_VIRGULA
74 VAR
75 ds = declaracao*
76 fs = funcao*
77 BEGIN
78 cs = comando*
79 END PONTO
80 EOF { Programa (identificador, List.flatten ds, fs, cs) }
81
82 declaracao: ids = separated_nonempty_list(VIRGULA, IDENTIFICADOR)

DOIS_PONTOS t=tipo PONTO_VIRGULA {
83 List.map (fun id -> DecVar (id,t)) ids
84 }
85
86 argumento : nome = IDENTIFICADOR DOIS_PONTOS t = tipo {
87 (nome,t)
3.0
88 }
89
90 funcao: FUNCTION id=IDENTIFICADOR ABRE_PARENTESE parametros=separated_list
(VIRGULA, argumento) FECHA_PARENTESE DOIS_PONTOS r=tipo PONTO_VIRGULA
91 VAR
92 ds = declaracao*
93 BEGIN
94 cs = comando*
95 END PONTO_VIRGULA {
96 DecFun {
97 fn_nome = id;
98 fn_tiporet = r;
99 fn_formais = parametros;
100 fn_locais = List.flatten ds;
101 fn_corpo = cs
102 }
103 }
104
105
106 tipo: INTEGER { TipoInteger }
107 | REAL { TipoReal }
108 | STRING { TipoString }
109 | CHAR { TipoString }
110 | BOOLEAN { TipoBool }
111
112
113 comando: c=comando_atribuicao { c }
114 | c=comando_if { c }
115 | c=comando_readln { c }
116 | c=comando_write { c }
117 | c=comando_for { c }
118 | c=comando_while { c }
119 | c=comando_case { c }
120 | c=comando_chamada_funcao { c }
121
122
123 comando_atribuicao: esq=expressao ATRIBUICAO dir=expressao PONTO_VIRGULA {
124 CmdAtrib (esq,dir)
125 }
126
127
128
129
130 comando_if: IF ABRE_PARENTESE teste=expressao FECHA_PARENTESE THEN
131 BEGIN
132 entao=comando*
133 END PONTO_VIRGULA
134 senao=option ( ELSE
135 BEGIN
136 cs = comando*
137 END PONTO_VIRGULA {cs} ) {
138 CmdIf (teste, entao, senao)
139 }
140
141 comando_readln: READLN ABRE_PARENTESE xs=separated_nonempty_list(VIRGULA,
expressao) FECHA_PARENTESE PONTO_VIRGULA {
142 CmdReadln xs
143 }
144
3.0
145 funcaoSaida:
146 | c=WRITE { c }
147 | c=WRITELN { c }
148
149 comando_write: funcaoSaida ABRE_PARENTESE xs=separated_nonempty_list(

VIRGULA, expressao) FECHA_PARENTESE PONTO_VIRGULA {
150 CmdWrite xs
151 }
152
153 comando_for: FOR v=expressao ATRIBUICAO e1=expressao TO e2=expressao DO
154 BEGIN
155 corpo=comando*
157 CmdFor(v, e1, e2,corpo)
158 }
159
160 comando_while: WHILE teste=expressao DO

161 BEGIN
162 corpo=comando+
164 CmdWhile(teste, corpo)
165 }
166
167
168 caso: e=expressao DOIS_PONTOS cmd=comando { CmdOpCase (e, cmd) }
169
170 comando_case: CASE teste=expressao OF
171 corpo=caso+
172 senao=option(OTHERWISE cs=comando* {cs})
174 CmdCase(teste, corpo, senao)
175 }
176
177 comando_chamada_funcao: exp=chamada PONTO_VIRGULA {
178 CmdChamFunc exp
179 }
180
181 chamada: id=IDENTIFICADOR ABRE_PARENTESE args=separated_list(VIRGULA,
expressao) FECHA_PARENTESE {
182 ExpressaoChamadaFuncao (id, args)
183 }
184
185 expressao:
186 | v=variavel { ExpressaoVariavel v }
187 | i=LITERAL_INTEGER { ExpressaoInteger i}
188 | s=LITERAL_STRING { ExpressaoString s }
189 | b=LITERAL_BOOLEAN { ExpressaoBool b }
190 | r=LITERAL_REAL { ExpressaoReal r }
191 | c = chamada { c }
192 | e1=expressao op=oper e2=expressao { ExpressaoOperador (op, e1, e2
) }
193 | ABRE_PARENTESE e=expressao FECHA_PARENTESE { e }
194
195 %inline oper:
196 | pos = MAIS { (Mais, pos) }
197 | pos = MENOS { (Menos, pos) }
198 | pos = MULTIPLICACAO { (Multiplicacao, pos) }
199 | pos = DIVISAO { (Divisao, pos) }
200 | pos = MOD { (Mod, pos) }
3.0
201 | pos = MENOR { (Menor, pos) }

202 | pos = MENOR_IGUAL { (MenorIgual, pos) }
203 | pos = MAIOR { (Maior, pos) }
204 | pos = MAIOR_IGUAL { (MaiorIgual,pos) }
205 | pos = IGUAL { (Igual,pos) }
206 | pos = DIFERENTE { (Diferente,pos) }
207 | pos = OR { (Or,pos) }
208 | pos = AND { (And,pos) }
209 | pos = NOT { (Not,pos) }
210
211 variavel: x=IDENTIFICADOR { VarSimples x }
Os compiladores, em geral, so organizados como uma srie de passos. medida que

o compilador deriva conhecimento sobre o cdigo que compila, precisa transmitir esta in-
formao de um passo para outro. E, portanto, necessita de uma representao para todos
os fatos que deriva sobre o programa. Chamamos isto de representao intermediria (IR).
Um exemplo a rvore sinttica abstrata (AST) retm a estrutura essencial da rvore de
derivao, mas elimina os ns irrelevantes. Eis o programa em Ocaml da rvore sinttica
abstrata:
Listagem 3.2: ast.ml
1 (* The type of the abstract syntax tree (AST). *)
2 open Lexing
3
4 type ident = string
5
6 type 'a pos = 'a * Lexing.position (* tipo e posio no arquivo fonte *)
7
8 type 'expr programa = Programa of (ident pos) * declaracoes * ('expr
funcoes) * ('expr comandos)
9
10 and declaracoes = declaracao list

11
12 and 'expr funcoes = ('expr funcao) list
13
14 and 'expr comandos = ('expr comando) list
15
16 and 'expr funcao = DecFun of ('expr decfn)

17
18 and declaracao = DecVar of (ident pos) * tipo
19
20 and 'expr decfn = {
21 fn_nome : ident pos;
22 fn_tiporet: tipo;
23 fn_formais: (ident pos * tipo) list;
24 fn_locais: declaracoes;
25 fn_corpo: 'expr comandos
26 }
27
28 and tipo = TipoInteger

29 | TipoReal
30 | TipoString
31 | TipoBool
32 | TipoVoid
33
34 and 'expr comando =

35 | CmdAtrib of 'expr * 'expr
3.0
36 | CmdIf of 'expr * ('expr comandos) * ('expr comandos option)

37 | CmdReadln of ('expr expressoes)
38 | CmdWrite of ('expr expressoes)
39 | CmdFor of 'expr * 'expr * 'expr * ('expr comandos)
40 | CmdWhile of 'expr * ('expr comandos)
41 | CmdChamFunc of 'expr
42 | CmdCase of 'expr * ('expr comandos) * ('expr comandos option)
43 | CmdOpCase of 'expr * ('expr comando)
44 | CmdReturn of 'expr option
45
46 and constante = ConstInteger of int

47 | ConstString of string
48 | ConstBool of bool
49 | ConstChar of char
50 | ConstReal of float
51
52 and 'expr variaveis = ('expr variavel) list

53
54 and 'expr variavel = VarSimples of ident pos
55
56 and 'expr expressoes = 'expr list
57
58 and operacao =
59 | Mais
60 | Menos
61 | Multiplicacao
62 | Divisao
63 | Mod
64 | Menor
65 | MenorIgual
66 | Maior
67 | MaiorIgual
68 | Igual
69 | Diferente
70 | Or
71 | And
72 | Not
Eis o programa em Ocaml da rvore sinttica abstrata tipada:

Listagem 3.3: tast.ml
1 open Ast
2
3 type expressao =
4 | ExpressaoVariavel of (expressao variavel) * tipo
5 | ExpressaoInteger of int * tipo
6 | ExpressaoString of string * tipo
7 | ExpressaoBool of bool * tipo
8 | ExpressaoReal of float * tipo
9 | ExpressaoVoid
10 | ExpressaoOperador of (operacao * tipo) * (expressao * tipo) * (expressao
* tipo)
11 | ExpressaoChamadaFuncao of ident * (expressao expressoes) * tipo
Captulo 4
Analisador Semntico
A anlise semntica trata a entrada sinttica e transforma-a numa representao mais

simples e mais adaptada a gerao de cdigo. O objetivo da anlise semntica trabalhar
nesse nvel de inter-relacionamento entre partes distintas do programa. As tarefas bsicas
desempenhadas durante a anlise semntica incluem a verificao de tipos, a verificao
do fluxo de controle e a verificao da unicidade da declarao de variveis. Dependendo
da linguagem de programao, outros tipos de verificaes podem ser necessrios. Eis o
programa em Ocaml da rvore sinttica abstrata semntica:
Listagem 4.1: sast.ml
1 open Ast
2
3 type expressao =
4 | ExpressaoVariavel of (expressao variavel)
5 | ExpressaoInteger of int pos
6 | ExpressaoString of string pos
7 | ExpressaoBool of bool pos
8 | ExpressaoReal of float pos
9 | ExpressaoOperador of (operacao pos) * expressao * expressao
10 | ExpressaoChamadaFuncao of (ident pos) * (expressao expressoes)
Eis o programa em Ocaml do analisador semntico:

Listagem 4.2: semantico.ml
1 module Amb = Ambiente
2 module A = Ast
3 module S = Sast
4 module T = Tast
5
6 let rec posicao exp = let open S in
7 match exp with
8 | ExpressaoVariavel v -> (match v with
9 | A.VarSimples (_,pos) -> pos
10 )
11 | ExpressaoInteger (_,pos) -> pos
12 | ExpressaoString (_,pos) -> pos
13 | ExpressaoBool (_,pos) -> pos
14 | ExpressaoReal (_,pos) -> pos
15 | ExpressaoOperador ((_,pos),_,_) -> pos
69
4.0
16 | ExpressaoChamadaFuncao ((_,pos), _) -> pos

17
18 type classe_op = Aritmetico | Relacional | Logico
19
20 let classifica op =
21 let open A in
22 match op with
23 | Not
24 | Or
25 | And -> Logico
26 | Menor
27 | MenorIgual
28 | Maior
29 | MaiorIgual
30 | Igual
31 | Diferente -> Relacional
32 | Mod
33 | Mais
34 | Menos
35 | Multiplicacao
36 | Divisao -> Aritmetico
37
38 let msg_erro_pos pos msg =

39 let open Lexing in
42 Printf.sprintf "Semantico -> linha %d, coluna %d: %s" lin col msg
43
44 let msg_erro nome msg =

45 let pos = snd nome in
46 msg_erro_pos pos msg
47
48 let nome_tipo t =
49 let open A in
50 match t with
51 | TipoInteger -> "integer"
52 | TipoString -> "string"
53 | TipoBool -> "boolean"
54 | TipoReal -> "real"
55 | TipoVoid -> "void"
56
57 let mesmo_tipo pos msg tinf tdec =
58 if tinf <> tdec
59 then
60 let msg = Printf.sprintf msg (nome_tipo tinf) (nome_tipo tdec) in
61 failwith (msg_erro_pos pos msg)
62
63 let rec infere_exp amb exp =
64 match exp with
65 S.ExpressaoInteger n -> (T.ExpressaoInteger (fst n, A.TipoInteger), A.
TipoInteger)
66 | S.ExpressaoString s -> (T.ExpressaoString (fst s, A.TipoString), A.
TipoString)
67 | S.ExpressaoBool b -> (T.ExpressaoBool (fst b, A.TipoBool), A.TipoBool)
68 | S.ExpressaoReal r -> (T.ExpressaoReal (fst r, A.TipoReal), A.TipoReal)
69 | S.ExpressaoVariavel v ->
70 (match v with
71 A.VarSimples nome ->
72 (* Tenta encontrar a definio da varivel no escopo local, se no
4.0
*)
73 (* encontar tenta novamente no escopo que engloba o atual.
Prossegue-se *)
74 (* assim at encontrar a definio em algum escopo englobante ou at
*)
75 (* encontrar o escopo global. Se em algum lugar for encontrado,
*)
76 (* devolve-se a definio. Em caso contrrio, devolve uma exceo
*)
77 let id = fst nome in
78 (try (match (Amb.busca amb id) with
79 | Amb.EntVar tipo -> (T.ExpressaoVariavel (A.VarSimples
nome, tipo), tipo)
80 | Amb.EntFun _ ->
81 let msg = "nome de funcao usado como nome de variavel: "
^ id in
82 failwith (msg_erro nome msg)
83 )
84 with Not_found ->
85 let msg = "A variavel " ^ id ^ " nao foi declarada" in
87 )
88 (* | _ -> failwith "infere_exp: no implementado" *)
89 )
90 | S.ExpressaoOperador (op, esq, dir) ->
91 let (esq, tesq) = infere_exp amb esq
92 and (dir, tdir) = infere_exp amb dir in
93
94 let verifica_aritmetico () =
95 (match tesq with
96 A.TipoInteger ->
97 let _ = mesmo_tipo (snd op)
98 "O operando esquerdo eh do tipo %s mas o direito eh
do tipo %s"
99 tesq tdir
100 in tesq (* O tipo da expresso aritmtica como um todo *)
101
102 | A.TipoReal ->
104 "O operando esquerdo eh do tipo %s mas o direito eh
do tipo %s"
105 tesq tdir
106 in tesq (* O tipo da expresso aritmtica como um todo *)
107
108 | t -> let msg = "um operador aritmetico nao pode ser usado com o
tipo " ^
109 (nome_tipo t)
110 in failwith (msg_erro_pos (snd op) msg)
111 )
112
113 and verifica_relacional () =
114 (match tesq with
115 A.TipoInteger
116 | A.TipoReal
117 | A.TipoString ->
119 "O operando esquerdo eh do tipo %s mas o direito eh do
tipo %s"
120 tesq tdir
4.0
121 in A.TipoBool (* O tipo da expresso relacional sempre booleano

*)
122
123 | t -> let msg = "um operador relacional nao pode ser usado com o
tipo " ^
124 (nome_tipo t)
126 )
127
128 and verifica_logico () =
130 A.TipoBool ->
tipo %s"
133 tesq tdir
134 in A.TipoBool (* O tipo da expresso lgica sempre booleano *)
135
136 | t -> let msg = "um operador logico nao pode ser usado com o tipo
" ^
137 (nome_tipo t)
139 )
140 (*
141 and verifica_cadeia () =
143 A.TipoString ->
tipo %s"
146 tesq tdir
147 in A.TipoString (* O tipo da expresso relacional sempre string
*)
148
149 | t -> let msg = "um operador relacional nao pode ser usado com o
tipo " ^
150 (nome_tipo t)
152 )
153 *)
154 in
155 let op = fst op in
156 let tinf = (match (classifica op) with
157 Aritmetico -> verifica_aritmetico ()
158 | Relacional -> verifica_relacional ()
159 | Logico -> verifica_logico ()
160 (* | Cadeia -> verifica_cadeia () *)
161 )
162 in
163 (T.ExpressaoOperador ((op,tinf), (esq, tesq), (dir, tdir)), tinf)
164
165 | S.ExpressaoChamadaFuncao (nome, args) ->
166 let rec verifica_parametros ags ps fs =
167 match (ags, ps, fs) with
168 (a::ags), (p::ps), (f::fs) ->
169 let _ = mesmo_tipo (posicao a)
170 "O parametro eh do tipo %s mas deveria ser do tipo %s
" p f
171 in verifica_parametros ags ps fs
4.0
172 | [], [], [] -> ()

173 | _ -> failwith (msg_erro nome "Numero incorreto de parametros")
174 in
176 try
177 begin
178 let open Amb in
179
180 match (Amb.busca amb id) with
181 (* verifica se 'nome' est associada a uma funo *)
182 Amb.EntFun {tipo_fn; formais} ->
183 (* Infere o tipo de cada um dos argumentos *)
184 let argst = List.map (infere_exp amb) args
185 (* Obtem o tipo de cada parmetro formal *)
186 and tipos_formais = List.map snd formais in
187 (* Verifica se o tipo de cada argumento confere com o tipo
declarado *)
188 (* do parmetro formal correspondente.
*)
189 let _ = verifica_parametros args (List.map snd argst)
tipos_formais
190 in (T.ExpressaoChamadaFuncao (id, (List.map fst argst),
tipo_fn), tipo_fn)
191 | Amb.EntVar _ -> (* Se estiver associada a uma varivel, falhe
*)
192 let msg = id ^ " eh uma variavel e nao uma funcao" in
194 end
195 with Not_found ->
196 let msg = "Nao existe a funcao de nome " ^ id in
198 let rec verifica_cmd amb tiporet cmd =
199 let open A in
200 match cmd with
201
202 CmdReturn exp ->
203 (match exp with
204 (* Se a funo no retornar nada, verifica se ela foi declarada como
void *)
205 None ->
206 let _ = mesmo_tipo (Lexing.dummy_pos)
207 "O tipo retornado eh %s mas foi declarado como %s"
208 TipoVoid tiporet
209 in CmdReturn None
210 | Some e ->
211 (* Verifica se o tipo inferido para a expresso de retorno confere
com o *)
212 (* tipo declarado para a funo.
*)
213 let (e1,tinf) = infere_exp amb e in
214 let _ = mesmo_tipo (posicao e)
215 "O tipo retornado eh %s mas foi declarado
como %s"
216 tinf tiporet
217 in CmdReturn (Some e1)
218 )
219 | CmdIf (teste, entao, senao) ->
220 let (teste1,tinf) = infere_exp amb teste in
221 (* O tipo inferido para a expresso 'teste' do condicional deve ser
4.0
booleano *)
222 let _ = mesmo_tipo (posicao teste)
223 "O teste do if deveria ser do tipo %s e nao %s"
224 TipoBool tinf in
225 (* Verifica a validade de cada comando do bloco 'ento' *)
226 let entao1 = List.map (verifica_cmd amb tiporet) entao in
227 (* Verifica a validade de cada comando do bloco 'seno', se houver *)
228 let senao1 =
229 match senao with
230 None -> None
231 | Some bloco -> Some (List.map (verifica_cmd amb tiporet) bloco)
232 in
233 CmdIf (teste1, entao1, senao1)
234
235
236 (*
237 | ExpressaoVariavel v -> (match v with
238 | A.VarSimples (_,pos) -> pos
239 )
240 *)
241
242 | CmdAtrib (elem, exp) -> let open Amb in
243 let (exp2, tdir) = infere_exp amb exp in
244 (match elem with
245 S.ExpressaoVariavel v ->
246 ( match v with
247 | A.VarSimples(ch,_) ->
248 ( try
249 (match (Amb.busca amb ch ) with
250 Amb.EntVar tipo -> let (elem_tip, telem) =
infere_exp amb elem
251 and (exp_tip, ttip) = infere_exp amb exp
in
252 let _ = mesmo_tipo (posicao elem) "
Atribuicao com tipos diferentes: %s = %
s"
253 telem ttip
254 in CmdAtrib (elem_tip, exp_tip)
255
256 | Amb.EntFun { tipo_fn; _} -> ( match tipo_fn
with
257 TipoVoid -> let _ = mesmo_tipo (
posicao elem) "Funcao do tipo %
s nao pode receber o valor do
tipo %s"
258 TipoVoid tdir in
259 CmdReturn (None)
260 | tipo -> let _ = mesmo_tipo (
posicao elem) "Funcao do tipo %s
nao pode receber o valor do tipo
%s"
261 tipo tdir in
262 CmdReturn (Some exp2)
263
264 )
265 )
266 with Not_found -> failwith ("A varivel " ^ ch ^ " no
foi declarada")
267 )
4.0
268 )
269 | _ -> failwith ""
270 )
271
272
273 | CmdCase (teste, corpo, senao) ->
274 (* Infere o tipo da variavel a ser tomada no case *)
276
277 (* Verifica a validade de cada comando do bloco 'corpo' *)
278 let corpo1 = List.map (verifica_cmd amb tiporet) corpo in
279
280 (* Verifica a validade de cada comando do bloco 'seno', se houver *)
281 let senao1 =
282 match senao with
283 None -> None
284 | Some bloco -> Some (List.map (verifica_cmd amb tiporet) bloco)
285 in
286 CmdCase(teste1, corpo1, senao1)
287
288 | CmdOpCase (expressao, comando) ->
289 (* Verifica a validade da expressao *)
290 let (expressao1,tinf) = infere_exp amb expressao in
291
292 (* Verifica a validade de cada comando do bloco 'comandos' *)
293 let comando1 = verifica_cmd amb tiporet comando in
294 CmdOpCase (expressao1, comando1)
295
296 | CmdFor (variavel, valorInicial, valorFinal, corpo) ->

297 (* Infere o tipo da variavel *)
298 let (variavel1, tvariavel) = infere_exp amb variavel
299
300 (* Infere o tipo do valorInicial *)
301 and (valorInicial1, tvalorInicial) = infere_exp amb valorInicial in
302
303 let _ = mesmo_tipo (posicao variavel) "Variavel de controle do tipo %s e
valor inicial do tipo %s" tvariavel tvalorInicial in
304
305
306 (* Infere o tipo do valorFinal *)
307 let (valorFinal1, tvalorFinal) = infere_exp amb valorFinal in
308
309 let _ = mesmo_tipo (posicao valorInicial) "Valor inicial do tipo %s e
final do tipo %s" tvalorInicial tvalorFinal in
310
311 (* Verifica a validade de cada comando do bloco 'corpo' *)
312 let corpo1 = List.map (verifica_cmd amb tiporet) corpo in
313
314 CmdFor(variavel1, valorInicial1, valorFinal1, corpo1)
315
316
317 | CmdWhile (teste, comandos) ->
319 (* O tipo inferido para a expresso 'teste' do condicional deve ser
booleano *)
320 let _ = mesmo_tipo (posicao teste)
321 "O teste do if deveria ser do tipo %s e nao %s"
322 TipoBool tinf in
323
4.0
324 (* Verifica a validade de cada comando do bloco 'comandos' *)

325 let comandos1 = List.map (verifica_cmd amb tiporet) comandos in
326 CmdWhile(teste1, comandos1)
327
328 | CmdChamFunc exp ->

329 let (exp,tinf) = infere_exp amb exp in
330 CmdChamFunc exp
331
332 | CmdReadln exps ->
333 (* Verifica o tipo de cada argumento da funo 'entrada' *)
334 let exps = List.map (infere_exp amb) exps in
335 CmdReadln (List.map fst exps)
336
337 | CmdWrite exps ->
338 (* Verifica o tipo de cada argumento da funo 'saida' *)
339 let exps = List.map (infere_exp amb) exps in
340 CmdWrite (List.map fst exps)
341
342 and verifica_fun amb ast =
343 let open A in
344 match ast with
345 A.DecFun {fn_nome; fn_tiporet; fn_formais; fn_locais; fn_corpo} ->
346 (* Estende o ambiente global, adicionando um ambiente local *)
347 let ambfn = Amb.novo_escopo amb in
348 (* Insere os parmetros no novo ambiente *)
349 let insere_parametro (v,t) = Amb.insere_param ambfn (fst v) t in
350 let _ = List.iter insere_parametro fn_formais in
351 (* Insere as variveis locais no novo ambiente *)
352 let insere_local = function
353 (DecVar (v,t)) -> Amb.insere_local ambfn (fst v) t in
354 let _ = List.iter insere_local fn_locais in
355 (* Verifica cada comando presente no corpo da funo usando o novo
ambiente *)
356 let corpo_tipado = List.map (verifica_cmd ambfn fn_tiporet) fn_corpo
in
357 A.DecFun {fn_nome; fn_tiporet; fn_formais; fn_locais; fn_corpo =
corpo_tipado}
358
359
360 let rec verifica_dup xs =
361 match xs with
362 [] -> []
363 | (nome,t)::xs ->
365 if (List.for_all (fun (n,t) -> (fst n) <> id) xs)
366 then (id, t) :: verifica_dup xs
367 else let msg = "Parametro duplicado " ^ id in
369
370 let insere_declaracao_var amb dec =
371 let open A in
372 match dec with
373 DecVar (nome, tipo) -> Amb.insere_local amb (fst nome) tipo
374
375 let insere_declaracao_fun amb dec =
376 let open A in
377 match dec with
378 DecFun {fn_nome; fn_tiporet; fn_formais; fn_corpo} ->
379 (* Verifica se no h parmetros duplicados *)
4.0
380 let formais = verifica_dup fn_formais in

381 let nome = fst fn_nome in
382 Amb.insere_fun amb nome formais fn_tiporet
383
384
385 (* Lista de cabealhos das funes pr definidas *)
386 let fn_predefs = let open A in [
387 ("readln", [("x", TipoInteger); ("y", TipoInteger)], TipoVoid);
388 ("write", [("x", TipoInteger); ("y", TipoInteger)], TipoVoid);
389 ("writeln", [("x", TipoInteger); ("y", TipoInteger)], TipoVoid)
390 ]
391
392 (* insere as funes pr definidas no ambiente global *)
393 let declara_predefinidas amb =
394 List.iter (fun (n,ps,tr) -> Amb.insere_fun amb n ps tr) fn_predefs
395
396 let semantico ast =

397 (* cria ambiente global inicialmente vazio *)
398 let amb_global = Amb.novo_amb [] in
399 let _ = declara_predefinidas amb_global in
400 let (A.Programa (nome, decs_globais, decs_funs, corpo)) = ast in
401 let _ = List.iter (insere_declaracao_var amb_global) decs_globais in
402 let _ = List.iter (insere_declaracao_fun amb_global) decs_funs in
403 (* Verificao de tipos nas funes *)
404 let decs_funs = List.map (verifica_fun amb_global) decs_funs in
405 (* Verificao de tipos na funo principal *)
406 let corpo = List.map (verifica_cmd amb_global A.TipoVoid) corpo in
407 (A.Programa (nome, decs_globais, decs_funs, corpo), amb_global)
Captulo 5
Interprete
Interpretadores e compiladores tm muito em comum, e executam muitas das mesmas

tarefas. Ambos analisam o programa de entrada e determinam se ou no um programa
vlido; constroem um modelo interno da estrutura e significado do programa; determinam
onde armazenar valores durante a execuo. No entanto, interpretar o cdigo para produzir
um resultado bastante diferente de emitir um programa traduzido que pode ser executado
para produzir o resultado. Eis o programa em Ocaml do interprete:
Listagem 5.1: interprete.ml
1 module Amb = AmbInterp
2 module A = Ast
3 module S = Sast
4 module T = Tast
5
6 exception Valor_de_retorno of T.expressao
7
8 let obtem_nome_tipo_var exp = let open T in
9 match exp with
10 | ExpressaoVariavel (v,tipo) ->
11 (match v with
12 | A.VarSimples (nome,_) -> (nome,tipo)
13 | _ -> failwith "obtem_nome_tipo_var: nao implementado"
14 )
15 | _ -> failwith "obtem_nome_tipo_var: nao eh variavel"
16
17 let pega_int exp =
18 match exp with
19 | T.ExpressaoInteger (i,_) -> i
20 | _ -> failwith "pega_int: nao eh inteiro"
21
22 let pega_real exp =
23 match exp with
24 | T.ExpressaoReal (i,_) -> i
25 | _ -> failwith "pega_real: nao eh real"
26
27 let pega_string exp =
28 match exp with
29 | T.ExpressaoString (s,_) -> s
30 | _ -> failwith "pega_string: nao eh string"
31
32 let pega_bool exp =
78
5.0
33 match exp with

34 | T.ExpressaoBool (b,_) -> b
35 | _ -> failwith "pega_bool: nao eh booleano"
36
37 type classe_op = Aritmetico | Relacional | Logico

38
39 let classifica op =
40 let open A in
41 match op with
42 | Not
43 | Or
44 | And -> Logico
45 | Menor
46 | MenorIgual
47 | Maior
48 | MaiorIgual
49 | Igual
50 | Diferente -> Relacional
51 | Mod
52 | Mais
53 | Menos
54 | Multiplicacao
55 | Divisao -> Aritmetico
56
57
58 let rec interpreta_exp amb exp =
59 let open A in
60 let open T in
61 match exp with
62 | ExpressaoInteger _
63 | ExpressaoString _
64 | ExpressaoReal _
65 | ExpressaoVoid
66 | ExpressaoBool _ -> exp
67 | ExpressaoVariavel _ ->
68 let (id,tipo) = obtem_nome_tipo_var exp in
69 (* Tenta encontrar o valor da varivel no escopo local, se no *)
70 (* encontrar, tenta novamente no escopo que engloba o atual. Prossegue
-se *)
71 (* assim at encontrar o valor em algum escopo englobante ou at *)
72 (* encontrar o escopo global. Se em algum lugar for encontrado,
*)
73 (* devolve-se o valor. Em caso contrrio, devolve uma exceo *)
74 (match (Amb.busca amb id) with
75 | Amb.EntVar (tipo, v) ->
76 (match v with
77 | None -> failwith ("varivel nao inicializada: " ^ id)
78 | Some valor -> valor
79 )
80 | _ -> failwith "interpreta_exp: expvar"
81 )
82 | ExpressaoOperador ((op,top), (esq, tesq), (dir,tdir)) ->
83 let vesq = interpreta_exp amb esq
84 and vdir = interpreta_exp amb dir in
85
86 let interpreta_aritmetico () =
87 (match tesq with
88 | TipoInteger ->
89 (match op with
5.0
90 | Mais -> ExpressaoInteger (pega_int vesq + pega_int vdir, top)

91 | Menos -> ExpressaoInteger (pega_int vesq - pega_int vdir, top)
92 | Multiplicacao -> ExpressaoInteger (pega_int vesq * pega_int
vdir, top)
93 | Divisao -> ExpressaoInteger (pega_int vesq / pega_int vdir,
top)
94 | Mod -> ExpressaoInteger (pega_int vesq mod pega_int vdir, top)
95 | _ -> failwith "interpreta_aritmetico"
96 )
97 | TipoReal ->
98 (match op with
99 | Mais -> ExpressaoReal (pega_real vesq +. pega_real vdir, top)
100 | Menos -> ExpressaoReal (pega_real vesq -. pega_real vdir, top)
101 | Multiplicacao -> ExpressaoReal (pega_real vesq *. pega_real
vdir, top)
102 | Divisao -> ExpressaoReal (pega_real vesq /. pega_real vdir,
top)
104 )
106 )
107
108 and interpreta_relacional () =

110 | TipoInteger ->
111 (match op with
112 | Menor -> ExpressaoBool (pega_int vesq < pega_int vdir, top)
113 | MenorIgual -> ExpressaoBool (pega_int vesq <= pega_int vdir, top)
114 | Maior -> ExpressaoBool (pega_int vesq > pega_int vdir, top)
115 | MaiorIgual -> ExpressaoBool (pega_int vesq >= pega_int vdir, top)
116 | Igual -> ExpressaoBool (pega_int vesq == pega_int vdir, top)
117 | Diferente -> ExpressaoBool (pega_int vesq != pega_int vdir,
top)
118 | _ -> failwith "interpreta_relacional"
119 )
120 | TipoReal ->
121 (match op with
122 | Menor -> ExpressaoBool (pega_real vesq < pega_real vdir, top)
123 | MenorIgual -> ExpressaoBool (pega_real vesq <= pega_real vdir, top
)
124 | Maior -> ExpressaoBool (pega_real vesq > pega_real vdir, top)
125 | MaiorIgual -> ExpressaoBool (pega_real vesq >= pega_real vdir, top
)
126 | Igual -> ExpressaoBool (pega_real vesq == pega_real vdir,
top)
127 | Diferente -> ExpressaoBool (pega_real vesq != pega_real vdir
, top)
129 )
130 | TipoString ->
131 (match op with
132 | Menor -> ExpressaoBool (pega_string vesq < pega_string vdir,
top)
133 | MenorIgual -> ExpressaoBool (pega_string vesq <= pega_string vdir,
top)
134 | Maior -> ExpressaoBool (pega_string vesq > pega_string vdir,
top)
135 | MaiorIgual -> ExpressaoBool (pega_string vesq >= pega_string vdir,
top)
5.0
136 | Igual -> ExpressaoBool (pega_string vesq == pega_string vdir,

top)
137 | Diferente -> ExpressaoBool (pega_string vesq != pega_string
vdir, top)
139 )
140 | TipoBool ->
141 (match op with
142 | Menor -> ExpressaoBool (pega_bool vesq < pega_bool vdir, top)
143 | MenorIgual -> ExpressaoBool (pega_bool vesq <= pega_bool vdir, top
)
144 | Maior -> ExpressaoBool (pega_bool vesq > pega_bool vdir, top)
145 | MaiorIgual -> ExpressaoBool (pega_bool vesq >= pega_bool vdir, top
)
146 | Igual -> ExpressaoBool (pega_bool vesq == pega_bool vdir, top)
147 | Diferente -> ExpressaoBool (pega_bool vesq != pega_bool vdir,
top)
149 )
151 )
152
153 and interpreta_logico () =

155 | TipoBool ->
156 (match op with
157 | Not -> ExpressaoBool ( not ( pega_bool vdir ), top)
158 | Or -> ExpressaoBool (pega_bool vesq || pega_bool vdir, top)
159 | And -> ExpressaoBool (pega_bool vesq && pega_bool vdir, top)
160 | _ -> failwith "interpreta_logico"
161 )
162 | _ -> failwith "interpreta_logico"
163 )
164 (*
165 and interpreta_cadeia () =
167 | TipoString ->
168 (match op with
169 | Concat -> ExpString (pega_string vesq ^ pega_string vdir, top)
170 | _ -> failwith "interpreta_cadeia"
171 )
172 | _ -> failwith "interpreta_cadeia"
173 )
174 *)
175 in
176 let valor = (match (classifica op) with
177 Aritmetico -> interpreta_aritmetico ()
178 | Relacional -> interpreta_relacional ()
179 | Logico -> interpreta_logico ()
180 (* | Cadeia -> interpreta_cadeia () *)
181 )
182 in
183 valor
184
185 | ExpressaoChamadaFuncao (id, args, tipo) ->
186 let open Amb in
187 ( match (Amb.busca amb id) with
188 | Amb.EntFun {tipo_fn; formais; locais; corpo} ->
189 (* Interpreta cada um dos argumentos *)
5.0
190 let vargs = List.map (interpreta_exp amb) args in

191 (* Associa os argumentos aos parmetros formais *)
192 let vformais = List.map2 (fun (n,t) v -> (n, t, Some v))
formais vargs
193 in interpreta_fun amb id vformais locais corpo
194 | _ -> failwith "interpreta_exp: expchamada"
195 )
196
197 and interpreta_fun amb fn_nome fn_formais fn_locais fn_corpo =
198 let open A in
199 (* Estende o ambiente global, adicionando um ambiente local *)
200 let ambfn = Amb.novo_escopo amb in
201 let insere_local d =
202 match d with
203 (DecVar (v,t)) -> Amb.insere_local ambfn (fst v) t None
204 in
205 (* Associa os argumentos aos parmetros e insere no novo ambiente *)
206 let insere_parametro (n,t,v) = Amb.insere_param ambfn n t v in
207 let _ = List.iter insere_parametro fn_formais in
208 (* Insere as variveis locais no novo ambiente *)
209 let _ = List.iter insere_local fn_locais in
210 (* Interpreta cada comando presente no corpo da funo usando o novo
211 ambiente *)
212 try
213 let _ = List.iter (interpreta_cmd ambfn) fn_corpo in T.ExpressaoVoid
214 with
215 Valor_de_retorno expret -> expret
216
217 and interpreta_cmd amb cmd =

218 let open A in
219 let open T in
220 match cmd with
221 CmdReturn exp ->
222 (* Levantar uma exceo foi necessria pois, pela semntica do comando
de
223 retorno, sempre que ele for encontrado em uma funo, a computao
224 deve parar retornando o valor indicado, sem realizar os demais
comandos.
225 *)
226 (match exp with
227 (* Se a funo no retornar nada, ento retorne ExpVoid *)
228 None -> raise (Valor_de_retorno ExpressaoVoid)
229 | Some e ->
230 (* Avalia a expresso e retorne o resultado *)
231 let e1 = interpreta_exp amb e in
232 raise (Valor_de_retorno e1)
233 )
234
235 | CmdIf (teste, entao, senao) ->
236 let teste1 = interpreta_exp amb teste in
237 (match teste1 with
238 ExpressaoBool (true,_) ->
239 (* Interpreta cada comando do bloco 'ento' *)
240 List.iter (interpreta_cmd amb) entao
241 | _ ->
242 (* Interpreta cada comando do bloco 'seno', se houver *)
243 (match senao with
244 None -> ()
245 | Some bloco -> List.iter (interpreta_cmd amb) bloco
5.0
246 )
247 )
248
249
250 (*
251 | CmdAtrib (elem, exp) ->
252 (* Interpreta o lado direito da atribuio *)
253 let exp = interpreta_exp amb exp
254 (* Faz o mesmo para o lado esquerdo *)
255 and (elem1,tipo) = obtem_nome_tipo_var elem in
256 Amb.atualiza_var amb elem1 tipo (Some exp)
257 *)
258
259 | CmdAtrib (elem, exp) ->
260 (* Interpreta o lado direito da atribuio *)
261 let exp = interpreta_exp amb exp
262 (* Faz o mesmo para o lado esquerdo *)
263 and (elem1,tipo) = obtem_nome_tipo_var elem in
264 Amb.atualiza_var amb elem1 tipo (Some exp)
265
266 | CmdChamFunc exp -> ignore ( interpreta_exp amb exp )
267
268 | CmdWhile (teste, comandos) ->

269 let teste1 = interpreta_exp amb teste in
272 (* Interpreta cada comando do bloco 'comandos' *)
273 let _ = List.iter (interpreta_cmd amb) comandos in interpreta_cmd
amb cmd
274 | ExpressaoBool (false,_) -> ignore()
275 | _ -> failwith "Teste de while invalido"
276 )
277
278 | CmdFor (variavel, valorInicial, valorFinal, corpo) ->
279
280 (* Interpreta o valorInicial*)
281 let valorInicial1 = interpreta_exp amb valorInicial and
282
283 (* Faz o mesmo para a variavel *)
284 (variavel1,tipo) = obtem_nome_tipo_var variavel in
285 let _ = Amb.atualiza_var amb variavel1 tipo (Some valorInicial1) in
286
287
288
289 let exp = ExpressaoOperador ((MenorIgual, tipo), (variavel, tipo), (
valorFinal,tipo)) in
290 let teste1 = interpreta_exp amb exp in
292 (* Interpreta cada comando do bloco 'corpo' *)
294 (match valorInicial1 with
295 ExpressaoInteger(val1,_) ->
296 (match valorFinal with
297 ExpressaoInteger(val2,_) ->
298 for var = val1 to val2 do
299 List.iter (interpreta_cmd amb) corpo
300 done
302 )
5.0

304 )
305 | ExpressaoBool(false,_) -> ignore()
307 )
308
309 | CmdOpCase (expressao, comando) -> ignore()
310 | CmdCase (teste, corpo, senao) -> ignore()
311 | CmdReadln exps ->
312 (* Obtem os nomes e os tipos de cada um dos argumentos *)
313 let nts = List.map (obtem_nome_tipo_var) exps in
314 let leia_var (nome,tipo) =
315 let valor =
316 (match tipo with
317 | A.TipoInteger -> T.ExpressaoInteger (read_int (), tipo)
318 | A.TipoString -> T.ExpressaoString (read_line (), tipo)
319 | A.TipoReal -> T.ExpressaoReal (read_float(), tipo)
320 | _ -> failwith "leia_var: nao implementado"
321 )
322 in Amb.atualiza_var amb nome tipo (Some valor)
323 in
324 (* L o valor para cada argumento e atualiza o ambiente *)
325 List.iter leia_var nts
326
327 | CmdWrite exps ->
328 (* Interpreta cada argumento da funo 'saida' *)
329 let exps = List.map (interpreta_exp amb) exps in
330 let imprima exp =
331 (match exp with
332 | T.ExpressaoInteger (n,_) -> let _ = print_int n in
print_string " "
333 | T.ExpressaoString (s,_) -> let _ = print_string s in print_string
" "
334 | T.ExpressaoBool (b,_) ->
335 let _ = print_string (if b then "true" else "false")
336 in print_string " "
337 | T.ExpressaoReal (n,_) -> let _ = print_float n in print_string " "
338 | _ -> failwith "imprima: nao implementado"
339 )
340 in
341 let _ = List.iter imprima exps in
342 print_newline ()
343
344 let insere_declaracao_var amb dec =
345 match dec with
346 A.DecVar (nome, tipo) -> Amb.insere_local amb (fst nome) tipo
None
347
348 let insere_declaracao_fun amb dec =
349 let open A in
350 match dec with
351 DecFun {fn_nome; fn_tiporet; fn_formais; fn_locais; fn_corpo} ->
352 let nome = fst fn_nome in
353 let formais = List.map (fun (n,t) -> ((fst n), t)) fn_formais in
354 Amb.insere_fun amb nome formais fn_locais fn_tiporet fn_corpo
355
356
357 (* Lista de cabealhos das funes pr definidas *)
358 let fn_predefs = let open A in [
5.0
359 ("readln", [("x", TipoInteger); ("y", TipoInteger)], TipoVoid, []);

360 ("write", [("x", TipoInteger); ("y", TipoInteger); ("x", TipoReal); ("y
", TipoReal)], TipoVoid, []);
361 ("writeln", [("x", TipoInteger); ("y", TipoInteger); ("x", TipoReal);
("y", TipoReal)], TipoVoid, [])
362 ]
363
364 (* insere as funes pr definidas no ambiente global *)
365 let declara_predefinidas amb =
366 List.iter (fun (n,ps,tr,c) -> Amb.insere_fun amb n ps [] tr c)
fn_predefs
367
368 let interprete ast =
369 (* cria ambiente global inicialmente vazio *)
370 let amb_global = Amb.novo_amb [] in
371 let _ = declara_predefinidas amb_global in
372 let (A.Programa (nome, decs_globais, decs_funs, corpo)) = ast in
373 let _ = List.iter (insere_declaracao_var amb_global) decs_globais in
374 let _ = List.iter (insere_declaracao_fun amb_global) decs_funs in
375 (* Interpreta a funo principal *)
376 let resultado = List.iter (interpreta_cmd amb_global) corpo in
377 resultado

Tarefa

Uploaded by

Document Information

Original Title

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

Tarefa

Uploaded by

Copyright:

Available Formats

Construo de um compilador de MiniPascal para CLR

usando Objective Caml

Hugo Gustavo Valin Oliveira da Cunha

A Common Language Runtime (CLR) o componente de mquina virtual da plata-

A especificao do CLI permite que rodemos aplicaes escritas em uma linguagem de

1.1 Linha de comando

Para essa primeira parte do projeto utilizei os seguintes componentes:

Sistema Operacional Linux Desktop 4.10.0-32-generic 36 16.04.1-Ubuntu i686 i686 i686

Mono JIT compiler version 4.2.1 (Debian 4.2.1.102+dfsg2-7ubuntu4) Copyright (C)

Linguagem de programao interpretada, multi-paragdima, C, desenvolvida pela Mi-

Para fazer a instalao do sistema utilizei o seguintes comandos no terminal dentro do

J para fazer o desassembly utilizei o seguinte comando:

1.2 Linguagem Assembly

O assembly da plataforma CLR um conjuntode instrues baseado em pilha e orientado

add: retira os dois elementos do topo da pilha e coloca o resultado no topo.

arglist: retorna o identificador da lista de argumentos para o mtodo atual.

beq pula para o endereo se os elementos topo da pilha so iguais

bge.un. : igual ao bge, mas a comparao feita sem sinal.

ble: pula para o endereo se o topo menor ou igual ao seu antecessor.

ble.un: igual ao ble, mas a comparao feita sem sinal.

blt : pula pra o endereo se o o topo menor que seu antecessor.

blt.un: igual ao blt, mas a comparao feita sem sinal.

bne: pula para o endereo se o topo no for igual ou no ordenada.

bne.un: igual ao bne, mas a comparao feita sem sinal.

br: salto incondicional

break: instruo de breakpoint

brfalse: pula para o endereco se falso, nulo, ou zero.

brtrue: pula para o endereo se verdadeiro, diferente de zero, ou no nulo.

call: chamada de mtodo.

calli: chamada de mtodo indireto.

ceq: compara se igual

cgt: compara se maior que.

cgt.un: igual ao cgt, mas a comparao feita sem sinal.

clt: compara se menor que

clt.un igual ao clt, mas a comparao feita sem sinal.

conv : converso de dados.

conv.ovf: igual ao conv, mas com sinalizao de overflow.

conv.ovf.un: igual ao conv.of, mas a comparao feita sem sinal.

cpbllc: copia dados da memria para a memria.

div.un: igual ao div, mas a comparao feita sem sinal.

dup: duplica o valor da pilha.

jmp: pula para um mtodo.

jmpi: pular para um ponteiro de mtodo.

ldarg: carrega um argumento na pilha.

ldarga: carrega um argumento a partir de um endereo.

ldc: carrega uma constante numrica.

Idelem: carrega um elemento do vetor no index para topo da pilha.

Idelema: carrega o endereco do vetor na posicao index na pilha.

Idstr: poe no topo da pilha a string.

mul: multiplica os dois valores de cima da pilha e empilha o resultado.

mul.ovf: igual ao mul, mas feita sinalizao de overflow.

neg: altera o sinal do elemento do topo da pilha.

not: inverte os bits do elemento do topo da pilha.

r: faz um ou lgico bit a bit dos elementos do topo, empilhando o resultado.

pop: desempilha a pilha.

rem.un: igual ao rem, mas a comparao feita sem sinal.

shl: deslocamento de bits a esquerda.

shr: deslocamento de bits a direita.

starg: retira o elemento do topo da pilha e coloca em um argumento.

sizeof: carrega o tamanho em bits do topo na pilha.

sub: subtrai o segundo valor do primeiro e empilha o resultado.

sub.ovf: igual ao sub, mas com a sinalizao de overflow.

1.3 Cdigos de programas em Pascal