sfp 0.3.4 → 0.3.5

data/lib/sfp/Sfplib.rb

@@ -164,13 +164,19 @@ module Sfp
 
 	# Instance of this class will be returned as the value of a non-exist variable
 	class Undefined
+		def self.create(type)
+			@@list = {} if !defined? @@list
+			return @@list[type] if @@list.has_key?(type)
+			(@@list[type] = Undefined.new(nil, type))
+		end
+
 		attr_accessor :path, :type
 		def initialize(path=nil, type=nil)
 			@path = path
 			@type = type
 		end
 		def to_s
-			(@path.nil? ? "<sfp::undefined>" : "<sfp::undefined[#{@path}]>")
+			(@path.nil? ? "<sfp::undefined[#{type}]>" : "<sfp::undefined[#{type}][#{@path}]>")
 		end
 	end
 
@@ -365,3 +371,18 @@ String.send(:define_method, 'to_top') {
 	return self[0, self.length - parts[parts.length-1].length - 1]
 }
 
+String.send(:define_method, 'simplify') {
+	return self if not self.isref
+	ids = self.split('.')
+	i = 0
+	until i >= ids.length do
+		if i >= 3 and ids[i] == 'parent'
+			ids.delete_at(i)
+			ids.delete_at(i-1)
+			i -= 1
+		else
+			i += 1
+		end
+	end
+	ids.join('.')
+}

data/lib/sfp/sas_translator.rb

@@ -54,6 +54,16 @@ module Sfp
 		attr_reader :variables, :types, :operators, :axioms, :goals
 
 		def to_sas
+			self.compile_step_1
+			self.compile_step_2
+			return self.sas
+		end
+
+		def compile_step_2
+			self.postprocess_simple_global_constraint
+		end
+
+		def compile_step_1
 			begin
 				@unknown_value = ::Sfp::Unknown.new
 
@@ -179,7 +189,6 @@ module Sfp
 
 				@vars = @variables.values
 
-				return create_output
 			rescue Exception => e
 				raise e
 			end
@@ -284,13 +293,173 @@ module Sfp
 			end
 		end
 
