dbc 1.1.0

data/bin/dbcparse.rb

@@ -0,0 +1,281 @@
+#!/usr/bin/env ruby
+
+# 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.
+
+if RUBY_VERSION =~ /\A1\.6/
+	warn("attempting to run with Ruby 1.6.* (should be using Ruby 1.8+)")
+	$stdin = STDIN
+	$stdout = STDOUT
+	$stderr = STDERR
+end
+
+require 'getoptlong'
+
+command_dir = File.dirname($0)
+command = File.basename($0)
+#if $0 != command
+#	$:.unshift(command_dir)
+#end
+require 'dbc/searchpath'
+require 'dbc/preprocessor'
+require 'dbc/expand_function'
+require 'dbc/ctype'
+require 'dbc/dbc'
+
+class GetoptLong
+	def error(msg)
+		raise GetoptLong::Error, msg
+	end
+end
+
+opts = GetoptLong.new(
+	[ "--docs",						"-d",		GetoptLong::NO_ARGUMENT ],
+	[ "--help",						"-h",		GetoptLong::NO_ARGUMENT ],
+	[ "--no_line",				"-n",		GetoptLong::NO_ARGUMENT ],
+	[ "--preprocess-only","-p",		GetoptLong::NO_ARGUMENT ],
+	[ "--quiet",					"-q",		GetoptLong::NO_ARGUMENT ],
+#	[ "--trace",					"-t",		GetoptLong::NO_ARGUMENT ],
+	[ "--check_level",		"-c",		GetoptLong::REQUIRED_ARGUMENT ],
+	[ "--output",					"-o",		GetoptLong::REQUIRED_ARGUMENT ],
+	# cc compatibility options
+	[ "--define",					"-D",		GetoptLong::REQUIRED_ARGUMENT ],
+	[ "--include",				"-I",		GetoptLong::REQUIRED_ARGUMENT ]
+)
+
+# initialize with defaults
+line_info = true
+quiet = false
+dest_file = nil
+src_file = nil
+# could make overwrite an option in the future
+overwrite = true
+docs = nil
+preprocess_only = nil
+check_level = nil
+search_path = SearchPath.new
+defines = []
+
+begin
+	i = 1
+	opts.each do |opt, arg|
+		case opt
+			when "--check_level"
+				check_level = arg.to_i
+				unless DBC.valid_check_level?(check_level)
+					opts.error("invalid check level: #{arg}")
+				end
+			when "--include"
+				# should support including file in the future
+				begin
+					search_path << arg
+				rescue
+					opts.error($!)
+				end
+			when "--define"
+				unless arg =~ /\A([A-Za-z_]\w*)(?:\(([\w,\s]*)\))?(?:=(.*))?\Z/
+					opts.error("macro names must be identifiers: #{arg}")
+				end
+				macro = $1
+				opts.error("cannot use 'defined' as a macro name") if macro == 'defined'
+				value = $3 || '1'
+				params = $2.split(/\s*,\s*/) if $2
+				defines << [macro,params,value]
+			when "--output"
+				if dest_file
+					opts.error("multiple output files give")
+				end
+				dest_file = arg
+			when "--docs" then docs = true
+			when "--preprocess-only" then preprocess_only = true
+			when "--quiet" then quiet = true
+			when "--no_line" then line_info = false
+			when "--help"
+				puts "Converts OCL design by contract tags to C code."
+				puts "Usage:"
+				puts "\t#{command} [options] [commands] input_file"
+				puts "Options:"
+				puts "\t-d, --docs            : generate Doxygen documentation"
+				puts "\t-p, --preprocess-only : preprocess input files only"
+				puts "\t-h, --help            : print this message"
+				puts "\t-n, --no_line         : do not output '\#line' directives"
+				puts "\t-q, --quiet           : supress error messages"
+				puts "Commands:"
+				puts "\t-o, --output <file>"
+				puts "\t-c, --check_level <0,1,2>"
+				puts "\t-D, --define <macro(=value)>"
+				puts "\t-I, --include <directory>"
+				puts ""
+				puts "Check levels: 0 = none, 1 = preconditions only, 2 = all conditions."
+				puts "Reads from STDIN if input file is '-' or none is given."
+				puts "Outputs to STDOUT if no output file is given."
+				exit(0)
+			else raise GetoptLong::InvalidOption, "unrecognized option '#{opt}'"
+		end # case
+		i += 1
+	end # each
+rescue GetoptLong::InvalidOption, GetoptLong::Error
+	msg = $!.message
+	warn "<command line>:#{i}: #{msg} (-h will show vaild options)"
+	exit(2)
+end
+
+if [check_level, preprocess_only, docs].nitems > 1
+	warn %q{conflicting options: only one of the following may be selected:
+    --check_level
+    --preprocess-only
+    --docs}
+	exit(2)
+end
+
+# default condition is all
+check_level = DBC::ALL unless check_level
+
+if ARGV.length > 1
+	warn "expecting one input file, got #{ARGV.length}"
+	exit(2)
+end
+
+unless ARGV.empty? || ARGV[0] == '-'
+	src_file = ARGV[0]
+	unless File.file?(src_file)
+		warn "file does not exist: #{src_file}"
+		exit(2)
+	end
+end
+
+if dest_file
+	if File.exists?(dest_file) and not overwrite
+		warn "destination file exists: #{dest_file}"
+		exit(2)
+	end
+	# this is always bad - so don't allow it even if overwrite is true
+	if src_file and File.expand_path(dest_file) == File.expand_path(src_file)
+		warn "destination file and source file are the same"
+		exit(2)
+	end
+end
+
+if src_file
+	text = File.open(src_file, 'r') do |in_file|
+		in_file.read
+	end
+else
+	text = STDIN.read
+end
+
+### Compatibility with various compilers ###
+search_path.unshift('/usr/include') if File.exists?('/usr/include')
+search_path.unshift(File.dirname(src_file)) if src_file
+# search for /usr/lib/gcc*/<system>/<version>/include
+Dir['/usr/lib/gcc*/*/*/include'].each do |gcc_inc|
+	search_path << gcc_inc if File.directory?(gcc_inc)
+end
+case RUBY_PLATFORM
+	when /i[0-9]86|cygwin|mingw/
+		defines << ['__i386__', nil, nil]
+		# I have found that these setting work best with GNU C libs
+		# experiance may vary :)
+		defines << ['__GLIBC_HAVE_LONG_LONG', nil, '1']
+		defines << ['__extension__', nil, ' ']
+	when /powerpc|darwin/
+		defines << ['__ppc__', nil, nil]
+end
+# for gcc 3.4+ compatibility
+defines << ['__builtin_va_list', nil, 'int *']
+defines << ['SHLIB_COMPAT', ['arg'], '(0)']
+#############################################
+
+# output file text
+outstr = ''
+# included files
+includes = {}
+
+# Cache Tokens => Preprocessor => Parse OCL => Parse C Types
+# Cached tokens are output.
+if not docs and check_level == DBC::NONE
+	outstr = text
+else
+	begin
+		if docs
+			outstr = DBC.parse_docs(CTokenizer::Lexer.new(text, src_file))
+		elsif preprocess_only
+			preproc = Preprocessor::Parser.new(text, src_file) do |f|
+				if inc_text = includes[f]
+					inc_text
+				else
+					begin
+						File.open(search_path.find(f)) { |in_f| includes[f] = in_f.read }
+					rescue ArgumentError
+						preproc.error($!)
+					end
+				end
+			end
+			defines.each { |d,p,v| preproc.define(d, p, v) }
+			preproc.each do |t|
+				outstr << t[1]
+			end
+		else
+			# cache statements
+			cache = DBC::Cache.new(text, src_file)
+			# preprocesses all tokens
+			preproc = Preprocessor::Parser.new(cache) do |f|
+				# open included files
+				if inc_text = includes[f]
+					inc_text
+				else
+					begin
+						File.open(search_path.find(f)) { |in_f| includes[f] = in_f.read }
+					rescue ArgumentError
+						preproc.error($!)
+					end
+				end
+			end
+			# define tokens passed
+			defines.each { |d,p,v| preproc.define(d, p, v) }
+
+			# extracts DBC condtions
+			source = DBC::OCLParser.new(preproc)
+
+			# extract all C Statements
+			DBC.parse(source) do |context, f_body|
+				stmt = cache.reset
+				line = stmt.line
+				stmt = stmt.cache
+				# remove end of file token if it exists
+				stmt.pop unless stmt.empty? or stmt.last[0]
+
+				# define C types
+				context.each do |ctxt|
+					CType[ctxt.identifier] = ctxt if ctxt.typedef?
+				end
+				
+				if f_body and preproc.base?
+					unless context.first
+						raise CTokenizer.error(nil, line, "unmatched braket")
+					end
+					outstr << expand_function(source.conditions, context.first, \
+																		stmt, line, line_info)
+				else
+					stmt.each do |t|
+						outstr << t[1]
+					end
+				end
+			end
+		end
+	rescue CTokenizer::Error, CType::EvaluationError
+		warn $!
+		exit(-1)
+	end
+end
+
+if dest_file
+	File.open(dest_file, 'w') do |out_file|
+		out_file.write(outstr)
+	end
+else
+	STDOUT.write(outstr)
+end
+

