/*---------------------------------------------------------------------------- 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 U.S.A. -----------------------------------------------------------------------------*/ //-----------------------------------------------------------------------------// file: chuck.cpp// desc: chuck engine chasis; VM + compiler + state; independent of audio I/O//       REFACTOR-2017//// author: Ge Wang (https://ccrma.stanford.edu/~ge/)// date: fall 2017//// additional authors://       Jack Atherton (lja@ccrma.stanford.edu)//       Spencer Salazar (spencer@ccrma.stanford.edu)//-----------------------------------------------------------------------------#include "chuck.h"#include "chuck_errmsg.h"#include "chuck_io.h"#include "chuck_globals.h" // added 1.4.1.0 #ifndef __DISABLE_OTF_SERVER__#include "chuck_otf.h"#include "ulib_machine.h"#endif #ifndef __DISABLE_NETWORK__#include "util_network.h"#endif #include "util_string.h"#include "ugen_stk.h" #ifndef __PLATFORM_WIN32__#include <unistd.h>#include <netinet/in.h>#include <arpa/inet.h>#else#include <direct.h>      // added 1.3.0.0#endif // #ifndef __PLATFORM_WIN32__    // chuck param defaults#define CHUCK_PARAM_SAMPLE_RATE_DEFAULT            "44100"#define CHUCK_PARAM_INPUT_CHANNELS_DEFAULT         "2"#define CHUCK_PARAM_OUTPUT_CHANNELS_DEFAULT        "2"#define CHUCK_PARAM_VM_ADAPTIVE_DEFAULT            "0"#define CHUCK_PARAM_VM_HALT_DEFAULT                "0"#define CHUCK_PARAM_OTF_ENABLE_DEFAULT             "0"#define CHUCK_PARAM_OTF_PORT_DEFAULT               "8888"#define CHUCK_PARAM_DUMP_INSTRUCTIONS_DEFAULT      "0"#define CHUCK_PARAM_DEPRECATE_LEVEL_DEFAULT        "1"#define CHUCK_PARAM_WORKING_DIRECTORY_DEFAULT      ""#define CHUCK_PARAM_CHUGIN_ENABLE_DEFAULT          "1"#define CHUCK_PARAM_HINT_IS_REALTIME_AUDIO_DEFAULT "0"#ifndef __PLATFORM_WIN32__// 1.4.1.0 (ge) changed to ""; was "/usr/local/lib/chuck"// redundant with g_default_chugin_path, which already contains#define CHUCK_PARAM_CHUGIN_DIRECTORY_DEFAULT       ""#else // __PLATFORM_WIN32__// 1.4.1.0 (ge) changed to ""; "C:\\Program Files\\ChucK\\chugins"// redundant with g_default_chugin_path, which already contains#define CHUCK_PARAM_CHUGIN_DIRECTORY_DEFAULT       ""#endif // __PLATFORM_WIN32__#define CHUCK_PARAM_USER_CHUGINS_DEFAULT        std::list<std::string>()#define CHUCK_PARAM_USER_CHUGIN_DIRECTORIES_DEFAULT std::list<std::string>()   // chuck staticsconst char ChucK::VERSION[] = "1.5.0.0-beta-4.14 (numchucks)";t_CKUINT ChucK::o_numVMs = 0;t_CKBOOL ChucK::o_isGlobalInit = FALSE;t_CKBOOL ChucK::enableSystemCall = FALSE;    //-----------------------------------------------------------------------------// name: version()// desc: get chuck version//-----------------------------------------------------------------------------const char * ChucK::version(){    return VERSION;}    //-----------------------------------------------------------------------------// name: intSize()// desc: get chuck int size (in bits)//-----------------------------------------------------------------------------t_CKUINT ChucK::intSize(){    return machine_intsize();}    //-----------------------------------------------------------------------------// name: ChucK()// desc: constructor//-----------------------------------------------------------------------------ChucK::ChucK(){    // instantiate the carrier!    m_carrier = new Chuck_Carrier();    // set reference back to this    m_carrier->chuck = this;    // increment the numChucKs    o_numVMs++;    // initialize default params    initDefaultParams();    // did user init?    m_init = FALSE;    // did user start ChucK?    m_started = FALSE;    // zero out the hook    m_hook = NULL; // m_hook = nullptr     // global init, if needed    if( !o_isGlobalInit ) globalInit();}    //-----------------------------------------------------------------------------// name: ~ChucK()// desc: destructor//-----------------------------------------------------------------------------ChucK::~ChucK(){    // shutdown    shutdown();    // decrement the numChucKs    o_numVMs--;    // clean up the carrier    SAFE_DELETE( m_carrier );}    // REFACTOR-2017: TODO Ge: Implementation of this?//-----------------------------------------------------------------------------// name: ck_param_type// desc: enum for type of param (int, float, string)//-----------------------------------------------------------------------------enum ck_param_type{    ck_param_int, ck_param_float, ck_param_string, ck_param_string_list};    //-----------------------------------------------------------------------------// name: ck_param_types// desc: storage for types of param (int, float, string)//-----------------------------------------------------------------------------std::map< std::string, ck_param_type> ck_param_types;    //-----------------------------------------------------------------------------// name: initDefaultParams()// desc: initialize default params//-----------------------------------------------------------------------------void ChucK::initDefaultParams(){    m_params[CHUCK_PARAM_SAMPLE_RATE] = CHUCK_PARAM_SAMPLE_RATE_DEFAULT;    m_params[CHUCK_PARAM_INPUT_CHANNELS] = CHUCK_PARAM_INPUT_CHANNELS_DEFAULT;    m_params[CHUCK_PARAM_OUTPUT_CHANNELS] = CHUCK_PARAM_OUTPUT_CHANNELS_DEFAULT;    m_params[CHUCK_PARAM_VM_ADAPTIVE] = CHUCK_PARAM_VM_ADAPTIVE_DEFAULT;    m_params[CHUCK_PARAM_VM_HALT] = CHUCK_PARAM_VM_HALT_DEFAULT;    m_params[CHUCK_PARAM_OTF_ENABLE] = CHUCK_PARAM_OTF_ENABLE_DEFAULT;    m_params[CHUCK_PARAM_OTF_PORT] = CHUCK_PARAM_OTF_PORT_DEFAULT;    m_params[CHUCK_PARAM_DUMP_INSTRUCTIONS] = CHUCK_PARAM_DUMP_INSTRUCTIONS_DEFAULT;    m_params[CHUCK_PARAM_DEPRECATE_LEVEL] = CHUCK_PARAM_DEPRECATE_LEVEL_DEFAULT;    m_params[CHUCK_PARAM_WORKING_DIRECTORY] = CHUCK_PARAM_WORKING_DIRECTORY_DEFAULT;    m_params[CHUCK_PARAM_CHUGIN_DIRECTORY] = CHUCK_PARAM_CHUGIN_DIRECTORY_DEFAULT;    m_params[CHUCK_PARAM_CHUGIN_ENABLE] = CHUCK_PARAM_CHUGIN_ENABLE_DEFAULT;    m_listParams[CHUCK_PARAM_USER_CHUGINS] = CHUCK_PARAM_USER_CHUGINS_DEFAULT;    m_listParams[CHUCK_PARAM_USER_CHUGIN_DIRECTORIES] = CHUCK_PARAM_USER_CHUGIN_DIRECTORIES_DEFAULT;    m_params[CHUCK_PARAM_HINT_IS_REALTIME_AUDIO] = CHUCK_PARAM_HINT_IS_REALTIME_AUDIO_DEFAULT;     ck_param_types[CHUCK_PARAM_SAMPLE_RATE]             = ck_param_int;    ck_param_types[CHUCK_PARAM_INPUT_CHANNELS]          = ck_param_int;    ck_param_types[CHUCK_PARAM_OUTPUT_CHANNELS]         = ck_param_int;    ck_param_types[CHUCK_PARAM_VM_ADAPTIVE]             = ck_param_int;    ck_param_types[CHUCK_PARAM_VM_HALT]                 = ck_param_int;    ck_param_types[CHUCK_PARAM_OTF_ENABLE]              = ck_param_int;    ck_param_types[CHUCK_PARAM_OTF_PORT]                = ck_param_int;    ck_param_types[CHUCK_PARAM_DUMP_INSTRUCTIONS]       = ck_param_int;    ck_param_types[CHUCK_PARAM_DEPRECATE_LEVEL]         = ck_param_int;    ck_param_types[CHUCK_PARAM_WORKING_DIRECTORY]       = ck_param_string;    ck_param_types[CHUCK_PARAM_CHUGIN_DIRECTORY]        = ck_param_string;    ck_param_types[CHUCK_PARAM_CHUGIN_ENABLE]           = ck_param_int;    ck_param_types[CHUCK_PARAM_USER_CHUGINS]            = ck_param_string_list;    ck_param_types[CHUCK_PARAM_USER_CHUGIN_DIRECTORIES] = ck_param_string_list;    ck_param_types[CHUCK_PARAM_HINT_IS_REALTIME_AUDIO]  = ck_param_int;}    //-----------------------------------------------------------------------------// name: setParam()// desc: set an int param by name//-----------------------------------------------------------------------------bool ChucK::setParam( const std::string & name, t_CKINT value ){    if( m_params.count( name ) > 0 && ck_param_types[name] == ck_param_int )    {        std::ostringstream s;        s << value;        m_params[name] = s.str();        return TRUE;    }    else    {        return FALSE;    }}    //-----------------------------------------------------------------------------// name: setParamFloat()// desc: set a float param by name//-----------------------------------------------------------------------------bool ChucK::setParamFloat( const std::string & name, t_CKFLOAT value ){    if( m_params.count( name ) > 0 && ck_param_types[name] == ck_param_float )    {        std::ostringstream s;        s << value;        m_params[name] = s.str();        return TRUE;    }    else    {        return FALSE;    }}    //-----------------------------------------------------------------------------// name: setParam()// desc: set a string param by name//-----------------------------------------------------------------------------bool ChucK::setParam( const std::string & name, const std::string & value ){    if( m_params.count( name ) > 0 && ck_param_types[name] == ck_param_string )    {        m_params[name] = value;        return TRUE;    }    else    {        return FALSE;    }}    //-----------------------------------------------------------------------------// name: setParam()// desc: set a string list param by name//-----------------------------------------------------------------------------bool ChucK::setParam( const std::string & name, const std::list< std::string > & value ){    if( m_listParams.count( name ) > 0 &&        ck_param_types[name] == ck_param_string_list )    {        m_listParams[name] = value;        return TRUE;    }    else    {        return FALSE;    }}    //-----------------------------------------------------------------------------// name: getParamInt()// desc: get an int param//-----------------------------------------------------------------------------t_CKINT ChucK::getParamInt( const std::string & key ){    t_CKINT result = 0;    if( m_params.count( key ) > 0 && ck_param_types[key] == ck_param_int )    {        std::istringstream s( m_params[key] );        s >> result;    }    return result;}    //-----------------------------------------------------------------------------// name: getParamFloat()// desc: get a float param//-----------------------------------------------------------------------------t_CKFLOAT ChucK::getParamFloat( const std::string & key ){    t_CKFLOAT result = 0;    if( m_params.count( key ) > 0 && ck_param_types[key] == ck_param_float )    {        std::istringstream s( m_params[key] );        s >> result;    }    return result;}    //-----------------------------------------------------------------------------// name: getParamString()// desc: get a string param//-----------------------------------------------------------------------------std::string ChucK::getParamString( const std::string & key ){    if( m_params.count( key ) > 0 && ck_param_types[key] == ck_param_string )    {        return m_params[key];    }    else    {        return "";    }}    //-----------------------------------------------------------------------------// name: getParamStringList()// desc: get a string param//-----------------------------------------------------------------------------std::list< std::string > ChucK::getParamStringList( const std::string & key ){    if( m_listParams.count( key ) > 0 &&        ck_param_types[key] == ck_param_string_list )    {        return m_listParams[key];    }    else    {        return std::list< std::string >();    }}    //-----------------------------------------------------------------------------// name: init()// desc: initialize ChucK (using params)//-----------------------------------------------------------------------------bool ChucK::init(){    // sanity check    if( m_init == TRUE )    {        CK_FPRINTF_STDERR( "[chuck]: VM already initialized...\n" );        return false;    }     // initialize VM    if( !initVM() ) goto cleanup;     // initialize compiler    if( !initCompiler() ) goto cleanup;     // initialize chugin system    if( !initChugins() ) goto cleanup;     // initialize OTF programming system    if( !initOTF() ) goto cleanup;     // did user init?    m_init = TRUE;     return true; cleanup:    // shutdown, dealloc    shutdown();     return false;}    //-----------------------------------------------------------------------------// name: initVM()// desc: initialize VM//-----------------------------------------------------------------------------bool ChucK::initVM(){    // get VM params    t_CKUINT srate = getParamInt( CHUCK_PARAM_SAMPLE_RATE );    t_CKUINT outs = getParamInt( CHUCK_PARAM_OUTPUT_CHANNELS );    t_CKUINT ins = getParamInt( CHUCK_PARAM_INPUT_CHANNELS );    t_CKUINT adaptiveSize = getParamInt( CHUCK_PARAM_VM_ADAPTIVE );    t_CKBOOL halt = getParamInt( CHUCK_PARAM_VM_HALT ) != 0;     // instantiate VM    m_carrier->vm = new Chuck_VM();    // reference back to carrier    m_carrier->vm->setCarrier( m_carrier );    // initialize VM    if( !m_carrier->vm->initialize( srate, outs, ins, adaptiveSize, halt ) )    {        CK_FPRINTF_STDERR( "[chuck]: %s\n", m_carrier->vm->last_error() );        return false;    }     return true;}    //-----------------------------------------------------------------------------// name: initCompiler()// desc: initialize compiler//-----------------------------------------------------------------------------bool ChucK::initCompiler(){    // get compiler params    t_CKBOOL dump = getParamInt( CHUCK_PARAM_DUMP_INSTRUCTIONS ) != 0;    t_CKBOOL auto_depend = getParamInt( CHUCK_PARAM_AUTO_DEPEND ) != 0;    t_CKUINT deprecate = getParamInt( CHUCK_PARAM_DEPRECATE_LEVEL );    std::string workingDir = getParamString( CHUCK_PARAM_WORKING_DIRECTORY );     // instantiate compiler    m_carrier->compiler = new Chuck_Compiler();    // reference back to carrier    m_carrier->compiler->setCarrier( m_carrier );     // initialize compiler    if( !m_carrier->compiler->initialize() )    {        CK_FPRINTF_STDERR( "[chuck]: compiler failed to initialize...\n" );        return false;    }    // set dump flag    m_carrier->compiler->emitter->dump = dump;    // set auto depend flag (for type checker) | currently must be FALSE    m_carrier->compiler->set_auto_depend( auto_depend );    // set deprecation level    m_carrier->env->deprecate_level = deprecate;     // VM + type system integration (needs to be done after compiler)    if( !m_carrier->vm->initialize_synthesis() )    {        CK_FPRINTF_STDERR( "[chuck]: %s\n", m_carrier->vm->last_error() );        return false;    } 

Lines 1–500 of 1287. Load more