1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
|
##
# IO
#
# ISO 15.2.20
class IOError < StandardError; end
class EOFError < IOError; end
class IO
def self.open(*args, &block)
io = self.new(*args)
return io unless block
begin
yield io
ensure
begin
io.close unless io.closed?
rescue StandardError
end
end
end
def self.popen(command, mode = 'r', **opts, &block)
if !self.respond_to?(:_popen)
raise NotImplementedError, "popen is not supported on this platform"
end
io = self._popen(command, mode, **opts)
return io unless block
begin
yield io
ensure
begin
io.close unless io.closed?
rescue IOError
# nothing
end
end
end
def self.pipe(&block)
if !self.respond_to?(:_pipe)
raise NotImplementedError, "pipe is not supported on this platform"
end
if block
begin
r, w = IO._pipe
yield r, w
ensure
r.close unless r.closed?
w.close unless w.closed?
end
else
IO._pipe
end
end
def self.read(path, length=nil, offset=0, mode: "r")
str = ""
fd = -1
io = nil
begin
fd = IO.sysopen(path, mode)
io = IO.open(fd, mode)
io.seek(offset) if offset > 0
str = io.read(length)
ensure
if io
io.close
elsif fd != -1
IO._sysclose(fd)
end
end
str
end
def hash
# We must define IO#hash here because IO includes Enumerable and
# Enumerable#hash will call IO#read() otherwise
self.__id__
end
def <<(str)
write(str)
self
end
alias_method :eof, :eof?
alias_method :tell, :pos
def pos=(i)
seek(i, SEEK_SET)
end
def rewind
seek(0, SEEK_SET)
end
def ungetbyte(c)
if c.is_a? String
c = c.getbyte(0)
else
c &= 0xff
end
s = " "
s.setbyte(0,c)
ungetc s
end
# 15.2.20.5.3
def each(&block)
return to_enum unless block
while line = self.gets
block.call(line)
end
self
end
# 15.2.20.5.4
def each_byte(&block)
return to_enum(:each_byte) unless block
while byte = self.getbyte
block.call(byte)
end
self
end
# 15.2.20.5.5
alias each_line each
def each_char(&block)
return to_enum(:each_char) unless block
while char = self.getc
block.call(char)
end
self
end
def puts(*args)
i = 0
len = args.size
if len == 0
write "\n"
return
end
while i < len
s = args[i]
if s.kind_of?(Array)
puts(*s) if s.size > 0
else
s = s.to_s
write s
write "\n" if (s[-1] != "\n")
end
i += 1
end
nil
end
def print(*args)
i = 0
len = args.size
while i < len
write args[i].to_s
i += 1
end
end
def printf(*args)
write sprintf(*args)
nil
end
alias_method :to_i, :fileno
alias_method :tty?, :isatty
end
STDIN = IO.open(0, "r")
STDOUT = IO.open(1, "w")
STDERR = IO.open(2, "w")
$stdin = STDIN
$stdout = STDOUT
$stderr = STDERR
|
