path: root/build/ymake.core.conf

# !!! DISCLAIMER! PLEASE DON'T IGNORE !!!
# The FAKEID value is huge hammer. It affects UIDs of all nodes in build graph including, but not limited to
# any resource fetch (think java contrib), build on any language (C++, Python, Java, Go), any code generation.
# Any build after this change will pay the price:
# - Local builds and Sandbox builds will reload all resources from Sandbox and cached data from YT (if ready).
# - Distributed (YT) cache warmup will take significant time to catch up and will need to recache everything.
# - Autocheck will rebuild and recache everything.
# Use this with extreme care and only change if it is ultimately needed. Consider more specific XXX_FAKEIDs below instead.
FAKEID=3141592653

SANDBOX_FAKEID=${FAKEID}.7600000
CPP_FAKEID=9362383
GO_FAKEID=9336945
ANDROID_FAKEID=8821472
CLANG_TIDY_FAKEID=8625699

CURDIR=.
MODDIR=.
BINDIR=bin:/
SRCDIR=
YMAKE=ymake
ECHO=echo
INCLUDE_EXTS=.h .hh .hpp .rli .cuh .inc .i
CPP_EXT=.cpp
OBJ_SUF=
CFLAGS=
EXTRA_C_FLAGS=
SFLAGS=

AUTOCHECK_BALANCING_OPTIONS=
SO_OTPUTS=no

@import "${CONF_ROOT}/conf/settings.conf"
@import "${CONF_ROOT}/conf/opensource.conf"
@import "${CONF_ROOT}/conf/rules.conf"
@import "${CONF_ROOT}/conf/sysincl.conf"
@import "${CONF_ROOT}/conf/license.conf"
@import "${CONF_ROOT}/conf/ts.conf"
@import "${CONF_ROOT}/conf/docs.conf"

@import "${CONF_ROOT}/conf/project_specific/other.conf"

USE_GLOBAL_CMD=no
when ($OS_WINDOWS != "yes") {
    USE_GLOBAL_CMD=yes
}

YMAKE_RESOURCE_BIN=${YMAKE_RESOURCE_GLOBAL}/ymake
YMAKE_RESOURCE_DIR=build/external_resources/ymake
when ($USE_YMAKE_RESOURCE == "yes") {
    PEERDIR+=${YMAKE_RESOURCE_DIR}
}

__COMMA__=${comma:""}

ARCADIA_TEST_ROOT=../arcadia_tests_data/
DEFAULT_REQUIREMENTS=network:restricted cpu:1 ram:32
BISON_DATA_DIR=contrib/tools/bison/bison/data
CPP_BISON_SKELS=${BISON_DATA_DIR}/glr.cc ${BISON_DATA_DIR}/lalr1.cc ${BISON_DATA_DIR}/yacc.c ${BISON_DATA_DIR}/stack.hh ${BISON_DATA_DIR}/variant.hh ${BISON_DATA_DIR}/c++.m4 ${BISON_DATA_DIR}/c++-skel.m4

USE_PREBUILT_TOOLS=yes
when ($OPENSOURCE == "yes") {
    USE_PREBUILT_TOOLS=no
}

FAIL_PY2=no

_PREBUILT_TOOLS_ROOT=build/prebuilt
_TOOL_PROTOC_GEN_GO=vendor/github.com/golang/protobuf/protoc-gen-go
_TOOL_RESCOMPILER=tools/rescompiler
_TOOL_RESCOMPRESSOR=tools/rescompressor
_TOOL_RORESCOMPILER=tools/rorescompiler

when ($HOST_ARCH_X86_64 == "yes") {
    when ($HOST_OS_DARWIN == "yes" || $HOST_OS_LINUX == "yes" || $HOST_OS_WINDOWS == "yes") {
        VALID_HOST_PLATFORM_FOR_COMMON_PREBUILT_TOOLS=yes

        when ($USE_PREBUILT_TOOLS == "yes" && $ARCH_X86_64 == "yes") {
            _TOOL_PROTOC_GEN_GO=${_PREBUILT_TOOLS_ROOT}/vendor/github.com/golang/protobuf/protoc-gen-go
        }
    }
}

FAIL_MODULE_CMD=$YMAKE_PYTHON ${input:"build/scripts/fail_module_cmd.py"} $TARGET ${kv;hide:"p ER"} ${kv;hide:"pc red"}

when ($TIDY == "yes") {
    when ($TIDY_EXPORT_FIXES=="") {
        TIDY_EXPORT_FIXES="no"
    }

    CLANG_TIDY_ARGS=${hide:CLANG_TIDY_FAKEID} $YMAKE_PYTHON ${input:"build/scripts/clang_tidy.py"} "--ymake-python" $YMAKE_PYTHON "--clang-tidy-bin" "$(CLANG_TIDY_BIN)/bin/clang-tidy" "--config-validation-script" ${input:"build/tests/config/clang_tidy/tidy_config_validation.py"} "--testing-src" ${input:SRC} "--source-root" $(SOURCE_ROOT) "--build-root" $(BUILD_ROOT) "--tidy-json" ${output;noauto;suf=${OBJ_CROSS_SUF}${COMPILE_OUT_SUFFIX}.tidyjson:SRC} "--export-fixes" $TIDY_EXPORT_FIXES
    CLANG_TIDY_ARGS+="--default-config-file" ${input:DEFAULT_TIDY_CONFIG}
    CLANG_TIDY_ARGS+="--project-config-file" ${input:PROJECT_TIDY_CONFIG}
    when ($TIDY_CHECKS) {
        CLANG_TIDY_ARGS+="--checks=$TIDY_CHECKS"
    }

    when ($TIDY_HEADER_FILTER) {
        CLANG_TIDY_ARGS+="--header-filter=$TIDY_HEADER_FILTER"
    }

    TIDY_VALUE=USE_CONDITIONAL_SRCS
}
otherwise {
    CLANG_TIDY_ARGS=
    TIDY_VALUE=
}

# tag:codenav
when ($CODENAVIGATION && $NOCODENAVIGATION != "yes") {
    PY_PROGRAM_LINK_EXE=$LINK_EXE ${kv;hide:"pyndex $TARGET"}
    YNDEXER_ARGS=$YMAKE_PYTHON ${input:"build/scripts/yndexer.py"} $CPPYNDEXER_RESOURCE_GLOBAL/yndexer 1500 $(SOURCE_ROOT) $ARCADIA_BUILD_ROOT ${input:SRC}
    YNDEXER_OUTPUT=${output;noauto;suf=${OBJ_CROSS_SUF}${COMPILE_OUT_SUFFIX}.ydx.pb2:SRC}
}
otherwise {
    PY_PROGRAM_LINK_EXE=$LINK_EXE
    YNDEXER_ARGS=
    YNDEXER_OUTPUT=
}

COVERAGE_FLAGS=
EXTRA_OUTPUT=
when ($CLANG == "yes" || $GCC == "yes") {
    when ($BUILD_TYPE == "COVERAGE" || $GCOV_COVERAGE) {
        COVERAGE_FLAGS=-fprofile-arcs -ftest-coverage
        EXTRA_OUTPUT=${output;noauto;hide;suf=${OBJ_CROSS_SUF}${COMPILE_OUT_SUFFIX}.gcno:SRC}
    }
}

when ($OS_CYGWIN == "yes") {
    CFLAGS+=-D_LDBL_EQ_DBL=1 -U__STRICT_ANSI__
    USE_ASMLIB=no
    FSTACK=
}

CFLAGS+=$COVERAGE_FLAGS
LDFLAGS+=$COVERAGE_FLAGS

CHECKFLAG=
LEX_FLAGS=
NO_MAPREDUCE=

when ($NO_MAPREDUCE ==  "yes") {
    C_DEFINES+=-DNO_MAPREDUCE
}

when ($OS_ANDROID == "yes") {
    PIE=yes
}

# TODO: extract to conf/maps/maps.conf
when ($MAPSMOBI_BUILD_TARGET == "yes" && $OS_LINUX != "yes") {
    USE_STL_SYSTEM=yes
}
when ($MAPSMOBI_BUILD_TARGET == "yes" && $OS_IOS == "yes") {
    BUILD_IOS_APP=yes
    when ($ARCH_ARM7 || $ARCH_ARM64) {
        BOOSTTEST_IS_FAT_OBJECT=yes
    }
}

# USE_INTERNAL_STL is an internal flag (set on by default) but may be used externally to
# select system standard C++ library when USE_INTERNAL_STL=no is set.
#
# USE_STL_SYSTEM=yes is a regular way to select system standard C++ library.
#
when ($USE_STL_SYSTEM == "yes") {
    USE_INTERNAL_STL=no
}

when ($USE_INTERNAL_STL == "no") {
    USE_STL_SYSTEM=yes
}
otherwise {
    USE_INTERNAL_STL=yes
    # TODO: Extract to conf/sysincl.conf
    # This trigger doesn't work for module level since SYSINCL is processed at
    # configuration stage (This means that NO_RUNTIME() macro called in ya.make
    # won't affect SYSINCL and the only way to make this trigger work correctly
    # is to define configuration variable NORUNTIME (-DNORUNTIME) on the command
    # line when `ya make ...` is invoked.
    when ($NORUNTIME != "yes") {
        SYSINCL+=build/sysincl/stl-to-libcxx.yml
        when ($MUSL == "yes") {
            SYSINCL+=build/sysincl/libc-musl-libcxx.yml
        }
    }
}

# tag:linux-specific
when ($OS_LINUX && $OS_SDK == "ubuntu-14" && $MUSL != "yes") {
    USE_UBUNTU_COMPATIBILITY=yes
}

USE_ARCADIA_PYTHON=yes
USE_ARCADIA_LIBM=no
USE_EAT_MY_DATA=no

HAVE_MKL=
when ($HAVE_MKL == "") {
    when ($OS_LINUX && $ARCH_X86_64 && !$SANITIZER_TYPE) {
        HAVE_MKL=yes
    }
    otherwise {
        HAVE_MKL=no
    }
}

SFDL_TMP_OUT= ${output;tmp:SRC.tmp}

# tag:perl-specific
when ($USE_LOCAL_TOOLS == "yes") {
    PERL=$LOCAL_PERL
    PERL_VERSION=$LOCAL_PERL_VERSION
    PERL_PRIVLIB=$LOCAL_PERL_PRIVLIB
    PERL_ARCHLIB=$LOCAL_PERL_ARCHLIB
    when ($LOCAL_PERL_LIBS) {
        PERL_LIBS=$LOCAL_PERL_LIBS
    }
}
otherwise {
    PERL=NO-PERL-SELECTED
    PERL_VERSION=NO-PERL-SELECTED-VERSION
    PERL_PRIVLIB=NO-PERL-SELECTED-PRIVLIB
    PERL_ARCHLIB=NO-PERL-SELECTED-ARCHLIB
}

# tag:perl-specific
PERL_LD_LIBRARY_PATH=
PERL_INCLUDE=
USE_PERL_SYSTEM=yes
when ($USE_PERL_SYSTEM == "yes") {
    select ($PERL_SDK) {
        "ubuntu-12" ? {
            PERL_VERSION=5.14
            PERL_ROOT=${SYSTEM_PERL_514_RESOURCE_GLOBAL}/perl${PERL_VERSION}
            PERL_LIB_ARCH=
        }
        "ubuntu-14" ? {
            PERL_VERSION=5.18
            PERL_ROOT=${SYSTEM_PERL_518_RESOURCE_GLOBAL}/perl${PERL_VERSION}
            PERL_LIB_ARCH=
        }
        "ubuntu-16" ? {
            PERL_VERSION=5.22
            PERL_ROOT=${SYSTEM_PERL_522_RESOURCE_GLOBAL}/perl${PERL_VERSION}
            PERL_LIB_ARCH=/x86_64-linux-gnu
        }
        "ubuntu-18" ? {
            PERL_VERSION=5.26
            PERL_ROOT=${SYSTEM_PERL_526_RESOURCE_GLOBAL}/perl${PERL_VERSION}
            PERL_LIB_ARCH=/x86_64-linux-gnu
        }
        "ubuntu-20" ? {
            PERL_VERSION=5.30
            PERL_ROOT=${SYSTEM_PERL_530_RESOURCE_GLOBAL}/usr
            PERL_LIB_ARCH=/x86_64-linux-gnu
        }
    }

    PERL=${PERL_ROOT}/bin/perl
    PERL_ARCHLIB=${PERL_ROOT}/lib$PERL_LIB_ARCH/perl/${PERL_VERSION}
    PERL_PRIVLIB=${PERL_ROOT}/share/perl/${PERL_VERSION}
    PERL_LIBS=${PERL_ROOT}/lib${PERL_LIB_ARCH}
    PERL_LD_LIBRARY_PATH=${env:"LD_LIBRARY_PATH=${PERL_ROOT}/lib"}

    # Perl searches it's modules in INC@ paths. They can not be sysrooted or disabled (at least I haven't found a way),
    # so default Perl module directories should be prepended to perl command lines when using non-local perl.
    PERL_INCLUDE=-I${PERL_ARCHLIB} -I${PERL_PRIVLIB}
}
PERL_DEFAULT_PEERDIR=yes

# tag:perl-specific
PERLSUFFIX=-csuffix .cpp
PERLOUTPUT=${stdout;output:SRC.cpp}
when ($PERLC == "yes") {
    PERLSUFFIX=-csuffix .c
    PERLOUTPUT=${stdout;output:SRC.c}
}
XSUBPPFLAGS=

# tag:tool-specific
ARCH_TOOL=${tool:"tools/archiver"}

# tag:tool-specific tag:proto
PROTOC=${tool:"contrib/tools/protoc"}
PROTOC_STYLEGUIDE_OUT=--cpp_styleguide_out=$ARCADIA_BUILD_ROOT/$PROTO_NAMESPACE
PROTOC_PLUGIN_STYLEGUIDE=--plugin=protoc-gen-cpp_styleguide=${tool:"contrib/tools/protoc/plugins/cpp_styleguide"}
PROTOBUF_PATH=${ARCADIA_ROOT}/contrib/libs/protobuf/src
USE_VANILLA_PROTOC=no
PROTOC_TRANSITIVE_HEADERS=yes

# tag:tool-specific
FML_TOOL=${tool:"tools/relev_fml_codegen"}
FML_UNUSED_TOOL=${tool:"tools/relev_fml_unused"}
LUA_TOOL=${tool:"tools/lua"}
ENUM_PARSER_TOOL=${tool:"tools/enum_parser/enum_parser"}

# tag:python-specific tag:cython-specific
CYTHON_SCRIPT=${input:"${ARCADIA_ROOT}/contrib/tools/cython/cython.py"} $CYTHON_PREDEFINED_INCLUDES
RUN_CYTHON_SCRIPT=$YMAKE_PYTHON $CYTHON_SCRIPT
PYTHON_TYPE_FOR_CYTHON=PY2
CYTHON_OUTPUT_INCLUDES=\
${output_include;hide:"contrib/libs/python/Include/compile.h"} \
${output_include;hide:"contrib/libs/python/Include/frameobject.h"} \
${output_include;hide:"contrib/libs/python/Include/longintrepr.h"} \
${output_include;hide:"contrib/libs/python/Include/pyconfig.h"} \
${output_include;hide:"contrib/libs/python/Include/Python.h"} \
${output_include;hide:"contrib/libs/python/Include/pythread.h"} \
${output_include;hide:"contrib/libs/python/Include/structmember.h"} \
${output_include;hide:"contrib/libs/python/Include/traceback.h"} \
${output_include;hide:"contrib/tools/cython/generated_c_headers.h"} \
${output_include;hide:"omp.h"}

# tag:cython-specific
CYTHON_CPP_OUTPUT_INCLUDES=${output_include;hide:"contrib/tools/cython/generated_cpp_headers.h"}

# tag:cython-specific
CYTHON_PREDEFINED_INCLUDES=\
    ${input;hide:"contrib/tools/cython/Cython/Utility/Buffer.c"} \
    ${input;hide:"contrib/tools/cython/Cython/Utility/Builtins.c"} \
    ${input;hide:"contrib/tools/cython/Cython/Utility/CMath.c"} \
    ${input;hide:"contrib/tools/cython/Cython/Utility/Capsule.c"} \
    ${input;hide:"contrib/tools/cython/Cython/Utility/CommonTypes.c"} \
    ${input;hide:"contrib/tools/cython/Cython/Utility/Complex.c"} \
    ${input;hide:"contrib/tools/cython/Cython/Utility/Coroutine.c"} \
    ${input;hide:"contrib/tools/cython/Cython/Utility/CythonFunction.c"} \
    ${input;hide:"contrib/tools/cython/Cython/Utility/Embed.c"} \
    ${input;hide:"contrib/tools/cython/Cython/Utility/Exceptions.c"} \
    ${input;hide:"contrib/tools/cython/Cython/Utility/ExtensionTypes.c"} \
    ${input;hide:"contrib/tools/cython/Cython/Utility/FunctionArguments.c"} \
    ${input;hide:"contrib/tools/cython/Cython/Utility/ImportExport.c"} \
    ${input;hide:"contrib/tools/cython/Cython/Utility/MemoryView_C.c"} \
    ${input;hide:"contrib/tools/cython/Cython/Utility/ModuleSetupCode.c"} \
    ${input;hide:"contrib/tools/cython/Cython/Utility/ObjectHandling.c"} \
    ${input;hide:"contrib/tools/cython/Cython/Utility/Optimize.c"} \
    ${input;hide:"contrib/tools/cython/Cython/Utility/Overflow.c"} \
    ${input;hide:"contrib/tools/cython/Cython/Utility/Printing.c"} \
    ${input;hide:"contrib/tools/cython/Cython/Utility/Profile.c"} \
    ${input;hide:"contrib/tools/cython/Cython/Utility/StringTools.c"} \
    ${input;hide:"contrib/tools/cython/Cython/Utility/TestUtilityLoader.c"} \
    ${input;hide:"contrib/tools/cython/Cython/Utility/TypeConversion.c"}

# tag:cython-specific
CYTHON_PREDEFINED_INDUCED=\
    contrib/libs/python/Include/Python.h

# tag:cython-specific
CYTHON_OPTIONS=
when ($OS_LINUX) {
    CYTHON_OPTIONS += -E UNAME_SYSNAME=Linux
}
elsewhen ($OS_DARWIN) {
    CYTHON_OPTIONS += -E UNAME_SYSNAME=Darwin
}
elsewhen ($OS_WINDOWS) {
    CYTHON_OPTIONS += -E UNAME_SYSNAME=Windows
}

when ($USE_LOCAL_SWIG != "yes") {
    _SWIG_TOOL=${tool:"contrib/tools/swig"}
    _SWIG_LIBRARY=contrib/tools/swig/Lib
    _SWIG_LIBRARY_ABS=$ARCADIA_ROOT/$_SWIG_LIBRARY
}
otherwise {
    _SWIG_TOOL=$SWIG_TOOL
    _SWIG_LIBRARY=$SWIG_LIBRARY
    _SWIG_LIBRARY_ABS=$SWIG_LIBRARY
}
SWIG_IMPLICIT_INCLUDES = swig.swg go.swg java.swg perl5.swg python.swg

FATAL_ERROR_MODULE=no
FATAL_ERROR_MESSAGE=

# tag:python-specific
# PYTHON_DISTR={ "default" | "macos-brew" }  determine python system supply
# see build/platform/python/ya.make
PYTHON_DISTR="default"
when ($USE_SYSTEM_PYTHON) {
    USE_ARCADIA_PYTHON=no
    select ($USE_SYSTEM_PYTHON) {
        "2.7" ? {
            _SYSTEM_PYTHON27=yes
            PY_VERSION=2.7
            PY_FRAMEWORK_VERSION=2.7
        }
        "3.4" ? {
            _SYSTEM_PYTHON34=yes
            PY_VERSION=3.4m
            PY_FRAMEWORK_VERSION=3.4
        }
        "3.5" ? {
            _SYSTEM_PYTHON35=yes
            PY_VERSION=3.5m
            PY_FRAMEWORK_VERSION=3.5
        }
        "3.6" ? {
            _SYSTEM_PYTHON36=yes
            PY_VERSION=3.6m
            PY_FRAMEWORK_VERSION=3.6
        }
        "3.7" ? {
            _SYSTEM_PYTHON37=yes
            PY_VERSION=3.7m
            PY_FRAMEWORK_VERSION=3.7
        }
        "3.8" ? {
            _SYSTEM_PYTHON38=yes
            PY_VERSION=3.8
            PY_FRAMEWORK_VERSION=3.8
        }
        "3.9" ? {
            _SYSTEM_PYTHON39=yes
            PY_VERSION=3.9
            PY_FRAMEWORK_VERSION=3.9
        }
        "3.10" ? {
            _SYSTEM_PYTHON310=yes
            PY_VERSION=3.10
            PY_FRAMEWORK_VERSION=3.10
        }
        default ? {
            FATAL_ERROR_MESSAGE+=invalid USE_SYSTEM_PYTHON value
        }
    }
}

### @usage: NO_LTO()
###
### Disable any lto (link-time optimizations) for the module.
### This will compile module source files as usual (without LTO) but will not prevent lto-enabled
### linking of entire program if global settings say so.
macro NO_LTO() {
    DISABLE(USE_LTO)
    DISABLE(USE_THINLTO)
}

when ($USE_LTO == "yes" && $OS_LINUX != "yes" && $OS_ANDROID != "yes") {
    FATAL_ERROR_MESSAGE+=lto is only supported for linux
}

# tag:python-specific
YMAKE_PYTHON3_PEER=build/platform/python/ymake_python3
YMAKE_PYTHON3=$YMAKE_PYTHON3_RESOURCE_GLOBAL/python3
when ($HOST_OS_WINDOWS == "yes") {
    YMAKE_PYTHON3=$YMAKE_PYTHON3_RESOURCE_GLOBAL/python3.exe
}

# tag:python-specific
when ($USE_ARCADIA_PYTHON == "no") {
    SYSINCL+=build/sysincl/python.yml
}

# tag:allocator
DEFAULT_ALLOCATOR=LF

# tag:allocator
when ($OS_ANDROID == "yes" || $MSVC == "yes") {
    DEFAULT_ALLOCATOR=J
}

# tag:allocator
when ($OS_CYGWIN == "yes" || $ARCH_PPC64LE == "yes") {
    DEFAULT_ALLOCATOR=SYSTEM
}

# tag:allocator
when ($OS_DARWIN == "yes") {
    DEFAULT_ALLOCATOR=SYSTEM
}

# tag:allocator
when ($SANITIZER_TYPE) {
    when ($SANITIZER_TYPE != "no") {
        DEFAULT_ALLOCATOR=SYSTEM
    }
}

# tag:internal
### @usage: CHECK_CONFIG_H(<conf_header>) # internal
###
### This internal macro adds checking code for configuration header in external (contrib) library.
### The check is needed to avoid conflicts on certain types and functions available in arcadia.
###
### @see https://a.yandex-team.ru/arc/trunk/arcadia/build/scripts/check_config_h.py for exact details
macro CHECK_CONFIG_H(Conf) {
    .CMD=$YMAKE_PYTHON ${input:"build/scripts/check_config_h.py"} ${input;rootrel:Conf} ${output;nopath;noext:Conf.config.cpp} ${kv;hide:"p CH"} ${kv;hide:"pc yellow"}
    OUTPUT_INCLUDES=$Conf
}

REQUIRED_TRANSITIVE_PEERS=
### @usage REQUIRES(dirs...)
###
### Specify list of dirs which this module must depend on indirectly.
###
### This macro can be used if module depends on the directories specified but they can't be listed
### as direct PEERDIR dependencies (due to public include order or link order issues).
macro REQUIRES(DIRS[]) {
    SET_APPEND(REQUIRED_TRANSITIVE_PEERS $DIRS)
}

CHECK_DEPENDENT_DIRS_TYPES=
CHECK_DEPENDENT_DIRS_RESTRICTIONS=
### @usage CHECK_DEPENDENT_DIRS(DENY|ALLOW_ONLY ([ALL|PEERDIRS|GLOB] dir)...)
###
### Specify project transitive dependencies constraints.
###
### @params:
###  1. DENY: current module can not depend on module from any specified directory neither directly nor transitively.
###  2. ALLOW_ONLY: current module can not depend on module from a dir not specified in the directory list neither directly nor transitively.
###  3. ALL: directory constraints following after this modifier are applied to both transitive PEERDIR dependencies and tool dependencies.
###  4. PEERDIRS: directory constraints following after this modifier are applied to transitive PEERDIR dependencies only.
###  5. GLOB: next directory constraint is an ANT glob pattern.
###  6. EXCEPT: next constraint is an exception for the rest of other rules.
###
### Directory constraints added before either ALL or PEERDIRS modifier is used are treated as ALL directory constraints.
###
### Note: Can be used multiple times on the same module all specified constraints will be checked.
### All macro invocation for the same module must use same constraints type (DENY or ALLOW_ONLY)
macro CHECK_DEPENDENT_DIRS(TYPE, ALL?"UNUSED":"", PEERDIRS?"PEERDIRS":"ALL", RESTRICTIONS...) {
    SET_APPEND(CHECK_DEPENDENT_DIRS_RESTRICTIONS $PEERDIRS $RESTRICTIONS)
    SET_APPEND(CHECK_DEPENDENT_DIRS_TYPES $TYPE)
}

# tag:proto
PY_PROTOS_FOR=no
BUILD_PROTO_AS_EVLOG=no

# tag:proto
PROTO_NAMESPACE=

# tag:proto tag:python-specific
GEN_PY_PROTOS=$YMAKE_PYTHON ${input:"build/scripts/gen_py_protos.py"}

# tag:proto tag:cpp-specific
PROTO_HEADER_EXTS=.pb.h
CPP_PROTO_CMDLINE=
CPP_PROTO_OPTS=
CPP_PROTO_OUTS=
CPP_PROTO_OUTS_SEM=
CPP_PROTO_SUFFIXES=.pb.h .pb.cc
CPP_PROTO_PLUGINS=

# tag:proto tag:cpp-specific
CPP_EV_OPTS=--plugin=protoc-gen-event2cpp=${tool:"tools/event2cpp"} --event2cpp_out=$ARCADIA_BUILD_ROOT -I=$ARCADIA_ROOT/library/cpp/eventlog
CPP_EV_OUTS=

# tag:proto tag:python-specific
PY_PROTO_OPTS=
PY_PROTO_OUTS=
PY_PROTO_OUTS_INTERNAL=
PY_PROTO_DEPS=
PY_PROTO_SUFFIXES=_pb2.py
PY_EVLOG_SUFFIXES=_ev_pb2.py

# tag:proto tag:java-specific
JAVA_PROTO_ARGS=

# tag:proto tag:python-specific
OPTIMIZE_PY_PROTOS_FLAG=no

macro _RESOURCE_SEM(INPUTS[], KEYS[]) {
    SET(RESOURCE_OUTPUT ${hash:INPUTS}.cpp)
    .SEM=resources ${output;global:RESOURCE_OUTPUT} INPUTS ${input:INPUTS} KEYS $KEYS ${tool;hide:"tools/rescompiler/bin"}
}

# tag:built-in
### @usage: RESOURCE([FORCE_TEXT ][Src Key]* [- Key=Value]*) # built-in
### Add data (resources, random files, strings) to the program)
### The common usage is to place Src file into binary. The Key is used to access it using library/cpp/resource or library/python/resource.
### Alternative syntax with '- Key=Value' allows placing Value string as resource data into binary and make it accessible by Key.
###
### This is a simpler but less flexible option than ARCHIVE(), because in the case of ARCHIVE(), you have to use the data explicitly,
### and in the case of RESOURCE(), the data will fall through SRCS() or SRCS(GLOBAL) to binary linking.
###
### Use the FORCE_TEXT parameter to explicitly mark all Src files as text files: they will not be parsed unless used elsewhere.
###
### @example: https://wiki.yandex-team.ru/yatool/howtowriteyamakefiles/#a2ispolzujjtekomanduresource
###
### @example:
###
###     LIBRARY()
###         OWNER(user1)
###
###         RESOURCE(
###             path/to/file1 /key/in/program/1
###             path/to/file2 /key2
###         )
###     END()
###
macro RESOURCE(Args...) {
    PEERDIR(library/cpp/resource)
}

# tag:internal
### @usage: _ORDER_ADDINCL([BUILD ...] [SOURCE ...] Args...) # internal
###
### Order and filter ADDINCLs (Args - is intentionally omitted in ADDINCL macro)
macro _ORDER_ADDINCL(BUILD[], SOURCE[], ARGS...) {
    ADDINCL($BUILD $SOURCE)
}

# tag:proto
### @usage: PROTO_ADDINCL([GLOBAL] [WITH_GEN] Path)
###
### This macro introduces proper ADDINCLs for .proto-files found in sources and
### .cpp/.h generated files, supplying them to appropriate commands and allowing
### proper dependency resolution at configure-time.
###
### Note: you normally shouldn't use this macro. ADDINCLs should be sent to user
### from dependency via PROTO_NAMESPACE macro
macro PROTO_ADDINCL(GLOBAL?"GLOBAL":"", Path, WITH_GEN?"BUILD":"") {
    _ORDER_ADDINCL($WITH_GEN $GLOBAL FOR proto ${ARCADIA_BUILD_ROOT}/$Path SOURCE $GLOBAL FOR proto ${ARCADIA_ROOT}/$Path)
    ADDINCL($GLOBAL ${ARCADIA_BUILD_ROOT}/$Path)
}

# tag:proto
### @usage: PROTO_NAMESPACE([GLOBAL] [WITH_GEN] Namespace)
###
### Defines protobuf namespace (import/export path prefix) which should be used for imports and
### which defines output path for .proto generation.
###
### For proper importing and configure-time dependency management it sets ADDINCLs
### for both .cpp headers includes and .proto imports. If .proto expected to be used outside of the
### processing module use GLOBAL to send proper ADDINCLs to all (transitive) users. PEERDIR to
### PROTO_LIBRARY with PROTO_NAMESPACE(GLOBAL ) is enough at user side to correctly use the library.
### If generated .proto files are going to be used for building a module than use of WITH_GEN
### parameter will add appropriate dir from the build root for .proto files search.
macro PROTO_NAMESPACE(GLOBAL?"GLOBAL":"", WITH_GEN?"WITH_GEN":"", Namespace) {
    SET(PROTO_NAMESPACE $Namespace)
    PROTO_ADDINCL($GLOBAL $WITH_GEN $Namespace)
}

# tag:proto tag:internal tag:python-specific
### @usage: OPTIMIZE_PY_PROTOS()  # internal
###
### Enable Python proto optimization by embedding corresponding C++ code into binary.
### Python protobuf runtime will use C++ implementation instead of Python one if former is available.
### This is default mode for most PROTO_LIBRARY's and PY2_LIBRARY's, some system ones being exceptions.
macro OPTIMIZE_PY_PROTOS() {
    SET(OPTIMIZE_PY_PROTOS_FLAG yes)
}

# tag:proto tag:python-specific
### @usage: NO_OPTIMIZE_PY_PROTOS()
###
### Disable Python proto optimization using embedding corresponding C++ code into binary.
### Python protobuf runtime will use C++ implementation instead of Python one if former is available.
### This is default mode only for some system libraries.
macro NO_OPTIMIZE_PY_PROTOS() {
    SET(OPTIMIZE_PY_PROTOS_FLAG no)
}

# tag:proto tag:python-specific
macro _PROTO_PLUGIN_ARGS_BASE(Name, Tool, OutParm...) {
    .CMD=--plugin=protoc-gen-${Name}=\${tool:"$Tool"} --${Name}_out=$OutParm$ARCADIA_BUILD_ROOT/\$PROTO_NAMESPACE
    .SEM=ignored
}

# tag:proto tag:python-specific
macro _ADD_PY_PROTO_OUT(Suf) {
    SET_APPEND(PY_PROTO_OUTS \${output;hide;noauto;norel;nopath;noext;suf=$Suf:File})
    SET_APPEND(PY_PROTO_OUTS_INTERNAL \${output;hide;noauto;norel;nopath;noext;suf=__int__$Suf:File} \${hide;kv:"ext_out_name_for_\${nopath;noext;suf=__int__$Suf:File} \${nopath;noext;suf=$Suf:File}"})
    # XXX fix variable expansion in plugins
    SET(PY_PROTO_SUFFIXES $PY_PROTO_SUFFIXES $Suf)
}

# tag:proto tag:python-specific
### @usage: PY_PROTO_PLUGIN(Name Ext Tool DEPS <Dependencies>)
###
### Define protoc plugin for python with given Name that emits extra output with provided Extension
### using Tool. Extra dependencies are passed via DEPS
macro PY_PROTO_PLUGIN(NAME, EXT, TOOL, DEPS[]) {
    SET_APPEND(PY_PROTO_OPTS $_PROTO_PLUGIN_ARGS_BASE($NAME $TOOL))
    _ADD_PY_PROTO_OUT($EXT)
    # XXX fix variable expansion in plugins
    SET(PY_PROTO_DEPS $PY_PROTO_DEPS $DEPS)
}

# tag:proto tag:python-specific
### @usage: PY_PROTO_PLUGIN2(Name Ext1 Ext2 Tool DEPS <Dependencies>)
###
### Define protoc plugin for python with given Name that emits 2 extra outputs with provided Extensions
### using Tool. Extra dependencies are passed via DEPS
macro PY_PROTO_PLUGIN2(NAME, EXT1, EXT2, TOOL, DEPS[]) {
    PY_PROTO_PLUGIN($NAME $EXT1 $TOOL DEPS $DEPS)
    _ADD_PY_PROTO_OUT($EXT2)
}

# tag:proto tag:java-specific
macro _JAVA_PROTO_PLUGIN_ARGS_BASE(Name, Tool, OutParm...) {
    .CMD=--plugin=protoc-gen-${Name}=\${tool:"$Tool"} --${Name}_out=$ARCADIA_BUILD_ROOT/java_out
}

# tag:proto tag:java-specific
### @usage: JAVA_PROTO_PLUGIN(Name Tool DEPS <Dependencies>)
###
### Define protoc plugin for Java with given Name that emits extra outputs
### using Tool. Extra dependencies are passed via DEPS
macro JAVA_PROTO_PLUGIN(NAME, TOOL, DEPS[]) {
    SET_APPEND(JAVA_PROTO_ARGS $_JAVA_PROTO_PLUGIN_ARGS_BASE($NAME $TOOL))
    # XXX fix variable expansion in plugins
    SET(JAVA_PROTOBUF_PEERS $JAVA_PROTOBUF_PEERS $DEPS)
}

# tag:proto tag:cpp-specific
macro _ADD_CPP_PROTO_OUT(Suf) {
    .SEM=append_target_property PROTOC_EXTRA_OUTS $Suf ${output;hide;suf=.o:Suf} && set_target_property PROTO_NAMESPACE $PROTO_NAMESPACE
    SET_APPEND(CPP_PROTO_OUTS \${output;hide;norel;nopath;noext;suf=$Suf:File})

    # XXX fix variable expansion in plugins
    SET(CPP_PROTO_SUFFIXES $CPP_PROTO_SUFFIXES $Suf)
}

# tag:proto tag:cpp-specific
HAS_CPP_PROTOBUF_PEERS=no
CPP_PROTOBUF_PEERS=

# tag:proto tag:cpp-specific
### @usage: CPP_PROTO_PLUGIN0(Name Tool DEPS <Dependencies>)
###
### Define protoc plugin for C++ with given Name that emits code into regular outputs
### using Tool. Extra dependencies are passed via DEPS.
macro CPP_PROTO_PLUGIN0(NAME, TOOL, DEPS[]) {
    .SEM=target_proto_plugin $NAME ${tool;rootrel:TOOL} ${output;hide;suf=.fake.o:NAME}
    SET_APPEND(CPP_PROTO_OPTS $_PROTO_PLUGIN_ARGS_BASE($NAME $TOOL))

    # XXX fix variable expansion in plugins
    ENABLE(HAS_CPP_PROTOBUF_PEERS)
    SET(CPP_PROTOBUF_PEERS $CPP_PROTOBUF_PEERS $DEPS)
}

# tag:proto tag:cpp-specific
### @usage: CPP_PROTO_PLUGIN(Name Tool Suf DEPS <Dependencies>)
###
### Define protoc plugin for C++ with given Name that emits code into 1 extra output
### using Tool. Extra dependencies are passed via DEPS.
macro CPP_PROTO_PLUGIN(NAME, TOOL, SUF, DEPS[]) {
    CPP_PROTO_PLUGIN0($NAME $TOOL DEPS $DEPS)

    _ADD_CPP_PROTO_OUT($SUF)
}

# tag:proto tag:cpp-specific
### @usage: CPP_PROTO_PLUGIN2(Name Tool Suf1 Suf2 DEPS <Dependencies>)
###
### Define protoc plugin for C++ with given Name that emits code into 2 extra outputs
### using Tool. Extra dependencies are passed via DEPS.
macro CPP_PROTO_PLUGIN2(NAME, TOOL, SUF1, SUF2, DEPS[]) {
    CPP_PROTO_PLUGIN($NAME $TOOL $SUF1 DEPS $DEPS)

    _ADD_CPP_PROTO_OUT($SUF2)
    SET_APPEND(CPP_PROTO_OUTS_SEM \${output;hide;norel;nopath;noext;suf=$SUF2:File})
}

# tag:proto
### @usage: USE_SKIFF() #wip, do not use
###
### Use mapreduce/yt/skiff_proto/plugin for C++
macro USE_SKIFF() {
    # Move extra includes to INDUCED_DEPS macro in mapreduce/yt/skiff_proto/plugin/ya.make
    CPP_PROTO_PLUGIN0(skiff mapreduce/yt/skiff_proto/plugin DEPS mapreduce/yt/skiff_proto/lib)
}

# tag:go-specific
_GO_COMMON_GOOGLE_APIS = \
vendor/google.golang.org/genproto/googleapis/api/annotations \
vendor/google.golang.org/genproto/googleapis/api/configchange \
vendor/google.golang.org/genproto/googleapis/api/distribution \
vendor/google.golang.org/genproto/googleapis/api/expr/v1alpha1 \
vendor/google.golang.org/genproto/googleapis/api/expr/v1beta1 \
vendor/google.golang.org/genproto/googleapis/api/httpbody \
vendor/google.golang.org/genproto/googleapis/api/label \
vendor/google.golang.org/genproto/googleapis/api/metric \
vendor/google.golang.org/genproto/googleapis/api/monitoredres \
vendor/google.golang.org/genproto/googleapis/api/serviceconfig \
vendor/google.golang.org/genproto/googleapis/api/servicecontrol/v1 \
vendor/google.golang.org/genproto/googleapis/api/servicemanagement/v1 \
vendor/google.golang.org/genproto/googleapis/iam/admin/v1 \
vendor/google.golang.org/genproto/googleapis/iam/credentials/v1 \
vendor/google.golang.org/genproto/googleapis/iam/v1 \
vendor/google.golang.org/genproto/googleapis/iam/v1/logging \
vendor/google.golang.org/genproto/googleapis/logging/type \
vendor/google.golang.org/genproto/googleapis/logging/v2 \
vendor/google.golang.org/genproto/googleapis/rpc/code \
vendor/google.golang.org/genproto/googleapis/rpc/errdetails \
vendor/google.golang.org/genproto/googleapis/rpc/status \
vendor/google.golang.org/genproto/googleapis/type/calendarperiod \
vendor/google.golang.org/genproto/googleapis/type/color \
vendor/google.golang.org/genproto/googleapis/type/date \
vendor/google.golang.org/genproto/googleapis/type/dayofweek \
vendor/google.golang.org/genproto/googleapis/type/expr \
vendor/google.golang.org/genproto/googleapis/type/fraction \
vendor/google.golang.org/genproto/googleapis/type/latlng \
vendor/google.golang.org/genproto/googleapis/type/money \
vendor/google.golang.org/genproto/googleapis/type/postaladdress \
vendor/google.golang.org/genproto/googleapis/type/quaternion \
vendor/google.golang.org/genproto/googleapis/type/timeofday

# tag:go-specific
_COMMON_GOOGLE_APIS=None

# tag:go-specific
### @usage: USE_COMMON_GOOGLE_APIS([apis...])
###
### Use common-google-apis library set. Pass optional apis list to be used or use them all.
### This macro is properly handled for all languages including Go, where apis come in
## pregenerated form. In other languages apis are generated from sources in Arcadia.
macro USE_COMMON_GOOGLE_APIS(APIS...) {
    SET(_COMMON_GOOGLE_APIS ${pre=vendor/google.golang.org/genproto/googleapis/:APIS})
}

# tag:go-specific tag:proto
GO_PROTO_GEN_TOOL=$_TOOL_PROTOC_GEN_GO
GO_PROTO_GEN_PLUGINS=
GO_PROTO_PACKAGE_MAP=
GO_PROTO_OPTS=$_GO_PROTOC_PLUGIN_ARGS_BASE(go $GO_PROTO_GEN_TOOL MAP $GO_PROTO_PACKAGE_MAP PLUGINS $GO_PROTO_GEN_PLUGINS)
GO_PROTO_OUTS=

# tag:go-specific tag:proto
GO_PROTOBUF_IMPORTS=\
    ${GOSTD}/sync \
    ${GOSTD}/reflect \
    ${GOSTD}/fmt \
    ${GOSTD}/math \
    vendor/github.com/golang/protobuf/proto \
    vendor/google.golang.org/protobuf/types/descriptorpb \
    vendor/google.golang.org/protobuf/runtime/protoimpl \
    vendor/google.golang.org/protobuf/runtime/protoiface \
    vendor/google.golang.org/protobuf/reflect/protoreflect

# tag:go-specific tag:proto
GO_PROTOBUF_WELLKNOWN_TYPES=\
    vendor/google.golang.org/protobuf/types/known/anypb \
    vendor/google.golang.org/protobuf/types/known/apipb \
    vendor/google.golang.org/protobuf/types/known/durationpb \
    vendor/google.golang.org/protobuf/types/known/emptypb \
    vendor/google.golang.org/protobuf/types/known/fieldmaskpb \
    vendor/google.golang.org/protobuf/types/known/sourcecontextpb \
    vendor/google.golang.org/protobuf/types/known/structpb \
    vendor/google.golang.org/protobuf/types/known/timestamppb \
    vendor/google.golang.org/protobuf/types/known/typepb \
    vendor/google.golang.org/protobuf/types/known/wrapperspb

# tag:go-specific tag:proto
### @usage: GO_PROTO_PLUGIN(Name Ext Tool [DEPS dependencies...])
###
### Define protoc plugin for GO with given Name that emits extra output with provided extension
### Ext using Tool. Extra dependencies are passed via DEPS.
macro GO_PROTO_PLUGIN(NAME, EXT, TOOL, DEPS[]) {
    SET_APPEND(GO_PROTO_OPTS $_PROTO_PLUGIN_ARGS_BASE($NAME $TOOL))
    SET_APPEND(GO_PROTO_OUTS \${output;hide;noauto;norel;nopath;noext;suf=$EXT:File})
    PEERDIR(${DEPS})
}

# tag:go-specific tag:proto
macro _GO_PROTOC_PLUGIN_ARGS_BASE_IMPL(Name, Tool, PLUGINS...) {
    .CMD=--plugin=protoc-gen-${Name}=${tool:Tool} --${Name}_out=${join=|:PLUGINS}:${ARCADIA_BUILD_ROOT}/$PROTO_NAMESPACE
}

# tag:go-specific tag:proto
macro _GO_PROTOC_PLUGIN_ARGS_BASE_PROXY(Name, Tool, MAP[], PLUGINS[]) {
    .CMD=$_GO_PROTOC_PLUGIN_ARGS_BASE_IMPL($Name $Tool $MAP ${pre=plugins=:PLUGINS})
}

# tag:go-specific tag:proto
macro _GO_PROTOC_PLUGIN_ARGS_BASE(Name, Tool, MAP[], PLUGINS[]) {
    .CMD=$_GO_PROTOC_PLUGIN_ARGS_BASE_PROXY($Name $Tool MAP ${pre=M:MAP} PLUGINS ${join=|:PLUGINS})
}

# tag:go-specific tag:proto
GO_PROTO_CMDLINE=${cwd;rootdir;input:File} $YMAKE_PYTHON ${input:"build/scripts/go_proto_wrapper.py"} $GO_ARCADIA_PROJECT_PREFIX $GO_CONTRIB_PROJECT_PREFIX ./$PROTO_NAMESPACE $PROTOC -I=./$PROTO_NAMESPACE -I=$ARCADIA_ROOT/$PROTO_NAMESPACE ${pre=-I=:_PROTO__INCLUDE} -I=$ARCADIA_BUILD_ROOT -I=$PROTOBUF_PATH ${input;rootrel:File}

# tag:go-specific tag:proto
macro _GO_PROTO_CMD_IMPL(File, OPTS[], OUTS[]) {
    .CMD=$GO_PROTO_CMDLINE $OPTS $OUTS ${kv;hide:"p PB"} ${kv;hide:"pc yellow"}
    .PEERDIR=${GO_PROTOBUF_IMPORTS} ${GO_PROTOBUF_WELLKNOWN_TYPES}
    .ADDINCL=FOR proto contrib/libs/protobuf/src
}

# tag:go-specific tag:proto
macro _GO_PROTO_CMD(File) {
    .CMD=$_GO_PROTO_CMD_IMPL($File OPTS $GO_PROTO_OPTS OUTS $GO_PROTO_OUTS)
}

# tag:proto
### @usage: YP_PROTO_YSON(Files... OUT_OPTS Opts...)
###
### Generate .yson.go from .proto using yp/go/yson/internal/proto-yson-gen/cmd/proto-yson-gen
macro YP_PROTO_YSON(OUT_OPTS[], Files...) {
    .CMD=${cwd:BINDIR} $PROTOC --plugin=protoc-gen-custom=${tool:"yp/go/yson/internal/proto-yson-gen/cmd/proto-yson-gen"} -I=${ARCADIA_ROOT}/${PROTO_NAMESPACE} ${pre=-I=:_PROTO__INCLUDE} -I=${ARCADIA_ROOT} --custom_out="$OUT_OPTS paths=base_name:." --custom_opt="goroot=${GO_TOOLS_ROOT}" ${input:Files} ${output;hide;noauto;nopath;noext;suf=.yson.go:Files}
    .ADDINCL=FOR proto ${ARCADIA_ROOT}/${MODDIR} FOR proto ${ARCADIA_ROOT}/${GO_TEST_IMPORT_PATH} FOR proto yt ${ARCADIA_BUILD_ROOT}/yt FOR proto contrib/libs/protobuf/src
    .PEERDIR=$GOSTD/strings $GOSTD/fmt $GOSTD/errors $GOSTD/encoding/json library/go/core/xerrors yt/go/yson yt/go/yterrors yp/go/yson/ytypes contrib/libs/protobuf

}

_SEM_CPP_PROTO_CMD=target_proto_messages PRIVATE ${input:File} $CPP_PROTO_OUTS_SEM ${output;hide;suf=${OBJ_SUF}.pb.o:File} ${hide;tool:"contrib/tools/protoc/bin"} ${hide;tool:"contrib/tools/protoc/plugins/cpp_styleguide"} \
                   && set_global_flags COMMON_PROTOC_FLAGS \
                   && target_proto_outs --cpp_out=$ARCADIA_BUILD_ROOT/$PROTO_NAMESPACE $PROTOC_STYLEGUIDE_OUT \
                   && target_proto_addincls ./$PROTO_NAMESPACE $ARCADIA_ROOT/$PROTO_NAMESPACE ${_PROTO__INCLUDE} $ARCADIA_BUILD_ROOT $PROTOBUF_PATH

# tag:proto
macro _CPP_PROTO_CMD(File) {
    .CMD=$CPP_PROTO_CMDLINE $CPP_PROTO_OPTS $CPP_PROTO_OUTS ${kv;hide:"p PB"} ${kv;hide:"pc yellow"}
    .SEM=$_SEM_CPP_PROTO_CMD
    .PEERDIR=contrib/libs/protobuf
}

# tag:proto
macro _CPP_VANILLA_PROTO_CMD(File) {
    .CMD=$CPP_PROTO_CMDLINE $CPP_PROTO_OPTS $CPP_PROTO_OUTS ${kv;hide:"p PB"} ${kv;hide:"pc yellow"}
    .PEERDIR=contrib/libs/protobuf_std
}

# tag:proto
macro _CPP_EVLOG_CMD(File) {
    .CMD=$CPP_PROTO_CMDLINE $CPP_EV_OPTS $CPP_EV_OUTS ${kv;hide:"p EV"} ${kv;hide:"pc yellow"}
    .PEERDIR=library/cpp/eventlog contrib/libs/protobuf
}

# tag:proto
macro _CPP_PROTO_EVLOG_CMD(File) {
    # process .proto as .ev
    .CMD=$CPP_PROTO_CMDLINE $CPP_EV_OPTS $CPP_PROTO_OUTS ${kv;hide:"p PB"} ${kv;hide:"pc yellow"}
    .PEERDIR=library/cpp/eventlog contrib/libs/protobuf
}

# tag:proto
macro _CPP_CFGPROTO_CMD(File) {
    # keep extension in output just as in EV: this is hard-coded behaviour of protoc for non-.proto extensions
    .CMD=$CPP_PROTO_CMDLINE  --plugin=protoc-gen-config=${tool:"library/cpp/proto_config/plugin"} --config_out=$ARCADIA_BUILD_ROOT/$PROTO_NAMESPACE $CPP_EV_OUTS ${kv;hide:"p PB"} ${kv;hide:"pc yellow"}
    .PEERDIR=library/cpp/proto_config/codegen library/cpp/proto_config/protos contrib/libs/protobuf
}

# tag:proto
PY_PROTO_MYPY_ENABLED=yes
PY_PROTO_MYPY_PLUGIN_BASE=--plugin=protoc-gen-mypy=${tool:"contrib/python/mypy-protobuf/bin/protoc-gen-mypy"} --mypy_out=$ARCADIA_BUILD_ROOT/$PROTO_NAMESPACE

# tag:proto tag:python-specific
PY_PROTO_MYPY_SUFFIX=
PY_PROTO_MYPY_PLUGIN=
PY_PROTO_MYPY_PLUGIN_INTERNAL=

# tag:proto tag:python-specific
macro NO_MYPY() {
    DISABLE(PY_PROTO_MYPY_ENABLED)
}

# tag:proto tag:python-specific
macro _PY_PROTO_CMD_BASE(File, Suf, Args...) {
    .CMD=$PROTOC -I=./$PROTO_NAMESPACE -I=$ARCADIA_ROOT/$PROTO_NAMESPACE ${pre=-I=:_PROTO__INCLUDE} -I=$ARCADIA_BUILD_ROOT -I=$PROTOBUF_PATH --python_out=$ARCADIA_BUILD_ROOT/$PROTO_NAMESPACE ${input;rootrel:File} ${output;hide;noauto;norel;nopath;noext;suf=$Suf:File} ${kv;hide:"p PB"} ${kv;hide:"pc yellow"} $Args
}

# tag:proto tag:python-specific
macro _PY_PROTO_CMD(File) {
    .CMD=${cwd;rootdir;input:File} $_PY_PROTO_CMD_BASE($File _pb2.py $PY_PROTO_OPTS $PY_PROTO_OUTS $PY_PROTO_MYPY_PLUGIN)
}

# tag:proto tag:python-specific
macro _PY_PROTO_CMD_INTERNAL(File) {
    .CMD=${cwd;rootdir;input:File} $GEN_PY_PROTOS --suffixes $PY_PROTO_SUFFIXES $PY_PROTO_MYPY_SUFFIX -- $_PY_PROTO_CMD_BASE($File __int___pb2.py $PY_PROTO_OPTS $PY_PROTO_OUTS_INTERNAL ${hide;kv:"ext_out_name_for_${nopath;noext;suf=__int___pb2.py:File} ${nopath;noext;suf=_pb2.py:File}"} $PY_PROTO_MYPY_PLUGIN_INTERNAL)
}

# tag:proto tag:java-specific
JAVA_PROTO_RUNTIME=

# tag:proto tag:java-specific
### @usage: USE_JAVALITE()
### Use protobuf-javalite for Java
macro USE_JAVALITE() {
    SET(JAVA_PROTO_RUNTIME javalite)
}

# tag:proto tag:java-specific
JAVA_PROTO_RUNTIME_VERSION = 3.18.2
JAVA_PROTO_COMMON_VERSION = 1.12.0
when ($JAVA_PROTO_RUNTIME == "javalite") {
    _JAVA_PROTO_OUT_ARG=--java_out=lite:
    JAVA_PROTOBUF_PEERS=contrib/java/com/google/protobuf/protobuf-javalite/${JAVA_PROTO_RUNTIME_VERSION}
    JAVA_GRPC_STUB=contrib/java/io/grpc/grpc-stub/1.19.0
    JAVA_GRPC_PROTOBUF=contrib/java/io/grpc/grpc-protobuf/1.19.0
}
otherwise {
    _JAVA_PROTO_OUT_ARG=--java_out=
    JAVA_PROTOBUF_PEERS=contrib/java/com/google/protobuf/protobuf-java/${JAVA_PROTO_RUNTIME_VERSION}
    JAVA_GRPC_STUB=contrib/java/io/grpc/grpc-stub/1.26.0
    JAVA_GRPC_PROTOBUF=contrib/java/io/grpc/grpc-protobuf/1.26.0
}

# tag:proto tag:java-specific
macro _JAVA_PROTO_CMD(File) {
    .CMD=${cwd;rootdir;input:File} $YMAKE_PYTHON ${input:"build/scripts/tared_protoc.py"} --tar-output ${output;norel;nopath;noext;suf=.jsrc:File} --protoc-out-dir $ARCADIA_BUILD_ROOT/java_out $PROTOC -I=./$PROTO_NAMESPACE ${pre=-I=:_PROTO__INCLUDE} -I=$ARCADIA_ROOT $_JAVA_PROTO_OUT_ARG$ARCADIA_BUILD_ROOT/java_out ${input;rootrel:File} ${kv;hide:"p PB"} ${kv;hide:"pc yellow"} $JAVA_PROTO_ARGS
}


# tag:proto tag:perl-specific tag:deprecated
### @usage: XS_PROTO(InputProto Dir Outputs...) # deprecated
###
### Generate Perl code from protobuf.
### In order to use this macro one should predict all outputs protoc will emit from input_proto file and enlist those as outputs.
macro XS_PROTO(File, Dir, Outputs...) {
    .CMD=$PROTOC -I=${ARCADIA_ROOT}/${Dir} ${pre=-I=:_PROTO__INCLUDE} -I=${ARCADIA_ROOT} -I=${PROTOBUF_PATH} --perlxs_out=${BINDIR} ${input:File} ${hide;output:Outputs} ${output_include;hide;nopath;noext;suf=.pb.h:File}
    PEERDIR(${Dir})
    ADDINCL(${ARCADIA_BUILD_ROOT}/${Dir})
}

# tag:proto tag:fbs
### @usage: PROTO2FBS(InputProto)
###
### Produce flatbuf schema out of protobuf description.
macro PROTO2FBS(File) {
    .CMD=${cwd:BINDIR} ${tool:"contrib/tools/flatc"} -I . -I ${ARCADIA_ROOT} --proto ${input:File} ${output;hide;nopath;noext:File.fbs} ${kv;hide:"p FBS"} ${kv;hide:"pc yellow"}
}

# tag:proto tag:python-specific
when ($PY_PROTOS_FOR == "yes") {
    PEERDIR+=contrib/libs/protobuf/python
}

# tag:python-specific
macro _PY_EVLOG_CMD_BASE(File, Suf, Args...) {
    .CMD=$_PY_PROTO_CMD_BASE($File $Suf $Args)
    .PEERDIR=library/cpp/eventlog/proto
}

# tag:python-specific tag:proto
macro _PY_EVLOG_CMD(File) {
    .CMD=${cwd;rootdir;input:File} $_PY_EVLOG_CMD_BASE($File _ev_pb2.py)
}

# tag:python-specific tag:proto
macro _PY_EVLOG_CMD_INTERNAL(File) {
    .CMD=${cwd;rootdir;input:File} $GEN_PY_PROTOS --suffixes $PY_EVLOG_SUFFIXES -- $_PY_EVLOG_CMD_BASE($File __int___ev_pb2.py ${hide;kv:"ext_out_name_for_${nopath;noext;suf=__int___ev_pb2.py:File} ${nopath;noext;suf=_ev_pb2.py:File}"})
}

# tag:java-specific tag:proto
macro _JAVA_EVLOG_CMD(File) {
    .CMD=$COPY_CMD ${input:File} ${output;nopath;noext;norel;suf=_ev.proto:File} ${kv;hide:"p EV"} ${kv;hide:"pc yellow"}
    .PEERDIR=library/cpp/eventlog/proto
}

# tag:sanitize
RUN_NO_SANITIZE=$YMAKE_PYTHON ${input:"build/scripts/run_tool.py"} --

# tag:sanitize
when ($IS_CROSS_SANITIZE) {
    RUN_NO_SANITIZE=
}

YIELD=$YMAKE_PYTHON ${input:"build/scripts/yield_line.py"} -- ${BINDIR}/__args
XARGS=$YMAKE_PYTHON ${input:"build/scripts/xargs.py"} -- ${BINDIR}/__args

RESPFILE_CMD=$YMAKE_PYTHON ${input:"build/scripts/writer.py"}

FS_TOOLS=$YMAKE_PYTHON ${input:"build/scripts/fs_tools.py"}

COPY_CMD=$FS_TOOLS copy
LINK_OR_COPY_CMD=$FS_TOOLS link_or_copy
REMOVE_FILE=$FS_TOOLS remove
MOVE_FILE=$FS_TOOLS rename

# tag:allocator tag:windows-specific
MSVC_DYNAMICBASE=/DYNAMICBASE
when ($ALLOCATOR == "LF") {
    MSVC_DYNAMICBASE=/DYNAMICBASE:NO
}

# tag:sanitize
SANITIZER_CFLAGS=

# tag:proto tag:grpc
### @usage: GRPC()
###
### Emit GRPC code for all .proto files in a PROTO_LIBRARY.
### This works for all available PROTO_LIBRARY versions (C++, Python 2.x, Pyton 3.x, Java and Go).
macro GRPC() {
    # C++
    CPP_PROTO_PLUGIN2(grpc_cpp contrib/tools/protoc/plugins/grpc_cpp .grpc.pb.cc .grpc.pb.h DEPS contrib/libs/grpc)

    # Python
    PY_PROTO_PLUGIN(grpc_py _pb2_grpc.py contrib/tools/protoc/plugins/grpc_python DEPS contrib/libs/grpc/python contrib/libs/grpc)

    # Java
    JAVA_PROTO_PLUGIN(grpc_java contrib/tools/protoc/plugins/grpc_java DEPS $JAVA_GRPC_STUB $JAVA_GRPC_PROTOBUF)
}

# tag:fbs
FLATC_FLAGS_VALUE=
### @usage: FLATC_FLAGS(flags...)
###
### Add flags to flatc command line
macro FLATC_FLAGS(FLAGS...) {
    SET_APPEND(FLATC_FLAGS_VALUE $FLAGS)
}

# tag:fbs
_PY_FBS_DEPS=contrib/python/flatbuffers

# tag:fbs tag:internal
### @usage: FBS_TO_PYSRC(output_base_name fbs_files...) # internal
###
### Create a tar archive of .py files generated by flatc for Python. Output tar
### archive will have .fbs.pysrc extension. This .fbs.pysrc extension is specially
### processed when --add-flatbuf-result flag is specified on the command line
### for 'ya make ...' (tar archive is extracted to output directory).
macro FBS_TO_PYSRC(OUT_NAME, IN_FBS_FILES...) {
    .CMD=${cwd:ARCADIA_BUILD_ROOT} ${tool:"contrib/tools/flatc"} --python --gen-mutable ${FLATC_FLAGS_VALUE} ${pre=-I :_FLATC__INCLUDE} -o ${BINDIR} ${input:IN_FBS_FILES} && $YMAKE_PYTHON ${input:"build/scripts/tar_sources.py"} --exts .py --input $BINDIR --output ${output;noauto;tared:OUT_NAME.fbs.pysrc} ${kv;hide:"p FP"} ${kv;hide:"pc light-green"} ${kv;hide:"tared_kind nodir"}
}

# tag:fbs tag:go-specific
# Implicit dependencies of generated code for Go
_GO_FLATC_IMPORTS=\
    ${GOSTD}/strconv \
    vendor/github.com/google/flatbuffers/go

# tag:fbs tag:cpp-specific
macro _CPP_FLATC_CMD(SRC, SRCFLAGS...) {
    .CMD=${cwd:ARCADIA_BUILD_ROOT} $YMAKE_PYTHON ${input:"build/scripts/cpp_flatc_wrapper.py"} ${tool:"contrib/tools/flatc"} --no-warnings --cpp --keep-prefix --gen-mutable --schema -b --yandex-maps-iter --gen-object-api --filename-suffix .fbs ${FLATC_FLAGS_VALUE} ${pre=-I :_FLATC__INCLUDE} -o ${output;norel:SRC.h} ${output;hide;norel:SRC.cpp} ${input:SRC} ${output;hide;noext;norel:SRC.iter.fbs.h} ${output;noauto;hide;noext;norel:SRC.bfbs} ${kv;hide:"p FL"} ${kv;hide:"pc light-green"}
    .SEM=target_fbs_source PRIVATE ${input:SRC} ${pre=-I :_FLATC__INCLUDE} ${output;hide;norel:SRC.h} ${output;hide;norel:SRC.cpp} ${output;hide;noext;norel:SRC.iter.fbs.h} ${output;noauto;hide;noext;norel:SRC.bfbs} ${hide;tool:"contrib/tools/flatc/bin"} && set_global_flags FBS_CPP_FLAGS --no-warnings --cpp --keep-prefix --gen-mutable --schema -b --yandex-maps-iter --gen-object-api --filename-suffix .fbs ${FLATC_FLAGS_VALUE}
    .PEERDIR=contrib/libs/flatbuffers
}

# tag:fbs tag:cpp-specific
macro _CPP_FLATC64_CMD(SRC, SRCFLAGS...) {
    .CMD=${cwd:ARCADIA_BUILD_ROOT} $YMAKE_PYTHON ${input:"build/scripts/cpp_flatc_wrapper.py"} ${tool:"contrib/tools/flatc64"} --no-warnings --cpp --keep-prefix --gen-mutable --schema -b --filename-suffix .fbs64 ${FLATC_FLAGS_VALUE} -I ${ARCADIA_ROOT} -I ${ARCADIA_BUILD_ROOT} -o ${output;norel:SRC.h} ${output;hide;norel:SRC.cpp} ${input:SRC} ${output;noauto;hide;noext;norel:SRC.bfbs64} ${kv;hide:"p FL64"} ${kv;hide:"pc light-green"}
    .PEERDIR=contrib/libs/flatbuffers64
}

# tag:fbs tag:go-specific tag:internal
### @usage: _GO_FLATC_CMD(fbs_file flags...) # internal
###
### Create a tar archive of .go files generated by flatc for Go. Output tar archive
### will have .fbs.gosrc extension. This .fbs.gosrc is specially processed when
### --add-protobuf-result flag is specified on the command line for 'ya make ...'
### (tar archive is extracted to output directory).
macro _GO_FLATC_CMD(SRC, PACKAGE_NAME) {
    .CMD=${cwd:ARCADIA_BUILD_ROOT} ${tool:"contrib/tools/flatc"} --go --gen-mutable --go-namespace ${PACKAGE_NAME} ${FLATC_FLAGS_VALUE} ${pre=-I :_FLATC__INCLUDE} -o ${BINDIR}/_generated ${input:SRC} && $YMAKE_PYTHON ${input:"build/scripts/postprocess_go_fbs.py"} --input-dir ${BINDIR} --map $_FBS_NAMESPACE_MAP_GLOBAL && $YMAKE_PYTHON ${input:"build/scripts/tar_sources.py"} --flat --input ${BINDIR}/_generated --output ${output;noext;tared:SRC.fbs.gosrc} --exts .go ${kv;hide:"p FG"} ${kv;hide:"pc light-green"} ${kv;hide:"tared_kind nodir"}
    .PEERDIR=${_GO_FLATC_IMPORTS}
}

# tag:fbs tag:java-specific tag:internal
### @usage: _JAVA_FLATC_CMD(fbs_file) # internal
###
### Create a tar archive of .java files generated by flatc for Java. Output tar
### acrchive will have .fbs.jsrc extension. Files with .fbs.jsrc extension will
### be added to results when --add-flatbuf-result flag is specified on the command
### line for 'ya make ...'
macro _JAVA_FLATC_CMD(SRC) {
    .CMD=${cwd:ARCADIA_BUILD_ROOT} ${tool:"contrib/tools/flatc"} --java --gen-mutable ${FLATC_FLAGS_VALUE} ${pre=-I :_FLATC__INCLUDE} -o ${BINDIR} ${input:SRC} && $YMAKE_PYTHON ${input:"build/scripts/tar_sources.py"} --input $BINDIR --output ${output;nopath;noext:SRC.fbs.jsrc} --exts .java ${kv;hide:"p FJ"} ${kv;hide:"pc light-green"}
    .PEERDIR=contrib/java/com/google/flatbuffers/flatbuffers-java/${JAVA_FLATBUFFERS_VERSION}
}

# variables must be defined for all module types to make generate_mf.py work
MODULE_PREFIX=
MODULE_SUFFIX=
NEED_PLATFORM_PEERDIRS=yes
PEERDIR_TEST_TOOL=yes

# tag:python-specific
PYTHON2=no
PYTHON3=no

# tag:python-specific
when (!$ARCADIA_PYTHON_UNICODE_SIZE) {
    when ($OS_WINDOWS) {
        ARCADIA_PYTHON_UNICODE_SIZE=2
    }
    otherwise {
        ARCADIA_PYTHON_UNICODE_SIZE=4
    }
}

### @usage: _BARE_UNIT  # internal
###
### The base of all modules describing default bare minimum for all modules.
### To avoid surprises, all buildable modules are better to be inherited from it or its descendants.
module _BARE_UNIT {
    .EXTS=.*
    .CMD=TOUCH_UNIT
    .IGNORED=GO_PROTO_PLUGIN
    .NODE_TYPE=Bundle
    .PEERDIR_POLICY=as_include
    .RESTRICTED=GRPC USE_SKIFF INDUCED_DEPS FUZZ_DICTS FUZZ_OPTS PACK DOCS_DIR DOCS_CONFIG DOCS_VARS YT_SPEC USE_CXX USE_UTIL WHOLE_ARCHIVE PRIMARY_OUTPUT SECONDARY_OUTPUT DEPENDENCY_MANAGEMENT EXCLUDE NO_DOCTESTS EMBED_JAVA_VCS_INFO RESOURCE_FILES PACK_GLOBALS_IN_LIBRARY EXPOSE GLOBAL_DEPS
    .FINAL_TARGET=no

    PEERDIR_TAGS=__EMPTY__

    when ($FATAL_ERROR_MESSAGE && $FATAL_ERROR_MODULE != "yes") {
        PEERDIR+=build/conf_fatal_error
    }

    DEFAULT(MODULE_VERSION)
    DEFAULT(MODULE_PREFIX)
    DEFAULT(MODULE_SUFFIX)
}

### @usage: _BASE_UNIT  # internal
###
### The base of all LIBRARY/PROGRAM modules describing common logic for all modules.
### To avoid surprises, all buildable modules are better to be inherited from it or its descendants.
module _BASE_UNIT: _BARE_UNIT {
    .GLOBAL=_FBS_NAMESPACE_MAP

    PEERDIR_TAGS=CPP_PROTO CPP_FBS CPP_SSQLS CPP_IDL PY2 PY2_NATIVE YQL_UDF_STATIC __EMPTY__ DLL_LIB

    CPP_PROTO_CMDLINE=${cwd;rootdir;input:File} $PROTOC -I=./$PROTO_NAMESPACE -I=$ARCADIA_ROOT/$PROTO_NAMESPACE ${pre=-I=:_PROTO__INCLUDE} -I=$ARCADIA_BUILD_ROOT -I=$PROTOBUF_PATH --cpp_out=${CPP_PROTO_PLUGINS}$ARCADIA_BUILD_ROOT/$PROTO_NAMESPACE $PROTOC_STYLEGUIDE_OUT $PROTOC_PLUGIN_STYLEGUIDE ${input;rootrel:File}
    CPP_PROTO_OUTS+=${output;hide;norel;nopath;noext:File.pb.cc} ${output;main;hide;norel;nopath;noext:File.pb.h}
    CPP_PROTO_OUTS_SEM+=${output;main;hide;norel;nopath;noext:File.pb.h}
    CPP_EV_OUTS+=${output;hide;norel:File.pb.cc} ${output;hide;norel:File.pb.h}

    when ($PY_PROTOS_FOR == "yes") {
        MACRO_ALIAS(EVLOG_CMD _PY_EVLOG_CMD)
        MACRO_ALIAS(PROTO_CMD _PY_PROTO_CMD)
    }
    otherwise {
        MACRO_ALIAS(EVLOG_CMD _CPP_EVLOG_CMD)
        MACRO_ALIAS(FBS_CMD _CPP_FLATC_CMD)
        when ($BUILD_PROTO_AS_EVLOG == "yes") {
            MACRO_ALIAS(PROTO_CMD _CPP_PROTO_EVLOG_CMD)
        }
        otherwise {
            MACRO_ALIAS(PROTO_CMD _CPP_PROTO_CMD)
        }
        when ($USE_VANILLA_PROTOC == "yes") {
            PROTOC=${tool:"contrib/tools/protoc_std"}
            PROTOC_STYLEGUIDE_OUT=
            PROTOC_PLUGIN_STYLEGUIDE=
            PROTOBUF_PATH=${ARCADIA_ROOT}/contrib/libs/protobuf_std
            MACRO_ALIAS(PROTO_CMD _CPP_VANILLA_PROTO_CMD)
        }
        when ($PROTOC_TRANSITIVE_HEADERS == "no") {
            CPP_PROTO_PLUGINS=transitive_pb_h=false:${CPP_PROTO_PLUGINS}
        }
    }

    SANITIZER_DEFINED=no

    when ($SANITIZER_TYPE && $SANITIZER_TYPE != "no") {
        CFLAGS+=-fsanitize=$SANITIZER_TYPE -D${SANITIZER_TYPE}_sanitizer_enabled $SANITIZER_CFLAGS -fno-omit-frame-pointer
        LDFLAGS+=-fsanitize=$SANITIZER_TYPE
        SANITIZER_DEFINED=yes

        when ($CLANG) {
            CFLAGS+=-fsanitize-blacklist=${input:"build/sanitize-blacklist.txt"}
            LDFLAGS+=-fsanitize-blacklist=${input:"build/sanitize-blacklist.txt"}
        }
    }

    when ($SANITIZE_COVERAGE && $SANITIZE_COVERAGE != "no") {
        CFLAGS+=-fsanitize-coverage=$SANITIZE_COVERAGE
        LDFLAGS+=-fsanitize-coverage=$SANITIZE_COVERAGE
    }

    when ($CLANG_COVERAGE && $CLANG_COVERAGE != "no") {
        CFLAGS+=-fprofile-instr-generate -fcoverage-mapping -DCLANG_COVERAGE
        LDFLAGS+=-fprofile-instr-generate -fcoverage-mapping
    }

    when ($NLG_COVERAGE && $NLG_COVERAGE != "no") {
        CFLAGS+=-DNLG_COVERAGE
    }

    when ($GCC) {
        select ($SANITIZER_TYPE) {
            "address" ? {
                LDFLAGS+=-static-libasan
            }
            "undefined" ? {
                LDFLAGS+=-static-libubsan
            }
            "thread" ? {
                PIE=yes
                LDFLAGS+=-static-libtsan
            }
        }
    }

    when ($HARDENING == "yes") {
        when ($CLANG) {
            CFLAGS+=-fstack-protector-all -D_hardening_enabled_
            LDFLAGS+=-z relro -z now -z noexecstack
            PIE=yes
        }
    }

    when ($USE_LTO == "yes") {
        when ($GCC) {
            CFLAGS+=-flto -fno-fat-lto-objects
            LDFLAGS+=-flto
            NO_LTO_CFLAGS=-fno-lto
        }
        when ($CLANG) {
            CFLAGS+=-flto
            LDFLAGS+=-flto
            NO_LTO_CFLAGS=-fno-lto
        }
    }

    when ($USE_THINLTO == "yes") {
        when ($GCC) {
            CFLAGS+=-flto=thin
            LDFLAGS+=-flto=thin
            NO_LTO_CFLAGS=-fno-lto
        }
        when ($CLANG) {
            CFLAGS+=-flto=thin
            LDFLAGS+=-flto=thin
            NO_LTO_CFLAGS=-fno-lto
        }
    }


    when ($CLANG) {
        when ($PGO_ADD == "yes") {
            CFLAGS+=-fprofile-instr-generate
            LDFLAGS+=-fprofile-instr-generate
        }
        when ($PGO_PATH) {
            CFLAGS+=-fprofile-instr-use=$PGO_PATH -Wno-profile-instr-unprofiled -Wno-profile-instr-out-of-date
            LDFLAGS+=-fprofile-instr-use=$PGO_PATH
        }
    }

    when ($COMPILER_PLATFORM && $NEED_PLATFORM_PEERDIRS == "yes") {
        PEERDIR+=$COMPILER_PLATFORM
    }

    when ($OS_LINUX && $NEED_PLATFORM_PEERDIRS == "yes") {
        PEERDIR+=contrib/libs/linux-headers
    }

    # Adding PEERDIR from trigger doesn't always work. In this case it
    # cause troubles in contrib/libs/libc_compat/ubuntu_14 under musl
    # Workaround this issue by setting variable with PEERDIR in trigger
    # and then adding PEERDIR to it's value	unconditionally.
    when ($USE_UBUNTU_COMPATIBILITY == "yes" && $NEED_PLATFORM_PEERDIRS == "yes") {
        _UBUNTU_COMPAT_PEERDIR=contrib/libs/libc_compat/ubuntu_14
    }
    otherwise {
        _UBUNTU_COMPAT_PEERDIR=
    }
    PEERDIR+=$_UBUNTU_COMPAT_PEERDIR

    when ($NORUNTIME != "yes") {
        PEERDIR+=contrib/libs/cxxsupp
        when ($MAPSMOBI_BUILD_TARGET == "yes") {
            PEERDIR+=build/platform/mapkit
        }
    }

    when ($NOUTIL != "yes") {
        PEERDIR+=util
    }

    when ($MUSL == "yes") {
        CFLAGS += -D_musl_
        LINK_DYN_LIB_FLAGS += --musl
        LINK_SCRIPT_EXE_FLAGS += --musl
        PEERDIR+=contrib/libs/musl/include
    }

    # g++ has proxy C-headers which are incompatible with libc++ proxy C-headers.
    # The same problem exists for clang toolchain. On the other hand, the problem
    # doesn't affect cl since it has united C/C++ library and doesn't need
    # proxy C-headers.
    # Disable all C++ headers including proxy C-headers when we use libc++.
    when ($USE_INTERNAL_STL == "yes" && $MSVC != "yes") {
        CXXFLAGS += -nostdinc++
    }
    otherwise {
        CFLAGS += -DUSE_STL_SYSTEM
    }

    when ($CODENAVIGATION && $NOCODENAVIGATION != "yes") {
        PEERDIR += build/external_resources/codenavigation
    }

    when ($CYTHON_COVERAGE && $CYTHON_COVERAGE == "yes") {
        CFLAGS+=-DCYTHON_TRACE=1 -DCYTHON_TRACE_NOGIL=1
    }

    DEFAULT(USE_SSE4 yes)

    when ($NOSSE != "yes") {
       CFLAGS+=$SSE_CFLAGS
       C_DEFINES+=$SSE_DEFINES
       when ($USE_SSE4 == "yes") {
           CFLAGS+=$SSE4_CFLAGS
           C_DEFINES+=$SSE4_DEFINES
       }
    }
    elsewhen ($MSVC != "yes") {
        CFLAGS += -mno-sse
    }

    when ($LIPO == "yes" && $NEED_PLATFORM_PEERDIRS != "no") {
        when ($OS_DARWIN == "yes" || $OS_IOS == "yes") {
            PEERDIR += build/platform/cctools
        }
    }

    _REGISTER_NO_CHECK_IMPORTS()

    DEFAULT(PACKAGE_PREFIX_ARGS)

    DEFAULT(BYACC_FLAGS -v)
    DEFAULT(SWIG_LANG python)
    DEFAULT(BISON_FLAGS -v)
    DEFAULT(GP_FLAGS -CtTLANSI-C -Dk* -c)

    when ($NEED_BINUTILS_PEERDIR && $BINUTILS_USED && $NEED_PLATFORM_PEERDIRS == "yes") {
        PEERDIR+=build/platform/binutils
    }
}

_LINKER_ID=
# GCC does not support -fuse-ld with an executable path, only
# -fuse-ld=bfd or -fuse-ld=gold (or -fuse-ld=lld in later versions).
when ($_LINKER_ID != "" && $_DEFAULT_LINKER_ID != "" && $CLANG == "yes" && $NEED_PLATFORM_PEERDIRS == "yes") {
    when ($_LINKER_ID in [ "bfd", "gold", "lld" ]) {
        PEERDIR+=build/platform/${_LINKER_ID}
    }
}

macro _USE_LINKER_IMPL(LINKER_ID...) {
    SET(_LINKER_ID $LINKER_ID)
}

macro _USE_LINKER() {
    _USE_LINKER_IMPL($_DEFAULT_LINKER_ID)
}

### @usage: USE_LINKER_BFD()
### Use bfd linker for a program. This doesn't work in libraries
macro USE_LINKER_BFD() {
    _USE_LINKER_IMPL(bfd)
}
### @usage: USE_LINKER_GOLD()
### Use gold linker for a program. This doesn't work in libraries
macro USE_LINKER_GOLD() {
    _USE_LINKER_IMPL(gold)
}
### @usage: USE_LINKER_LLD()
### Use lld linker for a program. This doesn't work in libraries
macro USE_LINKER_LLD() {
    _USE_LINKER_IMPL(lld)
}

COMMON_LINK_SETTINGS=
LINK_ADDITIONAL_SECTIONS=
LINK_ADDITIONAL_SECTIONS_COMMAND=

when ($COMMON_LINK_SETTINGS == "yes") {
    when ($_LINKER_ID == "lld" || $_LINKER_ID == "gold") {
         LDFLAGS += -Wl,--gdb-index
    }

    when ($EMBED_LINKER_CREF == "yes") {
        LDFLAGS+=-Wl,--cref ${tmp;stdout;pre=$MODULE_PREFIX;suf=.ldcref:REALPRJNAME} -Wl,--no-demangle
        LINK_ADDITIONAL_SECTIONS+=--add-section=.ya.linker_cref=${tmp;pre=$MODULE_PREFIX;suf=.ldcref:REALPRJNAME}
    }
    elsewhen ($DUMP_LINKER_CREF == "yes") {
        LDFLAGS+=-Wl,--cref ${output;stdout;pre=$MODULE_PREFIX;suf=.ldcref:REALPRJNAME} -Wl,--no-demangle
    }

    when ($EMBED_LINKER_MAP == "yes") {
        LDFLAGS+=-Wl,-Map=${tmp;pre=$MODULE_PREFIX;suf=.map.$_LINKER_ID:REALPRJNAME}
        LINK_ADDITIONAL_SECTIONS+=--add-section=.ya.linker_map.${_LINKER_ID}=${tmp;pre=$MODULE_PREFIX;suf=.map.$_LINKER_ID:REALPRJNAME}
    }
    elsewhen ($DUMP_LINKER_MAP == "yes") {
        LDFLAGS+=-Wl,-Map=${output;rootrel;pre=$MODULE_PREFIX;suf=.map.$_LINKER_ID:REALPRJNAME}
    }

    when ($USE_MKL == "yes") {
        NOPLATFORM=yes
    }

    when (($USE_EAT_MY_DATA == "yes") && ($WIN32 != "yes") && ($DARWIN != "yes") && ($OS_ANDROID != "yes") && ($OS_IOS != "yes")) {
        PEERDIR+=contrib/libs/libeatmydata/autocheck_wrapper
    }

    when ($USE_ARCADIA_LIBM == "yes") {
        PEERDIR+=contrib/libs/libm
    }
    when ($USE_ARCADIA_LIBM == "no") {
        C_SYSTEM_LIBRARIES+=-lm
    }

    when (($MUSL != "yes" && $WITH_VALGRIND == "yes") || $SANITIZER_DEFINED == "yes") {
        when ($ALLOCATOR in [ "TCMALLOC", "TCMALLOC_SMALL_BUT_SLOW", "TCMALLOC_NUMA_256K", "TCMALLOC_NUMA_LARGE_PAGES", "TCMALLOC_256K", "GOOGLE", "J", "LF", "LF_YT", "LF_DBG", "B", "BM", "C", "LOCKLESS", "YT", "MIM", "HU" ]) {
            PEERDIR+=library/cpp/malloc/system
        }
    }
    otherwise {
        select ($ALLOCATOR) {
            "MIM" ? {
                PEERDIR+=library/cpp/malloc/mimalloc
            }
            "HU" ? {
                PEERDIR+=library/cpp/malloc/hu
            }
            "TCMALLOC_256K" ? {
                PEERDIR+=library/cpp/malloc/tcmalloc
                PEERDIR+=contrib/libs/tcmalloc
            }
            "TCMALLOC_SMALL_BUT_SLOW" ? {
                PEERDIR+=library/cpp/malloc/tcmalloc
                PEERDIR+=contrib/libs/tcmalloc/small_but_slow
            }
            "TCMALLOC_NUMA_256K" ? {
                PEERDIR+=library/cpp/malloc/tcmalloc
                PEERDIR+=contrib/libs/tcmalloc/numa_256k
            }
            "TCMALLOC_NUMA_LARGE_PAGES" ? {
                PEERDIR+=library/cpp/malloc/tcmalloc
                PEERDIR+=contrib/libs/tcmalloc/numa_large_pages
            }
            "TCMALLOC" ? {
                PEERDIR+=library/cpp/malloc/tcmalloc
                PEERDIR+=contrib/libs/tcmalloc/default
            }
            "GOOGLE" ? {
                PEERDIR+=library/cpp/malloc/galloc
            }
            "J" ? {
                when ($WIN32 == "yes") {
                    PEERDIR+=library/cpp/malloc/system
                }
                otherwise {
                    PEERDIR+=library/cpp/malloc/jemalloc
                }
            }
            "LF" ? {
                PEERDIR+=library/cpp/lfalloc
            }
            "LF_YT" ? {
                PEERDIR+=library/cpp/lfalloc/yt
            }
            "LF_DBG" ? {
                PEERDIR+=library/cpp/lfalloc/dbg
            }
            "B" ? {
                PEERDIR+=library/cpp/balloc
            }
            "BM" ? {
                PEERDIR+=library/cpp/balloc_market
            }
            "C" ? {
                PEERDIR+=library/cpp/malloc/calloc
            }
            "LOCKLESS" ? {
                PEERDIR+=library/cpp/malloc/lockless
            }
            "YT" ? {
                PEERDIR+=library/cpp/ytalloc/impl
            }
        }
    }

    when ($ALLOCATOR == "SYSTEM") {
        PEERDIR+=library/cpp/malloc/system
    }
    when ($WERROR != "no") {
        when ($WERROR_MODE == "all" || ($WERROR_MODE == "compiler_specific" && $WERROR == "yes")) {
            C_WARNING_OPTS += $WERROR_FLAG
        }
    }

    when ($ICC == "yes") {
        PEERDIR+=contrib/libs/intel/core
    }
    when ($WITH_VALGRIND == "yes") {
        PEERDIR+=contrib/libs/valgrind
    }
}

when ($EMBED_LINKER_MAP == "yes" || $EMBED_LINKER_CREF == "yes") {
    LINK_ADDITIONAL_SECTIONS_COMMAND+= \
        $OBJCOPY_TOOL $LINK_ADDITIONAL_SECTIONS $TARGET
}

_SO_EXT_FILTER=${ext=.so:PEERS} ${hide;late_out;nopath;ext=.so;pre=$BINDIR/:PEERS}
when ($OS_WINDOWS == "yes") {
    _SO_EXT_FILTER=${ext=.dll:PEERS} ${hide;late_out;nopath;ext=.dll;pre=$BINDIR/:PEERS}
}
elsewhen ($OS_DARWIN == "yes" || $OS_IOS == "yes") {
    _SO_EXT_FILTER=${ext=.dylib:PEERS} ${hide;late_out;nopath;ext=.dylib;pre=$BINDIR/:PEERS}
}

LINK_OR_COPY_SO_CMD=
when ($SO_OUTPUTS == "yes") {
    LINK_OR_COPY_SO_CMD=$FS_TOOLS link_or_copy_to_dir --no-check $_SO_EXT_FILTER ${BINDIR}
    LDFLAGS+=$RPATH_GLOBAL
}

# tag:restricted tag:DLL
### $usage: WITH_DYNAMIC_LIBS() # restricted
###
### Include dynamic libraries as extra PROGRAM/DLL outputs
macro WITH_DYNAMIC_LIBS() {
    ENABLE(SO_OUTPUTS)
}

# tag:internal
### $usage: REAL_LINK_EXE_IMPL(peers...) # internal
macro REAL_LINK_EXE_IMPL(WHOLE_ARCHIVE_PEERS...) {
    .CMD=$REAL_LINK_EXE_CMDLINE && $LINK_OR_COPY_SO_CMD
}

# tag:internal
### $usage: REAL_LINK_EXEC_DYN_LIB_IMPL(peers...) # internal
macro REAL_LINK_EXEC_DYN_LIB_IMPL(WHOLE_ARCHIVE_PEERS...) {
    .CMD=$REAL_LINK_EXEC_DYN_LIB_CMDLINE
}

# tag:internal
### $usage: REAL_LINK_DYN_LIB_IMPL(peers...) # internal
macro REAL_LINK_DYN_LIB_IMPL(WHOLE_ARCHIVE_PEERS...) {
    .CMD=$REAL_LINK_DYN_LIB_CMDLINE && $LINK_OR_COPY_SO_CMD
}

# tag:internal
### $usage: LINK_EXE_IMPL(peers...) # internal
macro LINK_EXE_IMPL(WHOLE_ARCHIVE_PEERS...) {
    .CMD=$LINK_EXE_CMDLINE && $LINK_OR_COPY_SO_CMD
}

# tag:internal
### $usage: LINK_EXEC_DYN_LIB_IMPL(peers...) # internal
macro LINK_EXEC_DYN_LIB_IMPL(WHOLE_ARCHIVE_PEERS...) {
    .CMD=$LINK_EXEC_DYN_LIB_CMDLINE
}

# tag:internal
### @usage: _LINK_UNIT  # internal
###
### The base of all linkable modules: programs, DLLs etc. Describes common linking logic.
module _LINK_UNIT: _BASE_UNIT {
    .EXTS=.o .obj .supp .tidyjson .ld
    .CMD=LINK_EXE
    .ALLOWED=EXTRALIBS OBJADDE_GLOBAL RESOURCE_FILES
    .NODE_TYPE=Program
    .PEERDIR_POLICY=as_build_from
    .FINAL_TARGET=yes
    .DEFAULT_NAME_GENERATOR=DirName
    .ARGS_PARSER=Base

    DEFAULT(ALLOCATOR $DEFAULT_ALLOCATOR)
    _USE_LINKER()

    #link with libunwind manually
    when ($DARWIN == "yes" && $NOPLATFORM != "yes") {
        PEERDIR += contrib/libs/cxxsupp
    }

    when ($USE_LIBCXXRT == "yes") {
        PEERDIR += contrib/libs/cxxsupp/libcxxrt
    }

    ENABLE(COMMON_LINK_SETTINGS)
    CHECK_PROVIDES()
}

MODULE_TYPE=UNKNOWN

macro ADD_CLANG_TIDY() {
    ADD_YTEST($MODULE_PREFIX$REALPRJNAME clang_tidy)
    SET_APPEND(_MAKEFILE_INCLUDE_LIKE_DEPS ${ARCADIA_ROOT}/build/yandex_specific/config/clang_tidy/tidy_project_map.json)
    SET_APPEND(_MAKEFILE_INCLUDE_LIKE_DEPS ${ARCADIA_ROOT}/build/yandex_specific/config/clang_tidy/tidy_default_map.json)
}

# tag:internal
### @usage: _BASE_PROGRAM  # internal
###
### The base of all programs. It adds dependencies to make final artefact complete and runnable.
module _BASE_PROGRAM: _LINK_UNIT {
    .SYMLINK_POLICY=EXE
    .ALLOWED=INDUCED_DEPS WHOLE_ARCHIVE
    .GLOBAL=LDFLAGS _WHOLE_ARCHIVE_LIBS_VALUE RPATH
    SET(MODULE_TYPE PROGRAM)

    when ($OS_IOS == "yes") {
        EXTS+=.ios.interface
    }

    when ($WIN32 == "yes" || $OS_CYGWIN == "yes") {
        MODULE_SUFFIX=.exe
    }

    when ($TIDY == "yes") {
        MODULE_SUFFIX=.tidyjson
    }

    when ($MSVC != "yes" && $NOPLATFORM != "yes" && $WITH_VALGRIND != "yes" && $USE_ASMLIB != "no" && $MIC_ARCH != "yes" && $PIC != "yes" && $PIE != "yes") {
        PEERDIR+=contrib/libs/asmlib
    }

    when ($MUSL == "yes") {
        when ($MUSL_LITE == "yes") {
            PEERDIR += contrib/libs/musl
        }
        otherwise {
            PEERDIR += contrib/libs/musl/full
        }
    }

    when ($USE_DYNAMIC_CUDA == "yes") {
        LINK_SCRIPT_EXE_FLAGS += --dynamic-cuda
    }

    DEFAULT(CPU_CHECK yes)
    when ($USE_SSE4 != "yes" || $NOUTIL == "yes" || $ALLOCATOR == "FAKE") {
        CPU_CHECK = no
    }

    when ($CPU_CHECK == "yes") {
        PEERDIR += library/cpp/cpuid_check
    }

    when ($USE_ARC_PROFILE == "yes" && $NOUTIL != "yes") {
        PEERDIR += library/cpp/execprofile/autostart
    }

    when ($SANITIZER_DEFINED == "yes") {
        PEERDIR += contrib/libs/cxxsupp/libsan
    }

    when ($CLANG_COVERAGE && $CLANG_COVERAGE != "no") {
        PEERDIR+=library/cpp/testing/dump_clang_coverage
    }

    when ($IDE_MSVS == "yes") {
        PEERDIR+=build/scripts/c_templates
    }

    when ($_CUSTOM_LINK_STEP_SCRIPT) {
        LINK_SCRIPT_EXE_FLAGS+=--python=$YMAKE_PYTHON --custom-step=${input:_CUSTOM_LINK_STEP_SCRIPT}
    }
}

CPP_PROGRAM_SEM=add_executable $MODDIR $CMAKE_TARGET_NAME ${hide:TARGET} ${hide:AUTO_INPUT} $CMAKE_TARGET_ARTEFACT_RENAME_RULES \
                && vcs_info \
                && target_link_options PRIVATE $LDFLAGS $OBJADDE_LIB $OBJADDE \
                && target_include_directories PRIVATE $_C__INCLUDE_OWNED \
                && target_compile_options PRIVATE $USER_CFLAGS $USER_CXXFLAGS
### @usage: PROGRAM([progname])
###
### Regular program module.
### If name is not specified it will be generated from the name of the containing project directory.
module PROGRAM: _BASE_PROGRAM {
    .SEM=CPP_PROGRAM_SEM

    ADD_YTEST($MODULE_PREFIX$REALPRJNAME coverage.extractor)
    ADD_CLANG_TIDY()
    SET(MODULE_LANG CPP)
}

# tag:python-specific tag:deprecated tag:internal
module _PY2_PROGRAM: _BASE_PY_PROGRAM {
    SET(MODULE_LANG PY2)

    # Looks like we cannot avoid copy-paste util ymake supports multiple inheritance
    # We need to attach coverage.extractor to every py_program target, except pytest targets
    ADD_YTEST($MODULE_PREFIX$REALPRJNAME coverage.extractor)
}

# tag:python-specific tag:deprecated
### @usage: PY2_PROGRAM([progname]) # deprecated
###
### Deprecated. Use PY3_PROGRAM instead.
### Python 2.x binary program. Links all Python 2.x libraries and Python 2.x interpreter into itself to form regular executable.
### If name is not specified it will be generated from the name of the containing project directory.
### This only compatible with PYTHON2-tagged modules and selects those from multimodules.
###
### Documentation: https://wiki.yandex-team.ru/devtools/commandsandvars/py_srcs/
module PY2_PROGRAM: _PY2_PROGRAM {
    .RESTRICTED=STYLE_PYTHON
    when ($FAIL_PY2 == "yes") {
        _OK=no
    }
    otherwise {
        PEERDIR+=build/rules/py2_deprecation
    }
    ASSERT(_OK You are using deprecated Python2-only code (PY2_PROGRAM). Please consider rewriting to Python 3.)
}

# tag:python-specific
### @usage: NO_EXTENDED_SOURCE_SEARCH()
###
### Prevent module using in extended python source search.
### Use the macro if module contains python2-only files (or other python sources which shouldn't be imported by python3 interpreter)
### which resides in the same directories with python 3 useful code. contrib/python/future is a example.
### Anyway, preferred way is to move such files into separate dir and don't use this macro at all.
###
### Also see: https://docs.yandex-team.ru/ya-make/manual/python/vars#y_python_extended_source_search for details
macro NO_EXTENDED_SOURCE_SEARCH() {
    SET(NO_EXTENDED_SOURCE_SEARCH yes)
}

# tag:python-specific
### @usage: PY3_PROGRAM([progname])
###
### Python 3.x binary program. Links all Python 3.x libraries and Python 3.x interpreter into itself to form regular executable.
### If name is not specified it will be generated from the name of the containing project directory.
### This only compatible with PYTHON3-tagged modules and selects those from multimodules.
###
### Documentation: https://wiki.yandex-team.ru/devtools/commandsandvars/py_srcs/
multimodule PY3_PROGRAM {
    module PY3_BIN: PY3_PROGRAM_BIN {
        .PEERDIRSELF=PY3_BIN_LIB
        .IGNORED=RESOURCE RESOURCE_FILES PEERDIR TASKLET_REG
        # Notify pybuild to skip almost all PY_SRCS arguments except MAIN
        ENABLE(PROCESS_PY_MAIN_ONLY)
        _PY_PROGRAM()
    }

    module PY3_BIN_LIB: PY3_LIBRARY {
        .IGNORED=RESTRICT_LICENSES
        # Notify pybuild to skip all python main function definitions
        ENABLE(IGNORE_PY_MAIN)
        _REQUIRE_EXPLICIT_LICENSE()
    }
}

# tag:ycr-specific
macro _YCR_GENERATE_CONFIGS_INTL(Package, App, Configs...) {
    .CMD=${tool:"maps/infra/yacare/scripts/make_configs"} $Package $App ${cwd:BINDIR} ${output;hide;pre=debian/$Package/:Configs}
}

# tag:ycr-specific
macro _YCR_GENERATE_CONFIGS(Package, App) {
    .CMD=$_YCR_GENERATE_CONFIGS_INTL($Package $App ${pre=etc/yandex/maps/yacare/:App.conf} ${pre=etc/template_generator/templates/etc/logrotate.d/:App} ${pre=etc/nginx/sites-available/:App.conf} ${pre=etc/syslog-ng/conf-available/:App.conf} ${pre=etc/template_generator/config.d/:App.yaml} ${pre=/juggler/checks-available/yacare_;suf=/MANIFEST.json:App} ${pre=etc/yandex/maps/roquefort/:App.conf} ${pre=usr/lib/yandex/maps/yacare/lua/init_worker.d/rate_limiter_:App.lua} ${pre=usr/lib/yandex/maps/yacare/lua/init_worker.d/tvm_:App.lua} ${pre=usr/lib/yandex/maps/yacare/lua/init.d/tvm_:App.lua} ${pre=etc/supervisor/conf-available/:App.conf} ${pre=etc/template_generator/templates/etc/yandex/unified_agent/conf.d/04_yacare_:App.yml})
}

# tag:ycr-specific
when ($TIDY=="yes") {
    YCR_LINK_EXE=$LINK_EXE
}
otherwise {
    YCR_LINK_EXE=$LINK_EXE && $_YCR_GENERATE_CONFIGS($MODULE_PREFIX$REALPRJNAME $MODULE_PREFIX$REALPRJNAME)
}

# tag:ycr-specific
### @usage: YCR_PROGRAM([progname])
###
### yacare-specific program module. Generates yacare configs in addition to producing the program.
### If name is not specified it will be generated from the name of the containing project directory.
module YCR_PROGRAM: PROGRAM {
    .CMD=YCR_LINK_EXE
}

# tag:ycr-specific tag:python-specific
macro _PYCR_GENERATE_CONFIGS_INTL(Package, App, Configs...) {
    .CMD=${tool:"maps/infra/pycare/scripts/make_configs"} $Package $App ${cwd:BINDIR} ${output;hide;pre=configs/:Configs}
}

# tag:ycr-specific tag:python-specific
macro _PYCR_GENERATE_CONFIGS(Package, App) {
    .CMD=$_PYCR_GENERATE_CONFIGS_INTL($Package $App ${pre=etc/nginx/sites-available/:App.conf} ${pre=etc/template_generator/templates/etc/logrotate.d/:App} ${pre=etc/syslog-ng/conf-available/:App.conf} ${pre=etc/yandex/maps/roquefort/:App.conf} ${pre=etc/template_generator/config.d/:App.yaml} ${pre=etc/supervisor/conf-available/:App.conf} ${pre=etc/template_generator/templates/etc/yandex/unified_agent/conf.d/04_pycare_:App.yml})
}

# tag:ycr-specific tag:python-specific
PYCR_LINK_EXE=$LINK_EXE && $_PYCR_GENERATE_CONFIGS($MODULE_PREFIX$REALPRJNAME $MODULE_PREFIX$REALPRJNAME)

# tag:ycr-specific tag:python-specific
### @usage: PYCR_PROGRAM([progname])
###
### pycare-specific program module. Generates pycare configs in addition to producing the program.
### If name is not specified it will be generated from the name of the containing project directory.
module PYCR_PROGRAM: PY3_PROGRAM_BIN {
    .CMD=PYCR_LINK_EXE
}

### @usage: EXPORTS_SCRIPT(exports_file)
###
### Specify exports script within PROGRAM, DLL and DLL-derived modules.
### This accepts 2 kind of files: .exports with <lang symbol> pairs and JSON-line .symlist files.
### The other option use EXPORTS parameter of the DLL module itself.
###
### @see: [DLL](#module_DLL)
macro EXPORTS_SCRIPT(Arg) {
    SET(EXPORTS_FILE $Arg)
}

### @usage: NO_EXPORT_DYNAMIC_SYMBOLS()
###
### Disable exporting all non-hidden symbols as dynamic when linking a PROGRAM.
macro NO_EXPORT_DYNAMIC_SYMBOLS() {
    ENABLE(NO_EXPORT_DYNAMIC_SYMBOLS)
}

### @usage: EXPORT_ALL_DYNAMIC_SYMBOLS()
###
### Export all non-hidden symbols as dynamic when linking a PROGRAM.
macro EXPORT_ALL_DYNAMIC_SYMBOLS() {
    # Dummy: default behaviour
    ENABLE(EXPORT_ALL_DYNAMIC_SYMBOLS)
}

### @usage: USE_DYNAMIC_CUDA()
###
### Enable linking of PROGRAM with dynamic CUDA. By default CUDA uses static linking
macro USE_DYNAMIC_CUDA() {
    LDFLAGS(-Wl,-rpath,$ORIGIN)
    ENABLE(USE_DYNAMIC_CUDA)
}

### @usage: CUSTOM_LINK_STEP_SCRIPT(name)
###
### Specifies name of a script for custom link step. The scripts
### should be placed in the build/scripts directory and are subject to
### review by devtools@.
macro CUSTOM_LINK_STEP_SCRIPT(Name) {
    SET(_CUSTOM_LINK_STEP_SCRIPT build/scripts/$Name)
}

### @usage: _BASE_UNITTEST  # internal
###
### Module with base logic for all unit-test modules: it makes code runnable as unit-test by Arcadia testing machinery.
module _BASE_UNITTEST: _BASE_PROGRAM {
    .FINAL_TARGET=no
    .NODE_TYPE=Program
    .ALLOWED=YT_SPEC
    when ($UT_SKIP_EXCEPTIONS == "yes") {
        C_DEFINES+=-DUT_SKIP_EXCEPTIONS
    }
    SET_APPEND(_MAKEFILE_INCLUDE_LIKE_DEPS canondata/result.json)
}

UNITTEST_SEM=$CPP_PROGRAM_SEM && add_test NAME $REALPRJNAME COMMAND $REALPRJNAME --print-before-suite --print-before-test --fork-tests --print-times --show-fails
# tag:test
### @usage: UNITTEST([name])
###
### Unit test module based on library/cpp/testing/unittest.
### It is recommended not to specify the name.
###
### Documentation: https://wiki.yandex-team.ru/yatool/test/#opisanievya.make1
module UNITTEST: _BASE_UNITTEST {
    .SEM=UNITTEST_SEM
    .DEFAULT_NAME_GENERATOR=FullPath
    .ARGS_PARSER=Base
    PEERDIR(library/cpp/testing/unittest_main)
    ADD_YTEST($MODULE_PREFIX$REALPRJNAME unittest.py)
    SET(MODULE_LANG CPP)
}

# tag:yt-specific tag:test
### @usage: YT_UNITTEST([name])
###
### YT Unit test module based on mapreduce/yt/library/utlib
module YT_UNITTEST: _BASE_UNITTEST {
    PEERDIR(mapreduce/yt/library/utlib)
    ADD_YTEST($MODULE_PREFIX$REALPRJNAME unittest.py)
}

# tag:test
### @usage: UNITTEST_WITH_CUSTOM_ENTRY_POINT([name])
###
### Generic unit test module.
module UNITTEST_WITH_CUSTOM_ENTRY_POINT: _BASE_UNITTEST {
    ADD_YTEST($MODULE_PREFIX$REALPRJNAME unittest.py)
}

# tag:cpp-specific tag:test
### @usage: GTEST([name])
###
### Unit test module based on library/cpp/testing/gtest.
### It is recommended not to specify the name.
###
### Documentation: https://docs.yandex-team.ru/arcadia-cpp/cpp_test
module GTEST: _BASE_UNITTEST {
    .SEM=UNITTEST_SEM
    .DEFAULT_NAME_GENERATOR=FullPath
    .ARGS_PARSER=Base
    PEERDIR(library/cpp/testing/gtest library/cpp/testing/gtest_main)
    ADD_YTEST($MODULE_PREFIX$REALPRJNAME gunittest)
    SET(MODULE_LANG CPP)
}

USE_AFL=no

# tag:fuzzing
### @usage: FUZZ()
###
### In order to start using Fuzzing in Arcadia, you need to create a FUZZ module with the implementation of the function LLVMFuzzerTestOneInput().
### This module should be reachable by RECURSE from /autocheck project in order for the corpus to be regularly updated.
### AFL and Libfuzzer are supported in Arcadia via a single interface, but the automatic fuzzing still works only through Libfuzzer.
###
### Example: https://a.yandex-team.ru/arc/trunk/arcadia/contrib/libs/re2/re2/fuzzing/re2_fuzzer.cc?rev=2919463#L58
###
### Documentation: https://wiki.yandex-team.ru/yatool/fuzzing/
module FUZZ: _BASE_PROGRAM {
    .NODE_TYPE=Program
    .FINAL_TARGET=no
    .ALLOWED=FUZZ_DICTS FUZZ_OPTS

    DEFAULT(LIBFUZZER_PATH contrib/libs/libfuzzer12)
    when ($USE_AFL == "no") {
        PEERDIR+=$LIBFUZZER_PATH
    }
    when ($USE_AFL == "yes") {
        PEERDIR+=$LIBFUZZER_PATH/afl
    }

    when (!$SANITIZER_TYPE || $SANITIZER_TYPE == "no") {
        PEERDIR+=devtools/nofuzz
    }

    ADD_YTEST($MODULE_PREFIX$REALPRJNAME fuzz.test)
}

# tag:ios-specific
PACK_IOS_CMD=
when ($OS_IOS && $BUILD_IOS_APP) {
    PACK_IOS_CMD=$YMAKE_PYTHON ${input:"build/scripts/pack_ios.py"} --binary $TARGET --target $TARGET --temp-dir $BINDIR $PEERS
}

LINK_BOOSTTEST_CMD=
BOOST_TEST_TYPE_STRING=

when ($BOOSTTEST_IS_FAT_OBJECT) {
    LINK_BOOSTTEST_CMD=$LINK_RECURSIVE_LIBRARY
    BOOST_TEST_TYPE_STRING=no.test
}
otherwise {
    LINK_BOOSTTEST_CMD=$LINK_EXE
    BOOST_TEST_TYPE_STRING=boost.test
}

# tag:deprecated
### @usage: BOOSTTEST([name]) #deprecated
###
### Test module based on boost/test/unit_test.hpp.
### As with entire boost library usage of this technology is deprecated in Arcadia and restricted with configuration error in most of projects.
### No new module of this type should be introduced unless it is explicitly approved by C++ committee.
module BOOSTTEST: _BASE_PROGRAM {
    .NODE_TYPE=Program
    .FINAL_TARGET=no
    .CMD=LINK_BOOSTTEST_CMD
    PEERDIR(library/cpp/testing/boost_test)
    when ($BOOSTTEST_IS_FAT_OBJECT) {
        MODULE_SUFFIX=.a
    }
    elsewhen ($OS_IOS && $BUILD_IOS_APP) {
        PEERDIR+=devtools/boosttest_ios_wrapper/library
        MODULE_SUFFIX=.ios.tar
    }
    ADD_YTEST($MODULE_PREFIX$REALPRJNAME $BOOST_TEST_TYPE_STRING)
    SET_APPEND(_MAKEFILE_INCLUDE_LIKE_DEPS canondata/result.json)
}

# tag:deprecated
### @usage BOOSTTEST_WITH_MAIN([name]) #deprecated
###
### Same as BOOSTTEST (see above), but comes with builtin int main(argc, argv) implementation
module BOOSTTEST_WITH_MAIN: BOOSTTEST {
    PEERDIR(library/cpp/testing/boost_test_main)
}

FUZZ_DICTS_VALUE=
### @usage: FUZZ_DICTS(path1 [path2...])
###
### Allows you to specify dictionaries, relative to the root of Arcadia, which will be used in Fuzzing.
### Libfuzzer and AFL use a single syntax for dictionary descriptions.
### Should only be used in FUZZ modules.
###
### Documentation: https://wiki.yandex-team.ru/yatool/fuzzing/
macro FUZZ_DICTS(Data...) {
    SET_APPEND(FUZZ_DICTS_VALUE $Data)
}

FUZZ_OPTS_VALUE=
### @usage: FUZZ_OPTS(opt1 [Opt2...])
###
### Overrides or adds options to the corpus mining and fuzzer run.
### Currently supported only Libfuzzer, so you should use the options for it.
### Should only be used in FUZZ modules.
###
### @example:
###
###     FUZZ_OPTS (
###         -max_len=1024
###         -rss_limit_mb=8192
###     )
###
### Documentation: https://wiki.yandex-team.ru/yatool/fuzzing/
macro FUZZ_OPTS(Data...) {
    SET_APPEND(FUZZ_OPTS_VALUE $Data)
}

# tag:yt-specific tag:test
TEST_YT_SPEC_VALUE=
### @usage: YT_SPEC(path1 [path2...])
###
### Allows you to specify json-files with YT task and operation specs,
### which will be used to run test node in the YT.
### Test must be marked with ya:yt tag.
### Files must be relative to the root of Arcadia.
###
### Documentation: https://wiki.yandex-team.ru/yatool/test/
macro YT_SPEC(Data...) {
    SET_APPEND(TEST_YT_SPEC_VALUE $Data)
}

# tag:test
TEST_SRCS_VALUE=
### @usage: TEST_SRCS(Files...)
###
### In PY2TEST, PY3TEST and PY*_LIBRARY modules used as PY_SRCS macro and additionally used to mine test cases to be executed by testing framework.
###
### Documentation: https://wiki.yandex-team.ru/yatool/test/#testynapytest
macro TEST_SRCS(Tests...) {
    SET_APPEND(TEST_SRCS_VALUE $Tests)
}

macro DISABLE_DATA_VALIDATION() {
    DISABLE(VALIDATE_DATA)
}

# tag:test
TEST_DATA_VALUE=
### @usage: DATA([path...])
###
### Specifies the path to the data necessary test.
### Valid values are: arcadia/<path> , arcadia_tests_data/<path> and sbr://<resource_id>.
### In the latter case resource will be brought to the working directory of the test before it is started
###
### Used only inside TEST modules.
###
### Documentation: https://wiki.yandex-team.ru/yatool/test/#dannyeizrepozitorija
macro DATA(Data...) {
    SET_APPEND(TEST_DATA_VALUE $Data)
    ADD_CHECK(check.data $Data)
}

# tag:test
TEST_TAGS_VALUE=
### @usage: TAG ([tag...])
###
### Each test can have one or more tags used to filter tests list for running.
### There are also special tags affecting test behaviour, for example ya:external, sb:ssd.
###
### Documentation: https://wiki.yandex-team.ru/yatool/test/#obshhieponjatija
macro TAG(Tags...) {
    SET_APPEND(TEST_TAGS_VALUE $Tags)
}

# tag:test
TEST_REQUIREMENTS_VALUE=
### @usage: REQUIREMENTS([cpu:<count>] [disk_usage:<size>] [ram:<size>] [ram_disk:<size>] [container:<id>] [network:<restricted|full>] [dns:dns64])
###
### Allows you to specify the requirements of the test.
###
### Documentation about the Arcadia test system: https://wiki.yandex-team.ru/yatool/test/
macro REQUIREMENTS(Tags...) {
    SET_APPEND(TEST_REQUIREMENTS_VALUE $Tags)
}

# tag:test
TEST_ENV_VALUE=
### @usage: ENV(key[=value])
###
### Sets env variable key to value (gets value from system env by default).
macro ENV(Data...) {
    SET_APPEND(TEST_ENV_VALUE ${quo:Data})
}

### @usage: CONFTEST_LOAD_POLICY_LOCAL()
###
### Loads conftest.py files in a way that pytest does it
macro CONFTEST_LOAD_POLICY_LOCAL() {
    SET_APPEND(TEST_ENV_VALUE "CONFTEST_LOAD_POLICY=LOCAL")
}

# tag:test
TEST_RECIPES_VALUE=
### @usage: USE_RECIPE(path [arg1 arg2...])
###
### Provides prepared environment via recipe for test.
###
### Documentation: https://wiki.yandex-team.ru/yatool/test/recipes
macro USE_RECIPE(Data...) {
    SET_APPEND(TEST_RECIPES_VALUE $Data)
    SET_APPEND(TEST_RECIPES_VALUE "USE_RECIPE_DELIM")
}

# tag:python-specific tag:test
TEST_PYTHON_PATH_VALUE=

# tag:python-specific tag:test
### @usage: PYTHON_PATH(Path)
###
### Set path to Python that will be used to runs scripts in tests
macro PYTHON_PATH(Path) {
    SET(TEST_PYTHON_PATH_VALUE $Path)
}

# tag:test
SKIP_TEST_VALUE=
### @usage: SKIP_TEST(Reason)
###
### Skip the suite defined by test module. Provide a reason to be output in test execution report.
macro SKIP_TEST(Reason...) {
    SET(SKIP_TEST_VALUE $Reason)
}

# tag:test
LINT_LEVEL_VALUE=extended
### @usage: NO_LINT()
###
### Do not check for style files included in PY_SRCS, TEST_SRCS, JAVA_SRCS.
macro NO_LINT() {
    SET(LINT_LEVEL_VALUE none)
}

### @usage: LINT(<none|base|strict>)
###
### Set linting levem for sources of the module
macro LINT(level) {
    SET(LINT_LEVEL_VALUE $level)
}

# tag:python-specific tag:test
STYLE_PYTHON_VALUE=no
### @usage: STYLE_PYTHON()
###
### Check python3 sources for style issues using black.
macro STYLE_PYTHON() {
    SET(STYLE_PYTHON_VALUE yes)
}

# tag:python-specific tag:test
### @usage: NO_DOCTESTS()
###
### Disable doctests in PY[|3|23_]TEST
macro NO_DOCTESTS() {
    ENV(YA_PYTEST_DISABLE_DOCTEST="yes")
}

# tag:python-specific tag:test
### @usage: _BASE_PYTEST  # internal
###
### Base logic of Python 2.x py.test modules: common module properties and dependencies.
module _BASE_PYTEST: _BASE_PY_PROGRAM {
    .NODE_TYPE=Program
    .FINAL_TARGET=no
    .ALLOWED=YT_SPEC NO_DOCTESTS
    when ($USE_ARCADIA_PYTHON == "yes") {
        PEERDIR+=library/python/pytest
    }
    when ($USE_ARCADIA_PYTHON == "no") {
        MODULE_SUFFIX=.pkg.fake
        PEERDIR+=library/python/pytest/empty
    }

    SET_APPEND(_MAKEFILE_INCLUDE_LIKE_DEPS canondata/result.json)
}

# tag:python-specific tag:deprecated tag:test
### @usage: PYTEST_BIN() #deprecated
###
### Same as PY2TEST. Don't use this, use PY2TEST instead.
module PYTEST_BIN: _BASE_PYTEST {
    .NODE_TYPE=Program
    .DEFAULT_NAME_GENERATOR=FullPath
    .ARGS_PARSER=Base
    SETUP_PYTEST_BIN()
}

# tag:python-specific tag:test
### @usage: PY2TEST([name])
###
### The test module for Python 2.x based on py.test
###
### This module is compatible only with PYTHON2-tagged modules and selects peers from multimodules accordingly.
### This module is compatible with non-Arcadia Python builds.
###
### Documentation: https://wiki.yandex-team.ru/yatool/test/#python
### Documentation about the Arcadia test system: https://wiki.yandex-team.ru/yatool/test/
module PY2TEST: PYTEST_BIN {
    .RESTRICTED=STYLE_PYTHON
    .DEFAULT_NAME_GENERATOR=FullPath
    .ARGS_PARSER=Base
    when ($FAIL_PY2 == "yes") {
        _OK=no
    }
    otherwise {
        PEERDIR+=build/rules/py2_deprecation
    }
    SET(MODULE_LANG PY2)
    ASSERT(_OK You are using deprecated Python2-only code (PY2TEST). Please consider rewriting to Python 3.)
}

# tag:python-specific tag:deprecated tag:test
### @usage: PY3TEST_BIN() #deprecated
###
### Same as PY3TEST. Don't use this, use PY3TEST instead.
module PY3TEST_BIN: _BASE_PY3_PROGRAM {
    .NODE_TYPE=Program
    .FINAL_TARGET=no
    .ALLOWED=YT_SPEC NO_DOCTESTS
    .DEFAULT_NAME_GENERATOR=FullPath
    .ARGS_PARSER=Base
    SET_APPEND(_MAKEFILE_INCLUDE_LIKE_DEPS canondata/result.json)
    SET(MODULE_LANG PY3)
    SETUP_PYTEST_BIN()
    PEERDIR+=library/python/pytest
}

# tag:python-specific tag:test
### Disable submodules with the specified name(s).
### Unlike EXCLUDE_TAGS this variable:
### - affects all projects in the build;
### - filter by module name and ignore MODULE_TAG.
EXCLUDE_SUBMODULES=PY3TEST_LIBRARY

# tag:python-specific tag:test
### @usage: PY3TEST([name])
###
### The test module for Python 3.x based on py.test
###
### This module is compatible only with PYTHON3-tagged modules and selects peers from multimodules accordingly.
### This module is only compatible with Arcadia Python build (to avoid tests duplication from Python2/3-tests). For non-Arcadia python use PYTEST.
###
### Documentation: https://wiki.yandex-team.ru/yatool/test/#testynapytest
### Documentation about the Arcadia test system: https://wiki.yandex-team.ru/yatool/test/
multimodule PY3TEST {
    module PY3TEST_PROGRAM: PY3TEST_BIN {
        .FINAL_TARGET=yes
    }

    module PY3TEST_LIBRARY: PY3_LIBRARY {
        PEERDIR+=library/python/pytest
        _REQUIRE_EXPLICIT_LICENSE()
    }
}

# tag:cpp-specific tag:test
module CPP_STYLE_TEST: PY3TEST_BIN {
    DEPENDS(contrib/libs/clang12/tools/clang-format)
    PEERDIR+=library/python/cpp_test
}

macro STYLE(Globs...) {
    _GLOB(STYLE_SRCS_GLOB ${pre=${ARCADIA_ROOT}:Globs})
    _STYLE(${STYLE_SRCS_GLOB})
}

# tag:cpp-specific tag:deprecated tag:test
### @usage: GTEST_UGLY([name])
###
### Deprecated, do not use in new projects. Use GTEST instead.
###
### The test module based on gtest (contrib/libs/gtest contrib/libs/gmock).
### Use public documentation on gtest for details.
###
### Documentation about the Arcadia test system: https://wiki.yandex-team.ru/yatool/test/
module GTEST_UGLY: _BASE_PROGRAM {
    .NODE_TYPE=Program
    .FINAL_TARGET=no
    PEERDIR(contrib/restricted/googletest/googlemock contrib/restricted/googletest/googletest)
    ADD_YTEST($MODULE_PREFIX$REALPRJNAME gtest)
    SET_APPEND(_MAKEFILE_INCLUDE_LIKE_DEPS canondata/result.json)
}

# tag:test
### @usage: EXECTEST()
###
### Module definition of generic test that executes a binary.
### Use macro RUN to specify binary to run.
###
### @example:
###
###     EXECTEST()
###         OWNER(g:yatool)
###
###         RUN(
###             cat input.txt
###         )
###         DATA(
###             arcadia/devtools/ya/test/tests/exectest/data
###         )
###         DEPENDS(
###             devtools/dummy_arcadia/cat
###         )
###         TEST_CWD(devtools/ya/test/tests/exectest/data)
###     END()
###
### More examples: https://wiki.yandex-team.ru/yatool/test/#exec-testy
###
### @see: [RUN()](#macro_RUN)
module EXECTEST: _BARE_UNIT {
    .NODE_TYPE=Program
    .FINAL_TARGET=no
    .ALLOWED=YT_SPEC
    .RESTRICTED=FORK_TEST_FILES
    .DEFAULT_NAME_GENERATOR=FullPath
    .ARGS_PARSER=Base
    SET(MODULE_SUFFIX .pkg.fake)
    SETUP_EXECTEST()
    SET_APPEND(_MAKEFILE_INCLUDE_LIKE_DEPS canondata/result.json)
}

# tag:cpp-specific tag:test
### @usage: Y_BENCHMARK([benchmarkname])
###
### Benchmark test based on the library/cpp/testing/benchmark.
###
### For more details see: https://wiki.yandex-team.ru/yatool/test/#zapuskbenchmark
module Y_BENCHMARK: PROGRAM {
    .SEM=CPP_PROGRAM_SEM
    PEERDIR(library/cpp/testing/benchmark/main)
    SET(MODULE_LANG CPP)
}

# tag:cpp-specific tag:test
### @usage: G_BENCHMARK([benchmarkname])
###
### Benchmark test based on the google benchmark.
###
### For more details see: https://a.yandex-team.ru/arc/trunk/arcadia/contrib/libs/benchmark/README.md
module G_BENCHMARK: _BASE_PROGRAM {
    PEERDIR(library/cpp/testing/gbenchmark_main)
    ADD_YTEST($MODULE_PREFIX$REALPRJNAME g_benchmark)
    SET(MODULE_LANG CPP)
}

# tag:test
TEST_ROOT=$(TESTS_DATA_ROOT)
RESULT_MAX_FILE=0
STRIP_FILES=--dont-strip-files
VERIFY_RESULTS=--verify-results
ADDITIONAL_PATH=

# set for tests variables to fill it by YA_DEV or YA
YA_ROOT=ya
when ($YA_DEV == "yes") {
    YA_ROOT=ya-dev
}


# tag:test
### @usage: UNITTEST_FOR(path/to/lib)
###
### Convenience extension of UNITTEST module.
### The UNINTTEST module with additional SRCDIR + ADDINCL + PEERDIR on path/to/lib.
### path/to/lib is the path to the directory with the LIBRARY project.
###
### Documentation about the Arcadia test system: https://wiki.yandex-team.ru/yatool/test/
module UNITTEST_FOR: UNITTEST {
    .SEM=UNITTEST_SEM
    PEERDIR(ADDINCL $UNITTEST_DIR)
    SRCDIR($UNITTEST_DIR)
}

### @usage: _LIBRARY # internal
###
### Base module definition for all libraries.
### Contains basic logic like module properties, default variable values etc.
### All libraries similar to C++-libraries should be inherited from it.
module _LIBRARY: _BASE_UNIT {
    .CMD=LINK_LIB
    .NODE_TYPE=Library
    .PEERDIR_POLICY=as_include
    .EXTS=.o .obj .a .mf .supp .tidyjson .ld
    .ALLOWED=GRPC USE_SKIFF EXTRALIBS OBJADDE_GLOBAL RESOURCE_FILES
    .GLOBAL=USER_CFLAGS USER_CXXFLAGS USER_CONLYFLAGS LDFLAGS SRCS _WHOLE_ARCHIVE_LIBS_VALUE RPATH
    .RESTRICTED=ALLOCATOR SIZE TAG DATA TEST_DATA DEPENDS FORK_TESTS FORK_SUBTESTS SPLIT_FACTOR TEST_CWD RUN TIMEOUT SPLIT_DWARF
    .FINAL_TARGET=no
    .GLOBAL_CMD=GLOBAL_LINK_LIB
    .GLOBAL_EXTS=.o .obj .tidyjson

    GLOBAL_SUFFIX=.global$MODULE_SUFFIX
    #TODO: Remove this hack (really we do not need add fake src at all)
    ENABLE(NEED_ADD_FAKE_SRC)
    _REQUIRE_EXPLICIT_LICENSE(contrib/deprecated contrib/libs contrib/restricted contrib/python)
    CHECK_CONTRIB_CREDITS(contrib/clickhouse contrib/libs contrib/deprecated EXCEPT contrib/deprecated/python)

    when ($USE_MKL == "yes") {
        NOPLATFORM=yes
    }

    when ($MSVC == "yes" || $CYGWIN == "yes") {
        MODULE_PREFIX=
        MODULE_SUFFIX=.lib
    }
    otherwise {
        when ($TIDY == "yes") {
            MODULE_PREFIX=
            MODULE_SUFFIX=.tidyjson
        }
        otherwise {
            MODULE_PREFIX=lib
            MODULE_SUFFIX=.a
        }
    }

    when ($WERROR != "no") {
        when ($WERROR_MODE == "all" || ($WERROR_MODE == "compiler_specific" && $WERROR == "yes")) {
            C_WARNING_OPTS += $WERROR_FLAG
        }
    }

    when ($WITH_VALGRIND == "yes") {
        PEERDIR+=contrib/libs/valgrind
    }

    when ($USE_ARCADIA_LIBM == "yes") {
        PEERDIR+=contrib/libs/libm
    }
}

CPP_LIBRARY_SEM=add_library ${MODDIR} $CMAKE_TARGET_NAME ${hide:TARGET} ${hide:AUTO_INPUT} $CMAKE_TARGET_ARTEFACT_RENAME_RULES \
                && library_fake_marker FAKE_MODULE ${FAKE_MODULE} \
                && consumer_link_library PUBLIC $CMAKE_LINK_TARGET \
                && target_include_directories PUBLIC $_C__INCLUDE_GLOBAL \
                && target_include_directories PRIVATE $_C__INCLUDE_OWNED \
                && target_compile_options PRIVATE $USER_CFLAGS $USER_CXXFLAGS \
                && target_compile_options PUBLIC $USER_CFLAGS_GLOBAL_RAW $USER_CXXFLAGS_GLOBAL_RAW \
                && target_link_options INTERFACE $LDFLAGS_GLOBAL_RAW \
                && add_language C && add_language CXX
CPP_OBJ_LIBRARY_SEM=add_global_library_for ${MODDIR} ${suf=.global:CMAKE_TARGET_NAME} $CMAKE_TARGET_NAME ${hide:GLOBAL_TARGET} ${hide:AUTO_INPUT} \
                && target_include_directories PUBLIC $_C__INCLUDE_GLOBAL \
                && target_include_directories PRIVATE $_C__INCLUDE_OWNED \
                && target_compile_options PRIVATE $USER_CFLAGS $USER_CXXFLAGS \
                && target_compile_options PUBLIC $USER_CFLAGS_GLOBAL_RAW $USER_CXXFLAGS_GLOBAL_RAW

CMAKE_FIND_PKG=
CMAKE_LINK_TARGET=$REALPRJNAME
CMAKE_FIND_PKG_COMP=
CONAN_REQUIRE=

### @usage: LIBRARY()
###
### The regular static library module.
###
### The LIBRARY() is intermediate module, so when built directly it won't build its dependencies.
### It transitively provides its PEERDIRs to ultimate final target, where all LIBRARY() modules are built and linked together.
###
### This is C++ library, and it selects peers from multimodules accordingly.
###
### It makes little sense to mention LIBRARY in DEPENDS or BUNDLE, package and deploy it since it is not a standalone entity.
### In order to use library in tests PEERDIR it to link into tests.
### If you think you need to distribute static library please contact devtools@ for assistance.
module LIBRARY: _LIBRARY {
    .GLOBAL=_AARS _PROGUARD_RULES
    .SEM=CPP_LIBRARY_SEM
    .GLOBAL_SEM=CPP_OBJ_LIBRARY_SEM
    .DEFAULT_NAME_GENERATOR=ThreeDirNames
    .ARGS_PARSER=Base

    when ($CMAKE_PACKAGE_COMPONENT != "") {
        CMAKE_FIND_PKG_COMP=COMPONENTS $CMAKE_PACKAGE_COMPONENT
    }
    when ($CMAKE_PACKAGE != "") {
        CMAKE_FIND_PKG=find_package $CMAKE_PACKAGE $CMAKE_FIND_PKG_COMP
        CPP_LIBRARY_SEM=$CMAKE_FIND_PKG && consumer_link_library PUBLIC $CMAKE_LINK_TARGET $CONAN_REQUIRE $CONAN_OPTS_SEM && ignored
    }
    when ($CONAN_REFERENCE != "") {
        CONAN_REQUIRE=&& conan_require $CONAN_REFERENCE
        CPP_LIBRARY_SEM=$CMAKE_FIND_PKG && consumer_link_library PUBLIC $CMAKE_LINK_TARGET $CONAN_REQUIRE $CONAN_OPTS_SEM && ignored
    }
    when ($CONAN_PKG_OPTS != "") {
        CONAN_OPTS_SEM=&& conan_options $CONAN_PKG_OPTS
    }
    when ($OPENSOURCE_EXPORT == "no") {
        CPP_LIBRARY_SEM=ignored
    }

    when ($HAS_CPP_PROTOBUF_PEERS == "yes") {
        PEERDIR+=$CPP_PROTOBUF_PEERS
    }
    SET(MODULE_TYPE LIBRARY)
    SET(MODULE_LANG CPP)

    ADD_CLANG_TIDY()
}

# tag:internal
### @usage: _BARE_MODULE() # internal
###
### Remove unwanted dependencies for "empty" library module
macro _BARE_MODULE() {
    SET(NEED_PLATFORM_PEERDIRS no)
    SET(PEERDIR_TEST_TOOL no)
    DISABLE(WITH_VALGRIND)
    NO_CODENAVIGATION()
    NO_PLATFORM()
    NO_RUNTIME()
    NO_UTIL()
    NO_CLANG_TIDY()
}

# tag:internal
### @usage: _BARE_LINK_MODULE() # internal
###
### Remove unwanted dependencies for "empty" link module
macro _BARE_LINK_MODULE() {
    _BARE_MODULE()
    ALLOCATOR(FAKE)
}

# tag:internal
### @usage: _CONDITIONAL_SRCS([USE_CONDITIONAL_SRCS] Files...) # internal
###
### Adds Files... to SRCS if first word is `USE_CONDITIONAL_SRCS`
### To be used with some variable which is set to `USE_CONDITIONAL_SRCS` under condition
macro _CONDITIONAL_SRCS(USE_CONDITIONAL_SRCS[], DYMMY...) {
    SRCS($USE_CONDITIONAL_SRCS)
}

# XXX: dirty hack for correct LDFLAGS passing
RESOURCES_LIBRARY_LINK=$TOUCH_UNIT ${hide:LDFLAGS_GLOBAL} ${hide:LDFLAGS}
RESOURCES_LIBRARY_SEM=ignored

### @usage: RESOURCES_LIBRARY()
###
### Definition of a module that brings its content from external source (Sandbox) via DECLARE_EXTERNAL_RESOURCE macro.
### This can participate in PEERDIRs of others as library but it cannot have own sources and PEERDIRs.
###
### @see: [DECLARE_EXTERNAL_RESOURCE()](#macro_DECLARE_EXTERNAL_RESOURCE)
module RESOURCES_LIBRARY: _BARE_UNIT {
    .CMD=RESOURCES_LIBRARY_LINK
    .SEM=RESOURCES_LIBRARY_SEM
    .ALLOWED=DECLARE_EXTERNAL_RESOURCE EXTRALIBS OBJADDE_GLOBAL
    .RESTRICTED=ALLOCATOR SIZE TAG DATA TEST_DATA DEPENDS FORK_TESTS FORK_SUBTESTS SPLIT_FACTOR TEST_CWD RUN TIMEOUT SRC SRCS PEERDIR SPLIT_DWARF
    .NODE_TYPE=Library
    .PEERDIR_POLICY=as_include
    .EXTS=.o .obj .a .mf .supp .tidyjson .ld
    .GLOBAL=USER_CFLAGS USER_CXXFLAGS USER_CONLYFLAGS LDFLAGS _WHOLE_ARCHIVE_LIBS_VALUE RPATH

    MODULE_SUFFIX=.pkg.fake
    ENABLE(NEED_ADD_FAKE_SRC)
    WITHOUT_LICENSE_TEXTS()
}

FAT_OBJECT_ARGS=
FAT_OBJECT_OUTS=

macro _FAT_OBJECT_ARGS_BASE(Flag, Lib) {
    .CMD=$Flag=$Lib
}

macro PACK_GLOBALS_IN_LIBRARY() {
     SET_APPEND(FAT_OBJECT_ARGS $_FAT_OBJECT_ARGS_BASE(--globals-lib, ${BINDIR}/${pre=$MODULE_PREFIX:REALPRJNAME.globals.a}))
     SET_APPEND(FAT_OBJECT_OUTS \${output;hide;noauto;norel;nopath;noext;pre=$MODULE_PREFIX;suf=$BINDIR:REALPRJNAME.globals.a})
}

when ($OS_ANDROID != "yes") {
    LINK_FAT_OBJECT_CMD=$LINK_FAT_OBJECT
}
otherwise {
    LINK_FAT_OBJECT_CMD=$LINK_FAT_OBJECT_LIBRARY
}

FAT_OBJECT_SEM=add_fat_object ${MODDIR} ${CMAKE_TARGET_NAME} ${hide:TARGET} ${hide:AUTO_INPUT} ${CMAKE_TARGET_ARTEFACT_RENAME_RULES} \
    && target_include_directories PRIVATE $_C__INCLUDE_OWNED \
    && target_compile_options PRIVATE $USER_CFLAGS $USER_CXXFLAGS \
    && set_global_flags FAT_OBJECT_PREFIX ${MODULE_PREFIX} \
    && set_global_flags FAT_OBJECT_SUFFIX ${MODULE_SUFFIX}

### Do not turn visibility=hidden symbos into static symbos of partially linked object file
###
### Note: This variable do not have any effect on platforms other than MacOS and iOS.
KEEP_FAT_OBJECT_SYMBOLS=no

### @usage: FAT_OBJECT()
###
### The "fat" object module. It will contain all its transitive dependencies reachable by PEERDIRs:
### static libraries, local (from own SRCS) and global (from peers') object files.
###
### Designed for use in XCode projects for iOS.
module FAT_OBJECT: LIBRARY {
    .ALLOWED=PACK_GLOBALS_IN_LIBRARY
    .CMD=LINK_FAT_OBJECT_CMD
    .SEM=FAT_OBJECT_SEM
    .PEERDIR_POLICY=as_build_from

    when ($MSVC == "yes" || $CYGWIN == "yes") {
        MODULE_SUFFIX=.global.lib
    }
    elsewhen ($OS_ANDROID == "yes") {
        MODULE_SUFFIX=.a
    }
    otherwise {
        MODULE_SUFFIX=.o
    }

    when (($OS_DARWIN == "yes" || $OS_IOS == "yes") && $KEEP_FAT_OBJECT_SYMBOLS == "yes") {
        LDFLAGS_GLOBAL += -keep_private_externs
    }

    _USE_LINKER()

    # This module requires at least one .o which is not subject to removal so just add _fake_src.cpp as SRCS
    # ymake's handling of NEED_ADD_FAKE_SRC may insert arbitrary command, not necessarily compilation
    DISABLE(NEED_ADD_FAKE_SRC)
    SRCS(build/scripts/_fake_src.cpp)
}

### @usage: RECURSIVE_LIBRARY()
###
### The recursive ("fat") library module. It will contain all its transitive dependencies reachable by PEERDIRs:
### from static libraries, local (from own SRCS) and global (from peers') object files.
###
### Designed for use in XCode projects for iOS.
module RECURSIVE_LIBRARY: LIBRARY {
    .CMD=LINK_RECURSIVE_LIBRARY
    .PEERDIR_POLICY=as_build_from

    # This module requires at least one .o which is not subject to removal so just add _fake_src.cpp as SRCS
    # ymake's handling of NEED_ADD_FAKE_SRC may insert arbitrary command, not necessarily compilation
    DISABLE(NEED_ADD_FAKE_SRC)
    SRCS(build/scripts/_fake_src.cpp)
}

_SONAME=
_EXPORT_SCRIPT_SEM=
macro _ADD_DYNLYB_SEM(Libname) {
    .SEM=add_library ${MODDIR} ${Libname} SHARED ${hide:TARGET} ${hide:AUTO_INPUT} && target_include_directories PUBLIC $_C__INCLUDE_GLOBAL && target_include_directories PRIVATE $_C__INCLUDE_OWNED && target_compile_options PRIVATE $USER_CFLAGS $USER_CXXFLAGS && target_compile_options PUBLIC $USER_CFLAGS_GLOBAL_RAW $USER_CXXFLAGS_GLOBAL_RAW && vcs_info $_EXPORT_SCRIPT_SEM
}
CPP_DYN_LIBRARY_SEM=$_ADD_DYNLYB_SEM($CMAKE_TARGET_NAME) $CMAKE_TARGET_ARTEFACT_RENAME_RULES

### @usage: DLL_UNIT # internal
###
### Base module for all dynamically linked libraries as final artifacts.
### Contains all general logic for such kind of modules. Supports versioning and export files.
### Cannot participate in linking to programs, intended to be used as final artifact (packaged and deployed).
module DLL_UNIT: _LINK_UNIT {
    .CMD=LINK_DYN_LIB
    .SEM=CPP_DYN_LIBRARY_SEM
    .NODE_TYPE=Library
    .SYMLINK_POLICY=SO
    .GLOBAL=USER_CFLAGS USER_CXXFLAGS USER_CONLYFLAGS LDFLAGS _WHOLE_ARCHIVE_LIBS_VALUE RPATH
    .ALLOWED=WHOLE_ARCHIVE
    .DEFAULT_NAME_GENERATOR=TwoDirNames
    .ARGS_PARSER=DLL
    DYNAMIC_LINK=yes
    ALLOCATOR(FAKE)
    SET(MODULE_TYPE DLL)
    SET(MODULE_TAG DLL)
    SET(MODULE_LANG CPP)
    ADD_CLANG_TIDY()

    when ($EXPORTS_FILE) {
        _EXPORT_SCRIPT_SEM=&& use_export_script ${input:EXPORTS_FILE}
    }

    when ($MSVC == "yes" || $CYGWIN == "yes") {
        MODULE_SUFFIX=.dll
    }
    elsewhen ($DARWIN == "yes" || $OS_IOS == "yes") {
        MODULE_PREFIX=lib
        MODULE_SUFFIX=.dylib
    }
    elsewhen ($TIDY == "yes") {
        MODULE_PREFIX=
        MODULE_SUFFIX=.tidyjson
    }
    otherwise {
        MODULE_PREFIX=lib
        MODULE_SUFFIX=.so
    }

    # This by now replicates ymake's behavior. We'll get rid of SONAME setting in ymake and fix this code altogether
    SONAME=${pre=$MODULE_PREFIX;suf=$MODULE_SUFFIX:REALPRJNAME}
    when ($MODULE_VERSION) {
       LINK_DYN_LIB_FLAGS=--soname ${output;pre=$MODULE_PREFIX;suf=$MODULE_SUFFIX$MODULE_VERSION:REALPRJNAME}
    }
    _SONAME=$SONAME$MODULE_VERSION

    when ($LINUX == "yes") {
        # '-z notext' is needed for linking mkl into shared libraries
        LDFLAGS += -Wl,-z,notext
        when ($_NO_FIX_ELF != "yes") {
            LINK_DYN_LIB_FLAGS+=--fix-elf ${tool:"tools/fix_elf"}
        }
    }

    when ($DARWIN == "yes") {
        LDFLAGS += -undefined dynamic_lookup
    }

    when ($CLANG_COVERAGE && $CLANG_COVERAGE != "no") {
        PEERDIR+=library/cpp/testing/dump_clang_coverage
    }

    when ($IDE_MSVS == "yes") {
        PEERDIR+=build/scripts/c_templates
    }
}

# tag:python-specific
### @usage: PY_ANY_MODULE(name major_ver [minor_ver] [EXPORTS symlist_file] [PREFIX prefix])
###
### The Python external module for any versio of Arcadia or system Python.
### 1. major_ver and minor_ver must be integers.
### 2. The resulting .so will have the prefix "lib".
### 3. Processing EXPORTS and PREFIX is the same as for DLL module
### This is native DLL, so it will select C++ version from PROTO_LIBRARY.
###
### Note: Use PYTHON2_MODULE()/PYTHON3_MODULE() in order to PEERDIR proper version of PY23_NATIVE_LIBRARY.
### Do not PEERDIR any PY*_LIBRARY: this will link Python in and render artifact unusable as Python module.
###
### Documentation: https://wiki.yandex-team.ru/devtools/commandsandvars/py_srcs/
module PY_ANY_MODULE: DLL_UNIT {
    .SEM=CPP_DYN_LIBRARY_SEM
    when ($MSVC != "yes" && $DARWIN != "yes") {
        LDFLAGS+= -Wl,-Bsymbolic
    }

    when ($USE_ARCADIA_PYTHON == "no") {
        when ($USE_SYSTEM_PYTHON) {
            PEERDIR+=build/platform/python
        }
        otherwise {
            when ($MSVC == "yes" || $CYGWIN == "yes") {
                LDFLAGS+=$PYTHON_LIBRARIES
            }
        }
    }

    # This by now replicates ymake's behavior. We'll get rid of SONAME setting in ymake and fix this code altogether
    SONAME=${pre=$MODULE_PREFIX;suf=$MODULE_SUFFIX:REALPRJNAME}
    when ($MODULE_VERSION) {
       LINK_DYN_LIB_FLAGS=--soname ${output;pre=$MODULE_PREFIX;suf=$MODULE_SUFFIX$MODULE_VERSION:REALPRJNAME}
    }
    _SONAME=$SONAME$MODULE_VERSION

    # -bundle
    when ($DARWIN == "yes") {
        LDFLAGS+=-flat_namespace
    }

    when ($MSVC == "yes" || $CYGWIN == "yes") {
        MODULE_PREFIX=
        MODULE_SUFFIX=.pyd
    }
    otherwise {
        MODULE_PREFIX=
        MODULE_SUFFIX=.so
    }
    .RESTRICTED=USE_PYTHON2 USE_PYTHON3 PY_SRCS PY_MAIN
}

# tag:python-specific
### @usage: PY2MODULE(name major_ver [minor_ver] [EXPORTS symlist_file] [PREFIX prefix])
###
### The Python external module for Python2 and any system Python
### 1. major_ver and minor_ver must be integers.
### 2. The resulting .so will have the prefix "lib".
### 3. Processing EXPORTS and PREFIX is the same as for DLL module
### This is native DLL, so it will select C++ version from PROTO_LIBRARY.
###
### Note: this module will always PEERDIR Python2 version of PY23_NATIVE_LIBRARY.
### Do not PEERDIR PY2_LIBRARY or PY23_LIBRARY: this will link Python in and render artifact unusable as Python module.
###
### Documentation: https://wiki.yandex-team.ru/devtools/commandsandvars/py_srcs/
module PY2MODULE: PY_ANY_MODULE {
    PYTHON2_MODULE()
    SET(MODULE_LANG PY2)
    .RESTRICTED=PYTHON3_MODULE PYTHON3_ADDINCL
}

# tag:python-specific
### @usage: PY3MODULE(name major_ver [minor_ver] [EXPORTS symlist_file] [PREFIX prefix])
###
### The Python external module for Python3 and any system Python
### 1. major_ver and minor_ver must be integers.
### 2. The resulting .so will have the prefix "lib".
### 3. Processing EXPORTS and PREFIX is the same as for DLL module
### This is native DLL, so it will select C++ version from PROTO_LIBRARY.
###
### Note: this module will always PEERDIR Python3 version of PY23_NATIVE_LIBRARY.
### Do not PEERDIR PY3_LIBRARY or PY23_LIBRARY: this will link Python in and render artifact unusable as Python module.
###
### Documentation: https://wiki.yandex-team.ru/devtools/commandsandvars/py_srcs/
module PY3MODULE: PY_ANY_MODULE {
    PYTHON3_MODULE()
    SET(MODULE_LANG PY3)
    .RESTRICTED=PYTHON2_MODULE PYTHON2_ADDINCL
}

# tag:python-specific
### @usage: PYTHON2_MODULE()
###
### Use in PY_ANY_MODULE to set it up for Python 2.x.
macro PYTHON2_MODULE() {
    when ($USE_ARCADIA_PYTHON == "yes" && $MSVC == "yes" || $IS_CROSS_TOOLS == "yes") {
        PEERDIR+=contrib/tools/python/lib
    }

    PYTHON2_ADDINCL()
}

# tag:python-specific
### @usage: PYTHON3_MODULE()
###
### Use in PY_ANY_MODULE to set it up for Python 3.x.
macro PYTHON3_MODULE() {
    when ($USE_ARCADIA_PYTHON == "yes" && $MSVC == "yes" || $IS_CROSS_TOOLS == "yes") {
        PEERDIR+=contrib/tools/python3/lib
    }

    PYTHON3_ADDINCL()
}

# tag:r-specific
### @usage: R_MODULE(name major_ver [minor_ver] [EXPORTS symlist_file] [PREFIX prefix])
###
### The external module for R language.
### 1. major_ver and minor_ver must be integers.
### 2. The resulting .so will have the prefix "lib".
### 3. Processing EXPORTS and PREFIX is the same as for DLL module
### This is native DLL, so it will select C++ version from PROTO_LIBRARY.
module R_MODULE: DLL_UNIT {
    .SEM=CPP_DYN_LIBRARY_SEM
    when ($DARWIN == "yes") {
        LDFLAGS+=-flat_namespace -dynamiclib
    }

    when ($MSVC == "yes" || $CYGWIN == "yes") {
        MODULE_PREFIX=lib
        MODULE_SUFFIX=.dll
    }

    ADDINCL(contrib/libs/r-lang)
}

### @usage: DYNAMIC_LIBRARY_FROM(Paths)
###
### Use specified libraries as sources of DLL
macro DYNAMIC_LIBRARY_FROM(Path...) {
    PEERDIR($Path)
    WHOLE_ARCHIVE($Path)
}


### @usage: DLL(name major_ver [minor_ver] [EXPORTS symlist_file] [PREFIX prefix])
###
### Dynamic library module definition.
### 1. major_ver and minor_ver must be integers.
### 2. EXPORTS allows you to explicitly specify the list of exported functions. This accepts 2 kind of files: .exports with <lang symbol> pairs and JSON-line .symlist files
### 3. PREFIX allows you to change the prefix of the output file (default DLL has the prefix "lib").
###
### DLL cannot participate in linking to programs but can be used from Java or as final artifact (packaged and deployed).
module DLL: DLL_UNIT {
    .SEM=CPP_DYN_LIBRARY_SEM
    SET(MAKE_ONLY_SHARED_LIB yes)
    SET(MODULE_LANG CPP)
    when ($OS_WINDOWS) {
        MODULE_SUFFIX=.dll
    }

    # TODO: Make it possible to use this syntax
    # DEFAULT(DLL_FOR_DIR no)
    ### FIXME: XXX
    ###when ($DLL_FOR_DIR != "no") {
    ###    SRCDIR($DLL_FOR_DIR)
    ###    ADDINCL($DLL_FOR_DIR)
    ###}
}

### DLL_TOOL is a DLL that can be used as a LD_PRELOAD tool.
module DLL_TOOL: DLL {
    .SEM=CPP_DYN_LIBRARY_SEM
    # ymake resolves only program nodes as tools.
    .NODE_TYPE=Program
}

### @usage: SO_PROGRAM(name major_ver [minor_ver] [EXPORTS symlist_file] [PREFIX prefix])
###
### Executable dynamic library module definition.
### 1. major_ver and minor_ver must be integers.
### 2. EXPORTS allows you to explicitly specify the list of exported functions. This accepts 2 kind of files: .exports with <lang symbol> pairs and JSON-line .symlist files
### 3. PREFIX allows you to change the prefix of the output file.
module SO_PROGRAM: DLL {
    .CMD=LINK_EXEC_DYN_LIB
    SET(MODULE_TYPE PROGRAM)

    MODULE_PREFIX=
    when ($MSVC == "yes" || $CYGWIN == "yes") {
        MODULE_SUFFIX=.exe
    }
    otherwise {
        MODULE_SUFFIX=
    }
}

DLL_PROXY_CMD_MF=$GENERATE_MF && $COPY_CMD $AUTO_INPUT $TARGET

# tag:internal
### @usage: DEV_DLL_PROXY() # internal
###
### The use of this module is strictly prohibited!!!
### This is a temporary and project-specific solution.
module DEV_DLL_PROXY: _BARE_UNIT {
    .NODE_TYPE=Library
    .EXTS=.so .dll .dylib .mf
    .CMD=DLL_PROXY_CMD_MF
    DYNAMIC_LINK=yes

    when ($OS_WINDOWS == "yes") {
        MODULE_SUFFIX=.dll
    }
    elsewhen ($DARWIN == "yes" || $OS_IOS == "yes") {
        MODULE_PREFIX=lib
        MODULE_SUFFIX=.dylib$MODULE_VERSION
    }
    otherwise {
        MODULE_PREFIX=lib
        MODULE_SUFFIX=.so$MODULE_VERSION
    }
}

# tag:internal
### @usage: DLL_PROXY() # internal
###
### The use of this module is strictly prohibited!!!
### This is a temporary and project-specific solution.
module DLL_PROXY: DEV_DLL_PROXY {
    .EXTS=.so .dylib .lib .mf
    .PROXY=yes
    .PEERDIR_POLICY=as_build_from
    SET(PEERDIR_TAGS DLL __EMPTY__)

    when ($OS_WINDOWS == "yes") {
        MODULE_SUFFIX=.lib
    }
}

# tag:internal
### @usage: DYNAMIC_DEPS(Path...) # internal, temporary
###
### Enlist paths to all DYNAMIC_LIBRARY dependencies of the DYNAMIC_LIBRARY
### This it needed to transfer their outputs through the library to PROGRAM
### or dependent DLL/DYNAMIC_LIBRARY.
###
### Note: this is temporary solution until support of `super-global` variables come
###       which will enable transfer of some properties though final targets like DLLs.
macro DYNAMIC_DEPS(Path...) {
     # PEERDIR as macro completely ignored in place where this macro applies
     SET_APPEND(PEERDIR $Path)
}

# tag:internal
### @usage: DYNAMIC_LIBRARY() # internal
###
### The use of this module is strictly prohibited except LGPL-related opensourcing
### This provides linkable DLL module which brings its results to programs and tests
### for seamless testing and packaging
multimodule DYNAMIC_LIBRARY {
    module DLL_BIN: DLL {
        .PROXY=yes
        .IGNORED=PROVIDES
        SET(MODULE_TAG DLL)
    }
    module DLL_LIB: _DLL_COMPATIBLE_LIBRARY {
        .CMD=TOUCH_UNIT_MF
        .PEERDIRSELF=DLL_BIN
        .IGNORED=SRCS PEERDIR RUN_PROGRAM PYTHON DYNAMIC_LIBRARY_FROM GENERATE_ENUM_SERIALIZATION GENERATE_ENUM_SERIALIZATION_WITH_HEADER USE_PYTHON2 USE_PYTHON3
        .ALLOWED=DYNAMIC_DEPS

        SET(PEERDIR_TAGS DLL_LIB __EMPTY__)

        _BARE_MODULE()
        DYNAMIC_LINK=yes
        MODULE_SUFFIX=.pkg.fake
        PEERDIR+=build/platform/local_so

        RESTRICT_PATH(contrib devtools/dummy_arcadia MSG Use of this module type outside contrib/libs is prohibited)

        # disable credits generation for static library
        SET(CREDITS_FLAGS)
    }
}

### @usage: GLOBAL_SRCS(filenames...)
###
### Make all source files listed as GLOBAL.
### Call to GLOBAL_SRCS macro is equivalent to call to SRCS macro when each source file is marked with GLOBAL keyword.
### Arcadia root relative or project dir relative paths are supported for filenames arguments. GLOBAL keyword is not
### recognized for GLOBAL_SRCS in contrast to SRCS macro.
###
### @example:
### Consider the file to ya.make:
###
###     LIBRARY()
###         GLOBAL_SRCS(foo.cpp bar.cpp)
###     END()
###
### @see: [SRCS()](#macro_SRCS)
macro GLOBAL_SRCS(Files...) {
    SRCS(${pre=GLOBAL :Files})
}

### @usage: ALL_SRCS([GLOBAL] filenames...)
###
### Make all source files listed as GLOBAL or not depending on the keyword GLOBAL
### Call to ALL_SRCS macro is equivalent to call to GLOBAL_SRCS macro when GLOBAL keyword is specified
### as the first argument and is equivalent to call to SRCS macro otherwise.
###
### @example:
###
###     LIBRARY()
###         SET(MAKE_IT_GLOBAL GLOBAL)
###         ALL_SRCS(${MAKE_IT_GLOBAL} foo.cpp bar.cpp)
###     END()
###
### @see: [GLOBAL_SRCS()](#macro_GLOBAL_SRCS), [SRCS()](#macro_SRCS)
macro ALL_SRCS(GLOBAL?"GLOBAL":"", Files...) {
    SRCS(${pre=$GLOBAL :Files})
}

### @usage: _DLL_COMPATIBLE_LIBRARY # internal
###
### Base module to place DLLs into multimodules back to back with libraries.
### In order to function properly all modules in multimodule shall have the
### same set of arguments. So this module is just library that accepts but
### ignores all DLL arguments.
module _DLL_COMPATIBLE_LIBRARY: LIBRARY {
    .DEFAULT_NAME_GENERATOR=TwoDirNames
    .ARGS_PARSER=DLL
}

@import "${CONF_ROOT}/conf/project_specific/yql_udf.conf"

# as SRCS in packages use macro BUNDLE_SRCS!

PACKED_PACKAGE_ARGS=
PACKED_PACKAGE_EXT=
### @usage: PACK(archive_type)
###
### When placed inside the PACKAGE module, packs the build results tree to the archive with specified extension. Currently supported extensions are `tar` and `tar.gz`
###
### Is not allowed other module types than PACKAGE().
###
### @see: [PACKAGE()](#module_PACKAGE)
macro PACK(Ext) {
    SET(PACKED_PACKAGE_EXT $Ext)
}

PACKAGE_STRICT_VALUE=
macro PACKAGE_STRICT() {
    SET(PACKAGE_STRICT_VALUE yes)
}

### @usage: PACKAGE(name)
###
### Module collects what is described directly inside it, builds and collects all its transitively available PEERDIRs.
### As a result, build directory of the project gets the structure of the accessible part of Arcadia, where the build result of each PEERDIR is placed to relevant Arcadia subpath.
### The data can be optionally packed if macro PACK() is used.
###
### Is only used together with the macros FILES(), PEERDIR(), COPY(), FROM_SANDBOX(), RUN_PROGRAM or BUNDLE(). Don't use SRCS inside a PACKAGE.
###
### Documentation: https://wiki.yandex-team.ru/yatool/large-data/
###
### @see: [PACK()](#macro_PACK)
module PACKAGE: _BASE_UNIT  {
    .CMD=TOUCH_PACKAGE_MF
    .PEERDIR_POLICY=as_build_from
    .ALL_INS_TO_OUT=yes
    .FINAL_TARGET=yes
    .ALLOWED=PACK
    SET(MODULE_SUFFIX .pkg.fake)
    SET(DONT_RESOLVE_INCLUDES yes)
    NO_PLATFORM()
    when ($PACKED_PACKAGE_EXT) {
        PACKED_PACKAGE_ARGS+=--dest-arch ${output;pre=$MODULE_PREFIX;suf=.$PACKED_PACKAGE_EXT:REALPRJNAME}
    }
    SET(NEED_PLATFORM_PEERDIRS no)
    PEERDIR_TAGS=CPP_PROTO CPP_FBS PY2 PY2_NATIVE YQL_UDF_SHARED __EMPTY__ DOCSBOOK JAR_RUNNABLE PY3_BIN PY3TEST_PROGRAM DLL
}

TOUCH_GROUP=$TOUCH_PACKAGE ${kv;hide:"p CI"}

### @usage: CI_GROUP()
###
### Module collects what is described directly inside it transitively by PEERDIRs.
### No particular layout of built artifacts is implied. This module is needed primarily for CI dependency analysis and may not trigger builds at all.
###
### Is only used together with the macro PEERDIR() and FILES(). Don't use SRCS inside CI_GROUP().
module CI_GROUP: _BARE_UNIT  {
    .CMD=TOUCH_GROUP
    .PEERDIR_POLICY=as_build_from
    .ALL_INS_TO_OUT=yes
    .FINAL_TARGET=yes
    .RESTRICTED=SRCS
    MODULE_SUFFIX=.ci.pkg.fake
    PEERDIR_TAGS=CPP_PROTO PY3 PY3_NATIVE YQL_UDF_SHARED __EMPTY__ DOCSBOOK JAR_RUNNABLE DLL
}

# tag:generic tag:internal
TOUCH_UNIT_MF=$TOUCH_UNIT && $GENERATE_MF

# tag:proto
### @usage: RESOLVE_PROTO()
###
### Enable include resolving within UNIONs and let system .proto being resolved
### among .proto/.gztproto imports
###
### Note: it is currently impossible to enable resolving only for .proto, so resolving is enabled for all supported files
### also we only add ADDINCL for stock protobuf. So use this macro with care: it may cause resolving problems those are
### to be addressed by either ADDINCLs or marking them as TEXT. Please contact devtools for details.
macro RESOLVE_PROTO() {
    SET(DONT_RESOLVE_INCLUDES no)
    ADDINCL(FOR proto $PROTOBUF_PATH)
}

### @usage: UNION(name)
###
### Collection of PEERDIR dependencies, files and artifacts.
### UNION doesn't build its peers, just provides those to modules depending on it.
### When specified in DEPENDS() macro the UNION is transitively closed, building all its peers and providing those by own paths (without adding this module path like PACKAGE does).
###
### Is only used together with the macros like FILES(), PEERDIR(), COPY(), FROM_SANDBOX(), RUN_PROGRAM or BUNDLE(). Don't use SRCS inside a UNION.
###
### Documentation: https://wiki.yandex-team.ru/yatool/large-data/
module UNION: _BASE_UNIT {
    .ALL_INS_TO_OUT=yes
    .FINAL_TARGET=no
    NO_PLATFORM()
    SET(MODULE_SUFFIX .pkg.fake)
    SET(DONT_RESOLVE_INCLUDES yes)
    .CMD=TOUCH_UNIT_MF
    SET(NEED_PLATFORM_PEERDIRS no)
    PEERDIR_TAGS=CPP_PROTO CPP_FBS PY2 PY2_NATIVE YQL_UDF_SHARED __EMPTY__ DOCSBOOK JAR_RUNABLE PY3_BIN DLL
}

# tag:python-specific
module _PY_PACKAGE: UNION {
    .EXTS=.py
    .ALL_INS_TO_OUT=yes
    .ALLOWED=GRPC USE_SKIFF
    ENABLE(PY_PROTOS_FOR)
    SET(PEERDIR_TAGS PY_PROTO)
    SET(DONT_RESOLVE_INCLUDES no)
}

# tag:python-specific tag:deprecated tag:internal
### @usage: PY_PACKAGE(name) # internal, deprecated
###
### This is module created via PY_PROTOS_FOR() macro
module PY_PACKAGE: _PY_PACKAGE {
    .FINAL_TARGET=yes
}

# tag:internal
### @usage: _SET_FIRST_VALUE(name args...) # internal
###
### This macro sets the value of `name` variable to the value of next argument
macro _SET_FIRST_VALUE(NAME, VALUE, OTHER...) {
    SET($NAME $VALUE)
}

# tag:python-specific
PY_NAMESPACE_VALUE=

# tag:python-specific
### @usage: PY_NAMESPACE(prefix)
###
### Sets default Python namespace for all python sources in the module.
### Especially suitable in PROTO_LIBRARY where Python sources are generated and there is no PY_SRCS to place NAMESPACE parameter.
macro PY_NAMESPACE(Arg) {
    SET(PY_NAMESPACE_VALUE $Arg)
}

# tag:internal
### @usage: _SRCS_NO_GLOBAL(files...) # internal
###
### Proxy macro to SRCS macro which filters out GLOBAL keyword from the list of source files.
### Useful for modules like EXTERNAL_JAVA_LIBRARY, where GLOBAL keyword cannot be applied properly.
### Note: this macro changes order of source files.
macro _SRCS_NO_GLOBAL(GLOBAL[], FILES...) {
    SRCS($GLOBAL $FILES)
}

# tag:java-specific
JAVA_VCS_MF_ARG=
COMPILE_JAVA_MF=$COMPILE_JAVA

# tag:java-specific
when ($EXT_JAVA_VCS_INFO == "yes") {
    JAVA_VCS_MF_ARG=--vcs-mf $VCS_JAVA
    COMPILE_JAVA_MF=$GENERATE_VCS_JAVA_INFO_NODEP && $COMPILE_JAVA
}

# tag:java-specific
EXT_JAVA_VCS_INFO=no
### @usage: EMBED_JAVA_VCS_INFO()
###
### Embed manifest with vcs info into `EXTERNAL_JAVA_LIBRARY`
### By default this is disabled.
macro EMBED_JAVA_VCS_INFO() {
    ENABLE(EXT_JAVA_VCS_INFO)
}

# tag:java-specific tag:internal
### @usage: EXTERNAL_JAVA_LIBRARY() #internal
###
### EXTERNAL_JAVA_LIBRARY() is a module for creating a .jar file using non-Java code (generators etc.)
### Unlike regular JAVA_LIBRARY this module doesn't produce .pom file, so it cannot be exported to Maven itself.
### PEERDIR it from JAVA_LIBRARY or JAVA_PROGRAM for export to Maven.
module EXTERNAL_JAVA_LIBRARY: _BASE_UNIT {
    .EXTS=.jsrc .java .jar .mf
    .NODE_TYPE=Bundle
    .CMD=COMPILE_JAVA_MF
    .PEERDIR_POLICY=as_build_from
    .FINAL_TARGET=no
    .ALIASES=SRCS=_SRCS_NO_GLOBAL
    .ALLOWED=EMBED_JAVA_VCS_INFO
    .RESTRICTED=EXTERNAL_JAR

    PEERDIR(build/platform/java/jdk)
    PEERDIR+=$JDK_RESOURCE_PEERDIR $EXTERNAL_JAVA_EXTRA_PEERDIR

    PEERDIR_TAGS=JAVA_PROTO JAVA_FBS JAVA_IDL
    HAS_MANAGEABLE_PEERS=yes
    DYNAMIC_LINK=yes
    MACRO_ALIAS(PROTO_CMD _JAVA_PROTO_CMD)
    MACRO_ALIAS(EVLOG_CMD _JAVA_EVLOG_CMD)
    MACRO_ALIAS(FBS_CMD _JAVA_FLATC_CMD)

    when ($PACKAGE_PREFIX) {
        PACKAGE_PREFIX_ARGS=--package-prefix=$PACKAGE_PREFIX
    }

    DISABLE(NEED_PLATFORM_PEERDIRS)
    NO_PLATFORM()
    SET(MODULE_SUFFIX .jar)
    SET(MODULE_LANG JAVA)
}

# tag:java-specific
ALL_JAR_SOURCES=
LINT_JAVA_SOURCES=
ALL_SRCDIRS=
LINK_JAR_RESOURCES=
LINK_JAR_JSOURCES=
JAR_GEN_SRCS=
JAR_GEN_JSRCS=
macro _JAR_SRCS(SRCDIR=".", PACKAGE_PREFIX="", EXCLUDE[], FILES[], RESOURCES?"yes":"no", Globs...) {
    _CHECK_JAVA_SRCDIR($SRCDIR)
    SET_APPEND(ALL_SRCDIRS $SRCDIR)
    SET(VAR_SALT $SRCDIR $Globs $EXCLUDE $PACKAGE_PREFIX $RESOURCES $FILES)
    SET(JAR_SRCS_GLOB uniq_${hash:VAR_SALT})
    _LATE_GLOB(${JAR_SRCS_GLOB} ${pre=${SRCDIR}/:Globs} EXCLUDE ${EXCLUDE})
    SET_APPEND(LINT_JAVA_SOURCES \${input;rootrel;ext=.java:${JAR_SRCS_GLOB}})
    SET_APPEND(ALL_JAR_SOURCES --jsources ${BINDIR}/misc/${tolower:JAR_SRCS_GLOB}.src.txt --resources ${BINDIR}/misc/${tolower:JAR_SRCS_GLOB}.res.txt --srcdir ${quo:SRCDIR} \${input:${JAR_SRCS_GLOB}} ${pre=\$\{input\:\";suf=\"\}:FILES})
    _FILL_JAR_COPY_RESOURCES_CMD(LINK_JAR_RESOURCES ${quo:SRCDIR} ${BINDIR}/cls ${PACKAGE_PREFIX} ${BINDIR}/misc/${tolower:JAR_SRCS_GLOB}.res.txt)
    _FILL_JAR_COPY_RESOURCES_CMD(LINK_JAR_JSOURCES ${quo:SRCDIR} ${BINDIR}/src ${PACKAGE_PREFIX} ${BINDIR}/misc/${tolower:JAR_SRCS_GLOB}.src.txt)
    _FILL_JAR_GEN_SRCS(JAR_GEN_SRCS  JAR     $SRCDIR ${BINDIR}/cls ${BINDIR}/all-java.srclst ${BINDIR}/misc/all-kt-sources.txt ${BINDIR}/misc/all-gr-sources.txt ${BINDIR}/misc/${tolower:JAR_SRCS_GLOB}.res.txt $Globs EXCLUDE $EXCLUDE)
    _FILL_JAR_GEN_SRCS(JAR_GEN_JSRCS SRC_JAR $SRCDIR ${BINDIR}/cls ${BINDIR}/all-java.srclst ${BINDIR}/misc/all-kt-sources.txt ${BINDIR}/misc/all-gr-sources.txt ${BINDIR}/misc/${tolower:JAR_SRCS_GLOB}.src.txt $Globs EXCLUDE $EXCLUDE)
}

macro IDEA_JAR_SRCS(Args...) {
    _JAR_SRCS($Args)
    SET_APPEND(JAVA_SRCS_VALUE $ARGS_DELIM $Args)
}

macro _HASH_HELPER(Args...) {
    .CMD=${hash:Args}
}

macro _GENTAR_HELPER(OUT_DIR[], Args...) {
    .CMD=${cwd:BINDIR} $YMAKE_PYTHON ${input:"build/scripts/autotar_gendirs.py"} --pack ${OUT_DIR} --outs ${output;tared;suf=.$_HASH_HELPER($Args).gentar:OUT_DIR} ${kv;hide:"tared_kind nodir"}
}

# tag:java-specific
RUN_JAR_PROG_CP_PRE=@
RUN_JAR_PROG_CP_SUF=.cplst
when($JDK_VERSION == "8") {
    RUN_JAR_PROG_CP_PRE=
    RUN_JAR_PROG_CP_SUF=
}

# tag:java-specific
macro _DO_2_RUN_JAR_PROGRAM(IN_DIRS_VAR="uniq_", IN_DIRS_INPUTS[], IN{input}[], IN_NOPARSE{input}[], IN_DIR[], OUT_NOAUTO{output}[], OUT{output}[], TOOL{tool}[], OUT_DIR[], CLASSPATH[], ADD_SRCS_TO_CLASSPATH?"yes":"no", CWD="${ARCADIA_BUILD_ROOT}", Args...) {
    _LATE_GLOB(${IN_DIRS_VAR} ${suf=/**/*:IN_DIR})
    _CHECK_RUN_JAVA_PROG_CLASSPATH($CLASSPATH)
    .PEERDIR=build/platform/java/jdk $JDK_RESOURCE_PEERDIR
    .CMD=${cwd:BINDIR} $YMAKE_PYTHON ${input:"build/scripts/mkdir.py"} ${OUT_DIR} && ${cwd:CWD} $YMAKE_PYTHON ${input:"build/scripts/setup_java_tmpdir.py"} $YMAKE_PYTHON ${input:"build/scripts/stdout2stderr.py"} $YMAKE_PYTHON ${input:"build/scripts/fix_java_command_file_cp.py"} --build-root ${ARCADIA_BUILD_ROOT} $JDK_RESOURCE/bin/java -Dfile.encoding=utf8 -classpath ${RUN_JAR_PROG_CP_PRE}${tool:CLASSPATH}${RUN_JAR_PROG_CP_SUF} ${Args} && $_GENTAR_HELPER($CLASSPATH $IN_DIR $IN $IN_NOPARSE $TOOL $Args OUT_DIR $OUT_DIR) ${input;hide:IN} ${input;context=TEXT;hide:IN_NOPARSE} ${output;noauto;hide:OUT_NOAUTO} ${output;hide:OUT} ${tool;hide:TOOL} ${IN_DIRS_INPUTS}
}

# tag:java-specific
macro _DO_1_RUN_JAR_PROGRAM(IN_DIRS_VAR="uniq", Args...) {
    _DO_2_RUN_JAR_PROGRAM($Args IN_DIRS_VAR $IN_DIRS_VAR IN_DIRS_INPUTS ${"$"}{input;hide:$IN_DIRS_VAR})
}

# tag:java-specific
macro RUN_JAVA_PROGRAM(Args...) {
    _DO_1_RUN_JAR_PROGRAM($Args IN_DIRS_VAR uniq_${hash:Args})
}

# tag:java-specific
_JAR_ANN_PROCESSORS=
_JAR_ANN_PROC_OPT_PREFIX=
macro JAR_ANNOTATION_PROCESSOR(Classes...) {
    SET_APPEND(_JAR_ANN_PROCESSORS $Classes)
    SET(_JAR_ANN_PROC_OPT_PREFIX -processor)

    # for ya ide idea only
    SET_APPEND(ANNOTATION_PROCESSOR_VALUE $ARGS_DELIM $Classes)
}

# tag:java-specific
macro _JAR_ANN_PROC_OPTS(Classes...) {
    .CMD=$_JAR_ANN_PROC_OPT_PREFIX ${join=,:Classes}
}

# tag:java-specific
macro _NOOP_MACRO(Args...) {
    ENABLE(UNUSED_MACRO)
}

# tag:java-specific
module _JAR_BASE: _BARE_UNIT {
    .NODE_TYPE=Bundle
    .CMD=TOUCH_UNIT
    .PEERDIR_POLICY=as_build_from
    .FINAL_TARGET=no
    .ALIASES=SRCS=_SRCS_NO_GLOBAL
    .ALLOWED=EMBED_JAVA_VCS_INFO DEPENDENCY_MANAGEMENT EXCLUDE
    .DEFAULT_NAME_GENERATOR=TwoDirNames

    PEERDIR_TAGS=JAVA_PROTO JAVA_FBS JAVA_IDL DLL JAR_COMPILATION __EMPTY__

    HAS_MANAGEABLE_PEERS=yes
    DYNAMIC_LINK=yes
    MACRO_ALIAS(PROTO_CMD _JAVA_PROTO_CMD)
    MACRO_ALIAS(EVLOG_CMD _JAVA_EVLOG_CMD)
    MACRO_ALIAS(FBS_CMD _JAVA_FLATC_CMD)

    DISABLE(NEED_PLATFORM_PEERDIRS)
    NO_PLATFORM()
    VCS_JAVA=${suf=.__vcs_version__.mf:TARGET}
    SET(MODULE_LANG JAVA)
}

# tag:java-specific
module JAVA_CONTRIB_PROXY: _JAR_BASE {
}

# tag:java-specific
macro _FETCH_CONTRIB(Id, Out, SBR="sbr:") {
    .CMD=${hide:SANDBOX_FAKEID} ${cwd:BINDIR} ${resource;pre=$SBR:Id} $YMAKE_PYTHON ${input:"build/scripts/fetch_from_sandbox.py"} --resource-file $(RESOURCE_ROOT)/sbr/$Id/resource --resource-id $Id --copy-to ${output:Out} ${input;hide:"build/scripts/fetch_from.py"} ${requirements;hide:"network:full"} ${kv;hide:"p SB"} ${kv;hide:"pc yellow"} ${kv;hide:"show_out"}
    ADD_CHECK(check.resource $Id)
}

# tag:java-specific
LOCAL_JAR_PATH=
LOCAL_SOURCES_JAR_PATH=
JAR_RESOURCE_ID=
SRC_RESOURCE_ID=
FETCH_SRCS_JAR=
FETCH_TARGET_JAR=
FETCH_CONTRIB_JAR=$FETCH_TARGET_JAR $FETCH_SRCS_JAR

# tag:java-specific
macro JAR_RESOURCE(Id) {
    SET(JAR_RESOURCE_ID $Id)
}

# tag:java-specific
macro SRC_RESOURCE(Id) {
    SET(SRC_RESOURCE_ID $Id)
}

# tag:java-specific
macro LOCAL_JAR(File) {
    SET(LOCAL_JAR_PATH $File)
}

# tag:java-specific
macro LOCAL_SOURCES_JAR(File) {
    SET(LOCAL_SOURCES_JAR_PATH $File)
}

# tag:java-specific
module JAVA_CONTRIB: _JAR_BASE {
    .CMD=FETCH_CONTRIB_JAR
    .FINAL_TARGET=yes

    when ($JAR_RESOURCE_ID) {
        FETCH_TARGET_JAR= && $_FETCH_CONTRIB($JAR_RESOURCE_ID ${BINDIR}/${MODULE_PREFIX}${REALPRJNAME}${MODULE_SUFFIX})
    }
    otherwise {
        when ($LOCAL_JAR_PATH) {
            FETCH_TARGET_JAR= && $FS_TOOLS copy ${input:LOCAL_JAR_PATH} $TARGET
        }
        otherwise {
            FETCH_TARGET_JAR= && $GENERATE_VCS_JAVA_INFO_NODEP && ${cwd:BINDIR} $JDK_RESOURCE/bin/jar cfvm $TARGET $VCS_JAVA .
            PEERDIR+=build/platform/java/jdk
            PEERDIR+=$JDK_RESOURCE_PEERDIR
        }
    }
    when ($SRC_RESOURCE_ID) {
        FETCH_SRCS_JAR= && $_FETCH_CONTRIB($SRC_RESOURCE_ID ${BINDIR}/${REALPRJNAME}-sources.jar)
    }
    otherwise {
        when ($LOCAL_SOURCES_JAR_PATH) {
            FETCH_SRCS_JAR= && $FS_TOOLS copy ${input:LOCAL_SOURCES_JAR_PATH} {output;pre=${BINDIR}/;suf=-sources.jar:REALPRJNAME}
        }
        otherwise {
            FETCH_SRCS_JAR= && $GENERATE_VCS_JAVA_INFO_NODEP && $FS_TOOLS md ${BINDIR}/fake-src && ${cwd;suf=/fake-src:BINDIR} $JDK_RESOURCE/bin/jar cfvm ${output;pre=${BINDIR}/;suf=-sources.jar:REALPRJNAME} $VCS_JAVA .
            PEERDIR+=build/platform/java/jdk
            PEERDIR+=$JDK_RESOURCE_PEERDIR
        }
    }

    SET(MODULE_SUFFIX .jar)
}

# tag:kotlin-specific
KOTLINC_OPTS_VALUE=

# tag:kotlin-specific
KT_SRSCLIST_FLAG=--kotlin ${BINDIR}/misc/all-kt-sources.txt
KT_CLASSES_DIR=${BINDIR}/kt_cls
COLLECT_KT_CLASSPATH=${YMAKE_PYTHON} ${input:"build/scripts/writer.py"} --file ${BINDIR}/kt_bfg.txt -m --ya-start-command-file ${ext=.jar:MANAGED_PEERS_CLOSURE} --ya-end-command-file
LINK_KT_CLASSPATH=$YMAKE_PYTHON ${input:"build/scripts/make_java_classpath_file.py"} ${BINDIR}/kt_bfg.txt ${BINDIR}/kt_cp.txt && $FS_TOOLS md $KT_CLASSES_DIR
COMPILE_KT=${cwd:ARCADIA_BUILD_ROOT} $YMAKE_PYTHON ${input:"build/scripts/with_pathsep_resolve.py"} $YMAKE_PYTHON ${input:"build/scripts/run_javac.py"} --kotlin --sources-list ${BINDIR}/misc/all-kt-sources.txt $JDK_RESOURCE/bin/java -jar $KOTLIN_COMPILER_RESOURCE_GLOBAL/kotlin-compiler.jar -no-stdlib -module-name $REALPRJNAME -jvm-target ${KOTLIN_JVM_TARGET} @${BINDIR}/misc/all-kt-sources.txt -classpath @${BINDIR}/kt_cp.txt $KOTLINC_FLAGS_VALUE -d $KT_CLASSES_DIR $KOTLINC_OPTS_VALUE
ALL_KT_COMMANDS=
KT_CLASSPATH_ITEM=

# tag:java-specific
JAVAC_CMD=$JDK_RESOURCE/bin/javac
ERROR_PRONE_JAVAC_CMD=${YMAKE_PYTHON} ${input:"build/scripts/build_java_with_error_prone2.py"} $JDK_RESOURCE/bin/java $JDK_RESOURCE/bin/javac $ERROR_PRONE_RESOURCE/error_prone.jar

# tag:java-specific tag:codenav
JAVA_YNDEXING=no

# tag:java-specific
when ($USE_SYSTEM_KYTHE) {
    KYTHE_RESOURCE=$USE_SYSTEM_KYTHE
}
otherwise {
    KYTHE_RESOURCE=$KYTHE_RESOURCE_GLOBAL
}

# tag:java-specific tag:codenav
_JAVA_YNDEXING_CMD=$YMAKE_PYTHON ${input:"build/scripts/build_java_codenav_index.py"} $TARGET $ARCADIA_BUILD_ROOT $ARCADIA_ROOT ${BINDIR}/all-java.srclst $JDK_RESOURCE/bin/java -jar $KYTHE_RESOURCE/kythe/extractors/javac_extractor.jar
_DO_JAVA_YNDEXING=

# tag:java-specific
SOURCES_JAR=no
_PACK_SRC_JAR_IMPL=&& $FS_TOOLS md ${BINDIR}/src $JAR_GEN_JSRCS $LINK_JAR_JSOURCES && ${cwd;suf=/src:BINDIR} $JDK_RESOURCE/bin/jar cfvm ${output;pre=${BINDIR}/${MODULE_PREFIX};suf=-sources.jar:REALPRJNAME} $VCS_JAVA .
_PACK_SRC_JAR=

# tag:java-specific
_PACK_JNI=
_PACK_JNI_CMD= && $FS_TOOLS link_or_copy_to_dir --ya-start-command-file ${ext=.so:MANAGED_PEERS_CLOSURE} ${ext=.dll:MANAGED_PEERS_CLOSURE} ${ext=.dylib:MANAGED_PEERS_CLOSURE} --ya-end-command-file ${BINDIR}/cls

# tag:java-specific
_MAKE_JSTYLE_FILE_LIST=

# tag:java-specific
_LINK_UBERJAR=
_UBERJAR_SELF=
_DO_LINK_UBERJAR= && $JDK_RESOURCE/bin/java -cp $UBERJAR_RESOURCE/devtools-java_shader.jar ru.yandex.devtools.emigrante.Main --out-jar $TARGET $_UBERJAR_SELF ${ext=.jar;pre=--jar :MANAGED_PEERS_CLOSURE} ${UBERJAR_PREFIX_FLAG} ${UBERJAR_HIDE_EXCLUDE_FLAGS} $UBERJAR_PATH_EXCLUDES ${UBERJAR_MANIFEST_TRANSFORMER_MAIN_FLAG} ${UBERJAR_MANIFEST_TRANSFORMER_ATTRIBUTE_FLAGS} ${UBERJAR_APPENDING_TRANSFORMER_FLAGS} ${UBERJAR_SERVICES_RESOURCE_TRANSFORMER_FLAG} \
                  && $YMAKE_PYTHON ${input:"build/scripts/mkdir.py"} $BINDIR/_empty/META-INF \
                  && $YMAKE_PYTHON ${input:"build/scripts/touch.py"} $BINDIR/_empty/META-INF/MANIFEST.MF \
                  && $UPDATE_VCS_JAVA_INFO_NODEP($TARGET) \
                  && ${cwd;suf=/_empty:BINDIR} ${JDK_RESOURCE}/bin/jar ufv ${TARGET} META-INF/MANIFEST.MF \
                  && $JDK_RESOURCE/bin/jar ufvm $TARGET $VCS_JAVA

# tag:java-specific
macro _PACK_JAR_HELPER(Out) {
    .CMD=${cwd;suf=/cls:BINDIR} $JDK_RESOURCE/bin/jar cfvm $Out $VCS_JAVA .
}

# tag:java-specific
macro _JAVAC_RUN_HELPER(JAVAC_CMD_WITH_ARGS...) {
    .CMD=${cwd:ARCADIA_BUILD_ROOT} $YMAKE_PYTHON ${input:"build/scripts/with_pathsep_resolve.py"} $YMAKE_PYTHON ${input:"build/scripts/setup_java_tmpdir.py"} $YMAKE_PYTHON ${input:"build/scripts/run_javac.py"} --sources-list ${BINDIR}/all-java.srclst ${JAVAC_CMD_WITH_ARGS} @${BINDIR}/all-java.srclst -classpath ${ARCADIA_BUILD_ROOT}/bfg.jar -Xpkginfo:always ${JAVAC_OPTS} $_JAR_ANN_PROC_OPTS($_JAR_ANN_PROCESSORS) -d ${BINDIR}/cls -g -encoding UTF-8
}
macro _ADD_HIDDEN_INPUTS(Inputs...) {
    .CMD=${input;hide:Inputs}
}

# tag:java-specific
ERROR_PRONE_JDK16_ADD_OPENS=-J--add-opens=jdk.compiler/com.sun.tools.javac.code=ALL-UNNAMED -J--add-opens=jdk.compiler/com.sun.tools.javac.comp=ALL-UNNAMED -J--add-opens=jdk.compiler/com.sun.tools.javac.file=ALL-UNNAMED -J--add-opens=jdk.compiler/com.sun.tools.javac.main=ALL-UNNAMED -J--add-opens=jdk.compiler/com.sun.tools.javac.model=ALL-UNNAMED -J--add-opens=jdk.compiler/com.sun.tools.javac.parser=ALL-UNNAMED -J--add-opens=jdk.compiler/com.sun.tools.javac.processing=ALL-UNNAMED -J--add-opens=jdk.compiler/com.sun.tools.javac.tree=ALL-UNNAMED -J--add-opens=jdk.compiler/com.sun.tools.javac.util=ALL-UNNAMED -J--add-opens=jdk.compiler/com.sun.tools.javac.jvm=ALL-UNNAMED -J--add-opens=jdk.compiler/com.sun.tools.javac.api=ALL-UNNAMED
ERROR_PRONE_2_7_1_FORCED_OPTS=-Xep:InlineMeInliner:OFF -Xep:SameNameButDifferent:OFF

# tag:java-specific
JAVA_COVERAGE_SRCLIST_FLAG=--coverage ${output;pre=${MODULE_PREFIX};suf=.cpsf:REALPRJNAME} --source-root ${ARCADIA_ROOT}
JAVA_COVERAGE_SRCLIST=
PREPARE_JAVA_BUILD_DIRS=$FS_TOOLS md ${BINDIR}/cls && $FS_TOOLS md ${BINDIR}/misc
EXTRACT_GENDIRS=${cwd:BINDIR} $YMAKE_PYTHON ${input:"build/scripts/autotar_gendirs.py"} --unpack --ext .gentar ${ext=.gentar:AUTO_INPUT}
COLLECT_JAVA_SRCLIST=${YMAKE_PYTHON} ${input:"build/scripts/make_java_srclists.py"} --moddir ${CURDIR} --java ${BINDIR}/all-java.srclst ${KT_SRSCLIST} ${JAVA_COVERAGE_SRCLIST} --ya-start-command-file ${ALL_JAR_SOURCES} ${ext=.java:AUTO_INPUT} ${ext=.kt:AUTO_INPUT} --ya-end-command-file
COLLECT_CLASSPATH=${YMAKE_PYTHON} ${input:"build/scripts/writer.py"} --file ${BINDIR}/bfg.txt -m --ya-start-command-file ${rootrel:MANAGED_PEERS_CLOSURE} $KT_CLASSPATH_ITEM --ya-end-command-file
LINK_CLASSPATH=${YMAKE_PYTHON} ${input:"build/scripts/make_manifest_from_bf.py"} ${BINDIR}/bfg.txt ${ARCADIA_BUILD_ROOT}/bfg.jar
COMPILE_JAVA_SRCLIST=$_JAVAC_RUN_HELPER($JAVAC_CMD)
PACK_JAR=$_PACK_JAR_HELPER($TARGET)
# NOTE: No && before LINK_JAR_RESOURCES, ALL_KT_COMMANDS and JAR_GEN_SRCS needed since those vars either empty or starts with &&
LINK_JAR=$PREPARE_JAVA_BUILD_DIRS \
      && $EXTRACT_GENDIRS \
      && $COLLECT_JAVA_SRCLIST \
         $JAR_GEN_SRCS \
         $ALL_KT_COMMANDS \
      && $COLLECT_CLASSPATH \
      && $LINK_CLASSPATH \
      && $COMPILE_JAVA_SRCLIST \
         $LINK_JAR_RESOURCES \
      && ${cwd;suf=/cls:BINDIR} $GENERATE_VCS_JAVA_INFO_NODEP . \
         $_PACK_SRC_JAR \
         $_PACK_JNI \
      && $PACK_JAR \
         $_DO_JAVA_YNDEXING \
         ${kv;hide:"p JV"} ${kv;hide:"pc light-blue"} ${kv;hide:"show_out"} \
         $_MAKE_JSTYLE_FILE_LIST \
         $_LINK_UBERJAR \
         $_ADD_HIDDEN_INPUTS($JAVA_EXTERNAL_DEPENDENCIES_VALUE)

# tag:java-specific
_EXT_SRC_JAR=
_EXT_JAR=
_COPY_EXT_SRC_JAR=
_DO_USE_EXT_JAR=$FS_TOOLS copy ${input:_EXT_JAR} $TARGET $_COPY_EXT_SRC_JAR
_DO_COPY_EXT_SRC_JAR= && $FS_TOOLS copy $_EXT_SRC_JAR ${output;pre=${BINDIR}/${MODULE_PREFIX};suf=-sources.jar:REALPRJNAME}
macro JAVA_RESOURCE(JAR, SOURCES="") {
    SET(_EXT_SRC_JAR $SOURCES)
    SET(_EXT_JAR $JAR)
}

# tag:java-specific tag:fbs
JAVA_FLATBUFFERS_VERSION = 2.0.0

# tag:java-specific
module _COMPILABLE_JAR_BASE : _JAR_BASE {
    # flatbuffers-java
    DEPENDENCY_MANAGEMENT(contrib/java/com/google/flatbuffers/flatbuffers-java/${JAVA_FLATBUFFERS_VERSION})
    CHECK_DEPENDENT_DIRS(DENY PEERDIRS contrib/java/com/google/flatbuffers/flatbuffers-java EXCEPT contrib/java/com/google/flatbuffers/flatbuffers-java/${JAVA_FLATBUFFERS_VERSION})

    # protobuf-java
    DEPENDENCY_MANAGEMENT(contrib/java/com/google/protobuf/protobuf-java/${JAVA_PROTO_RUNTIME_VERSION})
    CHECK_DEPENDENT_DIRS(DENY PEERDIRS contrib/java/com/google/protobuf/protobuf-java EXCEPT contrib/java/com/google/protobuf/protobuf-java/${JAVA_PROTO_RUNTIME_VERSION})

    # protobuf-javalite
    DEPENDENCY_MANAGEMENT(contrib/java/com/google/protobuf/protobuf-javalite/${JAVA_PROTO_RUNTIME_VERSION})
    CHECK_DEPENDENT_DIRS(DENY PEERDIRS contrib/java/com/google/protobuf/protobuf-javalite EXCEPT contrib/java/com/google/protobuf/protobuf-javalite/${JAVA_PROTO_RUNTIME_VERSION})

    # protobuf-java-util
    DEPENDENCY_MANAGEMENT(contrib/java/com/google/protobuf/protobuf-java-util/${JAVA_PROTO_RUNTIME_VERSION})
    CHECK_DEPENDENT_DIRS(DENY PEERDIRS contrib/java/com/google/protobuf/protobuf-java-util EXCEPT contrib/java/com/google/protobuf/protobuf-java-util/${JAVA_PROTO_RUNTIME_VERSION})
}

# tag:java-specific tag:internal
### @usage: JAR_LIBRARY() #internal
###
### Reimplementation of the JAVA_LIBRARY with ymake.core.conf and ymake based dependency management
module JAR_LIBRARY: _COMPILABLE_JAR_BASE {
    .EXTS=.jsrc .java .jar .mf .gentar .kt
    .CMD=LINK_JAR
    .FINAL_TARGET=yes
    .ALIASES=JAVA_SRCS=IDEA_JAR_SRCS ANNOTATION_PROCESSOR=JAR_ANNOTATION_PROCESSOR
    .RESTRICTED=EXTERNAL_JAR
    MODULE_SUFFIX=.jar

    PEERDIR(build/platform/java/jdk)
    PEERDIR+=$JDK_RESOURCE_PEERDIR

    when ($_EXT_SRC_JAR) {
        _COPY_EXT_SRC_JAR=_DO_COPY_EXT_SRC_JAR
    }
    when ($_EXT_JAR) {
        LINK_JAR=$_DO_USE_EXT_JAR
    }

    # in the ideal world this statement must be under condition bellow
    DEPENDENCY_MANAGEMENT(contrib/java/org/jetbrains/kotlin/kotlin-stdlib-jdk8/${KOTLIN_VERSION})
    when ($WITH_KOTLIN_VALUE) {
        KT_SRSCLIST=$KT_SRSCLIST_FLAG
        ALL_KT_COMMANDS=&& $COLLECT_KT_CLASSPATH && $LINK_KT_CLASSPATH && $COMPILE_KT
        LINK_JAR_RESOURCES+=&& $FS_TOOLS copy_all_files ${KT_CLASSES_DIR} ${BINDIR}/cls
        PEERDIR+=build/platform/java/kotlin contrib/java/org/jetbrains/kotlin/kotlin-stdlib-jdk8
        when($WITH_KOTLINC_PLUGIN_ALLOPEN) {
            KOTLINC_OPTS_VALUE+=-Xplugin=${KOTLIN_COMPILER_RESOURCE_GLOBAL}/plugins/kotlin-allopen-plugin.jar
        }
        when($WITH_KOTLINC_PLUGIN_NOARG) {
            KOTLINC_OPTS_VALUE+=-Xplugin=${KOTLIN_COMPILER_RESOURCE_GLOBAL}/plugins/kotlin-noarg-plugin.jar
        }
        # Must be in sync with KT_CLASSES_DIR!
        # There are problems in JDK13 with abs paths in classpath baked into jar file manifest. Using relative path
        # here assumes that jar file with classpath for javac located in the $ARCADIA_BUILD_ROOT
        KT_CLASSPATH_ITEM=$MODDIR/kt_cls
    }
    otherwise {
        KT_SRSCLIST=
        ALL_KT_COMMANDS=
        KT_CLASSES=
    }

    when ($SOURCES_JAR == "yes") {
        _PACK_SRC_JAR=$_PACK_SRC_JAR_IMPL
    }

    when ($JAVA_COVERAGE == "yes") {
        JAVA_COVERAGE_SRCLIST=$JAVA_COVERAGE_SRCLIST_FLAG
    }

    when ($MAKE_UBERJAR_VALUE == "yes") {
        _LINK_UBERJAR=$_DO_LINK_UBERJAR
        PACK_JAR=$_PACK_JAR_HELPER(${BINDIR}/${REALPRJNAME}.lib.jar)
        # TODO: This condition is incorrect in case of autoinputs _UBERJAR_SELF should be empty only for
        # modules without AUTO_INPUT and without JAVA_SRCS added inputs.
        when($ALL_JAR_SOURCES) {
            _UBERJAR_SELF=--jar ${BINDIR}/${REALPRJNAME}.lib.jar
        }
        PEERDIR+=build/platform/java/uberjar
        PEERDIR+=$UBERJAR_RESOURCE_PEERDIR
    }

    when($JAVA_YNDEXING == "yes") {
        PEERDIR+=build/platform/java/kythe
        _DO_JAVA_YNDEXING=&& $_JAVAC_RUN_HELPER($_JAVA_YNDEXING_CMD) && ${cwd:BINDIR} $YMAKE_PYTHON ${input:"build/scripts/find_and_tar.py"} kindex.tar .kzip ${output;hide;tared:"kindex.tar"}
    }

    when($ERROR_PRONE_VALUE) {
        PEERDIR+=$ERROR_PRONE_PEERDIR
        JAVAC_CMD=$ERROR_PRONE_JAVAC_CMD
    }

    when($ERROR_PRONE_VALUE && $JDK_REAL_VERSION == "16") {
        JAVAC_FLAGS_VALUE+=$ERROR_PRONE_JDK16_ADD_OPENS
        JAVAC_OPTS+=$ERROR_PRONE_JDK16_ADD_OPENS
    }

    when($ERROR_PRONE_VALUE && $JDK_REAL_VERSION == "17") {
        JAVAC_FLAGS_VALUE+=$ERROR_PRONE_JDK16_ADD_OPENS
        JAVAC_OPTS+=$ERROR_PRONE_JDK16_ADD_OPENS
    }

    when($ERROR_PRONE_VALUE && $ERROR_PRONE_VERSION == "2.7.1") {
        JAVAC_FLAGS_VALUE+=$ERROR_PRONE_2_7_1_FORCED_OPTS
        JAVAC_OPTS+=$ERROR_PRONE_2_7_1_FORCED_OPTS
    }

    when ($JAVA_ADD_DLLS_VALUE == "yes") {
        CONSUME_NON_MANAGEABLE_PEERS=yes
        _PACK_JNI=$_PACK_JNI_CMD
    }

    when ($LINT_LEVEL_VALUE != "none") {
        _MAKE_JSTYLE_FILE_LIST= && $YMAKE_PYTHON ${input:"build/scripts/writer.py"} --file ${output;noauto:"lint-java.srclst"} -m --ya-start-command-file $LINT_JAVA_SOURCES --ya-end-command-file
    }

    SET(MODULE_TYPE JAVA_LIBRARY)
    ENABLE(YMAKE_JAVA_TEST)
    _ADD_JAVA_STYLE_CHECKS($(BUILD_ROOT)/$MODDIR/lint-java.srclst::$(SOURCE_ROOT))
    _ADD_CLASSPATH_CLASH_CHECK()
    JAVA_MODULE(IDEA_ONLY)
}

# tag:java-specific
_SCRIPTGEN_FLAGS=
macro _GEN_JAVA_SCRIPT_IMPL(Out, Template, Props...) {
    .CMD=$SCRIPTGEN_RESOURCE_GLOBAL/scriptgen --java $JDK_RESOURCE/bin/java --output ${output:Out} --template ${input:Template} ${_SCRIPTGEN_FLAGS} -D JAR_NAME=${REALPRJNAME}.jar -D CLASSPATH=${nopath;join;ext=.jar;pre="::":MANAGED_PEERS_CLOSURE} -D PROJECT_DIR=${MODDIR} -D JAR_BASENAME=${REALPRJNAME} $Props
}

# tag:java-specific
_GEN_USERSCRIPTS=
macro _ADD_GEN_JAVA_SCRIPT(Out, Template, Props...) {
    SET_APPEND(_GEN_USERSCRIPTS && \$_GEN_JAVA_SCRIPT_IMPL($Out $Template $Props))
}

# tag:java-specific
_PACK_JDK=

# tag:java-specific
DO_GEN_JAVA_RUN_SH=
_SOURCE_JARS=
_SOURCE_JARS_CPLIST=
GEN_JAVA_RUN_SH=$SCRIPTGEN_RESOURCE_GLOBAL/scriptgen --java $JDK_RESOURCE/bin/java --output ${output:"run.sh"} -D GENERATE_DEFAULT_RUNNER=yes -D JAR_NAME=${REALPRJNAME}.jar -D CLASSPATH=${nopath;join;pre="::":MANAGED_PEERS_CLOSURE} -D PROJECT_DIR=${REALPRJNAME} -D JAR_BASENAME=${REALPRJNAME}
GEN_RUN_CP=${YMAKE_PYTHON} ${input:"build/scripts/writer.py"} --file ${BINDIR}/run-bf.txt -Q -m --ya-start-command-file ${nopath;qe;pre=$REALPRJNAME/:MANAGED_PEERS_CLOSURE} --ya-end-command-file && ${YMAKE_PYTHON} ${input:"build/scripts/make_manifest_from_bf.py"} ${BINDIR}/run-bf.txt ${TARGET}
COLLECT_JAR_PROGRAM_CP=$FS_TOOLS link_or_copy_to_dir --ya-start-command-file ${ext=.jar:MANAGED_PEERS_CLOSURE} ${ext=.so:MANAGED_PEERS_CLOSURE} ${ext=.dll:MANAGED_PEERS_CLOSURE} ${ext=.dylib:MANAGED_PEERS_CLOSURE} ${_SOURCE_JARS} --ya-end-command-file ${BINDIR}/${REALPRJNAME} ${hide;late_out;nopath;ext=.jar;pre=$BINDIR/$REALPRJNAME/:MANAGED_PEERS_CLOSURE} ${hide;late_out;nopath;ext=.so;pre=$BINDIR/$REALPRJNAME/:MANAGED_PEERS_CLOSURE} ${hide;late_out;nopath;ext=.dll;pre=$BINDIR/$REALPRJNAME/:MANAGED_PEERS_CLOSURE} ${hide;late_out;nopath;ext=.dylib;pre=$BINDIR/$REALPRJNAME/:MANAGED_PEERS_CLOSURE}
MAKE_JAR_PROGRAM_CPLST=$YMAKE_PYTHON ${input:"build/scripts/make_java_classpath_file.py"} --from-args ${output;pre=$MODULE_PREFIX;suf=${MODULE_SUFFIX}.cplst:REALPRJNAME} --ya-start-command-file ${nopath;rootrel;ext=.jar;pre=$BINDIR/$REALPRJNAME/:MANAGED_PEERS_CLOSURE} ${_SOURCE_JARS_CPLIST} --ya-end-command-file
TAR_CLASSPATH= && $YMAKE_PYTHON ${input:"build/scripts/find_and_tar.py"} ${output;pre=$MODULE_PREFIX;suf=.tar:REALPRJNAME} ${cwd;pre=$BINDIR/:REALPRJNAME}
DO_TAR_CLASSPATH=
LINK_JAR_PROGRAM=$FS_TOOLS md ${BINDIR}/${REALPRJNAME} && $COLLECT_JAR_PROGRAM_CP && $DO_GEN_JAVA_RUN_SH && $GEN_RUN_CP && $MAKE_JAR_PROGRAM_CPLST $DO_TAR_CLASSPATH $_GEN_USERSCRIPTS $_PACK_JDK ${kv;hide:"p JP"} ${kv;hide:"pc light-blue"} ${kv;hide:"show_out"}

# tag:java-specific
# UBERJAR program link command
LINK_UBERJAR_PROGRAM=$YMAKE_PYTHON ${input:"build/scripts/make_java_classpath_file.py"} --from-args ${output;pre=$MODULE_PREFIX;suf=${MODULE_SUFFIX}.cplst:REALPRJNAME} $TARGET \
                     && $FS_TOOLS md ${BINDIR}/${REALPRJNAME} \
                     && $FS_TOOLS link_or_copy ${BINDIR}/${REALPRJNAME}.jar $TARGET \
                     && $FS_TOOLS link_or_copy_to_dir --ya-start-command-file ${BINDIR}/${REALPRJNAME}.jar ${ext=.so:MANAGED_PEERS_CLOSURE} ${ext=.dll:MANAGED_PEERS_CLOSURE} ${ext=.dylib:MANAGED_PEERS_CLOSURE} ${_SOURCE_JARS} --ya-end-command-file ${BINDIR}/${REALPRJNAME} ${hide;late_out;ext=.jar;pre=$BINDIR/$REALPRJNAME/:REALPRJNAME} ${hide;late_out;nopath;ext=.so;pre=$BINDIR/$REALPRJNAME/:MANAGED_PEERS_CLOSURE} ${hide;late_out;nopath;ext=.dll;pre=$BINDIR/$REALPRJNAME/:MANAGED_PEERS_CLOSURE} ${hide;late_out;nopath;ext=.dylib;pre=$BINDIR/$REALPRJNAME/:MANAGED_PEERS_CLOSURE} \
                     $DO_TAR_CLASSPATH \
                     $_GEN_USERSCRIPTS \
                     $_PACK_JDK

# tag:java-specific
RUN_WITH_SOURCES=no
TARED_CLASSPATH=yes # TODO jbuild creates tar with all classpath deps by default and some projects rely on this. In ymake build this tar file creation is not needed and should be disabled by default in future
_JAR_SRCS_CALLED=no

# tag:java-specific
macro _MARK_JAVA_PROG_WITH_SOURCES(Args...) {
    ENABLE(_JAR_SRCS_CALLED)
}

# tag:java-specific
module _JAR_RUNABLE: _COMPILABLE_JAR_BASE {
    .FINAL_TARGET=yes
    .CMD=LINK_JAR_PROGRAM
    .ALIASES=JAVA_SRCS=_MARK_JAVA_PROG_WITH_SOURCES GENERATE_SCRIPT=_YMAKE_GENERATE_SCRIPT
    MODULE_SUFFIX=.run.cp.jar
    CONSUME_NON_MANAGEABLE_PEERS=yes

    when ($RUN_WITH_SOURCES == "yes") {
        _SOURCE_JARS=${ext=.jar;noext;suf=-sources.jar:MANAGED_PEERS_CLOSURE} ${hide;late_out;ext=.jar;nopath;pre=$BINDIR/$REALPRJNAME/;noext;suf=-sources.jar:MANAGED_PEERS_CLOSURE}
        _SOURCE_JARS_CPLIST=${nopath;rootrel;ext=.jar;pre=$BINDIR/$REALPRJNAME/;noext;suf=-sources.jar:MANAGED_PEERS_CLOSURE}
    }

    when ($_JAR_SRCS_CALLED && $TARED_CLASSPATH) {
        DO_TAR_CLASSPATH=$TAR_CLASSPATH
    }

    when ($DISABLE_SCRIPTGEN) {
        DO_GEN_JAVA_RUN_SH=
    }
    otherwise {
        DO_GEN_JAVA_RUN_SH=$GEN_JAVA_RUN_SH
        PEERDIR+=build/platform/java/scriptgen
    }

    when ($WITH_JDK_VALUE) {
        _PACK_JDK= && ${YMAKE_PYTHON} ${input:"build/scripts/tar_directory.py"} ${output;tared:"jdk.tar"} $WITH_JDK_RESOURCE $WITH_JDK_RESOURCE
    }

    when ($MAKE_UBERJAR_VALUE == "yes") {
        LINK_JAR_PROGRAM=$LINK_UBERJAR_PROGRAM
        DYNAMIC_LINK=no
        _SCRIPTGEN_FLAGS=-D IS_UBERJAR=yes
    }
    otherwise {
        _SCRIPTGEN_FLAGS=-D IS_UBERJAR=no
    }
    CHECK_PROVIDES()
}

# tag:java-specific
multimodule JAR_PROGRAM {
    module JAR_RUNABLE: _JAR_RUNABLE {
        .ALLOWED=JAVA_RUNTIME_PEERDIR JAVA_RUNTIME_EXCLUDE
        .IGNORED=JAVA_SRCS RUN_JAVA_PROGRAM
        .ALIASES=EXCLUDE=_NOOP_MACRO PEERDIR=_NOOP_MACRO DEPENDENCY_MANAGEMENT=_NOOP_MACRO JAVA_RUNTIME_PEERDIR=PEERDIR JAVA_RUNTIME_EXCLUDE=EXCLUDE
        .PEERDIRSELF=JAR_COMPILATION

        SET(MODULE_TYPE JAVA_PROGRAM)
    }
    module JAR_COMPILATION: JAR_LIBRARY {
        .ALIASES=JAVA_RUNTIME_PEERDIR=_NOOP_MACRO JAVA_RUNTIME_EXCLUDE=_NOOP_MACRO
        .FINAL_TARGET=no
        SET(MODULE_TYPE JAVA_PROGRAM)
    }
}

# tag:java-specific
LINK_JAR_TEST=${YMAKE_PYTHON} ${input:"build/scripts/writer.py"} --file ${BINDIR}/run-bf.txt -Q -m --ya-start-command-file ${ext=.jar:MANAGED_PEERS_CLOSURE} --ya-end-command-file && ${YMAKE_PYTHON} ${input:"build/scripts/make_manifest_from_bf.py"} ${BINDIR}/run-bf.txt ${TARGET}
YMAKE_JAVA_TEST=
module _JAR_TEST: _COMPILABLE_JAR_BASE {
    .FINAL_TARGET=yes
    .CMD=LINK_JAR_TEST
    .DEFAULT_NAME_GENERATOR=FullPath
    CONSUME_NON_MANAGEABLE_PEERS=yes

    SET(MODULE_SUFFIX .test.cp.jar)
    ENABLE(YMAKE_JAVA_TEST)
    JAVA_TEST()
    CHECK_PROVIDES()
}

# tag:java-specific
multimodule JUNIT5_YMAKE {
    module JAR_TESTABLE: _JAR_TEST {
        .ALLOWED=JAVA_TEST_PEERDIR
        .IGNORED=JAVA_SRCS RUN_JAVA_PROGRAM
        .ALIASES=EXCLUDE=_NOOP_MACRO PEERDIR=_NOOP_MACRO DEPENDENCY_MANAGEMENT=_NOOP_MACRO JAVA_TEST_PEERDIR=PEERDIR
        .PEERDIRSELF=JAR_COMPILATION

        SET(MODULE_TYPE JUNIT5)
    }
    module JAR_COMPILATION: JAR_LIBRARY {
        .IGNORED=JAVA_TEST_PEERDIR
        .ALIASES=JAVA_TEST_PEERDIR=_NOOP_MACRO
        .FINAL_TARGET=no

        PEERDIR(devtools/junit5-runner build/platform/java/jacoco-agent)
    }
}

# tag:java-specific
multimodule JTEST_YMAKE {
    module JAR_TESTABLE: _JAR_TEST {
        .ALLOWED=YT_SPEC
        .IGNORED=JAVA_SRCS RUN_JAVA_PROGRAM
        .ALIASES=EXCLUDE=_NOOP_MACRO PEERDIR=_NOOP_MACRO DEPENDENCY_MANAGEMENT=_NOOP_MACRO JAVA_TEST_PEERDIR=PEERDIR
        .PEERDIRSELF=JAR_COMPILATION

        SET(MODULE_TYPE JTEST)
        PEERDIR(devtools/junit-runner)
        DEPENDENCY_MANAGEMENT(contrib/java/org/hamcrest/hamcrest-core/1.3 contrib/java/com/google/code/gson/gson/2.8.6 contrib/java/com/beust/jcommander/1.72 contrib/java/junit/junit/4.12)
    }
    module JAR_COMPILATION: JAR_LIBRARY {
        .ALIASES=JAVA_TEST_PEERDIR=_NOOP_MACRO
        .ALLOWED=YT_SPEC
        .FINAL_TARGET=no

        DEPENDS(contrib/java/org/sonarsource/scanner/cli/sonar-scanner-cli/2.8)
        PEERDIR(build/platform/java/jacoco-agent)
    }
}

# tag:python-specific tag:deprecated
### @usage: PY2_LIBRARY() # deprecated
###
### Deprecated. Use PY23_LIBRARY or PY3_LIBRARY instead.
### Python 2.x binary built library. Builds sources from PY_SRCS to data suitable for PY2_PROGRAM.
### Adds dependencies to Python 2.x runtime library from Arcadia.
### This module is only compatible with PYTHON2-tagged modules and selects those from multimodules.
### This module is only compatible with Arcadia Python build.
###
### Documentation: https://wiki.yandex-team.ru/devtools/commandsandvars/py_srcs/
module PY2_LIBRARY: _LIBRARY {
    _ARCADIA_PYTHON_ADDINCL()

    when ($NO_PYTHON_INCLS != "yes") {
        PEERDIR+=contrib/libs/python
    }
    when ($MSVC == "yes" || $CYGWIN == "yes") {
        MODULE_PREFIX=py
    }
    otherwise {
        MODULE_PREFIX=libpy
    }
    .ALLOWED=FORK_TESTS
    .IGNORED=GENERATE_ENUM_SERIALIZATION GENERATE_ENUM_SERIALIZATION_WITH_HEADER USE_PYTHON2
    .RESTRICTED=PYTHON3_ADDINCL USE_PYTHON3 PYTHON2_ADDINCL OPTIMIZE_PY_PROTOS NO_OPTIMIZE_PY_PROTOS STYLE_PYTHON
    USE_GLOBAL_CMD=yes

    when ($PY_PROTO_MYPY_ENABLED == "yes") {
        PY_PROTO_MYPY_SUFFIX=_pb2.pyi
        PY_PROTO_MYPY_PLUGIN=$PY_PROTO_MYPY_PLUGIN_BASE ${output;hide;noauto;norel;nopath;noext;suf=_pb2.pyi:File}
        PY_PROTO_MYPY_PLUGIN_INTERNAL=$PY_PROTO_MYPY_PLUGIN_BASE ${output;hide;noauto;norel;nopath;noext;suf=__int___pb2.pyi:File} ${hide;kv:"ext_out_name_for_${nopath;noext;suf=__int___pb2.pyi:File} ${nopath;noext;suf=_pb2.pyi:File}"})
    }
    SET(MODULE_LANG PY2)
    ADD_CLANG_TIDY()
}


# tag:python-specific
### @usage: PY3_LIBRARY()
###
### Python 3.x binary library. Builds sources from PY_SRCS to data suitable for PY2_PROGRAM
### Adds dependencies to Python 2.x runtime library from Arcadia.
### This module is only compatible with PYTHON3-tagged modules and selects those from multimodules.
### This module is only compatible with Arcadia Python build.
###
### Documentation: https://wiki.yandex-team.ru/devtools/commandsandvars/py_srcs/
module PY3_LIBRARY: _LIBRARY {
    _ARCADIA_PYTHON3_ADDINCL()

    when ($NO_PYTHON_INCLS != "yes") {
        PEERDIR+=contrib/libs/python
    }
    when ($MSVC == "yes" || $CYGWIN == "yes") {
        MODULE_PREFIX=py
    }
    otherwise {
        MODULE_PREFIX=libpy
    }
    .ALLOWED=FORK_TESTS
    .IGNORED=GENERATE_ENUM_SERIALIZATION GENERATE_ENUM_SERIALIZATION_WITH_HEADER
    .RESTRICTED=PYTHON3_ADDINCL USE_PYTHON3 PYTHON2_ADDINCL USE_PYTHON2 OPTIMIZE_PY_PROTOS NO_OPTIMIZE_PY_PROTOS
    USE_GLOBAL_CMD=yes

    PEERDIR($YMAKE_PYTHON3_PEER)
    RUN_CYTHON_SCRIPT=$YMAKE_PYTHON3 $CYTHON_SCRIPT
    PYTHON_TYPE_FOR_CYTHON=PY3

    when ($PY_PROTO_MYPY_ENABLED == "yes") {
        PY_PROTO_MYPY_SUFFIX=_pb2.pyi
        PY_PROTO_MYPY_PLUGIN=$PY_PROTO_MYPY_PLUGIN_BASE ${output;hide;noauto;norel;nopath;noext;suf=_pb2.pyi:File}
        PY_PROTO_MYPY_PLUGIN_INTERNAL=$PY_PROTO_MYPY_PLUGIN_BASE ${output;hide;noauto;norel;nopath;noext;suf=__int___pb2.pyi:File} ${hide;kv:"ext_out_name_for_${nopath;noext;suf=__int___pb2.pyi:File} ${nopath;noext;suf=_pb2.pyi:File}"})
    }
    SET(MODULE_LANG PY3)
    ADD_CLANG_TIDY()
}


# tag:python-specific
### @usage: _BASE_PY_PROGRAM #internal
###
### The base module for all Python 2.x binary programs. Adds linking logic, relevant module properties and
### dependency on Python 2.x interpreter. Also adds import tests on all sources including PEERDIR'ed libraries.
### Links all Python 2.x libraries and Python 2.x interpreter into itself to form regular executable.
### This only compatible with PYTHON2-tagged modules and selects those from multimodules.
###
### Documentation: https://wiki.yandex-team.ru/devtools/commandsandvars/py_srcs/
module _BASE_PY_PROGRAM: _BASE_PROGRAM {
    .CMD=PY_PROGRAM_LINK_EXE
    _ARCADIA_PYTHON_ADDINCL()

    when ($SANITIZER_TYPE && $SANITIZER_TYPE != "no") {
        NO_CHECK_IMPORTS_FOR_VALUE=
    }
    ADD_CHECK_PY_IMPORTS()

    when ($NO_PYTHON_INCLS != "yes") {
        PEERDIR += contrib/libs/python
    }
    when ($USE_ARCADIA_PYTHON == "yes") {
        PEERDIR += library/python/runtime/main
        PEERDIR += contrib/python/subprocess32
        when ($PYTHON_SQLITE3 != "no") {
            PEERDIR += contrib/tools/python/src/Modules/_sqlite
        }
    }
    when ($PYTHON_COVERAGE == "yes") {
        PEERDIR+=library/python/coverage
    }

    when ($ARCH_PPC64LE == "yes") {
        _MY_ALLOCATOR=SYSTEM
    }
    otherwise {
        _MY_ALLOCATOR=J
    }
    ALLOCATOR($_MY_ALLOCATOR)
    STRIP()

    when ($BUILD_TYPE == "DEBUG") {
        NO_STRIP=yes
    }
    when ($SANITIZER_TYPE && $SANITIZER_TYPE != "no") {
        NO_STRIP=yes
    }
    .IGNORED=GENERATE_ENUM_SERIALIZATION GENERATE_ENUM_SERIALIZATION_WITH_HEADER USE_PYTHON2
    .RESTRICTED=PYTHON3_ADDINCL USE_PYTHON3 PYTHON2_ADDINCL OPTIMIZE_PY_PROTOS NO_OPTIMIZE_PY_PROTOS
    SET(MODULE_LANG PY2)
}

# tag:python-specific tag:codenav
when ($CODENAVIGATION && $NOCODENAVIGATION != "yes") {
    PY3_PROGRAM_LINK_EXE=$LINK_EXE ${kv;hide:"py3yndex $TARGET"}
}
otherwise {
    PY3_PROGRAM_LINK_EXE=$LINK_EXE
}


# tag:python-specific
### @usage: _BASE_PY_PROGRAM #internal
###
### The base module for all Python 3.x binary programs. Adds linking logic, relevant module properties and
### dependency on Python 3.x interpreter. Also adds import tests on all sources including libraries.
### Links all Python 3.x libraries and Python 3.x interpreter into itself to form regular executable.
### This only compatible with PYTHON3-tagged modules and selects those from multimodules
###
### Documentation: https://wiki.yandex-team.ru/devtools/commandsandvars/py_srcs/
module _BASE_PY3_PROGRAM: _BASE_PROGRAM {
    .CMD=PY3_PROGRAM_LINK_EXE
    _ARCADIA_PYTHON3_ADDINCL()
    PEERDIR(library/python/runtime_py3/main)
    when ($PYTHON_SQLITE3 != "no") {
        PEERDIR += contrib/tools/python3/src/Modules/_sqlite
    }

    when ($SANITIZER_TYPE && $SANITIZER_TYPE != "no") {
        NO_CHECK_IMPORTS_FOR_VALUE=
    }
    ADD_CHECK_PY_IMPORTS()

    when ($ARCH_PPC64LE == "yes") {
        _MY_ALLOCATOR=SYSTEM
    }
    otherwise {
        _MY_ALLOCATOR=J
    }
    ALLOCATOR($_MY_ALLOCATOR)
    STRIP()

    when ($NO_PYTHON_INCLS != "yes") {
        PEERDIR+=contrib/libs/python
    }
    when ($BUILD_TYPE == "DEBUG") {
        NO_STRIP=yes
    }
    when ($SANITIZER_TYPE && $SANITIZER_TYPE != "no") {
        NO_STRIP=yes
    }
    when ($PYTHON_COVERAGE == "yes") {
        PEERDIR+=library/python/coverage
    }
    when ($CODENAVIGATION && $NOCODENAVIGATION != "yes")  {
        PEERDIR += contrib/python/six
    }
    .IGNORED=GENERATE_ENUM_SERIALIZATION GENERATE_ENUM_SERIALIZATION_WITH_HEADER
    .RESTRICTED=PYTHON3_ADDINCL USE_PYTHON3 PYTHON2_ADDINCL USE_PYTHON2
    SET(MODULE_LANG PY3)
}

# tag:python-specific
### @usage: PY3_PROGRAM_BIN([progname])
### Use instead of PY3_PROGRAM only if ya.make with PY3_PROGRAM() included in another ya.make
### In all other cases use PY3_PROGRAM
module PY3_PROGRAM_BIN: _BASE_PY3_PROGRAM {
    # Look's like we cannot avoid copy-paste util ymake supports multiple inheritance
    # We need to attach coverage.extractor to every py_program target, except pytest targets
    ADD_YTEST($MODULE_PREFIX$REALPRJNAME coverage.extractor)
}

# tag:java-specific
JAVA_SWIG_DELIM=JAVA_SWIG_DELIM

# tag:java-specific
JDK_REAL_VERSION=
JDK_VERSION=

when ($JDK_VERSION == "17") {
    JDK_REAL_VERSION=17
}
elsewhen ($JDK_VERSION == "16") {
    JDK_REAL_VERSION=16
}
elsewhen ($JDK_VERSION == "15") {
    JDK_REAL_VERSION=15
}
elsewhen ($JDK_VERSION == "14") {
    JDK_REAL_VERSION=14
}
elsewhen ($JDK_VERSION == "13") {
    JDK_REAL_VERSION=13
}
elsewhen ($JDK_VERSION == "12") {
    JDK_REAL_VERSION=12
}
elsewhen ($JDK_VERSION == "11") {
    JDK_REAL_VERSION=11
}
elsewhen ($JDK_VERSION == "10") {
    JDK_REAL_VERSION=10
}
elsewhen ($JDK_VERSION == "8") {
    JDK_REAL_VERSION=8
}
elsewhen ($MAPSMOBI_BUILD_TARGET && $OS_ANDROID) {
    JDK_REAL_VERSION=8
}
otherwise {
    JDK_REAL_VERSION=17
}


# tag:java-specific
# remove extra peerdir to jdk11 after https://st.yandex-team.ru/DEVTOOLS-8851 is done
when ($USE_SYSTEM_JDK) {
    JDK_RESOURCE_PEERDIR=
}
otherwise {
    when ($JDK_REAL_VERSION == "17") {
        # need jdk11 for spare parts in "host" platform
        JDK_RESOURCE_PEERDIR=build/platform/java/jdk/jdk17 build/platform/java/jdk/jdk11
    }
    when ($JDK_REAL_VERSION == "16") {
        JDK_RESOURCE_PEERDIR=build/platform/java/jdk/jdk16 build/platform/java/jdk/jdk17
    }
    when ($JDK_REAL_VERSION == "15") {
        JDK_RESOURCE_PEERDIR=build/platform/java/jdk/jdk15 build/platform/java/jdk/jdk17
    }
    when ($JDK_REAL_VERSION == "14") {
        JDK_RESOURCE_PEERDIR=build/platform/java/jdk/jdk14 build/platform/java/jdk/jdk17
    }
    when ($JDK_REAL_VERSION == "13") {
        JDK_RESOURCE_PEERDIR=build/platform/java/jdk/jdk13 build/platform/java/jdk/jdk17
    }
    when ($JDK_REAL_VERSION == "12") {
        JDK_RESOURCE_PEERDIR=build/platform/java/jdk/jdk12 build/platform/java/jdk/jdk17
    }
    when ($JDK_REAL_VERSION == "11") {
        JDK_RESOURCE_PEERDIR=build/platform/java/jdk/jdk11 build/platform/java/jdk/jdk17
    }
    when ($JDK_REAL_VERSION == "10") {
        JDK_RESOURCE_PEERDIR=build/platform/java/jdk/jdk10 build/platform/java/jdk/jdk17
    }
    when ($JDK_REAL_VERSION == "8") {
        JDK_RESOURCE_PEERDIR=build/platform/java/jdk/jdk8 build/platform/java/jdk/jdk17
    }
}

# tag:java-specific
when ($JDK_REAL_VERSION == "17") {
    UBERJAR_RESOURCE_PEERDIR=build/platform/java/uberjar/uberjar17
}
when ($JDK_REAL_VERSION == "16") {
    UBERJAR_RESOURCE_PEERDIR=build/platform/java/uberjar/uberjar16
}
when ($JDK_REAL_VERSION == "15") {
    UBERJAR_RESOURCE_PEERDIR=build/platform/java/uberjar/uberjar15
}
when ($JDK_REAL_VERSION == "14") {
    UBERJAR_RESOURCE_PEERDIR=build/platform/java/uberjar/uberjar14
}
when ($JDK_REAL_VERSION == "13") {
    UBERJAR_RESOURCE_PEERDIR=build/platform/java/uberjar/uberjar13
}
when ($JDK_REAL_VERSION == "12") {
    UBERJAR_RESOURCE_PEERDIR=build/platform/java/uberjar/uberjar12
}
when ($JDK_REAL_VERSION == "11") {
    UBERJAR_RESOURCE_PEERDIR=build/platform/java/uberjar/uberjar11
}
when ($JDK_REAL_VERSION == "10") {
    UBERJAR_RESOURCE_PEERDIR=build/platform/java/uberjar/uberjar10
}
when ($JDK_REAL_VERSION == "8") {
    UBERJAR_RESOURCE_PEERDIR=build/platform/java/uberjar/uberjar8
}

# tag:java-specific
JAVAC_OPTS=
when ($USE_SYSTEM_JDK) {
    JDK_RESOURCE=$USE_SYSTEM_JDK
}
otherwise {
    when ($JDK_REAL_VERSION == "17") {
        JDK_RESOURCE=$JDK17_RESOURCE_GLOBAL
    }
    when ($JDK_REAL_VERSION == "16") {
        JDK_RESOURCE=$JDK16_RESOURCE_GLOBAL
    }
    when ($JDK_REAL_VERSION == "15") {
        JDK_RESOURCE=$JDK15_RESOURCE_GLOBAL
    }
    when ($JDK_REAL_VERSION == "14") {
        JDK_RESOURCE=$JDK14_RESOURCE_GLOBAL
    }
    when ($JDK_REAL_VERSION == "13") {
        JDK_RESOURCE=$JDK13_RESOURCE_GLOBAL
    }
    when ($JDK_REAL_VERSION == "12") {
        JDK_RESOURCE=$JDK12_RESOURCE_GLOBAL
    }
    when ($JDK_REAL_VERSION == "11") {
        JDK_RESOURCE=$JDK11_RESOURCE_GLOBAL
    }
    when ($JDK_REAL_VERSION == "10") {
        JDK_RESOURCE=$JDK10_RESOURCE_GLOBAL
    }
    when ($JDK_REAL_VERSION == "8") {
        JDK_RESOURCE=$JDK8_RESOURCE_GLOBAL
    }
}

# tag:java-specific
when (!$USE_SYSTEM_ERROR_PRONE) {
    when ($JDK_REAL_VERSION == "8" || $JDK_REAL_VERSION == "10") {
        ERROR_PRONE_VERSION=2.3.1
        ERROR_PRONE_PEERDIR=build/platform/java/error_prone/2.3.1
        ERROR_PRONE_RESOURCE=$ERROR_PRONE_2_3_1_RESOURCE_GLOBAL
    }
    elsewhen ($JDK_REAL_VERSION == "11" || $JDK_REAL_VERSION == "12" || $JDK_REAL_VERSION == "13" || $JDK_REAL_VERSION == "14" || $JDK_REAL_VERSION == "15" || $JDK_REAL_VERSION == "16") {
        ERROR_PRONE_VERSION=2.7.1
        ERROR_PRONE_PEERDIR=build/platform/java/error_prone/2.7.1
        ERROR_PRONE_RESOURCE=$ERROR_PRONE_2_7_1_RESOURCE_GLOBAL
    }
    elsewhen ($JDK_REAL_VERSION == "17") {
        ERROR_PRONE_VERSION=2.10.0
        ERROR_PRONE_PEERDIR=build/platform/java/error_prone/2.10.0
        ERROR_PRONE_RESOURCE=$ERROR_PRONE_2_10_0_RESOURCE_GLOBAL
    }
    otherwise {
        ERROR_PRONE_VERSION=2.7.1
        ERROR_PRONE_PEERDIR=build/platform/java/error_prone
        ERROR_PRONE_RESOURCE=$ERROR_PRONE_RESOURCE_GLOBAL
    }
}
otherwise {
    ERROR_PRONE_VERSION=2.7.1
    ERROR_PRONE_PEERDIR=build/platform/java/error_prone
    ERROR_PRONE_RESOURCE=$ERROR_PRONE_RESOURCE_GLOBAL
}

# tag:java-specific
when ($USE_SYSTEM_UBERJAR) {
    UBERJAR_RESOURCE=$USE_SYSTEM_UBERJAR
}
otherwise {
    when ($JDK_REAL_VERSION == "17") {
        UBERJAR_RESOURCE=$UBERJAR17_RESOURCE_GLOBAL
    }
    when ($JDK_REAL_VERSION == "16") {
        UBERJAR_RESOURCE=$UBERJAR16_RESOURCE_GLOBAL
    }
    when ($JDK_REAL_VERSION == "15") {
        UBERJAR_RESOURCE=$UBERJAR15_RESOURCE_GLOBAL
    }
    when ($JDK_REAL_VERSION == "14") {
        UBERJAR_RESOURCE=$UBERJAR14_RESOURCE_GLOBAL
    }
    when ($JDK_REAL_VERSION == "13") {
        UBERJAR_RESOURCE=$UBERJAR13_RESOURCE_GLOBAL
    }
    when ($JDK_REAL_VERSION == "12") {
        UBERJAR_RESOURCE=$UBERJAR12_RESOURCE_GLOBAL
    }
    when ($JDK_REAL_VERSION == "11") {
        UBERJAR_RESOURCE=$UBERJAR11_RESOURCE_GLOBAL
    }
    when ($JDK_REAL_VERSION == "10") {
        UBERJAR_RESOURCE=$UBERJAR10_RESOURCE_GLOBAL
    }
    when ($JDK_REAL_VERSION == "8") {
        UBERJAR_RESOURCE=$UBERJAR8_RESOURCE_GLOBAL
    }
}

# tag:java-specific
when ($JDK_REAL_VERSION == "17") {
    WITH_JDK_RESOURCE=$WITH_JDK17_RESOURCE_GLOBAL
}
when ($JDK_REAL_VERSION == "16") {
    WITH_JDK_RESOURCE=$WITH_JDK16_RESOURCE_GLOBAL
}
when ($JDK_REAL_VERSION == "15") {
    WITH_JDK_RESOURCE=$WITH_JDK15_RESOURCE_GLOBAL
}
when ($JDK_REAL_VERSION == "14") {
    WITH_JDK_RESOURCE=$WITH_JDK14_RESOURCE_GLOBAL
}
when ($JDK_REAL_VERSION == "13") {
    WITH_JDK_RESOURCE=$WITH_JDK13_RESOURCE_GLOBAL
}
when ($JDK_REAL_VERSION == "12") {
    WITH_JDK_RESOURCE=$WITH_JDK12_RESOURCE_GLOBAL
}
when ($JDK_REAL_VERSION == "11") {
    WITH_JDK_RESOURCE=$WITH_JDK11_RESOURCE_GLOBAL
}
when ($JDK_REAL_VERSION == "10") {
    WITH_JDK_RESOURCE=$WITH_JDK10_RESOURCE_GLOBAL
}
when ($JDK_REAL_VERSION == "8") {
    WITH_JDK_RESOURCE=$WITH_JDK8_RESOURCE_GLOBAL
}

# tag:java-specific
EXTERNAL_JAVA_JDK_RESOURCE=
EXTERNAL_JAVA_EXTRA_PEERDIR=
when ($USE_SYSTEM_JDK) {
    EXTERNAL_JAVA_EXTRA_PEERDIR=
    EXTERNAL_JAVA_JDK_RESOURCE=$USE_SYSTEM_JDK
}
elsewhen ($JDK_VERSION == "") {
    EXTERNAL_JAVA_JDK_RESOURCE=$JDK11_RESOURCE_GLOBAL
    EXTERNAL_JAVA_EXTRA_PEERDIR=build/platform/java/jdk/jdk11
}
otherwise {
    EXTERNAL_JAVA_JDK_RESOURCE=$JDK_RESOURCE
}
COMPILE_JAVA=${cwd:ARCADIA_BUILD_ROOT} $YMAKE_PYTHON ${input:"build/scripts/compile_java.py"} --javac-bin $EXTERNAL_JAVA_JDK_RESOURCE/bin/javac --jar-bin $JDK_RESOURCE/bin/jar $JAVA_VCS_MF_ARG $PACKAGE_PREFIX_ARGS --jar-output $TARGET --srcs-jar-output ${output;suf=-sources.jar:REALPRJNAME} $AUTO_INPUT DELIM $JAVAC_OPTS DELIM $MANAGED_PEERS_CLOSURE ${kv;hide:"p JV"} ${kv;hide:"pc light-blue"} ${kv;hide:"show_out"}
REAL_SWIG_DLL_JAR_CMD=$GENERATE_VCS_JAVA_INFO_NODEP && ${cwd:ARCADIA_BUILD_ROOT} $YMAKE_PYTHON ${input:"build/scripts/build_dll_and_java.py"} $JAVA_SWIG_DELIM $REAL_LINK_DYN_LIB $JAVA_SWIG_DELIM $COMPILE_JAVA $JAVA_SWIG_DELIM $AUTO_INPUT $JAVA_SWIG_DELIM $TARGET $JAVA_SWIG_DELIM ${output;suf=.jar:REALPRJNAME} $JAVA_SWIG_DELIM ${output;suf=-sources.jar:REALPRJNAME} $JAVA_SWIG_DELIM $ARCADIA_BUILD_ROOT $ARCADIA_ROOT

# tag:deprecated
### @usage: METAQUERY() #deprecated
###
### Project Definition - KIWI Meta query. (Objected)
###
### https://wiki.yandex-team.ru/robot/manual/kiwi/techdoc/design/metaquery/
module METAQUERY: _BASE_UNIT  {
    .ALL_INS_TO_OUT=yes
    .FINAL_TARGET=yes
    PRINT_MODULE_TYPE(METAQUERY $MODULE_PREFIX$REALPRJNAME)
}

ARGS_DELIM="MACRO_CALLS_DELIM"

SYSTEM_PROPERTIES_VALUE=
### @usage: SYSTEM_PROPERTIES([<Key Value>...] [<File Path>...])
###
### List of Key,Value pairs that will be available to test via System.getProperty().
### FILE means that parst should be read from file specifies as Path.
###
### Documentation: https://wiki.yandex-team.ru/yatool/test/
macro SYSTEM_PROPERTIES(Args...) {
    SET_APPEND(SYSTEM_PROPERTIES_VALUE $Args)
}

# tag:java-specific
JVM_ARGS_VALUE=
### @usage: JVM_ARGS(Args...)
###
### Arguments to run Java programs in tests.
###
### Documentation: https://wiki.yandex-team.ru/yatool/test/
macro JVM_ARGS(Args...) {
    SET_APPEND(JVM_ARGS_VALUE $Args)
}

# tag:java-specific
CHECK_JAVA_DEPS_VALUE=
### @usage: CHECK_JAVA_DEPS(<yes|no>)
###
### Check for different classes with duplicate name in classpath.
###
### Documentation: https://wiki.yandex-team.ru/yatool/test/
macro CHECK_JAVA_DEPS(Arg) {
    SET(CHECK_JAVA_DEPS_VALUE $Arg)
}

ERROR_PRONE_VALUE=
### @usage: USE_ERROR_PRONE()
###
### Use errorprone instead of javac for .java compilation.
macro USE_ERROR_PRONE() {
    SET(ERROR_PRONE_VALUE yes)
}

TEST_CWD_VALUE=
### @usage: TEST_CWD(path)
###
### Defines working directory for test runs. Often used in conjunction with DATA() macro.
### Is only used inside of the TEST modules.
###
### Documentation: https://wiki.yandex-team.ru/yatool/test/
macro TEST_CWD(Arg) {
    SET(TEST_CWD_VALUE $Arg)
}

# tag:java-specific
MAKE_UBERJAR_VALUE=
### @usage: UBERJAR()
###
### UBERJAR is a single all-in-one jar-archive that includes all its Java dependencies (reachable PEERDIR).
### It also supports shading classes inside the archive by moving them to a different package (similar to the maven-shade-plugin).
### Use UBERJAR inside JAVA_PROGRAM module.
###
### You can use the following macros to configure the archive:
### 1. UBERJAR_HIDING_PREFIX prefix for classes to shade (classes remain in their packages by default)
### 2. UBERJAR_HIDE_EXCLUDE_PATTERN exclude classes matching this patterns from shading (if enabled).
### 3. UBERJAR_PATH_EXCLUDE_PREFIX the prefix for classes that should not get into the jar archive (all classes are placed into the archive by default)
### 4. UBERJAR_MANIFEST_TRANSFORMER_MAIN add ManifestResourceTransformer class to uberjar processing and specify main-class
### 5. UBERJAR_MANIFEST_TRANSFORMER_ATTRIBUTE add ManifestResourceTransformer class to uberjar processing and specify some attribute
### 6. UBERJAR_APPENDING_TRANSFORMER add AppendingTransformer class to uberjar processing
### 7. UBERJAR_SERVICES_RESOURCE_TRANSFORMER add ServicesResourceTransformer class to uberjar processing
###
### Documentation: https://wiki.yandex-team.ru/yatool/java/
###
### @see: [JAVA_PROGRAM](#module_JAVA_PROGRAM), [UBERJAR_HIDING_PREFIX](#macro_UBERJAR_HIDING_PREFIX), [UBERJAR_HIDE_EXCLUDE_PATTERN](#macro_UBERJAR_HIDE_EXCLUDE_PATTERN), [UBERJAR_PATH_EXCLUDE_PREFIX](#macro_UBERJAR_PATH_EXCLUDE_PREFIX)
macro UBERJAR() {
    SET(MAKE_UBERJAR_VALUE yes)
}

# tag:java-specific
UBERJAR_PREFIX_VALUE=
UBERJAR_PREFIX_FLAG=
### @usage: UBERJAR_HIDING_PREFIX(Arg)
###
### Set prefix for classes to shade. All classes in UBERJAR will be moved into package prefixed with Arg.
### Classes remain in their packages by default.
###
### @see: [UBERJAR](#macro_UBERJAR)
macro UBERJAR_HIDING_PREFIX(Arg) {
    SET(UBERJAR_PREFIX_VALUE $Arg)
    SET(UBERJAR_PREFIX_FLAG ${pre=--shade-prefix :Arg})
}

# tag:java-specific
UBERJAR_HIDE_EXCLUDE_VALUE=
UBERJAR_HIDE_EXCLUDE_FLAGS=
### @usage: UBERJAR_HIDE_EXCLUDE_PATTERN(Args...)
###
### Exclude classes matching this patterns from shading (if enabled).
### Pattern may contain '*' and '**' globs.
### Shading is enabled for UBERJAR program using UBERJAR_HIDING_PREFIX macro. If this macro is not specified all classes are shaded.
###
### @see: [UBERJAR](#macro_UBERJAR), [UBERJAR_HIDING_PREFIX](#macro_UBERJAR_HIDING_PREFIX)
macro UBERJAR_HIDE_EXCLUDE_PATTERN(Args...) {
    SET_APPEND(UBERJAR_HIDE_EXCLUDE_VALUE $ARGS_DELIM $Args)
    SET_APPEND(UBERJAR_HIDE_EXCLUDE_FLAGS ${pre=--shade-exclude :Args})
}

# tag:java-specific
UBERJAR_PATH_EXCLUDES=
UBERJAR_PATH_EXCLUDE_VALUE=
### @usage: UBERJAR_PATH_EXCLUDE_PREFIX(Args...)
###
### Exclude classes matching this patterns from UBERJAR.
### By default all dependencies of UBERJAR program will lend in a .jar archive.
###
### @see: [UBERJAR](#macro_UBERJAR)
macro UBERJAR_PATH_EXCLUDE_PREFIX(Args...) {
    SET_APPEND(UBERJAR_PATH_EXCLUDE_VALUE $ARGS_DELIM $Args)
    SET_APPEND(UBERJAR_PATH_EXCLUDES ${pre=--uber-exclude :Args})
}

# tag:java-specific
UBERJAR_MANIFEST_TRANSFORMER_MAIN_VALUE=
UBERJAR_MANIFEST_TRANSFORMER_MAIN_FLAG=
### @usage: UBERJAR_MANIFEST_TRANSFORMER_MAIN(Main)
###
### Transform manifest.mf for UBERJAR() java programs, set main-class attribute
###
### @see: [UBERJAR](#macro_UBERJAR)
macro UBERJAR_MANIFEST_TRANSFORMER_MAIN(Main) {
    SET(UBERJAR_MANIFEST_TRANSFORMER_MAIN_VALUE $Main)
    SET(UBERJAR_MANIFEST_TRANSFORMER_MAIN_FLAG --manifest-main $Main)
}

# tag:java-specific
UBERJAR_MANIFEST_TRANSFORMER_ATTRIBUTE_VALUE=
UBERJAR_MANIFEST_TRANSFORMER_ATTRIBUTE_FLAGS=
### @usage: UBERJAR_MANIFEST_TRANSFORMER_ATTRIBUTE(Key, Value)
###
### Transform manifest.mf for UBERJAR() java programs, set attribute
###
### @see: [UBERJAR](#macro_UBERJAR)
macro UBERJAR_MANIFEST_TRANSFORMER_ATTRIBUTE(Key, Value) {
    SET_APPEND(UBERJAR_MANIFEST_TRANSFORMER_ATTRIBUTE_VALUE $ARGS_DELIM $Key : $Value)
    SET_APPEND(UBERJAR_MANIFEST_TRANSFORMER_ATTRIBUTE_FLAGS --manifest-attribute ${Key}:${Value})
}

# tag:java-specific
UBERJAR_APPENDING_TRANSFORMER_VALUE=
UBERJAR_APPENDING_TRANSFORMER_FLAGS=
### @usage: UBERJAR_APPENDING_TRANSFORMER(Resource)
###
### Add AppendingTransformer for UBERJAR() java programs
###
### Parameters:
### - Resource - Resource name
###
### @see: [UBERJAR](#macro_UBERJAR)
macro UBERJAR_APPENDING_TRANSFORMER(Resources...) {
    SET_APPEND(UBERJAR_APPENDING_TRANSFORMER_VALUE $ARGS_DELIM $Resources)
    SET_APPEND(UBERJAR_APPENDING_TRANSFORMER_FLAGS ${pre=--append-transformer :Resources})
}

# tag:java-specific
UBERJAR_SERVICES_RESOURCE_TRANSFORMER_VALUE=
UBERJAR_SERVICES_RESOURCE_TRANSFORMER_FLAG=
### @usage: UBERJAR_SERVICES_RESOURCE_TRANSFORMER()
###
### Add ServicesResourceTransformer for UBERJAR() java programs
###
### @see: [UBERJAR](#macro_UBERJAR)
macro UBERJAR_SERVICES_RESOURCE_TRANSFORMER() {
    SET(UBERJAR_SERVICES_RESOURCE_TRANSFORMER_VALUE yes)
    SET(UBERJAR_SERVICES_RESOURCE_TRANSFORMER_FLAG --service-transformer)
}

# tag:idea-specific
IDEA_EXCLUDE_DIRS_VALUE=
### @usage: IDEA_EXCLUDE_DIRS(<excluded dirs>)
###
### Exclude specified directories from an idea project generated by ya ide idea
### Have no effect on regular build.
macro IDEA_EXCLUDE_DIRS(Args...) {
    SET_APPEND(IDEA_EXCLUDE_DIRS_VALUE $Args)
}

# tag:idea-specific
IDEA_RESOURCE_DIRS_VALUE=
### @usage: IDEA_RESOURCE_DIRS(<additional dirs>)
###
### Set specified resource directories in an idea project generated by ya ide idea
### Have no effect on regular build.
macro IDEA_RESOURCE_DIRS(Args...) {
    SET_APPEND(IDEA_RESOURCE_DIRS_VALUE $Args)
}

# tag:idea-specific
IDEA_MODULE_NAME_VALUE=
### @usage: IDEA_MODULE_NAME(module_name)
###
### Set module name in an idea project generated by ya ide idea
### Have no effect on regular build.
macro IDEA_MODULE_NAME(Name) {
    SET(IDEA_MODULE_NAME_VALUE $Name)
}

# tag:java-specific
JAVAC_FLAGS_VALUE=
### @usage: JAVAC_FLAGS(Args...)
###
### Set additional Java compilation flags.
macro JAVAC_FLAGS(Args...) {
    SET_APPEND(JAVAC_OPTS $Args)
    SET_APPEND(JAVAC_FLAGS_VALUE $ARGS_DELIM $Args)
}

# tag:java-specific
ENABLE_PREVIEW_VALUE=
### @usage: ENABLE_PREVIEW()
###
### Enable java preview features.
macro ENABLE_PREVIEW() {
    SET_APPEND(JVM_ARGS_VALUE --enable-preview)
    SET_APPEND(JAVAC_OPTS --enable-preview --release $JDK_REAL_VERSION)
    SET_APPEND(JAVAC_FLAGS_VALUE --enable-preview --release $JDK_REAL_VERSION)
    SET(ENABLE_PREVIEW_VALUE yes)
}

# tag:java-specific
SAVE_JAVAC_GENERATED_SRCS=
SAVE_JAVAC_GENERATED_SRCS_DIR=
SAVE_JAVAC_GENERATED_SRCS_TAR=
when ($SAVE_JAVAC_GENERATED_SRCS) {
    SAVE_JAVAC_GENERATED_SRCS_DIR=${BINDIR}/__javac_generated_srcs__
    SAVE_JAVAC_GENERATED_SRCS_TAR=${BINDIR}/javac_generated.tar
    JAVAC_FLAGS_VALUE+=-s $SAVE_JAVAC_GENERATED_SRCS_DIR
}

# tag:java-specific
MAVEN_GROUP_ID_VALUE=
### @usage: MAVEN_GROUP_ID(group_id_for_maven_export)
###
### Set maven export group id for JAVA_PROGRAM() and JAVA_LIBRARY().
### Have no effect on regular build.
macro MAVEN_GROUP_ID(Arg) {
    SET(MAVEN_GROUP_ID_VALUE $Arg)
}

# tag:java-specific
ANNOTATION_PROCESSOR_VALUE=
### @usage: ANNOTATION_PROCESSOR(processors...)
###
### The macro is in development.
### Used to specify annotation processors to build JAVA_PROGRAM() and JAVA_LIBRARY().
macro ANNOTATION_PROCESSOR(Args...) {
    SET_APPEND(ANNOTATION_PROCESSOR_VALUE $ARGS_DELIM $Args)
}

EXCLUDE_VALUE=
### EXCLUDE(prefixes)
###
### The macro is in development.
### Specifies which libraries should be excluded from the classpath.
macro EXCLUDE(Args...) {
    SET_APPEND(EXCLUDE_VALUE $ARGS_DELIM $Args)
}

# tag:java-specific
JAVA_SRCS_VALUE=
### @usage: JAVA_SRCS(srcs)
###
### Specify java source files and resources. A macro can be contained in any of four java modules.
### Keywords:
### 1. X SRCDIR - specify the directory x is performed relatively to search the source code for these patterns. If there is no SRCDIR, the source will be searched relative to the module directory.
### 2. PACKAGE_PREFIX x - use if source paths relative to the SRCDIR does not coincide with the full class names. For example, if all sources of module are in the same package, you can create a directory package/name , and just put the source code in the SRCDIR and specify PACKAGE_PREFIX package.name.
###
### @example:
###  - example/ya.make
###
###        JAVA_PROGRAM()
###            JAVA_SRCS(SRCDIR src/main/java **/*)
###        END()
###
###  - example/src/main/java/ru/yandex/example/HelloWorld.java
###
###        package ru.yandex.example;
###        public class HelloWorld {
###             public static void main(String[] args) {
###                 System.out.println("Hello, World!");
###             }
###        }
###
### Documentation: https://wiki.yandex-team.ru/yatool/java/#javasrcs
macro JAVA_SRCS(Args...) {
    SET_APPEND(JAVA_SRCS_VALUE $ARGS_DELIM $Args)
}

# tag:java-specific
JAVA_ADD_DLLS_VALUE=no
macro ADD_DLLS_TO_JAR() {
    SET(JAVA_ADD_DLLS_VALUE yes)
}

# tag:java-specific
MANAGED_PEERS=
MANAGED_PEERS_CLOSURE=
RUN_JAVA_PROGRAM_MANAGED=
MANAGEABLE_PEERS_ROOTS=contrib/java
HAS_MANAGEABLE_PEERS=no
PROPAGATES_MANAGEABLE_PEERS=no
YMAKE_CLASSPATH_CHECKS=yes
# All items of this list must be PEERS, GHOST PEERS or TOOLS of the test module or module itself.
# All items of this list must has at least one of HAS_MANAGEABLE_PEERS or PROPAGATES_MANAGEABLE_PEERS flags set yes.
# This variable is used by JUnit tests but not TestNG.
TEST_CLASSPATH_VALUE=
# Calculated and replaced by ymake can be used in DART DATA
TEST_CLASSPATH_MANAGED=

# tag:java-specific
DEPENDENCY_MANAGEMENT_VALUE=
### @usage: DEPENDENCY_MANAGEMENT(path/to/lib1 path/to/lib2 ...)
###
### Lock version of the library from the contrib/java at some point, so that all unversioned PEERDIRs to this library refer to the specified version.
###
### For example, if the module has PEERDIR (contrib/java/junit/junit), and
###   1. specifies DEPENDENCY_MANAGEMENT(contrib/java/junit/junit/4.12),
###      the PEERDIR is automatically replaced by contrib/java/junit/junit/4.12;
###   2. doesn't specify DEPENDENCY_MANAGEMENT, PEERDIR automatically replaced
###      with the default from contrib/java/junit/junit/ya.make.
###      These defaults are always there and are supported by maven-import, which puts
###      there the maximum version available in contrib/java.
###
### The property is transitive. That is, if module A PEERDIRs module B, and B has PEERDIR(contrib/java/junit/junit), and this junit was replaced by junit-4.12, then junit-4.12 will come to A through B.
###
### If some module has both DEPENDENCY_MANAGEMENT(contrib/java/junit/junit/4.12) and PERDIR(contrib/java/junit/junit/4.11), the PEERDIR wins.
###
### Documentation: https://wiki.yandex-team.ru/yatool/java/
macro DEPENDENCY_MANAGEMENT(Args...) {
    SET_APPEND(DEPENDENCY_MANAGEMENT_VALUE $ARGS_DELIM $Args)
    _GHOST_PEERDIR($Args)
}

# tag:java-specific
WITH_JDK_VALUE=
### @usage: WITH_JDK()
###
### Add directory with JDK to JAVA_PROGRAM output
macro WITH_JDK() {
    SET(WITH_JDK_VALUE yes)
}

# tag:kotlin-specific
WITH_KOTLIN_VALUE=
### @usage: WITH_KOTLIN()
###
### Compile kotlin source code in this java module
macro WITH_KOTLIN() {
    SET(WITH_KOTLIN_VALUE yes)
}

# tag:java-specific
WITH_GROOVY_VALUE=
### @usage: WITH_GROOVY()
###
### Compile groovy source code in this java module
macro WITH_GROOVY() {
    SET(WITH_GROOVY_VALUE yes)
}

# tag:kotlin-specific
KOTLINC_FLAGS_VALUE=-Xjvm-default=all
### @usage: KOTLINC_FLAGS(-flags)
###
### Set additional Kotlin compilation flags.
macro KOTLINC_FLAGS(Args...) {
    SET_APPEND(KOTLINC_OPTS_VALUE $Args)
}

# tag:kotlin-specific
WITH_KOTLINC_PLUGIN_ALLOPEN=
### @usage: WITH_KOTLINC_ALLOPEN(-flags)
###
### Enable allopen kotlin compiler plugin https://kotlinlang.org/docs/all-open-plugin.html
macro WITH_KOTLINC_ALLOPEN(Options...) {
    SET_APPEND(KOTLINC_OPTS_VALUE ${pre=-P plugin\:org.jetbrains.kotlin.allopen\::Options})
    SET(WITH_KOTLINC_PLUGIN_ALLOPEN yes)
}

# tag:kotlin-specific
WITH_KOTLINC_PLUGIN_NOARG=
### @usage: WITH_KOTLINC_NOARG(-flags)
###
### Enable noarg kotlin compiler plugin https://kotlinlang.org/docs/no-arg-plugin.html
macro WITH_KOTLINC_NOARG(Options...) {
    SET_APPEND(KOTLINC_OPTS_VALUE ${pre=-P plugin\:org.jetbrains.kotlin.noarg\::Options})
    SET(WITH_KOTLINC_PLUGIN_NOARG yes)
}

# tag:kotlin-specific
KOTLIN_VERSION=1.6.10
KOTLIN_BOM_FILE=${ARCADIA_ROOT}/contrib/java/org/jetbrains/kotlin/kotlin-bom/1.6.10/ya.dependency_management.inc
GROOVY_VERSION=3.0.5

# tag:java-specific
DIRECT_DEPS_ONLY_VALUE=
### @usage: DIRECT_DEPS_ONLY
###
### Add direct PEERDIR's only in java compile classpath
macro DIRECT_DEPS_ONLY() {
    SET(DIRECT_DEPS_ONLY_VALUE yes)
}

# tag:java-specific
JAVA_EXTERNAL_DEPENDENCIES_VALUE=
### @usage: JAVA_EXTERNAL_DEPENDENCIES(file1 file2 ...)
###
### Add non-source java external build dependency (like lombok config file)
macro JAVA_EXTERNAL_DEPENDENCIES(Args...) {
    SET_APPEND(JAVA_EXTERNAL_DEPENDENCIES_VALUE $Args)
}

# tag:java-specific
### @usage _JAVA_PLACEHOLDER #internal
### The base module for all Java modules. Defines common properties and dependencies.
module _JAVA_PLACEHOLDER: _BASE_UNIT  {
    .CMD=TOUCH_JAVA_UNIT
    .FINAL_TARGET=yes
    .ALLOWED=DEPENDENCY_MANAGEMENT EXCLUDE
    .ALIASES=RUN_JAVA_PROGRAM=_RUN_JBUILD_PROGRAM
    HAS_MANAGEABLE_PEERS=yes
    DYNAMIC_LINK=yes
    PEERDIR_TAGS=JAVA_PROTO JAVA_FBS JAVA_IDL JAR_COMPILATION
    PEERDIR(build/platform/java/jdk)
    PEERDIR+=$JDK_RESOURCE_PEERDIR
    when($MAKE_UBERJAR_VALUE) {
        PEERDIR+=build/platform/java/uberjar
        PEERDIR+=$UBERJAR_RESOURCE_PEERDIR
    }
    when($ERROR_PRONE_VALUE) {
        # Jbuild assumes hardcoded resource name https://a.yandex-team.ru/arc_vcs/devtools/ya/jbuild/gen/consts/__init__.py?rev=1739368ed5aaa585b8300b84e5dea708a2bedd3a#L130
        # adding default peerdir as a hack to make `ya ide idea` and `ya maven-export` work for now
        PEERDIR+=build/platform/java/error_prone
        PEERDIR+=$ERROR_PRONE_PEERDIR
    }
    # in the ideal world this statement must be under condition bellow
    DEPENDENCY_MANAGEMENT(contrib/java/org/jetbrains/kotlin/kotlin-stdlib-jdk8/${KOTLIN_VERSION})
    when($WITH_KOTLIN_VALUE) {
        PEERDIR+=build/platform/java/kotlin contrib/java/org/jetbrains/kotlin/kotlin-stdlib-jdk8
        when($WITH_KOTLINC_PLUGIN_ALLOPEN) {
            KOTLINC_OPTS_VALUE+=-Xplugin=${KOTLIN_COMPILER_RESOURCE_GLOBAL}/plugins/kotlin-allopen-plugin.jar
        }
        when($WITH_KOTLINC_PLUGIN_NOARG) {
            KOTLINC_OPTS_VALUE+=-Xplugin=${KOTLIN_COMPILER_RESOURCE_GLOBAL}/plugins/kotlin-noarg-plugin.jar
        }
    }
    when($WITH_GROOVY_VALUE) {
        PEERDIR+=build/platform/java/groovy contrib/java/org/codehaus/groovy/groovy/${GROOVY_VERSION}
    }

    when($ERROR_PRONE_VALUE && $JDK_REAL_VERSION == "16") {
        JAVAC_FLAGS_VALUE+=$ERROR_PRONE_JDK16_ADD_OPENS
    }

    when($ERROR_PRONE_VALUE && $ERROR_PRONE_VERSION == "2.7.1") {
        JAVAC_FLAGS_VALUE+=$ERROR_PRONE_2_7_1_FORCED_OPTS
    }

    JAVA_DEPENDENCIES_CONFIGURATION(FORBID_DEFAULT_VERSIONS)
    DISABLE(NEED_PLATFORM_PEERDIRS)
    NO_PLATFORM()
    JAVA_MODULE()

    # flatbuffers-java
    DEPENDENCY_MANAGEMENT(contrib/java/com/google/flatbuffers/flatbuffers-java/${JAVA_FLATBUFFERS_VERSION})
    CHECK_DEPENDENT_DIRS(DENY PEERDIRS contrib/java/com/google/flatbuffers/flatbuffers-java EXCEPT contrib/java/com/google/flatbuffers/flatbuffers-java/${JAVA_FLATBUFFERS_VERSION})

    # protobuf-java
    DEPENDENCY_MANAGEMENT(contrib/java/com/google/protobuf/protobuf-java/${JAVA_PROTO_RUNTIME_VERSION})
    CHECK_DEPENDENT_DIRS(DENY PEERDIRS contrib/java/com/google/protobuf/protobuf-java EXCEPT contrib/java/com/google/protobuf/protobuf-java/${JAVA_PROTO_RUNTIME_VERSION})

    # protobuf-javalite
    DEPENDENCY_MANAGEMENT(contrib/java/com/google/protobuf/protobuf-javalite/${JAVA_PROTO_RUNTIME_VERSION})
    CHECK_DEPENDENT_DIRS(DENY PEERDIRS contrib/java/com/google/protobuf/protobuf-javalite EXCEPT contrib/java/com/google/protobuf/protobuf-javalite/${JAVA_PROTO_RUNTIME_VERSION})

    # protobuf-java-util
    DEPENDENCY_MANAGEMENT(contrib/java/com/google/protobuf/protobuf-java-util/${JAVA_PROTO_RUNTIME_VERSION})
    CHECK_DEPENDENT_DIRS(DENY PEERDIRS contrib/java/com/google/protobuf/protobuf-java-util EXCEPT contrib/java/com/google/protobuf/protobuf-java-util/${JAVA_PROTO_RUNTIME_VERSION})
    SET(MODULE_LANG JAVA)
}

# tag:java-specific
JAVA_CLASSPATH_CMD_TYPE_VALUE=

# tag:java-specific
### @usage:TEST_JAVA_CLASSPATH_CMD_TYPE(Type)
### Available types: MANIFEST(default), COMMAND_FILE, LIST
### Method for passing a classpath value to a java command line
### MANIFEST via empty jar file with manifest that contains Class-Path attribute
### COMMAND_FILE via @command_file
### LIST via flat args
macro TEST_JAVA_CLASSPATH_CMD_TYPE(Type) {
    SET(JAVA_CLASSPATH_CMD_TYPE_VALUE $Type)
}

# tag:java-specific
IGNORE_JAVA_DEPENDENCIES_CONFIGURATION=no
JAVA_DEPENDENCIES_CONFIGURATION_VALUE=

# tag:java-specific
### @usage JAVA_DEPENDENCIES_CONFIGURATION(Vetos...)
### Validate contrib/java dependencies
### Valid arguments
### FORBID_DIRECT_PEERDIRS - fail when module have direct PEERDIR (with version) (non-transitive)
### FORBID_DEFAULT_VERSIONS - fail when module have PEERDIR to library with default (last) version (transitive)
### FORBID_CONFLICT - fail when module have resolved without DEPENDENCY_MANAGEMENT version conflict (transitive)
### FORBID_CONFLICT_DM - fail when module have resolved with DEPENDENCY_MANAGEMENT version conflict (transitive)
### FORBID_CONFLICT_DM_RECENT - like FORBID_CONFLICT_DM but fail only when dependency have more recent version than specified in DEPENDENCY_MANAGEMENT
### REQUIRE_DM - all dependencies must be specified in DEPENDENCY_MANAGEMENT (transitive)
macro JAVA_DEPENDENCIES_CONFIGURATION(Args...) {
    SET_APPEND(JAVA_DEPENDENCIES_CONFIGURATION_VALUE $Args)
}

# tag:java-specific
# TODO(DEVTOOLS-6901): remove this variable when there are no more references to it in jbuild
JAVA_FORBIDDEN_LIBRARIES_VALUE=

# tag:java-specific
JAR_INCLUDE_FILTER_VALUE=
JAR_EXCLUDE_FILTER_VALUE=

# tag:java-specific
### @usage:JAR_INCLUDE(Filters...)
### Filter .jar file content: keep only matched files
### * and ** patterns are supported (like JAVA_SRCS)
macro JAR_INCLUDE(Filters...) {
    SET_APPEND(JAR_INCLUDE_FILTER_VALUE $Filters)
}

# tag:java-specific
### @usage:JAR_EXCLUDE(Filters...)
### Filter .jar file content: remove matched files
### * and ** patterns are supported (like JAVA_SRCS)
macro JAR_EXCLUDE(Filters...) {
    SET_APPEND(JAR_EXCLUDE_FILTER_VALUE $Filters)
}

# tag:sandbox-specific
### @usage: SANDBOX_TASK([Name])
###
### Multimodule describing Sandbox task (Python code that can be executed by Sandbox system).
###
### When being a final target, this multimodule builds Sandbox binary task. It may PEERDIR other SANDBOX_TASKs as libraries.
### The final artifact is provided when SANDBOX_TASK is referred to by DEPENDS and BUNDLE macros.
### As PEERDIR target, it works like regular PY2_LIBRARY with predefined dependencies on Sandbox SDK to allow code reuse among SANDBOX_TASKs.
###
### Currently Sandbox supports only Python 2.x, so both variants will be compatible only with Python 2.x modules
### and will select multimodule variants accordingly.
###
### Documentation: https://wiki.yandex-team.ru/sandbox/tasks/binary
multimodule SANDBOX_TASK {
    module SB_TASK_BIN: _PY2_PROGRAM {
        PY_MAIN(sandbox.taskbox.binary)
        PEERDIR(sandbox/bin sandbox/sdk2 sandbox/sandboxsdk sandbox/taskbox/worker)
        SET_APPEND(NO_CHECK_IMPORTS_FOR_VALUE api.*)
        SET_APPEND(NO_CHECK_IMPORTS_FOR_VALUE kernel.*)
        SET_APPEND(NO_CHECK_IMPORTS_FOR_VALUE library.*)
        SET_APPEND(NO_CHECK_IMPORTS_FOR_VALUE sky*)
        REGISTER_SANDBOX_IMPORT(${MODDIR})
        when ($FAIL_PY2 == "yes") {
            _OK=no
        }
        otherwise {
            PEERDIR+=build/rules/py2_deprecation
        }

        ASSERT(_OK You are using deprecated Python2-only code (SANDBOX_TASK). Please consider rewriting to 2/3-compatible code.)
    }
    module PY2: PY2_LIBRARY {
        PEERDIR(sandbox/sdk2 sandbox/sandboxsdk)
        REGISTER_SANDBOX_IMPORT(${MODDIR})
    }
}

# tag:sandbox-specific
multimodule SANDBOX_PY23_TASK {
    module SB_TASK_BIN: _PY2_PROGRAM {
        PY_MAIN(sandbox.taskbox.binary)
        PEERDIR(sandbox/bin sandbox/sdk2 sandbox/sandboxsdk sandbox/taskbox/worker)
        SET_APPEND(NO_CHECK_IMPORTS_FOR_VALUE api.*)
        SET_APPEND(NO_CHECK_IMPORTS_FOR_VALUE kernel.*)
        SET_APPEND(NO_CHECK_IMPORTS_FOR_VALUE library.*)
        SET_APPEND(NO_CHECK_IMPORTS_FOR_VALUE sky*)
        REGISTER_SANDBOX_IMPORT(${MODDIR})
    }
    module PY2: PY2_LIBRARY {
        PEERDIR(sandbox/sdk2 sandbox/sandboxsdk)
        REGISTER_SANDBOX_IMPORT(${MODDIR})
        OBJ_SUF=.py2
        RUN_CYTHON_SCRIPT=$YMAKE_PYTHON $CYTHON_SCRIPT
        PYTHON_TYPE_FOR_CYTHON=PY2
    }
    module PY3: PY3_LIBRARY {
        when ($MSVC == "yes" || $CYGWIN == "yes") {
            MODULE_PREFIX=py3
        }
        otherwise {
             MODULE_PREFIX=libpy3
        }
        OBJ_SUF=.py3
        RUN_CYTHON_SCRIPT=$YMAKE_PYTHON $CYTHON_SCRIPT
        PYTHON_TYPE_FOR_CYTHON=PY2
        PEERDIR(sandbox/sdk2)
        REGISTER_SANDBOX_IMPORT(${MODDIR})
    }
}

# tag:sandbox-specific
### @usage: SANDBOX_PY3_TASK([Name])
###
### Multimodule describing Sandbox task (Python3 code that can be executed by Sandbox system).
###
### When being a final target, this multimodule builds Sandbox binary task. It may PEERDIR other SANDBOX_PY3_TASKs as libraries.
### The final artifact is provided when SANDBOX_PY3_TASK is referred to by DEPENDS and BUNDLE macros.
### As PEERDIR target, it works like regular PY3_LIBRARY with predefined dependencies on Sandbox SDK to allow code reuse among SANDBOX_PY3_TASKs.
###
### Currently Sandbox supports Python 3.x only in binary tasks, both variants will be compatible only with Python 3.x and py23 libraries
### and will select multimodule variants accordingly.
###
### Documentation: https://wiki.yandex-team.ru/sandbox/tasks/binary
multimodule SANDBOX_PY3_TASK {
    module SB_TASK_BIN: PY3_PROGRAM_BIN {
        PY_MAIN(sandbox.taskbox.binary)
        PEERDIR(sandbox/bin sandbox/sdk2 sandbox/taskbox/worker)
        SET_APPEND(NO_CHECK_IMPORTS_FOR_VALUE api.*)
        SET_APPEND(NO_CHECK_IMPORTS_FOR_VALUE kernel.*)
        SET_APPEND(NO_CHECK_IMPORTS_FOR_VALUE library.*)
        SET_APPEND(NO_CHECK_IMPORTS_FOR_VALUE sky*)
        REGISTER_SANDBOX_IMPORT(${MODDIR})
    }
    module PY3: PY3_LIBRARY {
        PEERDIR(sandbox/sdk2)
        REGISTER_SANDBOX_IMPORT(${MODDIR})
    }
}

# tag:python-specific tag:internal
NO_PYTHON_INCLS=no
### @usage: NO_PYTHON_INCLUDES() # internal
###
### Disable dependencies on libraries providing Python headers.
### This is only used in Python libraries themselves to avoid PEERDIR loops.
macro NO_PYTHON_INCLUDES() {
    ENABLE(NO_PYTHON_INCLS)
}

# tag:python-specific
### @usage: PYTHON2_ADDINCL()
###
### This macro adds include path for Python headers (Python 2.x variant) without PEERDIR.
### This should be used in 2 cases only:
### - In PY2MODULE since it compiles into .so and uses external Python runtime;
### - In system Python libraries themselves since proper PEERDIR there may create a loop;
### In all other cases use USE_PYTHON2 macro instead.
###
### Never use this macro in PY2_PROGRAM, PY2_LIBRARY and PY23_LIBRARY: they have everything needed by default.
###
### Documentation: https://wiki.yandex-team.ru/devtools/commandsandvars/py_srcs
macro PYTHON2_ADDINCL() {
    _PYTHON_ADDINCL()
    SET(MODULE_TAG PY2_NATIVE)
    SET(PEERDIR_TAGS CPP_PROTO CPP_FBS PY2_NATIVE YQL_UDF_STATIC __EMPTY__ DLL_LIB)
}

# tag:python-specific tag:internal
### @usage: _ARCADIA_PYTHON_ADDINCL()  # internal
### This macro sets up Python headers for modules with Arcadia python (e.g. PY2_LIBRARY) and configures module as Python 2.x.
macro _ARCADIA_PYTHON_ADDINCL() {
    _PYTHON_ADDINCL()
    SET(MODULE_TAG PY2)
    SET(PEERDIR_TAGS PY2 PY2_NATIVE PY_PROTO PY2_FBS YQL_UDF_STATIC __EMPTY__ DLL_LIB)
}

# tag:python-specific tag:internal
### @usage: _PYTHON_ADDINCL()  # internal
### This macro sets up Python 2.x headers for both Arcadia and non-Arcadia python.
macro _PYTHON_ADDINCL() {
    SET(PYTHON2 yes)
    SET(PYTHON3 no)
    when ($USE_ARCADIA_PYTHON == "yes") {
        ADDINCL+=GLOBAL contrib/libs/python/Include
        CFLAGS+=-DARCADIA_PYTHON_UNICODE_SIZE=$ARCADIA_PYTHON_UNICODE_SIZE
    }
    otherwise {
        when ($USE_SYSTEM_PYTHON) {
            PEERDIR+=build/platform/python
        }
        otherwise {
            CFLAGS+=$PYTHON_INCLUDE
        }
    }
}

# tag:python-specific
### @usage: PYTHON3_ADDINCL()
###
### This macro adds include path for Python headers (Python 3.x variant).
### This should be used in 2 cases only:
### - In PY2MODULE since it compiles into .so and uses external Python runtime;
### - In system Python libraries themselves since peerdir there may create a loop;
### In all other cases use USE_PYTHON3() macro instead.
###
### Never use this macro in PY3_PROGRAM and PY3_LIBRARY and PY23_LIBRARY: they have everything by default.
###
### Documentation: https://wiki.yandex-team.ru/devtools/commandsandvars/py_srcs
macro PYTHON3_ADDINCL() {
    _PYTHON3_ADDINCL()
    SET(MODULE_TAG PY3_NATIVE)
    SET(PEERDIR_TAGS CPP_PROTO CPP_FBS PY3_NATIVE YQL_UDF_STATIC __EMPTY__ DLL_LIB)
}

# tag:python-specific tag:internal
### @usage: _ARCADIA_PYTHON3_ADDINCL()  # internal
###
### This macro sets up Python3 headers for modules with Arcadia python (e.g. PY3_LIBRARY) and configures module as Python 3.x.
macro _ARCADIA_PYTHON3_ADDINCL() {
    _PYTHON3_ADDINCL()
    SET(MODULE_TAG PY3)
    SET(MODULE_LANG PY3)
    SET(PEERDIR_TAGS PY3 PY3_BIN_LIB PY3TEST_LIBRARY PY3_NATIVE PY3_PROTO PY3_FBS PY3_SSQLS YQL_UDF_STATIC __EMPTY__ DLL_LIB)
}

# tag:python-specific  tag:internal
### @usage: _PYTHON_ADDINCL()  # internal
###
### This macro sets up Python 3.x headers for both Arcadia and non-Arcadia python.
macro _PYTHON3_ADDINCL() {
    SET(PYTHON3 yes)
    SET(PYTHON2 no)
    when ($USE_ARCADIA_PYTHON == "yes") {
        CFLAGS+=-DUSE_PYTHON3
        ADDINCL+=GLOBAL contrib/libs/python/Include
    }
    otherwise {
        when ($USE_SYSTEM_PYTHON) {
            PEERDIR+=build/platform/python
        }
        otherwise {
            CFLAGS+=$PYTHON_INCLUDE
        }
    }
}

# tag:python-specific
### @usage: USE_PYTHON2()
###
### This adds Python 2.x runtime library to your LIBRARY and makes it Python2-compatible.
### Compatibility means proper PEERDIRs, ADDINCLs and variant selection on PEERDIRs to multimodules.
###
### If you'd like to use #include <Python.h> with Python2 specify USE_PYTHON2 or better make it PY2_LIBRARY.
### If you'd like to use #include <Python.h> with Python3 specify USE_PYTHON3 or better make it PY3_LIBRARY.
### If you'd like to use #include <Python.h> with both Python2 and Python3 convert your LIBRARY to PY23_LIBRARY.
###
### @see: [PY2_LIBRARY](#module_PY2_LIBRARY), [PY3_LIBRARY](#module_PY3_LIBRARY), [PY23_LIBRARY](#multimodule_PY23_LIBRARY)
macro USE_PYTHON2() {
    _ARCADIA_PYTHON_ADDINCL()
    SET(PEERDIR_TAGS PY2 PY2_NATIVE CPP_PROTO CPP_FBS YQL_UDF_STATIC __EMPTY__ DLL_LIB)
    PEERDIR(contrib/libs/python)
}

# tag:python-specific
### @usage: USE_PYTHON3()
###
### This adds Python3 library to your LIBRARY and makes it Python3-compatible.
### Compatibility means proper PEERDIRs, ADDINCLs and variant selection on PEERDIRs to multimodules.
###
### If you'd like to use #include <Python.h> with Python3 specify USE_PYTHON3 or better make it PY3_LIBRARY.
### If you'd like to use #include <Python.h> with Python2 specify USE_PYTHON2 or better make it PY2_LIBRARY.
### If you'd like to use #include <Python.h> with both Python2 and Python3 convert your LIBRARY to PY23_LIBRARY.
###
### @see: [PY2_LIBRARY](#module_PY2_LIBRARY), [PY3_LIBRARY](#module_PY3_LIBRARY), [PY23_LIBRARY](#multimodule_PY23_LIBRARY)
macro USE_PYTHON3() {
    _ARCADIA_PYTHON3_ADDINCL()
    SET(PEERDIR_TAGS PY3 PY3_BIN_LIB PY3TEST_LIBRARY PY3_NATIVE CPP_PROTO CPP_FBS YQL_UDF_STATIC __EMPTY__ DLL_LIB)
    PEERDIR(contrib/libs/python)

    when ($USE_ARCADIA_PYTHON == "yes") {
        PEERDIR+=library/python/runtime_py3
    }
}

# tag:python-specific
when ($PERL_DEFAULT_PEERDIR == "yes") {
    when (($PERLXS == "yes") || ($PERLXSCPP == "yes") || ($USE_PERL == "yes")) {
        PEERDIR+=build/platform/perl
    }
}

# tag:perl-specific
### @usage: USE_PERL_LIB()
### Add dependency on Perl to your LIBRARY
macro USE_PERL_LIB() {
    PEERDIR(build/platform/perl)
}

# tag:perl-specific
### @usage: USE_PERL_514_LIB()
### Add dependency on Perl 5.14 to your LIBRARY
macro USE_PERL_514_LIB() {
    SET(PERL_SDK ubuntu-12)
    SET(PERL_DEFAULT_PEERDIR no)
    PEERDIR(build/platform/perl/5.14)
}

# tag:perl-specific
### @usage: ADD_PERL_MODULE(Dir ModuleName)
### Add dependency on specified Perl module to the library
macro ADD_PERL_MODULE(Dir, Module) {
    PEERDIR($Dir)
    SET_APPEND(modules $Module)
}

# tag:allocator
### @usage: ALLOCATOR(Alloc)  # Default: LF
###
### Set memory allocator implementation for the PROGRAM()/DLL() module.
### This may only be specified for programs and dlls, use in other modules leads to configuration errors.
###
### Available allocators are: "LF", "LF_YT", "LF_DBG", "YT", "J", "B", "BM", "C", "TCMALLOC", "GOOGLE", "LOCKLESS", "SYSTEM", "FAKE", "MIM", "HU".
###   - LF - lfalloc (https://a.yandex-team.ru/arc/trunk/arcadia/library/cpp/lfalloc)
###   - LF_YT -  Allocator selection for YT (https://a.yandex-team.ru/arc/trunk/arcadia/library/cpp/lfalloc/yt/ya.make)
###   - LF_DBG -  Debug allocator selection (https://a.yandex-team.ru/arc/trunk/arcadia/library/cpp/lfalloc/dbg/ya.make)
###   - YT - The YTAlloc allocator (https://a.yandex-team.ru/arc/trunk/arcadia/library/cpp/ytalloc/impl/ya.make)
###   - J - The JEMalloc allocator (https://a.yandex-team.ru/arc/trunk/arcadia/library/malloc/jemalloc)
###   - B - The balloc allocator named Pyotr Popov and Anton Samokhvalov
###       - Discussion: https://ironpeter.at.yandex-team.ru/replies.xml?item_no=126
###       - Code: https://a.yandex-team.ru/arc/trunk/arcadia/library/cpp/balloc
###   - BM - The balloc for market (agri@ commits from july 2018 till November 2018 saved)
###   - C - Like B, but can be disabled for each thread to LF or SYSTEM one (B can be disabled only to SYSTEM)
###   - MIM -  Microsoft's mimalloc (actual version) (https://a.yandex-team.ru/arc/trunk/arcadia/library/malloc/mimalloc)
###   - TCMALLOC -  Google TCMalloc (actual version) (https://a.yandex-team.ru/arc/trunk/arcadia/library/malloc/tcmalloc)
###   - GOOGLE -  Google TCMalloc (https://a.yandex-team.ru/arc/trunk/arcadia/library/malloc/galloc)
###   - LOCKLESS - Allocator based upon lockless queues (https://a.yandex-team.ru/arc/trunk/arcadia/library/malloc/lockless)
###   - SYSTEM - Use target system allocator
###   - FAKE - Don't link with any allocator
###
### More about allocators in Arcadia: https://wiki.yandex-team.ru/arcadia/allocators/
macro ALLOCATOR(Alloc) {
    SET(ALLOCATOR $Alloc)

    when ($ALLOCATOR in [ "LF", "LF_YT", "LF_DBG", "YT", "J", "B", "BM", "C", "TCMALLOC", "TCMALLOC_SMALL_BUT_SLOW", "TCMALLOC_NUMA_256K", "TCMALLOC_NUMA_LARGE_PAGES", "TCMALLOC_256K", "GOOGLE", "LOCKLESS", "SYSTEM", "FAKE", "MIM", "HU" ]) {
    }
    otherwise {
        PEERDIR+=___configure_error___unknown_allocator_type___$ALLOCATOR
    }
}

when ($MIC_ARCH == "yes") {
    CFLAGS+=-mmic
    LDFLAGS+=-mmic
}
when ($USE_OPENMP == "yes") {
    PEERDIR+=contrib/libs/openmp
}

when ($STRIP == "yes" && $NO_STRIP != "yes") {
    STRIP_FLAG=$LD_STRIP_FLAG
    DWARF_COMMAND=
    GO_LINK_FLAGS_VALUE+=-s
}

when ($NO_LINKER_DCE != "yes") {
    DCE_FLAG=$LD_DCE_FLAG
}

when ($BT_MINSIZEREL == "yes" || $LINKER_ICF == "yes") {
    ICF_FLAG=$LD_ICF_FLAG
}

OBJCOPY_TOOL=$OBJCOPY_TOOL_VENDOR
STRIP_TOOL=$STRIP_TOOL_VENDOR
NEED_BINUTILS_PEERDIR=
BINUTILS_USED=

when (!$OBJCOPY_TOOL_VENDOR) {
    OBJCOPY_TOOL=$BINUTILS_ROOT_RESOURCE_GLOBAL/bin/objcopy
    NEED_BINUTILS_PEERDIR=yes
}
when (!$STRIP_TOOL_VENDOR) {
    STRIP_TOOL=$BINUTILS_ROOT_RESOURCE_GLOBAL/bin/strip
    NEED_BINUTILS_PEERDIR=yes
}

SPLIT_DWARF_VALUE=no
NO_SPLIT_DWARF=no

when ($STRIP_DEBUG_INFO) {
    SPLIT_DWARF_VALUE=yes
    NO_SPLIT_DWARF=no
}

### @usage: SPLIT_DWARF()
###
### Emit debug info for the PROGRAM/DLL as a separate file <module_name>.debug.
### NB: It does not help you to save process RSS but can add problems (see e.g. BEGEMOT-2147).
macro SPLIT_DWARF() {
    SET(SPLIT_DWARF_VALUE yes)
}

SPLIT_DWARF_OUTPUT=${output;tobindir;pre=$MODULE_PREFIX;suf=$MODULE_SUFFIX.debug:REALPRJNAME}
when ($SPLIT_DWARF_VALUE == "yes" && $NO_SPLIT_DWARF != "yes" && $NO_DEBUGINFO != "yes" && $HOST_OS_LINUX == "yes" && $TARGET_PLATFORM == "LINUX") {
    DWARF_COMMAND+= \
        $OBJCOPY_TOOL --only-keep-debug $TARGET $SPLIT_DWARF_OUTPUT && \
        $STRIP_TOOL --strip-debug $TARGET && \
        $OBJCOPY_TOOL --remove-section=.gnu_debuglink --add-gnu-debuglink $SPLIT_DWARF_OUTPUT $TARGET
    BINUTILS_USED=yes
}

### @usage: EXTRALIBS_STATIC(Libs...)
###
### Add the specified external static libraries to the program link
macro EXTRALIBS_STATIC(Args...) {
    LDFLAGS(-Wl,-Bstatic ${Args} -Wl,-Bdynamic)
}

### @usage ADD_COMPILABLE_TRANSLATE(Dict Name Options...)
###
### Generate translation dictionary code to transdict.LOWER(Name).cpp that will than be compiled into library
macro ADD_COMPILABLE_TRANSLATE(Dict, Name, MakeTransDictOptions...) {
     __translatename_lower=${tolower:Name}
     __translate_dict=${BINDIR}/transdict.${__translatename_lower}.cpp
     RUN_PROGRAM(dict/tools/maketransdict -i ${Dict} ${MakeTransDictOptions} ${Name} STDOUT_NOAUTO ${__translate_dict} IN ${Dict})
}

### @usage ADD_COMPILABLE_TRANSLIT(TranslitTable NGrams Name Options...)
###
### Generate transliteration dictionary code
### This will emit both translit, untranslit and ngrams table codes those will be than further compiled into library
macro ADD_COMPILABLE_TRANSLIT(TranslitTable, NGrams, Name, Options...) {
     __translitname_lower=${tolower:Name}
     __translit_table=${BINDIR}/translit_trie_${__translitname_lower}.cpp
     __untranslit_table=${BINDIR}/untranslit_trie_${__translitname_lower}.cpp
     __ngrams_table=${BINDIR}/ngr_arr_${__translitname_lower}.cpp
     __gentrie_dir=dict/tools/make_untranslit_trie

     RUN_PROGRAM(${__gentrie_dir} -i ${TranslitTable} ${Options} ${__translitname_lower} IN ${TranslitTable} STDOUT ${__untranslit_table})
     RUN_PROGRAM(${__gentrie_dir} -i ${TranslitTable} -n ${Options} ${__translitname_lower} IN ${TranslitTable} STDOUT ${__translit_table})
     RUN_PROGRAM(dict/tools/make_ngrams -i ${NGrams} ${Options} ${__translitname_lower} IN ${NGrams} STDOUT ${__ngrams_table})
}


# tag:python-specific tag:proto tag:deprecated
### @usage GENERATE_PY_PROTOS(ProtoFiles...) # deprecated
###
### Generate python bindings for protobuf files.
### Macro is obsolete and not recommended for use!
macro GENERATE_PY_PROTOS(FILES...) {
    foreach (FILE : $FILES) {
        _PY_PROTO_CMD($FILE)
    }
}

# tag:python-specific tag:proto
macro _GENERATE_PY_PROTOS_INTERNAL(FILES...) {
    foreach (FILE : $FILES) {
        _PY_PROTO_CMD_INTERNAL($FILE)
    }
}

# tag:python-specific
macro _GENERATE_PY_EVS_INTERNAL(FILES...) {
    foreach (FILE : $FILES) {
        _PY_EVLOG_CMD_INTERNAL($FILE)
    }
}

macro _COPY_FILE_IMPL(FILE, AUTO_DST="", NOAUTO_DST="", OUTPUT_INCLUDES[], INDUCED_DEPS[]) {
    .CMD=$COPY_CMD ${input:FILE} ${output:AUTO_DST} ${output;noauto:NOAUTO_DST} ${output_include;hide:OUTPUT_INCLUDES} $INDUCED_DEPS ${kv;hide:"p CP"} ${kv;hide:"pc light-cyan"}
    .SEM=copy_file ${input:FILE} ${output:AUTO_DST} ${output;noauto:NOAUTO_DST}
}

### @usage: COPY_FILE(File Destination [AUTO] [OUTPUT_INCLUDES Deps...])
###
### Copy file to build root. It is possible to change both location and the name.
###
### Parameters:
### - File - Source file name.
### - Destination - Output file name.
### - AUTO - Consider copied file for further processing automatically.
### - OUTPUT_INCLUDES output_includes... - Output file dependencies.
### - INDUCED_DEPS $VARs... - Dependencies for generated files. Unlike `OUTPUT_INCLUDES` these may target files further in processing chain.
###                           In order to do so VAR should be filled by PREPARE_INDUCED_DEPS macro, stating target files (by type)
###                           and set of dependencies
###
### The file will be just copied if AUTO boolean parameter is not specified. You should explicitly
### mention it in SRCS under new name (or specify AUTO boolean parameter) for further processing.
macro COPY_FILE(File, Destination, AUTO?"AUTO_DST":"NOAUTO_DST", OUTPUT_INCLUDES[], INDUCED_DEPS[]) {
    .CMD=$_COPY_FILE_IMPL($File $AUTO $Destination OUTPUT_INCLUDES $OUTPUT_INCLUDES INDUCED_DEPS $INDUCED_DEPS)
    .SEM=$_COPY_FILE_IMPL($File $AUTO $Destination)
}

### @usage: COPY_FILE_WITH_CONTEXT(FILE DEST [AUTO] [OUTPUT_INCLUDES DEPS...])
###
### Copy file to build root the same way as it is done for COPY_FILE, but also
### propagates the context of the source file.
macro COPY_FILE_WITH_CONTEXT(FILE, DEST, AUTO?"AUTO":"", OUTPUT_INCLUDES[], INDUCED_DEPS[]) {
    .CMD=$COPY_FILE($FILE $DEST $AUTO OUTPUT_INCLUDES $FILE $OUTPUT_INCLUDES INDUCED_DEPS $INDUCED_DEPS)
}

### This is to join $ALL_RES_ and $EXT
macro _ARF_HELPER(Args...) {
     RESOURCE_FILES($Args)
}

### @usage ALL_RESOURCE_FILES(Ext [PREFIX {prefix}] [STRIP {strip}] Dirs...)
###
### This macro collects all files with extension `Ext` and
### Passes them to `RESOURCE_FILES` macro as relative to current directory
###
### `PREFIX` and `STRIP` have the same meaning as in `ROURCES_FILES`, both are applied over moddir-relative paths
###
### Note: This macro can be used multiple times per ya.make, but only once for each Ext value
### Note: Wildcards are not allowed neither as Ext nor in Dirs
macro ALL_RESOURCE_FILES(EXT, PREFIX="", STRIP="", DIRS...) {
     _GLOB(ALL_RES_$EXT ${suf=/*.$EXT:DIRS})
     _ARF_HELPER(${pre=PREFIX :PREFIX} STRIP ${ARCADIA_ROOT}/${MODDIR}${pre=/:STRIP} ${pre=$ALL_RES_:EXT})
}


macro _BUNDLE_TARGET(Target, Destination) {
    .CMD=$MOVE_FILE ${result:Target} ${output;noauto:Destination} ${kv;hide:"p BN"} ${kv;hide:"pc light-cyan"} $VCS_INFO_DISABLE_CACHE__NO_UID__
}

### @usage: TIMEOUT(TIMEOUT)
###
### Sets a timeout on test execution
###
### Documentation about the system test: https://wiki.yandex-team.ru/yatool/test/
macro TIMEOUT(Time) {
    SET(TEST_TIMEOUT $Time)
}

SBR_UID_EXT=""
# tag:test
### @usage: VALIDATE_DATA_RESTART(ext)
###
### Change uid for resource validation tests. May be useful when sandbox resource ttl is changed, but test status is cached in CI.
### You can change ext to change test's uid. For example VALIDATE_DATA_RESTART(X), where is X is current revision.
macro VALIDATE_DATA_RESTART(Ext) {
    SET(SBR_UID_EXT $Ext)
}

# tag:test
TEST_FORK_MODE=none
TEST_PARTITION=SEQUENTIAL

# tag:test
### @usage: FORK_TESTS()
###
### Splits a test run on chunks by test classes.
### The number of chunks can be overridden using the macro SPLIT_FACTOR.
###
### Allows to run tests in parallel. Supported in UNITTEST, JTEST/JUNIT5 and PY2TEST/PY3TEST modules.
###
### Documentation about the system test: https://wiki.yandex-team.ru/yatool/test/
macro FORK_TESTS(MODE...) {
    SET(TEST_FORK_MODE tests)
    SET(TEST_PARTITION $MODE)
}

# tag:test
### @usage: FORK_SUBTESTS()
###
### Splits the test run in chunks on subtests.
### The number of chunks can be overridden using the macro SPLIT_FACTOR.
###
### Allows to run tests in parallel. Supported in UNITTEST, JTEST/JUNIT5 and PY2TEST/PY3TEST modules.
###
### Documentation about the system test: https://wiki.yandex-team.ru/yatool/test/
macro FORK_SUBTESTS(MODE...) {
    SET(TEST_FORK_MODE subtests)
    SET(TEST_PARTITION $MODE)
}

# tag:test
### @usage: SPLIT_FACTOR(x)
###
### Sets the number of chunks for parallel run tests when used in test module with FORK_TESTS() or FORK_SUBTESTS().
### If none of those is specified this macro implies FORK_TESTS().
###
### Supports C++ ut and PyTest.
###
### Documentation about the system test: https://wiki.yandex-team.ru/yatool/test/
macro SPLIT_FACTOR(Factor) {
    SET(TEST_SPLIT_FACTOR $Factor)
}

# tag:test
FORK_TEST_FILES_MODE=
### @usage: FORK_TEST_FILES()
###
### Only for PY2TEST and PY3TEST: splits a file executable with the tests on chunks in the files listed in TEST_SRCS
### Compatible with FORK_(SUB)TESTS.
###
### Documentation about the system test: https://wiki.yandex-team.ru/yatool/test/
macro FORK_TEST_FILES() {
    SET(FORK_TEST_FILES_MODE on)
}

# tag:test
TEST_SIZE_NAME=SMALL
### @usage: SIZE(SMALL/MEDIUM/LARGE)
###
### Set the 'size' for the test. Each 'size' has own set of resrtictions, SMALL bein the most restricted and LARGE being the list.
### See documentation on test system for more details.
###
### Documentation about the system test: https://wiki.yandex-team.ru/yatool/test/
macro SIZE(Type) {
    SET(TEST_SIZE_NAME $Type)
}

### @usage: JOIN_SRCS(Out Src...)
###
### Join set of sources into single file named Out and send it for further processing.
### This macro doesn't place all file into Out, it emits #include<Src>... Use the for C++ source files only.
### You should specify file name with the extension as Out. Further processing will be done according this extension.
macro JOIN_SRCS(Out, Src...) {
    .CMD=$YMAKE_PYTHON ${input:"build/scripts/gen_join_srcs.py"} ${output:Out} --ya-start-command-file ${input;rootrel:Src} --ya-end-command-file ${output_include;hide:Src} ${kv;hide:"p JS"} ${kv;hide:"pc magenta"}
    .SEM=target_joined_source $Out ${input:Src} ${output;hide;suf=.o:Out}
    _CONDITIONAL_SRCS($TIDY_VALUE $Src)
}

### @usage: JOIN_SRCS_GLOBAL(Out Src...)
###
### Join set of sources into single file named Out and send it for further processing as if it were listed as SRCS(GLOBAL Out).
### This macro doesn't place all file into Out, it emits #include<Src>... Use the for C++ source files only.
### You should specify file name with the extension as Out. Further processing will be done according to this extension.
macro JOIN_SRCS_GLOBAL(Out, Src...) {
    .CMD=$YMAKE_PYTHON ${input:"build/scripts/gen_join_srcs.py"} ${output;noauto:Out} --ya-start-command-file ${input;rootrel:Src} --ya-end-command-file ${output_include;hide:Src} ${kv;hide:"p JS"} ${kv;hide:"pc magenta"}
    SRCS(GLOBAL $Out)
}

### @usage: FLAT_JOIN_SRCS_GLOBAL(Out Src...)
###
### Join set of sources into single file named Out and send it for further processing as if it were listed as SRCS(GLOBAL Out).
### This macro places all files into single file, so will work with any sources.
### You should specify file name with the extension as Out. Further processing will be done according to this extension.
macro FLAT_JOIN_SRCS_GLOBAL(Out, Src...) {
    .CMD=$YMAKE_PYTHON ${input:"build/scripts/fs_tools.py"} cat ${output;noauto:Out} --ya-start-command-file ${input:Src} --ya-end-command-file ${output_include;hide:Src} ${kv;hide:"p JS"} ${kv;hide:"pc magenta"}
    SRCS(GLOBAL $Out)
}

# tag:cpu
PIC_CFLAGS=
SSE2_CFLAGS=
SSE3_CFLAGS=
SSSE3_CFLAGS=
SSE41_CFLAGS=
SSE42_CFLAGS=
POPCNT_CFLAGS=
PCLMUL_CFLAGS=
CX16_FLAGS=
AVX_CFLAGS=
AVX2_CFLAGS=
AVX512_CFLAGS=

# tag:cpu
SSE_DEFINES=
SSE_CFLAGS=
SSE4_DEFINES=
SSE4_CFLAGS=
XOP_CFLAGS=

NO_LTO_CFLAGS=

# tag:cpu
when (($ARCH_X86_64 || $ARCH_I386) && $DISABLE_INSTRUCTION_SETS != "yes") {
    when ($CLANG || $CLANG_CL || $GCC) {
        PIC_CFLAGS=-fPIC
        SSE2_CFLAGS=-msse2
        SSE3_CFLAGS=-msse3
        SSSE3_CFLAGS=-mssse3
        SSE41_CFLAGS=-msse4.1
        SSE42_CFLAGS=-msse4.2
        XOP_CFLAGS=-mxop
        POPCNT_CFLAGS=-mpopcnt
        PCLMUL_CFLAGS=-mpclmul
        AVX_CFLAGS=-mavx

        # On Intel FMA3 instruction set comes together with AVX-2 extension starting with Broadwell / Haswell.
        # See:
        # https://en.wikipedia.org/wiki/FMA_instruction_set
        #
        # AMD implemented it in Piledriver architecture over AVX prior to AVX-2 which was introduced in Zen.
        # See:
        # https://en.wikipedia.org/wiki/Template:AMD_x86_CPU_features
        AVX2_CFLAGS=-mavx2 -mfma

        # All Intel CPUS with AVX-512 have these instructions except for the Knights Landing / Knights Mill
        # (these are Xeon Phi)
        # See:
        # https://en.wikichip.org/wiki/x86/avx-512
        AVX512_CFLAGS=-mavx512f -mavx512cd -mavx512bw -mavx512dq -mavx512vl
        when ($ARCH_X86_64 && $OS_ANDROID != "yes") {
            CX16_FLAGS=-mcx16
        }
        SSE_DEFINES=-DSSE_ENABLED=1 -DSSE3_ENABLED=1 -DSSSE3_ENABLED=1
        SSE4_DEFINES=-DSSE41_ENABLED=1 -DSSE42_ENABLED=1 -DPOPCNT_ENABLED=1 -DCX16_ENABLED=1
    }
    elsewhen ($MSVC) {
        SSE2_CFLAGS=/D__SSE2__=1
        SSE3_CFLAGS=/D__SSE3__=1
        SSSE3_CFLAGS=/D__SSSE3__=1
        SSE41_CFLAGS=/D__SSE4_1__=1
        SSE42_CFLAGS=/D__SSE4_2__=1
        POPCNT_CFLAGS=/D__POPCNT__=1
        PCLMUL_CFLAGS=/D__PCLMUL__=1
        AVX_CFLAGS=/arch:AVX /DAVX_ENABLED=1
        AVX2_CFLAGS=/arch:AVX2 /DAVX2_ENABLED=1
        AVX512_CFLAGS=/arch:AVX512 /DAVX512_ENABLED=1
        SSE_DEFINES=/DSSE_ENABLED=1 /DSSE3_ENABLED=1 /DSSSE3_ENABLED=1
        SSE4_DEFINES=/DSSE41_ENABLED=1 /DSSE42_ENABLED=1 /DPOPCNT_ENABLED=1 /DCX16_ENABLED=1
    }
    SSE_CFLAGS=$SSE2_CFLAGS $SSE3_CFLAGS $SSSE3_CFLAGS
    SSE4_CFLAGS=$SSE41_CFLAGS $SSE42_CFLAGS $POPCNT_CFLAGS $CX16_FLAGS
    when ($ARCH_I386 && $OS_ANDROID == "yes") {
        USE_SSE4=no
    }
}
otherwise {
    USE_SSE4=no
    CPU_CHECK=no
}

# tag:cpu
when ($NOSSE == "yes") {
    USE_SSE4=no
}

# tag:cpu
### @usage: NO_SSE4()
###
### Compile module without SSE4
macro NO_SSE4() {
    SET(USE_SSE4 no)
}

# tag:cpu
### @usage: NO_CPU_CHECK()
###
### Compile module without startup CPU features check
macro NO_CPU_CHECK() {
    SET(CPU_CHECK no)
}

### @usage: ADDINCLSELF()
###
### The macro adds the -I<project source path> flag to the source compilation flags of the current project.
macro ADDINCLSELF(FOR="") {
    when($FOR) {
        ADDINCL+=FOR $FOR ${MODDIR}
    }
    otherwise {
        ADDINCL+=${MODDIR}
    }
}

COMPILE_OUT_SUFFIX=
_COMPILE_OUTPUTS=${output;suf=${COMPILE_OUT_SUFFIX}${OBJECT_SUF}:SRC}
_COMPILE_TIME_TRACE_OUTPUTS=${output;noauto;suf=${COMPILE_OUT_SUFFIX}${OBJECT_SUF}.time_trace.json:SRC}

macro SET_COMPILE_OUTPUTS_MODIFIERS(NOREL?";norel":"") {
    SET(_COMPILE_OUTPUTS \${output;suf=\${OBJECT_SUF}$NOREL:SRC})
    SET(_COMPILE_TIME_TRACE_OUTPUTS \${output;noauto;suf=\${OBJECT_SUF}.time_trace.json$NOREL:SRC})
}

# tag:internal
### @usage: _ADD_EXTRA_FLAGS_IMPL([GENERATE] Args...) # internal
### Generate prefix = " && set_property SOURCE ${input:SRC} APPEND PROPERTY COMPILE_OPTIONS " before $Args when GENERATE
### is specified in the list of actual arguments
macro _ADD_EXTRA_FLAGS_IMPL(GENERATE?" && set_property SOURCE ${input:SRC} APPEND PROPERTY COMPILE_OPTIONS ":"", Args...) {
    .SEM=$GENERATE $Args
}

# tag:internal
### @usage: _ADD_EXTRA_FLAGS([GENERATE] Args...) # internal
### Generate prefix = " && set_property SOURCE ${input:SRC} APPEND PROPERTY COMPILE_OPTIONS " if Args is not empty
macro _ADD_EXTRA_FLAGS(COMPILE_OUT_SUFFIX="", Args...) {
    .SEM=$_ADD_EXTRA_FLAGS_IMPL(${pre=GENERATE :Args})
}

_EMPTY_CMD=

# tag:src-processing tag:internal
### @usage: _SRC(Ext Src Flags) # internal
###
### Basic building block of extension-based command dispatching
### To enable specific extension processing define _SRC() macro with fixed first argument (Ext).
### Internal logic will apply this macro to all files with this Ext listed in SRC/SRCS macros or outputs
### of other commands (except ones marked as noauto)
macro _SRC(EXT, SRC, SRCFLAGS...) {
    # Generic macro definition for _SRC (just a placeholder, it does nothing)
}

RODATA_SYMBOL_PREFIX=
when ($DARWIN == "yes" || $IOS == "yes" || ($WINDOWS == "yes" && $ARCH_TYPE_32 == "yes")) {
    RODATA_SYMBOL_PREFIX=_
}

RODATA_ELF_FLAGS=
when($LINUX  == "yes" || $ANDROID == "yes") {
    RODATA_ELF_FLAGS=--elf
}

RODATA_COMPILE=$YMAKE_PYTHON3 ${input:"build/scripts/rodata2asm.py"} $RODATA_ELF_FLAGS ${RODATA_SYMBOL_PREFIX}${noext;nopath:SRC} ${input:SRC} ${tmp;suf=.asm:SRC} ${hide:OBJECT_SUF} && $_SRC_yasm_helper(${tmp;suf=.asm:SRC})
when (($ARCH_AARCH64 || $ARCH_ARM || $ARCH_PPC64LE) == "yes") {
    RODATA_COMPILE=$YMAKE_PYTHON3 ${input:"build/scripts/rodata2cpp.py"} ${noext;nopath:SRC} ${input:SRC} ${output;suf=.cpp:SRC}
}

# tag:src-processing
macro _SRC("rodata", SRC, SRCFLAGS...) {
    .CMD=$RODATA_COMPILE ${hide;kv:"p RD"} ${hide;kv:"pc light-green"}
    .PEERDIR=$YMAKE_PYTHON3_PEER
    .SEM=target_rodata_sources PRIVATE ${input:SRC} ${output;hide;suf=${OBJ_SUF}.o:SRC}
}

# tag:src-processing
macro _SRC("S", SRC, SRCFLAGS...) {
    .CMD=$C_COMPILER $C_FLAGS_PLATFORM $CFLAGS $SFLAGS $SRCFLAGS -c -o ${output:SRC.o} ${input:SRC} ${pre=-I:_C__INCLUDE}
    .SEM=target_sources PRIVATE ${input:SRC} ${output;hide;suf=${OBJ_SUF}.o:SRC} $_ADD_EXTRA_FLAGS($SRCFLAGS)
}

# tag:src-processing
macro _SRC("s", SRC, SRCFLAGS...) {
    .CMD=$_SRC(S, $SRC $SRCFLAGS)
}

# tag:src-processing
macro _SRC("s79", SRC, SRCFLAGS...) {
    .CMD=$_SRC(S, $SRC $SRCFLAGS -x assembler-with-cpp)
}

# tag:src-processing
macro _SRC("mm", SRC, SRCFLAGS...) {
    .CMD=$C_COMPILER $C_FLAGS_PLATFORM -x objective-c++ -fobjc-arc -fobjc-abi-version=2 -c -o ${output:SRC.o} ${input:SRC} $CXXFLAGS ${pre=-I:_C__INCLUDE} ${SRCFLAGS} ${kv;hide:"p CC"} ${kv;hide:"pc light-green"} $TOOLCHAIN_ENV
}

# tag:src-processing
macro _SRC("fml", SRC, SRCFLAGS...) {
    .CMD=$FML_TOOL $CHECKFLAG -b -o ${output:SRC.inc} -T ${input:SRC} ${SRCFLAGS} ${kv;hide:"p FM"} ${kv;hide:"pc yellow"}
}

# tag:src-processing
macro _SRC("fml2", SRC, SRCFLAGS...) {
    .CMD=$FML_TOOL $CHECKFLAG -b -o ${output;nopath;noext:SRC.fml.inc} -2 -O ${output;nopath;noext:SRC.fml.cpp} -T ${input:SRC} ${SRCFLAGS} ${kv;hide:"p FM"} ${kv;hide:"pc yellow"}
}

# tag:src-processing
macro _SRC("fml3", SRC, SRCFLAGS...) {
    .CMD=$FML_TOOL $CHECKFLAG -b -o ${output;nopath;noext:SRC.fml.inc} -3 -O ${output;nopath;noext:SRC.fml.cpp} -L ${input;nopath;noext:SRC.list} -P ${nopath;noext:SRC} -T ${input:SRC} ${SRCFLAGS} ${kv;hide:"p FM"} ${kv;hide:"pc yellow"}
}

# tag:src-processing
macro _SRC("sfdl", SRC, SRCFLAGS...) {
    .CMD=$CXX_COMPILER $C_FLAGS_PLATFORM $CXXFLAGS $SFDL_FLAG ${SRCFLAGS} ${input:SRC} && ${tool:"tools/calcstaticopt"} -i ${tmp:SRC.tmp} -a $ARCADIA_ROOT ${output;stdout;nopath;noext;defext=.inc:SRC} ${kv;hide:"p SF"} ${kv;hide:"pc yellow"} $TOOLCHAIN_ENV
}

# tag:src-processing
macro _SRC("xs", SRC, SRCFLAGS...) {
    .CMD=$PERL_LD_LIBRARY_PATH $PERL $PERL_INCLUDE ${suf=/ExtUtils/xsubpp:PERL_PRIVLIB} -typemap ${suf=/ExtUtils/typemap:PERL_PRIVLIB} $PERLSUFFIX $XSUBPPFLAGS ${SRCFLAGS} ${input:SRC} $PERLOUTPUT ${kv;hide:"p XS"} ${kv;hide:"pc yellow"}
}

# tag:src-processing
macro _SRC("y", SRC, SRCFLAGS...) {
    # .CMD=${tool:"contrib/tools/byacc"} $BYACC_FLAGS ${nopath;noext;output:SRC.cpp} ${input:SRC} ${nopath;noext;hide;output;addincl:SRC.h} ${kv;hide:"p YC"} ${kv;hide:"pc light-green"}
    .CMD=${tool:"contrib/tools/bison/bison"} $BISON_FLAGS --m4=${tool:"contrib/tools/bison/m4"} --defines=${nopath;noext;output;main;addincl;norel:SRC.h} -o ${nopath;noext;output:SRC.cpp} ${input:SRC} ${SRCFLAGS} && $YMAKE_PYTHON ${input:"build/scripts/preprocess.py"} $_ADD_HIDDEN_INPUTS($CPP_BISON_SKELS) ${nopath;noext;tmp:SRC.h} ${kv;hide:"p YC"} ${kv;hide:"pc light-green"}
    .SEM=target_bison_parser PRIVATE ${input:SRC} ${output;nopath;noext;hide;suf=${OBJ_SUF}.o:SRC} ${nopath;noext;output;hide:SRC.h} ${nopath;noext;output;addincl;hide:SRC.h} && set_global_flags BISON_FLAGS $BISON_FLAGS && conan_require bison/3.5.3 && conan_import '"bin, bison* -> ./bin/bison/bin"' && conan_import '"res, * -> ./bin/bison/res"'
}

# tag:src-processing
macro _SRC("ypp", SRC, SRCFLAGS...) {
    .CMD=$_SRC(y $SRC $SRCFLAGS)
}

# tag:src-processing
macro _SRC("gperf", SRC, SRCFLAGS...) {
    .CMD=$RUN_NO_SANITIZE ${tool:"contrib/tools/gperf"} $GP_FLAGS ${SRCFLAGS} ${pre=-Nin_;suf=_set;nopath;noallext:SRC} ${input:SRC} ${output;stdout;nopath;noext;defext=.gperf.cpp:SRC} ${kv;hide:"p GP"} ${kv;hide:"pc yellow"}
}

# tag:src-processing
macro _SRC("rl", SRC, SRCFLAGS...) {
    .CMD=$RUN_NO_SANITIZE ${tool:"contrib/tools/ragel5/ragel"} $RAGEL_FLAGS ${SRCFLAGS} -o ${tmp:SRC.tmp} ${input:SRC} && $RUN_NO_SANITIZE ${tool:"contrib/tools/ragel5/rlgen-cd"} $RLGEN_FLAGS -o ${output;nopath;noext;defext=.rl5.cpp:SRC} ${tmp:SRC.tmp} ${kv;hide:"p R5"} ${kv;hide:"pc yellow"}
}

# tag:src-processing
macro _SRC("rl5", SRC, SRCFLAGS...) {
    .CMD=$_SRC(rl $SRC $SRCFLAGS)
}

# tag:src-processing
macro _SRC("asp", SRC, SRCFLAGS...) {
    .CMD=$RUN_NO_SANITIZE ${tool:"tools/html2cpp"} ${input:SRC} ${output:SRC.cpp} ${kv;hide:"p HT"} ${kv;hide:"pc yellow"}
}

# tag:src-processing
macro _SRC("rl6", SRC, SRCFLAGS...) {
    .CMD=$RUN_NO_SANITIZE ${tool:"contrib/tools/ragel6"} $RAGEL6_FLAGS ${SRCFLAGS} -L -I${ARCADIA_ROOT} -o ${output;nopath;noext;defext=.rl6.cpp:SRC} ${input:SRC} ${kv;hide:"p R6"} ${kv;hide:"pc yellow"}
    .SEM=target_ragel_lexers PRIVATE ${input:SRC} ${output;hide;suf=${OBJ_SUF}.o:SRC} $RAGEL6_FLAGS ${SRCFLAGS} && set_global_flags RAGEL_FLAGS -L -I $S/ && conan_require ragel/6.10 && conan_import '"bin, ragel* -> ./bin"'
}

# tag:src-processing
macro _SRC("l", SRC, SRCFLAGS...) {
    .CMD=${tool:"contrib/tools/flex-old"} $LEX_FLAGS ${SRCFLAGS} -o${output:SRC.cpp} ${output_include;hide:"util/system/compiler.h"} ${input:SRC} ${kv;hide:"p LX"} ${kv;hide:"pc yellow"}
    .ADDINCL=contrib/tools/flex-old
    .SEM=target_flex_lexers ${tool;hide:"contrib/tools/flex-old"} ${output;hide;suf=${OBJ_SUF}.o:SRC} ${input:SRC} && set_global_flags LEX_FLAGS $LEX_FLAGS
}

# tag:src-processing
macro _SRC("lex", SRC, SRCFLAGS...) {
    .CMD=$_SRC(l $SRC $SRCFLAGS)
}

# tag:src-processing
macro _SRC("lpp", SRC, SRCFLAGS...) {
    .CMD=$_SRC(l $SRC $SRCFLAGS)
}

# tag:src-processing
macro _SRC("pln", SRC, SRCFLAGS...) {
    .CMD=$FML_TOOL -b -o ${output;pre=pln.;nopath;noext:SRC.cpp} -f ${input:SRC} ${SRCFLAGS} ${kv;hide:"p FM"} ${kv;hide:"pc yellow"}
}

# tag:src-processing
macro _SRC("xsyn", SRC, SRCFLAGS...) {
    .CMD=$YMAKE_PYTHON ${input:"library/cpp/xml/parslib/xsyn2ragel.py"} ${input:SRC} ${input:"library/cpp/xml/parslib/xmlpars.xh"} dontuse ${output;stdout:SRC.h.rl5} ${kv;hide:"p XN"} ${kv;hide:"pc yellow"}
}

# tag:src-processing
macro _SRC("ev", SRC, SRCFLAGS...) {
    .CMD=$EVLOG_CMD($SRC)
}

# tag:src-processing
macro _SRC("proto", SRC, SRCFLAGS...) {
    .CMD=$PROTO_CMD($SRC)
    .SEM=$PROTO_CMD($SRC)
}

# tag:src-processing
macro _SRC("gztproto", SRC, SRCFLAGS...) {
    # _PROTO__INCLUDE is before ARCADIA_ROOT in includes because in gazetteer we don't use builtins now and paths' canonization (resolving) depends on order of roots.
    # descriptor.proto must be resolved as google/protobuf/descriptor.proto
    .CMD=${tool:"dict/gazetteer/converter"} -I$PROTOBUF_PATH ${pre="-I":_PROTO__INCLUDE} -I$ARCADIA_ROOT ${SRCFLAGS} ${input:SRC} ${output;nopath;noext;norel:SRC.proto} ${kv;hide:"p GZ"} ${kv;hide:"pc yellow"}
    .PEERDIR=kernel/gazetteer/proto
}

# tag:src-processing
macro _SRC("cfgproto", SRC, SRCFLAGS...) {
    .CMD=$_CPP_CFGPROTO_CMD($SRC)
}

# tag:src-processing
macro _SRC("pyx", SRC, SRCFLAGS...) {
    # Copy-paste from BUILDWITH_CYTHON
    .CMD=$RUN_CYTHON_SCRIPT $CYTHON_OPTIONS --cplus ${CYTHON_CPP_OUTPUT_INCLUDES} ${pre=-I:_CYTHON__INCLUDE} ${input:SRC} -o ${output;tobindir:SRC.cpp} $CYTHON_OUTPUT_INCLUDES ${SRCFLAGS} ${kv;hide:"p CY"} ${kv;hide:"pc yellow"}
    .SEM=target_cython_sources PRIVATE ${input:Src} ${output;hide;tobindir:Src.fake.o} && target_cython_options $CYTHON_OPTIONS --cplus ${SRCFLAGS} ${CYTHON_CPP_OUTPUT_INCLUDES} && target_cython_include_directories $_CYTHON__INCLUDE && set_python_type_for_cython $PYTHON_TYPE_FOR_CYTHON
    .ADDINCL=FOR cython contrib/tools/cython/Cython/Includes
}

# tag:src-processing
macro _SRC("in", SRC, SRCFLAGS...) {
   .CMD=$CONFIGURE_FILE(${SRC} ${nopath;noext:SRC})
   .SEM=$CONFIGURE_FILE(${SRC} ${nopath;noext:SRC})
}

macro MANUAL_GENERATION(Outs...) {
    .SEM=ignored ${output;hide;noauto:Outs}
}

# tag:src-processing
macro _SRC("sc", SRC, SRCFLAGS...) {
    .CMD=${tool:"tools/domschemec"} --in ${input:SRC} --out ${output;norel:SRC.h} ${output_include;hide:"util/generic/strbuf.h"} ${output_include;hide:"util/generic/string.h"} ${output_include;hide:"util/generic/vector.h"} ${output_include;hide:"util/string/cast.h"} ${SRCFLAGS} ${kv;hide:"p SC"} ${kv;hide:"pc yellow"}
}

# tag:src-processing
macro _SRC("ssqls", SRC, SRCFLAGS...) {
    .CMD=${tool:"metrika/core/tools/ssqls"} ${input;notransformbuilddir:SRC} -S $ARCADIA_ROOT -B $ARCADIA_BUILD_ROOT $SRCFLAGS ${output;noext;hide:SRC.cpp} ${output;noext;hide:SRC.h} ${kv;hide:"p SS"} ${kv;hide:"pc yellow"}
}

# tag:src-processing
macro _SRC("f", SRC, SRCFLAGS...) {
    .CMD=$YMAKE_PYTHON ${input:"build/scripts/f2c.py"} -t ${tool:"contrib/tools/f2c"} -c ${input:SRC} -o ${output:SRC.c} ${kv;hide:"p FT"} ${kv;hide:"pc light-green"}
    .PEERDIR=contrib/libs/libf2c
    .ADDINCL=contrib/libs/libf2c
}

# tag:src-processing
macro _SRC("cpp", SRC, SRCFLAGS...) {
    .CMD=$_SRC_cpp($SRC $SRCFLAGS)
    .SEM=target_sources PRIVATE ${input:SRC} ${output;hide;suf=${OBJ_SUF}.o:SRC} $_ADD_EXTRA_FLAGS($SRCFLAGS)
}

# tag:src-processing
macro _SRC("cxx", SRC, SRCFLAGS...) {
    .CMD=$_SRC(cpp $SRC $SRCFLAGS)
}

# tag:src-processing
macro _SRC("cc", SRC, SRCFLAGS...) {
    .CMD=$_SRC(cpp $SRC $SRCFLAGS)
    .SEM=target_sources PRIVATE ${input:SRC} ${output;hide;suf=${OBJ_SUF}.o:SRC} $_ADD_EXTRA_FLAGS($SRCFLAGS)
}

# tag:src-processing
macro _SRC("C", SRC, SRCFLAGS...) {
    .CMD=$_SRC(cpp $SRC $SRCFLAGS)
}

# tag:src-processing
macro _SRC("c", SRC, SRCFLAGS...) {
    .CMD=$_SRC_c($SRC $SRCFLAGS)
    .SEM=target_sources PRIVATE ${input:SRC} ${output;hide;suf=${OBJ_SUF}.o:SRC} $_ADD_EXTRA_FLAGS($SRCFLAGS $USER_CONLYFLAGS $USER_CONLYFLAGS_GLOBAL)
}

# tag:src-processing
macro _SRC("m", SRC, SRCFLAGS...) {
    .CMD=$_SRC(c $SRC $SRCFLAGS)
}

# tag:src-processing
macro _SRC("masm", SRC, SRCFLAGS...) {
    .CMD=$_SRC_masm($SRC $SRCFLAGS)
}

YASM_SEM=target_yasm_source PRIVATE ${input:SRC} ${output;hide;suf=${OBJ_SUF}.o:SRC} $YASM_FLAGS ${pre=-I :_ASM__INCLUDE} $SRCFLAGS ${pre=-P :PREINCLUDES} \
         && set_global_flags YASM_FLAGS -f ${_YASM_FMT_VALUE}${HARDWARE_ARCH} $_YASM_PLATFORM_FLAGS_VALUE -D ${pre=_;suf=_:HARDWARE_TYPE} -D_YASM_ $ASM_PREFIX_VALUE $_YASM_PREDEFINED_FLAGS_VALUE \
         && add_language ASM \
         && conan_require yasm/1.3.0 && conan_import '"bin, *yasm* -> ./bin"' && conan_import '"bin, ytasm* -> ./bin"'
ASM_SEM=target_yasm_source PRIVATE ${input:SRC} ${output;hide;suf=${OBJ_SUF}.o:SRC} $YASM_FLAGS ${pre=-I :_ASM__INCLUDE} $SRCFLAGS \
        && set_global_flags YASM_FLAGS -f ${_YASM_FMT_VALUE}${HARDWARE_ARCH} $_YASM_PLATFORM_FLAGS_VALUE -D ${pre=_;suf=_:HARDWARE_TYPE} -D_YASM_ $ASM_PREFIX_VALUE $_YASM_PREDEFINED_FLAGS_VALUE \
        && add_language ASM \
        && conan_require yasm/1.3.0 && conan_import '"bin, *yasm* -> ./bin"' && conan_import '"bin, ytasm* -> ./bin"'
# tag:src-processing
macro _SRC("yasm", SRC, SRCFLAGS...) {
    .CMD=$_SRC_yasm($SRC $SRCFLAGS PREINCLUDES $YASM_PREINCLUDES_VALUE)
    .SEM=$YASM_SEM
}

# tag:src-processing
macro _SRC("asm", SRC, SRCFLAGS...) {
    .CMD=$_SRC(yasm $SRC $SRCFLAGS)
    .SEM=$ASM_SEM
}

# tag:src-processing
macro _SRC("lua", SRC, SRCFLAGS...) {
    .CMD=${cwd:LUAJIT_PATH} ${tool:"contrib/libs/luajit/compiler"} -b -g ${input:SRC} ${SRCFLAGS} ${global;output;suf=.o:SRC} ${kv;hide:"p LJ"} ${kv;hide:"pc light-cyan"}
    .PEERDIR=$LUAJIT_PATH
}

NVCC_STD_VER=14
when ($MSVC == "yes") {
    NVCC_STD=/std:c++${NVCC_STD_VER}
}
otherwise {
    NVCC_STD=-std=c++${NVCC_STD_VER}
}

# tag:src-processing
macro _SRC("cu", SRC, SRCFLAGS...) {
    .CMD=$_SRC_CU_CMD
    .SEM=target_cuda_sources PRIVATE ${input:SRC} ${output;hide;suf=${OBJ_SUF}.o:SRC} && add_language CUDA && set_global_flags CMAKE_CUDA_STANDARD ${NVCC_STD_VER} && target_cuda_flags $CUDA_NVCC_FLAGS && target_cuda_cflags $USER_CXXFLAGS $SRCFLAGS
    .PEERDIR=$_SRC_CU_PEERDIR
}

# tag:src-processing
macro _SRC("fbs", SRC, SRCFLAGS...) {
    .CMD=$FBS_CMD($SRC, $SRCFLAGS)
    .SEM=$FBS_CMD($SRC, $SRCFLAGS)
}

# tag:src-processing
macro _SRC("fbs64", SRC, SRCFLAGS...) {
    .CMD=$_CPP_FLATC64_CMD($SRC, $SRCFLAGS)
}

# tag:src-processing
macro _SRC("pysrc", SRC, SRCFLAGS...) {
    .CMD=$_SRC_PYSRC($SRC, $SRCFLAGS)
}

# tag:src-processing
macro _SRC_py2src(SRC, SRCFLAGS...) {
    .CMD=${cwd:BINDIR} $YMAKE_PYTHON ${input:"build/scripts/compile_pysrc.py"} --input ${input:SRC} --output ${output;noext;suf=.py2_raw.cpp:SRC} --rescompiler ${tool:"tools/rescompiler"} py2 --python $(PYTHON)/python --py_compile ${input:"build/scripts/py_compile.py"} ${kv;hide:"p P2"} ${kv;hide:"pc light-green"}
}

# tag:src-processing
macro _SRC_py3src(SRC, SRCFLAGS...) {
    .CMD=${cwd:BINDIR} $YMAKE_PYTHON ${input:"build/scripts/compile_pysrc.py"} --input ${input:SRC} --output ${output;noext;suf=.py3_raw.cpp:SRC} --rescompiler ${tool:"tools/rescompiler"} py3 --pycc ${tool:"contrib/tools/python3/pycc"} ${kv;hide:"p P3"} ${kv;hide:"pc light-green"}
}

# tag:src-processing python-specific
when ($PYTHON3 == "yes") {
    MACRO_ALIAS(_SRC_PYSRC _SRC_py3src)
}
otherwise {
    MACRO_ALIAS(_SRC_PYSRC _SRC_py2src)
}

# tag:src-processing
macro _SRC_c_nodeps(SRC, OUTFILE, INC...) {
     .CMD=$_SRC_C_NODEPS_CMD
}

# Custom flags for generated cpp-files. To support another generator:
# - insert additional file extension before .cpp into generated cpp-file name
# - update _LANG_CFLAGS_FILTER variable. Don't forget to add ' SKIP ' after flag list
#
# ragel5 and ragel6 generated terrible code which makes use of goto's in switch statements.
# This triggers -Werror-implicit-fallthrough due to `unannotated fall-through between switch labels`.
#
# cython generated code also fails to pass this diagnostics due to `fallthrough annotation in unreachable code`.
# We use cython==0.29.26 at the time. This issue might be fixed in further versions.

## tag:src-processing
_LANG_CFLAGS_FILTER=\
    ${pre=-Wno-implicit-fallthrough SKIP ;ext=.rl5:SRC} \
    ${pre=-Wno-implicit-fallthrough SKIP ;ext=.rl6:SRC} \
    ${pre=-Wno-implicit-fallthrough SKIP ;ext=.pyx:SRC}

# tag:src-processing
# Magic macro for removing file name from result (file name is passed as unused SKIP parameter)
macro _FILTER_EXTS(SKIP="", FLAGS...) {
    .CMD=$FLAGS
}

# tag:src-processing
macro _LANG_CFLAGS(SRC) {
    .CMD=$_FILTER_EXTS($_LANG_CFLAGS_FILTER)
}

# tag:src-processing
# ymake bug workaround: variables followed a macros call in .CMD are not substituted and are placed in result as is
# Pack macro call into a variable and use it in _SRC_CPP_CMD instead of macro call
_LANG_CFLAGS_VALUE=
when ($CLANG == "yes" || $CLANG_CL == "yes" || $GCC == "yes") {
    _LANG_CFLAGS_VALUE=$_LANG_CFLAGS(${noext:SRC})
}

# Allows to add single compilation unit name to the node's 'kv' section.
# This is used by the coverage machinery to instrument only the necessary sources
# when --coverage-prefix-filter <rootrelpath> is specified. For more info see DEVTOOLSSUPPORT-16891
SCU_NAME_KV=
when ($CLANG_COVERAGE && $CLANG_COVERAGE != "no") {
    SCU_NAME_KV=${hide;kv:"scu_name $KV_VAL"}
}

macro _ADD_SCU_NAME(KV_VAL) {
    .CMD=$SCU_NAME_KV
}

# tag:src-processing
macro _SRC_cpp(SRC, COMPILE_OUT_SUFFIX="", SRCFLAGS...) {
    .CMD=$_SRC_CPP_CMD $_ADD_SCU_NAME(${input:SRC})
}

# tag:src-processing
macro _SRC_c(SRC, COMPILE_OUT_SUFFIX="", SRCFLAGS...) {
    .CMD=$_SRC_C_CMD $_ADD_SCU_NAME(${input:SRC})
}

# tag:src-processing
macro _SRC_m(SRC, SRCFLAGS...) {
    .CMD=$_SRC_M_CMD
}

# tag:src-processing
macro _SRC_masm(SRC, SRCFLAGS...) {
    .CMD=$_SRC_MASM_CMD
}

# tag:lua-specific
### @usage: COMPILE_LUA(Src, [NAME <import_name>])
###
### Compile LUA source file to object code using LUA 2.0
### Optionally override import name which is by default reflects Src name
macro COMPILE_LUA(Src, NAME="") {
    .CMD=$_SRC(lua, $Src, ${pre=-n :NAME})
}

# tag:lua-specific
### @usage: _SRC_lua_21(SRC [SRCFLAGS...]) # internal
###
### Compile LUA source file to object code using LUA 2.1
macro _SRC_lua_21(SRC, SRCFLAGS...) {
    .CMD=${cwd:LUAJIT_21_PATH} ${tool:"contrib/libs/luajit_21/compiler"} -b -g ${input:SRC} ${SRCFLAGS} ${global;output;suf=.o:SRC} ${kv;hide:"p LJ"} ${kv;hide:"pc light-cyan"}
    .PEERDIR=$LUAJIT_21_PATH
}

# tag:lua-specific
### @usage: COMPILE_LUA_21(Src, [NAME <import_name>])
###
### Compile LUA source file to object code using LUA 2.1
### Optionally override import name which is by default reflects Src name
macro COMPILE_LUA_21(Src, NAME="") {
    .CMD=$_SRC_lua_21($Src, ${pre=-n :NAME})
}

GETTEXT_KEEP_PATH=no
_MO_OUTPUT=
when ($GETTEXT_KEEP_PATH == "yes") {
    _MO_OUTPUT=${output;noauto;norel;noext:SRC.mo}
}
otherwise {
    _MO_OUTPUT=${output;noauto;nopath;noext;tobindir:SRC.mo}
}

# tag:src-processing
macro _SRC("po", SRC, SRCFLAGS...) {
    .CMD=$YMAKE_PYTHON ${input:"contrib/tools/python/src/Tools/i18n/msgfmt.py"} -o $_MO_OUTPUT ${input:SRC}
}

# tag:ydl-specific
YDL_FLAGS= --force-color -I ${ARCADIA_ROOT}
YDL_DESC_FLAGS=

# tag:src-processing tag:ydl-specific
macro _SRC("ydl", SRC, SRCFLAGS...) {
    .CMD=${tool:"statbox/ydl/compiler/tooling/ydl/bin"} c $YDL_FLAGS --cpp-output-header ${output;suf=.h:SRC} --cpp-output-source ${output;suf=.cpp:SRC} ${input:SRC} ${output_include;hide:"statbox/ydl/runtime/cpp/gen_support/standard_includes.h"} ${kv;hide:"p YDL"} ${kv;hide:"pc yellow"}
    .PEERDIR+=statbox/ydl/runtime/cpp
}

# tag:ydl-specific
### @usage BUILD_YDL_DESC(Input Symbol Output)
###
### Generate a descriptor for a Symbol located in a ydl module Input, and put it to the file Output.
###
### @example:
###
###     PACKAGE()
###         BUILD_YDL_DESC(../types.ydl Event Event.ydld)
###     END()
###
### This will parse file ../types.ydl, generate a descriptor for a symbol Event defined in the said file, and put the descriptor to the Event.ydld.
macro BUILD_YDL_DESC(Input, Symbol, Output) {
    .CMD=${tool:"statbox/ydl/compiler/tooling/ydl/bin"} ti $YDL_FLAGS $YDL_DESC_FLAGS -o ${output;noauto:Output} ${input:Input} ${Symbol} ${kv;hide:"p YDL"} ${kv;hide:"pc yellow"}
}

# tag:ydl-specific
### @usage: YDL_DESC_USE_BINARY()
###
### Used in conjunction with BUILD_YDL_DESC. When enabled, all generated descriptors are binary.
###
### @example:
###
###     PACKAGE()
###         YDL_DESC_USE_BINARY()
###         BUILD_YDL_DESC(../types.ydl Event Event.ydld)
###     END()
###
### This will generate descriptor Event.ydld in a binary format.
macro YDL_DESC_USE_BINARY() {
    YDL_DESC_FLAGS_BINARY= --binary
    SET_APPEND(YDL_DESC_FLAGS $YDL_DESC_FLAGS_BINARY)
}

### @usage SRC(File Flags...)
###
### Compile single file with extra Flags.
### Compilation is driven by the last extension of the File and Flags are specific to corresponding compilation command
macro SRC(FILE, FLAGS...) {
    _SRC(${lastext:FILE} $FILE $FLAGS)
}

### @usage: SRCS(<[GLOBAL] File> ...)
###
### Source files of the project. Files are built according to their extension and put int module output or fed to ultimate PROGRAM/DLL depending on GLOBAL presence.
### Arcadia Paths from the root and is relative to the project's LIST are supported
###
### GLOBAL marks next file as direct input to link phase of the program/shared library project built into. This prevents symbols of the file to be excluded by linker as unused.
### The scope of the GLOBAL keyword is the following file (that is, in the case of SRCS(GLOBAL foo.cpp bar.cpp) global will be only foo.cpp)
###
### @example:
###
###     LIBRARY(test_global)
###         SRCS(GLOBAL foo.cpp)
###     END()
###
### This will produce foo.o and feed it to any PROGRAM/DLL module transitively depending on test_global library. The library itself will be empty and won't produce .a file.
macro SRCS(FILES...) {
    foreach (FILE : $FILES) {
        _SRC(${lastext:FILE} $FILE)
    }
}

# tag:cpu tag:src-processing
### @usage SRC_C_SSE2(File Flags...)
### Compile single .c-file with SSE2 and extra Flags.
macro SRC_C_SSE2(FILE, FLAGS...) {
    _SRC(c $FILE $SSE2_CFLAGS $FLAGS COMPILE_OUT_SUFFIX .sse2)
}

# tag:cpu tag:src-processing
### @usage SRC_C_SSE3(File Flags...)
### Compile single .c-file with SSE3 and extra Flags.
macro SRC_C_SSE3(FILE, FLAGS...) {
    _SRC(c $FILE $SSE3_CFLAGS $FLAGS COMPILE_OUT_SUFFIX .sse3)
}

# tag:cpu tag:src-processing
### @usage SRC_C_SSSE3(File Flags...)
### Compile single .c-file with SSSE3 and extra Flags.
macro SRC_C_SSSE3(FILE, FLAGS...) {
    _SRC(c $FILE $SSSE3_CFLAGS $FLAGS COMPILE_OUT_SUFFIX .ssse3)
}

# tag:cpu tag:src-processing
### @usage SRC_C_SSE41(File Flags...)
### Compile single .c-file with SSE4.1 and extra Flags.
macro SRC_C_SSE41(FILE, FLAGS...) {
    _SRC(c $FILE $SSE41_CFLAGS $FLAGS COMPILE_OUT_SUFFIX .sse41)
}

# tag:cpu tag:src-processing
### @usage SRC_C_SSE4(File Flags...)
### Compile single .c-file with SSE4 (SSE4.1, SSE4.2 and POPCNT) and extra Flags.
macro SRC_C_SSE4(FILE, FLAGS...) {
    _SRC(c $FILE $SSE4_CFLAGS $FLAGS COMPILE_OUT_SUFFIX .sse4)
}

# tag:cpu tag:src-processing
### @usage SRC_C_SSE4(File Flags...)
### Compile single .c-file with XOP
### (an AMD-specific instruction set, see https://en.wikipedia.org/wiki/XOP_instruction_set)
### and extra Flags (optional)
macro SRC_C_XOP(FILE, FLAGS...) {
    _SRC(c $FILE $XOP_CFLAGS $FLAGS COMPILE_OUT_SUFFIX .xop)
}

# tag:cpu tag:src-processing
### @usage SRC_C_AVX(File Flags...)
### Compile single .c-file with AVX and extra Flags.
macro SRC_C_AVX(FILE, FLAGS...) {
    _SRC(c $FILE $AVX_CFLAGS $FLAGS COMPILE_OUT_SUFFIX .avx)
}

# tag:cpu tag:src-processing
### @usage SRC_C_AVX2(File Flags...)
### Compile single .c-file with AVX2 and extra Flags.
macro SRC_C_AVX2(FILE, FLAGS...) {
    _SRC(c $FILE $AVX2_CFLAGS $FLAGS COMPILE_OUT_SUFFIX .avx2)
}

# tag:cpu tag:src-processing
### @usage SRC_CPP_PIC(File Flags...)
### Compile single .c-file with -fPIC and extra Flags.
macro SRC_CPP_PIC(FILE, FLAGS...) {
    _SRC(cpp $FILE $PIC_CFLAGS $FLAGS)
}

# tag:cpu tag:src-processing
### @usage SRC_CPP_NO_LTO(File)
### Compile single .cpp file with link-time-optimization disabled
macro SRC_CPP_NO_LTO(FILE) {
    _SRC(cpp $FILE $NO_LTO_CFLAGS)
}

# tag:cpu tag:src-processing
### @usage SRC_CPP_SSE2(File Flags...)
### Compile single .cpp-file with SSE2 and extra Flags.
macro SRC_CPP_SSE2(FILE, FLAGS...) {
    _SRC(cpp $FILE $SSE2_CFLAGS $FLAGS COMPILE_OUT_SUFFIX .sse2)
}

# tag:cpu tag:src-processing
### @usage SRC_CPP_SSE3(File Flags...)
### Compile single .cpp-file with SSE3 and extra Flags.
macro SRC_CPP_SSE3(FILE, FLAGS...) {
    _SRC(cpp $FILE $SSE3_CFLAGS $FLAGS COMPILE_OUT_SUFFIX .sse3)
}

# tag:cpu tag:src-processing
### @usage SRC_CPP_SSSE3(File Flags...)
### Compile single .cpp-file with SSSE3 and extra Flags.
macro SRC_CPP_SSSE3(FILE, FLAGS...) {
    _SRC(cpp $FILE $SSSE3_CFLAGS $FLAGS COMPILE_OUT_SUFFIX .sss3)
}

# tag:cpu tag:src-processing
### @usage SRC_CPP_SSE41(File Flags...)
### Compile single .cpp-file with SSE4.1 and extra Flags.
macro SRC_CPP_SSE41(FILE, FLAGS...) {
    _SRC(cpp $FILE $SSE41_CFLAGS $FLAGS COMPILE_OUT_SUFFIX .sse41)
}

# tag:cpu tag:src-processing
### @usage SRC_CPP_SSE4(File Flags...)
### Compile single .cpp-file with SSE4 (SSE4.1, SSE4.2 and POPCNT) and extra Flags.
macro SRC_CPP_SSE4(FILE, FLAGS...) {
    _SRC(cpp $FILE $SSE4_CFLAGS $FLAGS COMPILE_OUT_SUFFIX .sse4)
}

# tag:cpu tag:src-processing
### @usage SRC_CPP_AVX(File Flags...)
### Compile single .cpp-file with AVX and extra Flags.
macro SRC_CPP_AVX(FILE, FLAGS...) {
    _SRC(cpp $FILE $AVX_CFLAGS $FLAGS COMPILE_OUT_SUFFIX .avx)
}

# tag:cpu tag:src-processing
### @usage SRC_CPP_AVX2(File Flags...)
### Compile single .cpp-file with AVX2 and extra Flags.
macro SRC_CPP_AVX2(FILE, FLAGS...) {
    _SRC(cpp $FILE $AVX2_CFLAGS $FLAGS COMPILE_OUT_SUFFIX .avx2)
}

# tag:python-processing tag:cython
# TODO: use it in [.pyx] cmd
### @usage: BUILDWITH_CYTHON_CPP(Src Options...)
###
### Generates .cpp file from .pyx.
macro BUILDWITH_CYTHON_CPP(Src, Options...) {
    .CMD=$RUN_CYTHON_SCRIPT $CYTHON_OPTIONS ${Options} --cplus ${CYTHON_CPP_OUTPUT_INCLUDES} ${pre=-I:_CYTHON__INCLUDE} ${input:Src} -o ${output;tobindir:Src.cpp} $CYTHON_OUTPUT_INCLUDES ${kv;hide:"p CY"} ${kv;hide:"pc yellow"}
    .SEM=target_cython_sources PRIVATE ${input:Src} ${output;hide;tobindir:Src.fake.o} && target_cython_options $CYTHON_OPTIONS ${Options} --cplus ${CYTHON_CPP_OUTPUT_INCLUDES} && target_cython_include_directories $_CYTHON__INCLUDE && set_python_type_for_cython $PYTHON_TYPE_FOR_CYTHON
    ADDINCL(FOR cython contrib/tools/cython/Cython/Includes)
}

# tag:python-processing tag:cython tag:internal
### @usage: _BUILDWITH_CYTHON_CPP_DEP(Src Dep Options...) # internal
###
### Generates .cpp file from .pyx and attach extra input Dep.
### If Dep changes the .cpp file will be re-generated.
macro _BUILDWITH_CYTHON_CPP_DEP(Src, Dep, Options...) {
    .CMD=$RUN_CYTHON_SCRIPT $CYTHON_OPTIONS ${Options} --cplus ${CYTHON_CPP_OUTPUT_INCLUDES} ${pre=-I:_CYTHON__INCLUDE} ${input:Src} ${input;hide:Dep} -o ${output;tobindir:Src.cpp} $CYTHON_OUTPUT_INCLUDES ${kv;hide:"p CY"} ${kv;hide:"pc yellow"}
    .SEM=target_cython_sources PRIVATE ${input:Src} ${input;hide:Dep} ${output;hide;tobindir:Src.fake.o} && target_cython_options $CYTHON_OPTIONS ${Options} --cplus ${CYTHON_CPP_OUTPUT_INCLUDES} && target_cython_include_directories $_CYTHON__INCLUDE && set_python_type_for_cython $PYTHON_TYPE_FOR_CYTHON
    ADDINCL(FOR cython contrib/tools/cython/Cython/Includes)
}

# tag:python-processing tag:cython
### @usage: BUILDWITH_CYTHON_C(Src Options...)
###
### Generates .c file from .pyx.
macro BUILDWITH_CYTHON_C(Src, Options...) {
    .CMD=$RUN_CYTHON_SCRIPT $CYTHON_OPTIONS ${Options} ${pre=-I:_CYTHON__INCLUDE} ${input:Src} -o ${output;tobindir:Src.c} $CYTHON_OUTPUT_INCLUDES ${kv;hide:"p CY"} ${kv;hide:"pc yellow"}
    .SEM=target_cython_sources PRIVATE ${input:Src} ${output;hide;tobindir:Src.fake.o} && target_cython_options $CYTHON_OPTIONS ${Options} ${CYTHON_OUTPUT_INCLUDES} && target_cython_include_directories $_CYTHON__INCLUDE && set_python_type_for_cython $PYTHON_TYPE_FOR_CYTHON
    ADDINCL(FOR cython contrib/tools/cython/Cython/Includes)
}

# tag:python-processing tag:cython tag:internal
### @usage: _BUILDWITH_CYTHON_C_DEP(Src Dep Options...) # internal
###
### Generates .c file from .pyx and attach extra input Dep.
### If Dep changes the .c file will be re-generated.
macro _BUILDWITH_CYTHON_C_DEP(Src, Dep, Options...) {
    .CMD=$RUN_CYTHON_SCRIPT $CYTHON_OPTIONS ${Options} ${pre=-I:_CYTHON__INCLUDE} ${input:Src} ${input;hide:Dep} -o ${output;tobindir:Src.c} $CYTHON_OUTPUT_INCLUDES ${kv;hide:"p CY"} ${kv;hide:"pc yellow"}
    .SEM=target_cython_sources PRIVATE ${input:Src} ${input;hide:Dep} ${output;hide;tobindir:Src.fake.o} && target_cython_options $CYTHON_OPTIONS ${Options} ${CYTHON_OUTPUT_INCLUDES} && target_cython_include_directories $_CYTHON__INCLUDE && set_python_type_for_cython $PYTHON_TYPE_FOR_CYTHON
    ADDINCL(FOR cython contrib/tools/cython/Cython/Includes)
}

# tag:python-processing tag:cython tag:internal
### @usage: _BUILDWITH_CYTHON_C_H(Src Dep Options...) # internal
###
### BUILDWITH_CYTHON_C without .pyx infix and with cdef public .h file.
macro _BUILDWITH_CYTHON_C_H(Src, Dep, Options...) {
    .CMD=$RUN_CYTHON_SCRIPT $CYTHON_OPTIONS ${Options} ${pre=-I:_CYTHON__INCLUDE} ${input:Src} ${input;hide:Dep} -o ${output;noext;tobindir:Src.c} ${output;hide;addincl;noext;tobindir:Src.h} $CYTHON_OUTPUT_INCLUDES ${kv;hide:"p CY"} ${kv;hide:"pc yellow"}
    ADDINCL(FOR cython contrib/tools/cython/Cython/Includes)
}

# tag:python-processing tag:cython tag:internal
### @usage: _BUILDWITH_CYTHON_C_API_H(Src Dep Options...) # internal
###
### BUILDWITH_CYTHON_C_H with cdef api _api.h file.
macro _BUILDWITH_CYTHON_C_API_H(Src, Dep, Options...) {
    .CMD=$RUN_CYTHON_SCRIPT $CYTHON_OPTIONS ${Options} ${pre=-I:_CYTHON__INCLUDE} ${input:Src} ${input;hide:Dep} -o ${output;noext;tobindir:Src.c} ${output;hide;addincl;noext;tobindir:Src.h} ${output;hide;addincl;noext;defext=_api.h;tobindir:Src} $CYTHON_OUTPUT_INCLUDES ${kv;hide:"p CY"} ${kv;hide:"pc yellow"}
    ADDINCL(FOR cython contrib/tools/cython/Cython/Includes)
}

# tag:python-processing tag:internal
### @usage: _SWIG_PYTHON_CPP(Src, DstSubPrefix) # internal
###
### Run swig on Src to produce DstSubPrefix.py and DstSubPrefix_swg.cpp that
### provides DstSubPrefix_swg python module.
macro _SWIG_PYTHON_CPP(Src, DstSubPrefix) {
    .CMD=$_SWIG_TOOL -I$ARCADIA_BUILD_ROOT -I$ARCADIA_ROOT -I$_SWIG_LIBRARY_ABS/python -I$_SWIG_LIBRARY_ABS -c++ -python -module ${nopath:DstSubPrefix} -interface ${nopath;suf=_swg:DstSubPrefix} -o ${output;suf=.swg.cpp:DstSubPrefix} ${input:Src} ${output;noauto;hide;suf=.py:DstSubPrefix} ${kv;hide:"p SW"} ${kv;hide:"pc yellow"}
    ADDINCL(FOR swig $_SWIG_LIBRARY/python FOR swig $_SWIG_LIBRARY)
}

# tag:python-processing tag:internal
### @usage: _SWIG_PYTHON_C(Src, DstSubPrefix) # internal
###
### Like _SWIG_PYTHON_CPP but generate DstSubPrefix_swg.c.
macro _SWIG_PYTHON_C(Src, DstSubPrefix) {
    .CMD=$_SWIG_TOOL -I$ARCADIA_BUILD_ROOT -I$ARCADIA_ROOT -I$_SWIG_LIBRARY_ABS/python -I$_SWIG_LIBRARY_ABS -python -module ${nopath:DstSubPrefix} -interface ${nopath;suf=_swg:DstSubPrefix} -o ${output;suf=.swg.c:DstSubPrefix} ${input:Src} ${output;noauto;hide;suf=.py:DstSubPrefix} ${kv;hide:"p SW"} ${kv;hide:"pc yellow"}
    ADDINCL(FOR swig $_SWIG_LIBRARY/python FOR swig $_SWIG_LIBRARY)
}

### @usage: BUILDWITH_RAGEL6(Src Options...)
###
### Compile .rl file using Ragel6.
macro BUILDWITH_RAGEL6(Src, Options...) {
    .CMD=$RUN_NO_SANITIZE ${tool:"contrib/tools/ragel6"} $RAGEL6_FLAGS ${Options} -I${ARCADIA_ROOT} -o ${output;nopath;noext;defext=.rl6.cpp:Src} ${input:Src} ${kv;hide:"p R6"} ${kv;hide:"pc yellow"}
}

# tag:python-processing tag:internal
# TODO: use it in [.pyx] cmd
### @usage: _PY_REGISTER() # internal
###
### Register Python 2.x module in internal resource file system. Arcadia Python 2.x importer will be retrieve these on import directive.
###
### Documentation: https://wiki.yandex-team.ru/devtools/commandsandvars/pysrcs/#makrospyregister
macro _PY_REGISTER(Func) {
    .CMD=$YMAKE_PYTHON ${input:"build/scripts/gen_py_reg.py"} $Func ${output;noauto:Func.reg.cpp} ${kv;hide:"p PY"} ${kv;hide:"pc yellow"}
    SRCS(GLOBAL $Func.reg.cpp)
}

# tag:python-processing tag:internal
### @usage: _PY3_REGISTER() # internal
###
### Register Python 3.x module in internal resource file system. Arcadia Python 3.x importer will be retrieve these on import directive
###
### Documentation: https://wiki.yandex-team.ru/devtools/commandsandvars/pysrcs/#makrospyregister
macro _PY3_REGISTER(Func) {
    .CMD=$YMAKE_PYTHON ${input:"build/scripts/gen_py3_reg.py"} $Func ${output;noauto:Func.reg3.cpp} ${kv;hide:"p PY"} ${kv;hide:"pc yellow"}
    SRCS(GLOBAL $Func.reg3.cpp)
}

# tag:python-processing tag:internal
### @usage: _PY_COMPILE_BYTECODE(SrcX Src) # internal
###
### Compile Python 2.x .py source file into Arcadia binary form suitable for PY2_PROGRAM
###
### Documentation: https://wiki.yandex-team.ru/devtools/commandsandvars/pysrcs/#makrospyregister
macro _PY_COMPILE_BYTECODE(SrcX, Src, Dst) {
    .CMD=$YMAKE_PYTHON ${input:"build/scripts/py_compile.py"} $SrcX ${input:Src} ${output;noauto:Dst.yapyc} ${kv;hide:"p PY"} ${kv;hide:"pc yellow"}
}

# tag:python-processing tag:internal
### @usage: _PY3_COMPILE_BYTECODE(SrcX Src) # internal
###
### Compile Python 3.x .py source file into Arcadia binary form suitable for PY3_PROGRAM
###
### Documentation: https://wiki.yandex-team.ru/devtools/commandsandvars/pysrcs/#makrospyregister
macro _PY3_COMPILE_BYTECODE(SrcX, Src, Dst) {
    .CMD=${env:"PYTHONHASHSEED=0"} ${tool:"contrib/tools/python3/pycc"} $SrcX ${input:Src} ${output;noauto:Dst.yapyc3} ${kv;hide:"p PY"} ${kv;hide:"pc yellow"}
}

macro _ARCHIVE_SEM_HELPER(OUT, DONTCOMPRESS, Files...) {
    .SEM=add_custom_command OUTPUT ${OUT} DEPENDS ${Files} COMMAND $ARCH_TOOL -q $DONTCOMPRESS ${join=\: :Files}: -o ${OUT}
}

### @usage: ARCHIVE_ASM(NAME archive_name files...)
###
### Similar to the macro ARCHIVE, but:
### 1. works faster and it is better to use for large files.
### 2. Different syntax (see examples in codesearch or users/pg/tests/archive_test)
macro ARCHIVE_ASM(NAME="", DONTCOMPRESS?"-p":"", Files...) {
    .CMD=$ARCH_TOOL -q $DONTCOMPRESS ${input;join=\: :Files}: -o ${output;chksum;suf=$OBJ_SUF.rodata:NAME} ${kv;hide:"p AR"} ${kv;hide:"pc light-cyan"}
    .SEM=$_ARCHIVE_SEM_HELPER(${output;suf=$OBJ_SUF.rodata:NAME}, $DONTCOMPRESS, ${input:Files})
}

# tag:yweb-specific
macro PIRE_INLINE_CMD(SRC) {
   .CMD=${tool:"library/cpp/regex/pire/inline"} -o ${output:SRC} ${input:SRC} ${output_include;hide:SRC} ${kv;hide:"p PI"} ${kv;hide:"pc yellow"}
}

# tag:yweb-specific
macro PIRE_INLINE(FILES...) {
    foreach (FILE : $FILES) {
        PIRE_INLINE_CMD($FILE)
    }
}

### @usage: ARCHIVE(archive_name [DONT_COMPRESS] files...)
###
### Add arbitrary data to a modules. Unlike RESOURCE macro the result should be futher processed by othet macros in the module.
###
### Example: https://wiki.yandex-team.ru/yatool/howtowriteyamakefiles/#a1ispolzujjtekomanduarchive
macro ARCHIVE(NAME="", DONTCOMPRESS?"-p":"", Files...) {
    .CMD=$ARCH_TOOL -q -x $DONTCOMPRESS ${input;join=\: :Files}: -o ${output;chksum;addincl;noauto:NAME} ${kv;hide:"p AR"} ${kv;hide:"pc light-red"}
    .SEM=$_ARCHIVE_SEM_HELPER(${output;addincl;noauto:NAME}, $DONTCOMPRESS, ${input:Files})
}

### @usage: ARCHIVE_BY_KEYS(archive_name key [DONT_COMPRESS] files...)
###
### Add arbitrary data to a module be accessible by specified key.
### Unlike RESOURCE macro the result should be futher processed by othet macros in the module.
###
### Example: https://wiki.yandex-team.ru/yatool/howtowriteyamakefiles/#a1ispolzujjtekomanduarchive
macro ARCHIVE_BY_KEYS(NAME="", KEYS="", DONTCOMPRESS?"-p":"", Files...) {
    .CMD=$ARCH_TOOL -q -x $DONTCOMPRESS ${input:Files} -k $KEYS -o ${output;chksum;addincl;noauto:NAME} ${kv;hide:"p AR"} ${kv;hide:"pc light-red"}
}

#scripts

#special commands
BUILDVERSION_SCRIPT=build/scripts/build_info_gen.py
SVNVERSION_JAVA_MARKER=output-java-class
SVNVERSION_GO_MARKER=output-go
VCS_C_OBJ=$BINDIR/__vcs_version__.c$OBJECT_SUF
VCS_C_OBJ_RR=$MODDIR/__vcs_version__.c$OBJECT_SUF
VCS_C=$BINDIR/__vcs_version__.c
VCS_GO=$BINDIR/__vcs_version__.go
VCS_JAVA=$BINDIR/__vcs_version__.mf
VCS_INFO_DISABLE_CACHE__NO_UID__=
YASM_DEBUG_INFO_DISABLE_CACHE__NO_UID__=
CL_DEBUG_INFO_DISABLE_CACHE__NO_UID__=
CL_MACRO_INFO_DISABLE_CACHE__NO_UID__=
YASM_DEBUG_INFO=
CL_DEBUG_INFO=
CL_MACRO_INFO=
when ($FORCE_VCS_INFO_UPDATE == "yes") {
    VCS_INFO_DISABLE_CACHE__NO_UID__=${hide;kv:"disable_cache"}
}
### Works for pyton too.
GENERATE_VCS_C_INFO_NODEP=$YMAKE_PYTHON ${input:"build/scripts/vcs_info.py"} $(VCS)/vcs.json $VCS_C ${input:"build/scripts/c_templates/svn_interface.c"} $VCS_INFO_DISABLE_CACHE__NO_UID__ && $_SRC_c_nodeps($VCS_C, $VCS_C_OBJ, $(SOURCE_ROOT))
GENERATE_VCS_GO_INFO_NODEP=$YMAKE_PYTHON ${input:"build/scripts/vcs_info.py"} output-go $(VCS)/vcs.json $VCS_GO $VCS_INFO_DISABLE_CACHE__NO_UID__
GENERATE_VCS_JAVA_INFO_NODEP=$YMAKE_PYTHON ${input:"build/scripts/vcs_info.py"} output-java $(VCS)/vcs.json $VCS_JAVA $VCS_INFO_DISABLE_CACHE__NO_UID__
macro UPDATE_VCS_JAVA_INFO_NODEP(Jar) {
    .CMD=$YMAKE_PYTHON ${input:"build/scripts/vcs_info.py"} output-java $(VCS)/vcs.json $VCS_JAVA $Jar $VCS_INFO_DISABLE_CACHE__NO_UID__
}

### @usage: CREATE_BUILDINFO_FOR(GenHdr)
###
### Creates header file to access some information about build specified via configuration variables.
### Unlike CREATE_SVNVERSION_FOR() it doesn't take revion information from VCS, it uses revision and SandboxTaskId passed via -D options to ya make
macro CREATE_BUILDINFO_FOR(GenHdr) {
    .CMD=$YIELD $CXX_COMPILER && $YIELD $CXXFLAGS && $XARGS $YMAKE_PYTHON ${input:BUILDVERSION_SCRIPT} ${output:GenHdr} ${kv;hide:"p BI"} ${kv;hide:"pc yellow"} ${hide;kv:"show_out"} $SVN_DEPENDS_CACHE__NO_UID__
    .SEM=$PYTHON($BUILDVERSION_SCRIPT $GenHdr \\\"${CMAKE_CXX_COMPILER}\\\" \\\"${CMAKE_CXX_FLAGS}\\\" OUT $GenHdr)
}

DECIMAL_MD5_SCRIPT=build/scripts/decimal_md5.py
DECIMAL_MD5_FIXED=

### @usage: DECIMAL_MD5_LOWER_32_BITS(<fileName> [FUNCNAME funcName] [inputs...])
###
### Generates .cpp file <fileName> with one defined function 'const char* <funcName>() { return "<calculated_md5_hash>"; }'.
### <calculated_md5_hash> will be md5 hash for all inputs passed to this macro.
macro DECIMAL_MD5_LOWER_32_BITS(File, FUNCNAME="", Opts...) {
    .CMD=$YMAKE_PYTHON ${input:DECIMAL_MD5_SCRIPT} --fixed-output=${DECIMAL_MD5_FIXED} --func-name=${FUNCNAME} --lower-bits 32 --source-root=$ARCADIA_ROOT ${input;context=TEXT:Opts} ${output;stdout;chksum:File} ${kv;hide:"p SV"} ${kv;hide:"pc yellow"} ${hide;kv:"show_out"}
}

# tag:internal
### @usage $CFG_VARS # internal
###
### Mark commands that embed Configuration variables into files
macro CFG_VARS() {
    .GEN_FROM_FILE=yes
}

### @usage: CONFIGURE_FILE(from to)
###
### Copy file with the replacement of configuration variables in form of @ANY_CONF_VAR@ with their values.
### The values are collected during configure stage, while replacement itself happens during build stage.
### Used implicitly for .in-files processing.
macro CONFIGURE_FILE(Src, Dst) {
    .CMD=$YMAKE_PYTHON ${input:"build/scripts/configure_file.py"} ${input:Src} ${output;addincl:Dst} $CFG_VARS ${kv;hide:"p CF"} ${kv;hide:"pc yellow"}
    .SEM=set_vars ${CFG_VARS} && configure_file $S/${input;rootrel:Src} $B/${output;rootrel:Dst}
}

### @usage: BASE_CODEGEN(tool_path prefix)
###
### Generator ${prefix}.cpp + ${prefix}.h files based on ${prefix}.in.
macro BASE_CODEGEN(Tool, Prefix, Opts...) {
    .CMD=${tool:Tool} ${input:Prefix.in} ${output;nopath;noauto:Prefix.cpp} ${output;nopath:Prefix.h} $Opts ${kv;hide:"p BC"} ${kv;hide:"pc yellow"}
}

# tag:internal
### @usage: _SPLIT_CODEGEN_BASE(tool prefix OUTS[] OUTPUT_INCLUDES[]) # internal
###
### Generator of a certain number .the. cpp file + one header .h file from .in.
### This is the call of the generator. Python macro SPLIT_CODEGEN() is defined in order to properly fill command outputs from OUT_NUM argument.
macro _SPLIT_CODEGEN_BASE(Tool, Prefix, OUT[], OPTS[], OUTPUT_INCLUDES[]) {
    .CMD=${tool:Tool} ${input:Prefix.in} ${output;hide:OUT} ${output;nopath;noauto:Prefix.cpp} ${output;nopath:Prefix.h} $OPTS ${output_include;hide:OUTPUT_INCLUDES} ${kv;hide:"p SC"} ${kv;hide:"pc yellow"}
}

STRUCT_CODEGEN_OUTPUT_INCLUDES=${output_include;hide:"util/generic/singleton.h"} \
${output_include;hide:"util/generic/strbuf.h"} \
${output_include;hide:"util/generic/vector.h"} \
${output_include;hide:"util/generic/ptr.h"} \
${output_include;hide:"util/generic/yexception.h"} \
${output_include;hide:"kernel/struct_codegen/reflection/reflection.h"} \
${output_include;hide:"kernel/struct_codegen/reflection/floats.h"}

### @usage: STRUCT_CODEGEN(Prefix)
### A special case BASE_CODEGEN, in which the kernel/struct_codegen/codegen_tool tool is used.
macro STRUCT_CODEGEN(Prefix) {
    .CMD=$BASE_CODEGEN(kernel/struct_codegen/codegen_tool, $Prefix, $STRUCT_CODEGEN_OUTPUT_INCLUDES)
    .PEERDIR=kernel/struct_codegen/metadata kernel/struct_codegen/reflection
}

### @usage: DUMPERF_CODEGEN(Prefix)
### A special case BASE_CODEGEN, in which the extsearch/images/robot/tools/dumperf/codegen tool is used
macro DUMPERF_CODEGEN(Prefix) {
    .CMD=$BASE_CODEGEN(extsearch/images/robot/tools/dumperf/codegen, $Prefix, ${output_include;hide:"extsearch/images/kernel/erf/erf_format.h"})
}

# tag:flags
### @usage: LDFLAGS(LinkerFlags...)
###
### Add flags to the link command line of executable or shared library/dll.
### Note: LDFLAGS are always global. When set in the LIBRARY module they will affect all programs/dlls/tests the library is linked into.
### Note: remember about the incompatibility of flags for gcc and cl.
macro LDFLAGS(Flags...) {
    SET_APPEND(LDFLAGS_GLOBAL $Flags)
}

# tag:flags
### @usage: CFLAGS([GLOBAL compiler_flag]* compiler_flags)
###
### Add the specified flags to the compilation command of C and C++ files.
### @params: GLOBAL - Propagates these flags to dependent projects
### Note: remember about the incompatibility flags for clang and cl (to set flags specifically for cl.exe use MSVC_FLAGS).
macro CFLAGS(Flags...) {
   SET_APPEND_WITH_GLOBAL(USER_CFLAGS $Flags)
}

# tag:flags
### @usage: MASMFLAGS(compiler flags)
### Add the specified flags to the compilation command of .masm files.
macro MASMFLAGS(Flags...) {
   SET_APPEND(MASMFLAGS $Flags)
}

# tag:flags
### @usage: CONLYFLAGS([GLOBAL compiler_flag]* compiler_flags)
### Add the specified flags to the compilation command of .c (but not .cpp) files.
### @params: GLOBAL - Distributes these flags on dependent projects
macro CONLYFLAGS(Flags...) {
   SET_APPEND_WITH_GLOBAL(USER_CONLYFLAGS $Flags)
}

# tag:flags
### @usage: CXXFLAGS(compiler_flags)
### Add the specified flags to the compilation command of .cpp (but not .c) files.
macro CXXFLAGS(Flags...) {
   SET_APPEND_WITH_GLOBAL(USER_CXXFLAGS $Flags)
}

# tag:flags
### @usage: CUDA_NVCC_FLAGS(compiler flags)
### Add the specified flags to the compile line .cu-files.
macro CUDA_NVCC_FLAGS(Flags...) {
   SET_APPEND(CUDA_NVCC_FLAGS $Flags)
}

# tag:flags
### @usage: NVCC_DEVICE_LINK(file.cu...)
### Run nvcc --device-link on objects compiled from srcs with --device-c.
### This generates a stub object devlink.o that supplies missing pieces for the
### host linker to link relocatable device objects into the final executable.
macro NVCC_DEVICE_LINK(Srcs...) {
    .CMD=$NVCC $NVCC_FLAGS -o ${output;suf=${OBJ_SUF}${NVCC_OBJ_EXT}:"devlink"} -dlink ${input;suf=${OBJ_SUF}${NVCC_OBJ_EXT}:Srcs} ${kv;hide:"p DL"} ${kv;hide:"pc light-blue"}
}

### @usage: STRIP()
### Strip debug info from a PROGRAM, DLL or TEST.
### This macro doesn't work in LIBRARY's, UNION's and PACKAGE's.
macro STRIP() {
    ENABLE(STRIP)
}

### @usage: NO_OPTIMIZE()
### Build code without any optimizations (-O0 mode).
macro NO_OPTIMIZE() {
    ENABLE(NO_OPTIMIZE)
}

### @usage: NO_COMPILER_WARNINGS()
### Disable all compiler warnings in the module.
### Priorities: NO_COMPILER_WARNINGS > NO_WERROR > WERROR_MODE > WERROR.
macro NO_COMPILER_WARNINGS() {
    ENABLE(NO_COMPILER_WARNINGS)
}

### @usage: WERROR()
### Consider warnings as errors in the current module.
### In the bright future will be removed, since WERROR is the default.
### Priorities: NO_COMPILER_WARNINGS > NO_WERROR > WERROR_MODE > WERROR.
macro WERROR() {
    ENABLE(WERROR)
}

### @usage: NO_WERROR()
### Override WERROR() behavior
### Priorities: NO_COMPILER_WARNINGS > NO_WERROR > WERROR_MODE > WERROR.
macro NO_WERROR() {
    DISABLE(WERROR)
}

### @usage: NO_WSHADOW()
### Disable C++ shadowing warnings.
macro NO_WSHADOW() {
    ENABLE(NO_WSHADOW)
}

# tag:internal
### @usage: NO_PLATFORM_RESOURCES() # internal
### Exclude dependency on platform resources libraries.
### Most probably you'll never need this. If you think you need, please contact devtools@ for assistance.
macro NO_PLATFORM_RESOURCES() {
    ENABLE(NOPLATFORM_RESOURCES)
}

# tag:internal tag:codenav
### @usage: NO_CODENAVIGATION() # internal
### Disable codenaviagtion for a module. Needed to avoid PEERDIR loops in codenavigation support.
### Most probably you'll never need this. If you think you need, please contact devtools@ for assistance.
macro NO_CODENAVIGATION() {
    ENABLE(NOCODENAVIGATION)
}

### @usage: NO_UTIL()
### Build module without dependency on util.
### Note: use this with care. Util most likely will be linked into executable anyway,
### so using util headers/functions/classes may not be detected at build time and may lead to unpredictable behavors at configure time.
macro NO_UTIL() {
    ENABLE(NOUTIL)
}

### @usage: NO_RUNTIME()
###
### This macro:
### 1. Sets the ENABLE(NOUTIL) + DISABLE(USE_INTERNAL_STL);
### 2. If the project that contains the macro NO_RUNTIME(), peerdir-it project does not contain NO_RUNTIME() => Warning.
### Note: use this with care. Arcadia STL most likely will be linked into executable anyway, so using STL headers/functions/classes
### may not be detected at build time and may lead to unpredictable behavors at configure time.
macro NO_RUNTIME() {
    SET(USE_ARCADIA_LIBM no)
    NO_UTIL()
    ENABLE(NORUNTIME)
}

### @usage: NO_LIBC()
###
### Exclude dependencies on C++ and C runtimes (including util, musl and libeatmydata).
### Note: use this with care. libc most likely will be linked into executable anyway,
### so using libc headers/functions may not be detected at build time and may lead to unpredictable behavors at configure time.
macro NO_LIBC() {
    NO_RUNTIME()
    DISABLE(MUSL)
}

### @usage: NO_PLATFORM()
###
### Exclude dependencies on C++ and C runtimes (including util, musl and libeatmydata) and set NO_PLATFORM variable for special processing.
### Note: use this with care. libc most likely will be linked into executable anyway,
### so using libc headers/functions may not be detected at build time and may lead to unpredictable behavors at configure time.
macro NO_PLATFORM() {
    NO_LIBC()
    ENABLE(NOPLATFORM)
}

# tag:cpp-specific
### @usage: USE_CXX()
###
### Add dependency on C++ runtime
### Note: This macro is inteneded for use in _GO_BASE_UNIT like module when the module is built without C++ runtime by default
macro USE_CXX() {
    DISABLE(NORUNTIME)
}

### @usage: USE_UTIL()
###
### Add dependency on util and C++ runtime
### Note: This macro is intended for use in _GO_BASE_UNIT like module when the module is build without util by default
macro USE_UTIL() {
    USE_CXX()
    DISABLE(NOUTIL)
}

# tag:deprecated
### @usage: NO_JOIN_SRC() # deprecated, does-nothing
### This macro currently does nothing. This is default behavior which cannot be overridden at module level.
macro NO_JOIN_SRC() {
    ENABLE(UNUSED_MACRO)
}

# tag:deprecated
### @usage: JOINSRC() # deprecated, does-nothing
### This macro currently does nothing. Use JOIN_SRCS and similar macros to make one file of set of sources.
macro JOINSRC() {
    ENABLE(UNUSED_MACRO)
}

# tag:sanitize
### @usage: NO_SANITIZE()
###
### Disable all sanitizers for the module.
macro NO_SANITIZE() {
    DISABLE(SANITIZER_TYPE)
}

# tag:coverage tag:sanitize
### @usage: NO_SANITIZE_COVERAGE()
###
### Disable lightweight coverage (-fsanitize-coverage) for the module.
macro NO_SANITIZE_COVERAGE() {
    DISABLE(SANITIZE_COVERAGE)
}

# tag:coverage
### @usage: NO_CLANG_COVERAGE()
###
### Disable heavyweight clang coverage for the module
macro NO_CLANG_COVERAGE() {
    DISABLE(CLANG_COVERAGE)
}

macro NO_CLANG_TIDY() {
    DISABLE(TIDY)
}

# tag:python-specific tag:coverage
### @usage: NO_PYTHON_COVERAGE()
###
### Disable python coverage for module
macro NO_PYTHON_COVERAGE() {
    DISABLE(PYTHON_COVERAGE)
}

# tag:python-specific tag:coverage tag:cython
### @usage: NO_CYTHON_COVERAGE()
###
### Disable cython and cythonized python coverage (CYTHONIZE_PY)
### Implies NO_CLANG_COVERAGE() - right now, we can't disable instrumentation for .py.cpp files, but enable for .cpp
macro NO_CYTHON_COVERAGE() {
    DISABLE(CYTHON_COVERAGE)
    NO_CLANG_COVERAGE()
}

# tag:lua-specific
LUAJIT_PATH=${ARCADIA_ROOT}/contrib/libs/luajit
macro _LUAJIT_OBJDUMP(Src, OUT="") {
   .CMD=${cwd:LUAJIT_PATH} ${tool:"contrib/libs/luajit/compiler"} -b -g ${input:Src} ${output;noauto:OUT} ${kv;hide:"p LJ"} ${kv;hide:"pc light-cyan"}
}

# tag:lua-specific
LUAJIT_21_PATH=${ARCADIA_ROOT}/contrib/libs/luajit_21
macro _LUAJIT_21_OBJDUMP(Src, OUT="") {
   .CMD=${cwd:LUAJIT_21_PATH} ${tool:"contrib/libs/luajit_21/compiler"} -b -g ${input:Src} ${output;noauto:OUT} ${kv;hide:"p LJ"} ${kv;hide:"pc light-cyan"}
}

macro _MX_BIN_TO_INFO(Src) {
    .CMD=${tool:"tools/mx_bin2info"} ${input:Src} ${output;nopath;noext;noauto:Src.info} ${kv;hide:"p MX"} ${kv;hide:"pc yellow"}
}

MX_GEN_TABLE_INCLS=${output_include;hide:"yabs_mx_calc_table.h"} \
${output_include;hide:"kernel/matrixnet/mn_sse.h"} \
${output_include;hide:"library/cpp/archive/yarchive.h"} \
${output_include;hide:"util/memory/blob.h"} \
${output_include;hide:"util/generic/hash.h"} \
${output_include;hide:"util/generic/ptr.h"} \
${output_include;hide:"util/generic/singleton.h"}

macro _MX_GEN_TABLE(Srcs...) {
   .CMD=$YMAKE_PYTHON ${input:"build/scripts/gen_mx_table.py"} $Srcs ${output;stdout:"mx_tables.cpp"} $MX_GEN_TABLE_INCLS ${kv;hide:"p MX"} ${kv;hide:"pc yellow"}
   PEERDIR(kernel/matrixnet)
   PEERDIR(library/cpp/archive)
}

RELEV_FML_CODEGEN_INCLS=${output_include;hide:"kernel/relevfml/relev_fml.h"} ${output_include;hide:"library/cpp/sse/sse.h"}

### @usage: GENERATE_ENUM_SERIALIZATION(File.h)
###
### Create serialization support for enumeration members defined in the header (String <-> Enum conversions) and compile it into the module.
###
### Documentation: https://wiki.yandex-team.ru/yatool/HowToWriteYaMakeFiles/
macro GENERATE_ENUM_SERIALIZATION(File) {
    .CMD=$ENUM_PARSER_TOOL ${input:File} --include-path ${input;rootrel:File} --output ${output;chksum;suf=_serialized.cpp:File} ${output_include;hide:File} ${output_include;hide:"util/generic/serialized_enum.h"} ${kv;hide:"p EN"} ${kv;hide:"pc yellow"}
    .SEM=generate_enum_serilization ${input:File} ${output;hide;suf=_serialized.o:File} INCLUDE_HEADERS ${input;rootrel:File} ${tool;hide:"tools/enum_parser/enum_parser/bin"}
    PEERDIR(tools/enum_parser/enum_serialization_runtime)
}

### @usage: GENERATE_ENUM_SERIALIZATION_WITH_HEADER(File.h)
###
### Create serialization support for enumeration members defined in the header (String <-> Enum conversions) and compile it into the module
### Provide access to serialization functions via generated header File_serialized.h
###
### Documentation: https://wiki.yandex-team.ru/yatool/HowToWriteYaMakeFiles/
macro GENERATE_ENUM_SERIALIZATION_WITH_HEADER(File) {
    .CMD=$ENUM_PARSER_TOOL ${input:File} --include-path ${input;rootrel:File} --output ${output;chksum;suf=_serialized.cpp:File} --header ${output;chksum;suf=_serialized.h:File} ${output_include;hide:File} ${kv;hide:"p EN"} ${kv;hide:"pc yellow"}
    .SEM=generate_enum_serilization ${input:File} ${output;hide;suf=_serialized.o:File} GEN_HEADER ${output;suf=_serialized.h:File} INCLUDE_HEADERS ${input;rootrel:File} ${tool;hide:"tools/enum_parser/enum_parser/bin"}
    PEERDIR(tools/enum_parser/enum_serialization_runtime)
}

### @usage: DEB_VERSION(File)
###
### Creates a header file DebianVersion.h define the DEBIAN_VERSION taken from the File.
macro DEB_VERSION(File) {
    .CMD=$YMAKE_PYTHON ${input:"build/scripts/mkver.py"} ${input:File} ${output;stdout:"DebianVersion.h"} ${kv;hide:"p CL"} ${kv;hide:"pc yellow"}
}

BUILD_MN_SCRIPT=build/scripts/build_mn.py

# tag:matrixnet
### @usage: BUILD_MN([CHECK] [PTR] [MULTI] mninfo mnname) # matrixnet
###
### Generate MatrixNet data and access code using single command.
### Alternative macro BUILD_MNS() works faster and better for large files.
macro BUILD_MN(MnInfo, MnName, CHECK?"fml_tool=$FML_UNUSED_TOOL CHECK":"", MULTI?, PTR?, RANKING_SUFFIX="") {
    .CMD=$YMAKE_PYTHON ${input:BUILD_MN_SCRIPT} BuildMnF $ARCADIA_ROOT $ARCH_TOOL ${input:MnInfo} $MnName ranking_suffix=$RANKING_SUFFIX ${output;chksum;pre=mn.:MnName.cpp} ${output;hide;pre=MN_External_;suf=.rodata:MnName} ${output_include;hide:"kernel/matrixnet/mn_sse.h"} $CHECK $MULTI $PTR ${kv;hide:"p MN"} ${kv;hide:"pc yellow"}
}

macro _BUILD_MNS_FILE(Input, Name, Output, Suffix, Check, Fml_tool, AsmDataName) {
    .CMD=$YMAKE_PYTHON ${input:BUILD_MN_SCRIPT} BuildMnsFilesF $ARCADIA_ROOT $BINDIR $ARCH_TOOL fml_tool=$Fml_tool $Name ranking_suffix=$Suffix ${input:Input} ${output;hide:Output} ${output;hide;pre=MN_External_;suf=.rodata:AsmDataName} ${output_include;hide:"kernel/matrixnet/mn_sse.h"} ${kv;hide:"p MN"} ${kv;hide:"pc yellow"}
}

MNS_OUTPUT=mnmodels

macro _BUILD_MNS_CPP(NAME="", CHECK?, RANKING_SUFFIX="", Files...) {
    .CMD=$YMAKE_PYTHON ${input:BUILD_MN_SCRIPT} BuildMnsCppF $NAME ranking_suffix=$RANKING_SUFFIX ${input:MNS_OUTPUT.h} ${output:MNS_OUTPUT.cpp} ${input:Files} ${output_include;hide:MNS_OUTPUT.h} ${output_include;hide:"kernel/matrixnet/mn_sse.h"} ${kv;hide:"p MN"} ${kv;hide:"pc yellow"}
}

macro _BUILD_MNS_HEADER(NAME="", CHECK?, RANKING_SUFFIX="", Files...) {
    .CMD=$YMAKE_PYTHON ${input:BUILD_MN_SCRIPT} BuildMnsHeaderF $NAME ranking_suffix=$RANKING_SUFFIX ${output:MNS_OUTPUT.h} ${input:Files} ${output_include;hide:"kernel/matrixnet/mn_sse.h"} ${output_include;hide:"kernel/matrixnet/mn_multi_categ.h"} ${kv;hide:"p MN"} ${kv;hide:"pc yellow"}
}

# TODO: support foreach_in and keywords simultaneous usage (look at BUILD_MNS_FILES)

# tag:matrixnet
### @usage: BUILD_MNS([CHECK] NAME listname mninfos...) # matrixnet
###
### Generate MatrixNet data and access code using separate commands for support code, interface and data.
### Faster version of BUILD_MN() macro for large files.
macro BUILD_MNS(Files...) {
    _BUILD_MNS_HEADER($Files)
    _BUILD_MNS_CPP($Files)
    _BUILD_MNS_FILES($Files)
}

### @usage: COMPILE_NLG(Src...)
###
### Generate and compile .nlg templates (Jinja2-based) and interface for megamind runtime.
###
### Alice-specific macro
macro COMPILE_NLG(Src...) {
    PEERDIR(alice/nlg/library/runtime)
    RUN_PROGRAM(alice/nlg/tools/codegen compile-cpp --import-dir ${ARCADIA_ROOT} --out-dir ${ARCADIA_BUILD_ROOT} --include-prefix ${MODDIR} ${Src} IN ${Src} OUT_NOAUTO register.cpp register.h ${suf=.cpp:Src} ${suf=.h:Src} ${suf=.pb.txt:Src})
    SRCS(GLOBAL register.cpp ${suf=.cpp:Src})
}

### @usage: NEED_CHECK()
###
### Commits to the project marked with this macro will be blocked by pre-commit check and then will be
### automatically merged to trunk only if there is no new broken build targets in check results.
### The use of this macro is disabled by default.
macro NEED_CHECK(Flags...) {
    # TODO: FIXME
    ENABLE(UNUSED_MACRO)
}

### @usage: NO_NEED_CHECK()
###
### Commits to the project marked with this macro will not be affected by higher-level NEED_CHECK macro.
macro NO_NEED_CHECK(Flags...) {
    ENABLE(UNUSED_MACRO)
}

# tag:deprecated
### @usage: NEED_REVIEW() # deprecated
###
### Mark the project as needing review.
### Reviewers are listed in the macro OWNER. The use of this macro is disabled by default.
### Details can be found here: https://clubs.at.yandex-team.ru/arcadia/6104
macro NEED_REVIEW(Flags...) {
    # TODO: FIXME
    ENABLE(UNUSED_MACRO)
}

### @usage: VERSION(Args...)
###
### Specify version of a module. Currently unused by build system, only informative.
macro VERSION(Flags...) {
    ENABLE(UNUSED_MACRO)
}

DATAWORK_SCHEEME_EXPORT_FLAGS=

when ($UNIX == "yes") {
    SCHEEME2_CFLAGS= -E -x c++
}

when ($WIN32 == "yes") {
    SCHEEME2_CFLAGS= /E /TP
}

SCHEEME2_STRUCT_INFO_FLAGS=-f "const static ui32 RecordSig" -u "RecordSig" --gcc44_no_typename --no_complex_overloaded_func_export
### @usage: GEN_SCHEEME2(scheeme_name from_file dependent_files...)
###
### Generates a C++ description for structure(contains the field RecordSig) in the specified file (and connected).
###
### 1. ${scheeme_name}.inc - the name of the generated file.
### 2. Use an environment variable - DATAWORK_SCHEEME_EXPORT_FLAGS that allows to specify flags to tools/structparser
###
### @example:
###
###     SET(DATAWORK_SCHEEME_EXPORT_FLAGS --final_only -m "::")
###
### all options are passed to structparser (in this example --final_only - do not export heirs with public base that contains the required field,,- m "::" only from the root namespace)
### sets in extra option
###
### @example:
###
###     SET(EXTRACT_STRUCT_INFO_FLAGS -f \"const static ui32 RecordSig\"
###         -u \"RecordSig\" -n${scheeme_name}SchemeInfo ----gcc44_no_typename no_complex_overloaded_func_export
###         ${DATAWORK_SCHEEME_EXPORT_FLAGS})
###
### for compatibility with C++ compiler and the external environment.
### See tools/structparser for more details.
macro GEN_SCHEEME2(ScheemeName, FromFile) {
    .CMD=$CXX_COMPILER $C_FLAGS_PLATFORM -c ${tmp;stdout:FromFile.cph} $SCHEEME2_CFLAGS ${input:FromFile} ${pre=-I:_C__INCLUDE} $CXXFLAGS -Wno-error && ${tool:"tools/structparser"} -o ${output:ScheemeName.inc} -n N${ScheemeName}SchemeInfo $SCHEEME2_STRUCT_INFO_FLAGS $DATAWORK_SCHEEME_EXPORT_FLAGS ${tmp:FromFile.cph} ${output;stdout;noauto:ScheemeName.inc.log} ${kv;hide:"p SH"} ${kv;hide:"pc yellow"}
}

### @usage: SYMLINK(from to)
### Add symlink
macro SYMLINK(From, To) {
    .CMD=$YMAKE_PYTHON ${input:"build/scripts/symlink.py"} ${input;dirallowed:From} ${output;noauto:To} ${kv;hide:"p LN"} ${kv;hide:"pc light-cyan"}
}

# tag:internal
### @usage: _TARGET_SOURCES_FOR_HEADERS_IMPL([GENERATE] Args...) # internal
### Generate prefix " && target_sources PRIVATE " before $Args when GENERATE is specified in the list of actual arguments
macro _TARGET_SOURCES_FOR_HEADERS_IMPL(GENERATE?" && target_sources PRIVATE ":"", Args...) {
    .SEM=$GENERATE ${output;ext=.h:Args} ${output;ext=.hh:Args} ${output;ext=.hpp:Args} ${output;ext=.inc:Args} ${output;ext=.i:Args}
}

# tag:internal
### @usage: _TARGET_SOURCES_FOR_HEADERS(Args...) # internal
### Generate prefix " && target_sources PRIVATE " before $Args if Args is not empty
macro _TARGET_SOURCES_FOR_HEADERS(Args...) {
    .SEM=$_TARGET_SOURCES_FOR_HEADERS_IMPL(${pre=GENERATE :Args})
}

# tag:internal
### @usage: _TARGET_SOURCES_FOR_HEADERS_IMPL([GENERATE] Args...) # internal
### Generate prefix " ${CMAKE_COMMAND} -E env " before $Args when GENERATE is specified in the list of actual arguments
macro _SET_ENV_FOR_CUSTOM_COMMAND_IMPL(GENERATE?" ${CMAKE_COMMAND} -E env ":"", Args...) {
    .SEM=$GENERATE ${pre= :Args}
}

# tag:internal
### @usage: _SET_ENV_FOR_CUSTOM_COMMAND(Args...) # internal
### Generate prefix " ${CMAKE_COMMAND} -E env " before $Args if Args is not empty
macro _SET_ENV_FOR_CUSTOM_COMMAND(Args...) {
    .SEM=$_SET_ENV_FOR_CUSTOM_COMMAND_IMPL(${pre=GENERATE :Args})
}


macro _FMT_INDUCED_DEPS(For, Deps...) {
    .CMD=${induced_deps=$For:Deps}
}


### @usage: PREPARE_INDUCED_DEPS(VAR Type Files...)
###
### Format value for `INDUCED_DEPS` param in certain macros and assign to `VAR`
### This tells that files of Type resulted from code generation macros (not neccessarily directly,
### but in processing chain of generated files) should have extra dependencies from list of Files...
###
### Prominent example here is Cython: one can generate .pyx file that may depend on .pxd and have cimpot from
### certain .h. The former is dependency for .pyx itself, while the latter is dependency for .pyx.cpp
### resulted from Cython-processing of generated pyx. The code ganeration will look like:
### ```
### PREPARE_INDUCED_DEPS(PYX_DEPS pyx imported.pxd)
### PREPARE_INDUCED_DEPS(CPP_DEPS cpp cdefed.h)
### PYTHON3(generate_pyx.py genereted.pyx OUT generated.pyx INDUCED_DEPS $PYX_DEPS $CPP_DEPS)
### ```
###
### The VAR will basically contain pair of `Type:[Files...]` in a form suitable for passing
### as an element of array parameter. This is needed because language of ya.make doesn't support
### Dict params right now and so it is impossible to directly pass something
### like `{Type1:[Files2...], Type2:[Files2...]}`
###
macro PREPARE_INDUCED_DEPS(VAR, For, Deps...) {
    SET($VAR \$_FMT_INDUCED_DEPS($For $Deps))
}

### @usage: RUN_PROGRAM(tool_path args... [CWD dir] [ENV key=value...] [TOOL tools...] [IN[_NOPARSE] inputs...] [OUT[_NOAUTO] outputs...] [STDOUT[_NOAUTO] output] [OUTPUT_INCLUDES output_includes...] [INDUCED_DEPS $VARs...])
###
### Run a program from arcadia.
### These macros are similar: RUN_PROGRAM, LUA, PYTHON.
###
### Parameters:
### - tool_path - Path to the directory of the tool.
### - args... - Program arguments. Relative paths listed in TOOL, IN, OUT, STDOUT become absolute.
### - CWD dir - Absolute path of the working directory.
### - ENV key=value... - Environment variables.
### - TOOL tools... - Auxiliary tool directories.
### - IN[_NOPARSE] inputs... - Input files. NOPARSE inputs are treated as textual and not parsed for dependencies regardless of file extensions.
### - OUT[_NOAUTO] outputs... - Output files. NOAUTO outputs are not automatically added to the build process.
### - STDOUT[_NOAUTO] output - Redirect the standard output to the output file.
### - OUTPUT_INCLUDES output_includes... - Includes of the output files that are needed to build them.
### - INDUCED_DEPS $VARs... - Dependencies for generated files. Unlike `OUTPUT_INCLUDES` these may target files further in processing chain.
###                           In order to do so VAR should be filled by PREPARE_INDUCED_DEPS macro, stating target files (by type) and set of dependencies
###
### For absolute paths use ${ARCADIA_ROOT} and ${ARCADIA_BUILD_ROOT}, or
### ${CURDIR} and ${BINDIR} which are expanded where the outputs are used.
### Note that Tool is always built for the host platform, so be careful to provide that tool can be built for all Arcadia major host platforms (Linux, MacOS and Windows).
macro RUN_PROGRAM(Tool, IN{input}[], IN_NOPARSE{input}[], OUT{output}[], OUT_NOAUTO{output}[], TOOL{tool}[], OUTPUT_INCLUDES[], INDUCED_DEPS[], IN_DEPS[], STDOUT="", STDOUT_NOAUTO="", CWD="", ENV[], Args...) {
    .CMD=${cwd:CWD} ${env:ENV} ${tool:Tool} $Args ${input;hide:IN} ${input;context=TEXT;hide:IN_NOPARSE} ${input;hide:IN_DEPS} ${output_include;hide:OUTPUT_INCLUDES} $INDUCED_DEPS ${tool;hide:TOOL} ${output;hide:OUT} ${output;noauto;hide:OUT_NOAUTO} ${output;stdout:STDOUT} ${output;stdout;noauto:STDOUT_NOAUTO} ${kv;hide:"p PR"} ${kv;hide:"pc yellow"} ${kv;hide:"show_out"}
    .SEM=add_custom_command $_SET_ENV_FOR_CUSTOM_COMMAND($ENV) OUTPUT ${output:OUT} ${output;noauto:OUT_NOAUTO} ${output:STDOUT} ${output;noauto:STDOUT_NOAUTO} DEPENDS ${input:IN} ${input;context=TEXT:IN_NOPARSE} ${tool:Tool} ${tool:TOOL} ${pre=WORKING_DIRECTORY :CWD} COMMAND ${tool:Tool} $Args ${pre=> :STDOUT} ${pre=> :STDOUT_NOAUTO} $_TARGET_SOURCES_FOR_HEADERS($OUT $OUT_NOAUTO $STDOUT $STDOUT_NOAUTO)
}

# tag:lua-specific
### @usage: LUA(script_path args... [CWD dir] [ENV key=value...] [TOOL tools...] [IN[_NOPARSE] inputs...] [OUT[_NOAUTO] outputs...] [STDOUT[_NOAUTO] output] [OUTPUT_INCLUDES output_includes...] [INDUCED_DEPS $VARs...])
###
### Run a lua script.
### These macros are similar: RUN_PROGRAM, LUA, PYTHON.
###
### Parameters:
### - script_path - Path to the script.3
### - args... - Program arguments. Relative paths listed in TOOL, IN, OUT, STDOUT become absolute.
### - CWD dir - Absolute path of the working directory.
### - ENV key=value... - Environment variables.
### - TOOL tools... - Auxiliary tool directories.
### - IN[_NOPARSE] inputs... - Input files. NOPARSE inputs are treated as textual and not parsed for dependencies regardless of file extensions.
### - OUT[_NOAUTO] outputs... - Output files. NOAUTO outputs are not automatically added to the build process.
### - STDOUT[_NOAUTO] output - Redirect the standard output to the output file.
### - OUTPUT_INCLUDES output_includes... - Includes of the output files that are needed to build them.
### - INDUCED_DEPS $VARs... - Dependencies for generated files. Unlike `OUTPUT_INCLUDES` these may target files further in processing chain.
###                           In order to do so VAR should be filled by PREPARE_INDUCED_DEPS macro, stating target files (by type) and set of dependencies
###
### For absolute paths use ${ARCADIA_ROOT} and ${ARCADIA_BUILD_ROOT}, or
### ${CURDIR} and ${BINDIR} which are expanded where the outputs are used.
macro LUA(ScriptPath, IN{input}[], IN_NOPARSE{input}[], OUT{output}[], OUT_NOAUTO{output}[], TOOL{tool}[], OUTPUT_INCLUDES[], INDUCED_DEPS[], STDOUT="", STDOUT_NOAUTO="", CWD="", ENV[], Args...) {
    .CMD=${cwd:CWD} ${env:ENV} $LUA_TOOL ${input:ScriptPath} $Args ${input;hide:IN} ${input;context=TEXT;hide:IN_NOPARSE} ${output_include;hide:OUTPUT_INCLUDES} $INDUCED_DEPS ${tool;hide:TOOL} ${output;hide:OUT} ${output;noauto;hide:OUT_NOAUTO} ${output;stdout:STDOUT} ${output;stdout;noauto:STDOUT_NOAUTO} ${kv;hide:"p LU"} ${kv;hide:"pc yellow"} ${kv;hide:"show_out"}
}

# tag:python-specific
### @usage: PYTHON(script_path args... [CWD dir] [ENV key=value...] [TOOL tools...] [IN[_NOPARSE] inputs...] [OUT[_NOAUTO] outputs...] [STDOUT[_NOAUTO] output] [OUTPUT_INCLUDES output_includes...] [INDUCED_DEPS $VARs...])
###
### Run a python script with $(PYTHON)/python built from devtools/huge_python.
### These macros are similar: RUN_PROGRAM, LUA, PYTHON.
###
### Parameters:
### - script_path - Path to the script.
### - args... - Program arguments. Relative paths listed in TOOL, IN, OUT, STDOUT become absolute.
### - CWD dir - Absolute path of the working directory.
### - ENV key=value... - Environment variables.
### - TOOL tools... - Auxiliary tool directories.
### - IN[_NOPARSE] inputs... - Input files. NOPARSE inputs are treated as textual and not parsed for dependencies regardless of file extensions.
### - OUT[_NOAUTO] outputs... - Output files. NOAUTO outputs are not automatically added to the build process.
### - STDOUT[_NOAUTO] output - Redirect the standard output to the output file.
### - OUTPUT_INCLUDES output_includes... - Includes of the output files that are needed to build them.
### - INDUCED_DEPS $VARs... - Dependencies for generated files. Unlike `OUTPUT_INCLUDES` these may target files further in processing chain.
###                           In order to do so VAR should be filled by PREPARE_INDUCED_DEPS macro, stating target files (by type) and set of dependencies
###
### For absolute paths use ${ARCADIA_ROOT} and ${ARCADIA_BUILD_ROOT}, or
### ${CURDIR} and ${BINDIR} which are expanded where the outputs are used.
macro PYTHON(ScriptPath, IN{input}[], IN_NOPARSE{input}[], OUT{output}[], OUT_NOAUTO{output}[], TOOL{tool}[], OUTPUT_INCLUDES[], INDUCED_DEPS[], STDOUT="", STDOUT_NOAUTO="", CWD="", ENV[], Args...) {
    .CMD=${cwd:CWD} ${env:ENV} $YMAKE_PYTHON ${input:ScriptPath} $Args ${input;hide:IN} ${input;context=TEXT;hide:IN_NOPARSE} ${output_include;hide:OUTPUT_INCLUDES} $INDUCED_DEPS ${tool;hide:TOOL} ${output;hide:OUT} ${output;noauto;hide:OUT_NOAUTO} ${output;stdout:STDOUT} ${output;stdout;noauto:STDOUT_NOAUTO} ${kv;hide:"p PY"} ${kv;hide:"pc yellow"} ${kv;hide:"show_out"}
    .SEM=find_package Python2 && add_custom_command $_SET_ENV_FOR_CUSTOM_COMMAND($ENV) OUTPUT ${output:OUT} ${output;noauto:OUT_NOAUTO} ${output:STDOUT} ${output;noauto:STDOUT_NOAUTO} DEPENDS ${input:IN} ${input;context=TEXT:IN_NOPARSE} ${input:ScriptPath} ${tool:TOOL} ${pre=WORKING_DIRECTORY :CWD} COMMAND Python2::Interpreter ${input:ScriptPath} $Args ${pre=> :STDOUT} ${pre=> :STDOUT_NOAUTO} $_TARGET_SOURCES_FOR_HEADERS($OUT $OUT_NOAUTO $STDOUT $STDOUT_NOAUTO)
}

# tag:python-specific
### @usage: PYTHON3(script_path args... [CWD dir] [ENV key=value...] [TOOL tools...] [IN[_NOPARSE] inputs...] [OUT[_NOAUTO] outputs...] [STDOUT[_NOAUTO] output] [OUTPUT_INCLUDES output_includes...] [INDUCED_DEPS $VARs...])
###
### Run a python script with prebuilt python3 interpretor built from devtools/huge_python3.
### These macros are similar: RUN_PROGRAM, LUA, PYTHON.
###
### Parameters:
### - script_path - Path to the script.
### - args... - Program arguments. Relative paths listed in TOOL, IN, OUT, STDOUT become absolute.
### - CWD dir - Absolute path of the working directory.
### - ENV key=value... - Environment variables.
### - TOOL tools... - Auxiliary tool directories.
### - IN[_NOPARSE] inputs... - Input files. NOPARSE inputs are treated as textual and not parsed for dependencies regardless of file extensions.
### - OUT[_NOAUTO] outputs... - Output files. NOAUTO outputs are not automatically added to the build process.
### - STDOUT[_NOAUTO] output - Redirect the standard output to the output file.
### - OUTPUT_INCLUDES output_includes... - Includes of the output files that are needed to build them.
### - INDUCED_DEPS $VARs... - Dependencies for generated files. Unlike `OUTPUT_INCLUDES` these may target files further in processing chain.
###                           In order to do so VAR should be filled by PREPARE_INDUCED_DEPS macro, stating target files (by type) and set of dependencies
###
### For absolute paths use ${ARCADIA_ROOT} and ${ARCADIA_BUILD_ROOT}, or
### ${CURDIR} and ${BINDIR} which are expanded where the outputs are used.
macro PYTHON3(ScriptPath, IN{input}[], IN_NOPARSE{input}[], OUT{output}[], OUT_NOAUTO{output}[], TOOL{tool}[], OUTPUT_INCLUDES[], INDUCED_DEPS[], STDOUT="", STDOUT_NOAUTO="", CWD="", ENV[], Args...) {
    .CMD=${cwd:CWD} ${env:ENV} $YMAKE_PYTHON3 ${input:ScriptPath} $Args ${input;hide:IN} ${input;context=TEXT;hide:IN_NOPARSE} ${output_include;hide:OUTPUT_INCLUDES} $INDUCED_DEPS ${tool;hide:TOOL} ${output;hide:OUT} ${output;noauto;hide:OUT_NOAUTO} ${output;stdout:STDOUT} ${output;stdout;noauto:STDOUT_NOAUTO} ${kv;hide:"p PY"} ${kv;hide:"pc yellow"} ${kv;hide:"show_out"}
    .PEERDIR=$YMAKE_PYTHON3_PEER
    .SEM=find_package Python3 && add_custom_command $_SET_ENV_FOR_CUSTOM_COMMAND($ENV) OUTPUT ${output:OUT} ${output;noauto:OUT_NOAUTO} ${output:STDOUT} ${output;noauto:STDOUT_NOAUTO} DEPENDS ${input:IN} ${input;context=TEXT:IN_NOPARSE} ${input:ScriptPath} ${tool:TOOL} ${pre=WORKING_DIRECTORY :CWD} COMMAND Python3::Interpreter ${input:ScriptPath} $Args ${pre=> :STDOUT} ${pre=> :STDOUT_NOAUTO} $_TARGET_SOURCES_FOR_HEADERS($OUT $OUT_NOAUTO $STDOUT $STDOUT_NOAUTO)
}

# tag:java-specific
macro _RUN_JAVA(IN{input}[], IN_NOPARSE{input}[], OUT{output}[], OUT_NOAUTO{output}[], OUTPUT_INCLUDES[], INDUCED_DEPS[], TOOL[], STDOUT="", STDOUT_NOAUTO="", CWD="", ENV[], HIDE_OUTPUT?"stderr2stdout":"stdout2stderr", Args...) {
    PEERDIR(build/platform/java/jdk $JDK_RESOURCE_PEERDIR)
    .CMD=${cwd:CWD} ${env:ENV} $YMAKE_PYTHON ${input;pre=build/scripts/:HIDE_OUTPUT.py} $JDK_RESOURCE/bin/java $Args ${tool;hide:TOOL} ${input;hide:IN} ${input;context=TEXT;hide:IN_NOPARSE} ${output_include;hide:OUTPUT_INCLUDES} $INDUCED_DEPS ${output;hide:OUT} ${output;noauto;hide:OUT_NOAUTO} ${output;stdout:STDOUT} ${output;stdout;noauto:STDOUT_NOAUTO} ${kv;hide:"p JV"} ${kv;hide:"pc light-blue"} ${kv;hide:"show_out"}
}

### @usage: FROM_SANDBOX([FILE] resource_id [AUTOUPDATED script] [RENAME <resource files>] OUT_[NOAUTO] <output files> [EXECUTABLE] [OUTPUT_INCLUDES <include files>] [INDUCED_DEPS $VARs...])
###
### Download the resource from the Sandbox, unpack (if not explicitly specified word FILE) and add OUT files to the build. EXECUTABLE makes them executable.
### You may specify extra dependencies that output files bring using OUTPUT_INCLUDES or INDUCED_DEPS. The change of these may e.g. lead to recompilation of .cpp files extracted from resource.
### If there is no default processing for OUT files or you need process them specially use OUT_NOAUTO instead of OUT.
###
### It is disallowed to specify directory as OUT/OUT_NOAUTO since all outputs of commands shall be known to build system.
###
### RENAME renames files to the corresponding OUT and OUT_NOAUTO outputs:
### FROM_SANDBOX(resource_id RENAME in_file1 in_file2 OUT out_file1 out_file2 out_file3)
### FROM_SANDBOX(resource_id RENAME in_file1 OUT out_file1 RENAME in_file2 OUT out_file2)
### FROM_SANDBOX(FILE resource_id RENAME resource_file OUT out_name)
###
### RENAME RESOURCE allows to rename the resource without specifying its file name.
###
### OUTPUT_INCLUDES output_includes... - Includes of the output files that are needed to build them.
### INDUCED_DEPS $VARs... - Dependencies for generated files. Unlike `OUTPUT_INCLUDES` these may target files further in processing chain.
###                         In order to do so VAR should be filled by PREPARE_INDUCED_DEPS macro, stating target files (by type) and set of dependencies
###
### If AUTOUPDATED is specified than macro will be regularly updated according to autoupdate script. The dedicated Sandbox task scans the arcadia and
### changes resource_ids in such macros if newer resource of specified type is available. Note that the task seeks AUTOUPDATED in specific position,
### so you shall place it immediately after resource_id.
macro FROM_SANDBOX(Id, OUT{output}[], OUT_NOAUTO{output}[], OUTPUT_INCLUDES[], INDUCED_DEPS[], FILE?"--copy-to-dir":"--untar-to", AUTOUPDATED="", PREFIX=".", RENAME[], EXECUTABLE?"--executable":"", SBR="sbr:") {
    .CMD=${hide:SANDBOX_FAKEID} ${cwd:BINDIR} ${resource;pre=$SBR:Id} $YMAKE_PYTHON ${input:"build/scripts/fetch_from_sandbox.py"} --resource-file $(RESOURCE_ROOT)/sbr/$Id/resource --resource-id $Id $FILE $PREFIX ${pre=--rename :RENAME} $EXECUTABLE -- $OUT $OUT_NOAUTO ${input;hide:"build/scripts/fetch_from.py"} ${output_include;hide:OUTPUT_INCLUDES} $INDUCED_DEPS ${output;hide:OUT} ${output;noauto;hide:OUT_NOAUTO} ${requirements;hide:"network:full"} ${kv;hide:"p SB"} ${kv;hide:"pc yellow"} ${kv;hide:"show_out"}
    ADD_CHECK(check.resource $Id)
}

### @usage: FROM_MDS([FILE] key [RENAME <resource files>] OUT_[NOAUTO] <output files> [EXECUTABLE] [OUTPUT_INCLUDES <include files>] [INDUCED_DEPS $VARs...])
###
### Download resource from MDS with the specified key and process like [FROM_SANDBOX()](#macro_FROM_SANDBOX).
macro FROM_MDS(Key, OUT{output}[], OUT_NOAUTO{output}[], OUTPUT_INCLUDES[], INDUCED_DEPS[], FILE?"--copy-to-dir":"--untar-to", PREFIX=".", RENAME[], EXECUTABLE?"--executable":"") {
    .CMD=${cwd:BINDIR} $YMAKE_PYTHON ${input:"build/scripts/fetch_from_mds.py"} --key $Key $FILE $PREFIX ${pre=--rename :RENAME} $EXECUTABLE -- $OUT $OUT_NOAUTO ${input;hide:"build/scripts/fetch_from.py"} ${output_include;hide:OUTPUT_INCLUDES} $INDUCED_DEPS ${output;hide:OUT} ${output;noauto;hide:OUT_NOAUTO} ${requirements;hide:"network:full"} ${kv;hide:"p MD"} ${kv;hide:"pc yellow"} ${kv;hide:"show_out"}
    ADD_CHECK(check.mds $Key)
}

# tag:internal
### @usage: _FROM_EXTERNAL(ExtFile [AUTOUPDATED script] [RENAME <resource files>] OUT_[NOAUTO] <output files> [EXECUTABLE])  #internal
###
### Use resource described as .external file as [FROM_SANDBOX()](#macro_FROM_SANDBOX)/[FROM_MDS()](#macro_FROM_MDS).
macro _FROM_EXTERNAL(File, OutFile, OUT{output}[], OUT_NOAUTO{output}[], OUTPUT_INCLUDES[], INDUCED_DEPS[], AUTOUPDATED="", PREFIX=".", RENAME[], EXECUTABLE?"--executable":"", EXT="ext:") {
    .CMD=${hide:SANDBOX_FAKEID} ${cwd:BINDIR} ${resource;pre=$EXT;suf=.external:OutFile} $YMAKE_PYTHON ${input:"build/scripts/fetch_from_external.py"} --external-file ${input:File} --resource-file $(RESOURCE_ROOT)/ext/$OutFile --copy-to-dir $PREFIX ${pre=--rename :RENAME} $EXECUTABLE -- $OUT $OUT_NOAUTO ${input;hide:"build/scripts/fetch_from.py"} ${input;hide:"build/scripts/fetch_from_sandbox.py"} ${input;hide:"build/scripts/fetch_from_mds.py"} ${output_include;hide:OUTPUT_INCLUDES} $INDUCED_DEPS ${output;hide:OUT} ${output;noauto;hide:OUT_NOAUTO} ${requirements;hide:"network:full"} ${kv;hide:"p XT"} ${kv;hide:"pc yellow"} ${kv;hide:"show_out"}

#FIXME: add '${resource;pre=$EXT:OutFile}' when support of the scheme is added to executors
#FIXME: add 'ADD_CHECK(check.external $File)' when proper testing is implemented
}

### @usage LARGE_FILES([AUTOUPDATED]  Files...)
###
### Use large file ether from working copy or from remote storage via placeholder <File>.external
### If <File> is present locally (and not a symlink!) it will be copied to build directory.
### Otherwise macro will try to locate <File>.external, parse it retrieve ot during build phase.
macro LARGE_FILES(AUTOUPDATED?, Files...) {
    # This is needed to correctly switch between remote and local modes
    _GLOB($LF $Files)
}


### @usage: FROM_ARCHIVE(Src [RENAME <resource files>] OUT_[NOAUTO] <output files> [EXECUTABLE] [OUTPUT_INCLUDES <include files>] [INDUCED_DEPS $VARs...])
###
### Process file archive as [FROM_SANDBOX()](#macro_FROM_SANDBOX).
macro FROM_ARCHIVE(Src, OUT{output}[], OUT_NOAUTO{output}[], OUTPUT_INCLUDES[], INDUCED_DEPS[], PREFIX=".", RENAME[], EXECUTABLE?"--executable":"") {
    .CMD=${cwd:BINDIR} $YMAKE_PYTHON ${input:"build/scripts/fetch_from_archive.py"} "--archive" ${input:Src} "--file-name" ${suf=-:Src} "--untar-to" $PREFIX ${pre=--rename :RENAME} $EXECUTABLE -- $OUT $OUT_NOAUTO ${input;hide:"build/scripts/fetch_from.py"} ${output_include;hide:OUTPUT_INCLUDES} $INDUCED_DEPS ${output;hide:OUT} ${output;noauto;hide:OUT_NOAUTO} ${kv;hide:"p FA"} ${kv;hide:"pc yellow"} ${kv;hide:"show_out"}
}

when ($MSVC == "yes") {
    C_AS_CXX_FLAGS=/TP /std:c++17
}
otherwise {
    C_AS_CXX_FLAGS=-x c++ -std=c++17
}

# tag:cpp-specific
### @usage: COMPILE_C_AS_CXX()
###
### Compile .c files as .cpp ones within a module.
macro COMPILE_C_AS_CXX() {
    SET(EXTRA_C_FLAGS $C_AS_CXX_FLAGS)
}

### @usage: NO_DEBUG_INFO()
###
### Compile files without debug info collection.
macro NO_DEBUG_INFO() {
    SET(NO_DEBUGINFO yes)
}

### @usage: CTEMPLATE_VARNAMES(File)
###
### Generate File.varnames.h using contrib/libs/ctemplate/make_tpl_varnames_h
###
### Documentation: https://a.yandex-team.ru/arc/trunk/arcadia/contrib/libs/ctemplate/README.md
macro CTEMPLATE_VARNAMES(File) {
    .CMD=${tool:"contrib/libs/ctemplate/make_tpl_varnames_h"} -f ${output;addincl;nopath;noallext:File.varnames.h} ${input:File}
}

LLVM_OPTS=
CLANG_ROOT=$CLANG_RESOURCE_GLOBAL
CLANG_BINARIES_ROOT=$CLANG_ROOT/bin
CLANG_CPP_COMPILER_BIN=$CLANG_BINARIES_ROOT/clang++
CLANG_C_COMPILER_BIN=$CLANG_BINARIES_ROOT/clang

when ($OS_ANDROID == "yes") {
    CLANG_ROOT=$CLANG_ANDROID_RESOURCE_GLOBAL
    when ($HOST_OS_DARWIN) {
        CLANG_BINARIES_ROOT=$CLANG_ROOT/toolchains/llvm/prebuilt/darwin-x86_64/bin
    }
    otherwise {
        CLANG_BINARIES_ROOT=$CLANG_ROOT/toolchains/llvm/prebuilt/linux-x86_64/bin
    }
}

### @usage: GENERATED_SRCS(srcs... PARSE_META_FROM cpp_srcs... [OUTPUT_INCLUDES output_includes...] [OPTIONS])
###
### Generate sources using Jinja 2 template engine.
###
### srcs... - list of text files which will be generated during build time by templates. Each template must be
###     placed to the place in source tree where corresponding source file should be generated. Name of
###     template must be "<name_of_src_file>.markettemplate". For example if you want to generate file "example.cpp"
###     then template should be named "example.cpp.markettemplate".
### PARSE_META_FROM cpp_srcs... - list of C++ source files (.cpp, .h) which will be parsed using clang library
###     and metainformation extracted from the files will be made available for templates. Example of
###     template code fragment using metainformation: {{ meta.objects["@N@std@S@string"].name }}
### OUTPUT_INCLUDES output_includes... - in cases when build system parser fails to determine all headers
###     which generated files include, you can specify additional headers here. In a normal situation this should
###     not be needed and this feature could be removed in the future.
### OPTIONS - additional options for code_generator utility
###
### Examples of templates can be found in directory market/tools/code_generator/templates.
### Metainformation does not contain entries for every object declared in C++ files specified in PARSE_META_FROM
### parameter. To include some object into consideration you need to mark it by attribute. Attributes can
### automatically add more attributes to dependent objects. This behavior depends on attribute definition.
###
### More information will be available (eventually:) here: https://wiki.yandex-team.ru/Users/denisk/codegenerator/
macro GENERATED_SRCS(PARSE_META_FROM{input}[], OUTPUT_INCLUDES[], OPTIONS[], TEMPLATES...) {
    .CMD=${tool:"market/tools/code_generator"} --cpp-file ${input:PARSE_META_FROM} --templates-dir / ${ARCADIA_ROOT} --templates ${input:TEMPLATES.markettemplate} --generated-files ${output:TEMPLATES} ${output_include;hide:OUTPUT_INCLUDES} ${output_include;hide:PARSE_META_FROM} --arcadia-root ${ARCADIA_ROOT} --arcadia-build-root ${ARCADIA_BUILD_ROOT} --clang-root $CLANG_ROOT ${OPTIONS} -- $C_FLAGS_PLATFORM $CXXFLAGS ${pre=-I:_C__INCLUDE} -std=c++17 -Wno-unknown-warning-option -Wno-unused-parameter -Wno-undefined-inline -Wno-undefined-internal -Wno-unused-function $LLVM_OPTS -fno-lto
    PEERDIR(build/platform/clang)
}

### @usage: CLANG_EMIT_AST_CXX(Input Output Opts...)
###
### Emit Clang AST from .cpp file. CXXFLAGS and LLVM_OPTS are passed in, while CFLAGS and C_FLAGS_PLATFORM are not.
### Note: Output name is used as is, no extension added.
macro CLANG_EMIT_AST_CXX(Input, Output, Opts...) {
    .CMD=$YMAKE_PYTHON ${input:"build/scripts/clang_wrapper.py"} $WINDOWS $CLANG_CPP_COMPILER_BIN ${pre=-I:_C__INCLUDE} $CXXFLAGS $C_FLAGS_PLATFORM -Wno-unknown-warning-option $LLVM_OPTS -emit-ast -c ${input:Input} -o ${output;noauto:Output} $Opts ${kv;hide:"p ST"} ${kv;hide:"pc light-green"}
    PEERDIR(build/platform/clang)
}

### @usage: LLVM_COMPILE_CXX(Input Output Opts...)
###
### Emit LLVM bytecode from .cpp file. BC_CXXFLAGS, LLVM_OPTS and C_FLAGS_PLATFORM are passed in, while CFLAGS are not.
### Note: Output name is used as is, no extension added.
macro LLVM_COMPILE_CXX(Input, Output, Opts...) {
    .CMD=$YMAKE_PYTHON ${input:"build/scripts/clang_wrapper.py"} $WINDOWS $CLANG_CPP_COMPILER_BIN ${pre=-I:_C__INCLUDE} $BC_CXXFLAGS $C_FLAGS_PLATFORM -Wno-unknown-warning-option $LLVM_OPTS ${NO_LTO_CFLAGS} -emit-llvm -c ${input:Input} -o ${output;noauto:Output} $Opts ${kv;hide:"p BC"} ${kv;hide:"pc light-green"}
    .SEM=llvm_compile_cxx ${input:Input} ${output;noauto:Output} ${CLANGPLUSPLUS} -Wno-unknown-warning-option $LLVM_OPTS ${NO_LTO_CFLAGS} -emit-llvm ${Opts}
    PEERDIR(build/platform/clang)
}

### @usage: LLVM_COMPILE_C(Input Output Opts...)
###
### Emit LLVM bytecode from .c file. BC_CFLAGS, LLVM_OPTS and C_FLAGS_PLATFORM are passed in, while CFLAGS are not.
### Note: Output name is used as is, no extension added.
macro LLVM_COMPILE_C(Input, Output, Opts...) {
    .CMD=$YMAKE_PYTHON ${input:"build/scripts/clang_wrapper.py"} $WINDOWS $CLANG_C_COMPILER_BIN ${pre=-I:_C__INCLUDE} $BC_CFLAGS $C_FLAGS_PLATFORM $LLVM_OPTS ${NO_LTO_CFLAGS} -emit-llvm -c ${input:Input} -o ${output;noauto:Output} $Opts ${kv;hide:"p BC"} ${kv;hide:"pc light-green"}
    PEERDIR(build/platform/clang)
}

### @usage: BPF(Input Output Opts...)
###
### Emit eBPF bytecode from .c file.
### Note: Output name is used as is, no extension added.
macro BPF(Input, Output, Opts...) {
    .CMD=$YMAKE_PYTHON ${input:"build/scripts/clang_wrapper.py"} $WINDOWS $CLANG_C_COMPILER_BIN ${pre=-I:_C__INCLUDE} $C_FLAGS_PLATFORM -target bpf -c ${input:Input} -o ${output;noauto:Output} $Opts ${kv;hide:"p BP"} ${kv;hide:"pc light-green"}
    PEERDIR(build/platform/clang)
}

### @usage: BPF_STATIC(Input Output Opts...)
###
### Emit eBPF bytecode from .c file.
### Note: Output name is used as is, no extension added.
macro BPF_STATIC(Input, Output, Opts...) {
    .CMD=$YMAKE_PYTHON ${input:"build/scripts/clang_wrapper.py"} $WINDOWS $CLANG_C_COMPILER_BIN ${pre=-I:_C__INCLUDE} $C_FLAGS_PLATFORM -target bpf -c ${input:Input} -o ${output;noauto:Output} $Opts ${kv;hide:"p BP"} ${kv;hide:"pc light-green"} && ${cwd:BINDIR} $LLD_ROOT_RESOURCE_GLOBAL/ld -r -b binary -m elf_x86_64 -o ${output;noauto;suf=.bpf.o:Input} ${noauto;nopath:Output}
    PEERDIR(build/platform/clang build/platform/lld)
}

### @usage: LLVM_COMPILE_LL(Input Output Opts...)
###
### Compile LLVM bytecode to object representation.
### Note: Output name is used as is, no extension added.
macro LLVM_COMPILE_LL(Input, Output, Opts...) {
    .CMD=$CLANG_BINARIES_ROOT/llvm-as ${input:Input} -o ${output;noauto:Output} ${kv;hide:"p BC"} ${kv;hide:"pc light-green"}
    PEERDIR(build/platform/clang)
}

### @usage: LLVM_LINK(Output Inputs...)
###
### Call llvm-link on set of Inputs to produce Output.
### Note: Unlike many other macros output argument goes first. Output name is used as is, no extension added.
macro LLVM_LINK(Output, Inputs...) {
    .CMD=$CLANG_BINARIES_ROOT/llvm-link ${input:Inputs} -o ${output;noauto:Output} ${kv;hide:"p LD"} ${kv;hide:"pc light-red"}
    .SEM=add_custom_command OUTPUT ${output;noauto:Output} DEPENDS ${input:Inputs} COMMAND ${LLVMLINK} ${input:Inputs} -o ${output;noauto:Output}
    PEERDIR(build/platform/clang)
}

### @usage: LLVM_OPT(Input Output Opts...)
###
### Call llvm-opt with set of Opts on Input to produce Output.
### Note: Output name is used as is, no extension added.
macro LLVM_OPT(Input, Output, Opts...) {
    .CMD=$YMAKE_PYTHON ${input:"build/scripts/llvm_opt_wrapper.py"} $CLANG_BINARIES_ROOT/opt ${input:Input} -o ${output;noauto:Output} $Opts ${kv;hide:"p OP"} ${kv;hide:"pc yellow"}
    .SEM=add_custom_command OUTPUT ${output;noauto:Output} DEPENDS ${input:Input} COMMAND ${LLVMOPT} ${input:Input} -o ${output;noauto:Output} $Opts
    PEERDIR(build/platform/clang)
}

when ($NO_DEBUGINFO == "yes") {
    DEBUG_INFO_FLAGS=
}

when ($CLANG && $DEBUGINFO_LINES_ONLY == "yes" && $NO_DEBUGINFO != "yes") {
    DEBUG_INFO_FLAGS=-gline-tables-only
}

# TODO: configurable tar and touch
PACK_TGZ=${cwd:ARCADIA_BUILD_ROOT} tar -czf ${rootrel:OUTPUT} ${rootrel:INPUT} ${kv;hide:"p AR"} ${kv;hide:"pc light-red"}

#  tag:internal
### @usage TOUCH(Outputs...) # internal
### Just introduce outputs
macro TOUCH(Outputs...) {
    .CMD=$YMAKE_PYTHON ${input:"build/scripts/touch.py"} ${output:Outputs}
}
TOUCH_UNIT=$YMAKE_PYTHON ${input:"build/scripts/touch.py"} ${kv;hide:"p UN"} ${kv;hide:"pc light-cyan"} $TARGET
TOUCH_PACKAGE=$YMAKE_PYTHON ${input:"build/scripts/touch.py"} ${kv;hide:"pc light-red"} $TARGET && $YMAKE_PYTHON ${input:"build/scripts/copy_to_dir.py"} --dest-dir $BINDIR --build-root $ARCADIA_BUILD_ROOT $PACKED_PACKAGE_ARGS $SRCS_GLOBAL $PEERS
_P_PK=${kv;hide:"p PK"}
TOUCH_PACKAGE_MF=$GENERATE_MF && $TOUCH_PACKAGE $_P_PK
TOUCH_JAVA_UNIT=$YMAKE_PYTHON ${input:"build/scripts/touch.py"} ${kv;hide:"java $CURDIR"} $TARGET

NO_CHECK_IMPORTS_FOR_VALUE=None
### @usage: NO_CHECK_IMPORTS([patterns])
###
### Do not run checks on imports of Python modules.
### Optional parameter mask patterns describes the names of the modules that do not need to check.
macro NO_CHECK_IMPORTS(Masks...) {
    SET(NO_CHECK_IMPORTS_FOR_VALUE $Masks)
}


# tag:yasm-specific
_YASM_FMT_VALUE=
_YASM_PLATFORM_FLAGS_VALUE=
_YASM_PREDEFINED_FLAGS_VALUE=
when ($OS_DARWIN || $OS_IOS) {
    _YASM_FMT_VALUE=macho
    _YASM_PLATFORM_FLAGS_VALUE=-D DARWIN -D UNIX
}
elsewhen ($OS_WINDOWS && $ARCH_X86_64) {
    _YASM_FMT_VALUE=win
    _YASM_PLATFORM_FLAGS_VALUE=-D WIN64
}
elsewhen ($OS_WINDOWS && $ARCH_I386) {
    _YASM_FMT_VALUE=win
    _YASM_PLATFORM_FLAGS_VALUE=-D WIN32
}
otherwise {
    _YASM_FMT_VALUE=elf
    _YASM_PLATFORM_FLAGS_VALUE=-D UNIX
    _YASM_PREDEFINED_FLAGS_VALUE=-g dwarf2
}

when ($ASM_PREFIX) {
    ASM_PREFIX_VALUE=--prefix=$ASM_PREFIX
}
otherwise {
    ASM_PREFIX_VALUE=
}

# tag:yasm-specific
YASM_FLAGS=
YASM_PREINCLUDES_VALUE=

# tag:yasm-specific
macro _SRC_yasm_helper(SRC, PREINCLUDES[], SRCFLAGS...) {
    .CMD=${tool:"contrib/tools/yasm"} -f ${_YASM_FMT_VALUE}${HARDWARE_ARCH} $_YASM_PLATFORM_FLAGS_VALUE $YASM_DEBUG_INFO $YASM_DEBUG_INFO_DISABLE_CACHE__NO_UID__ -D ${pre=_;suf=_:HARDWARE_TYPE} -D_YASM_ $ASM_PREFIX_VALUE $_YASM_PREDEFINED_FLAGS_VALUE $YASM_FLAGS ${pre=-I :_ASM__INCLUDE} $SRCFLAGS -o ${output;noext;suf=${OBJECT_SUF}:SRC} ${pre=-P :PREINCLUDES} ${input;hide:PREINCLUDES} ${SRC} ${kv;hide:"p AS"} ${kv;hide:"pc light-green"}
}

# tag:yasm-specific
macro _SRC_yasm(SRC, PREINCLUDES[], SRCFLAGS...) {
    .CMD=$_SRC_yasm_helper(${input:SRC}, $SRCFLAGS, PREINCLUDES $PREINCLUDES)
}

### @usage: ASM_PREINCLUDE(AsmFiles...)
###
### Supply additional .asm files to all assembler calls within a module
macro ASM_PREINCLUDE(PREINCLUDES...) {
    SET_APPEND(YASM_PREINCLUDES_VALUE $PREINCLUDES)
}

# tag:python-specific
### @usage: RUN_PYTHON(Args...)
###
### Version of RUN() macro to invoke Python scripts
### @see: [RUN()](#macro_RUN)
macro RUN_PYTHON(Args...) {
    SETUP_RUN_PYTHON()
    RUN(${PYTHON_BIN} $Args)
}

### @usage: RUN_ANTLR(Args...)
###
### Macro to invoke ANTLR3 generator (general case)
macro RUN_ANTLR(IN[], IN_NOPARSE[], OUT[], OUT_NOAUTO[], OUTPUT_INCLUDES[], INDUCED_DEPS[], CWD="", Args...) {
    PEERDIR(build/external_resources/antlr3 build/platform/java/jdk $JDK_RESOURCE_PEERDIR)
    .CMD=$_RUN_JAVA(-jar $ANTLR3_RESOURCE_GLOBAL/antlr-3.5.2-complete-no-st3.jar $Args IN $IN IN_NOPARSE $IN_NOPARSE OUT $OUT OUT_NOAUTO $OUT_NOAUTO OUTPUT_INCLUDES $OUTPUT_INCLUDES INDUCED_DEPS $INDUCED_DEPS ${pre=CWD :CWD})
    .SEM=run_antlr OUTPUT ${output:OUT} ${output;noauto:OUT_NOAUTO} DEPENDS ${input:IN} ${pre=WORKING_DIRECTORY :CWD} ANTLER_ARGS $Args
}

### @usage: RUN_ANTLR4(Args...)
###
### Macro to invoke ANTLR4 generator (general case)
macro RUN_ANTLR4(IN[], IN_NOPARSE[], OUT[], OUT_NOAUTO[], OUTPUT_INCLUDES[], INDUCED_DEPS[], CWD="", Args...) {
    PEERDIR(build/external_resources/antlr4)
    _RUN_JAVA(-jar $ANTLR4_RESOURCE_GLOBAL/antlr-4.9-complete.jar $Args IN $IN IN_NOPARSE $IN_NOPARSE OUT $OUT OUT_NOAUTO $OUT_NOAUTO OUTPUT_INCLUDES $OUTPUT_INCLUDES INDUCED_DEPS $INDUCED_DEPS ${pre=CWD :CWD})
}

_ANTLR4_LISTENER_GRAMMAR=-listener
_ANTLR4_LISTENER__ANTLR4_EMPTY=-no-listener
_ANTLR4_VISITOR_GRAMMAR=-visitor
_ANTLR4_VISITOR__ANTLR4_EMPTY=-no-visitor

### @usage: RUN_ANTLR4_CPP(GRAMMAR, OUTPUT_INCLUDES, LISTENER, VISITOR, Args...)
###
### Macro to invoke ANTLR4 generator (Cpp)
macro RUN_ANTLR4_CPP(GRAMMAR, OUTPUT_INCLUDES[], LISTENER?"GRAMMAR":"_ANTLR4_EMPTY", VISITOR?"GRAMMAR":"_ANTLR4_EMPTY", _ANTLR4_EMPTY="", Args...) {
    RUN_ANTLR4(${GRAMMAR} -Dlanguage=Cpp -o ${BINDIR} ${Args} ${_ANTLR4_VISITOR_$VISITOR} ${_ANTLR4_LISTENER_$LISTENER} CWD ${BINDIR} IN ${GRAMMAR} OUT ${noext;suf=Lexer.cpp:GRAMMAR} ${noext;suf=Lexer.h:GRAMMAR} ${noext;suf=Parser.cpp:GRAMMAR} ${noext;suf=Parser.h:GRAMMAR} ${noext;suf=Listener.h:$LISTENER} ${noext;suf=BaseListener.h:$LISTENER} ${noext;suf=Visitor.h:$VISITOR} ${noext;suf=BaseVisitor.h:$VISITOR} OUTPUT_INCLUDES ${ARCADIA_ROOT}/contrib/libs/antlr4_cpp_runtime/src/antlr4-runtime.h ${OUTPUT_INCLUDES})
    PEERDIR(contrib/libs/antlr4_cpp_runtime)
}

### @usage: RUN_ANTLR4_GO(GRAMMAR, OUTPUT_INCLUDES, LISTENER, VISITOR, Args...)
###
### Macro to invoke ANTLR4 generator (Go)
macro RUN_ANTLR4_GO(GRAMMAR, OUTPUT_INCLUDES[], LISTENER?"GRAMMAR":"_ANTLR4_EMPTY", VISITOR?"GRAMMAR":"_ANTLR4_EMPTY", _ANTLR4_EMPTY="", Args...) {
    RUN_ANTLR4(${GRAMMAR} -Dlanguage=Go -o ${BINDIR} ${Args} ${_ANTLR4_VISITOR_$VISITOR} ${_ANTLR4_LISTENER_$LISTENER} CWD ${BINDIR} IN ${GRAMMAR} OUT ${noext;tolower;suf=_lexer.go:GRAMMAR} ${noext;tolower;suf=_parser.go:GRAMMAR} ${noext;tolower;suf=_listener.go:$LISTENER} ${noext;tolower;suf=_base_listener.go:$LISTENER} ${noext;tolower;suf=_visitor.go:$VISITOR} ${noext;tolower;suf=_base_visitor.go:$VISITOR} OUTPUT_INCLUDES ${OUTPUT_INCLUDES})
    PEERDIR(${GOSTD}/fmt ${GOSTD}/reflect ${GOSTD}/strconv ${GOSTD}/unicode vendor/github.com/antlr/antlr4/runtime/Go/antlr)
}

# tag:cpp-specific
macro CPP_ADDINCL(Dirs...) {
    ADDINCL($Dirs)
}

# tag:internal
_WHOLE_ARCHIVE_PEERS_VALUE=
### @usage: WHOLE_ARCHIVE(dirnames...) # internal
macro WHOLE_ARCHIVE(PEERS...) {
    SET_APPEND(_WHOLE_ARCHIVE_PEERS_VALUE ${PEERS})
    REQUIRES(${PEERS})
}

ANDROID_SDK_ROOT=${ANDROID_SDK_RESOURCE_GLOBAL}/android_sdk

macro TASKLET() {
    PEERDIR(tasklet/api)

    # CPP
    CPP_PROTO_PLUGIN(tasklet_cpp tasklet/gen/cpp .tasklet.h)

    # Python
    PY_PROTO_PLUGIN2(tasklet_py _tasklet.py _sbtask.py tasklet/gen/python DEPS tasklet/domain/sandbox tasklet/runtime sandbox/sdk2)

    #Java
    JAVA_PROTO_PLUGIN(tasket_java tasklet/gen/java DEPS tasklet/runtime/java/lib $JAVA_GRPC_STUB $JAVA_GRPC_PROTOBUF)
}

TASKLET_REG_INCLUDES= \
    ${output_include;hide:"tasklet/runtime/lib/cpp_wrapper.h"} \
    ${output_include;hide:"tasklet/runtime/lib/go_wrapper.h"} \
    ${output_include;hide:"tasklet/runtime/lib/py_wrapper.h"} \
    ${output_include;hide:"tasklet/runtime/lib/js_wrapper.h"} \
    ${output_include;hide:"tasklet/runtime/lib/registry.h"}

macro TASKLET_REG(Name, Lang, Impl, Includes...) {
    PEERDIR(tasklet/domain sandbox/bin sandbox/taskbox/worker)

    when($Lang == "js") {
        # JS runtime links the Node.js from contrib as a library, which is a bit heavy,
        # so we do it, only if any JS tasklets are linked into the target
        PEERDIR+=tasklet/runtime/js
    }

    .CMD=$YMAKE_PYTHON ${input:"build/scripts/gen_tasklet_reg.py"} $Name -l $Lang -i $Impl ${output;noauto:Name.task.cpp} $Includes ${output_include;hide:Includes} $TASKLET_REG_INCLUDES ${kv;hide:"p TT"} ${kv;hide:"pc yellow"}
    SRCS(GLOBAL $Name.task.cpp)
}

# TEMPORARY METHOD FOR EXTENDED REGISTRY SETUP
# NOT COMPLETE
macro TASKLET_REG_EXT(Name, Lang, Impl, Wrapper, Includes...) {
    PEERDIR(tasklet/domain sandbox/bin sandbox/taskbox/worker)

    .CMD=$YMAKE_PYTHON ${input:"build/scripts/gen_tasklet_reg.py"} $Name -l $Lang -i $Impl -w $Wrapper ${output;noauto:Name.task.cpp} $Includes ${output_include;hide:Includes} $TASKLET_REG_INCLUDES ${kv;hide:"p TT"} ${kv;hide:"pc yellow"}
    SRCS(GLOBAL $Name.task.cpp)
}

# tag:cpp-specific
_CPP_PROTO_MODULE_PREFIX=
_CPP_PROTO_MODULE_SUFFIX=
when ($MSVC == "yes" || $CYGWIN == "yes") {
    _CPP_PROTO_MODULE_PREFIX=
    _CPP_PROTO_MODULE_SUFFIX=.lib
}
otherwise {
    _CPP_PROTO_MODULE_PREFIX=lib
    _CPP_PROTO_MODULE_SUFFIX=.a
}

### @usage: EXPOSE(OutputsToExport...)
###
### Allows to mark outputs of macro command as unused in the current module but intended
### to be used in modules consuming current via PEERDIR.
###
### TODO(DEVTOOLS-9000) proper implementation needed
macro EXPOSE(Args...) {
    .CMD=$YMAKE_PYTHON ${input:"build/scripts/touch.py"} ${output;suf=$_HASH_HELPER($Args).cpp:"empty_"} ${input;hide:Args}
}


# tag:proto
macro _PROTO_DESC_CMD(File) {
    .CMD=${cwd;rootdir;input:File} $PROTOC -I=./$PROTO_NAMESPACE -I=$ARCADIA_ROOT/$PROTO_NAMESPACE ${pre=-I=:_PROTO__INCLUDE} -I=$ARCADIA_BUILD_ROOT -I=$PROTOBUF_PATH --descriptor_set_out=${output;suf=.desc:File} --include_source_info ${input;rootrel:File}
}

_PROTO_DESC_MERGE_CMD=$YMAKE_PYTHON ${input:"build/scripts/merge_files.py"} $TARGET $AUTO_INPUT ${kv;hide:"p PD"} ${kv;hide:"pc light-cyan"}
_PROTO_DESC_MERGE_PEERS_CMD=$YMAKE_PYTHON ${input:"build/scripts/merge_files.py"} $TARGET $PEERS $SRCS_GLOBAL  ${kv;hide:"p PD"} ${kv;hide:"pc light-cyan"}

NEED_GOOGLE_PROTO_PEERDIRS=yes

PROTO_LIBRARY_SEM=$CPP_LIBRARY_SEM

# tag:proto
### @usage: PROTO_LIBRARY()
###
### Build some varian of protocol buffers library.
###
### The particular variant is selected based on where PEERDIR to PROTO_LIBRARY comes from.
###
### Now supported 5 variants: C++, Java, Python 2.x, Python 3.x and Go.
### When PEERDIR comes from module for particular language appropriate variant is selected.
### PROTO_LIBRARY also supports emission of GRPC code if GRPC() macro is specified.
### Notes:
### - Python versions emit C++ code in addition to Python as optimization.
### - In some PROTO_LIBRARY-es Java or Python versions are excluded via EXCLUDE_TAGS macros due to incompatibilities.
### - Use from DEPENDS or BUNDLE is not allowed
###
### Documentation: https://wiki.yandex-team.ru/yatool/proto_library/
###
### See: [GRPC()](#macro_GRPC), [OPTIMIZE_PY_PROTOS()](#macro_OPTIMIZE_PY_PROTOS), [INCLUDE_TAGS()](#macro_INCLUDE_TAGS), [EXCLUDE_TAGS()](#macro_EXCLUDE_TAGS)
multimodule PROTO_LIBRARY {
    module CPP_PROTO : LIBRARY {
        .ALLOWED=EXPOSE
        # TODO(svidyuk): think about marker which forces semantics inheritance
        .SEM=PROTO_LIBRARY_SEM
        ENABLE(CPP_PROTO)
        ENABLE(GEN_PROTO)
        NO_CLANG_TIDY()
        SET(PEERDIR_TAGS CPP_PROTO)

        when ($BUILD_PROTO_AS_EVLOG == "yes" && $USE_VANILLA_PROTOC == "yes") {
            _OK=no
        }
        ASSERT(_OK BUILD_PROTO_AS_EVLOG and USE_VANILLA_PROTOC are incompatible yet)

        MODULE_SUFFIX=$_CPP_PROTO_MODULE_SUFFIX
        MODULE_PREFIX=$_CPP_PROTO_MODULE_PREFIX

        when ($_COMMON_GOOGLE_APIS != "None") {
            PEERDIR += contrib/libs/googleapis-common-protos
        }
    }

    module JAVA_PROTO: EXTERNAL_JAVA_LIBRARY {
        .EXTS=.jsrc
        .ALLOWED=GRPC
        .SEM=ignored
        SET(PEERDIR_TAGS JAVA_PROTO)
        ENABLE(JAVA_PROTO)
        PEERDIR+=$JAVA_PROTOBUF_PEERS contrib/java/javax/annotation/javax.annotation-api/1.3.1

        .IGNORED=GENERATE_ENUM_SERIALIZATION GENERATE_ENUM_SERIALIZATION_WITH_HEADER USE_SKIFF CPP_PROTO_PLUGIN2 PY_PROTO_PLUGIN YMAPS_SPROTO RESOURCE
        ADDINCL(FOR proto $PROTOBUF_PATH)

        when ($_COMMON_GOOGLE_APIS != "None") {
            PEERDIR += contrib/java/com/google/api/grpc/proto-google-common-protos/${JAVA_PROTO_COMMON_VERSION}
            ADDINCL += GLOBAL FOR proto ${ARCADIA_ROOT}/contrib/libs/googleapis-common-protos
        }
    }

    module PY_PROTO: PY2_LIBRARY {
        .ALIASES=SRCS=PY_SRCS
        .ALLOWED=OPTIMIZE_PY_PROTOS NO_OPTIMIZE_PY_PROTOS
        .PEERDIRSELF=CPP_PROTO
        .SEM=ignored
        SET(PEERDIR_TAGS PY2 PY_PROTO)
        ENABLE(PY_PROTO)
        OPTIMIZE_PY_PROTOS()
        OBJ_SUF=.py2
        # Can not use NO_LINT(), because is not allowed outside of contrib directory
        SET(LINT_LEVEL_VALUE none_internal)

        when ($_COMMON_GOOGLE_APIS != "None") {
            PEERDIR += contrib/libs/googleapis-common-protos
        }

        _IGNORE_SELF_PEERS=
        _CPP_PROTO_LIBRARY=${MODDIR}/$_CPP_PROTO_MODULE_PREFIX$REALPRJNAME$_CPP_PROTO_MODULE_SUFFIX
        when ($OPTIMIZE_PY_PROTOS_FLAG == "no") {
            _IGNORE_PEERDIRSELF=CPP_PROTO
        }
        SET_APPEND(_WHOLE_ARCHIVE_LIBS_VALUE_GLOBAL $_CPP_PROTO_LIBRARY)
    }

    module PY3_PROTO: PY3_LIBRARY {
        .ALIASES=SRCS=PY_SRCS
        .ALLOWED=OPTIMIZE_PY_PROTOS NO_OPTIMIZE_PY_PROTOS
        .PEERDIRSELF=CPP_PROTO
        .SEM=ignored
        SET(PEERDIR_TAGS PY3 PY3_PROTO)
        ENABLE(PY3_PROTO)
        OPTIMIZE_PY_PROTOS()
        when ($MSVC == "yes" || $CYGWIN == "yes") {
            MODULE_PREFIX=py3
        }
        otherwise {
            MODULE_PREFIX=libpy3
        }
        OBJ_SUF=.py3
        # Can not use NO_LINT(), because is not allowed outside of contrib directory
        SET(LINT_LEVEL_VALUE none_internal)

        when ($_COMMON_GOOGLE_APIS != "None") {
            PEERDIR += contrib/libs/googleapis-common-protos
        }

        _IGNORE_SELF_PEERS=
        _CPP_PROTO_LIBRARY=${MODDIR}/$_CPP_PROTO_MODULE_PREFIX$REALPRJNAME$_CPP_PROTO_MODULE_SUFFIX
        when ($OPTIMIZE_PY_PROTOS_FLAG == "no") {
            _IGNORE_PEERDIRSELF=CPP_PROTO
        }
        SET_APPEND(_WHOLE_ARCHIVE_LIBS_VALUE_GLOBAL $_CPP_PROTO_LIBRARY)
    }

    module GO_PROTO: GO_LIBRARY {
        .IGNORED=GENERATE_ENUM_SERIALIZATION GENERATE_ENUM_SERIALIZATION_WITH_HEADER YMAPS_SPROTO
        .SEM=ignored
        SET(PEERDIR_TAGS GO GO_PROTO)
        ENABLE(GO_PROTO)

        when ($_COMMON_GOOGLE_APIS == "None") {
        }
        elsewhen ($_COMMON_GOOGLE_APIS == "") {
            PEERDIR += $_GO_COMMON_GOOGLE_APIS
            ADDINCL += GLOBAL FOR proto ${ARCADIA_ROOT}/contrib/libs/googleapis-common-protos
        }
        otherwise {
            PEERDIR += $_COMMON_GOOGLE_APIS
            ADDINCL += GLOBAL FOR proto ${ARCADIA_ROOT}/contrib/libs/googleapis-common-protos
        }
    }

    module EXT_PROTO: _BARE_UNIT {
        .ALIASES=SRCS=_RAW_PROTO_SRCS
        .CMD=TOUCH_UNIT_MF
        .SEM=ignored
        .EXTS=.*
        .PROXY=yes
        .PEERDIR_POLICY=as_build_from
        SET(PEERDIR_TAGS EXT_PROTO)
        ENABLE(EXT_PROTO)
        SET(MODULE_SUFFIX .raw.fake.pkg)
        SET(MODULE_TYPE LIBRARY)

        when ($_COMMON_GOOGLE_APIS != "None") {
            PEERDIR += contrib/libs/googleapis-common-protos
        }
        SET(CREDITS_FILE_EXTRA_EXT .ext_proto)
    }

    module DESC_PROTO: _BARE_UNIT {
        .CMD=_PROTO_DESC_MERGE_CMD
        .SEM=ignored
        .EXTS=.desc
        .NODE_TYPE=Library
        .IGNORED=GENERATE_ENUM_SERIALIZATION GENERATE_ENUM_SERIALIZATION_WITH_HEADER YMAPS_SPROTO RESOURCE GO_PROTO_PLUGIN GRPC

        SET(PEERDIR_TAGS DESC_PROTO)
        ENABLE(DESC_PROTO)
        MODULE_SUFFIX=.self.protodesc
        SET(MODULE_TYPE LIBRARY)

        MACRO_ALIAS(EVLOG_CMD _PROTO_DESC_CMD)
        MACRO_ALIAS(PROTO_CMD _PROTO_DESC_CMD)

        when ($_COMMON_GOOGLE_APIS != "None") {
            PEERDIR += contrib/libs/googleapis-common-protos
        }

        when ($NEED_GOOGLE_PROTO_PEERDIRS == "yes") {
            when ($USE_VANILLA_PROTOC == "yes") {
                PEERDIR += contrib/libs/protobuf_std/builtin_proto/protos_from_protobuf
            }
            otherwise {
                PEERDIR += contrib/libs/protobuf/builtin_proto/protos_from_protoc
            }
        }
    }

    module PB_PY_PROTO: _PY_PACKAGE {
        .INCLUDE_TAG=no
        .PROXY=yes
        .SEM=ignored
        SET(MODULE_SUFFIX .pb_py.fake.pkg)
        ENABLE(PB_PY_PROTO)

        # WARN:
        #   _COMMON_GOOGLE_APIS aren't handled intentionally.
        #   PB_PY_PROTO is a legacy module type, stop using it.
    }
}

# tag:proto
_EXT_PROTO_DIR=_RAW_

# tag:proto
### This var defines the root of the tree for copied proto files from EXT_PROTO
### submodule of PROTO_LIBRARY module
EXT_PROTO_ROOT=${ARCADIA_BUILD_ROOT}/${_EXT_PROTO_DIR}

# tag:proto
### @usage: USE_EXT_PROTO(peerdir_tag...)
###
### Configure module to use proto files from existing PROTO_LIBRARY module.
### Additional PEERDIR tags required to build a module can be passed through
### EXTRA_TAGS vararg parameter.
macro USE_EXT_PROTO(EXTRA_TAGS...) {
    SET(PEERDIR_TAGS EXT_PROTO ${EXTRA_TAGS})
    SRCDIR(${EXT_PROTO_ROOT})
}

# tag:proto tag:internal
### @usage: _RAW_PROTO_SRCS(files...) # internal
###
### _RAW_PROTO_SRCS is a proxy macro to FILES macro which filters out
### GLOBAL keyword from the list of files (NOTE! The order of files listed
### originally in call to _RAW_PROTO_SRCS() macro is changed in call to
### FILES() macro). Currently this macro copies only files with the following
### extensions: .proto, .gztproto, .ev
macro _RAW_PROTO_SRCS(FILES...) {
    _COPY_FILES_TO_BUILD_PREFIX(${ext=.proto:FILES} PREFIX ${_EXT_PROTO_DIR})
    _COPY_FILES_TO_BUILD_PREFIX(${ext=.gztproto:FILES} PREFIX ${_EXT_PROTO_DIR})
    _COPY_FILES_TO_BUILD_PREFIX(${ext=.ev:FILES} PREFIX ${_EXT_PROTO_DIR})
}

module PROTO_DESCRIPTIONS: _BARE_UNIT {
    .CMD=_PROTO_DESC_MERGE_PEERS_CMD
    .PEERDIR_POLICY=as_build_from
    .NODE_TYPE=Library
    .RESTRICTED=SRCS
    .FINAL_TARGET=yes

    SET(PEERDIR_TAGS DESC_PROTO)
    SET(MODULE_SUFFIX .protodesc)
    SET(MODULE_TYPE PROTO_DESCRIPTIONS)
}

module PROTO_REGISTRY: PROTO_DESCRIPTIONS {
    SET(MODULE_TYPE PROTO_REGISTRY)
}

# tag:fbs
_FBS_NAMESPACE_MAP_GLOBAL=

# tag:fbs
macro _FBS_NAMESPACE_IMPL(NAMESPACE, PATH, DUMMY...) {
    SET_APPEND(_FBS_NAMESPACE_MAP_GLOBAL ${NAMESPACE}=${PATH})
}

# tag:fbs
macro FBS_NAMESPACE(NAMESPACE, PATH...) {
    _FBS_NAMESPACE_IMPL($NAMESPACE $PATH $MODDIR)
}

# tag:fbs
### @usage: FBS_LIBRARY()
###
### Build some variant of Flatbuffers library.
###
### The particular variant is selected based on where PEERDIR to FBS_LIBRARY
### comes from.
###
### Now supported 5 variants: C++, Java, Python 2.x, Python 3.x and Go.
### When PEERDIR comes from module for particular language appropriate variant
### is selected.
###
### Notes: FBS_NAMESPACE must be specified in all dependent FBS_LIBRARY modules
###        if build of Go code is requested.
multimodule FBS_LIBRARY {
    module CPP_FBS: LIBRARY {
        ENABLE(CPP_FBS)
        SET(PEERDIR_TAGS CPP_FBS)
    }

    module GO_FBS: GO_LIBRARY {
        .IGNORED=GENERATE_ENUM_SERIALIZATION GENERATE_ENUM_SERIALIZATION_WITH_HEADER
        ENABLE(GO_FBS)
        SET(PEERDIR_TAGS GO GO_FBS)
    }

    module JAVA_FBS: EXTERNAL_JAVA_LIBRARY {
        .IGNORED=GENERATE_ENUM_SERIALIZATION GENERATE_ENUM_SERIALIZATION_WITH_HEADER
        ENABLE(JAVA_FBS)
        SET(PEERDIR_TAGS JAVA_FBS)
    }

    module PY2_FBS: PY2_LIBRARY {
        .IGNORED=GENERATE_ENUM_SERIALIZATION GENERATE_ENUM_SERIALIZATION_WITH_HEADER
        .ALIASES=SRCS=PY_SRCS
        ENABLE(PY2_FBS)
        SET(PEERDIR_TAGS PY2 PY2_FBS)
        # Can not use NO_LINT(), because is not allowed outside of contrib directory
        SET(LINT_LEVEL_VALUE none_internal)
    }

    module PY3_FBS: PY3_LIBRARY {
        .IGNORED=GENERATE_ENUM_SERIALIZATION GENERATE_ENUM_SERIALIZATION_WITH_HEADER
        .ALIASES=SRCS=PY_SRCS
        ENABLE(PY3_FBS)
        SET(PEERDIR_TAGS PY3 PY3_FBS)
        # Can not use NO_LINT(), because is not allowed outside of contrib directory
        SET(LINT_LEVEL_VALUE none_internal)
        when ($MSVC == "yes" || $CYGWIN == "yes") {
            MODULE_PREFIX=py3
        }
        otherwise {
            MODULE_PREFIX=libpy3
        }
        OBJ_SUF=.py3
    }
}

# tag:java-specific
_COMPILE_JSRC=${cwd:ARCADIA_BUILD_ROOT} $YMAKE_PYTHON ${input:"build/scripts/compile_jsrc.py"} --input $AUTO_INPUT --output $TARGET --prefix $BINDIR ${kv;hide:"p JC"} ${kv;hide:"pc light-blue"} ${kv;hide:"show_out"}

# tag:java-specific
COMPILE_JSRC_MF=$_COMPILE_JSRC && $GENERATE_MF

# tag:java-specific tag:internal
### @usage: JSRC_LIBRARY() # internal
module JSRC_LIBRARY: _BARE_UNIT {
    .CMD=COMPILE_JSRC_MF
    .EXTS=.java
    .ALL_INS_TO_OUT=no
    .PEERDIR_POLICY=as_include
    .FINAL_TARGET=no
    .ALIASES=SRCS=FILES
    PEERDIR_TAGS=JAVA_PROTO JAVA_FBS JAVA_IDL
    MODULE_TYPE=Library
    SET(MODULE_SUFFIX .jsrc)
    SET(DONT_RESOLVE_INCLUDES yes)
    SET(NEED_PLATFORM_PEERDIRS no)
    SET(MODULE_LANG JAVA)

    NO_RUNTIME()
}

# tag:maps-specific
@import "${CONF_ROOT}/conf/project_specific/maps/asrc.conf"

# tag:internal
### @usage: _PROXY_LIBRARY() # internal
###
### The use of this module is strictly prohibited!!!
module _PROXY_LIBRARY: LIBRARY {
    .EXTS=.a .lib
    .PEERDIR_POLICY=as_build_from
    .PROXY=yes
    .FINAL_TARGET=yes
    DISABLE(NEED_ADD_FAKE_SRC)

    NO_UTIL()
    NO_RUNTIME()
}

# tag:maps-specific
@import "${CONF_ROOT}/conf/project_specific/maps/aar.conf"
@import "${CONF_ROOT}/conf/project_specific/maps/sproto.conf"
@import "${CONF_ROOT}/conf/project_specific/maps/mapkit.conf"

_PRIMARY_OUTPUT_VALUE=

# tag:internal
### @usage: PRIMARY_OUTPUT_VALUE(Output) # internal
###
### The use of this module is strictly prohibited!!!
macro PRIMARY_OUTPUT(OUTPUT) {
    SET(_PRIMARY_OUTPUT_VALUE $OUTPUT)
}

_DLL_PROXY_LIBRARY_CMD=$GENERATE_MF && $COPY_CMD $_PRIMARY_OUTPUT_VALUE ${input;hide:_PRIMARY_OUTPUT_VALUE} ${TARGET}

# tag:internal
### @usage: DLL_PROXY_LIBRARY() # internal
###
### The use of this module is strictly prohibited!!!
module DLL_PROXY_LIBRARY: _PROXY_LIBRARY {
    .ALLOWED=PRIMARY_OUTPUT
    .CMD=_DLL_PROXY_LIBRARY_CMD
}

_PREBUILT_PROGRAM_CMD=$GENERATE_MF && $COPY_CMD $_PRIMARY_OUTPUT_VALUE ${TARGET} ${kv;hide:"p ld"} ${kv;hide:"pc light-blue"} ${kv;hide:"show_out"}

# tag:internal
### @usage: PREBUILT_PROGRAM([programname]) # internal
###
### Program module which uses a prebuilt prgram as its output.
module PREBUILT_PROGRAM: _LINK_UNIT {
    .CMD=_PREBUILT_PROGRAM_CMD
    .SYMLINK_POLICY=EXE
    .ALLOWED=INDUCED_DEPS PRIMARY_OUTPUT
    .RESTRICTED=SRCS

    _BARE_LINK_MODULE()

    SET(MODULE_TYPE PROGRAM)

    when ($WIN32 == "yes" || $OS_CYGWIN == "yes") {
        MODULE_SUFFIX=.exe
    }
}

### @usage COLLECT_JINJA_TEMPLATES(varname path)
###
### This macro collects all jinja and yaml files in the directory specified by second argument and
### stores result in the variable with mane specified by first parameter.
macro COLLECT_JINJA_TEMPLATES(VAR, DIR) {
    _GLOB($VAR ${DIR}/**/*.jinja ${DIR}/**/*.yaml)
}

# tag:go-specific
GO_HOST_OS=unknown
when ($HOST_OS_LINUX) {
    GO_HOST_OS=linux
}
elsewhen ($HOST_OS_DARWIN) {
    GO_HOST_OS=darwin
}
elsewhen($HOST_OS_WINDOWS) {
    GO_HOST_OS=windows
}

# tag:go-specific
GO_HOST_ARCH=unknown
when ($HOST_ARCH_X86_64) {
    GO_HOST_ARCH=amd64
}
elsewhen($HOST_ARCH_ARM64) {
    GO_HOST_ARCH=arm64
}

# tag:go-specific
GO_TARG_OS=unknown
when ($OS_LINUX) {
    GO_TARG_OS=linux
}
elsewhen ($OS_DARWIN) {
    GO_TARG_OS=darwin
}
elsewhen ($OS_WINDOWS) {
    GO_TARG_OS=windows
}

# tag:go-specific
GO_TARG_ARCH=unknwon
when ($ARCH_X86_64) {
    GO_TARG_ARCH=amd64
}
elsewhen ($ARCH_I386) {
    GO_TARG_ARCH=x86
}
elsewhen ($ARCH_ARM64) {
    GO_TARG_ARCH=arm64
}

# tag:go-specific
GO_HOST_TARG_PARAMS=++host-os $GO_HOST_OS ++host-arch $GO_HOST_ARCH ++targ-os $GO_TARG_OS ++targ-arch $GO_TARG_ARCH

# tag:go-specific
GOSTD_VERSION=1.17.8
when ($GOSTD_VERSION == "1.17.8") {
    GOSTD=contrib/go/_std/src
}
elsewhen ($GOSTD_VERSION == "1.18rc1") {
    GOSTD=contrib/go/_std_1.18rc1/src
}
otherwise {
    GOSTD=__unsupported_go_std_library_version_[$GOSTD_VERSION]__
}

# tag:go-specific
GO_DEBUG_PATH_RELATIVE=no
_GO_DEBUG_PATH__NO_UID__=
_GO_COMPILE_SYMABIS_TRIMPATH__NO_UID__=

# tag:go-specific
_GO_IMPORT_PATH=${MODDIR}

# tag:go-specific
GO_VET=yolint
GO_VET_TOOL=
GO_VET_FLAGS=
GO_VET_EXTRA_FLAGS=

# tag:go-specific
_GO_VET_ADD_CHECK=yes
_GO_FMT_ADD_CHECK=yes
_GO_YDX_FILE=

# tag:go-specific
_GO_CGO1_WRAPPER_FLAGS=--build-prefix=/-B --source-prefix=/-S
_GO_LINK_EXE_EXT_CMD=

# tag:go-specific
GO_WITH_MUSL=

# tag:go-specific
GO_TOOLS_ROOT=${GO_TOOLS_RESOURCE_GLOBAL}
GO_TEST_MINER=${tool:"tools/go_test_miner"}
GO_TEST_IMPORT_PATH=

# tag:go-specific
GO_STD_LIB_PREFIX=${GOSTD}/
GO_STD_CMD_PREFIX=${GOSTD}/cmd/
GO_ARCADIA_PROJECT_PREFIX=a.yandex-team.ru/
GO_CONTRIB_PROJECT_PREFIX=vendor/
GO_SKIP_IMPORTS=unsafe C
GO_VET_INFO_EXT=.vet.out
GO_VET_REPORT_EXT=.vet.txt
GO_VET_OUTPUT_INFO=${output;rootrel;hide;pre=${MODULE_PREFIX};suf=${MODULE_SUFFIX}${GO_VET_INFO_EXT}:REALPRJNAME}
GO_VET_OUTPUT_REPORT=${output;rootrel;hide;pre=${MODULE_PREFIX};suf=${MODULE_SUFFIX}${GO_VET_REPORT_EXT}:REALPRJNAME}

# tag:go-specific tag:codenav
_GO_YNDEXER_EXT=.ydx.pb2
GO_YNDEXER_OUTPUT=${output;pre=${MODULE_PREFIX};suf=${MODULE_SUFFIX}${_GO_YNDEXER_EXT}:REALPRJNAME}

# tag:go-specific
GO_PROJECT_PREFIXES=++std-lib-prefix $GO_STD_LIB_PREFIX ++arc-project-prefix $GO_ARCADIA_PROJECT_PREFIX

# tag:go-specific
_GO_FAKEID=${FAKEID}.${BUILD_TYPE}.${GO_FAKEID}

# tag:go-specific
CGO2_CFLAGS_VALUE=
CGO2_LDFLAGS_VALUE=

# tag:go-specific
GO_ASM_FLAGS_VALUE=
### @usage: GO_ASM_FLAGS(flags)
### Add the specified flags to the go asm compile command line.
macro GO_ASM_FLAGS(Flags...) {
    SET_APPEND(GO_ASM_FLAGS_VALUE $Flags)
}

# tag:go-specific
GO_CGO1_FLAGS_VALUE=
### @usage: GO_CGO1_FLAGS(flags)
### Add the specified flags to the go cgo compile command line.
macro GO_CGO1_FLAGS(Flags...) {
    SET_APPEND(GO_CGO1_FLAGS_VALUE $Flags)
}

# tag:go-specific
GO_CGO2_FLAGS_VALUE=
### @usage: GO_CGO2_FLAGS(flags)
### Add the specified flags to the go cgo compile command line.
macro GO_CGO2_FLAGS(Flags...) {
    SET_APPEND(GO_CGO2_FLAGS_VALUE $Flags)
}

# tag:go-specific
GO_COMPILE_FLAGS_VALUE=$USER_GO_COMPILE_FLAGS
### @usage: GO_COMPILE_FLAGS(flags)
### Add the specified flags to the go compile command line.
macro GO_COMPILE_FLAGS(Flags...) {
    SET_APPEND(GO_COMPILE_FLAGS_VALUE $Flags)
}

# tag:go-specific
GO_LINK_FLAGS_VALUE=$USER_GO_LINK_FLAGS
### @usage: GO_LINK_FLAGS(flags)
### Add the specified flags to the go link command line.
macro GO_LINK_FLAGS(Flags...) {
    SET_APPEND(GO_LINK_FLAGS_VALUE $Flags)
}

# tag:go-specific
_GO_TOOL_MODE=

# tag:go-specific
_GO_TOOL_COMMON_FLAGS=\
    ++mode $_GO_TOOL_MODE \
    $GO_PROJECT_PREFIXES \
    ++goversion $GOSTD_VERSION \
    ++source-root $ARCADIA_ROOT \
    ++build-root $ARCADIA_BUILD_ROOT \
    ++output-root $BINDIR \
    ++toolchain-root $GO_TOOLS_ROOT \
    $GO_HOST_TARG_PARAMS \
    ++output $TARGET \
    $GO_VET_OUTPUT \
    $_GO_YDX_FILE \
    $_GO_DEBUG_PATH__NO_UID__ \
    ++srcs $AUTO_INPUT ${input:GO_FILES} \
    ++asm-flags $GO_ASM_FLAGS_VALUE \
    ++compile-flags $GO_COMPILE_FLAGS_VALUE \
    ++link-flags $GO_LINK_FLAGS_VALUE \
    ++cgo-srcs ${input:CGO_FILES} \
    $_GO_EMBED_VALUE \
    $GO_TOOLCHAIN_ENV

# tag:go-specific
macro _GO_GEN_COVER_GO(GO_FILE, VAR_ID) {
    .CMD=${hide:_GO_FAKEID} $GO_TOOLS_ROOT/pkg/tool/${GO_HOST_OS}_${GO_HOST_ARCH}/cover -mode set -var $VAR_ID -o ${output;noext;suf=.cover.go:GO_FILE} ${input:GO_FILE}
}

# tag:go-specific
macro _GO_COMPILE_SYMABIS(FLAGS[], ASM_FILES...) {
    .CMD=${hide:_GO_FAKEID} $GO_TOOLS_ROOT/pkg/tool/${GO_HOST_OS}_${GO_HOST_ARCH}/asm $_GO_COMPILE_SYMABIS_TRIMPATH__NO_UID__ ${pre=-I :_C__INCLUDE} -I $GO_TOOLS_ROOT/pkg/include -D GOOS_${GO_TARG_OS} -D GOARCH_${GO_TARG_ARCH} $FLAGS $GO_ASM_FLAGS_VALUE -gensymabis -o ${output:"gen.symabis"} ${input:ASM_FILES} ${kv;hide:"p go"} ${kv;hide:"pc light-blue"} ${kv;hide:"show_out"}
    .ADDINCL=build/scripts/go_fake_include
}

# tag:go-specific
macro _GO_COMPILE_CGO1(NAME, FLAGS[], FILES...) {
    .CMD=${hide:_GO_FAKEID} ${cwd:ARCADIA_ROOT} $YMAKE_PYTHON ${input:"build/scripts/cgo1_wrapper.py"} $_GO_CGO1_WRAPPER_FLAGS --build-root ${ARCADIA_BUILD_ROOT} --source-root ${ARCADIA_ROOT} --cgo1-files ${output;noext:FILES.cgo1.go} --cgo2-files ${output;noauto;noext:FILES.cgo2.c} -- ${GO_TOOLS_ROOT}/pkg/tool/${GO_HOST_OS}_${GO_HOST_ARCH}/cgo -objdir $BINDIR -importpath $NAME $GO_CGO1_FLAGS_VALUE $FLAGS -- $C_FLAGS_PLATFORM ${pre=-I:_C__INCLUDE} ${CGO_CFLAGS_VALUE} ${input:FILES} ${output;hide:"_cgo_export.h"} ${output;hide:"_cgo_export.c"} ${output;hide:"_cgo_gotypes.go"} ${output;noauto;hide:"_cgo_main.c"} ${output;noauto;hide:"_cgo_flags"} $GO_TOOLCHAIN_ENV ${kv;hide:"p go"} ${kv;hide:"pc light-blue"} ${kv;hide:"show_out"}
}

# tag:go-specific
macro _GO_COMPILE_CGO2(NAME, C_FILES[], S_FILES[], OBJ_FILES[], FILES...) {
    .CMD=${hide:_GO_FAKEID} $C_COMPILER $C_FLAGS_PLATFORM ${pre=-I:_C__INCLUDE} $CGO_CFLAGS_VALUE ${input;tobindir:"_cgo_main.c"} -c -o ${tmp;noauto;suf=${OBJECT_SUF}:"_cgo_main.c"} && $C_COMPILER $C_FLAGS_PLATFORM ${pre=-I:_C__INCLUDE} -o ${tmp;noauto;suf=${OBJECT_SUF}:"_cgo_"} $LDFLAGS $LDFLAGS_GLOBAL $CGO2_LDFLAGS_VALUE ${input;hide:"_cgo_export.h"} ${tmp;noauto;suf=${OBJECT_SUF}:"_cgo_main.c"} ${input;suf=${OBJECT_SUF}:"_cgo_export.c"} ${input;nopath;noext;suf=.cgo2.c${OBJECT_SUF}:FILES} ${input;suf=${OBJECT_SUF}:C_FILES} ${input;suf=.o:S_FILES} ${input:OBJ_FILES} $CGO_LDFLAGS_VALUE && ${GO_TOOLS_ROOT}/pkg/tool/${GO_HOST_OS}_${GO_HOST_ARCH}/cgo -dynpackage $NAME -dynimport ${tmp;noauto;suf=${OBJECT_SUF}:"_cgo_"} -dynout ${output:"_cgo_import.go"} -dynlinker $GO_CGO2_FLAGS_VALUE $GO_TOOLCHAIN_ENV ${kv;hide:"p go"} ${kv;hide:"pc light-blue"} ${kv;hide:"show_out"}

    _USE_LINKER()
}

# tag:go-specific
macro _GO_LINK_LIB_IMPL(CGO_FILES[], EXTRA_INPUTS[], GO_FILES...) {
    .CMD=${hide:_GO_FAKEID} $YMAKE_PYTHON ${input:"build/scripts/go_tool.py"} ${hide;input:EXTRA_INPUTS} --ya-start-command-file $_GO_TOOL_COMMON_FLAGS ++peers ${rootrel;tags_in=local,GO|local,GO_PROTO|local,GO_FBS:PEERS} --ya-end-command-file ${kv;hide:"p GO"} ${kv;hide:"pc light-red"} ${kv;hide:"show_out"}
}

# tag:go-specific
macro _GO_LINK_EXE_IMPL(CGO_FILES[], EXTRA_INPUTS[], GO_FILES...) {
    .CMD=${hide:_GO_FAKEID} $YMAKE_PYTHON ${input:"build/scripts/go_tool.py"} ${hide;input:EXTRA_INPUTS} --ya-start-command-file $_GO_TOOL_COMMON_FLAGS ++vcs $VCS_GO $GO_WITH_MUSL $GO_EXTLD ++peers ${rootrel;tags_in=local,GO|local,GO_PROTO|local,GO_FBS:PEERS} ++non-local-peers ${rootrel;tags_in=GO|GO_PROTO|GO_FBS;tags_out=local:PEERS} ++cgo-peers ${VCS_C_OBJ_RR} ${rootrel;tags_out=GO|GO_PROTO|GO_FBS:PEERS} --ya-end-command-file ${kv;hide:"p LD"} ${kv;hide:"pc light-red"} ${kv;hide:"show_out"} $_GO_LINK_EXE_EXT_CMD
}

# tag:go-specific
macro _GO_LINK_TEST_IMPL(CGO_FILES[], EXTRA_INPUTS[], GO_TEST_FILES[], GO_XTEST_FILES[], GO_FILES...) {
    .CMD=${hide:_GO_FAKEID} $YMAKE_PYTHON ${input:"build/scripts/go_tool.py"} ${hide;input:EXTRA_INPUTS} --ya-start-command-file $_GO_TOOL_COMMON_FLAGS ++vcs $VCS_GO $GO_WITH_MUSL $GO_EXTLD ++test-miner $GO_TEST_MINER ++test-import-path $GO_TEST_IMPORT_PATH ++peers ${rootrel;tags_in=local,GO|local,GO_PROTO|local,GO_FBS:PEERS} ++non-local-peers ${rootrel;tags_in=GO|GO_PROTO|GO_FBS;tags_out=local:PEERS} ++cgo-peers ${VCS_C_OBJ_RR} ${rootrel;tags_out=GO|GO_PROTO|GO_FBS:PEERS} ++test_srcs ${input:GO_TEST_FILES} ++xtest_srcs ${input:GO_XTEST_FILES} ++cover_info $GO_COVER_INFO_VALUE ++skip-tests $_GO_SKIP_TEST_VALUE --ya-end-command-file ${kv;hide:"p GO"} ${kv;hide:"pc light-red"} ${kv;hide:"show_out"}
}

# tag:go-specific
GO_LINK_LIB=$GENERATE_MF && $_GO_LINK_LIB_IMPL($_GO_SRCS_VALUE CGO_FILES $_CGO_SRCS_VALUE EXTRA_INPUTS $_GO_EMBED_INPUTS)
GO_LINK_EXE=$GENERATE_MF && $GENERATE_VCS_C_INFO_NODEP && $GENERATE_VCS_GO_INFO_NODEP && $_GO_LINK_EXE_IMPL($_GO_SRCS_VALUE CGO_FILES $_CGO_SRCS_VALUE EXTRA_INPUTS $_GO_EMBED_INPUTS)
GO_LINK_TEST=$GENERATE_VCS_C_INFO_NODEP && $GENERATE_VCS_GO_INFO_NODEP && $_GO_LINK_TEST_IMPL($_GO_SRCS_VALUE CGO_FILES $_CGO_SRCS_VALUE EXTRA_INPUTS $_GO_EMBED_INPUTS GO_TEST_FILES $_GO_TEST_SRCS_VALUE GO_XTEST_FILES $_GO_XTEST_SRCS_VALUE)
GO_LINK_DLL=$GO_LINK_EXE && $COPY_CMD $BINDIR/_cgo_export.h ${output;pre=${MODULE_PREFIX};suf=.h:REALPRJNAME}

# tag:go-specific
CGO_ENABLED=yes
when ($OS_WINDOWS == "yes" || $SANITIZER_TYPE && $SANITIZER_TYPE != "no") {
    CGO_ENABLED=no
}

# tag:go-specific
GO_PACKAGE_VALUE=
### @usage: GO_PACKAGE_NAME(Name)
### Override name of a Go package.
macro GO_PACKAGE_NAME(NAME) {
    SET(GO_PACKAGE_VALUE $NAME)
}

# tag:go-specific tag:internal
_GO_SRCS_VALUE=
### @usage: _GO_SRCS(Files...) # internal
### This macro shouldn't be used in ya.make files, use SRCS() instead.
### This is internal macro collecting .go sources for processing within Go modules (GO_PROGRAM and GO_LIBRARY)
macro _GO_SRCS(FILES...) {
    GO_FAKE_OUTPUT($FILES)
    SET_APPEND(_GO_SRCS_VALUE $FILES)
}

# tag:go-specific
_GO_TEST_SRCS_VALUE=
GO_HAS_INTERNAL_TESTS=no
### @usage: GO_TEST_SRCS(Files...)
### .go sources for internal tests of a module
macro GO_TEST_SRCS(FILES...) {
    GO_FAKE_OUTPUT($FILES)
    _SET_FIRST_VALUE(GO_HAS_INTERNAL_TESTS ${pre=yes :FILES} ${GO_HAS_INTERNAL_TESTS})
    SET_APPEND(_GO_TEST_SRCS_VALUE $FILES)
}

# tag:go-specific
_GO_XTEST_SRCS_VALUE=
GO_HAS_EXTERNAL_TESTS=no
### @usage: GO_XTEST_SRCS(Files...)
### .go sources for external tests of a module
macro GO_XTEST_SRCS(FILES...) {
    GO_FAKE_OUTPUT($FILES)
    SET(GO_HAS_EXTERNAL_TESTS yes)
    SET_APPEND(_GO_XTEST_SRCS_VALUE $FILES)
}

# tag:go-specific
macro _GO_UNUSED_SRCS(FLAGS...) {
    ENABLE(UNUSED_MACRO)
}

# tag:go-specific
_CGO_SRCS_VALUE=
### @usage: CGO_SRCS(Files...)
### .go sources to be built with CGO
macro CGO_SRCS(FILES...) {
    SET_APPEND(_CGO_SRCS_VALUE $FILES)
    PEERDIR(${GOSTD}/syscall)
}

# tag:go-specific
GO_LDFLAGS_GLOBAL=
### @usage: GO_LDFLAGS(Flags...)
### Link flags for GO_PROGRAM linking from .go sources
macro GO_LDFLAGS(FLAGS...) {
    SET_APPEND(GO_LDFLAGS_GLOBAL $FLAGS)
}

# tag:go-specific
CGO_CFLAGS_VALUE=
### @usage: CGO_CFLAGS(Flags...)
### Compiler flags specific to CGO compilation
macro CGO_CFLAGS(FLAGS...) {
    SET_APPEND(CGO_CFLAGS_VALUE $FLAGS)
    CFLAGS($FLAGS)
}

# tag:go-specific
CGO_LDFLAGS_VALUE=
### @usage: CGO_LDFLAGS(Files...)
### Linker flags specific to CGO linking
macro CGO_LDFLAGS(FLAGS...) {
    SET_APPEND(CGO_LDFLAGS_VALUE $FLAGS)
    GO_LDFLAGS($FLAGS)
}

# tag:go-specific
_GO_SKIP_TEST_VALUE=
### @usage: GO_SKIP_TESTS(TestNames...)
###
### Define a set of tests that should not be run.
### NB! Subtests are not taken into account!
macro GO_SKIP_TESTS(TESTS...) {
    SET_APPEND(_GO_SKIP_TEST_VALUE $TESTS)
    RESTRICT_PATH(vendor MSG This macro is prohibited to be used outside the vendor/ directory)
}

# tag:go-specific tag:internal
_GO_EMBED_VALUE=
_GO_EMBED_INPUTS=
### @usage: _GO_EMBED_PATTERN(PATTERN) # internal
###
### Define an embed pattern.
macro _GO_EMBED_PATTERN(XTEST?"_xtest":"", PATTERN, IMPORT_PATH) {
    SET(VAR_SALT1 $XTEST $PATTERN $IMPORT_PATH 1)
    SET(_PATTERN_GLOB1 uniq_embed_${hash:VAR_SALT1})
    _GLOB($_PATTERN_GLOB1 ${ARCADIA_ROOT}/${IMPORT_PATH}/${PATTERN}/**/* EXCLUDE ${ARCADIA_ROOT}/${IMPORT_PATH}/${PATTERN}/**/_* ${ARCADIA_ROOT}/${IMPORT_PATH}/${PATTERN}/**/.*)
    SET(VAR_SALT2 $XTEST $PATTERN $IMPORT_PATH 2)
    SET(_PATTERN_GLOB2 _uniq_embed_${hash:VAR_SALT2})
    _GLOB($_PATTERN_GLOB2 ${ARCADIA_ROOT}/${IMPORT_PATH}/${PATTERN})
    SET_APPEND(_GO_EMBED_VALUE ++embed$XTEST $PATTERN \$$_PATTERN_GLOB1 \$$_PATTERN_GLOB2)
    SET_APPEND(_GO_EMBED_INPUTS \$$_PATTERN_GLOB1 \$$_PATTERN_GLOB2)
}

# tag:go-specific
### @usage: GO_EMBED_PATTERN(PATTERN)
###
### Define an embed pattern.
macro GO_EMBED_PATTERN(PATTERN) {
    _GO_EMBED_PATTERN($PATTERN $_GO_IMPORT_PATH)
}

# tag:go-specific
### @usage: GO_TEST_EMBED_PATTERN(PATTERN)
###
### Define an embed pattern for internal go tests.
macro GO_TEST_EMBED_PATTERN(PATTERN) {
    _GO_EMBED_PATTERN($PATTERN $_GO_IMPORT_PATH)
}

# tag:go-specific
### @usage: GO_XTEST_EMBED_PATTERN(PATTERN)
###
### Define an embed pattern for external go tests.
macro GO_XTEST_EMBED_PATTERN(PATTERN) {
    _GO_EMBED_PATTERN(XTEST $PATTERN $_GO_IMPORT_PATH)
}

# tag:go-specific tag:internal
### @usage: _GO_EMBED_DIR(PATTERN) # internal
###
### Define an embed directory DIR.
macro _GO_EMBED_DIR(XTEST?"_xtest":"", DIR, IMPORT_PATH) {
    SET(VAR_SALT $XTEST $DIR $IMPORT_PATH)
    SET(_PATTERN_GLOB uniq_embed_${hash:VAR_SALT})
    _GLOB($_PATTERN_GLOB ${ARCADIA_ROOT}/${IMPORT_PATH}/${DIR}/**/* EXCLUDE ${ARCADIA_ROOT}/${IMPORT_PATH}/${DIR}/**/_* ${ARCADIA_ROOT}/${IMPORT_PATH}/${DIR}/**/.*)
    SET_APPEND(_GO_EMBED_VALUE ++embed$XTEST $DIR \$$_PATTERN_GLOB)
    SET_APPEND(_GO_EMBED_INPUTS \$$_PATTERN_GLOB)
}

# tag:go-specific
### @usage: GO_EMBED_DIR(DIR)
###
### Define an embed directory DIR.
macro GO_EMBED_DIR(DIR) {
    _GO_EMBED_DIR($DIR $_GO_IMPORT_PATH)
}

# tag:go-specific
### @usage: GO_TEST_EMBED_DIR(DIR)
###
### Define an embed directory DIR for internal go tests.
macro GO_EMBED_TEST_DIR(DIR) {
    _GO_EMBED_DIR($DIR $_GO_IMPORT_PATH)
}

# tag:go-specific
### @usage: GO_XTEST_EMBED_DIR(DIR)
###
### Define an embed directory DIR for external go tests.
macro GO_EMBED_XTEST_DIR(DIR) {
    _GO_EMBED_DIR(XTEST $DIR $_GO_IMPORT_PATH)
}

# tag:go-specific
_GO_TOOLCHAIN_ENV_GOARCH=unknown
when ($ARCH_ARM64) {
    _GO_TOOLCHAIN_ENV_GOARCH=${env:"GOARCH=arm64"}
}
elsewhen ($ARCH_X86_64) {
    _GO_TOOLCHAIN_ENV_GOARCH=${env:"GOARCH=amd64"}
}

# tag:go-specific
_GO_TOOLCHAIN_ENV_GOOS=unknown
when ($OS_DARWIN) {
    _GO_TOOLCHAIN_ENV_GOOS=${env:"GOOS=darwin"}
}
elsewhen ($OS_LINUX) {
    _GO_TOOLCHAIN_ENV_GOOS=${env:"GOOS=linux"}
}
elsewhen ($OS_WINDOWS) {
    _GO_TOOLCHAIN_ENV_GOOS=${env:"GOOS=windows"}
}
_GO_TOOLCHAIN_ENV_PATH=

# tag:go-specific
GO_TOOLCHAIN_ENV=$TOOLCHAIN_ENV $_GO_TOOLCHAIN_ENV_GOARCH $_GO_TOOLCHAIN_ENV_GOOS $_GO_TOOLCHAIN_ENV_PATH

# tag:go-specific
_GO_GRPC_WELLKNOWN=\
    vendor/google.golang.org/grpc \
    vendor/google.golang.org/grpc \
    vendor/google.golang.org/grpc/codes \
    vendor/google.golang.org/grpc/grpclog \
    vendor/google.golang.org/grpc/status

# tag:go-specific
macro _GO_GRPC() {
    SET(GO_PROTO_GEN_PLUGINS grpc)
    PEERDIR(${GOSTD}/context ${_GO_GRPC_WELLKNOWN})
}

# tag:go-specific
### @usage: GO_GRPC_GATEWAY_SRCS()
###
### Use of grpc-gateway plugin (Supported for Go only).
macro GO_GRPC_GATEWAY_SRCS(FILE...) {
    ENABLE(UNUSED_MACRO)
}

# tag:go-specific
### @usage: GO_GRPC_GATEWAY_SWAGGER_SRCS()
###
### Use of grpc-gateway plugin w/ swagger emission (Supported for Go only).
macro GO_GRPC_GATEWAY_SWAGGER_SRCS(FILE...) {
    PEERDIR(vendor/github.com/grpc-ecosystem/grpc-gateway/protoc-gen-swagger/options)
}

# tag:go-specific
_GO_PROTO_GRPC_GATEWAY_OPTS=
_GO_PROTO_GRPC_GATEWAY_OUTS=

# tag:go-specific
macro _GO_GRPC_GATEWAY_SRCS_IMPL(Files...) {
    foreach (File : $Files) {
        [.proto]=$_GO_PROTO_CMD_IMPL($File OPTS $_GO_PROTO_GRPC_GATEWAY_OPTS OUTS $_GO_PROTO_GRPC_GATEWAY_OUTS)
    }

    PEERDIR(${GOSTD}/context ${GOSTD}/io ${GOSTD}/net/http)
    PEERDIR(vendor/github.com/golang/protobuf/descriptor)
    PEERDIR(vendor/github.com/grpc-ecosystem/grpc-gateway/runtime)
    PEERDIR(vendor/github.com/grpc-ecosystem/grpc-gateway/utilities)
    PEERDIR(vendor/google.golang.org/grpc/metadata)
}

# tag:go-specific
macro _SETUP_GO_GRPC_GATEWAY() {
    SET(_GO_PROTO_GRPC_GATEWAY_OPTS $_PROTO_PLUGIN_ARGS_BASE(go_grpc_gw vendor/github.com/grpc-ecosystem/grpc-gateway/protoc-gen-grpc-gateway allow_repeated_fields_in_body=true:))
    SET(_GO_PROTO_GRPC_GATEWAY_OUTS \${output;hide;norel;nopath;noext;suf=.pb.gw.go:File})
}

# tag:go-specific
macro _GO_GRPC_GATEWAY_SRCS(Files...) {
    _SETUP_GO_GRPC_GATEWAY()
    _GO_GRPC_GATEWAY_SRCS_IMPL($Files)
}

# tag:go-specific
macro _GO_GRPC_GATEWAY_SWAGGER_SRCS(Files...) {
    _SETUP_GO_GRPC_GATEWAY()
    SET_APPEND(_GO_PROTO_GRPC_GATEWAY_OPTS  $_PROTO_PLUGIN_ARGS_BASE(swagger vendor/github.com/grpc-ecosystem/grpc-gateway/protoc-gen-swagger logtostderr=true:))
    SET_APPEND(_GO_PROTO_GRPC_GATEWAY_OUTS \${output;hide;norel;noauto;nopath;noext;suf=.swagger.json:File})

    _GO_GRPC_GATEWAY_SRCS_IMPL($Files)
    PEERDIR(vendor/github.com/grpc-ecosystem/grpc-gateway/protoc-gen-swagger/options)
}

# tag:go-specific
when ($MUSL == "yes") {
    _GO_DEFAULT_ALLOCATOR=$DEFAULT_ALLOCATOR
}
otherwise {
    _GO_DEFAULT_ALLOCATOR=FAKE
}

# tag:go-specific tag:internal
### @usage _GO_BASE_UNIT # internal
###
### The base module of all golang modules. Defines common properties, dependencies and rules for go build.
module _GO_BASE_UNIT: _BASE_UNIT {
    .EXTS=.go .gosrc .o .obj .a .symabis .mf
    .CMD=TOUCH_UNIT
    .NODE_TYPE=Bundle
    .GLOBAL=GO_LDFLAGS
    .PEERDIR_POLICY=as_build_from
    .ALIASES=SRCS=_GO_SRCS RESOURCE=_GO_RESOURCE GO_TEST_SRCS=_GO_UNUSED_SRCS GO_XTEST_SRCS=_GO_UNUSED_SRCS GRPC=_GO_GRPC GO_GRPC_GATEWAY_SRCS=_GO_GRPC_GATEWAY_SRCS GO_GRPC_GATEWAY_SWAGGER_SRCS=_GO_GRPC_GATEWAY_SWAGGER_SRCS CFLAGS=CGO_CFLAGS GO_TEST_EMBED_PATTERN=_GO_UNUSED_SRCS GO_XTEST_EMBED_PATTERN=_GO_UNUSED_SRCS GO_TEST_EMBED_DIR=_GO_UNUSED_SRCS GO_XTEST_EMBED_DIR=_GO_UNUSED_SRCS
    .ALLOWED=GO_PROTO_PLUGIN USE_CXX USE_UTIL RESOURCE_FILES
    .IGNORED=GO_SKIP_TESTS USE_SKIFF
    .DEFAULT_NAME_GENERATOR=UseDirNameOrSetGoPackage

    ENABLE(_GO_MODULE)
    SET(MODULE_TAG GO)
    PEERDIR_TAGS=GO GO_PROTO GO_FBS __EMPTY__
    DEFAULT(_GO_VET_TOOL)
    DEFAULT(_GO_VET_FLAGS)
    DEFAULT(_GO_VET_EXTS)
    DEFAULT(_GO_SONAME)

    NO_RUNTIME()

    SET(COVERAGE_FLAGS)
    SET(EXTRA_OUTPUT)
    SET(MODULE_LANG GO)

    PEERDIR(build/external_resources/go_tools)

    GO_PROTO_OUTS+=${output;hide;norel;nopath;noext;suf=.pb.go:File}

    when ($COMPILER_PLATFORM && $NEED_PLATFORM_PEERDIRS == "yes") {
        PEERDIR+=$COMPILER_PLATFORM
    }

    when ($CLANG == "yes" || $GCC == "yes") {
        CGO_CFLAGS_VALUE += -w -pthread -fpic
        CGO2_CFLAGS_VALUE += -Wno-unused-variable
    }

    select ($GO_VET) {
        "yes" | "on" ? {
            _GO_VET=yes
            _GO_VET_FLAGS+=-cgocall=false
        }
        "yndexer" ? {
            _GO_VET=yes
            PEERDIR+=build/external_resources/goyndexer
            _GO_VET_TOOL=${GOYNDEXER_RESOURCE_GLOBAL}/goyndexer
            _GO_YDX_FILE=++ydx-file ${_GO_YNDEXER_EXT}
            _GO_VET_FLAGS=-indexer.arc ${ARCADIA_ROOT} -indexer.indexfile ${GO_YNDEXER_OUTPUT} -indexer.loglevel info
            _GO_FMT_ADD_CHECK=no
            _GO_VET_ADD_CHECK=no
            GO_VET_INFO_EXT=.ydx.out
            GO_VET_REPORT_EXT=.ydx.txt
            _GO_VET_EXTS=++vet-info-ext .ydx.out ++vet-report-ext .ydx.txt
            _GO_CGO1_WRAPPER_FLAGS=--build-prefix=__ARCADIA_BUILD_ROOT_PREFIX__ --source-prefix=__ARCADIA_SOURCE_ROOT_PREFIX__
        }
        "yolint" ? {
            _GO_VET=yes
            PEERDIR+=build/external_resources/yolint
            _GO_VET_TOOL=${YOLINT_RESOURCE_GLOBAL}/yolint
            _GO_VET_FLAGS=-migration.config=${input:"${ARCADIA_ROOT}/build/rules/go/migrations.yaml"} -scopelint.config=${input:"${ARCADIA_ROOT}/build/rules/go/extended_lint.yaml"}
        }
        "yolint_next" ? {
            _GO_VET=yes
            PEERDIR+=build/external_resources/yolint
            _GO_VET_TOOL=${YOLINT_NEXT_RESOURCE_GLOBAL}/yolint
            _GO_VET_FLAGS=-scopelint.config=${input:"${ARCADIA_ROOT}/build/rules/go/extended_lint.yaml"}
        }
        "local" ? {
            _GO_VET=yes
            _GO_VET_FLAGS=
        }
        default ? {
            _GO_VET=no
            _GO_VET_FLAGS=
        }
    }
    SET(_GO_VET $_GO_VET)

    when ($GO_VET_TOOL == "") {
        _GO_VET_TOOL_REAL=$_GO_VET_TOOL
    }
    otherwise {
        _GO_VET_TOOL_REAL=$GO_VET_TOOL
    }

    when ($GO_VET_FLAGS == "") {
        _GO_VET_FLAGS_REAL=$_GO_VET_FLAGS
    }
    otherwise {
        _GO_VET_FLAGS_REAL=$GO_VET_FLAGS
    }

    when ($_GO_VET == "yes" && $NO_GO_VET != "yes") {
        GO_VET_OUTPUT=++vet $_GO_VET_TOOL_REAL ++vet-flags $_GO_VET_FLAGS_REAL $GO_VET_EXTRA_FLAGS $GO_VET_OUTPUT_INFO $GO_VET_OUTPUT_REPORT $_GO_VET_EXTS
    }
    otherwise {
        GO_VET_OUTPUT=
        _GO_VET_ADD_CHECK=no
    }

    when ($GO_DEBUG_PATH_RELATIVE == "yes") {
        _GO_DEBUG_PATH__NO_UID__=++debug-root-map source=;build=;tools= ++tools-root $(TOOL_ROOT)
        _GO_COMPILE_SYMABIS_TRIMPATH__NO_UID__=-trimpath $ARCADIA_ROOT=>;$ARCADIA_BUILD_ROOT=>;$(TOOL_ROOT)=>
    }
    otherwise {
        _GO_DEBUG_PATH__NO_UID__=++debug-root-map source=/-S;build=/-B;tools=/-T ++tools-root $(TOOL_ROOT)
        _GO_COMPILE_SYMABIS_TRIMPATH__NO_UID__=-trimpath $ARCADIA_ROOT=>/-S;$ARCADIA_BUILD_ROOT=>/-B;$(TOOL_ROOT)=>/-T
    }

    _GO_PROCESS_SRCS()

    when ($CLANG == "yes") {
        _GO_EXTLD=clang
        GO_TOOLCHAIN_ENV += ${env:"CC=clang"}
    }
    otherwise {
        _GO_EXTLD=gcc
        GO_TOOLCHAIN_ENV += ${env:"CC=gcc"}
    }

    when ($OS_DARWIN) {
        PEERDIR+=build/external_resources/go_fake_xcrun
        GO_EXTLD = ++extld $_GO_EXTLD ++extldflags $_GO_SONAME $LD_SDK_VERSION -undefined dynamic_lookup $C_FLAGS_PLATFORM --sysroot=$MACOS_SDK_RESOURCE_GLOBAL --start-wa ${rootrel;ext=.a:SRCS_GLOBAL} --end-wa ${rootrel;ext=.o:SRCS_GLOBAL} --cgo-peers $LDFLAGS $LDFLAGS_GLOBAL $OBJADDE $OBJADDE_LIB $GO_LDFLAGS_GLOBAL $C_LIBRARY_PATH $C_SYSTEM_LIBRARIES_INTERCEPT $C_SYSTEM_LIBRARIES $STRIP_FLAG
        CGO2_LDFLAGS_VALUE += $LD_SDK_VERSION -undefined dynamic_lookup -nodefaultlibs -lc
    }
    elsewhen ($OS_LINUX) {
        GO_EXTLD = ++extld $_GO_EXTLD ++extldflags $_GO_SONAME $C_FLAGS_PLATFORM --sysroot=$OS_SDK_ROOT_RESOURCE_GLOBAL -Wl,--whole-archive ${rootrel;ext=.a:SRCS_GLOBAL} -Wl,--no-whole-archive ${rootrel;ext=.o:SRCS_GLOBAL} --cgo-peers $LDFLAGS $LDFLAGS_GLOBAL $OBJADDE $OBJADDE_LIB $GO_LDFLAGS_GLOBAL $C_LIBRARY_PATH $C_SYSTEM_LIBRARIES_INTERCEPT $C_SYSTEM_LIBRARIES $STRIP_FLAG
        CGO2_LDFLAGS_VALUE += -Wl,--unresolved-symbols=ignore-all -nodefaultlibs -lc
    }
    otherwise {
        GO_EXTLD = ++extld $_GO_EXTLD
    }

    when ($RACE == "yes") {
        _GO_COMPILE_FLAGS_RACE=-race
        _GO_LINK_FLAGS_RACE=-race
    }
    otherwise {
        _GO_COMPILE_FLAGS_RACE=
        _GO_LINK_FLAGS_RACE=
    }

    when ($PIC == "yes") {
        _GO_COMPILE_FLAGS_SHARED=-shared
        _GO_ASM_FLAGS_SHARED=-shared
    }
    otherwise {
        _GO_COMPILE_FLAGS_SHARED=
        _GO_ASM_FLAGS_SHARED=
    }

    GO_ASM_FLAGS_VALUE += $_GO_ASM_FLAGS_SHARED
    GO_COMPILE_FLAGS_VALUE += $_GO_COMPILE_FLAGS_RACE $_GO_COMPILE_FLAGS_SHARED
    GO_LINK_FLAGS_VALUE += $_GO_LINK_FLAGS_RACE

    ADDINCL(${GOSTD}/runtime)
}

# tag:go-specific
### @usage: GO_LIBRARY([name])
###
### Go library module definition.
### Compile Go module as a library suitable for PEERDIR from other Go modules.
### Will select Go implementation on PEERDIR to PROTO_LIBRARY.
module GO_LIBRARY: _GO_BASE_UNIT {
    .CMD=GO_LINK_LIB
    .NODE_TYPE=Bundle
    .FINAL_TARGET=no
    SET(_GO_TOOL_MODE lib)
    SET(MODULE_TYPE LIBRARY)
    _REQUIRE_EXPLICIT_LICENSE(vendor)

    MODULE_SUFFIX=.a
}

# tag:go-specific
### @usage: GO_PROGRAM([name])
###
### Go program module definition.
### Compile and link Go module to an executable program.
### Will select Go implementation on PEERDIR to PROTO_LIBRARY.
module GO_PROGRAM: _GO_BASE_UNIT {
    .CMD=GO_LINK_EXE
    .NODE_TYPE=Bundle
    .SYMLINK_POLICY=EXE
    .ALLOWED=INDUCED_DEPS
    .FINAL_TARGET=yes
    SET(_GO_TOOL_MODE exe)
    SET(MODULE_TYPE PROGRAM)
    SET(GO_VET_OUTPUT_INFO)

    ALLOCATOR($_GO_DEFAULT_ALLOCATOR)

    _USE_LINKER()

    ENABLE(COMMON_LINK_SETTINGS)

    when ($MUSL == "yes") {
        PEERDIR += contrib/libs/musl/full
    }

    when ($MSVC == "yes" || $CYGWIN == "yes") {
        MODULE_SUFFIX=.exe
    }

    PEERDIR(${GOSTD}/runtime library/go/core/buildinfo)

    when ($RACE == "yes") {
        PEERDIR += ${GOSTD}/runtime/cgo
        PEERDIR += ${GOSTD}/runtime/race
    }

    when ($MUSL == "yes") {
        GO_WITH_MUSL = ++musl
    }
}

# tag:go-specific
module _GO_DLL_BASE_UNIT: GO_PROGRAM {
    .CMD=GO_LINK_DLL
    .SYMLINK_POLICY=SO
    .ALLOWED=WHOLE_ARCHIVE
    .ARGS_PARSER=DLL
    SET(_GO_TOOL_MODE dll)
    SET(MODULE_TYPE DLL)

    GO_PACKAGE_NAME(main)

    when ($MSVC == "yes" || $CYGWIN == "yes") {
        MODULE_SUFFIX=.dll
    }
    elsewhen ($DARWIN == "yes" || $OS_IOS == "yes") {
        MODULE_PREFIX=lib
        MODULE_SUFFIX=.dylib$MODULE_VERSION
    }
    otherwise {
        MODULE_PREFIX=lib
        MODULE_SUFFIX=.so$MODULE_VERSION
    }

    when ($OS_DARWIN) {
        _GO_SONAME=-Wl,-install_name,$SONAME
    }
    elsewhen ($OS_LINUX) {
        _GO_SONAME=-Wl,-soname,$SONAME
    }

    when ($MODULE_VERSION) {
        when ($OS_LINUX || $OS_DARWIN) {
            _GO_LINK_EXE_EXT_CMD+= && $LINK_OR_COPY_CMD $TARGET ${output;nopath;noext:SONAME}
        }
    }
}

# tag:go-specific
### @usage: GO_DLL(name major_ver [minor_ver] [PREFIX prefix])
###
### Go ishared object module definition.
### Compile and link Go module to a shared object.
### Will select Go implementation on PEERDIR to PROTO_LIBRARY.
module GO_DLL: _GO_DLL_BASE_UNIT {
}

# tag:go-specific tag:test
### @usage: GO_BENCH_TIMEOUT(x)
###
### Sets timeout in seconds for 1 Benchmark in go benchmark suite
###
### Documentation about the system test: https://wiki.yandex-team.ru/yatool/test/
macro GO_BENCH_TIMEOUT(bench_timeout) {
    SET(GO_BENCH_TIMEOUT $bench_timeout)
}

# tag:go-specific tag:test
### @usage: GO_TEST([name])
###
### Go test module definition.
### Compile and link Go module as a test suitable for running with Arcadia testing support.
### All usual testing support macros like DATA, DEPENDS, SIZE, REQUIREMENTS etc. are supported.
### Will select Go implementation on PEERDIR to PROTO_LIBRARY.
module GO_TEST: GO_PROGRAM {
    .CMD=GO_LINK_TEST
    .ALIASES=GO_TEST_SRCS=GO_TEST_SRCS GO_XTEST_SRCS=GO_XTEST_SRCS GO_TEST_EMBED_PATTERN=GO_TEST_EMBED_PATTERN GO_XTEST_EMBED_PATTERN=GO_XTEST_EMBED_PATTERN GO_TEST_EMBED_DIR=GO_TEST_EMBED_DIR GO_XTEST_EMBED_DIR=GO_XTEST_EMBED_DIR
    .ALLOWED=GO_SKIP_TESTS YT_SPEC
    .FINAL_TARGET=no
    SET(_GO_TOOL_MODE test)
    SET(MODULE_TYPE PROGRAM)
    ENABLE(GO_TEST_MODULE)
    SET(GO_COVER_INFO_VALUE)

    # We have to add uncoditionaly PEERDIR to ${GOSTD}/os here thouth it is really
    # needed when TestMain is defined in the source code of the test
    PEERDIR(${GOSTD}/os)

    PEERDIR(${GOSTD}/testing/internal/testdeps)
    PEERDIR(${GOSTD}/testing)

    ADD_YTEST($MODULE_PREFIX$REALPRJNAME go.test)
    ADD_YTEST($MODULE_PREFIX$REALPRJNAME go.bench)

    SET_APPEND(_MAKEFILE_INCLUDE_LIKE_DEPS canondata/result.json)
}

# tag:go-specific
macro GO_MOCKGEN_FROM(Path) {
    SET(MOCKGEN_FROM ${Path})
}

# tag:go-specific
macro GO_MOCKGEN_TYPES(First, Rest...) {
     SET(MOCKGEN_FIRST $First)
     SET(MOCKGEN_REST $Rest)
}

# tag:go-specific
macro GO_MOCKGEN_REFLECT() {
    PEERDIR(${GOSTD}/encoding/gob)
    PEERDIR(${GOSTD}/flag)
    PEERDIR(${GOSTD}/fmt)
    PEERDIR(${GOSTD}/os)
    PEERDIR(${GOSTD}/path)
    PEERDIR(${GOSTD}/reflect)
    PEERDIR(vendor/github.com/golang/mock/mockgen/model)
    PEERDIR(${MOCKGEN_FROM})

    RUN_PROGRAM(vendor/github.com/golang/mock/mockgen -prog_only a.yandex-team.ru/${MOCKGEN_FROM} $MOCKGEN_FIRST${pre=$__COMMA__:MOCKGEN_REST} STDOUT main.go)
}

# tag:go-specific
macro GO_MOCKGEN_MOCKS() {
    PEERDIR(${GOSTD}/reflect)
    PEERDIR(vendor/github.com/golang/mock/gomock)

    RUN_PROGRAM(vendor/github.com/golang/mock/mockgen -package mocks -exec_only ${BINDIR}/gen/gen a.yandex-team.ru/${MOCKGEN_FROM} $MOCKGEN_FIRST${pre=$__COMMA__:MOCKGEN_REST} TOOL ${MODDIR}/gen STDOUT mocks.go)
}

# tag:java-specific
JAVA_IGNORE_CLASSPATH_CLASH_VALUE=
### @usage: JAVA_IGNORE_CLASSPATH_CLASH_FOR([classes])
### Ignore classpath clash test fails for classes
macro JAVA_IGNORE_CLASSPATH_CLASH_FOR(Args...) {
    SET_APPEND(JAVA_IGNORE_CLASSPATH_CLASH_VALUE $Args)
}

# tag:python-specific
### @usage: PY_SRCS({| CYTHON_C} { | TOP_LEVEL | NAMESPACE ns} Files...)
###
### Build specified Python sources according to Arcadia binary Python build. Basically creates precompiled and source resources keyed with module paths.
### The resources eventually are linked into final program and can be accessed as regular Python modules.
### This custom loader linked into the program will add them to sys.meta_path.
###
### PY_SRCS also support .proto, .ev, .pyx and .swg files. The .proto and .ev are compiled to .py-code by protoc and than handled as usual .py files.
### .pyx and .swg lead to C/C++ Python extensions generation, that are automatically registered in Python as built-in modules.
###
### By default .pyx files are built as C++-extensions. Use CYTHON_C to build them as C (similar to BUILDWITH_CYTHON_C, but with the ability to specify namespace).
###
### __init__.py never required, but if present (and specified in PY_SRCS), it will be imported when you import package modules with __init__.py Oh.
###
### @example
###
###     PY2_LIBRARY(mymodule)
###         PY_SRCS(a.py sub/dir/b.py e.proto sub/dir/f.proto c.pyx sub/dir/d.pyx g.swg sub/dir/h.swg)
###     END()
###
### PY_SRCS honors Python2 and Python3 differences and adjusts itself to Python version of a current module.
### PY_SRCS can be used in any Arcadia Python build modules like PY*_LIBRARY, PY*_PROGRAM, PY*TEST.
### PY_SRCS in LIBRARY or PROGRAM effectively converts these into PY2_LIBRARY and PY2_PROGRAM respectively.
### It is strongly advised to make this conversion explicit. Never use PY_SRCS in a LIBRARY if you plan to use it from external Python extension module.
###
### Documentation: https://wiki.yandex-team.ru/arcadia/python/pysrcs/#modulipylibrarypy3libraryimakrospysrcs
macro PY_SRCS() {
    DEFAULT(MODULE_TAG PY2)
    DEFAULT(PYTHON2 yes)
    DEFAULT(PYTHON3 no)
}

# tag:python-specific
_ALL_PY_FILES=

# tag:python-specific
macro _ALL_PY_SRCS2(TOP_LEVEL?"TOP_LEVEL":"", RECURSIVE?"/**":"", NAMESPACE[], REST[]) {
    _GLOB(_ALL_PY_FILES ${suf=${RECURSIVE}/*.py:REST} ${suf=${RECURSIVE}/ya.make:REST} EXCLUDE ya.make)
}

# tag:python-specific
### @usage: ALL_PY_SRCS([RECURSIVE] { | TOP_LEVEL | NAMESPACE ns} [Dirs...])
###
### Puts all .py-files from given Dirs (relative to projects') into PY_SRCS of the current module.
### If Dirs is ommitted project directory is used
###
### `RECURSIVE` makes lookup recursive with resprect to Dirs
### `TOP_LEVEL` and `NAMESPACE` are forwarded to `PY_SRCS`
###
### Note: Only one such macro per module is allowed
### Note: Macro is designed to reject any ya.make files in Dirs except current one
###
### @see [PY_SRCS()](#macro_PY_SRCS)
macro ALL_PY_SRCS(TOP_LEVEL?"TOP_LEVEL":"", NAMESPACE="", RECURSIVE?"RECURSIVE":"", Files...) {
    _ALL_PY_SRCS2(${pre=NAMESPACE :NAMESPACE} ${TOP_LEVEL} ${RECURSIVE} REST .${pre=/:Files})
    PY_SRCS(_MR ${pre=NAMESPACE :NAMESPACE} ${TOP_LEVEL} $_ALL_PY_FILES)
}

# tag:python-specific
### @usage: ALL_PYTEST_SRCS([RECURSIVE] [Dirs...])
###
### Puts all .py-files from given Dirs (relative to projects') into TEST_SRCS of the current module.
### If Dirs is omitted project directory is used
###
### `RECURSIVE` makes lookup recursive with respect to Dirs
###
### Note: Only one such macro per module is allowed
### Note: Macro is designed to reject any ya.make files in Dirs except current one
###
### @see [TEST_SRCS()](#macro_TEST_SRCS)
macro ALL_PYTEST_SRCS(TOP_LEVEL?"TOP_LEVEL":"", NAMESPACE="", RECURSIVE?"RECURSIVE":"", Files...) {
    _ALL_PY_SRCS2(${pre=NAMESPACE :NAMESPACE} ${TOP_LEVEL} ${RECURSIVE} REST .${pre=/:Files})
    TEST_SRCS(_MR $_ALL_PY_FILES)
}

# tag:python-specific
_PY_EXTRA_LINT_FILES_VALUE=
### @usage: PY_EXTRA_LINT_FILES(files...)
###
### Add extra Python files for linting. This macro allows adding
### Python files which has no .py extension.
macro PY_EXTRA_LINT_FILES(FILES...) {
    SET_APPEND(_PY_EXTRA_LINT_FILES_VALUE $FILES)
}

# tag:python-specific
### @usage: PY23_LIBRARY([name])
###
### Build PY2_LIBRARY or PY3_LIBRARY depending on incoming PEERDIR.
### Direct build or build by RECURSE creates both variants.
### This multimodule doesn't define any final targets, so use from DEPENDS or BUNDLE is not allowed.
###
### Documentation: https://wiki.yandex-team.ru/arcadia/python/pysrcs
multimodule PY23_LIBRARY {
    module PY2: PY2_LIBRARY {
        OBJ_SUF=.py2
        RUN_CYTHON_SCRIPT=$YMAKE_PYTHON $CYTHON_SCRIPT
        PYTHON_TYPE_FOR_CYTHON=PY2
    }
    module PY3: PY3_LIBRARY {
        RUN_CYTHON_SCRIPT=$YMAKE_PYTHON $CYTHON_SCRIPT
        PYTHON_TYPE_FOR_CYTHON=PY2
        when ($MSVC == "yes" || $CYGWIN == "yes") {
            MODULE_PREFIX=py3
        }
        otherwise {
             MODULE_PREFIX=libpy3
        }
        OBJ_SUF=.py3
    }
}

# tag:python-specific
### @usage: PY23_NATIVE_LIBRARY([name])
###
### Build LIBRARY compatible with either Python 2.x or Python 3.x depending on incoming PEERDIR.
###
### This multimodule doesn't depend on Arcadia Python binary build. It is intended only for C++ code and cannot contain PY_SRCS and USE_PYTHON2 macros.
### Use these multimodule instead of PY23_LIBRARY if the C++ extension defined in it will be used in PY2MODULE.
### While it doesn't bring Arcadia Python dependency itself, it is still compatible with Arcadia Python build and can be PEERDIR-ed from PY2_LIBRARY and alikes.
### Proper version will be selected according to Python version of the module PEERDIR comes from.
###
### This mulrtimodule doesn't define any final targets so cannot be used from DEPENDS or BUNDLE macros.
###
### For more information read https://wiki.yandex-team.ru/arcadia/python/pysrcs/#pysrcssrcsipy23nativelibrary
###
### @see [LIBRARY()](#module_LIBRARY), [PY2MODULE()](#module_PY2MODULE)
multimodule PY23_NATIVE_LIBRARY {
    module PY2: LIBRARY {
        .RESTRICTED=PY_SRCS USE_PYTHON2 USE_PYTHON3 PYTHON3_ADDINCL
        OBJ_SUF=.py2
        PYTHON2_ADDINCL()
        SET(MODULE_LANG PY2)
    }
    module PY3: LIBRARY {
        .RESTRICTED=PY_SRCS USE_PYTHON2 USE_PYTHON3
        .ALIASES=PYTHON2_ADDINCL=PYTHON3_ADDINCL
        PYTHON3_ADDINCL()
        SET(MODULE_LANG PY3)
        when ($MSVC == "yes" || $CYGWIN == "yes") {
            MODULE_PREFIX=py3c
        }
        otherwise {
            MODULE_PREFIX=libpy3c
        }
        OBJ_SUF=.py3
    }
}

IBTOOL_PATH=$XCODE_TOOLS_ROOT_RESOURCE_GLOBAL/Xcode/Contents/Developer/usr/bin/ibtool
# tag:src-processing
STORYBOARD_FLAGS=--errors --warnings --notices --auto-activate-custom-fonts --output-format human-readable-text
macro _SRC("storyboard", SRC, SRCFLAGS...) {
    .CMD=$IBTOOL_PATH $STORYBOARD_FLAGS --module $REALPRJNAME --output-partial-info-plist ${output;suf=.partial_plist:SRC} --compilation-directory $BINDIR ${input:SRC} && $YMAKE_PYTHON ${input:"build/scripts/tar_directory.py"}  ${output;tobindir;suf=.compiled_storyboard_tar:SRC} $BINDIR/${nopath;suf=c:SRC} $BINDIR/${nopath;suf=c:SRC}
}

# tag:src-processing
macro _SRC("xib", SRC, SRCFLAGS...) {
    .CMD=$IBTOOL_PATH $STORYBOARD_FLAGS --module $REALPRJNAME --output-partial-info-plist ${output;suf=.partial_plist:SRC} --compile ${output;tobindir;nopath;noext;suf=.nib:SRC} ${input:SRC}
}

ACTOOL_PATH=$XCODE_TOOLS_ROOT_RESOURCE_GLOBAL/Xcode/Contents/Developer/usr/bin/ibtool
# tag:ios-specific
ASSETS_FLAGS=--output-format human-readable-text --notices --warnings
macro _IOS_ASSETS(AssetsDir, Content...) {
    .CMD=$FS_TOOLS md $BINDIR/$REALPRJNAME && $ACTOOL_PATH $ASSETS_FLAGS --export-dependency-info $BINDIR/assetcatalog_dependencies --output-partial-info-plist ${output:"assetcatalog_generated_info.partial_plist"} --product-type com.apple.product-type.application --compile $BINDIR/$REALPRJNAME $AssetsDir ${input;hide:Content} && ${cwd:BINDIR} $YMAKE_PYTHON ${input:"build/scripts/tar_directory.py"} ${output;suf=_assetes.resource_tar:REALPRJNAME} $REALPRJNAME $REALPRJNAME
}

# tag:ios-specific
macro IOS_APP_COMMON_FLAGS(Flags...) {
    SET_APPEND(STORYBOARD_FLAGS $Flags)
    SET_APPEND(ASSETS_FLAGS $Flags)
}

# tag:ios-specific
macro IOS_APP_ASSETS_FLAGS(Flags...) {
    SET_APPEND(ASSETS_FLAGS $Flags)
}

macro DARWIN_STRINGS_RESOURCE(Resource, Relpath) {
    .CMD=$COPY_CMD ${input:Resource} $BINDIR/$Relpath && $YMAKE_PYTHON ${input:"build/scripts/tar_directory.py"} ${output;tobindir;suf=.strings_tar:Relpath} $BINDIR/$Relpath $BINDIR
}

macro DARWIN_SIGNED_RESOURCE(Resource, Relpath) {
    .CMD=$COPY_CMD $Resource $BINDIR/$Relpath && $YMAKE_PYTHON ${input:"build/scripts/tar_directory.py"} ${output;tobindir;suf=.signed_resource_tar:Relpath} $BINDIR/$Relpath $BINDIR
}

# tag:ios-specific
DELIM=__DELIM__
PACK_IOS_ARCHIVE=$GENERATE_MF && $YMAKE_PYTHON ${input:"build/scripts/ios_wrapper.py"} bin $IBTOOL_PATH $TARGET $REALPRJNAME $BINDIR $DELIM $AUTO_INPUT $DELIM $STORYBOARD_FLAGS
### @usage: IOS_INTERFACE()
### iOS GUI module definition
module IOS_INTERFACE: _BARE_UNIT {
    .CMD=PACK_IOS_ARCHIVE
    .EXTS=.compiled_storyboard_tar .partial_plist .plist .xcent .nib .resource_tar .signed_resource_tar .strings_tar .plist_json
    .NODE_TYPE=Library
    .FINAL_TARGET=no
    SET(MODULE_SUFFIX .ios.interface)

    PEERDIR+=build/platform/xcode/tools
}

# tag:ios-specific
module DEFAULT_IOS_INTERFACE: IOS_INTERFACE {
    SET(MODULE_SUFFIX .default.ios.interface)
}

DEFAULT_IOS_TYPE=
IOS_TYPE=
when(!$IOS_TYPE) {
    when($DEFAULT_IOS_TYPE) {
        IOS_TYPE=$DEFAULT_IOS_TYPE
    }
    otherwise {
        IOS_TYPE=com.apple.CoreSimulator.SimDeviceType.iPhone-X
    }
}
DEFAULT_IOS_RUNTIME=
IOS_RUNTIME=
when(!$IOS_RUNTIME) {
    when($DEFAULT_IOS_RUNTIME) {
        IOS_RUNTIME=$DEFAULT_IOS_RUNTIME
    }
    otherwise {
        IOS_RUNTIME=com.apple.CoreSimulator.SimRuntime.iOS-12-1
    }
}
when ($ARCH_I386) {
    TEST_IOS_DEVICE_TYPE_VALUE=com.apple.CoreSimulator.SimDeviceType.iPhone-5
    TEST_IOS_RUNTIME_TYPE_VALUE=com.apple.CoreSimulator.SimRuntime.iOS-10-3
}
otherwise {
    TEST_IOS_DEVICE_TYPE_VALUE=$IOS_TYPE
    TEST_IOS_RUNTIME_TYPE_VALUE=$IOS_RUNTIME
}

# tag:java-specific
### @usage: MODULE_JDK(Version)
###
### Specify JDK version for module
macro JDK_VERSION(Arg) {
    SET(JDK_REAL_VERSION $Arg)
    _JDK_VERSION_MACRO_CHECK($Arg)
}

# tag:java-specific
when ($JDK_REAL_VERSION == "10") {
    JDK10=yes # remove this later
}
JAVA_PROGRAM_CP_USE_COMMAND_FILE=yes
when ($JDK_REAL_VERSION == "8") {
    JAVA_PROGRAM_CP_USE_COMMAND_FILE=no
}

# tag:kotlin-specific
KOTLIN_JVM_TARGET=
when ($JDK_REAL_VERSION == "8") {
    KOTLIN_JVM_TARGET=1.8
}
elsewhen ($JDK_REAL_VERSION == "18") {
    # remove when kotlin starts supporting jdk18 bytecode
    # see also devtools/ya/jbuild/gen/actions/idea.py
    KOTLIN_JVM_TARGET=17
}
otherwise {
    KOTLIN_JVM_TARGET=$JDK_REAL_VERSION
}

# tag:frontend-specific
### @usage: COLLECT_FRONTEND_FILES(Varname, Dir)
###
### Recursively collect files with typical frontend extensions from Dir and save the result into variable Varname
macro COLLECT_FRONTEND_FILES(Varname, Dir) {
    _GLOB($Varname $Dir/**/*.(css|ejs|jpg|js|jsx|png|styl|svg|ts|tsx|json|html))
}

# tag:java-specific
# local jdk and tools
USE_SYSTEM_JDK=
USE_SYSTEM_UBERJAR=
USE_SYSTEM_ERROR_PRONE=

# tag:swift-specific
CPP_XCODE_TOOLCHAIN_VERSION=9.2
SWIFT_XCODE_TOOLCHAIN_VERSION=9.2
XCODE_TOOLS_VERSION=10.1
macro COMPILE_SWIFT_MODULE(SRCS{input}[], BRIDGE_HEADER{input}="", Flags...) {
    when ($BRIDGE_HEADER != "") {
        SWIFT_BRIDGE_HEADER=-import-objc-header ${input:BRIDGE_HEADER}
    }
    otherwise {
        SWIFT_BRIDGE_HEADER=
    }

    .PEERDIR+=build/platform/xcode/swift
    # swift core libraries
    LDFLAGS($SWIFT_LD_FLAGS)

    .CMD=$YMAKE_PYTHON ${input:"build/scripts/gen_swiftc_output_map.py"} $(SOURCE_ROOT) $(BUILD_ROOT) $BINDIR/swift_output_map.json ${input:SRCS} && $SWIFT_COMPILER -c $SWIFT_FLAGS_PLATFORM $Flags $SWIFT_BRIDGE_HEADER ${pre=-Xcc -I:_C__INCLUDE} ${input:SRCS} -emit-objc-header -emit-objc-header-path ${output;suf=-Swift.h:REALPRJNAME} -emit-module -module-name $REALPRJNAME -output-file-map $BINDIR/swift_output_map.json ${output;hide;suf=.o:SRCS}
}

TEST_TOOL_HOST_LOCAL=
TEST_TOOL_TARGET_LOCAL=

when ($TENSORFLOW_WITH_CUDA) {
    CUDA_REQUIRED=yes
}

when (!$TENSORRT_VERSION) {
    TENSORRT_VERSION=5
}

ANDROID_APK_TEST_ACTIVITY_VALUE=com.yandex.test.unittests/.RunTestsActivity

MAVEN_BIN=$MAVEN_RESOURCE_GLOBAL/bin

when ($QT_REQUIRED) {
    QT_BIN=${HOST_QT_RESOURCE_GLOBAL}/bin
}
when ($OPENGL_REQUIRED) {
    OPENGL_VERSION=18.0.5
}

# tag:python-specific
multimodule PY23_TEST {
    module PY2 : PYTEST_BIN {
        MODULE_PREFIX=py2_
        OBJ_SUF=.py2
        CANONIZE_SUB_PATH=py2test
        RUN_CYTHON_SCRIPT=$YMAKE_PYTHON $CYTHON_SCRIPT
        PYTHON_TYPE_FOR_CYTHON=PY2
    }
    module PY3TEST_PROGRAM: PY3TEST_BIN {
        .FINAL_TARGET=yes
        OBJ_SUF=.py3
        CANONIZE_SUB_PATH=py3test
        RUN_CYTHON_SCRIPT=$YMAKE_PYTHON $CYTHON_SCRIPT
        PYTHON_TYPE_FOR_CYTHON=PY2
    }

    module PY3TEST_LIBRARY: PY3_LIBRARY {
        PEERDIR+=library/python/pytest
        _REQUIRE_EXPLICIT_LICENSE()
        RUN_CYTHON_SCRIPT=$YMAKE_PYTHON $CYTHON_SCRIPT
        PYTHON_TYPE_FOR_CYTHON=PY2
    }
}

# tag:windows-specific
WINDOWS_MANIFEST=
macro WINDOWS_MANIFEST(Manifest) {
    SET(WINDOWS_MANIFEST $Manifest)
}

# tag:windows-specific
when ($MSVC == "yes" && $WINDOWS_MANIFEST) {
    LDFLAGS+=/MANIFEST:EMBED /MANIFESTINPUT:${input:WINDOWS_MANIFEST}
}

# tag:cpp-specific
_VISIBILITY_LEVEL=
### @usage: VISIBILITY(level)
###
### This macro sets visibility level for symbols compiled for the current module. 'level'
### may take only one of the following values: DEFAULT, HIDDEN.
macro VISIBILITY(LEVEL) {
    SET(_VISIBILITY_LEVEL ${LEVEL})
    select ($LEVEL) {
        "DEFAULT" | "HIDDEN" ? {
        }
        default ? {
            _OK = no
        }
    }
    ASSERT(_OK Unsupported value [$LEVEL] passed to VISIBILITY macro, expected values are DEFAULT, HIDDEN.)
}

# tag:cpp-specific
_CFLAGS_VISIBILITY=
when ($_VISIBILITY_LEVEL != "" && $IGNORE_VISIBILITY != "yes") {
    when ($CLANG == "yes" || $GCC == "yes") {
        _CFLAGS_VISIBILITY=-fvisibility=${tolower:_VISIBILITY_LEVEL}
    }
}
CFLAGS+=$_CFLAGS_VISIBILITY

# tag:cpp-specific
macro SDBUS_CPP_ADAPTOR(File) {
    .CMD=${tool:"contrib/libs/sdbus-cpp/tools/xml2cpp-codegen"} --adaptor=${output;nopath;noext:File.adaptor.h} ${input:File}
    .PEERDIR=contrib/libs/sdbus-cpp
}

# tag:cpp-specific
macro SDBUS_CPP_PROXY(File) {
    .CMD=${tool:"contrib/libs/sdbus-cpp/tools/xml2cpp-codegen"} --proxy=${output;nopath;noext:File.proxy.h} ${input:File}
    .PEERDIR=contrib/libs/sdbus-cpp
}


# tag:python-specific
macro _PY_SSQLS_SRC(EXT, SRC, SRCFLAGS...) {
    #generic macro
}

# tag:python-specific
macro _PY_SSQLS_SRC("ssqls", SRC, SRCFLAGS...) {
    .CMD=${tool:"metrika/core/tools/ssqls"} ${input;notransformbuilddir:SRC} -S $ARCADIA_ROOT -B $ARCADIA_BUILD_ROOT -L "python" -D $MODDIR $SRCFLAGS ${output;tobindir;noext;hide;pre=autogenerated/$MODDIR/:SRC.py}
}

# tag:python-specific
macro _PY_SSQLS_SRCS(Srcs...) {
    foreach(Src: $Srcs) {
        _PY_SSQLS_SRC(${lastext:Src} $Src)
    }
}

# tag:python-specific
macro PY_SSQLS_SRCS(Srcs...) {
    _PY_SSQLS_SRCS(KEEP_DIR_STRUCT $Srcs)
    PY_SRCS(${noext;pre=autogenerated/$MODDIR/:Srcs.py})
}

# tag:python-specific
macro _PY_ENUM_SERIALIZATION_TO_JSON(File) {
    .CMD=$ENUM_PARSER_TOOL ${input:File} --output ${output;chksum;noext;suf=.generated.h:File} --json-output ${output;noext:File.json} ${kv;hide:"p EN"} ${kv;hide:"pc yellow"}
}

# tag:python-specific
macro _PY_ENUM_SERIALIZATION_TO_PY(File) {
    .CMD=${tool:"metrika/core/tools/python_enum_generator"} ${input;noext:File.json} -D ${MODDIR} --output ${output;noext:File.py} ${kv;hide:"p EN"} ${kv;hide:"pc yellow"}
}

# tag:metrika
multimodule SSQLS_LIBRARY {
    module CPP_SSQLS : LIBRARY {
        .ALIASES=ENUMS_SERIALIZATION=CPP_ENUMS_SERIALIZATION
        SET(PEERDIR_TAGS CPP_SSQLS)
        PEERDIR(metrika/core/libs/appmetrica/types metrika/core/libs/types)
        ADDINCL(GLOBAL ${ARCADIA_BUILD_ROOT}/metrika/core/common_tables/include)
    }
    module PY3_SSQLS : PY3_LIBRARY {
        .ALIASES=SRCS=PY_SSQLS_SRCS ENUMS_SERIALIZATION=PY_ENUMS_SERIALIZATION
        SET(PEERDIR_TAGS PY3 PY3_SSQLS)
    }
}

macro NGINX_MODULES(Modules...) {
    PEERDIR(${Modules})
    RUN_PROGRAM(nginx/module_gen ${Modules} CWD ${ARCADIA_ROOT} IN ${suf=/modules.json:Modules} OUTPUT_INCLUDES contrib/nginx/core/src/core/ngx_config.h contrib/nginx/core/src/core/ngx_core.h STDOUT ngx_modules.c)
}

# Experimental: container as output. https://st.yandex-team.ru/DTCC-179

# tag:external-build
CONTAINER_LAYER_CMD=$YMAKE_PYTHON ${input:"devtools/experimental/solar/selfcontainer/scripts/make_container_layer.py"} -o $TARGET $AUTO_INPUT ${cwd:ARCADIA_BUILD_ROOT} ${kv;hide:"p CL"} ${kv;hide:"pc blue"}
CONTAINER_CMD=$YMAKE_PYTHON ${input:"devtools/experimental/solar/selfcontainer/scripts/make_container.py"} -o $TARGET ${rootrel:PEERS} ${cwd:ARCADIA_BUILD_ROOT} ${kv;hide:"p CN"} ${kv;hide:"pc blue"}

# tag:external-build
module CONTAINER_LAYER: _BARE_UNIT {
    .CMD=CONTAINER_LAYER_CMD

    MODULE_SUFFIX=.container_layer
}

# tag:external-build
module CONTAINER: _BARE_UNIT {
    .NODE_TYPE=Bundle
    .PEERDIR_POLICY=as_build_from
    .FINAL_TARGET=yes
    .CMD=CONTAINER_CMD
}

# tag:external-build
CUSTOM_BUILD_LIBRARY_USE=
CUSTOM_BUILD_LIBRARY_CMD=$GENERATE_MF && ${tool:"devtools/experimental/solar/outbuild/runner"} ${hide:PEERS} --script=${input:CUSTOM_SCRIPT} --output $TARGET --python=${tool:"contrib/tools/python3"} --isolator=${tool:"devtools/experimental/solar/outbuild/isolator"} $CUSTOM_BUILD_LIBRARY_USE

# tag:external-build
module CUSTOM_BUILD_LIBRARY: LIBRARY {
    .NODE_TYPE=Bundle
    .PEERDIR_POLICY=as_build_from
    .PROXY=yes
    .CMD=CUSTOM_BUILD_LIBRARY_CMD
    DISABLE(NEED_ADD_FAKE_SRC)
}

### @usage: ORIGINAL_SOURCE(Source)
###
### This macro specifies the source repository for contrib
### Does nothing now (just a placeholder for future functionality)
### See https://st.yandex-team.ru/DTCC-316
macro ORIGINAL_SOURCE(Source) {
    ENABLE(UNUSED_MACRO)
}

# tag:licence
CREDITS_FILE_EXTRA_EXT=
CREDITS_FLAGS=
CREDITS_TEXTS_FILE=
NO_CREDITS_TEXTS_FILE=
WITH_CREDITS=
### @usage: LICENSE_TEXTS(File)
###
### This macro specifies the filename with all library licenses texts
macro LICENSE_TEXTS(Source) {
    SET(CREDITS_TEXTS_FILE $Source)
}

# tag:licence
### @usage: WITHOUT_LICENSE_TEXTS()
###
### This macro indicates that the module has no license text
macro WITHOUT_LICENSE_TEXTS() {
    ENABLE(NO_CREDITS_TEXTS_FILE)
}

# tag:licence
when ($WITH_CREDITS) {
    CREDITS_FLAGS+=--credits-output ${output;suf=${CREDITS_FILE_EXTRA_EXT}".CREDITS.txt":REALPRJNAME}
}

GENERATE_MF=
when ($WITH_CREDITS) {
    GENERATE_MF=$GENERATE_MF_CMD
}

macro _MCU_CONVERT(Bin) {
    .CMD=${cwd:BINDIR} $OBJCOPY_TOOL -O ihex $Bin ${output;noext:Bin.hex} && ${cwd:BINDIR} $OBJCOPY_TOOL -O srec $Bin ${output;noext:Bin.s37} && ${cwd:BINDIR} $OBJCOPY_TOOL -O binary $Bin ${output;noext:Bin.bin}
}

MCU_LINK_EXE=$LINK_EXE && $_MCU_CONVERT($MODULE_PREFIX$REALPRJNAME)

### @usage: MCU_PROGRAM([progname])
###
### Program module for microcontrollers. Converts ELF to Intel HEX, Motorola S-record and raw binary file formats.
### If name is not specified it will be generated from the name of the containing project directory.
module MCU_PROGRAM: PROGRAM {
    .CMD=MCU_LINK_EXE
}

# tag:deprecated
### @usage: METAQUERYFILES(filenames...) #deprecated
###
### This macro does nothing and will be removed
macro METAQUERYFILES(Files...) {
    ENABLE(UNUSED_MACRO)
}

# tag:flags tag:internal tag:windows-specific
### @usage: _MSVC_FLAGS_WINDOWS_IMPL(target_platform compiler_flags) # internal
###
### Add CFLAGS when the firts argument is WINDOWS
macro _MSVC_FLAGS_WINDOWS_IMPL(WINDOWS[], FLAGS...) {
    CFLAGS($WINDOWS)
}

# tag:flags tag:windows-specific tag:cpp-specific
### @usage: MSVC_FLAGS([GLOBAL compiler_flag]* compiler_flags)
###
### Add the specified flags to the compilation line of C/C++files.
### Flags apply only if the compiler used is MSVC (cl.exe)
macro MSVC_FLAGS(FLAGS...) {
    _MSVC_FLAGS_WINDOWS_IMPL($TARGET_PLATFORM $FLAGS)
}

### @usage: COLLECT_YDB_API_SPECS_LEGACY(VarName Paths...)  #deprecated
###
### This macro is ugly hack for legacy YDB go API codegen, any other uses are prohibited
macro COLLECT_YDB_API_SPECS_LEGACY(FILES_VAR, PATHS...) {
    _GLOB($FILES_VAR ${suf=/*.proto:PATHS})
    RESTRICT_PATH(kikimr/public/sdk/go/ydb/api MSG This is ugly hack for legacy YDB go API codegen, any other uses are probibited)
}

# tag:proto tag:apphost
### @usage: APPHOST()
###
### Emit APPHOST service code for all .proto files in a PROTO_LIBRARY.
### This works only for C++ and Java at the moment.
macro APPHOST() {
    # C++
    CPP_PROTO_PLUGIN(cpp_plugin apphost/tools/stub_generator/cpp_plugin .apphost.h)

    # Java
    JAVA_PROTO_PLUGIN(java_plugin apphost/tools/stub_generator/java_plugin DEPS apphost/api/service/java/apphost)
}