0UT1S's

opt/alt/ruby26/lib64/ruby/2.6.0/

By Order of Mr.0UT1S

N/A

N/A

N/A

N/A

N/A

N/A

N/A

N/A

[DIR] fileutils

N/A

[DIR] forwardable

N/A

N/A

N/A

N/A

N/A

N/A

N/A

N/A

N/A

N/A

N/A

N/A

N/A

N/A

N/A

N/A

N/A

N/A

N/A

N/A

[DIR] unicode_normalize

N/A

N/A

N/A

[DIR] x86_64-linux

N/A

N/A

6.31 KB

3.49 KB

3.30 KB

18.07 KB

179 bytes

17.82 KB

9.80 KB

9.49 KB

368 bytes

52.00 KB

1.01 KB

29.97 KB

10.44 KB

2.83 KB

50 bytes

3.94 KB

28.73 KB

2.17 KB

1.68 KB

47.16 KB

2.47 KB

8.49 KB

15.42 KB

19.56 KB

22.53 KB

1.77 KB

5.77 KB

23.47 KB

60.17 KB

84.87 KB

7.87 KB

2.16 KB

5.83 KB

25.13 KB

21.81 KB

469 bytes

optionparser.rb

59 bytes

57.74 KB

10.65 KB

16.17 KB

15.08 KB

15.89 KB

12.37 KB

235 bytes

4.54 KB

14.70 KB

21.11 KB

4.88 KB

resolv-replace.rb

1.76 KB

73.44 KB

2.44 KB

2.87 KB

36.11 KB

23.55 KB

securerandom.rb

8.98 KB

24.07 KB

11.39 KB

6.66 KB

4.04 KB

43.51 KB

7.23 KB

11.21 KB

3.33 KB

23.56 KB

3.81 KB

4.25 KB

6.42 KB

14.30 KB

9.95 KB

3.12 KB

1.44 KB

6.72 KB

1.81 KB

# frozen_string_literal: true
$expect_verbose = false

# Expect library adds the IO instance method #expect, which does similar act to
# tcl's expect extension.
#
# In order to use this method, you must require expect:
#
#   require 'expect'
#
# Please see #expect for usage.
class IO
  # call-seq:
  #   IO#expect(pattern,timeout=9999999)                  ->  Array
  #   IO#expect(pattern,timeout=9999999) { |result| ... } ->  nil
  #
  # Reads from the IO until the given +pattern+ matches or the +timeout+ is over.
  #
  # It returns an array with the read buffer, followed by the matches.
  # If a block is given, the result is yielded to the block and returns nil.
  #
  # When called without a block, it waits until the input that matches the
  # given +pattern+ is obtained from the IO or the time specified as the
  # timeout passes. An array is returned when the pattern is obtained from the
  # IO. The first element of the array is the entire string obtained from the
  # IO until the pattern matches, followed by elements indicating which the
  # pattern which matched to the anchor in the regular expression.
  #
  # The optional timeout parameter defines, in seconds, the total time to wait
  # for the pattern.  If the timeout expires or eof is found, nil is returned
  # or yielded.  However, the buffer in a timeout session is kept for the next
  # expect call.  The default timeout is 9999999 seconds.
  def expect(pat,timeout=9999999)
    buf = ''.dup
    case pat
    when String
      e_pat = Regexp.new(Regexp.quote(pat))
    when Regexp
      e_pat = pat
    else
      raise TypeError, "unsupported pattern class: #{pat.class}"
    end
    @unusedBuf ||= ''
    while true
      if not @unusedBuf.empty?
        c = @unusedBuf.slice!(0)
      elsif !IO.select([self],nil,nil,timeout) or eof? then
        result = nil
        @unusedBuf = buf
        break
      else
        c = getc
      end
      buf << c
      if $expect_verbose
        STDOUT.print c
        STDOUT.flush
      end
      if mat=e_pat.match(buf) then
        result = [buf,*mat.captures]
        break
      end
    end
    if block_given? then
      yield result
    else
      return result
    end
    nil
  end
end