Operators for the C grammar

The debugger supports most C operators and includes an additional set of operators for convenience. The WATCOM C Language Reference manual describes many of these operators.

The syntax for debugger expressions is similar to that of the C programming language. Operators are presented in order of precedence, from lowest to highest. Operators on the same line have the same priority.

Assignment Operators (lowest priority):

    =  +=  -=  *=  /=  %=  &=  |=  ^=  <<=  >>=

Logical Operators:

    ||
    &&

Bit Operators:

    |
    ^ 
    &

Relational Operators:

    ==  != 
    >   <=  <  >=

Shift Operators:

    <<	>>

Arithmetic Operators:

    +  -
    *  /  %

Unary Operators:

    +  -  ~  !  ++  --  &  *  %
    sizeof unary_expr
    sizeof(type_name)
    (type_name) unary_expr
    [type_name] unary_expr
    ?

Binary Address Operator (highest priority):

    :

Parentheses can be used to order the evaluation of an expression.

In addition to the operators listed above, a number of primary expression operators are supported. These operators are used in identifying the object to be operated upon.

[ ]

subscripting, substringing

()

function call

.

field selection

->

field selection using a pointer

The following sections describe the operators presented above.

Assignment operators

=

Assignment: The value on the right is assigned to the object on the left.

+=

Additive assignment: The value of the object on the left is augmented by the value on the right.

-=

Subtractive assignment: The value of the object on the left is reduced by the value on the right.

*=

Multiplicative assignment: The value of the object on the left is multiplied by the value on the right.

/=

Division assignment: The value of the object on the left is divided by the value on the right.

%=

Modulus assignment: The object on the left is updated with MOD(left,right). The result is the remainder when the value of the object on the left is divided by the value on the right.

&=

Bit-wise AND: The bits in the object on the left are ANDed with the bits of the value on the right.

|=

Bit-wise inclusive OR: The bits in the object on the left are ORed with the bits of the value on the right.

^=

Bit-wise exclusive OR: The bits in the object on the left are exclusively ORed with the bits of the value on the right.

<<=

Left shift: The bits in the object on the left are shifted to the left by the amount of the value on the right.

>>=

Right shift: The bits in the object on the left are shifted to the right by the amount of the value on the right. If the object on the left is described as unsigned, the vacated high-order bits are zeroed. If the object on the left is described as signed, the sign bit is propagated through the vacated high-order bits. The debugger treats registers as unsigned items.

Logical operators

&&

Logical conjunction: The logical AND of the value on the left and the value on the right is produced. If either of the values on the left or right is equal to 0, then the result is 0; otherwise the result is 1.

||

Logical inclusive disjunction: The logical OR of the value on the left and the value on the right is produced. If either of the values on the left or right isn't equal to 0, then the result is 1; otherwise the result is 0.

---

If the value on the left is non-zero, then the expression on the right isn't evaluated. This is known as short-circuit expression evaluation.

---

Bit operators

&

Bit-wise AND: The bits of the value on the left and the value on the right are ANDed.

|

Bit-wise OR: The bits of the value on the left and the value on the right are ORed.

^

Bit-wise exclusive OR: The bits of the value on the left and the value on the right are exclusively ORed.

Relational operators

==

Equal: If the value on the left is equal to the value on the right, then the result is 1; otherwise the result is 0.

!=

Not equal: If the value on the left isn't equal to the value on the right, then the result is 1; otherwise the result is 0.

<

Less than: If the value on the left is less than the value on the right, then the result is 1; otherwise the result is 0.

<=

Less than or equal: If the value on the left is less than or equal to the value on the right, then the result is 1; otherwise the result is 0.

>

Greater than: If the value on the left is greater than the value on the right, then the result is 1; otherwise the result is 0.

>=

Greater than or equal: If the value on the left is greater than or equal to the value on the right, then the result is 1; otherwise the result is 0.

Arithmetic/logical shift operators

<<

Left shift: The bits of the value on the left are shifted to the left by the amount described by the value on the right.

>>

Right shift: The bits of the value on the left are shifted to the right by the amount described by the value on the right. If the object on the left is described as unsigned, the vacated high-order bits are zeroed. If the object on the left is described as signed, the sign bit is propagated through the vacated high-order bits. The debugger treats registers as unsigned items.

Binary arithmetic operators

+

Addition: The value on the right is added to the value on the left.

-

