Development Tools

2.21.1 Input rule

Following is the rules for input to each panel/dialog box.

(1)	Character set

Character sets that are allowed to input are as follows:

Table 2.32

List of Character Set

Character Set	Outline
ASCII	1- byte alphabets, numbers, symbols
Shift-JIS	2-byte alphabet, number, symbol, Hiragana, Katakana, Kanji and 1-byte Katakana.
EUC-JP	2-byte alphabet, number, symbol, Hiragana, Katakana, Kanji and 1-byte Katakana.
UTF-8	2-byte alphabet, number, symbol, Hiragana, Katakana, Kanji (include Chinese characters) and 1-byte Katakana.
UTF-16 Big-Endian	2-byte alphabet, number, symbol, Hiragana, Katakana, Kanji (include Chinese characters) and 1-byte Katakana.
UTF-16 Little-Endian	2-byte alphabet, number, symbol, Hiragana, Katakana, Kanji (include Chinese characters) and 1-byte Katakana.
UTF-32 Big-Endian	2-byte alphabet, number, symbol, Hiragana, Katakana, Kanji (include Chinese characters) and 1-byte Katakana.
UTF-32 Little-Endian	2-byte alphabet, number, symbol, Hiragana, Katakana, Kanji (include Chinese characters) and 1-byte Katakana.

(2)	Escape sequence

Escape sequences that are allowed to input are as follows:

Table 2.33

Escape Sequence List

Escape Sequence	Value	Outline
\0	0x00	null character
\a	0x07	Alert
\b	0x08	Backspace
\t	0x09	Horizontal tab
\n	0x0A	New line
\v	0x0B	Vertical tab
\f	0x0C	Form feed
\r	0x0D	Carriage return
\"	0x22	Double-quotation mark
\'	0x27	Single-quotation mark
\?	0x3F	Question mark handled as a question mark if ? is entered.
\\	0x5C	Backslash

(3)

Number

Notations allowed when entering numbers are as follows:

Table 2.34

Notation List

Notation	Outline
Binary number	Start with 0b and continues with the numbers from 0 to 1. (Case insensitive for alphabets)
Octal number	Start with 0 and continues with the numbers from 0 to 7.
Decimal	Start without 0 and continues with the numbers from 0 to 9.
Hexadecimal number	Start with 0x and continues with the numbers from 0 to 9 and alphabets a to f. (Case insensitive for alphabets) In the input area with the mark, prefix 0x is not needed.

(4)	Expression and operator

Expression represents constants, CPU register name, I/O register name and symbols and those connected with operators.

An expression comes in two types: an address expression and a watch-expression. The expression that requires the address of a symbol is referred to as an address expression, and the one that requires the value of a symbol is referred to as a watch-expression.

(a)	An address expression and operators

With an address expression, the address of a symbol is used to perform operations. Only when a CPU register name is written, the value of the symbol is used to perform operations.

The basic input formats of address expressions are as follows:

Table 2.35

Basic Input Format of Address Expressions

Expression	Description
Name of a C language variableNote 1	Address of a C language variable
Expression [ExpressionNote 2]	Address of an array
Expression.Member name	Address of a structure/union/class member
Expression->Member name	Address of a structure/union/class member that is pointed to
Name of a CPU register	Value of the CPU register
Name of an I/O register	Address of the I/O register
Label nameNote 3, EQU symbol nameNote 3 and [immediate value]	Address of a label, a value of an EQU symbol, and an immediate address
Integer constant	Address

Note 1.

If the register is assigned the value of a C variable, an error results.

Note 2.

The expression that is input as an index to an array is parsed as a watch-expression.

Note 3.

If the label name or EQU symbol name includes a "$", be sure to enclose the name in "{ }" (e.g. {$Label}).
When you specify the CPU register name "I", add ":REG" (e.g. I:REG) to distinguish it from the keyword "I" that indicates an imaginary number.

From "Table 2.35 Basic Input Format of Address Expressions", the following expressions with operator can be constructed.

Table 2.36

Construction of Expressions with Operators

