irb 0.9.6

data/lib/irb/ruby-token.rb

@@ -0,0 +1,267 @@
+# frozen_string_literal: false
+#
+#   irb/ruby-token.rb - ruby tokens
+#   	$Release Version: 0.9.6$
+#   	$Revision$
+#   	by Keiju ISHITSUKA(keiju@ruby-lang.org)
+#
+# --
+#
+#
+#
+# :stopdoc:
+module RubyToken
+  EXPR_BEG = :EXPR_BEG
+  EXPR_MID = :EXPR_MID
+  EXPR_END = :EXPR_END
+  EXPR_ARG = :EXPR_ARG
+  EXPR_FNAME = :EXPR_FNAME
+  EXPR_DOT = :EXPR_DOT
+  EXPR_CLASS = :EXPR_CLASS
+
+  class Token
+    def initialize(seek, line_no, char_no)
+      @seek = seek
+      @line_no = line_no
+      @char_no = char_no
+    end
+    attr_reader :seek, :line_no, :char_no
+  end
+
+  class TkNode < Token
+    def initialize(seek, line_no, char_no)
+      super
+    end
+    attr_reader :node
+  end
+
+  class TkId < Token
+    def initialize(seek, line_no, char_no, name)
+      super(seek, line_no, char_no)
+      @name = name
+    end
+    attr_reader :name
+  end
+
+  class TkVal < Token
+    def initialize(seek, line_no, char_no, value = nil)
+      super(seek, line_no, char_no)
+      @value = value
+    end
+    attr_reader :value
+  end
+
+  class TkOp < Token
+    attr_accessor :name
+  end
+
+  class TkOPASGN < TkOp
+    def initialize(seek, line_no, char_no, op)
+      super(seek, line_no, char_no)
+      op = TkReading2Token[op][0] unless op.kind_of?(Symbol)
+      @op = op
+    end
+    attr_reader :op
+  end
+
+  class TkUnknownChar < Token
+    def initialize(seek, line_no, char_no, id)
+      super(seek, line_no, char_no)
+      @name = name
+    end
+    attr_reader :name
+  end
+
+  class TkError < Token
+  end
+
+  def Token(token, value = nil)
+    case token
+    when String
+      if (tk = TkReading2Token[token]).nil?
+        IRB.fail TkReading2TokenNoKey, token
+      end
+      tk = Token(tk[0], value)
+      if tk.kind_of?(TkOp)
+        tk.name = token
+      end
+      return tk
+    when Symbol
+      if (tk = TkSymbol2Token[token]).nil?
+        IRB.fail TkSymbol2TokenNoKey, token
+      end
+      return Token(tk[0], value)
+    else
+      if (token.ancestors & [TkId, TkVal, TkOPASGN, TkUnknownChar]).empty?
+        token.new(@prev_seek, @prev_line_no, @prev_char_no)
+      else
+        token.new(@prev_seek, @prev_line_no, @prev_char_no, value)
+      end
+    end
+  end
+
+  TokenDefinitions = [
+    [:TkCLASS,      TkId,  "class",  EXPR_CLASS],
+    [:TkMODULE,     TkId,  "module", EXPR_BEG],
+    [:TkDEF,	    TkId,  "def",    EXPR_FNAME],
+    [:TkUNDEF,      TkId,  "undef",  EXPR_FNAME],
+    [:TkBEGIN,      TkId,  "begin",  EXPR_BEG],
+    [:TkRESCUE,     TkId,  "rescue", EXPR_MID],
+    [:TkENSURE,     TkId,  "ensure", EXPR_BEG],
+    [:TkEND,	    TkId,  "end",    EXPR_END],
+    [:TkIF,         TkId,  "if",     EXPR_BEG, :TkIF_MOD],
+    [:TkUNLESS,     TkId,  "unless", EXPR_BEG, :TkUNLESS_MOD],
+    [:TkTHEN,	    TkId,  "then",   EXPR_BEG],
+    [:TkELSIF,      TkId,  "elsif",  EXPR_BEG],
+    [:TkELSE,	    TkId,  "else",   EXPR_BEG],
+    [:TkCASE,	    TkId,  "case",   EXPR_BEG],
+    [:TkWHEN,	    TkId,  "when",   EXPR_BEG],
+    [:TkWHILE,      TkId,  "while",  EXPR_BEG, :TkWHILE_MOD],
+    [:TkUNTIL,      TkId,  "until",  EXPR_BEG, :TkUNTIL_MOD],
+    [:TkFOR,	    TkId,  "for",    EXPR_BEG],
+    [:TkBREAK,      TkId,  "break",  EXPR_END],
+    [:TkNEXT,	    TkId,  "next",   EXPR_END],
+    [:TkREDO,	    TkId,  "redo",   EXPR_END],
+    [:TkRETRY,      TkId,  "retry",  EXPR_END],
+    [:TkIN,	    TkId,  "in",     EXPR_BEG],
+    [:TkDO,	    TkId,  "do",     EXPR_BEG],
+    [:TkRETURN,     TkId,  "return", EXPR_MID],
+    [:TkYIELD,      TkId,  "yield",  EXPR_END],
+    [:TkSUPER,      TkId,  "super",  EXPR_END],
+    [:TkSELF,	    TkId,  "self",   EXPR_END],
+    [:TkNIL, 	    TkId,  "nil",    EXPR_END],
+    [:TkTRUE,	    TkId,  "true",   EXPR_END],
+    [:TkFALSE,      TkId,  "false",  EXPR_END],
+    [:TkAND,	    TkId,  "and",    EXPR_BEG],
+    [:TkOR, 	    TkId,  "or",     EXPR_BEG],
+    [:TkNOT,	    TkId,  "not",    EXPR_BEG],
+    [:TkIF_MOD,     TkId],
+    [:TkUNLESS_MOD, TkId],
+    [:TkWHILE_MOD,  TkId],
+    [:TkUNTIL_MOD,  TkId],
+    [:TkALIAS,      TkId,  "alias",    EXPR_FNAME],
+    [:TkDEFINED,    TkId,  "defined?", EXPR_END],
+    [:TklBEGIN,     TkId,  "BEGIN",    EXPR_END],
+    [:TklEND,	    TkId,  "END",      EXPR_END],
+    [:Tk__LINE__,   TkId,  "__LINE__", EXPR_END],
+    [:Tk__FILE__,   TkId,  "__FILE__", EXPR_END],
+
+    [:TkIDENTIFIER, TkId],
+    [:TkFID,	    TkId],
+    [:TkGVAR,	    TkId],
+    [:TkCVAR,	    TkId],
+    [:TkIVAR,	    TkId],
+    [:TkCONSTANT,   TkId],
+
+    [:TkINTEGER,    TkVal],
+    [:TkFLOAT,      TkVal],
+    [:TkSTRING,     TkVal],
+    [:TkXSTRING,    TkVal],
+    [:TkREGEXP,     TkVal],
+    [:TkSYMBOL,     TkVal],
+
+    [:TkDSTRING,    TkNode],
+    [:TkDXSTRING,   TkNode],
+    [:TkDREGEXP,    TkNode],
+    [:TkNTH_REF,    TkNode],
+    [:TkBACK_REF,   TkNode],
+
+    [:TkUPLUS,      TkOp,   "+@"],
+    [:TkUMINUS,     TkOp,   "-@"],
+    [:TkPOW,	    TkOp,   "**"],
+    [:TkCMP,	    TkOp,   "<=>"],
+    [:TkEQ,	    TkOp,   "=="],
+    [:TkEQQ,	    TkOp,   "==="],
+    [:TkNEQ,	    TkOp,   "!="],
+    [:TkGEQ,	    TkOp,   ">="],
+    [:TkLEQ,	    TkOp,   "<="],
+    [:TkANDOP,      TkOp,   "&&"],
+    [:TkOROP,	    TkOp,   "||"],
+    [:TkMATCH,      TkOp,   "=~"],
+    [:TkNMATCH,     TkOp,   "!~"],
+    [:TkDOT2,	    TkOp,   ".."],
+    [:TkDOT3,	    TkOp,   "..."],
+    [:TkAREF,	    TkOp,   "[]"],
+    [:TkASET,	    TkOp,   "[]="],
+    [:TkLSHFT,      TkOp,   "<<"],
+    [:TkRSHFT,      TkOp,   ">>"],
+    [:TkCOLON2,     TkOp],
+    [:TkCOLON3,     TkOp],
+    [:TkASSOC,      TkOp,   "=>"],
+    [:TkQUESTION,   TkOp,   "?"],	 #?
+    [:TkCOLON,      TkOp,   ":"],        #:
+
+    [:TkfLPAREN],         # func( #
+    [:TkfLBRACK],         # func[ #
+    [:TkfLBRACE],         # func{ #
+    [:TkSTAR],            # *arg
+    [:TkAMPER],           # &arg #
+    [:TkSYMBEG],          # :SYMBOL
+
+    [:TkGT,	    TkOp,   ">"],
+    [:TkLT,	    TkOp,   "<"],
+    [:TkPLUS,	    TkOp,   "+"],
+    [:TkMINUS,      TkOp,   "-"],
+    [:TkMULT,	    TkOp,   "*"],
+    [:TkDIV,	    TkOp,   "/"],
+    [:TkMOD,	    TkOp,   "%"],
+    [:TkBITOR,      TkOp,   "|"],
+    [:TkBITXOR,     TkOp,   "^"],
+    [:TkBITAND,     TkOp,   "&"],
+    [:TkBITNOT,     TkOp,   "~"],
+    [:TkNOTOP,      TkOp,   "!"],
+
+    [:TkBACKQUOTE,  TkOp,   "`"],
+
+    [:TkASSIGN,     Token,  "="],
+    [:TkDOT,	    Token,  "."],
+    [:TkLPAREN,     Token,  "("],  #(exp)
+    [:TkLBRACK,     Token,  "["],  #[arry]
+    [:TkLBRACE,     Token,  "{"],  #{hash}
+    [:TkRPAREN,     Token,  ")"],
+    [:TkRBRACK,     Token,  "]"],
+    [:TkRBRACE,     Token,  "}"],
+    [:TkCOMMA,      Token,  ","],
+    [:TkSEMICOLON,  Token,  ";"],
+
+    [:TkCOMMENT],
+    [:TkRD_COMMENT],
+    [:TkSPACE],
+    [:TkNL],
+    [:TkEND_OF_SCRIPT],
+
+    [:TkBACKSLASH,  TkUnknownChar,  "\\"],
+    [:TkAT,	    TkUnknownChar,  "@"],
+    [:TkDOLLAR,     TkUnknownChar,  "$"],
+  ]
+
+  # {reading => token_class}
+  # {reading => [token_class, *opt]}
+  TkReading2Token = {}
+  TkSymbol2Token = {}
+
+  def RubyToken.def_token(token_n, super_token = Token, reading = nil, *opts)
+    token_n = token_n.id2name if token_n.kind_of?(Symbol)
+    if RubyToken.const_defined?(token_n)
+      IRB.fail AlreadyDefinedToken, token_n
+    end
+    token_c = eval("class #{token_n} < #{super_token}; end; #{token_n}")
+
+    if reading
+      if TkReading2Token[reading]
+        IRB.fail TkReading2TokenDuplicateError, token_n, reading
+      end
+      if opts.empty?
+        TkReading2Token[reading] = [token_c]
+      else
+        TkReading2Token[reading] = [token_c].concat(opts)
+      end
+    end
+    TkSymbol2Token[token_n.intern] = token_c
+  end
+
+  for defs in TokenDefinitions
+    def_token(*defs)
+  end
+end
+# :startdoc:

