gv_fsm 0.0.1 → 0.1.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6e22ea784bd92deabd21520f674e347e1edbebcdb3f1acba0256b62994c97a0f
-  data.tar.gz: ab0a2f310beed50a681582ce1b64fd32edb49ab5329150e7f152dbd8d6e99daf
+  metadata.gz: 450afef3dccacff09f92f297a5b5bcbdfb9d1c960bea0d546bcafe7123f5cebd
+  data.tar.gz: 1fa684d748abecd8c8f17ac2a2b7ca17c83506003eb2cc143596668a32d0a1ea
 SHA512:
-  metadata.gz: 9ee624e62959b91f95cf9d5ac3aa02a7172424f8738ea615bb8193aec2631a6a4d31354c60a9958470f9198105406c65f3658c3191d60c345ec0a4a799c76abe
-  data.tar.gz: da45ed138e0ae9d2f54937614ad91bd903aeac8b352761eb0c996b8888ad2079a73b280c09a4185d3dadde6d60fb4045723fd8156d589abd6ce535dfe8b6a8ae
+  metadata.gz: 98d883a1bff3afaae6fe1531a8f702b6600c97bd37fa4260b3eef02ecccfaf978ab3a9acc096a0c62d9d95c2b4450df105a5cc38f1a03f624984813c9ac5bcb9
+  data.tar.gz: 20af124b281a5aeba975d5124c4a552480d03ea9d4cb13903f4c60f3408c28876adf12a040455dd48afb98ebed8dedb0ee65121e6e93e0d3c9d854a43e4fea57

data/bin/gv_fsm

@@ -1,19 +1,60 @@
 #!/usr/bin/env ruby
 
 require "gv_fsm"
+require 'optparse'
 
-SM = FSM.new(ARGV[0])
-SM.project_name = "test project"
-SM.description = "FSM designed to test the generator"
-SM.cname = "test_fsm"
+sm = GV_FSM::FSM.new
 
-File.open("#{SM.cname}.h", "w") do |f|
-  f.puts ERB.new(Templates::HEADER, 0, "<>").result
-  f.puts ERB.new(Templates::HH, 0, "<>").result
-end
+options = {header: true, source: true}
+OptionParser.new do |parser|
+  parser.banner =<<~EOB 
+  Graphviz to Finite State Machine generator
+  Version: #{GV_FSM::VERSION}
+  See also https://github.com/pbosetti/gv_fsm
+  
+  Usage: gv_fsm [options] scheme.dot
+  EOB
+
+  parser.on("-p", "--project PROJECT_NAME",
+            "Set the project name to PROJECT_NAME") do |pn|
+    sm.project_name = pn
+  end
+
+  parser.on("-d", "--description DESCRIPTION", "Use DESCRITION string in header") do |desc|
+    sm.description = desc
+  end
+
+  parser.on("-o", "--output_file NAME", "Use NAME for generated .c and .h files") do |f|
+    sm.cname = f
+  end
+
+  parser.on("-h", "--header-only", "Only generate header file") do
+    options[:source] = false
+  end
+
+  parser.on("-s", "--source-only", "Only generate source file") do
+    options[:header] = false
+  end
 
-File.open("#{SM.cname}.c", "w") do |f|
-  f.puts ERB.new(Templates::HEADER, 0, "<>").result
-  f.puts ERB.new(Templates::CC, 0, "<>").result
+  parser.on("-x", "--prefix PREFIX", "Prepend PREFIX to names of generated functions and objects") do |p|
+    sm.prefix = p
+  end
+
+end.parse!
+
+raise ArgumentError, "I need the path to a Graphviz file!" unless ARGV[0]
+raise ArgumentError, "#{ARGV[0]} does not look like a Graphviz file!" unless File.extname(ARGV[0]) == ".dot"
+
+sm.parse(ARGV[0])
+
+puts "Parsed #{sm.dotfile}.\nGenerating C stub for states: #{sm.states_list.join(", ")}."
+if options[:header] then
+  sm.generate_h 
+  puts "Generated header #{sm.cname}.h"
+end
+if options[:source] then
+  sm.generate_c 
+  puts "Generated source #{sm.cname}.c"
 end
 
