lat 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 8e6c5e2d1956cf589b2b5806eb6e51c66641c25229891b78c185cb5176c56efe
+  data.tar.gz: feab0e27cd58b07e5c98c172131c4266bbbeb5a261fdd796e8f7dd6624d448ce
+SHA512:
+  metadata.gz: d4d9151124f40dc9e43ea4784b72c771a3d0df57072dc195cb14d88827adc311d57d73134dbeec57d351f0abcce88310756c073801d6004e85217a4a4a0da725
+  data.tar.gz: 7edc1cfecf74c3d99dc4b3379a9e511a64ddc325eb0f5c43b1cc7268ab37effbfbcdf760c65e9967edf2cded23a99dc925ca16e33c5c1daba04b711a02336463

data/bin/lat

@@ -0,0 +1,3 @@
+#!/usr/bin/env ruby
+$LOAD_PATH.unshift File.join(__dir__, "../compiler")
+require_relative "../compiler/compile"

data/compiler/codegen.rb

@@ -0,0 +1,322 @@
+class Generator
+  def generate(node)
+    if node.is_a?(Array)
+      return node.map { |n| generate(n) }.join("\n")
+    end 
+
+    case node
+    
+    when ImportNode
+      "require %s" % [
+        node.location
+      ]
+    when ClassNode
+      out = []
+      out << "local #{node.name} = {}"
+      out << "#{node.name}.__index = #{node.name}"
+
+      out << ""
+
+      # entry point constructor
+      out << "function #{node.name}:new()"
+      out << "  local instance = setmetatable({}, self)"
+      node.body.each do |stmt|
+        if stmt.is_a?(VarAssignNode)
+          out << " instance.#{stmt.name} = #{generate(stmt.value)}"
+        else
+          out << "#{generate(stmt)}"
+        end
+      end
+      
+      out << "  return instance"
+      out << "end"
+      out << ""
+
+      #methods
+      node.defs.each do |d|
+        out << generate(d)
+        out << ""
+      end
+     
+      out.join("\n")
+    when ClassDefNode
+      body_code = node.body.map { |n| generate(n) }.join("\n  ")
+     "function %s(%s)\n  %s\nend" % [node.name, node.args.join(","), body_code]
+
+    when DefNode
+      body_code = 
+        if node.body.is_a?(Array)
+          node.body.map { |n| generate (n) }.join("\n  ")
+        else
+          generate(node.body)
+        end
+
+      "function #{node.type == "love"? "love." : ""}%s(%s)\n  %s \nend" % [
+        node.name,
+        node.args.join(","),
+        body_code
+      ]
+
+    when IfNode
+      compiled = ""
+
+      first = node.condition
+      compiled << "if #{generate(first)} then\n  "
+      compiled << node.body.map { |n| generate (n) }.join("\n")
+
+      node.elif_blocks.each do |c|
+        compiled << "\nelseif #{generate(c.condition)} then\n  "
+        compiled << c.body.map { |n| generate (n) }.join("\n")
+      end
+
+      if node.else_body
+        compiled << "\nelse\n  "
+        compiled << node.else_body.map { |n| generate (n) }.join("\n")
+      end
+
+      compiled << "\nend\n"
+      compiled
+
+    when WhileNode
+      body_code = 
+      if node.body.is_a?(Array)
+        node.body.map{ |n| generate (n) }.join("\n")
+      else
+        generate(node.body)
+      end
+
+      "while %s do \n %s \nend" % [
+        generate(node.statement),
+        body_code
+      ]
+
+    when SwitchNode
+      compiled = ""
+      node.cases.each_with_index do |c, i|
+        if i == 0
+          compiled << "if #{generate(c.match)} == #{generate(node.value)} then\n"
+        else
+          compiled << "elseif #{generate(c.match)} == #{generate(node.value)} then\n"
+        end
+
+        body_code = c.body.map { |b| generate(b) }.join("\n")
+        compiled << " #{body_code}\n"
+
+      end
+      compiled << "end\n"
+      compiled
+
+
+    when CallNode
+      "%s(%s)" % [
+        node.name,
+        node.arg_expr.map { |expr| generate(expr) }.join(",")
+      ]
+
+    when PrintNode
+      "print(%s)" % [
+        node.args.map { |expr| generate(expr) }.join(",")
+      ]
+
+    when VarAssignNode
+      "local %s = %s" % [
+        node.name,
+        generate(node.value)
+      ]
+
+    when VarSetNode
+      "%s = %s" % [
+        node.name,
+        generate(node.value)
+      ]
+
+    when BinOpNode
+      if node.right.is_a?(AndOrListNode) && node.op == :dequal
+        left = generate(node.left)
+        parts = node.right.items.map{ |item| "#{left} == #{generate(item)}"}
+        return "(#{parts.join(' or ')})"
+      end
+      "(#{generate(node.left)} #{OP_NAMESPACES[node.op]} #{generate(node.right)})"
+
+    when SelfNode
+      selfstring = "self#{node.type}#{node.name}"
+    
+      if !node.args.empty?
+        args_string = node.args.map {|expr| generate(expr) }.join(",")
+        selfstring += "(#{args_string})"
+      else
+        selfstring += " = %s" % [
+          generate(node.value)
+        ]
+      end
+      selfstring
+
+    when LoveCallNode
+      "love.%s.%s(%s)" % [
+        node.namespace,
+        node.name,
+        node.args.map { |expr| generate(expr) }.join(",")
+      ]
+
+    when ReturnNode
+      "return %s" % [
+        generate(node.statement)
+      ]
+
+    when VarRefNode
+      node.value
+
+    when IntegerNode
+      node.value.to_s
+
+    when StringNode
+      "\"%s\"" % [
+        node.value
+      ]
+    
+    when ArrayNode
+      elements = node.elements.map { |e| generate(e) }.join(", ")
+      "{#{elements}}"
+
+    when ArrayAccessNode
+      "#{node.name}[#{generate(node.index)}]"
+
+    # when ErrorCallNode
+    #   <<~LUA
+    #   local utf8 = require("utf8")
+
+    #   local function error_printer(msg, layer)
+    #     print((debug.traceback("Error: " .. tostring(msg), 1+(layer or 1)):gsub("\n[^\n]+$", "")))
+    #   end
+
+    #   function love.errorhandler(msg)
+    #     msg = tostring(msg)
+
+    #     error_printer(msg, 2)
+
+    #     if not love.window or not love.graphics or not love.event then
+    #       return
+    #     end
+
+    #     if not love.graphics.isCreated() or not love.window.isOpen() then
+    #       local success, status = pcall(love.window.setMode, 800, 600)
+    #       if not success or not status then
+    #         return
+    #       end
+    #     end
+
+    #     -- Reset state.
+    #     if love.mouse then
+    #       love.mouse.setVisible(true)
+    #       love.mouse.setGrabbed(false)
+    #       love.mouse.setRelativeMode(false)
+    #       if love.mouse.isCursorSupported() then
+    #         love.mouse.setCursor()
+    #       end
+    #     end
+    #     if love.joystick then
+    #       -- Stop all joystick vibrations.
+    #       for i,v in ipairs(love.joystick.getJoysticks()) do
+    #         v:setVibration()
+    #       end
+    #     end
+    #     if love.audio then love.audio.stop() end
+
+    #     love.graphics.reset()
+    #     local font = love.graphics.setNewFont(14)
+
+    #     love.graphics.setColor(1, 1, 1)
+
+    #     local trace = debug.traceback()
+
+    #     love.graphics.origin()
+
+    #     local sanitizedmsg = {}
+    #     for char in msg:gmatch(utf8.charpattern) do
+    #       table.insert(sanitizedmsg, char)
+    #     end
+    #     sanitizedmsg = table.concat(sanitizedmsg)
+
+    #     local err = {}
+
+    #     table.insert(err, "Error\n")
+    #     table.insert(err, sanitizedmsg)
+
+    #     if #sanitizedmsg ~= #msg then
+    #       table.insert(err, "Invalid UTF-8 string in error message.")
+    #     end
+
+    #     table.insert(err, "\n")
+
+    #     for l in trace:gmatch("(.-)\n") do
+    #       if not l:match("boot.lua") then
+    #         l = l:gsub("stack traceback:", "Traceback\n")
+    #         table.insert(err, l)
+    #       end
+    #     end
+
+    #     local p = table.concat(err, "\n")
+
+    #     p = p:gsub("\t", "")
+    #     p = p:gsub("%[string \"(.-)\"%]", "%1")
+
+    #     local function draw()
+    #       if not love.graphics.isActive() then return end
+    #       local pos = 70
+    #       love.graphics.clear(89/255, 157/255, 220/255)
+    #       love.graphics.printf(p, pos, pos, love.graphics.getWidth() - pos)
+    #       love.graphics.present()
+    #     end
+
+    #     local fullErrorText = p
+    #     local function copyToClipboard()
+    #       if not love.system then return end
+    #       love.system.setClipboardText(fullErrorText)
+    #       p = p .. "\nCopied to clipboard!"
+    #     end
+
+    #     if love.system then
+    #       p = p .. "\n\nPress Ctrl+C or tap to copy this error"
+    #     end
+
+    #     return function()
+    #       love.event.pump()
+
+    #       for e, a, b, c in love.event.poll() do
+    #         if e == "quit" then
+    #           return 1
+    #         elseif e == "keypressed" and a == "escape" then
+    #           return 1
+    #         elseif e == "keypressed" and a == "c" and love.keyboard.isDown("lctrl", "rctrl") then
+    #           copyToClipboard()
+    #         elseif e == "touchpressed" then
+    #           local name = love.window.getTitle()
+    #           if #name == 0 or name == "Untitled" then name = "Game" end
+    #           local buttons = {"OK", "Cancel"}
+    #           if love.system then
+    #             buttons[3] = "Copy to clipboard"
+    #           end
+    #           local pressed = love.window.showMessageBox("Quit "..name.."?", "", buttons)
+    #           if pressed == 1 then
+    #             return 1
+    #           elseif pressed == 3 then
+    #             copyToClipboard()
+    #           end
+    #         end
+    #       end
+
+    #       draw()
+
+    #       if love.timer then
+    #         love.timer.sleep(0.1)
+    #       end
+    #     end
+
+    #   end
+    #   LUA
+
+    else
+      raise "Unknown node type: #{node.class}"
+    end
+  end
+end

