taoism 1.0.1 → 1.0.3

data/lib/taoism/lexer.rb

@@ -0,0 +1,278 @@
+module Taoism
+  class Lexer
+    KEYWORDS = {
+      'if'      => TokenType::IF,
+      'else'    => TokenType::ELSE,
+      'loop'    => TokenType::LOOP,
+      'leave'   => TokenType::LEAVE,
+      'switch'  => TokenType::SWITCH,
+      'package' => TokenType::PACKAGE,
+      'import'  => TokenType::IMPORT,
+      'const'   => TokenType::CONST,
+      'data'    => TokenType::DATA,
+      'fun'     => TokenType::FUN,
+      'let'     => TokenType::LET,
+      'mut'     => TokenType::MUT,
+      'try'     => TokenType::TRY,
+      'return'  => TokenType::RETURN,
+      'and'     => TokenType::AND,
+      'or'      => TokenType::OR,
+      'not'     => TokenType::NOT,
+    }.freeze
+
+    PUNCTUATION = {
+      '{' => TokenType::LBRACE,
+      '}' => TokenType::RBRACE,
+      '[' => TokenType::LSQUARE,
+      ']' => TokenType::RSQUARE,
+      '(' => TokenType::LPAREN,
+      ')' => TokenType::RPAREN,
+      ',' => TokenType::COMMA,
+      ':' => TokenType::COLON,
+      ';' => TokenType::SEMI,
+      '.' => TokenType::DOT,
+    }.freeze
+
+    attr_reader :errors
+
+    def initialize(source)
+      @source = source
+      @offset = 0
+      @line   = 1
+      @col    = 0
+      @errors = ErrorHandler.new
+    end
+
+    def next_token
+      loop do
+        return eof_token if at_end?
+        @start = pos
+
+        char = advance
+        next if whitespace?(char)
+
+        if char == '/' && peek == '/'
+          skip_line_comment
+          next
+        end
+
+        return scan_token(char)
+      end
+    end
+
+    def skip_line_comment
+      advance
+      until at_end? || peek == "\n"
+        advance
+      end
+    end
+
+    def scan_token(char)
+      type = PUNCTUATION[char]
+      return make_token(type) if type
+
+      case char
+      when '+' then make_token(TokenType::PLUS)
+      when '-'
+        match('>') ? make_token(TokenType::ARROW) : make_token(TokenType::MINUS)
+      when '*' then make_token(TokenType::STAR)
+      when '/' then make_token(TokenType::SLASH)
+      when '%' then make_token(TokenType::MODULO)
+      when '>'
+        match('=') ? make_token(TokenType::GREATEREQ) : make_token(TokenType::GREATER)
+      when '<'
+        match('=') ? make_token(TokenType::LESSEQ) : make_token(TokenType::LESS)
+      when '='
+        if match('=')
+          make_token(TokenType::EQUALEQ)
+        elsif match('>')
+          make_token(TokenType::EQARROW)
+        else
+          make_token(TokenType::EQUAL)
+        end
+      when '!'
+        match('=') ? make_token(TokenType::BANGEQ) : make_token(TokenType::BANG)
+      when '&'
+        match('&') ? make_token(TokenType::AND) : make_token(TokenType::ILLEGAL)
+      when '|'
+        if match('>')
+          make_token(TokenType::PIPE)
+        elsif match('|')
+          make_token(TokenType::OR)
+        else
+          make_token(TokenType::ILLEGAL)
+        end
+      when '?'
+        match('.') ? make_token(TokenType::QDOT) : make_token(TokenType::ILLEGAL)
+      when '0'..'9' then number_token
+      when '"' then string_token
+      else
+        alpha?(char) ? identifier_token : make_token(TokenType::ILLEGAL)
+      end
+    end
+
+    def identifier_token
+      while alpha_numeric?(peek)
+        advance
+      end
+
+      str = lexeme
+
+      if bool_token?(str)
+        make_token(TokenType::BOOL)
+      elsif none_token?(str)
+        make_token(TokenType::NONE)
+      else
+        if type = KEYWORDS[str]
+          make_token(type)
+        else
+          make_token(TokenType::IDENTIFIER)
+        end
+      end
+    end
+
+    def string_token
+      loop do
+        if at_end?
+          @errors.add(:unterminated_string, "unterminated string", pos)
+          return make_token(TokenType::ILLEGAL, "")
+        end
+
+        case peek
+        when '"'
+          advance
+          return make_token(TokenType::STRING)
+        when "\n"
+          @errors.add(:unterminated_string, "unterminated string", pos)
+          return make_token(TokenType::ILLEGAL, "")
+        when '\\'
+          advance
+          if peek == '('
+            advance
+            while alpha_numeric?(peek)
+              advance
+            end
+
+            @errors.add(:bad_interpolation, "expected ')'", pos) unless peek == ')'
+            advance if peek == ')'
+
+          else
+            advance unless at_end?
+          end
+        else
+          advance
+        end
+      end
+    end
+
+    def number_token
+      type = TokenType::INT
+
+      while digit?(peek) || peek == '_'
+        advance
+      end
+
+      if peek == '.' && digit?(peek_next)
+        type = TokenType::FLOAT
+        advance
+
+        while digit?(peek) || peek == '_'
+          advance
+        end
+      end
+
+      make_token(type)
+    end
+
+    def make_token(type, text = lexeme)
+      Token.new(type, text, nil, @start, pos)
+    end
+
+    def eof_token
+      Token.new(TokenType::EOF, "", nil, @start, pos)
+    end
+
+    def lexeme
+      @source[@start.offset...@offset]
+    end
+
+    def pos
+      Token::Position.new(@offset, @line, @col)
+    end
+
+    def match(expected)
+      return false if peek != expected
+      advance
+      true
+    end
+
+    def peek
+      return "\0" if at_end?
+      @source[@offset]
+    end
+
+    def peek_next
+      if @offset.next < @source.length
+        @source[@offset + 1]
+      else
+        "\0"
+      end
+    end
+
+    def advance
+      char = @source[@offset]
+      @offset += 1
+      @col += 1
+      char
+    end
+
+    def at_end?
+      @offset >= @source.length
+    end
+
+    def bool_token?(str)
+      str == 'True' || str == 'False'
+    end
+
+    def none_token?(str)
+      str == 'None'
+    end
+
+    def whitespace?(char)
+      case char
+      when ' ', "\t", "\r" then true
+      when "\n"
+        @line += 1
+        @col = 0
+        true
+      else false
+      end
+    end
+
+    def alpha_numeric?(char)
+      alpha?(char) || digit?(char)
+    end
+
+    def alpha?(char)
+      ('A' <= char && char <= 'Z') ||
+      ('a' <= char && char <= 'z') ||
+      char == '_'
+    end
+
+    def digit?(char)
+      '0' <= char && char <= '9'
+    end
+
+    class ErrorHandler
+      attr_reader :errors
+
+      def initialize
+        @errors = []
+      end
+
+      def add(code, message = "", pos = nil)
+        @errors << LexicalError.new(code, message, pos)
+      end
+    end
+  end
+end

