cauldron 0.1.0

data/lib/core/statement/StatementDependencies.rb

@@ -0,0 +1,271 @@
+#
+# TODO  I might just make this part of StatementGroup
+# 
+# TODO TSort examples show a single use.  So you basically add all your variables 
+# and then sort them once.  Rather than what I'm doing which is to attempt
+# to find the dependencies for particular statements.  It might be better
+# to rebuild the dependies each time and then do a single sort.
+
+# Include a scope dependencies as well - if a statement resides within a nested statement
+# the nested statement must come first.
+#
+#    New statement: - statement level: 183
+#      var_5918 = var_652  +  var_658 
+# 
+#    Pre-requiste statements: 
+#    var_34 = method_13 
+#    var_34.times do |var_658|
+#    end
+#    var_652 = var_34  +  var_34 
+
+# In this case the scope means that the nested "var_34.times do |var_658|" is dependent
+# on var_652 = var_34  +  var_34.
+#    
+#    # Find the statement that contains this statement - if it exists
+#    self.each do |x|
+#      if x.kind_of?(BlockStatement)
+#        if x.scope_id == statement.statement_level
+#          
+#          # Apply the dependencies for the statement to the containing statement
+#          # unless it's the containing statement itself.
+#          
+#        end        
+#      end
+#    end
+#
+class StatementDependencies < Array
+  #include TSort   # See p750
+  
+  alias :array_push :push  
+  
+  def initialize(*params)
+    super()
+    #@dependencies = {}
+    
+    # Add the statements
+    params.each {|x| self.push(x)}
+  end
+
+  # TODO  Write about this in more detail
+  #
+  def tsort_for_statement(statement)
+    
+    @statement_sort = TopologicalStatements.new    
+    add_dependent_statements(@statement_sort,statement)    
+    
+    # TODO  Should probably copy the @statement_sort before itterating through it
+    #
+    each_used_nest_statement(@statement_sort,statement) do |x| 
+      # CONTINUE - Why are these nested statements populated
+      
+      # Find statements that have the same scope as this
+      each_nested_statement(@statement_sort,statement,x.scope_id) do |y|
+         
+         #  Add the inner statement dependencies onto the nested statement
+         @statement_sort[x.statement_id] += @statement_sort[y.statement_id]
+      end
+      
+    end
+        
+    return @statement_sort.tsort
+    
+  end
+  
+  def dependencies_for(statement_id)
+
+    # Check that the statement exists
+    unknown_statement_id = lambda {raise StandardError.new('Could\'nt find statement_id '+statement_id.to_s)}
+    self.detect(unknown_statement_id) {|x| x.statement_id == statement_id}
+    
+    # 
+    @statement_sort = TopologicalStatements.new
+    
+    # First find the initial statement
+    initial_statement = find_statement(statement_id)
+    add_dependent_statements(@statement_sort,initial_statement)
+    
+    
+    return @statement_sort.tsort
+  end
+  
+  def add_dependent_statements(tsort,statement)
+    dependencies = find_dependencies_for(statement)
+    tsort[statement.statement_id] = dependencies
+    
+    # Find the dependiencies for the 
+    dependencies.each do |x|
+      add_dependent_statements(tsort,find_statement(x))
+    end
+  end
+  
+  def find_statement(id)
+    self.each do |x|
+      if x.statement_id == id
+        return x
+      end
+    end 
+    # TODO  Should raise error here
+  end
+  
+  # Returns an array of statement ids of all the statements that the supplied 
+  # statement is dependent on.
+  #
+  # @param  statement   A statement instance thats dependencies are returned
+  #
+  def find_dependencies_for(statement)
+    results = []
+    statement.not_declared_variables.each do |x| 
+
+      # Find the original declaration statement
+      # TODO  Doesn't catch no results
+      statement_ids = self.inject([]) do |ids,y| 
+        #ids.push(y.statement_id) if x.uniq_id == y.created_variable.uniq_id
+        if x.uniq_id == y.created_variable.uniq_id
+          # TODO  Quick hack to prevent bug
+          ids.push(y.statement_id) unless statement.statement_id == y.statement_id
+        end
+        ids
+      end
+      
+      # Find any further required uniq ids
+      x.uniq_id_history.each do |y|             
+        # TODO  Change to detect since this presumes a result is found
+        statement_ids.push(self.select {|z| z.created_variable.uniq_id == y}.first.statement_id)
+      end
+      raise StandardError.new('Can\'t find the declaration of '+x.write+' or '+x.write_with_uniq_id) if statement_ids.empty?      
+      results += statement_ids               
+      results.each do |y|
+        raise StandardError.new('dksafkjdashfkahsdf '+statement.statement_id.to_s) if(y==statement.statement_id)
+      end
+#      # TODO  Change to catch :found
+#      found = false
+#      self.each do |y|
+#        #if x.variable_id == y.declared_variable_id
+#        if x.uniq_id == y.created_variable.uniq_id
+#          found = true
+#          results.push(y.statement_id)
+#          break
+#        end
+#      end
+#      raise StandardError.new('Can\'t find the declaration of '+x.write+' or '+x.write_with_uniq_id) unless found         
+    end
+    return results
+  end
+  
+  # Saves any of the statements thats dependencies are being
+  # saved.
+  #
+  # @param  statement      
+  #
+  def push(statement)
+            
+    # Check that any statements this statement is dependent on is included
+    find_dependencies_for(statement)
+
+    # Add the new piece of code to the statement
+    array_push(statement)   
+    
+  end
+  
+  # Returns the saved statement based on the statement id provided
+  #
+  # @param  statement_id    The statement id of the stored statement.
+  #
+  def find_statement(statement_id,new_statement=nil)
+    unless new_statement.nil?
+      return new_statement if new_statement.statement_id == statement_id
+    end
+    return self.detect {|x| x.statement_id == statement_id}
+  end
+  
+  # Returns a string to be printed out for the general use of 
+  # debugging.
+  #
+  # @param  topsort         Topological sort containing the dependencies 
+  #                         for each statement.
+  # @param  statements      An array of statements that have already been
+  #                         saved.
+  # @param  new_statement   The new statement that has yet to be included 
+  #                         in a large method and hasn't been realised yet.
+  #
+  def display_statement_dependencies(topsort,statements,new_statement)
+    msg = ''  
+    msg += topsort.inspect+"\n"
+    topsort.each_key do |x|
+      msg += x.to_s+"\n"
+      msg += find_statement(x,new_statement).write+"\n"
+    end
+    return msg
+  end
+  
+  # Modifies the supplied topological sort to include scope dependency.  This
+  # basically involves applying the dependencies of nested statements to 
+  # the containing statement. e.g. 
+  # 
+  # var_a = 6
+  # 5.times do |var_b|
+  #   var_c = var_b+var_a
+  # end
+  #
+  # So "var_c = var_b+var_a" is dependent on the two proceeding statements but
+  # sequentially they could be written as 
+  # 
+  # 5.times do |var_b| 
+  # var_a = 6
+  # var_c = var_b+var_a
+  #
+  # But when put it into its particular nest we end up with
+  # 
+  # 5.times do |var_b|
+  #   var_c = var_b+var_a
+  # end
+  # var_a = 6
+  # 
+  # @param  topsort         Topoligical sort indicating an ordering dependencey
+  # @param  new_statement   The new statement that is yet to saved internally
+  #                         (because it hasn't been realised)
+  #
+  def apply_scope_dependencies(topsort,new_statement)
+    
+    # Find each nest statement and then any statements contained within
+    each_used_nested_statement(topsort,new_statement) do |x|
+#      CONTIUE
+    end
+            
+  end
+  
+  # Yeilds each nested statement.  Despite the naming convention a nested
+  # statement is really a nest statement.  NOTE This is not every contained
+  # NestStatement but rather those used.
+  #
+  # TODO  NestStatement would be a more reflective name - after all the statements
+  #       within the statement are nested.
+  #
+  def each_used_nest_statement(topsort,new_statement)
+    topsort.each_key do |x|
+      found_statement = find_statement(x,new_statement)
+      yield found_statement if found_statement.kind_of?(BlockStatement)
+    end
+  end
+  
+  # Yeilds each statement that is nested within the scope specified
+  # 
+  # @param  topsort       The has containing each relevent statement id as well
+  #                       as there dependencies.
+  # @param  statement     The statement in the process of being added.  It needs
+  #                       passed since is not yet saved within this class.
+  # @param  scope_id      The scope id of the nest statement that contains the 
+  #                       nested statements.
+  #
+  def each_nested_statement(topsort,new_statement,scope_id)
+    topsort.each_key do |x|  
+      found_statement = find_statement(x,new_statement)
+      # TODO  I need to clarify the terms ,scope,scope_id and statement_level
+      #       - I think one can at least go or at least have less confusing names.
+      if found_statement.statement_level == scope_id
+        yield found_statement
+      end
+    end
+  end
+    
+end

