General-Purpose Mail Filter
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’:
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
declares the variable as public and the
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
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
static precious string rcpt_list
precious static string rcpt_list
The declaration can be followed by any valid MFL expression, which supplies the initial value for the variable, for example:
string var "test"
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.
A variable is assigned a value using
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.
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.
Variables are referenced using the notation ‘%name’. The variable being referenced must have been declared earlier (either explicitly or implicitly).
This document was generated on January 3, 2019 using makeinfo.Verbatim copying and distribution of this entire article is permitted in any medium, provided this notice is preserved.