gv_fsm 0.1.0 → 0.2.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 74b717895ae52d4a28c56c12944e18db81886463858bd42d9507a6cbb3c1309e
-  data.tar.gz: f929706aace8b53639fdd8e67aa3096be88994c551266d4c7805196144595e26
+  metadata.gz: 48a490d68d563a441424cfdd79c6c6051d30d4b6e55765239936aed794a898a5
+  data.tar.gz: fc16d72b89d439ae9b18f021e46a9cbf1c5caf4b48ed71a45bad2db72998005b
 SHA512:
-  metadata.gz: a807c54fa79bda61a07df1fee06b8dac62d193d92eb7e056a44c56b144fd008f63e983b0ea28e18d1a7008637a5cf5c64dd21a430f5133cb03f8ca62a75af021
-  data.tar.gz: 6c471ada43c67ef29bdf12d7797b8f4d4bd23aa4e37bcc78ff7e56f0c91657c01066bec2ee5ee5d64a8c5ce0ac50845c4a156e7cf5ebc5d2af28413d25be3a40
+  metadata.gz: ff52872fa8b822d0b63085cf1721bff88123d64112d3ba1103bdaf6da7e5eb1e801f5fed4526d029128b0853ab1527c45f1fc625d61cc37a9350c81709c5a578
+  data.tar.gz: 2d4c28d766e9c34bbe379af163f3302f53501870497df608142c7b67e9f02059846944d17ecac780c4d732a68be00eb790625ffbbd6d2d90b4040c764ea6dcea

data/bin/gv_fsm

@@ -6,11 +6,12 @@ require 'optparse'
 sm = GV_FSM::FSM.new
 
 options = {header: true, source: true}
-OptionParser.new do |parser|
+op = 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
 
@@ -35,18 +36,52 @@ OptionParser.new do |parser|
     options[:header] = false
   end
 
-end.parse!
+  parser.on("-x", "--prefix PREFIX", "Prepend PREFIX to names of generated functions and objects") do |p|
+    sm.prefix = p
+  end
+
+  parser.on("-i", "--ino", "Generate a single .ino file (for Arduino)") do
+    sm.ino = true
+  end
+
+  parser.on("-l", "--no-syslog", "Omit syslog calls in stub functions") do
+    sm.syslog = false
+  end
+
+  parser.on("-h", "--help", "Prints this help") do
+    puts parser
+    exit
+  end
+
+end
 
-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"
+op.parse!
+
+unless ARGV[0]
+  STDERR.puts "ERROR: I need the path to a Graphviz file!\n\n"
+  STDERR.puts op
+  exit
+end
+unless File.extname(ARGV[0]) == ".dot"
+  STDERR.puts "ERROR: #{ARGV[0]} does not look like a Graphviz file!\n\n"
+  STDERR.puts op
+  exit
+end
 
 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"
+if sm.ino then
+  sm.generate_ino
+  puts "Generated .ino file #{sm.cname}.ino"
+else
+  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
 end
+

data/lib/gv_fsm.rb

@@ -2,20 +2,27 @@
 
 require 'ruby-graphviz'
 require 'erb'
-
+require 'pry'
 require File.expand_path('../templates.rb', __FILE__)
 require File.expand_path("../version.rb", __FILE__)
 
 module GV_FSM
   class FSM
-    attr_reader :states, :transitions, :dotfile
-    attr_accessor :project_name, :description, :cname
+    attr_reader :states, :transitions, :dotfile, :prefix
+    attr_accessor :project_name, :description, :cname, :syslog, :ino
     include GV_FSM::Templates
 
     def initialize(filename = nil)
+      @prefix = ""
+      @syslog = true
+      @ino = false
       parse(filename) if filename
     end
 
+    def prefix=(v)
+      @prefix = v + '_'
+    end
+
     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?)
@@ -25,12 +32,17 @@ module GV_FSM
       GraphViz.parse(filename) do |g|
         g.each_node do |id|
           n = g.get_node(id)
+          binding.pry
           label = n[:label].source.empty? ? "do_#{id}" : n[:label].source
-          @states << {id: id, function: label}
+          @states << {id: id, function: @prefix+label}
         end
         g.each_edge do |e|
           from = e.node_one
           to = e.node_two
+          unless e[:label] then
+            @transitions << {from: from, to: to, function: nil} 
+            next
+          end
           case e[:label].source
           when ""
             label = nil
@@ -39,7 +51,7 @@ module GV_FSM
           else
             label = e[:label].source
           end
-          @transitions << {from: from, to: to, function: label}
+          @transitions << {from: from, to: to, function: label ? @prefix+label : nil}
         end
       end
     end
