API tools faq
paste
Advertisement
Gabriel_Rofl

SYSTEMV1.s

Gabriel_Rofl
Apr 30th, 2018
133
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
6502 ACME Cross Assembler 49.32 KB | None | 0 0
raw download clone embed print report
  1. #########################################################################
  2. # Rotina de tratamento de excecao e interrupcao   v1.0    #
  3. # Lembre-se: Os ecalls originais do Rars possuem precedencia sobre #
  4. #        estes definidos aqui         #
  5. # Os ecalls 1XX usam o BitMap Display e Keyboard Display MMIO Tools #
  6. #                 #
  7. # Marcus Vinicius Lamar             #
  8. # 2017/2                #
  9. #########################################################################
  10.  
  11.  
  12. #definicao do mapa de enderecamento de MMIO
  13. .eqv VGAADDRESSINI      0xFF000000
  14. .eqv VGAADDRESSFIM      0xFF012C00
  15. .eqv NUMLINHAS          240
  16. .eqv NUMCOLUNAS         320
  17.  
  18. .eqv KDMMIO_Ctrl  0xFF100000
  19. .eqv KDMMIO_Data  0xFF200004
  20.  
  21. .eqv Buffer0Teclado     0xFF200100
  22. .eqv Buffer1Teclado     0xFF200104
  23.  
  24. .eqv TecladoxMouse      0xFF200110
  25. .eqv BufferMouse        0xFF200114
  26.  
  27. .eqv AudioBase    0xFF200160
  28. .eqv AudioINL           0xFF200160
  29. .eqv AudioINR           0xFF200164
  30. .eqv AudioOUTL          0xFF200168
  31. .eqv AudioOUTR          0xFF20016C
  32. .eqv AudioCTRL1         0xFF200170
  33. .eqv AudioCTRL2         0xFF200174
  34.  
  35. # Sintetizador - 2015/1
  36. .eqv NoteData           0xFF200178
  37. .eqv NoteClock          0xFF20017C
  38. .eqv NoteMelody         0xFF200180
  39. .eqv MusicTempo         0xFF200184
  40. .eqv MusicAddress       0xFF200188
  41.  
  42.  
  43. .eqv IrDA_CTRL    0xFF20 0500
  44. .eqv IrDA_RX    0xFF20 0504
  45. .eqv IrDA_TX    0xFF20 0508
  46.  
  47. .eqv STOPWATCH    0xFF200510
  48.  
  49. .eqv LFSR   0xFF200514
  50.  
  51. .eqv KeyMap0    0xFF200520
  52. .eqv KeyMap1    0xFF200524
  53. .eqv KeyMap2    0xFF200528
  54. .eqv KeyMap3    0xFF20052C
  55.  
  56. ######### Macro que verifica se eh a DE2 ###############
  57. .macro DE2(%salto)
  58.   li t6, 0x10008000
  59.   bne gp,t6,%salto
  60. .end_macro
  61.  
  62. .data
  63.  
  64. LabelTabChar:
  65. .word   0x00000000, 0x00000000, 0x10101010, 0x00100010, 0x00002828, 0x00000000, 0x28FE2828, 0x002828FE,
  66.   0x38503C10, 0x00107814, 0x10686400, 0x00004C2C, 0x28102818, 0x003A4446, 0x00001010, 0x00000000,
  67.   0x20201008, 0x00081020, 0x08081020, 0x00201008, 0x38549210, 0x00109254, 0xFE101010, 0x00101010,
  68.   0x00000000, 0x10081818, 0xFE000000, 0x00000000, 0x00000000, 0x18180000, 0x10080402, 0x00804020,
  69.   0x54444438, 0x00384444, 0x10103010, 0x00381010, 0x08044438, 0x007C2010, 0x18044438, 0x00384404,
  70.   0x7C482818, 0x001C0808, 0x7840407C, 0x00384404, 0x78404438, 0x00384444, 0x1008047C, 0x00202020,
  71.   0x38444438, 0x00384444, 0x3C444438, 0x00384404, 0x00181800, 0x00001818, 0x00181800, 0x10081818,
  72.   0x20100804, 0x00040810, 0x00FE0000, 0x000000FE, 0x04081020, 0x00201008, 0x08044438, 0x00100010,
  73.   0x545C4438, 0x0038405C, 0x7C444438, 0x00444444, 0x78444478, 0x00784444, 0x40404438, 0x00384440,
  74.   0x44444478, 0x00784444, 0x7840407C, 0x007C4040, 0x7C40407C, 0x00404040, 0x5C404438, 0x00384444,
  75.   0x7C444444, 0x00444444, 0x10101038, 0x00381010, 0x0808081C, 0x00304848, 0x70484444, 0x00444448,
  76.   0x20202020, 0x003C2020, 0x92AAC682, 0x00828282, 0x54546444, 0x0044444C, 0x44444438, 0x00384444,
  77.   0x38242438, 0x00202020, 0x44444438, 0x0C384444, 0x78444478, 0x00444850, 0x38404438, 0x00384404,
  78.   0x1010107C, 0x00101010, 0x44444444, 0x00384444, 0x28444444, 0x00101028, 0x54828282, 0x00282854,
  79.   0x10284444, 0x00444428, 0x10284444, 0x00101010, 0x1008047C, 0x007C4020, 0x20202038, 0x00382020,
  80.   0x10204080, 0x00020408, 0x08080838, 0x00380808, 0x00442810, 0x00000000, 0x00000000, 0xFE000000,
  81.   0x00000810, 0x00000000, 0x3C043800, 0x003A4444, 0x24382020, 0x00582424, 0x201C0000, 0x001C2020,
  82.   0x48380808, 0x00344848, 0x44380000, 0x0038407C, 0x70202418, 0x00202020, 0x443A0000, 0x38043C44,
  83.   0x64584040, 0x00444444, 0x10001000, 0x00101010, 0x10001000, 0x60101010, 0x28242020, 0x00242830,
  84.   0x08080818, 0x00080808, 0x49B60000, 0x00414149, 0x24580000, 0x00242424, 0x44380000, 0x00384444,
  85.   0x24580000, 0x20203824, 0x48340000, 0x08083848, 0x302C0000, 0x00202020, 0x201C0000, 0x00380418,
  86.   0x10381000, 0x00101010, 0x48480000, 0x00344848, 0x44440000, 0x00102844, 0x82820000, 0x0044AA92,
  87.   0x28440000, 0x00442810, 0x24240000, 0x38041C24, 0x043C0000, 0x003C1008, 0x2010100C, 0x000C1010,
  88.   0x10101010, 0x00101010, 0x04080830, 0x00300808, 0x92600000, 0x0000000C, 0x243C1818, 0xA55A7E3C,
  89.   0x99FF5A81, 0x99663CFF, 0x10280000, 0x00000028, 0x10081020, 0x00081020
  90.  
  91. # scancode -> ascii
  92. LabelScanCode:
  93. #   0     1     2     3     4     5     6     7     8     9     A     B     C     D     E     F
  94. .byte   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, # 00 a 0F
  95.   0x00, 0x00, 0x00, 0x00, 0x00, 0x71, 0x31, 0x00, 0x00, 0x00, 0x7a, 0x73, 0x61, 0x77, 0x32, 0x00, # 10 a 1F
  96.   0x00, 0x63, 0x78, 0x64, 0x65, 0x34, 0x33, 0x00, 0x00, 0x20, 0x76, 0x66, 0x74, 0x72, 0x35, 0x00, # 20 a 2F  29 espaco => 20
  97.   0x00, 0x6e, 0x62, 0x68, 0x67, 0x79, 0x36, 0x00, 0x00, 0x00, 0x6d, 0x6a, 0x75, 0x37, 0x38, 0x00, # 30 a 3F
  98.   0x00, 0x2c, 0x6b, 0x69, 0x6f, 0x30, 0x39, 0x00, 0x00, 0x2e, 0x2f, 0x6c, 0x3b, 0x70, 0x2d, 0x00, # 40 a 4F
  99.   0x00, 0x00, 0x27, 0x00, 0x00, 0x3d, 0x00, 0x00, 0x00, 0x00, 0x0A, 0x5b, 0x00, 0x5d, 0x00, 0x00, # 50 a 5F   5A enter => 0A (= ao Mars)
  100.   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x31, 0x00, 0x34, 0x37, 0x00, 0x00, 0x00, # 60 a 6F
  101.   0x30, 0x2e, 0x32, 0x35, 0x36, 0x38, 0x00, 0x00, 0x00, 0x2b, 0x33, 0x2d, 0x2a, 0x39, 0x00, 0x00, # 70 a 7F
  102.   0x00, 0x00, 0x00, 0x00, 0x00, 0x00                  # 80 a 85
  103. # scancode -> ascii (com shift)
  104. LabelScanCodeShift:
  105. .byte   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
  106.   0x00, 0x00, 0x00, 0x00, 0x00, 0x51, 0x21, 0x00, 0x00, 0x00, 0x5a, 0x53, 0x41, 0x57, 0x40, 0x00,
  107.   0x00, 0x43, 0x58, 0x44, 0x45, 0x24, 0x23, 0x00, 0x00, 0x00, 0x56, 0x46, 0x54, 0x52, 0x25, 0x00,
  108.   0x00, 0x4e, 0x42, 0x48, 0x47, 0x59, 0x5e, 0x00, 0x00, 0x00, 0x4d, 0x4a, 0x55, 0x26, 0x2a, 0x00,
  109.   0x00, 0x3c, 0x4b, 0x49, 0x4f, 0x29, 0x28, 0x00, 0x00, 0x3e, 0x3f, 0x4c, 0x3a, 0x50, 0x5f, 0x00,
  110.   0x00, 0x00, 0x22, 0x00, 0x00, 0x2b, 0x00, 0x00, 0x00, 0x00, 0x00, 0x7b, 0x00, 0x7d, 0x00, 0x00,
  111.   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
  112.   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
  113.   0x00, 0x00, 0x00, 0x00, 0x00, 0x00
  114.  
  115. #instructionMessage:     .ascii  "   Instrucao    "
  116. #                        .asciz "   Invalida!    "
  117.  
  118. .align 2
  119.  
  120. #buffer do ReadString, ReadFloat, SDread, etc. 512 caracteres/bytes
  121. TempBuffer:
  122. .ascii ""
  123. #.space 512
  124.  
  125.  
  126. # tabela de conversao hexa para ascii
  127. TabelaHexASCII:   .asciz "0123456789ABCDEF  "
  128. NumDesnormP:    .asciz "+desnorm"
  129. NumDesnormN:    .asciz "-desnorm"
  130. NumZero:    .asciz "0.00000000"
  131. NumInfP:    .asciz "+Infinity"
  132. NumInfN:    .asciz "-Infinity"
  133. NumNaN:     .asciz "NaN"
  134.  
  135.  
  136. .align 2
  137. # variaveis para implementar a fila de eventos de input
  138. eventQueueBeginAddr:    .word 0x90000E00
  139. eventQueueEndAddr:      .word 0x90001000
  140. eventQueueBeginPtr:     .word 0x90000E00
  141. eventQueueEndPtr:       .word 0x90000E00
  142.  
  143. ##### Preparado para considerar ecall similar a jal text  para o pipeline
  144.  
  145. ### Obs.: a forma 'LABEL: instrucao' embora fique feio facilita o debug no Rars, por favor nao reformatar!!!
  146.  
  147. .text
  148.  
  149.  #inicio do exception handler
  150.  exceptionHandling:
  151.    addi sp,sp,-8
  152.  
  153. ############# interrupcao de ecall ###################
  154. ecallException:
  155.   addi sp,sp,-264
  156.  
  157.   sw x1,0(sp)
  158.   sw x2,4(sp)
  159.   sw x3,8(sp)
  160.   sw x4,12(sp)
  161.   sw x5,16(sp)
  162.   sw x6,20(sp)
  163.   sw x7,24(sp)
  164.   sw x8,28(sp)
  165.   sw x9,32(sp)
  166.   sw x10,36(sp)
  167.   sw x11,40(sp)
  168.   sw x12,44(sp)
  169.   sw x13,48(sp)
  170.   sw x14,52(sp)
  171.   sw x15,56(sp)
  172.   sw x16,60(sp)
  173.   sw x17,64(sp)
  174.   sw x18,68(sp)
  175.   sw x19,72(sp)
  176.   sw x20,76(sp)
  177.   sw x21,80(sp)
  178.   sw x22,84(sp)
  179.   sw x23,88(sp)
  180.   sw x24,92(sp)
  181.   sw x25,96(sp)
  182.   sw x26,100(sp)
  183.   sw x27,104(sp)
  184.   sw x28,108(sp)
  185.   sw x29,112(sp)
  186.   sw x30,116(sp)
  187.   sw x31,120(sp)
  188.  
  189.   fsw f0,124(sp)
  190.   fsw f1,128(sp)
  191.   fsw f2,132(sp)
  192.   fsw f3,136(sp)
  193.   fsw f4,140(sp)
  194.   fsw f5,144(sp)
  195.   fsw f6,148(sp)
  196.   fsw f7,152(sp)
  197.   fsw f8,156(sp)
  198.   fsw f9,160(sp)
  199.   fsw f10,164(sp)
  200.   fsw f11,168(sp)
  201.   fsw f12,172(sp)
  202.   fsw f13,176(sp)
  203.   fsw f14,180(sp)
  204.   fsw f15,184(sp)
  205.   fsw f16,188(sp)
  206.   fsw f17,192(sp)
  207.   fsw f18,196(sp)
  208.   fsw f19,200(sp)
  209.   fsw f20,204(sp)
  210.   fsw f21,208(sp)
  211.   fsw f22,212(sp)
  212.   fsw f23,216(sp)
  213.   fsw f24,220(sp)
  214.   fsw f25,224(sp)
  215.   fsw f26,228(sp)
  216.   fsw f27,232(sp)
  217.   fsw f28,236(sp)
  218.   fsw f29,240(sp)
  219.   fsw f30,244(sp)
  220.   fsw f31,256(sp)
  221.  
  222.   #Zera os registradores temporarios
  223.  
  224.   add     t0, zero, zero
  225.     add     t1, zero, zero
  226.     add     t2, zero, zero
  227.     add     t3, zero, zero
  228.     add     t4, zero, zero
  229.     add     t5, zero, zero
  230.     add     t6, zero, zero
  231.  
  232.     #li a7,105       # SERVICO SELECIONADO
  233.     #li a0, 12345678        # valor de teste
  234.  
  235.     addi    t0, zero, 10
  236.     beq     t0, a7, goToExit          # ecall exit
  237.     addi    t0, zero, 110
  238.     beq     t0, a7, goToExit          # ecall exit
  239.  
  240.     addi    t0, zero, 1               # ecall 1 = print int
  241.     beq     t0, a7, goToPrintInt
  242.     addi    t0, zero, 101             # ecall 1 = print int
  243.     beq     t0, a7, goToPrintInt
  244.  
  245.     addi    t0, zero, 2               # syscall 2 = print float
  246.     beq     t0, a7, goToPrintFloat
  247.     addi    t0, zero, 102             # syscall 2 = print float
  248.     beq     t0, a7, goToPrintFloat
  249.  
  250.     addi    t0, zero, 4               # ecall 4 = print string
  251.     beq     t0, a7, goToPrintString
  252.     addi    t0, zero, 104             # ecall 4 = print string
  253.     beq     t0, a7, goToPrintString
  254.  
  255.     addi    t0, zero, 5               # ecall 5 = read int
  256.     beq     t0, a7, goToReadInt
  257.     addi    t0, zero, 105             # ecall 5 = read int
  258.     beq     t0, a7, goToReadInt
  259.  
  260.     addi    t0, zero, 6               # syscall 6 = read float
  261.     beq     t0, a7, goToReadFloat
  262.     addi    t0, zero, 106             # syscall 6 = read float
  263.     beq     t0, a7, goToReadFloat
  264.  
  265.     addi    t0, zero, 8               # ecall 8 = read string
  266.     beq     t0, a7, goToReadString
  267.     addi    t0, zero, 108             # ecall 8 = read string
  268.     beq     t0, a7, goToReadString
  269.  
  270.     addi    t0, zero, 11              # ecall 11 = print char
  271.     beq     t0, a7, goToPrintChar
  272.     addi    t0, zero, 111             # ecall 11 = print char
  273.     beq     t0, a7, goToPrintChar
  274.  
  275.     addi    t0, zero, 12              # ecall 12 = read char
  276.     beq     t0, a7, goToReadChar
  277.     addi    t0, zero, 112             # ecall 12 = read char
  278.     beq     t0, a7, goToReadChar
  279.  
  280.     addi    t0, zero, 30              # ecall 30 = time
  281.     beq     t0, a7, goToTime
  282.     addi    t0, zero, 130             # ecall 30 = time
  283.     beq     t0, a7, goToTime
  284.  
  285.     #addi    t0, zero, 31              # syscall 31 = MIDI out
  286.     #beq     t0, a7, goToMidiOut
  287.     #addi    t0, zero, 131             # syscall 31 = MIDI out
  288.     #beq     t0, a7, goToMidiOut
  289.  
  290.     #addi    t0, zero, 33              # syscall 33 = MIDI out synchronous
  291.     #beq     t0, a7, goToMidiOutSync
  292.     #addi    t0, zero, 133             # syscall 33 = MIDI out synchronous
  293.     #beq     t0, a7, goToMidiOutSync
  294.  
  295.     # addi    t0, zero, 49              # syscall 49 = SD Card read
  296.     # beq     t0, a7, goToSDread
  297.     # addi    t0, zero, 149              # syscall 49 = SD Card read
  298.     # beq     t0, a7, goToSDread
  299.  
  300.     addi    t0, zero, 32              # ecall 32 = sleep
  301.     beq     t0, a7, goToSleep
  302.     addi    t0, zero, 132             # ecall 32 = sleep
  303.     beq     t0, a7, goToSleep
  304.  
  305.     addi    t0, zero, 34           # ecall 34 = print hex
  306.     beq     t0, a7, goToPrintHex
  307.     addi    t0, zero, 134    # ecall 41 = print hex
  308.     beq     t0, a7, goToPrintHex
  309.  
  310.     addi    t0, zero, 41              # ecall 41 = random
  311.     beq     t0, a7, goToRandom
  312.     addi    t0, zero, 141             # ecall 41 = random
  313.     beq     t0, a7, goToRandom
  314.  
  315.     addi    t0, zero, 48              # ecall 48 = CLS
  316.     beq     t0, a7, goToCLS
  317.     addi    t0, zero, 148              # ecall 48 = CLS
  318.     beq     t0, a7, goToCLS
  319.  
  320. #EXIT
  321. endEcall:
  322.     lw      x1, 0(sp)  # recupera QUASE todos os registradores na pilha
  323.     lw      x2,   4(sp)
  324.     lw      x3,   8(sp)
  325.     lw      x4,  12(sp)
  326.     lw      x5,  16(sp)
  327.     lw      x6,  20(sp)
  328.     lw      x7,  24(sp)
  329.     lw      x8,  28(sp)
  330.     lw      x9,    32(sp)
  331. #   lw      x10,   36(sp)    #a0 retorno de valor
  332. #   lw      x11,   40(sp)    #a1 retorno de valor
  333.     lw      x12,   44(sp)
  334.     lw      x13,   48(sp)
  335.     lw      x14,   52(sp)
  336.     lw      x15,   56(sp)
  337.     lw      x16,   60(sp)
  338.     lw      x17,   64(sp)
  339.     lw      x18,   68(sp)
  340.     lw      x19,   72(sp)
  341.     lw      x20,   76(sp)
  342.     lw      x21,   80(sp)
  343.     lw      x22,   84(sp)
  344.     lw      x23,   88(sp)
  345.     lw      x24,   92(sp)
  346.     lw      x25,   96(sp)
  347.     lw      x26,  100(sp)
  348.     lw      x27,  104(sp)
  349.     lw      x28,  108(sp)
  350.     lw      x29,  112(sp)
  351.     lw      x30,  116(sp)
  352.     lw      x31,  120(sp)
  353.     flw    f1,  128(sp)
  354.     flw    f2,  132(sp)
  355.     flw    f3,  136(sp)
  356.     flw    f4,  140(sp)
  357.     flw    f5,  144(sp)
  358.     flw    f6,  148(sp)
  359.     flw    f7,  152(sp)
  360.     flw    f8,  156(sp)
  361.     flw    f9,  160(sp)
  362. #   flw    f10, 164(sp)    #fa0 retorno de valor
  363. #   flw    f11, 168(sp)    #fa1 retorno de valor
  364.     flw    f12, 172(sp)
  365.     flw    f13, 176(sp)
  366.     flw    f14, 180(sp)
  367.     flw    f15, 184(sp)
  368.     flw    f16, 188(sp)
  369.     flw    f17, 192(sp)
  370.     flw    f18, 196(sp)
  371.     flw    f19, 200(sp)
  372.     flw    f20, 204(sp)
  373.     flw    f21, 208(sp)
  374.     flw    f22, 212(sp)
  375.     flw    f23, 216(sp)
  376.     flw    f24, 220(sp)
  377.     flw    f25, 224(sp)
  378.     flw    f26, 228(sp)
  379.     flw    f27, 232(sp)
  380.     flw    f28, 236(sp)
  381.     flw    f29, 240(sp)
  382.     flw    f30, 244(sp)
  383.     flw    f31, 248(sp)
  384.  
  385.     addi    sp, sp, 264
  386.  
  387.     li a7,10
  388.     ecall
  389.  
  390. # Funcoes de chamada de sistema
  391.  
  392. goToExit:
  393.                     li a7,10                        # Chama Exit
  394.                     ecall
  395.  
  396. goToPrintInt:
  397.                     jal printInt                    # Chama printInt
  398.                     j endEcall
  399.  
  400. goToPrintString:
  401.                     jal printString                 # Chama printString
  402.                     j endEcall
  403.  
  404. goToPrintChar:
  405.                     jal printChar                   # Chama printChar
  406.                     j endEcall
  407.  
  408. goToPrintFloat:
  409.                     jal     printFloat        # chama printFloat
  410.                     j       endEcall
  411.  
  412. goToReadChar:
  413.                     jal readChar                    # Chama readChar
  414.                     j endEcall
  415.  
  416. goToReadString:
  417.                     jal readString                  # Chama readString
  418.                     j endEcall
  419.  
  420. goToReadInt:
  421.                     jal readInt                     # Chama readInt
  422.                     j endEcall
  423.  
  424. goToReadFloat:
  425.                     jal     readFloat               # chama readFloat
  426.                     j       endEcall
  427.  
  428. goToCLS:
  429.                     jal clsCLS                      # Chama CLS
  430.                     j endEcall
  431. goToPrintHex:
  432.                     jal printHex                    # Chama printHex
  433.                     j endEcall
  434.  
  435. goToTime:
  436.                     jal time                        # Chama time
  437.                     j endEcall
  438.  
  439. goToSleep:
  440.                     jal sleep                       # Chama sleep
  441.                     j endEcall
  442.  
  443. goToRandom:
  444.                     jal random                      # Chama random
  445.                     j endEcall
  446.  
  447. #goToMidiOut:
  448.                     #jal     midiOut                 # chama MIDIout
  449.                     #j       endEcall
  450.  
  451. #goToMidiOutSync:
  452. #                   jal     midiOutSync     # chama MIDIoutSync
  453. #                   j       endEcall
  454.  
  455. #goToSDread:
  456. #                    jal     sdRead                 # Chama sdRead
  457. #                    j       endEcall
  458.  
  459. ############################################
  460. #  PrintInt                                #
  461. #  a0    =    valor inteiro                #
  462. #  a1    =    x                            #
  463. #  a2    =    y                            #
  464. #  a3    =    cor                          #
  465. ############################################
  466.  
  467. printInt:
  468.           addi sp,sp,-4     # aloca espaco
  469.           sw ra,0(sp)       # salva ra
  470.           la t0,TempBuffer    # carrega o endereco do buffer
  471.  
  472.           bge a0,zero, ehposprintInt  #se eh positivo
  473.           li t1,'-'   #carrega o sinal -
  474.           sb t1,0(t0)   #  armazena - no buffer
  475.           addi t0,t0,1  # incrementa endereco do buffer
  476.           sub a0,zero,a0  # torna o numero positivo
  477.  
  478. ehposprintInt:
  479.               li t2,10    # carrega
  480.               li t1,0     # carrega numero de digitos com 0
  481.  
  482. loop1printInt:
  483.               div t4,a0,t2    #divide por 10, t4 = quociente
  484.               rem t3,a0,t2    # resto
  485.               addi sp,sp,-4   # aloca espaco na pilha
  486.               sw t3,0(sp)     # coloca o restp na pilha
  487.               mv a0,t4
  488.               addi t1,t1,1    # incrementa o contador de digitos
  489.               bne a0,zero,loop1printInt #verifica se o número eh zero
  490.  
  491. loop2printInt:
  492.               lw t2,0(sp)     # le digito da pilha
  493.               addi sp,sp,4    # libera espaco na pilha
  494.               addi t2,t2,48   # converte o digito para ascii
  495.               sb t2,0(t0)     # coloca caractere no buffer
  496.               addi t0,t0,1    # encrementa o contador do buffer
  497.               addi t1,t1,-1   # decrementa contador de digitos
  498.               bne t1,zero, loop1printInt  # eh o ultimo?
  499.               sb zero,0(t0)       # insere /NULL na string
  500.  
  501.               la a0, TempBuffer   # endereco do buffer na string
  502.               jal printString     # chama print string
  503.  
  504.               lw ra,0(sp)       # carrega o endereco de retorno
  505.               addi sp,sp,4      # libera espaco da pilha
  506.  
  507.             fimprintInt:
  508.               jalr zero, ra,0   # retorna
  509.  
  510.  
  511. #############################################
  512. #  PrintHex                                 #
  513. #  a0    =    valor inteiro                #
  514. #  a1    =    x                            #
  515. #  a2    =    y                            #
  516. #  a3    =    cor          #
  517. #############################################
  518.  
  519. printHex:
  520.           addi sp,sp,-8     # aloca espaco
  521.           sw ra,0(sp)       # guarda endereco de retorno na pilha
  522.           mv t0,a0        # inteiro de 32 bits a ser impresso em hex
  523.           la t1,TabelaHexASCII  # endereco da tabela HEX > ASCII
  524.           la t2, TempBuffer   # onde a string será montada
  525.  
  526.           li t3,'0'       # t3 recebe caractere 0 de '0x'
  527.           sb t3,0(t2)       # escreve caractere no buffer da string
  528.           li t3,'x'       # caractere 'x'
  529.           sb t3,1(t2)       # escreve caractere no buffer da string
  530.           addi t2,t2,2      # novo endereco inicial da string
  531.  
  532.           li t3,28        # contador de nibble, inicio = 28
  533.  
  534. loopprintHex:
  535.               blt t3,zero, fimloopprintHex  #se t3 < 0, terminou
  536.               srl t4,t0,t3          #desloca o nibble para a direita
  537.               andi t4,t3,0x000F         # mascara o nibble
  538.               add t4,t1,t4          # endereco ASCII do nibble
  539.               lb t4,0(t4)           # armazena o ASCII do nibble em t4
  540.               sb t4,0(t2)           # armazena o caractere no buffer da string
  541.               addi t2,t2,1            # incrementa o contador
  542.               addi t3,t3,-4         # decrementa o numero do nibble
  543.               j loopprintHex          # chama a funcao para o proximo nibble
  544.  
  545. fimloopprintHex:
  546.               sb zero,0(t2)         # escreve o caractere null
  547.               la a0, TempBuffer       # argumento do printString
  548.               jal printString         # imprime a numero
  549.               lw ra, 0(sp)          # retira o endereco de retorno da pilha
  550.               addi sp,sp,4          # libera espaco da pilha
  551.  
  552. fimprintHex:
  553.             jalr zero, ra,0         #retorna
  554.  
  555. #####################################
  556. #  PrintSring                       #
  557. #  a0    =  endereco da string     #
  558. #  a1    =  x                      #
  559. #  a2    =  y                      #
  560. #  a3    =  cor       #
  561. #####################################
  562.  
  563. printString:
  564.             addi sp, sp, -8     # aloca espaco
  565.             sw  ra, 0(sp)     # salva ra
  566.             sw  s0, 4(sp)     # salva s0
  567.             mv  s0, a0                  # s0 = endereco do caractere na string
  568.  
  569. loopprintString:
  570.                 lb a0, 0(s0)                  # le em a0 o caracter a ser impresso
  571.                 beq a0, zero, fimloopprintString   # string ASCIIZ termina com NULL
  572.                 jal printChar           # imprime char
  573.  
  574.                  addi a1, a1, 8                  # incrementa a coluna
  575.                 blt a1, t0, NaoPulaLinha        # se ainda tiver lugar na linha
  576.                 addi a2, a2, 8                  # incrementa a linha
  577.                 mv a1, zero     # volta a coluna zero
  578.  
  579. NaoPulaLinha:
  580.                 addi s0, s0, 1      # proximo caractere
  581.                 j loopprintString           # volta ao loop
  582.  
  583. fimloopprintString:
  584.                   lw ra, 0(sp)        # recupera ra
  585.                   lw s0, 0(sp)    # recupera s0
  586.                   addi sp, sp, 8    # libera espaco
  587.  
  588. fimprintString:
  589.                 jalr zero,ra,0              # retorna
  590.  
  591.  
  592. #########################################################
  593. #  PrintChar                                            #
  594. #  a0 = char(ASCII)                                    #
  595. #  a1 = x                                              #
  596. #  a2 = y                                              #
  597. #########################################################
  598. #   t0 = i                                             #
  599. #   t1 = j                                             #
  600. #   t2 = endereco do char na memoria                   #
  601. #   t3 = metade do char (2a e depois 1a)               #
  602. #   t4 = endereco para impressao                       #
  603. #   t5 = background color                              #
  604. #   t6 = foreground color                              #
  605. #   t7 = 2                                             #
  606. #########################################################
  607.  
  608.  
  609. printChar:
  610.         addi t5, a3, 0x0AA            # cor fundo
  611.         addi t6,a3,0xFF       # cor frente
  612.         #srli t5, t5, 8     # numero da cor de fundo
  613.  
  614.         li t0,' '
  615.         blt a0, t0, NAOIMPRIMIVEL   # ascii menor que 32 nao eh imprimivel
  616.         li t0,'~'
  617.         bgt a0, t0, NAOIMPRIMIVEL   # ascii Maior que 126  nao eh imprimivel
  618.         j IMPRIMIVEL
  619.  
  620. NAOIMPRIMIVEL:
  621.               li a0, 32     # Imprime espaco
  622.  
  623. IMPRIMIVEL:
  624.         li  t0, NUMCOLUNAS    # Num colunas 320
  625.         mul t4,t0, a2     # multiplica a2x320
  626.         add t4, t4, a1                # t4 = 320*y + x
  627.         addi t4, t4, 7                  # t4 = 320*y + (x+7)
  628.         #la s0, VGAADDRESSINI           # Endereco de inicio da memoria VGA
  629.         lui s1,0xFF00
  630.         ori s1,s1,0
  631.         slli s1,s1,4
  632.         add t4, t4, s1                # t4 = endereco de impressao do ultimo pixel da primeira linha do char
  633.         addi t2, a0, -32                # indice do char na memoria
  634.         slli t2, t2, 3                  # offset em bytes em relacao ao endereco inicial
  635.         la t3, LabelTabChar   # endereco dos caracteres na memoria
  636.         add t2, t2, t3                # endereco do caractere na memoria
  637.         lw t3, 0(t2)                  # carrega a primeira word do char
  638.         li t0, 4        # i=4
  639.  
  640. forChar1I:
  641.           beq t0, zero, endForChar1I  # if(i == 0) end for i
  642.           addi t1, zero, 8                # j = 8
  643.  
  644.   forChar1J:
  645.             beq t1, zero, endForChar1J      # if(j == 0) end for j
  646.             andi s1, t3, 0x0001   # primeiro bit do caracter
  647.             srli t3, t3, 1              # retira o primeiro bit
  648.             beq s1, zero, printCharPixelbg1 # pixel eh fundo?
  649.             sb t6, 0(t4)              # imprime pixel com cor de frente
  650.             j endCharPixel1
  651.  
  652. printCharPixelbg1:
  653.                   sb t5, 0(t4)                  # imprime pixel com cor de fundo
  654.  
  655. endCharPixel1:
  656.                 addi t1, t1, -1                 # j--
  657.                 addi t4, t4, -1                 # t4 aponta um pixel para a esquerda
  658.                 j forChar1J     # volta novo pixel
  659.  
  660. endForChar1J:
  661.             addi t0, t0, -1     # i--
  662.             addi t4, t4, 328           # 2**12 + 8
  663.             j forChar1I   # volta ao loop
  664.  
  665. endForChar1I:
  666.               lw t3, 4(t2)            # carrega a segunda word do char
  667.               li  t0, 4     # i = 4
  668.  
  669. forChar2I:
  670.             beq t0, zero, endForChar2I      # if(i == 0) end for i
  671.             addi t1, zero, 8               # j = 8
  672.  
  673.   forChar2J:
  674.             beq t1, zero, endForChar2J      # if(j == 0) end for j
  675.             andi s1, t3, 0x0001       # pixel a ser impresso
  676.             srli t3, t3, 1                  # desloca para o proximo
  677.             beq s1, zero, printCharPixelbg2 # pixel eh fundo?
  678.             sb t6, 0(t4)      # imprime cor frente
  679.             j endCharPixel2     # volta ao loop
  680.  
  681. printCharPixelbg2:
  682.                     sb      t5, 0(t4)     # imprime cor de fundo
  683.  
  684. endCharPixel2:
  685.               addi t1, t1, -1     # j--
  686.               addi t4, t4, -1                 # t4 aponta um pixel para a esquerda
  687.               j forChar2J
  688.  
  689. endForChar2J:
  690.             addi t0, t0, -1     # i--
  691.             addi t4, t4, 328    #
  692.             j forChar2I   # volta ao loop
  693.  
  694. endForChar2I:
  695.               jalr zero,ra,0        # retorna
  696.  
  697.  
  698. #########################################
  699. # ReadChar                #
  700. # a0 = valor ascii da tecla      #
  701. # 2017/2          #
  702. #########################################
  703. readChar: #DE2(readCharKDMMIODE2)
  704.  
  705. readCharKDMMIO:
  706.                 li t0,KDMMIO_Ctrl
  707.  
  708.  
  709. loopReadCharKDMMIO:
  710.                     lbu a7,0(t0)
  711.                     andi a7,a7,0x0001
  712.                     beq a7,zero,loopReadCharKDMMIO
  713.                     lw a7,4(t0)
  714.                     j fimreadChar
  715.  
  716. fimreadChar:
  717.             ret
  718.  
  719. #########################################
  720. #    ReadString             #
  721. # a0 = end Inicio          #
  722. # a1 = tam Max String      #
  723. # a7 = end do ultimo caractere  #
  724. # s0 = num de caracteres digitados  #
  725. # s1/fp        #
  726. # 2017/2                    #
  727. #########################################
  728. # muda a0 e fp
  729.  
  730. readString:
  731.             addi sp,sp,-8     # aloca espaco na pilha
  732.             sw ra,0(sp)       # guarda o endereco de retorno
  733.             li s0,0         # zera o contador de caracteres digitados
  734.             li a1,100
  735.             la a0, TempBuffer   # endereco inicial da string
  736.             la s1, LabelScanCode  # endereco da tabela de ScanCode inicial de readChar
  737.  
  738. loopreadString:
  739.                 beq a1,s0, fimreadString # buffer cheio fim
  740.                 mv t1,ra        # salva ra
  741.                 jal readChar      # chama readChar
  742.                 mv ra,t1
  743.                 li t1,0x0A
  744.                 beq a7,t1,fimreadString # se for ENTER exit
  745.                 sb a7,0(a0)       # grava no buffer
  746.                 addi s0,s0,1      # incrementa contador de caracteres
  747.                 addi a0,a0,1      # incrementa endereco do buffer
  748.                 j loopreadString
  749.  
  750. fimreadString:
  751.                 sb zero,0(a0)     # grava null no buffer
  752.                 addi a7,a0,-1   # a7 recebe o endereco do outro caractere
  753.                 lw ra,0(sp)   # recupera ra
  754.                 addi sp,sp,4    # libera espaco na pilha
  755.                 jalr zero,ra,0        # retorna
  756.  
  757. ###########################
  758. #    ReadInt              #
  759. # a7 = valor do inteiro  #
  760. #                         #
  761. ###########################
  762.  
  763. readInt:
  764.             addi sp,sp,-4   # aloca espaco na pilha
  765.             sw ra,0(sp)   # guarda endereco de retorno na pilha
  766.             la a0, TempBuffer   #endereco do buffer da string
  767.             li a1, 10       # numero maximo de digitos
  768.             jal readString    # le uma string de ate 10 digitos
  769.             mv t0, a7       # copia endereco do ultimo digito
  770.             li t2,10      # 10
  771.             li t3,1       # dezenas, centenas, etc
  772.             mv a7,zero      # zera o numero
  773.  
  774. loopReadInt:
  775.             beq s0, zero, fimReadInt    # leu todos os digitos
  776.             lb t1, 0(t0)          # le um digito
  777.             li t4,0x2d
  778.             beq t1, t4, ehnegReadInt    # = '-'
  779.             li t4,0x2b
  780.             beq t1,t4, ehposReadInt     # = '+'
  781.             li t4,0x30
  782.             blt t1,t4,naoehReadInt    # < '0'
  783.             li t4,0x39
  784.             bgt t1,t4,naoehReadInt          # > '9'
  785.             addi t1,t1,-48          # transforma ascii em numero
  786.             mul t1,t1,t3          # multiplica por dezenas,centenas
  787.             add a7,a7,t1          # soma no numero
  788.             mul t3,t3,t2          # proxima dezena centena
  789.             addi t0,t0,-1           # busca o digito anterior
  790.             addi s0,s0,-1         # reduz o contador de digitos
  791.             j loopReadInt           # volta para buscar proximo digito
  792.  
  793. naoehReadInt:
  794.             j endEcall      # gera erro instrucao invalida
  795.  
  796. ehnegReadInt:
  797.             sub a7,zero,a7    # se for negativo
  798.  
  799. ehposReadInt:
  800.             j loopReadInt
  801.  
  802. fimReadInt:
  803.             lw ra,0(sp)     # recupera ra
  804.             addi sp,sp,4    # libera espaco da pilha
  805.             ret   # retorna
  806.  
  807.  
  808. #################################
  809. # printFloat                    #
  810. # imprime Float em f12         #
  811. # na posicao (a1,a2)  cor a3 #
  812. #################################
  813.  
  814. printFloat:
  815.               addi  sp, sp, -4
  816.               sw  ra, 0(sp)
  817.               la  s0, TempBuffer
  818.  
  819.               # Encontra o sinal do nUmero e coloca no Buffer
  820.               li  t0, '+'               # define sinal '+'
  821.               fmv.x.s   s1, f12           # recupera o numero float
  822.               li    tp, 0x80000000
  823.               and   s1, s1, tp            # mascara com 1000
  824.               beq   s1, zero, ehposprintFloat   # eh positivo s0=0
  825.               li  s1, 1               # numero eh negativo s0=1
  826.               li  t0, '-'               # define sinal '-'
  827. ehposprintFloat:
  828.                 sb   t0, 0(s0)       # coloca sinal no buffer
  829.                 addi  s0, s0,1            # incrementa o endereco do buffer
  830.  
  831.                 # Encontra o expoente em t0
  832.                  fmv.x.s  t0, f12           # recupera o numero float
  833.                  li   tp, 0x7F800000
  834.                  and  t0, t0, tp            # mascara com 0111 1111 1000 0000 0000 0000...
  835.                  slli   t0, t0, 1           # tira o sinal do numero
  836.                  srli   t0, t0, 24            # recupera o expoente
  837.  
  838.                 # Encontra a fracao em t1
  839.                 fmv.x.s   t1, f12           # recupera o numero float
  840.                 li tp, 0x007FFFFF
  841.                 and   t1, t1, tp            # mascara com 0000 0000 0111 1111 1111...
  842.  
  843.                 beq   t0, zero, ehExp0printFloat    # Expoente = 0
  844.                 li    tp, 255
  845.                 beq   t0, tp, ehExp255printFloat    # Expoente = 255
  846.  
  847.                 # Eh um numero float normal  t0 eh o expoente e t1 eh a mantissa
  848.                 # Encontra o E tal que 10^E <= x <10^(E+1)
  849.                 fabs.s  f0, f12             # f0 recebe o m�dulo  de x
  850.                 li    t0, 0x3F800000
  851.                 fmv.s.x   f1, t0            # f1 recebe o numero 1.0
  852.                 li    t0, 0x41200000
  853.                 fmv.s.x   f10, t0           # f10 recebe o numero 10.0
  854.  
  855.                 flt.s   s11, f0, f1           # f0 < 1.0 ? Flag 1 indica se f0<1 ou seja E deve ser negativo
  856.                 bnez  s11, menor1printFloat
  857.                 fmv.s   f2, f10             # f2  fator de multiplica�ao = 10
  858.                 j   cont2printFloat           # vai para expoente positivo
  859. menor1printFloat:
  860.                 fdiv.s f2,f1,f10        # f2 fator multiplicativo = 0.1
  861.  
  862.       # calcula o expoente negativo de 10
  863. cont1printFloat:
  864.               fmv.s   f4, f0        # inicia com o numero x
  865.               fmv.s   f3, f1            # contador come�a em 1
  866. loop1printFloat:
  867.               fdiv.s  f4, f4, f2      # divide o numero pelo fator multiplicativo
  868.               fle.s   s10, f4, f1         # o numero eh > que 1? entao fim
  869.               beqz    s10, fimloop1printFloat
  870.               fadd.s  f3, f3, f1          # incrementa o contador
  871.               j   loop1printFloat         # volta ao loop
  872. fimloop1printFloat:
  873.                   fdiv.s  f4, f4, f2    # ajusta o numero
  874.                   j   intprintFloat         # vai para imprimir a parte inteira
  875.  
  876.       # calcula o expoente positivo de 10
  877. cont2printFloat:
  878.               fmv.s   f4, f0        # inicia com o numero x
  879.               fmv.s.x   f3, zero        # contador come�a em 0
  880. loop2printFloat:
  881.                 flt.s   s10, f4, f10    # resultado eh < que 10? entao fim
  882.                 fdiv.s  f4, f4, f2          # divide o numero pelo fator multiplicativo
  883.                 bnez  s10 ,intprintFloat
  884.                 fadd.s  f3, f3, f1          # incrementa o contador
  885.                 j   loop2printFloat
  886.  
  887.     # Neste ponto tem-se no flag 1 se f0<1, em f3 o expoente de 10 e f0 0 m�dulo do numero e s1 o sinal
  888.     # e em f4 um n�mero entre 1 e 10 que multiplicado por Ef3 deve voltar ao numero
  889.  
  890.         # imprime parte inteira (o sinal j� est� no buffer)
  891. intprintFloat:
  892.               fmul.s    f4, f4, f2    # ajusta o numero
  893.               fsrmi   001           # seta o rounding mode pra arredondar para o zero
  894.               fcvt.w.s  t0, f4          # menor inteiro
  895.               li tp, 0xa
  896.               bne t0, tp, naoehdez        # evita enviar o simbolo a
  897.               li t0, 0x1
  898.               naoehdez:   addi    t0, t0, 48        # converte para ascii
  899.               sb    t0, 0(s0)         # coloca no buffer
  900.               addi    s0, s0, 1       # incrementta o buffer
  901.  
  902.               # imprime parte fracionaria
  903.               li  t0, '.'             # carrega o '.'
  904.               sb  t0, 0(s0)           # coloca no buffer
  905.               addi  s0, s0, 1         # incrementa o buffer
  906.  
  907.               # f4 contem a mantissa com 1 casa n�o decimal
  908.               li    t1, 8           # contador de digitos  -  8 casas decimais
  909. loopfracprintFloat:
  910.                   beq  t1, zero, fimfracprintFloat # fim dos digitos?
  911.                   fsrmi   001           # rounding mode RTZ
  912.                   fcvt.w.s  t0, f4
  913.                   fcvt.s.w  f5, t0          #parte inteira de f4 em f5
  914.                   fsub.s    f5, f4, f5        # parte fracionaria
  915.                   fmul.s    f5, f5, f10       # mult x 10
  916.                   fcvt.w.s  t0, f5          # converte para inteiro
  917.                   addi    t0, t0, 48        # converte para ascii
  918.                   sb    t0, 0(s0)         # coloca no buffer
  919.                   addi    s0, s0, 1       # incrementa endereco
  920.                   addi    t1, t1, -1        # decrementa contador
  921.                   fmv.s     f4, f5          # coloca o numero em f4
  922.                   j     loopfracprintFloat      # volta ao loop
  923.  
  924.         # imprime 'E'
  925. fimfracprintFloat:
  926.                   li  t0,'E'          # carrega 'E'
  927.                   sb  t0, 0(s0)           # coloca no buffer
  928.                   addi  s0, s0, 1         # incrementa endereco
  929.  
  930.                   # imprime sinal do expoente
  931.                   li  t0, '+'             # carrega '+'
  932.  
  933.                   beqz  s11, expposprintFloat   # nao eh negativo?
  934.                   li  t0, '-'             # carrega '-'
  935. expposprintFloat:
  936.                 sb  t0, 0(s0)       # coloca no buffer
  937.                 addi  s0, s0, 1         #incrementa endereco
  938.  
  939.                 # imprimeo expoente com 2 digitos (maximo E+38)
  940.                 li  t1, 10              # carrega 10
  941.                 fcvt.w.s t0, f3           # converte f3 em inteiro
  942.                 div   t0,t0, t1         # divide por 10
  943.                 addi  t0, t0, 48          # converte para ascii
  944.                 sb  t0, 0(s0)           # coloca no buffer
  945.                 fcvt.w.s t0, f3
  946.                 rem   t0, t0, t1          # resto (unidade)
  947.                 addi  t0, t0, 48          # converte para ascii
  948.                 sb  t0, 1(s0)           # coloca no buffer
  949.                 sb  zero, 2(s0)           # insere \NULL da string
  950.                 la  a0, TempBuffer          # endereco do Buffer
  951.                 j   fimprintFloat         # imprime a string
  952.  
  953. ehExp0printFloat:   beq t1, zero, eh0printFloat # Verifica se eh zero
  954.  
  955. ehDesnormprintFloat:
  956.                     la  a0, NumDesnormP   # string numero desnormalizado positivo
  957.                     beq   s1, zero, fimprintFloat   # o sinal eh 1? entao � negativo
  958.                     la  a0, NumDesnormN         # string numero desnormalizado negativo
  959.                     j   fimprintFloat         # imprime a string
  960.  
  961. eh0printFloat:
  962.                 la  a0, NumZero       # string do zero
  963.                 j   fimprintFloat           # imprime a string
  964.  
  965. ehExp255printFloat:
  966.                     beq t1, zero, ehInfprintFloat # se mantissa eh zero entao eh Infinito
  967.  
  968. ehNaNprintfFloat:
  969.                   la  a0, NumNaN        # string do NaN
  970.                   j   fimprintFloat         # imprime string
  971.  
  972. ehInfprintFloat:
  973.                 la  a0, NumInfP       # string do infinito positivo
  974.                 beq   s1, zero, fimprintFloat   # o sinal eh 1? entao eh negativo
  975.                 la  a0, NumInfN           # string do infinito negativo
  976.                                   # imprime string
  977.  
  978. fimprintFloat:
  979.               jal   printString     # imprime a string em a0
  980.               lw  ra, 0(sp)           # recupera ra
  981.               addi  sp, sp, 4         # libera sepaco
  982.               jalr zero,ra,0            # retorna
  983.  
  984.  
  985. #################################
  986. # readFloat                     #
  987. # f0 = float digitado           #
  988. # 2017/2                        #
  989. #################################
  990.  
  991. readFloat:
  992.           addi sp, sp, -4            # aloca espaco
  993.           sw  ra, 0(sp)               # salva ra
  994.           la  a0, TempBuffer              # endereco do FloatBuffer
  995.           li  a1, 32                  # numero maximo de caracteres
  996.           jal readString                # le string, retorna v0 ultimo endereco e v1 numero de caracteres
  997.           mv  s0, a2                # ultimo endereco da string (antes do \0)
  998.           mv  s1, a3                # numero de caracteres digitados
  999.           la  s7, TempBuffer              # Endereco do primeiro caractere
  1000.  
  1001. lePrimeiroreadFloat:
  1002.                     mv  t0, s7      # Endereco de Inicio
  1003.                     lb  t1, 0(t0)               # le primeiro caractere
  1004.                     li    tp, 'e'
  1005.                     beq   t1, tp, insere0AreadFloat     # insere '0' antes
  1006.                     li    tp, 'E'
  1007.                     beq   t1, tp, insere0AreadFloat     # insere '0' antes
  1008.                     li    tp, '.'
  1009.                     beq   t1, tp, insere0AreadFloat     #  insere '0' antes
  1010.                     li    tp, '+'
  1011.                     beq   t1, tp, pulaPrimreadChar      # pula o primeiro caractere
  1012.                     li    tp, '-'
  1013.                     beq   t1, tp, pulaPrimreadChar
  1014.                     j leUltimoreadFloat
  1015.  
  1016. pulaPrimreadChar:
  1017.                   addi s7, s7,1         # incrementa o endereco inicial
  1018.                   j lePrimeiroreadFloat         # volta a testar o novo primeiro caractere
  1019.  
  1020. insere0AreadFloat:
  1021.                   mv t0, s0          # endereco do ultimo caractere
  1022.                   addi s0, s0, 1           # desloca o ultimo endereco para o proximo
  1023.                   addi s1, s1, 1           # incrementa o num. caracteres
  1024.                   sb   zero, 1(s0)           # \NULL do final de string
  1025.                   mv t6, s7              # primeiro caractere
  1026. insere0Aloop:
  1027.              beq t0, t6, saiinsere0AreadFloat  # chegou no inicio entao fim
  1028.              lb   t1, 0(t0)           # le caractere
  1029.              sb   t1, 1(t0)           # escreve no proximo
  1030.              addi t0, t0, -1            # decrementa endereco
  1031.              j insere0Aloop           # volta ao loop
  1032. saiinsere0AreadFloat:
  1033.                     li t1, '0'        # ascii '0'
  1034.                     sb t1, 0(t0)             # escreve '0' no primeiro caractere
  1035.  
  1036. leUltimoreadFloat:
  1037.                   lb   t1,0(s0)        # le ultimo caractere
  1038.                   li    tp, 'e'
  1039.                   beq   t1, tp, insere0PreadFloat   # insere '0' depois
  1040.                   li    tp, 'E'
  1041.                   beq   t1, tp, insere0PreadFloat   # insere '0' depois
  1042.                   li    tp, '.'
  1043.                   beq   t1, tp, insere0PreadFloat   # insere '0' depois
  1044.                   j   inicioreadFloat
  1045.  
  1046. insere0PreadFloat:
  1047.                   addi s0, s0, 1       # desloca o ultimo endereco para o proximo
  1048.                   addi s1, s1, 1           # incrementa o num. caracteres
  1049.                   li   t1,'0'              # ascii '0'
  1050.                   sb   t1,0(s0)            # escreve '0' no ultimo
  1051.                   sb   zero,1(s0)            # \null do final de string
  1052.  
  1053. inicioreadFloat:
  1054.                 fmv.s.x   f0, zero        # f0 Resultado inicialmente zero
  1055.                 li      t0, 10            # inteiro 10
  1056.                 fcvt.s.w  f10, t0           # passa para o C1, f10 sempre contem a cte 10.0000
  1057.                 li      t0, 1           # inteiro 1
  1058.                 fcvt.s.w  f1, t0            # passa para o C1, f1 contem sempre o numero cte 1.000
  1059.  
  1060. ##### Verifica se tem 'e' ou 'E' na string  resultado em s3
  1061. procuraEreadFloat:
  1062.                   addi  s3, s0, 1     # inicialmente nao tem 'e' ou 'E' na string (fora da string)
  1063.                   mv  t0, s7              # endereco inicial
  1064. loopEreadFloat:
  1065.               beq t0, s0, naotemEreadFloat  # sai se nao encontrou 'e'
  1066.               lb    t1, 0(t0)         # le o caractere
  1067.               li    tp, 'e'
  1068.               beq   t1, tp, ehEreadFloat    # tem 'e'
  1069.               li    tp, 'E'
  1070.               beq   t1, tp, ehEreadFloat    # tem 'E'
  1071.               addi  t0, t0, 1         # incrementa endereco
  1072.               j   loopEreadFloat          # volta ao loop
  1073. ehEreadFloat:
  1074.             mv  s3, t0          # endereco do 'e' ou 'E' na string
  1075. naotemEreadFloat:               # nao tem 'e' ou 'E' s3 eh o endereco do \0 da string
  1076.  
  1077. ##### Verifica se tem '.' na string resultado em s2 espera-se que nao exista ponto no expoente
  1078. procuraPontoreadFloat:
  1079.                       mv s2, s3       # local inicial do ponto na string (='e' se existir) ou fora da string
  1080.                       mv  t0, s7              # endereco inicial
  1081. loopPontoreadFloat:
  1082.                   beq t0, s0, naotemPontoreadFloat  # sai se nao encontrou '.'
  1083.                   lb  t1, 0(t0)           # le o caractere
  1084.                   li    tp, '.'
  1085.                   beq   t1, tp, ehPontoreadFloat  # tem '.'
  1086.                   addi  t0, t0, 1         # incrementa endereco
  1087.                   j   loopPontoreadFloat        # volta ao loop
  1088. ehPontoreadFloat:
  1089.                   mv  s2, t0          # endereco do '.' na string
  1090. naotemPontoreadFloat:             # nao tem '.' s2 = local do 'e' ou \0 da string
  1091.  
  1092. ### Encontra a parte inteira em f0
  1093. intreadFloat:   fmv.s.x   f2, zero    # zera parte inteira
  1094.               addi  t0, s2, -1          # endereco do caractere antes do ponto
  1095.               fmv.s   f3, f1            # f3 contem unidade/dezenas/centenas
  1096.               mv  t6, s7              # Primeiro Endereco
  1097. loopintreadFloat:
  1098.                 blt t0, t6, fimintreadFloat # sai se o enderefo for < inicio da string
  1099.                 lb    t1, 0(t0)         # le o caracter
  1100.                 li    tp, '0'
  1101.                 blt   t1, tp, erroreadFloat   # nao eh caractere valido para numero
  1102.                 li    tp, '9'
  1103.                 bgt   t1, tp, erroreadFloat   # nao eh caractere valido para numero
  1104.                 addi  t1, t1, -48         # converte ascii para decimal
  1105.                 fcvt.s.w  f2, t1          # passa para o f2
  1106.  
  1107.                 fmul.s  f2,f2,f3          # multiplcica por un/dezena/centena
  1108.                 fadd.s  f0,f0,f2          # soma no resultado
  1109.                 fmul.s  f3,f3,f10         # proxima dezena/centena
  1110.  
  1111.                 addi t0,t0,-1           # endereco anterior
  1112.                 j loopintreadFloat          # volta ao loop
  1113. fimintreadFloat:
  1114.  
  1115. ### Encontra a parte fracionaria  ja em f0
  1116. fracreadFloat:
  1117.               fmv.s.x   f2, zero    # zera parte fracionaria
  1118.               addi  t0, s2, 1         # endereco depois do ponto
  1119.               fdiv.s  f3, f1, f10         # f3 inicial 0.1
  1120.  
  1121. loopfracreadFloat:
  1122.                   bge t0, s3, fimfracreadFloat  # endereco eh 'e' 'E' ou >ultimo
  1123.                   lb  t1, 0(t0)           # le o caracter
  1124.                   li    tp, '0'
  1125.                   blt   t1, tp, erroreadFloat   # nao eh valido
  1126.                   li    tp, '9'
  1127.                   bgt   t1, tp, erroreadFloat   # nao eh valido
  1128.                   addi  t1, t1, -48         # converte ascii para decimal
  1129.                   fcvt.s.w  f2, t1          # passa para C1
  1130.  
  1131.                   fmul.s  f2, f2, f3          # multiplica por ezena/centena
  1132.                   fadd.s  f0, f0, f2          # soma no resultado
  1133.                   fdiv.s  f3, f3, f10         # proxima frac un/dezena/centena
  1134.  
  1135.                   addi  t0, t0, 1         # proximo endereco
  1136.                   j   loopfracreadFloat       # volta ao loop
  1137. #fimfracreadFloat:
  1138.  
  1139. potreadFloat:
  1140.               fmv.s.x   f2, zero    # zera potencia
  1141.               addi  t0, s3, 1         # endereco seguinte ao 'e'
  1142.               li  s4, 0             # sinal do expoente positivo
  1143.               lb  t1, 0(t0)           # le o caractere seguinte ao 'e'
  1144.               li  tp, '-'
  1145.               beq t1, tp, potsinalnegreadFloat  # sinal do expoente esta escrito e eh positivo
  1146.               li  tp, '+'
  1147.               beq t1, tp, potsinalposreadFloat  # sinal do expoente eh negativo
  1148.               j   pulapotsinalreadFloat     # nao esta escrito o sinal do expoente
  1149. potsinalnegreadFloat:
  1150.                       li  s4, 1       # s4=1 expoente negativo
  1151. potsinalposreadFloat:
  1152.                       addi  t0, t0, 1   # se tiver '-' ou '+' avanca para o proximo endereco
  1153. pulapotsinalreadFloat:
  1154.                       mv    s5, t0    # Neste ponto s5 contem o endereco do primeiro digito da pot e s4 o sinal do expoente
  1155.  
  1156.                       fmv.s   f3, f1          # f3 un/dez/cen = 1
  1157.  
  1158. ### Encontra o expoente inteiro em t2
  1159. expreadFloat:
  1160.               li  t2, 0       # zera expoente
  1161.               mv  t0, s0          # endereco do ultimo caractere da string
  1162.               li  t3, 10            # numero dez
  1163.               li  t4, 1           # und/dez/cent
  1164.  
  1165. loopexpreadFloat:
  1166.                 blt t0, s5, fimexpreadFloat # ainda nao eh o endereco do primeiro digito?
  1167.                 lb  t1, 0(t0)         # le o caracter
  1168.                 addi  t1, t1, -48       # converte ascii para decimal
  1169.                 mul   t1, t1, t4        # mul digito
  1170.                 add   t2, t2, t1        # soma ao exp
  1171.                 mul   t4, t4, t3        # proxima casa decimal
  1172.                 addi  t0, t0, -1        # endereco anterior
  1173.                 j loopexpreadFloat        # volta ao loop
  1174.  
  1175. fimexpreadFloat:
  1176. # calcula o numero em f2 o numero 10^exp
  1177.                 fmv.s   f2, f1          # numero 10^exp  inicial=1
  1178.                 fmv.s   f3, f10         # se o sinal for + f3 eh 10
  1179.                 beq   s4, zero, sinalexpPosreadFloat  # se sinal exp positivo
  1180.                 fdiv.s  f3, f1, f10       # se o final for - f3 eh 0.1
  1181. sinalexpPosreadFloat:
  1182.                     li  t0, 0     # contador
  1183. sinalexpreadFloat:
  1184.                    beq t0, t2, fimsinalexpreadFloat  # se chegou ao fim
  1185.                   fmul.s  f2, f2, f3        # multiplica pelo fator 10 ou 0.1
  1186.                   addi  t0, t0, 1       # incrementa o contador
  1187.                   j   sinalexpreadFloat
  1188. fimsinalexpreadFloat:
  1189.  
  1190.                     fmul.s  f0, f0, f2          # multiplicacao final!
  1191.  
  1192.                     la  t0, TempBuffer          # ajuste final do sinal do numero
  1193.                     lb  t1, 0(t0)           # le primeiro caractere
  1194.                     li    tp, '-'
  1195.                     bne   t1, tp, fimreadFloat    # nao eh '-' entao fim
  1196.                     fneg.s  f0, f0            # nega o numero float
  1197.  
  1198. #erroreadFloat:
  1199. fimreadFloat:
  1200.               lw  ra, 0(sp)       # recupera ra
  1201.               addi  sp, sp, 4         # libera espaco
  1202.               jalr zero,ra,0            # retorna
  1203.  
  1204.  
  1205. ############################################
  1206. #  Time                                #
  1207. #  a0    =    Time                     #
  1208. #  a1    =    zero                     #
  1209. ############################################
  1210.  
  1211. time:
  1212.     li a7,30      # ecall time
  1213.     ecall
  1214.     j fimTime
  1215.  
  1216. fimTime:
  1217.         jalr zero,ra,0
  1218.  
  1219.  
  1220. ############################################
  1221. #  Sleep                                 #
  1222. #  a0    =    Tempo em ms                  #
  1223. ############################################
  1224.  
  1225. sleep:
  1226.     li a7,32    # ecall sleep
  1227.     ecall
  1228.     j fimSleep
  1229.  
  1230. loopSleep:
  1231.         lw t1, 0(t0)  # carrega o contador de ms
  1232.         blt t1,t2,loopSleep
  1233.  
  1234. fimSleep:
  1235.         jalr zero,ra,0    # retorna
  1236.  
  1237.  
  1238. ############################################
  1239. #  Random                                #
  1240. #  a0    =    numero randomico             #
  1241. ############################################
  1242.  
  1243. random:
  1244.         li a7,41    # chama rand
  1245.         ecall
  1246.         j fimRandom   # saida
  1247.  
  1248. fimRandom:
  1249.             jalr zero,ra,0
  1250.  
  1251.  
  1252. #################################
  1253. #    CLS                        #
  1254. #  Clear Screen                 #
  1255. #  a0 = cor                    #
  1256. #################################
  1257.  
  1258. clsCLS:
  1259.         li t1, VGAADDRESSINI
  1260.         li t2, VGAADDRESSFIM
  1261.         andi a0,a0,0X00FF
  1262.         mul a0,t0,a0
  1263.  
  1264. forCLS:
  1265.         beq t1,t2,fimCLS
  1266.         addi t1,t1,4
  1267.         j forCLS
  1268.  
  1269. fimCLS:
  1270.         jalr zero,ra,0
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement
Public Pastes
Advertisement
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!