Subversion Repositories Kolibri OS

Rev

Rev 5363 | Rev 8965 | Go to most recent revision | Show entire file | Regard whitespace | Details | Blame | Last modification | View Log | RSS feed

Rev 5363 Rev 7294
Line 1... Line -...
1 
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 - 
 
2 
;;                                                              ;;
 - 
 
3 
;; Copyright (C) KolibriOS team 2004-2015. All rights reserved. ;;
 - 
 
4 
;; Distributed under terms of the GNU General Public License    ;;
 - 
 
5 
;;                                                              ;;
 - 
 
6 
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 - 
 
7 
 
 - 
 
8 
$Revision: 5363 $
 - 
 
9 
 
 - 
 
Line 10... Line 1...
10 
 
 1 
; Macroinstructions for defining and calling procedures
Line 11... Line 2...
11 
; Macroinstructions for defining and calling procedures
 2 
 
12 
 
 3 
macro stdcall proc,[arg]                ; directly call STDCALL procedure
Line 62... Line 53...
62 
    \{ define@proc name,
 53 
 
Line 63... Line 54...
63 
 
 54 
prologue@proc equ prologuedef
Line 64... Line 55...
64 
prologue@proc equ prologuedef
 55 
 
- 
 
 56 
macro prologuedef procname,flag,parmbytes,localbytes,reglist
- 
 
 57 
 { local loc
- 
 
 58 
   loc = (localbytes+3) and (not 3)
- 
 
 59 
   parmbase@proc equ ebp+8
65 
 
 60 
   localbase@proc equ ebp-loc
66 
macro prologuedef procname,flag,parmbytes,localbytes,reglist
 61 
   if parmbytes | localbytes
67 
 { if parmbytes | localbytes
 62 
        push    ebp
68 
        push    ebp
 63 
        mov     ebp, esp
69 
        mov     ebp, esp
 64 
    if localbytes
70 
    if localbytes
 65 
        sub     esp, loc
71 
        sub     esp, localbytes
 66 
    end if
72 
    end if
 67 
   end if
Line 73... Line 68...
73 
   end if
 68 
   irps reg, reglist \{ push reg \} }
Line 78... Line 73...
78 
macro epiloguedef procname,flag,parmbytes,localbytes,reglist
 73 
 { irps reg, reglist \{ reverse pop reg \}
79 
 { irps reg, reglist \{ reverse pop reg \}
 74 
   if parmbytes | localbytes
80 
   if parmbytes | localbytes
 75 
        leave
81 
        leave
 76 
   end if
82 
   end if
 77 
   if flag and 10000b
83 
   if (flag and 10000b) | (parmbytes=0)
 78 
        retn
84 
        retn
 79 
   else
85 
   else
 80 
        retn    parmbytes
86 
        retn    parmbytes
 81 
   end if }
87 
   end if }
 82 
 
Line -... Line 83...
- 
 
 83 
close@proc equ
- 
 
 84 
 
88 
 
 85 
macro define@proc name,statement
89 
macro define@proc name,statement
 86 
 { local params,flag,regs,parmbytes,localbytes,current
90 
 { local params,flag,regs,parmbytes,localbytes,current
 87 
   if used name
91 
   if used name
 88 
   name:
92 
   name:
 89 
   match =stdcall args, statement \{ params equ args
Line 98... Line 95...
98 
                               flag = 10001b \}
 95 
   match =c, statement \{ params equ
99 
   match =c, statement \{ params equ
 96 
                          flag = 10001b \}
100 
                          flag = 10001b \}
 97 
   match =params, params \{ params equ statement
101 
   match =params, params \{ params equ statement
 98 
                            flag = 0 \}
102 
                            flag = 0 \}
 99 
   match =uses reglist=,args, params \{ regs equ reglist
103 
   virtual at ebp+8
 - 
 
104 
   match =uses reglist=,args, params \{ regs equ reglist
 100 
                                        params equ args \}
105 
                                        params equ args \}
 101 
   match =regs =uses reglist, regs params \{ regs equ reglist
106 
   match =regs =uses reglist, regs params \{ regs equ reglist
 102 
                                             params equ \}
107 
                                             params equ \}
 103 
   match =regs, regs \{ regs equ \}
108 
   match =regs, regs \{ regs equ \}
 104 
   match prologue:reglist, prologue@proc: \{ prologue name,flag,parmbytes,localbytes,reglist \}
- 
 
 105 
   virtual at parmbase@proc
- 
 
 106 
   match =,args, params \{ defargs@proc args \}
109 
   match =,args, params \{ defargs@proc args \}
 107 
   match =args@proc args, args@proc params \{ defargs@proc args \}
110 
   match =args@proc args, args@proc params \{ defargs@proc args \}
 108 
   parmbytes = $-(parmbase@proc)
111 
   parmbytes = $ - (ebp+8)
 109 
   end virtual
112 
   end virtual
 110 
   name # % = parmbytes/4
113 
   name # % = parmbytes/4
 111 
   all@vars equ
114 
   all@vars equ
 112 
   current = 0
115 
   current = 0
 113 
   macro locals
116 
   match prologue:reglist, prologue@proc: \{ prologue name,flag,parmbytes,localbytes,reglist \}
 - 
 
117 
   macro locals
 114 
   \{ virtual at localbase@proc+current
118 
   \{ virtual at ebp-localbytes+current
 115 
      macro label def \\{ match . type,def> \\\{ deflocal@proc .,label,
119 
      macro label . \\{ deflocal@proc .,:, \\}
 116 
      struc db [val] \\{ \common deflocal@proc .,db,val \\}
120 
      struc db [val] \\{ \common deflocal@proc .,db,val \\}
 117 
      struc du [val] \\{ \common deflocal@proc .,du,val \\}
- 
 
 118 
      struc dw [val] \\{ \common deflocal@proc .,dw,val \\}
121 
      struc dw [val] \\{ \common deflocal@proc .,dw,val \\}
 119 
      struc dp [val] \\{ \common deflocal@proc .,dp,val \\}
122 
      struc dp [val] \\{ \common deflocal@proc .,dp,val \\}
 120 
      struc dd [val] \\{ \common deflocal@proc .,dd,val \\}
123 
      struc dd [val] \\{ \common deflocal@proc .,dd,val \\}
 121 
      struc dt [val] \\{ \common deflocal@proc .,dt,val \\}
124 
      struc dt [val] \\{ \common deflocal@proc .,dt,val \\}
 122 
      struc dq [val] \\{ \common deflocal@proc .,dq,val \\}
125 
      struc dq [val] \\{ \common deflocal@proc .,dq,val \\}
 123 
      struc rb cnt \\{ deflocal@proc .,rb cnt, \\}
Line 129... Line 127...
129 
      struc rd cnt \\{ deflocal@proc .,rd cnt, \\}
 127 
      struc rt cnt \\{ deflocal@proc .,rt cnt, \\}
130 
      struc rt cnt \\{ deflocal@proc .,rt cnt, \\}
 128 
      struc rq cnt \\{ deflocal@proc .,rq cnt, \\} \}
131 
      struc rq cnt \\{ deflocal@proc .,rq cnt, \\} \}
 129 
   macro endl
132 
   macro endl
 130 
   \{ purge label
133 
   \{ purge label
 131 
      restruc db,du,dw,dp,dd,dt,dq
134 
      restruc db,dw,dp,dd,dt,dq
 132 
      restruc rb,rw,rp,rd,rt,rq
135 
      restruc rb,rw,rp,rd,rt,rq
 133 
      current = $-(localbase@proc)
136 
      restruc byte,word,dword,pword,tword,qword
 - 
 
137 
      current = $-(ebp-localbytes)
 134 
      end virtual \}
138 
      end virtual \}
 135 
   macro ret operand
139 
   macro ret operand
 136 
   \{ match any, operand \\{ retn operand \\}
140 
   \{ match any, operand \\{ retn operand \\}
 137 
      match , operand \\{ match epilogue:reglist, epilogue@proc: \\\{ epilogue name,flag,parmbytes,localbytes,reglist \\\} \\} \}
141 
      match , operand \\{ match epilogue:reglist, epilogue@proc:
 138 
   macro finish@proc
- 
 
 139 
   \{ localbytes = current
142 
                          \\\{ epilogue name,flag,parmbytes,localbytes,reglist \\\} \\} \}
 140 
      match close:reglist, close@proc: \\{ close name,flag,parmbytes,localbytes,reglist \\}
143 
   macro finish@proc \{ localbytes = (((current-1) shr 2)+1) shl 2
 141 
      end if \} }
144 
                        end if \} }
 142 
 
Line 145... Line 143...
145 
 
 143 
macro defargs@proc [arg]
146 
macro defargs@proc [arg]
 144 
 { common
147 
 { common
 145 
    if ~ arg eq
Line 170... Line 168...
170 
   forward
 168 
     restore current@arg
171 
     restore current@arg
 169 
   common
172 
   common
 170 
    end if }
173 
    end if }
 171 
 
Line -... Line 172...
- 
 
 172 
macro deflocal@proc name,def,[val] { name def val }
- 
 
 173 
 
174 
 
 174 
macro deflocal@proc name,def,[val]
175 
macro deflocal@proc name,def,[val]
 175 
 { common
176 
 { common
 176 
    match vars, all@vars \{ all@vars equ all@vars, \}
177 
    match vars, all@vars \{ all@vars equ all@vars, \}
 177 
    all@vars equ all@vars name
178 
    all@vars equ all@vars name
 178 
   forward
179 
   forward
 179 
    local ..var,..tmp
180 
    local ..var,..tmp
 180 
    ..var def val
181 
    ..var def val
 181 
    match =?, val \{ ..tmp equ \}
- 
 
 182 
    match any =?, val \{ ..tmp equ \}
182 
    match =?, val \{ ..tmp equ \}
 183 
    match any (=?), val \{ ..tmp equ \}
- 
 
 184 
    match =label, def \{ ..tmp equ \}
183 
    match any =dup (=?), val \{ ..tmp equ \}
 185 
    match tmp : value, ..tmp : val
184 
    match tmp : value, ..tmp : val
 186 
     \{ tmp: end virtual
185 
     \{ tmp: end virtual
 187 
        initlocal@proc ..var,def value
186 
        initlocal@proc ..var,def value
 188 
        virtual at tmp\}
187 
        virtual at tmp\}
 189 
   common
188 
   common
 190 
    match first rest, ..var, \{ name equ first \} }
Line -... Line 191...
- 
 
 191 
 
- 
 
 192 
struc label type { label . type }
189 
    match first rest, ..var, \{ name equ first \} }
 193 
 
190 
 
 194 
macro initlocal@proc name,def
191 
macro initlocal@proc name,def
 195 
 { virtual at name
192 
 { virtual at name
 196 
    def
193 
    def
 197 
    size@initlocal = $ - name