home *** CD-ROM | disk | FTP | other *** search
/ OS/2 Shareware BBS: 5 Edit / 05-Edit.zip / p2demo21.exe / PEL / EMACS.PEL < prev    next >
Text File  |  1995-03-22  |  70KB  |  2,746 lines
  1. # $Header:   P:\source\wmacros\emacs.pev   1.55   22 Mar 1995 11:01:50   PFHJXM0  $
  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.  
  21. #### $Workfile:   emacs.pel  $: Key bindings for emacs compatibility
  22.  
  23. # local variables:
  24.  
  25. local markx;
  26. local marky;
  27. local last_column;
  28. local last_command = 0;
  29. local KILL         = 1;
  30. local VERT         = 2;
  31. local YANK         = 3;
  32. local search_strings;
  33. local search_string_count = 0;
  34. local current_search_string = 0;
  35. local line_prefix = "";
  36. local emacc = 0;
  37. local keymac;
  38. local savedmacs;
  39. local fid, tid;
  40. local NUMKILLBUFFERS = 30;
  41. local killbuffers;
  42. local currentkill=0;
  43. local lastyankx1 = (-1);
  44. local lastyanky1 = (-1);
  45. local lastyankx2 = (-1);
  46. local lastyanky2 = (-1);
  47. local errfile;
  48. local makebuffer = 0;
  49. local em_sta_file = 0;
  50. local em_sta_name = "emem.sta";
  51.  
  52. #  local old_default_buffer_flags;
  53. local old_search_flags;
  54.  
  55. global ctrlxr_keymap;
  56. global ctrlx_keymap;
  57. global emacs_keymap = -1;
  58. global emacs_music = 0;
  59.  
  60. local comments;
  61. local matching;
  62.  
  63. # establish emacs mode:
  64.  
  65. global function emacs()
  66. {
  67.    local prevPauseOnError, first;
  68.  
  69.    if (emulation_mode != "emacs")
  70.    {
  71. #        attach_event_handler(EVENT.EDITOR_RUNNING, function_id("em_change_buffer_flags"));
  72.  
  73.       emulation_mode = "emacs";
  74.       execute_event_handler(EVENT.EMULATION_CHANGED);
  75.       attach_event_handler(EVENT.EMULATION_CHANGED, function_id("emacs_exit"));
  76.       attach_event_handler(EVENT.MOUSE_LEFT_DOWN, function_id("em_mouse_set_mark"));
  77. #        attach_event_handler(EVENT.EMULATION_CHANGED, function_id("em_change_buffer_flags"));
  78.  
  79.       # pause if an error or warning occurs during initialization
  80.       prevPauseOnError = pause_on_error
  81.       pause_on_error   = 1
  82.  
  83. #        old_default_buffer_flags = default_buffer_flags;
  84.       old_search_flags         = search_flags;
  85.       markx = 0;
  86.       marky = 0;
  87.    
  88. #     toggle_dialog(1);
  89.    
  90.       if (!em_read_state())
  91.          emacs_set_keymap()
  92.  
  93. #        default_buffer_flags = 0 + BUFFER_EXPAND_TABS + BUFFER_REAL_SPACE_ONLY \
  94. #                                 + BUFFER_SNAP_TO_EOL + BUFFER_TABS_TO_SPACES;
  95.  
  96.       emacs_menu();
  97.       em_fix_toolbar();
  98.  
  99.       pause_on_error = prevPauseOnError;
  100.    }
  101.  
  102.    return 23;
  103. }
  104.  
  105. global function emacs_set_keymap()
  106. {
  107.    local i, name;
  108.  
  109.    # Enable the keymap.  Subsequent mods to the keymap will persist
  110.    #       through the end of the session.
  111.    # Only one-time initialization should follow this point.
  112.  
  113.    if( emacs_keymap >= 0 )
  114.    {
  115.       current_keymap = emacs_keymap
  116.       return
  117.    }
  118.    else
  119.    {
  120.       em_comments();    # Initialize comment structure array
  121.  
  122.       current_keymap = ctrlxr_keymap   = create_keymap(empty_keymap);
  123.       assign_ctrlxr_keys()
  124.       # assert: ctrlxr_keymap exists and has the C-X r keys mapped to it.
  125.  
  126.       current_keymap = ctrlx_keymap   = create_keymap(empty_keymap);
  127.       assign_ctrlx_keys()
  128.       # assert: ctrlx_keymap exists and has the C-X keys mapped to it.
  129.  
  130.       current_keymap = emacs_keymap = create_keymap(ascii_keymap);
  131.       assign_emacs_keys()
  132.       # assert: emacs_keymap exists and has the emacs keys mapped to it.
  133.  
  134. #     assign_mouse_buttons()
  135.  
  136.       optional_function("local_keys")
  137.  
  138.       for (i = 0; i < NUMKILLBUFFERS; i++)
  139.       {
  140.          name = "killbufer" i "";
  141.          killbuffers[i].bufid = create_buffer( name, name, BUFFER_SYSTEM+BUFFER_NO_UNDO);
  142.       }
  143.       # assert: NUMKILLBUFFERS empty system buffers exist in the killbuffers array.
  144.    }
  145. }
  146.  
  147. #global function em_change_buffer_flags()
  148. #{
  149. # first = current_buffer;
  150. # do {
  151. #    current_buffer = next_buffer();
  152. #    if(!and(buffer_flags, BUFFER_SYSTEM))
  153. #       buffer_flags = default_buffer_flags;
  154. # } while(current_buffer != first);
  155. # 
  156. #}
  157.  
  158. local function em_comments()
  159. {
  160.    comments[".c"]   = "/*  */";
  161.    comments[".h"]   = "/*  */";
  162.    comments[".cpp"] = "// ";
  163.    comments[".hpp"] = "// ";
  164.    comments[".pel"] = "#  ";
  165.    comments[".pas"] = "(*  *)";
  166.  
  167.    matching["("] = ")";
  168.    matching["{"] = "}";
  169.    matching["["] = "]";
  170. }
  171.  
  172. global function emacs_menu()
  173. {
  174.    local prefix;
  175.    local menu = menu_info( 0, MI_MENUHANDLE )
  176.    local temp_array
  177.  
  178.    #  modify what functions are called by the cut, copy and paste functions
  179.  
  180.    if(!(fid[IDM_CUT] || fid[IDM_COPY] || fid[IDM_PASTE]))
  181.    {
  182.  
  183.       fid[IDM_CUT]   = menu_functions[IDM_CUT]
  184.       fid[IDM_COPY]  = menu_functions[IDM_COPY]
  185.       fid[IDM_PASTE] = menu_functions[IDM_PASTE]
  186.  
  187.    }
  188.  
  189.    menu_functions[IDM_CUT]   = "em_kill_region"
  190.    menu_functions[IDM_COPY]  = "em_copy_to_scrap"
  191.    menu_functions[IDM_PASTE] = "em_yank"
  192.  
  193.    if ( menu )
  194.    {
  195.       # add keys to menu that contain non-special-dialog box functions
  196.       
  197.       # set the default keymap
  198.       set_default_keymap( emacs_keymap )
  199.  
  200.       temp_array[ IDM_UNDO    ].mapped =  "em_undo"
  201.       temp_array[ IDM_CUT     ].mapped =  "em_kill_region"
  202.       temp_array[ IDM_COPY    ].mapped =  "em_copy_to_scrap"
  203.       temp_array[ IDM_PASTE   ].mapped =  "em_yank"
  204.       temp_array[ IDM_UPPER   ].mapped =  "em_upper"
  205.       temp_array[ IDM_LOWER   ].mapped =  "em_lower"
  206.       
  207.       temp_array[ IDM_ISEARCH ].mapped = "em_i_search"
  208.       temp_array[ IDM_CHANGE  ].mapped = "em_query_replace"
  209.       
  210.       temp_array[ IDM_COMMAND ].mapped = "em_invoke_function"
  211.       
  212.       prefix = "Ctrl+x-";
  213.       
  214.       temp_array[ IDM_ADDFILE    ] = set_menu_mappings( "em_find_file",    prefix, ctrlx_keymap )
  215.       temp_array[ IDM_INSERTFILE ] = set_menu_mappings( "em_insert_file",  prefix, ctrlx_keymap )
  216.       temp_array[ IDM_SAVE       ] = set_menu_mappings( "em_save_file",    prefix, ctrlx_keymap )
  217.       temp_array[ IDM_SAVEAS     ] = set_menu_mappings( "em_write_file",   prefix, ctrlx_keymap )
  218.       temp_array[ IDM_SAVEALL    ] = set_menu_mappings( "em_save_all",     prefix, ctrlx_keymap )
  219.       temp_array[ IDM_EXIT       ] = set_menu_mappings( "em_exit",         prefix, ctrlx_keymap )
  220.                                                                      
  221.       temp_array[ IDM_UNDO       ] = set_menu_mappings( "em_undo",         prefix, ctrlx_keymap )
  222.       temp_array[ IDM_REDO       ] = set_menu_mappings( "em_redo",         prefix, ctrlx_keymap )
  223.                                                                      
  224.       temp_array[ IDM_GOTOLINE   ] = set_menu_mappings( "em_goto_line",    prefix, ctrlx_keymap )
  225.                                                                      
  226.       temp_array[ IDM_NEXT       ] = set_menu_mappings( "em_next_buffer",  prefix, ctrlx_keymap )
  227.       temp_array[ IDM_PREV       ] = set_menu_mappings( "em_prev_buffer",  prefix, ctrlx_keymap )
  228.       temp_array[ IDM_CLOSE      ] = set_menu_mappings( "em_kill_buffer",  prefix, ctrlx_keymap )
  229.       temp_array[ IDM_BUFFERLIST ] = set_menu_mappings( "em_bufed",        prefix, ctrlx_keymap )
  230.  
  231.       temp_array[ IDM_HSPLIT_WINDOW ] = set_menu_mappings( "em_horizontal_window", prefix, ctrlx_keymap )
  232.       temp_array[ IDM_VSPLIT_WINDOW ] = set_menu_mappings( "em_vertical_window", prefix, ctrlx_keymap )
  233.  
  234.       mapped_menu_functions = temp_array
  235.    }
  236. }
  237.  
  238. global function em_fix_toolbar()
  239. {
  240.    local tbhand;
  241.  
  242.    if ( !( tbhand = toolbar_info(0) ) )
  243.       return FALSE
  244.  
  245.    if(!(tid[IDM_CUT] || tid[IDM_COPY] || tid[IDM_PASTE]))
  246.    {
  247.  
  248.       tid[IDM_CUT]   = toolbar_info(tbhand, TI_FUNCTIONID, IDM_CUT, 1);
  249.       tid[IDM_COPY]  = toolbar_info(tbhand, TI_FUNCTIONID, IDM_COPY, 1);
  250.       tid[IDM_PASTE] = toolbar_info(tbhand, TI_FUNCTIONID, IDM_PASTE, 1);
  251.  
  252.    }
  253.  
  254.    modify_toolbaritem(tbhand, IDM_CUT,   TI_FUNCTIONID, function_id("em_kill_region"));
  255.    modify_toolbaritem(tbhand, IDM_COPY,  TI_FUNCTIONID, function_id("em_copy_to_scrap"));
  256.    modify_toolbaritem(tbhand, IDM_PASTE, TI_FUNCTIONID, function_id("em_yank"));
  257. }
  258.  
  259. ###############################################################################
  260. # pre:  current_keymap == emacs_keymap == ascii_keymap
  261. # post: current_keymap == emacs_keymap == emacs standard keymappings
  262. ###############################################################################
  263. global function assign_emacs_keys()
  264. {
  265.    local i;
  266.  
  267.    for(i = 32; i < 128; i++)                          # perform normal operations
  268.       assign_key(int_to_key(i), "donormal");
  269.  
  270.    # Normal keys that do extra things
  271.  
  272.    assign_key( "]", "paren" );                        # find matching character
  273.    assign_key( "}", "paren" );
  274.    assign_key( ")", "paren" );
  275.  
  276.    # Main keyboard special keys that do extra things
  277.  
  278.    assign_key( "<Backspace>", "em_bksp" );            # delete previous character
  279.    assign_key( "<Enter>",     "em_insert_newline" );  # insert a new line
  280.    assign_key( "<Esc>",       "em_get_arg 0");        # allows user to enter integers into the argument
  281.    assign_key( "<Num-5>",     "em_scroll_window_middle" ); # centers the current window around current line
  282.    
  283.    # Alt (meta) functions
  284.  
  285.    assign_key( "<Alt-Backspace>", "em_delete_prev_word" );    #  
  286.    assign_key( "<Alt-Delete>",    "em_delete_prev_word");     # deletes word to the left
  287.    assign_key( "<Alt-\\>",        "em_remove_white_space" );  #
  288. #   assign_key( "<Alt-,>",         "em_goto_window_top");     # moves cursor to the top of the window
  289.    assign_key( "<Alt-.>",         "em_tags");                 # finds the first occurence of the tag under the cursor
  290. #     assign_key( "<Alt-/>",         "expand_template" );        #
  291.    set_expand_template_key("<Alt-/>");
  292.    assign_key( "<Alt-;>",         "em_start_comment");        # moves cursor to the bottom of the window
  293.  
  294.    assign_key( "<Alt-A>", "em_prev_sentence" );        # goes to the beginning of previous sentence
  295.    assign_key( "<Alt-B>", "em_prev_word" );            # goes to the beginning of word
  296.    assign_key( "<Alt-C>", "em_capitalize" );
  297.    assign_key( "<Alt-D>", "em_delete_next_word");      # deletes word to the right
  298.    assign_key( "<Alt-E>", "em_next_sentence" );        # goes to beginning of next sentence
  299.    assign_key( "<Alt-F>", "em_next_word" );            # goes to the beginning of the next word
  300.    assign_key( "<Alt-H>", "em_mark_paragraph" );       
  301.    assign_key( "<Alt-K>", "em_delete_next_sentence");  # deletes next sentence
  302.    assign_key( "<Alt-L>", "em_lower" );
  303.    assign_key( "<Alt-Q>", "em_wrap_paragraph" );
  304.    assign_key( "<Alt-S>", "em_center" );
  305.    assign_key( "<Alt-T>", "em_transpose_words" );
  306.    assign_key( "<Alt-U>", "em_upper" );
  307.    assign_key( "<Alt-V>", "em_page_up" );              # scrolls the window up one page
  308.    assign_key( "<Alt-W>", "em_copy_to_scrap" );        # copies the marked region to the next kill buffer
  309.    assign_key( "<Alt-X>", "em_invoke_function");       # brings up the command dialog
  310.    assign_key( "<Alt-Y>", "em_yankpop" );
  311.    assign_key( "<Alt-Z>", "em_delete_to_char" );
  312.  
  313.    assign_key( "<Alt-F4>", "em_exit" );
  314.  
  315.    #  alt-shift functions
  316.  
  317.    assign_key( "<Alt-Shift->>", "em_goto_buffer_bottom" );    # moves cursor to the bottom of the buffer
  318.    assign_key( "<Alt-Shift-<>", "em_goto_buffer_top"); # moves cursor to the top of the buffer
  319.    assign_key( "<Alt-Shift-{>", "em_prev_paragraph");  # moves cursor to the previous blank line
  320.    assign_key( "<Alt-Shift-}>", "em_next_paragraph");  # moves cursor to the next blank line
  321.    assign_key( "<Alt-Shift-%>", "em_query_replace");   # moves cursor to the next blank line
  322.    assign_key( "<Alt-Shift-!>", "em_shell" );              
  323.    assign_key( "<Alt-Shift-|>", "em_filter" );              
  324.    assign_key( "<Alt-Shift-@>", "em_set_far_mark" );              
  325.  
  326.    # normal control keys
  327.    assign_key( "<Ctrl-A>", "em_goto_bol" );            # move to beginning of the current line
  328.    assign_key( "<Ctrl-B>", "em_prev_char" );           # move to the previous character in the buffer
  329.    assign_key( "<Ctrl-D>", "em_delete_chars" );        # delete character to the right
  330.    assign_key( "<Ctrl-E>", "em_goto_eol" );            # move to the end of the current line
  331.    assign_key( "<Ctrl-F>", "em_next_char" );           # move to the next character in the buffer
  332.    assign_key( "<Ctrl-G>", "em_cancel" );              # cancels command and restores emacs keymap
  333.    assign_key( "<Ctrl-H>", "em_help" );                # pull up the help index
  334.    assign_key( "<Ctrl-K>", "em_kill_to_eol" );         # kills to end of line
  335.    assign_key( "<Ctrl-L>", "em_scroll_window_middle" ); # scrolls the current line to the center of the screen
  336.    assign_key( "<Ctrl-N>", "em_down" );                # moves the cursor down one line
  337.    assign_key( "<Ctrl-O>", "em_open_line" );           # inserts a new line after the cursor
  338.    assign_key( "<Ctrl-P>", "em_up" );                  # moves the cursor up one line
  339.    assign_key( "<Ctrl-R>", "em_i_search" );            # reverse incremental search
  340.    assign_key( "<Ctrl-S>", "em_i_search" );            # forward incremental search
  341.    assign_key( "<Ctrl-T>", "em_transpose_characters" ); # transposes the two characters following the cursor
  342.    assign_key( "<Ctrl-U>", "em_quad_arg" );            # multiply the argument by 4
  343.    assign_key( "<Ctrl-V>", "em_page_down" );           # scrolls to next page down
  344.    assign_key( "<Ctrl-W>", "em_kill_region" );         
  345.    assign_key( "<Ctrl-X>", "ctrlx" );                  # invoke C-X key map
  346.    assign_key( "<Ctrl-Y>", "em_yank" );                # yanks last thing killed
  347.    assign_key( "<Ctrl-Z>", "em_iconify");              # minimize the editor
  348.    assign_key( "<Ctrl-1>", "em_redraw" );              # redraws the current screen
  349.    assign_key( "<Ctrl-2>", "em_revert_buffer" );       # restores the buffer to its original contents
  350.    assign_key( "<Ctrl-Shift-@>", "em_set_mark" );      # set mark 
  351.    assign_key( "<Ctrl-Shift-_>", "em_undo");           # undoes the previous edit
  352.    assign_key( "<Ctrl-Space>", "em_set_column_mark" ); # set mark
  353.  
  354.    # ctrl function keys
  355.  
  356.    assign_key( "<Ctrl-F1>", "display_help_item" );
  357.  
  358.    # ctrl-alt keys
  359.  
  360.    assign_key("<Ctrl-Alt-A>", "em_prev_function");    # move to the previous function
  361.    assign_key("<Ctrl-Alt-E>", "em_next_function");    # moce to the next function
  362.    assign_key("<Ctrl-Alt-H>", "em_mark_function");    # mark a function
  363.    assign_key("<Ctrl-Alt-K>", "em_kill_to_bol");      # kills from the current position to beginning of line
  364.    assign_key("<Ctrl-Alt-R>", "em_i_search");         # invokes reverse regular expression incremental search
  365.    assign_key("<Ctrl-Alt-S>", "em_i_search");         # invokes regular expression incremental search
  366.    assign_key("<Ctrl-Alt-Shift-@>", "em_mark_sexp");  # marks an s expression
  367.  
  368.    # normal function keys
  369. #  assign_key( "<F1>", "em_help" );
  370.    assign_key( "<F2>", "expand_template" );
  371.    assign_key( "<F4>", "bind_to_key" );
  372.    assign_key( "<F6>", "whatiskey" );                 # find what function is bound to a key
  373.    assign_key( "<F7>", "em_cd" );                     # change directories
  374. #     assign_key( "<F8>", "em_get_arg 0"); #setvar" );
  375.    assign_key( "<F9>", "em_undo" );
  376.    assign_key( "<F10>", "em_redo" );
  377.  
  378.    # normal cursor keys
  379.    assign_key( "<Home>",     "em_goto_window_top" );
  380.    assign_key( "<End>",      "em_goto_window_bottom" );
  381.    assign_key( "<Left>",     "em_prev_char" );
  382.    assign_key( "<PageDown>", "em_page_down" );
  383.    assign_key( "<PageUp>",   "em_page_up" );
  384.    assign_key( "<Right>",    "em_next_char" );
  385.    assign_key( "<Up>",       "em_up" );
  386.    assign_key( "<Down>",     "em_down" );
  387.    assign_key( "<Insert>",   "em_toggle_insert_mode" );
  388.    assign_key( "<Delete>",   "em_delete_chars" );
  389.    assign_key( "<Tab>",      "em_indent_tab_maybe" );
  390. }
  391.  
  392. ################################################################################
  393. #
  394. ################################################################################
  395. global function assign_ctrlx_keys()
  396. {
  397.    assign_key( "<Delete>", "em_delete_prev_sentence" );  # deletes the sentence before the cursor
  398.    assign_key( "<Backspace>", "em_delete_prev_sentence" );  # deletes the sentence before the cursor
  399.  
  400.    assign_key( "<Ctrl-B>", "em_bufed" );              # displays the buffer list
  401.    assign_key( "<Ctrl-C>", "em_exit" );               # exits the editor
  402. #??   assign_key( "<Ctrl-E>", "em_push" );
  403.    assign_key( "<Ctrl-F>", "em_find_file" );          # loads a buffer from a file
  404.    assign_key( "<Ctrl-G>", "em_cancel" );             # cancels command and restores emacs keymap
  405. #??   assign_key( "<Ctrl-I>", "em_indent_rigidly" );
  406.    assign_key( "<Ctrl-L>", "em_lower_region" );                 #  lower cases region
  407.    assign_key( "<Ctrl-M>", "em_start_process" );
  408. #??   assign_key( "<Ctrl-N>", "em_next_error" );
  409. #??   assign_key( "<Ctrl-O>", "em_delete_blank_lines" );
  410.    assign_key( "<Ctrl-S>", "em_save_file" );          # saves the current buffer to disk
  411.    assign_key( "<Ctrl-T>", "em_transpose_lines" );    # transposes current line with line above
  412.    assign_key( "<Ctrl-U>", "em_upper_region" );                 # upper cases region
  413.    assign_key( "<Ctrl-V>", "em_replace" );            # replace buffer with specified file
  414.    assign_key( "<Ctrl-W>", "em_write_file" );         # writes buffer to file
  415.    assign_key( "<Ctrl-X>", "em_exchange_point_and_mark" ); # echanges point and mark
  416. #??   assign_key( "<Ctrl-Z>", "em_exit" );
  417.  
  418.  
  419.    assign_key( "(", "em_start_kbd_macro" );           # starts recording a macro
  420.    assign_key( ")", "em_end_kbd_macro" );             # stops recording a macro
  421.    assign_key( "[", "em_page_up" );                   # move back in the the buffer by one page
  422.    assign_key( "]", "em_page_down" );                 # move forward in the the buffer by one page
  423.    assign_key( "0", "em_delete_window" );             # deletes the current window
  424.    assign_key( "1", "em_one_window" );                # makes the current window the only 
  425.    assign_key( "2", "em_horizontal_window" );         # splits the current window in two horizontally
  426.    assign_key( "3", "em_vertical_window" );           # splits the current window in two vertically
  427.    assign_key( "=", "em_show_point" );
  428.    assign_key( "<", "em_scroll_right" );              # scroll window right
  429.    assign_key( ">", "em_scroll_left" );               # scroll window left
  430.    assign_key( ".", "em_set_line_prefix" );           # sets the string that prefixes each new line
  431.    assign_key( "b", "em_bufed" );                     # invoke buffer list
  432.    assign_key( "e", "em_last_kbd_macro" );            # play last keyboard macro
  433.    assign_key( "f", "em_set_fill_column" );
  434.    assign_key( "g", "em_goto_line" );                 # go to specified line number
  435.    assign_key( "h", "em_mark_buffer" );               # mark entire buffer
  436.    assign_key( "i", "em_insert_file" );               # unserts a file into the current buffer
  437.    assign_key( "j", "em_redo" );                      # redoes the last undo
  438.    assign_key( "k", "em_kill_buffer" );               # delete the buffer from the buffer list
  439.    assign_key( "l", "em_count_lines" );
  440.    assign_key( "n", "em_next_buffer" );               # make next buffer current
  441.    assign_key( "o", "em_next_window" );               # make next window current
  442.    assign_key( "p", "em_prev_buffer" );               # make previous buffer current
  443.    assign_key( "r", "em_ctrlxr" );                    # switch to the ctrlxr keymap
  444.    assign_key( "s", "em_save_all" );                  # saves all buffers to disk
  445.    assign_key( "u", "em_undo" );                      # undoes the previous edit      
  446.    assign_key( "w", "em_write_region" );              # write the specified region to disk
  447.  
  448.    assign_key( "B", "em_bufed" );
  449.    assign_key( "E", "em_last_kbd_macro" );
  450.    assign_key( "F", "em_set_fill_column" );
  451.    assign_key( "G", "em_goto_line" );                 # go to specified line number
  452.    assign_key( "H", "em_mark_buffer" );
  453.    assign_key( "I", "em_insert_file" );               # unserts a file into the current buffer
  454.    assign_key( "J", "em_redo" );                      # redoes the last undo
  455.    assign_key( "K", "em_kill_buffer" );
  456.    assign_key( "L", "em_count_lines" );
  457.    assign_key( "N", "em_next_buffer" );
  458.    assign_key( "O", "em_next_window" );
  459.    assign_key( "P", "em_prev_buffer" );
  460.    assign_key( "R", "em_ctrlxr" );
  461.    assign_key( "S", "em_save_all" );                  # saves all buffers to disk
  462.    assign_key( "U", "em_undo" );                      # undoes the previous edit      
  463.    assign_key( "W", "em_write_region" );
  464.  
  465.    assign_key( "<Alt-N>", "name_last_kbd_macro" );
  466.    assign_key( "<Esc>", "em_cancel" );
  467.  
  468.    assign_key( "<F6>", "whatiskey" );
  469.  
  470. #   assign_key( "<Esc>b", "em_bufed" );
  471. #   assign_key( "<Esc>n", "name_macro" );
  472. }
  473.  
  474. global function assign_ctrlxr_keys()
  475. {
  476.    assign_key( "b", "em_clear_rectangle" );           # clears the defined rectangle
  477.    assign_key( "k", "em_rect_kill" );                 # kills rectangle to current killbuffer
  478.    assign_key( "o", "em_rect_open" );                 # shifts rectangle right by the width of the rectangle
  479.    assign_key( "p", "em_string_rectangle" );          # prefixes each line of the rectangle with the prompted string
  480.    assign_key( "r", "em_rect_copy_to_register" );
  481.    assign_key( "y", "em_rect_yank" );
  482.  
  483.    assign_key( "B", "em_clear_rectangle" );           # clears the defined rectangle
  484.    assign_key( "K", "em_rect_kill" );                 # kills rectangle to current killbuffer
  485.    assign_key( "O", "em_rect_open" );                 # shifts rectangle right by the width of the rectangle
  486.    assign_key( "P", "em_string_rectangle" );          # prefixes each line of the rectangle with the prompted string
  487.    assign_key( "R", "em_rect_copy_to_register" );
  488.    assign_key( "Y", "em_rect_yank" );
  489.    assign_key( "<Ctrl-G>", "em_cancel" );             # cancels command and restores emacs keymap
  490.    assign_key( "<Esc>", "em_cancel" );
  491.  
  492.    assign_key( "<F6>", "whatiskey" );
  493. }
  494.  
  495. global function em_always(command, new_message)
  496. {
  497.    local val, msg, response;
  498.  
  499.    while(current_keymap != emacs_keymap)
  500.       pop_keymap();
  501.  
  502.    last_command = command;
  503.  
  504.    val = em_num();
  505.    if(val > 100)
  506.    {
  507.       msg = sprintf("Argument is very large (%d).  Are you sure you want to use it [yn]?", val);
  508.       response = confirm(msg, "YyNn");
  509.       if(tolower(response) == "n")
  510.          val = 1;
  511.    }
  512.  
  513.    if((last_message != " ") || (!new_message))
  514.       message(" ");
  515.    else
  516.       message(new_message);
  517.  
  518.    return val;
  519. }
  520.  
  521. global function ctrlx()
  522. {
  523.    message("C-X ");
  524.    push_keymap(ctrlx_keymap);
  525. }
  526.  
  527. global function em_ctrlxr()
  528. {
  529.    message("C-X r");
  530.    push_keymap(ctrlxr_keymap);
  531. }
  532.  
  533. ###############################################################################
  534. # post: if (last_command == KILL) em_num lines, including the current line from
  535. #     the current position is the last block in the current kill buffer and are
  536. #     removed from the current buffer.
  537. #     if !(last_was_kill == KILL) em_num lines, including the current line from
  538. #     the current position is the only block in the current kill buffer and are
  539. #     removed from the current buffer.
  540. ###############################################################################
  541. global function em_kill_to_bol()
  542. {
  543.    local normal, last = last_command;
  544.  
  545.    save_position();
  546.    begin_selection(NORMAL_SELECTION);
  547.  
  548.    if(emacc)
  549.       up(em_always(KILL) - 1);
  550.    else
  551.       em_always(KILL);
  552.  
  553.    normal = goto_bol();
  554.    if (last == KILL)
  555.    {
  556.       em_append_to_scrap(!normal);
  557.       if(!normal)
  558.          delete_chars();
  559.    }
  560.    else
  561.       em_delete_to_scrap();
  562.    restore_position(TRUE);
  563.    end_selection();
  564. }
  565.  
  566. ###############################################################################
  567. # post: if (last_command == KILL) em_num lines, including the current line from
  568. #     the current position is the last block in the current kill buffer and are
  569. #     removed from the current buffer.
  570. #     if !(last_was_kill == KILL) em_num lines, including the current line from
  571. #     the current position is the only block in the current kill buffer and are
  572. #     removed from the current buffer.
  573. ###############################################################################
  574. global function em_kill_to_eol()
  575. {
  576.    local normal, last = last_command;
  577.  
  578.    save_position();
  579.    begin_selection(NORMAL_SELECTION);
  580.  
  581.    if(emacc)
  582.       down(em_always(KILL) - 1);
  583.    else
  584.       em_always(KILL);
  585.  
  586.    normal = goto_eol();
  587.    if (last == KILL)
  588.    {
  589.       em_append_to_scrap(!normal);
  590.       if(!normal)
  591.          delete_chars();
  592.    }
  593.    else
  594.       em_delete_to_scrap();
  595.  
  596.    restore_position(TRUE);
  597.    end_selection();
  598. }
  599.  
  600. global function em_kill_region()
  601. {
  602.    if (last_command == KILL)
  603.       em_append_to_scrap();
  604.    else
  605.       em_delete_to_scrap();
  606.  
  607.    end_selection();
  608.    em_always(KILL, "Region killed");
  609. }
  610.  
  611. global function em_delete_next_word()
  612. {
  613.    local last = last_command;
  614.  
  615.    begin_selection(NORMAL_SELECTION);
  616.  
  617.    next_word(em_always(), ">");
  618.  
  619.    if (last == KILL)
  620.       em_append_to_scrap();
  621.    else em_delete_to_scrap();
  622.  
  623.    end_selection();
  624.  
  625.    last_command = KILL;
  626. }
  627.  
  628. local function massage_string(instr, direction, regex)
  629. {
  630.    local outstr = instr;
  631.  
  632.    if(!regex)
  633.       outstr = quote_regex(instr);
  634.  
  635.    if(direction)
  636.       outstr = outstr "\\c"
  637.  
  638.    return outstr;
  639. }
  640.  
  641. global function em_i_search()
  642. {
  643.    local   ch,
  644.            savex, savey,
  645.            char,
  646.            key_to_do,
  647.            found,
  648.            search_name,
  649.            old_current_search_string = current_search_string,
  650.            ESC          = key_to_int("<Esc>"),
  651.            RET          = key_to_int("<Enter>"),
  652.            BKSP         = key_to_int("<Backspace>"),
  653.            CTRLR        = key_to_int("<Ctrl-R>"),
  654.            CTRLS        = key_to_int("<Ctrl-S>"),
  655.            CTRLG        = key_to_int("<Ctrl-G>"),
  656.            CAR          = key_to_int("<Ctrl-Alt-R>"),
  657.            CAS          = key_to_int("<Ctrl-Alt-S>"),
  658.            MN           = key_to_int("<Alt-N>"),
  659.            MP           = key_to_int("<Alt-P>"),
  660.            level        = 0,
  661.            pattern      = "",
  662.            spattern     = "",
  663.            dokey        = FALSE,
  664.            direction    = 1,
  665.            finished     = FALSE,
  666.            wrap         = FALSE,
  667.            regex        = FALSE,
  668.            restore      = FALSE,
  669.            flags        = SEARCH_MAXIMAL_MATCH + SEARCH_FORWARD + SEARCH_REGEX
  670.  
  671.    em_always();
  672.    search_name[0] = "Reverse I-Search";
  673.    search_name[1] = "I-Search";
  674.  
  675.    #  Set the direction and determine regular expressions for the search;
  676.    if((current_key == CTRLR) || (current_key == CAR))
  677.    {
  678.       direction = 0;
  679.       flags = and(flags,not(SEARCH_FORWARD));
  680.    }
  681.    if((current_key == CAR) || (current_key == CAS))
  682.       flags = or(flags, SEARCH_REGEX);
  683.  
  684.    message(search_name[direction] " for:");
  685.    save_position();
  686.    while (!finished)
  687.    {
  688.       ch = getkey();
  689.  
  690.       if (ch == BKSP)
  691.       {
  692. #         if (level) {
  693. #            restore_position(TRUE);
  694. #            restore_position(TRUE);
  695. #            level --;
  696. #            save_position();
  697. #         }
  698. #         if(direction)
  699. #            prev_char(length(pattern));
  700. #         else
  701. #            next_char(length(pattern));
  702. #         pattern = substr( pattern, 0, length( pattern ) - 1)
  703. #
  704. #         spattern = massage_string(pattern, direction, regex);
  705. #
  706. #         if (search(spattern, flags)) {
  707. #            message(search_name[direction] " for: %s",pattern);
  708. #            save_position();
  709. #            level++;
  710. #         }
  711. #         else {
  712. #            message("Failing " search_name[direction] " for: %s",pattern);
  713. #            restore_position(TRUE);
  714. #            save_position();
  715. #         }
  716.  
  717.          savex = current_column;
  718.          savey = current_line;
  719.          if (level)
  720.          {
  721.             restore_position(TRUE);
  722.             level --;
  723.          }
  724.          if(direction)
  725.             prev_char(length(pattern));
  726.          else
  727.             next_char(length(pattern));
  728.          pattern = substr( pattern, 0, length( pattern ) - 1)
  729.  
  730.          spattern = massage_string(pattern, direction, regex);
  731.  
  732.          if (search(spattern, flags))
  733.          {
  734.             message(search_name[direction] " for: %s",pattern);
  735.             save_position();
  736.             level++;
  737.          }
  738.          else
  739.          {
  740.             message("Failing " search_name[direction] " for: %s",pattern);
  741.             goto_pos(savey, savex);
  742.             save_position();
  743.             level++
  744.          }
  745.       }
  746.  
  747.       else if((ch == CTRLS) || (ch == CTRLR) || (ch == CAR) || (ch == CAS))
  748.       {
  749.          if (pattern == "")
  750.              pattern = search_strings[current_search_string];
  751. #               pattern = search_strings[(current_search_string + search_string_count - 1) % search_string_count];
  752.  
  753.          direction = ((ch == CTRLS) || (ch == CAS));
  754.          regex     = ((ch == CAS)   || (ch == CAR));
  755.  
  756.          spattern = massage_string(pattern, direction, regex);
  757.  
  758.          if(direction)
  759.          {
  760.             flags = or(flags, SEARCH_FORWARD);
  761.             found = search(spattern, flags);
  762.          }
  763.          else
  764.          {
  765.             flags = and(flags, not(SEARCH_FORWARD));
  766.             found = search(spattern, flags+SEARCH_ADVANCE);
  767.          }
  768.  
  769.          if(found)
  770.          {
  771.             if(wrap)
  772.             {
  773.                message("Wrapped " search_name[direction] " for: %s",pattern);
  774.                wrap = FALSE;
  775.                flags = and(flags, not(SEARCH_WRAPS));
  776.             }
  777.             else
  778.                message(search_name[direction] " for: %s",pattern);
  779.  
  780.             save_position();
  781.             level++;
  782.          }
  783.          else
  784.          {
  785.             if(!wrap)
  786.             {
  787.                wrap = TRUE;
  788.                flags = or(flags, SEARCH_WRAPS);
  789.                message("Failing " search_name[direction] " for: %s",pattern);
  790.             }
  791.             else
  792.             {
  793.                wrap = FALSE;
  794.                flags = and(flags, not(SEARCH_WRAPS));
  795.                message("Failing Wrapped " search_name[direction] " for: %s",pattern);
  796.             }
  797.          }
  798.       }
  799.       else if(ch == MN)
  800.       {
  801.          current_search_string++;
  802.          if(current_search_string >= search_string_count)
  803.             current_search_string = 0;
  804.          pattern = search_strings[current_search_string];
  805.          message("Pattern: " search_strings[current_search_string]);
  806.       }
  807.       else if(ch == MP)
  808.       {
  809.          current_search_string--;
  810.          if(current_search_string < 0)
  811.             current_search_string = search_string_count - 1;
  812.          pattern = search_strings[current_search_string];
  813.          message("Pattern: " search_strings[current_search_string]);
  814.       }
  815.       else if(ch == CTRLG)
  816.       {
  817.          finished = TRUE;
  818.          restore  = TRUE;
  819.          current_search_string = old_current_search_string;
  820.       }
  821.       else if(ch == RET)
  822.       {
  823.          finished = TRUE;
  824.       }
  825.       else if (isprint( chr(int_to_ascii(ch) )) )
  826.       {
  827.          char     = chr(int_to_ascii(ch));
  828.          pattern  = pattern char;
  829.          spattern = massage_string(pattern, direction, regex);
  830.          current_search_string = search_string_count;
  831.  
  832.          if(direction)
  833.             prev_char(length(pattern) - 1);
  834.          else
  835.             next_char(length(pattern));
  836.  
  837.          if (search(spattern, flags))
  838.          {
  839.             message(search_name[direction] " for: %s",pattern);
  840.             level++;
  841.          }
  842.          else
  843.          {
  844.             restore_position(TRUE);
  845. #            save_position();
  846. #            level++;
  847.             message("Failing " search_name[direction] " for: %s",pattern);
  848.          }
  849.          save_position();
  850.       }
  851.       else
  852.       {
  853.           finished = TRUE;
  854. #         message("key not recognized");
  855.          dokey = TRUE;
  856.          key_to_do = ch;
  857.       }
  858.       display_update();
  859. #      message(spattern);
  860.    }
  861. # This is commented out while I try to find the goofy character bug.
  862.    while (level)
  863.    {
  864.       restore_position(FALSE);
  865.       level --;
  866.    }
  867.    restore_position(restore);
  868.    if( (!restore) && (pattern != "") && 
  869.        (current_search_string == search_string_count) )
  870.    {
  871.       search_strings[search_string_count] = pattern;
  872.       search_string_count++;
  873. #        message("getting here");
  874. #         message("ss[css] = " search_strings[search_string_count-1]);
  875.    }
  876.    message("Search complete.");
  877.  
  878.    if (dokey)
  879.       invoke_function(keymap_binding(int_to_key(key_to_do)));
  880. #execute_key_action(int_to_key(key_to_do));
  881. }
  882.  
  883. global function em_iconify()
  884. {
  885.    em_always();
  886.    set_editwin_property(EWC_MINIMIZE);
  887. }
  888.  
  889. global function em_redraw()
  890. {
  891.    em_always();
  892.    display_redraw();
  893.    message("Window redrawn");
  894. }
  895.  
  896. global function em_revert_buffer()
  897. {
  898.    em_always();
  899.  
  900.    if(undo_index())
  901.    {
  902.       undo(1);  #  this is done to preserve the first cursor movement performed by the config file
  903.       if(and(buffer_flags, BUFFER_MODIFIED))
  904.          undo();
  905.    }
  906.  
  907.    message("Buffer restored");
  908. }
  909.  
  910. global function em_mouse_set_mark()
  911. {
  912.    em_always();
  913.  
  914.    marky = current_line;
  915.    markx = current_column;
  916.  
  917.    message("Mark set");
  918. }
  919.  
  920. global function em_set_far_mark()
  921. {
  922.    marky = current_line;
  923.    markx = current_column;
  924.    save_position();
  925.    em_next_word();
  926.    begin_selection(NORMAL_SELECTION);
  927.    restore_position(TRUE);
  928.  
  929.    em_always();
  930.  
  931.    message("Mark set");
  932. }
  933.  
  934. global function em_set_mark()
  935. {
  936.    em_always();
  937.  
  938.    marky = current_line;
  939.    markx = current_column;
  940.    begin_selection(NORMAL_SELECTION);
  941.  
  942.    message("Mark set");
  943. }
  944.  
  945. global function em_set_column_mark()
  946. {
  947.    em_always();
  948.  
  949.    marky = current_line;
  950.    markx = current_column;
  951.    set_column_mark();
  952.    message("Column mark set");
  953. }
  954.  
  955. global function em_unset_mark()
  956. {
  957.    em_always();
  958.    marky = 0;
  959.    markx = 0;
  960.    end_selection();
  961.    remove_selection();
  962.  
  963.    message("Mark unset");
  964. }
  965.  
  966. global function em_next_word()
  967. {
  968.    next_word(em_always());
  969. }
  970.  
  971. global function em_prev_word()
  972. {
  973.    prev_word(em_always());
  974. }
  975.  
  976. global function em_transpose_characters()
  977. {
  978.    local char, goleft;
  979.  
  980.    em_always();
  981.    if (current_line_length < 2)
  982.       return;
  983.  
  984.    goleft = !left(1);
  985.    char = read_buffer(1);
  986.    delete_chars(1);
  987.    right(1);
  988.    insert_string(char);
  989.    left(1);
  990.    if (goleft) left(1);
  991. }
  992.  
  993. global function em_delete_prev_word()
  994. {
  995.    local count = em_num();
  996.  
  997.    begin_selection(NORMAL_SELECTION);
  998.  
  999.    prev_word(count);
  1000.  
  1001.    if (last_command == KILL)
  1002.       em_append_to_scrap();
  1003.  
  1004.    else
  1005.       em_delete_to_scrap();
  1006.  
  1007.    end_selection();
  1008.  
  1009.    em_always(KILL);
  1010. }
  1011.  
  1012. global function em_delete_prev_sentence()
  1013. {
  1014.    local count = em_num();
  1015.  
  1016.    begin_selection(NORMAL_SELECTION);
  1017.  
  1018.    prev_sentence(count);
  1019.  
  1020.    end_selection();
  1021.  
  1022.    if (last_command == KILL)
  1023.       em_append_to_scrap();
  1024.  
  1025.    else
  1026.       em_delete_to_scrap();
  1027.  
  1028.  
  1029.    em_always(KILL);
  1030. }
  1031.  
  1032. global function em_capitalize()
  1033. {
  1034.    local count;
  1035.  
  1036.    count = em_always();
  1037.    do
  1038.    {
  1039.       capitalize();
  1040.       next_word();
  1041.       count--;
  1042.    } while(count > 0);
  1043. }
  1044.  
  1045. global function em_upper()
  1046. {
  1047.    save_position();
  1048.    begin_selection(NORMAL_SELECTION);
  1049.  
  1050.    next_word(em_always());
  1051.  
  1052.    upper();
  1053.  
  1054.    restore_position(TRUE);
  1055. }
  1056.  
  1057. global function em_upper_region()
  1058. {
  1059.    em_always();
  1060.  
  1061.    upper();
  1062. }
  1063.  
  1064. global function em_delete_next_sentence()
  1065. {
  1066.    begin_selection(NORMAL_SELECTION);
  1067.  
  1068.    next_sentence(em_num());
  1069.  
  1070.    em_kill_region();
  1071.  
  1072.    message("Sentence deleted");
  1073. }
  1074.  
  1075. global function em_lower()
  1076. {
  1077.    save_position();
  1078.    begin_selection(NORMAL_SELECTION);
  1079.  
  1080.    next_word(em_always());
  1081.  
  1082.    lower();
  1083.  
  1084.    restore_position(TRUE);
  1085. }
  1086.  
  1087. global function em_lower_region()
  1088. {
  1089.    em_always();
  1090.  
  1091.    lower();
  1092. }
  1093.  
  1094. global function em_center()
  1095. {
  1096.    local s,e,c;
  1097.    local ft;
  1098.  
  1099.    em_num();
  1100.  
  1101.    if (and(keyboard_flags,4))
  1102.    {
  1103.       toggle_search_flags( SEARCH_REGEX, TRUE);
  1104.       search_forward();
  1105.       return;
  1106.    }
  1107.  
  1108.    goto_bol();
  1109.    if (!search("[^ \t]",SEARCH_FORWARD+SEARCH_REGEX))
  1110.       return;
  1111.  
  1112.    s = current_column;
  1113.    goto_eol();
  1114.    search("[^ \t]",SEARCH_REGEX);
  1115.    e = current_column;
  1116.    c = 40-((s + e)/2);
  1117.    current_column = s;
  1118.    ft = first_tab_distance();
  1119.    indent_tabs(c/ft);
  1120.    indent_columns(c%ft);
  1121.    last_command = FALSE;
  1122. }
  1123.  
  1124. global function em_remove_white_space()
  1125. {
  1126.    local col = current_column;
  1127.  
  1128.    em_always();
  1129.  
  1130.    search("[^ \t]|^", SEARCH_REGEX);
  1131.  
  1132.    if(!(read_buffer(1) ~ "[ \t]"))
  1133.       next_char();
  1134.  
  1135.    col = (current_column < col) ? current_column : col;
  1136.  
  1137.    begin_selection(NORMAL_SELECTION);
  1138.    search("[^ \t]|$", SEARCH_FORWARD+SEARCH_REGEX);
  1139.    delete_chars();
  1140.  
  1141.    goto_pos(0, col);
  1142. }
  1143.  
  1144. global function em_goto_buffer_top()
  1145. {
  1146.    em_always();
  1147.    goto_buffer_top();
  1148.  
  1149.    message("Top of buffer");
  1150. }
  1151.  
  1152. global function em_goto_buffer_bottom()
  1153. {
  1154.    em_always();
  1155.    goto_buffer_bottom();
  1156.  
  1157.    message("Bottom of buffer");
  1158. }
  1159.  
  1160. global function em_shell()
  1161. {
  1162.    local command;
  1163.  
  1164.    em_always();
  1165.    
  1166.    command = prompt("OS/2 command: ", "" );
  1167.    if(command)
  1168.       system(command);
  1169. }
  1170.  
  1171. global function em_filter()
  1172. {
  1173.    local command, code;
  1174.  
  1175.    em_always();
  1176.    command = prompt_history("XMACRO", "Enter command: ", "", 1, 1, "em_filter_prompt" );
  1177.    if(command)
  1178.    {
  1179.       code  = filter(command);
  1180.       if(!code)
  1181.          message("Command executed successfully");
  1182.       else
  1183.          warning("Command encountered an error.  Return code %d", code);
  1184.    }
  1185.    else
  1186.       message("Command canceled");
  1187. }
  1188.  
  1189. global function bind_to_key()
  1190. {
  1191.    local key, comm, ch;
  1192.  
  1193.    comm = prompt_history("XMACRO", "Bind command: ", "", 1, 1, "em_bind_to_key_prompt" );
  1194.  
  1195.    if (comm != "")
  1196.    {
  1197.       message("To key: ");
  1198.  
  1199.       ch = getkey();
  1200.  
  1201.       if (comm in savedmacs)
  1202.          assign_key(int_to_key(ch), "replay " comm);
  1203.       else
  1204.          assign_key(int_to_key(ch),comm);
  1205.    }
  1206.    em_always();
  1207. }
  1208.  
  1209. global function paren()
  1210. {
  1211.    local i,j, ch;
  1212.  
  1213.    j = em_always();
  1214.  
  1215.    ch = chr(int_to_ascii(current_key));
  1216.    for (i=0; i<j; i++)
  1217.    {
  1218.       insert_string(ch);
  1219.       save_position();
  1220.       prev_char();
  1221.       goto_matching();
  1222.       create_linecol_selection(COLUMN_SELECTION, current_line, current_column, current_line, current_column);
  1223.       play("P1P1P1P1P1");
  1224.       end_selection();
  1225.  
  1226.       if(ch == "}")
  1227.          move_bracket();
  1228.  
  1229.       restore_position(TRUE);
  1230.    }
  1231. }
  1232.  
  1233. global function first_nonwhite()
  1234. {
  1235.    local ch;
  1236.  
  1237.    goto_bol();
  1238.           
  1239.    do
  1240.    {
  1241.       ch = read_buffer(1);
  1242.       if(ch)
  1243.          next_char();
  1244.    } while(((ch == " ") || (ch == "\t")) && (ch != ""));
  1245.  
  1246.    return (ch == "") ? 0 : (current_column - 1);
  1247. }
  1248.  
  1249. local function move_bracket()
  1250. {
  1251.    local start, col = first_nonwhite(), offset = "";
  1252.  
  1253.    restore_position(TRUE);
  1254.    prev_char();
  1255.    start = current_column;
  1256.  
  1257.    if(start < col)
  1258.       offset = strrepeat(" ", col - start);
  1259.  
  1260.    insert_string(offset);
  1261.    next_char();
  1262. }
  1263.  
  1264. global function em_transpose_words()
  1265. {
  1266.    local s1,e1,s2,e2, save1, save2;
  1267.  
  1268.    em_num();
  1269.    next_word();
  1270.    e1 = current_column;
  1271.    prev_word();
  1272.    s1 = current_column;
  1273.    save1 = read_buffer(e1-s1);
  1274.  
  1275.    prev_word();
  1276.  
  1277.    next_word();
  1278.    e2 = current_column;
  1279.    prev_word();
  1280.    s2 = current_column;
  1281.    save2 = read_buffer(e2-s2);
  1282.  
  1283.    current_column = s1;
  1284.    delete_chars(e1-s1);
  1285.    insert_string(save2);
  1286.  
  1287.    current_column = s2;
  1288.    delete_chars(e2-s2);
  1289.    insert_string(save1);
  1290.    last_command = FALSE;
  1291. }
  1292.  
  1293. global function em_mark_paragraph()
  1294. {
  1295.    local i,j;
  1296.  
  1297.    j = em_always();
  1298.    prev_paragraph();
  1299.    em_set_mark();
  1300.    for (i=0; i<j; i++)
  1301.       next_paragraph();
  1302. }
  1303.  
  1304. global function em_query_replace()
  1305. {
  1306.    em_always();
  1307.    sf_replace();
  1308. }
  1309.  
  1310. global function em_delete_chars()
  1311. {
  1312.       delete_chars(em_always());
  1313. }
  1314.  
  1315. global function em_down()
  1316. {
  1317.    local count = em_always(last_command);
  1318.  
  1319.    if(last_command == VERT)
  1320.       goto_pos(current_line + count, last_column);
  1321.    else
  1322.    {
  1323.       last_column = current_column;
  1324.       last_command = VERT;
  1325.       down(count);
  1326.    }
  1327. }
  1328.  
  1329. global function em_insert_newline()
  1330. {
  1331.    local i, j;
  1332.  
  1333.    j = em_always();
  1334.    for (i = 0; i < j; i ++)
  1335.    {
  1336.       auto_indent_cr()
  1337.       insert_string(line_prefix);
  1338.    }
  1339. }
  1340.  
  1341. global function em_open_line()
  1342. {
  1343.    save_position()
  1344.    em_insert_newline()
  1345.    restore_position(TRUE)
  1346. }
  1347.  
  1348. global function em_insert_scrap()
  1349. {
  1350.    local i, j;
  1351.  
  1352.    j = em_always();
  1353.  
  1354.    lastyankx1 = current_column;
  1355.    lastyanky1 = current_line;
  1356.  
  1357.    for (i = 0; i < j; i ++)
  1358.       insert_scrap()
  1359.  
  1360.    lastyankx2 = current_column;
  1361.    lastyanky2 = current_line;
  1362. }
  1363.  
  1364. ###############################################################################
  1365. # pre:  killbuffers[currentkill].bufid exists
  1366. # post: killbuffers[currentkill].bufis is in the current buffer at current_position'
  1367. #     current_position is next character after killbuffers[currentkill]
  1368. ###############################################################################
  1369. global function em_yank()
  1370. {
  1371.    local buffer = current_buffer, 
  1372.          count  = em_always(YANK), i;
  1373.  
  1374.    lastyankx1 = current_column;
  1375.    lastyanky1 = current_line;
  1376.  
  1377.    current_buffer = killbuffers[currentkill].bufid;
  1378.  
  1379.    goto_buffer_top();
  1380.    begin_selection(killbuffers[currentkill].type);
  1381.    goto_buffer_bottom();
  1382.    if(killbuffers[currentkill].type == COLUMN_SELECTION)
  1383.       prev_char();
  1384.  
  1385.    copy_to_scrap();
  1386.    end_selection();
  1387.  
  1388.    current_buffer = buffer;
  1389.  
  1390.    for(i=0; i<count; i++)
  1391.       insert_scrap();
  1392.  
  1393.    lastyankx2 = current_column;
  1394.    lastyanky2 = current_line;
  1395. }
  1396.  
  1397. global function em_next_char()
  1398. {
  1399.    next_char(em_always());
  1400. }
  1401.  
  1402. global function em_next_paragraph()
  1403. {
  1404.    next_paragraph(em_always())
  1405. }
  1406.  
  1407. global function em_next_function()
  1408. {
  1409.    next_section(em_always())
  1410. }
  1411.  
  1412. global function em_next_sentence()
  1413. {
  1414.    next_sentence(em_always());
  1415. }
  1416.  
  1417. global function em_page_down()
  1418. {
  1419.    local i, count;
  1420.  
  1421.    count = em_always();
  1422.  
  1423.    for (i = 0; i < count; i++)
  1424.       page_down()
  1425. }
  1426.  
  1427. global function em_page_up()
  1428. {
  1429.    local i, count;
  1430.  
  1431.    count = em_always();
  1432.  
  1433.    for (i = 0; i < count; i++)
  1434.       page_up()
  1435. }
  1436.  
  1437. global function em_prev_char()
  1438. {
  1439.    prev_char(em_always())
  1440. }
  1441.  
  1442. global function em_prev_paragraph()
  1443. {
  1444.    prev_paragraph(em_always())
  1445. }
  1446.  
  1447. global function em_prev_function()
  1448. {
  1449.    prev_section(em_always())
  1450. }
  1451.  
  1452. global function em_prev_sentence()
  1453. {
  1454.    prev_sentence(em_always())
  1455. }
  1456.  
  1457. global function em_scroll_vertical_up()
  1458. {
  1459.    scroll_vertical(-em_always())
  1460. }
  1461.  
  1462. global function em_scroll_vertical_down()
  1463. {
  1464.    scroll_vertical(em_always())
  1465. }
  1466.  
  1467. global function em_up()
  1468. {
  1469.    local count = em_always(last_command);
  1470.  
  1471.    if(last_command == VERT)
  1472.       goto_pos(max(1, current_line - count), last_column);
  1473.    else
  1474.    {
  1475.       last_column = current_column;
  1476.       last_command = VERT;
  1477.       up(count);
  1478.    }
  1479. }
  1480.  
  1481. global function em_bksp()
  1482. {
  1483.    local i,j;
  1484.  
  1485.    j = em_always();
  1486.    for (i=0; i<j; i++)
  1487.       backspace();
  1488. }
  1489.  
  1490. global function em_num()
  1491. {
  1492.    local i;
  1493.  
  1494.    i = ((emacc) ? emacc : 1);
  1495.    emacc = 0;
  1496.  
  1497.    return i;
  1498. }
  1499.  
  1500. global function em_quad_arg()
  1501. {
  1502.    if (!emacc) emacc++;
  1503.    emacc *= 4;
  1504.    message("Argument %d",emacc);
  1505. }
  1506.  
  1507. global function em_get_arg(n)
  1508. {
  1509.    local   ch;
  1510.  
  1511.    do
  1512.    {
  1513.       emacc *= 10;
  1514.       emacc += n;
  1515.       message("Arg: %d", emacc);
  1516.  
  1517.       ch = getkey();
  1518.       n  = int_to_ascii(ch) - ord("0");
  1519.    } while (isdigit( chr(int_to_ascii(ch))));
  1520.  
  1521.    ungetkey(ch);
  1522. }
  1523.  
  1524. global function donormal()
  1525. {
  1526.    local ch, count = em_always(), note, tune;
  1527.  
  1528.    ch = chr(int_to_ascii(current_key));
  1529.    if(count > 1)
  1530.    {
  1531.       insert_string(strrepeat(ch, count));
  1532.  
  1533.       if(and(buffer_flags, BUFFER_OVERTYPE_MODE))
  1534.       {
  1535.  
  1536.          if((count + current_column) > current_line_width)
  1537.             delete_to_eol();
  1538.          else
  1539.             delete_chars(count);
  1540.       }
  1541.    }
  1542.    else
  1543.       insert_key();
  1544.  
  1545.    if(emacs_music)
  1546.    {
  1547.       note = (( (ord(ch) - 32) * 83 ) / 95) + 16;
  1548.       tune = "L16N" note;
  1549.       message(tune); 
  1550.       play(tune);
  1551.    }
  1552. }
  1553.  
  1554. global function em_cd()
  1555. {
  1556.    em_always();
  1557.    chdir(prompt_history("EDITFILE", "Change directory to: ", getcwd(), 1, 1, "em_cd_dialog" ));
  1558. }
  1559.  
  1560. global function em_help()
  1561. {
  1562.    em_always();
  1563.    gui_help_index();
  1564. }
  1565.  
  1566. global function em_delete_to_char()
  1567. {
  1568.    local ch;
  1569.  
  1570.    em_always();
  1571.    message("Enter search character: ");
  1572.    ch = chr(int_to_ascii(getkey()));
  1573.    save_position();
  1574.    begin_selection(NORMAL_SELECTION);
  1575.  
  1576.    if(search(ch, SEARCH_FORWARD+SEARCH_CASE))
  1577.    {
  1578.       em_kill_region();
  1579.  
  1580.       message("Text deleted");
  1581.    }
  1582.    else
  1583.       message("Character not found");
  1584.    restore_position(TRUE);
  1585.          end_selection();
  1586. }
  1587.  
  1588. global function em_invoke_function()
  1589. {
  1590.    local comm;
  1591.  
  1592.    em_always();
  1593.  
  1594.    comm = prompt_history("XMACRO","Command: ","em_", 1, 1, "command" );
  1595.  
  1596.    if (comm in savedmacs)
  1597.       replay(comm);
  1598.    else if(comm)
  1599.       invoke_function(comm);
  1600. }
  1601.  
  1602. global function em_redo()
  1603. {
  1604.    em_always();
  1605.    redo();
  1606. }
  1607.  
  1608. global function em_scroll_window_middle()
  1609. {
  1610.    em_always();
  1611.    scroll_window_middle();
  1612. }
  1613.  
  1614. global function em_toggle_insert_mode()
  1615. {
  1616.    em_always();
  1617.    toggle_buffer_flags( BUFFER_OVERTYPE_MODE );
  1618. }
  1619.  
  1620. global function em_undo()
  1621. {
  1622.    em_always();
  1623.    undo();
  1624. }
  1625.  
  1626. global function em_goto_bol()
  1627. {
  1628.    em_always();
  1629.    goto_bol();
  1630. }
  1631.  
  1632. global function em_goto_eol()
  1633. {
  1634.    em_always();
  1635.    goto_eol();
  1636. }
  1637.  
  1638. global function em_goto_window_bottom()
  1639. {
  1640.    em_always();
  1641.    goto_window_bottom();
  1642. }
  1643.  
  1644. global function em_tags()
  1645. {
  1646.    local symbol;
  1647.  
  1648.    em_always();
  1649.    symbol = symbol_under_cursor();
  1650.    tags(symbol);
  1651. }
  1652.  
  1653. global function em_start_comment()
  1654. {
  1655.    local key;
  1656.  
  1657.    em_always();
  1658.  
  1659.    key = path_ext(buffer_filename);
  1660.    message(key);
  1661.    if(key in comments)
  1662.    {
  1663.       save_position();
  1664.       insert_string(comments[key]);
  1665.       restore_position(TRUE);
  1666.       current_column += 3;
  1667.    }
  1668.    else
  1669.       warning("Unrecognized file extension.");
  1670. }
  1671.  
  1672. global function em_goto_window_top()
  1673. {
  1674.    em_always();
  1675.    goto_window_top();
  1676. }
  1677.  
  1678. global function name_last_kbd_macro()
  1679. {
  1680.    local s;
  1681.  
  1682.    if (current_keymap == ctrlx_keymap)
  1683.       pop_keymap();
  1684.  
  1685.    if (keymac == "")
  1686.       return;
  1687.  
  1688.    s = prompt("Macro name: ", "", "em_name_kbd_macro_prompt" );
  1689.  
  1690.    if (s == "")
  1691.       return;
  1692.  
  1693.    savedmacs[s] = keymac;
  1694.    message("");
  1695. }
  1696.  
  1697. global function replay(comm)
  1698. {
  1699.    local s;
  1700.  
  1701.    em_always();
  1702.    s = savedmacs[comm];
  1703.    playback(substr(s, 1, length(s) -1));
  1704. }
  1705.  
  1706. ################################################################################
  1707. #  C-x r keymap functions.
  1708. #  These functions handle all rectangle commands.
  1709. ################################################################################
  1710.  
  1711. global function em_clear_rectangle()
  1712. {
  1713.    local    prefix, i, flags,
  1714.             start  = min(marky, current_line),
  1715.             end    = max(marky, current_line),
  1716.             col    = min(markx, current_column),
  1717.             len    = abs(markx - current_column) + 1,
  1718.             old_buffer = buffer_flags;
  1719.  
  1720.    em_always();
  1721.  
  1722.    if(em_rectangle_defined())
  1723.    {
  1724.       em_rect_kill();
  1725.       prefix = strrepeat(" ", len);
  1726.  
  1727.       for(i = start; i <= end; i++)
  1728.       {
  1729.          goto_pos(i, col);
  1730.          insert_string(prefix);
  1731.       }
  1732.       remove_selection();
  1733.  
  1734.       message("Rectangle blanked out");
  1735.    }
  1736. }
  1737.  
  1738. global function em_rect_kill()
  1739. {
  1740.    em_always();
  1741.  
  1742.    if(em_rectangle_defined())
  1743.    {
  1744.       create_linecol_selection(COLUMN_SELECTION, marky, markx, current_line, current_column);
  1745.       em_delete_to_scrap();
  1746.       remove_selection();
  1747.          
  1748.       message("Rectangle killed");
  1749.    }
  1750. }
  1751.  
  1752. global function em_rect_open()
  1753. {
  1754.    local col = current_column, scol;
  1755.  
  1756.    em_always();
  1757.    if(em_rectangle_defined())
  1758.    {
  1759.       scol = min(markx, col);
  1760.       create_linecol_selection(COLUMN_SELECTION, min(marky, current_line), scol, max(marky, current_line), scol);
  1761.       indent_columns(abs(col - markx)+1);
  1762.       message("Rectangle shifted right");
  1763.       remove_selection();
  1764.    }
  1765. }
  1766.  
  1767. global function em_string_rectangle()
  1768. {
  1769.    local    prefix, i, start, end, col;
  1770.  
  1771.    em_always();
  1772.  
  1773.    if(em_rectangle_defined())
  1774.    {
  1775.       start  = min(marky, current_line);
  1776.       end    = max(marky, current_line);
  1777.       col    = min(markx, current_column);
  1778.  
  1779.       prefix = prompt_history("PREFIX", "String to prefix rectangle: ", "", 1, 1, "em_prefix_rectangle_prompt");
  1780.       for(i = start; i <= end; i++)
  1781.       {
  1782.          goto_pos(i, col);
  1783.          insert_string(prefix);
  1784.       }
  1785.       remove_selection();
  1786.  
  1787.       message("Rectangle prefixed");
  1788.    }
  1789. }
  1790.  
  1791. global function em_rect_copy_to_register()
  1792. {
  1793.    em_always();
  1794.    message("Find out what a register is");
  1795. }
  1796.  
  1797. global function em_rect_yank()
  1798. {
  1799.    local this_buffer;
  1800.  
  1801.    em_always();
  1802.  
  1803.    this_buffer = current_buffer;
  1804.    current_buffer = killbuffers[currentkill].bufid;
  1805.  
  1806.    goto_buffer_top();
  1807.    begin_selection(killbuffers[currentkill].type);
  1808.  
  1809.    goto_buffer_bottom();
  1810.    if(killbuffers[currentkill].type == COLUMN_SELECTION)
  1811.       prev_char();
  1812.  
  1813.    copy_to_scrap();
  1814.  
  1815.    current_buffer = this_buffer;
  1816.    insert_scrap();
  1817.  
  1818.    message("Yank rectangle from kill buffer");
  1819. }
  1820.  
  1821. global function em_rectangle_defined()
  1822. {
  1823.    local markset = !((markx + marky) == 0);
  1824.  
  1825.    if(!markset)
  1826.       warning("Rectangle not defined");
  1827.  
  1828.    return markset;
  1829. }
  1830.  
  1831. ######## end rectangle functions
  1832.  
  1833. global function em_indent_tab_maybe()
  1834. {
  1835.    local i, cnt = em_always();
  1836.  
  1837.    for(i = 0; i < cnt; i++)
  1838.       indent_tab_maybe();
  1839. }
  1840.  
  1841. #  
  1842. #  Current line is adjusted to line up with line above or indented one stop if required
  1843. #  
  1844. #  Indent if line above has an open structure ( ([{" )
  1845. #         or does not end in a semi-colon followed by white space
  1846. #  
  1847. global function em_indent()
  1848. {
  1849.    local ch, pos = 0, fnw = 0, fnw2 = 0, line, level = 0, quote = 0, tablevel = FALSE;
  1850.    local savex = current_column, savey = current_line, newx;
  1851.    local save_buffer_flags = buffer_flags;
  1852.  
  1853.    if(and(save_buffer_flags, BUFFER_OVERTYPE_MODE))
  1854.       buffer_flags = xor(buffer_flags, BUFFER_OVERTYPE_MODE);
  1855.  
  1856.    em_always();
  1857.  
  1858.    do
  1859.    {
  1860.       pos = up(1);
  1861.       fnw = first_nonwhite();
  1862.    } while(!fnw && pos)
  1863.  
  1864.    if(!pos)
  1865.    {
  1866.       tablevel = TRUE;
  1867.       fnw = 1;
  1868.    }
  1869.    else
  1870.    {
  1871.       goto_pos(0, fnw);
  1872.       ch = read_buffer(1);
  1873.  
  1874.       pos = 0;
  1875.       while(ch != "")
  1876.       {
  1877.          
  1878.          #  Only count characters that are outside of quotes
  1879.          if(ch == "\"")
  1880.             quote = xor(quote, TRUE);
  1881.  
  1882.          else if(!quote)
  1883.          {
  1884.             if(match(ch, "[\\{\\(\\[]"))
  1885.                level++;
  1886.             else if(match(ch, "[\\}\\)\\]]"))
  1887.                level--;
  1888.             else if(match(ch, "[ \t]") && pos)
  1889.                pos++;
  1890.             else if(ch == ";")
  1891.                pos = current_column;
  1892.          }
  1893.          next_char();
  1894.          ch = read_buffer(1);
  1895.       }
  1896.       if( ((pos != current_line_width) && (level >= 0)) || (level > 0) || quote )
  1897.          tablevel = TRUE;
  1898.    }
  1899.    goto_pos(savey, 0);
  1900.    fnw2 = first_nonwhite();
  1901.    goto_pos(0, fnw2);
  1902.    line = read_buffer();
  1903.    delete_line();
  1904.    goto_bol();
  1905.       
  1906.    insert_string(strrepeat(" ", fnw-1));
  1907.    if(tablevel)
  1908.    {
  1909.       fnw += distance_next_tab;
  1910.       insert_string(strrepeat(" ", distance_next_tab));
  1911.    }
  1912.    newx = current_column;
  1913.    savex = savex - fnw2 + fnw;
  1914.  
  1915.    insert_string(line "\n");
  1916.    if(savex > newx)
  1917.       goto_pos(savey, savex);
  1918.    else
  1919.       goto_pos(savey, newx);
  1920.  
  1921.    buffer_flags = save_buffer_flags;
  1922.  
  1923. }
  1924.  
  1925. global function whatiskey()
  1926. {
  1927.    local ch, func, bound, name;
  1928.  
  1929.    message("What is key: ");
  1930.    ch    = getkey();
  1931.    name  = int_to_key(ch);
  1932.    bound = keymap_binding(name);
  1933.  
  1934.    em_always();
  1935.    if(bound)
  1936.       func = "Mapped to: " "\"" bound "\"";
  1937.    else
  1938.       func = "Key not mapped."
  1939.  
  1940.    message("Key ID: " ch "; String: " name "; " func);
  1941. }
  1942.  
  1943. global function em_wrap_paragraph()
  1944. {
  1945.    em_always();
  1946.    wrap_paragraph();
  1947. }
  1948.  
  1949. global function em_yankpop()
  1950. {
  1951.    local width;
  1952.    local thisbuffer = current_buffer;
  1953.    local type = killbuffers[currentkill].type;
  1954.  
  1955.    if(last_command == YANK)
  1956.    {
  1957.       if(type == COLUMN_SELECTION)
  1958.       {
  1959.          current_buffer = killbuffers[currentkill].bufid;
  1960.          save_position();
  1961.          goto_buffer_top();
  1962.          restore_position(TRUE);
  1963.          width = current_line_width;
  1964.  
  1965.          current_buffer = thisbuffer;
  1966.          current_line --;
  1967.          current_column = lastyankx1 + width - 1;
  1968.       }
  1969.  
  1970.       begin_selection(type);
  1971.  
  1972.       current_column = lastyankx1;
  1973.       current_line = lastyanky1;
  1974.  
  1975.       delete_chars();
  1976.       end_selection();
  1977.  
  1978.       prevkillbuf(1);
  1979.       em_yank();
  1980.    }
  1981.    else
  1982.       warning("Last command was not a yank");
  1983. }
  1984.  
  1985. global function em_delete_to_scrap()
  1986. {
  1987.    local thisbuffer, 
  1988.          name,
  1989.          type = selection_type();
  1990.  
  1991.    thisbuffer = current_buffer;
  1992.  
  1993.    delete_to_scrap();
  1994.  
  1995.    nextkillbuf(1);
  1996.  
  1997.    delete_buffer(killbuffers[currentkill].bufid);
  1998.    name = "killbuffer" currentkill "";
  1999.    killbuffers[currentkill].bufid = create_buffer(name, name, BUFFER_SYSTEM+BUFFER_NO_UNDO);
  2000.  
  2001.    killbuffers[currentkill].type = type;
  2002.    current_buffer = killbuffers[currentkill].bufid;
  2003.    insert_scrap();
  2004.  
  2005.    current_buffer = thisbuffer;
  2006. }
  2007.  
  2008. global function em_append_to_scrap(newline)
  2009. {
  2010.    local thisbuffer;
  2011.  
  2012.    thisbuffer = current_buffer;
  2013.  
  2014.    delete_to_scrap();
  2015.  
  2016.    current_buffer = killbuffers[currentkill].bufid;
  2017.  
  2018.    if(newline)
  2019.       insert_newline();
  2020.    else
  2021.      insert_scrap();
  2022.  
  2023.    current_buffer = thisbuffer;
  2024. }
  2025.  
  2026. global function em_copy_to_scrap()
  2027. {
  2028.    local thisbuffer,
  2029.          name,
  2030.          type = selection_type();
  2031.  
  2032.    thisbuffer = current_buffer;
  2033.  
  2034.    copy_to_scrap();
  2035.  
  2036.    nextkillbuf(1);
  2037.  
  2038.    delete_buffer(killbuffers[currentkill].bufid);
  2039.    name = "killbuffer" currentkill "";
  2040.    killbuffers[currentkill].bufid = create_buffer(name, name, BUFFER_SYSTEM);
  2041.    killbuffers[currentkill].type = type;
  2042.    current_buffer = killbuffers[currentkill].bufid;
  2043.    insert_scrap();
  2044.  
  2045.    current_buffer = thisbuffer;
  2046.    
  2047.    em_unset_mark();
  2048. }
  2049.  
  2050. global function nextkillbuf(adv)
  2051. {
  2052.    currentkill += adv;
  2053.    currentkill %= NUMKILLBUFFERS;
  2054. }
  2055.  
  2056. global function prevkillbuf(adv)
  2057. {
  2058.    adv %= NUMKILLBUFFERS;
  2059.    currentkill += (NUMKILLBUFFERS - adv);
  2060.    currentkill %= NUMKILLBUFFERS;
  2061. }
  2062.  
  2063. global function em_display_next_kill()
  2064. {
  2065. #     local old_flags = window_flags;
  2066.  
  2067.    nextkillbuf(em_always());
  2068.    window_flags = or(window_flags, WINDOW_SHOW_SYSTEM);
  2069.    current_buffer = killbuffers[currentkill].bufid;
  2070.  
  2071. #     window_flags = old_flags;
  2072. }
  2073.  
  2074. global function em_display_prev_kill()
  2075. {
  2076. #     local old_flags = window_flags;
  2077.  
  2078.    prevkillbuf(em_always());
  2079.    window_flags = or(window_flags, WINDOW_SHOW_SYSTEM);
  2080.    current_buffer = killbuffers[currentkill].bufid;
  2081.  
  2082. #     window_flags = old_flags;
  2083. }
  2084.  
  2085. global function em_modified()
  2086. {
  2087.    em_always();
  2088.    buffer_flags = xor(buffer_flags, BUFFER_MODIFIED);
  2089.  
  2090.    if (and(buffer_flags,BUFFER_MODIFIED))
  2091.       message("Buffer is marked changed");
  2092.    else
  2093.       message("Buffer is marked unchanged");
  2094. }
  2095.  
  2096. global function em_showvar()
  2097. {
  2098.    local showme;
  2099.  
  2100.    em_always();
  2101.  
  2102.    showme = prompt_history("XMACRO","Show variable: ","", 1, 1);
  2103.  
  2104.    if(showme)
  2105.       message(showme " == " execute_function(showme));
  2106. }
  2107.  
  2108. global function setvar()
  2109. {
  2110.    local setme;
  2111.    local to;
  2112.  
  2113.    em_always();
  2114.  
  2115.    setme = prompt_history("XMACRO","set variable: ","", 1, 1);
  2116.    to = prompt("to: ");
  2117.    message(setme " == " execute_function(setme"="to));
  2118. }
  2119.  
  2120. global function em_copytofile()
  2121. {
  2122.    local t;
  2123.  
  2124.    em_always();
  2125.    t = and(buffer_flags,BUFFER_MODIFIED);
  2126.    write_buffer(prompt_history("EDITFILE","Copy to file: ", getcwd(), 1, 1, "em_copytofile_dialog"));
  2127.    buffer_flags = set_flag_bits(buffer_flags, BUFFER_MODIFIED, t);
  2128. }
  2129.  
  2130. global function em_set_line_prefix()
  2131. {
  2132.    local prefix_string;
  2133.  
  2134.    prefix_string = prompt_history("PREFIX", "New line prefix: " , line_prefix, 1, 1, "em_set_line_prefix_prompt" );
  2135.  
  2136.    line_prefix = prefix_string;
  2137.    em_always();
  2138. }
  2139.  
  2140. global function em_bufed()
  2141. {
  2142.    em_always();
  2143.    buffer_list();
  2144. }
  2145.  
  2146. global function em_count_lines()
  2147. {
  2148.    em_always();
  2149.    message("%d lines, point on line %d",buffer_last_line, current_line);
  2150. }
  2151.  
  2152. global function em_cancel()
  2153. {
  2154.    em_always();
  2155.    message("Command canceled");
  2156. }
  2157.  
  2158. global function em_delete_blank_lines()
  2159. {
  2160.    em_always();
  2161.    goto_bol();
  2162.  
  2163.    save_position();
  2164.    while (up() && isblank(read_buffer()))
  2165.    {
  2166.       restore_position(FALSE);
  2167.       save_position();
  2168.    }
  2169.    restore_position(TRUE);
  2170.    begin_selection(NORMAL_SELECTION);
  2171.  
  2172.    save_position();
  2173.    while (isblank(read_buffer()) && down())
  2174.    {
  2175.       restore_position(FALSE);
  2176.       save_position();
  2177.    }
  2178.    restore_position(TRUE);
  2179.  
  2180.    delete_chars();
  2181. }
  2182.  
  2183. global function em_end_kbd_macro()
  2184. {
  2185.    em_always();
  2186.    keymac=record(0);
  2187.    message("Done Recording");
  2188. }
  2189.  
  2190. global function em_exchange_point_and_mark()
  2191. {
  2192.    local t;
  2193.  
  2194.    em_always();
  2195.    end_selection();
  2196.  
  2197.    update_current_view();
  2198.    begin_selection(NORMAL_SELECTION);
  2199.  
  2200.    t = markx;
  2201.    markx = current_column;
  2202.    current_column = t;
  2203.    t = marky;
  2204.    marky = current_line;
  2205.    current_line = t;
  2206. }
  2207.  
  2208. global function em_exit()
  2209. {
  2210.    em_always();
  2211. #     em_write_state();
  2212.    done();
  2213. }
  2214.  
  2215. global function em_find_file()
  2216. {
  2217.    local fn
  2218.    em_always();
  2219.    fn = prompt_history("EDITFILE", "Find file: ", getcwd(), 1, 1, "create_buf_and_win_prompt" )
  2220.  
  2221.    if ( fn )
  2222.       create_buf_and_win(fn);
  2223. }
  2224.  
  2225. global function em_goto_line()
  2226. {
  2227.    local t=0, j, response;
  2228.  
  2229.    t = emacc;
  2230.    j = em_always();
  2231.  
  2232.    if(t)
  2233.       goto_line(j);
  2234.  
  2235.    else
  2236.       goto_line_key();
  2237.  
  2238. }
  2239.  
  2240. global function em_mark_sexp()
  2241. {
  2242.    em_always();
  2243.    message("mark sexp");
  2244. }
  2245.  
  2246. global function em_mark_function()
  2247. {
  2248.    em_always();
  2249.    message("mark function");
  2250. }
  2251.  
  2252. global function em_mark_buffer()
  2253. {
  2254.    em_always();
  2255.    goto_buffer_top();
  2256.    begin_selection(NORMAL_SELECTION);
  2257.  
  2258.    goto_buffer_bottom();
  2259. }
  2260.  
  2261. global function em_indent_rigidly()
  2262. {
  2263.    local i, j, t;
  2264.  
  2265.    t = emacc;
  2266.    j = em_always();
  2267.  
  2268.    begin_selection(NORMAL_SELECTION);
  2269.  
  2270.    current_column = markx;
  2271.    current_line = marky;
  2272.    indent_columns((t) ? j : first_tab_distance());
  2273.    end_selection();
  2274. }
  2275.  
  2276. global function em_insert_file(file)
  2277. {
  2278.    em_always();
  2279.    markx = current_column;
  2280.    marky = current_line;
  2281.  
  2282.    if(!file)   
  2283.       read_file(prompt_history("EDITFILE", "Insert file: ", getcwd(), 1, 1, "insert_prompt" ));
  2284.    else
  2285.       read_file(file);       
  2286. }
  2287.  
  2288. global function em_kill_buffer()
  2289. {
  2290.    em_always();
  2291.    delete_buffer_key();
  2292. }
  2293.  
  2294. global function em_kill_window()
  2295. {
  2296.    em_always();
  2297.    delete_window();
  2298. }
  2299.  
  2300. global function em_last_kbd_macro()
  2301. {
  2302.    local i, j;
  2303.  
  2304.    j = em_always();
  2305.    for (i=0; i<j; i++)
  2306.       playback(substr(keymac,1,length(keymac)-1));
  2307. }
  2308.  
  2309. global function em_make()
  2310. {
  2311.    local status;
  2312.    local old_window = current_window, old_buffer = current_buffer;
  2313.  
  2314.    em_always();
  2315.  
  2316.    if (makebuffer)
  2317.       delete_buffer(makebuffer);
  2318.  
  2319.    if (buffers_modified && toupper(prompt("Save buffers?")) == "Y")
  2320.       write_all_buffers();
  2321.  
  2322.    errfile=create_temp_name();
  2323.    current_window = create_window(3,8,display_width-6,display_height-16)
  2324. #                                  WINDOW_MENU0);
  2325. #     window_cursor_x = 0;
  2326. #     window_cursor_y = 0;
  2327.    display_update();
  2328.    status = dos_window("make >& "errfile);
  2329.    makebuffer = current_buffer =
  2330.                 create_buffer("", errfile, BUFFER_SYSTEM + BUFFER_NO_UNDO);
  2331.    attach_window_buffer(current_window, current_buffer);
  2332.    goto_buffer_bottom();
  2333.    goto_eol();
  2334.    display_update();
  2335.    confirm( "Press <ENTER> to continue.", "" );
  2336.    goto_buffer_top();
  2337.    goto_bol();
  2338.    delete_window();
  2339.    current_buffer = old_buffer;
  2340.    if (old_window)
  2341.       current_window = old_window;
  2342.  
  2343.    display_redraw();
  2344.    unlink(errfile);
  2345.    message("make returns %d",status);
  2346. }
  2347.  
  2348. global function em_next_error()
  2349. {
  2350.    em_always();
  2351. #  goto_next_error( errorSrcName );
  2352. }
  2353.  
  2354. global function em_next_buffer()
  2355. {
  2356.    local i, count;
  2357.  
  2358.    count = em_always();
  2359.    for(i = 0; i < count; i++)
  2360.       next_buffer_mask();
  2361. }
  2362.  
  2363. global function em_prev_buffer()
  2364. {
  2365.    local i, count;
  2366.  
  2367.    count = em_always();
  2368.    for(i = 0; i < count; i++)
  2369.       prev_buffer_mask();
  2370. }
  2371.  
  2372. global function em_next_window()
  2373. {
  2374.    em_always();
  2375.    next_window();
  2376. }
  2377.  
  2378. # post: mdi_mode = FALSE
  2379.  
  2380. global function em_previous_window()
  2381. {
  2382.    em_always();
  2383.    prev_window();
  2384. }
  2385.  
  2386. global function em_push()
  2387. {
  2388.    em_always();
  2389.    system("p");
  2390. }
  2391.  
  2392. global function em_save_file()
  2393. {
  2394.    em_always();
  2395.    write_buffer_key();
  2396. #   message("File saved.");
  2397. }
  2398.  
  2399. global function em_save_all()
  2400. {
  2401.    em_always();
  2402.    gui_saveall();
  2403. }
  2404.  
  2405. global function em_set_fill_column()
  2406. {
  2407.    local t, j;
  2408.  
  2409.    t = emacc;
  2410.    j = em_always();
  2411.    wp_right_margin = (t) ? j : current_column;
  2412. }
  2413.  
  2414. global function em_show_point()
  2415. {
  2416.    em_always();
  2417.    message("%d Characters, point at %d",buffer_size, buffer_offset);
  2418. }
  2419.  
  2420. global function em_scroll_right()
  2421. {
  2422.    scroll_horizontal(-em_always());
  2423. }
  2424.  
  2425. global function em_scroll_left()
  2426. {
  2427.    scroll_horizontal(em_always());
  2428. }
  2429.  
  2430. global function em_one_window()
  2431. {
  2432.    em_always();
  2433.    if(mdi_mode)
  2434.       toggle_window_mode(0);
  2435. }
  2436.  
  2437. global function em_delete_window()
  2438. {
  2439.    em_always();
  2440.  
  2441.    if(mdi_mode && current_window)
  2442.       delete_window();
  2443. }
  2444.  
  2445. ###############################################################################
  2446. # pre:  There is at least one window open.
  2447. # post: mdi_mode = TRUE.  current_window' is split horizontally
  2448. ###############################################################################
  2449. global function em_horizontal_window()
  2450. {
  2451.    em_always();
  2452.    if(!mdi_mode)
  2453.       toggle_window_mode(1);
  2454.    split_window_horizontal();
  2455. }
  2456.  
  2457. ###############################################################################
  2458. # pre:  There is at least one window open.
  2459. # post: mdi_mode = TRUE.  current_window' is split vertically
  2460. ###############################################################################
  2461. global function em_vertical_window()
  2462. {
  2463.    em_always();
  2464.    if(!mdi_mode)
  2465.       toggle_window_mode(1);
  2466.    split_window_vertical();
  2467. }
  2468.  
  2469. global function em_start_kbd_macro()
  2470. {
  2471.    em_always();
  2472.    record(1);
  2473.    message("Recording");
  2474. }
  2475.  
  2476. global function em_start_process()
  2477. {
  2478.    em_always();
  2479.    system();
  2480. }
  2481.  
  2482. global function em_transpose_lines()
  2483. {
  2484.    em_always();
  2485.  
  2486.    up(1);
  2487.    goto_bol();
  2488.    begin_selection(NORMAL_SELECTION);
  2489.    down(1);
  2490.    delete_to_scrap();
  2491.    end_selection();
  2492.  
  2493.    down(1);
  2494.    insert_scrap();
  2495.    up(1);
  2496. }
  2497.  
  2498. global function em_replace()
  2499. {
  2500.    local fn, old_buffer = current_buffer;
  2501.  
  2502.    em_always();
  2503.  
  2504.    fn = prompt_history("EDITFILE", "File to open: ", getcwd(), 1, 1, "em_replace_prompt" )
  2505.  
  2506.    if(fn && (fn != buffer_filename) && create_buf_and_win(fn))
  2507.       delete_buffer(old_buffer);
  2508. }
  2509.  
  2510. #global function em_visit_file()
  2511. #{
  2512. #   local name;
  2513. #  local fn;
  2514. #
  2515. #   em_always();
  2516. #  fn = prompt_history("EDITFILE","Visit file :",buffer_filename)
  2517. #
  2518. #  create_buf_and_win(fn);
  2519. #
  2520. #   if (and(buffer_flags,BUFFER_MODIFIED))
  2521. #   {
  2522. #      if (toupper(prompt("Write changes to disk first?"))=="Y")
  2523. #         write_buffer();
  2524. #      else
  2525. #      {
  2526. #         name = buffer_filename;
  2527. #         buffer_flags = xor(buffer_flags,BUFFER_MODIFIED);
  2528. #         delete_buffer();
  2529. #         edit_file(name);
  2530. #      }
  2531. #   }
  2532. #}
  2533.  
  2534. global function em_write_file(file)
  2535. {
  2536.    local msg;
  2537.  
  2538.    em_always();
  2539.  
  2540.    if(!file)
  2541.       file = prompt("Write to file: ", getcwd(), "write_buffer_as_dialog");
  2542.  
  2543.    if(file)
  2544.    {
  2545.       change_output_name(file);
  2546.       if(write_buffer())
  2547.          message("File written.");
  2548.       else
  2549.       {
  2550.          msg = sprintf("Zero bytes written to '%s'", file);
  2551.          warning(msg);
  2552.       }
  2553.    }
  2554. }
  2555.  
  2556. global function em_write_region()
  2557. {
  2558.    local file;
  2559.  
  2560.    save_position();
  2561.  
  2562.    if(!selection_type())
  2563.       em_mark_buffer();
  2564.  
  2565.    file = prompt("Write region to file: ", getcwd());
  2566.  
  2567.    if(file)
  2568.       write_marked_block(file);
  2569.  
  2570.    remove_selection();
  2571.  
  2572. #     raise_anchor();
  2573.    restore_position(TRUE);
  2574. }
  2575.  
  2576. local function isblank(s)
  2577. {
  2578.    local i;
  2579.  
  2580.    if (s == "")
  2581.       return TRUE;
  2582.  
  2583.    for (i=1; i<=length(s); i++)
  2584.    {
  2585.       if (substr(s,i,1) !~ "[ \t]")
  2586.          return FALSE;
  2587.    }
  2588.  
  2589.    return TRUE;
  2590. }
  2591.  
  2592. global function indent_region()
  2593. {
  2594.    local oldcurrent, swapt = FALSE;
  2595.  
  2596.    em_always();
  2597.  
  2598.    if (current_line < marky)
  2599.    {
  2600.       em_exchange_point_and_mark();
  2601.       swapt = TRUE;
  2602.    }
  2603.    save_position();
  2604.  
  2605.    oldcurrent = current_line;
  2606.  
  2607.    for (current_line=marky; current_line<=oldcurrent; current_line++)
  2608.    {
  2609.       goto_bol();
  2610.       em_indent();
  2611.    }
  2612.    restore_position(TRUE);
  2613.  
  2614.    if (swapt)
  2615.       em_exchange_point_and_mark();
  2616. }
  2617.  
  2618. global function em_write_state()
  2619. {
  2620.    local i;
  2621.  
  2622.    em_always();
  2623.  
  2624.    em_sta_file = fopen(em_sta_name,1)
  2625.    if (!em_sta_file)
  2626.    {
  2627.       message("Cannot open state file");
  2628.       return;
  2629.    }
  2630.  
  2631.    if (search_strings[search_string_count] != "")
  2632.       fprintf(em_sta_file,"lastsearch="search_strings[search_string_count]"\n");
  2633.  
  2634.  
  2635.    if (keymac != "")
  2636.    {
  2637.       fprintf(em_sta_file,"keymac="keymac"\n");
  2638.       # !! this doesn't always work right
  2639.    }
  2640.  
  2641.    for (i in savedmacs)
  2642.    {
  2643.       fprintf(em_sta_file,"savedmacs["i"]="i"\n");
  2644.       # !! this also doesn't always work right
  2645.    }
  2646.    # !! fprintf(em_sta_file,"push_keymap ctrlx_keymap\n");
  2647.    # !! save ctrlx keymap here as a set of assign_key commands
  2648.    # !! fprintf(em_sta_file,"pop_keymap\n");
  2649.    # !! save normal keymap here as a set of assign_key commands
  2650.    fclose(em_sta_file);
  2651.    message("State file written.");
  2652. }
  2653.  
  2654. global function em_read_state()
  2655. {
  2656.    local oldbuffer = current_buffer,cf,cmd;
  2657.  
  2658.    cf = create_buffer("",em_sta_name, BUFFER_SYSTEM+BUFFER_NO_UNDO);
  2659.  
  2660.    # !! create the ctrlx keymap (should be put in when keymaps are saved)
  2661.    # !!
  2662.    # !! ctrlx_keymap=create_keymap(empty_keymap);
  2663.    # !!
  2664.  
  2665.    # !! create and activate the main keymap (should be put in when
  2666.    # !! keymaps are saved)
  2667.    # !!
  2668.    # !! push_keymap(create_keymap(empty_keymap));
  2669.  
  2670.    if (cf)
  2671.    {
  2672.       current_buffer = cf;
  2673.       goto_buffer_top();
  2674.       do
  2675.       {
  2676.          cmd = read_buffer();
  2677.          if (cmd)
  2678.             execute_function(cmd);
  2679.  
  2680.          next_line();
  2681.       } while (cmd);
  2682.       delete_buffer(cf);
  2683.       current_buffer = oldbuffer;
  2684.    }
  2685.    else
  2686.       return FALSE;
  2687.  
  2688.    return FALSE; # !! this should return true when the keymap stuff is
  2689.                  # !! built. My problem is saving all the maps including
  2690.                  # !! multiple keystroke sequences
  2691. }
  2692.  
  2693.  
  2694. local em_tab_distance;
  2695. local em_tab_string;
  2696.  
  2697. ## first_tab_distance()
  2698. #
  2699. # Determine the column where the first Tab in a row would be positioned.
  2700. #
  2701. global function first_tab_distance()
  2702. {
  2703.    if (em_tab_string != buffer_tabs)
  2704.    {
  2705.       em_tab_string = buffer_tabs;
  2706.       buffer_flags = and(buffer_flags, not(BUFFER_REAL_SPACE_ONLY))
  2707.       save_position()
  2708.       goto_bol()
  2709.       goto_next_tab();
  2710.       em_tab_distance = current_column - 1;
  2711.       restore_position(1);
  2712.       buffer_flags = or(buffer_flags, BUFFER_REAL_SPACE_ONLY)
  2713.    }
  2714.    return em_tab_distance;
  2715. }
  2716.  
  2717. global function emacs_exit()
  2718. {
  2719.    local item, name, menu, tbhand;
  2720.  
  2721.    search_flags         = old_search_flags;
  2722.  
  2723.    #  Reset the functions called by the menu items
  2724.  
  2725.    menu = menu_info(0, MI_MENUHANDLE);
  2726.  
  2727.    for(item in fid)
  2728.    {
  2729.       if ( menu )
  2730.          menu_functions[item] = fid[item];
  2731.    }
  2732.  
  2733.    #  Reset the functions called by the toolbar buttons
  2734.  
  2735.    tbhand = toolbar_info(0);
  2736.  
  2737.    for(item in tid)
  2738.    {
  2739.       if ( tbhand )
  2740.          modify_toolbaritem(tbhand, item, TI_FUNCTIONID, tid[item]);
  2741.    }
  2742.  
  2743.    delete_event(EVENT.EMULATION_CHANGED, function_id("emacs_exit"));
  2744.    delete_event(EVENT.MOUSE_LEFT_DOWN, function_id("em_mouse_set_mark"));
  2745. }
  2746.