data/lib/taoism/nodes.rb

@@ -0,0 +1,54 @@
+module Taoism
+  module Nodes
+    # ── Top Level ──
+    Program = Struct.new(:stmts, :start, :end)
+
+    # ── Statements ──
+    Let            = Struct.new(:name, :value, :mutable, :start, :end)
+    LetPair        = Struct.new(:first, :second, :expr, :start, :end)
+    Assign         = Struct.new(:target, :value, :start, :end)
+    Const          = Struct.new(:name, :value, :start, :end)
+    Import         = Struct.new(:path, :start, :end)
+    Package        = Struct.new(:name, :start, :end)
+    Return         = Struct.new(:value, :start, :end)
+    Leave          = Struct.new(:start, :end)
+    ExprStmt       = Struct.new(:expr, :start, :end)
+
+    # ── Function ──
+    FunDef   = Struct.new(:name, :params, :body, :receiver, :start, :end)
+    Receiver = Struct.new(:param_name, :type_name, :start, :end)
+
+    # ── Data ──
+    DataDef = Struct.new(:name, :fields, :start, :end)
+    Field   = Struct.new(:name, :default, :start, :end)
+
+    # ── Block ──
+    Block = Struct.new(:stmts, :start, :end)
+
+    # ── Expressions ──
+    BinaryOp     = Struct.new(:left, :op, :right, :start, :end)
+    UnaryOp      = Struct.new(:op, :operand, :start, :end)
+    Call         = Struct.new(:callee, :args, :start, :end)
+    Index        = Struct.new(:target, :index, :start, :end)
+    DotExpr      = Struct.new(:target, :name, :start, :end)
+    SafeDot      = Struct.new(:target, :name, :start, :end)
+    Identifier   = Struct.new(:name, :start, :end)
+
+    # ── Literals ──
+    IntLit    = Struct.new(:value, :start, :end)
+    FloatLit  = Struct.new(:value, :start, :end)
+    StringLit = Struct.new(:value, :start, :end)
+    BoolLit   = Struct.new(:value, :start, :end)
+    NoneLit   = Struct.new(:start, :end)
+    ListLit   = Struct.new(:elements, :start, :end)
+
+    # ── Special Forms ──
+    Try = Struct.new(:call, :start, :end)
+
+    # ── Control Flow ──
+    If        = Struct.new(:cond, :then_body, :else_body, :start, :end)
+    Loop      = Struct.new(:body, :start, :end)
+    Switch    = Struct.new(:value, :arms, :else_body, :start, :end)
+    SwitchArm = Struct.new(:pattern, :value, :start, :end)
+  end
+end