dbc 1.3.0 → 2.0.0

data/lib/caphir/preprocessor_conf.rb

@@ -0,0 +1,153 @@
+# If there are additional platform specific options that
+# belong in this file, please contribute them.
+
+# Removes dots and zero pads
+def expand_version(pre, version)
+	version.delete!('.')
+	(3 - version.length).times { version << '0' }
+	"#{pre}#{version}"
+end
+
+class Preprocessor::Parser
+
+	def configure(options, includes, compiler=nil, version=nil)
+	
+		# __FILE__ and __LINE__ macros are define in preprocessor.y
+
+		# so '##' is used to paste tokens, not '/**/'
+		self.define('__STDC__', nil, '1')
+		self.define('__STDC_VERSION__', nil, '199901L')
+		comp_time = Time.now
+		self.define('__DATE__', nil, comp_time.strftime('%m %d %Y'))
+		self.define('__TIME__', nil, comp_time.strftime('%H:%M:%S'))
+	
+		case RUBY_PLATFORM
+			when /i[0-9]86/
+				self.define('__i386__', nil, '1')
+			when /powerpc/
+				self.define('__ppc__', nil, '1')
+#			when /ia64/
+#				self.define('__ia64__', nil, '1')
+			else
+				warn "unrecognized platform: #{RUBY_PLATFORM}"
+		end
+		
+		case RUBY_PLATFORM
+			#when /darwin/
+			#when /netbsd/
+			when /mswin32/
+				self.define('__WIN32', nil, '1')
+			when /cygwin/
+				self.define('__WIN32', nil, '1')
+				self.define('__CYGWIN__', nil, '1')
+			when /mingw/
+				self.define('__WIN32', nil, '1')
+				self.define('__MINGW32__', nil, '1')
+			#when /bccwin/
+			#when /os2/
+			#when /sparc/
+			#when /AIX/
+		end
+
+		case compiler # gcc is the default
+			when nil, 'gcc'
+				
+				warn "invalid gcc version (got #{version} expecting major.minor.patch_level)" \
+					if version and not version =~ /\A(\d+)\.(\d+)(?:\.(\d+))?\Z/
+	
+				# defaults to gcc 3.3.0
+				self.define('__GNUC__', nil, $1 || '3')
+				self.define('__GNUC_MINOR__', nil, $2 || '3')
+				self.define('__GNUC_PATCHLEVEL__', nil, $3 || '0') # default must be '0'
+	
+				self.define('__complex__', nil, '_Complex')
+
+				# define all these as blank
+				empty_str = ''.freeze
+				self.define('__asm__', ['...'], empty_str)
+				self.define('__attribute__', ['...'], empty_str)
+
+				# this is now handled by the parser
+				#self.define('throw', ['...'], empty_str)
+
+				# note that __cdecl is included here
+				[	'__const__', '__extension__', '__inline__',
+					'__signed__', '__volatile__', '__cdecl' ].each do |kw|
+					self.define(kw, nil, empty_str)
+				end
+
+				self.define('__restrict_arr', nil, 'restrict')
+				
+				# define psuedo-ANSI C keywords.  Note these
+				# may be redefined later in the code
+				[ '__const', '__inline', '__restrict', '__signed', '__volatile' ].each do |kw|
+					self.define(kw, nil, kw[2, kw.length-2])
+				end
+	
+				# for gcc 3.4+ compatibility
+				self.define('__GLIBC_HAVE_LONG_LONG', nil, '1')
+				self.define('__builtin_va_list', nil, 'int *')
+				self.define('SHLIB_COMPAT', ['...'], '(0)')
+				
+			when 'vc++'
+				# win32 should already be defined
+	
+				self.define('__cdecl', nil, ' ')
+				# make up a time stamp
+				self.define('__TIMESTAMP__', nil, comp_time.strftime('%a %b %d %H:%M:%S %y'))
+	
+				# default version is 6.0 => 1200
+				version = version ? ((version.to_f + 6) * 100).to_i.to_s : '1200'
+				self.define('_MSC_VER', nil, version)
+	
+				# Not sure if these should be added
+				#if RUBY_PLATFORM =~ /i[0-9]86/
+				#	self.define('_M_IX86', nil, '500') # default
+				#else
+				#	self.define('_M_MPPC', nil, '601') # default
+				#	self.define('_M_PPC', nil, '604') # default
+				#end
+			when 'tinyc'
+				# tinyc compilers do not specify version numbers
+				self.define('__TINYC__', nil, '1')
+			
+			when 'turboc'
+				warn "ignoring version number, defaulting to 3.0" if version
+				self.define('__TURBOC__', nil, '661') # 3.0
+	
+			when 'borland'
+				version = version ? expand_version('0x', version) : '0x550'
+				self.define('__BORLANDC__', nil, version)
+	
+			when 'intel'
+				version = version ? expand_version(nil, version) : '600'
+				self.define('__INTEL_COMPILER', nil, version)
+				self.define('__ICC', nil, version)
+	
+			when 'mars'
+				version = version ? expand_version('0x', version) : '0x800'
+				self.define('__DMC__', nil, version)
+	
+			when 'watcom'
+				version = version ? expand_version(version) << '0' : '1100'
+				self.define('__WATCOMC__', nil, version)
+	
+			else
+				warn "unrecognized compiler: #{compiler}"
+				exit(2)
+		end # case
+		
+		# options should be applied after the preprocessor is configured
+		options.each do |opt|
+			if opt[0] == :DEFINE
+				self.define(opt[1], opt[2], opt[3])
+			elsif opt[0] == :UNDEF
+				self.undef(opt[1])
+			else
+				raise "impossible"
+			end
+		end
+		includes.each { |f| self.include_arg(f) }
+	end
+end
+

