ADD: init compiler and rename the project.

.gitignore

@@ -0,0 +1,4 @@
+*~*
+*\#*
+build
+.cache

Makefile

@@ -0,0 +1,11 @@
+.PHONY: build tests
+
+build:
+	meson setup build
+	meson compile -C build
+
+test: build
+	build/wongotest
+
+install: test
+	meson install -C build

doc/grammar.bnf

@@ -0,0 +1,4 @@
+PROG ::= INSTR*
+INSTR ::= DIR
+DIR ::= hash ident EXPR
+EXPR ::= ident

lib/Compiler.cpp

@@ -0,0 +1,17 @@
+#include "Compiler.hpp"
+
+namespace wg
+{
+  /*explicit*/ Compiler::Compiler()
+  {
+  }
+
+  /*virtual*/ Compiler::~Compiler()
+  {
+  }
+
+  void Compiler::compile(std::shared_ptr<Node> node)
+  {
+    std::cout << node->string() << std::endl;
+  }
+}

lib/Compiler.hpp

@@ -0,0 +1,32 @@
+#ifndef wg_COMPILER_HPP
+#define wg_COMPILER_HPP
+
+#include <llvm/IR/LLVMContext.h>
+#include <llvm/IR/IRBuilder.h>
+#include <llvm/IR/Module.h>
+
+#include "commons.hpp"
+#include "Node.hpp"
+
+namespace wg
+{
+  class Compiler
+  {
+  public:
+    explicit Compiler();
+    virtual ~Compiler();
+
+    void compile(std::shared_ptr<Node> node);
+  private:
+    std::unique_ptr<llvm::LLVMContext> m_context =
+      std::make_unique<llvm::LLVMContext>();
+
+    std::unique_ptr<llvm::IRBuilder<>> m_builder =
+      std::make_unique<llvm::IRBuilder<>>(*m_context);
+
+    std::unique_ptr<llvm::Module> m_module =
+      std::make_unique<llvm::Module>("my module", *m_context);
+  };
+}
+
+#endif

lib/Lexer.cpp

@@ -0,0 +1,157 @@
+#include "Lexer.hpp"
+
+namespace wg
+{
+  /*explicit*/ Lexer::Lexer()
+  {
+    add_text("#", NODE_HASH);
+
+    m_scanners.push_back(std::bind(&Lexer::scan_ident, this));
+  }
+
+  /*virtual*/ Lexer::~Lexer()
+  {
+  }
+
+  void Lexer::scan(std::string const& source)
+  {
+    m_source = source;
+    m_cursor = 0;
+  }
+
+  std::shared_ptr<Node> Lexer::next()
+  {
+    std::optional<ScanInfo> scan_info;
+
+    skip_spaces();
+
+    for (auto scanner: m_scanners)
+      {
+        auto info = scanner();
+
+        if (info && (scan_info == std::nullopt
+                     || info->cursor > scan_info->cursor))
+          {
+            scan_info = info;
+          }
+      }
+
+    if (scan_info)
+      {
+        m_cursor = scan_info->cursor;
+
+        return std::make_shared<Node>(scan_info->type,
+                                      scan_info->repr,
+                                      m_loc);
+      }
+
+    WG_ASSERT(m_cursor <= m_source.size(), "unexpected token");
+
+    return nullptr;
+  }
+
+  std::vector<std::shared_ptr<Node>> Lexer::all()
+  {
+    std::vector<std::shared_ptr<Node>> result;
+    std::shared_ptr<Node> node;
+
+    while ( (node = next()) != nullptr )
+      {
+        result.push_back(node);
+      }
+
+    return result;
+  }
+
+  void Lexer::add_text(std::string const& text,
+                       NodeType node,
+                       bool has_value)
+  {
+    if (text.size() == 1)
+      {
+        m_seps.push_back(text[0]);
+      }
+
+    m_scanners.push_back(std::bind(&Lexer::scan_text,
+                                   this, text,
+                                   node, has_value));
+  }
+
+  bool Lexer::is_sep(size_t index) const
+  {
+    WG_ASSERT(index < m_source.size(), "cannot find separator");
+
+    if (std::isspace(m_source[index]))
+      {
+        return true;
+      }
+
+    auto itr = std::find(std::begin(m_seps),
+                         std::end(m_seps),
+                         m_source[index]);
+
+    return itr != std::end(m_seps);
+  }
+
+  void Lexer::skip_spaces()
+  {
+    while (m_cursor < m_source.size()
+           && std::isspace(m_source[m_cursor]))
+      {
+        if (m_source[m_cursor] == '\n')
+          {
+            m_loc = Loc {m_loc.origin(), m_loc.line() + 1};
+          }
+
+        m_cursor++;
+      }
+  }
+
+  std::optional<ScanInfo> Lexer::scan_text(std::string const& text,
+                                           NodeType type,
+                                           bool has_value) const
+  {
+    if (m_cursor + text.size() > m_source.size())
+      {
+        return std::nullopt;
+      }
+
+    for (size_t i=0; i<text.size(); i++)
+      {
+        if (m_source[m_cursor + i] != text[i])
+          {
+            return std::nullopt;
+          }
+      }
+
+    return ScanInfo {
+      m_cursor + text.size(),
+      type,
+      has_value ? text : ""
+    };
+  }
+
+  std::optional<ScanInfo> Lexer::scan_ident() const
+  {
+    size_t cursor = m_cursor;
+    std::string repr;
+
+    while (cursor < m_source.size()
+           && !is_sep(cursor))
+      {
+        repr += m_source[cursor];
+        cursor++;
+      }
+
+    if (repr.empty() == false)
+      {
+        return ScanInfo {
+          cursor,
+          NODE_IDENT,
+          repr
+        };
+      }
+
+    return std::nullopt;
+  }
+}

