shog-build 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 5054b9f6f86bbdef798bcba4906245c4112bd59bdeb7865d904f07c15b04c7c3
+  data.tar.gz: 244eb986186f443c54a123adb30a3b5e79aa73b38189600ad744a38867bc4c2c
+SHA512:
+  metadata.gz: 537d73019d1952b24f1b05c2cae0b03d30dde67584e0fc670189a94aa8e4aa673b13d214cf5c3e291d38aeaa9ca83b71a66f9aa996513992adc314ca4918f964
+  data.tar.gz: efd5400d63f73c8a11d01f92a5ef12fe25db21452690a6b67d05bad4d0134f366b0704111aadba475229cd2c158bb297032d5b6c2c359816cf8e62e1dcbce658

data/LICENSE.md

@@ -0,0 +1,20 @@
+Copyright (c) 2017 [Anatol Pomozov](https://github.com/anatol).
+
+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,7 @@
+# Shog Build Generator
+
+A Ruby generator for [Ninja](https://ninja-build.org/) build system.
+
+## Credits
+
+Developed by Anatol Pomozov.

data/bin/shog

@@ -0,0 +1,5 @@
+#!/usr/bin/ruby
+
+require_relative '../lib/runner'
+
+Shog::Runner.run(ARGV)

data/lib/context.rb

@@ -0,0 +1,87 @@
+require_relative 'util'
+require_relative 'pathset'
+
+module Shog
+  # An instance of this class is visible to our build scripts with name @shog
+  class Context
+    attr_accessor :default_target, :rule, :config
+
+    def initialize(backend, emitter)
+      @backend = backend
+      @emitter = emitter
+
+      @rule = {}
+      @default_target = PathSet.new
+      @config = {}
+    end
+
+    def register_rule(type)
+      r = type.new
+      @emitter.rule(r)
+      @rule[r.id] = r
+    end
+
+    def bind
+      binding
+    end
+
+    def visit_dir(dir, new_ctx = true)
+      old_pwd = Path.pwd
+      ctx = new_ctx ? deep_clone() : self
+
+      Path.pwd = File.join(Path.pwd, dir)
+      script = cwd('shog.build')
+      @rule[:generate_build].deps << script
+      script_name = script.path
+      build_script = File.read(script_name)
+      out = ctx.bind.eval(build_script, script_name)
+
+      Path.pwd = old_pwd
+
+      return out
+    end
+
+    def visit(dirs)
+      case dirs
+      when String then visit_dir(dirs)
+      when Array then dirs.map { |d| visit_dir(d) }.flatten
+      else raise "Unknown object type for dirs: #{dirs.class.name}"
+      end
+    end
+
+    def cwd(src)
+      Path.make(src)
+    end
+
+    def emit(rule_id, src, params = {})
+      r = @rule[rule_id]
+      raise "Rule #{rule_id} is not registered" unless r
+
+      params[:input] = PathSet.make(src)
+      target = r.target(params)
+      # fix path to inputs, outputs, includes
+
+      @emitter.emit(target)
+      return target[:output]
+    end
+
+    def emit_each(rule_id, srcs, params = {})
+      out = []
+      for s in srcs
+        p = params.dup
+        p[:input] = s
+        out += emit(rule_id, s, p)
+      end
+      return out
+    end
+
+    def deep_clone
+      ctx = Context.new(@backend, @emitter)
+      ctx.rule = @rule.deep_clone
+      ctx.rule[:generate_build].deps = @rule[:generate_build].deps # deps are global across the build
+      ctx.default_target = @default_target.deep_clone
+      ctx.config = @config
+      ctx
+    end
+  end
+end

data/lib/generator.rb

@@ -0,0 +1,39 @@
+require_relative 'context'
+require_relative 'rule/cc'
+require_relative 'rule/link'
+require_relative 'rule/objcopy'
+require_relative 'rule/kconfig'
+require_relative 'rule/generate_build'
+require_relative 'rule/yacc'
+
+module Shog
+  class Generator
+    def initialize(backend)
+      @backend = backend
+    end
+
+    def generate
+      emitter = @backend.emitter
+      ctx = Context.new(@backend, emitter)
+
+      if File.exists?('Kconfig') and not File.exists?('.config')
+        system 'conf --alldefconfig -s Kconfig'
+      end
+
+      # Register all rules
+      ctx.register_rule(CC)
+      ctx.register_rule(Link)
+      ctx.register_rule(ObjCopy)
+      ctx.register_rule(Kconfig)
+      ctx.register_rule(GenerateBuild)
+      ctx.register_rule(Yacc)
+
+      Path.pwd = '.'
+      ctx.visit_dir('.', false)
+
+      emitter.default(ctx.default_target)
+
+      emitter.finish
+    end
+  end
+end

data/lib/ninja.rb

@@ -0,0 +1,65 @@
+module Shog
+  class Ninja
+    attr_reader :backend_file
+
+    def initialize
+      @out_dir = 'out'
+      @backend_file = File.join(@out_dir, 'build.ninja')
+    end
+
+    def configured?
+      File.exists?(@backend_file)
+    end
+
+    def emitter
+      Emitter.new(@backend_file)
+    end
+
+    def run
+      system "ninja -C #{@out_dir}"
+    end
+
+    class Emitter
+      def initialize(file)
+        @out = File.open(file, 'w')
+      end
+
+      def finish
+        @out.close
+      end
+
+      def default(target)
+        unless target.empty?
+          @out.puts "default #{target.join(' ')}"
+          @out.puts
+        end
+      end
+
+      def rule(r)
+        vars = r.rule
+        @out.puts "rule #{r.id.to_s}"
+        for k, v in vars
+          @out.puts "  #{k}=#{v}"
+        end
+        @out.puts
+      end
+
+      def emit(target)
+        rule = target[:rule]
+        input = target[:input].join(' ')
+        implicit_input = if target[:implicit_input] and not target[:implicit_input].empty?
+                           ' | ' + target[:implicit_input].join(' ')
+                         else
+                           ''
+                         end
+        output = target[:output].join(' ')
+        variables = target[:variables]
+        @out.puts "build #{output}: #{rule} #{input}#{implicit_input}"
+        for k, v in variables
+          @out.puts "  #{k}=#{v}"
+        end if variables
+        @out.puts
+      end
+    end
+  end
+end

data/lib/path.rb

@@ -0,0 +1,70 @@
+require 'pathname'
+
+module Shog
+  class Path
+    @pwd = '.'
+
+    class << self
+      attr_accessor :pwd
+    end
+
+    attr_reader :path, :outoftree, :absolute
+
+    private :initialize
+
+    def initialize(path, outoftree, absolute = false)
+      @path = path
+      @outoftree = outoftree
+      @absolute = absolute
+    end
+
+    def self.normalize(path)
+      Pathname.new(path).cleanpath.to_s
+    end
+
+    def self.make(path, params = {})
+      if path.is_a?(String)
+        abolute = false
+        if params.key?(:absolute) and params[:absolute]
+          path = File.expand_path(path)
+          absolute = true
+        elsif not params.key?(:root) and not params[:root]
+          path = File.join(Path.pwd, path)
+        end
+        path = Path.normalize(path)
+        outoftree = if params.key?(:outoftree)
+                      params[:outoftree]
+                    else
+                      false # by default we assume input file
+                    end
+        return Path.new(path, outoftree, absolute)
+      elsif path.is_a?(Path)
+        if params.key?(:outoftree) and params[:outoftree] != path.outoftree
+          return Path.new(path.path, params[:outoftree])
+        else
+          return path
+        end
+      else
+        raise "Cannot make path from #{path}"
+      end
+    end
+
+    def dir
+      path = File.dirname(@path)
+      Path.new(path, @outoftree)
+    end
+
+    def with_suffix(suffix)
+      Path.new(Path.normalize(@path + suffix), @outoftree)
+    end
+
+    def to_str
+      # as we build files by ninja from inside outoftree directory then outs should not have any prefixes, but inputs should be accessed by '../'
+      if @outoftree or @absolute
+        @path
+      else
+        File.join('..', @path)
+      end
+    end
+  end
+end

data/lib/pathset.rb

@@ -0,0 +1,46 @@
+require_relative 'path'
+
+module Shog
+  class PathSet < Array
+    def self.make(set)
+      if set.is_a?(PathSet)
+        set
+      elsif set.is_a?(Path)
+        ary = PathSet.new
+        ary << set
+        ary
+      elsif set.is_a?(Array)
+        set.map { |p| Path.make(p) }
+      elsif set.is_a?(String)
+        ary = PathSet.new
+        ary << set
+        ary
+      else
+        raise "Unknown path type #{set.class}"
+      end
+    end
+
+    def <<(p)
+      if p.is_a?(PathSet)
+        self.concat(p)
+      elsif p.is_a?(Path)
+        self.push(p)
+      elsif p.is_a?(Array)
+        p.each { |p| self.push(Path.make(p)) }
+      elsif p.is_a?(String)
+        self.push(Path.make(p))
+      else
+        raise "Unknown path type #{p}"
+      end
+    end
+
+    def single_path
+      raise "Expected number of paths is 1" if self.size != 1
+      self[0]
+    end
+
+    def +(ary)
+      self.concat(PathSet.make(ary))
+    end
+  end
+end

data/lib/rule/cc.rb

@@ -0,0 +1,55 @@
+require_relative '../path'
+
+module Shog
+  class CC
+    attr_accessor :cflags, :includes, :implicit_input, :bin
+
+    def id
+      :cc
+    end
+
+    def initialize
+      @cflags = []
+      @includes = PathSet.new
+      @implicit_input = PathSet.new
+    end
+
+    def rule
+      {
+        'command' => '$bin $cflags -MMD -MQ $out -MF $out.d -c $in -o $out',
+        'description' => 'Compile $in',
+        'deps' => 'gcc',
+        'depfile' => '$out.d',
+      }
+    end
+
+    def target(params)
+      input = PathSet.new
+      input << params[:input]
+
+      output = PathSet.new
+      if params[:output]
+        output << Path.make(params[:output], :outoftree => true)
+      else
+        output << Path.make(params[:input].single_path, :outoftree => true).with_suffix('.o')
+      end
+
+      cflags = @cflags.dup
+      cflags << params[:cflags] if params[:cflags]
+      cflags += @includes.map { |i| '-I' + i }
+      includes = params[:includes]
+      if includes
+        includes = PathSet.make(includes)
+        cflags += includes.map { |i| '-I' + i }
+      end
+
+      variables = {
+        'cflags' => cflags.join(' '),
+        'bin' => params[:bin] || @bin || 'gcc',
+      }
+      implicit_input = @implicit_input.dup
+      implicit_input += params[:implicit_input] if params[:implicit_input]
+      {:rule => 'cc', :input => input, :implicit_input => implicit_input, :output => output, :variables => variables}
+    end
+  end
+end

data/lib/rule/generate_build.rb

@@ -0,0 +1,33 @@
+require_relative '../path'
+
+module Shog
+  class GenerateBuild
+    attr_accessor :deps
+
+    def id
+      :generate_build
+    end
+
+    def initialize
+      @deps = PathSet.new
+    end
+
+    def rule
+      {
+        'command' => 'cd .. && shog generate',
+        'description' => 'Generate Build Script',
+      }
+    end
+
+    def target(params)
+      output = PathSet.new
+      output << Path.make('build.ninja', :outoftree => true, :root => true)
+      variables = {
+        'generator' => '1',
+      }
+      input = PathSet.new(params[:input])
+      input += @deps
+      {:rule => 'generate_build', :input => input, :output => output, :variables => variables}
+    end
+  end
+end

data/lib/rule/kconfig.rb

@@ -0,0 +1,44 @@
+require_relative '../path'
+
+module Shog
+  class Kconfig
+    def id
+      :kconfig
+    end
+
+    def initialize
+      @ldflags = []
+    end
+
+    def rule
+      {
+        'command' => 'KCONFIG_CONFIG=$out conf --oldconfig -s $in',
+        'description' => 'Generate .config file',
+      }
+    end
+
+    def target(params)
+      output = PathSet.new(Path.make(params[:output]))
+      input = PathSet.new(Path.make(params[:input]))
+      {:rule => 'kconfig', :input => input, :output => output}
+    end
+
+    def self.parse(file)
+      config = {}
+      for line in IO.readlines(file)
+        next if line.start_with?('#')
+        if line =~ /^CONFIG_(.*?)=(.*)$/
+          key = $1.to_sym
+          val = $2
+          case val
+          when "y" then val = true
+          when /^\d+$/ then val = val.to_i
+          when /^\"(.*)\"$/ then val = $1
+          end
+          config[key] = val
+        end
+      end
+      config
+    end
+  end
+end

data/lib/rule/link.rb

@@ -0,0 +1,40 @@
+require_relative '../path'
+
+module Shog
+  class Link
+    attr_accessor :bin, :implicit_input
+
+    def initialize
+      @implicit_input = PathSet.new
+    end
+
+    def id
+      :ld
+    end
+
+    def rule
+      {
+        'command' => '$bin $ldflags $in -o $out',
+        'description' => 'Linking $out',
+      }
+    end
+
+    def target(params)
+      output = PathSet.make(Path.make(params[:output], :outoftree => true))
+      input = PathSet.make(params[:input])
+      ldflags = params[:ldflags]
+      if ldflags.nil?
+        ldflags = ''
+      elsif ldflags.is_a?(Array)
+        ldflags = ldflags.join(' ')
+      end
+      variables = {
+        'ldflags' => ldflags,
+        'bin' => params[:bin] || @bin || 'gcc',
+      }
+      implicit_input = @implicit_input.dup
+      implicit_input += params[:implicit_input] if params[:implicit_input]
+      {:rule => 'ld', :input => input, :implicit_input => implicit_input, :output => output, :variables => variables}
+    end
+  end
+end

data/lib/rule/objcopy.rb

@@ -0,0 +1,29 @@
+require_relative '../path'
+
+module Shog
+  class ObjCopy
+    attr_accessor :bin
+
+    def id
+      :objcopy
+    end
+
+    def rule
+      {
+        'command' => '$bin -O $arch $in $out',
+        'description' => 'Objcopy $out',
+      }
+    end
+
+    def target(params)
+      input = PathSet.make(params[:input])
+      output = PathSet.make(Path.make(params[:output], :outoftree => true))
+
+      variables = {
+        'bin' => params[:bin] || @bin || 'objcopy',
+      }
+      variables['arch'] = params[:arch] if params[:arch]
+      {:rule => 'objcopy', :input => input, :output => output, :variables => variables}
+    end
+  end
+end

data/lib/rule/yacc.rb

@@ -0,0 +1,22 @@
+require_relative '../path'
+
+module Shog
+  class Yacc
+    def id
+      :yacc
+    end
+
+    def rule
+      {
+        'command' => 'yacc -o $out $in',
+        'description' => 'Yacc $in',
+      }
+    end
+
+    def target(params)
+      input = PathSet.make(params[:input])
+      output = PathSet.make(Path.make(params[:output], :outoftree => true))
+      {:rule => 'yacc', :input => input, :output => output, :variables => {}}
+    end
+  end
+end

data/lib/runner.rb

@@ -0,0 +1,34 @@
+require_relative 'ninja'
+require_relative 'generator'
+
+module Shog
+  module Runner
+    WORKDIR = 'out'
+
+    def generate(backend)
+      Dir.mkdir(WORKDIR) unless Dir.exists?(WORKDIR)
+      gen = Generator.new(backend)
+      gen.generate
+    end
+
+    def run(argv)
+      unless File.exists?('shog.build')
+        puts "shog.build file is not found in #{Dir.pwd}"
+        exit 1
+      end
+
+      backend = Ninja.new
+
+      cmd = argv[0]
+      if cmd == 'generate'
+        generate(backend)
+        return
+      end
+
+      generate(backend) unless backend.configured?
+      backend.run
+    end
+
+    module_function :run, :generate
+  end
+end

data/lib/util.rb

@@ -0,0 +1,6 @@
+class Object
+  def deep_clone
+    # https://stackoverflow.com/questions/8206523/how-to-create-a-deep-copy-of-an-object-in-ruby
+    Marshal.load(Marshal.dump(self))
+  end
+end

metadata

@@ -0,0 +1,91 @@
+--- !ruby/object:Gem::Specification
+name: shog-build
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Anatol Pomozov
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2018-01-08 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '12.3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '12.3'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.7'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.7'
+description: 
+email:
+- anatol.pomozov@gmail.com
+executables:
+- shog
+extensions: []
+extra_rdoc_files:
+- README.md
+- LICENSE.md
+files:
+- LICENSE.md
+- README.md
+- bin/shog
+- lib/context.rb
+- lib/generator.rb
+- lib/ninja.rb
+- lib/path.rb
+- lib/pathset.rb
+- lib/rule/cc.rb
+- lib/rule/generate_build.rb
+- lib/rule/kconfig.rb
+- lib/rule/link.rb
+- lib/rule/objcopy.rb
+- lib/rule/yacc.rb
+- lib/runner.rb
+- lib/util.rb
+homepage: https://github.com/anatol/shog
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - "~>"
+    - !ruby/object:Gem::Version
+      version: '2.4'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.7.3
+signing_key: 
+specification_version: 4
+summary: Ruby frontend for Ninja build system
+test_files: []