cauldron 0.1.0

data/lib/core/variable/UnknownVariable.rb

@@ -0,0 +1,29 @@
+# NOTE FROM VARIABLE REFERENCE
+# I'm not sure if this is the way to go, but I need some way
+# to handle the case where variables reference variables. 
+#
+# For example:
+#
+#  #
+#  #
+#  def method_8
+#    var_12 = Statement.new(Unknown.new,Equal.new,8.to_declaration) 
+#    var_570 = var_12.declared_variable 
+#  end
+#
+# In this case it is difficult to realise var_570 since it references an 
+# unrealised variable.  I should maybe have created an Unknown class, but
+# it is still an Unknown.
+# 
+class UnknownVariable < TypeVariable
+  
+  def initialize(val,id=nil)
+    super(val,id)
+  end
+  
+  #
+  def destructive_instance_calls(available=[])
+    return [] 
+  end  
+  
+end

data/lib/core/variable/Variable.rb

@@ -0,0 +1,70 @@
+# This class represents any variable object used to help generate 
+# a method.
+#
+
+module Variable 
+  
+  include VariableIncluded
+  
+  @@variable_id = 0
+  
+  # The unique id is used to identify actually different variables.  This essentially occurs 
+  # when a destructive method call is used.  For example an two array variables might have the
+  # same variable_id say '2' so would both be written as 'var_2' but one of them might have had
+  # another element pushed into it e.g. 'var_2.push(6)'.  The changed variable would then 
+  # receive a different uniq_id. 
+  @@uniq_id = 0
+  
+  #CONST_TEST = 'test'
+  # 331 Constants are in capitals and accesses Variable::CONST_TEST class variables use @@    
+  
+  # Create the declaration for a unique variable id.  The unique_variable_id reflects the different
+  # values a variable might have.  For example if a variable is overwritten it will have the same
+  # name as it's predisessor but not the same value.
+  attr_reader :uniq_id, :scope_id
+  attr_writer :scope_id
+  
+  def self.reset_global_id
+    #http://www.zenspider.com/Languages/Ruby/QuickRef.html
+    unless $".include?('test/unit.rb')
+      StandardLogger.log 'WARNING: Resetting variable id, this should only be done for tests'
+    end
+    @@variable_id = 0
+    @@uniq_id = 0    
+  end  
+  
+  def self.variable_id
+    return @@variable_id
+  end  
+  
+  # TODO  This is not a permenant method it is a temporary fix
+  #       as I migrate away from requirements.
+  #
+  def meets_requirements? of    
+    return true if of.literalise.value == self.value
+    return false
+  end
+  
+  # Change the value of the variables uniq_id
+  #
+  # @param  The new value for the variables uniq_id 
+  #
+  def uniq_id=(value)
+    @uniq_id = value
+    raise StandardError.new('Should be fixnum') unless value.kind_of?(Fixnum)
+  end
+  
+  # Updates the uniq_id for this variable so it can be regarded
+  # differently.  Uniq_ids are used in the CodeHandler to allow
+  # the inclusion of the correct statements to recreate a variable.
+  #
+  def increament_uniq_id!
+    @uniq_id = @@uniq_id    
+    @@uniq_id += 1
+  end
+  
+  def to_var(id=nil)
+    raise StandardError.new(self.class.to_s+' is already a Variable - should not call to_var')  
+  end
+  
+end

data/lib/core/variable/VariableContainer.rb

@@ -0,0 +1,28 @@
+class VariableContainer < BaseVariable
+  
+  attr_writer :realised
+  
+  def initialize
+    super()
+    
+    @realised = false
+  end  
+  
+  # Returns a duplicate of this variable container.  
+  # 
+  def copy
+    result = VariableContainer.new(){{:variable_id => self.variable_id,:uniq_id=>@uniq_id, :uniq_id_history=>@uniq_id_history.copy}}
+    result.instance_variable = @instance_variable    
+    self.each do |x|
+      result.push(x)
+    end
+    result.realised = @realised
+    return result        
+  end
+  
+  # TODO  Write description - hack for instance calls
+  def variable
+    return self
+  end
+  
+end

