// Copyright 2019 Google Inc. All rights reserved.
//
// 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.

// *** THIS PACKAGE HAS SPECIAL LICENSING CONDITIONS.  PLEASE
//     CONSULT THE OWNERS AND opensource-licensing@google.com BEFORE
//     DEPENDING ON IT IN YOUR PROJECT. ***
package {
    default_applicable_licenses: ["external_python_cpython3_license"],
}

// See: http://go/android-license-faq
license {
    name: "external_python_cpython3_license",
    visibility: [":__subpackages__"],
    license_kinds: [
        "SPDX-license-identifier-0BSD",
        "SPDX-license-identifier-Apache-2.0",
        "SPDX-license-identifier-BSD",
        "SPDX-license-identifier-CC0-1.0",
        "SPDX-license-identifier-MIT",
        "SPDX-license-identifier-MS-RL", // by exception only
        "SPDX-license-identifier-PSF-2.0",
        "SPDX-license-identifier-Unicode-DFS",
        "SPDX-license-identifier-W3C",
        "SPDX-license-identifier-Zlib",
        "legacy_by_exception_only", // by exception only
        "legacy_notice",
        "legacy_unencumbered",
        // GPL removed. All GPL code either Autoconf exception or dual-licensed PSF
    ],
    license_text: [
        "LICENSE",
    ],
}

build = [
    "Android-bionic.bp",
    "Android-linux_arm64.bp",
    "Android-linux_x86_64.bp",
    "Android-darwin.bp",
]

soong_config_module_type {
    name: "cpython3_cc_defaults",
    module_type: "cc_defaults",
    config_namespace: "cpython3",
    bool_variables: ["force_build_host"],
    properties: ["defaults"],
}

// By default, disable the source and use the prebuilts for host linux
// and darwin. Overridden by cpython3-interp-force_build_host when
// force_build_host is true (set on aosp-build-tools).
cc_defaults {
    name: "cpython3-interp-host-prebuilts",
    defaults_visibility: ["//visibility:private"],
    target: {
        linux_glibc: {
            enabled: false,
        },
        linux_musl: {
            enabled: false,
        },
        darwin: {
            enabled: false,
        },
    },
}

cc_defaults {
    name: "cpython3-interp-force_build_host",
    defaults_visibility: ["//visibility:private"],
    target: {
        linux_glibc: {
            enabled: true,
        },
        linux_musl: {
            enabled: true,
        },
        darwin: {
            enabled: true,
        },
    },
}

