LabeLase® Designer

Function Processor

LabeLase® Designer has a built-in function processor that allows you to perform string, mathematical and logical operations on text fields or barcode contents.

The function evaluator is specifically designed for text string processing. All function arguments and results are text strings by their nature, although some functions interpret strings as numbers and some return results are numbers represented as strings.

Functions can be embedded anywhere within a text string, and upon evaluation, will be replaced by the result of the function computation. Any number of functions can be included in a single text field, and functions may be nested to any level.

Each function begins with a special sequence that identifies the start of a function. This sequence is the combination of a colon and an equal sign ":=". Immediately following this start sequence is the name of the function. All function names are followed by an argument list with zero or more arguments enclosed in parentheses.

For example, the "concat" function simply returns its argument list combined (or concatenated) as a single string as shown below (note that in all examples, double quotes enclose the strings for clarity only and are not required):

Notice that in all examples, the function is surrounded by text strings "ABC" and "DEF" that are copied directly to the output. In the first example, the arguments to the concat function are placed directly next to each other with no intervening space. This is because the second argument immediately follows the comma, which separates the arguments. The second example corrects this by placing a comma before the word "World".

The third example above produces the same same result as the second, but is perhaps more obvious since the space character is part of the argument to the second, nested concat function.

The fourth example also produces the desired result by using the anonymous function - simply leave off the function name - which is the same as the concat function.

Function Arguments

Functions take zero or more arguments. Functions will ignore arguments beyond their required number, except for those functions that take an unlimited number of arguments.

Arguments are separated from each other by commas. Spaces within arguments are significant as shown in the examples above, unless the argument is itself a function call. For example, in a reworking of the third example above, the added spaces before the nested concat function call are ignored and not part of the output result:

"ABC :=concat(Hello,      concat( World)) DEF"

"ABC Hello World DEF"

If you don't supply the minimum number of arguments for a function, you will receive an error flag in the result text.

Argument Types

The function processor is designed to handle text strings, so all arguments are fundamentally just text. However, some functions treat text strings as numbers or logical values.

Return Results

Each function returns a result that is a text string by nature. However, just like function arguments, return results may be interpreted as numbers or logical values depending on the function.

The return result of the outer level function is always embedded into the surrounding text, even if the return result is a null string (empty).

Error Messages

If you have an error in your formula, the processor will insert an error message into the result string. The error message begins and ends with an exclamation point. If the error is specific to a function, the function name will follow the first exclamation point. The type of error follows the function name.

Function Reference

The following functions are supported by Producer for both text and barcode fields:

String Functions

Mathematical Functions

Logical Functions

Miscellaneous Functions