+		#####
+		# Method for postprocessing simple global constraints
+		#####
+		def postprocess_simple_global_constraint
+			@operators.keys.each do |name|
+				operator = @operators[name]
+				@operators.delete(name)
+
+				postprocess_simple_global_constraint_to_operator(operator).each { |op|
+					@operators[op.name] = op
+				}
+			end
+		end
+
+		def postprocess_simple_global_constraint_to_operator(operator)
+			return [operator] if GlobalConstraintMethod == 2
+
+			def enforce_equals_constraint(operator, var, val)
+				if operator.has_key?(var)
+					return nil if !operator[var].pre.nil? or operator[var].pre != val
+					operator[var].pre = val
+				else
+					operator[var] = Parameter.new(@variables[var], val)
+				end
+				operator
+			end
+
+			if @global_simple_conjunctions.is_a?(Hash)
+				# simple conjunction
+				@global_simple_conjunctions.each do |var,c|
+					if c['_type'] == 'and'
+						c.each { |k,v| return [] if enforce_equals_constraint(operator, k, v['_value']).nil? }
+					else c['_type'] == 'equals'
+						return [] if enforce_equals_constraint(operator, var, c['_value']).nil?
+					end
+				end
+			end
+
+			# TODO - test with premise and conclusion clauses have > 1 statements
+			#
+			# pre |= premise
+			def pre_support_premise(operator, premise)
+				premise.each { |var,c|
+					next if var[0,1] == '_'
+					return false if !operator.has_key?(var) or (!operator[var].pre.nil? and c['_value'] != operator[var].pre)
+				}
+				true
+			end
+
+			def post_threat_conclusion(operator, conclusion)
+				conclusion.each { |var,c|
+					next if var[0,1] == '_'
+					if operator.has_key?(var) and !operator[var].post.nil? and operator[var].post != c['_value']
+						return true
+					end
+				}
+				false
+			end
+
+			return [operator] if not @global_simple_implications.is_a?(Hash)
+
+			@global_simple_implications.each do |id,imply|
+				# If the operator's precondition support the premise, then
+				# it should support the conclusion as well.
+				if pre_support_premise(operator, imply['_premise'])
+					imply['_conclusion'].each { |var,c|
+						next if var[0,1] == '_'
+						if operator.has_key?(var)
+							if operator[var].pre.nil? # enforce the operator to support the conclusion
+								operator[var].pre = c['_value']
+							end
+							# this operator's does not support conclusion, then remove it from operators list
+							return [] if operator[var].pre != c['_value']
+						else
+							# enforce the operator to support the conclusion
+							operator[var] = Parameter.new(@variables[var], c['_value'])
+						end
+					}
+				end
+			end
+			
+			results = []
+			@global_simple_implications.each do |id,imply|
+				imply['_premise'].each do |var,c|
+					next if var[0,1] == '_'
+					@variables[var].not(c['_value']).each { |x|
+						op = operator.clone
+						if op.has_key?(var)
+							if op[var].pre != x
+								op[var].pre == x
+								results << op
+							end
+						else
+							op[var] = Parameter.new(@variables[var], x)
+							results << op
+						end
+					}
+				end if post_threat_conclusion(operator, imply['_conclusion'])
+			end
+			return [operator] if results.length <= 0
+			results
+		end
+
+		def preprocess_simple_global_constraint
+			return if GlobalConstraintMethod == 2
+
+			def conjunction_only(id, f)
+				#return true if @variables.has_key?(id) and f['_type'] == 'equals'
+				return true if f['_type'] == 'equals'
+				if f['_type'] == 'and'
+					f.each { |k,v| return false if k[0,1] != '_' and not conjunction_only(k, v) }
+					return true
+				end
+
+				false
+			end
+
+			def simple_formulae(id, f)
+				if f['_type'] == 'imply'
+					f.each { |k,v| return false if k[0,1] != '_' and not conjunction_only(k, v) }
+					return true
+				end
+				conjunction_only(id, f)
+			end
+
+			global = @root['global']
+			simples = global.select { |k,v| k[0,1] != '_' and simple_formulae(k, v) }
+
+			@global_simple_conjunctions = {}
+			@global_simple_implications = {}
+			simples.each do |id,constraint|
+				case constraint['_type']
+				when 'equals', 'and'
+					raise TranslationException, 'Invalid global constraint' if not normalize_formula(constraint)
+					@global_simple_conjunctions[id] = constraint
+				when 'imply'
+					constraint.keys.each { |k|
+						next if k[0,1] == '_'
+						raise TranslationException, 'Invalid global constraint' if not normalize_formula(constraint[k])
+						constraint[k].select { |k,v| k[0,1] != '_' }
+						constraint['_premise'] = constraint[k] if constraint[k]['_subtype'] == 'premise'
+						constraint['_conclusion'] = constraint[k] if constraint[k]['_subtype'] == 'conclusion'
+					}
+					@global_simple_implications[id] = constraint
+				else
+					raise Exception, "Bug: non-simple formulae detected - #{constraint['_type']}"
+				end
+				global.delete(id)
+			end
+		end
+		##### End of methods for processing simple global constraints #####
+
+
 		def process_global_constraint
+			@total_complex_global_constraints = 0
+
 			### normalize global constraint formula ###
 			if @root.has_key?('global') and @root['global'].isconstraint
+				preprocess_simple_global_constraint
+
+				keys = @root['global'].keys.select { |k| k[0,1] != '_' }
+				@total_complex_global_constraints = keys.length
+
 				raise TranslationException, 'Invalid global constraint' if 
 						not normalize_formula(@root['global'], true)
 
-				if GlobalConstraintMethod == 1
+				if GlobalConstraintMethod == 1 and @total_complex_global_constraints > 0
 					# dummy variable
 					@global_var = Variable.new(GlobalVariable, '$.Boolean', -1, false, true)
 					@global_var << true
@@ -400,6 +569,10 @@ module Sfp
 		end
 
 		def create_output
+			self.to_s
+		end
+
+		def sas
 			# version
 			out = "begin_version\n3\nend_version\n"
 			# metric
@@ -455,6 +628,7 @@ module Sfp
 					ops += op.to_sas(@root['initial'], @variables) + "\n"
 					total += 1
 				rescue Exception => exp
+					#puts "#{exp}\n#{exp.backtrace.join("\n")}"
 				end
 			}
 			out += "#{total}\n"
@@ -591,10 +765,12 @@ module Sfp
 				sas_op[@variables[k].name] = Parameter.new(@variables[k], pre, post)
 			}
 