cpython3_cc_defaults {
    name: "py3-interp-defaults",
    defaults_visibility: ["//visibility:private"],
    cflags: [
        "-fwrapv",
        "-O3",
        "-Wall",
        "-DPy_BUILD_CORE",
        "-Werror",
        "-Wno-atomic-alignment",
        "-Wno-format",
        "-Wno-gnu-pointer-arith",
        "-Wno-invalid-source-encoding",
        "-Wno-int-conversion",
        "-Wno-missing-field-initializers",
        "-Wno-null-pointer-arithmetic",
        "-Wno-register",
        "-Wno-shift-count-overflow",
        "-Wno-sign-compare",
        "-Wno-tautological-compare",
        "-Wno-tautological-constant-out-of-range-compare",
        "-Wno-unused-function",
        "-Wno-unused-parameter",
        "-Wno-unused-result",
    ],
    local_include_dirs: [
        "Include",
        "Include/internal",
        "Include/internal/mimalloc",
    ],
    static_libs: ["libffi"],
    target: {
        android: {
            local_include_dirs: ["android/bionic/pyconfig"],
        },
        android_arm: {
            cflags: ["-DSOABI=\"cpython-311android-arm-android-bionic\""],
        },
        android_arm64: {
            cflags: ["-DSOABI=\"cpython-311android-arm64-android-bionic\""],
        },
        android_riscv64: {
            cflags: ["-DSOABI=\"cpython-311android-riscv64-android-bionic\""],
        },
        android_x86: {
            cflags: ["-DSOABI=\"cpython-311android-x86-android-bionic\""],
        },
        android_x86_64: {
            cflags: ["-DSOABI=\"cpython-311android-x86_64-android-bionic\""],
        },
        host: {
            // Host builds are moving to prebuilts, which has a higher risk of
            // having an incompatible libc++.so when installed.
            stl: "libc++_static",
        },
        // Regenerate include dirs with android_regen.sh
        darwin: {
            local_include_dirs: ["android/darwin/pyconfig"],
            cflags: [
                "-Wno-deprecated-declarations",
                "-Wno-pointer-arith",
                "-DSOABI=\"cpython-311android-x86_64-darwin\"",
            ],
        },
        linux_bionic: {
            // NB linux_bionic is a 'host' architecture but it uses the bionic libc like 'android'
            // targets so use the android pyconfig.
            local_include_dirs: ["android/bionic/pyconfig"],
            cflags: ["-DSOABI=\"cpython-311android-x86_64-linux-bionic\""],
        },
        linux_glibc_x86: {
            enabled: false,
        },
        linux_musl_x86: {
            enabled: false,
        },
        linux_musl_arm: {
            enabled: false,
        },
        linux_glibc_x86_64: {
            local_include_dirs: ["android/linux_x86_64/pyconfig"],
            cflags: ["-DSOABI=\"cpython-311android-x86_64-linux-gnu\""],
        },
        linux_musl_x86_64: {
            local_include_dirs: ["android/linux_x86_64/pyconfig"],
            cflags: ["-DSOABI=\"cpython-311android-x86_64-linux-gnu\""],
        },
        linux_musl_arm64: {
            local_include_dirs: ["android/linux_arm64/pyconfig"],
            cflags: ["-DSOABI=\"cpython-311android-arm64-linux-gnu\""],
        },
        windows: {
            enabled: false,
        },
    },
    host_supported: true,
    compile_multilib: "both",
    multilib: {
        lib32: {
            suffix: "32",
        },
        lib64: {
            suffix: "64",
        },
    },
    soong_config_variables: {
        force_build_host: {
            defaults: ["cpython3-interp-force_build_host"],
        },
    },
}

