WebSVN – Kolibri OS – Diff – /programs/develop/fast_call_test/MACROS.INC


; new application structure
macro meos_app_start
 {
  use32
  org 0x0
 
  db 'MENUET01'
  dd 0x01
  dd __start
  dd __end
  dd __memory
  dd __stack
 
  if used __params & ~defined __params
    dd __params
  else
    dd 0x0
  end if
 
  dd 0x0
 }
MEOS_APP_START fix meos_app_start
 
macro code
 {
  __start:
 }
CODE fix code
 
macro data
 {
  __data:
 }
DATA fix data
 
macro udata
 {
  if used __params & ~defined __params
    __params:
      db 0
    __end:
      rb 255
  else
    __end:
  end if
  __udata:
 }
UDATA fix udata
 
macro meos_app_end
 {
  align 32
  rb 2048
  __stack:
  __memory:
 }
MEOS_APP_END fix meos_app_end
 
 
; macro for defining multiline text data
struc mstr [sstring]
 {
  forward
    local ssize
    virtual at 0
      db sstring
      ssize = $
    end virtual
    dd ssize
    db sstring
  common
    dd -1
 }
 
 
; strings
macro sz name,[data] {       ; from MFAR [mike.dld]
  common
   if used name
    label name
   end if
  forward
   if used name
    db data
   end if
  common
   if used name
    .size = $-name
   end if
}
 
macro lsz name,[lng,data] {  ; from MFAR [mike.dld]
  common
   if used name
    label name
   end if
  forward
   if (used name)&(lang eq lng)
    db data
   end if
  common
   if used name
    .size = $-name
   end if
}
 
 
 
; easy system call macro
macro mpack dest, hsrc, lsrc
{
  if (hsrc eqtype 0) & (lsrc eqtype 0)
    mov dest, (hsrc) shl 16 + lsrc
  else
    if (hsrc eqtype 0) & (~lsrc eqtype 0)
      mov dest, (hsrc) shl 16
      add dest, lsrc
    else
      mov dest, hsrc
      shl dest, 16
      add dest, lsrc
    end if
  end if
}
 
macro __mov reg,a {         ; mike.dld
 if ~a eq
   mov reg,a
 end if
}
 
__CPU_type      equ     p6
SYSENTER_VAR    equ     0
 
macro mcall a,b,c,d,e,f {   ; mike.dld, updated by Ghost for Fast System Calls
 local  ..ret_point
 __mov eax,a
 __mov ebx,b
 __mov ecx,c
 __mov edx,d
 __mov esi,e
 __mov edi,f
 
 if __CPU_type eq p5
        int     0x40
 else
  if __CPU_type eq p6
        push    ebp
        mov     ebp, esp
        push    ..ret_point     ; it may be 2 or 5 byte
        sysenter
 ..ret_point:
        pop     edx
        pop     ecx
 
  else
   if __CPU_type eq k6
        push    ecx
        syscall
        pop     ecx
   else
        display 'ERROR : unknown CPU type'
        int     0x40
   end if
  end if
 end if
}
 
 
; language for programs
lang fix ru ; ru en fr ge fi
 
 
 
; optimize the code for size
__regs fix 
 
macro add arg1,arg2
 {
   if (arg2 eqtype 0)
      if (arg2) = 1
         inc arg1
      else
         add arg1,arg2
      end if
   else
      add arg1,arg2
   end if
 }
 
macro sub arg1,arg2
 {
   if (arg2 eqtype 0)
      if (arg2) = 1
         dec arg1
      else
         sub arg1,arg2
      end if
   else
      sub arg1,arg2
   end if
 }
 
macro mov arg1,arg2
 {
   if (arg1 in __regs) & (arg2 eqtype 0)
      if (arg2) = 0
         xor arg1,arg1
      else if (arg2) = 1
         xor arg1,arg1
         inc arg1
      else if (arg2) = -1
         or  arg1,-1
      else if (arg2) > -128 & (arg2) < 128
         push arg2
         pop  arg1
      else
         mov  arg1,arg2
      end if
   else
      mov arg1,arg2
   end if
 }
 
 
macro struct name
 {
  virtual at 0
   name name
   sizeof.#name = $ - name
  end virtual
 }
 
; structures used in MeOS
struc process_information
 {
  .cpu_usage               dd ?  ; +0
  .window_stack_position   dw ?  ; +4
  .window_stack_value      dw ?  ; +6
  .not_used1               dw ?  ; +8
  .process_name            rb 12 ; +10
  .memory_start            dd ?  ; +22
  .used_memory             dd ?  ; +26
  .PID                     dd ?  ; +30
  .x_start                 dd ?  ; +34
  .y_start                 dd ?  ; +38
  .x_size                  dd ?  ; +42
  .y_size                  dd ?  ; +46
  .slot_state              dw ?  ; +50
  rb (1024-52)
 }
