git @ Cat's Eye Technologies Decoy / master src / decoy / parser.lua
master

Tree @master (Download .tar.gz)

parser.lua @master — raw · history · blame 

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
--
-- decoy.parser
--

-- SPDX-FileCopyrightText: Copyright (c) 2023-2024 Chris Pressey, Cat's Eye Technologies.
-- This work is distributed under a 2-clause BSD license. For more information, see:
-- SPDX-License-Identifier: LicenseRef-BSD-2-Clause-X-Decoy

table = require "table"

require "decoy.model"
local Lexer = require "decoy.lexer"
local ast = require "decoy.ast"


local Parser = {}

function Parser:parse_sexps()
    local es = {}
    local e
    while (not self.lexer:is_eof()) and self.lexer:get_token_text() ~= ")" do
        e = self:parse_sexp()
        table.insert(es, e)
    end
    return es
end

function Parser:parse_sexp()
    local e
    local lexer = self.lexer
    if lexer:consume("(") then
        local es = self:parse_sexps()
        lexer:expect(")")
        e = Cons.table_to_list(es)
    elseif lexer:get_token_type() == "symbol" then
        e = Symbol.new(lexer:get_token_text())
        lexer:scan()
    elseif lexer:get_token_type() == "strlit" then
        e = String.new(lexer:get_token_text())
        lexer:scan()
    elseif lexer:get_token_type() == "numlit" then
        local value = tonumber(lexer:get_token_text())
        e = Number.new(value)
        lexer:scan()
    else
        error("what is this I don't even: " .. lexer:get_token_text())
    end
    return e
end

function Parser:parse_toplevels()
    local es = {}
    local e
    while not self.lexer:is_eof() do
        e = self:parse_toplevel()
        table.insert(es, e)
    end
    return es
end

function Parser:parse_toplevel()
    local e
    local lexer = self.lexer
    if lexer:consume("(") then
        if lexer:consume("define") then
            assert(lexer:get_token_type() == "symbol")
            local name = lexer:get_token_text()
            lexer:consume_type("symbol")
            local defn = self:parse_sexp()
            lexer:expect(")")
            e = ast.Define.new(name, defn)
        elseif lexer:consume("import-from") then
            assert(lexer:get_token_type() == "strlit")
            local name = lexer:get_token_text()
            lexer:consume_type("strlit")
            local import_list = self:parse_sexp()
            local imports = Cons.list_to_table(import_list)
            lexer:expect(")")
            e = ast.ImportFrom.new(name, imports)
        else
            local es = self:parse_sexps()
            lexer:expect(")")
            e = Cons.table_to_list(es)
        end
    else
        e = self:parse_sexp()
    end
    return e
end

Parser.new = function(source)
   local self = {
       line = 1,
       pos = 0,
       token,
       lexer = Lexer.new(source),
       parse_special_forms = false,
   }

   setmetatable(self, {__index = Parser})

    -- init
    self.lexer:scan()

   return self
end

return Parser