lib/Lexer.hpp

@@ -0,0 +1,52 @@
+#ifndef wg_LEXER_HPP
+#define wg_LEXER_HPP
+
+#include "commons.hpp"
+#include "Node.hpp"
+#include "Loc.hpp"
+
+namespace wg
+{
+  struct ScanInfo {
+    size_t cursor;
+    NodeType type;
+    std::string repr;
+  };
+
+  using scanner_t = std::function<std::optional<ScanInfo>()>;
+
+  class Lexer
+  {
+  public:
+    explicit Lexer();
+    virtual ~Lexer();
+
+    void scan(std::string const& source);
+    std::shared_ptr<Node> next();
+    std::vector<std::shared_ptr<Node>> all();
+
+  private:
+    std::string m_source;
+    size_t m_cursor = 0;
+    Loc m_loc;
+    std::vector<scanner_t> m_scanners;
+    std::vector<char> m_seps;
+
+    void add_text(std::string const& text,
+                  NodeType node,
+                  bool has_value=false);
+
+    bool is_sep(size_t index) const;
+
+    void skip_spaces();
+
+    std::optional<ScanInfo> scan_text(std::string const& text,
+                                      NodeType type,
+                                      bool has_value) const;
+
+    std::optional<ScanInfo> scan_ident() const;
+
+  };
+}
+
+#endif

lib/Loc.cpp

@@ -0,0 +1,14 @@
+#include "Loc.hpp"
+
+namespace wg
+{
+  /*explicit*/ Loc::Loc(std::filesystem::path origin, int line)
+    : m_origin { origin }
+    , m_line { line }
+  {
+  }
+
+  /*virtual*/ Loc::~Loc()
+  {
+  }
+}

lib/Loc.hpp

@@ -0,0 +1,45 @@
+#ifndef wg_LOC_HPP
+#define wg_LOC_HPP
+
+#include "commons.hpp"
+#include <sstream>
+
+namespace wg
+{
+  class Loc
+  {
+  public:
+    explicit Loc(std::filesystem::path origin = "???", int line = 0);
+    virtual ~Loc();
+
+    std::filesystem::path origin() const { return m_origin; }
+    int line() const { return m_line; }
+
+    template <typename T>
+    void error(std::string const& what);
+
+    template <typename T>
+    void error(std::stringstream const& what);
+
+  private:
+    std::filesystem::path m_origin;
+    int m_line = 0;
+  };
+
+  template <typename T>
+  void Loc::error(std::string const& what)
+  {
+    std::stringstream ss;
+    ss << m_origin.string() << ": ERROR " << what;
+
+    throw T {ss.str() };
+  }
+
+  template <typename T>
+  void Loc::error(std::stringstream const& what)
+  {
+    error<T>(what.str());
+  }
+}
+
+#endif

