S → DB
D → final id “=“ [“-”] const”;” [1][5] |
Tipo id1 [6]
[“=“ [“-”[15]] const [16][7]]
[2] {“,” id2 [6][“=“ [-[15]]
const[16][7]] [3]}*
“;”
Tipo → int [8]| byte [9]|
string [10]| boolean[11]
B → begin {C}* end
C → id[4] =
Exp [12]“;”
[15]| while [16] Exp [13] [17] ( C | B )[18] |
If [19]Exp [13]
[20] (
C | B ) [else [21]( C | B ) ] [22]|
“;” |
readln”,” id[4] [14]“;” | (write | writeln)”,” Exp [17]{“,”
Exp [17] }*
“;”
Exp → ExpS1 [18] [12] [
( “<“ [20][13.1]|
“>“ [20][13.2]|
“<=“ [20][13.3]|
“>=“ [20][13.4]|
“==“ [21][13.5]| “!=“ [20][13.6])
ExpS2 [19]
[22] [14]]
ExpS → [ “-”[8]] T1 [23][9]{
( “+” [27][10.1]|
“-” [28][10.2]| or [28][10.3])
T2 [24][30][11]}*
T → F1 [25][5]{
( “*” [29][6.1]|
“/” [29][36][6.2]| and [29][6.3])
F2 [26][31][7]}*
F → “(“ Exp [32]“)”
[3]| not F1 [33][4] | const[34][2] | id [4][35][1]
[1] {se id.classe != vazio então ERRO
senao id.classe = classe_const }
[2] { se id1.classe
!= vazio então ERRO
senao id1.classe
= classe_var}
[3] { se id2.classe
!= vazio então ERRO
senao id2.classe
= classe_var}
[4] { se id.classe = vazio então ERRO}
[5] { id.tipo := const.tipo }
[6] { id.tipo =
Tipo.t }
[7] { se id1.tipo
!= const.tipo E (id1.tipo != inteiro E const.tipo != byte OU
id1.tipo != byte E const.tipo != inteiro) então
ERRO }
[8] { Tipo.t = inteiro }
[9]{ Tipo.t = byte }
[10] { Tipo.t = string }
[11]{ Tipo.t = boolean }
[12] { se id1.tipo
!= exp.tipo E (id1.tipo != inteiro E exp.tipo != byte OU id1.tipo
!= byte E exp.tipo != inteiro) então ERRO }
[13] { se exp.tipo != logico então ERRO }
[14] { se id.tipo != inteiro E id.tipo != byte E
id.tipo != string então ERRO }
[15] { D.neg = true }
[16] {
se D.neg = true
então id.tipo = inteiro }
[17] { se exp.tipo != inteiro E exp.tipo != byte E
exp.tipo != string então ERRO }
[18] { Exp.tipo = Exps.tipo }
[19] { se Exp.tipo != inteiro E ExpS.tipo != inteiro E
Exp.tipo != byte E ExpS.tipo != byte E (Exp.tipo != inteiro E Exps.tipo != byte
OU Exp.tipo != byte E Exps.tipo != inteiro)
então ERRO }
[20] { se Exps1.tipo
= string então ERRO }
[21] { se Exps1.tipo
!= string E Exps1.tipo != inteiro E Exps1.tipo
!= byte então ERRO}
[22] { Exp.tipo = logico }
[23] { Exps.tipo = T1.tipo
}
[24] {
se Exps.tipo != T2.tipo E (Exps.tipo != inteiro E T2.tipo
!= byte OU Exps.tipo != byte E T2.tipo != inteiro) então
ERRO }
[25] { T.tipo = F1.tipo
}
[26] { se T.tipo != F2.tipo
E (T.tipo != inteiro E F2.tipo != byte OU T.tipo
!= byte E F2.tipo != inteiro) então ERRO }
[27] { se T1.tipo
!= string E T1.tipo != inteiro E T1.tipo
!= byte então ERRO}
[28] { se T1.tipo
= string então ERRO }
[29] { se F1.tipo
= string então ERRO }
[30] { se T1.tipo
= inteiro E T2.tipo = byte OU se T1.tipo
= byte E T2.tipo = inteiro
então ExpS.tipo = inteiro }
[31] { se F1.tipo
= inteiro E F2.tipo = byte OU se F1.tipo
= byte E F2.tipo = inteiro
então T.tipo = inteiro }
[32] { F.tipo = Exp.tipo }
[33] { se F1.tipo
= string então ERRO
senão F.tipo = F1.tipo}
[34] {
F.tipo = const.tipo }
[35] { F.tipo = id.tipo }
[36] { se (F1.tipo
!= inteiro) então F1.tipo = inteiro
se
(F2.tipo != inteiro) então F2.tipo
= inteiro }
[1] { F.end := id.end }
[2] {se const.tipo=string então
dseg SEGMENT PUBLIC
byte "const.lex$"
dseg ENDS
F.end := cont_dados
cont_dados+= 256
senão
F.end:=NovoTemp
mov regA, const.lex
mov F.end, regA }
[3] { F.end := Exp.end }
[4] { F.end := NovoTemp }
{ mov regA, Fi.end }
{ not regA }
{ mov F.end, regA}
[5] { T.end := F1.end }
[6.1] {T.op = *}
[6.2] {T.op = /}
[6.3] {T.op = and}
[7] { mov ax, DS:[T.end] }
{mov bx, DS:[F2.end] }
{ se T.tipo != inteiro então
cwd
se F2.tipo != inteiro entao
mov cx, DS:[ax]
mov ax, DS:[bx]
cwd
mov DS:[bx], ax
mov DS:[ax], cx}
{se T.op = “*” então
imul bx
senao se T.op = “/” então
idiv bx
senao
and
ax, bx}
{ T.end := NovoTemp }
{ mov DS:[T.end], ax }
[8] { Exps.neg = true }
[9] { se Exps.neg = true
Exps.end = NovoTemp
mov ax, DS:[T1.end]
neg ax
mov DS:[Exps.end], ax}
{ ExpS.end := T1.end }
[10.1] { Exps.op = + }
[10.2] { Exps.op = - }
[10.3] { Exps.op = or }
[11] {
mov ax, DS:[Exps .end] }
{ mov bx, DS:[T2.end] }
{ se Exps.tipo != inteiro então
cwd
se T2.tipo != inteiro entao
mov cx, DS:[ax]
mov ax, DS:[bx]
cwd
mov DS:[bx], ax
mov DS:[ax], cx}
{se Exps.op = “+” então
imul bx
senao se Exps.op = “-” entao
idiv bx
senao
and ax, bx}
{ Exps.end := NovoTemp }
{ mov DS:[Exps.end], ax }
[12] { Exp.end = Exps1.end }
[13.1] { Exp.op = “<” }
[13.2] { Exp.op = “>” }
[13.3] { Exp.op = “<=” }
[13.4] { Exp.op = “>=” }
[13.5] { Exp.op = “==” }
[13.6] { Exp.op = “!=” }
[14] { mov ax, DS:[Exp.end]
mov bx, DS:{Exps2.end]
cwd
mov cx, DS:[ax]
mov ax, DS[bx]
cwd
mov DS:[bx],ax
mov DS:[ax],cx }
{ cmp ax, bx }
{ RotVerdadeiro = NovoRot }
{ se Exp.op = “=” então
je RotVerdadeiro
senao se Exp.op = “!=” então
jne RotVerdadeiro
senao se Exp.op = “<” então
jl RotVerdadeiro
senao se Exp.op = “>” então
jg RotVerdadeiro
senao se Exp.op = “>=” então
jge RotVerdadeiro
senao
jle RotVerdadeiro }
{ mov al, 0 }
{ RotFim = NovoRot }
{ jmp RotFim }
{ RotVerdadeiro: }
{ mov AL, 0FFh }
{ RotFim: }
{ Exp.end:=NovoTemp }
{ Exp.tipo:=TIPOLÓGICO }
{ mov Exp.end, AL }
[15] { mov ax, DS:[Exp.end] }
{ se id.tipo != Exp.tipo então
cwd }
{ mov DS:[id.end], ax }
[16] { RotInicio:=NovoRot }
{ RotFim:=NovoRot }
{ RotInicio: }
[17] { mov ax, DS:[Exp.end] }
{ cmp ax, 0
je RotFim }
[18] { jmp RotInicio }
{ RotFim: }
[19] { RotFalso:=NovoRot }
{ RotFim:=NovoRot }
[20] { mov ax, DS:[Exp.end] }
{ cmp ax, 0
je RotFalso }
[21] { jmp RotFim }
{ RotFalso: }
[22] { RotFim: }
