Category: ZIM 4GL Language Reference

Except in certain limited instances (e.g., security passwords, values held in objects of data type CHAR and VARCHAR), the software is case insensitive. Insensitivity to case means that the software makes no distinction between uppercase and lowercase letters in any part of a statement. For example, the following statements are identical, provided LastName is not a CHAR or VARCHAR field:

list all employees where lastname = ‘smith’

LIST ALL EMPLOYEES WHERE LASTNAME = ‘SMITH’

lIsT aLl EmPlOyEeS wHeRe LaStNaMe = ‘SmItH’

list all employees where LastName = ‘Smith’

Normally, in a statement, you can use the combination of uppercase and lowercase letters that makes the statement most readable.

Any value expression used in an application – including the names of objects that represent values – must conform to one of the available data types.

Data Types and Objects

Objects that represent values (constants, variables, fields and form fields) have an explicit data type attribute defined in the Object Dictionary. Value expressions that are not defined objects take implicit data types. The data type of an object or expression determines the values that an object or expression can represent and how the software handles the value. The software recognizes nine different data types:

Output masks are employed to format the output of fields, form fields, and data values in output operations. The MASK format option in Zim Reports specifies an output mask pattern for a report item. The $mask function specifies an output masking pattern to be applied to fields, form fields, and data values and returns a character string with the result of the masking operation. The Field Mask attribute defines the expected output format of a field’s data value when it is printed or listed in Zim Reports, or by the list or output commands.   Mask patterns used with any of the three options described above are constructed in the same manner using the same set of available characters. However, the set of characters available varies according to the data type of the item being masked. For more information on mask patterns and their relation to data types, see Masking.

Selected Examples of Mask Patterns for Numbers

In the following examples, leading or trailing spaces are indicated by / in the Output column.

Output of Sign Placeholders

Behaviour of Fixed Text Characters

Behaviour of Float Characters

Mask Patterns and the Language Customizer

Certain characters inserted into the output value by a mask are defined internally in the software. The Language Customizer (ZIMLANG) administrative utility is used to redefine the internal characters and strings used by the software in a variety of circumstances, such as output masks.

For example, the currency placeholder $,  is by default the dollar sign $. However, it can be redefined to output other symbols, such as the Euro sign €, the pound sign  £, etc. To achieve this, the Language Customizer can redefine the currency symbol output by the currency placeholder.

When using the Language Customizer to edit the software’s internal characters and strings, note the following:

• In application programs, output masks are always specified using the standard mask pattern characters. This rule applies to mask patterns specified in reports, in field and form field definitions, and in the $mask function.
• In user interface displays and output, the characters output by a mask pattern are determined by the software’s internal values.

For example, in Zim application programs, the dollar sign $ is universally used as the currency placeholder. However, the currency symbol output by the placeholder depends on the current language customization (if any).

Any meaningful combination of the following options can be applied to any value displayed in a report:

Triggers an exception handler in the absence of an exception condition.

Syntax

SET EXCEPTION condition

Parameters

Comments

A SET EXCEPTION command mimics the specified condition, triggering the associated exception handler, if such a handler has been declared (by the ON command). The SET EXCEPTION command cannot be used in the body of an exception handler. The SET EXCEPTION command has no effect on system variables such as $InTransaction, $ErrCode, or $ErrLevel. The SET EXCEPTION command is not affected by the SET RESET and SET RESTORE commands.

Example

localprocedure LocProc (inout $Deadlock)
   on deadlock
      let $Deadlock = $true
      return
   endon
   ... other commands ...
endprocedure
procedure MainProc ()
   on deadlock
      goto RetryTransaction
   endon
   ... other commands ...
RetryTransaction:
   transaction
   ... other commands ...
   LocProc ($Deadlock)
   if $Deadlock = $true
      set exception deadlock
   endif
   ... other commands ...
   endtransaction
endprocedure

In the preceding example, SET EXCEPTION mimics a DEADLOCK condition, triggering the declared deadlock exception handler in one procedure when the deadlock has actually occurred in another procedure.

See Also

ON

A macro is a dynamically declared name that represents a character string. When a macro call is encountered in an application program the macro call is replaced by the current character string value of the macro. Macros are sometimes called replacement parameters or substitution variables.
The following topics discuss how to work with macros in applications:

The name of the file containing the online help.

Syntax

$helpfile

Return Value

A character string. Can be reset by an application program.

Description

$HelpFile gives the name of a file containing online help topics.
Set by the application program to the name of a file containing the online help information. By changing the value of $HelpFile, an application can use different help files at different times during a session. The default help file is ZIM.HLP.
The file name should include the directory path. The special file path indicator characters can be used.

Example

let $helpfile = "c:\myapp\applic.hlp"

