home *** CD-ROM | disk | FTP | other *** search
/ OS/2 Shareware BBS: 5 Edit / 05-Edit.zip / p2demo21.exe / PEL / BOOKMARK.PEL < prev    next >
Text File  |  1995-03-17  |  20KB  |  816 lines
  1. # $Header:   P:\source\wmacros\bookmark.pev   1.42   17 Mar 1995 09:50:04   NOBLE  $
  2.  
  3. ##############################################################################
  4. #
  5. #       Compuware Corporation
  6. #         31440 Northwestern Highway
  7. #           Farmington Hills, Michigan 48334-2564
  8. #
  9. #   This source code listing contains information that is
  10. #   proprietary to Compuware Corporation and may not be copied
  11. #   duplicated, translated, transmitted, stored, retrieved
  12. #   or in any manner or by any method conveyed or disclosed
  13. #   to a third party or parties without express written
  14. #   permission from Compuware Corporation.
  15. #
  16. #  
  17. ##############################################################################
  18.  
  19. #### $Workfile:   bookmark.pel  $: Support for Marked Blocks
  20.  
  21. ## $Tabs:4 7$
  22.  
  23. # global markid assignments
  24.  
  25. #local   MIN_BOOKMARK    = 1             # window/buffer/pos bookmarks
  26. #local   MAX_BOOKMARK    = 10
  27.  
  28. # selection types (constants):
  29.  
  30. global  NO_SELECTION            = 0
  31. global  NORMAL_SELECTION        = 1
  32. global  COLUMN_SELECTION        = 2
  33. global  LINE_SELECTION          = 3
  34. global  INCLUSIVE_SELECTION     = 4
  35.  
  36. local   MULTIPLE_SELECTION      = 1
  37. local   event_defined           = 0
  38.  
  39. ### system-wide bookmarks
  40.  
  41. global  TEMP_MARK       = 999           # generic temporary
  42.                                         # values above this are illegal
  43.  
  44. global bookmark_table      # bookmark_table[i].file - filename of bookmark "i"
  45.                            # bookmark_table[i].number - markid of bookmark "i"
  46.                            # bookmark_table[i].buff_id - buffer id of bookmark "i"
  47.  
  48. global function goto_bookmark( name )
  49. {
  50.    local num
  51.    local bookmarksInUse
  52.    local n = 0
  53.    local i
  54.    local filename;
  55.    local success = FALSE
  56.  
  57.    for ( i in bookmark_table )
  58.    {
  59.        n++
  60. #         bookmarksInUse = bookmarksInUse " " i
  61. #      else
  62. #         bookmarksInUse = num = i
  63.    }
  64.  
  65.    if ( n == 0 )
  66.    {
  67.       warning( "No bookmarks defined." )
  68.       return
  69.    }
  70.  
  71. #   if ( n >= 1 )
  72. #   {
  73. #      name = prompt_history(  "BOOKMARKS", "Enter bookmark to jump to [" \
  74. #                              bookmarksInUse "]: ", num )
  75. #   }
  76.  
  77.    if ( name == "" )
  78.       name = prompt_history("BOOKMARKS", "Enter bookmark to jump to : ", "", 0, 0, "goto_bookmark_prompt");
  79.  
  80.    if ( name in bookmark_table )
  81.    {
  82.       filename = bookmark_table[name].file;
  83.       if ( create_buf_and_win(filename) )
  84.       {
  85.          goto_mark(bookmark_table[name].number)
  86.          display_filename()
  87.          success = TRUE
  88.       }
  89.       else
  90.          warning( "Error: could not access file: %s", filename )
  91.    }
  92.    else
  93.       message( "Bookmark %s is undefined.", name )
  94.  
  95.    return success
  96. }
  97.  
  98. global function bookmark_defined(name)
  99. {
  100.    local rc = 0
  101.    local start_buff = current_buffer
  102.  
  103.    if (name in bookmark_table) 
  104.    {
  105.       current_buffer = bookmark_table[name].buff_id
  106.       rc = mark_defined(bookmark_table[name].number);
  107.    }
  108.  
  109.    current_buffer = start_buff
  110.    return rc;
  111. }
  112.  
  113. global function delete_bookmark(name)
  114. { 
  115.    local start_buff = current_buffer
  116.    
  117.    # delete old mark if one exists.
  118.    if (name in bookmark_table) 
  119.    {
  120.       current_buffer = bookmark_table[name].buff_id
  121.       delete_mark(bookmark_table[name].number);
  122.       delete(bookmark_table[name])
  123.    }
  124.    
  125.    current_buffer = start_buff
  126. }
  127.  
  128. # place a bookmark at the cursor (companion to goto_bookmark)
  129. #
  130. global function place_bookmark( name, noPrompt, system_mark )
  131. {
  132.    local i, num, mark = TRUE;
  133.    local max_name = 0;  # highest current mark name
  134.  
  135.    # If no argument was given, prompt for a bookmark name to
  136.    # use, offering the next numerically available bookmark as a default.
  137.  
  138.    if(name == "")
  139.    {
  140.       name = 0;
  141.       for(name in bookmark_table)
  142.          if (name+0 > max_name)
  143.             max_name = name+0
  144.             
  145.       max_name += 1;
  146.  
  147.       name = max_name "";
  148.       name = prompt_history("BOOKMARKS", "Bookmark name to drop: ", name, 1, 1, "place_bookmark_prompt")
  149.  
  150.       if(!name)
  151.          mark = FALSE;
  152.    }
  153.    else
  154.       add_prompt_history("BOOKMARKS", name)
  155.  
  156.    if(!noPrompt)
  157.    {
  158.       if( (name in bookmark_table) && 
  159.            (tolower(confirm("Reuse bookmark '" name "'? [yn]", "yYnN")) != "y"))
  160.       {
  161.          mark = FALSE;
  162.       }
  163.    }
  164.  
  165.    if(mark)
  166.    {
  167.       # delete old mark if one exists.
  168.       if (name in bookmark_table) 
  169.          delete_mark(bookmark_table[name].number);
  170.  
  171.       num = pick_unused_mark();
  172.       create_mark( num, current_line, current_column, TRUE );
  173.       bookmark_table[name].number = num;
  174.       bookmark_table[name].file   = buffer_filename;
  175.       bookmark_table[name].system = system_mark;
  176.       bookmark_table[name].buff_id = current_buffer;
  177.  
  178.       message( "Dropped bookmark %s", name )
  179.       display_update();
  180.  
  181.       # the next pointless looking line forces the line numbers to be redrawn
  182.       # which shows a bookmark marker immediately
  183.       linenumber_format = linenumber_format;
  184.       
  185.       if(!event_defined)
  186.       {
  187.          event_defined = TRUE;
  188.          attach_event_handler(EVENT.DELETING_BUFFER, function_id("buffer_delete_bookmarks"));
  189.       }
  190.    }
  191.  
  192.    return mark
  193. }
  194.  
  195. global function buffer_delete_bookmarks()
  196. {
  197.    local i;
  198.  
  199.    if(!and(buffer_flags, BUFFER_SYSTEM))
  200.       for(i in bookmark_table)
  201.          if(bookmark_table[i].buff_id == current_buffer)
  202.          {
  203.             delete_mark(bookmark_table[i].number)
  204.             delete bookmark_table[i];
  205.          }
  206. }
  207.  
  208. global function bookmark_delete_pressed(list_line, data_line)
  209. {
  210.    local mark, pos, msg, name, array, start_buff;
  211.  
  212.    start_buff = current_buffer;
  213.    
  214.    pos = match(list_line, ":");
  215.    name = substr(list_line, 1, pos-1);
  216.    split(data_line, array);
  217.  
  218.    if(name in bookmark_table)
  219.    {
  220.       edit_file(array[1]);
  221.       mark = bookmark_table[name].number;
  222.       delete_mark(mark);
  223.       delete bookmark_table[name];
  224.    }
  225.    else
  226.    {
  227.       # restore the deleted bookmark when the dialog is still visible
  228.       #  (the user pressed the Delete button twice)
  229.       edit_file(array[1]);
  230.       goto_pos(array[2], array[3]);
  231.       place_bookmark(name);
  232.    }
  233.    
  234.    current_buffer = start_buff;
  235.  
  236.    # this is that same goofy thing we have to do in place_bookmark to redraw line numbers.
  237.    linenumber_format = linenumber_format;
  238.    update_current_view();
  239. }
  240.  
  241. global function build_bookmark_list()
  242. {
  243.    local list[]
  244.    local name
  245.    local start_buff = current_buffer
  246.    local line, column, filename, mark, text;
  247.    
  248.    for(name in bookmark_table)
  249.       if ( !bookmark_table[name].system )
  250.          if(bookmark_table[name].buff_id)
  251.          {
  252.             current_buffer = bookmark_table[name].buff_id
  253.             mark   = bookmark_table[name].number;
  254.             line   = mark_line(mark);
  255.             column = mark_column(mark);
  256.             filename = bookmark_table[name].file;
  257.          
  258.             save_position();
  259.             goto_line(line);
  260.             goto_bol();
  261.             text = read_buffer();
  262.             restore_position(TRUE);
  263.          
  264.             list[name]   = name ": " filename " ( " line " , " column " ) : " text;
  265.          }
  266.          
  267.    current_buffer = start_buff
  268.    return list         
  269. }
  270.  
  271. global function bookmark_list()
  272. {
  273.    local dhList, line, column, filename, name, mark, data, text,
  274.          found = FALSE, start_buff;
  275.  
  276.    dhList = create_list_dialog( "Bookmark List", editor_helpfile, "bookmark_list_callback" );
  277.  
  278.    start_buff = current_buffer;
  279.  
  280.    for(name in bookmark_table)
  281.    {
  282.       if ( !bookmark_table[name].system )
  283.          if(bookmark_table[name].buff_id)
  284.          {
  285.             current_buffer = bookmark_table[name].buff_id
  286.             mark   = bookmark_table[name].number;
  287.             line   = mark_line(mark);
  288.             column = mark_column(mark);
  289.             filename = bookmark_table[name].file;
  290.          
  291.             save_position();
  292.             goto_line(line);
  293.             goto_bol();
  294.             text = read_buffer();
  295.             restore_position(TRUE);
  296.          
  297.             data   = name ": " filename " ( " line " , " column " ) : " text;
  298.          
  299.             add_item_to_list(dhList, data, filename, line, column, -1);
  300.             found = TRUE;
  301.          }
  302.    }
  303.    
  304.    current_buffer = start_buff;
  305.    
  306.    if(found)
  307.       begin_list_dialog(dhList);
  308.    else
  309.    {
  310.       delete_list_dialog(dhList);
  311.       warning("No bookmarks set");
  312.    }
  313. }
  314.  
  315. function write_block_key()
  316. {
  317.    local   fileToWrite
  318.    local   status
  319.  
  320.    if( selection_type() == NO_SELECTION )
  321.    {
  322.       if (buffer_filename)
  323.       {
  324.          if ( !and( buffer_flags, BUFFER_MODIFIED ) )
  325.             message( buffer_name ": has not been modified. " );
  326.          else if ( is_scratch_file(current_buffer)  )
  327.                write_buffer_as()
  328.          else
  329.          {
  330.             message( buffer_name ":" );
  331.             backup_file( buffer_filename );
  332.             status = write_buffer();
  333.             if ( (status >= 0) && (!errno) )
  334.                message( buffer_name ":" buffer_last_line " lines written" );
  335.          }
  336.       }
  337.       else
  338.          warning( "buffer_filename is not defined. " );
  339.    }
  340.    else
  341.    {
  342.       fileToWrite = prompt( "Write block as: ", "" )
  343.       if (fileToWrite)
  344.       {
  345.          backup_file( fileToWrite );
  346.          if (write_marked_block( fileToWrite ))
  347.             message("Write successful.")
  348.       }
  349.    }
  350. }
  351.  
  352. local function set_anchor_mark( mtype )
  353. {
  354.    local   otype = selection_type()
  355.  
  356.    if ( otype == mtype )
  357.    {
  358.       # There is a currently a selection of the specified type.
  359.       # If the selection is "floating" with the cursor as one
  360.       # endpoint, make the selection cursor independent if multiple
  361.       # selections are enabled.
  362.       # Otherwise remove the existing selection.
  363.       #
  364.       if ( ( selection_mode == MULTIPLE_SELECTION ) &&
  365.            (( selection_mark_top() == 0 ) || 
  366.             ( selection_mark_bottom() == 0 )) )
  367.          end_selection()
  368.       else if ( selection_mode == MULTIPLE_SELECTION )
  369.          begin_selection(mtype)
  370.       else
  371.          remove_selection()
  372.    }
  373.    else
  374.    {
  375.       # Create a new selection
  376.       #
  377.       remove_selection()
  378.       begin_selection( mtype )
  379.    }
  380. }
  381.  
  382.  
  383. global function set_exclusive_mark()
  384. {
  385.    set_anchor_mark( NORMAL_SELECTION );
  386. }
  387.  
  388. global function set_column_mark()
  389. {
  390.    set_anchor_mark( COLUMN_SELECTION );
  391. }
  392.  
  393. global function set_line_mark()
  394. {
  395.    set_anchor_mark( LINE_SELECTION );
  396. }
  397.  
  398. global function set_inclusive_mark()
  399. {
  400.    set_anchor_mark( INCLUSIVE_SELECTION );
  401. }
  402.  
  403. global function copy_to_scrap_key( append )
  404. {
  405.    local    status;
  406.       
  407.    if (argcount() && append)
  408.       status = append_to_scrap();
  409.    else
  410.       status = copy_to_scrap();
  411. }
  412.  
  413. #
  414. # mark_paragraph()
  415. #
  416. # mark the current paragraph by first searching backward to the
  417. # beginning of the paragraph (a blank line) and then searching forwards
  418. # to the end of the paragraph ( a blank line ).
  419. #
  420. global function mark_paragraph()                                #PUBLIC #INT
  421. {
  422.    # find beginning of paragraph
  423.    #
  424.    if ( !search("^[ \t]*$", SEARCH_BKWD_REGEX_MAX) )
  425.       goto_buffer_top();
  426.  
  427.    search("[ \t]*\\c[^ \t]", SEARCH_FWD_REGEX_MAX)
  428.  
  429.    begin_selection( NORMAL_SELECTION )
  430.  
  431.    # find end of paragraph
  432.    #
  433.    if ( !search("^[ \t]*$", SEARCH_FWD_REGEX_MAX) )
  434.       goto_buffer_bottom()
  435.  
  436.    end_selection()
  437. }
  438.  
  439. ## marked_region_size()
  440. #
  441. # Returns the number of characters included in the current highlight.
  442. # If the current selection is a column block, return the area.
  443. # (Note that column block may include virtual space, so the area may
  444. # differ from the number of characters in the highlight.)
  445. #
  446. global function marked_region_size()
  447. {
  448.    local st
  449.    local height, width
  450.    local begin
  451.    local markid
  452.    local ret
  453.  
  454.    # ensure that a highlight exists
  455.    st = selection_type()
  456.    if ( !st )
  457.       return 0
  458.  
  459.    save_position()
  460.  
  461.    # get the position at the top of the selected region
  462.    #
  463.    goto_mark( selection_mark_top() )
  464.    if ( st == COLUMN_SELECTION )
  465.    {
  466.       height  = current_line
  467.       width   = current_column
  468.    }
  469.    else
  470.    {
  471.       if ( st == LINE_SELECTION )
  472.          goto_bol()                 # include all of the first line
  473.  
  474.       begin = buffer_offset
  475.    }
  476.  
  477.    # get the position at the bottom of the selected region
  478.    #
  479.    markid = selection_mark_bottom()
  480.    if ( markid )
  481.       goto_mark( markid )
  482.    else
  483.    {
  484.       restore_position( 1 )
  485.       save_position()
  486.    }
  487.  
  488.    if ( st == COLUMN_SELECTION )
  489.    {
  490.       height = current_line - height + 1
  491.       width = ( width > current_column )              \
  492.                       ? width - current_column + 1    \
  493.                       : current_column - width + 1
  494.       ret = height * width         # area
  495.    }
  496.    else
  497.    {
  498.       if ( st == LINE_SELECTION )
  499.       {
  500.          goto_eol()      # include all of the last line
  501.          next_char()
  502.       }
  503.       else if ( st == INCLUSIVE_SELECTION )
  504.       {
  505.          # include character at cursor
  506.          next_char()
  507.       }
  508.       ret = buffer_offset - begin
  509.    }
  510.  
  511.    restore_position( 1 )
  512.    return ret
  513. }
  514.  
  515. #===========================================================================
  516. # primitives which extend the current selection
  517.  
  518. global function extend_selection_init()
  519. {
  520.    # make sure selection is active
  521.    if ( !selection_type() )
  522.       begin_selection( NORMAL_SELECTION )
  523. }
  524.  
  525. global function extend_selection()
  526. {
  527.    local   mark1, mark2
  528.    local   diff1, diff2
  529.  
  530.    # Get current selection endpoints
  531.    #
  532.    mark1 = selection_mark_top()
  533.    mark2 = selection_mark_bottom()
  534.    if ( !mark1 || !mark2 )
  535.    {
  536.       end_selection()
  537.       return
  538.    }
  539.  
  540.    # Find mark closest to cursor
  541.    #
  542.    diff1 = distance_between_marks( mark1, 0 )
  543.    diff2 = distance_between_marks( mark2, 0 )
  544.  
  545.    if ( diff1 < 0 )
  546.       diff1 = 0 - diff1
  547.    if ( diff2 < 0 )
  548.       diff2 = 0 - diff2
  549.  
  550.    # Move the closer mark to the current cursor position
  551.    #
  552.    create_mark( ((diff1 < diff2) ? mark1 : mark2) )
  553. }
  554.  
  555. #===========================================================================
  556.  
  557. # functions to save and restore the current selection (stack of 1)
  558. #
  559.  
  560. local   selectionArray
  561.  
  562. global function save_selection()
  563. {
  564.    selectionArray.type = selection_type()
  565.  
  566.    if ( selectionArray.type )
  567.    {
  568.       # Save the original cursor position.
  569.       #
  570.       selectionArray.curpos = create_mark( pick_unused_mark() )
  571.  
  572.       # Save the id numbers of the two bookmarks now in use, in
  573.       # case they are permanent bookmarks assigned by the user.
  574.       #
  575.       selectionArray.m1 = selection_mark_top()
  576.       selectionArray.m2 = selection_mark_bottom()
  577.       if ( !selectionArray.m1 )
  578.       {
  579.          selectionArray.m1 = selectionArray.m2
  580.          selectionArray.m2 = 0
  581.       }
  582.  
  583.       # Make copies of the two selection endpoints
  584.       #
  585.       goto_mark( selectionArray.m2 )
  586.       selectionArray.temp2 = create_mark( pick_unused_mark() )
  587.       goto_mark( selectionArray.m1 )
  588.       selectionArray.temp1 = create_mark( pick_unused_mark() )
  589.  
  590.       # Now it is safe to remove the selection.
  591.       remove_selection()
  592.  
  593.       # Return to the original cursor position
  594.       goto_mark( selectionArray.curpos )
  595.  
  596.       update_current_view()
  597.    }
  598. }
  599.  
  600. global function restore_selection()
  601. {
  602.    if ( selectionArray )
  603.    {
  604.       if ( selectionArray.type )
  605.       {
  606.          # restore the first endpoint
  607.          #
  608.          if ( !begin_selection( selectionArray.type, selectionArray.m1 ))
  609.          {
  610.             # m1 no longer exists, create a new one
  611.             begin_selection( selectionArray.type, selectionArray.temp1 )
  612.          }
  613.          else
  614.             delete_mark( selectionArray.temp1 )
  615.  
  616.          # Restore the second endpoint.
  617.          #
  618.          if ( selectionArray.m2 )
  619.          {
  620.             if ( !end_selection( selectionArray.m2 ))
  621.             {
  622.                # m2 no longer exists, create a new one
  623.                end_selection( selectionArray.temp2 )
  624.             }
  625.          }
  626.          else
  627.             delete_mark( selectionArray.temp2 )
  628.  
  629.          # Return the cursor to the original location.
  630.          goto_mark( selectionArray.curpos )
  631.          delete_mark( selectionArray.curpos )
  632.  
  633.          update_current_view()
  634.       }
  635.       delete( selectionArray )
  636.    }
  637. }
  638.  
  639. #===========================================================================
  640. #
  641. # The following functions are retained from SPE v1.1 for forward
  642. # compatibility.
  643. #
  644.  
  645. global function region_type()
  646. {
  647.    return selection_type()
  648. }
  649.  
  650. global function swap_selection_marks()
  651. {
  652.    swap_marks( selection_mark_top(), selection_mark_bottom() )
  653. }
  654.  
  655. local   anchorStack = initStack(anchorStack);
  656. local   selectionStack = initStack(selectionStack);
  657.  
  658. # CFV redesigned so that it matched the documentation from pel manuals
  659. # 9/24/93
  660. global function drop_anchor( type, mark1, mark2 )
  661. {
  662.    local retval = 0
  663. #  message("drop anchor: type = %d; mark1 = %d; mark2 = %d",type, mark1, mark2);
  664.    # save previous region type
  665.    selectionStack = pushStack( selectionStack, selection_type() )
  666.    
  667.    if ( argcount() == 0 )
  668.       type = NORMAL_SELECTION
  669.  
  670.    if ( argcount() == 3 )
  671.    {
  672.       if (mark_defined(mark1))
  673.       {
  674.          if (mark_defined(mark2))
  675.          {
  676.             goto_mark(mark1);
  677.             save_position();    # saves cursor postion of mark1
  678.             begin_selection( type, mark1 )
  679.             goto_mark(mark2);
  680.             return TRUE;
  681.          }
  682.          else 
  683.            return FALSE;
  684.       }
  685.       else 
  686.         return FALSE;
  687.     }
  688.  
  689.    save_position();   # save current cursor position
  690.    if ( argcount() == 2 )  {
  691.       if ( mark_defined(mark1) ) {
  692.          begin_selection( type, mark1 )
  693.          return TRUE;
  694.       }
  695.       else 
  696.          return FALSE
  697.    }
  698.    else {
  699.       begin_selection( type )
  700.       return TRUE
  701.    }
  702.  
  703. }
  704.  
  705. # CFV changed raise anchor so that it works like the manual says it should
  706. # 9/24/93
  707. global function raise_anchor()
  708. {
  709.    local mark1;
  710.    local cur_col = current_column;
  711.    local cur_line = current_line;
  712. #  local mark2 = create_mark( pick_unused_mark() );
  713.  
  714.    mark1 = restore_position( 0 );
  715. #  message("raise anchor");
  716.  
  717.    if ( mark1 )
  718.    {
  719. #  if (restore_position( 0 ) ) {
  720.  
  721.       mark1 = restore_position( 1 );
  722. #  warning("first restore pos = %d", mark1);
  723.       if ( mark1 )
  724.       {
  725. #     if ( restore_position( 1 ) ) {
  726.          save_position();
  727.  
  728.          begin_selection( topOfStack( selectionStack ) );
  729.          goto_pos(cur_line,cur_col);
  730.       }
  731.       else
  732.       {
  733.          remove_selection();
  734.       }
  735.       selectionStack = popStack( selectionStack );
  736.       return TRUE
  737.    }  # if mark1
  738.    else
  739.    {
  740. #  warning("removing selection")
  741.       remove_selection();
  742.       return FALSE
  743.    }
  744. }
  745.  
  746. # CFV changed so that it works like the manual says it should
  747. # 9/24/93
  748. global function toggle_anchor( type )
  749. {
  750.    if( selection_type() == NO_SELECTION )
  751.    {
  752.       if ( argcount() == 0 )
  753.          type = NORMAL_SELECTION
  754.  
  755.       drop_anchor( type )
  756.       return TRUE
  757.    }
  758.    else
  759.    {
  760.       raise_anchor()
  761.       return FALSE;
  762.    }
  763. }
  764.  
  765. local function initStack( stack )
  766. {
  767.    delete( stack )
  768.    stack[0] = 0;
  769.    return stack;
  770. }
  771.  
  772. local function pushStack( stack, element )
  773. {
  774.    local top = ++stack[0];
  775.  
  776.    stack[top] = element;
  777.    return stack;
  778. }
  779.  
  780. local function topOfStack( stack )
  781. {
  782.    local top = stack[0];
  783.    
  784.    if (top)
  785.    {
  786.       return stack[top];
  787.    }
  788.    else
  789.       return FALSE;
  790. }
  791.  
  792. local function popStack( stack )
  793. {
  794.    local top = stack[0];
  795.    local retval
  796.  
  797.    if (top)
  798.    {
  799.       delete(stack[top] );
  800.       --stack[0];
  801.       return stack;
  802.    }
  803. }
  804.  
  805. global function resetAnchorStacks()
  806. {
  807.    local i= 0;
  808.  
  809.    while (++i <= anchorStack[0])
  810.       delete_mark( anchorStack[i] );
  811.  
  812.    anchorStack = initStack( anchorStack );
  813.    selectionStack = initStack( selectionStack );
  814.    remove_selection();
  815. }
  816.