gv_fsm 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 6e22ea784bd92deabd21520f674e347e1edbebcdb3f1acba0256b62994c97a0f
+  data.tar.gz: ab0a2f310beed50a681582ce1b64fd32edb49ab5329150e7f152dbd8d6e99daf
+SHA512:
+  metadata.gz: 9ee624e62959b91f95cf9d5ac3aa02a7172424f8738ea615bb8193aec2631a6a4d31354c60a9958470f9198105406c65f3658c3191d60c345ec0a4a799c76abe
+  data.tar.gz: da45ed138e0ae9d2f54937614ad91bd903aeac8b352761eb0c996b8888ad2079a73b280c09a4185d3dadde6d60fb4045723fd8156d589abd6ce535dfe8b6a8ae

data/bin/gv_fsm

@@ -0,0 +1,19 @@
+#!/usr/bin/env ruby
+
+require "gv_fsm"
+
+SM = FSM.new(ARGV[0])
+SM.project_name = "test project"
+SM.description = "FSM designed to test the generator"
+SM.cname = "test_fsm"
+
+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
+
+File.open("#{SM.cname}.c", "w") do |f|
+  f.puts ERB.new(Templates::HEADER, 0, "<>").result
+  f.puts ERB.new(Templates::CC, 0, "<>").result
+end
+

data/lib/gv_fsm.rb

@@ -0,0 +1,80 @@
+#!/usr/bin/env ruby
+
+require 'ruby-graphviz'
+require 'erb'
+
+require './templates.rb'
+
+class FSM
+  attr_reader :states, :transitions, :dotfile
+  attr_accessor :project_name, :description, :cname
+
+  def initialize(filename)
+    parse(filename)
+  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}
+      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
+        @transitions << {from: from, to: to, function: label}
+      end
+    end
+  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
+    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")
+    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]
+    end
+    return dest
+  end
+end
+

data/lib/templates.rb

@@ -0,0 +1,136 @@
+
+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 */
+      
+      // 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;
+      }
+      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
+end

metadata

@@ -0,0 +1,61 @@
+--- !ruby/object:Gem::Specification
+name: gv_fsm
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Paolo Bosetti
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2020-08-28 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: ruby-graphviz
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.2.5
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.2.5
+description: A C/C++ code generator that creates code for a finite state machine given
+  a description in graphviz language.
+email: paolo.bosetti@unitn.it
+executables:
+- gv_fsm
+extensions: []
+extra_rdoc_files: []
+files:
+- bin/gv_fsm
+- lib/gv_fsm.rb
+- lib/templates.rb
+homepage: https://rubygems.org/gems/gv_fsm
+licenses:
+- MIT
+metadata: {}
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.1.2
+signing_key:
+specification_version: 4
+summary: Graphviz to Finite state machine
+test_files: []