return s[:p]

def resolve_to_ymake_path(path):

def join_intl_paths(*args):

return '/'.join(args)

def resolve_includes(unit, src, paths):

return unit.resolve_include([src] + paths) if paths else []

import os

resolved_args.append(self.resolve_path(arg))

env = os.environ.copy()

env['ASAN_OPTIONS'] = 'detect_leaks=0'

rc = subprocess.call(resolved_args, cwd=cwd, stdout=stdout, env=env)

def resolve_path(self, path):

return common.resolve_to_abs_path(path, self._source_root, self._build_root)

def addparser(*unused, **kwargs):

from ymake import CustomCommand as RealCustomCommand

from ymake import subst

class CustomCommand(RealCustomCommand):

def __init__(self, *args, **kwargs):

RealCustomCommand.__init__(*args, **kwargs)

def resolve_path(self, path):

return subst(path)

from _custom_command import CustomCommand # noqa

from _custom_command import addrule # noqa

from _custom_command import addparser # noqa

sys.dont_write_bytecode = True

try:

import cPickle as pickle

except Exception:

import pickle

import _common as common

args, unknown_args = parser.parse_known_args()

cmd_object = pickle.loads(base64.b64decode(encoded_cmd))

cmd_object.run(unknown_args, common.get_interpreter_path())

cmd_object.run(unknown_args, *tools[1:])