data/lib/core/variable/VariableIncluded.rb

@@ -0,0 +1,27 @@
+# Classes that include this module are presumeed to include a variable,
+# this is is used in the following classes.
+#
+# Variable
+# InstanceCallContainer
+# ArrayAccess
+#
+module VariableIncluded
+  
+  # Should have the following methods
+  # variable
+  
+  # Returns the variable.  This call also exists in the InstanceCallContainer class.  It is
+  # included to allow access of the variable with the need to disgiush whether it
+  # is variable or an instance call.
+  #
+  def variable
+    return self
+  end    
+  
+  # Returns the actual variable with the specified id. 
+  #
+  def find_actual_variable(id)
+    raise StandardError.new('Method needs defined in class')  
+  end
+  
+end

data/lib/core/variable/VariableReference.rb

@@ -0,0 +1,85 @@
+# I'm not sure if this is the way to go, but I need some way
+# to handle the case where variables reference variables. 
+#
+# For example:
+#
+#  #
+#  #
+#  def method_8
+#    var_12 = Statement.new(Unknown.new,Equal.new,8.to_declaration) 
+#    var_570 = var_12.declared_variable 
+#  end
+#
+# In this case it is difficult to realise var_570 since it references an 
+# unrealised variable.  I should maybe have created an Unknown class, but
+# it is still an Unknown.
+# 
+class VariableReference
+  include Variable  
+  
+  attr_reader :variable_id
+  
+  # 
+  # @param  referenced_variable_id      
+  #
+  def initialize(var_id,referenced_variable_id)
+    @variable_id = var_id
+    @referenced_variable_id = referenced_variable_id
+    raise StandardError.new('I am getting rid of this')
+  end
+  
+  def copy
+    return VariableReference.new(@variable_id,@referenced_variable_id)
+  end
+  
+  # Returns the variable if the ids matched
+  #
+  # @param  id    The id of the variable that is being looked for
+  #
+  def find_actual_variable(id)
+    return self if @variable_id == id
+    throw :variable_not_found
+  end  
+  
+  #
+  # 
+  #
+  def write()
+    if (@instance_variable)
+      return '@var_'+variable_id.to_s    
+    end
+    return 'var_'+variable_id.to_s    
+  end   
+  
+  def to_literal_string
+    return 'var'  
+  end  
+  
+  def realised?
+    return false
+  end  
+  
+  # TODO  Write tests for this
+  # Returns an array of desctructive instance calls given the available
+  # variables.
+  # 
+  # @param  available     An array of other variables that can be used as
+  #                       parameters. 
+  #
+  def destructive_instance_calls(available=[])
+    
+    # Find the variable it references
+    available_variables = available.select {|x| x.kind_of?(Variable)}
+
+    not_found = lambda{raise StandardError.new('Unable to find variable with id '+@referenced_variable_id.to_s)}
+    referenced_variable = available_variables.detect(not_found) {|x| x.variable_id == @referenced_variable_id}
+      
+    # Duplicate the referenced variable and update it's variable id
+    duplicated_var = referenced_variable.copy
+    duplicated_var.variable_id = @variable_id
+    
+    return duplicated_var.destructive_instance_calls(available)
+    
+  end    
+  
+end

data/lib/error/FailedToFindStatementContainerError.rb

@@ -0,0 +1,7 @@
+class FailedToFindStatementContainerError < StandardError
+  
+  def initialize(msg='')
+    super(msg)
+  end
+    
+end

data/lib/error/FailedToFindStatementError.rb

@@ -0,0 +1,7 @@
+class FailedToFindStatementError < StandardError
+  
+  def initialize(msg)
+    super(msg)
+  end
+  
+end

data/lib/error/FailedToFindVariableError.rb

@@ -0,0 +1,7 @@
+class FailedToFindVariableError < StandardError
+  
+  def initialize(msg)
+    super(msg)
+  end
+  
+end

data/lib/error/FailedToLiteraliseError.rb