Although every application has its own unique requirements, the individual components of applications are often very similar. For example, menus, pop-up windows, and data entry forms and displays are common components of most applications. Pop-up windows, for instance, can vary in size, location and contents, but the commands to present them to the application user and to process the result of user interaction are essentially the same. While Zim provides a great deal of flexibility in how applications can be designed and developed, experienced Zim programmers typically develop a programming style for various components of their applications. Consistency of style means that the application program code for one application object can be copied and modified when another, similar object is needed. If a new pop-up window is needed, for example, the object definition and processing code for a similar, existing pop-up can be copied, and the necessary minor changes made. This approach can reduce development time considerably.

Template Definition

The template feature for Zim is a formal mechanism for producing reusable program code. A template is an application program that contains the basic code for defining, presenting, and processing an application component such as a standard pop-up window. In addition, the template contains fragments of code that

• customize the basic code
• generate the application objects (e.g., windows, forms, variables) needed by the application components

Template Syntax

A template is similar to any other application program, in that it contains a series of command statements. However, a template is also different, in that it contains sections of code bounded by special template delimiters: << and >>. The template delimiters are always placed at the start of a line; nothing else should appear on the same line. In this example,

… commands 1 …

<<

… commands 2 …

>>

… commands 3 …

the software handles the command statements that appear between the template delimiters differently depending on if the program is being executed, parsed, or compiled, or if it is being run under the GENERATE command. During normal execution, commands 1 and commands 3 execute normally. Commands 2 are ignored. With the PARSE or COMPILE command, commands 1 and commands 3 are parsed or compiles in the usual manner. Commands 2 are ignored. With the GENERATE command, commands 1 and commands 3 execute normally. Commands 2 are sent as output, after macro substitution, to the current output device.

Program Call Syntax

The syntax of the call to the template program in the GENERATE command is identical to the structure of a call to a standard application program of the same type. The rules for passing values to the parameters in a template program containing a formal procedure operate in exactly the same way as for an application program containing a formal procedure.

Program Execution

Program execution is handled slightly differently under GENERATE. Execution always proceeds interpretively, even if the template program has been compiled. When the software encounters the << template delimiter alone on a line, execution is suspended, and the subsequent lines are written – after macro substitutions – to the current output destination. Execution resumes when the software encounters the >> template delimiter alone on a line.

Physical Line Handling

Normally, each physical line in the template is sent as a separate line to the current output destination. To cause successive physical lines in the template to be joined into one line in the output, end the appropriate lines in the template with the dollar sign ($). At the output destination, the physical line containing the dollar sign and the next physical line appear concatenated on one physical line. If a line must end with a dollar sign for another reason, direct the software to interpret the dollar sign literally by placing a backslash (\ – Escape) preceding the dollar sign.

A variable is a programming object defined in the Object Dictionary for the application.
Variables are used to store values temporarily during an application session.
A variable is assigned a size and a data type in its definition, but until assigned a value during an application session, the variable is valueless (that is, $Null).

Value expressions represent character or number values.
A value expression is an expression that, when evaluated, yields either a number or a character string.
Value expressions are subdivided into

• atomic expressions
• arithmetic expressions
• functional expressions

A value expression can be very simple, containing only one argument. Such expressions are called atomic expressions. An atomic expression is a value expression that consists solely of
literals (explicit numbers or character strings)
permanent object names (constants, global variables, system variables, fields, form fields)
temporary names (local variables, parameters)
Value expressions can also be quite complex, containing many arguments combined by means of arithmetic operators (arithmetic expressions), or software functions (functional expressions), or both. Parentheses can be used to explicitly control the order of evaluation in complex value expressions.
When a statement contains a value expression, the software evaluates the expression and returns the resulting value. Consequently, a value expression can be used almost anywhere that you can use a literal.

Assigning and Reassigning Values to Atomic Expressions

An atomic expression is a value expression that consists solely of a literal constant, named constant, variable name (including subscript, if applicable), field name, form field name, or formal parameter name.
During an application session, an application program can explicitly set and reset the values of certain atomic expressions, specifically: global and local variables, selected system variables, parameters to formal procedures, and macros. The command that explicitly assigns values to these expressions is the LET command.
Note: To assign values to database fields, you must use an ADD, CHANGE, INSERT, or UPDATE command (which can contain LET as a subcommand).
The LET command can be used as shown in the following example:
let var1='abcd' var2=10.5 var3=var4
The LET command can also make its assignments during the evaluation of a complex value expression that appears within another command statement. The special assignment expression format is created by enclosing the LET command in parentheses.

How To Use Literal Constants

A literal constant is a number or character string written directly into an application program.

Writing Valid Number Constants

Number constants can consist only of the digits 0 to 9 and a decimal point (if required).
Number constants are automatically assigned the data type VASTINT and the number of decimal places shown in the number (if any).

Writing Valid Character Constants

Character constants can contain any digits, letters, or symbols, including reserved characters and hex codes.
Character strings should be enclosed in quotation marks (either single or double), but the quotation marks can be omitted if the string contains only digits, letters, dollar signs ($), and underscores (_), and if the string is not identical to a reserved word.

Examples of Number Literals

3.14159
10
.999

Examples of Character Literals

abcde
"$10.99"
1234A
""