feat: initial commit

Author: EightM

.gitignore

@@ -0,0 +1,2 @@
+/target
+/Cargo.lock

.idea/.gitignore

@@ -0,0 +1,12 @@
+[package]
+name = "onescript-preprocessor"
+version = "0.1.0"
+edition = "2021"
+authors = ["Viktor Gukov <[email protected]>"]
+license = "MIT"
+repository = "https://github.com/EightM/onescript-preprocessor"
+description = "Preprocessor for OneScript language"
+
+# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+
+[dependencies]

.idea/modules.xml

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2023 EightM <[email protected]>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

.idea/onescript-preprocessor.iml

@@ -0,0 +1,31 @@
+# onescript-preprocessor
+
+Препроцессор языка OneScript
+
+## Зачем нужен?
+
+* Удалять директивы препроцессора из исходного текста
+* Получать информацию которая хранится в директивах препроцессора
+
+## Что умеет?
+
+* [x] Получать на вход строку исходного текста, удалять из нее директивы препроцессора и возвращать "чистую" строку 
+* [ ] Возвращать информацию о том, в каких областях (с какими именами) находятся токены исходного текста
+* [ ] Возвращать информацию об именах библиотек используемых в директивах `#Использовать`
+
+## Как использовать?
+
+```rust
+use onescript_preprocessor::preprocessor::Preprocessor;
+
+fn main() {
+    let example = "#region Test\nProcedure Test()\nEndProcedure\n#EndRegion";
+    let preprocessor = Preprocessor::new();
+
+    let result = preprocessor.preprocess(example);
+}
+```
+
+## Что нужно иметь в виду?
+
+Пока не готовы все три галочки, публичное API может изменяться как ему будет удобнее.

.idea/sonarlint/issuestore/index.pb

@@ -0,0 +1,196 @@
+use std::collections::HashMap;
+use std::iter::Peekable;
+use std::str::Chars;
+use crate::token::{KeywordTable, Token, TokenKind};
+
+/// Лексер, разбирающий исходный текст на токены
+pub struct Lexer {
+    current_line: u16,
+}
+
+impl Lexer {
+    /// Создает новый экземпляр лексера. Отсчет номеров строк токенов начинается с 1.
+    pub fn new() -> Self { Lexer { current_line: 1 } }
+
+    /// Осуществляет лексинг переданного исходного текста. Возвращает вектор токенов, включающих в себя
+    /// как простой текст, так и токены инструкций препроцессора
+    pub fn lex(&mut self, source: &str) -> Vec<Token> {
+        let mut chars = source.chars().peekable();
+        let mut tokens: Vec<Token> = Vec::new();
+        let keywords_table = KeywordTable::new();
+
+        while let Some(char) = chars.peek() {
+            match char {
+                '#' => {
+                    chars.next();
+
+                    if match_char('!', &mut chars) {
+                        let token = Token::new(TokenKind::Shebang, "#!".to_string(), self
+                            .current_line, self.current_line);
+                        tokens.push(token);
+                        Lexer::shebang_text(self, &mut tokens, &mut chars);
+                    } else {
+                        let token = Token::new(TokenKind::Hash, "#".to_string(), self
+                            .current_line, self.current_line);
+                        tokens.push(token);
+                        Lexer::preprocessor_line(self, &mut tokens, &mut chars, &keywords_table);
+                    }
+                }
+                _ => {
+                    Lexer::text(self, &mut tokens, &mut chars);
+                }
+            }
+        }
+
+        tokens
+    }
+
+    fn shebang_text(&mut self, tokens: &mut Vec<Token>, chars: &mut Peekable<Chars>) {
+        let mut text_chars: Vec<char> = Vec::new();
+        let start_line = self.current_line;
+        let end_line = self.current_line;
+
+        while let Some(char) = chars.peek() {
+            match char {
+                '\n' => {
+                    break;
+                }
+                _ => {
+                    text_chars.push(*char);
+                    chars.next();
+                }
+            }
+        }
+
+        if !text_chars.is_empty() {
+            let token = Token::new(TokenKind::Text, text_chars.iter().collect(), start_line, end_line);
+            tokens.push(token);
+        }
+    }
+
+    fn preprocessor_line(&mut self, tokens: &mut Vec<Token>, chars: &mut Peekable<Chars>, keywords: &KeywordTable) {
+        while let Some(char) = chars.peek() {
+            match char {
+                '\n' => {
+                    break;
+                }
+                char if char.is_alphabetic() || *char == '_' => {
+                    let token = Lexer::identifier(self, chars, &keywords.table);
+                    tokens.push(token);
+                }
+                '"' => {
+                    let mut token = Lexer::string(self, chars);
+                    token.token_kind = TokenKind::Path;
+                    tokens.push(token);
+                }
+                _ => {
+                    chars.next();
+                }
+            }
+        }
+    }
+
+    fn identifier(&mut self, chars: &mut Peekable<Chars>, keywords: &HashMap<String, TokenKind>) -> Token {
+        let mut text_chars: Vec<char> = Vec::new();
+
+        while let Some(char) = chars.peek() {
+            if char.is_alphabetic() || *char == '_' {
+                text_chars.push(*char);
+                chars.next();
+            } else {
+                break;
+            }
+        }
+
+        let identifier: String = String::from_iter(text_chars);
+        if let Some(token_kind) = keywords.get(identifier.to_uppercase().as_str()) {
+            return Token::new(*token_kind, identifier, self.current_line, self.current_line);
+        }
+
+        return Token::new(TokenKind::Identifier, identifier, self.current_line, self.current_line);
+    }
+
+    fn text(&mut self, tokens: &mut Vec<Token>, chars: &mut Peekable<Chars>) {
+        let mut text_chars: Vec<char> = Vec::new();
+        let mut string_or_date = false;
+        let start_line = self.current_line;
+        let mut end_line = self.current_line;
+
+        while let Some(char) = chars.peek() {
+            match char {
+                '#' => {
+                    if !string_or_date {
+                        break;
+                    } else {
+                        text_chars.push(*char);
+                        chars.next();
+                    }
+                }
+                '"' | '\'' => {
+                    if string_or_date == false {
+                        string_or_date = true
+                    } else {
+                        string_or_date = false
+                    }
+                    text_chars.push(*char);
+                    chars.next();
+                }
+                '\n' => {
+                    self.current_line = self.current_line + 1;
+                    end_line = end_line + 1;
+                    text_chars.push(*char);
+                    chars.next();
+                }
+                _ => {
+                    text_chars.push(*char);
+                    chars.next();
+                }
+            }
+        }
+
+        let token = Token::new(TokenKind::Text, text_chars.into_iter().collect(),
+                               start_line, end_line);
+        tokens.push(token);
+    }
+
+    fn string(&mut self, chars: &mut Peekable<Chars>) -> Token {
+        let mut text_chars: Vec<char> = Vec::new();
+        // add first quote symbol
+        text_chars.push(chars.next().unwrap());
+        let start_line = self.current_line;
+        let mut end_line = self.current_line;
+
+        while let Some(char) = chars.next() {
+            match char {
+                char if char == '"' => {
+                    text_chars.push(char);
+                    break;
+                }
+                '\n' => {
+                    self.current_line = self.current_line + 1;
+                    end_line = end_line + 1;
+                    text_chars.push(char);
+                }
+                _ => { text_chars.push(char) }
+            }
+        }
+
+        Token::new(TokenKind::Text, text_chars.into_iter().collect(), start_line, end_line)
+    }
+}
+
+fn match_char(expected: char, chars: &mut Peekable<Chars>) -> bool {
+    let next_char = chars.peek();
+
+    if next_char.is_none() {
+        return false;
+    }
+
+    if next_char.is_some() && *next_char.unwrap() != expected {
+        return false;
+    }
+
+    // Consume matched character
+    chars.next();
+    true
+}