Subtraction: The value on the right is subtracted from the value on the left.

*

Multiplication: The value on the left is multiplied by the value on the right.

/

Division: The value on the left is divided by the value on the right.

%

Modulus: The modulus of the value on the left with respect to the value on the right is produced. The result is the remainder when the value on the left is divided by the value on the right.

Unary arithmetic operators

+

Plus: The result is the value on the right.

-

Minus: The result is the negation of the value on the right.

~

Bit-wise complement: The result is the bit-wise complement of the value on the right.

!

Logical complement: If the value on the right is equal to 0, then the result is 1; otherwise it is 0.

++

Increment: Both prefix and postfix operators are supported. If the object is on the right, it is pre-incremented by 1 (for example, ++x). If the object is on the left, it is post-incremented by 1 (for example, x++).

--

Decrement: Both prefix and postfix operators are supported. If the object is on the right, it is pre-decremented by 1 (for example, --x). If the object is on the left, it is post-decremented by 1 (for example, x--).

&

Address of: The result is the address (segment:offset) of the object on the right (for example, &main).

*

Points: The result is the value stored at the location addressed by the value on the right (for example, *(ds:100), *string.loc). In the absence of typing information, a near pointer is produced. If the operand doesn't have a segment specified, the default data segment (DGROUP) is assumed:

          (SS:00FE) = FFFF
    var:  (SS:0100) = 0152
          (SS:0102) = 1240
          (SS:0104) = EEEE
        

%

Value at address: The result is the value stored at the location addressed by the value on the right (for example, %(ds:100), %string.loc). In the absence of typing information, a far pointer is produced. If the operand doesn't have a segment specified, the default data segment (DGROUP) is assumed:

          (SS:00FE) = FFFF
    var:  (SS:0100) = 0152
          (SS:0102) = 1240
          (SS:0104) = EEEE
        

---

This operator isn't found in the C or C++ programming languages.

---

Special unary operators

sizeof unary_expression

For example:

    sizeof tyme
    sizeof (*tyme)
        

sizeof(type_name)

For example:

    sizeof( struct tm )
        

(type_name) unary_expression

The type conversion operator (type_name) is used to convert an item from one type to another. The following describes the syntax of type_name:

    type_name ::= type_spec { [ "near" | "far" | 
                                "huge" ] "*" }
    type_spec ::= typedef_name
            |   "struct" structure_tag
            |   "union"  union_tag
            |   "enum"   enum_tag
            |   scalar_type { scalar_type }
    scalar_type ::= "char" | "int" | "float" 
            | "double" |   "short" | "long" 
            | "signed" | "unsigned"
        

For example:

    (float) 4
    (int) 3.1415926
        

[type_name] unary_expression

You can force the debugger to treat a memory reference as a particular type of value by using a type coercion operator. A type specification is placed inside brackets as shown above. The basic types are:

char

character, 8 bits

short

short integer, 16 bits

long

long integer, 32 bits

float

single-precision floating-point, 32 bits

double

double-precision floating-point, 64 bits

Unless qualified by the short or long keyword, the int type is 16 bits in 16-bit applications and 32 bits in 32-bit applications (386, 486, and Pentium systems). The character, short integer, and long integer types may be treated as signed or unsigned items. The default for the character type is unsigned. The default for the integer types is signed. For example:

    [char]             (default is unsigned)
    [signed char]
    [unsigned char]
    [int]              (default is signed)
    [short]            (default is signed)
    [short int]        (default is signed)
    [signed short int]
    [long]             (default is signed)
    [long int]         (default is signed)
    [signed long]
    [unsigned long int]
    [float]
    [double]
        

Note that it's unnecessary to specify the int keyword when short or long is specified.

?

Existence test: The ? unary operator may be used to test for the existence of a symbol. For example:

    ?id
        

The result of this expression is 1 if id is a symbol known to the debugger, and 0 otherwise. If the symbol doesn't exist in the current scope, then it must be qualified with its module name. Automatic symbols exist only in the current function.

Binary address operator

:

Memory locations can be referenced by using the binary : (colon) operator and a combination of constants, register names, and symbol names. In the Intel 80x86 architecture, a memory reference requires a segment and offset specification. A memory reference using the : operator takes the following form:

segment:offset

The elements segment and offset can be expressions. For example:

    (ES):(DI+100)
    (SS):(SP-20)
        

Primary expression operators

[ ]

