dbc 1.1.0

data/lib/dbc/dbc.rb

@@ -0,0 +1,237 @@
+# Copyright (c) 2004 Charles M Mills
+# This document is licenced under The MIT Licence.
+# THIS SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND.
+# See included LICENCE file.
+
+require 'dbc/ctokenizer'
+require 'dbc/ctype'
+require 'dbc/ocl'
+
+module DBC
+	NONE = 0
+	PRE = 1
+	ALL = 2
+
+	def DBC.valid_check_level?(c)
+		case c
+			when NONE, PRE, ALL
+				true
+			else
+				false
+		end
+	end
+
+	def DBC.get_ocl(str)
+		str =~ /\A\/\*\*[ \t]*[\r\n]+(.+)[ \t]*\*\/\Z/m
+		$1
+	end
+
+	class Cache < CTokenizer::LexerBase
+		def initialize(str, file=nil, line=1)
+			super(str, file, line)
+			@token_cache = CTokenizer::Cache.new(super.file, super.line)
+		end
+
+		def shift
+			t = super
+			@token_cache << t
+			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
+				end
+				f_body = true
+			end
+			yield(context, f_body)
+		end
+	end # DBC.parse
+
+	def DBC.format_conditions(conditions)
+		outstr = ''
+		conditions.each do |type, label, conds|
+			outstr << case type
+				when 'pre' then '\\pre'
+				when 'post' then '\\post'
+				when 'inv' then '\\invariant'
+			end << ' '
+			if label and not label.empty?
+				outstr << label << ': '
+			end
+			outstr << "\\code\n" << conds << "\n\\endcode\n"
+		end
+		outstr
+	end
+
+	# kinda ugly...
+	def DBC.parse_docs(tokens)
+		tokens = CTokenizer::SkipMacros.new(tokens)
+		ctype_parser = CType::Parser.new()
+		outstr = ''
+		
+		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])
+				context = nil
+				# take out context information
+				str.gsub!(/^[ \t]*context[ \t]+(.+)$/) do
+					if context
+						source.error("multiple contexts given: '#{context.to_s}' and '#{$1}'")
+					end
+					context = ctype_parser.parse($1 << ';')
+					context = context.first
+					'' # replace with an empty string
+				end
+				conditions = []
+				str.scan(/^[ \t]*(pre|post|inv)[ \t]*([^:]*):|\Z/) do
+					conditions.push([$1, $2]) if $1
+				end
+				statements = str.split(/^[ \t]*(?:pre|post|inv)[^:]*:|\Z/)
+				statements.shift # remove first element
+				conditions.zip(statements) do |cond, stmt|
+					cond.push(stmt)
+				end
+				# condition is an array of arrays like so:
+				# [ ['pre', 'msg', 'statment'], ['post', 'msg', 'stmt'], ...]
+
+				doc_str = ''
+				# open Doxygen tag
+				doc_str << '/*!'
+				if context
+					doc_str << if context.function?
+						'\\fn' << context.to_init_s << "\n"
+					else
+						context = context.to_s
+						if context =~ /\A(?:struct|union|enum)\W/
+							'\\' << context << "\n"
+						else
+							'\\typedef' << context << "\n"
+						end
+					end
+				end
+				doc_str << DBC.format_conditions(conditions) << '*/'
+				# if no context is given and we have function
+				# 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] == '{'
+					end
+				end
+				outstr << doc_str
+			else
+				outstr << t[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[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?
+			count = CTokenizer.line_count(str)
+			parser = OCL::Parser.new(str, self.file, self.line - count)
+			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/define.rb

@@ -0,0 +1,302 @@
+#
+# DO NOT MODIFY!!!!
+# This file is automatically generated by racc 1.4.4
+# from racc grammer file "src/define.y".
+#
+
+require 'racc/parser'
+
+
+
+require 'dbc/parameters'
+require 'dbc/parseerrorhandler'
+
+
+module Preprocessor
+
+  class Define < Racc::Parser
+
+module_eval <<'..end src/define.y modeval..id6f1b6c1f3b', 'src/define.y', 75
+
+	def initialize(params, tokens)
+		if params and not params.class == Parameters
+			@params = Parameters.new
+			params.each { |p| @params << p }
+		else
+			@params = params
+		end
+		@value = tokens.to_s
+	end
+
+	#attr_reader :file, :line
+
+	def takes_args?
+		@params != nil and not @params.empty?
+	end
+
+	# get the value of the macro
+	# 1) substitute macro function parameters if any
+	# note function parameters should NOT be resolved
+	# 2) stringify macro function parameters
+	# 3) concat tokens using ## operator
+	# 4) (happens after call to tokens) repeat 1) for each identifier
+	def value(stack)
+		if takes_args?
+			args = @params.get_args(stack)
+		end
+		evaluate(args)
+	end
+
+	def to_s
+		@value
+	end
+
+	def inspect
+		"\#<#{self.class}:#{self.to_s}>"
+	end
+	
+protected
+
+	def evaluate(args)
+		str = @value
+		@q = []
+		until str.empty?
+			@q << case str 
+				# this works because all spaces, comments and newlines were
+				# replaced by a single space by the preprocessor
+				when /\A[ \t]*##[ \t]*/o
+					str = $'
+					['##', $&].freeze
+				when /\A#[ \t]*/o
+					str = $'
+					['#', '#'].freeze
+				else
+					token, str = CTokenizer.split_token(str)
+					if (args and token[0] == :IDENTIFIER and idx = @params.index(token[1]))
+						[:PARAMETER, args[idx]].freeze
+					else
+						token
+					end
+			end # case
+		end # until
+		@q << [false, false]
+		do_parse
+	end
+
+	include ParseErrorHandler
+
+	def next_token
+		@q.shift
+	end
+
+..end src/define.y modeval..id6f1b6c1f3b
+
+##### racc 1.4.4 generates ###
+
+racc_reduce_table = [
+ 0, 0, :racc_error,
+ 1, 15, :_reduce_none,
+ 1, 15, :_reduce_none,
+ 0, 17, :_reduce_3,
+ 1, 16, :_reduce_4,
+ 2, 16, :_reduce_5,
+ 1, 18, :_reduce_none,
+ 1, 18, :_reduce_none,
+ 1, 18, :_reduce_none,
+ 1, 19, :_reduce_none,
+ 3, 19, :_reduce_10,
+ 1, 22, :_reduce_none,
+ 1, 22, :_reduce_none,
+ 1, 22, :_reduce_none,
+ 1, 22, :_reduce_none,
+ 1, 22, :_reduce_none,
+ 1, 22, :_reduce_none,
+ 1, 22, :_reduce_none,
+ 1, 22, :_reduce_none,
+ 1, 22, :_reduce_none,
+ 2, 21, :_reduce_20,
+ 1, 23, :_reduce_none,
+ 1, 20, :_reduce_none ]
+
+racc_reduce_n = 23
+
+racc_shift_n = 27
+
+racc_action_table = [
+     5,     6,     8,    10,    12,    14,    16,    18,     1,    23,
+     4,     5,     6,     8,    10,    12,    14,    16,    18,     1,
+     1,     4,     6,     8,    10,    12,    14,    16,    18,     1,
+    24,    26,    21 ]
+
+racc_action_check = [
+     0,     0,     0,     0,     0,     0,     0,     0,     0,    15,
+     0,     9,     9,     9,     9,     9,     9,     9,     9,     9,
+     4,     9,    23,    23,    23,    23,    23,    23,    23,    23,
+    21,    23,     7 ]
+
+racc_action_pointer = [
+    -3,   nil,   nil,   nil,     9,   nil,   nil,    32,   nil,     8,
+   nil,   nil,   nil,   nil,   nil,    -3,   nil,   nil,   nil,   nil,
+   nil,    30,   nil,    18,   nil,   nil,   nil ]
+
+racc_action_default = [
+    -3,   -21,    -9,   -18,   -19,   -22,   -11,   -23,   -17,    -1,
+   -12,    -2,   -13,    -4,   -14,    -6,   -15,    -7,   -16,    -8,
+   -20,   -23,    -5,   -23,    27,   -10,   -19 ]
+
+racc_goto_table = [
+    13,     7,    11,     9,    25,    20,   nil,   nil,   nil,    22 ]
+
+racc_goto_check = [
+     4,     1,     3,     2,     8,     9,   nil,   nil,   nil,     4 ]
+
+racc_goto_pointer = [
+   nil,     1,     3,     2,     0,   nil,   nil,   nil,   -19,     1 ]
+
+racc_goto_default = [
+   nil,   nil,   nil,   nil,   nil,    15,    17,    19,     2,     3 ]
+
+racc_token_table = {
+ false => 0,
+ Object.new => 1,
+ :STRINGIFY => 2,
+ :SPACE => 3,
+ :SYMBOL => 4,
+ :UNKNOWN => 5,
+ :CHARACTER => 6,
+ :STRING => 7,
+ :FLOAT => 8,
+ :INTEGER => 9,
+ :IDENTIFIER => 10,
+ :PARAMETER => 11,
+ "##" => 12,
+ "#" => 13 }
+
+racc_use_result_var = true
+
+racc_nt_base = 14
+
+Racc_arg = [
+ racc_action_table,
+ racc_action_check,
+ racc_action_default,
+ racc_action_pointer,
+ racc_goto_table,
+ racc_goto_check,
+ racc_goto_default,
+ racc_goto_pointer,
+ racc_nt_base,
+ racc_reduce_table,
+ racc_token_table,
+ racc_shift_n,
+ racc_reduce_n,
+ racc_use_result_var ]
+
+Racc_token_to_s_table = [
+'$end',
+'error',
+'STRINGIFY',
+'SPACE',
+'SYMBOL',
+'UNKNOWN',
+'CHARACTER',
+'STRING',
+'FLOAT',
+'INTEGER',
+'IDENTIFIER',
+'PARAMETER',
+'"##"',
+'"#"',
+'$start',
+'target',
+'token_sequence',
+'empty_target',
+'token',
+'token_expression',
+'white_space',
+'stringify_parameter',
+'basic_token',
+'parameter']
+
+Racc_debug_parser = false
+
+##### racc system variables end #####
+
+ # reduce 0 omitted
+
+ # reduce 1 omitted
+
+ # reduce 2 omitted
+
+module_eval <<'.,.,', 'src/define.y', 23
+  def _reduce_3( val, _values, result )
+ result = ''
+   result
+  end
+.,.,
+
+module_eval <<'.,.,', 'src/define.y', 27
+  def _reduce_4( val, _values, result )
+ result = val[0].dup
+   result
+  end
+.,.,
+
+module_eval <<'.,.,', 'src/define.y', 28
+  def _reduce_5( val, _values, result )
+ result = val[0] << val[1]
+   result
+  end
+.,.,
+
+ # reduce 6 omitted
+
+ # reduce 7 omitted
+
+ # reduce 8 omitted
+
+ # reduce 9 omitted
+
+module_eval <<'.,.,', 'src/define.y', 39
+  def _reduce_10( val, _values, result )
+ result = val[0] +  val[2]
+   result
+  end
+.,.,
+
+ # reduce 11 omitted
+
+ # reduce 12 omitted
+
+ # reduce 13 omitted
+
+ # reduce 14 omitted
+
+ # reduce 15 omitted
+
+ # reduce 16 omitted
+
+ # reduce 17 omitted
+
+ # reduce 18 omitted
+
+ # reduce 19 omitted
+
+module_eval <<'.,.,', 'src/define.y', 56
+  def _reduce_20( val, _values, result )
+ result = "\"#{val[1]}\""
+   result
+  end
+.,.,
+
+ # reduce 21 omitted
+
+ # reduce 22 omitted
+
+ def _reduce_none( val, _values, result )
+  result
+ end
+
+  end   # class Define
+
+end   # module Preprocessor