dbc 1.3.0 → 2.0.0

data/bin/caphir.rb

@@ -0,0 +1,152 @@
+#!/usr/bin/env ruby
+#
+# Simple test script to run the parser on the given input file
+#
+
+
+if RUBY_VERSION =~ /\A1\.6/
+    warn("attempt to run with Ruby 1.6.* (should be using Ruby 1.8+)")
+    exit(1)
+end
+
+require 'optparse'
+
+# allows us to run the regression test with local source base
+# without installing caphir
+if $0 != File.basename($0)
+    $:.unshift(File.join(File.dirname($0),'..','lib'))
+end
+
+require 'caphir/parsersettings'
+require 'caphir/parser'
+
+
+if $0 == __FILE__
+
+settings = ParserSettings.new
+
+# initialize with defaults
+always_output = false
+
+#
+# define OptionParser
+#
+
+opts = OptionParser.new do |opts|
+    opts.banner = "Usage: parser.rb [options] [input file]"
+    opts.separator ""
+    opts.separator "Specific options:"
+
+    # Compiler like options
+    opts.on("-o", "--output file", String, 
+        "Output to file (default STDOUT)") do |file|
+        opts.error("multiple output files give") if settings.dest_file
+        settings.dest_file = file
+    end
+    opts.on("-D macro(=value)", String, "Define macro") do |macro|
+        settings.define_macro(macro)
+    end
+    # allow user to undefine compiler specific macros
+    opts.on("-U macro", String, "Cancel the definintion of macro") do |macro|
+        settings.undefine_macro(macro)
+    end
+    opts.on("-I directory", String,
+        "Use directory to search for header files") do |inc_dir|
+        settings.add_include_path(inc_dir)
+    end
+    opts.on("--include file", String, "Include file before processing") do |file|
+        settings.includes << file
+    end
+    opts.on("--cc=compiler(-version)", String, "Specify target compiler") do |cc|
+        opts.error("invalid compiler #{cc}") unless cc =~ /\A[^-]+(?:-(\d\.)+)?\Z/
+        settings.compiler = $1
+        settings.version = $2
+    end
+    opts.on("-E", "Preprocess input file only") do
+        settings.preprocess_only = true 
+    end
+    opts.on("-a", "--always-output", "Always output to destination file") do
+        always_output = true
+    end
+    opts.on("--no-overwrite", "Don't overwrite output file") do
+        settings.overwrite = false 
+    end
+    opts.on("-h", "--help", "Print this message") do
+        puts opts
+        exit(0)
+    end
+
+    opts.separator ""
+    opts.separator "Reads from STDIN if input file is '-' or none is given."
+    opts.separator "-D and -U options are processed in the order given."
+
+end
+
+#
+# Handle command line options
+#
+
+begin
+    opts.parse!(ARGV)
+rescue
+    warn "#{$!} (-h will show vaild options)"
+    exit(2)
+end
+
+# make sure opts gets GC'ed
+opts = nil
+
+
+if ARGV.length > 1
+    warn "expecting one input file, got #{ARGV.length}"
+    exit(2)
+end
+
+unless ARGV.empty? || ARGV[0] == '-'
+    settings.src_file = ARGV[0]
+    unless File.file?(settings.src_file)
+        warn "file does not exist: #{settings.src_file}"
+        exit(2)
+    end
+end
+
+begin
+    settings.check
+    settings.execute
+rescue
+    $stderr.puts $!
+    exit(2)
+end
+
+
+begin
+    out_str = ''
+
+    parser = Caphir::EventParser.new(settings)
+
+    if settings.preprocess_only
+        parser.each do |t|
+            out_str << t 
+        end
+    else
+        parser.each do |function|
+            stmt = parser.in_stream.reset([])
+            
+            out_str << stmt.collect! { |t| t.at(1) }.join
+        end 
+    end 
+
+rescue CTokenizer::Error, CType::EvaluationError
+    warn $!
+    exit(-1)
+ensure
+    if !$! or always_output
+        if settings.dest_file
+            File.open(settings.dest_file, 'w') { |f| f.write(out_str) }
+        else
+            $stdout.write(out_str)
+        end
+    end
+end
+
+end

data/bin/dbcparse.rb

@@ -6,327 +6,181 @@
 # 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
+    warn("attempt to run with Ruby 1.6.* (should be using Ruby 1.8+)")
+    exit(1)
 end
 
-# create output directories if they don't exist
-def create_dest_dirs(dest_file)
-	dest_dir = File.dirname(dest_file)
-	dirs = []
-	until File.directory?(dest_dir)
-		# [ "/home/boson/fake", "/home/boson" ]
-		# "/home/boson" exists so loop ends
-		dirs << dest_dir
-		dest_dir = File.dirname(dest_dir)
-	end
-	dirs.reverse_each do |d|
-		Dir.mkdir(d)
-	end
-	nil
-end
-
-require 'getoptlong'
+require 'optparse'
 