data/lib/dbc/dbc.rb

@@ -3,8 +3,8 @@
 # THIS SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND.
 # See included LICENCE file.
 
-require 'dbc/ctokenizer'
-require 'dbc/ctype'
+require 'caphir/ctokenizer'
+require 'caphir/ctype'
 require 'dbc/ocl'
 
 module DBC
@@ -25,50 +25,72 @@ module DBC
 		str =~ /\A\/\*\*[ \t]*[\r\n]+(\s*\*?\s*(?:inv|pre|post|context).+)[ \t]*\*\/\Z/m
 		$1
 	end
-
-	class Cache < CTokenizer::LexerBase
+	
+	class Parser < CTokenizer::LexerBase
+		include CTokenizer::Scoped
 		def initialize(str, file=nil, line=1)
 			super(str, file, line)
-			@token_cache = CTokenizer::Cache.new(super.file, super.line)
+			
+			@scope = 0
+			@macro = false
+			@start_line = true # begining of file
+			
+			@contract = nil
+			@conditions = {} # hash of contracts
+			# @ctype_parser.parse(source) -> parses source until a compelete
+			# top level C statement has been parsed.  If the statement is a 
+			# function definition it stops when the opening '{' is reached.
+			@ctype_parser = CType::Parser.new()
 		end
 
-		def scan(re)
-			str = super
-			@token_cache << [:UNKNOWN, str.freeze].freeze
-			str
-		end
+		attr_reader :conditions
 
 		def shift
-			t = super
-			@token_cache << t
+			t = process_scope(super)
+			if t.at(0) == :COMMENT and start_of_line? and ocl = DBC.get_ocl(t.at(1))
+				self.error("no context for previous contract") if @contract
+				@contract = OCL::Parser.new(ocl, self.file, self.line - CTokenizer.line_count(ocl))
+				self.merge_current_contract() if @contract.context
+			end
 			t
 		end
 
-		def reset
-			cache = @token_cache
-			@token_cache = CTokenizer::Cache.new(self.file, self.line)
-			cache
-		end
-	end
-
-	def DBC.parse(source)
-		tokens = CTokenizer::SkipMacros.new(source)
-		ctype_parser = CType::Parser.new()
-		
-		until tokens.empty?
-			context = ctype_parser.parse(tokens)
-			f_body = false
-			unless tokens.scope == 0
-				yield([], f_body)
-				until tokens.scope == 0 or tokens.empty?
-					# get back to group zero
-					tokens.shift
+		def each_statement
+			until @source.empty?
+				context = @ctype_parser.parse(self)
+				# if scope != 0 then we are in a function body
+				if f_body = (@scope != 0)
+					# first yield function header
+					yield(nil)
+					until @scope == 0 or @source.empty?
+						# get back to group zero
+						# don't check for contract comments
+						process_scope(@source.shift)
+					end
+				end #if
+				# add type definitions
+				context.each do |ctxt|
+					CType[ctxt.identifier] = ctxt if ctxt.typedef?
 				end