struct process_information
 
struc system_colors
 {
  .frame            dd ?
  .grab             dd ?
  .grab_button      dd ?
  .grab_button_text dd ?
  .grab_text        dd ?
  .work             dd ?
  .work_button      dd ?
  .work_button_text dd ?
  .work_text        dd ?
  .work_graph       dd ?
 }
struct system_colors
 
 
; constants
 
; events
EV_IDLE        = 0
EV_TIMER       = 0
EV_REDRAW      = 1
EV_KEY         = 2
EV_BUTTON      = 3
EV_EXIT        = 4
EV_BACKGROUND  = 5
EV_MOUSE       = 6
EV_IPC         = 7
EV_STACK       = 8
 
; event mask bits for function 40
EVM_REDRAW     =        1b
EVM_KEY        =       10b
EVM_BUTTON     =      100b
EVM_EXIT       =     1000b
EVM_BACKGROUND =    10000b
EVM_MOUSE      =   100000b
EVM_IPC        =  1000000b
EVM_STACK      = 10000000b

Rev 477	Rev 805
1	; new application structure	1	; new application structure
2	macro meos_app_start	2	macro meos_app_start
3	{	3	{
4	use32	4	use32
5	org 0x0	5	org 0x0
6		6
7	db 'MENUET01'	7	db 'MENUET01'
8	dd 0x01	8	dd 0x01
9	dd __start	9	dd __start
10	dd __end	10	dd __end
11	dd __memory	11	dd __memory
12	dd __stack	12	dd __stack
13		13
14	if used __params & ~defined __params	14	if used __params & ~defined __params
15	dd __params	15	dd __params
16	else	16	else
17	dd 0x0	17	dd 0x0
18	end if	18	end if
19		19
20	dd 0x0	20	dd 0x0
21	}	21	}
22	MEOS_APP_START fix meos_app_start	22	MEOS_APP_START fix meos_app_start
23		23
24	macro code	24	macro code
25	{	25	{
26	__start:	26	__start:
27	}	27	}
28	CODE fix code	28	CODE fix code
29		29
30	macro data	30	macro data
31	{	31	{
32	__data:	32	__data:
33	}	33	}
34	DATA fix data	34	DATA fix data
35		35
36	macro udata	36	macro udata
37	{	37	{
38	if used __params & ~defined __params	38	if used __params & ~defined __params
39	__params:	39	__params:
40	db 0	40	db 0
41	__end:	41	__end:
42	rb 255	42	rb 255
43	else	43	else
44	__end:	44	__end:
45	end if	45	end if
46	__udata:	46	__udata:
47	}	47	}
48	UDATA fix udata	48	UDATA fix udata
49		49
50	macro meos_app_end	50	macro meos_app_end
51	{	51	{
52	align 32	52	align 32
53	rb 2048	53	rb 2048
54	__stack:	54	__stack:
55	__memory:	55	__memory:
56	}	56	}
57	MEOS_APP_END fix meos_app_end	57	MEOS_APP_END fix meos_app_end
58		58
59		59
60	; macro for defining multiline text data	60	; macro for defining multiline text data
61	struc mstr [sstring]	61	struc mstr [sstring]
62	{	62	{
63	forward	63	forward
64	local ssize	64	local ssize
65	virtual at 0	65	virtual at 0
66	db sstring	66	db sstring
67	ssize = $	67	ssize = $
68	end virtual	68	end virtual
69	dd ssize	69	dd ssize
70	db sstring	70	db sstring
71	common	71	common
72	dd -1	72	dd -1
73	}	73	}
74		74
75		75
76	; strings	76	; strings
77	macro sz name,[data] { ; from MFAR [mike.dld]	77	macro sz name,[data] { ; from MFAR [mike.dld]
78	common	78	common
79	if used name	79	if used name
80	label name	80	label name
81	end if	81	end if
82	forward	82	forward
83	if used name	83	if used name
84	db data	84	db data
85	end if	85	end if
86	common	86	common
87	if used name	87	if used name
88	.size = $-name	88	.size = $-name
89	end if	89	end if
90	}	90	}
91		91
92	macro lsz name,[lng,data] { ; from MFAR [mike.dld]	92	macro lsz name,[lng,data] { ; from MFAR [mike.dld]
93	common	93	common
94	if used name	94	if used name
95	label name	95	label name
96	end if	96	end if
97	forward	97	forward
98	if (used name)&(lang eq lng)	98	if (used name)&(lang eq lng)
99	db data	99	db data
100	end if	100	end if
101	common	101	common
102	if used name	102	if used name
103	.size = $-name	103	.size = $-name
104	end if	104	end if
105	}	105	}
106		106
107		107
108		108
109	; easy system call macro	109	; easy system call macro
110	macro mpack dest, hsrc, lsrc	110	macro mpack dest, hsrc, lsrc
111	{	111	{
112	if (hsrc eqtype 0) & (lsrc eqtype 0)	112	if (hsrc eqtype 0) & (lsrc eqtype 0)
113	mov dest, (hsrc) shl 16 + lsrc	113	mov dest, (hsrc) shl 16 + lsrc
114	else	114	else
115	if (hsrc eqtype 0) & (~lsrc eqtype 0)	115	if (hsrc eqtype 0) & (~lsrc eqtype 0)
116	mov dest, (hsrc) shl 16	116	mov dest, (hsrc) shl 16
117	add dest, lsrc	117	add dest, lsrc
118	else	118	else
119	mov dest, hsrc	119	mov dest, hsrc
120	shl dest, 16	120	shl dest, 16
121	add dest, lsrc	121	add dest, lsrc
122	end if	122	end if
123	end if	123	end if
124	}	124	}
125		125
126	macro __mov reg,a { ; mike.dld	126	macro __mov reg,a { ; mike.dld
127	if ~a eq	127	if ~a eq
128	mov reg,a	128	mov reg,a
129	end if	129	end if
130	}	130	}
131		131
132	__CPU_type equ p5	132	__CPU_type equ p6
133	SYSENTER_VAR equ 0	133	SYSENTER_VAR equ 0
134		134
135	macro mcall a,b,c,d,e,f { ; mike.dld, updated by Ghost for Fast System Calls	135	macro mcall a,b,c,d,e,f { ; mike.dld, updated by Ghost for Fast System Calls
136	local ..ret_point	136	local ..ret_point
137	__mov eax,a	137	__mov eax,a
138	__mov ebx,b	138	__mov ebx,b
139	__mov ecx,c	139	__mov ecx,c
140	__mov edx,d	140	__mov edx,d
141	__mov esi,e	141	__mov esi,e
142	__mov edi,f	142	__mov edi,f
143		143
144	if __CPU_type eq p5	144	if __CPU_type eq p5
145	int 0x40	145	int 0x40
146	else	146	else
147	if __CPU_type eq p6	147	if __CPU_type eq p6
148	push ebp	148	push ebp
149	mov ebp, esp	149	mov ebp, esp
150	push ..ret_point ; it may be 2 or 5 byte	150	push ..ret_point ; it may be 2 or 5 byte
151	sysenter	151	sysenter
152	..ret_point:	152	..ret_point:
153	pop edx	153	pop edx
154	pop ecx	154	pop ecx
155		155
156	else	156	else
157	if __CPU_type eq k6	157	if __CPU_type eq k6
158	push ecx	158	push ecx
159	syscall	159	syscall
160	pop ecx	160	pop ecx
161	else	161	else
162	display 'ERROR : unknown CPU type'	162	display 'ERROR : unknown CPU type'
163	int 0x40	163	int 0x40
164	end if	164	end if
165	end if	165	end if
166	end if	166	end if
167	}	167	}
168		168
169		169
170	; language for programs	170	; language for programs
171	lang fix ru ; ru en fr ge fi	171	lang fix ru ; ru en fr ge fi
172		172
173		173
174		174
175	; optimize the code for size	175	; optimize the code for size
176	__regs fix	176	__regs fix
177		177
178	macro add arg1,arg2	178	macro add arg1,arg2
179	{	179	{
180	if (arg2 eqtype 0)	180	if (arg2 eqtype 0)
181	if (arg2) = 1	181	if (arg2) = 1
182	inc arg1	182	inc arg1
183	else	183	else
184	add arg1,arg2	184	add arg1,arg2
185	end if	185	end if
186	else	186	else
187	add arg1,arg2	187	add arg1,arg2
188	end if	188	end if
189	}	189	}
190		190
191	macro sub arg1,arg2	191	macro sub arg1,arg2
192	{	192	{
193	if (arg2 eqtype 0)	193	if (arg2 eqtype 0)
194	if (arg2) = 1	194	if (arg2) = 1
195	dec arg1	195	dec arg1
196	else	196	else
197	sub arg1,arg2	197	sub arg1,arg2
198	end if	198	end if
199	else	199	else
200	sub arg1,arg2	200	sub arg1,arg2
201	end if	201	end if
202	}	202	}
203		203
204	macro mov arg1,arg2	204	macro mov arg1,arg2
205	{	205	{
206	if (arg1 in __regs) & (arg2 eqtype 0)	206	if (arg1 in __regs) & (arg2 eqtype 0)
207	if (arg2) = 0	207	if (arg2) = 0
208	xor arg1,arg1	208	xor arg1,arg1
209	else if (arg2) = 1	209	else if (arg2) = 1
210	xor arg1,arg1	210	xor arg1,arg1
211	inc arg1	211	inc arg1
212	else if (arg2) = -1	212	else if (arg2) = -1
213	or arg1,-1	213	or arg1,-1
214	else if (arg2) > -128 & (arg2) < 128	214	else if (arg2) > -128 & (arg2) < 128
215	push arg2	215	push arg2
216	pop arg1	216	pop arg1
217	else	217	else
218	mov arg1,arg2	218	mov arg1,arg2
219	end if	219	end if
220	else	220	else
221	mov arg1,arg2	221	mov arg1,arg2
222	end if	222	end if
223	}	223	}
224		224
225		225
226	macro struct name	226	macro struct name
227	{	227	{
228	virtual at 0	228	virtual at 0
229	name name	229	name name
230	sizeof.#name = $ - name	230	sizeof.#name = $ - name
231	end virtual	231	end virtual
232	}	232	}
233		233
234	; structures used in MeOS	234	; structures used in MeOS
235	struc process_information	235	struc process_information
236	{	236	{
237	.cpu_usage dd ? ; +0	237	.cpu_usage dd ? ; +0
238	.window_stack_position dw ? ; +4	238	.window_stack_position dw ? ; +4
239	.window_stack_value dw ? ; +6	239	.window_stack_value dw ? ; +6
240	.not_used1 dw ? ; +8	240	.not_used1 dw ? ; +8
241	.process_name rb 12 ; +10	241	.process_name rb 12 ; +10
242	.memory_start dd ? ; +22	242	.memory_start dd ? ; +22
243	.used_memory dd ? ; +26	243	.used_memory dd ? ; +26
244	.PID dd ? ; +30	244	.PID dd ? ; +30
245	.x_start dd ? ; +34	245	.x_start dd ? ; +34
246	.y_start dd ? ; +38	246	.y_start dd ? ; +38
247	.x_size dd ? ; +42	247	.x_size dd ? ; +42
248	.y_size dd ? ; +46	248	.y_size dd ? ; +46
249	.slot_state dw ? ; +50	249	.slot_state dw ? ; +50
250	rb (1024-52)	250	rb (1024-52)
251	}	251	}
252	struct process_information	252	struct process_information
253		253
254	struc system_colors	254	struc system_colors
255	{	255	{
256	.frame dd ?	256	.frame dd ?
257	.grab dd ?	257	.grab dd ?
258	.grab_button dd ?	258	.grab_button dd ?
259	.grab_button_text dd ?	259	.grab_button_text dd ?
260	.grab_text dd ?	260	.grab_text dd ?
261	.work dd ?	261	.work dd ?
262	.work_button dd ?	262	.work_button dd ?
263	.work_button_text dd ?	263	.work_button_text dd ?
264	.work_text dd ?	264	.work_text dd ?
265	.work_graph dd ?	265	.work_graph dd ?
266	}	266	}
267	struct system_colors	267	struct system_colors
268		268
269		269
270	; constants	270	; constants
271		271
272	; events	272	; events
273	EV_IDLE = 0	273	EV_IDLE = 0
274	EV_TIMER = 0	274	EV_TIMER = 0
275	EV_REDRAW = 1	275	EV_REDRAW = 1
276	EV_KEY = 2	276	EV_KEY = 2
277	EV_BUTTON = 3	277	EV_BUTTON = 3
278	EV_EXIT = 4	278	EV_EXIT = 4
279	EV_BACKGROUND = 5	279	EV_BACKGROUND = 5
280	EV_MOUSE = 6	280	EV_MOUSE = 6
281	EV_IPC = 7	281	EV_IPC = 7
282	EV_STACK = 8	282	EV_STACK = 8
283		283
284	; event mask bits for function 40	284	; event mask bits for function 40
285	EVM_REDRAW = 1b	285	EVM_REDRAW = 1b
286	EVM_KEY = 10b	286	EVM_KEY = 10b
287	EVM_BUTTON = 100b	287	EVM_BUTTON = 100b
288	EVM_EXIT = 1000b	288	EVM_EXIT = 1000b
289	EVM_BACKGROUND = 10000b	289	EVM_BACKGROUND = 10000b
290	EVM_MOUSE = 100000b	290	EVM_MOUSE = 100000b
291	EVM_IPC = 1000000b	291	EVM_IPC = 1000000b
292	EVM_STACK = 10000000b	292	EVM_STACK = 10000000b

Subversion Repositories Kolibri OS

(root)/programs/develop/fast_call_test/MACROS.INC – Rev 477 → 805