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.
@@ -1,5 +1,5 @@
1
1
  # coding: utf-8
2
- grammar Sexp
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 / if_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>
@@ -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
- :popContext, :entries, :resolveModule
34
+ :popContext,
35
+ :entries,
36
+ :symbols,
37
+ :resolveModule
33
38
 
34
39
  # ------------------------------------------------------------------
35
40
  # Logger
36
41
 
37
- PROGNAME = "context" # progname for logger
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
- # constructore
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
- # manage context
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 etnries
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
- @symbol_table.addEntry( entry )
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
- :symbol => symbol,
117
- :resolved => resolved,
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 << resolvedIdentifier( lvalue, symbol_table.resolveContext( lvalue ))
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 << resolvedIdentifier( node.called, symbol_table.resolveContext( node.called ) )
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 << resolvedIdentifier( node.called, symbol_table.resolveContext( node.called ) )
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.warn( msg )
188
- warn msg
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
- # @return see 'resolveStatement'
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?(Sexp::Expression)
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 << resolvedIdentifier( node_val, symbol_table.resolveContext( node_val ) )
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
- enode.attribute_accessors && enode.attribute_accessors.each do |identifier|
262
- sret = sret.concat( resolveExpression( identifier ))
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 << resolvedIdentifier( node_val, symbol_table.resolveContext( node_val ) )
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 << resolvedIdentifier( id, symbol_table.resolveContext( id ) )
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 << resolvedIdentifier( operator_name, symbol_table.resolveContext( operator_name ) )
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 {Hash} with {:sybol,:resolved} -properties
381
- def resolvedIdentifier( identifier, resolved )
438
+ # @return [Hash] with {:symbol,:resolved} -properties
439
+ def resolvedSymbol( identifier, resolved )
382
440
  { :symbol => identifier, :resolved => resolved }
383
441
  end
384
442