falluto 0.0.1 → 0.0.9

data/bin/cleantrace.rb

@@ -0,0 +1,97 @@
+#!/usr/bin/env ruby
+
+require 'optparse'
+
+require 'falluto/ruby_extensions'
+require 'falluto/version'
+
+class TraceCleaner
+  def clean tracefile, auxfile, output
+    load_auxdata auxfile
+    do_clean tracefile, output
+  end
+
+  private
+
+  def load_auxdata filename
+    @auxvars, @specs = [], []
+
+    IO.foreach(filename) do |line|
+      if line =~ /^VAR: (.*)$/
+        @auxvars << $1.chomp
+      elsif line =~ /^SPEC: (.*)$/
+        @specs << $1.chomp
+      end
+    end
+  end
+
+  def do_clean filename, output
+    varsregexp = @auxvars.join('|')
+    i = 0
+
+    IO.foreach(filename) do |line|
+      if line =~ /^-- specification (.*) is (true|false)/
+        output.puts "Spec: #{@specs[i]} is #{$2}"
+        output.puts "Counterexample:" if $2 == "false"
+        i += 1
+      elsif ((!varsregexp.empty?) && (line =~ /#{varsregexp}/))
+        # skip it
+      elsif (line =~ /-- Loop/) or (line !~ /^(\*\*\*|WARNING|--|Trace|$)/)
+        output.print line
+      end
+    end
+  end
+end
+
+def parse_cmdline_args
+  options = {:file => nil, :auxfile => nil, :output => nil}
+  optparser = OptionParser.new do |opts|
+    opts.on('-f', '--file <trace_file>', 'Indicate the <trace_file> to be cleaned.') do |file|
+      options[:file] = file
+    end
+
+    opts.on('-a', '--auxfile <aux_file>', 'Indicate the <aux_file> which contains compiler objects.') do |file|
+      options[:auxfile] = file
+    end
+
+    opts.on('-o', '--output <clean_trace>', 'Indicate the output file which will have the clean trace.') do |file|
+      options[:output] = file
+    end
+
+    opts.on('-v', '--version', "Print the version number of #{Falluto::NAME} and exit.") do |x|
+      puts Falluto::Version::STRING
+      exit 0
+    end
+  end
+  optparser.parse!
+  options
+end
+
+
+def main
+  begin
+    options = parse_cmdline_args
+
+    tracefile = options[:file]
+    auxfile = options[:auxfile]
+    cleantrace = options[:output]
+
+    puts "Reading NuSMV trace from: #{tracefile}"
+    puts "Reading support objects from: #{auxfile}"
+    puts "Writing clean trace to: #{cleantrace}"
+
+    cleaner = TraceCleaner.new
+    File.open(cleantrace, "w+") do |output|
+      cleaner.clean tracefile, auxfile, output
+    end
+
+    puts "Done."
+
+  rescue => e
+    puts ""
+    puts "ERROR: #{Falluto::NAME}: #{e} "
+    exit 1
+  end
+end
+
+main

data/bin/falluto.rb

@@ -1,3 +1,93 @@
-gem 'falluto'
+#!/usr/bin/ruby
+
+require 'optparse'
+
+require 'falluto/ruby_extensions'
+require 'falluto/version'
+
+def parse_cmdline_args
+  options = {:file => nil}
+  optparser = OptionParser.new do |opts|
+    opts.on('-f', '--file <input_file>', 'Verify the model and specs given in <input_file>.') do |file|
+      options[:file] = file
+    end
+
+    opts.on('-n', '--nusmv <options>', 'Additional options for NuSMV (between quotes).') do |nusmvopts|
+      options[:nusmvopts] = nusmvopts
+    end
+
+    opts.on('-g', '--graph', 'Generate graph of the counterexample automata.') do |x|
+      options[:graph] = true
+    end
+
+    opts.on('-v', '--version', "Print the version number of #{Falluto::NAME} and exit.") do |x|
+      puts Falluto::Version::STRING
+      exit 0
+    end
+  end
+  optparser.parse!
+  options
+end
+
+def execute_command cmd
+  puts cmd
+  out = %x{#{cmd}}
+  puts out if out !~ /^$/
+end
+
+def compile inputfile, modelfile, auxfile
+  puts "# Compiling..."
+  cmd = "ftnusmv.rb -f #{inputfile} -o #{modelfile} -a #{auxfile}"
+  execute_command cmd
+end
+
+def check_model modelfile, tracefile, opts = nil
+  puts "# Model checking..."
+  cmd = "NuSMV #{opts} #{modelfile} > #{tracefile}"
+  execute_command cmd
+end
+
+def clean_trace tracefile, auxfile, cleantracefile
+  puts "# Cleaning trace..."
+  cmd = "cleantrace.rb -f #{tracefile} -a #{auxfile} -o #{cleantracefile}"
+  execute_command cmd
+end
+
+def generate_automata tracefile, dotfile, pdffile
+  puts "# Graphing automata..."
+  cmd = "viewtrace.rb -f #{tracefile} -d #{dotfile}  -o #{pdffile}"
+  execute_command cmd
+end
+
+def main
+  begin
+    options = parse_cmdline_args
+
+    inputfile = File.expand_path options[:file]
+    modelfile = File.replace_extension inputfile, 'out'
+    auxfile = File.replace_extension inputfile, 'aux'
+    tracefile = File.replace_extension inputfile, 'trace'
+    cleantracefile = File.replace_extension inputfile, "clean"
+    dotfile = File.replace_extension inputfile, "dot"
+    pdffile = File.replace_extension inputfile, "pdf"
+
+    puts Falluto::Version::STRING
+    puts ""
+
+    compile inputfile, modelfile, auxfile
+    check_model modelfile, tracefile, options[:nusmvopts]
+    clean_trace tracefile, auxfile, cleantracefile
+
+    if options[:graph]
+      generate_automata cleantracefile, dotfile, pdffile 
+    end
+
+  rescue OptionParser::InvalidOption => e
+    puts "Falluto: " + e
+    exit 1
+  end
+end
+
+main
+
 
-puts "hello world"

data/bin/ftnusmv.rb

@@ -0,0 +1,96 @@
+#!/usr/bin/ruby
+#
+# FT-NuSMV compiler front end
+
+require 'optparse' # to build a nicer CLI
+
+require 'falluto/compiler'
+require 'falluto/version'
+
+def parse_cmdline_args
+  options = {:method => :compile, :rule => 'program', :file => nil, :output => nil, :auxfile => nil }
+  op = OptionParser.new do |opts|
+    opts.on('-f', '--file FILE', 'Specify input file') do |f|
+      options[:file] = f
+    end
+
+    opts.on('-o', '--output FILE', 'Specify output file (compiled model)') do |f|
+      options[:output] = f
+    end
+
+    opts.on('-a', '--auxfile FILE', 'Specify auxiliar file (auxiliar variables, etc)') do |f|
+      options[:auxfile] = f
+    end
+
+    opts.on('-v', '--version', "Print the version number of #{Falluto::NAME} and exit.") do |x|
+      puts Falluto::Version::STRING
+      exit 0
+    end
+  end
+  op.parse!
+  options
+end
+
+def save_auxiliar_data compiler, filename
+  File.open(filename, "w+") do |f|
+    compiler.auxiliar_variables.each do |v|
+      f.puts "VAR: #{v}"
+    end
+    compiler.specs.each do |s|
+      f.puts "SPEC: #{s}"
+    end
+  end
+end
+
+def save_compiled_code compiler, filename
+  File.open(filename, "w+") do |f|
+    f.puts compiler.compiled_string
+  end
+end
+
+def main
+  begin
+    options = parse_cmdline_args
+
+    infile = options[:file]
+    outfile = options[:output]
+    auxfile = options[:auxfile]
+
+
+    puts "Reading input model from: #{infile}"
+    puts "Writing compiled model to: #{outfile}"
+    puts "Writing support objects to: #{auxfile}"
+
+    string = File.read infile
+    compiler = Compiler.new
+    compiler.run string
+
+    # save compiled string into output file
+    save_compiled_code compiler, outfile
+
+    # save auxiliar data into separate file
+    save_auxiliar_data compiler, auxfile
+
+    puts "Done."
+
+  rescue UndeclaredFault => e
+    puts ""
+    puts "ERROR: Fault #{e} undeclared in module "
+    exit 1
+  rescue RedefinedFault => e
+    puts ""
+    puts "ERROR: Fault #{e} already declared in module "
+    exit 1
+  rescue OptionParser::InvalidOption => e
+    puts ""
+    puts "ERROR: #{e}"
+    exit 1
+  rescue => e
+    puts ""
+    puts "ERROR: #{Falluto::NAME}: #{e}"
+    exit 1
+  end
+end
+
+main
+

data/bin/viewtrace.rb

@@ -0,0 +1,162 @@
+#!/usr/bin/env ruby
+
+require 'optparse'
+
+require 'falluto/ruby_extensions'
+require 'falluto/version'
+
+class Edge
+  def initialize source, dest
+    @source = source
+    @dest = dest
+    @label = ''
+  end
+  def << str
+    @label << str.chomp.strip + '\\n'
+  end
+  def to_dot
+    "#{@source.quote} -> #{@dest.quote} [label=#{@label.quote}];"
+  end
+end
+
+class LoopEdge < Edge
+  def to_dot
+    "#{@source.quote} -> #{@dest.quote} [style=dotted,bold label=#{'LOOP'.quote}];"
+  end
+end
+
+class Node
+  attr_reader :name, :has_loop
+  def initialize name, has_loop
+    @name = name
+    @label = 'State: ' + name + '\\n'
+    @has_loop = has_loop
+  end
+  def << str
+    @label << str.chomp.strip + '\\n'
+  end
+  def to_dot
+    "#{@name.quote} [label=#{@label.quote}];"
+  end
+end
+
+class TraceParser
+  def initialize file
+    @nodes = []
+    @edges = []
+    parse file
+  end
+
+  def to_dot
+    "digraph G {\n" +
+    @nodes.collect{|n| n.to_dot + "\n" }.join +
+    @edges.collect{|e| e.to_dot + "\n" }.join +
+    "}\n"
+  end
+
+  private
+  def parse file
+    @elems = []
+    node = nil
+    edge = nil
+    has_loop = false
+    IO.foreach(file) do |line|
+      case line
+      when /\*\*\*/
+        # do nothing
+      when /^Trace Description: (.*)/
+        # do nothing
+      when /^Trace Type: (.*)/
+        # do nothing
+      when /-- Loop/
+        has_loop = true
+      when /-> State: (\S+)/
+        node = Node.new $1, has_loop
+        has_loop = false
+        @nodes << node
+        edge = nil
+      when /-> Input: (\S+) /
+        edge = Edge.new node.name, $1
+        @edges << edge
+        node = nil
+      else
+        node <<(line) if node
+        edge <<(line) if edge
+      end
+    end
+    build_loops
+    nil
+  end
+
+  def build_loops
+    source = @nodes.last
+    loop_nodes = @nodes.select {|n| n.has_loop}
+    loop_nodes.each { |dest| @edges << LoopEdge.new(source.name, dest.name) }
+  end
+end
+
+
+def parse_cmdline_args
+  options = {:file => nil}
+  op = OptionParser.new do |opts|
+    opts.on('-f', '--file <trace_file>', 'Generate the automata for the trace in <trace_file>.') do |file|
+      options[:file] = file
+    end
+
+    opts.on('-d', '--dotfile <dot_file>', 'Save the output dot file to <dot_file>.') do |file|
+      options[:dotfile] = file
+    end
+
+    opts.on('-o', '--output <pdf_file>', 'Save the output PDF to file <pdf_file>.') do |output|
+      options[:pdffile] = output
+    end
+
+    opts.on('-v', '--version', "Print the version number of #{Falluto::NAME} and exit.") do |x|
+      puts Falluto::Version::STRING
+      exit 0
+    end
+  end
+  op.parse!
+  options
+end
+
+
+def dump_dot tracefile, dotfile
+    tp = TraceParser.new tracefile
+
+    File.open(dotfile, "w+") do |f|
+      f.puts tp.to_dot
+    end
+end
+
+def generate_pdf dotfile, pdffile
+  %x{dot -Tpdf #{dotfile} -o #{pdffile}}
+end
+
+
+def main
+  begin
+    options = parse_cmdline_args
+
+    tracefile = options[:file]
+    dotfile = options[:dotfile]
+    pdffile = options[:pdffile]
+
+    puts "Reading clean trace from: #{tracefile}"
+    puts "Writing dot file to: #{dotfile}"
+    puts "Writing automata to: #{pdffile}"
+
+    dump_dot tracefile, dotfile
+    generate_pdf dotfile, pdffile
+
+    puts "Done."
+
+  rescue => e
+    puts ""
+    puts "ERROR: #{Falluto::NAME}: #{e} "
+    puts e.backtrace.join("\n")
+    exit 1
+  end
+end
+
+main