lib/Node.cpp

@@ -0,0 +1,55 @@
+#include "Node.hpp"
+
+namespace wg
+{
+  /*explicit*/ Node::Node(NodeType type, std::string const& repr, Loc const& loc)
+    : m_type { type }
+    , m_repr { repr }
+    , m_loc { loc }
+  {
+  }
+
+  /*virtual*/ Node::~Node()
+  {
+  }
+
+  void Node::add_child(std::shared_ptr<Node> child)
+  {
+    m_children.push_back(child);
+  }
+
+  std::shared_ptr<Node> Node::child(size_t index) const
+  {
+    WG_ASSERT(index < size(), "aze");
+    return m_children.at(index);
+  }
+
+  std::string Node::string() const
+  {
+    std::stringstream ss;
+    ss << (NodeTypeStr[m_type] + strlen("NODE_"));
+
+    if (!m_repr.empty())
+      {
+        ss << "[" << m_repr << "]";
+      }
+
+    if (size() > 0)
+      {
+        ss << "(";
+
+        std::string sep;
+
+        for (auto child: m_children)
+          {
+            ss << sep << child->string();
+            sep = ",";
+          }
+
+        ss << ")";
+      }
+
+    return ss.str();
+  }
+
+}

lib/Node.hpp

@@ -0,0 +1,42 @@
+#ifndef wg_NODE_HPP
+#define wg_NODE_HPP
+
+#include "commons.hpp"
+#include "Loc.hpp"
+
+#define NODE_TYPES(G)                           \
+  G(NODE_PROG),                                 \
+    G(NODE_IDENT),                              \
+    G(NODE_HASH),                               \
+    G(NODE_DIR),
+
+namespace wg
+{
+  WG_ENUM(NodeType, NODE_TYPES);
+
+  class Node
+  {
+  public:
+    explicit Node(NodeType type, std::string const& repr, Loc const& loc);
+    virtual ~Node();
+
+    NodeType type() const { return m_type; }
+    std::string repr() const { return m_repr; }
+    Loc loc() const { return m_loc; }
+
+    size_t size() const { return m_children.size(); }
+
+    void add_child(std::shared_ptr<Node> child);
+    std::shared_ptr<Node> child(size_t index) const;
+
+    std::string string() const;
+
+  private:
+    NodeType m_type;
+    std::string m_repr;
+    Loc m_loc;
+    std::vector<std::shared_ptr<Node>> m_children;
+  };
+}
+
+#endif

lib/Parser.cpp

