rubimc 0.2.1

data/lib/rubimc/printer.rb

@@ -0,0 +1,143 @@
+def print_comment(comment)
+	comment.lines.each do |line|
+		RubimCode.pout "// #{line}"
+	end
+end
+
+def printf(str, *args)
+	if args.empty?
+		RubimCode.pout("printf(#{str.dump});")
+	else
+		args_str = args.join(', ')
+		RubimCode.pout("printf(#{str.dump}, #{args_str});")
+	end
+end
+
+
+class RubimCode
+class << self
+
+	attr_accessor :level
+	def level
+		@level = 0 if @level.nil?
+		@level
+	end
+
+	def perror(error_message)
+		if error_message.nil? or error_message.to_s.nil? 
+			raise ArgumentError, "error message is not string" 
+		end
+
+		error_message += "\n"
+		code_ptr = caller_locations(2)
+		code_ptr.each do |place| 
+			place = place.to_s
+			place.gsub!(/^release\/pre_/, '')
+			error_message += "\tfrom #{place}\n"
+		end
+		puts "#ERROR: #{error_message}"
+		exit 1
+	end
+
+	def pout(str = "")
+		return if RubimCode::Printer.sandbox == true # don`t print output in sandbox
+
+		if str.nil? or str.to_s.nil?
+			raise ArgumentError, "str is nil"
+		else
+			@level = 0 if @level.nil?
+			res_str = " "*4*@level + str.to_s 
+			if (($pout_destination == :default) or ($pout_destination.nil?))
+				puts res_str
+				unless defined? TEST_MODE
+					File.open("#{ARGV[0]}", 'a+') {|file| file.puts(res_str) }
+				end
+			else
+				$pout_destination.concat(res_str).concat("\n")
+			end
+		end
+	end
+
+	# ToDo: remove to RubimCode::Printer
+	$pout_destination = :default
+	def pout_destination=(dest)
+		if dest.nil?
+			perror "Wrong parameter for method #{__method__}. Set destination string"
+		end
+
+		if dest.class.name == "String" or dest == :default # dest.is_a? not work...WTF
+			$pout_destination = dest
+		else
+			perror "Wrong parameter for method #{__method__}. Only string variable or ':default' value is permit as a parameters"
+		end
+	end
+
+	def clear_c(str)
+		pout "// generate with clear_c function"
+		pout str
+		pout "// end clear_c function"
+	end
+
+
+end # class << self
+end # RubimCode class
+
+class RubimCode::Printer
+	class << self
+		attr_accessor :sandbox
+	end
+
+	def self.code_type
+		if not Controllers.all.empty?
+			"avr-gcc" 
+		elsif Controllers.all.empty? and eval("self.private_methods.include? :main")
+			"gcc"
+		else
+			RubimCode.perror "Can not to define type of code"
+		end
+	end
+
+	def self.mcu_type
+		code_type == "avr-gcc" ? Controllers.all.first::MCU_NAME : "undefined"
+	end
+
+	def self.print_main_loop
+		RubimCode.pout
+		RubimCode.pout "// === Main Infinite Loop === //"
+		RubimCode.pout "while (true) {"
+			RubimCode.level += 1
+			yield # print body of main loop
+			RubimCode.level -= 1
+		RubimCode.pout"} // end main loop"
+	end
+
+	def self.generate_cc
+		if Controllers.all.count > 1
+			RubimCode.perror "In current version in one file you can define only one Controller Class"
+		end
+
+		if self.code_type == "avr-gcc" # if compile program for MCU
+			Controllers.all.each do |controllerClass|
+				controllerClass.print_layout(:before_main)
+				controller = controllerClass.new # print initialize section
+				print_main_loop {controller.main_loop} # print body of main loop
+				controllerClass.print_layout(:after_main)
+				RubimCode::Interrupts.print
+			end # each Controllers.all
+
+		elsif self.code_type == "gcc" # if compile clear-C program 
+			if Controllers.all.empty? and eval("self.private_methods.include? :main")
+				Controllers.print_cc_layout(:before_main)
+				eval("main(RubimCode::CC_ARGS.new)") # execute method :main (CC_ARGS - helper for C agruments argc/argv)
+				Controllers.print_cc_layout(:after_main)
+			end
+		end
+	end
+
+	END { # execute when user`s program is end
+		exit 0 if defined? TEST_MODE
+		exit 0 if sandbox == true
+		self.generate_cc
+		exit 0
+		}
+end

data/lib/rubimc/ruby_classes.rb

