tildeath 0.0.1

data/lib/tildeath.rb

@@ -0,0 +1,2 @@
+require_relative 'tildeath/version'
+require_relative 'tildeath/interpreter'

data/lib/tildeath/ast_nodes.rb

@@ -0,0 +1,10 @@
+require_relative 'ast_nodes/program'
+require_relative 'ast_nodes/statements'
+require_relative 'ast_nodes/bifurcate'
+require_relative 'ast_nodes/split'
+require_relative 'ast_nodes/import'
+require_relative 'ast_nodes/tildeath'
+require_relative 'ast_nodes/null'
+require_relative 'ast_nodes/dot_die'
+require_relative 'ast_nodes/bang'
+require_relative 'ast_nodes/value'

data/lib/tildeath/ast_nodes/bang.rb

@@ -0,0 +1,17 @@
+module Tildeath
+  module ASTNodes
+    class Bang
+      def initialize(value)
+        @value = value
+      end
+
+      def execute(context)
+        !@value.execute(context)
+      end
+
+      def to_s
+        "!#{@value}"
+      end
+    end
+  end
+end

data/lib/tildeath/ast_nodes/bifurcate.rb

@@ -0,0 +1,25 @@
+require_relative '../imminently_deceased_object'
+
+module Tildeath
+  module ASTNodes
+    class Bifurcate
+      def initialize(orig, parts)
+        @orig = orig
+        @parts = parts
+      end
+
+      def execute(context)
+        type = context[@orig].type
+        @parts.each do |part|
+          context[part] = ImminentlyDeceasedObject.new(type, part)
+        end
+      end
+
+      def to_s
+        @parts[1..-1].reduce("bifurcate #{@orig}[#{@parts[0]}") {|memo, part|
+          memo << ', ' << part.to_s
+        } << ']'
+      end
+    end
+  end
+end

data/lib/tildeath/ast_nodes/dot_die.rb

@@ -0,0 +1,18 @@
+module Tildeath
+  module ASTNodes
+    class DotDie
+      def initialize(victim)
+        @victim = victim
+      end
+
+      def execute(context)
+        return unless context[:THIS].alive?
+        context[@victim].die
+      end
+
+      def to_s
+        "#{@victim}.DIE()"
+      end
+    end
+  end
+end

data/lib/tildeath/ast_nodes/import.rb

@@ -0,0 +1,22 @@
+require_relative '../imminently_deceased_object'
+
+module Tildeath
+  module ASTNodes
+    class Import
+      def initialize(type, name)
+        @type = type
+        @name = name
+      end
+
+      def execute(context)
+        return unless context[:THIS].alive?
+        # Create new object of the specified type and name and store it in context
+        context[@name] = ImminentlyDeceasedObject.new(@type, @name)
+      end
+
+      def to_s
+        "import #{@type} #{@name}"
+      end
+    end
+  end
+end

data/lib/tildeath/ast_nodes/null.rb

@@ -0,0 +1,11 @@
+module Tildeath
+  module ASTNodes
+    class Null
+      def execute(context); end
+
+      def to_s
+        'NULL'
+      end
+    end
+  end
+end

data/lib/tildeath/ast_nodes/program.rb

@@ -0,0 +1,22 @@
+require_relative '../imminently_deceased_object'
+
+module Tildeath
+  module ASTNodes
+    class Program
+      def initialize(statements)
+        @statements = statements
+      end
+
+      def execute
+        context = {
+          THIS: ImminentlyDeceasedObject.new(:program, :THIS)
+        }
+        @statements.execute(context)
+      end
+
+      def to_s
+        @statements.to_s
+      end
+    end
+  end
+end

data/lib/tildeath/ast_nodes/split.rb

@@ -0,0 +1,25 @@
+require_relative '../imminently_deceased_object'
+
+module Tildeath
+  module ASTNodes
+    class Split
+      def initialize(orig, parts)
+        @orig = orig
+        @parts = parts
+      end
+
+      def execute(context)
+        type = context[@orig].type
+        @parts.each do |part|
+          context[part] = ImminentlyDeceasedObject.new(type, part)
+        end
+      end
+
+      def to_s
+        @parts[1..-1].reduce("split #{@orig}[#{@parts[0]}") {|memo, part|
+          memo << ', ' << part.to_s
+        } << ']'
+      end
+    end
+  end
+end

data/lib/tildeath/ast_nodes/statements.rb

@@ -0,0 +1,23 @@
+module Tildeath
+  module ASTNodes
+    class Statements
+      def initialize(statements=[])
+        @statements = statements
+      end
+
+      def execute(context)
+        return unless context[:THIS].alive?
+        @statements.each do |statement|
+          return unless context[:THIS].alive?
+          statement.execute(context)
+        end
+      end
+
+      def to_s
+        @statements.reduce('') do |memo, stmt|
+          memo << stmt.to_s << ";\n"
+        end
+      end
+    end
+  end
+end

data/lib/tildeath/ast_nodes/tildeath.rb

