The _lcase() function converts the input string to lower case. The _lcase() function uses the following format:

_lcase(input)

The _ucase() function converts the input string to upper case. The _ucase() function uses the following format:

_ucase(input)

The _trim() function removes leading and trailing white spaces from a string. This includes blanks, tabs, and carriage returns. Whitespace includes blanks, tabs, carriage returns, and any characters defined for the current locale as a whitespace character. The _trim() function uses the following format:

_trim(input)

The _normalizespace() function removes leading and trailing white spaces from a string. This includes blanks, tabs, carriage returns, and any characters defined for the current locale as a whitespace character. Within the string multiple blanks are converted to a single blank. For example, if the dot character represents a space, _normalizespace('ab…c') yields 'ab.c'.

The _normalizespace() function uses the following format:

_normalizespace(input)

The _entity() function replaces XML characters with entities, for example, A&B becomes A&B.

The _entity() function uses the following format:

_entity(input)

The _deentity() function replaces XML entities with characters, for example, A&B becomes A&B.

The _deentity() function uses the following format:

_deentity(input)

The _substr() function extracts a substring from the input string. The substring begins at the starting position and extends to the ending position, which is not included in the substring. If a specific ending position is omitted, the substring extends to the end of the input string. For example, _substr('abcde',1,3) returns bc.

The _substr() function uses the following format:

_substr(input, start [,end])

The _before() function extracts a substring from the input string. The substring begins at the start of the string and extends to the ending string, which is not included in the substring. If omitted, the substring extends to the end of the input string. For example, _before('abcde','de') returns abc.

The _before() function uses the following format:

_before(input, pattern)

The _after() function extracts a substring from the input string. The substring begins at the start trigger and extends to the end of the string. For example, _after('abcde','bc') returns de.

The _after() function uses the following format:

_after(input, pattern)

_pad(input, length [,type [,character [,control]]])

input	string	The string value to be operated upon.
length	integer	Length of desired output.
type	keyword	Direction of the padding. Right Pad on the right of the input (default). Left Pad on the left of the input (right justification).
character	char	One character to be used for padding. Default is blank.
control	keyword	Final disposition of the output asis Take no action following padding (default). cut Cut output to length if input is too long.

The input string is padded and optionally cut to fit an exact length. Padding can be done to the right or left of the string.

For example, given the input abc, the following will be the result, using the character b for blank:

The _concat() function joins together to generate a single string. For example, if special register x holds the letter 'b', _concat('a',sreg(x),'c') returns abc.

The compiler attempts automatic concatenation when functions are recognized in input strings. For example, the special register iway.home holds the root of the iWay Server installation. So if you want to address a file named myfile.txt in the mydir subdirectory off the iWay root, use of sreg('iway.home')/mydir/myfile.txt will return the correct path name.

The _concat() function uses the following format:

_concat(input*)

The _length() function returns the number of characters in the supplied input string. It uses the following format:

_length(input)

The _count() function returns the number of items in the supplied input string. It uses the following format:

_count(input [,action][,delim])

<a>
     <top>
     <b>one</b>
     <b>two</b>
      <x>sreg(iwayhome)</x>
     </top>
</a>

The _contains() function returns true if the input string contains the value. The search is case sensitive. The _contains() function uses the following format:

_contains(input, value)

The _startswith() function returns true if the input string starts with the value. For example, _startswith('iWay Software','iW') yields true. The _startswith() function uses the following format:

_startswith(input, value)

The _endswith() function returns true if the input string ends with the value. It uses the following format:

_endswith(input, value)

The _regex() function searches an input string via the regular expression. Any matches are replaced with the value that is specified for the replacement parameter. Regular expressions are specifications of what is to be located and where, for example, locating the first carriage return. The _regex() function uses the following format:

_regex(input, pattern, replacement)

_regex('scat, cat','\\bcat','dog')

_replace(input, chars ,replacements)

input	string	The string to be operated upon.
chars	string	The characters in the string to be replaced.
replacements	string	The replacement characters.

The input string is searched for the designated characters. Each located character in the chars operand is replaced with the replacements operand.

The characters in the chars and replacements operands are replaced on a one-forone basis. The first character in the chars operand is replaced by the first character in the replacements operand, and so forth. Any ASCII character can be entered into either operand. Additionally, escaped sequences, each representing one character, can be included in the operands.

\n	New line
\t	Tab
\r	Line feed
\\	Backslash
\"	Double quote
\'	Single quote
\xcc	Hex character, where cc is the hex representation. Example \x01 is hex 01.

Example: replace all bar characters with commas. This example is important, as the _xpath functions return lists of values separated by bars.

_replace(_xpath(/root/childval),'|',',')

Example: replace all new lines with tabs.

_replace(sreg(values),\n,\t)

The _isnumber() function tests whether the input is a valid number. A value of true indicates that the input is numeric and false indicates that it is not numeric or is not present. Use this to test the results from functions that are expected to return numeric output but may return NAN (not a number) or another value.

The _isnumber() function uses the following format:

_isnumber (input)

The _xml() function treats the input string as XML for parsing purposes. Functional replacement is performed but math operations are ignored. If the XML string is in literals, the entire string is treated as a single literal, and no further operation takes place. However if the literal marks (single quotes) are omitted, the parameter can be evaluated.

In the following example, assume that a special register portno has been set to 3284.

_xml(input)

The input string is treated as a string for parsing purposes. Functional replacement is performed but math operations are ignored. This operates identically to _xml().

The _sql() function uses the following format:

_sql(input)

This function generates a quoted string of the input operand; optionally the string NULL can be produced. This function is useful when generating values for an SQL insert or update DML statement.

The _qval() function uses the following format:

_qval(input [,char [,action]]))

values(_qval(a))

values(?a)

xpath(/root/field)

Given a delimited string, this function splits the string on the specified delimiter and returns the token at the requested index. The delimiter can be a regular expression and the index of the first token is 1. This function returns an empty string if:

• The delimiter is an invalid regular expression.
• The index parameter can not be parsed as an integer.
• The index parameter is less than 1 or greater than the number of tokens after splitting.

The _token() function uses the following format:

_token(input, delimiter, index)

_token('a,b,c,d,e', ',', 3) = c
_token('a/b/c/d/e', '/', 3) = c
_token('a/b/c/d/e', '/', 18) = empty
_token('a_split_b_split_c_split_','_split_',3)=c

_token("ax%%%xbx%%%pcx%%%xdx%%%pe",'x\%{3}[xp]', 3)=c

The _indexof() function uses the following format:

_indexof(input, pattern [,startat])

The _printable() function uses the following format:

_printable(input [,keyword])