root/lang/ruby/LoLS/trunk/lols.rb @ 31217

#!/usr/bin/env ruby
#
# Lisp Of Least Surprise (for Rubyist)
#
#
require 'stringio'
require 'pp'

class Cell
  NIL=:nil
  def initialize( car = NIL, cdr = NIL )
    @car = car
    @cdr = cdr
  end
  attr_accessor :car, :cdr
end


class Token
  def initialize( type, str )
    @type = type
    @str  = str
  end
  attr_accessor :type, :str
end


class Reader
  ## tokens
  T_EOF       = :t_eof
  T_LPAREN    = :t_lparen
  T_RPAREN    = :t_rparen
  T_SYMBOL    = :t_symbol
  T_NUM       = :t_num
  T_QUOTE     = :t_quote
  T_DOT       = :t_dot

  # inport is IO class
  def initialize( inport )
    @inport   = inport
    @curtoken = nil
  end

  def skipspace
    ch = @inport.getc
    if !@inport.eof? 
      while ch.chr.match( /[ \t\r\n]/ )
        ch = @inport.getc
      end
      @inport.ungetc( ch )
    end
  end

  def readwhile( exp )
    ret = ""
    while true
      ch = @inport.getc
      if @inport.eof? 
        break
      end
      if ch.chr.match( exp )
        ret += ch.chr
      else
        @inport.ungetc( ch )
        break
      end
    end
    ret
  end

  def token
    skipspace
    ch = @inport.getc
    if @inport.eof?
      @curtoken = Token.new( T_EOF, "" )
    else
      str = ch.chr
      type =
        case str
        when '('
          T_LPAREN
        when ')'
          T_RPAREN
        when '.'
          T_DOT
        when /[a-zA-Z+*\/=!-]/ # symbol
          str += readwhile( /[a-zA-Z+*\/=!-]/ )
          T_SYMBOL
        when /[0-9]/        # number
          str += readwhile( /[0-9.]/ )
          T_NUM
        when /[\']/
          T_QUOTE
        end
      p "  [" + str + "] : " + type.to_s
      @curtoken = Token.new( type, str )
    end
  end

  def curtoken
    @curtoken
  end

  def atom( tok )
    case tok.type
    when T_SYMBOL
      tok.str
    when T_NUM
      tok.str.to_i
    when T_QUOTE
      "quote"
    end
  end

  def sexp( tok )
    dotted = false
    cells = []
    while true
      case tok.type
      when T_EOF
        print "Error: unbalanced paren(2)"
        break
      when T_LPAREN
        cells << Cell.new( sexp( token ))
        tok = curtoken
      when T_RPAREN
        token
        break
      else
        if tok.type == T_DOT
          if 1 == cells.size
            dotted = true
            tok = token
          else
            print "Error : illegal dotted pair syntax"
            break
          end
        elsif tok.type == T_QUOTE
          cells << Cell.new( atom( tok ), top( token ))
          tok = curtoken
        else
          cells << Cell.new( atom( tok ))
          tok = token
        end
      end
    end
    if dotted
      ## dotted list
      Cell.new( cells[0].car, cells[1].car )
    else
      ## setup list
      if 1 < cells.size
        ptr = cells.pop
        cells.reverse.each { |x|
          x.cdr = ptr
          ptr = x
        }
      end
      cells.first
    end
  end
  def top( tok )
    case tok.type
    when T_EOF
      break
    when T_LPAREN
      sexp( token )
    when T_RPAREN
      print "Error: unbalanced paren(1)"
    when T_QUOTE
      Cell.new( atom( tok ), top( token ))
    else
      atom( tok )
    end
  end

  def read
    top( token )
  end
end


class Core
  def initialize( io )
    @reader       = Reader.new( io )
    @evalulator   = Evalulator.new
    @printer      = Printer.new
  end
  
  def repl
    while true
      @printer.print( @evalulator.eval( @reader.read ))
    end
  end
end


# test
def readerTest( sexp )
  sio = StringIO.open( sexp )
  reader = Reader.new( sio )
  p "--- " + sexp + " --- is "
  pp reader.read
end

readerTest( " + " )
readerTest( " 123 " )
readerTest( " ( 1 . 2 ) " )
readerTest( " ( 1 ) " )
readerTest( " (car '(1 . 2)) " )
readerTest( " (cdr '(1 . 2)) " )
readerTest( " ( 1 2 3 4 ) " )
readerTest( " '( 1 2 3 '4 ) " )
#readerTest( " (( 1 )) " )
#readerTest( " ( 1 2 ( 3 4 )) " )
#readerTest( " ( " )
#readerTest( " ) " )


#def main
#  sio = StringIO.open( " (car 1 2 3) " )
#  core = Core.new( sio )
#  while true
#    core.repl
#  end
#end