data/lib/core/statement/StatementGroup.rb

@@ -0,0 +1,157 @@
+class StatementGroup < Array
+  attr_reader :scope, :scope_id, :statement_level
+  attr_writer :scope, :scope_id, :statement_level
+  
+  # The scope id is used to determine what variables are available with the nested statement
+  @@scope_id = 0    
+  
+  alias :array_push :push    
+  
+  def initialize(*statements)
+    super()
+    statements.each {|x| self.push(x)}
+    
+    # Update the scope id for the nested statement
+    @scope_id = @@scope_id
+    @@scope_id += 1
+    
+    @scope = [@scope_id]
+    
+  end
+  
+  def cauldron_method_calls
+    return ['.statement_id']
+  end    
+  
+  def write(tab=0)
+    line = ''
+    self.each {|x| line += x.write(tab)+"\n" }
+    return line
+  end    
+  
+  def describe(tab=0)
+    line = ''
+    #self.each {|x| line += x.describe(tab)+"\n" }
+    self.each do |x| 
+      line += x.describe(tab)+"\n"
+    end
+    return line
+  end    
+  
+  # Removes any statements that simple re-declare an existing statement
+  # e.g var_a = var_b.
+  #
+  def remove_simple
+    results = StatementGroup.new
+    self.each do |x|
+      results.push x unless x.is_simple?
+    end
+    return results
+  end
+  
+  def push(*entries)
+    self.entries.each do |x|
+      x.scope = [@scope_id]
+    end
+    #super.array_push(*entries)
+    entries.each do |y|
+      
+      # TODO  Oddly super.array_push seems to add it twice - might investigate
+      #super.array_push(y)
+      array_push(y)
+    end
+  end
+  
+  # TODO  This method name doesn't suit what it returns
+  def statement_id
+    return @scope_id
+  end
+  
+  # Returns a statement container (either a runtime method or a nested statement)
+  # thats scope is the statement level specified.  This means that any statements
+  # with the statement level specified should reside directly in the statement
+  # container.
+  #
+  # @param  statement_level   The statement level the statement group should 
+  #                           contain statements at.
+  #
+  def find_container_at_level(statement_level)
+    return self if scope_id == statement_level
+    self.each do |x|
+      if x.kind_of?(StatementGroup)
+        begin
+          return x.find_container_at_level(statement_level)
+        rescue FailedToFindStatementContainerError => e
+          next
+        end
+        #result = x.find_container_at_level(statement_level)
+        #return result unless result.nil?
+      end
+    end
+    raise FailedToFindStatementContainerError.new('Failed to find containing statement with id '+statement_level.to_s)
+    #return nil
+    #raise StandardEror.new('There is no container at level '+)
+  end
+  
+  # Returns the statement thats id matches that supplied.
+  #
+  # @param  id    The id of the statement should exist in the runtime method
+  #
+  def find_statement(id)
+    self.each do |x|    
+      begin 
+        return x.find_statement(id)
+      rescue FailedToFindStatementError => e
+        next
+      end
+    end
+    raise FailedToFindStatementError.new('Couldn\'t find statement with id '+id.to_s)
+  end  
+  
+  # Returns an array of all the runtime method instances that are
+  # required for this statement group.  This is essentially the 
+  # runtime methods referenced in DefCalls.
+  #
+  def find_all_required_runtime_methods
+    results = []
+    self.each do |x|
+      results += x.find_all_required_runtime_methods
+    end
+    return results
+  end
+  
+  def copy 
+    result = self.class.new(*self.collect {|x| x.copy })
+    result.scope_id = scope_id
+    result.scope = scope
+    result.statement_level = statement_level
+    return result
+  end
+  
+  # Identify any of the contained statements that override an 
+  # existing variable. 
+  # 
+  # @param  already_declared      An array of previously declared variable ids in the 
+  #                               following format. [{:variable_id=>43},{:variable_id=>12}, ..]
+  #
+  def identify_overriding_statements(already_declared=[])
+    self.each do |x|
+      x.identify_overriding_statements(already_declared)
+    end
+  end  
+  
+  # Returns an array of overriding statements that reside inside
+  # this statement group.  A overriding statement is a statement that 
+  # re-declares or modifies a previously declared variable.
+  #
+  # @param  overriding_statements   An array of statements that have been overriden
+  #                                 within the statement group.
+  #
+  def find_overriding_statements(overriding_statements=[])
+    self.each do |x|
+      x.find_overriding_statements(overriding_statements)
+    end
+    return overriding_statements
+  end  
+  
+end