@@ -55,7 +67,7 @@ module GV_FSM
     def transition_functions_list
       lst = []
       @transitions.each do |t|
-        if !lst.include? t[:function] then
+        if t[:function] and !lst.include? t[:function] then
           lst << (t[:function] or "NULL")
         end
       end
@@ -82,6 +94,15 @@ module GV_FSM
       return dest
     end
 
+    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
+
     def generate_c(filename = @cname)
       File.open("#{filename}.c", "w") do |f|
         f.puts ERB.new(HEADER, 0, "<>").result(binding)
@@ -95,6 +116,15 @@ module GV_FSM
         f.puts ERB.new(HH, 0, "<>").result(binding)
       end
     end
+
+    def generate_ino(filename=@cname)
+      @syslog = false
+      File.open("#{filename}.ino", "w") do |f|
+        f.puts ERB.new(HEADER, 0, "<>").result(binding)
+        f.puts ERB.new(HH, 0, "<>").result(binding)
+        f.puts ERB.new(CC, 0, "<>").result(binding)
+      end
+    end
   end
 
 end

data/lib/templates.rb

@@ -2,139 +2,261 @@
 module GV_FSM
   module Templates
     HEADER =<<~EOHEADER
-      // Finite State Machine
-      // Project: <%= self.project_name or self.dotfile %>
-      // Description: <%= self.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: <%= self.dotfile %>
-      // The finite state machine has:
-      //   <%= self.states.count %> states
-      //   <%= self.transitions.count %> transitions
+      /******************************************************************************
+      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
+        <%= transition_functions_list.select {|e| e != 'NULL'}.count %> transition functions
+      <% if @prefix != '' %>
+      Functions and types have been generated with prefix "<%= @prefix %>"
+      <% end %>
+      ******************************************************************************/
 
     EOHEADER
 
     HH =<<~EOH
-      #ifndef <%= self.cname.upcase %>_H
-      #define <%= self.cname.upcase %>_H
+      <% if !@ino then %>
+      #ifndef <%= @cname.upcase %>_H
+      #define <%= @cname.upcase %>_H
       #include <stdlib.h>
+      <% end %>
+
+      // State data object
+      // By default set to void; override this typedef or load the proper
+      // header if you need
+      typedef void <%= @prefix %>state_data_t;
+      <% if !@ino then %>
+      
+      // NOTHING SHALL BE CHANGED AFTER THIS LINE!
+      <% end %>
 
       // List of states
       typedef enum {
-      <% self.states.each_with_index do |s, i| %>
-        STATE_<%= s[:id].upcase %><%= i == 0 ? " = 0" : "" %>,  
+      <% @states.each_with_index do |s, i| %>
+        <%= @prefix.upcase %>STATE_<%= s[:id].upcase %><%= i == 0 ? " = 0" : "" %>,  
       <% end %>
-        NUM_STATES,
-        NO_CHANGE
-      } state_t;
-
-      const char *state_names[] = {<%= self.states_list.map {|sn| '"'+sn+'"'}.join(", ") %>};
+        <%= @prefix.upcase %>NUM_STATES,
+        <%= @prefix.upcase %>NO_CHANGE
+      } <%= @prefix %>state_t;
 
+      // State human-readable names
+      extern const char *state_names[];
+      
+      <% if transition_functions_list.count > 0 then %>
       // State function and state transition prototypes
-      typedef state_t state_func_t(void *data);
-      typedef void transition_func_t(void *data);
+      typedef <%= @prefix %>state_t state_func_t(<%= @prefix %>state_data_t *data);
+      typedef void transition_func_t(<%= @prefix %>state_data_t *data);
+      <% else %>
+      // State function prototype
+      typedef <%= @prefix %>state_t state_func_t(<%= @prefix %>state_data_t *data);
+      <%end %>
 
-      // state functions
-      <% self.states.each do |s| %>
-      state_t <%= s[:function] %>(void *data);
+      // State functions
+      <% 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 %>
+      // Function to be executed in state <%= s[:id] %>
+      // valid return states: <%= dest[s[:id]].join(", ") %>
+      <%= @prefix %>state_t <%= s[:function] %>(<%= @prefix %>state_data_t *data);
       <% end %>
 
-      // transition functions
-      <% self.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] = {
-        <%= self.state_functions_list.join(",\n  ")%>
-      };
+      extern state_func_t *const <%= @prefix %>state_table[<%= @prefix.upcase %>NUM_STATES];
+      
+
+      <% if transition_functions_list.count > 0 then %>
+      // Transition functions
+      <% transition_functions_list.each do |t| %>
+      <% next if t == "NULL" %>
+      void <%= t %>(<%= @prefix %>state_data_t *data);
+      <% end %>
 
       // Table of transition functions
