In the programming language Chora the compiler directives are special constructs intended to control how the Chora compiler should process the corresponding source code when translating a method, slot method, onget method, onset method or inline code member. In particular, the directives allow you to conditionally control the code compilation.

Conditional directives:

Diagnostic directives:

Equality operators:

Logical AND, OR, NOT operators:

The conditional directives allow you to explicitly exclude chunks of code from the Chora compilation. For example, depending on the condition in the $if directive, the Chora compiler decides whether the following code should be taken in account or whether it should be ignored. The directive $endif marks the end of the affected code section. For example:

Generally, the condition in the $if directive is fulfilled if it results in the literal true. If it contains the literal false, the condition is not fulfilled. As demonstrated in the example above, eventual user defined macros involved within the condition are evaluated and replaced in advance by their actual content. Similarly, the built-in macros are treated (e.g. $prototyper):

The Chora compiler treats the condition very strictly. If the condition results in a value other than the literal true or false, the Chora compiler will report an error. For example, the built-in macro $line evaluates to a number literal (e.g. 14). Thus trying to use this macro as condition will raise a compilation error:

The directive $else allows you to specify an alternative code section to be taken in the case the condition is not fulfilled. Depending on the condition the directive selects then between the first or the second code section taking exact one of the both:

For more sophisticated application cases the $elseif directive is available. With it you can specify a further condition to be evaluated if the preceding condition is not fulfilled:

Please note, Chora doesn't allow nested conditional directives. Thus the following code will raise a Chora compilation error. To formulate more complex conditions you can use e.g. the logical AND operator && and the logical NOT operator !:

Please note, a directive must be the only instruction on a line. Trying to use several directives within the same line will result again in a Chora compilation error:

With the equality operator == you can compare in the condition whether the literal resulting from the operand on the left of the operator is identical to the from the operand on the right. If this is the case, the operator itself evaluates to the literal true. If the both operands are different, the operator == results in false. For example:

Similarly, with the equality operator != you can compare in the condition whether the literal resulting from the operand on the left of the operator is not identical to the from the operand on the right. If this is the case, the operator itself evaluates to the literal true. If the both operands are identical, the operator != results in false. For example:

The operands used in context of the == or != operator can be macros. For example, the built-in macro $profile evaluates to the name of the currently selected profile. Accordingly, the following condition is fulfilled if you compile the code for the profile with the name DeviceRev2:

When using the == or != operator, one of the both operands may contain wildcard signs ? and *. Here, the sign ? is assumed as representing exactly one arbitrary character. In turn the sign * can represent any arbitrary number of characters including even an empty text. Thus with the wildcard signs you can formulate patterns to be used in the comparison operation. For example, the following condition is fulfilled if you are working with the eight generation of Embedded Wizard (means version 8.00, 8.10, 8.20 ...):

This pattern notation with wildcard signs is very convenient to build conditions to be fulfilled when compiling code for a particular target system. The name of a target system is composed of identifiers separated by a . (dot) sign and it can be queried by evaluating the built-in macro $platform. For example, the following first condition is fulfilled when code for the Microsoft Windows system is compiled. In turn, the second condition is fulfilled when compiling code for a target of a particular color format:

With the logical AND operator && you can combine two partial conditions. Precisely, if the operands on the left and on the right of the operator do both evaluate to the literal true, the operator && results itself in true. Otherwise the operator && results in the literal false. For example, the following condition is fulfilled only when compiling the code for prototyping and the macro UseHeater is defined with the value true:

If necessary you can enclose the partial conditions between a pair of parentheses ( ... ):

With the logical OR operator || you can combine two partial conditions. Precisely, if the operand on the left or on the right of the operator do evaluate to the literal true, the operator || results itself in true. If both operands evaluate to false the operator || results also in false. For example, the following condition is fulfilled when compiling the code for prototyping or with the macro UseHeater defined with the value true:

If necessary you can enclose the partial conditions between a pair of parentheses ( ... ):

The logical NOT operator ! results in the negation of the operand on its right. Precisely, if the operand on the right evaluates to the literal true, the operator ! results in false. If the operand evaluates to false, the operator results in true. For example, the following condition is fulfilled when compiling the code for code generation (not prototyping):

The directive $warning causes the Chora compiler to report a warning when the directive is evaluated. The directive can be combined with the conditional directives. The warning message is specified after the $warning directive separated by at least one blank:

At the compilation time, when the condition $platform == Tara.WebGL.* is fulfilled, the following warning is reported:

Please note, a directive must be the only instruction on a line. Trying to use several directives within the same line will result in a Chora compilation error.

The directive $error causes the Chora compiler to report an error when the directive is evaluated. The directive can be combined with the conditional directives. The error message is specified after the $error directive separated by at least one blank:

At the compilation time, when the condition $platform == Tara.WebGL.* is fulfilled, the following error is reported and the compilation is aborted:

Please note, a directive must be the only instruction on a line. Trying to use several directives within the same line will result in a Chora compilation error.