@@ -0,0 +1,54 @@
+class Object
+	def not_nil?
+		!self.nil?
+	end
+
+	def has_parent?(name)
+		return false unless self.respond_to? :ancestors
+		self!=name and self.ancestors.include?(name)
+	end
+
+	def to_rubim
+		type = case self.class.name
+					when "Fixnum" then 'int'
+					when "Float" then 'float'
+					when "String" then 'string'
+					else nil
+				end
+		if type.nil? or self.to_s.nil?
+			perror "Неизвестный тип переменной"
+		end
+		UserVariable.new(self.to_s, type)
+	end
+
+	def in?(array)
+		array.each {|el| return true if el == self}
+		return false
+	end
+
+end
+
+class Class
+	# get list of all childs inhereted from self class
+	def descendants
+		ObjectSpace.each_object(Class).select { |klass| klass < self }
+	end # see alternative realization: http://apidock.com/rails/Class/descendants
+end
+
+class Hash
+	def permit_and_default! (**args)
+		self.keys.each do |param|
+			if not args.keys.include? param
+			    mname = caller_locations(1)[2].label
+			    perror "Method '#{mname}' have no param: #{param}}" 
+			end
+		end
+
+        args.keys.each do |param|
+		    self[param] = args[param] if self[param].nil?
+        end
+
+	end
+end
+
+

data/lib/rubimc.rb

@@ -0,0 +1,234 @@
+#####################################################################
+# RubimCode CORE													#
+# 																	#
+# Author: Evgeny Danilov											#
+# Created at 2016 March-14											#
+#####################################################################
+class RubimCode; end
+
+require "version"
+require "rubimc/ruby_classes"
+
+require "rubimc/io_ports"
+require "rubimc/controllers"
+require "rubimc/mcu/avr/avr_controller"
+
+require "rubimc/printer"
+require "rubimc/init_var"
+require "rubimc/control_structures"
+
+class RubimCode
+
+	class UserVariable
+		attr_accessor :name, :type
+		# attr_accessor :level # ToDo: для указания области видимости
+		def initialize(name, type = "undefined")
+			@name, @type = name.to_s, type.to_s
+		end
+
+		def to_s
+			"(" + self.name + ")"
+		end
+
+		def to_i
+			@name.to_i
+		end
+
+		def to_rubim
+			self
+		end
+
+		def c_assign=(val) 
+			RubimCode.pout "#{@name} = #{val};"
+		end
+
+		def common_operator(val, operator_sym)
+			if not val.class.respond_to? :to_s
+				RubimCode.perror "Conversion of variable #{val} is impossible. Method 'to_s' not found"
+			else 
+				UserVariable.new(self.name + operator_sym.to_s + val.to_s)
+			end
+		end
+
+		# Arithmetic Operators:
+		def +(val);	common_operator(val, __method__); end
+		def -(val);	common_operator(val, __method__); end
+		def *(val);	common_operator(val, __method__); end
+		def /(val);	common_operator(val, __method__); end
+		def %(val);	common_operator(val, __method__); end
+		def **(val);common_operator(val, __method__); end
+
+		# Operators +=, -=, e.t.
+		# ToDo: (can not override; use preprocessor)
+
+		# Unary Operators:
+		def -@; UserVariable.new("(-" + self.name + ")"); end
+		def +@; UserVariable.new("(+" + self.name + ")"); end
+		def !@; UserVariable.new("(+" + self.name + ")"); end
+		def ~@; UserVariable.new("(+" + self.name + ")"); end
+
+		# Comparison Operators:
+		def ==(val);	common_operator(val, __method__); end
+		def !=(val);	common_operator(val, __method__); end
+		def  <(val);	common_operator(val, __method__); end
+		def  >(val);	common_operator(val, __method__); end
+		def <=(val);	common_operator(val, __method__); end
+		def >=(val);	common_operator(val, __method__); end
+
+		# Binary Operators:
+		def &(val); common_operator(val, __method__); end
+		def |(val); common_operator(val, __method__); end
+		def ^(val); common_operator(val, __method__); end
+		def <<(val); common_operator(val, __method__); end
+		def >>(val); common_operator(val, __method__); end
+
+		# Logical Operators: (and, or, not, &&, ||)
+		# can not override, use preprocessor
+
+		# Ternary Operators: (? :)
+		# ToDo...
+
+		# Ruby Parallel Assignment:
+		# a, b, c = 10, 20, 30 # ToDo
+
+		# ToDo: операторы, которым нет аналогов в Си
+		# def <=>(val);	??? end
+		# def ===(val);	??? end
+		# def =~(val);	??? end
+		# def !~(val);	??? end
+
+		# Range-operators ".." and "..."
+		# ToDo: is it need? or use Enumerator?
+
+		def times
+			n = LoopCounter.new
+			RubimCode.pout ("for (int #{n}=0; #{n}<#{self}; #{n}++) {")
+			RubimCode.level += 1
+			yield(n)
+			RubimCode.pout ("}")
+			RubimCode.level -= 1
+		end
+
+		# ToDo: add mixins Enumerable and Comparable
+	end
+
+	# ToDo: в Ruby присваивание значений индексной переменной 
+	# не должно влиять на выполнение цикла
+	# например следующий цикл будет выполнен ровно 10 раз
+	# for var in 1..10; var = var+2; end
+	class LoopCounter < UserVariable
+		def initialize
+			name = "i" + RubimCode.level.to_s
+			# ToDo - вместо "i" - __rubim__i
+			super(name)
+		end
+
+		def to_s
+			self.name
+		end
+	end
+
+	class UserArray < Array
+		attr_accessor :name, :type
+
+		def []=(index, val)
+			RubimCode.pout "#{@name}[#{index.to_i}] = #{val.to_s};"
+		end
+
+		def [](index)
+			super index.to_i
+		end
+
+		def each
+			n = LoopCounter.new
+			RubimCode.pout "for (int #{n}=0; #{n}<#{self.size}; #{n}++) {"
+			RubimCode.level +=1
+			joy_name = self.name + "[#{n}]"
+			yield(self[0].class.new("#{joy_name}"))
+			RubimCode.level -=1
+			RubimCode.pout "}"
+		end
+	end
+
+	# Наследник всех пользовательских классов
+	class UserClass < UserVariable
+
+		# список всех пользовательских "свойств" класса
+		@@var_array = {}
+		def self.add_var_array(user_class_name, value)
+			@@var_array[user_class_name.to_sym] ||= []
+			@@var_array[user_class_name.to_sym] << value
+		end
+
+		# генерация класса (typedef struct + методы)
+		def self.generate_struct
+			RubimCode.pout "typedef struct {"
+			RubimCode.level +=1
+			@@var_array[self.to_s.to_sym].each do |var| 
+				RubimCode.pout "#{var.type} #{var.name};"
+			end
+			RubimCode.pout "} #{self.to_s};"
+			RubimCode.level -=1
+
+			public_instance_methods(false).each do |method_name| 
+				tmp_str = ""
+				pout_destination = tmp_str
+				return_var = self.new("(*params)").send(method_name).to_rubim
+				pout_destination = :default
+				return_var.type = "void" if return_var.type.nil? # if type is not set
+
+				RubimCode.pout "#{return_var.type} #{method_name.to_s} (#{self.to_s} *params) {"
+				RubimCode.level += 1
+					self.new("(*params)").send(method_name)
+					RubimCode.pout "return #{return_var};"
+					RubimCode.pout "}"
+				RubimCode.level -= 1
+			end
+		end
+
+		def self.redefine_users_methods
+			public_instance_methods(false).each do |method_name|
+				define_method(method_name) do
+					"#{__method__}(&#{self.name})" 
+				end
+			end
+		end
+
+	end
+
+	# Список аппаратных прерываний (содержит Си-код в текстовом виде)
+	class Interrupts
+		@@interrupt_array = []
+
+		def self.array
+			@@interrupt_array
+		end
+
+		def self.add(val)
+			if val.class.name == "String"
+				@@interrupt_array << val
+			else
+				RubimCode.perror "wrong params in method #{__method__}"
+			end
+		end
+
+		def self.print
+			@@interrupt_array.each do |interrupt_code|
+				RubimCode.pout interrupt_code
+				end
+		end
+	end
+
+	class CC_ARGS # class for arguments when work with clear C-code
+		def count
+			RubimCode::UserVariable.new("argc", "int")
+		end
+
+		def [](index)
+			RubimCode::UserVariable.new("argv[#{index}]", "int")
+		end
+	end
+
+end 
+# === END class RubimCode === #
+