-command_dir = File.dirname($0)
-command = File.basename($0)
-if $0 != command
-	$:.unshift(File.join(command_dir,'..','lib'))
+# allows us to run the regression test with local source base
+# without installing DBC 
+if $0 != File.basename($0)
+    $:.unshift(File.join(File.dirname($0),'..','lib'))
 end
-require 'dbc/searchpath'
-require 'dbc/preprocessor'
+
+require 'caphir/parsersettings'
+require 'caphir/parser'
 require 'dbc/expand_function'
-require 'dbc/ctype'
 require 'dbc/dbc'
 
-class GetoptLong
-	def error(msg)
-		raise GetoptLong::Error, msg
-	end
-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 ],
-#	[ "--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::OPTIONAL_ARGUMENT ]
-)
-
 # initialize with defaults
-dest_file = nil
-src_file = nil
-search_path = SearchPath.new
-defines = []
-search_usr_include = true
+settings = ParserSettings.new
 
 always_output = false
 check_level = nil
 docs = nil
 line_info = true
-preprocess_only = nil
 
-overwrite = true # unused
+#
+# define OptionParser
+#
+opts = OptionParser.new do |opts|
+    opts.banner = "Usage: dbcparse.rb [options] [input file]"
+    opts.separator ""
+    opts.separator "Specific options:"
+
+    # Compiler like options
+    opts.on("-o", "--output file", String, \
+        "Output to file (default STDOUT)") do |file|
+        opts.error("multiple output files give") if settings.dest_file
+        settings.dest_file = file
+    end
+    opts.on("-D macro(=value)", String, "Define macro") do |macro|
+        settings.define_macro(macro)
+    end
+    # allow user to undefine compiler specific macros
+    opts.on("-U macro", String, "Cancel the definintion of macro") do |macro|
+        settings.undefine_macro(macro)
+    end
+    opts.on("-I directory", String,
+        "Use directory to search for header files") do |inc_dir|
+        settings.add_include_path(inc_dir)
+    end
+    opts.on("--include file", String, "Include file before processing") do |file|
+        settings.includes << file
+    end
+    opts.on("--cc=compiler(-version)", String, "Specify target compiler") do |cc|
+        opts.error("invalid compiler #{cc}") unless cc =~ /\A([^-]+)(?:-(\d\.)+)?\Z/
+        settings.compiler = $1
+        settings.version = $2
+    end
+    opts.on("-E", "Preprocess input file only") do
+        settings.preprocess_only = true 
+    end
+    opts.on("-c", "--check-level [0,1,2]", Integer,
+        "Set check level (default 2)") do |level|
+        opts.error("invalid check level '#{level}'") unless DBC.valid_check_level?(level)
+        check_level = level
+    end
+    opts.on("-a", "--always-output", "Always output to destination file") do
+        always_output = true
+    end
+    opts.on("-d", "--docs", "Generate Doxygen documentation") do
+        docs = true 
+    end
+    opts.on("--no-overwrite", "Don't overwrite output file") do
+        settings.overwrite = false 
+    end
+    opts.on("--no-line", "Don't output '\#line' directives") do
+        line_info = false
+    end
+    opts.on("-h", "--help", "Print this message") do
+        puts opts
+        exit(0)
+    end
+
+    opts.separator ""
+    opts.separator "Check levels: 0 = none, 1 = preconditions only, 2 = all conditions."
+    opts.separator "Reads from STDIN if input file is '-' or none is given."
+    opts.separator "-D and -U options are processed in the order given."
+end
+
+#
+# Handle command line options
+#
 
 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
-				if arg
-					begin
-						search_path.unshift(arg)
-					rescue
-						opts.error($!)
-					end
-				else
-					# -I with no argument means don't search /usr/include
-					search_usr_include = false
-				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 "--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-h, --help            : print this message"
-				puts "\t-n, --no_line         : do not output '\#line' directives"
-				puts "\t-p, --preprocess-only : preprocess input files only"
-				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)
+    opts.parse!(ARGV)
+rescue
+    warn "#{$!} (-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
+# make sure opts gets gc'ed
+opts = nil
+
+if [check_level, settings.preprocess_only, docs].nitems > 1
+    warn %q{conflicting options: only one of the following may be selected:
+    --check-level
     --preprocess-only
     --docs}
