lisp-interpreter 0.1.0

data/lib/lisp/interpreter/object.rb

@@ -0,0 +1,51 @@
+# redefine method in Object class
+class Object
+  def number?
+    to_f.to_s == to_s || to_i.to_s == to_s
+  end
+
+  def to_num
+    return to_f if to_f.to_s == to_s
+    return to_i if to_i.to_s == to_s
+  end
+
+  def character?
+    (start_with? '#\\') && (('a'..'z').to_a.include? self[2]) && size == 3
+  end
+
+  def string?
+    return false unless self.class == String
+    (start_with? '"') && (end_with? '"') && (size != 1)
+  end
+
+  def list?
+    return false if size < 3
+    check_for_list
+  end
+
+  def pair?
+    res = object_split if is_a? String
+    res = to_a if is_a? Array
+    return true if res[-3] == '.'
+    list? && !res[2..-2].empty?
+  end
+
+  def quote?
+    return true if start_with? '\''
+    false
+  end
+
+  private
+
+  def object_split
+    result = to_s.split(/(\(|\)|\.)|\ /)
+    result.delete('')
+    result
+  end
+
+  def check_for_list
+    res = to_a if is_a? Array
+    res = object_split if is_a? String
+    res[0..1].join == '\'(' && res[-1] == ')' && res[-3] != '.'
+  end
+end

data/lib/lisp/interpreter/parser.rb