data/lib/irb/slex.rb

@@ -0,0 +1,282 @@
+# frozen_string_literal: false
+#
+#   irb/slex.rb - simple lex analyzer
+#   	$Release Version: 0.9.6$
+#   	$Revision$
+#   	by Keiju ISHITSUKA(keiju@ruby-lang.org)
+#
+# --
+#
+#
+#
+
+require "e2mmap"
+require_relative "notifier"
+
+# :stopdoc:
+module IRB
+  class SLex
+
+    extend Exception2MessageMapper
+    def_exception :ErrNodeNothing, "node nothing"
+    def_exception :ErrNodeAlreadyExists, "node already exists"
+
+    DOUT = Notifier::def_notifier("SLex::")
+    D_WARN = DOUT::def_notifier(1, "Warn: ")
+    D_DEBUG = DOUT::def_notifier(2, "Debug: ")
+    D_DETAIL = DOUT::def_notifier(4, "Detail: ")
+
+    DOUT.level = Notifier::D_NOMSG
+
+    def initialize
+      @head = Node.new("")
+    end
+
+    def def_rule(token, preproc = nil, postproc = nil, &block)
+      D_DETAIL.pp token
+
+      postproc = block if block_given?
+      create(token, preproc, postproc)
+    end
+
+    def def_rules(*tokens, &block)
+      if block_given?
+        p = block
+      end
+      for token in tokens
+        def_rule(token, nil, p)
+      end
+    end
+
+    def preproc(token, proc)
+      node = search(token)
+      node.preproc=proc
+    end
+
+    # need a check?
+    def postproc(token)
+      node = search(token, proc)
+      node.postproc=proc
+    end
+
+    def search(token)
+      @head.search(token.split(//))
+    end
+
+    def create(token, preproc = nil, postproc = nil)
+      @head.create_subnode(token.split(//), preproc, postproc)
+    end
+
+    def match(token)
+      case token
+      when Array
+      when String
+        return match(token.split(//))
+      else
+        return @head.match_io(token)
+      end
+      ret = @head.match(token)
+      D_DETAIL.exec_if{D_DETAIL.printf "match end: %s:%s\n", ret, token.inspect}
+      ret
+    end
+
+    def inspect
+      format("<SLex: @head = %s>", @head.inspect)
+    end
+
+    #----------------------------------------------------------------------
+    #
+    #   class Node -
+    #
+    #----------------------------------------------------------------------
+    class Node
+      # if postproc is nil, this node is an abstract node.
+      # if postproc is non-nil, this node is a real node.
+      def initialize(preproc = nil, postproc = nil)
+        @Tree = {}
+        @preproc = preproc
+        @postproc = postproc
+      end
+
+      attr_accessor :preproc
+      attr_accessor :postproc
+
+      def search(chrs, opt = nil)
+        return self if chrs.empty?
+        ch = chrs.shift
+        if node = @Tree[ch]
+          node.search(chrs, opt)
+        else
+          if opt
+            chrs.unshift ch
+            self.create_subnode(chrs)
+          else
+            SLex.fail ErrNodeNothing
+          end
+        end
+      end
+
+      def create_subnode(chrs, preproc = nil, postproc = nil)
+        if chrs.empty?
+          if @postproc
+            D_DETAIL.pp node
+            SLex.fail ErrNodeAlreadyExists
+          else
+            D_DEBUG.puts "change abstract node to real node."
+            @preproc = preproc
+            @postproc = postproc
+          end
+          return self
+        end
+
+        ch = chrs.shift
+        if node = @Tree[ch]
+          if chrs.empty?
+            if node.postproc
+              DebugLogger.pp node
+              DebugLogger.pp self
+              DebugLogger.pp ch
+              DebugLogger.pp chrs
+              SLex.fail ErrNodeAlreadyExists
+            else
+              D_WARN.puts "change abstract node to real node"
+              node.preproc = preproc
+              node.postproc = postproc
+            end
+          else
+            node.create_subnode(chrs, preproc, postproc)
+          end
+        else
+          if chrs.empty?
+            node = Node.new(preproc, postproc)
+          else
+            node = Node.new
+            node.create_subnode(chrs, preproc, postproc)
+          end
+          @Tree[ch] = node
+        end
+        node
+      end
+
+      #
+      # chrs: String
+      #       character array
+      #       io must have getc()/ungetc(); and ungetc() must be
+      #       able to be called arbitrary number of times.
+      #
+      def match(chrs, op = "")
+        D_DETAIL.print "match>: ", chrs, "op:", op, "\n"
+        if chrs.empty?
+          if @preproc.nil? || @preproc.call(op, chrs)
+            DOUT.printf(D_DETAIL, "op1: %s\n", op)
+            @postproc.call(op, chrs)
+          else
+            nil
+          end
+        else
+          ch = chrs.shift
+          if node = @Tree[ch]
+            if ret = node.match(chrs, op+ch)
+              return ret
+            else
+              chrs.unshift ch
+              if @postproc and @preproc.nil? || @preproc.call(op, chrs)
+                DOUT.printf(D_DETAIL, "op2: %s\n", op.inspect)
+                ret = @postproc.call(op, chrs)
+                return ret
+              else
+                return nil
+              end
+            end
+          else
+            chrs.unshift ch
+            if @postproc and @preproc.nil? || @preproc.call(op, chrs)
+              DOUT.printf(D_DETAIL, "op3: %s\n", op)
+              @postproc.call(op, chrs)
+              return ""
+            else
+              return nil
+            end
+          end
+        end
+      end
+
+      def match_io(io, op = "")
+        if op == ""
+          ch = io.getc
+          if ch == nil
+            return nil
+          end
+        else
+          ch = io.getc_of_rests
+        end
+        if ch.nil?
+          if @preproc.nil? || @preproc.call(op, io)
+            D_DETAIL.printf("op1: %s\n", op)
+            @postproc.call(op, io)
+          else
+            nil
+          end
+        else
+          if node = @Tree[ch]
+            if ret = node.match_io(io, op+ch)
+              ret
+            else
+              io.ungetc ch
+              if @postproc and @preproc.nil? || @preproc.call(op, io)
+                DOUT.exec_if{D_DETAIL.printf "op2: %s\n", op.inspect}
+                @postproc.call(op, io)
+              else
+                nil
+              end
+            end
+          else
+            io.ungetc ch
+            if @postproc and @preproc.nil? || @preproc.call(op, io)
+              D_DETAIL.printf("op3: %s\n", op)
+              @postproc.call(op, io)
+            else
+              nil
+            end
+          end
+        end
+      end
+    end
+  end
+end
+# :startdoc:
+
+if $0 == __FILE__
+  case $1
+  when "1"
+    tr = SLex.new
+    print "0: ", tr.inspect, "\n"
+    tr.def_rule("=") {print "=\n"}
+    print "1: ", tr.inspect, "\n"
+    tr.def_rule("==") {print "==\n"}
+    print "2: ", tr.inspect, "\n"
+
+    print "case 1:\n"
+    print tr.match("="), "\n"
+    print "case 2:\n"
+    print tr.match("=="), "\n"
+    print "case 3:\n"
+    print tr.match("=>"), "\n"
+
+  when "2"
+    tr = SLex.new
+    print "0: ", tr.inspect, "\n"
+    tr.def_rule("=") {print "=\n"}
+    print "1: ", tr.inspect, "\n"
+    tr.def_rule("==", proc{false}) {print "==\n"}
+    print "2: ", tr.inspect, "\n"
+
+    print "case 1:\n"
+    print tr.match("="), "\n"
+    print "case 2:\n"
+    print tr.match("=="), "\n"
+    print "case 3:\n"
+    print tr.match("=>"), "\n"
+  end
+  exit
+end