-      transition_func_t *const transition_table[NUM_STATES][NUM_STATES] = {
-      <% sl = self.states_list %>
-      <% fw = self.transition_functions_list.max {|a, b| a.length <=> b.length}.length %>
-      <% sw = self.states_list.max {|a, b| a.length <=> b.length}.length %>
-        /* <%= "states:".ljust(sw) %>     <%= sl.map {|e| e.ljust(fw) }.join(", ") %> */
-      <% self.transitions_map.each_with_index do |l, i| %>
-        /* <%= sl[i].ljust(sw) %> */ {<%= l.map {|e| e.ljust(fw)}.join(", ") %>}, 
+      extern transition_func_t *const <%= @prefix %>transition_table[<%= @prefix.upcase %>NUM_STATES][<%= @prefix.upcase %>NUM_STATES];
+      <% else %>
+      // No transition functions
       <% end %>
-      };
 
       // state manager
-      state_t run_state(state_t cur_state, void *data);
+      <%= @prefix %>state_t <%= @prefix %>run_state(<%= @prefix %>state_t cur_state, state_data_t *data);
       
+      <% if !@ino then %>
       #endif
+      <% end %>
     EOH
 
     CC =<<~EOC
+      <% if !@ino then %>
+      <% if @syslog then %>
       #include <syslog.h>
-      #include "<%= self.cname %>.h"
+      <% end %>
+      #include "<%= @cname %>.h"
+      <% end %>
       
-      // State functions
-      <% dest = self.destinations.dup %>
-      <% self.states.each do |s| %>
+      <% placeholder = "Your Code Here" %>
+      // SEARCH FOR <%= placeholder %> FOR CODE INSERTION POINTS!
+
+      // GLOBALS
+      // State human-readable names
+      const char *state_names[] = {<%= states_list.map {|sn| '"'+sn+'"'}.join(", ") %>};
+
+      // List of state functions
+      <% fw = state_functions_list.max {|a, b| a.length <=> b.length}.length %>
+      state_func_t *const <%= @prefix %>state_table[<%= @prefix.upcase %>NUM_STATES] = {
+      <% @states.each do |s| %>
+        <%= (s[:function] + ',').ljust(fw+1) %> // in state <%= s[:id] %>
+      <% end %>
+      };
+      <% if transition_functions_list.count > 0 then %>
+      
+      // 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, "states:"].flatten.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 %>
+
+      //  ____  _        _       
+      // / ___|| |_ __ _| |_ ___ 
+      // \\___ \\| __/ _` | __/ _ \\
+      //  ___) | || (_| | ||  __/
+      // |____/ \\__\\__,_|\\__\\___|
+      //                         
+      //   __                  _   _                 
+      //  / _|_   _ _ __   ___| |_(_) ___  _ __  ___ 
+      // | |_| | | | '_ \\ / __| __| |/ _ \\| '_ \\/ __|
+      // |  _| |_| | | | | (__| |_| | (_) | | | \\__ \\
+      // |_|  \\__,_|_| |_|\\___|\\__|_|\\___/|_| |_|___/
+      //                                             
+      <% dest = destinations.dup %>
+      <% @states.each do |s| %>
       <% stable = true if dest[s[:id]].include? s[:id] %>
-      <% dest[s[:id]].map! {|n| "STATE_"+n.upcase} %>
+      <% dest[s[:id]].map! {|n| (@prefix+"STATE_"+n).upcase} %>
       <% if dest[s[:id]].empty? or stable then
-        dest[s[:id]].unshift "NO_CHANGE"
+        dest[s[:id]].unshift @prefix.upcase+"NO_CHANGE"
       end %>
