wrapture 0.2.2 → 0.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 5a6c087443d51b13a641bf0810c398c073415422de2a3a5cc715bc75ab265230
-  data.tar.gz: a2d2175fe6d0ffbdc5e1a878fda7c9ed3db8dd8d0ae8d2c88b143167bf76b0a8
+  metadata.gz: 5a2ff7411136ffd84e6078406f6a4a8bf76cfaf0c2f1398d9409d019d29a6b8a
+  data.tar.gz: 8c91f45af881ad5f7f28b184d5d9d63ce9cabde0320af43303efb51764a2d458
 SHA512:
-  metadata.gz: e722abc8af3af03e5e98189c034a3d60df5f1814776d127cee8be5bebdc9d87a1226f4b305e1b083da38c03a9ad239e98e1572b75f1b5bb9dd4d5bc5e93a95ea
-  data.tar.gz: e26c2a12e04af2b22172de83b31246846f6a73780a46987604748da9232b9191f5204c94ead1b3016db55b8c6b29e2d1e193629abfee0a1a18bd63d592e97f9f
+  metadata.gz: cfb9b375f81fbfb6e75af4f52882fcff232ff5a9757732deb3446a1ae5b6de39cb1d4ddc2fd93d0c31f9fa3d9344e917119ad428a2040c2ec6415cdb002761ea
+  data.tar.gz: 936c998fd990eec6b580257b50a4e2d440ff9d6670c62250d1a38c6e42b7f70c1c7f8c02113a572388cd74beeeef7d235566d9bf89d90d028905eece199d2bc7

data/bin/wrapture

@@ -1,13 +1,46 @@
 #!/usr/bin/env ruby
 
+# SPDX-License-Identifier: Apache-2.0
+
 # frozen_string_literal: true
 
+# Copyright 2019-2020 Joel E. Anderson
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
 require 'yaml'
 require 'wrapture'
 
-spec = YAML.load_file ARGV[0]
+scope = Wrapture::Scope.new
+
+ARGV.each do |spec_file|
+  spec = YAML.load_file(spec_file)
+
+  if spec.key?('version') && !Wrapture.supports_version?(spec['version'])
+    raise Wrapture::UnsupportedSpecVersion
+  end
 
-spec['classes'].each do |spec_hash|
-  class_spec = Wrapture::ClassSpec.new spec_hash
-  class_spec.generate_wrappers
+  spec.fetch('templates', []).each do |temp_spec|
+    scope << Wrapture::TemplateSpec.new(temp_spec)
+  end
+
+  spec.fetch('classes', []).each do |class_spec|
+    scope.add_class_spec_hash(class_spec)
+  end
+
+  spec.fetch('enums', []).each do |enum_spec|
+    scope.add_enum_spec_hash(enum_spec)
+  end
 end
+
+scope.generate_wrappers

data/lib/wrapture.rb

@@ -1,10 +1,38 @@
+# SPDX-License-Identifier: Apache-2.0
+
 # frozen_string_literal: true
 
-##
+# Copyright 2019-2020 Joel E. Anderson
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
 # Classes and functions for generating language wrappers
 module Wrapture
+  require 'wrapture/action_spec'
+  require 'wrapture/comment'
   require 'wrapture/constant_spec'
+  require 'wrapture/constants'
   require 'wrapture/class_spec'
+  require 'wrapture/enum_spec'
+  require 'wrapture/errors'
   require 'wrapture/function_spec'
+  require 'wrapture/normalize'
+  require 'wrapture/rule_spec'
+  require 'wrapture/param_spec'
+  require 'wrapture/scope'
+  require 'wrapture/struct_spec'
+  require 'wrapture/template_spec'
+  require 'wrapture/type_spec'
   require 'wrapture/version'
+  require 'wrapture/wrapped_function_spec'
 end

data/lib/wrapture/action_spec.rb

