tla-parser-s 0.1.2 → 0.2.2
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- checksums.yaml +4 -4
- data/README.md +1 -1
- data/VERSION +1 -1
- data/lib/parser/lvalue.rb +2 -2
- data/lib/parser/parser.rb +1 -1
- data/lib/parser/parser_nodes.rb +200 -85
- data/lib/parser/parser_sexp.treetop +39 -7
- data/lib/semantics/context.rb +113 -55
- data/lib/semantics/resolver.rb +206 -58
- data/lib/semantics/symbol_table.rb +45 -11
- data/lib/utils/logger.rb +2 -1
- data/spec/fixtures/resolver1/op4.tla +2 -0
- data/spec/fixtures/resolver1/op_let.tla +1 -0
- data/spec/fixtures/resolver1/op_tail_chg.tla +1 -0
- data/spec/fixtures/resolver1/var_rec_expr_add.tla +3 -0
- data/spec/parser/parser_fixtures_spec.rb +4 -4
- data/spec/parser/parser_spec.rb +177 -12
- data/spec/semantics/context_spec.rb +52 -0
- data/spec/semantics/resolver_spec.rb +106 -11
- data/spec/semantics/symbol_table_spec.rb +6 -4
- metadata +6 -2
@@ -1,5 +1,5 @@
|
|
1
1
|
# coding: utf-8
|
2
|
-
grammar
|
2
|
+
grammar SbuilderSexp
|
3
3
|
|
4
4
|
# ------------------------------------------------------------------
|
5
5
|
# Default starting point we will parse TLA+ snippets
|
@@ -12,13 +12,30 @@ end
|
|
12
12
|
# directive
|
13
13
|
|
14
14
|
rule directive
|
15
|
-
invariants / assumptions
|
15
|
+
invariants / assumptions / recursive
|
16
16
|
end
|
17
17
|
|
18
18
|
rule assumptions
|
19
19
|
'ASSUME' space? identifier (assumption* <Assumption> ) <Assumption>
|
20
20
|
end
|
21
21
|
|
22
|
+
rule recursive
|
23
|
+
'RECURSIVE' space* name space* '(' space* place_holder_list? space* ')' <Recursive>
|
24
|
+
end
|
25
|
+
|
26
|
+
rule place_holder
|
27
|
+
'_'
|
28
|
+
end
|
29
|
+
rule place_holder_list
|
30
|
+
place_holder space? place_holder_list_tail?
|
31
|
+
end
|
32
|
+
# Right recursive rule
|
33
|
+
rule place_holder_list_tail
|
34
|
+
',' space* place_holder_list
|
35
|
+
end
|
36
|
+
|
37
|
+
|
38
|
+
|
22
39
|
rule assumption
|
23
40
|
space? identifier <NonTerminal>
|
24
41
|
end
|
@@ -131,7 +148,10 @@ end
|
|
131
148
|
|
132
149
|
|
133
150
|
rule unit_expression
|
134
|
-
sequence_expression / set_expression / set_expression_map / set_constructor / record_expression / operator_expression / quantify_expression / choose_expression
|
151
|
+
sequence_expression / set_expression / set_expression_map / set_constructor / record_expression / operator_expression / quantify_expression / choose_expression
|
152
|
+
/ function_expression
|
153
|
+
/ let_expression
|
154
|
+
/ if_expression
|
135
155
|
/ identifier
|
136
156
|
/ record_self
|
137
157
|
/ original_value
|
@@ -140,9 +160,7 @@ rule unit_expression
|
|
140
160
|
end
|
141
161
|
|
142
162
|
rule unit_expression_tail
|
143
|
-
|
144
|
-
'.' space* identifier space* <FieldByName> / '[' space* unit_expression space* ']' space* <FieldByValue>
|
145
|
-
|
163
|
+
'.' space* identifier space* <FieldByName> / '[' space* expression space* ']' space* <FieldByValue>
|
146
164
|
end
|
147
165
|
|
148
166
|
|
@@ -186,6 +204,10 @@ rule choose_expression
|
|
186
204
|
|
187
205
|
end
|
188
206
|
|
207
|
+
rule let_expression
|
208
|
+
'LET' space* operator space* 'IN' space* expression <LetExpression>
|
209
|
+
end
|
210
|
+
|
189
211
|
rule if_expression
|
190
212
|
'IF' (space* expression <IfExpressionCondition> ) space* 'THEN' (space* expression <IfExpressionThen>) if_expression_else? <IfExpression>
|
191
213
|
end
|
@@ -210,6 +232,10 @@ rule sequence_expression
|
|
210
232
|
'<<' space* expression_list? space* '>>' <SequenceExpression>
|
211
233
|
end
|
212
234
|
|
235
|
+
rule function_expression
|
236
|
+
'[' space* bound_expression space* '|->' space* expression space* ']' <FunctionExpression>
|
237
|
+
end
|
238
|
+
|
213
239
|
rule set_expression_map
|
214
240
|
'{' ( space* expression space* <SetExpressionDef>) ':' ( space* bound_expression <BoundInExpression> ) '}' <SetExpressionMap>
|
215
241
|
|
@@ -242,7 +268,7 @@ end
|
|
242
268
|
# unlabeled statements
|
243
269
|
|
244
270
|
rule unlabeled_statement
|
245
|
-
assignment_statement / compound_statement / either / conditional / macro_call / return_statement / skip / assert / goto / print / call
|
271
|
+
assignment_statement / compound_statement / with_statement / either / conditional / macro_call / return_statement / skip / assert / goto / print / call
|
246
272
|
end
|
247
273
|
|
248
274
|
rule conditional
|
@@ -273,6 +299,10 @@ rule compound_statement_list
|
|
273
299
|
statement ';' <StatementList>
|
274
300
|
end
|
275
301
|
|
302
|
+
rule with_statement
|
303
|
+
'with' space* '(' space* expression space* ')' space* statement <WithStatement>
|
304
|
+
end
|
305
|
+
|
276
306
|
rule goto
|
277
307
|
'goto' space* identifier <Goto>
|
278
308
|
end
|
@@ -372,6 +402,8 @@ end
|
|
372
402
|
rule additive_operator
|
373
403
|
"=>" <Operator> / '#' <Operator> /
|
374
404
|
'<=>' <Operator> /
|
405
|
+
'..' <Operator> /
|
406
|
+
'\o' <Operator> /
|
375
407
|
'>=' <Operator> / '>' <Operator> / '=' <Operator> /
|
376
408
|
'<=' <Operator> / '<' <Operator> /
|
377
409
|
'-' <Operator> / '+' <Operator>
|
data/lib/semantics/context.rb
CHANGED
@@ -27,14 +27,19 @@ module TlaParserS
|
|
27
27
|
extend Forwardable # for easy delegation
|
28
28
|
|
29
29
|
attr_accessor :symbol_table
|
30
|
+
|
31
|
+
attr_reader :options
|
30
32
|
|
31
33
|
def_delegators :symbol_table, :currentContext, :dumpContext,
|
32
|
-
|
34
|
+
:popContext,
|
35
|
+
:entries,
|
36
|
+
:symbols,
|
37
|
+
:resolveModule
|
33
38
|
|
34
39
|
# ------------------------------------------------------------------
|
35
40
|
# Logger
|
36
41
|
|
37
|
-
PROGNAME =
|
42
|
+
PROGNAME = nil # progname for logger default class name
|
38
43
|
include TlaParserS::Utils::MyLogger # mix logger
|
39
44
|
|
40
45
|
# # TLA+ standar library symbols
|
@@ -43,8 +48,11 @@ module TlaParserS
|
|
43
48
|
|
44
49
|
|
45
50
|
# ------------------------------------------------------------------
|
46
|
-
#
|
51
|
+
# @!group Constructor & configs
|
52
|
+
|
47
53
|
def initialize( options={} )
|
54
|
+
|
55
|
+
@options = options
|
48
56
|
|
49
57
|
@logger = getLogger( PROGNAME, options )
|
50
58
|
@logger.info( "#{__method__} initialized" )
|
@@ -52,11 +60,14 @@ module TlaParserS
|
|
52
60
|
initContext
|
53
61
|
end
|
54
62
|
|
63
|
+
# @!endgroup
|
64
|
+
|
55
65
|
# ------------------------------------------------------------------
|
56
|
-
#
|
66
|
+
# @!group Services to initialize
|
67
|
+
|
57
68
|
|
58
69
|
def initContext
|
59
|
-
@symbol_table = SymbolTable.new
|
70
|
+
@symbol_table = SymbolTable.new( options )
|
60
71
|
|
61
72
|
# # create context for standar library && add entries
|
62
73
|
# @symbol_table.pushContext( nil )
|
@@ -73,7 +84,7 @@ module TlaParserS
|
|
73
84
|
return self
|
74
85
|
end
|
75
86
|
|
76
|
-
# Create new context in symbol table && add
|
87
|
+
# Create new context in symbol table && add entries
|
77
88
|
def initEntries( entries )
|
78
89
|
|
79
90
|
return unless entries && entries.any?
|
@@ -83,10 +94,12 @@ module TlaParserS
|
|
83
94
|
|
84
95
|
# add entries
|
85
96
|
entries.each do |entry|
|
86
|
-
|
97
|
+
symbol_table.addEntry( entry )
|
87
98
|
end
|
88
99
|
|
89
100
|
end
|
101
|
+
|
102
|
+
# @!endgroup
|
90
103
|
|
91
104
|
|
92
105
|
# Add more symbols to current context levell
|
@@ -107,37 +120,46 @@ module TlaParserS
|
|
107
120
|
return self
|
108
121
|
end
|
109
122
|
|
110
|
-
|
123
|
+
|
124
|
+
# Locate 'symbol' in context
|
125
|
+
#
|
111
126
|
# @param symbol [String] to resolve
|
127
|
+
#
|
112
128
|
# @return [Hash] with :symbol, :resolved properties
|
113
129
|
def resolveSymbol( symbol )
|
114
130
|
resolved = symbol_table.resolveContext( symbol )
|
115
|
-
return
|
116
|
-
|
117
|
-
|
118
|
-
|
131
|
+
return resolvedSymbol( symbol, resolved );
|
132
|
+
# return {
|
133
|
+
# :symbol => symbol,
|
134
|
+
# :resolved => resolved,
|
135
|
+
# }
|
119
136
|
end
|
120
137
|
|
121
138
|
# ------------------------------------------------------------------
|
122
139
|
# Resolver
|
123
140
|
|
141
|
+
# Resolve symbol table entries in 'stmt'
|
142
|
+
#
|
124
143
|
# @param stmt [Statement] parse tree node for statement to resolve
|
125
144
|
# @return see 'resolveExpression'
|
126
145
|
private def resolveStatement( stmt, ret=[] )
|
127
146
|
|
128
147
|
stmt.traverse(ret) do |ret,node_type, node|
|
129
|
-
@logger.debug( "#{__method__}: enter node_type=#{node_type}, #{node.text_value}ret=#{ret}." )
|
148
|
+
@logger.debug( "#{__method__}: enter node_type=#{node_type}, #{node.text_value}ret=#{ret}." ) if @logger.debug?
|
130
149
|
case node_type
|
131
150
|
when "Statement"
|
132
151
|
when "Skip"
|
133
152
|
when "Return"
|
134
153
|
when "Goto"
|
135
154
|
when "Identifier"
|
136
|
-
@logger.debug( "#{__method__}: Identifier node=#{node.inspect}" )
|
155
|
+
@logger.debug( "#{__method__}: Identifier node=#{node.inspect}" ) if @logger.debug?
|
137
156
|
ret.concat( resolveExpression( node ))
|
157
|
+
when "WithStatement"
|
158
|
+
ret.concat( resolveExpression( node.with_expression ))
|
159
|
+
ret.concat( resolveStatement( node.with_statement, ret ))
|
138
160
|
when "Conditional"
|
139
161
|
ret.concat( resolveExpression( node.condition ))
|
140
|
-
@logger.debug( "#{__method__}: Conditional if_true=#{node.if_true.inspect}" )
|
162
|
+
@logger.debug( "#{__method__}: Conditional if_true=#{node.if_true.inspect}" ) if @logger.debug?
|
141
163
|
ret.concat( resolveStatement( node.if_true, ret ))
|
142
164
|
ret.concat( resolveStatement( node.if_not_true, ret )) if node.if_not_true
|
143
165
|
when "Either"
|
@@ -146,20 +168,20 @@ module TlaParserS
|
|
146
168
|
ret.concat( resolveExpression( node.assertion ))
|
147
169
|
when "Assignment"
|
148
170
|
lvalue = node.lvalue
|
149
|
-
@logger.debug( "#{__method__}: Assignment lvalue=#{lvalue.inspect}" )
|
171
|
+
@logger.debug( "#{__method__}: Assignment lvalue=#{lvalue.inspect}" ) if @logger.debug?
|
150
172
|
ret.concat( resolveExpression( node.lvalue.expression ) )
|
151
173
|
ret.concat( resolveExpression( node.rvalue ))
|
152
174
|
# lvalue = node.lvalue.node_value
|
153
175
|
# @logger.debug( "#{__method__}: Assign lvalue=#{lvalue}" )
|
154
176
|
# # take just first variable
|
155
177
|
# lvalue = lvalue.split( /[.\[]/ ).first
|
156
|
-
# ret <<
|
178
|
+
# ret << resolvedSymbol( lvalue, symbol_table.resolveContext( lvalue ))
|
157
179
|
# # resovel expression
|
158
180
|
# ret.concat( resolveExpression( node.rvalue ))
|
159
181
|
when "Print"
|
160
|
-
@logger.debug( "#{__method__}: Print node=#{node.inspect}" )
|
182
|
+
@logger.debug( "#{__method__}: Print node=#{node.inspect}" ) if @logger.debug?
|
161
183
|
sret = resolveExpression( node.print_expression )
|
162
|
-
@logger.debug( "#{__method__}: Print sret=#{sret}" )
|
184
|
+
@logger.debug( "#{__method__}: Print sret=#{sret}" ) if @logger.debug?
|
163
185
|
ret = ret.concat( sret )
|
164
186
|
when "CompoundStatement"
|
165
187
|
ret = node.statements.each { |s| resolveStatement( s, ret ) }
|
@@ -168,35 +190,40 @@ module TlaParserS
|
|
168
190
|
# ret.concat( sret )
|
169
191
|
when "MacroCall"
|
170
192
|
# resolve macro definition
|
171
|
-
ret <<
|
193
|
+
ret << resolvedSymbol( node.called, symbol_table.resolveContext( node.called ) )
|
172
194
|
# resolve actual parameters
|
173
195
|
node.actual_parameters.each do |expr_node|
|
174
196
|
eret = resolveExpression(expr_node )
|
175
|
-
@logger.debug "actual param eret=#{eret}"
|
197
|
+
@logger.debug "actual param eret=#{eret}" if @logger.debug?
|
176
198
|
ret.concat( eret )
|
177
199
|
end # actual paramtere
|
178
200
|
when "Call"
|
179
201
|
# resolve procedure definition
|
180
|
-
ret <<
|
202
|
+
ret << resolvedSymbol( node.called, symbol_table.resolveContext( node.called ) )
|
181
203
|
# resolve actual parameters
|
182
204
|
ret = node.actual_parameters.each do |expr_node|
|
183
205
|
ret.concat( resolveExpression( expr_node ))
|
184
206
|
end # actual paramtere
|
185
207
|
else
|
186
208
|
msg = "#{__method__}: Unknwon statement node type #{node_type} for node #{node.inspect}"
|
187
|
-
@logger.
|
188
|
-
|
209
|
+
@logger.error "#{__method__}:# {msg} )"
|
210
|
+
raise ContextException, msg
|
189
211
|
end
|
190
|
-
@logger.debug( "#{__method__}: leave node_type=#{node_type} ret=#{ret}." )
|
212
|
+
@logger.debug( "#{__method__}: leave node_type=#{node_type} ret=#{ret}." ) if @logger.debug?
|
191
213
|
ret
|
192
214
|
end
|
193
215
|
ret
|
194
216
|
end # def resolveStatement( stmt )
|
195
217
|
|
196
218
|
|
197
|
-
#
|
219
|
+
# Resolve definitions with body (macro, procedure,operator
|
220
|
+
# definition = callables), and variable definitions.
|
221
|
+
#
|
222
|
+
# @return [Hash:Array] of resolved entries, hash with {:symbol,:resolved} -properties
|
223
|
+
# @see resolveExpression
|
224
|
+
|
198
225
|
def resolveDefine( defineNode )
|
199
|
-
# @logger.debug "resolveDefine starting callable=#{defineNode.inspect}"
|
226
|
+
# @logger.debug "resolveDefine starting callable=#{defineNode.inspect}" if @logger.debug?
|
200
227
|
|
201
228
|
ret = nil
|
202
229
|
pushContext( defineNode )
|
@@ -204,7 +231,7 @@ module TlaParserS
|
|
204
231
|
if defineNode.respond_to?( :body_node ) then
|
205
232
|
# macro, procedure, operatordef
|
206
233
|
@logger.info( "#{__method__} start with resolveStatement for #{defineNode.body_node}" )
|
207
|
-
if defineNode.body_node.is_a?(
|
234
|
+
if defineNode.body_node.is_a?(SbuilderSexp::Expression)
|
208
235
|
# operator
|
209
236
|
ret = resolveExpression( defineNode.body_node )
|
210
237
|
else
|
@@ -227,7 +254,7 @@ module TlaParserS
|
|
227
254
|
elsif defineNode.respond_to?( :init ) then
|
228
255
|
@logger.info( "#{__method__} start with resolveExpression #{defineNode.init}" )
|
229
256
|
ret = resolveExpression( defineNode.init )
|
230
|
-
@logger.debug( "#{__method__} resolveExpression-->#{ret}" )
|
257
|
+
@logger.debug( "#{__method__} resolveExpression-->#{ret}" ) if @logger.debug?
|
231
258
|
else
|
232
259
|
msg = <<-EOS
|
233
260
|
Unknown tree node object #{defineNode}.
|
@@ -244,36 +271,43 @@ module TlaParserS
|
|
244
271
|
end
|
245
272
|
|
246
273
|
|
274
|
+
# Resolve symbol table entries in 'expression'
|
275
|
+
#
|
247
276
|
# @param expression [Expression] parse tree node for exprresion to resolve
|
277
|
+
#
|
248
278
|
# @return [Hash:Array] {:symbol,:resolved} hashes, where :resolved is the result
|
249
279
|
# of symbol table lookup
|
250
280
|
def resolveExpression( expr )
|
251
281
|
|
252
282
|
ret = []
|
253
283
|
expr && expr.traverse do |m, node_type, enode, node_val |
|
254
|
-
@logger.debug( "#{__method__} node_type=#{node_type}, node_val=#{node_val}" )
|
284
|
+
@logger.debug( "#{__method__} node_type=#{node_type}, node_val=#{node_val}" ) if @logger.debug?
|
255
285
|
case node_type
|
256
286
|
when "Identifier"
|
257
|
-
ret <<
|
287
|
+
ret << resolvedSymbol( node_val, symbol_table.resolveContext( node_val ) )
|
258
288
|
when "AdditiveExpression", "MultitiveExpression", "UnaryExpression", "ParenthesisExpression"
|
259
289
|
when "PrimaryExpression"
|
260
290
|
sret = []
|
261
|
-
|
262
|
-
|
291
|
+
# puts "PrimaryExpression: attribute_accessors=#{enode.attribute_accessors.join(',')}"
|
292
|
+
enode.attribute_accessors && enode.attribute_accessors.each do |accessor|
|
293
|
+
sret = sret.concat( resolveExpression( accessor ))
|
263
294
|
end
|
264
295
|
ret = ret.concat( sret )
|
265
296
|
when "FieldByValue"
|
266
|
-
ret <<
|
297
|
+
# ret << resolvedSymbol( node_val, symbol_table.resolveContext( node_val ) )
|
298
|
+
# expr = node.field_value_expression.traverse { |m, node_type, enode, node_val| m.concat( expression_value(node_type, enode, node_val )) }
|
299
|
+
sret = resolveExpression( enode.field_value_expression )
|
300
|
+
ret = ret.concat( sret )
|
267
301
|
when "FieldByName"
|
268
302
|
when "SequenceExpression"
|
269
|
-
@logger.debug( "#{__method__} SequenceExpression: enode=#{enode.inspect}" )
|
303
|
+
@logger.debug( "#{__method__} SequenceExpression: enode=#{enode.inspect}" ) if @logger.debug?
|
270
304
|
sret = []
|
271
305
|
enode.tuples && enode.tuples.each do |tuple_expr|
|
272
306
|
sret = sret.concat( resolveExpression( tuple_expr ))
|
273
307
|
end
|
274
308
|
ret = ret.concat( sret )
|
275
309
|
when "IfExpression"
|
276
|
-
@logger.debug( "#{__method__} IfExpression: enode=#{enode.inspect}" )
|
310
|
+
@logger.debug( "#{__method__} IfExpression: enode=#{enode.inspect}" ) if @logger.debug?
|
277
311
|
sret = resolveExpression( enode.condition_node )
|
278
312
|
ret.concat( sret )
|
279
313
|
@logger.info( "#{__method__} IfExpression: condition-expr=#{sret}" )
|
@@ -285,18 +319,18 @@ module TlaParserS
|
|
285
319
|
ret.concat( sret )
|
286
320
|
@logger.info( "#{__method__} IfExpression: els-expr=#{sret}" )
|
287
321
|
when "ChooseExpression"
|
288
|
-
@logger.debug( "#{__method__} ChooseExpression: enode=#{enode.inspect}" )
|
289
|
-
@logger.debug( "#{__method__} ChooseExpression: enode.binds_node=#{enode.binds_node}" )
|
322
|
+
@logger.debug( "#{__method__} ChooseExpression: enode=#{enode.inspect}" ) if @logger.debug?
|
323
|
+
@logger.debug( "#{__method__} ChooseExpression: enode.binds_node=#{enode.binds_node}" ) if @logger.debug?
|
290
324
|
# bind node defines symbol table
|
291
325
|
pushContext( enode )
|
292
326
|
choose_expression=enode.choose_expression
|
293
|
-
@logger.debug( "#{__method__} ChooseExpression: choose_expression=#{choose_expression.inspect}" )
|
327
|
+
@logger.debug( "#{__method__} ChooseExpression: choose_expression=#{choose_expression.inspect}" ) if @logger.debug?
|
294
328
|
sret = resolveExpression( choose_expression )
|
295
329
|
@logger.info( "#{__method__} ChooseExpression: resolved sret=#{sret.map {|e| { e[:symbol] => e[:resolved] ? e[:resolved][:symbol_type]+':'+e[:resolved][:context] : nil} }}" )
|
296
330
|
ret = ret.concat( sret )
|
297
331
|
popContext()
|
298
332
|
when "RecordDefinition"
|
299
|
-
@logger.debug( "#{__method__} RecordDefinition: enode=#{enode.inspect}" )
|
333
|
+
@logger.debug( "#{__method__} RecordDefinition: enode=#{enode.inspect}" ) if @logger.debug?
|
300
334
|
sret = []
|
301
335
|
enode.record_fields.each do |record_field|
|
302
336
|
sret = sret.concat( resolveExpression( record_field.element_expression ))
|
@@ -306,10 +340,10 @@ module TlaParserS
|
|
306
340
|
when "RecordExcept"
|
307
341
|
# resolve where base expression
|
308
342
|
# id = enode.record_identifier
|
309
|
-
# ret <<
|
343
|
+
# ret << resolvedSymbol( id, symbol_table.resolveContext( id ) )
|
310
344
|
bret = resolveExpression( enode.record_base )
|
311
345
|
ret = ret.concat( bret )
|
312
|
-
@logger.debug( "#{__method__} RecordExcept: record_base -->=#{bret}" )
|
346
|
+
@logger.debug( "#{__method__} RecordExcept: record_base -->=#{bret}" ) if @logger.debug?
|
313
347
|
sret = []
|
314
348
|
# resolve EXCEPT constructor field rvalue expression
|
315
349
|
enode.record_field_definitions && enode.record_field_definitions.each do |field_definition|
|
@@ -323,7 +357,7 @@ module TlaParserS
|
|
323
357
|
end
|
324
358
|
ret = ret.concat( sret )
|
325
359
|
when "SetExpressionMap"
|
326
|
-
@logger.debug( "#{__method__} SetExpressionMap: enode=#{enode.inspect}" )
|
360
|
+
@logger.debug( "#{__method__} SetExpressionMap: enode=#{enode.inspect}" ) if @logger.debug?
|
327
361
|
# resolve set mapped
|
328
362
|
sret = resolveExpression( enode.binds_node.bind_set )
|
329
363
|
ret = ret.concat( sret )
|
@@ -331,38 +365,62 @@ module TlaParserS
|
|
331
365
|
# resolve expression in set map
|
332
366
|
pushContext( enode )
|
333
367
|
sret = resolveExpression( enode.set_expression )
|
334
|
-
@logger.debug( "#{__method__} SetExpressionMap: resolved sret=#{sret}" )
|
368
|
+
@logger.debug( "#{__method__} SetExpressionMap: resolved sret=#{sret}" ) if @logger.debug?
|
369
|
+
ret = ret.concat( sret )
|
370
|
+
when "FunctionExpression"
|
371
|
+
@logger.debug( "#{__method__} FunctionExpression: enode=#{enode.inspect}" ) if @logger.debug?
|
372
|
+
pushContext( enode )
|
373
|
+
sret = resolveExpression( enode.function_expression )
|
335
374
|
ret = ret.concat( sret )
|
375
|
+
popContext( )
|
336
376
|
when "SetExpression"
|
337
|
-
@logger.debug( "#{__method__} SetExpression: enode=#{enode.inspect}" )
|
377
|
+
@logger.debug( "#{__method__} SetExpression: enode=#{enode.inspect}" ) if @logger.debug?
|
338
378
|
pushContext( enode )
|
339
379
|
sret = resolveExpression( enode.set_expression )
|
340
|
-
@logger.debug( "#{__method__} SetExpression: resolved sret=#{sret}" )
|
380
|
+
@logger.debug( "#{__method__} SetExpression: resolved sret=#{sret}" ) if @logger.debug?
|
341
381
|
ret = ret.concat( sret )
|
342
382
|
popContext( )
|
343
383
|
when "OperatorExpression"
|
344
|
-
@logger.debug( "#{__method__} OperatorExpression: enode=#{enode.inspect}" )
|
384
|
+
@logger.debug( "#{__method__} OperatorExpression: enode=#{enode.inspect}" ) if @logger.debug?
|
345
385
|
operator_name = enode.operator_name
|
346
|
-
ret <<
|
386
|
+
ret << resolvedSymbol( operator_name, symbol_table.resolveContext( operator_name ) )
|
347
387
|
sret = []
|
348
388
|
enode.arguments && enode.arguments.each do |argument_node|
|
349
389
|
sret = sret.concat( resolveExpression( argument_node ))
|
350
390
|
end
|
351
391
|
@logger.info( "#{__method__} OperatorExpression: resolved sret=#{sret.map {|e| { e[:symbol] => e[:resolved] ? e[:resolved][:symbol_type]+':'+e[:resolved][:context] : nil} }}" )
|
352
392
|
ret = ret.concat( sret )
|
393
|
+
|
394
|
+
when "LetExpression"
|
395
|
+
@logger.debug( "#{__method__} SetExpression: node.symbol_definitions=#{enode.symbol_definitions}" ) if @logger.debug?
|
396
|
+
|
397
|
+
pushContext( enode )
|
398
|
+
|
399
|
+
# resolve let operator
|
400
|
+
oret = resolveExpression( enode.operatorDef.body_node )
|
401
|
+
@logger.debug( "#{__method__} resolved oret=#{oret}" ) if @logger.debug?
|
402
|
+
ret = ret.concat( oret )
|
403
|
+
|
404
|
+
# resolve let expression
|
405
|
+
eret = resolveExpression( enode.letExpression )
|
406
|
+
@logger.debug( "#{__method__} resolved eret=#{eret}" ) if @logger.debug?
|
407
|
+
ret = ret.concat( eret )
|
408
|
+
|
409
|
+
popContext( )
|
410
|
+
|
353
411
|
|
354
412
|
when "QuantifyExpression"
|
355
413
|
|
356
|
-
@logger.debug( "#{__method__} SetExpression: node.symbol_definitions=#{enode.symbol_definitions}" )
|
414
|
+
@logger.debug( "#{__method__} SetExpression: node.symbol_definitions=#{enode.symbol_definitions}" ) if @logger.debug?
|
357
415
|
pushContext( enode )
|
358
416
|
sret = resolveExpression( enode.binds_nodes.first.bind_set )
|
359
417
|
ret = ret.concat( sret )
|
360
|
-
@logger.debug( "#{__method__} resolved sret=#{sret}" )
|
361
|
-
@logger.debug( "#{__method__} SetExpression: #{enode.quantified_expression.inspect}" )
|
418
|
+
@logger.debug( "#{__method__} resolved sret=#{sret}" ) if @logger.debug?
|
419
|
+
@logger.debug( "#{__method__} SetExpression: #{enode.quantified_expression.inspect}" ) if @logger.debug?
|
362
420
|
qret = resolveExpression( enode.quantified_expression )
|
363
|
-
@logger.debug( "#{__method__} resolved qret=#{qret}" )
|
421
|
+
@logger.debug( "#{__method__} resolved qret=#{qret}" ) if @logger.debug?
|
364
422
|
ret = ret.concat( qret )
|
365
|
-
@logger.debug( "#{__method__} resolved ret=#{ret}" )
|
423
|
+
@logger.debug( "#{__method__} resolved ret=#{ret}" ) if @logger.debug?
|
366
424
|
popContext( )
|
367
425
|
when "IntegerValue", "StringValue", "OriginalValue"
|
368
426
|
else
|
@@ -377,8 +435,8 @@ module TlaParserS
|
|
377
435
|
end # def resolveExpression( expr )
|
378
436
|
|
379
437
|
private
|
380
|
-
# @return
|
381
|
-
def
|
438
|
+
# @return [Hash] with {:symbol,:resolved} -properties
|
439
|
+
def resolvedSymbol( identifier, resolved )
|
382
440
|
{ :symbol => identifier, :resolved => resolved }
|
383
441
|
end
|
384
442
|
|