1
0
Fork 0
mirror of https://github.com/denoland/deno.git synced 2024-12-12 18:42:18 -05:00
denoland-deno/BUILD.gn

373 lines
8.4 KiB
Text
Raw Normal View History

# Copyright 2018 the Deno authors. All rights reserved. MIT license.
import("//build/toolchain/cc_wrapper.gni")
2018-07-03 04:15:32 -04:00
import("//third_party/v8/gni/v8.gni")
import("//third_party/v8/snapshot_toolchain.gni")
import("//build_extra/flatbuffers/flatbuffer.gni")
import("//build_extra/flatbuffers/rust/rust_flatbuffer.gni")
import("//build_extra/deno.gni")
import("//build_extra/rust/rust.gni")
import("//build_extra/toolchain/validate.gni")
2018-08-17 18:23:14 -04:00
group("default") {
2018-07-12 18:37:06 -04:00
testonly = true
deps = [
":deno",
2018-07-17 00:41:25 -04:00
":deno_ns",
2018-07-12 18:37:06 -04:00
":test_cc",
":test_rs",
2018-07-12 18:37:06 -04:00
]
}
2018-06-19 06:54:24 -04:00
config("deno_config") {
2018-07-03 04:15:32 -04:00
include_dirs = [ "third_party/v8" ] # This allows us to v8/src/base/ libraries.
configs = [ "third_party/v8:external_config" ]
if (is_debug) {
defines = [ "DEBUG" ]
}
# Targets built with the `rust_executable()` template automatically pick up
# these dependencies, but those built with `executable()` need them when they
# have Rust inputs. Currently, there's only one such target, `test_cc`.
if (is_mac) {
libs = [ "resolv" ]
}
if (is_win) {
libs = [ "userenv.lib" ]
}
if (is_clang) {
cflags = [
"-fcolor-diagnostics",
"-fansi-escape-codes",
]
}
2018-06-19 06:54:24 -04:00
}
main_extern = [
2018-08-05 18:50:15 -04:00
"$rust_build:hyper",
"$rust_build:hyper_rustls",
"$rust_build:futures",
"$rust_build:lazy_static",
"$rust_build:libc",
"$rust_build:log",
"$rust_build:ring",
2018-07-24 01:45:23 -04:00
"$rust_build:tempfile",
2018-08-23 18:36:45 -04:00
"$rust_build:rand",
"$rust_build:tokio",
"$rust_build:tokio_io",
"$rust_build:tokio_fs",
"$rust_build:tokio_executor",
2018-09-22 04:42:07 -04:00
"$rust_build:tokio_threadpool",
"$rust_build:url",
"$rust_build:remove_dir_all",
"$rust_build:dirs",
"//build_extra/flatbuffers/rust:flatbuffers",
":msg_rs",
]
2018-09-12 10:33:30 -04:00
ts_sources = [
"js/assets.ts",
2018-09-14 08:45:50 -04:00
"js/blob.ts",
2018-09-12 10:33:30 -04:00
"js/compiler.ts",
"js/console.ts",
"js/copy_file.ts",
2018-09-12 10:33:30 -04:00
"js/deno.ts",
2018-10-13 16:03:27 -04:00
"js/dir.ts",
2018-09-12 10:33:30 -04:00
"js/dispatch.ts",
2018-09-16 02:46:12 -04:00
"js/dom_types.ts",
2018-09-12 10:33:30 -04:00
"js/errors.ts",
"js/fetch.ts",
2018-10-03 21:41:59 -04:00
"js/file_info.ts",
"js/files.ts",
2018-10-03 21:41:59 -04:00
"js/global_eval.ts",
2018-09-12 10:33:30 -04:00
"js/globals.ts",
"js/io.ts",
2018-09-12 10:33:30 -04:00
"js/libdeno.ts",
"js/main.ts",
2018-09-12 22:04:45 -04:00
"js/make_temp_dir.ts",
2018-10-05 13:21:15 -04:00
"js/metrics.ts",
"js/mkdir.ts",
2018-09-12 10:33:30 -04:00
"js/mock_builtin.js",
"js/net.ts",
2018-09-12 10:33:30 -04:00
"js/os.ts",
2018-09-20 02:13:59 -04:00
"js/platform.ts",
2018-09-12 10:33:30 -04:00
"js/plugins.d.ts",
2018-10-12 14:22:52 -04:00
"js/promise_util.ts",
2018-10-03 17:56:56 -04:00
"js/read_dir.ts",
"js/read_file.ts",
"js/read_link.ts",
2018-09-12 10:33:30 -04:00
"js/remove.ts",
"js/rename.ts",
"js/stat.ts",
2018-09-19 00:38:24 -04:00
"js/symlink.ts",
2018-09-12 10:33:30 -04:00
"js/text_encoding.ts",
"js/timers.ts",
2018-09-22 03:59:26 -04:00
"js/trace.ts",
2018-09-30 15:06:20 -04:00
"js/truncate.ts",
2018-09-12 10:33:30 -04:00
"js/types.ts",
"js/util.ts",
"js/v8_source_maps.ts",
"js/write_file.ts",
"tsconfig.json",
# Listing package.json and yarn.lock as sources ensures the bundle is rebuilt
# when npm packages are added/removed or their contents changes.
"package.json",
"third_party/yarn.lock",
2018-09-12 10:33:30 -04:00
]
2018-06-23 03:42:06 -04:00
rust_executable("deno") {
source_root = "src/main.rs"
extern = main_extern
2018-07-12 18:38:00 -04:00
deps = [
":libdeno",
]
}
# This target is for fast incremental development.
# When modifying the javascript runtime, this target will not go through the
# extra process of building a snapshot and instead load the bundle from disk.
2018-07-17 00:41:25 -04:00
# ns = no snapshot
rust_executable("deno_ns") {
source_root = "src/main.rs"
extern = main_extern
2018-07-12 18:38:00 -04:00
deps = [
":libdeno_nosnapshot",
]
2018-06-15 19:43:23 -04:00
}
rust_test("test_rs") {
source_root = "src/main.rs"
extern = main_extern
deps = [
":libdeno",
2018-07-10 14:56:12 -04:00
]
}
2018-08-13 23:03:32 -04:00
v8_executable("test_cc") {
2018-06-10 08:24:39 -04:00
testonly = true
sources = [
"libdeno/test.cc",
2018-06-10 08:24:39 -04:00
]
deps = [
":deno_base_test",
2018-06-10 08:24:39 -04:00
"//testing/gtest:gtest",
]
2018-08-13 23:03:32 -04:00
configs = [ ":deno_config" ]
2018-06-10 08:24:39 -04:00
}
static_library("libdeno") {
complete_static_lib = true
2018-06-11 11:01:35 -04:00
sources = [
"libdeno/from_snapshot.cc",
2018-06-11 11:01:35 -04:00
]
2018-08-01 21:33:52 -04:00
inputs = [
"$target_gen_dir/snapshot_deno.bin",
]
2018-06-10 08:24:39 -04:00
deps = [
2018-06-11 11:01:35 -04:00
":create_snapshot_deno",
":deno_bindings",
2018-06-10 08:24:39 -04:00
]
2018-06-19 06:54:24 -04:00
configs += [ ":deno_config" ]
# from_snapshot.cc uses an assembly '.incbin' directive to embed the snapshot.
# This causes trouble when using sccache: since the snapshot file is not
# inlined by the c preprocessor, sccache doesn't take its contents into
# consideration, leading to false-positive cache hits.
# Maybe other caching tools have this issue too, but ccache is unaffected.
# Therefore, if a cc_wrapper is used that isn't ccache, include a generated
# header file that contains the the sha256 hash of the snapshot.
if (cc_wrapper != "" && cc_wrapper != "ccache") {
hash_h = "$target_gen_dir/bundle/hash.h"
inputs += [ hash_h ]
deps += [ ":bundle_hash_h" ]
if (is_win) {
cflags = [ "/FI" + rebase_path(hash_h, target_out_dir) ]
} else {
cflags = [
"-include",
rebase_path(hash_h, target_out_dir),
]
}
}
2018-06-10 08:24:39 -04:00
}
# Only functionality needed for libdeno_test and snapshot_creator
# In particular no flatbuffers, no assets, no rust, no msg handlers.
# Because snapshots are slow, it's important that snapshot_creator's
# dependencies are minimal.
v8_source_set("deno_base") {
2018-06-10 08:24:39 -04:00
sources = [
"libdeno/binding.cc",
"libdeno/deno.h",
"libdeno/file_util.cc",
"libdeno/file_util.h",
"libdeno/internal.h",
]
public_deps = [
"third_party/v8:v8_monolith",
]
configs = [ ":deno_config" ]
}
v8_source_set("deno_base_test") {
testonly = true
sources = [
"libdeno/file_util_test.cc",
"libdeno/from_snapshot.cc",
"libdeno/libdeno_test.cc",
]
2018-08-06 19:40:04 -04:00
inputs = [
"$target_gen_dir/snapshot_libdeno_test.bin",
]
deps = [
":create_snapshot_libdeno_test",
":deno_base",
"//testing/gtest:gtest",
]
defines = [ "LIBDENO_TEST" ]
configs = [ ":deno_config" ]
}
v8_source_set("deno_bindings") {
deps = [
":deno_base",
]
configs = [ ":deno_config" ]
}
2018-06-10 08:24:39 -04:00
executable("snapshot_creator") {
sources = [
"libdeno/snapshot_creator.cc",
2018-06-10 08:24:39 -04:00
]
deps = [
":deno_base",
2018-06-10 08:24:39 -04:00
]
2018-06-19 06:54:24 -04:00
configs += [ ":deno_config" ]
2018-06-10 08:24:39 -04:00
}
# Generates the core TypeScript type library for deno that will be
# included in the runtime bundle
run_node("deno_runtime_declaration") {
2018-08-07 16:27:31 -04:00
out_dir = target_gen_dir
2018-09-12 10:33:30 -04:00
sources = ts_sources
2018-08-07 16:27:31 -04:00
outputs = [
"$out_dir/lib/lib.deno_runtime.d.ts",
2018-08-07 16:27:31 -04:00
]
deps = [
":msg_ts",
]
args = [
rebase_path("node_modules/.bin/ts-node", root_build_dir),
"--project",
rebase_path("tools/ts_library_builder/tsconfig.json"),
rebase_path("tools/ts_library_builder/main.ts", root_build_dir),
"--basePath",
rebase_path(".", root_build_dir),
"--buildPath",
rebase_path(root_build_dir, root_build_dir),
"--outFile",
rebase_path("$out_dir/lib/lib.deno_runtime.d.ts", root_build_dir),
"--silent",
2018-08-07 16:27:31 -04:00
]
if (is_debug) {
args += [ "--debug" ]
}
2018-08-07 16:27:31 -04:00
}
2018-06-11 21:54:55 -04:00
run_node("bundle") {
out_dir = "$target_gen_dir/bundle/"
sources = ts_sources + [ "rollup.config.js" ]
outputs = [
out_dir + "main.js",
2018-07-21 21:14:52 -04:00
out_dir + "main.js.map",
2018-06-11 21:54:55 -04:00
]
deps = [
":deno_runtime_declaration",
2018-07-25 23:07:50 -04:00
":msg_ts",
]
2018-06-11 21:54:55 -04:00
args = [
2018-07-21 21:14:52 -04:00
"./node_modules/rollup/bin/rollup",
"-c",
rebase_path("rollup.config.js", root_build_dir),
"-i",
rebase_path("js/main.ts", root_build_dir),
2018-07-21 21:14:52 -04:00
"-o",
rebase_path(out_dir + "main.js", root_build_dir),
"--sourcemapFile",
rebase_path("."),
2018-07-21 21:14:52 -04:00
"--silent",
"--environment",
"BASEPATH:" + rebase_path(".", root_build_dir),
2018-06-11 21:54:55 -04:00
]
}
action("bundle_hash_h") {
script = "//tools/sha256sum.py"
inputs = get_target_outputs(":bundle")
outputs = [
"$target_gen_dir/bundle/hash.h",
]
deps = [
":bundle",
]
args = [
"--format",
"__attribute__((__unused__)) static const int dummy_%s = 0;",
"--outfile",
rebase_path(outputs[0], root_build_dir),
]
foreach(input, inputs) {
args += [
"--infile",
rebase_path(input, root_build_dir),
]
}
}
source_set("libdeno_nosnapshot") {
2018-08-10 13:41:12 -04:00
bundle_outputs = get_target_outputs(":bundle")
bundle_location = rebase_path(bundle_outputs[0], root_build_dir)
bundle_map_location = rebase_path(bundle_outputs[1], root_build_dir)
2018-08-10 13:41:12 -04:00
inputs = bundle_outputs
sources = [
"libdeno/from_filesystem.cc",
]
deps = [
":bundle",
":deno_bindings",
]
configs += [ ":deno_config" ]
2018-08-10 13:41:12 -04:00
defines = [
"BUNDLE_LOCATION=\"$bundle_location\"",
"BUNDLE_MAP_LOCATION=\"$bundle_map_location\"",
]
}
2018-07-04 14:50:28 -04:00
ts_flatbuffer("msg_ts") {
sources = [
"src/msg.fbs",
]
}
rust_flatbuffer("msg_rs") {
sources = [
"src/msg.fbs",
]
}
# Generates $target_gen_dir/snapshot_deno.bin
create_snapshot("deno") {
2018-06-11 21:54:55 -04:00
js = "$target_gen_dir/bundle/main.js"
source_map = "$target_gen_dir/bundle/main.js.map"
deps = [
2018-06-11 21:54:55 -04:00
":bundle",
]
}
2018-06-11 11:01:35 -04:00
# Generates $target_gen_dir/snapshot_libdeno_test.bin
create_snapshot("libdeno_test") {
2018-06-11 11:01:35 -04:00
testonly = true
js = "libdeno/libdeno_test.js"
2018-06-11 11:01:35 -04:00
}