@@ -0,0 +1,109 @@
+#include "Parser.hpp"
+
+namespace wg
+{
+  /*explicit*/ Parser::Parser()
+  {
+  }
+
+  /*virtual*/ Parser::~Parser()
+  {
+  }
+
+  std::shared_ptr<Node> Parser::parse(std::vector<std::shared_ptr<Node>>
+                                      const& tokens)
+  {
+    m_cursor = 0;
+    m_tokens = tokens;
+
+    return parse_prog();
+  }
+
+  Loc Parser::loc() const
+  {
+    return m_tokens[m_cursor]->loc();
+  }
+
+  std::shared_ptr<Node> Parser::consume(NodeType type)
+  {
+    auto current = m_tokens[m_cursor];
+
+    if (current->type() != type)
+      {
+        std::stringstream ss;
+        ss << "type mismatch, expected '"
+           << (NodeTypeStr[type] + strlen("NODE_"))
+           << "', got '"
+           << (NodeTypeStr[current->type()] + strlen("NODE_"))
+           << "'";
+
+        loc().error<syntax_error>(ss);
+      }
+    else
+      {
+        return consume();
+      }
+
+    return nullptr;
+  }
+
+  std::shared_ptr<Node> Parser::consume()
+  {
+    WG_ASSERT(m_cursor < m_tokens.size(), "cannot consume");
+    auto node = m_tokens[m_cursor];
+    m_cursor++;
+    return node;
+  }
+
+  bool Parser::type_is(NodeType type, int lookahead)
+  {
+    if (m_cursor + lookahead >= m_tokens.size())
+      {
+        return false;
+      }
+
+    return m_tokens[m_cursor + lookahead]->type() == type;
+  }
+
+  bool Parser::type_isnt(NodeType type, int lookahead)
+  {
+    return !type_is(type, lookahead);
+  }
+
+  std::shared_ptr<Node> Parser::make_node(NodeType type) const
+  {
+    return std::make_shared<Node>(type, "", loc());
+  }
+
+  std::shared_ptr<Node> Parser::parse_prog()
+  {
+    auto node = std::make_shared<Node>(NODE_PROG, "", Loc {});
+
+
+    while (m_cursor < m_tokens.size())
+      {
+        node->add_child(parse_instr());
+      }
+
+    return node;
+  }
+
+  std::shared_ptr<Node> Parser::parse_instr()
+  {
+    return parse_dir();
+  }
+
+  std::shared_ptr<Node> Parser::parse_dir()
+  {
+    auto node = make_node(NODE_DIR);
+    consume(NODE_HASH);
+    node->add_child(consume(NODE_IDENT));
+    node->add_child(parse_expr());
+    return node;
+  }
+
+  std::shared_ptr<Node> Parser::parse_expr()
+  {
+    return consume(NODE_IDENT);
+  }
+}

lib/Parser.hpp

@@ -0,0 +1,39 @@
+#ifndef wg_PARSER_HPP
+#define wg_PARSER_HPP
+
+#include "commons.hpp"
+#include "Node.hpp"
+
+namespace wg
+{
+  WG_ERROR(syntax_error);
+
+  class Parser
+  {
+  public:
+    explicit Parser();
+    virtual ~Parser();
+
+    std::shared_ptr<Node> parse(std::vector<std::shared_ptr<Node>>
+                                const& tokens);
+  private:
+    std::vector<std::shared_ptr<Node>> m_tokens;
+    size_t m_cursor;
+
+    Loc loc() const;
+    std::shared_ptr<Node> consume(NodeType type);
+    std::shared_ptr<Node> consume();
+
+    bool type_is(NodeType type, int lookahead=0);
+    bool type_isnt(NodeType type, int lookahead=0);
+    std::shared_ptr<Node> make_node(NodeType type) const;
+
+    std::shared_ptr<Node> parse_prog();
+    std::shared_ptr<Node> parse_instr();
+    std::shared_ptr<Node> parse_dir();
+    std::shared_ptr<Node> parse_expr();
+
+  };
+}
+
+#endif

lib/commons.hpp

@@ -0,0 +1,29 @@
+#ifndef wg_COMMONS_HPP
+#define wg_COMMONS_HPP
+
+#define WG_GEN_ENUM(X) X
+#define WG_GEN_STRING(X) #X
+
+#define WG_ENUM(PREFIX, TYPES)                                          \
+  enum PREFIX { TYPES(WG_GEN_ENUM) };                                   \
+  constexpr char const* PREFIX ## Str [] = { TYPES(WG_GEN_STRING) }
+
+#define WG_ERROR(NAME)                                                  \
+  struct NAME : public std::runtime_error {                             \
+    NAME (std::string const& what) : std::runtime_error { what } {}     \
+  }
+
+#define WG_ASSERT(COND, MSG) \
+  if ( ! (COND) ) { std::cerr << MSG << std::endl; abort(); }
+
+#include <string>
+#include <filesystem>
+#include <memory>
+#include <vector>
+#include <sstream>
+#include <iostream>
+#include <cstring>
+#include <functional>
+#include <optional>
+
+#endif

meson.build