@@ -0,0 +1,80 @@
+# SPDX-License-Identifier: Apache-2.0
+
+# frozen_string_literal: true
+
+#--
+# Copyright 2020 Joel E. Anderson
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#++
+
+module Wrapture
+  # An action to take within a generated program.
+  class ActionSpec
+    # Normalizes a hash specification of a rule. Normalization checks for
+    # invalid keys and unrecognized conditions.
+    def self.normalize_spec_hash(spec)
+      normalized = spec.dup
+
+      required_keys = %w[name constructor]
+
+      missing_keys = required_keys - spec.keys
+      unless missing_keys.empty?
+        missing_msg = "required keys are missing: #{missing_keys.join(', ')}"
+        raise(MissingSpecKey, missing_msg)
+      end
+
+      extra_keys = spec.keys - required_keys
+      unless extra_keys.empty?
+        extra_msg = "these keys are unrecognized: #{extra_keys.join(', ')}"
+        raise(InvalidSpecKey, extra_msg)
+      end
+
+      func_spec = WrappedFunctionSpec.normalize_spec_hash(spec['constructor'])
+      normalized['constructor'] = func_spec
+
+      normalized
+    end
+
+    # Creates an action spec based on the provided spec hash.
+    #
+    # The hash must have the following keys:
+    # name:: the type of action to take (currently only throw-exception is
+    # supported)
+    # constructor:: the function to use to create the exception, described as a
+    # wrapped function call
+    def initialize(spec)
+      @spec = ActionSpec.normalize_spec_hash(spec)
+    end
+
+    # A list of includes needed for the action.
+    def includes
+      @spec['constructor']['includes'].dup
+    end
+
+    # A string containing the invocation of this action.
+    def take
+      call_spec = @spec['constructor']
+
+      params = call_spec['params'].map do |param_spec|
+        if param_spec['value'] == RETURN_VALUE_KEYWORD
+          'return_val'
+        else
+          param_spec['value']
+        end
+      end
+
+      "throw #{call_spec['name']}( #{params.join(', ')} )"
+    end
+  end
+end

data/lib/wrapture/class_spec.rb

@@ -1,203 +1,220 @@
+# SPDX-License-Identifier: Apache-2.0
+
 # frozen_string_literal: true
 
-require 'wrapture/constant_spec'
-require 'wrapture/function_spec'
+#--
+# Copyright 2019-2020 Joel E. Anderson
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#++
 
 module Wrapture
-  ##
   # A description of a class, including its constants, functions, and other
   # details.
   class ClassSpec
-    def self.typed_variable(type, name)
-      if type.end_with? '*'
-        "#{type}#{name}"
-      else
-        "#{type} #{name}"
-      end
-    end
+    # Normalizes a hash specification of a class. Normalization will check for
+    # things like invalid keys, duplicate entries in include lists, and will set
+    # missing keys to their default values (for example, an empty list if no
+    # includes are given).
+    #
+    # If this spec cannot be normalized, for example because it is invalid or
+    # it uses an unsupported version type, then an exception is raised.
+    def self.normalize_spec_hash(spec)
+      raise NoNamespace unless spec.key?('namespace')
+      raise MissingSpecKey, 'name key is required' unless spec.key?('name')
 
-    def initialize(spec)
-      @spec = ClassSpec.normalize_spec_hash(spec)
+      Comment.validate_doc(spec['doc']) if spec.key?('doc')
 
-      @functions = []
-      @spec['functions'].each do |function_spec|
-        @functions << FunctionSpec.new(function_spec, self)
-      end
+      normalized = spec.dup
+      normalized.default = []
+
+      normalized['version'] = Wrapture.spec_version(spec)
+      normalized['includes'] = Wrapture.normalize_includes(spec['includes'])
+      normalized['type'] = ClassSpec.effective_type(normalized)
 
-      @constants = []
-      @spec['constants'].each do |constant_spec|
-        @constants << ConstantSpec.new(constant_spec)
+      if spec.key?('parent')
+        includes = Wrapture.normalize_includes(spec['parent']['includes'])
+        normalized['parent']['includes'] = includes
       end
-    end
 
-    def generate_wrappers
-      files = []
-      files << generate_declaration_file
-      files << generate_definition_file
+      normalized
     end
 
-    def resolve_param(param)
-      case param
-      when 'equivalent-struct'
-        equivalent_struct
-      when 'equivalent-struct-pointer'
-        equivalent_struct_pointer
-      else
-        param
+    # Gives the effective type of the given class spec hash.
+    def self.effective_type(spec)
+      inferred_pointer_wrapper = spec['constructors'].any? do |func|
+        func['wrapped-function']['return']['type'] == EQUIVALENT_POINTER_KEYWORD
       end
