aligning headers with 1.5-beta; Bitcrusher crushing a bit better; removing Faust osx -lcrypto dependency

Ge Wang committed 3 years ago

Commit 6e4b6fc1 parent 01c8ae472 files · +2167 −1113Browse files

Unified · Split

72 files

Bitcrusher/Bitcrusher.cpp +10 −2
Faust/makefile.osx +2 −2
chuck/include/chuck.h +2 −4
chuck/include/chuck_compile.h +6 −1
chuck/include/chuck_def.h +8 −1
chuck/include/chuck_dl.h +3 −3
chuck/include/chuck_emit.h +3 −1
chuck/include/chuck_errmsg.h +1 −1
chuck/include/chuck_frame.h +1 −1
chuck/include/chuck_instr.h +73 −9
chuck/include/chuck_io.h +7 −4
chuck/include/chuck_lang.h +37 −2
chuck/include/chuck_oo.h +48 −13
chuck/include/chuck_parse.h +2 −0
chuck/include/chuck_type.h +77 −16
chuck/include/ugen_stk.h +4 −6
chuck/include/ulib_ai.h +159 −19
chuck/include/ulib_machine.h +8 −11
chuck/include/ulib_math.h +11 −0
chuck/include/util_hid.h +2 −0
chuck/include/util_math.h +2 −1
chuck/include/util_network.h +1 −0
chuck/include/util_opsc.h +1 −0
chuck/include/util_serial.h +2 −0
chuck/include/util_sndfile.h +7 −1
chuginate/template/chuck/include/chuck.h +15 −17
chuginate/template/chuck/include/chuck.tab.h +1 −1
chuginate/template/chuck/include/chuck_absyn.h +15 −14
chuginate/template/chuck/include/chuck_carrier.h +8 −8
chuginate/template/chuck/include/chuck_compile.h +23 −11
chuginate/template/chuck/include/chuck_def.h +17 −7
chuginate/template/chuck/include/chuck_dl.h +62 −56
chuginate/template/chuck/include/chuck_emit.h +7 −5
chuginate/template/chuck/include/chuck_errmsg.h +9 −9
chuginate/template/chuck/include/chuck_frame.h +1 −1
chuginate/template/chuck/include/chuck_globals.h +21 −21
chuginate/template/chuck/include/chuck_instr.h +163 −93
chuginate/template/chuck/include/chuck_io.h +32 −29
chuginate/template/chuck/include/chuck_lang.h +40 −3
chuginate/template/chuck/include/chuck_oo.h +93 −41
chuginate/template/chuck/include/chuck_otf.h +4 −4
chuginate/template/chuck/include/chuck_parse.h +7 −5
chuginate/template/chuck/include/chuck_scan.h +2 −2
chuginate/template/chuck/include/chuck_shell.h +80 −80
chuginate/template/chuck/include/chuck_stats.h +10 −10
chuginate/template/chuck/include/chuck_symbol.h +1 −1
chuginate/template/chuck/include/chuck_table.h +2 −2
chuginate/template/chuck/include/chuck_type.h +131 −57
chuginate/template/chuck/include/chuck_ugen.h +6 −6
chuginate/template/chuck/include/chuck_utils.h +1 −1
chuginate/template/chuck/include/chuck_vm.h +18 −18
chuginate/template/chuck/include/chuck_win32.h +3 −3
chuginate/template/chuck/include/dirent_win32.h +37 −37
chuginate/template/chuck/include/hidio_sdl.h +4 −4
chuginate/template/chuck/include/midiio_rtmidi.h +46 −46
chuginate/template/chuck/include/rtmidi.h +10 −10
chuginate/template/chuck/include/ugen_osc.h +2 −2
chuginate/template/chuck/include/ugen_stk.h +141 −143
chuginate/template/chuck/include/ulib_ai.h +377 −0
chuginate/template/chuck/include/ulib_machine.h +9 −10
chuginate/template/chuck/include/ulib_math.h +12 −6
chuginate/template/chuck/include/ulib_regex.h +4 −4
chuginate/template/chuck/include/util_buffers.h +54 −54
chuginate/template/chuck/include/util_hid.h +4 −2
chuginate/template/chuck/include/util_math.h +23 −7
chuginate/template/chuck/include/util_network.h +1 −0
chuginate/template/chuck/include/util_opsc.h +52 −51
chuginate/template/chuck/include/util_platforms.h +9 −10
chuginate/template/chuck/include/util_serial.h +5 −4
chuginate/template/chuck/include/util_sndfile.h +103 −99
chuginate/template/chuck/include/util_string.h +7 −3
chuginate/template/chuck/include/util_thread.h +18 −18

     // convert to 32-bit int
     t_CKINT shift = 32-bcdata->bits;
-    int q32 = theSample * INT_MAX;
+    // cast to double for avoid floating point precision warning/error | (ge) 2023.4.14
+    // "implicit conversion from 'int' to 'float' changes value from 2147483647 to 2147483648"
+    // https://stackoverflow.com/questions/23420783/convert-int-max-to-float-and-then-back-to-integer
+    // for example...
+    //     int i = ((float)(INT_MAX)); // on mac (intel and arm64) seem to produce arbitrary and different values
+    //     int i = ((float)(INT_MAX)-64); // on mac appears stable
+    //     int i = ((double)(INT_MAX)); // on mac appears stable
+    //     int i = ((double)(INT_MAX)+.1); // on mac appears stable
+    //     int i = ((double)(INT_MAX)+1); // on mac not stable
+    int q32 = ((double)theSample) * INT_MAX;
     q32 = (q32 >> shift) << shift;
     *out = q32 / ((float) INT_MAX);
     return TRUE;

Faust/makefile.osx+2−2

@@ -1,9 +1,9 @@
1		1
2	ARCHS?=x86_64	2	ARCHS?=arm64
3	ARCHOPTS=$(addprefix -arch ,$(ARCHS))	3	ARCHOPTS=$(addprefix -arch ,$(ARCHS))
4		4
5	FLAGS+=-mmacosx-version-min=10.9 -D__MACOSX_CORE__ -I$(CK_SRC_PATH) $(ARCHOPTS) -fPIC -I/usr/local/include	5	FLAGS+=-mmacosx-version-min=10.9 -D__MACOSX_CORE__ -I$(CK_SRC_PATH) $(ARCHOPTS) -fPIC -I/usr/local/include
6	LDFLAGS+=-mmacosx-version-min=10.9 -L/usr/local/lib -shared -lc++ $(ARCHOPTS) -lfaust `llvm-config-mp-3.5 --ldflags --libs all` -lcrypto -lz -lcurses -lc++	6	LDFLAGS+=-mmacosx-version-min=10.9 -L/usr/local/lib -shared -lc++ $(ARCHOPTS) -lfaust `llvm-config --ldflags --libs all` -lz -lcurses -lc++
7		7
8	LD=clang++	8	LD=clang++
9	CXX=clang++	9	CXX=clang++

chuck/include/chuck.h+2−4

 public: // static functions
     // chuck version
     static const char * version();
-    #ifndef __DISABLE_OTF_SERVER__
     // chuck int size (in bits)
-    // (this depends on machine, which depends on OTF, so
+    // (this depends on machine, which depends on OTF, so disable it if we don't have OTF)
-    //  disable it if we don't have OTF)
+    // 1.5.0.0 (ge) | reinstated for non-OTF, along with parts of machine
     static t_CKUINT intSize();
-    #endif
     // number of ChucK's
     static t_CKUINT numVMs() { return o_numVMs; };
     // --poop compatibilty

chuck/include/chuck_compile.h+6−1

     // set carrier
     t_CKBOOL setCarrier( Chuck_Carrier * c ) { m_carrier = c; return TRUE; }
 public: // data
     // emitter
     Chuck_Emitter * emitter;
     // recent map
     std::map<std::string, Chuck_Context *> m_recent;
+    // chugins
     std::list<Chuck_DLL *> m_dlls;
+    // libraries (ck code) to import
     std::list<std::string> m_cklibs_to_preload;
+    // origin hint; this flag is set to different te_Origin values
+    // to denote where new entities originate | 1.5.0.0 (ge) added
+    te_Origin m_originHint;
 public: // to all
     // contructor
     Chuck_Compiler();

chuck/include/chuck_def.h+8−1

 #define SAFE_RELEASE(x)             do { if(x){ x->release(); x = NULL; } } while(0)
 #define SAFE_ADD_REF(x)             do { if(x){ x->add_ref(); } } while(0)
 #define SAFE_REF_ASSIGN(lhs,rhs)    do { SAFE_RELEASE(lhs); (lhs) = (rhs); SAFE_ADD_REF(lhs); } while(0)
+#define SAFE_FREE(x)                do { if(x){ free(x); x = NULL; } } while(0)
+#define SAFE_UNLOCK_DELETE(x)       do { if(x){ x->unlock(); delete x; x = NULL; } } while(0)
 #endif
 // max + min
 #ifdef __PLATFORM_WIN32__
 #ifndef usleep
-#define usleep(x) Sleep( (x / 1000 <= 0 ? 1 : x / 1000) )
+  #define usleep(x) Sleep( (x / 1000 <= 0 ? 1 : x / 1000) )
+#endif
+// 1.4.2.0 (ge and spencer) | added for legacy windows, as part of switch to snprintf
+// https://stackoverflow.com/questions/2915672/snprintf-and-visual-studio-2010
+#if defined(_MSC_VER) && _MSC_VER < 1900
+  #define snprintf(buf,len, format,...) _snprintf_s(buf, len,len, format, __VA_ARGS__)
 #endif
 #pragma warning (disable : 4996)  // stdio deprecation
 #pragma warning (disable : 4786)  // stl debug info

chuck/include/chuck_dl.h+3−3

@@ -161,7 +161,7 @@ namespace Chuck_DL_Api { struct Api; } · 160 unmodified lines
161	#endif	161	#endif
162		162
163	// calling convention of functions provided by chuck to the dll	163	// calling convention of functions provided by chuck to the dll
164	#if defined(__WINDOWS_DS__)	164	#if defined(__PLATFORM_WIN32__)
165	#define CK_DLL_CALL _cdecl	165	#define CK_DLL_CALL _cdecl
166	#else	166	#else
167	#define CK_DLL_CALL	167	#define CK_DLL_CALL
@@ -676,7 +676,7 @@ public: · 508 unmodified lines
676	{	676	{
677	ObjectApi();	677	ObjectApi();
678		678
679	// 1.4.2.1 (nshaheed and ge and anonymous pr-lab member) \| changed from private to public	679	// 1.5.0.0 (nshaheed and ge and anonymous pr-lab member) \| changed from private to public
680	// also changed all std::string & in this section to const char *	680	// also changed all std::string & in this section to const char *
681	// intent: this allows for chugins to access member variables and create chuck strings	681	// intent: this allows for chugins to access member variables and create chuck strings
682	public:	682	public:
@@ -724,7 +724,7 @@ private: · 41 unmodified lines
724		724
725	#error ChucK not support on Mac OS X 10.3 or lower	725	#error ChucK not support on Mac OS X 10.3 or lower
726		726
727	#elif defined(__WINDOWS_DS__) \|\| defined(__WINDOWS_ASIO__)	727	#elif defined(__PLATFORM_WIN32__)
728		728
729	#ifdef __cplusplus	729	#ifdef __cplusplus
730	extern "C" {	730	extern "C" {

chuck/include/chuck_emit.h+3−1

     // add references to locals on current scope (added 1.3.0.0)
     void addref_on_scope();
     // pop scope
-    void pop_scope( );
+    void pop_scope();
+    // traverse scope on jumps such as 'return' 'break' 'continue' | 1.5.0.0 (ge)
+    void traverse_scope_on_jump();
     // default durations
     t_CKBOOL find_dur( const std::string & name, t_CKDUR * out );

chuck/include/chuck_errmsg.h+1−1

@@ -53,7 +53,7 @@ extern t_CKINT EM_extLineNum; · 52 unmodified lines
53	void EM_newline( );	53	void EM_newline( );
54		54
55	// levels	55	// levels
56	#define CK_LOG_CRAZY 10 // set this to log everything	56	#define CK_LOG_ALL 10 // set this to log everything
57	#define CK_LOG_FINEST 9	57	#define CK_LOG_FINEST 9
58	#define CK_LOG_FINER 8	58	#define CK_LOG_FINER 8
59	#define CK_LOG_FINE 7	59	#define CK_LOG_FINE 7

chuck/include/chuck_frame.h+1−1

@@ -92,7 +92,7 @@ public: · 91 unmodified lines
92	Chuck_Local * alloc_local( t_CKUINT size, const std::string & name,	92	Chuck_Local * alloc_local( t_CKUINT size, const std::string & name,
93	t_CKBOOL is_ref, t_CKBOOL is_obj, t_CKBOOL is_global );	93	t_CKBOOL is_ref, t_CKBOOL is_obj, t_CKBOOL is_global );
94	// get the current scope (added 1.3.0.0)	94	// get the current scope (added 1.3.0.0)
95	void get_scope( std::vector<Chuck_Local *> & out ) const;	95	void get_scope( std::vector<Chuck_Local *> & out, bool localOnly = true ) const;
96	// pop scope	96	// pop scope
97	void pop_scope( std::vector<Chuck_Local *> & out );	97	void pop_scope( std::vector<Chuck_Local *> & out );
98	};	98	};

chuck/include/chuck_instr.h+73−9

 {
 public:
     Chuck_Instr();
-    virtual ~Chuck_Instr() { }
+    virtual ~Chuck_Instr() { SAFE_DELETE(m_codestr); }
 public:
     virtual void execute( Chuck_VM * vm, Chuck_VM_Shred * shred ) = 0;
     { return ""; }
 public:
+    // store line position for error messages
     void set_linepos( t_CKUINT linepos );
     t_CKUINT m_linepos;
+    // set codestr associated with this instruction
+    void set_codestr( const std::string & str );
+    // (used in instruction dump) | 1.5.0.0 (ge) added
+    std::string * m_codestr;
 };
+//-----------------------------------------------------------------------------
+// name: struct Chuck_Instr_Reg_Push_Zero
+// desc: push immediate value 0 to reg stack with specific width
+//-----------------------------------------------------------------------------
+struct Chuck_Instr_Reg_Push_Zero : public Chuck_Instr_Unary_Op
+{
+public:
+    Chuck_Instr_Reg_Push_Zero( t_CKUINT sizeInBytes )
+    { this->set( sizeInBytes ); }
+public:
+    virtual void execute( Chuck_VM * vm, Chuck_VM_Shred * shred );
+};
 //-----------------------------------------------------------------------------
 // name: struct Chuck_Instr_Reg_Dup_Last
 // desc: duplicate last value on reg stack
 //-----------------------------------------------------------------------------
 // name: struct Chuck_Instr_Reg_AddRef_Object3
 // desc: added 1.3.0.0 -- does the ref add in-place
+//       operates on top of the register stack
 //-----------------------------------------------------------------------------
 struct Chuck_Instr_Reg_AddRef_Object3 : public Chuck_Instr
 {
 //-----------------------------------------------------------------------------
 // name: struct Chuck_Instr_Release_Object
-// desc: ...
+// desc: release object on stack by its offset
 //-----------------------------------------------------------------------------
 struct Chuck_Instr_Release_Object : public Chuck_Instr
 {
+//-----------------------------------------------------------------------------
+// name: struct Chuck_Instr_Release_Object3_Pop_Word
+// desc: release object reference + pop from reg stack | 1.5.0.0 (ge) added
+//       the variant assumes object pointer directly on stack (not offset)
+//-----------------------------------------------------------------------------
+struct Chuck_Instr_Release_Object3_Pop_Word : public Chuck_Instr
+{
+public:
+    virtual void execute( Chuck_VM * vm, Chuck_VM_Shred * shred );
+};
+//-----------------------------------------------------------------------------
+// name: struct Chuck_Instr_Release_Object4
+// desc: release object reference from reg stack (no pop) | 1.5.0.0 (ge) added
+//       the variant assumes object pointer directly on stack (not offset)
+//-----------------------------------------------------------------------------
+struct Chuck_Instr_Release_Object4 : public Chuck_Instr_Unary_Op
+{
+public:
+    Chuck_Instr_Release_Object4( t_CKUINT offset )
+    { this->set( offset ); }
+public:
+    virtual void execute( Chuck_VM * vm, Chuck_VM_Shred * shred );
+};
 //-----------------------------------------------------------------------------
 // name: struct Chuck_Instr_Func_To_Code
 // desc: Chuck_Func * to Chuck_VM_Code *
 struct Chuck_Instr_Func_Call_Member : public Chuck_Instr_Unary_Op
 {
 public:
-    Chuck_Instr_Func_Call_Member( t_CKUINT ret_size )
+    Chuck_Instr_Func_Call_Member( t_CKUINT ret_size, Chuck_Func * func_ref )
-    { this->set( ret_size ); }
+    { this->set( ret_size ); m_func_ref = func_ref; }
 public:
     virtual void execute( Chuck_VM * vm, Chuck_VM_Shred * shred );
+public:
+    Chuck_Func * m_func_ref; // 1.5.0.0 (ge) | added for arg list cleanup
 };
 struct Chuck_Instr_Func_Call_Static : public Chuck_Instr_Unary_Op
 {
 public:
-    Chuck_Instr_Func_Call_Static( t_CKUINT ret_size )
+    Chuck_Instr_Func_Call_Static( t_CKUINT ret_size, Chuck_Func * func_ref )
-    { this->set( ret_size ); }
+    { this->set( ret_size ); m_func_ref = func_ref; }
 public:
     virtual void execute( Chuck_VM * vm, Chuck_VM_Shred * shred );
+public:
+    Chuck_Func * m_func_ref; // 1.5.0.0 (ge) | added for arg list cleanup
 };
 struct Chuck_Instr_Array_Alloc : public Chuck_Instr
 {
 public: // REFACTOR-2017: added env
-    Chuck_Instr_Array_Alloc( Chuck_Env * env, t_CKUINT depth, Chuck_Type * the_type,
+    Chuck_Instr_Array_Alloc( Chuck_Env * env, t_CKUINT depth,
-        t_CKUINT offset, t_CKBOOL ref );
+        Chuck_Type * contentType, t_CKUINT offset, t_CKBOOL ref,
+        Chuck_Type * arrayType );
     virtual ~Chuck_Instr_Array_Alloc();
 public:
 protected:
     t_CKUINT m_depth;
-    Chuck_Type * m_type_ref;
+    Chuck_Type * m_type_ref_content;
+    Chuck_Type * m_type_ref_array; // 1.5.0.0 (ge) added
     t_CKBOOL m_is_obj;
     char * m_param_str;
     t_CKUINT m_stack_offset;

chuck/include/chuck_io.h+7−4

 t_CKBOOL init_class_HID( Chuck_Env * env );
 #endif
 t_CKBOOL init_class_io( Chuck_Env * env, Chuck_Type * type );
-#ifndef __DISABLE_FILEIO__
+// #ifndef __DISABLE_FILEIO__
 t_CKBOOL init_class_fileio( Chuck_Env * env, Chuck_Type * type );
-#endif
+// #endif
 // added 1.3.0.0 -- moved to be full-fledged class
 t_CKBOOL init_class_chout( Chuck_Env * env, Chuck_Type * type );
 // added 1.3.0.0 -- moved to be full-fledged class
 CK_DLL_SFUN( io_openfile );
-#ifndef __DISABLE_FILEIO__
+// #ifndef __DISABLE_FILEIO__
 //-----------------------------------------------------------------------------
 // fileio API
 //-----------------------------------------------------------------------------
 CK_DLL_MFUN( fileio_readline );
 CK_DLL_MFUN( fileio_readint );
 CK_DLL_MFUN( fileio_readintflags );
+CK_DLL_MFUN( fileio_readint8 );
+CK_DLL_MFUN( fileio_readint16 );
+CK_DLL_MFUN( fileio_readint32 );
 CK_DLL_MFUN( fileio_readfloat );
 CK_DLL_MFUN( fileio_eof );
 CK_DLL_MFUN( fileio_more );
 CK_DLL_MFUN( fileio_writeint );
 CK_DLL_MFUN( fileio_writeintflags );
 CK_DLL_MFUN( fileio_writefloat );
-#endif
+// #endif // __DISABLE_FILEIO__
 //-----------------------------------------------------------------------------

chuck/include/chuck_lang.h+37−2

@@ -58,7 +58,8 @@ t_CKBOOL init_class_string( Chuck_Env * env, Chuck_Type * type ); · 57 unmodified lines
58	t_CKBOOL init_class_array( Chuck_Env * env, Chuck_Type * type );	58	t_CKBOOL init_class_array( Chuck_Env * env, Chuck_Type * type );
59	t_CKBOOL init_class_vec3( Chuck_Env * env, Chuck_Type * type ); // 1.3.5.3	59	t_CKBOOL init_class_vec3( Chuck_Env * env, Chuck_Type * type ); // 1.3.5.3
60	t_CKBOOL init_class_vec4( Chuck_Env * env, Chuck_Type * type ); // 1.3.5.3	60	t_CKBOOL init_class_vec4( Chuck_Env * env, Chuck_Type * type ); // 1.3.5.3
61		61	t_CKBOOL init_class_type( Chuck_Env * env, Chuck_Type * type ); // 1.5.0.0
		62	t_CKBOOL init_primitive_types( Chuck_Env * env ); // 1.5.0.0
62		63
63		64
64		65
@@ -69,11 +70,11 @@ t_CKBOOL init_class_vec4( Chuck_Env * env, Chuck_Type * type ); // 1.3.5.3 · 4 unmodified lines
69	CK_DLL_CTOR( object_ctor );	70	CK_DLL_CTOR( object_ctor );
70	CK_DLL_DTOR( object_dtor );	71	CK_DLL_DTOR( object_dtor );
71	CK_DLL_MFUN( object_equals );	72	CK_DLL_MFUN( object_equals );
72	CK_DLL_MFUN( object_getType );
73	CK_DLL_MFUN( object_hashCode );	73	CK_DLL_MFUN( object_hashCode );
74	CK_DLL_MFUN( object_toString );	74	CK_DLL_MFUN( object_toString );
75	CK_DLL_MFUN( object_dump );	75	CK_DLL_MFUN( object_dump );
76	CK_DLL_SFUN( object_help );	76	CK_DLL_SFUN( object_help );
		77	CK_DLL_SFUN( object_typeInfo );
77		78
78		79
79	//-----------------------------------------------------------------------------	80	//-----------------------------------------------------------------------------
@@ -187,7 +188,10 @@ CK_DLL_MFUN( array_find ); · 107 unmodified lines
187	CK_DLL_MFUN( array_erase );	188	CK_DLL_MFUN( array_erase );
188	CK_DLL_MFUN( array_clear );	189	CK_DLL_MFUN( array_clear );
189	CK_DLL_MFUN( array_reset );	190	CK_DLL_MFUN( array_reset );
		191	CK_DLL_MFUN( array_zero );
190	CK_DLL_MFUN( array_get_keys );	192	CK_DLL_MFUN( array_get_keys );
		193	CK_DLL_MFUN( array_reverse );
		194	CK_DLL_MFUN( array_shuffle );
191		195
192		196
193	//-----------------------------------------------------------------------------	197	//-----------------------------------------------------------------------------
@@ -256,6 +260,37 @@ CK_DLL_MFUN( vec4_magnitude ); · 62 unmodified lines
256	CK_DLL_MFUN( vec4_normalize );	260	CK_DLL_MFUN( vec4_normalize );
257		261
258		262
		263	//-----------------------------------------------------------------------------
		264	// type API \| 1.5.0.0 (ge) added
		265	//-----------------------------------------------------------------------------
		266	CK_DLL_CTOR( type_ctor );
		267	CK_DLL_DTOR( type_dtor );
		268	CK_DLL_MFUN( type_equals );
		269	CK_DLL_MFUN( type_isa );
		270	CK_DLL_MFUN( type_isa_str );
		271	CK_DLL_MFUN( type_name );
		272	CK_DLL_MFUN( type_parent ); // return parent Type
		273	CK_DLL_MFUN( type_children ); // return children Types
		274	CK_DLL_MFUN( type_origin ); // built-in, chugin, defined in chuck
		275	CK_DLL_MFUN( type_isPrimitive );
		276	CK_DLL_MFUN( type_isArray );
		277	CK_DLL_MFUN( type_arrayDims );
		278	CK_DLL_SFUN( type_findString );
		279	CK_DLL_SFUN( type_typeOf_obj ); // Type.typeOf( Object )
		280	CK_DLL_SFUN( type_typeOf_int ); // Type.typeOf( int )
		281	CK_DLL_SFUN( type_typeOf_float ); // Type.typeOf( float )
		282	CK_DLL_SFUN( type_typeOf_time ); // Type.typeOf( time )
		283	CK_DLL_SFUN( type_typeOf_dur ); // Type.typeOf( dur )
		284	CK_DLL_SFUN( type_typeOf_complex ); // Type.typeOf( complex )
		285	CK_DLL_SFUN( type_typeOf_polar ); // Type.typeOf( polar )
		286	CK_DLL_SFUN( type_typeOf_vec3 ); // Type.typeOf( vec3 )
		287	CK_DLL_SFUN( type_typeOf_vec4 ); // Type.typeOf( vec4 )
		288	CK_DLL_SFUN( type_getTypes );
		289	CK_DLL_SFUN( type_getTypesAll );
		290
		291
		292
		293
259	//-----------------------------------------------------------------------------	294	//-----------------------------------------------------------------------------
260	// name: Data_Exception	295	// name: Data_Exception
261	// desc: data for base Chuck Exception class	296	// desc: data for base Chuck Exception class

chuck/include/chuck_oo.h+48−13

@@ -98,6 +98,8 @@ public: · 97 unmodified lines
98	virtual void release();	98	virtual void release();
99	// lock	99	// lock
100	virtual void lock();	100	virtual void lock();
		101	// unlock \| 1.5.0.0 (ge) added
		102	virtual void unlock();
101		103
102	// NOTE: be careful when overriding these, should always	104	// NOTE: be careful when overriding these, should always
103	// explicitly call up to ChucK_VM_Object (ge: 2013)	105	// explicitly call up to ChucK_VM_Object (ge: 2013)
@@ -228,8 +230,14 @@ public: · 124 unmodified lines
228	virtual t_CKINT find( const std::string & key ) = 0; // find	230	virtual t_CKINT find( const std::string & key ) = 0; // find
229	virtual t_CKINT erase( const std::string & key ) = 0; // erase	231	virtual t_CKINT erase( const std::string & key ) = 0; // erase
230	virtual void clear( ) = 0; // clear	232	virtual void clear( ) = 0; // clear
		233	virtual void zero( t_CKUINT start, t_CKUINT end ) = 0; // zero
		234	virtual void zero() = 0; // zero (all)
231	// get map keys \| added (1.4.2.0) nshaheed	235	// get map keys \| added (1.4.2.0) nshaheed
232	virtual void get_keys( std::vector<std::string> & keys ) = 0;	236	virtual void get_keys( std::vector<std::string> & keys ) = 0;
		237	// reverse array order \| added (1.5.0.0) azaday
		238	virtual void reverse() = 0;
		239	// reverse array order \| added (1.5.0.0) kunwoo, nshaheed, azaday, ge
		240	virtual void shuffle() = 0;
233		241
234	Chuck_Type * m_array_type;	242	Chuck_Type * m_array_type;
235	};	243	};
@@ -259,6 +267,7 @@ public: · 23 unmodified lines
259	t_CKINT pop_out( t_CKINT pos );	267	t_CKINT pop_out( t_CKINT pos );
260	t_CKINT back( t_CKUINT * val ) const;	268	t_CKINT back( t_CKUINT * val ) const;
261	void zero( t_CKUINT start, t_CKUINT end );	269	void zero( t_CKUINT start, t_CKUINT end );
		270	void zero() { this->zero(0, m_vector.size()); }
262		271
263	virtual void clear( );	272	virtual void clear( );
264	virtual t_CKINT size( ) { return m_vector.size(); }	273	virtual t_CKINT size( ) { return m_vector.size(); }
@@ -271,11 +280,18 @@ public: · 6 unmodified lines
271	virtual t_CKINT data_type_kind( ) { return CHUCK_ARRAY4_DATAKIND; }	280	virtual t_CKINT data_type_kind( ) { return CHUCK_ARRAY4_DATAKIND; }
272	// get map keys \| added (1.4.2.0) nshaheed	281	// get map keys \| added (1.4.2.0) nshaheed
273	virtual void get_keys( std::vector<std::string> & keys );	282	virtual void get_keys( std::vector<std::string> & keys );
		283	// reverse array order \| added (1.5.0.0) azaday
		284	virtual void reverse();
		285	// reverse array order \| added (1.5.0.0) kunwoo, nshaheed, azaday, ge
		286	virtual void shuffle();
274		287
275	public:	288	public:
276	std::vector<t_CKUINT> m_vector;	289	std::vector<t_CKUINT> m_vector;
277	std::map<std::string, t_CKUINT> m_map;	290	std::map<std::string, t_CKUINT> m_map;
278	t_CKBOOL m_is_obj;	291	t_CKBOOL m_is_obj;
		292
		293	// TODO: may need additional information here for set_size, if this is part of a multi-dim array
		294
279	// t_CKINT m_size;	295	// t_CKINT m_size;
280	// t_CKINT m_capacity;	296	// t_CKINT m_capacity;
281	};	297	};
@@ -305,6 +321,7 @@ public: · 23 unmodified lines
305	t_CKINT pop_out( t_CKINT pos );	321	t_CKINT pop_out( t_CKINT pos );
306	t_CKINT back( t_CKFLOAT * val ) const;	322	t_CKINT back( t_CKFLOAT * val ) const;
307	void zero( t_CKUINT start, t_CKUINT end );	323	void zero( t_CKUINT start, t_CKUINT end );
		324	void zero() { this->zero(0, m_vector.size()); }
308		325
309	virtual void clear( );	326	virtual void clear( );
310	virtual t_CKINT size( ) { return m_vector.size(); }	327	virtual t_CKINT size( ) { return m_vector.size(); }
@@ -317,6 +334,10 @@ public: · 6 unmodified lines
317	virtual t_CKINT data_type_kind( ) { return CHUCK_ARRAY8_DATAKIND; }	334	virtual t_CKINT data_type_kind( ) { return CHUCK_ARRAY8_DATAKIND; }
318	// get map keys \| added (1.4.2.0) nshaheed	335	// get map keys \| added (1.4.2.0) nshaheed
319	virtual void get_keys( std::vector<std::string> & keys );	336	virtual void get_keys( std::vector<std::string> & keys );
		337	// reverse array order \| added (1.5.0.0) azaday
		338	virtual void reverse();
		339	// reverse array order \| added (1.5.0.0) kunwoo, nshaheed, azaday, ge
		340	virtual void shuffle();
320		341
321	public:	342	public:
322	std::vector<t_CKFLOAT> m_vector;	343	std::vector<t_CKFLOAT> m_vector;
@@ -350,6 +371,7 @@ public: · 27 unmodified lines
350	t_CKINT pop_out( t_CKINT pos );	371	t_CKINT pop_out( t_CKINT pos );
351	t_CKINT back( t_CKCOMPLEX * val ) const;	372	t_CKINT back( t_CKCOMPLEX * val ) const;
352	void zero( t_CKUINT start, t_CKUINT end );	373	void zero( t_CKUINT start, t_CKUINT end );
		374	void zero() { this->zero(0, m_vector.size()); }
353		375
354	virtual void clear( );	376	virtual void clear( );
355	virtual t_CKINT size( ) { return m_vector.size(); }	377	virtual t_CKINT size( ) { return m_vector.size(); }
@@ -362,6 +384,10 @@ public: · 6 unmodified lines
362	virtual t_CKINT data_type_kind( ) { return CHUCK_ARRAY16_DATAKIND; }	384	virtual t_CKINT data_type_kind( ) { return CHUCK_ARRAY16_DATAKIND; }
363	// get map keys \| added (1.4.2.0) nshaheed	385	// get map keys \| added (1.4.2.0) nshaheed
364	virtual void get_keys( std::vector<std::string> & keys );	386	virtual void get_keys( std::vector<std::string> & keys );
		387	// reverse array order \| added (1.5.0.0) azaday
		388	virtual void reverse();
		389	// reverse array order \| added (1.5.0.0) kunwoo, nshaheed, azaday, ge
		390	virtual void shuffle();
365		391
366	public:	392	public:
367	std::vector<t_CKCOMPLEX> m_vector;	393	std::vector<t_CKCOMPLEX> m_vector;
@@ -395,6 +421,7 @@ public: · 27 unmodified lines
395	t_CKINT pop_out( t_CKUINT pos );	421	t_CKINT pop_out( t_CKUINT pos );
396	t_CKINT back( t_CKVEC3 * val ) const;	422	t_CKINT back( t_CKVEC3 * val ) const;
397	void zero( t_CKUINT start, t_CKUINT end );	423	void zero( t_CKUINT start, t_CKUINT end );
		424	void zero() { this->zero(0, m_vector.size()); }
398		425
399	virtual void clear( );	426	virtual void clear( );
400	virtual t_CKINT size( ) { return m_vector.size(); }	427	virtual t_CKINT size( ) { return m_vector.size(); }
@@ -407,6 +434,10 @@ public: · 6 unmodified lines
407	virtual t_CKINT data_type_kind( ) { return CHUCK_ARRAY24_DATAKIND; }	434	virtual t_CKINT data_type_kind( ) { return CHUCK_ARRAY24_DATAKIND; }
408	// get map keys \| added (1.4.2.0) nshaheed	435	// get map keys \| added (1.4.2.0) nshaheed
409	virtual void get_keys( std::vector<std::string> & keys );	436	virtual void get_keys( std::vector<std::string> & keys );
		437	// reverse array order \| added (1.5.0.0) azaday
		438	virtual void reverse();
		439	// reverse array order \| added (1.5.0.0) kunwoo, nshaheed, azaday, ge
		440	virtual void shuffle();
410		441
411	public:	442	public:
412	std::vector<t_CKVEC3> m_vector;	443	std::vector<t_CKVEC3> m_vector;
@@ -438,6 +469,7 @@ public: · 25 unmodified lines
438	t_CKINT pop_out( t_CKUINT pos );	469	t_CKINT pop_out( t_CKUINT pos );
439	t_CKINT back( t_CKVEC4 * val ) const;	470	t_CKINT back( t_CKVEC4 * val ) const;
440	void zero( t_CKUINT start, t_CKUINT end );	471	void zero( t_CKUINT start, t_CKUINT end );
		472	void zero() { this->zero(0, m_vector.size()); }
441		473
442	virtual void clear( );	474	virtual void clear( );
443	virtual t_CKINT size( ) { return m_vector.size(); }	475	virtual t_CKINT size( ) { return m_vector.size(); }
@@ -450,6 +482,10 @@ public: · 6 unmodified lines
450	virtual t_CKINT data_type_kind( ) { return CHUCK_ARRAY32_DATAKIND; }	482	virtual t_CKINT data_type_kind( ) { return CHUCK_ARRAY32_DATAKIND; }
451	// get map keys \| added (1.4.1.2) nshaheed	483	// get map keys \| added (1.4.1.2) nshaheed
452	virtual void get_keys( std::vector<std::string> & keys );	484	virtual void get_keys( std::vector<std::string> & keys );
		485	// reverse array order \| added (1.5.0.0) azaday
		486	virtual void reverse();
		487	// reverse array order \| added (1.5.0.0) kunwoo, nshaheed, azaday, ge
		488	virtual void shuffle();
453		489
454	public:	490	public:
455	std::vector<t_CKVEC4> m_vector;	491	std::vector<t_CKVEC4> m_vector;
@@ -589,15 +625,23 @@ public: · 133 unmodified lines
589	virtual void write( t_CKINT val, t_CKINT flags ) = 0;	625	virtual void write( t_CKINT val, t_CKINT flags ) = 0;
590	virtual void write( t_CKFLOAT val ) = 0;	626	virtual void write( t_CKFLOAT val ) = 0;
591		627
592	// constants
593	public:	628	public:
		629	// type \| moved to IO in 1.5.0.0 (ge)
		630	static const t_CKINT TYPE_ASCII;
		631	static const t_CKINT TYPE_BINARY;
		632	// datatype
594	static const t_CKINT INT32;	633	static const t_CKINT INT32;
595	static const t_CKINT INT16;	634	static const t_CKINT INT16;
596	static const t_CKINT INT8;	635	static const t_CKINT INT8;
597		636	// flags \| moved to IO in 1.5.0.0 (ge)
		637	static const t_CKINT FLAG_READ_WRITE;
		638	static const t_CKINT FLAG_READONLY;
		639	static const t_CKINT FLAG_WRITEONLY;
		640	static const t_CKINT FLAG_APPEND;
598	// asynchronous I/O members	641	// asynchronous I/O members
599	static const t_CKINT MODE_SYNC;	642	static const t_CKINT MODE_SYNC;
600	static const t_CKINT MODE_ASYNC;	643	static const t_CKINT MODE_ASYNC;
		644
601	Chuck_Event * m_asyncEvent;	645	Chuck_Event * m_asyncEvent;
602	#ifndef __DISABLE_THREADS__	646	#ifndef __DISABLE_THREADS__
603	XThread * m_thread;	647	XThread * m_thread;
@@ -614,7 +658,7 @@ public: · 10 unmodified lines
614		658
615		659
616		660
617	#ifndef __DISABLE_FILEIO__	661	// #ifndef __DISABLE_FILEIO__
618	//-----------------------------------------------------------------------------	662	//-----------------------------------------------------------------------------
619	// name: Chuck_IO_File	663	// name: Chuck_IO_File
620	// desc: Chuck File IO class	664	// desc: Chuck File IO class
@@ -673,15 +717,6 @@ public: · 52 unmodified lines
673	static THREAD_RETURN ( THREAD_TYPE writeFloat_thread ) ( void *data );	717	static THREAD_RETURN ( THREAD_TYPE writeFloat_thread ) ( void *data );
674	#endif	718	#endif
675		719
676	public:
677	// constants
678	static const t_CKINT FLAG_READ_WRITE;
679	static const t_CKINT FLAG_READONLY;
680	static const t_CKINT FLAG_WRITEONLY;
681	static const t_CKINT FLAG_APPEND;
682	static const t_CKINT TYPE_ASCII;
683	static const t_CKINT TYPE_BINARY;
684
685	protected:	720	protected:
686	// open flags	721	// open flags
687	t_CKINT m_flags;	722	t_CKINT m_flags;
@@ -698,7 +733,7 @@ protected: · 10 unmodified lines
698	// vm and shred	733	// vm and shred
699	Chuck_VM * m_vmRef;	734	Chuck_VM * m_vmRef;
700	};	735	};
701	#endif // __DISABLE_FILEIO__	736	// #endif // __DISABLE_FILEIO__
702		737
703		738
704		739

chuck/include/chuck_parse.h+2−0

@@ -63,6 +63,8 @@ t_CKBOOL chuck_parse( c_constr fname, FILE * fd = NULL, c_constr code = NULL ); · 62 unmodified lines
63	// reset the parser	63	// reset the parser
64	void reset_parse( );	64	void reset_parse( );
65		65
		66	// convert abstract syntax expression to string
		67	std::string absyn2str( a_Exp exp );
66		68
67	// syntax highlighting tools	69	// syntax highlighting tools
68	#include <vector>	70	#include <vector>

chuck/include/chuck_type.h+77−16

@@ -84,6 +84,22 @@ typedef enum { · 83 unmodified lines
84		84
85		85
86		86
		87	//-----------------------------------------------------------------------------
		88	// name: enum te_Origin \| 1.5.0.0 (ge) added
		89	// desc: where something (e.g., a Type) originates
		90	//-----------------------------------------------------------------------------
		91	typedef enum {
		92	te_originUnknown = 0,
		93	te_originBuiltin, // in core
		94	te_originChugin, // in imported chugin
		95	te_originImport, // library CK code
		96	te_originUserDefined, // in user chuck code
		97	te_originGenerated // generated (e.g., array types like int[][][][])
		98	} te_Origin;
		99
		100
		101
		102
87	//-----------------------------------------------------------------------------	103	//-----------------------------------------------------------------------------
88	// name: struct Chuck_Scope	104	// name: struct Chuck_Scope
89	// desc: scoping structure	105	// desc: scoping structure
@@ -199,8 +215,15 @@ public: · 109 unmodified lines
199	return (T)val;	215	return (T)val;
200	}	216	}
201		217
		218	// test if a name has been "mangled", e.g., "toString@0@Object"
		219	static t_CKBOOL is_mangled( const std::string & name )
		220	{
		221	// check for @ in the name, which would not be possible for names in language
		222	return ( name.find("@") != std::string::npos );
		223	}
		224
202	// get list of top level	225	// get list of top level
203	void get_toplevel( std::vector<Chuck_VM_Object *> & out )	226	void get_toplevel( std::vector<Chuck_VM_Object *> & out, t_CKBOOL includeMangled = TRUE )
204	{	227	{
205	assert( scope.size() != 0 );	228	assert( scope.size() != 0 );
206	std::map<S_Symbol, Chuck_VM_Object *>::iterator iter;	229	std::map<S_Symbol, Chuck_VM_Object *>::iterator iter;
@@ -213,13 +236,16 @@ public: · 6 unmodified lines
213	// go through map	236	// go through map
214	for( iter = m->begin(); iter != m->end(); iter++ )	237	for( iter = m->begin(); iter != m->end(); iter++ )
215	{	238	{
		239	// check mangled name
		240	if( !includeMangled && is_mangled( std::string(S_name((*iter).first))) )
		241	continue;
216	// add	242	// add
217	out.push_back( (*iter).second );	243	out.push_back( (*iter).second );
218	}	244	}
219	}	245	}
220		246
221	// get list of top level	247	// get list of top level
222	void get_level( int level, std::vector<Chuck_VM_Object *> & out )	248	void get_level( int level, std::vector<Chuck_VM_Object *> & out, t_CKBOOL includeMangled = TRUE )
223	{	249	{
224	assert( scope.size() >= level );	250	assert( scope.size() >= level );
225	std::map<S_Symbol, Chuck_VM_Object *>::iterator iter;	251	std::map<S_Symbol, Chuck_VM_Object *>::iterator iter;
@@ -232,12 +258,15 @@ public: · 6 unmodified lines
232	// go through map	258	// go through map
233	for( iter = m->begin(); iter != m->end(); iter++ )	259	for( iter = m->begin(); iter != m->end(); iter++ )
234	{	260	{
		261	// check mangled name
		262	if( !includeMangled && is_mangled( std::string(S_name((*iter).first))) )
		263	continue;
		264
235	// add	265	// add
236	out.push_back( (*iter).second );	266	out.push_back( (*iter).second );
237	}	267	}
238	}	268	}
239		269
240
241	protected:	270	protected:
242	std::vector<std::map<S_Symbol, Chuck_VM_Object > > scope;	271	std::vector<std::map<S_Symbol, Chuck_VM_Object > > scope;
243	std::map<S_Symbol, Chuck_VM_Object *> commit_map;	272	std::map<S_Symbol, Chuck_VM_Object *> commit_map;
@@ -324,7 +353,7 @@ struct Chuck_Namespace : public Chuck_VM_Object · 80 unmodified lines
324	// get top level values	353	// get top level values
325	void get_values( std::vector<Chuck_Value *> & out );	354	void get_values( std::vector<Chuck_Value *> & out );
326	// get top level functions	355	// get top level functions
327	void get_funcs( std::vector<Chuck_Func *> & out );	356	void get_funcs( std::vector<Chuck_Func *> & out, t_CKBOOL includeManged = TRUE );
328	};	357	};
329		358
330		359
@@ -398,10 +427,15 @@ public: · 67 unmodified lines
398	// constructor	427	// constructor
399	Chuck_Env();	428	Chuck_Env();
400		429
		430	public:
		431	// initialize
		432	t_CKBOOL init();
		433
401	// REFACTOR-2017: carrier and accessors	434	// REFACTOR-2017: carrier and accessors
402	public:	435	public:
403	void set_carrier( Chuck_Carrier * carrier ) { m_carrier = carrier; }	436	void set_carrier( Chuck_Carrier * carrier ) { m_carrier = carrier; }
404	Chuck_VM * vm() { return m_carrier->vm; }	437	Chuck_VM * vm() { return m_carrier ? m_carrier->vm : NULL; }
		438	Chuck_Compiler * compiler() { return m_carrier ? m_carrier->compiler : NULL; }
405		439
406	protected:	440	protected:
407	Chuck_Carrier * m_carrier;	441	Chuck_Carrier * m_carrier;
@@ -533,12 +567,10 @@ public: · 125 unmodified lines
533	Chuck_Type * t_uanablob;	567	Chuck_Type * t_uanablob;
534	Chuck_Type * t_shred;	568	Chuck_Type * t_shred;
535	Chuck_Type * t_io;	569	Chuck_Type * t_io;
536	#ifndef __DISABLE_FILEIO__
537	Chuck_Type * t_fileio;	570	Chuck_Type * t_fileio;
538	#endif
539	Chuck_Type * t_chout;	571	Chuck_Type * t_chout;
540	Chuck_Type * t_cherr;	572	Chuck_Type * t_cherr;
541	Chuck_Type * t_thread;	573	// Chuck_Type * t_thread;
542	Chuck_Type * t_class;	574	Chuck_Type * t_class;
543	Chuck_Type * t_dac;	575	Chuck_Type * t_dac;
544	Chuck_Type * t_adc;	576	Chuck_Type * t_adc;
@@ -583,8 +615,9 @@ struct Chuck_UGen_Info : public Chuck_VM_Object · 38 unmodified lines
583	//-----------------------------------------------------------------------------	615	//-----------------------------------------------------------------------------
584	// name: struct Chuck_Type	616	// name: struct Chuck_Type
585	// desc: class containing information about a type	617	// desc: class containing information about a type
586	//-----------------------------------------------------------------------------_id	618	// note: 1.5.0.0 (ge) Chuck_VM_Object -> Chuck_Object
587	struct Chuck_Type : public Chuck_VM_Object	619	//-----------------------------------------------------------------------------
		620	struct Chuck_Type : public Chuck_Object
588	{	621	{
589	// type id	622	// type id
590	te_Type xid;	623	te_Type xid;
@@ -620,6 +653,8 @@ struct Chuck_Type : public Chuck_VM_Object · 29 unmodified lines
620	t_CKBOOL has_destructor;	653	t_CKBOOL has_destructor;
621	// custom allocator	654	// custom allocator
622	f_alloc allocator;	655	f_alloc allocator;
		656	// origin hint
		657	te_Origin originHint;
623		658
624	// documentation	659	// documentation
625	std::string doc;	660	std::string doc;
@@ -839,7 +874,10 @@ t_CKBOOL isfunc( Chuck_Env * env, Chuck_Type * type ); · 213 unmodified lines
839	t_CKBOOL iskindofint( Chuck_Env * env, Chuck_Type * type ); // added 1.3.1.0: this includes int + pointers	874	t_CKBOOL iskindofint( Chuck_Env * env, Chuck_Type * type ); // added 1.3.1.0: this includes int + pointers
840	t_CKUINT getkindof( Chuck_Env * env, Chuck_Type * type ); // added 1.3.1.0: to get the kindof a type	875	t_CKUINT getkindof( Chuck_Env * env, Chuck_Type * type ); // added 1.3.1.0: to get the kindof a type
841		876
		877
		878	//-----------------------------------------------------------------------------
842	// import	879	// import
		880	//-----------------------------------------------------------------------------
843	Chuck_Type * type_engine_import_class_begin( Chuck_Env * env, Chuck_Type * type,	881	Chuck_Type * type_engine_import_class_begin( Chuck_Env * env, Chuck_Type * type,
844	Chuck_Namespace * where, f_ctor pre_ctor, f_dtor dtor = NULL,	882	Chuck_Namespace * where, f_ctor pre_ctor, f_dtor dtor = NULL,
845	const char * doc = NULL );	883	const char * doc = NULL );
@@ -884,7 +922,10 @@ t_CKBOOL type_engine_import_class_end( Chuck_Env * env ); · 38 unmodified lines
884	t_CKBOOL type_engine_register_deprecate( Chuck_Env * env,	922	t_CKBOOL type_engine_register_deprecate( Chuck_Env * env,
885	const std::string & former, const std::string & latter );	923	const std::string & former, const std::string & latter );
886		924
887	// helpers	925
		926	//-----------------------------------------------------------------------------
		927	// helper functions
		928	//-----------------------------------------------------------------------------
888	t_CKBOOL type_engine_check_reserved( Chuck_Env * env, const std::string & xid, int pos );	929	t_CKBOOL type_engine_check_reserved( Chuck_Env * env, const std::string & xid, int pos );
889	t_CKBOOL type_engine_check_reserved( Chuck_Env * env, S_Symbol xid, int pos );	930	t_CKBOOL type_engine_check_reserved( Chuck_Env * env, S_Symbol xid, int pos );
890	// 1.4.1.0 (ge): abilty to toggle reserved words for special cases, such as Math.pi co-existing with pi (use with care!)	931	// 1.4.1.0 (ge): abilty to toggle reserved words for special cases, such as Math.pi co-existing with pi (use with care!)
@@ -893,17 +934,21 @@ t_CKBOOL type_engine_check_primitive( Chuck_Env * env, Chuck_Type * type ); · 2 unmodified lines
893	t_CKBOOL type_engine_check_const( Chuck_Env * env, a_Exp e, int pos ); // TODO	934	t_CKBOOL type_engine_check_const( Chuck_Env * env, a_Exp e, int pos ); // TODO
894	t_CKBOOL type_engine_compat_func( a_Func_Def lhs, a_Func_Def rhs, int pos, std::string & err, t_CKBOOL print = TRUE );	935	t_CKBOOL type_engine_compat_func( a_Func_Def lhs, a_Func_Def rhs, int pos, std::string & err, t_CKBOOL print = TRUE );
895	t_CKBOOL type_engine_get_deprecate( Chuck_Env * env, const std::string & from, std::string & to );	936	t_CKBOOL type_engine_get_deprecate( Chuck_Env * env, const std::string & from, std::string & to );
		937	t_CKBOOL type_engine_is_base_static( Chuck_Env * env, Chuck_Type * baseType ); // 1.5.0.0 (ge) added
896	Chuck_Type * type_engine_find_common_anc( Chuck_Type * lhs, Chuck_Type * rhs );	938	Chuck_Type * type_engine_find_common_anc( Chuck_Type * lhs, Chuck_Type * rhs );
897	Chuck_Type * type_engine_find_type( Chuck_Env * env, a_Id_List path );	939	Chuck_Type * type_engine_find_type( Chuck_Env * env, a_Id_List path );
		940	Chuck_Type * type_engine_find_type( Chuck_Env * env, const std::string & name ); // 1.5.0.0 (ge) added
898	Chuck_Value * type_engine_find_value( Chuck_Type * type, const std::string & xid );	941	Chuck_Value * type_engine_find_value( Chuck_Type * type, const std::string & xid );
899	Chuck_Value * type_engine_find_value( Chuck_Type * type, S_Symbol xid );	942	Chuck_Value * type_engine_find_value( Chuck_Type * type, S_Symbol xid );
900	Chuck_Value * type_engine_find_value( Chuck_Env * env, const std::string & xid, t_CKBOOL climb, int linepos = 0 );	943	Chuck_Value * type_engine_find_value( Chuck_Env * env, const std::string & xid, t_CKBOOL climb, int linepos = 0 );
901	Chuck_Namespace * type_engine_find_nspc( Chuck_Env * env, a_Id_List path );	944	Chuck_Namespace * type_engine_find_nspc( Chuck_Env * env, a_Id_List path );
902	/*******************************************************************************	945
903	* spencer: added this into function to provide the same logic path	946
904	* for type_engine_check_exp_decl() and ck_add_mvar() when they determine	947	//-----------------------------------------------------------------------------
905	* offsets for mvars -- added 1.3.0.0	948	// spencer: added this into function to provide the same logic path
906	******************************************************************************/	949	// for type_engine_check_exp_decl() and ck_add_mvar() when they determine
		950	// offsets for mvars -- added 1.3.0.0
		951	//-----------------------------------------------------------------------------
907	t_CKUINT type_engine_next_offset( t_CKUINT current_offset, Chuck_Type * type );	952	t_CKUINT type_engine_next_offset( t_CKUINT current_offset, Chuck_Type * type );
908	// array verify	953	// array verify
909	t_CKBOOL verify_array( a_Array_Sub array );	954	t_CKBOOL verify_array( a_Array_Sub array );
@@ -914,7 +959,11 @@ Chuck_Type * new_array_type( Chuck_Env * env, Chuck_Type * array_parent, · 4 unmodified lines
914	// make type \| 1.4.1.1 (nshaheed) added	959	// make type \| 1.4.1.1 (nshaheed) added
915	Chuck_Type * new_array_element_type( Chuck_Env * env, Chuck_Type * base_type,	960	Chuck_Type * new_array_element_type( Chuck_Env * env, Chuck_Type * base_type,
916	t_CKUINT depth, Chuck_Namespace * owner_nspc);	961	t_CKUINT depth, Chuck_Namespace * owner_nspc);
		962
		963
		964	//-----------------------------------------------------------------------------
917	// conversion	965	// conversion
		966	//-----------------------------------------------------------------------------
918	const char * type_path( a_Id_List path );	967	const char * type_path( a_Id_List path );
919	a_Id_List str2list( const std::string & path );	968	a_Id_List str2list( const std::string & path );
920	a_Id_List str2list( const std::string & path, t_CKBOOL & is_array );	969	a_Id_List str2list( const std::string & path, t_CKBOOL & is_array );
@@ -922,7 +971,19 @@ const char * howmuch2str( te_HowMuch how_much ); · 1 unmodified line
922	t_CKBOOL escape_str( char * str_lit, int linepos );	971	t_CKBOOL escape_str( char * str_lit, int linepos );
923	t_CKINT str2char( const char * char_lit, int linepos );	972	t_CKINT str2char( const char * char_lit, int linepos );
924		973
		974
		975	//-----------------------------------------------------------------------------
		976	// more helper functions for type scan and checking \| 1.5.0.0 (ge) added
		977	//-----------------------------------------------------------------------------
		978	// compare two argument lists to see if they are the same (sequence of types)
		979	t_CKBOOL same_arg_lists( a_Arg_List lhs, a_Arg_List rhs );
		980	// generate a string from an argument list (types only)
		981	std::string arglist2string( a_Arg_List list );
		982
		983
		984	//-----------------------------------------------------------------------------
925	// REFACTOR-2017: exile! these default types now stored in env	985	// REFACTOR-2017: exile! these default types now stored in env
		986	//-----------------------------------------------------------------------------
926	//extern Chuck_Type t_void;	987	//extern Chuck_Type t_void;
927	//extern Chuck_Type t_int;	988	//extern Chuck_Type t_int;
928	//extern Chuck_Type t_float;	989	//extern Chuck_Type t_float;

chuck/include/ugen_stk.h+4−6

 // versions higher than 4.1.2 and replaced with the variable
 // "StkFloat".
 //typedef double StkFloat;
-//#if defined(__WINDOWS_DS__) || defined(__WINDOWS_ASIO__)
+//#if defined(__PLATFORM_WIN32__) ||
 //  #pragma deprecated(MY_FLOAT)
 //#else
 //  typedef StkFloat MY_FLOAT __attribute__ ((deprecated));
 #if defined(__WINDOWS_PTHREAD__)
   #define __OS_WINDOWS_CYGWIN__
   #define __STK_REALTIME__
-#elif defined(__WINDOWS_DS__) || defined(__WINDOWS_ASIO__)
+#elif defined(__PLATFORM_WIN32__)
   #define __OS_WINDOWS__
   #define __STK_REALTIME__
 #elif defined(__PLATFORM_LINUX__)
   virtual void controlChange(int number, MY_FLOAT value);
 public: // SWAP formerly protected
+  MY_FLOAT lastOutput;
   // chuck
   t_CKFLOAT m_frequency;
-  MY_FLOAT lastOutput;
 };
   MY_FLOAT __FM_gains[100];
   MY_FLOAT __FM_susLevels[16];
   MY_FLOAT __FM_attTimes[32];
 };
 #endif
     The user is responsible for checking the values
     returned by the read/write methods.  Values
     less than or equal to zero indicate a closed
-    or lost connection or the occurence of an error.
+    or lost connection or the occurrence of an error.
     by Perry R. Cook and Gary P. Scavone, 1995 - 2002.
 */

chuck/include/ulib_ai.h+159−19

@@ -24,17 +24,66 @@ · 23 unmodified lines
24		24
25	//-----------------------------------------------------------------------------	25	//-----------------------------------------------------------------------------
26	// file: ulib_ai.h	26	// file: ulib_ai.h
27	// desc: class library for libAI -- part of ChAI (ChucK for AI)	27	// desc: Music and AI class library; part of ChAI (ChucK for AI)
28	//	28	//
29	// author: Ge Wang (ge@ccrma.stanford.edu)	29	// date: Fall 2022 -- present
30	// Yikai Li (yikaili@stanford.edu)	30	// authors: Ge Wang (ge@ccrma.stanford.edu)
31	// date: Fall 2022	31	// Yikai Li (yikaili@stanford.edu)
		32	//
		33	// (HISTORICAL NOTE)
		34	// Much of ChAI and its ways of thinking and doing can be foundationally
		35	// attributed to the work of Dr. Rebecca Fiebrink, her landmark Ph.D. Thesis,
		36	// /Real-time Human Interaction With Supervised Learning Algorithms for Music
		37	// Composition and Performance/ (2011) [1], the Wekinator framework [2], her
		38	// teaching at the intersections of AI, HCI, and Music [3], as well as earlier
		39	// collaborations between Rebecca and Ge [4,5] including SMIRK [6] (Small Musical
		40	// Information Retrieval toolKit; 2008; MARSYAS and the MIR work of Dr. George
		41	// Tzanetakis; early efforts in on-the-fly learning), the unit analyzer
		42	// framework [7] (2007; afford real-time audio feature extraction). All of
		43	// these have directly or indirectly contributed the creation of ChAI.
		44	// Additionally, ChAI benefitted from the teaching and design philosophy of
		45	// Dr. Perry R. Cook (Ph.D. advisor to Rebecca, George, and Ge at Princeton,
		46	// and ChucK co-author), who argued for real-time human interaction, parametric
		47	// sound synthesis, and the importance of play in the design of musical tools.
		48	//
		49	// [1] Fiebrink, Rebecca. 2011. /Real-time Human Interaction With Supervised
		50	// Learning Algorithms for Music Composition and Performance/ Ph.D. Thesis.
		51	// Princeton University. https://www.cs.princeton.edu/techreports/2010/891.pdf
		52	//
		53	// [2] http://www.wekinator.org/
		54	// Wekinator \| Software for real-time, interactive machine learning
		55	//
		56	// [3] Fiebrink, Rebecca. "Machine Learning for Musicians and Artists" MOOC
		57	// https://www.kadenze.com/courses/machine-learning-for-musicians-and-artists/info
		58	//
		59	// [4] Fiebrink, R., G. Wang, P. R. Cook. 2008. "Foundations for On-the-fly
		60	// Learning in the ChucK Programming Language." /International Computer Music
		61	// Conference/. https://mcd.stanford.edu/publish/files/2008-icmc-learning.pdf
		62	//
		63	// [5] Fiebrink, R., G. Wang, P. R. Cook. 2008. "Support for Music Information
		64	// Retrieval in the ChucK Programming Language." /International Conference
		65	// on Music Information Retrieval/ (ISMIR).
		66	// https://mcd.stanford.edu/publish/files/2008-ismir-proto.pdf
		67	//
		68	// [6] http://smirk.cs.princeton.edu/
		69	// sMIRk \| Small Music Information Retrieval toolKit
		70	//
		71	// [7] Tzanetakis, G. and P. R. Cook. 2000 "MARSYAS: A Framework for Audio
		72	// Analysis." Organised Sound. 4:(3)
		73	//
		74	// [8] Tzanetakis, G. and P. R. Cook. 2002 "Musical Genre Classification of
		75	// Audio Signals." IEEE Transaction on Speech and Audio Processing. 10(5).
		76	//
		77	// [9] Wang, G., R. Fiebrink, P. R. Cook. 2007. "Combining Analysis and
		78	// Synthesis in the ChucK Programming Language." /International Computer
		79	// Music Conference/. https://mcd.stanford.edu/publish/files/2007-icmc-uana.pdf
32	//-----------------------------------------------------------------------------	80	//-----------------------------------------------------------------------------
33	#ifndef __ULIB_AI_H__	81	#ifndef __ULIB_AI_H__
34	#define __ULIB_AI_H__	82	#define __ULIB_AI_H__
35		83
36	#include "chuck_dl.h"	84	#include "chuck_dl.h"
37	#include "chuck_errmsg.h"	85	#include "chuck_errmsg.h"
		86	#include "util_math.h"
38		87
39		88
40		89
@@ -86,7 +135,7 @@ public: · 45 unmodified lines
86	if( !m_matrix )	135	if( !m_matrix )
87	{	136	{
88	// error	137	// error
89	CK_FPRINTF_STDERR( "[chuck]: ChaiMatrixFast allocation failure: %s, %d x %d...",	138	CK_FPRINTF_STDERR( "[chuck]: ChaiMatrixFast allocation failure: %s, %d x %d...\n",
90	typeid( T ).name(), xDim, yDim );	139	typeid( T ).name(), xDim, yDim );
91	// bail	140	// bail
92	return FALSE;	141	return FALSE;
@@ -106,18 +155,22 @@ public: · 13 unmodified lines
106	if( x < 0 \|\| x >= m_xDim \|\| y < 0 \|\| y >= m_yDim )	155	if( x < 0 \|\| x >= m_xDim \|\| y < 0 \|\| y >= m_yDim )
107	{	156	{
108	// error	157	// error
109	CK_FPRINTF_STDERR( "[chuck]: ChaiMatrixFast out of bound: %s[%d][%d]...",	158	CK_FPRINTF_STDERR( "[chuck]: ChaiMatrixFast out of bound: %s[%d][%d]...\n",
110	typeid( T ).name(), x, y );	159	typeid( T ).name(), x, y );
111	// halt	160	// halt
112	// TODO: this should throw (a shred-level, probably) exception	161	// TODO: this should throw (a shred-level, probably) exception
113	assert( FALSE );	162	assert( FALSE );
114	}	163	}
115		164
116	// NOTE: this is NOT bound-checked!!!
117	// NOTE: yet, this is arguably no worse than using c 2d arrays
118	return m_matrix[x * m_yDim + y];	165	return m_matrix[x * m_yDim + y];
119	}	166	}
120		167
		168	// overloaded operator
		169	T & operator()( t_CKINT x, t_CKINT y )
		170	{
		171	return v( x, y );
		172	}
		173
121	// get dimensions	174	// get dimensions
122	t_CKINT xDim() const	175	t_CKINT xDim() const
123	{ return m_xDim; }	176	{ return m_xDim; }
@@ -138,9 +191,6 @@ protected: · 14 unmodified lines
138	t_CKINT m_yDim;	191	t_CKINT m_yDim;
139	};	192	};
140		193
141
142
143
144	//-----------------------------------------------------------------------------	194	//-----------------------------------------------------------------------------
145	// name: class ChaiVectorFast \| 1.4.2.0 (ge) added	195	// name: class ChaiVectorFast \| 1.4.2.0 (ge) added
146	// desc: a templated fast access but not bound-checked 1D array	196	// desc: a templated fast access but not bound-checked 1D array
@@ -185,7 +235,7 @@ public: · 38 unmodified lines
185	if( !m_vector )	235	if( !m_vector )
186	{	236	{
187	// error	237	// error
188	CK_FPRINTF_STDERR( "[chuck]: ChaiVectorFast allocation failure: %s[%d]...",	238	CK_FPRINTF_STDERR( "[chuck]: ChaiVectorFast allocation failure: %s[%d]...\n",
189	typeid( T ).name(), length );	239	typeid( T ).name(), length );
190	// bail	240	// bail
191	return FALSE;	241	return FALSE;
@@ -197,30 +247,69 @@ public: · 5 unmodified lines
197	return TRUE;	247	return TRUE;
198	}	248	}
199		249
		250	void shuffle()
		251	{
		252	T temp;
		253	t_CKINT j;
		254	for( t_CKINT i = m_length - 1; i > 0; i-- )
		255	{
		256	j = ck_random() % ( i + 1 );
		257	temp = m_vector[i];
		258	m_vector[i] = m_vector[j];
		259	m_vector[j] = temp;
		260	}
		261	}
		262
200	t_CKUINT length()	263	t_CKUINT length()
201	{ return m_length; }	264	{ return m_length; }
202		265
203	t_CKINT size()	266	t_CKINT size()
204	{ return m_length; }	267	{ return m_length; }
205		268
206	// get element value	269	T getMax()
207	T & v( t_CKINT i )	270	{
		271	T max = m_vector[0];
		272	for( t_CKINT i = 1; i < m_length; i++ )
		273	{
		274	if( m_vector[i] > max )
		275	{
		276	max = m_vector[i];
		277	}
		278	}
		279	return max;
		280	}
		281
		282	void setAll( T value )
		283	{
		284	// iterate
		285	for( t_CKINT i = 0; i < m_length; i++ )
		286	{
		287	// set to value
		288	m_vector[i] = value;
		289	}
		290	}
		291
		292	T & operator[]( t_CKINT i )
208	{	293	{
209	// at least do a check	294	// at least do a check
210	if( i < 0 \|\| i >= m_length )	295	if( i < 0 \|\| i >= m_length )
211	{	296	{
212	// error	297	// error
213	CK_FPRINTF_STDERR( "[chuck]: ChaiVectorFast out of bound: %s[%d]...",	298	CK_FPRINTF_STDERR( "[chuck]: ChaiVectorFast out of bound: %s[%d] (capacity=%d)...\n",
214	typeid( T ).name(), i );	299	typeid( T ).name(), i, m_length );
215	// TODO: this should throw (a shred-level, probably) exception	300	// TODO: this should throw (a shred-level, probably) exception
216	assert( FALSE );	301	assert( FALSE );
217	}	302	}
218		303
219	// NOTE: this is NOT bound-checked!!!
220	// NOTE: yet, this is arguably no worse than using c arrays
221	return m_vector[i];	304	return m_vector[i];
222	}	305	}
223		306
		307	// get element value
		308	T & v( t_CKINT i )
		309	{
		310	return ( *this )[i];
		311	}
		312
224	void cleanup()	313	void cleanup()
225	{	314	{
226	// reclaim array memory and zero the pointer	315	// reclaim array memory and zero the pointer
@@ -229,9 +318,60 @@ public: · 2 unmodified lines
229	m_length = 0;	318	m_length = 0;
230	}	319	}
231		320
232	protected:	321	public:
233	T * m_vector;	322	T * m_vector;
234	t_CKINT m_length;	323	t_CKINT m_length;
235	};	324	};
236		325
237	#endif	326	#endif
		327
		328	#ifndef _KD_TREE_H
		329	#define _KD_TREE_H
		330
		331	#include <float.h>
		332	// #define DBL_EPSILON 2.2204460492503131e-16
		333
		334	#define KDTREE_MAX_LEVEL 64
		335	#define KDTREE_LEFT_INDEX 0
		336	#define KDTREE_RIGHT_INDEX 1
		337
		338	typedef struct knn_list
		339	{
		340	struct kdnode * node;
		341	double distance;
		342	struct knn_list * prev;
		343	struct knn_list * next;
		344	} knn_list_t;
		345
		346	typedef struct kdnode
		347	{
		348	long coord_index;
		349	double * coord;
		350	struct kdnode * left;
		351	struct kdnode * right;
		352	t_CKINT r;
		353	} kdnode_t;
		354
		355	typedef struct kdtree
		356	{
		357	struct kdnode * root;
		358	size_t count;
		359	size_t capacity;
		360	double * coords;
		361	double ** coord_table;
		362	long * coord_indexes;
		363	unsigned char * coord_deleted;
		364	unsigned char * coord_passed;
		365	struct knn_list knn_list_head;
		366	t_CKINT dim;
		367	t_CKINT knn_num;
		368	} kdtree_t;
		369
		370	struct kdtree * kdtree_init( t_CKINT dim );
		371	void kdtree_insert( struct kdtree * tree, double * coord );
		372	void kdtree_rebuild( struct kdtree * tree );
		373	void kdtree_knn_search( struct kdtree * tree, double * coord, t_CKINT k );
		374	void kdtree_destroy( struct kdtree * tree );
		375	void kdtree_dump( struct kdtree * tree );
		376
		377	#endif /* _KD_TREE_H */

chuck/include/ulib_machine.h+8−11

@@ -42,24 +42,21 @@ struct Chuck_Compiler; · 41 unmodified lines
42		42
43	// query	43	// query
44	DLL_QUERY machine_query( Chuck_DL_Query * QUERY );	44	DLL_QUERY machine_query( Chuck_DL_Query * QUERY );
		45
		46	#ifndef __DISABLE_OTF_SERVER__
45	typedef t_CKUINT (* proc_msg_func)( Chuck_VM , Chuck_Compiler ,	47	typedef t_CKUINT (* proc_msg_func)( Chuck_VM , Chuck_Compiler ,
46	Net_Msg , t_CKBOOL, void );	48	Net_Msg , t_CKBOOL, void );
47	t_CKBOOL machine_init( Chuck_Compiler * compiler, proc_msg_func func );	49	t_CKBOOL machine_init( Chuck_Compiler * compiler, proc_msg_func func );
48	// 1.4.0.1: TODO: refactor out of ulib machine; not all platforms have OTF	50	// 1.4.0.1: TODO: refactor out of ulib machine; not all platforms have OTF
		51	#endif // __DISABLE_OTF_SERVER__
		52
		53	// machine exports
49	t_CKUINT machine_intsize();	54	t_CKUINT machine_intsize();
50		55
51		56
52	// exports	57	// ckdoc query
53	CK_DLL_SFUN( machine_crash_impl );	58	DLL_QUERY ckdoc_query( Chuck_DL_Query * QUERY );
54	CK_DLL_SFUN( machine_add_impl );	59
55	CK_DLL_SFUN( machine_spork_impl );
56	CK_DLL_SFUN( machine_remove_impl );
57	CK_DLL_SFUN( machine_replace_impl );
58	CK_DLL_SFUN( machine_status_impl );
59	CK_DLL_SFUN( machine_intsize_impl );
60	CK_DLL_SFUN( machine_shreds_impl );
61	CK_DLL_SFUN( machine_realtime_impl );
62	CK_DLL_SFUN( machine_silent_impl );
63		60
64		61
65	#endif	62	#endif

chuck/include/ulib_math.h+11−0

@@ -90,6 +90,17 @@ CK_DLL_SFUN( srandom_impl ); · 89 unmodified lines
90		90
91	CK_DLL_SFUN( gauss_impl );	91	CK_DLL_SFUN( gauss_impl );
92		92
		93	CK_DLL_SFUN( cossim_impl );
		94	CK_DLL_SFUN( cossim3d_impl );
		95	CK_DLL_SFUN( cossim4d_impl );
		96
		97	CK_DLL_SFUN( euclidean_impl );
		98	CK_DLL_SFUN( euclidean3d_impl );
		99	CK_DLL_SFUN( euclidean4d_impl );
		100
		101	CK_DLL_SFUN( map_impl );
		102	CK_DLL_SFUN( map2_impl );
		103
93		104
94		105
95		106

chuck/include/util_hid.h+2−0

@@ -32,6 +32,8 @@ · 31 unmodified lines
32	#ifndef __UTIL_HID_H__	32	#ifndef __UTIL_HID_H__
33	#define __UTIL_HID_H__	33	#define __UTIL_HID_H__
34		34
		35	#include "chuck_def.h"
		36
35		37
36		38
37		39

chuck/include/util_math.h+2−1

 #define __UTIL_MATH_H__
 #include <math.h>
+#include "chuck_def.h" // 1.4.1.0 (ge) for t_CKINT
 #if defined (__cplusplus) || defined(_cplusplus)
 extern "C" {
 // max for random functions
-#ifdef __WINDOWS_DS__
+#ifdef __PLATFORM_WIN32__
 #define CK_RANDOM_MAX RAND_MAX
 #else
 #define CK_RANDOM_MAX 0x7fffffff

chuck/include/util_network.h+1−0

@@ -41,6 +41,7 @@ · 40 unmodified lines
41	#include <sys/socket.h>	41	#include <sys/socket.h>
42	#include <netinet/in.h>	42	#include <netinet/in.h>
43	#else	43	#else
		44	#define _WINSOCKAPI_
44	#include <windows.h>	45	#include <windows.h>
45	#endif	46	#endif
46		47

chuck/include/util_opsc.h+1−0

@@ -41,6 +41,7 @@ · 40 unmodified lines
41		41
42	// the included files were from the CNMAT OSC-Kit distrib.	42	// the included files were from the CNMAT OSC-Kit distrib.
43	#ifdef __PLATFORM_WIN32__	43	#ifdef __PLATFORM_WIN32__
		44	#define _WINSOCKAPI_
44	#include <windows.h>	45	#include <windows.h>
45	#endif	46	#endif
46		47

chuck/include/util_serial.h+2−0

@@ -32,6 +32,8 @@ · 31 unmodified lines
32	#ifndef __UTIL_SERIAL_H__	32	#ifndef __UTIL_SERIAL_H__
33	#define __UTIL_SERIAL_H__	33	#define __UTIL_SERIAL_H__
34		34
		35	#include "chuck_def.h"
		36
35	#include <vector>	37	#include <vector>
36	#include <string>	38	#include <string>
37		39

chuck/include/util_sndfile.h+7−1

 {
   /* keep sorted for wav_w64_format_str() */
     WAVE_FORMAT_UNKNOWN                 = 0x0000,       /* Microsoft Corporation */
-    WAVE_FORMAT_PCM                     = 0x0001,       /* Microsoft PCM format */
+    WAVE_FORMAT_MS_PCM                  = 0x0001,       /* Microsoft PCM format */
+    /* -------------------------------------------------------------------------
+    creating and using WAVE_FORMAT_MS_PCM in this module, as WAVE_FORMAT_PCM may
+    be defined by windows, e.g., in mmeapi.h -- which breaks the build...thanks
+    important: WAVE_FORMAT_MS_PCM must be 1, as WAV format tag | 1.5.0.0 (ge)
+    ------------------------------------------------------------------------- */
+    /* WAVE_FORMAT_PCM                  = 0x0001, */    /* Microsoft PCM format */
     WAVE_FORMAT_MS_ADPCM                = 0x0002,       /* Microsoft ADPCM */
     WAVE_FORMAT_IEEE_FLOAT              = 0x0003,       /* Micrososft 32 bit float format */
     WAVE_FORMAT_VSELP                   = 0x0004,       /* Compaq Computer Corporation */

chuginate/template/chuck/include/chuck.h+15−17

 /*----------------------------------------------------------------------------
  ChucK Concurrent, On-the-fly Audio Programming Language
    Compiler and Virtual Machine
  Copyright (c) 2003 Ge Wang and Perry R. Cook.  All rights reserved.
    http://chuck.stanford.edu/
    http://chuck.cs.princeton.edu/
  This program is free software; you can redistribute it and/or modify
  it under the terms of the GNU General Public License as published by
  the Free Software Foundation; either version 2 of the License, or
  (at your option) any later version.
  This program is distributed in the hope that it will be useful,
  but WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  GNU General Public License for more details.
  You should have received a copy of the GNU General Public License
  along with this program; if not, write to the Free Software
  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
 //-----------------------------------------------------------------------------
 // file: chuck.h
-// desc: chuck engine header; VM + compiler + state; no audio I/O
+// desc: chuck engine header; VM + compiler + state; independent of audio I/O
 //       REFACTOR-2017
 //
-// author: Ge Wang (http://www.gewang.com/)
+// author: Ge Wang (https://ccrma.stanford.edu/~ge/)
 // date: fall 2017
 //
 // additional authors:
     ChucK();
     // desctructor
     virtual ~ChucK();
 public:
     // set parameter by name
     // -- all params should have reasonable defaults
 public:
     // compile a file (can be called anytime)
-    bool compileFile( const std::string & path, const std::string & argsTogether, int count = 1 );
+    bool compileFile( const std::string & path, const std::string & argsTogether, t_CKINT count = 1 );
     // compile code directly
-    bool compileCode( const std::string & code, const std::string & argsTogether, int count = 1 );
+    bool compileCode( const std::string & code, const std::string & argsTogether, t_CKINT count = 1 );
 public:
     // initialize ChucK (using params)
 public:
     // run engine (call from callback)
-    void run( SAMPLE * input, SAMPLE * output, int numFrames );
+    void run( SAMPLE * input, SAMPLE * output, t_CKINT numFrames );
 public:
     // is initialized
     bool isInit() { return m_init; }
 public:
     // additional native chuck bindings/types (use with extra caution)
     bool bind( f_ck_query queryFunc, const std::string & name );
 public: // static functions
     // chuck version
     static const char * version();
-    #ifndef __DISABLE_OTF_SERVER__
     // chuck int size (in bits)
-    // (this depends on machine, which depends on OTF, so
+    // (this depends on machine, which depends on OTF, so disable it if we don't have OTF)
-    //  disable it if we don't have OTF)
+    // 1.5.0.0 (ge) | reinstated for non-OTF, along with parts of machine
     static t_CKUINT intSize();
-    #endif
     // number of ChucK's
     static t_CKUINT numVMs() { return o_numVMs; };
     // --poop compatibilty
     static const char VERSION[];
     // number of VMs -- managed from VM constructor/destructors
     static t_CKUINT o_numVMs;
 protected:
     // initialize default params
     void initDefaultParams();
     bool initChugins();
     // init OTF programming system
     bool initOTF();
 protected:
     // core elements: compiler, VM, etc.
     Chuck_Carrier * m_carrier;

chuginate/template/chuck/include/chuck.tab.h+1−1

@@ -266,7 +266,7 @@ · 265 unmodified lines
266		266
267	#if ! defined YYSTYPE && ! defined YYSTYPE_IS_DECLARED	267	#if ! defined YYSTYPE && ! defined YYSTYPE_IS_DECLARED
268	typedef union YYSTYPE	268	typedef union YYSTYPE
269	#line 62 "chuck.y"	269	#line 65 "chuck.y"
270	{	270	{
271	int pos;	271	int pos;
272	int ival;	272	int ival;

chuginate/template/chuck/include/chuck_absyn.h+15−14

     ae_op_s_or_chuck, ae_op_s_xor_chuck, ae_op_shift_right_chuck,
     ae_op_shift_left_chuck, ae_op_percent_chuck, ae_op_s_chuck,
     ae_op_plusplus, ae_op_minusminus, ae_op_tilda, ae_op_exclamation,
     ae_op_at_chuck, ae_op_unchuck, ae_op_upchuck, ae_op_spork,
     ae_op_typeof, ae_op_sizeof, ae_op_new, ae_op_arrow_left, ae_op_arrow_right
 } ae_Operator;
 // forward reference for type
 typedef struct Chuck_Type * t_CKTYPE;
 typedef struct Chuck_Value * t_CKVALUE;
 typedef struct Chuck_Func * t_CKFUNC;
 typedef struct Chuck_Namespace * t_CKNSPC;
 typedef struct Chuck_VM_Code * t_CKVMCODE;
                      t_CKTYPE ck_type; int linepos; a_Exp self; };
 struct a_Exp_Hack_ { a_Exp exp; int linepos; a_Exp self; };
 struct a_Var_Decl_List_ { a_Var_Decl var_decl; a_Var_Decl_List next; int linepos; a_Exp self; };
+// 1.4.2.0 (ge) added ck_type and ref, to handle multiple array decl (e.g., int x, y[], z[1];)
 struct a_Var_Decl_ { S_Symbol xid; a_Var_Decl var_decl; a_Array_Sub array; t_CKVALUE value;
-                     void * addr; int linepos; a_Exp self; };
+                     void * addr; t_CKTYPE ck_type; int ref; int linepos; a_Exp self; };
 struct a_Type_Decl_ { a_Id_List xid; a_Array_Sub array; int ref; int linepos; /*a_Exp self;*/ };
 struct a_Array_Sub_ { t_CKUINT depth; a_Exp exp_list; int linepos; a_Exp self;
                       int err_num; int err_pos; };
 struct a_Arg_List_ { a_Type_Decl type_decl; a_Var_Decl var_decl; t_CKTYPE type;
                      a_Arg_List next; int linepos; a_Exp self; };
 struct a_Vec_ { a_Exp args; int numdims; int linepos; a_Exp self; }; // ge: added 1.3.5.3
 // enum primary exp type
 typedef enum { ae_primary_var, ae_primary_num, ae_primary_float,
                ae_primary_str, ae_primary_array, ae_primary_exp,
                ae_primary_hack, ae_primary_complex, ae_primary_polar,
                ae_primary_vec, ae_primary_char, ae_primary_nil
 {
     ae_Exp_Primary_Type s_type;
     t_CKVALUE value;
     union
     {
         S_Symbol var;
     t_CKUINT group_size;
     t_CKTYPE cast_to;
     t_CKUINT emit_var; // 1 = emit var, 2 = emit var and value
     union
     {
         struct a_Exp_Binary_ binary;
 // enum values for stmt type
 typedef enum { ae_stmt_exp, ae_stmt_while, ae_stmt_until, ae_stmt_for, ae_stmt_loop,
                ae_stmt_if, ae_stmt_code, ae_stmt_switch, ae_stmt_break,
                ae_stmt_continue, ae_stmt_return, ae_stmt_case, ae_stmt_gotolabel
              } ae_Stmt_Type;
 struct a_Stmt_
 {
     ae_Stmt_Type s_type;
     int skip;
     union
     {
         a_Exp stmt_exp;
 };
 struct a_Stmt_List_ { a_Stmt stmt; a_Stmt_List next; int linepos; };
 struct a_Class_Def_ { ae_Keyword decl; a_Id_List name; a_Class_Ext ext;
                       a_Class_Body body; t_CKTYPE type; int iface; t_CKNSPC home;
                       int linepos; };
 struct a_Class_Ext_ { a_Id_List extend_id; a_Id_List impl_list; int linepos; };
 // struct t_Func_BuiltIn_ { builtin_func_ptr func_ptr; int linepos; };
 struct a_Func_Def_ {
     ae_Keyword func_decl;
     ae_Keyword static_decl;
     a_Type_Decl type_decl;
     t_CKTYPE ret_type;
     S_Symbol name;
     a_Arg_List arg_list;
     a_Stmt code;
     t_CKFUNC ck_func;
 struct a_Section_
 {
     ae_Section_Type s_type;
     union
     {
         a_Stmt_List stmt_list;

chuginate/template/chuck/include/chuck_carrier.h+8−8

@@ -1,21 +1,21 @@
1	/*----------------------------------------------------------------------------	1	/*----------------------------------------------------------------------------
2	ChucK Concurrent, On-the-fly Audio Programming Language	2	ChucK Concurrent, On-the-fly Audio Programming Language
3	Compiler and Virtual Machine	3	Compiler and Virtual Machine
4		4
5	Copyright (c) 2003 Ge Wang and Perry R. Cook. All rights reserved.	5	Copyright (c) 2003 Ge Wang and Perry R. Cook. All rights reserved.
6	http://chuck.stanford.edu/	6	http://chuck.stanford.edu/
7	http://chuck.cs.princeton.edu/	7	http://chuck.cs.princeton.edu/
8		8
9	This program is free software; you can redistribute it and/or modify	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	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	11	the Free Software Foundation; either version 2 of the License, or
12	(at your option) any later version.	12	(at your option) any later version.
13		13
14	This program is distributed in the hope that it will be useful,	14	This program is distributed in the hope that it will be useful,
15	but WITHOUT ANY WARRANTY; without even the implied warranty of	15	but WITHOUT ANY WARRANTY; without even the implied warranty of
16	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the	16	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17	GNU General Public License for more details.	17	GNU General Public License for more details.
18		18
19	You should have received a copy of the GNU General Public License	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	20	along with this program; if not, write to the Free Software
21	Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307	21	Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
@@ -75,20 +75,20 @@ struct Chuck_Carrier · 53 unmodified lines
75	Chuck_VM * vm;	75	Chuck_VM * vm;
76	Chuck_IO_Chout * chout;	76	Chuck_IO_Chout * chout;
77	Chuck_IO_Cherr * cherr;	77	Chuck_IO_Cherr * cherr;
78		78
79	#ifndef __DISABLE_OTF_SERVER__	79	#ifndef __DISABLE_OTF_SERVER__
80	// OTF programming things	80	// OTF programming things
81	ck_socket otf_socket;	81	ck_socket otf_socket;
82	t_CKINT otf_port;	82	t_CKINT otf_port;
83	CHUCK_THREAD otf_thread;	83	CHUCK_THREAD otf_thread;
84	#endif	84	#endif
85		85
86	// STK-specific	86	// STK-specific
87	#ifndef __DISABLE_WVOUT__	87	#ifndef __DISABLE_WVOUT__
88	XWriteThread * stk_writeThread;	88	XWriteThread * stk_writeThread;
89	std::map<WvOut , WvOut > stk_wvOutMap;	89	std::map<WvOut , WvOut > stk_wvOutMap;
90	#endif	90	#endif
91		91
92	// constructor	92	// constructor
93	Chuck_Carrier() :	93	Chuck_Carrier() :
94	chuck(NULL),	94	chuck(NULL),
@@ -107,7 +107,7 @@ struct Chuck_Carrier · 12 unmodified lines
107	cherr( NULL )	107	cherr( NULL )
108		108
109	{ }	109	{ }
110		110
111	// get hint: is realtime audio?	111	// get hint: is realtime audio?
112	t_CKBOOL hintIsRealtimeAudio();	112	t_CKBOOL hintIsRealtimeAudio();
113	};	113	};

chuginate/template/chuck/include/chuck_compile.h+23−11

 protected: // data
     // carrier
     Chuck_Carrier * m_carrier;
 public: // get protected data
     // REFACTOR-2017: get associated, per-compiler environment
     Chuck_Env * env() const { return m_carrier->env; }
     // set carrier
     t_CKBOOL setCarrier( Chuck_Carrier * c ) { m_carrier = c; return TRUE; }
 public: // data
     // emitter
     Chuck_Emitter * emitter;
     t_CKBOOL m_auto_depend;
     // recent map
     std::map<std::string, Chuck_Context *> m_recent;
+    // chugins
     std::list<Chuck_DLL *> m_dlls;
+    // libraries (ck code) to import
     std::list<std::string> m_cklibs_to_preload;
+    // origin hint; this flag is set to different te_Origin values
+    // to denote where new entities originate | 1.5.0.0 (ge) added
+    te_Origin m_originHint;
 public: // to all
     // contructor
     Chuck_Compiler();
     virtual ~Chuck_Compiler();
     // initialize
-    t_CKBOOL initialize( std::list<std::string> & chugin_search_paths,
+    t_CKBOOL initialize();
-                         std::list<std::string> & named_dls );
     // shutdown
     void shutdown();
     // set auto depend
     void set_auto_depend( t_CKBOOL v );
     // parse, type-check, and emit a program
     t_CKBOOL go( const std::string & filename, FILE * fd = NULL,
                  const char * str_src = NULL, const std::string & full_path = "" );
     // resolve a type automatically, if auto_depend is on
     t_CKBOOL resolve( const std::string & type );
     // get the code generated from the last go()
     Chuck_VM_Code * output( );
 public: // replace-dac | added 1.4.1.0 (jack)
     // sets a "replacement dac": one global UGen is secretly used
     // as a stand-in for "dac" for this compilation;
     // for example, ChuckSubInstances in Chunity use a global Gain as a
     // replacement dac, then use the global getUGenSamples() function to
     // get the samples of the gain. this enables the creation
     // of a new sample sucker.
     void setReplaceDac( t_CKBOOL shouldReplaceDac, const std::string & replacement );
+public: // chugin load | refactored 1.4.1.0 (ge)
+    t_CKBOOL load_external_modules( const char * extension,
+                                    std::list<std::string> & chugin_search_paths,
+                                    std::list<std::string> & named_dls );
 protected: // internal
     // do entire file
     t_CKBOOL do_entire_file( Chuck_Context * context );
     // do all excect classes
     t_CKBOOL do_all_except_classes( Chuck_Context * context );
     // do normal compile
-    t_CKBOOL do_normal( const std::string & path, FILE * fd = NULL,
+    t_CKBOOL do_normal_depend( const std::string & path, FILE * fd = NULL,
-                        const char * str_src = NULL, const std::string & full_path = "" );
+        const char * str_src = NULL, const std::string & full_path = "" );
+    // do auto-depend compile
+    t_CKBOOL do_auto_depend( const std::string & path, FILE * fd = NULL,
+        const char * str_src = NULL, const std::string & full_path = "" );
     // look up in recent
     Chuck_Context * find_recent_path( const std::string & path );
     // look up in recent

chuginate/template/chuck/include/chuck_def.h+17−7

 // kinds (added 1.3.1.0 to faciliate 64-bit support)
 // to differentiate in case int and float have same size
-#define kindof_VOID                0
+#define kindof_VOID                 0
-#define kindof_INT                 1
+#define kindof_INT                  1
-#define kindof_FLOAT               2
+#define kindof_FLOAT                2
-#define kindof_COMPLEX             3
+#define kindof_COMPLEX              3
-#define kindof_VEC3                4
+#define kindof_VEC3                 4
-#define kindof_VEC4                5
+#define kindof_VEC4                 5
 typedef char *                      c_str;
 typedef const char *                c_constr;
 #define FALSE                       0
 #endif
+// special non-zero value to denote "no value" | added 1.4.2.0 (ge)
+#define CK_NO_VALUE                 0xffffffff
 // 3.1415926535897932384626433832795028841971693993751058209749445...
 #define ONE_PI (3.14159265358979323846)
 #define TWO_PI (2.0 * ONE_PI)
 #define SAFE_RELEASE(x)             do { if(x){ x->release(); x = NULL; } } while(0)
 #define SAFE_ADD_REF(x)             do { if(x){ x->add_ref(); } } while(0)
 #define SAFE_REF_ASSIGN(lhs,rhs)    do { SAFE_RELEASE(lhs); (lhs) = (rhs); SAFE_ADD_REF(lhs); } while(0)
+#define SAFE_FREE(x)                do { if(x){ free(x); x = NULL; } } while(0)
+#define SAFE_UNLOCK_DELETE(x)       do { if(x){ x->unlock(); delete x; x = NULL; } } while(0)
 #endif
 // max + min
 #ifdef __PLATFORM_WIN32__
 #ifndef usleep
-#define usleep(x) Sleep( (x / 1000 <= 0 ? 1 : x / 1000) )
+  #define usleep(x) Sleep( (x / 1000 <= 0 ? 1 : x / 1000) )
+#endif
+// 1.4.2.0 (ge and spencer) | added for legacy windows, as part of switch to snprintf
+// https://stackoverflow.com/questions/2915672/snprintf-and-visual-studio-2010
+#if defined(_MSC_VER) && _MSC_VER < 1900
+  #define snprintf(buf,len, format,...) _snprintf_s(buf, len,len, format, __VA_ARGS__)
 #endif
 #pragma warning (disable : 4996)  // stdio deprecation
 #pragma warning (disable : 4786)  // stl debug info

chuginate/template/chuck/include/chuck_dl.h+62−56

@@ -154,14 +154,14 @@ namespace Chuck_DL_Api { struct Api; } · 153 unmodified lines
154		154
155		155
156	// chuck dll export linkage and calling convention	156	// chuck dll export linkage and calling convention
157	#if defined (__PLATFORM_WIN32__)	157	#if defined (__PLATFORM_WIN32__)
158	#define CK_DLL_LINKAGE extern "C" __declspec( dllexport )	158	#define CK_DLL_LINKAGE extern "C" __declspec( dllexport )
159	#else	159	#else
160	#define CK_DLL_LINKAGE extern "C"	160	#define CK_DLL_LINKAGE extern "C"
161	#endif	161	#endif
162		162
163	// calling convention of functions provided by chuck to the dll	163	// calling convention of functions provided by chuck to the dll
164	#if defined(__WINDOWS_DS__)	164	#if defined(__PLATFORM_WIN32__)
165	#define CK_DLL_CALL _cdecl	165	#define CK_DLL_CALL _cdecl
166	#else	166	#else
167	#define CK_DLL_CALL	167	#define CK_DLL_CALL
@@ -183,7 +183,7 @@ typedef const Chuck_DL_Api::Api *CK_DL_API; · 15 unmodified lines
183	// example: CK_DLL_QUERY	183	// example: CK_DLL_QUERY
184	#ifndef __CK_DLL_STATIC__	184	#ifndef __CK_DLL_STATIC__
185	#define CK_DLL_QUERY(name) CK_DLL_DECLVERSION CK_DLL_EXPORT(t_CKBOOL) ck_query( Chuck_DL_Query * QUERY )	185	#define CK_DLL_QUERY(name) CK_DLL_DECLVERSION CK_DLL_EXPORT(t_CKBOOL) ck_query( Chuck_DL_Query * QUERY )
186	#else	186	#else
187	#define CK_DLL_QUERY(name) CK_DLL_QUERY_STATIC(name)	187	#define CK_DLL_QUERY(name) CK_DLL_QUERY_STATIC(name)
188	#endif // __CK_DLL_STATIC__	188	#endif // __CK_DLL_STATIC__
189	// macro for defining ChucK DLL export allocator	189	// macro for defining ChucK DLL export allocator
@@ -382,13 +382,13 @@ public: · 192 unmodified lines
382		382
383	// re-added 1.4.0.1	383	// re-added 1.4.0.1
384	f_create_main_thread_hook create_main_thread_hook;	384	f_create_main_thread_hook create_main_thread_hook;
385		385
386	// NOTE: everything below std::anything cannot be reliably accessed	386	// NOTE: everything below std::anything cannot be reliably accessed
387	// by offset between dynamic modules, since std::anything could be variable	387	// by offset between dynamic modules, since std::anything could be variable
388	// size -- put everything need to be accessed across modules above here!	388	// size -- put everything need to be accessed across modules above here!
389	// discovered by the vigilant and forever traumatized Jack Atherton,	389	// discovered by the vigilant and forever traumatized Jack Atherton,
390	// fixed during REFACTOR-2017; warning by the guilt-ridden Ge Wang	390	// fixed during REFACTOR-2017; warning by the guilt-ridden Ge Wang
391		391
392	// dll	392	// dll
393	Chuck_DLL * dll_ref;	393	Chuck_DLL * dll_ref;
394	// reserved	394	// reserved
@@ -410,7 +410,7 @@ public: · 15 unmodified lines
410	std::vector<Chuck_DL_Class *> classes;	410	std::vector<Chuck_DL_Class *> classes;
411	// stack	411	// stack
412	std::vector<Chuck_DL_Class * >stack;	412	std::vector<Chuck_DL_Class * >stack;
413		413
414	// constructor	414	// constructor
415	Chuck_DL_Query( Chuck_Carrier * carrier );	415	Chuck_DL_Query( Chuck_Carrier * carrier );
416	// desctructor	416	// desctructor
@@ -458,12 +458,12 @@ struct Chuck_DL_Class · 41 unmodified lines
458	std::vector<Chuck_DL_Class *> classes;	458	std::vector<Chuck_DL_Class *> classes;
459	// current mvar offset	459	// current mvar offset
460	t_CKUINT current_mvar_offset;	460	t_CKUINT current_mvar_offset;
461		461
462	t_CKUINT ugen_num_in, ugen_num_out;	462	t_CKUINT ugen_num_in, ugen_num_out;
463		463
464	std::string doc;	464	std::string doc;
465	std::vector<std::string> examples;	465	std::vector<std::string> examples;
466		466
467	// constructor	467	// constructor
468	Chuck_DL_Class() { dtor = NULL; ugen_tick = NULL; ugen_tickf = NULL; ugen_pmsg = NULL; uana_tock = NULL; ugen_pmsg = NULL; current_mvar_offset = 0; ugen_num_in = ugen_num_out = 0; }	468	Chuck_DL_Class() { dtor = NULL; ugen_tick = NULL; ugen_tickf = NULL; ugen_pmsg = NULL; uana_tock = NULL; ugen_pmsg = NULL; current_mvar_offset = 0; ugen_num_in = ugen_num_out = 0; }
469	// destructor	469	// destructor
@@ -515,7 +515,7 @@ struct Chuck_DL_Func · 45 unmodified lines
515	std::vector<Chuck_DL_Value *> args;	515	std::vector<Chuck_DL_Value *> args;
516	// description	516	// description
517	std::string doc;	517	std::string doc;
518		518
519	// constructor	519	// constructor
520	Chuck_DL_Func() { ctor = NULL; }	520	Chuck_DL_Func() { ctor = NULL; }
521	Chuck_DL_Func( const char * t, const char * n, t_CKUINT a )	521	Chuck_DL_Func( const char * t, const char * n, t_CKUINT a )
@@ -580,7 +580,7 @@ union Chuck_DL_Return · 58 unmodified lines
580	t_CKVEC4 v_vec4; // ge: added 1.3.5.3	580	t_CKVEC4 v_vec4; // ge: added 1.3.5.3
581	Chuck_Object * v_object;	581	Chuck_Object * v_object;
582	Chuck_String * v_string;	582	Chuck_String * v_string;
583		583
584	Chuck_DL_Return() { v_vec4.x = v_vec4.y = v_vec4.z = v_vec4.w = 0; }	584	Chuck_DL_Return() { v_vec4.x = v_vec4.y = v_vec4.z = v_vec4.w = 0; }
585	};	585	};
586		586
@@ -595,7 +595,7 @@ struct Chuck_DLL : public Chuck_VM_Object · 8 unmodified lines
595	{	595	{
596	public:	596	public:
597	// load dynamic ckx/dll from filename	597	// load dynamic ckx/dll from filename
598	t_CKBOOL load( const char * filename,	598	t_CKBOOL load( const char * filename,
599	const char * func = CK_QUERY_FUNC,	599	const char * func = CK_QUERY_FUNC,
600	t_CKBOOL lazy = FALSE );	600	t_CKBOOL lazy = FALSE );
601	t_CKBOOL load( f_ck_query query_func, t_CKBOOL lazy = FALSE );	601	t_CKBOOL load( f_ck_query query_func, t_CKBOOL lazy = FALSE );
@@ -611,7 +611,7 @@ public: · 9 unmodified lines
611	t_CKBOOL good() const;	611	t_CKBOOL good() const;
612	// name	612	// name
613	const char * name() const;	613	const char * name() const;
614		614
615	public:	615	public:
616	// constructor	616	// constructor
617	Chuck_DLL( Chuck_Carrier * carrier, const char * xid = NULL )	617	Chuck_DLL( Chuck_Carrier * carrier, const char * xid = NULL )
@@ -644,7 +644,7 @@ public: · 26 unmodified lines
644	void * bindle, Chuck_Carrier * carrier);	644	void * bindle, Chuck_Carrier * carrier);
645	t_CKBOOL (* const activate)(Chuck_DL_MainThreadHook *);	645	t_CKBOOL (* const activate)(Chuck_DL_MainThreadHook *);
646	t_CKBOOL (* const deactivate)(Chuck_DL_MainThreadHook *);	646	t_CKBOOL (* const deactivate)(Chuck_DL_MainThreadHook *);
647		647
648	Chuck_Carrier * const m_carrier;	648	Chuck_Carrier * const m_carrier;
649	f_mainthreadhook const m_hook;	649	f_mainthreadhook const m_hook;
650	f_mainthreadquit const m_quit;	650	f_mainthreadquit const m_quit;
@@ -665,45 +665,49 @@ struct Api · 14 unmodified lines
665	public:	665	public:
666	static Api g_api;	666	static Api g_api;
667	static inline const Api * instance() { return &g_api; }	667	static inline const Api * instance() { return &g_api; }
668		668
669	struct VMApi	669	struct VMApi
670	{	670	{
671	VMApi();	671	VMApi();
672	t_CKUINT (* const get_srate)( CK_DL_API, Chuck_VM_Shred * );	672	t_CKUINT (* const get_srate)( CK_DL_API, Chuck_VM_Shred * );
673	} * const vm;	673	} * const vm;
674		674
675	struct ObjectApi	675	struct ObjectApi
676	{	676	{
677	ObjectApi();	677	ObjectApi();
678	private:	678
		679	// 1.5.0.0 (nshaheed and ge and anonymous pr-lab member) \| changed from private to public
		680	// also changed all std::string & in this section to const char *
		681	// intent: this allows for chugins to access member variables and create chuck strings
		682	public:
679	// function pointer get_type()	683	// function pointer get_type()
680	Type (* const get_type)( CK_DL_API, Chuck_VM_Shred *, std::string &name );	684	Type (* const get_type)( CK_DL_API, Chuck_VM_Shred , const char name );
681	// function pointer create()	685	// function pointer create()
682	Object (* const create)( CK_DL_API, Chuck_VM_Shred *, Type type );	686	Object (* const create)( CK_DL_API, Chuck_VM_Shred *, Type type );
683	// function pointer create_string()	687	// function pointer create_string()
684	String (* const create_string)( CK_DL_API, Chuck_VM_Shred *, std::string &value );	688	String (* const create_string)( CK_DL_API, Chuck_VM_Shred , const char value );
685	// function pointers for get_mvar_*()	689	// function pointers for get_mvar_*()
686	t_CKBOOL (* const get_mvar_int)( CK_DL_API, Object object, std::string &name, t_CKINT &value );	690	t_CKBOOL (* const get_mvar_int)( CK_DL_API, Object object, const char * name, t_CKINT & value );
687	t_CKBOOL (* const get_mvar_float)( CK_DL_API, Object object, std::string &name, t_CKFLOAT &value );	691	t_CKBOOL (* const get_mvar_float)( CK_DL_API, Object object, const char * name, t_CKFLOAT & value );
688	t_CKBOOL (* const get_mvar_dur)( CK_DL_API, Object object, std::string &name, t_CKDUR &value );	692	t_CKBOOL (* const get_mvar_dur)( CK_DL_API, Object object, const char * name, t_CKDUR & value );
689	t_CKBOOL (* const get_mvar_time)( CK_DL_API, Object object, std::string &name, t_CKTIME &value );	693	t_CKBOOL (* const get_mvar_time)( CK_DL_API, Object object, const char * name, t_CKTIME & value );
690	t_CKBOOL (* const get_mvar_string)( CK_DL_API, Object object, std::string &name, String &value );	694	t_CKBOOL (* const get_mvar_string)( CK_DL_API, Object object, const char * name, String & value );
691	t_CKBOOL (* const get_mvar_object)( CK_DL_API, Object object, std::string &name, Object &value );	695	t_CKBOOL (* const get_mvar_object)( CK_DL_API, Object object, const char * name, Object & value );
692	// function pointer for set_string()	696	// function pointer for set_string()
693	t_CKBOOL (* const set_string)( CK_DL_API, String string, std::string &value );	697	t_CKBOOL (* const set_string)( CK_DL_API, String string, const char * value );
694	} * const object;	698	} * const object;
695		699
696	Api() :	700	Api() :
697	vm(new VMApi),	701	vm(new VMApi),
698	object(new ObjectApi)	702	object(new ObjectApi)
699	{ }	703	{ }
700		704
701	private:	705	private:
702	Api( Api & a ) :	706	Api( Api & a ) :
703	vm(a.vm),	707	vm(a.vm),
704	object(a.object)	708	object(a.object)
705	{ assert(0); };	709	{ assert(0); };
706		710
707	Api & operator=( Api & a ) { assert(0); return a; }	711	Api & operator=( Api & a ) { assert(0); return a; }
708	};	712	};
709	}	713	}
@@ -720,31 +724,33 @@ private: · 10 unmodified lines
720		724
721	#error ChucK not support on Mac OS X 10.3 or lower	725	#error ChucK not support on Mac OS X 10.3 or lower
722		726
723	#elif defined(__WINDOWS_DS__) \|\| defined(__WINDOWS_ASIO__)	727	#elif defined(__PLATFORM_WIN32__)
724		728
725	#ifdef __cplusplus	729	#ifdef __cplusplus
726	extern "C" {	730	extern "C" {
727	#endif	731	#endif
728		732
729	#define RTLD_LAZY 0x1	733	#define RTLD_LAZY 0x1
730	#define RTLD_NOW 0x2	734	#define RTLD_NOW 0x2
731	#define RTLD_LOCAL 0x4	735	#define RTLD_LOCAL 0x4
732	#define RTLD_GLOBAL 0x8	736	#define RTLD_GLOBAL 0x8
733	#define RTLD_NOLOAD 0x10	737	#define RTLD_NOLOAD 0x10
734	#define RTLD_SHARED 0x20 /* not used, the default */	738	#define RTLD_SHARED 0x20 /* not used, the default */
735	#define RTLD_UNSHARED 0x40	739	#define RTLD_UNSHARED 0x40
736	#define RTLD_NODELETE 0x80	740	#define RTLD_NODELETE 0x80
737	#define RTLD_LAZY_UNDEF 0x100	741	#define RTLD_LAZY_UNDEF 0x100
738		742
739	void * dlopen( const char * path, int mode );	743	void * dlopen( const char * path, int mode );
740	void * dlsym( void * handle, const char * symbol );	744	void * dlsym( void * handle, const char * symbol );
741	const char * dlerror( void );	745	const char * dlerror( void );
742	int dlclose( void * handle );	746	int dlclose( void * handle );
743	static char dlerror_buffer[128];	747	// 1.4.2.0 (ge) \| added DLERROR_BUFFER_LENGTH
744		748	#define DLERROR_BUFFER_LENGTH 128
745	#ifdef __cplusplus	749	static char dlerror_buffer[DLERROR_BUFFER_LENGTH];
746	}	750
747	#endif	751	#ifdef __cplusplus
		752	}
		753	#endif
748		754
749	#else	755	#else
750	#include "dlfcn.h"	756	#include "dlfcn.h"

chuginate/template/chuck/include/chuck_emit.h+7−5

     std::vector<Chuck_Instr_Goto *> stack_break;
     // return stack
     std::vector<Chuck_Instr_Goto *> stack_return;
     // filename this code came from (added 1.3.0.0)
     std::string filename;
     // constructor
     Chuck_Code( )
     {
     // constructor
     Chuck_Emitter()
     { env = NULL; code = NULL; context = NULL;
       nspc = NULL; func = NULL; dump = FALSE;
       should_replace_dac = FALSE; }
     // add references to locals on current scope (added 1.3.0.0)
     void addref_on_scope();
     // pop scope
-    void pop_scope( );
+    void pop_scope();
+    // traverse scope on jumps such as 'return' 'break' 'continue' | 1.5.0.0 (ge)
+    void traverse_scope_on_jump();
     // default durations
     t_CKBOOL find_dur( const std::string & name, t_CKDUR * out );
     // post REFACTOR-2017: replace-dac
     std::string dac_replacement;
     t_CKBOOL should_replace_dac;

chuginate/template/chuck/include/chuck_errmsg.h+9−9

@@ -43,17 +43,17 @@ extern "C" { · 42 unmodified lines
43		43
44		44
45	extern t_CKBOOL EM_anyErrors;	45	extern t_CKBOOL EM_anyErrors;
46	extern int EM_tokPos;	46	extern t_CKINT EM_tokPos;
47	extern int EM_lineNum;	47	extern t_CKINT EM_lineNum;
48		48
49	// EM_extLineNum is synced with EM_lineNum in lexer/parser phase, then synced	49	// EM_extLineNum is synced with EM_lineNum in lexer/parser phase, then synced
50	// with scanner/typechecker (EM_lineNum is not synced with scanner/typechecker)	50	// with scanner/typechecker (EM_lineNum is not synced with scanner/typechecker)
51	extern int EM_extLineNum;	51	extern t_CKINT EM_extLineNum;
52		52
53	void EM_newline( );	53	void EM_newline( );
54		54
55	// levels	55	// levels
56	#define CK_LOG_CRAZY 10 // set this to log everything	56	#define CK_LOG_ALL 10 // set this to log everything
57	#define CK_LOG_FINEST 9	57	#define CK_LOG_FINEST 9
58	#define CK_LOG_FINER 8	58	#define CK_LOG_FINER 8
59	#define CK_LOG_FINE 7	59	#define CK_LOG_FINE 7
@@ -155,9 +155,9 @@ extern t_CKINT g_loglevel; · 95 unmodified lines
155	// macro to compare	155	// macro to compare
156	#define DO_LOG(x) ( x <= g_loglevel )	156	#define DO_LOG(x) ( x <= g_loglevel )
157		157
158	void EM_error( int, c_constr, ... );	158	void EM_error( t_CKINT, c_constr, ... );
159	void EM_error2( int, c_constr, ... );	159	void EM_error2( t_CKINT, c_constr, ... );
160	void EM_error2b( int, c_constr, ... );	160	void EM_error2b( t_CKINT, c_constr, ... );
161	void EM_error3( c_constr, ... );	161	void EM_error3( c_constr, ... );
162	void EM_impossible( c_constr, ... );	162	void EM_impossible( c_constr, ... );
163	t_CKBOOL EM_reset( c_constr filename, FILE * fd );	163	t_CKBOOL EM_reset( c_constr filename, FILE * fd );
@@ -190,7 +190,7 @@ public: · 26 unmodified lines
190	{	190	{
191	EM_pushlog();	191	EM_pushlog();
192	}	192	}
193		193
194	~SmartPushLog()	194	~SmartPushLog()
195	{	195	{
196	EM_poplog();	196	EM_poplog();

chuginate/template/chuck/include/chuck_frame.h+1−1

@@ -92,7 +92,7 @@ public: · 91 unmodified lines
92	Chuck_Local * alloc_local( t_CKUINT size, const std::string & name,	92	Chuck_Local * alloc_local( t_CKUINT size, const std::string & name,
93	t_CKBOOL is_ref, t_CKBOOL is_obj, t_CKBOOL is_global );	93	t_CKBOOL is_ref, t_CKBOOL is_obj, t_CKBOOL is_global );
94	// get the current scope (added 1.3.0.0)	94	// get the current scope (added 1.3.0.0)
95	void get_scope( std::vector<Chuck_Local *> & out ) const;	95	void get_scope( std::vector<Chuck_Local *> & out, bool localOnly = true ) const;
96	// pop scope	96	// pop scope
97	void pop_scope( std::vector<Chuck_Local *> & out );	97	void pop_scope( std::vector<Chuck_Local *> & out );
98	};	98	};

chuginate/template/chuck/include/chuck_globals.h+21−21

chuginate/template/chuck/include/chuck_instr.h+163−93

 struct Chuck_Type;
 struct Chuck_Func;
+// 1.4.2.0 (ge) | added for switching from snprintf()
+#define CK_PRINT_BUF_LENGTH 256
 {
 public:
     Chuck_Instr();
-    virtual ~Chuck_Instr() { }
+    virtual ~Chuck_Instr() { SAFE_DELETE(m_codestr); }
 public:
     virtual void execute( Chuck_VM * vm, Chuck_VM_Shred * shred ) = 0;
 public:
     virtual const char * name() const;
     virtual const char * params() const
     { return ""; }
 public:
+    // store line position for error messages
     void set_linepos( t_CKUINT linepos );
     t_CKUINT m_linepos;
+    // set codestr associated with this instruction
+    void set_codestr( const std::string & str );
+    // (used in instruction dump) | 1.5.0.0 (ge) added
+    std::string * m_codestr;
 };
 public:
     virtual const char * params() const
-    { static char buffer[256]; sprintf( buffer, "%ld", m_jmp ); return buffer; }
+    { static char buffer[CK_PRINT_BUF_LENGTH]; snprintf( buffer, CK_PRINT_BUF_LENGTH, "%ld", (long)m_jmp ); return buffer; }
 protected:
     t_CKUINT m_jmp;
 public:
     virtual const char * params() const
-    { static char buffer[256]; sprintf( buffer, "%ld", m_val ); return buffer; }
+    { static char buffer[CK_PRINT_BUF_LENGTH]; snprintf( buffer, CK_PRINT_BUF_LENGTH, "%ld", (long)m_val ); return buffer; }
 protected:
     t_CKUINT m_val;
 public:
     virtual const char * params() const
-    { static char buffer[256]; sprintf( buffer, "%.6f", m_val ); return buffer; }
+    { static char buffer[CK_PRINT_BUF_LENGTH]; snprintf( buffer, CK_PRINT_BUF_LENGTH, "%.6f", m_val ); return buffer; }
 protected:
     t_CKFLOAT m_val;
+//-----------------------------------------------------------------------------
+// name: struct Chuck_Instr_Reg_Push_Zero
+// desc: push immediate value 0 to reg stack with specific width
+//-----------------------------------------------------------------------------
+struct Chuck_Instr_Reg_Push_Zero : public Chuck_Instr_Unary_Op
+{
+public:
+    Chuck_Instr_Reg_Push_Zero( t_CKUINT sizeInBytes )
+    { this->set( sizeInBytes ); }
+public:
+    virtual void execute( Chuck_VM * vm, Chuck_VM_Shred * shred );
+};
 //-----------------------------------------------------------------------------
 // name: struct Chuck_Instr_Reg_Dup_Last
 // desc: duplicate last value on reg stack
 public:
     virtual void execute( Chuck_VM * vm, Chuck_VM_Shred * shred );
     virtual const char * params() const
-    { static char buffer[256];
+    { static char buffer[CK_PRINT_BUF_LENGTH];
-      sprintf( buffer, "src=%ld, base=%ld", m_val, base );
+      snprintf( buffer, CK_PRINT_BUF_LENGTH, "src=%ld, base=%ld", (long)m_val, (long)base );
       return buffer; }
 protected:
 public:
     virtual void execute( Chuck_VM * vm, Chuck_VM_Shred * shred );
     virtual const char * params() const
-    { static char buffer[256];
+    { static char buffer[CK_PRINT_BUF_LENGTH];
-      sprintf( buffer, "src=%ld, base=%ld", m_val, base );
+      snprintf( buffer, CK_PRINT_BUF_LENGTH, "src=%ld, base=%ld", (long)m_val, (long)base );
       return buffer; }
 protected:
 public:
     virtual void execute( Chuck_VM * vm, Chuck_VM_Shred * shred );
     virtual const char * params() const
-    { static char buffer[256];
+    { static char buffer[CK_PRINT_BUF_LENGTH];
-      sprintf( buffer, "src=%ld, base=%ld", m_val, base );
+      snprintf( buffer, CK_PRINT_BUF_LENGTH, "src=%ld, base=%ld", (long)m_val, (long)base );
       return buffer; }
 protected:
 public:
     Chuck_Instr_Reg_Push_Mem_Vec3( t_CKUINT src, t_CKBOOL use_base = FALSE )
     { this->set( src ); base = use_base; }
 public:
     virtual void execute( Chuck_VM * vm, Chuck_VM_Shred * shred );
     virtual const char * params() const
-    { static char buffer[256];
+    { static char buffer[CK_PRINT_BUF_LENGTH];
-        sprintf( buffer, "src=%ld, base=%ld", m_val, base );
+        snprintf( buffer, CK_PRINT_BUF_LENGTH, "src=%ld, base=%ld", (long)m_val, (long)base );
         return buffer; }
 protected:
     // use global stack base
     t_CKBOOL base;
 public:
     Chuck_Instr_Reg_Push_Mem_Vec4( t_CKUINT src, t_CKBOOL use_base = FALSE )
     { this->set( src ); base = use_base; }
 public:
     virtual void execute( Chuck_VM * vm, Chuck_VM_Shred * shred );
     virtual const char * params() const
-    { static char buffer[256];
+    { static char buffer[CK_PRINT_BUF_LENGTH];
-        sprintf( buffer, "src=%ld, base=%ld", m_val, base );
+        snprintf( buffer, CK_PRINT_BUF_LENGTH, "src=%ld, base=%ld", (long)m_val, (long)base );
         return buffer; }
 protected:
     // use global stack base
     t_CKBOOL base;
 public:
     virtual void execute( Chuck_VM * vm, Chuck_VM_Shred * shred );
     virtual const char * params() const
-    { static char buffer[256];
+    { static char buffer[CK_PRINT_BUF_LENGTH];
-      sprintf( buffer, "name='%s'", m_name.c_str() );
+      snprintf( buffer, CK_PRINT_BUF_LENGTH, "name='%s'", m_name.c_str() );
       return buffer; }
 public:
 public:
     virtual void execute( Chuck_VM * vm, Chuck_VM_Shred * shred );
     virtual const char * params() const
-    { static char buffer[256];
+    { static char buffer[CK_PRINT_BUF_LENGTH];
-      sprintf( buffer, "src=%ld, base=%ld", m_val, base );
+      snprintf( buffer, CK_PRINT_BUF_LENGTH, "src=%ld, base=%ld", (long)m_val, (long)base );
       return buffer; }
 protected:
 public:
     virtual void execute( Chuck_VM * vm, Chuck_VM_Shred * shred );
     virtual const char * params() const
-    { static char buffer[256];
+    { static char buffer[CK_PRINT_BUF_LENGTH];
-      sprintf( buffer, "name='%s'", m_name.c_str() );
+      snprintf( buffer, CK_PRINT_BUF_LENGTH, "name='%s'", m_name.c_str() );
       return buffer; }
 protected:
 public:
     Chuck_Instr_Mem_Set_Imm( t_CKUINT offset, t_CKUINT val )
     { m_offset = offset; m_val = val; }
 public:
     virtual void execute( Chuck_VM * vm, Chuck_VM_Shred * shred );
     virtual const char * params() const
-    { static char buffer[256];
+    { static char buffer[CK_PRINT_BUF_LENGTH];
-      sprintf( buffer, "offset=%ld, value=%ld", m_offset, m_val );
+      snprintf( buffer, CK_PRINT_BUF_LENGTH, "offset=%ld, value=%ld", (long)m_offset, (long)m_val );
       return buffer; }
 protected:
 public:
     Chuck_Instr_Mem_Set_Imm2( t_CKUINT offset, t_CKFLOAT val )
     { m_offset = offset; m_val = val; }
 public:
     virtual void execute( Chuck_VM * vm, Chuck_VM_Shred * shred );
     virtual const char * params() const
-    { static char buffer[256];
+    { static char buffer[CK_PRINT_BUF_LENGTH];
-      sprintf( buffer, "offset=%ld, value=%f", m_offset, m_val );
+      snprintf( buffer, CK_PRINT_BUF_LENGTH, "offset=%ld, value=%f", (long)m_offset, m_val );
       return buffer; }
 protected:
 public:
     Chuck_Instr_Mem_Push_Imm( t_CKUINT src )
     { this->set( src ); }
 public:
     virtual void execute( Chuck_VM * vm, Chuck_VM_Shred * shred );
 };
 public:
     Chuck_Instr_Mem_Push_Imm2( t_CKFLOAT src )
     { this->set( src ); }
 public:
     virtual void execute( Chuck_VM * vm, Chuck_VM_Shred * shred );
 };
     // (added 1.3.0.0 -- is_object)
     Chuck_Instr_Alloc_Word( t_CKUINT offset, t_CKBOOL is_object )
     { this->set( offset ); m_is_object = is_object; }
     // was this object reference? (added 1.3.0.0)
     t_CKBOOL m_is_object;
     virtual void execute( Chuck_VM * vm, Chuck_VM_Shred * shred );
 };
 public:
     Chuck_Instr_Alloc_Word2( t_CKUINT offset )
     { this->set( offset ); }
     virtual void execute( Chuck_VM * vm, Chuck_VM_Shred * shred );
 };
 public:
     Chuck_Instr_Alloc_Vec3( t_CKUINT offset )
     { this->set( offset ); }
     virtual void execute( Chuck_VM * vm, Chuck_VM_Shred * shred );
 };
 public:
     Chuck_Instr_Alloc_Vec4( t_CKUINT offset )
     { this->set( offset ); }
     virtual void execute( Chuck_VM * vm, Chuck_VM_Shred * shred );
 };
 public:
     Chuck_Instr_Alloc_Member_Vec3( t_CKUINT offset  )
     { this->set( offset ); }
     virtual void execute( Chuck_VM * vm, Chuck_VM_Shred * shred );
 };
 public:
     Chuck_Instr_Alloc_Member_Vec4( t_CKUINT offset  )
     { this->set( offset ); }
     virtual void execute( Chuck_VM * vm, Chuck_VM_Shred * shred );
 };
     Chuck_Instr_Alloc_Word_Global()
     { this->set( 0 ); m_stack_offset = 0; m_chuck_type = NULL;
       m_should_execute_ctors = FALSE; m_is_array = FALSE; }
     virtual const char * params() const
-    { static char buffer[256];
+    { static char buffer[CK_PRINT_BUF_LENGTH];
-      sprintf( buffer, "name='%s'", m_name.c_str() );
+      snprintf( buffer, CK_PRINT_BUF_LENGTH, "name='%s'", m_name.c_str() );
       return buffer; }
     // global name and type
     std::string m_name;
     te_GlobalType m_type;
     t_CKBOOL m_is_array;
     // for objects
     t_CKBOOL m_should_execute_ctors;
     t_CKUINT m_stack_offset;
     Chuck_Type * m_chuck_type;
     virtual void execute( Chuck_VM * vm, Chuck_VM_Shred * shred );
 };
 public:
     Chuck_Instr_AddRef_Object2( t_CKUINT offset )
     { this->set( offset ); }
 public:
     virtual void execute( Chuck_VM * vm, Chuck_VM_Shred * shred );
 };
 //-----------------------------------------------------------------------------
 // name: struct Chuck_Instr_Reg_AddRef_Object3
 // desc: added 1.3.0.0 -- does the ref add in-place
+//       operates on top of the register stack
 //-----------------------------------------------------------------------------
 struct Chuck_Instr_Reg_AddRef_Object3 : public Chuck_Instr
 {
 //-----------------------------------------------------------------------------
 // name: struct Chuck_Instr_Release_Object
-// desc: ...
+// desc: release object on stack by its offset
 //-----------------------------------------------------------------------------
 struct Chuck_Instr_Release_Object : public Chuck_Instr
 {
+//-----------------------------------------------------------------------------
+// name: struct Chuck_Instr_Release_Object3_Pop_Word
+// desc: release object reference + pop from reg stack | 1.5.0.0 (ge) added
+//       the variant assumes object pointer directly on stack (not offset)
+//-----------------------------------------------------------------------------
+struct Chuck_Instr_Release_Object3_Pop_Word : public Chuck_Instr
+{
+public:
+    virtual void execute( Chuck_VM * vm, Chuck_VM_Shred * shred );
+};
+//-----------------------------------------------------------------------------
+// name: struct Chuck_Instr_Release_Object4
+// desc: release object reference from reg stack (no pop) | 1.5.0.0 (ge) added
+//       the variant assumes object pointer directly on stack (not offset)
+//-----------------------------------------------------------------------------
+struct Chuck_Instr_Release_Object4 : public Chuck_Instr_Unary_Op
+{
+public:
+    Chuck_Instr_Release_Object4( t_CKUINT offset )
+    { this->set( offset ); }
+public:
+    virtual void execute( Chuck_VM * vm, Chuck_VM_Shred * shred );
+};
 //-----------------------------------------------------------------------------
 // name: struct Chuck_Instr_Func_To_Code
 // desc: Chuck_Func * to Chuck_VM_Code *
 struct Chuck_Instr_Func_Call_Member : public Chuck_Instr_Unary_Op
 {
 public:
-    Chuck_Instr_Func_Call_Member( t_CKUINT ret_size )
+    Chuck_Instr_Func_Call_Member( t_CKUINT ret_size, Chuck_Func * func_ref )
-    { this->set( ret_size ); }
+    { this->set( ret_size ); m_func_ref = func_ref; }
 public:
     virtual void execute( Chuck_VM * vm, Chuck_VM_Shred * shred );
+public:
+    Chuck_Func * m_func_ref; // 1.5.0.0 (ge) | added for arg list cleanup
 };
 struct Chuck_Instr_Func_Call_Static : public Chuck_Instr_Unary_Op
 {
 public:
-    Chuck_Instr_Func_Call_Static( t_CKUINT ret_size )
+    Chuck_Instr_Func_Call_Static( t_CKUINT ret_size, Chuck_Func * func_ref )
-    { this->set( ret_size ); }
+    { this->set( ret_size ); m_func_ref = func_ref; }
 public:
     virtual void execute( Chuck_VM * vm, Chuck_VM_Shred * shred );
+public:
+    Chuck_Func * m_func_ref; // 1.5.0.0 (ge) | added for arg list cleanup
 };
     Chuck_Type * m_type_ref;
     t_CKINT m_length;
     t_CKBOOL m_is_obj;
+    t_CKBOOL m_is_float;
     char * m_param_str;
 };
 struct Chuck_Instr_Array_Alloc : public Chuck_Instr
 {
 public: // REFACTOR-2017: added env
-    Chuck_Instr_Array_Alloc( Chuck_Env * env, t_CKUINT depth, Chuck_Type * the_type,
+    Chuck_Instr_Array_Alloc( Chuck_Env * env, t_CKUINT depth,
-        t_CKUINT offset, t_CKBOOL ref );
+        Chuck_Type * contentType, t_CKUINT offset, t_CKBOOL ref,
+        Chuck_Type * arrayType );
     virtual ~Chuck_Instr_Array_Alloc();
 public:
 protected:
     t_CKUINT m_depth;
-    Chuck_Type * m_type_ref;
+    Chuck_Type * m_type_ref_content;
+    Chuck_Type * m_type_ref_array; // 1.5.0.0 (ge) added
     t_CKBOOL m_is_obj;
     char * m_param_str;
     t_CKUINT m_stack_offset;
 struct Chuck_Instr_Array_Access : public Chuck_Instr
 {
 public:
     Chuck_Instr_Array_Access( t_CKUINT kind, t_CKUINT emit_addr,
         t_CKUINT istr = FALSE )
     { m_kind = kind; m_emit_addr = emit_addr; m_istr = istr; }
 public:
     virtual void execute( Chuck_VM * vm, Chuck_VM_Shred * shred );
     virtual const char * params() const
-    { static char buffer[256];
+    { static char buffer[CK_PRINT_BUF_LENGTH];
-      sprintf( buffer, "kind=%ld, emit_addr=%ld istr=%ld",
+      snprintf( buffer, CK_PRINT_BUF_LENGTH, "kind=%ld, emit_addr=%p istr=%ld",
-               m_kind, m_emit_addr, m_istr );
+          (long)m_kind, (void *)m_emit_addr, (long)m_istr );
       return buffer; }
 protected:
 public:
     virtual void execute( Chuck_VM * vm, Chuck_VM_Shred * shred );
     virtual const char * params() const
-    { static char buffer[256];
+    { static char buffer[CK_PRINT_BUF_LENGTH];
-      sprintf( buffer, "kind=%ld, emit_addr=%ld", m_kind, m_emit_addr );
+      snprintf( buffer, CK_PRINT_BUF_LENGTH, "kind=%ld, emit_addr=%p", (long)m_kind, (void *)m_emit_addr );
       return buffer; }
 protected:
 public:
     virtual void execute( Chuck_VM * vm, Chuck_VM_Shred * shred );
     virtual const char * params() const
-    { static char buffer[256];
+    { static char buffer[CK_PRINT_BUF_LENGTH];
-      sprintf( buffer, "depth=%ld, kind=%ld, emit_addr=%ld", m_depth, m_kind, m_emit_addr );
+      snprintf( buffer, CK_PRINT_BUF_LENGTH, "depth=%ld, kind=%ld, emit_addr=%p", (long)m_depth, (long)m_kind, (void *)m_emit_addr );
       return buffer; }
 protected:
     t_CKUINT m_depth;
     t_CKUINT m_kind;
     t_CKUINT m_emit_addr;
     // 1.3.1.0 list of types of indices
     std::vector<t_CKBOOL> m_indexIsAssociative;
 };
 public:
     virtual void execute( Chuck_VM * vm, Chuck_VM_Shred * shred );
     virtual const char * params() const
-    { static char buffer[256];
+    { static char buffer[CK_PRINT_BUF_LENGTH];
-      sprintf( buffer, "offset=%ld, kind=%ld, emit_addr=%ld", m_offset, m_kind, m_emit_addr );
+      snprintf( buffer, CK_PRINT_BUF_LENGTH, "offset=%ld, kind=%ld, emit_addr=%p", (long)m_offset, (long)m_kind, (void *)m_emit_addr );
       return buffer; }
 protected:
 public:
     virtual void execute( Chuck_VM * vm, Chuck_VM_Shred * shred );
     virtual const char * params() const
-    { static char buffer[256];
+    { static char buffer[CK_PRINT_BUF_LENGTH];
-      sprintf( buffer, "offset=%ld", m_offset );
+      snprintf( buffer, CK_PRINT_BUF_LENGTH, "offset=%ld", (long)m_offset );
       return buffer; }
 protected:
 public:
     Chuck_Instr_Dot_Primitive_Func( t_CKUINT native_func )
     { m_native_func = native_func; }
 public:
     virtual void execute( Chuck_VM * vm, Chuck_VM_Shred * shred );
     virtual const char * params() const
-    { static char buffer[256];
+    { static char buffer[CK_PRINT_BUF_LENGTH];
-        sprintf( buffer, "native_func=%ld", m_native_func );
+        snprintf( buffer, CK_PRINT_BUF_LENGTH, "native_func=%p", (void *)m_native_func );
         return buffer; }
 protected:
     t_CKUINT m_native_func;
 };
 public:
     virtual void execute( Chuck_VM * vm, Chuck_VM_Shred * shred );
     virtual const char * params() const
-    { static char buffer[256];
+    { static char buffer[CK_PRINT_BUF_LENGTH];
-      sprintf( buffer, "offset=%ld, size=%ld, kind=%ld, emit_addr=%ld", m_offset, m_size, m_kind, m_emit_addr );
+      snprintf( buffer, CK_PRINT_BUF_LENGTH, "offset=%ld, size=%ld, kind=%ld, emit_addr=%p",
+                (long)m_offset, (long)m_size, (long)m_kind, (void *)m_emit_addr );
       return buffer; }
 protected:
 public:
     virtual void execute( Chuck_VM * vm, Chuck_VM_Shred * shred );
     virtual const char * params() const
-    { static char buffer[256];
+    { static char buffer[CK_PRINT_BUF_LENGTH];
-      sprintf( buffer, "addr=%ld, kind=%ld, emit_addr=%ld", (t_CKUINT)m_addr, m_kind, m_emit_addr );
+      snprintf( buffer, CK_PRINT_BUF_LENGTH, "addr=%p, kind=%ld, emit_addr=%p",
+                (void *)m_addr, (long)m_kind, (void *)m_emit_addr );
       return buffer; }
 protected:
 public:
     virtual void execute( Chuck_VM * vm, Chuck_VM_Shred * shred );
     virtual const char * params() const
-    { static char buffer[256];
+    { static char buffer[CK_PRINT_BUF_LENGTH];
-      sprintf( buffer, "func=%ld", (t_CKUINT)m_func );
+      snprintf( buffer, CK_PRINT_BUF_LENGTH, "func=%p", (void *)m_func );
       return buffer; }
 protected:
 public:
     virtual void execute( Chuck_VM * vm, Chuck_VM_Shred * shred );
     virtual const char * params() const
-    { static char buffer[256];
+    { static char buffer[CK_PRINT_BUF_LENGTH];
-      sprintf( buffer, "is_mem=%ld, emit_addr=%ld", m_is_mem, m_emit_addr );
+      snprintf( buffer, CK_PRINT_BUF_LENGTH, "is_mem=%ld, emit_addr=%p", (long)m_is_mem, (void *)m_emit_addr );
       return buffer; }
 protected:
 public:
     virtual void execute( Chuck_VM * vm, Chuck_VM_Shred * shred );
     virtual const char * params() const
-    { static char buffer[256];
+    { static char buffer[CK_PRINT_BUF_LENGTH];
-      sprintf( buffer, "is_mem=%ld, emit_addr=%ld", m_is_mem, m_emit_addr );
+      snprintf( buffer, CK_PRINT_BUF_LENGTH, "is_mem=%ld, emit_addr=%p", (long)m_is_mem, (void *)m_emit_addr );
       return buffer; }
 protected:
 public:
     Chuck_Instr_Dot_Cmp_Third( t_CKUINT is_mem, t_CKUINT emit_addr )
     { m_is_mem = is_mem; m_emit_addr = emit_addr; }
 public:
     virtual void execute( Chuck_VM * vm, Chuck_VM_Shred * shred );
     virtual const char * params() const
-    { static char buffer[256];
+    { static char buffer[CK_PRINT_BUF_LENGTH];
-        sprintf( buffer, "is_mem=%ld, emit_addr=%ld", m_is_mem, m_emit_addr );
+        snprintf( buffer, CK_PRINT_BUF_LENGTH, "is_mem=%ld, emit_addr=%p", (long)m_is_mem, (void *)m_emit_addr );
         return buffer; }
 protected:
     t_CKUINT m_is_mem;
     t_CKUINT m_emit_addr;
 public:
     Chuck_Instr_Dot_Cmp_Fourth( t_CKUINT is_mem, t_CKUINT emit_addr )
     { m_is_mem = is_mem; m_emit_addr = emit_addr; }
 public:
     virtual void execute( Chuck_VM * vm, Chuck_VM_Shred * shred );
     virtual const char * params() const
-    { static char buffer[256];
+    { static char buffer[CK_PRINT_BUF_LENGTH];
-        sprintf( buffer, "is_mem=%ld, emit_addr=%ld", m_is_mem, m_emit_addr );
+        snprintf( buffer, CK_PRINT_BUF_LENGTH, "is_mem=%ld, emit_addr=%p", (long)m_is_mem, (void *)m_emit_addr );
         return buffer; }
 protected:
     t_CKUINT m_is_mem;
     t_CKUINT m_emit_addr;
 {
 public:
     Chuck_Instr_UGen_Link( t_CKBOOL isUpChuck = FALSE );
 public:
     virtual void execute( Chuck_VM * vm, Chuck_VM_Shred * shred );
 protected:
     t_CKBOOL m_isUpChuck;
 };
     { }
     virtual void execute( Chuck_VM * vm, Chuck_VM_Shred * shred );
 protected:
     t_CKBOOL m_srcIsArray, m_dstIsArray;
 };

chuginate/template/chuck/include/chuck_io.h+32−29

 t_CKBOOL init_class_HID( Chuck_Env * env );
 #endif
 t_CKBOOL init_class_io( Chuck_Env * env, Chuck_Type * type );
-#ifndef __DISABLE_FILEIO__
+// #ifndef __DISABLE_FILEIO__
 t_CKBOOL init_class_fileio( Chuck_Env * env, Chuck_Type * type );
-#endif
+// #endif
 // added 1.3.0.0 -- moved to be full-fledged class
 t_CKBOOL init_class_chout( Chuck_Env * env, Chuck_Type * type );
 // added 1.3.0.0 -- moved to be full-fledged class
 CK_DLL_SFUN( io_openfile );
-#ifndef __DISABLE_FILEIO__
+// #ifndef __DISABLE_FILEIO__
 //-----------------------------------------------------------------------------
 // fileio API
 //-----------------------------------------------------------------------------
 CK_DLL_MFUN( fileio_readline );
 CK_DLL_MFUN( fileio_readint );
 CK_DLL_MFUN( fileio_readintflags );
+CK_DLL_MFUN( fileio_readint8 );
+CK_DLL_MFUN( fileio_readint16 );
+CK_DLL_MFUN( fileio_readint32 );
 CK_DLL_MFUN( fileio_readfloat );
 CK_DLL_MFUN( fileio_eof );
 CK_DLL_MFUN( fileio_more );
 CK_DLL_MFUN( fileio_writeint );
 CK_DLL_MFUN( fileio_writeintflags );
 CK_DLL_MFUN( fileio_writefloat );
-#endif
+// #endif // __DISABLE_FILEIO__
 //-----------------------------------------------------------------------------
 public:
     Chuck_IO_Serial( Chuck_VM * vm );
     virtual ~Chuck_IO_Serial();
     static void shutdown();
 public:
     // meta
     virtual t_CKBOOL open( const t_CKUINT i, t_CKINT flags, t_CKUINT baud = CK_BAUD_9600 );
     virtual t_CKBOOL open( const std::string & path, t_CKINT flags, t_CKUINT baud = CK_BAUD_9600 );
     virtual t_CKBOOL can_wait();
     virtual t_CKBOOL good();
     virtual void close();
     virtual void flush();
     virtual t_CKINT mode();
     virtual void mode( t_CKINT flag );
     // reading
     virtual Chuck_String * readLine();
     virtual t_CKINT readInt( t_CKINT flags );
     virtual t_CKFLOAT readFloat();
     virtual t_CKBOOL readString( std::string & str );
     virtual t_CKBOOL eof();
     // writing
     virtual void write( const std::string & val );
     virtual void write( t_CKINT val );
     // serial stuff
     virtual t_CKBOOL setBaudRate( t_CKUINT rate );
     virtual t_CKUINT getBaudRate();
     // async reading
     virtual t_CKBOOL readAsync( t_CKUINT type, t_CKUINT num );
     virtual Chuck_String * getLine();
     virtual Chuck_Array * getInts();
     virtual Chuck_Array * getFloats();
     virtual Chuck_String * getString();
     static const t_CKUINT TYPE_NONE;
     static const t_CKUINT TYPE_BYTE;
     static const t_CKUINT TYPE_WORD;
     static const t_CKUINT TYPE_INT;
     static const t_CKUINT TYPE_STRING;
     static const t_CKUINT TYPE_LINE;
     static const t_CKUINT TYPE_WRITE;
     struct Request
     {
         t_CKUINT m_type; // type
         t_CKUINT m_num; // how many
         t_CKUINT m_status;
         t_CKUINT m_val; // ISSUE: 64-bit
         enum Status
         {
             RQ_STATUS_PENDING,
             RQ_STATUS_EOF,
         };
     };
     virtual t_CKBOOL ready();
     // available baud rates
     static const t_CKUINT CK_BAUD_2400;
     static const t_CKUINT CK_BAUD_4800;
     static const t_CKUINT CK_BAUD_230400;
 protected:
     void start_read_thread();
     XThread * m_read_thread;
     static void *shell_read_cb(void *);
     XThread * m_write_thread;
     static void *shell_write_cb(void *);
     void write_cb();
     void close_int();
     t_CKBOOL get_buffer(t_CKINT timeout_ms = 1);
     t_CKINT peek_buffer();
     t_CKINT pull_buffer();
     t_CKINT buffer_bytes_to_tmp(t_CKINT num_bytes);
     t_CKBOOL handle_line(Request &);
     t_CKBOOL handle_string(Request &);
     t_CKBOOL handle_float_ascii(Request &);
     t_CKBOOL handle_byte(Request &);
     t_CKBOOL handle_float_binary(Request &);
     t_CKBOOL handle_int_binary(Request &);
     bool m_do_read_thread;
     bool m_do_write_thread;
     CircularBuffer<Request> m_asyncRequests;
     CircularBuffer<Request> m_asyncResponses;
     CBufferSimple * m_event_buffer;
     int m_fd;
     FILE * m_cfd;
     std::string m_path;
     unsigned char * m_io_buf;
     t_CKUINT m_io_buf_max;
     t_CKUINT m_io_buf_available;
     t_CKUINT m_io_buf_pos;
     unsigned char * m_tmp_buf;
     t_CKUINT m_tmp_buf_max;
     CircularBuffer<Request> m_asyncWriteRequests;
     CircularBuffer<char> m_writeBuffer;
     t_CKINT m_flags;
     t_CKINT m_iomode; // SYNC or ASYNC
     t_CKBOOL m_eof;
     t_CKBOOL m_do_exit;
     static std::list<Chuck_IO_Serial *> s_serials;
     Chuck_VM * m_vmRef;
 };
 #endif // __DISABLE_SERIAL__

chuginate/template/chuck/include/chuck_lang.h+40−3

@@ -58,7 +58,8 @@ t_CKBOOL init_class_string( Chuck_Env * env, Chuck_Type * type ); · 57 unmodified lines
58	t_CKBOOL init_class_array( Chuck_Env * env, Chuck_Type * type );	58	t_CKBOOL init_class_array( Chuck_Env * env, Chuck_Type * type );
59	t_CKBOOL init_class_vec3( Chuck_Env * env, Chuck_Type * type ); // 1.3.5.3	59	t_CKBOOL init_class_vec3( Chuck_Env * env, Chuck_Type * type ); // 1.3.5.3
60	t_CKBOOL init_class_vec4( Chuck_Env * env, Chuck_Type * type ); // 1.3.5.3	60	t_CKBOOL init_class_vec4( Chuck_Env * env, Chuck_Type * type ); // 1.3.5.3
61		61	t_CKBOOL init_class_type( Chuck_Env * env, Chuck_Type * type ); // 1.5.0.0
		62	t_CKBOOL init_primitive_types( Chuck_Env * env ); // 1.5.0.0
62		63
63		64
64		65
@@ -69,11 +70,11 @@ t_CKBOOL init_class_vec4( Chuck_Env * env, Chuck_Type * type ); // 1.3.5.3 · 4 unmodified lines
69	CK_DLL_CTOR( object_ctor );	70	CK_DLL_CTOR( object_ctor );
70	CK_DLL_DTOR( object_dtor );	71	CK_DLL_DTOR( object_dtor );
71	CK_DLL_MFUN( object_equals );	72	CK_DLL_MFUN( object_equals );
72	CK_DLL_MFUN( object_getType );
73	CK_DLL_MFUN( object_hashCode );	73	CK_DLL_MFUN( object_hashCode );
74	CK_DLL_MFUN( object_toString );	74	CK_DLL_MFUN( object_toString );
75	CK_DLL_MFUN( object_dump );	75	CK_DLL_MFUN( object_dump );
76	CK_DLL_SFUN( object_apropos );	76	CK_DLL_SFUN( object_help );
		77	CK_DLL_SFUN( object_typeInfo );
77		78
78		79
79	//-----------------------------------------------------------------------------	80	//-----------------------------------------------------------------------------
@@ -180,12 +181,17 @@ CK_DLL_MFUN( array_set_size ); · 100 unmodified lines
180	CK_DLL_MFUN( array_get_size );	181	CK_DLL_MFUN( array_get_size );
181	CK_DLL_MFUN( array_push_back );	182	CK_DLL_MFUN( array_push_back );
182	CK_DLL_MFUN( array_pop_back );	183	CK_DLL_MFUN( array_pop_back );
		184	CK_DLL_MFUN( array_pop_out );
183	CK_DLL_MFUN( array_push_front );	185	CK_DLL_MFUN( array_push_front );
184	CK_DLL_MFUN( array_pop_front );	186	CK_DLL_MFUN( array_pop_front );
185	CK_DLL_MFUN( array_find );	187	CK_DLL_MFUN( array_find );
186	CK_DLL_MFUN( array_erase );	188	CK_DLL_MFUN( array_erase );
187	CK_DLL_MFUN( array_clear );	189	CK_DLL_MFUN( array_clear );
188	CK_DLL_MFUN( array_reset );	190	CK_DLL_MFUN( array_reset );
		191	CK_DLL_MFUN( array_zero );
		192	CK_DLL_MFUN( array_get_keys );
		193	CK_DLL_MFUN( array_reverse );
		194	CK_DLL_MFUN( array_shuffle );
189		195
190		196
191	//-----------------------------------------------------------------------------	197	//-----------------------------------------------------------------------------
@@ -254,6 +260,37 @@ CK_DLL_MFUN( vec4_magnitude ); · 62 unmodified lines
254	CK_DLL_MFUN( vec4_normalize );	260	CK_DLL_MFUN( vec4_normalize );
255		261
256		262
		263	//-----------------------------------------------------------------------------
		264	// type API \| 1.5.0.0 (ge) added
		265	//-----------------------------------------------------------------------------
		266	CK_DLL_CTOR( type_ctor );
		267	CK_DLL_DTOR( type_dtor );
		268	CK_DLL_MFUN( type_equals );
		269	CK_DLL_MFUN( type_isa );
		270	CK_DLL_MFUN( type_isa_str );
		271	CK_DLL_MFUN( type_name );
		272	CK_DLL_MFUN( type_parent ); // return parent Type
		273	CK_DLL_MFUN( type_children ); // return children Types
		274	CK_DLL_MFUN( type_origin ); // built-in, chugin, defined in chuck
		275	CK_DLL_MFUN( type_isPrimitive );
		276	CK_DLL_MFUN( type_isArray );
		277	CK_DLL_MFUN( type_arrayDims );
		278	CK_DLL_SFUN( type_findString );
		279	CK_DLL_SFUN( type_typeOf_obj ); // Type.typeOf( Object )
		280	CK_DLL_SFUN( type_typeOf_int ); // Type.typeOf( int )
		281	CK_DLL_SFUN( type_typeOf_float ); // Type.typeOf( float )
		282	CK_DLL_SFUN( type_typeOf_time ); // Type.typeOf( time )
		283	CK_DLL_SFUN( type_typeOf_dur ); // Type.typeOf( dur )
		284	CK_DLL_SFUN( type_typeOf_complex ); // Type.typeOf( complex )
		285	CK_DLL_SFUN( type_typeOf_polar ); // Type.typeOf( polar )
		286	CK_DLL_SFUN( type_typeOf_vec3 ); // Type.typeOf( vec3 )
		287	CK_DLL_SFUN( type_typeOf_vec4 ); // Type.typeOf( vec4 )
		288	CK_DLL_SFUN( type_getTypes );
		289	CK_DLL_SFUN( type_getTypesAll );
		290
		291
		292
		293
257	//-----------------------------------------------------------------------------	294	//-----------------------------------------------------------------------------
258	// name: Data_Exception	295	// name: Data_Exception
259	// desc: data for base Chuck Exception class	296	// desc: data for base Chuck Exception class

chuginate/template/chuck/include/chuck_oo.h+93−41

@@ -98,7 +98,9 @@ public: · 97 unmodified lines
98	virtual void release();	98	virtual void release();
99	// lock	99	// lock
100	virtual void lock();	100	virtual void lock();
101		101	// unlock \| 1.5.0.0 (ge) added
		102	virtual void unlock();
		103
102	// NOTE: be careful when overriding these, should always	104	// NOTE: be careful when overriding these, should always
103	// explicitly call up to ChucK_VM_Object (ge: 2013)	105	// explicitly call up to ChucK_VM_Object (ge: 2013)
104		106
@@ -132,7 +134,7 @@ private: · 27 unmodified lines
132	//{	134	//{
133	//public:	135	//public:
134	// static Chuck_VM_Alloc * instance();	136	// static Chuck_VM_Alloc * instance();
135	//	137	//
136	//public:	138	//public:
137	// void add_object( Chuck_VM_Object * obj );	139	// void add_object( Chuck_VM_Object * obj );
138	// void free_object( Chuck_VM_Object * obj );	140	// void free_object( Chuck_VM_Object * obj );
@@ -180,8 +182,8 @@ public: · 41 unmodified lines
180		182
181	public:	183	public:
182	// output type info (can be overriden; but probably shouldn't be)	184	// output type info (can be overriden; but probably shouldn't be)
183	virtual void apropos();	185	virtual void help();
184		186
185	public:	187	public:
186	// virtual table	188	// virtual table
187	Chuck_VTable * vtable;	189	Chuck_VTable * vtable;
@@ -228,7 +230,15 @@ public: · 40 unmodified lines
228	virtual t_CKINT find( const std::string & key ) = 0; // find	230	virtual t_CKINT find( const std::string & key ) = 0; // find
229	virtual t_CKINT erase( const std::string & key ) = 0; // erase	231	virtual t_CKINT erase( const std::string & key ) = 0; // erase
230	virtual void clear( ) = 0; // clear	232	virtual void clear( ) = 0; // clear
231		233	virtual void zero( t_CKUINT start, t_CKUINT end ) = 0; // zero
		234	virtual void zero() = 0; // zero (all)
		235	// get map keys \| added (1.4.2.0) nshaheed
		236	virtual void get_keys( std::vector<std::string> & keys ) = 0;
		237	// reverse array order \| added (1.5.0.0) azaday
		238	virtual void reverse() = 0;
		239	// reverse array order \| added (1.5.0.0) kunwoo, nshaheed, azaday, ge
		240	virtual void shuffle() = 0;
		241
232	Chuck_Type * m_array_type;	242	Chuck_Type * m_array_type;
233	};	243	};
234		244
@@ -254,8 +264,10 @@ public: · 19 unmodified lines
254	t_CKINT set( const std::string & key, t_CKUINT val );	264	t_CKINT set( const std::string & key, t_CKUINT val );
255	t_CKINT push_back( t_CKUINT val );	265	t_CKINT push_back( t_CKUINT val );
256	t_CKINT pop_back( );	266	t_CKINT pop_back( );
		267	t_CKINT pop_out( t_CKINT pos );
257	t_CKINT back( t_CKUINT * val ) const;	268	t_CKINT back( t_CKUINT * val ) const;
258	void zero( t_CKUINT start, t_CKUINT end );	269	void zero( t_CKUINT start, t_CKUINT end );
		270	void zero() { this->zero(0, m_vector.size()); }
259		271
260	virtual void clear( );	272	virtual void clear( );
261	virtual t_CKINT size( ) { return m_vector.size(); }	273	virtual t_CKINT size( ) { return m_vector.size(); }
@@ -264,13 +276,22 @@ public: · 2 unmodified lines
264	virtual t_CKINT set_capacity( t_CKINT capacity );	276	virtual t_CKINT set_capacity( t_CKINT capacity );
265	virtual t_CKINT find( const std::string & key );	277	virtual t_CKINT find( const std::string & key );
266	virtual t_CKINT erase( const std::string & key );	278	virtual t_CKINT erase( const std::string & key );
267	virtual t_CKINT data_type_size( ) { return CHUCK_ARRAY4_DATASIZE; }	279	virtual t_CKINT data_type_size( ) { return CHUCK_ARRAY4_DATASIZE; }
268	virtual t_CKINT data_type_kind( ) { return CHUCK_ARRAY4_DATAKIND; }	280	virtual t_CKINT data_type_kind( ) { return CHUCK_ARRAY4_DATAKIND; }
		281	// get map keys \| added (1.4.2.0) nshaheed
		282	virtual void get_keys( std::vector<std::string> & keys );
		283	// reverse array order \| added (1.5.0.0) azaday
		284	virtual void reverse();
		285	// reverse array order \| added (1.5.0.0) kunwoo, nshaheed, azaday, ge
		286	virtual void shuffle();
269		287
270	public:	288	public:
271	std::vector<t_CKUINT> m_vector;	289	std::vector<t_CKUINT> m_vector;
272	std::map<std::string, t_CKUINT> m_map;	290	std::map<std::string, t_CKUINT> m_map;
273	t_CKBOOL m_is_obj;	291	t_CKBOOL m_is_obj;
		292
		293	// TODO: may need additional information here for set_size, if this is part of a multi-dim array
		294
274	// t_CKINT m_size;	295	// t_CKINT m_size;
275	// t_CKINT m_capacity;	296	// t_CKINT m_capacity;
276	};	297	};
@@ -297,8 +318,10 @@ public: · 20 unmodified lines
297	t_CKINT set( const std::string & key, t_CKFLOAT val );	318	t_CKINT set( const std::string & key, t_CKFLOAT val );
298	t_CKINT push_back( t_CKFLOAT val );	319	t_CKINT push_back( t_CKFLOAT val );
299	t_CKINT pop_back( );	320	t_CKINT pop_back( );
		321	t_CKINT pop_out( t_CKINT pos );
300	t_CKINT back( t_CKFLOAT * val ) const;	322	t_CKINT back( t_CKFLOAT * val ) const;
301	void zero( t_CKUINT start, t_CKUINT end );	323	void zero( t_CKUINT start, t_CKUINT end );
		324	void zero() { this->zero(0, m_vector.size()); }
302		325
303	virtual void clear( );	326	virtual void clear( );
304	virtual t_CKINT size( ) { return m_vector.size(); }	327	virtual t_CKINT size( ) { return m_vector.size(); }
@@ -308,7 +331,13 @@ public: · 3 unmodified lines
308	virtual t_CKINT find( const std::string & key );	331	virtual t_CKINT find( const std::string & key );
309	virtual t_CKINT erase( const std::string & key );	332	virtual t_CKINT erase( const std::string & key );
310	virtual t_CKINT data_type_size( ) { return CHUCK_ARRAY8_DATASIZE; }	333	virtual t_CKINT data_type_size( ) { return CHUCK_ARRAY8_DATASIZE; }
311	virtual t_CKINT data_type_kind( ) { return CHUCK_ARRAY8_DATAKIND; }	334	virtual t_CKINT data_type_kind( ) { return CHUCK_ARRAY8_DATAKIND; }
		335	// get map keys \| added (1.4.2.0) nshaheed
		336	virtual void get_keys( std::vector<std::string> & keys );
		337	// reverse array order \| added (1.5.0.0) azaday
		338	virtual void reverse();
		339	// reverse array order \| added (1.5.0.0) kunwoo, nshaheed, azaday, ge
		340	virtual void shuffle();
312		341
313	public:	342	public:
314	std::vector<t_CKFLOAT> m_vector;	343	std::vector<t_CKFLOAT> m_vector;
@@ -339,8 +368,10 @@ public: · 24 unmodified lines
339	t_CKINT set( const std::string & key, const t_CKCOMPLEX & val );	368	t_CKINT set( const std::string & key, const t_CKCOMPLEX & val );
340	t_CKINT push_back( const t_CKCOMPLEX & val );	369	t_CKINT push_back( const t_CKCOMPLEX & val );
341	t_CKINT pop_back( );	370	t_CKINT pop_back( );
		371	t_CKINT pop_out( t_CKINT pos );
342	t_CKINT back( t_CKCOMPLEX * val ) const;	372	t_CKINT back( t_CKCOMPLEX * val ) const;
343	void zero( t_CKUINT start, t_CKUINT end );	373	void zero( t_CKUINT start, t_CKUINT end );
		374	void zero() { this->zero(0, m_vector.size()); }
344		375
345	virtual void clear( );	376	virtual void clear( );
346	virtual t_CKINT size( ) { return m_vector.size(); }	377	virtual t_CKINT size( ) { return m_vector.size(); }
@@ -350,7 +381,13 @@ public: · 3 unmodified lines
350	virtual t_CKINT find( const std::string & key );	381	virtual t_CKINT find( const std::string & key );
351	virtual t_CKINT erase( const std::string & key );	382	virtual t_CKINT erase( const std::string & key );
352	virtual t_CKINT data_type_size( ) { return CHUCK_ARRAY16_DATASIZE; }	383	virtual t_CKINT data_type_size( ) { return CHUCK_ARRAY16_DATASIZE; }
353	virtual t_CKINT data_type_kind( ) { return CHUCK_ARRAY16_DATAKIND; }	384	virtual t_CKINT data_type_kind( ) { return CHUCK_ARRAY16_DATAKIND; }
		385	// get map keys \| added (1.4.2.0) nshaheed
		386	virtual void get_keys( std::vector<std::string> & keys );
		387	// reverse array order \| added (1.5.0.0) azaday
		388	virtual void reverse();
		389	// reverse array order \| added (1.5.0.0) kunwoo, nshaheed, azaday, ge
		390	virtual void shuffle();
354		391
355	public:	392	public:
356	std::vector<t_CKCOMPLEX> m_vector;	393	std::vector<t_CKCOMPLEX> m_vector;
@@ -371,7 +408,7 @@ struct Chuck_Array24 : Chuck_Array · 14 unmodified lines
371	public:	408	public:
372	Chuck_Array24( t_CKINT capacity = 8 );	409	Chuck_Array24( t_CKINT capacity = 8 );
373	virtual ~Chuck_Array24();	410	virtual ~Chuck_Array24();
374		411
375	public:	412	public:
376	t_CKUINT addr( t_CKINT i );	413	t_CKUINT addr( t_CKINT i );
377	t_CKUINT addr( const std::string & key );	414	t_CKUINT addr( const std::string & key );
@@ -381,9 +418,11 @@ public: · 3 unmodified lines
381	t_CKINT set( const std::string & key, const t_CKVEC3 & val );	418	t_CKINT set( const std::string & key, const t_CKVEC3 & val );
382	t_CKINT push_back( const t_CKVEC3 & val );	419	t_CKINT push_back( const t_CKVEC3 & val );
383	t_CKINT pop_back( );	420	t_CKINT pop_back( );
		421	t_CKINT pop_out( t_CKUINT pos );
384	t_CKINT back( t_CKVEC3 * val ) const;	422	t_CKINT back( t_CKVEC3 * val ) const;
385	void zero( t_CKUINT start, t_CKUINT end );	423	void zero( t_CKUINT start, t_CKUINT end );
386		424	void zero() { this->zero(0, m_vector.size()); }
		425
387	virtual void clear( );	426	virtual void clear( );
388	virtual t_CKINT size( ) { return m_vector.size(); }	427	virtual t_CKINT size( ) { return m_vector.size(); }
389	virtual t_CKINT capacity( ) { return m_vector.capacity(); }	428	virtual t_CKINT capacity( ) { return m_vector.capacity(); }
@@ -393,7 +432,13 @@ public: · 3 unmodified lines
393	virtual t_CKINT erase( const std::string & key );	432	virtual t_CKINT erase( const std::string & key );
394	virtual t_CKINT data_type_size( ) { return CHUCK_ARRAY24_DATASIZE; }	433	virtual t_CKINT data_type_size( ) { return CHUCK_ARRAY24_DATASIZE; }
395	virtual t_CKINT data_type_kind( ) { return CHUCK_ARRAY24_DATAKIND; }	434	virtual t_CKINT data_type_kind( ) { return CHUCK_ARRAY24_DATAKIND; }
396		435	// get map keys \| added (1.4.2.0) nshaheed
		436	virtual void get_keys( std::vector<std::string> & keys );
		437	// reverse array order \| added (1.5.0.0) azaday
		438	virtual void reverse();
		439	// reverse array order \| added (1.5.0.0) kunwoo, nshaheed, azaday, ge
		440	virtual void shuffle();
		441
397	public:	442	public:
398	std::vector<t_CKVEC3> m_vector;	443	std::vector<t_CKVEC3> m_vector;
399	std::map<std::string, t_CKVEC3> m_map;	444	std::map<std::string, t_CKVEC3> m_map;
@@ -411,7 +456,7 @@ struct Chuck_Array32 : Chuck_Array · 11 unmodified lines
411	public:	456	public:
412	Chuck_Array32( t_CKINT capacity = 8 );	457	Chuck_Array32( t_CKINT capacity = 8 );
413	virtual ~Chuck_Array32();	458	virtual ~Chuck_Array32();
414		459
415	public:	460	public:
416	t_CKUINT addr( t_CKINT i );	461	t_CKUINT addr( t_CKINT i );
417	t_CKUINT addr( const std::string & key );	462	t_CKUINT addr( const std::string & key );
@@ -421,9 +466,11 @@ public: · 3 unmodified lines
421	t_CKINT set( const std::string & key, const t_CKVEC4 & val );	466	t_CKINT set( const std::string & key, const t_CKVEC4 & val );
422	t_CKINT push_back( const t_CKVEC4 & val );	467	t_CKINT push_back( const t_CKVEC4 & val );
423	t_CKINT pop_back( );	468	t_CKINT pop_back( );
		469	t_CKINT pop_out( t_CKUINT pos );
424	t_CKINT back( t_CKVEC4 * val ) const;	470	t_CKINT back( t_CKVEC4 * val ) const;
425	void zero( t_CKUINT start, t_CKUINT end );	471	void zero( t_CKUINT start, t_CKUINT end );
426		472	void zero() { this->zero(0, m_vector.size()); }
		473
427	virtual void clear( );	474	virtual void clear( );
428	virtual t_CKINT size( ) { return m_vector.size(); }	475	virtual t_CKINT size( ) { return m_vector.size(); }
429	virtual t_CKINT capacity( ) { return m_vector.capacity(); }	476	virtual t_CKINT capacity( ) { return m_vector.capacity(); }
@@ -433,7 +480,13 @@ public: · 3 unmodified lines
433	virtual t_CKINT erase( const std::string & key );	480	virtual t_CKINT erase( const std::string & key );
434	virtual t_CKINT data_type_size( ) { return CHUCK_ARRAY32_DATASIZE; }	481	virtual t_CKINT data_type_size( ) { return CHUCK_ARRAY32_DATASIZE; }
435	virtual t_CKINT data_type_kind( ) { return CHUCK_ARRAY32_DATAKIND; }	482	virtual t_CKINT data_type_kind( ) { return CHUCK_ARRAY32_DATAKIND; }
436		483	// get map keys \| added (1.4.1.2) nshaheed
		484	virtual void get_keys( std::vector<std::string> & keys );
		485	// reverse array order \| added (1.5.0.0) azaday
		486	virtual void reverse();
		487	// reverse array order \| added (1.5.0.0) kunwoo, nshaheed, azaday, ge
		488	virtual void shuffle();
		489
437	public:	490	public:
438	std::vector<t_CKVEC4> m_vector;	491	std::vector<t_CKVEC4> m_vector;
439	std::map<std::string, t_CKVEC4> m_map;	492	std::map<std::string, t_CKVEC4> m_map;
@@ -457,7 +510,7 @@ struct Chuck_Global_Event_Listener · 17 unmodified lines
457	Chuck_Global_Get_Callback_Type callback_type;	510	Chuck_Global_Get_Callback_Type callback_type;
458	std::string name;	511	std::string name;
459	t_CKINT id;	512	t_CKINT id;
460	Chuck_Global_Event_Listener() : void_callback(NULL), listen_forever(FALSE),	513	Chuck_Global_Event_Listener() : void_callback(NULL), listen_forever(FALSE),
461	callback_type(ck_get_plain), name(""), id(0) {};	514	callback_type(ck_get_plain), name(""), id(0) {};
462	};	515	};
463		516
@@ -550,7 +603,7 @@ struct Chuck_IO : Chuck_Event · 86 unmodified lines
550	public:	603	public:
551	Chuck_IO();	604	Chuck_IO();
552	virtual ~Chuck_IO();	605	virtual ~Chuck_IO();
553		606
554	public:	607	public:
555	// meta	608	// meta
556	virtual t_CKBOOL good() = 0;	609	virtual t_CKBOOL good() = 0;
@@ -558,29 +611,37 @@ public: · 1 unmodified line
558	virtual void flush() = 0;	611	virtual void flush() = 0;
559	virtual t_CKINT mode() = 0;	612	virtual t_CKINT mode() = 0;
560	virtual void mode( t_CKINT flag ) = 0;	613	virtual void mode( t_CKINT flag ) = 0;
561		614
562	// reading	615	// reading
563	virtual Chuck_String * readLine() = 0;	616	virtual Chuck_String * readLine() = 0;
564	virtual t_CKINT readInt( t_CKINT flags ) = 0;	617	virtual t_CKINT readInt( t_CKINT flags ) = 0;
565	virtual t_CKFLOAT readFloat() = 0;	618	virtual t_CKFLOAT readFloat() = 0;
566	virtual t_CKBOOL readString( std::string & str ) = 0;	619	virtual t_CKBOOL readString( std::string & str ) = 0;
567	virtual t_CKBOOL eof() = 0;	620	virtual t_CKBOOL eof() = 0;
568		621
569	// writing	622	// writing
570	virtual void write( const std::string & val ) = 0;	623	virtual void write( const std::string & val ) = 0;
571	virtual void write( t_CKINT val ) = 0;	624	virtual void write( t_CKINT val ) = 0;
572	virtual void write( t_CKINT val, t_CKINT flags ) = 0;	625	virtual void write( t_CKINT val, t_CKINT flags ) = 0;
573	virtual void write( t_CKFLOAT val ) = 0;	626	virtual void write( t_CKFLOAT val ) = 0;
574		627
575	// constants
576	public:	628	public:
		629	// type \| moved to IO in 1.5.0.0 (ge)
		630	static const t_CKINT TYPE_ASCII;
		631	static const t_CKINT TYPE_BINARY;
		632	// datatype
577	static const t_CKINT INT32;	633	static const t_CKINT INT32;
578	static const t_CKINT INT16;	634	static const t_CKINT INT16;
579	static const t_CKINT INT8;	635	static const t_CKINT INT8;
580		636	// flags \| moved to IO in 1.5.0.0 (ge)
		637	static const t_CKINT FLAG_READ_WRITE;
		638	static const t_CKINT FLAG_READONLY;
		639	static const t_CKINT FLAG_WRITEONLY;
		640	static const t_CKINT FLAG_APPEND;
581	// asynchronous I/O members	641	// asynchronous I/O members
582	static const t_CKINT MODE_SYNC;	642	static const t_CKINT MODE_SYNC;
583	static const t_CKINT MODE_ASYNC;	643	static const t_CKINT MODE_ASYNC;
		644
584	Chuck_Event * m_asyncEvent;	645	Chuck_Event * m_asyncEvent;
585	#ifndef __DISABLE_THREADS__	646	#ifndef __DISABLE_THREADS__
586	XThread * m_thread;	647	XThread * m_thread;
@@ -597,7 +658,7 @@ public: · 10 unmodified lines
597		658
598		659
599		660
600	#ifndef __DISABLE_FILEIO__	661	// #ifndef __DISABLE_FILEIO__
601	//-----------------------------------------------------------------------------	662	//-----------------------------------------------------------------------------
602	// name: Chuck_IO_File	663	// name: Chuck_IO_File
603	// desc: Chuck File IO class	664	// desc: Chuck File IO class
@@ -608,7 +669,7 @@ public: · 4 unmodified lines
608	// REFACTOR-2017	669	// REFACTOR-2017
609	Chuck_IO_File( Chuck_VM * vm );	670	Chuck_IO_File( Chuck_VM * vm );
610	virtual ~Chuck_IO_File();	671	virtual ~Chuck_IO_File();
611		672
612	public:	673	public:
613	// meta	674	// meta
614	virtual t_CKBOOL open( const std::string & path, t_CKINT flags );	675	virtual t_CKBOOL open( const std::string & path, t_CKINT flags );
@@ -618,15 +679,15 @@ public: · 3 unmodified lines
618	virtual t_CKINT mode();	679	virtual t_CKINT mode();
619	virtual void mode( t_CKINT flag );	680	virtual void mode( t_CKINT flag );
620	virtual t_CKINT size();	681	virtual t_CKINT size();
621		682
622	// seeking	683	// seeking
623	virtual void seek( t_CKINT pos );	684	virtual void seek( t_CKINT pos );
624	virtual t_CKINT tell();	685	virtual t_CKINT tell();
625		686
626	// directories	687	// directories
627	virtual t_CKINT isDir();	688	virtual t_CKINT isDir();
628	virtual Chuck_Array4 * dirList();	689	virtual Chuck_Array4 * dirList();
629		690
630	// reading	691	// reading
631	// virtual Chuck_String * read( t_CKINT length );	692	// virtual Chuck_String * read( t_CKINT length );
632	virtual Chuck_String * readLine();	693	virtual Chuck_String * readLine();
@@ -634,7 +695,7 @@ public: · 1 unmodified line
634	virtual t_CKFLOAT readFloat();	695	virtual t_CKFLOAT readFloat();
635	virtual t_CKBOOL readString( std::string & str );	696	virtual t_CKBOOL readString( std::string & str );
636	virtual t_CKBOOL eof();	697	virtual t_CKBOOL eof();
637		698
638	// reading -- async	699	// reading -- async
639	/* TODO: doesn't look like asynchronous reads will work	700	/* TODO: doesn't look like asynchronous reads will work
640	static THREAD_RETURN ( THREAD_TYPE read_thread ) ( void *data );	701	static THREAD_RETURN ( THREAD_TYPE read_thread ) ( void *data );
@@ -642,29 +703,20 @@ public: · 1 unmodified line
642	static THREAD_RETURN ( THREAD_TYPE readInt_thread ) ( void *data );	703	static THREAD_RETURN ( THREAD_TYPE readInt_thread ) ( void *data );
643	static THREAD_RETURN ( THREAD_TYPE readFloat_thread ) ( void *data );	704	static THREAD_RETURN ( THREAD_TYPE readFloat_thread ) ( void *data );
644	*/	705	*/
645		706
646	// writing	707	// writing
647	virtual void write( const std::string & val );	708	virtual void write( const std::string & val );
648	virtual void write( t_CKINT val );	709	virtual void write( t_CKINT val );
649	virtual void write( t_CKINT val, t_CKINT flags );	710	virtual void write( t_CKINT val, t_CKINT flags );
650	virtual void write( t_CKFLOAT val );	711	virtual void write( t_CKFLOAT val );
651		712
652	#ifndef __DISABLE_THREADS__	713	#ifndef __DISABLE_THREADS__
653	// writing -- async	714	// writing -- async
654	static THREAD_RETURN ( THREAD_TYPE writeStr_thread ) ( void *data );	715	static THREAD_RETURN ( THREAD_TYPE writeStr_thread ) ( void *data );
655	static THREAD_RETURN ( THREAD_TYPE writeInt_thread ) ( void *data );	716	static THREAD_RETURN ( THREAD_TYPE writeInt_thread ) ( void *data );
656	static THREAD_RETURN ( THREAD_TYPE writeFloat_thread ) ( void *data );	717	static THREAD_RETURN ( THREAD_TYPE writeFloat_thread ) ( void *data );
657	#endif	718	#endif
658		719
659	public:
660	// constants
661	static const t_CKINT FLAG_READ_WRITE;
662	static const t_CKINT FLAG_READONLY;
663	static const t_CKINT FLAG_WRITEONLY;
664	static const t_CKINT FLAG_APPEND;
665	static const t_CKINT TYPE_ASCII;
666	static const t_CKINT TYPE_BINARY;
667
668	protected:	720	protected:
669	// open flags	721	// open flags
670	t_CKINT m_flags;	722	t_CKINT m_flags;
@@ -681,7 +733,7 @@ protected: · 10 unmodified lines
681	// vm and shred	733	// vm and shred
682	Chuck_VM * m_vmRef;	734	Chuck_VM * m_vmRef;
683	};	735	};
684	#endif // __DISABLE_FILEIO__	736	// #endif // __DISABLE_FILEIO__
685		737
686		738
687		739

chuginate/template/chuck/include/chuck_otf.h+4−4

@@ -74,15 +74,15 @@ void otf_hton( Net_Msg * msg ); · 73 unmodified lines
74	void otf_ntoh( Net_Msg * msg );	74	void otf_ntoh( Net_Msg * msg );
75		75
76	// process incoming message	76	// process incoming message
77	t_CKUINT otf_process_msg( Chuck_VM * vm, Chuck_Compiler * compiler,	77	t_CKUINT otf_process_msg( Chuck_VM * vm, Chuck_Compiler * compiler,
78	Net_Msg * msg, t_CKBOOL immediate, void * data );	78	Net_Msg * msg, t_CKBOOL immediate, void * data );
79		79
80	// send command	80	// send command
81	int otf_send_cmd( int argc, const char ** argv, t_CKINT & i, const char * host, int port, int * is_otf = NULL );	81	t_CKINT otf_send_cmd( t_CKINT argc, const char ** argv, t_CKINT & i, const char * host, t_CKINT port, t_CKINT * is_otf = NULL );
82	// send file to remote host	82	// send file to remote host
83	int otf_send_file( const char * filename, Net_Msg & msg, const char * op, ck_socket sock );	83	t_CKINT otf_send_file( const char * filename, Net_Msg & msg, const char * op, ck_socket sock );
84	// connect	84	// connect
85	ck_socket otf_send_connect( const char * host, int port );	85	ck_socket otf_send_connect( const char * host, t_CKINT port );
86		86
87	// callback	87	// callback
88	void * otf_cb( void * p );	88	void * otf_cb( void * p );

chuginate/template/chuck/include/chuck_parse.h+7−5

 // reset the parser
 void reset_parse( );
+// convert abstract syntax expression to string
+std::string absyn2str( a_Exp exp );
 // syntax highlighting tools
 #include <vector>
     std::string::size_type begin;
     // from the beginning of line
     std::string::size_type end;
     // constructor
     SyntaxToken() : type(0) { }
     // copy constructor
 struct SyntaxTokenList
 {
     std::vector<SyntaxToken> list;
     std::vector<SyntaxToken>::size_type howmany;
     // copy constructor
     SyntaxTokenList( const SyntaxTokenList & rhs )
     {
         for( std::vector<SyntaxToken>::size_type i = 0; i < howmany; i++ )
             list[i] = rhs.list[i];
     }
-	SyntaxTokenList() {
+    SyntaxTokenList() {
-		howmany = 0;
+        howmany = 0;
-	}
+    }
 };

chuginate/template/chuck/include/chuck_scan.h+2−2

@@ -38,13 +38,13 @@ · 37 unmodified lines
38		38
39		39
40	// scan a program into the env - type discovery scan	40	// scan a program into the env - type discovery scan
41	t_CKBOOL type_engine_scan0_prog( Chuck_Env * env, a_Program prog,	41	t_CKBOOL type_engine_scan0_prog( Chuck_Env * env, a_Program prog,
42	te_HowMuch val = te_do_all );	42	te_HowMuch val = te_do_all );
43	// scan a class definition (used by type_engine_add_dll())	43	// scan a class definition (used by type_engine_add_dll())
44	t_CKBOOL type_engine_scan0_class_def( Chuck_Env * env, a_Class_Def def );	44	t_CKBOOL type_engine_scan0_class_def( Chuck_Env * env, a_Class_Def def );
45		45
46	// scan a program into the env - type resolution scan	46	// scan a program into the env - type resolution scan
47	t_CKBOOL type_engine_scan1_prog( Chuck_Env * env, a_Program prog,	47	t_CKBOOL type_engine_scan1_prog( Chuck_Env * env, a_Program prog,
48	te_HowMuch val = te_do_all );	48	te_HowMuch val = te_do_all );
49	// scan a class definition (used by type_engine_add_dll())	49	// scan a class definition (used by type_engine_add_dll())
50	t_CKBOOL type_engine_scan1_class_def( Chuck_Env * env, a_Class_Def def );	50	t_CKBOOL type_engine_scan1_class_def( Chuck_Env * env, a_Class_Def def );

chuginate/template/chuck/include/chuck_shell.h+80−80

@@ -51,7 +51,7 @@ typedef string Chuck_Shell_Response; · 50 unmodified lines
51		51
52	//-----------------------------------------------------------------------------	52	//-----------------------------------------------------------------------------
53	// name: class Chuck_Shell	53	// name: class Chuck_Shell
54	// desc: controller class for facilitating interaction between a shell UI and a	54	// desc: controller class for facilitating interaction between a shell UI and a
55	// shell mode.	55	// shell mode.
56	//-----------------------------------------------------------------------------	56	//-----------------------------------------------------------------------------
57	class Chuck_Shell	57	class Chuck_Shell
@@ -59,7 +59,7 @@ class Chuck_Shell · 1 unmodified line
59	public:	59	public:
60	Chuck_Shell();	60	Chuck_Shell();
61	virtual ~Chuck_Shell();	61	virtual ~Chuck_Shell();
62		62
63	t_CKBOOL init( Chuck_VM * process_vm, Chuck_Shell_UI * );	63	t_CKBOOL init( Chuck_VM * process_vm, Chuck_Shell_UI * );
64	void run();	64	void run();
65	t_CKBOOL execute( string &, string & );	65	t_CKBOOL execute( string &, string & );
@@ -79,35 +79,35 @@ public: // HACK-GE: these were moved from protected for win32 · 13 unmodified lines
79	map < string, string > variables;	79	map < string, string > variables;
80	map < string, Command * > commands;	80	map < string, Command * > commands;
81	vector < Command * > allocated_commands;	81	vector < Command * > allocated_commands;
82		82
83	map < string, string > saved_code;	83	map < string, string > saved_code;
84		84
85	string code;	85	string code;
86		86
87	// helper functions	87	// helper functions
88	t_CKBOOL do_glob( const string &, string &, vector < string > & );	88	t_CKBOOL do_glob( const string &, string &, vector < string > & );
89	void do_code( string &, string &, string command = "+ " );	89	void do_code( string &, string &, string command = "+ " );
90	void do_code_context( string & );	90	void do_code_context( string & );
91		91
92	protected:	92	protected:
93	// helper functions	93	// helper functions
94	void do_aliases();	94	void do_aliases();
95	void do_variables();	95	void do_variables();
96		96
97	// code helper functions	97	// code helper functions
98	void start_code();	98	void start_code();
99	void continue_code( string & );	99	void continue_code( string & );
100	void string_hash( string &, string & );	100	void string_hash( string &, string & );
101		101
102	Chuck_Shell_UI * ui;	102	Chuck_Shell_UI * ui;
103		103
104	t_CKBOOL initialized;	104	t_CKBOOL initialized;
105	t_CKBOOL stop;	105	t_CKBOOL stop;
106		106
107	string prompt;	107	string prompt;
108		108
109	string in;	109	string in;
110		110
111	// code entry variables	111	// code entry variables
112	t_CKBOOL code_entry_active;	112	t_CKBOOL code_entry_active;
113	t_CKUINT scope;	113	t_CKUINT scope;
@@ -127,13 +127,13 @@ public: // HACK-GE: moved from protected for win32 · 13 unmodified lines
127	public:	127	public:
128	virtual t_CKBOOL init( Chuck_Shell * );	128	virtual t_CKBOOL init( Chuck_Shell * );
129	virtual t_CKINT execute( vector< string > &, string & ) = 0;	129	virtual t_CKINT execute( vector< string > &, string & ) = 0;
130	virtual string usage();	130	virtual string usage();
131	virtual string long_usage();	131	virtual string long_usage();
132		132
133	protected:	133	protected:
134	Chuck_Shell * caller;	134	Chuck_Shell * caller;
135	};	135	};
136		136
137	//-----------------------------------------------------------------------------	137	//-----------------------------------------------------------------------------
138	// name: class Chuck_Shell::Command_VM	138	// name: class Chuck_Shell::Command_VM
139	// desc: ...	139	// desc: ...
@@ -144,8 +144,8 @@ public: // HACK-GE: moved from protected for win32 · 4 unmodified lines
144	~Command_VM();	144	~Command_VM();
145	t_CKBOOL init( Chuck_Shell * );	145	t_CKBOOL init( Chuck_Shell * );
146	t_CKINT execute( vector< string > &, string & );	146	t_CKINT execute( vector< string > &, string & );
147	string usage();	147	string usage();
148		148
149	protected:	149	protected:
150	map < string, Command * > commands;	150	map < string, Command * > commands;
151	vector < Command * > allocated_commands;	151	vector < Command * > allocated_commands;
@@ -160,7 +160,7 @@ public: // HACK-GE: moved from protected for win32 · 8 unmodified lines
160	public:	160	public:
161	t_CKINT execute( vector< string > &, string & );	161	t_CKINT execute( vector< string > &, string & );
162	};	162	};
163		163
164	//-----------------------------------------------------------------------------	164	//-----------------------------------------------------------------------------
165	// name: class Chuck_Shell::Command_VM_Remove	165	// name: class Chuck_Shell::Command_VM_Remove
166	// desc: ...	166	// desc: ...
@@ -180,7 +180,7 @@ public: // HACK-GE: moved from protected for win32 · 13 unmodified lines
180	public:	180	public:
181	t_CKINT execute( vector< string > &, string & );	181	t_CKINT execute( vector< string > &, string & );
182	};	182	};
183		183
184	//-----------------------------------------------------------------------------	184	//-----------------------------------------------------------------------------
185	// name: class Chuck_Shell::Command_VM_List	185	// name: class Chuck_Shell::Command_VM_List
186	// desc: ...	186	// desc: ...
@@ -190,7 +190,7 @@ public: // HACK-GE: moved from protected for win32 · 3 unmodified lines
190	public:	190	public:
191	t_CKINT execute( vector< string > &, string & );	191	t_CKINT execute( vector< string > &, string & );
192	};	192	};
193		193
194	//-----------------------------------------------------------------------------	194	//-----------------------------------------------------------------------------
195	// name: class Chuck_Shell::Command_VM_Swap	195	// name: class Chuck_Shell::Command_VM_Swap
196	// desc: ...	196	// desc: ...
@@ -200,7 +200,7 @@ public: // HACK-GE: moved from protected for win32 · 3 unmodified lines
200	public:	200	public:
201	t_CKINT execute( vector< string > &, string & );	201	t_CKINT execute( vector< string > &, string & );
202	};	202	};
203		203
204	//-----------------------------------------------------------------------------	204	//-----------------------------------------------------------------------------
205	// name: class Chuck_Shell::Command_VM_AttachAdd	205	// name: class Chuck_Shell::Command_VM_AttachAdd
206	// desc: ...	206	// desc: ...
@@ -210,7 +210,7 @@ public: // HACK-GE: moved from protected for win32 · 3 unmodified lines
210	public:	210	public:
211	t_CKINT execute( vector< string > &, string & );	211	t_CKINT execute( vector< string > &, string & );
212	};	212	};
213		213
214	//-----------------------------------------------------------------------------	214	//-----------------------------------------------------------------------------
215	// name: class Chuck_Shell::Command_Add	215	// name: class Chuck_Shell::Command_Add
216	// desc: ...	216	// desc: ...
@@ -219,9 +219,9 @@ public: // HACK-GE: moved from protected for win32 · 2 unmodified lines
219	{	219	{
220	public:	220	public:
221	t_CKINT execute( vector < string > &, string & );	221	t_CKINT execute( vector < string > &, string & );
222	string usage();	222	string usage();
223	};	223	};
224		224
225	//-----------------------------------------------------------------------------	225	//-----------------------------------------------------------------------------
226	// name: class Chuck_Shell::Command_Remove	226	// name: class Chuck_Shell::Command_Remove
227	// desc: ...	227	// desc: ...
@@ -230,9 +230,9 @@ public: // HACK-GE: moved from protected for win32 · 2 unmodified lines
230	{	230	{
231	public:	231	public:
232	t_CKINT execute( vector < string > &, string & );	232	t_CKINT execute( vector < string > &, string & );
233	string usage();	233	string usage();
234	};	234	};
235		235
236	//-----------------------------------------------------------------------------	236	//-----------------------------------------------------------------------------
237	// name: class Chuck_Shell::Command_Status	237	// name: class Chuck_Shell::Command_Status
238	// desc: ...	238	// desc: ...
@@ -241,10 +241,10 @@ public: // HACK-GE: moved from protected for win32 · 2 unmodified lines
241	{	241	{
242	public:	242	public:
243	t_CKINT execute( vector < string > &, string & );	243	t_CKINT execute( vector < string > &, string & );
244	string usage();	244	string usage();
245	};	245	};
246		246
247	//-----------------------------------------------------------------------------	247	//-----------------------------------------------------------------------------
248	// name: class Chuck_Shell::Command_Removeall	248	// name: class Chuck_Shell::Command_Removeall
249	// desc: ...	249	// desc: ...
250	//-----------------------------------------------------------------------------	250	//-----------------------------------------------------------------------------
@@ -252,9 +252,9 @@ public: // HACK-GE: moved from protected for win32 · 1 unmodified line
252	{	252	{
253	public:	253	public:
254	t_CKINT execute( vector< string > &, string & );	254	t_CKINT execute( vector< string > &, string & );
255	string usage();	255	string usage();
256	};	256	};
257		257
258	//-----------------------------------------------------------------------------	258	//-----------------------------------------------------------------------------
259	// name: class Chuck_Shell::Command_Removelast	259	// name: class Chuck_Shell::Command_Removelast
260	// desc: ...	260	// desc: ...
@@ -263,9 +263,9 @@ public: // HACK-GE: moved from protected for win32 · 2 unmodified lines
263	{	263	{
264	public:	264	public:
265	t_CKINT execute( vector< string > &, string & );	265	t_CKINT execute( vector< string > &, string & );
266	string usage();	266	string usage();
267	};	267	};
268		268
269	//-----------------------------------------------------------------------------	269	//-----------------------------------------------------------------------------
270	// name: class Chuck_Shell::Command_Replace	270	// name: class Chuck_Shell::Command_Replace
271	// desc: ...	271	// desc: ...
@@ -274,9 +274,9 @@ public: // HACK-GE: moved from protected for win32 · 2 unmodified lines
274	{	274	{
275	public:	275	public:
276	t_CKINT execute( vector< string > &, string & );	276	t_CKINT execute( vector< string > &, string & );
277	string usage();	277	string usage();
278	};	278	};
279		279
280	//-----------------------------------------------------------------------------	280	//-----------------------------------------------------------------------------
281	// name: class Chuck_Shell::Command_Kill	281	// name: class Chuck_Shell::Command_Kill
282	// desc: ...	282	// desc: ...
@@ -285,9 +285,9 @@ public: // HACK-GE: moved from protected for win32 · 2 unmodified lines
285	{	285	{
286	public:	286	public:
287	t_CKINT execute( vector< string > &, string & );	287	t_CKINT execute( vector< string > &, string & );
288	//string usage();	288	//string usage();
289	};	289	};
290		290
291	//-----------------------------------------------------------------------------	291	//-----------------------------------------------------------------------------
292	// name: class Chuck_Shell::Command_Close	292	// name: class Chuck_Shell::Command_Close
293	// desc: ...	293	// desc: ...
@@ -296,9 +296,9 @@ public: // HACK-GE: moved from protected for win32 · 2 unmodified lines
296	{	296	{
297	public:	297	public:
298	t_CKINT execute( vector< string > &, string & );	298	t_CKINT execute( vector< string > &, string & );
299	//string usage();	299	//string usage();
300	};	300	};
301		301
302	//-----------------------------------------------------------------------------	302	//-----------------------------------------------------------------------------
303	// name: class Chuck_Shell::Command_Exit	303	// name: class Chuck_Shell::Command_Exit
304	// desc: ...	304	// desc: ...
@@ -307,9 +307,9 @@ public: // HACK-GE: moved from protected for win32 · 2 unmodified lines
307	{	307	{
308	public:	308	public:
309	t_CKINT execute( vector< string > &, string & );	309	t_CKINT execute( vector< string > &, string & );
310	//string usage();	310	//string usage();
311	};	311	};
312		312
313	//-----------------------------------------------------------------------------	313	//-----------------------------------------------------------------------------
314	// name: class Chuck_Shell::Command_Ls	314	// name: class Chuck_Shell::Command_Ls
315	// desc: ...	315	// desc: ...
@@ -318,9 +318,9 @@ public: // HACK-GE: moved from protected for win32 · 2 unmodified lines
318	{	318	{
319	public:	319	public:
320	t_CKINT execute( vector< string > &, string & );	320	t_CKINT execute( vector< string > &, string & );
321	//string usage();	321	//string usage();
322	};	322	};
323		323
324	//-----------------------------------------------------------------------------	324	//-----------------------------------------------------------------------------
325	// name: class Chuck_Shell::Command_Cd	325	// name: class Chuck_Shell::Command_Cd
326	// desc: ...	326	// desc: ...
@@ -329,9 +329,9 @@ public: // HACK-GE: moved from protected for win32 · 2 unmodified lines
329	{	329	{
330	public:	330	public:
331	t_CKINT execute( vector< string > &, string & );	331	t_CKINT execute( vector< string > &, string & );
332	//string usage();	332	//string usage();
333	};	333	};
334		334
335	//-----------------------------------------------------------------------------	335	//-----------------------------------------------------------------------------
336	// name: class Chuck_Shell::Command_Pwd	336	// name: class Chuck_Shell::Command_Pwd
337	// desc: ...	337	// desc: ...
@@ -341,7 +341,7 @@ public: // HACK-GE: moved from protected for win32 · 3 unmodified lines
341	public:	341	public:
342	t_CKINT execute( vector< string > &, string & );	342	t_CKINT execute( vector< string > &, string & );
343	};	343	};
344		344
345	//-----------------------------------------------------------------------------	345	//-----------------------------------------------------------------------------
346	// name: class Chuck_Shell::Command_Alias	346	// name: class Chuck_Shell::Command_Alias
347	// desc: ...	347	// desc: ...
@@ -351,7 +351,7 @@ public: // HACK-GE: moved from protected for win32 · 3 unmodified lines
351	public:	351	public:
352	t_CKINT execute( vector< string > &, string & );	352	t_CKINT execute( vector< string > &, string & );
353	};	353	};
354		354
355	//-----------------------------------------------------------------------------	355	//-----------------------------------------------------------------------------
356	// name: class Chuck_Shell::Command_Unalias	356	// name: class Chuck_Shell::Command_Unalias
357	// desc: ...	357	// desc: ...
@@ -361,7 +361,7 @@ public: // HACK-GE: moved from protected for win32 · 3 unmodified lines
361	public:	361	public:
362	t_CKINT execute( vector< string > &, string & );	362	t_CKINT execute( vector< string > &, string & );
363	};	363	};
364		364
365	//-----------------------------------------------------------------------------	365	//-----------------------------------------------------------------------------
366	// name: class Chuck_Shell::Command_Source	366	// name: class Chuck_Shell::Command_Source
367	// desc: ...	367	// desc: ...
@@ -371,7 +371,7 @@ public: // HACK-GE: moved from protected for win32 · 3 unmodified lines
371	public:	371	public:
372	t_CKINT execute( vector< string > &, string & );	372	t_CKINT execute( vector< string > &, string & );
373	};	373	};
374		374
375	//-----------------------------------------------------------------------------	375	//-----------------------------------------------------------------------------
376	// name: class Chuck_Shell::Command_Code	376	// name: class Chuck_Shell::Command_Code
377	// desc: ...	377	// desc: ...
@@ -382,13 +382,13 @@ public: // HACK-GE: moved from protected for win32 · 4 unmodified lines
382	~Command_Code();	382	~Command_Code();
383	t_CKBOOL init( Chuck_Shell * );	383	t_CKBOOL init( Chuck_Shell * );
384	t_CKINT execute( vector< string > &, string & );	384	t_CKINT execute( vector< string > &, string & );
385	string usage();	385	string usage();
386		386
387	private:	387	private:
388	map < string, Command * > commands;	388	map < string, Command * > commands;
389	vector < Command * > allocated_commands;	389	vector < Command * > allocated_commands;
390	};	390	};
391		391
392	//-----------------------------------------------------------------------------	392	//-----------------------------------------------------------------------------
393	// name: class Chuck_Shell::Command_CodeContext	393	// name: class Chuck_Shell::Command_CodeContext
394	// desc: ...	394	// desc: ...
@@ -398,7 +398,7 @@ public: // HACK-GE: moved from protected for win32 · 3 unmodified lines
398	public:	398	public:
399	t_CKINT execute( vector< string > &, string & );	399	t_CKINT execute( vector< string > &, string & );
400	};	400	};
401		401
402	//-----------------------------------------------------------------------------	402	//-----------------------------------------------------------------------------
403	// name: class Chuck_Shell::Command_CodeSave	403	// name: class Chuck_Shell::Command_CodeSave
404	// desc: ...	404	// desc: ...
@@ -413,22 +413,22 @@ public: // HACK-GE: moved from protected for win32 · 8 unmodified lines
413	// name: class Chuck_Shell::Command_CodeDelete	413	// name: class Chuck_Shell::Command_CodeDelete
414	// desc: ...	414	// desc: ...
415	//-----------------------------------------------------------------------------	415	//-----------------------------------------------------------------------------
416	class Command_CodeDelete : public Command	416	class Command_CodeDelete : public Command
417	{	417	{
418	public:	418	public:
419	t_CKINT execute( vector< string > &, string & );	419	t_CKINT execute( vector< string > &, string & );
420	};	420	};
421		421
422	//-----------------------------------------------------------------------------	422	//-----------------------------------------------------------------------------
423	// name: class Chuck_Shell::Command_CodeAdd	423	// name: class Chuck_Shell::Command_CodeAdd
424	// desc: ...	424	// desc: ...
425	//-----------------------------------------------------------------------------	425	//-----------------------------------------------------------------------------
426	class Command_CodeAdd : public Command	426	class Command_CodeAdd : public Command
427	{	427	{
428	public:	428	public:
429	t_CKINT execute( vector< string > &, string & );	429	t_CKINT execute( vector< string > &, string & );
430	};	430	};
431		431
432	//-----------------------------------------------------------------------------	432	//-----------------------------------------------------------------------------
433	// name: class Chuck_Shell::Command_CodeList	433	// name: class Chuck_Shell::Command_CodeList
434	// desc: ...	434	// desc: ...
@@ -448,7 +448,7 @@ public: // HACK-GE: moved from protected for win32 · 13 unmodified lines
448	public:	448	public:
449	t_CKINT execute( vector< string > &, string & );	449	t_CKINT execute( vector< string > &, string & );
450	};	450	};
451		451
452	//-----------------------------------------------------------------------------	452	//-----------------------------------------------------------------------------
453	// name: class Chuck_Shell::Command_CodeWrite	453	// name: class Chuck_Shell::Command_CodeWrite
454	// desc: ...	454	// desc: ...
@@ -468,7 +468,7 @@ public: // HACK-GE: moved from protected for win32 · 13 unmodified lines
468	public:	468	public:
469	t_CKINT execute( vector< string > &, string & );	469	t_CKINT execute( vector< string > &, string & );
470	};	470	};
471		471
472	//-----------------------------------------------------------------------------	472	//-----------------------------------------------------------------------------
473	// name: class Chuck_Shell::Command_Help	473	// name: class Chuck_Shell::Command_Help
474	// desc: ...	474	// desc: ...
@@ -478,7 +478,7 @@ public: // HACK-GE: moved from protected for win32 · 3 unmodified lines
478	public:	478	public:
479	t_CKINT execute( vector< string > &, string & );	479	t_CKINT execute( vector< string > &, string & );
480	};	480	};
481		481
482	};	482	};
483		483
484		484
@@ -492,7 +492,7 @@ public: · 7 unmodified lines
492	virtual ~Chuck_Shell_VM() {}	492	virtual ~Chuck_Shell_VM() {}
493		493
494	public:	494	public:
495	virtual Chuck_Shell_VM * copy()=0;	495	virtual Chuck_Shell_VM * copy()=0;
496	virtual t_CKBOOL add_shred( const vector< string > &, string & )=0;	496	virtual t_CKBOOL add_shred( const vector< string > &, string & )=0;
497	virtual t_CKBOOL remove_shred( const vector< string > &, string & )=0;	497	virtual t_CKBOOL remove_shred( const vector< string > &, string & )=0;
498	virtual t_CKBOOL remove_all( string & )=0;	498	virtual t_CKBOOL remove_all( string & )=0;
@@ -511,9 +511,9 @@ class Chuck_Shell_Network_VM : public Chuck_Shell_VM · 12 unmodified lines
511	{	511	{
512	public:	512	public:
513	virtual ~Chuck_Shell_Network_VM() {}	513	virtual ~Chuck_Shell_Network_VM() {}
514		514
515	public:	515	public:
516	Chuck_Shell_VM * copy();	516	Chuck_Shell_VM * copy();
517	t_CKBOOL init( const string &, t_CKINT );	517	t_CKBOOL init( const string &, t_CKINT );
518	t_CKBOOL add_shred( const vector< string > &, string & );	518	t_CKBOOL add_shred( const vector< string > &, string & );
519	t_CKBOOL remove_shred( const vector< string > &, string & );	519	t_CKBOOL remove_shred( const vector< string > &, string & );
@@ -523,9 +523,9 @@ public: · 3 unmodified lines
523	t_CKBOOL status( string & );	523	t_CKBOOL status( string & );
524	t_CKBOOL kill( string & );	524	t_CKBOOL kill( string & );
525	string fullname();	525	string fullname();
526		526
527	private:	527	private:
528	string hostname;	528	string hostname;
529	t_CKINT port;	529	t_CKINT port;
530	};	530	};
531	/*	531	/*
@@ -537,9 +537,9 @@ class Chuck_Shell_Process_VM : public Chuck_Shell_VM · 5 unmodified lines
537	{	537	{
538	public:	538	public:
539	virtual ~Chuck_Shell_Process_VM() {}	539	virtual ~Chuck_Shell_Process_VM() {}
540		540
541	public:	541	public:
542	Chuck_Shell_VM * copy();	542	Chuck_Shell_VM * copy();
543	t_CKBOOL init( const string &, t_CKINT );	543	t_CKBOOL init( const string &, t_CKINT );
544	t_CKBOOL add_shred( const vector< string > &, string & );	544	t_CKBOOL add_shred( const vector< string > &, string & );
545	t_CKBOOL remove_shred( const vector< string > &, string & );	545	t_CKBOOL remove_shred( const vector< string > &, string & );
@@ -549,12 +549,12 @@ public: · 3 unmodified lines
549	t_CKBOOL status( string & );	549	t_CKBOOL status( string & );
550	t_CKBOOL kill( string & );	550	t_CKBOOL kill( string & );
551	string fullname();	551	string fullname();
552		552
553	t_CKUINT last_shred_id();	553	t_CKUINT last_shred_id();
554		554
555	private:	555	private:
556	Chuck_VM * vm;	556	Chuck_VM * vm;
557	Chuck_Compiler * compiler;	557	Chuck_Compiler * compiler;
558	};	558	};
559	*/	559	*/
560	//-----------------------------------------------------------------------------	560	//-----------------------------------------------------------------------------

chuginate/template/chuck/include/chuck_stats.h+10−10

@@ -64,7 +64,7 @@ struct Shred_Activation · 63 unmodified lines
64	{	64	{
65	t_CKTIME when;	65	t_CKTIME when;
66	t_CKUINT cycles;	66	t_CKUINT cycles;
67		67
68	Shred_Activation( t_CKTIME a, t_CKUINT b ) { when = a; cycles = b; }	68	Shred_Activation( t_CKTIME a, t_CKUINT b ) { when = a; cycles = b; }
69	};	69	};
70		70
@@ -108,31 +108,31 @@ public: · 37 unmodified lines
108	std::string owner;	108	std::string owner;
109	// source	109	// source
110	std::string source;	110	std::string source;
111		111
112	// ctrl rate calculation	112	// ctrl rate calculation
113	std::queue<t_CKDUR> diffs;	113	std::queue<t_CKDUR> diffs;
114	// number of diffs	114	// number of diffs
115	t_CKUINT num_diffs;	115	t_CKUINT num_diffs;
116	// total diffs	116	// total diffs
117	t_CKDUR diff_total;	117	t_CKDUR diff_total;
118		118
119	// exe per activation	119	// exe per activation
120	std::queue<t_CKUINT> act_cycles;	120	std::queue<t_CKUINT> act_cycles;
121	// total	121	// total
122	t_CKUINT act_cycles_total;	122	t_CKUINT act_cycles_total;
123	// last	123	// last
124	t_CKUINT last_cycles;	124	t_CKUINT last_cycles;
125		125
126	// children	126	// children
127	std::vector<Shred_Stat *> children;	127	std::vector<Shred_Stat *> children;
128	void get_sporked( std::vector<Shred_Stat *> & out );	128	void get_sporked( std::vector<Shred_Stat *> & out );
129		129
130	std::vector<Shred_Activation> activationss;	130	std::vector<Shred_Activation> activationss;
131	void get_activations( std::vector<Shred_Activation> & out );	131	void get_activations( std::vector<Shred_Activation> & out );
132		132
133	// mutex	133	// mutex
134	XMutex mutex;	134	XMutex mutex;
135		135
136	// audicle info	136	// audicle info
137	Shred_Data * data;	137	Shred_Data * data;
138	Shred_Time * time;	138	Shred_Time * time;
@@ -161,7 +161,7 @@ public: · 22 unmodified lines
161	static Chuck_Stats * instance();	161	static Chuck_Stats * instance();
162		162
163	public:	163	public:
164	void set_vm_ref( Chuck_VM * _vm ) { vm = _vm; }	164	void set_vm_ref( Chuck_VM * _vm ) { vm = _vm; }
165		165
166	public:	166	public:
167	void add_shred( Chuck_VM_Shred * shred );	167	void add_shred( Chuck_VM_Shred * shred );
@@ -173,16 +173,16 @@ public: · 5 unmodified lines
173	public:	173	public:
174	Shred_Stat * get_shred( t_CKUINT xid )	174	Shred_Stat * get_shred( t_CKUINT xid )
175	{ mutex.acquire(); Shred_Stat * s = shreds[xid]; mutex.release(); return s; }	175	{ mutex.acquire(); Shred_Stat * s = shreds[xid]; mutex.release(); return s; }
176	void get_shreds( std::vector<Shred_Stat *> & out,	176	void get_shreds( std::vector<Shred_Stat *> & out,
177	std::map<Shred_Stat , Shred_Stat > & d );	177	std::map<Shred_Stat , Shred_Stat > & d );
178	static t_CKBOOL activations_yes;	178	static t_CKBOOL activations_yes;
179		179
180	protected:	180	protected:
181	Chuck_Stats();	181	Chuck_Stats();
182	~Chuck_Stats();	182	~Chuck_Stats();
183		183
184	static Chuck_Stats * our_instance;	184	static Chuck_Stats * our_instance;
185		185
186	protected:	186	protected:
187	Chuck_VM * vm;	187	Chuck_VM * vm;
188	std::map<t_CKUINT, Shred_Stat *> shreds;	188	std::map<t_CKUINT, Shred_Stat *> shreds;

chuginate/template/chuck/include/chuck_symbol.h+1−1

@@ -43,7 +43,7 @@ extern "C" { · 42 unmodified lines
43		43
44	typedef struct S_Symbol_ * S_Symbol;	44	typedef struct S_Symbol_ * S_Symbol;
45		45
46	/* Make a unique symbol from a given c_str.	46	/* Make a unique symbol from a given c_str.
47	* Different calls to make_symbol("foo") will yield the same S_Symbol	47	* Different calls to make_symbol("foo") will yield the same S_Symbol
48	* value, even if the "foo" c_str are at different locations. */	48	* value, even if the "foo" c_str are at different locations. */
49	S_Symbol insert_symbol( c_constr );	49	S_Symbol insert_symbol( c_constr );

chuginate/template/chuck/include/chuck_table.h+2−2

@@ -51,7 +51,7 @@ TAB_table TAB_empty2(unsigned long size); · 50 unmodified lines
51	TAB_table TAB_empty3( TAB_eq_func eq, TAB_hash_func hash, unsigned int size );	51	TAB_table TAB_empty3( TAB_eq_func eq, TAB_hash_func hash, unsigned int size );
52	void TAB_delete( TAB_table t );	52	void TAB_delete( TAB_table t );
53		53
54	/* Enter the mapping "key"->"value" into table "t",	54	/* Enter the mapping "key"->"value" into table "t",
55	* shadowing but not destroying any previous binding for "key". */	55	* shadowing but not destroying any previous binding for "key". */
56	void TAB_enter(TAB_table t, void key, void value);	56	void TAB_enter(TAB_table t, void key, void value);
57		57
@@ -65,7 +65,7 @@ void *TAB_topv(TAB_table t); · 7 unmodified lines
65		65
66		66
67	/* Call "show" on every "key"->"value" pair in the table,	67	/* Call "show" on every "key"->"value" pair in the table,
68	* including shadowed bindings, in order from the most	68	* including shadowed bindings, in order from the most
69	* recent binding of any key to the oldest binding in the table */	69	* recent binding of any key to the oldest binding in the table */
70	void TAB_dump(TAB_table t, void (show)(void key, void *value));	70	void TAB_dump(TAB_table t, void (show)(void key, void *value));
71		71

chuginate/template/chuck/include/chuck_type.h+131−57

@@ -49,8 +49,8 @@ typedef enum { · 48 unmodified lines
49	// general types	49	// general types
50	te_none = 0, te_int, te_uint, te_single, te_float, te_double, te_time, te_dur,	50	te_none = 0, te_int, te_uint, te_single, te_float, te_double, te_time, te_dur,
51	te_complex, te_polar, te_string, te_thread, te_shred, te_class,	51	te_complex, te_polar, te_string, te_thread, te_shred, te_class,
52	te_function, te_object, te_user, te_array, te_null, te_ugen, te_uana,	52	te_function, te_object, te_user, te_array, te_null, te_ugen, te_uana,
53	te_event, te_void, te_stdout, te_stderr, te_adc, te_dac, te_bunghole,	53	te_event, te_void, te_stdout, te_stderr, te_adc, te_dac, te_bunghole,
54	te_uanablob, te_io, te_fileio, te_chout, te_cherr, te_multi,	54	te_uanablob, te_io, te_fileio, te_chout, te_cherr, te_multi,
55	te_vec3, te_vec4, te_vector // ge: added 1.3.5.3	55	te_vec3, te_vec4, te_vector // ge: added 1.3.5.3
56	} te_Type;	56	} te_Type;
@@ -77,13 +77,29 @@ typedef enum { · 20 unmodified lines
77	// name: enum te_HowMuch	77	// name: enum te_HowMuch
78	// desc: how much to scan/type check	78	// desc: how much to scan/type check
79	//-----------------------------------------------------------------------------	79	//-----------------------------------------------------------------------------
80	typedef enum {	80	typedef enum {
81	te_do_all = 0, te_do_classes_only, te_do_no_classes	81	te_do_all = 0, te_do_classes_only, te_do_no_classes
82	} te_HowMuch;	82	} te_HowMuch;
83		83
84		84
85		85
86		86
		87	//-----------------------------------------------------------------------------
		88	// name: enum te_Origin \| 1.5.0.0 (ge) added
		89	// desc: where something (e.g., a Type) originates
		90	//-----------------------------------------------------------------------------
		91	typedef enum {
		92	te_originUnknown = 0,
		93	te_originBuiltin, // in core
		94	te_originChugin, // in imported chugin
		95	te_originImport, // library CK code
		96	te_originUserDefined, // in user chuck code
		97	te_originGenerated // generated (e.g., array types like int[][][][])
		98	} te_Origin;
		99
		100
		101
		102
87	//-----------------------------------------------------------------------------	103	//-----------------------------------------------------------------------------
88	// name: struct Chuck_Scope	104	// name: struct Chuck_Scope
89	// desc: scoping structure	105	// desc: scoping structure
@@ -111,14 +127,14 @@ public: · 21 unmodified lines
111	// reset the scope	127	// reset the scope
112	void reset()	128	void reset()
113	{ scope.clear(); this->push(); }	129	{ scope.clear(); this->push(); }
114		130
115	// atomic commit	131	// atomic commit
116	void commit()	132	void commit()
117	{	133	{
118	assert( scope.size() != 0 );	134	assert( scope.size() != 0 );
119	std::map<S_Symbol, Chuck_VM_Object *>::iterator iter;	135	std::map<S_Symbol, Chuck_VM_Object *>::iterator iter;
120		136
121	// go through buffer	137	// go through buffer
122	for( iter = commit_map.begin(); iter != commit_map.end(); iter++ )	138	for( iter = commit_map.begin(); iter != commit_map.end(); iter++ )
123	{	139	{
124	// add to front/where	140	// add to front/where
@@ -135,7 +151,7 @@ public: · 10 unmodified lines
135	assert( scope.size() != 0 );	151	assert( scope.size() != 0 );
136	std::map<S_Symbol, Chuck_VM_Object *>::iterator iter;	152	std::map<S_Symbol, Chuck_VM_Object *>::iterator iter;
137		153
138	// go through buffer	154	// go through buffer
139	for( iter = commit_map.begin(); iter != commit_map.end(); iter++ )	155	for( iter = commit_map.begin(); iter != commit_map.end(); iter++ )
140	{	156	{
141	// release	157	// release
@@ -175,8 +191,8 @@ public: · 33 unmodified lines
175	{	191	{
176	val = (*scope.back())[xid];	192	val = (*scope.back())[xid];
177	// look in commit buffer if the back is the front	193	// look in commit buffer if the back is the front
178	if( !val && scope.back() == scope.front()	194	if( !val && scope.back() == scope.front()
179	&& (commit_map.find(xid) != commit_map.end()) )	195	&& (commit_map.find(xid) != commit_map.end()) )
180	val = commit_map[xid];	196	val = commit_map[xid];
181	}	197	}
182	else if( climb > 0 )	198	else if( climb > 0 )
@@ -199,8 +215,15 @@ public: · 16 unmodified lines
199	return (T)val;	215	return (T)val;
200	}	216	}
201		217
		218	// test if a name has been "mangled", e.g., "toString@0@Object"
		219	static t_CKBOOL is_mangled( const std::string & name )
		220	{
		221	// check for @ in the name, which would not be possible for names in language
		222	return ( name.find("@") != std::string::npos );
		223	}
		224
202	// get list of top level	225	// get list of top level
203	void get_toplevel( std::vector<Chuck_VM_Object *> & out )	226	void get_toplevel( std::vector<Chuck_VM_Object *> & out, t_CKBOOL includeMangled = TRUE )
204	{	227	{
205	assert( scope.size() != 0 );	228	assert( scope.size() != 0 );
206	std::map<S_Symbol, Chuck_VM_Object *>::iterator iter;	229	std::map<S_Symbol, Chuck_VM_Object *>::iterator iter;
@@ -213,30 +236,36 @@ public: · 6 unmodified lines
213	// go through map	236	// go through map
214	for( iter = m->begin(); iter != m->end(); iter++ )	237	for( iter = m->begin(); iter != m->end(); iter++ )
215	{	238	{
		239	// check mangled name
		240	if( !includeMangled && is_mangled( std::string(S_name((*iter).first))) )
		241	continue;
216	// add	242	// add
217	out.push_back( (*iter).second );	243	out.push_back( (*iter).second );
218	}	244	}
219	}	245	}
220		246
221	// get list of top level	247	// get list of top level
222	void get_level( int level, std::vector<Chuck_VM_Object *> & out )	248	void get_level( int level, std::vector<Chuck_VM_Object *> & out, t_CKBOOL includeMangled = TRUE )
223	{	249	{
224	assert( scope.size() >= level );	250	assert( scope.size() >= level );
225	std::map<S_Symbol, Chuck_VM_Object *>::iterator iter;	251	std::map<S_Symbol, Chuck_VM_Object *>::iterator iter;
226		252
227	// clear the out	253	// clear the out
228	out.clear();	254	out.clear();
229	// get the front of the array	255	// get the front of the array
230	std::map<S_Symbol, Chuck_VM_Object > m = &commit_map;	256	std::map<S_Symbol, Chuck_VM_Object > m = &commit_map;
231		257
232	// go through map	258	// go through map
233	for( iter = m->begin(); iter != m->end(); iter++ )	259	for( iter = m->begin(); iter != m->end(); iter++ )
234	{	260	{
		261	// check mangled name
		262	if( !includeMangled && is_mangled( std::string(S_name((*iter).first))) )
		263	continue;
		264
235	// add	265	// add
236	out.push_back( (*iter).second );	266	out.push_back( (*iter).second );
237	}	267	}
238	}	268	}
239
240		269
241	protected:	270	protected:
242	std::vector<std::map<S_Symbol, Chuck_VM_Object > > scope;	271	std::vector<std::map<S_Symbol, Chuck_VM_Object > > scope;
@@ -288,7 +317,7 @@ struct Chuck_Namespace : public Chuck_VM_Object · 45 unmodified lines
288	t_CKUINT offset;	317	t_CKUINT offset;
289		318
290	// constructor	319	// constructor
291	Chuck_Namespace() { pre_ctor = NULL; dtor = NULL; parent = NULL; offset = 0;	320	Chuck_Namespace() { pre_ctor = NULL; dtor = NULL; parent = NULL; offset = 0;
292	class_data = NULL; class_data_size = 0; }	321	class_data = NULL; class_data_size = 0; }
293	// destructor	322	// destructor
294	virtual ~Chuck_Namespace() {	323	virtual ~Chuck_Namespace() {
@@ -308,13 +337,13 @@ struct Chuck_Namespace : public Chuck_VM_Object · 13 unmodified lines
308	Chuck_Func * lookup_func( S_Symbol name, t_CKINT climb = 1 );	337	Chuck_Func * lookup_func( S_Symbol name, t_CKINT climb = 1 );
309		338
310	// commit the maps	339	// commit the maps
311	void commit() {	340	void commit() {
312	EM_log( CK_LOG_FINER, "committing namespace: '%s'...", name.c_str() );	341	EM_log( CK_LOG_FINER, "committing namespace: '%s'...", name.c_str() );
313	type.commit(); value.commit(); func.commit();	342	type.commit(); value.commit(); func.commit();
314	}	343	}
315		344
316	// rollback the maps	345	// rollback the maps
317	void rollback() {	346	void rollback() {
318	EM_log( CK_LOG_FINER, "rolling back namespace: '%s'...", name.c_str() );	347	EM_log( CK_LOG_FINER, "rolling back namespace: '%s'...", name.c_str() );
319	type.rollback(); value.rollback(); func.rollback();	348	type.rollback(); value.rollback(); func.rollback();
320	}	349	}
@@ -324,7 +353,7 @@ struct Chuck_Namespace : public Chuck_VM_Object · 3 unmodified lines
324	// get top level values	353	// get top level values
325	void get_values( std::vector<Chuck_Value *> & out );	354	void get_values( std::vector<Chuck_Value *> & out );
326	// get top level functions	355	// get top level functions
327	void get_funcs( std::vector<Chuck_Func *> & out );	356	void get_funcs( std::vector<Chuck_Func *> & out, t_CKBOOL includeManged = TRUE );
328	};	357	};
329		358
330		359
@@ -334,7 +363,7 @@ struct Chuck_Namespace : public Chuck_VM_Object · 3 unmodified lines
334	// name: struct Chuck_Context	363	// name: struct Chuck_Context
335	// desc: runtime type information pertaining to a file	364	// desc: runtime type information pertaining to a file
336	//-----------------------------------------------------------------------------	365	//-----------------------------------------------------------------------------
337	struct Chuck_Context : public Chuck_VM_Object	366	struct Chuck_Context : public Chuck_VM_Object
338	{	367	{
339	// src_name	368	// src_name
340	std::string filename;	369	std::string filename;
@@ -370,7 +399,7 @@ struct Chuck_Context : public Chuck_VM_Object · 29 unmodified lines
370	void rollback();	399	void rollback();
371		400
372	// constructor	401	// constructor
373	Chuck_Context() { parse_tree = NULL; nspc = new Chuck_Namespace;	402	Chuck_Context() { parse_tree = NULL; nspc = new Chuck_Namespace;
374	public_class_def = NULL; has_error = FALSE;	403	public_class_def = NULL; has_error = FALSE;
375	progress = P_NONE; }	404	progress = P_NONE; }
376	// destructor	405	// destructor
@@ -398,10 +427,15 @@ public: · 21 unmodified lines
398	// constructor	427	// constructor
399	Chuck_Env();	428	Chuck_Env();
400		429
		430	public:
		431	// initialize
		432	t_CKBOOL init();
		433
401	// REFACTOR-2017: carrier and accessors	434	// REFACTOR-2017: carrier and accessors
402	public:	435	public:
403	void set_carrier( Chuck_Carrier * carrier ) { m_carrier = carrier; }	436	void set_carrier( Chuck_Carrier * carrier ) { m_carrier = carrier; }
404	Chuck_VM * vm() { return m_carrier->vm; }	437	Chuck_VM * vm() { return m_carrier ? m_carrier->vm : NULL; }
		438	Chuck_Compiler * compiler() { return m_carrier ? m_carrier->compiler : NULL; }
405		439
406	protected:	440	protected:
407	Chuck_Carrier * m_carrier;	441	Chuck_Carrier * m_carrier;
@@ -425,7 +459,7 @@ public: · 17 unmodified lines
425	else	459	else
426	return user_nspc;	460	return user_nspc;
427	}	461	}
428		462
429	// namespace stack	463	// namespace stack
430	std::vector<Chuck_Namespace *> nspc_stack;	464	std::vector<Chuck_Namespace *> nspc_stack;
431	// expression namespace	465	// expression namespace
@@ -482,7 +516,7 @@ public: · 50 unmodified lines
482	// make sure this is 0	516	// make sure this is 0
483	class_scope = 0;	517	class_scope = 0;
484	}	518	}
485		519
486	void load_user_namespace()	520	void load_user_namespace()
487	{	521	{
488	// user namespace	522	// user namespace
@@ -492,7 +526,7 @@ public: · 3 unmodified lines
492	SAFE_ADD_REF(global_nspc);	526	SAFE_ADD_REF(global_nspc);
493	SAFE_ADD_REF(user_nspc);	527	SAFE_ADD_REF(user_nspc);
494	}	528	}
495		529
496	void clear_user_namespace()	530	void clear_user_namespace()
497	{	531	{
498	if(user_nspc) SAFE_RELEASE(user_nspc->parent);	532	if(user_nspc) SAFE_RELEASE(user_nspc->parent);
@@ -506,11 +540,11 @@ public: · 7 unmodified lines
506	{ assert( nspc_stack.size() > 0 ); return nspc_stack.back(); }	540	{ assert( nspc_stack.size() > 0 ); return nspc_stack.back(); }
507	Chuck_Type * class_top( )	541	Chuck_Type * class_top( )
508	{ assert( class_stack.size() > 0 ); return class_stack.back(); }	542	{ assert( class_stack.size() > 0 ); return class_stack.back(); }
509		543
510	// check whether the context is the global context	544	// check whether the context is the global context
511	t_CKBOOL is_global()	545	t_CKBOOL is_global()
512	{ return class_def == NULL && func == NULL && class_scope == 0; }	546	{ return class_def == NULL && func == NULL && class_scope == 0; }
513		547
514	public:	548	public:
515	// REFACTOR-2017: public types	549	// REFACTOR-2017: public types
516	Chuck_Type * t_void;	550	Chuck_Type * t_void;
@@ -533,12 +567,10 @@ public: · 16 unmodified lines
533	Chuck_Type * t_uanablob;	567	Chuck_Type * t_uanablob;
534	Chuck_Type * t_shred;	568	Chuck_Type * t_shred;
535	Chuck_Type * t_io;	569	Chuck_Type * t_io;
536	#ifndef __DISABLE_FILEIO__
537	Chuck_Type * t_fileio;	570	Chuck_Type * t_fileio;
538	#endif
539	Chuck_Type * t_chout;	571	Chuck_Type * t_chout;
540	Chuck_Type * t_cherr;	572	Chuck_Type * t_cherr;
541	Chuck_Type * t_thread;	573	// Chuck_Type * t_thread;
542	Chuck_Type * t_class;	574	Chuck_Type * t_class;
543	Chuck_Type * t_dac;	575	Chuck_Type * t_dac;
544	Chuck_Type * t_adc;	576	Chuck_Type * t_adc;
@@ -563,7 +595,7 @@ struct Chuck_UGen_Info : public Chuck_VM_Object · 18 unmodified lines
563	t_CKUINT num_ins;	595	t_CKUINT num_ins;
564	// number of outgoing channels	596	// number of outgoing channels
565	t_CKUINT num_outs;	597	t_CKUINT num_outs;
566		598
567	// for uana, NULL for ugen	599	// for uana, NULL for ugen
568	f_tock tock;	600	f_tock tock;
569	// number of incoming ana channels	601	// number of incoming ana channels
@@ -573,7 +605,7 @@ struct Chuck_UGen_Info : public Chuck_VM_Object · 3 unmodified lines
573		605
574	// constructor	606	// constructor
575	Chuck_UGen_Info()	607	Chuck_UGen_Info()
576	{ tick = NULL; tickf = NULL; pmsg = NULL; num_ins = num_outs = 1;	608	{ tick = NULL; tickf = NULL; pmsg = NULL; num_ins = num_outs = 1;
577	tock = NULL; num_ins_ana = num_outs_ana = 1; }	609	tock = NULL; num_ins_ana = num_outs_ana = 1; }
578	};	610	};
579		611
@@ -583,8 +615,9 @@ struct Chuck_UGen_Info : public Chuck_VM_Object · 3 unmodified lines
583	//-----------------------------------------------------------------------------	615	//-----------------------------------------------------------------------------
584	// name: struct Chuck_Type	616	// name: struct Chuck_Type
585	// desc: class containing information about a type	617	// desc: class containing information about a type
586	//-----------------------------------------------------------------------------_id	618	// note: 1.5.0.0 (ge) Chuck_VM_Object -> Chuck_Object
587	struct Chuck_Type : public Chuck_VM_Object	619	//-----------------------------------------------------------------------------
		620	struct Chuck_Type : public Chuck_Object
588	{	621	{
589	// type id	622	// type id
590	te_Type xid;	623	te_Type xid;
@@ -620,7 +653,9 @@ struct Chuck_Type : public Chuck_VM_Object · 29 unmodified lines
620	t_CKBOOL has_destructor;	653	t_CKBOOL has_destructor;
621	// custom allocator	654	// custom allocator
622	f_alloc allocator;	655	f_alloc allocator;
623		656	// origin hint
		657	te_Origin originHint;
		658
624	// documentation	659	// documentation
625	std::string doc;	660	std::string doc;
626	// example files	661	// example files
@@ -650,17 +685,23 @@ public: · 23 unmodified lines
650	const std::string & str();	685	const std::string & str();
651	// to c string	686	// to c string
652	const char * c_name();	687	const char * c_name();
653		688
654	protected:	689	protected:
655	// this for str() and c_name() use only	690	// this for str() and c_name() use only
656	std::string ret;	691	std::string ret;
657		692
658	public: // apropos \| 1.4.1.0 (ge)	693	public: // apropos \| 1.4.1.0 (ge)
659	// dump info to console	694	// generate info; output to console
660	void apropos();	695	void apropos();
661	// dump info to string	696	// generate info; output to string
662	void apropos( std::string & output );	697	void apropos( std::string & output );
663		698
		699	public: // dump \| 1.4.1.1 (ge)
		700	// generate object state; output to console
		701	void dump( Chuck_Object * obj );
		702	// generate object state; output to string
		703	void dump( Chuck_Object * obj, std::string & output );
		704
664	protected: // apropos-related helper function	705	protected: // apropos-related helper function
665	// dump top level info	706	// dump top level info
666	void apropos_top( std::string & output, const std::string & prefix );	707	void apropos_top( std::string & output, const std::string & prefix );
@@ -711,7 +752,7 @@ struct Chuck_Value : public Chuck_VM_Object · 44 unmodified lines
711	Chuck_Func * func_ref;	752	Chuck_Func * func_ref;
712	// overloads	753	// overloads
713	t_CKINT func_num_overloads;	754	t_CKINT func_num_overloads;
714		755
715	// documentation	756	// documentation
716	std::string doc;	757	std::string doc;
717		758
@@ -720,7 +761,7 @@ struct Chuck_Value : public Chuck_VM_Object · 2 unmodified lines
720	t_CKBOOL c = FALSE, t_CKBOOL acc = 0, Chuck_Namespace * o = NULL,	761	t_CKBOOL c = FALSE, t_CKBOOL acc = 0, Chuck_Namespace * o = NULL,
721	Chuck_Type * oc = NULL, t_CKUINT s = 0 )	762	Chuck_Type * oc = NULL, t_CKUINT s = 0 )
722	{ type = t; SAFE_ADD_REF(type); // add reference	763	{ type = t; SAFE_ADD_REF(type); // add reference
723	name = n; offset = s;	764	name = n; offset = s;
724	is_const = c; access = acc;	765	is_const = c; access = acc;
725	owner = o; SAFE_ADD_REF(o); // add reference	766	owner = o; SAFE_ADD_REF(o); // add reference
726	owner_class = oc; SAFE_ADD_REF(oc); // add reference	767	owner_class = oc; SAFE_ADD_REF(oc); // add reference
@@ -772,13 +813,13 @@ struct Chuck_Func : public Chuck_VM_Object · 45 unmodified lines
772	Chuck_Func * next;	813	Chuck_Func * next;
773	// for overriding	814	// for overriding
774	Chuck_Value * up;	815	Chuck_Value * up;
775		816
776	// documentation	817	// documentation
777	std::string doc;	818	std::string doc;
778		819
779	// constructor	820	// constructor
780	Chuck_Func() { def = NULL; code = NULL; is_member = FALSE; is_static = FALSE,	821	Chuck_Func() { def = NULL; code = NULL; is_member = FALSE; is_static = FALSE,
781	vt_index = 0xffffffff; value_ref = NULL; /dl_code = NULL;/ next = NULL;	822	vt_index = CK_NO_VALUE; value_ref = NULL; /dl_code = NULL;/ next = NULL;
782	up = NULL; }	823	up = NULL; }
783		824
784	// destructor	825	// destructor
@@ -802,7 +843,7 @@ t_CKBOOL type_engine_load_context( Chuck_Env * env, Chuck_Context * context ); · 17 unmodified lines
802	t_CKBOOL type_engine_unload_context( Chuck_Env * env );	843	t_CKBOOL type_engine_unload_context( Chuck_Env * env );
803		844
804	// type check a program into the env	845	// type check a program into the env
805	t_CKBOOL type_engine_check_prog( Chuck_Env * env, a_Program prog,	846	t_CKBOOL type_engine_check_prog( Chuck_Env * env, a_Program prog,
806	const std::string & filename );	847	const std::string & filename );
807	// make a context	848	// make a context
808	Chuck_Context * type_engine_make_context( a_Program prog,	849	Chuck_Context * type_engine_make_context( a_Program prog,
@@ -833,8 +874,11 @@ t_CKBOOL isfunc( Chuck_Env * env, Chuck_Type * type ); · 24 unmodified lines
833	t_CKBOOL iskindofint( Chuck_Env * env, Chuck_Type * type ); // added 1.3.1.0: this includes int + pointers	874	t_CKBOOL iskindofint( Chuck_Env * env, Chuck_Type * type ); // added 1.3.1.0: this includes int + pointers
834	t_CKUINT getkindof( Chuck_Env * env, Chuck_Type * type ); // added 1.3.1.0: to get the kindof a type	875	t_CKUINT getkindof( Chuck_Env * env, Chuck_Type * type ); // added 1.3.1.0: to get the kindof a type
835		876
		877
		878	//-----------------------------------------------------------------------------
836	// import	879	// import
837	Chuck_Type * type_engine_import_class_begin( Chuck_Env * env, Chuck_Type * type,	880	//-----------------------------------------------------------------------------
		881	Chuck_Type * type_engine_import_class_begin( Chuck_Env * env, Chuck_Type * type,
838	Chuck_Namespace * where, f_ctor pre_ctor, f_dtor dtor = NULL,	882	Chuck_Namespace * where, f_ctor pre_ctor, f_dtor dtor = NULL,
839	const char * doc = NULL );	883	const char * doc = NULL );
840	Chuck_Type * type_engine_import_class_begin( Chuck_Env * env, const char * name, const char * parent,	884	Chuck_Type * type_engine_import_class_begin( Chuck_Env * env, const char * name, const char * parent,
@@ -843,12 +887,14 @@ Chuck_Type * type_engine_import_class_begin( Chuck_Env * env, const char * name, · 2 unmodified lines
843	Chuck_Type * type_engine_import_ugen_begin( Chuck_Env * env, const char * name, const char * parent,	887	Chuck_Type * type_engine_import_ugen_begin( Chuck_Env * env, const char * name, const char * parent,
844	Chuck_Namespace * where, f_ctor pre_ctor, f_dtor dtor,	888	Chuck_Namespace * where, f_ctor pre_ctor, f_dtor dtor,
845	f_tick tick, f_tickf tickf, f_pmsg pmsg, // (tickf added 1.3.0.0)	889	f_tick tick, f_tickf tickf, f_pmsg pmsg, // (tickf added 1.3.0.0)
846	t_CKUINT num_ins = 0xffffffff, t_CKUINT num_outs = 0xffffffff,	890	t_CKUINT num_ins = CK_NO_VALUE,
		891	t_CKUINT num_outs = CK_NO_VALUE,
847	const char * doc = NULL );	892	const char * doc = NULL );
848	Chuck_Type * type_engine_import_ugen_begin( Chuck_Env * env, const char * name, const char * parent,	893	Chuck_Type * type_engine_import_ugen_begin( Chuck_Env * env, const char * name, const char * parent,
849	Chuck_Namespace * where, f_ctor pre_ctor, f_dtor dtor,	894	Chuck_Namespace * where, f_ctor pre_ctor, f_dtor dtor,
850	f_tick tick, f_pmsg pmsg,	895	f_tick tick, f_pmsg pmsg,
851	t_CKUINT num_ins = 0xffffffff, t_CKUINT num_outs = 0xffffffff,	896	t_CKUINT num_ins = CK_NO_VALUE,
		897	t_CKUINT num_outs = CK_NO_VALUE,
852	const char * doc = NULL );	898	const char * doc = NULL );
853	Chuck_Type * type_engine_import_ugen_begin( Chuck_Env * env, const char * name, const char * parent,	899	Chuck_Type * type_engine_import_ugen_begin( Chuck_Env * env, const char * name, const char * parent,
854	Chuck_Namespace * where, f_ctor pre_ctor, f_dtor dtor,	900	Chuck_Namespace * where, f_ctor pre_ctor, f_dtor dtor,
@@ -856,12 +902,14 @@ Chuck_Type * type_engine_import_ugen_begin( Chuck_Env * env, const char * name, · 1 unmodified line
856	Chuck_Type * type_engine_import_uana_begin( Chuck_Env * env, const char * name, const char * parent,	902	Chuck_Type * type_engine_import_uana_begin( Chuck_Env * env, const char * name, const char * parent,
857	Chuck_Namespace * where, f_ctor pre_ctor, f_dtor dtor,	903	Chuck_Namespace * where, f_ctor pre_ctor, f_dtor dtor,
858	f_tick tick, f_tock tock, f_pmsg pmsg,	904	f_tick tick, f_tock tock, f_pmsg pmsg,
859	t_CKUINT num_ins = 0xffffffff, t_CKUINT num_outs = 0xffffffff,	905	t_CKUINT num_ins = CK_NO_VALUE,
860	t_CKUINT num_ins_ana = 0xffffffff, t_CKUINT num_outs_ana = 0xffffffff,	906	t_CKUINT num_outs = CK_NO_VALUE,
		907	t_CKUINT num_ins_ana = CK_NO_VALUE,
		908	t_CKUINT num_outs_ana = CK_NO_VALUE,
861	const char * doc = NULL );	909	const char * doc = NULL );
862	t_CKBOOL type_engine_import_mfun( Chuck_Env * env, Chuck_DL_Func * mfun );	910	t_CKBOOL type_engine_import_mfun( Chuck_Env * env, Chuck_DL_Func * mfun );
863	t_CKBOOL type_engine_import_sfun( Chuck_Env * env, Chuck_DL_Func * sfun );	911	t_CKBOOL type_engine_import_sfun( Chuck_Env * env, Chuck_DL_Func * sfun );
864	t_CKUINT type_engine_import_mvar( Chuck_Env * env, const char * type,	912	t_CKUINT type_engine_import_mvar( Chuck_Env * env, const char * type,
865	const char * name, t_CKUINT is_const,	913	const char * name, t_CKUINT is_const,
866	const char * doc = NULL );	914	const char * doc = NULL );
867	t_CKBOOL type_engine_import_svar( Chuck_Env * env, const char * type,	915	t_CKBOOL type_engine_import_svar( Chuck_Env * env, const char * type,
@@ -871,10 +919,13 @@ t_CKBOOL type_engine_import_ugen_ctrl( Chuck_Env * env, const char * type, const · 3 unmodified lines
871	f_ctrl ctrl, t_CKBOOL write, t_CKBOOL read );	919	f_ctrl ctrl, t_CKBOOL write, t_CKBOOL read );
872	t_CKBOOL type_engine_import_add_ex( Chuck_Env * env, const char * ex );	920	t_CKBOOL type_engine_import_add_ex( Chuck_Env * env, const char * ex );
873	t_CKBOOL type_engine_import_class_end( Chuck_Env * env );	921	t_CKBOOL type_engine_import_class_end( Chuck_Env * env );
874	t_CKBOOL type_engine_register_deprecate( Chuck_Env * env,	922	t_CKBOOL type_engine_register_deprecate( Chuck_Env * env,
875	const std::string & former, const std::string & latter );	923	const std::string & former, const std::string & latter );
876		924
877	// helpers	925
		926	//-----------------------------------------------------------------------------
		927	// helper functions
		928	//-----------------------------------------------------------------------------
878	t_CKBOOL type_engine_check_reserved( Chuck_Env * env, const std::string & xid, int pos );	929	t_CKBOOL type_engine_check_reserved( Chuck_Env * env, const std::string & xid, int pos );
879	t_CKBOOL type_engine_check_reserved( Chuck_Env * env, S_Symbol xid, int pos );	930	t_CKBOOL type_engine_check_reserved( Chuck_Env * env, S_Symbol xid, int pos );
880	// 1.4.1.0 (ge): abilty to toggle reserved words for special cases, such as Math.pi co-existing with pi (use with care!)	931	// 1.4.1.0 (ge): abilty to toggle reserved words for special cases, such as Math.pi co-existing with pi (use with care!)
@@ -883,17 +934,21 @@ t_CKBOOL type_engine_check_primitive( Chuck_Env * env, Chuck_Type * type ); · 2 unmodified lines
883	t_CKBOOL type_engine_check_const( Chuck_Env * env, a_Exp e, int pos ); // TODO	934	t_CKBOOL type_engine_check_const( Chuck_Env * env, a_Exp e, int pos ); // TODO
884	t_CKBOOL type_engine_compat_func( a_Func_Def lhs, a_Func_Def rhs, int pos, std::string & err, t_CKBOOL print = TRUE );	935	t_CKBOOL type_engine_compat_func( a_Func_Def lhs, a_Func_Def rhs, int pos, std::string & err, t_CKBOOL print = TRUE );
885	t_CKBOOL type_engine_get_deprecate( Chuck_Env * env, const std::string & from, std::string & to );	936	t_CKBOOL type_engine_get_deprecate( Chuck_Env * env, const std::string & from, std::string & to );
		937	t_CKBOOL type_engine_is_base_static( Chuck_Env * env, Chuck_Type * baseType ); // 1.5.0.0 (ge) added
886	Chuck_Type * type_engine_find_common_anc( Chuck_Type * lhs, Chuck_Type * rhs );	938	Chuck_Type * type_engine_find_common_anc( Chuck_Type * lhs, Chuck_Type * rhs );
887	Chuck_Type * type_engine_find_type( Chuck_Env * env, a_Id_List path );	939	Chuck_Type * type_engine_find_type( Chuck_Env * env, a_Id_List path );
		940	Chuck_Type * type_engine_find_type( Chuck_Env * env, const std::string & name ); // 1.5.0.0 (ge) added
888	Chuck_Value * type_engine_find_value( Chuck_Type * type, const std::string & xid );	941	Chuck_Value * type_engine_find_value( Chuck_Type * type, const std::string & xid );
889	Chuck_Value * type_engine_find_value( Chuck_Type * type, S_Symbol xid );	942	Chuck_Value * type_engine_find_value( Chuck_Type * type, S_Symbol xid );
890	Chuck_Value * type_engine_find_value( Chuck_Env * env, const std::string & xid, t_CKBOOL climb, int linepos = 0 );	943	Chuck_Value * type_engine_find_value( Chuck_Env * env, const std::string & xid, t_CKBOOL climb, int linepos = 0 );
891	Chuck_Namespace * type_engine_find_nspc( Chuck_Env * env, a_Id_List path );	944	Chuck_Namespace * type_engine_find_nspc( Chuck_Env * env, a_Id_List path );
892	/*******************************************************************************	945
893	* spencer: added this into function to provide the same logic path	946
894	* for type_engine_check_exp_decl() and ck_add_mvar() when they determine	947	//-----------------------------------------------------------------------------
895	* offsets for mvars -- added 1.3.0.0	948	// spencer: added this into function to provide the same logic path
896	******************************************************************************/	949	// for type_engine_check_exp_decl() and ck_add_mvar() when they determine
		950	// offsets for mvars -- added 1.3.0.0
		951	//-----------------------------------------------------------------------------
897	t_CKUINT type_engine_next_offset( t_CKUINT current_offset, Chuck_Type * type );	952	t_CKUINT type_engine_next_offset( t_CKUINT current_offset, Chuck_Type * type );
898	// array verify	953	// array verify
899	t_CKBOOL verify_array( a_Array_Sub array );	954	t_CKBOOL verify_array( a_Array_Sub array );
@@ -901,7 +956,14 @@ t_CKBOOL verify_array( a_Array_Sub array ); · 1 unmodified line
901	Chuck_Type * new_array_type( Chuck_Env * env, Chuck_Type * array_parent,	956	Chuck_Type * new_array_type( Chuck_Env * env, Chuck_Type * array_parent,
902	t_CKUINT depth, Chuck_Type * base_type,	957	t_CKUINT depth, Chuck_Type * base_type,
903	Chuck_Namespace * owner_nspc );	958	Chuck_Namespace * owner_nspc );
		959	// make type \| 1.4.1.1 (nshaheed) added
		960	Chuck_Type * new_array_element_type( Chuck_Env * env, Chuck_Type * base_type,
		961	t_CKUINT depth, Chuck_Namespace * owner_nspc);
		962
		963
		964	//-----------------------------------------------------------------------------
904	// conversion	965	// conversion
		966	//-----------------------------------------------------------------------------
905	const char * type_path( a_Id_List path );	967	const char * type_path( a_Id_List path );
906	a_Id_List str2list( const std::string & path );	968	a_Id_List str2list( const std::string & path );
907	a_Id_List str2list( const std::string & path, t_CKBOOL & is_array );	969	a_Id_List str2list( const std::string & path, t_CKBOOL & is_array );
@@ -909,7 +971,19 @@ const char * howmuch2str( te_HowMuch how_much ); · 1 unmodified line
909	t_CKBOOL escape_str( char * str_lit, int linepos );	971	t_CKBOOL escape_str( char * str_lit, int linepos );
910	t_CKINT str2char( const char * char_lit, int linepos );	972	t_CKINT str2char( const char * char_lit, int linepos );
911		973
		974
		975	//-----------------------------------------------------------------------------
		976	// more helper functions for type scan and checking \| 1.5.0.0 (ge) added
		977	//-----------------------------------------------------------------------------
		978	// compare two argument lists to see if they are the same (sequence of types)
		979	t_CKBOOL same_arg_lists( a_Arg_List lhs, a_Arg_List rhs );
		980	// generate a string from an argument list (types only)
		981	std::string arglist2string( a_Arg_List list );
		982
		983
		984	//-----------------------------------------------------------------------------
912	// REFACTOR-2017: exile! these default types now stored in env	985	// REFACTOR-2017: exile! these default types now stored in env
		986	//-----------------------------------------------------------------------------
913	//extern Chuck_Type t_void;	987	//extern Chuck_Type t_void;
914	//extern Chuck_Type t_int;	988	//extern Chuck_Type t_int;
915	//extern Chuck_Type t_float;	989	//extern Chuck_Type t_float;

chuginate/template/chuck/include/chuck_ugen.h+6−6

@@ -80,7 +80,7 @@ public: // src · 79 unmodified lines
80	t_CKBOOL alloc_v( t_CKUINT size );	80	t_CKBOOL alloc_v( t_CKUINT size );
81	t_CKBOOL set_is_buffered( t_CKBOOL buffered );	81	t_CKBOOL set_is_buffered( t_CKBOOL buffered );
82	void get_buffer( SAMPLE * buffer, t_CKINT num_elem );	82	void get_buffer( SAMPLE * buffer, t_CKINT num_elem );
83		83
84	Chuck_UGen *src_chan( t_CKUINT chan );	84	Chuck_UGen *src_chan( t_CKUINT chan );
85	Chuck_UGen *dst_for_src_chan( t_CKUINT chan );	85	Chuck_UGen *dst_for_src_chan( t_CKUINT chan );
86		86
@@ -133,17 +133,17 @@ public: // data · 46 unmodified lines
133	SAMPLE m_pan;	133	SAMPLE m_pan;
134	t_CKINT m_op;	134	t_CKINT m_op;
135	t_CKINT m_max_block_size;	135	t_CKINT m_max_block_size;
136		136
137	// SPENCERTODO: combine with block processing (added 1.3.0.0)	137	// SPENCERTODO: combine with block processing (added 1.3.0.0)
138	SAMPLE * m_multi_in_v;	138	SAMPLE * m_multi_in_v;
139	SAMPLE * m_multi_out_v;	139	SAMPLE * m_multi_out_v;
140		140
141	// SPENCERTODO: better way to handle this (added 1.3.0.0)	141	// SPENCERTODO: better way to handle this (added 1.3.0.0)
142	t_CKBOOL m_is_subgraph;	142	t_CKBOOL m_is_subgraph;
143	Chuck_UGen * m_inlet, * m_outlet;	143	Chuck_UGen * m_inlet, * m_outlet;
144	Chuck_UGen * inlet();	144	Chuck_UGen * inlet();
145	Chuck_UGen * outlet();	145	Chuck_UGen * outlet();
146		146
147	// block processing	147	// block processing
148	SAMPLE * m_sum_v;	148	SAMPLE * m_sum_v;
149	SAMPLE * m_current_v;	149	SAMPLE * m_current_v;
@@ -154,10 +154,10 @@ public: // data · 4 unmodified lines
154	Chuck_VM * vm;	154	Chuck_VM * vm;
155	// owner	155	// owner
156	Chuck_UGen * owner;	156	Chuck_UGen * owner;
157		157
158	// what a hack!	158	// what a hack!
159	t_CKBOOL m_is_uana;	159	t_CKBOOL m_is_uana;
160		160
161	// what a hack! (added some time after REFACTOR-2017)	161	// what a hack! (added some time after REFACTOR-2017)
162	t_CKBOOL m_is_buffered;	162	t_CKBOOL m_is_buffered;
163	AccumBuffer m_buffer;	163	AccumBuffer m_buffer;

chuginate/template/chuck/include/chuck_utils.h+1−1

@@ -49,7 +49,7 @@ struct U_boolList_ · 48 unmodified lines
49	};	49	};
50		50
51		51
52	void * checked_malloc( int size );	52	void * checked_malloc( t_CKINT size );
53	c_str cc_str( char * );	53	c_str cc_str( char * );
54	U_boolList U_BoolList( t_CKBOOL head, U_boolList tail );	54	U_boolList U_BoolList( t_CKBOOL head, U_boolList tail );
55		55

chuginate/template/chuck/include/chuck_vm.h+18−18

@@ -145,7 +145,7 @@ public: · 144 unmodified lines
145	t_CKUINT native_func;	145	t_CKUINT native_func;
146	// is ctor?	146	// is ctor?
147	t_CKUINT native_func_type;	147	t_CKUINT native_func_type;
148		148
149	// filename this code came from (added 1.3.0.0)	149	// filename this code came from (added 1.3.0.0)
150	std::string filename;	150	std::string filename;
151		151
@@ -169,17 +169,17 @@ public: · 17 unmodified lines
169	Chuck_VM_Shred( );	169	Chuck_VM_Shred( );
170	~Chuck_VM_Shred( );	170	~Chuck_VM_Shred( );
171		171
172	t_CKBOOL initialize( Chuck_VM_Code * c,	172	t_CKBOOL initialize( Chuck_VM_Code * c,
173	t_CKUINT mem_st_size = CVM_MEM_STACK_SIZE,	173	t_CKUINT mem_st_size = CVM_MEM_STACK_SIZE,
174	t_CKUINT reg_st_size = CVM_REG_STACK_SIZE );	174	t_CKUINT reg_st_size = CVM_REG_STACK_SIZE );
175	t_CKBOOL shutdown();	175	t_CKBOOL shutdown();
176	t_CKBOOL run( Chuck_VM * vm );	176	t_CKBOOL run( Chuck_VM * vm );
177	t_CKBOOL add( Chuck_UGen * ugen );	177	t_CKBOOL add( Chuck_UGen * ugen );
178	t_CKBOOL remove( Chuck_UGen * ugen );	178	t_CKBOOL remove( Chuck_UGen * ugen );
179		179
180	// add parent object reference (added 1.3.1.2)	180	// add parent object reference (added 1.3.1.2)
181	t_CKVOID add_parent_ref( Chuck_Object * obj );	181	t_CKVOID add_parent_ref( Chuck_Object * obj );
182		182
183	#ifndef __DISABLE_SERIAL__	183	#ifndef __DISABLE_SERIAL__
184	// HACK - spencer (added 1.3.2.0)	184	// HACK - spencer (added 1.3.2.0)
185	// add/remove SerialIO devices to close on shred exit	185	// add/remove SerialIO devices to close on shred exit
@@ -187,7 +187,7 @@ public: · 1 unmodified line
187	t_CKVOID add_serialio( Chuck_IO_Serial * serial );	187	t_CKVOID add_serialio( Chuck_IO_Serial * serial );
188	t_CKVOID remove_serialio( Chuck_IO_Serial * serial );	188	t_CKVOID remove_serialio( Chuck_IO_Serial * serial );
189	#endif	189	#endif
190		190
191	//-----------------------------------------------------------------------------	191	//-----------------------------------------------------------------------------
192	// data	192	// data
193	//-----------------------------------------------------------------------------	193	//-----------------------------------------------------------------------------
@@ -252,7 +252,7 @@ public: // ge: 1.3.5.3 · 58 unmodified lines
252	bool popLoopCounter();	252	bool popLoopCounter();
253	// loop counter pointer stack	253	// loop counter pointer stack
254	std::vector<t_CKUINT *> m_loopCounters;	254	std::vector<t_CKUINT *> m_loopCounters;
255		255
256	#ifndef __DISABLE_SERIAL__	256	#ifndef __DISABLE_SERIAL__
257	private:	257	private:
258	std::list<Chuck_IO_Serial > m_serials;	258	std::list<Chuck_IO_Serial > m_serials;
@@ -272,7 +272,7 @@ public: · 13 unmodified lines
272	t_CKUINT xid;	272	t_CKUINT xid;
273	std::string name;	273	std::string name;
274	t_CKTIME start;	274	t_CKTIME start;
275	t_CKBOOL has_event;	275	t_CKBOOL has_event;
276		276
277	public:	277	public:
278	Chuck_VM_Shred_Status( t_CKUINT _id, const std::string & n, t_CKTIME _start, t_CKBOOL e )	278	Chuck_VM_Shred_Status( t_CKUINT _id, const std::string & n, t_CKTIME _start, t_CKBOOL e )
@@ -297,7 +297,7 @@ public: · 18 unmodified lines
297	Chuck_VM_Status();	297	Chuck_VM_Status();
298	~Chuck_VM_Status();	298	~Chuck_VM_Status();
299	void clear();	299	void clear();
300		300
301	public:	301	public:
302	// sample rate	302	// sample rate
303	t_CKUINT srate;	303	t_CKUINT srate;
@@ -308,7 +308,7 @@ public: · 4 unmodified lines
308	t_CKUINT t_minute;	308	t_CKUINT t_minute;
309	t_CKUINT t_hour;	309	t_CKUINT t_hour;
310	// list of shred status	310	// list of shred status
311	std::vector<Chuck_VM_Shred_Status *> list;	311	std::vector<Chuck_VM_Shred_Status *> list;
312	};	312	};
313		313
314		314
@@ -374,10 +374,10 @@ public: · 59 unmodified lines
374	Chuck_UGen * m_bunghole;	374	Chuck_UGen * m_bunghole;
375	t_CKUINT m_num_dac_channels;	375	t_CKUINT m_num_dac_channels;
376	t_CKUINT m_num_adc_channels;	376	t_CKUINT m_num_adc_channels;
377		377
378	// status cache	378	// status cache
379	Chuck_VM_Status m_status;	379	Chuck_VM_Status m_status;
380		380
381	// max block size for adaptive block processing	381	// max block size for adaptive block processing
382	t_CKUINT m_max_block_size;	382	t_CKUINT m_max_block_size;
383	t_CKBOOL m_adaptive;	383	t_CKBOOL m_adaptive;
@@ -446,7 +446,7 @@ public: // running the machine · 62 unmodified lines
446	t_CKBOOL compute( );	446	t_CKBOOL compute( );
447	// abort current running shred	447	// abort current running shred
448	t_CKBOOL abort_current_shred( );	448	t_CKBOOL abort_current_shred( );
449		449
450	public: // invoke functions	450	public: // invoke functions
451	t_CKBOOL invoke_static( Chuck_VM_Shred * shred );	451	t_CKBOOL invoke_static( Chuck_VM_Shred * shred );
452		452
@@ -464,7 +464,7 @@ public: // msg · 11 unmodified lines
464	// added 1.3.0.0 to fix uber-crash	464	// added 1.3.0.0 to fix uber-crash
465	CBufferSimple * create_event_buffer();	465	CBufferSimple * create_event_buffer();
466	void destroy_event_buffer( CBufferSimple * buffer );	466	void destroy_event_buffer( CBufferSimple * buffer );
467		467
468	public: // get error	468	public: // get error
469	const char * last_error() const	469	const char * last_error() const
470	{ return m_last_error.c_str(); }	470	{ return m_last_error.c_str(); }
@@ -514,7 +514,7 @@ public: · 43 unmodified lines
514	Chuck_VM_Shred * spork( Chuck_VM_Shred * shred );	514	Chuck_VM_Shred * spork( Chuck_VM_Shred * shred );
515		515
516	protected:	516	protected:
517	t_CKBOOL free( Chuck_VM_Shred * shred, t_CKBOOL cascade,	517	t_CKBOOL free( Chuck_VM_Shred * shred, t_CKBOOL cascade,
518	t_CKBOOL dec = TRUE );	518	t_CKBOOL dec = TRUE );
519	void dump( Chuck_VM_Shred * shred );	519	void dump( Chuck_VM_Shred * shred );
520	void release_dump();	520	void release_dump();
@@ -536,7 +536,7 @@ protected: · 15 unmodified lines
536	CBufferSimple * m_msg_buffer;	536	CBufferSimple * m_msg_buffer;
537	CBufferSimple * m_reply_buffer;	537	CBufferSimple * m_reply_buffer;
538	CBufferSimple * m_event_buffer;	538	CBufferSimple * m_event_buffer;
539		539
540	// TODO: vector? (added 1.3.0.0 to fix uber-crash)	540	// TODO: vector? (added 1.3.0.0 to fix uber-crash)
541	std::list<CBufferSimple *> m_event_buffers;	541	std::list<CBufferSimple *> m_event_buffers;
542		542
@@ -597,10 +597,10 @@ struct Chuck_Msg · 54 unmodified lines
597		597
598	Chuck_Msg() : args(NULL) { clear(); }	598	Chuck_Msg() : args(NULL) { clear(); }
599	~Chuck_Msg() { SAFE_DELETE( args ); }	599	~Chuck_Msg() { SAFE_DELETE( args ); }
600		600
601	// added 1.3.0.0	601	// added 1.3.0.0
602	void clear() { SAFE_DELETE( args ); memset( this, 0, sizeof(*this) ); }	602	void clear() { SAFE_DELETE( args ); memset( this, 0, sizeof(*this) ); }
603		603
604	void set( const std::vector<std::string> & vargs )	604	void set( const std::vector<std::string> & vargs )
605	{	605	{
606	SAFE_DELETE(args);	606	SAFE_DELETE(args);

chuginate/template/chuck/include/chuck_win32.h+3−3

@@ -266,13 +266,13 @@ · 265 unmodified lines
266		266
267	#if ! defined YYSTYPE && ! defined YYSTYPE_IS_DECLARED	267	#if ! defined YYSTYPE && ! defined YYSTYPE_IS_DECLARED
268	typedef union YYSTYPE	268	typedef union YYSTYPE
269	#line 59 "chuck.y"	269	#line 65 "chuck.y"
270	{	270	{
271	int pos;	271	int pos;
272	int ival;	272	int ival;
273	double fval;	273	double fval;
274	c_str sval;	274	c_str sval;
275		275
276	a_Program program;	276	a_Program program;
277	a_Section program_section;	277	a_Section program_section;
278	a_Stmt_List stmt_list;	278	a_Stmt_List stmt_list;
@@ -294,7 +294,7 @@ typedef union YYSTYPE · 15 unmodified lines
294	}	294	}
295	/* Line 1529 of yacc.c. */	295	/* Line 1529 of yacc.c. */
296	#line 297 "chuck.tab.h"	296	#line 297 "chuck.tab.h"
297	YYSTYPE;	297	YYSTYPE;
298	# define yystype YYSTYPE /* obsolescent; will be withdrawn */	298	# define yystype YYSTYPE /* obsolescent; will be withdrawn */
299	# define YYSTYPE_IS_DECLARED 1	299	# define YYSTYPE_IS_DECLARED 1
300	# define YYSTYPE_IS_TRIVIAL 1	300	# define YYSTYPE_IS_TRIVIAL 1

chuginate/template/chuck/include/dirent_win32.h+37−37

@@ -1,8 +1,8 @@
1	/*	1	/*
2	* dirent.h - dirent API for Microsoft Visual Studio	2	* dirent.h - dirent API for Microsoft Visual Studio
3	*	3	*
4	* Copyright (C) 2006 Toni Ronkko	4	* Copyright (C) 2006 Toni Ronkko
5	*	5	*
6	* Permission is hereby granted, free of charge, to any person obtaining	6	* Permission is hereby granted, free of charge, to any person obtaining
7	* a copy of this software and associated documentation files (the	7	* a copy of this software and associated documentation files (the
8	* ``Software''), to deal in the Software without restriction, including	8	* ``Software''), to deal in the Software without restriction, including
@@ -10,10 +10,10 @@ · 1 unmodified line
10	* distribute, sublicense, and/or sell copies of the Software, and to	10	* distribute, sublicense, and/or sell copies of the Software, and to
11	* permit persons to whom the Software is furnished to do so, subject to	11	* permit persons to whom the Software is furnished to do so, subject to
12	* the following conditions:	12	* the following conditions:
13	*	13	*
14	* The above copyright notice and this permission notice shall be included	14	* The above copyright notice and this permission notice shall be included
15	* in all copies or substantial portions of the Software.	15	* in all copies or substantial portions of the Software.
16	*	16	*
17	* THE SOFTWARE IS PROVIDED ``AS IS'', WITHOUT WARRANTY OF ANY KIND, EXPRESS	17	* THE SOFTWARE IS PROVIDED ``AS IS'', WITHOUT WARRANTY OF ANY KIND, EXPRESS
18	* OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF	18	* OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
19	* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.	19	* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
@@ -33,13 +33,13 @@ · 13 unmodified lines
33	* Bug fix: due to the strncpy_s() function this file only compiled in	33	* Bug fix: due to the strncpy_s() function this file only compiled in
34	* Visual Studio 2005. Using the new string functions only when the	34	* Visual Studio 2005. Using the new string functions only when the
35	* compiler version allows.	35	* compiler version allows.
36	*	36	*
37	* Nov 2, 2006, Toni Ronkko	37	* Nov 2, 2006, Toni Ronkko
38	* Major update: removed support for Watcom C, MS-DOS and Turbo C to	38	* Major update: removed support for Watcom C, MS-DOS and Turbo C to
39	* simplify the file, updated the code to compile cleanly on Visual	39	* simplify the file, updated the code to compile cleanly on Visual
40	* Studio 2005 with both unicode and multi-byte character strings,	40	* Studio 2005 with both unicode and multi-byte character strings,
41	* removed rewinddir() as it had a bug.	41	* removed rewinddir() as it had a bug.
42	*	42	*
43	* Aug 20, 2006, Toni Ronkko	43	* Aug 20, 2006, Toni Ronkko
44	* Removed all remarks about MSVC 1.0, which is antiqued now. Simplified	44	* Removed all remarks about MSVC 1.0, which is antiqued now. Simplified
45	* comments by removing SGML tags.	45	* comments by removing SGML tags.
@@ -115,11 +115,11 @@ opendir( · 69 unmodified lines
115	dirp = (DIR*) malloc (sizeof (struct DIR));	115	dirp = (DIR*) malloc (sizeof (struct DIR));
116	if (dirp != NULL) {	116	if (dirp != NULL) {
117	char *p;	117	char *p;
118		118
119	/* take directory name... */	119	/* take directory name... */
120	STRNCPY (dirp->patt, dirname, sizeof(dirp->patt));	120	STRNCPY (dirp->patt, dirname, sizeof(dirp->patt));
121	dirp->patt[MAX_PATH] = '\0';	121	dirp->patt[MAX_PATH] = '\0';
122		122
123	/* ... and append search pattern to it */	123	/* ... and append search pattern to it */
124	p = strchr (dirp->patt, '\0');	124	p = strchr (dirp->patt, '\0');
125	if (dirp->patt < p && (p-1) != '\\' && (p-1) != ':') {	125	if (dirp->patt < p && (p-1) != '\\' && (p-1) != ':') {
@@ -138,42 +138,42 @@ opendir( · 12 unmodified lines
138		138
139	/* there is an un-processed directory entry in memory now */	139	/* there is an un-processed directory entry in memory now */
140	dirp->cached = 1;	140	dirp->cached = 1;
141		141
142	}	142	}
143	return dirp;	143	return dirp;
144	}	144	}
145		145
146		146
147	/*	147	/*
148	* ge: not a good idea	148	* ge: not a good idea
149	*/	149	*/
150	static void	150	static void
151	rewinddir(	151	rewinddir(
152	DIR *dirp)	152	DIR *dirp)
153	{	153	{
154	assert( dirp != NULL );	154	assert( dirp != NULL );
155		155
156	/* no cache */	156	/* no cache */
157	dirp->cached = 0;	157	dirp->cached = 0;
158		158
159	/* open stream and retrieve first file */	159	/* open stream and retrieve first file */
160	dirp->search_handle = FindFirstFileA (dirp->patt, &dirp->current.data);	160	dirp->search_handle = FindFirstFileA (dirp->patt, &dirp->current.data);
161	if (dirp->search_handle == INVALID_HANDLE_VALUE) {	161	if (dirp->search_handle == INVALID_HANDLE_VALUE) {
162	/* invalid search pattern? */	162	/* invalid search pattern? */
163	return;	163	return;
164	}	164	}
165		165
166	/* there is an un-processed directory entry in memory now */	166	/* there is an un-processed directory entry in memory now */
167	dirp->cached = 1;	167	dirp->cached = 1;
168	}	168	}
169		169
170		170
171	/*	171	/*
172	* Read a directory entry, and return a pointer to a dirent structure	172	* Read a directory entry, and return a pointer to a dirent structure
173	* containing the name of the entry in d_name field. Individual directory	173	* containing the name of the entry in d_name field. Individual directory
174	* entries returned by this very function include regular files,	174	* entries returned by this very function include regular files,
175	* sub-directories, pseudo-directories "." and "..", but also volume labels,	175	* sub-directories, pseudo-directories "." and "..", but also volume labels,
176	* hidden files and system files may be returned.	176	* hidden files and system files may be returned.
177	*/	177	*/
178	static struct dirent *	178	static struct dirent *
179	readdir(	179	readdir(
@@ -203,7 +203,7 @@ readdir( · 23 unmodified lines
203	/* copy as a multibyte character string */	203	/* copy as a multibyte character string */
204	STRNCPY (dirp->current.d_name, dirp->current.data.cFileName, sizeof(dirp->current.d_name));	204	STRNCPY (dirp->current.d_name, dirp->current.data.cFileName, sizeof(dirp->current.d_name));
205	dirp->current.d_name[MAX_PATH] = '\0';	205	dirp->current.d_name[MAX_PATH] = '\0';
206		206
207	return &dirp->current;	207	return &dirp->current;
208	}	208	}
209		209
@@ -218,7 +218,7 @@ closedir( · 8 unmodified lines
218	DIR *dirp)	218	DIR *dirp)
219	{	219	{
220	assert (dirp != NULL);	220	assert (dirp != NULL);
221		221
222	/* release search handle */	222	/* release search handle */
223	if (dirp->search_handle != INVALID_HANDLE_VALUE) {	223	if (dirp->search_handle != INVALID_HANDLE_VALUE) {
224	FindClose (dirp->search_handle);	224	FindClose (dirp->search_handle);

chuginate/template/chuck/include/hidio_sdl.h+4−4

@@ -63,7 +63,7 @@ public: · 62 unmodified lines
63	t_CKBOOL close();	63	t_CKBOOL close();
64	t_CKBOOL good() { return m_valid; }	64	t_CKBOOL good() { return m_valid; }
65	t_CKINT num() { return m_valid ? (t_CKINT)m_device_num : -1; }	65	t_CKINT num() { return m_valid ? (t_CKINT)m_device_num : -1; }
66		66
67	public:	67	public:
68	void set_suppress( t_CKBOOL print_or_not )	68	void set_suppress( t_CKBOOL print_or_not )
69	{ m_suppress_output = print_or_not; }	69	{ m_suppress_output = print_or_not; }
@@ -131,7 +131,7 @@ public: · 61 unmodified lines
131	static t_CKBOOL open( HidIn * hin, Chuck_VM * vm, t_CKINT device_type, std::string & device_name );	131	static t_CKBOOL open( HidIn * hin, Chuck_VM * vm, t_CKINT device_type, std::string & device_name );
132	static t_CKBOOL close( HidIn * hin );	132	static t_CKBOOL close( HidIn * hin );
133	static void cleanup_buffer( Chuck_VM * vm );	133	static void cleanup_buffer( Chuck_VM * vm );
134		134
135	static void probeHidIn();	135	static void probeHidIn();
136	static void probeHidOut();	136	static void probeHidOut();
137		137
@@ -142,9 +142,9 @@ public: · 4 unmodified lines
142	#endif	142	#endif
143		143
144	static void push_message( HidMsg & msg );	144	static void push_message( HidMsg & msg );
145		145
146	static std::map< Chuck_VM , CBufferSimple > m_event_buffers;	146	static std::map< Chuck_VM , CBufferSimple > m_event_buffers;
147		147
148	protected:	148	protected:
149	static std::vector< std::vector<PhyHidDevIn *> > the_matrix;	149	static std::vector< std::vector<PhyHidDevIn *> > the_matrix;
150	static XThread * the_thread;	150	static XThread * the_thread;

chuginate/template/chuck/include/midiio_rtmidi.h+46−46

@@ -92,7 +92,7 @@ public: · 91 unmodified lines
92	t_CKBOOL close();	92	t_CKBOOL close();
93	t_CKBOOL good() { return m_valid; }	93	t_CKBOOL good() { return m_valid; }
94	t_CKINT num() { return m_valid ? (t_CKINT)m_device_num : -1; }	94	t_CKINT num() { return m_valid ? (t_CKINT)m_device_num : -1; }
95		95
96	public:	96	public:
97	void set_suppress( t_CKBOOL print_or_not )	97	void set_suppress( t_CKBOOL print_or_not )
98	{ m_suppress_output = print_or_not; }	98	{ m_suppress_output = print_or_not; }
@@ -187,7 +187,7 @@ public: · 88 unmodified lines
187	protected:	187	protected:
188	MidiInManager();	188	MidiInManager();
189	~MidiInManager();	189	~MidiInManager();
190		190
191	static t_CKBOOL add_vm( Chuck_VM * vm, t_CKINT device_num, t_CKBOOL suppress_output );	191	static t_CKBOOL add_vm( Chuck_VM * vm, t_CKINT device_num, t_CKBOOL suppress_output );
192		192
193	static std::vector<RtMidiIn *> the_mins;	193	static std::vector<RtMidiIn *> the_mins;
@@ -333,7 +333,7 @@ struct MidiNoteEvent · 139 unmodified lines
333	MidiNoteEvent * simultaneous;	333	MidiNoteEvent * simultaneous;
334	// link to parent (could be self)	334	// link to parent (could be self)
335	MidiNoteEvent * parent;	335	MidiNoteEvent * parent;
336		336
337	// more data	337	// more data
338	double startTime;	338	double startTime;
339	double endTime;	339	double endTime;
@@ -341,12 +341,12 @@ struct MidiNoteEvent · 1 unmodified line
341	int bendAmount;	341	int bendAmount;
342	int programChange;	342	int programChange;
343	bool phrasemark;	343	bool phrasemark;
344		344
345	// constructor	345	// constructor
346	MidiNoteEvent() : data1(0), data2(0), data3(0), time(0.0), untilNext(0.0),	346	MidiNoteEvent() : data1(0), data2(0), data3(0), time(0.0), untilNext(0.0),
347	simultaneous(NULL), parent(NULL), startTime(0), endTime(0), shouldBend(false),	347	simultaneous(NULL), parent(NULL), startTime(0), endTime(0), shouldBend(false),
348	bendAmount(0), programChange(0), phrasemark(false) { }	348	bendAmount(0), programChange(0), phrasemark(false) { }
349		349
350	// type of message	350	// type of message
351	int type() const { return data1 & 0x70; }	351	int type() const { return data1 & 0x70; }
352	// channel	352	// channel
@@ -367,7 +367,7 @@ struct MidiLyricEvent · 14 unmodified lines
367	// time data	367	// time data
368	double time;	368	double time;
369	double endTime;	369	double endTime;
370		370
371	// constructor	371	// constructor
372	MidiLyricEvent() : time(0), endTime(0) { }	372	MidiLyricEvent() : time(0), endTime(0) { }
373	};	373	};
@@ -390,51 +390,51 @@ class MidiScoreReader · 16 unmodified lines
390	public:	390	public:
391	MidiScoreReader();	391	MidiScoreReader();
392	~MidiScoreReader();	392	~MidiScoreReader();
393		393
394	public:	394	public:
395	bool load( const char * filename, float velScale = 0.0f );	395	bool load( const char * filename, float velScale = 0.0f );
396	void cleanup();	396	void cleanup();
397		397
398	public:	398	public:
399	// rewind to beginning	399	// rewind to beginning
400	void rewind();	400	void rewind();
401	// get current top event (NO simultaneous)	401	// get current top event (NO simultaneous)
402	const MidiNoteEvent * getTopEvent( long track, long offset = 0 );	402	const MidiNoteEvent * getTopEvent( t_CKINT track, t_CKINT offset = 0 );
403	// get current event (YES simultaneous) + move to next	403	// get current event (YES simultaneous) + move to next
404	const MidiNoteEvent * scanEvent( long track, bool & isNewSet );	404	const MidiNoteEvent * scanEvent( t_CKINT track, bool & isNewSet );
405	// advance to next event	405	// advance to next event
406	bool seek( long track, long numToAdvance = 1 );	406	bool seek( t_CKINT track, t_CKINT numToAdvance = 1 );
407	// advance to next note on	407	// advance to next note on
408	bool seekToNoteOn( long track );	408	bool seekToNoteOn( t_CKINT track );
409	// get notes in a time window	409	// get notes in a time window
410	void getEvents( long track, double startTime, double endTime, std::vector<const MidiNoteEvent *> & result,	410	void getEvents( t_CKINT track, double startTime, double endTime, std::vector<const MidiNoteEvent *> & result,
411	bool includeSimultaneous = false );	411	bool includeSimultaneous = false );
412	// isDone	412	// isDone
413	bool isDone( long track, double currTime );	413	bool isDone( t_CKINT track, double currTime );
414		414
415		415
416	public:	416	public:
417	// get number of tracks	417	// get number of tracks
418	long getNumTracks() const;	418	t_CKINT getNumTracks() const;
419	// get number of events per track	419	// get number of events per track
420	long getNumEvents( long track ) const;	420	t_CKINT getNumEvents( t_CKINT track ) const;
421	// get number of tracks with more than 0 events	421	// get number of tracks with more than 0 events
422	long getNumTracksNonZero() const;	422	t_CKINT getNumTracksNonZero() const;
423	// get a vector of tracks indices that have more than 0 events	423	// get a vector of tracks indices that have more than 0 events
424	const std::vector<long> & getTracksNonZero() const;	424	const std::vector<t_CKINT> & getTracksNonZero() const;
425	// get BPM	425	// get BPM
426	double getBPM() const;	426	double getBPM() const;
427	// get an entire track's note events	427	// get an entire track's note events
428	const std::vector<MidiNoteEvent *> & getNoteEvents( long track );	428	const std::vector<MidiNoteEvent *> & getNoteEvents( t_CKINT track );
429	// get an entire track's lyric events	429	// get an entire track's lyric events
430	const std::vector<MidiLyricEvent *> & getLyricEvents( long track );	430	const std::vector<MidiLyricEvent *> & getLyricEvents( t_CKINT track );
431	// get count	431	// get count
432	long getCount( long track, const std::string & key );	432	t_CKINT getCount( t_CKINT track, const std::string & key );
433	// get lowest note for a track	433	// get lowest note for a track
434	long getLowestNote( long track, const MidiNoteEvent *start );	434	t_CKINT getLowestNote( t_CKINT track, const MidiNoteEvent *start );
435	// get highest note for a track	435	// get highest note for a track
436	long getHighestNote( long track, const MidiNoteEvent *start );	436	t_CKINT getHighestNote( t_CKINT track, const MidiNoteEvent *start );
437		437
438	public: // TODO: these may as well be a separate object	438	public: // TODO: these may as well be a separate object
439	// push a event to remember	439	// push a event to remember
440	void enqueue( const MidiNoteEvent * event );	440	void enqueue( const MidiNoteEvent * event );
@@ -444,26 +444,26 @@ public: // TODO: these may as well be a separate object · 3 unmodified lines
444	void dequeue();	444	void dequeue();
445	// push to front	445	// push to front
446	void enqueue_front( const MidiNoteEvent * event );	446	void enqueue_front( const MidiNoteEvent * event );
447		447
448	public: // track naming	448	public: // track naming
449	// sets track name	449	// sets track name
450	void setTrackName( long track, const std::string & name );	450	void setTrackName( t_CKINT track, const std::string & name );
451	// gets track name ("" if not present)	451	// gets track name ("" if not present)
452	std::string getTrackName( long track );	452	std::string getTrackName( t_CKINT track );
453	// gets the track with the given name (-1 if not present)	453	// gets the track with the given name (-1 if not present)
454	long getTrackForName( const std::string & name );	454	t_CKINT getTrackForName( const std::string & name );
455		455
456	protected: // for use while loading a track	456	protected: // for use while loading a track
457	// load a track	457	// load a track
458	bool loadTrack( long track, std::vector<MidiNoteEvent > & data, std::vector<MidiLyricEvent > & lyricData );	458	bool loadTrack( t_CKINT track, std::vector<MidiNoteEvent > & data, std::vector<MidiLyricEvent > & lyricData );
459	// apply control to existing event	459	// apply control to existing event
460	bool applyControl( long track, long data2, long data3, MidiNoteEvent * e );	460	bool applyControl( t_CKINT track, t_CKINT data2, t_CKINT data3, MidiNoteEvent * e );
461	// increment count for the given key (used for counting the number of notes, glissandi, etc)	461	// increment count for the given key (used for counting the number of notes, glissandi, etc)
462	void incrementCount( long track, const std::string & key );	462	void incrementCount( t_CKINT track, const std::string & key );
463	// handle note events, managing m_activeNotes and setting the event's endTime	463	// handle note events, managing m_activeNotes and setting the event's endTime
464	void handleNoteOn( MidiNoteEvent * e, long note );	464	void handleNoteOn( MidiNoteEvent * e, t_CKINT note );
465	void handleNoteOff( long note, double time );	465	void handleNoteOff( t_CKINT note, double time );
466		466
467	protected:	467	protected:
468	// midi	468	// midi
469	stk::MidiFileIn * m_midiFile;	469	stk::MidiFileIn * m_midiFile;
@@ -472,28 +472,28 @@ protected: · 2 unmodified lines
472	// vector of tracks of events	472	// vector of tracks of events
473	std::vector< std::vector<MidiLyricEvent *> > m_lyricEvents;	473	std::vector< std::vector<MidiLyricEvent *> > m_lyricEvents;
474	// vector of indices	474	// vector of indices
475	std::vector<unsigned long> m_indices;	475	std::vector<t_CKUINT> m_indices;
476	// stack of events	476	// stack of events
477	std::deque<const MidiNoteEvent *> m_queue;	477	std::deque<const MidiNoteEvent *> m_queue;
478	// vector of event	478	// vector of event
479	std::vector<const MidiNoteEvent *> m_result;	479	std::vector<const MidiNoteEvent *> m_result;
480	// search pointer	480	// search pointer
481	std::vector<unsigned long> m_searchIndices;	481	std::vector<t_CKUINT> m_searchIndices;
482	// count map	482	// count map
483	std::vector< std::map< std::string, long > > m_countMaps;	483	std::vector< std::map< std::string, t_CKINT > > m_countMaps;
484	// HACK: scale the velocity (0-1)	484	// HACK: scale the velocity (0-1)
485	float m_velocity_scale;	485	float m_velocity_scale;
486	// track names	486	// track names
487	std::map<std::string, long> m_nameToTrack;	487	std::map<std::string, t_CKINT> m_nameToTrack;
488	std::map<long, std::string> m_trackToName;	488	std::map<t_CKINT, std::string> m_trackToName;
489	// number of non-zero tracks	489	// number of non-zero tracks
490	long m_numNonZeroTracks;	490	t_CKINT m_numNonZeroTracks;
491	// vector of indices of non-zero tracks	491	// vector of indices of non-zero tracks
492	std::vector<long> m_nonZeroTrackIndices;	492	std::vector<t_CKINT> m_nonZeroTrackIndices;
493		493
494	private: // used during track loading	494	private: // used during track loading
495	// active notes, map from MIDI note to event	495	// active notes, map from MIDI note to event
496	std::map<long, MidiNoteEvent *> m_activeNotes;	496	std::map<t_CKINT, MidiNoteEvent *> m_activeNotes;
497	};	497	};
498		498
499		499

chuginate/template/chuck/include/rtmidi.h+10−10

chuginate/template/chuck/include/ugen_osc.h+2−2

@@ -66,11 +66,11 @@ CK_DLL_TICK( pulseosc_tick ); · 65 unmodified lines
66	// triosc	66	// triosc
67	CK_DLL_TICK( triosc_tick );	67	CK_DLL_TICK( triosc_tick );
68		68
69	// sawosc	69	// sawosc
70	CK_DLL_CTOR( sawosc_ctor );	70	CK_DLL_CTOR( sawosc_ctor );
71	CK_DLL_CTRL( sawosc_ctrl_width );	71	CK_DLL_CTRL( sawosc_ctrl_width );
72		72
73	// sqrosc	73	// sqrosc
74	CK_DLL_CTOR( sqrosc_ctor );	74	CK_DLL_CTOR( sqrosc_ctor );
75	CK_DLL_CTRL( sqrosc_ctrl_width );	75	CK_DLL_CTRL( sqrosc_ctrl_width );
76		76

chuginate/template/chuck/include/ugen_stk.h+141−143

 DLL_QUERY stk_query( Chuck_DL_Query * QUERY );
 t_CKBOOL  stk_detach( Chuck_Carrier * carrier );
 // this determines STK float type and de-denormal method
 #ifndef __STK_USE_SINGLE_PRECISION__
 #define MY_FLOAT double
 #define CK_STK_DDN CK_DDN_SINGLE
 #endif
+// 1.4.2.0 (ge) | added as part of switch to snprintf()
+#define STK_MSG_BUF_LENGTH 256
 // a "long double" in the future.
 //XXX sample is already defined in chuck_def.h!!!
 #if !defined(SAMPLE)
    typedef SAMPLE MY_FLOAT;
 #endif
 // The "MY_FLOAT" type will be deprecated in STK
 // versions higher than 4.1.2 and replaced with the variable
 // "StkFloat".
 //typedef double StkFloat;
-//#if defined(__WINDOWS_DS__) || defined(__WINDOWS_ASIO__)
+//#if defined(__PLATFORM_WIN32__) ||
 //  #pragma deprecated(MY_FLOAT)
 //#else
 //  typedef StkFloat MY_FLOAT __attribute__ ((deprecated));
 class StkError
 {
 public:
   enum TYPE {
     WARNING,
     DEBUG_WARNING,
     FUNCTION_ARGUMENT,
   };
 public: // SWAP formerly protected
-  char message[256];
+  char message[STK_MSG_BUF_LENGTH];
   TYPE type;
 public:
 #if defined(__WINDOWS_PTHREAD__)
   #define __OS_WINDOWS_CYGWIN__
   #define __STK_REALTIME__
-#elif defined(__WINDOWS_DS__) || defined(__WINDOWS_ASIO__)
+#elif defined(__PLATFORM_WIN32__)
   #define __OS_WINDOWS__
   #define __STK_REALTIME__
 #elif defined(__PLATFORM_LINUX__)
   //! Computer \e vectorSize outputs and return them in \e vector.
   virtual MY_FLOAT *tick(MY_FLOAT *vector, unsigned int vectorSize);
   //! Perform the control change specified by \e number and \e value (0.0 - 128.0).
   virtual void controlChange(int number, MY_FLOAT value);
 public: // SWAP formerly protected
+  MY_FLOAT lastOutput;
   // chuck
   t_CKFLOAT m_frequency;
-  MY_FLOAT lastOutput;
 };
     Alternatively, the delay and maximum length
     can be set during instantiation with an
     overloaded constructor.
     A non-interpolating delay line is typically
     used in fixed delay-length applications, such
     as for reverberation.
   DelayL();
   //! Overloaded constructor which specifies the current and maximum delay-line lengths.
   DelayL(MY_FLOAT theDelay, long maxDelay);
   //! Class destructor.
   //! Input one sample to the delay-line and return one output.
   MY_FLOAT tick(MY_FLOAT sample);
  public: // SWAP formerly protected
   MY_FLOAT alpha;
   MY_FLOAT omAlpha;
   MY_FLOAT nextOutput;
   //! Take \e vectorSize inputs and return the corresponding function values in \e vector.
   MY_FLOAT *tick(MY_FLOAT *vector, unsigned int vectorSize);
 public: // SWAP formerly protected
   MY_FLOAT offSet;
   MY_FLOAT slope;
   MY_FLOAT lastOutput;
     Percussion Instruments", Proceedings of the
     1999 International Computer Music Conference.
     Control Change Numbers:
        - Bow Pressure = 2
        - Bow Motion = 4
        - Strike Position = 8 (not implemented)
   void pluck(MY_FLOAT amp);
   //! Start a note with the given frequency and amplitude.
   void noteOn(MY_FLOAT amplitude) { noteOn ( freakency, amplitude ); }
   void noteOn(MY_FLOAT frequency, MY_FLOAT amplitude);
   //! Stop a note with the given amplitude (speed of decay).
     WvIn supports multi-channel data in interleaved
     format.  It is important to distinguish the
     tick() methods, which return samples produced
     by averaging across sample frames, from the
     tickFrame() methods, which return pointers to
     multi-channel sample frames.  For single-channel
     data, these methods return equivalent values.
   //! Normalize data to a maximum of \e +-peak.
   /*!
     For large, incrementally loaded files with integer data types,
     normalization is computed relative to the data type maximum
     (\e peak/maximum).  For incrementally loaded files with floating-
     point data types, direct scaling by \e peak is performed.
   */
   // Get MAT-file header information.
   bool getMatInfo( const char *fileName );
-  char msg[256];
+  char msg[STK_MSG_BUF_LENGTH];
-  // char m_filename[256]; // chuck data
+  // char m_filename[STK_MSG_BUF_LENGTH]; // chuck data
   Chuck_String str_filename; // chuck data
   FILE *fd;
   MY_FLOAT *data;
   WaveLoop( );
   //! Class constructor.
   WaveLoop( const char *fileName, bool raw = FALSE, bool generate = true );
   virtual void openFile( const char * fileName, bool raw = FALSE, bool n = TRUE );
   //! Class destructor.
     waves and envelopes, determined via a
     constructor argument.
     Control Change Numbers:
        - Control One = 2
        - Control Two = 4
        - LFO Speed = 11
   MY_FLOAT getFMTableSusLevel(int index); // programming settings
   // 1.4.1.0 (prc): *** END REPAIRATHON2021 BLOCK ***
   /****************************************/
   //! Set instrument parameters for a particular frequency.
   virtual void setFrequency(MY_FLOAT frequency);
   //! Perform the control change specified by \e number and \e value (0.0 - 128.0).
   virtual void controlChange(int number, MY_FLOAT value);
  public: // SWAP formerly protected
   ADSR     **adsr;
   WaveLoop **waves;
   WaveLoop *vibrato;
   TwoZero  *twozero;
   MY_FLOAT __FM_gains[100];
   MY_FLOAT __FM_susLevels[16];
   MY_FLOAT __FM_attTimes[32];
 };
 #endif
                      4 --
     \endcode
     Control Change Numbers:
        - Operator 4 (feedback) Gain = 2
        - Operator 3 Gain = 4
        - LFO Speed = 11
   //! Take \e vectorSize inputs and return the corresponding function values in \e vector.
   MY_FLOAT *tick(MY_FLOAT *vector, unsigned int vectorSize);
 public: // SWAP formerly protected
   MY_FLOAT lastOutput;
 };
   //! Return the last computed value.
   MY_FLOAT lastOut() const;
 public: // SWAP formerly protected
   MY_FLOAT lastOutput;
     (biquad filter) with a polynomial jet
     excitation (a la Cook).
     Control Change Numbers:
        - Noise Gain = 4
        - Vibrato Frequency = 11
        - Vibrato Gain = 1
   //! Perform the control change specified by \e number and \e value (0.0 - 128.0).
   void controlChange(int number, MY_FLOAT value);
  public: // SWAP formerly protected
   // chuck
   t_CKFLOAT m_rate;
   t_CKFLOAT m_noiseGain;
   t_CKFLOAT m_vibratoFreq;
   t_CKFLOAT m_vibratoGain;
   t_CKFLOAT m_volume;
   void setVibratoFreq(MY_FLOAT freq)
   { vibrato->setFrequency( freq ); m_vibratoFreq = vibrato->m_freq; }
   void setVibratoGain(MY_FLOAT gain)
   //! Take \e vectorSize inputs and return the corresponding function values in \e vector.
   MY_FLOAT *tick(MY_FLOAT *vector, unsigned int vectorSize);
 public: // SWAP formerly protected
   MY_FLOAT offSet;
   MY_FLOAT slope;
   MY_FLOAT lastOutput;
     use possibly subject to patents held by Stanford
     University, Yamaha, and others.
     Control Change Numbers:
        - Reed Stiffness = 2
        - Noise Gain = 4
        - Tonehole State = 11
   //! Perform the control change specified by \e number and \e value (0.0 - 128.0).
   void controlChange(int number, MY_FLOAT value);
  public: // SWAP formerly protected
   // CHUCK
   t_CKFLOAT m_reed;
     use possibly subject to patents held by
     Stanford University, Yamaha, and others.
     Control Change Numbers:
        - Bow Pressure = 2
        - Bow Position = 4
        - Vibrato Frequency = 11
   //! Decrease breath pressure with given rate of decrease.
   void stopBowing(MY_FLOAT rate);
   void noteOn(MY_FLOAT amplitude) { noteOn ( m_frequency, amplitude ); }
   //! Start a note with the given frequency and amplitude.
   void noteOn(MY_FLOAT frequency, MY_FLOAT amplitude);
   DelayA();
   //! Overloaded constructor which specifies the current and maximum delay-line lengths.
   DelayA(MY_FLOAT theDelay, long maxDelay);
   //! Class destructor.
   //! Input one sample to the delay-line and return one output.
   MY_FLOAT tick(MY_FLOAT sample);
 public: // SWAP formerly protected
   MY_FLOAT alpha;
   MY_FLOAT coeff;
   MY_FLOAT apInput;
     use possibly subject to patents held by
     Stanford University, Yamaha, and others.
     Control Change Numbers:
        - Lip Tension = 2
        - Slide Length = 4
        - Vibrato Frequency = 11
   //! Perform the control change specified by \e number and \e value (0.0 - 128.0).
   void controlChange(int number, MY_FLOAT value);
  public: // SWAP formerly protected
   // CHUCK
   t_CKFLOAT m_rate;
   //! Set modulation frequency.
   void setModFrequency(MY_FLOAT frequency);
   //! Set the mixture of input and processed levels in the output (0.0 = input only, 1.0 = processed only).
   void setEffectMix(MY_FLOAT mix);
   //! Return the last output value.
   //! Take \e vectorSize inputs, compute the same number of outputs and return them in \e vector.
   MY_FLOAT *tick(MY_FLOAT *vector, unsigned int vectorSize);
  public: // SWAP formerly protected
   DelayL *delayLine[2];
   WaveLoop *mods[2];
   MY_FLOAT baseLength;
     use possibly subject to patents held by Stanford
     University, Yamaha, and others.
     Control Change Numbers:
        - Reed Stiffness = 2
        - Noise Gain = 4
        - Vibrato Frequency = 11
   //! Compute one output sample.
   MY_FLOAT tick();
  public: // SWAP formerly protected
   WvIn    *waves[DRUM_POLYPHONY];
   OnePole *filters[DRUM_POLYPHONY];
   int      sounding[DRUM_POLYPHONY];
   void set(MY_FLOAT max);
   MY_FLOAT getDelay();
   //! Set the mixture of input and processed levels in the output (0.0 = input only, 1.0 = processed only).
   void setEffectMix(MY_FLOAT mix);
   //! Return the last output value.
                         \->3 -/
     \endcode
     Control Change Numbers:
        - Vowel = 2
        - Spectral Tilt = 4
        - LFO Speed = 11
     use possibly subject to patents held by Stanford
     University, Yamaha, and others.
     Control Change Numbers:
        - Jet Delay = 2
        - Noise Gain = 4
        - Vibrato Frequency = 11
   t_CKFLOAT m_vibratoGain;
   t_CKFLOAT m_pressure;
   t_CKFLOAT m_rate;
   void setVibratoFreq(MY_FLOAT freq)
   { vibrato->setFrequency( freq ); m_vibratoFreq = vibrato->m_freq; }
   void setVibratoGain(MY_FLOAT gain)
   { vibratoGain = gain; m_vibratoGain = vibratoGain; }
   void setNoiseGain(MY_FLOAT gain)
   { noiseGain = gain; m_noiseGain = gain; }
   DelayL *jetDelay;
   DelayL *boreDelay;
   JetTabl *jetTable;
     A sweep rate of 1.0 will produce an immediate change in
     resonance parameters from their current values to the
     target values.  A sweep rate of 0.0 will produce no
     change in resonance parameters.
   */
   void setSweepRate(MY_FLOAT aRate);
   //! Input \e vectorSize samples to the filter and return an equal number of outputs in \e vector.
   MY_FLOAT *tick(MY_FLOAT *vector, unsigned int vectorSize);
  public: // SWAP formerly protected
   bool dirty;
   MY_FLOAT frequency;
   MY_FLOAT radius;
                     3-->2-- + -->1-->Out
     \endcode
     Control Change Numbers:
        - Total Modulator Index = 2
        - Modulator Crossfade = 4
        - LFO Speed = 11
 /***************************************************/
 /*! \class HnkyTonk
  \brief STK Honkey Tonk Piano FM synthesis instrument.
  This class implements 4 cascade operators with
  feedback modulation on the master modulator,
  also referred to as algorithm 1 of the TX81Z.
  Algorithm 1 is :
  4-->3-->2-->1-->Out
  Control Change Numbers:
  - Total Modulator Index = 2
  - Modulator Crossfade = 4
  - LFO Speed = 11
  - LFO Depth = 1
  - ADSR 2 & 4 Target = 128
  The basic Chowning/Stanford FM patent expired
  in 1995, but there exist follow-on patents,
  mostly assigned to Yamaha.  If you are of the
  type who should worry about this (making
  money) worry away.
  by Perry R. Cook, 2021.
  */
 /***************************************************/
 public:
     //! Class constructor.
     HnkyTonk();
     //! Class destructor.
     ~HnkyTonk();
     //! Start a note with the given frequency and amplitude.
     void noteOn(MY_FLOAT frequency, MY_FLOAT amplitude);
     void noteOn( MY_FLOAT amplitude) { noteOn(baseFrequency, amplitude); }
     //! Compute one output sample.
     MY_FLOAT tick();
 };
 /***************************************************/
 /*! \class FrencHrn
  \brief NEW STK-style French Horn FM synthesis instrument.
  This class implements 3 cascade operators with
  feedback modulation, also referred to as
  algorithm 3 of the TX81Z.
  Algorithm 3 is :     4--\
  3-->2-- + -->1-->Out
  Control Change Numbers:
  - Total Modulator Index = 2
  - Modulator Crossfade = 4
  - LFO Speed = 11
  - LFO Depth = 1
  - ADSR 2 & 4 Target = 128
  The basic Chowning/Stanford FM patent expired
  in 1995, but there exist follow-on patents,
  mostly assigned to Yamaha.  If you are of the
  type who should worry about this (making
  money) worry away.
  by Perry R. Cook, 2021.
  */
 /***************************************************/
 public:
     //! Class constructor.
     FrencHrn();
     //! Class destructor.
     ~FrencHrn();
     //! Start a note with the given frequency and amplitude.
     void noteOn(MY_FLOAT frequency, MY_FLOAT amplitude);
     void noteOn( MY_FLOAT amplitude) { noteOn(baseFrequency, amplitude); }
     //! Compute one output sample.
     MY_FLOAT tick();
 };
 /***************************************************/
 /*! \class KrstlChr
  \brief New STK-style Crystal Choir FM synthesis instrument.
  This class implements 3 parallel operators with
  one modulated, by one with feedback modulation,
  also referred to as algorithm 7 of the TX81Z.
  Algorithm 3 is :     4-->3-->\
  2--> + -->Out
  1-->/
  Control Change Numbers:
  - Total Modulator Index = 2
  - Modulator Crossfade = 4
  - LFO Speed = 11
  - LFO Depth = 1
  - ADSR 2 & 4 Target = 128
  The basic Chowning/Stanford FM patent expired
  in 1995, but there exist follow-on patents,
  mostly assigned to Yamaha.  If you are of the
  type who should worry about this (making
  money) worry away.
  by Perry R. Cook, 2021.
  */
 /***************************************************/
 public:
     //! Class constructor.
     KrstlChr();
     //! Class destructor.
     ~KrstlChr();
     //! Start a note with the given frequency and amplitude.
     void noteOn(MY_FLOAT frequency, MY_FLOAT amplitude);
     void noteOn( MY_FLOAT amplitude) { noteOn(baseFrequency, amplitude); }
     //! Compute one output sample.
     MY_FLOAT tick();
 };
   //! Reset and clear all internal state.
   virtual void clear() = 0;
   //! Set the mixture of input and "reverberated" levels in the output (0.0 = input only, 1.0 = reverb only).
   void setEffectMix(MY_FLOAT mix);
   //! Return the last output value.
   //! Virtual (abstract) tick function is implemented by subclasses.
   virtual MY_FLOAT tick() = 0;
   public: // SWAP formerly protected
     DelayA *delayLine;
     DelayA *delayLine2;
     DelayL *combDelay;
     information, contact the Office of Technology
     Licensing, Stanford University.
     Control Change Numbers:
        - Body Size = 2
        - Pluck Position = 4
        - String Sustain = 11
   //! Perform the control change specified by \e number and \e value (0.0 - 128.0).
   virtual void controlChange(int number, MY_FLOAT value);
   public: // SWAP formerly protected
     WvIn *soundfile[12];
     MY_FLOAT directBody;
     int mic;
     use possibly subject to patents held by Stanford
     University, Yamaha, and others.
     Control Change Numbers:
        - X Dimension = 2
        - Y Dimension = 4
        - Mesh Decay = 11
   ~Mesh2D();
   //! Reset and clear all internal state.
   void clear();
   //! Set the x dimension size in samples.
   void setNX(short lenX);
   t_CKFLOAT m_vibratoFreq;
   t_CKFLOAT m_volume;
   Envelope *envelope;
   WvIn     *wave;
   BiQuad   **filters;
   OnePole  *onepole;
     struck bar instruments.  It inherits from the
     Modal class.
     Control Change Numbers:
        - Stick Hardness = 2
        - Stick Position = 4
        - Vibrato Gain = 11
   //! Return a sub-sampled random number between -1.0 and 1.0.
   MY_FLOAT tick();
  public: // SWAP formerly protected
   int counter;
   int rate;
   //! Perform the control change specified by \e number and \e value (0.0 - 128.0).
   virtual void controlChange(int number, MY_FLOAT value) = 0;
  public: // SWAP formerly protected
   ADSR     *adsr;
   WvIn     *attacks[5];
   WaveLoop *loops[5];
   OnePole  *filter;
     from the Sampler class) and adds two sweepable
     formant (FormSwep) filters.
     Control Change Numbers:
        - Filter Q = 2
        - Filter Sweep Rate = 4
        - Vibrato Frequency = 11
   //! Compute one output sample.
   MY_FLOAT tick(MY_FLOAT input);
  public: // SWAP formerly protected
   Delay *allpassDelays[8];
   Delay *combDelays[6];
   MY_FLOAT allpassCoefficient;
   //! Compute one output sample.
   MY_FLOAT tick(MY_FLOAT input);
 public: // SWAP formerly protected
   Delay *allpassDelays[2];
   Delay *combDelays[2];
   MY_FLOAT allpassCoefficient;
                           2-- + -->1-->Out
     \endcode
     Control Change Numbers:
        - Total Modulator Index = 2
        - Modulator Crossfade = 4
        - LFO Speed = 11
   //! Set the pitch shift factor (1.0 produces no shift).
   void setShift(MY_FLOAT shift);
   //! Set the mixture of input and processed levels in the output (0.0 = input only, 1.0 = processed only).
   void setEffectMix(MY_FLOAT mix);
   //! Return the last output value.
   //! Input \e vectorSize samples to the filter and return an equal number of outputs in \e vector.
   MY_FLOAT *tick(MY_FLOAT *vector, unsigned int vectorSize);
  public: // SWAP formerly protected
   //chuck
   t_CKFLOAT m_vibratoGain;
   t_CKFLOAT m_vibratoFreq;
   //! Compute one output sample.
   virtual MY_FLOAT tick();
  public: // SWAP formerly protected
   DelayA *delayLine;
   OneZero *loopFilter;
   OnePole *pickFilter;
   //! Perform the control change specified by \e number and \e value (0.0 - 128.0).
   virtual void controlChange(int number, MY_FLOAT value);
  public: // SWAP formerly protected
   ADSR     *adsr;
   BiQuad   *filter;
   Noise    *noise;
                       2->1--/
     \endcode
     Control Change Numbers:
        - Modulator Index One = 2
        - Crossfade of Outputs = 4
        - LFO Speed = 11
   //! Start a note with the given frequency and amplitude.
   void noteOn(MY_FLOAT frequency, MY_FLOAT amplitude);
   void noteOn(MY_FLOAT amplitude) { noteOn(baseFrequency * 0.5, amplitude ); }
   //! Compute one output sample.
   MY_FLOAT tick();
     use possibly subject to patents held by Stanford
     University, Yamaha, and others.
     Control Change Numbers:
        - Reed Stiffness = 2
        - Reed Aperture = 26
        - Noise Gain = 4
     breaking sticks, crunchy snow (or not), a
     wrench, sandpaper, and more.
     Control Change Numbers:
       - Shake Energy = 2
       - System Decay = 4
       - Number Of Objects = 11
     Use the instrument numbers above, converted to frequency values
     as if MIDI note numbers, to select a particular instrument.
   */
   virtual void ck_noteOn(MY_FLOAT amplitude ); // chuck single arg call
   virtual void noteOn(MY_FLOAT instrument, MY_FLOAT amplitude);
   //! Stop a note with the given amplitude (speed of decay).
     a one-pole filter, and an ADSR envelope
     to create some interesting sounds.
     Control Change Numbers:
        - Filter Pole Position = 2
        - Noise/Pitched Cross-Fade = 4
        - Envelope Rate = 11
   //! Perform the control change specified by \e number and \e value (0.0 - 128.0).
   virtual void controlChange(int number, MY_FLOAT value);
  public: // SWAP formerly protected
   ADSR     *adsr;
   WaveLoop  *loop;
   OnePole  *filter;
   BiQuad   *biquad;
   //! Compute one output sample.
   MY_FLOAT tick();
  public: // SWAP formerly protected
   DelayA *delayLine;
   OneZero *loopFilter;
   Noise *noise;
     The user is responsible for checking the values
     returned by the read/write methods.  Values
     less than or equal to zero indicate a closed
-    or lost connection or the occurence of an error.
+    or lost connection or the occurrence of an error.
     by Perry R. Cook and Gary P. Scavone, 1995 - 2002.
 */
  public: // SWAP formerly protected
-  char msg[256];
+  char msg[STK_MSG_BUF_LENGTH];
   int soket;
   int poort;
   bool server;
   //! Move the sphere for the given time increment.
   void tick(double timeIncrement);
 public: // SWAP formerly private
   Vector3D *myPosition;
   Vector3D *myVelocity;
   //! Take \e vectorSize index positions and return the corresponding table values in \e vector.
   MY_FLOAT *tick(MY_FLOAT *vector, unsigned int vectorSize);
 public: // SWAP formerly protected
   long length;
   MY_FLOAT *data;
   MY_FLOAT lastOutput;
     int fflush(FILE *stream);
     int fclose(FILE *stream);
     size_t fread(void *ptr, size_t size, size_t nitems, FILE *stream);
   //! Default constructor.
   WvOut();
   // Close MAT-file, updating the header.
   void closeMatFile( void );
-  char msg[256];
+  char msg[STK_MSG_BUF_LENGTH];
   FILE *fd;
   MY_FLOAT *data;
   FILE_TYPE fileType;
   Chuck_String autoPrefix;
   t_CKUINT flush;
   t_CKFLOAT fileGain;
   // spencer: for data asynch write
   t_CKBOOL asyncIO;
   XWriteThread * asyncWriteThread;
                       2->1--/
     \endcode
     Control Change Numbers:
        - Modulator Index One = 2
        - Crossfade of Outputs = 4
        - LFO Speed = 11
   MY_FLOAT m_resFreq;
   MY_FLOAT m_resRad;
   void ck_setResNorm( bool n ) { m_resNorm = n; setResonance(m_resFreq, m_resRad, m_resNorm); }
   void ck_setResFreq( MY_FLOAT n ) { m_resFreq = n; setResonance(m_resFreq, m_resRad, m_resNorm); }
   void ck_setResRad( MY_FLOAT n ) { m_resRad = n; setResonance(m_resFreq, m_resRad, m_resNorm); }
   //! Set the filter gain.
   /*!
     The gain is applied at the filter input and does not affect the
     cascade synthesis is the most natural so
     that's what you'll find here.
     Control Change Numbers:
        - Voiced/Unvoiced Mix = 2
        - Vowel/Phoneme Selection = 4
        - Vibrato Frequency = 11
     This class implements a hybrid physical/spectral
     model of a police whistle (a la Cook).
     Control Change Numbers:
        - Noise Gain = 4
        - Fipple Modulation Frequency = 11
        - Fipple Modulation Gain = 1
   //! Perform the control change specified by \e number and \e value (0.0 - 128.0).
   void controlChange(int number, MY_FLOAT value);
 public: // SWAP formerly protected
     Vector3D *tempVectorP;
   Vector3D *tempVector;
   OnePole onepole;
                       2->1--/
     \endcode
     Control Change Numbers:
        - Modulator Index One = 2
        - Crossfade of Outputs = 4
        - LFO Speed = 11
   //! Start a note with the given frequency and amplitude.
   void noteOn(MY_FLOAT frequency, MY_FLOAT amplitude);
   void noteOn(MY_FLOAT amplitude) { noteOn ( baseFrequency, amplitude ); }
   // CHUCK HACK:
   virtual void controlChange( int which, MY_FLOAT value );
     Set the phase of the signal, in the range 0 to 1.
   */
   virtual void setPhase( MY_FLOAT phase ) { phase_ = ONE_PI * phase; }
   //! Set the sawtooth oscillator rate in terms of a frequency in Hz.
   virtual void setFrequency( MY_FLOAT frequency );
 #include <sstream>
 namespace stk {
 /**********************************************************************/
 /*! \class MidiFileIn
  \brief A standard MIDI file reading/parsing class.
  This class can be used to read events from a standard MIDI file.
  Event bytes are copied to a C++ vector and must be subsequently
  interpreted by the user.  The function getNextMidiEvent() skips
  function is provided to determine the current "seconds per tick".
  Tempo changes are internally tracked by the class and reflected in
  the values returned by the function getTickSeconds().
  by Gary P. Scavone, 2003 - 2010.
  */
 /**********************************************************************/
      StkError exception will be thrown.
      */
     MidiFileIn( std::string fileName );
     //! Class destructor.
     ~MidiFileIn();
     //! Return the MIDI file format (0, 1, or 2).
     int getFileFormat() const;
     //! Return the number of tracks in the MIDI file.
     unsigned int getNumberOfTracks() const;
     //! Return the MIDI file division value from the file header.
     /*!
      Note that this value must be "parsed" in accordance with the
      file uses time-code representations for delta-time values.
      */
     int getDivision() const;
     //! Move the specified track event reader to the beginning of its track.
     /*!
      The relevant track tempo value is reset as well.  If an invalid
      track number is specified, an StkError exception will be thrown.
      */
     void rewindTrack( unsigned int track = 0 );
     //! Get the current value, in seconds, of delta-time ticks for the specified track.
     /*!
      This value can change as events are read (via "Set Tempo"
      thrown.
      */
     double getTickSeconds( unsigned int track = 0 );
     //! Fill the user-provided vector with the next event in the specified track and return the event delta-time in ticks.
     /*!
      MIDI File events consist of a delta time and a sequence of event
      file, an StkError exception will be thrown.
      */
     unsigned long getNextEvent( std::vector<unsigned char> *event, unsigned int track = 0 );
     //! Fill the user-provided vector with the next MIDI channel event in the specified track and return the event delta time in ticks.
     /*!
      All returned MIDI events are complete ... a status byte is
      StkError exception will be thrown.
      */
     unsigned long getNextMidiEvent( std::vector<unsigned char> *midiEvent, unsigned int track = 0 );
     //! ge: get the current BPM (I think)
     /*!
      This value can change as events are read... hmm pretty much
      what it says above for getTickSeconds()
      */
     double getBPM();
 protected:
     // This protected class function is used for reading variable-length
     // MIDI file values. It is assumed that this function is called with
     // the file read pointer positioned at the start of a
     // variable-length value.  The function returns true if the value is
     // successfully parsed.  Otherwise, it returns false.
     bool readVariableLength( unsigned long *value );
     std::ifstream file_;
     unsigned int nTracks_;
     int format_;
     std::vector<char> trackStatus_;
     // ge:
     double bpm_;
     // This structure and the following variables are used to save and
     // keep track of a format 1 tempo map (and the initial tickSeconds
     // parameter for formats 0 and 2).
     struct TempoChange {
         unsigned long count;
         double tickSeconds;
     };
     std::vector<unsigned long> trackCounters_;
     std::vector<unsigned int> trackTempoIndex_;
 };
 } // stk namespace
 #endif
 #define __SK_Pan_                    10
 #define __SK_Sustain_                64
 #define __SK_Damper_                 __SK_Sustain_
 #define __SK_Expression_             11
 #define __SK_AfterTouch_Cont_        128
 #define __SK_ModFrequency_           __SK_Expression_
 #define __SK_FilterFreq_             1062
 #define __SK_FilterSweepRate_        __SK_FootControl_
 #define __SK_ShakerInst_             1071
 #define __SK_ShakerEnergy_           __SK_Breath_
 #define __SK_ShakerDamping_          __SK_ModFrequency_
 #define __SK_ShakerNumObjects_       __SK_FootControl_

chuginate/template/chuck/include/ulib_ai.h+377−0

@@ -0,0 +1,377 @@
	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.stanford.edu/
	7	http://chuck.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	// file: ulib_ai.h
	27	// desc: Music and AI class library; part of ChAI (ChucK for AI)
	28	//
	29	// date: Fall 2022 -- present
	30	// authors: Ge Wang (ge@ccrma.stanford.edu)
	31	// Yikai Li (yikaili@stanford.edu)
	32	//
	33	// (HISTORICAL NOTE)
	34	// Much of ChAI and its ways of thinking and doing can be foundationally
	35	// attributed to the work of Dr. Rebecca Fiebrink, her landmark Ph.D. Thesis,
	36	// /Real-time Human Interaction With Supervised Learning Algorithms for Music
	37	// Composition and Performance/ (2011) [1], the Wekinator framework [2], her
	38	// teaching at the intersections of AI, HCI, and Music [3], as well as earlier
	39	// collaborations between Rebecca and Ge [4,5] including SMIRK [6] (Small Musical
	40	// Information Retrieval toolKit; 2008; MARSYAS and the MIR work of Dr. George
	41	// Tzanetakis; early efforts in on-the-fly learning), the unit analyzer
	42	// framework [7] (2007; afford real-time audio feature extraction). All of
	43	// these have directly or indirectly contributed the creation of ChAI.
	44	// Additionally, ChAI benefitted from the teaching and design philosophy of
	45	// Dr. Perry R. Cook (Ph.D. advisor to Rebecca, George, and Ge at Princeton,
	46	// and ChucK co-author), who argued for real-time human interaction, parametric
	47	// sound synthesis, and the importance of play in the design of musical tools.
	48	//
	49	// [1] Fiebrink, Rebecca. 2011. /Real-time Human Interaction With Supervised
	50	// Learning Algorithms for Music Composition and Performance/ Ph.D. Thesis.
	51	// Princeton University. https://www.cs.princeton.edu/techreports/2010/891.pdf
	52	//
	53	// [2] http://www.wekinator.org/
	54	// Wekinator \| Software for real-time, interactive machine learning
	55	//
	56	// [3] Fiebrink, Rebecca. "Machine Learning for Musicians and Artists" MOOC
	57	// https://www.kadenze.com/courses/machine-learning-for-musicians-and-artists/info
	58	//
	59	// [4] Fiebrink, R., G. Wang, P. R. Cook. 2008. "Foundations for On-the-fly
	60	// Learning in the ChucK Programming Language." /International Computer Music
	61	// Conference/. https://mcd.stanford.edu/publish/files/2008-icmc-learning.pdf
	62	//
	63	// [5] Fiebrink, R., G. Wang, P. R. Cook. 2008. "Support for Music Information
	64	// Retrieval in the ChucK Programming Language." /International Conference
	65	// on Music Information Retrieval/ (ISMIR).
	66	// https://mcd.stanford.edu/publish/files/2008-ismir-proto.pdf
	67	//
	68	// [6] http://smirk.cs.princeton.edu/
	69	// sMIRk \| Small Music Information Retrieval toolKit
	70	//
	71	// [7] Tzanetakis, G. and P. R. Cook. 2000 "MARSYAS: A Framework for Audio
	72	// Analysis." Organised Sound. 4:(3)
	73	//
	74	// [8] Tzanetakis, G. and P. R. Cook. 2002 "Musical Genre Classification of
	75	// Audio Signals." IEEE Transaction on Speech and Audio Processing. 10(5).
	76	//
	77	// [9] Wang, G., R. Fiebrink, P. R. Cook. 2007. "Combining Analysis and
	78	// Synthesis in the ChucK Programming Language." /International Computer
	79	// Music Conference/. https://mcd.stanford.edu/publish/files/2007-icmc-uana.pdf
	80	//-----------------------------------------------------------------------------
	81	#ifndef __ULIB_AI_H__
	82	#define __ULIB_AI_H__
	83
	84	#include "chuck_dl.h"
	85	#include "chuck_errmsg.h"
	86	#include "util_math.h"
	87
	88
	89
	90
	91	// query
	92	DLL_QUERY libai_query( Chuck_DL_Query * QUERY );
	93
	94	//-----------------------------------------------------------------------------
	95	// name: class ChaiMatrixFast \| 1.4.2.0 (ge) added
	96	// desc: a templated fast access but not bound-checked 2D matrix
	97	// allows arbitrary 2D arrays of arbitrary and non-constant dimensions
	98	// to be allocated locally, e.g., int matrix[xDim][yDim] -- which is not
	99	// valid syntax with some compilers.
	100	//-----------------------------------------------------------------------------
	101	template<class T>
	102	class ChaiMatrixFast
	103	{
	104	public:
	105	ChaiMatrixFast()
	106	{
	107	// zero out
	108	m_matrix = NULL;
	109	// zero out
	110	m_xDim = m_yDim = 0;
	111	}
	112
	113	ChaiMatrixFast( t_CKINT xDim, t_CKINT yDim )
	114	{
	115	// zero out
	116	m_matrix = NULL;
	117	// allocate
	118	allocate( xDim, yDim );
	119	}
	120
	121	~ChaiMatrixFast()
	122	{
	123	// deallocate
	124	cleanup();
	125	}
	126
	127	t_CKBOOL allocate( t_CKINT xDim, t_CKINT yDim )
	128	{
	129	// delete if necessary
	130	if( m_matrix != NULL ) cleanup();
	131
	132	// allocate
	133	m_matrix = new T[xDim * yDim];
	134	// check
	135	if( !m_matrix )
	136	{
	137	// error
	138	CK_FPRINTF_STDERR( "[chuck]: ChaiMatrixFast allocation failure: %s, %d x %d...\n",
	139	typeid( T ).name(), xDim, yDim );
	140	// bail
	141	return FALSE;
	142	}
	143	// remember
	144	m_xDim = xDim;
	145	m_yDim = yDim;
	146
	147	// done
	148	return TRUE;
	149	}
	150
	151	// get element value
	152	T & v( t_CKINT x, t_CKINT y )
	153	{
	154	// at least do a check
	155	if( x < 0 \|\| x >= m_xDim \|\| y < 0 \|\| y >= m_yDim )
	156	{
	157	// error
	158	CK_FPRINTF_STDERR( "[chuck]: ChaiMatrixFast out of bound: %s[%d][%d]...\n",
	159	typeid( T ).name(), x, y );
	160	// halt
	161	// TODO: this should throw (a shred-level, probably) exception
	162	assert( FALSE );
	163	}
	164
	165	return m_matrix[x * m_yDim + y];
	166	}
	167
	168	// overloaded operator
	169	T & operator()( t_CKINT x, t_CKINT y )
	170	{
	171	return v( x, y );
	172	}
	173
	174	// get dimensions
	175	t_CKINT xDim() const
	176	{ return m_xDim; }
	177	t_CKINT yDim() const
	178	{ return m_yDim; }
	179
	180	void cleanup()
	181	{
	182	// reclaim array memory and zero the pointer
	183	SAFE_DELETE_ARRAY( m_matrix );
	184	// zero out
	185	m_xDim = m_yDim = 0;
	186	}
	187
	188	protected:
	189	T * m_matrix;
	190	t_CKINT m_xDim;
	191	t_CKINT m_yDim;
	192	};
	193
	194	//-----------------------------------------------------------------------------
	195	// name: class ChaiVectorFast \| 1.4.2.0 (ge) added
	196	// desc: a templated fast access but not bound-checked 1D array
	197	// allows arbitrary arrays of arbitrary and non-constant dimension
	198	// to be allocated locally, e.g., int array[dim] -- which is not
	199	// valid syntax with some compilers.
	200	//-----------------------------------------------------------------------------
	201	template<class T>
	202	class ChaiVectorFast
	203	{
	204	public:
	205	ChaiVectorFast()
	206	{
	207	// zero out
	208	m_vector = NULL;
	209	// zero out
	210	m_length = 0;
	211	}
	212
	213	ChaiVectorFast( t_CKINT length )
	214	{
	215	// zero out
	216	m_vector = NULL;
	217	// allocate
	218	allocate( length );
	219	}
	220
	221	~ChaiVectorFast()
	222	{
	223	// deallocate
	224	cleanup();
	225	}
	226
	227	t_CKBOOL allocate( t_CKINT length )
	228	{
	229	// delete if necessary
	230	if( m_vector != NULL ) cleanup();
	231
	232	// allocate
	233	m_vector = new T[length];
	234	// check
	235	if( !m_vector )
	236	{
	237	// error
	238	CK_FPRINTF_STDERR( "[chuck]: ChaiVectorFast allocation failure: %s[%d]...\n",
	239	typeid( T ).name(), length );
	240	// bail
	241	return FALSE;
	242	}
	243	// remember
	244	m_length = length;
	245
	246	// done
	247	return TRUE;
	248	}
	249
	250	void shuffle()
	251	{
	252	T temp;
	253	t_CKINT j;
	254	for( t_CKINT i = m_length - 1; i > 0; i-- )
	255	{
	256	j = ck_random() % ( i + 1 );
	257	temp = m_vector[i];
	258	m_vector[i] = m_vector[j];
	259	m_vector[j] = temp;
	260	}
	261	}
	262
	263	t_CKUINT length()
	264	{ return m_length; }
	265
	266	t_CKINT size()
	267	{ return m_length; }
	268
	269	T getMax()
	270	{
	271	T max = m_vector[0];
	272	for( t_CKINT i = 1; i < m_length; i++ )
	273	{
	274	if( m_vector[i] > max )
	275	{
	276	max = m_vector[i];
	277	}
	278	}
	279	return max;
	280	}
	281
	282	void setAll( T value )
	283	{
	284	// iterate
	285	for( t_CKINT i = 0; i < m_length; i++ )
	286	{
	287	// set to value
	288	m_vector[i] = value;
	289	}
	290	}
	291
	292	T & operator[]( t_CKINT i )
	293	{
	294	// at least do a check
	295	if( i < 0 \|\| i >= m_length )
	296	{
	297	// error
	298	CK_FPRINTF_STDERR( "[chuck]: ChaiVectorFast out of bound: %s[%d] (capacity=%d)...\n",
	299	typeid( T ).name(), i, m_length );
	300	// TODO: this should throw (a shred-level, probably) exception
	301	assert( FALSE );
	302	}
	303
	304	return m_vector[i];
	305	}
	306
	307	// get element value
	308	T & v( t_CKINT i )
	309	{
	310	return ( *this )[i];
	311	}
	312
	313	void cleanup()
	314	{
	315	// reclaim array memory and zero the pointer
	316	SAFE_DELETE_ARRAY( m_vector );
	317	// zero out
	318	m_length = 0;
	319	}
	320
	321	public:
	322	T * m_vector;
	323	t_CKINT m_length;
	324	};
	325
	326	#endif
	327
	328	#ifndef _KD_TREE_H
	329	#define _KD_TREE_H
	330
	331	#include <float.h>
	332	// #define DBL_EPSILON 2.2204460492503131e-16
	333
	334	#define KDTREE_MAX_LEVEL 64
	335	#define KDTREE_LEFT_INDEX 0
	336	#define KDTREE_RIGHT_INDEX 1
	337
	338	typedef struct knn_list
	339	{
	340	struct kdnode * node;
	341	double distance;
	342	struct knn_list * prev;
	343	struct knn_list * next;
	344	} knn_list_t;
	345
	346	typedef struct kdnode
	347	{
	348	long coord_index;
	349	double * coord;
	350	struct kdnode * left;
	351	struct kdnode * right;
	352	t_CKINT r;
	353	} kdnode_t;
	354
	355	typedef struct kdtree
	356	{
	357	struct kdnode * root;
	358	size_t count;
	359	size_t capacity;
	360	double * coords;
	361	double ** coord_table;
	362	long * coord_indexes;
	363	unsigned char * coord_deleted;
	364	unsigned char * coord_passed;
	365	struct knn_list knn_list_head;
	366	t_CKINT dim;
	367	t_CKINT knn_num;
	368	} kdtree_t;
	369
	370	struct kdtree * kdtree_init( t_CKINT dim );
	371	void kdtree_insert( struct kdtree * tree, double * coord );
	372	void kdtree_rebuild( struct kdtree * tree );
	373	void kdtree_knn_search( struct kdtree * tree, double * coord, t_CKINT k );
	374	void kdtree_destroy( struct kdtree * tree );
	375	void kdtree_dump( struct kdtree * tree );
	376
	377	#endif /* _KD_TREE_H */

chuginate/template/chuck/include/ulib_machine.h+9−10

@@ -42,22 +42,21 @@ struct Chuck_Compiler; · 41 unmodified lines
42		42
43	// query	43	// query
44	DLL_QUERY machine_query( Chuck_DL_Query * QUERY );	44	DLL_QUERY machine_query( Chuck_DL_Query * QUERY );
45	typedef t_CKUINT (* proc_msg_func)( Chuck_VM , Chuck_Compiler ,	45
		46	#ifndef __DISABLE_OTF_SERVER__
		47	typedef t_CKUINT (* proc_msg_func)( Chuck_VM , Chuck_Compiler ,
46	Net_Msg , t_CKBOOL, void );	48	Net_Msg , t_CKBOOL, void );
47	t_CKBOOL machine_init( Chuck_Compiler * compiler, proc_msg_func func );	49	t_CKBOOL machine_init( Chuck_Compiler * compiler, proc_msg_func func );
48	// 1.4.0.1: TODO: refactor out of ulib machine; not all platforms have OTF	50	// 1.4.0.1: TODO: refactor out of ulib machine; not all platforms have OTF
		51	#endif // __DISABLE_OTF_SERVER__
		52
		53	// machine exports
49	t_CKUINT machine_intsize();	54	t_CKUINT machine_intsize();
50		55
51		56
52	// exports	57	// ckdoc query
53	CK_DLL_SFUN( machine_crash_impl );	58	DLL_QUERY ckdoc_query( Chuck_DL_Query * QUERY );
54	CK_DLL_SFUN( machine_add_impl );	59
55	CK_DLL_SFUN( machine_spork_impl );
56	CK_DLL_SFUN( machine_remove_impl );
57	CK_DLL_SFUN( machine_replace_impl );
58	CK_DLL_SFUN( machine_status_impl );
59	CK_DLL_SFUN( machine_intsize_impl );
60	CK_DLL_SFUN( machine_shreds_impl );
61		60
62		61
63	#endif	62	#endif

chuginate/template/chuck/include/ulib_math.h+12−6

@@ -68,6 +68,7 @@ CK_DLL_SFUN( min_impl ); · 67 unmodified lines
68	CK_DLL_SFUN( max_impl );	68	CK_DLL_SFUN( max_impl );
69	CK_DLL_SFUN( isinf_impl );	69	CK_DLL_SFUN( isinf_impl );
70	CK_DLL_SFUN( isnan_impl );	70	CK_DLL_SFUN( isnan_impl );
		71	CK_DLL_SFUN( equal_impl );
71	CK_DLL_SFUN( floatMax_impl );	72	CK_DLL_SFUN( floatMax_impl );
72	CK_DLL_SFUN( intMax_impl );	73	CK_DLL_SFUN( intMax_impl );
73		74
@@ -89,12 +90,17 @@ CK_DLL_SFUN( srandom_impl ); · 15 unmodified lines
89		90
90	CK_DLL_SFUN( gauss_impl );	91	CK_DLL_SFUN( gauss_impl );
91		92
92	// max for random functions	93	CK_DLL_SFUN( cossim_impl );
93	#ifdef __WINDOWS_DS__	94	CK_DLL_SFUN( cossim3d_impl );
94	#define CK_RANDOM_MAX RAND_MAX	95	CK_DLL_SFUN( cossim4d_impl );
95	#else	96
96	#define CK_RANDOM_MAX 0x7fffffff	97	CK_DLL_SFUN( euclidean_impl );
97	#endif	98	CK_DLL_SFUN( euclidean3d_impl );
		99	CK_DLL_SFUN( euclidean4d_impl );
		100
		101	CK_DLL_SFUN( map_impl );
		102	CK_DLL_SFUN( map2_impl );
		103
98		104
99		105
100		106

chuginate/template/chuck/include/ulib_regex.h+4−4

chuginate/template/chuck/include/util_buffers.h+54−54

@@ -43,8 +43,8 @@ · 42 unmodified lines
43	#include <queue>	43	#include <queue>
44	#include <iostream>	44	#include <iostream>
45		45
46	#define DWORD__ unsigned long	46	#define DWORD__ t_CKUINT
47	#define SINT__ long	47	#define SINT__ t_CKINT
48	#define UINT__ DWORD__	48	#define UINT__ DWORD__
49	#define BOOL__ DWORD__	49	#define BOOL__ DWORD__
50	#define BYTE__ unsigned char	50	#define BYTE__ unsigned char
@@ -103,7 +103,7 @@ protected: · 52 unmodified lines
103	#ifndef __DISABLE_THREADS__	103	#ifndef __DISABLE_THREADS__
104	XMutex m_mutex;	104	XMutex m_mutex;
105	#endif	105	#endif
106		106
107	CBufferSimple * m_event_buffer;	107	CBufferSimple * m_event_buffer;
108	};	108	};
109		109
@@ -203,7 +203,7 @@ template<typename T> · 93 unmodified lines
203	class CircularBuffer	203	class CircularBuffer
204	{	204	{
205	public:	205	public:
206		206
207	CircularBuffer(size_t numElements) :	207	CircularBuffer(size_t numElements) :
208	m_read(0),	208	m_read(0),
209	m_write(0),	209	m_write(0),
@@ -211,7 +211,7 @@ public: · 1 unmodified line
211	{	211	{
212	m_elements = new T[m_numElements];	212	m_elements = new T[m_numElements];
213	}	213	}
214		214
215	~CircularBuffer()	215	~CircularBuffer()
216	{	216	{
217	if(m_elements != NULL)	217	if(m_elements != NULL)
@@ -220,7 +220,7 @@ public: · 2 unmodified lines
220	m_elements = NULL;	220	m_elements = NULL;
221	}	221	}
222	}	222	}
223		223
224	// put one element	224	// put one element
225	// returns number of elements successfully put	225	// returns number of elements successfully put
226	size_t put(T element)	226	size_t put(T element)
@@ -230,14 +230,14 @@ public: · 3 unmodified lines
230	// no space	230	// no space
231	return 0;	231	return 0;
232	}	232	}
233		233
234	m_elements[m_write] = element;	234	m_elements[m_write] = element;
235		235
236	m_write = (m_write+1)%m_numElements;	236	m_write = (m_write+1)%m_numElements;
237		237
238	return 1;	238	return 1;
239	}	239	}
240		240
241	// get one element	241	// get one element
242	// returns number of elements successfully got	242	// returns number of elements successfully got
243	size_t get(T &element)	243	size_t get(T &element)
@@ -247,14 +247,14 @@ public: · 3 unmodified lines
247	// nothing to get	247	// nothing to get
248	return 0;	248	return 0;
249	}	249	}
250		250
251	element = m_elements[m_read];	251	element = m_elements[m_read];
252		252
253	m_read = (m_read+1)%m_numElements;	253	m_read = (m_read+1)%m_numElements;
254		254
255	return 1;	255	return 1;
256	}	256	}
257		257
258	// peek at element i without removing it	258	// peek at element i without removing it
259	// i = 1 would correspond to the least recently put element;	259	// i = 1 would correspond to the least recently put element;
260	// i = -1 would correspond to the most recent (not implemented)	260	// i = -1 would correspond to the most recent (not implemented)
@@ -263,24 +263,24 @@ public: · 2 unmodified lines
263	{	263	{
264	if(i == 0)	264	if(i == 0)
265	return 0;	265	return 0;
266		266
267	if(i > 0 && i <= numElements())	267	if(i > 0 && i <= numElements())
268	{	268	{
269	element = m_elements[(m_read+(i-1))%m_numElements];	269	element = m_elements[(m_read+(i-1))%m_numElements];
270	return 1;	270	return 1;
271	}	271	}
272		272
273	return 0;	273	return 0;
274	}	274	}
275		275
276	void clear() { m_write = m_read; }	276	void clear() { m_write = m_read; }
277		277
278	// return maximum number of elements that can be held	278	// return maximum number of elements that can be held
279	size_t maxElements() { return m_numElements-1; }	279	size_t maxElements() { return m_numElements-1; }
280		280
281	// return if buffer is full	281	// return if buffer is full
282	bool atMaximum() { return (m_write + 1)%m_numElements == m_read; }	282	bool atMaximum() { return (m_write + 1)%m_numElements == m_read; }
283		283
284	// return number of valid elements in the buffer	284	// return number of valid elements in the buffer
285	size_t numElements()	285	size_t numElements()
286	{	286	{
@@ -291,7 +291,7 @@ public: · 4 unmodified lines
291	else	291	else
292	return m_numElements - m_read + m_write;	292	return m_numElements - m_read + m_write;
293	}	293	}
294		294
295	private:	295	private:
296	T * m_elements;	296	T * m_elements;
297	size_t m_read, m_write;	297	size_t m_read, m_write;
@@ -311,17 +311,17 @@ class FastCircularBuffer · 13 unmodified lines
311	public:	311	public:
312	FastCircularBuffer();	312	FastCircularBuffer();
313	~FastCircularBuffer();	313	~FastCircularBuffer();
314		314
315	public:	315	public:
316	t_CKUINT initialize( t_CKUINT num_elem, t_CKUINT width );	316	t_CKUINT initialize( t_CKUINT num_elem, t_CKUINT width );
317	void cleanup();	317	void cleanup();
318		318
319	public:	319	public:
320	t_CKUINT get( void * data, t_CKUINT num_elem );	320	t_CKUINT get( void * data, t_CKUINT num_elem );
321	t_CKUINT put( void * data, t_CKUINT num_elem );	321	t_CKUINT put( void * data, t_CKUINT num_elem );
322	inline bool hasMore() { return (m_read_offset != m_write_offset); }	322	inline bool hasMore() { return (m_read_offset != m_write_offset); }
323	inline void clear() { m_read_offset = m_write_offset = 0; }	323	inline void clear() { m_read_offset = m_write_offset = 0; }
324		324
325	protected:	325	protected:
326	t_CKBYTE * m_data;	326	t_CKBYTE * m_data;
327	t_CKUINT m_data_width;	327	t_CKUINT m_data_width;
@@ -343,7 +343,7 @@ class XCircleBuffer · 15 unmodified lines
343	public:	343	public:
344	XCircleBuffer( long length = 0 );	344	XCircleBuffer( long length = 0 );
345	~XCircleBuffer();	345	~XCircleBuffer();
346		346
347	public:	347	public:
348	// reset length of buffer (capacity)	348	// reset length of buffer (capacity)
349	void init( long length );	349	void init( long length );
@@ -351,7 +351,7 @@ public: · 1 unmodified line
351	long length() const;	351	long length() const;
352	// clear (does no explicit memory management)	352	// clear (does no explicit memory management)
353	void clear();	353	void clear();
354		354
355	public:	355	public:
356	// put an element into the buffer - the item will be copied	356	// put an element into the buffer - the item will be copied
357	// NOTE: if over-capacity, will discard least recently put item	357	// NOTE: if over-capacity, will discard least recently put item
@@ -366,11 +366,11 @@ public: · 8 unmodified lines
366	long peek( T * array, long numItems, unsigned long stride = 0 );	366	long peek( T * array, long numItems, unsigned long stride = 0 );
367	// pop	367	// pop
368	long pop( long numItems = 1 );	368	long pop( long numItems = 1 );
369		369
370	protected: // helper functions	370	protected: // helper functions
371	inline void advanceWrite();	371	inline void advanceWrite();
372	inline void advanceRead();	372	inline void advanceRead();
373		373
374	protected:	374	protected:
375	// the buffer	375	// the buffer
376	T * m_buffer;	376	T * m_buffer;
@@ -397,7 +397,7 @@ XCircleBuffer<T>::XCircleBuffer( long length ) · 20 unmodified lines
397	// zero out first	397	// zero out first
398	m_buffer = NULL;	398	m_buffer = NULL;
399	m_length = m_readIndex = m_writeIndex = m_numElements = 0;	399	m_length = m_readIndex = m_writeIndex = m_numElements = 0;
400		400
401	// call init	401	// call init
402	this->init( length );	402	this->init( length );
403	}	403	}
@@ -412,7 +412,7 @@ XCircleBuffer<T>::XCircleBuffer( long length ) · 8 unmodified lines
412	template <typename T>	412	template <typename T>
413	XCircleBuffer<T>::~XCircleBuffer()	413	XCircleBuffer<T>::~XCircleBuffer()
414	{	414	{
415		415
416	}	416	}
417		417
418		418
@@ -433,20 +433,20 @@ void XCircleBuffer<T>::init( long length ) · 14 unmodified lines
433	// zero out	433	// zero out
434	m_length = m_readIndex = m_writeIndex = m_numElements = 0;	434	m_length = m_readIndex = m_writeIndex = m_numElements = 0;
435	}	435	}
436		436
437	// sanity check	437	// sanity check
438	if( length < 0 )	438	if( length < 0 )
439	{	439	{
440	// doh	440	// doh
441	std::cerr << "[XCircleBuffer]: error invalid length '"	441	std::cerr << "[XCircleBuffer]: error invalid length '"
442	<< length << "' requested" << std::endl;	442	<< length << "' requested" << std::endl;
443		443
444	return;	444	return;
445	}	445	}
446		446
447	// check for zero length	447	// check for zero length
448	if( length == 0 ) return;	448	if( length == 0 ) return;
449		449
450	// allocate	450	// allocate
451	m_buffer = new T[length];	451	m_buffer = new T[length];
452	// check	452	// check
@@ -455,10 +455,10 @@ void XCircleBuffer<T>::init( long length ) · 2 unmodified lines
455	// doh	455	// doh
456	std::cerr << "[XCircleBuffer]: failed to allocate buffer of length '"	456	std::cerr << "[XCircleBuffer]: failed to allocate buffer of length '"
457	<< length << "'..." << std::endl;	457	<< length << "'..." << std::endl;
458		458
459	return;	459	return;
460	}	460	}
461		461
462	// save	462	// save
463	m_length = length;	463	m_length = length;
464	// zero out	464	// zero out
@@ -504,14 +504,14 @@ void XCircleBuffer<T>::advanceWrite() · 39 unmodified lines
504	{	504	{
505	// increment	505	// increment
506	m_writeIndex++;	506	m_writeIndex++;
507		507
508	// check for bounds	508	// check for bounds
509	if( m_writeIndex >= m_length )	509	if( m_writeIndex >= m_length )
510	{	510	{
511	// wrap	511	// wrap
512	m_writeIndex -= m_length;	512	m_writeIndex -= m_length;
513	}	513	}
514		514
515	// increment count	515	// increment count
516	m_numElements++;	516	m_numElements++;
517	}	517	}
@@ -528,14 +528,14 @@ void XCircleBuffer<T>::advanceRead() · 10 unmodified lines
528	{	528	{
529	// increment	529	// increment
530	m_readIndex++;	530	m_readIndex++;
531		531
532	// check for bounds	532	// check for bounds
533	if( m_readIndex >= m_length )	533	if( m_readIndex >= m_length )
534	{	534	{
535	// wrap	535	// wrap
536	m_readIndex -= m_length;	536	m_readIndex -= m_length;
537	}	537	}
538		538
539	// decrement count	539	// decrement count
540	m_numElements--;	540	m_numElements--;
541	}	541	}
@@ -553,13 +553,13 @@ void XCircleBuffer<T>::put( const T & item ) · 11 unmodified lines
553	{	553	{
554	// sanity check	554	// sanity check
555	if( m_buffer == NULL ) return;	555	if( m_buffer == NULL ) return;
556		556
557	// copy it	557	// copy it
558	m_buffer[m_writeIndex] = item;	558	m_buffer[m_writeIndex] = item;
559		559
560	// advance write index	560	// advance write index
561	advanceWrite();	561	advanceWrite();
562		562
563	// if read and write pointer are the same, over-capacity	563	// if read and write pointer are the same, over-capacity
564	if( m_writeIndex == m_readIndex )	564	if( m_writeIndex == m_readIndex )
565	{	565	{
@@ -609,19 +609,19 @@ long XCircleBuffer<T>::peek( T * array, long numItems, unsigned long stride ) · 43 unmodified lines
609	{	609	{
610	// sanity check	610	// sanity check
611	if( m_buffer == NULL ) return 0;	611	if( m_buffer == NULL ) return 0;
612		612
613	// sanity check (so the wrap can be sure to land inbounds)	613	// sanity check (so the wrap can be sure to land inbounds)
614	if( stride >= m_length ) return 0;	614	if( stride >= m_length ) return 0;
615		615
616	// count	616	// count
617	long count = 0;	617	long count = 0;
618	// actual count, taking stride out of the equation	618	// actual count, taking stride out of the equation
619	long actualCount = 0;	619	long actualCount = 0;
620		620
621	// starting index	621	// starting index
622	long index = m_writeIndex - 1;	622	long index = m_writeIndex - 1;
623	if( index < 0 ) index += m_length;	623	if( index < 0 ) index += m_length;
624		624
625	// while need more but haven't reached write index...	625	// while need more but haven't reached write index...
626	while( (count < numItems) && (count < m_numElements) )	626	while( (count < numItems) && (count < m_numElements) )
627	{	627	{
@@ -636,7 +636,7 @@ long XCircleBuffer<T>::peek( T * array, long numItems, unsigned long stride ) · 8 unmodified lines
636	// wrap	636	// wrap
637	if( index < 0 ) index += m_length;	637	if( index < 0 ) index += m_length;
638	}	638	}
639		639
640	// reverse contents	640	// reverse contents
641	for( int i = 0; i < actualCount/2; i++ )	641	for( int i = 0; i < actualCount/2; i++ )
642	{	642	{
@@ -644,7 +644,7 @@ long XCircleBuffer<T>::peek( T * array, long numItems, unsigned long stride ) · 1 unmodified line
644	array[i] = array[actualCount-1-i];	644	array[i] = array[actualCount-1-i];
645	array[actualCount-1-i] = v;	645	array[actualCount-1-i] = v;
646	}	646	}
647		647
648	return actualCount;	648	return actualCount;
649	}	649	}
650		650
@@ -660,10 +660,10 @@ long XCircleBuffer<T>::pop( long numItems ) · 9 unmodified lines
660	{	660	{
661	// sanity check	661	// sanity check
662	if( m_buffer == NULL ) return 0;	662	if( m_buffer == NULL ) return 0;
663		663
664	// count	664	// count
665	long count = 0;	665	long count = 0;
666		666
667	// while there is more to pop and need to pop more	667	// while there is more to pop and need to pop more
668	while( more() && count < numItems )	668	while( more() && count < numItems )
669	{	669	{
@@ -672,7 +672,7 @@ long XCircleBuffer<T>::pop( long numItems ) · 2 unmodified lines
672	// increment count	672	// increment count
673	count++;	673	count++;
674	}	674	}
675		675
676	return count;	676	return count;
677	}	677	}
678		678
@@ -688,12 +688,12 @@ bool XCircleBuffer<T>::get( T * result ) · 9 unmodified lines
688	{	688	{
689	// sanity check	689	// sanity check
690	if( m_buffer == NULL \|\| m_readIndex == m_writeIndex ) return false;	690	if( m_buffer == NULL \|\| m_readIndex == m_writeIndex ) return false;
691		691
692	// get item to read	692	// get item to read
693	*result = m_buffer[m_readIndex];	693	*result = m_buffer[m_readIndex];
694	// advance read	694	// advance read
695	advanceRead();	695	advanceRead();
696		696
697	return true;	697	return true;
698	}	698	}
699		699

chuginate/template/chuck/include/util_hid.h+4−2

 #ifndef __UTIL_HID_H__
 #define __UTIL_HID_H__
+#include "chuck_def.h"
     t_CKINT idata[4];    // int data
 #endif
     t_CKFLOAT fdata[4];  // float data
 #ifdef __cplusplus
     HidMsg()
     { this->clear(); }
 extern int Mouse_buttons( int m );
 extern int Mouse_start_cursor_track();
 extern int Mouse_stop_cursor_track();
 extern void Keyboard_init();
 extern void Keyboard_poll();
 extern void Keyboard_quit();

chuginate/template/chuck/include/util_math.h+23−7

@@ -34,21 +34,36 @@ · 33 unmodified lines
34	#define __UTIL_MATH_H__	34	#define __UTIL_MATH_H__
35		35
36	#include <math.h>	36	#include <math.h>
		37	#include "chuck_def.h" // 1.4.1.0 (ge) for t_CKINT
37		38
38	#if defined (__cplusplus) \|\| defined(_cplusplus)	39	#if defined (__cplusplus) \|\| defined(_cplusplus)
39	extern "C" {	40	extern "C" {
40	#endif	41	#endif
41		42
		43	// 1.4.1.1 (ge) removed -- seems no longer needed on more modern windows
42	#ifdef __PLATFORM_WIN32__	44	#ifdef __PLATFORM_WIN32__
43		45	#ifdef __CK_MATH_DEFINE_ROUND_TRUNC__
44	double round( double a );	46	double round( double a );
45	double trunc( double a );	47	double trunc( double a );
46	#ifndef __WINDOWS_MODERN__
47	double remainder( long a, long b );
48	#endif	48	#endif
		49	#endif
		50
		51	// 1.4.1.0 (ge) need this since __WINDOWS_MODERN__ can be defined but remainder still not found (VC++ 2010)
		52	double ck_remainder( double a, double b );
		53
49		54
		55	// max for random functions
		56	#ifdef __PLATFORM_WIN32__
		57	#define CK_RANDOM_MAX RAND_MAX
		58	#else
		59	#define CK_RANDOM_MAX 0x7fffffff
50	#endif	60	#endif
51		61
		62	// chuck random wrapper
		63	long ck_random();
		64	// chuck srandom wrapper
		65	void ck_srandom( unsigned seed );
		66
52	// mtof	67	// mtof
53	double mtof( double f );	68	double mtof( double f );
54	// ftom	69	// ftom
@@ -66,10 +81,11 @@ unsigned long nextpow2( unsigned long i ); · 11 unmodified lines
66	// ensurepow2	81	// ensurepow2
67	unsigned long ensurepow2( unsigned long i );	82	unsigned long ensurepow2( unsigned long i );
68		83
69	#if defined (__cplusplus) \|\| defined(_cplusplus)	84	#if defined (__cplusplus) \|\| defined(_cplusplus)
70	}	85	}
71	#endif	86	#endif
72		87
73		88
74		89
75	#endif	90
		91	#endif

chuginate/template/chuck/include/util_network.h+1−0

@@ -41,6 +41,7 @@ · 40 unmodified lines
41	#include <sys/socket.h>	41	#include <sys/socket.h>
42	#include <netinet/in.h>	42	#include <netinet/in.h>
43	#else	43	#else
		44	#define _WINSOCKAPI_
44	#include <windows.h>	45	#include <windows.h>
45	#endif	46	#endif
46		47

chuginate/template/chuck/include/util_opsc.h+52−51

 // chuck high-style artistry
 // let's just cat included files into an enormous code-wad.
 // keep that bubble gum in your hair.
 // the included files were from the CNMAT OSC-Kit distrib.
 #ifdef __PLATFORM_WIN32__
+#define _WINSOCKAPI_
 #include <windows.h>
 #endif
 // OSC-pattern-match.h
 /*
 Copyright � 1998. The Regents of the University of California (Regents).
 All Rights Reserved.
 Written by Matt Wright, The Center for New Music and Audio Technologies,
 HEREUNDER IS PROVIDED "AS IS". REGENTS HAS NO OBLIGATION TO PROVIDE
 MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS.
 The OpenSound Control WWW page is
     http://www.cnmat.berkeley.edu/OpenSoundControl
 */
 // - end OSC-pattern-match.h
 //#inclue OSC-TimeTag.h
 /*
 Copyright (c) 1998.  The Regents of the University of California (Regents).
      REGENTS HAS NO OBLIGATION TO PROVIDE MAINTENANCE, SUPPORT, UPDATES,
      ENHANCEMENTS, OR MODIFICATIONS.
 The OpenSound Control WWW page is
     http://www.cnmat.berkeley.edu/OpenSoundControl
 */
  Time tags in OSC have the same format as in NTP: 64 bit fixed point, with the
  top 32 bits giving number of seconds sinve midnight 1/1/1900 and the bottom
  32 bits giving fractional parts of a second.  We represent this by a 64-bit
  unsigned long if possible, or else a struct.
  NB: On many architectures with 64-bit ints, it's illegal (like maybe a bus error)
  to dereference a pointer to a 64-bit int that's not 64-bit aligned.
 */
 #ifndef OSC_TIMETAG
     typedef unsigned long long uint64;
     typedef unsigned long uint32;
 #else
     /* You may have to redefine this typedef if ints on your system
        aren't 32 bits. */
     typedef unsigned int uint32;
 #endif
 //#include "OSC-client.h"
 // OSC-client.h
 /*
 Copyright (c) 1996,1997.  The Regents of the University of California (Regents).
 All Rights Reserved.
      ENHANCEMENTS, OR MODIFICATIONS.
 */
 /*
    OSC-client.h: library for constructing OpenSoundControl messages.
    Derived from SynthControl.h
 #endif
 /* The maximum depth of bundles within bundles within bundles within...
    This is the size of a static array.  If you exceed this limit you'll
    get an error message. */
 #define MAX_BUNDLE_NESTING 32
     int size;                /* Size of the buffer */
     char *bufptr;            /* Current position as we fill the buffer */
     int state;           /* State of partially-constructed message */
     int4byte *thisMsgSize;   /* Pointer to count field before
                     currently-being-written message */
     int4byte *prevCounts[MAX_BUNDLE_NESTING];
                  /* Pointers to count field before each currently
     - Make sure the OSCbuf has been initialized with OSC_initBuffer().
     - To open a bundle, call OSC_openBundle().  You can then write
       messages or open new bundles within the bundle you opened.
       Call OSC_closeBundle() to close the bundle.  Note that a packet
       does not have to have a bundle; it can instead consist of just a
       single message.
     - For each message you want to send:
         - Alternately, call OSC_writeAddressAndTypes() with the name of
           your message and with a type string listing the types of all the
           arguments you will be putting in this message.
     - Now write each of the arguments into the buffer, by calling one of:
         OSC_writeFloatArg()
         OSC_writeFloatArgs()
 /* How many bytes will be needed in the OSC format to hold the given
    string?  The length of the string, plus the null char, plus any padding
    needed for 4-byte alignment. */
 int OSC_effectiveStringLength(char *string);
 // end OSC-client.h
 class OSC_Address_Space;
 class UDP_Transmitter;
 class UDP_Receiver;
 class OSC_Transmitter
 {
 protected:
     char              _buffer[2048];
     OSCbuf            _osc;
     UDP_Transmitter * _out;
     void init();
     void setHost( char * host, int port);
     void addMessage( char * address, char * args, ...);
     void openBundle( OSCTimeTag t);
     void closeBundle();
     void startMessage( char * spec );
     void startMessage( char * address, char * args );
     void addInt( int4byte i ); // gewang: changed from int
     void kickMessage();
     void presend( char * buffer , int size );
 };
 #define OSCINBUFSIZE 8192
 //maximum size for the array  ( ~2mb is enough, no )
 #define OSCINBOXMAX 256
 struct OSCMesg {
     char *address;
     char *types;
     char *data;
     virtual ~UDP_Subscriber() {}
 public:
     virtual int& port() = 0; // get/set the value of the subscriber's current port.
     virtual void onReceive( char * mesg, int mesgLen ) = 0;
 protected:
     virtual bool subscribe( int port );
     virtual bool unsubscribe();
 };
     // int            _mesglen;
 protected:
-	void onReceive( char * mesg, int mesgLen);
+    void onReceive( char * mesg, int mesgLen);
-	int & port();
+    int & port();
 protected:
-	int			   _port;
+    int               _port;
-	int			   _tmp_port;
+    int               _tmp_port;
     XMutex *        _io_mutex;
     XMutex *        _address_mutex;
     // XThread *       _io_thread;
     OSC_Address_Space **      _address_space;
     int             _address_size;
     int             _address_num;
     CBufferSimple * m_event_buffer;
     // REFACTOR-2017: VM ref
     Chuck_VM * m_vmRef;
 public:
     OSC_Receiver( Chuck_VM * vm );
     OSC_Receiver( Chuck_VM * vm, UDP_Receiver * in );
     virtual ~OSC_Receiver();
     //setup //takedown
     void init();
     void bind_to_port(int port = 0);
     void close_sock();
     void recv_mesg();
-	bool listen( int port );
+    bool listen( int port );
     bool listen();
-	void stopListening(); //unsubscribe;
+    void stopListening(); //unsubscribe;
     void parse(char *, int len);
     void handle_mesg(char *, int len);
     void handle_bundle(char *, int len);
     void set_mesg(OSCMesg *m, char * buf, int len );
     OSCMesg *write()  { return _inbox + _in_write;}
     void next_write();
     OSCMesg *read()  { return _inbox + _in_read;}
     OSCMesg *next_read();
     bool get_mesg(OSCMesg* bucket);
     void add_address ( OSC_Address_Space * o );
     void remove_address ( OSC_Address_Space * o );
     OSC_Address_Space * new_event ( char * spec );
     OSC_Address_Space * new_event ( char * addr, char * type );
     void distribute_message( OSCMesg * msg);
 struct opsc_data
 {
     osc_datatype t;
     OSCTimeTag timetag;
-	union {
+    union {
-		int4byte i;  // gewang: changed from int
+        int4byte i;  // gewang: changed from int
-		unsigned long u;  // gewang: changed from unsigned int
+        unsigned long u;  // gewang: changed from unsigned int
-		float f;
+        float f;
-	};
+    };
     char * s;
     opsc_data() {
         t = OSC_UNTYPED;
         s = NULL;
     }
     ~opsc_data() {
         s = NULL;
     }
 };
     void resizeData(int n);
     void resizeQueue(int n);
     void parseSpec();
-	void scanSpec();
+    void scanSpec();
 public:
     Chuck_Object * SELF;
     Chuck_String p_str;
     OSC_Address_Space();
     OSC_Address_Space( const char * spec );

chuginate/template/chuck/include/util_platforms.h+9−10

chuginate/template/chuck/include/util_serial.h+5−4

 #ifndef __UTIL_SERIAL_H__
 #define __UTIL_SERIAL_H__
+#include "chuck_def.h"
 #include <vector>
 #include <string>
-using namespace std;
 class SerialIOManager
 {
 public:
-    static vector<string> availableSerialDevices();
+    static std::vector<std::string> availableSerialDevices();
 private:
-    static vector<string> s_availableSerialDevices;
+    static std::vector<std::string> s_availableSerialDevices;
 };

chuginate/template/chuck/include/util_sndfile.h+103−99

 // XXX philipd this might break things?
 // these defines were placed after the machine-dependent
 // checks below...i'm not sure why
 #define COMPILER_IS_GCC 1
 #endif
 #ifdef __LINUX_ALSA__
 #define HAVE_ALSA_ASOUNDLIB_H
 #endif
 #if defined(__PLATFORM_LINUX__)
 // XXX 'inline' is necessary for C compilation
 // in the microsoft vc6 compiler...
 // and other ms win32 specialteez.
 #ifdef __PLATFORM_WIN32__
 #define C_INLINE __inline
 #define SF_COUNT_MAX 0x7FFFFFFFFFFFFFFF
 #else
 /* The following typedef is system specific and is defined when libsndfile is.
 ** compiled. sf_count_t can be one of loff_t (Linux), off_t (*BSD),
 ** off64_t (Solaris), __int64_t (Win32) etc.
 */
 */
 /*
 ** Copyright (C) 1999-2001 Erik de Castro Lopo <erikd@mega-nerd.com>
 **
 ** This program is free software; you can redistribute it and/or modify
 ** it under the terms of the GNU Lesser General Public License as published by
 ** the Free Software Foundation; either version 2.1 of the License, or
 ** (at your option) any later version.
 **
 ** This program is distributed in the hope that it will be useful,
 ** but WITHOUT ANY WARRANTY; without even the implied warranty of
 ** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 ** GNU Lesser General Public License for more details.
 **
 ** You should have received a copy of the GNU Lesser General Public License
 ** along with this program; if not, write to the Free Software
 ** Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
 */
 /*
 ** This file is not the same as the original file from Sun Microsystems. Nearly
 ** all the original definitions and function prototypes that were in the file
 ** of this name have been moved to private.h.
 */
 #ifndef G72X_HEADER_FILE
 #define G72X_HEADER_FILE
 /*
 ** Number of samples per block to process.
 ** Must be a common multiple of possible bits per sample : 2, 3, 4, 5 and 8.
 */
 #define G72x_BLOCK_SIZE     (3*5*8)
 /*
 **  Identifiers for the differing kinds of G72x ADPCM codecs.
 **  The identifiers also define the number of encoded bits per sample.
 */
 enum
 {   G723_16_BITS_PER_SAMPLE = 2,
     G723_24_BITS_PER_SAMPLE = 3,
     G723_40_BITS_PER_SAMPLE = 5,
     G721_32_BITS_PER_SAMPLE = 4,
     G721_40_BITS_PER_SAMPLE = 5,
     G723_16_SAMPLES_PER_BLOCK = G72x_BLOCK_SIZE,
     G723_24_SAMPLES_PER_BLOCK = G723_24_BITS_PER_SAMPLE * (G72x_BLOCK_SIZE / G723_24_BITS_PER_SAMPLE),
     G723_40_SAMPLES_PER_BLOCK = G723_40_BITS_PER_SAMPLE * (G72x_BLOCK_SIZE / G723_40_BITS_PER_SAMPLE),
     G721_32_SAMPLES_PER_BLOCK = G72x_BLOCK_SIZE,
     G721_40_SAMPLES_PER_BLOCK = G721_40_BITS_PER_SAMPLE * (G72x_BLOCK_SIZE / G721_40_BITS_PER_SAMPLE),
     G721_32_BYTES_PER_BLOCK = (G721_32_BITS_PER_SAMPLE * G72x_BLOCK_SIZE) / 8,
     G721_40_BYTES_PER_BLOCK = (G721_40_BITS_PER_SAMPLE * G72x_BLOCK_SIZE) / 8
 } ;
 /*
 ** This is the public structure for passing data between the caller and
 ** the G72x encoder and decoder.
 ** The private array is used by the encoder and decoder for internal
 ** state information and should not be changed in any way by the caller.
 ** When decoding or encoding a stream, the same instance of this struct
 ** correct state data between calls.
 */
 typedef struct
 {   /* Private data. Don't mess with it. */
     unsigned long   sprivateo [256 / sizeof (long)] ;
     /* Public data. Read only. */
     int             blocksize, max_bytes, samplesperblock, bytesperblock ;
 int g72x_decode_block (G72x_DATA *data) ;
 /*
 **  The caller fills data->block with data->bytes bytes before calling the
 **  function. The value data->bytes must be an integer multiple of
 **  data->blocksize and be <= data->max_bytes.
 **  When it returns, the caller can read out data->samples samples.
 */
 int g72x_encode_block (G72x_DATA *data) ;
 /*
 **  The caller fills state->samples some integer multiple data->samples_per_block
 **  (up to G72x_BLOCK_SIZE) samples before calling the function.
 **  When it returns, the caller can read out bytes encoded bytes.
 */
 #endif /* !G72X_HEADER_FILE */
 /*
 ** Do not edit or modify anything in this comment block.
 ** The arch-tag line is a file identity tag for the GNU Arch
 ** revision control system.
 **
 ** arch-tag: 6ca84e5f-f932-4ba1-87ee-37056d921621
 /*
 ** The following is the definition of the state structure used by the
 ** G.721/G.723 encoder and decoder to preserve their internal state
 ** between successive calls.  The meanings of the majority of the state
 ** structure fields are explained in detail in the CCITT Recommendation
 ** G.721.  The field names are essentially identical to variable names
 ** in the bit level description of the coding algorithm included in this
 ** Recommendation.
 */
                     ** format.
                     */
     char td;    /* delayed tone detect, new in 1988 version */
     /*  The following struct members were added for libsndfile. The original
     **  code worked by calling a set of functions on a sample by sample basis
     **  which is slow on architectures like Intel x86. For libsndfile, this
     **  was changed so that the encoding and decoding routines could work on
     **  a block of samples at a time to reduce the function call overhead.
     */
     int     (*encoder) (int, struct private_g72x* state) ;
     int     (*decoder) (int, struct private_g72x* state) ;
     int     codec_bits ;
     int     byte_index, sample_index ;
 } G72x_STATE ;
 #endif /* G72X_PRIVATE_H */
 /*
 ** Do not edit or modify anything in this comment block.
 ** The arch-tag line is a file identity tag for the GNU Arch
 ** revision control system.
 **
 ** arch-tag: d9ad4da7-0fa3-471d-8020-720b5cfb5e5b
 /*
 ** Do not edit or modify anything in this comment block.
 ** The arch-tag line is a file identity tag for the GNU Arch
 ** revision control system.
 **
 ** arch-tag: f0c5cd54-42d3-4237-90ec-11fe24995de7
 gsm  gsm_create     (void);
 /* Added for libsndfile : May 6, 2002 */
 void gsm_init (gsm);
 void gsm_destroy (gsm);
 int  gsm_print   (FILE *, gsm, gsm_byte  *);
 int  gsm_option  (gsm, int, int *);
 #endif  /* GSM_H */
 /*
 ** Do not edit or modify anything in this comment block.
 ** The arch-tag line is a file identity tag for the GNU Arch
 ** revision control system.
 **
 ** arch-tag: 8cfc7698-5433-4b6f-aeca-967c6fda4dec
 /*
 ** Copyright (C) 1999-2004 Erik de Castro Lopo <erikd@mega-nerd.com>
 **
 ** This program is free software; you can redistribute it and/or modify
 ** it under the terms of the GNU Lesser General Public License as published by
 ** the Free Software Foundation; either version 2.1 of the License, or
 ** (at your option) any later version.
 **
 ** This program is distributed in the hope that it will be useful,
 ** but WITHOUT ANY WARRANTY; without even the implied warranty of
 ** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 ** GNU Lesser General Public License for more details.
 **
 ** You should have received a copy of the GNU Lesser General Public License
 ** along with this program; if not, write to the Free Software
 ** Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
 */
 #endif /* AU_HEADER_FILE */
 /*
 ** Do not edit or modify anything in this comment block.
 ** The arch-tag line is a file identity tag for the GNU Arch
 ** revision control system.
 **
 ** arch-tag: 63affc81-e204-4468-9705-60abe4d10689
 {
   /* keep sorted for wav_w64_format_str() */
     WAVE_FORMAT_UNKNOWN                 = 0x0000,       /* Microsoft Corporation */
-#ifndef WAVE_FORMAT_PCM
+    WAVE_FORMAT_MS_PCM                  = 0x0001,       /* Microsoft PCM format */
-    WAVE_FORMAT_PCM                     = 0x0001,       /* Microsoft PCM format */
+    /* -------------------------------------------------------------------------
-#endif
+    creating and using WAVE_FORMAT_MS_PCM in this module, as WAVE_FORMAT_PCM may
+    be defined by windows, e.g., in mmeapi.h -- which breaks the build...thanks
+    important: WAVE_FORMAT_MS_PCM must be 1, as WAV format tag | 1.5.0.0 (ge)
+    ------------------------------------------------------------------------- */
+    /* WAVE_FORMAT_PCM                  = 0x0001, */    /* Microsoft PCM format */
     WAVE_FORMAT_MS_ADPCM                = 0x0002,       /* Microsoft ADPCM */
     WAVE_FORMAT_IEEE_FLOAT              = 0x0003,       /* Micrososft 32 bit float format */
     WAVE_FORMAT_VSELP                   = 0x0004,       /* Compaq Computer Corporation */
 #endif
 /*
 ** Do not edit or modify anything in this comment block.
 ** The arch-tag line is a file identity tag for the GNU Arch
 ** revision control system.
 **
 ** arch-tag: 877fde12-9be3-4a31-8a5a-fdae39958613
 */
 /*
 ** Copyright (C) 1999-2001 Erik de Castro Lopo <erikd@mega-nerd.com>
 **
 ** This program is free software; you can redistribute it and/or modify
 ** it under the terms of the GNU Lesser General Public License as published by
 ** the Free Software Foundation; either version 2.1 of the License, or
 ** (at your option) any later version.
 **
 ** This program is distributed in the hope that it will be useful,
 ** but WITHOUT ANY WARRANTY; without even the implied warranty of
 ** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 ** GNU Lesser General Public License for more details.
 **
 ** You should have received a copy of the GNU Lesser General Public License
 ** along with this program; if not, write to the Free Software
 ** Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
 */
 /*
 ** This file is not the same as the original file from Sun Microsystems. Nearly
 ** all the original definitions and function prototypes that were in the file
 ** of this name have been moved to private.h.
 */
 #ifndef G72X_HEADER_FILE
 #define G72X_HEADER_FILE
 /*
 ** Number of samples per block to process.
 ** Must be a common multiple of possible bits per sample : 2, 3, 4, 5 and 8.
 */
 #define G72x_BLOCK_SIZE     (3*5*8)
 /*
 **  Identifiers for the differing kinds of G72x ADPCM codecs.
 **  The identifiers also define the number of encoded bits per sample.
 */
 enum
 {   G723_16_BITS_PER_SAMPLE = 2,
     G723_24_BITS_PER_SAMPLE = 3,
     G723_40_BITS_PER_SAMPLE = 5,
     G721_32_BITS_PER_SAMPLE = 4,
     G721_40_BITS_PER_SAMPLE = 5,
     G723_16_SAMPLES_PER_BLOCK = G72x_BLOCK_SIZE,
     G723_24_SAMPLES_PER_BLOCK = G723_24_BITS_PER_SAMPLE * (G72x_BLOCK_SIZE / G723_24_BITS_PER_SAMPLE),
     G723_40_SAMPLES_PER_BLOCK = G723_40_BITS_PER_SAMPLE * (G72x_BLOCK_SIZE / G723_40_BITS_PER_SAMPLE),
     G721_32_SAMPLES_PER_BLOCK = G72x_BLOCK_SIZE,
     G721_40_SAMPLES_PER_BLOCK = G721_40_BITS_PER_SAMPLE * (G72x_BLOCK_SIZE / G721_40_BITS_PER_SAMPLE),
     G721_32_BYTES_PER_BLOCK = (G721_32_BITS_PER_SAMPLE * G72x_BLOCK_SIZE) / 8,
     G721_40_BYTES_PER_BLOCK = (G721_40_BITS_PER_SAMPLE * G72x_BLOCK_SIZE) / 8
 } ;
 /*
 ** This is the public structure for passing data between the caller and
 ** the G72x encoder and decoder.
 ** The private array is used by the encoder and decoder for internal
 ** state information and should not be changed in any way by the caller.
 ** When decoding or encoding a stream, the same instance of this struct
 ** correct state data between calls.
 */
 typedef struct
 {   /* Private data. Don't mess with it. */
     unsigned long   sprivateo [256 / sizeof (long)] ;
     /* Public data. Read only. */
     int             blocksize, max_bytes, samplesperblock, bytesperblock ;
 int g72x_decode_block (G72x_DATA *data) ;
 /*
 **  The caller fills data->block with data->bytes bytes before calling the
 **  function. The value data->bytes must be an integer multiple of
 **  data->blocksize and be <= data->max_bytes.
 **  When it returns, the caller can read out data->samples samples.
 */
 int g72x_encode_block (G72x_DATA *data) ;
 /*
 **  The caller fills state->samples some integer multiple data->samples_per_block
 **  (up to G72x_BLOCK_SIZE) samples before calling the function.
 **  When it returns, the caller can read out bytes encoded bytes.
 */
 #endif /* !G72X_HEADER_FILE */
 /*
 ** Do not edit or modify anything in this comment block.
 ** The arch-tag line is a file identity tag for the GNU Arch
 ** revision control system.
 **
 ** arch-tag: 6ca84e5f-f932-4ba1-87ee-37056d921621
 /* Added by Erik de Castro Lopo */
 #define USE_FLOAT_MUL
 #define FAST
 #define WAV49
 /* Added by Erik de Castro Lopo */
 typedef unsigned short      uword;      /* unsigned word    */
 typedef unsigned int        ulongword;  /* unsigned longword    */
 struct gsm_state
 {   word            dp0[ 280 ] ;
     word            z1;         /* preprocessing.c, Offset_com. */
 word    gsm_asr         (word a, int n) ;
 /*
  *  Inlined functions from add.h
  */
 static C_INLINE longword
 static C_INLINE longword
 GSM_L_ADD (longword a, longword b)
 {   ulongword utmp ;
     if (a < 0 && b < 0)
     {   utmp = (ulongword)-((a) + 1) + (ulongword)-((b) + 1) ;
         return (utmp >= (ulongword) MAX_LONGWORD) ? MIN_LONGWORD : -(longword)utmp-2 ;
         } ;
     if (a > 0 && b > 0)
     {   utmp = (ulongword) a + (ulongword) b ;
         return (utmp >= (ulongword) MAX_LONGWORD) ? MAX_LONGWORD : utmp ;
         } ;
     return a + b ;
 } /* GSM_L_ADD */
 {   longword ltmp ;
     ltmp = ((longword) a) - ((longword) b) ;
     if (ltmp >= MAX_WORD)
         ltmp = MAX_WORD ;
     else if (ltmp <= MIN_WORD)
         ltmp = MIN_WORD ;
     return ltmp ;
 } /* GSM_SUB */
 void Gsm_Encoding (
         struct gsm_state * S,
         word    * e,
         word    * ep,
         word    * xmaxc,
         word    * Mc,
         word    * xMc) ;
 void Gsm_Short_Term_Analysis_Filter (
 #endif  /* PRIVATE_H */
 /*
 ** Do not edit or modify anything in this comment block.
 ** The arch-tag line is a file identity tag for the GNU Arch
 ** revision control system.
 **
 ** arch-tag: 8bc5fdf2-e8c8-4686-9bd7-a30b512bef0c
     {   int res [2] ;
         __asm__ __volatile__
-        (   "fctiw	%1, %1\n\t"
+        (   "fctiw    %1, %1\n\t"
-            "stfd	%1, %0"
+            "stfd    %1, %0"
             : "=m" (res)    /* Output */
             : "f" (in)      /* Input */
             : "memory"
     {   int res [2] ;
         __asm__ __volatile__
-        (   "fctiw	%1, %1\n\t"
+        (   "fctiw    %1, %1\n\t"
-            "stfd	%1, %0"
+            "stfd    %1, %0"
             : "=m" (res)    /* Output */
             : "f" (in)      /* Input */
             : "memory"
 /*
 ** Do not edit or modify anything in this comment block.
 ** The arch-tag line is a file identity tag for the GNU Arch
 ** revision control system.
 **
 ** arch-tag: 42db1693-ff61-4051-bac1-e4d24c4e30b7
 */
 /*
 ** Do not edit or modify anything in this comment block.
 ** The arch-tag line is a file identity tag for the GNU Arch
 ** revision control system.
 **
 ** arch-tag: 253aea6d-6299-46fd-8d06-bc5f6224c8fe

chuginate/template/chuck/include/util_string.h+7−3

 std::string rtrim( const std::string & val );
 // argument extraction
 t_CKBOOL extract_args( const std::string & token,
                        std::string & filename,
                        std::vector<std::string> & args );
 std::string get_full_path( const std::string & fp );
 // currently just expands ~ to HOME and ~user to user's home directory
-std::string expand_filepath( std::string & fp );
+std::string expand_filepath( std::string & fp, t_CKBOOL ensurePathExists = TRUE );
+// get directory portion of a filepath (minus the file itself)
 std::string extract_filepath_dir(std::string &filepath);
 // convert \ to / (on Windows)
 // determine if the last characters of str match end exactly
 // e.g. to test file extension
-int str_endsin(const char *str, const char *end);
+t_CKBOOL str_endsin(const char *str, const char *end);
+// check if path is absolute on the underlying platform
+t_CKBOOL is_absolute_path( const std::string & path );
 //-----------------------------------------------------------------------------
 // name: parse_path_list()

chuginate/template/chuck/include/util_thread.h+18−18

@@ -148,47 +148,47 @@ protected: · 147 unmodified lines
148	//-----------------------------------------------------------------------------	148	//-----------------------------------------------------------------------------
149	// name: XWriteThread()	149	// name: XWriteThread()
150	// desc: utility class for scheduling writes to be executed on a separate	150	// desc: utility class for scheduling writes to be executed on a separate
151	// thread.	151	// thread.
152	//-----------------------------------------------------------------------------	152	//-----------------------------------------------------------------------------
153	class XWriteThread	153	class XWriteThread
154	{	154	{
155	public:	155	public:
156	// get the shared instance	156	// get the shared instance
157	static XWriteThread * shared();	157	static XWriteThread * shared();
158	// static buffer size	158	// static buffer size
159	const static size_t PRODUCER_BUFFER_SIZE;	159	const static size_t PRODUCER_BUFFER_SIZE;
160		160
161	public:	161	public:
162	// constructor	162	// constructor
163	XWriteThread( size_t data_buffer_size = 4096, size_t msg_buffer_size = 32 );	163	XWriteThread( size_t data_buffer_size = 4096, size_t msg_buffer_size = 32 );
164		164
165	public:	165	public:
166	size_t fwrite( const void * ptr, size_t size, size_t nitems, FILE * stream );	166	size_t fwrite( const void * ptr, size_t size, size_t nitems, FILE * stream );
167	int fseek( FILE * stream, long offset, int whence );	167	int fseek( FILE * stream, long offset, int whence );
168	int fflush( FILE * stream );	168	int fflush( FILE * stream );
169	int fclose( FILE * stream );	169	int fclose( FILE * stream );
170		170
171	// DO NOT DELETE INSTANCES OF XWriteThread	171	// DO NOT DELETE INSTANCES OF XWriteThread
172	// instead call shutdown and they will be cleaned up in the background	172	// instead call shutdown and they will be cleaned up in the background
173	void shutdown();	173	void shutdown();
174		174
175	private:	175	private:
176	// DO NOT DELETE INSTANCES OF XWriteThread	176	// DO NOT DELETE INSTANCES OF XWriteThread
177	// instead call shutdown and they will be cleaned up in the background	177	// instead call shutdown and they will be cleaned up in the background
178	~XWriteThread();	178	~XWriteThread();
179		179
180	// flush	180	// flush
181	void flush_data_buffer();	181	void flush_data_buffer();
182		182
183	// callback	183	// callback
184	#if ( defined(__PLATFORM_MACOSX__) \|\| defined(__PLATFORM_LINUX__) \|\| defined(__WINDOWS_PTHREAD__) )	184	#if ( defined(__PLATFORM_MACOSX__) \|\| defined(__PLATFORM_LINUX__) \|\| defined(__WINDOWS_PTHREAD__) )
185	static void * write_cb( void * _thiss );	185	static void * write_cb( void * _thiss );
186	#elif defined(__PLATFORM_WIN32__)	186	#elif defined(__PLATFORM_WIN32__)
187	static unsigned THREAD_TYPE write_cb( void * _thiss );	187	static unsigned THREAD_TYPE write_cb( void * _thiss );
188	#endif	188	#endif
189		189
190	// shared instance	190	// shared instance
191	static XWriteThread * o_defaultWriteThread;	191	static XWriteThread * o_defaultWriteThread;
192		192
193	private:	193	private:
194	t_CKBOOL m_thread_exit;	194	t_CKBOOL m_thread_exit;
@@ -198,10 +198,10 @@ private: · 3 unmodified lines
198	t_CKBYTE * m_thread_buffer;	198	t_CKBYTE * m_thread_buffer;
199	FILE * m_stream;	199	FILE * m_stream;
200		200
201	// internal message format	201	// internal message format
202	struct Message	202	struct Message
203	{	203	{
204	// operation type	204	// operation type
205	enum	205	enum
206	{	206	{
207	WRITE,	207	WRITE,
@@ -210,18 +210,18 @@ private: · 2 unmodified lines
210	CLOSE,	210	CLOSE,
211	SHUTDOWN	211	SHUTDOWN
212	} operation;	212	} operation;
213		213
214	// file pointer	214	// file pointer
215	FILE * file;	215	FILE * file;
216		216
217	// size / offset	217	// size / offset
218	union	218	union
219	{	219	{
220	struct	220	struct
221	{	221	{
222	size_t data_size;	222	size_t data_size;
223	} write;	223	} write;
224		224
225	struct	225	struct
226	{	226	{
227	long offset;	227	long offset;
@@ -233,7 +233,7 @@ private: · 5 unmodified lines
233	Message() : file(NULL) { }	233	Message() : file(NULL) { }
234	};	234	};
235		235
236	// circular buffer	236	// circular buffer
237	CircularBuffer<Message> * m_msg_buffer;	237	CircularBuffer<Message> * m_msg_buffer;
238	};	238	};
239		239

aligning headers with 1.5-beta; Bitcrusher crushing a bit better; removing Faust osx -lcrypto dependency

Keyboard shortcuts

General

Issues and pull requests

Issues, pull requests and Inbox

Repository code

@@ -164,7 +164,7 @@ struct Chuck_Global_Request · 163 unmodified lines
164	// chuck_msg	164	// chuck_msg
165	Chuck_Execute_Chuck_Msg_Request* executeChuckMsgRequest;	165	Chuck_Execute_Chuck_Msg_Request* executeChuckMsgRequest;
166	};	166	};
167		167
168	Chuck_Global_Request()	168	Chuck_Global_Request()
169	{	169	{
170	retries = 0;	170	retries = 0;
@@ -183,7 +183,7 @@ struct Chuck_Globals_Manager · 12 unmodified lines
183	public:	183	public:
184	Chuck_Globals_Manager( Chuck_VM * vm );	184	Chuck_Globals_Manager( Chuck_VM * vm );
185	~Chuck_Globals_Manager();	185	~Chuck_Globals_Manager();
186		186
187	public:	187	public:
188	// REFACTOR-2017: externally accessible + global variables.	188	// REFACTOR-2017: externally accessible + global variables.
189	// use these getters and setters from outside the audio thread	189	// use these getters and setters from outside the audio thread
@@ -191,17 +191,17 @@ public: · 1 unmodified line
191	t_CKBOOL getGlobalInt( const char * name, void (callback)(const char, t_CKINT) );	191	t_CKBOOL getGlobalInt( const char * name, void (callback)(const char, t_CKINT) );
192	t_CKBOOL getGlobalInt( const char * name, t_CKINT callbackID, void (*callback)(t_CKINT, t_CKINT) );	192	t_CKBOOL getGlobalInt( const char * name, t_CKINT callbackID, void (*callback)(t_CKINT, t_CKINT) );
193	t_CKBOOL setGlobalInt( const char * name, t_CKINT val );	193	t_CKBOOL setGlobalInt( const char * name, t_CKINT val );
194		194
195	t_CKBOOL getGlobalFloat( const char * name, void (*callback)(t_CKFLOAT) );	195	t_CKBOOL getGlobalFloat( const char * name, void (*callback)(t_CKFLOAT) );
196	t_CKBOOL getGlobalFloat( const char * name, void (callback)(const char, t_CKFLOAT) );	196	t_CKBOOL getGlobalFloat( const char * name, void (callback)(const char, t_CKFLOAT) );
197	t_CKBOOL getGlobalFloat( const char * name, t_CKINT callbackID, void (*callback)(t_CKINT, t_CKFLOAT) );	197	t_CKBOOL getGlobalFloat( const char * name, t_CKINT callbackID, void (*callback)(t_CKINT, t_CKFLOAT) );
198	t_CKBOOL setGlobalFloat( const char * name, t_CKFLOAT val );	198	t_CKBOOL setGlobalFloat( const char * name, t_CKFLOAT val );
199		199
200	t_CKBOOL getGlobalString( const char * name, void (callback)(const char) );	200	t_CKBOOL getGlobalString( const char * name, void (callback)(const char) );
201	t_CKBOOL getGlobalString( const char * name, void (callback)(const char, const char*) );	201	t_CKBOOL getGlobalString( const char * name, void (callback)(const char, const char*) );
202	t_CKBOOL getGlobalString( const char * name, t_CKINT callbackID, void (callback)(t_CKINT, const char) );	202	t_CKBOOL getGlobalString( const char * name, t_CKINT callbackID, void (callback)(t_CKINT, const char) );
203	t_CKBOOL setGlobalString( const char * name, const char * val );	203	t_CKBOOL setGlobalString( const char * name, const char * val );
204		204
205	t_CKBOOL signalGlobalEvent( const char * name );	205	t_CKBOOL signalGlobalEvent( const char * name );
206	t_CKBOOL broadcastGlobalEvent( const char * name );	206	t_CKBOOL broadcastGlobalEvent( const char * name );
207	t_CKBOOL listenForGlobalEvent( const char * name, void (*callback)(void), t_CKBOOL listen_forever );	207	t_CKBOOL listenForGlobalEvent( const char * name, void (*callback)(void), t_CKBOOL listen_forever );
@@ -210,9 +210,9 @@ public: · 2 unmodified lines
210	t_CKBOOL stopListeningForGlobalEvent( const char * name, void (*callback)(void) );	210	t_CKBOOL stopListeningForGlobalEvent( const char * name, void (*callback)(void) );
211	t_CKBOOL stopListeningForGlobalEvent( const char * name, void (callback)(const char) );	211	t_CKBOOL stopListeningForGlobalEvent( const char * name, void (callback)(const char) );
212	t_CKBOOL stopListeningForGlobalEvent( const char * name, t_CKINT callbackID, void (*callback)(t_CKINT) );	212	t_CKBOOL stopListeningForGlobalEvent( const char * name, t_CKINT callbackID, void (*callback)(t_CKINT) );
213		213
214	t_CKBOOL getGlobalUGenSamples( const char * name, SAMPLE* buffer, int numFrames );	214	t_CKBOOL getGlobalUGenSamples( const char * name, SAMPLE* buffer, int numFrames );
215		215
216	t_CKBOOL setGlobalIntArray( const char * name, t_CKINT arrayValues[], t_CKUINT numValues );	216	t_CKBOOL setGlobalIntArray( const char * name, t_CKINT arrayValues[], t_CKUINT numValues );
217	t_CKBOOL getGlobalIntArray( const char * name, void (*callback)(t_CKINT[], t_CKUINT) );	217	t_CKBOOL getGlobalIntArray( const char * name, void (*callback)(t_CKINT[], t_CKUINT) );
218	t_CKBOOL getGlobalIntArray( const char * name, void (callback)(const char, t_CKINT[], t_CKUINT) );	218	t_CKBOOL getGlobalIntArray( const char * name, void (callback)(const char, t_CKINT[], t_CKUINT) );
@@ -225,7 +225,7 @@ public: · 6 unmodified lines
225	t_CKBOOL getGlobalAssociativeIntArrayValue( const char * name, const char * key, void (*callback)(t_CKINT) );	225	t_CKBOOL getGlobalAssociativeIntArrayValue( const char * name, const char * key, void (*callback)(t_CKINT) );
226	t_CKBOOL getGlobalAssociativeIntArrayValue( const char * name, const char * key, void (callback)(const char, t_CKINT) );	226	t_CKBOOL getGlobalAssociativeIntArrayValue( const char * name, const char * key, void (callback)(const char, t_CKINT) );
227	t_CKBOOL getGlobalAssociativeIntArrayValue( const char * name, t_CKINT callbackID, const char * key, void (*callback)(t_CKINT, t_CKINT) );	227	t_CKBOOL getGlobalAssociativeIntArrayValue( const char * name, t_CKINT callbackID, const char * key, void (*callback)(t_CKINT, t_CKINT) );
228		228
229	t_CKBOOL setGlobalFloatArray( const char * name, t_CKFLOAT arrayValues[], t_CKUINT numValues );	229	t_CKBOOL setGlobalFloatArray( const char * name, t_CKFLOAT arrayValues[], t_CKUINT numValues );
230	t_CKBOOL getGlobalFloatArray( const char * name, void (*callback)(t_CKFLOAT[], t_CKUINT) );	230	t_CKBOOL getGlobalFloatArray( const char * name, void (*callback)(t_CKFLOAT[], t_CKUINT) );
231	t_CKBOOL getGlobalFloatArray( const char * name, void (callback)(const char, t_CKFLOAT[], t_CKUINT) );	231	t_CKBOOL getGlobalFloatArray( const char * name, void (callback)(const char, t_CKFLOAT[], t_CKUINT) );
@@ -238,11 +238,11 @@ public: · 6 unmodified lines
238	t_CKBOOL getGlobalAssociativeFloatArrayValue( const char * name, const char * key, void (*callback)(t_CKFLOAT) );	238	t_CKBOOL getGlobalAssociativeFloatArrayValue( const char * name, const char * key, void (*callback)(t_CKFLOAT) );
239	t_CKBOOL getGlobalAssociativeFloatArrayValue( const char * name, const char * key, void (callback)(const char, t_CKFLOAT) );	239	t_CKBOOL getGlobalAssociativeFloatArrayValue( const char * name, const char * key, void (callback)(const char, t_CKFLOAT) );
240	t_CKBOOL getGlobalAssociativeFloatArrayValue( const char * name, t_CKINT callbackID, const char * key, void (*callback)(t_CKINT, t_CKFLOAT) );	240	t_CKBOOL getGlobalAssociativeFloatArrayValue( const char * name, t_CKINT callbackID, const char * key, void (*callback)(t_CKINT, t_CKFLOAT) );
241		241
242	public:	242	public:
243	// run Chuck_Msg in the globals order	243	// run Chuck_Msg in the globals order
244	t_CKBOOL execute_chuck_msg_with_globals( Chuck_Msg* msg );	244	t_CKBOOL execute_chuck_msg_with_globals( Chuck_Msg* msg );
245		245
246	public:	246	public:
247	// REFACTOR-2017: externally accessible + global variables.	247	// REFACTOR-2017: externally accessible + global variables.
248	// WARNING: these internal functions are to be used only by other	248	// WARNING: these internal functions are to be used only by other
@@ -250,25 +250,25 @@ public: · 1 unmodified line
250	t_CKBOOL init_global_int( const std::string & name );	250	t_CKBOOL init_global_int( const std::string & name );
251	t_CKINT get_global_int_value( const std::string & name );	251	t_CKINT get_global_int_value( const std::string & name );
252	t_CKINT* get_ptr_to_global_int( const std::string & name );	252	t_CKINT* get_ptr_to_global_int( const std::string & name );
253		253
254	t_CKBOOL init_global_float( const std::string & name );	254	t_CKBOOL init_global_float( const std::string & name );
255	t_CKFLOAT get_global_float_value( const std::string & name );	255	t_CKFLOAT get_global_float_value( const std::string & name );
256	t_CKFLOAT* get_ptr_to_global_float( const std::string & name );	256	t_CKFLOAT* get_ptr_to_global_float( const std::string & name );
257		257
258	t_CKBOOL init_global_string( const std::string & name );	258	t_CKBOOL init_global_string( const std::string & name );
259	Chuck_String* get_global_string( const std::string & name );	259	Chuck_String* get_global_string( const std::string & name );
260	Chuck_String** get_ptr_to_global_string( const std::string & name );	260	Chuck_String** get_ptr_to_global_string( const std::string & name );
261		261
262	t_CKBOOL init_global_event( const std::string & name, Chuck_Type* type );	262	t_CKBOOL init_global_event( const std::string & name, Chuck_Type* type );
263	Chuck_Event* get_global_event( const std::string & name );	263	Chuck_Event* get_global_event( const std::string & name );
264	Chuck_Event** get_ptr_to_global_event( const std::string & name );	264	Chuck_Event** get_ptr_to_global_event( const std::string & name );
265		265
266	t_CKBOOL init_global_ugen( const std::string & name, Chuck_Type* type );	266	t_CKBOOL init_global_ugen( const std::string & name, Chuck_Type* type );
267	t_CKBOOL is_global_ugen_init( const std::string & name );	267	t_CKBOOL is_global_ugen_init( const std::string & name );
268	t_CKBOOL is_global_ugen_valid( const std::string & name );	268	t_CKBOOL is_global_ugen_valid( const std::string & name );
269	Chuck_UGen* get_global_ugen( const std::string & name );	269	Chuck_UGen* get_global_ugen( const std::string & name );
270	Chuck_UGen** get_ptr_to_global_ugen( const std::string & name );	270	Chuck_UGen** get_ptr_to_global_ugen( const std::string & name );
271		271
272	t_CKBOOL init_global_array( const std::string & name, Chuck_Type* type, te_GlobalType arr_type );	272	t_CKBOOL init_global_array( const std::string & name, Chuck_Type* type, te_GlobalType arr_type );
273	Chuck_Object* get_global_array( const std::string & name );	273	Chuck_Object* get_global_array( const std::string & name );
274	Chuck_Object** get_ptr_to_global_array( const std::string & name );	274	Chuck_Object** get_ptr_to_global_array( const std::string & name );
@@ -282,24 +282,24 @@ public: · 7 unmodified lines
282	t_CKBOOL is_global_object_valid( const std::string & name );	282	t_CKBOOL is_global_object_valid( const std::string & name );
283	Chuck_Object* get_global_object( const std::string & name );	283	Chuck_Object* get_global_object( const std::string & name );
284	Chuck_Object** get_ptr_to_global_object( const std::string & name );	284	Chuck_Object** get_ptr_to_global_object( const std::string & name );
285		285
286	t_CKBOOL should_call_global_ctor( const std::string & name, te_GlobalType type );	286	t_CKBOOL should_call_global_ctor( const std::string & name, te_GlobalType type );
287	void global_ctor_was_called( const std::string & name, te_GlobalType type );	287	void global_ctor_was_called( const std::string & name, te_GlobalType type );
288		288
289	// global variables -- clean up	289	// global variables -- clean up
290	void cleanup_global_variables();	290	void cleanup_global_variables();
291		291
292	public: // these should ever ONLY be called from within the VM	292	public: // these should ever ONLY be called from within the VM
293	// request queue: add, query for size	293	// request queue: add, query for size
294	t_CKBOOL add_request( Chuck_Global_Request request );	294	t_CKBOOL add_request( Chuck_Global_Request request );
295	t_CKBOOL more_requests();	295	t_CKBOOL more_requests();
296	// REFACTOR-2017: execute the messages from the global queue	296	// REFACTOR-2017: execute the messages from the global queue
297	void handle_global_queue_messages();	297	void handle_global_queue_messages();
298		298
299	private:	299	private:
300	// ptr to my vm	300	// ptr to my vm
301	Chuck_VM * m_vm;	301	Chuck_VM * m_vm;
302		302
303	// global variables -- storage	303	// global variables -- storage
304	std::map< std::string, Chuck_Global_Int_Container* > m_global_ints;	304	std::map< std::string, Chuck_Global_Int_Container* > m_global_ints;
305	std::map< std::string, Chuck_Global_Float_Container* > m_global_floats;	305	std::map< std::string, Chuck_Global_Float_Container* > m_global_floats;
@@ -311,7 +311,7 @@ private: · 5 unmodified lines
311		311
312	// global variables -- messages for set, get, etc.	312	// global variables -- messages for set, get, etc.
313	XCircleBuffer< Chuck_Global_Request > m_global_request_queue;	313	XCircleBuffer< Chuck_Global_Request > m_global_request_queue;
314		314
315	// retry queue: sometimes a request comes through exactly 1 sample	315	// retry queue: sometimes a request comes through exactly 1 sample
316	// before the relevant global variable is constructed	316	// before the relevant global variable is constructed
317	// (e.g. signalEvent before the compileCode that would construct the event)	317	// (e.g. signalEvent before the compileCode that would construct the event)

@@ -38,11 +38,11 @@ · 37 unmodified lines
38	/************************************************************************/	38	/************************************************************************/
39	/*! \class RtMidiError	39	/*! \class RtMidiError
40	\brief Exception handling class for RtAudio & RtMidi.	40	\brief Exception handling class for RtAudio & RtMidi.
41		41
42	The RtMidiError class is quite simple but it does allow errors to be	42	The RtMidiError class is quite simple but it does allow errors to be
43	"caught" by RtMidiError::Type. See the RtAudio and RtMidi	43	"caught" by RtMidiError::Type. See the RtAudio and RtMidi
44	documentation to know which methods can throw an RtMidiError.	44	documentation to know which methods can throw an RtMidiError.
45		45
46	*/	46	*/
47	/************************************************************************/	47	/************************************************************************/
48		48
@@ -70,26 +70,26 @@ public: · 21 unmodified lines
70	SYSTEM_ERROR, /!< A system error occured. /	70	SYSTEM_ERROR, /!< A system error occured. /
71	THREAD_ERROR /!< A thread error occured. /	71	THREAD_ERROR /!< A thread error occured. /
72	};	72	};
73		73
74	//! The constructor.	74	//! The constructor.
75	RtMidiError( const std::string& message, Type type = RtMidiError::UNSPECIFIED )	75	RtMidiError( const std::string& message, Type type = RtMidiError::UNSPECIFIED )
76	throw() : message_(message), type_(type) {}	76	throw() : message_(message), type_(type) {}
77		77
78	//! The destructor.	78	//! The destructor.
79	virtual ~RtMidiError( void ) throw() {}	79	virtual ~RtMidiError( void ) throw() {}
80		80
81	//! Prints thrown error message to stderr.	81	//! Prints thrown error message to stderr.
82	virtual void printMessage( void ) const throw() { std::cerr << '\n' << message_ << "\n\n"; }	82	virtual void printMessage( void ) const throw() { std::cerr << '\n' << message_ << "\n\n"; }
83		83
84	//! Returns the thrown error message type.	84	//! Returns the thrown error message type.
85	virtual const Type& getType(void) const throw() { return type_; }	85	virtual const Type& getType(void) const throw() { return type_; }
86		86
87	//! Returns the thrown error message string.	87	//! Returns the thrown error message string.
88	virtual const std::string& getMessage(void) const throw() { return message_; }	88	virtual const std::string& getMessage(void) const throw() { return message_; }
89		89
90	//! Returns the thrown error message as a c-style string.	90	//! Returns the thrown error message as a c-style string.
91	virtual const char* what( void ) const throw() { return message_.c_str(); }	91	virtual const char* what( void ) const throw() { return message_.c_str(); }
92		92
93	protected:	93	protected:
94	std::string message_;	94	std::string message_;
95	Type type_;	95	Type type_;
@@ -253,8 +253,8 @@ class RtMidiIn : public RtMidi · 157 unmodified lines
253		253
254	// A MIDI structure used internally by the class to store incoming	254	// A MIDI structure used internally by the class to store incoming
255	// messages. Each message represents one and only one MIDI message.	255	// messages. Each message represents one and only one MIDI message.
256	struct MidiMessage {	256	struct MidiMessage {
257	std::vector<unsigned char> bytes;	257	std::vector<unsigned char> bytes;
258	double timeStamp;	258	double timeStamp;
259		259
260	// Default constructor.	260	// Default constructor.