DPCL Class Reference

Chapter 11. Class ProbeExp

Objects of the ProbeExp class represent probe expressions to be executed within one or more target applications. This class overloads common operators so that expressions do not execute locally, but instead call member functions to create the probe expressions.

This book uses two terms that you may not be familiar with. The term lhs refers to the left-hand side of an expression or operator, while the term rhs refers to the right-hand side.

Note that some ProbeExp operators may cause an exception of ASC_invalid_internal_tree to be raised. If this exception occurs, it should be treated as an internal error.

Supporting data types

Primitive Data Types

Synopsis

typedef char                     int8_t;
typedef short                    int16_t;
typedef int                      int32_t;
typedef long long                int64_t;
typedef unsigned char            uint8_t;
typedef unsigned short           uint16_t;
typedef unsigned int             uint32_t;
typedef unsigned long long       uint64_t;
typedef float                    float32_t;
typedef double                   float64_t;

Description

This collection of data types represents the primitive data types supported at some level by probe expressions. These are client data types that represent entities used in a probe expression inside an application process. Not all data types are given the same level of support. 32-bit integers are given the greatest level of support, with arithmetic, logical, bitwise, relational and assignment operators. Although pointer values can be manipulated in probe expressions, they are not given a separate data type on the client, but are themselves represented by probe expressions. More complex data types may be obtained from examining data variables in a target application program, but operators that make use of such values are quite limited.

CodeExpNodeType

Description

The following table provides brief descriptions of the ProbeExp expression types.

Table 11. ProbeExp Expression Types

