$$OUT=-

$$START!

## II. Переменные, константы и типы данных | ## II. Variables, constants and data types

### II. 1. Простые типы данных | ### II. 1. Simple data types

#### II. 1. a. Встроенные простые типы данных | #### II. 1. a. Names of data types, data types classification

Простые (встроенные) типы данных (которые не могут быть переопределены): | There are predefined simple data types which can not be redefined:
`BOOL` - булевский тип, значения `TRUE` и `FALSE`. | `BOOL` - Boolean data type, with values `TRUE` and `FALSE`.
`BYTE` - байтовый тип, значения от 0 до 255 (использование байтового типа в классе требует добавления модификатора `BYTES` в заголовке класса). | `BYTE` - byte data type, with values from 0 to 255. Using bytes in a class requires adding a modifier `BYTES` to the class header.
`INT|EGER` - целочисленный тип (обычной точности). | `INT|EGER` - integer numbers of usual precision.
`REAL` - вещественный тип. | `REAL` - real numbers with default precision.
`STR|ING` - строковый тип. | `STR|ING` - string type (chain of characters).
Для типов данных разрядность не задаётся. Для переменных базовых типов всегда используется разрядность, которую определяет разработчик компилятора (или управляемая на уровне проекта, если компилятор допускает вариации). | For data types a precision is never specified: For variables of base data types always a precision is used which is defined by a compiler developer (or controlled by project options, if the compiler allows to do so).
При использовании байтового типа в классе, он должен быть помечен в заголовке модификатором `BYTES`, и не может маркироваться как `SAFE`. |

#### II. 1. b. Запись констант базовых типов данных | #### II. 1. a. Writing constants of base data types

Целые константы в десятичной системе: `[-|+]<0...9_>...` `1_345 = 1345` (подчеркивания игнорируются и могут использоваться для разделения групп разрядов). | Integer constants in decimal base system: `[-|+]<0...9_>...` `1_345 = 1345` (underscores are ignored and can be used to separate groups of digits).
В двоичной системе: `0b_0100_1010_0011_1001` (Регистр буквы, определяющей разрядность, не учитывается: B=b, G=g, X=x) | In binary system: `0b_0100_1010_0011_1001` (Case of a letter used to define a base, is ignored: B=b, G=g, X=x)
В шестнадцатеричной системе (x=X): `0x` `F2EA_d44a` | In hexadecimal system (x=X): `0x` `FFEA_d44a`
В восьмеричной системе (только малая буква 'o'): `0o_``7_342_001` | In octal system (only small letter 'o'): `0o_``7_342_001`
Вещественные константы: `{0...9}.{0...9}[e[+|-]{0...9}]` (e=E)ю Например: `-2.73e3 11_E-04` | Real constants:`{0...9}.{0...9}[e[+|-]{0...9}]` E.g.: `-2.73e3 11_E-04`
Строковые константы: `"{символ кроме "}"` где символ - любой печатный знак или пробел, двойные кавычки в строке не записываются, для их записи необходимо использовать символьную константу `#QU`). Например: `#QU "Этот текст заключен в двойные кавычки" #QU` | String constants: `"{symbol except "}"` where symbol is any printable character or space, double quotas are never written. To write it, it is necessary to use a symbol constant `#QU`). E.g.: `#QU "This text is enclosed into double quotas" #QU`
Для конкатенации символьных и строчных констант и переменных какой-либо символ операции не используется. Например: `"Этот текст завершается возвратом каретки" #CR` Если строка начинается символом двойной кавычки, то эта строка считается продолжением предыдущей. Т.е. для записи длинных строчных констант, не вмещающихся в одну строку, достаточно разбить строку в любом месте и записать продолжение в следующей строке. Пример: `"Это очень длинная строка. Настолько длинная, что " "она не может быть записана в одной строке кода."` Если перед началом строковой константы записан символ @, то для всех последующих конкатенаций с последующими строковыми константами и переменными, при переносе выражения на следующую строку, все символы переноса строки становятся частью константы. Например: `@"Эта константа состоит из трёх строк: первая," "вторая," "и третья"` Cимвол @@ перед строчной константой отменяет действие символа @ - до конца конкатенации или до следующего символа @. | To concatenate character constants and literal strings there are no operation symbols using. E.g.: `"This text is finished by a caret return" #CR` If a line of code is starting from a quotation symbol, the line is a continuation of the previous line. So, to write a very long string constant, not fit into a single line of code, it is sufficient to divide the string onto two (or more) strings, and write its continuation in another string. E.g.: `"This is very long string of text. It is so long that " "it can not be written in a single line of code."` If a string constant is starting from a symbol '@', then for all continued lines symbol `#NL` is inserted in between, so new line characters are inserted into a long string constant in places where the line is continued in next lines. E.g.: `@"This string constant contains 3 lines: the 1st," "the 2nd," "and the 3rd"` A symbol @@ before a string literal cancels previous symbol @ - until the end of the concatenation of strings or until the next symbol @.

#### II. 1. c. Перечисления | #### II. 1. c. Enumerations

