cilVMBranchMacro.h

Revision 100, 9.9 kB (checked in by hak, 7 months ago)

Ver.0.9.12.56
- Fixed build failure.

Reverted compile option not to have /Zm option

- Performance improvement

In mandelbrot test, now 540msec -> 350msec.
Changed eval stack not to use STL vector

- Fixed int + Number case handling.

Was adding int64 instead of int32

Line
1	/****************************************************************************
2	*
3	* CRI Middleware SDK
4	*
5	* Copyright (c) 2008 CRI Middleware, Inc. All rights reserved.
6	*
7	* Use, modification and distribution are subject to the CRI Script Software
8	* License, Version 1.0(see accompanying file "CriScript_License_1_0.txt" or
9	* copy at www.criscript.com/trac/wiki/CRI%20Script%20Software%20License%201.0 ).
10	*
11	*
12	* Library : CRIScript
13	* Module : cil Virtual Machine
14	* File : cilVMBranchMacro.h
15	* Date :
16	* Version :
17	*
18	****************************************************************************/
19	#pragma once
20
21	/***************************************************************************
22	* Include file
23	***************************************************************************/
24	namespace cri {
25	/***************************************************************************
26	* Variables
27	***************************************************************************/
28
29	/***************************************************************************
30	* Methods
31	***************************************************************************/
32
33	#define CheckBranch(OP,OP2)\
34	{\
35	wstring* pstrLhs;\
36	wstring* pstrRhs;\
37	lhs.iOperandType = (OPERAND_TYPE)OperandType( lhs.iOperandType );\
38	rhs.iOperandType = (OPERAND_TYPE)OperandType( rhs.iOperandType );\
39	\
40	if( lhs.iOperandType == rhs.iOperandType )\
41	{\
42	switch( lhs.iOperandType )\
43	{\
44	case OPERAND_UNDEFINED:\
45	bTrue = true;\
46	break;\
47	case OPERAND_NULL:\
48	bTrue = 0 OP 0;\
49	break;\
50	case OPERAND_NAN:\
51	bTrue = false;\
52	break;\
53	case OPERAND_BOOLEAN:\
54	bTrue = (lhs.bValue OP rhs.bValue );\
55	break;\
56	case OPERAND_INT:\
57	bTrue = (lhs.iValue OP rhs.iValue );\
58	break;\
59	case OPERAND_INT64:\
60	bTrue = (lhs.i64Value OP rhs.i64Value );\
61	break;\
62	case OPERAND_FLOAT:\
63	bTrue = (lhs.fValue OP rhs.fValue );\
64	break;\
65	case OPERAND_DOUBLE:\
66	bTrue = (lhs.dValue OP rhs.dValue );\
67	break;\
68	case OPERAND_OBJECTREF:\
69	switch( rhs.getPrimitiveType() )\
70	{\
71	case OPERAND_BOOLEAN:\
72	bTrue = (lhs.toInt() OP rhs.toInt() );\
73	break;\
74	case OPERAND_INT:\
75	bTrue = (lhs.toInt() OP rhs.toInt() );\
76	break;\
77	case OPERAND_INT64:\
78	bTrue = (lhs.toInt64() OP rhs.toInt64() );\
79	break;\
80	case OPERAND_FLOAT:\
81	bTrue = (lhs.toFloat() OP rhs.toFloat() );\
82	break;\
83	case OPERAND_DOUBLE:\
84	bTrue = (lhs.toDouble() OP rhs.toDouble() );\
85	break;\
86	case OPERAND_STRING:\
87	default:\
88	pstrLhs = lhs.toString( this );\
89	pstrRhs = rhs.toString( this );\
90	bTrue = pstrLhs OP pstrRhs;\
91	delete( pstrLhs );\
92	delete( pstrRhs );\
93	break;\
94	}\
95	break;\
96	case OPERAND_STRING:\
97	bTrue = lhs.pString OP rhs.pString;\
98	break;\
99	default:\
100	bTrue = false;\
101	break;\
102	}\
103	}\
104	else\
105	{\
106	/*Each case should have 7 entries
107	// OPERAND_BOOLEAN
108	// OPERAND_INT
109	// OPERAND_INT64
110	// OPERAND_FLOAT
111	// OPERAND_DOUBLE
112	// OPERAND_OBJECTREF
113	// OPERAND_STRING*/\
114	if( rhs.iOperandType == OPERAND_OBJECTREF )\
115	{\
116	switch( rhs.getPrimitiveType() )\
117	{\
118	case OPERAND_BOOLEAN:\
119	bTrue = (lhs.toInt() OP rhs.toInt() );\
120	break;\
121	case OPERAND_INT:\
122	bTrue = (lhs.toInt() OP rhs.toInt() );\
123	break;\
124	case OPERAND_INT64:\
125	bTrue = (lhs.toInt64() OP rhs.toInt64() );\
126	break;\
127	case OPERAND_FLOAT:\
128	bTrue = (lhs.toFloat() OP rhs.toFloat() );\
129	break;\
130	case OPERAND_DOUBLE:\
131	bTrue = (lhs.toDouble() OP rhs.toDouble() );\
132	break;\
133	case OPERAND_STRING:\
134	default:\
135	pstrLhs = lhs.toString( this );\
136	pstrRhs = rhs.toString( this );\
137	bTrue = pstrLhs OP pstrRhs;\
138	delete( pstrLhs );\
139	delete( pstrRhs );\
140	break;\
141	}\
142	}\
143	else if( lhs.iOperandType == OPERAND_NAN\
144	\|\| rhs.iOperandType == OPERAND_NAN )\
145	{\
146	bTrue = false;\
147	}\
148	else\
149	{\
150	switch( lhs.iOperandType )\
151	{\
152	case OPERAND_NULL:\
153	switch( rhs.iOperandType )\
154	{\
155	case OPERAND_UNDEFINED:\
156	bTrue = true;\
157	break;\
158	default:\
159	bTrue = (0 OP rhs.toInt());\
160	break;\
161	}\
162	break;\
163	case OPERAND_UNDEFINED:\
164	if( rhs.iOperandType == OPERAND_NULL ) bTrue = true;\
165	break;\
166	case OPERAND_STRING:\
167	switch( rhs.iOperandType )\
168	{\
169	case OPERAND_BOOLEAN:\
170	bTrue = ( lhs.toInt() OP rhs.iValue );\
171	break;\
172	case OPERAND_INT:\
173	bTrue = (lhs.toInt() OP rhs.iValue );\
174	break;\
175	case OPERAND_INT64:\
176	bTrue = ((int64_t)lhs.toInt64() OP rhs.i64Value );\
177	break;\
178	case OPERAND_FLOAT:\
179	bTrue = (lhs.toFloat() OP rhs.fValue );\
180	break;\
181	case OPERAND_DOUBLE:\
182	bTrue = (lhs.toDouble() OP rhs.dValue );\
183	break;\
184	case OPERAND_NULL:\
185	bTrue = (lhs.toInt() OP 0 );\
186	break;\
187	default:\
188	bTrue = false;\
189	break;\
190	}\
191	break;\
192	case OPERAND_BOOLEAN:\
193	switch( rhs.iOperandType )\
194	{\
195	case OPERAND_INT:\
196	bTrue = (int32_t(lhs.bValue) OP rhs.iValue );\
197	break;\
198	case OPERAND_INT64:\
199	bTrue = (int64_t(lhs.bValue) OP rhs.i64Value );\
200	break;\
201	case OPERAND_STRING:\
202	bTrue = (int32_t(lhs.bValue) OP rhs.toInt());\
203	break;\
204	case OPERAND_FLOAT:\
205	bTrue = (float(lhs.bValue) OP rhs.fValue);\
206	break;\
207	case OPERAND_DOUBLE:\
208	bTrue = (double(lhs.bValue) OP rhs.dValue);\
209	break;\
210	case OPERAND_NULL:\
211	bTrue = (lhs.toInt() OP 0 );\
212	break;\
213	case OPERAND_BOOLEAN:\
214	Debug_Fatal( "Illegal operand" );\
215	default:\
216	bTrue = false;\
217	break;\
218	}\
219	break;\
220	case OPERAND_INT:\
221	switch( rhs.iOperandType )\
222	{\
223	case OPERAND_BOOLEAN:\
224	bTrue = (lhs.iValue OP rhs.iValue );\
225	break;\
226	case OPERAND_INT64:\
227	bTrue = (int64_t(lhs.iValue) OP rhs.i64Value );\
228	break;\
229	case OPERAND_STRING:\
230	bTrue = (lhs.iValue OP rhs.toInt());\
231	break;\
232	case OPERAND_FLOAT:\
233	bTrue = (float(lhs.iValue) OP rhs.fValue);\
234	break;\
235	case OPERAND_DOUBLE:\
236	bTrue = (double(lhs.iValue) OP rhs.dValue);\
237	break;\
238	case OPERAND_NULL:\
239	bTrue = (lhs.iValue OP 0 );\
240	break;\
241	case OPERAND_INT:\
242	Debug_Fatal( "Illegal operand" );\
243	default:\
244	bTrue = false;\
245	break;\
246	}\
247	break;\
248	case OPERAND_INT64:\
249	switch( rhs.iOperandType )\
250	{\
251	case OPERAND_BOOLEAN:\
252	bTrue = (lhs.i64Value OP rhs.iValue );\
253	break;\
254	case OPERAND_INT:\
255	bTrue = (int32_t(lhs.i64Value) OP rhs.iValue );\
256	break;\
257	case OPERAND_STRING:\
258	bTrue = (lhs.i64Value OP rhs.toInt());\
259	break;\
260	case OPERAND_FLOAT:\
261	bTrue = (float(lhs.i64Value) OP rhs.fValue);\
262	break;\
263	case OPERAND_DOUBLE:\
264	bTrue = (double(lhs.i64Value) OP rhs.dValue);\
265	break;\
266	case OPERAND_NULL:\
267	bTrue = (lhs.i64Value OP 0 );\
268	break;\
269	case OPERAND_INT64:\
270	Debug_Fatal( "Illegal operand" );\
271	default:\
272	bTrue = false;\
273	break;\
274	}\
275	break;\
276	case OPERAND_FLOAT:\
277	switch( rhs.iOperandType )\
278	{\
279	case OPERAND_BOOLEAN:\
280	bTrue = (lhs.fValue OP rhs.iValue );\
281	break;\
282	case OPERAND_INT:\
283	bTrue = (int32_t(lhs.fValue) OP rhs.iValue );\
284	break;\
285	case OPERAND_INT64:\
286	bTrue = (int64_t(lhs.fValue) OP rhs.i64Value );\
287	break;\
288	case OPERAND_STRING:\
289	bTrue = (lhs.fValue OP rhs.toFloat());\
290	break;\
291	case OPERAND_DOUBLE:\
292	bTrue = (double(lhs.fValue) OP rhs.dValue);\
293	break;\
294	case OPERAND_NULL:\
295	bTrue = (lhs.fValue OP 0 );\
296	break;\
297	case OPERAND_FLOAT:\
298	Debug_Fatal( "Illegal operand" );\
299	default:\
300	bTrue = false;\
301	break;\
302	}\
303	break;\
304	case OPERAND_DOUBLE:\
305	switch( rhs.iOperandType )\
306	{\
307	case OPERAND_BOOLEAN:\
308	bTrue = (lhs.toInt() OP rhs.iValue );\
309	break;\
310	case OPERAND_INT:\
311	bTrue = (int32_t(lhs.dValue) OP rhs.iValue );\
312	break;\
313	case OPERAND_INT64:\
314	bTrue = (int64_t(lhs.dValue) OP rhs.i64Value );\
315	break;\
316	case OPERAND_STRING:\
317	bTrue = (lhs.dValue OP rhs.toDouble());\
318	break;\
319	case OPERAND_FLOAT:\
320	bTrue = (float(lhs.dValue) OP rhs.fValue);\
321	break;\
322	case OPERAND_NULL:\
323	bTrue = (lhs.dValue OP 0 );\
324	break;\
325	case OPERAND_DOUBLE:\
326	Debug_Fatal( "Illegal operand" );\
327	default:\
328	bTrue = false;\
329	break;\
330	}\
331	break;\
332	case OPERAND_OBJECTREF:\
333	switch( lhs.getPrimitiveType() )\
334	{\
335	case OPERAND_INT:\
336	switch( rhs.iOperandType )\
337	{\
338	case OPERAND_BOOLEAN:\
339	bTrue = (lhs.toInt() OP rhs.iValue );\
340	break;\
341	case OPERAND_INT:\
342	bTrue = (lhs.toInt() OP rhs.iValue );\
343	break;\
344	case OPERAND_INT64:\
345	bTrue = (int64_t(lhs.toInt()) OP rhs.i64Value );\
346	break;\
347	case OPERAND_STRING:\
348	pstrLhs = lhs.toString( this );\
349	pstrRhs = rhs.toString( this );\
350	bTrue = pstrLhs OP pstrRhs;\
351	delete( pstrLhs );\
352	delete( pstrRhs );\
353	break;\
354	case OPERAND_FLOAT:\
355	bTrue = (lhs.toFloat() OP rhs.fValue);\
356	break;\
357	case OPERAND_DOUBLE:\
358	bTrue = (lhs.toDouble() OP rhs.dValue);\
359	break;\
360	case OPERAND_OBJECTREF:\
361	Debug_Fatal( "Illegal operand" );\
362	break;\
363	default:\
364	bTrue = false;\
365	break;\
366	}\
367	break;\
368	case OPERAND_STRING:\
369	pstrLhs = lhs.toString( this );\
370	pstrRhs = rhs.toString( this );\
371	bTrue = pstrLhs OP pstrRhs;\
372	delete( pstrLhs );\
373	delete( pstrRhs );\
374	break;\
375	case OPERAND_BOOLEAN:\
376	bTrue = lhs.toInt() OP rhs.toInt();\
377	break;\
378	default:\
379	bTrue = false;\
380	break;\
381	}\
382	break;\
383	default:\
384	Debug_Fatal( "Illegal operand" );\
385	}\
386	}\
387	}\
388	}\
389
390	//End of macro
391
392
393	} //namespace CRI

Note: See TracBrowser for help on using the browser.