Inno Setup Preprocessor: Expression Syntax

ISPP uses C/C++-like expression syntax. It supports simple and compound assignment operators, the conditional operator, and the sequential evaluation operator. Although ISPP is an interpreter, it does support short-circuit boolean evaluation. It never evaluates an expression (or calls any user defined function within it) when the operator's rules say it should not be evaluated. For example, the conditional operator always evaluates only 2 of its 3 operands.

ISPPBuiltins.iss contains many example expressions.

Differences between C and ISPP expression syntax

• ISPP doesn't support a number of operators (dereference, namespace resolution, member selection, etc.). The @ operator is supported for passing identifiers to func and array parameters (see User Defined Functions).
• ISPP treats an identifier and the equality sign as a name of a parameter, if it is used in the parameter list.
• The arithmetic division operator (slash) performs integer division, since ISPP does not support floating point math.
• ISPP does not check for validity of expressions in certain cases. For example, in a conditional expression, the "true" operand can be of string type, whereas the "false" operand can be of integer type.
• String literals can be quoted by both single and double quotes (in both modes – C-style or Pascal-style). If a literal begins with a single quote, it must also end with a single quote. Double quotes may be used in a single quoted string without any escaping, and vice versa. Within a string, the character used to quote the string must be escaped (the manner depends on the current state of the "Pascal-style string literals" parser option, see pragma). Also see the predefined variable NewLine.

Data types

There are three types in ISPP: void, integer, and string. A variable of void type is declared by specifying its name after the define directive without any value. Such variables should be used with the ifdef directive or the Defined function.

If the "allow undeclared identifiers" parser option is off (the default state, see pragma), an error is raised when an undefined variable is mentioned. Otherwise, it will be treated as a value of type void.

void is compatible with integer and string in expressions. For example, you can use the addition operator with void and integer operands. In this case, the void operand will be treated as zero. In conjunction with a string, the void operand is treated as an empty string.

String comparison operators are case-insensitive.

Comments

Comments may be embedded in an expression by using a slash and an asterisk. For example:

#emit Var1 /* this is a comment */ + Var2 /* this is also a comment */

Comments may also be placed at the end of an expression by using a semicolon. For example:

#emit Var1 + Var2 ; this is a comment

Note that the line spanning feature is triggered before any further processing, so this is also a valid comment:

#emit Var1 + Var2 ; this is \
  still a comment

Comments may also be placed anywhere by starting a line with two slashes. For example:

// This is a comment

All of the comments listed above are not included in the preprocessor output, unlike (non ISPP) comments using a semicolon at the start of a line. For example:

#emit Var1 + Var2 ; this comment is not included
// This comment is not included
; This comment IS included

Extended User Defined Function Call Syntax

In ISPP, you can use named parameters when calling a user defined function. Given the declaration:

#define MyFunction(int A = 2, int B = 2) A + B

This function can be called specifying parameter names:

#emit MyFunction(A = 5, B = 10)
#emit MyFunction(B = 3)
#emit MyFunction(B = 10, A = 5)

• If a name is specified for one parameter, then all (required) parameters in the list must also be named.
• The order of named parameters does not matter.

• Because of this extension, an assignment expression must be enclosed in parentheses, if not using the extended call syntax, to avoid ambiguity:

  #emit MyFunction((MyVar = 5), 10)
  

  In the above example, the equality sign is treated as a direct assignment operator.

  Even when a function doesn't have named parameters, assignment expressions still need parentheses when calling it.

• By the standard rule, a comma is used to separate actual parameters. If you need to use the sequential evaluation operator, you must include the expression in parentheses:

  #emit MyFunction((SaveToFile("script.txt"), 5), 10)
  

  In the above example, the first comma is treated as the sequential evaluation operator, and the second one is treated as the parameter delimiter.