1 #include "sqplus.h"
2
SquirrelObject(void)3 SquirrelObject::SquirrelObject(void)
4 {
5 sq_resetobject(&_o);
6 }
7
~SquirrelObject()8 SquirrelObject::~SquirrelObject()
9 {
10 if(SquirrelVM::_VM)
11 sq_release(SquirrelVM::_VM,&_o);
12 }
13
SquirrelObject(const SquirrelObject & o)14 SquirrelObject::SquirrelObject(const SquirrelObject &o)
15 {
16 _o = o._o;
17 sq_addref(SquirrelVM::_VM,&_o);
18 }
19
SquirrelObject(HSQOBJECT o)20 SquirrelObject::SquirrelObject(HSQOBJECT o)
21 {
22 _o = o;
23 sq_addref(SquirrelVM::_VM,&_o);
24 }
25
Reset(void)26 void SquirrelObject::Reset(void) {
27 if(SquirrelVM::_VM)
28 sq_release(SquirrelVM::_VM,&_o);
29 sq_resetobject(&_o);
30 } // SquirrelObject::Reset
31
Clone()32 SquirrelObject SquirrelObject::Clone()
33 {
34 SquirrelObject ret;
35 if(GetType() == OT_TABLE || GetType() == OT_ARRAY)
36 {
37 sq_pushobject(SquirrelVM::_VM,_o);
38 sq_clone(SquirrelVM::_VM,-1);
39 ret.AttachToStackObject(-1);
40 sq_pop(SquirrelVM::_VM,2);
41 }
42 return ret;
43
44 }
45
operator =(const SquirrelObject & o)46 SquirrelObject & SquirrelObject::operator =(const SquirrelObject &o)
47 {
48 HSQOBJECT t;
49 t = o._o;
50 sq_addref(SquirrelVM::_VM,&t);
51 sq_release(SquirrelVM::_VM,&_o);
52 _o = t;
53 return *this;
54 }
55
operator =(SQInteger n)56 SquirrelObject & SquirrelObject::operator =(SQInteger n)
57 {
58 sq_pushinteger(SquirrelVM::_VM,n);
59 AttachToStackObject(-1);
60 sq_pop(SquirrelVM::_VM,1);
61 return *this;
62 }
63
ArrayAppend(const SquirrelObject & o)64 void SquirrelObject::ArrayAppend(const SquirrelObject &o)
65 {
66 if(sq_isarray(_o)) {
67 sq_pushobject(SquirrelVM::_VM,_o);
68 sq_pushobject(SquirrelVM::_VM,o._o);
69 sq_arrayappend(SquirrelVM::_VM,-2);
70 sq_pop(SquirrelVM::_VM,1);
71 }
72 }
73
AttachToStackObject(SQInteger idx)74 void SquirrelObject::AttachToStackObject(SQInteger idx)
75 {
76 HSQOBJECT t;
77 sq_getstackobj(SquirrelVM::_VM,idx,&t);
78 sq_addref(SquirrelVM::_VM,&t);
79 sq_release(SquirrelVM::_VM,&_o);
80 _o = t;
81 }
82
SetDelegate(SquirrelObject & obj)83 BOOL_T SquirrelObject::SetDelegate(SquirrelObject &obj)
84 {
85 if(obj.GetType() == OT_TABLE ||
86 obj.GetType() == OT_NULL) {
87 switch(_o._type) {
88 case OT_USERDATA:
89 case OT_TABLE:
90 sq_pushobject(SquirrelVM::_VM,_o);
91 sq_pushobject(SquirrelVM::_VM,obj._o);
92 if(SQ_SUCCEEDED(sq_setdelegate(SquirrelVM::_VM,-2)))
93 return TRUE;
94 break;
95 // C::B patch: Handle all switch cases
96 default: break;
97 }
98 }
99 return FALSE;
100 }
101
GetDelegate()102 SquirrelObject SquirrelObject::GetDelegate()
103 {
104 SquirrelObject ret;
105 if(_o._type == OT_TABLE || _o._type == OT_USERDATA)
106 {
107 SQInteger top = sq_gettop(SquirrelVM::_VM);
108 sq_pushobject(SquirrelVM::_VM,_o);
109 sq_getdelegate(SquirrelVM::_VM,-1);
110 ret.AttachToStackObject(-1);
111 sq_settop(SquirrelVM::_VM,top);
112 // sq_pop(SquirrelVM::_VM,2);
113 }
114 return ret;
115 }
116
IsNull() const117 BOOL_T SquirrelObject::IsNull() const
118 {
119 return sq_isnull(_o);
120 }
121
IsNumeric() const122 BOOL_T SquirrelObject::IsNumeric() const
123 {
124 return sq_isnumeric(_o);
125 }
126
Len() const127 SQInteger SquirrelObject::Len() const
128 {
129 SQInteger ret = 0;
130 if(sq_isarray(_o) || sq_istable(_o) || sq_isstring(_o)) {
131 sq_pushobject(SquirrelVM::_VM,_o);
132 ret = sq_getsize(SquirrelVM::_VM,-1);
133 sq_pop(SquirrelVM::_VM,1);
134 }
135 return ret;
136 }
137
138 #define _SETVALUE_INT_BEGIN \
139 BOOL_T ret = FALSE; \
140 SQInteger top = sq_gettop(SquirrelVM::_VM); \
141 sq_pushobject(SquirrelVM::_VM,_o); \
142 sq_pushinteger(SquirrelVM::_VM,key);
143
144 #define _SETVALUE_INT_END \
145 if(SQ_SUCCEEDED(sq_rawset(SquirrelVM::_VM,-3))) { \
146 ret = TRUE; \
147 } \
148 sq_settop(SquirrelVM::_VM,top); \
149 return ret;
150
SetValue(INT_T key,const SquirrelObject & val)151 BOOL_T SquirrelObject::SetValue(INT_T key,const SquirrelObject &val)
152 {
153 _SETVALUE_INT_BEGIN
154 sq_pushobject(SquirrelVM::_VM,val._o);
155 _SETVALUE_INT_END
156 }
157
SetValue(INT_T key,INT_T n)158 BOOL_T SquirrelObject::SetValue(INT_T key,INT_T n)
159 {
160 _SETVALUE_INT_BEGIN
161 sq_pushinteger(SquirrelVM::_VM,n);
162 _SETVALUE_INT_END
163 }
164
SetValue(INT_T key,FLOAT_T f)165 BOOL_T SquirrelObject::SetValue(INT_T key,FLOAT_T f)
166 {
167 _SETVALUE_INT_BEGIN
168 sq_pushfloat(SquirrelVM::_VM,f);
169 _SETVALUE_INT_END
170 }
171
SetValue(INT_T key,const SQChar * s)172 BOOL_T SquirrelObject::SetValue(INT_T key,const SQChar *s)
173 {
174 _SETVALUE_INT_BEGIN
175 sq_pushstring(SquirrelVM::_VM,s,-1);
176 _SETVALUE_INT_END
177 }
178
SetValue(INT_T key,bool b)179 BOOL_T SquirrelObject::SetValue(INT_T key,bool b)
180 {
181 _SETVALUE_INT_BEGIN
182 sq_pushbool(SquirrelVM::_VM,b);
183 _SETVALUE_INT_END
184 }
185
SetValue(const SquirrelObject & key,const SquirrelObject & val)186 BOOL_T SquirrelObject::SetValue(const SquirrelObject &key,const SquirrelObject &val)
187 {
188 BOOL_T ret = FALSE;
189 SQInteger top = sq_gettop(SquirrelVM::_VM);
190 sq_pushobject(SquirrelVM::_VM,_o);
191 sq_pushobject(SquirrelVM::_VM,key._o);
192 sq_pushobject(SquirrelVM::_VM,val._o);
193 if(SQ_SUCCEEDED(sq_rawset(SquirrelVM::_VM,-3))) {
194 ret = TRUE;
195 }
196 sq_settop(SquirrelVM::_VM,top);
197 return ret;
198 }
199
200 #define _SETVALUE_STR_BEGIN \
201 BOOL_T ret = FALSE; \
202 SQInteger top = sq_gettop(SquirrelVM::_VM); \
203 sq_pushobject(SquirrelVM::_VM,_o); \
204 sq_pushstring(SquirrelVM::_VM,key,-1);
205
206 #define _SETVALUE_STR_END \
207 if(SQ_SUCCEEDED(sq_rawset(SquirrelVM::_VM,-3))) { \
208 ret = TRUE; \
209 } \
210 sq_settop(SquirrelVM::_VM,top); \
211 return ret;
212
SetValue(const SQChar * key,const SquirrelObject & val)213 BOOL_T SquirrelObject::SetValue(const SQChar *key,const SquirrelObject &val)
214 {
215 _SETVALUE_STR_BEGIN
216 sq_pushobject(SquirrelVM::_VM,val._o);
217 _SETVALUE_STR_END
218 }
219
SetValue(const SQChar * key,INT_T n)220 BOOL_T SquirrelObject::SetValue(const SQChar *key,INT_T n)
221 {
222 _SETVALUE_STR_BEGIN
223 sq_pushinteger(SquirrelVM::_VM,n);
224 _SETVALUE_STR_END
225 }
226
SetValue(const SQChar * key,FLOAT_T f)227 BOOL_T SquirrelObject::SetValue(const SQChar *key,FLOAT_T f)
228 {
229 _SETVALUE_STR_BEGIN
230 sq_pushfloat(SquirrelVM::_VM,f);
231 _SETVALUE_STR_END
232 }
233
SetValue(const SQChar * key,const SQChar * s)234 BOOL_T SquirrelObject::SetValue(const SQChar *key,const SQChar *s)
235 {
236 _SETVALUE_STR_BEGIN
237 sq_pushstring(SquirrelVM::_VM,s,-1);
238 _SETVALUE_STR_END
239 }
240
SetValue(const SQChar * key,bool b)241 BOOL_T SquirrelObject::SetValue(const SQChar *key,bool b)
242 {
243 _SETVALUE_STR_BEGIN
244 sq_pushbool(SquirrelVM::_VM,b);
245 _SETVALUE_STR_END
246 }
247
248 // === BEGIN User Pointer, User Data ===
249
SetUserPointer(const SQChar * key,SQUserPointer up)250 BOOL_T SquirrelObject::SetUserPointer(const SQChar * key,SQUserPointer up) {
251 _SETVALUE_STR_BEGIN
252 sq_pushuserpointer(SquirrelVM::_VM,up);
253 _SETVALUE_STR_END
254 } // SquirrelObject::SetUserPointer
255
GetUserPointer(const SQChar * key)256 SQUserPointer SquirrelObject::GetUserPointer(const SQChar * key) {
257 SQUserPointer ret = NULL;
258 if (GetSlot(key)) {
259 sq_getuserpointer(SquirrelVM::_VM,-1,&ret);
260 sq_pop(SquirrelVM::_VM,1);
261 } // if
262 sq_pop(SquirrelVM::_VM,1);
263 return ret;
264 } // SquirrelObject::GetUserPointer
265
SetUserPointer(INT_T key,SQUserPointer up)266 BOOL_T SquirrelObject::SetUserPointer(INT_T key,SQUserPointer up) {
267 _SETVALUE_INT_BEGIN
268 sq_pushuserpointer(SquirrelVM::_VM,up);
269 _SETVALUE_INT_END
270 } // SquirrelObject::SetUserPointer
271
GetUserPointer(INT_T key)272 SQUserPointer SquirrelObject::GetUserPointer(INT_T key) {
273 SQUserPointer ret = NULL;
274 if (GetSlot(key)) {
275 sq_getuserpointer(SquirrelVM::_VM,-1,&ret);
276 sq_pop(SquirrelVM::_VM,1);
277 } // if
278 sq_pop(SquirrelVM::_VM,1);
279 return ret;
280 } // SquirrelObject::GetUserPointer
281
282 // === User Data ===
283
NewUserData(const SQChar * key,INT_T size,SQUserPointer * typetag)284 BOOL_T SquirrelObject::NewUserData(const SQChar * key,INT_T size,SQUserPointer * typetag) {
285 _SETVALUE_STR_BEGIN
286 sq_newuserdata(SquirrelVM::_VM,size);
287 if (typetag) {
288 sq_settypetag(SquirrelVM::_VM,-1,typetag);
289 } // if
290 _SETVALUE_STR_END
291 } // SquirrelObject::NewUserData
292
GetUserData(const SQChar * key,SQUserPointer * data,SQUserPointer * typetag)293 BOOL_T SquirrelObject::GetUserData(const SQChar * key,SQUserPointer * data,SQUserPointer * typetag) {
294 BOOL_T ret = false;
295 if (GetSlot(key)) {
296 sq_getuserdata(SquirrelVM::_VM,-1,data,typetag);
297 sq_pop(SquirrelVM::_VM,1);
298 ret = true;
299 } // if
300 sq_pop(SquirrelVM::_VM,1);
301 return ret;
302 } // SquirrelObject::GetUserData
303
RawGetUserData(const SQChar * key,SQUserPointer * data,SQUserPointer * typetag)304 BOOL_T SquirrelObject::RawGetUserData(const SQChar * key,SQUserPointer * data,SQUserPointer * typetag) {
305 BOOL_T ret = false;
306 if (RawGetSlot(key)) {
307 sq_getuserdata(SquirrelVM::_VM,-1,data,typetag);
308 sq_pop(SquirrelVM::_VM,1);
309 ret = true;
310 } // if
311 sq_pop(SquirrelVM::_VM,1);
312 return ret;
313 } // SquirrelObject::RawGetUserData
314
315 // === END User Pointer ===
316
317 // === BEGIN Arrays ===
318
ArrayResize(INT_T newSize)319 BOOL_T SquirrelObject::ArrayResize(INT_T newSize) {
320 // SQInteger top = sq_gettop(SquirrelVM::_VM);
321 sq_pushobject(SquirrelVM::_VM,GetObjectHandle());
322 BOOL_T res = sq_arrayresize(SquirrelVM::_VM,-1,newSize) == SQ_OK;
323 sq_pop(SquirrelVM::_VM,1);
324 // sq_settop(SquirrelVM::_VM,top);
325 return res;
326 } // SquirrelObject::ArrayResize
327
ArrayExtend(INT_T amount)328 BOOL_T SquirrelObject::ArrayExtend(INT_T amount) {
329 SQInteger newLen = Len()+amount;
330 return ArrayResize(newLen);
331 } // SquirrelObject::ArrayExtend
332
ArrayReverse(void)333 BOOL_T SquirrelObject::ArrayReverse(void) {
334 sq_pushobject(SquirrelVM::_VM,GetObjectHandle());
335 BOOL_T res = sq_arrayreverse(SquirrelVM::_VM,-1) == SQ_OK;
336 sq_pop(SquirrelVM::_VM,1);
337 return res;
338 } // SquirrelObject::ArrayReverse
339
ArrayPop(SQBool returnPoppedVal)340 SquirrelObject SquirrelObject::ArrayPop(SQBool returnPoppedVal) {
341 SquirrelObject ret;
342 SQInteger top = sq_gettop(SquirrelVM::_VM);
343 sq_pushobject(SquirrelVM::_VM,GetObjectHandle());
344 if (sq_arraypop(SquirrelVM::_VM,-1,returnPoppedVal) == SQ_OK) {
345 if (returnPoppedVal) {
346 ret.AttachToStackObject(-1);
347 } // if
348 } // if
349 sq_settop(SquirrelVM::_VM,top);
350 return ret;
351 } // SquirrelObject::ArrayPop
352
353 // === END Arrays ===
354
GetType()355 SQObjectType SquirrelObject::GetType()
356 {
357 return _o._type;
358 }
359
GetSlot(INT_T key) const360 BOOL_T SquirrelObject::GetSlot(INT_T key) const
361 {
362 sq_pushobject(SquirrelVM::_VM,_o);
363 sq_pushinteger(SquirrelVM::_VM,key);
364 if(SQ_SUCCEEDED(sq_get(SquirrelVM::_VM,-2))) {
365 return TRUE;
366 }
367
368 return FALSE;
369 }
370
371
GetValue(INT_T key) const372 SquirrelObject SquirrelObject::GetValue(INT_T key)const
373 {
374 SquirrelObject ret;
375 if(GetSlot(key)) {
376 ret.AttachToStackObject(-1);
377 sq_pop(SquirrelVM::_VM,1);
378 }
379 sq_pop(SquirrelVM::_VM,1);
380 return ret;
381 }
382
GetFloat(INT_T key) const383 FLOAT_T SquirrelObject::GetFloat(INT_T key) const
384 {
385 FLOAT_T ret = 0.0f;
386 if(GetSlot(key)) {
387 sq_getfloat(SquirrelVM::_VM,-1,&ret);
388 sq_pop(SquirrelVM::_VM,1);
389 }
390 sq_pop(SquirrelVM::_VM,1);
391 return ret;
392 }
393
GetInt(INT_T key) const394 INT_T SquirrelObject::GetInt(INT_T key) const
395 {
396 INT_T ret = 0;
397 if(GetSlot(key)) {
398 sq_getinteger(SquirrelVM::_VM,-1,&ret);
399 sq_pop(SquirrelVM::_VM,1);
400 }
401 sq_pop(SquirrelVM::_VM,1);
402 return ret;
403 }
404
GetString(INT_T key) const405 const SQChar *SquirrelObject::GetString(INT_T key) const
406 {
407 const SQChar *ret = NULL;
408 if(GetSlot(key)) {
409 sq_getstring(SquirrelVM::_VM,-1,&ret);
410 sq_pop(SquirrelVM::_VM,1);
411 }
412 sq_pop(SquirrelVM::_VM,1);
413 return ret;
414 }
415
GetBool(INT_T key) const416 bool SquirrelObject::GetBool(INT_T key) const
417 {
418 SQBool ret = FALSE;
419 if(GetSlot(key)) {
420 sq_getbool(SquirrelVM::_VM,-1,&ret);
421 sq_pop(SquirrelVM::_VM,1);
422 }
423 sq_pop(SquirrelVM::_VM,1);
424 return ret?true:false;
425 }
426
Exists(const SQChar * key) const427 BOOL_T SquirrelObject::Exists(const SQChar *key) const
428 {
429 BOOL_T ret = FALSE;
430 if(GetSlot(key)) {
431 ret = TRUE;
432 }
433 sq_pop(SquirrelVM::_VM,1);
434 return ret;
435 }
436 ////////////////////////////////////////////////////////////////////////////////
437 ///////////////////////////////////////////////////////////////////////////////
438
GetSlot(const SQChar * name) const439 BOOL_T SquirrelObject::GetSlot(const SQChar *name) const
440 {
441 sq_pushobject(SquirrelVM::_VM,_o);
442 sq_pushstring(SquirrelVM::_VM,name,-1);
443 if(SQ_SUCCEEDED(sq_get(SquirrelVM::_VM,-2))) {
444 return TRUE;
445 }
446
447 return FALSE;
448 }
449
RawGetSlot(const SQChar * name) const450 BOOL_T SquirrelObject::RawGetSlot(const SQChar *name) const {
451 sq_pushobject(SquirrelVM::_VM,_o);
452 sq_pushstring(SquirrelVM::_VM,name,-1);
453 if(SQ_SUCCEEDED(sq_rawget(SquirrelVM::_VM,-2))) {
454 return TRUE;
455 }
456 return FALSE;
457 } // SquirrelObject::RawGetSlot
458
GetValue(const SQChar * key) const459 SquirrelObject SquirrelObject::GetValue(const SQChar *key)const
460 {
461 SquirrelObject ret;
462 if(GetSlot(key)) {
463 ret.AttachToStackObject(-1);
464 sq_pop(SquirrelVM::_VM,1);
465 }
466 sq_pop(SquirrelVM::_VM,1);
467 return ret;
468 }
469
GetFloat(const SQChar * key) const470 FLOAT_T SquirrelObject::GetFloat(const SQChar *key) const
471 {
472 FLOAT_T ret = 0.0f;
473 if(GetSlot(key)) {
474 sq_getfloat(SquirrelVM::_VM,-1,&ret);
475 sq_pop(SquirrelVM::_VM,1);
476 }
477 sq_pop(SquirrelVM::_VM,1);
478 return ret;
479 }
480
GetInt(const SQChar * key) const481 INT_T SquirrelObject::GetInt(const SQChar *key) const
482 {
483 INT_T ret = 0;
484 if(GetSlot(key)) {
485 sq_getinteger(SquirrelVM::_VM,-1,&ret);
486 sq_pop(SquirrelVM::_VM,1);
487 }
488 sq_pop(SquirrelVM::_VM,1);
489 return ret;
490 }
491
GetString(const SQChar * key) const492 const SQChar *SquirrelObject::GetString(const SQChar *key) const
493 {
494 const SQChar *ret = NULL;
495 if(GetSlot(key)) {
496 sq_getstring(SquirrelVM::_VM,-1,&ret);
497 sq_pop(SquirrelVM::_VM,1);
498 }
499 sq_pop(SquirrelVM::_VM,1);
500 return ret;
501 }
502
GetBool(const SQChar * key) const503 bool SquirrelObject::GetBool(const SQChar *key) const
504 {
505 SQBool ret = FALSE;
506 if(GetSlot(key)) {
507 sq_getbool(SquirrelVM::_VM,-1,&ret);
508 sq_pop(SquirrelVM::_VM,1);
509 }
510 sq_pop(SquirrelVM::_VM,1);
511 return ret?true:false;
512 }
513
GetInstanceUP(SQUserPointer tag) const514 SQUserPointer SquirrelObject::GetInstanceUP(SQUserPointer tag) const
515 {
516 SQUserPointer up;
517 sq_pushobject(SquirrelVM::_VM,_o);
518 if (SQ_FAILED(sq_getinstanceup(SquirrelVM::_VM,-1,(SQUserPointer*)&up,tag))) {
519 sq_reseterror(SquirrelVM::_VM);
520 up = NULL;
521 } // if
522 sq_pop(SquirrelVM::_VM,1);
523 return up;
524 }
525
SetInstanceUP(SQUserPointer up)526 BOOL_T SquirrelObject::SetInstanceUP(SQUserPointer up)
527 {
528 if(!sq_isinstance(_o)) return FALSE;
529 sq_pushobject(SquirrelVM::_VM,_o);
530 sq_setinstanceup(SquirrelVM::_VM,-1,up);
531 sq_pop(SquirrelVM::_VM,1);
532 return TRUE;
533 }
534
GetAttributes(const SQChar * key)535 SquirrelObject SquirrelObject::GetAttributes(const SQChar *key)
536 {
537 SquirrelObject ret;
538 SQInteger top = sq_gettop(SquirrelVM::_VM);
539 sq_pushobject(SquirrelVM::_VM,_o);
540 if(key)
541 sq_pushstring(SquirrelVM::_VM,key,-1);
542 else
543 sq_pushnull(SquirrelVM::_VM);
544 if(SQ_SUCCEEDED(sq_getattributes(SquirrelVM::_VM,-2))) {
545 ret.AttachToStackObject(-1);
546 }
547 sq_settop(SquirrelVM::_VM,top);
548 return ret;
549 }
550
BeginIteration()551 BOOL_T SquirrelObject::BeginIteration()
552 {
553 if(!sq_istable(_o) && !sq_isarray(_o) && !sq_isclass(_o))
554 return FALSE;
555 sq_pushobject(SquirrelVM::_VM,_o);
556 sq_pushnull(SquirrelVM::_VM);
557 return TRUE;
558 }
559
Next(SquirrelObject & key,SquirrelObject & val)560 BOOL_T SquirrelObject::Next(SquirrelObject &key,SquirrelObject &val)
561 {
562 if(SQ_SUCCEEDED(sq_next(SquirrelVM::_VM,-2))) {
563 key.AttachToStackObject(-2);
564 val.AttachToStackObject(-1);
565 sq_pop(SquirrelVM::_VM,2);
566 return TRUE;
567 }
568 return FALSE;
569 }
570
GetTypeTag(SQUserPointer * typeTag)571 BOOL_T SquirrelObject::GetTypeTag(SQUserPointer * typeTag) {
572 if (SQ_SUCCEEDED(sq_getobjtypetag(&_o,typeTag))) {
573 return TRUE;
574 } // if
575 return FALSE;
576 } // SquirrelObject::GetTypeTag
577
GetTypeName(const SQChar * key)578 const SQChar * SquirrelObject::GetTypeName(const SQChar * key) {
579 #if 1
580 // This version will work even if SQ_SUPPORT_INSTANCE_TYPE_INFO is not enabled.
581 SqPlus::ScriptStringVar256 varNameTag;
582 SqPlus::getVarNameTag(varNameTag,sizeof(varNameTag),key);
583 SQUserPointer data=0;
584 if (!RawGetUserData(varNameTag,&data)) {
585 return NULL;
586 } // if
587 SqPlus::VarRefPtr vr = (SqPlus::VarRefPtr)data;
588 return vr->typeName;
589 #else // This version will only work if SQ_SUPPORT_INSTANCE_TYPE_INFO is enabled.
590 SquirrelObject so = GetValue(key);
591 if (so.IsNull()) return NULL;
592 return so.GetTypeName();
593 #endif
594 } // SquirrelObject::GetTypeName
595
GetTypeName(INT_T key)596 const SQChar * SquirrelObject::GetTypeName(INT_T key) {
597 SquirrelObject so = GetValue(key);
598 if (so.IsNull()) return NULL;
599 return so.GetTypeName();
600 } // SquirrelObject::GetTypeName
601
GetTypeName(void)602 const SQChar * SquirrelObject::GetTypeName(void) {
603 SQUserPointer typeTag=NULL;
604 if (SQ_SUCCEEDED(sq_getobjtypetag(&_o,&typeTag))) {
605 SquirrelObject typeTable = SquirrelVM::GetRootTable().GetValue(SQ_PLUS_TYPE_TABLE);
606 if (typeTable.IsNull()) {
607 return NULL; // Not compiled with SQ_SUPPORT_INSTANCE_TYPE_INFO enabled.
608 } // if
609 return typeTable.GetString(INT_T((size_t)typeTag));
610 } // if
611 return NULL;
612 } // SquirrelObject::GetTypeName
613
ToString()614 const SQChar* SquirrelObject::ToString()
615 {
616 return sq_objtostring(&_o);
617 }
618
ToInteger()619 SQInteger SquirrelObject::ToInteger()
620 {
621 return sq_objtointeger(&_o);
622 }
623
ToFloat()624 SQFloat SquirrelObject::ToFloat()
625 {
626 return sq_objtofloat(&_o);
627 }
628
ToBool()629 bool SquirrelObject::ToBool()
630 {
631 //<<FIXME>>
632 return _o._unVal.nInteger?true:false;
633 }
634
EndIteration()635 void SquirrelObject::EndIteration()
636 {
637 sq_pop(SquirrelVM::_VM,2);
638 }
639
640