home *** CD-ROM | disk | FTP | other *** search
/ OS/2 Shareware BBS: 5 Edit / 05-Edit.zip / p2demo21.exe / PEL / VI.PEL < prev    next >
Text File  |  1995-04-10  |  151KB  |  5,785 lines
  1. # $Header:   P:\source\wmacros\vi.pev   1.74   10 Apr 1995 17:08:00   NOBLE  $
  2. ## $Tabs:4 7$
  3.  
  4. ##############################################################################
  5. #
  6. #       Compuware Corporation
  7. #         31440 Northwestern Highway
  8. #           Farmington Hills, Michigan 48334-2564
  9. #
  10. #   This source code listing contains information that is
  11. #   proprietary to Compuware Corporation and may not be copied
  12. #   duplicated, translated, transmitted, stored, retrieved
  13. #   or in any manner or by any method conveyed or disclosed
  14. #   to a third party or parties without express written
  15. #   permission from Compuware Corporation.
  16. #
  17. #
  18. ##############################################################################
  19.  
  20. #### $Workfile:   vi.pel  $:  vi support keymaps and macros
  21.  
  22. #### VI emulation mode release notes:
  23. #
  24. #  EXTENSIONS:
  25. #
  26. #  This editor is capable of editing multiple files at once.  Thus it's 
  27. #  unnecessary to write the current file before switching to a new one, 
  28. #  nor is it necessary to process multiple files in strict sequential 
  29. #  order.  ":n" switches to next buffer without writing file; 
  30. #  and ":e file" loads a new file or 
  31. #  switches to an existing buffer by that name -- all without requiring 
  32. #  files to be written at each step.  The unnamed put buffer's contents 
  33. #  are not lost when buffer changes, thereby allowing cuts and pastes 
  34. #  between buffers without writing to intermediate files.
  35. #
  36. #  This implementation allows empty files and files with incomplete last
  37. #  lines to be edited.  This is in contrast with VI, which prohibits
  38. #  incomplete last lines and insists that there exist at least a single
  39. #  newline character in the file.
  40. #
  41. #  This implementation provides multiple windows.  Each window may view 
  42. #  different parts of the same file or different files.
  43. #
  44. #  The mouse can be used for all window operations, and for making text 
  45. #  selections.  Vi operators apply to the selected text, if any, in lieu 
  46. #  of a vi motion.  (Make a selection, then type "dd" to delete it.)  The
  47. #  mouse allows column selections in addition to character- and line-
  48. #  oriented ones, however, line commands such as dd, yy, << and >> will
  49. #  treat all selections as line selections.
  50. #
  51. #  vi-style undo has been augmented by PREDITOR's unlimited undo and redo.
  52. #  <Alt-U> undoes and <Alt-Y> redoes.  Also, vi's "U" command has been
  53. #  extended to toggle between the fully edited and undone versions of 
  54. #  the current line, like "u" does for a single edit.
  55. #
  56. #  This implementation always portrays a 100% accurate representation 
  57. #  of the text in the buffer.  Standard vi employed "@" and "$" symbols
  58. #  to indicate where text had been or would be deleted while minimizing 
  59. #  screen updates.  This kludge is unnecessary and unsupported in this 
  60. #  implementation.
  61. #
  62. #  Similarly, this editor is capable of scrolling horizontally, so long
  63. #  lines are not wrapped.  The redraw commands are not needed, so
  64. #  <Ctrl-L> and <Ctrl-R> scroll left and right, respectively.
  65. #
  66. #  Search commands have additional history associated with them.
  67. #  Previous search patterns entered are accessable via vertical arrow
  68. #  keys.  The default is the most recently entered search pattern, same
  69. #  as normal vi.  One subtle difference is that the previous pattern is
  70. #  visible on the command line.  Patterns histories may be accepted by 
  71. #  pressing enter, or rejected by pressing escape.  They also may be
  72. #  edited with the DEL, backspace, and horizontal arrow keys.  Newly
  73. #  entered text overwrites the pattern unless an editing character has
  74. #  been pressed first.  Thus "/<Enter>" and "/newpattern<Enter>" work 
  75. #  exactly as before, although additional functionality is available as
  76. #  a superset of previous key sequences.
  77. #
  78. #  DEL and ^U are used to cancel insert input on the current line.  ^C 
  79. #  terminates an insert. Ctrl-Break resets the editor.
  80. #
  81. #  ^V is only needed to quote keys that have a special meaning in insert 
  82. #  mode (  ^J  ^M  ^[  ^@  ^C  ^D  ^H  ^W  ^U  ^V  ).  Other control 
  83. #  keys will self-insert, though they still can be quoted with ^V.
  84. #
  85. #  The various forms of ^D are not required in insert mode.  
  86. #  Backspace unindents, and tab indents.
  87. #
  88. #  The Ctrl-@ command in insert mode works for any previous insertion,
  89. #  and is not limited to 128 chars.  If typed as NOT the first character,
  90. #  it inserts the previous insertion without terminating insert mode.
  91. #
  92. #  Most of the native mode function- and Alt-keys are implemented for 
  93. #  convenience.  Thus <Alt-W><Alt-Q> works like :wq
  94. #
  95. #  Other special features, such as error-fix, word-processing, and "Code 
  96. #  Processing" support are available in VI mode via "<F10>command", and
  97. #  other native key bindings.
  98. #
  99. #  Code Processing template inserting is bound to the <F2> key during
  100. #  insert mode.
  101. #
  102. #  A new command is added: "g" goes to top of buffer if no address is 
  103. #  specified, otherwise goes to the specified line, like "G".
  104. #
  105. #
  106. #  Known limitations of this emulation:
  107. #
  108. #  Should allow cascaded searches: "/abc/;/def/"
  109. #
  110. #  Positioning past EOL and EOF are sometimes off by one:
  111. #
  112. #     "A^["   "Gj"
  113. #
  114. #  Sentence motions should stop at paragraph and section breaks.
  115. #
  116. #  The ":l" command and "l" suffix to ":g" and ":s" should work
  117. #  differently from "p"
  118. #
  119. #
  120. #  TODO LIST (to be implemented next):
  121. #
  122. #  should use VI's regex syntax instead of our own
  123. #
  124. #  ":s" and ":g" commands should accept multi-line input
  125. #
  126. #  ":G" and ":V" commands ( :g or :v with prompt ).
  127. #
  128. #  should prohibit motion past EOL of last line
  129. #
  130. #  should prohibit having 0 lines in buffer
  131. #
  132. #
  133. #  OMISSIONS (likely never to be implemented):
  134. #
  135. #  Several vi commands take a count to adjust the window size.  Presently
  136. #  all such counts are ignored, and, given the more robust windowing
  137. #  capabilities, they are unlikely ever to be implemented. In some 
  138. #  cases, like searches, the counts may be changed to repeat counts.
  139. #  Commands I know about (purportedly all "large motion" commands)...
  140. #
  141. #     "z<num>." (change window size to <num>)
  142. #
  143. #     ^D  ^U  ^F  ^B  /  ?  [[  ]]  `  and '  
  144. #
  145. #     maybe:  ^E  ^Y   n   N
  146. #
  147. #  # -- macro character -- substitute for FN keys on keyboards w/out
  148. #
  149. #  @ macro commands
  150. #
  151. #  :n filename... command (use :e instead) -- can manually add or delete
  152. #     from buffer list, but can't replace it.  Not meaningful,
  153. #     since we are a multi-buffer editor.          
  154. #
  155. #  nO to open n lines -- no way to "open" lines. text is always 100%
  156. #     accurate re the buffer being edited
  157. #
  158. #  lisp mode commands: "(", ")", "{", "}", "="
  159. #
  160. ####
  161.  
  162. ### local variables
  163.  
  164. ## vi keymaps:
  165.  
  166. local vi_command_keymap = -1
  167. local vi_insert_keymap = -1
  168. local default_vi_command_keymap   # copy of command mode keymap used when vi.pel is recompiled
  169. local default_vi_insert_keymap    # similarily for insert mode keymap
  170.  
  171. ## vi constants:
  172.  
  173. local DEFAULT_BID = "1"    # default buffer id if not explicitly spec'd
  174. local LINE_BUFFER = 0x80000   # user buffer flag for line mode buffers
  175. local AND_DELETE = 1    # optional arg to vi_yank()
  176. local DEFAULT_ONE = 1      # optional arg to ex_ and select_range()
  177. #local DONT_DELETE = 0     # optional arg to vi_yank()
  178. local SEARCH_HIST  = "SEARCH" # history index for "/" and "?" commands
  179. local NEWLINE_BEFORE = 1   # insert flag -- put newline before or
  180. local NEWLINE_AFTER = 2    #  -- after  current line
  181. local ESC = 0x011B      # escape key
  182. local MOVE = 1       # move-mode argument to ex_copy
  183. local COPY = 0       # copy-mode argument to ex_copy
  184. local VI_EXPAND_TEMPLATE_KEY   = "<F2>"
  185. local VI_NEXT_FIELD_KEY        = "<Ctrl-Enter>"
  186.  
  187. #local vi_exact_mark = "`" # syntax for exact mark motion
  188. local vi_line_mark = "'"   # syntax for line mark motion
  189.    # block of reserved marks (ugh!!)
  190. local vi_major_mark = 909  # place from which last major motion moved
  191. local vi_base_mark = 910   # named marks --  first is "''" / ""
  192.  
  193. local DONT_MARK = 2     # op_type_2b() arg to suppress mark_context()
  194. local MAJOR_MARK = 1    # op_type_2b() arg mark major motion
  195. #local MAGIC = 1         # 1 if :e! file should delete current
  196.             # buffer before starting new file; 0 otherwise
  197. local READWRITE = 2     # read/write mode for fopen
  198. local END_FILE = 2      # end of file mode for fseek
  199. local BOB = 908         # beginning of buffer bookmark            
  200. local B1 = 907       # marks one end of text to be appended to a file
  201. local B2 = 906       # marks the other end
  202.  
  203.  
  204. local in_ex_mode = 1    # vi mode flag, 1 = command mode, 0 = insert mode
  205.  
  206. ## vi emulation internal states:
  207.  
  208. local pending_operator     # name of pending operator, if any
  209.  
  210. local number_register = 0  # number register used to repeat commands
  211. local option_disable[]     # array of disable flags for :set options
  212. local option_value[]    # value associated with :set option
  213. local recursion_count[]    # recursion protector for :map command
  214. local insert_macro_table[] # table of inert mode macros for :map 
  215. local command_macro_table[]   # table of command mode macros for :map
  216. local covered_command_macro_body[]  # record of overwritten macros
  217. local covered_insert_macro_body[]
  218. local covered_insert_macro[]
  219. local covered_command_macro[]
  220. local templates[]       # abbreviations for :abb mode
  221. local original_com      # original version of command string
  222. local save_command      # pattern part of last :s command for replay
  223. local prev_old          # previous match pattern for :s command
  224. local prev_new          # previous substitution string for :s command
  225. local last_buffer       # previous buffer for :e #
  226.  
  227.  
  228. local vi_read_name         # file name in last read command
  229. local in_glob              # executing a :g or :v command
  230. local browser_bid = 0      # buffer containing ":" command's "printed" output
  231. local browser_keymap = -1  # keymap for browser process
  232. local confirmer_bid = 0    # buffer for confirmer process
  233. local confirmer_keymap = -1   # keymap for confirmer process
  234.  
  235. local buf_id               # selected get/put buffer
  236. local buf_id_map           # maps buf_id names to buffer handles
  237.  
  238. local vi_search_dir        # previous search direction for search_again
  239. local vi_search_flags      # vi search flags
  240.  
  241. local vi_find_com          # last find command, if any
  242. local vi_find_char         # last find character, if any
  243.  
  244.    # address ranges for ":" commands:
  245.  
  246. local ex_addr1             # first address if any
  247. local ex_addr2             # second address if any
  248. local ex_addresses = 0     # count of addresses supplied
  249. local ex_com               # command string being parsed
  250.  
  251. local line_search          # signal from ex_address() to vi_search_key()
  252.  
  253.    # state vars for vi-style undo and "."/again:
  254.  
  255. local undo_baseline        # undo indicies to undo previous command
  256. local redo_baseline        # undo indicies to undo previous command
  257. local undo_line_baseline   # undo indicies to undo all changes to...
  258. local undo_line            # ...the current line (remembered here)
  259.  
  260. local again_string         # playback string to re-execute last command
  261. local tmp_again            # interim version of again_string
  262. local playing_again = 0    # flag for insert, et al.
  263.  
  264. local prev_number_register = 1   # previous repeat count
  265. local prev_buf_id          # previous buf id
  266. local prev_mark_id         # previous mark id
  267. local vi_r_ch              # previous "r" command replacement string
  268.  
  269. local insert_buffer        # buffer at start of insert mode
  270. local insert_window        # window at start of insert mode
  271. ## vi mode user-visible external states, flags and modes
  272.  
  273. local clipboard_only = 1   # Do not use vi numbered delete registers
  274.                            #  much improved performance for cuts/pastes
  275. local last_yank_type = 0   # Used when pasting from system clipboard. Set
  276.                            #  to LINE_BUFFER when yanking lines.
  277. local bs_over_ai = 1       # allow bs over ai in insert mode
  278.                            #  (extension to standard vi)
  279.  
  280. local mouse_handlers[]     # prexisting mouse handlers overriden by insert mode
  281. ### vi emulation
  282. #
  283.  
  284. ## vi -- enter vi mode
  285. #
  286. function vi()
  287. {
  288.    if ( emulation_mode == "vi" )
  289.       return;
  290.  
  291.    emulation_mode = "vi"
  292.    execute_event_handler( EVENT.EMULATION_CHANGED );
  293.  
  294.    # Misc. items...
  295.  
  296.    visible_end_buffer    = default_visible_end_buffer    = ""
  297.    visible_virtual_lines = default_visible_virtual_lines = "~"
  298.  
  299.    # turn on prompts on statusbar
  300.    status_bar_flags = or(status_bar_flags, STB_PROMPTS)
  301.    
  302.    window_page_overlap = 2
  303.  
  304.    search_flags = vi_search_flags = SEARCH_REGEX          \
  305.                                   + SEARCH_MAXIMAL_MATCH  \
  306.                                   + SEARCH_WRAPS          \
  307.                                   + SEARCH_ADVANCE        \
  308.                                   + SEARCH_FORWARD        \
  309.                                   + SEARCH_CASE
  310.    vi_check_flags()
  311.  
  312.    if (!editor_running)
  313.       attach_event_handler( EVENT.EDITOR_RUNNING, "vi_setup")
  314.    else
  315.       vi_setup()
  316. }
  317.  
  318. function vi_setup()
  319. {
  320. #   message("begin vi_setup")
  321.    delete_event( EVENT.EDITOR_RUNNING, "vi_setup")
  322.    attach_event_handler( EVENT.EMULATION_CHANGED, "vi_restore" )
  323.    
  324.    attach_event_handler( EVENT.NEW_CURNT_BUFFER, "vi_new_current_win")
  325.    attach_event_handler( EVENT.NEW_CURNT_WINDOW, "vi_new_current_win")
  326.  
  327.    attach_event_handler( EVENT.ERROR, "vi_reset" )
  328.  
  329.    # initialize all the ex :set options
  330.    ex_init_state()      
  331.  
  332.    assign_key( VI_EXPAND_TEMPLATE_KEY, "beep" )
  333.    assign_key( VI_NEXT_FIELD_KEY, "beep" ) 
  334.    set_expand_template_key( VI_EXPAND_TEMPLATE_KEY )
  335.    set_next_field_key( VI_NEXT_FIELD_KEY ) 
  336.    
  337.    create_vi_command_keymaps()
  338.    vi_menu()
  339.    create_vi_insert_keymaps()
  340.    vi_command_mode(1)    # vi starts in command mode
  341. #   message("vi_setup complete")
  342. }
  343.  
  344.  
  345. # change flags so that they are correct for vi
  346. #
  347. local function vi_check_flags()
  348. {
  349. #   local mod_ro = and(buffer_flags, BUFFER_READ_ONLY+BUFFER_MODIFIED)
  350. #
  351. #   buffer_flags = default_buffer_flags = or( default_buffer_flags,      
  352. #                                                BUFFER_REAL_SPACE_ONLY + \
  353. #                                                BUFFER_WHOLE_LINES )
  354. #   buffer_flags = default_buffer_flags = or( default_buffer_flags,      
  355. #                                                BUFFER_REAL_SPACE_ONLY)
  356. #   # restore those bits
  357. #   #
  358. #   buffer_flags = or(buffer_flags, mod_ro)
  359. }
  360.  
  361. function vi_process_end()
  362. {
  363.    # check to see if in insert mode, if so end process
  364.    #
  365.    #if (current_keymap == vi_insert_keymap )
  366.    if (!in_ex_mode || (current_keymap != vi_command_keymap) )
  367.    {
  368.       # since we use keymap as a check, change keymap so that we don't come in here
  369.       # again
  370.       #current_keymap = vi_command_keymap
  371.       # Note: this call to vi_command_mode() may be redundant but we'll do it
  372.       # here in case process_end() fails.
  373.       vi_command_mode(1)   # 1 - force the command keymap if it's not current
  374.    }
  375.  
  376.    process_end() # does nothing if not in process_begin
  377. }
  378.  
  379.  
  380. # handler invoked when changing out of vi mode
  381. function vi_restore()
  382. {
  383.    # clear buffer flags set during vi mode initialization
  384. #   buffer_flags = buffer_flags       \
  385. #                = and( buffer_flags, \
  386. #                       not(BUFFER_REAL_SPACE_ONLY + BUFFER_WHOLE_LINES ))
  387.  
  388.    # reset misc. display attributes
  389.    visible_virtual_lines = default_visible_virtual_lines = ""
  390.  
  391.    # remove this event handler
  392.    delete_event( EVENT.NEW_CURNT_BUFFER, "vi_new_current_win")
  393.    delete_event( EVENT.NEW_CURNT_WINDOW, "vi_new_current_win")
  394.    delete_event( EVENT.EMULATION_CHANGED, "vi_restore" )
  395.    delete_event( EVENT.ERROR, "vi_reset" )
  396.    restore_id()
  397. }
  398.  
  399.  
  400. ## entering vi command mode
  401. #
  402. #  This gets called at the conclusion of insert mode, after all errors, 
  403. #  after all "operators", and after each "ex" command.
  404. #
  405. local function vi_command_mode(force_keymap)
  406. {
  407.    # reset to normal state
  408.  
  409.    if (!in_ex_mode)
  410.    {
  411.       in_ex_mode = 1
  412. #      if (!handler_active(EVENT.LMOUSE_DRAG, function_id("lmouse_drag")))
  413. #         attach_event_handler(EVENT.LMOUSE_DRAG,      function_id("lmouse_drag"))
  414. #      if (!handler_active(EVENT.MOUSE_LEFT_DOWN,  function_id("mouse_left_down")))
  415. #         attach_event_handler(EVENT.MOUSE_LEFT_DOWN,  function_id("mouse_left_down"))
  416. #      if (!handler_active(EVENT.MOUSE_LEFT_UP,    function_id("mouse_left_up")))
  417. #         attach_event_handler(EVENT.MOUSE_LEFT_UP,    function_id("mouse_left_up"))
  418.       message( "[ Command mode ]" )
  419.    }
  420.  
  421.    if (force_keymap && current_keymap != vi_command_keymap)
  422.    {
  423.       if (!vi_keymap_valid(vi_command_keymap))
  424.       {
  425.          create_vi_command_keymaps()
  426.       }
  427.       current_keymap = vi_command_keymap
  428.    }
  429.  
  430.    # calling use_number() overwrites prev num
  431.    number_register = 0                 
  432.  
  433.    buf_id = DEFAULT_BID
  434.    in_glob = 0
  435.    op_flush()
  436. }
  437.  
  438. ## indicate a common error
  439.  
  440. local function vi_error( s )
  441. {
  442.    vi_warning()
  443.    pending_operator = ""   # cancel any pending operator
  444.  
  445.    
  446.    #vi_command_mode() 
  447.    
  448.    delete_event( EVENT.ERROR, "vi_reset" )
  449.    vi_reset()# reset to command mode
  450.    attach_event_handler( EVENT.ERROR, "vi_reset" )
  451.  
  452.    error( s )     # cause longjump to editor top-level
  453.                   #     ( "never" returns )
  454. }
  455.  
  456. ## errors e.g. within insert mode must return
  457.  
  458. local function vi_warning( s )
  459. {
  460.    if ( s ) 
  461.       warning( s )
  462.    else if ( ! option_disable[ "errorbells" ] ) 
  463.       beep()
  464. #   if ( ! option_disable[ "errorbells" ] && pause_on_error ) 
  465. #      beep()
  466. }
  467.  
  468. function vi_redo_index()
  469. {
  470.    return redo_index()
  471. }
  472.  
  473. # kludge to force accurate undo_index within macros
  474.  
  475. function vi_undo_index()
  476. {
  477. #   record( 1 )
  478. #   record( 0 )
  479.  
  480.    return undo_index()
  481. }
  482.  
  483. function establish_baseline()
  484. {
  485.    undo_baseline[ current_buffer ] = vi_undo_index()
  486.    redo_baseline[ current_buffer ] = vi_redo_index()
  487.  
  488.    if ( undo_line[ current_buffer ] != current_line )
  489.       {
  490.       undo_line[ current_buffer ] = current_line
  491.       undo_line_baseline[ current_buffer ] = vi_undo_index()
  492.       }
  493. }
  494.  
  495. function vi_undo_redo( baseline )
  496. {
  497.    local new, old
  498.  
  499.    if ( current_buffer in baseline )
  500.       {
  501.       new = baseline[ current_buffer ]
  502.       baseline[ current_buffer ] = old = vi_undo_index()
  503.  
  504.       if ( new < old )
  505.          undo( new )
  506.       else
  507.          redo( redo_baseline[ current_buffer ] )
  508.  
  509.       } 
  510.    else 
  511.       vi_error()
  512. }
  513.  
  514. function vi_undo()
  515. {
  516.    vi_undo_redo( undo_baseline )
  517. }
  518.  
  519. function vi_undo_line()
  520. {
  521.    if ( undo_line[ current_buffer ] == current_line )
  522.       vi_undo_redo( undo_line_baseline )
  523. }
  524.  
  525. function vi_again()
  526. {
  527.    local i, ch
  528.  
  529.    if ( !again_string )
  530.       vi_error()
  531.  
  532.    if ( prev_buf_id ~ /[1-8]/ )
  533.       prev_buf_id = chr( ord( prev_buf_id ) + 1 )
  534.    buf_id = prev_buf_id
  535.  
  536.    if ( !number_register )
  537.       number_register = prev_number_register 
  538.  
  539.    playing_again = 1
  540.    playback( again_string )
  541.    playing_again = 0
  542. }
  543.  
  544.  
  545. # setup for a single-char command, like "Y" or "~".
  546. #
  547. #  Generate an error if there is a pending operator.
  548. #  Record the appropriate information for undo and again.
  549. #  Special case "single-char" commands like "[[" and "]]" must
  550. #     manually insert an extra record_op()
  551.  
  552. local function op_type_1()
  553. {
  554.    operator_disallowed()
  555.    prev_number_register = number_register 
  556.    record_op()
  557.    establish_baseline()
  558.    op_wrap()
  559. }
  560.  
  561. # setup for the first of a two-char operator command, like "dW" or "yy":
  562. #
  563. #  Record the appropriate information for undo and again.
  564.  
  565. local function op_type_2a()
  566. {
  567.    prev_number_register = number_register 
  568.    record_op()
  569.    establish_baseline()
  570. }
  571.  
  572. # setup for a motion that might be paired with a two-char operator.
  573. #  like "!" or ">w" (may or may not be paired with an operator):
  574. #
  575. #  Record the appropriate information for undo and again.
  576.  
  577. local function op_type_2b( context_type )
  578. {
  579.    if ( pending_operator )
  580.       prev_number_register = number_register 
  581.  
  582.    if ( tmp_again )
  583.       record_op()
  584.  
  585.    mark_context( context_type )
  586. }
  587.  
  588. # wrap-up for the successful completion of any command
  589.  
  590. local function op_wrap()
  591. {
  592.    if ( tmp_again )
  593.       {
  594.       prev_buf_id = buf_id
  595.       again_string = tmp_again
  596.       tmp_again = ""
  597.       }
  598. }
  599.  
  600. # cancel command history accumulated thus far
  601.  
  602. local function op_flush()
  603. {
  604.       tmp_again = ""
  605. }
  606.  
  607. # record a key into the again string
  608.  
  609. local function record_op( key )
  610. {
  611.    if ( !argcount() )
  612.       key = current_key
  613.  
  614.    if ( key == 0 )
  615.       key = key_to_int("<Ctrl-@>")
  616.  
  617.    tmp_again = tmp_again chr( key ) chr( shiftr( key, 8 ))
  618. }
  619.  
  620.  
  621. ## a numeric count may preceed most commands.
  622. #
  623. #  leading zeros are illegal ("0" is a command, executed here).
  624. #  no count means 1.
  625. #  the count is reset after every command, whether the count is used or not.
  626. #  a copy of the previous count is maintained for vi_again
  627.  
  628. function vi_digit()
  629. {
  630.    local key = and( current_key, 0xF )
  631.  
  632.    if ( number_register )
  633.       number_register = number_register * 10 + key
  634.    else
  635.       if ( key )
  636.          number_register = key
  637.       else
  638.          vi_goto_bol()
  639.  
  640. #  message("number_register = %d", number_register);
  641. }
  642.  
  643. function vi_prompt( a, b, c, d ) 
  644. {
  645.    local r
  646.  
  647.    attach_event_handler( EVENT.INVALID_PCHAR, "vi_prompt_err" )
  648.  
  649.    r = prompt_history( a, b, c, d )
  650.  
  651.    delete_event( EVENT.INVALID_PCHAR, "vi_prompt_err" )
  652.  
  653.    return r
  654. }
  655.  
  656. # allow <Backspace> to cancel prompts:
  657.  
  658. function vi_prompt_err() 
  659. {
  660.    if ( prompt_response == "" && current_key == key_to_int("<Backspace>") )
  661.       ungetkey( ESC )
  662. }
  663.  
  664.  
  665. local function use_number()
  666. {
  667.    local prev = number_register
  668.  
  669.    if ( prev == 0 )
  670.       prev = 1
  671.  
  672.    number_register = 0
  673.    return prev
  674. }
  675.  
  676. local function disallow_number()
  677. {
  678.    if ( number_register != 0 )
  679.       message( "Count ignored with this command." )
  680.  
  681.    number_register = 0
  682. }
  683.  
  684. local function vi_getc()
  685. {
  686.    local ch
  687.  
  688.    if (!playing_again && (ch = int_to_ascii(getkey())) && (ch != ASCII_ESC) )
  689.       return chr( ch )
  690.    else
  691.       vi_error()
  692. }
  693.  
  694.  
  695. ### vi operators
  696.  
  697. # process operator command
  698. #
  699. #  if first one and no selection then remember it pending next motion
  700. #  if first one and existing selection, execute operator
  701. #  if second one matches previous one, execute operator in line mode
  702. #  else error
  703.  
  704. function vi_operator()
  705. {
  706.    local ch = chr( int_to_ascii( current_key ))  # get operator
  707.    local selection
  708.  
  709.    op_type_2a()
  710.  
  711.    if ( pending_operator )
  712.    {
  713.       if ( ch == pending_operator )
  714.       {
  715.          # always operate on full lines
  716.          select_lines( use_number() )
  717.          xeq_op()    # operate on lines
  718.       } 
  719.       else 
  720.          vi_error()     # operator mismatch
  721.    } 
  722.    else
  723.    {
  724.       pending_operator = ch      # remember for later
  725.       if ( selection_type() )
  726.       {
  727.          # Convert possible mouse selection into a regular selection
  728.          selection = get_selection_info() 
  729.          UnhighlightMouseSel()
  730.          cua_remove_selection(1)
  731.          restore_selection_info(selection)
  732.    #      xeq_op()                   # !! can't do again # now we can!
  733.       } 
  734.    }
  735. }  
  736.  
  737. local function operator_disallowed(){
  738.    tmp_again = ""       # avoids problem w/vi_space, etc
  739.                #    followed by "."
  740.    if( pending_operator )
  741.       vi_error()     # never returns
  742. }
  743.  
  744. # manually insert an operator
  745. #
  746. #  usage: "pend_operator( op ); motion()"
  747. #
  748. local function pend_operator( op )
  749. {    
  750.    operator_disallowed()
  751.    pending_operator = op
  752. }
  753.  
  754. # process pending operator, if any
  755. #
  756. #  mode specifies the mode of the operation: line, normal, or inclusive
  757. #  if a region has already been selected, mode is ignored
  758.  
  759. local function xeq_op( mode )
  760. {
  761.    local rt
  762.    local line
  763.  
  764.    if ( pending_operator )
  765.       {
  766.  
  767.       if ( !argcount() )
  768.          mode = NORMAL_SELECTION
  769.    
  770.       op_wrap()
  771.    
  772.       if ( ( rt = selection_type()) )
  773.          mode = rt
  774.       else 
  775.          {
  776.          drop_anchor( mode )
  777.          goto_mark( vi_base_mark )
  778.          }
  779.  
  780.       if ( pending_operator == "y" )
  781.          {
  782.          vi_yank()
  783.          #raise_anchor()
  784.          } 
  785.       else if ( pending_operator == "d" )
  786.          {
  787.          vi_yank( AND_DELETE )
  788.  
  789.          if( mode == LINE_SELECTION )
  790.             skip_whitespace()
  791.  
  792.          } 
  793.       else if( pending_operator == "c" )
  794.          {
  795.          vi_yank( AND_DELETE )
  796.          vi_insert( (mode == LINE_SELECTION) ? NEWLINE_BEFORE : 0 )
  797.          } 
  798.       else if ( pending_operator == "<" )
  799.          {
  800. #         outdent_tabs()
  801.          outdent_lines()
  802.          raise_anchor()
  803.          } 
  804.       else if ( pending_operator == ">" )
  805.          {
  806. #         indent_tabs()
  807.          indent_lines()
  808.          raise_anchor()
  809.          } 
  810.       else if ( pending_operator == "!" )
  811.          {
  812.          vi_filter()
  813.          raise_anchor()
  814.          } 
  815.       else 
  816.          vi_error( "bad VI operator: " pending_operator )
  817.  
  818.       pending_operator = ""
  819.    
  820.       } 
  821.    else 
  822.       op_flush()
  823.  
  824.    vi_command_mode()
  825. }
  826.  
  827.  
  828.  
  829. ### yank/put buffers & associated stuff
  830.  
  831.  
  832. # select n lines, starting with the current
  833.  
  834. local function select_lines( n )
  835. {
  836.    local target = current_line + n - 1
  837.    local selection
  838.  
  839.           
  840.    if (selection_type() != LINE_SELECTION)
  841.    {
  842.       if (selection_type())
  843.       {
  844.          # convert current selection into a line selection
  845.          selection = get_selection_info() 
  846.          remove_selection()
  847.          n = (selection.endline - selection.startline) + 1
  848.          prev_number_register = n   # set so vi_again will work correctly
  849.          goto_line(selection.startline) # move to 1st column of line
  850.          skip_whitespace()
  851.       }    
  852.       
  853.       save_position()
  854.       if ( n > 1 )
  855.       {
  856.          target = current_line + n - 1
  857.          current_line = target
  858.    
  859.          if ( current_line != target )
  860.          {
  861.             # there were not enough lines in the file
  862.             restore_position(1)
  863.             vi_error() # never returns
  864.          }
  865.       }
  866.       
  867.       # select from the end to the beginning, current position is then
  868.       # at the beginning of the selection
  869.       begin_selection( LINE_SELECTION )
  870.       restore_position(1)
  871.    }
  872.  
  873. }  
  874.  
  875. # select n characters, n>0 => select towards EOL; n<0 => select towards BOL
  876. #  error if selection bypasses BOL or EOL
  877. #  n=0 => error
  878. #  do nothing if there is already a selection
  879. local function select_chars( n )
  880. {
  881.    local selection
  882.    
  883.    if (!selection_type())
  884.    {
  885.       if ( n > 0 && current_line_length - current_line_offset >= n )
  886.       {
  887.          drop_anchor( NORMAL_SELECTION )
  888.          next_char( n )
  889.       } 
  890.       else if ( (n < 0) && (current_line_offset >= -n) )
  891.       {
  892.          drop_anchor( NORMAL_SELECTION )
  893.          prev_char( -n )
  894.       } 
  895.       else 
  896.          vi_error()
  897.    }
  898.    else
  899.    {
  900.       selection = get_selection_info()
  901.       if (selection.startline != selection.endline)
  902.          vi_error()
  903.       else
  904.       {
  905.          n = marked_region_size()
  906.          prev_number_register = n   # set so vi_again will work correctly
  907.       }
  908.    }
  909.    
  910.    return n
  911. }
  912.  
  913. local function move_down( n )
  914. {
  915.    local target = current_line + n
  916.  
  917.    #create_mark( TEMP_MARK )
  918.    save_position()
  919.    current_line = target
  920.  
  921.    if ( current_line != target )
  922.       {
  923.       #goto_mark( TEMP_MARK )
  924.       restore_position(1)
  925.       vi_error()  
  926.       }
  927.    else   
  928.       restore_position(0)
  929. }
  930.  
  931. # prompt for buffer id
  932.  
  933. function vi_bufid_key()
  934. {
  935.    local ch = vi_getc()
  936.  
  937.    # buffer id "@" is also used internally
  938.    if ( ch ~ /[a-zA-Z1-9]/ )  
  939.       buf_id = ch
  940.    else
  941.       vi_error()
  942. }
  943.  
  944. # returns a buffer id of a system buffer associated with the current buf_id
  945. #  if clear is true, the buffer returned is empty.
  946. #
  947. local function yank_bid( put, del )
  948. {
  949.    local bid = tolower( buf_id )
  950.    local buf, i, b2, b1
  951.  
  952.    if ( bid in buf_id_map )      # we're reusing an existing buffer:
  953.       {   
  954.       if ( bid == DEFAULT_BID && del )
  955.          {
  956.          # save 9 most recent deletes:
  957.  
  958.          if ( "9" in buf_id_map )
  959.             delete_buffer( buf_id_map[ "9" ])
  960.  
  961.          for( i = 9; i > 1; i-- )
  962.             {
  963.             b2 = "" i
  964.             b1 = "" i - 1
  965.             if ( b1 in buf_id_map )
  966.                buf_id_map[ b2 ] = buf_id_map[ b1 ]
  967.             }
  968.          # and fall to the return to create the new one
  969.          } 
  970.       else 
  971.          {
  972.          if ( put || isupper( buf_id ))    # upper=> append        # !del || 
  973.  
  974.             return buf_id_map[ bid ]
  975.  
  976.          # we're reusing a bid and need it to be empty
  977.          # and we fall through to create an empty one
  978.          else
  979.  
  980.             delete_buffer( buf_id_map[ bid ])
  981.          }
  982.  
  983.       } 
  984.    else if ( put )
  985.  
  986.       vi_error( "Nothing has been put in buffer \"" buf_id )
  987.  
  988.    return ( buf_id_map[ bid ] = create_buffer( "vi_yank_" bid, "", BUFFER_SYSTEM ))
  989. }
  990.  
  991. # yank or delete the current selection into the current "put" buffer
  992. #
  993. #  this is the yank command, and also used by other commands.
  994.  
  995. function vi_yank( del )
  996. {
  997.    local prev = current_buffer
  998.    local line = ( selection_type() == LINE_SELECTION )
  999.    local end_line
  1000.    local selection = get_selection_info() 
  1001.    local real_space
  1002.    #local str = get_region_as_str()
  1003.    
  1004.    # if line > 0, then we have a line selection, so set line to be the
  1005.    # number of lines to be yanked
  1006.    if (line)
  1007.       line = selection.endline - selection.startline + 1
  1008.    
  1009.    # must set last_yank_type to be used by paste if using clipboard only
  1010.    last_yank_type = line ? LINE_BUFFER : 0
  1011.         
  1012.    #restore_selection_info(selection)
  1013.    if( del )
  1014.    {
  1015.       # Turn off REAL_SPACE_ONLY to prevent shorter lines that follow a deleted
  1016.       # line from being padded out to the current cursor column.
  1017.       real_space = and(buffer_flags, BUFFER_REAL_SPACE_ONLY)
  1018.       buffer_flags = set_flag_bits(buffer_flags, BUFFER_REAL_SPACE_ONLY, 0)
  1019.       delete_to_scrap()
  1020.       if (line)
  1021.       {
  1022.          goto_bol()
  1023.          skip_whitespace()
  1024.       }
  1025.       buffer_flags = set_flag_bits(buffer_flags, BUFFER_REAL_SPACE_ONLY, real_space)
  1026.    }
  1027.    else
  1028.       copy_to_scrap()
  1029.  
  1030.    raise_anchor()
  1031.  
  1032.    if (!clipboard_only)
  1033.    {
  1034.       delete_event( EVENT.NEW_CURNT_BUFFER, "vi_new_current_win")
  1035.       current_buffer = yank_bid( 0, del )
  1036.    
  1037.       if( line )
  1038.          buffer_flags = or( buffer_flags, LINE_BUFFER )
  1039.       else
  1040.          buffer_flags = and( buffer_flags, not( LINE_BUFFER ))
  1041.    
  1042.       insert_scrap()
  1043.      #insert_string(str)
  1044.       current_buffer = prev 
  1045.    
  1046.       attach_event_handler( EVENT.NEW_CURNT_BUFFER, "vi_new_current_win")
  1047.    }
  1048.    
  1049.    # The following code deletes the last line of the buffer by removing
  1050.    # the EOL character from the preceding line.
  1051.    if (line && buffer_offset >= buffer_size)
  1052.    {
  1053.       end_line = current_line
  1054.       prev_char()
  1055.       if (current_line < end_line && read_buffer() == "")
  1056.          delete_chars(1)
  1057.       else
  1058.          next_char()
  1059.    }
  1060.    
  1061.    message("%s%s%s%s to scrap",  (line > 1 ? line " ": ""), 
  1062.                               (line ? "Line" : "Block"), 
  1063.                               (line > 1 ? "s " : " "),
  1064.                               (del ? "deleted" : "copied") );
  1065.    return line
  1066. }
  1067.  
  1068. # put the current yank buffer's contents into the scrap buffer,
  1069. #  and return true if the buffer was a "LINE" buffer.
  1070. #
  1071. #  Most clients need to perform some fine positioning
  1072. #  depending on the line status, before actually inserting the text.
  1073. #  Hence the obscure nature of this function.
  1074. #
  1075. local function put_buffer_to_scrap()
  1076. {
  1077.    local prev = current_buffer
  1078.    local line_oriented
  1079.  
  1080.    delete_event( EVENT.NEW_CURNT_BUFFER, "vi_new_current_win")
  1081.    current_buffer = yank_bid( 1, 0 )
  1082.  
  1083.    goto_buffer_top()
  1084.    drop_anchor()
  1085.    goto_buffer_bottom()
  1086.    copy_to_scrap()
  1087.    raise_anchor()
  1088.  
  1089.    line_oriented =  and( buffer_flags, LINE_BUFFER )
  1090.    current_buffer = prev
  1091.    attach_event_handler( EVENT.NEW_CURNT_BUFFER, "vi_new_current_win")
  1092.  
  1093.    return line_oriented
  1094. }
  1095.  
  1096. function vi_Y()   # yank lines or selected block
  1097. {           
  1098.    local temp = selection_type();
  1099.    local n = use_number();
  1100.  
  1101.    op_type_1()
  1102.  
  1103.    if ( !temp ) 
  1104.       select_lines( n )  
  1105.  
  1106.    vi_yank()
  1107. }
  1108.  
  1109. function vi_p()   # put after cursor/line
  1110. {           
  1111.    local lnum, lines
  1112.  
  1113.    disallow_number()
  1114.    op_type_1()
  1115.    lines = clipboard_only ? last_yank_type : put_buffer_to_scrap()
  1116.  
  1117.    #if( (lines = put_buffer_to_scrap()) )
  1118.    if( lines )
  1119.       {
  1120.       down()
  1121.       goto_bol()
  1122.       lnum = current_line
  1123.       } 
  1124.    else 
  1125.       right()
  1126.  
  1127.    insert_scrap()
  1128.  
  1129.    if( lines )
  1130.       vi_goto_line( lnum )
  1131.    else
  1132.       prev_char()
  1133. }
  1134.  
  1135. function vi_P()   # put before cursor/line
  1136. {           
  1137.    local lnum, lines
  1138.  
  1139.    op_type_1()
  1140.  
  1141.    lines = clipboard_only ? last_yank_type : put_buffer_to_scrap()
  1142.    #if( (lines = put_buffer_to_scrap()) )
  1143.    if( lines )
  1144.       {
  1145.       goto_bol()
  1146.       lnum = current_line
  1147.       }
  1148.  
  1149.    insert_scrap()
  1150.  
  1151.    if( lines )
  1152.       vi_goto_line( lnum )
  1153.    else
  1154.       prev_char()
  1155. }
  1156.  
  1157.  
  1158. ### insert mode and auxiliary operations
  1159.  
  1160. local insert_text       # copy of text of previous insert
  1161. local insert_start      # start offset of insert
  1162. local insert_start_line # start line of insert
  1163. local insert_backstop   # backstop of this line; cancel deletes back to here
  1164. local insert_indent     # flag, true <=> backstop follows auto-indent text
  1165.  
  1166. # set insert_backstop and insert_indent
  1167. local function set_backstop( ai )
  1168. {
  1169.    insert_indent = ai     
  1170.    insert_backstop = buffer_offset
  1171. }
  1172.  
  1173. local function vi_reset_insert()
  1174. {
  1175.    set_backstop( 0 )
  1176.    insert_text = ""
  1177.    # remember starting position:
  1178.    insert_start = buffer_offset
  1179.    insert_start_line = current_line
  1180. }
  1181.  
  1182. function vi_insert_mouse_handler()
  1183. {
  1184.    if ( event_id == EVENT.MOUSE_LEFT_DOWN ||
  1185.         event_id == EVENT.MOUSE_RIGHT_DOWN )
  1186.    {
  1187.       mouse_left_down()
  1188.       vi_reset_insert()
  1189.    }                  
  1190. }
  1191.  
  1192. local function vi_override_events()
  1193. {
  1194.    local event
  1195.    local mouse_events[]
  1196.    local mouse_drag_events[]
  1197.    local exit_events[]
  1198.    local dummy_handler_id = function_id( "vi_insert_mouse_handler" )
  1199.  
  1200.    # store all mouse event handlers 
  1201.    mouse_events      = save_and_remove_events( EVENT.MOUSE_LEFT_DOWN, EVENT.MOUSE_MID_CLICK2 ) 
  1202.    mouse_drag_events = save_and_remove_events( EVENT.LMOUSE_DRAG, EVENT.RMOUSE_DRAG )
  1203.  
  1204.    mouse_handlers = merge_arrays( mouse_events, mouse_drag_events )
  1205.  
  1206.    # attach dummy handlers for all mouse events
  1207.    for ( event in mouse_handlers )
  1208.       attach_event_handler( event, dummy_handler_id )
  1209.  
  1210. }                                                         
  1211.  
  1212. local function vi_restore_events()
  1213. {
  1214.    local event
  1215.    local dummy_handler_id = function_id( "vi_insert_mouse_handler" )
  1216.  
  1217.    # delete dummy handlers for all mouse events
  1218.    for ( event in mouse_handlers )
  1219.       delete_event( event, dummy_handler_id )
  1220.  
  1221.    restore_events( mouse_handlers )
  1222.  
  1223.    delete mouse_handlers
  1224. }                                                   
  1225.  
  1226.  
  1227. # all common text insertion functionality
  1228. #
  1229. #  -- auto indents
  1230. #  -- repeated inserts
  1231. #  -- macro playback
  1232. #  -- intra-line editing
  1233.  
  1234. local function vi_insert( newline )
  1235. {
  1236.    local n, count, col, line, offset
  1237.    local new_cb, new_cw
  1238.    local insert_buffer_name
  1239.  
  1240.    in_ex_mode = 0
  1241.    count = use_number()
  1242.  
  1243.       # insert requested newlines
  1244.       #  _BEFORE => before current line (e.g. "O", "S")
  1245.       #  _AFTER => after current line (e.g. "o")
  1246.       #  else => no newline
  1247.  
  1248.       if ( newline == NEWLINE_BEFORE )
  1249.       {
  1250.          if ( current_line == 1 )
  1251.             { 
  1252.             goto_bol()
  1253.             insert_newline()
  1254.             up()
  1255.             } 
  1256.          else 
  1257.             {
  1258.             up()
  1259.             vi_insert_nl(newline)
  1260.             }
  1261.  
  1262. #         insert_text = "\n"
  1263.       } 
  1264.       else if ( newline == NEWLINE_AFTER )
  1265.       {
  1266.          vi_insert_nl()
  1267. #         insert_text = "\n"
  1268.       } 
  1269.          
  1270.    if( playing_again )
  1271.    {
  1272.       if ( and(buffer_flags, BUFFER_OVERTYPE_MODE) )
  1273.          delete_chars( length( insert_text ))
  1274.  
  1275.       #warning("insert_text is: |%s|", insert_text)
  1276.       reinsert_string( insert_text, newline)
  1277.    } 
  1278.    else 
  1279.    {
  1280.       # mark starting point for BS/CAN and remember starting position
  1281.       vi_reset_insert()
  1282.                       
  1283.       # interpret insert keymap:
  1284.  
  1285.       message( "[ Insert mode ]" )
  1286.       if (current_keymap != vi_insert_keymap)
  1287.       {
  1288.          if (!vi_keymap_valid(vi_insert_keymap))
  1289.          {
  1290.             if (!vi_keymap_valid(default_vi_insert_keymap))
  1291.                create_vi_insert_keymaps()
  1292.             else
  1293.                vi_insert_keymap = default_vi_insert_keymap
  1294.          }
  1295.          current_keymap = vi_insert_keymap
  1296.       }
  1297.       
  1298.       # save buffer and window we start in before process_begin
  1299.       #
  1300.       insert_buffer = current_buffer
  1301.       insert_buffer_name = buffer_filename
  1302.       insert_window = current_window
  1303.       
  1304.       if (playingback)
  1305.          return
  1306.          
  1307.       vi_override_events()
  1308.       
  1309.       process_begin()
  1310.       
  1311. #      warning("Leaving Insert Mode")
  1312.       vi_restore_events()
  1313.  
  1314.  
  1315.       if (current_buffer != insert_buffer)
  1316.       {
  1317.          vi_reset(1)
  1318.          return
  1319.       }
  1320.       
  1321.       # save the new buffer and window we may now be in
  1322.       #                        
  1323.       new_cb = current_buffer
  1324.       new_cw = current_window
  1325.       
  1326.       # change to the window then the buffer you were in before the process_begin
  1327.       # to finish executing the following code
  1328. #      if (window_valid(insert_window) && new_cw != insert_window)
  1329. #         current_window = insert_window
  1330.       if (insert_buffer && new_cb != insert_buffer)
  1331.          next_buffer(insert_buffer_name, 0, 1)
  1332. #         current_buffer = insert_buffer
  1333.       
  1334.       # no longer in insert mode--erase status message
  1335. #      message( "" )
  1336.  
  1337.       # copy inserted text to insert_text (!!string length limit)
  1338.  
  1339.       if (buffer_offset <= insert_start)
  1340.          insert_text = ""
  1341.       else if ( current_line == insert_start_line )
  1342.       {
  1343.          insert_text = insert_text  \
  1344.             read_buffer( insert_start - buffer_offset ) # read backwards
  1345.       } 
  1346.       else 
  1347.       {
  1348.          line = current_line - 1
  1349.          offset = buffer_offset
  1350.          goto_buffer_offset( insert_start )
  1351.          
  1352.          # if the only text before the first line is whitespace, then include
  1353.          # it in insert_text.  This will allow reinsert_string() to properly
  1354.          # handle auto_indents.
  1355.          if ( !(read_buffer(-current_line_offset) ~ /[^ \t]/) )
  1356.             goto_bol()
  1357.  
  1358.          insert_text = insert_text read_buffer()
  1359.          current_column = 0
  1360.  
  1361.          while( current_line++ < line )
  1362.             insert_text = insert_text "\n" read_buffer()
  1363.  
  1364.          goto_buffer_offset( offset )
  1365.          insert_text = insert_text "\n" read_buffer( -current_line_offset )
  1366.       }
  1367.    }
  1368.  
  1369.    # process repeat count, if any
  1370.  
  1371.    while( count-- > 1 )
  1372.       reinsert_string( insert_text, newline)
  1373.  
  1374.    # change to new window first, then the buffer we were in after process_begin
  1375.    #
  1376. #   if ( new_cw && (new_cw != current_window) ) 
  1377. #      current_window = new_cw
  1378.  
  1379.    if ( new_cb && (new_cb != current_buffer) ) 
  1380.       current_buffer = new_cb
  1381.    
  1382.    left()   # move back one character after insert to better emulate real vi
  1383.    vi_command_mode(1)
  1384. }
  1385.  
  1386.  
  1387. local function get_column_diff(str_a, str_b)
  1388. {
  1389.    local diff
  1390.    local end_offset
  1391.    
  1392.    save_position()
  1393.    goto_eol()
  1394.    save_position()
  1395.    insert_string("\n")
  1396.    insert_string(str_a)
  1397.    diff = current_column
  1398.    goto_bol()
  1399.    delete_to_eol()
  1400.    insert_string(str_b)
  1401.    diff -= current_column
  1402.    end_offset = buffer_offset
  1403.    restore_position(1)
  1404.    delete_chars(end_offset - buffer_offset - 1)
  1405.    restore_position(1)
  1406.    
  1407.    return diff
  1408. }
  1409.  
  1410. ##
  1411. # reinsert_string (text, newline)
  1412. # Reinsert previously inserted text, properly auto-indented. 'text' contains the
  1413. # text to insert which is usually the global 'insert_text' set by vi_insert().
  1414. # 'newline' will be non-zero if vi_insert() was called by the o or O commands.  If
  1415. # it is non-zero, then vi_insert() has already inserted the first carriage return.
  1416. #  
  1417. local function reinsert_string( text, newline)
  1418. {
  1419.    local i, line, s, n
  1420.    local prev_white
  1421.    local curr_white
  1422.    local diff
  1423.    local dist
  1424.  
  1425.    if (!auto_indent_mode)
  1426.       insert_string(text)
  1427.    else
  1428.    {
  1429.       n = split( text, line, "\n" )
  1430.    
  1431.       for ( i = 1; i<= n; i++ )
  1432.       {
  1433.          s = line[ i ]
  1434.    
  1435.          # if this is the first line of a muli-line insertion, and the original
  1436.          # insertion was on a new line (o or O commands), then strip off the
  1437.          # leading whitespace since we are already at the proper auto indent level.
  1438.          if ( i == 1 && i < n && newline)
  1439.             sub( /^[ \t]+/, "", s )
  1440.          else if (i > 1 && match(line[i-1], /^[ \t]+/))
  1441.          {
  1442.             # subsequent lines must remove extra whitesspace already accounted for
  1443.             # by auto indent
  1444.             prev_white = substr(line[i-1], RSTART, RLENGTH)
  1445.             if (!sub(prev_white, "", s))
  1446.             {
  1447.                # if however, this line is indented less than the previous one
  1448.                # figure out how far back to move it
  1449.                match(line[i], /^[ \t]+/)
  1450.                curr_white = substr(line[i], RSTART, RLENGTH)
  1451.                
  1452.                # get the actual column difference between the two lines
  1453.                diff = get_column_diff(prev_white, curr_white)
  1454.                
  1455.                # move back to the closest tab stop
  1456.                while (diff > 0)
  1457.                {
  1458.                   dist = distance_prev_tab
  1459.                   current_column -= dist
  1460.                   diff -= dist 
  1461.                }
  1462.                
  1463.                # remove the extra whitespace from the line
  1464.                delete_to_eol()
  1465.                
  1466.                # remove leading whitespace from string since we're at indent level
  1467.                sub(curr_white, "", s)
  1468.             }
  1469.          }
  1470.          
  1471.          insert_string( s )
  1472.    
  1473.          if ( i < n )
  1474.             vi_insert_cr()
  1475.       }  # end for(lines)
  1476.    }
  1477. }
  1478.  
  1479. ## following functions are bound to keys for insert mode actions
  1480.  
  1481. # cancel input thus far on the current line
  1482.  
  1483. function vi_insert_cancel()
  1484. {
  1485.    local n = buffer_offset - insert_backstop
  1486.    if( n > 0 )
  1487.       {
  1488.       prev_char( n )
  1489.       delete_chars( n )
  1490.       }
  1491. }
  1492.  
  1493. # backspace in insert mode
  1494. #
  1495. #  The standard VI BS function can only bs over user-generated chars, 
  1496. #  and in particular cannot bs over auto-indent text.  This 
  1497. #  implementation allows backspacing over a-i text.  To disallow it
  1498. #  (and more faithfully emulate VI) set the bs_over_ai variable to 0.
  1499. #
  1500.  
  1501. function vi_insert_bs()
  1502. {
  1503.    if ( insert_backstop < buffer_offset )
  1504.       backspace()
  1505.    else if (   bs_over_ai     &&  
  1506.                insert_indent  && 
  1507.                (current_line_offset < buffer_offset) )
  1508.       {
  1509.       backspace()
  1510.       set_backstop( insert_indent )
  1511.       } 
  1512.    else 
  1513.       vi_warning()
  1514. }
  1515.  
  1516. # Standard VI ^D/unindent and ^T/reindent functions: ?? incomplete
  1517.  
  1518. function vi_insert_unindent()
  1519. {
  1520.    local ch = read_buffer( -1 )
  1521.    local start_offset
  1522.  
  1523.    if ( ch == "^" || ch == "0" )
  1524.       {
  1525.       insert_backstop = buffer_offset - current_line_offset
  1526.       vi_insert_cancel()
  1527.  
  1528.       # ^D should save this new indent for subsequent lines
  1529.  
  1530.       } 
  1531.    else if ( (ch == "\t" || ch == " ") &&
  1532.             !(read_buffer(-current_line_offset) ~ /[^ \t]/) )
  1533.    {
  1534.       if (ch == "\t")
  1535.          backspace()
  1536.       else
  1537.       {
  1538.          start_offset = buffer_offset
  1539.          current_column = current_column - distance_prev_tab
  1540.          delete_chars(start_offset - buffer_offset)
  1541.       }
  1542.       insert_backstop = buffer_offset
  1543.       if (insert_start_line == current_line)
  1544.          vi_reset_insert()
  1545.    }
  1546.    else
  1547.       vi_warning()
  1548. }
  1549.  
  1550. function vi_insert_reindent()
  1551. {
  1552.    if ( !(read_buffer(-current_line_offset) ~ /[^ \t]/) )
  1553.       insert_string( "\t" )
  1554.    else
  1555.       vi_warning()
  1556. }
  1557.  
  1558.  
  1559. # "dB", limited by scope of current insert
  1560.  
  1561. function vi_insert_dB()
  1562. {
  1563.    local patt = "[^a-z0-9A-Z_ \t]+" word_patt
  1564.  
  1565.    local sflags = SEARCH_REGEX + SEARCH_MAXIMAL_MATCH    \
  1566.          + SEARCH_ADVANCE + SEARCH_BACKWARD     \
  1567.          + and( search_flags, SEARCH_CASE ) \
  1568.          + and( search_flags, SEARCH_WRAPS )
  1569.          #+ and( vi_search_flags, SEARCH_CASE ) \
  1570.          #+ and( vi_search_flags, SEARCH_WRAPS )
  1571.  
  1572.    if( buffer_offset <= insert_backstop )
  1573.       vi_warning()
  1574.    else 
  1575.       {
  1576.       drop_anchor( NORMAL_SELECTION )
  1577.  
  1578.       #if( search( WORD_patt, sflags ))
  1579.       if( search( patt, sflags ))
  1580.          {                         
  1581.          if ( buffer_offset < insert_backstop )
  1582.             goto_buffer_offset( insert_backstop )
  1583.  
  1584.          delete_chars()
  1585.          #warning("after delete_chars")
  1586.          }
  1587.          
  1588.       raise_anchor()
  1589.       }
  1590. }
  1591.  
  1592. function vi_reinsert()
  1593. {
  1594.    local flag = ( insert_backstop < buffer_offset )
  1595.  
  1596.    reinsert_string( insert_text )
  1597.  
  1598.    if( !flag )
  1599.       process_end()
  1600.  
  1601.    # a more accurate implementation would beep if !flag
  1602.    # and always process_end() the insert; this is an extension
  1603. }
  1604.  
  1605. function vi_insert_quoted()
  1606. {
  1607.    local key
  1608.    local ch
  1609.  
  1610.    message( "Type ascii key to be inserted:" )
  1611.  
  1612.    key = getkey()
  1613.    ch  = int_to_ascii(key)
  1614.  
  1615.    if ( ch || key == key_to_int("<Ctrl-@>") )
  1616.    {
  1617.       insert_key( ch )
  1618.       message( "" )
  1619.    } 
  1620.    else 
  1621.       # error() would screw-up insert mode
  1622.       warning( "Can't insert non-ascii keys." )
  1623. }
  1624.  
  1625. # normal newline text entry; implements auto-indenting if enabled.
  1626.  
  1627. function vi_insert_cr(newline)
  1628. {
  1629.    local str
  1630.    insert_string( "\n" )
  1631.  
  1632.    if ( auto_indent_mode )
  1633.       {
  1634.       # if the command was O, use indenting from line below, else use line above
  1635.       if (newline == NEWLINE_BEFORE)
  1636.          next_line()
  1637.       else
  1638.          prev_line()
  1639.  
  1640.       drop_anchor()
  1641.  
  1642.       goto_bol()
  1643. #      copy_to_scrap()
  1644.       str = get_region_as_str()
  1645.  
  1646.       raise_anchor()
  1647.  
  1648.       if (newline == NEWLINE_BEFORE)
  1649.          up()
  1650.       else
  1651.          down()
  1652.          
  1653.       insert_string(str)
  1654. #      insert_scrap()
  1655.       }
  1656.  
  1657.    set_backstop( auto_indent_mode )
  1658. }
  1659.  
  1660. # shift-enter -- goto EOL and enter
  1661.  
  1662. function vi_insert_nl(newline)
  1663. {
  1664.    goto_eol()
  1665.    vi_insert_cr(newline)
  1666. }
  1667.  
  1668.  
  1669. ### Template Editing
  1670. #
  1671. #
  1672. #  vi_expand_template() checks the buffer for an abbreviation,
  1673. #     and replaces the abbreviation with the expansion
  1674. #     if there is one
  1675. #
  1676. #     Function is activated by the space, tab, or <Enter> keys
  1677. #     in insertion mode.
  1678.  
  1679.  
  1680. function vi_expand_template() 
  1681. {
  1682.    local string, len, abbreviation, ok
  1683.  
  1684.    for ( abbreviation in templates ) 
  1685.       {
  1686.       len = length( abbreviation )
  1687.  
  1688.       string = read_buffer( - len -1 )
  1689.  
  1690.       if ( ( ok = string ~ "^[ \t]" ) )
  1691.          string = substr( string, 2 ) 
  1692.  
  1693.       if ( ok || current_column == len + 1 ) 
  1694.          {
  1695.          if ( abbreviation == string ) 
  1696.             {
  1697.             current_column -= len
  1698.             delete_chars( len )
  1699.             insert_string( templates[ abbreviation ] )
  1700.             }
  1701.          }
  1702.       }
  1703.  
  1704.    if ( and( current_key, 0x00ff) == 13 )
  1705.       vi_insert_cr()
  1706.    else
  1707.       insert_key()
  1708. }
  1709.  
  1710.  
  1711. ### insertion commands
  1712.  
  1713. function vi_i()
  1714. {
  1715.    op_type_1()
  1716.  
  1717.    vi_insert()
  1718. }
  1719.  
  1720. function vi_I()
  1721. {
  1722.    op_type_1()
  1723.  
  1724.    skip_whitespace()
  1725.    vi_insert()
  1726. }
  1727.  
  1728.  
  1729. function vi_a()
  1730. {
  1731.    op_type_1()
  1732.  
  1733.    if ( current_line_length > current_line_offset )
  1734.       right()
  1735.  
  1736.    vi_insert()
  1737. }
  1738.  
  1739. function vi_A()
  1740. {
  1741.    op_type_1()
  1742.  
  1743.    goto_eol()
  1744.    vi_insert()
  1745. }
  1746.  
  1747.  
  1748. function vi_o()
  1749. {
  1750.    op_type_1()
  1751.  
  1752.    vi_insert( NEWLINE_AFTER )
  1753. }
  1754.  
  1755. function vi_O()
  1756. {
  1757.    op_type_1()
  1758.  
  1759.    vi_insert( NEWLINE_BEFORE )
  1760. }
  1761.  
  1762. ### deletions
  1763. #
  1764. #  all deletions delete_to_scrap() even if single character
  1765.  
  1766.  
  1767. function vi_X()
  1768. {
  1769.    op_type_1()
  1770.  
  1771.    select_chars( -use_number() )
  1772.    vi_yank( AND_DELETE )
  1773. }
  1774.  
  1775. function vi_x()
  1776. {
  1777.    op_type_1()
  1778.  
  1779.    select_chars( use_number())
  1780.    vi_yank( AND_DELETE )
  1781.  
  1782.    if ( (current_line_length <= current_line_offset) && 
  1783.          current_line_offset )
  1784.       prev_char()
  1785. }
  1786.  
  1787. ## more complex edits -- combinations of delete/insert
  1788.  
  1789. function vi_J()
  1790. {
  1791.    local n = use_number()
  1792.    local ins
  1793.  
  1794.    op_type_1()
  1795.  
  1796.    if ( n > 1 )
  1797.       n -= 1
  1798.  
  1799.    while ( n-- > 0 )
  1800.       {
  1801.       goto_eol()
  1802.  
  1803.       while ( read_buffer( -1 ) ~ /[ \t]/ )
  1804.          prev_char()
  1805.  
  1806.       ins = ( read_buffer( -1 ) == "." ) ? "  " : " "
  1807.  
  1808.       drop_anchor()
  1809.       next_line()
  1810.       vi_yank( AND_DELETE )
  1811.  
  1812.       if ( read_buffer( 1 ) != "(" )
  1813.          insert_string( ins )
  1814.       }
  1815. }
  1816.  
  1817. function vi_D()
  1818. {
  1819.    op_type_1()
  1820.    pend_operator( "d" )
  1821.    vi_goto_eol()
  1822. }
  1823.  
  1824. function vi_C()
  1825. {
  1826.    vi_D()
  1827.    vi_insert()
  1828. }
  1829.  
  1830. function vi_R()
  1831. {
  1832.    op_type_1()
  1833.    buffer_flags = or( buffer_flags, BUFFER_OVERTYPE_MODE )
  1834.  
  1835.    vi_insert()
  1836.    buffer_flags = xor( buffer_flags, BUFFER_OVERTYPE_MODE )
  1837. }
  1838.  
  1839. function vi_r( )
  1840. {
  1841.    local n
  1842.  
  1843.    op_type_1()
  1844.  
  1845.    n = use_number()
  1846.  
  1847.    # limit scope to current line
  1848.    if ( current_line_length - current_line_offset < n )
  1849.       vi_error()
  1850.  
  1851.    if ( !playing_again )
  1852.       vi_r_ch = vi_getc()
  1853.    if ( vi_r_ch == "\r" || vi_r_ch == "\n" )
  1854.       vi_r_ch = "\n"
  1855.  
  1856.    # number returned will be different than n if there is already a selection
  1857.    n = select_chars( n )
  1858.    vi_yank( AND_DELETE )
  1859.  
  1860.    if ( vi_r_ch == "\n" )
  1861.       {
  1862.       while( n-- > 0 )
  1863.          vi_insert_cr()
  1864.       } 
  1865.    else 
  1866.       {
  1867.       while( n-- > 0 )
  1868.          insert_string( vi_r_ch )
  1869.  
  1870.       if ( current_column > 1 )
  1871.          prev_char()
  1872.       }
  1873. }
  1874.  
  1875. function vi_S()
  1876. {
  1877.    op_type_1()
  1878.  
  1879.    select_lines( use_number())
  1880.    vi_yank( AND_DELETE )
  1881.    vi_insert( NEWLINE_BEFORE )
  1882. }
  1883.  
  1884. function vi_s()
  1885. {
  1886.    op_type_1()
  1887.  
  1888. # This command is not needed, restore position is never called 
  1889. # on it.  I removed it because of a current bug in raise_anchor:
  1890. # it will restore the selection set by save_position, leaving
  1891. # the user an unwanted selection.  DWM
  1892. #   save_position();
  1893.  
  1894.    select_chars( use_number())
  1895.    vi_yank( AND_DELETE )
  1896.    vi_insert()
  1897. }
  1898.  
  1899. function vi_tilde()
  1900. {
  1901.    op_type_1()
  1902.  
  1903.    select_chars( use_number())
  1904.       
  1905.    reverse()
  1906.  
  1907.    raise_anchor()
  1908.    
  1909.    if ( (current_line_length <= current_line_offset) && 
  1910.          current_line_offset )
  1911.       prev_char()
  1912. }
  1913.  
  1914. ### vi motion commands
  1915.  
  1916. local function vi_goto_line( line )
  1917. {
  1918.    current_line = line
  1919.    skip_whitespace()
  1920. }
  1921.  
  1922. function vi_goto( n )
  1923. {
  1924.    op_type_2b( MAJOR_MARK )
  1925.  
  1926.    if ( number_register )
  1927.       n = use_number()     # need a range check
  1928.    else if( !n )
  1929.          n = buffer_last_line
  1930.  
  1931.    vi_goto_line( n )
  1932.  
  1933.    xeq_op( LINE_SELECTION )
  1934. }
  1935.  
  1936. local vert_column
  1937. local vert_motion
  1938.  
  1939. # vi_arrow()
  1940. # Arrow key handler.
  1941. # which: 1 = up, 2 = down, 3 = left, 4 = right
  1942. function vi_arrow(which)
  1943. {
  1944.    local n = 1
  1945.    local remaining = current_line_length - (current_line_offset + 1)
  1946.    local down_target
  1947.  
  1948.    if (in_ex_mode)
  1949.    {
  1950.       n = use_number()
  1951.  
  1952.       if (which < 1 || which > 4)
  1953.          which = 1
  1954.          
  1955.       if ( which == 1 && current_line <= n )
  1956.          n = current_line
  1957.       else if (which == 2 && (down_target = current_line + n) > buffer_last_line)
  1958.          n = buffer_last_line - current_line
  1959.       else if (which == 3 && current_line_offset < n )
  1960.          n = current_line_offset
  1961.       else if (which == 4 &&  remaining <= n )
  1962.          n = remaining + (pending_operator == "" ? 0 : 1)
  1963.  
  1964.       if (n < 1)
  1965.          vi_error()
  1966.          
  1967.       op_type_2b()
  1968.    }
  1969.    
  1970.    vi_move(which, n)
  1971.  
  1972.    if (in_ex_mode)
  1973.       xeq_op(which < 3 ? LINE_SELECTION : 0)
  1974.    else
  1975.       vi_reset_insert()
  1976. }
  1977.  
  1978. # vi_insert_arrow()
  1979. # Arrow key handler when in insert mode.
  1980. # which: 1 = up, 2 = down, 3 = left, 4 = right,
  1981. #        5 = home, 6 = end, 7 = page up, 8 = page down
  1982. function vi_insert_arrow(which)
  1983. {
  1984.    if (which < 5)
  1985.       vi_move(which, 1)
  1986.    else if (which == 5)
  1987.       home_key()
  1988.    else if (which == 6)
  1989.       end_key()
  1990.    else if (which == 7)
  1991.       page_up()
  1992.    else if (which == 8)
  1993.       page_down()
  1994.  
  1995.    vi_reset_insert()
  1996. }
  1997.  
  1998.  
  1999. local function vi_move(dir, n)
  2000. {
  2001.    if (dir < 3) # up or down
  2002.       if ( prev_command != vert_motion )
  2003.          vert_column = current_column
  2004.       else
  2005.          current_column = vert_column
  2006.  
  2007.    if (dir == 1)
  2008.    {
  2009.       vert_motion = current_command
  2010.       up( n )
  2011.       vi_adjust_column()
  2012.    }
  2013.    else if (dir == 2)
  2014.    {
  2015.       vert_motion = current_command
  2016.       move_down( n )
  2017.       vi_adjust_column()
  2018.    }
  2019.    else if (dir == 3)
  2020.    {
  2021.       vert_motion = 0
  2022.       prev_char( n )
  2023.    }
  2024.    else if (dir == 4)
  2025.    {
  2026.       vert_motion = 0
  2027.       next_char( n )
  2028.    }
  2029. } 
  2030.  
  2031. function vi_space()
  2032. {
  2033.    if ( selection_type() )
  2034.       {
  2035.       operator_disallowed()
  2036.  
  2037.       if ( and(keyboard_flags, KB_ALT) )
  2038.          outdent_columns()
  2039.       else
  2040.          indent_columns()  
  2041.  
  2042.       } 
  2043.    else 
  2044.       vi_arrow(4) # right
  2045. }
  2046.  
  2047. function vi_bksp()
  2048. {
  2049.    if ( selection_type() )
  2050.       {
  2051.       operator_disallowed()
  2052.       outdent_columns()    
  2053.       } 
  2054.    else 
  2055.       vi_arrow(3) # left
  2056. }
  2057.  
  2058. function vi_tab()
  2059. {
  2060.    if ( selection_type() )
  2061.       {
  2062.       operator_disallowed()
  2063.       if ( and(keyboard_flags, KB_ALT) )
  2064.          outdent_lines()
  2065.          #outdent_tabs()
  2066.       else
  2067.          indent_lines()
  2068.          #indent_tabs()
  2069.       } 
  2070.    else 
  2071.       vi_error()
  2072. }
  2073.  
  2074. function vi_back_tab()
  2075. {
  2076.    if ( selection_type() )
  2077.       {
  2078.       operator_disallowed()
  2079.       outdent_lines()
  2080.       #outdent_tabs()
  2081.       } 
  2082.    else 
  2083.       vi_error()
  2084. }
  2085.  
  2086. function vi_goto_column()
  2087. {
  2088.    local n = use_number()
  2089.  
  2090.    if ( current_line_width < n )
  2091.       vi_error()
  2092.  
  2093.    op_type_2b()
  2094.    current_column = n
  2095.    xeq_op()
  2096. }
  2097.  
  2098. function vi_H()
  2099. {
  2100.    local n = use_number() - 1
  2101.  
  2102.    op_type_2b( MAJOR_MARK )
  2103.  
  2104.    goto_window_top()
  2105.  
  2106.    if ( n >= window_text_height )
  2107.       n = window_text_height - 1
  2108.  
  2109.    down( n )
  2110.    skip_whitespace()
  2111.  
  2112.    xeq_op( LINE_SELECTION )
  2113. }
  2114.  
  2115. function vi_M()
  2116. {
  2117.    disallow_number()
  2118.    op_type_2b( MAJOR_MARK )
  2119.  
  2120.    goto_window_middle()
  2121.    skip_whitespace()
  2122.  
  2123.    xeq_op( LINE_SELECTION )
  2124. }
  2125.  
  2126. function vi_L()
  2127. {
  2128.    local n = use_number() - 1
  2129.  
  2130.    op_type_2b( MAJOR_MARK )
  2131.  
  2132.    goto_window_bottom()
  2133.  
  2134.    if ( n >= window_text_height )
  2135.       n = window_text_height - 1
  2136.  
  2137.    up( n )
  2138.    skip_whitespace()
  2139.  
  2140.    xeq_op( LINE_SELECTION )
  2141. }
  2142.  
  2143. function vi_goto_bol()
  2144. {
  2145.    disallow_number()
  2146.  
  2147.    op_type_2b()
  2148.    goto_bol()
  2149.    xeq_op()
  2150. }
  2151.  
  2152. function vi_goto_eol()
  2153. {
  2154.    local n = use_number()
  2155.  
  2156.    op_type_2b()
  2157.  
  2158.    if ( n > 1 )
  2159.       down( n - 1 )
  2160.  
  2161.    current_column = current_line_width # goto_eol()
  2162.    xeq_op( current_line_width ? INCLUSIVE_SELECTION : NORMAL_SELECTION )
  2163. }
  2164.  
  2165. function vi_next_line()
  2166. {
  2167.    local n = use_number()
  2168.  
  2169.    op_type_2b()
  2170.    next_line( n )
  2171.    xeq_op( LINE_SELECTION )
  2172. }
  2173.  
  2174. function vi_prev_line()
  2175. {
  2176.    local n = use_number()
  2177.  
  2178.    op_type_2b()
  2179.    prev_line( n )
  2180.    xeq_op( LINE_SELECTION )
  2181. }
  2182.  
  2183. function vi_skip_whitespace()
  2184. {
  2185.    local n = use_number()
  2186.  
  2187.    op_type_2b()
  2188.    skip_whitespace()
  2189.    xeq_op()
  2190. }
  2191.  
  2192. function vi_goto_matching()
  2193. {
  2194.    local n = use_number()
  2195.  
  2196.    op_type_2b( MAJOR_MARK )
  2197.    if ( read_buffer( 1 ) !~ /[(){}[\]]/ )
  2198.       if ( match(read_buffer(), "[(){}[\\]]") )
  2199.          next_char( RSTART - 1 )
  2200.       else
  2201.          vi_error()
  2202.  
  2203.    goto_matching()
  2204.    xeq_op( INCLUSIVE_SELECTION )
  2205. }
  2206.  
  2207. local function vi_adjust_column()
  2208. {
  2209.  
  2210. #   if (  and( buffer_flags, BUFFER_POSITION_IS_VIRTUAL ) || 
  2211. #         ( current_line_offset == current_line_length )     )
  2212.    if ( current_line_offset >= current_line_length )
  2213.       {
  2214.       goto_eol()
  2215.  
  2216.       if ( current_line_offset )
  2217.          prev_char()
  2218.       }
  2219.  
  2220.    origPos = buffer_offset;
  2221. }
  2222.  
  2223.  
  2224.  
  2225. # Word, sentence, paragraph, and section motions.
  2226. # Different commands call vi_motion with one of the patterns below.
  2227. #
  2228. # Different dialects of vi implement subtle variations for certain combos:
  2229. #
  2230. #  Commands.....     SPE   MKS   Sun   AIX
  2231. #
  2232. #  !w >W etc.     yes   yes   error error
  2233. #
  2234. #  w W b B over \n      skips skips stops error
  2235. #           \n \n at \n
  2236. #
  2237. #
  2238. #  add "|^[ \t]*$" to word_, WORD_, end_, and END_patt to make these
  2239. #  motions treat newlines as words, ala Sun vi.
  2240.  
  2241.  
  2242. # the following search pattern would be better to use, but cursor placement
  2243. # seems to mess things up.
  2244. local word_patt = "[a-z0-9A-Z_]+"
  2245. local WORD_patt = "[^ \t]+"
  2246. #local  end_patt = "[a-z0-9A-Z_]*[a-z0-9A-Z_]\\c"#|[^a-z0-9A-Z_ \t]*\\c[^a-z0-9A-Z_ \t]"
  2247. # The following 2 patterns are used by vi_e() to define a word.  See the comment
  2248. # for the vi_e() function.
  2249. local  end_patt = "[a-z0-9A-Z_]*\\c[a-z0-9A-Z_]"
  2250. local  end_patt2 = "[^a-z0-9A-Z_ \t]*\\c[^a-z0-9A-Z_ \t]"
  2251. local END_patt = "[^ \t]*\\c[^ \t]"
  2252. #local END_patt = "[a-z0-9A-Z_]([ \t]+|$)"
  2253. #local sent_patt   = "(\\.|!|\\?)[)\"'\\]]*(\t| |$|^)"
  2254. #local para_patt   = "^$|^\\.PP$|^\\.NH|^\\.IP|^\\.LP|^\\.PP|^\\.QP|^\\.LI"
  2255. #local sect_patt   = "^\\.NH|^\\.SH|^\\.H([ \t]|$)|^\\.HU|^\\{|^function|^local[ \t]+function|^global[ \t]+function|^\f"
  2256.  
  2257.  
  2258. local function vi_motion( patt, direction )
  2259. {
  2260.    if ( direction )
  2261.       return vi_forward_motion( patt )
  2262.    else
  2263.       return vi_backward_motion( patt )
  2264. }
  2265.  
  2266. local origPos 
  2267.  
  2268. # this function is never used
  2269. #local function vi_save_pos()
  2270. #{
  2271. #   origPos = buffer_offset;
  2272. #}
  2273.  
  2274. local function vi_forward_motion( patt )
  2275. {
  2276.    local sflags = SEARCH_REGEX + SEARCH_MAXIMAL_MATCH + SEARCH_FORWARD + SEARCH_HIGHLIGHT
  2277.    local count
  2278.    origPos = buffer_offset;
  2279.  
  2280.    search_count = 0
  2281.    count = use_number()
  2282.    op_type_2b( MAJOR_MARK )
  2283.  
  2284.    save_position()
  2285.  
  2286.    do
  2287.       {
  2288.       if ( !search( patt, sflags ) )
  2289.          {
  2290.          restore_position( 1 )
  2291.          vi_error()
  2292.          break
  2293.          }
  2294.  
  2295.       if ( buffer_offset == origPos )
  2296.          {
  2297.          # didn't move, so advance past current pattern
  2298.          if ( !search_string_length )
  2299.             break
  2300.  
  2301.          goto_buffer_offset( origPos + search_string_length )
  2302.          count++
  2303.          } 
  2304.       else 
  2305.          origPos = buffer_offset
  2306.  
  2307.       # WGN - Removed following to better emulate vi
  2308.       #if ( patt == END_patt )
  2309.          #right();
  2310.  
  2311.       } 
  2312.    while ( --count > 0 )
  2313.  
  2314.    restore_position( 0 )
  2315. }
  2316.  
  2317. local function vi_backward_motion( patt )
  2318. {
  2319.    local sflags = SEARCH_REGEX + 
  2320.                   SEARCH_MAXIMAL_MATCH + 
  2321.                   SEARCH_FORWARD + 
  2322.                   SEARCH_ONCE_PER_LINE
  2323.    local count
  2324.    local found
  2325.    local line
  2326.    local origPos = buffer_offset
  2327.  
  2328.    count = use_number()
  2329.    search_count = 0
  2330.  
  2331.    op_type_2b( MAJOR_MARK )
  2332.  
  2333.    save_position()
  2334.  
  2335.    do 
  2336.       {
  2337.       # advance forward to the match immediately preceeding the
  2338.       # cursor position
  2339.       #
  2340.  
  2341.       found = FALSE
  2342.       save_position()
  2343.  
  2344.       for ( line = current_line; line; line-- )
  2345.          {
  2346.          goto_pos( line, 1 )
  2347.  
  2348.          while ( search( patt, sflags ) && (buffer_offset < origPos ) )
  2349.             {
  2350.             found = TRUE
  2351.             restore_position( 0 )
  2352.             save_position()
  2353.             goto_buffer_offset( buffer_offset + search_string_length )
  2354.             }
  2355.  
  2356.          if ( found )
  2357.             {
  2358.             restore_position( 1 )
  2359.             origPos = buffer_offset
  2360.             count--
  2361.             break
  2362.             }
  2363.          }
  2364.       } while ( count > 0 && line )
  2365.  
  2366.    restore_position( 0 )
  2367.  
  2368.    if ( !found )
  2369.       {
  2370.       restore_position( 1 )
  2371.       vi_error()
  2372.       }
  2373. }
  2374.  
  2375.  
  2376. function vi_w( patt )
  2377. {
  2378.    local toLeft = 0;
  2379.  
  2380.    if ( !argcount() )
  2381. #      patt = word_patt
  2382.       # WGN - Added 0-9 to following pattern to work like real vi
  2383. #      patt = "[^a-zA-Z_ \t]+|" word_patt
  2384.       patt = "[^a-z0-9A-Z_ \t]+|" word_patt
  2385.  
  2386.    if ( pending_operator ~ /[ycd]/ )
  2387.       patt = patt "|$"
  2388.  
  2389.    if ( pending_operator == "c" )
  2390.       vi_cw( patt )
  2391.    else 
  2392.       {
  2393.       vi_motion( patt, SEARCH_FORWARD )
  2394.  
  2395.       xeq_op( NORMAL_SELECTION )
  2396.       }
  2397. }
  2398.  
  2399. function vi_cw( patt )
  2400. {
  2401.    local ch = read_buffer( 1 )
  2402.  
  2403.    vi_motion( patt, SEARCH_FORWARD )
  2404.  
  2405.    if ( ch !~ /[ \t]/ )
  2406.       {
  2407.       search( "[^ \t]\\c", 
  2408.                SEARCH_REGEX + 
  2409.                SEARCH_ADVANCE + 
  2410.                and( search_flags, SEARCH_CASE ) + 
  2411.                and( search_flags, SEARCH_WRAPS) )
  2412.                #and( vi_search_flags, SEARCH_CASE ) + 
  2413.                #and( vi_search_flags, SEARCH_WRAPS) )
  2414.       }
  2415.  
  2416.       xeq_op( NORMAL_SELECTION )
  2417.  
  2418. }
  2419.  
  2420. function vi_W()
  2421. {
  2422.    vi_w( WORD_patt )
  2423. }
  2424.             
  2425. ## vi_e()
  2426. ##
  2427. # Move to the end of the current word, or the end of the next word if already
  2428. # at the end of a word.  For vi_e(), a word is either a string of letters,
  2429. # numbers and underscores, or a string of punctuation characters.  Which
  2430. # definition of a word to use depends on the value of the next non-whitespace
  2431. # character.
  2432. function vi_e()
  2433. {
  2434.    local char
  2435.    local patt = end_patt
  2436.    
  2437.    save_position()
  2438.    
  2439.    next_char()
  2440.    char = read_buffer(1)
  2441.    while (char && isspace(char))
  2442.    {
  2443.       next_char()
  2444.       char = read_buffer(1)
  2445.    }
  2446.    
  2447.    if (char && (char ~ end_patt2) )
  2448.       patt = end_patt2
  2449.       
  2450.    restore_position(1)  # go back to where we started
  2451.    vi_motion( patt, SEARCH_FORWARD )
  2452.    xeq_op( INCLUSIVE_SELECTION )
  2453. }
  2454.  
  2455. ## vi_E()
  2456. ##
  2457. # Move to the end of the current word, or the end of the next word if already
  2458. # at the end of a word.  For vi_E(), a word is either a string of 
  2459. # non-whitespace characters.
  2460. function vi_E()
  2461. {
  2462.    vi_motion( END_patt, SEARCH_FORWARD )
  2463.    xeq_op( INCLUSIVE_SELECTION )
  2464. }
  2465.  
  2466. function vi_B()
  2467. {
  2468.    vi_motion( WORD_patt, SEARCH_BACKWARD )
  2469.    xeq_op( NORMAL_SELECTION )
  2470. }
  2471.  
  2472. function vi_b()
  2473. {
  2474.    local toLeft;
  2475.    local patt = "[^a-z0-9A-Z_ \t]+|" word_patt
  2476.    
  2477.    vi_motion( patt, SEARCH_BACKWARD )
  2478.  
  2479.    xeq_op( NORMAL_SELECTION )
  2480. }
  2481.  
  2482. function vi_prev_sent()
  2483. {
  2484.    op_type_2b( MAJOR_MARK )
  2485.  
  2486.    if (!prev_sentence(use_number()))
  2487.       goto_buffer_top()
  2488.    else
  2489.       xeq_op( NORMAL_SELECTION )
  2490. }
  2491.  
  2492. function vi_next_sent()
  2493. {
  2494.    op_type_2b( MAJOR_MARK )
  2495.  
  2496.    if (!next_sentence(use_number()))
  2497.       goto_buffer_bottom()
  2498.    else
  2499.       xeq_op( NORMAL_SELECTION )
  2500. }
  2501.  
  2502. function vi_prev_para()
  2503. {
  2504.    op_type_2b( MAJOR_MARK )
  2505.  
  2506.    if (!prev_paragraph(use_number()))
  2507.       goto_buffer_top()
  2508.    else
  2509.    {
  2510.       if ( pending_operator )
  2511.          current_line--
  2512.    
  2513.       xeq_op( LINE_SELECTION )
  2514.    }
  2515. }
  2516.  
  2517. function vi_next_para()
  2518. {
  2519.    op_type_2b( MAJOR_MARK )
  2520.  
  2521.    if (!next_paragraph(use_number()))
  2522.       goto_buffer_bottom()
  2523.    else
  2524.    {
  2525.       if ( pending_operator )
  2526.          current_line--
  2527.    
  2528.       xeq_op( LINE_SELECTION )
  2529.    }
  2530. }
  2531.  
  2532. function vi_prev_sect()
  2533. {
  2534.    local ch = "["
  2535.    
  2536.    op_type_2b( MAJOR_MARK )
  2537.  
  2538.    if (!playing_again)
  2539.       ch = vi_getc()
  2540.  
  2541.    if (ch != "[")
  2542.       vi_error()
  2543.    else
  2544.    {
  2545.       if (!prev_section(use_number()))
  2546.          goto_buffer_top()
  2547.  
  2548.       if ( pending_operator && current_line > 1)
  2549.          current_line--
  2550.    
  2551.       # must update view to use window_first
  2552.       update_current_view()
  2553.       if (current_line > 1 && current_line == window_first)
  2554.       {
  2555.          save_position()
  2556.          message("scrolling window")
  2557.          scroll_up_1()
  2558.          restore_position(1)
  2559.       }
  2560.       xeq_op( LINE_SELECTION )
  2561.    }
  2562. }
  2563.  
  2564. function vi_next_sect()
  2565. {
  2566.    local ch = "]"
  2567.    local result = 0
  2568.    local patt = section_pattern
  2569.    
  2570.    op_type_2b( MAJOR_MARK )
  2571.  
  2572.    if (!playing_again)
  2573.       ch = vi_getc()
  2574.  
  2575.    if (ch != "]")
  2576.       vi_error()
  2577.    else
  2578.    {
  2579.       if (pending_operator)
  2580.          patt = section_end_pattern "|" patt
  2581.       
  2582.       if (!next_section(use_number(), patt))
  2583.       {
  2584.          goto_buffer_bottom()
  2585.          goto_bol()
  2586.       }
  2587.       else
  2588.          if (pending_operator && (read_buffer(1) ~ section_pattern) )
  2589.             current_line--
  2590.  
  2591.       xeq_op( LINE_SELECTION )
  2592.    }
  2593. }
  2594.  
  2595.  
  2596.  
  2597.  
  2598. ## vi "find" commands
  2599. #  fx skip forward to character "x"
  2600. #  Fx skip backwards to character "x"
  2601. #  tx skip forwards to just before character "x"
  2602. #  Tx backwards just before "x"
  2603. #  ;  repeat last find command
  2604. #  ,  execute last find command in reverse direction
  2605.  
  2606. function vi_find_repeat()
  2607. {
  2608.    vi_find_it( vi_find_com )
  2609. }
  2610.  
  2611. function vi_find_reverse()
  2612. {
  2613.    local com = toreverse( vi_find_com )
  2614.    vi_find_it( com )
  2615. }
  2616.  
  2617. function vi_find()
  2618. {
  2619.    vi_find_com = chr( current_key )
  2620.    vi_find_it( vi_find_com, 1 )
  2621. }
  2622.  
  2623. local function vi_find_it( com, needChar )
  2624. {
  2625.    local i, n
  2626.  
  2627.    op_type_2b( MAJOR_MARK )
  2628.  
  2629.    if ( needChar && !playing_again) 
  2630.       vi_find_char = vi_getc()
  2631.  
  2632.    if ( !vi_find_char )
  2633.       vi_error()
  2634.  
  2635.    n = use_number()
  2636.  
  2637.    while ( n-- > 0 )
  2638.       {
  2639.       # forwards
  2640.       if ( islower( com ) )
  2641.          {    
  2642.          i = index( substr( read_buffer(), 2), vi_find_char )
  2643.          if ( i )
  2644.             next_char( i - ( com == "t" ))
  2645.          } 
  2646.       # backwards
  2647.       else 
  2648.          {       
  2649.          i = bindex( read_buffer( - current_column ), vi_find_char )
  2650.          if ( i )
  2651.             prev_char( i - ( com == "T" ))
  2652.          }
  2653.       }
  2654.  
  2655.    if ( !i )
  2656.       vi_error()
  2657.  
  2658.    xeq_op( islower( com ) ? INCLUSIVE_SELECTION : NORMAL_SELECTION )
  2659. }
  2660.  
  2661. # backwards index
  2662. #  return the offset left from the end of the string of the rightmost 
  2663. #  instance of ch, if any, in s
  2664.  
  2665. local function bindex( s, ch )
  2666. {
  2667.    local n = rindex( s, ch )
  2668.  
  2669.    if ( n )
  2670.       n = length( s ) - n + 1
  2671.  
  2672.    return n
  2673. }
  2674.  
  2675. function vi_scroll_window()
  2676. {
  2677.    local key
  2678.    local c
  2679.    disallow_number()
  2680.    if ( !playing_again )
  2681.       key = getkey()
  2682.  
  2683.    if ( key == KEYCODE_KEYPAD_ENTER || key == KEYCODE_ENTER)
  2684.       scroll_window_top()
  2685.    else 
  2686.    {
  2687.       c = chr(int_to_ascii(key)) 
  2688.       if (c == ".")
  2689.          scroll_window_middle()
  2690.       else if (c == "-")
  2691.          scroll_window_bottom()
  2692.       else
  2693.          vi_error()  
  2694.    }
  2695. }
  2696.  
  2697.  
  2698. ## marks & mark motion
  2699.  
  2700. # translate a mark ascii name to a bookmark id
  2701.  
  2702. local function vi_mark_id( ch )
  2703. {
  2704.    if ( !argcount())
  2705.       if (!playing_again)
  2706.          ch = vi_getc()
  2707.       else
  2708.          ch = prev_mark_id
  2709.  
  2710.    prev_mark_id = ch 
  2711.  
  2712.    if ( ch ~ /[`']/ )
  2713.       return vi_base_mark
  2714.  
  2715.    if ( ch ~ /[a-zA-Z]/ )
  2716.       return vi_base_mark + ord( toupper( ch )) - ord( "@" )
  2717.  
  2718.    vi_error()
  2719. }
  2720.  
  2721.  
  2722. # record current position into "`" mark
  2723. #  called by all motion commands to permit goto previous location,
  2724. #  and to mark the range of vi operators
  2725. #
  2726. #  context_type:  0 or Null =>   mark motion starting point
  2727. #        1 =>     mark non-relative motion starting point
  2728. #        2 =>     don't mark (for vi_place_mark)
  2729.  
  2730. local function mark_context( context_type )
  2731. {
  2732.    if ( context_type == DONT_MARK )
  2733.       return
  2734.  
  2735.    if ( context_type == MAJOR_MARK )
  2736.       create_mark( vi_major_mark ) 
  2737.  
  2738.    create_mark( vi_base_mark ) #, current_line, current_column )
  2739. }
  2740.  
  2741.  
  2742. # m command -- places a mark here
  2743.  
  2744. function vi_place_mark()
  2745. {
  2746.    operator_disallowed()
  2747.    disallow_number()
  2748.    record_op()
  2749.    create_mark( vi_mark_id(), current_line, current_column )
  2750. }
  2751.  
  2752. function vi_goto_mark()
  2753. {
  2754.    local lines = chr( int_to_ascii(current_key) ) == vi_line_mark
  2755.    local mark
  2756.  
  2757.    disallow_number()
  2758.    record_op()
  2759.    op_type_2b( DONT_MARK )
  2760.    mark = vi_mark_id()
  2761.  
  2762.    if ( mark == vi_base_mark )
  2763.       swap_marks( vi_major_mark, 0 )
  2764.    else 
  2765.       {
  2766.       if ( !mark_defined( mark ))
  2767.          vi_error()
  2768.  
  2769.       mark_context( MAJOR_MARK )
  2770.       goto_mark( mark )
  2771.       }
  2772.  
  2773.    if ( lines )
  2774.       skip_whitespace()
  2775.  
  2776.    xeq_op( lines ? LINE_SELECTION : NORMAL_SELECTION )
  2777. }
  2778.  
  2779. # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # #
  2780.  # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # #
  2781. # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # #
  2782.  
  2783. ### ex mode
  2784. #
  2785. #  ex_key:     prompt the user; call x_mode if something entered
  2786. #
  2787. #  ex_mode: handle non-globable prefix and suffix
  2788. #
  2789. #  ex_mode1:   called recursively by ex_glob()
  2790. #
  2791. #  Bug: this version ignores superflurous stuff after a valid command
  2792.  
  2793. function ex_key()
  2794. {
  2795.    local com
  2796.  
  2797.    operator_disallowed()
  2798.    establish_baseline()
  2799.  
  2800.    com = vi_prompt( "EX_MODE", ":" )
  2801.    original_com = com
  2802.  
  2803.    if ( com )
  2804.       ex_mode( com )
  2805. }
  2806.  
  2807. local function ex_mode( command )
  2808. {
  2809.    ex_com = command 
  2810.    ex_address_range()
  2811.  
  2812.    ex_mode1()
  2813.  
  2814.    if ( browser_bid )
  2815.       browse_printed()
  2816.  
  2817.    vi_command_mode()
  2818. }
  2819.  
  2820. local function ex_mode1( command )
  2821. {
  2822.    local times, n, com, variant, macro_name, key_function, macro_body
  2823.    local tmp_str = ""
  2824.    local covered_macro, covered_name, covered_body
  2825.    local abbreviation
  2826.    local buf_char
  2827.    local count, mark
  2828.    local NI = " -- not implemented"
  2829.  
  2830.  
  2831.    if( command )
  2832.       ex_com = command 
  2833.  
  2834.    com = eat_command() # eat_command operates on ex_com (via eat_match())
  2835.  
  2836.    #count = eat_count()
  2837. #   message("com = %s, ex_addresses = %d, ex_addr1 = %d, ex_addr2 = %d, command = %s",
  2838. #            com, ex_addresses, ex_addr1, ex_addr2, command)
  2839. #   message("original_com = %s, command = %s, ex_com = %s, com = %s",
  2840. #            original_com, command, ex_com, com)
  2841.    #return
  2842.             
  2843.    if( com == "" && ex_addresses == 1)
  2844.       vi_goto_line( ex_addr1 )   
  2845.  
  2846.    else if ( com == "" && ex_addresses > 1 )
  2847.       {
  2848.       select_range( DEFAULT_ONE )
  2849.       copy_to_scrap()
  2850.       scrap_to_browser()
  2851.       raise_anchor()
  2852.       }
  2853.    else if( com == "" )
  2854.       {
  2855.       vi_error( "unrecognized command" )
  2856.       }
  2857.    else if( index( "append", com ) == 1 )
  2858.       {
  2859.       eat_space()
  2860.       next_line()
  2861.       prev_char()
  2862.       insert_string( ex_com )
  2863.       insert_newline()
  2864.       }
  2865.    else if( index( "abbreviate", com ) == 1 )
  2866.       {
  2867.       if( in_glob )
  2868.          vi_error( "can't glob:" com ex_com )
  2869.       else if( ex_addresses )
  2870.          vi_error( "addresses are illegal for :" com ex_com )
  2871.       else
  2872.          {
  2873.          abbreviation = eat_word()
  2874.          if( !abbreviation)
  2875.             vi_error( "null abbreviation not allowed" )
  2876.          else
  2877.             {
  2878.             eat_space()
  2879.             templates[ abbreviation ] = ex_com
  2880.             }
  2881.          }
  2882.       }
  2883.    else if( index( "args", com ) == 1 )
  2884.       vi_error( "args" NI )
  2885.    
  2886.    else if( index( "change", com ) == 1 )
  2887.       {
  2888.       count = eat_count()
  2889.       if( ex_addresses == 1 && count )
  2890.          {
  2891.          ex_addresses = 2
  2892.          ex_addr2 = ex_addr1 + count - 1
  2893.          }
  2894.  
  2895.       select_range( DEFAULT_ONE )
  2896.       vi_yank( AND_DELETE )
  2897.       variant = eat_bang()
  2898.       if( variant )
  2899.          auto_indent_mode = option_disable[ "autoindent" ]
  2900.       vi_O()
  2901.       if( variant )
  2902.          auto_indent_mode = ! option_disable[ "autoindent" ]
  2903.  
  2904.       }
  2905.    else if( index( "cd", com ) == 1 )
  2906.       vi_error( "cd" NI )
  2907.  
  2908.    else if( index( "copy", com ) == 1 )
  2909.       ex_copy( COPY )
  2910.  
  2911.    else if( index( "cr", com ) == 1 )
  2912.       vi_error( "cr" NI )
  2913.  
  2914.    else if( com == "X" )
  2915.       vi_error( "X" NI )
  2916.  
  2917.    else if( index( "delete", com ) == 1 )
  2918.       {
  2919.       eat_space()
  2920.       buf_char = eat_match( "[a-zA-Z]" )
  2921.       count = eat_count()
  2922.       if( ex_addresses == 1 && count )
  2923.          {
  2924.          ex_addresses = 2
  2925.          ex_addr2 = ex_addr1 + count - 1
  2926.          }
  2927.       select_range( DEFAULT_ONE )
  2928.       if( buf_char ) buf_id = buf_char
  2929.          vi_yank( AND_DELETE )
  2930.       }
  2931.  
  2932.    else if( index( "ex", com ) == 1 || index( "edit", com ) == 1 )
  2933.       {
  2934.       if( in_glob )
  2935.          vi_error( "can't glob:" com ex_com )
  2936.       else if( ex_addresses )
  2937.          vi_error( "addresses are illegal for :" com ex_com )
  2938.       else
  2939.          ex_edit()
  2940.       }
  2941.  
  2942.    else if( index( "file", com ) == 1 )
  2943.       {
  2944.       if( in_glob )
  2945.          vi_error( "can't glob:" com ex_com )
  2946.       else if( ex_addresses )
  2947.          vi_error( "addresses are illegal for :" com ex_com )
  2948.       else
  2949.          {
  2950.          ex_file_subst()
  2951.          if(( com = eat_arg()))
  2952.             {
  2953.             buffer_filename = com
  2954.             buffer_name = path_fname(buffer_filename) \
  2955.                          path_ext(buffer_filename)
  2956.             buffer_flags = and( buffer_flags, not( BUFFER_MODIFIED ))
  2957.             display_redraw()
  2958.             }
  2959.          }
  2960.       ex_show_file()
  2961.       }
  2962.  
  2963.    else if( index( "global", com ) == 1 || com == "v" )
  2964.       {
  2965.       if( com != "v" && eat_bang() )
  2966.          com = "v"
  2967.       ex_glob( com )
  2968.       }
  2969.  
  2970.    else if( index( "insert", com ) == 1 )
  2971.       {
  2972.       eat_space()
  2973.       prev_char()
  2974.       insert_string( ex_com )
  2975.       insert_newline()
  2976.       }
  2977.  
  2978.    else if( index( "join", com ) == 1 )
  2979.       {
  2980.       count = eat_count()
  2981.       if (ex_addresses)
  2982.          vi_goto_line( ex_addr1 )   
  2983.       if (ex_addresses == 2)
  2984.          number_register = ex_addr2 - ex_addr1
  2985.       else
  2986.          number_register = count
  2987.       if (number_register < 1)
  2988.          number_register = 1;
  2989.       vi_J()
  2990. #      vi_error( "join" NI )
  2991.       }
  2992.  
  2993.    else if( index( "list", com ) == 1 || index( "print", com ) == 1 )
  2994.       {
  2995.       count = eat_count()
  2996.       if( ex_addresses == 1 && count )
  2997.          {
  2998.          ex_addresses = 2
  2999.          ex_addr2 = ex_addr1 + count - 1
  3000.          }
  3001.       select_range( DEFAULT_ONE )
  3002.       copy_to_scrap()
  3003.       scrap_to_browser()
  3004.       raise_anchor()
  3005.       }
  3006.  
  3007.    else if( index( "move", com ) == 1 )
  3008.       ex_copy( MOVE )
  3009.  
  3010.    else if( index( "mark", com ) == 1 || com == "k")
  3011.       {
  3012.       eat_space()
  3013.       mark = eat_letter()
  3014.       create_mark( vi_mark_id( mark ))
  3015.       }
  3016.  
  3017.    else if( match( com, "^k[a-z]" ))
  3018.       {
  3019.       mark = substr( com, 2 )
  3020.       create_mark( vi_mark_id( mark ))
  3021.       }
  3022.  
  3023.    else if( index( "map", com ) == 1 )
  3024.       {
  3025.       if( in_glob )
  3026.          vi_error( "can't glob:" com ex_com)
  3027.       else if( ex_addresses )
  3028.          vi_error( "addresses are illegal for :" com ex_com )
  3029.       else
  3030.          {
  3031.          variant = eat_bang()
  3032.          macro_name = eat_word()
  3033.          if( !macro_name )
  3034.             {
  3035.             if( !variant )
  3036.                {
  3037.                for( macro_name in command_macro_table)
  3038.                   pbuf( macro_name " " command_macro_table[ macro_name ] )
  3039.                }
  3040.             else 
  3041.                for( macro_name in insert_macro_table )
  3042.                   pbuf( macro_name " " insert_macro_table[ macro_name ] )
  3043.             }
  3044.          else
  3045.             {
  3046.             macro_body = eat_word()
  3047.             if ( !variant )
  3048.                {
  3049.                covered_name = covered_binding( macro_name, variant)
  3050.                covered_command_macro[ macro_name ] =covered_name
  3051.                covered_command_macro_body[ macro_name ] = keymap_binding( covered_name, current_keymap)
  3052.                delete command_macro_table[ covered_command_macro[ macro_name ]]
  3053.                command_macro_table[ macro_name ] = macro_body
  3054.                assign_key( macro_name, "expand_macro " macro_name ) 
  3055.                }
  3056.             else
  3057.                {
  3058.                current_keymap = vi_insert_keymap 
  3059.                covered_name = covered_binding( macro_name, variant )
  3060.                covered_insert_macro[ macro_name ] = covered_name
  3061.                covered_insert_macro_body[ macro_name ] = keymap_binding( covered_name, current_keymap )
  3062.                delete insert_macro_table[ covered_insert_macro[ macro_name ]]
  3063.                insert_macro_table[ macro_name ] = macro_body
  3064.                assign_key( macro_name, "expand_macro " macro_name ) 
  3065.                current_keymap = vi_command_keymap 
  3066.                }
  3067.             }
  3068.          }
  3069.       }
  3070.    else if( index( "next", com ) == 1 )
  3071.       {
  3072.       variant = eat_bang()
  3073.        if( in_glob )
  3074.          vi_error( "can't glob:" com ex_com )
  3075.       else if( ex_addresses )
  3076.          vi_error( "addresses are illegal for :" com ex_com )
  3077.       else
  3078.          {
  3079.          ex_file_subst()
  3080.          if( !variant )
  3081.             ex_autowrite()
  3082.          next_buffer()
  3083.          ex_show_file()
  3084.          }
  3085.       }
  3086.  
  3087.    else if( index( "number", com ) == 1 || com == "#" )
  3088.       vi_error( "number" NI )
  3089.  
  3090.    else if( index( "open", com ) == 1 )
  3091.       vi_error( "open" NI )
  3092.  
  3093.    else if( index( "put", com ) == 1 )
  3094.    {
  3095.       if( in_glob )
  3096.          vi_error( "can't glob:" com ex_com )
  3097.       else if (eat_count())
  3098.          vi_error( "count invalid for: put" )
  3099.       else
  3100.       {
  3101.       if (ex_addresses == 1)
  3102.          vi_goto_line( ex_addr1 )   
  3103.       else if (ex_addresses == 2)
  3104.          vi_goto_line( ex_addr2 )   
  3105.       vi_p()
  3106.       }   
  3107.    }
  3108.  
  3109.    else if( index( "preserve", com ) == 1 )
  3110.    {
  3111.       # can't make :p = prev_buffer, since it is defined as 'print' above (see list)
  3112.       vi_error( "preserve" NI )
  3113.    }
  3114.    
  3115.    else if( index( "quit", com ) == 1 )
  3116.       {
  3117.       if( in_glob )
  3118.          vi_error( "can't glob:" com ex_com )
  3119.       else if( ex_addresses )
  3120.          vi_error( "addresses are illegal for :" com ex_com )
  3121.       else
  3122.          ex_quit()
  3123.       }
  3124.  
  3125.    else if( index( "read", com ) == 1 )
  3126.       {
  3127.       eat_space()
  3128.       if( eat_bang() )
  3129.          ex_shell_read()
  3130.       else
  3131.          ex_read()
  3132.       }
  3133.  
  3134.    else if( index( "recover", com ) == 1 )
  3135.       vi_error( "recover" NI )
  3136.  
  3137.    else if( index( "rewind", com ) == 1 )
  3138.       # need to account for autowrite when this code is implemented
  3139.       # see :next code for method
  3140.       vi_error( "rewind" NI )
  3141.  
  3142.    else if ( index( "substitute", com ) == 1 )
  3143.       {
  3144.       if( ex_com ) 
  3145.          save_command = ex_com
  3146.       ex_sub()
  3147.       }
  3148.  
  3149.    else if ( index( "set", com ) == 1 )
  3150.       ex_set()
  3151.  
  3152.    else if( index( "shell", com ) == 1 )
  3153.       {
  3154.       if( in_glob )
  3155.          vi_error( "can't glob:" com ex_com )
  3156.       else if( ex_addresses )
  3157.          vi_error( "addresses are illegal for :" com ex_com )
  3158.       else
  3159.          system()
  3160.       }
  3161.  
  3162.    else if( index( "source", com ) == 1 )
  3163.       vi_error( "source" NI )
  3164.  
  3165.    else if( index( "t", com ) == 1 )
  3166.       ex_copy( COPY )
  3167.  
  3168.    else if( index( "tag", com ) == 1 )
  3169.       {
  3170.       variant = eat_bang()
  3171.       n = eat_word()
  3172.       if( !variant )
  3173.          ex_autowrite()
  3174.       vi_tags( n )
  3175.       }
  3176.  
  3177.    else if( index( "undo", com ) == 1 )
  3178.       {
  3179. #      vi_error( "undo" NI )
  3180.       undo()
  3181.       }
  3182.  
  3183.    else if( index( "unabbreviate", com ) == 1 )
  3184.       {
  3185.       if( in_glob )
  3186.          vi_error( "can't glob:" com ex_com )
  3187.       else if( ex_addresses )
  3188.          vi_error( "addresses are illegal for :" com ex_com )
  3189.       else
  3190.          {
  3191.          abbreviation = eat_word()
  3192.          if( !abbreviation )
  3193.             vi_error( "null abbreviation not allowed" )
  3194.          else
  3195.             delete templates[ abbreviation ]
  3196.          }
  3197.       }
  3198.  
  3199.    else if( index( "unmap", com ) == 1 )
  3200.       {
  3201.       if( in_glob )
  3202.          vi_error( "can't glob:" com ex_com)
  3203.       else if( ex_addresses )
  3204.          vi_error( "addresses are illegal for :" com ex_com )
  3205.       else
  3206.          {
  3207.          variant = eat_bang()
  3208.          macro_name = eat_word()
  3209.          if( !macro_name )
  3210.             vi_error( "need macro name to unmap" )
  3211.          else
  3212.             {
  3213.             if( !variant )
  3214.                {
  3215.                delete command_macro_table[ macro_name ]
  3216.                covered_macro = covered_command_macro[ macro_name ]
  3217.                if( covered_macro )
  3218.                   {
  3219.                   covered_body = covered_command_macro_body[ macro_name ]
  3220.                   if( covered_body ~ /expand_macro/ )
  3221.                      command_macro_table[ covered_macro ] = covered_body
  3222.                   delete covered_command_macro_body[ macro_name ]
  3223.                   delete covered_command_macro[ macro_name ]
  3224.                   assign_key( covered_macro, covered_body )
  3225.                   }
  3226.                }
  3227.             else
  3228.                {
  3229.                delete insert_macro_table[ macro_name ]
  3230.                covered_macro = covered_insert_macro[ macro_name ]
  3231.                if( covered_macro )
  3232.                   {
  3233.                   covered_body = covered_insert_macro_body[ macro_name ]
  3234.                   if( covered_body ~ /expand_macro/ )
  3235.                      insert_macro_table[ covered_macro ] = covered_body
  3236.                   delete covered_insert_macro_body[ macro_name ]
  3237.                   delete covered_insert_macro[ macro_name ]
  3238.                   push_keymap( vi_insert_keymap )
  3239.                   assign_key( covered_macro, covered_body )
  3240.                   pop_keymap()
  3241.                   }
  3242.                }
  3243.             }
  3244.          }
  3245.  
  3246.       }
  3247.  
  3248.    else if( index( "version", com ) == 1 )
  3249.       print_version()
  3250.  
  3251. #  else if( index( "visual", com ) == 1 )
  3252. #
  3253.    else if( index( "w", com ) == 1 && match( ex_com, "^ !" ))
  3254.       {
  3255.       eat_match( " !" )
  3256.       ex_shell_write()
  3257.       }
  3258.  
  3259.    else if( index( "write", com ) == 1 )
  3260.       ex_write()
  3261.  
  3262.    else if( index( "xit", com ) == 1 || com == "wq" )
  3263.       {
  3264.       if( in_glob )
  3265.          vi_error( "can't glob:" com ex_com )
  3266.       else if( ex_addresses )
  3267.          vi_error( "addresses are illegal for :" com ex_com )
  3268.       else
  3269.          ex_write_and_quit()
  3270.       }
  3271.  
  3272.    else if( index( "yank", com ) == 1 )
  3273.       {
  3274.       eat_space()
  3275.       buf_char = eat_match( "[a-zA-Z]" )
  3276.       count = eat_count()
  3277.       if( ex_addresses == 1 && count )
  3278.          {
  3279.          ex_addresses = 2
  3280.          ex_addr2 = ex_addr1 + count - 1
  3281.          }
  3282.       #message("buf_char = %s", buf_char);
  3283.       select_range( DEFAULT_ONE )
  3284.       if( buf_char )
  3285.          buf_id = buf_char
  3286.       vi_yank()
  3287.       }
  3288.  
  3289.    else if( com == "z" )
  3290.    {
  3291.       if( in_glob )
  3292.          vi_error( "can't glob:" com ex_com )
  3293.       else if (eat_count())
  3294.          vi_error( "count invalid for: z" )
  3295.       else
  3296.       {
  3297.       if (ex_addresses == 1)
  3298.          vi_goto_line( ex_addr1 )   
  3299.       else if (ex_addresses == 2)
  3300.          vi_goto_line( ex_addr2 )   
  3301.          
  3302.       if (ex_com == ".")
  3303.          scroll_window_middle()
  3304.       else if (ex_com == "-")
  3305.          scroll_window_bottom()
  3306.       else if (ex_com == "")
  3307.          scroll_window_top()
  3308.       else
  3309.          vi_error( "Extra characters at end of z command")
  3310.       }
  3311.    }
  3312.  
  3313.    else if( index( com, "<" ) == 1 || index( com, ">" ) == 1 )
  3314.    {
  3315.       count = eat_count()
  3316.       if (count && ex_addresses == 2)
  3317.          vi_goto_line(ex_addr2)
  3318.       else
  3319.          vi_goto_line(ex_addr1)
  3320.       
  3321.       if (!count)
  3322.          count = ex_addr2 - ex_addr1 + 1
  3323.          
  3324.       message("count = %d", count)
  3325.       times = length(com)
  3326.       while (times-- > 0)
  3327.          if ( index( com, "<") )
  3328.             outdent_lines(count) 
  3329.          else
  3330.             indent_lines(count)  
  3331.    }
  3332.    else if( com == "!" )
  3333.       {
  3334.       if( in_glob )
  3335.          vi_error( "can't glob:" com ex_com )
  3336.       else if( ex_addresses )
  3337.          vi_error( "addresses are illegal for :" com ex_com )
  3338.       else
  3339.          {
  3340.          ex_file_subst()
  3341.          if( !option_disable[ "warn" ] && buffers_modified )
  3342.             vi_error( "warning: buffers have been modified" )
  3343.          ex_autowrite()
  3344.          if( eat_bang())
  3345.             com = current_history_item( "SYSTEM" )
  3346. #            com = current_history_item( "!" )
  3347.          else
  3348. #            com = add_prompt_history( "!", eat_arg())
  3349.             com = eat_arg()
  3350.          system_key( com )
  3351.          }
  3352.       }
  3353.  
  3354.    else if( com == "=" )
  3355.       {
  3356.       n = ( ex_addresses > 1 ) ? ex_addr2 : ex_addr1
  3357.       if( in_glob )
  3358.          pbuf( n )
  3359.       else
  3360.          message( n )
  3361.       }
  3362.  
  3363.    else if( com == "&" )
  3364.       {
  3365.       if( save_command )
  3366.          {
  3367.          ex_com = save_command
  3368.          ex_sub()
  3369.          }
  3370.       else 
  3371.          vi_error( "no previous :s command to repeat" )
  3372.       }
  3373.  
  3374.    else
  3375.       vi_error( "unrecognized command" )
  3376. }
  3377.  
  3378. local function ex_show_state( option )
  3379. {
  3380.    #was message
  3381.    message( option_disable[ option ] option (option_value[ option ]? "=" option_value[ option ] : ""))
  3382. }
  3383.  
  3384.  
  3385. local function ex_set_state( option, option_switch, value )
  3386. {
  3387.    #message("ex_set_state");
  3388.    option_disable[ option ] = option_switch
  3389.    option_value[ option ] = value
  3390. }
  3391.  
  3392. function ex_show_match()
  3393. {
  3394.    local i, top_line, found_match, the_line, the_column
  3395.    local terminator = ""
  3396.  
  3397.    #message("ex_show_match");
  3398.    insert_key()
  3399.    if (chr(current_key) != "}")
  3400.       terminator = "{"
  3401.    the_line = current_line
  3402.    the_column = current_column
  3403.    left(1)
  3404.    top_line = current_line - distance_to_window_top()
  3405.    found_match = goto_matching(terminator)
  3406.    if( current_line >= top_line && found_match )
  3407.    {
  3408.       begin_selection(INCLUSIVE_SELECTION)
  3409.       end_selection()
  3410.       display_update()
  3411.       for(i=1; i<10000; i++) {}  # ugly delay
  3412.       remove_selection()
  3413.       goto_pos( the_line, the_column )
  3414.       display_update()
  3415.    }
  3416.    else 
  3417.       goto_pos( the_line, the_column )
  3418. }      
  3419.  
  3420.  
  3421. local function ex_copy( mode ) {
  3422.    local destination
  3423.  
  3424.    #message("ex_copy");
  3425.    select_range( DEFAULT_ONE )
  3426.    copy_to_scrap()
  3427.    raise_anchor()
  3428.    destination = ex_address()
  3429.    if( destination )
  3430.       destination++
  3431.    goto_line( destination )
  3432.    insert_scrap()
  3433.    if( mode )
  3434.       {
  3435.       select_range( DEFAULT_ONE )
  3436.       delete_to_scrap()
  3437.       }
  3438.  
  3439. }
  3440.  
  3441. # set the state of all the settable options
  3442. local function ex_init_state() 
  3443. { 
  3444.    #message("ex_init_state");
  3445.  
  3446.    ex_set_state( "autoindent", "no", "" )
  3447.    ex_set_state( "autoprint", "", "" )
  3448.    ex_set_state( "autowrite", "no", "" )
  3449.    ex_set_state( "beautify", "no", "" )
  3450.    ex_set_state( "directory", "", "/tmp" )
  3451.    ex_set_state( "edcompatible", "no", "" )
  3452.    ex_set_state( "errorbells", "", "" )
  3453.    ex_set_state( "flash", "no", "" )
  3454.    ex_set_state( "hardtabs", "", "8" )
  3455.    ex_set_state( "ignorecase", "no", "" )
  3456.    ex_set_state( "lisp", "no", "" )
  3457.    ex_set_state( "list", "no", "" )
  3458.    ex_set_state( "magic", "", "" )
  3459.    ex_set_state( "mesg", "", "" )
  3460.    ex_set_state( "modelines", "no", "" )
  3461.    ex_set_state( "novice", "no", "" )
  3462.    ex_set_state( "number", "no", "" )
  3463.    ex_set_state( "optimize", "no", "" )
  3464.    ex_set_state( "paragraphs", "", "IPLPPPQPP LIbp" )
  3465.    ex_set_state( "prompt", "", "" )
  3466.    ex_set_state( "readonly", "no", "" )
  3467.    ex_set_state( "redraw", "", "" )
  3468.    ex_set_state( "remap", "", "" )
  3469.    ex_set_state( "report", "", "5" )
  3470.    ex_set_state( "scroll", "", "11" )
  3471.    ex_set_state( "sections", "", "NHSHH HU" )
  3472.    ex_set_state( "shell", "", "/bin/sh" )
  3473.    ex_set_state( "shiftwidth", "", "8h" )
  3474.    ex_set_state( "showmatch", "no", "" )
  3475.    ex_set_state( "showmode", "no", "" )
  3476.    ex_set_state( "slowopen", "no", "" )
  3477.    ex_set_state( "tabstop", "", "8" )
  3478.    ex_set_state( "taglength", "", "0" )
  3479.    ex_set_state( "tags", "", "tags" )
  3480. #   vi_tags_init( "tags" )
  3481.    vi_tags_init( tags_path )
  3482.    ex_set_state( "term", "", "vt100" )   
  3483.    ex_set_state( "terse", "no", "" )
  3484.    ex_set_state( "timeout", "", "" )
  3485.    ex_set_state( "ttytype", "", "vt100" )
  3486.    ex_set_state( "warn", "", "" )
  3487.    ex_set_state( "window", "", "8" )
  3488.    ex_set_state( "wrapscan", "", "" )
  3489.    ex_set_state( "wrapmargin", "", "0" )
  3490.    ex_set_state( "writeany", "no", "" )
  3491. }
  3492.  
  3493. local function ex_set() {
  3494.  
  3495.    local option, option_switch, query
  3496.    option_switch = eat_no()
  3497.    option = eat_option()
  3498.    query = eat_question_mark()
  3499.    #message("ex_set: option = %s; op_switch = %s; query = %s", option, option_switch, query);
  3500.  
  3501.    if( option == "all" || option == "")
  3502.       {
  3503.       if (auto_indent_mode)
  3504.          ex_set_state( "autoindent", "", "" )
  3505.       else
  3506.          ex_set_state( "autoindent", "no", "" )
  3507.       for ( option in option_disable )
  3508.          pbuf( option_disable[ option ] option (option_value[ option ]? "=" option_value[ option ] : "" ))
  3509.       }
  3510.  
  3511.    else if( option == "ai" || option == "autoindent" )
  3512.       {
  3513.       if( query )  
  3514.          ex_show_state( "autoindent" )
  3515.       else
  3516.          {
  3517.          default_auto_indent_mode = auto_indent_mode =  !option_switch 
  3518.          ex_set_state( "autoindent", option_switch, "" )
  3519.          }
  3520.       }
  3521.  
  3522.    else if( option == "ap" || option == "autoprint" )
  3523.       {
  3524.       if( query )  
  3525.          ex_show_state( "autoprint" )
  3526.       else
  3527.          ex_set_state( "autoprint", option_switch, "" )
  3528.       }
  3529.  
  3530.    else if( option == "aw" || option == "autowrite" )
  3531.       {
  3532.       if( query )  
  3533.          ex_show_state( "autowrite" )
  3534.       else
  3535.          ex_set_state( "autowrite", option_switch, "" )  
  3536.       }
  3537.  
  3538.    else if( option == "bf" || option == "beautify" )
  3539.       {
  3540.       if( query )  
  3541.          ex_show_state( "beautify" )
  3542.       else
  3543.          ex_set_state( "beautify", option_switch, "" )   
  3544.       }
  3545.  
  3546.    else if( option == "dir" || option == "directory" )
  3547.       {
  3548.       if( option_switch )
  3549.          vi_error( option " cannot be disabled" )
  3550.       else
  3551.          if( query )  
  3552.             ex_show_state( "directory" )
  3553.          else
  3554.             if( eat_equal())
  3555.                ex_set_state( "directory", "", ex_com )   
  3556.             else
  3557.                vi_error( "syntax" ) 
  3558.       }
  3559.  
  3560.    else if( option == "ed" || option == "edcompatible" )
  3561.       {
  3562.       if( query )  
  3563.          ex_show_state( "edcompatible" )
  3564.       else
  3565.          ex_set_state( "edcompatible", option_switch, "" ) 
  3566.       }
  3567.  
  3568.    else if( option == "eb" || option == "errorbells" )
  3569.       {
  3570.       if( query )  
  3571.          ex_show_state( "errorbells" )
  3572.       else
  3573.          ex_set_state( "errorbells", option_switch, "" )
  3574.       }
  3575.  
  3576.    else if( option == "fl" || option == "flash" )
  3577.       {
  3578.       if( query )  
  3579.          ex_show_state( "flash" )
  3580.       else
  3581.          ex_set_state( "flash", option_switch, "" )
  3582.       }
  3583.  
  3584.    else if( option == "ht" || option == "hardtabs" )
  3585.       {
  3586.       if( option_switch )
  3587.          vi_error( option " cannot be disabled" )
  3588.       else
  3589.          if( query )  
  3590.             ex_show_state( "hardtabs" )
  3591.          else
  3592.             if( eat_equal())
  3593.                ex_set_state( "hardtabs", "", ex_com )
  3594.       }
  3595.  
  3596.    else if( option == "ic" || option == "ignorecase" )
  3597.       {
  3598.       if( query )  
  3599.          ex_show_state( "ignorecase" )
  3600.       else
  3601.          {
  3602.          ex_set_state( "ignorecase", option_switch, "" )
  3603.          if( option_switch )
  3604.             search_flags = vi_search_flags = or( search_flags, SEARCH_CASE )
  3605.             #search_flags = vi_search_flags = or( vi_search_flags, SEARCH_CASE )
  3606.          else
  3607.             search_flags = vi_search_flags = and( search_flags, not(SEARCH_CASE) )
  3608.             #search_flags = vi_search_flags = and( vi_search_flags, not(SEARCH_CASE) )
  3609.          }
  3610.       }
  3611.  
  3612.    else if( option == "lisp" )
  3613.       {
  3614.       if( query )  
  3615.          ex_show_state( "lisp" )
  3616.       else
  3617.          ex_set_state( "lisp", option_switch, "" )
  3618.       }
  3619.  
  3620.    else if( option == "list" )
  3621.       {
  3622.       if( query )  
  3623.          ex_show_state( "list" )
  3624.       else
  3625.          ex_set_state( "list", option_switch, "" )
  3626.       }
  3627.  
  3628.    else if( option == "magic" )
  3629.       {
  3630.       if( query )  
  3631.          ex_show_state( "magic" )
  3632.       else
  3633.          ex_set_state( "magic", option_switch, "" )
  3634.       }
  3635.  
  3636.    else if( option == "mesg" )
  3637.       {
  3638.       if( query )  
  3639.          ex_show_state( "mesg" )
  3640.       else
  3641.          ex_set_state( "mesg", option_switch, "" )
  3642.       }
  3643.  
  3644.    else if( option == "modelines" )
  3645.       {
  3646.       if( query )  
  3647.          ex_show_state("modelines" )
  3648.       else
  3649.          ex_set_state( "modelines", option_switch, "" )
  3650.       }
  3651.  
  3652.    else if( option == "nu" || option == "number" )
  3653.       {
  3654.       if( query )  
  3655.          ex_show_state( "number" )
  3656.       else
  3657.          {
  3658.          if( option_switch )
  3659.             linenumber_format = ""
  3660.          else
  3661.             linenumber_format = "%5d"
  3662.          ex_set_state( "number", option_switch, "" )     
  3663.          }
  3664.       }
  3665.  
  3666.    else if( option == "opt" || option == "optimize" )
  3667.       {
  3668.       if( query )  
  3669.          ex_show_state( "optimize" )
  3670.       else
  3671.          ex_set_state( "optimize", option_switch, "" )
  3672.       }
  3673.  
  3674.    else if( option == "para" || option == "paragraphs" )
  3675.       {
  3676.       if( option_switch )
  3677.          vi_error( option " cannot be disabled." )
  3678.       else
  3679.          if( query )  
  3680.             ex_show_state( "paragraphs" )
  3681.          else
  3682.             if( eat_equal())
  3683.                ex_set_state( "paragraphs", "", ex_com )
  3684.             else
  3685.                vi_error( "syntax" ) 
  3686.       }
  3687.  
  3688.    else if( option == "prompt" )
  3689.       {
  3690.       if( query )  
  3691.          ex_show_state( "prompt" )
  3692.       else
  3693.          ex_set_state( "prompt", option_switch, "" )
  3694.       }
  3695.  
  3696.    else if( option == "ro" || option == "readonly" )
  3697.       {
  3698.       if( query )  
  3699.          ex_show_state( "readonly" )
  3700.       else
  3701.          ex_set_state( "readonly", option_switch, "" )
  3702.       }
  3703.  
  3704.    else if( option == "redraw" )
  3705.       {
  3706.       }
  3707.  
  3708.    else if( option == "remap" )
  3709.       {
  3710.       if( query )  
  3711.          ex_show_state( "remap" )
  3712.       else
  3713.          ex_set_state( "remap", option_switch, "" )
  3714.       }
  3715.  
  3716.    else if( option == "report" )
  3717.       {
  3718.       }
  3719.  
  3720.    else if( option == "scroll" )
  3721.       {
  3722.       }
  3723.  
  3724.    else if( option == "sh" || option == "shell" )
  3725.       {
  3726.       if( option_switch )
  3727.          vi_error( option " cannot be disabled." )
  3728.       else
  3729.          if( query )  
  3730.             ex_show_state( "shell" )
  3731.          else
  3732.             if( eat_equal() )
  3733.                ex_set_state( "shell", "", ex_com )
  3734.             else
  3735.                vi_error( "syntax" ) 
  3736.       }
  3737.  
  3738.    else if( option == "sw" || option == "shiftwidth" )
  3739.       {
  3740.       }
  3741.  
  3742.    else if( option == "sm" || option == "showmatch" )
  3743.       {
  3744.       if( query )  
  3745.          ex_show_state( "showmatch" )
  3746.       else
  3747.          ex_set_state( "showmatch", option_switch, "" )
  3748.  
  3749.       push_keymap( vi_insert_keymap )
  3750.       if( option_switch )
  3751.          {
  3752.          assign_key( ")", "insert_key" )
  3753.          assign_key( "]", "insert_key" )
  3754.          assign_key( "}", "insert_key" )
  3755.          }
  3756.       else
  3757.          {
  3758.          assign_key( ")", "ex_show_match" )
  3759.          assign_key( "]", "ex_show_match" )
  3760.          assign_key( "}", "ex_show_match" )
  3761.          }
  3762.       pop_keymap()
  3763.    }
  3764.  
  3765.    else if( option == "showmode" )
  3766.       {
  3767.       }
  3768.  
  3769.    else if( option == "slow" || option == "slowopen" )
  3770.       {
  3771.       }
  3772.  
  3773.    else if( option == "ts" || option == "tabstop" )
  3774.       {
  3775.       }
  3776.  
  3777.    else if( option == "tl" || option == "taglength" )
  3778.       {
  3779.       }
  3780.  
  3781.    else if( option == "tags" )
  3782.       {
  3783.       if( query )  
  3784.          ex_show_state( "tags" )
  3785.       else
  3786.          if( eat_equal())
  3787.             {
  3788.             ex_set_state( "tags", "", ex_com )
  3789.             vi_tags_init( ex_com )
  3790.             }
  3791.       }
  3792.  
  3793.    else if( option == "term" )
  3794.       {
  3795.       }
  3796.  
  3797.    else if( option == "terse" )
  3798.       {
  3799.       }
  3800.  
  3801.    else if( option == "timeout" )
  3802.       {
  3803.       }
  3804.  
  3805.    else if( option == "ttytype" )
  3806.       {
  3807.       }
  3808.  
  3809.    else if( option == "warn" )
  3810.       {
  3811.       if( query )  
  3812.          ex_show_state( "warn" )
  3813.       else
  3814.          ex_set_state( "warn", option_switch, "" )
  3815.       }
  3816.  
  3817.    else if( option == "window" )
  3818.       {
  3819.       }
  3820.  
  3821.    else if( option == "ws" || option == "wrapscan" )
  3822.       {
  3823.       if( query )  
  3824.          ex_show_state( "wrapscan" )
  3825.       else
  3826.          {
  3827.          ex_set_state( "wrapscan", option_switch, "" )
  3828.          if( option_switch )
  3829.             search_flags = vi_search_flags = and( search_flags, not( SEARCH_WRAPS ))
  3830.             #search_flags = vi_search_flags = and( vi_search_flags, not( SEARCH_WRAPS ))
  3831.          else
  3832.             search_flags = vi_search_flags = or( search_flags, SEARCH_WRAPS )
  3833.             #search_flags = vi_search_flags = or( vi_search_flags, SEARCH_WRAPS )
  3834.          }
  3835.       }
  3836.  
  3837.    else if( option == "wm" || option == "wrapmargin" )
  3838.       {
  3839.       }
  3840.  
  3841.    else if( option == "wa" || option == "writeany" )
  3842.       {
  3843.       }
  3844.  
  3845.    else 
  3846.       vi_error( "unknown option" )
  3847. }
  3848.  
  3849. # finds and substitutes file names for % and #
  3850. local function ex_file_subst()
  3851. {
  3852.    local remainder, subs = 0
  3853.    local start_buf = current_buffer
  3854.  
  3855.    #message("ex_file_subst");
  3856.    remainder = index(original_com, ex_com )
  3857.    subs = gsub( /%/, buffer_filename, ex_com )
  3858.    if (index(ex_com, /#/))
  3859.    {
  3860.       if (!last_buffer)
  3861.       {
  3862.          last_buffer = current_buffer
  3863.          prev_buffer("", 0, 1)
  3864.       }
  3865.       else
  3866.       {
  3867.          current_buffer = last_buffer
  3868.          last_buffer = start_buf
  3869.       }
  3870.       subs = subs + gsub( /#/, buffer_filename, ex_com )
  3871.    }
  3872.    
  3873.    if( subs ) 
  3874.       message( ":" substr(original_com, 1, remainder - 1 ) ex_com )
  3875.    
  3876.    current_buffer = start_buf
  3877. }
  3878.  
  3879. function vi_ZZ()
  3880. {
  3881.    local ch = "["
  3882.    
  3883.    if (!playing_again)
  3884.       ch = vi_getc()
  3885.  
  3886.    if (ch != "Z")
  3887.       vi_error()
  3888.    else
  3889.    {
  3890.       ex_addresses = 0
  3891.       ex_com = ""
  3892.       ex_write_and_quit()
  3893.    }
  3894. }
  3895.  
  3896. function ex_write_and_quit() {
  3897.    ex_write()
  3898.    ex_quit()
  3899. }
  3900.  
  3901. local function ex_quit( force ){
  3902.    force = force || eat_bang()
  3903.  
  3904.    if( !force && buffers_modified )
  3905.       warning( "File has been modified;\n\"q!\" quits and discards changes" )
  3906.    else
  3907.       done( force )
  3908. }
  3909.  
  3910. function vi_next_buffer(next_flag)
  3911. {
  3912.    if (argcount() < 1)
  3913.       next_flag = 1
  3914.       
  3915.    if (next_flag)
  3916.       next_buffer_mask()
  3917.    else
  3918.       prev_buffer_mask()
  3919.       
  3920.    ex_show_file()
  3921. }
  3922.  
  3923.  
  3924. function ex_subs_repeat() {
  3925.    #message("ex_subs_repeate");
  3926.    if( save_command )
  3927.       {
  3928.       ex_com = save_command
  3929.       ex_sub()
  3930.       }
  3931.    else 
  3932.       vi_error( "no previous :s command to repeat" )
  3933. }
  3934.  
  3935. local function append_buffer( filename ) 
  3936. {
  3937.    local ret_val = -1   # failure
  3938.    local fileID = fopen( filename, READWRITE )
  3939.  
  3940.    if ( fileID ) 
  3941.       {
  3942.       fseek( fileID, 0, END_FILE )
  3943.       fwrite( fileID, create_mark( BOB, 1, 1 ), buffer_size )
  3944.       fclose( fileID )
  3945.       ret_val = TRUE
  3946.       } 
  3947.    else 
  3948.       vi_error( "cannot open file " filename )
  3949.  
  3950.    return ret_val
  3951. }
  3952.  
  3953. local function append_marked_block( filename ) {
  3954.    local line_1, line_2, length_line_1, length_line_2, length
  3955.    local mark_1, mark_2
  3956.    local fileID = fopen( filename, READWRITE )
  3957.  
  3958.    #message("append marked block");
  3959.    if( fileID )
  3960.       {
  3961.       fseek( fileID, 0, END_FILE )
  3962.       line_1 = current_line
  3963.       length_line_1= current_line_length
  3964.       swap_selection_marks()
  3965.       line_2 = current_line
  3966.       length_line_2= current_line_length
  3967.       swap_selection_marks()
  3968.       mark_1 = create_mark( B1, line_1, 1 )
  3969.       mark_2 = create_mark( B2, line_2, 1 )
  3970.       length = distance_between_marks( mark_1, mark_2 )
  3971.       if( line_1 > line_2 )
  3972.          {
  3973.          length_line_2 = length_line_1
  3974.          mark_1 = mark_2
  3975.          }
  3976.       length = length + length_line_2
  3977.       fwrite( fileID, mark_1, length )       
  3978.       fclose( fileID )
  3979.       }
  3980.    else 
  3981.       vi_error( "cannot open file " filename )
  3982. }
  3983.  
  3984. local function ex_shell_read() 
  3985. {
  3986.    local input_redirection
  3987.  
  3988.    ex_file_subst()
  3989.    if ( ex_addresses > 1 )
  3990.       vi_error( "only 0 or 1 addresses allowed for :r!" )
  3991.  
  3992.    if ( ex_addresses )
  3993.       current_line = ex_addr1 + 1
  3994.    else
  3995.       current_line ++
  3996.  
  3997.    goto_bol()
  3998.    if ( ex_com ~ "\\<" )
  3999.       input_redirection = ""
  4000.    else
  4001.       input_redirection = "<temp_inp"
  4002.  
  4003.    system( ex_com input_redirection " >&temp_out" )
  4004.    read_file( "temp_out" )
  4005. }
  4006.  
  4007. local function ex_shell_write() 
  4008. {
  4009.    local output_redirection
  4010.  
  4011.    ex_file_subst()
  4012.    select_range( DEFAULT_ONE )
  4013.    write_marked_block( "temp_inp" )
  4014.  
  4015.    if ( ex_com ~ "\\>" ) 
  4016.       {
  4017.       output_redirection = ""
  4018.       sub( "\\>", " >\\&", ex_com )
  4019.       } 
  4020.    else 
  4021.       output_redirection = " >&temp_out"
  4022.  
  4023.    system( ex_com " <temp_inp" output_redirection )
  4024.  
  4025.    if ( output_redirection && filesize( "temp_out" ) > 0 )
  4026.       file_to_browser( "temp_out" )
  4027. }
  4028.  
  4029. function vi_saveas( fn )
  4030. {
  4031.    if ( !fn )
  4032.       fn = prompt( ":w ", "" )
  4033.  
  4034.    if (fn)
  4035.       ex_write(fn);
  4036. }
  4037.  
  4038. function vi_save()
  4039. {
  4040.    if ( is_scratch_file(current_buffer) )
  4041.       vi_saveas()
  4042.    else
  4043.       ex_write()
  4044. }
  4045.  
  4046. local function ex_write( name )
  4047. {
  4048.  
  4049.    local force = eat_bang()
  4050.    local append, name_supplied, file_exists, name_changed
  4051.    local success = -1
  4052.  
  4053.    #message("ex_write");
  4054.    ex_file_subst()
  4055.    append = eat_append()
  4056.  
  4057.    # check for filename passed in as parameter
  4058.    #
  4059.    if ( !name ) 
  4060.       {
  4061.       name = eat_arg()
  4062.       name_supplied = name
  4063.       }
  4064.  
  4065.    if ( !name ) 
  4066.       name = buffer_filename
  4067.  
  4068.    file_exists    = filesize( name ) >= 0
  4069.    name_changed   = (buffer_filename != buffer_original_filename)
  4070.  
  4071.    if ( file_exists && ! force && ( name_supplied || name_changed ) && ! append)
  4072.       vi_error( "attempt to overwrite existing file; use \"w!\" to overwrite" )  
  4073.  
  4074.    else if (   force                                        || 
  4075.                !file_exists                                 || 
  4076.                (!name_changed && buffer_is_modified())      || 
  4077.                (name_changed && !file_exists)               || 
  4078.                append ) 
  4079.       {
  4080.  
  4081.       if ( read_only() )
  4082.          vi_error( "file " name " is read-only" )
  4083.       else if ( !option_disable[ "readonly" ] && ! force )
  4084.          vi_error( "readonly option enabled; use \"w!\" to write" )
  4085.  
  4086.          else if ( selection_type() )
  4087.             {
  4088.             if ( append )
  4089.                append_marked_block( name )
  4090.             else
  4091.                write_marked_block( name )
  4092.             } 
  4093.          else if ( ex_addresses )
  4094.             {
  4095.             select_range()
  4096.             if ( append )
  4097.                append_marked_block( name )
  4098.             else
  4099.                write_marked_block( name )
  4100.  
  4101.             raise_anchor()
  4102.             } 
  4103.          else 
  4104.             {
  4105.             if ( append )
  4106.                success = append_buffer( name )
  4107.             else
  4108.             {
  4109.                if (buffer_filename == name)
  4110.                   backup_file( buffer_filename )
  4111.                success = write_buffer( name ) 
  4112.             }
  4113.  
  4114.             # reset BUFFER_MODIFIED only on a full write
  4115.             if ( success != -1 )
  4116.                buffer_flags = and( buffer_flags, not( BUFFER_MODIFIED ))
  4117.             }
  4118.  
  4119.       ex_show_file()
  4120.       }
  4121. }
  4122.  
  4123. local function ex_autowrite() 
  4124. {
  4125.    if ( !option_disable[ "autowrite" ] && buffer_is_modified()) 
  4126.       {
  4127.  
  4128.       if ( read_only() )
  4129.          vi_error( "file " buffer_filename " is read_only; unable to autowrite" )
  4130.       else if ( option_disable[ "readonly" ] )
  4131.          vi_error( "readonly option enabled; unable to autowrite" )
  4132.       else 
  4133.          {
  4134.          write_buffer()
  4135.          buffer_flags = and( buffer_flags, not( BUFFER_MODIFIED ))
  4136.          }
  4137.       }
  4138. }
  4139.  
  4140. # this catches <Ctl>^ keystrokes
  4141. function last_buffer_key() 
  4142. { 
  4143.    ex_autowrite()
  4144.    prev_buffer()
  4145. }
  4146.  
  4147. # tests if current file is read-only
  4148. local function read_only() 
  4149. {  
  4150.    local is_ro = FALSE
  4151.    local mode  = filemode( buffer_filename )
  4152.  
  4153.    # check for non-error ret mode
  4154.    if ( mode >= 0 )
  4155.       is_ro = and( mode, _READ_ONLY)
  4156.  
  4157.    return is_ro
  4158. }
  4159.  
  4160. function vi_read( fn )
  4161. {
  4162.    if ( !fn )
  4163.       fn = prompt_history( "EDITFILE", ":r ", "" )
  4164.  
  4165.    if (fn)
  4166.       ex_read(fn);
  4167. }
  4168.  
  4169. local function ex_read( name )
  4170. {
  4171.    ex_file_subst()
  4172.  
  4173.    if ( !name )
  4174.       name = eat_arg()
  4175.  
  4176.    if ( !name ) 
  4177.       name = vi_read_name
  4178.  
  4179.    if ( !name ) 
  4180.       vi_error( "must supply file name to read" )
  4181.  
  4182.    vi_read_name = name
  4183.  
  4184.    if ( filesize( name ) < 0 )
  4185.       vi_error( name ": file does not exist" )
  4186.  
  4187.    if ( ex_addresses > 1 )
  4188.       vi_error( "only 0 or 1 addresses allowed for :r" )
  4189.  
  4190.    if ( ex_addresses )
  4191.       current_line = ex_addr1 + 1   # may be 0
  4192.    else
  4193.       current_line++
  4194.  
  4195.    goto_bol()
  4196.  
  4197.    read_file( name )
  4198.    ex_show_file()
  4199. }
  4200.  
  4201. function vi_open( fn )
  4202. {
  4203.    if ( !fn )
  4204.       fn = prompt_history( "EDITFILE", ":e ", "" )
  4205.  
  4206.    if (fn)
  4207.       ex_edit(fn);
  4208. }
  4209.  
  4210. local function ex_edit( fn )
  4211. {
  4212.    local force = eat_bang()
  4213.    local poundLine
  4214.    local name
  4215.  
  4216.    ex_file_subst()
  4217.  
  4218.    # read space or semicolon delimited argument
  4219.    eat_space()
  4220.  
  4221.    if ( fn )
  4222.       name = fn
  4223.    else
  4224.       name = eat_match( "[^; ]+" )
  4225.  
  4226.    if ( substr(name,1,1) == "+" )
  4227.       {
  4228.       # read line number to start at in specified file
  4229.       poundLine = substr( name, 2 ) + 0
  4230.       name = eat_arg()
  4231.       }
  4232.  
  4233.    if( !name && !force )
  4234.       vi_error( "file name required; use \"e!\" to restart current file" )
  4235.    else if ( name == buffer_name )
  4236.       vi_error( "file name same as current file; use \"e!\" to restart current file" )
  4237.    else 
  4238.       {
  4239.       if ( !name )
  4240.          {
  4241.          name = buffer_filename
  4242.  
  4243.          if ( !name )
  4244.             return
  4245.          }
  4246.  
  4247.       if ( force ) #&& MAGIC )
  4248.          {
  4249.          buffer_flags = and( buffer_flags, not( BUFFER_MODIFIED ) )
  4250.          delete_buffer()
  4251.          }
  4252.  
  4253. #      edit_file( name )
  4254.       create_buf_and_win(name)
  4255.  
  4256.       ex_show_file()
  4257.  
  4258.       if( poundLine )
  4259.          goto_line( poundLine )
  4260.       }
  4261. }
  4262.  
  4263. local function vi_filter()
  4264. {
  4265.    local com = prompt_history( "!", "!", "", 1 )
  4266.  
  4267.    if ( com )
  4268.       filter( com )
  4269. }
  4270.  
  4271. local function vi_tags_init( tags )
  4272. {
  4273.    sub( " ", ";", tags )
  4274.    tags_path = tags
  4275. }
  4276.  
  4277. local function vi_tags( n ){
  4278.    vi_tags_push()
  4279.    tags( n )   
  4280. }
  4281.  
  4282. function vi_tags_auto(){
  4283.    vi_tags_push()
  4284.    tags_auto()
  4285. }
  4286.  
  4287. local vi_tags_index = 0
  4288. local vi_tags_stack
  4289.  
  4290. function vi_tags_push(){
  4291.    vi_tags_stack[ vi_tags_index++ ] = buffer_filename " "   \
  4292.             buffer_offset        " "   \
  4293.             distance_to_window_top()  
  4294. }
  4295.  
  4296. function vi_tags_pop(){
  4297.    local loc
  4298.  
  4299.    if( vi_tags_index <= 0 )
  4300.       warning( "vi tags stack empty" )
  4301.  
  4302.    split( vi_tags_stack[ --vi_tags_index ], loc, " " )
  4303.    delete vi_tags_stack[ vi_tags_index ]
  4304.    edit_file( loc[ 1 ])
  4305.    goto_buffer_offset( loc[ 2 ])
  4306.  
  4307.    # restore window orientation, if possible
  4308.  
  4309.    scroll_window_top( loc[ 3 ])
  4310. }
  4311.  
  4312. function ex_show_file( annotation )
  4313. {
  4314.    local pct = 100
  4315.  
  4316.    # # faster, but less accurate:
  4317.    # if( buffer_size > 0 )
  4318.    #  pct = 100 * buffer_offset / buffer_size
  4319.    if( buffer_last_line > 0 )
  4320.       pct = 100 * current_line / buffer_last_line
  4321.  
  4322.    if( !annotation && and( buffer_flags, BUFFER_MODIFIED ))
  4323.       annotation = "[modified]"
  4324.  
  4325.    message( "\"%s\" %sline %d of %d -- %d%% --",   \
  4326.       buffer_filename,           \
  4327.       ( annotation ? annotation " " : "" ),     \
  4328.       current_line,              \
  4329.       buffer_last_line,          \
  4330.       pct )
  4331. }
  4332.  
  4333. local function ex_sub()
  4334. {
  4335.    local quote, old, new, gc, start, stop, count, n = 0, sflags
  4336.    local pflag, cflag, gflag
  4337.    local line_count
  4338.  
  4339.    #message("ex_sub");
  4340.    quote = eat_punctuation()
  4341.    if( !quote ) {
  4342.       if( prev_old && prev_new ) {
  4343.          old = prev_old
  4344.          new = prev_new
  4345.       } else 
  4346.          vi_error( "no previous substitute pattern to reuse" )
  4347.    } else {
  4348.       old = search_hist( eat_regex( quote ))
  4349.       new = eat_regex( quote )
  4350.       prev_old = old
  4351.       prev_new = new
  4352.    }
  4353.  
  4354.    gc = eat_match( "[gc]+" ) # ":s/foo" is the same as ":s/foo//"
  4355.  
  4356.    sflags = SEARCH_FORWARD          \
  4357.       + SEARCH_MAXIMAL_MATCH        \
  4358.       + SEARCH_BLOCK             \
  4359.       + SEARCH_REGEX          \
  4360.       + and( search_flags,       \
  4361.          or( SEARCH_CASE,    \
  4362.              SEARCH_WRAPS ))
  4363.       #+ and( vi_search_flags,       \
  4364.       #   or( SEARCH_CASE,    \
  4365.       #       SEARCH_WRAPS ))
  4366.  
  4367.    line_count = eat_count()
  4368.    if( ex_addresses == 1 && line_count )
  4369.       {
  4370.       ex_addresses = 2
  4371.       ex_addr2 = ex_addr1 + line_count 
  4372.       }
  4373.    else 
  4374.       ex_addr2 ++
  4375.  
  4376.    pflag = eat_match( "p" )
  4377.    cflag = gc ~ /c/
  4378.    gflag = gc ~ /g/
  4379.  
  4380.    if( match( "", old ) && RLENGTH == 0 )
  4381.       vi_error( "NULL search pattern length." );
  4382.  
  4383.    if( ! gflag && ! cflag ){
  4384.       search_count = 0x7FFFFFFF;
  4385.       if( ! gflag ){
  4386.          sflags = sflags + SEARCH_ONCE_PER_LINE
  4387.       }
  4388.       select_range( DEFAULT_ONE )
  4389.       n = replace( old, new, sflags )
  4390.       raise_anchor()
  4391.    } else {
  4392.       stop = ex_range( DEFAULT_ONE )
  4393.       start = current_line
  4394.       count = ( gflag ) ? 0x7FFFFFFF : 1
  4395.  
  4396.       while( start <= stop )
  4397.          {
  4398.          goto_pos( start++, 1 )
  4399.          drop_anchor( LINE_SELECTION )
  4400.          search_count = count
  4401.          if( cflag? ex_sub_confirm( old ) : 1 ) {
  4402.             n += replace( old, new, sflags )
  4403.             if( pflag ){
  4404.                copy_to_scrap()
  4405.                scrap_to_browser()
  4406.             }
  4407.          }
  4408.          raise_anchor()
  4409.       }
  4410.    }
  4411.  
  4412.    if( !in_glob )
  4413.       message( "%d replacements made", n )
  4414. }
  4415.  
  4416. local function ex_sub_confirm( old ) {
  4417.    local results
  4418.  
  4419.    #message("ex_sub_confirm");
  4420.    if( search( old, 23 + and( vi_search_flags,  SEARCH_CASE ))) {
  4421.       copy_to_scrap()
  4422.       scrap_to_confirmer()
  4423.       results = confirmer( current_column, 1, length( old ), 1 )
  4424.       return results
  4425.    }
  4426. }
  4427.  
  4428. local function ex_glob( gv ){
  4429.    local com, quote, regex, n = 0
  4430.    local sflags = or( or( SEARCH_FWD_REGEX_MAX, SEARCH_BLOCK ),   \
  4431.             or( SEARCH_ADVANCE,        \
  4432.                and( search_flags, SEARCH_CASE )))
  4433.                #and( vi_search_flags, SEARCH_CASE )))
  4434.  
  4435.    #message("ex_glob");
  4436.    if( in_glob )
  4437.       vi_error( "recursive :" gv " is not allowed" )
  4438.    in_glob = 1
  4439.    gv = ( gv == "v" )
  4440.  
  4441.    quote = eat_char()
  4442.    regex = search_hist( eat_regex( quote ))
  4443.  
  4444.    if( match( "", regex ) && RLENGTH == 0 )
  4445.       vi_error( "NULL search pattern length." );
  4446.  
  4447.    com = ex_com      # save remainder of glob command
  4448.    search_count = 1
  4449.  
  4450.    select_range()
  4451.    save_position()
  4452.  
  4453.    while( search( regex, sflags ) )
  4454.       {
  4455.  
  4456.       restore_position()
  4457.       save_position()
  4458.  
  4459.       ex_addr1 = ex_addr2 = current_line
  4460.       ex_addresses = 1
  4461.       ex_mode1( com )
  4462.  
  4463.       if(( n++ % 10 ) == 3 )
  4464.          display_update()
  4465.  
  4466.       if( com !~ /d/ )
  4467.          goto_eol()
  4468.       }
  4469.  
  4470.    restore_position( 1 )
  4471.  
  4472.    if( selection_type())
  4473.       raise_anchor()
  4474.    in_glob = 0
  4475.  
  4476.    message( "%d lines processed", n )
  4477. }
  4478.  
  4479. local function ex_range( defaultOne ){
  4480.    local start, stop
  4481.  
  4482.    #message("ex_range");
  4483.    if( selection_type())
  4484.       {
  4485.       stop = current_line
  4486.       swap_selection_marks()
  4487.       start = current_line
  4488.       raise_anchor()
  4489.       if( stop < start )
  4490.          {
  4491.          start = stop
  4492.          stop = current_line
  4493.          }
  4494.       }
  4495.    else if( ex_addresses )
  4496.       {
  4497.       start = ex_addr1
  4498.       stop = ex_addr2 - 1
  4499.       }
  4500.  
  4501.    else if( defaultOne )
  4502.       {
  4503.       start = stop = current_line
  4504.       }
  4505.  
  4506.    else
  4507.       {
  4508.       start = 1
  4509.       stop = buffer_last_line - 1
  4510.       }
  4511.  
  4512.    current_line = start
  4513.    return stop
  4514. }
  4515.  
  4516.  
  4517. local function browser_buffer(){
  4518.    #message("browser_buffer");
  4519.    if( !browser_bid )
  4520.       browser_bid = create_buffer( "", "", BUFFER_SYSTEM )
  4521.  
  4522.    return browser_bid
  4523. }
  4524.  
  4525. local function file_to_browser( filename ) {
  4526.    local cur_buf = current_buffer
  4527.  
  4528.    #message("file_to_browser");
  4529.    delete_event( EVENT.NEW_CURNT_BUFFER, "vi_new_current_win")
  4530.    current_buffer = browser_buffer()
  4531.    read_file( filename )
  4532.    current_buffer = cur_buf
  4533.    attach_event_handler( EVENT.NEW_CURNT_BUFFER, "vi_new_current_win")
  4534. }
  4535.  
  4536. local function scrap_to_browser(){
  4537.    local cur_buf = current_buffer
  4538.  
  4539.    #message("scrap_to_browser");
  4540.    delete_event( EVENT.NEW_CURNT_BUFFER, "vi_new_current_win")
  4541.    current_buffer = browser_buffer()
  4542.    goto_buffer_bottom()
  4543.    insert_scrap()
  4544.  
  4545.    current_buffer = cur_buf
  4546.    attach_event_handler( EVENT.NEW_CURNT_BUFFER, "vi_new_current_win")
  4547. }
  4548.  
  4549. local function scrap_to_confirmer() {
  4550.    local cur_buf = current_buffer
  4551.  
  4552.    #message("scrap_to_confirmer");
  4553.    delete_event( EVENT.NEW_CURNT_BUFFER, "vi_new_current_win")
  4554.    current_buffer = confirmer_buffer()
  4555.    goto_buffer_bottom()
  4556.    insert_scrap()
  4557.  
  4558.    current_buffer = cur_buf
  4559.    attach_event_handler( EVENT.NEW_CURNT_BUFFER, "vi_new_current_win")
  4560. }
  4561.  
  4562. local function confirmer_buffer() {
  4563.    #message("confirmer_buffer")
  4564.    if( ! confirmer_bid )
  4565.       confirmer_bid = create_buffer( "", "", 1 )
  4566.  
  4567.    return confirmer_bid
  4568. }
  4569.  
  4570.  
  4571.  
  4572. ########################################################
  4573. #
  4574. #  confirmer(col, line, width, height )
  4575. #        displays lines placed by line_to confirmer in a window
  4576. #        returns 1 or 0 depending upon whether process was
  4577. #        terminated by a "y" key or not
  4578.  
  4579. local function confirmer( col, line, width, height )
  4580. {
  4581.    local cur_win = current_window
  4582.    local cur_buf = current_buffer
  4583.    local cur_map = current_keymap
  4584.    local i
  4585.    local results
  4586.    local old_wflags = window_flags
  4587.  
  4588.    #message("confirmer");
  4589.    # Must execute the next lines before changing keymaps since changing
  4590.    # buffers or windows sets the vi_command_keymap
  4591.    current_window = create_window()
  4592.    current_buffer = confirmer_buffer()
  4593.    window_flags = or(window_flags, WINDOW_SHOW_SYSTEM)
  4594.    attach_window_buffer( current_window, current_buffer )
  4595.    window_flags = old_wflags
  4596.    
  4597.    window_name = "Confirmer" 
  4598.    if( confirmer_keymap == -1 ){
  4599.       current_keymap = confirmer_keymap = create_keymap( empty_keymap )
  4600.  
  4601.       for( i = 0; i < 256; i ++ )
  4602.          assign_key( "#" i, "process_end" )
  4603.       assign_key( "y",  "process_end 1" )
  4604.       assign_key( "Y",  "process_end 1" )
  4605.    }
  4606.  
  4607.    current_keymap = confirmer_keymap 
  4608.  
  4609.    message( "Confirm with \"y\" key; reject with any other ascii key" )
  4610. #   highlight_window( window_text_x0 + col -2, window_text_y0 + line -2, width, height, 0x20 )
  4611.  
  4612.    results = process_begin()
  4613.  
  4614.    delete_buffer( current_buffer )
  4615.    delete_window( current_window )
  4616.    current_buffer = cur_buf
  4617.    current_window = cur_win
  4618.    current_keymap = cur_map 
  4619.  
  4620.    confirmer_bid = 0
  4621.  
  4622.    return results
  4623. }
  4624.  
  4625.  
  4626. local function browse_printed()
  4627. {
  4628.    local cur_buf = current_buffer
  4629.    local cur_map = current_keymap
  4630.    local win_name = window_name
  4631.    local old_wflags = window_flags
  4632.    
  4633.  
  4634.    # Changing the buffer must come before the keymap assignment because
  4635.    # changing buffers or windows causes the vi_command_keymap to be
  4636.    # assigned to current_keymap.
  4637.    current_buffer = browser_buffer()
  4638.    
  4639.    window_flags = or(window_flags, WINDOW_SHOW_SYSTEM)
  4640.    attach_window_buffer( current_window, current_buffer )
  4641.    window_flags = old_wflags
  4642.    goto_buffer_top()
  4643.  
  4644.    #message("browse_printed");
  4645.    if( browser_keymap == -1 )
  4646.    {
  4647.       current_keymap = browser_keymap = create_keymap( empty_keymap )
  4648.  
  4649.       assign_key( "<Esc>",    "vi_process_end" )
  4650.  
  4651.       # motion keys which call vi_error are not safe to use within
  4652.       #  browse_printed.  The following simulate vi
  4653.  
  4654.       assign_key( "<Ctrl-PageUp>",  "goto_buffer_top" )
  4655.       assign_key( "<Ctrl-PageDown>",   "goto_buffer_bottom" )
  4656.       assign_key( "<PageUp>",    "page_up" )
  4657.       assign_key( "<PageDown>",     "page_down" )
  4658.  
  4659.       assign_key( "<Ctrl-B>",    "page_up" )
  4660.       assign_key( "<Ctrl-F>",    "page_down" )
  4661.       assign_key( "<Ctrl-D>",    "scroll_down_half" )
  4662.       assign_key( "<Ctrl-U>",    "scroll_up_half" )
  4663.       assign_key( "<Ctrl-E>",    "scroll_down_1" )
  4664.       assign_key( "<Ctrl-Y>",    "scroll_up_1" )
  4665.  
  4666.       assign_key( "h",     "prev_char" )
  4667.       assign_key( "j",     "down" )
  4668.       assign_key( "k",     "up" )
  4669.       assign_key( "l",     "next_char" )
  4670.       assign_key( "<Left>",      "prev_char" )
  4671.       assign_key( "<Up>",        "up" )
  4672.       assign_key( "<Down>",      "down" )
  4673.       assign_key( "<Right>",     "next_char" )
  4674.  
  4675.       assign_key( "<Home>",      "goto_bol" )
  4676.       assign_key( "<End>",    "goto_eol" )
  4677.       assign_key( "G",     "goto_buffer_bottom" )
  4678.       assign_key( "g",     "goto_buffer_top" )
  4679.    }
  4680.    else
  4681.       current_keymap = browser_keymap 
  4682.  
  4683.    window_name  = "Command Output Listing"
  4684.    message( "Use <Esc> to exit, PageUp/PageDown keys to browse" )
  4685.    process_begin()
  4686.  
  4687.    message( "" )
  4688.    delete_buffer( current_buffer )
  4689.    window_name = win_name
  4690.    current_buffer = cur_buf
  4691.    current_keymap = cur_map 
  4692.  
  4693.    browser_bid = 0
  4694. }
  4695.  
  4696. local function pbuf( s ){
  4697.    local cur_buf = current_buffer
  4698.  
  4699.    current_buffer = browser_buffer()
  4700.    insert_string( s "\n" )
  4701.  
  4702.    current_buffer = cur_buf
  4703. }
  4704.  
  4705.  
  4706. # select a region based on starting and ending addresses
  4707.  
  4708. local function select_range( defaultOne ){
  4709.    #message("select_range");
  4710.    if( ex_addresses )
  4711.    {
  4712.       current_line = ex_addr1
  4713.       current_column = 1
  4714.       drop_anchor( LINE_SELECTION )
  4715.       if( ex_addresses > 1 )
  4716.          current_line = ex_addr2
  4717.    }
  4718.    else
  4719.    {
  4720.       if( defaultOne )
  4721.       {
  4722.          drop_anchor( LINE_SELECTION )
  4723.       }
  4724.       else
  4725.          current_line = current_column = 1
  4726.    }
  4727. }
  4728.  
  4729. # parse a range address expression; result is 0, 1 or 2 numbers
  4730. #
  4731. #  term:
  4732. #     .
  4733. #     $
  4734. #     'a
  4735. #     /.../
  4736. #     ?...?
  4737. #  addr: 
  4738. #     term
  4739. #     term + num
  4740. #     term - num
  4741. #     + num       # . + num
  4742. #     - num       # . - num
  4743. #     term +         # term + 1
  4744. #     term -         # term - 1
  4745. #     num
  4746. #  range:
  4747. #     /* empty */    # 1,$
  4748. #     addr
  4749. #     addr , addr
  4750. #     addr ; addr
  4751. #     ,        # 1,$
  4752. #     ;        # .,$
  4753. #
  4754. local function ex_address()
  4755. {
  4756.    local len1, len = length( ex_com )
  4757.    local num, patt, mark, op, ex_addr2 # made ex_addr2 local /Gj/
  4758.  
  4759.    #message("ex_address");
  4760.    # get stand-alone term, if any:
  4761.  
  4762.    if( eat_match( "/" )){
  4763.       vi_search( eat_regex( "/" ), SEARCH_FORWARD )
  4764.       ex_addr2 = current_line
  4765.  
  4766.    } else if( eat_match( "\\?" )){
  4767.       vi_search( eat_regex( "?" ), SEARCH_BACKWARD )
  4768.       ex_addr2 = current_line
  4769.  
  4770.    } else if( eat_match( "\\." )){
  4771.       ex_addr2 = current_line
  4772.  
  4773.    } else if( eat_match( "\\$" )){
  4774.       #ex_addr2 = buffer_last_line - 1
  4775.       ex_addr2 = buffer_last_line
  4776.  
  4777.    } else if(( patt = eat_match( "'." ))){
  4778.       mark = vi_mark_id( substr( patt, 2 ))
  4779.       if( !mark_defined( mark ))
  4780.          bad_addr()
  4781.       ex_addr2 = mark_line( mark )
  4782.  
  4783.       } else 
  4784.       ex_addr2 = current_line    # missing -- set default
  4785.  
  4786.    len1 = len - length( ex_com )
  4787.  
  4788.    # get operator, if any:
  4789.  
  4790.    op = eat_match( "[+\\-]" )
  4791.  
  4792.    line_search = !!op      # signal to vi_search_key()
  4793.  
  4794.    # get number, if any:
  4795.  
  4796.    if(( num = eat_match( "[0-9]+" ))){
  4797.       if( len1 && op == "" )
  4798.          bad_addr()
  4799.       num = 0 + num
  4800.       } else 
  4801.       num = 1
  4802.  
  4803.    # compute final value:
  4804.  
  4805.    if( op == "+" )
  4806.       ex_addr2 = ex_addr2 + num
  4807.    else if( op == "-" )
  4808.       ex_addr2 = ex_addr2 - num
  4809.    else if( !len1 )  # if no op and no stand-alone term
  4810.       ex_addr2 = num
  4811.  
  4812.    # update address count, if any:
  4813.  
  4814.    if( len != length( ex_com ))
  4815.       ex_addresses ++
  4816.  
  4817.    return ex_addr2
  4818. }
  4819.  
  4820. local function ex_address_range()
  4821. {
  4822.    local ch
  4823.  
  4824.    ex_addresses = 0
  4825.    mark_context()
  4826.    ex_addr1 = ex_address()
  4827.  
  4828.    #message("ex_address_range");
  4829.    if( ex_addresses )
  4830.       {
  4831.       if( ex_com ~ /^;/ )
  4832.          {
  4833.          vi_goto_line( ex_addr1 )   
  4834.          goto_bol()
  4835.          }
  4836.       if( eat_match( "[,;]" ))
  4837.          {
  4838.          ex_addr2 = ex_address()
  4839.          if( ex_addresses != 2 )
  4840.             bad_addr()
  4841.          }
  4842.       }
  4843.  
  4844.    else if( eat_match( "[,%]" ))
  4845.       {
  4846.       ex_addr1 = 1
  4847.       ex_addr2 = buffer_last_line - 1
  4848.       ex_addresses = 2
  4849.    }
  4850.  
  4851.    else if( eat_match( ";" ))
  4852.       {
  4853.       ex_addr1 = current_line
  4854.       ex_addr2 = buffer_last_line - 1
  4855.       ex_addresses = 2
  4856.       }
  4857.  
  4858.    else
  4859.       {
  4860.       ex_addr1 = ex_addr2 = current_line
  4861.       }
  4862.  
  4863.    if( ex_addresses > 1 && ex_addr1 > ex_addr2 )
  4864.       bad_addr()
  4865.  
  4866.    goto_mark( vi_base_mark )
  4867. }
  4868.  
  4869. local function bad_addr(){
  4870.    #message("bad_addr")
  4871.    goto_mark( vi_base_mark )     # restore initial position
  4872.    vi_error( "Ill-formed address" )
  4873. }
  4874.  
  4875. ## address and ex mode parser helpers
  4876. #
  4877. #  eat_... => if match then return the matched string and advance ex_com; 
  4878. #     else return null without advancing ex_com.
  4879.  
  4880. local function eat_match( patt )
  4881. {
  4882.    local r = ""
  4883.  
  4884.    if( match( ex_com, "^" patt )){
  4885.       r = substr( ex_com, 1, RLENGTH )
  4886.       ex_com = substr( ex_com, RLENGTH + 1 )
  4887.    }
  4888.    return r
  4889. }
  4890.  
  4891. local function eat_count() {
  4892.    local num
  4893.  
  4894.       eat_space()
  4895.    num = eat_match( "[0-9]+" )
  4896.    #message("eat_count = %d", num);
  4897.  
  4898.    if( num )
  4899.       return num + 0
  4900.       else
  4901.       return 0
  4902. }
  4903.  
  4904. local function eat_append() {
  4905.    local app
  4906.       eat_space()
  4907.    app = eat_match( "\\>\\>" )
  4908.    #message("eat_append = %s", app);
  4909.    return app;
  4910. }
  4911.  
  4912.  
  4913. local function eat_word() {
  4914.    local word;
  4915.  
  4916.    eat_space()
  4917.    word = eat_match( "[^" " \t]+" )
  4918.    return word
  4919. }
  4920.  
  4921. local function eat_command()
  4922. {
  4923.    local com =  eat_match( "[a-zA-Z]+|!|#|=|&|[<]+|[>]+" )
  4924.    return com;
  4925. }
  4926.  
  4927. local function eat_no() {
  4928.    local no;
  4929.    eat_space()
  4930.    no = eat_match( "no" )
  4931.    return no;
  4932. }
  4933.  
  4934. local function eat_option() {
  4935.    local op;
  4936.    eat_space()
  4937.    op = eat_match( "[a-z]+" )
  4938.    return op;
  4939. }
  4940.  
  4941. local function eat_space(){
  4942.    local space = eat_match( "[ \t]*" )
  4943.    return space;
  4944. }
  4945.  
  4946. local function eat_bang(){
  4947.    local bang = eat_match( "!" )
  4948.    return bang;
  4949. }
  4950.  
  4951. local function eat_equal() {
  4952.    local equal = eat_match( "=" )
  4953.    return equal
  4954. }
  4955.  
  4956. local function eat_question_mark() {
  4957.    local q = eat_match( "\\?" )
  4958.    return q;
  4959. }
  4960.  
  4961. local function eat_arg(){
  4962.    local arg;
  4963.    eat_space()
  4964.    arg = eat_match( "[^;]+" )
  4965.    return arg;
  4966. }
  4967.  
  4968. local function eat_char(){
  4969.    local ch = substr( ex_com, 1, 1 )
  4970.    ex_com = substr( ex_com, 2 )
  4971.    #message("eat_char = %s", ch);
  4972.    return ch
  4973. }
  4974.  
  4975. local function eat_punctuation()
  4976. {
  4977.    local p = eat_match( "[!@#%&-_={}\\:;\"\\'<>,/~\\`]" ) 
  4978.    return p;
  4979. }
  4980.  
  4981. local function eat_letter()
  4982. {
  4983.    local l = eat_match( "[a-z]" )
  4984.    return l;
  4985. }
  4986.  
  4987. # eat a regular expression, with <sep> as the separator.
  4988. #
  4989. #  syntax is   sep regex sep
  4990. #         or   sep regex EOL
  4991. #
  4992. #  sep is      "/"  or  "?"
  4993. #
  4994. #  Leading separator should already have been removed.
  4995. #  We don't use eat_match to avoid the slower anchored search.
  4996. #  This is a good place to implement nomagic and other regex
  4997. #     transformations.
  4998. #
  4999. local function eat_regex( sep )
  5000. {
  5001.    local patt, regex, len
  5002.  
  5003.    # closing seperator may be prefixed by an even number of backslashes;
  5004.    # an odd number of backslashes quote the seperator, requiring it to
  5005.    # be included in the regex.
  5006.  
  5007.    patt = "[^\\\\](\\\\\\\\)*"   
  5008.    if( sep ~ /[|\]^$*+(){}.?\\]/ )  # regex seperators must be quoted
  5009.       sep =  "\\" sep
  5010.  
  5011.    # split the input into a regex LHS and a remainder RHS, discarding
  5012.    # the closing seperator; two matches because first may not be longest
  5013.  
  5014.    if( match( ex_com, "^" sep ) || match( ex_com, patt sep ))
  5015.    {
  5016.       len = RSTART + RLENGTH - 1 # index of closing seperator
  5017.       regex = substr( ex_com, 1, len - 1 )
  5018.       ex_com = substr( ex_com, len + 1 )
  5019.    }
  5020.    else
  5021.    {
  5022.       regex = ex_com
  5023.       ex_com = ""
  5024.    }
  5025.  
  5026.    # Now remove quotes from quoted seperators.  By definition, they must 
  5027.    # have an odd number of preceeding backslashes, one of which must be
  5028.    # removed.  However, regex chars need to retain the quoting.
  5029.  
  5030.    if( length( sep ) == 1 )
  5031.       gsub( "\\" sep, sep, regex )
  5032.  
  5033.    return regex
  5034. }
  5035.  
  5036. #########################################################################
  5037. #
  5038. #       expand_macro replaces a set of keystrokes with
  5039. #        a string specified with the :map ex command.
  5040. #        Looks at setting of remap option to allow or
  5041. #        inhibit nested macros
  5042.  
  5043. function expand_macro( macro_name )
  5044. {
  5045.    local macro_body, the_key, success
  5046.    if( macro_name in recursion_count )
  5047.    {
  5048.       if( in_ex_mode )
  5049.          vi_error( "recursive map not allowed" )
  5050.       else
  5051.       {
  5052.          vi_warning( "recursive map not allowed" )
  5053.          flush_keyboard()
  5054.          process_end()
  5055.       }
  5056.    }
  5057.    else
  5058.    {
  5059.       recursion_count[ macro_name ] = ""
  5060.       if( option_disable[ "remap" ] )
  5061.       {
  5062.          if( in_ex_mode )
  5063.             push_keymap( default_vi_command_keymap )
  5064.          else
  5065.             push_keymap( default_vi_insert_keymap )
  5066.       }
  5067.  
  5068.       if( in_ex_mode)
  5069.       {
  5070.          macro_body = command_macro_table[ macro_name ]
  5071.          the_key = keymap_binding( macro_body )
  5072.          gsub( ".", "&\0", macro_body )
  5073.          the_key = keymap_binding( macro_body )
  5074.          success =playback( macro_body )
  5075.       }
  5076.       else
  5077.       {
  5078.          macro_body = insert_macro_table[ macro_name ]
  5079.          gsub( ".", "&\0", macro_body )
  5080.          playback( macro_body )
  5081.       }
  5082.  
  5083.       delete recursion_count[ macro_name ]
  5084.       if( option_disable[ "remap" ] )
  5085.          pop_keymap()
  5086.    }
  5087. }
  5088.  
  5089. ##########################################################################
  5090. #
  5091. #` covered_binding      finds any keybinding that will be covered
  5092. #           by the specified binding. Returns the
  5093. #           key string that will be covered.
  5094. #
  5095.  
  5096. local function covered_binding( macro_name, variant)
  5097. {
  5098.    local i, found = 1, name = "", prev_name, keymap, prev_prev_name
  5099.  
  5100.    # check keymap first for anything that might get covered
  5101.  
  5102.    if( variant )
  5103.       keymap = vi_insert_keymap
  5104.    else
  5105.       keymap = vi_command_keymap
  5106.  
  5107.    for( i = length( macro_name); found; i-- )
  5108.    {
  5109.       prev_name = name
  5110.       name = substr( macro_name, 1, i )
  5111.       found = keymap_binding( name, keymap )
  5112.    }
  5113.  
  5114.    if( prev_name ) # see if the one you are about to cover covers anything
  5115.    {
  5116.       if( variant )
  5117.       {
  5118.          prev_prev_name = covered_insert_macro[ prev_name ]
  5119.          return prev_prev_name? prev_prev_name: prev_name
  5120.       }
  5121.       else
  5122.       {
  5123.          prev_prev_name = covered_command_macro[ prev_name ]
  5124.          return prev_prev_name? prev_prev_name: prev_name
  5125.       }
  5126.    }
  5127.    else # if no luck in the keymap, check existing macros
  5128.    {
  5129.       if (variant)
  5130.       {
  5131.          for( prev_name in insert_macro_table) 
  5132.             if( index( macro_name, prev_name ) == 1 )
  5133.                return prev_name
  5134.       }
  5135.       else
  5136.       {
  5137.          for( prev_name in command_macro_table )
  5138.             if( index( macro_name, prev_name ) == 1 )
  5139.                return prev_name
  5140.       }
  5141.    }
  5142. }
  5143.  
  5144. # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # #
  5145.  # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # #
  5146. # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # #
  5147.  
  5148. ### regex searches
  5149. #
  5150. #  vi_search   searches forwards or backwards for 1 pattern
  5151. #        vi_error()s if the pattern is not found.
  5152. #  vi_search_key  prompts for input, and otherwise handles the 
  5153. #        "/" and "?" commands
  5154. #  vi_search_again   handles the "n", "N", and Alt-F5 and Alt-F6 commands.
  5155. #
  5156. #  search_hist()  recalls or remembers previous search pattern
  5157. #
  5158.  
  5159. function vi_search_key( key )
  5160. {
  5161.    local patt
  5162.  
  5163.    patt = vi_prompt( "SEARCH", key, "", 1 )
  5164.    if (patt == key)
  5165.    {
  5166.       delete_history_item("SEARCH", patt)
  5167.       vi_search_again(key)
  5168.    }
  5169.    else
  5170.    {
  5171.    disallow_number()
  5172.    op_type_2b( DONT_MARK )
  5173.  
  5174.    vi_search_on_pattern( key, patt )
  5175.    }
  5176. }
  5177.  
  5178. function vi_search_on_pattern( key, patt )
  5179. {
  5180.    local addr
  5181.  
  5182.    if( patt )
  5183.    {
  5184.       record_op( key_to_int("<Enter>") )
  5185.  
  5186.       vi_search_dir = ( key == "/" ? SEARCH_FORWARD : SEARCH_BACKWARD )
  5187.       mark_context( MAJOR_MARK ) # mark context for motion
  5188.  
  5189.       ex_com = key patt
  5190.       addr = ex_address()  # parse command, call vi_search() as needed
  5191.  
  5192.       # execute op, if any, in line or normal mode
  5193.  
  5194.       if( line_search )
  5195.       {
  5196.          vi_goto_line( addr )
  5197.          xeq_op( LINE_SELECTION )
  5198.       }
  5199.       else 
  5200.          xeq_op()
  5201.    }
  5202.    else 
  5203.       op_flush()
  5204. }
  5205.  
  5206. local function search_hist( patt )
  5207. {
  5208.    if( patt )
  5209.       add_prompt_history( SEARCH_HIST, patt )
  5210.    else
  5211.    {
  5212.       patt = current_history_item( SEARCH_HIST )
  5213.       if( !patt )
  5214.          vi_error( "Missing previous pattern" )
  5215.    }
  5216.  
  5217.    return patt
  5218. }
  5219.  
  5220.  
  5221. local function vi_search( pattern, dir )
  5222. {
  5223.    local search_op
  5224.    local orig_offset = buffer_offset
  5225.    local offset_diff
  5226.  
  5227.    # set vi_search_flags to not have a direction.  We must do it this
  5228.    # way since SEARCH_FORWARD = 4 and SEARCH_BACKWARD = 0
  5229.    vi_search_flags = or(SEARCH_ADVANCE, and(search_flags, not(SEARCH_FORWARD)))
  5230.    pattern = search_hist( pattern )
  5231.    if( !search( pattern, or( vi_search_flags, dir )))
  5232.       {
  5233.       message("Pattern not found: " pattern )
  5234.       vi_error() # never returns
  5235.       }     
  5236.    else
  5237.    {
  5238.       if( eat_match( "z-" ))
  5239.          scroll_window_bottom()
  5240.       else if( eat_match( "z." ))
  5241.          scroll_window_middle()
  5242.       else if( eat_match( "z" ))
  5243.          scroll_window_top()
  5244.       else if( eat_match( ";" ))
  5245.          if(( search_op = eat_match( "[/?]" )))
  5246.             vi_search_on_pattern( search_op, ex_com )
  5247.       else
  5248.          vi_error( "syntax" ) 
  5249.  
  5250.       offset_diff = (dir == SEARCH_FORWARD) ? buffer_offset - orig_offset : 
  5251.                                                 orig_offset - buffer_offset
  5252.       if (offset_diff < 0)
  5253.          notify("Search wrapped around")
  5254.       else
  5255.          message("")
  5256.    }
  5257. }
  5258.  
  5259. # search again is called by 4 different keys, with 4 different meanings:
  5260. #
  5261. #  n  search again, same direction as originally
  5262. #  N  search again, opposite direction as originally
  5263. #  Alt-F5   search again, backwards
  5264. #  Alt-F6   search again, forwards
  5265. #
  5266. function vi_search_again( key )
  5267. {
  5268.    local dir 
  5269.    local last_dir = vi_search_dir
  5270.  
  5271.    disallow_number()
  5272.    op_type_2b( MAJOR_MARK )
  5273.  
  5274.    #message("search again key is: %s", key)
  5275.    # figure out what direction we're going...
  5276.    if (key == "?")
  5277.       dir = SEARCH_BACKWARD
  5278.    else if (key == "/")
  5279.       dir = SEARCH_FORWARD
  5280.    else if (key == "N")  
  5281.       dir = (last_dir == SEARCH_FORWARD) ? SEARCH_BACKWARD : SEARCH_FORWARD
  5282.    else
  5283.       dir = last_dir
  5284.    
  5285.    
  5286.    #dir = (argcount() ? (( key == "?" ) ? SEARCH_BACKWARD : SEARCH_FORWARD ) \
  5287.    #                  : (( chr( int_to_ascii( current_key )) == "N" )        \
  5288.    #                    ? (( vi_search_dir == SEARCH_FORWARD )               \
  5289.    #                      ? SEARCH_BACKWARD : SEARCH_FORWARD )               \
  5290.    #                    : vi_search_dir ))
  5291.  
  5292.    message( "%s%s", ( dir == SEARCH_FORWARD ? "/" : "?" ), search_hist())
  5293.  
  5294.    # execute search operator:
  5295.  
  5296.    vi_search( "", dir )
  5297.    xeq_op()
  5298. }
  5299.  
  5300. function vi_new_current_win()
  5301. {
  5302.    # Do NOT call vi_reset() if bogus NEW_CURNT_WINDOW event (i.e. mouse click)
  5303.    # or if we are already in ex_mode
  5304.    if (!in_ex_mode && (current_window != insert_window || current_buffer != insert_buffer))
  5305.    {
  5306.       vi_process_end()
  5307.    }
  5308. }
  5309.  
  5310. function vi_reset(force_keymap)
  5311. {
  5312. #   message("In vi_reset, event_id is: %d", event_id)
  5313.       
  5314.    if (event_id == EVENT.ERROR)
  5315.       force_keymap = 1
  5316.       
  5317.    number_register=0
  5318.    pending_operator = ""
  5319.    raise_anchor()
  5320.    remove_selection()
  5321.    vi_command_mode(force_keymap)
  5322.    process_end()
  5323. }  
  5324.  
  5325. function vi_delete_buffer()
  5326. {
  5327.    # Delete the current buffer and make the NEXT buffer current
  5328.    # (0 instead of 1 makes the previous buffer current).
  5329.    delete_buffer_key("",1) 
  5330.    ex_show_file()
  5331. }
  5332.  
  5333.  
  5334. # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # #
  5335.  # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # #
  5336. # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # #
  5337.  
  5338. local function vi_keymap_valid(km)
  5339. {
  5340.    local result = 1
  5341.  
  5342.    if (km <= 0 || km > 16)
  5343.       result = 0
  5344.       
  5345. #  message("Keymap id is: %d", km)
  5346. #   if ( (km <= 0) || !push_keymap(km))
  5347. #      result = 0
  5348. #   else
  5349. #      pop_keymap()
  5350.   
  5351.    return result
  5352. }
  5353.  
  5354. ### create the VI keymaps if they have not already been
  5355. #
  5356. local function create_vi_command_keymaps()
  5357. {
  5358.    # Enable the keymap.  Subsequent mods to the keymap will persist 
  5359.    #  through the end of the session. 
  5360.    # Only one-time initialization should follow this point. 
  5361.  
  5362.    if( vi_keymap_valid(vi_command_keymap) )
  5363.    {
  5364.       current_keymap = vi_command_keymap 
  5365.    }
  5366.    else if (vi_keymap_valid(default_vi_command_keymap) )
  5367.    {
  5368.       vi_command_keymap = default_vi_command_keymap
  5369.       current_keymap = vi_command_keymap 
  5370.    }
  5371.    else
  5372.    {
  5373.       current_keymap = vi_command_keymap = create_keymap( empty_keymap )
  5374.  
  5375.       assign_vi_command_keys()
  5376.       
  5377.       optional_function("local_keys")
  5378.       default_vi_command_keymap = create_keymap( vi_command_keymap )
  5379.    } 
  5380. }
  5381.  
  5382. local function assign_vi_command_keys()
  5383. {
  5384.    assign_key( "0",     "vi_digit" )  
  5385.    assign_key( "1",     "vi_digit" )
  5386.    assign_key( "2",     "vi_digit" )
  5387.    assign_key( "3",     "vi_digit" )
  5388.    assign_key( "4",     "vi_digit" )
  5389.    assign_key( "5",     "vi_digit" )
  5390.    assign_key( "6",     "vi_digit" )
  5391.    assign_key( "7",     "vi_digit" )
  5392.    assign_key( "8",     "vi_digit" )
  5393.    assign_key( "9",     "vi_digit" )
  5394.  
  5395.    assign_key( "<Alt-1>",     "place_bookmark 1" )
  5396.    assign_key( "<Alt-2>",     "place_bookmark 2" )
  5397.    assign_key( "<Alt-3>",     "place_bookmark 3" )
  5398.    assign_key( "<Alt-4>",     "place_bookmark 4" )
  5399.    assign_key( "<Alt-5>",     "place_bookmark 5" )
  5400.    assign_key( "<Alt-6>",     "place_bookmark 6" )
  5401.    assign_key( "<Alt-7>",     "place_bookmark 7" )
  5402.    assign_key( "<Alt-8>",     "place_bookmark 8" )
  5403.    assign_key( "<Alt-9>",     "place_bookmark 9" )
  5404.    assign_key( "<Alt-0>",     "place_bookmark 10" )
  5405.  
  5406.    assign_key( "a",     "vi_a" )
  5407.    assign_key( "b",     "vi_b" )
  5408.    assign_key( "c",     "vi_operator" )
  5409.    assign_key( "d",     "vi_operator" )
  5410.    assign_key( "e",     "vi_e" )
  5411.    assign_key( "f",     "vi_find" )
  5412.    assign_key( "g",     "vi_goto 1" )
  5413. #   assign_key( "h",     "vi_left" )
  5414.    assign_key( "h",     "vi_arrow 3" )
  5415.    assign_key( "i",     "vi_i" )
  5416. #   assign_key( "j",     "vi_down" )
  5417.    assign_key( "j",     "vi_arrow 2" )
  5418. #   assign_key( "k",     "vi_up" )
  5419. #   assign_key( "l",     "vi_right" )
  5420.    assign_key( "k",     "vi_arrow 1" )
  5421.    assign_key( "l",     "vi_arrow 4" )
  5422.    assign_key( "m",     "vi_place_mark" )
  5423.    assign_key( "n",     "vi_search_again n" )
  5424.    assign_key( "o",     "vi_o" )
  5425.    assign_key( "p",     "vi_p" )
  5426.    assign_key( "r",     "vi_r" )
  5427.    assign_key( "s",     "vi_s" )
  5428.    assign_key( "t",     "vi_find" )
  5429.    assign_key( "u",     "vi_undo" )
  5430.    assign_key( "w",     "vi_w" )
  5431.    assign_key( "x",     "vi_x" )
  5432.    assign_key( "y",     "vi_operator" )
  5433.    assign_key( "z",     "vi_scroll_window" )
  5434.  
  5435.    assign_key( "A",     "vi_A" )
  5436.    assign_key( "B",     "vi_B" )
  5437.    assign_key( "C",     "vi_C" )
  5438.    assign_key( "D",     "vi_D" )
  5439.    assign_key( "E",     "vi_E" )
  5440.    assign_key( "F",     "vi_find" )
  5441.    assign_key( "G",     "vi_goto" )
  5442.    assign_key( "H",     "vi_H" )
  5443.    assign_key( "I",     "vi_I" )
  5444.    assign_key( "J",     "vi_J" )
  5445.    assign_key( "L",     "vi_L" )
  5446.    assign_key( "M",     "vi_M" )
  5447.    assign_key( "N",     "vi_search_again N" )
  5448.    assign_key( "O",     "vi_O" )
  5449.    assign_key( "P",     "vi_P" )
  5450.    assign_key( "R",     "vi_R" )
  5451.    assign_key( "S",     "vi_S" )
  5452.    assign_key( "T",     "vi_find" )
  5453.    assign_key( "U",     "vi_undo_line" )
  5454.    assign_key( "W",     "vi_W" )
  5455.    assign_key( "X",     "vi_X" )
  5456.    assign_key( "Y",     "vi_Y" )
  5457.    assign_key( "Z",     "vi_ZZ" )
  5458.  
  5459.    assign_key( "<Alt-A>",     "set_exclusive_mark" )
  5460.    assign_key( "<Alt-B>",     "buffer_list" )
  5461.    assign_key( "<Alt-C>",     "copy_to_scrap_key" )
  5462.    assign_key( "<Alt-D>",     "native_delete" )
  5463.    assign_key( "<Alt-E>",     "create_buf_and_win_key" )
  5464.    assign_key( "<Alt-F>",     "ex_show_file" )
  5465.    assign_key( "<Alt-G>",     "goto_line_or_mark" )
  5466.    assign_key( "<Alt-H>",     "display_help_item" )
  5467.    assign_key( "<Alt-I>",  function_id("toggle_buffer_flags", BUFFER_OVERTYPE_MODE))
  5468.    assign_key( "<Alt-J>",     "vi_J" )
  5469.    assign_key( "<Alt-K>",     "delete_to_eol" )
  5470.    assign_key( "<Alt-L>",     "set_line_mark" )
  5471.    assign_key( "<Alt-M>",     "mark_matching" )
  5472.    assign_key( "<Alt-N>",     "vi_next_buffer 1" )
  5473.    assign_key( "<Alt-->",     "vi_next_buffer 0" )
  5474.    assign_key( "<Alt-O>",     "change_output_name" )
  5475.    assign_key( "<Alt-P>",     "wrap_paragraph" )
  5476.    assign_key( "<Alt-Q>",     "done" )
  5477.    assign_key( "<Alt-R>",     "vi_read" )
  5478.    assign_key( "<Alt-S>",     "search_forward" )
  5479.    assign_key( "<Alt-T>",     "replace_forward" )
  5480.    assign_key( "<Alt-U>",     "undo" )
  5481.    assign_key( "<Alt-V>",     "print_version" )
  5482.    assign_key( "<Alt-W>",     "vi_save" )
  5483.    assign_key( "<Alt-X>",     "done" )
  5484.    assign_key( "<Alt-Y>",     "redo" )
  5485.    assign_key( "<Alt-Z>",     "system" )
  5486.  
  5487.    assign_key( "<Ctrl-A>",    "optional_function display_ascii_table" )
  5488.    assign_key( "<Ctrl-B>",    "page_up" )    # not a motion
  5489.    assign_key( "<Ctrl-C>",    "vi_process_end" )
  5490.    assign_key( "<Ctrl-D>",    "scroll_down_half" ) # not a motion
  5491.    assign_key( "<Ctrl-E>",    "scroll_down_1" ) # not a motion
  5492.    assign_key( "<Ctrl-F>",    "page_down" )     # not a motion
  5493.    assign_key( "<Ctrl-G>",    "ex_show_file" )
  5494.    assign_key( "<Ctrl-H>",    "vi_bksp" ) # Ctrl-H or Backspace
  5495.    assign_key( "<Ctrl-I>",    "vi_tab" )  # Ctrl-I or Tab
  5496.    assign_key( "<Ctrl-L>",    "scroll_left_1" )
  5497.    assign_key( "<Ctrl-N>",    "vi_arrow 2" ) # down
  5498.    assign_key( "<Ctrl-P>",    "vi_arrow 1" ) # up
  5499.    assign_key( "<Ctrl-R>",    "scroll_right_1" ) # inexact but appropriate substitution
  5500.    assign_key( "<Ctrl-T>",    "vi_tags_pop" )
  5501.    assign_key( "<Ctrl-U>",    "scroll_up_half" )   # not a motion
  5502.    assign_key( "<Ctrl-Y>",    "scroll_up_1" )      # not a motion
  5503.    assign_key( "<Ctrl-Z>",    "system" )
  5504.    assign_key( "<Ctrl-->",    "vi_delete_buffer" )
  5505.  
  5506.    assign_key( "<Esc>",             "vi_reset 1" )
  5507.    assign_key( "<PageUp>"       ,   "page_up" )    # not a motion
  5508.    assign_key( "<PageDown>"     ,   "page_down" )     # not a motion
  5509.    assign_key( "<Home>"         ,   "vi_goto_bol" )
  5510.    assign_key( "<End>"          ,   "vi_goto_eol" )
  5511.    assign_key( "<Up>"           ,   "vi_arrow 1" )
  5512.    assign_key( "<Down>"         ,   "vi_arrow 2" )
  5513.    assign_key( "<Left>"         ,   "vi_arrow 3" )
  5514.    assign_key( "<Right>"        ,   "vi_arrow 4" )
  5515.    assign_key( "<BackTab>"      ,   "vi_back_tab" )  #in PM use BackTab, else use shift-tab
  5516.    assign_key( "<Tab>"          ,   "vi_tab" )  # Ctrl-I or Tab
  5517.    assign_key( "<Enter>"        ,   "vi_next_line" )
  5518.    assign_key( "<Space>"        ,   "vi_space" )
  5519.    assign_key( "<Shift-Space>"  ,   "vi_space" )
  5520.    assign_key( "<Backspace>"    ,   "vi_bksp" ) # Ctrl-H or Backspace
  5521.    assign_key( "<Insert>"       ,   "vi_P" )
  5522.    #assign_key( "<Delete>"       ,   "vi_yank 1" )
  5523.    assign_key( "<Delete>"       ,   "delete_chars" )
  5524.  
  5525.    assign_key( "<Ctrl-PageUp>"  ,   "goto_buffer_top" )  # extension!
  5526.    assign_key( "<Ctrl-PageDown>",   "goto_buffer_bottom" )  # extension!
  5527.    assign_key( "<Ctrl-Left>"    ,   "vi_B" )
  5528.    assign_key( "<Ctrl-Right>"   ,   "vi_W" )
  5529.    assign_key( "<Ctrl-Home>"    ,   "goto_window_top" )
  5530.    assign_key( "<Ctrl-End>"     ,   "goto_window_bottom" )
  5531.  
  5532.    assign_key( "<Alt-Tab>"      ,   "vi_back_tab" )
  5533.  
  5534.    assign_key( "^",     "vi_skip_whitespace" )
  5535.    assign_key( "$",     "vi_goto_eol" )
  5536.    assign_key( "|",     "vi_goto_column" )
  5537.    assign_key( "+",     "vi_next_line" )
  5538.    assign_key( "-",     "vi_prev_line" )
  5539.    assign_key( ":",     "ex_key" )
  5540.    assign_key( "?",     "vi_search_key ?" )
  5541.    assign_key( "/",     "vi_search_key /" )
  5542.    assign_key( "%",     "vi_goto_matching" )
  5543.    assign_key( "(",     "vi_prev_sent" )
  5544.    assign_key( ")",     "vi_next_sent" )
  5545.    assign_key( "{",     "vi_prev_para" )
  5546.    assign_key( "}",     "vi_next_para" )
  5547.    assign_key( "[",     "vi_prev_sect" )
  5548.    assign_key( "]",     "vi_next_sect" )
  5549.    assign_key( ";",     "vi_find_repeat" )
  5550.    assign_key( ",",     "vi_find_reverse" )
  5551.    assign_key( "'",     "vi_goto_mark" )
  5552.    assign_key( "`",     "vi_goto_mark" )
  5553.    assign_key( ">",     "vi_operator" )
  5554.    assign_key( "!",     "vi_operator" )
  5555.    assign_key( ".",     "vi_again" )
  5556.    assign_key( "~",     "vi_tilde" )
  5557.    assign_key( "&",     "ex_subs_repeat" )
  5558.    assign_key( "\"",    "vi_bufid_key" )
  5559.    assign_key( "<",     "vi_operator" )
  5560.  
  5561. #  assign_key( "<Num-4>",   "left" )
  5562. #  assign_key( "<Num-6>",   "right" )
  5563.    assign_key( "<Num-->",  "vi_prev_line" )
  5564.    assign_key( "<Num-+>",  "vi_next_line" )
  5565.  
  5566.  
  5567.    assign_key( "<Ctrl-^>", "last_buffer_key" )
  5568.    assign_key( "<Ctrl-]>", "vi_tags_auto" )
  5569.  
  5570.    assign_key( "<F3>",     "vi_next_buffer 0" )
  5571.    assign_key( "<F4>",     "vi_next_buffer 1" )
  5572.    assign_key( "<F5>",     "vi_search_key ?" )
  5573.    assign_key( "<F6>",     "vi_search_key /" )
  5574. #   assign_key( "<F7>",     "record_key" )
  5575. #   assign_key( "<F8>",     "playback" )
  5576.    assign_key( "<F7>",     "record_macro" )
  5577.    assign_key( "<F8>",     "playback_macro" )
  5578.    assign_key( "<F9>",     "system_key" )
  5579.    assign_key( "<F10>",    "invoke_function" )
  5580.  
  5581. #  assign_key( "<Alt-F1>",    "split_window_horizontal" )
  5582. #  assign_key( "<Alt-F2>",    "split_window_vertical" )
  5583. #  assign_key( "<Alt-F3>",    "make_window" )
  5584. #  assign_key( "<Alt-F4>",    "delete_tiled_window" )
  5585.    assign_key( "<Alt-F4>",    "done" )
  5586.    assign_key( "<Alt-F5>",    "vi_search_again ?" )
  5587.    assign_key( "<Alt-F6>",    "vi_search_again /" )
  5588.    assign_key( "<Alt-F7>",    "learn_key" )
  5589. #  assign_key( "<Alt-F8>",    )
  5590. #  assign_key( "<Alt-F9>",    )
  5591.    assign_key( "<Alt-F10>",   "compile_buffer" )
  5592.  
  5593.    #  electric-c template expansion keys
  5594.    assign_key( VI_EXPAND_TEMPLATE_KEY, "beep" )
  5595.    assign_key( VI_NEXT_FIELD_KEY, "beep" ) 
  5596.    
  5597. #  assign_key( "<Shift-F1>",  "smaller_window" )
  5598. #  assign_key( "<Shift-F2>",  "larger_window" )
  5599. #  assign_key( "<Shift-F3>",  "organize_windows" )
  5600. #  assign_key( "<Shift-F4>",  "organize_buffers" )
  5601. #  assign_key( "<Shift-F5>",  )
  5602. #  assign_key( "<Shift-F6>",  )
  5603. #  assign_key( "<Shift-F7>",  "display_errors" )
  5604. #  assign_key( "<Shift-F8>",  "goto_next_error" )
  5605. #  assign_key( "<Shift-F9>",  )
  5606. #  assign_key( "<Shift-F10>", )
  5607.  
  5608.    assign_key( "<Ctrl-F1>",          "display_help_item" )
  5609. #  assign_key( "<Ctrl-F2>",   )
  5610. #  assign_key( "<Ctrl-F3>",   )
  5611. #  assign_key( "<Ctrl-F4>",   )
  5612. #  assign_key( "<Ctrl-F5>",   )
  5613. #  assign_key( "<Ctrl-F6>",   )
  5614. #  assign_key( "<Ctrl-F7>",   )
  5615. #  assign_key( "<Ctrl-F8>",   )
  5616. #  assign_key( "<Ctrl-F9>",   )
  5617. #  assign_key( "<Ctrl-F10>",  )
  5618. }
  5619.  
  5620.   
  5621. local function create_vi_insert_keymaps()
  5622. {
  5623.    # Enable the keymap.  Subsequent mods to the keymap will persist 
  5624.    #  through the end of the session. 
  5625.    # Only one-time initialization should follow this point. 
  5626.  
  5627.    if( vi_insert_keymap > 0 )
  5628.    {
  5629.       current_keymap = vi_insert_keymap 
  5630.    }
  5631.    else if (default_vi_insert_keymap > 0)
  5632.    {
  5633.       current_keymap = vi_insert_keymap = default_vi_insert_keymap
  5634.    }
  5635.    else
  5636.    {
  5637.       current_keymap = vi_insert_keymap = create_keymap( ascii_keymap )
  5638.    
  5639.       # changed the following from process_end to vi_process_end to add
  5640.       # some fail-safe processing.
  5641.       assign_key( "<Esc>",    "vi_process_end" )
  5642.       assign_key( "<Ctrl-]>", "vi_process_end" )      # Esc or Ctrl-]
  5643.       assign_key( "<Ctrl-C>", "vi_process_end" )
  5644.       assign_key( "<Ctrl-@>", "vi_reinsert" )
  5645.       assign_key( "<Ctrl-Enter>",   "vi_insert_nl" )  # Ctrl-J or Ctrl-Enter
  5646.       assign_key( "<Ctrl-J>", "vi_insert_nl" )  # Ctrl-J or Ctrl-Enter
  5647.       assign_key( "<Enter>",  "vi_insert_cr" )  # Ctrl-M or Enter
  5648.    
  5649.       assign_key( "<Backspace>", "vi_insert_bs" )  
  5650.       assign_key( "<Shift-Backspace>", "vi_insert_bs" )  
  5651.       assign_key( "<Ctrl-H>", "vi_insert_bs" )
  5652.    #  assign_key( "#",     "vi_insert_bs" )  # obsolete
  5653.       assign_key( "<Ctrl-W>", "vi_insert_dB" )
  5654.       assign_key( "<Ctrl-U>", "vi_insert_cancel" )
  5655.       assign_key( "<Delete>", "vi_insert_cancel" )
  5656.    
  5657.       assign_key( "<Up>"           ,   "vi_insert_arrow 1" )
  5658.       assign_key( "<Down>"         ,   "vi_insert_arrow 2" )
  5659.       assign_key( "<Left>"         ,   "vi_insert_arrow 3" )
  5660.       assign_key( "<Right>"        ,   "vi_insert_arrow 4" )
  5661.       assign_key( "<Num-Up>"       ,   "vi_insert_arrow 1" )
  5662.       assign_key( "<Num-Down>"     ,   "vi_insert_arrow 2" )
  5663.       assign_key( "<Num-Left>"     ,   "vi_insert_arrow 3" )
  5664.       assign_key( "<Num-Right>"    ,   "vi_insert_arrow 4" )
  5665.       assign_key( "<Home>"         ,   "vi_insert_arrow 5" )
  5666.       assign_key( "<End>"          ,   "vi_insert_arrow 6" )
  5667.       assign_key( "<PageUp>"       ,   "vi_insert_arrow 7" )
  5668.       assign_key( "<PageDown>"     ,   "vi_insert_arrow 8" )
  5669.                                             
  5670.    #  assign_key( "@",     "vi_insert_cancel" ) # obsolete
  5671.       assign_key( "<Ctrl-V>", "vi_insert_quoted" )
  5672.       assign_key( "<Ctrl-D>", "vi_insert_unindent" )
  5673.       assign_key( "<Ctrl-T>", "vi_insert_reindent" )
  5674.       assign_key( "<Space>", "insert_key 32" )
  5675.       assign_key( "<Shift-Space>", "insert_key 32" )
  5676.       
  5677.    #  electric-c template expansion keys
  5678.       assign_key( VI_EXPAND_TEMPLATE_KEY,     "expand_template_key" )
  5679.       assign_key( VI_NEXT_FIELD_KEY,   "next_field_key" )  # Ctrl-J or Ctrl-Enter
  5680.    #  assign_key( "<Space>", "vi_expand_template" )
  5681.    #  assign_key( "<Tab>",      "vi_expand_template" )
  5682.    #this was Enter
  5683.    #  assign_key( "<Ctrl-X>",   "vi_expand_template" )
  5684.    
  5685.       default_vi_insert_keymap = create_keymap( vi_insert_keymap )
  5686.    }
  5687. }
  5688.  
  5689. # This function will restore the menu and toolbar functions after VI
  5690. # has messed them up
  5691. # 
  5692. function restore_id()
  5693. {
  5694.    local tbhand = toolbar_info(0);
  5695.  
  5696.    local undo   = "undo"
  5697.    local redo   = "redo"
  5698.    local cut    = "delete_to_scrap"
  5699.    local copy   = "copy_to_scrap_key"
  5700.    local paste  = "insert_scrap"
  5701.    
  5702.    menu_functions[IDM_UNDO]  = undo
  5703.    menu_functions[IDM_REDO]  = redo
  5704.    menu_functions[IDM_CUT]   = cut
  5705.    menu_functions[IDM_COPY]  = copy
  5706.    menu_functions[IDM_PASTE] = paste
  5707.    
  5708.    menu_functions[POP_CUT]   = cut
  5709.    menu_functions[POP_COPY]  = copy 
  5710.    menu_functions[POP_PASTE] = paste
  5711.  
  5712.    if ( tbhand )
  5713.    {
  5714.       modify_toolbaritem( tbhand,  IDM_UNDO, TI_FUNCTIONID, function_id(undo))
  5715.       modify_toolbaritem( tbhand,  IDM_REDO, TI_FUNCTIONID, function_id(redo))
  5716.       modify_toolbaritem( tbhand,  IDM_CUT, TI_FUNCTIONID, function_id(cut))
  5717.       modify_toolbaritem( tbhand,  IDM_COPY, TI_FUNCTIONID, function_id(copy))
  5718.       modify_toolbaritem( tbhand,  IDM_PASTE, TI_FUNCTIONID, function_id(paste))
  5719.    }
  5720. }
  5721.  
  5722. # this function is used to customize the menu so that the keys you have
  5723. # assigned to do the same thing as the menuitem will show on the menu
  5724. # It should be global and start with the string inside emulation_mode
  5725. function vi_menu() 
  5726. {
  5727.    local tbhand = toolbar_info(0);
  5728.    local menu = menu_info(0, MI_MENUHANDLE);
  5729.  
  5730.    local undo   = "vi_undo"
  5731.    local redo   = "vi_undo"
  5732.    local cut    = "vi_yank 1"
  5733.    local copy   = "vi_Y"
  5734.    local paste  = "vi_P"
  5735.  
  5736.    menu_functions[IDM_UNDO]  = undo
  5737.    menu_functions[IDM_REDO]  = redo
  5738.    menu_functions[IDM_CUT]   = cut
  5739.    menu_functions[IDM_COPY]  = copy 
  5740.    menu_functions[IDM_PASTE] = paste
  5741.    
  5742.    menu_functions[POP_CUT]   = cut
  5743.    menu_functions[POP_COPY]  = copy
  5744.    menu_functions[POP_PASTE] = paste
  5745.  
  5746.    modify_toolbaritem( tbhand,  IDM_UNDO, TI_FUNCTIONID,  function_id(undo))
  5747.    modify_toolbaritem( tbhand,  IDM_REDO, TI_FUNCTIONID,  function_id(redo))
  5748.    modify_toolbaritem( tbhand,  IDM_CUT, TI_FUNCTIONID,   function_id(cut))
  5749.    modify_toolbaritem( tbhand,  IDM_COPY, TI_FUNCTIONID,  function_id(copy))
  5750.    modify_toolbaritem( tbhand,  IDM_PASTE, TI_FUNCTIONID, function_id(paste))
  5751.  
  5752.    if ( menu )
  5753.    {
  5754.       modify_menuitem( menu, IDM_ADDFILE,     MI_KEYSTEXT, ":e filename")
  5755.       modify_menuitem( menu, IDM_INSERTFILE,  MI_KEYSTEXT, ":r")
  5756.       modify_menuitem( menu, IDM_SAVE,        MI_KEYSTEXT, ":w")
  5757.       modify_menuitem( menu, IDM_SAVEAS,      MI_KEYSTEXT, ":w filename")
  5758.       modify_menuitem( menu, IDM_SAVEALL,     MI_KEYSTEXT, "")
  5759.       modify_menuitem( menu, IDM_PRINT,       MI_KEYSTEXT, "")
  5760.       modify_menuitem( menu, IDM_EXIT,        MI_KEYSTEXT, ":q")
  5761.       
  5762.       modify_menuitem( menu, IDM_UNDO,        MI_KEYSTEXT, "u")
  5763.       modify_menuitem( menu, IDM_REDO,        MI_KEYSTEXT, "u")
  5764.       modify_menuitem( menu, IDM_CUT,         MI_KEYSTEXT, "Delete")
  5765.       modify_menuitem( menu, IDM_COPY,        MI_KEYSTEXT, "Y")
  5766.       modify_menuitem( menu, IDM_PASTE,       MI_KEYSTEXT, "P")
  5767.       modify_menuitem( menu, IDM_DELETE,      MI_KEYSTEXT, "d")
  5768.       
  5769.       modify_menuitem( menu, IDM_FIND,        MI_KEYSTEXT, "/")
  5770.       modify_menuitem( menu, IDM_FINDAGAIN,   MI_KEYSTEXT, "n")
  5771.       modify_menuitem( menu, IDM_CHANGE,      MI_KEYSTEXT, "")
  5772.       modify_menuitem( menu, IDM_GOTOLINE,    MI_KEYSTEXT, "(number) G")
  5773.       
  5774.       modify_menuitem( menu, IDM_COMMAND,     MI_KEYSTEXT, "F10")
  5775.       
  5776.       modify_menuitem( menu, IDM_NEXT,        MI_KEYSTEXT, "F3")
  5777.       modify_menuitem( menu, IDM_PREV,        MI_KEYSTEXT, "F4")
  5778.       modify_menuitem( menu, IDM_CLOSE,       MI_KEYSTEXT, "")
  5779.       modify_menuitem( menu, IDM_BUFFERLIST,  MI_KEYSTEXT, "")
  5780.       
  5781.       modify_menuitem( menu, IDM_INDEX,       MI_KEYSTEXT, "F1")
  5782.       modify_menuitem( menu, IDM_KEYWORDHELP, MI_KEYSTEXT, "Ctrl-F1" )
  5783.    }
  5784. }
  5785.