-			if GlobalConstraintMethod == 1
+			if GlobalConstraintMethod == 1 and @total_complex_global_constraints > 0
 				@operators[sas_op.name] = sas_op if apply_global_constraint_method_1(sas_op)
 			elsif GlobalConstraintMethod == 2 or GlobalConstraintMethod == 3
 				@operators[sas_op.name] = sas_op if apply_global_constraint_method_2(sas_op)
+			else
+				@operators[sas_op.name] = sas_op
 			end
 		end
 
@@ -795,9 +971,11 @@ module Sfp
 			return true
 		end
 
-		# normalize the given first-order formula by transforming it into
-		# DNF 
+		# normalize the given first-order formula by transforming it to DNF
+		#
 		def normalize_formula(formula, dump=false)
+			{:formula => formula}.accept(ImplicationToDisjunction)
+
 			def create_equals_constraint(value)
 				return {'_context'=>'constraint', '_type'=>'equals', '_value'=>value}
 			end
@@ -1283,6 +1461,16 @@ module Sfp
 		end
 
 
+		ImplicationToDisjunction = Object.new
+		def ImplicationToDisjunction.visit(name, value, parent)
+			return if !value.is_a?(Hash)
+			if value['_type'] == 'imply'
+				value['_type'] = 'or'
+				value.each_value { |f| f['_type'] = 'not' if f['_subtype'] == 'premise' }
+			end
+			true
+		end
+
 		### Helper Classes ###
 
 		class VariableNotFoundException < Exception; end
@@ -1367,14 +1555,6 @@ module Sfp
 			end
 	
 			def get_type(name, value, parent)
-=begin
-				type = self.isa?(value)
-				if type == nil and parent.is_a?(Hash) and parent.has_key?('_isa')
-					isa = @main.root.at?(parent['_isa'])
-					type = isa.type?(name) if isa != nil
-					return type if type != nil
-				end
-=end
 				return value.type if value.is_a?(Sfp::Undefined)
 
 				type = nil
@@ -1386,7 +1566,7 @@ module Sfp
 					end
 				end
 				type = self.isa?(value)
-	
+
 				return "(#{value['_isa']})" if value.is_a?(Hash) and value.isset and value.has_key?('_isa')
 	
 				return nil if type == nil
@@ -1585,6 +1765,10 @@ module Sfp
 			}
 			return sas += "end_variable"
 		end
+
+		def not(x)
+			self.select { |y| y != x }
+		end
 	end
 
 	# A class for Grounded Operator
@@ -1693,7 +1877,8 @@ module Sfp
 		end
 
 		def to_s
-			return @name + ': ' + self.length.to_s
+			#return @name + ': ' + self.length.to_s
+			return @name + ": " + (self.map { |k,v| v.to_s }).join("|")
 		end
 
 		def to_sas(root, variables)
@@ -1769,12 +1954,24 @@ module Sfp
 			return 'axiom#' + @id.to_s
 		end
 
-		def to_sas
-			#TODO
+		def to_sas(root, variables)
+			prevails = select { |var,param| param.post.nil? }
+			preposts = select { |var,param| !param.post.nil? }
+			raise Exception, "Invalid axiom: total preposts > 1" if preposts.length > 1
+			raise Exception, "Invalid axiom: total preposts <= 0" if preposts.length <= 0
+
+			sas = "begin_rule"
+			sas += "\n#{prevails.length}"
+			prevails.each { |var,param| sas += "\n" + param.to_sas(root, variables) }
+			preposts.each { |var,param| sas += "\n" + param.to_sas(root, variables) }
+			sas += "\nend_rule"
+			return sas
 		end
 	end
 
 	# A class for operator/axiom parameter (prevail or effect condition)
+	# :pre = nil - it can be anything (translated to -1)
+	# :post = nil - variable's value doesn't change
 	class Parameter
 		attr_accessor :var, :pre, :post
 
@@ -1806,7 +2003,7 @@ module Sfp
 			pre = ( (pre.is_a?(Hash) and pre.isnull) ? 0 : (pre == nil ? -1 : @var.index(pre)) )
 			post = ( (post.is_a?(Hash) and post.isnull) ? 0 : @var.index(post) )
 
-			raise TranslationException if not prevail and post.nil?
+			raise Exception, self.to_s if not prevail and post.nil?
 
 			return "#{@var.id} #{pre}" if post.nil?
 			return "0 #{@var.id} #{pre} #{post}"

