Article
Substring Access
In operand positions, subareas of certain data objects can be accessed
by specifying an offset/length:
Syntax
dobj[+off][(len)]
fs [+off][(len)]
dref- *[+off][(len)]
Effect
A specified offset or length is directly appended to either the
dobj
descriptor of the data object, an fs field symbol, or
a dereferenced data reference variable dref- * : Offsets/lengths
can be specified for:
Elementary
byte-like data objects
Elementary
character-like data objects
Flat structures , whereby one of the
following prerequisites must be satisfied in
Unicode programs :
The structure contains flat character-like components only.
The first Unicode fragment of
the structure is flat and character-like, and the substring addressed by
specifying the offset and length is located within this fragment.
The following restrictions apply:
In write positions , only flat data
objects are permitted; it is not possible to write to substrings of
strings.
Access to substrings of strings is also not possible in the following
reader positions :
dobj[+off][(len)] specified as a memory area
mem_area of the statement
ASSIGN .
dobj[+off][(len)] specified as an argument of the statement
GET REFERENCE or the reference operator
REF .
dobj[+off][(len)] specified as an actual parameter for input
parameters in calls of methods ,
function modules , and
subroutines .
Offsets/lengths cannot be specified for literals or text symbols.
In the case of dynamically specified
operands in parentheses, no lengths can be specified.
A dereferenced data reference variable dref- * must be typed in
full.
For a writable expression ,
offsets/lengths cannot be specified as
memory areas in the statement
ASSIGN or as arguments of the reference operator
REF (table expressions
only).
The segment of the data object is used that has the offset specified in
off and the length (in characters or bytes) specified in len
. A memory area must not be addressed outside the field boundaries,
except in the case of the ASSIGN statement.
For an offset specified without a length, the entire substring is
addressed as of the off character; for a length specified without
an offset, the first len characters are addressed (different
rules apply to the ASSIGN statement).
The operands off and len expect data objects of the type
i . These data objects must contain positive integers, with the
following exceptions.
The length 0 can be specified for strings .
A negative offset (but never length 0) can be specified if an <(>
fs field symbol is specified in the
ASSIGN statement for
dobj .
If off is smaller than the length of dobj , an asterisk (
* ) can be specified for len . The upper limit of dobj
then determines the upper limit of the memory area.
If the prerequisites are not met or if the subarea defined by off
and len is not completely contained in the data object (except
in the case of ASSIGN ), a syntax error occurs (if statically
identifiable). Otherwise, an exception of class
CX_SY_RANGE_OUT_OF_BOUNDS occurs. If off is specified as a
numeric literal, then this literal cannot be prefixed with a sign.
The offset and length specified are counted in characters for
character-like data objects and in bytes for all other data objects. A
character is equivalent to a byte in non-
Unicode systems .
A substring specified by an offset or length is handled like a data
object of the specified length for which the data type depends on the
data type of the original data object, the field symbol, or the data
reference variable, as shown below:
Original data type Data type of substring
c c
d n
n n
t n
string string
x x
xstring xstring
Structure type c
If the length of the substring exactly corresponds to the length of the
structure in a substring access to a structure, the substring does not
have data type c ; instead, it is handled like the structure
itself.
Notes
For reads on substrings of character-like data objects, predefined
substring functions that allow searches
by specifying both substring and offset/lengths are available.
It is a good idea to specify offsets with the value 0 explicitly too
(that is, dobj+0(len) instead of dobj(len) ). This
differentiates a substring access in the source code clearly from other
language constructs that also use parentheses, such as dynamic
specifications, method calls, or inline declarations.
No substring access cnt(len) , sum(len) can be performed on
data objects called cnt and sum unless an offset is
specified explicitly. The compiler always interprets this as a
number or sum of a field len in
the control level processing of an
extract dataset .
Obsolete syntax forms can still occur
with substring access (apart from with classes).
The statement MOVE PERCENTAGE
indicates an obsolete form of substring access.
Documentation extract taken from SAP system, � Copyright SAP AG. All rights reserved