Expression	Description
(Expression)	Value of the parenthetical watch-expression
! Expression	Inverts symbol
- Expression	Logical negation
~ Expression	Bit inversion
Expression * ExpressionNote	Multiplication
Expression / ExpressionNote	Division
Expression % ExpressionNote	Remainder calculation
Expression + ExpressionNote	Addition
Expression . ExpressionNote	Subtraction
Expression & ExpressionNote	Logical multiplication by bits
Expression ^ ExpressionNote	Exclusive disjunction by bits
Expression \| ExpressionNote	Logical sum by bits

Note	Variables and functions can be combined by an operator only with variables, functions and integer constants.

Example

C variable name + I/O register name

(b)	Watch-expression and operator

With watch-expression, the value of a symbol is used to perform operations. Only when the value does not exist, the address of the symbol is used to perform operations (e.g. main( ) + 1).

The basic input formats of watch-expressions are as follows:

Table 2.37

Basic Input Format of Watch-expressions

Expression	Description
Name of a C language variable	Address of a C language variable
Expression [Expression	Element of an array
Expression.Member name	Value of a structure/union/class member
Expression->Member name	Value of a structure/union/class member that is pointed to
*Expression	Value of pointer variable
&Expression	Location address
Name of a CPU register	Value of the CPU register
Name of an I/O register	Value of the I/O register
Label nameNote, EQU symbol nameNote and and [immediate value]	Values of a label, a value of an EQU symbol, and an immediate address
Integer constant	Integer constant value
Floating constant	Floating point constant value
Character constant	Character constant value

Note

If the label name or EQU symbol name includes a "$", be sure to enclose the name in "{ }" (e.g. {$Label}).
Any imaginary number must be multiplied by an uppercase "I" (e.g. 1.0 + 2.0*I). When you specify the CPU register name "I", add ":REG" (e.g. I:REG) to distinguish it from the keyword "I" that indicates an imaginary number.

From "Table 2.37 Basic Input Format of Watch-expressions", the following watch-expressions with operator can be constructed. For the operators listed in the table below, the expression is parsed according to C language specifications.

Table 2.38

Construction of Expressions with Operators

Expression	Description
(Expression)	Specifies the order in which operations are performed
! Expression	Inverts symbol
- Expression	Logical negation
Expression * ExpressionNote	Multiplication
Expression / ExpressionNote	Division
Expression % ExpressionNote	Remainder calculation
Expression + ExpressionNote	Addition
Expression . ExpressionNote	Subtraction
Expression & ExpressionNote	Logical multiplication by bits
Expression ^ ExpressionNote	Exclusive disjunction by bits
Expression \| ExpressionNote	Logical sum by bits

Note	Variables and functions can be combined by an operator only with variables, functions and integer constants.

C variable name + I/O register name

Caution 1.

When a char-type one-dimensional array is assigned to multiple locations in registers or memory as shown below, no character string will be displayed in the value column of the Watch panel or Local Variables panel even after the array "array" has been registered with the panel.
char array[5] = "ABCD";

Caution 2.

When the selection for [Scope] in the Local Variables panel is not [Current], the values of variables assigned to registers are not displayed correctly. Editing these values is also not possible.

Caution 3.

When a defined variable satisfies both of the conditions given below, the Watch panel and Local Variables panel indicate the location of the entire variable rather than the location of its member variables.

[Conditions]

<1>	The variable is assigned to two or more addresses or registers (i.e. two or more addresses or registers are displayed in the address column).

<2>	A structure-, class-, array-, or union-type member is defined in the variable.

[Example]

struct Mem {

    long m_base;

};

struct Sample {

    long m_a;

    struct Mem m_b; <- Condition <2>

};

main () {

    struct Sample obj;

Display in the Watch and Local Variables panels:

"obj"                        -    { R1:REG, R2:REG }      (struct Sample)

    L m_a           0x00000000    { R1:REG }              (long)

    L m_b                    -    { R1:REG, R2:REG }      (struct Base)

        L m_base    0x00000000    { R2:REG }              (long)

Caution 4.

In case of a variable with the size beyond 0x10000, Value, Style and Address indicate "?" in the Watch panel.