neo_rad 0.4.0

data/lib/rad/init.rb

@@ -0,0 +1,15 @@
+RAD_ROOT = "#{File.dirname(__FILE__)}/../.." unless defined?(RAD_ROOT)
+
+unless defined?(PROJECT_DIR_NAME)
+  a = File.expand_path(File.expand_path("#{RAD_ROOT}")).split("/")
+  PROJECT_DIR_NAME = a[a.length-1]
+end
+
+PLUGIN_C_VAR_TYPES = "int|void|unsigned|long|short|uint8_t|static|byte|char\\*|uint8_t"
+
+gem "ParseTree", "=2.2"
+
+%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/linux_installer.rb

@@ -0,0 +1,132 @@
+class LinuxInstaller
+  
+  # this is the thing we actually run to make something happen
+  def self.install!
+    puts "Welcome to the RAD Linux Installer!"
+    puts "-----------------------------------"
+    puts "Let's begin."
+    puts
+    
+    check_or_warn_for_usb_driver
+    
+    # of course we need rubygems
+    # maybe just rely on the user installing rubygems, because the ubuntu one sux
+    #check_or_install_package("rubygems")
+    #%x{gem update --system}
+    
+    # we need java to make this ship float
+    check_or_nag_package("sun-java5-jre")
+    
+    # remove a package that interferes with the arduino usb/serial driver
+    check_or_remove_package("brltty")
+    
+    # install pre-requisites
+    check_or_install_package("binutils-avr")
+    check_or_install_package("gcc-avr")
+    check_or_install_package("avr-libc")
+    check_or_install_package("unzip")
+    check_or_install_package("wget")
+    
+    # remove a probably out of date avrdude
+    check_or_remove_package("avrdude")
+    
+    # install pre-requisites for avrdude if we wanted to build from source
+    # nah, it comes with the arduino binary
+    #check_or_install_package("gcc")
+    #check_or_install_package("bison")
+    #check_or_install_package("flex")
+    check_or_install_arduino
+  end
+  
+  def self.check_or_install_package(package_name)
+  	package = %x{dpkg --get-selections | grep #{package_name}}
+  	if package.include?("\tinstall")
+  		puts "#{package_name} installed!"
+  	else
+  		puts "installing #{package_name}..."
+  		%x{apt-get install -y #{package_name}}
+  	end
+  end
+  
+  def self.check_or_nag_package(package_name, custom_msg = nil)
+  	package = %x{dpkg --get-selections | grep #{package_name}}
+  	if package.include?("\tinstall")
+  		puts "#{package_name} installed!"
+  	else
+  		puts "you will need to manually install #{package_name}! use the command below."
+  		if custom_msg
+  			puts custom_msg
+  		else
+  			puts "sudo apt-get install #{package_name}"
+  		end		
+  		exit
+  	end
+  end
+  
+  def self.check_or_remove_package(package_name)
+  	package = %x{dpkg --get-selections | grep #{package_name}}
+  
+  	#an easier way to check for installed packages?
+  	if package.include?("\tinstall")
+  		puts "removing #{package_name}..."
+  		%x{apt-get remove -y #{package_name}}
+  	else
+  		puts "#{package_name} previously uninstalled!"
+  	end
+  end
+  
+  def self.check_or_warn_for_usb_driver
+  
+  	# check if usb device recognized by system
+  	puts "Please plug in your arduino to your usb port... [hit enter to continue]"
+  	STDIN.gets # we patiently wait
+  
+  	usb = %x{dmesg | tail | grep "FTDI USB Serial" | grep -c "now attached"}
+  
+  	if usb.to_i == 0
+  		# maybe we can be nice here and offer to download and install the driver package
+  		puts "the system is not recognizing your usb-serial driver, please re-install"
+  		exit
+  	end
+  end
+  
+  def self.check_or_install_arduino 
+  	if File.exist?("/usr/local/arduino-0012")
+  		puts "arduino software previously installed at /usr/local/arduino-0012 !"
+  	else
+  		puts "installing arduino software..."
+  		%x{cd /usr/local/; wget http://arduino.cc/files/arduino-0012-linux.tgz}
+  		%x{tar -C /usr/local -xzf /usr/local/arduino-0012-linux.tgz}
+  
+  		%x{ln -s /usr/local/arduino-0012/arduino ~/Desktop/arduino}
+  
+  		# gotta patch it so it can run from command line or anywhere
+  		arduino_file = File.open("/usr/local/arduino-0012/arduino") {|f| f.read}
+  		new_doc = arduino_file.split("\n")
+  		new_doc[1] = "cd /usr/local/arduino-0012"
+  		File.open("/usr/local/arduino-0012/arduino", "w") {|f| f.puts new_doc }
+  
+  		%x{mkdir -p /usr/local/arduino-0012/hardware/tools/avr/bin}
+  		# there is a difference from what the makefile expects to where it is
+  		%x{ln -s /usr/bin/avr-gcc /usr/local/arduino-0012/hardware/tools/avr/bin/avr-gcc}		
+  		%x{ln -s /usr/bin/avr-g++ /usr/local/arduino-0012/hardware/tools/avr/bin/avr-g++}
+  		%x{ln -s /usr/bin/avr-ar /usr/local/arduino-0012/hardware/tools/avr/bin/avr-ar}
+  		%x{ln -s /usr/bin/avr-objcopy /usr/local/arduino-0012/hardware/tools/avr/bin/avr-objcopy}
+  		%x{ln -s /usr/local/arduino-0012/hardware/tools/avrdude /usr/local/arduino-0012/hardware/tools/avr/bin/avrdude}
+  		%x{ln -s /usr/local/arduino-0012/hardware/tools/avrdude.conf /usr/local/arduino-0012/hardware/tools/avr/etc/avrdude.conf}
+  
+  
+  		puts
+  		puts "************************************************************************"
+  		puts "**  please add /usr/local/arduino-0012 to your path!                  **"
+  		puts "**  you will also need to run sudo update-alternatives --config java  **"
+  		puts "**  to choose java-1.50-sun as the default java                       **"
+  		puts "************************************************************************"
+  		puts
+  	end
+  	
+  end
+end
+
+
+

data/lib/rad/progressbar.rb

@@ -0,0 +1,236 @@
+#
+# Ruby/ProgressBar - a text progress bar library
+#
+# Copyright (C) 2001-2005 Satoru Takabayashi <satoru@namazu.org>
+#     All rights reserved.
+#     This is free software with ABSOLUTELY NO WARRANTY.
+#
+# You can redistribute it and/or modify it under the terms
+# of Ruby's license.
+#
+
+class ProgressBar
+  VERSION = "0.9"
+
+  def initialize (title, total, out = STDERR)
+    @title = title
+    @total = total
+    @out = out
+    @terminal_width = 80
+    @bar_mark = "o"
+    @current = 0
+    @previous = 0
+    @finished_p = false
+    @start_time = Time.now
+    @previous_time = @start_time
+    @title_width = 14
+    @format = "%-#{@title_width}s %3d%% %s %s"
+    @format_arguments = [:title, :percentage, :bar, :stat]
+    clear
+    show
+  end
+  attr_reader   :title
+  attr_reader   :current
+  attr_reader   :total
+  attr_accessor :start_time
+
+  private
+  def fmt_bar
+    bar_width = do_percentage * @terminal_width / 100
+    sprintf("|%s%s|", 
+            @bar_mark * bar_width, 
+            " " *  (@terminal_width - bar_width))
+  end
+
+  def fmt_percentage
+    do_percentage
+  end
+
+  def fmt_stat
+    if @finished_p then elapsed else eta end
+  end
+
+  def fmt_stat_for_file_transfer
+    if @finished_p then 
+      sprintf("%s %s %s", bytes, transfer_rate, elapsed)
+    else 
+      sprintf("%s %s %s", bytes, transfer_rate, eta)
+    end
+  end
+
+  def fmt_title
+    @title[0,(@title_width - 1)] + ":"
+  end
+
+  def convert_bytes (bytes)
+    if bytes < 1024
+      sprintf("%6dB", bytes)
+    elsif bytes < 1024 * 1000 # 1000kb
+      sprintf("%5.1fKB", bytes.to_f / 1024)
+    elsif bytes < 1024 * 1024 * 1000  # 1000mb
+      sprintf("%5.1fMB", bytes.to_f / 1024 / 1024)
+    else
+      sprintf("%5.1fGB", bytes.to_f / 1024 / 1024 / 1024)
+    end
+  end
+
+  def transfer_rate
+    bytes_per_second = @current.to_f / (Time.now - @start_time)
+    sprintf("%s/s", convert_bytes(bytes_per_second))
+  end
+
+  def bytes
+    convert_bytes(@current)
+  end
+
+  def format_time (t)
+    t = t.to_i
+    sec = t % 60
+    min  = (t / 60) % 60
+    hour = t / 3600
+    sprintf("%02d:%02d:%02d", hour, min, sec);
+  end
+
+  # ETA stands for Estimated Time of Arrival.
+  def eta
+    if @current == 0
+      "ETA:  --:--:--"
+    else
+      elapsed = Time.now - @start_time
+      eta = elapsed * @total / @current - elapsed;
+      sprintf("ETA:  %s", format_time(eta))
+    end
+  end
+
+  def elapsed
+    elapsed = Time.now - @start_time
+    sprintf("Time: %s", format_time(elapsed))
+  end
+  
+  def eol
+    if @finished_p then "\n" else "\r" end
+  end
+
+  def do_percentage
+    if @total.zero?
+      100
+    else
+      @current  * 100 / @total
+    end
+  end
+
+  def get_width
+    # FIXME: I don't know how portable it is.
+    default_width = 80
+    begin
+      tiocgwinsz = 0x5413
+      data = [0, 0, 0, 0].pack("SSSS")
+      if @out.ioctl(tiocgwinsz, data) >= 0 then
+        rows, cols, xpixels, ypixels = data.unpack("SSSS")
+        if cols >= 0 then cols else default_width end
+      else
+        default_width
+      end
+    rescue Exception
+      default_width
+    end
+  end
+
+  def show
+    arguments = @format_arguments.map {|method| 
+      method = sprintf("fmt_%s", method)
+      send(method)
+    }
+    line = sprintf(@format, *arguments)
+
+    width = get_width
+    if line.length == width - 1 
+      @out.print(line + eol)
+      @out.flush
+    elsif line.length >= width
+      @terminal_width = [@terminal_width - (line.length - width + 1), 0].max
+      if @terminal_width == 0 then @out.print(line + eol) else show end
+    else # line.length < width - 1
+      @terminal_width += width - line.length + 1
+      show
+    end
+    @previous_time = Time.now
+  end
+
+  def show_if_needed
+    if @total.zero?
+      cur_percentage = 100
+      prev_percentage = 0
+    else
+      cur_percentage  = (@current  * 100 / @total).to_i
+      prev_percentage = (@previous * 100 / @total).to_i
+    end
+
+    # Use "!=" instead of ">" to support negative changes
+    if cur_percentage != prev_percentage || 
+        Time.now - @previous_time >= 1 || @finished_p
+      show
+    end
+  end
+
+  public
+  def clear
+    @out.print "\r"
+    @out.print(" " * (get_width - 1))
+    @out.print "\r"
+  end
+
+  def finish
+    @current = @total
+    @finished_p = true
+    show
+  end
+
+  def finished?
+    @finished_p
+  end
+
+  def file_transfer_mode
+    @format_arguments = [:title, :percentage, :bar, :stat_for_file_transfer]
+  end
+
+  def format= (format)
+    @format = format
+  end
+
+  def format_arguments= (arguments)
+    @format_arguments = arguments
+  end
+
+  def halt
+    @finished_p = true
+    show
+  end
+
+  def inc (step = 1)
+    @current += step
+    @current = @total if @current > @total
+    show_if_needed
+    @previous = @current
+  end
+
+  def set (count)
+    if count < 0 || count > @total
+      raise "invalid count: #{count} (total: #{@total})"
+    end
+    @current = count
+    show_if_needed
+    @previous = @current
+  end
+
+  def inspect
+    "#<ProgressBar:#{@current}/#{@total}>"
+  end
+end
+
+class ReversedProgressBar < ProgressBar
+  def do_percentage
+    100 - super
+  end
+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