init

.gitignore

@@ -0,0 +1,20 @@
+# ---> CMake
+CMakeLists.txt.user
+CMakeCache.txt
+CMakeFiles
+CMakeScripts
+Testing
+Makefile
+cmake_install.cmake
+install_manifest.txt
+compile_commands.json
+CTestTestfile.cmake
+_deps
+
+
+build
+cmake-build-debug
+
+.old
+
+.idea

.gitmodules

@@ -0,0 +1,6 @@
+[submodule "tree-sitter-lang"]
+	path = deps/tree-sitter-lang
+	url = https://codeberg.org/ProgramSnail/tree-sitter-lang.git
+[submodule "tree-sitter"]
+	path = deps/tree-sitter
+	url = https://github.com/tree-sitter/tree-sitter.git

CMakeLists.txt

@@ -0,0 +1,18 @@
+cmake_minimum_required(VERSION 3.10)
+
+project(Lang)
+
+set(CMAKE_CXX_STANDARD 17)
+
+set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wall -Wextra")
+
+include_directories(include
+                    deps/tree-sitter-lang/src
+                    deps/tree-sitter/lib/src)
+
+
+add_executable(lang src/main.cpp
+                    parse_tree.hpp
+                    deps/tree-sitter-lang/src/tree_sitter/parser.h
+                    deps/tree-sitter-lang/src/parser.c
+                    deps/tree-sitter/lib/src/lib.c)

deps/tree-sitter

@@ -0,0 +1 @@
+Subproject commit e1ea3328f4e07895c8ff04dc6da8cda8ed0a0f45

deps/tree-sitter-lang

@@ -0,0 +1 @@
+Subproject commit d218e02a78c7a8b899c32794324b25beeb212afb

parse_tree.hpp

@@ -0,0 +1,142 @@
+#pragma once
+
+#include <string>
+
+// for clangd
+#include "tree_sitter/api.h"
+
+extern "C" const TSLanguage* tree_sitter_lang();
+
+namespace parser {
+
+class ParseTree {
+public:
+  class Node {
+  public:
+    Node() : uninitialized_(true) {
+      for (unsigned int& i : node_.context) {
+          i = 0;
+      }
+      node_.id = nullptr;
+      node_.tree = nullptr;
+
+      source_ = nullptr;
+    };
+    Node(const TSNode& node, const std::string* source) : uninitialized_(false), node_(node), source_(source) {}
+
+    std::string GetType() {
+        return ts_node_type(node_);
+    }
+
+    std::pair<size_t, size_t> GetStartPoint() {
+        TSPoint point = ts_node_start_point(node_);
+        return {point.row, point.column};
+    }
+
+    std::pair<size_t, size_t> GetEndPoint() {
+        TSPoint point = ts_node_end_point(node_);
+        return {point.row, point.column};
+    }
+
+    std::string GetAsSExpression() {
+      return ts_node_string(node_);
+    }
+
+    std::string GetValue() { // from source
+      size_t start = ts_node_start_byte(node_);
+      size_t end = ts_node_end_byte(node_);
+      return source_->substr(start, end - start);
+    }
+
+    bool IsNull() {
+      return ts_node_is_null(node_);
+    }
+
+    bool IsNamed() {
+      return ts_node_is_named(node_);
+    }
+
+    bool IsMissing() {
+      return ts_node_is_missing(node_);
+    }
+
+    bool IsExtra() { // comments, etc.
+      return ts_node_is_extra(node_);
+    }
+
+    bool HasError() {
+      return ts_node_has_error(node_);
+    }
+
+    Node NthChild(size_t n) {
+      return Node(ts_node_child(node_, n), source_);
+    }
+
+    size_t ChildCount() {
+      return ts_node_child_count(node_);
+    }
+
+    Node NthNamedChild(size_t n) {
+      return Node(ts_node_named_child(node_, n), source_);
+    }
+    size_t NamedChildCount() {
+      return ts_node_named_child_count(node_);
+    }
+
+    Node ChildByFieldName(const std::string& name) {
+      return Node(ts_node_child_by_field_name(node_, name.c_str(), name.size()), source_);
+    }
+
+    Node PreviousSibling() {
+      return Node(ts_node_prev_sibling(node_), source_);
+    }
+
+    Node PreviousNamedSibling() {
+      return Node(ts_node_prev_named_sibling(node_), source_);
+    }
+
+    Node NextSibling() {
+      return Node(ts_node_next_sibling(node_), source_);
+    }
+
+    Node NextNamedSibling() {
+      return Node(ts_node_next_named_sibling(node_), source_);
+    }
+  private:
+    bool uninitialized_;
+    TSNode node_;
+    const std::string* source_;
+  };
+
+  ParseTree(const std::string& source) : source_(source) {
+    TSParser* parser = ts_parser_new();
+    ts_parser_set_language(parser, tree_sitter_lang());
+
+    tree_ = ts_parser_parse_string(
+      parser,
+      nullptr,
+      source_.c_str(),
+      source_.size());
+
+    ts_parser_delete(parser);
+  }
+
+  ParseTree(const ParseTree& parse_tree) : tree_(ts_tree_copy(parse_tree.tree_)), source_(parse_tree.source_) {}
+
+  Node GetRoot() const {
+    return Node(ts_tree_root_node(tree_), &source_);
+  }
+
+  ~ParseTree() {
+    ts_tree_delete(tree_);
+  }
+
+  bool IsProperlyParsed() { // TODO: find place
+    return !GetRoot().HasError();
+  }
+private:
+  TSTree* tree_;
+  std::string source_; // for token value extraction
+};
+
+} // namespace parser

src/main.cpp

@@ -0,0 +1,3 @@
+int main() {
+  return 0;
+}