data/lib/version.rb

@@ -0,0 +1,3 @@
+class RubimCode
+	VERSION = "0.2.1" 
+end

metadata

@@ -0,0 +1,60 @@
+--- !ruby/object:Gem::Specification
+name: rubimc
+version: !ruby/object:Gem::Version
+  version: 0.2.1
+platform: ruby
+authors:
+- Evgeny Danilov
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2016-04-27 00:00:00.000000000 Z
+dependencies: []
+description: Ruby compiler and framework for microcontrollers like AVR, PIC & STM.
+  It was designed to simplify the process of programming microcontrollers, but can
+  also be used as an clear С-code generator that can be compiled with gcc
+email: jmelkor@rambler.ru
+executables:
+- rubimc
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE.md
+- README.md
+- bin/rubimc
+- lib/rubimc.rb
+- lib/rubimc/control_structures.rb
+- lib/rubimc/controllers.rb
+- lib/rubimc/init_var.rb
+- lib/rubimc/io_ports.rb
+- lib/rubimc/mcu/avr/attiny13.rb
+- lib/rubimc/mcu/avr/avr_controller.rb
+- lib/rubimc/preprocessor.rb
+- lib/rubimc/printer.rb
+- lib/rubimc/ruby_classes.rb
+- lib/version.rb
+homepage: https://github.com/jmelkor/RubimC
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.4.5
+signing_key: 
+specification_version: 4
+summary: 'RubimC: Framework for MCU - 0.2.1'
+test_files: []