-    end
 
-    def function_call(spec)
-      resolved_params = []
+      if spec.key?('type')
+        valid_types = %w[pointer struct]
+        unless valid_types.include?(spec['type'])
+          type_message = "#{spec['type']} is not a valid class type"
+          raise InvalidSpecKey.new(type_message, valid_keys: valid_types)
+        end
 
-      spec['params'].each do |param|
-        resolved_params << resolve_param(param['name'])
+        spec['type']
+      elsif inferred_pointer_wrapper
+        'pointer'
+      else
+        'struct'
       end
-
-      "#{spec['name']}( #{resolved_params.join ', '} )"
-    end
-
-    def self.normalize_spec_hash(spec)
-      normalized_spec = spec.dup
-      normalized_spec.default = []
-
-      normalized_spec['equivalent-struct']['members'] ||= []
-      normalized_spec['equivalent-struct']['includes'] ||= []
-
-      normalized_spec
     end
 
-    private
-
-    def header_guard
-      "__#{@spec['name'].upcase}_HPP"
-    end
+    # The underlying struct of this class.
+    attr_reader :struct
+
+    # Creates a class spec based on the provided hash spec.
+    #
+    # The scope can be provided if available.
+    #
+    # The hash must have the following keys:
+    # name:: the name of the class
+    # namespace:: the namespace to put the class into
+    # equivalent-struct:: a hash describing the struct this class wraps
+    #
+    # The following keys are optional:
+    # doc:: a string containing the documentation for this class
+    # constructors:: a list of function specs that can create this class
+    # destructor:: a function spec for the destructor of the class
+    # functions:: a list of function specs
+    # constants:: a list of constant specs
+    def initialize(spec, scope: Scope.new)
+      @spec = Marshal.load(Marshal.dump(spec))
+      TemplateSpec.replace_all_uses(@spec, *scope.templates)
+
+      @spec = ClassSpec.normalize_spec_hash(@spec)
+
+      @struct = if @spec.key?(EQUIVALENT_STRUCT_KEYWORD)
+                  StructSpec.new(@spec[EQUIVALENT_STRUCT_KEYWORD])
+                end
+
+      @functions = @spec['constructors'].map do |constructor_spec|
+        full_spec = constructor_spec.dup
+        full_spec['name'] = @spec['name']
+        full_spec['params'] = constructor_spec['wrapped-function']['params']
+
+        FunctionSpec.new(full_spec, self, constructor: true)
+      end
 
-    def declaration_includes
-      includes = @spec['equivalent-struct']['includes'].dup
+      if @spec.key?('destructor')
+        destructor_spec = @spec['destructor'].dup
+        destructor_spec['name'] = "~#{@spec['name']}"
 
-      @functions.each do |func|
-        includes.concat func.declaration_includes
+        @functions << FunctionSpec.new(destructor_spec, self, destructor: true)
       end
 
-      @constants.each do |const|
-        includes.concat const.declaration_includes
+      @spec['functions'].each do |function_spec|
+        @functions << FunctionSpec.new(function_spec, self)
       end
 
-      includes.uniq
-    end
-
-    def definition_includes
-      includes = ["#{@spec['name']}.hpp"]
-
-      @functions.each do |func|
-        includes.concat func.definition_includes
+      @constants = @spec['constants'].map do |constant_spec|
+        ConstantSpec.new(constant_spec)
       end
 
-      @constants.each do |const|
-        includes.concat const.definition_includes
-      end
+      @doc = @spec.key?('doc') ? Comment.new(@spec['doc']) : nil
 
-      includes.uniq
+      scope << self
+      @scope = scope
     end
 
-    def pointer_wrapper?
-      @spec['constructors'].each do |constructor_spec|
-        return_type = constructor_spec['wrapped-function']['return']['type']
-
-        return true if return_type == 'equivalent-struct-pointer'
-      end
+    # Returns a cast of an instance of this class with the provided name to the
+    # specified type. Optionally the from parameter may hold the type of the
+    # instance, either a reference or a pointer.
+    def cast(instance, to, from = name)
+      member_access = from.pointer? ? '->' : '.'
 
