Syntax and lexical analysis¶

Global structure¶

LSP is a strongly typed, block structured programming language. An LSP program is made of a sequence of functions or classes located in one or multiple LSP file(s) called “module(s)”. Each function contains a block of code consisting of a list of expressions or statements surrounded by braces {}. The modeler is case-sensitive. Each instruction is separated from others by character ;.

Encoding¶

The modeler is able to handle many encodings and different charsets (UTF-8, all ISO-8859 standards and many windows code pages). For the complete list, please consult the Charset module.

The default encoding for a file is ISO-8859-1 (latin1), except if it starts with a byte-order mark (BOM). In that case, LocalSolver assumes that the file is encoded with UTF-8 or UTF-16 accordingly. If an unmappable character or an invalid byte sequence is encountered by the parser, an error will be thrown.

You can declare a different encoding with a special comment to put at the beginning of your file. This comment must start with #, contains the word coding followed by a colon or an equals sign followed by the name of the encoding you want. This special comment must appear on the first or the second line of the file. If it is the second line, the first line must be a shebang comment. The following pattern is an example of a valid encoding declaration:

# coding: <encoding-name>

where <encoding-name> must be a valid and recognized encoding name. For the complete list of supported encodings and their aliases, please consult the Charset module.

Comments¶

Comments have no impact on the execution of the program. Three kinds of comments are allowed:

• Mono-line comments. They are prefixed with characters //. Anything between these two characters and the end of the line is ignored.

• Multi-line comments. They start with characters /* and end when characters */ are encountered. A multi-line comment must be closed. Nesting multi-line comments are forbidden, thus /* Comment 1 /* Comment 2 */ */ is forbidden.

• Special declaration comments. These declarations must start with # and are only allowed at the beginning of LSP files. For now, two kinds of declarations are supported:

  1. The ‘shebang’ declaration starting with #!. This declaration is only allowed on the first line of the LSP program. Under Unix systems it allows specifying the interpreter executing the program (here LocalSolver).

  2. The encoding declaration that must follow the regex pattern coding[=:]\s*[-\w]+. As detailed above, this declaration switch the encoding of the file.

Identifiers¶

Identifiers are used as variable, function names, class names or module names in LSP files. An identifier can only be composed of alphanumeric characters (latin letters) or underscores. It cannot start with a digit. Identifiers, as the rest of the modeler, are case-sensitive. There are described by the following lexical definition:

identifier :  ("_" | letter) ("_" | letter | digit)*
letter     :  lowercase | uppercase
lowercase  :  "a".."z"
uppercase  :  "A".."Z"
digit      :  "0".."9"

Thus,

• identifier is different from IdeNtiFier

• _ident is a valid identifier

• 0ident is not a valid identifier (it starts with a digit)

• àÀéÉùÛ is not a valid identifier (accented characters are not supported for identifiers).

• 안녕하세요 is not a valid identifier (non-latin letters are not supported for identifiers).

• for is not a valid identifier (reserved keyword, see below)

Keywords¶

Keywords are reserved words having a specific significance for the modeler. You cannot use these keywords as variable or function name. Their use is subject to syntaxic rules described later in this document. Some keywords are reserved for future use.

Keywords having a specific significance:

true        false       nil         nan         inf
function    local       return      this        use
while       do          break       continue
for         in          if          else
class       override    final       static      constructor
new         super
minimize    maximize    constraint
try         throw       catch
is          typeof      with

Keywords reserved for future use:

const       var         import
goto        switch      case        object

Contextual keywords¶

Contextual keywords are words that in certain contexts have a particular meaning, but which the rest of the time will be considered as identifiers (usable as variable, class, module or function names).

Contextual keywords having a specific significance:

as          from        extends     pragma

Literals¶

Literals represent constant values of some built-in types.

integer        :  nonzerodigit digit* | "0"
digit          :  "0".."9"
nonzerodigit   :  "1".."9"

float          :  pointfloat | expfloat | "inf" | "nan"
pointfloat     :  digit* "." digit+
expfloat       :  (digit+ | pointfloat) "e" ["+" | "-"] digit+
digit          :  "0".."9"