data/lib/dbc/ctokenizer.rb

@@ -0,0 +1,379 @@
+# 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.
+
+module CTokenizer
+	class Error < StandardError
+		def initialize(file, line)
+			@file = file
+			@line = line
+		end
+		def to_s
+			"#{@file + ':' if @file}#{@line}: #{super}"
+		end
+	end
+
+	def CTokenizer.error(file, line, msg)
+		raise CTokenizer::Error.new(file, line), msg
+	end
+
+	def CTokenizer.check_string(str)
+		raise "expecting a String: #{str.class}" unless str.class <= String
+	end
+	def CTokenizer.check_token(t)
+		raise "expecting a Array[2]: #{t.inspect}" \
+			unless t.class <= Array and t.length == 2
+	end
+
+	def CTokenizer.create_newlines(start, finish)
+		newlines = ''
+		(finish - start).times { newlines << "\n" }
+		[:NEWLINE, newlines.freeze].freeze
+	end
+
+	def CTokenizer.line_count(str)
+		count = 0
+		str.scan(/\r\n|\n\r|\n|\r/) { count += 1 } if str.class == String
+		count
+	end
+
+	# tokens are immutable
+	def CTokenizer.split_token(str)
+		check_string(str)
+		# would be easier if '\n' was the only kind of newline....
+		token = case str
+			when /\A[\t ]+/o
+				[:SPACE, $&]
+			when /\A(?:\r\n|\n\r|\r|\n)/o
+				[:NEWLINE, $&]
+			when /\A\\[\t ]*(?:\r\n|\n\r|\r|\n)/o
+				[:SPACE, $&]
+			when /\A\/\*.*?\*\//m
+				[:COMMENT, $&]
+			when /\A\/\/(?:\\[ \t]*(?:\r\n|\n\r|\r|\n)|[^\r\n])+/o
+				# scarry comment - bad style - beward of line \ at end of line...
+				[:COMMENT, $&]
+			when /\A(?:\+=|\-=|\*=|\/=|%=|\&=|\^=|\|=|<<=|>>=|##|\.\.\.)/
+				[:SYMBOL, $&]
+			when /\A(?:==|!=|<=|>=|->|\&\&|\|\||<<|>>|\+\+|\-\-)/o
+				[:SYMBOL, $&]
+			when /\A(?:<:|:>|<%|%>)/o
+				[:SYMBOL, $&]
+			when /\A[\(\)\[\]\{\}\|\&\+\-\/\*%<>\.,=!:;\?\^~#]/o
+				[:SYMBOL, $&]
+			when /\AL?'(?:[^']|\\.)*'/o
+				[:CHARACTER, $&]
+			when /\AL?"(?:[^"]|\\.)*"/o
+				[:STRING, $&]
+			when /\A[a-zA-Z_]\w*/o
+				[:IDENTIFIER, $&]
+			# FLOAT should come before INTEGER
+			when /\A(?:[0-9]*\.[0-9]+)|(?:[0-9]+\.)[eE][-+]?[0-9]+?[fFlL]?/o
+				[:FLOAT, $&]
+			when /\A[0-9]+[eE][-+]?[0-9]+[fFlL]?/o
+				[:FLOAT, $&]
+			when /\A0[xX][0-9a-fA-F]+(?:(?:[uU][lL]?)|(?:[lL][uU]?)?)/o
+				[:INTEGER, $&]
+			when /\A0[0-7]+(?:(?:[uU][lL]?)|(?:[lL][uU]?)?)/o
+				[:INTEGER, $&]
+			when /\A\d+(?:(?:[uU][lL]?)|(?:[lL][uU]?)?)/o
+				[:INTEGER, $&]
+			when /\A\Z/o
+				[false, false] # end of file
+			when /\A./m
+				[:UNKNOWN, $&]
+			else
+				raise "shouldn't get here!"
+		end # case
+		token[1].freeze
+		[token.freeze, $']
+	end
+
+	def CTokenizer.split(str)
+		tokens = []
+		until str.empty?
+			t, str = CTokenizer.split_token(str)
+			tokens << t
+		end # until
+		tokens
+	end
+
+	def CTokenizer.join(tokens)
+		str = ''
+		tokens.each do |t|
+			str << t[1]
+		end
+		str
+	end
+	
+	def error(msg)
+		CTokenizer.error(file, line, msg)
+	end
+	
+	def token_error(token)
+		self.error("unrecognized token: #{token}")
+	end
+
+	def parse_error(token)
+		self.error("parse error on token: #{token}")
+	end
+
+	def warning(msg)
+		warn "#{file + ':' if file}#{line}: #{msg}"
+	end
+
+	def to_a
+		ary = []
+		until self.empty?
+			ary << self.shift
+		end
+		ary
+	end
+
+	def each
+		until self.empty?
+			yield(self.shift)
+		end
+		self
+	end
+	
+	def collect
+		ary = []
+		until self.empty?
+			ary << yield(self.shift)
+		end
+		ary
+	end
+
+	class Lexer
+		# C Lexer which keeps ALL tokens
+		include	CTokenizer
+		
+		def initialize(str, file=nil, line=1)
+			CTokenizer.check_string(str)
+			@rest = str
+			@file = file
+			@line = line
+		end
+	
+		attr_reader :file, :line
+	
+		def empty?
+			@rest.empty?
+		end
+	
+		def shift
+			t, @rest = CTokenizer.split_token(@rest)
+			@line += CTokenizer.line_count(t[1])
+
+			t
+		end
+	
+	end
+
+	# provides a way of keeping track of the current scope
+	module Scoped
+		attr_reader :scope
+
+		def start_of_line?
+			@start_line
+		end
+
+		def macro?
+			@macro
+		end
+
+		def process_scope(t)
+			case t[0]
+				when :SPACE, :COMMENT
+					# do nothing
+				when :NEWLINE
+					@start_line = true
+					@macro = false
+				else
+					unless @macro
+						# these tokens are ignored if inside of a macro
+						case t[1]
+							when '#'
+								@macro = @start_line
+							when '{'
+								@scope += 1
+							when '}'
+								@scope -= 1
+						end
+					end
+					@start_line = false
+			end
+			t
+		end
+	end # Scoped
+
+	# wraps a lexer and uses that to produce new tokens
+	class LexerBase
+		include	CTokenizer
+		
+		def initialize(str, file=nil, line=1)
+			if (str.class <= String)
+				@source = Lexer.new(str, file, line)
+			else
+				@source = str
+			end
+		end
+
+		def file
+			@source.file
+		end
+		def line
+			@source.line
+		end
+
+		def shift
+			t = @source.shift
+			CTokenizer.check_token(t)
+			t
+		end
+
+		def empty?
+			@source.empty?
+		end
+
+	end # LexerBase
+
+	class Cache
+		include CTokenizer
+		def initialize(file=nil, line=1)
+			@cache = []
+			@file = file
+			@line = line
+		end
+		attr_reader :cache, :file, :line
+		def reset(file, line)
+			@file = file
+			@line = line
+		end
+		def <<(t)
+			@cache << t
+		end
+		def shift
+			t = @cache.shift
+			CTokenizer.check_token(t)
+			@line += CTokenizer.line_count(t[1])
+			t
+		end
+		def empty?
+			@cache.empty?
+		end
+	end # Cache
+
+	# Skips macro tokens - NOT lossy - converts macro into a single newline token
+	class SkipMacros < LexerBase
+		include Scoped
+		def initialize(str, file=nil, line=1)
+			super(str, file, line)
+			@scope = 0
+			@macro = false
+			@start_line = true
+		end
+		def shift
+			t = process_scope(super)
+			if macro?
+				start = self.line
+				token = t[1].dup
+				while macro? and not empty?
+					t = process_scope(super)
+					token << t[1]
+				end
+				self.error("expecting newline") unless empty? or t[0] == :NEWLINE
+				t = [:NEWLINE, token.freeze].freeze
+			end
+			t
+		end
+	end # SkipMacros
+
+	# writes tokens to some output source
+	# may not be useful...
+	class Splitter < LexerBase
+		def initialize(out, source, file=nil, line=1)
+			super(source, file, line)
+			@out = out
+		end
+
+		def shift
+			t = super
+			@out << t
+			t
+		end
+	end
+
+	# C Lexer
+	class CLexer < LexerBase
+	
+		def CLexer.reserved_word?(str)
+			str =~ /\A(?:auto|break|case|char|const|continue|default|do|double|else|enum|extern|float|for|goto|if|inline|int|long|register|return|short|signed|sizeof|static|struct|switch|typedef|union|unsigned|void|volatile|while)\Z/o
+		end
+
+		def CLexer.convert_token(t)
+			case t[0]
+				when :SYMBOL
+					t = case t[1]
+						when '<:'
+							'['
+						when ':>'
+							']'
+						when '<%'
+							'{'
+						when '%>'
+							'}'
+						else
+							t[1]
+					end # case
+					t = [t, t].freeze
+				when :IDENTIFIER
+					if CLexer.reserved_word?(t[1])
+						t = [t[1], t[1]].freeze
+					end
+			end #case
+			t
+		end
+
+		def shift
+			CLexer.convert_token(super)
+		end
+
+	end # CLexer
+	
+	# C Preprocessor Lexer
+	class CPLexer < LexerBase
+	
+		def CPLexer.reserved_word?(str)
+			str =~ /\A(?:if|ifdef|ifndef|else|elif|endif|include|include_next|define|defined|undef|line|error|pragma)\Z/
+		end
+
+		def CPLexer.convert_token(t)
+			case t[0]
+				when :SYMBOL
+					case t[1]
+						when	'!', '*', '/', '%', '+', '-', \
+									'<<', '>>', '(', ')', \
+									'<', '<=', '>', '>=', '==', '!=', \
+									'&', '^', '|', '&&', '||', \
+									'?', ':', '#', '##', '...', ','
+							t = [t[1], t[1]].freeze
+					end # case
+				when :IDENTIFIER
+					if CPLexer.reserved_word?(t[1])
+						t = [t[1], t[1]].freeze
+					end
+			end # case
+			t
+		end
+	
+		def shift
+			CPLexer.convert_token(super)
+		end
+	
+	end # CPLexer
+
+end # Tokenizer
+