root/src/VM/cil/cilVMArgumentList.cpp

Revision 195, 12.5 kB (checked in by hak, 1 year ago)

Ver.0.91.0.137
- Added OSX/GCC support!
- Can compile in XCode 3.1/GCC 4.0.1 & Visual Studio 2005.
- Runs in OSX 10.5.4 & Windows XP/Vista
- Number::toString support a radix.
- BRFALSE bug fix
- Minor code clean up

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     : cilVMArgumentList.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 /***************************************************************************
36  *      Store from top of the stack to a Argument List
37  ***************************************************************************/
38 void CCilVm::storeArgument( const int32_t iIndex )
39 {
40         VM_CALLSTACK* stack = getCurrentCallStack( VM_CALLSTACK_CALLSTACK );    //Arglist resides in the last callstack
41         assert( stack->iArgumentListStartIndex + iIndex <= int32_t(m_iArgListIndex) );
42
43         if( m_ArgList[ stack->iArgumentListStartIndex + iIndex ].getFlag() & OPERAND_FLAG_READONLY )
44         {
45                 //Read only variable
46                 popEvalStack();
47                 return;
48         }
49
50         if( m_ArgList[ stack->iArgumentListStartIndex + iIndex ].getFlag() & OPERAND_FLAG_STRICT )
51         {
52                 //Test type constraint
53                 storeAsRestrictedType( m_ArgList[ stack->iArgumentListStartIndex + iIndex ]  );
54                 popEvalStack();
55                 return;
56         }
57
58         getEvalStackFirstEntry().moveTo( m_ArgList[ stack->iArgumentListStartIndex + iIndex ] );
59         popEvalStackFast();
60 }
61
62 /***************************************************************************
63  *      Load from a Argument List to Top of the stack
64  ***************************************************************************/
65 void CCilVm::loadArgument( const int32_t iIndex )
66 {
67         VM_CALLSTACK* stack = getCurrentCallStack( VM_CALLSTACK_CALLSTACK );    //Arglist resides in the last callstack
68         assert( stack->iArgumentListStartIndex + iIndex <= int32_t(m_iArgListIndex) );
69         pushEvalStack( m_ArgList[ stack->iArgumentListStartIndex + iIndex ] );
70 }
71
72 /***************************************************************************
73  *      Push undefined to the arglist
74  ***************************************************************************/
75 void CCilVm::pushArgumentListUndefined()
76 {
77         assert( m_iArgListIndex < MAX_ARG_VARIABLE );
78         CVariable operand;
79         operand.iOperandType = OPERAND_UNDEFINED;
80         operand.iOperandFlag = OPERAND_FLAG_NONE;
81         operand.dValue = NULL;
82         m_ArgList[ m_iArgListIndex ] = operand;
83         updateArgListIndex();
84 }
85
86 /***************************************************************************
87  *      Pop undefined to the arglist
88  ***************************************************************************/
89 void CCilVm::popArgumentList()
90 {
91         assert( m_iArgListIndex >= 1 );
92 #ifdef VM_TRACK_ERASEWHENPOP
93         m_ArgList[ m_iArgListIndex ].erase();
94 #endif
95         m_iArgListIndex--;
96         //Note that it does not destroy entry
97 }
98
99 /***************************************************************************
100  *      get Argument Value (Debugger helper)
101  ***************************************************************************/
102 CVariable& CCilVm::getArgument( const int32_t iIndex )
103 {
104         VM_CALLSTACK* stack = getCurrentCallStack( VM_CALLSTACK_CALLSTACK );    //Arglist resides in the last callstack
105         assert( stack->iArgumentListStartIndex + iIndex <= (int32_t)m_iArgListIndex );
106         return m_ArgList[ stack->iArgumentListStartIndex + iIndex ];
107 }
108
109 /***************************************************************************
110  *      Set Argument Value (Debugger helper)
111  ***************************************************************************/
112 bool CCilVm::setArgument( const int32_t iIndex, const CVariable& value )
113 {
114         VM_CALLSTACK* stack = getCurrentCallStack( VM_CALLSTACK_CALLSTACK );    //Arglist resides in the last callstack
115         assert( stack->iArgumentListStartIndex + iIndex <= (int32_t)m_iArgListIndex );
116         m_ArgList[ stack->iArgumentListStartIndex + iIndex ] = value;
117         return true;
118 }
119
120 /***************************************************************************
121  *      VM local variable management
122  *              store args from eval stack
123  ***************************************************************************/
124 void CCilVm::storeArgumentListWithThisPointer( const uint32_t iArgsToStore )
125 {
126         assert( m_iArgListIndex < MAX_ARG_VARIABLE );
127         assert( getEvalStackSize() >= iArgsToStore );
128
129         //Add param list
130         CVariable variable;
131         //Reserve this pointer entry
132         storeArgumentList( variable );
133        
134         for( uint32_t i = 0; i < iArgsToStore; i++ )
135         {
136                 //Note that here, the order of the arg list is swapped
137                 getEvalStackFirstEntry().moveTo( m_ArgList[ m_iArgListIndex ] );
138                 updateArgListIndex();
139                 popEvalStackFast();
140         }
141 }
142
143 void CCilVm::storeArgumentListWithoutThisPointer( const uint32_t iArgsToStore )
144 {
145         assert( m_iArgListIndex < MAX_ARG_VARIABLE );
146         assert( getEvalStackSize() >= iArgsToStore );
147
148         //Add param list
149         //Reserve this pointer entry
150         storeArgumentList( m_ArgList[ m_iCurrentThisPointerIndex ] );
151
152         CVariable var;
153         for( uint32_t i = 0; i < iArgsToStore; i++ )
154         {
155                 //Note that here, the order of the arg list is swapped
156                 getEvalStackFirstEntry().moveTo( m_ArgList[ m_iArgListIndex ] );
157                 updateArgListIndex();
158                 popEvalStackFast();
159         }
160 }
161
162 void CCilVm::storeArgumentList( const CVariable& var )
163 {
164         assert( m_iArgListIndex < MAX_ARG_VARIABLE );
165         m_ArgList[ m_iArgListIndex ] = var;
166         updateArgListIndex();
167 }
168
169 /***************************************************************************
170  *      VM arg list management
171  *              dispose arg list slot for future use
172  ***************************************************************************/
173 void CCilVm::disposeArgumentList( const uint32_t iArgsToDispose )
174 {
175         assert( iArgsToDispose <= m_iArgListIndex );
176
177 #ifdef VM_TRACK_ERASEWHENPOP
178         for( uint32_t i = 0; i < iArgsToDispose; ++i )
179                 m_ArgList[ m_iArgListIndex-- ].erase();
180 #else
181         m_iArgListIndex -= iArgsToDispose;
182 #endif
183
184         //the Argument list should keep at least 1 entry for the this pointer
185         assert( m_iArgListIndex >= 1 );
186 }
187
188 /***************************************************************************
189  *      VM arg list management
190  *              dispose arg list slot for future use
191  ***************************************************************************/
192 void CCilVm::disposeArgumentList()
193 {
194         assert( m_iNumGivenArguments <= (int32_t)m_iArgListIndex );
195
196 #ifdef VM_TRACK_ERASEWHENPOP
197         for( int32_t i = 0; i < m_iNumGivenArguments; ++i )
198                 m_ArgList[ --m_iArgListIndex ].erase();
199 #else
200         m_iArgListIndex -= m_iNumGivenArguments;
201 #endif
202         m_iNumGivenArguments = 0;
203
204         //the Argument list should keep at least 1 entry for the this pointer
205         assert( m_iArgListIndex >= 1 );
206 }
207
208 /***************************************************************************
209  *      VM arg list management
210  *              reset argument list count
211  ***************************************************************************/
212 void CCilVm::resetArgumentList()
213 {
214         m_iNumGivenArguments = 0;
215 }
216
217 /***************************************************************************
218  *      VM arg list management
219  *              generateArgumentsProperty
220  ***************************************************************************/
221 CVariable* CCilVm::generateArgumentsProperty()
222 {
223         wchar_t strBuffer[ 22 ];                //22=max value width of longlong
224         VM_CALLSTACK* pStack = getCurrentCallStack( VM_CALLSTACK_CALLSTACK );
225         int32_t iNumArguments = min( pStack->iNumGivenArgument, pStack->iNumArgument );
226
227         //
228         //Need to return a value even no arguments are given
229         
230         //the object looks like indicading current executing context
231         CVmObject* pObj = createObject( m_ridArrayObject );
232         CVariable obj( pObj, OPERAND_FLAG( OPERAND_FLAG_DONTDELETE
233                                                                         | OPERAND_FLAG_DONTENUM
234                                                                         | OPERAND_FLAG_READONLY ) );
235
236         pObj->addProperty( STRING_INTERNAL_LENGTH, (int32_t)iNumArguments - 1 );
237         for( int32_t i = 0; i < (int32_t)iNumArguments - 1; ++i )
238         {
239                 //Argument: 1) value of the property
240                 swprintf( strBuffer, 22, L"%d", i );
241                 //Does not store 'this' value
242                 pObj->setProperty( strBuffer, m_ArgList[ pStack->iArgumentListStartIndex + i + 1 ] );
243         }
244
245         //Set callee property
246         VMOBJECTREF pCallee = createObject( m_ridFunctionObject );
247         pCallee->setCallProperty( pStack->ridMethod );
248        
249         CVariable varPointer( pCallee );
250         pObj->setProperty( NAME_BUILTIN_FUNCTION_PROPERTY_CALLEE, varPointer );
251
252         //Set caller proeperty
253         //Get 2nd level call stack
254         pStack = getCurrentCallStack( VM_CALLSTACK_CALLSTACK, 2 );
255         if( pStack != NULL )
256         {
257                 iNumArguments = min( pStack->iNumGivenArgument, pStack->iNumArgument );
258
259                 //
260                 //Need to return a value even no arguments are given
261                 
262                 //the object looks like indicading current executing context
263                 CVmObject* pObjCaller = createObject( m_ridArrayObject );
264                 CVariable obj( pObjCaller, OPERAND_FLAG( OPERAND_FLAG_DONTDELETE
265                                                                                 | OPERAND_FLAG_DONTENUM
266                                                                                 | OPERAND_FLAG_READONLY ) );
267
268                 pObjCaller->addProperty( STRING_INTERNAL_LENGTH, (int32_t)iNumArguments - 1 );
269                 for( int32_t i = 0; i < (int32_t)iNumArguments - 1; ++i )
270                 {
271                         //Argument: 1) value of the property
272                         swprintf( strBuffer, 22, L"%d", i );
273                         //Does not store 'this' value
274                         pObjCaller->setProperty( strBuffer, m_ArgList[ pStack->iArgumentListStartIndex + i + 1 ] );
275                 }
276
277                 //Set callee property
278                 VMOBJECTREF pCallee = createObject( m_ridFunctionObject );
279                 pCallee->setCallProperty( pStack->ridMethod );
280                 CVariable varPointer( pCallee );
281                 pObjCaller->setProperty( NAME_BUILTIN_FUNCTION_PROPERTY_CALLEE, varPointer );
282
283                 CVariable varPointerObj( pObjCaller );
284                 pObj->setProperty( NAME_BUILTIN_FUNCTION_PROPERTY_CALLER, varPointerObj );
285         }
286
287
288         setStaticField( RID_ARGUMENTS_TMP, obj, true );
289
290         return &getStaticField( RID_ARGUMENTS_TMP );
291 }
292
293 /***************************************************************************
294  *      VM arg list management
295  *              generateRestArguments
296  ***************************************************************************/
297 void CCilVm::generateRestArguments( int32_t iNumArgsToStore )
298 {
299         wchar_t strBuffer[ 22 ];                //22=max value width of longlong
300         assert( m_iArgListIndex >= uint32_t(iNumArgsToStore) );
301         //
302         //Need to return a value even no arguments are given
303         
304         //the object looks like indicading current executing context
305         CVmObject* pObj = createObject( m_ridArrayObject );
306         CVariable obj( pObj, OPERAND_FLAG( OPERAND_FLAG_DONTDELETE
307                                                                         | OPERAND_FLAG_DONTENUM
308                                                                         | OPERAND_FLAG_READONLY ) );
309
310         pObj->addProperty( STRING_INTERNAL_LENGTH, (int32_t)iNumArgsToStore );
311         if( iNumArgsToStore )
312                 for( int32_t i = iNumArgsToStore - 1; i >= 0; --i )
313                 {
314                         //Argument: 1) value of the property
315                         swprintf( strBuffer, 22, L"%d", i );
316                         //Does not store 'this' value
317                         pObj->setProperty( strBuffer, m_ArgList[ m_iArgListIndex - 1 ] );
318                         popArgumentList();
319                 }
320         else
321                 popArgumentList();      //Just pop_back and push array
322
323         m_ArgList[ m_iArgListIndex ] = obj;
324         m_ArgList[ m_iArgListIndex ].iOperandFlag = OPERAND_FLAG_NONE;
325         updateArgListIndex();
326         return;
327 }
328
329 /***************************************************************************
330  *      VM arg list management
331  *              generateCallerProperty
332  ***************************************************************************/
333 CVariable* CCilVm::generateCallerProperty()
334 {
335         VM_CALLSTACK* pStack = getCurrentCallStack( VM_CALLSTACK_CALLSTACK, 2);
336         //
337         //Need to return a value even no arguments are given
338         
339         //the object looks like indicading current executing context
340
341         //Set caller proeperty
342         if( pStack != NULL )
343         {
344                 VMOBJECTREF pCaller = createObject( m_ridFunctionObject );
345                 CVariable obj( pCaller, OPERAND_FLAG( OPERAND_FLAG_DONTDELETE
346                                                                                 | OPERAND_FLAG_DONTENUM
347                                                                                 | OPERAND_FLAG_READONLY ) );
348                 setStaticField( RID_ARGUMENTS_TMP, obj, true );
349         }
350         else
351                 setStaticField( RID_ARGUMENTS_TMP, CVariable(), true );
352
353
354         return &getStaticField( RID_ARGUMENTS_TMP );
355 }
356
357 } //namespace CRI
Note: See TracBrowser for help on using the browser.