ebngen 1.0.0 → 1.0.1

data/lib/ebngen/adapter/cmake.rb

@@ -0,0 +1,291 @@
+
+require_relative '_base'
+require_relative '_yml_helper'
+require_relative '_path_modifier'
+require_relative 'cmake/txt'
+
+
+#replace me when yml_merger becomes gem
+require 'yml_merger'
+require 'nokogiri'
+require 'uri'
+require 'open-uri'
+
+module CMAKE
+  class Project
+	TOOLCHAIN='cmake'
+	include Base
+	include TXT
+	include UNI_Project
+
+	def initialize(project_data, generator_variable)
+		set_hash(project_data)
+		@project_name = get_project_name()
+		@board = get_board()
+		@paths = PathModifier.new(generator_variable["paths"])
+		@cmake_project_files = {".txt" => nil, ".bat" => nil, ".sh" => nil}
+		@project = Hash.new if @project.nil?
+		@project["document"] = {"project_name" => @project_name, "board" => @board }
+	end
+
+  	def generator(filter, project_data)
+    	create_method(Project::TOOLCHAIN)
+    	send(Project::TOOLCHAIN.to_sym, project_data)
+    	save_project()
+  	end
+
+  	def source()
+  		#add sources to target
+  		sources = get_src_list(Project::TOOLCHAIN)
+  		o_path = get_output_dir(Project::TOOLCHAIN, @paths.rootdir_table)
+  		proj_path = File.join(@paths.rootdir_table['output_root'], o_path)
+  		@project['sources'] = Array.new
+  		sources.each do |src|
+          if src['rootdir']
+            full_path = @paths.fullpath(src['rootdir'],src['path'])
+          else
+            full_path = @paths.fullpath('default_path',src['path'])
+          end
+          ipath = File.join("$ProjDirPath$", @paths.relpath(proj_path, full_path))
+		  @project['sources'].insert(-1, ipath)
+		end
+
+  	end
+
+  	def templates()
+  		#load tempaltes
+  	end
+
+  	def type()
+  		@project['type'] = get_type(Project::TOOLCHAIN)
+  	end
+
+  	def outdir()
+  		puts "#{get_output_dir(Project::TOOLCHAIN, @paths.rootdir_table)}"
+  	end
+
+	def targets()
+		get_targets(Project::TOOLCHAIN).each do |key, value|
+			return if value.nil?
+			@project["target"] = Hash.new if @project["target"].nil?
+			ta = key.upcase
+			@project["target"][ta] = Hash.new if @project["target"][ta].nil?
+			#do the target settings
+			value.each_key do |subkey|
+				methods = self.class.instance_methods(false)
+          		if methods.include?("target_#{subkey}".to_sym)
+            		send("target_#{subkey}".to_sym, key, value[subkey])
+          		else
+            		puts "#{key} is not processed"
+          		end
+			end
+		end
+	end
+
+    # tool_chain_specific attribute for each target
+    # Params:
+    # - target: the name for the target
+    # - doc: the hash that holds the data
+	def target_tool_chain_specific(target, doc)
+		#no specific for cmake
+	end
+
+	def save_project()
+		path = get_output_dir(Project::TOOLCHAIN, @paths.rootdir_table)
+		save(File.join(@paths.rootdir_table['output_root'], path, "CMakeLists.txt"), @project)
+	end
+
+	def target_cp_defines(target, doc)
+		ta = target.upcase
+		@project["target"][ta]['cp_defines'] = Array.new
+		doc.each do |d, v|
+		  if v.nil? 
+		  	st_def = "SET(CMAKE_C_FLAGS_#{ta} \"${CMAKE_C_FLAGS_#{ta}} -D#{d} \""
+		  else
+		  	st_def = "SET(CMAKE_C_FLAGS_#{ta} \"${CMAKE_C_FLAGS_#{ta}} -D#{d}=#{v} \""
+		  end
+		  @project["target"][ta]['cp_defines'].insert(-1, st_def)
+		end
+	end
+
+	def target_as_predefines(target, doc)
+
+	end
+
+	def target_as_defines(target, doc)
+		ta = target.upcase
+		@project["target"][ta]['as_defines'] = Array.new
+		doc.each do | d, v|
+		  if v.nil? 
+		  	st_def = "SET(CMAKE_ASM_FLAGS_#{ta} \"${CMAKE_ASM_FLAGS_#{ta}} -D#{d} \""
+		  else
+		  	st_def = "SET(CMAKE_ASM_FLAGS_#{ta} \"${CMAKE_ASM_FLAGS_#{ta}} -D#{d}=#{v} \""
+		  end
+		  @project["target"][ta]['as_defines'].insert(-1, st_def)
+		end
+	end
+
+	def target_as_include(target, doc)
+		ta = target.upcase
+		o_path = get_output_dir(Project::TOOLCHAIN, @paths.rootdir_table)
+  		proj_path = File.join(@paths.rootdir_table['output_root'], o_path)
+		@project["target"][ta]['as_include'] = Array.new
+		doc.each do |inc|
+          if inc['rootdir']
+            full_path = @paths.fullpath(inc['rootdir'],inc['path'])
+          else
+            full_path = @paths.fullpath('default_path',inc['path'])
+          end
+          ipath = File.join("$ProjDirPath$", @paths.relpath(proj_path, full_path))
+		  inc_str = "include_directories(#{ipath})"
+		  @project["target"][ta]['as_include'].insert(-1, inc_str)
+		end
+	end
+
+	def target_as_flags(target, doc)
+		ta = target.upcase
+		@project["target"][ta]['as_flags'] = Array.new
+		doc.each do |flag|
+		  @project["target"][ta]['as_flags'].insert(-1, "SET(CMAKE_ASM_FLAGS_#{ta} \"\$\{CMAKE_ASM_FLAGS_#{ta}\} #{flag}\")")
+		end
+	end
+
+	def target_cc_predefines(target, doc)
+
+	end
+
+	def target_cc_preincludes(target, doc)
+
+	end
+
+	def target_cc_defines(target, doc)
+		ta = target.upcase
+		@project["target"][ta]['cc_defines'] = Array.new
+		doc.each do |d, v|
+		  if v.nil? 
+		  	st_def = "SET(CMAKE_C_FLAGS_#{ta} \"${CMAKE_C_FLAGS_#{ta}} -D#{d} \""
+		  else
+		  	st_def = "SET(CMAKE_C_FLAGS_#{ta} \"${CMAKE_C_FLAGS_#{ta}} -D#{d}=#{v} \""
+		  end
+		  @project["target"][ta]['cc_defines'].insert(-1, st_def)
+		end
+	end
+
+	def target_cc_include(target, doc)
+		ta = target.upcase
+		o_path = get_output_dir(Project::TOOLCHAIN, @paths.rootdir_table)
+  		proj_path = File.join(@paths.rootdir_table['output_root'], o_path)
+		@project["target"][ta]['cc_include'] = Array.new
+		doc.each do |inc|
+          if inc['rootdir']
+            full_path = @paths.fullpath(inc['rootdir'],inc['path'])
+          else
+            full_path = @paths.fullpath('default_path',inc['path'])
+          end
+          ipath = File.join("$ProjDirPath$", @paths.relpath(proj_path, full_path))
+		  inc_str = "include_directories(#{ipath})"
+		  @project["target"][ta]['cc_include'].insert(-1, inc_str)
+		end
+	end
+
+	def target_cc_flags(target, doc)
+		ta = target.upcase
+		@project["target"][ta]['cc_flags'] = Array.new
+		doc.each do |flag|
+		  @project["target"][ta]['cc_flags'].insert(-1, "SET(CMAKE_C_FLAGS_#{ta} \"\$\{CMAKE_C_FLAGS_#{ta}\} #{flag}\")")
+		end
+	end
+
+	def target_cxx_predefines(target, doc)
+
+	end
+
+	def target_cxx_preincludes(target, doc)
+
+	end
+
+	def target_cxx_defines(target, doc)
+		ta = target.upcase
+		@project["target"][ta]['cxx_defines'] = Array.new
+		doc.each do |d, v|
+		  if v.nil? 
+		  	st_def = "SET(CMAKE_CXX_FLAGS_#{ta} \"${CMAKE_CXX_FLAGS_#{ta}} -D#{d} \""
+		  else
+		  	st_def = "SET(CMAKE_CXX_FLAGS_#{ta} \"${CMAKE_CXX_FLAGS_#{ta}} -D#{d}=#{v} \""
+		  end
+		  @project["target"][ta]['cxx_defines'].insert(-1, st_def)
+		end
+	end
+
+	def target_cxx_include(target, doc)
+		ta = target.upcase
+		o_path = get_output_dir(Project::TOOLCHAIN, @paths.rootdir_table)
+  		proj_path = File.join(@paths.rootdir_table['output_root'], o_path)
+		@project["target"][ta]['cxx_include'] = Array.new
+		doc.each do |inc|
+          if inc['rootdir']
+            full_path = @paths.fullpath(inc['rootdir'],inc['path'])
+          else
+            full_path = @paths.fullpath('default_path',inc['path'])
+          end
+          ipath = File.join("$ProjDirPath$", @paths.relpath(proj_path, full_path))
+		  inc_str = "include_directories(#{ipath})"
+		  @project["target"][ta]['cxx_include'].insert(-1, inc_str)
+		end
+	end
+
+	def target_cxx_flags(target, doc)
+		ta = target.upcase
+		@project["target"][ta]['cxx_flags'] = Array.new
+		doc.each do |flag|
+		  @project["target"][ta]['cxx_flags'].insert(-1, "SET(CMAKE_CXX_FLAGS_#{ta} \"\$\{CMAKE_CXX_FLAGS_#{ta}\} #{flag}\")")
+		end
+	end
+
+	def target_ld_flags(target, doc)
+		ta = target.upcase
+		@project["target"][ta]['ld_flags'] = Array.new
+		doc.each do |flag|
+		  @project["target"][ta]['ld_flags'].insert(-1, "SET(CMAKE_EXE_LINKER_FLAGS_#{ta} \"\$\{CMAKE_EXE_LINKER_FLAGS_#{ta}\} #{flag}\")")
+		end
+	end
+
+	def target_libraries(target, doc)
+		ta = target.upcase
+		convert_string = {'DEBUG' => 'debug', 'RELEASE' => 'optimized'}
+		@project["target"][ta]['libraries'] = Array.new
+		header = "TARGET_LINK_LIBRARIES(#{project_name}.elf -Wl,--start-group)"
+		@project["target"][ta]['libraries'].insert(-1, header)
+		doc.each do |library|
+		  lib = "target_link_libraries(#{project_name}.elf #{convert_string[ta]} #{library})"
+		  @project["target"][ta]['libraries'].insert(-1, lib)
+		end
+		footer = "TARGET_LINK_LIBRARIES(#{project_name}.elf -Wl,--end-group)"
+		@project["target"][ta]['libraries'].insert(-1, footer)
+	end
+
+	def target_linker_file(target, doc)
+		ta = target.upcase
+		o_path = get_output_dir(Project::TOOLCHAIN, @paths.rootdir_table)
+  		proj_path = File.join(@paths.rootdir_table['output_root'], o_path)
+		@project["target"][ta]['linker_file'] = Array.new
+	    if doc['rootdir']
+	      full_path = @paths.fullpath(doc['rootdir'],doc['path'])
+	    else
+	      full_path = @paths.fullpath('default_path',doc['path'])
+	    end
+	    link = File.join("${ProjDirPath}", @paths.relpath(proj_path, full_path))
+		linkstr = "set(CMAKE_EXE_LINKER_FLAGS_#{ta} \"${CMAKE_EXE_LINKER_FLAGS_#{ta}} -T#{link} -static\")"
+		@project["target"][ta]['linker_file'].insert(-1, linkstr)
+	end
+
+	def target_binary_file(target, doc)
+		ta= target.upcase
+		@project["target"][ta]["binary_file"] = doc
+	end
+
+	def target_outdir(target, doc)
+
+	end
+  end
+end # end Module IAR

