atduskgreg-rad 0.2.5

data/lib/rad/init.rb

@@ -0,0 +1,14 @@
+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"
+
+
+%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/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