root/src/VM/cil/cilVMEvalStack.cpp

Revision 138, 14.1 kB (checked in by hak, 1 year ago)

- Added CCilVm::reset()
- Fixed VM status management (ticket #5)
- Fixed API names not to have upper case as 1st letter.
- Fixed sample build break
- Added new sample, "vm_contol" to demonstrate VM status control API

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     : CCilVmEvalStack.cpp
15  * Date     :
16  * Version  :
17  *
18  ****************************************************************************/
19
20 /***************************************************************************
21  *      Include file
22  ***************************************************************************/
23 #include "stdafx.h"
24 #include "criscript.h"
25 #include "cilVm.h"
26 namespace cri {
27 /***************************************************************************
28  *      Variables
29  ***************************************************************************/
30
31 /***************************************************************************
32  *      Methods
33  ***************************************************************************/
34
35 //TODO
36 //Those eval stack manipurations need to be refactored as a
37 //Write allocate, pointer based implementation
38
39 /***************************************************************************
40  *      pushEvalStack
41  ***************************************************************************/
42 void CCilVm::pushEvalStack( const CVariable& operand )
43 {
44         assert( m_pCurrentEvalStack < &m_OperandEvalStack[ MAX_EVALSTACK - 1 ] );
45         CVariable& var = *m_pCurrentEvalStack;
46
47 #ifdef VM_TRACK_ERASEWHENPOP
48         var.copyFast( operand );
49 //      var.iOperandFlag = OPERAND_FLAG_NONE;
50 #else
51         var = operand;
52         var.iOperandFlag = OPERAND_FLAG_NONE;
53 #endif
54         updateEvalStackIndex();
55 }
56
57 /***************************************************************************
58  *      pushEvalStackString
59  ***************************************************************************/
60 void CCilVm::pushEvalStackString( const wchar_t* pStr )
61 {
62         assert( m_pCurrentEvalStack < &m_OperandEvalStack[ MAX_EVALSTACK - 1 ] );
63         CVariable& var = *m_pCurrentEvalStack;
64 #ifdef VM_TRACK_ERASEWHENPOP
65         var.iPrameters = OPERAND_STRING;
66         var.pString = new wstring( pStr );
67 #else
68         var = CVariable( pStr );
69 #endif
70         updateEvalStackIndex();
71 }
72
73 /***************************************************************************
74  *      pushEvalStackString( wstring * version )
75  ***************************************************************************/
76 void CCilVm::pushEvalStackString( const wstring* str )
77 {
78         assert( m_pCurrentEvalStack < &m_OperandEvalStack[ MAX_EVALSTACK - 1 ] );
79         CVariable& var = *m_pCurrentEvalStack;
80 #ifdef VM_TRACK_ERASEWHENPOP
81         var.iPrameters = OPERAND_STRING;
82         var.pString = new wstring( *str );
83 #else
84         CVariable operand;
85         var = operand;
86         var.iOperandType = OPERAND_STRING;
87         var.pString = new wstring( *str );
88 #endif
89         updateEvalStackIndex();
90 }
91
92 /***************************************************************************
93  *      pushEvalStackStringPointer
94  ***************************************************************************/
95 void CCilVm::pushEvalStackStringPointer( wstring* pstr )
96 {
97         assert( m_pCurrentEvalStack < &m_OperandEvalStack[ MAX_EVALSTACK - 1 ] );
98         CVariable& var = *m_pCurrentEvalStack;
99 #ifdef VM_TRACK_ERASEWHENPOP
100         var.iPrameters = OPERAND_STRING;
101         var.pString = pstr;
102 #else
103         CVariable operand;
104         var = operand;
105         var.iOperandType = OPERAND_STRING;
106         var.pString = pstr;
107 #endif
108         updateEvalStackIndex();
109 }
110
111 /***************************************************************************
112  *      pushEvalStack( int32_t version )
113  ***************************************************************************/
114 void CCilVm::pushEvalStack( const int32_t i )
115 {
116         CVariable& var = *m_pCurrentEvalStack;
117 #ifdef VM_TRACK_ERASEWHENPOP
118         var.iPrameters = OPERAND_INT;
119         var.iValue = i;
120 #else
121         var = CVariable( i );
122 #endif
123         updateEvalStackIndex();
124 }
125
126 /***************************************************************************
127  *      pushEvalStack( int64_t version )
128  ***************************************************************************/
129 void CCilVm::pushEvalStack( const int64_t i )
130 {
131         CVariable& var = *m_pCurrentEvalStack;
132 #ifdef VM_TRACK_ERASEWHENPOP
133         var.iPrameters = OPERAND_INT64;
134         var.i64Value = i;
135 #else
136         var = CVariable( i );
137 #endif
138         updateEvalStackIndex();
139 }
140
141 /***************************************************************************
142  *      pushEvalStack ( boolean )
143  ***************************************************************************/
144 void CCilVm::pushEvalStack( const bool b )
145 {
146         assert( m_pCurrentEvalStack < &m_OperandEvalStack[ MAX_EVALSTACK - 1 ] );
147         CVariable& var = *m_pCurrentEvalStack;
148 #ifdef VM_TRACK_ERASEWHENPOP
149         var.iPrameters = OPERAND_BOOLEAN;
150         var.bValue = b;
151 #else
152         var = CVariable( b );
153 #endif
154         updateEvalStackIndex();
155 }
156
157 /***************************************************************************
158  *      pushEvalStack( float )
159  ***************************************************************************/
160 void CCilVm::pushEvalStack( const float f )
161 {
162         CVariable& var = *m_pCurrentEvalStack;
163 #ifdef VM_TRACK_ERASEWHENPOP
164         var.iPrameters = OPERAND_FLOAT;
165         var.fValue = f;
166 #else
167         var = CVariable( f );
168 #endif
169         updateEvalStackIndex();
170 }
171
172 /***************************************************************************
173  *      pushEvalStack( double )
174  ***************************************************************************/
175 void CCilVm::pushEvalStack( const double d )
176 {
177         assert( m_pCurrentEvalStack < &m_OperandEvalStack[ MAX_EVALSTACK - 1 ] );
178         CVariable& var = *m_pCurrentEvalStack;
179 #ifdef VM_TRACK_ERASEWHENPOP
180         var.iPrameters = OPERAND_DOUBLE;
181         var.dValue = d;
182 #else
183         var = CVariable( d );
184 #endif
185         updateEvalStackIndex();
186 }
187
188 /***************************************************************************
189  *      pushEvalStackNull
190  ***************************************************************************/
191 void CCilVm::pushEvalStackNull()
192 {
193         assert( m_pCurrentEvalStack < &m_OperandEvalStack[ MAX_EVALSTACK - 1 ] );
194         CVariable& var = *m_pCurrentEvalStack;
195 #ifdef VM_TRACK_ERASEWHENPOP
196         var.iPrameters = OPERAND_NULL;
197 #else
198         CVariable operand;
199         operand.iOperandType = OPERAND_NULL;
200         operand.dValue = NULL;
201         var = operand;
202 #endif
203         updateEvalStackIndex();
204 }
205
206 /***************************************************************************
207  *      pushEvalStackUndefined
208  ***************************************************************************/
209 void CCilVm::pushEvalStackUndefined()
210 {
211         assert( m_pCurrentEvalStack < &m_OperandEvalStack[ MAX_EVALSTACK - 1 ] );
212         CVariable& var = *m_pCurrentEvalStack;
213 #ifdef VM_TRACK_ERASEWHENPOP
214         var.iPrameters = OPERAND_UNDEFINED;
215 #else
216         CVariable operand;
217         operand.iOperandType = OPERAND_UNDEFINED;
218         operand.dValue = NULL;
219         var = operand;
220 #endif
221         updateEvalStackIndex();
222 }
223
224 /***************************************************************************
225  *     
226  ***************************************************************************/
227 void CCilVm::pushEvalStackNaN()
228 {
229         assert( m_pCurrentEvalStack < &m_OperandEvalStack[ MAX_EVALSTACK - 1 ] );
230         CVariable& var = *m_pCurrentEvalStack;
231 #ifdef VM_TRACK_ERASEWHENPOP
232         var.iPrameters = OPERAND_NAN;
233 #else
234         CVariable operand;
235         operand.iOperandType = OPERAND_NAN;
236         operand.dValue = NULL;
237         var = operand;
238 #endif
239         updateEvalStackIndex();
240 }
241
242 /***************************************************************************
243  *      pushEvalStackInfinity
244  ***************************************************************************/
245 void CCilVm::pushEvalStackInfinity()
246 {
247         assert( m_pCurrentEvalStack < &m_OperandEvalStack[ MAX_EVALSTACK - 1 ] );
248         CVariable& var = *m_pCurrentEvalStack;
249 #ifdef VM_TRACK_ERASEWHENPOP
250         var.iPrameters = OPERAND_FLOAT;
251         var.iValue = 0x7f800000;
252 #else
253         CVariable operand;
254         operand.iOperandType = OPERAND_FLOAT;
255         operand.iValue = 0x7f800000;
256         var = operand;
257 #endif
258         updateEvalStackIndex();
259 }
260
261 /***************************************************************************
262  *     
263  ***************************************************************************/
264 void CCilVm::pushEvalStackObjectRef( VMOBJECTREF refObject )
265 {
266         assert( m_pCurrentEvalStack < &m_OperandEvalStack[ MAX_EVALSTACK - 1 ] );
267         CVariable& var = *m_pCurrentEvalStack;
268 #ifdef VM_TRACK_ERASEWHENPOP
269         var.iPrameters = OPERAND_OBJECTREF;
270         var.refObject = refObject;
271         if( refObject )
272                 refObject->addRef();
273 #else
274         CVariable operand;
275         operand.iOperandType = OPERAND_OBJECTREF;
276         operand.refObject = refObject;
277         var = operand;
278 #endif
279         updateEvalStackIndex();
280 }
281
282 /***************************************************************************
283  *      pushEvalStackVariable
284  ***************************************************************************/
285 void CCilVm::pushEvalStackVariable( const CVariable& varSrc )
286 {
287         assert( m_pCurrentEvalStack < &m_OperandEvalStack[ MAX_EVALSTACK - 1 ] );
288         CVariable& var = *m_pCurrentEvalStack;
289 #ifdef VM_TRACK_ERASEWHENPOP
290         var.copyFast( varSrc );
291 #else
292         var = varSrc;
293         var.iOperandFlag = OPERAND_FLAG_NONE;
294 #endif
295         updateEvalStackIndex();
296 }
297
298 /***************************************************************************
299  *     
300  ***************************************************************************/
301 void CCilVm::popEvalStack( void )
302 {
303         assert( m_pCurrentEvalStack > &m_OperandEvalStack[ 0 ]  );
304         m_pCurrentEvalStack--;
305         CVariable& var = *m_pCurrentEvalStack;
306 #ifdef VM_TRACK_ERASEWHENPOP
307         var.erase();
308 #endif
309 }
310
311 /***************************************************************************
312  *      popEvalStackFast
313  ***************************************************************************/
314 //Used after moveto()
315 void CCilVm::popEvalStackFast( void )
316 {
317         assert( m_pCurrentEvalStack > &m_OperandEvalStack[ 0 ]  );
318         m_pCurrentEvalStack--;
319 }
320
321 /***************************************************************************
322  *      isEvalStackEmpty
323  ***************************************************************************/
324 bool CCilVm::isEvalStackEmpty() { return (bool)(m_pCurrentEvalStack != &m_OperandEvalStack[ 0 ]); }
325
326 /***************************************************************************
327  *      dupEvalStack
328  ***************************************************************************/
329 void CCilVm::dupEvalStack( void )
330 {
331         assert( m_pCurrentEvalStack > &m_OperandEvalStack[ 0 ]  );
332         CVariable& var = *m_pCurrentEvalStack;
333 #ifdef VM_TRACK_ERASEWHENPOP
334         var.copyFast( *(m_pCurrentEvalStack - 1) );
335 #else
336         var = *(m_pCurrentEvalStack - 1);
337 #endif
338         updateEvalStackIndex();
339 }
340
341 /***************************************************************************
342  *      getEvalStackSize
343  ***************************************************************************/
344 size_t CCilVm::getEvalStackSize()
345 {
346         return (m_pCurrentEvalStack - &m_OperandEvalStack[ 0 ] ) / (&m_OperandEvalStack[ 1 ] - &m_OperandEvalStack[ 0 ] );
347 }
348
349 /***************************************************************************
350  *      getEvalStackNewEntry
351  ***************************************************************************/
352 CVariable& CCilVm::getEvalStackNewEntry()
353 {
354         assert( m_pCurrentEvalStack < &m_OperandEvalStack[ MAX_EVALSTACK - 1 ] );
355         return *m_pCurrentEvalStack++;
356 }
357
358 /***************************************************************************
359  *      getEvalStackFirstEntry
360  ***************************************************************************/
361 CVariable& CCilVm::getEvalStackFirstEntry()
362 {
363         assert( getEvalStackSize() >= 1 );
364         return *(m_pCurrentEvalStack - 1);
365 }
366
367 /***************************************************************************
368  *      getEvalStackSecondEntry
369  ***************************************************************************/
370 CVariable& CCilVm::getEvalStackSecondEntry()
371 {
372         assert( getEvalStackSize() >= 2 );
373         return *(m_pCurrentEvalStack - 2);
374 }
375
376 /***************************************************************************
377  *      clearCallStack
378  ***************************************************************************/
379 void CCilVm::clearCallStack()
380 {
381         m_CallStack.clear();
382 }
383
384 /***************************************************************************
385  *      clearStaticFields
386  ***************************************************************************/
387 void CCilVm::clearStaticFields()
388 {
389         for( uint32_t i = 0; i < m_iStaticFieldTalbeSize; ++i )
390         {
391                 switch( OperandType( m_pStaticFieldTable[ i ].iOperandType ) )
392                 {
393                 case OPERAND_OBJECTREF:
394                         m_pStaticFieldTable[ i ].i64Value = 0;
395                         break;
396                 case OPERAND_STRING:
397                         delete(  m_pStaticFieldTable[ i ].pString ) ;
398                         m_pStaticFieldTable[ i ].pString = NULL;
399                         break;
400                 default:
401                         m_pStaticFieldTable[ i ].i64Value = 0;
402                         break;
403                 }
404         }
405 }
406
407 /***************************************************************************
408  *      clearEvalStack
409  ***************************************************************************/
410 void CCilVm::clearEvalStack()
411 {
412         CVariable var ( 0 );
413         for( int32_t i = 0; i < MAX_EVALSTACK; ++i )
414         {
415                 m_OperandEvalStack[ i ] = var;
416         }
417         m_pCurrentEvalStack = &m_OperandEvalStack[ 0 ];
418         m_pMaxEvalStack = m_pCurrentEvalStack;
419
420 }
421
422 /***************************************************************************
423  *      clearLocalVariableList
424  ***************************************************************************/
425 void CCilVm::clearLocalVariableList()
426 {
427         CVariable var ( 0 );
428         for( int32_t i = 0; i < MAX_LOCAL_VARIABLE; ++i )
429         {
430                 m_LocalVariableList[ i ] = var;
431         }
432         m_iLocalVariableListIndex = 0;
433         m_iMaxLocalVariableListIndex = 0;
434 }
435
436 /***************************************************************************
437  *      clearArgList
438  ***************************************************************************/
439 void CCilVm::clearArgList()
440 {
441         CVariable var ( 0 );
442         for( int32_t i = 0; i < MAX_ARG_VARIABLE; ++i )
443         {
444                 m_ArgList[ i ] = var;
445         }
446         m_iArgListIndex = 0;
447         m_iMaxArgListIndex = 0;
448 }
449
450 } //namespace CRI
Note: See TracBrowser for help on using the browser.