rad 0.2.2 → 0.2.9

data/lib/rad/init.rb

@@ -5,8 +5,10 @@ unless defined?(PROJECT_DIR_NAME)
   PROJECT_DIR_NAME = a[a.length-1]
 end
 
+PLUGIN_C_VAR_TYPES = "int|void|unsigned|long|short|uint8_t|static|byte|char\\*|uint8_t"
 
-%w(generators/makefile/makefile.rb arduino_sketch.rb tasks/rad.rb).each do |path|
+
+%w(generators/makefile/makefile.rb rad_processor.rb rad_rewriter.rb rad_type_checker.rb variable_processing.rb arduino_sketch.rb arduino_plugin.rb hardware_library.rb tasks/rad.rb sketch_compiler.rb).each do |path|
   require File.expand_path("#{RAD_ROOT}/vendor/rad/#{path}")
 end
 

data/lib/rad/rad_processor.rb

@@ -0,0 +1,128 @@
+require 'rubygems'
+require 'ruby_to_ansi_c'
+
+class RADProcessor < RubyToAnsiC
+
+  def self.translator
+    unless defined? @translator then
+      @translator = CompositeSexpProcessor.new
+      @translator << RADRewriter.new
+      @translator << RADTypeChecker.new
+      @translator << R2CRewriter.new
+      @translator << self.new
+      @translator.on_error_in(:defn) do |processor, exp, err|
+        result = processor.expected.new
+        case result
+        when Array then
+          result << :error
+        end
+        msg = "// ERROR: #{err.class}: #{err}"
+        msg += " in #{exp.inspect}" unless exp.nil? or $TESTING
+        msg += " from #{caller.join(', ')}" unless $TESTING
+        result << msg
+        result
+      end
+    end
+    @translator
+  end
+  
+  def process_iasgn(exp)
+    name = exp.shift
+    val = process exp.shift
+    "__#{name.to_s.sub(/^@/, '')} = #{val}"
+  end
+  
+  def process_ivar(exp)
+    name = exp.shift
+    "__#{name.to_s.sub(/^@/, '')}"
+  end
+  
+  def process_iter(exp)
+    # the array identifer may be in one of two locations
+    # when using the instance variable (ivar) style it is located at exp[0][1][1]
+    if exp[0][1][1]
+      enum = exp[0][1][1]
+      enum = "__#{enum.to_s.sub(/^@/, '')}" if enum.to_s =~ /^@/
+    # for local variables it is located at exp[0][1][2]  
+    elsif exp[0][1][2]
+      enum = exp[0][1][2]
+    end
+    
+    out = []
+    # Only support enums in C-land # not sure if this comment if valid anymore
+    raise UnsupportedNodeError if exp[0][1].nil? # HACK ugly
+    @env.scope do
+      
+      call = process exp.shift
+      var  = process(exp.shift).intern # semi-HACK-y 
+      body = process exp.shift
+      
+      # array types from varible_processing>post_process_arrays and arduino_sketch>array
+      $array_types.each do |k,v|
+            @array_type = v if k == enum.to_s.sub(/^__/,"")
+      end
+      
+      index_helper = $array_index_helpers.shift
+      index = "index_#{index_helper}" # solves redeclaration issue
+
+      body += ";" unless body =~ /[;}]\Z/
+      body.gsub!(/\n\n+/, "\n")
+
+      out << "unsigned int #{index};" # shouldn't need more than int
+      out << "for (#{index} = 0; #{index} < (int) (sizeof(#{enum}) / sizeof(#{enum}[0])); #{index}++) {"   
+      out << "#{@array_type} #{var} = #{enum}[#{index}];"
+      out << body
+      out << "}"
+    end
+
+    return out.join("\n")
+  end
+    
+  def process_lasgn(exp)
+    out = ""
+
+    var = exp.shift
+    value = exp.shift
+    # grab the size of the args, if any, before process converts to a string
+    arg_count = 0
+    arg_count = value.length - 1 if value.first == :array
+    args = value
+
+    exp_type = exp.sexp_type
+    @env.add var.to_sym, exp_type
+    var_type = self.class.c_type exp_type
+
+    if exp_type.list? then
+      assert_type args, :array
+
+      raise "array must be of one type" unless args.sexp_type == Type.homo
+
+      # HACK: until we figure out properly what to do w/ zarray
+      # before we know what its type is, we will default to long.
+      array_type = args.sexp_types.empty? ? 'void *' : self.class.c_type(args.sexp_types.first)
+      # we can fix array here..
+      args.shift # :arglist
+      out << "#{var} = (#{array_type}) malloc(sizeof(#{array_type}) * #{args.length});\n"
+      args.each_with_index do |o,i|
+        out << "#{var}[#{i}] = #{process o};\n"
+      end
+    else
+      out << "#{var} = #{process args}"
+    end
+
+    out.sub!(/;\n\Z/, '')
+
+    return out
+  end
+  
+  def process_str(exp)
+    s = exp.shift.gsub(/\n/, '\\n')
+    if s.size == 1
+      return "\'#{s}\'"
+    else
+      return "\"#{s}\""
+    end
+  end
+
+
+end

