Subversion Repositories Kolibri OS

Rev

Rev 836 | Go to most recent revision | Blame | Compare with Previous | Last modification | View Log | Download | RSS feed

  1.  
  2. ; Macroinstructions for defining and calling procedures
  3.  
  4. macro stdcall proc,[arg]                ; directly call STDCALL procedure
  5.  { common
  6.     if ~ arg eq
  7.    reverse
  8.     pushd arg
  9.    common
  10.     end if
  11.     call proc }
  12.  
  13. macro invoke proc,[arg]                 ; indirectly call STDCALL procedure
  14.  { common
  15.     if ~ arg eq
  16.    reverse
  17.      pushd arg
  18.    common
  19.     end if
  20.     call [proc] }
  21.  
  22. macro ccall proc,[arg]                  ; directly call CDECL procedure
  23.  { common
  24.     size@ccall = 0
  25.     if ~ arg eq
  26.    reverse
  27.     pushd arg
  28.     size@ccall = size@ccall+4
  29.    common
  30.     end if
  31.     call proc
  32.     if size@ccall
  33.     add esp,size@ccall
  34.     end if }
  35.  
  36. macro cinvoke proc,[arg]                ; indirectly call CDECL procedure
  37.  { common
  38.     size@ccall = 0
  39.     if ~ arg eq
  40.    reverse
  41.     pushd arg
  42.     size@ccall = size@ccall+4
  43.    common
  44.     end if
  45.     call [proc]
  46.     if size@ccall
  47.     add esp,size@ccall
  48.     end if }
  49.  
  50. macro proc [args]                       ; define procedure
  51.  { common
  52.     match name params, args>
  53.     \{ define@proc name,<params \} }
  54.  
  55. prologue@proc equ prologuedef
  56.  
  57. macro prologuedef procname,flag,parmbytes,localbytes,reglist
  58.  { if parmbytes | localbytes
  59.     push ebp
  60.     mov ebp,esp
  61.     if localbytes
  62.      sub esp,localbytes
  63.     end if
  64.    end if
  65.    irps reg, reglist \{ push reg \} }
  66.  
  67. epilogue@proc equ epiloguedef
  68.  
  69. macro epiloguedef procname,flag,parmbytes,localbytes,reglist
  70.  { irps reg, reglist \{ reverse pop reg \}
  71.    if parmbytes | localbytes
  72.     leave
  73.    end if
  74.    if flag and 10000b
  75.     retn
  76.    else
  77.     retn parmbytes
  78.    end if }
  79.  
  80. macro define@proc name,statement
  81.  { local params,flag,regs,parmbytes,localbytes,current
  82.    if used name
  83.    name:
  84.    match =stdcall args, statement \{ params equ args
  85.                                      flag = 11b \}
  86.    match =stdcall, statement \{ params equ
  87.                                 flag = 11b \}
  88.    match =c args, statement \{ params equ args
  89.                                flag = 10001b \}
  90.    match =c, statement \{ params equ
  91.                           flag = 10001b \}
  92.    match =params, params \{ params equ statement
  93.                             flag = 0 \}
  94.    virtual at ebp+8
  95.    match =uses reglist=,args, params \{ regs equ reglist
  96.                                         params equ args \}
  97.    match =regs =uses reglist, regs params \{ regs equ reglist
  98.                                              params equ \}
  99.    match =regs, regs \{ regs equ \}
  100.    match =,args, params \{ defargs@proc args \}
  101.    match =args@proc args, args@proc params \{ defargs@proc args \}
  102.    parmbytes = $ - (ebp+8)
  103.    end virtual
  104.    name # % = parmbytes/4
  105.    all@vars equ
  106.    current = 0
  107.    match prologue:reglist, prologue@proc:<regs> \{ prologue name,flag,parmbytes,localbytes,reglist \}
  108.    macro locals
  109.    \{ virtual at ebp-localbytes+current
  110.       macro label . \\{ deflocal@proc .,:, \\}
  111.       struc db [val] \\{ \common deflocal@proc .,db,val \\}
  112.       struc dw [val] \\{ \common deflocal@proc .,dw,val \\}
  113.       struc dp [val] \\{ \common deflocal@proc .,dp,val \\}
  114.       struc dd [val] \\{ \common deflocal@proc .,dd,val \\}
  115.       struc dt [val] \\{ \common deflocal@proc .,dt,val \\}
  116.       struc dq [val] \\{ \common deflocal@proc .,dq,val \\}
  117.       struc rb cnt \\{ deflocal@proc .,rb cnt, \\}
  118.       struc rw cnt \\{ deflocal@proc .,rw cnt, \\}
  119.       struc rp cnt \\{ deflocal@proc .,rp cnt, \\}
  120.       struc rd cnt \\{ deflocal@proc .,rd cnt, \\}
  121.       struc rt cnt \\{ deflocal@proc .,rt cnt, \\}
  122.       struc rq cnt \\{ deflocal@proc .,rq cnt, \\} \}
  123.    macro endl
  124.    \{ purge label
  125.       restruc db,dw,dp,dd,dt,dq
  126.       restruc rb,rw,rp,rd,rt,rq
  127.       restruc byte,word,dword,pword,tword,qword
  128.       current = $-(ebp-localbytes)
  129.       end virtual \}
  130.    macro ret operand
  131.    \{ match any, operand \\{ retn operand \\}
  132.       match , operand \\{ match epilogue:reglist, epilogue@proc:<regs>
  133.                           \\\{ epilogue name,flag,parmbytes,localbytes,reglist \\\} \\} \}
  134.    macro finish@proc \{ localbytes = (((current-1) shr 2)+1) shl 2
  135.                         end if \} }
  136.  
  137. macro defargs@proc [arg]
  138.  { common
  139.     if ~ arg eq
  140.    forward
  141.      local ..arg,current@arg
  142.      match argname:type, arg
  143.       \{ current@arg equ argname
  144.          label ..arg type
  145.          argname equ ..arg
  146.          if dqword eq type
  147.            dd ?,?,?,?
  148.          else if tbyte eq type
  149.            dd ?,?,?
  150.          else if qword eq type | pword eq type
  151.            dd ?,?
  152.          else
  153.            dd ?
  154.          end if \}
  155.      match =current@arg,current@arg
  156.       \{ current@arg equ arg
  157.          arg equ ..arg
  158.          ..arg dd ? \}
  159.    common
  160.      args@proc equ current@arg
  161.    forward
  162.      restore current@arg
  163.    common
  164.     end if }
  165.  
  166. macro deflocal@proc name,def,[val]
  167.  { common
  168.     match vars, all@vars \{ all@vars equ all@vars, \}
  169.     all@vars equ all@vars name
  170.    forward
  171.     local ..var,..tmp
  172.     ..var def val
  173.     match =?, val \{ ..tmp equ \}
  174.     match any =dup (=?), val \{ ..tmp equ \}
  175.     match tmp : value, ..tmp : val
  176.      \{ tmp: end virtual
  177.         initlocal@proc ..var,def value
  178.         virtual at tmp\}
  179.    common
  180.     match first rest, ..var, \{ name equ first \} }
  181.  
  182. macro initlocal@proc name,def
  183.  { virtual at name
  184.     def
  185.     size@initlocal = $ - name
  186.    end virtual
  187.    position@initlocal = 0
  188.    while size@initlocal > position@initlocal
  189.     virtual at name
  190.      def
  191.      if size@initlocal - position@initlocal < 2
  192.       current@initlocal = 1
  193.       load byte@initlocal byte from name+position@initlocal
  194.      else if size@initlocal - position@initlocal < 4
  195.       current@initlocal = 2
  196.       load word@initlocal word from name+position@initlocal
  197.      else
  198.       current@initlocal = 4
  199.       load dword@initlocal dword from name+position@initlocal
  200.      end if
  201.     end virtual
  202.     if current@initlocal = 1
  203.      mov byte [name+position@initlocal],byte@initlocal
  204.     else if current@initlocal = 2
  205.      mov word [name+position@initlocal],word@initlocal
  206.     else
  207.      mov dword [name+position@initlocal],dword@initlocal
  208.     end if
  209.     position@initlocal = position@initlocal + current@initlocal
  210.    end while }
  211.  
  212. macro endp
  213.  { purge ret,locals,endl
  214.    finish@proc
  215.    purge finish@proc
  216.    restore regs@proc
  217.    match all,args@proc \{ restore all \}
  218.    restore args@proc
  219.    match all,all@vars \{ restore all \} }
  220.  
  221. macro local [var]
  222.  { common
  223.     locals
  224.    forward done@local equ
  225.     match varname[count]:vartype, var
  226.     \{ match =BYTE, vartype \\{ varname rb count
  227.                                 restore done@local \\}
  228.        match =WORD, vartype \\{ varname rw count
  229.                                 restore done@local \\}
  230.        match =DWORD, vartype \\{ varname rd count
  231.                                  restore done@local \\}
  232.        match =PWORD, vartype \\{ varname rp count
  233.                                  restore done@local \\}
  234.        match =QWORD, vartype \\{ varname rq count
  235.                                  restore done@local \\}
  236.        match =TBYTE, vartype \\{ varname rt count
  237.                                  restore done@local \\}
  238.        match =DQWORD, vartype \\{ label varname dqword
  239.                                   rq count+count
  240.                                   restore done@local \\}
  241.        match , done@local \\{ virtual
  242.                                varname vartype
  243.                               end virtual
  244.                               rb count*sizeof.\#vartype
  245.                               restore done@local \\} \}
  246.     match :varname:vartype, done@local:var
  247.     \{ match =BYTE, vartype \\{ varname db ?
  248.                                 restore done@local \\}
  249.        match =WORD, vartype \\{ varname dw ?
  250.                                 restore done@local \\}
  251.        match =DWORD, vartype \\{ varname dd ?
  252.                                  restore done@local \\}
  253.        match =PWORD, vartype \\{ varname dp ?
  254.                                  restore done@local \\}
  255.        match =QWORD, vartype \\{ varname dq ?
  256.                                  restore done@local \\}
  257.        match =TBYTE, vartype \\{ varname dt ?
  258.                                  restore done@local \\}
  259.        match =DQWORD, vartype \\{ label varname dqword
  260.                                   dq ?,?
  261.                                   restore done@local \\}
  262.        match , done@local \\{ varname vartype
  263.                               restore done@local \\} \}
  264.     match ,done@local
  265.     \{ var
  266.        restore done@local \}
  267.    common
  268.     endl }
  269.