data/sfp.gemspec

@@ -1,7 +1,7 @@
 Gem::Specification.new do |s|
 	s.name			= 'sfp'
-	s.version		= '0.3.4'
-	s.date			= '2013-07-14'
+	s.version		= '0.3.5'
+	s.date			= '2013-07-15'
 	s.summary		= 'SFP Parser'
 	s.description	= 'A Ruby API and script for SFP language parser'
 	s.authors		= ['Herry']

data/src/SfpLang.g

@@ -522,11 +522,7 @@ nested_constraint
 constraint
 	:	ID 'constraint'
 		{
-			@now[$ID.text] = { '_self' => $ID.text,
-				'_context' => 'constraint',
-				'_type' => 'and',
-				'_parent' => @now
-			}
+			@now[$ID.text] = self.create_constraint($ID.text, 'and')
 			@now = @now[$ID.text]
 		}
 		'{' NL* constraint_body '}' NL+
@@ -559,21 +555,13 @@ constraint_iterator
 	:	'foreach' '(' path 'as' ID ')' NL* '{' NL+
 		{
 			id = self.next_id.to_s
-			@now[id] = { '_parent' => @now,
-				'_context' => 'constraint',
-				'_type' => 'iterator',
-				'_self' => id,
-				'_value' => '$.' + $path.text,
-				'_variable' => $ID.text
-			}
+			@now[id] = self.create_constraint(id, 'iterator')
+			@now[id]['_value'] = '$.' + $path.text
+			@now[id]['_variable'] = $ID.text
 			@now = @now[id]
 			
 			id = '_template'
-			@now[id] = { '_parent' => @now,
-				'_context' => 'constraint',
-				'_type' => 'and',
-				'_self' => id,
-			}
+			@now[id] = self.create_constraint(id, 'and')
 			@now = @now[id]
 		}
 		(constraint_statement
@@ -608,11 +596,7 @@ constraint_class_quantification
 			@now = @now[id]
 
 			id = '_template'
-			@now[id] = { '_parent' => @now,
-				'_context' => 'constraint',
-				'_type' => 'and',
-				'_self' => id
-			}
+			@now[id] = self.create_constraint(id, 'and')
 			@now = @now[id]
 		}
 		(	(	binary_comp
@@ -746,10 +730,7 @@ conditional_constraint returns [key, val]
 	:	'if'
 		{
 			$key = id = self.next_id.to_s
-			@now[id] = { '_parent' => @now,
-				'_context' => 'constraint',
-				'_type' => 'or'
-			}
+			@now[id] = self.create_constraint(id, 'imply')
 			@now = @now[id]
 		}
 		conditional_constraint_if_part
@@ -761,16 +742,15 @@ conditional_constraint_if_part
 	:	constraint_statement NL*
 		{
 			id = self.next_id
-			@now[id] = { '_parent' => @now,
-				'_context' => 'constraint',
-				'_type' => 'not'
-			}
+			@now[id] = self.create_constraint(id, 'and')
+			@now[id]['_subtype'] = 'premise'
 			@now[id][$constraint_statement.key] = $constraint_statement.val
 		}
 	|	'{'
 		{
 			id = self.next_id
-			@now[id] = self.create_constraint(id, 'not')
+			@now[id] = self.create_constraint(id, 'and')
+			@now[id]['_subtype'] = 'premise'
 			@now = @now[id]
 		}
 		NL+ constraint_body
@@ -782,19 +762,15 @@ conditional_constraint_then_part
 	:	'then' constraint_statement
 		{
 			id = self.next_id
-			@now[id] = { '_parent' => @now,
-				'_context' => 'constraint',
-				'_type' => 'and'
-			}
+			@now[id] = self.create_constraint(id, 'and')
+			@now[id]['_subtype'] = 'conclusion'
 			@now[id][$constraint_statement.key] = $constraint_statement.val
 		}
 	|	'then'
 		{
 			id = self.next_id
-			@now[id] = { '_parent' => @now,
-				'_context' => 'constraint',
-				'_type' => 'and'
-			}
+			@now[id] = self.create_constraint(id, 'and')
+			@now[id]['_subtype'] = 'conclusion'
 			@now = @now[id]
 		}
 		'{' NL+ constraint_body '}'