Перечислимый тип данных определяет набор именованных целочисленных констант. Сам набор так же именуется для того, чтобы на него можно было ссылаться. В декларации перечисления элементы перечисления записываются через запятую. Форма декларации: `ENUM {``имена|перечисления} : значения .` (точка завершает декларацию). Имя типа перечисления заключается в фигурные скобки и начинается со строчной буквы. Имена элементов перечисления заключаются в апострофы. Имён для элемента может быть два, краткое имя и остаток полного имени разделяются символом '|'. Имена должны быть уникальны в пределах класса (среди всех перечислений класса). | A enumerated data type defines a set of named integer constants. The set itself is also named to make it possible to refer to it by the name. In enumeration declaration, its items are written comma separated. A declaration: `ENUM {names|_of_enumeration} : values .` A enumeration type name is always enclosed into figure brackets and starts from a lowercase letter. Each enumeration item name is enclosed into apostrophes. An item name can have short and small form as usual (separating short name and the rest part by a symbol '|'). Names must be unique in the class (among all the enumerations in the class).

`ENUM``{color|s_of_traffic_light} : 'R|ED_COLOR', 'Y|ELLOW_COLOR', 'G|REEN_COLOR' .`

Операции над значениями перечислимых типов данных: Переменной с типом, созданным оператором `ENUMERATION`, нельзя присвоить числовое значение или значение из чужого перечисления. Значение переменной (или константы, или выражения) такого типа может быть преобразовано в целочисленное: встроенная функция `Int`. Обратное преобразование числового значения в тип перечисления не предусмотрено (кроме как с помощью собственной функции, в которой выполняется такое преобразование, например, оператором `CASE`). Встроенная функция `Name` возвращает имя элемента по его значению. В качестве имени возвращается первое имя константы без апострофов. | Operations on enumerations: It is not allowed to assign an integer value or value from another enumeration to a variable of such type. Value of variable (or constant, or expression) of a enumerated type can be converted to an integer using embedded function `Int`. Back conversion of a numeric value to an enumerated type is not possible except via a custom function (e.g. using `CASE` statement). Embedded function `Name` returns for an enumerated item its name by value (the first name of an item if there are several there).
Перечисление может использоваться как диапазон индексов фиксированного массива при его декларации: `STR LName|s_of_lights[{color}]` В этом случае в качестве индексов этого массива могут использоваться переменные и константы соответствующего перечисления: `LName['R'] = "Red color"` | A enumeration can be used as a range for indexes of a fixed array: `STR LName|s_of_lights[{color}]` In such case the enumeration items only can be used as indexes of such fixed array: `LName['R'] = "Red color"`
Элементы перечисления считаются неупорядоченными, и не могут сравниваться операциями <, <=, >, >= (применимы сравнения == и !=). Из элементов перечисления может быть сформирован константный массив, и для пары элемент - массив элементов допустима операция `IN` (и `!IN`): `CASE A IN ['R', 'Y'] ? ... ; ▄▄▄▄` В случае конфликта имён перечислимых элементов, они обязаны квалифицироваться именем перечисления в форме: `{enumeration_name}.'EUMERATION_ITEM'`. В случае совпадения имён самих перечислений, в квалификацию должен включаться класс, из которого это перечисление родом: `{Class_name}.{enumeration_name}.'EUMERATION_ITEM'`. | Enumeration items are not ordered and can not be compared using operations <, <=, >, >= (only == and != are allowed). Enumeration items can form a constant array, and for pair "item - array of items" it is possible to use operations `IN` and `!IN`: `CASE A IN ['R', 'Y'] ? ... ; ▄▄▄▄` In case of naming conflict between enumeration items from different enumerations, those should be qualified using names of enumerations: `{enumeration_name}.'EUMERATION_ITEM'`. In case when names of enumerations are matching, a class name should also be added to a specification: `{Class_name}.{enumeration_name}.'EUMERATION_ITEM'`.
При использовании в операторе `CASE` выражения типа перечисления: запрещается использовать ветвь `ELSE` должны быть использованы (перечислены) все константы в одной ветви может использоваться более одной константы: `CASE Greek ? ▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄ ['ALPHA', 'BETHA']: ... █ ['GAMMA', 'DELTA']: ... █ ['EPSILON']: ... █ ['DZETHA', 'ETHA', 'TETHA', 'IOTHA', 'KAPPA']: ... █ ... ; ▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄█` | When a `CASE` statement condition has a enumerated type: it is not allowed to use the `ELSE` branch all the items from the enumerated data type must be listed more then a single constant can be used in a single branch: `CASE Greek ? ▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄ ['ALPHA', 'BETHA']: ... █ ['GAMMA', 'DELTA']: ... █ ['EPSILON']: ... █ ['DZETHA', 'ETHA', 'TETHA', 'IOTHA', 'KAPPA']: ... █ ... ; ▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄█`

### II. 2. Переменные, массивы | ### II. 2. Variables and arrays

#### II. 2. a. Декларация переменных | #### II. 2. a. Declaration of variables

