home *** CD-ROM | disk | FTP | other *** search
/ OS/2 Shareware BBS: 5 Edit / 05-Edit.zip / p2demo21.exe / PEL / DEBUG.PEL < prev    next >
Text File  |  1995-04-04  |  57KB  |  2,048 lines
  1. # $Header:   P:\source\wmacros\debug.pev   1.47   04 Apr 1995 18:06:32   PFHDWM0  $
  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.  
  20. #### $Workfile:   debug.pel  $: sageedit debugger entry points
  21. #
  22.  
  23. global dhDebug
  24.  
  25. global original_keymap           
  26. local main_window          
  27. local main_buffer          
  28.            
  29. local debug_text_fg           = COLOR_NEON_BABY_BLUE
  30. local debug_text_bg           = COLOR_BLACK
  31. local debug_line_fg           = COLOR_RED
  32. local debug_line_bg           = COLOR_BLACK
  33. #local debug_color_text        = COLOR_NEON_BABY_BLUE
  34. local debug_color_highlight   = COLOR_YELLOW
  35.  
  36. global debug_flip = 1;
  37. local debug_remote_window
  38. local debug_window;
  39. local debug_empty_name = "Debug Window: no function active"
  40. local debug_keymap;
  41. local debug_buffer;
  42. local debug_filename = "";
  43. local debug_enabled             # True if debug has been called
  44. local original_window;          # Saved when function is debugged.
  45. local original_buffer;
  46. local debug_id;
  47. local debug_tabs = default_buffer_tabs;
  48. local debug_view_file = "???"
  49. local debug_num_steps = 0;
  50.  
  51. local IDM_FIRST_ITEM           = 0x200
  52. local IDM_DEBUG_FILE_OPEN      = 0x200
  53. local IDM_DEBUG_FILE_EXIT      = 0x201
  54. local IDM_DEBUG_FILE           = 0x202
  55. local IDM_DEBUG_BP_LIST        = 0x203
  56. local IDM_DEBUG_BP_SETCLR      = 0x204
  57. local IDM_DEBUG_BP_CLRALL      = 0x205
  58. local IDM_DEBUG_BP             = 0x206
  59. local IDM_DEBUG_VIEW_CALLSTACK = 0x207
  60. local IDM_DEBUG_VIEW_LOCALS    = 0x208
  61. local IDM_DEBUG_VIEW_VAR       = 0x209
  62. local IDM_DEBUG_VIEW           = 0x20A
  63. local IDM_DEBUG_RUN_GO         = 0x20B
  64. local IDM_DEBUG_RUN_STEPINTO   = 0x20C
  65. local IDM_DEBUG_RUN_STEPOVER   = 0x20D
  66. local IDM_DEBUG_RUN            = 0x20E
  67. local IDM_DEBUG_SEARCH_FORWARD = 0x20F
  68. local IDM_DEBUG_SEARCH_AGAIN   = 0x210
  69. local IDM_DEBUG_SEARCH_LINE    = 0x211
  70. local IDM_DEBUG_SEARCH         = 0x212
  71. local IDM_LAST_ITEM            = 0x212
  72.  
  73. local debug_mta[]
  74.  
  75. #
  76. # debug_fun_breakpoints is an array of function gids to break on.
  77. # The index is the gid as a string.  The value is the gid itself.
  78. # The distinction is important because function_name requires the gid itself.
  79. # debug_fun_lineno are the line numbers of the start of the function,
  80. # determined when we hit it.
  81. #
  82. local debug_fun_breakpoints;
  83. local debug_fun_breakpoint_names;
  84. local debug_fun_bp_types;               # 0 = disabled, 1 = enabled, 2 = goto point
  85. local debug_bp_linenos;
  86. local breakpoints_visible = 0;
  87. local ctrl_break_attached = 0;
  88.  
  89. local BP_ENABLED                = 0x01;
  90. local BP_GOTO_POINT             = 0x02;
  91.  
  92. local debug_gid, debug_lineno = 0; # GID and lineno of current debugged function
  93. local debug_step_gid;           # GID of function during debug_step
  94. local debug_go_mode;
  95.  
  96. local debug_tbhand   = 0
  97. local debug_menu     = 0
  98. local filemenu         = 0
  99. local bpmenu        = 0
  100. local runmenu       = 0
  101. local viewmenu         = 0
  102. local searchmenu    = 0
  103.  
  104. #local debug_command_keymap
  105. #local debug_command_window
  106. #local debug_command_buffer
  107.  
  108. #local CTRL_G = 8711
  109. #local CTRL_T = 5140
  110.  
  111. local function set_debug_window()
  112. {
  113.    current_window = debug_window
  114.    current_buffer = debug_buffer
  115.    current_keymap = debug_keymap
  116. }
  117.  
  118. local function set_user_window()
  119. {
  120.    current_window = original_window
  121.    current_buffer = original_buffer
  122.    current_keymap = original_keymap
  123. }
  124.  
  125. local function update_bp_marks()
  126. {
  127.    local old_window = current_window
  128.    current_window = debug_window
  129.  
  130.    linenumber_format = linenumber_format
  131.  
  132.    current_window = old_window
  133. }
  134.  
  135. global debugger_running = 0;
  136.  
  137. global function debug_reset()
  138. {
  139.    debug_gid        = 0;
  140.    debug_filename   = "";
  141. }      
  142.  
  143. global function debug_win( dialogTitle)
  144. {
  145. } #end debug window
  146.  
  147.  
  148. local function create_debug_menu( parent )
  149. {
  150.    # Create Debugger menu
  151.    debug_menu = create_menu()
  152.    
  153.    # File menu
  154.    debug_mta[ IDM_DEBUG_FILE_OPEN      ] =  "~Open..."
  155.    debug_mta[ IDM_DEBUG_FILE_EXIT      ] =  "~Exit"
  156.  
  157.    filemenu = create_menu();
  158.    append_menuitem( filemenu, IDM_DEBUG_FILE_OPEN, MI_DEFAULT, 
  159.                      debug_mta[ IDM_DEBUG_FILE_OPEN ], "debug_open" )
  160.    append_menuitem( filemenu, IDM_DEBUG_FILE_EXIT, MI_DEFAULT, 
  161.                      debug_mta[ IDM_DEBUG_FILE_EXIT ], "debug_esc" )
  162.  
  163.    append_menuitem( debug_menu, IDM_DEBUG_FILE, MI_SUBDEFAULT, "~File", filemenu )
  164.  
  165.    # Breakpoint submenu
  166.    debug_mta[ IDM_DEBUG_BP_LIST        ] =  "~List..."   
  167.    debug_mta[ IDM_DEBUG_BP_SETCLR      ] =  "~Set/Clear"
  168.    debug_mta[ IDM_DEBUG_BP_CLRALL      ] =  "~Clear all"
  169.  
  170.    bpmenu = create_menu();
  171.    append_menuitem( bpmenu, IDM_DEBUG_BP_LIST,     MI_DEFAULT, 
  172.                      debug_mta[ IDM_DEBUG_BP_LIST ], "debug_breakpoint_list" )
  173.    append_menuitem( bpmenu, IDM_DEBUG_BP_SETCLR,   MI_DEFAULT, 
  174.                      debug_mta[ IDM_DEBUG_BP_SETCLR ], "bp_line" )
  175.    append_menuitem( bpmenu, IDM_DEBUG_BP_CLRALL,   MI_DEFAULT, 
  176.                      debug_mta[ IDM_DEBUG_BP_CLRALL ],"bc -1" )
  177.    
  178.    append_menuitem( debug_menu, IDM_DEBUG_BP, MI_SUBDEFAULT, "~Breakpoints", bpmenu )
  179.  
  180.    # Run submenu
  181.    debug_mta[ IDM_DEBUG_RUN_GO         ] =  "~Go"     
  182.    debug_mta[ IDM_DEBUG_RUN_STEPINTO   ] =  "~Step into"
  183.    debug_mta[ IDM_DEBUG_RUN_STEPOVER   ] =  "~Step over"
  184.  
  185.    runmenu = create_menu()
  186.    append_menuitem( runmenu, IDM_DEBUG_RUN_GO,        MI_DEFAULT, 
  187.                      debug_mta[ IDM_DEBUG_RUN_GO ], "debug_go" )
  188.    append_menuitem( runmenu, IDM_DEBUG_RUN_STEPINTO,  MI_DEFAULT, 
  189.                      debug_mta[ IDM_DEBUG_RUN_STEPINTO ], "debug_trace" )
  190.    append_menuitem( runmenu, IDM_DEBUG_RUN_STEPOVER,  MI_DEFAULT, 
  191.                      debug_mta[ IDM_DEBUG_RUN_STEPOVER ], "debug_step" )
  192.    
  193.    append_menuitem( debug_menu, IDM_DEBUG_RUN, MI_SUBDEFAULT, "~Run", runmenu )
  194.  
  195.    # View submenu
  196.    debug_mta[ IDM_DEBUG_VIEW_CALLSTACK ] =  "~Call stack"      
  197.    debug_mta[ IDM_DEBUG_VIEW_LOCALS    ] =  "~Local variables"
  198.    debug_mta[ IDM_DEBUG_VIEW_VAR       ] =  "~Variable"     
  199.  
  200.    viewmenu = create_menu();
  201.    append_menuitem( viewmenu, IDM_DEBUG_VIEW_CALLSTACK, MI_DEFAULT, 
  202.                      debug_mta[ IDM_DEBUG_VIEW_CALLSTACK ], "my_debug_callstack" )
  203.    append_menuitem( viewmenu, IDM_DEBUG_VIEW_LOCALS,    MI_DEFAULT, 
  204.                      debug_mta[ IDM_DEBUG_VIEW_LOCALS ], "debug_local_variables" )
  205.    append_menuitem( viewmenu, IDM_DEBUG_VIEW_VAR,       MI_DEFAULT, 
  206.                      debug_mta[ IDM_DEBUG_VIEW_VAR ], "debug_query_var_info" )
  207.    
  208.    append_menuitem( debug_menu, IDM_DEBUG_VIEW, MI_SUBMENU+MI_DISABLED, "~View", viewmenu )
  209.  
  210.    # Search submenu
  211.    debug_mta[ IDM_DEBUG_SEARCH_FORWARD ] =  "~Search"       
  212.    debug_mta[ IDM_DEBUG_SEARCH_AGAIN   ] =  "Search ~again"
  213.    debug_mta[ IDM_DEBUG_SEARCH_LINE   ]  =  "~Goto line"
  214.  
  215.    searchmenu = create_menu();
  216.    append_menuitem( searchmenu, IDM_DEBUG_SEARCH_FORWARD,   MI_DEFAULT, 
  217.                      debug_mta[ IDM_DEBUG_SEARCH_FORWARD ], "search_forward" )
  218.    append_menuitem( searchmenu, IDM_DEBUG_SEARCH_AGAIN,     MI_DEFAULT, 
  219.                      debug_mta[ IDM_DEBUG_SEARCH_AGAIN ], "search_again" )
  220.    append_menuitem( searchmenu, IDM_DEBUG_SEARCH_LINE,     MI_DEFAULT, 
  221.                      debug_mta[ IDM_DEBUG_SEARCH_LINE ], "goto_line_key" )
  222.    
  223.    append_menuitem( debug_menu, IDM_DEBUG_SEARCH, MI_SUBDEFAULT, "~Search", searchmenu )
  224.  
  225.    change_menu( debug_menu, parent )
  226. }
  227.  
  228. # disable all invalid menu options
  229. local function disable_debug_menu()
  230. {
  231.    modify_menuitem( debug_menu, IDM_DEBUG_VIEW,          MI_DISABLED )
  232.    modify_menuitem( debug_menu, IDM_DEBUG_RUN,           MI_DISABLED )
  233. }
  234.  
  235. # enable all invalid menu options
  236. local function enable_debug_menu()
  237. {
  238.    modify_menuitem( debug_menu, IDM_DEBUG_VIEW,          MI_ENABLED )
  239.    modify_menuitem( debug_menu, IDM_DEBUG_RUN,           MI_ENABLED )
  240. }
  241.  
  242. # This function will use the given id and change the menu text so that
  243. # the key assigned to the function that the menu item executes is displayed
  244. # on the menu
  245. #
  246. local function fix_debug_menu_text()
  247. {
  248.    local keys
  249.    local tab = "\t"
  250.    local functionid
  251.    local menuid
  252.    local oldLevel = message_level
  253.  
  254.    for ( menuid in debug_mta )
  255.       {
  256.       functionid = function_id( menu_functions[menuid] )
  257.    
  258.       # make sure it's valid
  259.       if ( functionid ) 
  260.          {
  261.          # turn of messages
  262.          message_level = 3
  263.             
  264.          # Get the list of keys bound to the id with no angle brackets and 
  265.          # with the "+" as separator within the key name
  266.          #
  267.          keys = function_binding_key( functionid, 1, 1)
  268.             
  269.          modify_menuitem( debug_menu, menuid, MI_ITEMTEXT, debug_mta[menuid] tab keys )
  270.          }  
  271.       }
  272.  
  273.    # restore old message level
  274.    message_level = oldLevel
  275. }
  276.  
  277. local curr_bmp_pos = 0
  278.  
  279. local function bmp_pos( pos )
  280. {
  281.    if ( pos == -1 )
  282.       curr_bmp_pos = 0  
  283.    else if ( pos == TRUE )
  284.       curr_bmp_pos += 34
  285.    else
  286.       curr_bmp_pos += 27
  287.       
  288.    return curr_bmp_pos
  289. }
  290.  
  291. local function create_debug_toolbar( parent )
  292. {
  293.    # copied here from tbar.pel for debugger use
  294.    local    TBMP_FIND         =  10
  295.    local    TBMP_FINDNEXT     =  11
  296.  
  297.    local    TBMP_GO           = 20
  298.    local    TBMP_STEP_INTO    = 21
  299.    local    TBMP_STEP_OVER    = 22
  300.    local    TBMP_DEBUG_END    = 23       
  301.    local    TBMP_SETBP        = 24       
  302.    local    TBMP_QUERY        = 25       
  303.                  
  304.    debug_tbhand = create_toolbar( parent )
  305.  
  306.    insert_toolbaritem(  debug_tbhand, IDM_DEBUG_RUN_GO, TOOLBAR_BUTTON, bmp_pos(-1), 4,  
  307.                         TBMP_GO,       
  308.                         function_id( "debug_go" ) )
  309.  
  310.    insert_toolbaritem(  debug_tbhand, IDM_DEBUG_RUN_STEPINTO, TOOLBAR_BUTTON, bmp_pos(1), 4,
  311.                         TBMP_STEP_INTO,       
  312.                         function_id( "debug_trace" ) )
  313.  
  314.    insert_toolbaritem(  debug_tbhand, IDM_DEBUG_RUN_STEPOVER, TOOLBAR_BUTTON, bmp_pos(0), 4,
  315.                         TBMP_STEP_OVER,       
  316.                         function_id( "debug_step" ) )
  317.  
  318.    insert_toolbaritem(  debug_tbhand, IDM_DEBUG_SEARCH_FORWARD, TOOLBAR_BUTTON, bmp_pos(1), 4,
  319.                         TBMP_FIND,     
  320.                         function_id( "search_forward" ) )
  321.  
  322.    insert_toolbaritem(  debug_tbhand, IDM_DEBUG_SEARCH_AGAIN, TOOLBAR_BUTTON, bmp_pos(0), 4,  
  323.                         TBMP_FINDNEXT, 
  324.                         function_id( "search_again" ) )
  325.  
  326.    insert_toolbaritem(  debug_tbhand, IDM_DEBUG_BP_SETCLR, TOOLBAR_BUTTON, bmp_pos(1), 4,  
  327.                         TBMP_SETBP,       
  328.                         function_id( "bp_line" ) )
  329.  
  330.    insert_toolbaritem(  debug_tbhand, TBMP_QUERY, TOOLBAR_BUTTON, bmp_pos(0), 4,
  331.                         TBMP_QUERY,       
  332.                         function_id( "debug_query_var_info" ) )
  333.  
  334. #   insert_toolbaritem(  debug_tbhand, IDM_DEBUG_FILE_EXIT, TOOLBAR_BUTTON, bmp_pos(1), 4,
  335. #                        TBMP_DEBUG_END,       
  336. #                        function_id( "debug_esc" ) )
  337.  
  338.    show_toolbar( debug_tbhand )
  339.  
  340.    return debug_tbhand
  341. }
  342.  
  343. local function create_debug_keymap()
  344. {
  345.    original_keymap   = current_keymap        
  346.  
  347.    if ( !debug_keymap )
  348.    {
  349.       debug_keymap      = create_keymap( ascii_keymap ) 
  350.                                    
  351.       push_keymap( debug_keymap )
  352.     
  353.       #
  354.       # define command keymap bindings for the debug window and
  355.       # the command window.
  356.       #
  357.       assign_key( "<Up>",             "up"                     )
  358.       assign_key( "<Down>",           "down"                   )
  359.       assign_key( "<Left>",           "left"                   )
  360.       assign_key( "<Right>",          "right"                  )
  361.       assign_key( "<PageUp>",         "page_up"                )
  362.       assign_key( "<PageDown>",       "page_down"              )
  363.       assign_key( "<Home>",           "goto_bol"               )
  364.       assign_key( "<End>",            "goto_eol"               )
  365.                                                                   
  366.       assign_key( "<Num-Up>",         "up"                     )
  367.       assign_key( "<Num-Down>",       "down"                   )
  368.       assign_key( "<Num-Left>",       "left"                   )
  369.       assign_key( "<Num-Right>",      "right"                  )
  370.       assign_key( "<Num-PageUp>",     "page_up"                )
  371.       assign_key( "<Num-PageDown>",   "page_down"              )
  372.       assign_key( "<Num-Home>",       "goto_bol"               )
  373.       assign_key( "<Num-End>",        "goto_eol"               )
  374.                                                                
  375.       assign_key( "<F5>",             "debug_go"               )
  376.       assign_key( "<F8>",             "debug_trace"            )
  377.       assign_key( "<F9>",             "bp_line"                )   
  378.       assign_key( "<F10>",            "debug_step"             )      
  379.       assign_key( "<Alt-C>",          "my_debug_callstack"     )
  380.       assign_key( "<Alt-S>",          "search_forward"         )
  381.       assign_key( "<Alt-A>",          "search_again"           )
  382.                                        
  383.       assign_key( "<F9>",             "bp_line"                )
  384.    
  385.       assign_key( "a",                "search_again"           )
  386.       assign_key( "b",                "debug_breakpoint_list"  )
  387.       assign_key( "g",                "goto_line_key"          )
  388.       assign_key( "s",                "search_forward"         )
  389.       assign_key( "v",                "debug_open"             )
  390.    
  391.       assign_key( "A",                "search_again"           )
  392.       assign_key( "B",                "debug_breakpoint_list"  )
  393.       assign_key( "G",                "goto_line_key"          )
  394.       assign_key( "S",                "search_forward"         )
  395.       assign_key( "V",                "debug_open"             )
  396.    }
  397.    else
  398.       push_keymap( debug_keymap )
  399.  
  400. #   pop_keymap()
  401. }
  402.  
  403. local function create_debug_display_window( parent )
  404. {
  405.    current_window = debug_window = create_factory_window( 0, 0,     
  406.                                                           0, 0, 
  407.                                                           WINDOW_VERT_SB      +      
  408.                                                             WINDOW_HORIZ_SB   +      
  409.                                                             WINDOW_SYSTEM     +
  410.                                                             WINDOW_EXPANDED   +
  411.                                                             0x8,
  412.                                                           parent )
  413.  
  414.    expand_window()
  415.  
  416.    linenumber_format = " %5d:%m "
  417.  
  418.    color_window_fg      = debug_text_fg
  419.    color_window_bg      = debug_text_bg
  420.    color_linenumbers_fg = debug_line_fg
  421.    color_linenumbers_bg = debug_line_bg
  422.    
  423.    if ( debug_buffer )
  424.       delete_buffer( debug_buffer )
  425.  
  426.    debug_buffer = create_buffer( debug_empty_name, 
  427.                                  "", 
  428.                                  BUFFER_SYSTEM        + 
  429.                                     BUFFER_NO_UNDO    + 
  430.                                     BUFFER_READ_ONLY     )
  431. }
  432.  
  433. local function debug_init()
  434. {
  435.    local    cw;
  436.    local    cb;
  437.    local    i;
  438.    local    win_height
  439.    local    debug_sbar_flags
  440.  
  441.    #  This was taken out because this function is only called if a 
  442.    #  window is open.
  443.  
  444. #   if ( !current_window )
  445. #   {
  446. #      current_window = create_window( 0, 0, display_width, display_height);
  447. #      attach_window_buffer( current_window, current_buffer );
  448. #   }
  449.  
  450.    # DWM 5/10/94
  451.    original_window = current_window
  452.    original_buffer = current_buffer
  453.    original_keymap = current_keymap
  454.  
  455.    cw = current_window
  456.    cb = current_buffer
  457.  
  458.    if ( debug_enabled )
  459.    { 
  460.       expand_window( debug_window )  
  461.       debug_reset()
  462.       return;
  463.    }
  464.  
  465.    debug_enabled  = 1
  466.    debug_go_mode  = 0
  467.    debug_id       = function_id( "debug_fun" )
  468.  
  469.    debug_sbar_flags     = status_bar_flags
  470.    debug_remote_window  = create_remote_window( "Pel Debugger" )
  471.    status_bar_flags     = debug_sbar_flags
  472.  
  473.    create_debug_toolbar( debug_remote_window )
  474.  
  475.    create_debug_menu( debug_remote_window )
  476.  
  477.    create_debug_display_window( debug_remote_window )
  478.  
  479.    create_debug_keymap()
  480.  
  481.    fix_debug_menu_text()
  482.  
  483.    attach_window_buffer( debug_window, debug_buffer );
  484.    
  485.    scroll_context_top = 0;
  486.    scroll_context_bottom = 0;
  487.  
  488.    set_debug_window()
  489. }
  490.  
  491. # array containing all non-debugger mouse events
  492. local debug_event_handlers[] 
  493.  
  494. # call original event handlers of mouse_event
  495. local function original_handler( mouse_event )
  496. {
  497.    local handler 
  498.  
  499.    for ( handler in debug_event_handlers[ mouse_event ] )
  500.       execute_function( debug_event_handlers[mouse_event][handler] )
  501. }
  502.  
  503. global function dummy_handler()
  504. {
  505.    local mouse_event = event_id
  506.  
  507.    if ( current_window == debug_window )
  508.       {
  509.       if ( mouse_event == EVENT.MOUSE_LEFT_CLICK2 )
  510.          debug_lmouse_double_click()
  511.  
  512.       else if ( mouse_event == EVENT.MOUSE_LEFT_DOWN )
  513.          {
  514.          goto_pos( mouse_event_y + window_first, mouse_event_x + window_margin + 1 );
  515.          update_current_view();
  516.          }
  517.       else if ( mouse_event == EVENT.EXIT_EDITOR )
  518.          {
  519.          debug_esc()
  520.          original_handler()
  521.          }
  522.       }
  523.    else
  524.       original_handler( mouse_event )
  525.       
  526. }
  527.  
  528. local function override_events()
  529. {
  530.    local event
  531.    local mouse_events[]
  532.    local mouse_drag_events[]
  533.    local exit_events[]
  534.    local dummy_handler_id = function_id( "dummy_handler" )
  535.  
  536.    # store all mouse event handlers 
  537.    mouse_events      = save_and_remove_events( EVENT.MOUSE_LEFT_DOWN, EVENT.MOUSE_MID_CLICK2 ) 
  538.    mouse_drag_events = save_and_remove_events( EVENT.LMOUSE_DRAG, EVENT.RMOUSE_DRAG )
  539.    exit_events       = save_and_remove_events( EVENT.EXIT_EDITOR, EVENT.EXIT_EDITOR )
  540.  
  541.    debug_event_handlers = merge_arrays( mouse_events, mouse_drag_events )
  542.    debug_event_handlers = merge_arrays( debug_event_handlers, exit_events )
  543.  
  544.    # attach dummy handlers for all mouse events
  545.    for ( event in debug_event_handlers )
  546.       attach_event_handler( event, dummy_handler_id )
  547.  
  548.    attach_event_handler( EVENT.NEW_CURNT_WINDOW,         "changing_windows"   ) 
  549.    attach_event_handler( EVENT.CLOSING_REMOTE_WINDOW,    "debug_esc"          ) 
  550. }
  551.  
  552. local function debug_restore_events()
  553. {
  554.    local event
  555.    local dummy_handler_id = function_id( "dummy_handler" )
  556.  
  557.    # delete dummy handlers for all mouse events
  558.    for ( event in debug_event_handlers )
  559.       delete_event( event, dummy_handler_id )
  560.  
  561.    restore_events( debug_event_handlers )
  562.  
  563.    delete debug_event_handlers
  564.  
  565.    delete_event( EVENT.NEW_CURNT_WINDOW,           "changing_windows"   ) 
  566.    delete_event( EVENT.CLOSING_REMOTE_WINDOW,      "debug_esc"          ) 
  567. }
  568.  
  569. # Invoke this to start debugging.
  570. #
  571. function debug()
  572. {
  573.    local gid;
  574.    local fn;
  575.  
  576.    local user_file = buffer_filename
  577.    local user_line = 1
  578.  
  579.    if(!current_window)
  580.    {
  581.       warning("PEL Debugger may not be run with no windows open.");
  582.       return FALSE;
  583.    }
  584.  
  585.    # DWM 4/4/95
  586.    # Why would this only be useful for modified buffers?
  587.    #if ( and(buffer_flags, BUFFER_MODIFIED) )
  588.       user_line = current_line
  589.  
  590.    main_window = current_window
  591.    main_buffer = current_buffer
  592.                          
  593.    attach_break_handler()
  594.  
  595.    override_events()
  596.  
  597.    debug_function( 0 );
  598.    debug_init()
  599.  
  600.    # if the user is looking at a pel file, load it
  601.    if ( path_ext(user_file) == ".pel" && path_fname(user_file) != "debug" )
  602.       {
  603.       debug_filename = user_file
  604.       debug_view( user_file, user_line )
  605.       }
  606.  
  607.    # Put debugger in trace mode.
  608.    debug_step_gid = 0
  609.    debug_go_mode = 0
  610.    debug_num_steps = 0;
  611.  
  612.    for ( gid in debug_fun_breakpoints )
  613.    {
  614.       if ( and(debug_fun_bp_types[gid], BP_GOTO_POINT) )
  615.          debug_remove_goto_point( gid );
  616.    }
  617.             
  618.    if ( debugger_running )
  619.       debugger_running = 0;
  620.  
  621.    debug_fun( 0, 1 );
  622. }        
  623.  
  624. function changing_windows ()
  625. {
  626.    if ( current_window == debug_window )
  627.    {                                              
  628.       if ( current_keymap != debug_keymap )
  629.          original_keymap = current_keymap 
  630.  
  631.       if ( debug_keymap )
  632.          current_keymap = debug_keymap
  633.    
  634.       if ( !debug_go_mode && debugger_running )
  635.          highlight_line()
  636.       else
  637.          unhighlight_line()
  638.    }                               
  639.    else 
  640.    {
  641.       current_keymap = original_keymap
  642.    
  643.       if ( !debug_enabled )
  644.          debug_reset()        
  645.    }
  646. }
  647.  
  648. # Step over function call.
  649. # This will not work if the function is called recursively.
  650. function debug_step()
  651. {
  652.    if ( !debug_go_mode )
  653.    {
  654.       if ( debug_gid )
  655.       {         
  656.          debug_go_mode  = 0
  657.          debug_step_gid = debug_gid
  658.    
  659.          process_end( 1 )          
  660.       }
  661.       else
  662.          debug_view( debug_view_file )
  663.    }
  664.    else
  665.       beep()
  666. }
  667.  
  668. function debug_trace()
  669. {
  670.    if ( !debug_go_mode )
  671.    {
  672.       debug_go_mode  = 0
  673.       debug_step_gid = 0
  674.    
  675.       process_end( 1 )
  676.    }
  677.    else
  678.       beep()
  679. }
  680.  
  681. function debug_esc()
  682. {
  683.    local i
  684.    local event = event_id
  685.  
  686.    debug_function( 0 )
  687.  
  688.    debug_restore_events()
  689.  
  690.    debug_go_mode     = 0
  691.    debug_step_gid    = 0
  692.    debug_enabled     = 0
  693.    debug_view_file   = "???";
  694.    debug_filename    = ""
  695.  
  696.    debug_reset()
  697.  
  698.    pop_keymap()                    
  699.    remove_break_handler()
  700.  
  701.    if ( debug_menu )
  702.       {
  703.       # delete our local list that maps function id's to menu item
  704.       # id's.  This list was created during the append_menuitem calls.   
  705.       for ( i = IDM_FIRST_ITEM; i <= IDM_LAST_ITEM; i++ )
  706.          if ( i in menu_functions )
  707.             delete menu_functions[i]
  708.  
  709.       delete_menu( filemenu, debug_remote_window )
  710.       delete_menu( bpmenu, debug_remote_window )
  711.       delete_menu( runmenu, debug_remote_window )
  712.       delete_menu( viewmenu, debug_remote_window )
  713.       delete_menu( searchmenu, debug_remote_window )
  714.       delete_menu( debug_menu, debug_remote_window )
  715.       debug_menu = 0
  716.       filemenu       = 0
  717.       bpmenu         = 0
  718.       runmenu        = 0
  719.       viewmenu       = 0
  720.       searchmenu     = 0
  721.       }
  722.  
  723.    if ( debug_tbhand )
  724.       {
  725.       delete_toolbar( debug_tbhand )
  726.       debug_tbhand = 0
  727.       }
  728.  
  729.    if ( bl_hdlg )
  730.       {
  731.       delete_dialog( bl_hdlg )
  732.       bl_hdlg = 0
  733.       }
  734.  
  735.    if ( debug_keymap )
  736.       {
  737.       delete_keymap( debug_keymap )
  738.       debug_keymap = 0
  739.       }
  740.  
  741.    enable_all_windows()
  742.    set_user_window()
  743.  
  744.    debug_enabled  = FALSE
  745.  
  746.    if ( event != EVENT.CLOSING_REMOTE_WINDOW )
  747.       {
  748.       delete_remote_window( debug_remote_window )
  749.       debug_remote_window  = 0
  750.       debug_window         = 0
  751.       }
  752.  
  753.    process_end( 0 ) 
  754. }
  755.  
  756. # If name is a function parameter or local variable of the current
  757. # function being debugged, then return the index of that variable.
  758. # stframe is the frame number of the function desired.
  759. local function debug_find_stvar(varname,stframe)
  760. {
  761.    local x, list,list1,n,i
  762.  
  763.    if ((x = debug_get_frame(stframe)))
  764.    {
  765.       split(x[4],list1,";")           # x[4] is the parameter;local list
  766.       n = split(list1[1],list)        # list1[1] is the parameters
  767.       for (i = 1; i <= n; i++)
  768.       {
  769.          if (list[i] == varname) 
  770.          return(i)
  771.       }
  772.       n = split(list1[2],list)        # list1[2] is the locals
  773.       for (i = 1; i <= n; i++)
  774.       {
  775.          if (list[i] == varname)
  776.          return(- i)
  777.       }                        
  778.    }
  779.  
  780.    return( 0 )
  781. }
  782.  
  783. #
  784. # Clear Breakpoint
  785. #
  786. function bc( bpindex )
  787. {
  788.    local gid
  789.    local mark
  790.    
  791.    if ( bpindex >= 0 ) 
  792.       {
  793.       gid = bpindex_to_gid( bpindex )
  794.  
  795.       if ( gid && gid in debug_fun_breakpoints ) 
  796.          {
  797.          mark = debug_marks[ debug_fun_breakpoints[ gid ] ]
  798.          if ( mark )
  799.             delete_mark( mark )
  800.  
  801.          delete debug_fun_breakpoints[ gid ]
  802.          delete debug_fun_breakpoint_names[ gid ]
  803.          delete debug_fun_bp_types[ gid ]
  804.          } 
  805.       } 
  806.    # Clear all breakpoints
  807.    else 
  808.       {
  809.       for ( gid in debug_fun_breakpoints )
  810.          {
  811.          mark = debug_marks[ debug_fun_breakpoints[ gid ] ]
  812.          if ( mark )
  813.             delete_mark( mark )
  814.          }
  815.  
  816.       delete debug_fun_breakpoints
  817.       delete debug_fun_breakpoint_names;
  818.       delete debug_fun_bp_types;
  819.       }
  820.  
  821.    update_bl( bpindex )
  822. }        
  823.  
  824.  
  825. #
  826. # Disable Breakpoint
  827. #
  828. function bd( bpindex )
  829. {
  830.    local gid
  831.    
  832.    if ( bpindex >= 0 ) 
  833.       {
  834.       gid = bpindex_to_gid( bpindex )
  835.  
  836.       if ( gid && gid in debug_fun_breakpoints )
  837.          debug_fun_bp_types[ gid ] = and( debug_fun_bp_types[gid], not(BP_ENABLED) )
  838.       } 
  839.    else 
  840.       {
  841.       for ( gid in debug_fun_bp_types )
  842.          debug_fun_bp_types[ gid ] = and( debug_fun_bp_types[gid], not(BP_ENABLED) )
  843.       }
  844.  
  845.    update_bl( bpindex )
  846. }        
  847.  
  848. #
  849. # Enable Breakpoint
  850. #
  851. function be( bpindex )
  852. {
  853.    local gid
  854.    
  855.    if ( bpindex >= 0 ) 
  856.       {
  857.       gid = bpindex_to_gid( bpindex );
  858.  
  859.       if ( gid ) 
  860.          debug_fun_bp_types[ gid ] = or( debug_fun_bp_types[ gid ], BP_ENABLED )
  861.       } 
  862.    else 
  863.       {
  864.       for ( gid in debug_fun_bp_types )
  865.          debug_fun_bp_types[ gid ] = or( debug_fun_bp_types[ gid ], BP_ENABLED )
  866.       }
  867.  
  868.    update_bl( bpindex )
  869. }       
  870.  
  871.  
  872.  
  873. # 
  874. # Set Breakpoints
  875. #
  876. function bp( funname )
  877. {
  878.    local   gid = 0
  879.    local   i   = 0;
  880.    
  881.    debug_init()
  882.    
  883.    gid = function_id( funname )
  884.    
  885.    # This is magic: acceptable gids lie in the range 1000 to 8000
  886.    if ( !(!gid || (gid < 1000 || gid >= 8000)) ) 
  887.       {
  888.       debug_fun_breakpoints[gid] = 0
  889.       debug_fun_breakpoint_names[gid] = function_name( gid );
  890.       # DWM 1/24/94
  891.       # The old concept of a BP_GOTO_POINT doesn't exist anymore.
  892.       # debug_fun_bp_types[gid] = debug_go_mode ? BP_ENABLED + BP_GOTO_POINT : BP_ENABLED;
  893.       debug_fun_bp_types[gid] = BP_ENABLED;
  894.       
  895.       if ( !debugger_running ) 
  896.          {
  897.          debug_go_mode = 1;
  898.          debug_step_gid = 0;
  899.          debug_function(debug_id)
  900.          }
  901.       }
  902.  
  903.    update_bl( gid_to_bpindex(gid) )
  904.  
  905.    return gid;
  906. }
  907.  
  908. local debug_marks[]
  909.  
  910. function bp_line()
  911. {
  912.    local   fn;
  913.    local   mark
  914.  
  915.    if ( debug_view_file )
  916.       {
  917.       fn = buildpath( debug_view_file ) ":" current_line;
  918.    
  919.       if ( fn in debug_fun_breakpoints ) 
  920.          {        
  921.          delete( debug_fun_breakpoints[fn] );
  922.          delete( debug_fun_bp_types[fn] );
  923.          delete( debug_fun_breakpoint_names[fn] );
  924.  
  925.          delete_mark( debug_marks[ current_line ] )
  926.          linenumber_format = linenumber_format
  927.          } 
  928.       else 
  929.          {
  930.          debug_bp_linenos[ current_line ] = 1;
  931.          debug_fun_breakpoints[ fn ] = current_line;
  932.          debug_fun_bp_types[ fn ] = BP_ENABLED;     
  933.          debug_fun_breakpoint_names[ fn ] = fn;
  934.  
  935.          mark = pick_unused_mark()
  936.          create_mark( mark )
  937.          debug_marks[ current_line ] = mark
  938.          linenumber_format = linenumber_format
  939.  
  940.          breakpoints_visible = 1;
  941.          }
  942.    
  943.       update_bl( gid_to_bpindex(fn) )
  944.       }
  945. }        
  946.  
  947. function debug_go()
  948. {
  949.    debug_step_gid = 0;
  950.    debug_go_mode  = 1
  951.  
  952.    process_end( 1 )
  953.  
  954.    set_user_window()
  955. }        
  956.  
  957. global function disable_all_windows()
  958. {
  959.    local start_win
  960.    local cur_win
  961.  
  962.    set_editwin_property( EWC_DISABLE, 0 )            
  963.  
  964.    #set_editwin_property( 18, 0 )            
  965.  
  966.    start_win = current_window
  967.    cur_win = next_window( "", 0, 1 )
  968.    while ( cur_win != start_win )
  969.    {
  970.       if ( cur_win != debug_window )
  971.          set_editwin_property( EWC_DISABLE, cur_win )            
  972.  
  973.       cur_win = next_window( "", 0, 1 )
  974.    }
  975.  
  976.    if ( cur_win != debug_window )
  977.       set_editwin_property( EWC_DISABLE, cur_win )            
  978.  
  979.    #set_editwin_property( 18, debug_remote_window )            
  980. }
  981.  
  982. global function enable_all_windows()
  983. {
  984.    local start_win
  985.    local cur_win
  986.  
  987.    set_editwin_property( EWC_ENABLE, 0 )            
  988.  
  989.    #set_editwin_property( 18, 0 )            
  990.  
  991.    start_win = current_window
  992.    cur_win = next_window( "", 0, 1 )
  993.    while ( cur_win != start_win )
  994.    {
  995.       if ( cur_win != debug_window )
  996.          set_editwin_property( EWC_ENABLE, cur_win )            
  997.  
  998.       cur_win = next_window( "", 0, 1 )
  999.    }
  1000.  
  1001.    if ( cur_win != debug_window )
  1002.       set_editwin_property( EWC_ENABLE, cur_win )            
  1003.  
  1004.    #set_editwin_property( 18, debug_remote_window )            
  1005. }
  1006.  
  1007. # Call this with the gid and line number of function being debugged,
  1008. # or with gid == 0 to just bring up the debugger on nothing.
  1009. # debug_session returns 1 to continue debugging, 0 to quit
  1010. local function debug_session()
  1011. {
  1012.    local   filename = debug_filename;
  1013.    local   cb;
  1014.    
  1015.    attach_break_handler()
  1016.    
  1017.    if ( current_window != debug_window )
  1018.       {
  1019.       original_window = current_window
  1020.       original_keymap = current_keymap
  1021.       original_buffer = current_buffer
  1022.       }
  1023.    
  1024.    if ( !debugger_running ) 
  1025.       debugger_running = 1;
  1026.    
  1027.    debug_at()
  1028.  
  1029.    disable_all_windows()
  1030.  
  1031.    if ( debug_gid )
  1032.       enable_debug_menu()
  1033.  
  1034.    debugger_running = process_begin() + 0
  1035.  
  1036.    enable_all_windows()
  1037.  
  1038.    if ( debug_enabled )
  1039.       disable_debug_menu()
  1040.    
  1041.    set_user_window()
  1042.  
  1043.    if ( debugger_running != 0 )      
  1044.       pop_keymap()                     
  1045.    
  1046.    return( debugger_running )
  1047. }
  1048.  
  1049. local function debug_file_display( filename )
  1050. {
  1051.    local def_buf_eol = default_buffer_eol_string;
  1052.    
  1053.    debug_view_file = filename;
  1054.    delete_buffer( debug_buffer )
  1055.    
  1056.    default_buffer_eol_string = "\r\n"     
  1057.    current_buffer = debug_buffer = 
  1058.       create_buffer( debug_gid \
  1059.                         ? "FILE: " debug_filename " FUNCTION: " function_name(debug_gid) \
  1060.                         : debug_empty_name,
  1061.                      debug_filename,
  1062.                      BUFFER_SYSTEM + BUFFER_NO_UNDO + BUFFER_READ_ONLY )
  1063.  
  1064.    default_buffer_eol_string = def_buf_eol;
  1065.    
  1066.    buffer_tabs = debug_tabs;
  1067.    attach_window_buffer( debug_window, debug_buffer );
  1068. }        
  1069.  
  1070. function debug_at()
  1071. {
  1072.    if ( current_window != debug_window )
  1073.       set_debug_window()
  1074.  
  1075.    #                      
  1076.    # if the current file displayed doesn't equal the one that's
  1077.    # suppose to be displayed, find the one to display
  1078.    #
  1079.    if ( debug_filename != debug_view_file ) 
  1080.    {
  1081.       debug_filename  = debug_gid ? get_source_file_name(debug_gid) : "";
  1082.  
  1083.       debug_file_display( debug_filename );
  1084.       debug_file_display( debug_filename );
  1085.    }
  1086.    
  1087.    if ( debug_gid )  
  1088.    {
  1089.       current_line = debug_lineno;
  1090.       unhighlight_line()
  1091.       center_cursor();
  1092.       highlight_line( debug_color_highlight );
  1093.    }
  1094. }        
  1095.  
  1096.  
  1097. local   currentFrame = 1;
  1098.  
  1099. # Gid is the function_id of the function being executed.
  1100. # lineno is the line number in that function.
  1101. #
  1102. function debug_fun(gid,lineno)
  1103. {
  1104.    local   fn;
  1105.    local   i,ln;
  1106.    local   x;
  1107.    local   done;           
  1108.    local   ck
  1109.  
  1110.    ck = current_keymap
  1111.    if ( ck != debug_keymap )
  1112.       original_keymap = ck
  1113.  
  1114.    # If we are performing a debug_step function,
  1115.    # keep going until we get back to the function
  1116.    # we did the step in or stepping out of.
  1117.    #
  1118.    done = 0
  1119.    if ( debug_step_gid && (gid != debug_step_gid) ) 
  1120.    {
  1121.       if ( debug_get_frame(currentFrame) ) 
  1122.       {
  1123.          debug_function( debug_id )
  1124.          return;
  1125.       }
  1126.    }
  1127.  
  1128.    # If we are performing a debug_go function, keep going
  1129.    # until a breakpoint is reached.
  1130.    # We remember the first line number of each function.
  1131.    if ( debug_go_mode ) 
  1132.    {
  1133.       if (  (gid in debug_fun_breakpoints)            && 
  1134.             and(debug_fun_bp_types[gid], BP_ENABLED)  &&
  1135.             (!debug_fun_breakpoints[gid] || (debug_fun_breakpoints[gid] == lineno)) )
  1136.       {
  1137.          if ( !debug_fun_breakpoints[gid] )
  1138.             debug_fun_breakpoints[gid] = lineno;
  1139.          
  1140.          if ( and(debug_fun_bp_types[gid], BP_GOTO_POINT) )
  1141.             debug_remove_goto_point( gid );
  1142.       } 
  1143.       else if ( lineno in debug_bp_linenos ) 
  1144.       {
  1145.          fn = gid ? get_source_file_name( gid ) ":" lineno : ""
  1146. #         if ( !(fn in debug_fun_breakpoints) && and(debug_fun_bp_types[fn], BP_ENABLED) ) 
  1147.          if ( !(fn in debug_fun_breakpoints) ) 
  1148.          {
  1149.             debug_function( debug_id )
  1150.             return;        
  1151.          }
  1152.  
  1153.          delete( debug_bp_linenos );
  1154.  
  1155.          for ( i in debug_fun_breakpoints )
  1156.             if ( (ln = debug_fun_breakpoints[i]) )
  1157.                debug_bp_linenos[ ln ] = ln;
  1158.  
  1159.       } # if lineno in debug_bp_linenos
  1160.       else 
  1161.       {
  1162.          debug_function( debug_id )
  1163.          return;
  1164.       }
  1165.  
  1166.       debug_go_mode = 0;                                  
  1167.       debug_num_steps = 0;
  1168.  
  1169.    } # if debug_go_mode
  1170.  
  1171.    if ( debug_gid != gid ) 
  1172.    {                                
  1173.       debug_filename = gid ? get_source_file_name(gid) : "";
  1174.       debug_gid = gid;
  1175.  
  1176.       if ( path_fname(debug_filename) == "debug" &&
  1177.             path_ext(debug_filename) == ".pel" )
  1178.       {
  1179.          # DWM 5/20/94
  1180.          # don't quit debugger when we get 
  1181.          # into debug code, just step over it
  1182.          debug_function( debug_id )
  1183.          return;
  1184.  
  1185.          #debug_esc()
  1186.          #current_keymap = original_keymap
  1187.          #return;
  1188.       }
  1189.    }       
  1190.    debug_lineno = lineno;
  1191.  
  1192.    for ( currentFrame=0; debug_get_frame(currentFrame+1); currentFrame++ )
  1193.       continue;
  1194.         
  1195.    remove_break_handler()  
  1196.  
  1197.    if ( debug_session() ) 
  1198.    {
  1199.       debug_function( debug_id )
  1200.       attach_break_handler()
  1201.    }
  1202. }                      
  1203.  
  1204. local function debug_remove_goto_point( gid )
  1205. {
  1206.    delete( debug_fun_breakpoints[gid] )
  1207.    delete( debug_fun_bp_types[gid] )
  1208.    delete( debug_fun_breakpoint_names[gid] )
  1209. }
  1210.  
  1211. local function bpindex_to_gid( index )
  1212. {
  1213.    local gid
  1214.    
  1215.    for ( gid in debug_fun_bp_types ) 
  1216.       {
  1217.       if ( !index ) 
  1218.          return gid
  1219.  
  1220.       index--;
  1221.       }
  1222.  
  1223.    return 0
  1224. }
  1225.  
  1226. local function gid_to_bpindex( gid )
  1227. {
  1228.    local bpindex  = 0
  1229.    local curr_gid
  1230.    
  1231.    for ( curr_gid in debug_fun_bp_types ) 
  1232.       {
  1233.       if ( gid == curr_gid ) 
  1234.          break
  1235.  
  1236.       bpindex++
  1237.       }
  1238.  
  1239.    if ( gid != curr_gid )
  1240.       bpindex = -1
  1241.  
  1242.    return bpindex
  1243. }
  1244.  
  1245. function debug_view( fname, line )
  1246. {
  1247.    local cb          = current_buffer;
  1248.    local def_buf_eol = default_buffer_eol_string;
  1249.    
  1250.    fname = ltrim( trim( fname ) )
  1251.  
  1252.    default_buffer_eol_string = "\r\n"
  1253.  
  1254.    current_buffer = create_buffer(  "FILE: " path_fname(fname) path_ext(fname),
  1255.                                     fname,
  1256.                                     BUFFER_SYSTEM  + 
  1257.                                     BUFFER_NO_UNDO + 
  1258.                                     BUFFER_READ_ONLY )
  1259.  
  1260.    default_buffer_eol_string = def_buf_eol;
  1261.    
  1262.    if ( buffer_size ) 
  1263.       {
  1264.       buffer_tabs = debug_tabs;
  1265.       
  1266. #new_buf = current_buffer
  1267. #current_buffer = debug_buffer
  1268.       delete_buffer(debug_buffer); 
  1269.       debug_buffer = current_buffer
  1270. #     debug_buffer = new_buf;
  1271. #current_buffer = debug_buffer
  1272. #      debug_buffer = current_buffer;
  1273.  
  1274. #if ( buffer_last_line >= line )
  1275. #  ; 
  1276.  
  1277. #      if ( argcount() > 1 && buffer_last_line >= line )
  1278.          current_line = line
  1279.  
  1280.       debug_view_file = fname;
  1281.       attach_window_buffer( debug_window, debug_buffer )
  1282.       }
  1283.    else
  1284.       current_buffer = cb;
  1285. }
  1286.  
  1287. #local y_highlight = -1;
  1288. #local y_ext = -1;
  1289. #local x_ext = -1;
  1290.  
  1291. local function highlight_line( attr )
  1292. {
  1293.    remove_selection()
  1294.    update_current_view()
  1295.  
  1296.    save_position()
  1297.  
  1298.    current_line = debug_lineno
  1299.    begin_selection(LINE_SELECTION)
  1300.    end_selection()
  1301.    update_current_view()
  1302.  
  1303.    restore_position(TRUE)
  1304. }
  1305.  
  1306. local function unhighlight_line()
  1307. {
  1308.    remove_selection()
  1309.    update_current_view()
  1310.  
  1311. #   if ( breakpoints_visible )
  1312. #   {
  1313. #      breakpoints_visible = 0;
  1314. #      update_current_view()
  1315. #   }
  1316. #   else
  1317. #   {
  1318. #      # use the last highlighted line setting to unhighlight
  1319. #      #
  1320. #      if ( (y_highlight >= 0) && (y_highlight < y_ext) )
  1321. #      {
  1322. #         highlight_window( 0, y_highlight, x_ext, 1, debug_color_text,
  1323. #                           debug_window );
  1324. #      }
  1325. #   }
  1326. #
  1327. #   y_highlight = -1;
  1328. }
  1329.  
  1330.  
  1331.  
  1332. local function get_source_file_name( gid )
  1333. {
  1334.    local   fn = source_file_name( gid );
  1335.    local   src_name;
  1336.  
  1337.    if (findfirst( fn ) == "")
  1338.       return buildpath( path_fname( fn ) path_ext( fn ) );
  1339.    else
  1340.       return fn;
  1341. }
  1342.  
  1343. global function debug_ctrl_break()
  1344. {
  1345.    debug_num_steps = 0;
  1346.    debug_go_mode = 0;
  1347. }
  1348.  
  1349.  
  1350. function attach_break_handler()
  1351. {
  1352.    if (!ctrl_break_attached)
  1353.    {
  1354.       attach_event_handler( EVENT.CTRL_BREAK, function_id( "debug_ctrl_break" ));
  1355.       ctrl_break_attached = 1;
  1356.    }
  1357. }
  1358.  
  1359. function remove_break_handler()
  1360. {
  1361.    if (ctrl_break_attached)
  1362.    {
  1363.       delete_event( EVENT.CTRL_BREAK, function_id( "debug_ctrl_break" ) )
  1364.       ctrl_break_attached = 0;
  1365.    }
  1366. }
  1367.  
  1368. local function my_debug_cvdebug(outline)
  1369. {
  1370.    local MAX = 80;
  1371.  
  1372.    outline = prefix(outline, MAX);
  1373.    cvdebug(outline);
  1374. }
  1375.  
  1376. local my_debug_gid         = 0
  1377. local my_last_gid          = 0
  1378. local my_target_gid        = 0
  1379. local my_do_callstack      = FALSE
  1380. local my_last_stacklevel   = 0
  1381. local my_debug_level       = 0
  1382. local my_last_caller       = 0
  1383.  
  1384. global function my_debug_fun( gid, lineno )
  1385. {
  1386.    local currentFrame 
  1387.  
  1388.    if ( !my_debug_gid )
  1389.       my_debug_gid = function_id("my_debug_fun")
  1390.  
  1391.    if ( argcount() > 0 && gid && gid != my_debug_gid )
  1392.       {
  1393.       if ( my_target_gid != 0 && gid == my_target_gid )
  1394.          {
  1395.          if ( argcount() < 2 )
  1396.             lineno = -1
  1397.          
  1398.          if ( my_do_callstack )
  1399.             {
  1400.             my_debug_callstack()
  1401.             my_do_callstack = FALSE
  1402.             }
  1403.          else
  1404.             my_debug_fun_call( my_debug_level, currentFrame )
  1405.          }
  1406.       else if ( my_target_gid == 0 && gid != my_last_gid )
  1407.          {
  1408.          if ( argcount() < 2 )
  1409.             lineno = -1
  1410.          
  1411.          for ( currentFrame=0; debug_get_frame(currentFrame+1); currentFrame++ )
  1412.             continue;
  1413.  
  1414.          if ( my_last_stacklevel && currentFrame > my_last_stacklevel )
  1415.          {
  1416.             my_last_caller = my_last_gid
  1417.             my_debug_cvdebug(sprintf("%s{", strrepeat("\t",my_last_stacklevel-1) ));
  1418.          }
  1419.  
  1420.          if ( my_last_stacklevel && currentFrame < my_last_stacklevel )
  1421.             my_debug_cvdebug(sprintf( "%s}", strrepeat("\t",currentFrame-1) ));
  1422.  
  1423.          if ( gid != my_last_caller )
  1424.             my_debug_fun_call( my_debug_level, currentFrame )
  1425.  
  1426.          my_last_stacklevel = currentFrame
  1427.          }
  1428.  
  1429.       my_last_gid = gid
  1430.       }
  1431.  
  1432.    debug_function( my_debug_gid )
  1433. }
  1434.  
  1435. global function my_debug( onOff )
  1436. {
  1437.    if ( argcount() > 0 && !onOff )
  1438.       debug_function( 0 )
  1439.    else
  1440.       my_debug_fun( 0, 0 )
  1441. }
  1442.  
  1443. global function my_debug_var_at( fname, var_name ) 
  1444. {
  1445.    
  1446. }
  1447.  
  1448. global function my_debug_at_fun( fname )
  1449. {
  1450.    my_target_gid     = function_id( fname )
  1451.    my_do_callstack   = FALSE
  1452.  
  1453. #   cvdebug( "targetting %s(%d)", fname, my_target_gid )
  1454.  
  1455.    return my_target_gid
  1456. }
  1457.  
  1458. global function my_debug_in( file_name )
  1459. {
  1460. }
  1461.  
  1462. global function my_debug_callstack()
  1463. {
  1464.    local list[]
  1465.    local vars[]
  1466.    local x[]
  1467.    local argc     = 0
  1468.    local i        = 1
  1469.    local n        = 1
  1470.    local arglist  = ""
  1471.    local var_val  = ""
  1472.    local var_type = ""
  1473.    local popbuf[]
  1474.  
  1475.    if (!debug_gid)
  1476.       return;
  1477.  
  1478.    for (n=1; (x = debug_get_frame(n)); n++)
  1479.    {
  1480.       # x[1] is gid, x[2] is lineno, x[3] is argc, x[4] is param list
  1481.       # Create the list of function arguments
  1482.       argc = x[3]
  1483.       split( x[4], list, ";" )   # list[1] = parameters, list[2] = local vars
  1484.       split( list[1], vars )
  1485.       for (i = 1; i <= argc; i++)
  1486.       {
  1487.          var_val = debug_get_stack_var( 1, i )
  1488.          var_type = typeof( var_val )
  1489.    
  1490.          if ( var_type == "string" || var_type == "regular expression" )
  1491.             var_val = "\"" var_val "\""
  1492.    
  1493.          if ( var_val )
  1494.             {
  1495.             arglist = arglist vars[i] "=" var_val
  1496.    
  1497.             if ( i != argc )
  1498.                arglist = arglist ", "
  1499.             }
  1500.       }
  1501.       popbuf[ n ] = sprintf( "%s %d: %s( %s )", 
  1502.                               get_source_file_name(x[1]), 
  1503.                               x[2],  
  1504.                               function_name( x[1] ),
  1505.                               arglist )
  1506.    }
  1507.  
  1508.    debug_display_info( popbuf, "Pel Debugger:  Call Stack" )
  1509. }
  1510.  
  1511. function my_debug_fun_call()
  1512. {
  1513.    local list[]
  1514.    local vars[]
  1515.    local x[]
  1516.    local argc     = 0
  1517.    local i        = 1
  1518.    local arglist  = ""
  1519.    local var_val  = ""
  1520.    local var_type = ""
  1521.  
  1522.    x = debug_get_frame( 1 )
  1523.  
  1524.    # x[1] is gid, x[2] is lineno, x[3] is argc, x[4] is param list
  1525.    # Create the list of function arguments
  1526.    argc = x[3]
  1527.    split( x[4], list, ";" )   # list[1] = parameters, list[2] = local vars
  1528.    split( list[1], vars )
  1529.    for (i = 1; i <= argc; i++)
  1530.    {
  1531.       var_val = debug_get_stack_var( 1, i )
  1532.       var_type = typeof( var_val )
  1533.  
  1534.       if ( var_type == "string" || var_type == "regular expression" )
  1535.          var_val = "\"" var_val "\""
  1536.  
  1537.       if ( var_val )
  1538.          {
  1539.          arglist = arglist vars[i] "=" var_val
  1540.  
  1541.          if ( i != argc )
  1542.             arglist = arglist ", "
  1543.          }
  1544.    }
  1545.  
  1546.    cvdebug( "%s %d: %s( %s )", 
  1547.             get_source_file_name(x[1]), 
  1548.             x[2],  
  1549.             function_name( x[1] ),
  1550.             arglist )
  1551. }
  1552.  
  1553. # displays type/value of named var 
  1554. global function debug_query_var_info( var )
  1555. {
  1556.    local type     = ""
  1557.    local i        = 0
  1558.    local value    = 0
  1559.    local var_fid  = 0
  1560.    local info[]
  1561.    local str
  1562.  
  1563.    if ( !var )
  1564.       {
  1565.       str = symbol_under_cursor()
  1566.       var = prompt_history( "DEBUG_QUERY", "Query pel var:  ", str, str ? FALSE : TRUE, 1, "debug_query_prompt" )
  1567.       }
  1568.  
  1569.    if ( var )
  1570.       {
  1571.       i = debug_find_stvar( var, 1 )
  1572.    
  1573.       if ( i != 0 )
  1574.          {
  1575.          value = debug_get_stack_var( 1, i )
  1576.          type = typeof( value )
  1577.          }
  1578.       else
  1579.          {
  1580.          # try for a var local to the file
  1581.          var_fid = function_id( path_fname(debug_filename) ":" var )
  1582.  
  1583.          # else see if its a global var
  1584.          if ( !var_fid )
  1585.             var_fid = function_id( var )
  1586.  
  1587.          if ( var_fid )
  1588.             {
  1589.             # is it a user function id?
  1590.             if ( var_fid >= 1000 && var_fid <= 2999 )
  1591.                {
  1592.                value = var_fid
  1593.                type = typeof( var_fid )
  1594.                }
  1595.             else
  1596.                {
  1597.                # switch context in case its buffer_filename, etc
  1598.                set_user_window()
  1599.                value = execute_function( var_fid )
  1600.                set_debug_window()
  1601.  
  1602.                type = typeof( value )
  1603.                }
  1604.             }
  1605.          }
  1606.  
  1607.       if ( type )
  1608.          {
  1609.          if ( type == "string" )
  1610.             value = "\"" value "\""
  1611.          
  1612.          if ( type == "array" )
  1613.             display_array( value )
  1614.          else
  1615.             {
  1616.             info[ 1 ] = type " " var " : " value
  1617.             debug_display_info( info, "Pel Debugger:  Inspector" )
  1618.             }
  1619.          }
  1620.       else
  1621.          beep()
  1622.  
  1623.       }
  1624. }
  1625.  
  1626. global function debug_lmouse_double_click()
  1627. {
  1628.    local var = ""
  1629.  
  1630.    if ( current_window == debug_window )
  1631.       {
  1632.       var = symbol_under_cursor()
  1633.  
  1634.       if ( var && debug_gid && mouse_event_x >= 1 )
  1635.          debug_query_var_info( var )
  1636.  
  1637.       else if ( mouse_event_x < 1 )
  1638.          bp_line()
  1639.       }
  1640. }
  1641.  
  1642.  
  1643. local function debug_display_info( info, title )
  1644. {
  1645.    local   i      = ""
  1646.    local   width  = 30
  1647.    local   dhArray
  1648.  
  1649.    # check argument type
  1650.    if ( typeof( info ) != "array" )
  1651.       return
  1652.  
  1653.    if ( !title )
  1654.       title = "Pel Debugger"
  1655.  
  1656.    # create a dialog box for the list
  1657.    dhArray = create_selection_dialog( title, width )
  1658.    set_dialog_item( dhArray, DI_OK, DAC_HIDE)
  1659.  
  1660.    # insert the array contents
  1661.    for ( i in info )
  1662.    {
  1663.       set_dialog_item( dhArray, IDL_LIST, DAC_ADD_ITEM, info[i] )
  1664.    }
  1665.  
  1666.    begin_dialog(dhArray)
  1667. }
  1668.  
  1669. global function debug_local_variables()
  1670. {
  1671.    local list[]
  1672.    local vars[]
  1673.    local local_list[]
  1674.  
  1675.    local type           = ""
  1676.    local value          = ""
  1677.    local pad            = 0
  1678.    local frame          = 0
  1679.    local n              = 0
  1680.    local i              = 1
  1681.    local j              = 1
  1682.    local longest_var    = 0
  1683.    local longest_type   = 0
  1684.  
  1685.    if ( (frame = debug_get_frame(1)) )
  1686.    {
  1687.       split( frame[4], vars, ";" )      # frame[4] is the parameter;local list
  1688.       n = split( vars[1], list )        # vars[1] is the parameters
  1689.  
  1690.       longest_var = 0
  1691.       for (i = 1; i <= n; i++)
  1692.          longest_var = max( length( list[i] ), longest_var )
  1693.  
  1694.       longest_var += 5
  1695.  
  1696.       longest_type = 0
  1697.       for (i = 1; i <= n; i++) 
  1698.          longest_type = max( length( typeof(list[i]) ), longest_type )
  1699.  
  1700.       longest_type += 5
  1701.  
  1702.       j = 1
  1703.       for (i = 1; i <= n; i++,j++)
  1704.          {
  1705.          value = debug_get_stack_var( 1, i )
  1706.          type  = typeof( value )
  1707.  
  1708.          if ( type == "string" && value == "" )
  1709.             value = "\"\""
  1710.  
  1711.          local_list[ j ] = sprintf( "%s%s %s%s : %s", 
  1712.                                     type, 
  1713.                                     strrepeat(" ", longest_type - length(type) ), 
  1714.                                     list[i],
  1715.                                     strrepeat(" ", longest_var - length(list[i]) ),
  1716.                                     value )
  1717.          }
  1718.  
  1719.       n = split( vars[2], list )        # vars[2] is the locals
  1720.       longest_var = 0
  1721.       for (i = 1; i <= n; i++)
  1722.          longest_var = max( length( list[i] ), longest_var )
  1723.  
  1724.       longest_var += 5
  1725.  
  1726.       longest_type = 0
  1727.       for (i = 1; i <= n; i++)
  1728.          longest_type = max( length( typeof(list[i]) ), longest_type )
  1729.  
  1730.       longest_type += 5
  1731.  
  1732.       for (i = 1; i <= n; i++,j++)
  1733.          {
  1734.          value = debug_get_stack_var( 1, -i )
  1735.          type  = typeof( value )
  1736.  
  1737.          if ( type == "string" && value == "" )
  1738.             value = "\"\""
  1739.  
  1740.          local_list[ j ] = sprintf( "%s%s %s%s : %s", 
  1741.                                     type, 
  1742.                                     strrepeat(" ", longest_type - length(type) ), 
  1743.                                     list[i],
  1744.                                     strrepeat(" ", longest_var - length(list[i]) ),
  1745.                                     value )
  1746.          }
  1747.  
  1748.    }
  1749.    debug_display_info( local_list, "Pel Debugger:  Local Variables" )
  1750. }
  1751.  
  1752. local function debug_calc_functions()
  1753. {
  1754.    local i
  1755.    local j
  1756.  
  1757.    local sorted_global_funs[]
  1758.    local sorted_local_funs[]
  1759.  
  1760.    local global_funs = symbol_match( "", 0x4 )  
  1761.    local local_funs  = symbol_match( "", 0x10 ) 
  1762.  
  1763.    local fun_list[]
  1764.  
  1765.    message( "Working..." )
  1766.  
  1767.    # sort global functions
  1768.    for ( i in global_funs )
  1769.       sorted_global_funs[ global_funs[ i ] ] = i
  1770.  
  1771.    # add globals to info list
  1772.    j = 1
  1773.    for ( i in sorted_global_funs )
  1774.       fun_list[ j++ ] = i
  1775.  
  1776.    # sort local functions
  1777.    for ( i in local_funs )
  1778.       sorted_local_funs[ local_funs[ i ] ] = i
  1779.  
  1780.    # append locals to info list
  1781.    for ( i in sorted_local_funs )
  1782.       fun_list[ j++ ] = i
  1783.  
  1784.    return fun_list
  1785. }
  1786.  
  1787. global function my_debug_functions()
  1788. {
  1789.    debug_display_info( debug_calc_functions(), "Pel Debugger:  User Functions" ) 
  1790. }
  1791.  
  1792. #
  1793. # List Breakpoints
  1794. #
  1795. global function my_debug_bl()
  1796. {
  1797.    local    i        
  1798.    local    j        
  1799.    local    info[]
  1800.    
  1801.    j = 0
  1802.    for ( i in debug_fun_breakpoint_names )  
  1803.       info[ j + 1 ] = sprintf("%4d %s %s", 
  1804.                               j++, 
  1805.                               and(debug_fun_bp_types[i],BP_ENABLED) ? "Enabled " : "Disabled", 
  1806.                               debug_fun_breakpoint_names[i] )
  1807.  
  1808.    debug_display_info( info, "Pel Debugger:  Breakpoint List" )
  1809. }
  1810.  
  1811. local lastPath = "*.pel"
  1812.  
  1813. global function debug_open()
  1814. {
  1815.    local fileArray[]
  1816.    local fileToOpen
  1817.    local str
  1818.    local file
  1819.    local mode
  1820.    
  1821.    #  if infileToOpen is specified use it otherwise use 
  1822.    #  use the last path that was used.
  1823.    fileToOpen = open_dialog( lastPath, "Open" )
  1824.    
  1825.    split( fileToOpen, fileArray, ";" )
  1826.    file = fileArray[ 2 ]
  1827.  
  1828.    if ( file )
  1829.       {
  1830.       str = buildpath( file )
  1831.  
  1832.       mode = filemode(str)
  1833.       if ( str && mode != -1 && mode != _SUBDIR )
  1834.          {
  1835.          lastPath = path_path( str ) "*.pel"
  1836.  
  1837.          debug_view( str )
  1838.          }
  1839.       else
  1840.          beep()
  1841.       }
  1842. }
  1843.  
  1844. local DI_ABLE_BUTTON       = DI_NEXT_BUTTON   
  1845. local DI_CLEAR_BUTTON      = DI_PREV_BUTTON   
  1846. local DI_CLEAR_ALL_BUTTON  = DI_STOP_BUTTON   
  1847.  
  1848. local function debug_create_bl_dlg()
  1849. {
  1850.    local dlgid
  1851.    local newtitle
  1852.    local id = 1
  1853.    local callbackid = function_id( "debug_bl_callback" )
  1854.  
  1855.    dlgid = create_mdialog( callbackid, 0, DLG_LIST_DIALOG, resource_dll )
  1856.  
  1857.    set_dialog_item( dlgid, DI_GOTO_BUTTON,    DAC_DISABLE )
  1858.  
  1859.    add_dialog_item( dlgid, DI_STOP_BUTTON,      DCTRL_PUSH_BUTTON )
  1860.    add_dialog_item( dlgid, DI_CLEAR_ALL_BUTTON, DCTRL_PUSH_BUTTON )
  1861.  
  1862.    add_dialog_item( dlgid, IDL_LIST, DCTRL_LIST_BOX )
  1863.    
  1864.    # add items for the buttons. Since the buttons are disabled the assumed type
  1865.    # is incorrect so we must explicitly tell the dialog manager what type these
  1866.    # controls are.
  1867.    add_dialog_item( dlgid, DI_GOTO_BUTTON,      DCTRL_DEFAULT_PUSH_BUTTON  )
  1868.    add_dialog_item( dlgid, DI_CLEAR_BUTTON,     DCTRL_PUSH_BUTTON          )
  1869.    add_dialog_item( dlgid, DI_ABLE_BUTTON,      DCTRL_PUSH_BUTTON          ) 
  1870.    add_dialog_item( dlgid, DI_CLEAR_ALL_BUTTON, DCTRL_PUSH_BUTTON          )
  1871.    add_dialog_item( dlgid, DI_HELP,             DCTRL_PUSH_BUTTON          )
  1872.    add_dialog_item( dlgid, IDL_LIST,            DCTRL_LIST_BOX             )
  1873.    add_dialog_item( dlgid, IDB_CLOSE_BTN,       DCTRL_PUSH_BUTTON          )
  1874.  
  1875.    set_dialog_item( dlgid, DI_ABLE_BUTTON,      DAC_TEXT, "~Disable"       )
  1876.    set_dialog_item( dlgid, DI_CLEAR_BUTTON,     DAC_TEXT, "~Clear"         )
  1877.    set_dialog_item( dlgid, DI_CLEAR_ALL_BUTTON, DAC_TEXT, "Clear ~all"     )
  1878.  
  1879.    set_dialog_window( dlgid, DWC_TITLE, "Pel Debugger Breakpoints" )
  1880.  
  1881. #   attach_help(help_file, dlgid)
  1882.  
  1883.    return dlgid
  1884. }
  1885.  
  1886. local bl_hdlg = 0
  1887. local function update_bl( bpindex )
  1888. {
  1889.    local j           = 0
  1890.    local i           = 0
  1891.    local info        = ""
  1892.    local num_items   = 0
  1893.  
  1894.    if ( !bl_hdlg )
  1895.       {
  1896.       bl_hdlg = debug_create_bl_dlg()
  1897.       set_debug_window()
  1898.       }
  1899.  
  1900.    set_dialog_item( bl_hdlg, IDL_LIST, DAC_CLEAR_LIST )
  1901.  
  1902.    j = 0
  1903.    for ( i in debug_fun_breakpoint_names )  
  1904.       {
  1905.       info = sprintf(   "%4d %s %s", 
  1906.                         j++, 
  1907.                         and(debug_fun_bp_types[i],BP_ENABLED) \
  1908.                            ? "Enabled " \
  1909.                            : "Disabled", 
  1910.                         debug_fun_breakpoint_names[i] )
  1911.    
  1912.       set_dialog_item( bl_hdlg, IDL_LIST, DAC_ADD_ITEM, info )
  1913.       }
  1914.    
  1915.    if ( bpindex >= 0 )
  1916.       {
  1917.       num_items = query_dialog_item( bl_hdlg, IDL_LIST, DAC_COUNT_ITEMS )
  1918.  
  1919.       if ( bpindex < num_items )
  1920.          set_dialog_item( bl_hdlg, IDL_LIST, DAC_SELECT_INDEX, bpindex+0 )
  1921.       else 
  1922.          set_dialog_item( bl_hdlg, IDL_LIST, DAC_SELECT_INDEX, num_items-1 )
  1923.       }
  1924.    else
  1925.       set_dialog_item( bl_hdlg, IDL_LIST, DAC_SELECT_INDEX, 0 )
  1926.  
  1927.    # update breakpoints
  1928.    update_bp_marks()
  1929. }
  1930.  
  1931. global function debug_breakpoint_list()
  1932. {
  1933.    local    i        
  1934.    local    j        
  1935.    local    info[]
  1936.  
  1937.    if ( !bl_hdlg )
  1938.       bl_hdlg = debug_create_bl_dlg()
  1939.  
  1940.    update_bl()
  1941.  
  1942.    begin_dialog( bl_hdlg )
  1943. }
  1944.  
  1945. global function debug_bl_callback()
  1946. {
  1947.    local j
  1948.    local able_str
  1949.    local bpindex
  1950.    local gid
  1951.    local file
  1952.    local data[]
  1953.    local pos
  1954.    local str
  1955.    local line
  1956.    local ret_val = DRC_CONTINUE
  1957.  
  1958.    if ( callback_msg == DM_SET_FOCUS && callback_index != IDL_LIST )
  1959.       set_dialog_item( callback_dialog_handle, IDL_LIST, DAC_SETFOCUS )
  1960.  
  1961.    else if ( callback_msg == DM_INIT )
  1962.       set_dialog_item( callback_dialog_handle, IDL_LIST, DAC_SELECT_INDEX, 0 )
  1963.  
  1964.    else if ( callback_msg == DM_SELECT )
  1965.    {
  1966.       bpindex = query_dialog_item( callback_dialog_handle, IDL_LIST, DAC_SELECT_INDEX )
  1967.  
  1968.       if ( bpindex != -1 )
  1969.       {
  1970.          gid = bpindex_to_gid( bpindex )
  1971.  
  1972.          if ( debug_fun_breakpoints[ gid ] )
  1973.             set_dialog_item( callback_dialog_handle, DI_GOTO_BUTTON,    DAC_ENABLE )
  1974.          else
  1975.             set_dialog_item( callback_dialog_handle, DI_GOTO_BUTTON,    DAC_DISABLE )
  1976.  
  1977.          if ( and( debug_fun_bp_types[gid], BP_ENABLED ) )
  1978.             able_str = "~Disable"
  1979.          else
  1980.             able_str = "~Enable"
  1981.  
  1982.          set_dialog_item( callback_dialog_handle, DI_ABLE_BUTTON,       DAC_ENABLE ) 
  1983.          set_dialog_item( callback_dialog_handle, DI_CLEAR_BUTTON,      DAC_ENABLE )
  1984.          set_dialog_item( callback_dialog_handle, DI_CLEAR_ALL_BUTTON,  DAC_ENABLE )
  1985.  
  1986.          set_dialog_item( callback_dialog_handle, DI_ABLE_BUTTON, DAC_TEXT, able_str )
  1987.       }
  1988.       else
  1989.       {
  1990.          set_dialog_item( callback_dialog_handle, DI_GOTO_BUTTON,       DAC_DISABLE )
  1991.          set_dialog_item( callback_dialog_handle, DI_ABLE_BUTTON,       DAC_DISABLE ) 
  1992.          set_dialog_item( callback_dialog_handle, DI_CLEAR_BUTTON,      DAC_DISABLE )
  1993.          set_dialog_item( callback_dialog_handle, DI_CLEAR_ALL_BUTTON,  DAC_DISABLE )
  1994.       }
  1995.    }
  1996.    else if ( callback_msg == DM_CLICK || callback_msg == DM_DOUBLE_CLICK )
  1997.    {
  1998.       ret_val = DRC_MSG_PROCESSED
  1999.  
  2000.       bpindex  = query_dialog_item( callback_dialog_handle, IDL_LIST, DAC_SELECT_INDEX )
  2001.       gid      = bpindex_to_gid( bpindex )
  2002.  
  2003.       if ( callback_index == DI_GOTO_BUTTON && debug_fun_breakpoints[gid] > 0 )
  2004.       {
  2005.          str = query_dialog_item( callback_dialog_handle, IDL_LIST, DAC_SELECT_ITEM )
  2006.  
  2007.          # parse out the filename
  2008.          str = suffix( str, length(str) - rindex(str, " ") )
  2009.  
  2010.          pos = rindex( str, ":" )
  2011.          file = prefix( str, pos - 1 )
  2012.          line = suffix( str, length(str) - pos )
  2013.  
  2014.          debug_view( file, line )
  2015.       }
  2016.       else if ( callback_index == DI_ABLE_BUTTON )
  2017.       {
  2018.          if ( bpindex >= 0 )
  2019.          {
  2020.             able_str = query_dialog_item( callback_dialog_handle, DI_ABLE_BUTTON, DAC_TEXT )
  2021.    
  2022.             if ( able_str == "Enable" )
  2023.                be( bpindex )
  2024.             else
  2025.                bd( bpindex )
  2026.          }
  2027.       }
  2028.       else if ( callback_index == DI_CLEAR_BUTTON )
  2029.       {
  2030.          if ( bpindex >= 0 )
  2031.             bc( bpindex )
  2032.       }
  2033.       else if ( callback_index == DI_CLEAR_ALL_BUTTON )
  2034.          bc( -1 )
  2035.       else if ( callback_index == IDB_CLOSE_BTN )
  2036.          ret_val = DRC_EXIT
  2037.       else
  2038.          ret_val = dlg_list_callback()
  2039.    }
  2040.    else if (callback_msg == DM_CLOSE || callback_msg == DM_CANCEL )
  2041.       ret_val = DRC_EXIT;
  2042.    else 
  2043.       ret_val = dlg_list_callback()
  2044.  
  2045.    return ret_val
  2046. }
  2047.  
  2048.