cc_library_static {
    name: "py3-interp",
    defaults: [
        "py3-interp-defaults",
        "cpython3-interp-host-prebuilts",
    ],
    cflags: [
        "-DPy_BUILD_CORE",
        "-DPLATLIBDIR=\"lib\"",
    ],
    srcs: [
        // Corresponds to PARSER_OBJS, OBJECT_OBJS, and PYTHON_OBJS in Makefile.pre.in

        // Makefile.pre.in POBJS
        "Parser/token.c",

        // Makefile.pre.in PEGEN_OBJS
        "Parser/pegen.c",
        "Parser/pegen_errors.c",
        "Parser/action_helpers.c",
        "Parser/parser.c",
        "Parser/string_parser.c",
        "Parser/peg_api.c",

        // Makefile.pre.in TOKENIZER_OBJS
        "Parser/lexer/buffer.c",
        "Parser/lexer/lexer.c",
        "Parser/lexer/state.c",
        "Parser/tokenizer/file_tokenizer.c",
        "Parser/tokenizer/readline_tokenizer.c",
        "Parser/tokenizer/string_tokenizer.c",
        "Parser/tokenizer/utf8_tokenizer.c",
        "Parser/tokenizer/helpers.c",

        // Makefile.pre.in PARSER_OBJS
        "Parser/myreadline.c",

        // Makefile.pre.in OBJECT_OBJS
        "Objects/abstract.c",
        "Objects/boolobject.c",
        "Objects/bytes_methods.c",
        "Objects/bytearrayobject.c",
        "Objects/bytesobject.c",
        "Objects/call.c",
        "Objects/capsule.c",
        "Objects/cellobject.c",
        "Objects/classobject.c",
        "Objects/codeobject.c",
        "Objects/complexobject.c",
        "Objects/descrobject.c",
        "Objects/enumobject.c",
        "Objects/exceptions.c",
        "Objects/genericaliasobject.c",
        "Objects/genobject.c",
        "Objects/fileobject.c",
        "Objects/floatobject.c",
        "Objects/frameobject.c",
        "Objects/funcobject.c",
        "Objects/iterobject.c",
        "Objects/listobject.c",
        "Objects/longobject.c",
        "Objects/dictobject.c",
        "Objects/odictobject.c",
        "Objects/memoryobject.c",
        "Objects/methodobject.c",
        "Objects/moduleobject.c",
        "Objects/namespaceobject.c",
        "Objects/object.c",
        "Objects/obmalloc.c",
        "Objects/picklebufobject.c",
        "Objects/rangeobject.c",
        "Objects/setobject.c",
        "Objects/sliceobject.c",
        "Objects/structseq.c",
        "Objects/tupleobject.c",
        "Objects/typeobject.c",
        "Objects/typevarobject.c",
        "Objects/unicodeobject.c",
        "Objects/unicodectype.c",
        "Objects/unionobject.c",
        "Objects/weakrefobject.c",

        // Makefile.pre.in PYTHON_OBJS
        "Python/_warnings.c",
        "Python/Python-ast.c",
        "Python/Python-tokenize.c",
        "Python/asdl.c",
        "Python/assemble.c",
        "Python/ast.c",
        "Python/ast_opt.c",
        "Python/ast_unparse.c",
        "Python/bltinmodule.c",
        "Python/brc.c",
        "Python/ceval.c",
        "Python/codecs.c",
        "Python/compile.c",
        "Python/context.c",
        "Python/critical_section.c",
        "Python/crossinterp.c",
        "Python/dynamic_annotations.c",
        "Python/errors.c",
        "Python/flowgraph.c",
        "Python/frame.c",
        "Python/frozenmain.c",
        "Python/future.c",
        "Python/gc.c",
        "Python/gc_free_threading.c",
        "Python/gc_gil.c",
        "Python/getargs.c",
        "Python/getcompiler.c",
        "Python/getcopyright.c",
        "Python/getplatform.c",
        "Python/getversion.c",
        "Python/ceval_gil.c",
        "Python/hamt.c",
        "Python/hashtable.c",
        "Python/import.c",
        "Python/importdl.c",
        "Python/initconfig.c",
        "Python/interpconfig.c",
        "Python/instrumentation.c",
        "Python/instruction_sequence.c",
        "Python/intrinsics.c",
        "Python/jit.c",
        "Python/legacy_tracing.c",
        "Python/lock.c",
        "Python/marshal.c",
        "Python/modsupport.c",
        "Python/mysnprintf.c",
        "Python/mystrtoul.c",
        "Python/object_stack.c",
        "Python/optimizer.c",
        "Python/optimizer_analysis.c",
        "Python/optimizer_symbols.c",
        "Python/parking_lot.c",
        "Python/pathconfig.c",
        "Python/preconfig.c",
        "Python/pyarena.c",
        "Python/pyctype.c",
        "Python/pyfpe.c",
        "Python/pyhash.c",
        "Python/pylifecycle.c",
        "Python/pymath.c",
        "Python/pystate.c",
        "Python/pythonrun.c",
        "Python/pytime.c",
        "Python/qsbr.c",
        "Python/bootstrap_hash.c",
        "Python/specialize.c",
        "Python/structmember.c",
        "Python/symtable.c",
        "Python/sysmodule.c",
        "Python/thread.c",
        "Python/traceback.c",
        "Python/tracemalloc.c",
        "Python/getopt.c",
        "Python/pystrcmp.c",
        "Python/pystrtod.c",
        "Python/pystrhex.c",
        "Python/dtoa.c",
        "Python/formatter_unicode.c",
        "Python/fileutils.c",
        "Python/suggestions.c",
        "Python/perf_trampoline.c",
        "Python/perf_jit_trampoline.c",
        "Python/dynload_shlib.c",
    ],

    target: {
        linux: {
            cflags: [
                "-DPLATFORM=\"linux\"",
                "-DABIFLAGS=\"\"",
            ],
        },
        linux_arm64: {
            srcs: [
                // PERF_TRAMPOLINE_OBJ
                "Python/asm_trampoline.S",
            ],
        },
        linux_x86_64: {
            srcs: [
                // PERF_TRAMPOLINE_OBJ
                "Python/asm_trampoline.S",
            ],
        },
        darwin: {
            cflags: [
                "-DPLATFORM=\"darwin\"",
                "-DABIFLAGS=\"\"",
            ],
        },
    },
}

