    # File lib/yard/parser/ruby/legacy/ruby_lex.rb, line 612
          def lex_init()
            @OP = SLex.new
            @OP.def_rules("\0", "\004", "\032") do |chars, io|
              Token(TkEND_OF_SCRIPT).set_text(chars)
            end

            @OP.def_rules(" ", "\t", "\f", "\r", "\13") do |chars, io|
              @space_seen = TRUE
              while (ch = getc) =~ /[ \t\f\r\13]/
                chars << ch
              end
              ungetc
              Token(TkSPACE).set_text(chars)
            end

            @OP.def_rule("#") do
              |op, io|
              identify_comment
            end

            @OP.def_rule("=begin", proc{@prev_char_no == 0 && peek(0) =~ /\s/}) do
              |op, io|
              str = op
              @ltype = "="

              begin
                line = ""
                begin
                  ch = getc
                  line << ch
                end until ch == "\n"
                str << line
              end until line =~ /^=end/

              ungetc

              @ltype = nil

              if str =~ /\A=begin\s+rdoc/i
                str.sub!(/\A=begin.*\n/, '')
                str.sub!(/^=end.*/m, '')
                Token(TkCOMMENT).set_text(str)
              else
                Token(TkCOMMENT).set_text(str)
              end
            end

            @OP.def_rule("\n") do
              print "\\n\n" if RubyLex.debug?
              @colonblock_seen = false
              case @lex_state
              when EXPR_BEG, EXPR_FNAME, EXPR_DOT
                @continue = TRUE
              else
                @continue = FALSE
                @lex_state = EXPR_BEG
              end
              Token(TkNL).set_text("\n")
            end

            @OP.def_rules("*", "**",
              "!", "!=", "!~",
              "=", "==", "===",
              "=~", "<=>",
              "<", "<=",
              ">", ">=", ">>") do |op, io|
              @lex_state = EXPR_BEG
              Token(op).set_text(op)
            end

            @OP.def_rules("<<") do |op, io|
              tk = nil
              if @lex_state != EXPR_END && @lex_state != EXPR_CLASS &&
                 (@lex_state != EXPR_ARG || @space_seen)
                c = peek(0)
                tk = identify_here_document if /[-\w_\"\'\`]/ =~ c
              end
              if !tk
                @lex_state = EXPR_BEG
                tk = Token(op).set_text(op)
              end
              tk
            end

            @OP.def_rules("'", '"') do |op, io|
              identify_string(op)
            end

            @OP.def_rules("`") do |op, io|
              if @lex_state == EXPR_FNAME
                Token(op).set_text(op)
              else
                identify_string(op)
              end
            end

            @OP.def_rules('?') do |op, io|
              if @lex_state == EXPR_END
                @lex_state = EXPR_BEG
                Token(TkQUESTION).set_text(op)
              else
                ch = getc
                if @lex_state == EXPR_ARG && ch !~ /\s/
                  ungetc
                  @lex_state = EXPR_BEG
                  Token(TkQUESTION).set_text(op)
                else
                  str = op
                  str << ch
                  if (ch == '\\') #'
                    str << read_escape
                  end
                  @lex_state = EXPR_END
                  Token(TkINTEGER).set_text(str)
                end
              end
            end

            @OP.def_rules("&", "&&", "|", "||") do |op, io|
              @lex_state = EXPR_BEG
              Token(op).set_text(op)
            end

            @OP.def_rules("+=", "-=", "*=", "**=",
              "&=", "|=", "^=", "<<=", ">>=", "||=", "&&=") do |op, io|
              @lex_state = EXPR_BEG
              op =~ /^(.*)=$/
              Token(TkOPASGN, $1).set_text(op)
            end

            @OP.def_rule("+@", proc{@lex_state == EXPR_FNAME}) do |op, io|
              Token(TkUPLUS).set_text(op)
            end

            @OP.def_rule("-@", proc{@lex_state == EXPR_FNAME}) do |op, io|
              Token(TkUMINUS).set_text(op)
            end

            @OP.def_rules("+", "-") do |op, io|
              catch(:RET) do
                if @lex_state == EXPR_ARG
                  if @space_seen and peek(0) =~ /[0-9]/
                    throw :RET, identify_number(op)
                  else
                    @lex_state = EXPR_BEG
                  end
                elsif @lex_state != EXPR_END and peek(0) =~ /[0-9]/
                  throw :RET, identify_number(op)
                else
                  @lex_state = EXPR_BEG
                end
                Token(op).set_text(op)
              end
            end

            @OP.def_rule(".") do
              @lex_state = EXPR_BEG
              if peek(0) =~ /[0-9]/
                ungetc
                identify_number("")
              else
                # for obj.if
                @lex_state = EXPR_DOT
                Token(TkDOT).set_text(".")
              end
            end

            @OP.def_rules("..", "...") do |op, io|
              @lex_state = EXPR_BEG
              Token(op).set_text(op)
            end

            lex_int2
          end