-      false
-    end
+      struct = "struct #{@struct.name}"
 
-    def equivalent_member(member)
-      if pointer_wrapper?
-        "this->equivalent->#{member}"
-      else
-        "this->equivalent.#{member}"
+      if [EQUIVALENT_STRUCT_KEYWORD, struct].include?(to)
+        "#{'*' if pointer_wrapper?}#{instance}#{member_access}equivalent"
+      elsif [EQUIVALENT_POINTER_KEYWORD, "#{struct} *"].include?(to)
+        "#{'&' unless pointer_wrapper?}#{instance}#{member_access}equivalent"
       end
     end
 
-    def equivalent_name
-      if pointer_wrapper?
-        '*equivalent'
-      else
-        'equivalent'
-      end
+    # Generates the wrapper class declaration and definition files.
+    def generate_wrappers
+      [generate_declaration_file, generate_definition_file]
     end
 
-    def equivalent_struct
-      if pointer_wrapper?
-        '*(this->equivalent)'
-      else
-        'this->equivalent'
-      end
+    # The name of the class
+    def name
+      @spec['name']
     end
 
-    def equivalent_struct_pointer
-      if pointer_wrapper?
-        'this->equivalent'
-      else
-        '&this->equivalent'
-      end
+    # True if this class overloads the given one. A class is considered an
+    # overload if its parent is the given class, it has the same equivalent
+    # struct name, and the equivalent struct has a set of rules. The overloaded
+    # class cannot have any rules in its equivalent struct, or it will not be
+    # overloaded.
+    def overloads?(parent_spec)
+      return false unless parent_spec.struct&.rules&.empty?
+
+      parent_spec.struct.name == struct_name &&
+        parent_spec.name == parent_name &&
+        !@struct.rules.empty?
     end
 
-    def wrapped_constructor_signature(index)
-      function_spec = @spec['constructors'][index]['wrapped-function']
-
-      "#{@spec['name']}( #{FunctionSpec.param_list function_spec} )"
+    # The name of the parent of this class, or nil if there is no parent.
+    def parent_name
+      @spec['parent']['name'] if child?
     end
 
-    def destructor_signature
-      "~#{@spec['name']}( void )"
+    # Determines if this class is a wrapper for a struct pointer or not.
+    def pointer_wrapper?
+      @spec['type'] == 'pointer'
     end
 
-    def wrapped_constructor_definition(index)
-      constructor_spec = @spec['constructors'][index]
-      wrapped_function = constructor_spec['wrapped-function']
-
-      yield "#{@spec['name']}::#{wrapped_constructor_signature(index)}{"
-
-      result = resolve_param wrapped_function['return']['type']
-
-      yield "  #{result} = #{function_call wrapped_function};"
-
-      yield '}'
+    # The name of the equivalent struct of this class.
+    def struct_name
+      @struct.name
     end
 
-    def member_constructor_signature
-      params = []
-
-      @spec['equivalent-struct']['members'].each do |member|
-        params << ClassSpec.typed_variable(member['type'], member['name'])
+    # Gives a code snippet that accesses the equivalent struct from within the
+    # class using the 'this' keyword.
+    def this_struct
+      if pointer_wrapper?
+        '*(this->equivalent)'
+      else
+        'this->equivalent'
       end
-
-      "#{@spec['name']}( #{params.join ', '} )"
     end
 
-    def struct_constructor_signature
-      struct_name = @spec['equivalent-struct']['name']
-      "#{@spec['name']}( struct #{struct_name} equivalent )"
+    # Gives a code snippet that accesses the equivalent struct pointer from
+    # within the class using the 'this' keyword.
+    def this_struct_pointer
+      "#{'&' unless pointer_wrapper?}this->equivalent"
     end
 
-    def pointer_constructor_signature
-      struct_name = @spec['equivalent-struct']['name']
-      "#{@spec['name']}( struct #{struct_name} *equivalent )"
+    # Returns the ClassSpec for the given type in this class's scope.
+    def type(type)
+      @scope.type(type)
     end
 
-    def generate_declaration_file
-      filename = "#{@spec['name']}.hpp"
+    # Returns true if the given type exists in this class's scope.
+    def type?(type)
+      @scope.type?(type)
+    end
 