+

data/lib/gv_fsm.rb

@@ -3,78 +3,113 @@
 require 'ruby-graphviz'
 require 'erb'
 
-require './templates.rb'
+require File.expand_path('../templates.rb', __FILE__)
+require File.expand_path("../version.rb", __FILE__)
 
-class FSM
-  attr_reader :states, :transitions, :dotfile
-  attr_accessor :project_name, :description, :cname
+module GV_FSM
+  class FSM
+    attr_reader :states, :transitions, :dotfile, :prefix
+    attr_accessor :project_name, :description, :cname
+    include GV_FSM::Templates
 
-  def initialize(filename)
-    parse(filename)
-  end
+    def initialize(filename = nil)
+      @prefix = ""
+      parse(filename) if filename
+    end
+
+    def prefix=(v)
+      @prefix = v + '_'
+    end
 
-  def parse(filename)
-    @dotfile = filename
-    @states = []
-    @transitions = []
-    GraphViz.parse(filename) do |g|
-      g.each_node do |id|
-        n = g.get_node(id)
-        label = n[:label].source.empty? ? "do_#{id}" : n[:label].source
-        @states << {id: id, function: label}
+    def parse(filename)
+      raise ArgumentError, "File must be in .dot format" unless File.extname(filename) == ".dot"
+      @cname = File.basename(filename, ".dot") unless (@cname and ! @cname.empty?)
+      @dotfile = filename
+      @states = []
+      @transitions = []
+      GraphViz.parse(filename) do |g|
+        g.each_node do |id|
+          n = g.get_node(id)
+          label = n[:label].source.empty? ? "do_#{id}" : n[:label].source
+          @states << {id: id, function: @prefix+label}
+        end
+        g.each_edge do |e|
+          from = e.node_one
+          to = e.node_two
+          next unless e[:label]
+          case e[:label].source
+          when ""
+            label = nil
+          when /[#]/
+            label = "#{from}_to_#{to}"
+          else
+            label = e[:label].source
+          end
+          @transitions << {from: from, to: to, function: label ? @prefix+label : nil}
+        end
       end
-      g.each_edge do |e|
-        from = e.node_one
-        to = e.node_two
-        case e[:label].source
-        when ""
-          label = nil
-        when /[#]/
-          label = "#{from}_to_#{to}"
-        else
-          label = e[:label].source
+    end
+
+    def state_functions_list
+      @states.map {|s| s[:function]}
+    end
+
+    def states_list
+      @states.map {|s| s[:id]}
+    end
+
+    def transition_functions_list
+      lst = []
+      @transitions.each do |t|
+        if !lst.include? t[:function] then
+          lst << (t[:function] or "NULL")
         end
-        @transitions << {from: from, to: to, function: label}
       end
+      return lst
     end
-  end
 
-  def state_functions_list
-    @states.map {|s| s[:function]}
-  end
+    def transitions_map
+      idx = {}
+      map = Array.new(@states.count)
+      map.map! {|e| e = Array.new(@states.count, "NULL")}
+      states_list.each_with_index {|s, i| idx[s] = i }
+      @transitions.each do |t|
+        map[idx[t[:from]]][idx[t[:to]]] = (t[:function] or "NULL")
+      end
+      map
+    end
 
-  def states_list
-    @states.map {|s| s[:id]}
-  end
+    def destinations
+      dest = Hash[states_list.map {|x| [x, []]}]
+      @transitions.each do |t|
+        dest[t[:from]] = [] unless dest[t[:from]]
+        dest[t[:from]] << t[:to]
+      end
+      return dest
+    end
 
-  def transition_functions_list
-    lst = []
-    @transitions.each do |t|
-      if !lst.include? t[:function] then
-        lst << (t[:function] or "NULL")
+    def transitions_paths
+      path = {}
+      @transitions.each do |t|
+        path[t[:function]] = [] unless path[t[:function]]
+        path[t[:function]] << {from: t[:from], to: t[:to]}
       end
+      return path
     end
-    return lst
-  end
 
-  def transitions_map
-    idx = {}
-    map = Array.new(@states.count)
-    map.map! {|e| e = Array.new(@states.count, "NULL")}
-    states_list.each_with_index {|s, i| idx[s] = i }
-    @transitions.each do |t|
-      map[idx[t[:from]]][idx[t[:to]]] = (t[:function] or "NULL")
+    def generate_c(filename = @cname)
+      File.open("#{filename}.c", "w") do |f|
+        f.puts ERB.new(HEADER, 0, "<>").result(binding)
+        f.puts ERB.new(CC, 0, "<>").result(binding)
+      end
     end
-    map
-  end
 
-  def destinations
-    dest = Hash[states_list.map {|x| [x, []]}]
-    @transitions.each do |t|
-      dest[t[:from]] = [] unless dest[t[:from]]
-      dest[t[:from]] << t[:to]
+    def generate_h(filename = @cname)
+      File.open("#{filename}.h", "w") do |f|
+        f.puts ERB.new(HEADER, 0, "<>").result(binding)
+        f.puts ERB.new(HH, 0, "<>").result(binding)
+      end
     end
-    return dest
   end
-end
 
+end

data/lib/templates.rb

@@ -1,136 +1,189 @@
 
-module Templates
-  HEADER =<<~EOHEADER
-    // Finite State Machine
-    // Project: <%= SM.project_name or SM.dotfile %>
-    // Description: <%= SM.description or "<none given>" %>
-    //
-    // Generation date: <%= Time.now %>
-    // Generated from: <%= SM.dotfile %>
-    // The finite state machine has:
-    //   <%= SM.states.count %> states
-    //   <%= SM.transitions.count %> transitions
-
-  EOHEADER
-
-  HH =<<~EOH
-    #ifndef <%= SM.cname.upcase %>_H
-    #define <%= SM.cname.upcase %>_H
-    #include <stdlib.h>
-
-    // List of states
-    typedef enum {
-    <% SM.states.each_with_index do |s, i| %>
-      STATE_<%= s[:id].upcase %><%= i == 0 ? " = 0" : "" %>,  
-    <% end %>
-      NUM_STATES,
-      NO_CHANGE
-    } state_t;
-
-    const char *state_names[] = {<%= SM.states_list.map {|sn| '"'+sn+'"'}.join(", ") %>};
-
-    // State function and state transition prototypes
-    typedef state_t state_func_t(void *data);
-    typedef void transition_func_t(void *data);
-
-    // state functions
-    <% SM.states.each do |s| %>
-    state_t <%= s[:function] %>(void *data);
-    <% end %>
-
-    // transition functions
-    <% SM.transition_functions_list.each do |t| %>
-    <% next if t == "NULL" %>
-    void <%= t %>(void *data);
-    <% end %>
-
-    // List of state functions
-    state_func_t *const state_table[NUM_STATES] = {
-      <%= SM.state_functions_list.join(",\n  ")%>
-    };
-
-    // Table of transition functions
-    transition_func_t *const transition_table[NUM_STATES][NUM_STATES] = {
-    <% sl = SM.states_list %>
-    <% fw = SM.transition_functions_list.max {|a, b| a.length <=> b.length}.length %>
-    <% sw = SM.states_list.max {|a, b| a.length <=> b.length}.length %>
-      /* <%= "states:".ljust(sw) %>     <%= sl.map {|e| e.ljust(fw) }.join(", ") %> */
-    <% SM.transitions_map.each_with_index do |l, i| %>
-      /* <%= sl[i].ljust(sw) %> */ {<%= l.map {|e| e.ljust(fw)}.join(", ") %>}, 
-    <% end %>
-    };
-
-    // state manager
-    state_t run_state(state_t cur_state, void *data);
-    
-    #endif
-  EOH
-
-  CC =<<~EOC
-    #include <syslog.h>
-    #include "<%= SM.cname %>.h"
-    
-    // State functions
-    <% dest = SM.destinations.dup %>
-    <% SM.states.each do |s| %>
-    <% stable = true if dest[s[:id]].include? s[:id] %>
-    <% dest[s[:id]].map! {|n| "STATE_"+n.upcase} %>
-    <% if dest[s[:id]].empty? or stable then
-      dest[s[:id]].unshift "NO_CHANGE"
-    end %>
-    state_t <%= s[:function] %>(void *data) {
-      state_t next_state = <%= dest[s[:id]].first %>;
-
-      syslog(LOG_INFO, "[FSM] In state <%= s[:id] %>");
-      /* Your code here */
+module GV_FSM
+  module Templates
+    HEADER =<<~EOHEADER
+      // Finite State Machine
+      // Project: <%= @project_name or @dotfile %>
+      // Description: <%= @description or "<none given>" %>
+      //
+      // Generated by gv_fsm ruby gem, see https://rubygems.org/gems/gv_fsm
+      // gv_fsm version <%= GV_FSM::VERSION %>
+      // Generation date: <%= Time.now %>
+      // Generated from: <%= @dotfile %>
+      // The finite state machine has:
+      //   <%= @states.count %> states
+      //   <%= @transitions.count %> transitions
+      //   <%= transition_functions_list.select {|e| e != 'NULL'}.count %> transition functions
+
+    EOHEADER
+
+    HH =<<~EOH
+      #ifndef <%= @cname.upcase %>_H
+      #define <%= @cname.upcase %>_H
+      #include <stdlib.h>
+
+      // List of states
+      typedef enum {
+      <% @states.each_with_index do |s, i| %>
+        <%= @prefix.upcase %>STATE_<%= s[:id].upcase %><%= i == 0 ? " = 0" : "" %>,  
+      <% end %>
+        <%= @prefix.upcase %>NUM_STATES,
+        <%= @prefix.upcase %>NO_CHANGE
+      } state_t;
+
+      const char *state_names[] = {<%= states_list.map {|sn| '"'+sn+'"'}.join(", ") %>};
+
+      // State function and state transition prototypes
+      typedef state_t state_func_t(void *data);
+      typedef void transition_func_t(void *data);
+
+      // state functions
+      <% @states.each do |s| %>
+      state_t <%= s[:function] %>(void *data);
+      <% end %>
+
+      // List of state functions
+      state_func_t *const <%= @prefix %>state_table[<%= @prefix.upcase %>NUM_STATES] = {
+        <%= state_functions_list.join(",\n  ")%>
+      };
       
-      // valid return states: <%= dest[s[:id]].join(", ") %>
-      switch (next_state) {
-    <% dest[s[:id]].each  do |str| %>
-        case <%= str %>:
-    <% end %>
-          break;
-        default:
-          syslog(LOG_WARNING, "[FSM] Cannot pass from <%= s[:id] %> to %s, remaining in this state", state_names[next_state]);
-          next_state = NO_CHANGE;
+      <% if transition_functions_list.count > 0 then %>
+      // transition functions
+      <% transition_functions_list.each do |t| %>
+      <% next if t == "NULL" %>
+      void <%= t %>(void *data);
+      <% end %>
+
+      // Table of transition functions
+      transition_func_t *const <%= @prefix %>transition_table[<%= @prefix.upcase %>NUM_STATES][<%= @prefix.upcase %>NUM_STATES] = {
+      <% sl = states_list %>
+      <% fw = transition_functions_list.max {|a, b| a.length <=> b.length}.length %>
+      <% sw = states_list.max {|a, b| a.length <=> b.length}.length %>
+        /* <%= "states:".ljust(sw) %>     <%= sl.map {|e| e.ljust(fw) }.join(", ") %> */
+      <% transitions_map.each_with_index do |l, i| %>
+        /* <%= sl[i].ljust(sw) %> */ {<%= l.map {|e| e.ljust(fw)}.join(", ") %>}, 
+      <% end %>
+      };
+      <% else %>
+      // No transition functions
+      <% end %>
+
+      // state manager
+      state_t <%= @prefix %>run_state(state_t cur_state, void *data);
+      
+      #endif
+    EOH
+
+    CC =<<~EOC
+      #include <syslog.h>
+      #include "<%= @cname %>.h"
+      
+      //  ____  _        _       
+      // / ___|| |_ __ _| |_ ___ 
+      // \\___ \\| __/ _` | __/ _ \\
+      //  ___) | || (_| | ||  __/
+      // |____/ \\__\\__,_|\\__\\___|
+      //                         
+      //   __                  _   _                 
+      //  / _|_   _ _ __   ___| |_(_) ___  _ __  ___ 
+      // | |_| | | | '_ \\ / __| __| |/ _ \\| '_ \\/ __|
+      // |  _| |_| | | | | (__| |_| | (_) | | | \\__ \\
+      // |_|  \\__,_|_| |_|\\___|\\__|_|\\___/|_| |_|___/
+      //                                             
+      <% dest = destinations.dup %>
+      <% @states.each do |s| %>
+      <% stable = true if dest[s[:id]].include? s[:id] %>
+      <% dest[s[:id]].map! {|n| (@prefix+"STATE_"+n).upcase} %>
+      <% if dest[s[:id]].empty? or stable then
+        dest[s[:id]].unshift @prefix.upcase+"NO_CHANGE"
+      end %>
+      // To be executed in state <%= s[:id] %>
+      state_t <%= s[:function] %>(void *data) {
+        state_t next_state = <%= dest[s[:id]].first %>;
+
+        syslog(LOG_INFO, "[FSM] In state <%= s[:id] %>");
+        /* Your code here */
+        
+        // valid return states: <%= dest[s[:id]].join(", ") %>
+        switch (next_state) {
+      <% dest[s[:id]].each  do |str| %>
+          case <%= str %>:
+      <% end %>
+            break;
+          default:
+            syslog(LOG_WARNING, "[FSM] Cannot pass from <%= s[:id] %> to %s, remaining in this state", state_names[next_state]);
+            next_state = <%= @prefix.upcase %>NO_CHANGE;
+        }
+        return next_state;
+      }
+
+      <% end %>
+
+      <% if transition_functions_list.count > 0 then %>
+      //  _____                    _ _   _              
+      // |_   _| __ __ _ _ __  ___(_) |_(_) ___  _ __   
+      //   | || '__/ _` | '_ \\/ __| | __| |/ _ \\| '_ \\
+      //   | || | | (_| | | | \\__ \\ | |_| | (_) | | | | 
+      //   |_||_|  \\__,_|_| |_|___/_|\\__|_|\\___/|_| |_| 
+      //                                                
+      //   __                  _   _                 
+      //  / _|_   _ _ __   ___| |_(_) ___  _ __  ___ 
+      // | |_| | | | '_ \\ / __| __| |/ _ \\| '_ \\/ __|
+      // |  _| |_| | | | | (__| |_| | (_) | | | \\__ \\
+      // |_|  \\__,_|_| |_|\\___|\\__|_|\\___/|_| |_|___/
+      //    
+                                               
+      <% transition_functions_list.each do |t| %>
+      <% next if t == "NULL" %>
+      // This function is called in transitions:
+      <% transitions_paths[t].each do |e| %>
+      // from <%= e[:from] %> to <%= e[:to] %>
+      <% end %>
+      void <%= t %>(void *data) {
+        syslog(LOG_INFO, "[FSM] State transition <%= t %>");
+        /* Your code here */
+      }
+
+      <% end %>
+      <% end %>
+
+      //  ____  _        _        
+      // / ___|| |_ __ _| |_ ___  
+      // \\___ \\| __/ _` | __/ _ \\
+      //  ___) | || (_| | ||  __/ 
+      // |____/ \\__\\__,_|\\__\\___| 
+      //                          
+      //                                              
+      //  _ __ ___   __ _ _ __   __ _  __ _  ___ _ __ 
+      // | '_ ` _ \\ / _` | '_ \\ / _` |/ _` |/ _ \\ '__|
+      // | | | | | | (_| | | | | (_| | (_| |  __/ |   
+      // |_| |_| |_|\\__,_|_| |_|\\__,_|\\__, |\\___|_|   
+      //                              |___/           
+
+      state_t <%= @prefix %>run_state(state_t cur_state, void *data) {
+        state_t new_state = <%= @prefix %>state_table[cur_state](data);
+      <% if transition_functions_list.count > 0 then %>
+        transition_func_t *transition = <%= @prefix %>transition_table[cur_state][new_state];
+        if (transition)
+          transition(data);
+      <% end %>
+        return new_state == <%= @prefix.upcase %>NO_CHANGE ? cur_state : new_state;
+      };
+
+
+      #ifdef TEST_MAIN
+      #include <unistd.h>
+      int main() {
+        state_t cur_state = <%= @prefix.upcase %>STATE_INIT;
+        openlog("SM", LOG_PID | LOG_PERROR, LOG_USER);
+        syslog(LOG_INFO, "Starting SM");
+        do {
+          cur_state = run_state(cur_state, NULL);
+          sleep(1);
+        } while (cur_state != <%= @prefix.upcase %>STATE_STOP);
+        return 0;
       }
-      return next_state;
-    }
-
-    <% end %>
-
-    // Transition functions
-    <% SM.transition_functions_list.each do |t| %>
-    <% next if t == "NULL" %>
-    void <%= t %>(void *data) {
-      syslog(LOG_INFO, "[FSM] State transition <%= t %>");
-      /* Your code here */
-    }
-
-    <% end %>
-
-    // State manager
-    state_t run_state(state_t cur_state, void *data) {
-      state_t new_state = state_table[cur_state](data);
-      transition_func_t *transition = transition_table[cur_state][new_state];
-      if (transition)
-        transition(data);
-      return new_state == NO_CHANGE ? cur_state : new_state;
-    };
-
-
-    #ifdef TEST_MAIN
-    #include <unistd.h>
-    int main() {
-      state_t cur_state = STATE_INIT;
-      openlog("SM", LOG_PID | LOG_PERROR, LOG_USER);
-      syslog(LOG_INFO, "Starting SM");
-      do {
-        cur_state = run_state(cur_state, NULL);
-        sleep(1);
-      } while (cur_state != STATE_STOP);
-      return 0;
-    }
-    #endif
-  EOC
+      #endif
+    EOC
+  end
 end

data/lib/version.rb

@@ -0,0 +1,3 @@
+module GV_FSM
+  VERSION = "0.1.2"
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: gv_fsm
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.1.2
 platform: ruby
 authors:
 - Paolo Bosetti
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2020-08-28 00:00:00.000000000 Z
+date: 2020-08-08 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: ruby-graphviz
@@ -35,7 +35,8 @@ files:
 - bin/gv_fsm
 - lib/gv_fsm.rb
 - lib/templates.rb
-homepage: https://rubygems.org/gems/gv_fsm
+- lib/version.rb
+homepage: https://github.com/pbosetti/gv_fsm
 licenses:
 - MIT
 metadata: {}