Декларация переменной начинается с указания ее типа данных в {фигурных} скобках (или одного из зарезервированных имён типов `BOOL`, `BYTE`, `INT`, `REAL`, `STR`). При объявлении глобальной или локальной переменной её полное имя должно быть длиной не менее 8 символов. ИСКЛЮЧЕНИЕ: Переменные циклов FOR могут иметь только краткий вариант имени. Имя может быть коротким, но тогда вслед за короткой частью после разделителя '|' размещается остальная часть имени. Для массивов далее задаётся размерность в `[`квадратных`]` скобках. для динамических массивов - пустые квадратные скобки, для фиксированных массивов с целочисленными индексами указывается константа, задающая размер фиксированного массива (индекс последнего элемента + 1), для фиксированных массивов с индексами из перечисления указывается имя перечислимого типа, в фигурных скобках: `BOOL My_arr|ay_of_flags[{traffic}]` Затем, при необходимости, МОДИФИКАТОРЫ`` переменной/поля (`READ`, `INIT`, `MAXLEN[n]`). Далее может следовать присваивание начального значения (в качестве начального значения допускается использовать константы). Переменной всегда присваивается начальное значение. Если такое значение не присвоено явно, присваивается значение по умолчанию. Для объекта - это `NONE`-значение соответствующего класса (см. "Классы"). Для строк - пустая строка. Для динамических массивов - пустой массив. Для перечислений, коллекций, чисел - арифметический ноль (для перечислений это всегда первый элемент перечисления). | A declaration of a variable is starting from a specification of its data type in {figure} brackets (or from one of reserved data type names: `BOOL`, `BYTE`, `INT`, `REAL`, `STR`). When a variable is declaring its full name should be at least 8 characters length. EXCLUSION: Loop variables (FOR) name length is not restricted. Short part of the variable name is separated from the rest of name with a symbol '`|`'. For dynamic arrays brackets are empty. For fixed arrays indexed by integer index, a constant is specified defining the array size (index of the last item + 1). For fixed arrays with indexes from a enumeration, a name of the enumerated type is specified, in figure brackets as usual: `` `BOOL My_arr|ay_of_flags[{traffic}]` For arrays its dimension is following in `[`square`]` brackets. Then variable MODIFIERS are following if these are necessary (`READ`, `INIT`, `MAXLEN[n]`). A declaration can continuing with an assignment of an initial constant value, if this is suitable (not in all cases, see about classes, structures, global object variable). A variable always has an initial value. If there are no explicit initial value specified, a default initial value is set. For an object, this is `NONE`-value of a correspondent class (see "Classes"). For a string this is an empty string. For a dynamic array this is an empty array. For enumerations, collections, numbers this is arithmetic 0 value (for enumeration types this means always the first item in the enumeration).
Правила именования переменных: | Naming variables rules:
Краткое имя - это идентификатор от 1 символа, Длинное имя - идентификатор от 8 до 80 символов, Далее в коде употребляется краткое имя наравне с длинным. | A short name is in identifier of 1 or more characters, Along name is an identifier from 8 to 80 characters, In the code both short and long names can be used equally.
Регистр букв имён переменных: Имена Публичных полей классов и Параметров функций начинаются с прописной буквы (в том числе с атрибутом `READ` - только для чтения). КОНСТАНТЫ (обычно) содержит только прописные буквы. Со строчной буквы начинается имя приватных полей класса и локальных переменных. | Case of letters in a variable name: A Public variable or class field name is starting from an uppercase letter (and can have modifier `READ` making it read-only). CONSTANTS usually contain only capital letters. private variables and class fields usually start from lowercase letter.

