Nuitka-winsvc 1.8__cp311-cp311-win_amd64.whl → 2.5.1__cp311-cp311-win_amd64.whl

nuitka/build/static_src/HelpersBuiltin.c

@@ -1,20 +1,5 @@
-//     Copyright 2023, Kay Hayen, mailto:kay.hayen@gmail.com
-//
-//     Part of "Nuitka", an optimizing Python compiler that is compatible and
-//     integrates with CPython, but also works on its own.
-//
-//     Licensed under the Apache License, Version 2.0 (the "License");
-//     you may not use this file except in compliance with the License.
-//     You may obtain a copy of the License at
-//
-//        http://www.apache.org/licenses/LICENSE-2.0
-//
-//     Unless required by applicable law or agreed to in writing, software
-//     distributed under the License is distributed on an "AS IS" BASIS,
-//     WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-//     See the License for the specific language governing permissions and
-//     limitations under the License.
-//
+//     Copyright 2024, Kay Hayen, mailto:kay.hayen@gmail.com find license text at end of file
+
 /** For calling built-ins, calls it and uses keyword dictionary if necessary.
  *
  * This helper simplifies calling built-ins with optional arguments that can
@@ -31,12 +16,13 @@
 #endif
 
 PyObject *CALL_BUILTIN_KW_ARGS(PyThreadState *tstate, PyObject *callable, PyObject **args, char const **arg_names,
-                               int max_args) {
+                               int max_args, int kw_only_args) {
     int i = 0;
 
-    while (i < max_args) {
-        if (args[i] == NULL)
+    while (i < max_args - kw_only_args) {
+        if (args[i] == NULL) {
             break;
+        }
 
         CHECK_OBJECT(args[i]);
 
@@ -52,17 +38,17 @@ PyObject *CALL_BUILTIN_KW_ARGS(PyThreadState *tstate, PyObject *callable, PyObje
             CHECK_OBJECT(args[i]);
 
             if (kw_dict == NULL) {
-                kw_dict = MAKE_DICT_EMPTY();
+                kw_dict = MAKE_DICT_EMPTY(tstate);
             }
 
-            int res = PyDict_SetItemString(kw_dict, arg_names[i], args[i]);
+            NUITKA_MAY_BE_UNUSED int res = PyDict_SetItemString(kw_dict, arg_names[i], args[i]);
             assert(res == 0);
         }
 
         i++;
     }
 
-    PyObject *args_tuple = MAKE_TUPLE(args, usable_args);
+    PyObject *args_tuple = MAKE_TUPLE(tstate, args, usable_args);
 
     PyObject *result = CALL_FUNCTION(tstate, callable, args_tuple, kw_dict);
     Py_XDECREF(kw_dict);
@@ -92,7 +78,7 @@ PyObject *COMPILE_CODE(PyThreadState *tstate, PyObject *source_code, PyObject *f
         return source_code;
     }
 
-    PyObject *pos_args = MAKE_TUPLE3(source_code, file_name, mode);
+    PyObject *pos_args = MAKE_TUPLE3(tstate, source_code, file_name, mode);
 
     PyObject *kw_values[] = {
         flags,
@@ -179,10 +165,19 @@ PyObject *EVAL_CODE(PyThreadState *tstate, PyObject *code, PyObject *globals, Py
         return NULL;
     }
 
-    // Set the __builtins__ in globals, it is expected to be present.
-    if (PyDict_Check(globals) && DICT_HAS_ITEM(tstate, globals, const_str_plain___builtins__) == 0) {
-        if (PyDict_SetItem(globals, const_str_plain___builtins__, (PyObject *)builtin_module) != 0) {
-            return NULL;
+    // Set the "__builtins__" value in globals, it is expected to be present.
+    assert(builtin_module != NULL);
+
+    if (PyDict_Check(globals)) {
+        const int res = DICT_HAS_ITEM(tstate, globals, const_str_plain___builtins__);
+
+        if (res == 0) {
+            if (PyDict_SetItem(globals, const_str_plain___builtins__, (PyObject *)builtin_module) != 0) {
+                // Not really allowed to happen, so far this was seen only with
+                // C compilers getting the value of "res" wrong.
+                assert(false);
+                return NULL;
+            }
         }
     }
 
@@ -230,7 +225,7 @@ PyObject *BUILTIN_OPEN(PyThreadState *tstate, PyObject *file_name, PyObject *mod
 
     char const *arg_names[] = {"name", "mode", "buffering"};
 
-    return CALL_BUILTIN_KW_ARGS(tstate, NUITKA_ACCESS_BUILTIN(open), args, arg_names, 3);
+    return CALL_BUILTIN_KW_ARGS(tstate, NUITKA_ACCESS_BUILTIN(open), args, arg_names, 3, 0);
 }
 #else
 PyObject *BUILTIN_OPEN(PyThreadState *tstate, PyObject *file_name, PyObject *mode, PyObject *buffering,
@@ -247,7 +242,7 @@ PyObject *BUILTIN_OPEN(PyThreadState *tstate, PyObject *file_name, PyObject *mod
 
     char const *arg_names[] = {"file", "mode", "buffering", "encoding", "errors", "newline", "closefd", "opener"};
 
-    return CALL_BUILTIN_KW_ARGS(tstate, NUITKA_ACCESS_BUILTIN(open), args, arg_names, 8);
+    return CALL_BUILTIN_KW_ARGS(tstate, NUITKA_ACCESS_BUILTIN(open), args, arg_names, 8, 0);
 }
 
 #endif
@@ -320,7 +315,7 @@ PyObject *BUILTIN_BYTES3(PyThreadState *tstate, PyObject *value, PyObject *encod
 
     char const *arg_names[] = {"value", "encoding", "errors"};
 
-    return CALL_BUILTIN_KW_ARGS(tstate, NUITKA_ACCESS_BUILTIN(bytes), args, arg_names, 3);
+    return CALL_BUILTIN_KW_ARGS(tstate, NUITKA_ACCESS_BUILTIN(bytes), args, arg_names, 3, 0);
 }
 #endif
 
@@ -427,6 +422,7 @@ PyObject *BUILTIN_HEX(PyThreadState *tstate, PyObject *value) {
 
 static void SET_HASH_NOT_IMPLEMENTED_ERROR(PyThreadState *tstate, PyObject *value) {
     // TODO: Use our own formatting code.
+    // spell-checker: ignore unhashable
 
     PyErr_Format(PyExc_TypeError, "unhashable type: '%s'", Py_TYPE(value)->tp_name);
 }
@@ -455,16 +451,17 @@ PyObject *BUILTIN_HASH(PyThreadState *tstate, PyObject *value) {
         }
 
 #if PYTHON_VERSION < 0x300
-        return PyInt_FromLong(hash);
+        return Nuitka_PyInt_FromLong(hash);
 #else
+        // TODO: Have a dedicated helper of ours for this as well.
         return PyLong_FromSsize_t(hash);
 #endif
     }
 
 #if PYTHON_VERSION < 0x300
-    if (likely(type->tp_compare == NULL && RICHCOMPARE(type) == NULL)) {
+    if (likely(type->tp_compare == NULL && TP_RICHCOMPARE(type) == NULL)) {
         Py_hash_t hash = Nuitka_HashFromPointer(value);
-        return PyInt_FromLong(hash);
+        return Nuitka_PyInt_FromLong(hash);
     }
 #endif
 
@@ -481,7 +478,7 @@ Py_hash_t HASH_VALUE_WITH_ERROR(PyThreadState *tstate, PyObject *value) {
     }
 
 #if PYTHON_VERSION < 0x300
-    if (likely(type->tp_compare == NULL && RICHCOMPARE(type) == NULL)) {
+    if (likely(type->tp_compare == NULL && TP_RICHCOMPARE(type) == NULL)) {
         return Nuitka_HashFromPointer(value);
     }
 #endif
@@ -504,7 +501,7 @@ Py_hash_t HASH_VALUE_WITHOUT_ERROR(PyThreadState *tstate, PyObject *value) {
     }
 
 #if PYTHON_VERSION < 0x300
-    if (likely(type->tp_compare == NULL && RICHCOMPARE(type) == NULL)) {
+    if (likely(type->tp_compare == NULL && TP_RICHCOMPARE(type) == NULL)) {
         return Nuitka_HashFromPointer(value);
     }
 #endif
@@ -558,7 +555,7 @@ PyObject *BUILTIN_BYTEARRAY3(PyThreadState *tstate, PyObject *string, PyObject *
  * This comes in two flavors, with one or two arguments. The second one
  * creates a "calliterobject" that is private to CPython. We define it here
  * for ourselves. The one argument version is in headers for in-lining of
- * the code.
+ * the code. spell-checker: ignore calliterobject
  *
  **/
 