-      File.open(filename, 'w') do |file|
-        declaration_contents do |line|
-          file.puts line
-        end
-      end
+    private
 
-      filename
+    # True if the class has a parent.
+    def child?
+      @spec.key?('parent')
     end
 
+    # Gives the content of the class declaration to a block, line by line.
     def declaration_contents
       yield "#ifndef #{header_guard}"
       yield "#define #{header_guard}"
@@ -210,36 +227,38 @@ module Wrapture
       yield
       yield "namespace #{@spec['namespace']} {"
       yield
-      yield "  class #{@spec['name']} {"
+
+      documentation { |line| yield "  #{line}" }
+      parent = if child?
+                 ": public #{parent_name} "
+               else
+                 ''
+               end
+      yield "  class #{@spec['name']} #{parent}{"
+
       yield '  public:'
 
       yield unless @constants.empty?
       @constants.each do |const|
-        yield "  #{const.declaration};"
+        const.declaration { |line| yield "    #{line}" }
       end
 
       yield
-      struct_name = @spec['equivalent-struct']['name']
-      yield "    struct #{struct_name} #{equivalent_name};"
+      equivalent_member_declaration { |line| yield "    #{line}" }
       yield
 
-      unless @spec['equivalent-struct']['members'].empty?
-        yield "    #{member_constructor_signature};"
-      end
+      member_constructor_declaration { |line| yield "    #{line}" }
 
-      unless pointer_wrapper?
-        yield "    #{struct_constructor_signature};"
-        yield "    #{pointer_constructor_signature};"
-      end
+      pointer_constructor_declaration { |line| yield "    #{line}" }
 
-      @spec['constructors'].each_index do |constructor|
-        yield "    #{wrapped_constructor_signature constructor};"
+      unless !@struct || pointer_wrapper?
+        yield "    #{struct_constructor_signature};"
       end
 
-      yield "    #{destructor_signature};" if @spec.key? 'destructor'
+      overload_declaration { |line| yield "    #{line}" }
 
       @functions.each do |func|
-        yield "    #{func.declaration};"
+        func.declaration { |line| yield "    #{line}" }
       end
 
       yield '  };' # end of class
@@ -249,18 +268,26 @@ module Wrapture
       yield '#endif' # end of header guard
     end
 
-    def generate_definition_file
-      filename = "#{@spec['name']}.cpp"
+    # A list of includes needed for the declaration of the class.
+    def declaration_includes
+      includes = @spec['includes'].dup
 
-      File.open(filename, 'w') do |file|
-        definition_contents do |line|
-          file.puts line
-        end
+      includes.concat(@struct.includes) if @struct
+
+      @functions.each do |func|
+        includes.concat(func.declaration_includes)
       end
 
-      filename
+      @constants.each do |const|
+        includes.concat(const.declaration_includes)
+      end
+
+      includes.concat(@spec['parent']['includes']) if child?
+
+      includes.uniq
     end
 
+    # Gives the content of the class definition to a block, line by line.
     def definition_contents
       definition_includes.each do |include_file|
         yield "#include <#{include_file}>"
@@ -271,68 +298,264 @@ module Wrapture
 
       yield unless @constants.empty?
       @constants.each do |const|
-        yield "  #{const.definition @spec['name']};"
+        yield "  #{const.definition(@spec['name'])};"
       end
 
-      unless @spec['equivalent-struct']['members'].empty?
-        yield
-        yield "  #{@spec['name']}::#{member_constructor_signature} {"
-
-        @spec['equivalent-struct']['members'].each do |member|
-          member_decl = equivalent_member member['name']
-          yield "    #{member_decl} = #{member['name']};"
-        end
+      member_constructor_definition { |line| yield "  #{line}" }
 
-        yield '  }'
-      end
+      pointer_constructor_definition { |line| yield "  #{line}" }
 
-      unless pointer_wrapper?
+      unless pointer_wrapper? || !@struct
         yield
         yield "  #{@spec['name']}::#{struct_constructor_signature} {"
 
-        @spec['equivalent-struct']['members'].each do |member|
-          member_decl = equivalent_member member['name']
+        @struct.members.each do |member|
+          member_decl = this_member(member['name'])
           yield "    #{member_decl} = equivalent.#{member['name']};"
         end
 
         yield '  }'