Elements of an array can be identified using subscript expressions. Consider the following 3-dimensional array defined in the C language:

    char *ProcessorType[2][4][2] =
        { { { "Intel 8086",   "Intel 8088"  },
            { "Intel 80186",  "Intel 80188" },
            { "Intel 80286",  "unknown"     },
            { "Intel 80386",  "unknown"     } },

          { { "NEC V30",      "NEC V20"     },
            { "unknown",      "unknown"     },
            { "unknown",      "unknown"     },
            { "unknown",      "unknown"     } } };
        

This array can be viewed as two layers of rectangular matrices of 4 rows by 2 columns. The array elements are all pointers to string values.

By using a subscript expression, specific slices of an array can be displayed. To see only the values of the first layer, the following expression can be issued:

    processortype[0]
        

To see only the first row of the first layer, the following expression can be issued:

    processortype[0][0]
        

To see the second row of the first layer, the following command can be issued:

    processortype[0][1]
        

To see the value of a specific entry in a matrix, all the indexes can be specified:

    processortype[0][0][0]
    processortype[0][0][1]
    processortype[0][1][0]
        

()

The function call operators appear to the right of a symbol name and identify a function call in an expression. The parentheses can contain arguments. For example:

    ClearScreen()
    PosCursor( 10, 20 )
    Line( 15, 1, 30, '-', '+', '-' )
        

.

The . (dot) operator indicates field selection in a structure. In the following example, tyme2 is a structure, and tm_year is a field in the structure:

    tyme2.tm_year
        

->

The -> operator indicates field selection when using a pointer to a structure. In the following example, tyme is the pointer, and tm_year is a field in the structure to which it points:

    tyme->tm_year
        

Operators for the C++ grammar

Debugger support for the C++ grammar includes all of the C operators described in the previous section ``Operators for the C Grammar.'' In addition to this, the debugger supports a variety of C++ operators in the C++ Programming Language manual.

Perhaps the best way to illustrate the additional capabilities of the debugger's support for the C++ grammar is by way of an example. The following C++ program encompasses the features of C++ that we use in our debugging example:

// DBG_EXAM.C: C++ debugging example program

struct BASE {
    int a;
    BASE() : a(0) {}
    ~BASE(){}
    BASE & operator =( BASE const &s )
    {
        a = s.a;
        return *this;
    }
    virtual void foo()
    {
        a = 1;
    }
};

struct DERIVED : BASE {
    int b;
    DERIVED() : b(0) {}
    ~DERIVED() {}
    DERIVED & operator =( DERIVED const &s )
    {
        a = s.a;
        b = s.b;
        return *this;
    }
    virtual void foo()
    {
        a = 2;
        b = 3;
    }
    virtual void foo( int )
    {
    }
};

void use( BASE *p )
{
    p->foo();
}

void main()
{
    DERIVED x;
    DERIVED y;

    use( &x );
    y = x;
}

Compile and link this program so that the most comprehensive debugging information is included in the executable file.

Ambiguity resolution

Continuing with the example of the previous section, we can step into the call to use() and up to the p->foo() function call. Try to set a breakpoint at foo.

You'll be presented with a window containing a list of foo functions to choose from since the reference to foo at this point is ambiguous. Select the one that interests you.

You may also have observed that, in this instance, p is really a pointer to the variable x, which is a DERIVED type. To display all the fields of x, you can typecast it as follows.

    *(DERIVED *)p

The this operator

Continuing with the example of the previous sections, we can step into the call to f->foo()() and up to the b=3 statement. You can use the this operator as illustrated in the following example.

    this->a
    *this

Operator functions

Continuing with the example of the previous sections, we can set breakpoints at C++ operators using expressions similar to the following:

    operator =

For example:

    DERIVED & operator =( DERIVED const &s )
    {
        a = s.a;
        b = s.b;
        return *this;
    }

Scope operator ::

We can use the scope operator :: to identify what it is that we wish to examine. Continuing with the example of the previous sections, we can enter an address like:

    base::foo

In some cases, this also helps resolve any ambiguity. The example above permits us to set a breakpoint at the source code for the function foo() in the class BASE.

    virtual void foo()
    {
        a = 1;
    }

Here are some more interesting examples:

    derived::foo
    derived::operator =

The first of these two examples contains an ambiguous reference, so a prompt window is displayed to resolve the ambiguity.

Constructor and destructor functions

