# Грамматика языка Ъ+ (EBNF)

Формальное описание грамматики языка «Ъ+» в форме Бэкуса — Наура (EBNF).

## Основные принципы

- **Кириллица обязательна** для ключевых конструкций (блоков)
- **Латинский алфавит опционален**, используется только для имен переменных
- **Конвейерный стиль** (`|>`) — основной способ передачи данных
- **Префиксация сущностей** (`@`, `:`, `?`) для однозначного разбора
- **Разделение мутации и вычисления** — разные операторы для сдвигов и записи в буфер

## Базовые символы

```ebnf
digit = "0" | "1" | "2" | "3" | "4" | "5" | "6" | "7" | "8" | "9";
hex_digit = digit | "a" | "b" | "c" | "d" | "e" | "f" | "A" | "B" | "C" | "D" | "E" | "F";
binary_digit = "0" | "1";
cyrillic_letter = "а".."я" | "А".."Я" | "ё" | "Ё"; 
latin_letter    = "a".."z" | "A".."Z";
letter          = cyrillic_letter | latin_letter;
```

## 1. Структура программы

```ebnf
program = { item };
item = function_definition | constant_definition | type_definition;

type_definition = "!:ТИП", identifier_body, "=", ...
constant_definition = "!:КОНСТ", identifier_body, "=", ...
```

## 2. Идентификаторы

```ebnf
variable_identifier  = "@", identifier_body;
label_identifier     = ":", identifier_body;
predicate_identifier = "?", identifier_body; 
identifier_body      = letter, {letter | digit | "_"};
```

## 3. Литералы

### 3.1. Числовые литералы

```ebnf
integer_literal = (decimal_literal | hex_literal | binary_literal), [type_suffix];
decimal_literal = digit, [{digit | "_"}, digit];
hex_literal     = "0x", hex_digit, [{hex_digit | "_"}, hex_digit];
binary_literal  = "0b", binary_digit, [{binary_digit | "_"}, binary_digit];

type_suffix = "_", type_suffix_raw;
type_suffix_raw = 
    "б8" | "ц8"  |
    "б16" | "ц16" |
    "б32" | "ц32" |
    "б64" | "ц64" | 
    "бр"  | "цр"  |
    "в32" | "в64"; 

float_literal = (decimal_literal, ".", [decimal_literal] | ".", decimal_literal), [type_suffix];
```

### 3.2. Строки и коллекции

```ebnf
string_literal  = '"', {string_char | escape_sequence}, '"';
string_char     = ? любой символ Unicode, кроме '"' и '\' ?;
escape_sequence = "\", ("n" | "t" | "r" | "\\" | '"' | "0", hex_digit, hex_digit | "u{", hex_digit, {hex_digit}, "}");

array_literal = array_fixed | array_list;
array_fixed   = "[", expression, ";", expression, "]";
array_list    = "[", [expression, {",", expression}, [","]], "]";

tuple_literal = "(", [expression, {",", expression}, [","]], ")";
```

## 4. Операторы

### 4.1. Арифметические и логические
```ebnf
    
arithmetic_operator = "+" | "-" | "*" | "/" | "%";
logical_operator    = "&&" | "||" | "!";
comparison_operator = "==" | "!=" | "<" | ">" | "<=" | ">=";
```

### 4.2. Битовые операторы
```ebnf
bitwise_operator = "&" | "|" | "^" | "~" | "<<<" | ">>>";
```

### 4.3. Специальные операторы
```ebnf
special_operator = "|>" | "<<" | "=";
```

## 5. Управляющие конструкции

### 5.1. Блоки и инструкции
```ebnf
block_start = "Ъ+";
block_end   = "Ъ-";
block       = block_start, {statement}, block_end;

statement = 
      binding_statement 
    | mutation_statement 
    | (expression, [";"]);

binding_statement  = variable_identifier, "=", expression, ";";
mutation_statement = variable_identifier, "<<", expression, ";";
```

### 5.2. Условие (Предикативное ветвление)
```ebnf
conditional_expr = "?", expression, ( block_branch | arrow_branch );

block_branch = block, [":", block];
arrow_branch = "->", expression, [":", expression]; 
```

### 5.3. Цикл (Итеративный предикат)
```ebnf
loop_expr = "?*", expression, block;
```

### 5.4. Сопоставление с образцом
```ebnf
match_expr = "?", variable_identifier, "{", match_arm, {match_arm}, "}";
match_arm  = "|", pattern, "->", (expression | block), [","]; 
pattern    = literal | variable_identifier | "_" ;
```

## 6. Функции и Типы

### 6.1. Определение функции и Типов
```ebnf
function_definition = ":", identifier_body, [parameter_list], ["->", type_descriptor], block;
parameter_list      = variable_identifier, {",", variable_identifier};

type_descriptor = type_suffix_raw | "@пусто" | array_type | tuple_type | function_type | variable_identifier;
array_type      = "[", type_descriptor, ";", expression, "]";
tuple_type      = "(", [type_descriptor, {",", type_descriptor}], ")";
function_type   = ":", "(", [type_descriptor, {",", type_descriptor}], ")", ["->", type_descriptor];
```

### 6.2. Вызовы
```ebnf
function_call = label_identifier, "(", [argument_list], ")";
argument_list = expression, {",", expression};
```

### 6.3. Лямбды
```ebnf
lambda = "@", "(", [parameter_list], "->", (expression | block), ")";
```

## 7. Выражения и Приоритеты

```ebnf
expression = mutation_expr;

(* 13: Мутация *)
mutation_expr = binding_expr, [ "<<", mutation_expr ];

(* 12: Связывание *)
binding_expr = pipeline_expr, [ "=", binding_expr ];

(* 11: Конвейер *)
pipeline_expr = logical_or_expr, { "|>", (function_call | lambda | label_identifier) };

(* 10: Логическое ИЛИ *)
logical_or_expr = logical_and_expr, { "||", logical_and_expr };

(* 9: Логическое И *)
logical_and_expr = comparison_expr, { "&&", comparison_expr };

(* 8: Сравнение *)
comparison_expr = bitwise_or_expr, [ comparison_operator, bitwise_or_expr ];

(* 7: Битовое ИЛИ *)
bitwise_or_expr = bitwise_xor_expr, { "|", bitwise_xor_expr };

(* 6: Битовое XOR *)
bitwise_xor_expr = bitwise_and_expr, { "^", bitwise_and_expr };

(* 5: Битовое И *)
bitwise_and_expr = shift_expr, { "&", shift_expr };

(* 4: Сдвиги *)
shift_expr = additive_expr, { ("<<<" | ">>>"), additive_expr };

(* 3: Сложение / Вычитание *)
additive_expr = multiplicative_expr, { ("+" | "-"), multiplicative_expr };

(* 2: Умножение / Деление / Остаток (Уровень power_expr удален) *)
multiplicative_expr = unary_expr, { ("*" | "/" | "%"), unary_expr };

(* 1: Унарные операторы и Постфиксные выражения *)
unary_expr = ("-" | "!" | "~"), unary_expr | postfix_expr;

(* 0: Постфиксные (Индексация, Доступ к полям) и Первичные *)
postfix_expr  = primary_expr, { index_access | member_access };
index_access  = "[", expression, "]";
member_access = ".", identifier_body;

primary_expr = 
      literal
    | variable_identifier
    | function_call
    | lambda
    | parenthesized_expr
    | block
    | conditional_expr
    | match_expr
    | loop_expr;

parenthesized_expr = "(", expression, ")";
literal = integer_literal | float_literal | string_literal | array_literal | tuple_literal;
```

## 8. Комментарии

```ebnf
comment = "<[", {comment_content | comment}, "]>";
comment_content = ? любой символ, кроме последовательности "]>" и начала вложенного "<[" ?;
```

## 9. Пример кода (Валидация по грамматике)

```rust
<[ Пример функции вычисления CRC ]>
:Вычислить_ЦРЦ @данные, @длина -> @црц Ъ+
    @црц = 0xFFFFFFFF_бр; 
    @и   = 0_бр;
    
    ?* (@и < @длина) Ъ+
        @байт = @данные[@и];
        @црц = @црц ^ @байт;
        @к = 0_б8;
        
        ?* (@к < 8_б8) Ъ+
            ? (@црц & 1_бр) -> (@црц >>> 1) ^ 0xEDB88320_бр : (@црц >>> 1);
            @к << @к + 1_б8;
        Ъ-
        
        @и << @и + 1_бр;
    Ъ-
    
    @црц = ~@црц;
Ъ-
```

## Примечания

- **Кодировка**: UTF-8 (ISO/IEC 10646)
- **Отслеживание позиций**: Каждый токен имеет координаты (строка, столбец) для сквозного аудита
- **Детерминизм**: Язык предназначен для создания детерминированного системного ПО
- **Безопасность**: Минимизация вектора атак, использование no_std окружения
- **Аппаратная поддержка**: Оптимизация для архитектур «Эльбрус» (предикатное исполнение) и x86