-	exit(2)
+    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)
+    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 '#{dest_file}' exists"
-		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
-	begin
-		create_dest_dirs(dest_file)
-	rescue
-		warn "could not create destination directory: #{$?}"
-		exit(2)
-	end
-end
-
-if src_file
-	begin
-		text = File.open(src_file, 'r') do |in_file|
-			in_file.read
-		end
-	rescue
-		warn "could not open '#{src_file}': #{$?}"
-		exit(2)
-	end
-else
-	text = STDIN.read
-end
-
-### Compatibility with various compilers ###
-
-# the following are added to the end of the search path
-if search_usr_include
-	if File.exists?('/usr/include')
-		search_path << '/usr/include'
-		# 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
-	else
-		if env_include = ENV['INCLUDE']
-			env_include.split(';').each do |p|
-				# any anci c installation should have stdlib.h or stdio.h
-				if File.exists?(File.join(p, 'stdlib.h'))
-					search_path << p
-				end
-			end # each
-		end
-	end # if File.exists?('/usr/include')
+    settings.src_file = ARGV[0]
+    unless File.file?(settings.src_file)
+        warn "file does not exist: #{settings.src_file}"
+        exit(2)
+    end
 end
 
-search_path_limited = search_path.dup
-# Add directory of file to the begining of the search_path
-# search_path_limited does not include the directory of the file being parsed
-search_path.unshift( src_file ? File.dirname(src_file) : '.' )
-
-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']
-	when /powerpc|darwin/
-		defines << ['__ppc__', nil, nil]
-	else
-		warn "unrecognized platform: #{RUBY_PLATFORM}"
+begin
+    settings.check
+    settings.execute
+rescue
+    $stderr.puts $!
+    exit(2)
 end
 
-# for gcc compatibility
-defines << ['__asm__', ['...'], ' ']
-defines << ['__attribute__', ['...'], ' ']
-defines << ['__const__', nil, 'const']
-defines << ['__extension__', nil, ' ']
-defines << ['__inline__', nil, ' ']
-defines << ['__signed__', nil, 'signed']
-defines << ['__volatile__', nil, 'volatile']
-
-# for gcc 3.4+ compatibility
-defines << ['__builtin_va_list', nil, 'int *']
-defines << ['SHLIB_COMPAT', ['...'], '(0)']
-
-# so '##' is used to paste tokens, not '/**/'
-defines << ['__STDC__', nil, '1']
-#############################################
 
 begin
-	if docs
-		out_str = DBC.parse_docs(CTokenizer::Lexer.new(text, src_file))
-	elsif preprocess_only
-		out_str = ''
-		preproc = Preprocessor::Parser.new( search_path,
-																				search_path_limited,
-																				text, src_file )
-		
-		defines.each { |d,p,v| preproc.define(d, p, v) }
-		preproc.each do |t|
-			out_str << t.at(1)
-		end
-	else
-		if check_level == DBC::NONE
-			out_str = text
-		else
-			# Cache Tokens => Preprocessor => Parse OCL => Parse C Types
-			# Cached tokens are output, not Preprocessed tokens
-			out_str = ''
-			# cache statements
-			cache = DBC::Cache.new(text, src_file)
-			# preprocesses all tokens
-			preproc = Preprocessor::Parser.new(	search_path,
-																					search_path_limited,
-																					cache )
-			
-			# define tokens passed
-			defines.each { |d| preproc.define(*d) }
-	
-			# 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
-					out_str << expand_function(	source.conditions,
-																			context.first,
-																			stmt, line, line_info	)
-				else
-					stmt.each do |t|
-						out_str << t.at(1)
-					end
-				end
-			end # do
-		end #if
-	end # if
+    out_str = ''
+
+    if docs
+        out_str = DBC.parse_docs(CTokenizer::Lexer.new(
+            settings.source, settings.src_file))
+    elsif check_level == DBC::NONE
+        out_str = settings.source
+    else
+        parser = Caphir::EventParser.new(settings, DBC::Parser)
+
+        if settings.preprocess_only
+            parser.each do |t|
+                out_str << t 
+            end
+        else
+            parser.each do |function|
+                line = parser.in_stream.last_line
+                stmt = parser.in_stream.reset([])
+                
+                if function and parser.preproc.base?
+                    out_str << expand_function( parser.handler.conditions,
+                        function, stmt, line, line_info)
+                else
+                    out_str << stmt.collect! { |t| t.at(1) }.join
+                end
+            end 
+        end 
+    end 
 rescue CTokenizer::Error, CType::EvaluationError
-	warn $!
-	exit(-1)
+    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
+    if !$! or always_output
+        if settings.dest_file
+            File.open(settings.dest_file, 'w') { |f| f.write(out_str) }
+        else
+            $stdout.write(out_str)
+        end
+    end
 end