cpp/sdk_library.gni

# Copyright 2018 The Fuchsia Authors. All rights reserved.
# Use of this source code is governed by a BSD-style license that can be
# found in the LICENSE file.

import("//build/sdk/sdk_atom.gni")

# A set of C++ code exportable in an SDK as sources.
#
# Parameters
#
#   type (required)
#     GN template type for the library.
#
#   category (required)
#     Publication level of the library in SDKs.
#     See //build/sdk/sdk_atom.gni.
#
#   sdk_name (optional)
#     Name of the library in the SDK.
#     If not specified, a name is inferred from the target's label.
#
#   source_dir (optional)
#     If set, path to the base directory of the sources.
#     This is useful if the sources are generated and therefore not hosted
#     directly under the directory where the GN rules are declared.
#
#   include_base (optional)
#     Path to the root directory for includes.
#     Defaults to "include".

template("sdk_library") {
  assert(defined(invoker.type), "Must specify a library type.")
  library_type = invoker.type

  assert(defined(invoker.category), "Must define an SDK category")

  main_target_name = target_name
  sdk_target_name = "${target_name}_sdk"

  target(library_type, main_target_name) {
    forward_variables_from(invoker,
                           "*",
                           [
                             "category",
                             "include_base",
                             "sdk_name",
                             "source_dir",
                             "type",
                           ])

    if (defined(visibility)) {
      visibility += [ ":$sdk_target_name" ]
    }
  }

  compute_name = !defined(invoker.sdk_name)
  if (compute_name) {
    name_target_name = "${target_name}_name"
    default_name = target_name
    target_label = get_label_info(":$target_name", "label_no_toolchain")
    atom_name_file = "$target_gen_dir/${target_name}_sdk_name.txt"

    action(name_target_name) {
      script = "//build/cpp/compute_sdk_name.py"

      outputs = [
        atom_name_file,
      ]

      args = [
        "--out",
        rebase_path(atom_name_file),
        "--default-name",
        default_name,
        "--label",
        target_label,
      ]
    }
  } else {
    atom_name = invoker.sdk_name
  }

  sdk_atom(sdk_target_name) {
    forward_variables_from(invoker,
                           [
                             "source_dir",
                             "testonly",
                           ])

    domain = "cpp"
    if (compute_name) {
      name_file = atom_name_file
    } else {
      name = atom_name
    }

    category = invoker.category

    tags = [ "type:sources" ]

    headers = []
    sources = []
    source_headers_are_public = true
    if (defined(invoker.public)) {
      source_headers_are_public = false
      headers += invoker.public
    }
    if (defined(invoker.sources)) {
      foreach(source_file, invoker.sources) {
        extension = get_path_info(source_file, "extension")
        if (extension == "h" && source_headers_are_public) {
          headers += [ source_file ]
        } else {
          sources += [ source_file ]
        }
      }
    }

    files = []
    foreach(source_file, sources) {
      files += [
        {
          source = source_file
        },
      ]
    }
    foreach(header_file, headers) {
      include_base = "include"
      if (defined(invoker.include_base)) {
        include_base = invoker.include_base
      }
      destination = rebase_path(header_file, include_base)
      files += [
        {
          source = header_file
          dest = "include/$destination"
        },
      ]
    }

    deps = []
    if (defined(invoker.public_deps)) {
      foreach(dep, invoker.public_deps) {
        full_label = get_label_info(dep, "label_no_toolchain")
        deps += [ "${full_label}_sdk" ]
      }
    }

    non_sdk_deps = [ ":$main_target_name" ]
    if (compute_name) {
      non_sdk_deps += [ ":$name_target_name" ]
    }

    # Explicitly add non-public dependencies, in case some of the source files
    # are generated.
    if (defined(invoker.deps)) {
      non_sdk_deps += invoker.deps
    }
  }
}