.idea/vcs.xml

@@ -0,0 +1,12 @@
+#![warn(missing_docs)]
+//! Реализация препроцессора для языка программирования OneScript.
+//! Позволяет разобрать исходный текст программ на OneScript, обработать и удалить директивы препроцессора
+
+/// Модуль содержащий API для работы с лексером
+pub mod lexer;
+
+/// Модуль для имплементации токенов разбора исходного текста
+pub mod token;
+
+/// Модуль содержащий API для работы с препроцессором
+pub mod preprocessor;

Cargo.toml

@@ -0,0 +1,52 @@
+use crate::lexer::Lexer;
+use crate::token::TokenKind;
+
+/// Представление препроцессора
+pub struct Preprocessor {}
+
+impl Preprocessor {
+    /// Возвращает новый экземпляр препроцессора
+    pub fn new() -> Self {
+        return Preprocessor {};
+    }
+
+    /// Обрабатывает переданный исходный текст, разбирая его на токены. Токены инструкций препроцессора
+    /// заменяются на пробелы. Остальной текст добавляется без изменений
+    ///
+    /// # Arguments
+    ///
+    /// * `source`: исходный текст для разбора
+    ///
+    /// returns: String исходный текст с удаленными директивами препроцессора
+    ///
+    /// # Examples
+    ///
+    /// ```
+    ///     use onescript_preprocessor::preprocessor::Preprocessor;
+    ///     let example = "#region Test\nProcedure Test()\nEndProcedure\n#EndRegion";
+    ///     let expected = " \nProcedure Test()\nEndProcedure\n ";
+    ///
+    ///     let preprocessor = Preprocessor::new();
+    ///     let result = preprocessor.preprocess(example);
+    ///     assert_eq!(expected, result);
+    /// ```
+    pub fn preprocess(&self, source: &str) -> String {
+        let mut lexer = Lexer::new();
+        let tokens = lexer.lex(source);
+        let mut result: String = String::new();
+
+        for token in &tokens {
+            match token.token_kind {
+                TokenKind::Hash => { result.push(' ') }
+                TokenKind::Shebang => { result.push(' ') }
+                TokenKind::Text => { result.push_str(&token.lexeme) }
+                TokenKind::Keyword(_) => {}
+                TokenKind::Path => {}
+                TokenKind::ShebangText => {}
+                TokenKind::Identifier => {}
+            }
+        };
+
+        result
+    }
+}