data/lib/ebngen/adapter/iar/ewd.rb

@@ -0,0 +1,6 @@
+
+
+module EWD
+
+
+end

data/lib/ebngen/adapter/iar/ewp.rb

@@ -0,0 +1,250 @@
+require 'nokogiri'
+require 'pathname'
+#require 'FileUtils'
+
+class Hash
+ def to_xml(doc)
+   return if doc.nil?
+   self.each do |key, value|
+     if doc.css("/#{key}").count == 0
+       mynode = Nokogiri::XML::Node.new key, doc
+     else
+       mynode = doc.css("/#{key}")[0]
+     end
+     doc.add_child mynode
+     value.to_xml(mynode) if value.class == Hash
+     mynode.content = value if value.class == String or value.class == Fixnum
+   end
+   return doc
+ end #end to_xml
+end #end Hash
+
+module EWP
+  def load_node(doc, xpath)
+  	return doc.xpath(xpath)
+  end
+
+  def new_target(target, doc, name = 'debug')
+  	nset = load_node(doc, "/project/configuration")
+  	#use existing one
+  	nset.each do |element|
+  		if element.xpath("name").text.downcase == target.downcase
+  			return element
+  		end
+  	end
+  	#create new one
+  	nset.each do |element|
+  		#use the first available configuration
+  		t = element.dup
+  		t.xpath('name').text = target
+  			#doc.xpath("/project") << t
+  		element.add_previous_sibling(t)
+  		return t
+  	end
+	 nil
+  end
+  
+  # remove_targets remove unused targets
+  # Params:
+  # - doc: the xml node project file
+  # - targets_in: used target array
+  def remove_targets(doc, targets_in)
+  	#remove the target that not in the targets_in
+  	nset = load_node(doc, "//project/configuration")
+  	targets_in.collect{|x| x.downcase}
+    nset.each do |element|
+  	  target = element.xpath("name").text.downcase
+  	  if !targets_in.include?(target)
+  	  	element.remove
+  	  end	
+	  end
+  end
+
+  def remove_sources(doc)
+    puts "remove source"
+    groups = load_node(doc, "//group")
+    groups.each do |ele|
+      ele.remove
+    end
+    files = load_node(doc, "//file")
+    files.each do |ele|
+      ele.remove
+    end   
+  end
+
+  def remove_unused(doc, xpath, **names)
+  	nset = load_node(doc, xpath)
+ 	  nset.each do |element|
+ 		  names.each do |key, value|
+			  if element.xpath(key).text.downcase == value.downcase
+				  element.remove
+			  end
+		  end
+	  end
+  end
+
+  def create_node(doc, hash_value)
+    hash_value.to_xml(doc)
+  end
+
+  def add_specific(target_node, doc)
+    doc.each do |key, value|
+      checked = false
+      options = target_node.xpath("//option")
+      options.each do |option|
+        if option.css('name').text == key
+          value.each do |subkey, subvalue|
+            if subvalue.class == String
+              if option.css(subkey)[0].content.nil?
+                option.css(subkey)[0].content = subvalue
+              else
+                create_node(option, {subkey => subvalue})
+              end
+            elsif subvalue.class == Array
+              subvalue.each do |line|
+                create_node(option, {subkey => line})
+              end
+            else
+              puts "not supported format must be string or array"
+              next
+            end
+          end
+          #processing done
+          checked = true
+          break
+        end
+      end
+      if !checked
+        #not an exist option need create new node
+        data_node = target_node.xpath('data')
+        option_node = create_node(data_node, "option" => nil)
+        create_node(option_node, {"name" => key})
+        value.each do |subkey, subvalue|
+          if subvalue.class == String
+            create_node(option_node, {subkey => subvalue})
+          elsif subvalue.class == Array
+            subvalue.each do |line|
+              create_node(option_node, {subkey => line})
+            end
+          else
+            puts "not supported format must be string or array"
+            next
+          end
+        end
+      end
+      if !checked
+        puts "can not find match for #{key}"
+      end
+    end
+  end
+
+  def set_specific(target_node, doc)
+  	doc.each do |key, value|
+      checked = false
+  		options = target_node.xpath("//option")
+  		options.each do |option|
+  			if option.css('name').text == key
+  				value.each do |subkey, subvalue|
+            if subvalue.class == String
+              if option.css(subkey)[0].content.nil?
+                option.css(subkey)[0].content = subvalue
+              else
+                create_node(option, {subkey => subvalue})
+              end
+            elsif subvalue.class == Array
+              subvalue.each do |line|
+                create_node(node, {subkey => line})
+              end
+            else
+              puts "not supported format must be string or array"
+              next
+            end
+  				end
+          #processing done
+          checked = true
+          break
+  			end
+  		end
+      if !checked
+        #not an exist option need create new node
+        #not an exist option need create new node
+        data_node = target_node.xpath('data')
+        option_node = create_node(data_node, "option" => nil)
+        create_node(option_node, {"name" => key})
+        value.each do |subkey, subvalue|
+          if subvalue.class == String
+            create_node(option_node, {subkey => subvalue})
+          elsif subvalue.class == Array
+            subvalue.each do |line|
+              create_node(option_node, {subkey => line})
+            end
+          else
+            puts "not supported format must be string or array"
+            next
+          end
+        end
+      end
+      if !checked
+        puts "can not find match for #{key}"
+      end
+  	end
+  end
+
+  def save(xml, path)
+    Core.assert(path.is_a?(String)) do
+        "param is not a string #{path.class.name}"
+    end
+    FileUtils.mkdir_p File.dirname(path) if ! File.exist?(File.dirname(path))
+    File.write(path, xml.to_xml)
+  end
+
+  def add_sources(doc, source_hash, path_mod, proj_path)
+    groups_existing = Array.new
+    files_hash = Hash.new
+    source_hash.each do |src|
+      rootdir = src['rootdir']
+      virtual_dir = src['virtual_dir']
+      path = src['path']
+      if virtual_dir
+        if ! groups_existing.include?(virtual_dir)
+          groups_existing.insert(-1, virtual_dir)
+          node = Nokogiri::XML::Node.new 'group', doc
+          node << "<name>#{virtual_dir}</name>"
+          doc.root << node
+        end
+        files_hash[virtual_dir] = Array.new if files_hash[virtual_dir].nil?
+        files_hash[virtual_dir].insert(-1, {'path' => path, 'rootdir' => rootdir})
+      else
+        files_hash["_"] = Array.new if files_hash["_"].nil?
+        files_hash["_"].insert(-1, {'path' => path, 'rootdir' => rootdir})
+      end
+    end #end source_hash
+    doc.css("//group").each do |node|
+      files_hash[node.text].each do |file|
+        gfiles = Nokogiri::XML::Node.new('file', node)
+        sfile = Nokogiri::XML::Node.new('name', gfiles)
+        if file['rootdir']
+          full_path = path_mod.fullpath(file['rootdir'],file['path'])
+        else
+          full_path = path_mod.fullpath('default_path',file['path'])
+        end
+        sfile.content = File.join("$PROJ_DIR$", path_mod.relpath(proj_path, full_path))
+        gfiles << sfile
+        node << gfiles
+      end
+    end
+    return if files_hash["_"].nil?
+    files_hash["_"].each do |file|
+      gfiles = Nokogiri::XML::Node.new('file', doc)
+      sfile = Nokogiri::XML::Node.new('name', gfiles)
+      if file['rootdir']
+        full_path = path_mod.fullpath(file['rootdir'],file['path'])
+      else
+        full_path = path_mod.fullpath('default_path',file['path'])
+      end
+      sfile.content = File.join("$PROJ_DIR$", path_mod.relpath(proj_path, full_path))
+      gfiles << sfile
+      doc.root << gfiles
+    end
+  end
+end