data/lib/core/statement/StatementStructure2.rb

@@ -0,0 +1,224 @@
+# Move this class to the structure folder
+# 
+# TODO  This is more a StatementStructureFactory
+class StatementStructure2 < Array
+  
+#  attr_reader :declared_fixnum
+#  
+#  @@DECLARED_FIXNUM = 'declared_fixnum'
+#  DECLARE_STRING = 'declared_string'
+#  DECLARE_STRING_ADDITION = 'declared_string_addition'
+  TIMES_ON_FIXNUM = 'times_on_fixnum'
+  
+  # TODO  I don't think I really need to pass the parameters anymore
+  def initialize(name)
+    # TODO  What are the two parameters an array expects
+    super()
+    
+    @structure_name = name
+
+    # Add the parameters to the array 
+    structure().each do |code|
+      self.push(code)
+    end    
+  end
+  
+  # var = 'test'+'ing'
+  def StatementStructure2.declared_string_addition
+    return 'declared_string_addition'
+  end
+  
+  def StatementStructure2.times_on_fixnum
+    return 'times_on_fixnum'
+  end
+  
+  def StatementStructure2.declared_array
+    return 'declared_array'
+  end
+  
+  def StatementStructure2.declared_runtime_method
+    return 'declared_runtime_method'
+  end
+  
+  # var = 5+8
+  def StatementStructure2.declared_fixnum_addition
+    return 'declared_fixnum_addition'
+  end
+  
+  def StatementStructure2.declared_statement
+    return 'declared_statement'
+  end
+  
+  def structure
+    case @structure_name
+#      when StatementStructure2.declared_fixnum
+#        return [Unknown,Equal,FixnumVariable]
+#      when StatementStructure2.declared_string
+#        return [Unknown,Equal,StringVariable]
+      when StatementStructure2.declared_array
+        return [Unknown,Equal,ArrayVariable]
+      when StatementStructure2.declared_runtime_method
+        return DeclareRuntimeMethodStructure.new()
+      when StatementStructure2.declared_string_addition
+        return [Unknown,Equal,StringVariable,Addition,StringVariable]
+      when StatementStructure2.declared_fixnum_addition
+        return FixnumAdditionStructure.new()
+      when StatementStructure2.declared_statement
+        return DeclareStatementStructure.new()
+    else
+      raise StandardError.new('Unknown statement structure "'+@structure_name+'"')
+    end
+  end
+  
+  # Returns an array of possible statements that can be
+  # created to follow the structure of the statement.
+  #
+  # Any method calls are considered as their returned value. So
+  # a method that returns a string is just considered as a 
+  # RuntimeVariable with a string class requirement.
+  #  
+  def statements(available=[])
+    
+    # Retrieve the statements for 
+    if(@structure_name==StatementStructure2.times_on_fixnum)
+      return fixnum_times_statements(available)
+    end
+    
+    # Create an array of statements that gets extended
+    partial_statements = [Statement.new]
+    
+    # Go through each element of the statement structure
+    self.each do |statement_element|
+      
+      # Creates an array of updated statements
+      updated_statements = []
+      
+      # If it is an unknown variable just add it 
+      if(statement_element == Unknown)
+          partial_statements = add_unknown_variable(partial_statements)
+          next
+      end
+      
+      # Just include it if it's a = sign
+      if(statement_element == Equal)or(statement_element == Addition)
+      
+          # Go through each element in the partial statements and add a copy of the new element
+          partial_statements.each do |partial|              
+            copied_statement = partial.copy
+            copied_statement.push(statement_element.new)
+            updated_statements.push copied_statement
+          end
+          partial_statements = updated_statements          
+          next
+      end      
+      
+      # Go through each of the available elements and see if they meet the statement elements
+      available.each do |avail|
+        
+        # If any of the values match - include them in the statement
+        if avail.kind_of?(statement_element)
+          
+          # Go through each element in the partial statements and add a copy of the new element
+          partial_statements.each do |partial|              
+            copied_statement = partial.copy
+            copied_statement.push(avail.copy)
+            updated_statements.push copied_statement
+          end
+              
+        end
+        
+        # Now see what instance calls are available to the passed avail
+        if avail.kind_of?(Variable)
+          
+          # Retrieve any instance calls available for that variable
+          # TODO  Availabe should not include the variable with the same id
+          instance_calls = avail.instance_calls(available)
+          instance_calls.each do |x|
+
+            if x.response.class == statement_element
+                
+              partial_statements.each do |partial|              
+                copied_statement = partial.copy
+                copied_statement.push(x.copy)
+                updated_statements.push copied_statement
+              end                            
+                
+            end
+          end
+              
+        end
+        
+        # If it is a definition call then check against the response value
+        if avail.kind_of?(DefCall)
+          if avail.response.class == statement_element
+            partial_statements.each do |y|
+              copied_statement = y.copy
+              copied_statement.push(avail.copy)
+              updated_statements.push copied_statement
+            end
+          end
+        end
+        
+      end
+      
+      partial_statements = updated_statements
+      
+    end
+    
+#    # Save the structure used to create the statement - this structure type will 
+#    # become deprecated soom.
+#    partial_statements.each do |x|
+#      x.structure = self.class
+#    end
+
+    return partial_statements     
+     
+  end
+ 
+  # Returns a general description of the statement to 
+  # indicate whether it declares a new variable or 
+  # modifies an existing variable or nothing.
+  #
+  def self.statement_type
+    #raise StandardError.new('This method should be overridden "'+self.to_s+'"')
+    StandardLogger.instance.warning('This method should be used')
+    #return StatementStructure.DECLARATION_STATEMENT
+    return 'declaration_statement'
+  end 
+
+protected 
+  
+  # TODO Write tests
+  # Adds a unknown variable to each statement in the supplied 
+  # array and returns the result.
+  #
+  def add_unknown_variable(current_statements)
+    results = []
+    current_statements.each do |x|              
+      copied = x.copy
+      copied.push(Unknown.new)
+      results.push copied
+    end    
+    return results
+  end
+  
+  # Get the possible .times statements from the available
+  # fixnum variables 
+  #
+  def fixnum_times_statements(available=[])
+    
+    # If there aren't any fixnum variables there is nothing to return
+    return [] unless available.any? {|x| x.kind_of?(FixnumVariable)}
+
+    # Use each of the fixnum variables
+    results = []
+    available.find_all {|x| x.kind_of?(FixnumVariable) }.each do |y|  
+      new_statement = BlockStatement.new(Statement.new(InstanceCallContainer.new(y.copy,Times.new)),BlockContainer.new(BlockVariable.new))
+      new_statement.structure = self.class
+      results.push(new_statement)
+    end
+
+    return results
+  end
+  
+end