-				f_body = true
-			end
-			yield(context, f_body)
-		end
-	end # DBC.parse
+				if @contract
+					# the contract should have no context
+					#raise "impossible" if @contract.context
+					self.error("expecting one context for contract") unless context.length == 1
+					@contract.context = context.first
+					self.merge_current_contract()
+				end # if
+				yield(f_body ? context.first : nil)
+			end # until
+		end # each_statement
+
+		def merge_current_contract()
+			context = @contract.context
+			context = context.short_name unless context.class == String
+			@conditions[context] = @contract
+			@contract = nil # done with current contract
+		end
+
+	end # class Parser
 
 	def DBC.format_conditions(conditions)
 		outstr = ''
@@ -95,7 +117,9 @@ module DBC
 		until tokens.empty?
 			t = tokens.shift
 			# note: comments don't affect start_of_line?
-			if t[0] == :COMMENT and tokens.start_of_line? and str = DBC.get_ocl(t[1])
+			if t.at(0) == :COMMENT and \
+					tokens.start_of_line? and \
+					str = DBC.get_ocl(t.at(1))
 				context = nil
 				# take out context information
 				str.gsub!(/^[ \t]*\*?[ \t]*context[ \t]+(.+)$/) do
@@ -148,105 +172,17 @@ module DBC
 				# try to insert the tag after then next opening braket
 				if conditions.first[0] =~ /pre|post/ and not context
 					until tokens.empty?
-						t = tokens.shift
-						outstr << t[1]
-						break if t[1] == '{'
+						t = tokens.shift.at(1)
+						outstr << t
+						break if t == '{'
 					end
 				end
 				outstr << doc_str
 			else
-				outstr << t[1]
+				outstr << t.at(1)
 			end
 		end
 		outstr
 	end
-
-	class Parser < CTokenizer::LexerBase
-		include CTokenizer::Scoped
-		def initialize(str, file=nil, line=1)
-			super(str, file, line)
-			@token_cache = CTokenizer::Cache.new(super.file, super.line)
-			@scope = 0
-			@macro = false
-			@start_line = true # begining of file
-		end
-
-		def shift
-			process_scope(@token_cache.empty? ? super : @token_cache.shift)
-		end
-
-		def empty?
-			@token_cache.empty? and super
-		end
-
-		def file
-			if @token_cache.empty?
-				super
-			else
-				@token_cache.file
-			end
-		end
-
-		def line
-			if @token_cache.empty?
-				super
-			else
-				@token_cache.line
-			end
-		end
-
-	end # Parser
-
-	class OCLParser < Parser
-		
-		def initialize(str, file=nil, line=1)
-			super(str, file, line)
-			@conditions = {}
-			@ctype_parser = CType::Parser.new()
-		end
-
-		attr_reader :conditions
-		
-		def shift
-			t = super
-			# note: comments don't affect start_of_line?
-			if t.at(0) == :COMMENT and start_of_line? and ocl = DBC.get_ocl(t[1])
-				parse_ocl(ocl)
-			end
-			t
-		end
-
-private
-		def parse_ocl(str)
-			self.error("no context for previous contract") \
-					unless @token_cache.empty?
-			parser = OCL::Parser.new(str, self.file, self.line - CTokenizer.line_count(str))
-			self.error("no conditions given") if parser.conditions.empty?
-
-			unless parser.context
-				@token_cache.reset(self.file, self.line)
-				# Use the Splitter to cache the tokens used by the type parser
-				splitter = CTokenizer::Splitter.new(@token_cache, @source)
-				splitter = CTokenizer::SkipMacros.new(splitter)
-				context = @ctype_parser.parse(splitter)
-				self.error("multiple contexts given") unless context.length == 1
-				parser.context = context.first
-			end
-
-			if parser.conditions.last.type =~ /\A(?:pre|post)/
-				# should be followed by a function
-				self.error("pre and post conditions must be in the context of a function") \
-					unless parser.context.function?
-			end
-			
-			context_str = if parser.context.class == String
-				parser.context
-			else
-				parser.context.short_name
-			end
-			@conditions[context_str] = parser
-		end
-	end # OCLParser
-
 end # DBC
 

data/lib/dbc/expand_function.rb

@@ -3,7 +3,7 @@
 # THIS SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND.
 # See included LICENCE file.
 
-require 'dbc/ctokenizer'
+require 'caphir/ctokenizer'
 
 def expand_function(conditions, context, body, start_line, line_info)
 	raise 'should be a function' unless context.function?