cc_defaults {
    name: "py3-launcher-defaults",
    defaults: [
        "py3-interp-defaults",
        "cpython3-interp-host-prebuilts",
    ],
    cflags: [
        "-DVERSION=\"3.13\"",
        "-DVPATH=\"\"",
        "-DPREFIX=\"\"",
        "-DEXEC_PREFIX=\"\"",
        "-DPLATLIBDIR=\"lib\"",
        "-DPYTHONPATH=\"\"",
        "-DDATE=\"Dec 31 1969\"",
        "-DTIME=\"23:59:59\"",
    ],
    static_libs: [
        "libbase",
        "libexpat",
        "libz",
        "libbz",
    ],
    target: {
        linux_glibc_x86_64: {
            host_ldlibs: ["-lutil"],
        },
        linux: {
            // Due to test infra limitations, Python native symbols are linked
            // statically to py3-launcher(s). Hence, need this flag to export
            // these symbols so that runtime imported native extensions can use
            // them (e.g. PyBaseObject_Type)
            ldflags: ["-Wl,--export-dynamic"],
        },
        darwin: {
            host_ldlibs: [
                "-framework SystemConfiguration",
                "-framework CoreFoundation",
            ],
        },
        host: {
            static_libs: [
                "libsqlite_static_noicu",
                "liblog",
                "libopenssl_ssl",
                "libopenssl_crypto",
            ],
        },
        linux_bionic: {
            // Linux Bionic doesn't have openssl prebuilts
            exclude_static_libs: [
                "libopenssl_ssl",
                "libopenssl_crypto",
            ],
        },
        android: {
            shared_libs: [
                // Use shared libsqlite for device side, otherwise
                // the executable size will be really huge.
                "libsqlite",
                // Dependency from libbase
                "liblog",
            ],
        },
    },
}

cc_library_static {
    name: "py3-launcher-lib-omit-frozen",
    defaults: ["py3-launcher-defaults"],
    cflags: ["-DPy_BUILD_CORE"],
    srcs: [
        // Makefile.pre.in MODULE_OBJS
        "Modules/main.c",
        "Modules/gcmodule.c",

        // Makefile.pre.in LIBRARY_OBJS_OMIT_FROZEN
        "Modules/getbuildinfo.c",
    ],
    whole_static_libs: [
        "py3-interp",
        "py3-c-modules",
    ],
    target: {
        android: {
            srcs: ["android/bionic/config.c"],
        },
        linux_bionic: {
            srcs: ["android/bionic/config.c"],
        },
        glibc_x86_64: {
            srcs: ["android/linux_x86_64/config.c"],
        },
        musl_x86_64: {
            srcs: ["android/linux_x86_64/config.c"],
        },
        musl_arm64: {
            srcs: ["android/linux_arm64/config.c"],
        },
        darwin: {
            srcs: ["android/darwin/config.c"],
        },
    },
}

cc_library_static {
    name: "py3-launcher-lib",
    defaults: ["py3-launcher-defaults"],
    cflags: ["-DPy_BUILD_CORE"],
    srcs: [
        // Makefile.pre.in LIBRARY_OBJS
        "Modules/getpath.c",
        "Python/frozen.c",
    ],
    local_include_dirs: [
        "android",
        "android/Python",
    ],
    whole_static_libs: [
        "py3-launcher-lib-omit-frozen",
    ],
}

