===============================================================================
TABLE OF CONTENTS
1.REQUIREMENTS
2.INSTALLATION
3.START THE DEBUGGER
4.REMAINING BUGS
5.DEBUGGER COMMANDS
===============================================================================
1.REQUIREMENTS
===============================================================================
A valid development or runtime license. A temporary or demo license
cannot be used.
2.INSTALLATION
===============================================================================
The debugger is a part of the runtime system. No additional software is
required to debug 4GL applications.
See the documentation of the 3.00 compilers for more details about the
installation procedure.
3.STARTING THE DEBUGGER
===============================================================================
The debugger is included in the dynamic virtual machine. You can now start
the runner in normal or in debug mode.
IMPORTANT WARNING: You must re-compile your 4gl programs to use the debugger.
3.1. Start the runner in debug mode with -d option
--------------------------------------------------
You can start the runner with the -d option to enable debug mode.
Example : fglrun -d program
If you do not specify a file extension, the runner looks for a file called
program.42r.
When the debug mode is enabled, you can execute debug commands from the
terminal (UNIX) or command window (NT) to control the program execution.
A debug command file can be used to execute a set of commands. This command
file can be specified with the -f option as in the following example :
fglrun -f cmdfile -d program
By default, if you do not specify a command file with the -f option, the
debugger looks automatically for a file having the same name as the executed
4gl program, with a .4db extension.
Additionally, when the application is started in debug mode, you can load a
command file with the "READ" instruction.
To start the application, execute the "RUN" command at the debugger prompt.
To stop the debugger, execute the "EXIT" command.
3.2. Invoke the debug mode on running applications
--------------------------------------------------
3.2.1. On UNIX platforms
------------------------
Debug mode is activated on a running 4gl application by sending the
TRAP signal to the runner process.
Example :
On first terminal :
$ fglrun program.42r
On second terminal:
$ ps | grep fglrun
15966 pts/8 0:00 fglrun -d program.42r
$ kill -TRAP 15966
Warning : This is not possible if the runner has been started in background,
as the process is not attached to a terminal (The debugger needs a terminal
to get user commands).
To stop the debugger, you can leave the 4GL application or execute the
"EXIT" debug command.
3.2.2. On Microsoft Windows NT
------------------------------
If you want to activate the debug mode on a running 4GL application, you
must press the CTRL+BREAK key combination in the command window where the
runner has been started.
Example:
c:\> fglrun program.42r
- Open/select the command window
- Press CTRL+BREAK
To stop the debugger, you can leave the 4GL application or execute the
"EXIT" debug command.
4.REMAINING BUGS
===============================================================================
---------------------------
BUGS DECLARED
---------------------------
Bug # : 17110B
Status : DECLARED
Priority : BLOCKING AT USAGE (EMERGENCY OR HIGH PRIORITY)
Product : FOUR J'S UNIVERSAL COMPILER
System : ALL
DbEngine : ALL
Description : TEXT OR BYTE VARIABLE ARE NOT SUPPORTED BY THE DEBUGGER
Full description : Text and byte variable are not supported by the debugger.
For example, you cannot print a text variable or define a
break point on it.
Appeared the : 02/03/2000
Apparition version : 3.00.3c
Bug # : 17118
Status : DECLARED
Priority : NON BLOCKING BUT ANNOYING (LOW PRIORITY)
Product : FOUR J'S UNIVERSAL COMPILER
System : ALL
DbEngine : ALL
Description : THE DEBUGGER DOES NOT CREATE THE FGLAPSCR FILE WHITH THE
COMMAND CTRL+P
Full description : Pressing "CTRL+P" to capture the application screen is not
supported when using the debugger.
Appeared the : 22/02/2000
Apparition version : 3.00.3h
Bug # : 17126
Status : DECLARED
Priority : BLOCKING USAGE OR DEVELOPMENT (HIGH PRIORITY)
Product : FOUR J'S UNIVERSAL COMPILER
System : ALL
DbEngine : ALL
Description : THE DEBUGGER DOES NOT ACCEPT TO PRINT A SUBSTRING
Full description : When you want to print a substring with "print txt[1,5]",
you get a "Syntax error:,".
Appeared the : 23/02/2000
Apparition version : 3.00.3h
Bug # : 17142F
Status : DECLARED
Priority : NON BLOCKING BUT ANNOYING (LOW PRIORITY)
Product : FOUR J'S UNIVERSAL COMPILER
System : ALL
DbEngine : ALL
Description : DEBUGGER ALWAYS DISPLAYS "TYPES OF MODULE VARIABLES" EVEN
IF THEY DO NOT EXIST
Full description : When you define a cursor in your 4GL program and you
execute the command "variable global", the debugger
displays "TYPES OF MODULE VARIABLES OF MODULE
[]" even if no variables have been defined in
the module .
Appeared the : 20/03/2000
Apparition version : 3.00.8r
Bug # : 17149B
Status : DECLARED
Priority : NON BLOCKING BUT ANNOYING (LOW PRIORITY)
Product : FOUR J'S UNIVERSAL COMPILER
System : ALL
DbEngine : ALL
Description : DEBUGGER COMMAND VARIABLE ON INTERVAL DISPLAYS THE FIRST
QUALIFIER SIZE
Full description : The debugger command "variable" on an interval variable
displays the default value of the first qualifier size like
"var type INTERVAL DAY(2) TO DAY" when var is defined like
"INTERVAL DAY TO DAY".
Appeared the : 18/04/2000
Apparition version : 3.00.8o
Bug # : 17159B
Status : DECLARED
Priority : BLOCKING AT USAGE (EMERGENCY OR HIGH PRIORITY)
Product : FOUR J'S UNIVERSAL COMPILER
System : ALL
DbEngine : ALL
Description : "LET V=" STATEMENT IN A TRACE DOESN'T EXECUTE THE OTHERS
TRACE POINTS
Full description : When you define a trace on a variable v with a command
changing the variable v, like "trace v { let v = 5; pr v
}", the program doesn't execute the others trace points
defined on the variable v.
Appeared the : 29/06/2000
Apparition version : 3.04.6b
Bug # : 17161B
Status : DECLARED
Priority : BLOCKING USAGE OR DEVELOPMENT (HIGH PRIORITY)
Product : FOUR J'S UNIVERSAL COMPILER
System : ALL
DbEngine : ALL
Description : BREAK WITH IF DOESN'T DEFINE THE SCOPE FUNCTION
Full description : When you define a break with a condition and no line,
variable or function to link to this break, you get
corectly a new break, but this break is not liked to any
function scope. You should have a scope on the function
that defined the variable used in the condition.
Appeared the : 03/07/2000
Apparition version : 3.04.6b
Bug # : 17163B
Status : DECLARED
Priority : BLOCKING AT USAGE (EMERGENCY OR HIGH PRIORITY)
Product : FOUR J'S UNIVERSAL COMPILER
System : ALL
DbEngine : ALL
Description : "CLEANUP ALL" AND "CALL FUNCTION" STATEMENTS CAN GENERATE
ERROR AT EXECUTION
Full description : Start the runner in debug mode, then create a database,
then execute the CLEANUP ALL command. Call the function f1
doing a select in a table: You get error -349 "Database not
selected yet." Then select the database and call a second
time function f1, the program stops at the first break
point but when you want to continue the execution, you get
-16338 "Cannot continue execution." If you don't call the
f1 just after "cleanup all", it works fine.
Appeared the : 04/04/2000
Apparition version : 3.00.8t
Bug # : 17172
Status : UNDER CORRECTION
Priority : NON BLOCKING BUT ANNOYING (LOW PRIORITY)
Product : FOUR J'S UNIVERSAL COMPILER
System : ALL
DbEngine : ALL
Description : DEBUGGER LIST COMMAND DOESN'T DISPLAY THE BREAK/TRACE
POINTS IN THE RIGHT ORDER
Full description : When you execute the list command, you should get the list
of the break/trace points ordered by break/trace number.
The order is false when you disable/enable some break/trace
points.
Appeared the : 13/04/2000
Apparition version : 3.00.8v
Bug # : 17176
Status : ON HOLD
Priority : NON BLOCKING BUT ANNOYING (LOW PRIORITY)
Product : FOUR J'S UNIVERSAL COMPILER
System : ALL
DbEngine : ALL
Description : DEBUGGER ABBREVIATION MATCHING MULTIPLE COMMANDS RESULTS IN
A SYNTAX ERROR
Full description : Using an abbreviation that matches multiple commands (like
"v") results in a "Syntax error:". It would be better to
get the error "v is not an unique abbreviation. Choices
are: variable, view"
Appeared the : 17/04/2000
Apparition version : 3.00.8v
Bug # : 17180
Status : DECLARED
Priority : BLOCKING AT USAGE (EMERGENCY OR HIGH PRIORITY)
Product : FOUR J'S UNIVERSAL COMPILER
System : ALL
DbEngine : ALL
Description : WHEN YOU DISABLE A BREAK IF, THE OTHERS BREAKPOINTS ARE NOT
EXECUTED.
Full description : When you define several break points and one of them is a
break if with no scope (like "break if myvar = 10 { ... }")
and you desable this break point, you don't stop anymore
with the others breakpoints even they are enabled.
Appeared the : 29/06/2000
Apparition version : 3.04.6b
Bug # : 17181
Status : DECLARED
Priority : BLOCKING AT USAGE (EMERGENCY OR HIGH PRIORITY)
Product : FOUR J'S UNIVERSAL COMPILER
System : ALL
DbEngine : ALL
Description : WHEN YOU DEFINE A BREAK IF, YOU STOPS AT EACH 4GL STATEMENT
Full description : When you define a break if myvar = , you stops at
each 4gl statement and not only the 4gl statements where
myvar is touched.
Appeared the : 30/06/2000
Apparition version : 3.04.6b
Bug # : 17182
Status : DECLARED
Priority : NON BLOCKING BUT ANNOYING (LOW PRIORITY)
Product : FOUR J'S UNIVERSAL COMPILER
System : ALL
DbEngine : ALL
Description : EXECUTE AN EMPTY FILE WITH THE DEBUGGER GIVES A COREDUMP
Full description : When you try to execute an empty file with the debugger,
you get a coredump. We should receive the error message :
The function "main" has not be defined in any module in the
program.
Appeared the : 07/09/2000
Apparition version : 3.04.6d
Bug # : 17183
Status : DECLARED
Priority : NON BLOCKING BUT ANNOYING (LOW PRIORITY)
Product : FOUR J'S UNIVERSAL COMPILER
System : ALL
DbEngine : ALL
Description : YOU CANNOT READ OR WRITE A FILE WITH COMPLETE PATH THAT
CONTAINS "."
Full description : When you try to read / write a file with complete path that
contains "." you get an error. Example : write
/fjs/fgl2c/3.04.6d/demo/myfile, you get the error "Syntax
error 3.04".
Appeared the : 07/09/2000
Apparition version : 3.04.6d
Bug # : 17184
Status : DECLARED
Priority : NON BLOCKING BUT ANNOYING (LOW PRIORITY)
Product : FOUR J'S UNIVERSAL COMPILER
System : ALL
DbEngine : ALL
Description : THE HELP OF THE COMMAND WRITE IS WRONG
Full description : The help of the WRITE command says that this command saves
also the terminal display parameters. It is wrong.
Appeared the : 07/09/2000
Apparition version : 3.04.6d
Bug # : 17185
Status : DECLARED
Priority : NON BLOCKING BUT ANNOYING (LOW PRIORITY)
Product : FOUR J'S UNIVERSAL COMPILER
System : ALL
DbEngine : ALL
Description : THE RUN COMMAND DOESN'T REUSED ITS PREVIOUS PARAMETERS
Full description : If RUN is executed more than once during a debugging
session, the same arguments should be reused. The arguments
may be changed by specifying new ones in the RUN command.
Appeared the : 08/09/2000
Apparition version : 3.04.6d
---------------------------
BUGS NO CORRECTION PLANED
---------------------------
Bug # : 17101
Status : NO CORRECTION PLANED
Priority : BLOCKING USAGE OR DEVELOPMENT (HIGH PRIORITY)
Product : FOUR J'S UNIVERSAL COMPILER
System : ALL
DbEngine : ALL
Description : MODIFYING A VARIABLE WITHOUT CHANGING IT'S VALUE IS NOT
DETECTED BY THE DEBUGGER
Full description : When you execute a program with a .4db file defining a
break when the variable is modified, the modification
of the variable to the same value is not detected by
the debugger. The debugger should detect this modification.
Appeared the : 08/02/2000
Apparition version : 3.00.3c
Bug # : 17102B
Status : NO CORRECTION PLANED
Priority : NON BLOCKING BUT ANNOYING (LOW PRIORITY)
Product : FOUR J'S UNIVERSAL COMPILER
System : ALL
DbEngine : ALL
Description : THE COMMAND "BREAK " IS NOT ALWAYS ACCEPTED BY THE
DEBUGGER
Full description : When defining a break on a line which is blank, or having a
comment line outside a function or defining a function
"FUNCTION myfunc()", the debugger displays: Line number
not in the specified module. The line number should be
incremented until the next line holding a breakable 4gl
instruction.
Appeared the : 24/02/2000
Apparition version : 3.00.3h
Bug # : 17105
Status : NO CORRECTION PLANED
Priority : BLOCKING USAGE OR DEVELOPMENT (HIGH PRIORITY)
Product : FOUR J'S UNIVERSAL COMPILER
System : ALL
DbEngine : ALL
Description : CANNOT WRITE TO A FILE THAT YOU JUST DELETED BEFORE
Full description : When you execute the command "dump global >> tmp.xyy", then
you delete the file tmp.xyy and re-execute the command, the
file tmp.xyy is not re-created !
Appeared the : 11/02/2000
Apparition version : 3.00.3c
Bug # : 17115
Status : NO CORRECTION PLANED
Priority : NON BLOCKING BUT ANNOYING (LOW PRIORITY)
Product : FOUR J'S UNIVERSAL COMPILER
System : ALL
DbEngine : ALL
Description : THE DEBUGGER DOES NOT ACCEPT TO DEFINE AN ALIAS WITH OTHER
ALIAS
Full description : Defining aliases with other aliases like "alias f10 = f5",
raises a syntax error when you press f10: "Syntax
error:f5".
Appeared the : 22/02/2000
Apparition version : 3.00.3h
Bug # : 17115C
Status : NO CORRECTION PLANED
Priority : NON BLOCKING BUT ANNOYING (LOW PRIORITY)
Product : FOUR J'S UNIVERSAL COMPILER
System : ALL
DbEngine : ALL
Description : DEBUGGER DOES NOT LINE UP DATA WHEN DISPLAYING ALIASES
Full description : When you execute the debugger command "ALIAS *", the names
are not lined up. You get 2 spaces between the equal sign
and the command linked to the alias.
Appeared the : 05/04/2000
Apparition version : 3.00.8u
Bug # : 17142H
Status : NO CORRECTION PLANED
Priority : NON BLOCKING BUT ANNOYING (LOW PRIORITY)
Product : FOUR J'S UNIVERSAL COMPILER
System : ALL
DbEngine : ALL
Description : DEBUG COMMAND "VARIABLE GLOBALS" DOESN'T DISPLAY THE LIST
OF THE GLOBAL VARS
Full description : When you execute the command "variable globals" and the
variable "globals" exists, you get the type of the variable
"globals". You could not have the list of the global
variables. Same behaviour with a variable "all".
Appeared the : 05/04/2000
Apparition version : 3.00.8u
Bug # : 17148
Status : NO CORRECTION PLANED
Priority : NON BLOCKING BUT ANNOYING (LOW PRIORITY)
Product : FOUR J'S UNIVERSAL COMPILER
System : ALL
DbEngine : ALL
Description : THE SYNTAX "PRINT TAB.*" IS NOT SUPPORTED BY THE DEBUGGER
Full description : When you execute a statement like "print tab.*", you get a
"Syntax error:.*".
Appeared the : 06/03/2000
Apparition version : 3.00.8o
Bug # : 17152A
Status : NO CORRECTION PLANED
Priority : BLOCKING AT USAGE (EMERGENCY OR HIGH PRIORITY)
Product : FOUR J'S UNIVERSAL COMPILER
System : ALL
DbEngine : ALL
Description : DEBUGGER DOES NOT ACCEPT MODULE NAME IN UPPERCASE
Full description : When you use the debugger with a 4gl module "b512052A", the
statements "view b517052A", "break b517052A.",
"variable MODULE.b517052A." generate errors
because the module name is defined with uppercase letters.
It is impossible to correct this bugs because all
variable-names in INFORMIX-4GL are not case sensitive.
Appeared the : 14/03/2000
Apparition version : 3.00.8r
Bug # : 17161
Status : NO CORRECTION PLANED
Priority : BLOCKING USAGE OR DEVELOPMENT (HIGH PRIORITY)
Product : FOUR J'S UNIVERSAL COMPILER
System : ALL
DbEngine : ALL
Description : BREAK WITH IF AND NO SCOPE IS NOT IMPLEMENTED
Full description : When you define a break with a condition and no line,
variable or function to link to this break, you get a
syntax error. Example : break if variable = 10 : This
statement should stop at the fisrt instruction that sets
variable to 10 and each next 4GL instruction until variable
<> 10. The debugger displays "Syntax error: variable".
Appeared the : 04/04/2000
Apparition version : 3.00.8t
Bug # : 17163C
Status : NO CORRECTION PLANED
Priority : NON BLOCKING BUT ANNOYING (LOW PRIORITY)
Product : FOUR J'S UNIVERSAL COMPILER
System : ALL
DbEngine : ALL
Description : "CLEANUP A" DEBUGGER COMMAND IS NOT RECOGNIZED AS "CLEANUP
ALL"
Full description : The statement "cleanup a" is interpreted like "cleanup" and
not "cleanup all" like it should.
Appeared the : 04/04/2000
Apparition version : 3.00.8t
Bug # : 17170
Status : NO CORRECTION PLANED
Priority : BLOCKING BUT WORKAROUND AVAILABLE (NORMAL PRIO.)
Product : FOUR J'S UNIVERSAL COMPILER
System : ALL
DbEngine : ALL
Description : DEBUGGER BREAK/TRACE COMMAND ON A LINE IGNORES SCOPE
FUNCTION
Full description : Defining a break / trace on a line number with scope
function always define the break / trace on the specified
line in the current module. It should define the break /
trace in the module where the function is defined.
Workaround : To define a break on a line of another module (not the
current), use the syntax break module_name.noline
Appeared the : 10/04/2000
Apparition version : 3.00.8v
5.DEBUGGER COMMANDS
===============================================================================
The syntax of the Four J's debugger is similar to the Informix debugger.
A on-line help is provided in the debugger. Execute the "HELP" command
to display this help. You can specify the command name after "HELP" in
order to display a detailed description of that command.
Example :
HELP RUN
To get help on key commands, you must prefix the name of the key with
an underscore. Supported key names are _ESCAPE, _INTERRUPT, _REDRAW,
_SCREEN and _TOGGLE.
Example :
HELP _INTERRUPT
-----------------------------------------------------------------------
Here is the list of all Debugger commands.
Warning : (*) means not supported in this first version of the debugger.
-----------------------------------------------------------------------
_ESCAPE - !command
_INTERRUPT - CONTROL-c
_REDRAW - CONTROL-r
_SCREEN - CONTROL-p
_TOGGLE - CONTROL-t
ALIAS {name = cmd_str | *}
APPLICATION [DEVICE] device-name
BREAK [*] [(function)] ["name"] [-count]
{ [module.]line-no [IF condition] |
variable [IF condition] |
function [IF condition] }
[{commands}]
CALL function ([arg [,...]])
CLEANUP [ALL]
CONTINUE [INTERRUPT | QUIT]
DATABASE database-name
DISABLE {name | refno | function | ALL}
DUMP [GLOBALS | ALL] [>> filename]
ENABLE {name | refno | function | ALL}
EXIT
FUNCTIONS [pattern] [>> filename]
HELP [command]
LET variable = expression
LIST [BREAK] [TRACE]
NOBREAK {name | refno | function | ALL}
NOTRACE {name | refno | function | ALL}
PRINT expression [{ >> filename | (*)PROGRAM = }]
READ filename
RUN [arg [arg ...]]
STEP [n] [INTO] [NOBREAK]
TRACE [*] [(function)] ["name"]
{ [module.]line-no |
variable |
function |
FUNCTIONS }
[{commands}] [>> filename]
USE [[=] directory-name [, ...]]
VARIABLE [variable | GLOBALS | ALL] [>> filename]
VIEW [module | function]
WHERE [>> filename]
WRITE [BREAK] [TRACE] [ALIASES] [>>] [filename]
---------------------------------------------------------------------------
ESCAPE
Overview
Use the exclamation point ( ! ) to send a command line to the operating
system.
Syntax
-------------------------------------------------------------------------
!command
-------------------------------------------------------------------------
Explanation
! is the symbol that invokes the Escape feature.
command is an operating system command.
Notes
1. You can use this feature to invoke an interactive program, such as a
text editor, that requires keyboard input.
2. You must use the exclamation point ( ! ) to invoke this command. The
string ``_ESCAPE'' (with a leading underscore symbol) can be used as an
argument of a HELP command.
3. Your system must have enough RAM to support the command while the
Debugger is running.
4. When the command terminates, you are prompted to return to the
Debugger. Pressing [RETURN] key restores the Command window.
The cursor returns to the window from which you escaped.
Examples
If you enter the following command at the Command window
!csh
you create a new C shell. You can work at this shell, and then return to
the Debugger by entering exit (the system command, not the Debugger
command) and then pressing [RETURN] key.
Related Commands
HELP
---------------------------------------------------------------------------
INTERRUPT
Overview
Press the Interrupt key from the Application screen to make the Command
window your current window. If the 4GL program is running, pressing the
Interrupt key suspends program execution at the current 4GL statement.
Syntax
-------------------------------------------------------------------------
{ CONTROL-C | DEL }
-------------------------------------------------------------------------
Notes
1. The Interrupt key is the key specified by the stty command (often
[CONTROL-C] or [DELETE]).
2. If the Application screen is your current window, pressing the
Interrupt key restores the Debugger screen. The Command window
becomes your current window.
3. If a 4GL statement is executing, pressing the Interrupt key stops
execution immediately after the statement.
4. Like the names of the Escape feature and the Redraw, Screen, and
Toggle commands, INTERRUPT is not a Debugger keyword, but it appears
at the top of this page and among the HELP topics so that you can find
these notes. Prefix the word INTERRUPT with an underscore ( _ ) when
you use it as an option of the HELP command.
5. Pressing the Interrupt key stops execution of an application by
interrupting the Debugger process that interprets the program, rather
than by passing an Interrupt signal to the 4GL program. You must use
the CONTINUE INTERRUPT command, rather than the Interrupt key, if you
want to test how a 4GL application handles an Interrupt signal.
6. Pressing the Interrupt key repeatedly while a 4GL program is running
can produce unpredictable results. When the Application screen is
your current window, for example, consecutive interrupts may result in
an incorrect display of the Command window. If this happens, press
[CONTROL-R] to redraw the screen.
Examples
If the application program is waiting for input, pressing the Interrupt key
suspends program execution after the current 4GL statement, and makes the
Command window your current window.
Related Commands
BREAK, CONTINUE, EXIT, REDRAW
---------------------------------------------------------------------------
REDRAW
Overview
Press [CONTROL-R] to redraw the Command window or the Application screen.
Syntax
-------------------------------------------------------------------------
CONTROL-R
-------------------------------------------------------------------------
Notes
1. On some terminals, sequences of Debugger commands can sometimes
produce an anomalous screen display. For example, repeatedly pressing
the Interrupt key when the Application screen prompts you for input
can produce strange results.
If you think that your Application screen or Command window has been
incorrectly updated, press [CONTROL-R] to redraw the current screen
display.
2. Like the names of the Escape feature, Interrupt, Screen, Search, and
Toggle commands, ``REDRAW'' is not a Debugger keyword, but it appears
at the top of this page and among the HELP topics so that you can find
these notes. You must prefix the name REDRAW with an underscore ( _ )
to use it as an option of the HELP command.
3. If you are using a second terminal to display the output of the
application program, [CONTROL-R] redraws both screens.
Examples
Typing [CONTROL-R] redraws the current screen.
Related Commands
APPLICATION DEVICE, HELP, INTERRUPT, SCREEN
---------------------------------------------------------------------------
SCREEN
Overview
Press [CONTROL-P] to save the current display of the Application screen
in a disk file.
Syntax
-------------------------------------------------------------------------
CONTROL-P
-------------------------------------------------------------------------
Notes
1. Like the names of the Escape, Interrupt, Redraw, Search, and Toggle
commands, ``SCREEN'' is not a Debugger keyword, but it appears here
and among the HELP topics so that you can find these notes. You must
prefix the name SCREEN with an underscore ( _ ) to use it as an option
of the HELP command.
2. This facility enables you to record the screens of the 4GL application
program. Like other Debugger commands to display information, this
can simplify the task of documenting debugging sessions.
3. If your current window is the application, pressing [CONTROL-P]
saves the current screen display in a disk file defined by the
environment variable DBSCREENOUT. If this file already exists, the
Debugger appends the current display to the file.
4. If you have used the APPLICATION DEVICE command to designate a second
terminal for program output, your current window does not matter to
the Screen command. After you press [CONTROL-P], the Debugger updates
the $DBCREENOUT file with the current contents of the Application
screen.
Examples
When you type [CONTROL-P], this saves the application screen display in a
file.
Related Commands
APPLICATION DEVICE
---------------------------------------------------------------------------
TOGGLE
Overview
Press [CONTROL-T] to switch your screen display from the Debugger screen to
the Application screen.
Syntax
-------------------------------------------------------------------------
CONTROL-T
-------------------------------------------------------------------------
Notes
1. If your current window is the Command window, pressing the Toggle key
([CONTROL-T]) displays the Application screen, so that you can see the
screen output of the 4GL application program.
2. You cannot supply input to the 4GL program after a Toggle command
displays the Application screen. Pressing the Toggle key again
restores the Debugger screen, and the previous current window.
Pressing any other key (except [CONTROL-S], [CONTROL-P], [CONTROL-Q],
or [CONTROL-R]) makes the Command window the current window.
3. Like the names of the Escape feature and the Interrupt, Screen,
and Redraw commands, ``TOGGLE'' is not a Debugger keyword, but it
appears here and among the HELP topics so that you can find these
notes. You must prefix the name TOGGLE with an underscore ( _ ) to
use it as an option of the HELP command.
4. If you have used an APPLICATION DEVICE command to display output from
the 4GL application on a different terminal, then pressing [CONTROL-T]
has no effect.
5. Unless you use the Toggle key or an APPLICATION DEVICE command, the
Application screen only appears when the 4GL program produces screen
output or requires keyboard input.
6. If the 4GL program produces no output screen, then pressing
[CONTROL-T] has no effect.
Examples
When you type [CONTROL-T], this displays the Application screen.
Related Commands
APPLICATION DEVICE, INTERRUPT, SCREEN
---------------------------------------------------------------------------
ALIAS
Overview
Use ALIAS to assign a name or function key to a command string.
Syntax
-------------------------------------------------------------------------
ALIAS { * | name = cmd_str | name = { cmd_str [; cmd_str...] } }
-------------------------------------------------------------------------
Explanation
ALIAS is a required keyword.
name is an alias or the name of a function key.
cmd_str specifies the command string.
* lists all of the current aliases.
Notes
1. On some terminals you can use a function key name, such as f1 for [F1],
as an alias. Function key names must be defined in the file that is
specified by the TERMCAP environment variable.
2. The command string that you assign to an alias can be the first part of
a command, or a command, or it can group several commands enclosed by a
single pair of braces ( { } ). Use a semicolon ( ; ) to separate
commands.
3. The name specification cannot be the complete name of another Debugger
command.
4. Entering the alias or pressing the function key sends the command
string to the Debugger. The Command window echoes the alias, and then
displays the expanded command, substituting command strings for the
alias before executing the command.
5. The asterisk ( * ) option displays all your current aliases.
6. If you use the terminal Setup keys to program your function keys, the
Debugger may not recognize your function keys.
7. An alias persists until another ALIAS command reassigns the same name
or function key, or until an EXIT command ends the debugging session.
If you exit to the Programmer's Environment, and then resume debugging
the same 4GL program without returning to the operating system, your
aliases are restored. Otherwise, they are replaced by the initial
default aliases.
Examples
If you have not established any aliases, entering
alias *
displays the default aliases that are defined for the first nine function
keys:
alias f1 = help
alias f2 = step
alias f3 = step into
alias f4 = continue
alias f5 = run
alias f6 = list break trace
alias f7 = list
alias f8 = dump
alias f9 = exit
To establish x as an alias for EXIT, enter
alias x = exit
The next example assigns two commands to function key [F9].
alias f9 = { print add_flag; view }
You can invoke both commands by pressing the [F9] key or by entering f9.
Related Commands
WRITE
---------------------------------------------------------------------------
APPLICATION DEVICE
Overview
Use APPLICATION DEVICE to redirect screen output from the 4GL application
to a second video terminal.
Syntax
-------------------------------------------------------------------------
APPLICATION [DEVICE] device-name
-------------------------------------------------------------------------
Explanation
APPLICATION is a required keyword.
DEVICE is an optional keyword.
device-name is a required name, specifying the terminal device to
display the application screen.
Notes
1. This command enables you to monitor the Application screen
continuously, rather than only when your screen is not displaying
the Debugger screen.
This command can be useful if are working on a multiuser system, and
have access to two terminals that can support identical TERMCAP
entries. The terminal specified in this command uses the TERMCAP
entry of the terminal that invoked the Debugger.
2. When the application program requires input, only the keyboard of the
terminal that invoked the Debugger can enter input. Since the second
terminal is only used for output, its keyboard is not enabled until you
invoke the EXIT command from the terminal that is running the Debugger.
3. The device-name must include the complete terminal pathname of the
device.
4. Both terminals must be logged in under the same account name.
5. Do not choose the terminal that is running the Debugger as your
application device.
-------------------------------------------------------------------------
Caution! If you invoke the APPLICATION DEVICE command, you must specify
another terminal. Otherwise you will have difficulty reading screen
output, and your keyboard may lock up.
-------------------------------------------------------------------------
6. The Toggle key have no effect after an APPLICATION DEVICE command.
The Interrupt key switches keyboard input to the Command window, if
the 4GL program is requesting input.
7. You can display the terminal pathname of any logged-in terminal by
using its keyboard to enter the command tty.
Examples
The following command selects a terminal designated as /dev/tty05 to be the
device to display screen output from the 4GL application program being
debugged:
app dev /dev/tty05
Related Commands
EXIT, INTERRUPT, LIST, WRITE
---------------------------------------------------------------------------
BREAK
Overview
Use BREAK to set a breakpoint to suspend program execution.
Syntax
-------------------------------------------------------------------------
BREAK [*] [(function)] ["name"] [-count]
{ [[module.]line-no [ IF condition ] | variable [ IF condition ] |
function [ IF condition ] ] }
[{ commands }]
-------------------------------------------------------------------------
BREAK [*] [(function)] ["name"] [-count]
{ [module.]line-no [IF condition] |
variable [IF condition] |
function [IF condition] }
[{commands}]
Explanation
BREAK is a required keyword.
* is a symbol to disable the new breakpoint.
(function) is an optional function name, in parentheses.
name is the name that you give the breakpoint.
-count is a negative-signed integer. Execution stops when the
breakpoint is reached count times.
module is the module containing the breakpoint.
line-no is the line number within the module.
variable is the name of a variable that causes a break whenever its
value changes.
function is the name of a function that causes a break when the
function is executed.
IF is an optional keyword specifying a condition.
condition is an expression that causes a break in program execution
when the expression is TRUE.
{commands} is a list of commands within braces to be executed when the
breakpoint is reached.
Notes
1. A breakpoint stops execution immediately prior to executing the 4GL
statement specified by the BREAK command.
2. If you specify a (function), the function that you name overrides the
current function in determining the scope of reference of any variable
in a variable or IF condition specification.
3. The name option allows you to assign an optional name to a breakpoint.
The name must start with a letter, and it must appear in the command
line within single or double quotes.
4. If you specify a count, a minus symbol ( - ) must prefix it. After
program execution reaches an enabled breakpoint count times, execution
stops whenever that breakpoint is reached. That is, the Debugger does
not wait another count times before stopping again, but stops every
time thereafter. The default value of count is one.
5. After a breakpoint stops execution, you can use CONTINUE or STEP to
resume execution without resetting the count.
6. If you invoke a RUN command after a breakpoint stops execution, the
Debugger resets the count at your starting value, and restarts
execution.
7. If the module name is omitted, then line-no refers to the current
module.
8. If the line-no is not an executable statement, the Debugger places the
breakpoint at the start of the next executable 4GL statement, or at
the last statement in the function (whichever is first). Variable
definition statements, blank lines, and comments are not executable
statements.
9. If the module contains no executable statements, an error message
appears.
10. If the line-no is not the first line of a 4GL statement,
the breakpoint stops execution at the first line of the statement.
11. A condition cannot contain function calls.
12. If you specify both a count and an IF condition, count is reduced only
if the condition is TRUE.
13. When you specify a function, execution stops whenever the function is
entered.
14. If you specify both a count and a function, the breakpoint is reached
count times before execution stops at the function entry point.
15. You can specify the line-no of a 4GL statement that calls a C function
or 4GL library function, but you cannot specify a function that is not
a programmer-defined 4GL function.
16. You cannot abbreviate the keyword IF.
17. You can qualify variable names.
18. There is no restriction on the number of breakpoints that you can set
at any time.
19. If many breakpoints are simultaneously active, you may wish to include
distinctive PRINT messages as commands options, to identify which
breakpoint stops execution.
20. The scope of reference of any variables in the commands list is
determined by their qualifiers and by the function that is current
when the breakpoint takes effect.
The Debugger disregards whatever function was current when you issued
a BREAK command, and ignores the (function) option, in identifying the
scope of any variables in commands.
21. If several BREAK IF commands reference variables, the Debugger
suspends execution if any of the variables changes when one of the
breakpoint conditions is true. You may need to specify DISABLE
commands in the commands list to avoid unplanned breaks in this
situation.
22. The Debugger assigns to each breakpoint a unique reference number.
When you establish a new breakpoint, the Command window displays its
reference number and other specifications. These can include the
name, line number, function, module, IF conditions, commands to
execute, and scope, depending on the arguments of your BREAK command.
23. Setting a breakpoint with the BREAK command also enables the
breakpoint, unless you include the asterisk ( * ) symbol.
You can use the asterisk ( * ) option to create a breakpoint without
enabling it. The breakpoint is specified but disabled, as if you had
set it and then used a DISABLE command to deactivate it.
Examples
If you enter
break 10
you set an unnamed breakpoint at the tenth line of the current module. The
Command window displays its reference number, the word break, and its
function, line number, module, and scope of reference.
The command
break main.100
sets a breakpoint at line 100 in module main.
If you enter the command
break x
the Debugger first searches for a function named x. If x is a function
in the current program, this breakpoint suspends program execution after
a statement that calls x.
If no function named x is found, the Debugger searches for a variable
called x. If variable x is found, the Command window displays the
reference number of the new breakpoint, the word ``break,'' and the name of
the variable. The next line displays its scope of reference. Program
execution stops whenever the value of x changes.
If both a function and a variable have the name x, you must prefix the
variable with appropriate qualifiers in a BREAK command. If neither a
function nor a variable called x is found, the Command window displays the
error message
-16351: Variable [x] could not be located.
The command
break x[i]
immediately evaluates array member x[i] and returns an error if i does not
have a value. The command
break if x[i]
treats i as a variable, and evaluates x[i] whenever the value of i changes
during program execution.
The command
break global.flag
stops execution whenever the value of the global variable flag changes.
The command
break "x" -2 20 if global.flag = 3 { print "Flag=3" }
sets a breakpoint named x at line 20 in the current module. The breakpoint
causes execution to stop if the breakpoint is reached twice and the global
variable flag equals 3 each time. When execution stops, the PRINT command
is executed.
Related Commands
DISABLE, ENABLE, LIST, NOBREAK, STEP, WRITE
---------------------------------------------------------------------------
CALL
Overview
Use CALL to execute a function and display returned values.
Syntax
-------------------------------------------------------------------------
CALL function ([arg [,...]])
-------------------------------------------------------------------------
Explanation
CALL is a required keyword.
function is the name of the function to execute.
arg is an argument of the function.
Notes
1. The function can be a programmer-defined 4GL function, or a 4GL library
function, or a C function, or an -INFORMIX-ESQL/C- function.
2. The function name must be followed by left and right parentheses. Use
a comma ( , ) to separate arguments.
3. The Application screen displays any output. Returned values appear in
the Command window.
4. The function can contain breakpoints and tracepoints.
5. The function does not need to be part of a completed 4GL program with a
main program block.
6. You can CALL a function before a RUN command has started program
execution. If a function includes SQL statements referencing a
database that is not the current database, you must specify a database
before you can CALL that function.
7. You can specify a database by a DATABASE command, or by a RUN command
to start the current program, if the program includes an appropriate
DATABASE statement.
8. It may be necessary to use the CLEANUP command to reinitialize
variables and to close forms and windows before you reexecute a
function by repeating a CALL command.
9. Any 4GL program variables that you specify as arguments of a CALL
command must be active.
Examples
The following command executes the main section:
call main()
The next command executes a function called find_cust with arguments of 50
and 0:
call find_cust(50,0)
You can use CALL to execute a built-in 4GL function. For example, the
command
call err_get(-408)
displays 4GL error message -408 in the Command window.
Related Commands
CLEANUP, DATABASE, FUNCTIONS, RUN, STEP, TRACE, VARIABLE, WHERE
---------------------------------------------------------------------------
CLEANUP
Overview
Use CLEANUP to initialize all variables, to close all open windows and
forms, and optionally to close the current database.
Syntax
-------------------------------------------------------------------------
CLEANUP [ALL]
-------------------------------------------------------------------------
Explanation
CLEANUP is a required keyword.
ALL is an optional keyword, specifying that the current
database should be closed.
Notes
1. The CLEANUP command is helpful when the function that you are executing
with a CALL command has not reached a normal termination, but you wish
to CALL it again. In some debugging situations, this command is
necessary before you can use a CALL command to restart a function that
terminated abnormally.
2. If you enter the CLEANUP keyword with no option, the Debugger
reinitializes all program variables, and closes all windows and forms.
The database remains open.
3. If you include the ALL option after the CLEANUP keyword, the Debugger
reinitializes all the program variables, closes all windows and forms
of the 4GL program, and closes the database.
The Debugger automatically closes the current database if the 4GL
program stops because of a fatal error.
4. It is unnecessary to invoke a CLEANUP command before a RUN command.
Invoking a RUN command automatically reinitializes all program variables
and closes all forms and windows before execution starts.
5. You cannot use a CONTINUE or STEP command after a CLEANUP command until
a RUN or CALL command resumes program execution.
Examples
In the sequence of commands that follows, the CLEANUP command closes all
windows and forms, and reinitializes all program variables, but leaves the
current database open:
call home(30,3)
...
cleanup
...
call home(30,3)
Without the CLEANUP command, open windows or forms, or variables with
unexpected values might interfere with the second attempt to call the
function.
The command
cleanup all
closes any open windows or forms, reinitializes all program variables, and
closes the current database.
Related Commands
CALL, DATABASE, EXIT, LET, RUN
---------------------------------------------------------------------------
CONTINUE
Overview
Use CONTINUE to resume execution of a program, or to send an Interrupt or
Quit signal to a currently running 4GL program.
Syntax
-------------------------------------------------------------------------
CONTINUE [INTERRUPT | QUIT]
-------------------------------------------------------------------------
Explanation
CONTINUE is a required keyword.
INTERRUPT is an optional keyword that passes an Interrupt signal to
the 4GL program.
QUIT is an optional keyword that passes a Quit signal to the 4GL
program.
Notes
1. CONTINUE without any options resumes execution at the first 4GL
statement after an interrupt or breakpoint.
2. An error message appears if execution has not begun, or has terminated,
or if CLEANUP followed the last RUN or CALL command.
3. The Debugger traps all interrupts. The INTERRUPT and QUIT options send
an Interrupt or Quit signal to your 4GL application, to test its signal
handling code.
4. Refer to the UNIX stty command for information about setting interrupt
characters. On some systems the default is [CONTROL-C], but others use
[DELETE] or [BREAK].
5. [CONTROL-] \ is the default quit key on many UNIX systems. On systems
that cannot generate a Quit signal, the QUIT option has no effect.
6. Whether or not the INTERRUPT or QUIT option interrupts or terminates
execution depends on how the specific 4GL program handles these
signals.
7. If the INTERRUPT or QUIT option terminates program execution, the
Command window displays the name of the module, function, and line
number of the current 4GL statement when execution stopped. Neither
STEP nor CONTINUE can resume execution, but DUMP, PRINT, and WHERE can
examine active variables and functions.
Examples
If program execution is suspended, the following command resumes execution
of the current 4GL program or function:
continue
The next sends an Interrupt signal to the 4GL application:
continue int
The next command sends a Quit signal:
continue quit
Whether this stops execution of the application depends on whether a DEFER
QUIT statement in the 4GL code prevents the signal from passing through to
the operating system.
Related Commands
BREAK, CALL, CLEANUP, INTERRUPT, STEP, RUN
---------------------------------------------------------------------------
DATABASE
Overview
Use DATABASE to specify the current database.
Syntax
-------------------------------------------------------------------------
DATABASE database-name
-------------------------------------------------------------------------
Explanation
DATABASE is a required keyword.
database-name is the name of an existing database.
Notes
1. If no database has been specified, a DATABASE command selects one. If
you have a different current database, a DATABASE command closes it,
and replaces it with database-name.
2. Invoking the RUN command reopens the database specified in your
program. To use a different database, you must set a breakpoint at
the first line in the main program block, and then invoke a DATABASE
command to select a new database when that breakpoint is encountered.
You can use CONTINUE to resume program execution.
Examples
The following command selects the stores database:
database stores
The following sequence of commands sets a breakpoint at the beginning of
main, begins running the program, selects a new database called stereos,
and resumes program execution using the new database.
break main
run 9 5
database stereos
continue
This example does not show an actual Command window display, which would
also show output from several of these commands.
Related Commands
CALL, CLEANUP, RUN
---------------------------------------------------------------------------
DISABLE
Overview
Use DISABLE to turn off a breakpoint or tracepoint.
Syntax
-------------------------------------------------------------------------
DISABLE { name | refno | function | ALL }
-------------------------------------------------------------------------
Explanation
name is the name that you assigned to a breakpoint or tracepoint.
refno is the reference number assigned to each breakpoint or
tracepoint.
function is a name of a function.
ALL is a keyword.
Notes
1. The ALL option disables all breakpoints and tracepoints in the current
4GL program.
2. The function option disables all breakpoints and tracepoints within the
function.
3. If a breakpoint or tracepoint is enabled and has the same name as a
function, only the breakpoint or tracepoint called name is disabled.
If that breakpoint or tracepoint is already disabled, all breakpoints
and tracepoints within the function are disabled.
4. You have the option of enclosing the name of a breakpoint or tracepoint
in single or double quotes.
5. DISABLE does not remove breakpoints or tracepoints. You can reactivate
a disabled breakpoint or tracepoint at a later time, by invoking the
ENABLE command.
6. If a breakpoint or tracepoint named all is enabled, the DISABLE ALL
command disables the breakpoint or tracepoint, rather than disabling
all of them.
Examples
The command
disable "kn"
disables the breakpoint or tracepoint whose name is kn. An error message
appears if kn cannot be located, or if it is not active.
The command
disable x
disables a breakpoint or tracepoint with name x, or all breakpoints and
tracepoints within the function x, while
disable 1
disables the breakpoint or tracepoint with a refno of 1.
The command
disable add_cust
deactivates all of the breakpoints in the function add_cust.
Related Commands
BREAK, ENABLE, LIST, NOBREAK, NOTRACE, TRACE, WRITE
---------------------------------------------------------------------------
DUMP
Overview
Use DUMP to write the names and values of variables in the current function
to the Command window or to an ASCII file.
Syntax
-------------------------------------------------------------------------
DUMP [GLOBALS | ALL] [>> filename]
-------------------------------------------------------------------------
Explanation
DUMP is a required keyword.
GLOBALS is an optional keyword, for global variables.
ALL is an optional keyword, for both local and global variables.
>> are symbols to send output to the disk.
filename is the name of an output file.
Notes
1. The most recently executed function is the current function.
2. If you do not specify GLOBALS or ALL, only the variables in the current
function are evaluated.
3. If you specify GLOBALS, only global variables are evaluated.
4. If you specify ALL, all global variables and all variables in the
current function are evaluated.
5. If a file called filename already exists, the Debugger appends the
names and values to the file. Otherwise, the Debugger creates the
file. You can specify a pathname if you want the file saved outside
your current directory.
6. An error message appears if you enter a DUMP command when no 4GL
function is active. You cannot use DUMP to evaluate variables that
exist only in C or -INFORMIX-ESQL/C- functions.
7. After a fatal error or some other action causes the 4GL program to
terminate abnormally, DUMP can evaluate global variables, and variables
from the function in which execution stopped.
Examples
The command
dump
displays in the Command window the names and values of all the variables in
the current function.
The following command saves in a file called fnstatus the names and values
of all global variables and of all the variables in the current function:
dump all >> fnstatus
Related Commands
LET, TRACE, VARIABLE
---------------------------------------------------------------------------
ENABLE
Overview
Use ENABLE to activate a breakpoint or tracepoint.
Syntax
-------------------------------------------------------------------------
ENABLE { name | refno | function | ALL }
-------------------------------------------------------------------------
Explanation
name is the name that you assigned to a breakpoint or tracepoint.
refno is the reference number assigned to each breakpoint or
tracepoint.
function is a name of a function.
ALL is a keyword.
Notes
1. The ALL option enables all breakpoints and tracepoints in the program.
2. The function option enables all breakpoints and tracepoints within the
function.
3. If a disabled breakpoint or tracepoint name is the same as a function
name, only the breakpoint or tracepoint name is enabled. If that
breakpoint or tracepoint is already enabled, all breakpoints and
tracepoints within the function are enabled.
4. The name can be enclosed in single quotes or double quotes.
5. If a breakpoint or tracepoint called all exists, the ENABLE ALL command
enables it, rather than enabling all breakpoints and tracepoints.
Examples
The command
enable x
enables the breakpoint or tracepoint called x, or enables all breakpoints
and tracepoints within the function called x, if the current program calls
a function of that name.
The command
enable 1
enables the breakpoint or tracepoint with a refno of 1.
The command
enable all
activates any disabled breakpoints or tracepoints in the program, or one
called all, if a disabled breakpoint or tracepoint called all exists.
The command
enable "me"
activates a breakpoint or tracepoint called me.
Related Commands
BREAK, DISABLE, LIST, NOBREAK, NOTRACE, TRACE, WRITE
---------------------------------------------------------------------------
EXIT
Overview
Use EXIT to terminate a debugging session.
Syntax
-------------------------------------------------------------------------
EXIT
-------------------------------------------------------------------------
Explanation
EXIT is a required keyword.
Notes
1. If you invoked the Debugger directly from the system prompt, EXIT
returns you to that prompt. If you invoked the Debugger from the
Programmer's Environment, enter EXIT and press [RETURN] to return to a
menu.
2. If you are at the Application screen with a 4GL program waiting for
input or producing output, you must first press the Interrupt key
before you can EXIT.
Examples
This command terminates the Debugger:
exit
Related Commands
INTERRUPT
---------------------------------------------------------------------------
FUNCTIONS
Overview
Use FUNCTIONS to list in the Command window the names of programmer-defined
4GL functions in the current application.
Syntax
-------------------------------------------------------------------------
FUNCTIONS [pattern] [>> filename]
-------------------------------------------------------------------------
Explanation
FUNCTIONS is a required keyword.
pattern is an optional search pattern specification, expressed
as a string of one or more characters.
>> symbols used to rerirect output to a disk
filename is an optional output file.
Notes
1. If no search pattern specification follows the FUNCTIONS keyword, then
the names of all functions in the current 4GL application program are
displayed in the Command window.
2. The search pattern specifications can include a function name or any
combination of characters, blanks, and the following special
characters:
? Match any single non-blank character
* Match zero or more non-blank characters
[d-q] Match any character between d and q (inclusive) in the ASCII
collating sequence
If you specify a search pattern, FUNCTIONS displays every function name
that matches the pattern.
3. FUNCTIONS does not list the names of -INFORMIX-ESQL/C- or C functions.
4. If no function name matches a pattern, the Command window returns only
the $ prompt. No additional message appears.
Examples
The command
functions
returns the name of every programmer-defined function in the current 4GL
program. The next command
functions add_cust
searches the source file for a function called add_cust. If the function
is found, its name is displayed in the Command window. The next command
functions add*
specifies a ``wildcard'' pattern that matches the function in the previous
example, as well as any other function whose name starts with add.
The following command lists the names of all the functions whose names
contain the pattern ust, followed by any lowercase letter that comes after
m and before x:
functions *ust[n-w]*
Related Commands
CALL, TRACE, VIEW, WHERE
---------------------------------------------------------------------------
HELP
Overview
Use HELP for instructions on using Debugger commands.
Syntax
-------------------------------------------------------------------------
HELP [command]
-------------------------------------------------------------------------
Explanation
HELP is a required keyword.
command is a Debugger command.
Notes
1. If the command that follows the keyword HELP is the full or abbreviated
name of a Debugger command, then the information about how to use that
command is display in the Command window.
2. If no command argument is specified, then a brief synopsis of every
Debugger commands appears in the Command window. The same synopsis
appears if you enter a string after the HELP keyword that begins with
an alphabetic character, but that does not correspond to a keyword.
For example, your argument can be k, which matches no command.
3. Besides the Debugger command keywords, the HELP command recognizes the
options _ESCAPE, _INTERRUPT, _SCREEN, _REDRAW, and _TOGGLE,
representing Debugger commands that are controlled by special non-
alphabetic characters. Each of these options is prefixed by an
underscore ( _ ) symbol.
4. If your argument after the HELP keyword begins with any other
non-alphabetic character, an error message and the synopsis of every
Debugger commands are displayed.
Examples
The command
help trace
displays a message about the TRACE command, based on the description of
TRACE from the manual. Enter the command
h
to see a synopsis of every Debugger command syntax.
Related Commands
ESCAPE, INTERRUPT
---------------------------------------------------------------------------
LET
Overview
Use LET to assign an expression to a variable.
Syntax
-------------------------------------------------------------------------
LET variable = expression
-------------------------------------------------------------------------
Explanation
LET is a required keyword.
variable is the name of a program variable.
expression is an expression, separated from the variable by an equal (
= ) sign.
Notes
1. If a 4GL program assigns to a variable a value that is different from
what you intended, you can use the LET command to substitute the
intended value. This allows you to continue examining a program
without terminating a debugging session to modify and recompile the
source code after you find the first flaw in program logic.
2. Since a LET command has no effect on the source code, you must
subsequently correct the source code if it assigns an improper value to
a program variable.
3. The value that a LET statement assigns to a variable should be
consistent with its data type declaration. If the two are different,
the Debugger attempts to convert the value. This may result in
truncation. An error message appears if the conversion fails.
4. The syntax of a LET command closely resembles the syntax of a 4GL LET
statement. You must enclose character expressions in quotation marks.
5. An expression can contain a substring of a character array.
6. An expression cannot include function calls, or variables from multiple
functions, or variables from functions that are not active. You cannot
use LET to reference variables unless program execution is suspended,
or has terminated abnormally, after a RUN or CALL command.
7. You can qualify the variable.
8. If you follow a LET command with a RUN command, the RUN command will
reinitialize all the program variables, restoring their original
values.
To avoid having your work undone in this way, set a breakpoint before a
4GL statement that uses a variable whose value is incorrect. After the
breakpoint stops program execution, use a LET command to assign a new
value, and invoke CONTINUE to resume execution with the corrected
value.
Examples
The following command assigns the character y to the variable answer:
let answer = "y"
The following command
let global.rfrsh_flg = function.main.x/23
divides by 23 the variable called x that was defined in the main program
block, and assigns the resulting value to the global variable rfrsh_flg.
If the data type of global.rfrsh_flg is INTEGER, the decimal portion of the
value is discarded.
If x is of type CHARACTER, the command
let x[101,101] = y
replaces the current value of the 101st character of x with the value of
4GL program variable y.
Related Commands
DUMP, PRINT, RUN, TRACE, VARIABLE
---------------------------------------------------------------------------
LIST
Overview
Use LIST to display the current breakpoints and tracepoints.
Syntax
-------------------------------------------------------------------------
LIST [BREAK] [TRACE]
-------------------------------------------------------------------------
Explanation
LIST is a required keyword.
BREAK is a keyword for listing current breakpoints.
TRACE is a keyword for listing current tracepoints.
Notes
1. If you specify BREAK, the Command window displays the reference numbers
and other specifications of the currently enabled and disabled
breakpoints.
2. If you specify TRACE, the Command window displays the reference numbers
and other specifications of the currently enabled and disabled
tracepoints.
3. If you do not specify any option, the Command window displays all of
the information described in the first two notes.
4. Besides LIST, other commands that can display information about your
current debugging session are ALIAS, DUMP, FUNCTIONS, PRINT, USE,
VARIABLE, and WHERE.
Examples
The command
list
displays in the Command window all of the current breakpoints and
tracepoints.
The following LIST command displays all the breakpoints in the current 4GL
program:
list break
The following command
list trace
lists the current tracepoints.
Related Commands
APPLICATION DEVICE, BREAK, READ, TRACE
---------------------------------------------------------------------------
NOBREAK
Overview
Use NOBREAK to remove a breakpoint.
Syntax
-------------------------------------------------------------------------
NOBREAK { name | refno | function | ALL }
-------------------------------------------------------------------------
Explanation
NOBREAK is a keyword.
name is the name that you assigned to a breakpoint.
refno is the reference number assigned to each breakpoint.
function is a name of a function.
ALL is an optional keyword that designates all breakpoints.
Notes
1. Use NOBREAK to delete a breakpoint. To deactivate a breakpoint that
you may later want to reactivate, you should use the DISABLE command,
rather than NOBREAK.
2. The LIST BREAK command displays the current reference numbers and that
names can be used for the refno or name options of a NOBREAK command.
3. The ALL option removes all breakpoints in the program. If a breakpoint
called all exists, the Debugger removes only that breakpoint, rather
than all of them.
4. If you specify a function, the Debugger removes all breakpoints within
the function. If a breakpoint and a function have the same name, only
the breakpoint called name is removed. In that case, all breakpoints
within the function remain.
5. As an option, you can place name within a pair of single or double
quotes.
Examples
The command
nobreak fnbr
removes a breakpoint called fnbr, if a breakpoint of that name exists.
Otherwise it removes all of the breakpoints in a function called fnbr.
An unambiguous command to remove a breakpoint called fnbr is as follows:
nobreak "fnbr"
The command
nobreak 4
removes the breakpoint whose reference number is 4.
Related Commands
BREAK, DISABLE, ENABLE, LIST, STEP, WRITE
---------------------------------------------------------------------------
NOTRACE
Overview
Use NOTRACE to remove a tracepoint.
Syntax
-------------------------------------------------------------------------
NOTRACE { name | refno | function | ALL }
-------------------------------------------------------------------------
Explanation
NOTRACE is a keyword.
name is the name that you assigned to a tracepoint.
refno is the reference number assigned to each tracepoint.
function is a name of a function.
ALL is an optional keyword that designates all tracepoints.
Notes
1. Use NOTRACE to delete a tracepoint. To deactivate a tracepoint that
you may later want to reactivate, you should use the DISABLE command,
rather than NOTRACE.
2. The LIST TRACE command displays the current reference numbers and any
names that can be used for the refno or name options of a NOTRACE
command.
3. The ALL option removes all tracepoints in the program. If a tracepoint
called all exists, the Debugger removes only that tracepoint, rather
than all of them.
4. If you specify a function, the Debugger removes all tracepoints within
the function. If a tracepoint and a function have the same name, only
the tracepoint called name is removed. In that case, all tracepoints
within the function remain.
5. As an option, you can place name within a pair of single or double
quotes.
Examples
The command
notrace fntr
removes a tracepoint called fntr if a tracepoint of that name exists.
Otherwise it removes all of the tracepoints in a function called fntr. An
unambiguous command to remove a tracepoint called fntr is as follows:
notrace "fntr"
The command
notrace 5
removes the tracepoint whose reference number is 5.
The next command
notrace all
removes all tracepoints from the current program, if no tracepoint with the
name all exists.
Related Commands
DISABLE, ENABLE, LIST, TRACE, WRITE
---------------------------------------------------------------------------
PRINT
Overview
Use PRINT to display the value of an expression or save it in a file.
Syntax
-------------------------------------------------------------------------
PRINT expression [{ >> filename | PROGRAM = }]
-------------------------------------------------------------------------
Explanation
PRINT is a required keyword.
expression is the expression that you want to evaluate.
>> are symbols to send output to the disk.
filename is the name of an optional output file.
PROGRAM is a keyword used to indicate how to print a BLOB variable.
= required with the above program option.
prog_name name of program to use for printing a BLOB variable.
Notes
1. An expression can be the name of a variable, a record, or an array.
It can be a quoted string or an arithmetic expression.
2. The expression cannot contain a function call. It cannot include
non-global variables from multiple functions, or from a function that
is not active.
3. The expression cannot reference any program variable unless a CALL or
RUN command has started program execution.
4. You can qualify variable names in an expression. If a non-global
variable is defined in another active function that is not the current
function, you must qualify the variable if you reference it in a PRINT
expression.
5. You can use PRINT to display the current values of an entire record or
array by specifying only its name as the expression.
6. An expression can specify substrings of a character array.
7. If you do not specify a filename, the returned values are displayed in
the Command window.
8. The filename can include a pathname, if you want the values saved in a
disk file outside the current directory.
9. If you redirect output to a file that already exists, the Debugger
appends the output to filename. Otherwise, the file is created.
10. You can use PRINT like a calculator during debugging sessions, to
perform arithmetic operations.
11. The program option can be used only when printing BLOB variables.
The debugger first copies the BLOB to a temporary file and then
calls "prog_name" with the temporary file name as an argument.
Examples
The command
print x
displays the value of variable x. This can be a simple variable, or a
record, or an array.
The command
print 365/7
divides 365 by 7, and displays the result in the Command window.
The command
print sqlca
displays an entire SQLCA record on the screen.
The next command
print global.sqlca.sqlcode >> glbstatus
copies to the disk file called glbstatus the current value of sqlcode.
If wrtschz is the name of a variable of type CHARACTER, the command
print wrtschz[1,20]
displays a substring that includes the first 20 characters of the current
value of wrtschz.
The command
print program = "vi"
copies the contents of the BLOB to a temporary file and then calls
vi with the temporary file name as an argument. You can then use
vi commands to view the entire BLOB value.
Related Commands
CALL, DUMP, LET, RUN, TRACE, VARIABLE
---------------------------------------------------------------------------
READ
Overview
Use READ to execute Debugger commands from a file.
Syntax
-------------------------------------------------------------------------
READ filename[.4db]
-------------------------------------------------------------------------
Explanation
READ is a required keyword.
filename is the name of a .4db command file.
Notes
1. The READ command enables you to execute Debugger commands that are
specified in an ASCII file. These commands are executed, and their
output is displayed in the Command window.
2. If you use a WRITE command to save features of a debugging session in
filename, you can use a subsequent READ command to reestablish those
features.
You can also create filename.4db with an editor, or you can use an
editor to modify a .4db file that you created with WRITE, and then use
READ to execute its commands.
3. The required extension of filename is .4db. You do not need to include
the extension when you specify the filename in a READ command.
4. If you want to read a .4db file that is outside your current directory,
you can prefix filename with a pathname.
5. You can include READ commands in the .4db file of a READ command.
Error messages will appear, however, if you establish more than 10
levels of nested READ commands, or if you attempt to READ a file that
is still being processed by another READ command.
6. You cannot use READ to execute the following commands or control
characters, which are not based on keywords:
Command Function
Escape feature ( ! )Operating system commands
Interrupt Switches control to Command window
CONTROL-P Saves screen display as a file
CONTROL-Q Enables terminal I/O
CONTROL-R Redraws screen display
CONTROL-S Suspends terminal I/O
CONTROL-T Toggles Application screen
Examples
The command
read stdtest
reads and executes the Debugger commands contained in file stdtest.4db.
Related Commands
WRITE
---------------------------------------------------------------------------
RUN
Overview
Use RUN to start or restart execution of a 4GL program during a debugging
session.
Syntax
-------------------------------------------------------------------------
RUN [arg [arg ...]]
-------------------------------------------------------------------------
Explanation
RUN is a required keyword.
arg is an argument to the program.
Notes
1. If multiple arguments are used, separate each one with spaces.
2. If you execute RUN more than once within the same debugging session,
the same arguments are reused. You can change the arguments by
specifying new ones when you execute RUN.
3. If you use RUN to restart a program that contains an enabled breakpoint
with a count specification, RUN reinitializes count to the starting
value. (Use CONTINUE or STEP if you want to maintain the current
values.)
4. Before a RUN command restarts a 4GL program, it first performs the
functions of a CLEANUP command. The Debugger closes the database and
any open windows or forms, and initializes all program variables with
zero or null values.
5. You cannot include RUN in the commands list of a tracepoint.
Examples
The command
run 1000 1
initializes all of the 4GL variables, closes any open forms or windows, and
resets the counts of all breakpoints at their starting values. Then it
starts (or restarts) the current 4GL application with two arguments.
Related Commands
BREAK, CALL, CONTINUE, INTERRUPT, STEP
---------------------------------------------------------------------------
STEP
Overview
Use STEP to execute one or more individual 4GL statements.
Syntax
-------------------------------------------------------------------------
STEP [n] [INTO] [NOBREAK]
-------------------------------------------------------------------------
Explanation
STEP is a required keyword.
n is the number of steps to execute.
INTO is an optional keyword, to continue execution of the steps
into a function.
NOBREAK is an optional keyword, to continue execution of the steps
regardless of breakpoints.
Notes
1. Each step is a single executable 4GL statement. Variable definition
statements, blank lines, and comments are not executable statements.
2. The default value of n is one. If n is not specified, only the next
statement is executed.
3. A function call is treated as a single statement, unless you specify
the INTO option.
If you specify INTO, each executable statement in a function is a step.
You cannot STEP INTO a C function, or a 4GL library function.
4. Execution stops if a step reaches a statement that contains an enabled
breakpoint, unless you specify the NOBREAK option. If neither the INTO
nor NOBREAK option is specified, execution stops if a step reaches a
function that contains an enabled breakpoint.
5. If you specify NOBREAK, breakpoints have no effect while the STEP
command is executing. This does not remove breakpoints, but it causes
the Debugger to ignore breakpoints during the current STEP command.
6. Before you can invoke STEP, you must first begin execution with CALL or
RUN, and then suspend execution with a breakpoint or with an Interrupt
command. STEP elicits an error message after execution terminates, or
after a CLEANUP command.
Examples
The following command executes the next line as one statement, even if it
includes a function call:
step
The following command executes the next 12 statements, not counting the
statements inside functions as steps. Execution stops at enabled
breakpoints or at the call of a function that contains an enabled
breakpoint.
step 12
The following command executes the next 10 4GL statements. If a function
call is encountered, executable statements within the function are counted
as individual steps. If an enabled breakpoint is encountered before the 10
statements are executed, the program stops at the breakpoint.
step 10 into
The following command executes the next five statements, counting
statements inside functions as steps. Execution does not stop at
breakpoints.
step 5 into nobreak
Including or not including the INTO or NOBREAK options can produce very
different results when you STEP through a 4GL program that calls a function
containing a breakpoint. Suppose that you have the following 4GL source
code. An enabled breakpoint has been set at line 8, and program execution
is currently suspended at line 2.
1 MAIN
2 CALL a()
3 END MAIN
4
5 FUNCTION a()
6 DEFINE i INTEGER
7 LET i = 7
8 DISPLAY i
9 DISPLAY "DONE"
10 END FUNCTION
In this example, the following STEP commands respectively stop executing at
the line listed at the right:
STEP Command Stops at Line
STEP 8
STEP INTO 7
STEP NOBREAK 3
STEP INTO NOBREAK 7
STEP 3 8
STEP 3 INTO 8
STEP 3 INTO NOBREAK 9
Related Commands
BREAK, CALL, CONTINUE, ENABLE, DISABLE, FUNCTIONS, NOBREAK, RUN, TRACE
---------------------------------------------------------------------------
TRACE
Overview
Use TRACE to show when a statement or function executes, or when the value
of a program variable changes.
Syntax
-------------------------------------------------------------------------
TRACE [*] [(function)] ["name"]
{ [module.]line-no | variable | function | FUNCTIONS }
[{ commands }] [>> filename ]
-------------------------------------------------------------------------
Explanation
TRACE is a required keyword.
* is an optional symbol to disable the tracepoint.
(function) is an optional function name, in parentheses.
name is an optional identifier of the tracepoint.
module is the name of the module containing the line that you want
to trace.
line-no is the number of a line (within module) that will be
displayed when the line executes.
variable is the name of a variable that will be displayed when its
value changes.
function is the name of a function to display when its execution
begins and when it returns.
FUNCTIONS is a keyword that specifies tracing execution of all
functions.
{ commands } is a list of Debugger commands in braces ({ }) that will be
executed when the tracepoint is encountered.
filename is the name of an output file to receive the tracepoint
display.
Notes
1. The Debugger assigns a unique reference number to each tracepoint.
When the Debugger executes a TRACE command, the Command window displays
the reference number and other specifications of the new tracepoint.
These can include its name, line number, function, module, output file,
commands to execute, and scope.
2. If you include a (function) specification, the function that you name
overrides the current function in determining the scope of a variable
on which you set a tracepoint.
3. If you specify a name, you must enclose the name in either single or
double quote marks. The name of a tracepoint must not duplicate the
name of another breakpoint or tracepoint. It must start with a
letter, but the subsequent characters can be letters, numbers, or
underscore ( _ ) symbols.
4. If module name is omitted, then line-no refers to the current module.
5. If the line-no is not an executable statement, the tracepoint is set
at the next executable statement following the line-no.
6. When you set a tracepoint on a variable, the variable name and its
contents are displayed each time that the value of the variable
changes.
7. If you specify commands while tracing a function, the commands are
executed only when the function is entered.
8. When you set a tracepoint on a function, the Debugger displays the
function name and parameters when the function is entered. When
execution of the function is completed, the Debugger displays the
function name and returned values in the Command window.
9. You can specify any function that the current program calls, including
a C function, an -INFORMIX-ESQL/C- function, or a 4GL library function.
10. If you specify a commands list, you must enclose it within braces
( { } ). Use a semicolon ( ; ) to separate commands.
11. The commands list cannot include a CALL, CONTINUE, STEP, or RUN command.
12. The scope of reference of any variables in the commands list is
determined by their qualifiers and by the function that is current
when the tracepoint takes effect.
The Debugger disregards whatever function was current when you issued
a TRACE command, and ignores the (function) option, in identifying the
scope of any variables in commands.
13. You can qualify variable names.
14. The FUNCTIONS option sets a tracepoint on every function.
15. You cannot abbreviate the FUNCTIONS keyword.
16. There is no restriction on the number of tracepoints that you can set
at any time.
17. Setting a tracepoint with the TRACE command also enables the
tracepoint, unless you include the asterisk ( * ) symbol.
You can use the asterisk ( * ) option to create a tracepoint without
enabling it. Use this option to define tracepoints that you would
like to save for future debugging sessions, but that you do not want
to be active in the current one. The tracepoint is specified but
disabled, as if you had set it and then used a DISABLE command to
disable it.
Examples
The command
trace 15
establishes a tracepoint with no name at line 15 of the current module.
The Command window displays its reference number, the word ``trace,'' and
its function, line number, module, and scope of reference. For example,
(1) trace main:15 [r_main.4gl]
scope function: main
If you enter the command
trace x
a function of the current program, the Command window displays its name and
parameters when the function is entered, and its name and returned values
after the function returns.
If no function called x is found, the Debugger searches for a variable
called x, applying the scope of reference rules. If variable x is found,
its name and value are displayed in the Command window whenever its value
changes.
If both a function and a variable have the name x, you must prefix the
variable with appropriate qualifiers in a TRACE command to set a tracepoint
on the variable. If neither a function nor a variable called x is found,
the Command window displays the error message
-16351: Variable [x] could not be located.
The command
trace global.sqlca.sqlcode
displays the name and value of the sqlcode variable whenever it changes.
Since sqlcode is set at zero after each successfully executed -RDSQL-
statement, this tracepoint identifies queries that return no rows, and
unsuccessfully executed statements.
The following command traces the execution of all functions, and executes a
PRINT command to display the current value of the global variable
sqlca.sqlcode when each function is entered:
trace functions {print global.sqlca.sqlcode}
The command
trace * "vestige" cmenu.12 {va all} >> vestigial
specifies (but does not enable) a tracepoint called ``vestige'' at the 12th
line of the module called cmenu. If you later enable this tracepoint and
execute the 4GL statement in this line, the Debugger executes a VARIABLE
ALL command when the tracepoint is reached, and saves the output from this
command in a disk file called vestigial.
The command
trace (funca) reca.b
sets a tracepoint on member b of the record named reca in function funca.
The Debugger will display the name and value of reca.b whenever it changes
in funca, but will ignore any variable called reca.b in other functions.
The (function) specification requires fewer keystrokes than using
qualifiers, as in the equivalent command:
trace function.funca.reca.b
Related Commands
DISABLE, ENABLE, LIST, NOTRACE, WRITE
---------------------------------------------------------------------------
USE
Overview
Use USE to specify or display the source file search path.
Syntax
-------------------------------------------------------------------------
USE [[=] pathname[, ...]]
-------------------------------------------------------------------------
Explanation
USE is a required keyword.
pathname is a full or relative pathname.
= is an optional symbol to replace the current search path
with a new path.
Notes
1. Enter a USE command without any arguments to display your current
directory search path for 4GL source files.
2. If any of your source files are in directories outside your current
search path, the USE command enables you to add the pathnames of one or
more additional directories to the current directory search path.
If you list multiple pathnames in a USE command, the first directory
that will be searched is specified by the first pathname, the second by
the second pathname, and so forth.
3. If you include the equal ( = ) symbol in a USE command, the new
pathname(s) replace the current search path.
4. If you do not include the equal ( = ) symbol, the pathnames take
precedence in the order of search, ahead of the following directories:
+o Directories from previous USE commands
+o The current directory
+o The directory associated with the 4GL program
5. A modified directory search order that you establish by a USE command
only persists for the duration of the current debugging session, or
until your next USE command.
If you exit to the Programmer's Environment, and then resume debugging
the same 4GL program without returning to the operating system, the
Debugger restores any source file search path that was in effect when
you ended the previous debugging session.
Examples
The following command
use
displays your current search path in the Command window.
After the following USE command, the first directory in your current search
path will be /b/low and the second will be /m/b/high:
use /b/low, /m/b/high
After the second of the following two commands, the first directory in the
current search path will be /m/b/high, and the second will be /b/low, since
the most recent USE command takes precedence:
use /b/low
. . .
use /m/b/high
The next command replaces the current source file search path with the
current directory:
use = .
Related Commands
WRITE
---------------------------------------------------------------------------
VARIABLE
Overview
Use VARIABLE to display the declaration of a variable or to save it in a
file.
Syntax
-------------------------------------------------------------------------
VARIABLE [variable | GLOBALS | ALL] [>> filename]
-------------------------------------------------------------------------
Explanation
VARIABLE is a required keyword.
variable is the name of a program variable.
GLOBALS is a keyword to ignore local variables.
ALL is a keyword to include all variables.
>> is a symbol, required if the information returned is saved
in a file.
filename is the name of an output file.
Notes
1. A VARIABLE command displays the declaration of a variable, including
the data type specification and the scope of reference.
2. If you do not specify variable, GLOBALS, or ALL, the type of each
variable in the current function is displayed, but global variables
outside the current function are ignored.
3. If the variable is a record, the name and data type of each component
variable are displayed.
4. You can qualify the scope of reference of a variable by prefixing its
name with a qualifier. Possible qualifiers include those in the
following list:
Qualifier Scope
GLOBAL. in all modules
MODULE.mod-name. in the specified module
FUNCTION.func-name. in the specified function
rec-name[.rec-name ...]. in the record [within another record ... ]
5. If you specify GLOBALS, the Debugger only returns the types of the
global variables.
6. If you specify ALL, the Debugger returns the data types of all global
variables in the program, and of all local variables in the current
function.
7. The VARIABLE command can only return the declarations of variables in
4GL functions. If a C or -INFORMIX-ESQL/C- function is the current
function, only the ALL or GLOBALS options return data type information.
Both options declare all the global variables, but no local variables.
8. If you specify an output file, the display is redirected to the file.
If the file already exists, the output is appended to it.
Examples
The following command returns the types of the local and global variables
that appear in the current function:
variable
The next command displays declarations of all the global variables in the
program:
variable global
The following command
variable function.add_order.num_cust
displays the declaration of the variable num_cost in a function called
add_ord.
If you enter the command
variable all >> snapshot
the Debugger saves the declarations of all global variables in the program,
and any other variables of the current function, in a file called snapshot.
This output is not displayed in the Command window.
Related Commands
DUMP, LET, PRINT
---------------------------------------------------------------------------
VIEW
Overview
Use VIEW to display a specific 4GL function or module in the Command
window.
Syntax
-------------------------------------------------------------------------
VIEW [line-no | module | function]
-------------------------------------------------------------------------
Explanation
VIEW is a required keyword.
line-no is the line number within the module.
module is the name of the module to be displayed.
function is the name of the function to be displayed.
Notes
1. If you enter the VIEW keyword without additional options, the source
code lines of the current module are displayed in the Command window.
If the first x lines of the source code have been always displayed, the
lines x+1 to x+10 are displayed.
2. The Debugger displays in the Command window whatever 4GL function or
module you specify in a VIEW command. If necessary, the current module
is replaced by the module that you specify, or with the function that
you specify.
4. Do not include an argument list with a function.
5. The VIEW command can only display a 4GL function or a 4GL module.
You cannot specify a 4GL library function, a C function, or
an -INFORMIX-ESQL/C- function in a VIEW command.
6. If both a function and module have the same name, the Command window
displays the function.
7. The line-no refers to the line number in the current module that you
want displayed. Then the lines between line-no - 5 to line-no + 4 are
displayed.
Examples
The command
view add_cust
displays the source code of the function add_cust, or the module of the
same name, if no function exists.
Related Commands
CALL, FUNCTIONS, INTERRUPT
---------------------------------------------------------------------------
WHERE
Overview
Use WHERE to display the name and arguments of each 4GL function that was
called to reach the current 4GL statement, or to redirect this information
to a file.
Syntax
-------------------------------------------------------------------------
WHERE [>> filename]
-------------------------------------------------------------------------
Explanation
WHERE is a required keyword.
>> are symbols, required if the information returned is saved
in a file.
filename is the name of an optional output file.
Notes
1. WHERE displays the current list of active functions. These are
functions that were called before the current 4GL statement was
executed, but that have not yet returned. Besides the names of these
functions, WHERE displays the line and source module from which each
function was called, and evaluates any parameters that were passed with
it.
2. You can specify a filename in which to save the output from a WHERE
command. This can be outside your current directory, if you prefix
filename with a pathname.
3. If a file called filename already exists, the WHERE command appends the
returned values, without overwriting the file.
4. WHERE only describes programmer-defined 4GL functions. An exception
occurs, however, if WHERE appears in the command list of a tracepoint
that you set on a C function, on a -INFORMIX-ESQL/C- function, or on a
4GL library function. If the tracepoint is reached, WHERE evaluates
any parameters that were passed. It lists the function as a C or 4GL
library function, rather than the module and line number of the calling
statement, and lists the active functions.
5. An error message appears if you invoke the WHERE command when no 4GL
program is currently executing. You can use WHERE when execution is
suspended, or after a program or function terminates abnormally.
Examples
The following command
where
displays the programmer-defined functions that were executed to get to the
current 4GL statement, as well as the module and line number from which
each function was called, and any parameters that it passed.
The next command saves the results of a WHERE display in a disk file called
myfile in a subdirectory called /m/tom:
where >> /m/tom/myfile
If you have not yet issued a RUN or CALL command since you began the
debugging session or since the last CLEANUP command, no function is active.
If you use WHERE when there are no active functions, the error message
appears:
-16387: Program is not currently being executed.
Related Commands
CALL, CLEANUP, FUNCTIONS, RUN, TRACE
---------------------------------------------------------------------------
WRITE
Overview
Use WRITE to save in a file the commands to establish the breakpoints,
tracepoints, aliases and directory search path specifications.
Syntax
-------------------------------------------------------------------------
WRITE [BREAK] [TRACE] [ALIASES] [>>] [filename]
-------------------------------------------------------------------------
Explanation
WRITE is a required keyword.
BREAK is a keyword to save the current breakpoints.
TRACE is a keyword to save the current tracepoints.
ALIASES is a keyword to save the current aliases.
>> are optional symbols before an output filename.
filename is the name of an output file, with no extension.
Notes
1. You can use WRITE to save in a file the commands to establish any or
all of the specifications of your current debugging environment. The
resulting output file can be used as an initialization file or with a
subsequent READ command to reestablish the current debugging session.
2. If no other keyword appears in a WRITE command, then by default all of
the current breakpoints, tracepoints, aliases, and the source file
search path are saved in the output file.
3. If you include the >> symbols and specify a filename, the WRITE
command assigns a name to the output file by appending the extension
.4db to your filename.
4. If you do not include a filename specification, WRITE assigns a
default name to the output file by appending the extension .4db to the
filename of the .42r or .42m program that you are currently debugging.
5. If a .4db file with the same name as the output file already exists in
the same directory, information in the existing file is not
overwritten. Instead, WRITE appends commands to the existing file.
6. If you want to save the output file in a directory other than your
current directory, you must prefix filename with the complete
pathname.
7. You can use an editor to supplement, delete, or modify the commands in
an output file. The file cannot include non-keyword commands such as
Interrupt, Screen, or Toggle.
8. You can edit the output file of a WRITE command to include READ
statements that specify other .4db input files. The Debugger will
display an error message, however, if READ commands are nested more
than ten deep, or if nested READ commands attempt to access each other.
Examples
write >> strtdbg
This WRITE commands saves commands in the file strtdbg.4db. Since no
restriction is included, the output file includes commands to establish all
the current breakpoints, tracepoints, search paths, and aliases.
The >> filename specification is unnecessary if you want to save the
commands in a file whose filename is the same as that of the current
program, but with extension .4db.
The >> symbol is usually optional, unless the name of the output file could
be confused with one of the options. It could be omitted in the previous
example, but not in the command
write a b >> t
which specifies that the ALIAS and BREAK commands will be saved in a file
named t.4db. If you omit the redirect symbol in this example, the Debugger
interprets t as the abbreviation of TRACE.
Related Commands
ALIAS, APPLICATION DEVICE, BREAK, LIST, READ, TRACE, USE