@@ -11,11 +11,13 @@ def expand_function(conditions, context, body, start_line, line_info)
 	context_str = context.short_name
 	f_cond = conditions[context_str]
 
-	pre_text = ''		# preconditions
-	post_text = ''	# postconditions
-	inv_text = ''		# invariants
-	init_text = ''	# initializations
-	final_text = ''	# stuff at the end
+	outstr = ''
+	outstr << "\n"
+
+	pre_text = ''			# preconditions
+	post_text = ''		# postconditions
+	inv_text = ''			# invariants
+	final_text = ''		# stuff at the end
 
 	if f_cond
 		# get the conditions
@@ -37,8 +39,9 @@ def expand_function(conditions, context, body, start_line, line_info)
 			rescue CType::EvaluationError
 				raise CType::EvaluationError, "#{line_info}: in #{context_str}, #{$!} for #{identifier}"
 			end
-			init_text << "\t" << p_type.to_init_s(var_used)
-			init_text << ' = ' << identifier << ";\n"
+			# initializations
+			outstr << "\t" << p_type.to_init_s(var_used)
+			outstr << ' = ' << identifier << ";\n"
 		end
 	end
 
@@ -54,26 +57,18 @@ def expand_function(conditions, context, body, start_line, line_info)
 			inv_text << exp_str
 		end; end
 	end
-
-	void_return_type = (context.base_type.to_s == 'void')
-
-	unless void_return_type or \
-				(post_text.empty? and inv_text.empty?)
-		init_text << "\t" << context.base_type.to_init_s('ocl__ret_val') << ";\n"
-	end
 	
-	outstr = ''
-
 	if pre_text.empty? and post_text.empty? and inv_text.empty?
 		# we're done early
-		body.each do |t|
-			outstr << t.at(1)
-		end
-		return outstr
+		return body.collect! { |t| t.at(1) }.join
 	end
 
-	outstr << "\n" << init_text
+	void_return_type = (context.base_type.to_s == 'void')
 
+	unless void_return_type or (post_text.empty? and inv_text.empty?)
+		outstr << "\t" << context.base_type.to_init_s('ocl__ret_val') << ";\n"
+	end
+	
 	# output invariants and preconditions
 	outstr << "\t/* Invariants: */\n" << inv_text unless inv_text.empty?
 	outstr << "\t/* Preconditions: */\n" << pre_text unless pre_text.empty?
@@ -83,37 +78,39 @@ def expand_function(conditions, context, body, start_line, line_info)
 
 	# output function body
 	if post_text.empty? and inv_text.empty?
-		body.each do |t|
-			outstr << t.at(1)
-			start_line += CTokenizer.line_count(t.at(1))
-		end
+		outstr << body.collect! do |t|
+			start_line += CTokenizer.line_count(t = t.at(1))
+			t
+		end.join
 	else
 		output_label = false
-		body = body.dup
-		until body.empty?
-			t = body.shift
-			start_line += CTokenizer.line_count(t.at(1))
-			# replace return statements with goto statements.
-			# if a value is returned this value is saved in ocl__ret_val
-			if t.at(1) == 'return'
-				output_label = true
-				if void_return_type
-					outstr << 'goto ocl__return_here'
+		if void_return_type
+			outstr << body.collect do |t|
+				start_line += CTokenizer.line_count( t = t.at(1) )
+				if t == 'return'
+					output_label = true
+					'goto ocl__return_here'
 				else
+					t
+				end
+			end.join # do
+		else
+			until body.empty?
+				start_line += CTokenizer.line_count( t = body.shift.at(1) )
+				if t == 'return'
+					output_label = true
 					outstr << '{ ocl__ret_val = ( '
-					loop do
-						raise "syntax error" if body.empty?
-						t = body.shift
-						start_line += CTokenizer.line_count(t.at(1))
-						break if t.at(1) == ';'
-						outstr << t.at(1)
+					until body.empty?
+						start_line += CTokenizer.line_count( t = body.shift.at(1) )
+						break if t == ';'
+						outstr << t
 					end
 					outstr << ' ); goto ocl__return_here; }'
+				else
+					outstr << t
 				end
-			else # output all other tokens
-				outstr << t.at(1)
-			end
-		end
+			end # until
+		end # if
 		outstr << "\nocl__return_here:\n" if output_label
 		# must explicitly return the return value unless return value is void
 		final_text << "\treturn ocl__ret_val;\n" unless void_return_type