Pesquisar neste blog

25/10/2019

Arquitetura para Assembly



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: }

Nenhum comentário: