1.1.0

Author: FlacSy

GiraffeInterpreter/src/lib.rs

@@ -7,4 +7,5 @@ edition = "2021"
 GiraffeInterpreter ={ path = "../GiraffeInterpreter"}
 GiraffeLexer = { path = "../GiraffeLexer" }
 GiraffeAST = { path = "../GiraffeAST"}
-GiraffeParser ={ path = "../GiraffeParser"}
+GiraffeParser ={ path = "../GiraffeParser"}
+colored = "2.0"

GiraffeLanguage/Cargo.toml

@@ -1,22 +1,50 @@
 use std::env;
 use std::fs;
+use colored::*;
 use std::process;
 use GiraffeLexer::Lexer;
 use GiraffeParser::Parser;
 use GiraffeInterpreter::interpret;
 
+
+fn print_error(title: &str, details: &[(&str, String)], filename: &str, line: usize, column: usize) {
+    let absolute_path = match fs::canonicalize(filename) {
+        Ok(path) => path.display().to_string(),
+        Err(_) => filename.to_string(),
+    };
+
+    eprintln!("{}", format!("error: {}", title).red().bold());
+    
+    eprintln!(" --> {}:{}:{}", absolute_path, line, column);
+    eprintln!("  |");
+    
+    for (label, value) in details {
+        eprintln!("{} {}", label.green().bold(), value);
+    }
+
+    eprintln!("  |");
+    eprintln!("  |                 ^");
+    eprintln!();
+}
+
 fn main() {
     let args: Vec<String> = env::args().collect();
     if args.len() < 2 {
-        eprintln!("Usage: {} <filename>", args[0]);
+        eprintln!("{}", "Использование: <filename>".red().bold());
         process::exit(1);
     }
 
     let filename = &args[1];
     let source_code = match fs::read_to_string(filename) {
         Ok(content) => content,
         Err(err) => {
-            eprintln!("Ошибка при чтении файла {}: {}", filename, err);
+            print_error(
+                "Ошибка при чтении файла",
+                &[("Детали", err.to_string())],
+                filename,
+                0,
+                0,
+            );
             process::exit(1);
         }
     };
@@ -31,12 +59,27 @@ fn main() {
             if let Ok(program) = program {
                 interpret(program);
             } else {
-                eprintln!("Ошибка при парсинге программы!");
+                let error_token = parser.get_current_token();
+                print_error(
+                    "Ошибка при парсинге программы",
+                    &[
+                        ("Найденное значение", error_token.value.clone())
+                    ],
+                    filename,
+                    error_token.line,
+                    error_token.column,
+                );
                 process::exit(1);
             }
         },
         Err(err) => {
-            eprintln!("Ошибка токенизации: {:?}", err);
+            print_error(
+                "Ошибка токенизации",
+                &[("Детали", format!("{:?}", err))],
+                filename,
+                0,
+                0,
+            );
             process::exit(1);
         }
     }

GiraffeLanguage/src/main.rs

@@ -51,13 +51,17 @@ pub enum TokenType {
 pub struct Token {
     pub token_type: TokenType,
     pub value: String,
+    pub line: usize,
+    pub column: usize,
 }
 
 impl Token {
-    pub fn new(token_type: TokenType, value: &str) -> Self {
+    pub fn new(token_type: TokenType, value: &str, line: usize, column: usize) -> Self {
         Token {
             token_type,
             value: value.to_string(),
+            line,
+            column,
         }
     }
 }
@@ -74,7 +78,7 @@ impl Lexer {
         for kw in &[
             "const", "func", "var", "if", "elif", "else", "while", "for",
             "continue", "break", "return", "is", "in", "and", "or", "not",
-            "try", "handle", "finally"
+            "try", "handle", "finally", "get"
         ] {
             keywords.insert(kw.to_string(), TokenType::KEYWORD);
         }
@@ -155,38 +159,51 @@ impl Lexer {
         let mut tokens = Vec::new();
         let mut position = 0;
         let code_len = code.len();
+        
+        let mut line = 1;
+        let mut column = 1;
 
         while position < code_len {
             let slice = &code[position..];
             let mut matched = false;
 
             for (regex, token_type_opt) in &self.regex_patterns {
                 if let Some(mat) = regex.find(slice) {
-                    // Благодаря якорю, совпадение должно начинаться с 0
                     if mat.start() != 0 {
                         continue;
                     }
                     let value = &slice[mat.start()..mat.end()];
-                    // Если шаблон возвращает None – пропускаем (например, пробелы)
+                    
                     if let Some(token_type) = token_type_opt {
-                        tokens.push(Token::new(token_type.clone(), value));
+                        tokens.push(Token::new(token_type.clone(), value, line, column));
                     }
+
+                    for ch in value.chars() {
+                        if ch == '\n' {
+                            line += 1;
+                            column = 1;
+                        } else {
+                            column += 1;
+                        }
+                    }
+
                     position += mat.end();
                     matched = true;
                     break;
                 }
             }
 
             if !matched {
+                let err_char = code[position..].chars().next().unwrap();
                 return Err(format!(
-                    "Нераспознанный символ на позиции {}: '{}'",
-                    position,
-                    &code[position..].chars().next().unwrap()
+                    "Нераспознанный символ на позиции {} (line {}, column {}): '{}'",
+                    position, line, column, err_char
                 ));
             }
         }
 
-        tokens.push(Token::new(TokenType::EOF, "EOF"));
+        // Добавляем токен EOF с текущими координатами
+        tokens.push(Token::new(TokenType::EOF, "EOF", line, column));
         Ok(tokens)
     }
-}
+}

GiraffeLexer/src/lib.rs

@@ -1,19 +1,25 @@
 use GiraffeAST::*;
 use GiraffeLexer::{Token, TokenType};
-use std::collections::HashMap;
 use ordered_float::OrderedFloat;
 
 
 /// Структура парсера, содержащая список токенов и текущую позицию в них.
 pub struct Parser {
     tokens: Vec<Token>,
     pos: usize,
+    code_line: usize,
+    code_pos: usize,
 }
 
 impl Parser {
     /// Создаёт новый парсер на основе вектора токенов.
     pub fn new(tokens: Vec<Token>) -> Self {
-        Parser { tokens, pos: 0 }
+        Parser {
+            tokens,
+            pos: 0,
+            code_pos: 0,
+            code_line: 1,
+        }
     }
 
     /// Возвращает текущий токен.
@@ -24,9 +30,13 @@ impl Parser {
     /// Переходит к следующему токену.
     fn advance(&mut self) {
         if self.pos < self.tokens.len() {
+            let token = &self.tokens[self.pos];
+            self.code_line = token.line;
+            self.code_pos = token.column;
+            
             self.pos += 1;
         }
-    }
+    }    
 
     /// Проверяет, достигнут ли конец входного потока.
     fn is_at_end(&self) -> bool {
@@ -154,9 +164,10 @@ impl Parser {
                 if self.peek_token_is(TokenType::OPERATOR, Some("=")) {
                     self.parse_assignment()
                 } else {
-                    Err(format!("Неожиданный идентификатор: {}", token.value))
+                    let expr = self.parse_expression()?;
+                    Ok(Statement::ExpressionStatement(expr))
                 }
-            }
+            }            
             _ => Err(format!("Неожиданный токен в операторе: {:?}", token)),
         }
     }        
@@ -788,4 +799,16 @@ impl Parser {
         let token = self.current();
         token.token_type == TokenType::KEYWORD && token.value == kw
     }
+
+    // =========================================================================
+    // Вспомогательные функции для составления ошибок
+    // =========================================================================
+
+    pub fn get_current_position(&self) -> usize {
+        return self.pos;
+    }
+
+    pub fn get_current_token(&self) -> Token {
+        return self.tokens[self.pos].clone();
+    }
 }

GiraffeParser/src/lib.rs

@@ -19,6 +19,13 @@
   - [x] `TryHandleStatement` (try-catch-finally)
   - [x] `ReturnStatement` (возврат значений из функций)
   - [x] `Break/Continue` (выход из цикла)
+  - [ ] Диапазоны (range для цикла for)
+
+- [ ] Модули
+  - [ ] Импорты (`.gfe` файлы)
+  - [ ] API интерпритатора для библиотек 
+  - [ ] IO библиотека 
+  
 
 - [x] **Обработка выражений** (`Expression`)
   - [x] Литералы (`Literal`)
@@ -36,7 +43,7 @@
   - [x] Логические операции (`&&`, `||`)
 
 #### **3. Ошибки**
-- [?] Вывод ошибок в понятном формате (`Error(String)`)
+- [x] Вывод ошибок в понятном формате (`Error(String)`)
 - [ ] Поддержка исключений (`TryHandleStatement`)
 
 #### **4. Дополнительно**