HPlogo System Debug Reference Manual > Chapter 2 User Interface

Literals

MPE documents

Complete PDF
Table of Contents
Index

E0201 Edition 4 ♥
E0300 Edition 3
E0692 Edition 3

Literals represent specific values of one of the data types supported by System Debug. This section explains how to construct and interpret literals.

Numeric Literals

Numeric literals are a sequence of digits that are valid in the indicated radix. If the digits are not preceded by one of the base prefix characters, %, #, or $, the current input base is assumed.

Examples of valid numeric literals are the following: 

   #2048
   $fff
   %1762
   26
The type of a numeric literal is determined by the smallest amount of storage required to store the value and by whether or not the literal is treated as being signed. The presence of a preceding minus sign, which must always precede the base prefix character, does not affect the sign of the literal. Such minus signs are treated as unary operators and are not considered to be parts of literals.

Octal and hex literals are considered to be signed if the representation of the unsigned digits fits into the natural word size of the current mode of System Debug (16 bits for CM, 32 bits for NM), and the high-order bit of the word is 1. Decimal literals are always unsigned.

Examples: 

 $nmdebug > env outbase '#' /* set output base to decimal
 #nmdebug > wl $ffffffff    /* S32 - sign bit 1, NM word size
 #-1
 #nmdebug > wl $ffff        /* U16 - sign bit 1, but not NM word size
 #65535
 #nmdebug > cm              /* switch to CM
 #cmdebug > wl $ffff        /* S16 - sign bit 1, CM word size
 #-1
 #cmdebug > wl $ffffffff    /* U32 - sign bit 1, but not CM word size
 #4294967295
 #cmdebug >

Pointer Literals

Short pointer literals are represented by numeric literals. Essentially, this means that wherever a short pointer is required, a numeric literal that fits in 32 bits is accepted and is silently converted to the type SPTR.

Long pointer literals of type LPTR are entered as a pair of (32-bit) numbers separated by a dot, forming the so-called dotted pair. Long pointer literals are entered in the form sid.offset. When the offset part exceeds 32 bits, the type of the literal becomes EADDR.

Examples are:
$c0002040

short pointer literal

3f.204c

long pointer literal (SID=3f, offset=204c)

String Literals

String literals are formed by enclosing an arbitrary sequence of ASCII characters within either single quotes (') or double quotes (").

The same type of quote used to start the string (single or double) must be used to terminate it. For example, 'abc' and "abc" are valid string literals, but 'abc" is not.

A string which is defined with single quotes can contain one or more double quotes within the string body, and vice versa. For example, "don't fret" and "SEG'ONE" are valid strings.

In order to include the same quote character that is used as the string delimiter within the string itself, that quote character should appear in duplicate within the string. For example, the apostrophe in'don&'&'t'comes out as don't.

Examples of string literals are: 

   'Rufus T. Firefly'

   "OB'"

   'xltypes:pib_type.parent'

   'The sun isn''t shining and I''m feeling so sad.'

Regular Expression String Literals

A special class of string literals called regular expressions is formed by enclosing an arbitrary sequence of characters with the backquote character (`). Refer to appendix A for a discussion of how patterns and regular express can be constructed for use in pattern matching.



Data Types

Operators