v2/chuck_lang.cpp

   1 /*----------------------------------------------------------------------------
   2     ChucK Concurrent, On-the-fly Audio Programming Language
   3       Compiler and Virtual Machine
   4
   5     Copyright (c) 2004 Ge Wang and Perry R. Cook.  All rights reserved.
   6       http://chuck.cs.princeton.edu/
   7       http://soundlab.cs.princeton.edu/
   8
   9     This program is free software; you can redistribute it and/or modify
  10     it under the terms of the GNU General Public License as published by
  11     the Free Software Foundation; either version 2 of the License, or
  12     (at your option) any later version.
  13
  14     This program is distributed in the hope that it will be useful,
  15     but WITHOUT ANY WARRANTY; without even the implied warranty of
  16     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17     GNU General Public License for more details.
  18
  19     You should have received a copy of the GNU General Public License
  20     along with this program; if not, write to the Free Software
  21     Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
  22     U.S.A.
  23 -----------------------------------------------------------------------------*/
  24
  25 //-----------------------------------------------------------------------------
  26 // name: chuck_lang.cpp
  27 // desc: chuck class library base
  28 //
  29 // authors: Ge Wang (gewang@cs.princeton.edu)
  30 //          Perry R. Cook (prc@cs.princeton.edu)
  31 //    date: spring 2005
  32 //-----------------------------------------------------------------------------
  33 #include "chuck_lang.h"
  34 #include "chuck_type.h"
  35 #include "chuck_instr.h"
  36 #include "chuck_vm.h"
  37 #include "chuck_errmsg.h"
  38 #include "chuck_ugen.h"
  39 #include "midiio_rtmidi.h"
  40 #include "hidio_sdl.h"
  41 #include "util_string.h"
  42
  43 #include <iostream>
  44 #include <iomanip>
  45 #include <sstream>
  46 using namespace std;
  47
  48 // dac tick
  49 CK_DLL_TICK(__ugen_tick) { *out = in; return TRUE; }
  50 // object string offset
  51 static t_CKUINT Object_offset_string = 0;
  52
  53
  54 //-----------------------------------------------------------------------------
  55 // name: init_class_object()
  56 // desc: ...
  57 //-----------------------------------------------------------------------------
  58 t_CKBOOL init_class_object( Chuck_Env * env, Chuck_Type * type )
  59 {
  60     Chuck_DL_Func * func = NULL;
  61
  62     // log
  63     EM_log( CK_LOG_SEVERE, "class 'object'" );
  64
  65     // init as base class
  66     if( !type_engine_import_class_begin( env, type, env->global(), object_ctor, object_dtor ) )
  67         return FALSE;
  68
  69     // add member to hold string
  70     Object_offset_string = type_engine_import_mvar( env, "string", "@string", FALSE );
  71     if( Object_offset_string == CK_INVALID_OFFSET ) goto error;
  72
  73     // add toString()
  74     func = make_new_mfun( "string", "toString", object_toString );
  75     if( !type_engine_import_mfun( env, func ) ) goto error;
  76
  77     // end the class import
  78     type_engine_import_class_end( env );
  79
  80     return TRUE;
  81
  82 error:
  83
  84     // end the class import
  85     type_engine_import_class_end( env );
  86
  87     return FALSE;
  88 }
  89
  90
  91
  92
  93 //-----------------------------------------------------------------------------
  94 // name: init_class_ugen()
  95 // desc: ...
  96 //-----------------------------------------------------------------------------
  97 t_CKBOOL init_class_ugen( Chuck_Env * env, Chuck_Type * type )
  98 {
  99     Chuck_DL_Func * func = NULL;
 100
 101     EM_log( CK_LOG_SEVERE, "class 'ugen'" );
 102
 103     // add ugen info
 104     type->ugen_info = new Chuck_UGen_Info;
 105     type->ugen_info->add_ref();
 106     type->ugen_info->tick = __ugen_tick;
 107     type->ugen_info->num_ins = 1;
 108     type->ugen_info->num_outs = 1;
 109
 110     // init as base class
 111     // TODO: ctor/dtor, ugen's sometimes created internally?
 112     if( !type_engine_import_class_begin( env, type, env->global(), NULL, NULL ) )
 113         return FALSE;
 114
 115     // gain
 116     func = make_new_mfun( "float", "gain", ugen_gain );
 117     func->add_arg( "float", "val" );
 118     if( !type_engine_import_mfun( env, func ) ) goto error;
 119     func = make_new_mfun( "float", "gain", ugen_cget_gain );
 120     if( !type_engine_import_mfun( env, func ) ) goto error;
 121
 122 /*    // next
 123     func = make_new_mfun( "float", "next", ugen_next );
 124     func->add_arg( "float", "val" );
 125     if( !type_engine_import_mfun( env, func ) ) goto error;
 126     func = make_new_mfun( "float", "next", ugen_cget_next );
 127     if( !type_engine_import_mfun( env, func ) ) goto error;
 128 */
 129     // last
 130     func = make_new_mfun( "float", "last", ugen_last );
 131     if( !type_engine_import_mfun( env, func ) ) goto error;
 132
 133     // op
 134     func = make_new_mfun( "int", "op", ugen_op );
 135     func->add_arg( "int", "val" );
 136     if( !type_engine_import_mfun( env, func ) ) goto error;
 137     func = make_new_mfun( "int", "op", ugen_cget_op );
 138     if( !type_engine_import_mfun( env, func ) ) goto error;
 139
 140     // add numChannels
 141     func = make_new_mfun( "int", "channels", ugen_numChannels );
 142     func->add_arg( "int", "num" );
 143     if( !type_engine_import_mfun( env, func ) ) goto error;
 144     func = make_new_mfun( "int", "channels", ugen_cget_numChannels );
 145     if( !type_engine_import_mfun( env, func ) ) goto error;
 146
 147     // add chan
 148     func = make_new_mfun( "UGen", "chan", ugen_chan );
 149     func->add_arg( "int", "num" );
 150     if( !type_engine_import_mfun( env, func ) ) goto error;
 151
 152     // add isConnectedTo
 153     func = make_new_mfun( "int", "isConnectedTo", ugen_connected );
 154     func->add_arg( "UGen", "right" );
 155     if( !type_engine_import_mfun( env, func ) ) goto error;
 156
 157     // end
 158     type_engine_import_class_end( env );
 159
 160     return TRUE;
 161
 162 error:
 163
 164     // end the class import
 165     type_engine_import_class_end( env );
 166
 167     return FALSE;
 168 }
 169
 170
 171
 172
 173 // virtual table offset
 174 static t_CKINT uana_offset_blob = 0;
 175 //-----------------------------------------------------------------------------
 176 // name: init_class_uana()
 177 // desc: ...
 178 //-----------------------------------------------------------------------------
 179 t_CKBOOL init_class_uana( Chuck_Env * env, Chuck_Type * type )
 180 {
 181     Chuck_DL_Func * func = NULL;
 182
 183     EM_log( CK_LOG_SEVERE, "class 'uana'" );
 184
 185     // add uana info
 186     type->ugen_info = new Chuck_UGen_Info;
 187     type->ugen_info->add_ref();
 188     type->ugen_info->tick = __ugen_tick;
 189     type->ugen_info->num_ins = 1;
 190     type->ugen_info->num_outs = 1;
 191
 192     // init as base class, type should already know the parent type
 193     // TODO: ctor/dtor, ugen's sometimes created internally?
 194     if( !type_engine_import_class_begin( env, type, env->global(), uana_ctor, uana_dtor ) )
 195         return FALSE;
 196
 197     // add variables
 198     uana_offset_blob = type_engine_import_mvar( env, "UAnaBlob", "m_blob", FALSE );
 199     if( uana_offset_blob == CK_INVALID_OFFSET ) goto error;
 200
 201     // add upchuck
 202     func = make_new_mfun( "UAnaBlob", "upchuck", uana_upchuck );
 203     if( !type_engine_import_mfun( env, func ) ) goto error;
 204
 205     // add fvals
 206     func = make_new_mfun( "float[]", "fvals", uana_fvals );
 207     if( !type_engine_import_mfun( env, func ) ) goto error;
 208
 209     // add cvals
 210     func = make_new_mfun( "complex[]", "cvals", uana_cvals );
 211     if( !type_engine_import_mfun( env, func ) ) goto error;
 212
 213     // add fval
 214     func = make_new_mfun( "float", "fval", uana_fval );
 215     func->add_arg( "int", "index" );
 216     if( !type_engine_import_mfun( env, func ) ) goto error;
 217
 218     // add cval
 219     func = make_new_mfun( "complex", "cval", uana_cval );
 220     func->add_arg( "int", "index" );
 221     if( !type_engine_import_mfun( env, func ) ) goto error;
 222
 223     // TODO: add nonchuck
 224     // func = make_new_mfun( "void", "nonchuck", uana_nonchuck );
 225     // if( !type_engine_import_mfun( env, func ) ) goto error;
 226
 227     // TODO: add event
 228     // func = make_new_mfun( "Event", "event", uana_event );
 229     // if( !type_engine_import_mfun( env, func ) ) goto error;
 230
 231     // end
 232     type_engine_import_class_end( env );
 233
 234     return TRUE;
 235
 236 error:
 237
 238     // end the class import
 239     type_engine_import_class_end( env );
 240
 241     return FALSE;
 242 }
 243
 244
 245
 246
 247 // virtual table offset
 248 static t_CKINT uanablob_offset_when = 0;
 249 static t_CKINT uanablob_offset_fvals = 0;
 250 static t_CKINT uanablob_offset_cvals = 0;
 251 //-----------------------------------------------------------------------------
 252 // name: init_class_blob()
 253 // desc: ...
 254 //-----------------------------------------------------------------------------
 255 t_CKBOOL init_class_blob( Chuck_Env * env, Chuck_Type * type )
 256 {
 257     Chuck_DL_Func * func = NULL;
 258     Chuck_Value * value = NULL;
 259
 260     // log
 261     EM_log( CK_LOG_SEVERE, "class 'uanablob'" );
 262
 263     // init class
 264     // TODO: ctor/dtor
 265     if( !type_engine_import_class_begin( env, type, env->global(), uanablob_ctor, uanablob_dtor ) )
 266         return FALSE;
 267
 268     // add variables
 269     uanablob_offset_when = type_engine_import_mvar( env, "time", "m_when", FALSE );
 270     if( uanablob_offset_when == CK_INVALID_OFFSET ) goto error;
 271     uanablob_offset_fvals = type_engine_import_mvar( env, "float[]", "m_fvals", FALSE );
 272     if( uanablob_offset_fvals == CK_INVALID_OFFSET ) goto error;
 273     uanablob_offset_cvals = type_engine_import_mvar( env, "complex[]", "m_cvals", FALSE );
 274     if( uanablob_offset_cvals == CK_INVALID_OFFSET ) goto error;
 275
 276     // add when
 277     func = make_new_mfun( "time", "when", uanablob_when );
 278     if( !type_engine_import_mfun( env, func ) ) goto error;
 279
 280     // add fvals
 281     func = make_new_mfun( "float[]", "fvals", uanablob_fvals );
 282     if( !type_engine_import_mfun( env, func ) ) goto error;
 283
 284     // add cvals
 285     func = make_new_mfun( "complex[]", "cvals", uanablob_cvals );
 286     if( !type_engine_import_mfun( env, func ) ) goto error;
 287
 288     // add fval
 289     func = make_new_mfun( "float", "fval", uanablob_fval );
 290     func->add_arg( "int", "index" );
 291     if( !type_engine_import_mfun( env, func ) ) goto error;
 292
 293     // add cval
 294     func = make_new_mfun( "complex", "cval", uanablob_cval );
 295     func->add_arg( "int", "index" );
 296     if( !type_engine_import_mfun( env, func ) ) goto error;
 297
 298     // end class import
 299     type_engine_import_class_end( env );
 300
 301     // done
 302     return TRUE;
 303
 304 error:
 305
 306     // end class import
 307     type_engine_import_class_end( env );
 308
 309     // error
 310     return FALSE;
 311 }
 312
 313
 314
 315
 316 // static t_CKUINT event_offset_data = 0;
 317 //-----------------------------------------------------------------------------
 318 // name: init_class_event()
 319 // desc: ...
 320 //-----------------------------------------------------------------------------
 321 t_CKBOOL init_class_event( Chuck_Env * env, Chuck_Type * type )
 322 {
 323     Chuck_DL_Func * func = NULL;
 324     Chuck_Value * value = NULL;
 325
 326     // log
 327     EM_log( CK_LOG_SEVERE, "class 'event'" );
 328
 329     // init as base class
 330     // TODO: ctor/dtor?
 331     if( !type_engine_import_class_begin( env, type, env->global(), NULL, NULL ) )
 332         return FALSE;
 333
 334     // add signal()
 335     func = make_new_mfun( "void", "signal", event_signal );
 336     if( !type_engine_import_mfun( env, func ) ) goto error;
 337
 338     // add broadcast()
 339     func = make_new_mfun( "void", "broadcast", event_broadcast );
 340     if( !type_engine_import_mfun( env, func ) ) goto error;
 341
 342     // add wait()
 343     func = make_new_mfun( "void", "wait", event_wait );
 344     func->add_arg( "Shred", "me" );
 345     if( !type_engine_import_mfun( env, func ) ) goto error;
 346
 347     // add can_wait()
 348     func = make_new_mfun( "int", "can_wait", event_can_wait );
 349     if( !type_engine_import_mfun( env, func ) ) goto error;
 350
 351     // end the class import
 352     type_engine_import_class_end( env );
 353
 354     // find the offset for can_wait
 355     value = type_engine_find_value( type, "can_wait" );
 356     assert( value != NULL );
 357     assert( value->func_ref != NULL );
 358     // remember it
 359     Chuck_Event::our_can_wait = value->func_ref->vt_index;
 360
 361     return TRUE;
 362
 363 error:
 364
 365     // end the class import
 366     type_engine_import_class_end( env );
 367
 368     return FALSE;
 369 }
 370
 371
 372
 373
 374 static t_CKUINT shred_offset_args = 0;
 375 //-----------------------------------------------------------------------------
 376 // name: init_class_shred()
 377 // desc: ...
 378 //-----------------------------------------------------------------------------
 379 t_CKBOOL init_class_shred( Chuck_Env * env, Chuck_Type * type )
 380 {
 381     // init as base class
 382     Chuck_DL_Func * func = NULL;
 383
 384     // log
 385     EM_log( CK_LOG_SEVERE, "class 'shred'" );
 386
 387     // init as base class
 388     // TODO: ctor/dtor?
 389     if( !type_engine_import_class_begin( env, type, env->global(), NULL, NULL ) )
 390         return FALSE;
 391
 392     // add dtor
 393     // not
 394
 395     // add clone()
 396     func = make_new_mfun( "void", "clone", shred_clone );
 397     if( !type_engine_import_mfun( env, func ) ) goto error;
 398
 399     // add exit()
 400     func = make_new_mfun( "void", "exit", shred_exit );
 401     if( !type_engine_import_mfun( env, func ) ) goto error;
 402
 403     // add id()
 404     func = make_new_mfun( "int", "id", shred_id );
 405     if( !type_engine_import_mfun( env, func ) ) goto error;
 406
 407     // add yield()
 408     func = make_new_mfun( "void", "yield", shred_yield );
 409     if( !type_engine_import_mfun( env, func ) ) goto error;
 410
 411     // add nargs()
 412     // func = make_new_mfun( "int", "numArgs", shred_numArgs );
 413     // if( !type_engine_import_mfun( env, func ) ) goto error;
 414
 415     // add nargs()
 416     func = make_new_mfun( "int", "args", shred_numArgs );
 417     if( !type_engine_import_mfun( env, func ) ) goto error;
 418
 419     // add arg()
 420     // func = make_new_mfun( "string", "getArg", shred_getArg );
 421     // func->add_arg( "int", "index" );
 422     // if( !type_engine_import_mfun( env, func ) ) goto error;
 423
 424     // add arg()
 425     func = make_new_mfun( "string", "arg", shred_getArg );
 426     func->add_arg( "int", "index" );
 427     if( !type_engine_import_mfun( env, func ) ) goto error;
 428
 429     // end the class import
 430     type_engine_import_class_end( env );
 431
 432     return TRUE;
 433
 434 error:
 435
 436     // end the class import
 437     type_engine_import_class_end( env );
 438
 439     return FALSE;
 440 }
 441
 442
 443
 444
 445 static t_CKUINT io_offset_args = 0;
 446 //-----------------------------------------------------------------------------
 447 // name: init_class_io()
 448 // desc: ...
 449 //-----------------------------------------------------------------------------
 450 t_CKBOOL init_class_io( Chuck_Env * env, Chuck_Type * type )
 451 {
 452     // init as base class
 453     Chuck_DL_Func * func = NULL;
 454
 455     // log
 456     EM_log( CK_LOG_SEVERE, "class 'io'" );
 457
 458     // init as base class
 459     // TODO: ctor/dtor?
 460     // TODO: replace dummy with pure function
 461     if( !type_engine_import_class_begin( env, type, env->global(), NULL, NULL ) )
 462         return FALSE;
 463
 464     // add more()
 465     func = make_new_mfun( "int", "more", io_dummy );
 466     if( !type_engine_import_mfun( env, func ) ) goto error;
 467
 468     // add eof()
 469     func = make_new_mfun( "int", "eof", io_dummy );
 470     if( !type_engine_import_mfun( env, func ) ) goto error;
 471
 472     // add good()
 473     func = make_new_mfun( "int", "good", io_dummy );
 474     if( !type_engine_import_mfun( env, func ) ) goto error;
 475
 476     // add good2read()
 477     func = make_new_mfun( "int", "good2read", io_dummy );
 478     if( !type_engine_import_mfun( env, func ) ) goto error;
 479
 480     // add good2write()
 481     func = make_new_mfun( "int", "good2write", io_dummy );
 482     if( !type_engine_import_mfun( env, func ) ) goto error;
 483
 484     // add close()
 485     func = make_new_mfun( "void", "close", io_dummy );
 486     if( !type_engine_import_mfun( env, func ) ) goto error;
 487
 488     // add readInt
 489     func = make_new_mfun( "int", "readInt", io_dummy );
 490     if( !type_engine_import_mfun( env, func ) ) goto error;
 491
 492     // add readFloat
 493     func = make_new_mfun( "float", "readFloat", io_dummy );
 494     if( !type_engine_import_mfun( env, func ) ) goto error;
 495
 496     // add readString
 497     func = make_new_mfun( "string", "readString", io_dummy );
 498     if( !type_engine_import_mfun( env, func ) ) goto error;
 499
 500     // add readLine
 501     func = make_new_mfun( "string", "readLine", io_dummy );
 502     if( !type_engine_import_mfun( env, func ) ) goto error;
 503
 504     // add writeInt
 505     func = make_new_mfun( "void", "writeInt", io_dummy );
 506     func->add_arg( "int", "val" );
 507     if( !type_engine_import_mfun( env, func ) ) goto error;
 508
 509     // add writeFloat
 510     func = make_new_mfun( "void", "writeFloat", io_dummy );
 511     func->add_arg( "float", "val" );
 512     if( !type_engine_import_mfun( env, func ) ) goto error;
 513
 514     // add writeString
 515     func = make_new_mfun( "void", "writeString", io_dummy );
 516     func->add_arg( "string", "val" );
 517     if( !type_engine_import_mfun( env, func ) ) goto error;
 518
 519     // add writeLine
 520     func = make_new_mfun( "string", "writeLine", io_dummy );
 521     func->add_arg( "string", "line" );
 522     if( !type_engine_import_mfun( env, func ) ) goto error;
 523
 524     // add READ
 525     if( !type_engine_import_svar( env, "int", "READ", TRUE, (t_CKUINT)&Chuck_IO::READ ) ) goto error;
 526
 527     // add WRITE
 528     if( !type_engine_import_svar( env, "int", "WRITE", TRUE, (t_CKUINT)&Chuck_IO::WRITE ) ) goto error;
 529
 530     // add APPEND
 531     if( !type_engine_import_svar( env, "int", "APPEND", TRUE, (t_CKUINT)&Chuck_IO::APPEND ) ) goto error;
 532
 533     // add TRUNCATE
 534     if( !type_engine_import_svar( env, "int", "TRUNCATE", TRUE, (t_CKUINT)&Chuck_IO::TRUNCATE) ) goto error;
 535
 536     // add BINARY
 537     if( !type_engine_import_svar( env, "int", "BINARY", TRUE, (t_CKUINT)&Chuck_IO::BINARY ) ) goto error;
 538
 539     // end the class import
 540     type_engine_import_class_end( env );
 541
 542     return TRUE;
 543
 544 error:
 545
 546     // end the class import
 547     type_engine_import_class_end( env );
 548
 549     return FALSE;
 550 }
 551
 552
 553
 554
 555 //-----------------------------------------------------------------------------
 556 // name: init_class_fileio()
 557 // desc: ...
 558 //-----------------------------------------------------------------------------
 559 t_CKBOOL init_class_fileio( Chuck_Env * env, Chuck_Type * type )
 560 {
 561     // init as base class
 562     Chuck_DL_Func * func = NULL;
 563
 564     // log
 565     EM_log( CK_LOG_SEVERE, "class 'fileio'" );
 566
 567     // init as base class
 568     // TODO: ctor/dtor?
 569     // TODO: replace dummy with pure function
 570     if( !type_engine_import_class_begin( env, type, env->global(), fileio_ctor, fileio_dtor ) )
 571         return FALSE;
 572
 573     // add more()
 574     func = make_new_mfun( "int", "more", fileio_more );
 575     if( !type_engine_import_mfun( env, func ) ) goto error;
 576
 577     // add eof()
 578     func = make_new_mfun( "int", "eof", fileio_eof );
 579     if( !type_engine_import_mfun( env, func ) ) goto error;
 580
 581     // add good()
 582     func = make_new_mfun( "int", "good", fileio_good );
 583     if( !type_engine_import_mfun( env, func ) ) goto error;
 584
 585     // add good2read()
 586     func = make_new_mfun( "int", "good2read", fileio_good2read );
 587     if( !type_engine_import_mfun( env, func ) ) goto error;
 588
 589     // add good2write()
 590     func = make_new_mfun( "int", "good2write", fileio_good2write );
 591     if( !type_engine_import_mfun( env, func ) ) goto error;
 592
 593     // add close()
 594     func = make_new_mfun( "void", "close", fileio_close );
 595     if( !type_engine_import_mfun( env, func ) ) goto error;
 596
 597     // add readInt
 598     func = make_new_mfun( "int", "readInt", fileio_readint );
 599     if( !type_engine_import_mfun( env, func ) ) goto error;
 600
 601     // add readFloat
 602     func = make_new_mfun( "float", "readFloat", fileio_readfloat );
 603     if( !type_engine_import_mfun( env, func ) ) goto error;
 604
 605     // add readString
 606     func = make_new_mfun( "string", "readString", fileio_readstring );
 607     if( !type_engine_import_mfun( env, func ) ) goto error;
 608
 609     // add readLine
 610     func = make_new_mfun( "string", "readLine", fileio_readline );
 611     if( !type_engine_import_mfun( env, func ) ) goto error;
 612
 613     // add writeInt
 614     func = make_new_mfun( "void", "writeInt", fileio_writeint );
 615     func->add_arg( "int", "val" );
 616     if( !type_engine_import_mfun( env, func ) ) goto error;
 617
 618     // add writeFloat
 619     func = make_new_mfun( "void", "writeFloat", fileio_writefloat );
 620     func->add_arg( "float", "val" );
 621     if( !type_engine_import_mfun( env, func ) ) goto error;
 622
 623     // add writeString
 624     func = make_new_mfun( "void", "writeString", fileio_writestring );
 625     func->add_arg( "string", "val" );
 626     if( !type_engine_import_mfun( env, func ) ) goto error;
 627
 628     // add writeLine
 629     func = make_new_mfun( "string", "writeLine", fileio_writeline );
 630     func->add_arg( "string", "line" );
 631     if( !type_engine_import_mfun( env, func ) ) goto error;
 632
 633     // end the class import
 634     type_engine_import_class_end( env );
 635
 636     return TRUE;
 637
 638 error:
 639
 640     // end the class import
 641     type_engine_import_class_end( env );
 642
 643     return FALSE;
 644 }
 645
 646
 647
 648
 649 //-----------------------------------------------------------------------------
 650 // name: init_class_string()
 651 // desc: ...
 652 //-----------------------------------------------------------------------------
 653 t_CKBOOL init_class_string( Chuck_Env * env, Chuck_Type * type )
 654 {
 655     // init as base class
 656     Chuck_DL_Func * func = NULL;
 657
 658     // log
 659     EM_log( CK_LOG_SEVERE, "class 'string'" );
 660
 661     // init as base class
 662     // TODO: ctor/dtor
 663     if( !type_engine_import_class_begin( env, type, env->global(), NULL, NULL ) )
 664         return FALSE;
 665
 666     // add length()
 667     func = make_new_mfun( "int", "length", string_length );
 668     if( !type_engine_import_mfun( env, func ) ) goto error;
 669
 670     // add upper()
 671     func = make_new_mfun( "string", "upper", string_upper );
 672     if( !type_engine_import_mfun( env, func ) ) goto error;
 673
 674     // add lower()
 675     func = make_new_mfun( "string", "lower", string_lower );
 676     if( !type_engine_import_mfun( env, func ) ) goto error;
 677
 678     // add ltrim()
 679     func = make_new_mfun( "string", "ltrim", string_ltrim );
 680     if( !type_engine_import_mfun( env, func ) ) goto error;
 681
 682     // add rtrim()
 683     func = make_new_mfun( "string", "rtrim", string_rtrim );
 684     if( !type_engine_import_mfun( env, func ) ) goto error;
 685
 686     // add trim()
 687     func = make_new_mfun( "string", "trim", string_trim );
 688     if( !type_engine_import_mfun( env, func ) ) goto error;
 689
 690     // add toString()
 691     func = make_new_mfun( "string", "toString", string_toString );
 692     if( !type_engine_import_mfun( env, func ) ) goto error;
 693
 694 /*    // add at()
 695     func = make_new_mfun( "int", "ch", string_set_at );
 696     func->add_arg( "int", "index" );
 697     func->add_arg( "int", "val" );
 698     if( !type_engine_import_mfun( env, func ) ) goto error;
 699     func = make_new_mfun( "int", "ch", string_get_at );
 700     func->add_arg( "int", "index" );
 701     if( !type_engine_import_mfun( env, func ) ) goto error;
 702 */
 703     // end the class import
 704     type_engine_import_class_end( env );
 705
 706     return TRUE;
 707
 708 error:
 709
 710     // end the class import
 711     type_engine_import_class_end( env );
 712
 713     return FALSE;
 714 }
 715
 716
 717
 718
 719 //-----------------------------------------------------------------------------
 720 // name: init_class_array()
 721 // desc: ...
 722 //-----------------------------------------------------------------------------
 723 t_CKBOOL init_class_array( Chuck_Env * env, Chuck_Type * type )
 724 {
 725     // init as base class
 726     Chuck_DL_Func * func = NULL;
 727
 728     // log
 729     EM_log( CK_LOG_SEVERE, "class 'array'" );
 730
 731     // init as base class
 732     // TODO: ctor/dtor?
 733     if( !type_engine_import_class_begin( env, type, env->global(), NULL, NULL ) )
 734         return FALSE;
 735
 736     // add clear()
 737     func = make_new_mfun( "void", "clear", array_clear );
 738     if( !type_engine_import_mfun( env, func ) ) goto error;
 739
 740     // add popBack()
 741     func = make_new_mfun( "void", "popBack", array_pop_back );
 742     if( !type_engine_import_mfun( env, func ) ) goto error;
 743
 744     // add size()
 745     func = make_new_mfun( "int", "size", array_get_size );
 746     if( !type_engine_import_mfun( env, func ) ) goto error;
 747     // add size()
 748     func = make_new_mfun( "int", "size", array_set_size );
 749     func->add_arg( "int", "newSize" );
 750     if( !type_engine_import_mfun( env, func ) ) goto error;
 751
 752     // add cap()
 753     func = make_new_mfun( "int", "cap", array_get_capacity_hack );
 754     if( !type_engine_import_mfun( env, func ) ) goto error;
 755     //func = make_new_mfun( "int", "cap", array_set_capacity );
 756     //func->add_arg( "int", "val" );
 757     //if( !type_engine_import_mfun( env, func ) ) goto error;
 758
 759     // add capacity()
 760     func = make_new_mfun( "int", "capacity", array_get_capacity );
 761     if( !type_engine_import_mfun( env, func ) ) goto error;
 762
 763     // add find()
 764     func = make_new_mfun( "int", "find", array_find );
 765     func->add_arg( "string", "key" );
 766     if( !type_engine_import_mfun( env, func ) ) goto error;
 767
 768     // add erase()
 769     func = make_new_mfun( "int", "erase", array_erase );
 770     func->add_arg( "string", "key" );
 771     if( !type_engine_import_mfun( env, func ) ) goto error;
 772
 773     type_engine_import_class_end( env );
 774
 775     return TRUE;
 776
 777 error:
 778
 779     // end the class import
 780     type_engine_import_class_end( env );
 781
 782     return FALSE;
 783 }
 784
 785
 786
 787
 788 // static
 789 static t_CKUINT MidiIn_offset_data = 0;
 790 static t_CKUINT MidiMsg_offset_data1 = 0;
 791 static t_CKUINT MidiMsg_offset_data2 = 0;
 792 static t_CKUINT MidiMsg_offset_data3 = 0;
 793 static t_CKUINT MidiMsg_offset_when = 0;
 794 static t_CKUINT MidiOut_offset_data = 0;
 795
 796 //-----------------------------------------------------------------------------
 797 // name: init_class_Midi()
 798 // desc: ...
 799 //-----------------------------------------------------------------------------
 800 t_CKBOOL init_class_Midi( Chuck_Env * env )
 801 {
 802     Chuck_DL_Func * func = NULL;
 803
 804     // init base class
 805     // TODO: ctor/dtor?
 806     if( !type_engine_import_class_begin( env, "MidiMsg", "Object",
 807                                          env->global(), NULL, NULL ) )
 808         return FALSE;
 809
 810     // add member variable
 811     MidiMsg_offset_data1 = type_engine_import_mvar( env, "int", "data1", FALSE );
 812     if( MidiMsg_offset_data1 == CK_INVALID_OFFSET ) goto error;
 813
 814     // add member variable
 815     MidiMsg_offset_data2 = type_engine_import_mvar( env, "int", "data2", FALSE );
 816     if( MidiMsg_offset_data2 == CK_INVALID_OFFSET ) goto error;
 817
 818     // add member variable
 819     MidiMsg_offset_data3 = type_engine_import_mvar( env, "int", "data3", FALSE );
 820     if( MidiMsg_offset_data3 == CK_INVALID_OFFSET ) goto error;
 821
 822     // add member variable
 823     MidiMsg_offset_when = type_engine_import_mvar( env, "time", "when", FALSE );
 824     if( MidiMsg_offset_when == CK_INVALID_OFFSET ) goto error;
 825
 826     // end the class import
 827     type_engine_import_class_end( env );
 828
 829
 830     // init base class
 831     if( !type_engine_import_class_begin( env, "MidiIn", "Event",
 832                                          env->global(), MidiIn_ctor, MidiIn_dtor ) )
 833         return FALSE;
 834
 835     // add open()
 836     func = make_new_mfun( "int", "open", MidiIn_open );
 837     func->add_arg( "int", "port" );
 838     if( !type_engine_import_mfun( env, func ) ) goto error;
 839
 840     // add good()
 841     func = make_new_mfun( "int", "good", MidiIn_good );
 842     if( !type_engine_import_mfun( env, func ) ) goto error;
 843
 844     // add num()
 845     func = make_new_mfun( "int", "num", MidiIn_num );
 846     if( !type_engine_import_mfun( env, func ) ) goto error;
 847
 848     // add name()
 849     func = make_new_mfun( "string", "name", MidiIn_name );
 850     if( !type_engine_import_mfun( env, func ) ) goto error;
 851
 852     // add printerr()
 853     func = make_new_mfun( "void", "printerr", MidiIn_printerr );
 854     func->add_arg( "int", "print_or_not" );
 855     if( !type_engine_import_mfun( env, func ) ) goto error;
 856
 857     // add recv()
 858     func = make_new_mfun( "int", "recv", MidiIn_recv );
 859     func->add_arg( "MidiMsg", "msg" );
 860     if( !type_engine_import_mfun( env, func ) ) goto error;
 861
 862     // add can_wait()
 863     func = make_new_mfun( "int", "can_wait", MidiIn_can_wait );
 864     if( !type_engine_import_mfun( env, func ) ) goto error;
 865
 866     // add member variable
 867     MidiIn_offset_data = type_engine_import_mvar( env, "int", "@MidiIn_data", FALSE );
 868     if( MidiIn_offset_data == CK_INVALID_OFFSET ) goto error;
 869
 870     // end the class import
 871     type_engine_import_class_end( env );
 872
 873     // init base class
 874     if( !type_engine_import_class_begin( env, "MidiOut", "Object",
 875                                          env->global(), MidiOut_ctor, MidiOut_dtor ) )
 876         return FALSE;
 877
 878     // add open()
 879     func = make_new_mfun( "int", "open", MidiOut_open );
 880     func->add_arg( "int", "port" );
 881     if( !type_engine_import_mfun( env, func ) ) goto error;
 882
 883     // add good()
 884     func = make_new_mfun( "int", "good", MidiOut_good );
 885     if( !type_engine_import_mfun( env, func ) ) goto error;
 886
 887     // add num()
 888     func = make_new_mfun( "int", "num", MidiOut_num );
 889     if( !type_engine_import_mfun( env, func ) ) goto error;
 890
 891     // add name()
 892     func = make_new_mfun( "string", "name", MidiOut_name );
 893     if( !type_engine_import_mfun( env, func ) ) goto error;
 894
 895     // add printerr()
 896     func = make_new_mfun( "void", "printerr", MidiOut_printerr );
 897     func->add_arg( "int", "print_or_not" );
 898     if( !type_engine_import_mfun( env, func ) ) goto error;
 899
 900     // add send()
 901     func = make_new_mfun( "int", "send", MidiOut_send );
 902     func->add_arg( "MidiMsg", "msg" );
 903     if( !type_engine_import_mfun( env, func ) ) goto error;
 904
 905     // add member variable
 906     MidiOut_offset_data = type_engine_import_mvar( env, "int", "@MidiOut_data", FALSE );
 907     if( MidiOut_offset_data == CK_INVALID_OFFSET ) goto error;
 908
 909     // end the class import
 910     type_engine_import_class_end( env );
 911
 912     return TRUE;
 913
 914 error:
 915
 916     // end the class import
 917     type_engine_import_class_end( env );
 918
 919     return FALSE;
 920 }
 921
 922
 923
 924
 925 // static
 926 static t_CKUINT HidIn_offset_data = 0;
 927
 928 static t_CKUINT HidMsg_offset_device_type = 0;
 929 static t_CKUINT HidMsg_offset_device_num = 0;
 930 static t_CKUINT HidMsg_offset_type = 0;
 931 static t_CKUINT HidMsg_offset_which = 0;
 932 static t_CKUINT HidMsg_offset_idata = 0;
 933 static t_CKUINT HidMsg_offset_fdata = 0;
 934 static t_CKUINT HidMsg_offset_when = 0;
 935 static t_CKUINT HidMsg_offset_deltax = 0;
 936 static t_CKUINT HidMsg_offset_deltay = 0;
 937 static t_CKUINT HidMsg_offset_axis_position = 0; // deprecated
 938 static t_CKUINT HidMsg_offset_axis_position2 = 0;
 939 static t_CKUINT HidMsg_offset_scaled_axis_position = 0; // deprecated
 940 static t_CKUINT HidMsg_offset_hat_position = 0;
 941 static t_CKUINT HidMsg_offset_cursorx = 0;
 942 static t_CKUINT HidMsg_offset_cursory = 0;
 943 static t_CKUINT HidMsg_offset_scaledcursorx = 0;
 944 static t_CKUINT HidMsg_offset_scaledcursory = 0;
 945 static t_CKUINT HidMsg_offset_x = 0;
 946 static t_CKUINT HidMsg_offset_y = 0;
 947 static t_CKUINT HidMsg_offset_z = 0;
 948 static t_CKUINT HidMsg_offset_ascii = 0;
 949 static t_CKUINT HidMsg_offset_key = 0;
 950
 951 static t_CKUINT HidOut_offset_data = 0;
 952
 953 //-----------------------------------------------------------------------------
 954 // name: init_class_HID()
 955 // desc: ...
 956 //-----------------------------------------------------------------------------
 957 t_CKBOOL init_class_HID( Chuck_Env * env )
 958 {
 959     Chuck_DL_Func * func = NULL;
 960
 961     // init base class
 962     if( !type_engine_import_class_begin( env, "HidMsg", "Object",
 963                                          env->global(), NULL, NULL ) )
 964         return FALSE;
 965
 966     // add member variable
 967     HidMsg_offset_device_type = type_engine_import_mvar( env, "int", "deviceType", FALSE );
 968     if( HidMsg_offset_device_type == CK_INVALID_OFFSET ) goto error;
 969
 970     // add member variable
 971     HidMsg_offset_device_num = type_engine_import_mvar( env, "int", "deviceNum", FALSE );
 972     if( HidMsg_offset_device_num == CK_INVALID_OFFSET ) goto error;
 973
 974     // add member variable
 975     HidMsg_offset_type = type_engine_import_mvar( env, "int", "type", FALSE );
 976     if( HidMsg_offset_type == CK_INVALID_OFFSET ) goto error;
 977
 978     // add member variable
 979     HidMsg_offset_which = type_engine_import_mvar( env, "int", "which", FALSE );
 980     if( HidMsg_offset_which == CK_INVALID_OFFSET ) goto error;
 981
 982     // add member variable
 983     HidMsg_offset_idata = type_engine_import_mvar( env, "int", "idata", FALSE );
 984     if( HidMsg_offset_idata == CK_INVALID_OFFSET ) goto error;
 985
 986     // add member variable
 987     HidMsg_offset_fdata = type_engine_import_mvar( env, "float", "fdata", FALSE );
 988     if( HidMsg_offset_fdata == CK_INVALID_OFFSET ) goto error;
 989
 990     // add member variable
 991     HidMsg_offset_when = type_engine_import_mvar( env, "time", "when", FALSE );
 992     if( HidMsg_offset_when == CK_INVALID_OFFSET ) goto error;
 993
 994     // add member variable
 995     HidMsg_offset_deltax = type_engine_import_mvar( env, "int", "deltaX", FALSE );
 996     if( HidMsg_offset_deltax == CK_INVALID_OFFSET ) goto error;
 997
 998     // add member variable
 999     HidMsg_offset_deltay = type_engine_import_mvar( env, "int", "deltaY", FALSE );
1000     if( HidMsg_offset_deltay == CK_INVALID_OFFSET ) goto error;
1001
1002     // add member variable
1003     HidMsg_offset_cursorx = type_engine_import_mvar( env, "int", "cursorX", FALSE );
1004     if( HidMsg_offset_cursorx == CK_INVALID_OFFSET ) goto error;
1005
1006     // add member variable
1007     HidMsg_offset_cursory = type_engine_import_mvar( env, "int", "cursorY", FALSE );
1008     if( HidMsg_offset_cursory == CK_INVALID_OFFSET ) goto error;
1009
1010     // add member variable
1011     HidMsg_offset_scaledcursorx = type_engine_import_mvar( env, "float", "scaledCursorX", FALSE );
1012     if( HidMsg_offset_scaledcursorx == CK_INVALID_OFFSET ) goto error;
1013
1014     // add member variable
1015     HidMsg_offset_scaledcursory = type_engine_import_mvar( env, "float", "scaledCursorY", FALSE );
1016     if( HidMsg_offset_scaledcursory == CK_INVALID_OFFSET ) goto error;
1017
1018     // add member variable
1019     HidMsg_offset_x = type_engine_import_mvar( env, "int", "x", FALSE );
1020     if( HidMsg_offset_x == CK_INVALID_OFFSET ) goto error;
1021
1022     // add member variable
1023     HidMsg_offset_y = type_engine_import_mvar( env, "int", "y", FALSE );
1024     if( HidMsg_offset_y == CK_INVALID_OFFSET ) goto error;
1025
1026     // add member variable
1027     HidMsg_offset_z = type_engine_import_mvar( env, "int", "z", FALSE );
1028     if( HidMsg_offset_z == CK_INVALID_OFFSET ) goto error;
1029
1030     // add member variable
1031     HidMsg_offset_axis_position = type_engine_import_mvar( env, "int", "axis_position", FALSE );
1032     if( HidMsg_offset_axis_position == CK_INVALID_OFFSET ) goto error;
1033
1034     // add member variable
1035     HidMsg_offset_axis_position2 = type_engine_import_mvar( env, "float", "axisPosition", FALSE );
1036     if( HidMsg_offset_axis_position2 == CK_INVALID_OFFSET ) goto error;
1037
1038     // add member variable
1039     HidMsg_offset_hat_position = type_engine_import_mvar( env, "int", "hatPosition", FALSE );
1040     if( HidMsg_offset_hat_position == CK_INVALID_OFFSET ) goto error;
1041
1042     // add member variable
1043     HidMsg_offset_ascii = type_engine_import_mvar( env, "int", "ascii", FALSE );
1044     if( HidMsg_offset_ascii == CK_INVALID_OFFSET ) goto error;
1045
1046     // add member variable
1047     HidMsg_offset_key = type_engine_import_mvar( env, "int", "key", FALSE );
1048     if( HidMsg_offset_key == CK_INVALID_OFFSET ) goto error;
1049
1050     // add member variable
1051     HidMsg_offset_scaled_axis_position = type_engine_import_mvar( env, "float", "scaled_axis_position", FALSE );
1052     if( HidMsg_offset_scaled_axis_position == CK_INVALID_OFFSET ) goto error;
1053
1054     // add is_axis_motion()
1055     func = make_new_mfun( "int", "is_axis_motion", HidMsg_is_axis_motion ); // deprecated
1056     if( !type_engine_import_mfun( env, func ) ) goto error;
1057
1058     // add isAxisMotion()
1059     func = make_new_mfun( "int", "isAxisMotion", HidMsg_is_axis_motion );
1060     if( !type_engine_import_mfun( env, func ) ) goto error;
1061
1062     // add is_button_down()
1063     func = make_new_mfun( "int", "is_button_down", HidMsg_is_button_down ); // deprecated
1064     if( !type_engine_import_mfun( env, func ) ) goto error;
1065
1066     // add isButtonDown()
1067     func = make_new_mfun( "int", "isButtonDown", HidMsg_is_button_down );
1068     if( !type_engine_import_mfun( env, func ) ) goto error;
1069
1070     // add is_button_up()
1071     func = make_new_mfun( "int", "is_button_up", HidMsg_is_button_up ); // deprecated
1072     if( !type_engine_import_mfun( env, func ) ) goto error;
1073
1074     // add isButtonUp()
1075     func = make_new_mfun( "int", "isButtonUp", HidMsg_is_button_up );
1076     if( !type_engine_import_mfun( env, func ) ) goto error;
1077
1078     // add is_mouse_motion()
1079     func = make_new_mfun( "int", "is_mouse_motion", HidMsg_is_mouse_motion ); // deprecated
1080     if( !type_engine_import_mfun( env, func ) ) goto error;
1081
1082     // add isMouseMotion()
1083     func = make_new_mfun( "int", "isMouseMotion", HidMsg_is_mouse_motion );
1084     if( !type_engine_import_mfun( env, func ) ) goto error;
1085
1086     // add is_hat_motion()
1087     func = make_new_mfun( "int", "is_hat_motion", HidMsg_is_hat_motion ); // deprecated
1088     if( !type_engine_import_mfun( env, func ) ) goto error;
1089
1090     // add isHatMotion()
1091     func = make_new_mfun( "int", "isHatMotion", HidMsg_is_hat_motion );
1092     if( !type_engine_import_mfun( env, func ) ) goto error;
1093
1094     // add isWheelMotion()
1095     func = make_new_mfun( "int", "isWheelMotion", HidMsg_is_wheel_motion );
1096     if( !type_engine_import_mfun( env, func ) ) goto error;
1097
1098     // end the class import
1099     type_engine_import_class_end( env );
1100
1101
1102     // register deprecate
1103     type_engine_register_deprecate( env, "HidIn", "Hid" );
1104
1105     // init base class Hid (copy of HidIn + constants)
1106     if( !type_engine_import_class_begin( env, "Hid", "Event",
1107                                          env->global(), HidIn_ctor, HidIn_dtor ) )
1108         return FALSE;
1109
1110     // add open()
1111     func = make_new_mfun( "int", "open", HidIn_open );
1112     func->add_arg( "int", "type" );
1113     func->add_arg( "int", "num" );
1114     if( !type_engine_import_mfun( env, func ) ) goto error;
1115
1116     // add openJoystick()
1117     func = make_new_mfun( "int", "openJoystick", HidIn_open_joystick );
1118     func->add_arg( "int", "num" );
1119     if( !type_engine_import_mfun( env, func ) ) goto error;
1120
1121     // add openMouse()
1122     func = make_new_mfun( "int", "openMouse", HidIn_open_mouse );
1123     func->add_arg( "int", "num" );
1124     if( !type_engine_import_mfun( env, func ) ) goto error;
1125
1126     // add openKeyboard()
1127     func = make_new_mfun( "int", "openKeyboard", HidIn_open_keyboard );
1128     func->add_arg( "int", "num" );
1129     if( !type_engine_import_mfun( env, func ) ) goto error;
1130
1131     // add openTiltSensor()
1132     func = make_new_mfun( "int", "openTiltSensor", HidIn_open_tiltsensor );
1133     if( !type_engine_import_mfun( env, func ) ) goto error;
1134
1135     // add good()
1136     func = make_new_mfun( "int", "good", HidIn_good );
1137     if( !type_engine_import_mfun( env, func ) ) goto error;
1138
1139     // add num()
1140     func = make_new_mfun( "int", "num", HidIn_num );
1141     if( !type_engine_import_mfun( env, func ) ) goto error;
1142
1143     // add name()
1144     func = make_new_mfun( "string", "name", HidIn_name );
1145     if( !type_engine_import_mfun( env, func ) ) goto error;
1146
1147     // add printerr()
1148     func = make_new_mfun( "void", "printerr", HidIn_printerr );
1149     func->add_arg( "int", "print_or_not" );
1150     if( !type_engine_import_mfun( env, func ) ) goto error;
1151
1152     // add recv()
1153     func = make_new_mfun( "int", "recv", HidIn_recv );
1154     func->add_arg( "HidMsg", "msg" );
1155     if( !type_engine_import_mfun( env, func ) ) goto error;
1156
1157     // add read()
1158     func = make_new_mfun( "int", "read", HidIn_read );
1159     func->add_arg( "int", "type" );
1160     func->add_arg( "int", "which" );
1161     func->add_arg( "HidMsg", "msg" );
1162     if( !type_engine_import_mfun( env, func ) ) goto error;
1163
1164     // add send()
1165     func = make_new_mfun( "int", "send", HidIn_send );
1166     func->add_arg( "HidMsg", "msg" );
1167     if( !type_engine_import_mfun( env, func ) ) goto error;
1168
1169     // add can_wait()
1170     func = make_new_mfun( "int", "can_wait", HidIn_can_wait );
1171     if( !type_engine_import_mfun( env, func ) ) goto error;
1172
1173     // add readTiltSensor()
1174     func = make_new_sfun( "int[]", "readTiltSensor", HidIn_read_tilt_sensor );
1175     if( !type_engine_import_sfun( env, func ) ) goto error;
1176
1177     // add startCursorTrack()
1178     func = make_new_sfun( "int", "startCursorTrack", HidIn_start_cursor_track );
1179     if( !type_engine_import_sfun( env, func ) ) goto error;
1180
1181     // add stopCursorTrack()
1182     func = make_new_sfun( "int", "stopCursorTrack", HidIn_stop_cursor_track );
1183     if( !type_engine_import_sfun( env, func ) ) goto error;
1184
1185     // add member variable
1186     HidIn_offset_data = type_engine_import_mvar( env, "int", "@Hid_data", FALSE );
1187     if( HidIn_offset_data == CK_INVALID_OFFSET ) goto error;
1188
1189     // add static member variable joystick
1190     if( type_engine_import_svar( env, "int", "JOYSTICK", TRUE,
1191                                  ( t_CKUINT ) &CK_HID_DEV_JOYSTICK ) == FALSE )
1192         goto error;
1193
1194     // add static member variable keyboard
1195     if( type_engine_import_svar( env, "int", "KEYBOARD", TRUE,
1196                                  ( t_CKUINT ) &CK_HID_DEV_KEYBOARD ) == FALSE )
1197         goto error;
1198
1199     // add static member variable mouse
1200     if( type_engine_import_svar( env, "int", "MOUSE", TRUE,
1201                                  ( t_CKUINT ) &CK_HID_DEV_MOUSE ) == FALSE )
1202         goto error;
1203
1204     // add static member variable wii_remote
1205     if( type_engine_import_svar( env, "int", "WII_REMOTE", TRUE,
1206                                  ( t_CKUINT ) &CK_HID_DEV_WIIREMOTE ) == FALSE )
1207         goto error;
1208
1209     // add static member variable wii_remote
1210     if( type_engine_import_svar( env, "int", "TILT_SENSOR", TRUE,
1211                                  ( t_CKUINT ) &CK_HID_DEV_TILTSENSOR ) == FALSE )
1212         goto error;
1213
1214     // add static member variable tablet
1215     if( type_engine_import_svar( env, "int", "TABLET", TRUE,
1216                                  ( t_CKUINT ) &CK_HID_DEV_TABLET ) == FALSE )
1217         goto error;
1218
1219     // add static member variable axisMotion
1220     if( type_engine_import_svar( env, "int", "AXIS_MOTION", TRUE,
1221                                  ( t_CKUINT ) &CK_HID_JOYSTICK_AXIS ) == FALSE )
1222         goto error;
1223
1224     // add static member variable buttonDown
1225     if( type_engine_import_svar( env, "int", "BUTTON_DOWN", TRUE,
1226                                  ( t_CKUINT ) &CK_HID_BUTTON_DOWN ) == FALSE )
1227         goto error;
1228
1229     // add static member variable buttonUp
1230     if( type_engine_import_svar( env, "int", "BUTTON_UP", TRUE,
1231                                  ( t_CKUINT ) &CK_HID_BUTTON_UP ) == FALSE )
1232         goto error;
1233
1234     // add static member variable joystickHat
1235     if( type_engine_import_svar( env, "int", "JOYSTICK_HAT", TRUE,
1236                                  ( t_CKUINT ) &CK_HID_JOYSTICK_HAT ) == FALSE )
1237         goto error;
1238
1239     // add static member variable JOYSTICK_BALL
1240     if( type_engine_import_svar( env, "int", "JOYSTICK_BALL", TRUE,
1241                                  ( t_CKUINT ) &CK_HID_JOYSTICK_BALL ) == FALSE )
1242         goto error;
1243
1244     // add static member variable mouseMotion
1245     if( type_engine_import_svar( env, "int", "MOUSE_MOTION", TRUE,
1246                                  ( t_CKUINT ) &CK_HID_MOUSE_MOTION ) == FALSE )
1247         goto error;
1248
1249     // add static member variable mouseWheel
1250     if( type_engine_import_svar( env, "int", "MOUSE_WHEEL", TRUE,
1251                                  ( t_CKUINT ) &CK_HID_MOUSE_WHEEL ) == FALSE )
1252         goto error;
1253
1254     // add static member variable DEVICE_CONNECTED
1255     if( type_engine_import_svar( env, "int", "DEVICE_CONNECTED", TRUE,
1256                                  ( t_CKUINT ) &CK_HID_DEVICE_CONNECTED ) == FALSE )
1257         goto error;
1258
1259     // add static member variable DEVICE_DISCONNECTED
1260     if( type_engine_import_svar( env, "int", "DEVICE_DISCONNECTED", TRUE,
1261                                  ( t_CKUINT ) &CK_HID_DEVICE_DISCONNECTED ) == FALSE )
1262         goto error;
1263
1264     // add static member variable ACCELEROMETER
1265     if( type_engine_import_svar( env, "int", "ACCELEROMETER", TRUE,
1266                                  ( t_CKUINT ) &CK_HID_ACCELEROMETER ) == FALSE )
1267         goto error;
1268
1269     // add static member variable LED
1270     if( type_engine_import_svar( env, "int", "LED", TRUE,
1271                                  ( t_CKUINT ) &CK_HID_LED ) == FALSE )
1272         goto error;
1273
1274     // add static member variable LED
1275     if( type_engine_import_svar( env, "int", "FORCE_FEEDBACK", TRUE,
1276                                  ( t_CKUINT ) &CK_HID_FORCE_FEEDBACK ) == FALSE )
1277         goto error;
1278
1279     // end the class import
1280     type_engine_import_class_end( env );
1281
1282     /*
1283     // init base class
1284     if( !type_engine_import_class_begin( env, "HidOut", "Object",
1285                                          env->global(), HidOut_ctor ) )
1286         return FALSE;
1287
1288     // add open()
1289     func = make_new_mfun( "int", "open", HidOut_open );
1290     func->add_arg( "int", "port" );
1291     if( !type_engine_import_mfun( env, func ) ) goto error;
1292
1293     // add good()
1294     func = make_new_mfun( "int", "good", HidOut_good );
1295     if( !type_engine_import_mfun( env, func ) ) goto error;
1296
1297     // add num()
1298     func = make_new_mfun( "int", "num", HidOut_num );
1299     if( !type_engine_import_mfun( env, func ) ) goto error;
1300
1301     // add name()
1302     func = make_new_mfun( "string", "name", HidOut_name );
1303     if( !type_engine_import_mfun( env, func ) ) goto error;
1304
1305     // add printerr()
1306     func = make_new_mfun( "void", "printerr", HidOut_printerr );
1307     func->add_arg( "int", "print_or_not" );
1308     if( !type_engine_import_mfun( env, func ) ) goto error;
1309
1310     // add send()
1311     func = make_new_mfun( "int", "send", HidOut_send );
1312     func->add_arg( "HidMsg", "msg" );
1313     if( !type_engine_import_mfun( env, func ) ) goto error;
1314
1315     // add member variable
1316     HidOut_offset_data = type_engine_import_mvar( env, "int", "@HidOut_data", FALSE );
1317     if( HidOut_offset_data == CK_INVALID_OFFSET ) goto error;
1318
1319     // end the class import
1320     type_engine_import_class_end( env );
1321     */
1322     return TRUE;
1323
1324 error:
1325
1326     // end the class import
1327     type_engine_import_class_end( env );
1328
1329     return FALSE;
1330 }
1331
1332
1333
1334
1335 // static
1336 static t_CKUINT MidiRW_offset_data = 0;
1337 static t_CKUINT MidiMsgOut_offset_data = 0;
1338 static t_CKUINT MidiMsgIn_offset_data = 0;
1339 //-----------------------------------------------------------------------------
1340 // name: init_class_MidiRW()
1341 // desc: ...
1342 //-----------------------------------------------------------------------------
1343 t_CKBOOL init_class_MidiRW( Chuck_Env * env )
1344 {
1345     Chuck_DL_Func * func = NULL;
1346
1347     // init base class
1348     if( !type_engine_import_class_begin( env, "MidiRW", "Object",
1349                                          env->global(), MidiRW_ctor, MidiRW_dtor ) )
1350         return FALSE;
1351
1352     // add open()
1353     func = make_new_mfun( "int", "open", MidiRW_open );
1354     func->add_arg( "string", "filename" );
1355     if( !type_engine_import_mfun( env, func ) ) goto error;
1356
1357     // add close()
1358     func = make_new_mfun( "int", "close", MidiRW_close );
1359     if( !type_engine_import_mfun( env, func ) ) goto error;
1360
1361     // add write()
1362     func = make_new_mfun( "int", "write", MidiRW_write );
1363     func->add_arg( "MidiMsg", "msg" );
1364     func->add_arg( "time", "t" );
1365     if( !type_engine_import_mfun( env, func ) ) goto error;
1366
1367     // add read()
1368     func = make_new_mfun( "int", "read", MidiRW_read );
1369     func->add_arg( "MidiMsg", "msg" );
1370     //func->add_arg( "time", "t" );
1371     if( !type_engine_import_mfun( env, func ) ) goto error;
1372
1373     // add member variable
1374     MidiRW_offset_data = type_engine_import_mvar( env, "int", "@MidiRW_data", FALSE );
1375     if( MidiRW_offset_data == CK_INVALID_OFFSET ) goto error;
1376
1377     // end the class import
1378     type_engine_import_class_end( env );
1379
1380         // init base class
1381     if( !type_engine_import_class_begin( env, "MidiMsgOut", "Object",
1382                                          env->global(), MidiMsgOut_ctor, MidiMsgOut_dtor ) )
1383         return FALSE;
1384
1385     // add open()
1386     func = make_new_mfun( "int", "open", MidiMsgOut_open );
1387     func->add_arg( "string", "filename" );
1388     if( !type_engine_import_mfun( env, func ) ) goto error;
1389
1390     // add close()
1391     func = make_new_mfun( "int", "close", MidiMsgOut_close );
1392     if( !type_engine_import_mfun( env, func ) ) goto error;
1393
1394     // add write()
1395     func = make_new_mfun( "int", "write", MidiMsgOut_write );
1396     func->add_arg( "MidiMsg", "msg" );
1397     func->add_arg( "time", "t" );
1398     if( !type_engine_import_mfun( env, func ) ) goto error;
1399
1400     // add member variable
1401     MidiMsgOut_offset_data = type_engine_import_mvar( env, "int", "@MidiMsgOut_data", FALSE );
1402     if( MidiMsgOut_offset_data == CK_INVALID_OFFSET ) goto error;
1403
1404     // end the class import
1405     type_engine_import_class_end( env );
1406
1407         // init base class
1408     if( !type_engine_import_class_begin( env, "MidiMsgIn", "Object",
1409                                          env->global(), MidiMsgIn_ctor, MidiMsgIn_dtor ) )
1410         return FALSE;
1411
1412     // add open()
1413     func = make_new_mfun( "int", "open", MidiMsgIn_open );
1414     func->add_arg( "string", "filename" );
1415     if( !type_engine_import_mfun( env, func ) ) goto error;
1416
1417     // add close()
1418     func = make_new_mfun( "int", "close", MidiMsgIn_close );
1419     if( !type_engine_import_mfun( env, func ) ) goto error;
1420
1421     // add read()
1422     func = make_new_mfun( "int", "read", MidiMsgIn_read );
1423     func->add_arg( "MidiMsg", "msg" );
1424     //func->add_arg( "time", "t" );
1425     if( !type_engine_import_mfun( env, func ) ) goto error;
1426
1427     // add member variable
1428     MidiMsgIn_offset_data = type_engine_import_mvar( env, "int", "@MidiMsgIn_data", FALSE );
1429     if( MidiMsgIn_offset_data == CK_INVALID_OFFSET ) goto error;
1430
1431     // end the class import
1432     type_engine_import_class_end( env );
1433
1434     // initialize
1435     // HidInManager::init();
1436
1437     return TRUE;
1438
1439 error:
1440
1441     // end the class import
1442     type_engine_import_class_end( env );
1443
1444     return FALSE;
1445 }
1446
1447
1448 // Object ctor
1449 CK_DLL_CTOR( object_ctor )
1450 {
1451     // log
1452     // EM_log( CK_LOG_FINEST, "Object constructor..." );
1453
1454     // initialize
1455     OBJ_MEMBER_UINT(SELF, Object_offset_string) = 0;
1456 }
1457
1458
1459 // Object dtor
1460 CK_DLL_DTOR( object_dtor )
1461 {
1462     // log
1463     // EM_log( CK_LOG_FINEST, "Object destructor..." );
1464
1465     // get the string
1466     Chuck_String * str = (Chuck_String *)OBJ_MEMBER_UINT(SELF, Object_offset_string);
1467     // release
1468     SAFE_RELEASE( str );
1469 }
1470
1471
1472 // toString
1473 CK_DLL_MFUN( object_toString )
1474 {
1475     // get the string
1476     Chuck_String * str = (Chuck_String *)OBJ_MEMBER_UINT(SELF, Object_offset_string);
1477     // allocate
1478     if( !str )
1479     {
1480         // new it
1481         str = (Chuck_String *)instantiate_and_initialize_object( &t_string, SHRED );
1482         // check it
1483         if( !str )
1484         {
1485             // TODO: make this exception
1486             fprintf( stderr, "[chuck]: Object.toString() out of memory!\n" );
1487             RETURN->v_object = NULL;
1488             return;
1489         }
1490         // set it
1491         ostringstream strout( ostringstream::out );
1492         // get the type
1493         Chuck_Type * type = SELF->type_ref;
1494         // write
1495         strout.setf( ios::hex, ios::basefield );
1496         strout << ((type != NULL) ? type->c_name() : "[VOID]") << ":" << (t_CKUINT)SELF;
1497         strout.flush();
1498
1499         // done
1500         str->str = strout.str();
1501     }
1502
1503     // set return
1504     RETURN->v_object = str;
1505 }
1506
1507
1508 // ctor
1509 CK_DLL_CTOR( ugen_ctor )
1510 {
1511 }
1512
1513 CK_DLL_DTOR( ugen_dtor )
1514 {
1515     // get as ugen
1516     // Chuck_UGen * ugen = (Chuck_UGen *)SELF;
1517 }
1518
1519 CK_DLL_MFUN( ugen_op )
1520 {
1521     // get as ugen
1522     Chuck_UGen * ugen = (Chuck_UGen *)SELF;
1523     // get arg
1524     t_CKINT op = GET_CK_INT( ARGS );
1525     // set op
1526     ugen->m_op = op;
1527     // set return
1528     RETURN->v_int = ugen->m_op;
1529
1530     // for multiple channels
1531     Chuck_DL_Return ret;
1532     for( t_CKUINT i = 0; i < ugen->m_multi_chan_size; i++ )
1533         ugen_op( ugen->m_multi_chan[i], ARGS, &ret, SHRED );
1534 }
1535
1536 CK_DLL_MFUN( ugen_cget_op )
1537 {
1538     // get as ugen
1539     Chuck_UGen * ugen = (Chuck_UGen *)SELF;
1540     // set return
1541     RETURN->v_int = ugen->m_op;
1542 }
1543
1544 CK_DLL_MFUN( ugen_last )
1545 {
1546     // get as ugen
1547     Chuck_UGen * ugen = (Chuck_UGen *)SELF;
1548     // set return
1549     RETURN->v_float = (t_CKFLOAT)ugen->m_last;
1550 }
1551
1552 CK_DLL_MFUN( ugen_next )
1553 {
1554     // get as ugen
1555     Chuck_UGen * ugen = (Chuck_UGen *)SELF;
1556     // get arg
1557     t_CKFLOAT next = GET_CK_FLOAT( ARGS );
1558     // set op
1559     ugen->m_next = (SAMPLE)next;
1560     ugen->m_use_next = TRUE;
1561     // set return
1562     RETURN->v_float = (t_CKFLOAT)ugen->m_next;
1563
1564     // for multiple channels
1565     Chuck_DL_Return ret;
1566     for( t_CKUINT i = 0; i < ugen->m_multi_chan_size; i++ )
1567         ugen_next( ugen->m_multi_chan[i], ARGS, &ret, SHRED );
1568 }
1569
1570 CK_DLL_MFUN( ugen_cget_next )
1571 {
1572     // get as ugen
1573     Chuck_UGen * ugen = (Chuck_UGen *)SELF;
1574     // set return
1575     RETURN->v_float = ugen->m_use_next ? (t_CKFLOAT)ugen->m_next : 0.0f;
1576 }
1577
1578 CK_DLL_MFUN( ugen_gain )
1579 {
1580     // get as ugen
1581     Chuck_UGen * ugen = (Chuck_UGen *)SELF;
1582     // get arg
1583     t_CKFLOAT gain = GET_CK_FLOAT( ARGS );
1584     // set op
1585     ugen->m_gain = (SAMPLE)gain;
1586     // set return
1587     RETURN->v_float = (t_CKFLOAT)ugen->m_gain;
1588
1589     // for multiple channels
1590     Chuck_DL_Return ret;
1591     for( t_CKUINT i = 0; i < ugen->m_multi_chan_size; i++ )
1592         ugen_gain( ugen->m_multi_chan[i], ARGS, &ret, SHRED );
1593 }
1594
1595 CK_DLL_MFUN( ugen_cget_gain )
1596 {
1597     // get as ugen
1598     Chuck_UGen * ugen = (Chuck_UGen *)SELF;
1599     // set return
1600     RETURN->v_float = (t_CKFLOAT)ugen->m_gain;
1601 }
1602
1603 CK_DLL_CTRL( ugen_numChannels )
1604 {
1605     // get ugen
1606     Chuck_UGen * ugen = (Chuck_UGen *)SELF;
1607     // error
1608     EM_error3( "setting .numChannels is not yet supported (use the command line)..." );
1609 }
1610
1611 CK_DLL_CGET( ugen_cget_numChannels )
1612 {
1613     // get ugen
1614     Chuck_UGen * ugen = (Chuck_UGen *)SELF;
1615     // return
1616     RETURN->v_int = ugen->m_multi_chan_size == 0 ? 1 : ugen->m_multi_chan_size;
1617 }
1618
1619 CK_DLL_CTRL( ugen_chan )
1620 {
1621     // get ugen
1622     Chuck_UGen * ugen = (Chuck_UGen *)SELF;
1623     t_CKINT num = GET_NEXT_INT(ARGS);
1624     // check
1625     if( !ugen->m_multi_chan_size && num == 0 )
1626         RETURN->v_object = ugen;
1627     else if( num >= 0 && num < ugen->m_multi_chan_size )
1628         RETURN->v_object = ugen->m_multi_chan[num];
1629     else
1630         RETURN->v_object = NULL;
1631 }
1632
1633 CK_DLL_CTRL( ugen_connected )
1634 {
1635     // get ugen
1636     Chuck_UGen * ugen = (Chuck_UGen *)SELF;
1637     Chuck_UGen * right = (Chuck_UGen *)GET_NEXT_OBJECT(ARGS);
1638
1639     // sanity
1640     t_CKINT ret = FALSE;
1641     if( !right )
1642     {
1643         ret = FALSE;
1644     }
1645     else
1646     {
1647         ret = right->is_connected_from( ugen );
1648     }
1649
1650     RETURN->v_int = ret;
1651 }
1652
1653
1654 // ctor
1655 CK_DLL_CTOR( uana_ctor )
1656 {
1657     // make an actual blob
1658     Chuck_Object * blob = instantiate_and_initialize_object( &t_uanablob, SHRED );
1659     // TODO: check out of memory
1660     assert( blob != NULL );
1661     // make a blob proxy
1662     Chuck_UAnaBlobProxy * proxy = new Chuck_UAnaBlobProxy( blob );
1663     // remember it
1664     OBJ_MEMBER_INT(SELF, uana_offset_blob) = (t_CKINT)proxy;
1665     // HACK: DANGER: manually call blob's ctor
1666     uanablob_ctor( blob, NULL, NULL );
1667 }
1668
1669 CK_DLL_DTOR( uana_dtor )
1670 {
1671     // TODO: GC should release the blob!
1672 }
1673
1674 CK_DLL_MFUN( uana_upchuck )
1675 {
1676     // get as uana
1677     Chuck_UAna * uana = (Chuck_UAna *)SELF;
1678     // get shred
1679     Chuck_VM_Shred * derhs = SHRED;
1680     // make sure it's not NULL
1681     if( !derhs )
1682     {
1683         EM_error3( "UAna.upchuck() encountered NULL shred; operation aborting!" );
1684         return;
1685     }
1686
1687     // get VM
1688     Chuck_VM * vm = derhs->vm_ref;
1689     // ensure
1690     if( !vm )
1691     {
1692         EM_error3( "UAna.upchuck() encountered NULL VM ref; operation aborting!" );
1693         return;
1694     }
1695
1696     // check if time
1697     if( uana->m_uana_time < vm->shreduler()->now_system )
1698     {
1699         // for multiple channels
1700         Chuck_DL_Return ret;
1701         for( t_CKUINT i = 0; i < uana->m_multi_chan_size; i++ )
1702             uana_upchuck( uana->m_multi_chan[i], ARGS, &ret, SHRED );
1703
1704         // tock it (TODO: order relative to multiple channels?)
1705         uana->system_tock( vm->shreduler()->now_system );
1706     }
1707
1708     // return
1709     RETURN->v_object = uana->blobProxy()->realblob();
1710 }
1711
1712 /* CK_DLL_MFUN( uana_blob )
1713 {
1714     // get as uana
1715     Chuck_UAna * uana = (Chuck_UAna *)SELF;
1716
1717     // TODO: return
1718     RETURN->v_object = NULL;
1719 } */
1720
1721 CK_DLL_MFUN( uana_fvals )
1722 {
1723     // get the fvals array
1724     Chuck_UAnaBlobProxy * blob = (Chuck_UAnaBlobProxy *)OBJ_MEMBER_INT(SELF, uana_offset_blob);
1725     RETURN->v_object = &blob->fvals();
1726 }
1727
1728 CK_DLL_MFUN( uana_cvals )
1729 {
1730     // get the fvals array
1731     Chuck_UAnaBlobProxy * blob = (Chuck_UAnaBlobProxy *)OBJ_MEMBER_INT(SELF, uana_offset_blob);
1732     RETURN->v_object = &blob->cvals();
1733 }
1734
1735 CK_DLL_MFUN( uana_fval )
1736 {
1737     // get index
1738     t_CKINT i = GET_NEXT_INT(ARGS);
1739     // get the fvals array
1740     Chuck_UAnaBlobProxy * blob = (Chuck_UAnaBlobProxy *)OBJ_MEMBER_INT(SELF, uana_offset_blob);
1741     Chuck_Array8 & fvals = blob->fvals();
1742     // check caps
1743     if( i < 0 || fvals.size() <= i ) RETURN->v_float = 0;
1744     else
1745     {
1746         // get
1747         t_CKFLOAT val;
1748         fvals.get( i, &val );
1749         RETURN->v_float = val;
1750     }
1751 }
1752
1753 CK_DLL_MFUN( uana_cval )
1754 {
1755     // get index
1756     t_CKINT i = GET_NEXT_INT(ARGS);
1757     // get the fvals array
1758     Chuck_UAnaBlobProxy * blob = (Chuck_UAnaBlobProxy *)OBJ_MEMBER_INT(SELF, uana_offset_blob);
1759     Chuck_Array16 & cvals = blob->cvals();
1760     // check caps
1761     if( i < 0 || cvals.size() <= i ) RETURN->v_complex.re = RETURN->v_complex.im = 0;
1762     else
1763     {
1764         // get
1765         t_CKCOMPLEX val;
1766         cvals.get( i, &val );
1767         RETURN->v_complex = val;
1768     }
1769 }
1770
1771 // blob proxy implementation
1772 Chuck_UAnaBlobProxy::Chuck_UAnaBlobProxy( Chuck_Object * blob )
1773 {
1774     m_blob = blob;
1775     assert( m_blob != NULL );
1776     // add reference
1777     m_blob->add_ref();
1778 }
1779
1780 Chuck_UAnaBlobProxy::~Chuck_UAnaBlobProxy()
1781 {
1782     // release
1783     SAFE_RELEASE( m_blob );
1784 }
1785
1786 t_CKTIME & Chuck_UAnaBlobProxy::when()
1787 {
1788     // TODO: DANGER: is this actually returning correct reference?!
1789     return OBJ_MEMBER_TIME(m_blob, uanablob_offset_when);
1790 }
1791
1792 Chuck_Array8 & Chuck_UAnaBlobProxy::fvals()
1793 {
1794     // TODO: DANGER: is this actually returning correct reference?!
1795     Chuck_Array8 * arr8 = (Chuck_Array8 *)OBJ_MEMBER_INT(m_blob, uanablob_offset_fvals);
1796     assert( arr8 != NULL );
1797     return *arr8;
1798 }
1799
1800 Chuck_Array16 & Chuck_UAnaBlobProxy::cvals()
1801 {
1802     // TODO: DANGER: is this actually returning correct reference?!
1803     Chuck_Array16 * arr16 = (Chuck_Array16 *)OBJ_MEMBER_INT(m_blob, uanablob_offset_cvals);
1804     assert( arr16 != NULL );
1805     return *arr16;
1806 }
1807
1808 // get proxy
1809 Chuck_UAnaBlobProxy * getBlobProxy( const Chuck_UAna * uana )
1810 {
1811     return (Chuck_UAnaBlobProxy *)OBJ_MEMBER_INT(uana, uana_offset_blob);
1812 }
1813
1814 // ctor
1815 CK_DLL_CTOR( uanablob_ctor )
1816 {
1817     // when
1818     OBJ_MEMBER_TIME(SELF, uanablob_offset_when) = 0;
1819     // fvals
1820     Chuck_Array8 * arr8 = new Chuck_Array8( 8 );
1821     initialize_object( arr8, &t_array );
1822     // TODO: check out of memory
1823     arr8->add_ref();
1824     OBJ_MEMBER_INT(SELF, uanablob_offset_fvals) = (t_CKINT)arr8;
1825     // cvals
1826     Chuck_Array16 * arr16 = new Chuck_Array16( 8 );
1827     initialize_object( arr16, &t_array );
1828     // TODO: check out of memory
1829     arr16->add_ref();
1830     OBJ_MEMBER_INT(SELF, uanablob_offset_cvals) = (t_CKINT)arr16;
1831 }
1832
1833 // dtor
1834 CK_DLL_DTOR( uanablob_dtor )
1835 {
1836     // get array
1837     Chuck_Array8 * arr8 = (Chuck_Array8 *)OBJ_MEMBER_INT(SELF, uanablob_offset_fvals);
1838     // release it
1839     arr8->release();
1840     OBJ_MEMBER_INT(SELF, uanablob_offset_fvals) = 0;
1841
1842     // get array
1843     Chuck_Array16 * arr16 = (Chuck_Array16 *)OBJ_MEMBER_INT(SELF, uanablob_offset_cvals);
1844     // release it
1845     arr16->release();
1846     OBJ_MEMBER_INT(SELF, uanablob_offset_cvals) = 0;
1847
1848     OBJ_MEMBER_TIME(SELF, uanablob_offset_when) = 0;
1849 }
1850
1851 CK_DLL_MFUN( uanablob_when )
1852 {
1853     // set return
1854     RETURN->v_time = OBJ_MEMBER_TIME(SELF, uanablob_offset_when);
1855 }
1856
1857 CK_DLL_MFUN( uanablob_fvals )
1858 {
1859     // set return
1860     RETURN->v_object = (Chuck_Array8 *)OBJ_MEMBER_INT(SELF, uanablob_offset_fvals);
1861 }
1862
1863 CK_DLL_MFUN( uanablob_fval )
1864 {
1865     // get index
1866     t_CKINT i = GET_NEXT_INT(ARGS);
1867     // get the fvals array
1868     Chuck_Array8 * fvals = (Chuck_Array8 *)OBJ_MEMBER_INT(SELF, uanablob_offset_fvals);
1869     // check caps
1870     if( i < 0 || fvals->size() <= i ) RETURN->v_float = 0;
1871     else
1872     {
1873         // get
1874         t_CKFLOAT val;
1875         fvals->get( i, &val );
1876         RETURN->v_float = val;
1877     }
1878 }
1879
1880 CK_DLL_MFUN( uanablob_cval )
1881 {
1882     // get index
1883     t_CKINT i = GET_NEXT_INT(ARGS);
1884     // get the fvals array
1885     Chuck_Array16 * cvals = (Chuck_Array16 *)OBJ_MEMBER_INT(SELF, uanablob_offset_cvals);
1886     // check caps
1887     if( i < 0 || cvals->size() <= i ) RETURN->v_complex.re = RETURN->v_complex.im = 0;
1888     else
1889     {
1890         // get
1891         t_CKCOMPLEX val;
1892         cvals->get( i, &val );
1893         RETURN->v_complex = val;
1894     }
1895 }
1896
1897 CK_DLL_MFUN( uanablob_cvals )
1898 {
1899     // set return
1900     RETURN->v_object = (Chuck_Array16 *)OBJ_MEMBER_INT(SELF, uanablob_offset_cvals);
1901 }
1902
1903 // ctor
1904 CK_DLL_CTOR( event_ctor )
1905 {
1906 //  OBJ_MEMBER_INT(SELF, event_offset_data) = (t_CKUINT)new Data_Event;
1907 //  Chuck_Event * event = (Chuck_Event *)SELF;
1908 }
1909
1910
1911 CK_DLL_DTOR( event_dtor )
1912 {
1913 //  delete (Data_Event *)OBJ_MEMBER_INT(SELF, event_offset_data);
1914 }
1915
1916 CK_DLL_MFUN( event_signal )
1917 {
1918     Chuck_Event * d = (Chuck_Event *)SELF;
1919     d->signal();
1920 }
1921
1922 CK_DLL_MFUN( event_broadcast )
1923 {
1924     Chuck_Event * d = (Chuck_Event *)SELF;
1925     d->broadcast();
1926 }
1927
1928 CK_DLL_MFUN( event_wait )
1929 {
1930     // Chuck_Event * d = (Chuck_Event *)SELF;
1931     assert( FALSE );
1932 }
1933
1934 CK_DLL_MFUN( event_can_wait )
1935 {
1936     RETURN->v_int = TRUE;
1937 }
1938
1939
1940 //-----------------------------------------------------------------------------
1941 // IO API
1942 //-----------------------------------------------------------------------------
1943 CK_DLL_MFUN( io_dummy )
1944 {
1945     EM_error3( "(IO): internal error! inside an abstract function! help!" );
1946     EM_error3( "    note: please hunt down someone (e.g., Ge) to fix this..." );
1947     assert( FALSE );
1948     RETURN->v_int = 0;
1949 }
1950
1951
1952 //-----------------------------------------------------------------------------
1953 // FileIO API
1954 //-----------------------------------------------------------------------------
1955 CK_DLL_CTOR( fileio_ctor )
1956 { }
1957
1958 CK_DLL_DTOR( fileio_dtor )
1959 { }
1960
1961 CK_DLL_MFUN( fileio_open )
1962 { }
1963
1964 CK_DLL_MFUN( fileio_more )
1965 { }
1966
1967 CK_DLL_MFUN( fileio_eof )
1968 { }
1969
1970 CK_DLL_MFUN( fileio_good2read )
1971 { }
1972
1973 CK_DLL_MFUN( fileio_good2write )
1974 { }
1975
1976 CK_DLL_MFUN( fileio_good )
1977 { }
1978
1979 CK_DLL_MFUN( fileio_close )
1980 { }
1981
1982 CK_DLL_MFUN( fileio_readint )
1983 { }
1984
1985 CK_DLL_MFUN( fileio_readfloat )
1986 { }
1987
1988 CK_DLL_MFUN( fileio_readstring )
1989 { }
1990
1991 CK_DLL_MFUN( fileio_readline )
1992 { }
1993
1994 CK_DLL_MFUN( fileio_writeint )
1995 { }
1996
1997 CK_DLL_MFUN( fileio_writefloat )
1998 { }
1999
2000 CK_DLL_MFUN( fileio_writestring )
2001 { }
2002
2003 CK_DLL_MFUN( fileio_writeline )
2004 { }
2005
2006
2007 //-----------------------------------------------------------------------------
2008 // Shred API
2009 //-----------------------------------------------------------------------------
2010
2011 //CK_DLL_CTOR( shred_ctor );
2012 //CK_DLL_DTOR( shred_dtor ); //
2013
2014 CK_DLL_MFUN( shred_exit )
2015 {
2016     Chuck_VM_Shred * derhs = (Chuck_VM_Shred *)SELF;
2017     // end the shred
2018     derhs->is_done = TRUE;
2019     derhs->is_running = FALSE;
2020 // return; // thanks
2021 }
2022
2023 CK_DLL_MFUN( shred_clone )
2024 {
2025 }
2026
2027 CK_DLL_MFUN( shred_id )
2028 {
2029     Chuck_VM_Shred * derhs = (Chuck_VM_Shred *)SELF;
2030     // return the id
2031     RETURN->v_int = derhs->xid;
2032 }
2033
2034 CK_DLL_MFUN( shred_yield )
2035 {
2036     Chuck_VM_Shred * derhs = (Chuck_VM_Shred *)SELF;
2037     Chuck_VM * vm = derhs->vm_ref;
2038
2039     // suspend
2040     derhs->is_running = FALSE;
2041     // reshredule
2042     vm->shreduler()->shredule( derhs, derhs->now );
2043 }
2044
2045 CK_DLL_MFUN( shred_numArgs )
2046 {
2047     Chuck_VM_Shred * derhs = (Chuck_VM_Shred *)SELF;
2048
2049     // get the number of arguments
2050     RETURN->v_int = derhs->args.size();
2051 }
2052
2053 CK_DLL_MFUN( shred_getArg )
2054 {
2055     Chuck_VM_Shred * derhs = (Chuck_VM_Shred *)SELF;
2056
2057     // get index
2058     t_CKINT i = GET_NEXT_INT(ARGS);
2059     // total
2060     t_CKINT num = derhs->args.size();
2061
2062     Chuck_String * str = (Chuck_String *)instantiate_and_initialize_object( &t_string, NULL );
2063     str->str = ( i < num ? derhs->args[i] : "" );
2064     RETURN->v_string = str;
2065 }
2066
2067 CK_DLL_MFUN( string_length )
2068 {
2069     Chuck_String * s = (Chuck_String *)SELF;
2070     RETURN->v_int = s->str.length();
2071 }
2072
2073 CK_DLL_MFUN( string_upper )
2074 {
2075     Chuck_String * s = (Chuck_String *)SELF;
2076     Chuck_String * str = (Chuck_String *)instantiate_and_initialize_object( &t_string, NULL );
2077     str->str = toupper( s->str );
2078     RETURN->v_string = str;
2079 }
2080
2081 CK_DLL_MFUN( string_lower )
2082 {
2083     Chuck_String * s = (Chuck_String *)SELF;
2084     Chuck_String * str = (Chuck_String *)instantiate_and_initialize_object( &t_string, NULL );
2085     str->str = tolower( s->str );
2086     RETURN->v_string = str;
2087 }
2088
2089 CK_DLL_MFUN( string_ltrim )
2090 {
2091     Chuck_String * s = (Chuck_String *)SELF;
2092     Chuck_String * str = (Chuck_String *)instantiate_and_initialize_object( &t_string, NULL );
2093     str->str = ltrim( s->str );
2094     RETURN->v_string = str;
2095 }
2096
2097 CK_DLL_MFUN( string_rtrim )
2098 {
2099     Chuck_String * s = (Chuck_String *)SELF;
2100     Chuck_String * str = (Chuck_String *)instantiate_and_initialize_object( &t_string, NULL );
2101     str->str = rtrim( s->str );
2102     RETURN->v_string = str;
2103 }
2104
2105 CK_DLL_MFUN( string_trim )
2106 {
2107     Chuck_String * s = (Chuck_String *)SELF;
2108     Chuck_String * str = (Chuck_String *)instantiate_and_initialize_object( &t_string, NULL );
2109     str->str = trim( s->str );
2110     RETURN->v_string = str;
2111 }
2112
2113 CK_DLL_MFUN( string_toString )
2114 {
2115     Chuck_String * s = (Chuck_String *)SELF;
2116     RETURN->v_string = s;
2117 }
2118
2119 /*
2120 CK_DLL_MFUN( string_set_at )
2121 {
2122     Chuck_String * s = (Chuck_String *)SELF;
2123     t_CKINT c = GET_CK_INT(
2124     RETURN->v_int = s->str.length();
2125 }
2126
2127 CK_DLL_MFUN( string_get_at )
2128 {
2129     Chuck_String * s = (Chuck_String *)SELF;
2130     RETURN->v_int = s->str.length();
2131 }
2132 */
2133
2134
2135 // array.size()
2136 CK_DLL_MFUN( array_get_size )
2137 {
2138     Chuck_Array * array = (Chuck_Array *)SELF;
2139     RETURN->v_int = array->size();
2140 }
2141
2142 // array.size()
2143 CK_DLL_MFUN( array_set_size )
2144 {
2145     Chuck_Array * array = (Chuck_Array *)SELF;
2146     t_CKINT size = GET_NEXT_INT(ARGS);
2147     if( size < 0 )
2148     {
2149         // TODO: make this exception
2150         fprintf( stderr, "[chuck](via array): attempt to set negative array size!\n" );
2151         RETURN->v_int = 0;
2152     }
2153     else
2154     {
2155         array->set_size( size );
2156         RETURN->v_int = array->size();
2157     }
2158     RETURN->v_int = array->size();
2159 }
2160
2161 // array.clear()
2162 CK_DLL_MFUN( array_clear )
2163 {
2164     Chuck_Array * array = (Chuck_Array *)SELF;
2165     array->clear();
2166 }
2167
2168 // array.cap()
2169 CK_DLL_MFUN( array_set_capacity )
2170 {
2171     Chuck_Array * array = (Chuck_Array *)SELF;
2172     t_CKINT capacity = GET_NEXT_INT(ARGS);
2173     if( capacity < 0 )
2174     {
2175         // TODO: make this exception
2176         fprintf( stderr, "[chuck](via array): attempt to set negative array capacity!\n" );
2177         RETURN->v_int = 0;
2178     }
2179     else
2180     {
2181         array->set_capacity( capacity );
2182         RETURN->v_int = array->capacity();
2183     }
2184 }
2185
2186 // array.cap()
2187 CK_DLL_MFUN( array_get_capacity_hack )
2188 {
2189     Chuck_Array * array = (Chuck_Array *)SELF;
2190     RETURN->v_int = array->size();
2191 }
2192
2193 // array.capacity()
2194 CK_DLL_MFUN( array_get_capacity )
2195 {
2196     Chuck_Array * array = (Chuck_Array *)SELF;
2197     RETURN->v_int = array->capacity();
2198 }
2199
2200 // array.find()
2201 CK_DLL_MFUN( array_find )
2202 {
2203     Chuck_Array * array = (Chuck_Array *)SELF;
2204     Chuck_String * name = GET_NEXT_STRING( ARGS );
2205     RETURN->v_int = array->find( name->str );
2206 }
2207
2208 // array.erase()
2209 CK_DLL_MFUN( array_erase )
2210 {
2211     Chuck_Array * array = (Chuck_Array *)SELF;
2212     Chuck_String * name = GET_NEXT_STRING( ARGS );
2213     RETURN->v_int = array->erase( name->str );
2214 }
2215
2216 // array.push_back()
2217 CK_DLL_MFUN( array_push_back )
2218 {
2219     Chuck_Array * array = (Chuck_Array *)SELF;
2220     // TODO: make this safe!
2221     if( array->data_type_size() == CHUCK_ARRAY4_DATASIZE )
2222         RETURN->v_int = ((Chuck_Array4 *)array)->push_back( GET_NEXT_UINT( ARGS ) );
2223     else if( array->data_type_size() == CHUCK_ARRAY8_DATASIZE )
2224         RETURN->v_int = ((Chuck_Array8 *)array)->push_back( GET_NEXT_FLOAT( ARGS ) );
2225     else if( array->data_type_size() == CHUCK_ARRAY16_DATASIZE )
2226         RETURN->v_int = ((Chuck_Array16 *)array)->push_back( GET_NEXT_COMPLEX( ARGS ) );
2227     else
2228         assert( FALSE );
2229 }
2230
2231 // array.pop_back()
2232 CK_DLL_MFUN( array_pop_back )
2233 {
2234     Chuck_Array * array = (Chuck_Array *)SELF;
2235     // TODO: make this safe!
2236     if( array->data_type_size() == CHUCK_ARRAY4_DATASIZE )
2237         RETURN->v_int = ((Chuck_Array4 *)array)->pop_back( );
2238     else if( array->data_type_size() == CHUCK_ARRAY8_DATASIZE )
2239         RETURN->v_int = ((Chuck_Array8 *)array)->pop_back( );
2240     else if( array->data_type_size() == CHUCK_ARRAY16_DATASIZE )
2241         RETURN->v_int = ((Chuck_Array16 *)array)->push_back( GET_NEXT_COMPLEX( ARGS ) );
2242     else
2243         assert( FALSE );
2244 }
2245
2246
2247 //-----------------------------------------------------------------------------
2248 // MidiIn API
2249 //-----------------------------------------------------------------------------
2250 CK_DLL_CTOR( MidiIn_ctor )
2251 {
2252     MidiIn * min = new MidiIn;
2253     min->SELF = SELF;
2254     OBJ_MEMBER_INT(SELF, MidiIn_offset_data) = (t_CKINT)min;
2255 }
2256
2257 CK_DLL_DTOR( MidiIn_dtor )
2258 {
2259     delete (MidiIn *)OBJ_MEMBER_INT(SELF, MidiIn_offset_data);
2260     OBJ_MEMBER_INT(SELF, MidiIn_offset_data) = 0;
2261 }
2262
2263 CK_DLL_MFUN( MidiIn_open )
2264 {
2265     MidiIn * min = (MidiIn *)OBJ_MEMBER_INT(SELF, MidiIn_offset_data);
2266     t_CKINT port = GET_CK_INT(ARGS);
2267     RETURN->v_int = min->open( port );
2268 }
2269
2270 CK_DLL_MFUN( MidiIn_good )
2271 {
2272     MidiIn * min = (MidiIn *)OBJ_MEMBER_INT(SELF, MidiIn_offset_data);
2273     RETURN->v_int = (t_CKINT)min->good();
2274 }
2275
2276 CK_DLL_MFUN( MidiIn_num )
2277 {
2278     MidiIn * min = (MidiIn *)OBJ_MEMBER_INT(SELF, MidiIn_offset_data);
2279     RETURN->v_int = min->num();
2280 }
2281
2282 CK_DLL_MFUN( MidiIn_printerr )
2283 {
2284     MidiIn * min = (MidiIn *)OBJ_MEMBER_INT(SELF, MidiIn_offset_data);
2285     t_CKINT print_or_not = GET_CK_INT(ARGS);
2286     min->set_suppress( !print_or_not );
2287 }
2288
2289 CK_DLL_MFUN( MidiIn_name )
2290 {
2291     MidiIn * min = (MidiIn *)OBJ_MEMBER_INT(SELF, MidiIn_offset_data);
2292     // TODO: memory leak, please fix, Thanks.
2293     Chuck_String * a = (Chuck_String *)instantiate_and_initialize_object( &t_string, NULL );
2294     // only if valid
2295     if( min->good() )
2296         a->str = min->min->getPortName( min->num() );
2297     RETURN->v_string = a;
2298 }
2299
2300 CK_DLL_MFUN( MidiIn_recv )
2301 {
2302     MidiIn * min = (MidiIn *)OBJ_MEMBER_INT(SELF, MidiIn_offset_data);
2303     Chuck_Object * fake_msg = GET_CK_OBJECT(ARGS);
2304     MidiMsg the_msg;
2305     RETURN->v_int = min->recv( &the_msg );
2306     if( RETURN->v_int )
2307     {
2308         OBJ_MEMBER_INT(fake_msg, MidiMsg_offset_data1) = the_msg.data[0];
2309         OBJ_MEMBER_INT(fake_msg, MidiMsg_offset_data2) = the_msg.data[1];
2310         OBJ_MEMBER_INT(fake_msg, MidiMsg_offset_data3) = the_msg.data[2];
2311     }
2312 }
2313
2314
2315 CK_DLL_MFUN( MidiIn_can_wait )
2316 {
2317     MidiIn * min = (MidiIn *)OBJ_MEMBER_INT(SELF, MidiIn_offset_data);
2318     RETURN->v_int = min->empty();
2319 }
2320
2321
2322 //-----------------------------------------------------------------------------
2323 // MidiOut API
2324 //-----------------------------------------------------------------------------
2325 CK_DLL_CTOR( MidiOut_ctor )
2326 {
2327     OBJ_MEMBER_INT(SELF, MidiOut_offset_data) = (t_CKUINT)new MidiOut;
2328 }
2329
2330 CK_DLL_DTOR( MidiOut_dtor )
2331 {
2332     delete (MidiOut *)OBJ_MEMBER_INT(SELF, MidiOut_offset_data);
2333     OBJ_MEMBER_INT(SELF, MidiOut_offset_data) = 0;
2334 }
2335
2336 CK_DLL_MFUN( MidiOut_open )
2337 {
2338     MidiOut * mout = (MidiOut *)OBJ_MEMBER_INT(SELF, MidiOut_offset_data);
2339     t_CKINT port = GET_CK_INT(ARGS);
2340     RETURN->v_int = mout->open( port );
2341 }
2342
2343 CK_DLL_MFUN( MidiOut_good )
2344 {
2345     MidiOut * mout = (MidiOut *)OBJ_MEMBER_INT(SELF, MidiOut_offset_data);
2346     RETURN->v_int = (t_CKINT)mout->good();
2347 }
2348
2349 CK_DLL_MFUN( MidiOut_num )
2350 {
2351     MidiOut * mout = (MidiOut *)OBJ_MEMBER_INT(SELF, MidiOut_offset_data);
2352     RETURN->v_int = mout->num();
2353 }
2354
2355 CK_DLL_MFUN( MidiOut_name )
2356 {
2357     MidiOut * mout = (MidiOut *)OBJ_MEMBER_INT(SELF, MidiOut_offset_data);
2358     // TODO: memory leak, please fix, Thanks.
2359     Chuck_String * a = (Chuck_String *)instantiate_and_initialize_object( &t_string, NULL );
2360     // only if valid
2361     if( mout->good() )
2362         a->str = mout->mout->getPortName( mout->num() );
2363     RETURN->v_string = a;
2364 }
2365
2366 CK_DLL_MFUN( MidiOut_printerr )
2367 {
2368     MidiOut * mout = (MidiOut *)OBJ_MEMBER_INT(SELF, MidiOut_offset_data);
2369     t_CKINT print_or_not = GET_CK_INT(ARGS);
2370     mout->set_suppress( !print_or_not );
2371 }
2372
2373 CK_DLL_MFUN( MidiOut_send )
2374 {
2375     MidiOut * mout = (MidiOut *)OBJ_MEMBER_INT(SELF, MidiOut_offset_data);
2376     Chuck_Object * fake_msg = GET_CK_OBJECT(ARGS);
2377     MidiMsg the_msg;
2378     the_msg.data[0] = (t_CKBYTE)OBJ_MEMBER_INT(fake_msg, MidiMsg_offset_data1);
2379     the_msg.data[1] = (t_CKBYTE)OBJ_MEMBER_INT(fake_msg, MidiMsg_offset_data2);
2380     the_msg.data[2] = (t_CKBYTE)OBJ_MEMBER_INT(fake_msg, MidiMsg_offset_data3);
2381     RETURN->v_int = mout->send( &the_msg );
2382 }
2383
2384
2385
2386 //-----------------------------------------------------------------------------
2387 // HidMsg API
2388 //-----------------------------------------------------------------------------
2389 CK_DLL_MFUN( HidMsg_is_axis_motion )
2390 {
2391     RETURN->v_int = ( ( t_CKINT ) OBJ_MEMBER_INT( SELF, HidMsg_offset_type ) ==
2392                       CK_HID_JOYSTICK_AXIS ? 1 : 0 );
2393 }
2394
2395 CK_DLL_MFUN( HidMsg_is_button_down )
2396 {
2397     RETURN->v_int = ( ( t_CKINT ) OBJ_MEMBER_INT( SELF, HidMsg_offset_type ) ==
2398                       CK_HID_BUTTON_DOWN ? 1 : 0 );
2399 }
2400
2401 CK_DLL_MFUN( HidMsg_is_button_up )
2402 {
2403     RETURN->v_int = ( ( t_CKINT ) OBJ_MEMBER_INT( SELF, HidMsg_offset_type ) ==
2404                       CK_HID_BUTTON_UP ? 1 : 0 );
2405 }
2406
2407 CK_DLL_MFUN( HidMsg_is_mouse_motion )
2408 {
2409     RETURN->v_int = ( ( t_CKINT ) OBJ_MEMBER_INT( SELF, HidMsg_offset_type ) ==
2410                       CK_HID_MOUSE_MOTION ? 1 : 0 );
2411 }
2412
2413 CK_DLL_MFUN( HidMsg_is_hat_motion )
2414 {
2415     RETURN->v_int = ( ( t_CKINT ) OBJ_MEMBER_INT( SELF, HidMsg_offset_type ) ==
2416                       CK_HID_JOYSTICK_HAT ? 1 : 0 );
2417 }
2418
2419 CK_DLL_MFUN( HidMsg_is_wheel_motion )
2420 {
2421     RETURN->v_int = ( ( t_CKINT ) OBJ_MEMBER_INT( SELF, HidMsg_offset_type ) ==
2422                       CK_HID_MOUSE_WHEEL ? 1 : 0 );
2423 }
2424
2425 //-----------------------------------------------------------------------------
2426 // HidIn API
2427 //-----------------------------------------------------------------------------
2428 CK_DLL_CTOR( HidIn_ctor )
2429 {
2430     HidIn * min = new HidIn;
2431     min->SELF = SELF;
2432     OBJ_MEMBER_INT(SELF, HidIn_offset_data) = (t_CKINT)min;
2433 }
2434
2435 CK_DLL_DTOR( HidIn_dtor )
2436 {
2437     delete (HidIn *)OBJ_MEMBER_INT(SELF, HidIn_offset_data);
2438     OBJ_MEMBER_INT(SELF, HidIn_offset_data) = 0;
2439 }
2440
2441 CK_DLL_MFUN( HidIn_open )
2442 {
2443     HidIn * min = (HidIn *)OBJ_MEMBER_INT(SELF, HidIn_offset_data);
2444     t_CKINT type = GET_NEXT_INT(ARGS);
2445     t_CKINT num = GET_NEXT_INT(ARGS);
2446     RETURN->v_int = min->open( type, num );
2447 }
2448
2449 CK_DLL_MFUN( HidIn_open_joystick )
2450 {
2451     HidIn * min = (HidIn *)OBJ_MEMBER_INT(SELF, HidIn_offset_data);
2452     t_CKINT num = GET_NEXT_INT(ARGS);
2453     RETURN->v_int = min->open( CK_HID_DEV_JOYSTICK, num );
2454 }
2455
2456 CK_DLL_MFUN( HidIn_open_mouse )
2457 {
2458     HidIn * min = (HidIn *)OBJ_MEMBER_INT(SELF, HidIn_offset_data);
2459     t_CKINT num = GET_NEXT_INT(ARGS);
2460     RETURN->v_int = min->open( CK_HID_DEV_MOUSE, num );
2461 }
2462
2463 CK_DLL_MFUN( HidIn_open_keyboard )
2464 {
2465     HidIn * min = (HidIn *)OBJ_MEMBER_INT(SELF, HidIn_offset_data);
2466     t_CKINT num = GET_NEXT_INT(ARGS);
2467     RETURN->v_int = min->open( CK_HID_DEV_KEYBOARD, num );
2468 }
2469
2470 CK_DLL_MFUN( HidIn_open_tiltsensor )
2471 {
2472     HidIn * min = (HidIn *)OBJ_MEMBER_INT(SELF, HidIn_offset_data);
2473     RETURN->v_int = min->open( CK_HID_DEV_TILTSENSOR, 0 );
2474 }
2475
2476 CK_DLL_MFUN( HidIn_good )
2477 {
2478     HidIn * min = (HidIn *)OBJ_MEMBER_INT(SELF, HidIn_offset_data);
2479     RETURN->v_int = (t_CKINT)min->good();
2480 }
2481
2482 CK_DLL_MFUN( HidIn_num )
2483 {
2484     HidIn * min = (HidIn *)OBJ_MEMBER_INT(SELF, HidIn_offset_data);
2485     RETURN->v_int = min->num();
2486 }
2487
2488 CK_DLL_MFUN( HidIn_printerr )
2489 {
2490     HidIn * min = (HidIn *)OBJ_MEMBER_INT(SELF, HidIn_offset_data);
2491     t_CKINT print_or_not = GET_CK_INT(ARGS);
2492     min->set_suppress( !print_or_not );
2493 }
2494
2495 CK_DLL_MFUN( HidIn_name )
2496 {
2497     HidIn * min = (HidIn *)OBJ_MEMBER_INT(SELF, HidIn_offset_data);
2498     // TODO: memory leak, please fix, Thanks.
2499     // Chuck_String * a = (Chuck_String *)instantiate_and_initialize_object( &t_string, NULL );
2500     // only if valid
2501     // if( min->good() )
2502     //     a->str = min->phin->getPortName( min->num() );
2503     // TODO: is null problem?
2504     RETURN->v_string = (Chuck_String *)instantiate_and_initialize_object( &t_string, NULL );
2505     RETURN->v_string->str = min->name();
2506 }
2507
2508 CK_DLL_MFUN( HidIn_recv )
2509 {
2510     HidIn * min = (HidIn *)OBJ_MEMBER_INT(SELF, HidIn_offset_data);
2511     Chuck_Object * fake_msg = GET_CK_OBJECT(ARGS);
2512     HidMsg the_msg;
2513     RETURN->v_int = min->recv( &the_msg );
2514     if( RETURN->v_int )
2515     {
2516         OBJ_MEMBER_INT(fake_msg, HidMsg_offset_device_type) = the_msg.device_type;
2517         OBJ_MEMBER_INT(fake_msg, HidMsg_offset_device_num) = the_msg.device_num;
2518         OBJ_MEMBER_INT(fake_msg, HidMsg_offset_type) = the_msg.type;
2519         OBJ_MEMBER_INT(fake_msg, HidMsg_offset_which) = the_msg.eid;
2520         OBJ_MEMBER_INT(fake_msg, HidMsg_offset_idata) = the_msg.idata[0];
2521         OBJ_MEMBER_FLOAT(fake_msg, HidMsg_offset_fdata) = the_msg.fdata[0];
2522
2523         // mouse motion specific member variables
2524         OBJ_MEMBER_INT(fake_msg, HidMsg_offset_deltax) = the_msg.idata[0];
2525         OBJ_MEMBER_INT(fake_msg, HidMsg_offset_deltay) = the_msg.idata[1];
2526         OBJ_MEMBER_INT(fake_msg, HidMsg_offset_cursorx) = the_msg.idata[2];
2527         OBJ_MEMBER_INT(fake_msg, HidMsg_offset_cursory) = the_msg.idata[3];
2528         OBJ_MEMBER_FLOAT(fake_msg, HidMsg_offset_scaledcursorx) = the_msg.fdata[0];
2529         OBJ_MEMBER_FLOAT(fake_msg, HidMsg_offset_scaledcursory) = the_msg.fdata[1];
2530
2531         // axis motion specific member variables
2532         OBJ_MEMBER_INT(fake_msg, HidMsg_offset_axis_position) = the_msg.idata[0];
2533         OBJ_MEMBER_FLOAT(fake_msg, HidMsg_offset_scaled_axis_position) = the_msg.fdata[0];
2534         OBJ_MEMBER_FLOAT(fake_msg, HidMsg_offset_axis_position2) = the_msg.fdata[0];
2535
2536         // hat motion specific variables
2537         OBJ_MEMBER_INT(fake_msg, HidMsg_offset_hat_position) = the_msg.idata[0];
2538
2539         // keyboard specific variables
2540         OBJ_MEMBER_INT(fake_msg, HidMsg_offset_key) = the_msg.idata[1];
2541         OBJ_MEMBER_INT(fake_msg, HidMsg_offset_ascii) = the_msg.idata[2];
2542
2543         // accelerometer (tilt sensor, wii remote) specific members
2544         OBJ_MEMBER_INT(fake_msg, HidMsg_offset_x) = the_msg.idata[0];
2545         OBJ_MEMBER_INT(fake_msg, HidMsg_offset_y) = the_msg.idata[1];
2546         OBJ_MEMBER_INT(fake_msg, HidMsg_offset_z) = the_msg.idata[2];
2547     }
2548 }
2549
2550 CK_DLL_MFUN( HidIn_read )
2551 {
2552     HidIn * min = (HidIn *)OBJ_MEMBER_INT(SELF, HidIn_offset_data);
2553     t_CKINT type = GET_NEXT_INT(ARGS);
2554     t_CKINT num = GET_NEXT_INT(ARGS);
2555     Chuck_Object * fake_msg = GET_NEXT_OBJECT(ARGS);
2556
2557     HidMsg the_msg;
2558
2559     RETURN->v_int = min->read( type, num, &the_msg );
2560
2561     if( RETURN->v_int )
2562     {
2563         OBJ_MEMBER_INT(fake_msg, HidMsg_offset_device_type) = the_msg.device_type;
2564         OBJ_MEMBER_INT(fake_msg, HidMsg_offset_device_num) = the_msg.device_num;
2565         OBJ_MEMBER_INT(fake_msg, HidMsg_offset_type) = the_msg.type;
2566         OBJ_MEMBER_INT(fake_msg, HidMsg_offset_which) = the_msg.eid;
2567
2568         OBJ_MEMBER_INT(fake_msg, HidMsg_offset_idata) = the_msg.idata[0];
2569         OBJ_MEMBER_FLOAT(fake_msg, HidMsg_offset_fdata) = the_msg.fdata[0];
2570
2571         // mouse motion specific member members
2572         OBJ_MEMBER_INT(fake_msg, HidMsg_offset_deltax) = the_msg.idata[0];
2573         OBJ_MEMBER_INT(fake_msg, HidMsg_offset_deltay) = the_msg.idata[1];
2574         OBJ_MEMBER_INT(fake_msg, HidMsg_offset_cursorx) = the_msg.idata[2];
2575         OBJ_MEMBER_INT(fake_msg, HidMsg_offset_cursory) = the_msg.idata[3];
2576         OBJ_MEMBER_FLOAT(fake_msg, HidMsg_offset_scaledcursorx) = the_msg.fdata[0];
2577         OBJ_MEMBER_FLOAT(fake_msg, HidMsg_offset_scaledcursory) = the_msg.fdata[1];
2578
2579         // joystick axis specific member members
2580         OBJ_MEMBER_INT(fake_msg, HidMsg_offset_axis_position) = the_msg.idata[0];
2581         OBJ_MEMBER_FLOAT(fake_msg, HidMsg_offset_scaled_axis_position) = the_msg.fdata[0];
2582         OBJ_MEMBER_FLOAT(fake_msg, HidMsg_offset_axis_position2) = the_msg.fdata[0];
2583
2584         // joystick hat specific member members
2585         OBJ_MEMBER_INT(fake_msg, HidMsg_offset_hat_position) = the_msg.idata[0];
2586
2587         // keyboard specific members
2588         OBJ_MEMBER_INT(fake_msg, HidMsg_offset_key) = the_msg.idata[1];
2589         OBJ_MEMBER_INT(fake_msg, HidMsg_offset_ascii) = the_msg.idata[2];
2590
2591         // accelerometer (tilt sensor, wii remote) specific members
2592         OBJ_MEMBER_INT(fake_msg, HidMsg_offset_x) = the_msg.idata[0];
2593         OBJ_MEMBER_INT(fake_msg, HidMsg_offset_y) = the_msg.idata[1];
2594         OBJ_MEMBER_INT(fake_msg, HidMsg_offset_z) = the_msg.idata[2];
2595     }
2596 }
2597
2598 CK_DLL_MFUN( HidIn_send )
2599 {
2600     HidIn * min = (HidIn *)OBJ_MEMBER_INT(SELF, HidIn_offset_data);
2601     Chuck_Object * fake_msg = GET_NEXT_OBJECT(ARGS);
2602
2603     HidMsg the_msg;
2604     the_msg.device_type = OBJ_MEMBER_INT( fake_msg, HidMsg_offset_device_type );
2605     the_msg.device_num = OBJ_MEMBER_INT( fake_msg, HidMsg_offset_device_num );
2606     the_msg.type = OBJ_MEMBER_INT( fake_msg, HidMsg_offset_type );
2607     the_msg.eid = OBJ_MEMBER_INT( fake_msg, HidMsg_offset_which );
2608     the_msg.idata[0] = OBJ_MEMBER_INT( fake_msg, HidMsg_offset_idata );
2609
2610     RETURN->v_int = min->send( &the_msg );
2611 }
2612
2613 CK_DLL_MFUN( HidIn_can_wait )
2614 {
2615     HidIn * min = (HidIn *)OBJ_MEMBER_INT(SELF, HidIn_offset_data);
2616     RETURN->v_int = min->empty();
2617 }
2618
2619 CK_DLL_SFUN( HidIn_read_tilt_sensor )
2620 {
2621     static HidIn * hi;
2622     static t_CKBOOL hi_good = TRUE;
2623
2624     Chuck_Array4 * array = new Chuck_Array4( FALSE, 3 );
2625     array->set( 0, 0 );
2626     array->set( 1, 0 );
2627     array->set( 2, 0 );
2628
2629     // TODO: reference count?
2630     array->add_ref();
2631     RETURN->v_object = array;
2632
2633     if( hi_good == FALSE )
2634         return;
2635
2636     if( !hi )
2637     {
2638         hi = new HidIn;
2639         if( !hi->open( CK_HID_DEV_TILTSENSOR, 0 ) )
2640         {
2641             hi_good = FALSE;
2642             return;
2643         }
2644     }
2645
2646     HidMsg msg;
2647
2648     if( !hi->read( CK_HID_ACCELEROMETER, 0, &msg ) )
2649     {
2650         return;
2651     }
2652
2653     array->set( 0, msg.idata[0] );
2654     array->set( 1, msg.idata[1] );
2655     array->set( 2, msg.idata[2] );
2656 }
2657
2658 CK_DLL_SFUN( HidIn_start_cursor_track )
2659 {
2660     RETURN->v_int = !Mouse_start_cursor_track();
2661 }
2662
2663 CK_DLL_SFUN( HidIn_stop_cursor_track )
2664 {
2665     RETURN->v_int = !Mouse_stop_cursor_track();
2666 }
2667
2668 //-----------------------------------------------------------------------------
2669 // HidOut API
2670 //-----------------------------------------------------------------------------
2671 CK_DLL_CTOR( HidOut_ctor )
2672 {
2673     OBJ_MEMBER_INT(SELF, HidOut_offset_data) = (t_CKUINT)new HidOut;
2674 }
2675
2676 CK_DLL_DTOR( HidOut_dtor )
2677 {
2678     delete (HidOut *)OBJ_MEMBER_INT(SELF, HidOut_offset_data);
2679     OBJ_MEMBER_INT(SELF, HidOut_offset_data) = 0;
2680 }
2681
2682 CK_DLL_MFUN( HidOut_open )
2683 {
2684     HidOut * mout = (HidOut *)OBJ_MEMBER_INT(SELF, HidOut_offset_data);
2685     t_CKINT num = GET_CK_INT(ARGS);
2686     RETURN->v_int = mout->open( num );
2687 }
2688
2689 CK_DLL_MFUN( HidOut_good )
2690 {
2691     HidOut * mout = (HidOut *)OBJ_MEMBER_INT(SELF, HidOut_offset_data);
2692     RETURN->v_int = (t_CKINT)mout->good();
2693 }
2694
2695 CK_DLL_MFUN( HidOut_num )
2696 {
2697     HidOut * mout = (HidOut *)OBJ_MEMBER_INT(SELF, HidOut_offset_data);
2698     RETURN->v_int = mout->num();
2699 }
2700
2701 CK_DLL_MFUN( HidOut_name )
2702 {
2703     HidOut * mout = (HidOut *)OBJ_MEMBER_INT(SELF, HidOut_offset_data);
2704     // TODO: memory leak, please fix, Thanks.
2705     Chuck_String * a = (Chuck_String *)instantiate_and_initialize_object( &t_string, NULL );
2706     // only if valid
2707     // if( mout->good() )
2708     //     a->str = mout->mout->getPortName( mout->num() );
2709     RETURN->v_string = a;
2710 }
2711
2712 CK_DLL_MFUN( HidOut_printerr )
2713 {
2714     HidOut * mout = (HidOut *)OBJ_MEMBER_INT(SELF, HidOut_offset_data);
2715     t_CKINT print_or_not = GET_CK_INT(ARGS);
2716     mout->set_suppress( !print_or_not );
2717 }
2718
2719 CK_DLL_MFUN( HidOut_send )
2720 {
2721     HidOut * mout = (HidOut *)OBJ_MEMBER_INT(SELF, HidOut_offset_data);
2722     Chuck_Object * fake_msg = GET_CK_OBJECT(ARGS);
2723     HidMsg the_msg;
2724 /*    the_msg.data[0] = (t_CKBYTE)OBJ_MEMBER_INT(fake_msg, HidMsg_offset_data1);
2725     the_msg.data[1] = (t_CKBYTE)OBJ_MEMBER_INT(fake_msg, HidMsg_offset_data2);
2726     the_msg.data[2] = (t_CKBYTE)OBJ_MEMBER_INT(fake_msg, HidMsg_offset_data3);
2727 */    RETURN->v_int = mout->send( &the_msg );
2728 }
2729
2730
2731
2732 //-----------------------------------------------------------------------------
2733 // MidiRW API
2734 //-----------------------------------------------------------------------------
2735 CK_DLL_CTOR( MidiRW_ctor )
2736 {
2737     OBJ_MEMBER_INT(SELF, MidiRW_offset_data) = (t_CKUINT)new MidiRW;
2738 }
2739
2740 CK_DLL_DTOR( MidiRW_dtor )
2741 {
2742     delete (MidiRW *)OBJ_MEMBER_INT(SELF, MidiRW_offset_data);
2743     OBJ_MEMBER_INT(SELF, MidiRW_offset_data) = 0;
2744 }
2745
2746 CK_DLL_MFUN( MidiRW_open )
2747 {
2748     MidiRW * mrw = (MidiRW *)OBJ_MEMBER_INT(SELF, MidiRW_offset_data);
2749     const char * filename = GET_CK_STRING(ARGS)->str.c_str();
2750     RETURN->v_int = mrw->open( filename );
2751 }
2752
2753 CK_DLL_MFUN( MidiRW_close )
2754 {
2755     MidiRW * mrw = (MidiRW *)OBJ_MEMBER_INT(SELF, MidiRW_offset_data);
2756     RETURN->v_int = mrw->close();
2757 }
2758
2759 CK_DLL_MFUN( MidiRW_read )
2760 {
2761     MidiRW * mrw = (MidiRW *)OBJ_MEMBER_INT(SELF, MidiRW_offset_data);
2762     Chuck_Object * fake_msg = GET_NEXT_OBJECT(ARGS);
2763     MidiMsg the_msg;
2764     t_CKTIME time = 0.0;
2765     RETURN->v_int = mrw->read( &the_msg, &time );
2766     OBJ_MEMBER_INT(fake_msg, MidiMsg_offset_data1) = the_msg.data[0];
2767     OBJ_MEMBER_INT(fake_msg, MidiMsg_offset_data2) = the_msg.data[1];
2768     OBJ_MEMBER_INT(fake_msg, MidiMsg_offset_data3) = the_msg.data[2];
2769     OBJ_MEMBER_TIME(fake_msg, MidiMsg_offset_when) = time;
2770 }
2771
2772 CK_DLL_MFUN( MidiRW_write )
2773 {
2774     MidiRW * mrw = (MidiRW *)OBJ_MEMBER_INT(SELF, MidiRW_offset_data);
2775     Chuck_Object * fake_msg = GET_NEXT_OBJECT(ARGS);
2776     t_CKTIME time = GET_NEXT_TIME(ARGS);
2777     MidiMsg the_msg;
2778     the_msg.data[0] = (t_CKBYTE)OBJ_MEMBER_INT(fake_msg, MidiMsg_offset_data1);
2779     the_msg.data[1] = (t_CKBYTE)OBJ_MEMBER_INT(fake_msg, MidiMsg_offset_data2);
2780     the_msg.data[2] = (t_CKBYTE)OBJ_MEMBER_INT(fake_msg, MidiMsg_offset_data3);
2781     RETURN->v_int = mrw->write( &the_msg, &time );
2782 }
2783
2784
2785 //-----------------------------------------------------------------------------
2786 // MidiMsgOut API
2787 //-----------------------------------------------------------------------------
2788 CK_DLL_CTOR( MidiMsgOut_ctor )
2789 {
2790     OBJ_MEMBER_INT(SELF, MidiMsgOut_offset_data) = (t_CKUINT)new MidiMsgOut;
2791 }
2792
2793 CK_DLL_DTOR( MidiMsgOut_dtor )
2794 {
2795     delete (MidiMsgOut *)OBJ_MEMBER_INT(SELF, MidiMsgOut_offset_data);
2796     OBJ_MEMBER_INT(SELF, MidiMsgOut_offset_data) = 0;
2797 }
2798
2799 CK_DLL_MFUN( MidiMsgOut_open )
2800 {
2801     MidiMsgOut * mrw = (MidiMsgOut *)OBJ_MEMBER_INT(SELF, MidiMsgOut_offset_data);
2802     const char * filename = GET_CK_STRING(ARGS)->str.c_str();
2803     RETURN->v_int = mrw->open( filename );
2804 }
2805
2806 CK_DLL_MFUN( MidiMsgOut_close )
2807 {
2808     MidiMsgOut * mrw = (MidiMsgOut *)OBJ_MEMBER_INT(SELF, MidiMsgOut_offset_data);
2809     RETURN->v_int = mrw->close();
2810 }
2811
2812 CK_DLL_MFUN( MidiMsgOut_write )
2813 {
2814     MidiMsgOut * mrw = (MidiMsgOut *)OBJ_MEMBER_INT(SELF, MidiMsgOut_offset_data);
2815     Chuck_Object * fake_msg = GET_NEXT_OBJECT(ARGS);
2816     t_CKTIME time = GET_NEXT_TIME(ARGS);
2817     MidiMsg the_msg;
2818     the_msg.data[0] = (t_CKBYTE)OBJ_MEMBER_INT(fake_msg, MidiMsg_offset_data1);
2819     the_msg.data[1] = (t_CKBYTE)OBJ_MEMBER_INT(fake_msg, MidiMsg_offset_data2);
2820     the_msg.data[2] = (t_CKBYTE)OBJ_MEMBER_INT(fake_msg, MidiMsg_offset_data3);
2821     RETURN->v_int = mrw->write( &the_msg, &time );
2822 }
2823
2824
2825 //-----------------------------------------------------------------------------
2826 // MidiMsgIn API
2827 //-----------------------------------------------------------------------------
2828 CK_DLL_CTOR( MidiMsgIn_ctor )
2829 {
2830     OBJ_MEMBER_INT(SELF, MidiMsgIn_offset_data) = (t_CKUINT)new MidiMsgIn;
2831 }
2832
2833 CK_DLL_DTOR( MidiMsgIn_dtor )
2834 {
2835     delete (MidiMsgIn *)OBJ_MEMBER_INT(SELF, MidiMsgIn_offset_data);
2836     OBJ_MEMBER_INT(SELF, MidiMsgIn_offset_data) = 0;
2837 }
2838
2839 CK_DLL_MFUN( MidiMsgIn_open )
2840 {
2841     MidiMsgIn * mrw = (MidiMsgIn *)OBJ_MEMBER_INT(SELF, MidiMsgIn_offset_data);
2842     const char * filename = GET_CK_STRING(ARGS)->str.c_str();
2843     RETURN->v_int = mrw->open( filename );
2844 }
2845
2846 CK_DLL_MFUN( MidiMsgIn_close )
2847 {
2848     MidiMsgIn * mrw = (MidiMsgIn *)OBJ_MEMBER_INT(SELF, MidiMsgIn_offset_data);
2849     RETURN->v_int = mrw->close();
2850 }
2851
2852 CK_DLL_MFUN( MidiMsgIn_read )
2853 {
2854     MidiMsgIn * mrw = (MidiMsgIn *)OBJ_MEMBER_INT(SELF, MidiMsgIn_offset_data);
2855     Chuck_Object * fake_msg = GET_NEXT_OBJECT(ARGS);
2856     MidiMsg the_msg;
2857     t_CKTIME time = 0.0;
2858     RETURN->v_int = mrw->read( &the_msg, &time );
2859     OBJ_MEMBER_INT(fake_msg, MidiMsg_offset_data1) = the_msg.data[0];
2860     OBJ_MEMBER_INT(fake_msg, MidiMsg_offset_data2) = the_msg.data[1];
2861     OBJ_MEMBER_INT(fake_msg, MidiMsg_offset_data3) = the_msg.data[2];
2862     OBJ_MEMBER_TIME(fake_msg, MidiMsg_offset_when) = time;
2863 }
2864