+      end
 
+      overload_definition { |line| yield "  #{line}" }
+
+      @functions.each do |func|
         yield
-        yield "  #{@spec['name']}::#{pointer_constructor_signature} {"
 
-        @spec['equivalent-struct']['members'].each do |member|
-          member_decl = equivalent_member member['name']
-          yield "    #{member_decl} = equivalent->#{member['name']};"
+        func.definition do |def_line|
+          yield "  #{def_line}"
         end
+      end
 
-        yield '  }'
+      yield
+      yield '}' # end of namespace
+    end
+
+    # A list of includes needed for the definition of the class.
+    def definition_includes
+      includes = ["#{@spec['name']}.hpp"]
+
+      includes.concat(@spec['includes'])
+
+      @functions.each do |func|
+        includes.concat(func.definition_includes)
       end
 
-      @spec['constructors'].each_index do |constructor|
-        yield
-        wrapped_constructor_definition(constructor) do |line|
-          yield "  #{line}"
-        end
+      @constants.each do |const|
+        includes.concat(const.definition_includes)
       end
 
-      if @spec.key? 'destructor'
-        yield
-        yield "  #{@spec['name']}::#{destructor_signature} {"
-        func_spec = @spec['destructor']['wrapped-function']
-        yield "    #{function_call func_spec};"
-        yield '  }'
+      includes.concat(overload_definition_includes)
+
+      includes.uniq
+    end
+
+    # Calls the given block for each line of the class documentation.
+    def documentation(&block)
+      @doc&.format_as_doxygen(max_line_length: 78) { |line| block.call(line) }
+    end
+
+    # Yields the declaration of the equivalent member if this class has one.
+    #
+    # A class might not have an equivalent member if it is able to use the
+    # parent class's, for example if the child class wraps the same struct.
+    def equivalent_member_declaration
+      return unless @struct
+
+      if child?
+        parent_spec = @scope.type(TypeSpec.new(parent_name))
+        member_reusable = !parent_spec.nil? &&
+                          parent_spec.struct_name == @struct.name &&
+                          parent_spec.pointer_wrapper? == pointer_wrapper?
+        return if member_reusable
       end
 
-      @functions.each do |func|
-        yield
+      yield "#{@struct.declaration(equivalent_name)};"
+    end
 
-        func.definition(@spec['name']) do |def_line|
-          yield "  #{def_line}"
+    # Gives the name of the equivalent struct.
+    def equivalent_name
+      "#{'*' if pointer_wrapper?}equivalent"
+    end
+
+    # Generates the declaration of the class.
+    def generate_declaration_file
+      filename = "#{@spec['name']}.hpp"
+
+      File.open(filename, 'w') do |file|
+        declaration_contents do |line|
+          file.puts(line)
         end
       end
 
+      filename
+    end
+
+    # Generates the definition of the class.
+    def generate_definition_file
+      filename = "#{@spec['name']}.cpp"
+
+      File.open(filename, 'w') do |file|
+        definition_contents do |line|
+          file.puts(line)
+        end
+      end
+
+      filename
+    end
+
+    # The header guard for the class.
+    def header_guard
+      "__#{@spec['name'].upcase}_HPP"
+    end
+
+    # Yields the declaration of the member constructor for a class. This will be
+    # empty if the wrapped struct is a pointer wrapper.
+    def member_constructor_declaration
+      return unless @struct&.members?
+
+      yield "#{@spec['name']}( #{@struct.member_list_with_defaults} );"
+    end
+
+    # Yields the definition of the member constructor for a class. This will be
+    # empty if the wrapped struct is a pointer wrapper.
+    def member_constructor_definition
+      return unless @struct&.members?
+
+      yield "#{@spec['name']}::#{@spec['name']}( #{@struct.member_list} ) {"
+
+      @struct.members.each do |member|
+        member_decl = this_member(member['name'])
+        yield "  #{member_decl} = #{member['name']};"
+      end
+
+      yield '}'
+    end
+
+    # Yields the declaration of the overload function for this class. If there
+    # is no overload function for this class, then nothing is yielded.
+    def overload_declaration
+      return unless @scope.overloads?(self)
+
+      yield "static #{name} *new#{name}( struct #{@struct.name} *equivalent );"
+    end
+
+    # Yields each line of the definition of the overload function, with a
+    # leading empty yield. If there is no overload function for this class,
+    # then nothing is yielded.
+    def overload_definition
+      return unless @scope.overloads?(self)
+
       yield