data/lib/ebngen/adapter/iar/eww.rb

@@ -0,0 +1,62 @@
+
+require 'nokogiri'
+
+
+module EWW
+
+    def add_batch_project_target(xml, batchname, project, target)
+        definition_node = xml.at_xpath("/workspace/batchBuild/batchDefinition[name[text()='#{batchname}']]")
+        unless (definition_node)
+            build_node = xml.at_xpath("/workspace/batchBuild")
+            unless (build_node)
+                workspace_node = xml.at_xpath("/workspace")
+                Core.assert(workspace_node, "no <workspace> present")
+                # <batchBuild>
+                build_node = Nokogiri::XML::Node.new("batchBuild", xml)
+                workspace_node << build_node
+            end
+            # <batchDefinition>
+            definition_node = Nokogiri::XML::Node.new("batchDefinition", xml)
+            build_node << definition_node
+            # <name>
+            name_node = Nokogiri::XML::Node.new("name", xml)
+            name_node.content = batchname
+            definition_node << name_node
+        end
+        # <member>
+        member_node = Nokogiri::XML::Node.new("member", xml)
+        definition_node << member_node
+        # <project>
+        project_node = Nokogiri::XML::Node.new("project", xml)
+        project_node.content = project
+        member_node << project_node
+        # <configuration>
+        configuration_node = Nokogiri::XML::Node.new("configuration", xml)
+        configuration_node.content = target
+        member_node << configuration_node
+    end
+
+
+    def add_project(xml , project_path)
+        # find <ProjectWorkspace>
+        workspace_node = xml.at_xpath('/workspace')
+        # add <project>
+        project_node = Nokogiri::XML::Node.new("project", xml)
+        workspace_node << project_node
+        # add <PathAndName>
+        path_node = Nokogiri::XML::Node.new("path", xml)
+        path_node.content = project_path
+        project_node << path_node
+        # add project into existing lists
+        #@projects[ project_path ] = project_node
+    end
+
+	def save(xml, path)
+		Core.assert(path.is_a?(String)) do
+		    "param is not a string #{path.class.name}"
+		end
+        FileUtils.mkdir_p File.dirname(path) if ! File.exist?(File.dirname(path))
+		File.write(path, xml.to_xml)
+	end
+
+end