In DTrace, strings are represented as an array of characters
terminated by a null byte (that is, a byte whose value is zero,
usually written as '\0'
). The visible part of
the string is of variable length, depending on the location of
the null byte, but DTrace stores each string in a fixed-size
array so that each probe traces a consistent amount of data.
Strings cannot exceed the length of the predefined string limit.
However, the limit can be modified in your D program or on the
dtrace command line by tuning the
strsize
option. See
Chapter 10, Options and Tunables for more information about tunable
DTrace options. The default string limit is 256 bytes.
The D language provides an explicit string
type rather than using the type char *
to
refer to strings. The string type is equivalent to char
*
, in that it is the address of a sequence of
characters, but the D compiler and D functions such as
trace
provide enhanced capabilities when
applied to expressions of type string. For example, the string
type removes the ambiguity of type char *
when you need to trace the actual bytes of a string.
In the following D statement, if s
is of type
char *
, DTrace traces the value of the
pointer s
, which means it traces an integer
address value:
trace(s);
In the following D statement, by the definition of the
*
operator, the D compiler dereferences the
pointer s
and traces the single character at
that location:
trace(*s);
These behaviors enable you to manipulate character pointers that refer to either single characters, or to arrays of byte-sized integers that are not strings and do not end with a null byte.
In the next D statement, if s
is of type
string
, the string type indicates to the D
compiler that you want DTrace to trace a null terminated string
of characters whose address is stored in the variable
s
:
trace(s);
You can also perform lexical comparison of expressions of type string. See Section 2.11.5, “String Comparison”.