data/compiler/compile.rb

@@ -0,0 +1,80 @@
+#!/usr/bin/env ruby
+
+require_relative "tokenizer"
+require_relative "parser"
+require_relative "codegen"
+
+if ARGV.empty?
+    puts "Usage: lat <input.lat> [output.lua]"
+    exit 1
+end
+
+def find_love
+    candidates = [
+        "love",
+        "C:/Program Files/LOVE/love.exe",
+        "C:/Program Files (x86)/LOVE/love.exe",
+        ENV["LOVE_PATH"]
+    ].compact
+
+    candidates.each do |path|
+        return path if system("where #{path} >nul 2>&1") || File.exist?(path.to_s)
+    end
+
+    puts "Error: LOVE2D not found. Install it from https://love2d.org or set LOVE_PATH env variable."
+    exit 1
+end
+skip_run = false
+love = find_love()
+
+if ARGV[0] == "run"
+    latcDir = File.join(Dir.pwd, ".latc")
+    unless Dir.exist?(latcDir)
+        puts "Error: no .latc folder foound. Compile something first \n 'lat <input.lat> [main.lua]"
+        exit 1
+    end
+
+    unless File.exist?(File.join(latcDir, "main.lua"))
+        puts "Error: .latc exists but no main.lua found"
+        exit 1
+    end
+    exec(love, latcDir)
+elsif ARGV[0] == "build"
+    ARGV.shift
+    skip_run = true
+end
+inputFile  = ARGV[0] || "main.lat"
+
+unless File.exist?(inputFile)
+    puts "Error: fil `#{inputFile}` not found"
+    exit 1
+end
+
+latcDir = File.join(Dir.pwd, ".latc")
+Dir.mkdir(latcDir) unless Dir.exist?(latcDir)
+
+if RbConfig::CONFIG["host_os"] =~ /mswin|mingw|cygwin/
+  system("attrib +h #{latcDir}") # -h to unhide
+end
+
+basename = File.basename(inputFile, ".*")
+outputFile = File.join(latcDir, basename == "main" ? "main.lua" : "#{basename}.lua")
+
+input = File.read(inputFile)
+
+tokens = Tokenizer.new(input).tokenize
+# puts "--- TOKENS ---"
+# puts tokens.map(&:inspect).join("\n")
+
+tree = Parser.new(tokens).parse
+# puts "--- AST ---"
+# p tree
+
+generated = Generator.new.generate(tree)
+# puts "--- LUA OUTPUT ---"
+# puts generated
+File.open(outputFile, 'w') { |file| file.write(generated)}
+
+exec(love, latcDir) unless skip_run
+
+# ln -s "$(pwd)/compiler/compile.rb" /usr/local/bin/lat

