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
require 'ripper/core'
require 'ripper/lexer'
require 'ripper/filter'
require 'ripper/sexp'

# Ripper is a Ruby script parser.
#
# You can get information from the parser with event-based style.
# Information such as abstract syntax trees or simple lexical analysis of the
# Ruby program.
#
# == Usage
#
# Ripper provides an easy interface for parsing your program into a symbolic
# expression tree (or S-expression).
#
# Understanding the output of the parser may come as a challenge, it's
# recommended you use PP to format the output for legibility.
#
#   require 'ripper'
#   require 'pp'
#
#   pp Ripper.sexp('def hello(world) "Hello, #{world}!"; end')
#     #=> [:program,
#          [[:def,
#            [:@ident, "hello", [1, 4]],
#            [:paren,
#             [:params, [[:@ident, "world", [1, 10]]], nil, nil, nil, nil, nil, nil]],
#            [:bodystmt,
#             [[:string_literal,
#               [:string_content,
#                [:@tstring_content, "Hello, ", [1, 18]],
#                [:string_embexpr, [[:var_ref, [:@ident, "world", [1, 27]]]]],
#                [:@tstring_content, "!", [1, 33]]]]],
#             nil,
#             nil,
#             nil]]]]
#
# You can see in the example above, the expression starts with +:program+.
#
# From here, a method definition at +:def+, followed by the method's identifier
# <code>:@ident</code>. After the method's identifier comes the parentheses
# +:paren+ and the method parameters under +:params+.
#
# Next is the method body, starting at +:bodystmt+ (+stmt+ meaning statement),
# which contains the full definition of the method.
#
# In our case, we're simply returning a String, so next we have the
# +:string_literal+ expression.
#
# Within our +:string_literal+ you'll notice two <code>@tstring_content</code>,
# this is the literal part for <code>Hello, </code> and <code>!</code>. Between
# the two <code>@tstring_content</code> statements is a +:string_embexpr+,
# where _embexpr_ is an embedded expression. Our expression consists of a local
# variable, or +var_ref+, with the identifier (<code>@ident</code>) of +world+.
#
# == Resources
#
# * {Ruby Inside}[http://www.rubyinside.com/using-ripper-to-see-how-ruby-is-parsing-your-code-5270.html]
#
# == Requirements
#
# * ruby 1.9 (support CVS HEAD only)
# * bison 1.28 or later (Other yaccs do not work)
#
# == License
#
# Ruby License.
#
# - Minero Aoki
# - aamine@loveruby.net
# - http://i.loveruby.net
class Ripper; end