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
|
module CodeRay
module Scanners
class RuleBasedScanner < Scanner
Groups = Struct.new :token_kinds
Kind = Struct.new :token_kind
Push = Struct.new :state
Pop = Class.new
PushState = Struct.new :state
PopState = Class.new
Check = Struct.new :condition
CheckIf = Class.new Check
CheckUnless = Class.new Check
ValueSetter = Struct.new :targets, :value
Continue = Class.new
class << self
attr_accessor :states
def state *names, &block
@code ||= ""
@code << "when #{names.map(&:inspect).join(', ')}\n"
@first = true
instance_eval(&block)
@code << " else\n"
# @code << " raise 'no match for #{names.map(&:inspect).join(', ')}'\n"
@code << " encoder.text_token getch, :error\n"
@code << " end\n"
@code << " \n"
end
def on? pattern
pattern_expression = pattern.inspect
@code << " #{'els' unless @first}if check(#{pattern_expression})\n"
@first = true
yield
@code << " end\n"
@first = false
end
def on *pattern_and_actions
if index = pattern_and_actions.find_index { |item| !item.is_a?(Check) }
preconditions = pattern_and_actions[0..index - 1] if index > 0
pattern = pattern_and_actions[index] or raise 'I need a pattern!'
actions = pattern_and_actions[index + 1..-1] or raise 'I need actions!'
end
precondition_expression = ''
if preconditions
for precondition in preconditions
case precondition
when CheckIf
case precondition.condition
when Proc
precondition_expression << "#{make_callback(precondition.condition)} && "
when Symbol
precondition_expression << "#{precondition.condition} && "
else
raise "I don't know how to evaluate this check_if precondition: %p" % [precondition.condition]
end
when CheckUnless
case precondition.condition
when Proc
precondition_expression << "!#{make_callback(precondition.condition)} && "
when Symbol
precondition_expression << "!#{precondition.condition} && "
else
raise "I don't know how to evaluate this check_unless precondition: %p" % [precondition.condition]
end
else
raise "I don't know how to evaluate this precondition: %p" % [precondition]
end
end
end
case pattern
when String
raise
pattern_expression = pattern
when Regexp
pattern_expression = pattern.inspect
when Proc
pattern_expression = make_callback(pattern)
else
raise "I don't know how to evaluate this pattern: %p" % [pattern]
end
@code << " #{'els' unless @first}if #{precondition_expression}match = scan(#{pattern_expression})\n"
for action in actions
case action
when String
raise
@code << " p 'evaluate #{action.inspect}'\n" if $DEBUG
@code << " #{action}\n"
when Symbol
@code << " p 'text_token %p %p' % [match, #{action.inspect}]\n" if $DEBUG
@code << " encoder.text_token match, #{action.inspect}\n"
when Kind
case action.token_kind
when Proc
@code << " encoder.text_token match, kind = #{make_callback(action.token_kind)}\n"
else
raise "I don't know how to evaluate this kind: %p" % [action.token_kind]
end
when Groups
@code << " p 'text_tokens %p in groups %p' % [match, #{action.token_kinds.inspect}]\n" if $DEBUG
action.token_kinds.each_with_index do |kind, i|
@code << " encoder.text_token self[#{i + 1}], #{kind.inspect} if self[#{i + 1}]\n"
end
when Push, PushState
case action.state
when String
raise
@code << " p 'push %p' % [#{action.state}]\n" if $DEBUG
@code << " state = #{action.state}\n"
when Symbol
@code << " p 'push %p' % [#{action.state.inspect}]\n" if $DEBUG
@code << " state = #{action.state.inspect}\n"
when Proc
@code << " state = #{make_callback(action.state)}\n"
else
raise "I don't know how to evaluate this push state: %p" % [action.state]
end
@code << " states << state\n"
@code << " encoder.begin_group state\n" if action.is_a? Push
when Pop, PopState
@code << " p 'pop %p' % [states.last]\n" if $DEBUG
if action.is_a? Pop
@code << " encoder.end_group states.pop\n"
else
@code << " states.pop\n"
end
@code << " state = states.last\n"
when ValueSetter
case action.value
when Proc
@code << " #{action.targets.join(' = ')} = #{make_callback(action.value)}\n"
when Symbol
@code << " #{action.targets.join(' = ')} = #{action.value}\n"
else
@code << " #{action.targets.join(' = ')} = #{action.value.inspect}\n"
end
when Proc
@code << " #{make_callback(action)}\n"
when Continue
@code << " next\n"
else
raise "I don't know how to evaluate this action: %p" % [action]
end
end
@first = false
end
def groups *token_kinds
Groups.new token_kinds
end
def kind token_kind = nil, &block
Kind.new token_kind || block
end
def push state = nil, &block
raise 'push requires a state or a block; got nothing' unless state || block
Push.new state || block
end
def pop
Pop.new
end
def push_state state = nil, &block
raise 'push_state requires a state or a block; got nothing' unless state || block
PushState.new state || block
end
def pop_state
PopState.new
end
def check_if value = nil, &callback
CheckIf.new value || callback
end
def check_unless value = nil, &callback
CheckUnless.new value || callback
end
def flag_on *flags
ValueSetter.new Array(flags), true
end
def flag_off *flags
ValueSetter.new Array(flags), false
end
def set flag, value = nil, &callback
ValueSetter.new [flag], value || callback
end
def unset *flags
ValueSetter.new Array(flags), nil
end
def continue
Continue.new
end
protected
def make_callback block
@callbacks ||= {}
base_name = "__callback_line_#{block.source_location.last}"
name = base_name
counter = 'a'
while @callbacks.key?(name)
name = "#{base_name}_#{counter}"
counter.succ!
end
@callbacks[name] = define_method(name, &block)
arguments = block.parameters.map(&:last)
if arguments.empty?
name
else
"#{name}(#{arguments.join(', ')})"
end
end
end
end
end
end
|
