vimsh/vimsh.py

   1 #ls###############################################################################
   2 #
   3 # file:     vimsh.py
   4 # purpose:  allows execution of shell commands in a vim buffer
   5 #
   6 # author:   brian m sturk   bsturk@adelphia.net,
   7 #                           http://users.adelphia.net/~bsturk
   8 # created:  12/02/01
   9 # last_mod: 03/26/04
  10 # version:  0.20
  11 #
  12 # usage, etc:   see vimsh.readme
  13 # history:      see ChangeLog
  14 # in the works: see TODO
  15 #
  16 ###############################################################################
  17
  18 import vim, sys, os, string, signal, re, time
  19
  20 ##  NOTE: If you're having a problem running vimsh, please
  21 ##        change the 0 to a 1 for _DEBUG_ and send me an email
  22 ##        of the output.
  23
  24 _DEBUG_   = 0
  25 _BUFFERS_ = []
  26
  27 ################################################################################
  28
  29 try:
  30     if sys.platform == 'win32':
  31         import popen2, stat
  32         use_pty   = 0
  33
  34     else:
  35         import pty, tty, select
  36         use_pty   = 1
  37
  38 except ImportError:
  39     print 'vimsh: import error'
  40
  41 ################################################################################
  42 ##                             class vimsh                                    ##
  43 ################################################################################
  44
  45 class vimsh:
  46     def __init__( self, _sh, _arg, _filename ):
  47
  48         self.sh        = _sh
  49         self.arg       = _arg
  50         self.filename  = _filename
  51
  52         self.prompt_line, self.prompt_cursor = self.get_vim_cursor_pos()
  53
  54         self.password_regex   = [ '^\s*Password:',         ##  su, ssh, ftp
  55                                   'password:',             ##  ???, seen this somewhere
  56                                   'Password required' ]    ##  other ftp clients
  57
  58         self.last_cmd_executed     = "foobar"
  59         self.keyboard_interrupt    = 0
  60         self.shell_exited          = 0
  61         self.buffer                = vim.current.buffer
  62
  63 ################################################################################
  64
  65     def setup_pty( self, _use_pty ):
  66
  67         self.using_pty = _use_pty
  68
  69         if _use_pty:
  70
  71             ##  The lower this number is the more responsive some commands
  72             ##  may be ( printing prompt, ls ), but also the quicker others
  73             ##  may timeout reading their output ( ping, ftp )
  74
  75             self.delay = 0.1
  76
  77             ##  Hack to get pty name until I can figure out to get name
  78             ##  of slave pty using pty.fork() I've tried everything
  79             ##  including using all of the python src for pty.fork().
  80             ##  I'm probably trying to do something I can't do. However,
  81             ##  there does seem to be a std call named ptsname() which
  82             ##  returns the slave pty name i.e. /dev/pty/XX
  83
  84             ##  Assumption is, that between the dummy call to
  85             ##  master_open is done and the pty.fork happens, we'll be
  86             ##  the next pty entry after the one from pty.master_open()
  87             ##  According to SysV docs it will look for the first
  88             ##  unused, so this shouldn't be too bad besides its looks.
  89             ##  Only have to make sure they're not already in use and
  90             ##  if it is try the next one etc.
  91
  92             self.master, pty_name = pty.master_open()
  93             dbg_print ( 'setup_pty: slave pty name is ' + pty_name )
  94
  95             self.pid, self.fd = pty.fork()
  96
  97             self.outd = self.fd
  98             self.ind  = self.fd
  99             self.errd = self.fd
 100
 101             signal.signal( signal.SIGCHLD, self.sigchld_handler )
 102
 103             if self.pid == 0:
 104
 105                 ##  In spawned shell process, NOTE: any 'print'ing done within
 106                 ##  here will corrupt vim.
 107
 108                 attrs = tty.tcgetattr( 1 )
 109
 110                 attrs[ 6 ][ tty.VMIN ]  = 1
 111                 attrs[ 6 ][ tty.VTIME ] = 0
 112                 attrs[ 0 ] = attrs[ 0 ] | tty.BRKINT
 113                 attrs[ 0 ] = attrs[ 0 ] & tty.IGNBRK
 114                 attrs[ 3 ] = attrs[ 3 ] & ~tty.ICANON & ~tty.ECHO
 115
 116                 tty.tcsetattr( 1, tty.TCSANOW, attrs )
 117
 118                 if self.arg != '':
 119                     os.execv( self.sh, [ self.sh, self.arg ] )
 120
 121                 else:
 122                     os.execv( self.sh, [ self.sh, ] )
 123
 124             else:
 125
 126                 try:
 127                     attrs = tty.tcgetattr( 1 )
 128
 129                     termios_keys = attrs[ 6 ]
 130
 131                 except:
 132                     dbg_print ( 'setup_pty: tcgetattr failed' )
 133                     return
 134
 135                 #  Get *real* key-sequence for standard input keys, i.e. EOF
 136
 137                 self.eof_key   = termios_keys[ tty.VEOF ]
 138                 self.eol_key   = termios_keys[ tty.VEOL ]
 139                 self.erase_key = termios_keys[ tty.VERASE ]
 140                 self.intr_key  = termios_keys[ tty.VINTR ]
 141                 self.kill_key  = termios_keys[ tty.VKILL ]
 142                 self.susp_key  = termios_keys[ tty.VSUSP ]
 143
 144         else:
 145
 146             ##  Use pipes on Win32. not as reliable/nice. works OK but with limitations.
 147
 148             self.delay = 0.2
 149
 150             try:
 151                 import win32pipe
 152
 153                 dbg_print ( 'setup_pty: using windows extensions' )
 154                 self.stdin, self.stdout, self.stderr = win32pipe.popen3( self.sh + " " + self.arg )
 155
 156             except ImportError:
 157
 158                 dbg_print ( 'setup_pty: not using windows extensions' )
 159                 self.stdout, self.stdin, self.stderr = popen2.popen3( self.sh + " " + self.arg, -1, 'b' )
 160
 161             self.outd = self.stdout.fileno()
 162             self.ind  = self.stdin.fileno ()
 163             self.errd = self.stderr.fileno()
 164
 165             self.intr_key = '\x03'
 166             self.eof_key  = '\x04'
 167
 168 ################################################################################
 169
 170     def execute_cmd( self, _cmd = None, _null_terminate = 1 ):
 171
 172         dbg_print ( 'execute_cmd: Entered cmd is ' + str( _cmd ) )
 173
 174         if self.keyboard_interrupt:
 175             dbg_print( 'execute_cmd: keyboard interrupt earlier, cleaning up' )
 176
 177             self.page_output( 1 )
 178             self.keyboard_interrupt = 0
 179
 180             return
 181
 182         ##  This is the main worker function
 183
 184         try:
 185             print ""            ## Clears the ex command window
 186
 187             cur = self.buffer
 188             cur_line, cur_row = self.get_vim_cursor_pos()
 189
 190             if _cmd == None:
 191
 192                 ## Grab everything from the prompt to the current cursor position.
 193
 194                 _cmd    = cur[ self.prompt_line - 1 : cur_line ]        # whole line
 195                 _cmd[0] = _cmd[0][ ( self.prompt_cursor - 1 ) : ]       # remove prompt, zero based slicing
 196
 197             if re.search( r'^\s*\bclear\b', _cmd[0] ) or re.search( r'^\s*\bcls\b', _cmd[0] ):
 198
 199                 dbg_print ( 'execute_cmd: clear detected' )
 200                 self.clear_screen( True )
 201
 202             elif re.search( r'^\s*\exit\b', _cmd[0] ):
 203
 204                 dbg_print ( 'execute_cmd: exit detected' )
 205                 self.handle_exit_cmd( _cmd )
 206
 207             else:
 208
 209                 dbg_print ( 'execute_cmd: other command executed' )
 210
 211                 for c in _cmd:
 212                     if _null_terminate:
 213                         self.write( c + '\n' )
 214
 215                     else:
 216                         self.write( c )
 217
 218                 self.end_exe_line()
 219                 vim.command( "startinsert!" )
 220
 221             self.last_cmd_executed = _cmd[0]
 222
 223         except KeyboardInterrupt:
 224
 225             dbg_print( 'execute_cmd: in keyboard interrupt exception, sending SIGINT' )
 226
 227             self.keyboard_interrupt = 1
 228
 229             ##  TODO: Sending Ctrl-C isn't working on Windows yet, so
 230             ##        executing something like 'findstr foo' will hang.
 231
 232             if sys.platform != 'win32':
 233                 self.send_intr()
 234
 235 ################################################################################
 236
 237     def end_exe_line( self ):
 238
 239         ##  read anything that's on stdout after a command is executed
 240
 241         dbg_print( 'end_exe_line: enter' )
 242
 243         cur = self.buffer
 244
 245         cur.append( "" )
 246         vim.command( "normal G$" )
 247
 248         self.read( cur )
 249         self.check_for_passwd()
 250
 251 ################################################################################
 252
 253     def write( self, _cmd ):
 254
 255         dbg_print( 'write: writing out --> ' + _cmd )
 256
 257         os.write( self.ind, _cmd )
 258
 259 ################################################################################
 260
 261     def read( self, _buffer ):
 262
 263         num_iterations       = 0      ##  counter for periodic redraw
 264         iters_before_redraw  = 10
 265         any_lines_read       = 0      ##  sentinel for reading anything at all
 266
 267         if sys.platform == 'win32':
 268             iters_before_redraw = 1
 269
 270         while 1:
 271             if self.using_pty:
 272                 r, w, e = select.select( [ self.outd ], [], [], self.delay )
 273
 274             else:
 275                 r = [1,]  ##  pipes, unused, fake it out so I don't have to special case
 276
 277             for file_iter in r:
 278
 279                 lines = ''
 280
 281                 if self.using_pty:
 282                     lines = os.read( self.outd, 32 )
 283
 284                 else:
 285                     lines = self.pipe_read( self.outd, 2048 )
 286
 287                 if lines == '':
 288                     dbg_print( 'read: No more data on stdout pipe_read' )
 289
 290                     r = []          ##  sentinel, end of data to read
 291                     break
 292
 293                 any_lines_read  = 1
 294                 num_iterations += 1
 295
 296                 lines = self.process_read( lines )
 297                 self.print_lines( lines, _buffer )
 298
 299                 ##  Give vim a little cpu time, so programs that spit
 300                 ##  output or are long operations seem more responsive
 301
 302                 if not num_iterations % iters_before_redraw:
 303                     dbg_print( 'read: Letting vim redraw' )
 304                     vim.command( 'call VimShRedraw()' )
 305
 306             if r == []:
 307                 dbg_print( 'read: end of data to self.read()' )
 308                 self.end_read( any_lines_read )
 309
 310                 break
 311
 312 ################################################################################
 313
 314     def process_read( self, _lines ):
 315
 316         dbg_print( 'process_read: Raw lines read from stdout:' )
 317         dbg_print( _lines )
 318
 319         lines_to_print = string.split( _lines, '\n' )
 320
 321         ##  On windows cmd is "echoed" and output sometimes has leading empty line
 322
 323         if sys.platform == 'win32':
 324             m = re.search( re.escape( self.last_cmd_executed.strip() ), lines_to_print[ 0 ] )
 325
 326             if m != None or lines_to_print[ 0 ] == "":
 327                 dbg_print( 'process_read: Win32, removing leading blank line' )
 328                 lines_to_print = lines_to_print[ 1: ]
 329
 330         num_lines = len( lines_to_print )
 331
 332         ##  Split on '\n' sometimes returns n + 1 entries
 333
 334         if num_lines > 1:
 335             last_line = lines_to_print[ num_lines - 1 ].strip()
 336
 337             if last_line == "":
 338                 lines_to_print = lines_to_print[ :-1 ]
 339
 340         errors = self.chk_stderr()
 341
 342         if errors:
 343             dbg_print( 'process_read: Prepending stderr --> ' )
 344             lines_to_print = errors + lines_to_print
 345
 346         return lines_to_print
 347
 348 ################################################################################
 349
 350     def print_lines( self, _lines, _buffer ):
 351
 352         num_lines = len( _lines )
 353
 354         dbg_print( 'print_lines: Number of lines to print--> ' + str( num_lines ) )
 355
 356         for line_iter in _lines:
 357
 358             dbg_print( 'print_lines: Current line is --> %s' % line_iter )
 359
 360             m = None
 361
 362             while re.search( '\r$', line_iter ):
 363
 364                 dbg_print( 'print_lines: removing trailing ^M' )
 365
 366                 line_iter = line_iter[ :-1 ]   #  Force it
 367                 m = True
 368
 369             ##  Jump to the position of the last insertion to the buffer
 370             ##  if it was a new line it should be 1, if it wasn't
 371             ##  terminated by a '\n' it should be the end of the string
 372
 373             vim.command( "normal " + str( self.prompt_cursor ) + "|" )
 374
 375             cur_line, cur_row = self.get_vim_cursor_pos()
 376             dbg_print( 'print_lines: After jumping to end of last cmd: line %d row %d' % ( cur_line, cur_row ) )
 377
 378             dbg_print( 'print_lines: Pasting ' + line_iter + ' to current line' )
 379             _buffer[ cur_line - 1 ] += line_iter
 380
 381             ##  If there's a '\n' or using pipes and it's not the last line
 382
 383             if not self.using_pty or m != None:
 384
 385                 dbg_print( 'print_lines: Appending new line since ^M or not using pty' )
 386                 _buffer.append( "" )
 387
 388             vim.command( "normal G$" )
 389             vim.command( "startinsert!" )
 390
 391             self.prompt_line, self.prompt_cursor = self.get_vim_cursor_pos()
 392             dbg_print( 'print_lines: Saving cursor location: line %d row %d ' % ( self.prompt_line, self.prompt_cursor ) )
 393
 394 ################################################################################
 395
 396     def end_read( self, any_lines_read ):
 397
 398         cur_line, cur_row = self.get_vim_cursor_pos( )
 399
 400         if not self.using_pty and any_lines_read:
 401
 402             ##  remove last line for last read only if lines were
 403             ##  read from stdout.  TODO: any better way to do this?
 404
 405             vim.command( 'normal dd' )
 406
 407         vim.command( "normal G$" )
 408         vim.command( "startinsert!" )
 409
 410         ##  Tuck away location, all data read is in buffer
 411
 412         self.prompt_line, self.prompt_cursor = self.get_vim_cursor_pos()
 413         dbg_print( 'end_read: Saving cursor location: line %d row %d ' % ( self.prompt_line, self.prompt_cursor ) )
 414
 415 ################################################################################
 416
 417     def page_output( self, _add_new_line = 0 ):
 418
 419         dbg_print( 'page_output: enter' )
 420
 421         ##  read anything that's left on stdout
 422
 423         cur = self.buffer
 424
 425         if _add_new_line:
 426
 427             cur.append( "" )
 428             vim.command( "normal G$" )
 429
 430         self.read( cur )
 431
 432         self.check_for_passwd()
 433
 434         vim.command( "startinsert!" )
 435
 436 ################################################################################
 437
 438     def cleanup( self ):
 439
 440         # NOTE: Only called via autocommand
 441
 442         dbg_print( 'cleanup: enter' )
 443
 444         # Remove autocommand so we don't get multiple calls
 445
 446         vim.command( 'au! BufDelete ' + self.filename )
 447
 448         remove_buf( self.filename )
 449
 450         if self.shell_exited:
 451             dbg_print( 'cleanup: process is already dead, nothing to do' )
 452             return
 453
 454         try:
 455
 456             if not self.using_pty:
 457                 os.close( self.ind )
 458                 os.close( self.outd )
 459
 460             os.close( self.errd )       ##  all the same if pty
 461
 462             if self.using_pty:
 463                 os.kill( self.pid, signal.SIGKILL )
 464
 465         except:
 466             dbg_print( 'cleanup: Exception, process probably already killed' )
 467
 468 ################################################################################
 469
 470     def send_intr( self ):
 471
 472         dbg_print( 'send_intr: enter' )
 473
 474         if show_workaround_msgs == '1':
 475             print 'If you do NOT see a prompt in the vimsh buffer, press F5 or go into insert mode and press Enter'
 476             print 'If you need a new prompt press F4'
 477             print 'NOTE: To disable this help message set \'g:vimsh_show_workaround_msgs\' to 0 in your .vimrc'
 478
 479         ##  This triggers another KeyboardInterrupt async
 480
 481         try:
 482             dbg_print( 'send_intr: writing intr_key' )
 483             self.write( self.intr_key )
 484
 485             self.page_output( 1 )
 486
 487         except KeyboardInterrupt:
 488
 489             dbg_print( 'send_intr: caught KeyboardInterrupt in send_intr' )
 490             pass
 491
 492 ################################################################################
 493
 494     def send_eof( self ):
 495
 496         dbg_print( 'send_eof: enter' )
 497
 498         try:     ## could cause shell to exit
 499
 500             self.write( self.eof_key )
 501             self.page_output( 1 )
 502
 503         except Exception, e:
 504
 505             dbg_print( 'send_eof: exception' )
 506
 507             ## shell exited, self.shell_exited may not have been set yet in
 508             ## sigchld_handler.
 509
 510             dbg_print( 'send_eof: shell_exited is ' + str( self.shell_exited ) )
 511
 512             self.exit_shell()
 513
 514 ################################################################################
 515
 516     def handle_exit_cmd( self, _cmd ):
 517
 518         ##  Exit was typed, could be the spawned shell, or a subprocess like
 519         ##  telnet/ssh/etc.
 520
 521         dbg_print( 'handle_exit_cmd: enter' )
 522
 523         if not self.shell_exited:           ##  process is still around
 524
 525             try:    ## could cause shell to exit
 526
 527                 dbg_print ( 'handle_exit_cmd: shell is still around, writing exit command' )
 528                 self.write( _cmd[0] + '\n' )
 529
 530                 self.end_exe_line()
 531                 vim.command( "startinsert!" )
 532
 533             except Exception, e:
 534
 535                 dbg_print( 'handle_exit_cmd: exception' )
 536
 537                 ## shell exited, self.shell_exited may not have been set yet in
 538                 ## sigchld_handler.
 539
 540                 dbg_print( 'handle_exit_cmd: shell_exited is ' + str( self.shell_exited ) )
 541
 542                 self.exit_shell()
 543
 544 ################################################################################
 545
 546     def exit_shell( self ):
 547
 548         dbg_print( 'exit_shell: enter' )
 549
 550         ##  when exiting this way can't have the autocommand
 551         ##  for BufDelete run.  It crashes vim.  TODO:  Figure this out.
 552
 553         vim.command( 'stopinsert' )
 554         vim.command( 'au! BufDelete ' + self.filename )
 555         vim.command( 'bdelete! ' + self.filename )
 556
 557         remove_buf( self.filename )
 558
 559 ################################################################################
 560
 561     def sigchld_handler( self, sig, frame ):
 562
 563         dbg_print( 'sigchld_handler: caught SIGCHLD' )
 564
 565         self.waitpid()
 566
 567 ################################################################################
 568
 569     def sigint_handler( self, sig, frame ):
 570
 571         dbg_print( 'sigint_handler: caught SIGINT' )
 572         dbg_print( '' )
 573
 574         self.waitpid()
 575
 576 ################################################################################
 577
 578     def waitpid( self ):
 579
 580         ##  This routine cannot do anything except for marking that the original
 581         ##  shell process has gone away if it has.  This is due to the async
 582         ##  nature of signals.
 583
 584         if os.waitpid( self.pid, os.WNOHANG )[0]:
 585
 586             self.shell_exited = 1
 587             dbg_print( 'waitpid: shell exited' )
 588
 589         else:
 590
 591             dbg_print( 'waitpid: shell hasn\'t exited, ignoring' )
 592
 593 ################################################################################
 594
 595     def set_timeout( self ):
 596
 597         timeout_ok = 0
 598
 599         while not timeout_ok:
 600
 601             try:
 602                 vim.command( 'let timeout = input( "Enter new timeout in seconds (i.e. 0.1), currently set to ' + str( self.delay ) + ' :  " )' )
 603
 604             except KeyboardInterrupt:
 605                 return
 606
 607             timeout = vim.eval( "timeout" )
 608
 609             if timeout == "":               ##  usr cancelled dialog, break out
 610                 timeout_ok = 1
 611
 612             else:
 613                 timeout = float( timeout )
 614
 615                 if timeout >= 0.1:
 616                     print '      --->   New timeout is ' + str( timeout ) + ' seconds'
 617                     self.delay = timeout
 618                     timeout_ok = 1
 619
 620 ################################################################################
 621
 622     def clear_screen( self, in_insert_mode ):
 623
 624         dbg_print( 'clear_screen: insert mode is ' + str( in_insert_mode )  )
 625
 626         self.write( "" + "\n" )    ##   new prompt
 627
 628         if clear_all == '1':
 629             vim.command( "normal ggdG" )
 630
 631         self.end_exe_line()
 632
 633         if clear_all == '0':
 634             vim.command( "normal zt" )
 635
 636         if in_insert_mode:
 637             vim.command( "startinsert!" )
 638
 639         else:
 640             vim.command( 'stopinsert' )
 641
 642 ################################################################################
 643
 644     def new_prompt( self ):
 645
 646         self.execute_cmd( [""] )        #  just press enter
 647
 648         vim.command( "normal G$" )
 649         vim.command( "startinsert!" )
 650
 651 ################################################################################
 652
 653     def get_vim_cursor_pos( self ):
 654
 655         cur_line, cur_row = vim.current.window.cursor
 656
 657         return cur_line, cur_row + 1
 658
 659 ################################################################################
 660
 661     def check_for_passwd( self ):
 662
 663         cur_line, cur_row = self.get_vim_cursor_pos()
 664
 665         prev_line = self.buffer[ cur_line - 1 ]
 666
 667         for regex in self.password_regex:
 668
 669             if re.search( regex, prev_line ):
 670
 671                 try:
 672                     vim.command( 'let password = inputsecret( "Password? " )' )
 673
 674                 except KeyboardInterrupt:
 675                     return
 676
 677                 password = vim.eval( "password" )
 678
 679                 self.execute_cmd( [password] )       ##  recursive call here...
 680
 681 ################################################################################
 682
 683     def pipe_read( self, pipe, minimum_to_read ):
 684
 685         ##  Hackaround since Windows doesn't support select() except for sockets.
 686
 687         dbg_print( 'pipe_read: minimum to read is ' + str( minimum_to_read ) )
 688         dbg_print( 'pipe_read: sleeping for ' + str( self.delay ) + ' seconds' )
 689
 690         time.sleep( self.delay )
 691
 692         count = 0
 693         count = os.fstat( pipe )[stat.ST_SIZE]
 694
 695         data = ''
 696
 697         dbg_print( 'pipe_read: initial count via fstat is ' + str( count ) )
 698
 699         while ( count > 0 ):
 700
 701             tmp = os.read( pipe, 1 )
 702             data += tmp
 703
 704             count = os.fstat( pipe )[stat.ST_SIZE]
 705
 706             if len( tmp ) == 0:
 707                 dbg_print( 'pipe_read: count ' + str( count ) + ' but nothing read' )
 708                 break
 709
 710             ##  Be sure to break the read, if asked to do so,
 711             ##  after we've read in a line termination.
 712
 713             if minimum_to_read != 0 and len( data ) > 0 and data[ len( data ) -1 ] == '\n':
 714
 715                 if len( data ) >= minimum_to_read:
 716                     dbg_print( 'pipe_read: found termination and read at least the minimum asked for' )
 717                     break
 718
 719                 else:
 720                     dbg_print( 'pipe_read: not all of the data has been read: count is ' + str( count ) )
 721
 722         dbg_print( 'pipe_read: returning' )
 723
 724         return data
 725
 726 ################################################################################
 727
 728     def chk_stderr( self ):
 729
 730         errors  = ''
 731         dbg_print( 'chk_stderr: enter' )
 732
 733         if sys.platform == 'win32':
 734
 735             err_txt  = self.pipe_read( self.errd, 0 )
 736             errors   = string.split( err_txt, '\n' )
 737
 738             num_lines = len( errors )
 739             dbg_print( 'chk_stderr: Number of error lines is ' + `num_lines` )
 740
 741             last_line = errors[ num_lines - 1 ].strip()
 742
 743             if last_line == "":
 744                 dbg_print( 'chk_stderr: Removing last line, it\'s empty' )
 745                 errors = errors[ :-1 ]
 746
 747         return errors
 748
 749 ################################################################################
 750
 751     #def thread_worker( self ):
 752
 753         #self.idle = 0
 754         ## Not working 100% yet
 755         #thread.start_new_thread( self.thread_worker, () )
 756
 757         #try:
 758             #while 1:
 759
 760                 #time.sleep( 5.0 )
 761
 762                 ## This doesn't seem to work
 763                 ##  vim.command( 'let dummy = remote_send( v:servername, "<C-\><C-N>:python periodic( \'' + self.filename + '\' )<CR>" )' )
 764
 765                 ## Nor this
 766                 #vim.command( 'let dummy = v:servername' )
 767                 #servername = vim.eval( "dummy" )
 768                 #os.system( 'gvim --remote-send --servername ' + servername + '"<C-\><C-N>:python periodic( ' + self.filename + ')<CR>"' )
 769
 770                 ## or this
 771                 # os.system( 'gvim --remote-expr ":python periodic( \'' + self.filename + '\' )<CR>"' )
 772
 773                 ## This works well so far ( haven't testing thoroughly though )
 774                 ## only problem is it changes to normal mode while the user may
 775                 ## be typing.
 776
 777                 #os.system( 'gvim --remote-send "<C-\><C-N>:python periodic( \'' + self.filename + '\' )<CR>"' )
 778
 779         #except:
 780             #pass
 781
 782 ################################################################################
 783 ##                           Helper functions                                 ##
 784 ################################################################################
 785
 786 def test_and_set( vim_var, default_val ):
 787
 788     ret = default_val
 789
 790     vim.command( 'let dummy = exists( "' + vim_var + '" )' )
 791     exists = vim.eval( "dummy" )
 792
 793     ##  exists will always be a string representation of the evaluation
 794
 795     if exists != '0':
 796         ret = vim.eval( vim_var )
 797         dbg_print( 'test_and_set: variable ' + vim_var + ' exists, using supplied ' + ret )
 798
 799     else:
 800         dbg_print( 'test_and_set: variable ' + vim_var + ' doesn\'t exist, using default ' + ret )
 801
 802     return ret
 803
 804 ################################################################################
 805
 806 def dump_str_as_hex( _str ):
 807
 808     hex_str = ''
 809
 810     print 'length of string is ' + str( len( _str ) )
 811
 812     for x in range( 0, len( _str ) ):
 813         hex_str = hex_str + hex( ord( _str[x] ) ) + "\n"
 814
 815     print 'raw line ( hex ) is:'
 816     print hex_str
 817
 818 ################################################################################
 819
 820 def dbg_print( _str ):
 821
 822     if _DEBUG_:
 823         print _str
 824
 825 ################################################################################
 826
 827 def new_buf( _filename ):
 828
 829     ##  If a buffer named vimsh doesn't exist create it, if it
 830     ##  does, switch to it.  Use the config options for splitting etc.
 831
 832     filename = _filename
 833
 834     try:
 835         vim.command( 'let dummy = buflisted( "' + filename + '" )' )
 836         exists = vim.eval( "dummy" )
 837
 838         if exists == '0':
 839             dbg_print( 'new_buf: buffer ' + filename + ' doesn\'t exist' )
 840
 841             if split_open == '0':
 842                 vim.command( 'edit ' + filename )
 843
 844             else:
 845                 vim.command( 'new ' + filename )
 846
 847             vim.command( 'setlocal buftype=nofile' )
 848             vim.command( 'setlocal bufhidden=hide' )
 849             vim.command( 'setlocal noswapfile' )
 850             vim.command( 'setlocal tabstop=4' )
 851             vim.command( 'setlocal modifiable' )
 852             vim.command( 'setlocal nowrap' )
 853             vim.command( 'setlocal textwidth=999' )
 854             vim.command( 'setfiletype vim_shell' )
 855
 856             vim.command( 'au BufDelete ' + filename + ' :python lookup_buf( "' + filename + '" ).cleanup()' )
 857
 858             vim.command( 'inoremap <buffer> <CR>  <ESC>:python lookup_buf( "' + filename + '" ).execute_cmd()<CR>' )
 859
 860             vim.command( 'inoremap <buffer> ' + timeout_key + ' <ESC>:python lookup_buf( "' + filename + '" ).set_timeout()<CR>' )
 861             vim.command( 'nnoremap <buffer> ' + timeout_key + ' :python lookup_buf( "' + filename + '" ).set_timeout()<CR>' )
 862
 863             vim.command( 'inoremap <buffer> ' + new_prompt_key + ' <ESC>:python lookup_buf ( "' + filename + '" ).new_prompt()<CR>' )
 864             vim.command( 'nnoremap <buffer> ' + new_prompt_key + ' :python lookup_buf( "' + filename + '" ).new_prompt()<CR>' )
 865
 866             vim.command( 'inoremap <buffer> ' + page_output_key + ' <ESC>:python lookup_buf ( "' + filename + '" ).page_output()<CR>' )
 867             vim.command( 'nnoremap <buffer> ' + page_output_key + ' :python lookup_buf( "' + filename + '" ).page_output()<CR>' )
 868
 869             vim.command( 'inoremap <buffer> ' + eof_signal_key + ' <ESC>:python lookup_buf ( "' + filename + '" ).send_eof()<CR>' )
 870             vim.command( 'nnoremap <buffer> ' + eof_signal_key + ' :python lookup_buf( "' + filename + '" ).send_eof()<CR>' )
 871
 872             vim.command( 'inoremap <buffer> ' + intr_signal_key + ' <ESC>:python lookup_buf ( "' + filename + '" ).send_intr()<CR>' )
 873             vim.command( 'nnoremap <buffer> ' + intr_signal_key + ' :python lookup_buf( "' + filename + '" ).send_intr()<CR>' )
 874
 875             vim.command( 'inoremap <buffer> ' + clear_key + ' <ESC>:python lookup_buf ( "' + filename + '" ).clear_screen( True )<CR>')
 876             vim.command( 'nnoremap <buffer> ' + clear_key + ' :python lookup_buf( "' + filename + '").clear_screen( False )<CR>' )
 877
 878             return 0
 879
 880         else:
 881
 882             dbg_print( 'new_buf: file ' + filename + ' exists' )
 883
 884             vim.command( "edit " + filename )
 885             return 1
 886
 887     except:
 888         dbg_print( 'new_buf: exception!' + str( sys.exc_info()[0] ) )
 889
 890 ################################################################################
 891
 892 def spawn_buf( _filename ):
 893
 894     exists = new_buf( _filename )
 895
 896     if not exists:
 897
 898         dbg_print( 'spawn_buf: buffer doesn\'t exist so creating a new one' )
 899
 900         cur = vim.current.buffer
 901
 902         ## Make vimsh associate buffer with _filename and add to list of buffers
 903         vim_shell = vimsh( sh, arg, _filename )
 904
 905         _BUFFERS_.append( ( _filename, vim_shell ) )
 906         vim_shell.setup_pty( use_pty )
 907
 908         vim_shell.read( cur )
 909         cur_line, cur_row = vim_shell.get_vim_cursor_pos()
 910
 911         ##  last line *should* be prompt, tuck it away for syntax hilighting
 912         hi_prompt = cur[ cur_line - 1 ]
 913
 914     else:
 915
 916         dbg_print( 'main: buffer does exist' )
 917         vim.command( "normal G$" )
 918         vim_shell = lookup_buf( _filename )
 919
 920     vim.command( "startinsert!" )
 921
 922 ################################################################################
 923
 924 def periodic( _filename ):
 925
 926     print( 'periodic: enter for ' + _filename )
 927     print( 'testing' )
 928
 929     if not use_pty:
 930         return
 931
 932     vim_shell = lookup_buf( _filename )
 933
 934     if vim_shell == None:
 935         dbg_print( 'periodic: couldn\'t find buffer' )
 936         return
 937
 938     if vim_shell.idle:
 939
 940         try:
 941             r, w, e = select.select( [ vim_shell.outd ], [], [], 0.1 )
 942
 943             if r == []:
 944                 return
 945
 946             dbg_print( 'periodic: new data to read on pty' )
 947
 948             vim_shell.page_output()
 949
 950         except:
 951             pass
 952
 953 ################################################################################
 954
 955 def lookup_buf( _filename ):
 956
 957     for key, val in _BUFFERS_:
 958
 959         if key == _filename:
 960
 961             dbg_print( 'lookup_buf: found match ' + str( val ) )
 962             return val
 963
 964     dbg_print( 'lookup_buf: couldn\'t find match for ' + _filename )
 965
 966     return None
 967
 968 ################################################################################
 969
 970 def remove_buf( _filename ):
 971
 972     dbg_print ( 'remove_buf: looking for ' + _filename + ' to remove from buffer list' )
 973
 974     idx = 0
 975
 976     for key, val in _BUFFERS_:
 977
 978         if key == _filename:
 979             break
 980
 981         idx = idx + 1
 982
 983     if ( len( _BUFFERS_ ) >= idx ) & ( len( _BUFFERS_ ) != 0 ):
 984
 985         dbg_print ( 'remove_buf: removing buffer from list' )
 986         del _BUFFERS_[ idx ]
 987
 988 ############################# customization ###################################
 989 #
 990 #  Don't edit the lines below, instead set the g:<variable> in your
 991 #  .vimrc to the value you would like to use.  For numeric settings
 992 #  *DO NOT* put quotes around them.  The quotes are only needed in
 993 #  this script.  See vimsh.readme for more details
 994 #
 995 ###############################################################################
 996
 997 ##  Allow pty prompt override, useful if you have an ansi prompt, etc
 998 #
 999