data/lib/rad/rad_rewriter.rb

@@ -0,0 +1,94 @@
+require 'ruby_to_ansi_c'
+
+class RADRewriter < Rewriter
+  
+  def process_iter(exp)
+    call = process exp.shift
+    var  = process exp.shift
+    body = process exp.shift
+
+    var = s(:dasgn_curr, Unique.next) if var.nil?
+
+    assert_type call, :call
+
+    if call[2] != :each then # TODO: fix call[n] (api)
+      call.shift # :call
+      lhs = call.shift
+      method_name = call.shift
+
+      case method_name
+      when :downto then
+        var.shift # 
+        start_value = lhs
+        finish_value = call.pop.pop # not sure about this
+        var_name = var.shift
+        body.find_and_replace_all(:dvar, :lvar)
+        result = s(:dummy,
+                   s(:lasgn, var_name, start_value),
+                   s(:while,
+                     s(:call, s(:lvar, var_name), :>=,
+                       s(:arglist, finish_value)),
+                     s(:block,
+                       body,
+                       s(:lasgn, var_name,
+                         s(:call, s(:lvar, var_name), :-,
+                           s(:arglist, s(:lit, 1))))), true))
+      when :upto then
+        # REFACTOR: completely duped from above and direction changed
+        var.shift # 
+        start_value = lhs
+        finish_value = call.pop.pop # not sure about this
+        var_name = var.shift
+        body.find_and_replace_all(:dvar, :lvar)
+        result = s(:dummy,
+                   s(:lasgn, var_name, start_value),
+                   s(:while,
+                     s(:call, s(:lvar, var_name), :<=,
+                       s(:arglist, finish_value)),
+                     s(:block,
+                       body,
+                       s(:lasgn, var_name,
+                         s(:call, s(:lvar, var_name), :+,
+                           s(:arglist, s(:lit, 1))))), true))
+       when :times then
+         # REFACTOR: mostly duped from above and gave default start value of 0
+         # and a finish value that was the start value above
+         var.shift 
+         start_value = s(:lit, 0)
+         finish_value = lhs
+         var_name = var.shift
+         body.find_and_replace_all(:dvar, :lvar)
+         result = s(:dummy,
+                    s(:lasgn, var_name, start_value),
+                    s(:while,
+                      s(:call, s(:lvar, var_name), :<,
+                        s(:arglist, finish_value)),
+                      s(:block,
+                        body,
+                        s(:lasgn, var_name,
+                          s(:call, s(:lvar, var_name), :+,
+                            s(:arglist, s(:lit, 1))))), true))
+      when :define_method then
+        # BEFORE: [:iter, [:call, nil, :define_method, [:array, [:lit, :bmethod_added]]], [:dasgn_curr, :x], [:call, [:dvar, :x], :+, [:array, [:lit, 1]]]]
+        # we want to get it rewritten for the scope/block context, so:
+        #   - throw call away
+        #   - rewrite to args
+        #   - plop body into a scope
+        # AFTER:  [:block, [:args, :x], [:call, [:lvar, :x], :+, [:arglist, [:lit, 1]]]]
+        var.find_and_replace_all(:dasgn_curr, :args)
+        body.find_and_replace_all(:dvar, :lvar)
+        result = s(:block, var, body)
+      else
+        # HACK we butchered call up top
+        result = s(:iter, s(:call, lhs, method_name, call.shift), var, body)
+      end
+    else
+      if var.nil? then
+        var = s(:lvar, Unique.next)
+      end
+
+      s(:iter, call, var, body)
+    end
+  end
+
+end

data/lib/rad/rad_type_checker.rb