-      state_t <%= s[:function] %>(void *data) {
-        state_t next_state = <%= dest[s[:id]].first %>;
+      // Function to be executed in state <%= s[:id] %>
+      // valid return states: <%= dest[s[:id]].join(", ") %>
+      <%= @prefix %>state_t <%= s[:function] %>(<%= @prefix %>state_data_t *data) {
+        <%= @prefix %>state_t next_state = <%= dest[s[:id]].first %>;
 
+      <% if @syslog then %>
         syslog(LOG_INFO, "[FSM] In state <%= s[:id] %>");
-        /* Your code here */
+      <% end %>
+        /* <%= placeholder %> */
         
-        // valid return states: <%= dest[s[:id]].join(", ") %>
         switch (next_state) {
       <% dest[s[:id]].each  do |str| %>
           case <%= str %>:
       <% end %>
             break;
           default:
+      <% if @syslog then %>
             syslog(LOG_WARNING, "[FSM] Cannot pass from <%= s[:id] %> to %s, remaining in this state", state_names[next_state]);
-            next_state = NO_CHANGE;
+      <% end %>
+            next_state = <%= @prefix.upcase %>NO_CHANGE;
         }
         return next_state;
       }
 
       <% end %>
 
-      // Transition functions
-      <% self.transition_functions_list.each do |t| %>
+      <% if transition_functions_list.count > 0 then %>
+      //  _____                    _ _   _              
+      // |_   _| __ __ _ _ __  ___(_) |_(_) ___  _ __   
+      //   | || '__/ _` | '_ \\/ __| | __| |/ _ \\| '_ \\
+      //   | || | | (_| | | | \\__ \\ | |_| | (_) | | | | 
+      //   |_||_|  \\__,_|_| |_|___/_|\\__|_|\\___/|_| |_| 
+      //                                                
+      //   __                  _   _                 
+      //  / _|_   _ _ __   ___| |_(_) ___  _ __  ___ 
+      // | |_| | | | '_ \\ / __| __| |/ _ \\| '_ \\/ __|
+      // |  _| |_| | | | | (__| |_| | (_) | | | \\__ \\
+      // |_|  \\__,_|_| |_|\\___|\\__|_|\\___/|_| |_|___/
+      //    
+                                               
+      <% transition_functions_list.each do |t| %>
       <% next if t == "NULL" %>
-      void <%= t %>(void *data) {
+      <% tpaths = transitions_paths[t] %>
+      // This function is called in <%= tpaths.count %> transition<%= tpaths.count == 1 ? '' : 's' %>:
+      <% tpaths.each_with_index do |e, i| %>
+      // <%= i+1 %>. from <%= e[:from] %> to <%= e[:to] %>
+      <% end %>
+      void <%= t %>(<%= @prefix %>state_data_t *data) {
+      <% if @syslog then %>
         syslog(LOG_INFO, "[FSM] State transition <%= t %>");
-        /* Your code here */
+      <% end %>
+        /* <%= placeholder %> */
       }
 
+      <% end %>
       <% 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];
+      //  ____  _        _        
+      // / ___|| |_ __ _| |_ ___  
+      // \\___ \\| __/ _` | __/ _ \\
+      //  ___) | || (_| | ||  __/ 
+      // |____/ \\__\\__,_|\\__\\___| 
+      //                          
+      //                                              
+      //  _ __ ___   __ _ _ __   __ _  __ _  ___ _ __ 
+      // | '_ ` _ \\ / _` | '_ \\ / _` |/ _` |/ _ \\ '__|
+      // | | | | | | (_| | | | | (_| | (_| |  __/ |   
+      // |_| |_| |_|\\__,_|_| |_|\\__,_|\\__, |\\___|_|   
+      //                              |___/           
+
+      <%= @prefix %>state_t <%= @prefix %>run_state(<%= @prefix %>state_t cur_state, <%= @prefix %>state_data_t *data) {
+        <%= @prefix %>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);
-        return new_state == NO_CHANGE ? cur_state : new_state;
+      <% end %>
+        return new_state == <%= @prefix.upcase %>NO_CHANGE ? cur_state : new_state;
       };
 
-
+      <% if @ino then %>
+      /* Example usage:
+      <% else %>
       #ifdef TEST_MAIN
       #include <unistd.h>
       int main() {
-        state_t cur_state = STATE_INIT;
+      <% end %>
+        <%= @prefix %>state_t cur_state = <%= @prefix.upcase %>STATE_INIT;
+      <% if @syslog then %>
         openlog("SM", LOG_PID | LOG_PERROR, LOG_USER);
         syslog(LOG_INFO, "Starting SM");
+      <% end %>
         do {
-          cur_state = run_state(cur_state, NULL);
+          cur_state = <%= @prefix %>run_state(cur_state, NULL);
           sleep(1);
-        } while (cur_state != STATE_STOP);
+        } while (cur_state != <%= @prefix.upcase %>STATE_STOP);
+      <% if !@ino then %>
         return 0;
       }
       #endif
+      <% else %>
+      */
+      <% end %>
     EOC
   end
 end

data/lib/version.rb

@@ -1,3 +1,3 @@
 module GV_FSM
-  VERSION = "0.1.0"
+  VERSION = "0.2.3"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: gv_fsm
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.3
 platform: ruby
 authors:
 - Paolo Bosetti
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2020-08-08 00:00:00.000000000 Z
+date: 2020-09-09 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: ruby-graphviz