"""

.. function: get_include_callback returns function that processes each DOM element to get xsyn include from it, and it's aware of directory with all the xsyns.

return res

ranking_suffix = ''

check = ''

index = 0

while index < len(args):

if args[index] == 'NAME':

index += 1

ranking_suffix = args[index]

elif args[index] == 'CHECK':

check = 'CHECK'

else:

files.append(args[index])

index += 1

keywords = {'RESULT': 1, 'KEEP_DIR_STRUCT': 0, 'DESTINATION': 1, 'FROM': 1}

from_dir = spec_args['FROM'][0] if 'FROM' in spec_args else ''

source_path = os.path.join(from_dir, rel_path, filename)

target_path = os.path.join(dest_dir, rel_path, filename)

targets.append(target_path)

unit.oncopy_file([source_path, target_path])

def oncreate_init_py_structure(unit, *args):

target_dir = unit.get('PY_PROTOS_FOR_DIR')

path_list = target_dir.split(os.path.sep)[1:]

inits = [os.path.join("${ARCADIA_BUILD_ROOT}", '__init__.py')]

for i in range(1, len(path_list) + 1):

inits.append(os.path.join("${ARCADIA_BUILD_ROOT}", os.path.join(*path_list[0:i]), '__init__.py'))

unit.ontouch(inits)

if len(args) >= 2 and filepath is not None:

return 'RD', self._path, 'light-green'

def input(self):

def main_out(self):

return common.tobuilddir(common.stripext(self._path)) + '.cpp'

def output(self):

def run(self, extra_args, binary):

with open(self.resolve_path(self.main_out()), 'w') as f:

return ROData(path, unit)

# This hard-coded many times in CppParts in various codegens

_DEFAULT_CPP_PARTS = 20

# See TCodegenParams::MethodStream usage in factor codegen

_ADDITIONAL_STREAM_COUNT = 5

'''

@usage: SPLIT_CODEGEN(tool prefix opts... [OUT_NUM num] [OUTPUT_INCLUDES output_includes...])

1. OUT_NUM <the number of generated Prefix.N.cpp default 25 (N varies from 0 to 24)>

2. OUTPUT_INCLUDES <path to files that will be included in generalnyj of macro files>

'''

num_outputs = _DEFAULT_CPP_PARTS + _ADDITIONAL_STREAM_COUNT

if "OUT_NUM" in spec_args:

num_outputs = int(spec_args["OUT_NUM"][0])

cpp_parts = int(num_outputs) - _ADDITIONAL_STREAM_COUNT

cpp_parts_args = ['--cpp-parts', str(cpp_parts)]

cmd += cpp_parts_args + flat_args[2:]

else:

cmd += ['OPTS'] + cpp_parts_args

unit.on_split_codegen_base(cmd)

import posixpath

import re

def init():

iw.addrule('swg', Swig)

self._tool = unit.get('SWIG_TOOL')

self._library_dir = unit.get('SWIG_LIBRARY') or 'contrib/tools/swig/Lib'

self._local_swig = unit.get('USE_LOCAL_SWIG') == "yes"

self._flags = ['-cpperraswarn']

self._swig_lang = unit.get('SWIG_LANG')

if self._swig_lang != 'jni_java':

self._main_out = os.path.join(

self._bindir,

]

self._incl_dirs = ['$S', '$B'] + [posixpath.join('$S', d) for d in incl_dirs]

if not self._local_swig:

unit.onaddincl(incl_dirs)

if self._swig_lang == 'python':

if self._swig_lang == 'perl':

unit.onpeerdir(['build/platform/perl'])

if self._swig_lang in ['jni_cpp', 'java']:

self._out_header = os.path.splitext(self._main_out)[0] + '.h'

if (not unit.get('USE_SYSTEM_JDK')) and (unit.get('OS_ANDROID') != "yes"):

unit.onpeerdir(['contrib/libs/jdk'])

self._package = 'ru.yandex.' + os.path.dirname(self._path).replace('$S/', '').replace('$B/', '').replace('/', '.').replace('-', '_')

if self._swig_lang in ['jni_java', 'java']:

self._out_name = os.path.splitext(os.path.basename(self._path))[0] + '.jsrc'

elif self._swig_lang != 'jni_cpp':

self._flags.append('-' + self._swig_lang)

return ['contrib/tools/swig'] if not self._tool else []

if self._swig_lang == 'jni_java':

return [(common.join_intl_paths(self._bindir, self._out_name), [])]

elif self._swig_lang == 'jni_cpp':

return [(self._main_out, []), (self._out_header, [])]

(common.join_intl_paths(self._bindir, self._out_name), (['noauto', 'add_to_outs'] if self._swig_lang != 'java' else [])),

] + ([(self._out_header, [])] if self._swig_lang == 'java' else [])

def output_includes(self):

return [(self._out_header, [])] if self._swig_lang in ['java', 'jni_cpp'] else []

if self._local_swig:

binary = self._tool

return self.do_run_java(binary, self._path) if self._swig_lang in ['java', 'jni_cpp', 'jni_java'] else self.do_run(binary, self._path)

def _incl_flags(self):

return ['-I' + self.resolve_path(x) for x in self._incl_dirs]

self.call([binary] + self._flags + [

'-o', self.resolve_path(common.get(self.output, 0)),

'-outdir', self.resolve_path(self._bindir)

] + self._incl_flags() + [self.resolve_path(path)])

def do_run_java(self, binary, path):

import tarfile

outdir = self.resolve_path(self._bindir)

if self._swig_lang != 'jni_cpp':

java_srcs_dir = os.path.join(outdir, self._package.replace('.', '/'))

'$S/library/cpp/xml/parslib/xsyn2ragel.py',

'$S/library/cpp/xml/parslib/xmlpars.xh'

def run(self, extra_args, interpeter):

OWNER(g:ymake)

PY2_LIBRARY()

PY_SRCS(

code_generator.py

ssqls.py

PEERDIR(build/plugins/lib)

RECURSE(

tests

import lib._metric_resolvers as mr

import _test_const as consts

import _requirements as reqs

import subprocess

import collections

import ymake

MDS_URI_PREFIX = 'https://storage.yandex-team.ru/get-devtools/'

MDS_SHEME = 'mds'

VALID_NETWORK_REQUIREMENTS = ("full", "restricted")

VALID_DNS_REQUIREMENTS = ("default", "local", "dns64")

SPLIT_FACTOR_MAX_VALUE = 1000

SPLIT_FACTOR_TEST_FILES_MAX_VALUE = 4250

PARTITION_MODS = ('SEQUENTIAL', 'MODULO')

DEFAULT_TIDY_CONFIG = "build/config/tests/clang_tidy/config.yaml"

DEFAULT_TIDY_CONFIG_MAP_PATH = "build/yandex_specific/config/clang_tidy/tidy_default_map.json"

PROJECT_TIDY_CONFIG_MAP_PATH = "build/yandex_specific/config/clang_tidy/tidy_project_map.json"

tidy_config_map = None

ymake.report_configure_error("TEST_DATA is removed in favour of DATA")

def prepare_recipes(data):

data = data.replace('"USE_RECIPE_DELIM"', "\n")

data = data.replace("$TEST_RECIPES_VALUE", "")

ymake.report_configure_error(e)

if valid_kw is None:

return None

for k, v in valid_kw.iteritems():

print >>string_handler, BLOCK_SEPARATOR

def serialize_list(lst):

lst = filter(None, lst)

return '\"' + ';'.join(lst) + '\"' if lst else ''

def onadd_ytest(unit, *args):

flat_args, spec_args = _common.sort_by_keywords(keywords, args)

test_data = sorted(_common.filter_out_by_keyword(spec_args.get('DATA', []) + get_norm_paths(unit, 'TEST_DATA_VALUE'), 'AUTOUPDATED'))

unit.set(["DEFAULT_TIDY_CONFIG", default_config_path])

unit.set(["PROJECT_TIDY_CONFIG", project_config_path])

unit_path = get_norm_unit_path(unit)

test_record = {

'TEST_PARTITION': unit.get("TEST_PARTITION") or 'SEQUENTIAL',

'GO_BENCH_TIMEOUT': unit.get('GO_BENCH_TIMEOUT') or '',

}

if flat_args[1] == "go.bench":

if "ya:run_go_benchmark" not in test_record["TAG"]:

return

if data:

unit.set_property(["DART_DATA", data])

save_in_file(unit.get('TEST_DART_OUT_FILE'), data)

def java_srcdirs_to_data(unit, var):

extra_data = []

for srcdir in (unit.get(var) or '').replace('$' + var, '').split():

data_lst.sort()

related_dirs_list = ['{ARCADIA_ROOT}/devtools/${YA_ROOT}', '${ARCADIA_ROOT}/devtools/${YA_ROOT}', '$RELATED_TARGET_SRCDIR']