From 5611ff267b7f11615516fd6efe8373b730999a0d Mon Sep 17 00:00:00 2001
From: Joshua Haberman <jhaberman@gmail.com>
Date: Thu, 16 May 2019 11:35:00 -0700
Subject: Moved bazel files to bazel/ directory.

---
 bazel/BUILD                 |   0
 bazel/build_defs.bzl        | 225 ++++++++++++++++++++++++++++++++++
 bazel/lua.BUILD             | 102 ++++++++++++++++
 bazel/ragel.BUILD           | 193 +++++++++++++++++++++++++++++
 bazel/repository_defs.bzl   |  15 +++
 bazel/upb_proto_library.bzl | 291 ++++++++++++++++++++++++++++++++++++++++++++
 bazel/workspace_deps.bzl    |  36 ++++++
 7 files changed, 862 insertions(+)
 create mode 100644 bazel/BUILD
 create mode 100644 bazel/build_defs.bzl
 create mode 100644 bazel/lua.BUILD
 create mode 100644 bazel/ragel.BUILD
 create mode 100644 bazel/repository_defs.bzl
 create mode 100644 bazel/upb_proto_library.bzl
 create mode 100644 bazel/workspace_deps.bzl

(limited to 'bazel')

diff --git a/bazel/BUILD b/bazel/BUILD
new file mode 100644
index 0000000..e69de29
diff --git a/bazel/build_defs.bzl b/bazel/build_defs.bzl
new file mode 100644
index 0000000..44ef0a3
--- /dev/null
+++ b/bazel/build_defs.bzl
@@ -0,0 +1,225 @@
+"""Internal rules for building upb."""
+
+load(":upb_proto_library.bzl", "GeneratedSrcs")
+
+def _librule(name):
+    return name + "_lib"
+
+def _get_real_short_path(file):
+    # For some reason, files from other archives have short paths that look like:
+    #   ../com_google_protobuf/google/protobuf/descriptor.proto
+    short_path = file.short_path
+    if short_path.startswith("../"):
+        second_slash = short_path.index("/", 3)
+        short_path = short_path[second_slash + 1:]
+    return short_path
+
+def _get_real_root(file):
+    real_short_path = _get_real_short_path(file)
+    return file.path[:-len(real_short_path) - 1]
+
+def _get_real_roots(files):
+    roots = {}
+    for file in files:
+        real_root = _get_real_root(file)
+        if real_root:
+            roots[real_root] = True
+    return roots.keys()
+
+def lua_cclibrary(name, srcs, hdrs = [], deps = [], luadeps = []):
+    lib_rule = name + "_lib"
+    so_rule = "lib" + name + ".so"
+    so_file = _remove_prefix(name, "lua/") + ".so"
+
+    native.cc_library(
+        name = _librule(name),
+        hdrs = hdrs,
+        srcs = srcs,
+        deps = deps + [_librule(dep) for dep in luadeps] + ["@lua//:liblua_headers"],
+    )
+
+    native.cc_binary(
+        name = so_rule,
+        linkshared = True,
+        deps = [_librule(name)],
+        linkopts = select({
+            ":darwin": [
+                "-undefined dynamic_lookup",
+            ],
+            "//conditions:default": [],
+        }),
+    )
+
+    native.genrule(
+        name = name + "_copy",
+        srcs = [":" + so_rule],
+        outs = [so_file],
+        cmd = "cp $< $@",
+    )
+
+    native.filegroup(
+        name = name,
+        data = [so_file],
+    )
+
+def _remove_prefix(str, prefix):
+    if not str.startswith(prefix):
+        fail("%s doesn't start with %s" % (str, prefix))
+    return str[len(prefix):]
+
+def _remove_suffix(str, suffix):
+    if not str.endswith(suffix):
+        fail("%s doesn't end with %s" % (str, suffix))
+    return str[:-len(suffix)]
+
+def lua_library(name, srcs, strip_prefix, luadeps = []):
+    outs = [_remove_prefix(src, strip_prefix + "/") for src in srcs]
+    native.genrule(
+        name = name + "_copy",
+        srcs = srcs,
+        outs = outs,
+        cmd = "cp $(SRCS) $(@D)",
+    )
+
+    native.filegroup(
+        name = name,
+        data = outs + luadeps,
+    )
+
+def make_shell_script(name, contents, out):
+    contents = contents.replace("$", "$$")
+    native.genrule(
+        name = "gen_" + name,
+        outs = [out],
+        cmd = "(cat <<'HEREDOC'\n%s\nHEREDOC\n) > $@" % contents,
+    )
+
+def _lua_binary_or_test(name, luamain, luadeps, rule):
+    script = name + ".sh"
+
+    make_shell_script(
+        name = "gen_" + name,
+        out = script,
+        contents = """
+BASE=$(dirname $(rlocation upb/upb_c.so))
+export LUA_CPATH="$BASE/?.so"
+export LUA_PATH="$BASE/?.lua"
+$(rlocation lua/lua) $(rlocation upb/tools/upbc.lua) "$@"
+""",
+    )
+
+    rule(
+        name = name,
+        srcs = [script],
+        data = ["@lua//:lua", luamain] + luadeps,
+    )
+
+def lua_binary(name, luamain, luadeps = []):
+    _lua_binary_or_test(name, luamain, luadeps, native.sh_binary)
+
+def lua_test(name, luamain, luadeps = []):
+    _lua_binary_or_test(name, luamain, luadeps, native.sh_test)
+
+def generated_file_staleness_test(name, outs, generated_pattern):
+    """Tests that checked-in file(s) match the contents of generated file(s).
+
+    The resulting test will verify that all output files exist and have the
+    correct contents.  If the test fails, it can be invoked with --fix to
+    bring the checked-in files up to date.
+
+    Args:
+      name: Name of the rule.
+      outs: the checked-in files that are copied from generated files.
+      generated_pattern: the pattern for transforming each "out" file into a
+        generated file.  For example, if generated_pattern="generated/%s" then
+        a file foo.txt will look for generated file generated/foo.txt.
+    """
+
+    script_name = name + ".py"
+    script_src = "//:tools/staleness_test.py"
+
+    # Filter out non-existing rules so Blaze doesn't error out before we even
+    # run the test.
+    existing_outs = native.glob(include = outs)
+
+    # The file list contains a few extra bits of information at the end.
+    # These get unpacked by the Config class in staleness_test_lib.py.
+    file_list = outs + [generated_pattern, native.package_name() or ".", name]
+
+    native.genrule(
+        name = name + "_makescript",
+        outs = [script_name],
+        srcs = [script_src],
+        testonly = 1,
+        cmd = "cat $(location " + script_src + ") > $@; " +
+              "sed -i.bak -e 's|INSERT_FILE_LIST_HERE|" + "\\\n  ".join(file_list) + "|' $@",
+    )
+
+    native.py_test(
+        name = name,
+        srcs = [script_name],
+        data = existing_outs + [generated_pattern % file for file in outs],
+        deps = [
+            "//:staleness_test_lib",
+        ],
+    )
+
+# upb_amalgamation() rule, with file_list aspect.
+
+SrcList = provider(
+    fields = {
+        "srcs": "list of srcs",
+        "hdrs": "list of hdrs",
+    },
+)
+
+def _file_list_aspect_impl(target, ctx):
+    if GeneratedSrcs in target:
+        srcs = target[GeneratedSrcs]
+        return [SrcList(srcs = srcs.srcs, hdrs = srcs.hdrs)]
+
+    srcs = []
+    hdrs = []
+    for src in ctx.rule.attr.srcs:
+        srcs += src.files.to_list()
+    for hdr in ctx.rule.attr.hdrs:
+        hdrs += hdr.files.to_list()
+    for hdr in ctx.rule.attr.textual_hdrs:
+        hdrs += hdr.files.to_list()
+    return [SrcList(srcs = srcs, hdrs = hdrs)]
+
+_file_list_aspect = aspect(
+    implementation = _file_list_aspect_impl,
+)
+
+def _upb_amalgamation(ctx):
+    inputs = []
+    srcs = []
+    for lib in ctx.attr.libs:
+        inputs += lib[SrcList].srcs
+        inputs += lib[SrcList].hdrs
+        srcs += [src for src in lib[SrcList].srcs if src.path.endswith("c")]
+    ctx.actions.run(
+        inputs = inputs,
+        outputs = ctx.outputs.outs,
+        arguments = [ctx.bin_dir.path + "/"] + [f.path for f in srcs] + ["-I" + root for root in _get_real_roots(inputs)],
+        progress_message = "Making amalgamation",
+        executable = ctx.executable.amalgamator,
+    )
+    return []
+
+upb_amalgamation = rule(
+    attrs = {
+        "amalgamator": attr.label(
+            executable = True,
+            cfg = "host",
+        ),
+        "libs": attr.label_list(aspects = [_file_list_aspect]),
+        "outs": attr.output_list(),
+    },
+    implementation = _upb_amalgamation,
+)
+
+def licenses(*args):
+    # No-op (for Google-internal usage).
+    pass
diff --git a/bazel/lua.BUILD b/bazel/lua.BUILD
new file mode 100644
index 0000000..7be0b59
--- /dev/null
+++ b/bazel/lua.BUILD
@@ -0,0 +1,102 @@
+package(
+    default_visibility = ["//visibility:public"],
+)
+
+cc_library(
+    name = "liblua_headers",
+    defines = ["LUA_USE_LINUX"],
+    hdrs = [
+        "src/lauxlib.h",
+        "src/lua.h",
+        "src/lua.hpp",
+        "src/luaconf.h",
+        "src/lualib.h",
+    ],
+    includes = ["src"],
+)
+
+cc_library(
+    name = "liblua",
+    srcs = [
+        "src/lapi.c",
+        "src/lapi.h",
+        "src/lauxlib.c",
+        "src/lauxlib.h",
+        "src/lbaselib.c",
+        "src/lbitlib.c",
+        "src/lcode.c",
+        "src/lcode.h",
+        "src/lcorolib.c",
+        "src/lctype.c",
+        "src/lctype.h",
+        "src/ldblib.c",
+        "src/ldebug.c",
+        "src/ldebug.h",
+        "src/ldo.c",
+        "src/ldo.h",
+        "src/ldump.c",
+        "src/lfunc.c",
+        "src/lfunc.h",
+        "src/lgc.c",
+        "src/lgc.h",
+        "src/linit.c",
+        "src/liolib.c",
+        "src/llex.c",
+        "src/llex.h",
+        "src/llimits.h",
+        "src/lmathlib.c",
+        "src/lmem.c",
+        "src/lmem.h",
+        "src/loadlib.c",
+        "src/lobject.c",
+        "src/lobject.h",
+        "src/lopcodes.c",
+        "src/lopcodes.h",
+        "src/loslib.c",
+        "src/lparser.c",
+        "src/lparser.h",
+        "src/lstate.c",
+        "src/lstate.h",
+        "src/lstring.c",
+        "src/lstring.h",
+        "src/lstrlib.c",
+        "src/ltable.c",
+        "src/ltable.h",
+        "src/ltablib.c",
+        "src/ltm.c",
+        "src/ltm.h",
+        "src/lundump.c",
+        "src/lundump.h",
+        "src/lvm.c",
+        "src/lvm.h",
+        "src/lzio.c",
+        "src/lzio.h",
+    ],
+    defines = ["LUA_USE_LINUX"],
+    hdrs = [
+        "src/lauxlib.h",
+        "src/lua.h",
+        "src/lua.hpp",
+        "src/luaconf.h",
+        "src/lualib.h",
+    ],
+    includes = ["src"],
+    linkopts = [
+        "-lm",
+        "-ldl",
+    ],
+)
+
+cc_binary(
+    name = "lua",
+    srcs = [
+        "src/lua.c",
+    ],
+    deps = [
+        ":liblua",
+    ],
+    linkopts = [
+        "-lreadline",
+        "-rdynamic",
+    ],
+)
diff --git a/bazel/ragel.BUILD b/bazel/ragel.BUILD
new file mode 100644
index 0000000..5e3b249
--- /dev/null
+++ b/bazel/ragel.BUILD
@@ -0,0 +1,193 @@
+
+package(
+    default_visibility = ["//visibility:public"],
+)
+
+cc_binary(
+    name = "ragelc",
+    srcs = [
+        "ragel/rubycodegen.cpp",
+        "ragel/goipgoto.h",
+        "ragel/cdtable.h",
+        "ragel/rubycodegen.h",
+        "ragel/gotable.h",
+        "ragel/gocodegen.cpp",
+        "ragel/rubyfflat.cpp",
+        "ragel/common.cpp",
+        "ragel/gofflat.cpp",
+        "ragel/cdtable.cpp",
+        "ragel/cdsplit.cpp",
+        "ragel/rlparse.cpp",
+        "ragel/csfgoto.cpp",
+        "ragel/javacodegen.cpp",
+        "ragel/gocodegen.h",
+        "ragel/mlgoto.cpp",
+        "ragel/fsmgraph.cpp",
+        "ragel/version.h",
+        "ragel/mlfflat.h",
+        "ragel/fsmgraph.h",
+        "ragel/fsmbase.cpp",
+        "ragel/fsmstate.cpp",
+        "ragel/gotablish.cpp",
+        "ragel/rubyflat.cpp",
+        "ragel/cdfgoto.h",
+        "ragel/cscodegen.h",
+        "ragel/mlflat.cpp",
+        "ragel/rubyflat.h",
+        "ragel/goftable.h",
+        "ragel/rbxgoto.cpp",
+        "ragel/csfflat.cpp",
+        "ragel/gofgoto.cpp",
+        "ragel/gofgoto.h",
+        "ragel/ragel.h",
+        "ragel/goftable.cpp",
+        "ragel/cdcodegen.cpp",
+        "ragel/rlparse.h",
+        "ragel/cdsplit.h",
+        "ragel/xmlcodegen.cpp",
+        "ragel/goipgoto.cpp",
+        "ragel/dotcodegen.h",
+        "ragel/gogoto.cpp",
+        "ragel/csflat.h",
+        "ragel/csfflat.h",
+        #"ragel/config.h.in",
+        "ragel/csipgoto.cpp",
+        "ragel/mltable.cpp",
+        "ragel/mlflat.h",
+        "ragel/csftable.cpp",
+        "ragel/cdgoto.h",
+        "ragel/goflat.cpp",
+        "ragel/rubyfflat.h",
+        "ragel/mlftable.h",
+        "ragel/rubyftable.h",
+        "ragel/fsmap.cpp",
+        "ragel/redfsm.cpp",
+        "ragel/goflat.h",
+        "ragel/parsetree.cpp",
+        "ragel/fsmmin.cpp",
+        "ragel/dotcodegen.cpp",
+        "ragel/redfsm.h",
+        "ragel/mlcodegen.cpp",
+        "ragel/cdfgoto.cpp",
+        "ragel/cssplit.cpp",
+        "ragel/cstable.cpp",
+        "ragel/javacodegen.h",
+        "ragel/parsedata.cpp",
+        "ragel/buffer.h",
+        "ragel/gogoto.h",
+        "ragel/csgoto.h",
+        "ragel/pcheck.h",
+        "ragel/rubyftable.cpp",
+        "ragel/csfgoto.h",
+        "ragel/common.h",
+        "ragel/cdftable.h",
+        "ragel/mlgoto.h",
+        "ragel/csgoto.cpp",
+        "ragel/cdflat.h",
+        "ragel/cdipgoto.h",
+        "ragel/cstable.h",
+        "ragel/gendata.h",
+        "ragel/cdfflat.cpp",
+        "ragel/gotable.cpp",
+        "ragel/cdcodegen.h",
+        "ragel/gendata.cpp",
+        "ragel/rubytable.h",
+        "ragel/csflat.cpp",
+        "ragel/inputdata.h",
+        "ragel/inputdata.cpp",
+        "ragel/rubytable.cpp",
+        "ragel/fsmattach.cpp",
+        "ragel/csipgoto.h",
+        "ragel/cscodegen.cpp",
+        "ragel/cdfflat.h",
+        "ragel/rbxgoto.h",
+        "ragel/xmlcodegen.h",
+        "ragel/gofflat.h",
+        "ragel/parsedata.h",
+        "ragel/mlfgoto.h",
+        "ragel/cdflat.cpp",
+        "ragel/config.h",
+        "ragel/rlscan.cpp",
+        "ragel/mlcodegen.h",
+        "ragel/mlfflat.cpp",
+        "ragel/mlftable.cpp",
+        "ragel/mltable.h",
+        "ragel/cdipgoto.cpp",
+        "ragel/cdftable.cpp",
+        "ragel/parsetree.h",
+        "ragel/rlscan.h",
+        "ragel/main.cpp",
+        "ragel/cssplit.h",
+        "ragel/mlfgoto.cpp",
+        "ragel/csftable.h",
+        "ragel/gotablish.h",
+        "ragel/cdgoto.cpp",
+        "aapl/avlmelkey.h",
+        "aapl/dlistmel.h",
+        "aapl/avliset.h",
+        "aapl/avlkeyless.h",
+        "aapl/sbstset.h",
+        "aapl/sbsttable.h",
+        "aapl/quicksort.h",
+        "aapl/avlitree.h",
+        "aapl/avlcommon.h",
+        "aapl/bstset.h",
+        "aapl/avlmel.h",
+        "aapl/insertsort.h",
+        "aapl/dlist.h",
+        "aapl/avlmap.h",
+        "aapl/mergesort.h",
+        "aapl/resize.h",
+        "aapl/bstcommon.h",
+        "aapl/bstmap.h",
+        "aapl/compare.h",
+        "aapl/svector.h",
+        "aapl/avlset.h",
+        "aapl/bsttable.h",
+        "aapl/avlikeyless.h",
+        "aapl/bubblesort.h",
+        "aapl/table.h",
+        "aapl/avlbasic.h",
+        "aapl/vector.h",
+        "aapl/avlimap.h",
+        "aapl/dlistval.h",
+        "aapl/dlcommon.h",
+        "aapl/avlibasic.h",
+        "aapl/sbstmap.h",
+        "aapl/avlimel.h",
+        "aapl/avlimelkey.h",
+        "aapl/avltree.h",
+    ],
+    includes = ["ragel", "aapl"],
+)
+
+config_h_contents = """
+#define PACKAGE "ragel"
+
+/* Define to the address where bug reports for this package should be sent. */
+#define PACKAGE_BUGREPORT ""
+
+/* Define to the full name of this package. */
+#define PACKAGE_NAME "ragel"
+
+/* Define to the full name and version of this package. */
+#define PACKAGE_STRING "ragel 6.10"
+
+/* Define to the one symbol short name of this package. */
+#define PACKAGE_TARNAME "ragel"
+
+/* Define to the home page for this package. */
+#define PACKAGE_URL ""
+
+/* Define to the version of this package. */
+#define PACKAGE_VERSION "6.10"
+
+/* Version number of package */
+#define VERSION "6.10"
+"""
+
+genrule(
+    name = "gen_config_h",
+    outs = ["ragel/config.h"],
+    cmd = "(cat <<'HEREDOC'\n%s\nHEREDOC\n) > $@" % config_h_contents,
+)
diff --git a/bazel/repository_defs.bzl b/bazel/repository_defs.bzl
new file mode 100644
index 0000000..7b6e78e
--- /dev/null
+++ b/bazel/repository_defs.bzl
@@ -0,0 +1,15 @@
+# A hacky way to work around the fact that native.bazel_version is only
+# available from WORKSPACE macros, not BUILD macros or rules.
+#
+# Hopefully we can remove this if/when this is fixed:
+#   https://github.com/bazelbuild/bazel/issues/8305
+
+def _impl(repository_ctx):
+    s = "bazel_version = \"" + native.bazel_version + "\""
+    repository_ctx.file("bazel_version.bzl", s)
+    repository_ctx.file("BUILD", "")
+
+bazel_version_repository = repository_rule(
+    implementation = _impl,
+    local = True,
+)
diff --git a/bazel/upb_proto_library.bzl b/bazel/upb_proto_library.bzl
new file mode 100644
index 0000000..0dc8c6e
--- /dev/null
+++ b/bazel/upb_proto_library.bzl
@@ -0,0 +1,291 @@
+"""Public rules for using upb protos:
+  - upb_proto_library()
+  - upb_proto_reflection_library()
+"""
+
+load("@bazel_skylib//lib:paths.bzl", "paths")
+load("@bazel_tools//tools/cpp:toolchain_utils.bzl", "find_cpp_toolchain")
+
+# copybara:strip_for_google3_begin
+load("@bazel_skylib//lib:versions.bzl", "versions")
+load("@bazel_version//:bazel_version.bzl", "bazel_version")
+# copybara:strip_end
+
+# Generic support code #########################################################
+
+_is_bazel = not hasattr(native, "genmpm")
+
+def _get_real_short_path(file):
+    # For some reason, files from other archives have short paths that look like:
+    #   ../com_google_protobuf/google/protobuf/descriptor.proto
+    short_path = file.short_path
+    if short_path.startswith("../"):
+        second_slash = short_path.index("/", 3)
+        short_path = short_path[second_slash + 1:]
+    return short_path
+
+def _get_real_root(file):
+    real_short_path = _get_real_short_path(file)
+    return file.path[:-len(real_short_path) - 1]
+
+def _get_real_roots(files):
+    roots = {}
+    for file in files:
+        real_root = _get_real_root(file)
+        if real_root:
+            roots[real_root] = True
+    return roots.keys()
+
+def _generate_output_file(ctx, src, extension):
+    if _is_bazel:
+        real_short_path = _get_real_short_path(src)
+    else:
+        real_short_path = paths.relativize(src.short_path, ctx.label.package)
+    output_filename = paths.replace_extension(real_short_path, extension)
+    ret = ctx.new_file(ctx.genfiles_dir, output_filename)
+    return ret
+
+def _filter_none(elems):
+    out = []
+    for elem in elems:
+        if elem:
+            out.append(elem)
+    return out
+
+def _cc_library_func(ctx, name, hdrs, srcs, dep_ccinfos):
+    """Like cc_library(), but callable from rules.
+
+    Args:
+      ctx: Rule context.
+      name: Unique name used to generate output files.
+      hdrs: Public headers that can be #included from other rules.
+      srcs: C/C++ source files.
+      dep_ccinfos: CcInfo providers of dependencies we should build/link against.
+
+    Returns:
+      CcInfo provider for this compilation.
+    """
+
+    compilation_contexts = [info.compilation_context for info in dep_ccinfos]
+    linking_contexts = [info.linking_context for info in dep_ccinfos]
+    toolchain = find_cpp_toolchain(ctx)
+    feature_configuration = cc_common.configure_features(
+        cc_toolchain = toolchain,
+        requested_features = ctx.features,
+        unsupported_features = ctx.disabled_features,
+    )
+
+    # copybara:strip_for_google3_begin
+    if bazel_version == "0.24.1":
+        # Compatibility code until gRPC is on 0.25.2 or later.
+        compilation_info = cc_common.compile(
+            ctx = ctx,
+            feature_configuration = feature_configuration,
+            cc_toolchain = toolchain,
+            srcs = srcs,
+            hdrs = hdrs,
+            compilation_contexts = compilation_contexts,
+        )
+        linking_info = cc_common.link(
+            ctx = ctx,
+            feature_configuration = feature_configuration,
+            cc_toolchain = toolchain,
+            cc_compilation_outputs = compilation_info.cc_compilation_outputs,
+            linking_contexts = linking_contexts,
+        )
+        return CcInfo(
+            compilation_context = compilation_info.compilation_context,
+            linking_context = linking_info.linking_context,
+        )
+
+    if not versions.is_at_least("0.25.2", bazel_version):
+        fail("upb requires Bazel >=0.25.2 or 0.24.1")
+
+    # copybara:strip_end
+
+    blaze_only_args = {}
+
+    if not _is_bazel:
+        blaze_only_args["grep_includes"] = ctx.file._grep_includes
+
+    (compilation_context, compilation_outputs) = cc_common.compile(
+        actions = ctx.actions,
+        feature_configuration = feature_configuration,
+        cc_toolchain = toolchain,
+        name = name,
+        srcs = srcs,
+        public_hdrs = hdrs,
+        compilation_contexts = compilation_contexts,
+        **blaze_only_args
+    )
+    (linking_context, linking_outputs) = cc_common.create_linking_context_from_compilation_outputs(
+        actions = ctx.actions,
+        name = name,
+        feature_configuration = feature_configuration,
+        cc_toolchain = toolchain,
+        compilation_outputs = compilation_outputs,
+        linking_contexts = linking_contexts,
+        **blaze_only_args
+    )
+
+    return CcInfo(
+        compilation_context = compilation_context,
+        linking_context = linking_context,
+    )
+
+# upb_proto_library / upb_proto_reflection_library shared code #################
+
+GeneratedSrcs = provider(
+    fields = {
+        "srcs": "list of srcs",
+        "hdrs": "list of hdrs",
+    },
+)
+
+_WrappedCcInfo = provider(fields = ["cc_info"])
+_WrappedGeneratedSrcs = provider(fields = ["srcs"])
+
+def _compile_upb_protos(ctx, proto_info, proto_sources, ext):
+    srcs = [_generate_output_file(ctx, name, ext + ".c") for name in proto_sources]
+    hdrs = [_generate_output_file(ctx, name, ext + ".h") for name in proto_sources]
+    transitive_sets = list(proto_info.transitive_descriptor_sets)
+    ctx.actions.run(
+        inputs = depset(
+            direct = [ctx.executable._upbc, proto_info.direct_descriptor_set],
+            transitive = [proto_info.transitive_descriptor_sets],
+        ),
+        outputs = srcs + hdrs,
+        executable = ctx.executable._protoc,
+        arguments = [
+                        "--upb_out=" + _get_real_root(srcs[0]),
+                        "--plugin=protoc-gen-upb=" + ctx.executable._upbc.path,
+                        "--descriptor_set_in=" + ":".join([f.path for f in transitive_sets]),
+                    ] +
+                    [_get_real_short_path(file) for file in proto_sources],
+        progress_message = "Generating upb protos for :" + ctx.label.name,
+    )
+    return GeneratedSrcs(srcs = srcs, hdrs = hdrs)
+
+def _upb_proto_rule_impl(ctx):
+    if len(ctx.attr.deps) != 1:
+        fail("only one deps dependency allowed.")
+    dep = ctx.attr.deps[0]
+    if _WrappedCcInfo not in dep or _WrappedGeneratedSrcs not in dep:
+        fail("proto_library rule must generate _WrappedCcInfo and " +
+             "_WrappedGeneratedSrcs (aspect should have handled this).")
+    cc_info = dep[_WrappedCcInfo].cc_info
+    srcs = dep[_WrappedGeneratedSrcs].srcs
+    lib = cc_info.linking_context.libraries_to_link[0]
+    files = _filter_none([
+        lib.static_library,
+        lib.pic_static_library,
+        lib.dynamic_library,
+    ])
+    return [
+        DefaultInfo(files = depset(files + srcs.hdrs + srcs.srcs)),
+        srcs,
+        cc_info,
+    ]
+
+def _upb_proto_aspect_impl(target, ctx):
+    proto_info = target[ProtoInfo]
+    files = _compile_upb_protos(ctx, proto_info, proto_info.direct_sources, ctx.attr._ext)
+    deps = ctx.rule.attr.deps + ctx.attr._upb
+    dep_ccinfos = [dep[CcInfo] for dep in deps if CcInfo in dep]
+    dep_ccinfos += [dep[_WrappedCcInfo].cc_info for dep in deps if _WrappedCcInfo in dep]
+    cc_info = _cc_library_func(
+        ctx = ctx,
+        name = ctx.rule.attr.name + ctx.attr._ext,
+        hdrs = files.hdrs,
+        srcs = files.srcs,
+        dep_ccinfos = dep_ccinfos,
+    )
+    return [_WrappedCcInfo(cc_info = cc_info), _WrappedGeneratedSrcs(srcs = files)]
+
+def _maybe_add(d):
+    if not _is_bazel:
+        d["_grep_includes"] = attr.label(
+            allow_single_file = True,
+            cfg = "host",
+            default = "//tools/cpp:grep-includes",
+        )
+    return d
+
+# upb_proto_library() ##########################################################
+
+_upb_proto_library_aspect = aspect(
+    attrs = _maybe_add({
+        "_upbc": attr.label(
+            executable = True,
+            cfg = "host",
+            default = "//:protoc-gen-upb",
+        ),
+        "_protoc": attr.label(
+            executable = True,
+            cfg = "host",
+            default = "@com_google_protobuf//:protoc",
+        ),
+        "_cc_toolchain": attr.label(
+            default = "@bazel_tools//tools/cpp:current_cc_toolchain",
+        ),
+        "_upb": attr.label_list(default = ["//:upb"]),
+        "_ext": attr.string(default = ".upb"),
+    }),
+    implementation = _upb_proto_aspect_impl,
+    attr_aspects = ["deps"],
+    fragments = ["cpp"],
+)
+
+upb_proto_library = rule(
+    output_to_genfiles = True,
+    implementation = _upb_proto_rule_impl,
+    attrs = {
+        "deps": attr.label_list(
+            aspects = [_upb_proto_library_aspect],
+            allow_rules = ["proto_library"],
+            providers = [ProtoInfo],
+        ),
+    },
+)
+
+# upb_proto_reflection_library() ###############################################
+
+_upb_proto_reflection_library_aspect = aspect(
+    attrs = _maybe_add({
+        "_upbc": attr.label(
+            executable = True,
+            cfg = "host",
+            default = "//:protoc-gen-upb",
+        ),
+        "_protoc": attr.label(
+            executable = True,
+            cfg = "host",
+            default = "@com_google_protobuf//:protoc",
+        ),
+        "_cc_toolchain": attr.label(
+            default = "@bazel_tools//tools/cpp:current_cc_toolchain",
+        ),
+        "_upb": attr.label_list(
+            default = [
+                "//:upb",
+                "//:reflection",
+            ],
+        ),
+        "_ext": attr.string(default = ".upbdefs"),
+    }),
+    implementation = _upb_proto_aspect_impl,
+    attr_aspects = ["deps"],
+    fragments = ["cpp"],
+)
+
+upb_proto_reflection_library = rule(
+    output_to_genfiles = True,
+    implementation = _upb_proto_rule_impl,
+    attrs = {
+        "deps": attr.label_list(
+            aspects = [_upb_proto_reflection_library_aspect],
+            allow_rules = ["proto_library"],
+            providers = [ProtoInfo],
+        ),
+    },
+)
diff --git a/bazel/workspace_deps.bzl b/bazel/workspace_deps.bzl
new file mode 100644
index 0000000..39bf524
--- /dev/null
+++ b/bazel/workspace_deps.bzl
@@ -0,0 +1,36 @@
+
+load("@bazel_tools//tools/build_defs/repo:http.bzl", "http_archive")
+load("@bazel_tools//tools/build_defs/repo:git.bzl", "git_repository")
+load("//bazel:repository_defs.bzl", "bazel_version_repository")
+
+def upb_deps():
+    bazel_version_repository(
+        name = "bazel_version",
+    )
+
+    git_repository(
+        name = "absl",
+        commit = "070f6e47b33a2909d039e620c873204f78809492",
+        remote = "https://github.com/abseil/abseil-cpp.git",
+        shallow_since = "1541627663 -0500",
+    )
+
+    git_repository(
+        name = "com_google_protobuf",
+        remote = "https://github.com/protocolbuffers/protobuf.git",
+        commit = "d41002663fd04325ead28439dfd5ce2822b0d6fb",
+    )
+
+    http_archive(
+        name = "bazel_skylib",
+        strip_prefix = "bazel-skylib-master",
+        urls = ["https://github.com/bazelbuild/bazel-skylib/archive/master.tar.gz"],
+    )
+
+    http_archive(
+        name = "zlib",
+        build_file = "@com_google_protobuf//:third_party/zlib.BUILD",
+        sha256 = "c3e5e9fdd5004dcb542feda5ee4f0ff0744628baf8ed2dd5d66f8ca1197cb1a1",
+        strip_prefix = "zlib-1.2.11",
+        urls = ["https://zlib.net/zlib-1.2.11.tar.gz"],
+    )
-- 
cgit v1.2.3