Questo sito utilizza cookies solo per scopi di autenticazione sul sito e nient'altro. Nessuna informazione personale viene tracciata. Leggi l'informativa sui cookies.
Username: Password: oppure
Midgen - parser.s

parser.s

Caricato da: ZioCrocifisso
Scarica il programma completo

  1. %include "src/parser.inc"
  2.  
  3. global parse
  4. global tokenid
  5. global tokenval
  6.  
  7. extern parseint
  8. extern getchar
  9. extern write
  10.  
  11. section .data
  12.         tokenid dd 0
  13.         tokenval dd 0
  14.         state dd STATE_START
  15.         numstr db '0000000000000000'
  16.         numlen dd 0
  17.         errorstring db 'Errore di sintassi.', 10, 0
  18.  
  19. section .text
  20.         parse:
  21.                 call getchar
  22.                 mov ebx, [state]
  23.                 shr ebx, 8
  24.                 jmp [ebx * 4 + .table]
  25.  
  26.                 .null:
  27.                         cmp eax, '0'
  28.                         jl .nonumber
  29.                         cmp eax, '9'
  30.                         jg .nonumber
  31.                         jmp .number
  32.  
  33.                         .nonumber:
  34.                         test eax, eax
  35.                         jz .end
  36.                         cmp eax, 0xFFFFFFFF
  37.                         jz .end
  38.                         cmp eax, '('
  39.                         je .char_bl
  40.                         cmp eax, '!'
  41.                         je .char_neg
  42.                         cmp eax, ':'
  43.                         je .char_colon
  44.                         cmp eax, '+'
  45.                         je .char_plus
  46.                         cmp eax, '-'
  47.                         je .char_minus
  48.                         cmp eax, '^'
  49.                         je .char_caret
  50.                         cmp eax, '/'
  51.                         je .char_slash
  52.                         cmp eax, '.'
  53.                         je .char_dot
  54.                         cmp eax, ';'
  55.                         je .char_semicolon
  56.                         cmp eax, '@'
  57.                         je .char_at
  58.                         cmp eax, 'n'
  59.                         mov ebx, TOKEN_BASE
  60.                         je .setting
  61.                         cmp eax, 'i'
  62.                         mov ebx, TOKEN_INSTRUMENT
  63.                         je .setting
  64.                         cmp eax, 'c'
  65.                         mov ebx, TOKEN_CHANNEL
  66.                         je .setting
  67.                         cmp eax, 't'
  68.                         mov ebx, TOKEN_TEMPO
  69.                         je .setting
  70.                         cmp eax, 'v'
  71.                         mov ebx, TOKEN_VOLUME
  72.                         je .setting
  73.                         cmp eax, 'd'
  74.                         mov ebx, TOKEN_DELTA
  75.                         je .setting
  76.                         jmp parse
  77.  
  78.                 .setting_open:
  79.                         cmp eax, '<'
  80.                         jne .syntaxerror
  81.                         mov eax, [state]
  82.                         mov dword [state], STATE_SETTING_NUMBER
  83.                         or [state], al
  84.                         jmp parse
  85.  
  86.                 .setting_number:
  87.                         cmp eax, '>'
  88.                         je .setting_end
  89.                         jmp .addnumber
  90.  
  91.                 .noteoff_open:
  92.                         cmp eax, '('
  93.                         jne .syntaxerror
  94.                         mov dword [state], STATE_LONGNOTE_NUMBER
  95.                         or dword [state], STATE_ATTRIB_OFF
  96.                         jmp parse
  97.  
  98.                 .longnote_number:
  99.                         cmp eax, ')'
  100.                         je .longnote_end
  101.                         jmp .addnumber
  102.  
  103.                 .start:
  104.                         mov dword [tokenid], TOKEN_START
  105.                         mov dword [state], STATE_NULL
  106.                         jmp write
  107.  
  108.                 .end:
  109.                         mov dword [state], STATE_END
  110.                         mov dword [tokenid], TOKEN_END
  111.                         jmp write
  112.  
  113.                 .number:
  114.                         mov dword [tokenid], TOKEN_NOTEON
  115.                         sub eax, '0'
  116.                         mov [tokenval], eax
  117.                         jmp write
  118.  
  119.                 .char_bl:
  120.                         mov dword [state], STATE_LONGNOTE_NUMBER
  121.                         jmp parse
  122.  
  123.                 .char_neg:
  124.                         mov dword [state], STATE_NOTEOFF_OPEN
  125.                         jmp parse
  126.  
  127.                 .char_colon:
  128.                         mov dword [tokenid], TOKEN_ZERODELTA
  129.                         jmp write
  130.  
  131.                 .char_plus:
  132.                         mov dword [tokenid], TOKEN_INCDELTA
  133.                         jmp write
  134.  
  135.                 .char_minus:
  136.                         mov dword [tokenid], TOKEN_DECDELTA
  137.                         jmp write
  138.  
  139.                 .char_caret:
  140.                         mov dword [tokenid], TOKEN_INCVOLUME
  141.                         jmp write
  142.  
  143.                 .char_slash:
  144.                         mov dword [tokenid], TOKEN_DECVOLUME
  145.                         jmp write
  146.  
  147.                 .char_dot:
  148.                         mov dword [tokenid], TOKEN_CONTINUE
  149.                         jmp write
  150.  
  151.                 .char_at:
  152.                         mov dword [tokenid], TOKEN_STOPMODE
  153.                         jmp write
  154.  
  155.                 .char_semicolon:
  156.                         mov dword [tokenid], TOKEN_END
  157.                         mov dword [state], STATE_END
  158.                         jmp write
  159.  
  160.                 .setting:
  161.                         mov dword [state], STATE_SETTING_OPEN
  162.                         or [state], bl
  163.                         jmp parse
  164.  
  165.                 .addnumber:
  166.                         mov ebx, [numlen]
  167.  
  168.                         cmp ebx, 15
  169.                         jg .syntaxerror
  170.  
  171.                         mov [numstr + ebx], eax
  172.                         inc dword [numlen]
  173.                         jmp parse
  174.  
  175.                 .setting_end:
  176.                         mov eax, [state]
  177.                         and eax, 0xFF
  178.                         mov [tokenid], eax
  179.  
  180.                         mov eax, [numlen]
  181.                         mov dword [numstr + eax], 0
  182.                         push dword numstr
  183.                         call parseint
  184.                         add esp, 4
  185.  
  186.                         mov [tokenval], eax
  187.                         mov dword [numlen], 0
  188.                         mov dword [state], STATE_NULL
  189.                         jmp write
  190.  
  191.                 .longnote_end:
  192.                         mov eax, [state]
  193.                         and eax, 0xFF
  194.                         add eax, TOKEN_NOTEON
  195.  
  196.                         mov [tokenid], eax
  197.  
  198.                         mov eax, [numlen]
  199.                         mov dword [numstr + eax], 0
  200.                         push dword numstr
  201.                         call parseint
  202.                         add esp, 4
  203.  
  204.                         mov [tokenval], eax
  205.                         mov dword [numlen], 0
  206.                         mov dword [state], STATE_NULL
  207.                         jmp write
  208.  
  209.                 .syntaxerror:
  210.                         mov eax, 0x4
  211.                         mov ebx, 0x2
  212.                         mov ecx, errorstring
  213.                         mov edx, 22
  214.                         int 0x80
  215.                         mov dword [state], STATE_END
  216.                         jmp parse
  217.  
  218.                 .table:
  219.                         dd .null
  220.                         dd .null
  221.                         dd .setting_open
  222.                         dd .setting_number
  223.                         dd .noteoff_open
  224.                         dd .longnote_number
  225.                         dd .start
  226.                         dd .end