Document revision date: 30 March 2001

## OpenVMS Debugger Manual

Previous | Contents | Index

#### C.7.7.4 Pointers to Members

Objects that are pointers to members are represented as 64-bit integers.

#### C.7.7.5 Referencing Entities by Type

To examine and display the value of an object or member by type, use the command EXAMINE/TYPE. Similarly, you can modify the value of an expression to be deposited to a type you specify by using the DEPOSIT/TYPE command. With the /TYPE qualifier, the syntax for these commands is as follows:

    deposit/type=(name)
    examine/type=(name)

The type denoted by name must be the name of a variable or data type declared in the program. The `/type` qualifier is particularly useful for referencing C++ objects that have been declared with more than one type.

### C.7.8 Using the Debugger with C++ Functions

This section describes how to reference the various kinds of functions and function arguments.

#### C.7.8.1 Referring to Overloaded Functions

To find the symbolic names of functions in your code, use the SHOW SYMBOL command. If the function is overloaded, use the asterisk wildcard character (*) in the name specification to display the overloaded symbol names.

For example, consider the following code:

    class base
      {
      public:
        base();
        base( int );

        ~base();

        int base_f1();

        void base_f2();
        void base_f2( int );
        void base_f2( char );
       };

The following sequence shows how to display overloaded symbols and determine the appropriate function reference:

    DBG> set break %name 'base::base_f2'
    %DEBUG-E-NOTUNQOVR, symbol 'base::base_f2' is overloaded
            use SHOW SYMBOL to find the unique symbol names
    DBG> show symbol *base_f2
    overloaded symbol CXX_T10_179\base::base_f2
      overloaded instance CXX_T10_179\base::base_f2__1
      overloaded instance CXX_T10_179\base::base_f2__2
      overloaded instance CXX_T10_179\base::base_f2__3
    DBG> set break %name 'base::base_f2__2'
    DBG> step
    stepped to CXX_T10_179\main\%LINE 20
        20:     x.base_f2();
    DBG> step
    stepped to CXX_T10_179\main\%LINE 21
        21:     x.base_f2(5);
    DBG> step
    break at routine CXX_T10_179\base::base_f2__2
        12:     void base_f2( int ) {}
    DBG> step
    stepped to CXX_T10_179\main\%LINE 22
        22:     x.base_f2('W');
    stepped to CXX_T10_179\main\%LINE 22
    DBG> go
    'Normal successful completion'
    DBG> ^Z

#### C.7.8.2 Referring to Static and Nonstatic Member Functions

To refer to a member function, quote, with %name, its qualified class name, two colons (::), and the name of the member function. If the member function is overloaded, append the suffix `__` integer-number.

The following examples show the correct use of member function references:

    DBG> set break %name 'MYSTRING::length'
    DBG> set break %name 'MYCOMPLEX::format__1', %name 'MYCOMPLEX::format__2'

#### C.7.8.3 Referring to Constructors

To refer to a constructor, state the name. If a constructor is overloaded, append the suffix `__` integer-number.

The following examples show the correct use of constructor references:

    DBG> set break FOO
    DBG> set break MYSTRING__1

#### C.7.8.4 Referring to Destructors

To refer to a destructor, quote its name, including the tilde ( `~` ), with %name.

The following example shows the correct use of a destructor reference:

    DBG> set break %name '~FOO'

#### C.7.8.5 Referring to Conversions

To refer to conversion operators from a class SRC to a type dest, quote SRC, two colons (::), and then dest with %name.

The set of atomic types is drawn from the following set of names:

    void            char   signed_char   unsigned_char   signed_short
    unsigned_short  int    signed_int    unsigned_int    signed_long
    unsigned_long   float  double        long_double

Pointer types are named (type*). Reference types are named (type&). The types struct, union class and enum are named by their tags and the qualifiers const and volatile precede their types with a space in between. For example:

    DBG> set break %name 'C::int', %name 'C::(const S)&'

#### C.7.8.6 Referring to User-Defined Operators

The following operators may be overloaded by user-defined functions:

    +     -      *     /       %      ^      &      |      ~       !
    =     <      >     +=      -=     *=     /=     %=     ^=      &=
    |=    <<     >>    >>=     <<=    ==     !=     <=     >=      &&
    |     ++     --    ->*     ,      ->     []     ()     delete  new

See The Annotated C++ Reference Manual (shipped with C++ documentation) for more details about overloading operators.

To refer to such user-defined functions, quote the operator characters with %name. As with regular functions, prefix the string quoted by %name with a qualified class name and two colons (::) if the user-defined operator is a member function. Similarly, if the function is overloaded, append the suffix `__` integer_number to the operator characters. In particular, this suffix is necessary if both unary and binary instances of an operator such as `+` are defined, or if prefix instances of `++` or `--` are defined.