@@ -0,0 +1,29 @@
+module Tildeath
+  module ASTNodes
+    class Tildeath
+      def initialize(victim, tildeath_body, execute_body)
+        @victim = victim
+        @tildeath_body = tildeath_body
+        @execute_body = execute_body
+      end
+
+      def execute(context)
+        fail "error: no such object: #{@victim}" unless context[@victim]
+        # loop over first set of statements while victim is alive
+        while context[@victim].alive?
+          return unless context[:THIS].alive?
+          @tildeath_body.execute(context)
+        end
+        # run second set of statements when victim dies
+        return unless context[:THIS].alive?
+        @execute_body.execute(context)
+      end
+
+      def to_s
+        "~ATH(#{@victim}) {
+  #{@tildeath_body}
+} EXECUTE(#{@execute_body})"
+      end
+    end
+  end
+end

data/lib/tildeath/ast_nodes/value.rb

@@ -0,0 +1,17 @@
+module Tildeath
+  module ASTNodes
+    class Value
+      def initialize(value)
+        @value = value
+      end
+
+      def execute(context)
+        context[@value].alive?
+      end
+
+      def to_s
+        @value
+      end
+    end
+  end
+end

data/lib/tildeath/imminently_deceased_object.rb

@@ -0,0 +1,19 @@
+module Tildeath
+  class ImminentlyDeceasedObject
+    attr_reader :type, :name
+
+    def initialize(type, name)
+      @type = type
+      @name = name
+      @alive = true
+    end
+
+    def die
+      @alive = false
+    end
+
+    def alive?
+      @alive
+    end
+  end
+end

data/lib/tildeath/interpreter.rb

@@ -0,0 +1,22 @@
+require_relative 'tildeath_error'
+require_relative 'lexer'
+require_relative 'parser'
+
+module Tildeath
+  module Interpreter
+    def self.interpret(script, filename:, verbose: false)
+      # discard shebang line if present
+      script.slice!(0, script.index("\n") + 1) if script[0..1] == "#!"
+      # scan string into tokens
+      tokens = Lexer.lex(script)
+      # parse tokens into abstract syntax tree
+      tree = Parser.parse(tokens)
+      # show gussed original source based on AST
+      puts tree if verbose
+      # execute AST starting at its root
+      tree.execute
+    rescue TildeathError => ex
+      puts "#{filename}:#{ex.line_number}:#{ex.column}: #{ex.message}"
+    end
+  end
+end

data/lib/tildeath/lexer.rb

@@ -0,0 +1,70 @@
+require_relative 'tildeath_error'
+require_relative 'token'
+
+module Tildeath
+  module Lexer
+    # token types
+    TOKENS = {
+      COMMENT:  /\/\/.*$/,
+      IMPORT:   /import/,
+      TILDEATH: /~ATH/,
+      EXECUTE:  /EXECUTE/,
+      THIS:     /THIS/,
+      BIFURC8:  /bifurcate/,
+      SPLIT:    /split/,
+      LBRACE:   /\{/,
+      RBRACE:   /\}/,
+      LPAREN:   /\(/,
+      RPAREN:   /\)/,
+      LBRACKET: /\[/,
+      RBRACKET: /\]/,
+      DOT:      /\./,
+      DIE:      /DIE/,
+      NULL:     /NULL/,
+      COMMA:    /,/,
+      SEMI:     /;/,
+      BANG:     /!/,
+      # one or more whitespace characters
+      WS:       /\s+/,
+      # a letter or underscore followed by zero or more letters, underscores, and digits
+      IDENT:    /[a-z_][a-z_0-9]*/i
+    }
+
+    def self.lex(input)
+      # tokens found so far
+      tokens = []
+      # current position in script
+      pos = 0
+      line_number = 0
+      column = 0
+      match = nil
+      # while pos isn't outside the script...
+      while pos < input.length
+        if input[pos] != "\n"
+          column += 1
+        else
+          line_number += 1
+          column = 0
+        end
+        # for each token type...
+        good = TOKENS.any? do |sym, regex|
+          # try to match it at the current position in the script
+          match = input.match(regex, pos)
+          # skip to next token type unless it matched at the current position
+          next unless match && match.begin(0) == pos
+          # ignore whitespace and comments
+          unless [:WS, :COMMENT].include?(sym)
+            # add new token to list of found tokens
+            # if it's an identifier, save the actual text found as well
+            tokens << Token.new(sym, line_number, column, sym == :IDENT ? match[0] : nil)
+          end
+          # move current position to just after the end of the found token
+          pos += match[0].length
+          true
+        end
+        fail TildeathError.new(line_number, column), "error: unrecognized token #{input[pos]}" unless good
+      end
+      return tokens
+    end
+  end
+end

data/lib/tildeath/parser.rb

@@ -0,0 +1,136 @@
+require_relative 'tildeath_error'
+require_relative 'ast_nodes'
+
+module Tildeath
+  module Parser
+    # null: NULL
+    def self.parse_null(tokens)
+      # shift the NULL off the token queue
+      tokens.shift
+      # return a new Null object
+      ASTNodes::Null.new
+    end
+
+    # import: IMPORT IDENT IDENT
+    def self.parse_import(tokens)
+      # Shift the IMPORT IDENT IDENT tokens off the queue, saving the type and
+      #   name as symbols
+      type, name = tokens.shift(3)[1..2].map{|token| token.value.to_sym}
+      # return a new Import with the given type and name
+      ASTNodes::Import.new(type, name)
+    end
+
+    # value: THIS | IDENT
+    def self.parse_value(tokens)
+      ASTNodes::Value.new(tokens.shift.value.to_sym)
+    end
+
+    # bang: BANG value
+    def self.parse_bang(tokens)
+      # shift off BANG
+      tokens.shift
+      value = parse_value(tokens)
+      ASTNodes::Bang.new(operand)
+    end
+
+    # expression: bang | value
+    def self.parse_expression(tokens)
+      return parse_bang(tokens) if tokens[0].name == :BANG
+      parse_value(tokens)
+    end
+
+    # tildeath: TILDEATH LPAREN expression RPAREN LBRACE statements RBRACE EXECUTE LPAREN statements RPAREN
+    def self.parse_tildeath(tokens)
+      # shift off the first five tokens, saving the IDENT
+      victim = tokens.shift(5)[2]
+      victim = victim == :THIS ? victim.name : victim.value.to_sym
+      # parse the first statements
+      tildeath_body = parse_statements(tokens)
+      # shift off some punctuation
+      tokens.shift(3)
+      # parse the EXECUTE statements (or NULL)
+      execute_body = tokens[0].name == :NULL ? parse_null(tokens) : parse_statements(tokens)
+      # shift off the last RPAREN
+      tokens.shift
+      # return a new Tildeath with the parsed victim and statements
+      ASTNodes::Tildeath.new(victim, tildeath_body, execute_body)
+    end
+
+    # array: LBRACKET expression (COMMA expression)* RBRACKET
+    def self.parse_array(tokens)
+      elements = []
+      elements << tokens.shift(2)[1].value.to_sym
+      ASTNodes::Array.new(elements)
+    end
+
+    # dot_die: expression DOT DIE LPAREN RPAREN
+    def self.parse_dot_die(tokens)
+      # shift off all the tokens, keeping the IDENT's value
+      victim = tokens.shift(5)[0]
+      victim = victim.name == :THIS ? victim.name.to_sym : victim.value.to_sym
+      ASTNodes::DotDie.new(victim)
+    end
+
+    # bifurcate: BIFURC8 IDENT LBRACKET IDENT COMMA IDENT RBRACKET
+    def self.parse_bifurcate(tokens)
+      orig = tokens.shift(3)[1].value.to_sym
+      parts = tokens.shift(4).values_at(0, 2).map do |token|
+        token.value.to_sym
+      end
+      ASTNodes::Bifurcate.new(orig, parts)
+    end
+
+    # split: SPLIT IDENT LBRACKET IDENT (COMMA IDENT)* RBRACKET
+    def self.parse_split(tokens)
+      orig = tokens.shift(3)[1].value.to_sym
+      parts = [tokens.shift.value.to_sym]
+      while true
+        part = tokens.shift
+        case part.name
+        when :COMMA
+          parts << tokens.shift.value.to_sym
+        when :RBRACKET
+          break
+        end
+      end
+      ASTNodes::Split.new(orig, parts)
+    end
+
+    # statement: (import | tildeath | dot_die | bifurcate | split) SEMI
+    # TODO: make [THIS, THIS].DIE() legal
+    def self.parse_statement(tokens)
+      # Determine statement type based on first token, and parse it
+      token = tokens[0].name
+      ret = case token
+            when :IMPORT then parse_import(tokens)
+            when :TILDEATH then parse_tildeath(tokens)
+            when :THIS, :IDENT then parse_dot_die(tokens)
+            when :BIFURC8 then parse_bifucate(tokens)
+            when :SPLIT then parse_split(tokens)
+            when :RBRACE then return
+            else fail TildeathError.new(token.line_number, token.column), "error: unexpected token #{token}"
+            end
+      # shift off SEMI
+      fail TildeathError.new(tokens[0].line_number, tokens[0].column), 'missing semicolon' unless tokens[0].name == :SEMI
+      tokens.shift
+      ret
+    end
+
+    # statements: statement*
+    def self.parse_statements(tokens)
+      statements = []
+      # while there are tokens left and parse_statement returns non-nil...
+      while tokens.length > 0 && statement = parse_statement(tokens)
+        # add parsed statement to list of parsed statements
+        statements << statement
+      end
+      # return a new Statements object with the list of parsed statements
+      ASTNodes::Statements.new(statements)
+    end
+
+    # program: statements
+    def self.parse(tokens)
+      ASTNodes::Program.new(parse_statements(tokens))
+    end
+  end
+end