data/compiler/parser.rb

@@ -0,0 +1,537 @@
+DefNode  = Struct.new(:type, :name, :args, :body)
+ClassNode = Struct.new(:name, :defs, :body )
+ClassDefNode = Struct.new(:name, :args, :body)
+
+IfNode = Struct.new(:condition, :body, :elif_blocks, :else_body)
+ElifBlock = Struct.new(:condition, :body)
+
+ImportNode = Struct.new(:location)
+WhileNode = Struct.new(:statement, :body)
+IntegerNode = Struct.new(:value)
+StringNode = Struct.new(:value)
+CallNode    = Struct.new(:name, :arg_expr)
+VarRefNode  = Struct.new(:value)
+VarAssignNode = Struct.new(:name, :value)
+VarSetNode = Struct.new(:name, :value)
+BinOpNode = Struct.new(:left, :op, :right)
+PrintNode = Struct.new(:args)
+ReturnNode = Struct.new(:statement)
+AndOrListNode = Struct.new(:items)
+SwitchNode = Struct.new(:value, :cases)
+CaseNode = Struct.new(:match, :body)
+
+ArrayNode = Struct.new(:elements)
+ArrayAccessNode = Struct.new(:name, :index)
+
+LoveCallNode = Struct.new(:namespace, :name, :args)
+SelfNode = Struct.new(:name, :type, :args, :value)
+
+ErrorCallNode = Struct.new()
+
+
+LOVE_NAMESPACES = {
+  lgraphics: "graphics",
+  laudio: "audio",
+  ldata: "data",
+  levent: "event",
+  lfilesystem: "filesystem",
+  lfont: "font",
+  limage: "image",
+  ljoystick: "joystick",
+  lmouse: "mouse",
+  lkeyboard: "keyboard"
+}
+
+OP_NAMESPACES = {
+  dequal: "==",
+  equal: "=",
+  divide: "/",
+  multiply: "*",
+  plus: "+",
+  minus: "-",
+
+}
+
+class Parser
+  def initialize(tokens)
+    @tokens = tokens
+  end
+
+  def parse
+    # if peek(:def)
+    #   parse_def
+    # else
+    #   parse_statement
+    # end
+    statements = []
+    while @tokens.any?
+      skip_newlines
+      break if @tokens.empty?
+      statements << parse_statement
+      skip_newlines
+    end
+    # statements << ErrorCallNode.new()
+    statements
+  end
+
+  def parse_statement
+
+    skip_newlines
+    return nil if peek(:end)
+
+    if peek(:import) then
+      parse_import
+    elsif peek(:class) then
+      parse_class
+    elsif peek(:def)
+      parse_def
+    elsif peek(:if)
+      parse_if
+    elsif peek(:while)
+      parse_while
+    elsif peek(:switch)
+      parse_switch
+    elsif peek(:print)
+      parse_print
+    elsif peek(:local)
+      parse_var_assign
+    elsif peek(:identifier) && peek(:equal, 1)
+      parse_var_set
+    elsif peek(:return)
+      parse_return
+    else
+      parse_expr
+    end
+
+
+  end
+
+  def skip_newlines
+    consume(:newline) while peek(:newline)
+  end
+
+  def parse_import
+    consume(:import)
+    location = consume(:string).value
+
+    ImportNode.new(location)
+  end
+
+  def parse_class
+    consume(:class)
+    name = consume(:identifier).value
+    
+    skip_newlines
+
+    defs = []
+    body = []
+    until peek(:end)
+      if peek(:def)
+        defs << parse_class_def(name)
+      else
+        body << parse_statement
+      end
+      skip_newlines
+    end
+    consume (:end)
+    ClassNode.new(name, defs, body)
+
+  end
+
+  def parse_class_def(name)
+    consume(:def)
+    name = "#{name}:#{consume(:identifier).value}"
+    args = parse_args
+    skip_newlines
+
+    body = []
+
+    until peek(:end)
+      body << parse_statement
+      skip_newlines
+    end
+    consume(:end)
+    ClassDefNode.new(name, args, body)
+  end
+
+  def parse_def
+    consume(:def)
+    type = "normal"
+    if peek(:love)
+      consume(:love)
+      type = "love"
+      consume(:dot)
+    end
+    name = consume(:identifier).value
+    args = parse_args
+
+    skip_newlines
+    body = []
+
+    until peek(:end)
+      body << parse_statement
+      skip_newlines
+    end
+    consume(:end)
+    DefNode.new(type, name, args, body)
+  end
+
+
+  def parse_if
+    consume(:if)
+    condition = parse_expr
+    skip_newlines
+    if_body = []
+    while !peek(:elif) && !peek(:else) && !peek(:end)
+      if_body << parse_statement
+      skip_newlines
+    end
+
+    elif_blocks = []
+    while peek(:elif)
+      consume(:elif)
+      elif_condition = parse_expr
+      skip_newlines
+
+      elif_body = []
+      while !peek(:elif) && !peek(:else) && !peek(:end)
+        elif_body << parse_statement
+        skip_newlines
+      end
+
+      elif_blocks << ElifBlock.new(elif_condition, elif_body)
+    end
+
+    else_body = nil
+    if peek(:else)
+      consume(:else)
+      skip_newlines
+
+      else_body = []
+      while !peek(:end)
+        else_body << parse_statement
+        skip_newlines
+      end
+    end
+
+    consume(:end)
+
+    IfNode.new(condition, if_body, elif_blocks, else_body)
+  end
+
+  def parse_while
+    consume(:while)
+
+    if peek(:oparen)
+      consume(:oparen)
+      statement = parse_expr
+      consume(:cparen)
+    else
+      statement = parse_expr
+    end
+
+    skip_newlines
+    body = []
+
+    until peek(:end)
+      body << parse_statement
+      skip_newlines
+    end
+
+    consume(:end)
+    WhileNode.new(statement, body)
+  end
+
+  def parse_switch
+    consume(:switch)
+    value = parse_expr
+    skip_newlines
+
+    cases = []
+
+    while peek(:to)
+      consume(:to)
+      match = parse_expr
+      skip_newlines
+    
+      body = []
+
+      until peek(:to) || peek(:end)
+        body << parse_statement
+        skip_newlines
+      end
+
+      cases << CaseNode.new(match, body)
+    end
+
+    consume(:end)
+    SwitchNode.new(value, cases)
+  end
+
+  def parse_print
+    consume(:print)
+    args = parse_arg_expr
+    PrintNode.new(args)
+  end
+
+  def parse_var_assign
+    consume(:local)
+    name = consume(:identifier).value
+    consume(:equal)
+    value = parse_expr
+    VarAssignNode.new(name, value)
+  end
+
+  def parse_var_set
+    name = consume(:identifier).value
+    consume(:equal)
+    value = parse_expr
+    VarSetNode.new(name, value)
+  end
+
+  def parse_return
+    consume(:return)
+    statement = parse_expr
+    ReturnNode.new(statement)
+  end
+
+  def parse_expr
+    left = parse_additive
+
+    while peek(:dequal)
+      op = consume(:dequal)
+      right = parse_additive
+      left = BinOpNode.new(left, op.type, right)
+    end
+
+    left
+  end
+    # consume(:if)
+
+    # if peek(:oparen)
+    #   consume(:oparen)
+    #   statement = parse_expr
+    #   consume(:cparen)
+    # else
+    #   statement = parse_expr
+    # end
+    # skip_newlines
+    # body = []
+
+    # until peek(:elif) peek(:end)
+    #   body << parse_statement
+    #   skip_newlines
+    # end
+    # consume(:end)
+    # IfNode.new(statement, body)
+
+  def parse_args
+    consume(:oparen)
+    args = []
+    if peek(:identifier)
+      args << consume(:identifier).value
+      while peek(:comma)
+        consume(:comma)
+        args << consume(:identifier).value
+      end
+    end
+    consume(:cparen)
+    args
+  end
+
+
+
+  def parse_additive
+    left = parse_multiplicative
+
+    while peek(:plus) || peek(:minus) 
+      op = @tokens.shift.type
+      right = parse_multiplicative
+      left = BinOpNode.new(left, op, right)
+    end
+    left
+  end
+  
+  def parse_multiplicative
+    left = parse_term
+
+    while peek(:multiply) || peek(:divide)
+      op = @tokens.shift.type
+      right = parse_term
+      left = BinOpNode.new(left, op, right)
+    end
+    left
+  end
+  # def parse_operators
+  #   left = parse_term
+
+  #   left = parse_op(left, :divide)
+  #   left = parse_op(left, :multiply)
+  #   left = parse_op(left, :plus)
+  #   left = parse_op(left, :minus)
+
+  #   left
+  # end
+
+  # def parse_op(left, operator)
+
+  #   while peek(operator)
+  #     consume(operator)
+  #     right = parse_term
+  #     left = BinOpNode.new(left, operator, right)
+  #   end
+  #   left
+  
+  # end
+
+  def parse_term
+    if peek(:integer)
+      IntegerNode.new(consume(:integer).value.to_i)
+
+    elsif peek(:identifier) && peek(:oparen, 1)
+      parse_call
+
+    elsif peek(:identifier)
+      VarRefNode.new(consume(:identifier).value)
+
+    elsif peek(:string)
+      strVal = consume(:string).value
+      StringNode.new(strVal[1..-2])
+
+    elsif peek(:oparen)
+      # consume(:oparen)
+      # expr = parse_expr
+      # consume(:cparen)
+      # expr
+      consume(:oparen)
+
+      first = parse_expr
+      items = [first]
+      until peek(:identifier) && peek(:or) && peek(:dequal) && peek(:cparen) && peek(:plus)
+        break
+      end
+
+      if !peek(:identifier) && peek(:or)
+        while peek(:or)
+          consume(:or)
+          items << parse_expr
+        end
+        consume(:cparen)
+        return AndOrListNode.new(items)
+      end
+
+      expr = first
+      consume(:cparen)
+      expr
+    elsif peek(:self)
+      parse_self_node
+
+    elsif peek(:coparen)
+      parse_array
+
+
+    elsif LOVE_NAMESPACES.keys.include?(peek_type)
+      parse_love_call
+    else
+      raise "Unexpected token #{@tokens[0].inspect} in term"
+
+    end
+  end
+
+
+
+  def parse_love_call
+    prefix = @tokens.shift.type
+    namespace = LOVE_NAMESPACES[prefix]
+
+    name = consume(:identifier).value
+    args = parse_arg_expr
+
+    LoveCallNode.new(namespace, name, args)
+  end
+
+  def parse_self_node
+    consume(:self)
+    
+    type = ""
+    if peek(:dot)
+      consume(:dot)
+      type = "."
+    elsif peek(:colon)
+      consume(:colon)
+      type = ":"
+    end
+
+    name = consume(:identifier).value
+
+    if peek(:oparen)
+      args = parse_arg_expr # parse args are for func defs and parse args expr is for call
+    else
+      args = []
+    end
+
+    if (type == ".") && peek(:equal)
+      consume(:equal)
+      value = parse_expr
+    end
+      
+    SelfNode.new(name, type, args, value)
+  end   
+
+  def parse_call
+    name = consume(:identifier).value
+    arg_expr = parse_arg_expr
+    CallNode.new(name, arg_expr)
+  end
+
+  def parse_arg_expr
+    consume(:oparen)
+    args = []
+    unless peek(:cparen)
+      args << parse_expr
+      while peek(:comma)
+        consume(:comma)
+        args << parse_expr
+      end
+    end
+    consume(:cparen)
+    args
+  end
+
+  def parse_array
+    consume(:coparen)
+    elements = []
+    unless peek(:ccparen)
+      elements << parse_expr
+      while peek(:comma)
+        consume(:comma)
+        elements << parse_expr
+      end
+    end
+    consume(:ccparen)
+    ArrayNode.new(elements)
+  end
+
+  
+  def parse_array_access
+    name = consume(:identifier).value
+    consume(:soparen)
+    index = parse_expr
+    consume(:scparen)
+    ArrayAccessNode.new(name, index)
+  end
+
+  def consume(type)
+    token = @tokens.shift
+    raise "Expected #{type}, got #{token.type}" unless token.type == type
+    token
+  end
+
+  def peek(type, offset = 0)
+    @tokens[offset]&.type == type
+  end
+
+  def peek_type(offset = 0)
+    @tokens[offset]&.type
+  end
+end

