From dba812043f3af08294a34caed955011851e3285f Mon Sep 17 00:00:00 2001 From: Stephen Sinclair Date: Wed, 20 Aug 2008 16:47:43 -0400 Subject: [PATCH] 64-bit support: Use word size instead of byte count for type assumptions and for emitting instructions. --- v2/chuck_def.h | 40 ++++++ v2/chuck_emit.cpp | 149 ++++++++++++++--------- v2/chuck_instr.cpp | 345 ++++++++++++++++++++++++++-------------------------- v2/chuck_instr.h | 26 ++-- v2/chuck_type.cpp | 11 ++ v2/chuck_type.h | 2 + 6 files changed, 330 insertions(+), 243 deletions(-) mode change 100755 => 100644 v2/chuck_instr.cpp diff --git a/v2/chuck_def.h b/v2/chuck_def.h index c15408d..e1073d0 100755 --- a/v2/chuck_def.h +++ b/v2/chuck_def.h @@ -57,6 +57,30 @@ typedef struct { t_CKFLOAT re ; t_CKFLOAT im ; } t_CKCOMPLEX; // polar type typedef struct { t_CKFLOAT modulus ; t_CKFLOAT phase ; } t_CKPOLAR; +// check for 64-bit +#if defined(__LP64__) || defined(_M_X64) || defined(_M_IA64) || defined(_WIN64) +#define CK64BIT +#else +#define CK32BIT +#endif + +// types of specific word sizes, for pointer manipulation +#ifdef CK32BIT +typedef t_CKUINT t_CK1WORD; +typedef t_CKFLOAT t_CK2WORD; +typedef t_CKCOMPLEX t_CK4WORD; +#endif +#ifdef CK64BIT +typedef t_CKUINT t_CK1WORD; +typedef t_CKCOMPLEX t_CK2WORD; +typedef struct { t_CKCOMPLEX i; t_CKCOMPLEX j; } t_CK4WORD; +#endif + +// static constants for zero of each type +extern t_CK1WORD zero_CK1WORD; +extern t_CK2WORD zero_CK2WORD; +extern t_CK4WORD zero_CK4WORD; + // size #define sz_TIME sizeof(double) #define sz_DUR sizeof(double) @@ -73,6 +97,22 @@ typedef struct { t_CKFLOAT modulus ; t_CKFLOAT phase ; } t_CKPOLAR; #define sz_COMPLEX sizeof(t_CKCOMPLEX) #define sz_POLAR sizeof(t_CKPOLAR) +// word size +#define wd_TIME sizeof(double)/sizeof(long) +#define wd_DUR sizeof(double)/sizeof(long) +#define wd_FLOAT sizeof(double)/sizeof(long) +#define wd_DOUBLE sizeof(double)/sizeof(long) +#define wd_SINGLE sizeof(float)/sizeof(long) +#define wd_INT sizeof(long)/sizeof(long) +#define wd_DWORD sizeof(unsigned long)/sizeof(long) +#define wd_UINT sizeof(t_CKDWORD)/sizeof(long) +#define wd_BOOL sizeof(t_CKDWORD)/sizeof(long) +#define wd_BYTE sizeof(unsigned char)/sizeof(long) +#define wd_VOID 0 +#define wd_VOIDPTR sizeof(void *)/sizeof(long) +#define wd_COMPLEX sizeof(t_CKCOMPLEX)/sizeof(long) +#define wd_POLAR sizeof(t_CKPOLAR)/sizeof(long) + typedef char * c_str; typedef const char * c_constr; diff --git a/v2/chuck_emit.cpp b/v2/chuck_emit.cpp index 2d3fd18..2054c8c 100755 --- a/v2/chuck_emit.cpp +++ b/v2/chuck_emit.cpp @@ -374,11 +374,11 @@ t_CKBOOL emit_engine_emit_stmt( Chuck_Emitter * emit, a_Stmt stmt, t_CKBOOL pop // if decl, then expect only one word per var if( exp->s_type == ae_exp_decl ) emit->append( new Chuck_Instr_Reg_Pop_Word3( exp->decl.num_var_decls ) ); - else if( exp->type->size == 4 ) // ISSUE: 64-bit + else if( exp->type->words() == 1 ) // ISSUE: 64-bit emit->append( new Chuck_Instr_Reg_Pop_Word ); - else if( exp->type->size == 8 ) // ISSUE: 64-bit + else if( exp->type->words() == 2 ) // ISSUE: 64-bit emit->append( new Chuck_Instr_Reg_Pop_Word2 ); - else if( exp->type->size == 16 ) // ISSUE: 64-bit + else if( exp->type->words() == 4 ) // ISSUE: 64-bit emit->append( new Chuck_Instr_Reg_Pop_Word3( 4 ) ); else { @@ -483,19 +483,24 @@ t_CKBOOL emit_engine_emit_if( Chuck_Emitter * emit, a_Stmt_If stmt ) if( !ret ) return FALSE; + // push 0 + if (stmt->cond->type->words() == 1) + emit->append( new Chuck_Instr_Reg_Push_Imm( zero_CK1WORD ) ); + else if (stmt->cond->type->words() == 2) + emit->append( new Chuck_Instr_Reg_Push_Imm2( zero_CK2WORD ) ); + else if (stmt->cond->type->words() == 4) + emit->append( new Chuck_Instr_Reg_Push_Imm4( zero_CK2WORD, + zero_CK2WORD ) ); + // type of the condition switch( stmt->cond->type->xid ) { case te_int: - // push 0 - emit->append( new Chuck_Instr_Reg_Push_Imm( 0 ) ); op = new Chuck_Instr_Branch_Eq_int( 0 ); break; case te_float: case te_dur: case te_time: - // push 0 - emit->append( new Chuck_Instr_Reg_Push_Imm2( 0.0 ) ); op = new Chuck_Instr_Branch_Eq_double( 0 ); break; @@ -570,18 +575,22 @@ t_CKBOOL emit_engine_emit_for( Chuck_Emitter * emit, a_Stmt_For stmt ) // could be NULL if( stmt->c2 ) { + // push 0 + if (stmt->c2->stmt_exp->type->words() == 1) + emit->append( new Chuck_Instr_Reg_Push_Imm( zero_CK1WORD ) ); + else if (stmt->c2->stmt_exp->type->words() == 2) + emit->append( new Chuck_Instr_Reg_Push_Imm2( zero_CK2WORD ) ); + else if (stmt->c2->stmt_exp->type->words() == 4) + emit->append( new Chuck_Instr_Reg_Push_Imm4( zero_CK2WORD, + zero_CK2WORD ) ); switch( stmt->c2->stmt_exp->type->xid ) { case te_int: - // push 0 - emit->append( new Chuck_Instr_Reg_Push_Imm( 0 ) ); op = new Chuck_Instr_Branch_Eq_int( 0 ); break; case te_float: case te_dur: case te_time: - // push 0 - emit->append( new Chuck_Instr_Reg_Push_Imm2( 0.0 ) ); op = new Chuck_Instr_Branch_Eq_double( 0 ); break; @@ -616,19 +625,7 @@ t_CKBOOL emit_engine_emit_for( Chuck_Emitter * emit, a_Stmt_For stmt ) t_CKUINT num_words = 0; while( e ) { - if( e->type->size == 8 ) // ISSUE: 64-bit - num_words += 2; - else if( e->type->size == 4 ) // ISSUE: 64-bit - num_words += 1; - else if( e->type->size == 16 ) // ISSUE: 64-bit - num_words += 4; - else if( e->type->size != 0 ) - { - EM_error2( e->linepos, - "(emit): internal error: non-void type size %i unhandled...", - e->type->size ); - return FALSE; - } + num_words += e->type->words(); // advance e = e->next; @@ -696,20 +693,25 @@ t_CKBOOL emit_engine_emit_while( Chuck_Emitter * emit, a_Stmt_While stmt ) ret = emit_engine_emit_exp( emit, stmt->cond ); if( !ret ) return FALSE; + + // push 0 + if (stmt->cond->type->words() == 1) + emit->append( new Chuck_Instr_Reg_Push_Imm( zero_CK1WORD ) ); + else if (stmt->cond->type->words() == 2) + emit->append( new Chuck_Instr_Reg_Push_Imm2( zero_CK2WORD ) ); + else if (stmt->cond->type->words() == 4) + emit->append( new Chuck_Instr_Reg_Push_Imm4( zero_CK2WORD, + zero_CK2WORD ) ); // the condition switch( stmt->cond->type->xid ) { case te_int: - // push 0 - emit->append( new Chuck_Instr_Reg_Push_Imm( 0 ) ); op = new Chuck_Instr_Branch_Eq_int( 0 ); break; case te_float: case te_dur: case te_time: - // push 0 - emit->append( new Chuck_Instr_Reg_Push_Imm2( 0.0 ) ); op = new Chuck_Instr_Branch_Eq_double( 0 ); break; @@ -788,20 +790,25 @@ t_CKBOOL emit_engine_emit_do_while( Chuck_Emitter * emit, a_Stmt_While stmt ) ret = emit_engine_emit_exp( emit, stmt->cond ); if( !ret ) return FALSE; + + // push 0 + if (stmt->cond->type->words() == 1) + emit->append( new Chuck_Instr_Reg_Push_Imm( zero_CK1WORD ) ); + else if (stmt->cond->type->words() == 2) + emit->append( new Chuck_Instr_Reg_Push_Imm2( zero_CK2WORD ) ); + else if (stmt->cond->type->words() == 4) + emit->append( new Chuck_Instr_Reg_Push_Imm4( zero_CK2WORD, + zero_CK2WORD ) ); // the condition switch( stmt->cond->type->xid ) { case te_int: - // push 0 - emit->append( new Chuck_Instr_Reg_Push_Imm( 0 ) ); op = new Chuck_Instr_Branch_Neq_int( 0 ); break; case te_float: case te_dur: case te_time: - // push 0 - emit->append( new Chuck_Instr_Reg_Push_Imm2( 0.0 ) ); op = new Chuck_Instr_Branch_Neq_double( 0 ); break; @@ -869,19 +876,24 @@ t_CKBOOL emit_engine_emit_until( Chuck_Emitter * emit, a_Stmt_Until stmt ) if( !ret ) return FALSE; + // push 0 + if (stmt->cond->type->words() == 1) + emit->append( new Chuck_Instr_Reg_Push_Imm( zero_CK1WORD ) ); + else if (stmt->cond->type->words() == 2) + emit->append( new Chuck_Instr_Reg_Push_Imm2( zero_CK2WORD ) ); + else if (stmt->cond->type->words() == 4) + emit->append( new Chuck_Instr_Reg_Push_Imm4( zero_CK2WORD, + zero_CK2WORD ) ); + // condition switch( stmt->cond->type->xid ) { case te_int: - // push 0 - emit->append( new Chuck_Instr_Reg_Push_Imm( 0 ) ); op = new Chuck_Instr_Branch_Neq_int( 0 ); break; case te_float: case te_dur: case te_time: - // push 0 - emit->append( new Chuck_Instr_Reg_Push_Imm2( 0.0 ) ); op = new Chuck_Instr_Branch_Neq_double( 0 ); break; @@ -960,19 +972,24 @@ t_CKBOOL emit_engine_emit_do_until( Chuck_Emitter * emit, a_Stmt_Until stmt ) if( !ret ) return FALSE; + // push 0 + if (stmt->cond->type->words() == 1) + emit->append( new Chuck_Instr_Reg_Push_Imm( zero_CK1WORD ) ); + else if (stmt->cond->type->words() == 2) + emit->append( new Chuck_Instr_Reg_Push_Imm2( zero_CK2WORD ) ); + else if (stmt->cond->type->words() == 4) + emit->append( new Chuck_Instr_Reg_Push_Imm4( zero_CK2WORD, + zero_CK2WORD ) ); + // condition switch( stmt->cond->type->xid ) { case te_int: - // push 0 - emit->append( new Chuck_Instr_Reg_Push_Imm( 0 ) ); op = new Chuck_Instr_Branch_Eq_int( 0 ); break; case te_float: case te_dur: case te_time: - // push 0 - emit->append( new Chuck_Instr_Reg_Push_Imm2( 0.0 ) ); op = new Chuck_Instr_Branch_Eq_double( 0 ); break; @@ -2293,11 +2310,11 @@ t_CKBOOL emit_engine_emit_op_at_chuck( Chuck_Emitter * emit, a_Exp lhs, a_Exp rh else { // assign primitive - if( right->size == 4 ) // ISSUE: 64-bit + if( right->words() == 1 ) // ISSUE: 64-bit emit->append( new Chuck_Instr_Assign_Primitive ); - else if( right->size == 8 ) // ISSUE: 64-bit + else if( right->words() == 2 ) // ISSUE: 64-bit emit->append( new Chuck_Instr_Assign_Primitive2 ); - else if( right->size == 16 ) // ISSUE: 64-bit + else if( right->words() == 4 ) // ISSUE: 64-bit emit->append( new Chuck_Instr_Assign_Primitive4 ); else { @@ -2521,7 +2538,10 @@ t_CKBOOL emit_engine_emit_exp_primary( Chuck_Emitter * emit, a_Exp_Primary exp ) else if( exp->var == insert_symbol( "pi" ) ) { double pi = 3.14159265358979323846; - emit->append( new Chuck_Instr_Reg_Push_Imm2( pi ) ); + if (wd_FLOAT == 1) + emit->append( new Chuck_Instr_Reg_Push_Imm(*(t_CK1WORD*)&pi) ); + else if (wd_FLOAT == 2) + emit->append( new Chuck_Instr_Reg_Push_Imm2(*(t_CK2WORD*)&pi) ); } else if( exp->var == insert_symbol( "dac" ) ) { @@ -2541,7 +2561,10 @@ t_CKBOOL emit_engine_emit_exp_primary( Chuck_Emitter * emit, a_Exp_Primary exp ) } else if( emit->find_dur( S_name(exp->var), &dur ) ) { - emit->append( new Chuck_Instr_Reg_Push_Imm2( dur ) ); + if (wd_FLOAT == 1) + emit->append( new Chuck_Instr_Reg_Push_Imm(*(t_CK1WORD*)&dur) ); + else if (wd_FLOAT == 2) + emit->append( new Chuck_Instr_Reg_Push_Imm2(*(t_CK2WORD*)&dur) ); } else { @@ -2557,7 +2580,10 @@ t_CKBOOL emit_engine_emit_exp_primary( Chuck_Emitter * emit, a_Exp_Primary exp ) break; case ae_primary_float: - emit->append( new Chuck_Instr_Reg_Push_Imm2( exp->fnum ) ); + if (wd_FLOAT == 1) + emit->append( new Chuck_Instr_Reg_Push_Imm(*(t_CK1WORD*)&exp->fnum) ); + else if (wd_FLOAT == 2) + emit->append( new Chuck_Instr_Reg_Push_Imm2(*(t_CK2WORD*)&exp->fnum) ); break; case ae_primary_str: @@ -3262,19 +3288,24 @@ t_CKBOOL emit_engine_emit_exp_if( Chuck_Emitter * emit, a_Exp_If exp_if ) if( !ret ) return FALSE; + // push 0 + if (exp_if->cond->type->words() == 1) + emit->append( new Chuck_Instr_Reg_Push_Imm( zero_CK1WORD ) ); + else if (exp_if->cond->type->words() == 2) + emit->append( new Chuck_Instr_Reg_Push_Imm2( zero_CK2WORD ) ); + else if (exp_if->cond->type->words() == 4) + emit->append( new Chuck_Instr_Reg_Push_Imm4( zero_CK2WORD, + zero_CK2WORD ) ); + // type of the condition switch( exp_if->cond->type->xid ) { case te_int: - // push 0 - emit->append( new Chuck_Instr_Reg_Push_Imm( 0 ) ); op = new Chuck_Instr_Branch_Eq_int( 0 ); break; case te_float: case te_dur: case te_time: - // push 0 - emit->append( new Chuck_Instr_Reg_Push_Imm2( 0.0 ) ); op = new Chuck_Instr_Branch_Eq_double( 0 ); break; @@ -3494,11 +3525,11 @@ t_CKBOOL emit_engine_emit_exp_decl( Chuck_Emitter * emit, a_Exp_Decl decl, if( value->is_member ) { // zero out location in object, and leave addr on operand stack - if( type->size == 4 ) // ISSUE: 64-bit + if( type->words() == 1 ) // ISSUE: 64-bit emit->append( new Chuck_Instr_Alloc_Member_Word( value->offset ) ); - else if( type->size == 8 ) // ISSUE: 64-bit + else if( type->words() == 2 ) // ISSUE: 64-bit emit->append( new Chuck_Instr_Alloc_Member_Word2( value->offset ) ); - else if( type->size == 16 ) // ISSUE: 64-bit + else if( type->words() == 4 ) // ISSUE: 64-bit emit->append( new Chuck_Instr_Alloc_Member_Word4( value->offset ) ); else { @@ -3530,11 +3561,11 @@ t_CKBOOL emit_engine_emit_exp_decl( Chuck_Emitter * emit, a_Exp_Decl decl, // TODO: this is wrong for static // BAD: // FIX: - if( type->size == 4 ) // ISSUE: 64-bit + if( type->words() == 1 ) // ISSUE: 64-bit emit->append( new Chuck_Instr_Alloc_Word( local->offset ) ); - else if( type->size == 8 ) // ISSUE: 64-bit + else if( type->words() == 2 ) // ISSUE: 64-bit emit->append( new Chuck_Instr_Alloc_Word2( local->offset ) ); - else if( type->size == 16 ) // ISSUE: 64-bit + else if( type->words() == 4 ) // ISSUE: 64-bit emit->append( new Chuck_Instr_Alloc_Word4( local->offset ) ); else { @@ -4064,11 +4095,11 @@ t_CKBOOL emit_engine_emit_symbol( Chuck_Emitter * emit, S_Symbol symbol, if( v->func_ref ) emit->append( new Chuck_Instr_Reg_Push_Imm( (t_CKUINT)v->func_ref ) ); // check size - else if( v->type->size == 4 ) // ISSUE: 64-bit + else if( v->type->words() == 1 ) // ISSUE: 64-bit emit->append( new Chuck_Instr_Reg_Push_Mem( v->offset, v->is_context_global ) ); - else if( v->type->size == 8 ) // ISSUE: 64-bit + else if( v->type->words() == 2 ) // ISSUE: 64-bit emit->append( new Chuck_Instr_Reg_Push_Mem2( v->offset, v->is_context_global ) ); - else if( v->type->size == 16 ) // ISSUE: 64-bit + else if( v->type->words() == 4 ) // ISSUE: 64-bit emit->append( new Chuck_Instr_Reg_Push_Mem4( v->offset, v->is_context_global ) ); else { diff --git a/v2/chuck_instr.cpp b/v2/chuck_instr.cpp old mode 100755 new mode 100644 index d4e0c4a..48a162c --- a/v2/chuck_instr.cpp +++ b/v2/chuck_instr.cpp @@ -47,9 +47,6 @@ #include using namespace std; - - - //----------------------------------------------------------------------------- // name: name() // desc: ... @@ -1427,7 +1424,7 @@ done: //----------------------------------------------------------------------------- void Chuck_Instr_Reg_Push_Imm::execute( Chuck_VM * vm, Chuck_VM_Shred * shred ) { - t_CKUINT *& reg_sp = (t_CKUINT *&)shred->reg->sp; + t_CK1WORD *& reg_sp = (t_CK1WORD *&)shred->reg->sp; // push val into reg stack push_( reg_sp, m_val ); @@ -1442,7 +1439,7 @@ void Chuck_Instr_Reg_Push_Imm::execute( Chuck_VM * vm, Chuck_VM_Shred * shred ) //----------------------------------------------------------------------------- void Chuck_Instr_Reg_Push_Imm2::execute( Chuck_VM * vm, Chuck_VM_Shred * shred ) { - t_CKFLOAT *& reg_sp = (t_CKFLOAT *&)shred->reg->sp; + t_CK2WORD *& reg_sp = (t_CK2WORD *&)shred->reg->sp; // push val into reg stack push_( reg_sp, m_val ); @@ -1457,7 +1454,7 @@ void Chuck_Instr_Reg_Push_Imm2::execute( Chuck_VM * vm, Chuck_VM_Shred * shred ) //----------------------------------------------------------------------------- void Chuck_Instr_Reg_Push_Imm4::execute( Chuck_VM * vm, Chuck_VM_Shred * shred ) { - t_CKFLOAT *& reg_sp = (t_CKFLOAT *&)shred->reg->sp; + t_CK2WORD *& reg_sp = (t_CK2WORD *&)shred->reg->sp; // push val into reg stack push_( reg_sp, m_val ); @@ -1473,7 +1470,7 @@ void Chuck_Instr_Reg_Push_Imm4::execute( Chuck_VM * vm, Chuck_VM_Shred * shred ) //----------------------------------------------------------------------------- void Chuck_Instr_Reg_Dup_Last::execute( Chuck_VM * vm, Chuck_VM_Shred * shred ) { - t_CKUINT *& reg_sp = (t_CKUINT *&)shred->reg->sp; + t_CK1WORD *& reg_sp = (t_CK1WORD *&)shred->reg->sp; // dup val into reg stack push_( reg_sp, *(reg_sp-1) ); @@ -1488,7 +1485,7 @@ void Chuck_Instr_Reg_Dup_Last::execute( Chuck_VM * vm, Chuck_VM_Shred * shred ) //----------------------------------------------------------------------------- void Chuck_Instr_Reg_Dup_Last2::execute( Chuck_VM * vm, Chuck_VM_Shred * shred ) { - t_CKFLOAT *& reg_sp = (t_CKFLOAT *&)shred->reg->sp; + t_CK2WORD *& reg_sp = (t_CK2WORD *&)shred->reg->sp; // dup val into reg stack push_( reg_sp, *(reg_sp-1) ); @@ -1602,10 +1599,10 @@ void Chuck_Instr_Reg_Push_Deref::execute( Chuck_VM * vm, Chuck_VM_Shred * shred void Chuck_Instr_Reg_Push_Mem::execute( Chuck_VM * vm, Chuck_VM_Shred * shred ) { t_CKBYTE *& mem_sp = (t_CKBYTE *&)(base?shred->base_ref->stack:shred->mem->sp); - t_CKUINT *& reg_sp = (t_CKUINT *&)shred->reg->sp; + t_CK1WORD *& reg_sp = (t_CK1WORD *&)shred->reg->sp; // push mem stack content into reg stack - push_( reg_sp, *((t_CKUINT *)(mem_sp + m_val)) ); + push_( reg_sp, *((t_CK1WORD *)(mem_sp + m_val)) ); } @@ -1618,10 +1615,10 @@ void Chuck_Instr_Reg_Push_Mem::execute( Chuck_VM * vm, Chuck_VM_Shred * shred ) void Chuck_Instr_Reg_Push_Mem2::execute( Chuck_VM * vm, Chuck_VM_Shred * shred ) { t_CKBYTE *& mem_sp = (t_CKBYTE *&)(base?shred->base_ref->stack:shred->mem->sp); - t_CKFLOAT *& reg_sp = (t_CKFLOAT *&)shred->reg->sp; + t_CK2WORD *& reg_sp = (t_CK2WORD *&)shred->reg->sp; // push mem stack content into reg stack - push_( reg_sp, *((t_CKFLOAT *)(mem_sp + m_val)) ); + push_( reg_sp, *((t_CK2WORD *)(mem_sp + m_val)) ); } @@ -1634,10 +1631,10 @@ void Chuck_Instr_Reg_Push_Mem2::execute( Chuck_VM * vm, Chuck_VM_Shred * shred ) void Chuck_Instr_Reg_Push_Mem4::execute( Chuck_VM * vm, Chuck_VM_Shred * shred ) { t_CKBYTE *& mem_sp = (t_CKBYTE *&)(base?shred->base_ref->stack:shred->mem->sp); - t_CKCOMPLEX *& reg_sp = (t_CKCOMPLEX *&)shred->reg->sp; + t_CK4WORD *& reg_sp = (t_CK4WORD *&)shred->reg->sp; // push mem stack content into reg stack - push_( reg_sp, *((t_CKCOMPLEX *)(mem_sp + m_val)) ); + push_( reg_sp, *((t_CK4WORD *)(mem_sp + m_val)) ); } @@ -1650,10 +1647,10 @@ void Chuck_Instr_Reg_Push_Mem4::execute( Chuck_VM * vm, Chuck_VM_Shred * shred ) void Chuck_Instr_Reg_Push_Mem_Addr::execute( Chuck_VM * vm, Chuck_VM_Shred * shred ) { t_CKBYTE *& mem_sp = (t_CKBYTE *&)(base?shred->base_ref->stack:shred->mem->sp); - t_CKUINT *& reg_sp = (t_CKUINT *&)shred->reg->sp; + t_CKVOIDPTR *& reg_sp = (t_CKVOIDPTR *&)shred->reg->sp; // push mem stack addr into reg stack - push_( reg_sp, (t_CKUINT)(mem_sp + m_val) ); + push_( reg_sp, (t_CKVOIDPTR)(mem_sp + m_val) ); } @@ -1666,12 +1663,12 @@ void Chuck_Instr_Reg_Push_Mem_Addr::execute( Chuck_VM * vm, Chuck_VM_Shred * shr void Chuck_Instr_Reg_Pop_Mem::execute( Chuck_VM * vm, Chuck_VM_Shred * shred ) { t_CKBYTE *& mem_sp = (t_CKBYTE *&)shred->mem->sp; - t_CKUINT *& reg_sp = (t_CKUINT *&)shred->reg->sp; + t_CK1WORD *& reg_sp = (t_CK1WORD *&)shred->reg->sp; // pop word from reg stack pop_( reg_sp, 2 ); // copy popped value into mem stack - *((t_CKUINT *)(mem_sp + *(reg_sp+1) )) = *reg_sp; + *((t_CK1WORD *)(mem_sp + *(reg_sp+1) )) = *reg_sp; } @@ -1683,7 +1680,7 @@ void Chuck_Instr_Reg_Pop_Mem::execute( Chuck_VM * vm, Chuck_VM_Shred * shred ) //----------------------------------------------------------------------------- void Chuck_Instr_Reg_Pop_Word::execute( Chuck_VM * vm, Chuck_VM_Shred * shred ) { - t_CKUINT *& reg_sp = (t_CKUINT *&)shred->reg->sp; + t_CK1WORD *& reg_sp = (t_CK1WORD *&)shred->reg->sp; // pop word from reg stack pop_( reg_sp, 1 ); @@ -1698,7 +1695,7 @@ void Chuck_Instr_Reg_Pop_Word::execute( Chuck_VM * vm, Chuck_VM_Shred * shred ) //----------------------------------------------------------------------------- void Chuck_Instr_Reg_Pop_Word2::execute( Chuck_VM * vm, Chuck_VM_Shred * shred ) { - t_CKFLOAT *& reg_sp = (t_CKFLOAT *&)shred->reg->sp; + t_CK2WORD *& reg_sp = (t_CK2WORD *&)shred->reg->sp; // pop word from reg stack pop_( reg_sp, 1 ); @@ -1713,7 +1710,7 @@ void Chuck_Instr_Reg_Pop_Word2::execute( Chuck_VM * vm, Chuck_VM_Shred * shred ) //----------------------------------------------------------------------------- void Chuck_Instr_Reg_Pop_Word3::execute( Chuck_VM * vm, Chuck_VM_Shred * shred ) { - t_CKUINT *& reg_sp = (t_CKUINT *&)shred->reg->sp; + t_CK1WORD *& reg_sp = (t_CK1WORD *&)shred->reg->sp; // pop word from reg stack pop_( reg_sp, m_val ); @@ -1728,7 +1725,7 @@ void Chuck_Instr_Reg_Pop_Word3::execute( Chuck_VM * vm, Chuck_VM_Shred * shred ) //----------------------------------------------------------------------------- void Chuck_Instr_Mem_Set_Imm::execute( Chuck_VM * vm, Chuck_VM_Shred * shred ) { - t_CKUINT * mem_sp = (t_CKUINT *)(shred->mem->sp + m_offset); + t_CK1WORD * mem_sp = (t_CK1WORD *)(shred->mem->sp + m_offset); // set *(mem_sp) = m_val; @@ -1743,7 +1740,7 @@ void Chuck_Instr_Mem_Set_Imm::execute( Chuck_VM * vm, Chuck_VM_Shred * shred ) //----------------------------------------------------------------------------- void Chuck_Instr_Mem_Set_Imm2::execute( Chuck_VM * vm, Chuck_VM_Shred * shred ) { - t_CKFLOAT * mem_sp = (t_CKFLOAT *)(shred->mem->sp + m_offset); + t_CK2WORD * mem_sp = (t_CK2WORD *)(shred->mem->sp + m_offset); // set *(mem_sp) = m_val; @@ -1758,7 +1755,7 @@ void Chuck_Instr_Mem_Set_Imm2::execute( Chuck_VM * vm, Chuck_VM_Shred * shred ) //----------------------------------------------------------------------------- void Chuck_Instr_Mem_Push_Imm::execute( Chuck_VM * vm, Chuck_VM_Shred * shred ) { - t_CKUINT *& mem_sp = (t_CKUINT *&)shred->mem->sp; + t_CK1WORD *& mem_sp = (t_CK1WORD *&)shred->mem->sp; // pop word from reg stack push_( mem_sp, m_val ); @@ -1773,7 +1770,7 @@ void Chuck_Instr_Mem_Push_Imm::execute( Chuck_VM * vm, Chuck_VM_Shred * shred ) //----------------------------------------------------------------------------- void Chuck_Instr_Mem_Push_Imm2::execute( Chuck_VM * vm, Chuck_VM_Shred * shred ) { - t_CKFLOAT *& mem_sp = (t_CKFLOAT *&)shred->mem->sp; + t_CK2WORD *& mem_sp = (t_CK2WORD *&)shred->mem->sp; // pop word from reg stack push_( mem_sp, m_val ); @@ -1788,7 +1785,7 @@ void Chuck_Instr_Mem_Push_Imm2::execute( Chuck_VM * vm, Chuck_VM_Shred * shred ) //----------------------------------------------------------------------------- void Chuck_Instr_Mem_Pop_Word::execute( Chuck_VM * vm, Chuck_VM_Shred * shred ) { - t_CKUINT *& mem_sp = (t_CKUINT *&)shred->mem->sp; + t_CK1WORD *& mem_sp = (t_CK1WORD *&)shred->mem->sp; // pop word from reg stack pop_( mem_sp, 1 ); @@ -1803,7 +1800,7 @@ void Chuck_Instr_Mem_Pop_Word::execute( Chuck_VM * vm, Chuck_VM_Shred * shred ) //----------------------------------------------------------------------------- void Chuck_Instr_Mem_Pop_Word2::execute( Chuck_VM * vm, Chuck_VM_Shred * shred ) { - t_CKFLOAT *& mem_sp = (t_CKFLOAT *&)shred->mem->sp; + t_CK2WORD *& mem_sp = (t_CK2WORD *&)shred->mem->sp; // pop word from reg stack pop_( mem_sp, 1 ); @@ -1818,7 +1815,7 @@ void Chuck_Instr_Mem_Pop_Word2::execute( Chuck_VM * vm, Chuck_VM_Shred * shred ) //----------------------------------------------------------------------------- void Chuck_Instr_Mem_Pop_Word3::execute( Chuck_VM * vm, Chuck_VM_Shred * shred ) { - t_CKUINT *& mem_sp = (t_CKUINT *&)shred->mem->sp; + t_CK1WORD *& mem_sp = (t_CK1WORD *&)shred->mem->sp; // pop word from reg stack pop_( mem_sp, m_val ); @@ -2466,12 +2463,12 @@ void Chuck_Instr_EOC::execute( Chuck_VM * vm, Chuck_VM_Shred * shred ) void Chuck_Instr_Alloc_Word::execute( Chuck_VM * vm, Chuck_VM_Shred * shred ) { t_CKBYTE *& mem_sp = (t_CKBYTE *&)shred->mem->sp; - t_CKUINT *& reg_sp = (t_CKUINT *&)shred->reg->sp; + t_CKVOIDPTR *& reg_sp = (t_CKVOIDPTR *&)shred->reg->sp; // zero out the memory stack - *( (t_CKUINT *)(mem_sp + m_val) ) = 0; + *( (t_CK1WORD *)(mem_sp + m_val) ) = 0; // push addr onto operand stack - push_( reg_sp, (t_CKUINT)(mem_sp + m_val) ); + push_( reg_sp, (mem_sp + m_val) ); } @@ -2484,12 +2481,12 @@ void Chuck_Instr_Alloc_Word::execute( Chuck_VM * vm, Chuck_VM_Shred * shred ) void Chuck_Instr_Alloc_Word2::execute( Chuck_VM * vm, Chuck_VM_Shred * shred ) { t_CKBYTE *& mem_sp = (t_CKBYTE *&)shred->mem->sp; - t_CKUINT *& reg_sp = (t_CKUINT *&)shred->reg->sp; + t_CKVOIDPTR *& reg_sp = (t_CKVOIDPTR *&)shred->reg->sp; // zero out the memory stack - *( (t_CKFLOAT *)(mem_sp + m_val) ) = 0.0; + memset((mem_sp + m_val), 0, sizeof(t_CK2WORD)); // push addr onto operand stack - push_( reg_sp, (t_CKUINT)(mem_sp + m_val) ); + push_( reg_sp, (mem_sp + m_val) ); } @@ -2502,13 +2499,12 @@ void Chuck_Instr_Alloc_Word2::execute( Chuck_VM * vm, Chuck_VM_Shred * shred ) void Chuck_Instr_Alloc_Word4::execute( Chuck_VM * vm, Chuck_VM_Shred * shred ) { t_CKBYTE *& mem_sp = (t_CKBYTE *&)shred->mem->sp; - t_CKUINT *& reg_sp = (t_CKUINT *&)shred->reg->sp; + t_CKVOIDPTR *& reg_sp = (t_CKVOIDPTR *&)shred->reg->sp; // zero out the memory stack - ( (t_CKCOMPLEX *)(mem_sp + m_val) )->re = 0.0; - ( (t_CKCOMPLEX *)(mem_sp + m_val) )->im = 0.0; + memset((mem_sp + m_val), 0, sizeof(t_CK4WORD)); // push addr onto operand stack - push_( reg_sp, (t_CKUINT)(mem_sp + m_val) ); + push_( reg_sp, (mem_sp + m_val) ); } @@ -2520,15 +2516,15 @@ void Chuck_Instr_Alloc_Word4::execute( Chuck_VM * vm, Chuck_VM_Shred * shred ) //----------------------------------------------------------------------------- void Chuck_Instr_Alloc_Member_Word::execute( Chuck_VM * vm, Chuck_VM_Shred * shred ) { - t_CKUINT *& mem_sp = (t_CKUINT *&)shred->mem->sp; - t_CKUINT *& reg_sp = (t_CKUINT *&)shred->reg->sp; + t_CKVOIDPTR *& mem_sp = (t_CKVOIDPTR *&)shred->mem->sp; + t_CKVOIDPTR *& reg_sp = (t_CKVOIDPTR *&)shred->reg->sp; // get the object Chuck_Object * obj = (Chuck_Object *)*(mem_sp); // zero out the memory stack - *( (t_CKUINT *)(obj->data + m_val) ) = 0; + *( (t_CK1WORD *)(obj->data + m_val) ) = 0; // push addr onto operand stack - push_( reg_sp, (t_CKUINT)(obj->data + m_val) ); + push_( reg_sp, (obj->data + m_val) ); } @@ -2540,15 +2536,15 @@ void Chuck_Instr_Alloc_Member_Word::execute( Chuck_VM * vm, Chuck_VM_Shred * shr //----------------------------------------------------------------------------- void Chuck_Instr_Alloc_Member_Word2::execute( Chuck_VM * vm, Chuck_VM_Shred * shred ) { - t_CKUINT *& mem_sp = (t_CKUINT *&)shred->mem->sp; - t_CKUINT *& reg_sp = (t_CKUINT *&)shred->reg->sp; + t_CKVOIDPTR *& mem_sp = (t_CKVOIDPTR *&)shred->mem->sp; + t_CKVOIDPTR *& reg_sp = (t_CKVOIDPTR *&)shred->reg->sp; // get the object Chuck_Object * obj = (Chuck_Object *)*(mem_sp); // zero out the memory stack - *( (t_CKFLOAT *)(obj->data + m_val) ) = 0.0; + memset((obj->data + m_val), 0, sizeof(t_CK2WORD)); // push addr onto operand stack - push_( reg_sp, (t_CKUINT)(obj->data + m_val) ); + push_( reg_sp, (obj->data + m_val) ); } @@ -2560,16 +2556,15 @@ void Chuck_Instr_Alloc_Member_Word2::execute( Chuck_VM * vm, Chuck_VM_Shred * sh //----------------------------------------------------------------------------- void Chuck_Instr_Alloc_Member_Word4::execute( Chuck_VM * vm, Chuck_VM_Shred * shred ) { - t_CKUINT *& mem_sp = (t_CKUINT *&)shred->mem->sp; - t_CKUINT *& reg_sp = (t_CKUINT *&)shred->reg->sp; + t_CKVOIDPTR *& mem_sp = (t_CKVOIDPTR *&)shred->mem->sp; + t_CKVOIDPTR *& reg_sp = (t_CKVOIDPTR *&)shred->reg->sp; // get the object Chuck_Object * obj = (Chuck_Object *)*(mem_sp); // zero out the memory stack - ( (t_CKCOMPLEX *)(obj->data + m_val) )->re = 0.0; - ( (t_CKCOMPLEX *)(obj->data + m_val) )->im = 0.0; + memset((obj->data + m_val), 0, sizeof(t_CK4WORD)); // push addr onto operand stack - push_( reg_sp, (t_CKUINT)(obj->data + m_val) ); + push_( reg_sp, (obj->data + m_val) ); } @@ -2778,14 +2773,14 @@ error: inline void instantiate_object( Chuck_VM * vm, Chuck_VM_Shred * shred, Chuck_Type * type ) { - t_CKUINT *& reg_sp = (t_CKUINT *&)shred->reg->sp; + t_CKVOIDPTR *& reg_sp = (t_CKVOIDPTR *&)shred->reg->sp; // allocate the VM object Chuck_Object * object = instantiate_and_initialize_object( type, shred ); if( !object ) goto error; // push the pointer on the operand stack - push_( reg_sp, (t_CKUINT)object ); + push_( reg_sp, (t_CKVOIDPTR)object ); // call preconstructor // call_pre_constructor( vm, shred, object, type, stack_offset ); @@ -2848,7 +2843,7 @@ const char * Chuck_Instr_Pre_Ctor_Array_Top::params() const //----------------------------------------------------------------------------- void Chuck_Instr_Pre_Ctor_Array_Top::execute( Chuck_VM * vm, Chuck_VM_Shred * shred ) { - t_CKUINT *& reg_sp = (t_CKUINT *&)shred->reg->sp; + t_CKVOIDPTR *& reg_sp = (t_CKVOIDPTR *&)shred->reg->sp; // see if we are done with all elements in the array if( *(reg_sp-2) >= *(reg_sp-1) ) @@ -2869,7 +2864,9 @@ void Chuck_Instr_Pre_Ctor_Array_Top::execute( Chuck_VM * vm, Chuck_VM_Shred * sh //----------------------------------------------------------------------------- void Chuck_Instr_Pre_Ctor_Array_Bottom::execute( Chuck_VM * vm, Chuck_VM_Shred * shred ) { - t_CKUINT *& reg_sp = (t_CKUINT *&)shred->reg->sp; + t_CKVOIDPTR *& reg_sp = (t_CKVOIDPTR *&)shred->reg->sp; + t_CKUINT *& reg_sp_uint = (t_CKUINT *&)shred->reg->sp; + t_CKBYTE *& reg_sp_byte = (t_CKBYTE *&)shred->reg->sp; // pop the object pop_( reg_sp, 1 ); @@ -2878,15 +2875,16 @@ void Chuck_Instr_Pre_Ctor_Array_Bottom::execute( Chuck_VM * vm, Chuck_VM_Shred * Chuck_Object * obj = (Chuck_Object *)(*(reg_sp)); // assign object - t_CKUINT * array = (t_CKUINT *)(*(reg_sp-3)); + t_CKVOIDPTR * array = (*(t_CKVOIDPTR**) + (reg_sp_byte-sz_UINT*2-sz_VOIDPTR)); // get the object pointer - Chuck_Object ** dest = (Chuck_Object **)(array[*(reg_sp-2)]); + Chuck_Object ** dest = (Chuck_Object **)(array[*(reg_sp_uint-2)]); // copy *dest = obj; // ref count obj->add_ref(); // increment the index - (*(reg_sp-2))++; //= (*(reg_sp-2)) + 1; + (*(reg_sp_uint-2))++; //= (*(reg_sp-2)) + 1; // goto top shred->next_pc = m_val; @@ -2901,13 +2899,13 @@ void Chuck_Instr_Pre_Ctor_Array_Bottom::execute( Chuck_VM * vm, Chuck_VM_Shred * //----------------------------------------------------------------------------- void Chuck_Instr_Pre_Ctor_Array_Post::execute( Chuck_VM * vm, Chuck_VM_Shred * shred ) { - t_CKUINT *& reg_sp = (t_CKUINT *&)shred->reg->sp; + t_CKVOIDPTR *& reg_sp = (t_CKVOIDPTR *&)shred->reg->sp; // pop the array, index, and size pop_( reg_sp, 3 ); // clean up the array - t_CKUINT * arr = (t_CKUINT *)*reg_sp; + t_CKVOIDPTR * arr = (t_CKVOIDPTR *)*reg_sp; SAFE_DELETE_ARRAY( arr ); } @@ -2920,12 +2918,12 @@ void Chuck_Instr_Pre_Ctor_Array_Post::execute( Chuck_VM * vm, Chuck_VM_Shred * s //----------------------------------------------------------------------------- void Chuck_Instr_Assign_Primitive::execute( Chuck_VM * vm, Chuck_VM_Shred * shred ) { - t_CKUINT *& reg_sp = (t_CKUINT *&)shred->reg->sp; + t_CK1WORD *& reg_sp = (t_CK1WORD *&)shred->reg->sp; // pop word from reg stack pop_( reg_sp, 2 ); // copy popped value into mem stack - *((t_CKUINT *)(*(reg_sp+1))) = *reg_sp; + *((t_CK1WORD *)(*(reg_sp+1))) = *reg_sp; push_( reg_sp, *reg_sp ); } @@ -2939,14 +2937,14 @@ void Chuck_Instr_Assign_Primitive::execute( Chuck_VM * vm, Chuck_VM_Shred * shre //----------------------------------------------------------------------------- void Chuck_Instr_Assign_Primitive2::execute( Chuck_VM * vm, Chuck_VM_Shred * shred ) { - t_CKUINT *& reg_sp = (t_CKUINT *&)shred->reg->sp; + t_CK1WORD *& reg_sp = (t_CK1WORD *&)shred->reg->sp; // pop word from reg stack // ISSUE: 64-bit pop_( reg_sp, 3 ); // copy popped value into mem stack - *( (t_CKFLOAT *)(*(reg_sp+2)) ) = *(t_CKFLOAT *)reg_sp; + *( (t_CK2WORD *)(*(reg_sp+2)) ) = *(t_CK2WORD *)reg_sp; - t_CKFLOAT *& sp_double = (t_CKFLOAT *&)reg_sp; + t_CK2WORD *& sp_double = (t_CK2WORD *&)reg_sp; push_( sp_double, *sp_double ); } @@ -2959,15 +2957,15 @@ void Chuck_Instr_Assign_Primitive2::execute( Chuck_VM * vm, Chuck_VM_Shred * shr //----------------------------------------------------------------------------- void Chuck_Instr_Assign_Primitive4::execute( Chuck_VM * vm, Chuck_VM_Shred * shred ) { - t_CKUINT *& reg_sp = (t_CKUINT *&)shred->reg->sp; + t_CK1WORD *& reg_sp = (t_CK1WORD *&)shred->reg->sp; // pop word from reg stack pop_( reg_sp, 5 ); // copy popped value into mem stack - *( (t_CKCOMPLEX*)(*(reg_sp+4)) ) = *(t_CKCOMPLEX *)reg_sp; + *( (t_CK4WORD*)(*(reg_sp+4)) ) = *(t_CK4WORD *)reg_sp; - t_CKCOMPLEX *& sp_complex = (t_CKCOMPLEX *&)reg_sp; - push_( sp_complex, *sp_complex ); + t_CK4WORD *& sp_4word = (t_CK4WORD *&)reg_sp; + push_( sp_4word, *sp_4word ); } @@ -2979,7 +2977,7 @@ void Chuck_Instr_Assign_Primitive4::execute( Chuck_VM * vm, Chuck_VM_Shred * shr //----------------------------------------------------------------------------- void Chuck_Instr_Assign_Object::execute( Chuck_VM * vm, Chuck_VM_Shred * shred ) { - t_CKUINT *& reg_sp = (t_CKUINT *&)shred->reg->sp; + t_CKVOIDPTR *& reg_sp = (t_CKVOIDPTR *&)shred->reg->sp; Chuck_VM_Object ** obj = NULL, * done = NULL; // pop word from reg stack @@ -2998,7 +2996,7 @@ void Chuck_Instr_Assign_Object::execute( Chuck_VM * vm, Chuck_VM_Shred * shred ) // copy // memcpy( (void *)*(reg_sp+1), *obj, sizeof(t_CKUINT) ); // push the reference value to reg stack - push_( reg_sp, (t_CKUINT)*obj ); + push_( reg_sp, *obj ); } @@ -3010,7 +3008,7 @@ void Chuck_Instr_Assign_Object::execute( Chuck_VM * vm, Chuck_VM_Shred * shred ) //----------------------------------------------------------------------------- void Chuck_Instr_Assign_String::execute( Chuck_VM * vm, Chuck_VM_Shred * shred ) { - t_CKUINT *& reg_sp = (t_CKUINT *&)shred->reg->sp; + t_CKVOIDPTR *& reg_sp = (t_CKVOIDPTR *&)shred->reg->sp; Chuck_String * lhs = NULL; Chuck_String ** rhs_ptr = NULL; @@ -3050,7 +3048,7 @@ void Chuck_Instr_Assign_String::execute( Chuck_VM * vm, Chuck_VM_Shred * shred ) // copy // memcpy( (void *)*(reg_sp+1), *obj, sizeof(t_CKUINT) ); // push the reference value to reg stack - push_( reg_sp, (t_CKUINT)*rhs_ptr ); + push_( reg_sp, *rhs_ptr ); } @@ -3083,14 +3081,14 @@ void Chuck_Instr_Chuck_Release_Object::execute( Chuck_VM * vm, Chuck_VM_Shred * //----------------------------------------------------------------------------- void Chuck_Instr_Func_To_Code::execute( Chuck_VM * vm, Chuck_VM_Shred * shred ) { - t_CKUINT *& reg_sp = (t_CKUINT *&)shred->reg->sp; + t_CKVOIDPTR *& reg_sp = (t_CKVOIDPTR *&)shred->reg->sp; // get func Chuck_Func * func = (Chuck_Func *)*(reg_sp-1); // make sure assert( func != NULL ); // code - *(reg_sp-1) = (t_CKUINT)func->code; + *(reg_sp-1) = func->code; } @@ -3111,12 +3109,12 @@ void Chuck_Instr_Func_Call::execute( Chuck_VM * vm, Chuck_VM_Shred * shred ) Chuck_VM_Code * func = (Chuck_VM_Code *)*reg_sp; // get the local stack depth - caller local variables t_CKUINT local_depth = *(reg_sp+1); - // convert to number of 4-byte words, extra partial word counts as additional word - local_depth = ( local_depth >> 2 ) + ( local_depth & 0x3 ? 1 : 0 ); + // convert to number of words, extra partial word counts as additional word + local_depth = ( local_depth / sz_INT ) + ( local_depth & (sz_INT-1) ? 1 : 0 ); // get the stack depth of the callee function args - t_CKUINT stack_depth = ( func->stack_depth >> 2 ) + ( func->stack_depth & 0x3 ? 1 : 0 ); + t_CKUINT stack_depth = ( func->stack_depth / sz_INT ) + ( func->stack_depth & (sz_INT-1) ? 1 : 0 ); // get the previous stack depth - caller function args - t_CKUINT prev_stack = ( *(mem_sp-1) >> 2 ) + ( *(mem_sp-1) & 0x3 ? 1 : 0 ); + t_CKUINT prev_stack = ( *(mem_sp-1) / sz_INT ) + ( *(mem_sp-1) & (sz_INT-1) ? 1 : 0 ); // jump the sp mem_sp += prev_stack + local_depth; @@ -3190,13 +3188,13 @@ void Chuck_Instr_Func_Call_Member::execute( Chuck_VM * vm, Chuck_VM_Shred * shre // MOVED TO BELOW: f_mfun f = (f_mfun)func->native_func; // get the local stack depth - caller local variables t_CKUINT local_depth = *(reg_sp+1); - // convert to number of 4-byte words, extra partial word counts as additional word - local_depth = ( local_depth >> 2 ) + ( local_depth & 0x3 ? 1 : 0 ); + // convert to number of words, extra partial word counts as additional word + local_depth = ( local_depth / sz_INT ) + ( local_depth & (sz_INT-1) ? 1 : 0 ); // get the stack depth of the callee function args - t_CKUINT stack_depth = ( func->stack_depth >> 2 ) + ( func->stack_depth & 0x3 ? 1 : 0 ); + t_CKUINT stack_depth = ( func->stack_depth / sz_INT ) + ( func->stack_depth & (sz_INT-1) ? 1 : 0 ); // UNUSED: get the previous stack depth - caller function args - // UNUSED: t_CKUINT prev_stack = ( *(mem_sp-1) >> 2 ) + ( *(mem_sp-1) & 0x3 ? 1 : 0 ); - // the amount to push in 4-byte words + // UNUSED: t_CKUINT prev_stack = ( *(mem_sp-1) / sz_INT ) + ( *(mem_sp-1) & (sz_INT-1) ? 1 : 0 ); + // the amount to push in words t_CKUINT push = local_depth; // push the mem stack passed the current function variables and arguments mem_sp += push; @@ -3246,18 +3244,19 @@ void Chuck_Instr_Func_Call_Member::execute( Chuck_VM * vm, Chuck_VM_Shred * shre mem_sp -= push; // push the return - if( m_val == 4 ) // ISSUE: 64-bit + if( m_val == sz_INT ) { // push the return args + // note: on 64-bit this might be a double push_( reg_sp, retval.v_uint ); } - else if( m_val == 8 ) // ISSUE: 64-bit + else if( m_val == sz_FLOAT ) { // push the return args t_CKFLOAT *& sp_double = (t_CKFLOAT *&)reg_sp; push_( sp_double, retval.v_float ); } - else if( m_val == 16 ) // ISSUE: 64-bit + else if( m_val == sz_COMPLEX ) { // push the return args t_CKCOMPLEX *& sp_complex = (t_CKCOMPLEX *&)reg_sp; @@ -3295,13 +3294,13 @@ void Chuck_Instr_Func_Call_Static::execute( Chuck_VM * vm, Chuck_VM_Shred * shre f_sfun f = (f_sfun)func->native_func; // get the local stack depth - caller local variables t_CKUINT local_depth = *(reg_sp+1); - // convert to number of 4-byte words, extra partial word counts as additional word - local_depth = ( local_depth >> 2 ) + ( local_depth & 0x3 ? 1 : 0 ); + // convert to number of words, extra partial word counts as additional word + local_depth = ( local_depth / sz_INT ) + ( local_depth & (sz_INT-1) ? 1 : 0 ); // get the stack depth of the callee function args - t_CKUINT stack_depth = ( func->stack_depth >> 2 ) + ( func->stack_depth & 0x3 ? 1 : 0 ); + t_CKUINT stack_depth = ( func->stack_depth / sz_INT ) + ( func->stack_depth & (sz_INT-1) ? 1 : 0 ); // UNUSED: get the previous stack depth - caller function args - // UNUSED: t_CKUINT prev_stack = ( *(mem_sp-1) >> 2 ) + ( *(mem_sp-1) & 0x3 ? 1 : 0 ); - // the amount to push in 4-byte words + // UNUSED: t_CKUINT prev_stack = ( *(mem_sp-1) / sz_INT ) + ( *(mem_sp-1) & (sz_INT-1) ? 1 : 0 ); + // the amount to push in words t_CKUINT push = local_depth; // push the mem stack passed the current function variables and arguments mem_sp += push; @@ -3339,18 +3338,19 @@ void Chuck_Instr_Func_Call_Static::execute( Chuck_VM * vm, Chuck_VM_Shred * shre mem_sp -= push; // push the return - if( m_val == 4 ) // ISSUE: 64-bit + if( m_val == sz_INT ) { // push the return args + // note: on 64-bit this might be a double push_( reg_sp, retval.v_uint ); } - else if( m_val == 8 ) // ISSUE: 64-bit + else if( m_val == sz_FLOAT ) { // push the return args t_CKFLOAT *& sp_double = (t_CKFLOAT *&)reg_sp; push_( sp_double, retval.v_float ); } - else if( m_val == 16 ) // ISSUE: 64-bit + else if( m_val == sz_COMPLEX ) { // push the return args t_CKCOMPLEX *& sp_complex = (t_CKCOMPLEX *&)reg_sp; @@ -3404,8 +3404,8 @@ void Chuck_Instr_Func_Return::execute( Chuck_VM * vm, Chuck_VM_Shred * shred ) //----------------------------------------------------------------------------- void Chuck_Instr_Spork::execute( Chuck_VM * vm, Chuck_VM_Shred * shred ) { - t_CKUINT *& reg_sp = (t_CKUINT *&)shred->reg->sp; - t_CKUINT this_ptr = 0; + t_CKVOIDPTR *& reg_sp = (t_CKVOIDPTR *&)shred->reg->sp; + t_CKVOIDPTR this_ptr = 0; // pop the stack pop_( reg_sp, 1 ); @@ -3435,12 +3435,12 @@ void Chuck_Instr_Spork::execute( Chuck_VM * vm, Chuck_VM_Shred * shred ) // copy this, if need if( func->is_member ) { - push_( (t_CKUINT*&)sh->reg->sp, this_ptr ); + push_( (t_CKVOIDPTR*&)sh->reg->sp, this_ptr ); } // copy func - push_( (t_CKUINT*&)sh->reg->sp, (t_CKUINT)func ); + push_( (t_CKVOIDPTR*&)sh->reg->sp, func ); // push the stack - push_( reg_sp, (t_CKUINT)sh ); + push_( reg_sp, sh ); } @@ -4410,9 +4410,9 @@ done: void Chuck_Instr_Dot_Member_Data::execute( Chuck_VM * vm, Chuck_VM_Shred * shred ) { // register stack pointer - t_CKUINT *& sp = (t_CKUINT *&)shred->reg->sp; + t_CKVOIDPTR *& sp = (t_CKVOIDPTR *&)shred->reg->sp; // the pointer - t_CKUINT data; + t_CKVOIDPTR data; // pop the object pointer pop_( sp, 1 ); @@ -4421,7 +4421,7 @@ void Chuck_Instr_Dot_Member_Data::execute( Chuck_VM * vm, Chuck_VM_Shred * shred // check if( !obj ) goto error; // calculate the data pointer - data = (t_CKUINT)(obj->data + m_offset); + data = (obj->data + m_offset); // emit addr or value if( m_emit_addr ) @@ -4431,10 +4431,12 @@ void Chuck_Instr_Dot_Member_Data::execute( Chuck_VM * vm, Chuck_VM_Shred * shred } else { - // 4 or 8 or 16 - if( m_size == 4 ) { push_( sp, *((t_CKUINT *)data) ); } // ISSUE: 64-bit - else if( m_size == 8 ) { push_float( sp, *((t_CKFLOAT *)data) ); } // ISSUE: 64-bit - else if( m_size == 16 ) { push_complex( sp, *((t_CKCOMPLEX *)data) ); } // ISSUE: 64-bit // TODO: polar same? + // type size (on 64-bit, sz_INT==sz_FLOAT!) + if( m_size == sz_INT ) { + t_CKUINT *& sp = (t_CKUINT *&)shred->reg->sp; + push_( sp, *((t_CKUINT *)data) ); } + else if( m_size == sz_FLOAT ) { push_float( sp, *((t_CKFLOAT *)data) ); } + else if( m_size == sz_COMPLEX ) { push_complex( sp, *((t_CKCOMPLEX *)data) ); } // TODO: polar same? else assert( FALSE ); } @@ -4461,9 +4463,9 @@ error: void Chuck_Instr_Dot_Member_Func::execute( Chuck_VM * vm, Chuck_VM_Shred * shred ) { // register stack pointer - t_CKUINT *& sp = (t_CKUINT *&)shred->reg->sp; + t_CKVOIDPTR *& sp = (t_CKVOIDPTR *&)shred->reg->sp; // the pointer - t_CKUINT data; + t_CKVOIDPTR data; // pop the object pointer pop_( sp, 1 ); @@ -4474,7 +4476,7 @@ void Chuck_Instr_Dot_Member_Func::execute( Chuck_VM * vm, Chuck_VM_Shred * shred // make sure we are in range assert( m_offset < obj->vtable->funcs.size() ); // calculate the data pointer - data = (t_CKUINT)(obj->vtable->funcs[m_offset]); + data = (obj->vtable->funcs[m_offset]); // push the address push_( sp, data ); @@ -4502,9 +4504,9 @@ error: void Chuck_Instr_Dot_Static_Data::execute( Chuck_VM * vm, Chuck_VM_Shred * shred ) { // register stack pointer - t_CKUINT *& sp = (t_CKUINT *&)shred->reg->sp; + t_CKVOIDPTR *& sp = (t_CKVOIDPTR *&)shred->reg->sp; // the pointer - t_CKUINT data; + t_CKVOIDPTR data; // pop the type pointer pop_( sp, 1 ); @@ -4513,7 +4515,7 @@ void Chuck_Instr_Dot_Static_Data::execute( Chuck_VM * vm, Chuck_VM_Shred * shred // make sure assert( (m_offset + m_size) <= t_class->info->class_data_size ); // calculate the data pointer - data = (t_CKUINT)(t_class->info->class_data + m_offset); + data = (t_class->info->class_data + m_offset); // emit addr or value if( m_emit_addr ) @@ -4523,10 +4525,12 @@ void Chuck_Instr_Dot_Static_Data::execute( Chuck_VM * vm, Chuck_VM_Shred * shred } else { - // 4 or 8 or 16 - if( m_size == 4 ) { push_( sp, *((t_CKUINT *)data) ); } // ISSUE: 64-bit - else if( m_size == 8 ) { push_float( sp, *((t_CKFLOAT *)data) ); } // ISSUE: 64-bit - else if( m_size == 16 ) { push_complex( sp, *((t_CKCOMPLEX *)data) ); } // ISSUE: 64-bit // TODO: polar same? + // type size (on 64-bit, sz_INT==sz_FLOAT!) + if( m_size == sz_INT ) { + t_CKINT *& sp = (t_CKINT *&)shred->reg->sp; + push_( sp, *((t_CKUINT *)data) ); } + else if( m_size == sz_FLOAT ) { push_float( sp, *((t_CKFLOAT *)data) ); } + else if( m_size == sz_COMPLEX ) { push_complex( sp, *((t_CKCOMPLEX *)data) ); } // TODO: polar same? else assert( FALSE ); } } @@ -4541,20 +4545,22 @@ void Chuck_Instr_Dot_Static_Data::execute( Chuck_VM * vm, Chuck_VM_Shred * shred void Chuck_Instr_Dot_Static_Import_Data::execute( Chuck_VM * vm, Chuck_VM_Shred * shred ) { // register stack pointer - t_CKUINT *& sp = (t_CKUINT *&)shred->reg->sp; + t_CKVOIDPTR *& sp = (t_CKVOIDPTR *&)shred->reg->sp; // emit addr or value if( m_emit_addr ) { // push the address - push_( sp, (t_CKUINT)m_addr ); + push_( sp, m_addr ); } else { - // 4 or 8 or 16 - if( m_size == 4 ) { push_( sp, *((t_CKUINT *)m_addr) ); } // ISSUE: 64-bit - else if( m_size == 8 ) { push_float( sp, *((t_CKFLOAT *)m_addr) ); } // ISSUE: 64-bit - else if( m_size == 16 ) { push_complex( sp, *((t_CKCOMPLEX *)m_addr) ); } // ISSUE: 64-bit // TODO: polar same? + // type size (on 64-bit, sz_INT==sz_FLOAT!) + if( m_size == sz_INT ) { + t_CKUINT *& sp = (t_CKUINT *&)shred->reg->sp; + push_( sp, *((t_CKUINT *)m_addr) ); } + else if( m_size == sz_FLOAT ) { push_float( sp, *((t_CKFLOAT *)m_addr) ); } + else if( m_size == sz_COMPLEX ) { push_complex( sp, *((t_CKCOMPLEX *)m_addr) ); } // TODO: polar same? else assert( FALSE ); } } @@ -4569,13 +4575,13 @@ void Chuck_Instr_Dot_Static_Import_Data::execute( Chuck_VM * vm, Chuck_VM_Shred void Chuck_Instr_Dot_Static_Func::execute( Chuck_VM * vm, Chuck_VM_Shred * shred ) { // register stack pointer - t_CKUINT *& sp = (t_CKUINT *&)shred->reg->sp; + t_CKVOIDPTR *& sp = (t_CKVOIDPTR *&)shred->reg->sp; // pop the type pointer pop_( sp, 1 ); // push the address - push_( sp, (t_CKUINT)(m_func) ); + push_( sp, (m_func) ); } @@ -4591,13 +4597,13 @@ void Chuck_Instr_Dot_Cmp_First::execute( Chuck_VM * vm, Chuck_VM_Shred * shred ) if( m_is_mem ) { // stack - t_CKUINT *& sp = (t_CKUINT *&)shred->reg->sp; + t_CKVOIDPTR *& sp = (t_CKVOIDPTR *&)shred->reg->sp; // pop pop_( sp, 1 ); // push the addr on if( m_emit_addr ) { t_CKFLOAT a = (*(t_CKCOMPLEX **)sp)->re; - push_( sp, (t_CKUINT)(&((*(t_CKCOMPLEX **)sp)->re)) ); + push_( sp, (&((*(t_CKCOMPLEX **)sp)->re)) ); } else { push_float( sp, (*(t_CKCOMPLEX **)sp)->re ); } @@ -4630,12 +4636,12 @@ void Chuck_Instr_Dot_Cmp_Second::execute( Chuck_VM * vm, Chuck_VM_Shred * shred if( m_is_mem ) { // stack - t_CKUINT *& sp = (t_CKUINT *&)shred->reg->sp; + t_CKVOIDPTR *& sp = (t_CKVOIDPTR *&)shred->reg->sp; // pop pop_( sp, 1 ); // push the addr on if( m_emit_addr ) { - push_( sp, (t_CKUINT)(&((*(t_CKCOMPLEX **)sp)->im)) ); + push_( sp, (&((*(t_CKCOMPLEX **)sp)->im)) ); } else { push_float( sp, (*(t_CKCOMPLEX **)sp)->im ); } @@ -4800,7 +4806,7 @@ void Chuck_Instr_Cast_polar2complex::execute( Chuck_VM * vm, Chuck_VM_Shred * sh //----------------------------------------------------------------------------- void Chuck_Instr_Cast_object2string::execute( Chuck_VM * vm, Chuck_VM_Shred * shred ) { - t_CKUINT *& sp = (t_CKUINT *&)shred->reg->sp; + t_CKVOIDPTR *& sp = (t_CKVOIDPTR *&)shred->reg->sp; // pop it pop_( sp, 1 ); // object @@ -4811,7 +4817,7 @@ void Chuck_Instr_Cast_object2string::execute( Chuck_VM * vm, Chuck_VM_Shred * sh object_toString( obj, NULL, &RETURN, NULL ); Chuck_String * str = RETURN.v_string; // set it - push_( sp, (t_CKUINT)str ); + push_( sp, str ); } @@ -4898,8 +4904,8 @@ done: //----------------------------------------------------------------------------- void Chuck_Instr_ADC::execute( Chuck_VM * vm, Chuck_VM_Shred * shred ) { - t_CKUINT *& reg_sp = (t_CKUINT *&)shred->reg->sp; - push_( reg_sp, (t_CKUINT)vm->m_adc ); + t_CKVOIDPTR *& reg_sp = (t_CKVOIDPTR *&)shred->reg->sp; + push_( reg_sp, vm->m_adc ); } @@ -4911,8 +4917,8 @@ void Chuck_Instr_ADC::execute( Chuck_VM * vm, Chuck_VM_Shred * shred ) //----------------------------------------------------------------------------- void Chuck_Instr_DAC::execute( Chuck_VM * vm, Chuck_VM_Shred * shred ) { - t_CKUINT *& reg_sp = (t_CKUINT *&)shred->reg->sp; - push_( reg_sp, (t_CKUINT)vm->m_dac ); + t_CKVOIDPTR *& reg_sp = (t_CKVOIDPTR *&)shred->reg->sp; + push_( reg_sp, vm->m_dac ); } @@ -4924,8 +4930,8 @@ void Chuck_Instr_DAC::execute( Chuck_VM * vm, Chuck_VM_Shred * shred ) //----------------------------------------------------------------------------- void Chuck_Instr_Bunghole::execute( Chuck_VM * vm, Chuck_VM_Shred * shred ) { - t_CKUINT *& reg_sp = (t_CKUINT *&)shred->reg->sp; - push_( reg_sp, (t_CKUINT)vm->m_bunghole ); + t_CKVOIDPTR *& reg_sp = (t_CKVOIDPTR *&)shred->reg->sp; + push_( reg_sp, vm->m_bunghole ); } @@ -5202,22 +5208,25 @@ Chuck_Instr_Hack::~Chuck_Instr_Hack() void Chuck_Instr_Hack::execute( Chuck_VM * vm, Chuck_VM_Shred * shred ) { // look at the type - if( m_type_ref->size == 4 ) // ISSUE: 64-bit + if( isa( m_type_ref, &t_int ) ) { t_CKINT * sp = (t_CKINT *)shred->reg->sp; - if( !isa( m_type_ref, &t_string ) ) - // print it - fprintf( stderr, "%d :(%s)\n", *(sp-1), m_type_ref->c_name() ); - else - fprintf( stderr, "\"%s\" : (%s)\n", ((Chuck_String *)*(sp-1))->str.c_str(), m_type_ref->c_name() ); + if( m_type_ref->size == 4 ) + fprintf(stderr, "%d :(%s)\n", *(sp-1), m_type_ref->c_name() ); + else if( m_type_ref->size == 8 ) + fprintf(stderr, "%ld :(%s)\n", *(sp-1), m_type_ref->c_name() ); } - else if( m_type_ref->size == 8 ) // ISSUE: 64-bit + else if( isa( m_type_ref, &t_float ) ) { t_CKFLOAT * sp = (t_CKFLOAT *)shred->reg->sp; - // print it fprintf( stderr, "%f :(%s)\n", *(sp-1), m_type_ref->c_name() ); } - else if( m_type_ref->size == 16 ) // ISSUE: 64-bit + else if( isa( m_type_ref, &t_string ) ) + { + t_CKVOIDPTR * sp = (t_CKVOIDPTR *)shred->reg->sp; + fprintf( stderr, "\"%s\" : (%s)\n", ((Chuck_String *)*(sp-1))->str.c_str(), m_type_ref->c_name() ); + } + else if( m_type_ref->size == sz_COMPLEX ) // ISSUE: 64-bit { if( m_type_ref->xid == te_complex ) { @@ -5297,42 +5306,34 @@ void Chuck_Instr_Gack::execute( Chuck_VM * vm, Chuck_VM_Shred * shred ) Chuck_Type * type = m_type_refs[i]; // look at the type - if( type->size == 4 ) // ISSUE: 64-bit + if( type->words() == 1 ) { t_CKINT * sp = (t_CKINT *)the_sp; - if( !isa( type, &t_string ) ) - { - if( isa( type, &t_object ) ) - // print it - fprintf( stderr, "0x%x ", *(sp) ); - else - // print it - fprintf( stderr, "%d ", *(sp) ); - } - else + if( isa( type, &t_string ) ) + // print it fprintf( stderr, "%s ", ((Chuck_String *)*(sp))->str.c_str() ); - - the_sp += 4; - } - else if( type->size == 8 ) // ISSUE: 64-bit - { - t_CKFLOAT * sp = (t_CKFLOAT *)the_sp; - // print it - fprintf( stderr, "%f ", *(sp) ); - - the_sp += 8; + else if( isa( type, &t_object ) ) + // print it + fprintf( stderr, "0x%x ", *(sp) ); + else if( isa( type, &t_float ) ) + // print it + fprintf( stderr, "%f ", *((t_CKFLOAT*)sp) ); + else + // print it + fprintf( stderr, "%d ", *(sp) ); } - else if( type->size == 16 ) // ISSUE: 64-bit + else if( type->words() == 2 || type->words() == 4 ) { t_CKFLOAT * sp = (t_CKFLOAT *)the_sp; - if( type->xid == te_complex ) + if( isa( type, &t_float ) ) + // print it + fprintf( stderr, "%f ", *(sp) ); + else if( type->xid == te_complex ) // print it fprintf( stderr, "#(%.4f,%.4f) ", *(sp), *(sp+1) ); else if( type->xid == te_polar ) // print it fprintf( stderr, "%%(%.4f,%.4f*pi) ", *(sp), *(sp+1)/ONE_PI ); - - the_sp += 16; } else if( type->size == 0 ) { @@ -5340,6 +5341,8 @@ void Chuck_Instr_Gack::execute( Chuck_VM * vm, Chuck_VM_Shred * shred ) } else assert( FALSE ); + + the_sp += type->size; } fprintf( stderr, "\n" ); diff --git a/v2/chuck_instr.h b/v2/chuck_instr.h index 6c5b50b..7008ea7 100755 --- a/v2/chuck_instr.h +++ b/v2/chuck_instr.h @@ -116,15 +116,15 @@ protected: struct Chuck_Instr_Unary_Op2 : public Chuck_Instr { public: - inline void set( t_CKFLOAT val ) { m_val = val; } - inline t_CKFLOAT get() { return m_val; } + inline void set( t_CK2WORD val ) { m_val = val; } + inline t_CK2WORD get() { return m_val; } public: virtual const char * params() const { static char buffer[256]; sprintf( buffer, "%.6f", m_val ); return buffer; } protected: - t_CKFLOAT m_val; + t_CK2WORD m_val; }; @@ -1556,7 +1556,7 @@ public: struct Chuck_Instr_Reg_Push_Imm : public Chuck_Instr_Unary_Op { public: - Chuck_Instr_Reg_Push_Imm( t_CKUINT val ) + Chuck_Instr_Reg_Push_Imm( t_CK1WORD val ) { this->set( val ); } public: @@ -1568,12 +1568,12 @@ public: //----------------------------------------------------------------------------- // name: struct Chuck_Instr_Reg_Push_Imm2 -// desc: push t_CKFLOAT immediate to reg stack +// desc: push a 2-word immediate to reg stack //----------------------------------------------------------------------------- struct Chuck_Instr_Reg_Push_Imm2 : public Chuck_Instr_Unary_Op2 { public: - Chuck_Instr_Reg_Push_Imm2( t_CKFLOAT val ) + Chuck_Instr_Reg_Push_Imm2( t_CK2WORD val ) { this->set( val ); } public: @@ -1585,19 +1585,19 @@ public: //----------------------------------------------------------------------------- // name: struct Chuck_Instr_Reg_Push_Imm4 -// desc: push t_CKCOMPLEX immediate to reg stack +// desc: push a 4-word immediate to reg stack //----------------------------------------------------------------------------- struct Chuck_Instr_Reg_Push_Imm4 : public Chuck_Instr_Unary_Op2 { public: - Chuck_Instr_Reg_Push_Imm4( t_CKFLOAT x, t_CKFLOAT y ) + Chuck_Instr_Reg_Push_Imm4( t_CK2WORD x, t_CK2WORD y ) { this->set( x ); m_val2 = y; } public: virtual void execute( Chuck_VM * vm, Chuck_VM_Shred * shred ); protected: - t_CKFLOAT m_val2; + t_CK2WORD m_val2; }; @@ -1819,7 +1819,7 @@ public: struct Chuck_Instr_Reg_Push_Deref2 : public Chuck_Instr_Unary_Op2 { public: - Chuck_Instr_Reg_Push_Deref2( t_CKFLOAT src ) + Chuck_Instr_Reg_Push_Deref2( t_CK2WORD src ) { this->set( src ); } public: @@ -1861,7 +1861,7 @@ protected: struct Chuck_Instr_Mem_Set_Imm2 : public Chuck_Instr_Unary_Op { public: - Chuck_Instr_Mem_Set_Imm2( t_CKUINT offset, t_CKFLOAT val ) + Chuck_Instr_Mem_Set_Imm2( t_CKUINT offset, t_CK2WORD val ) { m_offset = offset; m_val = val; } public: @@ -1873,7 +1873,7 @@ public: protected: t_CKUINT m_offset; - t_CKFLOAT m_val; + t_CK2WORD m_val; }; @@ -1902,7 +1902,7 @@ public: struct Chuck_Instr_Mem_Push_Imm2 : public Chuck_Instr_Unary_Op2 { public: - Chuck_Instr_Mem_Push_Imm2( t_CKFLOAT src ) + Chuck_Instr_Mem_Push_Imm2( t_CK2WORD src ) { this->set( src ); } public: diff --git a/v2/chuck_type.cpp b/v2/chuck_type.cpp index b099ddd..e9ef452 100755 --- a/v2/chuck_type.cpp +++ b/v2/chuck_type.cpp @@ -139,6 +139,17 @@ a_Func_Def make_dll_as_fun( Chuck_DL_Func * dl_fun, t_CKBOOL is_static ); // static Chuck_Env * Chuck_Env::our_instance = NULL; +// static zeros for each word size (should be in chuck_def.cpp?) +#ifdef CK32BIT +t_CK1WORD zero_CK1WORD = 0; +t_CK2WORD zero_CK2WORD = 0.0; +t_CK4WORD zero_CK4WORD = {0.0,0.0}; +#endif +#ifdef CK64BIT +t_CK1WORD zero_CK1WORD = 0; +t_CK2WORD zero_CK2WORD = {0.0,0.0}; +t_CK4WORD zero_CK4WORD = {{0.0,0.0},{0.0,0.0}}; +#endif //----------------------------------------------------------------------------- // name: startup() diff --git a/v2/chuck_type.h b/v2/chuck_type.h index bfc249f..460ca1e 100755 --- a/v2/chuck_type.h +++ b/v2/chuck_type.h @@ -492,6 +492,8 @@ struct Chuck_Type : public Chuck_VM_Object Chuck_Type * parent; // size (in bytes) t_CKUINT size; + // size (in words) + t_CKUINT words() { return size / sizeof(long); } // owner of the type Chuck_Namespace * owner; // array type -- 1.5.6.GIT