home *** CD-ROM | disk | FTP | other *** search
/ Liren Large Software Subsidy 16 / 16.iso / w / w055 / 4.ddi / SOURCES.LIF / DEBUG.PEL < prev    next >
Encoding:
Text File  |  1990-09-27  |  32.6 KB  |  1,387 lines
  1. # $Header:   P:/source/ppee/macros/debug.pev   1.46   13 Aug 1990 12:54:38   ericj  $
  2.  
  3. ##############################################################################
  4. #
  5. #           Sage Software - POLYTRON Division
  6. #             1700 NW 167th Place
  7. #               Beaverton, OR 97006
  8. #
  9. #   Copyright 1990, Sage Software, Inc.
  10. #
  11. #   Permission is hereby granted for licensed users of Sage Professional
  12. #   Editor and PolyAwk to copy and modify this source code for their own
  13. #   personal use.  These derivative works may be distributed only to other
  14. #   licensed Sage Professional Editor and PolyAwk users.  All other usage
  15. #   is prohibited without express written permission from Sage Software.
  16. #
  17. ##############################################################################
  18.  
  19. #### $Workfile:   debug.pel  $: sageedit debugger entry points
  20. #
  21.  
  22. global debug_color_border = 0x02
  23. global debug_color_text   = 0x07
  24. global debug_color_highlight = 0x1F
  25. global debug_color_title  = 0x02
  26.  
  27. global debug_flip = 1;
  28. local debug_window;
  29. local debug_empty_name = "Debug Window: no function active"
  30. local debug_keymap;
  31. local debug_buffer;
  32. local debug_filename = "";
  33. local command_mode;
  34. local debug_enabled        # True if debug has been called
  35. local original_window;        # Saved when function is debugged.
  36. local original_buffer;
  37. local win_top = 3
  38. local command_win_height = 7
  39. local display_win_height = 15
  40. local win_left, win_width;
  41. local debug_id;
  42. local debug_tabs = default_buffer_tabs;
  43. local debug_view_file = "???"
  44. local debug_num_steps = 0;
  45.  
  46. #
  47. # debug_fun_breakpoints is an array of function gids to break on.
  48. # The index is the gid as a string.  The value is the gid itself.
  49. # The distinction is important because function_name requires the gid itself.
  50. # debug_fun_lineno are the line numbers of the start of the function,
  51. # determined when we hit it.
  52. #
  53. local debug_fun_breakpoints;
  54. local debug_fun_breakpoint_names;
  55. local debug_fun_bp_types;        # 0 = disabled, 1 = enabled, 2 = goto point
  56. local debug_bp_linenos;
  57. local breakpoints_visible = 0;
  58. local ctrl_break_attached = 0;
  59.  
  60.  
  61. local BP_ENABLED        = 0x01;
  62. local BP_GOTO_POINT        = 0x02;
  63.  
  64. local debug_gid, debug_lineno = 0; # GID and lineno of current debugged function
  65. local debug_step_gid;        # GID of function during debug_step
  66. local debug_go_mode;
  67.  
  68. local debug_command_keymap
  69. local debug_command_window
  70. local debug_command_buffer
  71.  
  72. local CTRL_G = 8711
  73. local CTRL_T = 5140
  74.  
  75. global debugger_running = 0;
  76.  
  77.  
  78.  
  79. global function debug_reset(){
  80.     debug_gid        = 0;
  81.     debug_filename   = "";
  82. }
  83.  
  84.  
  85. local function debug_init()
  86. {
  87.     local    cw;
  88.     local    cb;
  89.     local    insert_id = function_id( "debug_insert_key" );
  90.     local    i;
  91.     local    win_height
  92.  
  93.     if (!current_window) {
  94.         current_window = create_window( 0, 0, display_width, display_height);
  95.         attach_window_buffer( current_window, current_buffer );
  96.     }
  97.  
  98.     cw = current_window
  99.     cb = current_buffer
  100.  
  101.     if (debug_enabled) { return; }
  102.     debug_enabled = 1
  103.  
  104.     debug_go_mode = 0;
  105.     debug_id = function_id( "debug_fun" );
  106.  
  107.     # determine the size of the debug window
  108.     win_left = display_width / 4;
  109.     win_width = win_left * 3 - 1;
  110.     win_height = display_height - win_top - 2 - command_win_height;
  111.  
  112.     current_window = 
  113.     debug_window = create_factory_window( win_left, win_top, win_width, display_win_height,
  114.                 WINDOW_SYSTEM + \
  115.                 WINDOW_SB_RIGHT + \
  116.                 WINDOW_TITLE )
  117.     linenumber_format = "%5d: "
  118.     color_text = color_linenumbers = debug_color_text;
  119.     color_border = debug_color_border;
  120.     color_title = debug_color_title;
  121.  
  122.     debug_buffer = create_buffer( \
  123.             debug_empty_name, \
  124.             "", \
  125.             BUFFER_SYSTEM + BUFFER_NO_UNDO + BUFFER_READ_ONLY )
  126.     attach_window_buffer( debug_window, debug_buffer );
  127.     
  128.     debug_keymap = create_keymap(empty_keymap)
  129.     push_keymap(debug_keymap)
  130.  
  131.     #
  132.     # define command keymap bindings for the debug window and
  133.     # the command window.
  134.     #
  135.     for (i = 32; i < 127; i++)
  136.         assign_key( "\\" chr(i), insert_id );
  137.     assign_key( "\\#", insert_id );
  138.     assign_key( "\\\\", insert_id );
  139.  
  140.     assign_key( "<Up>",        "debug_up" );
  141.     assign_key( "<Down>",        "debug_down" );
  142.     assign_key( "<Left>",        "debug_left" );
  143.     assign_key( "<Right>",        "right" );
  144.     assign_key( "<PgUp>",        "debug_page_up");
  145.     assign_key( "<PgDn>",        "debug_page_dn");
  146.     assign_key( "<Ctrl-PgUp>",    "debug_home");
  147.     assign_key( "<Ctrl-PgDn>",    "debug_end" );
  148.     assign_key( "<Ctrl-T>",        "debug_resize_window" );
  149.     assign_key( "<Ctrl-G>",        "debug_resize_window" );
  150.     assign_key( "<Enter>",        "debug_enter" );
  151.     assign_key( "<Bksp>",        "debug_backspace" );
  152.     assign_key( "<Del>",        "debug_delete_chars" );
  153.     assign_key( "<F1>",        "debug_help" );
  154.     assign_key( "<F4>",        "debug_prev_screen" );
  155.     assign_key( "<F5>",        "debug_go" );
  156.     assign_key( "<F6>",        "debug_toggle_windows" );
  157.     assign_key( "<F8>",        "debug_trace" );
  158.     assign_key( "<F10>",        "debug_step" );
  159.     assign_key( "#61440",        "debug_left_press" )
  160.     assign_key( "<End>",        "goto_eol" );
  161.     assign_key( "<Alt-H>",        "debug_help" );
  162.     assign_key( "<Ctrl-C>",        "debug_break" );
  163.     assign_key( "<Alt-C>",        "debug_callstack" );
  164.  
  165.     debug_command_keymap = create_keymap( debug_keymap )
  166.     
  167.  
  168.     # now the keys specific to the debug_window
  169.     #
  170.     assign_key( "<Home>",        "goto_bol" );
  171.     assign_key( "<F9>",        "bp_line" );
  172.  
  173.     pop_keymap()
  174.  
  175.     #
  176.     # create a command line window, buffer, and keymap
  177.     #
  178.     current_window =
  179.     debug_command_window = create_factory_window( win_left, win_top + display_win_height - 1,
  180.                 win_width, command_win_height,
  181.                 WINDOW_SYSTEM + \
  182.                 WINDOW_SB_RIGHT )
  183.     scroll_context_top = 0;
  184.     scroll_context_bottom = 0;
  185.     color_text = debug_color_text;
  186.     color_border = debug_color_border;
  187.     color_title = debug_color_title;
  188.  
  189.  
  190.     current_buffer =
  191.     debug_command_buffer = create_buffer( \
  192.             "", \
  193.             "", \
  194.             BUFFER_SYSTEM )
  195.     insert_key( ord(">") );
  196.     attach_window_buffer( debug_command_window, debug_command_buffer );
  197.     
  198.     push_keymap(debug_command_keymap)
  199.     
  200.     # now the keys specific to the debug_command_window
  201.     #
  202.     assign_key( "<Home>",        "debug_bol" );
  203.  
  204.     pop_keymap()
  205.  
  206.     assign_current_window( cw );
  207.     current_buffer = cb;
  208.  
  209.     command_mode = 1;
  210. }
  211.  
  212.  
  213. # Invoke this to start debugging.
  214. #
  215. function debug()
  216. {
  217.     local gid;
  218.  
  219.     attach_break_handler()
  220.  
  221.     debug_function( 0 );
  222.     debug_init()
  223.  
  224.     # Put debugger in trace mode.
  225.     debug_step_gid = 0
  226.     debug_go_mode = 0
  227.     debug_num_steps = 0;
  228.  
  229.     for (gid in debug_fun_breakpoints)
  230.         if ( and(debug_fun_bp_types[gid], BP_GOTO_POINT))
  231.             debug_remove_goto_point( gid );
  232.  
  233.     if (debugger_running)
  234.         debugger_running = 0;
  235.  
  236.     debug_fun( 0, 1 );
  237.  
  238. }
  239.  
  240.  
  241. # Contents is an array of strings to go in the popup window
  242. # This is a message() function that works
  243. # Used for debugging.
  244. #    local function mymessage(msg)
  245. #    {
  246. #        local x
  247. #        x[1] = msg
  248. #        popup("Here is a message",x)
  249. #    }
  250. #
  251. local function popup(winname,contents)
  252. {
  253.     local i
  254.     local width = length(winname)
  255.     local height
  256.     local curbuf = current_buffer
  257.     local curwin = current_window
  258.     for (i in contents) {
  259.         if (length(contents[i]) > width) { width = length(contents[i]); }
  260.         height++
  261.     }
  262.     width += 3;  # Add 2 for borders and 1 for a pleasing space
  263.     height += 2; # Add 2 for borders.
  264.     if (width > display_width) { width = display_width; }
  265.     if (height < 4) { height = 4; }        # Minimum height
  266.     current_window = create_factory_window( (display_width - width) / 2,
  267.                 3,
  268.                 width,
  269.                 height )
  270.     current_buffer = create_buffer( \
  271.             "DEBUG", \
  272.             "",
  273.             BUFFER_SYSTEM + BUFFER_NO_UNDO )
  274.     attach_window_buffer(current_window,current_buffer)
  275.     window_name = winname
  276.  
  277.     for (i in contents) {
  278.         insert_string(contents[i])
  279.         insert_newline()
  280.     }
  281.  
  282.     goto_buffer_top()
  283.     display_update()
  284.     getkey()
  285.     delete_buffer(current_buffer)
  286.     delete_window(current_window)
  287.     current_buffer = curbuf
  288.     assign_current_window( curwin );
  289. }
  290.  
  291.  
  292.  
  293.  
  294. # Print the call stack
  295. function debug_callstack()
  296. {
  297.     local i, n, x, argc, arglist = ""
  298.     local popbuf
  299.  
  300.     if (!debug_gid)
  301.         return;
  302.  
  303.     for (n=1; (x = debug_get_frame(n)); n++) {
  304.         # x[1] is gid, x[2] is lineno, x[3] is argc, x[4] is param list
  305.         # Create the list of function arguments
  306.         argc = x[3]
  307.         for (i = 1; i <= argc; i++) {
  308.             arglist = arglist debug_get_stack_var(n,i)
  309.             if (i != argc) arglist = arglist ","
  310.         }
  311.         popbuf[n*2] = substr(function_name(x[1]) "(" arglist ")", 1, 60)
  312.         popbuf[n*2+1] = sprintf("    at %s:%d",
  313.             get_source_file_name(x[1]),x[2]);
  314.     }
  315.     popup("Call Stack",popbuf)
  316. }
  317.  
  318.  
  319. function debug_prev_screen(){
  320.     if (debugger_running) {
  321.         assign_current_window( original_window );
  322.         current_buffer = original_buffer;
  323.         display_update();
  324.  
  325.         getkey();
  326.  
  327.         current_window = debug_window;
  328.         current_window = debug_command_window;
  329.         current_window = (command_mode) ? debug_command_window : debug_window;
  330.         display_update();
  331.     }
  332. }
  333.  
  334. function debug_break(){
  335.     debug_go_mode = 0
  336.     debug_step_gid = 0
  337. }
  338.  
  339.  
  340.  
  341. # Step over function call.
  342. # This will not work if the function is called recursively.
  343. function debug_step()
  344. {
  345.     debug_go_mode = 0
  346.     debug_step_gid = debug_gid
  347.     process_end(1)        # Run function some more.
  348. }
  349.  
  350.  
  351. function debug_trace() {
  352.     debug_go_mode = 0
  353.     debug_step_gid = 0
  354.     process_end(1)
  355. }
  356.  
  357.  
  358. function debug_esc() {
  359.     debug_go_mode = 0
  360.     debug_step_gid = 0
  361.     debug_view_file = "???";
  362.     debug_filename = ""
  363.     delete_buffer( debug_buffer )
  364.     process_end(0)
  365.     remove_break_handler()
  366. }
  367.  
  368.  
  369. # Print the value of a variable in the message box.
  370. local function print_val(varname,val)
  371. {
  372.     local typo
  373.  
  374.     current_window = debug_command_window;
  375.     current_buffer = debug_command_buffer;
  376.  
  377.     typo = typeof( val )
  378.  
  379.     if ( typo == "array" ) {
  380.         display_array( val )
  381.         return;
  382.     } else if( 0 + val ) {
  383.         val = sprintf( "%s  (hex 0x%04X)", val, val )
  384.     } else if( typo == "string" ){
  385.         val = "\"" val "\""
  386.     }
  387.  
  388.     debug_message( sprintf("%s == %s, type: %s", varname, val, typo ))
  389.     debug_newline();
  390. }
  391.  
  392.  
  393. # If name is a function parameter or local variable of the current
  394. # function being debugged, then return the index of that variable.
  395. # stframe is the frame number of the function desired.
  396. local function debug_find_stvar(varname,stframe)
  397. {
  398.     local x, list,list1,n,i
  399.     if ((x = debug_get_frame(stframe))) {
  400.         split(x[4],list1,";")        # x[4] is the parameter;local list
  401.         n = split(list1[1],list)    # list1[1] is the parameters
  402.         for (i = 1; i <= n; i++) {
  403.             if (list[i] == varname) return(i)
  404.         }
  405.         n = split(list1[2],list)    # list1[2] is the locals
  406.         for (i = 1; i <= n; i++) {
  407.             if (list[i] == varname) return(- i)
  408.         }
  409.     }
  410.     return(0)
  411. }
  412.  
  413.  
  414. #
  415. # List Breakpoints
  416. #
  417. function bl()
  418. {
  419.     local    i,j = 0;
  420.     local    gid = 0;
  421.     local    cw;
  422.     local    top, bottom;
  423.  
  424.     for (i in debug_fun_breakpoint_names) {
  425.         if (!j)   debug_message( "Breakpoints" );
  426.         debug_newline( 1 );
  427.         debug_message( sprintf( "%4d %s %s", j++, 
  428.             and(debug_fun_bp_types[i],BP_ENABLED) ? "e" : "d", \
  429.                 debug_fun_breakpoint_names[i] ));
  430.     }
  431.  
  432.     if (debug_filename && 
  433.             (current_window == debug_window) || 
  434.             (current_window == debug_command_window)) {
  435.         cw = current_window;
  436.         current_window = debug_window;
  437.         top = window_first;
  438.         bottom = current_line + distance_to_window_bottom();
  439.         while (top <= bottom) {
  440.             if ((top != current_line) && 
  441.                 ((debug_filename ":" top) in debug_fun_breakpoint_names)) {
  442.                 highlight_window( 0, top - window_first, 
  443.                     window_text_width, 1, 0x000F,
  444.                     debug_window );
  445.             }
  446.             top++;
  447.         }
  448.         breakpoints_visible = 1;
  449.         assign_current_window( cw );
  450.     }
  451.  
  452.     if (!j)
  453.         debug_message( "No Breakpoints Set" );
  454.  
  455.     debug_newline();
  456. }
  457.  
  458.  
  459. #
  460. # Clear Breakpoint
  461. #
  462. function bc( str )
  463. {
  464.     local gid,i;
  465.  
  466.     i = (str == "*" ? -1 : atoi( str ));
  467.     if ((i == 0) && (str != "0"))
  468.         return;
  469.     
  470.     if (i >= 0) {
  471.         gid = bpindex_to_gid( i );
  472.         if ((gid) && (gid in debug_fun_breakpoints)) {
  473.             delete debug_fun_breakpoints[gid]
  474.             delete debug_fun_breakpoint_names[gid]
  475.             delete debug_fun_bp_types[gid];
  476.         } else {
  477.             debug_message("Breakpoint " i " not set.")
  478.             debug_newline();
  479.         }
  480.     } else {
  481.         # Clear all breakpoints
  482.         delete debug_fun_breakpoints
  483.         delete debug_fun_breakpoint_names;
  484.         delete debug_fun_bp_types;
  485.     }
  486. }
  487.  
  488.  
  489. #
  490. # Disable Breakpoint
  491. #
  492. function bd( str ){
  493.     local gid,i;
  494.  
  495.     i = (str == "*" ? -1 : atoi( str ));
  496.     if ((i == 0) && (str != "0"))
  497.         return;
  498.     
  499.     if (i >= 0) {
  500.         gid = bpindex_to_gid( i );
  501.         if ((gid) && (gid in debug_fun_breakpoints))
  502.             debug_fun_bp_types[gid] = and( debug_fun_bp_types[gid], not(BP_ENABLED));
  503.     } else {
  504.         for (gid in debug_fun_bp_types)
  505.             debug_fun_bp_types[gid] = and( debug_fun_bp_types[gid], not(BP_ENABLED));
  506.     }
  507. }
  508.  
  509. #
  510. # Enable Breakpoint
  511. #
  512. function be( str ){
  513.     local gid,i;
  514.  
  515.     i = (str == "*" ? -1 : atoi( str ));
  516.     if ((i == 0) && (str != "0"))
  517.         return;
  518.     
  519.     if (i >= 0) {
  520.         gid = bpindex_to_gid( i );
  521.         if (gid) 
  522.             debug_fun_bp_types[gid] = or( debug_fun_bp_types[gid], BP_ENABLED);
  523.     } else {
  524.         for (gid in debug_fun_bp_types)
  525.             debug_fun_bp_types[gid] = or( debug_fun_bp_types[gid], BP_ENABLED);
  526.     }
  527. }
  528.  
  529.  
  530.  
  531. # 
  532. # Set Breakpoints
  533. #
  534. function bp(funname)
  535. {
  536.     local    gid;
  537.     local    i = 0;
  538.     local    msglvl = message_level;
  539.  
  540.     debug_init()
  541.  
  542.     message_level = 2;
  543.     gid = function_id(funname)
  544.     message_level = msglvl;
  545.  
  546.     # This is magic: acceptable gids lie in the range 1000 to 8000
  547.     if (!gid || (gid < 1000 || gid >= 8000)) {
  548.         debug_message("Invalid break address: " funname)
  549.         debug_newline();
  550.         return 0
  551.     }
  552.  
  553.     debug_fun_breakpoints[gid] = 0
  554.     debug_fun_breakpoint_names[gid] = function_name( gid );
  555.     debug_fun_bp_types[gid] = debug_go_mode ? BP_ENABLED + BP_GOTO_POINT : BP_ENABLED;
  556.  
  557.     if (!debugger_running) {
  558.         #
  559.         # don't make the windows visible unless the breakpoints
  560.         # were set from within the debugger.
  561.         #
  562.         hide_window( debug_window );
  563.         hide_window( debug_command_window );
  564.  
  565.         debug_go_mode = 1;
  566.         debug_step_gid = 0;
  567.         debug_function(debug_id)
  568.     }
  569.     return gid;
  570. }
  571.  
  572.  
  573. function bp_line(){
  574.     local    fn;
  575.  
  576.     if (debug_view_file) {
  577.         fn = buildpath( debug_view_file ) ":" current_line;
  578.  
  579.         if  (debug_lineno && (current_line != debug_lineno))
  580.             highlight_window( 0, current_line - window_first, 
  581.                 window_text_width, 1, debug_color_text,
  582.                 debug_window );
  583.         if (fn in debug_fun_breakpoints) {
  584.             delete( debug_fun_breakpoints[fn] );
  585.             delete( debug_fun_bp_types[fn] );
  586.             delete( debug_fun_breakpoint_names[fn] );
  587.         } else {
  588.             debug_bp_linenos[ current_line ] = 0;
  589.             debug_fun_breakpoints[ fn ] = current_line;
  590.             debug_fun_bp_types[ fn ] = BP_ENABLED;
  591.             debug_fun_breakpoint_names[ fn ] = fn;
  592.             highlight_window( 0, current_line - window_first, 
  593.                 window_text_width, 1, 0x000F,
  594.                 debug_window );
  595.             breakpoints_visible = 1;
  596.         }
  597.     }
  598. }
  599.  
  600.  
  601.  
  602. function debug_go()
  603. {
  604.     debug_step_gid = 0;
  605.     debug_go_mode = 1
  606.     process_end(1)
  607. }
  608.  
  609.  
  610. # Function to perform ? debug command.
  611. # Prompt for variable, then print it out.
  612. #
  613. function debug_query( varname )
  614. {
  615.     local msglev = message_level
  616.     local fid,n
  617.     local val
  618.  
  619.     if (!varname)
  620.         return;
  621.  
  622.     assign_current_window( original_window );
  623.     current_buffer = original_buffer;
  624.  
  625.     # Look for local or parameter, then module local var, then global.
  626.     # Turn off error messages while we are doing this.
  627.     message_level = 2
  628.     if (debug_gid && (n = debug_find_stvar(varname,1))) {
  629.         print_val(varname,debug_get_stack_var(1,n))
  630.     }
  631.     else if ((fid = quoted_function_id(path_fname(debug_filename) ":" varname)) ||
  632.             (fid = quoted_function_id(varname))) {
  633.         print_val(varname,execute_function(fid))
  634.     }
  635.     else {
  636.         current_window = debug_command_window;
  637.         current_buffer = debug_command_buffer;
  638.         debug_message("Variable \"" varname "\" not found.");
  639.         debug_newline();
  640.     }
  641.     message_level = msglev
  642.  
  643.     current_window = debug_command_window;
  644.     current_window = debug_window;
  645.     current_window = debug_command_window;
  646. }
  647.  
  648.  
  649. # Call this with the gid and line number of function being debugged,
  650. # or with gid == 0 to just bring up the debugger on nothing.
  651. # debug_session returns 1 to continue debugging, 0 to quit
  652. local function debug_session(){
  653.     local    filename = debug_filename;
  654.     local    cb;
  655.  
  656.     attach_break_handler()
  657.  
  658.     original_window = current_window
  659.     original_buffer = current_buffer
  660.  
  661.     if (!debugger_running) {
  662.         restore_window( debug_window );
  663.         restore_window( debug_command_window );
  664.         debugger_running = 1;
  665.     }
  666.  
  667.     unhighlight_line();
  668.  
  669.     current_window = debug_command_window;
  670.  
  671.     debug_at()
  672.  
  673.     if (command_mode)
  674.         current_window = debug_command_window;
  675.  
  676.     push_keymap( command_mode ? debug_command_keymap : debug_keymap );
  677.  
  678.     debugger_running = process_begin()+0
  679.  
  680.     pop_keymap()
  681.  
  682.     if (!debugger_running) {
  683.         hide_window( debug_command_window );
  684.         hide_window( debug_window );
  685.     }
  686.  
  687.     assign_current_window( original_window);
  688.     current_buffer = original_buffer;
  689.  
  690.     if ( !( debugger_running && !debug_flip) )
  691.         display_update()
  692.  
  693.     return(debugger_running)
  694. }
  695.  
  696.  
  697.  
  698. local function debug_file_display( filename ){
  699.     local def_buf_eol = default_buffer_eol_string;
  700.  
  701.     debug_view_file = filename;
  702.     delete_buffer( debug_buffer )
  703.  
  704.  
  705.     default_buffer_eol_string = "\r\n"
  706.     current_buffer =
  707.     debug_buffer = create_buffer( debug_gid    \
  708.             ? "FILE: " debug_filename " FUNCTION: " function_name(debug_gid) \
  709.             : debug_empty_name,
  710.         debug_filename,
  711.         BUFFER_SYSTEM + BUFFER_NO_UNDO + BUFFER_READ_ONLY)
  712.     default_buffer_eol_string = def_buf_eol;
  713.  
  714.     buffer_tabs = debug_tabs;
  715.     attach_window_buffer( current_window, current_buffer );
  716. }
  717.  
  718. function debug_at()
  719. {
  720.     current_window = debug_window;
  721.     
  722.  
  723.     #
  724.     # if the current file displayed doesn't equal the one that's
  725.     # suppose to be displayed, find the one to display
  726.     #
  727.     if (debug_filename != debug_view_file) {
  728.         debug_filename  = debug_gid ? get_source_file_name(debug_gid) : "";
  729.         debug_file_display( debug_filename );
  730.     }
  731.  
  732.     if (debug_gid) {
  733.         current_line = debug_lineno;
  734.         center_cursor();
  735.         highlight_line( debug_color_highlight );
  736.     }
  737.  
  738. }
  739.  
  740.  
  741. local    currentFrame = 1;
  742.  
  743. # Gid is the function_id of the function being executed.
  744. # lineno is the line number in that function.
  745. #
  746. function debug_fun(gid,lineno)
  747. {
  748.     local    fn;
  749.     local    i,ln;
  750.     local    x;
  751.  
  752.     # If we are performing a debug_step function,
  753.     # keep going until we get back to the function
  754.     # we did the step in or stepping out of.
  755.     #
  756.     if (debug_step_gid && (gid != debug_step_gid)) {
  757.         if ( debug_get_frame(currentFrame) ) {
  758.             debug_function(debug_id)
  759.             return;
  760.         }
  761.     }
  762.  
  763.     if (debug_num_steps) {
  764.         if (debug_num_steps != -1)
  765.             --debug_num_steps;
  766.         if (debug_num_steps) {
  767.             if (!keyboard_input_pending || debug_step_gid) {
  768.                 original_window = current_window
  769.                 original_buffer = current_buffer
  770.  
  771.                 if (debug_gid != gid) {
  772.                     debug_filename = gid ? get_source_file_name(gid) : "";
  773.                     debug_gid = gid;
  774.                 }
  775.  
  776.                 debug_lineno = lineno;
  777.                 unhighlight_line();
  778.                 debug_at();
  779.                 if (!debug_gid)
  780.                     highlight_line( debug_color_highlight ); 
  781.     display_update();
  782.  
  783.                 assign_current_window( original_window );
  784.                 current_buffer = original_buffer;
  785.  
  786.                 debug_function(debug_id)
  787.  
  788.                 return;
  789.             }
  790.             if (!debug_step_gid)
  791.                 getkey();
  792.             debug_num_steps = 0;
  793.         }
  794.         debug_step_gid = 0;
  795.     }
  796.  
  797.     # If we are performing a debug_go function, keep going
  798.     # until a breakpoint is reached.
  799.     # We remember the first line number of each function.
  800.     if (debug_go_mode) {
  801.         if ( (gid in debug_fun_breakpoints) &&
  802.             and(debug_fun_bp_types[gid], BP_ENABLED) &&
  803.                     (!debug_fun_breakpoints[gid] ||
  804.                     (debug_fun_breakpoints[gid] == lineno))){
  805.             if (!debug_fun_breakpoints[gid])
  806.                 debug_fun_breakpoints[gid] = lineno;
  807.             if (and(debug_fun_bp_types[gid], BP_GOTO_POINT))
  808.                 debug_remove_goto_point( gid );
  809.         } else if (lineno in debug_bp_linenos) {
  810.             fn = gid ? get_source_file_name( gid ) ":" lineno : ""
  811.             if ( !((fn in debug_fun_breakpoints) &&
  812.                     (and(debug_fun_bp_types[fn], BP_ENABLED))) ) {
  813.                 debug_function(debug_id)
  814.                 return;
  815.             }
  816.             delete( debug_bp_linenos );
  817.             for (i in debug_fun_breakpoints)
  818.                 if ( (ln = debug_fun_breakpoints[i]) )
  819.                     debug_bp_linenos[ ln ] = ln;
  820.         } else {
  821.             debug_function(debug_id)
  822.             return;
  823.         }
  824.         debug_go_mode = 0;
  825.         debug_num_steps = 0;
  826.     }
  827.     
  828.     if (debug_gid != gid) {
  829.         debug_filename = gid ? get_source_file_name(gid) : "";
  830.         debug_gid = gid;
  831.     }
  832.  
  833.     debug_lineno = lineno;
  834.  
  835.     for (currentFrame=0; debug_get_frame(currentFrame+1); currentFrame++)
  836.         continue;
  837.  
  838.     remove_break_handler()
  839.     if ( debug_session() ) {
  840.         debug_function(debug_id)
  841.         attach_break_handler()
  842.     }
  843. }
  844.  
  845. local function debug_remove_goto_point( gid ){
  846.     delete( debug_fun_breakpoints[gid] )
  847.     delete( debug_fun_bp_types[gid] )
  848.     delete( debug_fun_breakpoint_names[gid] )
  849. }
  850.  
  851. local function bpindex_to_gid( index ){
  852.     local    gid;
  853.  
  854.     for( gid in debug_fun_bp_types) {
  855.         if (!index) return gid;
  856.         index--;
  857.     }
  858.     return 0;
  859. }
  860.  
  861.  
  862. #-------------------------------------------------------------------
  863. #
  864. #                      Keymap bound functions
  865. #
  866. #-------------------------------------------------------------------
  867.  
  868.  
  869. function debug_left(){ 
  870.     left();
  871.     if (current_column < command_mode+1) {
  872.         scroll_horizontal( -display_width );
  873.         right();
  874.     }
  875. }
  876. function debug_up(){ 
  877.     if (command_mode)
  878.         up(); 
  879.     else {
  880.         up(); 
  881.         highlight_line( debug_color_highlight ); 
  882.     }
  883. }
  884. function debug_down(){ 
  885.     if (command_mode)
  886.         down(); 
  887.     else {
  888.         down(); 
  889.         highlight_line( debug_color_highlight );
  890.     }
  891. }
  892. function debug_bol(){ 
  893.     goto_bol(); 
  894.     scroll_horizontal( -display_width ); 
  895.     right(); 
  896. }
  897. function debug_page_up(){ 
  898.     if (command_mode) { 
  899.         page_up(); current_column = 2;
  900.     } else { 
  901.         page_up();
  902.         highlight_line( debug_color_highlight );
  903.     }
  904. }
  905. function debug_page_dn(){
  906.     if (command_mode) { 
  907.         page_down(); current_column = 2;
  908.     } else { 
  909.         page_down();
  910.         highlight_line( debug_color_highlight );
  911.     }
  912. }
  913. function debug_home(){ 
  914.     goto_buffer_top(); 
  915.     scroll_window_top();
  916.     current_column = command_mode+1; 
  917.     highlight_line( debug_color_highlight );
  918. }
  919. function debug_end(){ 
  920.     goto_buffer_bottom(); 
  921.     scroll_window_bottom();
  922.     current_column = command_mode+1; 
  923.     highlight_line( debug_color_highlight );
  924. }
  925. function debug_backspace(){ 
  926.     if (!command_mode)
  927.         current_window = debug_command_window;
  928.  
  929.     if (current_column > 2) {
  930.         backspace(); 
  931.     }
  932.     
  933.     if (!command_mode)
  934.         current_window = debug_window;
  935. }
  936. function debug_delete_chars(){ 
  937.     if (!command_mode)
  938.         current_window = debug_command_window;
  939.     if (current_column <= current_line_width) {
  940.         delete_chars(1); 
  941.     }
  942.     if (!command_mode)
  943.         current_window = debug_window;
  944. }
  945. function debug_insert_key(){
  946.     if (!command_mode)
  947.         current_window = debug_command_window;
  948.     insert_key( current_key );
  949.     if (!command_mode)
  950.         current_window = debug_window;
  951. }
  952. function debug_resize_window(){
  953.     local    cw = current_window;
  954.  
  955.     if (((current_key == CTRL_G) && command_mode) ||
  956.         ((current_key == CTRL_T) && !command_mode)) {
  957.          current_window = debug_window;
  958.         if (window_height > 3 ) {
  959.             # make the command window larger
  960.              frame_window( window_x0, window_y0, \
  961.                 window_width, window_height - 1 );
  962.             current_window = debug_command_window;
  963.             frame_window( window_x0, window_y0 - 1, \
  964.                 window_width, window_height + 1);
  965.         } 
  966.     } else {
  967.         current_window = debug_command_window;
  968.         if (window_height > 3 ) {
  969.             # make the debug window larger
  970.             frame_window( window_x0, window_y0 + 1, \
  971.                 window_width, window_height - 1);
  972.              current_window = debug_window;
  973.              frame_window( window_x0, window_y0, \
  974.                 window_width, window_height + 1 );
  975.         }
  976.     }
  977.     assign_current_window( cw );
  978. }
  979. function debug_toggle_windows(){
  980.     if ( (command_mode = !command_mode) ) {
  981.         current_window = debug_command_window;
  982.         pop_keymap();
  983.         push_keymap( debug_command_keymap );
  984.     } else {
  985.         current_window = debug_window;
  986.         pop_keymap();
  987.         push_keymap( debug_keymap );
  988.     }
  989. }
  990. function debug_message( str ){
  991.     if (current_window == debug_command_window)
  992.         insert_string( str );
  993.     else
  994.         notify( str );
  995. }
  996.  
  997. function debug_newline( no_prmpt ){
  998.     if (current_window == debug_command_window) {
  999.         insert_newline();
  1000.         insert_key( ord(no_prmpt ? " " : ">") );
  1001.         delete_to_eol();
  1002.     }
  1003. }
  1004.  
  1005. function debug_help()
  1006. {
  1007.     display_help_item( "debug" );
  1008. }
  1009.  
  1010. function debug_enter(){
  1011.     local    cmnd;
  1012.     local    cw = current_window;
  1013.     local    cb = current_buffer;
  1014.     local    ch;
  1015.     local    str;
  1016.     local    orig_cmnd;
  1017.     local    upper_cmnd;
  1018.     local    nch;
  1019.     local    id;
  1020.  
  1021.     current_window = debug_command_window;
  1022.     current_buffer = debug_command_buffer;
  1023.  
  1024.     # read the command from the current line
  1025.     #
  1026.     current_column = 2;
  1027.     cmnd = read_buffer();
  1028.     goto_buffer_bottom();
  1029.  
  1030.     debug_newline();
  1031.  
  1032.     if (distance_to_window_bottom() < 0)
  1033.         scroll_window_bottom();
  1034.     else if (distance_to_window_top() < 0)
  1035.         scroll_window_top();
  1036.  
  1037.     orig_cmnd = cmnd;
  1038.     cmnd = compress( ltrim( trim( cmnd, " \t" ), " \t" ), " \t" );
  1039.     upper_cmnd = toupper( cmnd );
  1040.     ch = substr(upper_cmnd,1,1);
  1041.  
  1042.     if (cmnd) {
  1043.         ch == toupper( substr(cmnd,1,1) );
  1044.         if (ch == "B") {
  1045.             # Breakpoints
  1046.             #
  1047.             cmnd = substr( cmnd, 2 );
  1048.             ch = toupper( substr( cmnd,1,1 ));
  1049.             if (upper_cmnd == "BL") {
  1050.                 bl();
  1051.             } else if (ch == "P") {
  1052.                 bp( substr( cmnd,2 ) );
  1053.             } else {
  1054.                 str = ltrim( substr( cmnd,2 ));
  1055.                 if (ch == "C")
  1056.                     bc( str );
  1057.                 else if (ch == "E")
  1058.                     be( str );
  1059.                 else if (ch == "D")
  1060.                     bd( str );
  1061.                 else
  1062.                     debug_bad_command( orig_cmnd );
  1063.             }
  1064.         } else if ( (id = function_id( cmnd )) ) {
  1065.             assign_current_window( original_window );
  1066.             current_buffer = original_buffer;
  1067.             execute_function( id );
  1068.         } else {
  1069.             if (cmnd == ".") {
  1070.                 # Restore position
  1071.                 #
  1072.                 debug_at();
  1073.             } else if (ch == "?") {
  1074.                 # Query
  1075.                 #
  1076.                 debug_query( ltrim(trim(substr( cmnd,2 ))));
  1077.             } else if (upper_cmnd == "E") {
  1078.                 # Execute
  1079.                 #
  1080.                 debug_num_steps = -1;
  1081.                 debug_trace();
  1082.             } else if (ch == "G") {
  1083.                 # Go
  1084.                 #
  1085.                 cmnd = ltrim( substr( cmnd,2 ));
  1086.                 if (cmnd != "") {
  1087.                     debug_go_mode = 1
  1088.                     if (bp( cmnd ))
  1089.                         debug_go();
  1090.                 } else
  1091.                     debug_go();
  1092.             } else if (upper_cmnd == "H") {
  1093.                 # Help
  1094.                 #
  1095.                 debug_help();
  1096.             } else if (ch == "P") {
  1097.                 # Step over
  1098.                 #
  1099.                 cmnd = ltrim( substr( cmnd,2 ));
  1100.                 if (cmnd != "") {
  1101.                     if ( (debug_num_steps = atoi( cmnd )) > 0 );
  1102.                         debug_step();
  1103.                 } else
  1104.                     debug_step();
  1105.             } else if ((upper_cmnd == "Q") || (upper_cmnd == "EXIT")) {
  1106.                 # Quit
  1107.                 #
  1108.                 debug_esc();
  1109.             } else if (cmnd== "@") {
  1110.                 # redraw display
  1111.                 #
  1112.                 display_redraw();
  1113.             } else if (cmnd == "K" || cmnd == "k") {
  1114.                 # Stack Trace
  1115.                 #
  1116.                 debug_callstack();
  1117.             } else if (ch == "#") {
  1118.                 # Tabs
  1119.                 #
  1120.                 current_window = debug_window;
  1121.                 current_buffer = debug_buffer;
  1122.                 debug_tabs =
  1123.                 buffer_tabs = substr( cmnd,2 );
  1124.                 display_update();
  1125.                 current_window = debug_command_window;
  1126.                 current_buffer = debug_command_buffer;
  1127.             } else if (ch == "T") {
  1128.                 # Trace
  1129.                 #
  1130.                 cmnd = ltrim( substr( cmnd,2 ));
  1131.                 if (cmnd != "") {
  1132.                     if ( (debug_num_steps = atoi( cmnd )) > 0);
  1133.                         debug_trace();
  1134.                 } else
  1135.                     debug_trace();
  1136.             } else if (ch == "V") {
  1137.                 # View new file
  1138.                 #
  1139.                  current_window = debug_window;
  1140.                 current_buffer = debug_buffer;
  1141.  
  1142.                 debug_view( substr( cmnd,2 ) );
  1143.                  current_window = debug_command_window;
  1144.                 current_buffer = debug_command_buffer;
  1145.             } else if (ch == "/") {
  1146.                 # Search
  1147.                 #
  1148.                  current_window = debug_window;
  1149.                 current_buffer = debug_buffer;
  1150.                 debug_search( orig_cmnd );
  1151.                  current_window = debug_command_window;
  1152.                 current_buffer = debug_command_buffer;
  1153.             } else if (ch == "O") {
  1154.                 cmnd = substr( cmnd, 2 );
  1155.                 ch = toupper( substr( cmnd,1,1 ));
  1156.                 nch = toupper( ltrim(substr( cmnd, 2 )));
  1157.                 if (ch == "R") {
  1158.                     # regex searching option
  1159.                     if (nch == "+")
  1160.                         debug_search_flags = or( debug_search_flags, SEARCH_REGEX )
  1161.                     else if (nch == "-")
  1162.                         debug_search_flags = and( debug_search_flags, not(SEARCH_REGEX) )
  1163.                     else 
  1164.                         debug_bad_command( orig_cmnd );
  1165.                     debug_show_options( OR_OPTION );
  1166.                 } else if (ch == "F") {
  1167.                     # flipping screen
  1168.                     if (nch == "+")
  1169.                         debug_flip = 1;
  1170.                     else if (nch == "-")
  1171.                         debug_flip = 0;
  1172.                     else debug_bad_command( orig_cmnd );
  1173.                     debug_show_options( OF_OPTION );
  1174.                 } else if (ch == "C") {
  1175.                     # case sensitive searching option
  1176.                     if (nch == "+")
  1177.                         debug_search_flags = and( debug_search_flags, not(SEARCH_IGNORE_CASE) )
  1178.                     else if (nch == "-")
  1179.                         debug_search_flags = or( debug_search_flags, SEARCH_IGNORE_CASE )
  1180.                     else 
  1181.                         debug_bad_command( orig_cmnd );
  1182.                     debug_show_options( OC_OPTION );
  1183.                 } else if (ch == "") {
  1184.                     debug_show_options( O_OPTION );
  1185.                 } else {
  1186.                     debug_bad_command( orig_cmnd );
  1187.                 }
  1188.             } else {
  1189.                 debug_bad_command( orig_cmnd );
  1190.             }
  1191.         }
  1192.     }
  1193.  
  1194.  
  1195.     if (distance_to_window_bottom() < 0)
  1196.         scroll_window_bottom();
  1197.     else if (distance_to_window_top() < 0)
  1198.         scroll_window_top();
  1199.  
  1200.  
  1201.     assign_current_window( cw );
  1202.     current_buffer = cb;
  1203. }
  1204.  
  1205. function debug_bad_command( cmnd ){
  1206.     debug_message( "Unknown command: " cmnd );
  1207.     debug_newline();
  1208. }
  1209.  
  1210.  
  1211. function debug_left_press(){
  1212.     local    mp;
  1213.     local    wc = window_containing( mouse_event_x, mouse_event_y );
  1214.  
  1215.     if (wc == debug_window) {
  1216.         current_window = debug_window;
  1217.         command_mode = 0;
  1218.     } else if (wc == debug_command_window) {
  1219.         current_window = debug_command_window;
  1220.         command_mode = 1;
  1221.     } else
  1222.         return;
  1223.  
  1224.     if (window_border_contains( mouse_event_x, mouse_event_y, debug_window ) ||
  1225.       window_border_contains( mouse_event_x, mouse_event_y, debug_command_window )) {
  1226.         mp = mouse_position( 1 );
  1227.         if ( and(mp, MOUSE_N + MOUSE_E ) && !and(mp, MOUSE_W) ) {
  1228.             if (!command_mode) 
  1229.                 unhighlight_line();
  1230.             left_press( 1 );
  1231.             if (!command_mode) 
  1232.                 highlight_line( debug_color_highlight );
  1233.         }
  1234.     }
  1235. }
  1236.  
  1237.  
  1238. local    last_search = "";
  1239. local    debug_search_flags = 0;
  1240.  
  1241. function debug_search( cmnd ){
  1242.     if (!debug_search_flags)
  1243.         debug_search_flags = SEARCH_FORWARD    + \
  1244.                     SEARCH_IGNORE_CASE + \
  1245.                     SEARCH_ADVANCE    + \
  1246.                     SEARCH_WRAPS    + \
  1247.                     SEARCH_MAXIMAL_MATCH;
  1248.  
  1249.     if ( length( cmnd ) > index( cmnd, "/") )
  1250.         last_search = substr( cmnd, index( cmnd, "/" )+1 );
  1251.  
  1252.     if (search( last_search, debug_search_flags ))
  1253.         center_cursor();
  1254.     highlight_line( debug_color_highlight );
  1255. }
  1256.  
  1257. function debug_view( fname ){
  1258.     local    cb = current_buffer;
  1259.     local def_buf_eol = default_buffer_eol_string;
  1260.  
  1261.  
  1262.     fname = ltrim( trim( fname ) )
  1263.  
  1264.     default_buffer_eol_string = "\r\n"
  1265.     current_buffer = create_buffer( \
  1266.             "FILE: " path_fname(fname) path_ext(fname),
  1267.             fname,
  1268.             BUFFER_SYSTEM + BUFFER_NO_UNDO + BUFFER_READ_ONLY)
  1269.     default_buffer_eol_string = def_buf_eol;
  1270.  
  1271.     if (buffer_size) {
  1272.         buffer_tabs = debug_tabs;
  1273.  
  1274.         delete_buffer( debug_buffer )
  1275.         debug_buffer = current_buffer;
  1276.  
  1277.         debug_view_file = fname;
  1278.         attach_window_buffer( debug_window, debug_buffer)
  1279.     }
  1280.  
  1281.     current_buffer = cb;
  1282. }
  1283.  
  1284.  
  1285. #
  1286. # options settings to be shown
  1287. #
  1288. local OR_OPTION = 0x01
  1289. local OF_OPTION = 0x02
  1290. local OC_OPTION = 0x04
  1291. local O_OPTION  = 0x07
  1292.  
  1293. local function debug_show_options( option ){
  1294.     if ( and(option, OR_OPTION) ) {
  1295.         if (and(debug_search_flags, SEARCH_REGEX))
  1296.             debug_message( "Regular Expression Searching On.")
  1297.         else
  1298.             debug_message( "Regular Expression Searching Off.")
  1299.         debug_newline();
  1300.     }
  1301.     if ( and(option, OF_OPTION) ) {
  1302.         if (debug_flip)
  1303.             debug_message( "Window Flipping On.")
  1304.         else
  1305.             debug_message( "Window Flipping Off.")
  1306.         debug_newline();
  1307.     }
  1308.     if ( and(option, OC_OPTION) ) {
  1309.         if (and(debug_search_flags, SEARCH_IGNORE_CASE))
  1310.             debug_message( "Case Searching Off.")
  1311.         else
  1312.             debug_message( "Case Searching On.")
  1313.         debug_newline();
  1314.     }
  1315. }
  1316.  
  1317.  
  1318.  
  1319. local y_highlight = -1;
  1320. local y_ext = -1;
  1321. local x_ext = -1;
  1322.  
  1323. local function highlight_line( attr ){
  1324.  
  1325.  
  1326.     display_update();    # this will set window_first appropriately
  1327.     unhighlight_line();
  1328.  
  1329.     y_highlight = debug_lineno - window_first;
  1330.  
  1331.     y_ext = window_text_height;
  1332.     x_ext = window_text_width;
  1333.  
  1334.     if ((y_highlight < 0) || (y_highlight >= y_ext))
  1335.         return;
  1336.  
  1337.     highlight_window( 0, y_highlight, x_ext, 1, attr, debug_window );
  1338. }
  1339.  
  1340. local function unhighlight_line(){
  1341.  
  1342.     if (breakpoints_visible) {
  1343.         breakpoints_visible = 0;
  1344.         display_redraw();
  1345.     } else {
  1346.         # use the last highlighted line setting to unhighlight
  1347.         #
  1348.         if ((y_highlight >= 0) && (y_highlight < y_ext))
  1349.             highlight_window( 0, y_highlight, x_ext, 1, debug_color_text,
  1350.                 debug_window );
  1351.     }
  1352.     y_highlight = -1;
  1353. }
  1354.  
  1355.  
  1356.  
  1357. local function get_source_file_name( gid ){
  1358.     local    fn = source_file_name( gid );
  1359.     local    src_name;
  1360.  
  1361.     if (findfirst( fn ) == "")
  1362.         return buildpath( path_fname( fn ) path_ext( fn ) );
  1363.     return fn;
  1364. }
  1365.  
  1366. global function debug_ctrl_break(){
  1367.     debug_num_steps = 0;
  1368.     debug_go_mode = 0;
  1369. }
  1370.  
  1371.  
  1372. function attach_break_handler(){
  1373.     if (!ctrl_break_attached) {
  1374.         attach_event_handler( EVENT_CTRL_BREAK, function_id( "debug_ctrl_break" ));
  1375.         ctrl_break_attached = 1;
  1376.     }
  1377. }
  1378.  
  1379.  
  1380. function remove_break_handler(){
  1381.     if (ctrl_break_attached) {
  1382.         delete_event( EVENT_CTRL_BREAK, function_id( "debug_ctrl_break" ));
  1383.         ctrl_break_attached = 0;
  1384.     }
  1385. }
  1386.  
  1387.