1000 prompt_override = int( test_and_set( "g:vimsh_pty_prompt_override", "1" ) )
1001
1002 ##  Prompt override, used for pty enabled.  Just use a very simple prompt
1003 ##  and make no definitive assumption about the shell being used if
1004 ##  vimsh_prompt_pty is not set.  This will only be used if
1005 ##  vimsh_pty_prompt_override (above) is 1.
1006 ##
1007 ##  NOTE: [t]csh doesn't use an environment variable for setting the prompt so setting
1008 ##        an override prompt will not work.
1009 #
1010
1011 if use_pty:
1012     if prompt_override:
1013         new_prompt = test_and_set( 'g:vimsh_prompt_pty', r'> ' )
1014
1015         os.environ['prompt'] = new_prompt
1016         os.environ['PROMPT'] = new_prompt
1017         os.environ['PS1']    = new_prompt
1018
1019 ## shell program and supplemental arg to shell.  If no supplemental
1020 ## arg, just use ''
1021 #
1022
1023 if sys.platform == 'win32':
1024     sh  = test_and_set( 'g:vimsh_sh',     'cmd.exe' )       # NT/Win2k
1025     arg = test_and_set( 'g:vimsh_sh_arg', '-i' )
1026
1027 else:
1028     sh  = test_and_set( 'g:vimsh_sh',     '/bin/sh' )       # Unix
1029     arg = test_and_set( 'g:vimsh_sh_arg', '-i' )
1030
1031 ## clear shell command behavior
1032 # 0 just scroll for empty screen
1033 # 1 delete contents of buffer
1034 #
1035
1036 clear_all  = test_and_set( "g:vimsh_clear_all", "0" )
1037
1038 ## new vimsh window behavior
1039 # 0 use current buffer if not modified
1040 # 1 always split
1041 #
1042
1043 split_open = test_and_set( "g:vimsh_split_open", "1" )
1044
1045 ## show helpful (hopefully) messages, mostly for issues that aren't resolved but
1046 ## have workarounds
1047 # 0 don't show them, you know what your doing
1048 # 1 show them
1049 #
1050
1051 show_workaround_msgs = test_and_set( "g:vimsh_show_workaround_msgs", "1" )
1052
1053 ##  Prompts for the timeouts for read( s )
1054 #
1055 #      set low for local usage, higher for network apps over slower link
1056 #      0.1 sec is the lowest setting
1057 #      over a slow link ( 28.8 ) 1+ seconds works well
1058 #
1059
1060 timeout_key = test_and_set( "g:vimsh_timeout_key", "<F3>" )
1061
1062 ##  Create a new prompt at the bottom of the buffer, useful if stuck.
1063 ##  Please try to give me a bug report of how you got stuck if possible.
1064
1065 new_prompt_key = test_and_set( "g:vimsh_new_prompt_key", "<F4>" )
1066
1067 ##  If output just stops, could be because of short timeouts, allow a key
1068 ##  to attempt to read more, rather than sending the <CR> which keeps
1069 ##  spitting out prompts.
1070
1071 page_output_key = test_and_set( "g:vimsh_page_output_key", "<F5>" )
1072
1073 ##  Send a process SIGINT (INTR) (usually control-C)
1074
1075 intr_signal_key = test_and_set( "g:vimsh_intr_key", "<C-c>" )
1076
1077 ##  Send a process EOF (usually control-D) python needs it to
1078 ##  quit interactive shell.
1079
1080 eof_signal_key = test_and_set( "g:vimsh_eof_key", "<C-d>" )
1081
1082 ##  Clear screen
1083
1084 clear_key = test_and_set( "g:vimsh_clear_key", "<C-l>" )
1085
1086 ############################ end customization #################################