#### II. 2. b. Модификаторы полей | #### II. 2. b. Field modifiers
Если переменная требует модификаторов, они записываются в декларации вслед за именами переменной и её размерностями. | If some modifiers are required for a variable, these are written in a declaration following it names and dimensions.
`READ|ONLY` - используется для переменных уровня модуля, полей классов (а так же параметров функций). Для поля класса разрешает доступ только для чтения, кроме самого модуля и из методов класса-наследника. Поле должно быть публичным (именоваться с Прописной буквы). `INIT|IALIZE -` для поля класса, требует инициализации поля при конструировании объекта (см. "Классы"). `MAXLEN|GTH[n]` - для полей записи (RECORD) строкового типа, позволяет задать фиксированную строку с заданным максимальным количеством символов. Запись может содержать только такие фиксированные строки. Класс, содержащий такие строки и оперирующий с такими строками, должен иметь модификатор `SHORT_STRINGS` в заголовке класса. `DEPRECATED('`текст') - данное поле "осуждается", но ещё поддерживается. В тексте указывается, что предлагается в качестве замены. Рекомендуется переходить к замене по мере возможности, в следующей версии поле может уже не поддерживаться. `ABANDONED('`текст') - поле "отменено". В тексте указывается, что есть взамен (если есть). Использование такого поля в коде уже невозможно, и вызывает ошибку компиляции. | `READ|ONLY` - is used for module level variables, fields of classes (and also for function parameters). For a module variable it enables only reading the variable from other modules. For a class field, it becomes read only except its own module and code of methods of inherited classes. `INIT|IALIZE` - for a class field, it is required to be initialized while creating an object (see "Classes"). `MAXLEN|GTH[n]` - for record fields, such modifier allows to specify a maximal number of characters in a fixed string. Only fixed strings with such modifier can be used in records. Class having fixed strings and operating with such strings must have a modifier `SHORT_STRINGS` in its header. `DEPRECATED('text')` - such field is deprecated though it is still is supported. Text should contain information about an alternative (this can be not only a filed, but a function, or another class etc.) It is recommended to use an alternative as quick as possible, still in following versions the field can become unsupported. `ABANDONED('text')` - the field is abandoned. Using it leads to a compiling error. The text should contain information about an alternative.
Кроме явно указываемых выше модификаторов`` существуют так же неявная маркировка переменных и параметров функции: Параметр, объявленный в заголовке функции, но не использующийся в теле функции, должен содержать в имени строку "dummy" (в любом регистре). Переменная, объявленная в теле функции (и даже если ей присвоили значение), но не использованная в выражениях, должна иметь строку "dummy" (в любом регистре) в своём имени. Объектная локальная переменная, которой присвоен новый объект, который не добавляется в массив сильных ссылок и для которого не указывается владелец, должна иметь в своём имени строку "temp" (в любом регистре). Например, `load|er_Temp = {Text_file}(Path = path)` | Additionally to explicit modifiers above, there are also implicit variables modifiers: A function parameter declared in the function header but not used in the function body, should have a substring "dummy" temp in its name (in any register case). A variable declared in a function body and (even if a value was assigned to it) not used in expressions also should have the substring "dummy" in its name. Object local variable, to which a new object variable was assigned, which were not added to an array of strong references, has not an owner specified, should have a substring "temp" in its name (in any register case). E.g.,: `load|er_Temp = {Text_file}(Path = path)`

#### II. 2. c. Декларация именованных констант | #### II. 2. c. Named constants declaration
Константы декларируются только на уровне класса. Декларация одиночной константы в одной строке: `CONST {имя_типа} : ИМЯ_КОНСТАНТЫ = выражение .` Декларация нескольких однотипных констант: `CONST {имя типа} : ИМЯ_КОНСТАНТЫ_1 = выражение ИМЯ_КОНСТАНТЫ_2 = выражение ... ИМЯ_КОНСТАНТЫ_2 = выражение .` Рекомендуется использовать капитализированные имена констант (все буквы в верхнем регистре). | Constants can be declared only on a module level.. Declaration of a single constant in a single line: `CONST {type_name} : CONSTANT_NAME = expression .` Declaration of several constants: `CONST {type_name} : CONSTANT_NAME_1 = expression CONSTANT_NAME_2 = expression ... CONSTANT_NAME_2 = expression .` It is recommended to use uppercased names for constants.

#### II. 2. d. Декларация массивов | #### II. 2. d. Arrays declaration
После имен переменной, являющейся массивом, в квадратных скобках записывается размерность. Массивы могут быть только одномерными. Массив может быть фиксированным или динамическим. В квадратных скобках динамического массива ничего не пишется при его декларации: `STR Lines|_of_text[]` Для фиксированного массива при его декларации в квадратных скобках записывается либо целочисленное константное выражение, либо имя типа перечисления. Для целочисленного, значение выражения - размер массива (на 1 больше последнего индекса по данному измерению).. Пример (массив 16 элементов): `REAL` `A|rray_of_values[16]` При использовании массива даже как цельного объекта (в отличие от его элементов), всегда указываются квадратные скобки. Например: `A[]` | Array dimensions are written in square brackets following the variable names. An array variable can be fixed or dynamic. Dynamic array always has a single dimension. In square brackets nothing are written for a dynamic array: `<str> Lines | Lines_if_text[]` Fixed array can have several dimensions. For each dimension of a fixed array a constant expression is written in square brackets. Its value is an array size (it is greater by 1 then an index on the given dimension). An example (an array 3x4): `<real> A | Array_of_values[3][4]` While using an array even as a whole object all its square brackets are listed always. E.g., `A[][]` for a two-dimensional fixed array.
Начальное значение для массивов обеспечивается обязательно, как и для всех остальных переменных. Массив переменной размерности первоначально пуст. Фиксированный массив объектов класса первоначально заполнен `NONE`-объектами соответствующего класса. Фиксированный массив строк заполнен пустыми строками. Фиксированный массив чисел, перечислений, коллекций заполнен арифметическими нулями. | Initial values for items of arrays are always provided as well as for all other variables. A dynamic size array initially is empty. A fixed array of class objects initially is filled by `NONE` objects of the correspondent class. A fixed array of numbers, enumerations, collections is initially filled with arithmetic zeroes.

#### II. 2. e. Конструктор массива | #### II. 2. e. Array constructor
Конструктор массива - это перечень элементов массива в квадратных скобках в виде: `[` `значение, значение, ... значение ]` | An array constructor is a sequence of items in square brackets in a form: `[ value``, value, ... value ]`
Конструктор массива может использоваться как второй операнд операции проверки на вхождение `A IN B` (и противоположной `A !IN B`). | An array constructor can be used as the second operand of an operation checking if the first operand is present in the second array `A IN B` (and in the opposite case: `A !IN B`).

#### II. 2. f. Использование массивов | #### II. 2. f. Using arrays

Основные операции с массивами: Чтение и запись элемента массива. В левой части оператора присваивания или в качестве операнда выражения указывается имя массива и в квадратных скобках записывается выражение, вычисляющее целочисленный индекс элемента по этой размерности. Например: `A[i] = B` Добавление элемента в динамический массив оператором `<<`, пример: `X[] << Value` Вызов одной из встроенных функций над динамическими массивами: `X[].Add(s)` `X[].Insert(i, Value:s)` `X[].Delete(i)` `X[].Delete_range(i, Count)` `X[].Remove(R)` `X[].Find(v)` `present = R IN X[]` `CASE X[].Find(R) < 0 ? not_found ;` `count = X[].Count` `X[].Clear` При обращении за пределами массива возвращается `NONE`-объект соответствующего типа. Присваивание значения за пределами массива игнорируется. Передача массива как параметра в функцию: Указываются квадратные скобки для массива. На место динамического массива может быть передан только динамический массив. На место фиксированного массива с целочисленными индексами может быть передан фиксированный (целочисленный) массив или часть динамического массива (с указанием диапазона индексов в форме: `A[first TO last]` Для указания того, что формальный параметр функции является массивом фиксированного размера с целочисленными индексами, в квадратных скобках записывается символ '*'. В качестве параметра - фиксированного массива с размером, заданным перечислением, может быть передан только фиксированный массив с размером, заданным тем же перечислением. Не допускается: Присваивание целого массива как единого значения. Возврат массива в качестве результата функции. | Main specific operations with arrays: Reading and writing items of an array. In the left side of an assignment statement or as an operand of an expression a name of an array is specified and for each of its dimensions an expression is written in square brackets, which represents an integer index of an item of the array. E.g.: `A[i][1] = B` Adding an item to the end of a dynamic array with an operation `<<`, e.g.: `X[] << Value` Calling one of embedded functions designed under dynamic arrays:: `X[].Add(s)` `X[].Insert(i, Value:s)` `X[].Delete(i)` `X[].Delete_range(i, Count)` `X[].Remove(R)` `X[].Find(v)` `present = R IN X[]` `CASE X[].Find(R) < 0 ? not_found ;` `count = X[].Count` `X[].Clear` When an item is read out of array bounds, then a `NONE` value of correspondent type is returned. Assigning a value out of array bounds is ignored. Passing an array as a parameter to a function: Square brackets for an array parameter (dynamic or fixed). In place of a dynamic array only a dynamic array can be passed. In place of a fixed array formal parameter only a fixed array or a range of a dynamic array can be passed: `A[first TO last]` To specify a formal parameter of a function as a fixed array with integer indexes, the symbol '*' is written in square brackets. In place of a fixed array with indexes given by a enumerated data type, only a fixed array with same type of indexes can be passed only. It is not allowed: Assigning an array as a whole variable. Returning an array as a result of a function.

### II. 3. Функции | ### II. 3. Functions

#### II. 3. a. Заголовок функции | #### II. 3. a. Function header

`FUNCTION имена (параметры) ==> тип_результата , модификаторы : операторы .` | `FUNCTION names (parameters) ==> result_type , modifiers : statements` `.`

`FUNCTION имена (параметры) ==> тип_результата, модификаторы :`
`FUNCTION names (parameters) ==> result_type , modifiers :`

Статическую функцию начинает функцию слово `FUNCTION` или `FUN`. Метод класса начинает ключевое слово `METHOD`. Если метод переопределенный, используется ключевое слово `OVERRIDE`. Для конструктора и деструктора класса используются ключевые слова `CONSTRUCT` и `DESTRUCT`, соответственно. И в этом случае уже нет имен функций, параметров, результатов, модификаторов - просто двоеточие, которое завершает заголовок. | A static function is starting from a keyword `FUNCTION` or `FUN`. A class method is starting with the keyword `METHOD`. If the method is overriding its predecessor method from its class ancestor, the keyword `OVERRIDE` is used. For a constructor and a destructor, a keyword `CONSTRUCT` or `DESTRUCT` are used, correspondently (and in such case there are no function name(s), parameters, result types and so on - just a colon symbol.

`FUNCTION имена (параметры) ==> тип_результата, модификаторы :`
`FUNCTION names (parameters) ==> result_type , modifiers :`

Функции могут иметь два имени (как минимум одно длинное имя не менее 8 символов).. В случае двойного именования, сначала записывается короткое имя, далее, после разделителя '|' - остаток имени. При определении замещения метода класса-предшественника указывается только первое имя замещаемого метода. | Functions can have two or more names (at least one name should be not less then 8 characters). If a function has two names, the short name is written first, than after a separator `'|'` - the rest of the name. When a method of a predecessor class is overriding, only the first (short) name of the method overriding is specified.
Имя публичной функции начинается с прописной буквы. Если требуется сделать публичной функцию или метод, начинающийся со строчной буквы, может использоваться модификатор PUBLIC. Имя функции, доступной только в самом классе (и нго наследниках) - начинается только со строчной буквы. | Public function name starts from an uppercase letter. To make public a method or function which name is starting from a lowercase letter, use the modifier PUBLIC (see below). Function accessible only in the class itself (and its descendants) is named from a lowercase letter always.

`FUNCTION имена (параметры) ==> тип_результата, модификаторы :`
`FUNCTION names (parameters) ==> result_type , modifiers :`

Параметры в круглых скобках в заголовке указываются при их наличии.. В случае их отсутствия записываются пустые круглые скобки. Число параметров не ограничено, но если количество явных параметров (не считая THIS) превышает три хотя бы у одной функции, класс должен иметь модификатор `BAD`. | Parentheses must be always present. For empty parameters list empty parenthesis are written. Amount of parameters is not restricted but if at least one function declared in a class has more then three parameters, the class must have a modifier `BAD`.
Параметры перечисляются через запятую. Для параметра сначала записывается тип параметра, затем имена параметра, далее размерность (необязательно). Параметр может иметь два имени (краткое имя отделяется от остальной части имени символом '|', как обычно). Полное имя параметра должно быть не менее 8 символов. Имена параметров должны начинаться с прописной буквы. | Parameters are separated with comma. First a type of a parameter is written, then its names, then optional: dimensions, modifiers, default value. Parameter can have two names (short name is separated from the rest of the long name with the symbol '|' as usual) . Full parameter name should be at least 8 characters length. Parameter names should start from the uppercase letter.
Для параметра-массива после имени указывается размерность в квадратных скобках. Для динамического массива, в квадратных скобках ничего не записывается. Для фиксированных массивов с целочисленными индексами записывается символ '*'. Для фиксированных массив с перечислимыми индексами указывается имя типа перечисления (в фигурных скобках), например, `A|rray_of_color[{color}]` | For an array parameter its dimensions are listed following its names. For dynamic array, square brackets are empty. For fixed arrays with integer indexes, the symbol '*' is written in brackets. For fixed arrays indexed by a enumeration, the name of the enumerated type is written, in figure brackets as usual, e.g.: `A|rray_of_color[{color}]`
Параметры не могут иметь модификаторы. Параметры, которые не используются, должны иметь слово dummy (в любом регистре) в качестве части своего имени. Скалярные параметры всегда принимаются по значению, и не могут изменяться в теле функции. | Parameters can not have its own modifiers. Parameters which are not used in the function body, should have a substring "dummy" in its name (in any registry case). Scalar parameters are always passed by the value (formally) and can not be changed in the function body.
Параметры могут иметь ограничения на значения или участвовать в ограничениях, которые задают возможные списки и диапазоны константных значение параметров - безусловно, либо в зависимости от значений других констант. (См. модификаторы `RESTRICT`, `IF`, `THEN` - для функции). | Parameters can have restrictions on values passed or be used in restrictions to other parameters. Parameters can be restricted with lists of constant values of ranges independently, or dependently from values of other parameters passed.. See function modifiers `RESTRICT`, `IF`, `THEN` (below).
Для обобщённых функций допускаются параметры особого типа {?}, а так же становятся возможными параметры-функции. Обобщённые функции описываются далее, в п. II.3.d. | For generic functions it is allowed generic parameters of a special data type {?}, as well function parameters. Generic functions are described below in a paragraph II.3.d.

`FUNCTION имена (параметры) ==> тип_результата, модификаторы :`
`FUNCTION names (parameters) ==> result_type , modifiers :`

Если тип результата не указывается (вместе со стрелочкой '==>'), то функция не возвращает результат. Для присваивания значения результату функции, используется присваивание значения псевдо-переменной `RESULT`. Как и все прочие локальные переменные, псевдо-переменная `RESULT` изначально инициализируется `NONE`-значением: `NONE` - для объектов, `0` - для чисел, `""` - для строк, первый элемент - для перечислений, `FALSE` - для типа `BOOL`. Функция не может возвращать массив в качестве результата, только скаляр. Специальный символ возврата `==``>` используется и как операция выхода из функции в теле функции (он может пристыковываться к концу любого простого оператора). | If a result type is not specified (together with the symbol '==>'), then the function is not returning a result. To assign a result to a function, an assignment to a pseudo variable `RESULT` is used. As well as for other local variables, the `RESULT` variable is initialized initially with a `NONE` value: `NONE` - for objects, `0` - for numbers, `""` - for strings, first item - for enumerations, `FALSE` - for `BOOL` data type. A function can not return an array as a result, only a scalar. Special symbol `==>` is also used as an operation of returning from a function. It can follow any simple statement (assignment, function call, etc.)
Например, подсчет символов точки в строке:
`FUNCTION Ndots|_count``(STR S) ==>` `INT :``FOR i IN [0 TO S.Len-1] : CASE S[i] == "." ? RESULT++ ; ; .`
| A sample of a function counting number of dots in a string:
`FUNCTION Ndots|_count``(STR S) ==>` `INT :``FOR i IN [0 TO S.Len-1] : CASE S[i] == "." ? RESULT++ ; ; .`

`FUNCTION имена (параметры) ==> тип_результата, модификаторы :`
`FUNCTION names (parameters) ==> result_type ,modifiers`

Модификаторы функции перечисляются через запятую. Возможны модификаторы: | Function modifiers are listed via comma. Following modifiers are possible:
`RECURSIVE` - для рекурсивной функции. Если функция уже использует некоторую рекурсивную функцию, и сама не вызывает себя непосредственно, то этот модификатор необязателен. Если в процессе выполнения обнаруживается превышение некоторого порога рекурсивных вызовов (обычно - 128, но может быть меньше или больше), то происходит возврат к самому верхнему рекурсивному уровню, этот вызов функции игнорируется, а в качестве результата, если он требуется, возвращается `NONE`-значение. | `RECURSIVE` - function is recursive. If a recursive function does not call itself and it is recursive via a call to a function which is already marked as recursive, the modifier can be omitted. If too deep recursion is detected (usually more then 128 call levels), then execution is returned to the first recursive call level and a function called on that level is ended (returning `NONE` value corresponding to its result type - if the function should return a value).
`NEW` - функция возвращает новый объект (экземпляр класса). Как минимум один оператор в функции представляет собой присваивание переменной `RESULT` конструктора нового объекта или результата вызова функции, имеющей модификатор `NEW`. Функцию с модификатором `NEW` можно вызвать только особо (не в составе выражения), присвоив результат какому-либо внешнему владельцу, или обеспечив корректное владение нового объекта другими способами (см. раздел "Классы"). | `NEW` - function is returning a new object instance. At least one statement in the function is an assignment of a new object creation (or a result of calling another function with the `NEW` modifier) to the pseudo variable `RESULT`. A function with the `NEW` modifier can be called only separately (not as an ordinary operand in an expression), and it is necessary either to assign a result to an owning object reference, or to provide a correct owner by some other way (see "Classes" section).
`REPLACE` - для переопреленного виртуального метода, не возвращающего результат сообщает, что виртуальный метод класса не использует вызов функции-предшественника, т.е. прототип функции полностью переопределен. Если такой модификатор отсутствует, то в теле требуется вызов метода предка (оператором `BASE`). | `REPLACE` - for an overridden virtual method of a class not returning a value, to inform that the function does not call a base method, so it is totally override. If there are no such modifier for such kind of an overrode function, then it is requred to call a base method (using operator `BASE`).
`NATIVE` - в качестве тела функции записывается строчная константа, которая, обычно, вставляется непосредственно в тело сгенерированной функции в откомпилированного коде. (Либо тело функции завершается оператором `NATIVE "`строка"). Класс, в котором используются NATIVE-функции, должен иметь модификатор `NATIVE`. | `NATIVE` - a body of the function is a string constant containing a code inserted into resulting (compiled) function as is. (Either a function body is ending with a statement `NATIVE "string"`). A class, having `NATIVE` functions must have the modifier `NATIVE.`
`SETTER FOR identifier` - функция является присваивателем для поля или получатель-метода, заданного идентификатором. Это поле или метод должно быть объявлено непосредственно перед функцией-присваивателем. В случае поля параметр должен быть единственным, того же типа, что и поле. В случае метода параметров должно быть на один больше, чем у метода-получателя, и тип последнего параметра должен совпадать с типом результата получателя (а прочие параметры - идентичны по типам). | `SETTER FOR identifier` - function is a setter for a field or a getter method specified by the identifier. Such field or method must be declared just before the setter function. In case of a field, a setter should have a single parameter of the same type as the field. For a case of the getter method, the setter should have number of parameters greater by one then a getter. The last parameter should have the same type as a result of a getter, all other parameter data types should match for getter and setter.
`CALLBACK` - функция предназначена для вызова из кода самого класса и кода нативных функций, её не следует вызывать из пользовательского кода, в том числе из кода классов-наследников данного класса. Например, событие мыши на форме mouse_down: следует переопределять данный метод в своём наследнике формы, но не вызывать напрямую метод класса {Form}. | `CALLBACK` - function is intended to call it from the class code (and native functions) only, not for direct call of it from the customer code (even not from descendant classes of the class containing the callback function). E.g. an event mouse_down in a form: it is necessary to override the method rather than to call it in your form implementation class.
`POP(Method2)` - функция может быть вызвана только в операторе PUSH. По окончании блока PUSH, гарантированно вызывается Method2 (он не должен иметь параметров, и не может вызываться напрямую вообще никаким способом). | `POP(Method2)` - function is intended to be called only in the PUSH statement. When such PUSH block is ending, the Method2 specified in parenthesis is called anyway (the Method2 should not have parameters, and it can not be called any other way except this).
`DEPRECATED('text')` - функция "осуждается" и теперь необходимо использовать альтернативу, указанную в тексте. В будущих версиях функция, возможно, перестанет поддерживаться. | `DEPRECATED('text')` - the function is deprecated and it is necessary to use an alternative specified in a 'text'. In further versions of a class it is possible that the function will not be supported (and become abandoned or removed).
`ABANDONED('text')` - функция более не поддерживается. Используйте альтернативу, указанную в тексте в апострофах. Попытка вызова функции вызывает ошибку компиляции. | `ABANDONED('text')` - the function is no more supported, use an alternative specified in the text in apostrophes. Calling such function leads to a compilation error.
`STORE(Parameter=value)` - Специальный "невидимый" параметр целого типа, создающий на стороне вызывающего класса для каждого отдельного вызова функции скрытую целочисленную переменную, которая и передаётся в качестве параметра, причем по ссылке. См. подробнее в Дополнительной секции. | `STORE(Parameter=value)` - creates a special "invisible" parameter of an integer data type, which creates on a caller class side correspondent integer variable (separately for each call to the function). Such variable is passed implicitly by reference at call. See more detailed in the Additional section.
`FORGET` - при вызове такого метола, все сохранённые невидимые значения на стороне вызывающего объекта сбрасываются в их начальное состояние. См. подробности в Дополнительной секции. | `FORGET` - When such method is called, all the stored invisible values in the caller object are reset to its initial values. See details in the Additional section.
`RESTRICT` имя IN [список] или `RESTRICT` имя IN {имя_блока_констант} или `RESTRICT имя IS CONST` - ограничение на параметр с указанным именем: он может быть только константой (в первом варианте - только из указанного списка). | `RESTRICT name IN [list]` or `RESTRICT name in {constants_block_name}` or `RESTRICT name IS CONST` - restricts a parameter with the given name: it can be only a constant (in the first case only from the list of values specified).
`IF имя IN [список]` - параметр функции, заданный именем, участвует в ограничении значения следующего за ним (модификатор `THEN`) параметра. Вместо списка может быть указано имя набора констант в фигурных скобках (см. описание оператора CONSTANT). | `IF name IN [list]` - a function parameter with the given name is used to restrict values of another parameter (specified in the next restriction modifier `THEN`). A list can be replaced with a name of a constants block in figure brackets (see CONSTANT statement definition).
`IF имя IS` `CONST` - если параметр функции, заданный именем, получает константу в качестве значения, то работает следующее ограничение значения параметра (модификатор `THEN`). | `IF name IS CONST` - if a function parameter with the given name gets a constant, then the following restriction (modifier `THEN`) is active.
`THEN` имя IN [список] - условное ограничение заданного именем параметра только указанными значениями (при условии, указанном предыдущим модификатором `IF`). | `THEN name IN [list]` - a conditional restriction of a given parameter by only values specified in the list (a condition is specified by the previous `IF` modifier).

