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:[F₂.end] }

{ se T.tipo != inteiro então

         cwd

se F₂.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:[T₁.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:[T₂.end] }

{ se Exps.tipo != inteiro então

    cwd

se T₂.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 = Exps₁.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:{Exps₂.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: }