We can also examine the constructor and destructor functions of an object or class. Continuing with the example of the previous sections, we can enter expressions like:

    base::base
    base::~base

The examples above permit us to refer to the source code for the constructor and destructor functions in the class BASE.

Operators for the FORTRAN grammar

The debugger supports most FORTRAN 77 operators and includes an additional set of operators for convenience. The additional operators are patterned after those available in the C programming language.

---

QNX doesn't support FORTRAN 77. The operators described in this section are useful only if you're remotely debugging an application on a platform that does support it.

---

The grammar that the debugger supports is close to that of the FORTRAN 77 language, but there are a few instances where space characters must be used to clear up any ambiguities. For example, the expression:

    1.eq.x

results in an error, since the debugger forms a floating-point constant from the 1., leaving the string eq.x. If you introduce a space after the 1, then you clear up the ambiguity:

    1 .eq.x

Unlike FORTRAN, the parser in the debugger treats spaces as significant characters. Thus spaces must not be introduced in the middle of symbol names, constants, multi-character operators like .EQ. or //, and so on.

Operators are presented in order of precedence, from lowest to highest. Operators on the same line have the same priority.

Assignment Operators (lowest priority):

    =  +=  -=  *=  /=  %=  &=  |=  ^=  <<=  >>=

Logical Operators:

    .EQV.  .NEQV.
    .OR.
    .AND.
    .NOT.

Bit Operators:

    |
    ^
    &

Relational Operators:

    .EQ.  .NE.	.LT.  .LE.  .GT.  .GE.

Shift and Concatenation Operators:

    <<	>>  //

Arithmetic Operators:

    +  -
    *  /  %
    ** (unsupported)

Unary Operators:

    +  -
    ~  ++  --  &  *  %
    [type_name] unary_expr
    ?

Binary Address Operator (highest priority):

    :

Parentheses can be used to order the evaluation of an expression.

In addition to the operators listed above, a number of primary expression operators are supported. These operators are used in identifying the object to be operated upon:

()

subscripting, substringing, or function call

.

field selection

->

field selection using a pointer

The following built-in functions may be used to convert the specified argument to a particular type:

INT()

conversion to integer

REAL()

conversion to real

DBLE()

conversion to double-precision

CMPLX()

conversion to complex

DCMPLX()

conversion to double-precision complex

The sections that follow describe the operators presented above.

Assignment operators

=

Assignment: The value on the right is assigned to the object on the left.

+=

Additive assignment: The object on the left is augmented by the value on the right.

-=

Subtractive assignment: The object on the left is reduced by the value on the right.

*=

Multiplicative assignment: The object on the left is multiplied by the value on the right.

/=

Division assignment: The object on the left is divided by the value on the right.

%=

Modulus assignment: The object on the left is updated with MOD(left, right). The result is the remainder when the value of the object on the left is divided by the value on the right.

&=

Bit-wise AND: The bits in the object on the left are ANDed with the bits of the value on the right.

|=

Bit-wise inclusive OR: The bits in the object on the left are ORed with the bits of the value on the right.

^=

Bit-wise exclusive OR: The bits in the object on the left are exclusively ORed with the bits of the value on the right.

<<=

Left shift: The bits in the object on the left are shifted to the left by the amount of the value on the right.

>>=

Right shift: The bits in the object on the left are shifted to the right by the amount of the value on the right. If the object on the left is described as unsigned, the vacated high-order bits are zeroed. If the object on the left is described as signed, the sign bit is propagated through the vacated high-order bits.

---

The debugger treats registers as unsigned items.

---

Logical operators

.EQV.

Logical equivalence: The logical equivalence of the value on the left and the value on the right is produced.

.NEQV.

Logical non-equivalence: The logical non-equivalence of the value on the left and the value on the right is produced.

.OR.

Logical inclusive disjunction: The logical OR of the value on the left and the value on the right is produced.

.AND.

Logical conjunction: The logical AND of the value on the left and the value on the right is produced.

.NOT.

Logical negation: The logical complement of the value on the right is produced.

Bit operators

|

Bit-wise OR: The bits of the value on the left and the value on the right are ORed.

^

Bit-wise exclusive OR: The bits of the value on the left and the value on the right are exclusively ORed.

&

Bit-wise AND: The bits of the value on the left and the value on the right are ANDed.

Relational operators

.EQ.