@@ -0,0 +1,47 @@
+project('wongola',
+        'cpp',
+        version: '0.0.0',
+        default_options: [
+          'prefix=/usr',
+          'warning_level=3',
+          'cpp_std=c++17'
+        ])
+
+wongola_lib = static_library(
+  'wongola',
+  sources: [
+    'lib/Node.cpp',
+    'lib/Lexer.cpp',
+    'lib/Parser.cpp',
+    'lib/Compiler.cpp',
+    'lib/Loc.cpp',
+  ],
+  dependencies: [
+    dependency('LLVM')
+  ]
+)
+
+wongola_dep = declare_dependency(
+  link_with: [wongola_lib],
+  include_directories: ['lib']
+)
+
+executable('wongoc',
+           sources: [
+             'src/main.cpp',
+           ],
+           dependencies: [
+             wongola_dep
+           ],
+           install: true)
+
+executable('wongotest',
+           sources: [
+             'tests/main.cpp',
+             'tests/Lexer.cpp',
+             'tests/Parser.cpp',
+           ],
+           dependencies: [
+             wongola_dep,
+             dependency('catch2')
+           ])

src/main.cpp

@@ -0,0 +1,39 @@
+#include <iostream>
+#include <fstream>
+#include <Lexer.hpp>
+#include <Parser.hpp>
+#include <Compiler.hpp>
+
+int main(int argc, char** argv)
+{
+  if (argc < 2)
+    {
+      return -1;
+    }
+
+  std::string source;
+
+  // Get Sources
+  {
+    std::ifstream file {argv[1]};
+    std::string line;
+
+    while (std::getline(file, line))
+      {
+        source += line + (file.eof() ? "" : "\n");
+      }
+  }
+
+  // Scan Sources
+  wg::Lexer lexer;
+  lexer.scan(source);
+  auto tokens = lexer.all();
+
+  wg::Parser parser;
+  auto ast = parser.parse(tokens);
+
+  wg::Compiler compiler;
+  compiler.compile(ast);
+
+  return 0;
+}

tests/Lexer.cpp

@@ -0,0 +1,36 @@
+#include <catch2/catch.hpp>
+#include "../lib/Lexer.hpp"
+
+class LexerTest
+{
+public:
+  explicit LexerTest() {}
+  virtual ~LexerTest() {}
+
+  void test_next(wg::Lexer& lexer, std::string const& oracle)
+  {
+    auto n = lexer.next();
+    REQUIRE(nullptr != n);
+
+    REQUIRE(oracle == n->string());
+  }
+
+  void test_end(wg::Lexer& lexer)
+  {
+    auto n = lexer.next();
+    REQUIRE(nullptr == n);
+  }
+
+protected:
+};
+
+TEST_CASE_METHOD(LexerTest, "Lexer_")
+{
+  wg::Lexer lex;
+  lex.scan(" # canard #canard");
+  test_next(lex, "HASH");
+  test_next(lex, "IDENT[canard]");
+  test_next(lex, "HASH");
+  test_next(lex, "IDENT[canard]");
+  test_end(lex);
+}

tests/Parser.cpp

@@ -0,0 +1,32 @@
+#include <catch2/catch.hpp>
+#include "../lib/Lexer.hpp"
+#include "../lib/Parser.hpp"
+
+class ParserTest
+{
+public:
+  explicit ParserTest() {}
+  virtual ~ParserTest() {}
+
+  void test_parse(std::string const& oracle,
+                  std::string const& source)
+  {
+    wg::Lexer lex;
+    lex.scan(source);
+    auto tokens = lex.all();
+
+    wg::Parser parser;
+
+    auto node = parser.parse(tokens);
+
+    REQUIRE(oracle == node->string());
+  }
+
+protected:
+};
+
+TEST_CASE_METHOD(ParserTest, "Parser_")
+{
+  test_parse("PROG(DIR(IDENT[hello],IDENT[world]))",
+             "#hello world");
+}

tests/main.cpp

@@ -0,0 +1,2 @@
+#define CATCH_CONFIG_MAIN
+#include <catch2/catch.hpp>