Class: RPC

Inherits:

Object

• Object
• RPC

Defined in:

lib/netlinx/erb/rpc.rb

Overview

:nodoc:

Class Method Summary

• .build ⇒ Object

  :nodoc:.

Class Method Details

.build ⇒ Object

:nodoc:

Raises:

• (Errno::ENOENT)

# File 'lib/netlinx/erb/rpc.rb', line 8

def self.build
  fn_exp = /
  (?#
    Pull out comment\\description above the function, enclosed in slash\\star syntax.
    Does not have to exist.
  )
  ^(?<desc>[\t ]*\/\*(?:[^\*]|\*[^\/])*\*\/)?\s*
  
  (?# Find the function definition. )
  define_function\s+
  
  (?# Capture function's return type, if it exists.)
  (?<rtn>\w+(?<width>\[\d+\])?)??\s*
  
  (?# Capture the function name. )
  (?<name>\w+)
  
  (?#
    Capture the function parameters.
    Run this through another regex to get the type\\name pairs.
  )
  \(\s*(?<params>.*?)\s*\)\s*
  
  (?# Capture the function's source code. )
  {[\r\n]*(?<code>(?:.|\r|\n)*?)?[\r\n]*}
  /x
  
  param_exp = /\s*(?:(?<type>\w+)\s+(?<name>\w+(?<width>\[\d*\])?)),?\s*/
  
  sections = {} # Collect a set of matches for each file, separated by file.
  
  
  # Pull file list from workspace.
  workspace = NetLinx::Workspace.search
  raise Errno::ENOENT, 'Workspace not found.' unless workspace
  
  file_paths = workspace.projects.first.systems.first.files
    .map(&:path)
    .select { |path| path =~ /(\.axi|\.axs)$/ }
    .reject { |path| path =~ /rpc(?:-|_.*?)?\.axi/ } # Remove RPC files.
  
  # file_paths = Dir['**/*.axi']
  
  file_paths.each do |f|
    str = File.open(f.gsub('\\', '/'), "r:iso-8859-1").read
    matches = []
    
    while str =~ fn_exp
      matches << $~
      str = $'
    end
    
    sections[f] = matches
  end
  
  # -----------------------
  # Documentation Generator
  # -----------------------
  
  # output = ''
  # sections.each do |name, matches|
  
  #   output << "--------------------------------------------------\n"
  #   output << "FILE: '#{name}'\n"
  #   output << "--------------------------------------------------\n"
  #   output << "\n\n"
  
  #   matches.each do |m|
  #     output << m[:desc].to_s
  #     output << "\n"
  #     output << m[:name].to_s
  #     output << "\n\n\n"
  #   end
  
  # end
  
  # File.open('functions.axi', 'w+') { |f| f << output }
  
  
  # ----------------------
  # RPC Function Generator
  # ----------------------
  
  # Generate list of included and excluded files for sanity check.
  directory_files = Dir['**/*.axi'] + Dir['**/*.axs']
  
  included_files  = ''
  file_paths.each { |path| included_files << path.to_s.gsub('\\', '/') + "\n" } # TODO: As string.
  
  excluded_files  = ''
  (directory_files - file_paths.map { |path| path.gsub '\\', '/' }).each { |path| excluded_files << path.to_s.gsub('\\', '/') + "\n" }
  
  fn_symbols = [] # Symbol names to avoid duplicates.
  output = ''
  
  output << <<-EOS
(***********************************************************)
(*                         WARNING                         *)
(***********************************************************)
(*  This file is automatically generated.                  *)
(***********************************************************)

/*
Included Files:
---------------
#{included_files}

Excluded Files:
---------------
#{excluded_files}
*/


#if_not_defined RPC_FUNCTION_LIST
#define RPC_FUNCTION_LIST 1

DEFINE_EVENT

data_event[vdvRPC]
{
  string:
  {
      char f_name[255];
      f_name = rpc_function_name(data.text);
      
EOS

  sections.each do |name, matches|
    output << "        /*------------------------------------------------------------------/\n"
    output << "            FILE: '#{name}'\n"
    output << "        /------------------------------------------------------------------*/\n\n"
    
    
    matches.each do |fn|
      function_valid = true
      fn_output      = ''
      return_type    = fn[:rtn].nil? ? nil : fn[:rtn].downcase.to_sym
      # TODO: Calculate return value width.
      params         = []
      
      # Store function name as symbol and check for duplicates.
      fn_sym = fn[:name].downcase.to_sym
      
      if fn_symbols.include? fn_sym
        output << "        // Already defined.\n"
        function_valid = false
      else
        fn_symbols << fn_sym
      end
      
      # Retrieve params.
      str = fn[:params]
      while str =~ param_exp
        params << $~
        str = $'
      end
      
      # Generate function handler.
      fn_output << "        if(compare_string(f_name, '#{fn[:name].downcase}'))\n"
      fn_output << "        {\n"
      
      # Generate return value.
      if return_type
        case return_type
        when :integer
          fn_output << "            #{return_type.to_s} return_value;\n"
        end
        
        fn_output << "            \n"
      end
      
      fn_output << "            print(LOG_LEVEL_INFO, 'RPC: #{fn[:name]}()');\n"
      fn_output << "            \n"
      
      # Set return value equal to function if return value exists.
      fn_output << "            "
      fn_output << "return_value = " if return_type
      
      fn_output << "#{fn[:name]}("
      fn_output << ");\n" if params.empty?
      
      function_valid = false unless [nil, :integer].include? return_type
      
      # Generate parameters.
      param_index = 0
      params.each do |param|
        param_index += 1
        
        valid_params = [:integer]
        type = param[:type].downcase.to_sym
        
        unless valid_params.include? type
          function_valid = false
          break
        end
        
        case type
        when :integer
          fn_output << "\n                rpc_get_arg_i(#{param_index}, data.text),"
        end
      end
      
      # Remove trailing comma from last arg.
      fn_output.chop! unless params.empty?
      
      # Close function.
      fn_output << "\n            );\n" unless params.empty?
      
      # Print return value if exists.
      if return_type
        fn_output << "            \n"
        
        case return_type
        when :integer
          fn_output << "            print(LOG_LEVEL_INFO, \"'RPC RTN: ', itoa(return_value)\");\n"
        end
      end
      
      fn_output << "        }\n\n"
      
      # Store function string.
      if function_valid
        output << fn_output 
      else
        output << "        // Skipped:\n"
        output << "        // #{fn[:name]}(#{fn[:params]})\n\n"
      end
    end
    
  end
  
  output << "    }\n"
  output << "}\n"
  output << "#end_if\n\n"
  
  
  File.open('include/rpc-functions.axi', 'w+') { |f| f << output }
end