tla-parser-s 0.1.2 → 0.2.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: f9d948ffca5a15da6675b14f14e17e5181615d2b
-  data.tar.gz: cbbb074f624f0afbc29a579bb0fe7a4afa5d3c9d
+  metadata.gz: 3e456bcc271a0ec3f6a7b5f71112eb11b33ae320
+  data.tar.gz: b4dfe0d536c58a28f9963c149d350e291583dfdd
 SHA512:
-  metadata.gz: 502e237ae5b32370fbfe1df73231fb90f56f7659a3af762442764d6f8e7de1ae6fa578a3872379f394ecdb549aaceb5f19f345a426b81b312f422bd763c766d6
-  data.tar.gz: f54fe71c01a2f878f322afe41c79ac1a621ecc92b599e8359c80032d48e5fadae43c1d89da9faa9bb8b10c794028669314a020487b4f8c58c971e883f7deedda
+  metadata.gz: 8401edf952eedba3bfc76ae0a08ffbab159dbd90481c82d48de19123bb90a9167369d01d624d16c63ed7c43956371f18ca182e9aedcfdf657ea5dab2a67f9bdf
+  data.tar.gz: c2e9d8063ef23e14c45f430568281f58e10b3eb6c72af478cb420828ca3eceb4443faa21e6ed0e312a012233149e3e2f0d35ad2a478ad9be22b76b171ba83eba

data/README.md

@@ -2,7 +2,7 @@
 [Up](../index.php) [Readme](README.html) [Releases](RELEASES.html) [Todo](TODO.html)
 
 