Expression Type Description DPCL Operator
CEN_actual_param actual parameter ---
CEN_address_op address of x.address()
CEN_and_op bitwise AND x & y
CEN_andand_op logical AND x && y
CEN_andeq_op bitwise assignment x &= y
CEN_array_ref_op array reference x[y]
CEN_assign_op assignment x.assign(y)
CEN_call_op function call f.call(...)
CEN_data_ref data variable ---
CEN_div_op division x / y
CEN_diveq_op divide assignment x /= y
CEN_eqeq_op value equality x == y
CEN_float32_value float32 value ---
CEN_float64_value float64 value ---
CEN_function_ref reference to function ---
CEN_ge_op value greater or equal x >= y
CEN_global_function predefined global function ---
CEN_global_variable predefined global variable ---
CEN_gt_op value greater x > y
CEN_heap_ref heap (malloc'd) variable ---
CEN_if_else_stmt if else statement x.ifelse(y,z)
CEN_if_stmt if statement x.ifelse(y)
CEN_int8_value int8 value ---
CEN_int16_value int16 value ---
CEN_int32_value int32 value ProbeExp(4)
CEN_int64_value int64 value ---
CEN_LAST_TYPE last node type marker ---
CEN_le_op value less or equal x <= y
CEN_list_item list node ---
CEN_lseq_op left shift assignment x <<= y
CEN_lshift_op left shift x << y
CEN_lt_op less than x < y
CEN_minus_op binary minus x - y
CEN_minuseq_op minus assignment x -= y
CEN_mod_op modulus x % y
CEN_modeq_op modulus assignment x %= y
CEN_mult_op multiplication x * y
CEN_multeq_op multiply assignment x *= y
CEN_ne_op not equal x != y
CEN_not_op logical NOT ~ x
CEN_null_stmt null/empty statement ---
CEN_or_op bitwise OR x | y
CEN_oreq_op bitwise OR assignment x |= y
CEN_oror_op logical OR x || y
CEN_plus_op addition x + y
CEN_pluseq_op addition assignment x += y
CEN_pointer_deref_op pointer dereference *x
CEN_postfix_minus_op postfix decrement x --
CEN_postfix_plus_op postfix increment x ++
CEN_prefix_minus_op prefix decrement -- x
CEN_prefix_plus_op prefix increment ++ x
CEN_rseq_op right shift assignment x >>= y
CEN_rshift_op right shift x >> y
CEN_stmt_list statement list x.sequence(y)
CEN_string_value string value ---
CEN_tilde_op bitwise negation ~ x
CEN_uint8_value uint8 value ---
CEN_uint16_value uint16 value ---
CEN_uint32_value uint32 value ---
CEN_uint64_value uint64 value ---
CEN_umin_op unary minus - x
CEN_undef_node undefined node ---
CEN_uplus_op unary plus + x
CEN_xor_op exclusive OR x ~ y
CEN_xoreq_op exclusive OR assignment x ~= y

Expression Type	Description	DPCL Operator
CEN_actual_param	actual parameter	---
CEN_address_op	address of	x.address()
CEN_and_op	bitwise AND	x & y
CEN_andand_op	logical AND	x && y
CEN_andeq_op	bitwise assignment	x &= y
CEN_array_ref_op	array reference	x[y]
CEN_assign_op	assignment	x.assign(y)
CEN_call_op	function call	f.call(...)
CEN_data_ref	data variable	---
CEN_div_op	division	x / y
CEN_diveq_op	divide assignment	x /= y
CEN_eqeq_op	value equality	x == y
CEN_float32_value	float32 value	---
CEN_float64_value	float64 value	---
CEN_function_ref	reference to function	---
CEN_ge_op	value greater or equal	x >= y
CEN_global_function	predefined global function	---
CEN_global_variable	predefined global variable	---
CEN_gt_op	value greater	x > y
CEN_heap_ref	heap (malloc'd) variable	---
CEN_if_else_stmt	if else statement	x.ifelse(y,z)
CEN_if_stmt	if statement	x.ifelse(y)
CEN_int8_value	int8 value	---
CEN_int16_value	int16 value	---
CEN_int32_value	int32 value	ProbeExp(4)
CEN_int64_value	int64 value	---
CEN_LAST_TYPE	last node type marker	---
CEN_le_op	value less or equal	x <= y
CEN_list_item	list node	---
CEN_lseq_op	left shift assignment	x <<= y
CEN_lshift_op	left shift	x << y
CEN_lt_op	less than	x < y
CEN_minus_op	binary minus	x - y
CEN_minuseq_op	minus assignment	x -= y
CEN_mod_op	modulus	x % y
CEN_modeq_op	modulus assignment	x %= y
CEN_mult_op	multiplication	x * y
CEN_multeq_op	multiply assignment	x *= y
CEN_ne_op	not equal	x != y
CEN_not_op	logical NOT	~ x
CEN_null_stmt	null/empty statement	---
CEN_or_op	bitwise OR	x \| y
CEN_oreq_op	bitwise OR assignment	x \|= y
CEN_oror_op	logical OR	x \|\| y
CEN_plus_op	addition	x + y
CEN_pluseq_op	addition assignment	x += y
CEN_pointer_deref_op	pointer dereference	*x
CEN_postfix_minus_op	postfix decrement	x --
CEN_postfix_plus_op	postfix increment	x ++
CEN_prefix_minus_op	prefix decrement	-- x
CEN_prefix_plus_op	prefix increment	++ x
CEN_rseq_op	right shift assignment	x >>= y
CEN_rshift_op	right shift	x >> y
CEN_stmt_list	statement list	x.sequence(y)
CEN_string_value	string value	---
CEN_tilde_op	bitwise negation	~ x
CEN_uint8_value	uint8 value	---
CEN_uint16_value	uint16 value	---
CEN_uint32_value	uint32 value	---
CEN_uint64_value	uint64 value	---
CEN_umin_op	unary minus	- x
CEN_undef_node	undefined node	---
CEN_uplus_op	unary plus	+ x
CEN_xor_op	exclusive OR	x ~ y
CEN_xoreq_op	exclusive OR assignment	x ~= y

Description

The CodeExpNodeType enumeration data type represents the various operators AND operands that may be found in probe expressions. Probe expressions are structured as abstract syntax trees. Expressions are represented with binary operators as a typed node with the left as the left sub-tree, and the right as the right sub-tree.

Rules for using ProbeExp operators

The following table lists the operator functions within the ProbeExp class, the allowable data types for each one, and the data type of the operation's result. If there is more than one type listed in either the left-hand or right-hand columns for a particular operator, the operand can be any of those types. For example, the types int and actual appear in both the left-hand and right-hand columns for operator* (unary). This means that the operation is permitted for the following combinations of operand types:
int * int
int * actual
actual * int
actual * actual

Also, if there is more than one line for an operator, then each line represents one set of rules for that operator. For example, operator== is permitted to have the following combination of operators:
int == int
int == actual
actual == int
actual == actual
actual == pointer
pointer == pointer
pointer == actual

Note that in memory means that the left-hand operand must be an object in memory.

Table 12. Operator and Operand Type Rules

Operator LH Operand Data Type RH Operand Data Type Other Requirement Data Type of Result
address any
LHS: in memory Pointer to invoking object's type
assign any Same type as RHS LHS: in mem Invoking object's type
call function pointer

Return type of function being called
ifelse

int, pointer, actual

Type of then clause
operator+ (binary) int, actual int, actual
int
operator+ (unary) int, actual

int
operator+= int int, actual LHS: in memory int
operator- (binary) int, actual int, actual LHS: in memory int
operator- (unary) int, actual

int
operator-= int int, actual LHS: in memory int
operator* (binary) int, actual int, actual
int
operator* (unary)

pointer (not to void)
actual

Type of pointee
operator*= int int, actual LHS: in memory int
operator/ int, actual int, actual
int
operator/= int int, actual LHS: in memory int
operator% int, actual int, actual
int
operator%= int int, actual LHS: in memory int
operator==

int, actual
actual, pointer
pointer

int, actual
pointer
actual

int
operator! int, pointer, actual

int
operator!=

int, actual
actual, pointer
pointer

int, actual
pointer
actual

int
operator<

int, actual
actual, pointer
pointer

int, actual
pointer
actual

int
operator<=

int, actual
actual, pointer
pointer

int, actual
pointer
actual

int
operator<< int, actual int, actual
int
operator<<= int int, actual LHS: in memory int
operator>

int, actual
actual, pointer
pointer

int, actual
pointer
actual

int
operator>=

int, actual
actual, pointer
pointer

int, actual
pointer
actual

int
operator>> int, actual int, actual
int
operator>>= int int, actual LHS: in memory int
operator& (binary) int, actual int, actual
int
operator&= int int, actual LHS: in memory int
operator&& int, pointer, actual int, pointer, actual
int
operator| int, actual int, actual
int
operator|= int int, actual LHS: in memory int
operator|| int, pointer, actual int, pointer, actual
int
operator^ int, actual int, actual
int
operator^= int int, actual LHS: in memory int
operator~ int, actual

int
operator[]

pointer (not to void)
actual

int, actual
int, actual

Type of pointee

Operator	LH Operand Data Type	RH Operand Data Type	Other Requirement	Data Type of Result
address	any		LHS: in memory	Pointer to invoking object's type
assign	any	Same type as RHS	LHS: in mem	Invoking object's type
call	function pointer			Return type of function being called
ifelse	int, pointer, actual			Type of `then` clause
operator+ (binary)	int, actual	int, actual		int
operator+ (unary)	int, actual			int
operator+=	int	int, actual	LHS: in memory	int
operator- (binary)	int, actual	int, actual	LHS: in memory	int
operator- (unary)	int, actual			int
operator-=	int	int, actual	LHS: in memory	int
operator* (binary)	int, actual	int, actual		int
operator* (unary)	pointer (not to void) actual			Type of pointee
operator*=	int	int, actual	LHS: in memory	int
operator/	int, actual	int, actual		int
operator/=	int	int, actual	LHS: in memory	int
operator%	int, actual	int, actual		int
operator%=	int	int, actual	LHS: in memory	int
operator==	int, actual actual, pointer pointer	int, actual pointer actual		int
operator!	int, pointer, actual			int
operator!=	int, actual actual, pointer pointer	int, actual pointer actual		int
operator<	int, actual actual, pointer pointer	int, actual pointer actual		int
operator<=	int, actual actual, pointer pointer	int, actual pointer actual		int
operator<<	int, actual	int, actual		int
operator<<=	int	int, actual	LHS: in memory	int
operator>	int, actual actual, pointer pointer	int, actual pointer actual		int
operator>=	int, actual actual, pointer pointer	int, actual pointer actual		int
operator>>	int, actual	int, actual		int
operator>>=	int	int, actual	LHS: in memory	int
operator& (binary)	int, actual	int, actual		int
operator&=	int	int, actual	LHS: in memory	int
operator&&	int, pointer, actual	int, pointer, actual		int
operator\|	int, actual	int, actual		int
operator\|=	int	int, actual	LHS: in memory	int
operator\|\|	int, pointer, actual	int, pointer, actual		int
operator^	int, actual	int, actual		int
operator^=	int	int, actual	LHS: in memory	int
operator~	int, actual			int
operator[]	pointer (not to void) actual	int, actual int, actual		Type of pointee

Constructors

Synopsis

ProbeExp(void);
ProbeExp(int32_t scalar)
ProbeExp(const char *string)
ProbeExp(const ProbeExp &copy);

Parameters

scalar: single value of a primitive data type
string: null-terminated array of signed 8-bit integers, or characters
copy: probe expression object that will be duplicated in a copy constructor

Description

All of the above constructors create a new node that may be used as a sub-tree in a larger probe expression. Each of the constructors, with the exception of the copy constructor, create terminal nodes. To create an expression containing operators, one must use the ProbeExp operator that corresponds to the desired action. The ProbeExp operator constructs the probe expression and performs a validity check. In general, the probe expression may then be combined with other probe expressions and then installed and activated in an application. At this time additional checks are made to ensure data references are valid within the process.

The default constructor ProbeExp(void) returns CEN_undef_node.

Exceptions

ASC_insufficient_memory: a memory allocation routine failed. Insufficient memory to create a new node.

address

Synopsis

#include <ProbeExp.h>
ProbeExp address(void) const;

Description

Creates a probe expression that represents taking the address of the object in application memory represented by the invoking object. The operand must be an object in application memory. For example,

ProbeExp exp = obj.address();

would create an expression exp that represents the address of obj. The expression exp could then be used as a sub-expression in an assignment or other type of statement or expression.

Refer to Table 12 for the data types that are permitted with this function, as well as the data type of the result.

This expression may be executed on the application process through the use of point probes or one-shot probes.

Return Values

Returns a probe expression representing the address of the object represented by the operand.

Exceptions

ASC_insufficient_memory: a memory allocation routine failed. Insufficient memory to create a new node.
ASC_invalid_expression: invoking object does not represent an object in memory

assign

Synopsis

#include <ProbeExp.h>
ProbeExp assign(const ProbeExp &rhs) const;

Parameters

rhs: right, or value expression, of the assignment

Description

Creates an expression where the right operand is evaluated and stored in the location indicated by the left operand. The left operand is represented by the invoking object. For example,

ProbeExp exp = lhs.assign(rhs);

would create an expression exp that represents evaluating rhs and storing its value in the location represented by lhs. It is essential that lhs represent an object in memory.

Refer to Table 12 for the data types that are permitted with this function, as well as the data type of the result.

This expression may be executed on the application process through the use of point probes or one-shot probes.

Return Values

Returns a probe expression representing the assignment of a value to an object.

Exceptions

ASC_insufficient_memory: a memory allocation routine failed. Insufficient memory to create a new node.
ASC_invalid_expression: data type of rhs (the value assigned) does not match the data type of the invoking object, or the invoking object does not represent an object in memory

call

Synopsis

#include <ProbeExp.h>
ProbeExp call(
       short count,
       ProbeExp *args) const;

Parameters

count: count of arguments or parameters passed to the function being called
args: array of arguments or parameters passed to the function being called

Description

Creates a probe expression that represents a function call. The invoking object represents the function to be called in the application process. For example, the expression

ProbeExp exp = foo.call(count, args);

would create an expression exp that represents calling a function represented by foo, with the arguments in args.

Refer to Table 12 for the data types that are permitted with this function, as well as the data type of the result.

This expression may be executed on the application process through the use of point probes or one-shot probes.

Return Values

Returns a probe expression representing a call to a function.

Exceptions

ASC_insufficient_memory: a memory allocation routine failed. Insufficient memory to create a new node.
ASC_invalid_expression: one or more arguments to the function does not represent a valid probe expression, either because the expression is poorly formed, the expression data type does not match the function argument data type, or data referenced in the expression does not reside on the process

See Also

ProbeModule::get_reference, SourceObj::reference

get_data_type

Synopsis

#include <ProbeExp.h>
ProbeType get_data_type(void) const;

Description

This function returns the data type of the probe expression.

Return Values

Returns the data type of the probe expression.

See Also

Class ProbeType

get_node_type

Synopsis

#include <ProbeExp.h>
CodeExpNodeType get_node_type(void) const;

Description

Returns the type of node at the root of the probe expression tree. Nodes in a tree represent operators or operands in an executable expression.

Return Values

Returns the type of operator or operand at the root of the probe expression tree.

has_center

Synopsis

#include <InstPoint.h>
int has_center(void) const;

Description

has_center returns a boolean indicator of whether the node being queried represents has a center child node. A node in an expression tree can have a left-hand node, a center node, and/or a right-hand node.

Return Values

If the node being queried has a center child node, the value 1 is returned. Otherwise, 0 is returned.

See Also

has_children, has_left, has_right, value_center, value_left, value_right

has_children

Synopsis

#include <InstPoint.h>
int has_children(void) const;

Description

has_children returns a boolean indicator of whether the node being queried has any child nodes. A node in an expression tree can have a left-hand node, a center node, and/or a right-hand node.

Return Values

If the node being queried has any child nodes, the value 1 is returned. Otherwise, 0 is returned.

See Also

has_center, has_left, has_right, value_center, value_left, value_right

has_float*

Synopsis

#include <InstPoint.h>
int has_float32(void) const;
int has_float64(void) const;

Description

This family of functions returns a boolean indicator of whether the node being queried represents a floating-point value having a size no larger than the size in question. For example, has_float32 returns 1 if the node represents a value of data type float32_t. If the node does not represent float32_t, 0 is returned. Similarly, has_float64 returns 1 if the node represents a constant of data type float64_t or float32_t. Otherwise, it returns 0.

See Also

value_int8, value_int16, value_int32, value_int64

has_int*

Synopsis

#include <InstPoint.h>
int has_int8(void) const;
int has_int16(void) const;
int has_int32(void) const;
int has_int64(void) const;
int has_int(void) const;

Description

This family of functions returns a boolean indicator of whether the node being queried represents a value of data type int64_t, int32_t, int16_t, or int8_t. If the node does not represent one of these values, a 0 is returned. For example, has_int16 returns 1 if the node represents a constant of the data type int16_t or int8_t. Otherwise, it returns 0.

See Also

value_int8, value_int16, value_int32, value_int64

has_left

Synopsis

#include <InstPoint.h>
int has_left(void) const;

Description

has_left() returns a boolean indicator of whether the node being queried has a left-hand child node. A node in an expression tree can have a left-hand node, a center node, and/or a right-hand node.

Return Values

If the node being queried has a left-hand child node, the value 1 is returned. Otherwise, 0 is returned.

See Also

has_center, has_children, has_right, value_center, value_left, value_right

has_right

Synopsis

#include <InstPoint.h>
int has_right(void) const;

Description

has_right() returns a boolean indicator of whether the node being queried has a right-hand child node. A node in an expression tree can have a left-hand node, a center node, and/or a right-hand node.

Return Values

If the node being queried has a right-hand child node, the value 1 is returned. Otherwise, 0 is returned.

See Also

has_center, has_children, has_left, value_center, value_left, value_right

has_string

Synopsis

#include <InstPoint.h>
int has_string(void) const;

Description

This function returns a boolean indicator of whether the node being queried represents a character string. For example, in:

ProbeExp pe("text"); flag = pe.has_string();

val would have the value 1. The function returns 1 for true and 0 for false.

See Also

value_text, value_text_length

has_uint*

Synopsis

#include <InstPoint.h>
int has_uint8(void) const;
int has_uint16(void) const;
int has_uint32(void) const;
int has_uint64(void) const;
int has_uint(void) const;

Description

This family of functions returns a boolean indicator of whether the node being queried represents an unsigned integer value having a size no larger than the size in question. For example, has_uint32 returns 1 if the node represents a value of data type uint64_t, uint32_t, uint16_t, or uint8_t. If the node does not represent one of these values, 0 is returned. For example, has_uint16 returns 1 if the node represents a constant of data type uint16_t or uint8_t. Otherwise, it returns 0.

See Also

value_int8, value_int16, value_int32, value_int64

ifelse

Synopsis

#include <ProbeExp.h>
ProbeExp ifelse(const ProbeExp &then_exp) const;
ProbeExp ifelse(
       const ProbeExp &then_exp,
       const ProbeExp &else_exp) const;

Parameters

then_exp: then expression, or expression executed when condition is true
else_exp: else expression, or expression executed when condition is false

Description

Creates a probe expression that represents a conditional statement. The invoking object represents the condition to be tested. It must be of type integer or pointer. If the test evaluates to a non-zero value, the expression represented by then_exp is executed. If the test evaluates to zero and else_exp is not supplied, execution continues past the conditional. If the test evaluates to zero and else_exp is supplied, then the expression represented by else_exp is executed. For example,

ProbeExp exp = cond_exp.ifelse(then_exp);

would create an expression exp that represents a conditional statement. The conditional expression to be tested is represented by cond_exp, and the expression to be executed, should that condition be evaluated to true (any non-zero integer value), is represented by then_else.

Refer to Table 12 for the data types that are permitted with this function, as well as the data type of the result.

This expression may be executed on the application process through the use of point probes or one-shot probes.

Return Values

Returns a probe expression that represents a conditional statement.

Exceptions

ASC_insufficient_memory: a memory allocation routine failed. Insufficient memory to create a new node.
ASC_invalid_expression: data type of the invoking object is not an integer or pointer

is_same_as

Synopsis

#include <ProbeExp.h>
int is_same_as(const ProbeExp &compare) const;

Parameters

compare: right hand side of comparison

Description

Compares two probe expressions for equivalence. If the invoking object has the same structure as the probe expression it is compared against, this function returns 1. If the structure is different in some way, or the expressions are similar in structure but have different values at corresponding nodes, it returns 0.

Return Values

This function returns 1 when the expressions are equivalent. Otherwise it returns 0.

operator + (binary)

Synopsis

#include <ProbeExp.h>
ProbeExp operator + (const ProbeExp &rhs) const;

Parameters

rhs: right operand

Description

Creates a probe expression that represents the addition of two operands. The invoking object represents the left operand, while the argument rhs represents the right operand. The operands may be objects in memory or expressions that evaluate to values. For example,

ProbeExp exp = lhs + rhs;

would create an expression exp that represents the addition of two values, lhs and rhs. The expression exp could then be used as a sub-expression in an assignment or other type of statement or expression.

Refer to Table 12 for the data types that are permitted with this function, as well as the data type of the result.

This expression may be executed on the application process through the use of point probes or one-shot probes.

Return Values

Returns a probe expression representing the addition of two operands.

Exceptions

ASC_insufficient_memory: a memory allocation routine failed. Insufficient memory to create a new node.
ASC_invalid_expression: data type of one or both operands is inappropriate

operator + (unary)

Synopsis

#include <ProbeExp.h>
ProbeExp operator + (void) const;

Description

This function returns the value of its operand.

Return Values

Returns a probe expression that represents the left operand.

Exceptions

ASC_insufficient_memory: a memory allocation routine failed. Insufficient memory to create a new node.

operator +=

Synopsis

#include <ProbeExp.h>
ProbeExp operator += (const ProbeExp &rhs) const;

Parameters

rhs: right operand

Description

Creates a probe expression that represents the addition of two operands, and the subsequent storage of the result into the invoking object. The invoking object represents the left operand, while the argument rhs represents the right operand. The left operand must be an object in memory, while the right operand may be an object in memory or an expression that evaluates to a value. For example, the expression

ProbeExp exp = lhs += rhs;

would create an expression exp that represents the addition of two values, lhs and rhs, and its assignment to lhs. The expression exp could then be used as a sub-expression in an assignment or other type of statement or expression.

Refer to Table 12 for the data types that are permitted with this function, as well as the data type of the result.

This expression may be executed on the application process through the use of point probes or one-shot probes.

Return Values

Returns a probe expression representing the addition of two operands and assignment of the result.

Exceptions

ASC_insufficient_memory: insufficient memory to create a new node
ASC_invalid_expression: data type of one or both operands is inappropriate

operator - (binary)

Synopsis

#include <ProbeExp.h>
ProbeExp operator - (const ProbeExp &rhs) const;

Parameters

rhs: right operand

Description

Creates a probe expression that represents the subtraction of two operands. The invoking object represents the left operand, while the argument rhs represents the right operand. The operands may be objects in memory or expressions that evaluate to values. For example,

ProbeExp exp = lhs - rhs;

would create an expression exp that represents the subtraction of rhs from lhs. The expression exp could then be used as a sub-expression in an assignment or other type of statement or expression.

Refer to Table 12 for the data types that are permitted with this function, as well as the data type of the result.

This expression may be executed on the application process through the use of point probes or one-shot probes.

Return Values

Returns a probe expression representing the subtraction of two operands.

Exceptions

ASC_insufficient_memory: insufficient memory to create a new node
ASC_invalid_expression: data type of one or both operands is inappropriate

operator - (unary)

Synopsis

#include <ProbeExp.h>
ProbeExp operator - (void) const;

Description

Creates a probe expression that represents the arithmetic negation of an operand. The right operand represents the invoking object. The operand may be an object in memory or an expression that evaluates to a value. For example,

ProbeExp exp = - rhs;

would create an expression exp that represents the negation of rhs. The expression exp could then be used as a sub-expression in an assignment or other type of statement or expression.

Refer to Table 12 for the data types that are permitted with this function, as well as the data type of the result.

This expression may be executed on the application process through the use of point probes or one-shot probes.

Return Values

Returns a probe expression representing the arithmetic negation of an operand.

Exceptions

ASC_insufficient_memory: insufficient memory to create a new node
ASC_invalid_expression: data type of the operand is inappropriate

operator -=

Synopsis

#include <ProbeExp.h>
ProbeExp operator -= (const ProbeExp &rhs) const;

Parameters

rhs: right operand

Description

Creates a probe expression that represents the subtraction of two operands, and the subsequent storage of the result into the invoking object. The left operand represents the invoking object, while the argument rhs represents the right operand. The left operand must be an object in memory, while the right operand may be an object in memory or an expression that evaluates to a value. For example,

ProbeExp exp = lhs -= rhs

create an expression exp that represents the subtraction of two values, lhs and rhs, and its assignment to lhs. The expression exp could then be used as a sub-expression in an assignment or other type of statement or expression.

Refer to Table 12 for the data types that are permitted with this function, as well as the data type of the result.

This expression may be executed on the application process through the use of point probes or one-shot probes.

Return Values

Returns a probe expression representing the subtraction of two operands and assignment of the result.

Exceptions

ASC_insufficient_memory: insufficient memory to create a new node
ASC_invalid_expression: data type of one or both operands is inappropriate

operator * (binary)

Synopsis

#include <ProbeExp.h>
ProbeExp operator * (const ProbeExp &rhs) const;

Parameters

rhs: right operand

Description

Creates a probe expression that represents the multiplication of two operands. The invoking object represents the left operand, while the argument rhs represents the right operand. The operands may be objects in memory or expressions that evaluate to values. For example,

ProbeExp exp = lhs * rhs;

would create an expression exp that represents the multiplication of rhs by lhs. The expression exp could then be used as a sub-expression in an assignment or other type of statement or expression.

Refer to Table 12 for the data types that are permitted with this function, as well as the data type of the result.

This expression may be executed on the application process through the use of point probes or one-shot probes.

Return Values

Returns a probe expression representing the multiplication of two operands.

Exceptions

ASC_insufficient_memory: insufficient memory to create a new node
ASC_invalid_expression: data type of one or both operands is inappropriate

operator * (unary)

Synopsis

#include <ProbeExp.h>
ProbeExp operator * (void) const;

Description

Creates a probe expression that represents the dereferencing of a pointer operand. The right operand represents the invoking object. The operand may be an object in memory or an expression that evaluates to a value. For example,

ProbeExp exp = * rhs;

would create an expression exp that represents the object pointed to by the pointer value rhs. The expression exp could then be used as a sub-expression in an assignment or other type of statement or expression.

Refer to Table 12 for the data types that are permitted with this function, as well as the data type of the result.

This expression may be executed on the application process through the use of point probes or one-shot probes.

Return Values

Returns a probe expression representing the dereferencing of a pointer operand.

Exceptions

ASC_insufficient_memory: insufficient memory to create a new node
ASC_invalid_expression: data type of the operand is inappropriate

operator *=

Synopsis

#include <ProbeExp.h>
ProbeExp operator *= (const ProbeExp &rhs) const;

Parameters

rhs: right operand

Description

Creates a probe expression that represents the multiplication of two operands, and the subsequent storage of the result into the invoking object. The left operand represents the invoking object, while the argument rhs represents the right operand. The left operand must be an object in memory, while the right operand may be an object in memory or an expression that evaluates to a value. For example,

ProbeExp exp = lhs *= rhs;

would create an expression exp that represents the multiplication of two values, lhs and rhs, and its assignment to lhs. The expression exp could then be used as a sub-expression in an assignment or other type of statement or expression.

Refer to Table 12 for the data types that are permitted with this function, as well as the data type of the result.

This expression may be executed on the application process through the use of point probes or one-shot probes.

Return Values

Returns a probe expression representing the multiplication of two operands and assignment of the result.

Exceptions

ASC_insufficient_memory: insufficient memory to create a new node
ASC_invalid_expression: data type of one or both operands is inappropriate

operator /

Synopsis

#include <ProbeExp.h>
ProbeExp operator / (const ProbeExp &rhs) const;

Parameters

rhs: right operand

Description

Creates a probe expression that represents the division of two operands. The invoking object represents the left operand, while the argument rhs represents the right operand. The operands may be objects in memory or expressions that evaluate to values. For example,

ProbeExp exp = lhs / rhs;

would create an expression exp that represents the division of rhs by lhs. The expression exp could then be used as a sub-expression in an assignment or other type of statement or expression.

Refer to Table 12 for the data types that are permitted with this function, as well as the data type of the result.

This expression may be executed on the application process through the use of point probes or one-shot probes.

Return Values

Returns a probe expression representing the division of two operands.

Exceptions

ASC_insufficient_memory: insufficient memory to create a new node
ASC_invalid_expression: data type of one or both operands is inappropriate

operator /=

Synopsis

#include <ProbeExp.h>
ProbeExp operator /= (const ProbeExp &rhs) const;

Parameters

rhs: right operand

Description

Creates a probe expression that represents the division of two operands, and the subsequent storage of the result into the invoking object. The left operand represents the invoking object, while the argument rhs represents the right operand. The left operand must be an object in memory, while the right operand may be an object in memory or an expression that evaluates to a value. For example,

ProbeExp exp = lhs /= rhs;

would create an expression exp that represents the division of two values, lhs and rhs, and its assignment to lhs. The expression exp could then be used as a sub-expression in an assignment or other type of statement or expression.

Refer to Table 12 for the data types that are permitted with this function, as well as the data type of the result.

This expression may be executed on the application process through the use of point probes or one-shot probes.

Return Values

Returns a probe expression representing the division of two operands and assignment of the result.

Exceptions

ASC_insufficient_memory: insufficient memory to create a new node
ASC_invalid_expression: data type of one or both operands is inappropriate

operator %

Synopsis

#include <ProbeExp.h>
ProbeExp operator % (const ProbeExp &rhs) const;

Parameters

rhs: right operand

Description

Creates a probe expression that represents the division of two operands, where the remainder rather than the dividend is returned. The invoking object represents the left operand, while the argument rhs represents the right operand. The operands may be objects in memory or expressions that evaluate to values. For example,

ProbeExp exp = lhs % rhs;

would create an expression exp that represents the division of rhs by lhs. The expression exp could then be used as a sub-expression in an assignment or other type of statement or expression.

Refer to Table 12 for the data types that are permitted with this function, as well as the data type of the result.

This expression may be executed on the application process through the use of point probes or one-shot probes.

Return Values

Returns a probe expression representing the remainder of the division of two operands.

Exceptions

ASC_insufficient_memory: insufficient memory to create a new node
ASC_invalid_expression: data type of one or both operands is inappropriate

operator %=

Synopsis

#include <ProbeExp.h>
ProbeExp operator %= (const ProbeExp &rhs) const;

Parameters

rhs: right operand

Description

Creates a probe expression that represents the division of two operands, where the remainder rather than the dividend is returned, and the subsequent storage of the result into the invoking object. The left operand represents the invoking object, while the argument rhs represents the right operand. The left operand must be an object in memory, while the right operand may be an object in memory or an expression that evaluates to a value. For example,

ProbeExp exp = lhs %= rhs;

Refer to Table 12 for the data types that are permitted with this function, as well as the data type of the result.

This expression may be executed on the application process through the use of point probes or one-shot probes.

Return Values

Returns a probe expression representing the division of two operands and assignment of the remainder.

Exceptions

ASC_insufficient_memory: insufficient memory to create a new node
ASC_invalid_expression: data type of one or both operands is inappropriate

operator =

Synopsis

#include <ProbeExp.h>
ProbeExp &operator = (const ProbeExp &rhs);

Parameters

rhs: right operand

Description

This function does not create a probe expression tree. Rather, it performs a local assignment on the client, of the value in the right operand, to the object represented by the left operand. For example,

ProbeExp lhs; lhs = rhs;

would assign the value contained in rhs to the variable lhs. Notice that the above example is different from

ProbeExp lhs = rhs;

in that the first example invokes the assignment operator, operator =, while the second example invokes the copy constructor. Although different functions are called, the end result is the same; the probe expression represented by the right operand is assigned to the object represented by the left operand.

Refer to Table 12 for the data types that are permitted with this function, as well as the data type of the result.

This expression may be executed on the application process through the use of point probes or one-shot probes.

Return Values

Returns a reference to the invoking object (i.e., the left operand).

operator ==

Synopsis

#include <ProbeExp.h>
ProbeExp operator == (const ProbeExp &rhs) const;

Parameters

rhs: right operand

Description

Creates a probe expression that represents a comparison for equality of two operands, where 1 is returned if they are equal, and 0 is returned if they are not. The invoking object represents the left operand, while the argument rhs represents the right operand. The operands may be objects in memory or expressions that evaluate to values. For example,

ProbeExp exp = lhs == rhs;

would create an expression exp that represents a comparison for equality of rhs and lhs. The expression exp could then be used as a sub-expression in an assignment or other type of statement or expression.

Refer to Table 12 for the data types that are permitted with this function, as well as the data type of the result.

This expression may be executed on the application process through the use of point probes or one-shot probes.

Return Values

Returns a probe expression representing the comparison of two operands for equality.

Exceptions

ASC_insufficient_memory: insufficient memory to create a new node
ASC_invalid_expression: data type of one or both operands is not an integer

operator !

Synopsis

#include <ProbeExp.h>
ProbeExp operator ! (void) const;

Description

Creates a probe expression that represents the logical negation of an operand, where 0 is returned if the operand is a non-zero value, and 1 is returned if the operand is 0. The right operand represents the invoking object. The operand may be an object in memory or an expression that evaluates to a value. For example,

ProbeExp exp = ! rhs;

would create an expression exp that represents the negation of rhs. The expression exp could then be used as a sub-expression in an assignment or other type of statement or expression.

Refer to Table 12 for the data types that are permitted with this function, as well as the data type of the result.

This expression may be executed on the application process through the use of point probes or one-shot probes.

Return Values

Returns a probe expression representing the negation of an operand.

Exceptions

ASC_insufficient_memory: insufficient memory to create a new node
ASC_invalid_expression: data type of the operand is inappropriate

operator !=

Synopsis

#include <ProbeExp.h>
ProbeExp operator != (const ProbeExp &rhs) const;

Parameters

rhs: right operand

Description

Creates a probe expression that represents a comparison for inequality of two operands, where 0 is returned if they are equal, and 1 is returned if they are not. The invoking object represents the left operand, while the argument rhs represents the right operand. The operands may be objects in memory or expressions that evaluate to values. For example,

ProbeExp exp = lhs != rhs;

Refer to Table 12 for the data types that are permitted with this function, as well as the data type of the result.

This expression may be executed on the application process through the use of point probes or one-shot probes.

Return Values

Returns a probe expression representing the comparison of two operands for inequality.

Exceptions

ASC_insufficient_memory: insufficient memory to create a new node
ASC_invalid_expression: data type of one or both operands is not an integer

operator <

Synopsis

#include <ProbeExp.h>
ProbeExp operator < (const ProbeExp &rhs) const;

Parameters

rhs: right operand

Description

Creates a probe expression that represents a comparison of two operands, where 1 is returned if the left operand is less than the right operand, and 0 is returned otherwise. The invoking object represents the left operand, while the argument rhs represents the right operand. The operands may be objects in memory or expressions that evaluate to values. For example,

ProbeExp exp = lhs < rhs;

would create an expression exp that represents a comparison of rhs and lhs. The expression exp could then be used as a sub-expression in an assignment or other type of statement or expression.

Refer to Table 12 for the data types that are permitted with this function, as well as the data type of the result.

This expression may be executed on the application process through the use of point probes or one-shot probes.

Return Values

Returns a probe expression representing the comparison of two operands for relative size.

Exceptions

ASC_insufficient_memory: insufficient memory to create a new node
ASC_invalid_expression: data type of one or both operands is not an integer

operator <=

Synopsis

#include <ProbeExp.h>
ProbeExp operator <= (const ProbeExp &rhs) const;

Parameters

rhs: right operand

Description

This function creates a probe expression that represents a comparison of two operands, where 1 is returned if the left is less than or equal to the right, and 0 is returned otherwise. The invoking object represents the left operand, while the argument rhs represents the right operand. The operands may be objects in memory or expressions that evaluate to values. For example,

ProbeExp exp = lhs <= rhs;

Refer to Table 12 for the data types that are permitted with this function, as well as the data type of the result.

This expression may be executed on the application process through the use of point probes or one-shot probes.

Return Values

Returns a probe expression representing the comparison of two operands for relative size.

Exceptions

ASC_insufficient_memory: insufficient memory to create a new node
ASC_invalid_expression: data type of one or both operands is not an integer

operator <<

Synopsis

#include <ProbeExp.h>
ProbeExp operator << (const ProbeExp &rhs) const;

Parameters

rhs: right operand

Description

Creates a probe expression that represents a bit-wise left shift of the left operand. When the right operand is positive, the value returned is the left operand shifted that many places to the left. When the right operand is 0, the value returned is the value of the left operand. When the right operand is negative, the shift operation is not defined, and the value returned is not predictable. The invoking object represents the left operand, while the argument rhs represents the right operand. The operands may be objects in memory or expressions that evaluate to values. For example,

ProbeExp exp = lhs << rhs;

would create an expression exp that represents a left shift of lhs. The expression exp could then be used as a sub-expression in an assignment or other type of statement or expression.

Refer to Table 12 for the data types that are permitted with this function, as well as the data type of the result.

This expression may be executed on the application process through the use of point probes or one-shot probes.

Return Values

Returns a probe expression representing the left shift of the left operator.

Exceptions

ASC_insufficient_memory: insufficient memory to create a new node
ASC_invalid_expression: data type of one or both operands is not an integer

operator <<=

Synopsis

#include <ProbeExp.h>
ProbeExp operator <<= (const ProbeExp &rhs) const;

Parameters

rhs: right operand

Description

Creates a probe expression that represents a bit-wise left shift of the left operand. When the right operand is positive, the value returned is left operand shifted that many places to the left. When the right operand is 0, the value returned is the value of the left operand. When the right operand is negative, the shift operation is not defined, and the value returned is unpredictable. The result is subsequently stored in the invoking object. The left operand represents the invoking object, while the argument rhs represents the right operand. The left operand must be an object in memory, while the right operand may be an object in memory or an expression that evaluates to a value. For example,

ProbeExp exp = lhs <<= rhs;

would create an expression exp that represents the left shift of lhs by rhs, and its assignment to lhs. The expression exp could then be used as a sub-expression in an assignment or other type of statement or expression.

Refer to Table 12 for the data types that are permitted with this function, as well as the data type of the result.

This expression may be executed on the application process through the use of point probes or one-shot probes.

Return Values

Returns a probe expression representing a left bit-wise shift and assignment of the result.

Exceptions

ASC_insufficient_memory: insufficient memory to create a new node
ASC_invalid_expression: data type of one or both operands is inappropriate

operator >

Synopsis

#include <ProbeExp.h>
ProbeExp operator > (const ProbeExp &rhs) const;

Parameters

rhs: right operand

Description

Creates a probe expression that represents a comparison of two operands, where 1 is returned if the left operand is greater than the right operand, and 0 is returned otherwise. The invoking object represents the left operand, while the argument rhs represents the right operand. The operands may be objects in memory or expressions that evaluate to values. For example,

ProbeExp exp = lhs > rhs;

Refer to Table 12 for the data types that are permitted with this function, as well as the data type of the result.

This expression may be executed on the application process through the use of point probes or one-shot probes.

Return Values

Returns a probe expression representing the comparison of two operands for relative size.

Exceptions

ASC_insufficient_memory: insufficient memory to create a new node
ASC_invalid_expression: data type of one or both operands is not an integer

operator >=

Synopsis

#include <ProbeExp.h>
ProbeExp operator >= (const ProbeExp &rhs) const;

Parameters

rhs: right operand

Description

Creates a probe expression that represents a comparison of two operands, where 1 is returned if the left is greater than or equal to the right. Otherwise, 0 is returned. The invoking object represents the left operand, while the argument rhs represents the right operand. The operands may be objects in memory or expressions that evaluate to values. For example,

ProbeExp exp = lhs >= rhs;

Refer to Table 12 for the data types that are permitted with this function, as well as the data type of the result.

This expression may be executed on the application process through the use of point probes or one-shot probes.

Return Values

Returns a probe expression representing the comparison of two operands for relative size.

Exceptions

ASC_insufficient_memory: insufficient memory to create a new node
ASC_invalid_expression: data type of one or both operands is not an integer

operator >>

Synopsis

#include <ProbeExp.h>
ProbeExp operator >> (const ProbeExp &rhs) const;

Parameters

rhs: right operand

Description

Creates a probe expression that represents a bit-wise right shift of the left operand. When the right operand is positive, the value returned is the left operand shifted that many places to the right. When the right operand is 0, the value returned is the value of the left operand. When the right operand is negative, the shift operation is not defined, and the value returned is unpredictable. The invoking object represents the left operand, while the argument rhs represents the right operand. The operands may be objects in memory or expressions that evaluate to values. For example,

ProbeExp exp = lhs >> rhs;

would create an expression exp that represents a left shift of lhs. The expression exp could then be used as a sub-expression in an assignment or other type of statement or expression.

Refer to Table 12 for the data types that are permitted with this function, as well as the data type of the result.

This expression may be executed on the application process through the use of point probes or one-shot probes.

Return Values

Returns a probe expression representing the right shift of the left operator.

Exceptions

ASC_insufficient_memory: insufficient memory to create a new node
ASC_invalid_expression: data type of one or both operands is not an integer

operator >>=

Synopsis

#include <ProbeExp.h>
ProbeExp operator >>= (const ProbeExp &rhs) const;

Parameters

rhs: right operand

Description

Creates a probe expression that represents a bit-wise right shift of the left operand. When the right operand is positive, the value returned is left operand shifted that many places to the right. When the right operand is 0, the value returned is the value of the left operand. When the right operand is negative, the shift operation is not defined, and the value returned is unpredictable. The result is subsequently stored into the invoking object. The left operand represents the invoking object, while the argument rhs represents the right operand. The left operand must be an object in memory, while the right operand may be an object in memory or an expression that evaluates to a value. For example,

ProbeExp exp = lhs >>= rhs;

would create an expression exp that represents the right shift of lhs by rhs, and its assignment to lhs. The expression exp could then be used as a sub-expression in an assignment or other type of statement or expression.

Refer to Table 12 for the data types that are permitted with this function, as well as the data type of the result.

This expression may be executed on the application process through the use of point probes or one-shot probes.

Return Values

Returns a probe expression representing a right bit-wise shift and assignment of the result.

Exceptions

ASC_insufficient_memory: insufficient memory to create a new node
ASC_invalid_expression: data type of one or both operands is inappropriate

operator & (binary)

Synopsis

#include <ProbeExp.h>
ProbeExp operator & (const ProbeExp &rhs) const;

Parameters

rhs: right operand

Description

Creates a probe expression that represents a bit-wise and of the left and right operands. The invoking object represents the left operand, while the argument rhs represents the right operand. The operands may be objects in memory or expressions that evaluate to values. For example,

ProbeExp exp = lhs & rhs;

would create an expression exp that represents a bit-wise and of lhs and rhs. The expression exp could then be used as a sub-expression in an assignment or other type of statement or expression.

Refer to Table 12 for the data types that are permitted with this function, as well as the data type of the result.

This expression may be executed on the application process through the use of point probes or one-shot probes.

Return Values

Returns a probe expression representing the bit-wise andof the left and right operands.

Exceptions

ASC_insufficient_memory: insufficient memory to create a new node
ASC_invalid_expression: data type of one or both operands is not an integer

operator & (unary)

Synopsis

#include <ProbeExp.h>
ProbeExp *operator & (void);

Description

Computes and returns the address of the invoking object on the client. This function does not create a probe expression tree. For example, the probe expression

ProbeExp *ptr = &obj;

would store a pointer to the object obj in the pointer ptr. In order to allow C++ to pass objects by reference, it is necessary that the function work in this manner (not create an expression tree).

Refer to Table 12 for the data types that are permitted with this function, as well as the data type of the result.

This expression may be executed on the application process through the use of point probes or one-shot probes.

Return Values

Returns a pointer to the invoking object on the client.

operator &=

Synopsis

#include <ProbeExp.h>
ProbeExp operator &= (const ProbeExp &rhs) const;

Parameters

rhs: right operand

Description

Creates a probe expression that represents a bit-wise and of the operands. The result is subsequently stored in the invoking object. The left operand represents the invoking object, while the argument rhs represents the right operand. The left operand must be an object in memory, while the right operand may be an object in memory or an expression that evaluates to a value. For example,

ProbeExp exp = lhs &= rhs;

would create an expression exp that represents the bit-wise and of lhs and rhs, and its assignment to lhs. The expression exp could then be used as a sub-expression in an assignment or other type of statement or expression.

Refer to Table 12 for the data types that are permitted with this function, as well as the data type of the result.

This expression may be executed on the application process through the use of point probes or one-shot probes.

Return Values

Returns a probe expression representing a bit-wise and, and assignment of the result.

Exceptions

ASC_insufficient_memory: insufficient memory to create a new node
ASC_invalid_expression: data type of one or both operands is inappropriate

operator &&

Synopsis

#include <ProbeExp.h>
ProbeExp operator && (const ProbeExp &rhs) const;

Parameters

rhs: right operand

Description

Creates a probe expression that represents a logical and of two operands, where 1 is returned if both operands are non-zero, and 0 is returned if one or more are not. The invoking object represents the left operand, while the argument rhs represents the right operand. The operands may be objects in memory or expressions that evaluate to values. For example,

ProbeExp exp = lhs && rhs;

would create an expression exp that represents a logical and of rhs and lhs. The expression exp could then be used as a sub-expression in an assignment or another type of statement or expression.

Refer to Table 12 for the data types that are permitted with this function, as well as the data type of the result.

This expression may be executed on the application process through the use of point probes or one-shot probes.

Return Values

Returns a probe expression representing the logical and of two operands.

Exceptions

ASC_insufficient_memory: insufficient memory to create a new node
ASC_invalid_expression: data type of one or both operands is not an integer

operator |

Synopsis

#include <ProbeExp.h>
ProbeExp operator | (const ProbeExp &rhs) const;

Parameters

rhs: right operand

Description

Creates a probe expression that represents a bit-wise or of the left and right operands. The invoking object represents the left operand, while the argument rhs represents the right operand. The operands may be objects in memory or expressions that evaluate to values. For example,

ProbeExp exp = lhs | rhs;

would create an expression exp that represents a bit-wise or of lhs and rhs. The expression exp could then be used as a sub-expression in an assignment or other type of statement or expression.

Refer to Table 12 for the data types that are permitted with this function, as well as the data type of the result.

This expression may be executed on the application process through the use of point probes or one-shot probes.

Return Values

Returns a probe expression representing the bit-wise or of the left and right operands.

Exceptions

ASC_insufficient_memory: insufficient memory to create a new node
ASC_invalid_expression: data type of one or both operands is not an integer

operator |=

Synopsis

#include <ProbeExp.h>
ProbeExp operator |= (const ProbeExp &rhs) const;

Parameters

rhs: right operand

Description

Creates a probe expression that represents a bit-wise or of the operands. The result is subsequently stored in the invoking object. The left operand represents the invoking object, while the argument rhs represents the right operand. The left operand must be an object in memory, while the right operand may be an object in memory or an expression that evaluates to a value. For example,

ProbeExp exp = lhs |= rhs;

would create an expression exp that represents the bit-wise or of lhs and rhs, and its assignment to lhs. The expression exp could then be used as a sub-expression in an assignment or other type of statement or expression.

Refer to Table 12 for the data types that are permitted with this function, as well as the data type of the result.

This expression may be executed on the application process through the use of point probes or one-shot probes.

Return Values

Returns a probe expression representing a bit-wise or and assignment of the result.

Exceptions

ASC_insufficient_memory: insufficient memory to create a new node
ASC_invalid_expression: data type of one or both operands is inappropriate

operator ||

Synopsis

#include <ProbeExp.h>
ProbeExp operator || (const ProbeExp &rhs) const;

Parameters

rhs: right operand

Description

Creates a probe expression that represents a logical or operator of two operands, where 1 is returned if at least one operand is non-zero, and 0 is returned if both are zero. The invoking object represents the left operand, while the argument rhs represents the right operand. The operands may be objects in memory or expressions that evaluate to values. For example,

ProbeExp exp = lhs || rhs;

would create an expression exp that represents a logical or of rhs and lhs. The expression exp could then be used as a sub-expression in an assignment or other type of statement or expression.

Refer to Table 12 for the data types that are permitted with this function, as well as the data type of the result.

This expression may be executed on the application process through the use of point probes or one-shot probes.

Return Values

Returns a probe expression representing the logical or of two operands.

Exceptions

ASC_insufficient_memory: insufficient memory to create a new node
ASC_invalid_expression: data type of one or both operands is not an integer

operator ^

Synopsis

#include <ProbeExp.h>
ProbeExp operator ^ (const ProbeExp &rhs) const;

Parameters

rhs: right operand

Description

Creates a probe expression that represents a bit-wise exclusive-or of the left and right operands. The invoking object represents the left operand, while the argument rhs represents the right operand. The operands may be objects in memory or expressions that evaluate to values. For example,

ProbeExp exp = lhs ^ rhs;

would create an expression exp that represents a bit-wise exclusive-or of lhs and rhs. The expression exp could then be used as a sub-expression in an assignment or other type of statement or expression.

Refer to Table 12 for the data types that are permitted with this function, as well as the data type of the result.

This expression may be executed on the application process through the use of point probes or one-shot probes.

Return Values

Returns a probe expression representing the bit-wise exclusive-or of the left and right operands.

Exceptions

ASC_insufficient_memory: insufficient memory to create a new node
ASC_invalid_expression: data type of one or both operands is not an integer

operator ^=

Synopsis

#include <ProbeExp.h>
ProbeExp operator ^= (const ProbeExp &rhs) const;

Parameters

rhs: right operand

Description

Creates a probe expression that represents a bit-wise exclusive-or of the operands. The result is subsequently stored in the invoking object. The left operand represents the invoking object, while the argument rhs represents the right operand. The left operand must be an object in memory, while the right operand may be an object in memory or an expression that evaluates to a value. For example,

ProbeExp exp = lhs ^= rhs;

would create an expression exp that represents the bit-wise exclusive-or of lhs and rhs, and its assignment to lhs. The expression exp could then be used as a sub-expression in an assignment or another type of statement or expression.

Refer to Table 12 for the data types that are permitted with this function, as well as the data type of the result.

This expression may be executed on the application process through the use of point probes or one-shot probes.

Return Values

Returns a probe expression representing a bit-wise exclusive-or and assignment of the result.

Exceptions

ASC_insufficient_memory: insufficient memory to create a new node
ASC_invalid_expression: data type of one or both operands is inappropriate

operator ~

Synopsis

#include <ProbeExp.h>
ProbeExp operator ~ (void) const;

Description

Creates a probe expression that represents the bit-wise inversion (1's complement) of an operand. The right operand represents the invoking object. The operand may be an object in memory or an expression that evaluates to a value. For example,

ProbeExp exp = ~ rhs

would create an expression exp that represents the inversion of rhs. The expression exp could then be used as a sub-expression in an assignment or other type of statement or expression.

Refer to Table 12 for the data types that are permitted with this function, as well as the data type of the result.

This expression may be executed on the application process through the use of point probes or one-shot probes.

Return Values

Returns a probe expression representing the bit-wise inversion of an operand.

Exceptions

ASC_insufficient_memory: insufficient memory to create a new node
ASC_invalid_expression: data type of the operand is inappropriate

operator []

Synopsis

#include <ProbeExp.h>
ProbeExp operator [] (int index) const;
ProbeExp operator [] (ProbeExp index) const;

Parameters

index: index in the array or pointer offset

Description

Creates a probe expression that represents the indexing and dereferencing of a pointer operand. The invoking object represents the left (pointer) operand, while the argument index represents the right (index) operand. The operands may be objects in memory or expressions that evaluate to values. For example,

ProbeExp exp = lhs [rhs];

would create an expression exp that represents accessing the element (rhs) of the array (lhs). The expression exp could then be used as a sub-expression in an assignment or other type of statement or expression.

Refer to Table 12 for the data types that are permitted with this function, as well as the data type of the result.

This expression may be executed on the application process through the use of point probes or one-shot probes.

Return Values

Returns a probe expression representing the indexing and dereferencing of the left and right operands.

Exceptions

ASC_insufficient_memory: insufficient memory to create a new node
ASC_invalid_expression: data type of one or both operands is inappropriate

sequence

Synopsis

#include <InstPoint.h>
#include <ProbeExp.h>
ProbeExp sequence(const ProbeExp &second) const;

Parameters

second: second expression in the sequence

Description

Creates a probe expression that represents the joining of two probe expressions into a sequence. The invoking object represents the first expression in the sequence to be executed, while the argument second represents the second expression to be executed. The operands may be objects in memory or expressions that evaluate to values. For example,

ProbeExp exp = first.sequence(second);

would create an expression exp that represents the execution of first followed by second. The expression exp could then be used as a sub-expression in a conditional expression, a sequence, or other type of statement or expression.

Refer to Table 12 for the data types that are permitted with this function, as well as the data type of the result.

This expression may be executed on the application process through the use of point probes or one-shot probes.

Return Values

Returns a probe expression representing the sequencing of two expressions.

Exceptions

ASC_insufficient_memory: insufficient memory to create a new node

value_center

Synopsis

#include <InstPoint.h>
ProbeExp value_center(void) const

Description

Returns the value of the indicated child of the node being queried.

Exceptions

ASC_invalid_value_ref: the object in question does not have a center subtree

Return Values

Returns the value, of the indicated type, contained within the node.

See Also

has_center, has_children, has_left, has_right, value_left, value_right

value_float*

Synopsis

#include <InstPoint.h>
int value_int32(void) const;
int value_int64(void) const;

Description

This family of functions returns the floating-point value contained within the node being queried. For a value of a given size, the query for that data type, or for any larger data type, is permitted. For example, if a node contains a 32-bit floating-point value, then both value_float32 and value_float64 return the node's value. However, value_float8 and value_float16 will throw an exception.

Exceptions

ASC_invalid_value_ref: for value_float32, value of object in question is not float32
for value_float64, value of object in question is not float64 or float32

See Also

has_float32, has_float64

value_int*

Synopsis

#include <InstPoint.h>
int8_t value_int8(void) const;
int16_t value_int16(void) const;
int32_t value_int32(void) const;
int64_t value_int64(void) const;

Description

This family of functions returns the integer value contained within the node being queried. For a value of a given size, the query for that data type, or for any larger data type, is permitted. For example, if a node contains a 32-bit integer value, then both value_int32 and value_int64 return the node's value. However, value_int8 and value_int16 will throw an exception.

Exceptions

ASC_invalid_value_ref

for value_int8, value of object in question is not int8

for value_int16, value of object in question is not int16 or int8

for value_int32, value of object in question is not int32, int16, or int8

for value_int64, value of object in question is not int64, int32, int16, or int8

Return Values

Returns the value, of the indicated type, contained within the node.

See Also

has_int8, has_int16, has_int32, has_int64.

value_left

Synopsis

#include <InstPoint.h>
ProbeExp value_left(void) const;

Description

Returns the value of the indicated child of the node being queried.

Exceptions

ASC_invalid_value_ref: the object in question does not have a left subtree

Return Values

Returns the value of the indicated type, contained within the node.

See Also

has_center, has_children, has_left, has_right, value_center, value_right.

value_right

Synopsis

#include <InstPoint.h>
ProbeExp value_right(void) const;

Description

Returns the value of the indicated child of the node being queried.

Exceptions

ASC_invalid_value_ref: the object in question does not have a right subtree

Return Values

Returns the value of the indicated type, contained within the node.

See Also

has_center, has_children, has_left, has_right, value_center, value_left.

value_text

Synopsis

#include <InstPoint.h>
char *value_text(
    char *buffer,
    unsigned int len) const;

Parameters

buffer: caller-allocated buffer that holds the text value
len: maximum number of bytes the function will place in buffer. The len parameter should include enough space for a null-terminating byte.

Description

Copies into buffer a null-terminated character string that represents the value contained within the node. The value may be truncated if the len parameter is smaller than the length of the text value.

Exceptions

ASC_invalid_value_ref: the object in question does not have a text value

Return Values

Returns a pointer to buffer, which contains, at most, len bytes of the text value contained within the node, or NULL if there is no text value contained within the node.

See Also

value_text_length

value_text_length

Synopsis

#include <InstPoint.h>
unsigned int value_text_length(void) const;

Description

Returns the length, including the null-terminating byte, of the text value contained within the node.

Return Values

Returns the length of the text value contained within the node, or 0 if there is no text value contained within the node.

See Also

value_text

value_uint*

Synopsis

#include <InstPoint.h>
uint8_t value_uint8(void) const;
uint16_t value_uint16(void) const;
uint32_t value_uint32(void) const;
uint64_t value_uint64(void) const;

Description

This family of functions returns the unsigned integer value contained within the node being queried. For a value of a given size, the query for that data type, or for any larger data type, is permitted. For example, if a node contains a 32-bit integer value, then both value_uint32 and value_uint64 return the node's value. However, value_uint8 and value_uint16 will throw an exception.

Exceptions

ASC_invalid_value_ref

for value_uint8, value of object in question is not uint8

for value_uint16, value of object in question is not uint16 or uint8

for value_uint32, value of object in question is not uint32, uint16, or uint8

for value_uint64, value of object in question is not uint64, uint32, uint16, or uint8

Return Values

Returns the value of the indicated type, contained within the node.

See Also

has_int8, has_int16, has_int32, has_int64.

[ Top of Page | Previous Page | Next Page | Table of Contents | Index ]