v2/chuck_shell.cpp

   1 /*----------------------------------------------------------------------------
   2     ChucK Concurrent, On-the-fly Audio Programming Language
   3       Compiler and Virtual Machine
   4
   5     Copyright (c) 2004 Ge Wang and Perry R. Cook.  All rights reserved.
   6       http://chuck.cs.princeton.edu/
   7       http://soundlab.cs.princeton.edu/
   8
   9     This program is free software; you can redistribute it and/or modify
  10     it under the terms of the GNU General Public License as published by
  11     the Free Software Foundation; either version 2 of the License, or
  12     (at your option) any later version.
  13
  14     This program is distributed in the hope that it will be useful,
  15     but WITHOUT ANY WARRANTY; without even the implied warranty of
  16     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17     GNU General Public License for more details.
  18
  19     You should have received a copy of the GNU General Public License
  20     along with this program; if not, write to the Free Software
  21     Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
  22     U.S.A.
  23 -----------------------------------------------------------------------------*/
  24
  25 //-----------------------------------------------------------------------------
  26 // file: chuck_shell.cpp
  27 // desc: ...
  28 //
  29 // author: Spencer Salazar (ssalazar@princeton.edu)
  30 // date: Autumn 2005
  31 //-----------------------------------------------------------------------------
  32
  33 #include "chuck_shell.h"
  34 #include "chuck_otf.h"
  35 #include "util_network.h"
  36
  37 #include <stdio.h>
  38 #include <errno.h>
  39 #include <ctype.h>
  40 #ifndef __PLATFORM_WIN32__
  41  #include <unistd.h>
  42  #include <sys/param.h>
  43  #include <sys/types.h>
  44  #include <dirent.h>
  45 #endif
  46
  47 using namespace std;
  48
  49 // global shell pointer (lives in chuck_main)
  50 extern Chuck_Shell * g_shell;
  51
  52 //-----------------------------------------------------------------------------
  53 // name: tokenize_string
  54 // desc: divides a string into space separated tokens, respecting single and
  55 //      double quotes
  56 //-----------------------------------------------------------------------------
  57 void tokenize_string( string str, vector< string > & tokens)
  58 {
  59     t_CKINT space = 1;
  60     t_CKINT end_space = 0;
  61     t_CKINT squote = 0;
  62     t_CKINT dquote = 0;
  63     t_CKINT i = 0, j = 0, len = str.size();
  64
  65     for( i = 0; i < len; i++ )
  66     {
  67         if( isspace( str[i] ) && space )
  68         {
  69             j++;
  70             continue;
  71         }
  72
  73         if( isspace( str[i] ) && end_space )
  74         {
  75             tokens.push_back( string( str, j, i - j ) );
  76             j = i + 1;
  77             space = 1;
  78             end_space = 0;
  79             continue;
  80         }
  81
  82         if( str[i] == '\'' )
  83         {
  84             if( dquote )
  85                 continue;
  86             if( !squote )
  87             {
  88                 str.erase( i, 1 );
  89                 len--;
  90                 i--;
  91                 space = 0;
  92                 end_space = 0;
  93                 squote = 1;
  94                 continue;
  95             }
  96
  97             else if( str[i - 1] == '\\' )
  98             {
  99                 str.erase( i - 1, 1 );
 100                 len--;
 101                 i--;
 102                 continue;
 103             }
 104
 105             else
 106             {
 107                 str.erase( i, 1 );
 108                 len--;
 109                 i--;
 110                 squote = 0;
 111                 end_space = 1;
 112                 space = 0;
 113                 continue;
 114             }
 115         }
 116
 117         if( str[i] == '"' ) //"
 118         {
 119             if( squote )
 120                 continue;
 121             if( !dquote )
 122             {
 123                 str.erase( i, 1 );
 124                 i--;
 125                 len--;
 126                 space = 0;
 127                 end_space = 0;
 128                 dquote = 1;
 129                 continue;
 130             }
 131
 132             else if( str[i - 1] == '\\' )
 133             {
 134                 str.erase( i - 1, 1 );
 135                 len--;
 136                 i--;
 137                 continue;
 138             }
 139
 140             else
 141             {
 142                 str.erase( i, 1 );
 143                 i--;
 144                 len--;
 145                 dquote = 0;
 146                 end_space = 1;
 147                 space = 0;
 148                 continue;
 149             }
 150         }
 151
 152         if( !squote && !dquote )
 153         {
 154             end_space = 1;
 155             space = 0;
 156         }
 157     }
 158
 159     if( i > j && end_space )
 160     {
 161         tokens.push_back( string( str, j, i - j ) );
 162     }
 163 }
 164
 165 //-----------------------------------------------------------------------------
 166 // name: shell_cb
 167 // desc: thread routine
 168 //-----------------------------------------------------------------------------
 169 void * shell_cb( void * p )
 170 {
 171     Chuck_Shell * shell;
 172     // log
 173     EM_log( CK_LOG_INFO, "starting thread routine for shell..." );
 174
 175     // assuming this is absolutely necessary, an assert may be better
 176     assert( p != NULL );
 177
 178     shell = ( Chuck_Shell * ) p;
 179
 180     //atexit( wait_for_shell );
 181
 182     // run the shell
 183     shell->run();
 184
 185     // delete and set to NULL
 186     SAFE_DELETE( g_shell );
 187     // perhaps let shell destructor clean up mode and ui?
 188
 189     EM_log( CK_LOG_INFO, "exiting thread routine for shell..." );
 190
 191     return NULL;
 192 }
 193
 194
 195
 196
 197 //-----------------------------------------------------------------------------
 198 // name: Chuck_Shell()
 199 // desc: ...
 200 //-----------------------------------------------------------------------------
 201 Chuck_Shell::Chuck_Shell()
 202 {
 203     ui = NULL;
 204     process_vm = NULL;
 205     current_vm = NULL;
 206     initialized = FALSE;
 207     stop = FALSE;
 208     code_entry_active = FALSE;
 209 }
 210
 211 //-----------------------------------------------------------------------------
 212 // name: ~Chuck_Shell()
 213 // desc: ...
 214 //-----------------------------------------------------------------------------
 215 Chuck_Shell::~Chuck_Shell()
 216 {
 217     vector<string>::size_type i, len = allocated_commands.size();
 218
 219     //iterate through commands, delete the associated heap data
 220     for( i = 0; i != len; i++ )
 221         SAFE_DELETE( allocated_commands[i] );
 222
 223     // delete ui
 224     SAFE_DELETE( ui );
 225
 226     // flag
 227     initialized = FALSE;
 228 }
 229
 230 //-----------------------------------------------------------------------------
 231 // name: init()
 232 // desc: ...
 233 //-----------------------------------------------------------------------------
 234 t_CKBOOL Chuck_Shell::init( Chuck_VM * vm, Chuck_Shell_UI * ui )
 235 {
 236     // log
 237     EM_log( CK_LOG_SYSTEM, "initializing chuck shell..." );
 238
 239     // check
 240     if( initialized == TRUE )
 241     {
 242         EM_log( CK_LOG_WARNING, "chuck shell already initialized" );
 243         return TRUE;
 244     }
 245
 246     // ui
 247     if( ui == NULL )
 248     {
 249         fprintf( stderr, "[chuck](via shell): NULL ui passed to Chuck_Shell::init..." );
 250         return FALSE;
 251     }
 252
 253     this->ui = ui;
 254
 255     process_vm = vm;
 256
 257     Chuck_Shell_Network_VM * cspv = new Chuck_Shell_Network_VM();
 258     if( !cspv->init( "localhost", 8888 ) )
 259     {
 260         fprintf( stderr, "[chuck](via shell): error initializing process VM..." );
 261         SAFE_DELETE( cspv );
 262         return FALSE;
 263     }
 264
 265     current_vm = cspv;
 266     vms.push_back( current_vm->copy() );
 267
 268     process_vm = vm;
 269
 270     code_entry_active = FALSE;
 271     code = "";
 272
 273     // init default variables
 274     variables["COMMAND_PROMPT"] = "chuck %> ";
 275     variables["DEFAULT_CONTEXT"] = "shell_global";
 276
 277     // initialize prompt
 278     prompt = variables["COMMAND_PROMPT"];
 279
 280     Command * temp;
 281
 282     // initialize the string -> Chuck_Shell_Command map
 283     temp = new Command_VM();
 284     temp->init( this );
 285     commands["vm"] = temp;
 286     allocated_commands.push_back( temp );
 287
 288     temp = new Command_VMList();
 289     temp->init( this );
 290     commands["vms"] = temp;
 291     allocated_commands.push_back( temp );
 292
 293     temp = new Command_Add();
 294     temp->init( this );
 295     commands["+"] = temp;
 296     commands["add"] = temp;
 297     allocated_commands.push_back( temp );
 298
 299     temp = new Command_Remove();
 300     temp->init( this );
 301     commands["-"] = temp;
 302     commands["remove"] = temp;
 303     allocated_commands.push_back( temp );
 304
 305     temp = new Command_Status();
 306     temp->init( this );
 307     commands["status"] = temp;
 308     commands["^"] = temp;
 309     allocated_commands.push_back( temp );
 310
 311     temp = new Command_Removeall();
 312     temp->init( this );
 313     commands["removeall"] = temp;
 314     allocated_commands.push_back( temp );
 315
 316     temp = new Command_Removelast();
 317     temp->init( this );
 318     commands["--"] = temp;
 319     allocated_commands.push_back( temp );
 320
 321     temp = new Command_Replace();
 322     temp->init( this );
 323     commands["replace"] = temp;
 324     commands["="] = temp;
 325     allocated_commands.push_back( temp );
 326
 327     temp = new Command_Close();
 328     temp->init( this );
 329     commands["close"] = temp;
 330     allocated_commands.push_back( temp );
 331
 332     temp = new Command_Kill();
 333     temp->init( this );
 334     commands["kill"] = temp;
 335     allocated_commands.push_back( temp );
 336
 337     temp = new Command_Exit();
 338     temp->init( this );
 339     commands["exit"] = temp;
 340     commands["quit"] = temp;
 341     allocated_commands.push_back( temp );
 342
 343     temp = new Command_Ls();
 344     temp->init( this );
 345     commands["ls"] = temp;
 346     allocated_commands.push_back( temp );
 347
 348     temp = new Command_Pwd();
 349     temp->init( this );
 350     commands["pwd"] = temp;
 351     allocated_commands.push_back( temp );
 352
 353     temp = new Command_Cd();
 354     temp->init( this );
 355     commands["cd"] = temp;
 356     allocated_commands.push_back( temp );
 357
 358     temp = new Command_Alias();
 359     temp->init( this );
 360     commands["alias"] = temp;
 361     allocated_commands.push_back( temp );
 362
 363     temp = new Command_Unalias();
 364     temp->init( this );
 365     commands["unalias"] = temp;
 366     allocated_commands.push_back( temp );
 367
 368     temp = new Command_Source();
 369     temp->init( this );
 370     commands["source"] = temp;
 371     commands["."] = temp;
 372     allocated_commands.push_back( temp );
 373
 374     temp = new Command_Code();
 375     temp->init( this );
 376     commands["code"] = temp;
 377     allocated_commands.push_back( temp );
 378
 379     // flag
 380     initialized = TRUE;
 381
 382     return TRUE;
 383 }
 384
 385 //-----------------------------------------------------------------------------
 386 // name: run()
 387 // desc: ...
 388 //-----------------------------------------------------------------------------
 389 void Chuck_Shell::run()
 390 {
 391     // log
 392     EM_log( CK_LOG_SYSTEM, "running chuck shell..." );
 393
 394     // make sure
 395     if(initialized == FALSE)
 396     {
 397         fprintf( stderr, "[chuck](via shell): shell not initialized...\n" );
 398         return;
 399     }
 400
 401     string command;
 402     string result;
 403
 404     ui->next_result( "welcome to chuck shell!\n" );
 405     // ui->next_result( "(type \"help\" for more information)\n" );
 406
 407     // loop
 408     for( ; !stop; )
 409     {
 410         // get command
 411         if( ui->next_command( prompt, command ) == TRUE )
 412         {
 413             // result.clear();
 414             result = "";
 415
 416             //printf( "chuck_shell::run\n" );
 417
 418             // execute the command
 419             execute( command, result );
 420
 421             // command.clear();
 422             command = "";
 423
 424             // pass the result to the shell ui
 425             ui->next_result( result );
 426         }
 427         else
 428             // done
 429             break;
 430     }
 431
 432     // log
 433     EM_log( CK_LOG_SYSTEM, "exiting chuck shell..." );
 434 }
 435
 436 //-----------------------------------------------------------------------------
 437 // name: execute
 438 // desc: ...
 439 //-----------------------------------------------------------------------------
 440 t_CKBOOL Chuck_Shell::execute( string & in, string & out )
 441 {
 442     if( !initialized )
 443     {
 444         //fprintf();
 445         return FALSE;
 446     }
 447
 448     // vector of string tokens
 449     vector< string > vec;
 450
 451     // clear the response
 452     out = "";
 453
 454     // first find out if this is code to run
 455     if( !code_entry_active && in[in.find_first_not_of( " \t\v\n" )] == '{' )
 456         start_code();
 457
 458     if( code_entry_active )
 459     {
 460         continue_code( in );
 461
 462         if( code_entry_active == FALSE )
 463         {
 464             //strip opening and closing braces
 465             string::size_type k = code.find( "{" );
 466             string head = string( code, 0, k );
 467             code = string( code, k + 1, code.size() - k - 1 );
 468
 469             k = code.rfind( "}" );
 470             string tail = string( code, k + 1, code.size() - k - 1 );
 471             code = string( code, 0, k );
 472
 473             do_code( code, out );
 474
 475             tokenize_string( tail, vec );
 476
 477             if( vec.size() > 0 )
 478             {
 479                 string temp = "code save " + vec[0];
 480                 execute( temp, out );
 481             }
 482         }
 483
 484         return TRUE;
 485     }
 486
 487     // divide the string into white space separated substrings
 488     tokenize_string( in, vec );
 489
 490     // if no tokens
 491     if( vec.size() == 0)
 492         return TRUE;
 493
 494     // first check if the first token matches an alias
 495     while( aliases.find( vec[0] ) != aliases.end() )
 496     // use a while loop to handle nested aliases
 497     {
 498         vector< string > vec2;
 499         tokenize_string( aliases[vec[0]], vec2 );
 500         vec.erase( vec.begin() );
 501         vec2.insert( vec2.end(), vec.begin(), vec.end() );
 502         vec = vec2;
 503     }
 504
 505     // locate the command
 506     if( commands.find( vec[0] ) == commands.end() )
 507     // command doesn't exist!
 508     {
 509         out += vec[0] + ": command not found\n";
 510         return FALSE;
 511     }
 512
 513     else
 514     // execute the command
 515     {
 516         Command * command = commands[vec[0]];
 517         vec.erase( vec.begin() );
 518         if( command->execute( vec, out ) == 0 )
 519             return TRUE;
 520
 521         else
 522             return FALSE;
 523     }
 524
 525     return TRUE;
 526 }
 527
 528 //-----------------------------------------------------------------------------
 529 // name: start_code()
 530 // desc: ...
 531 //-----------------------------------------------------------------------------
 532 void Chuck_Shell::start_code()
 533 {
 534     code = "";
 535     code_entry_active = TRUE;
 536     scope = 0;
 537 }
 538
 539 //-----------------------------------------------------------------------------
 540 // name: continue_code()
 541 // desc: ...
 542 //-----------------------------------------------------------------------------
 543 void Chuck_Shell::continue_code( string & in )
 544 {
 545     if( in.find( "{" ) != string::npos )
 546     // increase the scope one level and change the prompt
 547     {
 548         char buf[16];
 549         scope++;
 550 #ifndef __PLATFORM_WIN32__
 551         snprintf( buf, 16, "code %2d> ", (int)scope );
 552 #else
 553         sprintf( buf, "code %2d> ", scope);
 554 #endif
 555         prompt = buf;
 556     }
 557
 558     if( in.find( "}" ) != string::npos )
 559     // decrease the scope one level and change the prompt
 560     {
 561         char buf[16];
 562         scope--;
 563 #ifndef __PLATFORM_WIN32__
 564         snprintf( buf, 16, "code %2d> ", (int)scope );
 565 #else
 566         sprintf( buf, "code %2d> ", scope);
 567 #endif
 568         prompt = buf;
 569     }
 570
 571     // collect this line as ChucK code
 572     code += in + "\n";
 573
 574     if( scope == 0 )
 575     // the end of this code block -- lets execute it on the current_vm
 576         code_entry_active = FALSE;
 577 }
 578
 579 //-----------------------------------------------------------------------------
 580 // name: do_code()
 581 // desc: ...
 582 //-----------------------------------------------------------------------------
 583 void Chuck_Shell::do_code( string & code, string & out, string command )
 584 {
 585     // open a temporary file
 586 #if defined(__LINUX_ALSA__) || defined(__LINUX_OSS__) || defined(__LINUX_JACK__)
 587     char tmp_dir[] = "/tmp";
 588     char * tmp_filepath = new char [32];
 589     strncpy( tmp_filepath, "/tmp/chuck_file.XXXXXX", 32 );
 590     int fd = mkstemp( tmp_filepath );
 591     if( fd == -1 )
 592     {
 593         out += string( "shell: error: unable to create tmpfile at " ) + tmp_dir + "\n";
 594         delete[] tmp_filepath;
 595         prompt = variables["COMMAND_PROMPT"];
 596         return;
 597     }
 598
 599     FILE * tmp_file = fdopen( fd, "w+" );
 600     if( tmp_file == NULL )
 601     {
 602         out += string( "shell: error: unable to reopen tmpfile at " ) + tmp_filepath + "\n";
 603         delete[] tmp_filepath;
 604         prompt = variables["COMMAND_PROMPT"];
 605         return;
 606     }
 607 #else
 608     char * tmp_filepath = tmpnam( NULL );
 609     if( tmp_filepath == NULL )
 610     {
 611         out += string( "shell: error: unable to generate tmpfile name\n" );
 612         prompt = variables["COMMAND_PROMPT"];
 613         return;
 614     }
 615
 616     FILE * tmp_file = fopen( tmp_filepath, "w" );
 617     if( tmp_file == NULL )
 618     {
 619         out += string( "shell: error: unable to open tmpfile '" ) + tmp_filepath + "'\n";
 620         prompt = variables["COMMAND_PROMPT"];
 621         return;
 622     }
 623 #endif
 624
 625     // write the code to the temp file
 626     fprintf( tmp_file, "%s", code.c_str() );
 627     fclose( tmp_file );
 628
 629     string argv = string( command ) + tmp_filepath;
 630
 631     this->execute( argv, out );
 632     // if( this->execute( argv, out ) )
 633     //    ;
 634
 635     // delete the file
 636 #ifndef __PLATFORM_WIN32__
 637     unlink( tmp_filepath );
 638 #else
 639     DeleteFile( tmp_filepath );
 640 #endif // __PLATFORM_WIN32__
 641
 642 #if defined(__LINUX_ALSA__) || defined(__LINUX_OSS__) || defined(__LINUX_JACK__)
 643     delete[] tmp_filepath;
 644 #endif
 645
 646     prompt = variables["COMMAND_PROMPT"];
 647 }
 648
 649 //-----------------------------------------------------------------------------
 650 // name: do_context()
 651 // desc: ...
 652 //-----------------------------------------------------------------------------
 653 void Chuck_Shell::do_code_context( string & )
 654 {
 655
 656 }
 657
 658 //-----------------------------------------------------------------------------
 659 // name: close()
 660 // desc: ...
 661 //-----------------------------------------------------------------------------
 662 void Chuck_Shell::close()
 663 {
 664     stop = TRUE;
 665     //
 666 }
 667
 668 //-----------------------------------------------------------------------------
 669 // name: kill()
 670 // desc: ...
 671 //-----------------------------------------------------------------------------
 672 void Chuck_Shell::exit()
 673 {
 674     stop = TRUE;
 675
 676     if( process_vm != NULL )
 677         process_vm->stop();
 678 }
 679
 680 //-----------------------------------------------------------------------------
 681 // name: init()
 682 // desc: ...
 683 //-----------------------------------------------------------------------------
 684 t_CKBOOL Chuck_Shell_Network_VM::init( const string & hostname, t_CKINT port )
 685 {
 686     this->hostname = hostname;
 687     this->port = port;
 688     return TRUE;
 689 }
 690
 691 //-----------------------------------------------------------------------------
 692 // name: copy()
 693 // desc: ...
 694 //-----------------------------------------------------------------------------
 695 Chuck_Shell_VM * Chuck_Shell_Network_VM::copy()
 696 {
 697     Chuck_Shell_Network_VM * net_vm = new Chuck_Shell_Network_VM();
 698     net_vm->init( hostname, port );
 699     return net_vm;
 700 }
 701
 702 //-----------------------------------------------------------------------------
 703 // name: add_shred()
 704 // desc: ...
 705 //-----------------------------------------------------------------------------
 706 t_CKBOOL Chuck_Shell_Network_VM::add_shred( const vector< string > & files,
 707                                             string & out )
 708 {
 709     t_CKINT i = 0;
 710     t_CKBOOL return_val;
 711     vector<string>::size_type j, str_len, vec_len = files.size() + 1;
 712     const char ** argv = new const char * [ vec_len ];
 713
 714     /* prepare an argument vector to submit to otf_send_cmd */
 715     /* first, specify an add command */
 716     char * argv0 = new char [2];
 717     strncpy( argv0, "+", 2 );
 718     argv[0] = argv0;
 719
 720     /* copy file paths into argv */
 721     for( j = 1; j < vec_len; j++ )
 722     {
 723         str_len = files[j - 1].size() + 1;
 724         char * argvj = new char [str_len];
 725         strncpy( argvj, files[j - 1].c_str(), str_len );
 726         argv[j] = argvj;
 727     }
 728
 729     /* send the command */
 730     if( otf_send_cmd( vec_len, argv, i, hostname.c_str(), port ) )
 731         return_val = TRUE;
 732     else
 733     {
 734         out += "add: error: command failed\n";
 735         return_val = FALSE;
 736     }
 737
 738     /* clean up heap data */
 739     for( j = 0; j < vec_len; j++ )
 740     {
 741         // TODO: verify this is alright
 742         char * arg = (char *)argv[j];
 743         delete[] arg;
 744     }
 745     delete[] argv;
 746
 747     return return_val;
 748 }
 749
 750 //-----------------------------------------------------------------------------
 751 // name: remove_shred()
 752 // desc: ...
 753 //-----------------------------------------------------------------------------
 754 t_CKBOOL Chuck_Shell_Network_VM::remove_shred( const vector< string > & ids,
 755                                                string & out )
 756 {
 757     t_CKINT i = 0;
 758     t_CKBOOL return_val;
 759     vector<string>::size_type j, str_len, vec_len = ids.size() + 1;
 760     const char ** argv = new const char * [ vec_len ];
 761
 762     /* prepare an argument vector to submit to otf_send_cmd */
 763     /* first, specify an add command */
 764     char * argv0 = new char [2];
 765     strncpy( argv0, "-", 2 );
 766     argv[0] = argv0;
 767
 768     /* copy ids into argv */
 769     for( j = 1; j < vec_len; j++ )
 770     {
 771         str_len = ids[j - 1].size() + 1;
 772         char * argvj = new char [str_len];
 773         strncpy( argvj, ids[j - 1].c_str(), str_len );
 774         argv[j] = argvj;
 775     }
 776
 777     /* send the command */
 778     if( otf_send_cmd( vec_len, argv, i, hostname.c_str(), port ) )
 779         return_val = TRUE;
 780     else
 781     {
 782         out += "remove: error: command failed\n";
 783         return_val = FALSE;
 784     }
 785
 786     /* clean up heap data */
 787     for( j = 0; j < vec_len; j++ )
 788     {
 789         // TODO: verify this is ok
 790         char * arg = (char *)argv[j];
 791         delete[] arg;
 792     }
 793     delete[] argv;
 794
 795     return return_val;
 796 }
 797
 798 //-----------------------------------------------------------------------------
 799 // name: remove_all()
 800 // desc: ...
 801 //-----------------------------------------------------------------------------
 802 t_CKBOOL Chuck_Shell_Network_VM::remove_all( string & out )
 803 {
 804     t_CKBOOL return_val = TRUE;
 805     t_CKINT j = 0;
 806     const char * argv = "--removeall";
 807     if( !otf_send_cmd( 1, &argv, j, hostname.c_str(), port ) )
 808     {
 809         out += "removeall: error: command failed\n";
 810         return_val = FALSE;
 811     }
 812
 813     return return_val;
 814 }
 815
 816 //-----------------------------------------------------------------------------
 817 // name: remove_last()
 818 // desc: ...
 819 //-----------------------------------------------------------------------------
 820 t_CKBOOL Chuck_Shell_Network_VM::remove_last( string & out )
 821 {
 822     t_CKBOOL return_val = TRUE;
 823     t_CKINT j = 0;
 824     const char * argv = "--";
 825     if( !otf_send_cmd( 1, &argv, j, hostname.c_str(), port ) )
 826     {
 827         out += "removelast: error: command failed\n";
 828         return_val = FALSE;
 829     }
 830
 831     return return_val;
 832 }
 833
 834 //-----------------------------------------------------------------------------
 835 // name: replace_shred()
 836 // desc: ...
 837 //-----------------------------------------------------------------------------
 838 t_CKBOOL Chuck_Shell_Network_VM::replace_shred( const vector< string > &vec,
 839                                                 string & out )
 840 {
 841     if( vec.size() < 2 )
 842     {
 843         out += "replace: error: insufficient arguments...\n";
 844         return FALSE;
 845     }
 846
 847     t_CKINT i = 0;
 848     t_CKBOOL return_val;
 849     vector<string>::size_type j, str_len, vec_len = vec.size() + 1;
 850     const char ** argv = new const char * [ vec_len ];
 851
 852     /* prepare an argument vector to submit to otf_send_cmd */
 853     /* first, specify an add command */
 854     argv[0] = "--replace";
 855
 856     /* copy ids/files into argv */
 857     for( j = 1; j < vec_len; j++ )
 858     {
 859         str_len = vec[j - 1].size() + 1;
 860         char * argvj = new char [str_len];
 861         strncpy( argvj, vec[j - 1].c_str(), str_len );
 862         argv[j] = argvj;
 863     }
 864
 865     /* send the command */
 866     if( otf_send_cmd( vec_len, argv, i, hostname.c_str(), port ) )
 867         return_val = TRUE;
 868
 869     else
 870     {
 871         out += "replace: error: command failed\n";
 872         return_val = FALSE;
 873     }
 874
 875     if( vec.size() % 2 != 0 )
 876     {
 877         out += "repalce: warning: ignoring excess arguments\n";
 878         return FALSE;
 879     }
 880
 881     /* clean up heap data */
 882     for( j = 1; j < vec_len; j++ )
 883     {
 884         // TODO: verify this is ok
 885         char * arg = (char *)argv[j];
 886         delete[] arg;
 887     }
 888     delete[] argv;
 889
 890     return return_val;
 891 }
 892
 893 //-----------------------------------------------------------------------------
 894 // name: status()
 895 // desc: ...
 896 //-----------------------------------------------------------------------------
 897 t_CKBOOL Chuck_Shell_Network_VM::status( string & out )
 898 {
 899     const char * argv = "--status";
 900     t_CKBOOL return_val = FALSE;
 901     t_CKINT j = 0;
 902
 903     if( otf_send_cmd( 1, &argv, j, hostname.c_str(), port ) )
 904         return_val = TRUE;
 905     else
 906     {
 907         return_val = FALSE;
 908         out += "status: error: command failed\n";
 909     }
 910
 911     return return_val;
 912 }
 913
 914 //-----------------------------------------------------------------------------
 915 // name: kill()
 916 // desc: ...
 917 //-----------------------------------------------------------------------------
 918 t_CKBOOL Chuck_Shell_Network_VM::kill( string & out )
 919 {
 920     const char * argv = "--kill";
 921     t_CKINT j = 0;
 922     t_CKBOOL return_val;
 923
 924     if( otf_send_cmd( 1, &argv, j, hostname.c_str(), port ) )
 925         return_val = TRUE;
 926
 927     else
 928     {
 929         return_val = FALSE;
 930         out += "kill: error: command failed";
 931     }
 932
 933     return return_val;
 934 }
 935
 936 //-----------------------------------------------------------------------------
 937 // name: fullname()
 938 // desc: returns a somewhat descriptive full name for this VM
 939 //-----------------------------------------------------------------------------
 940 string Chuck_Shell_Network_VM::fullname()
 941 {
 942     char buf[16];
 943     sprintf( buf, ":%u", (int)port );
 944
 945     return hostname + buf;
 946 }
 947
 948 //-----------------------------------------------------------------------------
 949 // name: init()
 950 // desc: ...
 951 //-----------------------------------------------------------------------------
 952 t_CKBOOL Chuck_Shell_UI::init()
 953 {
 954     return TRUE;
 955 }
 956
 957 //-----------------------------------------------------------------------------
 958 // name: init()
 959 // desc: ...
 960 //-----------------------------------------------------------------------------
 961 t_CKBOOL Chuck_Shell::Command::init( Chuck_Shell * caller )
 962 {
 963     this->caller = caller;
 964     return TRUE;
 965 }
 966
 967 //-----------------------------------------------------------------------------
 968 // name: usage()
 969 // desc: ...
 970 //-----------------------------------------------------------------------------
 971 string Chuck_Shell::Command::usage()
 972 {
 973     return "no usage specified";
 974 }
 975
 976 //-----------------------------------------------------------------------------
 977 // name: long_usage()
 978 // desc: ...
 979 //-----------------------------------------------------------------------------
 980 string Chuck_Shell::Command::long_usage()
 981 {
 982     return "no usage specified";
 983 }
 984
 985 //-----------------------------------------------------------------------------
 986 // name: execute()
 987 // desc: ...
 988 //-----------------------------------------------------------------------------
 989 t_CKINT Chuck_Shell::Command_Add::execute( vector< string > & argv,
 990                                            string & out )
 991 {
 992     t_CKINT result = 0;
 993
 994     if( caller->current_vm == NULL)
 995     {
 996         out += "add: error: not attached to a VM\n";
 997         result = -1;
 998     }
 999
1000     else if( argv.size() < 1 )
1001     {
1002         out += "usage: " + usage() + "\n";
1003         result = -1;
1004     }
1005
1006     else
1007     {
1008         result = caller->current_vm->add_shred( argv, out );
1009     }
1010
1011     return result;
1012 }
1013
1014 //-----------------------------------------------------------------------------
1015 // name: usage()
1016 // desc: ...
1017 //-----------------------------------------------------------------------------
1018 string Chuck_Shell::Command_Add::usage()
1019 {
1020     return "add file ...";
1021 }
1022
1023 //-----------------------------------------------------------------------------
1024 // name: execute()
1025 // desc: ...
1026 //-----------------------------------------------------------------------------
1027 t_CKINT Chuck_Shell::Command_Remove::execute( vector< string > & argv,
1028                                               string & out )
1029 {
1030     t_CKINT result = 0;
1031
1032     if( caller->current_vm == NULL)
1033     {
1034         out += "remove: error: not attached to a VM\n";
1035         result = -1;
1036     }
1037
1038     else if( argv.size() < 1 )
1039     {
1040         out += "usage: " + usage() + "\n";
1041         result = -1;
1042     }
1043
1044     else
1045         result = caller->current_vm->remove_shred( argv, out );
1046
1047     return result;
1048 }
1049
1050 //-----------------------------------------------------------------------------
1051 // name: usage()
1052 // desc: ...
1053 //-----------------------------------------------------------------------------
1054 string Chuck_Shell::Command_Remove::usage()
1055 {
1056     return "remove shred_number ...";
1057 }
1058
1059 //-----------------------------------------------------------------------------
1060 // name: execute()
1061 // desc: ...
1062 //-----------------------------------------------------------------------------
1063 t_CKINT Chuck_Shell::Command_Removeall::execute( vector< string > & argv,
1064                                                  string & out )
1065 {
1066     t_CKINT result = 0;
1067
1068     if( caller->current_vm == NULL)
1069     {
1070         out += "removeall: error: not attached to a VM\n";
1071         result = -1;
1072     }
1073
1074     else if( argv.size() > 0 )
1075     {
1076         out += "usage " + usage() + "\n";
1077         result = -1;
1078     }
1079
1080     else
1081         result = caller->current_vm->remove_all( out );
1082
1083     return result;
1084 }
1085
1086 //-----------------------------------------------------------------------------
1087 // name: usage()
1088 // desc: ...
1089 //-----------------------------------------------------------------------------
1090 string Chuck_Shell::Command_Removeall::usage()
1091 {
1092     return "removeall";
1093 }
1094
1095 //-----------------------------------------------------------------------------
1096 // name: execute()
1097 // desc: ...
1098 //-----------------------------------------------------------------------------
1099 t_CKINT Chuck_Shell::Command_Removelast::execute( vector< string > & argv,
1100                                                   string & out )
1101 {
1102     t_CKINT result = -1;
1103
1104     if( caller->current_vm == NULL)
1105         out += "removelast: error: not attached to a VM\n";
1106     else
1107         result = caller->current_vm->remove_last( out );
1108
1109     if( argv.size() > 0 )
1110         out += "removelast: warning: ignoring excess arguments...\n";
1111
1112     return result;
1113 }
1114
1115 //-----------------------------------------------------------------------------
1116 // name: usage()
1117 // desc: ...
1118 //-----------------------------------------------------------------------------
1119 string Chuck_Shell::Command_Removelast::usage()
1120 {
1121     return "removelast";
1122 }
1123
1124 //-----------------------------------------------------------------------------
1125 // name: execute()
1126 // desc: ...
1127 //-----------------------------------------------------------------------------
1128 t_CKINT Chuck_Shell::Command_Replace::execute( vector< string > & argv,
1129                                                string & out )
1130 {
1131     if( caller->current_vm == NULL)
1132     {
1133         out += "replace: error: not attached to a VM\n";
1134         return -1;
1135     }
1136
1137     caller->current_vm->replace_shred( argv, out );
1138
1139     return 0;
1140 }
1141
1142 //-----------------------------------------------------------------------------
1143 // name: usage()
1144 // desc: ...
1145 //-----------------------------------------------------------------------------
1146 string Chuck_Shell::Command_Replace::usage()
1147 {
1148     return "replace shred_id file ...";
1149 }
1150
1151 //-----------------------------------------------------------------------------
1152 // name: execute()
1153 // desc: ...
1154 //-----------------------------------------------------------------------------
1155 t_CKINT Chuck_Shell::Command_Status::execute( vector< string > & argv,
1156                                               string & out )
1157 {
1158     t_CKINT result = 0;
1159
1160     if( caller->current_vm == NULL)
1161     {
1162         out += "status: error: not attached to a VM\n";
1163         result = -1;
1164     }
1165
1166     else if( argv.size() > 0 )
1167     {
1168         out += "usage: " + usage() + "\n";
1169         result = -1;
1170     }
1171
1172     else
1173         result = caller->current_vm->status( out );
1174
1175     return result;
1176 }
1177
1178 //-----------------------------------------------------------------------------
1179 // name: usage()
1180 // desc: ...
1181 //-----------------------------------------------------------------------------
1182 string Chuck_Shell::Command_Status::usage()
1183 {
1184     return "status";
1185 }
1186
1187 //-----------------------------------------------------------------------------
1188 // name: execute()
1189 // desc: ...
1190 //-----------------------------------------------------------------------------
1191 t_CKINT Chuck_Shell::Command_Kill::execute( vector< string > & argv,
1192                                             string & out )
1193 {
1194     caller->current_vm->kill( out );
1195     if( argv.size() > 0 )
1196         out += "kill: warning: ignoring excess arguments...\n";
1197
1198     return 0;
1199 }
1200
1201 //-----------------------------------------------------------------------------
1202 // name: execute()
1203 // desc: ...
1204 //-----------------------------------------------------------------------------
1205 t_CKINT Chuck_Shell::Command_Close::execute( vector< string > & argv,
1206                                              string & out )
1207 {
1208     caller->close();
1209
1210     out += "closing chuck shell...  bye!\n";
1211
1212     if( g_shell != NULL )
1213         out += "(note: in-process VM still running, hit ctrl-c to exit)\n";
1214
1215     if( argv.size() > 0 )
1216         out += "close: warning: ignoring excess arguments...\n";
1217
1218     return 0;
1219 }
1220
1221 //-----------------------------------------------------------------------------
1222 // name: execute()
1223 // desc: ...
1224 //-----------------------------------------------------------------------------
1225 t_CKINT Chuck_Shell::Command_Exit::execute( vector< string > & argv,
1226                                             string & out )
1227 {
1228     caller->exit();
1229     if( argv.size() > 0 )
1230         out += "exit: warning: ignoring excess arguments...\n";
1231
1232     return 0;
1233 }
1234
1235 //-----------------------------------------------------------------------------
1236 // name: execute()
1237 // desc: ...
1238 //-----------------------------------------------------------------------------
1239 t_CKINT Chuck_Shell::Command_Ls::execute( vector< string > & argv,
1240                                           string & out )
1241 {
1242 #ifndef __PLATFORM_WIN32__
1243
1244     if( argv.size() == 0 )
1245     {
1246         DIR * dir_handle = opendir( "." );
1247         if( dir_handle == NULL )
1248         {
1249             out += "ls: error: unable to open directory .\n";
1250             return -1;
1251         }
1252
1253         dirent * dir_entity = readdir( dir_handle );
1254
1255         while( dir_entity != NULL )
1256         {
1257             out += string( dir_entity->d_name ) + "\n";
1258             dir_entity = readdir( dir_handle );
1259         }
1260
1261         closedir( dir_handle );
1262         return 0;
1263     }
1264
1265     int i, len = argv.size();
1266     t_CKBOOL print_parent_name = len > 1 ? TRUE : FALSE;
1267
1268     for( i = 0; i < len; i++ )
1269     {
1270         DIR * dir_handle = opendir( argv[i].c_str() );
1271         if( dir_handle == NULL )
1272         {
1273             out += "ls: error: unable to open directory " + argv[i] + "\n";
1274             continue;
1275         }
1276
1277         dirent * dir_entity = readdir( dir_handle );
1278
1279         if( print_parent_name )
1280             out += argv[i] + ":\n";
1281
1282         while( dir_entity != NULL )
1283         {
1284             out += string( dir_entity->d_name ) + "\n";
1285             dir_entity = readdir( dir_handle );
1286         }
1287
1288         if( print_parent_name )
1289             out += "\n";
1290
1291         closedir( dir_handle );
1292     }
1293
1294 #else
1295
1296     if( argv.size() == 0 )
1297     {
1298         DWORD i, k = 64;
1299         LPTSTR cwd = new char [k];
1300         WIN32_FIND_DATA find_data;
1301
1302         i = GetCurrentDirectory( k - 2, cwd );
1303
1304         if( i >= k )
1305         {
1306             SAFE_DELETE_ARRAY( cwd );
1307             cwd = new char [i + 2];
1308             GetCurrentDirectory( i, cwd );
1309         }
1310
1311         i = strlen( cwd );
1312         cwd[i] = '\\';
1313         cwd[i + 1] = '*';
1314         cwd[i + 2] = 0;
1315
1316         HANDLE find_handle = FindFirstFile( cwd, &find_data );
1317
1318         out += string( find_data.cFileName ) + "\n";
1319
1320         while( FindNextFile( find_handle, &find_data ) )
1321             out += string( find_data.cFileName ) + "\n";
1322
1323         FindClose( find_handle );
1324         return 0;
1325     }
1326
1327     int i, len = argv.size();
1328     t_CKBOOL print_parent_name = len > 1 ? TRUE : FALSE;
1329
1330     for( i = 0; i < len; i++ )
1331     {
1332         int j = argv[i].size() + 3;
1333         WIN32_FIND_DATA find_data;
1334         LPTSTR dir = new char [j];
1335         strncpy( dir, argv[i].c_str(), j );
1336         dir[j - 3] = '\\';
1337         dir[j - 2] = '*';
1338         dir[j - 1] = 0;
1339
1340         if( print_parent_name )
1341             out += argv[i] + ":\n";
1342
1343         HANDLE find_handle = FindFirstFile( dir, &find_data );
1344
1345         out += string( find_data.cFileName ) + "\n";
1346
1347         while( FindNextFile( find_handle, &find_data ) )
1348             out += string( find_data.cFileName ) + "\n";
1349
1350         if( print_parent_name )
1351             out += "\n";
1352
1353         FindClose( find_handle );
1354     }
1355
1356
1357
1358 #endif // __PLATFORM_WIN32__
1359     return 0;
1360 }
1361
1362 //-----------------------------------------------------------------------------
1363 // name: execute()
1364 // desc: ...
1365 //-----------------------------------------------------------------------------
1366 t_CKINT Chuck_Shell::Command_Cd::execute( vector< string > & argv,
1367                                           string & out )
1368 {
1369 #ifndef __PLATFORM_WIN32__
1370     if( argv.size() < 1 )
1371     {
1372         if( chdir( getenv( "HOME" ) ) )
1373             out += "cd: error: command failed\n";
1374     }
1375
1376     else
1377     {
1378         if( chdir( argv[0].c_str() ) )
1379             out += "cd: error: command failed\n";
1380     }
1381
1382 #else
1383     if( argv.size() < 1 )
1384         out += "usage: " + usage() + "\n";
1385
1386     else
1387     {
1388         if( !SetCurrentDirectory( argv[0].c_str() ) )
1389             out += "cd: error: command failed\n";
1390     }
1391
1392 #endif //__PLATFORM_WIN32__
1393     return 0;
1394 }
1395
1396 //-----------------------------------------------------------------------------
1397 // name: execute()
1398 // desc: ...
1399 //-----------------------------------------------------------------------------
1400 t_CKINT Chuck_Shell::Command_Pwd::execute( vector< string > & argv,
1401                                            string & out )
1402 {
1403 #ifndef __PLATFORM_WIN32__
1404     char * cwd = getcwd( NULL, 0 );
1405     out += string( cwd ) + "\n";
1406     free( cwd );
1407 #else
1408     DWORD i, k = 256;
1409     LPTSTR cwd = new char [k];
1410     i = GetCurrentDirectory( k, cwd );
1411
1412     if( i >= k )
1413     {
1414         SAFE_DELETE_ARRAY( cwd );
1415         cwd = new char [i];
1416         GetCurrentDirectory( i, cwd );
1417     }
1418
1419     out += string( cwd ) + "\n";
1420
1421     SAFE_DELETE_ARRAY( cwd );
1422 #endif
1423
1424     if( argv.size() > 0 )
1425         out += "pwd: warning: ignoring excess arguments...\n";
1426
1427     return 0;
1428 }
1429
1430 //-----------------------------------------------------------------------------
1431 // name: execute()
1432 // desc: ...
1433 //-----------------------------------------------------------------------------
1434 t_CKINT Chuck_Shell::Command_Alias::execute( vector< string > & argv,
1435                                              string & out )
1436 {
1437     vector<string>::size_type i, len = argv.size();
1438     string::size_type j;
1439     string a, b;
1440
1441     for( i = 0; i < len; i++ )
1442     {
1443         j = argv[i].find( "=" );
1444
1445         // no alias assignment specified; just print the alias value if exists
1446         if( j == string::npos )
1447         {
1448             // see if the alias exists in the map
1449             if( caller->aliases.find( argv[i] ) == caller->aliases.end() )
1450                 out += "alias: error: alias " + argv[i] + " not found\n";
1451             else
1452                 out += "alias " + argv[i] + "='" +
1453                        caller->aliases[argv[i]] + "'\n";
1454         }
1455         // create the alias
1456         else
1457         {
1458             a = string( argv[i], 0, j );
1459             b = string( argv[i], j + 1, string::npos );
1460             caller->aliases[a] = b;
1461         }
1462     }
1463
1464     if( len == 0 )
1465     // no arguments specified; print the entire alias map
1466     {
1467         map< string, string>::iterator i = caller->aliases.begin(),
1468                                        end = caller->aliases.end();
1469         for( ; i != end; i++ )
1470             out += "alias " + i->first + "='" + i->second + "'\n";
1471     }
1472
1473     return 0;
1474 }
1475
1476 //-----------------------------------------------------------------------------
1477 // name: execute()
1478 // desc: ...
1479 //-----------------------------------------------------------------------------
1480 t_CKINT Chuck_Shell::Command_Unalias::execute( vector< string > & argv,
1481                                                string & out )
1482 {
1483     vector<string>::size_type i, len = argv.size();
1484
1485     for( i = 0; i < len; i++ )
1486     {
1487         if( caller->aliases.find( argv[i] ) == caller->aliases.end() )
1488             out += "error: alias " + argv[i] + " not found\n";
1489
1490         else
1491             caller->aliases.erase( argv[i] );
1492     }
1493
1494     return 0;
1495 }
1496
1497 //-----------------------------------------------------------------------------
1498 // name: execute()
1499 // desc: ...
1500 //-----------------------------------------------------------------------------
1501 t_CKINT Chuck_Shell::Command_Source::execute( vector< string > & argv,
1502                                               string & out )
1503 {
1504     vector<string>::size_type i, len = argv.size();
1505     char line_buf[255];
1506     string line, temp;
1507
1508     for( i = 0; i < len; i++ )
1509     {
1510         FILE * source_file = fopen( argv[i].c_str(), "r" );
1511
1512         if( source_file == NULL )
1513             out += "error: unable to open file " + argv[i];
1514
1515         else
1516         {
1517             while( fgets( line_buf, 255, source_file ) != NULL )
1518             {
1519                 line = string( line_buf );
1520                 caller->execute( line, temp );
1521                 out += temp;
1522             }
1523         }
1524     }
1525
1526     return 0;
1527 }
1528
1529 //-----------------------------------------------------------------------------
1530 // name: execute()
1531 // desc: ...
1532 //-----------------------------------------------------------------------------
1533 t_CKINT Chuck_Shell::Command_Help::execute( vector< string > & argv,
1534                                             string & out )
1535 {
1536     out += "";
1537     return 0;
1538 }
1539
1540 //-----------------------------------------------------------------------------
1541 // name: init()
1542 // desc: ...
1543 //-----------------------------------------------------------------------------
1544 t_CKBOOL Chuck_Shell::Command_VM::init( Chuck_Shell * caller )
1545 {
1546     Command * temp;
1547
1548     Command::init( caller );
1549
1550     temp = new Command_VMAttach();
1551     temp->init( caller );
1552     commands["attach"] = temp;
1553     commands["@"] = temp;
1554     allocated_commands.push_back( temp );
1555
1556     temp = new Command_VMAdd();
1557     temp->init( caller );
1558     commands["add"] = temp;
1559     commands["+"] = temp;
1560     allocated_commands.push_back( temp );
1561
1562     temp = new Command_VMRemove();
1563     temp->init( caller );
1564     commands["remove"] = temp;
1565     commands["-"] = temp;
1566     allocated_commands.push_back( temp );
1567
1568     temp = new Command_VMList();
1569     temp->init( caller );
1570     commands["list"] = temp;
1571     allocated_commands.push_back( temp );
1572
1573     temp = new Command_VMSwap();
1574     temp->init( caller );
1575     commands["swap"] = temp;
1576     commands["<"] = temp;
1577     commands["<-"] = temp;
1578     allocated_commands.push_back( temp );
1579
1580     temp = new Command_VMAttachAdd();
1581     temp->init( caller );
1582     commands["@+"] = temp;
1583     allocated_commands.push_back( temp );
1584
1585     return TRUE;
1586 }
1587
1588 //-----------------------------------------------------------------------------
1589 // name: ~Command_VM()
1590 // desc: ...
1591 //-----------------------------------------------------------------------------
1592 Chuck_Shell::Command_VM::~Command_VM()
1593 {
1594     vector<string>::size_type i, len = allocated_commands.size();
1595
1596     //iterate through commands, delete the associated heap data
1597     for( i = 0; i != len; i++ )
1598         SAFE_DELETE( allocated_commands[i] );
1599 }
1600
1601 //-----------------------------------------------------------------------------
1602 // name: execute()
1603 // desc: ...
1604 //-----------------------------------------------------------------------------
1605 t_CKINT Chuck_Shell::Command_VM::execute( vector< string > & argv,
1606                                           string & out )
1607 {
1608     if( argv.size() < 1)
1609         out += "usage: " + usage() + "\n";
1610
1611     else if( commands.find( argv[0] ) == commands.end() )
1612     // command doesn't exist
1613         out += "error: vm " + argv[0] + ": command not found\n";
1614
1615     else
1616     // call the mapped command
1617     {
1618         Command * command = commands[argv[0]];
1619         argv.erase( argv.begin() );
1620         command->execute( argv, out );
1621     }
1622
1623     return 0;
1624 }
1625
1626 //-----------------------------------------------------------------------------
1627 // name: usage()
1628 // desc: ...
1629 //-----------------------------------------------------------------------------
1630 string Chuck_Shell::Command_VM::usage()
1631 {
1632     return "vm [command] [args] ...";
1633 }
1634
1635 //-----------------------------------------------------------------------------
1636 // name: execute()
1637 // desc: ...
1638 //-----------------------------------------------------------------------------
1639 t_CKINT Chuck_Shell::Command_VMAttach::execute( vector < string > & argv,
1640                                                 string & out )
1641 {
1642     string hostname;
1643     t_CKINT port;
1644     t_CKINT result = 0;
1645
1646     /* parse the hostname:port */
1647     if( argv.size() == 0 )
1648     /* no hostname:port specified, use default */
1649     {
1650         argv.push_back( "localhost:8888" );
1651         hostname = "localhost";
1652         port = 8888;
1653     }
1654
1655     else
1656     {
1657         string::size_type i = argv[0].find( ":" );
1658
1659         if( i == string::npos )
1660         // couldn't find a port number; use the default
1661         {
1662             hostname = argv[0];
1663             port = 8888;
1664             argv[0] += ":8888";
1665         }
1666
1667         else
1668         {
1669             port = strtol( argv[0].c_str() + i + 1, NULL, 10 );
1670             if( port == 0 )
1671                 out += string( "error: invalid port '" ) +
1672                        string( argv[0].c_str() + i + 1 ) + "'\n";
1673
1674             else
1675                 hostname = string( argv[0], 0, i );
1676         }
1677     }
1678
1679     if( port != 0 )
1680     {
1681         //string temp;
1682
1683         Chuck_Shell_Network_VM * new_vm = new Chuck_Shell_Network_VM();
1684         new_vm->init( hostname, port );
1685
1686         /*if( !new_vm->status( temp ) )
1687         {
1688             SAFE_DELETE( new_vm );
1689             result = -1;
1690         }*/
1691
1692         SAFE_DELETE( caller->current_vm );
1693         caller->current_vm = new_vm;
1694         out += argv[0] + " is now current VM\n";
1695         result = 0;
1696     }
1697
1698     else
1699     {
1700         out += "error: unable to attach to " + argv[0] + "\n";
1701         result = -1;
1702     }
1703
1704     if( argv.size() > 1 )
1705         out += "warning: ignoring excess arguments...\n";
1706
1707     return result;
1708 }
1709
1710 //-----------------------------------------------------------------------------
1711 // name: execute()
1712 // desc: ...
1713 //-----------------------------------------------------------------------------
1714 t_CKINT Chuck_Shell::Command_VMAdd::execute( vector< string > & argv,
1715                                              string & out )
1716 {
1717     char buf[16];
1718
1719     if( caller->current_vm == NULL )
1720     {
1721         out += "error: no VM to save\n";
1722         return -1;
1723     }
1724
1725     caller->vms.push_back( caller->current_vm->copy() );
1726
1727 #ifndef __PLATFORM_WIN32__
1728     snprintf( buf, 16, "%u", caller->vms.size() - 1 );
1729 #else
1730     sprintf( buf, "%u", caller->vms.size() - 1 );
1731 #endif // __PLATFORM_WIN32__
1732
1733     out += caller->current_vm->fullname() + " saved as VM " + buf + "\n";
1734
1735     if( argv.size() > 0 )
1736         out += "warning: ignoring excess arguments...\n";
1737
1738     return 0;
1739 }
1740
1741 //-----------------------------------------------------------------------------
1742 // name: execute()
1743 // desc: ...
1744 //-----------------------------------------------------------------------------
1745 t_CKINT Chuck_Shell::Command_VMRemove::execute( vector< string > & argv,
1746                                                 string & out )
1747 {
1748     vector<string>::size_type i = 0, vm_no, len = argv.size();
1749
1750     for( ; i < len; i++ )
1751     {
1752         vm_no = strtoul( argv[i].c_str(), NULL, 10 );
1753         if( vm_no == 0 && errno == EINVAL || caller->vms.size() <= vm_no ||
1754             caller->vms[vm_no] == NULL )
1755         {
1756             out += "error: invalid VM id: " + argv[i] + "\n";
1757         }
1758         else
1759         {
1760             SAFE_DELETE( caller->vms[vm_no] );
1761         }
1762     }
1763
1764     return 0;
1765 }
1766
1767 //-----------------------------------------------------------------------------
1768 // name: execute()
1769 // desc: ...
1770 //-----------------------------------------------------------------------------
1771 t_CKINT Chuck_Shell::Command_VMSwap::execute( vector< string > & argv,
1772                                               string & out )
1773 {
1774     vector<string>::size_type new_vm = 0;
1775
1776     if( argv.size() < 1 )
1777     {
1778         out += string( "error: too few arguments...\n" );
1779         return -1;
1780     }
1781
1782     new_vm = strtol( argv[0].c_str(), NULL, 10 );
1783     if( new_vm >= caller->vms.size() || new_vm < 0 ||
1784         caller->vms[new_vm] == NULL )
1785     {
1786         out += string( "error: invalid VM: " ) + argv[0] + "\n";
1787         return -1;
1788     }
1789
1790     SAFE_DELETE( caller->current_vm );
1791     caller->current_vm = caller->vms[new_vm]->copy();
1792     out += "current VM is now " + caller->current_vm->fullname() + "\n";
1793
1794     if( argv.size() > 1 )
1795         out += "warning: ignoring excess arguments...\n";
1796
1797     return 0;
1798 }
1799
1800 //-----------------------------------------------------------------------------
1801 // name: execute()
1802 // desc: ...
1803 //-----------------------------------------------------------------------------
1804 t_CKINT Chuck_Shell::Command_VMList::execute( vector< string > & argv,
1805                                               string & out )
1806 {
1807     char buf[16];
1808     vector<string>::size_type i, len = caller->vms.size();
1809
1810     if( caller->current_vm != NULL )
1811         out += string("current VM: ") + caller->current_vm->fullname() + "\n";
1812
1813     for( i = 0; i < len; i++ )
1814     {
1815         if( caller->vms[i] != NULL )
1816         {
1817 #ifndef __PLATFORM_WIN32__
1818             snprintf( buf, 16, "%u", i );
1819 #else
1820             sprintf( buf, "%u", i );
1821 #endif // __PLATFORM_WIN32__
1822             out += string( "VM " ) + buf + ": " +
1823                    caller->vms[i]->fullname() + "\n";
1824         }
1825     }
1826
1827     if( argv.size() > 0 )
1828         out += "warning: ignoring excess arguments...\n";
1829
1830     return 0;
1831 }
1832
1833 //-----------------------------------------------------------------------------
1834 // name: execute()
1835 // desc: ...
1836 //-----------------------------------------------------------------------------
1837 t_CKINT Chuck_Shell::Command_VMAttachAdd::execute( vector< string > & argv,
1838                                                    string & out )
1839 {
1840     t_CKINT result = 0;
1841     string exec = string( "vm @ " ) + ( argv.size() > 0 ? argv[0] : "" );
1842
1843     if( caller->execute( exec, out ) )
1844     {
1845         exec = "vm + ";
1846         if( caller->execute( exec, out ) )
1847             result = 0;
1848
1849         else
1850             result = -1;
1851     }
1852
1853     else
1854         result = -1;
1855
1856     return result;
1857 }
1858
1859 //-----------------------------------------------------------------------------
1860 // name: init()
1861 // desc: ...
1862 //-----------------------------------------------------------------------------
1863 t_CKBOOL Chuck_Shell::Command_Code::init( Chuck_Shell * caller )
1864 {
1865     Command * temp;
1866
1867     Command::init( caller );
1868
1869     temp = new Command_CodeSave();
1870     temp->init( caller );
1871     commands["save"] = temp;
1872     allocated_commands.push_back( temp );
1873
1874     temp = new Command_CodeList();
1875     temp->init( caller );
1876     commands["list"] = temp;
1877     allocated_commands.push_back( temp );
1878
1879     temp = new Command_CodePrint();
1880     temp->init( caller );
1881     commands["print"] = temp;
1882     allocated_commands.push_back( temp );
1883
1884     temp = new Command_CodeDelete();
1885     temp->init( caller );
1886     commands["delete"] = temp;
1887     allocated_commands.push_back( temp );
1888
1889     temp = new Command_CodeWrite();
1890     temp->init( caller );
1891     commands["write"] = temp;
1892     allocated_commands.push_back( temp );
1893
1894     temp = new Command_CodeRead();
1895     temp->init( caller );
1896     commands["read"] = temp;
1897     allocated_commands.push_back( temp );
1898
1899     temp = new Command_CodeAdd();
1900     temp->init( caller );
1901     commands["add"] = temp;
1902     commands["+"] = temp;
1903     allocated_commands.push_back( temp );
1904
1905     return TRUE;
1906 }
1907
1908 //-----------------------------------------------------------------------------
1909 // name: ~Command_Code()
1910 // desc: ...
1911 //-----------------------------------------------------------------------------
1912 Chuck_Shell::Command_Code::~Command_Code()
1913 {
1914     vector<string>::size_type i, len = allocated_commands.size();
1915
1916     //iterate through commands, delete the associated heap data
1917     for( i = 0; i != len; i++ )
1918         SAFE_DELETE( allocated_commands[i] );
1919 }
1920
1921 //-----------------------------------------------------------------------------
1922 // name: execute()
1923 // desc: ...
1924 //-----------------------------------------------------------------------------
1925 t_CKINT Chuck_Shell::Command_Code::execute( vector< string > & argv,
1926                                             string & out )
1927 {
1928     if( argv.size() < 1)
1929         out += "usage: " + usage() + "\n";
1930
1931     else if( commands.find( argv[0] ) == commands.end() )
1932         // command doesn't exist
1933         out += "error: code " + argv[0] + ": command not found\n";
1934
1935     else
1936     {
1937         // call the mapped command
1938         Command * command = commands[argv[0]];
1939         argv.erase( argv.begin() );
1940         command->execute( argv, out );
1941     }
1942
1943     return 0;
1944 }
1945
1946 //-----------------------------------------------------------------------------
1947 // name: usage()
1948 // desc: ...
1949 //-----------------------------------------------------------------------------
1950 string Chuck_Shell::Command_Code::usage()
1951 {
1952     return "code [command] [args] ...";
1953 }
1954
1955 //-----------------------------------------------------------------------------
1956 // name: execute()
1957 // desc: ...
1958 //-----------------------------------------------------------------------------
1959 t_CKINT Chuck_Shell::Command_CodeSave::execute( vector < string > & argv,
1960                                                 string & out )
1961 {
1962     if( argv.size() < 1 )
1963     {
1964         out += "error: please specify a name to identify the code\n";
1965     }
1966     else
1967     {
1968         if( caller->code == "" )
1969             out += "error: no code to save\n";
1970
1971         else
1972             caller->saved_code[argv[0]] = caller->code;
1973
1974         if( argv.size() > 1 )
1975             out += "warning: ignoring excess arguments...\n";
1976     }
1977
1978     return 0;
1979 }
1980
1981 //-----------------------------------------------------------------------------
1982 // name: execute()
1983 // desc: ...
1984 //-----------------------------------------------------------------------------
1985 t_CKINT Chuck_Shell::Command_CodeList::execute( vector < string > & argv,
1986                                                 string & out )
1987 {
1988     map< string, string >::iterator i = caller->saved_code.begin(),
1989                                      end = caller->saved_code.end();
1990     for( ; i != end; i++ )
1991         out += i->first + "\n";
1992
1993     if( argv.size() > 0 )
1994         out += "warning: ignoring excess arguments...\n";
1995
1996     return 0;
1997 }
1998
1999 //-----------------------------------------------------------------------------
2000 // name: execute()
2001 // desc: ...
2002 //-----------------------------------------------------------------------------
2003 t_CKINT Chuck_Shell::Command_CodeAdd::execute( vector < string > & argv,
2004                                                string & out )
2005 {
2006     if( argv.size() == 0 )
2007     {
2008         if( caller->code != "" )
2009             caller->do_code( caller->code, out );
2010
2011         else
2012             out += "error: no code to add\n";
2013     }
2014
2015     else
2016     {
2017         vector<string>::size_type i, len;
2018         for( i = 0, len = argv.size(); i < len; i++ )
2019         {
2020             // iterate through all of the arguments, add the saved codes
2021             if( caller->saved_code.find( argv[i] ) ==
2022                 caller->saved_code.end() )
2023                 out += "error: code " + argv[i] + " not found\n";
2024
2025             else
2026                 caller->do_code( caller->code, out );
2027         }
2028     }
2029
2030     return 0;
2031 }
2032
2033 //-----------------------------------------------------------------------------
2034 // name: execute()
2035 // desc: ...
2036 //-----------------------------------------------------------------------------
2037 t_CKINT Chuck_Shell::Command_CodePrint::execute( vector < string > & argv,
2038                                                  string & out )
2039 {
2040     if( argv.size() == 0 )
2041     {
2042         if( caller->code != "" )
2043             out += caller->code + "\n";
2044         else
2045             out += "error: no code to print\n";
2046     }
2047
2048     else
2049     {
2050         vector<string>::size_type i, len;
2051         for( i = 0, len = argv.size(); i < len; i++ )
2052         {
2053             if( caller->saved_code.find( argv[i] ) ==
2054                 caller->saved_code.end() )
2055             {
2056                 out += "error: code " + argv[i] + " not found\n";
2057             }
2058             else
2059             {
2060                 string code = caller->saved_code[argv[i]];
2061
2062                 out += argv[i] + ":\n";
2063                 out += code + "\n";
2064             }
2065         }
2066     }
2067
2068     return 0;
2069 }
2070
2071 //-----------------------------------------------------------------------------
2072 // name: execute()
2073 // desc: ...
2074 //-----------------------------------------------------------------------------
2075 t_CKINT Chuck_Shell::Command_CodeDelete::execute( vector < string > & argv,
2076                                                   string & out )
2077 {
2078     if( argv.size() == 0 )
2079     {
2080         out += "error: specify the code to delete\n";
2081     }
2082     else
2083     {
2084         vector<string>::size_type i, len;
2085         for( i = 0, len = argv.size(); i < len; i++ )
2086         {
2087             if( caller->saved_code.find( argv[i] ) ==
2088                 caller->saved_code.end() )
2089                 out += "error: code " + argv[i] + " not found\n";
2090
2091             else
2092             {
2093                 caller->saved_code.erase( argv[i] );
2094             }
2095         }
2096     }
2097
2098     return 0;
2099 }
2100
2101 //-----------------------------------------------------------------------------
2102 // name: execute()
2103 // desc: ...
2104 //-----------------------------------------------------------------------------
2105 t_CKINT Chuck_Shell::Command_CodeWrite::execute( vector < string > & argv,
2106                                                  string & out )
2107 {
2108     if( argv.size() < 1 )
2109     {
2110         out += "error: insufficient arguments...\n";
2111     }
2112     else
2113     {
2114         if( caller->saved_code.find( argv[0] ) == caller->saved_code.end() )
2115         {
2116             // this code doesnt exist!
2117             out += "error: code " + argv[0] + " not found\n";
2118         }
2119         else
2120         {
2121             string filename;
2122             string code = caller->saved_code[argv[0]];
2123             FILE * write_file;
2124
2125             if( argv.size() >= 2 )
2126             {
2127                 // use second argument as filename
2128                 filename = argv[1];
2129             }
2130             else
2131             {
2132                 // append .ck to the code name to get the file name
2133                 filename = argv[0] + ".ck";
2134             }
2135
2136             // open the file
2137             write_file = fopen( filename.c_str(), "w" );
2138
2139             if( write_file == NULL )
2140             {
2141                 out += "error: unable to open " + filename + " for writing\n";
2142             }
2143             else
2144             {
2145                 // write code to the file
2146                 if( fprintf( write_file, "%s", code.c_str() ) < 0 )
2147                     out += "error: unable to write to " + filename + "\n";
2148
2149                 fclose( write_file );
2150             }
2151         }
2152     }
2153
2154     if( argv.size() > 2 )
2155         out += "warning: ignoring excess arguments...\n";
2156
2157     return 0;
2158 }
2159
2160 //-----------------------------------------------------------------------------
2161 // name: execute()
2162 // desc: ...
2163 //-----------------------------------------------------------------------------
2164 t_CKINT Chuck_Shell::Command_CodeRead::execute( vector < string > & argv,
2165                                                 string & out )
2166 {
2167     if( argv.size() < 1 )
2168     {
2169         out += "error: insufficient arguments...\n";
2170     }
2171     else
2172     {
2173         string code_name;
2174         FILE * read_file;
2175
2176         if( argv.size() >= 2 )
2177         {
2178             // use second argument as the code_name
2179             code_name = argv[1];
2180         }
2181         else
2182         {
2183             // remove the file extension to get the code_name
2184             // or use the whole filename if there is no extension
2185             string::size_type k = argv[0].rfind( "." );
2186
2187             if( k == string::npos )
2188                 code_name = argv[1];
2189             else
2190                 code_name = string( argv[0], 0, k );
2191         }
2192
2193         // open the file
2194         read_file = fopen( argv[0].c_str(), "r" );
2195         if( read_file == NULL )
2196             out += "error: unable to open " + argv[0] + " for reading\n";
2197
2198         else
2199         {
2200             string code = "";
2201             char buffer[256], * result = fgets( buffer, 256, read_file );
2202
2203             if( result == NULL )
2204                 out += "error: unable to read " + argv[0] +
2205                     ", or file is empty\n";
2206
2207             else
2208             {
2209                 while( result != NULL )
2210                 {
2211                     code += buffer;
2212                     result = fgets( buffer, 256, read_file );
2213                 }
2214
2215                 caller->saved_code[code_name] = code;
2216             }
2217
2218             fclose( read_file );
2219         }
2220     }
2221
2222     if( argv.size() > 2 )
2223         out += "warning: ignoring excess arguments...\n";
2224
2225     return 0;
2226 }