rubimc 0.2.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 4465934e351aae8519533e572a4db1f636230a2d
+  data.tar.gz: 20b82528892f27d9c7dc428b3c744d973da93dce
+SHA512:
+  metadata.gz: 6c9694603cc3dcd38c5a82df186c89573f586a0560b414f991771f4f7b638522b382e414b58febe950a210633c90e3a3ac5c43dd2e756997f0cbfc211a746b2a
+  data.tar.gz: 8bdf46becb20231885f57e47de38d0a8b5c347bb23dc5a1ae4f3788de98116894fb921d6ed89d5faedaaad508b8705e52a61cfba426fde5fb62e4ad8229528ed

data/LICENSE.md

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2016 Evgeny Danilov
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/README.md

@@ -0,0 +1,176 @@
+### RubimC
+It is a Ruby compiler and framework for microcontrollers. Full name RubimCode in Russian transcription heard as "cut down the code". Current version is working but realizes far not all the features of Ruby. All realized features you can find in folder "examples"
+
+### Description:
+RubimC designed to simplify the process of programming microcontrollers, but can also be used as an clear С-code generator. The framework is a syntax-flavored Ruby combines the unique features of the Ruby, adding and expanding the functions required for a specific area. At the input  generator takes the program to Ruby, and the output provides a pure C code, based on the user program and libraries that are connected to a select model of the microcontroller. All that is required to generate is installed ruby-interpreter. If it`s nessesary, for compile C-code you need installing compiler *gcc* or *avr-gcc* (for AVR microcontrollers)
+
+### Benefits of writing programs in RubymC 
++ increase development speed
++ code readability and elegance inherent in the Ruby language
++ an object-oriented approach
++ the use of an interpreted language does not reduce the performance of the final program because there is **no virtual mashine**
++ ability of hardware control IC and delivery of messages
++ ability to get a list of the hardware for a particular version of the device, as well as a list of all methods and help them directly from the generator console, on the basis of libraries.
+
+### Why?
+First of all for fan...I want to see at Ruby from other point, not only from famous framework Ruby On Rails. Of course, we have great project [mruby] (http://mruby.org/), that compile Ruby code, realized all common functions of Ruby and standart libraries, and supported by **Matz**. But...mruby generate a big-size code, and, as we know, microcontroller have very small memory. For example, for initialize only one array mruby generate binary file with size 1MB! At the other side RubimC generate code with minimal size, in most cases are not different from the similar size of, written on C. In addition, RubimC generator is clearness. You always can to see on generated C-code and to evaluate its performance and size.
+
+### How it`s work
+Code generated in three stage:
+
+1. Preprocessing user programm, that replaced some Ruby keywords, operators and identificators
+2. Shell Ruby-code and generate C-code (use metaprograming of Ruby)
+3. Compile C-code (with gcc or avr-gcc).
+
+### Install
+All you need to use **RubimC** gem is Ruby interpretator and gcc/avr-gcc compiler. 
+
+How to [install Ruby] (https://www.ruby-lang.org/en/documentation/installation/). For Ubuntu I recomended to use first chapter of this [manual] (https://gorails.com/setup/ubuntu).
+
+Then you can install RubimC gem:
+```sh
+gem install rubimc
+```
+
+Compiler *gcc* provided by Linux. For others platforms use this [manual] (https://gcc.gnu.org/install/binaries.html).
+
+To install *avr-gcc* use this [manual] (http://avr-eclipse.sourceforge.net/wiki/index.php/The_AVR_GCC_Toolchain).
+
+
+### ToDo list (main of them):
+0. upload to rubygems
+0. Test core with command "rubimc test"
+1. Code generator:
+    + define user`s variables as local (now it defined in top-level instance)
+    + support all C types of variables (int ,float, unsigned int, u_int8 e.t.)
+    + support array, hash, string, range and constants
+    + support user`s methods and classes
+    + support threads
+2. Write libraries for microcontrollers (AVR, PIC, STM, e.t.)
+3. Fix a lot of possible bugs & features
+
+### What is done
+1. Init variables
+2. Support all arithmetic operation except ternary and logical operators (binary operators is done)
+3. Support conditions (if/unless and it`s modify version) and loops (while/until) except next/redo/break/retry keywords
+4. Support arrays init and arithmetic operation with it
+5. Realize example library for AVR AtTiny13 MCU with DigitalIO and ADC support
+
+### Example for AVR microcontroller:
+Ruby programm (*"FirstController.rb"*):
+```ruby
+require 'rubimc'
+
+class FirstController < AVR_attiny13
+    def initialize
+        ANALOG_TO_DIGITAL.init(ref: "vcc", channel: ADC0)
+
+        ANALOG_TO_DIGITAL.interrupt(enabled: true) do |volts|
+            output :led, port: :B, pin: 3
+            led.off if volts < 30
+            led.on if volts >= 220
+        end
+    end
+
+    def main_loop # infinit loop, it stop only when MCU is reset
+    end
+end
+```
+
+To compile this code run in console:
+```sh
+rubimc compile FirstController.rb
+```
+or just
+```sh
+rubimc compile --all
+```
+
+It generate C-code placed in *"release/FirstController.c"* and hex-file for upload in MCU placed in *"release/FirstController.hex*
+```c
+//=============================
+#include <stdbool.h>
+
+#define F_CPU 1000000UL
+#include <avr/io.h>
+#include <avr/iotn13.h>
+#include <avr/interrupt.h>
+
+int main() 
+{
+    // Init ADC
+    ADMUX = (0<<REFS0) | (0<<ADLAR) | MUX0;
+    ADCSRA = (1<<ADEN) | (0<<ADATE) | (1<<ADPS0) | (0<<ADIE);
+
+    ADMUX |= 1<<ADIE;
+    return 1;
+}
+
+// ADC Interrupt
+ISR(ADC_vect)
+{
+    int __rubim__volt = ADCL + ((ADCH&0b11) << 8);
+    DDRB |= 1<<(3);
+    if ((__rubim__volt<=(0))) {
+        PORTB &= 255 ^ (1<<(3));
+    }
+    if (!((__rubim__volt<(15)))) {
+        PORTB |= 1<<(3);
+    }
+}
+```
+*note: this is a valid C-code, but in real AVR-controllers it may not work, because avr-libraries are still in development*
+
+### Some rake helpers
+For create new project RubimC gem support command "generate" (of just "g"). For example:
+```sh
+rubimc generate mcu "BrainControll.rb" type:attiny13 # create template "BrainControll.rb" for AVR microcontroller 'attiny13'
+rubimc g mcu FirstProg # create template "FirstProg.rb" for unknown microcontroller
+rubimc g clearC Example # create template "Example.rb" for generate clear C code
+```
+
+### Some interesting idea
+There is interesting idea for connect few microconrollers (IC) via some firmware interfaces, for example I2C or USB **(at this moment is not realized)**. This example will generate two binary files for each microcontroller. 
+
+```ruby
+class BrainController < AVR_atmega16
+    def initialize()
+        input :button, port: :A, pin: 6 
+        # its a syntax surag of "@button = input name: 'button', port: 'A', pin: 6"
+    end
+
+    def main_loop() # infinit loop, it stop only when IC is reset
+        if want_to_say_hello?
+            LeftHandController.move_hand = "up" # transfer data to other controller
+        end
+    end
+
+    private # define user`s methods and classes
+        def want_to_say_hello?
+            @button.press?
+        end
+end
+
+class LeftHandController < AVR_attiny13
+    attr_accessor :move_hand, via: "I2C" # I2C - fireware data-transfer bus
+
+    def move_hand=(message) # execute when command is received
+        @led.toggle
+        if message=="up" 
+            # ...run motor...
+        end
+    end
+
+    def initialize()
+        output :led, port: :B, pin: 3
+    end
+
+    def main_loop() # infinit loop, it stop only when IC is reset
+    end
+end
+```
+
+### Help
+If you interested the project and find some bugs, you may to write the tests and we try to fix it. Examples of tests is placed in folder *test*. To run tests use command *"rspec test/test_all.rb"*. Of course if you try to modify core and libraries it will be wonder.
+
+Thank you!

data/bin/rubimc

@@ -0,0 +1,190 @@
+#!/usr/bin/env ruby
+
+# Example:
+#
+#   rubimc generate mcu "Brain.rb" type:attiny13
+#   rubimc g mcu FirstProg
+#   rubimc g clearC Example
+# 
+#   rubimc compile "BrainControll.rb"
+#   rubimc compile BrainControll
+#   rubimc compile --all
+# 
+
+require 'rake' 
+
+gem_dir = File.expand_path("..", File.dirname(__FILE__))
+$LOAD_PATH.unshift gem_dir # Look in gem directory for resources first
+
+exec_type = ARGV[0]
+if exec_type == 'generate' or exec_type == 'g'
+	gen_type = ARGV[1]
+	if gen_type == 'mcu' # generate template for MCU
+		name = ARGV[2]
+		if name.nil?
+			puts "ERROR: you must define mcu name"
+			puts "for example: 'rubimc g mcu ExampleProg'"
+			exit 1
+		end
+
+		parent = "Unknown_MCU"
+		type_param = ARGV[3] # ToDo: parse params
+		unless type_param.nil?
+			require 'rubimc'
+			RubimCode::Printer.sandbox = true
+
+			type_param = type_param.gsub(/type:/, "")
+			mcu = Controllers.find_mcu("#{type_param}").first
+			if mcu.nil?
+				puts "ERROR: mcu type '#{type_param}'' not found in rubimc libraries"
+				exit 1
+			end
+			series, type = mcu::MCU_SERIES, mcu::MCU_NAME
+			parent = "#{series}_#{type}"
+		end
+
+		generated_text = "
+			require 'rubimc'
+
+			class #{name} < #{parent}
+				def initialize
+				end
+
+				def main_loop # infinit loop, it stop only when IC is reset
+				end
+			end"
+
+	elsif gen_type == 'clearC' # generate template for clear C code
+		name = ARGV[2]
+		if name.nil?
+			puts "ERROR: you must define file name"
+			puts "for example: 'rubimc g clearC ExampleProg'"
+			exit 1
+		end
+
+		generated_text = "
+			require 'rubimc'
+
+			def main(argv)
+			end"
+	else
+		puts "ERROR: unknown param '#{gen_type}'"
+		puts "Available params for generator: mcu; clearC"
+		exit 1
+	end
+
+	generated_text.gsub!(/\t\t\t/, "")
+	generated_text = generated_text[1..-1]
+	if File.exist?("#{name}.rb")
+		puts "WARNING: file '#{name}.rb' already exist. Overrire it (y/n)?"
+		answer = STDIN.gets
+		exit 1 if ["n\n", "N\n"].include? answer
+	end
+	File.open("#{name}.rb", 'w') {|file| file.puts(generated_text) }
+	# => end generate section
+
+elsif exec_type == 'compile'
+
+	puts "\n === Run RubimC compiler === "
+
+	input_files = []
+	if ARGV[1] == '-all' or ARGV[1] == '--all'
+		Dir['*.rb'].each do |file|
+			input_files << file
+		end
+	else
+		ARGV[1] += '.rb' if File.extname(ARGV[1]).empty?
+		input_files << ARGV[1]
+	end
+	ARGV.clear
+
+	unless input_files.any?
+		puts 'No files to compile...'
+		exit 1
+	end
+
+	need_to_clear_release = true
+	input_files.each do |input_file|
+		# === check file exist ===
+		unless File.exist?(input_file)
+		 	puts "ERROR: File \"#{input_file}\" not found"
+		 	puts "Use 'rubimc compile --all' to compile all files in current directory"
+		 	puts ""
+		 	exit 1
+		end
+
+		# === check syntax of user program ===
+		print "Check syntax..."
+		sh "ruby -c '#{input_file}'", verbose: false do |ok, res|
+			exit 1 unless ok # check exit status after command runs
+		end
+
+		# === prepare file names ===
+		input_file = File.expand_path(input_file)
+		basename = File.basename(input_file, ".rb") # extract filename without path and extention 
+		dirname = File.dirname(input_file)
+		release_folder = "#{dirname}/release/"
+		outfile = "#{dirname}/release/#{basename}"
+
+		# === clear directory "release" ===
+		if need_to_clear_release
+			need_to_clear_release = false
+			FileUtils.rm_rf(Dir.glob("#{release_folder}/*"))
+		end
+		Dir.mkdir("#{release_folder}/") unless Dir.exists?("#{release_folder}/")
+
+		# === preprocessing user`s program ===
+		print "preprocessing file \"#{basename}.rb\"..."
+		require 'rubimc/preprocessor'
+		PreProcessor.write_in_file(input_file, dirname, basename, "#{outfile}.rb")
+
+		# === check type: gcc/avr-gcc
+		require "#{outfile}.rb"
+		unless defined? RubimCode
+			puts "ERROR: file '#{outfile}.rb' is not rubimc program"
+			exit 1
+		end
+		RubimCode::Printer.sandbox = true
+		RubimCode::Printer.generate_cc
+		code_type = RubimCode::Printer.code_type
+		mcu_type = RubimCode::Printer.mcu_type
+
+		# === execute preprocessing program, generate C code ===
+		puts "generate C code"
+		sh "ruby '#{outfile}.rb' '#{outfile}'.c", verbose: false do |ok, res|
+			exit 1 unless ok # check exit status after command runs
+		end
+		puts "done"
+
+		# === compile C code to object-code and link to hex/exe ===
+		# ToDo: add DF_CPU (is it need?)
+		if code_type == "avr-gcc"
+			print "compile and link..."
+			sh "avr-gcc -std=c99 -Os -mmcu=#{mcu_type} -c '#{outfile}.c' -o '#{outfile}.o'", verbose: false do |ok, res|
+				exit 1 unless ok # check exit status after command runs
+			end
+			# generate hex for upload to MCU
+			sh "avr-objcopy -O ihex '#{outfile}.o' '#{outfile}.hex'", verbose: false do |ok, res|
+				exit 1 unless ok # check exit status after command runs
+			end
+			puts "done"
+
+		elsif code_type == "gcc"
+			print "compile and link..."
+			sh "gcc  -std=c99 -o '#{outfile}.out' '#{outfile}.c'", verbose: false do |ok, res|
+				exit 1 unless ok # check exit status after command runs
+			end
+			puts "done"
+
+			print "run..."
+			sh "'#{outfile}.out'", verbose: false do |ok, res|
+				exit 1 unless ok # check exit status after command runs
+			end
+		end
+	end
+
+else
+	puts "ERROR: unknown command for rubimc"
+	puts "Available commands: compile; generate;"
+	exit 1
+end

data/lib/rubimc/control_structures.rb

@@ -0,0 +1,58 @@
+class RubimCode
+class << self
+
+	@@rubim_defined_values = []
+
+	def rubim_cond(cond, type="if", &block)
+		# ToDo: auto-define type of ret_value
+		# use::  __rubim__rval__int, __rubim__rval__float, e.t.
+
+		if @@rubim_defined_values.include? @level
+			pout "__rubim__rval#{@level} = 0;"
+		else
+			pout "int __rubim__rval#{@level} = 0;"
+		end
+		@@rubim_defined_values << @level
+
+		if type=="if"
+			pout "if (#{cond}) {"
+		elsif type=="unless"
+			pout "if (!(#{cond})) {"
+		end
+		@level += 1 
+		ret_val = yield
+		pout "__rubim__rval#{@level-1} = #{ret_val};" if ret_val!="__rubim__noreturn"
+		pout "}"
+		@level -= 1
+		return "__rubim__rval#{@level}"
+	end
+
+	def rubim_cycle(type="while", cond="true", &block)
+		pout "#{type} (#{cond}) {"
+		@level+=1
+			yield
+			pout "}"
+		@level-=1
+	end
+
+	def rubim_if(cond, &block); rubim_cond(cond, "if", &block); end
+	def rubim_unless(cond, &block); rubim_cond(cond, "unless", &block); end
+	def rubim_while(cond, &block); rubim_cycle("while", cond, &block); end
+	def rubim_until(cond); rubim_cycle("until", cond, &block); end
+	def rubim_loop(&block); rubim_cycle("while", "true", &block); end
+
+	def rubim_whilemod(cond); pout "} while (#{cond});"; @level-=1; end
+	def rubim_untilmod(cond); pout "} until (#{cond});"; @level-=1; end
+
+	def rubim_ifmod(cond); pout "if (#{cond}) {"; @level+=1; true; end
+	def rubim_unlessmod(cond); pout "if (!(#{cond})) {"; @level+=1; true; end
+	def rubim_begin(); pout "{"; @level+=1; true; end
+	def rubim_end(); pout "}"; @level-=1; "__rubim__noreturn"; end
+	def rubim_tmpif(tmp); end
+
+	def rubim_else(); @level-=1; pout "} else {"; @level+=1; end
+	def rubim_elsif(cond); @level-=1; pout "} else if (#{cond}) {"; @level+=1; end
+	# ToDo: set return_val, like in rubim_if (need to change preprocessor)
+
+end # class << self
+end # RubimCode class