@@ -0,0 +1,7 @@
+class FailedToLiteraliseError < StandardError
+  
+  def initialize(msg)
+    super(msg)
+  end
+  
+end

data/lib/error/FailedVariableMatch.rb

@@ -0,0 +1,7 @@
+class FailedVariableMatch < StandardError
+  
+  def initialize(msg)
+    super(msg)
+  end
+  
+end

data/lib/error/ImproperStatementUsageError.rb

@@ -0,0 +1,7 @@
+class ImproperStatementUsageError < StandardError
+  
+  def initialize(msg)
+    super(msg)
+  end
+  
+end

data/lib/error/IncompatiableRequirementsError.rb

@@ -0,0 +1,7 @@
+class IncompatiableRequirementsError < StandardError
+  
+  def initialize(msg)
+    super(msg)
+  end
+  
+end

data/lib/error/InvalidStatementError.rb

@@ -0,0 +1,7 @@
+class InvalidStatementError < StandardError
+  
+  def initialize(msg)
+    super(msg)
+  end
+  
+end

data/lib/error/MethodSizeError.rb

@@ -0,0 +1,7 @@
+class MethodSizeError < StandardError
+  
+  def initialize(msg)
+    super(msg)
+  end
+  
+end

data/lib/error/RuntimeSyntaxError.rb

@@ -0,0 +1,7 @@
+class RuntimeSyntaxError < StandardError
+  
+  def initialize(msg='')
+    super(msg)
+  end
+  
+end

data/lib/error/UnexpectedStatementTypeError.rb

@@ -0,0 +1,7 @@
+class UnexpectedStatementTypeError < StandardError
+  
+  def initialize(msg)
+    super(msg)
+  end
+  
+end

data/lib/error/UnknownStatementType.rb

@@ -0,0 +1,7 @@
+class UnknownStatementType < StandardError
+  
+  def initialize(msg)
+    super(msg)
+  end
+  
+end

data/lib/error/UnliteralisableError.rb

@@ -0,0 +1,7 @@
+class UnliteralisableError < StandardError
+  
+  def initialize(msg)
+    super(msg)  
+  end
+  
+end

data/lib/implemented_chain.rb

@@ -0,0 +1,34 @@
+# This represents a chain that doesn't contain any theory variables.  All the variables
+# have been replaced with intrinsic/real values.
+#
+class ImplementedChain
+  
+  # 
+  #
+  # 
+  def initialize(nodes)
+    @nodes = nodes
+  end
+  
+  def each(&block)
+    @nodes.each(&block)
+  end  
+  
+  # TODO  Note sure how I feel about this direct access
+  def [](index)
+    return @nodes[index]
+  end  
+  
+  def length
+    return @nodes.length
+  end  
+  
+  def describe(tab=0)
+    return @nodes.inject('') {|total,x| total += x.describe}
+  end
+  
+  def write(tab=0)
+    return @nodes.inject('') {|total,x| total += x.write}
+  end  
+  
+end

data/lib/intrinsic/IntrinsicLastRuntimeMethod.rb

@@ -0,0 +1,20 @@
+# This represents any reference to main runtime method instance 
+# within theories.
+#
+class IntrinsicLastRuntimeMethod  < IntrinsicObject
+  include Token
+ 
+  def initialize(intrinsic_object_id=nil)
+    @intrinsic_object_id = intrinsic_object_id
+    super()
+  end
+  
+  def write
+    return 'last_runtime_method'
+  end
+  
+  def describe
+    return '<last_runtime_method>'
+  end
+  
+end

data/lib/intrinsic/IntrinsicLiteral.rb

@@ -0,0 +1,26 @@
+class IntrinsicLiteral < IntrinsicObject
+  include Token
+  
+  def initialize(value,intrinsic_object_id=nil)
+    @intrinsic_object_id = intrinsic_object_id
+    super()
+    @value = value
+  end
+  
+  def write
+    @value.write
+  end  
+  
+  def describe
+    @value.describe
+  end  
+  
+  def copy
+    return IntrinsicLiteral.new(@value,@intrinsic_object_id)
+  end    
+  
+  def literal
+    return @value
+  end
+  
+end