build/fidl/fidlc.gni

# Copyright 2022 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/compiled_action.gni")
import("//build/fidl/toolchain.gni")

# Runs the FIDL compiler.
#
# Parameters
#   fidl_target_name (required)
#     The name of the `fidl` target.
#
#   library_name (required)
#     The name of the fidl library.
#
#   json_representation (required)
#     The path to the JSON to generate.
#
#   target_api_level
#     Only compile APIs available at this level. Defaults to "HEAD".
#
#   target_api_platform
#     Only compile APIs available on this platform. Defaults to "fuchsia"
#
#   fidl_deps
#   non_fidl_deps
#   sources
#   experimental_flags
#   deps
#   public_deps
template("fidlc") {
  assert(defined(invoker.fidl_target_name), "fidl_target_name is required")
  assert(defined(invoker.json_representation),
         "json_representation is required")
  assert(defined(invoker.library_name), "library_name is required")
  assert(defined(invoker.fidl_deps), "fidl_deps is required")
  assert(defined(invoker.sources), "sources is required")

  experimental_flags = [ "no_optional_structs" ]
  if (defined(invoker.experimental_flags)) {
    experimental_flags += invoker.experimental_flags
  }

  fidl_deps = []
  if (defined(invoker.fidl_deps)) {
    fidl_deps += invoker.fidl_deps
  }

  non_fidl_deps = []
  if (defined(invoker.non_fidl_deps)) {
    non_fidl_deps += invoker.non_fidl_deps
  }

  gen_dir = target_gen_dir
  if (defined(invoker.gen_dir)) {
    gen_dir = invoker.gen_dir
  }

  main_target_name = target_name
  fidl_target_name = invoker.fidl_target_name
  library_name = invoker.library_name
  json_representation = invoker.json_representation

  # These paths are expected by the templates in //build/c/fidlc.gni.
  generated_binding_dir = "$gen_dir/$fidl_target_name/c"
  c_stem = string_replace(invoker.library_name, ".", "/") + "/c/fidl"
  c_client = "$generated_binding_dir/$c_stem.client.c"
  c_header = "$generated_binding_dir/$c_stem.h"
  c_server = "$generated_binding_dir/$c_stem.server.c"
  coding_tables = "$generated_binding_dir/$fidl_target_name.fidl.tables.c"
  fidlc_depfile_path = "$generated_binding_dir/$library_name.d"

  libraries_file = "$gen_dir/$fidl_target_name.libraries"
  response_file = "$gen_dir/$target_name.args"
  response_file_target_name = "${main_target_name}_response_file"
  action(response_file_target_name) {
    forward_variables_from(invoker,
                           [
                             "deps",
                             "public_deps",
                             "sources",
                             "testonly",
                             "visibility",
                           ])

    script = "//build/fidl/gen_response_file.py"

    outputs = [
      response_file,
      libraries_file,
    ]

    args = [
             "--out-response-file",
             rebase_path(response_file, root_build_dir),
             "--out-libraries",
             rebase_path(libraries_file, root_build_dir),
             "--json",
             rebase_path(json_representation, root_build_dir),
             "--deprecated-fuchsia-only-c-client",
             rebase_path(c_client, root_build_dir),
             "--deprecated-fuchsia-only-c-header",
             rebase_path(c_header, root_build_dir),
             "--deprecated-fuchsia-only-c-server",
             rebase_path(c_server, root_build_dir),
             "--tables",
             rebase_path(coding_tables, root_build_dir),
             "--name",
             library_name,
             "--depfile",
             rebase_path(fidlc_depfile_path, root_build_dir),
             "--sources",
           ] + rebase_path(sources, root_build_dir)

    if (defined(invoker.target_api_level)) {
      args += [
        "--target-api-level",
        invoker.target_api_level,
      ]
    }
    if (defined(invoker.target_api_platform)) {
      args += [
        "--target-platform",
        invoker.target_api_platform,
      ]
    }
    if (defined(invoker.fidl_deps)) {
      dep_libraries = []
      foreach(dep, invoker.fidl_deps) {
        dep_gen_dir = get_label_info(dep, "target_gen_dir")
        dep_name = get_label_info(dep, "name")
        dep_libraries += [ "$dep_gen_dir/$dep_name.libraries" ]
      }
      args += [ "--dep-libraries" ] + rebase_path(dep_libraries, root_build_dir)
      inputs = dep_libraries
    }

    foreach(flag, experimental_flags) {
      args += [
        "--experimental",
        flag,
      ]
    }
  }

  compiled_action(main_target_name) {
    forward_variables_from(invoker,
                           [
                             "deps",
                             "sources",
                             "testonly",
                           ])

    tool = "//tools/fidl/fidlc:fidlc"
    inputs = [ response_file ]
    depfile = fidlc_depfile_path
    outputs = [
      c_client,
      c_header,
      c_server,
      coding_tables,
      json_representation,
    ]
    args = [ "@" + rebase_path(response_file, root_build_dir) ]
    deps += non_fidl_deps
    public_deps = [ ":$response_file_target_name" ]
    if (defined(invoker.public_deps)) {
      public_deps += invoker.public_deps
    }
  }
}