cc_library_headers {
    name: "py3-headers",
    defaults: [
        "py3-interp-defaults",
        "cpython3-interp-host-prebuilts",
    ],
    host_supported: true,
    device_supported: false,
    export_include_dirs: ["Include"],
    target: {
        darwin: {
            export_include_dirs: ["android/darwin/pyconfig"],
        },
        linux_bionic: {
            export_include_dirs: ["android/bionic/pyconfig"],
        },
        linux_glibc_x86_64: {
            export_include_dirs: ["android/linux_x86_64/pyconfig"],
        },
        linux_musl_x86_64: {
            export_include_dirs: ["android/linux_x86_64/pyconfig"],
        },
        linux_musl_arm64: {
            export_include_dirs: ["android/linux_arm64/pyconfig"],
        },
    },
    visibility: ["//visibility:public"],
}

cc_binary {
    name: "py3-launcher",
    defaults: ["py3-launcher-defaults"],
    srcs: ["android/launcher_main.cpp"],
    static_libs: ["py3-launcher-lib"],
}

cc_binary {
    name: "py3-launcher-autorun",
    defaults: ["py3-launcher-defaults"],
    srcs: ["android/launcher_main.cpp"],
    static_libs: ["py3-launcher-lib"],
    cflags: ["-DANDROID_AUTORUN"],
}

cc_binary_host {
    name: "py3-launcher-static",
    defaults: ["py3-launcher-defaults"],
    srcs: ["android/launcher_main.cpp"],
    static_libs: ["py3-launcher-lib"],
    static_executable: true,
    target: {
        glibc: {
            enabled: false,
        },
    },
}

cc_binary_host {
    name: "py3-launcher-autorun-static",
    defaults: ["py3-launcher-defaults"],
    srcs: ["android/launcher_main.cpp"],
    static_libs: ["py3-launcher-lib"],
    static_executable: true,
    cflags: ["-DANDROID_AUTORUN"],
    target: {
        glibc: {
            enabled: false,
        },
    },
}

python_binary_host {
    name: "py3-cmd",
    autorun: false,
    // embedded_launcher: true is the default, but the whole point of this binary
    // is that it's the python interpreter, so writing it here for clarity.
    embedded_launcher: true,
}

// Enabled extension py3-c-modules.

cc_library_static {
    name: "py3-c-modules",
    defaults: [
        "py3-interp-defaults",
        "cpython3-interp-host-prebuilts",
    ],
    cflags: [
        "-DPy_BUILD_CORE_BUILTIN",
        "-DSQLITE_OMIT_LOAD_EXTENSION",
    ],
    local_include_dirs: [
        "Modules/_hacl/include",
    ],
    shared_libs: ["libsqlite"],
    static_libs: [
        "libexpat",
        "libz",
        "libbz",
    ],
    whole_static_libs: ["libmpdec"],
    srcs: [
        "Modules/_hacl/Hacl_Hash_SHA2.c",
    ],
    target: {
        android: {
            srcs: [":py3-c-modules-bionic"],
        },
        linux_bionic: {
            srcs: [":py3-c-modules-bionic"],
        },
        glibc_x86_64: {
            srcs: [":py3-c-modules-linux_x86_64"],
            static_libs: [
                "libopenssl_ssl",
                "libopenssl_crypto",
            ],
        },
        musl_x86_64: {
            srcs: [":py3-c-modules-linux_x86_64"],
            static_libs: [
                "libopenssl_ssl",
                "libopenssl_crypto",
            ],
        },
        musl_arm64: {
            srcs: [":py3-c-modules-linux_arm64"],
            static_libs: [
                "libopenssl_ssl",
                "libopenssl_crypto",
            ],
        },
        darwin: {
            cflags: [
                "-D__APPLE_USE_RFC_3542",
                "-DUSING_MALLOC_CLOSURE_DOT_C=1",
            ],
            srcs: [":py3-c-modules-darwin"],
            static_libs: [
                "libopenssl_ssl",
                "libopenssl_crypto",
            ],
        },
    },
}