-# tla-parser-s - TLA+ language parser (for tla-sbuilder) - $Release:0.1.2$
+# tla-parser-s - TLA+ language parser (for tla-sbuilder) - $Release:0.2.2$
 
 A Ruby library for parsing
 [TLA+ language](http://research.microsoft.com/en-us/um/people/lamport/tla/book.html).

data/VERSION

@@ -1 +1 @@
-0.1.2
+0.2.2

data/lib/parser/lvalue.rb

@@ -28,9 +28,9 @@ module TlaParserS
 
     # @return [String] lvalue
     def lvalue
-      # n = recursive_select( Sexp::Root ).first
+      # n = recursive_select( SbuilderSexp::Root ).first
       # return nil unless n
-      recursive_select( Sexp::Identifier ).first.node_value
+      recursive_select( SbuilderSexp::Identifier ).first.node_value
     end
     
 

data/lib/parser/parser.rb

@@ -53,7 +53,7 @@ module TlaParserS
       parser_path = File.join( base_path, 'parser_sexp.treetop')
       @logger.info( "#{__method__} loading parser from parser path #{parser_path}" )
       Treetop.load( parser_path)
-      @@parser = SexpParser.new
+      @@parser = SbuilderSexpParser.new
       @@parser 
     end
 

data/lib/parser/parser_nodes.rb

@@ -1,6 +1,6 @@
 require_relative 'lvalue'
 
-module Sexp
+module SbuilderSexp
 
   # ------------------------------------------------------------------
   # Abstract
@@ -32,7 +32,7 @@ module Sexp
 
     # @return [Directive:array] of parses' tree nodes
     def directives
-      recursive_select( Sexp::Directive )
+      recursive_select( SbuilderSexp::Directive )
     end
     
     def directive_definitions
@@ -41,18 +41,18 @@ module Sexp
     
     # @return [Callable:array] of 'Callable' tree nodes
     def callables
-      recursive_select( Sexp::Callable )
+      recursive_select( SbuilderSexp::Callable )
     end
     
     # @return [array] of 'Define' tree nodes
     def defines
-      recursive_select( Sexp::Define )
+      recursive_select( SbuilderSexp::Define )
     end
 
     # Snippets is main level parse target, and it adds to symbol table
     # base context entries for 'Define' nodes
     # 
-    # @return [Array] of hash with ':node_type', :value properties
+    # @return [Array] of hash with {:node_type, :value, :tree }
     # 
     def symbol_definitions
       defines.map { |c| { :node_type => c.node_type, :value => c.name, :tree => c } }
@@ -66,7 +66,7 @@ module Sexp
   class IdentifierList <Root
 
     def identifier_nodes
-      recursive_select( Sexp::Identifier)
+      recursive_select( SbuilderSexp::Identifier)
     end
     def identifiers
       identifier_nodes.map{ |r| r.value }
@@ -82,7 +82,7 @@ module Sexp
 
   class ProcVariables <IdentifierList
     def identifier_nodes
-      recursive_select( Sexp::VariableDef).first.recursive_select( Sexp::Identifier )
+      recursive_select( SbuilderSexp::VariableDef).first.recursive_select( SbuilderSexp::Identifier )
     end
     
   end
@@ -105,8 +105,8 @@ module Sexp
 
     # @return [AbstractExpression] sub expressions in a binary tree
     def expressions
-      # expressions = recursive_select( Sexp::AbstactExpression )
-      expressions = elements && elements.select { |e| e.is_a?( Sexp::AbstactExpression ) }
+      # expressions = recursive_select( SbuilderSexp::AbstactExpression )
+      expressions = elements && elements.select { |e| e.is_a?( SbuilderSexp::AbstactExpression ) }
       # raise "Parser error - compound expression should build binary tree" if expressions && expressios.length >2
             
     end
@@ -171,7 +171,7 @@ module Sexp
     # @return [String] operator to use (nil if no rhs, else rhs.operator)
     def operator 
       return nil if !has_rhs
-      rhs_operators = expressions[1].recursive_select( Sexp::Operator )
+      rhs_operators = expressions[1].recursive_select( SbuilderSexp::Operator )
       return rhs_operators && rhs_operators.any? && rhs_operators.first.node_value
     end
 
@@ -183,8 +183,8 @@ module Sexp
     # to UnitExpressions, instead yield block iterates using 'attribute_accessors'
     
     def expressions
-      # expressions = recursive_select( Sexp::AbstactExpression )
-      super.select { |e| !e.is_a?(Sexp::UnitExpression) }
+      # expressions = recursive_select( SbuilderSexp::AbstactExpression )
+      super.select { |e| !e.is_a?(SbuilderSexp::UnitExpression) }
     end
 
     # AbstactExpression.travers yield if non-nil
@@ -195,16 +195,16 @@ module Sexp
     # Access record by field name  or by value
     # @return [AbstactExpression:Array] to acccess record fields
     def attribute_accessors
-      deffi = elements.select{ |e| e.is_a?( Sexp::UnitExpression )}.first
+      deffi = elements.select{ |e| e.is_a?( SbuilderSexp::UnitExpression )}.first
       return unless deffi && !deffi.text_value.empty?
-      deffi = deffi.recursive_select( Sexp::AbstactExpression )
+      deffi = deffi.recursive_select( SbuilderSexp::AbstactExpression )
       return deffi
     end
 
 
     # @return [boolean] true if expression defines record accessor
     def has_attribute_accessors
-      attribute_accessors && attribute_accessors.any?
+      attribute_accessors && attribute_accessors.any?      
     end
 
   end
@@ -222,21 +222,21 @@ module Sexp
 
     # @return [AbstactExpression] for the LValue
     def expression
-      recursive_select( Sexp::AbstactExpression).first
+      recursive_select( SbuilderSexp::AbstactExpression).first
     end
 
     # implements lvalue
     include TlaParserS::LValue
 
     # Implement traverse down for 'recurse_lvalue'. In my case recurse
-    # 'Sexp::UnitExpression', which define record access by value or by name
+    # 'SbuilderSexp::UnitExpression', which define record access by value or by name
     #
     # @return [nil|RecordField] down next level in hierarchy
     def lvalue_down
-      down = recursive_select( Sexp::UnitExpression ).first
-      # down = recursive_select( Sexp::RecordField ).first
+      down = recursive_select( SbuilderSexp::UnitExpression ).first
+      # down = recursive_select( SbuilderSexp::RecordField ).first
       # return nil unless down
-      # down.recursive_select( Sexp::RecordField ).first
+      # down.recursive_select( SbuilderSexp::RecordField ).first
     end
     
   end
@@ -251,7 +251,7 @@ module Sexp
     # @return [nil|AbstractExpression] down next level in hierarchy
     
     def lvalue_down
-      down = recursive_select( Sexp::AbstactExpression ).first
+      down = recursive_select( SbuilderSexp::AbstactExpression ).first
     end
     
     
@@ -266,15 +266,15 @@ module Sexp
     end
 
     def operator_name
-      recursive_select( Sexp::Identifier ).first.node_value      
+      recursive_select( SbuilderSexp::Identifier ).first.node_value      
     end
     # @return [Expression:Array] list or arguments
     def arguments
-      recursive_select( Sexp::Expression )
+      recursive_select( SbuilderSexp::Expression )
     end
 
     def record_field_node
-      recursive_select( Sexp::RecordField ).first
+      recursive_select( SbuilderSexp::RecordField ).first
     end
     def record_field
       node = record_field_node
@@ -297,7 +297,7 @@ module Sexp
     end
 
     def operator_node
-      recursive_select( Sexp::Operator ).first
+      recursive_select( SbuilderSexp::Operator ).first
     end
     def operator
       operator_node.text_value
@@ -334,18 +334,18 @@ module Sexp
     # Node for condition
     # @return [Expression] for IF condition
     def condition_node
-      recursive_select( Sexp::IfExpressionCondition ).first.recursive_select(Sexp::Expression).first
+      recursive_select( SbuilderSexp::IfExpressionCondition ).first.recursive_select(SbuilderSexp::Expression).first
     end
 
     # @return [Expression] for THEN expression
     def then_expression_node
-      recursive_select( Sexp::IfExpressionThen ).first.recursive_select(Sexp::Expression).first       end
+      recursive_select( SbuilderSexp::IfExpressionThen ).first.recursive_select(SbuilderSexp::Expression).first       end
 
     # @return [Expression] for ELSE expression    
     def else_expression_node
-      tree_node = recursive_select( Sexp::IfExpressionElse ).first
+      tree_node = recursive_select( SbuilderSexp::IfExpressionElse ).first
       return tree_node unless tree_node
-      tree_node.recursive_select(Sexp::Expression).first
+      tree_node.recursive_select(SbuilderSexp::Expression).first
     end
 
     def name
@@ -353,12 +353,41 @@ module Sexp
     end
     
   end
+  
+  class LetExpression < SimpleExpression
+
+    def operatorDef
+      recursive_select( SbuilderSexp::OperatorDef ).first
+    end
+
+    def letExpression
+      elements[1]
+    end
+
+    # Return entries for symbol table. In this case, add just variable
+    # in operator definition
+    #
+    # @return [Array] of 1 hash with {:node_type,:value}
+    def symbol_definitions
+      [ { :node_type => node_type, :value => operatorDef.name } ]
+    end
+
+    # For documentation purposes symbol table context needs a name
+    # (For procedures, and macros name is ovbious. For a set
+    # expression we define name set a string "Set+<generator set>"
+    #
+    # @return [String] name identifying context in symbol table
+    def name
+      "LetExpr-??"
+    end
+    
+  end
 
   class ChooseExpression < SimpleExpression
 
     # @return [BoundInExpression] root node for x \in S
     def binds_node
-      recursive_select( Sexp::BoundInExpression ).first
+      recursive_select( SbuilderSexp::BoundInExpression ).first
     end
 
     # Choose defines 'choose_expression' in left hand size
@@ -406,7 +435,7 @@ module Sexp
     end
 
     def binds_nodes
-      recursive_select( Sexp::BindsInExpression ).first.recursive_select( Sexp::BoundInExpression )
+      recursive_select( SbuilderSexp::BindsInExpression ).first.recursive_select( SbuilderSexp::BoundInExpression )
     end
 
     # Quantification defines 'quantified_expression' in left hand size
@@ -428,7 +457,7 @@ module Sexp
     
     # Some variables in 'constructor_expression' (most likely) refer
     # to variable defined in set constructor generate. Return name of
-    # this variables.
+    # this variable.
     # 
     # @return [Array] of one hash with ':node_type',':value' properties
     def symbol_definitions
@@ -441,10 +470,10 @@ module Sexp
 
   class BoundInExpression < Root
     def bind_var
-      elements.select{ |e| e.is_a?( Sexp::Identifier ) }.first
+      elements.select{ |e| e.is_a?( SbuilderSexp::Identifier ) }.first
     end
     def bind_set
-      elements.select{ |e| e.is_a?( Sexp::Expression ) }.first
+      elements.select{ |e| e.is_a?( SbuilderSexp::Expression ) }.first
     end
 
   end
@@ -479,21 +508,21 @@ module Sexp
       "exprsssion"
     end
     def record_base
-      recursive_select( Sexp::RecordExcepBase ).first.recursive_select( Sexp::Expression ).first
+      recursive_select( SbuilderSexp::RecordExcepBase ).first.recursive_select( SbuilderSexp::Expression ).first
     end
     def record_field_definitions
       # rigth recursion results to empty RecordExceptField -node
-      recursive_select( Sexp::RecordExceptField ).select{ |f| f.elements && f.elements.any? }
+      recursive_select( SbuilderSexp::RecordExceptField ).select{ |f| f.elements && f.elements.any? }
     end
   end
   
   class RecordExceptField < Root
     def lvalue_expression
-      recursive_select( Sexp::LValue ).first
+      recursive_select( SbuilderSexp::LValue ).first
     end
     def rvalue_expression
       # first is expression for lvalue
-      recursive_select( Sexp::Expression ).last
+      recursive_select( SbuilderSexp::Expression ).last
     end
   end
   
@@ -509,7 +538,7 @@ module Sexp
 
     # @return [RecordElement:Array] of record field definitions 
     def record_fields
-      ret = recursive_select( Sexp::RecordElement )
+      ret = recursive_select( SbuilderSexp::RecordElement )
       ret
     end
 
@@ -524,9 +553,9 @@ module Sexp
     # Implement traversal for 'recurse_lvalue'
     # @return [nil|RecordField] down next level in hierarchy
     def lvalue_down
-      down = recursive_select( Sexp::RecordField ).first
+      down = recursive_select( SbuilderSexp::RecordField ).first
       return nil unless down
-      down.recursive_select( Sexp::RecordField ).first
+      down.recursive_select( SbuilderSexp::RecordField ).first
     end
 
 
@@ -566,11 +595,12 @@ module Sexp
 
     # @return [Expression:Array] of sequence expressions
     def tuples
-      recursive_select( Sexp::Expression )
+      recursive_select( SbuilderSexp::Expression )
     end
   end
 
 
+  
   class AbstractSetExpression < AbstactExpression
     # AbstactExpression.traverse quit traversing the expression
     def lhs_node
@@ -587,25 +617,25 @@ module Sexp
     # @return [BoundInExpression|nil] syntax tree node defining
     # generator variable and set
     def binds_node
-      ret = recursive_select( Sexp::BoundInExpression ).first
+      ret = recursive_select( SbuilderSexp::BoundInExpression ).first
       return nil unless ret
-      ret = ret.recursive_select( Sexp::BoundInExpression ).first
+      ret = ret.recursive_select( SbuilderSexp::BoundInExpression ).first
       # puts ret
       ret
     end
     
     def set_expression 
-      deffi = recursive_select( Sexp::SetExpressionDef )
+      deffi = recursive_select( SbuilderSexp::SetExpressionDef )
       return nil unless deffi && deffi.any?
       ret = deffi.first.elements[0]
-      # # ret = deffi.first.recursive_select( Sexp::SetExpression ).first
+      # # ret = deffi.first.recursive_select( SbuilderSexp::SetExpression ).first
       # puts "set_expression=#{ret.inspect}"
       ret
     end
 
     # Elements defined on constructore
     def set_elements
-      elems = recursive_select( Sexp::Expression )
+      elems = recursive_select( SbuilderSexp::Expression )
       elems
     end
 
@@ -629,6 +659,55 @@ module Sexp
     
   end
 
+  class FunctionExpression < AbstactExpression
+
+    def lhs_node
+      nil
+    end
+
+
+    # AbstactExpression.traverse calls in yield
+    def expression_val
+      true
+    end
+
+    def binds_node
+      ret = recursive_select( SbuilderSexp::BoundInExpression ).first
+      # return nil unless ret
+      # ret = ret.recursive_select( SbuilderSexp::BoundInExpression ).first
+      # # puts ret
+      # ret
+    end
+
+    def function_expression
+      elements[1]
+    end
+
+    # For documentation purposes symbol table context needs a name
+    # (For procedures, and macros name is ovbious. For a set
+    # expression we define name set a string "Set+<generator set>"
+    #
+    # @return [String] name identifying context in symbol table
+    def name
+      "Func-#{binds_node.bind_set.text_value}"
+    end
+    
+
+    # Some variables in 'set_expression' (most likely) refer to
+    # variable defined in set constructor generate. Return name of
+    # this variables.
+    # 
+    # @return [Hash:Array] with :node_type,:value, :tree -properties
+    def symbol_definitions
+      return [] unless binds_node
+      [ { :node_type => node_type, :value => binds_node.bind_var.expression_val, :tree=>binds_node } ]
+    end
+    
+    
+    
+  end
+  
+
   class SetExpressionMap < AbstractSetExpression
   end
 
@@ -653,10 +732,17 @@ module Sexp
   
 
   class FieldByName < FieldBy
+
+    def name_expression
+      elements[0]
+    end
+
+    # ---
+    # depracted here down
     
     # @return [AbstactExpression] defining the name    
     def field_name_expression
-      recursive_select( Sexp::AbstactExpression ).first
+      recursive_select( SbuilderSexp::AbstactExpression ).first
     end
     
     def expression_val
@@ -666,10 +752,10 @@ module Sexp
     # implements lvalue
     include TlaParserS::LValue
     def lvalue_down
-      down = recursive_select( Sexp::UnitExpression ).first
-      # down = recursive_select( Sexp::RecordField ).first
+      down = recursive_select( SbuilderSexp::UnitExpression ).first
+      # down = recursive_select( SbuilderSexp::RecordField ).first
       # return nil unless down
-      # down.recursive_select( Sexp::RecordField ).first
+      # down.recursive_select( SbuilderSexp::RecordField ).first
     end
     
     
@@ -678,26 +764,28 @@ module Sexp
   class FieldByValue < FieldBy
     
     def expression_val
-      field_value_expression && field_value_expression.expression_val
+      return true if field_value_expression
     end
 
     def field_value_expression
-      recursive_select( Sexp::AbstactExpression ).first
+      # recursive_select( SbuilderSexp::AbstactExpression ).first      
+      elements[0]
     end
+
     
 
     # # @return [AbstactExpression] defining the value
     # def val_expression
-    #   recursive_select( Sexp::AbstactExpression ).first
+    #   recursive_select( SbuilderSexp::AbstactExpression ).first
     # end
 
     # implements lvalue
     include TlaParserS::LValue
     def lvalue_down
-      down = recursive_select( Sexp::UnitExpression ).first
-      # down = recursive_select( Sexp::RecordField ).first
+      down = recursive_select( SbuilderSexp::UnitExpression ).first
+      # down = recursive_select( SbuilderSexp::RecordField ).first
       # return nil unless down
-      # down.recursive_select( Sexp::RecordField ).first
+      # down.recursive_select( SbuilderSexp::RecordField ).first
     end
     
   end
@@ -776,10 +864,10 @@ module Sexp
     # 'recursive_select'
     def find_labelnode
       
-      # return labelnode = recursive_select( Sexp::Label ).first
+      # return labelnode = recursive_select( SbuilderSexp::Label ).first
       if !elements.nil? then
         elements.each do |e|
-          return e if e.is_a?( Sexp::Label ) 
+          return e if e.is_a?( SbuilderSexp::Label ) 
         end
       end
       # Label node not found
@@ -795,7 +883,7 @@ module Sexp
     
     # @return [UnlabeledStatement:TreeNode] TLA -language statement
     def get_statement
-      ret = recursive_select( Sexp::UnlabeledStatement ).first
+      ret = recursive_select( SbuilderSexp::UnlabeledStatement ).first
       ret
     end
 
@@ -845,7 +933,7 @@ module Sexp
   class CompoundStatement < UnlabeledStatement
 
     def statements
-      stmts=recursive_select(Sexp::StatementList).first.recursive_select(Sexp::Statement)
+      stmts=recursive_select(SbuilderSexp::StatementList).first.recursive_select(SbuilderSexp::Statement)
       stmts
 
     end
@@ -858,7 +946,7 @@ module Sexp
   class Goto < UnlabeledStatement
     
     def goto_label
-      recursive_select( Sexp::Identifier).map{ |r| r.node_value }.first      
+      recursive_select( SbuilderSexp::Identifier).map{ |r| r.node_value }.first      
     end
     
   end
@@ -867,7 +955,7 @@ module Sexp
 
     # @return [Expression] to print
     def print_expression
-      recursive_select( Sexp::Expression).first
+      recursive_select( SbuilderSexp::Expression).first
     end
     
   end
@@ -876,12 +964,13 @@ module Sexp
 
     # @return [LValue] where to assign to
     def lvalue
-      recursive_select( Sexp::LValue).first      
+      recursive_select( SbuilderSexp::LValue).first      
     end
 
     # @return [Expression] expression to assign
     def rvalue
-      recursive_select( Sexp::Expression).first            
+      elements[1]
+      # recursive_select( SbuilderSexp::Expression).first            
     end
     
   end
@@ -890,14 +979,27 @@ module Sexp
   class Return < UnlabeledStatement
   end
 
+  class WithStatement < UnlabeledStatement
+
+    def with_expression
+      recursive_select( SbuilderSexp::Expression).first
+    end
+    
+    def with_statement
+      recursive_select( SbuilderSexp::Statement).first
+    end
+    
+    
+  end
+
   class Conditional < UnlabeledStatement
 
     def condition
-      recursive_select( Sexp::Expression).first
+      recursive_select( SbuilderSexp::Expression).first
     end
 
     def true_or_else
-      recursive_select( Sexp::Statement)
+      recursive_select( SbuilderSexp::Statement)
     end
 
     def if_true
@@ -915,7 +1017,7 @@ module Sexp
 
     # Return array of choices
     def choices
-      recursive_select( Sexp::Statement)
+      recursive_select( SbuilderSexp::Statement)
     end
     
   end
@@ -924,7 +1026,7 @@ module Sexp
   class Assert < UnlabeledStatement
     
     def assertion
-      recursive_select( Sexp::Expression).first
+      recursive_select( SbuilderSexp::Expression).first
     end
     
   end
@@ -932,7 +1034,7 @@ module Sexp
   class Called  < UnlabeledStatement
 
     def called
-      recursive_select( Sexp::Identifier).map{ |r| r.node_value }.first      
+      recursive_select( SbuilderSexp::Identifier).map{ |r| r.node_value }.first      
     end
 
     def statement_val
@@ -941,7 +1043,7 @@ module Sexp
 
     # @return [Array] actual parameters parsed as 'Expression' nodes
     def actual_parameters
-      recursive_select( Sexp::Expression)
+      recursive_select( SbuilderSexp::Expression)
     end
 
     
@@ -966,7 +1068,7 @@ module Sexp
   class Label < Root
 
     def label
-      recursive_select(Sexp::Identifier).first.node_value
+      recursive_select(SbuilderSexp::Identifier).first.node_value
     end
     
     def node_value
@@ -981,7 +1083,7 @@ module Sexp
 
     # @return [String:Array] of directive names
     def directives
-      recursive_select( Sexp::Identifier ).map { |i| i.node_value }
+      recursive_select( SbuilderSexp::Identifier ).map { |i| i.node_value }
     end
 
     
@@ -993,12 +1095,23 @@ module Sexp
   class Assumption < Directive
   end
 
+  class Recursive < Directive
+    def name
+      directives.first
+    end
+
+    def cardinality
+      directives.length - 1
+    end
+  end
+  
+
   # ------------------------------------------------------------------
   # callable (procedures, macros, processes?)
 
   class Define < Root
     def name
-      recursive_select(Sexp::Identifier).first.node_value
+      recursive_select(SbuilderSexp::Identifier).first.node_value
     end
     
   end
@@ -1006,7 +1119,7 @@ module Sexp
   class Callable < Define
     
     def parameters_node
-      tree_nodes = recursive_select(Sexp::Parameters)
+      tree_nodes = recursive_select(SbuilderSexp::Parameters)
       return tree_nodes.first if tree_nodes
     end
     def parameters
@@ -1016,7 +1129,7 @@ module Sexp
 
     
     def body_node
-      ret = recursive_select(Sexp::Statement).first
+      ret = recursive_select(SbuilderSexp::Statement).first
       ret
     end
     def body
@@ -1060,14 +1173,14 @@ module Sexp
 
     # @return [Nil|ProcVariables] of variable definition node for procedure
     def procedure_variables_node
-      tree_nodes = recursive_select(Sexp::ProcVariables)
+      tree_nodes = recursive_select(SbuilderSexp::ProcVariables)
       return tree_nodes.first if tree_nodes
     end
 
     # @return [VariableDef:Array] variable declarations
     def variable_declarations
       return [] unless procedure_variables_node
-      return procedure_variables_node.recursive_select(Sexp::VariableDef)
+      return procedure_variables_node.recursive_select(SbuilderSexp::VariableDef)
     end
 
     def procedure_variables
@@ -1092,7 +1205,7 @@ module Sexp
     
     # For operator no body:
     def body_node
-      tree_nodes = recursive_select(Sexp::Expression)
+      tree_nodes = recursive_select(SbuilderSexp::Expression)
       return tree_nodes.first if tree_nodes
     end
   end
@@ -1104,23 +1217,25 @@ module Sexp
 
     #
     def name
-      recursive_select(Sexp::Identifier).first.node_value
+      # recursive_select(SbuilderSexp::Identifier).first.node_value
+      variable.node_value
     end
 
     # @return [Identifier] tree node for variable defined
     def variable
-      tree_nodes = recursive_select(Sexp::Identifier).first      
+      tree_nodes = recursive_select(SbuilderSexp::Identifier).first      
     end
     
     
     # @return [Expression] tree node for init expression
     def init
-      tree_nodes = recursive_select(Sexp::Expression).first      
+      tree_nodes = recursive_select(SbuilderSexp::Expression).first
     end
 
     # Return entries for symbol table. In this case, add just variable
     # definition.
-    # @return [Array] of 1 hash with :node_type, :value -properties
+    #
+    # @return [Array] of 1 hash with {:node_type,:value}
     def symbol_definitions
       [ { :node_type => node_type, :value => name } ]
     end
@@ -1129,10 +1244,10 @@ module Sexp
 
   class RecordElement < Root
     def element_name
-      recursive_select( Sexp::Identifier ).first
+      recursive_select( SbuilderSexp::Identifier ).first
     end
     def element_expression
-      recursive_select( Sexp::Expression ).first
+      recursive_select( SbuilderSexp::Expression ).first
     end
   end