@@ -0,0 +1,72 @@
+require_relative 'errors'
+require_relative 'validator'
+require_relative 'tokenizer'
+
+# Environment type
+module Environment
+  TEST = 1
+  PROD = 2
+end
+
+# Parser is used to validate the user input and parse it to the tokenizer
+class Parser
+  include ErrorMessages
+  include Validator
+  include Environment
+
+  def initialize(env_type = Environment::TEST)
+    @ENV_TYPE = env_type
+    @tokenizer = Tokenizer.new
+  end
+
+  def run
+    loop do
+      print 'zakichan> ' if @ENV_TYPE == Environment::PROD
+      token = ''
+      until (validate_token token).nil? && token != ''
+        crr_input = STDIN.gets.chomp
+        token << crr_input
+        break if crr_input == ''
+      end
+      parse token
+    end
+  end
+
+  def split_token(token)
+    result = []
+    token.split(/\s+(?=(?:[^"]*"[^"]*")*[^"]*$)/).each do |t|
+      if !t.string? && (t.include?('(') || t.include?(')'))
+        t.to_s.split(/(\(|\))/).each { |p| result << p }
+      else
+        result << t
+      end
+    end
+    result
+  end
+
+  def parse(token)
+    token_error = validate_token token
+    result =
+      if token_error.nil?
+        @tokenizer.tokenize split_token token
+      else
+        token_error
+      end
+    print_result result unless result.to_s.empty?
+  end
+
+  def validate_token(token)
+    if !balanced_brackets? token
+      unbalanced_brackets_error
+    elsif !balanced_quotes? token
+      unbalanced_quotes_error
+    end
+  end
+
+  def print_result(result)
+    to_remove = result.to_s.list? || result.to_s.pair? || result.to_s.quote?
+    result = result.delete('\'') if to_remove
+    puts result if @ENV_TYPE == Environment::PROD
+    result
+  end
+end

data/lib/lisp/interpreter/run.rb

@@ -0,0 +1,4 @@
+require_relative 'parser'
+
+parser = Parser.new Environment::PROD
+parser.run

data/lib/lisp/interpreter/strings.rb

@@ -0,0 +1,131 @@
+# Helper functions for SchemeStrings
+module SchemeStringsHelper
+  def substring_builder(str, from, to)
+    result = (str[1..-2])[from..(to.nil? ? -1 : to - 1)]
+    return '""' if result.nil?
+    '"' + result + '"'
+  end
+
+  def find_delimeter(other)
+    return ' ' if other.nil?
+    other[1..-2]
+  end
+
+  def build_as_string_helper(other, idx)
+    value = other[0..idx].join(' ').gsub('( ', '(').gsub(' )', ')')
+    [value, other[idx + 1..-1]]
+  end
+
+  def build_next_value_as_string(other)
+    idx = find_idx_for_list other
+    if other[0] == '('
+      build_as_string_helper other, idx
+    elsif other[0..1].join == '\'('
+      [(get_raw_value other[0..idx]), other[idx + 1..-1]]
+    else
+      [other[0], other[1..-1]]
+    end
+  end
+
+  def build_character(char)
+    '#\\' + (char == ' ' ? 'space' : char)
+  end
+
+  def remove_carriage(str)
+    str = str[1..-2]
+    str.gsub('\n', '').gsub('\r', '').gsub('\t', '').strip.squeeze(' ')
+  end
+
+  def arg_function_validator(other, vars = 1)
+    raise 'Incorrect number of arguments' if other.size != vars
+    result = other[0..vars - 1].all? { |v| check_for_string v }
+    raise 'Invalid data type' unless result
+    result
+  end
+
+  def string_join_helper(other, dilimeter)
+    values = split_list_as_string other.to_s
+    delim_result = find_delimeter dilimeter
+    '"' + (values.join delim_result) + '"'
+  end
+end
+
+# Scheme numbers module
+module SchemeStrings
+  include SchemeStringsHelper
+  def substring(other)
+    raise 'Incorrect number of arguments' unless other.size.between? 2, 3
+    str, from, to = other
+    arg_function_validator [str]
+    valid = (check_for_number from) && (to.nil? || (check_for_number to))
+    raise 'Incorrect parameter type' unless valid
+    substring_builder str, from.to_num, to.to_num
+  end
+
+  def string?(other)
+    raise 'Incorrect number of arguments' if other.size != 1
+    result = check_for_string other[0].to_s
+    result ? '#t' : '#f'
+  end
+
+  def strlen(other)
+    arg_function_validator other
+    other[0][1..-2].length
+  end
+
+  def strupcase(other)
+    arg_function_validator other
+    other[0].upcase
+  end
+
+  def strdowncase(other)
+    arg_function_validator other
+    other[0].downcase
+  end
+
+  def strcontains(other)
+    arg_function_validator other, 2
+    result = other[0][1..-2].include? other[1][1..-2]
+    result ? '#t' : '#f'
+  end
+
+  def strsplit(other)
+    arg_function_validator other
+    str = remove_carriage other[0]
+    result = str.split(' ').map { |s| '"' + s + '"' }
+    build_list result
+  end
+
+  def strlist(other)
+    arg_function_validator other
+    result = other[0][1..-2].chars.map { |c| build_character c }
+    build_list result
+  end
+
+  def strreplace(other)
+    arg_function_validator other, 3
+    str, to_replace, replace_with = other.map { |t| t[1..-2] }
+    '"' + (str.gsub to_replace, replace_with) + '"'
+  end
+
+  def strprefix(other)
+    arg_function_validator other, 2
+    str, to_check = other.map { |t| t[1..-2] }
+    result = str.start_with? to_check
+    result ? '#t' : '#f'
+  end
+
+  def strsufix(other)
+    arg_function_validator other, 2
+    str, to_check = other.map { |t| t[1..-2] }
+    result = str.end_with? to_check
+    result ? '#t' : '#f'
+  end
+
+  def strjoin(other)
+    raise 'Incorrect number of arguments' unless other.size.between? 1, 2
+    raise 'Invalid data type' unless other[0].to_s.list?
+    arg_function_validator [other[1]] if other.size == 2
+    string_join_helper other[0], other[1]
+  end
+end

data/lib/lisp/interpreter/tokenizer.rb

@@ -0,0 +1,185 @@
+require_relative 'object'
+require_relative 'errors'
+require_relative 'value_finder'
+require_relative 'checker'
+require_relative 'validator'
+require_relative 'numbers'
+require_relative 'strings'
+require_relative 'boolean'
+require_relative 'list'
+require_relative 'functional'
+
+# Tokenizer helper
+module TokenizerHelper
+  def initialize
+    @other = []
+    @procs = {}
+    @do_not_calculate = init_do_not_calculate_fn
+    @reserved = init_reserved_fn
+    set_reserved_keywords
+    @functions = init_functions
+    init_predefined.each { |f| @functions[f] = f }
+  end
+
+  def reset
+    @other = []
+  end
+
+  def init_do_not_calculate_fn
+    %w[
+      foldl foldr map filter
+      if apply numerator denominator
+      lambda compose define
+    ]
+  end
+
+  def init_functions
+    {
+      'string-downcase'  => 'strdowncase', 'string-upcase'  => 'strupcase',
+      'string-contains?' => 'strcontains', 'string-length'  => 'strlen',
+      'string->list'     => 'strlist',     'string-split'   => 'strsplit',
+      'string-sufix?'    => 'strsufix',    'string-prefix?' => 'strprefix',
+      'string-replace'   => 'strreplace',  'string-join'    => 'strjoin',
+      'list-ref'         => 'listref',     'list-tail'      => 'listtail'
+    }
+  end
+
+  def init_predefined
+    %w[
+      define not equal? if quotient remainder modulo numerator denominator
+      min max sub1 add1 abs string? substring null? cons null list car
+      cdr list? pair? length reverse remove shuffle map foldl foldr filter
+      member lambda apply compose
+    ]
+  end
+
+  def init_reserved_fn
+    {
+      'null' => '\'()'
+    }
+  end
+
+  def set_reserved_keywords
+    @reserved.each do |key, value|
+      instance_variable_set("@#{key}", value)
+    end
+  end
+
+  def set_var_helper(var, value)
+    valid = (valid_var value.to_s) || (value.is_a? Proc)
+    raise 'Invalid parameter' unless valid
+    if value.is_a? Proc
+      remove_instance_variable("@#{var}") if check_instance_var var
+      @procs[var] = value if value.is_a? Proc
+    else
+      @procs.delete var
+      set_var var, value
+    end
+  end
+
+  def set_var(var, value)
+    raise 'Cannot predefine reserved keyword' if @reserved.key? var
+    instance_variable_set("@#{var}", value)
+  end
+
+  def get_var(var)
+    check = check_instance_var var
+    return instance_variable_get("@#{var}") if check
+    val = (predefined_method_caller [var])
+    return val unless val.nil?
+    valid = valid_var var
+    valid ? var : (raise 'Invalid data type')
+  end
+end
+
+# Tokenizer class
+class Tokenizer
+  include TokenizerHelper
+  include ValueFinder
+  include SchemeChecker
+  include Validator
+  include SchemeNumbers
+  include SchemeStrings
+  include SchemeBooleans
+  include SchemeLists
+  include FunctionalScheme
+
+  def tokenize(token)
+    reset
+    token.delete('')
+    @other = token
+    begin
+      calc_input_val @other
+    rescue ZeroDivisionError, RuntimeError => e
+      e.message
+    end
+  end
+
+  def check_car_cdr(arr)
+    result = arr[1].match(/c[ad]{2,}r/)
+    raise 'No procedure found' if result.nil?
+    car_cdr_infinite arr
+  end
+
+  def calc_input_val(arr)
+    get_raw = (arr.is_a? Array) && arr.size > 1 && arr[0..1].join != '\'('
+    return get_raw_value arr unless get_raw
+    m_name = predefined_method_caller arr
+    return check_car_cdr arr if m_name.nil?
+    call_predefined_method m_name, arr
+  end
+
+  def special_check_proc(m_name, arr)
+    if arr[0..1].join == '(('
+      idx = find_bracket_idx arr, 1
+      func, = valid_function arr[1..idx]
+      values = find_all_values arr[idx + 1..-2]
+      func.call(*values)
+    else
+      m_name.call(*arr[2..-2])
+    end
+  end
+
+  def call_predefined_method(m_name, arr)
+    return special_check_proc m_name, arr if m_name.is_a? Proc
+    if @do_not_calculate.include? m_name
+      send m_name.to_s, arr[2..-2]
+    elsif !m_name.nil?
+      values = find_all_values arr[2..-2]
+      send m_name.to_s, values
+    end
+  end
+
+  def predefined_method_caller_helper(m_name, operations)
+    return m_name if m_name.is_a? Proc
+    return @procs[m_name] if @procs.key? m_name
+    return m_name if operations.include? m_name
+    return @functions[m_name] if @functions.key? m_name
+    m_name if @functions.value? m_name
+  end
+
+  def method_caller_checker(token, operations)
+    !token.to_s.match(/[[:alpha:]]/).nil? || (operations.include? token.to_s)
+  end
+
+  def predefined_method_caller(arr)
+    operations = ['+', '-', '/', '*', '<', '<=', '>', '>=']
+    m_name =
+      arr.each do |t|
+        break t if t.is_a? Proc
+        break t if method_caller_checker t, operations
+        break t unless t.match(/[[:digit:]]/).nil?
+      end
+    predefined_method_caller_helper m_name, operations
+  end
+
+  def get_raw_value(token)
+    if token.pair? || token.list?
+      build_list no_eval_list token[2..-2]
+    else
+      return if token.empty?
+      token = token.join('') if token.is_a? Array
+      get_var token.to_s
+    end
+  end
+end