############################################################################ # # File: dbg_run.icn # # Subject: Icon interactive debugging. # Contains an interactive debugging run-time system. # # Author: Hakan Soderstrom # # Revision: $Revision$ # ########################################################################### # # Copyright (c) 1994 Hakan Soderstrom and # Soderstrom Programvaruverkstad AB, Sweden # # Permission to use, copy, modify, distribute, and sell this software # and its documentation for any purpose is hereby granted without fee, # provided that the above copyright notice and this permission notice # appear in all copies of the software and related documentation. # # THE SOFTWARE IS PROVIDED "AS-IS" AND WITHOUT WARRANTY OF ANY KIND, # EXPRESS, IMPLIED OR OTHERWISE, INCLUDING WITHOUT LIMITATION, ANY # WARRANTY OF MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. # # IN NO EVENT SHALL HAKAN SODERSTROM OR SODERSTROM PROGRAMVARUVERKSTAD # AB BE LIABLE FOR ANY SPECIAL, INCIDENTAL, INDIRECT OR CONSEQUENTIAL # DAMAGES OF ANY KIND, OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS # OF USE, DATA OR PROFITS, WHETHER OR NOT ADVISED OF THE POSSIBILITY # OF DAMAGE, AND ON ANY THEORY OF LIABILITY, ARISING OUT OF OR IN # CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. # ########################################################################### # # General note: all names are prefixed in an elaborate way in order to # avoid name collisions with the debugged program. # The default prefix for all globally visible names is '__dbg_'. # # This is the reason why lists are frequently used instead of records # (whose field names clutter the global name space). # ########################################################################### # #-------- Constants -------- # # Versions (this program and 'itweak'). $define PROGRAM_VERSION "$Revision$" # Components of a breakpoint descriptor (list). # Breakpoint id (integer). $define BRKP_ID 1 # Source file (string). $define BRKP_FILE 2 # File index. $define BRKP_FIDX 3 # First line number. $define BRKP_LINE1 4 # Second line number. $define BRKP_LINE2 5 # Ignore counter (integer). $define BRKP_IGNORE 6 # Condition for breaking. $define BRKP_COND 7 # Commands to perform on break. $define BRKP_DO 8 # Constants for 'the current breakpoint' and 'the last breakpoint'. $define BRKP_CURRENT -1 $define BRKP_LAST -2 # Keywords for the 'clear' command. # Definitions must match list in compilation procedure. $define CLEAR_BREAKPOINT 1 $define CLEAR_COND 2 $define CLEAR_DO 3 $define CLEAR_ECHO 4 $define CLEAR_MACRO 5 # Keywords for the 'info' command. # Definitions must match list in compilation procedure. $define INFO_BREAKPOINT 1 $define INFO_ECHO 2 $define INFO_FILES 3 $define INFO_GLOBALS 4 $define INFO_LOCALS 5 $define INFO_MACROS 6 $define INFO_TRACE 7 $define INFO_VERSION 8 # Keywords for the 'set' command. # Definitions must match list in compilation procedure. $define SET_ECHO 1 $define SET_PRELUDE 2 $define SET_POSTLUDE 3 # Components of a command definition (list). # Used for built-in commands as well as user-defined macros. # Unabbreviated command/macro name (string). $define CMD_NAME 1 # Command code (an integer corresponding to the name). $define CMD_CODE 2 # Help text (list of string). $define CMD_HELP 3 # Compilation procedure; null if macro. $define CMD_COMPILE 4 # Macro definition (list of command instances, list of list). # Null if built-in command. $define CMD_MACRO 5 # Executing procedure, if built-in. Null otherwise. $define CMD_EXEC 6 # Command codes. $define BREAK_CMD 1 $define CLEAR_CMD 2 $define COMMENT_CMD 3 $define CONDITION_CMD 4 $define DO_CMD 5 $define END_CMD 6 $define EPRINT_CMD 7 $define FAIL_CMD 8 $define FPRINT_CMD 9 $define FRAME_CMD 10 $define GOON_CMD 11 $define HELP_CMD 12 $define INFO_CMD 13 $define IGNORE_CMD 14 $define MACRO_CMD 15 $define NEXT_CMD 16 $define PRINT_CMD 17 $define SET_CMD 18 $define SOURCE_CMD 19 $define STOP_CMD 20 $define TRACE_CMD 21 $define WHERE_CMD 22 $define USERDEF_CMD 23 # Environment variable for defining the input file (must be a string value). $define DBG_INPUT_ENV "DBG_INPUT" # Environment variable for defining the primary output file # (must be a string value). $define DBG_OUTPUT_ENV "DBG_OUTPUT" # Prefix for debugging run-time global names. $define DBG_PREFIX "__dbg_" # Maximum source nesting levels. $define MAX_SOURCE_NESTING 12 # File index is obtained by shifting a small integer left a number of # positions. $define FIDX_SHIFT 10 # Prompt string to use in initialization mode. $define INIT_PROMPT "debug init $ " # Execution return status. # Normal return. $define OK_STATUS 0 # Break the command loop, resume execution. $define RESUME_STATUS 1 # Break the command loop, terminate the session. $define STOP_STATUS 2 # Break the command loop, make the current procedure fail. $define FAIL_STATUS 3 # Index into '__dbg_g_where'. $define WHERE_FILE 1 $define WHERE_LINE 2 $define WHERE_PROC 3 $define WHERE_BRKP 4 $define WHERE_PRELUDE 5 $define WHERE_POSTLUDE 6 # #-------- Record types -------- # # #-------- Globals -------- # global __dbg_default_prelude, __dbg_default_postlude # The source text for the default pre/postlude (single command assumed). global __dbg_g_automacro # The 'prelude' and 'postlude' macros. # List of two components: # (1) prelude commands, # (2) postlude commands. # Both are lists of compiled commands, not complete macros. global __dbg_g_brkpcnt # Counter incremented each break. # Used to identify the file written by 'display' which is used by several # commands. # In this way we can check if we have to write the file anew. global __dbg_g_brkpdef # Lookup table for breakpoints. # Entry key is a breakpoint id (integer). # Entry value is a breakpoint descriptor (list). global __dbg_g_brlookup # Lookup table for breakpoints. # Entry key is a file index or'ed with a line number (integer). # Entry value is a breakpoint descriptor (list). global __dbg_g_brkpid # Id of the latest breakpoint created (integer). global __dbg_g_cmd # Table of command and macro definitions. # Entry key is an unabbreviated command/macro name. # Entry value is a command descriptor (list). global __dbg_g_display # Name of temporary file used by '__dbg_x_opendisplay' and others. global __dbg_g_fileidx # Table mapping source file names on (large) integers. # Entry key is a source file name (string). # Entry value is a file index (integer). global __dbg_g_in # The file through which debugging input is taken. global __dbg_g_level # Value of &level for the interrupted procedure. # Calculated as &level for the breakpoint procedure - 1. global __dbg_g_local # Table containing local variables. # Entry key is variable name (string). # Entry value is the value of the variable (any type). global __dbg_g_out1 # Primary file for debugging output. global __dbg_g_out2, __dbg_g_out2name # Secondary file for debugging output; used for 'set echo'. # Null when no echoing is not active. # The name of this file. global __dbg_g_src # Stack of input files used by the 'source' command (list of file). # Empty list when no 'source' command is active. global __dbg_g_trace # Current trace level (passed to &trace when resuming execution). global __dbg_g_where # A list with data about the current breakpoint. # Contents (symbolic names below): # (1) Source file name (string). # (2) Source line number (integer). # (3) Procedure name (string). # (4) The breakpoint causing this break (breakpoint descriptor, a list). global __dbg_g_white # This program's definition of white space. # A note on the use of global '__dbg_test' (defined in 'dbg_init.icn'). # The runtime system assigns this variable one of the following values. # ** Function 'member' for ordinary testing against the breakpoint sets. # ** Function 'integer' (which is guaranteed to always fail, given a # set as its first parameter) in the 'nobreak' mode; execution continues # without break until the program completes. # ** Integer '2' which causes a break at every intercept point. # (Returns the second parameter which is the line number.) # #-------- Globals for Icon functions used by the debuggin runtime -------- # In an excruciating effort to avoid being hit by bad manners from the # program under test we use our own variables for Icon functions. global __dbg_fany, __dbg_fclose, __dbg_fdelete, __dbg_fexit, __dbg_ffind global __dbg_fgetenv, __dbg_fimage, __dbg_finsert, __dbg_finteger, __dbg_fior global __dbg_fishift, __dbg_fkey, __dbg_fmany, __dbg_fmatch global __dbg_fmove, __dbg_fpop, __dbg_fpos, __dbg_fproc, __dbg_fpush global __dbg_fput, __dbg_fread, __dbg_fremove, __dbg_freverse, __dbg_fright global __dbg_fsort, __dbg_fstring, __dbg_ftab, __dbg_ftable, __dbg_ftrim global __dbg_ftype, __dbg_fupto, __dbg_fwrite, __dbg_fwrites # #-------------- Expression management globals ----------- # global __dbg_ge_message # Holds message if there is a conflict in expression compilation or # evaluation global __dbg_ge_singular # Value used as default for the local variable table. # Must be initialized to an empty list (or other suitable value). # #-------- Main -------- # procedure __dbg_proc (file, line, proc_name, var_name, var_val[]) # This procedure is invoked a first time during initialization with parameters # all null. # Then it is called every time we hit a breakpoint during a debugging session. # The parameters define the breakpoint, as follows, # 'file': source file name (string). # 'line': source line number (integer). # 'proc_name': name of the current procedure (string). # 'var_name': names of variables local to the current procedure # (list of string). # The list is sorted alphabetically. # 'Local' variables include parameters and static variables. # 'var_val': The current values of the local variables (list). # The values occur in the same order as the names in 'var_name'. # NOTE: In order not to affect the logic of the debugged program this # procedure MUST FAIL. # If it returns anything the current procedure will fail immediately. local bdescr, cond, cmd, idx, tfname # Save trace level; turn tracing off. __dbg_g_trace := &trace &trace := 0 if \file then { # Not the first-time invocation from "dbg_init". # Increment the global breakpoint counter. __dbg_g_brkpcnt +:= 1 # Compute the procedure nesting level. __dbg_g_level := &level - 1 # Begin setting up the 'where' structure. __dbg_g_where := [file, line, proc_name, &null] # We get here either because of a 'next', or because we hit a # breakpoint. # If we break because of a 'next' we should not treat this as # a breakpoint, even if there is one on this source line. if __dbg_test === member then { # This is a breakpoint; get it. if bdescr := __dbg_g_brlookup[__dbg_fior (__dbg_g_fileidx[file], line)] then { # Check ignore count. ((bdescr[BRKP_IGNORE] -:= 1) = -1) | fail bdescr[BRKP_IGNORE] := 0 } else __dbg_io_cfl ("Mysterious break: %1 (%2:%3).", proc_name, file, line) } else { # Break caused by 'next'. # By convention treated as breakpoint number 0. bdescr := __dbg_g_brkpdef[0] # Check ignore count. ((bdescr[BRKP_IGNORE] -:= 1) = -1) | fail bdescr[BRKP_IGNORE] := 0 } __dbg_g_where[WHERE_BRKP] := bdescr # Create table of locals. __dbg_g_local := __dbg_ftable (__dbg_ge_singular) every idx := 1 to *var_name do __dbg_g_local[var_name[idx]] := var_val[idx] # Evaluate the condition of the breakpoint, if any. if cond := \(bdescr)[BRKP_COND] then { idx := 0 __dbg_e_eval (cond[1]) & (idx +:= 1) # Check for conflict. # Make sure we don't resume in such case. __dbg_io_cfl ("[%1] condition '%2'\n %3", bdescr[BRKP_ID], cond[2], \__dbg_ge_message) & (idx +:= 1) (idx > 0) | fail } # Reset the test procedure (effective if this is a 'next' break). __dbg_test := member # The first command to execute is the macro attached to the # breakpoint, if any; otherwise the prelude. cmd := (\(\bdescr)[BRKP_DO] | __dbg_g_automacro[1]) } else { # Initialize global variables for Icon functions. __dbg_func_init () # Initialize breakpoint globals. __dbg_g_brkpcnt := 0 __dbg_g_brkpdef := __dbg_ftable () __dbg_g_brlookup := __dbg_ftable () __dbg_g_brkpid := 0 # Compute the procedure nesting level. __dbg_g_level := &level - 2 # Create breakpoint number 0, used for 'next' breaks. __dbg_g_brkpdef[0] := [0, "*any*", 0, 0, 0, 0, , ] # Display file name. __dbg_g_display := "_DBG" || &clock[4:6] || &clock[7:0] || ".tmp" # More globals. __dbg_g_src := [] __dbg_g_white := ' \t' __dbg_ge_singular := [] # Create file index table. idx := -1 __dbg_g_fileidx := __dbg_ftable () every __dbg_g_fileidx[key(__dbg_file_map)] := __dbg_fishift ((idx +:= 1), FIDX_SHIFT) # Open input and output files. if tfname := __dbg_fgetenv (DBG_INPUT_ENV) then __dbg_g_in := __dbg_x_openfile (tfname) (/__dbg_g_in := &input) | __dbg_fpush (__dbg_g_src, &input) if tfname := __dbg_fgetenv (DBG_OUTPUT_ENV) then __dbg_g_out1 := __dbg_x_openfile (tfname, 1) /__dbg_g_out1 := &errout # Initialize command definitions. __dbg_cmd_init () # Set up the breakpoint data structure. # This is not a breakpoint; the following keeps some commands from # crashing. __dbg_g_local := __dbg_ftable () __dbg_g_where := [&null, 0, "main", &null] __dbg_default_prelude := "fprint \"[%1] %2 (%3:%4)\\n\";&bp;&proc;&file;&line" __dbg_default_postlude := "" __dbg_g_automacro := [[__dbg_c_compile (__dbg_default_prelude)], []] cmd := [] } # Command processing. repeat { case __dbg_c_interp (cmd) of { RESUME_STATUS: break STOP_STATUS: { __dbg_fremove (__dbg_g_display) __dbg_io_note ("Debug session terminates.") __dbg_fexit (0) } } # Get input until it compiles OK. repeat { (*__dbg_g_src > 0) | __dbg_fwrites ("$ ") if cmd := [__dbg_c_compile (__dbg_io_getline ())] then break } } # Run the postlude, if any; status discarded. __dbg_c_interp (__dbg_g_automacro[2]) &trace := __dbg_g_trace end # #-------- Command processing procedures -------- # procedure __dbg_c_compile (str, macro_def) # Compiles a command. # 'str' must be a command to compile (string). # 'macro_def' must be non-null to indicate a macro is being defined. # RETURNS a command instance (list), or # FAILS on conflict. local cmd, keywd str ? { __dbg_ftab (__dbg_fmany (__dbg_g_white)) keywd := __dbg_ftab (__dbg_fupto (__dbg_g_white) | 0) if *keywd = 0 then # empty line treated as comment return [__dbg_cx_NOOP, COMMENT_CMD] __dbg_ftab (__dbg_fmany (__dbg_g_white)) (cmd := __dbg_c_findcmd (keywd)) | fail return cmd[CMD_COMPILE] (cmd, macro_def) } end procedure __dbg_c_brkpt (not_zero) # Extracts a breakpoint id from a command. # A breakpoint id is either an integer, or one of the special forms # '.' (current), '$' (last defined). # 'not_zero' may be non-null to indicate that breakpoint number zero # is not accepted. # RETURNS a breakpoint identifier (integer) on success; # FAILS with a suitable conflict message otherwise. local id, res __dbg_ftab (__dbg_fmany (__dbg_g_white)) (res := (__dbg_finteger (__dbg_ftab (__dbg_fmany (&digits))) | 2(id := =".", BRKP_CURRENT) | 2(id := ="$", BRKP_LAST))) | { __dbg_io_cfl ("Breakpoint id (integer, '.', '$') expected.") fail } (res > 0) | /not_zero | { __dbg_io_cfl ("Breakpoint number 0 not accepted here.") fail } return res end procedure __dbg_c_interp (clist) # Command interpreter. # 'clist' must be a list of command instances. # The interpreter may call itself indirectly through commands. # RETURNS a status code, or # FAILS on conflict, abandoning its command list. local cmd, code every cmd := !clist do { (code := cmd[1]!cmd) | fail (code = OK_STATUS) | return code } return OK_STATUS end procedure __dbg_c_findcmd (keywd) # Finds a command descriptor given a keyword. # 'keywd' must be a command keyword candidate, possibly abbreviated (string). # RETURNS a command definition, or # FAILS with a message on conflict. local count, cmd, mstr, sep, try count := 0 sep := mstr := "" every __dbg_fmatch (keywd, (try := !__dbg_g_cmd)[CMD_NAME], 1, 0) do { cmd := try count +:= 1 mstr ||:= sep || cmd[CMD_NAME] sep := ", " } case count of { 0: { __dbg_io_cfl ("%1: unrecognized command.", keywd) fail } 1: return cmd default : { __dbg_io_cfl ("'%1': ambiguous (matches %2).", keywd, mstr) fail } } end procedure __dbg_c_findkey (keywd, keylist) # Finds a command descriptor given a keyword. # 'keywd' must be a keyword candidate, possibly abbreviated (string). # 'keylist' must be a list of available keywords. # RETURNS an integer index into 'keylist', or # FAILS with a message on conflict. local count, cmd, idx, mstr, sep count := 0 sep := mstr := "" every __dbg_fmatch (keywd, keylist[idx := 1 to *keylist], 1, 0) do { count +:= 1 mstr ||:= sep || keylist[cmd := idx] sep := ", " } case count of { 0: { __dbg_io_cfl ("%1: unrecognized keyword.", keywd) fail } 1: return cmd default : { __dbg_io_cfl ("'%1': ambiguous (matches %2).", keywd, mstr) fail } } end procedure __dbg_c_mcompile (fname) # Compiles a macro. # 'fname' must contain a file name (string) if the macro definition should # be read from a file; otherwise null. # If 'fname' is defined and can be opened, a null value is pushed on the file # stack before the file, as a mark. # RETURNS a macro, i.e. a list of compiled commands -- on success. # FAILS if a conflict arises during the macro definition. local cfl_count, cmd, f, line, macro cfl_count := 0 macro := [] if \fname then { if f := __dbg_x_openfile (fname) then { __dbg_fpush (__dbg_g_src, __dbg_g_in) __dbg_fpush (__dbg_g_src, &null) __dbg_g_in := f } else fail } repeat { (*__dbg_g_src > 0) | __dbg_fwrites ("> ") (line := __dbg_io_getline ()) | break if cmd := __dbg_c_compile (line, 1) then { if cmd[CMD_CODE] = END_CMD then break else __dbg_fput (macro, cmd) } else cfl_count +:= 1 (cfl_count < 30) | break } /__dbg_g_in := __dbg_fpop (__dbg_g_src) if cfl_count = 0 then return macro else { __dbg_io_note ("The definition did not take effect.") fail } end procedure __dbg_c_msource () # Checks if the source of a macro is a file. # RETURNS a file name if there is a '<' followed by a file name. # RETURNS null if there is nothing but white space. # FAILS with a message on conflict. local fname __dbg_ftab (__dbg_fmany (__dbg_g_white)) if ="<" then { __dbg_ftab (__dbg_fmany (__dbg_g_white)) if __dbg_fpos (0) then { __dbg_io_cfl ("File name expected.") fail } fname := __dbg_ftrim (__dbg_ftab (0)) } return fname end procedure __dbg_x_brkpt (id) # RETURNS a breakpoint descriptor, given a breakpoint id ('id', integer). # FAILS with a diagnostic message on conflict. local bdescr bdescr := case id of { BRKP_CURRENT: \__dbg_g_where[WHERE_BRKP] | (__dbg_io_cfl ("No current breakpoint."), &null) BRKP_LAST: \__dbg_g_brkpdef[__dbg_g_brkpid] | (__dbg_io_cfl ("Breakpoint [%1] undefined.", __dbg_g_brkpid), &null) default: \__dbg_g_brkpdef[id] | (__dbg_io_cfl ("Breakpoint [%1] undefined.", id), &null) } return \bdescr end procedure __dbg_x_dispglob (f, pat) # Essentially performs the 'info globals' command. # 'f' must be a display file open for input. # 'pat' must be a substring that variable names must contain. local fchanged, line, word static func initial { func := set () # A set containing all function names. every insert (func, function ()) } fchanged := [] until __dbg_fread (f) == "global identifiers:" repeat { (line := __dbg_fread (f)) | break word := [] line ? repeat { __dbg_ftab (__dbg_fmany (__dbg_g_white)) if __dbg_fpos (0) then break __dbg_fput (word, __dbg_ftab (__dbg_fupto (__dbg_g_white) | 0)) } __dbg_fmatch (DBG_PREFIX, word[1]) | (word[1] == word[-1]) | if __dbg_ffind (pat, word[1]) then __dbg_io_info ("%1", word[1]) # Check if function name has been used for other things. if member (func, word[1]) then { (word[-2] == "function" & word[-1] == word[1]) | put (fchanged, word[1]) } } if *fchanged > 0 then { __dbg_io_note ("The following global(s) no longer hold their usual Icon functions:") every __dbg_io_wrline (" " || !fchanged) } end procedure __dbg_x_dispinit (f) # Reads the display file, skipping over lines caused by the debugger. # 'f' must be the display file, open for input. # RETURNS the first 'significant' line. # NOTE that you must take care of the 'co-expression' line before calling # this procedure. local line until __dbg_fmatch (DBG_PREFIX, line := __dbg_fread (f)) while line[1] == " " | __dbg_fmatch (DBG_PREFIX, line) do line := __dbg_fread (f) return line end procedure __dbg_x_lbreak (bdescr) # Lists the nominal definition of a breakpoint. # 'bdescr' may be a breakpoint descriptor, or null. # If null all breakpoints are listed. local bd, blist, cond, dodef, tmplist (blist := [\bdescr]) | { tmplist := __dbg_fsort (__dbg_g_brkpdef) blist := [] every __dbg_fput (blist, (!tmplist)[2]) } every bd := !blist do { dodef := if \bd[BRKP_DO] then " DO defined" else "" __dbg_io_info ("[%1] %2 %3:%4%5", bd[BRKP_ID], bd[BRKP_FILE], bd[BRKP_LINE1], bd[BRKP_LINE2], dodef) if cond := \bd[BRKP_COND] then __dbg_io_info (" CONDITION: %1", cond[2]) } end procedure __dbg_x_openfile (fname, output, quiet) # Opens a file. # 'fname' must be the name of the file to open. # 'output' must be non-null if the file is to be opened for output. # 'quiet' must be non-null to prevent a conflict from generating a message. # RETURNS an open file on success; # FAILS with a message otherwise, unless 'quiet' is set. # FAILS silently if 'quiet' is set. local f, mode, modestr if \output then { mode := "w" modestr := "output" } else { mode := "r" modestr := "input" } (f := open (fname, mode)) | (\quiet & fail) | __dbg_io_cfl ("Cannot open '%1' for %2.", fname, modestr) return \f end procedure __dbg_x_opendisplay () # Opens the display file for reading; writes it first, if necessary. # RETURNS a file open for input on success. # FAILS with a message on conflict. local f, res if f := __dbg_x_openfile (__dbg_g_display,, 1) then { if __dbg_finteger (__dbg_fread (f)) = __dbg_g_brkpcnt then res := f else __dbg_fclose (f) } \res | { (f := __dbg_x_openfile (__dbg_g_display, 1)) | fail __dbg_fwrite (f, __dbg_g_brkpcnt) display (, f) __dbg_fclose (f) (f := __dbg_x_openfile (__dbg_g_display)) | fail __dbg_fread (f) # Throw away breakpoint counter. res := f } return res end #-------- Command compilation procedures -------- # 'macro_def' must be non-null to indicate that a macro is being defined. # The command compilation procedures must return a list representing the # compiled command, or fail on conflict. # When they are invoked the keyword and any following white space has been # parsed. procedure __dbg_cc_break (cmd, macro_def) local fidx, fname, line1, line2 __dbg_fany (&digits) | (fname := __dbg_ftab (__dbg_fupto (__dbg_g_white))) | { __dbg_io_cfl ("File name and/or line number expected.") fail } # Get file name. if \fname then { (fidx := \__dbg_g_fileidx[fname]) | { __dbg_io_cfl ("File name '%1' not recognized.", fname) fail } } else if fname := \__dbg_g_where[WHERE_FILE] then fidx := __dbg_g_fileidx[fname] else { # init mode __dbg_io_cfl ("File name required.") fail } # Get line number(s). __dbg_ftab (__dbg_fmany (__dbg_g_white)) (line1 := __dbg_finteger (__dbg_ftab (__dbg_fmany (&digits)))) | { __dbg_io_cfl ("Line number expected.") fail } __dbg_ftab (__dbg_fmany (__dbg_g_white)) if =":" then { __dbg_ftab (__dbg_fmany (__dbg_g_white)) (line2 := __dbg_finteger (__dbg_ftab (__dbg_fmany (&digits)))) | { __dbg_io_cfl ("Line number expected.") fail } } else line2 := line1 (line1 <= line2 < 1000000) | { __dbg_io_cfl ("Weird line number.") fail } # Create an almost finished breakpoint descriptor (id is missing). return [cmd[CMD_EXEC], cmd[CMD_CODE], [ , fname, fidx, line1, line2, 0, ,]] end procedure __dbg_cc_clear (cmd, macro_def) # A compound command. local keyidx, parm static ckey initial ckey := ["breakpoint", "condition", "do", "echo", "macro"] (keyidx := __dbg_c_findkey (__dbg_ftab (__dbg_fupto (__dbg_g_white) | 0), ckey)) | fail __dbg_ftab (__dbg_fmany (__dbg_g_white)) case keyidx of { CLEAR_BREAKPOINT: (parm := __dbg_c_brkpt (1)) | fail (CLEAR_COND | CLEAR_DO): (parm := __dbg_c_brkpt ()) | fail CLEAR_MACRO: (parm := __dbg_e_idf ()) | { __dbg_io_cfl ("Macro name expected.") fail } } return [cmd[CMD_EXEC], cmd[CMD_CODE], ckey, keyidx, parm] end procedure __dbg_cc_condition (cmd, macro_def) local brkpt, expr (brkpt := __dbg_c_brkpt ()) | fail # This makes the expression cleaner, but not necessary. __dbg_ftab (__dbg_fmany (__dbg_g_white)) (expr := __dbg_e_compile (__dbg_ftab (0))) | { __dbg_io_cfl (__dbg_ge_message) fail } (*expr = 1) | __dbg_io_note ("Last %1 expressions ignored.", *expr - 1) return [cmd[CMD_EXEC], cmd[CMD_CODE], brkpt, expr[1]] end procedure __dbg_cc_do (cmd, macro_def) local brkpt, fname /macro_def | { __dbg_io_cfl ("Sorry, nested macros not accepted.") fail } (brkpt := __dbg_c_brkpt ()) | fail (fname := __dbg_c_msource ()) | fail return [cmd[CMD_EXEC], cmd[CMD_CODE], brkpt, fname] end procedure __dbg_cc_end (cmd, macro_def) \macro_def | { __dbg_io_cfl ("'end' out of context.") fail } return [cmd[CMD_EXEC], cmd[CMD_CODE]] end procedure __dbg_cc_eprint (cmd, macro_def) local expr (expr := __dbg_e_compile (__dbg_ftab (0))) | { __dbg_io_cfl (__dbg_ge_message) fail } (*expr = 1) | __dbg_io_note ("Last %1 expressions ignored.", *expr - 1) return [cmd[CMD_EXEC], cmd[CMD_CODE], expr[1]] end procedure __dbg_cc_frame (cmd, macro_def) local frame_no __dbg_fpos (0) | (frame_no := __dbg_finteger (__dbg_ftab (__dbg_fmany (&digits ++ '-')))) | { __dbg_io_cfl ("Frame number expected.") fail } return [cmd[CMD_EXEC], cmd[CMD_CODE], frame_no] end procedure __dbg_cc_goon (cmd, macro_def) local opt __dbg_fpos (0) | __dbg_fmatch (opt := __dbg_ftab (__dbg_fmany (&lcase)), "nobreak", 1, 0) | { __dbg_io_cfl ("Expected 'nobreak', found '%1'.", opt) fail } return [cmd[CMD_EXEC], cmd[CMD_CODE], opt] end procedure __dbg_cc_help (cmd, macro_def) local keywd __dbg_fpos (0) | (keywd := __dbg_ftab (__dbg_fmany (&lcase))) | { __dbg_io_cfl ("Command keyword expected.") fail } return [cmd[CMD_EXEC], cmd[CMD_CODE], keywd] end procedure __dbg_cc_ignore (cmd, macro_def) local brkpt, count (brkpt := __dbg_c_brkpt ()) | fail __dbg_ftab (__dbg_fmany (__dbg_g_white)) (count := __dbg_finteger (__dbg_ftab (__dbg_fmany (&digits ++ '+-')))) | { __dbg_io_cfl ("Integer ignore count expected.") fail } return [cmd[CMD_EXEC], cmd[CMD_CODE], brkpt, count] end procedure __dbg_cc_info (cmd, macro_def) # A compound command. local keyidx, parm static ckey initial ckey := ["breakpoint", "echo", "files", "globals", "locals", "macros", "trace", "version"] (keyidx := __dbg_c_findkey (__dbg_ftab (__dbg_fupto (__dbg_g_white) | 0), ckey)) | fail __dbg_ftab (__dbg_fmany (__dbg_g_white)) if keyidx = INFO_BREAKPOINT then __dbg_fpos (0) | (parm := __dbg_c_brkpt ()) | fail else if keyidx = INFO_GLOBALS then __dbg_fpos (0) | (parm := __dbg_ftab (__dbg_fupto (__dbg_g_white) | 0)) return [cmd[CMD_EXEC], cmd[CMD_CODE], ckey, keyidx, parm] end procedure __dbg_cc_macro (cmd, macro_def) local fname, idf /macro_def | { __dbg_io_cfl ("Sorry, nested macros not accepted.") fail } (idf := __dbg_ftab (__dbg_fmany (&lcase))) | { __dbg_io_cfl ("Macro name expected.") fail } (fname := __dbg_c_msource ()) | fail return [cmd[CMD_EXEC], cmd[CMD_CODE], idf, fname] end procedure __dbg_cc_next (cmd, macro_def) local count __dbg_ftab (__dbg_fmany (__dbg_g_white)) __dbg_fpos (0) | (count := __dbg_finteger (__dbg_ftab (__dbg_fmany (&digits ++ '+-')))) | { __dbg_io_cfl ("Integer ignore count expected.") fail } return [cmd[CMD_EXEC], cmd[CMD_CODE], count] end procedure __dbg_cc_print (cmd, macro_def) # Used to compile 'fprint' and 'print'. local expr (expr := __dbg_e_compile (__dbg_ftab (0))) | { __dbg_io_cfl (__dbg_ge_message) fail } return [cmd[CMD_EXEC], cmd[CMD_CODE], expr] end procedure __dbg_cc_set (cmd, macro_def) # A compound command. local keyidx, parm static ckey initial ckey := ["echo", "prelude", "postlude"] (keyidx := __dbg_c_findkey (__dbg_ftab (__dbg_fupto (__dbg_g_white) | 0), ckey)) | fail __dbg_ftab (__dbg_fmany (__dbg_g_white)) case keyidx of { SET_ECHO: { parm := __dbg_ftrim (__dbg_ftab (__dbg_fupto (__dbg_g_white) | 0)) (*parm > 0) | { __dbg_io_cfl ("File name expected.") fail } } (SET_PRELUDE | SET_POSTLUDE): (parm := __dbg_c_msource ()) | fail } return [cmd[CMD_EXEC], cmd[CMD_CODE], ckey, keyidx, parm] end procedure __dbg_cc_source (cmd, macro_def) # The 'source' command is different from other commands, because it is not # really compiled; it takes effect immediately. # In contrast to macro compilation, no null marker is pushed on the file stack. # RETURNS a dummy 'source' command. local f, fname, res __dbg_ftab (__dbg_fmany (__dbg_g_white)) if __dbg_fpos (0) then __dbg_io_cfl ("File name expected.") else { fname := __dbg_ftrim (__dbg_ftab (0)) if *__dbg_g_src >= MAX_SOURCE_NESTING then __dbg_io_cfl ("%1: Too deeply nested 'source' file.", fname) else if f := __dbg_x_openfile (fname) then { __dbg_fpush (__dbg_g_src, __dbg_g_in) __dbg_g_in := f res := [cmd[CMD_EXEC], cmd[CMD_CODE], fname] } } return \res end procedure __dbg_cc_trace (cmd, macro_def) local tlevel (tlevel := __dbg_finteger (__dbg_ftab (__dbg_fmany (&digits ++ '+-')))) | { __dbg_io_cfl ("Integer value expected.") fail } return [cmd[CMD_EXEC], cmd[CMD_CODE], \tlevel] end procedure __dbg_cc_SIMPLE (cmd, macro_def) # Used to compile all keyword-only commands, including macros. return [cmd[CMD_EXEC], cmd[CMD_CODE], cmd[CMD_MACRO]] end #-------- Command executing procedures -------- # The first parameter of these procedures is the procedure itself. # (Not a very interesting parameter.) # The command executing procedures must return a return code on success. # Return codes are defined among the symbolic constants. # The procedures must fail on conflict. procedure __dbg_cx_break (proced, ccode, brkp) local id, bpset, fidx, line1, line2 # Add the breakpoint id to the descriptor. brkp[BRKP_ID] := id := (__dbg_g_brkpid +:= 1) __dbg_io_wrline ("[" || id || "]") # Make sure we can find the breakpint descriptor, given its id. __dbg_g_brkpdef[id] := brkp # Install the breakpoint lines in the lookup table. fidx := brkp[BRKP_FIDX] line1 := brkp[BRKP_LINE1] line2 := brkp[BRKP_LINE2] every __dbg_g_brlookup[__dbg_fior (fidx, line1 to line2)] := brkp # Add the line numbers to the breakpoint set. bpset := __dbg_file_map[brkp[BRKP_FILE]] every __dbg_finsert (bpset, line1 to line2) return OK_STATUS end procedure __dbg_cx_clear (proced, ccode, ckey, keyidx, parm) # 'ckey' will be a list containing all the possible keywords to 'clear'. # 'keyidx' is an index into that list, indicating a subcommand. local bdescr, bpset, cmd, fidx, lcode, line, line1, line2 if keyidx = (CLEAR_BREAKPOINT | CLEAR_COND | CLEAR_DO) then (bdescr := __dbg_x_brkpt (parm)) | fail else if keyidx = CLEAR_MACRO then (cmd := __dbg_c_findcmd (parm)) | fail case keyidx of { CLEAR_BREAKPOINT: { __dbg_fdelete (__dbg_g_brkpdef, bdescr[BRKP_ID]) fidx := bdescr[BRKP_FIDX] line1 := bdescr[BRKP_LINE1] line2 := bdescr[BRKP_LINE2] bpset := __dbg_file_map[bdescr[BRKP_FILE]] # The range of lines once defined for the breakpoint might # have been overwritten by later breakpoints. every lcode := __dbg_fior (fidx, line := line1 to line2) do { if __dbg_g_brlookup[lcode] === bdescr then { __dbg_fdelete (__dbg_g_brlookup, lcode) __dbg_fdelete (bpset, line) } } } CLEAR_COND: bdescr[BRKP_COND] := &null CLEAR_DO: bdescr[BRKP_DO] := &null CLEAR_ECHO: { __dbg_fclose (\__dbg_g_out2) __dbg_g_out2 := &null } CLEAR_MACRO: { (cmd := __dbg_c_findcmd (parm)) | fail __dbg_fdelete (__dbg_g_cmd, cmd[CMD_NAME]) } } return OK_STATUS end procedure __dbg_cx_condition (proced, ccode, brkpt, expr) local bdescr (bdescr := __dbg_x_brkpt (brkpt)) | fail bdescr[BRKP_COND] := expr return OK_STATUS end procedure __dbg_cx_do (proced, ccode, brkpt, fname) local bdescr (bdescr := __dbg_x_brkpt (brkpt)) | fail (bdescr[BRKP_DO] := __dbg_c_mcompile (fname)) | fail return OK_STATUS end procedure __dbg_cx_eprint (proced, ccode, expr) local count, val __dbg_io_wrline ("{" || expr[2] || "}") count := 0 every val := __dbg_fimage (__dbg_e_eval (expr[1])) do { if __dbg_io_cfl (\__dbg_ge_message) then fail else __dbg_io_wrline ("" || __dbg_fright ((count +:= 1), 3) || ": " || val) } return OK_STATUS end procedure __dbg_cx_fprint (proced, ccode, elist) # 'elist' must be a list on the format returned by '__dbg_e_compile'. local expr, fmt, idx, sval, val val := [] every expr := !elist do { __dbg_fput (val, __dbg_e_eval (expr[1]) | "&fail") if __dbg_io_cfl (\__dbg_ge_message) then fail } (fmt := __dbg_fstring (val[1])) | { __dbg_io_cfl ("Expected format string; got '%1'.", __dbg_fimage (val[1])) fail } sval := [] every idx := 2 to *val do { __dbg_fput (sval, __dbg_fstring (val[idx])) | { __dbg_io_cfl ("Expression not string-convertible: {%1} %2", elist[idx][2], __dbg_fimage (val[idx])) fail } } __dbg_io_wrstr (__dbg_x_subst (fmt, sval)) return OK_STATUS end procedure __dbg_cx_frame (proced, ccode, frame_spec) local f, frame_no, idx, line frame_no := if \frame_spec then { if frame_spec < 0 then __dbg_g_level + frame_spec else frame_spec } else __dbg_g_level (1 <= frame_no <= __dbg_g_level) | { __dbg_io_cfl ("Invalid frame number.") fail } (f := __dbg_x_opendisplay ()) | fail line := __dbg_x_dispinit (f) idx := __dbg_g_level while idx > frame_no do { repeat if (line := __dbg_fread (f))[1] ~== " " then break idx -:= 1 } __dbg_io_info ("(%1) %2", frame_no, line) repeat { if (line := __dbg_fread (f))[1] ~== " " then break line ? { __dbg_ftab (__dbg_fmany (__dbg_g_white)) =DBG_PREFIX | __dbg_io_info ("%1", line, *line > 0) } } __dbg_fclose (f) return OK_STATUS end procedure __dbg_cx_goon (proced, ccode, nobreak) if \nobreak then { __dbg_test := integer __dbg_fremove (__dbg_g_display) } return RESUME_STATUS end procedure __dbg_cx_help (proced, ccode, keywd) # 'keywd' will be an identifier if the command had a keyword. local cmd, hstr if cmd := __dbg_c_findcmd (\keywd) then { if hstr := \cmd[CMD_HELP] then __dbg_io_wrline (hstr) else __dbg_io_note ("No help available for '%1'.", cmd[CMD_NAME]) } else __dbg_io_wrline ("Available commands: (all keywords may be abbreviated)\n_ break (set breakpoint)\n_ clear (clear breakpoint or debugger parameter)\n_ condition (attach condition to breakpoint)\n_ do (attach macro to breakpoint)\n_ end (terminate macro definition)\n_ eprint (print every value from expression)\n_ fprint (formatted print)\n_ frame (inspect procedure call chain)\n_ goon (resume execution)\n_ help (print explanatory text)\n_ ignore (set ignore counter on breakpoint)\n_ info (print information about breakpoint or debugger parameter)\n_ macro (define new command)\n_ next (resume execution, break on every line)\n_ print (print expressions)\n_ set (set a debugger parameter)\n_ source (read debugging commands from file)\n_ stop (terminate program and debugging session)\n_ trace (set value of Icon &trace)\n_ where (print procedure call chain)\n\n_ An expression may be formed from a large subset of Icon operators; integer,\n_ string, list literals; locals from the current procedure, and globals.\n_ Procedure/function invocation, subscripting, record field reference is\n_ supported. Several keywords are also included.\n\n_ New/altered keywords,\n_ \ &bp, &breakpoint current breakpoint id (integer)\n_ \ &file current breakpoint source file name (string)\n_ \ &line current breakpoint line number (integer)\n_ \ &proc current breakpoint procedure name (string)") return OK_STATUS end procedure __dbg_cx_ignore (proced, ccode, brkpt, count) local bdescr (bdescr := __dbg_x_brkpt (brkpt)) | fail bdescr[BRKP_IGNORE] := count return OK_STATUS end procedure __dbg_cx_info (proced, ccode, ckey, keyidx, parm) # 'ckey' will be a list containing all the possible keywords to 'info'. # 'keyidx' is an index into that list, indicating a subcommand. local cmd, bdescr, f, nlist, version case keyidx of { INFO_BREAKPOINT: if \parm then { (bdescr := __dbg_x_brkpt (parm)) | fail __dbg_x_lbreak (bdescr) } else __dbg_x_lbreak () INFO_ECHO: if \__dbg_g_out2 then __dbg_io_info ("Echo file: %1.", __dbg_g_out2name) else __dbg_io_info ("No echo file.") INFO_FILES: { nlist := [] every __dbg_fput (nlist, __dbg_fkey (__dbg_file_map)) nlist := __dbg_fsort (nlist) __dbg_io_info ("Tweaked source files in this program:") every __dbg_io_info (" %1", !nlist) } INFO_GLOBALS: { (f := __dbg_x_opendisplay ()) | fail if \parm then __dbg_x_dispglob (f, parm) else __dbg_x_dispglob (f, "") __dbg_fclose (f) } INFO_LOCALS: { nlist := [] every __dbg_fput (nlist, __dbg_fkey (__dbg_g_local)) nlist := __dbg_fsort (nlist) __dbg_io_info ("Local identifiers in the current procedure:", *nlist > 0) every __dbg_io_info (" %1", !nlist) } INFO_MACROS: { nlist := [] every \(cmd := !__dbg_g_cmd)[CMD_MACRO] do __dbg_fput (nlist, cmd[CMD_NAME]) nlist := __dbg_fsort (nlist) __dbg_io_info ("Currently defined macros:", *nlist > 0) every __dbg_io_info (" %1", !nlist) } INFO_TRACE: __dbg_io_info ("Current trace level: %1.", __dbg_g_trace) INFO_VERSION: { version := (PROGRAM_VERSION ? (__dbg_ftab (__dbg_fupto (&digits)), __dbg_ftab (__dbg_fmany (&digits++'.')))) __dbg_io_info ("Program tweaked by itweak version %1.\n_ This is runtime version %2.", __dbg_itweak_ver, version) } } return OK_STATUS end procedure __dbg_cx_macro (proced, ccode, idf, fname) # Executes a 'macro' statement (not the resulting macro). # 'fname' contains a file name (string) if the macro definition should be # read from a file; otherwise null. # SIDE EFFECT: Adds a command definition to '__dbg_g_cmd' on success. local count, macro, mstr, sep, try count := 0 mlist := [] # Macro name must not be an abbreviation of an existing command. every __dbg_fmatch (idf, try := (!__dbg_g_cmd)[CMD_NAME], 1, 0) do { count +:= 1 __dbg_fput (mlist, try) } # Check that no existing command is an abbreviation of macro name. every __dbg_fmatch (try := (!__dbg_g_cmd)[CMD_NAME], idf, 1, 0) do { count +:= 1 (try == !mlist) | __dbg_fput (mlist, try) } (count = 0) | { mstr := sep := "" every mstr ||:= sep || !mlist do sep := ", " __dbg_io_cfl ("'%1' clashes with existing command (%2).", idf, mstr) fail } (macro := __dbg_c_mcompile (fname)) | fail __dbg_g_cmd[idf] := [idf, USERDEF_CMD, , __dbg_cc_SIMPLE, macro, __dbg_cx_userdef] return OK_STATUS end procedure __dbg_cx_next (proced, ccode, count) # 'count' may be an ignore count. __dbg_g_brkpdef[0][BRKP_IGNORE] := \count __dbg_test := 2 return RESUME_STATUS end procedure __dbg_cx_print (proced, ccode, elist) # 'elist' must be a list on the format returned by '__dbg_e_compile'. local expr, val every expr := !elist do { val := (__dbg_fimage (__dbg_e_eval (expr[1])) | "&fail") if __dbg_io_cfl (\__dbg_ge_message) then fail else __dbg_io_wrline ("{" || expr[2] || "} " || val) } return OK_STATUS end procedure __dbg_cx_set (proced, ccode, ckey, keyidx, parm) # 'ckey' will be a list containing all the possible keywords to 'set'. # 'keyidx' is an index into that list, indicating a subcommand. case keyidx of { SET_ECHO: { (__dbg_g_out2 := __dbg_x_openfile (parm, 1)) | fail __dbg_g_out2name := parm } SET_PRELUDE: (__dbg_g_automacro[1] := __dbg_c_mcompile (parm)) | fail SET_POSTLUDE: (__dbg_g_automacro[2] := __dbg_c_mcompile (parm)) | fail } return OK_STATUS end procedure __dbg_cx_stop (proced, ccode) return STOP_STATUS end procedure __dbg_cx_trace (proced, ccode, tlevel) __dbg_g_trace := tlevel return OK_STATUS end procedure __dbg_cx_where (proced, ccode) local f, idf, idx, line (f := __dbg_x_opendisplay ()) | fail __dbg_io_info ("Current call stack in %1:", __dbg_fread (f)) idx := __dbg_g_level line := __dbg_x_dispinit (f) repeat { idf := (line ? __dbg_ftab (__dbg_fupto (__dbg_g_white))) if idf == "global" then break if *idf > 0 then { __dbg_io_info ("(%1) %2", idx, idf) idx -:= 1 } (line := __dbg_fread (f)) | break # Sanity. } __dbg_fclose (f) return OK_STATUS end procedure __dbg_cx_userdef (proced, ccode, macro) return __dbg_c_interp (macro) end procedure __dbg_cx_NOOP (proced, ccode) return OK_STATUS end # #-------- General-purpose procedures -------- # procedure __dbg_x_fld_adj (str) # Part of 'subst' format string parsing. # 'str' must be a parameter string identified by the beginning part of a # placeholder ('%n'). # This procedure checks if the placeholder contains a fixed field width # specifier. # A fixed field specifier begins with '<' or '>' and continues with the field # width expressed as a decimal literal. # RETURNS 'str' possibly inserted in a fixed width field. local just, init_p, res, wid static fwf initial fwf := '<>' init_p := &pos if (just := if ="<" then left else if =">" then right) & (wid := __dbg_finteger (__dbg_ftab (__dbg_fmany (&digits)))) then res := just (str, wid) else { res := str &pos := init_p } return res end procedure __dbg_x_subst (msg, parm) # Substitutes parameters in a message template. # 'msg' must be a message template (string). # 'parm' must be a list of parameters (list of string-convertible), or null. # It may also be a string. local esc, res, sub static p_digit initial p_digit := '123456789' \parm | return msg parm := [__dbg_fstring (parm)] res := "" msg ? until __dbg_fpos (0) do { res ||:= __dbg_ftab (__dbg_fupto ('%\\') | 0) if ="%" then res ||:= { if __dbg_fany (p_digit) then { sub := (\parm[__dbg_finteger (__dbg_fmove (1))] | "") __dbg_x_fld_adj (sub) } else if __dbg_fany ('%') then __dbg_fmove (1) else "" } else if ="\\" then res ||:= case esc := __dbg_fmove (1) of { "n": "\n" "t": "\t" default: esc } } return res end # #-------- Input/Output procedures -------- # procedure __dbg_io_cfl (format, parm[]) # Writes a conflict message to debugging output. # 'format' must be a format string. # 'parm' must be string-convertibles to insert into placeholders in the # format string, if any. # RETURNS 1 (i.e. always succeeds). __dbg_io_wrline ("[debug CONFLICT] " || __dbg_x_subst (format, parm)) return 1 end procedure __dbg_io_getline () # RETURNS the next line from debugging input, or # FAILS on end of file. local line (line := __dbg_fread (__dbg_g_in)) | { __dbg_fclose (__dbg_g_in) # Check for a macro definition marker. \(__dbg_g_in := __dbg_fpop (__dbg_g_src)) | fail if *__dbg_g_src > 0 then return __dbg_io_getline () } __dbg_fwrite (\__dbg_g_out2, "$ ", \line) return \line end procedure __dbg_io_info (format, parm[]) # Writes an info message to debugging output. # 'format' must be a format string. # 'parm' must be string-convertibles to insert into placeholders in the # format string, if any. __dbg_io_wrline (__dbg_x_subst (format, parm)) end procedure __dbg_io_note (format, parm[]) # Writes a note to debugging output. # 'format' must be a format string. # 'parm' must be string-convertibles to insert into placeholders in the # format string, if any. __dbg_io_wrline ("[debug NOTE] " || __dbg_x_subst (format, parm)) end procedure __dbg_io_wrline (line) # Writes a string and a newline to debugging output. # 'line' must be the string to write. # It may contains additional newlines. __dbg_fwrite (__dbg_g_out1, line) __dbg_fwrite (\__dbg_g_out2, line) end procedure __dbg_io_wrstr (line) # Writes a string without a newline to debugging output. # 'line' must be the string to write. # It may contains additional newlines. __dbg_fwrites (__dbg_g_out1, line) __dbg_fwrites (\__dbg_g_out2, line) end # #-------- Function initialization --------- # procedure __dbg_func_init () __dbg_fany := any __dbg_fclose := close __dbg_fdelete := delete __dbg_fexit := exit __dbg_ffind := find __dbg_fgetenv := getenv __dbg_fimage := image __dbg_finsert := insert __dbg_finteger := integer __dbg_fior := ior __dbg_fishift := ishift __dbg_fkey := key __dbg_fmany := many __dbg_fmatch := match __dbg_fmove := move __dbg_fpop := pop __dbg_fpos := pos __dbg_fproc := proc __dbg_fpush := push __dbg_fput := put __dbg_fread := read __dbg_fremove := remove __dbg_freverse := reverse __dbg_fright := right __dbg_fsort := sort __dbg_fstring := string __dbg_ftab := tab __dbg_ftable := table __dbg_ftrim := trim __dbg_ftype := type __dbg_fupto := upto __dbg_fwrite := write __dbg_fwrites := writes end # #-------- Command initialization --------- # procedure __dbg_cmd_init () # Initialize command definitions. __dbg_g_cmd := __dbg_ftable () ### break __dbg_g_cmd["break"] := ["break", BREAK_CMD, " break [file] [line [: line]]\n_ Sets a breakpoint on a line or a range of lines. The file name (if present)\n_ must be one of the tweaked files (cf. the 'info files' command). If omitted\n_ the file of the current breakpoint is assumed. The identity of the new\n_ breakpoint (an integer) is displayed. It may be used in other commands.\n_ Besides an integer there are two other ways to identify a breakpoint,\n_ \ . (dot) the current breakpoint,\n_ \ $ (dollar) the last breakpoint defined by a 'break' command.\n_ Breakpoint 0 (zero) is special; see the 'next' command.\n\n_ As a rule a breakpoint takes effect AFTER the breakpointed line has been\n_ executed. If two breakpoints are defined on the same line, only the latest\n_ is in effect.", __dbg_cc_break, , __dbg_cx_break] ### clear __dbg_g_cmd["clear"] := ["clear", CLEAR_CMD, " clear breakpoint brkpt\n_ Deletes breakpoint identified by 'brkpt'.\n_ \ clear condition brkpt\n_ Removes condition from breakpoint 'brkpt'. The breakpoint becomes\n_ unconditional.\n_ \ clear do brkpt\n_ Removes commands associated with breakpoint 'brkpt'.\n_ \ clear echo\n_ Stops output to echo file.\n_ \ clear macro name\n_ Removes macro identified by 'name'.", __dbg_cc_clear, , __dbg_cx_clear] ### comment __dbg_g_cmd["#"] := ["#", COMMENT_CMD, " # comment text\n_ A line beginning with '#' is ignored.", __dbg_cc_SIMPLE, , __dbg_cx_NOOP] ### condition __dbg_g_cmd["condition"] := ["condition", CONDITION_CMD, " condition brkpt expr\n_ Attaches a condition to breakpoint 'brkpt'. The expression 'expr' must\n_ succeed for a break to occur.", __dbg_cc_condition, , __dbg_cx_condition] ### do __dbg_g_cmd["do"] := ["do", DO_CMD, " do brkpt [="] := NGE_OP optab[">"] := NGT_OP optab["<<"] := LLT_OP optab["<<="] := LLE_OP optab["=="] := LEQ_OP optab["~=="] := LNE_OP optab[">>="] := LGE_OP optab[">>"] := LGT_OP optab["==="] := EQ_OP optab["~==="] := NE_OP optab["+"] := ADD_OP optab["-"] := SUBTR_OP optab["++"] := UNION_OP optab["--"] := DIFF_OP optab["||"] := CAT_OP optab["|||"] := LCAT_OP optab["*"] := MUL_OP optab["/"] := DIV_OP optab["%"] := REM_OP optab["**"] := ISCT_OP optab["^"] := EXP_OP } __dbg_ftab (__dbg_fmany (' \t')) suspend \optab[__dbg_fmove (3)] | \optab[__dbg_fmove (2)] | \optab[__dbg_fmove (1)] | \optab[=("~===")] end procedure __dbg_e_ws() # Removes optional white space. # The point is that it always succeeds. __dbg_ftab (__dbg_fmany (' \t')) return 1 end #-------------- Linearization ---------------------- procedure __dbg_e_ecode (ex, res) # 'Evaluates' the list resulting from pattern matching. # Produces a single list with everything in postfix order. # 'ex' must be an expression in the form that '__dbg_e_compile' generates. # 'res' must be an (empty) list where the expression elements are to # be inserted. # Always FAILS. # SIDE EFFECT: Adds elements to 'res'. # Assigns a message string to '__dbg_ge_message' on conflict. local opnd, oprt, op_stack if *ex = 1 then __dbg_e_tcode (ex[1], res) else { op_stack := [] opnd := create !ex __dbg_e_tcode (@opnd, res) while oprt := @opnd do { while (op_stack[1]/100) <= (oprt/100) do __dbg_fput (res, __dbg_e_proc ([BINOP_T, __dbg_fpop (op_stack),])) __dbg_fpush (op_stack, oprt) __dbg_e_tcode (@opnd, res) } while __dbg_fput (res, __dbg_e_proc ([BINOP_T, __dbg_fpop (op_stack),])) } end procedure __dbg_e_tcode (tm, res) # Disentangles a term. local comp, unary static special, unop initial { special := __dbg_ftable () # The 'normal' keywords. special["clock"] := CLOCK_SP special["current"] := CURRENT_SP special["date"] := DATE_SP special["dateline"] := DATELINE_SP special["pos"] := POS_SP special["regions"] := REGIONS_SP special["source"] := SOURCE_SP special["storage"] := STORAGE_SP special["subject"] := SUBJECT_SP special["trace"] := TRACE_SP special["version"] := VERSION_SP # The special keywords. special["bp"] :=BREAK_SP special["breakpoint"] :=BREAK_SP special["file"] := FILE_SP special["level"] := LEVEL_SP special["line"] := LINE_SP special["proc"] := PROC_SP unop := __dbg_ftable () unop["\\"] := NOTN_OP unop["/"] := ISN_OP unop["*"] := SIZ_OP unop["!"] := BNG_OP unop["-"] := NEG_OP } every comp := !tm do case comp[1] of { UNOP_T: unary := comp # Save for later. INTEGER_T: { comp[2] := __dbg_finteger (comp[2]) __dbg_fput (res, comp) } SPECIAL_T: { if comp[2] := \special[comp[2]] then __dbg_fput (res, comp) else __dbg_ge_message := "'" || comp[2] || "': unrecognized special identifier." } EXPR_T: __dbg_e_ecode (comp[2], res) LIST_T: { every __dbg_e_ecode (!comp[2], res) __dbg_fput (res, [LIST_T, *comp[2]]) } (FLD_OP | SSC_OP | INVOKE_OP | PART_OP) : __dbg_e_fcode (comp, res) default: __dbg_fput (res, comp) # This includes: IDENT_T, STRING_T } every __dbg_fput (res, __dbg_e_proc ([UNOP_T, unop[!__dbg_freverse ((\unary)[2])],])) end procedure __dbg_e_fcode (fm, res) # Disentangles a form. # The operators have the same precedence; stack not needed. local comp, opnd, oprt comp := create !fm while oprt := @comp do { opnd := @comp # There is at least one operand. case oprt of { FLD_OP: { __dbg_fput (res, opnd) __dbg_fput (res, [BINOP_T, oprt, __dbg_e_field]) } SSC_OP: { __dbg_e_ecode (opnd, res) __dbg_fput (res, [BINOP_T, oprt, __dbg_fproc ("[]", 2)]) } INVOKE_OP: { every __dbg_e_ecode (!opnd, res) __dbg_fput (res, [INVOKE_T, *opnd]) } PART_OP: { __dbg_e_ecode (opnd, res) __dbg_e_ecode (@comp, res) __dbg_fput (res, [TEROP_T, oprt, __dbg_fproc ("[:]", 3)]) } default: __dbg_ge_message := __dbg_fimage (oprt) || ": weird operator." } } end procedure __dbg_e_proc (op_d) # 'op_d' must be an operator descriptor (list(3)). # RETURNS the descriptor with the 3rd component filled in by a # procedure/function. static opt initial { opt := __dbg_ftable () opt[NOTN_OP] := __dbg_fproc ("\\", 1) opt[ISN_OP] := __dbg_fproc ("/", 1) opt[SIZ_OP] := __dbg_fproc ("*", 1) opt[BNG_OP] := __dbg_fproc ("!", 1) opt[NEG_OP] := __dbg_fproc ("-", 1) opt[ALT_OP] := __dbg_e_alt opt[CNJ_OP] := __dbg_e_cnj opt[NEQ_OP] := __dbg_fproc ("=", 2) opt[NNE_OP] := __dbg_fproc ("~=", 2) opt[NLE_OP] := __dbg_fproc ("<=", 2) opt[NLT_OP] := __dbg_fproc ("<", 2) opt[NGE_OP] := __dbg_fproc (">=", 2) opt[NGT_OP] := __dbg_fproc (">", 2) opt[LLT_OP] := __dbg_fproc ("<<", 2) opt[LLE_OP] := __dbg_fproc ("<<=", 2) opt[LEQ_OP] := __dbg_fproc ("==", 2) opt[LNE_OP] := __dbg_fproc ("~==", 2) opt[LGE_OP] := __dbg_fproc (">>=", 2) opt[LGT_OP] := __dbg_fproc (">>", 2) opt[EQ_OP] := __dbg_fproc ("===", 2) opt[NE_OP] := __dbg_fproc ("~===", 2) opt[ADD_OP] := __dbg_fproc ("+", 2) opt[SUBTR_OP] := __dbg_fproc ("-", 2) opt[UNION_OP] := __dbg_fproc ("++", 2) opt[DIFF_OP] := __dbg_fproc ("--", 2) opt[CAT_OP] := __dbg_fproc ("||", 2) opt[LCAT_OP] := __dbg_fproc ("|||", 2) opt[MUL_OP] := __dbg_fproc ("*", 2) opt[DIV_OP] := __dbg_fproc ("/", 2) opt[REM_OP] := __dbg_fproc ("%", 2) opt[ISCT_OP] := __dbg_fproc ("**", 2) opt[EXP_OP] := __dbg_fproc ("^", 2) opt[SSC_OP] := __dbg_fproc ("[]", 2) opt[PART_OP] := __dbg_fproc ("[:]", 2) opt[FLD_OP] := __dbg_e_field } op_d[3] := opt[op_d[2]] return op_d end #-------------- Evaluation ---------------------- procedure __dbg_e_eval (expr) # Evaluates a compiled expression. # 'expr' must be an expression using the representation created by # '__dbg_e_compile' (list). # GENERATES all expression values. # SIDE EFFECT: Assigns a message (string) to '__dbg_ge_message' on conflict; # assigns &null otherwise. local val __dbg_ge_message := &null &error := -1 every val := __dbg_e_eval1 (expr, []) do { &error := 0 suspend val __dbg_ge_message := &null &error := -1 } if &error < -1 then __dbg_ge_message := "Error number " || &errornumber || ": " || &errortext || "." || (("\nOffending value: " || __dbg_fimage (\&errorvalue) || ".") | "") &error := 0 end procedure __dbg_e_alt (opnd1, opnd2) # Our version of alternation. suspend (opnd1 | opnd2) end procedure __dbg_e_cnj (opnd1, opnd2) # Our version of conjunction. suspend (opnd1 & opnd2) end procedure __dbg_e_field (opnd1, opnd2) # Record field access. # Any better way to determine if a value is a record of any type? static builtin initial { builtin := __dbg_ftable () builtin["co-expression"] := 1 builtin["cset"] := 1 builtin["file"] := 1 builtin["integer"] := 1 builtin["list"] := 1 builtin["null"] := 1 builtin["procedure"] := 1 builtin["real"] := 1 builtin["set"] := 1 builtin["string"] := 1 builtin["table"] := 1 } if \builtin[__dbg_ftype (opnd1)] then { __dbg_ge_message := "Record expected; found " || __dbg_fimage (opnd1) fail } suspend opnd1[opnd2] end procedure __dbg_e_ident (idf) # Evaluates an identifier. local val (val := ((__dbg_ge_singular ~=== __dbg_g_local[idf]) | variable (idf))) | { __dbg_ge_message := "Identifier '" || idf || "' not visible." fail } suspend val end procedure __dbg_e_special (sp_code) # Evaluates a special identifier. suspend case sp_code of { # Regular Icon keyword variables. CLOCK_SP: &clock CURRENT_SP: ¤t DATE_SP: &date DATELINE_SP: &dateline POS_SP: &pos REGIONS_SP: ®ions SOURCE_SP: &source STORAGE_SP: &storage SUBJECT_SP: &subject VERSION_SP: &version # Special keywords. BREAK_SP: (\__dbg_g_where[WHERE_BRKP])[BRKP_ID] FILE_SP: __dbg_g_where[WHERE_FILE] LEVEL_SP: __dbg_g_level LINE_SP: __dbg_g_where[WHERE_LINE] PROC_SP: __dbg_g_where[WHERE_PROC] TRACE_SP: __dbg_g_trace default: { __dbg_ge_message := __dbg_fimage (sp_code) || ": weird special identifier code." fail } } end procedure __dbg_e_eval1 (expr, stack) # Evaluates an expression. # 'stack' must be the current evaluation stack (list). # The procedure is recursive; the initial invocation must supply an # empty list. local comp (comp := expr[1]) | while suspend __dbg_fpop (stack) | fail suspend __dbg_e_eval1 (expr[2:0], case comp[1] of { IDENT_T: stack ||| [__dbg_e_ident (comp[2])] SPECIAL_T: stack ||| [__dbg_e_special (comp[2])] LIST_T: stack[1:-comp[2]] ||| [stack[-comp[2]:0]] UNOP_T: stack[1:-1] ||| [comp[3](stack[-1])] BINOP_T: stack[1:-2] ||| [comp[3]!stack[-2:0]] TEROP_T: stack[1:-3] ||| [comp[3]!stack[-3:0]] INVOKE_T: stack[1:-(comp[2]+1)] ||| [stack[-(comp[2]+1)]!stack[-comp[2]:0]] default: stack ||| [comp[2]] }) end