#### II. 3. b. Тело функции | #### II. 3. b. Function body

Тело функции состоит из операторов, и завершается символом '.' (точка). Тело функции на любом уровне блока не должно содержать более 7 простых операторов и 7 блочных операторов. Блок может быть разбит разделяющими комментариями вида `---------------- 'метка'` (не более, чем 7 таких комментариев на блок), в этом случае подсчёт начинается после комментария заново. | Function body consist of statements located and it is finished by a dot symbol. On any block level the body should not have more then 7 simple statements, 7 declarations of local variables and 7 block statements. A block can be separated by comments `---------------- 'label'` (not more then 7 such comments for a block), in such case counting statements of different kinds starts again.
Если обозначенные выше ограничения не соблюдены, в заголовке класса требуется указывать модификатор `BAD`. | If the requirements above are not satisfied. then it is necessary to mark entire class with the modifier `BAD` (in the class header).

#### II. 3. c. Вызов функций | #### II. 3. c. Calling functions

Круглые скобки используются только при наличии параметров. Параметры перечисляются в круглых скобках через запятую в порядке, соответствующем декларации параметров. Параметр-объект передаётся в функцию неявно. Он может быть явно использован (`THIS`). Если функция возвращает результат, её нельзя вызывать как самостоятельный оператор без присваивания её результата какой-либо переменной. Если результат не требуется, результат должен быть "присвоен" переменной `NONE`, например, в форме: `NONE = объект.Функция(параметры)` Любая статическая функция может быть вызвана в префиксной форме, когда её первый параметр выносится в префикс, например, `x.Sin` - вместо `Sin(x)` `s.Lower.Ending(".al4")` - вместо `Ending(Lower(s), ".al4")` | Parenthesis are used only if actual parameters are present. Actual parameters are listed in parentheses comma separated in the same order as correspondent formal parameters are declared. Object parameter is passed implicitly. It can be used explicitly via a pseudo-variable `THIS`. If a function is returning a result, it can be called in a separate statement not assigning returning result. If the result is not required, it should be "assigned" to a `NONE`, e.g. in form: `NONE = object.Function(parameters)` Any static function can be called using a prefix style, when its first parameter is moved to a function prefix, e.g.: `x.Sin` - instead of `Sin(x)` `s.Lower.Ending(".al4")` - instead of `Ending(Lower(s), ".al4")`

