Class: GeneratorPartials

Inherits:
Object show all
Defined in:
lib/ceedling/generators/generator_partials.rb

Instance Method Summary collapse

Instance Method Details

#generate_implementation(test:, name:, function_definitions:, source_includes:, header_includes:, c_module:, output_path:) ⇒ Object 



17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
 
# File 'lib/ceedling/generators/generator_partials.rb', line 17

def generate_implementation(
    test:,
    name:,
    function_definitions:,
    source_includes:,
    header_includes:,
    c_module:,
    output_path:
  )
  source = @file_path_utils.form_partial_implementation_source_filename(name)
  header = @file_path_utils.form_partial_implementation_header_filename(name)

  header_filepath = File.join(output_path, header)
  source_filepath = File.join(output_path, source)

  # Binary mode: the function bodies written below may already contain their
  # own line endings verbatim. Windows text mode rewrites every "\n" on
  # write, which would alter any line ending already present in that
  # content instead of passing it through unchanged.
  @file_wrapper.open(header_filepath, 'wb') do |file|
    generate_header(file, header, header_includes, function_definitions, c_module, true)
  end

  @file_wrapper.open(source_filepath, 'wb') do |file|
    generate_source(file, source_includes, function_definitions, c_module)
  end

  return source_filepath
end

#generate_interface(test:, name:, function_declarations:, includes:, c_module:, output_path:) ⇒ Object 



47
48
49
50
51
52
53
54
55
56
57
 
# File 'lib/ceedling/generators/generator_partials.rb', line 47

def generate_interface(test:, name:, function_declarations:, includes:, c_module:, output_path:)
  header = @file_path_utils.form_partial_interface_header_filename(name)
  filepath = File.join(output_path, header)

  # Binary mode: see generate_implementation above.
  @file_wrapper.open(filepath, 'wb') do |file|
    generate_header(file, header, includes, function_declarations, c_module, false)
  end

  return filepath
end

#generate_types(name:, c_module:, output_path:) ⇒ String?

A module's typedefs and aggregate (struct/enum/union) definitions are the same regardless of which functions a given test file chooses to test versus mock, so they're generated once here into their own header rather than by generate_header itself. Both the implementation and interface headers then simply #include this file, which means a module tested and mocked in the same test file -- each side producing its own generated header -- never ends up with two separate C definitions of the same type in one translation unit. Nothing is written and nil is returned when a module has no such content, since there's then nothing to share.

Parameters:

  • name (String) —

    Partial module name (used to form the filename and include guard)

  • c_module (CExtractorTypes::CModule) —

    Merged module with type_definitions/aggregate_definitions

  • output_path (String) —

    Directory shared with the implementation and interface headers

Returns:

  • (String, nil) —

    The bare filename (for use as a sibling #include), or nil if nothing was generated



72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
 
# File 'lib/ceedling/generators/generator_partials.rb', line 72

def generate_types(name:, c_module:, output_path:)
  return nil if c_module.type_definitions.empty? && c_module.aggregate_definitions.empty?

  header = @file_path_utils.form_partial_types_header_filename(name)
  filepath = File.join(output_path, header)

  # Binary mode: see generate_implementation above.
  @file_wrapper.open(filepath, 'wb') do |file|
    guard = FileWrapper.generate_include_guard(header)
    file << "#ifndef #{guard}\n"
    file << "#define #{guard}\n\n"

    anything_emitted = false
    c_module.element_sequence.each do |item|
      next unless item.is_a?(CExtractorTypes::CStatement) && type_defining?(item, c_module)
      file << item.text << "\n"
      anything_emitted = true
    end

    file << "\n" if anything_emitted
    file << "#endif // #{guard}\n\n"
  end

  return header
end