-      yield '}' # end of namespace
+
+      parameter = "struct #{@struct.name} *equivalent"
+      yield "#{name} *#{name}::new#{name}( #{parameter} ) {"
+
+      line_prefix = '  '
+      @scope.overloads(self).each do |overload|
+        check = overload.struct.rules_check('equivalent')
+        yield "#{line_prefix}if( #{check} ) {"
+        yield "    return new #{overload.name}( equivalent );"
+        line_prefix = '  } else '
+      end
+
+      yield "#{line_prefix}{"
+      yield "    return new #{name}( equivalent );"
+      yield '  }'
+      yield '}'
+    end
+
+    # A list of the includes needed for the overload definitions.
+    def overload_definition_includes
+      @scope.overloads(self).map { |overload| "#{overload.name}.hpp" }
+    end
+
+    # The initializer for the pointer constructor, if one is available, or an
+    # empty string if not.
+    def parent_provides_initializer?
+      return false if !pointer_wrapper? || !child?
+
+      parent_spec = @scope.type(TypeSpec.new(parent_name))
+
+      !parent_spec.nil? &&
+        parent_spec.pointer_wrapper? &&
+        parent_spec.struct_name == @struct.name
+    end
+
+    # Yields the declaration of the pointer constructor for a class.
+    #
+    # If this class does not have an equivalent struct, or if there is already
+    # a constructor defined with this signature, then this function will return
+    # with no output.
+    def pointer_constructor_declaration
+      return unless @struct
+
+      signature_prefix = "#{@spec['name']}( #{@struct.pointer_declaration('')}"
+      return if @functions.any? do |func|
+        func.constructor? && func.signature.start_with?(signature_prefix)
+      end
+
+      yield "#{pointer_constructor_signature};"
+    end
+
+    # Yields the definition of the pointer constructor for a class.
+    #
+    # If this class has no equivalent struct, or if there is already a
+    # constructor provided with this signature, then this function will return
+    # with no output.
+    #
+    # If this is a pointer wrapper class, then the constructor will simply set
+    # the underlying pointer to the provided one, and return the new object.
+    #
+    # If this is a struct wrapper class, then a constructor will be created that
+    # sets each member of the wrapped struct to the provided value.
+    def pointer_constructor_definition
+      return unless @struct
+
+      signature_prefix = "#{@spec['name']}( #{@struct.pointer_declaration('')}"
+      return if @functions.any? do |func|
+        func.constructor? && func.signature.start_with?(signature_prefix)
+      end
+
+      initializer = pointer_constructor_initializer
+      yield "#{@spec['name']}::#{pointer_constructor_signature} #{initializer}{"
+
+      if pointer_wrapper?
+        yield '  this->equivalent = equivalent;'
+      else
+        @struct.members.each do |member|
+          member_decl = this_member(member['name'])
+          yield "  #{member_decl} = equivalent->#{member['name']};"
+        end
+      end
+
+      yield '}'
+    end
+
+    # The initializer for the pointer constructor, if one is available, or an
+    # empty string if not.
+    def pointer_constructor_initializer
+      if parent_provides_initializer?
+        ": #{parent_name}( equivalent ) "
+      else
+        ''
+      end
+    end
+
+    # The signature of the constructor given an equivalent strucct pointer.
+    def pointer_constructor_signature
+      "#{@spec['name']}( #{@struct.pointer_declaration 'equivalent'} )"
+    end
+
+    # The signature of the constructor given an equivalent struct type.
+    def struct_constructor_signature
+      "#{@spec['name']}( #{@struct.declaration 'equivalent'} )"
+    end
+
+    # Gives a code snippet that accesses a member of the equivalent struct for
+    # this class within the class using the 'this' keyword.
+    def this_member(member)
+      "this->equivalent#{pointer_wrapper? ? '->' : '.'}#{member}"
     end
   end
 end