root/src/VM/cil/cilVMOperatorAdd.cpp

Revision 138, 7.6 kB (checked in by hak, 6 months 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 Arithmetical ops
14  * File     : CCilVmOperatorAdd.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  *      Add operator
37  *      (1) take value from stack
38  *      (2) take value from stack
39  *      (3) result(1) + result (2)
40  *      (4) push result (3)
41  ***************************************************************************/
42 void CCilVm::addOperator()
43 {
44         assert( getEvalStackSize() >= 2 );
45         CVariable& rhs = getEvalStackFirstEntry();
46         CVariable& lhs = getEvalStackSecondEntry();
47
48 //      bool bValue;
49
50         if( lhs.iOperandType == OPERAND_OBJECTREF
51                 || rhs.iOperandType == OPERAND_OBJECTREF)
52         {
53                 OPERAND_TYPE lhsType = lhs.getPrimitiveType( PRIMITIVETYPE_NUMBER );
54                 OPERAND_TYPE rhsType = rhs.getPrimitiveType( PRIMITIVETYPE_NUMBER );
55                 if( lhsType == OPERAND_STRING )
56                 {
57                         rhsType = rhs.getPrimitiveType( PRIMITIVETYPE_STRING );
58                 }
59                 else if( rhsType == OPERAND_STRING )
60                 {
61                         lhsType = lhs.getPrimitiveType( PRIMITIVETYPE_STRING );
62                 }
63                
64                 if( lhsType == OPERAND_OBJECTREF || rhsType == OPERAND_OBJECTREF )
65                 {
66                         //if( !lhs.GetConstraintRid() )
67                         //{
68                         //      lhsType = lhs.getPrimitiveType( PRIMITIVETYPE_STRING );
69                         //}
70                         //if( !rhs.GetConstraintRid() )
71                         //{
72                         //      rhsType = rhs.getPrimitiveType( PRIMITIVETYPE_STRING );
73                         //}
74
75                         //lhsType = lhs.getPrimitiveType( PRIMITIVETYPE_STRING );
76                         //rhsType = rhs.getPrimitiveType( PRIMITIVETYPE_STRING );
77
78                         //if( lhsType == OPERAND_OBJECTREF || rhsType == OPERAND_OBJECTREF )
79                         {
80                                 //Throw TypeError
81                                 popThrowTypeError();
82                                 return;
83                         }
84                 }
85                
86                 if( lhsType == OPERAND_STRING || rhsType == OPERAND_STRING )
87                 {
88                         rhs.convertToString( this );
89                         lhs.convertToString( this );
90                         lhs.pString->append( *rhs.pString );
91                         popEvalStack();
92                 }
93                 else if( lhsType == OPERAND_UNDEFINED || rhsType == OPERAND_UNDEFINED )
94                 {
95                         popPushEvalStackUndefined();
96                 }
97                 else if( lhsType == OPERAND_NAN || rhsType == OPERAND_NAN )
98                 {
99                         popPushEvalStackNaN();
100                 }
101                 else if( lhsType == OPERAND_DOUBLE || rhsType == OPERAND_DOUBLE )
102                 {
103                         popPushEvalStack( lhs.toDouble() + rhs.toDouble() );
104                 }
105                 else if( lhsType == OPERAND_FLOAT || rhsType == OPERAND_FLOAT )
106                 {
107                         popPushEvalStack( lhs.toFloat() +  rhs.toFloat() );
108                 }
109                 else if( lhsType == OPERAND_INT64 || rhsType == OPERAND_INT64 )
110                 {
111                         popPushEvalStack( lhs.toInt64() +  rhs.toInt64() );
112                 }
113                 else if( lhsType == OPERAND_INT || rhsType == OPERAND_INT )
114                 {
115                         popPushEvalStack( lhs.toInt() +  rhs.toInt() );
116                 }
117                 else if( lhsType == OPERAND_BOOLEAN || rhsType == OPERAND_BOOLEAN )
118                 {
119                         popPushEvalStack( lhs.toBoolean() + rhs.toBoolean() );
120                 }
121                 else
122                 {
123                         Debug_Fatal( "Not implemented yet" );
124                 }
125                 return;
126         } else if( lhs.iOperandType == OPERAND_STRING
127                 || rhs.iOperandType == OPERAND_STRING )
128         {
129                 lhs.convertToString( this );
130                 rhs.convertToString( this );
131                 lhs.pString->append( *rhs.pString );
132                 popEvalStack();
133                 return;
134         } else if( lhs.iOperandType == OPERAND_NAN
135                 || rhs.iOperandType == OPERAND_NAN )
136         {
137                 popPushEvalStackUndefined();
138                 return;
139         } else if( lhs.iOperandType == OPERAND_UNDEFINED
140                 || rhs.iOperandType == OPERAND_UNDEFINED )
141         {
142                 popPushEvalStackNaN();
143                 return;
144         }
145        
146         switch( lhs.iOperandType )
147         {
148         case OPERAND_INT:
149                 switch( rhs.iOperandType )
150                 {
151                 case OPERAND_INT:
152                         popPushEvalStack( int32_t( lhs.iValue + rhs.iValue ) );
153                         break;
154                 case OPERAND_INT64:
155                         popPushEvalStack( int64_t( int64_t(lhs.iValue) + rhs.i64Value ) );
156                         break;
157                 case OPERAND_FLOAT:
158                         popPushEvalStack( float( lhs.iValue ) + rhs.fValue );
159                         break;
160                 case OPERAND_DOUBLE:
161                         popPushEvalStack( double( lhs.iValue ) + rhs.dValue );
162                         break;
163                 case OPERAND_UNDEFINED:
164                 case OPERAND_NAN:
165                 case OPERAND_STRING:
166                 case OPERAND_OBJECTREF:
167                         Debug_Fatal( "Illegal operand" );
168                         break;
169                 default:
170                         popPushEvalStack( int32_t( lhs.iValue +  rhs.toInt() ) );
171                         break;
172                 }
173                 break;
174         case OPERAND_INT64:
175                 switch( rhs.iOperandType )
176                 {
177                 case OPERAND_INT:
178                         popPushEvalStack( lhs.i64Value + int64_t(rhs.iValue) );
179                         break;
180                 case OPERAND_INT64:
181                         popPushEvalStack( lhs.i64Value + rhs.i64Value );
182                         break;
183                 case OPERAND_FLOAT:
184                         popPushEvalStack( float( lhs.i64Value ) + rhs.fValue );
185                         break;
186                 case OPERAND_DOUBLE:
187                         popPushEvalStack( double( lhs.i64Value ) + rhs.dValue );
188                         break;
189                 case OPERAND_UNDEFINED:
190                 case OPERAND_NAN:
191                 case OPERAND_STRING:
192                 case OPERAND_OBJECTREF:
193                         Debug_Fatal( "Illegal operand" );
194                         break;
195                 default:
196                         popPushEvalStack( lhs.i64Value + rhs.toInt64() );
197                         break;
198                 }
199                 break;
200         case OPERAND_FLOAT:
201                 switch( rhs.iOperandType )
202                 {
203                 case OPERAND_FLOAT:
204                         popPushEvalStack( lhs.fValue + rhs.fValue );
205                         break;
206                 case OPERAND_DOUBLE:
207                         popPushEvalStack( double(lhs.fValue) + rhs.dValue );
208                         break;
209                 case OPERAND_UNDEFINED:
210                 case OPERAND_NAN:
211                 case OPERAND_STRING:
212                 case OPERAND_OBJECTREF:
213                         Debug_Fatal( "Illegal operand" );
214                         break;
215                 default:
216                         popPushEvalStack( lhs.fValue + rhs.toFloat() );
217                         break;
218                 }
219                 break;
220         case OPERAND_DOUBLE:
221                 switch( rhs.iOperandType )
222                 {
223                 case OPERAND_FLOAT:
224                         popPushEvalStack( lhs.dValue + double(rhs.fValue) );
225                         break;
226                 case OPERAND_DOUBLE:
227                         popPushEvalStack( lhs.dValue + rhs.dValue );
228                         break;
229                 case OPERAND_UNDEFINED:
230                 case OPERAND_NAN:
231                 case OPERAND_STRING:
232                 case OPERAND_OBJECTREF:
233                         Debug_Fatal( "Illegal operand" );
234                         break;
235                 default:
236                         popPushEvalStack( lhs.dValue + rhs.toDouble() );
237                         break;
238                 }
239                 break;
240                 break;
241         case OPERAND_UNDEFINED:
242         case OPERAND_NAN:
243         case OPERAND_OBJECTREF:
244         case OPERAND_STRING:
245                 Debug_Fatal( "Illegal operand" );
246                 break;
247         case OPERAND_BOOLEAN:
248                 switch( rhs.iOperandType )
249                 {
250                 case OPERAND_UNDEFINED:
251                 case OPERAND_NAN:
252                 case OPERAND_STRING:
253                 case OPERAND_OBJECTREF:
254                         Debug_Fatal( "Illegal operand" );
255                         break;
256                 default:
257                         //if( lhs.bValue )
258                         //      bValue = true;
259                         //else
260                         //      bValue = rhs.toBoolean();
261                         popPushEvalStack( lhs.toInt() + rhs.toInt() );
262                         break;
263                 }
264                 break;
265         case OPERAND_NULL:
266                 {
267                 CVariable var = rhs;
268                 popEvalStack();
269                 popEvalStack();
270                 pushEvalStack( var );
271                 }
272                 break;
273         default:
274                 Debug_Fatal( "Illegal operand" );
275                 break;
276         }
277
278 }
279
280 /***************************************************************************
281  *      Add operator Helper
282  ***************************************************************************/
283
284 } //namespace CRI
Note: See TracBrowser for help on using the browser.