Equal: If the value on the left is equal to the value on the right, then the result is 1; otherwise the result is 0.

.NE.

Not equal: If the value on the left isn't equal to the value on the right, then the result is 1; otherwise the result is 0.

.LT.

Less than: If the value on the left is less than the value on the right, then the result is 1; otherwise the result is 0.

.LE.

Less than or equal: If the value on the left is less than or equal to the value on the right, then the result is 1; otherwise the result is 0.

.GT.

Greater than: If the value on the left is greater than the value on the right, then the result is 1; otherwise the result is 0.

.GE.

Greater than or equal: If the value on the left is greater than or equal to the value on the right, then the result is 1; otherwise the result is 0.

Arithmetic/logical shift operators

<<

Left shift: The bits of the value on the left are shifted to the left by the amount described by the value on the right.

>>

Right shift: The bits of the value on the left are shifted to the right by the amount described by the value on the right. If the object on the left is described as unsigned, the vacated high-order bits are zeroed. If the object on the left is described as signed, the sign bit is propagated through the vacated high-order bits.

---

The debugger treats registers as unsigned items.

---

Concatenation operator

//

String concatenation: The concatenation of the character string value on the left and right is formed.

Binary arithmetic operators

+

Addition: The value on the right is added to the value on the left.

-

Subtraction: The value on the right is subtracted from the value on the left.

*

Multiplication: The value on the left is multiplied by the value on the right.

/

Division: The value on the left is divided by the value on the right.

%

Modulus: The modulus of the value on the left with respect to the value on the right is produced. The result is the remainder when the value on the left is divided by the value on the right.

**

Exponentiation

---

Exponentiation isn't supported by the debugger.

---

Unary arithmetic operators

+

Plus: The result is the value on the right.

-

Minus: The result is the negation of the value on the right.

~

Bit-wise complement: The result is the bit-wise complement of the value on the right.

++

Increment: Both prefix and postfix operators are supported. If the object is on the right, it's pre-incremented by 1 (for example, ++x). If the object is on the left, it's post-incremented by 1 (for example, x++).

--

Decrement: Both prefix and postfix operators are supported. If the object is on the right, it's pre-decremented by 1 (for example, --x). If the object is on the left, it's post-decremented by 1 (for example, x--).

&

Address of: The result is the address (segment:offset) of the object on the right (for example, main).

*

Points: The result is the value stored at the location addressed by the value on the right (for example, *(ds:100), *string.loc). In the absence of typing information, the value on the right is treated as a pointer into the default data segment (DGROUP) and a near pointer is produced:

          (SS:00FE) = FFFF
    var:  (SS:0100) = 0152
          (SS:0102) = 1240
          (SS:0104) = EEEE
        

%

Value at address: The result is the value stored at the location addressed by the value on the right (for example, %(ds:100), %string.loc). In the absence of typing information, the value on the right is treated as a pointer into the default data segment (DGROUP) and a far pointer is produced:

          (SS:00FE) = FFFF
    var:  (SS:0100) = 0152
          (SS:0102) = 1240
          (SS:0104) = EEEE
        

---

The % operator isn't found in the FORTRAN 77 programming language.

---

Special unary operators

?

Existence test: The ? unary operator may be used to test for the existence of a symbol. For example:

    ?id
        

The result of this expression is 1 if id is a symbol known to the debugger; 0 if not. If the symbol doesn't exist in the current scope, then it must be qualified with its module name. Automatic symbols exist only in the current subprogram.

Binary address operator

:

Memory locations can be referenced by using the binary : operator and a combination of constants, register names, and symbol names. In the Intel 80x86 architecture, a memory reference requires a segment and offset specification. A memory reference using the : operator takes the following form:

    segment:offset
        

The elements segment and offset can be expressions. For example:

    (ES):(DI+100)
    (SS):(SP-20)
        

Primary expression operators

()

The () operator is used for:

• subscripts for an array
• substrings
• function calls

.

The . operator indicates field selection in a structure. This operator is useful in mixed-language applications where part of the application is written in the C or C++ programming language. In the following example, tyme2 is a structure, and tm_year is a field in the structure.

    tyme2.tm_year
        

->

The -> operator indicates field selection when using a pointer to a structure. This operator is useful in mixed-language applications where part of the application is written in the C or C++ programming language. In the following example, tyme is the pointer, and tm_year is a field in the structure it points to.

    tyme->tm_year