data/compiler/tokenizer.rb

@@ -0,0 +1,97 @@
+Token = Struct.new(:type, :value)
+
+class Tokenizer
+
+  TOKEN_TYPES = [
+    [:local, /\bnat\b/],
+    [:def, /\bcall\b/],
+    [:end, /\bdone\b/],
+    [:if, /\bif\b/],
+    [:elif, /\belif\b/],
+    [:else, /\belse\b/],
+    [:while, /\bwhen\b/],
+    [:print, /\bprint\b/],
+    [:return, /\breturn\b/],
+    [:or, /\bor\b/],
+    [:and, /\band\b/],
+    [:switch, /\bswitch\b/],
+    [:to, /\bto\b/],
+    [:class, /\bclass\b/],
+    [:self, /\bself\b/],
+    [:import, /\bbring\b/],
+
+    #love 
+    [:lgraphics, /-G:/],
+    [:laudio, /-A:/],
+    [:ldata, /-D:/],
+    [:levent, /-E:/],
+    [:lfilesystem, /-FS:/],
+    [:lfont, /-F:/],
+    [:limage, /-I:/],
+    [:ljoystick, /-J:/],
+    [:lmouse, /-M:/],
+    [:lkeyboard, /-K:/],
+    [:love, /\blove\b/],
+
+    # thingies
+    [:identifier, /\b[a-zA-Z]+\b/],
+    [:string, /"([^"]*)"/],
+    [:integer, /\b[0-9]+\b/],
+    [:oparen, /\(/],
+    [:cparen, /\)/],
+    [:soparen, /\[/],
+    [:scparen, /\]/],
+    [:coparen, /\{/],
+    [:ccparen, /\}/],
+    [:comma, /,/],
+    [:dot, /\./],
+    [:colon, /:/],
+
+    # operators
+    [:dequal, /==/],
+    [:greater, />/],
+    [:lesser, /</],
+    [:grequal, />=/],
+    [:lequal, /<=/],
+    [:equal, /=/],
+    [:divide, /\//],
+    [:multiply, /\*/],
+    [:plus, /\+/],
+    [:minus, /\-/],
+    [:newline, /\n+/],
+    [:space, /[ \t]+/], 
+
+  ]
+
+  def initialize(code)
+    @code = code
+  end
+
+  def tokenize
+    tokens = []
+    until @code.empty?
+      tokens << tokenize_token
+      # @code = @code.strip
+    end
+    tokens
+  end
+
+  def tokenize_token
+    TOKEN_TYPES.each do |type, regex|
+      anchored = /\A(#{regex})/
+
+
+      if @code =~ anchored
+        value = $1
+        if type == :space
+          @code = @code[value.length..-1]
+          return tokenize_token
+        end
+        @code = @code[value.length..-1]
+        return Token.new(type, value)
+      end
+    end
+
+    raise "Couldn't match token on #{@code.inspect}"
+  end
+end

metadata

@@ -0,0 +1,43 @@
+--- !ruby/object:Gem::Specification
+name: lat
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- JakeOJeff
+bindir: bin
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies: []
+executables:
+- lat
+extensions: []
+extra_rdoc_files: []
+files:
+- bin/lat
+- compiler/codegen.rb
+- compiler/compile.rb
+- compiler/parser.rb
+- compiler/tokenizer.rb
+homepage: https://github.com/JakeOJeff/lat
+licenses:
+- MIT
+metadata: {}
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.6.9
+specification_version: 4
+summary: A language that compiles to Lua/LÖVE2D
+test_files: []