#### 3.2.1.2 Statements ¶

A simple statement consists of a keyword and value separated by any amount of whitespace. Simple statement is terminated with a semicolon (‘`;`’).

The following is a simple statement:

    standalone yes;
    pidfile /var/run/pop3d.pid;

A keyword begins with a letter and may contain letters, decimal digits, underscores (‘`_`’) and dashes (‘`-`’). Examples of keywords are: ‘`expression`’, ‘`output-file`’.

A value can be one of the following:

number

  A number is a sequence of decimal digits.

boolean ¶

  A boolean value is one of the following: ‘`yes`’, ‘`true`’, ‘`t`’ or ‘`1`’, meaning true, and ‘`no`’, ‘`false`’, ‘`nil`’, ‘`0`’ meaning false.

unquoted string ¶

  An unquoted string may contain letters, digits, and any of the following characters: ‘`_`’, ‘`-`’, ‘`.`’, ‘`/`’, ‘`@`’, ‘`*`’, ‘`:`’.

quoted string ¶

  A quoted string is any sequence of characters enclosed in double-quotes (‘`"`’). A backslash appearing within a quoted string introduces an escape sequence, which is replaced with a single character according to the following rules:

  Sequence | Replaced with
  \a | Audible bell character (ASCII 7)
  \b | Backspace character (ASCII 8)
  \f | Form-feed character (ASCII 12)
  \n | Newline character (ASCII 10)
  \r | Carriage return character (ASCII 13)
  \t | Horizontal tabulation character (ASCII 9)
  \v | Vertical tabulation character (ASCII 11)
  \\ | A single backslash (‘`\`’)
  \" | A double-quote.

  Table 3.1: Backslash escapes

  In addition, the sequence ‘`\newline`’ is removed from the string. This allows to split long strings over several physical lines, e.g.:

      "a long string may be\
       split over several lines"

  If the character following a backslash is not one of those specified above, the backslash is ignored and a warning is issued.

  Two or more adjacent quoted strings are concatenated, which gives another way to split long strings over several lines to improve readability. The following fragment produces the same result as the example above:

      "a long string may be"
      " split over several lines"

Here-document ¶

  A here-document is a special construct that allows to introduce strings of text containing embedded newlines.

  The `<<word` construct instructs the parser to read all the following lines up to the line containing only word, with possible trailing blanks. Any lines thus read are concatenated together into a single string. For example:

      <<EOT
      A multiline
      string
      EOT

  The body of a here-document is interpreted the same way as a double-quoted string, unless word is preceded by a backslash (e.g. ‘`<<\EOT`’) or enclosed in double-quotes, in which case the text is read as is, without interpretation of escape sequences.

  If word is prefixed with `-` (a dash), then all leading tab characters are stripped from input lines and the line containing word. Furthermore, if `-` is followed by a single space, all leading whitespace is stripped from them. This allows to indent here-documents in a natural fashion. For example:

      <<- TEXT
          The leading whitespace will be
          ignored when reading these lines.
      TEXT

  It is important that the terminating delimiter be the only token on its line. The only exception to this rule is allowed if a here-document appears as the last element of a statement. In this case a semicolon can be placed on the same line with its terminating delimiter, as in:

      help-text <<-EOT
              A sample help text.
      EOT;

list ¶

  A list is a comma-separated list of values. Lists are enclosed in parentheses. The following example shows a statement whose value is a list of strings:

      alias (test,null);

  In any case where a list is appropriate, a single value is allowed without being a member of a list: it is equivalent to a list with a single member. This means that, e.g.

      alias test;

  is equivalent to

      alias (test);

A block statement introduces a logical group of statements. It consists of a keyword, followed by an optional value, and a sequence of statements enclosed in curly braces, as shown in the example below:

    server srv1 {
      host 10.0.0.1;
      community "foo";
    }

The closing curly brace may be followed by a semicolon, although this is not required.