VCVRack
/
Rack
mirror of https://github.com/VCVRack/Rack.git
1
0
Fork 0
Code Issues 0 Releases 43 Wiki Activity
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
1347 Commits
4 Branches
540MB
Tree: 5b7b40e992
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from '5b7b40e992'
${ noResults }
Rack/dep/yac/yac_host.cpp

2296 lines
93KB
Raw Blame History 

  1. /// ----

  2. /// ---- file   : yac_host.cpp

  3. /// ----

  4. /// ---- author : (c) 2003 - 2018 by bsp

  5. /// ----

  6. /// ---- date   : 21-Nov-2003 / 27-Jun-2003 / 13-Feb-2004 / 17-Feb-2004 / 19-Feb-2004 / 26-Mar-2004

  7. /// ----          19-Feb-2005 / 24-Feb-2005 / 12-Mar-2005 / 19-Mar-2005 / 07-May-2005 / 28-Aug-2005

  8. /// ----          05-Sep-2005 / 28-Nov-2005 / 03-Feb-2006 / 05-Feb-2006 / 07-Feb-2006 / 24-Apr-2006

  9. /// ----          13-May-2006 / 01-Feb-2008 / 18-Feb-2008 / 24-Feb-2008 / 22-Mar-2008 / 14-Sep-2008

  10. /// ----          08-Jan-2009 / 05-Mar-2009 / 01-Apr-2009 / 04-Apr-2009 / 18-Apr-2009 / 04-May-2009

  11. /// ----          01-Jun-2009 / 11-Jul-2010 / 21-Apr-2011 / 21-Dec-2012 / 13-Aug-2013 / 05-Feb-2014

  12. /// ----          26-Jun-2018

  13. /// ----

  14. /// ---- info   : YAC - Yet Another Component object model. originally for the "tks" project

  15. /// ----

  16. /// ---- license: MIT. See LICENSE.txt.

  17. /// ---- 

  18. /// ---- 

  19. 

  20. #ifndef __YAC_HOST_CPP__

  21. #define __YAC_HOST_CPP__

  22. 

  23. 

  24. //

  25. // Define Dyac_object_counter_inc/dec macros before including this file to override

  26. // the default implementation

  27. //

  28. #ifndef Dyac_object_counter_inc

  29. 

  30. #ifdef YAC_OBJECT_COUNTER

  31. #define Dyac_object_counter_inc YAC_Object::object_counter++

  32. #define Dyac_object_counter_dec YAC_Object::object_counter--

  33. #else

  34. #define Dyac_object_counter_inc (void)0

  35. #define Dyac_object_counter_dec (void)0

  36. #endif // YAC_OBJECT_COUNTER

  37. 

  38. #endif // Dyac_object_counter_inc

  39. 

  40. 

  41. #ifdef YAC_TRACK_CHARALLOC

  42. sSI yac_string_total_char_size = 0;

  43. sSI yac_string_peak_char_size = 0;

  44. sU8 *yac_string_alloc_chars(size_t _n) {

  45.    yac_string_total_char_size += _n;

  46.    if(yac_string_total_char_size > yac_string_peak_char_size)

  47.    {

  48.       yac_string_peak_char_size = yac_string_total_char_size;

  49.    }

  50.    sSI *adr = (sSI*)::malloc(_n + sizeof(sSI));

  51.    *adr = _n;

  52.    return (sU8*) (adr + 1);

  53. }

  54. void yac_string_free_chars(sU8 *_chars) {

  55.    sSI *adr = ((sSI*)_chars) - 1;

  56.    yac_string_total_char_size -= *adr;

  57.    ::free(adr);

  58. }

  59. #endif // YAC_TRACK_CHARALLOC

  60. 

  61. 

  62. 

  63. #ifndef YAC_CUST_VALUE

  64.      YAC_Value::YAC_Value                                    (void)                                             {type=0;}

  65.      YAC_Value::~YAC_Value                                   ()                                                 { }

  66. void YAC_Value::initVoid                                     (void)                                             {deleteme=0;type=0;value.any=0;}

  67. void YAC_Value::initInt                                      (sSI _i)                                           {deleteme=0;type=1;value.int_val=_i;}

  68. void YAC_Value::initFloat                                    (sF32 _f)                                          {deleteme=0;type=2;value.float_val=_f;}

  69. void YAC_Value::initString                                   (YAC_String *_s, sBool _del)                       {deleteme=_del;type=4;value.string_val=_s;}

  70. void YAC_Value::initNewString                                (YAC_String *s)                                    {unsetFast(); type=4; deleteme=1; value.string_val=YAC_New_String(); value.string_val->yacCopy(s); }

  71. void YAC_Value::initObject                                   (YAC_Object *_o, sBool _del)                       {deleteme=_del;type=3;value.object_val=_o;}

  72. void YAC_Value::initNull                                     (void)                                             {unsetFast(); type=YAC_TYPE_OBJECT; value.any = 0; deleteme = 0; }

  73. void YAC_Value::safeInitInt                                  (sSI _i)                                           {unsetFast(); initInt(_i); }

  74. void YAC_Value::safeInitFloat                                (sF32 _f)                                          {unsetFast(); initFloat(_f); }

  75. void YAC_Value::safeInitString                               (YAC_String *_s, sBool _del)                       {unsetFast(); initString(_s, _del); }

  76. void YAC_Value::safeInitObject                               (YAC_Object *_o, sBool _new)                       {unsetFast(); initObject(_o, _new); }

  77. void YAC_Value::initEmptyString                              (void)                                             {deleteme=1; type=YAC_TYPE_STRING; value.string_val=(YAC_String*)YAC_NEW_CORE_POOLED(YAC_CLID_STRING);}

  78. void YAC_Value::typecast                                     (sUI _type)                                        {

  79.    sSI         i_t; 

  80.    sF32        f_t; 

  81.    switch(_type) 

  82.    { 

  83.    default: 

  84.       unset(); 

  85.       break; 

  86.    case 1: 

  87.       switch(type) 

  88.       {  

  89.       default:

  90.       case 0: 

  91.          initInt(0); 

  92.          break; 

  93.       case 1: 

  94.          break; 

  95.       case 2: 

  96.          initInt((sSI)value.float_val);

  97.          break; 

  98.       case 3: 

  99.          //i_t=(value.object_val!=0); 

  100.          //safeInitInt(i_t);  

  101.          if(value.object_val) 

  102.          { 

  103.             value.object_val->yacScanI(&i_t); 

  104.             safeInitInt(i_t); 

  105.          } 

  106.          else 

  107.             initInt(0);

  108.          break; 

  109.       case 4: 

  110.          if(value.string_val)  

  111.          { 

  112.             ////if(value.string_val->checkFloatConversion()) 

  113.             { 

  114.                value.string_val->yacScanF32(&f_t); 

  115.                safeInitInt((sSI)f_t); 

  116.             } 

  117.             ////else 

  118.             //// {

  119.             ////   value.string_val->yacScanI(&i_t);  

  120.             ////   safeInitInt(i_t); 

  121.             ///} 

  122.          }

  123.          else  

  124.          { 

  125.             safeInitInt(0); 

  126.          }

  127.          break; 

  128.       } 

  129.       break; 

  130.       case 2: 

  131.          switch(type) 

  132.          {  

  133.          default: 

  134.          case 0: 

  135.             initFloat(0.0f); 

  136.             break;

  137.          case 1: 

  138.             initFloat((sF32)value.int_val);

  139.             break; 

  140.          case 2: 

  141.             break; 

  142.          case 3:  

  143.          case 4: 

  144.             // ---- convert object to float value 

  145.             if(value.object_val) 

  146.                value.object_val->yacScanF32(&f_t); 

  147.             else 

  148.                f_t=0.0f; 

  149.             safeInitFloat(f_t); 

  150.             break; 

  151.          } 

  152.          break; 

  153.          case 3:  

  154.             switch(type) 

  155.             { 

  156.             default: 

  157.             case YAC_TYPE_VOID: 

  158.                // ---- typecast void to "null" Object 

  159.                initObject(NULL, 0); 

  160.                break; 

  161.             case YAC_TYPE_INT: 

  162.                // ---- typecast int to Integer Object 

  163.                { 

  164.                   YAC_Integer *io = (YAC_Integer*) YAC_NEW_CORE_POOLED(YAC_CLID_INTEGER);

  165.                   io->value=value.int_val; 

  166.                   initObject(io, 1); 

  167.                } 

  168.                break; 

  169.             case YAC_TYPE_FLOAT: 

  170.                // ---- typecast float to Float Object 

  171.                { 

  172.                   YAC_Float *fo = (YAC_Float*) YAC_NEW_CORE_POOLED(YAC_CLID_FLOAT);

  173.                   fo->value=value.float_val; 

  174.                   initObject(fo, 1); 

  175.                } 

  176.                break; 

  177.             case YAC_TYPE_OBJECT: 

  178.             case YAC_TYPE_STRING: 

  179.                break; 

  180.             } 

  181.             break;

  182.             case 4: 

  183.                { 

  184.                   //YAC_String *s; 

  185.                   switch(type) 

  186.                   {  

  187.                   default:

  188.                   case YAC_TYPE_VOID: 

  189.                      initEmptyString(); 

  190.                      break; 

  191.                   case YAC_TYPE_INT: 

  192.                      i_t = value.int_val; 

  193.                      value.string_val = (YAC_String*) YAC_NEW_CORE_POOLED(YAC_CLID_STRING16);

  194.                      value.string_val->printf("%i", i_t); 

  195.                      deleteme=1; 

  196.                      type=YAC_TYPE_STRING; 

  197.                      break; 

  198.                   case YAC_TYPE_FLOAT: 

  199.                      f_t = value.float_val; 

  200.                      value.string_val = (YAC_String*) YAC_NEW_CORE_POOLED(YAC_CLID_STRING32);

  201.                      value.string_val->printf("%g", f_t); 

  202.                      deleteme=1; 

  203.                      type=YAC_TYPE_STRING; 

  204.                      break; 

  205.                   case YAC_TYPE_OBJECT:  

  206.                      if(YAC_VALID(value.object_val))

  207.                      { 

  208.                         if(value.object_val->class_ID!=YAC_CLID_STRING) // string fix? 

  209.                         { 

  210.                            YAC_String *s = (YAC_String*) YAC_NEW_CORE_POOLED(YAC_CLID_STRING);

  211.                            value.object_val->yacToString(s); // convert Object to String 

  212.                            safeInitString(s, 1); 

  213.                         } 

  214.                      } 

  215.                      else 

  216.                      { 

  217.                         // ---- convert null object to empty String "" 

  218.                         initString((YAC_String*) YAC_NEW_CORE_POOLED(YAC_CLID_STRING), 1); 

  219.                      } 

  220.                      break;

  221.                   case YAC_TYPE_STRING: 

  222.                      break; 

  223.                   } 

  224.                } 

  225.                break; 

  226.    }

  227. } 

  228. 

  229. void YAC_Value::unsetFast                                    (void)                                             {if(type>=YAC_TYPE_OBJECT&&deleteme&&value.any)yac_host->yacDelete(value.object_val);} 

  230. void YAC_Value::unset                                        (void)                                             {if(type>=YAC_TYPE_OBJECT&&deleteme&&value.any)yac_host->yacDelete(value.object_val);value.object_val=0;type=0;deleteme=0;} 

  231. void YAC_Value::operator =                                   (YAC_Value *_v)                                    {deleteme=_v->deleteme;_v->deleteme=0;type=_v->type;value=_v->value;};

  232. void YAC_Value::copyRef                                      (const YAC_Value *_o)                         {type=_o->type;class_type=_o->class_type;value.any=_o->value.any;deleteme=0;}

  233. #endif

  234. 

  235. #ifndef YAC_CUST_EVENT

  236.                  YAC_Event::YAC_Event                 (void)                       {class_ID=YAC_CLID_EVENT;}

  237.                  YAC_Event::~YAC_Event                ()                           { }

  238. #endif // YAC_CUST_EVENT

  239. 

  240. #ifndef YAC_CUST_LISTNODE

  241. YAC_ListNode::YAC_ListNode                              (void)                                             {class_ID=YAC_CLID_LISTNODE;prev=next=0;}

  242. YAC_ListNode::~YAC_ListNode                             ()                                                 {if(next){yac_host->yacDelete(next);next=0;}unset();}

  243. #endif

  244. 

  245. #ifndef YAC_CUST_TREENODE

  246. YAC_TreeNode::YAC_TreeNode                              (void)                                             {class_ID=YAC_CLID_TREENODE;left=0;right=0;deleteme=0;value.int_val=0;}

  247. YAC_TreeNode::~YAC_TreeNode                             ()                                                 {if(left){yac_host->yacDelete(left);left=0;}if(right){yac_host->yacDelete(right); right=0;}unset();}

  248. #endif

  249. 

  250. 

  251.    // ---- 

  252.    // ---- 

  253.    // ---- LEVEL (1<<0) interface 

  254.    // ----                    ( C++ reflectance support )

  255.    // ---- 

  256.    // ---- 

  257. #ifdef YAC_OBJECT_COUNTER

  258. sUI              YAC_Object::object_counter                  =0;

  259. #endif //YAC_OBJECT_COUNTER

  260.                  YAC_Object::YAC_Object                      (void)                                  {

  261.                     Dyac_object_counter_inc;

  262. 

  263. #ifdef YAC_OBJECT_TAGS

  264.                     validation_tag = YAC_VALID_TAG;

  265. #endif

  266. 

  267. #ifdef YAC_OBJECT_POOL

  268.                     pool_handle.pool_id = 0;

  269. #endif // YAC_OBJECT_POOL

  270.                     

  271.                     // Note: pool_handle initialization is left out by intention! (it has already been set *before* this constructor is called!)

  272.                  }

  273.                  YAC_Object::~YAC_Object                     ()                                      {

  274.                     Dyac_object_counter_dec;

  275. #ifdef YAC_OBJECT_TAGS

  276.                     validation_tag = YAC_INVALID_TAG;

  277. #endif

  278. 

  279. #ifdef YAC_OBJECT_POOL

  280.                     pool_handle.pool_id = 0;

  281. #endif // YAC_OBJECT_POOL

  282.                  }

  283. sUI              YAC_VCALL YAC_Object::yacQueryInterfaces              (void)                                  {return YAC_INTERFACE_ALL;}

  284. #ifndef YAC_CUST_OBJECT

  285. const sChar*     YAC_VCALL YAC_Object::yacClassName                    (void)                                  {return "null";}

  286. YAC_Object*      YAC_VCALL YAC_Object::yacNewObject                    (void)                                  {return 0;}

  287. sUI              YAC_VCALL YAC_Object::yacMemberGetNum                 (void)                                  {return 0;}

  288. const char     **YAC_VCALL YAC_Object::yacMemberGetNames               (void)                                  {return 0;}

  289. const sUI       *YAC_VCALL YAC_Object::yacMemberGetTypes               (void)                                  {return 0;}

  290. const char     **YAC_VCALL YAC_Object::yacMemberGetObjectTypes         (void)                                  {return 0;}

  291. const sU8      **YAC_VCALL YAC_Object::yacMemberGetOffsets             (void)                                  {return (const sU8**)0;}

  292. sUI              YAC_VCALL YAC_Object::yacMethodGetNum                 (void)                                  {return 0;}

  293. const char     **YAC_VCALL YAC_Object::yacMethodGetNames               (void)                                  {return 0;}

  294. const sUI       *YAC_VCALL YAC_Object::yacMethodGetNumParameters       (void)                                  {return 0;}

  295. const sUI      **YAC_VCALL YAC_Object::yacMethodGetParameterTypes      (void)                                  {return 0;}

  296. const char    ***YAC_VCALL YAC_Object::yacMethodGetParameterObjectTypes(void)                                  {return 0;}

  297. const sUI       *YAC_VCALL YAC_Object::yacMethodGetReturnTypes         (void)                                  {return 0;}

  298. const char     **YAC_VCALL YAC_Object::yacMethodGetReturnObjectTypes   (void)                                  {return 0;}

  299. const void     **YAC_VCALL YAC_Object::yacMethodGetAdr                 (void)                                  {return 0;}

  300. sUI              YAC_VCALL YAC_Object::yacConstantGetNum               (void)                                  {return 0;}

  301. const char     **YAC_VCALL YAC_Object::yacConstantGetNames             (void)                                  {return 0;}

  302. const sUI       *YAC_VCALL YAC_Object::yacConstantGetTypes             (void)                                  {return 0;}

  303. yacmemptr        YAC_VCALL YAC_Object::yacConstantGetValues            (void)                                  {yacmemptr r; r.any=0; return r;}

  304. #endif // YAC_CUST_OBJECT

  305. void             YAC_VCALL YAC_Object::yacFinalizeObject               (YAC_ContextHandle)                     { }

  306. void             YAC_VCALL YAC_Object::yacGetConstantStringList        (YAC_String *)                          { }

  307. sBool            YAC_VCALL YAC_Object::yacIsComposite                  (void)                                  {return 0;}

  308. sUI              YAC_VCALL YAC_Object::yacPoolGetSize                  (void)                                  {return 0;}

  309. void             YAC_VCALL YAC_Object::yacPoolInit                     (YAC_Object *)                          { }

  310. sUI              YAC_VCALL YAC_Object::yacPoolGetPriority              (void)                                  {return 0;}

  311. void             YAC_VCALL YAC_Object::vtable_entry_0_25_reserved      (void)                                  { }

  312. void             YAC_VCALL YAC_Object::vtable_entry_0_26_reserved      (void)                                  { }

  313. void             YAC_VCALL YAC_Object::vtable_entry_0_27_reserved      (void)                                  { }

  314. void             YAC_VCALL YAC_Object::vtable_entry_0_28_reserved      (void)                                  { }

  315. void             YAC_VCALL YAC_Object::vtable_entry_0_29_reserved      (void)                                  { }

  316. void             YAC_VCALL YAC_Object::vtable_entry_0_30_reserved      (void)                                  { }

  317. void             YAC_VCALL YAC_Object::vtable_entry_0_31_reserved      (void)                                  { }

  318. 

  319. 

  320.    // ---- 

  321.    // ---- 

  322.    // ---- LEVEL (1<<1) interface 

  323.    // ----                    ( operator support )

  324.    // ----                        - also see YAC_OP_xxx constants

  325.    // ---- 

  326.    // ---- 

  327. void             YAC_VCALL Object__operator                           (void *_o, yacmemptr _args,YAC_Value*_v){((YAC_Object*)_o)->yacOperator(_args.si[0], _args.io[1], _v);}

  328. sBool            YAC_VCALL YAC_Object::yacCopy                        (YAC_Object *)                          {return 0;}

  329. sBool            YAC_VCALL YAC_Object::yacEquals                      (YAC_Object *_o)                        {return ((void*)this)==((void*)_o);} 

  330. void             YAC_VCALL YAC_Object::yacOperator                    (sSI _i, YAC_Object *_o, YAC_Value *_r) { 

  331. 	switch(_i)                                                                                       { 

  332. 	case YAC_OP_SHL: if(YAC_IS_STREAM(_o)){yacDeserialize(_o,1/**include type information**/);}       break;

  333. 	case YAC_OP_CLT: _r->initInt(0);                                                                  break;

  334. 	case YAC_OP_CLE: _r->initInt(0);                                                                  break;

  335.    case YAC_OP_CEQ: 

  336.       if(_o)

  337.          if(class_ID==YAC_CLID_OBJECT/*null*/)

  338.             _r->initInt(_o->class_ID==YAC_CLID_OBJECT);

  339.          else 

  340.             _r->initInt(((void*)this)==((void*)_o));

  341.       else 

  342.          _r->initInt(class_ID==YAC_CLID_OBJECT/*null*/); 

  343.       break;

  344.    case YAC_OP_CNE: 

  345.       //_r->initInt(((sUI)this)!=((sUI)_o));                                             break;

  346.       if(_o)

  347.          if(class_ID==YAC_CLID_OBJECT/*null*/)

  348.             _r->initInt(_o->class_ID!=YAC_CLID_OBJECT);

  349.          else 

  350.             _r->initInt(((void*)this)!=((void*)_o));

  351.       else 

  352.          _r->initInt(class_ID!=YAC_CLID_OBJECT/*null*/); 

  353.       break;

  354. 	case YAC_OP_CGE: _r->initInt(0);                                                                  break;

  355. 	case YAC_OP_CGT: _r->initInt(0);                                                                  break;

  356. 	                                                                                                 }

  357.                                                                                                     } 

  358. void             YAC_VCALL YAC_Object::yacOperatorInit                (void *_context, YAC_Object *_robj)     {YAC_Value r;yacOperator(YAC_OP_INIT,_robj,&r);r.unsetFast();} 

  359. void             YAC_VCALL YAC_Object::yacOperatorAssign              (YAC_Object *_robj)                     {YAC_Value r;yacOperator(YAC_OP_ASSIGN,_robj,&r);r.unsetFast();}

  360. void             YAC_VCALL YAC_Object::yacOperatorAdd                 (YAC_Object *_robj)                     {YAC_Value ret;yacOperator(YAC_OP_ADD,_robj,&ret);ret.unsetFast();}

  361. void             YAC_VCALL YAC_Object::yacOperatorSub                 (YAC_Object *_robj)                     {YAC_Value ret;yacOperator(YAC_OP_SUB,_robj,&ret);ret.unsetFast();}

  362. void             YAC_VCALL YAC_Object::yacOperatorMul                 (YAC_Object *_robj)                     {YAC_Value ret;yacOperator(YAC_OP_MUL,_robj,&ret);ret.unsetFast();}

  363. void             YAC_VCALL YAC_Object::yacOperatorDiv                 (YAC_Object *_robj)                     {YAC_Value ret;yacOperator(YAC_OP_DIV,_robj,&ret);ret.unsetFast();}

  364. void             YAC_VCALL YAC_Object::yacOperatorClamp               (YAC_Object *, YAC_Object *)            { }

  365. void             YAC_VCALL YAC_Object::yacOperatorWrap                (YAC_Object *, YAC_Object *)            { }

  366. sBool            YAC_VCALL YAC_Object::yacScanI                       (sSI *_ip)                              {*_ip=0;   return 0;}

  367. sBool            YAC_VCALL YAC_Object::yacScanF32                     (sF32 *_fp)                             {*_fp=0.0f;return 0;}

  368. sBool            YAC_VCALL YAC_Object::yacScanF64                     (sF64 *_dp)                             {*_dp=0.0; return 0;}

  369. sBool            YAC_VCALL YAC_Object::yacToString                    (YAC_String *) const                    {return 0;}

  370. sBool            YAC_VCALL YAC_Object::yacScanI64                     (sS64 *)                                {return 0;}

  371. void             YAC_VCALL YAC_Object::yacOperatorI                   (sSI _cmd,sSI _val,YAC_Value *)         {if(_cmd==YAC_OP_ASSIGN)yacValueOfI(_val);}

  372. void             YAC_VCALL YAC_Object::yacOperatorF32                 (sSI _cmd,sF32 _val,YAC_Value *_r)      {if(_cmd==YAC_OP_ASSIGN)yacValueOfF32(_val);else yacOperatorI(_cmd, (sSI)_val, _r);}

  373. void             YAC_VCALL YAC_Object::yacOperatorF64                 (sSI _cmd,sF64 _val,YAC_Value *_r)      {if(_cmd==YAC_OP_ASSIGN)yacValueOfF64(_val);else yacOperatorF32(_cmd, (sF32)_val, _r);}

  374. void             YAC_VCALL YAC_Object::yacValueOfI                    (sSI)                                   {}

  375. void             YAC_VCALL YAC_Object::yacValueOfF32                  (sF32 _val)                             {yacValueOfI((sSI)_val);}

  376. void             YAC_VCALL YAC_Object::yacValueOfF64                  (sF64 _val)                             {yacValueOfF32((sF32)_val);}

  377. sUI              YAC_VCALL YAC_Object::yacOperatorPriority            (void)                                  {return 0;}

  378. void             YAC_VCALL YAC_Object::yacValueOfI64                  (sS64 _val)                             {yacValueOfI((sSI)_val);}

  379. sSI              YAC_VCALL YAC_Object::yacTensorRank                  (void)                                  {return YAC_TENSOR_RANK_NONE;}

  380. sBool            YAC_VCALL YAC_Object::yacToParsableString            (YAC_String *s) const                   {return yacToString(s);}

  381. void             YAC_VCALL YAC_Object::yacOperatorI64                 (sSI _cmd,sS64 _val,YAC_Value *_r)      {if(_cmd==YAC_OP_ASSIGN)yacValueOfI64(_val);else yacOperatorI(_cmd, (sSI)_val, _r);}

  382. void             YAC_VCALL YAC_Object::vtable_entry_1_28_reserved     (void)                                  { }

  383. void             YAC_VCALL YAC_Object::vtable_entry_1_29_reserved     (void)                                  { }

  384. void             YAC_VCALL YAC_Object::vtable_entry_1_30_reserved     (void)                                  { }

  385. void             YAC_VCALL YAC_Object::vtable_entry_1_31_reserved     (void)                                  { }

  386. 

  387.    // ---- 

  388.    // ---- 

  389.    // ---- LEVEL (1<<2) interface 

  390.    // ----                    ( stream support )

  391.    // ---- 

  392.    // ---- 

  393.    // ---- 

  394. sBool            YAC_VCALL YAC_Object::yacIsStream                    (void)                                  {return 0;}

  395. void             YAC_VCALL YAC_Object::yacStreamClose                 (void)                                  { }

  396. sBool            YAC_VCALL YAC_Object::yacStreamOpenLocal             (sChar *, sSI)                          {return 0;}

  397. sBool            YAC_VCALL YAC_Object::yacStreamOpenLogic             (sChar *)                               {return 0;}

  398. sUI              YAC_VCALL YAC_Object::yacStreamGetByteOrder          (void)                                  {return 0;}

  399. void             YAC_VCALL YAC_Object::yacStreamSetByteOrder          (sUI)                                   { }        

  400. sBool            YAC_VCALL YAC_Object::yacStreamEOF                   (void)                                  {return 1;}

  401. void             YAC_VCALL YAC_Object::yacStreamSeek                  (sSI, sUI)                              { }        

  402. sUI              YAC_VCALL YAC_Object::yacStreamGetOffset             (void)                                  {return 0;}

  403. void             YAC_VCALL YAC_Object::yacStreamSetOffset             (sUI)                                   { }        

  404. sUI              YAC_VCALL YAC_Object::yacStreamGetSize               (void)                                  {return 0;}

  405. sSI              YAC_VCALL YAC_Object::yacStreamRead                  (sU8 *, sUI)                            {return 0;}

  406. sU8              YAC_VCALL YAC_Object::yacStreamReadI8                (void)                                  {return 0;}

  407. sU16             YAC_VCALL YAC_Object::yacStreamReadI16               (void)                                  {return 0;}

  408. sU32             YAC_VCALL YAC_Object::yacStreamReadI32               (void)                                  {return 0;}

  409. sF32             YAC_VCALL YAC_Object::yacStreamReadF32               (void)                                  {return 0;}

  410. void             YAC_VCALL YAC_Object::yacStreamReadObject            (YAC_Object *)                          { }        

  411. sSI              YAC_VCALL YAC_Object::yacStreamReadString            (YAC_String *, sUI)                     {return 0;}

  412. sSI              YAC_VCALL YAC_Object::yacStreamReadBuffer            (YAC_Buffer *, sUI, sUI, sBool)         {return 0;}

  413. sSI              YAC_VCALL YAC_Object::yacStreamReadLine              (YAC_String *, sUI)                     {return 0;}

  414. sSI              YAC_VCALL YAC_Object::yacStreamWrite                 (sU8 *, sUI)                            {return 0;}

  415. void             YAC_VCALL YAC_Object::yacStreamWriteI8               (sU8)                                   { }        

  416. void             YAC_VCALL YAC_Object::yacStreamWriteI16              (sU16)                                  { }        

  417. void             YAC_VCALL YAC_Object::yacStreamWriteI32              (sS32)                                  { }        

  418. void             YAC_VCALL YAC_Object::yacStreamWriteF32              (sF32)                                  { }        

  419. void             YAC_VCALL YAC_Object::yacStreamWriteObject           (YAC_Object*)                           { }        

  420. sSI              YAC_VCALL YAC_Object::yacStreamWriteString           (YAC_String *, sUI, sUI)                {return 0;}

  421. sSI              YAC_VCALL YAC_Object::yacStreamWriteBuffer           (YAC_Buffer *, sUI, sUI)                {return 0;}

  422. sSI              YAC_VCALL YAC_Object::yacStreamGetErrorCode          (void)                                  {return 0xCCCCCCCC;}

  423. void             YAC_VCALL YAC_Object::yacStreamGetErrorStringByCode  (sSI, YAC_Value *)                      { }

  424. sF64             YAC_VCALL YAC_Object::yacStreamReadF64               (void)                                  {return 0;}

  425. void             YAC_VCALL YAC_Object::yacStreamWriteF64              (sF64)                                  { }        

  426. sU64             YAC_VCALL YAC_Object::yacStreamReadI64               (void)                                  {return 0;}

  427. void             YAC_VCALL YAC_Object::yacStreamWriteI64              (sS64)                                  { }        

  428. void             YAC_VCALL YAC_Object::vtable_entry_2_35_reserved     (void)                                  { }

  429. void             YAC_VCALL YAC_Object::vtable_entry_2_36_reserved     (void)                                  { }

  430. void             YAC_VCALL YAC_Object::vtable_entry_2_37_reserved     (void)                                  { }

  431. void             YAC_VCALL YAC_Object::vtable_entry_2_38_reserved     (void)                                  { }

  432. void             YAC_VCALL YAC_Object::vtable_entry_2_39_reserved     (void)                                  { }

  433. void             YAC_VCALL YAC_Object::vtable_entry_2_40_reserved     (void)                                  { }

  434. void             YAC_VCALL YAC_Object::vtable_entry_2_41_reserved     (void)                                  { }

  435. void             YAC_VCALL YAC_Object::vtable_entry_2_42_reserved     (void)                                  { }

  436. void             YAC_VCALL YAC_Object::vtable_entry_2_43_reserved     (void)                                  { }

  437. void             YAC_VCALL YAC_Object::vtable_entry_2_44_reserved     (void)                                  { }

  438. void             YAC_VCALL YAC_Object::vtable_entry_2_45_reserved     (void)                                  { }

  439. void             YAC_VCALL YAC_Object::vtable_entry_2_46_reserved     (void)                                  { }

  440. void             YAC_VCALL YAC_Object::vtable_entry_2_47_reserved     (void)                                  { }

  441. 

  442.    // ---- 

  443.    // ---- 

  444.    // ---- LEVEL (1<<3) interface 

  445.    // ----                    ( serialization support )

  446.    // ---- 

  447.    // ---- 

  448.    // ---- 

  449. void             YAC_VCALL YAC_Object::yacSerializeClassName          (YAC_Object *_ofs)                      {YAC_String cln;cln.visit((sChar*)yacClassName());cln.yacSerialize(_ofs, 0);}

  450. void             YAC_VCALL YAC_Object::yacSerialize                   (YAC_Object *, sUI)                     { }

  451. sUI              YAC_VCALL YAC_Object::yacDeserialize                 (YAC_Object *, sUI)                     {return 0;}

  452. void             YAC_VCALL YAC_Object::vtable_entry_3_3_reserved      (void)                                  { }

  453. void             YAC_VCALL YAC_Object::vtable_entry_3_4_reserved      (void)                                  { }

  454. void             YAC_VCALL YAC_Object::vtable_entry_3_5_reserved      (void)                                  { }

  455. void             YAC_VCALL YAC_Object::vtable_entry_3_6_reserved      (void)                                  { }

  456. void             YAC_VCALL YAC_Object::vtable_entry_3_7_reserved      (void)                                  { }

  457. void             YAC_VCALL YAC_Object::vtable_entry_3_8_reserved      (void)                                  { }

  458. void             YAC_VCALL YAC_Object::vtable_entry_3_9_reserved      (void)                                  { }

  459. void             YAC_VCALL YAC_Object::vtable_entry_3_10_reserved     (void)                                  { }

  460. void             YAC_VCALL YAC_Object::vtable_entry_3_11_reserved     (void)                                  { }

  461. void             YAC_VCALL YAC_Object::vtable_entry_3_12_reserved     (void)                                  { }

  462. void             YAC_VCALL YAC_Object::vtable_entry_3_13_reserved     (void)                                  { }

  463. void             YAC_VCALL YAC_Object::vtable_entry_3_14_reserved     (void)                                  { }

  464. void             YAC_VCALL YAC_Object::vtable_entry_3_15_reserved     (void)                                  { }

  465. 

  466.    // ---- 

  467.    // ---- 

  468.    // ---- LEVEL (1<<4) interface 

  469.    // ----                    ( iterator support )

  470.    // ---- 

  471.    // ---- 

  472.    // ---- 

  473. 

  474. sBool            YAC_VCALL YAC_Object::yacIteratorInit                (YAC_Iterator *) const                  {return 0;} 

  475. void             YAC_VCALL YAC_Object::vtable_entry_4_1_reserved      (void)                                  { }

  476. void             YAC_VCALL YAC_Object::vtable_entry_4_2_reserved      (void)                                  { }

  477. void             YAC_VCALL YAC_Object::vtable_entry_4_3_reserved      (void)                                  { }

  478. void             YAC_VCALL YAC_Object::vtable_entry_4_4_reserved      (void)                                  { }

  479. void             YAC_VCALL YAC_Object::vtable_entry_4_5_reserved      (void)                                  { }

  480. void             YAC_VCALL YAC_Object::vtable_entry_4_6_reserved      (void)                                  { }

  481. void             YAC_VCALL YAC_Object::vtable_entry_4_7_reserved      (void)                                  { }

  482. void             YAC_VCALL YAC_Object::vtable_entry_4_8_reserved      (void)                                  { }

  483. void             YAC_VCALL YAC_Object::vtable_entry_4_9_reserved      (void)                                  { }

  484. void             YAC_VCALL YAC_Object::vtable_entry_4_10_reserved     (void)                                  { }

  485. void             YAC_VCALL YAC_Object::vtable_entry_4_11_reserved     (void)                                  { }

  486. void             YAC_VCALL YAC_Object::vtable_entry_4_12_reserved     (void)                                  { }

  487. void             YAC_VCALL YAC_Object::vtable_entry_4_13_reserved     (void)                                  { }

  488. void             YAC_VCALL YAC_Object::vtable_entry_4_14_reserved     (void)                                  { }

  489. void             YAC_VCALL YAC_Object::vtable_entry_4_15_reserved     (void)                                  { }

  490. 

  491.    // ---- 

  492.    // ---- 

  493.    // ---- LEVEL (1<<5) interface 

  494.    // ----                    ( array and hashtable support )

  495.    // ---- 

  496.    // ---- 

  497.    // ---- 

  498. YAC_Object*      YAC_VCALL YAC_Object::yacArrayNew                    (void)                                  {return 0;} 

  499. sUI              YAC_VCALL YAC_Object::yacArrayAlloc                  (sUI, sUI, sUI, sUI)                    {return 0;}

  500. sBool            YAC_VCALL YAC_Object::yacArrayRealloc                (sUI,sUI,sUI,sUI)                       {return 0;}

  501. sUI              YAC_VCALL YAC_Object::yacArrayGetNumElements         (void)                                  {return 0;}

  502. sUI              YAC_VCALL YAC_Object::yacArrayGetMaxElements         (void)                                  {return 0;}

  503. void             YAC_VCALL YAC_Object::yacArrayCopySize               (YAC_Object *)                          { }

  504. void             YAC_VCALL YAC_Object::yacArraySet                    (void *_context, sUI, YAC_Value *)      { }

  505. void             YAC_VCALL YAC_Object::yacArrayGet                    (void *_context, sUI, YAC_Value *)      { }

  506. sUI              YAC_VCALL YAC_Object::yacArrayGetWidth               (void)                                  {return 0;} 

  507. sUI              YAC_VCALL YAC_Object::yacArrayGetHeight              (void)                                  {return 0;}

  508. sUI              YAC_VCALL YAC_Object::yacArrayGetElementType         (void)                                  {return 0;}

  509. sUI              YAC_VCALL YAC_Object::yacArrayGetElementByteSize     (void)                                  {return 0;}

  510. sUI              YAC_VCALL YAC_Object::yacArrayGetStride              (void)                                  {return 0;} 

  511. void *           YAC_VCALL YAC_Object::yacArrayGetPointer             (void)                                  {return 0;} 

  512. void             YAC_VCALL YAC_Object::yacArraySetWidth               (sUI)                                   { }

  513. void             YAC_VCALL YAC_Object::yacArraySetTemplate            (YAC_Object *)                          { }

  514. void             YAC_VCALL YAC_Object::yacArrayGetDeref               (void *_context, sUI _i, YAC_Value *_r) {yacArrayGet(_context, _i, _r);}

  515. void             YAC_VCALL YAC_Object::vtable_entry_5_17_reserved     (void)                                  { }

  516. void             YAC_VCALL YAC_Object::vtable_entry_5_18_reserved     (void)                                  { }

  517. void             YAC_VCALL YAC_Object::vtable_entry_5_19_reserved     (void)                                  { }

  518. void             YAC_VCALL YAC_Object::vtable_entry_5_20_reserved     (void)                                  { }

  519. void             YAC_VCALL YAC_Object::vtable_entry_5_21_reserved     (void)                                  { }

  520. void             YAC_VCALL YAC_Object::vtable_entry_5_22_reserved     (void)                                  { }

  521. void             YAC_VCALL YAC_Object::vtable_entry_5_23_reserved     (void)                                  { }

  522. void             YAC_VCALL YAC_Object::vtable_entry_5_24_reserved     (void)                                  { }

  523. void             YAC_VCALL YAC_Object::vtable_entry_5_25_reserved     (void)                                  { }

  524. void             YAC_VCALL YAC_Object::vtable_entry_5_26_reserved     (void)                                  { }

  525. void             YAC_VCALL YAC_Object::vtable_entry_5_27_reserved     (void)                                  { }

  526. void             YAC_VCALL YAC_Object::vtable_entry_5_28_reserved     (void)                                  { }

  527. void             YAC_VCALL YAC_Object::vtable_entry_5_29_reserved     (void)                                  { }

  528. void             YAC_VCALL YAC_Object::vtable_entry_5_30_reserved     (void)                                  { }

  529. void             YAC_VCALL YAC_Object::vtable_entry_5_31_reserved     (void)                                  { }

  530. 

  531. void             YAC_VCALL YAC_Object::yacHashSet                     (void *_context, YAC_String *_s, YAC_Value *_v)         { 

  532.    sSI i=0;

  533.    if(YAC_Is_String(_s))

  534.    {

  535.       YAC_String *s=(YAC_String*)_s;

  536.       s->yacScanI(&i);

  537.    }

  538.    yacArraySet(_context, (sUI)i, _v);

  539. } 

  540. void             YAC_VCALL YAC_Object::yacHashGet                     (void *_context, YAC_String*_s, YAC_Value *_v)          { 

  541.    sSI i=0;

  542.    if(YAC_Is_String(_s))

  543.    {

  544.       YAC_String *s=(YAC_String*)_s;

  545.       s->yacScanI(&i);

  546.    }

  547.    yacArrayGet(_context, (sUI)i, _v);

  548. }

  549. void             YAC_VCALL YAC_Object::yacHashGetDeref                (void *_context, YAC_String*_s, YAC_Value *_v)          {yacHashGet(NULL, _s, _v);} // xxx TKS_MT: should use *real* thread context (exceptions!)

  550. void             YAC_VCALL YAC_Object::vtable_entry_5_35_reserved     (void)                                  { }

  551. void             YAC_VCALL YAC_Object::vtable_entry_5_36_reserved     (void)                                  { }

  552. void             YAC_VCALL YAC_Object::vtable_entry_5_37_reserved     (void)                                  { }

  553. void             YAC_VCALL YAC_Object::vtable_entry_5_38_reserved     (void)                                  { }

  554. void             YAC_VCALL YAC_Object::vtable_entry_5_39_reserved     (void)                                  { }

  555. 

  556.    // ---- 

  557.    // ---- 

  558.    // ---- LEVEL (1<<6) interface 

  559.    // ----                    ( metaclass support )

  560.    // ---- 

  561.    // ---- 

  562.    // ---- 

  563. sChar *          YAC_VCALL YAC_Object::yacMetaClassName                     (void)                            {return 0;} 

  564. sUI              YAC_VCALL YAC_Object::yacMetaClassMemberGetNum             (void)                            {return 0;}

  565. sUI              YAC_VCALL YAC_Object::yacMetaClassMemberGetAccessKeyByIndex(sUI)                             {return 0;}

  566. sUI              YAC_VCALL YAC_Object::yacMetaClassMemberGetAccessKeyByName (const sChar *)                   {return 0;}

  567. sUI              YAC_VCALL YAC_Object::yacMetaClassMemberGetType            (sUI)                             {return 0;}

  568. sChar *          YAC_VCALL YAC_Object::yacMetaClassMemberGetName            (sUI)                             {return 0;}

  569. void             YAC_VCALL YAC_Object::yacMetaClassMemberSet                (sUI, YAC_Value *)                { }

  570. void             YAC_VCALL YAC_Object::yacMetaClassMemberGet                (sUI, YAC_Value *)                { }

  571. sSI              YAC_VCALL YAC_Object::yacMetaClassInstanceOf               (YAC_Object *)                    {return 0;}

  572. void             YAC_VCALL YAC_Object::vtable_entry_6_10_reserved           (void)                            { }

  573. void             YAC_VCALL YAC_Object::vtable_entry_6_11_reserved           (void)                            { }

  574. void             YAC_VCALL YAC_Object::vtable_entry_6_12_reserved           (void)                            { }

  575. void             YAC_VCALL YAC_Object::vtable_entry_6_13_reserved           (void)                            { }

  576. void             YAC_VCALL YAC_Object::vtable_entry_6_14_reserved           (void)                            { }

  577. void             YAC_VCALL YAC_Object::vtable_entry_6_15_reserved           (void)                            { }

  578. 

  579.    // ---- 

  580.    // ---- 

  581.    // ---- LEVEL (1<<7) interface 

  582.    // ----                    ( signal/callback support )

  583.    // ---- 

  584. void             YAC_VCALL YAC_Object::yacRegisterSignal              (sUI, YAC_FunctionHandle)               { }

  585. void             YAC_VCALL YAC_Object::yacGetSignalStringList         (YAC_String *)                          { }

  586. 

  587. 

  588.    // ---- 

  589.    // ---- 

  590.    // ---- non-virtual helper methods

  591.    // ---- 

  592.    // ---- 

  593.    // ---- 

  594. #ifdef YAC_OBJECT_POOL

  595. YAC_Object *     YAC_Object::yacNew                         (YAC_ContextHandle _context)            {YAC_Object*t=yacNewObject();if(t){t->pool_handle.pool_id = 0; t->yacOperatorInit(_context, this);} return t;}

  596. #else

  597. YAC_Object *     YAC_Object::yacNew                         (YAC_ContextHandle _context)            {YAC_Object*t=yacNewObject();if(t){t->yacOperatorInit(_context, this);} return t;}

  598. #endif // YAC_OBJECT_POOL

  599. #ifdef YAC_OBJECT_POOL

  600. YAC_Object *     YAC_Object::yacNewPooled                   (YAC_ContextHandle _context, sUI _poolHint) {YAC_Object*t=yac_host->yacNewPooledByID(class_ID, _poolHint); if(t) { t->yacOperatorInit(_context, this); return t; } else { return yacNew(_context); } }

  601. #else

  602. YAC_Object *     YAC_Object::yacNewPooled                   (YAC_ContextHandle _context, sUI) { return yacNew(_context); }

  603. #endif // YAC_OBJECT_POOL

  604. // sBool            YAC_Object::yacCanDeserializeClass         (YAC_Object *_s)                        {YAC_String s;_s->yacStreamReadString(&s, 64);if( (yacClassName()&&s.compare((sChar*)yacClassName())) || (yacMetaClassName()&&s.compare((sChar*)yacMetaClassName())) ) {return 1;}else{_s->yacStreamSeek(-((sSI)s.length), YAC_CUR);/*expect ASCIIZ*/return 0;}}

  605. sBool            YAC_Object::yacCanDeserializeClass         (YAC_Object *_s)                        {

  606.    YAC_String *s = (YAC_String*) YAC_NEW_CORE_POOLED(YAC_CLID_STRING);

  607.    _s->yacStreamReadString(s, 64);// calls host-specific string methods so we need a "real" String object !

  608.    if( (yacClassName()&&s->compare((sChar*)yacClassName())) || (yacMetaClassName()&&s->compare((sChar*)yacMetaClassName())) ) 

  609.    {

  610.       YAC_DELETE(s);

  611.       return 1;

  612.    }

  613.    else

  614.    {

  615.       _s->yacStreamSeek(-((sSI)s->length), YAC_CUR);/*expect ASCIIZ*/

  616.       YAC_DELETE(s);

  617.       return 0;

  618.    }

  619. }

  620. sBool            YAC_Object::yacInstanceOf                  (YAC_Object *_o)                        {if(_o)return(yac_host->cpp_typecast_map[class_ID][_o->class_ID]);else return 0;}

  621. 

  622. #ifdef YAC_OBJECT_YAC

  623. // ---- auto-generated by gen_yac_object_c_calls.tks (Fri, 21/Dec/2012 23:12:48)

  624. void YAC_Object::_yacClassName(YAC_Value *_r) {

  625.     yac_object_yacClassName(this, _r);

  626. }

  627. void YAC_Object::_yacNewObject(YAC_Value *_r) {

  628.     yac_object_yacNewObject(this, _r);

  629. }

  630. sSI YAC_Object::_yacMemberGetNum(void) {

  631.     return yac_object_yacMemberGetNum(this);

  632. }

  633. void YAC_Object::_yacMemberGetNames(YAC_Value *_r) {

  634.     yac_object_yacMemberGetNames(this, _r);

  635. }

  636. void YAC_Object::_yacMemberGetTypes(YAC_Value *_r) {

  637.     yac_object_yacMemberGetTypes(this, _r);

  638. }

  639. void YAC_Object::_yacMemberGetObjectTypes(YAC_Value *_r) {

  640.     yac_object_yacMemberGetObjectTypes(this, _r);

  641. }

  642. void YAC_Object::_yacMemberGetOffsets(YAC_Value *_r) {

  643.     yac_object_yacMemberGetOffsets(this, _r);

  644. }

  645. sSI YAC_Object::_yacMethodGetNum(void) {

  646.     return yac_object_yacMethodGetNum(this);

  647. }

  648. void YAC_Object::_yacMethodGetNames(YAC_Value *_r) {

  649.     yac_object_yacMethodGetNames(this, _r);

  650. }

  651. void YAC_Object::_yacMethodGetNumParameters(YAC_Value *_r) {

  652.     yac_object_yacMethodGetNumParameters(this, _r);

  653. }

  654. void YAC_Object::_yacMethodGetParameterTypes(YAC_Value *_r) {

  655.     yac_object_yacMethodGetParameterTypes(this, _r);

  656. }

  657. void YAC_Object::_yacMethodGetParameterObjectTypes(YAC_Value *_r) {

  658.     yac_object_yacMethodGetParameterObjectTypes(this, _r);

  659. }

  660. void YAC_Object::_yacMethodGetReturnTypes(YAC_Value *_r) {

  661.     yac_object_yacMethodGetReturnTypes(this, _r);

  662. }

  663. void YAC_Object::_yacMethodGetReturnObjectTypes(YAC_Value *_r) {

  664.     yac_object_yacMethodGetReturnObjectTypes(this, _r);

  665. }

  666. void YAC_Object::_yacMethodGetAdr(YAC_Value *_r) {

  667.     yac_object_yacMethodGetAdr(this, _r);

  668. }

  669. sSI YAC_Object::_yacConstantGetNum(void) {

  670.     return yac_object_yacConstantGetNum(this);

  671. }

  672. void YAC_Object::_yacConstantGetNames(YAC_Value *_r) {

  673.     yac_object_yacConstantGetNames(this, _r);

  674. }

  675. void YAC_Object::_yacConstantGetTypes(YAC_Value *_r) {

  676.     yac_object_yacConstantGetTypes(this, _r);

  677. }

  678. void YAC_Object::_yacConstantGetValues(YAC_Value *_r) {

  679.     yac_object_yacConstantGetValues(this, _r);

  680. }

  681. sSI YAC_Object::_yacCopy(YAC_Object *_os) {

  682.     return yac_object_yacCopy(this, _os);

  683. }

  684. sSI YAC_Object::_yacEquals(YAC_Object *_ro) {

  685.     return yac_object_yacEquals(this, _ro);

  686. }

  687. void YAC_Object::_yacOperator(sSI _cmd, YAC_Object *_ro, YAC_Value *_r) {

  688.     yac_object_yacOperator(this, _cmd, _ro, _r);

  689. }

  690. void YAC_Object::_yacOperatorInit(YAC_Object *_ro) {

  691.     yac_object_yacOperatorInit(this, _ro);

  692. }

  693. void YAC_Object::_yacOperatorAssign(YAC_Object *_ro) {

  694.     yac_object_yacOperatorAssign(this, _ro);

  695. }

  696. void YAC_Object::_yacOperatorAdd(YAC_Object *_ro) {

  697.     yac_object_yacOperatorAdd(this, _ro);

  698. }

  699. void YAC_Object::_yacOperatorSub(YAC_Object *_ro) {

  700.     yac_object_yacOperatorSub(this, _ro);

  701. }

  702. void YAC_Object::_yacOperatorMul(YAC_Object *_ro) {

  703.     yac_object_yacOperatorMul(this, _ro);

  704. }

  705. void YAC_Object::_yacOperatorDiv(YAC_Object *_ro) {

  706.     yac_object_yacOperatorDiv(this, _ro);

  707. }

  708. void YAC_Object::_yacOperatorClamp(YAC_Object *_min, YAC_Object *_max) {

  709.     yac_object_yacOperatorClamp(this, _min, _max);

  710. }

  711. void YAC_Object::_yacOperatorWrap(YAC_Object *_min, YAC_Object *_max) {

  712.     yac_object_yacOperatorWrap(this, _min, _max);

  713. }

  714. sSI YAC_Object::_yacScanI32(YAC_Object *_vo) {

  715.     return yac_object_yacScanI32(this, _vo);

  716. }

  717. sSI YAC_Object::_yacScanI64(YAC_Object *_vo) {

  718.     return yac_object_yacScanI64(this, _vo);

  719. }

  720. sSI YAC_Object::_yacScanF32(YAC_Object *_vo) {

  721.     return yac_object_yacScanF32(this, _vo);

  722. }

  723. sSI YAC_Object::_yacScanF64(YAC_Object *_vo) {

  724.     return yac_object_yacScanF64(this, _vo);

  725. }

  726. sSI YAC_Object::_yacToString(YAC_Object *_s) const {

  727.     return yac_object_yacToString(this, _s);

  728. }

  729. void YAC_Object::_yacOperatorI(sSI _cmd, sSI _i, YAC_Value *_r) {

  730.     yac_object_yacOperatorI(this, _cmd, _i, _r);

  731. }

  732. void YAC_Object::_yacOperatorI64(sSI _cmd, YAC_Object *_no, YAC_Value *_r) {

  733.     yac_object_yacOperatorI64(this, _cmd, _no, _r);

  734. }

  735. void YAC_Object::_yacOperatorF32(sSI _cmd, sF32 _f32, YAC_Value *_r) {

  736.     yac_object_yacOperatorF32(this, _cmd, _f32, _r);

  737. }

  738. void YAC_Object::_yacOperatorF64(sSI _cmd, YAC_Object *_no, YAC_Value *_r) {

  739.     yac_object_yacOperatorF64(this, _cmd, _no, _r);

  740. }

  741. void YAC_Object::_yacValueOfI(sSI _i) {

  742.     yac_object_yacValueOfI(this, _i);

  743. }

  744. void YAC_Object::_yacValueOfF32(sF32 _f32) {

  745.     yac_object_yacValueOfF32(this, _f32);

  746. }

  747. void YAC_Object::_yacValueOfF64(YAC_Object *_no) {

  748.     yac_object_yacValueOfF64(this, _no);

  749. }

  750. void YAC_Object::_yacValueOfI64(YAC_Object *_no) {

  751.     yac_object_yacValueOfI64(this, _no);

  752. }

  753. sSI YAC_Object::_yacToParsableString(YAC_Object *_s) const {

  754.     return yac_object_yacToParsableString(this, _s);

  755. }

  756. sSI YAC_Object::_yacIsStream(void) {

  757.     return yac_object_yacIsStream(this);

  758. }

  759. void YAC_Object::_yacStreamClose(void) {

  760.     yac_object_yacStreamClose(this);

  761. }

  762. sSI YAC_Object::_yacStreamOpenLocal(YAC_Object *_name, sSI _access) {

  763.     return yac_object_yacStreamOpenLocal(this, _name, _access);

  764. }

  765. sSI YAC_Object::_yacStreamOpenLogic(YAC_Object *_name) {

  766.     return yac_object_yacStreamOpenLogic(this, _name);

  767. }

  768. sSI YAC_Object::_yacStreamGetByteOrder(void) {

  769.     return yac_object_yacStreamGetByteOrder(this);

  770. }

  771. void YAC_Object::_yacStreamSetByteOrder(sSI _order) {

  772.     yac_object_yacStreamSetByteOrder(this, _order);

  773. }

  774. sSI YAC_Object::_yacStreamEOF(void) {

  775.     return yac_object_yacStreamEOF(this);

  776. }

  777. void YAC_Object::_yacStreamSeek(sSI _off, sSI _mode) {

  778.     yac_object_yacStreamSeek(this, _off, _mode);

  779. }

  780. sSI YAC_Object::_yacStreamGetOffset(void) {

  781.     return yac_object_yacStreamGetOffset(this);

  782. }

  783. void YAC_Object::_yacStreamSetOffset(sSI _off) {

  784.     yac_object_yacStreamSetOffset(this, _off);

  785. }

  786. sSI YAC_Object::_yacStreamGetSize(void) {

  787.     return yac_object_yacStreamGetSize(this);

  788. }

  789. sSI YAC_Object::_yacStreamRead(YAC_Object *_ret, sSI _num) {

  790.     return yac_object_yacStreamRead(this, _ret, _num);

  791. }

  792. sSI YAC_Object::_yacStreamReadI8(void) {

  793.     return yac_object_yacStreamReadI8(this);

  794. }

  795. sSI YAC_Object::_yacStreamReadI16(void) {

  796.     return yac_object_yacStreamReadI16(this);

  797. }

  798. sSI YAC_Object::_yacStreamReadI32(void) {

  799.     return yac_object_yacStreamReadI32(this);

  800. }

  801. void YAC_Object::_yacStreamReadI64(YAC_Value *_r) {

  802.     yac_object_yacStreamReadI64(this, _r);

  803. }

  804. sF32 YAC_Object::_yacStreamReadF32(void) {

  805.     return yac_object_yacStreamReadF32(this);

  806. }

  807. void YAC_Object::_yacStreamReadF64(YAC_Value *_r) {

  808.     yac_object_yacStreamReadF64(this, _r);

  809. }

  810. void YAC_Object::_yacStreamReadObject(YAC_Object *_p) {

  811.     yac_object_yacStreamReadObject(this, _p);

  812. }

  813. sSI YAC_Object::_yacStreamReadString(YAC_Object *_s, sSI _maxlen) {

  814.     return yac_object_yacStreamReadString(this, _s, _maxlen);

  815. }

  816. sSI YAC_Object::_yacStreamReadBuffer(YAC_Object *_buffer, sSI _off, sSI _num, sSI _resize) {

  817.     return yac_object_yacStreamReadBuffer(this, _buffer, _off, _num, _resize);

  818. }

  819. sSI YAC_Object::_yacStreamReadLine(YAC_Object *_s, sSI _maxlen) {

  820.     return yac_object_yacStreamReadLine(this, _s, _maxlen);

  821. }

  822. sSI YAC_Object::_yacStreamWrite(YAC_Object *_in, sSI _num) {

  823.     return yac_object_yacStreamWrite(this, _in, _num);

  824. }

  825. void YAC_Object::_yacStreamWriteI8(sSI _i) {

  826.     yac_object_yacStreamWriteI8(this, _i);

  827. }

  828. void YAC_Object::_yacStreamWriteI16(sSI _i) {

  829.     yac_object_yacStreamWriteI16(this, _i);

  830. }

  831. void YAC_Object::_yacStreamWriteI32(sSI _i) {

  832.     yac_object_yacStreamWriteI32(this, _i);

  833. }

  834. void YAC_Object::_yacStreamWriteI64(YAC_Object *_no) {

  835.     yac_object_yacStreamWriteI64(this, _no);

  836. }

  837. void YAC_Object::_yacStreamWriteF32(sF32 _f) {

  838.     yac_object_yacStreamWriteF32(this, _f);

  839. }

  840. void YAC_Object::_yacStreamWriteF64(YAC_Object *_no) {

  841.     yac_object_yacStreamWriteF64(this, _no);

  842. }

  843. void YAC_Object::_yacStreamWriteObject(YAC_Object *_p) {

  844.     yac_object_yacStreamWriteObject(this, _p);

  845. }

  846. sSI YAC_Object::_yacStreamWriteString(YAC_Object *_s, sSI _off, sSI _num) {

  847.     return yac_object_yacStreamWriteString(this, _s, _off, _num);

  848. }

  849. sSI YAC_Object::_yacStreamWriteBuffer(YAC_Object *_b, sSI _off, sSI _num) {

  850.     return yac_object_yacStreamWriteBuffer(this, _b, _off, _num);

  851. }

  852. sSI YAC_Object::_yacStreamGetErrorCode(void) {

  853.     return yac_object_yacStreamGetErrorCode(this);

  854. }

  855. void YAC_Object::_yacStreamGetErrorStringByCode(sSI _code, YAC_Value *_r) {

  856.     yac_object_yacStreamGetErrorStringByCode(this, _code, _r);

  857. }

  858. void YAC_Object::_yacSerializeClassName(YAC_Object *_ofs) {

  859.     yac_object_yacSerializeClassName(this, _ofs);

  860. }

  861. void YAC_Object::_yacSerialize(YAC_Object *_ofs, sSI _usetypeinfo) {

  862.     yac_object_yacSerialize(this, _ofs, _usetypeinfo);

  863. }

  864. sSI YAC_Object::_yacDeserialize(YAC_Object *_ifs, sSI _usetypeinfo) {

  865.     return yac_object_yacDeserialize(this, _ifs, _usetypeinfo);

  866. }

  867. void YAC_Object::_yacArrayNew(YAC_Value *_r) {

  868.     yac_object_yacArrayNew(this, _r);

  869. }

  870. sSI YAC_Object::_yacArrayAlloc(sSI _sx, sSI _sy, sSI _type, sSI _ebytesize) {

  871.     return yac_object_yacArrayAlloc(this, _sx, _sy, _type, _ebytesize);

  872. }

  873. sSI YAC_Object::_yacArrayRealloc(sSI _sx, sSI _sy, sSI _type, sSI _ebytesize) {

  874.     return yac_object_yacArrayRealloc(this, _sx, _sy, _type, _ebytesize);

  875. }

  876. sSI YAC_Object::_yacArrayGetNumElements(void) {

  877.     return yac_object_yacArrayGetNumElements(this);

  878. }

  879. sSI YAC_Object::_yacArrayGetMaxElements(void) {

  880.     return yac_object_yacArrayGetMaxElements(this);

  881. }

  882. void YAC_Object::_yacArrayCopySize(YAC_Object *_p) {

  883.     yac_object_yacArrayCopySize(this, _p);

  884. }

  885. void YAC_Object::_yacArraySet(sSI _index, YAC_Object *_value) {

  886.     yac_object_yacArraySet(this, _index, _value);

  887. }

  888. void YAC_Object::_yacArrayGet(sSI _index, YAC_Value *_r) {

  889.     yac_object_yacArrayGet(this, _index, _r);

  890. }

  891. sSI YAC_Object::_yacArrayGetWidth(void) {

  892.     return yac_object_yacArrayGetWidth(this);

  893. }

  894. sSI YAC_Object::_yacArrayGetHeight(void) {

  895.     return yac_object_yacArrayGetHeight(this);

  896. }

  897. sSI YAC_Object::_yacArrayGetElementType(void) {

  898.     return yac_object_yacArrayGetElementType(this);

  899. }

  900. sSI YAC_Object::_yacArrayGetElementByteSize(void) {

  901.     return yac_object_yacArrayGetElementByteSize(this);

  902. }

  903. sSI YAC_Object::_yacArrayGetStride(void) {

  904.     return yac_object_yacArrayGetStride(this);

  905. }

  906. sSI YAC_Object::_yacArrayGetPointer(void) {

  907.     return yac_object_yacArrayGetPointer(this);

  908. }

  909. void YAC_Object::_yacArraySetWidth(sSI _width) {

  910.     yac_object_yacArraySetWidth(this, _width);

  911. }

  912. void YAC_Object::_yacArraySetTemplate(YAC_Object *_template) {

  913.     yac_object_yacArraySetTemplate(this, _template);

  914. }

  915. void YAC_Object::_yacArrayGetDeref(sSI _index, YAC_Value *_r) {

  916.     yac_object_yacArrayGetDeref(this, _index, _r);

  917. }

  918. void YAC_Object::_yacHashSet(YAC_Object *_key, YAC_Object *_value) {

  919.     yac_object_yacHashSet(this, _key, _value);

  920. }

  921. void YAC_Object::_yacHashGet(YAC_Object *_key, YAC_Value *_r) {

  922.     yac_object_yacHashGet(this, _key, _r);

  923. }

  924. void YAC_Object::_yacHashGetDeref(YAC_Object *_key, YAC_Value *_r) {

  925.     yac_object_yacHashGetDeref(this, _key, _r);

  926. }

  927. void YAC_Object::_yacGetSignalStringList(YAC_Object *_s) {

  928.     yac_object_yacGetSignalStringList(this, _s);

  929. }

  930. void YAC_Object::_yacMetaClassName(YAC_Value *_r) {

  931.     yac_object_yacMetaClassName(this, _r);

  932. }

  933. sSI YAC_Object::_yacMetaClassMemberGetNum(void) {

  934.     return yac_object_yacMetaClassMemberGetNum(this);

  935. }

  936. sSI YAC_Object::_yacMetaClassMemberGetAccessKeyByIndex(sSI _index) {

  937.     return yac_object_yacMetaClassMemberGetAccessKeyByIndex(this, _index);

  938. }

  939. sSI YAC_Object::_yacMetaClassMemberGetAccessKeyByName(YAC_Object *_s) {

  940.     return yac_object_yacMetaClassMemberGetAccessKeyByName(this, _s);

  941. }

  942. sSI YAC_Object::_yacMetaClassMemberGetType(sSI _ak) {

  943.     return yac_object_yacMetaClassMemberGetType(this, _ak);

  944. }

  945. void YAC_Object::_yacMetaClassMemberGetName(sSI _ak, YAC_Value *_r) {

  946.     yac_object_yacMetaClassMemberGetName(this, _ak, _r);

  947. }

  948. void YAC_Object::_yacMetaClassMemberSet(sSI _ak, YAC_Object *_value) {

  949.     yac_object_yacMetaClassMemberSet(this, _ak, _value);

  950. }

  951. void YAC_Object::_yacMetaClassMemberGet(sSI _ak, YAC_Value *_r) {

  952.     yac_object_yacMetaClassMemberGet(this, _ak, _r);

  953. }

  954. sSI YAC_Object::_yacMetaClassInstanceOf(YAC_Object *_o) {

  955.     return yac_object_yacMetaClassInstanceOf(this, _o);

  956. }

  957. void YAC_Object::_yacNew(YAC_Value *_r) {

  958.     yac_object_yacNew(this, _r);

  959. }

  960. sSI YAC_Object::_yacCanDeserializeClass(YAC_Object *_ifs) {

  961.     return yac_object_yacCanDeserializeClass(this, _ifs);

  962. }

  963. sSI YAC_Object::_yacInstanceOf(YAC_Object *_o) {

  964.     return yac_object_yacInstanceOf(this, _o);

  965. }

  966. #endif

  967. 

  968. #ifdef YAC_OBJECT_YAC

  969. //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 

  970. //~                                                                ~ 

  971. //~ YAC "C" interface for YAC_Object baseclass                     ~ 

  972. //~                                                                ~ 

  973. //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 

  974. void YAC_CALL yac_object_yacClassName(YAC_Object *_o, YAC_Value *_r) {

  975.     YAC_String *s=(YAC_String*)yac_host->yacNewByID(YAC_CLID_STRING);

  976.     s->visit((sChar*)_o->yacClassName());

  977.     YAC_RETS(s, 1);

  978. }

  979. 

  980. void YAC_CALL yac_object_yacNewObject(YAC_Object *_o, YAC_Value *_r) {

  981.     YAC_Object *o=_o->yacNewObject();

  982.     YAC_RETO(o, (o!=0));

  983. }

  984. 

  985. // ---- m e m b e r s

  986. 

  987. sSI YAC_CALL yac_object_yacMemberGetNum(YAC_Object *_o) {

  988.     return (sSI)_o->yacMemberGetNum();

  989. }

  990. 

  991. void YAC_CALL yac_object_yacMemberGetNames(YAC_Object *_o, YAC_Value *_r) {

  992.     YAC_StringArray *a=(YAC_StringArray*)yac_host->yacNewByID(YAC_CLID_STRINGARRAY);

  993.     if(a)

  994.     {

  995.         sSI num=(sSI)_o->yacMemberGetNum();

  996.         if(num&&a->yacArrayAlloc(num, 0,0,0))

  997.         {

  998.             a->num_elements=a->max_elements;

  999.             const char **memberNames=_o->yacMemberGetNames();

  1000.             for(sSI i=0; i<num; i++)

  1001.             {

  1002.                 a->elements[i].visit((sChar*)memberNames[i]);

  1003.             }

  1004.         }

  1005.     }

  1006.     YAC_RETO(a, (a!=0));

  1007. }

  1008. 

  1009. void YAC_CALL yac_object_yacMemberGetTypes(YAC_Object *_o, YAC_Value *_r) {

  1010.     YAC_IntArray *a=(YAC_IntArray*)yac_host->yacNewByID(YAC_CLID_INTARRAY);

  1011.     if(a)

  1012.     {

  1013.         sSI num=(int)_o->yacMemberGetNum();

  1014.         if(num&&a->yacArrayAlloc(num, 0,0,0))

  1015.         {

  1016.             a->num_elements=a->max_elements;

  1017.             const sUI *memberTypes=_o->yacMemberGetTypes();

  1018.             for(sSI i=0; i<num; i++)

  1019.             {

  1020.                 a->elements[i]=(sSI)memberTypes[i];

  1021.             }

  1022.         }

  1023.     }

  1024.     YAC_RETO(a, (a!=0));

  1025. }

  1026. 

  1027. void YAC_CALL yac_object_yacMemberGetObjectTypes(YAC_Object *_o, YAC_Value *_r) {

  1028.     YAC_StringArray *a=(YAC_StringArray*)yac_host->yacNewByID(YAC_CLID_STRINGARRAY);

  1029.     if(a)

  1030.     {

  1031.         sSI num=(int)_o->yacMemberGetNum();

  1032.         if(num&&a->yacArrayAlloc(num, 0,0,0))

  1033.         {

  1034.             a->num_elements=a->max_elements;

  1035.             const char **objectTypes=_o->yacMemberGetObjectTypes();

  1036.             for(sSI i=0; i<num; i++)

  1037.             {

  1038.                 a->elements[i].visit((sChar*)objectTypes[i]);

  1039.             }

  1040.         }

  1041.     }

  1042.     YAC_RETO(a, (a!=0));

  1043. }

  1044. 

  1045. void YAC_CALL yac_object_yacMemberGetOffsets(YAC_Object *_o, YAC_Value *_r) {

  1046.     YAC_IntArray *a=(YAC_IntArray*)yac_host->yacNewByID(YAC_CLID_INTARRAY);

  1047.     if(a)

  1048.     {

  1049.         sSI num=(int)_o->yacMemberGetNum();

  1050.         if(num&&a->yacArrayAlloc(num, 0,0,0))

  1051.         {

  1052.             a->num_elements=a->max_elements;

  1053.             const sU8**memberOffsets = _o->yacMemberGetOffsets();

  1054.             for(sSI i=0; i<num; i++)

  1055.             {

  1056. #ifdef YAC_64

  1057.                a->elements[i]=(sSI) ( (*(sU64*)&memberOffsets[i]) & 0xFFFFFFF );

  1058. #else

  1059.                a->elements[i]=(sSI) ( (*(sU32*)&memberOffsets[i]) & 0xFFFFFFF );

  1060. #endif // YAC_64

  1061.             }

  1062.         }

  1063.     }

  1064.     YAC_RETO(a, (a!=0));

  1065. }

  1066. 

  1067. // ---- m e t h o d s

  1068. 

  1069. sSI YAC_CALL yac_object_yacMethodGetNum(YAC_Object *_o) {

  1070.     return (sSI)_o->yacMethodGetNum();

  1071. }

  1072. 

  1073. void YAC_CALL yac_object_yacMethodGetNames(YAC_Object *_o, YAC_Value *_r) {

  1074.     YAC_StringArray *a=(YAC_StringArray*)yac_host->yacNewByID(YAC_CLID_STRINGARRAY);

  1075.     if(a)

  1076.     {

  1077.         sSI num=(int)_o->yacMethodGetNum();

  1078.         if(num&&a->yacArrayAlloc(num, 0,0,0))

  1079.         {

  1080.             a->num_elements=a->max_elements;

  1081.             const char **methodNames=_o->yacMethodGetNames();

  1082.             for(sSI i=0; i<num; i++)

  1083.             {

  1084.                 a->elements[i].visit((sChar*)methodNames[i]);

  1085.             }

  1086.         }

  1087.     }

  1088.     YAC_RETO(a, (a!=0));

  1089. }

  1090. 

  1091. void YAC_CALL yac_object_yacMethodGetNumParameters(YAC_Object *_o, YAC_Value *_r) {

  1092.     YAC_IntArray *a=(YAC_IntArray*)yac_host->yacNewByID(YAC_CLID_INTARRAY);

  1093.     if(a)

  1094.     {

  1095.         sSI num=(int)_o->yacMethodGetNum();

  1096.         if(num&&a->yacArrayAlloc(num, 0,0,0))

  1097.         {

  1098.             a->num_elements=a->max_elements;

  1099.             const sUI *numParameters=_o->yacMethodGetNumParameters();

  1100.             for(sSI i=0; i<num; i++)

  1101.             {

  1102.                 a->elements[i]=(sSI)numParameters[i];

  1103.             }

  1104.         }

  1105.     }

  1106.     YAC_RETO(a, (a!=0));

  1107. }

  1108. 

  1109. void YAC_CALL yac_object_yacMethodGetParameterTypes(YAC_Object *_o, YAC_Value *_r) {

  1110.     YAC_ValueArray *a=(YAC_ValueArray*)yac_host->yacNewByID(YAC_CLID_VALUEARRAY);

  1111.     if(a)

  1112.     {

  1113.         sSI num=(int)_o->yacMethodGetNum();

  1114.         if(num&&a->yacArrayAlloc(num, 0,0,0))

  1115.         {

  1116.              a->num_elements=a->max_elements;

  1117.              const sUI  *numParameters =_o->yacMethodGetNumParameters();

  1118.              const sUI **allParameterTypes=_o->yacMethodGetParameterTypes();

  1119.              for(sSI i=0; i<num; i++)

  1120.              {

  1121.                  YAC_IntArray *ia=(YAC_IntArray*)yac_host->yacNewByID(YAC_CLID_INTARRAY);

  1122.                  if(ia)

  1123.                  {

  1124.                      a->elements[i].initObject(ia, 1);

  1125.                      sSI inum=(sSI)numParameters[i];

  1126.                      if(inum&&ia->yacArrayAlloc(inum, 0,0,0))

  1127.                      {

  1128.                         ia->num_elements=ia->max_elements;

  1129.                         const sUI *parameterTypes=allParameterTypes[i];

  1130.                         for(sSI j=0; j<inum; j++)

  1131.                         {

  1132.                            ia->elements[j] =(sSI)parameterTypes[j];

  1133.                         }

  1134.                      }

  1135.                  }

  1136.                  else

  1137.                  {

  1138.                      yac_host->printf("[---] yac_object_yacMethodGetParameterTypes: cannot allocate inner array %i/%i.\n", i, num);

  1139.                      yac_host->yacDelete(a);

  1140.                      YAC_RETO(0, 0);

  1141.                      return;

  1142.                  }

  1143.              }

  1144.         }

  1145.     }

  1146.     YAC_RETO(a, (a!=0));

  1147. }

  1148. 

  1149. void YAC_CALL yac_object_yacMethodGetParameterObjectTypes(YAC_Object *_o, YAC_Value *_r) {

  1150.     YAC_ValueArray *a=(YAC_ValueArray*)yac_host->yacNewByID(YAC_CLID_VALUEARRAY);

  1151.     if(a)

  1152.     {

  1153.         sSI num=(int)_o->yacMethodGetNum();

  1154.         if(num&&a->yacArrayAlloc(num, 0,0,0))

  1155.         {

  1156.             a->num_elements=a->max_elements;

  1157.             const sUI    *numParameters =_o->yacMethodGetNumParameters();

  1158.             const char ***allParameterObjectTypes=_o->yacMethodGetParameterObjectTypes();

  1159.             for(sSI i=0; i<num; i++)

  1160.             {

  1161.                 YAC_StringArray *ia=(YAC_StringArray*)yac_host->yacNewByID(YAC_CLID_STRINGARRAY);

  1162.                 if(ia)

  1163.                 {

  1164.                     a->elements[i].initObject(ia, 1);

  1165.                     sSI inum=(sSI)numParameters[i];

  1166.                     if(inum&&ia->yacArrayAlloc(inum, 0,0,0))

  1167.                     {

  1168.                         ia->num_elements=ia->max_elements;

  1169.                         const char **parameterObjectTypes=allParameterObjectTypes[i];

  1170.                         for(sSI j=0; j<inum; j++)

  1171. 			  {

  1172. //               yac_host->printf("ia->elements[%i]=%p (%s) *s=%c\n", j, parameterObjectTypes[j],

  1173. //                                (char *)parameterObjectTypes[j],

  1174. //                                parameterObjectTypes[j]?parameterObjectTypes[j][0]:'?');

  1175.               ia->elements[j].visit((sChar*)parameterObjectTypes[j]);

  1176. 			  } 

  1177.                     }

  1178.                 }

  1179.                 else

  1180.                 {

  1181.                     yac_host->printf("[---] yac_object_yacMethodGetParameterObjectTypes: cannot allocate inner array %i/%i.\n", i, num);

  1182.                     yac_host->yacDelete(a);

  1183.                     YAC_RETO(0, 0);

  1184.                     return;

  1185.                 }

  1186.             }

  1187.         }

  1188.     }

  1189.     YAC_RETO(a, (a!=0));

  1190. }

  1191. 

  1192. void YAC_CALL yac_object_yacMethodGetReturnTypes(YAC_Object *_o, YAC_Value *_r) {

  1193.     YAC_IntArray *a=(YAC_IntArray*)yac_host->yacNewByID(YAC_CLID_INTARRAY);

  1194.     if(a)

  1195.     {

  1196.         sSI num=(int)_o->yacMethodGetNum();

  1197.         if(num&&a->yacArrayAlloc(num, 0,0,0))

  1198.         {

  1199.             a->num_elements=a->max_elements;

  1200.             const sUI *returnTypes=_o->yacMethodGetReturnTypes();

  1201.             for(sSI i=0; i<num; i++)

  1202.                 a->elements[i]=(sSI)returnTypes[i];

  1203.         }

  1204.     }

  1205.     YAC_RETO(a, (a!=0));

  1206. }

  1207. 

  1208. void YAC_CALL yac_object_yacMethodGetReturnObjectTypes(YAC_Object *_o, YAC_Value *_r) {

  1209.     YAC_StringArray *a=(YAC_StringArray*)yac_host->yacNewByID(YAC_CLID_STRINGARRAY);

  1210.     if(a)

  1211.     {

  1212.         sSI num=(int)_o->yacMethodGetNum();

  1213.         if(num&&a->yacArrayAlloc(num, 0,0,0))

  1214.         {

  1215.             a->num_elements=a->max_elements;

  1216.             const char **returnObjectTypes=_o->yacMethodGetReturnObjectTypes();

  1217.             for(sSI i=0; i<num; i++)

  1218.                 a->elements[i].visit((sChar*)returnObjectTypes[i]);

  1219.         }

  1220.     }

  1221.     YAC_RETO(a, (a!=0));

  1222. }

  1223. 

  1224. void YAC_CALL yac_object_yacMethodGetAdr(YAC_Object *_o, YAC_Value *_r) {

  1225.     YAC_IntArray *a=(YAC_IntArray*)yac_host->yacNewByID(YAC_CLID_INTARRAY);

  1226.     if(a)

  1227.     {

  1228.         sSI num=(int)_o->yacMethodGetNum();

  1229.         if(num&&a->yacArrayAlloc(num, 0,0,0))

  1230.         {

  1231.             a->num_elements=a->max_elements;

  1232.             const void **methodAdr=_o->yacMethodGetAdr();

  1233.             for(sSI i=0; i<num; i++)

  1234.                 a->elements[i]=*(sSI*)&methodAdr[i];

  1235.         }

  1236.     }

  1237.     YAC_RETO(a, (a!=0));

  1238. }

  1239. 

  1240. // ---- c o n s t a n t s

  1241. 

  1242. sSI YAC_CALL yac_object_yacConstantGetNum(YAC_Object *_o) {

  1243.     return (sSI)_o->yacConstantGetNum();

  1244. }

  1245. 

  1246. void YAC_CALL yac_object_yacConstantGetNames(YAC_Object *_o, YAC_Value *_r) {

  1247.     YAC_StringArray *a=(YAC_StringArray*)yac_host->yacNewByID(YAC_CLID_STRINGARRAY);

  1248.     if(a)

  1249.     {

  1250.         sSI num=(sSI)_o->yacConstantGetNum();

  1251.         if(num&&a->yacArrayAlloc(num, 0,0,0))

  1252.         {

  1253.             a->num_elements=a->max_elements;

  1254.             const char **constantNames=_o->yacConstantGetNames();

  1255.             for(sSI i=0; i<num; i++)

  1256.                 a->elements[i].visit((sChar*)constantNames[i]);

  1257.         }

  1258.     }

  1259.     YAC_RETO(a, (a!=0));

  1260. }

  1261. 

  1262. void YAC_CALL yac_object_yacConstantGetTypes(YAC_Object *_o, YAC_Value *_r) {

  1263.     YAC_IntArray *a=(YAC_IntArray*)yac_host->yacNewByID(YAC_CLID_INTARRAY);

  1264.     if(a)

  1265.     {

  1266.         sSI num=(int)_o->yacConstantGetNum();

  1267.         if(num&&a->yacArrayAlloc(num, 0,0,0))

  1268.         {

  1269.             a->num_elements=a->max_elements;

  1270.             const sUI *constantTypes=_o->yacConstantGetTypes();

  1271.             for(sSI i=0; i<num; i++)

  1272.                 a->elements[i]=(sSI)constantTypes[i];

  1273.         }

  1274.     }

  1275.     YAC_RETO(a, (a!=0));

  1276. }

  1277. 

  1278. void YAC_CALL yac_object_yacConstantGetValues(YAC_Object *_o, YAC_Value *_r) {

  1279.     YAC_ValueArray *a=(YAC_ValueArray*)yac_host->yacNewByID(YAC_CLID_VALUEARRAY);

  1280.     if(a)

  1281.     {

  1282.         sSI num=(int)_o->yacConstantGetNum();

  1283.         if(num&&a->yacArrayAlloc(num, 0,0,0))

  1284.         {

  1285.             a->num_elements=a->max_elements;

  1286.             const sUI *constantTypes=_o->yacConstantGetTypes();

  1287.             yacmemptr constantValues=_o->yacConstantGetValues();

  1288.             for(sSI i=0; i<num; i++)

  1289.             {

  1290.                 switch(constantTypes[i])

  1291.                 {

  1292.                 case YAC_TYPE_INT:

  1293.                     a->elements[i].initInt(constantValues.si[i]);

  1294.                     break;

  1295.                 case YAC_TYPE_FLOAT:

  1296.                     a->elements[i].initFloat(constantValues.f4[i]); // xxx 32bit float assumed

  1297.                     break;

  1298.                 case YAC_TYPE_OBJECT:

  1299.                 default:

  1300.                     a->elements[i].initObject(0, 0);

  1301.                     yac_host->printf("[---] yac_object_yacConstantGetValues(): constant %i has YAC_TYPE_OBJECT(%i) (not supported).\n", i, constantTypes[i]);

  1302.                     break;

  1303.                 }

  1304.             }

  1305.         }

  1306.     }

  1307.     YAC_RETO(a, (a!=0));

  1308. }

  1309. 

  1310. // ---- o p e r a t o r s

  1311. 

  1312. sSI YAC_CALL yac_object_yacCopy(YAC_Object *_o, YAC_Object *_os) {

  1313.     return _o->yacCopy(_os);

  1314. }

  1315. 

  1316. sSI YAC_CALL yac_object_yacEquals(YAC_Object *_o, YAC_Object *_ro) {

  1317.     return _o->yacEquals(_ro);

  1318. }

  1319. 

  1320. void YAC_CALL yac_object_yacOperator(YAC_Object *_o, sSI _cmd, YAC_Object *_ro, YAC_Value *_r) {

  1321.     _o->yacOperator(_cmd, _ro, _r);

  1322. }

  1323. 

  1324. void YAC_CALL yac_object_yacOperatorInit(YAC_Object *_o, YAC_Object *_ro) {

  1325.    _o->yacOperatorInit(NULL/*_context*/, _ro);

  1326. }

  1327. 

  1328. void YAC_CALL yac_object_yacOperatorAssign(YAC_Object *_o, YAC_Object *_ro) {

  1329.     _o->yacOperatorAssign(_ro);

  1330. }

  1331. 

  1332. void YAC_CALL yac_object_yacOperatorAdd(YAC_Object *_o, YAC_Object *_ro) {

  1333.     _o->yacOperatorAdd(_ro);

  1334. }

  1335. 

  1336. void YAC_CALL yac_object_yacOperatorSub(YAC_Object *_o, YAC_Object *_ro) {

  1337.     _o->yacOperatorSub(_ro);

  1338. }

  1339. 

  1340. void YAC_CALL yac_object_yacOperatorMul(YAC_Object *_o, YAC_Object *_ro) {

  1341.     _o->yacOperatorMul(_ro);

  1342. }

  1343. 

  1344. void YAC_CALL yac_object_yacOperatorDiv(YAC_Object *_o, YAC_Object *_ro) {

  1345.     _o->yacOperatorDiv(_ro);

  1346. }

  1347. 

  1348. void YAC_CALL yac_object_yacOperatorClamp(YAC_Object *_o, YAC_Object *_min, YAC_Object *_max) {

  1349.     _o->yacOperatorClamp(_min, _max);

  1350. }

  1351. 

  1352. void YAC_CALL yac_object_yacOperatorWrap(YAC_Object *_o, YAC_Object *_min, YAC_Object *_max) {

  1353.     _o->yacOperatorWrap(_min, _max);

  1354. }

  1355. 

  1356. sSI YAC_CALL yac_object_yacScanI32(YAC_Object *_o, YAC_Object *_vo) {

  1357.     if(YAC_BCHK(_vo, YAC_CLID_INTEGER)) // xxx should be YAC_CLID_LONG

  1358.     {

  1359.         YAC_Integer *vo=(YAC_Integer*)_vo;

  1360.         return _o->yacScanI(&vo->value);

  1361.     }

  1362.     return 0;

  1363. }

  1364. 

  1365. sSI YAC_CALL yac_object_yacScanI64(YAC_Object *_o, YAC_Object *_vo) {

  1366.    if(YAC_VALID(_vo))

  1367.    {

  1368.       sS64 i64;

  1369.       if(_o->yacScanI64(&i64))

  1370.       {

  1371.          _vo->yacValueOfI64(i64);

  1372.       }

  1373.    }

  1374.     return 0;

  1375. }

  1376. 

  1377. sSI YAC_CALL yac_object_yacScanF32(YAC_Object *_o, YAC_Object *_vo) {

  1378.     if(YAC_BCHK(_vo, YAC_CLID_FLOAT))

  1379.     {

  1380.         YAC_Float *vo=(YAC_Float*)_vo;

  1381.         return _o->yacScanF32(&vo->value);

  1382.     }

  1383.     return 0;

  1384. }

  1385. 

  1386. sSI YAC_CALL yac_object_yacScanF64(YAC_Object *_o, YAC_Object *_vo) {

  1387.    if(YAC_VALID(_vo))

  1388.    {

  1389.       sF64 f64;

  1390.       if(_o->yacScanF64(&f64))

  1391.       {

  1392.          _vo->yacValueOfF64(f64);

  1393.       }

  1394.    }

  1395.    return 0;

  1396. }

  1397. 

  1398. sSI YAC_CALL yac_object_yacToString(const YAC_Object *_o, YAC_Object *_s) {

  1399.     if(YAC_BCHK(_s, YAC_CLID_STRING))

  1400.     {

  1401.         YAC_String *s=(YAC_String*)_s;

  1402.         return _o->yacToString(s);

  1403.     }

  1404.     return 0;

  1405. }

  1406. 

  1407. void YAC_CALL yac_object_yacOperatorI(YAC_Object *_o, sSI _cmd, sSI _i, YAC_Value *_r) {

  1408.     _o->yacOperatorI(_cmd, _i, _r);

  1409. }

  1410. 

  1411. void YAC_CALL yac_object_yacOperatorI64(YAC_Object *_o, sSI _cmd, YAC_Object *_no, YAC_Value *_r) {

  1412.    if(YAC_VALID(_no))

  1413.    {

  1414.       sS64 i64;

  1415.       if(_no->yacScanI64(&i64))

  1416.       {

  1417.          _o->yacOperatorI64(_cmd, i64, _r);

  1418.       }

  1419.    }

  1420. }

  1421. 

  1422. void YAC_CALL yac_object_yacOperatorF32(YAC_Object *_o, sSI _cmd, sF32 _f32, YAC_Value *_r) {

  1423.     _o->yacOperatorF32(_cmd, _f32, _r);

  1424. }

  1425. 

  1426. void YAC_CALL yac_object_yacOperatorF64(YAC_Object *_o, sSI _cmd, YAC_Object *_no, YAC_Value *_r) {

  1427.    if(YAC_VALID(_no))

  1428.    {

  1429.       sF64 f64;

  1430.       if(_no->yacScanF64(&f64))

  1431.       {

  1432.          _o->yacOperatorF64(_cmd, f64, _r);

  1433.       }

  1434.    }

  1435. }

  1436. 

  1437. void YAC_CALL yac_object_yacValueOfI(YAC_Object *_o, sSI _i) {

  1438.     _o->yacValueOfI(_i);

  1439. }

  1440. 

  1441. void YAC_CALL yac_object_yacValueOfI64(YAC_Object *_o, YAC_Object *_no) {

  1442.    if(YAC_VALID(_no))

  1443.    {

  1444.       sS64 i64;

  1445.       if(_no->yacScanI64(&i64))

  1446.       {

  1447.          _o->yacValueOfI64(i64);

  1448.       }

  1449.    }

  1450. }

  1451. 

  1452. void YAC_CALL yac_object_yacValueOfF32(YAC_Object *_o, sF32 _f32) {

  1453.     _o->yacValueOfF32(_f32);

  1454. }

  1455. 

  1456. void YAC_CALL yac_object_yacValueOfF64(YAC_Object *_o, YAC_Object *_no) {

  1457.    if(YAC_VALID(_no))

  1458.    {

  1459.       sF64 f64;

  1460.       if(_no->yacScanF64(&f64))

  1461.       {

  1462.          _o->yacValueOfF64(f64);

  1463.       }

  1464.    }

  1465. }

  1466. 

  1467. sSI YAC_CALL yac_object_yacToParsableString(const YAC_Object *_o, YAC_Object *_s) {

  1468.     if(YAC_BCHK(_s, YAC_CLID_STRING))

  1469.     {

  1470.         YAC_String *s=(YAC_String*)_s;

  1471.         return _o->yacToParsableString(s);

  1472.     }

  1473.     return 0;

  1474. }

  1475. 

  1476. // ---- s t r e a m s

  1477. 

  1478. sSI YAC_CALL yac_object_yacIsStream(YAC_Object *_o) {

  1479.     return _o->yacIsStream();

  1480. }

  1481. 

  1482. void YAC_CALL yac_object_yacStreamClose(YAC_Object *_o) {

  1483.     _o->yacStreamClose();

  1484. }

  1485. 

  1486. sSI YAC_CALL yac_object_yacStreamOpenLocal(YAC_Object *_o, YAC_Object *_name, sSI _access) {

  1487.     if(YAC_BCHK(_name, YAC_CLID_STRING))

  1488.     {

  1489.         return _o->yacStreamOpenLocal((sChar*)((YAC_String*)_name)->chars, _access);

  1490.     }

  1491.     return 0;

  1492. }

  1493. 

  1494. sSI YAC_CALL yac_object_yacStreamOpenLogic(YAC_Object *_o, YAC_Object *_name) {

  1495.     if(YAC_BCHK(_name, YAC_CLID_STRING))

  1496.     {

  1497.         return _o->yacStreamOpenLogic((sChar*)((YAC_String*)_name)->chars);

  1498.     }

  1499.     return 0;

  1500. 

  1501. }

  1502. 

  1503. sSI YAC_CALL yac_object_yacStreamGetByteOrder(YAC_Object *_o) {

  1504.     return _o->yacStreamGetByteOrder();

  1505. }

  1506. 

  1507. void YAC_CALL yac_object_yacStreamSetByteOrder(YAC_Object *_o, sSI _order) {

  1508.     _o->yacStreamSetByteOrder((sUI)_order);

  1509. }

  1510. 

  1511. sSI YAC_CALL yac_object_yacStreamEOF(YAC_Object *_o) {

  1512.     return _o->yacStreamEOF();

  1513. }

  1514. 

  1515. void YAC_CALL yac_object_yacStreamSeek(YAC_Object *_o, sSI _off, sSI _mode) {

  1516.     _o->yacStreamSeek(_off, (sUI)_mode);

  1517. }

  1518. 

  1519. sSI YAC_CALL yac_object_yacStreamGetOffset(YAC_Object *_o) {

  1520.     return _o->yacStreamGetOffset();

  1521. }

  1522. 

  1523. void YAC_CALL yac_object_yacStreamSetOffset(YAC_Object *_o, sSI _off) {

  1524.     _o->yacStreamSetOffset((sUI)_off);

  1525. }

  1526. 

  1527. sSI YAC_CALL yac_object_yacStreamGetSize(YAC_Object *_o) {

  1528.     return _o->yacStreamGetSize();

  1529. }

  1530. 

  1531. sSI YAC_CALL yac_object_yacStreamRead(YAC_Object *_o, YAC_Object *_ret, sSI _num) {

  1532.     if(YAC_BCHK(_ret, YAC_CLID_BUFFER))

  1533.     {

  1534.         YAC_Buffer *ret=(YAC_Buffer*)_ret;

  1535.         if(ret->yacArrayAlloc(_num, 0,0,0))

  1536.         {

  1537.             sUI num=(sUI)_num;

  1538. 	    sUI i=0;

  1539.             for(; (!_o->yacStreamEOF())&&(i<num); i++)

  1540.                 ret->yacStreamWriteI8(_o->yacStreamReadI8());

  1541.             return i;

  1542.         }

  1543.     }

  1544.     return 0;

  1545. }

  1546. 

  1547. sSI YAC_CALL yac_object_yacStreamReadI8(YAC_Object *_o) {

  1548.     return (sSI)_o->yacStreamReadI8();

  1549. }

  1550. 

  1551. sSI YAC_CALL yac_object_yacStreamReadI16(YAC_Object *_o) {

  1552.     return (sSI)_o->yacStreamReadI16();

  1553. }

  1554. 

  1555. sSI YAC_CALL yac_object_yacStreamReadI32(YAC_Object *_o) {

  1556.     return (sSI)_o->yacStreamReadI32();

  1557. }

  1558. 

  1559. void YAC_CALL yac_object_yacStreamReadI64(YAC_Object *_o, YAC_Value *_r) {

  1560.    YAC_Long *l = YAC_New_Long();

  1561.    l->value = _o->yacStreamReadI64();

  1562.    _r->initObject(l, 1);

  1563. }

  1564. 

  1565. sF32 YAC_CALL yac_object_yacStreamReadF32(YAC_Object *_o) {

  1566.     return (sF32)_o->yacStreamReadF32();

  1567. }

  1568. 

  1569. void YAC_CALL yac_object_yacStreamReadF64(YAC_Object *_o, YAC_Value *_r) {

  1570.    YAC_Double *d = YAC_New_Double();

  1571.    d->value = _o->yacStreamReadF64();

  1572.    _r->initObject(d, 1);

  1573. }

  1574. 

  1575. void YAC_CALL yac_object_yacStreamReadObject(YAC_Object *_o, YAC_Object *_p) {

  1576.     _o->yacStreamReadObject(_p);

  1577. }

  1578. 

  1579. sSI YAC_CALL yac_object_yacStreamReadString(YAC_Object *_o, YAC_Object *_s, sSI _maxlen) {

  1580.     if(YAC_BCHK(_s, YAC_CLID_STRING))

  1581.     {

  1582.         return _o->yacStreamReadString((YAC_String*)_s, (sUI)_maxlen);

  1583.     }

  1584.     return 0;

  1585. }

  1586. 

  1587. sSI YAC_CALL yac_object_yacStreamReadBuffer(YAC_Object *_o, YAC_Object *_buffer, sSI _off, sSI _num, sSI _resize) {

  1588.     if(YAC_BCHK(_buffer, YAC_CLID_BUFFER))

  1589.     {

  1590.         return _o->yacStreamReadBuffer((YAC_Buffer*)_buffer, (sUI)_off, (sUI)_num, _resize);

  1591.     }

  1592.     return 0;

  1593. }

  1594. 

  1595. sSI YAC_CALL yac_object_yacStreamReadLine(YAC_Object *_o, YAC_Object *_s, sSI _maxlen) {

  1596.     if(YAC_BCHK(_s, YAC_CLID_STRING))

  1597.     {

  1598.         return _o->yacStreamReadLine((YAC_String*)_s, (sUI)_maxlen);

  1599.     }

  1600.     return 0;

  1601. }

  1602. 

  1603. sSI YAC_CALL yac_object_yacStreamWrite(YAC_Object *_o, YAC_Object *_in, sSI _num) {

  1604.     if(YAC_BCHK(_in, YAC_CLID_BUFFER))

  1605.     {

  1606.         YAC_Buffer *in=(YAC_Buffer*)_in;

  1607.         sUI num=(sUI)_num;

  1608.         if(in->yacStreamGetSize()<num)

  1609.             num=in->yacStreamGetSize();

  1610. 	in->yacStreamSetOffset(0);

  1611. 	sUI i=0;

  1612.         for(; (!_o->yacStreamGetErrorCode())&&(i<num); i++)

  1613.             _o->yacStreamWriteI8( in->yacStreamReadI8() );

  1614.         return i;

  1615.     }

  1616.     return 0;

  1617. }

  1618. 

  1619. void YAC_CALL yac_object_yacStreamWriteI8(YAC_Object *_o, sSI _i) {

  1620.     _o->yacStreamWriteI8((sS8)_i);

  1621. }

  1622. 

  1623. void YAC_CALL yac_object_yacStreamWriteI16(YAC_Object *_o, sSI _i) {

  1624.     _o->yacStreamWriteI16((sS16)_i);

  1625. }

  1626. 

  1627. void YAC_CALL yac_object_yacStreamWriteI32(YAC_Object *_o, sSI _i) {

  1628.     _o->yacStreamWriteI32((sS32)_i);

  1629. }

  1630. 

  1631. void YAC_CALL yac_object_yacStreamWriteI64(YAC_Object *_o, YAC_Object *_no) {

  1632.    if(YAC_VALID(_no))

  1633.    {

  1634.       sS64 i64;

  1635.       if(_no->yacScanI64(&i64))

  1636.       {

  1637.          _o->yacStreamWriteI64(i64);

  1638.       }

  1639.    }

  1640. }

  1641. 

  1642. void YAC_CALL yac_object_yacStreamWriteF32(YAC_Object *_o, sF32 _f) {

  1643.     _o->yacStreamWriteF32((sF32)_f);

  1644. }

  1645. 

  1646. void YAC_CALL yac_object_yacStreamWriteF64(YAC_Object *_o, YAC_Object *_no) {

  1647.    if(YAC_VALID(_no))

  1648.    {

  1649.       sF64 f64;

  1650.       if(_no->yacScanF64(&f64))

  1651.       {

  1652.          _o->yacStreamWriteF64(f64);

  1653.       }

  1654.    }

  1655. }

  1656. 

  1657. void YAC_CALL yac_object_yacStreamWriteObject(YAC_Object *_o, YAC_Object *_p) {

  1658.     _o->yacStreamWriteObject(_p);

  1659. }

  1660. 

  1661. sSI YAC_CALL yac_object_yacStreamWriteString(YAC_Object *_o, YAC_Object *_s, sSI _off, sSI _num) {

  1662.     if(YAC_BCHK(_s, YAC_CLID_STRING))

  1663.     {

  1664.         return _o->yacStreamWriteString((YAC_String*)_s, (sUI)_off, (sUI)_num);

  1665.     }

  1666.     return 0;

  1667. }

  1668. 

  1669. sSI YAC_CALL yac_object_yacStreamWriteBuffer(YAC_Object *_o, YAC_Object *_b, sSI _off, sSI _num) {

  1670.     if(YAC_BCHK(_b, YAC_CLID_BUFFER))

  1671.     {

  1672.         return _o->yacStreamWriteBuffer((YAC_Buffer *)_b, (sUI)_off, (sUI)_num);

  1673.     }

  1674.     return 0;

  1675. }

  1676. 

  1677. sSI YAC_CALL yac_object_yacStreamGetErrorCode(YAC_Object *_o) {

  1678.     return _o->yacStreamGetErrorCode();

  1679. }

  1680. 

  1681. void YAC_CALL yac_object_yacStreamGetErrorStringByCode(YAC_Object *_o, sSI _code, YAC_Value *_r) {

  1682.     _o->yacStreamGetErrorStringByCode(_code, _r);

  1683. }

  1684. 

  1685. // ---- s e r i a l i z a t i o n

  1686. 

  1687. void YAC_CALL yac_object_yacSerializeClassName(YAC_Object *_o, YAC_Object *_ofs) {

  1688.     _o->yacSerializeClassName(_ofs);

  1689. }

  1690. 

  1691. void YAC_CALL yac_object_yacSerialize(YAC_Object *_o, YAC_Object *_ofs, sSI _usetypeinfo) {

  1692.     _o->yacSerialize(_ofs, (sUI)_usetypeinfo);

  1693. }

  1694. 

  1695. sSI YAC_CALL yac_object_yacDeserialize(YAC_Object *_o, YAC_Object *_ifs, sSI _usetypeinfo) {

  1696.     return _o->yacDeserialize(_ifs, (sUI)_usetypeinfo);

  1697. }

  1698. 

  1699. // ---- i t e r a t o r s

  1700. 

  1701. // (( skipped ))

  1702. 

  1703. // ---- a r r a y s   /   h a s h t a b l e s

  1704. 

  1705. void YAC_CALL yac_object_yacArrayNew(YAC_Object *_o, YAC_Value *_r) {

  1706.     YAC_Object *n=_o->yacArrayNew();

  1707.     _r->initObject(n, (n!=0));

  1708. }

  1709. 

  1710. sSI YAC_CALL yac_object_yacArrayAlloc(YAC_Object *_o, sSI _sx, sSI _sy, sSI _type, sSI _ebytesize) {

  1711.     return (sSI)_o->yacArrayAlloc((sUI)_sx, (sUI)_sy, (sUI)_type, (sUI)_ebytesize);

  1712. }

  1713. 

  1714. sSI YAC_CALL yac_object_yacArrayRealloc(YAC_Object *_o, sSI _sx, sSI _sy, sSI _type, sSI _ebytesize) {

  1715.     return (sSI)_o->yacArrayRealloc((sUI)_sx, (sUI)_sy, (sUI)_type, (sUI)_ebytesize);

  1716. }

  1717. 

  1718. sSI YAC_CALL yac_object_yacArrayGetNumElements(YAC_Object *_o) {

  1719.     return (sSI)_o->yacArrayGetNumElements();

  1720. }

  1721. 

  1722. sSI YAC_CALL yac_object_yacArrayGetMaxElements(YAC_Object *_o) {

  1723.     return (sSI)_o->yacArrayGetMaxElements();

  1724. }

  1725. 

  1726. void YAC_CALL yac_object_yacArrayCopySize(YAC_Object *_o, YAC_Object *_p) {

  1727.     _o->yacArrayCopySize(_p);

  1728. }

  1729. 

  1730. void YAC_CALL yac_object_yacArraySet(YAC_Object *_o, sSI _index, YAC_Object *_value) {

  1731.     if(YAC_BCHK(_value, YAC_CLID_VALUE))

  1732.     {

  1733.        _o->yacArraySet(NULL, (sUI)_index, (YAC_ValueObject*)_value);  // xxx TKS_MT use real _context

  1734.     }

  1735. }

  1736. 

  1737. void YAC_CALL yac_object_yacArrayGet(YAC_Object *_o, sSI _index, YAC_Value *_r) {

  1738.     _o->yacArrayGet(NULL, (sUI)_index, _r);  // xxx TKS_MT use real _context

  1739. }

  1740. 

  1741. void YAC_CALL yac_object_yacArrayGetDeref(YAC_Object *_o, sSI _index, YAC_Value *_r) {

  1742.     _o->yacArrayGetDeref(NULL, (sUI)_index, _r);  // xxx TKS_MT use real _context

  1743. }

  1744. 

  1745. sSI YAC_CALL yac_object_yacArrayGetWidth(YAC_Object *_o) {

  1746.     return (sSI)_o->yacArrayGetWidth();

  1747. }

  1748. 

  1749. sSI YAC_CALL yac_object_yacArrayGetHeight(YAC_Object *_o) {

  1750.     return (sSI)_o->yacArrayGetHeight();

  1751. }

  1752. 

  1753. sSI YAC_CALL yac_object_yacArrayGetElementType(YAC_Object *_o) {

  1754.     return (sSI)_o->yacArrayGetElementType();

  1755. }

  1756. 

  1757. sSI YAC_CALL yac_object_yacArrayGetElementByteSize(YAC_Object *_o) {

  1758.     return (sSI)_o->yacArrayGetElementByteSize();

  1759. 

  1760. }

  1761. 

  1762. sSI YAC_CALL yac_object_yacArrayGetStride(YAC_Object *_o) {

  1763.     return (sSI)_o->yacArrayGetStride();

  1764. }

  1765. 

  1766. sSI YAC_CALL yac_object_yacArrayGetPointer(YAC_Object *_o) {

  1767.    /// xxx return Long object on 64bit

  1768.    //void *adr = _o->yacArrayGetPointer();

  1769.    //return *(sSI*)&adr;

  1770.    return 0; // !

  1771. }

  1772. 

  1773. void YAC_CALL yac_object_yacArraySetWidth(YAC_Object *_o, sSI _width) {

  1774.     _o->yacArraySetWidth((sUI)_width);

  1775. }

  1776. 

  1777. void YAC_CALL yac_object_yacArraySetTemplate(YAC_Object *_o, YAC_Object *_template) {

  1778.     _o->yacArraySetTemplate(_template);

  1779. }

  1780. 

  1781. void YAC_CALL yac_object_yacHashSet(YAC_Object *_o, YAC_Object *_key, YAC_Object *_value) {

  1782.     if(YAC_BCHK(_key, YAC_CLID_STRING))

  1783.     if(YAC_BCHK(_value, YAC_CLID_VALUE))

  1784.     {

  1785.        _o->yacHashSet(NULL, (YAC_String*)_key, (YAC_ValueObject*)_value); // xxx TKS_MT use real _context

  1786.     }

  1787. }

  1788. 

  1789. void YAC_CALL yac_object_yacHashGet(YAC_Object *_o, YAC_Object *_key, YAC_Value *_r) {

  1790.    if(YAC_BCHK(_key, YAC_CLID_STRING))

  1791.       _o->yacHashGet(NULL, (YAC_String*)_key, _r);  // xxx TKS_MT use real _context

  1792. }

  1793. 

  1794. void YAC_CALL yac_object_yacHashGetDeref(YAC_Object *_o, YAC_Object *_key, YAC_Value *_r) {

  1795.     if(YAC_BCHK(_key, YAC_CLID_STRING))

  1796.         _o->yacHashGetDeref(NULL, (YAC_String*)_key, _r);  // xxx TKS_MT use real _context

  1797. }

  1798. 

  1799. // ---- s i g n a l s

  1800. 

  1801. void YAC_CALL yac_object_yacGetSignalStringList(YAC_Object *_o, YAC_Object *_s) {

  1802.     if(YAC_BCHK(_s, YAC_CLID_STRING))

  1803.         _o->yacGetSignalStringList((YAC_String*)_s);

  1804. }

  1805. 

  1806. 

  1807. // ---- m e t a c l a s s e s

  1808. 

  1809. void YAC_CALL yac_object_yacMetaClassName(YAC_Object *_o, YAC_Value *_r) {

  1810.     YAC_String *s=YAC_New_String();

  1811.     if(s)

  1812.     {

  1813.         s->visit((char*)_o->yacMetaClassName());

  1814.     }

  1815.     YAC_RETS(s, (s!=0));

  1816. }

  1817. 

  1818. sSI YAC_CALL yac_object_yacMetaClassMemberGetNum(YAC_Object *_o) {

  1819.     return (sSI)_o->yacMetaClassMemberGetNum();

  1820. }

  1821. 

  1822. sSI YAC_CALL yac_object_yacMetaClassMemberGetAccessKeyByIndex(YAC_Object *_o, sSI _index) {

  1823.     return (sSI)_o->yacMetaClassMemberGetAccessKeyByIndex((sUI)_index);

  1824. }

  1825. 

  1826. sSI YAC_CALL yac_object_yacMetaClassMemberGetAccessKeyByName(YAC_Object *_o, YAC_Object *_s) {

  1827.     if(YAC_BCHK(_s, YAC_CLID_STRING))

  1828.         return (sSI)_o->yacMetaClassMemberGetAccessKeyByName((sChar*)((YAC_String*)_s)->chars);

  1829.     return -1;

  1830. }

  1831. 

  1832. sSI YAC_CALL yac_object_yacMetaClassMemberGetType(YAC_Object *_o, sSI _ak) {

  1833.     return (sSI)_o->yacMetaClassMemberGetType((sUI)_ak);

  1834. }

  1835. 

  1836. void YAC_CALL yac_object_yacMetaClassMemberGetName(YAC_Object *_o, sSI _ak, YAC_Value *_r) {

  1837.     YAC_String *s=YAC_New_String();

  1838.     if(s)

  1839.     {

  1840.         s->visit((char*)_o->yacMetaClassMemberGetName((sUI)_ak));

  1841.     }

  1842.     YAC_RETS(s, (s!=0));

  1843. }

  1844. 

  1845. 

  1846. void YAC_CALL yac_object_yacMetaClassMemberSet(YAC_Object *_o, sSI _ak, YAC_Object *_value) {

  1847.     if(YAC_BCHK(_value, YAC_CLID_VALUE))

  1848.     {

  1849.         _o->yacMetaClassMemberSet((sUI)_ak, (YAC_ValueObject*)_value);

  1850.     }

  1851. }

  1852. 

  1853. void YAC_CALL yac_object_yacMetaClassMemberGet(YAC_Object *_o, sSI _ak, YAC_Value *_r) {

  1854.     _o->yacMetaClassMemberGet((sUI)_ak, _r);

  1855. }

  1856. 

  1857. sSI YAC_CALL yac_object_yacMetaClassInstanceOf(YAC_Object *_this, YAC_Object *_o) {

  1858.     return _this->yacMetaClassInstanceOf(_o);

  1859. }

  1860. 

  1861. // ---- n o n - v i r t u a l

  1862. void YAC_CALL yac_object_yacNew(YAC_Object *_o, YAC_Value *_r) {

  1863.     YAC_Object *o=_o->yacNew(NULL/*_context*/);

  1864.     YAC_RETO(o, (o!=0));

  1865. }

  1866. 

  1867. sSI YAC_CALL yac_object_yacCanDeserializeClass(YAC_Object *_o, YAC_Object *_ifs) {

  1868.     return _o->yacCanDeserializeClass(_ifs);

  1869. }

  1870. 

  1871. sSI YAC_CALL yac_object_yacInstanceOf(YAC_Object *_this, YAC_Object *_o) {

  1872.   return _this->yacInstanceOf(_o);

  1873. }

  1874. 

  1875. #endif // YAC_OBJECT_YAC

  1876. 

  1877. 

  1878. #ifndef YAC_CUST_BUFFER

  1879.                  YAC_Buffer::YAC_Buffer                     (void)                                  { }

  1880.                  YAC_Buffer::~YAC_Buffer                    ()                                      { } // never called, see host impl. instead

  1881. void             YAC_Buffer::yacArraySet                    (void *_context, sUI, YAC_Value *)      { }

  1882. void             YAC_Buffer::yacArrayGet                    (void *_context, sUI, YAC_Value *_ret)  {_ret->initVoid();}

  1883. sUI              YAC_Buffer::yacArrayGetWidth               (void)                                  {return size;}

  1884. sUI              YAC_Buffer::yacArrayGetHeight              (void)                                  {return 1;}

  1885. sUI              YAC_Buffer::yacArrayGetElementType         (void)                                  {return 1;}

  1886. sUI              YAC_Buffer::yacArrayGetElementByteSize     (void)                                  {return sizeof(sU8);}

  1887. sUI              YAC_Buffer::yacArrayGetStride              (void)                                  {return 0;}

  1888. void *           YAC_Buffer::yacArrayGetPointer             (void)                                  {return (void*)buffer;}

  1889. #endif

  1890.                  YAC_Iterator::YAC_Iterator                 (void)                                  { }

  1891.                  YAC_Iterator::~YAC_Iterator                ()                                      { }

  1892. void             YAC_VCALL YAC_Iterator::getNext                      (YAC_Value*r)                           {r->initVoid();}

  1893. void             YAC_VCALL YAC_Iterator::begin                        (void)                                  { }

  1894. void             YAC_VCALL YAC_Iterator::end                          (void)                                  { }

  1895. 

  1896. 

  1897. 	// ----

  1898. 	// ----

  1899. 	// ----

  1900. 	// ---- LEVEL (1<<0) interface:

  1901. 	// ----                       ( C/C++ reflection support )

  1902. 	// ----

  1903. 	// ----

  1904.                  YAC_Host::YAC_Host                         (void)                                  { }

  1905.                  YAC_Host::~YAC_Host                        ()                                      { }

  1906. 

  1907. 

  1908. #ifndef YAC_CUST_STRING

  1909. sUI              YAC_strlen                           (const char *_s)            {if(_s){sUI r=0;while(*_s++)r++;return r;}else return 0;}

  1910.                  YAC_String::YAC_String               ()                          {class_ID=YAC_CLID_STRING;buflen=0;bflags=0;length=0;chars=0;key=YAC_LOSTKEY;}

  1911.                  YAC_String::~YAC_String              ()                          {free();}

  1912. void             YAC_String::free                     (void)                      {if(chars){if(bflags&DEL){Dyacfreechars(chars);}chars=0;length=0;buflen=0;bflags=0;key=YAC_LOSTKEY;}}

  1913. void             YAC_String::visit                    (const sChar*_cstring)      {YAC_String::free();chars=(sU8*)_cstring;key=YAC_LOSTKEY;length=YAC_strlen(_cstring)+1;buflen=length;}

  1914. sBool            YAC_String::compare                  (const sChar*e)             {yacmemptr f;f.u1=(sU8*)e;sBool ret=f.any!=0;if(ret&&*f.u1&&length){sU32 _key=1;do{_key++;}while(*++f.u1);ret=_key==length;if(ret){yacmemptr t;t.u1=chars;f.u1=(sU8*)e;sU32 i=0;sU32 l=(length>>RINT_SIZE_SHIFT);for(;i<l&&(*t.ui==*f.ui);t.ui++,f.ui++,i+=SIZEOF_RINT);if(i==length)return!f.u1[-1];ret=*t.u1==*f.u1;if(ret){while(*t.u1==*f.u1)if(!(*t.u1++ && *f.u1++))break;ret=(t.u1-length==chars);}}}return ret;}

  1915. sS32             YAC_String::lastIndexOf              (sChar _c, sUI _start)      {sSI li=-1;if(chars){sUI i=_start;for(;i<length;i++){if(chars[i]==((sChar)_c)){li=i;}}}return li;}

  1916. sS32             YAC_String::indexOf                  (sChar _c, sUI _start)      {if(chars){sUI i=_start;for(;i<length;i++){if(chars[i]==((sChar)_c))return i;}}return -1;}

  1917. #ifdef YAC_BIGSTRING

  1918. sUI              YAC_String::sum                      (void)                      {sU32 ret=0;sU8*c=chars;int i=1;if(NULL != c){for(;*c;c++,i+=128){ret=53*ret+i* *c;}} return ret;} //sU32 i=0;sU32 ret=0;sU8 cc;sU8 lc=0;for(;i<length;i++){cc=chars[i];ret+=((sU32)cc^lc)+(i<<2);lc=cc;}return ret;}

  1919. void             YAC_String::genKey                   (void)                      {key=sum();}

  1920. sUI              YAC_String::getKey                   (void)                      {if(key==YAC_LOSTKEY)genKey();return key;}

  1921. sBool            YAC_String::compare                  (YAC_String*s)              {if(s){if(s->length==length&&s->getKey()==getKey()&&s->chars&&chars){sU32 i=0;for(;i<length&&(s->chars[i]==chars[i]); i++);return i==length;}}return 0;}

  1922. void             YAC_String::fixLength                (void)                      {if(chars&&buflen) { length=0; sChar *s=(sChar*)chars; while(length<buflen&&*s++) length++; length++; /**count EOF**/ } else length=0; key=YAC_LOSTKEY;}

  1923. sBool            YAC_String::alloc                    (sU32 len)                  {if(length!=len){if(chars&&(bflags&DEL)){Dyacfreechars(chars);};buflen=len;length=len;if(len){chars=Dyacallocchars(length);if(chars){sU32 i;for(i=0; i<length; i++)chars[i]=0;}else{buflen=0;bflags=0;length=0;}}else	chars=0;}key=YAC_LOSTKEY;return (chars!=0)?1:0;}

  1924. sBool            YAC_String::copy                     (const sChar *e)            {if(e){sUI j=(sUI)YAC_strlen(e);sBool ret=YAC_String::realloc(j+1);if(ret){sU32 i=0;for(; i<j; i++) *(sChar *)&chars[i]=e[i];chars[i]=0;}return ret;}else return createEmpty();}

  1925. sBool            YAC_String::realloc                  (sU32 len)                  {if((!chars)||buflen<len){return YAC_String::alloc(len);}else{length=len;key=YAC_LOSTKEY;return length!=0;}}

  1926. sBool            YAC_String::createEmpty              (void)                      {sBool ret=YAC_String::alloc(1);if(ret)*chars=0;return ret;}

  1927. sBool            YAC_String::copy                     (YAC_String *_s)            {

  1928.    sBool ret;

  1929.    if( (ret=(_s!=0)) )

  1930.    {

  1931.       if(_s->length)

  1932.       {

  1933.          ret = YAC_String::realloc(_s->length);

  1934.          if(ret)

  1935.          {

  1936.             sU32 i;

  1937.             for(i=0; i<_s->length; i++)

  1938.             {

  1939.                chars[i]=_s->chars[i];

  1940.             }

  1941.             if(_s->bflags & YAC_String::QUOT)

  1942.             {

  1943.                bflags |= YAC_String::QUOT;

  1944.             }

  1945.          }

  1946.       }

  1947.       else 

  1948.       {

  1949.          ret=createEmpty();

  1950.       }

  1951.    }

  1952.    return ret;

  1953. }

  1954. sBool            YAC_String::append                   (YAC_String *o)             {if(o&&o->chars&&o->length){sUI k=o->length+length;if(buflen<k){sU8 *nc=Dyacallocchars(k);sBool ret=(nc!=0) ? 1 : 0;if(ret){sU32 i=0;if(chars){for(;i<length-1; i++)nc[i]=chars[i];if((bflags&DEL)){Dyacfreechars(chars);};length--;}for(k=0; i<(length/*-1*/+o->length); i++, k++)nc[i]=o->chars[k];chars=nc; length=length+o->length;key=YAC_LOSTKEY;}return ret;}else{sU8*d=chars+length-1;sU32 i=0;for(;i< o->length;i++)*d++=o->chars[i];length=k-1;if(length==(sU32)-1){length=length;}key=YAC_LOSTKEY;return 1;}}return 0;}

  1955. sBool            YAC_String::append                   (const char *_s)            {YAC_String s; s.visit(_s); return append(&s);}

  1956. sBool            YAC_String::substring                (YAC_String *s,sUI start, sUI len) {if(len){if(chars&&(start+len)<=length){sU8*a=chars+start;sU32 k=a[len-1]!=0?len+1:len;if(s->realloc(k)){sU32 i=0;for(;i<len;i++)s->chars[i]=*a++;if(k!=len)s->chars[i]=0;return 1;}}else{if(s){s->empty();}}}else{s->empty();}return 0;}

  1957. sBool            YAC_String::empty                    (void)                      {sBool ret=YAC_String::realloc(1);if(ret)*chars=0;return ret;}

  1958. void             YAC_String::printf                   (const char *_fmt, ...)     {va_list va;va_start(va,_fmt);

  1959. #ifdef YAC_VC

  1960. _vsnprintf((char*)chars, buflen, _fmt, va);

  1961. #else

  1962. vsnprintf((char*)chars, buflen, _fmt, va);

  1963. #endif

  1964. va_end(va);fixLength();}

  1965. #endif // YAC_BIGSTRING

  1966. #endif // YAC_CUST_STRING

  1967. 

  1968. #ifndef YAC_CUST_STRING

  1969. #endif

  1970. #ifdef YAC_PRINTF

  1971. void             YAC_Host::printf                     (const char *_fmt, ...)      {

  1972.    if(_fmt)

  1973.    {

  1974. #ifdef YAC_FORCE_NO_PRINTF_TLS

  1975.       static char buf[128*1024];

  1976. #else

  1977.       static YAC_TLS char buf[128*1024]; // TLS increases tks.exe file size by 128*1024 bytes :(

  1978. #endif // YAC_FORCE_NO_PRINTF_TLS

  1979.       va_list va;

  1980.       va_start(va,_fmt);

  1981.       ::vsprintf(buf,/*, sizeof(buf)/sizeof(char),*/_fmt,va);

  1982.       va_end(va);

  1983.       yacPrint(buf);

  1984.    }

  1985. }

  1986. #endif // YAC_PRINTF

  1987. 

  1988. 

  1989. // ----

  1990. // ----

  1991. // ---- Float relative (exponential) epsilon comparison helpers

  1992. // ---- contributed by Carsten Busse <carsten.busse@googlemail.com>

  1993. // ----

  1994. // ----

  1995. #ifdef YAC_EPSILONCOMPARE_REL

  1996. sSI yac_epsilon_flt_units = 10;

  1997. sS64 yac_epsilon_dbl_units = 100;

  1998. 

  1999. sF32 yac_epsilon_flt = YAC_FLT_EPSILON;

  2000. sF64 yac_epsilon_dbl = YAC_DBL_EPSILON;

  2001. 

  2002. #ifdef YAC_GCC

  2003. #include <math.h>

  2004. #define Dfabs(x) fabs(x)

  2005. #define Dfabsf(x) fabsf(x)

  2006. #else

  2007. #define Dfabs(x) ( (x<0.0)?(-x):(x) )

  2008. #define Dfabsf(x) ( (x<0.0f)?(-x):(x) )

  2009. #endif // YAC_GCC

  2010. 

  2011. sSI YAC_CALL yac_fltcmp_rel_fast(sF32 a, sF32 b) {

  2012.    yacmem _a, _b, _c;

  2013.    _a.f4 = a;

  2014.    _b.f4 = b;

  2015.    if( (a == 0.0f) || (b == 0.0f) ) 

  2016.    {

  2017.       _c.f4 = yac_epsilon_flt;

  2018.    }

  2019.    else 

  2020.    {

  2021.       _c.si = yac_epsilon_flt_units;

  2022.    }

  2023.    if(_a.si < 0)

  2024.    {

  2025.       _a.ui = 0x80000000 - _a.ui;

  2026.    }

  2027.    if(_b.si < 0) 

  2028.    {

  2029.       _b.ui = 0x80000000 - _b.ui;

  2030.    }

  2031.    if(abs(_a.si - _b.si) <= _c.si) 

  2032.    {

  2033.       return 0;

  2034.    }

  2035.    else if(a < b) 

  2036.    {

  2037.       return -1;

  2038.    }

  2039.    else 

  2040.    {

  2041.       return 1;

  2042.    }

  2043. }

  2044. 

  2045. sSI YAC_CALL yac_dblcmp_rel_fast(sF64 a, sF64 b) {

  2046.    yacmem64 _a, _b, _c;

  2047.    sS64 res;

  2048.    _a.f8 = a;

  2049.    _b.f8 = b;

  2050.    if( (a == 0.0) || (b == 0.0) )

  2051.    {

  2052.       _c.f8 = yac_epsilon_dbl;

  2053.    }

  2054.    else 

  2055.    {

  2056.       _c.si8 = yac_epsilon_dbl_units;

  2057.    }

  2058.    if(_a.si8 < 0)

  2059.    {

  2060.       _a.ui8 = 0x8000000000000000ull - _a.ui8;

  2061.    }

  2062.    if(_b.si8 < 0)

  2063.    {

  2064.       _b.ui8 = 0x8000000000000000ull - _b.ui8;

  2065.    }

  2066.    res = _a.si8 - _b.si8;

  2067.    if(res < 0) 

  2068.    {

  2069.       res = -res;

  2070.    }

  2071.    if(res <= _c.si8) 

  2072.    {

  2073.       return 0;

  2074.    }

  2075.    else if(a < b)

  2076.    {

  2077.       return -1;

  2078.    }

  2079.    else 

  2080.    {

  2081.       return 1;

  2082.    }

  2083. }

  2084. 

  2085. sSI YAC_CALL yac_fltcmp_rel(sF32 a, sF32 b, sF32 err) {

  2086.    //both 0

  2087.    if( (a == 0.0f) && (b == 0.0f))

  2088.    {

  2089.       return 0;

  2090.    }

  2091.    if(err <= 0.0f)

  2092.    {

  2093.       err = yac_epsilon_flt;

  2094.    }

  2095.    //special cases where one value is 0

  2096.    if(a == 0.0f) 

  2097.    {

  2098.       if(Dfabsf(b) <= err)

  2099.       {

  2100.          return 0;

  2101.       }

  2102.       else if(0.0f < b)

  2103.       {

  2104.          return -1;

  2105.       }

  2106.       else

  2107.       {

  2108.          return 1;

  2109.       }

  2110.    } 

  2111.    else if(b == 0.0f)

  2112.    {

  2113.       if(Dfabsf(a) <= err)

  2114.       {

  2115.          return 0;

  2116.       }

  2117.       else if(a < 0.0f)

  2118.       {

  2119.          return -1;

  2120.       }

  2121.       else 

  2122.       {

  2123.          return 1;

  2124.       }

  2125.    }

  2126.    //both values != 0

  2127.    sF32 amb = a - b;

  2128.    if(Dfabsf(amb) <= (Dfabsf(a)*err))

  2129.    {

  2130.       return 0;

  2131.    }

  2132.    else if(a < b)

  2133.    {

  2134.       return -1;

  2135.    }

  2136.    else 

  2137.    {

  2138.       return 1;

  2139.    }

  2140. }

  2141. 

  2142. sSI YAC_CALL yac_dblcmp_rel(sF64 a, sF64 b, sF64 err) {

  2143.    //both 0

  2144.    if( (a == 0.0) && (b == 0.0) )

  2145.    {

  2146.       return 0;

  2147.    }

  2148.    if(err <= 0.0)

  2149.    {

  2150.       err = yac_epsilon_dbl;

  2151.    }

  2152.    //special cases where one value is 0

  2153.    if(a == 0.0) 

  2154.    {

  2155.       if(Dfabs(b) <= err)

  2156.       {

  2157.          return 0;

  2158.       }

  2159.       else if(0.0 < b)

  2160.       {

  2161.          return -1;

  2162.       }

  2163.       else 

  2164.       {

  2165.          return 1;

  2166.       }

  2167.    } 

  2168.    else if(b == 0.0) 

  2169.    {

  2170.       if(Dfabs(a) <= err)

  2171.       {

  2172.          return 0;

  2173.       }

  2174.       else if(a < 0.0) 

  2175.       {

  2176.          return -1;

  2177.       }

  2178.       else 

  2179.       {

  2180.          return 1;

  2181.       }

  2182.    }

  2183.    //both values != 0

  2184.    sF64 amb = a - b;

  2185.    if(Dfabs(amb) <= (Dfabs(a) * err)) 

  2186.    {

  2187.       return 0;

  2188.    }

  2189.    else if(a < b)

  2190.    {

  2191.       return -1;

  2192.    }

  2193.    else 

  2194.    {

  2195.       return 1;

  2196.    }

  2197. }

  2198. 

  2199. #undef Dfabs

  2200. #undef Dfabsf

  2201. 

  2202. #endif // YAC_EPSILONCOMPARE_REL

  2203. 

  2204. 

  2205. // ----

  2206. // ----

  2207. // ---- PointerArray tool methods

  2208. // ----

  2209. // ----

  2210. #ifndef YAC_CUST_VALUE

  2211. sBool YAC_PointerArray::realloc(sUI _maxElements) {

  2212.    return (sBool) yacArrayRealloc(_maxElements, 0,0,0);

  2213. }

  2214. 

  2215. sBool YAC_PointerArray::add(YAC_Object *_o, sBool _bDelete) {

  2216.    if(num_elements == max_elements)

  2217.    {

  2218.       if(!YAC_PointerArray::realloc( (num_elements+10)+((sUI)(num_elements / 3)) ))

  2219.       {

  2220.          return 0;

  2221.       }

  2222.    }

  2223.    elements[num_elements++].initObject(_o, _bDelete);

  2224.    return 1;

  2225. }

  2226. 

  2227. void YAC_PointerArray::removeIndex(sUI _index) {

  2228.    if(_index < num_elements)

  2229.    {

  2230.       if(num_elements>1)

  2231.       {

  2232.          for(sUI i=((sUI)_index); i<(num_elements-1); i++) 

  2233.          {

  2234.             elements[i].unsetFast();

  2235.             elements[i] = &elements[i+1];

  2236.          }

  2237.          elements[num_elements-1].unset();

  2238.       }

  2239.       else

  2240.       {

  2241.          elements[0].unset();

  2242.       }

  2243.       num_elements--;

  2244.    }

  2245. }

  2246. 

  2247. sSI YAC_PointerArray::indexOfPointer(YAC_Object *_o, sUI _off) {

  2248.    sUI i = (sUI) _off;

  2249.    for(; i<num_elements; i++) 

  2250.    {

  2251.       if( ((void*)elements[i].value.object_val) == ((void*)_o) ) 

  2252.       {

  2253.          // Ok, found object address

  2254.          return (sSI) i;

  2255.       } 

  2256.    }

  2257.    // Failed, address not found

  2258.    return -1;

  2259. }

  2260. 

  2261. #endif // YAC_CUST_VALUE

  2262. 

  2263. 

  2264. #ifdef YAC_GLOBAL_NEWDELETE

  2265. #ifdef YAC_NO_EXPORTS

  2266. sSI yac_global_newdelete_counter = 0; // Only implemented on host side, plugins will call yacTrackNewDelete()

  2267. sSI yac_global_newdelete_numallocs = 0;

  2268. sSI yac_global_newdelete_numfrees = 0;

  2269. #endif // YAC_NO_EXPORTS

  2270. void* operator new(size_t size) {

  2271. #ifdef YAC_NO_EXPORTS

  2272.    yac_global_newdelete_counter += size;

  2273.    yac_global_newdelete_numallocs++;

  2274. #else

  2275.    yac_host->yacNewDeleteModifyCounter(size);

  2276. #endif // YAC_NO_EXPORTS

  2277.    sSI *p = (sSI*) malloc(size+sizeof(sSI));

  2278.    p[0] = size;

  2279.    return &p[1];

  2280. }

  2281. 

  2282. void operator delete(void *_p) {

  2283.    sSI *p = &((sSI*) _p)[-1];

  2284. #ifdef YAC_NO_EXPORTS

  2285.    yac_global_newdelete_counter -= *p;

  2286.    yac_global_newdelete_numfrees++;

  2287. #else

  2288.    yac_host->yacNewDeleteModifyCounter(-*p);

  2289. #endif // YAC_NO_EXPORTS

  2290.    free(p);

  2291. }

  2292. #endif // YAC_GLOBAL_NEWDELETE

  2293. 

  2294. 

  2295. #endif // __YAC_HOST_CPP__