#### II. 3. d. Шаблонные функции | #### II. 3. d. Generic functions

Допускается декларация обобщенных функций. Обобщенная функция должны быть статической. Обобщенная функция может принимать один или несколько параметров-функций. Декларация такого параметра: `?` Имя|_параметра(тип1, тип2, ...) ==> тип_результата Любой параметр обобщенной функции (а так же функции-параметра) может быть объявлен имеющим обобщенный тип `{?}` (что означает "любой тип", включая простые типы данных, перечисления, записи или классы). В качестве типа-параметра должен использоваться один и тот же тип данных для всех обобщенных параметров, включая параметры-функции и их результирующие типы данных. Для каждого типа параметра, с которым может вызываться функция, а так же для каждого уникального сочетания параметрических функций формируется свой уникальный экземпляр целевой функции в выходном коде. Т.к. невозможно протестировать обобщенную функцию для всех вероятных входных типов данных и/или входных параметров-функций, класс, содержащий обобщенные функции, всегда считается потенциально опасным, и должен быть отмечен маркером `GENERICS` в заголовка класса. | Parenthesis are used only if actual parameters are present. A generic function should always be static. Generic function can accept one or several function parameters. Such parameter is declared like `? Param|eter_name(type1, type2, ...) ==> result_type` Any generic function parameter can be declared having data type `{?}` which means "any type" (including simple data types, enumerations, records or classes). The same parameter data type should be used for all generic parameters including parameters and resulting data type of function parameters if any. For each data type parameter for which the function can be called, as well as for each combination of parameter functions its own unique instance of resulting function is generated in a resulting output code. Since it is not possible to test a generic function for all combinations of generic parameters, a class containing such functions must be marked with a modifier `GENERICS` in the class header.

Пример обобщённой функции: функция поиска индекса максимального значения в массиве значений: | An example of a generic function, searching an index of a maximal value in an array of integer, real or string values:

`FUN Index_max|imal_value( {?} Arr|ay_of_values) ==> INT, STATIC : ----------------------- 'for {?} = INT, REAL or STR' RESULT = Arr[0] FOR i IN [1 TO Arr[].Count-1] : ▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄ CASE Arr[i] > RESULT ? RESULT = Arr[i] ; ▄▄▄▄▄▄▄▄ █ ; . ▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄█`

Так как в приведённой функции используется операция '>', вызов её для любых типов, кроме INT, REAL, STR вызовет ошибки компиляции. | Since the above function is using the operation '>', calling it for other types then INT, REAL, STR will produce errors while compiling it.

$$STOP!