@@ -607,7 +604,7 @@ PyObject *BUILTIN_TYPE1(PyObject *arg) {
 }
 
 PyObject *BUILTIN_TYPE3(PyThreadState *tstate, PyObject *module_name, PyObject *name, PyObject *bases, PyObject *dict) {
-    PyObject *pos_args = MAKE_TUPLE3(name, bases, dict);
+    PyObject *pos_args = MAKE_TUPLE3(tstate, name, bases, dict);
 
     PyObject *result = PyType_Type.tp_new(&PyType_Type, pos_args, NULL);
 
@@ -633,9 +630,9 @@ PyObject *BUILTIN_TYPE3(PyThreadState *tstate, PyObject *module_name, PyObject *
     Py_DECREF(pos_args);
 
     if (HAS_ATTR_BOOL(tstate, result, const_str_plain___module__) == false) {
-        int res = SET_ATTRIBUTE(tstate, result, const_str_plain___module__, module_name);
+        bool b_res = SET_ATTRIBUTE(tstate, result, const_str_plain___module__, module_name);
 
-        if (res < 0) {
+        if (b_res == false) {
             Py_DECREF(result);
             return NULL;
         }
@@ -687,7 +684,7 @@ PyObject *BUILTIN_SUPER0(PyThreadState *tstate, PyDictObject *module_dict, PyObj
 PyObject *BUILTIN_CALLABLE(PyObject *value) {
     int res = PyCallable_Check(value);
     PyObject *result = BOOL_FROM(res != 0);
-    Py_INCREF(result);
+    Py_INCREF_IMMORTAL(result);
     return result;
 }
 
@@ -725,13 +722,18 @@ PyObject *BUILTIN_GETATTR(PyThreadState *tstate, PyObject *object, PyObject *att
     PyObject *result = PyObject_GetAttr(object, attribute);
 
     if (result == NULL) {
-        if (default_value != NULL &&
-            EXCEPTION_MATCH_BOOL_SINGLE(tstate, GET_ERROR_OCCURRED(tstate), PyExc_AttributeError)) {
-            CLEAR_ERROR_OCCURRED(tstate);
+        if (default_value != NULL) {
+            if (HAS_ERROR_OCCURRED(tstate)) {
+                if (EXCEPTION_MATCH_BOOL_SINGLE(tstate, GET_ERROR_OCCURRED(tstate), PyExc_AttributeError)) {
+                    CLEAR_ERROR_OCCURRED(tstate);
+                }
+            }
 
             Py_INCREF(default_value);
             return default_value;
         } else {
+            assert(HAS_ERROR_OCCURRED(tstate));
+
             return NULL;
         }
     } else {
@@ -755,7 +757,7 @@ PyObject *BUILTIN_SETATTR(PyObject *object, PyObject *attribute, PyObject *value
 }
 
 PyObject *BUILTIN_INT2(PyThreadState *tstate, PyObject *value, PyObject *base) {
-#if PYTHON_VERSION < 0x340
+#if PYTHON_VERSION < 0x300
     long base_int = PyInt_AsLong(base);
 #else
     Py_ssize_t base_int = PyNumber_AsSsize_t(base, NULL);
@@ -764,7 +766,9 @@ PyObject *BUILTIN_INT2(PyThreadState *tstate, PyObject *value, PyObject *base) {
     if (unlikely(base_int == -1)) {
         PyObject *error = GET_ERROR_OCCURRED(tstate);
 
-        if (likely(error)) {
+        if (likely(error != NULL)) {
+            assert(HAS_ERROR_OCCURRED(tstate));
+
 #if PYTHON_VERSION >= 0x300
             if (EXCEPTION_MATCH_BOOL_SINGLE(tstate, error, PyExc_OverflowError)) {
                 PyErr_Format(PyExc_ValueError,
@@ -878,3 +882,18 @@ PyObject *BUILTIN_LONG2(PyThreadState *tstate, PyObject *value, PyObject *base)
     return result;
 }
 #endif
+
+//     Part of "Nuitka", an optimizing Python compiler that is compatible and
+//     integrates with CPython, but also works on its own.
+//
+//     Licensed under the Apache License, Version 2.0 (the "License");
+//     you may not use this file except in compliance with the License.
+//     You may obtain a copy of the License at
+//
+//        http://www.apache.org/licenses/LICENSE-2.0
+//
+//     Unless required by applicable law or agreed to in writing, software
+//     distributed under the License is distributed on an "AS IS" BASIS,
+//     WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//     See the License for the specific language governing permissions and
+//     limitations under the License.

nuitka/build/static_src/HelpersBuiltinTypeMethods.c

@@ -1,20 +1,5 @@
-//     Copyright 2023, Kay Hayen, mailto:kay.hayen@gmail.com
-//
-//     Part of "Nuitka", an optimizing Python compiler that is compatible and
-//     integrates with CPython, but also works on its own.
-//
-//     Licensed under the Apache License, Version 2.0 (the "License");
-//     you may not use this file except in compliance with the License.
-//     You may obtain a copy of the License at
-//
-//        http://www.apache.org/licenses/LICENSE-2.0
-//
-//     Unless required by applicable law or agreed to in writing, software
-//     distributed under the License is distributed on an "AS IS" BASIS,
-//     WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-//     See the License for the specific language governing permissions and
-//     limitations under the License.
-//
+//     Copyright 2024, Kay Hayen, mailto:kay.hayen@gmail.com find license text at end of file
+
 /* WARNING, this code is GENERATED. Modify the template HelperBuiltinMethodOperation.c.j2 instead! */
 
 /* This file is included from another C file, help IDEs to still parse it on its own. */
@@ -3592,3 +3577,18 @@ PyObject *BYTES_ZFILL(PyThreadState *tstate, PyObject *bytes, PyObject *width) {
     return result;
 }
 #endif
+
+//     Part of "Nuitka", an optimizing Python compiler that is compatible and
+//     integrates with CPython, but also works on its own.
+//
+//     Licensed under the Apache License, Version 2.0 (the "License");
+//     you may not use this file except in compliance with the License.
+//     You may obtain a copy of the License at
+//
+//        http://www.apache.org/licenses/LICENSE-2.0
+//
+//     Unless required by applicable law or agreed to in writing, software
+//     distributed under the License is distributed on an "AS IS" BASIS,
+//     WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//     See the License for the specific language governing permissions and
+//     limitations under the License.

nuitka/build/static_src/HelpersBytes.c

@@ -1,20 +1,5 @@
-//     Copyright 2023, Kay Hayen, mailto:kay.hayen@gmail.com
-//
-//     Part of "Nuitka", an optimizing Python compiler that is compatible and
-//     integrates with CPython, but also works on its own.
-//
-//     Licensed under the Apache License, Version 2.0 (the "License");
-//     you may not use this file except in compliance with the License.
-//     You may obtain a copy of the License at
-//
-//        http://www.apache.org/licenses/LICENSE-2.0
-//
-//     Unless required by applicable law or agreed to in writing, software
-//     distributed under the License is distributed on an "AS IS" BASIS,
-//     WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-//     See the License for the specific language governing permissions and
-//     limitations under the License.
-//
+//     Copyright 2024, Kay Hayen, mailto:kay.hayen@gmail.com find license text at end of file
+
 /* This helpers is used to quickly create a bytes objects.
 
 */
@@ -80,10 +65,10 @@ PyObject *Nuitka_Bytes_FromStringAndSize(const char *data, Py_ssize_t size) {
 #endif
     }
 
-    op = (PyBytesObject *)PyObject_Malloc(PyBytesObject_SIZE + size);
+    op = (PyBytesObject *)NuitkaObject_Malloc(PyBytesObject_SIZE + size);
 
-    Py_SET_SIZE(op, size);
     Py_SET_TYPE(op, &PyBytes_Type);
+    Py_SET_SIZE(op, size);
 
     Nuitka_Py_NewReference((PyObject *)op);
 
@@ -105,4 +90,18 @@ PyObject *Nuitka_Bytes_FromStringAndSize(const char *data, Py_ssize_t size) {
 
 #endif
 
-#endif
+#endif
+//     Part of "Nuitka", an optimizing Python compiler that is compatible and
+//     integrates with CPython, but also works on its own.
+//
+//     Licensed under the Apache License, Version 2.0 (the "License");
+//     you may not use this file except in compliance with the License.
+//     You may obtain a copy of the License at
+//
+//        http://www.apache.org/licenses/LICENSE-2.0
+//
+//     Unless required by applicable law or agreed to in writing, software
+//     distributed under the License is distributed on an "AS IS" BASIS,
+//     WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//     See the License for the specific language governing permissions and
+//     limitations under the License.

nuitka/build/static_src/HelpersCalling.c

@@ -1,20 +1,5 @@
-//     Copyright 2023, Kay Hayen, mailto:kay.hayen@gmail.com
-//
-//     Part of "Nuitka", an optimizing Python compiler that is compatible and
-//     integrates with CPython, but also works on its own.
-//
-//     Licensed under the Apache License, Version 2.0 (the "License");
-//     you may not use this file except in compliance with the License.
-//     You may obtain a copy of the License at
-//
-//        http://www.apache.org/licenses/LICENSE-2.0
-//
-//     Unless required by applicable law or agreed to in writing, software
-//     distributed under the License is distributed on an "AS IS" BASIS,
-//     WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-//     See the License for the specific language governing permissions and
-//     limitations under the License.
-//
+//     Copyright 2024, Kay Hayen, mailto:kay.hayen@gmail.com find license text at end of file
+
 // This file is included from another C file, help IDEs to still parse it on
 // its own.
 #ifdef __IDE_ONLY__
@@ -95,6 +80,7 @@ PyObject *callPythonFunction(PyObject *func, PyObject *const *args, int count) {
     return result;
 }
 
+#if PYTHON_VERSION < 0x380 && !defined(_NUITKA_EXPERIMENTAL_DISABLE_UNCOMPILED_FUNCTION_CALL_OPT)
 static PyObject *callPythonFunctionNoArgs(PyObject *func) {
     PyCodeObject *co = (PyCodeObject *)PyFunction_GET_CODE(func);
     PyObject *globals = PyFunction_GET_GLOBALS(func);
@@ -160,8 +146,10 @@ static PyObject *callPythonFunctionNoArgs(PyObject *func) {
 }
 #endif
 
-PyObject *CALL_METHOD_WITH_POSARGS(PyThreadState *tstate, PyObject *source, PyObject *attr_name,
-                                   PyObject *positional_args) {
+#endif
+
+PyObject *CALL_METHOD_WITH_POS_ARGS(PyThreadState *tstate, PyObject *source, PyObject *attr_name,
+                                    PyObject *positional_args) {
     CHECK_OBJECT(source);
     CHECK_OBJECT(attr_name);
     CHECK_OBJECT(positional_args);
@@ -182,7 +170,7 @@ PyObject *CALL_METHOD_WITH_POSARGS(PyThreadState *tstate, PyObject *source, PyOb
         // Note: The "called_object" was found without taking a reference,
         // so we need not release it in this branch.
         if (called_object != NULL) {
-            return CALL_FUNCTION_WITH_POSARGS(tstate, called_object, positional_args);
+            return CALL_FUNCTION_WITH_POS_ARGS(tstate, called_object, positional_args);
         }
         // Then check the class dictionaries.
         called_object = FIND_ATTRIBUTE_IN_CLASS(source_instance->in_class, attr_name);
@@ -203,11 +191,11 @@ PyObject *CALL_METHOD_WITH_POSARGS(PyThreadState *tstate, PyObject *source, PyOb
                     return NULL;
                 }
 
-                PyObject *result = CALL_FUNCTION_WITH_POSARGS(tstate, method, positional_args);
+                PyObject *result = CALL_FUNCTION_WITH_POS_ARGS(tstate, method, positional_args);
                 Py_DECREF(method);
                 return result;
             } else {
-                return CALL_FUNCTION_WITH_POSARGS(tstate, called_object, positional_args);
+                return CALL_FUNCTION_WITH_POS_ARGS(tstate, called_object, positional_args);
             }
         } else if (unlikely(source_instance->in_class->cl_getattr == NULL)) {
             PyErr_Format(PyExc_AttributeError, "%s instance has no attribute '%s'",
@@ -226,7 +214,7 @@ PyObject *CALL_METHOD_WITH_POSARGS(PyThreadState *tstate, PyObject *source, PyOb
                 return NULL;
             }
 
-            PyObject *result = CALL_FUNCTION_WITH_POSARGS(tstate, called_object, positional_args);
+            PyObject *result = CALL_FUNCTION_WITH_POS_ARGS(tstate, called_object, positional_args);
             Py_DECREF(called_object);
             return result;
         }
@@ -252,7 +240,7 @@ PyObject *CALL_METHOD_WITH_POSARGS(PyThreadState *tstate, PyObject *source, PyOb
             return NULL;
         }
 
-        PyObject *result = CALL_FUNCTION_WITH_POSARGS(tstate, called_object, positional_args);
+        PyObject *result = CALL_FUNCTION_WITH_POS_ARGS(tstate, called_object, positional_args);
         Py_DECREF(called_object);
         return result;
     }
@@ -299,39 +287,39 @@ char const *GET_CALLABLE_DESC(PyObject *object) {
     }
 }
 
-char const *GET_CLASS_NAME(PyObject *klass) {
-    if (klass == NULL) {
+char const *GET_CLASS_NAME(PyObject *class_object) {
+    if (class_object == NULL) {
         return "?";
     } else {
 #if PYTHON_VERSION < 0x300
-        if (PyClass_Check(klass)) {
-            return Nuitka_String_AsString(((PyClassObject *)klass)->cl_name);
+        if (PyClass_Check(class_object)) {
+            return Nuitka_String_AsString(((PyClassObject *)class_object)->cl_name);
         }
 #endif
 
-        if (!PyType_Check(klass)) {
-            klass = (PyObject *)Py_TYPE(klass);
+        if (!PyType_Check(class_object)) {
+            class_object = (PyObject *)Py_TYPE(class_object);
         }
 
-        return ((PyTypeObject *)klass)->tp_name;
+        return ((PyTypeObject *)class_object)->tp_name;
     }
 }
 
 char const *GET_INSTANCE_CLASS_NAME(PyThreadState *tstate, PyObject *instance) {
     // TODO: Why not use our own attribute lookup here.
-    PyObject *klass = PyObject_GetAttr(instance, const_str_plain___class__);
+    PyObject *class_object = PyObject_GetAttr(instance, const_str_plain___class__);
 
     // Fallback to type as this cannot fail.
-    if (klass == NULL) {
+    if (class_object == NULL) {
         CLEAR_ERROR_OCCURRED(tstate);
 
-        klass = (PyObject *)Py_TYPE(instance);
-        Py_INCREF(klass);
+        class_object = (PyObject *)Py_TYPE(instance);
+        Py_INCREF(class_object);
     }
 
-    char const *result = GET_CLASS_NAME(klass);
+    char const *result = GET_CLASS_NAME(class_object);
 
-    Py_DECREF(klass);
+    Py_DECREF(class_object);
 
     return result;
 }
@@ -392,3 +380,18 @@ void formatCannotInstantiateAbstractClass(PyThreadState *tstate, PyTypeObject *t
 }
 
 #include "HelpersCallingGenerated.c"
+
+//     Part of "Nuitka", an optimizing Python compiler that is compatible and
+//     integrates with CPython, but also works on its own.
+//
+//     Licensed under the Apache License, Version 2.0 (the "License");
+//     you may not use this file except in compliance with the License.
+//     You may obtain a copy of the License at
+//
+//        http://www.apache.org/licenses/LICENSE-2.0
+//
+//     Unless required by applicable law or agreed to in writing, software
+//     distributed under the License is distributed on an "AS IS" BASIS,
+//     WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//     See the License for the specific language governing permissions and
+//     limitations under the License.