@@ -0,0 +1,26 @@
+require 'ruby_to_ansi_c'
+
+class RADTypeChecker < TypeChecker
+  
+  def process_const(exp)
+    c = exp.shift
+    if c.to_s =~ /^[A-Z]/ then
+      # TODO: validate that it really is a const? 
+      # uber hackery
+      # since constants are defined in the arduino_sketch define method and 
+      # we can't inject them into the methods 
+      # transport them here with a $define_types hash
+
+      $define_types.each do |k,v|
+        if k == c.to_s
+          @const_type = eval "Type.#{v}"
+        end
+      end
+      return t(:const, c, @const_type)
+    else
+      raise "I don't know what to do with const #{c.inspect}. It doesn't look like a class."
+    end
+    raise "need to finish process_const in #{self.class}"
+  end
+  
+end

data/lib/rad/sim/arduino_sketch.rb

@@ -0,0 +1,57 @@
+ON = true
+OFF = !ON
+HIGH = ON
+LOW = !HIGH
+
+class ArduinoSketch
+  attr_accessor :pins  
+   
+  def initialize
+    @pins = self.class.instance_variable_get("@pins")
+  end
+  
+  def self.output_pin(num, opts)
+    module_eval "@pins ||= []"
+    module_eval do 
+      @pins <<  Pin.new( num, :type => :output )
+    end
+
+    if opts[:as]
+       module_eval <<-CODE
+         def #{opts[:as]}
+           pins.select{|p| p.num == #{num}}.first
+         end
+       CODE
+     end
+  end
+
+  def loop    
+  end
+  
+  def digitalWrite( pin, value )
+    to_change = pins.select{|p| p.num == pin.num}.first
+    to_change.value = value
+  end
+
+  def delay( millis )
+  end
+  
+  # def serial_read
+  # end
+
+  # def serial_available
+  # end
+
+  # def blink
+  # end
+end
+
+class Pin
+  attr_accessor :num, :type, :value
+
+  def initialize num, opts
+    @num = num
+    @type = opts[:type]
+    @value = opts[:value] || false
+  end
+end

data/lib/rad/sketch_compiler.rb

@@ -0,0 +1,47 @@
+# TODO:
+#   compilation
+#   gather pieces of code we need as strings
+#   translate non-loop methods
+#   do plugin stuff
+#   deal with examples/ exception
+#   manage upload process
+#   compose_setup should move in here entirely
+
+# require 'arduino_sketch'
+
+class SketchCompiler
+  attr_accessor :path, :body, :klass, :target_dir, :name
+  
+  def initialize path_to_sketch 
+    @path = File.expand_path(path_to_sketch)
+    @body = open(@path).read
+    @name = @path.split("/").last.split(".").first
+    @klass = @name.split(".").first.split("_").collect{|c| c.capitalize}.join("")     
+    @target_dir = parent_dir
+  end
+  
+  def parent_dir
+    self.path.split("/")[0..@path.split("/").length-2].join("/")
+  end
+  
+  def build_dir
+    "#{self.target_dir}/#{self.name}"
+  end
+
+  def create_build_dir! optional_path_prefix=nil
+    self.target_dir = optional_path_prefix if optional_path_prefix
+    mkdir_p build_dir
+  end
+  
+  def process_constants
+    self.body.gsub!("HIGH", "1")
+    self.body.gsub!("LOW", "0")
+    self.body.gsub!("ON", "1")
+    self.body.gsub!("OFF", "0")
+  end
+  
+  def sketch_methods
+    self.body.scan(/^\s*def\s.\w*/).collect{ |m| m.gsub(/\s*def\s*/, "") }
+  end
+  
+end

data/lib/rad/tasks/build_and_make.rake

@@ -1,6 +1,43 @@
 require File.expand_path(File.dirname(__FILE__) + "/../init.rb")
 require 'ruby_to_ansi_c'
 
+C_VAR_TYPES = "unsigned|int|long|double|str|char|byte|bool"
+
+# incredibly primitive tests 
+# rake test:compile or rake test:upload
+# runs through all sketches in the example directory
+
+def run_tests(sketch, type)
+  sh %{rake make:#{type} sketch=examples/#{sketch}}
+end
+
+namespace :test do
+  
+  desc "iterate through all the sketches in the example directory"
+  task :upload => :gather do 
+    @examples.each {|e| run_tests(e, "upload")}
+  end
+  
+  task :compile => :gather do 
+
+    @examples.each {|e| run_tests(e, "compile")}
+  end
+  
+  desc "gather all tests"
+  task :gather do # => "make:upload" do
+    @examples = []
+    if ENV['sketch']
+      @examples << ENV['sketch']
+    else
+      Dir.entries( File.expand_path("#{RAD_ROOT}/examples/") ).each do |f|
+        @examples << f.split('.').first if (f =~ /\.rb$/)
+      end
+    end
+  end
+
+end
+
+
 namespace :make do
   
   desc "compile the sketch and then upload it to your Arduino board"
@@ -9,70 +46,155 @@ namespace :make do
       puts "Reset the Arduino and hit enter.\n==If your board doesn't need it, you can turn off this prompt in config/software.yml=="
       STDIN.gets.chomp
     end
-    sh %{cd #{RAD_ROOT}/#{@sketch_name}; make upload}
+    sh %{cd #{@sketch.build_dir}; make upload}
   end
-  
+    
   desc "generate a makefile and use it to compile the .cpp"
   task :compile => [:clean_sketch_dir, "build:sketch"] do # should also depend on "build:sketch"
-    Makefile.compose_for_sketch( @sketch_name )
+    Makefile.compose_for_sketch( @sketch.build_dir )
+
+    # not allowed? sh %{export PATH=#{Makefile.software_params[:arduino_root]}/tools/avr/bin:$PATH}
+    sh %{cd #{@sketch.build_dir}; make depend; make}
+  end
+  
+  desc "generate a makefile and use it to compile the .cpp using the current .cpp file"
+  task :compile_cpp => ["build:sketch_dir", "build:gather_required_plugins", "build:plugin_setup", "build:setup", :clean_sketch_dir] do # should also depend on "build:sketch"
+    Makefile.compose_for_sketch( @sketch.build_dir )
     # not allowed? sh %{export PATH=#{Makefile.software_params[:arduino_root]}/tools/avr/bin:$PATH}
-    sh %{cd #{RAD_ROOT}/#{@sketch_name}; make depend; make}
+    sh %{cd #{@sketch.build_dir}; make depend; make}
+  end
+  
+  desc "generate a makefile and use it to compile the .cpp and upload it using current .cpp file"
+  task :upload_cpp => ["build:sketch_dir", "build:gather_required_plugins", "build:plugin_setup", "build:setup", :clean_sketch_dir] do # should also depend on "build:sketch"
+    Makefile.compose_for_sketch( @sketch.build_dir )
+    # not allowed? sh %{export PATH=#{Makefile.software_params[:arduino_root]}/tools/avr/bin:$PATH}
+    sh %{cd #{@sketch.build_dir}; make depend; make upload}
   end
   
   task :clean_sketch_dir => ["build:file_list", "build:sketch_dir"] do
-    @sketch_name = @file_names.first.split(".").first
-    
-    FileList.new(Dir.entries("#{RAD_ROOT}/#{@sketch_name}")).exclude("#{@sketch_name}.cpp").exclude(/^\./).each do |f|
-      sh %{rm #{RAD_ROOT}/#{@sketch_name}/#{f}}
+    FileList.new(Dir.entries("#{@sketch.build_dir}")).exclude("#{@sketch.name}.cpp").exclude(/^\./).each do |f|
+      sh %{rm #{@sketch.build_dir}/#{f}}
     end
   end
+  
 end
 
 namespace :build do
 
   desc "actually build the sketch"
-  task :sketch => [:file_list, :sketch_dir, :setup] do
-    klass = @file_names.first.split(".").first.split("_").collect{|c| c.capitalize}.join("")
-    eval ArduinoSketch.pre_process(File.read(@file_names.first))
-    @loop = RubyToAnsiC.translate(constantize(klass), "loop")
-    result = "#{@setup}\n#{@loop}\n"
-    name = @file_names.first.split(".").first
-    File.open("#{name}/#{name}.cpp", "w"){|f| f << result}
+  task :sketch => [:file_list, :sketch_dir, :gather_required_plugins, :plugin_setup, :setup] do
+    c_methods = []
+    sketch_signatures = []
+    # until we better understand RubyToC let's see what's happening on errors
+    @sketch.sketch_methods.each do |meth|   
+      raw_rtc_meth = RADProcessor.translate(constantize(@sketch.klass), meth)
+      puts "Translator Error: #{raw_rtc_meth.inspect}" if raw_rtc_meth =~ /\/\/ ERROR:/ 
+      c_methods << raw_rtc_meth unless meth == "setup"
+      # treat the setup method differently
+      @additional_setup = [] if meth == "setup"
+      raw_rtc_meth.each {|m| @additional_setup << ArduinoSketch.add_to_setup(m) } if meth == "setup"
+    end
+    c_methods.each {|meth| sketch_signatures << "#{meth.scan(/^\w*\s?\*?\n.*\)/)[0].gsub("\n", " ")};" }
+    clean_c_methods = []
+    # remove external variables that were previously injected
+    c_methods.join("\n").each { |meth| clean_c_methods << ArduinoSketch.post_process_ruby_to_c_methods(meth) }
+    c_methods_with_timer = clean_c_methods.join.gsub(/loop\(\)\s\{/,"loop() {")
+    # last chance to add/change setup
+    @setup[2] << sketch_signatures.join("\n") unless sketch_signatures.empty?
+    # add special setup method to existing setup if present
+    if @additional_setup
+      @setup[2] << "void additional_setup();" # declaration
+      @setup[4] << "\tadditional_setup();" # call from setup 
+      @setup[5] << @additional_setup.join("") # 
+    end
+    result = "#{@setup.join( "\n" )}\n#{c_methods_with_timer}\n"
+    File.open("#{@sketch.build_dir}/#{@sketch.name}.cpp", "w"){|f| f << result}
   end
 
   # needs to write the library include and the method signatures
   desc "build setup function"
   task :setup do
-    klass = @file_names.first.split(".").first.split("_").collect{|c| c.capitalize}.join("")
-    eval "class #{klass} < ArduinoSketch; end;"
+    eval "class #{@sketch.klass} < ArduinoSketch; end;"
     
-    @@as = ArduinoSketch.new
+    @@as = HardwareLibrary.new
     
     delegate_methods = @@as.methods - Object.new.methods
     delegate_methods.reject!{|m| m == "compose_setup"}
         
     delegate_methods.each do |meth|
-       constantize(klass).module_eval <<-CODE
+       constantize(@sketch.klass).module_eval <<-CODE
        def self.#{meth}(*args)
        @@as.#{meth}(*args)
        end
        CODE
     end
+    # allow variable declaration without quotes: @foo = int 
+    ["long","unsigned","int","byte","short"].each do |type|
+      constantize(@sketch.klass).module_eval <<-CODE
+       def self.#{type}
+        return "#{type}"
+       end
+       CODE
+    end   
     
-    eval File.read(@file_names.first)
+    @sketch.process_constants
+    
+    eval ArduinoSketch.pre_process(@sketch.body)
+    @@as.process_external_vars(constantize(@sketch.klass))
     @setup = @@as.compose_setup
   end
   
+  desc "add plugin methods"
+  task :plugin_setup do
+    $plugins_to_load.each do |name|
+       klass = name.split(".").first.split("_").collect{|c| c.capitalize}.join("")
+       eval "class #{klass} < ArduinoPlugin; end;"
+    
+       @@ps = ArduinoPlugin.new
+       plugin_delegate_methods = @@ps.methods - Object.new.methods
+       plugin_delegate_methods.reject!{|m| m == "compose_setup"}
+    
+       plugin_delegate_methods.each do |meth|
+         constantize(klass).module_eval <<-CODE
+         def self.#{meth}(*args)
+           @@ps.#{meth}(*args)
+         end
+         CODE
+       end
+
+      eval ArduinoPlugin.process(File.read("vendor/plugins/#{name}"))
+      
+    end
+    @@no_plugins = ArduinoPlugin.new if @plugin_names.empty?
+  end
+  
+  desc "determine which plugins to load based on use of methods in sketch"
+  task :gather_required_plugins do
+    @plugin_names.each do |name|
+       ArduinoPlugin.check_for_plugin_use(@sketch.body, File.read("vendor/plugins/#{name}"), name )
+    end
+    puts "#{$plugins_to_load.length} of #{$plugin_methods_hash.length} plugins are being loaded:  #{$plugins_to_load.join(", ")}"
+  end
+  
   desc "setup target directory named after your sketch class"
   task :sketch_dir => [:file_list] do
-    mkdir_p "#{@file_names.first.split(".").first}"
+    @sketch.create_build_dir!
   end
 
   task :file_list do
-    @file_names = []
-    Dir.entries( File.expand_path(RAD_ROOT) ).each do |f|
+    # take another look at this, since if the root directory name is changed, everything breaks
+    # perhaps we generate a constant when the project is generated an pop it here or in the init file
+    if ENV['sketch']
+      @sketch = SketchCompiler.new File.expand_path("#{ENV['sketch']}.rb")
+    else
+      # assume the only .rb file in the sketch dir is the sketch:
+      @sketch = SketchCompiler.new Dir.glob("#{File.expand_path(File.dirname(__FILE__))}/../../../*.rb").first
+    end
+
+    @plugin_names = []
+    Dir.entries( File.expand_path("#{RAD_ROOT}/vendor/plugins/") ).each do |f|
       if (f =~ /\.rb$/)
-        @file_names << f
+        @plugin_names << f
       end
     end
   end