dbc 1.1.2 → 1.2.0

data/bin/dbcparse.rb

@@ -16,9 +16,9 @@ require 'getoptlong'
 
 command_dir = File.dirname($0)
 command = File.basename($0)
-#if $0 != command
-#	$:.unshift(command_dir)
-#end
+if $0 != command
+	$:.unshift(File.join(command_dir,'..','lib'))
+end
 require 'dbc/searchpath'
 require 'dbc/preprocessor'
 require 'dbc/expand_function'
@@ -32,11 +32,11 @@ class GetoptLong
 end
 
 opts = GetoptLong.new(
+	[ "--always-output",	"-a",		GetoptLong::NO_ARGUMENT ],
 	[ "--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 ],
@@ -46,18 +46,19 @@ opts = GetoptLong.new(
 )
 
 # 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 = []
 
+always_output = false
+check_level = nil
+docs = nil
+line_info = true
+preprocess_only = nil
+
+overwrite = true # unused
+
 begin
 	i = 1
 	opts.each do |opt, arg|
@@ -88,20 +89,20 @@ begin
 					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 "--always-output"		then always_output = true
+			when "--docs"							then docs = true
+			when "--no_line"					then line_info = false
+			when "--preprocess-only"	then preprocess_only = true
 			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-a, --always-output   : always output to destination file"
 				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 "\t-p, --preprocess-only : preprocess input files only"
 				puts "Commands:"
 				puts "\t-o, --output <file>"
 				puts "\t-c, --check_level <0,1,2>"
@@ -193,21 +194,16 @@ defines << ['__STDC__', nil, '1']
 # included files
 includes = {}
 
-if dest_file
-	out = File.new(dest_file, 'w')
-else
-	out = STDOUT
-end
-
 # Cache Tokens => Preprocessor => Parse OCL => Parse C Types
 # Cached tokens are output.
 if not docs and check_level == DBC::NONE
-	out << text
+	out_str = text
 else
 	begin
 		if docs
-			out << DBC.parse_docs(CTokenizer::Lexer.new(text, src_file))
+			out_str = DBC.parse_docs(CTokenizer::Lexer.new(text, src_file))
 		elsif preprocess_only
+			out_str = ''
 			preproc = Preprocessor::Parser.new(text, src_file) do |f|
 				if inc_text = includes[f]
 					inc_text
@@ -221,9 +217,10 @@ else
 			end
 			defines.each { |d,p,v| preproc.define(d, p, v) }
 			preproc.each do |t|
-				out << t[1]
+				out_str << t[1]
 			end
 		else
+			out_str = ''
 			# cache statements
 			cache = DBC::Cache.new(text, src_file)
 			# preprocesses all tokens
@@ -262,11 +259,11 @@ else
 					unless context.first
 						raise CTokenizer.error(nil, line, "unmatched braket")
 					end
-					out << expand_function(source.conditions, context.first, \
+					out_str << expand_function(source.conditions, context.first, \
 																	stmt, line, line_info)
 				else
 					stmt.each do |t|
-						out << t[1]
+						out_str << t[1]
 					end
 				end
 			end
@@ -274,6 +271,14 @@ else
 	rescue CTokenizer::Error, CType::EvaluationError
 		warn $!
 		exit(-1)
+	ensure
+		if !$! or always_output
+			if dest_file
+				File.open(dest_file, 'w') { |f| f.write(out_str) }
+			else
+				$stdout.write(out_str)
+			end
+		end
 	end
 end
 

data/lib/dbc/ctokenizer.rb

@@ -3,7 +3,50 @@
 # THIS SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND.
 # See included LICENCE file.
 
+require 'strscan'
+
 module CTokenizer
+	EOF_TOKEN = [false, false].freeze
+
+	module Expression
+		NEWLINE = /\r\n|\n\r|\r|\n/
+
+		SPACE_1 = /[\t ]+/
+		SPACE_2 = /\\[\t ]*#{NEWLINE}/
+		SPACE = %r(#{SPACE_1}|#{SPACE_2})
+
+		IDENTIFIER = /[a-zA-Z_]\w*/
+		
+		COMMENT_1 = /\/\*.*?\*\//m
+		# scarry comment - bad style - beward of '\' at end of line...
+		COMMENT_2 = /\/\/(?:\\[ \t]*#{NEWLINE}|[^\r\n])+/m
+		COMMENT = %r(#{COMMENT_1}|#{COMMENT_2})m
+
+		SYMBOL_1 = /\+=|\-=|\*=|\/=|%=|\&=|\^=|\|=|<<=|>>=|##|\.\.\./
+		SYMBOL_2 = /==|!=|<=|>=|->|\&\&|\|\||<<|>>|\+\+|\-\-|<:|:>|<%|%>/
+		SYMBOL_3 = /[\(\)\[\]\{\}\|\&\+\-\/\*%<>\.,=!:;\?\^~#]/
+		SYMBOL = %r(#{SYMBOL_1}|#{SYMBOL_2}|#{SYMBOL_3})
+
+		CHARACTER = /L?'(?:[^']|\\.)*'/
+		STRING = /L?"(?:[^"]|\\.)*"/
+
+		# Note: FLOAT should come before INTEGER
+		f_e = /[eE][-+]?[0-9]+/
+		f_s = /[fFlL]/
+		FLOAT_1 = /[0-9]+#{f_e}#{f_s}?/
+		FLOAT_2 = /[0-9]*\.[0-9]+#{f_e}?#{f_s}?/
+		# FLOAT_3 causes ambiguities... :(
+		#FLOAT_3 = /[0-9]+\.[0-9]*#{f_e}?#{f_s}?/
+		#FLOAT = %r(#{FLOAT_1}|#{FLOAT_2}|#{FLOAT_3})
+		FLOAT = %r(#{FLOAT_1}|#{FLOAT_2})
+
+		i_s = /[uU]?[lL]|[lL][uU]?/
+		INTEGER_1 = /0[xX][0-9a-fA-F]+#{i_s}?/
+		INTEGER_2 = /0[0-7]+#{i_s}?/
+		INTEGER_3 = /[0-9]+#{i_s}?/
+		INTEGER = %r(#{INTEGER_1}|#{INTEGER_2}|#{INTEGER_3})
+	end # Expression
+
 	class Error < StandardError
 		def initialize(file, line)
 			@file = file
@@ -18,78 +61,17 @@ module CTokenizer
 		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
+		str.scan(Expression::NEWLINE) { 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.whitespace?(t)
 		case t[0]
 			when :SPACE, :NEWLINE, :COMMENT
@@ -98,23 +80,6 @@ module CTokenizer
 				false
 		end
 	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)
@@ -155,37 +120,56 @@ module CTokenizer
 		ary
 	end
 
-	class Lexer
-		# C Lexer which keeps ALL tokens
+	class Lexer < StringScanner
+		# C Lexer
 		include	CTokenizer
 		
 		def initialize(str, file=nil, line=1)
-			CTokenizer.check_string(str)
-			@rest = str
+			str.freeze
+			super(str, false) # DO NOT dup str
 			@file = file
 			@line = line
 		end
 	
 		attr_reader :file, :line
 	
-		def peek_nonspace
-			t = nil
-			tmp_rest = @rest # @rest is unchanged
-			loop do
-				t, tmp_rest = CTokenizer.split_token(tmp_rest)
-				break unless CTokenizer.whitespace?(t)
-			end
-			t
-		end
-	
-		def empty?
-			@rest.empty?
-		end
+		alias empty? eos?
 	
 		def shift
-			t, @rest = CTokenizer.split_token(@rest)
-			@line += CTokenizer.line_count(t[1])
-			t
+			# don't need \A in regexp's cause StringScanner does this automatically.
+			t = case
+				when m = scan(Expression::SPACE)
+					@line += CTokenizer.line_count(m)
+					[:SPACE, m]
+				when m = scan(Expression::IDENTIFIER)
+					[:IDENTIFIER, m]
+				when m = scan(Expression::COMMENT)
+					@line += CTokenizer.line_count(m)
+					[:COMMENT, m]
+				when m = scan(Expression::SYMBOL)
+					[:SYMBOL, m]
+				when m = scan(Expression::NEWLINE)
+					@line += CTokenizer.line_count(m)
+					[:NEWLINE, m]
+				# FLOAT should come before INTEGER
+				when m = scan(Expression::FLOAT)
+					[:FLOAT, m]
+				when m = scan(Expression::INTEGER)
+					[:INTEGER, m]
+				when m = scan(Expression::CHARACTER)
+					[:CHARACTER, m]
+				when m = scan(Expression::STRING)
+					[:STRING, m]
+				when eos?
+					EOF_TOKEN # end of file, \Z don't work with StringScanner
+				when m = getch
+					@line += CTokenizer.line_count(m)
+					[:UNKNOWN, m]
+				else
+					raise "shouldn't get here!"
+			end # case
+			m.freeze
+			t.freeze
 		end
 	
 	end
@@ -239,6 +223,20 @@ module CTokenizer
 			end
 		end
 
+		attr_reader :source
+
+		def scan(regexp)
+			@source.scan(regexp)
+		end
+
+		def match?(regexp)
+			@source.match?(regexp)
+		end
+
+		def post_match
+			@source.post_match
+		end
+
 		def file
 			@source.file
 		end
@@ -246,14 +244,8 @@ module CTokenizer
 			@source.line
 		end
 
-		def peek_nonspace
-			@source.peek_nonspace
-		end
-
 		def shift
-			t = @source.shift
-			CTokenizer.check_token(t)
-			t
+			@source.shift
 		end
 
 		def empty?
@@ -279,7 +271,6 @@ module CTokenizer
 		end
 		def shift
 			t = @cache.shift
-			CTokenizer.check_token(t)
 			@line += CTokenizer.line_count(t[1])
 			t
 		end
@@ -330,30 +321,29 @@ module CTokenizer
 
 	# 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)
+			str = t[1]
 			case t[0]
 				when :SYMBOL
-					t = case t[1]
+					case str
 						when '<:'
-							'['
+							str = '['
 						when ':>'
-							']'
+							str = ']'
 						when '<%'
-							'{'
+							str = '{'
 						when '%>'
-							'}'
-						else
-							t[1]
+							str = '}'
 					end # case
-					t = [t, t].freeze
+					t = [str, str].freeze
 				when :IDENTIFIER
-					if CLexer.reserved_word?(t[1])
-						t = [t[1], t[1]].freeze
+					if CLexer.reserved_word?(str)
+						t = [str, str].freeze
 					end
 			end #case
 			t
@@ -373,19 +363,20 @@ module CTokenizer
 		end
 
 		def CPLexer.convert_token(t)
+			str = t[1]
 			case t[0]
 				when :SYMBOL
-					case t[1]
+					case str
 						when	'!', '*', '/', '%', '+', '-', \
 									'<<', '>>', '(', ')', \
 									'<', '<=', '>', '>=', '==', '!=', \
 									'&', '^', '|', '&&', '||', \
 									'?', ':', '#', '##', '...', ','
-							t = [t[1], t[1]].freeze
+							t = [str, str].freeze
 					end # case
 				when :IDENTIFIER
-					if CPLexer.reserved_word?(t[1])
-						t = [t[1], t[1]].freeze
+					if CPLexer.reserved_word?(str)
+						t = [str, str].freeze
 					end
 			end # case
 			t