The following examples show the correct use of user-defined function references:

    DBG> set break %name 'MYSTRING::+'
    DBG> set break %name 'COUNTER::++__1', %name 'COUNTER::++__2'

#### C.7.8.7 Referring to Function Arguments

In debugger referencing, you use `this` , `*this` , and `this->m` as follows:

- All nonstatic member functions have a pointer parameter available named `this` . For example:

      DBG> examine this

- Use `*this` to examine the prefix object that a member function is invoked against. For example:

      DBG> examine *this

- Use the `this` parameter to refer to a data member `m` of the prefix argument to a member function. For example:

      DBG> examine this->m

## C.8 COBOL

The following subtopics describe debugger support for COBOL.

### C.8.1 Operators in Language Expressions

Supported COBOL operators in language expressions include:

Kind | Symbol | Function
--- | --- | ---
Prefix | + | Unary plus
Prefix | - | Unary minus (negation)
Infix | + | Addition
Infix | - | Subtraction
Infix | * | Multiplication
Infix | / | Division
Infix | ** | Exponentiation (VAX specific)
Infix | = | Equal to
Infix | NOT = | Not equal to
Infix | > | Greater than
Infix | NOT < | Greater than or equal to
Infix | < | Less than
Infix | NOT > | Less than or equal to
Infix | NOT | Logical NOT
Infix | AND | Logical AND
Infix | OR | Logical OR

### C.8.2 Constructs in Language and Address Expressions

Supported constructs in language and address expressions for COBOL follow:

Symbol | Construct
--- | ---
( ) | Subscripting
OF | Record component selection
IN | Record component selection

### C.8.3 Data Types

Supported COBOL data types follow:

COBOL Data Type | Operating System Data Type Name
--- | ---
COMP | Longword Integer (L,LU)
COMP | Word Integer (W,WU)
COMP | Quadword Integer (Q,QU)
COMP-1 | F_Floating (F)
COMP-1 (Alpha specific) | S_Floating (FS)
COMP-2 | D_Floating (D)
COMP-2 (Alpha specific) | T_Floating (FT)
COMP-3 | Packed Decimal (P)
INDEX | Longword Integer (L)
Alphanumeric | ASCII Text (T)
Records | (None)
Numeric Unsigned | Numeric string, unsigned (NU)
Leading Separate Sign | Numeric string, left separate sign (NL)
Leading Overpunched Sign | Numeric string, left overpunched sign (NLO)
Trailing Separate Sign | Numeric string, right separate sign (NR)
Trailing Overpunched Sign | Numeric string, right overpunched sign (NRO)

Floating-point numbers of type COMP-1 may be represented by F_Floating or IEEE S_Floating, depending on compiler switches.

Floating-point numbers of type COMP-2 may be represented by D_Floating or IEEE T_Floating, depending on compiler switches.

### C.8.4 Source Display

The debugger can show source text included in a program with the COPY, COPY REPLACING, or REPLACE statement. However, when COPY REPLACING or REPLACE is used, the debugger shows the original source text instead of the modified source text generated by the COPY REPLACING or REPLACE statement.

The debugger cannot show the original source lines associated with the code for a REPORT section. You can see the DATA SECTION source lines associated with a REPORT, but no source lines are associated with the compiled code that generates the report.

### C.8.5 COBOL INITIALIZE Statement and Large Tables (Arrays) (Alpha Only)

On OpenVMS Alpha systems, the debugger can take an unusually great amount of time and resources if you use the STEP command to execute an INITIALIZE statement in a COBOL program when a large table (array) is being initialized.

To work around this problem, set a breakpoint on the first executable line past the INITIALIZE statement, rather than stepping across the INITIALIZE statement.

## C.9 DIBOL (VAX Only)

The following subtopics describe debugger support for DIBOL.

### C.9.1 Operators in Language Expressions

Supported DIBOL operators in language expressions include:

Kind | Symbol | Function
--- | --- | ---
Prefix | # | Round
Prefix | + | Unary plus
Prefix | - | Unary minus (negation)
Infix | + | Addition
Infix | - | Subtraction
Infix | * | Multiplication
Infix | / | Division
Infix | // | Division with fractional result
Infix | .EQ. | Equal to
Infix | .NE. | Not equal to
Infix | .GT. | Greater than
Infix | .GE. | Greater than or equal to
Infix | .LT. | Less than
Infix | .LE. | Less than or equal to
Infix | .NOT. | Logical NOT
Infix | .AND. | Logical AND
Infix | .OR. | Logical OR
Infix | .XOR. | Exclusive OR

### C.9.2 Constructs in Language and Address Expressions

Supported constructs in language and address expressions for DIBOL follow:

Symbol | Construct
--- | ---
( ) | Substring
[ ] | Subscripting
. (period) | Record component selection

