Next: Back references, Previous: Constants, Up: MFL [Contents][Index]
Variables represent regions of memory used to hold variable data. These memory regions are identified by variable names. A variable name must begin with a letter or underscore and must consist of letters, digits and underscores.
Each variable is associated with its scope of visibility, which defines the part of source code where it can be used (see scope of visibility). Depending on the scope, we discern three main classes of variables: public, static and automatic (or local).
Public variables have indefinite lexical scope, so they may be referred to anywhere in the program. Static are variables visible only within their module (see Modules). Automatic or local variables are visible only within the given function or handler.
Public and static variables are sometimes collectively called global.
These variable classes occupy separate namespaces, so that an automatic variable can have the same name as an existing public or static one. In this case this variable is said to shadow its global counterpart. All references to such a name will refer to the automatic variable until the end of its scope is reached, where the global one becomes visible again.
Likewise, a static variable may have the same name as a static variable defined in another module. However, it may not have the same name as a public variable.
A variable is declared using the following syntax:
[qualifiers] type name
where name is the variable name, type is the type of the data it is supposed to hold. It is ‘string’ for string variables and ‘number’ for numeric ones.
For example, this is a declaration of a string variable ‘var’:
string var
If a variable declaration occurs within a function (see User-defined) or handler (see Handlers), it declares an automatic variable, local to this function or handler. Otherwise, it declares a global variable.
Optional qualifiers are allowed only in global declarations, i.e.
in the variable declarations that appear outside of functions. They
specify the scope of the variable. The public
qualifier
declares the variable as public and the static
qualifier
declares it as static. The default scope is ‘public’,
unless specified otherwise in the module declaration (see module structure).
Additionally, qualifiers may contain the word precious
,
which instructs the compiler to mark this variable as precious.
(see precious variables). The value of the precious variable
is not affected by the SMTP ‘RSET’ command. If both
scope qualifier and precious
are used, they may appear in any
order, e.g.:
static precious string rcpt_list
or
precious static string rcpt_list
Declaration can be followed by any valid MFL expression, which supplies the initial value or initializer for the variable, for example:
string var "test"
A variable declared without initializer is implicitly initialized to a null value, no matter what its scope: a numeric variable assumes initial value 0, a string variables is initialized to an empty string.
A variable is assigned a value using the set
statement:
set name expr
where name is the variable name and expr is a
mailfromd
expression (see Expressions). The effect of
this statement is that the expr is evaluated and the value it
yields is assigned to the variable name.
If the set
statement is located outside a function or handler
definition, the expr must be a constant expression, i.e. the
compiler should be able to evaluate it immediately. See optimizer.
It is not an error to assign a value to a variable that is not declared. In this case the assignment first declares a global or automatic variable having the type of expr and then assigns a value to it. Automatic variable is created if the assignment occurs within a function or handler, global variable is declared if it occurs at topmost lexical level. This is called implicit variable declaration.
In the MFL program, variables are referenced by their name. When appearing inside a double-quoted string, variables are referenced using the notation ‘%name’. Any variable being referenced must have been declared earlier (either explicitly or implicitly).
• Predefined variables |
Next: Back references, Previous: Constants, Up: MFL [Contents][Index]