-
Notifications
You must be signed in to change notification settings - Fork 610
/
sexp_processor.rb
413 lines (324 loc) · 10.1 KB
/
sexp_processor.rb
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
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
############################################################
# This file is imported from a different project.
# DO NOT make modifications in this repo.
# File a patch instead and assign it to Ryan Davis
############################################################
$TESTING = false unless defined? $TESTING
require 'sexp'
##
# SexpProcessor provides a uniform interface to process Sexps.
#
# In order to create your own SexpProcessor subclass you'll need
# to call super in the initialize method, then set any of the
# Sexp flags you want to be different from the defaults.
#
# SexpProcessor uses a Sexp's type to determine which process method
# to call in the subclass. For Sexp <code>s(:lit, 1)</code>
# SexpProcessor will call #process_lit, if it is defined.
#
# You can also specify a default method to call for any Sexp types
# without a process_<type> method or use the default processor provided to
# skip over them.
#
# Here is a simple example:
#
# class MyProcessor < SexpProcessor
# def initialize
# super
# self.strict = false
# end
#
# def process_lit(exp)
# val = exp.shift
# return val
# end
# end
class SexpProcessor
VERSION = '3.0.0'
##
# Automatically shifts off the Sexp type before handing the
# Sexp to process_<type>
attr_accessor :auto_shift_type
##
# Return a stack of contexts. Most recent node is first.
attr_reader :context
##
# A Hash of Sexp types and Regexp.
#
# Print a debug message if the Sexp type matches the Hash key
# and the Sexp's #inspect output matches the Regexp.
attr_accessor :debug
##
# A default method to call if a process_<type> method is not found
# for the Sexp type.
attr_accessor :default_method
##
# Expected result class
attr_accessor :expected
##
# Raise an exception if the Sexp is not empty after processing
attr_accessor :require_empty
##
# Raise an exception if no process_<type> method is found for a Sexp.
attr_accessor :strict
##
# An array that specifies node types that are unsupported by this
# processor. SexpProcessor will raise UnsupportedNodeError if you try
# to process one of those node types.
attr_accessor :unsupported
##
# Emit a warning when the method in #default_method is called.
attr_accessor :warn_on_default
##
# A scoped environment to make you happy.
attr_reader :env
##
# Creates a new SexpProcessor. Use super to invoke this
# initializer from SexpProcessor subclasses, then use the
# attributes above to customize the functionality of the
# SexpProcessor
def initialize
@default_method = nil
@warn_on_default = true
@auto_shift_type = false
@strict = false
@unsupported = [:alloca, :cfunc, :cref, :ifunc, :last, :memo,
:newline, :opt_n, :method]
@unsupported_checked = false
@debug = {}
@expected = Sexp
@require_empty = true
@exceptions = {}
# we do this on an instance basis so we can subclass it for
# different processors.
@processors = {}
@rewriters = {}
@context = []
public_methods.each do |name|
case name
when /^process_(.*)/ then
@processors[$1.intern] = name.intern
when /^rewrite_(.*)/ then
@rewriters[$1.intern] = name.intern
end
end
end
def assert_empty(meth, exp, exp_orig)
unless exp.empty? then
msg = "exp not empty after #{self.class}.#{meth} on #{exp.inspect}"
msg += " from #{exp_orig.inspect}" if $DEBUG
raise NotEmptyError, msg
end
end
def rewrite(exp)
type = exp.first
self.context.unshift type
exp.map! { |sub| Array === sub ? rewrite(sub) : sub }
self.context.shift
begin
meth = @rewriters[type]
exp = self.send(meth, exp) if meth
break unless Sexp === exp
old_type, type = type, exp.first
end until old_type == type
exp
end
##
# Default Sexp processor. Invokes process_<type> methods matching
# the Sexp type given. Performs additional checks as specified by
# the initializer.
def process(exp)
return nil if exp.nil?
exp = self.rewrite(exp) if self.context.empty?
unless @unsupported_checked then
m = public_methods.grep(/^process_/) { |o| o.to_s.sub(/^process_/, '').intern }
supported = m - (m - @unsupported)
raise UnsupportedNodeError, "#{supported.inspect} shouldn't be in @unsupported" unless supported.empty?
@unsupported_checked = true
end
result = self.expected.new
type = exp.first
raise "type should be a Symbol, not: #{exp.first.inspect}" unless
Symbol === type
self.context.unshift type
if @debug.has_key? type then
str = exp.inspect
puts "// DEBUG: #{str}" if str =~ @debug[type]
end
exp_orig = nil
exp_orig = exp.deep_clone if $DEBUG or
@debug.has_key? type or @exceptions.has_key?(type)
raise UnsupportedNodeError, "'#{type}' is not a supported node type" if
@unsupported.include? type
if @debug.has_key? type then
str = exp.inspect
puts "// DEBUG (rewritten): #{str}" if str =~ @debug[type]
end
# now do a pass with the real processor (or generic)
meth = @processors[type] || @default_method
if meth then
if @warn_on_default and meth == @default_method then
warn "WARNING: Using default method #{meth} for #{type}"
end
exp.shift if @auto_shift_type and meth != @default_method
result = error_handler(type, exp_orig) do
self.send(meth, exp)
end
raise SexpTypeError, "Result must be a #{@expected}, was #{result.class}:#{result.inspect}" unless @expected === result
self.assert_empty(meth, exp, exp_orig) if @require_empty
else
unless @strict then
until exp.empty? do
sub_exp = exp.shift
sub_result = nil
if Array === sub_exp then
sub_result = error_handler(type, exp_orig) do
process(sub_exp)
end
raise "Result is a bad type" unless Array === sub_exp
raise "Result does not have a type in front: #{sub_exp.inspect}" unless Symbol === sub_exp.first unless sub_exp.empty?
else
sub_result = sub_exp
end
result << sub_result
end
# NOTE: this is costly, but we are in the generic processor
# so we shouldn't hit it too much with RubyToC stuff at least.
#if Sexp === exp and not exp.sexp_type.nil? then
begin
result.sexp_type = exp.sexp_type
rescue Exception
# nothing to do, on purpose
end
else
msg = "Bug! Unknown node-type #{type.inspect} to #{self.class}"
msg += " in #{exp_orig.inspect} from #{caller.inspect}" if $DEBUG
raise UnknownNodeError, msg
end
end
self.context.shift
result
end
##
# Raises unless the Sexp type for +list+ matches +typ+
def assert_type(list, typ)
raise SexpTypeError, "Expected type #{typ.inspect} in #{list.inspect}" if
not Array === list or list.first != typ
end
def error_handler(type, exp=nil) # :nodoc:
begin
return yield
rescue StandardError => err
if @exceptions.has_key? type then
return @exceptions[type].call(self, exp, err)
else
warn "#{err.class} Exception thrown while processing #{type} for sexp #{exp.inspect} #{caller.inspect}" if $DEBUG
raise
end
end
end
##
# Registers an error handler for +node+
def on_error_in(node_type, &block)
@exceptions[node_type] = block
end
##
# A fairly generic processor for a dummy node. Dummy nodes are used
# when your processor is doing a complicated rewrite that replaces
# the current sexp with multiple sexps.
#
# Bogus Example:
#
# def process_something(exp)
# return s(:dummy, process(exp), s(:extra, 42))
# end
def process_dummy(exp)
result = @expected.new(:dummy) rescue @expected.new
until exp.empty? do
result << self.process(exp.shift)
end
result
end
##
# Add a scope level to the current env. Eg:
#
# def process_defn exp
# name = exp.shift
# args = process(exp.shift)
# scope do
# body = process(exp.shift)
# # ...
# end
# end
#
# env[:x] = 42
# scope do
# env[:x] # => 42
# env[:y] = 24
# end
# env[:y] # => nil
def scope &block
env.scope(&block)
end
##
# I really hate this here, but I hate subdirs in my lib dir more...
# I guess it is kinda like shaving... I'll split this out when it
# itches too much...
class Environment
def initialize
@env = []
@env.unshift({})
end
def all
@env.reverse.inject { |env, scope| env.merge scope }
end
def depth
@env.length
end
# TODO: depth_of
def [] name
hash = @env.find { |closure| closure.has_key? name }
hash[name] if hash
end
def []= name, val
hash = @env.find { |closure| closure.has_key? name } || @env.first
hash[name] = val
end
def scope
@env.unshift({})
begin
yield
ensure
@env.shift
raise "You went too far unextending env" if @env.empty?
end
end
end
end
class Object
##
# deep_clone is the usual Marshalling hack to make a deep copy.
# It is rather slow, so use it sparingly. Helps with debugging
# SexpProcessors since you usually shift off sexps.
def deep_clone
Marshal.load(Marshal.dump(self))
end
end
##
# SexpProcessor base exception class.
class SexpProcessorError < StandardError; end
##
# Raised by SexpProcessor if it sees a node type listed in its
# unsupported list.
class UnsupportedNodeError < SexpProcessorError; end
##
# Raised by SexpProcessor if it is in strict mode and sees a node for
# which there is no processor available.
class UnknownNodeError < SexpProcessorError; end
##
# Raised by SexpProcessor if a processor did not process every node in
# a sexp and @require_empty is true.
class NotEmptyError < SexpProcessorError; end
##
# Raised if assert_type encounters an unexpected sexp type.
class SexpTypeError < SexpProcessorError; end