Revert ymake build from ydb oss export

1 files changed, 0 insertions, 164 deletions

diff --git a/contrib/tools/cython/Cython/Compiler/CythonScope.py b/contrib/tools/cython/Cython/Compiler/CythonScope.py
deleted file mode 100644
index 1c25d1a6b4c..00000000000
--- a/contrib/tools/cython/Cython/Compiler/CythonScope.py
+++ /dev/null
@@ -1,164 +0,0 @@
-from __future__ import absolute_import
-
-from .Symtab import ModuleScope
-from .PyrexTypes import *
-from .UtilityCode import CythonUtilityCode
-from .Errors import error
-from .Scanning import StringSourceDescriptor
-from . import MemoryView
-
-
-class CythonScope(ModuleScope):
-    is_cython_builtin = 1
-    _cythonscope_initialized = False
-
-    def __init__(self, context):
-        ModuleScope.__init__(self, u'cython', None, None)
-        self.pxd_file_loaded = True
-        self.populate_cython_scope()
-        # The Main.Context object
-        self.context = context
-
-        for fused_type in (cy_integral_type, cy_floating_type, cy_numeric_type):
-            entry = self.declare_typedef(fused_type.name,
-                                         fused_type,
-                                         None,
-                                         cname='<error>')
-            entry.in_cinclude = True
-
-    def is_cpp(self):
-        # Allow C++ utility code in C++ contexts.
-        return self.context.cpp
-
-    def lookup_type(self, name):
-        # This function should go away when types are all first-level objects.
-        type = parse_basic_type(name)
-        if type:
-            return type
-
-        return super(CythonScope, self).lookup_type(name)
-
-    def lookup(self, name):
-        entry = super(CythonScope, self).lookup(name)
-
-        if entry is None and not self._cythonscope_initialized:
-            self.load_cythonscope()
-            entry = super(CythonScope, self).lookup(name)
-
-        return entry
-
-    def find_module(self, module_name, pos):
-        error("cython.%s is not available" % module_name, pos)
-
-    def find_submodule(self, module_name):
-        entry = self.entries.get(module_name, None)
-        if not entry:
-            self.load_cythonscope()
-            entry = self.entries.get(module_name, None)
-
-        if entry and entry.as_module:
-            return entry.as_module
-        else:
-            # TODO: fix find_submodule control flow so that we're not
-            # expected to create a submodule here (to protect CythonScope's
-            # possible immutability). Hack ourselves out of the situation
-            # for now.
-            raise error((StringSourceDescriptor(u"cython", u""), 0, 0),
-                  "cython.%s is not available" % module_name)
-
-    def lookup_qualified_name(self, qname):
-        # ExprNode.as_cython_attribute generates qnames and we untangle it here...
-        name_path = qname.split(u'.')
-        scope = self
-        while len(name_path) > 1:
-            scope = scope.lookup_here(name_path[0])
-            if scope:
-                scope = scope.as_module
-            del name_path[0]
-            if scope is None:
-                return None
-        else:
-            return scope.lookup_here(name_path[0])
-
-    def populate_cython_scope(self):
-        # These are used to optimize isinstance in FinalOptimizePhase
-        type_object = self.declare_typedef(
-            'PyTypeObject',
-            base_type = c_void_type,
-            pos = None,
-            cname = 'PyTypeObject')
-        type_object.is_void = True
-        type_object_type = type_object.type
-
-        self.declare_cfunction(
-            'PyObject_TypeCheck',
-            CFuncType(c_bint_type, [CFuncTypeArg("o", py_object_type, None),
-                                    CFuncTypeArg("t", c_ptr_type(type_object_type), None)]),
-            pos = None,
-            defining = 1,
-            cname = 'PyObject_TypeCheck')
-
-    def load_cythonscope(self):
-        """
-        Creates some entries for testing purposes and entries for
-        cython.array() and for cython.view.*.
-        """
-        if self._cythonscope_initialized:
-            return
-
-        self._cythonscope_initialized = True
-        cython_testscope_utility_code.declare_in_scope(
-                                self, cython_scope=self)
-        cython_test_extclass_utility_code.declare_in_scope(
-                                    self, cython_scope=self)
-
-        #
-        # The view sub-scope
-        #
-        self.viewscope = viewscope = ModuleScope(u'view', self, None)
-        self.declare_module('view', viewscope, None).as_module = viewscope
-        viewscope.is_cython_builtin = True
-        viewscope.pxd_file_loaded = True
-
-        cythonview_testscope_utility_code.declare_in_scope(
-                                            viewscope, cython_scope=self)
-
-        view_utility_scope = MemoryView.view_utility_code.declare_in_scope(
-                                            self.viewscope, cython_scope=self,
-                                            whitelist=MemoryView.view_utility_whitelist)
-
-        # self.entries["array"] = view_utility_scope.entries.pop("array")
-
-
-def create_cython_scope(context):
-    # One could in fact probably make it a singleton,
-    # but not sure yet whether any code mutates it (which would kill reusing
-    # it across different contexts)
-    return CythonScope(context)
-
-# Load test utilities for the cython scope
-
-def load_testscope_utility(cy_util_name, **kwargs):
-    return CythonUtilityCode.load(cy_util_name, "TestCythonScope.pyx", **kwargs)
-
-
-undecorated_methods_protos = UtilityCode(proto=u"""
-    /* These methods are undecorated and have therefore no prototype */
-    static PyObject *__pyx_TestClass_cdef_method(
-            struct __pyx_TestClass_obj *self, int value);
-    static PyObject *__pyx_TestClass_cpdef_method(
-            struct __pyx_TestClass_obj *self, int value, int skip_dispatch);
-    static PyObject *__pyx_TestClass_def_method(
-            PyObject *self, PyObject *value);
-""")
-
-cython_testscope_utility_code = load_testscope_utility("TestScope")
-
-test_cython_utility_dep = load_testscope_utility("TestDep")
-
-cython_test_extclass_utility_code = \
-    load_testscope_utility("TestClass", name="TestClass",
-                           requires=[undecorated_methods_protos,
-                                     test_cython_utility_dep])
-
-cythonview_testscope_utility_code = load_testscope_utility("View.TestScope")