### C.9.3 Data Types

Supported DIBOL data types follow:

DIBOL Data Type | Operating System Data Type Name
--- | ---
I1 | Byte Integer (B)
I2 | Word Integer (W)
I4 | Longword Integer (L)
Pn | Packed Decimal String (P)
Pn.m | Packed Decimal String (P)
Dn | Numeric String, Zoned Sign (NZ)
Dn.m | Numeric String, Zoned Sign (NZ)
An | ASCII Text (T)
Arrays | (None)
Records | (None)

## C.10 Fortran

The following subtopics describe debugger support for Fortran.

### C.10.1 Operators in Language Expressions

Supported Fortran operators in language expressions include:

Kind | Symbol | Function
--- | --- | ---
Prefix | + | Unary plus
Prefix | - | Unary minus (negation)
Infix | + | Addition
Infix | - | Subtraction
Infix | * | Multiplication
Infix | / | Division
Infix | ** | Exponentiation (VAX specific)
Infix | // | Concatenation
Infix | .EQ. | Equal to
Infix | == | Equal to
Infix | .NE. | Not equal to
Infix | /= | Not equal to
Infix | .GT. | Greater than
Infix | > | Greater than
Infix | .GE. | Greater than or equal to
Infix | >= | Greater than or equal to
Infix | .LT. | Less than
Infix | < | Less than
Infix | .LE. | Less than or equal to
Infix | <= | Less than or equal to
Prefix | .NOT. | Logical NOT
Infix | .AND. | Logical AND
Infix | .OR. | Logical OR
Infix | .XOR. | Exclusive OR
Infix | .EQV. | Equivalence
Infix | .NEQV. | Exclusive OR

### C.10.2 Constructs in Language and Address Expressions

Supported constructs in language and address expressions for Fortran follow:

Symbol | Construct
--- | ---
( ) | Subscripting
. (period) | Record component selection
% (percent sign) | Record component selection

### C.10.3 Predefined Symbols

Supported Fortran predefined symbols follow:

Symbol | Description
--- | ---
.TRUE. | Logical True
.FALSE. | Logical False

### C.10.4 Data Types

Supported Fortran data types follow:

Fortran Data Type | Operating System Data Type Name
--- | ---
LOGICAL*1 | Byte Unsigned (BU)
LOGICAL*2 | Word Unsigned (WU)
LOGICAL*4 | Longword Unsigned (LU)
LOGICAL*8 (Alpha specific) | Quadword Unsigned (QU)
BYTE | Byte (B)
INTEGER*1 | Byte Integer (B)
INTEGER*2 | Word Integer (W)
INTEGER*4 | Longword Integer (L)
INTEGER*8 (Alpha specific) | Quadword Integer (Q)
REAL*4 | F_Floating (F)
REAL*4 (Alpha specific) | IEEE S_Floating (FS)
REAL*8 | D_Floating (D)
REAL*8 | G_Floating (G)
REAL*8 (Alpha specific) | IEEE T_Floating (FT)
REAL*16 (Alpha specific) | H_Floating (H)
COMPLEX*8 | F_Complex (FC)
COMPLEX*8 (Alpha specific) | IEEE S_Floating (SC)
COMPLEX*16 | D_Complex (DC)
COMPLEX*16 | G_Complex (GC)
COMPLEX*16 (Alpha specific) | IEEE T_Floating (TC)
CHARACTER | ASCII Text (T)
Arrays | (None)
Records | (None)

Even though the data type codes for unsigned integers (BU, WU, LU, QU) are used internally to describe the LOGICAL data types, the debugger (like the compiler) treats LOGICAL variables and values as being signed when they are used in language expressions.

The debugger prints the numeric values of LOGICAL variables or expressions instead of .TRUE. or .FALSE. Normally, only the low-order bit of a LOGICAL variable or value is significant (0 is .FALSE. and 1 is .TRUE.). However, Fortran does allow all bits in a LOGICAL value to be manipulated and LOGICAL values can be used in integer expressions. For this reason, it is at times necessary to see the entire integer value of a LOGICAL variable or expression, and that is what the debugger shows.

COMPLEX constants such as (1.0,2.0) are not supported in debugger expressions.

Floating-point numbers of type REAL*4 and COMPLEX*8 may be represented by F_Floating or IEEE S_Floating, depending on compiler switches.

Floating-point numbers of type REAL*8 and COMPLEX*16 may be represented by D_Floating, G_Floating, or IEEE T_Floating, depending on compiler switches.

On OpenVMS Alpha systems, the debugger cannot evaluate expressions that contain complex variables. To work around this problem, examine the complex variable and then evaluate the expression using the real and imaginary parts of the complex variable as shown by the EXAMINE command.

Previous | Next | Contents | Index

| privacy and legal statement |
4538PRO_070.HTML