void
TextContent::connect_tcp( const char * hostname, int port ) {
if ( !_tcp ) {
_tcp = ck_tcp_create ( 0 );
if ( !_tcp )
fprintf(stderr, "textcontent:: cannot open socket\n");
}
if ( _tcp && ( !_connected || hostname || port != _port ) ) {
_connected = false;
if ( hostname ) strncpy ( _hostname, hostname, 512 );
if ( port != _port ) _port = port;
if ( !ck_connect ( _tcp, _hostname, _port ) ) {
fprintf(stderr, "textcontent :: socket could not connect to %s:%i...\n", _hostname, _port );
}
else _connected = true;
}
}
extern "C" int chuck_main( int argc, const char ** argv )
#endif
{
Chuck_Compiler * compiler = NULL;
Chuck_VM * vm = NULL;
Chuck_VM_Code * code = NULL;
Chuck_VM_Shred * shred = NULL;
t_CKBOOL enable_audio = TRUE;
t_CKBOOL vm_halt = TRUE;
t_CKUINT srate = SAMPLING_RATE_DEFAULT;
t_CKUINT buffer_size = BUFFER_SIZE_DEFAULT;
t_CKUINT num_buffers = NUM_BUFFERS_DEFAULT;
t_CKUINT dac = 0;
t_CKUINT adc = 0;
t_CKUINT dac_chans = 2;
t_CKUINT adc_chans = 2;
t_CKBOOL dump = FALSE;
t_CKBOOL probe = FALSE;
t_CKBOOL set_priority = FALSE;
t_CKBOOL auto_depend = FALSE;
t_CKBOOL block = FALSE;
t_CKBOOL enable_shell = FALSE;
t_CKBOOL no_vm = FALSE;
t_CKBOOL load_hid = FALSE;
t_CKBOOL enable_server = TRUE;
t_CKBOOL do_watchdog = TRUE;
t_CKINT adaptive_size = 0;
t_CKINT log_level = CK_LOG_CORE;
t_CKINT deprecate_level = 1; // warn
string filename = "";
vector<string> args;
#if defined(__DISABLE_WATCHDOG__)
do_watchdog = FALSE;
#elif defined(__MACOSX_CORE__)
do_watchdog = TRUE;
#elif defined(__PLATFORM_WIN32__) && !defined(__WINDOWS_PTHREAD__)
do_watchdog = TRUE;
#else
do_watchdog = FALSE;
#endif
t_CKUINT files = 0;
t_CKUINT count = 1;
t_CKINT i;
// set log level
EM_setlog( log_level );
// parse command line args
for( i = 1; i < argc; i++ )
{
if( argv[i][0] == '-' || argv[i][0] == '+' ||
argv[i][0] == '=' || argv[i][0] == '^' || argv[i][0] == '@' )
{
if( !strcmp(argv[i], "--dump") || !strcmp(argv[i], "+d")
|| !strcmp(argv[i], "--nodump") || !strcmp(argv[i], "-d") )
continue;
else if( get_count( argv[i], &count ) )
continue;
else if( !strcmp(argv[i], "--audio") || !strcmp(argv[i], "-a") )
enable_audio = TRUE;
else if( !strcmp(argv[i], "--silent") || !strcmp(argv[i], "-s") )
enable_audio = FALSE;
else if( !strcmp(argv[i], "--halt") || !strcmp(argv[i], "-t") )
vm_halt = TRUE;
else if( !strcmp(argv[i], "--loop") || !strcmp(argv[i], "-l") )
{ vm_halt = FALSE; enable_server = TRUE; }
else if( !strcmp(argv[i], "--server") )
enable_server = TRUE;
else if( !strcmp(argv[i], "--standalone") )
enable_server = FALSE;
else if( !strcmp(argv[i], "--callback") )
block = FALSE;
else if( !strcmp(argv[i], "--blocking") )
block = TRUE;
else if( !strcmp(argv[i], "--hid") )
load_hid = TRUE;
else if( !strcmp(argv[i], "--shell") || !strcmp( argv[i], "-e" ) )
{ enable_shell = TRUE; vm_halt = FALSE; }
else if( !strcmp(argv[i], "--empty") )
no_vm = TRUE;
else if( !strncmp(argv[i], "--srate", 7) )
srate = atoi( argv[i]+7 ) > 0 ? atoi( argv[i]+7 ) : srate;
else if( !strncmp(argv[i], "-r", 2) )
srate = atoi( argv[i]+2 ) > 0 ? atoi( argv[i]+2 ) : srate;
else if( !strncmp(argv[i], "--bufsize", 9) )
buffer_size = atoi( argv[i]+9 ) > 0 ? atoi( argv[i]+9 ) : buffer_size;
else if( !strncmp(argv[i], "-b", 2) )
buffer_size = atoi( argv[i]+2 ) > 0 ? atoi( argv[i]+2 ) : buffer_size;
else if( !strncmp(argv[i], "--bufnum", 8) )
num_buffers = atoi( argv[i]+8 ) > 0 ? atoi( argv[i]+8 ) : num_buffers;
else if( !strncmp(argv[i], "-n", 2) )
num_buffers = atoi( argv[i]+2 ) > 0 ? atoi( argv[i]+2 ) : num_buffers;
else if( !strncmp(argv[i], "--dac", 5) )
dac = atoi( argv[i]+5 ) > 0 ? atoi( argv[i]+5 ) : 0;
else if( !strncmp(argv[i], "--adc", 5) )
adc = atoi( argv[i]+5 ) > 0 ? atoi( argv[i]+5 ) : 0;
else if( !strncmp(argv[i], "--channels", 10) )
dac_chans = adc_chans = atoi( argv[i]+10 ) > 0 ? atoi( argv[i]+10 ) : 2;
else if( !strncmp(argv[i], "-c", 2) )
dac_chans = adc_chans = atoi( argv[i]+2 ) > 0 ? atoi( argv[i]+2 ) : 2;
else if( !strncmp(argv[i], "--out", 5) )
dac_chans = atoi( argv[i]+5 ) > 0 ? atoi( argv[i]+5 ) : 2;
else if( !strncmp(argv[i], "-o", 2) )
dac_chans = atoi( argv[i]+2 ) > 0 ? atoi( argv[i]+2 ) : 2;
else if( !strncmp(argv[i], "--in", 4) )
adc_chans = atoi( argv[i]+4 ) > 0 ? atoi( argv[i]+4 ) : 2;
else if( !strncmp(argv[i], "-i", 2) )
adc_chans = atoi( argv[i]+2 ) > 0 ? atoi( argv[i]+2 ) : 2;
else if( !strncmp(argv[i], "--level", 7) )
{ g_priority = atoi( argv[i]+7 ); set_priority = TRUE; }
else if( !strncmp(argv[i], "--watchdog", 10) )
{ g_watchdog_timeout = atof( argv[i]+10 );
if( g_watchdog_timeout <= 0 ) g_watchdog_timeout = 0.5;
do_watchdog = TRUE; }
else if( !strncmp(argv[i], "--nowatchdog", 12) )
do_watchdog = FALSE;
else if( !strncmp(argv[i], "--remote", 8) )
strcpy( g_host, argv[i]+8 );
else if( !strncmp(argv[i], "@", 1) )
strcpy( g_host, argv[i]+1 );
else if( !strncmp(argv[i], "--port", 6) )
g_port = atoi( argv[i]+6 );
else if( !strncmp(argv[i], "-p", 2) )
g_port = atoi( argv[i]+2 );
else if( !strncmp(argv[i], "--auto", 6) )
auto_depend = TRUE;
else if( !strncmp(argv[i], "-u", 2) )
auto_depend = TRUE;
else if( !strncmp(argv[i], "--log", 5) )
log_level = argv[i][5] ? atoi( argv[i]+5 ) : CK_LOG_INFO;
else if( !strncmp(argv[i], "--verbose", 9) )
log_level = argv[i][9] ? atoi( argv[i]+9 ) : CK_LOG_INFO;
else if( !strncmp(argv[i], "-v", 2) )
log_level = argv[i][2] ? atoi( argv[i]+2 ) : CK_LOG_INFO;
else if( !strncmp(argv[i], "--adaptive", 10) )
adaptive_size = argv[i][10] ? atoi( argv[i]+10 ) : -1;
else if( !strncmp(argv[i], "--deprecate", 11) )
{
// get the rest
string arg = argv[i]+11;
if( arg == ":stop" ) deprecate_level = 0;
else if( arg == ":warn" ) deprecate_level = 1;
else if( arg == ":ignore" ) deprecate_level = 2;
else
{
// error
fprintf( stderr, "[chuck]: invalid arguments for '--deprecate'...\n" );
fprintf( stderr, "[chuck]: ... (looking for :stop, :warn, or :ignore)\n" );
exit( 1 );
}
}
else if( !strcmp( argv[i], "--probe" ) )
probe = TRUE;
else if( !strcmp( argv[i], "--poop" ) )
uh();
else if( !strcmp( argv[i], "--caution-to-the-wind" ) )
g_enable_system_cmd = TRUE;
else if( !strcmp(argv[i], "--help") || !strcmp(argv[i], "-h")
|| !strcmp(argv[i], "--about") )
{
usage();
exit( 2 );
}
else if( !strcmp( argv[i], "--version" ) )
{
version();
exit( 2 );
}
else
{
// boost log level
g_otf_log = CK_LOG_CORE;
// flag
int is_otf = FALSE;
// log level
EM_setlog( log_level );
// do it
if( otf_send_cmd( argc, argv, i, g_host, g_port, &is_otf ) )
exit( 0 );
// is otf
if( is_otf ) exit( 1 );
// done
fprintf( stderr, "[chuck]: invalid flag '%s'\n", argv[i] );
usage();
exit( 1 );
}
}
else
files++;
}
// log level
EM_setlog( log_level );
// probe
if( probe )
{
Digitalio::probe();
#ifndef __DISABLE_MIDI__
EM_error2b( 0, "" );
probeMidiIn();
EM_error2b( 0, "" );
probeMidiOut();
EM_error2b( 0, "" );
#endif // __DISABLE_MIDI__
// HidInManager::probeHidIn();
// exit
exit( 0 );
}
// check buffer size
buffer_size = ensurepow2( buffer_size );
// check mode and blocking
if( !enable_audio && !block ) block = TRUE;
// audio, boost
if( !set_priority && !block ) g_priority = g_priority_low;
if( !set_priority && !enable_audio ) g_priority = 0x7fffffff;
// set priority
Chuck_VM::our_priority = g_priority;
// set watchdog
g_do_watchdog = do_watchdog;
// set adaptive size
if( adaptive_size < 0 ) adaptive_size = buffer_size;
if ( !files && vm_halt && !enable_shell )
{
fprintf( stderr, "[chuck]: no input files... (try --help)\n" );
exit( 1 );
}
// shell initialization without vm
if( enable_shell && no_vm )
{
// instantiate
g_shell = new Chuck_Shell;
// initialize
if( !init_shell( g_shell, new Chuck_Console, NULL ) )
exit( 1 );
// no vm is needed, just start running the shell now
g_shell->run();
// clean up
SAFE_DELETE( g_shell );
// done
exit( 0 );
}
// make sure vm
if( no_vm )
{
fprintf( stderr, "[chuck]: '--empty' can only be used with shell...\n" );
exit( 1 );
}
// allocate the vm - needs the type system
vm = g_vm = new Chuck_VM;
if( !vm->initialize( enable_audio, vm_halt, srate, buffer_size,
num_buffers, dac, adc, dac_chans, adc_chans,
block, adaptive_size ) )
{
fprintf( stderr, "[chuck]: %s\n", vm->last_error() );
exit( 1 );
}
// allocate the compiler
compiler = g_compiler = new Chuck_Compiler;
// initialize the compiler
if( !compiler->initialize( vm ) )
{
fprintf( stderr, "[chuck]: error initializing compiler...\n" );
exit( 1 );
}
// enable dump
compiler->emitter->dump = dump;
// set auto depend
compiler->set_auto_depend( auto_depend );
// vm synthesis subsystem - needs the type system
if( !vm->initialize_synthesis( ) )
{
fprintf( stderr, "[chuck]: %s\n", vm->last_error() );
exit( 1 );
}
#ifndef __ALTER_HID__
// pre-load hid
if( load_hid ) HidInManager::init();
#endif // __ALTER_HID__
// catch SIGINT
signal( SIGINT, signal_int );
#ifndef __PLATFORM_WIN32__
// catch SIGPIPE
signal( SIGPIPE, signal_pipe );
#endif
// shell initialization
if( enable_shell )
{
// instantiate
g_shell = new Chuck_Shell;
// initialize
if( !init_shell( g_shell, new Chuck_Console, vm ) )
exit( 1 );
}
// set deprecate
compiler->env->deprecate_level = deprecate_level;
// reset count
count = 1;
// log
EM_log( CK_LOG_SEVERE, "starting compilation..." );
// push indent
EM_pushlog();
// loop through and process each file
for( i = 1; i < argc; i++ )
{
// make sure
if( argv[i][0] == '-' || argv[i][0] == '+' )
{
if( !strcmp(argv[i], "--dump") || !strcmp(argv[i], "+d" ) )
compiler->emitter->dump = TRUE;
else if( !strcmp(argv[i], "--nodump") || !strcmp(argv[i], "-d" ) )
compiler->emitter->dump = FALSE;
else
get_count( argv[i], &count );
continue;
}
// parse out command line arguments
if( !extract_args( argv[i], filename, args ) )
{
// error
fprintf( stderr, "[chuck]: malformed filename with argument list...\n" );
fprintf( stderr, " --> '%s'", argv[i] );
return 1;
}
// log
EM_log( CK_LOG_FINE, "compiling '%s'...", filename.c_str() );
// push indent
EM_pushlog();
// parse, type-check, and emit
if( !compiler->go( filename, NULL ) )
return 1;
// get the code
code = compiler->output();
// name it
code->name += string(argv[i]);
// log
EM_log( CK_LOG_FINE, "sporking %d %s...", count,
count == 1 ? "instance" : "instances" );
// spork it
while( count-- )
{
// spork
shred = vm->spork( code, NULL );
// add args
shred->args = args;
}
// pop indent
EM_poplog();
// reset count
count = 1;
}
// pop indent
EM_poplog();
// reset the parser
reset_parse();
// boost priority
if( Chuck_VM::our_priority != 0x7fffffff )
{
// try
if( !Chuck_VM::set_priority( Chuck_VM::our_priority, vm ) )
{
// error
fprintf( stderr, "[chuck]: %s\n", vm->last_error() );
exit( 1 );
}
}
// server
if( enable_server )
{
#ifndef __DISABLE_OTF_SERVER__
// log
EM_log( CK_LOG_SYSTEM, "starting listener on port: %d...", g_port );
// start tcp server
g_sock = ck_tcp_create( 1 );
if( !g_sock || !ck_bind( g_sock, g_port ) || !ck_listen( g_sock, 10 ) )
{
fprintf( stderr, "[chuck]: cannot bind to tcp port %i...\n", g_port );
ck_close( g_sock );
g_sock = NULL;
}
else
{
#if !defined(__PLATFORM_WIN32__) || defined(__WINDOWS_PTHREAD__)
pthread_create( &g_tid_otf, NULL, otf_cb, NULL );
#else
g_tid_otf = CreateThread( NULL, 0, (LPTHREAD_START_ROUTINE)otf_cb, NULL, 0, 0 );
#endif
}
#endif // __DISABLE_OTF_SERVER__
}
else
{
// log
EM_log( CK_LOG_SYSTEM, "OTF server/listener: OFF" );
}
// start shell on separate thread
if( enable_shell )
{
#if !defined(__PLATFORM_WIN32__) || defined(__WINDOWS_PTHREAD__)
pthread_create( &g_tid_shell, NULL, shell_cb, g_shell );
#else
g_tid_shell = CreateThread( NULL, 0, (LPTHREAD_START_ROUTINE)shell_cb, g_shell, 0, 0 );
#endif
}
// run the vm
vm->run();
// detach
all_detach();
// free vm
vm = NULL; SAFE_DELETE( g_vm );
// free the compiler
compiler = NULL; SAFE_DELETE( g_compiler );
// wait for the shell, if it is running
// does the VM reset its priority to normal before exiting?
if( enable_shell )
while( g_shell != NULL )
usleep(10000);
return 0;
}
//-----------------------------------------------------------------------------
// name: start_vm()
// desc: ...
//-----------------------------------------------------------------------------
t_CKBOOL miniAudicle::start_vm()
{
char buffer[1024];
time_t t;
// allocate status buffers
// allocate alternating buffers for VM status messages
num_status_bufs = 4;
status_bufs = new Chuck_VM_Status * [num_status_bufs];
for( size_t i = 0; i < num_status_bufs; i++ )
status_bufs[i] = new Chuck_VM_Status;
status_bufs_read = 0;
status_bufs_write = 0;
// clear shred management structures
last_result.clear();
while( !otf_docids.empty() )
otf_docids.pop();
map< t_CKUINT, vector< t_CKUINT > * >::iterator iter = documents.begin(),
end = documents.end();
for( ; iter != end; iter++ )
iter->second->clear();
shreds.clear();
// clear the class name existence map
class_names->clear();
time(&t);
strncpy( buffer, ctime(&t), 24 );
buffer[24] = '\0';
// log
EM_log( CK_LOG_SYSTEM, "-------( %s )-------", buffer );
EM_log( CK_LOG_SYSTEM, "starting chuck virtual machine..." );
// push log
EM_pushlog();
if( vm == NULL )
{
// log
EM_log( CK_LOG_INFO, "allocating VM..." );
t_CKBOOL enable_audio = vm_options.enable_audio;
t_CKBOOL vm_halt = FALSE;
t_CKUINT srate = vm_options.srate;
t_CKUINT buffer_size = vm_options.buffer_size;
t_CKUINT num_buffers = NUM_BUFFERS_DEFAULT;
t_CKUINT dac = vm_options.dac;
t_CKUINT adc = vm_options.adc;
t_CKBOOL set_priority = FALSE;
t_CKBOOL block = vm_options.enable_block;
t_CKUINT output_channels = vm_options.num_outputs;
t_CKUINT input_channels = vm_options.num_inputs;
// lets make up some magic numbers...
vm_sleep_time = vm_options.buffer_size * 1000000 / vm_options.srate;
vm_sleep_max = 20;
vm_status_timeouts_max = vm_options.buffer_size / 100;
vm_status_timeouts = 0;
// check buffer size
// buffer_size = next_power_2( buffer_size-1 );
// audio, boost
if( !set_priority && !block ) priority = priority_low;
if( !set_priority && !enable_audio ) priority = 0x7fffffff;
// set priority
Chuck_VM::our_priority = priority;
// set watchdog
#ifdef __MACOSX_CORE__
g_do_watchdog = TRUE;
g_watchdog_timeout = .5;
#else
g_do_watchdog = FALSE;
#endif
// allocate the vm - needs the type system
vm = g_vm = new Chuck_VM;
if( !vm->initialize( enable_audio, vm_halt, srate, buffer_size,
num_buffers, dac, adc, output_channels,
input_channels, block ) )
{
fprintf( stderr, "[chuck]: %s\n", vm->last_error() );
// pop
EM_poplog();
return FALSE;
}
// log
EM_log( CK_LOG_INFO, "allocating compiler..." );
// allocate the compiler
g_compiler = compiler = new Chuck_Compiler;
std::list<std::string> library_paths = vm_options.library_paths;
std::list<std::string> named_chugins = vm_options.named_chugins;
// normalize paths
for(std::list<std::string>::iterator i = library_paths.begin();
i != library_paths.end(); i++)
*i = expand_filepath(*i);
for(std::list<std::string>::iterator j = named_chugins.begin();
j != named_chugins.end(); j++)
*j = expand_filepath(*j);
// initialize the compiler
compiler->initialize( vm, library_paths, named_chugins );
// enable dump
compiler->emitter->dump = FALSE;
// set auto depend
compiler->set_auto_depend( FALSE );
// vm synthesis subsystem - needs the type system
if( !vm->initialize_synthesis() )
{
fprintf( stderr, "[chuck]: %s\n", vm->last_error() );
// pop
EM_poplog();
return FALSE;
}
#ifdef __MA_IMPORT_MAUI__
// import api
init_maui( compiler->env );
#endif
for(list<t_CKBOOL (*)(Chuck_Env *)>::iterator i = vm_options.query_funcs.begin(); i != vm_options.query_funcs.end(); i++)
(*i)( compiler->env );
// reset the parser
reset_parse();
Chuck_VM_Code * code = NULL;
Chuck_VM_Shred * shred = NULL;
// whether or not chug should be enabled (added 1.3.0.0)
EM_log( CK_LOG_SEVERE, "pre-loading ChucK libs..." );
EM_pushlog();
// iterate over list of ck files that the compiler found
for( std::list<std::string>::iterator fck = compiler->m_cklibs_to_preload.begin();
fck != compiler->m_cklibs_to_preload.end(); fck++)
{
// the filename
std::string filename = *fck;
// log
EM_log( CK_LOG_SEVERE, "preloading '%s'...", filename.c_str() );
// push indent
EM_pushlog();
// SPENCERTODO: what to do for full path
std::string full_path = filename;
// parse, type-check, and emit
if( compiler->go( filename, NULL, NULL, full_path ) )
{
// TODO: how to compilation handle?
//return 1;
// get the code
code = compiler->output();
// name it - TODO?
// code->name += string(argv[i]);
// spork it
shred = vm->spork( code, NULL );
}
// pop indent
EM_poplog();
}
// clear the list of chuck files to preload
compiler->m_cklibs_to_preload.clear();
// pop log
EM_poplog();
// load user namespace
compiler->env->load_user_namespace();
// start the vm handler threads
#ifndef __PLATFORM_WIN32__
pthread_create( &vm_tid, NULL, vm_cb, NULL );
#else
vm_tid = CreateThread( NULL, 0, (LPTHREAD_START_ROUTINE)vm_cb, NULL, 0, 0 );
#endif
}
// check it
if( !g_forked && vm_options.enable_network )
{
// start tcp server
g_sock = ck_tcp_create( 1 );
if( !g_sock || !ck_bind( g_sock, g_port ) || !ck_listen( g_sock, 10 ) )
{
fprintf( stderr, "[chuck]: cannot bind to tcp port %li...\n", g_port );
ck_close( g_sock );
g_sock = NULL;
}
else
{
#ifndef __PLATFORM_WIN32__
pthread_create( &otf_tid, NULL, otf_cb, NULL );
#else
otf_tid = CreateThread( NULL, 0, (LPTHREAD_START_ROUTINE)otf_cb, NULL, 0, 0 );
#endif
}
g_forked = TRUE;
}
vm_on = TRUE;
// pop
EM_poplog();
return vm_on;
}