class Rmk::ClikeProcessor

Processors similar to C-compilers

Constants

DEFAULT_CXX_MAIN_PATTERN: pattern to look for +main()+ function

Attributes

auto_detect_main[RW]

enable automatic detection of #main_sources

definitions[R]

#definitions that will be added to #flags (e.g., +-Dkey=value+)

include_paths[R]

list of include paths

Public Class Methods

new() click to toggle source

Calls superclass method Rmk::Processor.new

# File lib/processors.rb, line 72
def initialize
  super

  @definitions = []
  @include_paths = [generator.proj_root]
  @auto_detect_main = true
  @slot = SLOTS[:compiler]
  @requires = [LD]
end

Public Instance Methods

add_main_pattern(regex) click to toggle source

# File lib/processors.rb, line 140
def add_main_pattern(regex)
  begin
    @main_pattern = Regexp.union(main_pattern, *regex)
  rescue StandardError => e
    warn "ERROR: #{e}"
    exit(-1)
  end
end

add_project(proj, options = {}) click to toggle source

(should be implemented by subclass)

Calls superclass method Rmk::Processor#add_project

# File lib/processors.rb, line 127
def add_project(proj, options = {})
  super(proj, options)
  include_path options[:proj_root] if options[:proj_root]
end

define(key,value) click to toggle source

define key1 => value1, key2 → value2

Add a compiler definition. For instance, this refers to adding a preprocessor definition for the CC compiler.

# File lib/processors.rb, line 89
def define(key, value = nil)
  if key.is_a?(Hash) || key.is_a?(Array)
    raise "invalid 'value' argument" if value
    key.each { |k, v| define(k, v) }
  else
    d = @definitions.assoc(key)
    if d
      d[1] = value
    else
      @definitions << [key, value]
    end
  end
end

definitions_text() click to toggle source

get #definitions as in command line

# File lib/processors.rb, line 109
def definitions_text
  @definitions.map { |k, v| "-D#{k}" + (v.nil? ? '' : "=#{v}") }.join(' ')
end

descriptive_name() click to toggle source

# File lib/processors.rb, line 172
def descriptive_name
  klass = self.class.to_s
  klass[5, klass.length] # strip module prefix 'Rmk::'
end

include_path(*path) click to toggle source

Add include path(s).

# File lib/processors.rb, line 114
def include_path(*path)
  path.each do |p|
    pchecked = Pathname.new(p).to_s
    @include_paths << pchecked unless @include_paths.include?(pchecked)
  end
end

include_paths_text() click to toggle source

get include paths as in command line

# File lib/processors.rb, line 122
def include_paths_text
  @include_paths.map { |p| "-I#{p}" }.join(' ')
end

main(*files) click to toggle source

Manually add program file. For instance, manually add a file that contains a +main()+ function for the CC compiler.

See also #auto_detect_main.

# File lib/processors.rb, line 164
def main(*files)
  files.each { |f| main_sources[f] = true }
end

main_pattern() click to toggle source

# File lib/processors.rb, line 136
def main_pattern
  @main_pattern ||= DEFAULT_CXX_MAIN_PATTERN
end

ninja_build(writer = generator.ninja) click to toggle source

# File lib/processors.rb, line 190
def ninja_build(writer = generator.ninja)
  find_sources(source_pattern)
  find_main_sources
  @@log.debug "#{descriptive_name} sources = #{sources.join(' ')}"
  @@log.debug "#{descriptive_name} programs = #{main_sources.keys.join(' ')}"

  sources.each do |src|
    if src =~ /^\$builddir/
      obj = generator.object(src)
      source = src
    else
      obj = "$builddir/#{generator.object(src)}"
      source = generator.expand_source(src)
    end
    writer.build(generator.add_object(obj, main_sources[src]), rule_name, source)
  end
end

ninja_rules(writer = generator.ninja) click to toggle source

# File lib/processors.rb, line 185
def ninja_rules(writer = generator.ninja)
  writer.rule(rule_name, command,
              description: "#{descriptive_name} $out", depfile: '$out.dep')
end

rule_name() click to toggle source

# File lib/processors.rb, line 168
def rule_name
  descriptive_name.downcase
end

source_file?(filename) click to toggle source

# File lib/processors.rb, line 181
def source_file?(filename)
  filename =~ source_pattern
end

source_pattern() click to toggle source

# File lib/processors.rb, line 177
def source_pattern
  raise 'not implemented'
end

undefine(key) click to toggle source

Remove a compiler definition.

# File lib/processors.rb, line 104
def undefine(key)
  @definitions.delete(key)
end

Protected Instance Methods

find_main_sources() click to toggle source

# File lib/processors.rb, line 149
def find_main_sources
  return unless auto_detect_main

  # no generated files in src_files
  src_files = @sources.find_all { |name| name !~ /^\$builddir/ }
  grep(main_pattern, src_files).each { |src| @main_sources[src] = :main }
end