rename

4 files changed, 403 insertions, 0 deletions

diff --git a/include/lexer/ast.h b/include/lexer/ast.h
new file mode 100644
index 0000000..05ba553
--- /dev/null
+++ b/include/lexer/ast.h
@@ -0,0 +1,139 @@
+#pragma once
+
+#include <string>
+
+#include "parser/enum_type.h"
+#include "parser/token.h"
+#include "parser/shared.h"
+
+using namespace std; // remove this
+
+namespace ov4
+{
+
+class T_token;
+
+class T_ast
+{
+public:
+    T_ast() = default;
+
+    enum_token_type token_type;
+    string command_text;
+    size_t left = string::npos;
+    size_t right = string::npos;
+};
+
+string final_trim(size_t _begin, size_t _end)
+{
+    string s;
+    for (size_t i = _begin; i < _end; i++)
+    {
+        if (token[i].token_type != TEXT)
+            continue;
+        s += token[i].text + " ";
+    }
+    s = s.substr(0, s.size()-1); // eat final space
+    return s;
+}
+
+size_t alloc_ast()
+{
+    ast.emplace_back();
+    return ast_index++;
+}
+
+int get_pivot_order(enum_token_type x)
+{
+    switch(x)
+    {
+        case ASYNC:
+        case SEMICOLON:
+            return 1000;
+        
+        case LOGIC_AND:
+        case LOGIC_OR:
+            return 500;
+
+        case PIPE:
+            return 100;
+            
+        default:
+            return 0;
+    }
+    return 0;
+}
+
+bool is_operator(enum_token_type x)
+{
+    switch(x)
+    {
+        case LOGIC_AND:
+        case LOGIC_OR:
+        case PIPE:
+        case ASYNC:
+            return true;
+        default:
+            return false;
+    }
+}
+
+// region [begin, end)
+void parse(size_t cmd_begin, size_t cmd_end, size_t ast_vec)
+{
+    int current_depth = 0;
+    int current_order = -1;
+    int max_depth = -1;
+    size_t found_pos = string::npos;
+
+    for (size_t i = cmd_begin; i < cmd_end; i++)
+    {
+        if (token[i].bracket_depth > max_depth)
+            max_depth = token[i].bracket_depth;
+    }
+
+
+    while (found_pos == string::npos)
+    {
+        // scan from right to left
+        for (size_t i = cmd_end - 1; i >= cmd_begin && i < cmd_end; i--)
+        {
+            // if same depth
+            // and higher order number
+            if (token[i].bracket_depth == current_depth 
+                && is_operator(token[i].token_type) 
+                && get_pivot_order(token[i].token_type) > current_order)
+            {
+                current_order =  get_pivot_order(token[i].token_type);
+                found_pos = i;
+                println("Found pos: {} order: {} depth: {}", i, current_order, current_depth);
+            }
+        }
+        current_depth++;
+        if (current_depth > max_depth)
+        {
+            break;
+        }
+    }
+
+    if (found_pos == string::npos)
+    {
+        println("Smallest unit");
+        ast[ast_vec].token_type = TEXT;
+        ast[ast_vec].command_text = final_trim(cmd_begin, cmd_end);
+        return;
+    }
+
+    size_t l = alloc_ast();
+    size_t r = alloc_ast();
+    ast[ast_vec].left = l;
+    ast[ast_vec].right = r;
+    ast[ast_vec].token_type = token[found_pos].token_type;
+
+    println("Parse sub: {}, {}, {}", cmd_begin, found_pos, cmd_end);
+
+    parse(cmd_begin, found_pos, l);
+    parse(found_pos+1, cmd_end, r);
+}
+
+}
diff --git a/include/lexer/enum_type.h b/include/lexer/enum_type.h
new file mode 100644
index 0000000..9de3dc7
--- /dev/null
+++ b/include/lexer/enum_type.h
@@ -0,0 +1,28 @@
+#pragma once
+
+namespace ov4
+{
+
+enum enum_token_type
+{
+    TEXT,                   //    foo
+    SINGLE_QUOTATION,       //    '
+    DOUBLE_QUOTATION,       //    "
+    LOGIC_AND,              //    &&
+    LOGIC_OR,               //    ||
+    ASYNC,                  //    &
+    PIPE,                   //    |    
+    SEMICOLON,              //    ;
+    EXPAND,                 //    $
+    LEFT_BRACKET,           //    (
+    RIGHT_BRACKET,          //    )
+};
+
+enum guard_type
+{
+    GUARD_OFF,
+    GUARD_WEAK,
+    GUARD_STRONG,
+};
+
+}
diff --git a/include/lexer/shared.h b/include/lexer/shared.h
new file mode 100644
index 0000000..01f1483
--- /dev/null
+++ b/include/lexer/shared.h
@@ -0,0 +1,19 @@
+#pragma once
+
+#include <string>
+#include <vector>
+
+#include "parser/enum_type.h"
+
+namespace ov4
+{
+
+class T_ast;
+class T_token;
+
+inline size_t ast_index = 0;
+
+inline std::vector<T_ast> ast;
+inline std::vector<T_token> token;
+
+}
diff --git a/include/lexer/token.h b/include/lexer/token.h
new file mode 100644
index 0000000..5b65d67
--- /dev/null
+++ b/include/lexer/token.h
@@ -0,0 +1,217 @@
+#pragma once
+
+#include <string>
+
+#include "parser/enum_type.h"
+#include "parser/shared.h"
+
+using namespace std; // remove this
+
+namespace ov4
+{
+
+class T_token
+{
+public:
+    T_token() = default;
+
+    enum_token_type token_type;
+    string text;
+    guard_type guard = GUARD_OFF;
+    int bracket_depth = 0;
+};
+
+size_t find_non_space_previous(string s, size_t i)
+{
+    size_t len = s.size(), backup = i;
+    i--; // skip current char
+    for ( ; i < len; i--)
+        if (s[i] != ' ')
+            return i+1; // because region is [x, y) 
+
+    return backup;
+}
+
+string trim_space(const string &s)
+{
+    size_t b = s.find_first_not_of(" \t");
+    if (b == string::npos)
+        return "";
+    size_t e = s.find_last_not_of(" \t");
+    return s.substr(b, e - b + 1);
+}
+
+
+bool is_symbol(char c)
+{
+    if (c == '&' || c == '|' || c == '(' || c == ')')
+        return true;
+    return false;
+}
+
+bool is_symbol_same(string x, string y)
+{
+    string tmp = "";
+    for (size_t i = 0; i < x.size(); i++)
+    {
+        if (x[i] != ' ')
+            tmp += x[i];
+    }
+    return (tmp == y);
+}
+
+void bracket_depth_changer(char c, int &bracket_depth)
+{
+    if (c == '(')
+    {
+        bracket_depth++;
+        println("changed depth: {}", bracket_depth);
+        return;
+    }
+    if (c == ')')
+    {
+        bracket_depth--;
+        println("changed depth: {}", bracket_depth);
+        return;
+    }
+}
+
+// handle [prev, current)
+void token_push(string s, size_t current, size_t prev, int bracket_depth, bool is_symbol_prev)
+{
+    T_token tmp;
+    string sub = s.substr(prev, current - prev);
+        cout << "substr " << sub << endl;
+
+    tmp.bracket_depth = bracket_depth;
+    if (is_symbol_prev)
+    {
+        if (is_symbol_same(sub, "&&"))
+        {
+            cout << "&& symbol" << endl;
+            tmp.token_type = LOGIC_AND;
+        }
+        else if (is_symbol_same(sub, "||"))
+        {
+            cout << "|| symbol" << endl;
+            tmp.token_type = LOGIC_OR;
+        }
+        else if (is_symbol_same(sub, "&"))
+        {
+            cout << "& symbol" << endl;
+            tmp.token_type = ASYNC;
+        }
+        else if (is_symbol_same(sub, "|"))
+        {
+            cout << "| symbol" << endl;
+            tmp.token_type = PIPE;
+        }
+        else if (is_symbol_same(sub, "("))
+        {
+            cout << "( symbol" << endl;
+            tmp.token_type = LEFT_BRACKET;
+        }
+        else if (is_symbol_same(sub, ")"))
+        {
+            cout << ") symbol" << endl;
+            tmp.token_type = RIGHT_BRACKET;
+        }
+        else
+        {
+            cerr << "ERROR: is symbol but not symbol" << endl;
+            return;
+        }
+        token.push_back(tmp);
+        return;
+    }
+
+    string trimed = trim_space(sub);
+    if (trimed == "")   return;
+
+    tmp.token_type = TEXT;
+    tmp.text = trimed;
+    token.push_back(tmp);
+}
+
+int tokenizer(string s)
+{
+    if (s.size() == 0) return -1;
+
+    size_t len = s.size();
+    size_t prev = 0;
+    size_t token_vector_index = 0;
+    bool is_in_symbol;
+    int bracket_depth = 0;
+
+    if (is_symbol(s[0]))
+        is_in_symbol = true;
+    else
+        is_in_symbol = false;
+    for (size_t i = 0; i < len; i++)
+    {
+        println("---");
+        println("prev {} current char {}", prev, s[i]);
+
+
+        // turn from symbol to text
+        if (is_in_symbol && !is_symbol(s[i]))
+        {
+            cout << s[i] <<" symbol -> text" << endl;
+            is_in_symbol = false;
+            token_push(s, i, prev, bracket_depth, true);
+            prev = i;
+            bracket_depth_changer(s[i], bracket_depth);
+            continue;
+        }
+
+        // turn from text to symbol
+        if (!is_in_symbol && is_symbol(s[i]))
+        {
+            cout << s[i] << " text -> symbol" << endl;
+            is_in_symbol = true;
+            token_push(s, i, prev, bracket_depth, false);
+            prev = i;
+            bracket_depth_changer(s[i], bracket_depth);
+            continue;
+        }
+
+        bracket_depth_changer(s[i], bracket_depth);
+
+        // text continue
+        if (!is_in_symbol && !is_symbol(s[i]))
+        {
+            cout << s[i] <<" still text" << endl;
+            continue;
+        }
+
+        // symbol continue
+        if (is_in_symbol && is_symbol(s[i]))
+        {
+            cout << s[i] <<" still symbol" << endl;
+            continue;
+        }
+    }
+
+    if (bracket_depth != 0)
+    {
+        cerr << "Brackets are not paired" << endl;
+        return -1;
+    }
+
+    // final round text
+    if (!is_symbol(s[len - 1]))
+    {
+        cout << s[len - 1] << " final text" << endl;
+        token_push(s, len, prev, 0, false);
+    }
+
+    // final round symbol
+    if (is_symbol(s[len - 1]))
+    {
+        cout << s[len - 1] << " final symbol" << endl;
+        token_push(s, len, prev, 0, true);
+    }
+    return 0;
+}
+
+}