├── .gitattributes ├── .github └── workflows │ └── test.yml ├── .gitignore ├── Android ├── bldlibrary.patch ├── build_deps.py ├── configure.py ├── grph.patch ├── patchTrampc.patch ├── trampc.patch ├── unversioned-libpython.patch └── util.py ├── AndroidApp ├── .gitignore ├── app │ ├── .gitignore │ ├── build.gradle │ ├── proguard-rules.pro │ └── src │ │ ├── androidTest │ │ └── java │ │ │ └── com │ │ │ └── example │ │ │ └── pythontest │ │ │ ├── Common.java │ │ │ ├── ExampleInstrumentedTest.java │ │ │ └── PythonThread.java │ │ ├── main │ │ ├── AndroidManifest.xml │ │ ├── assets │ │ │ ├── Python64.zip │ │ │ ├── Pythonx86_64.zip │ │ │ └── main.py │ │ ├── java │ │ │ └── com │ │ │ │ └── example │ │ │ │ └── pythontest │ │ │ │ ├── Common.java │ │ │ │ ├── MainActivity.java │ │ │ │ └── PythonThread.java │ │ ├── jni │ │ │ ├── CMakeLists.txt │ │ │ ├── PythonThread.cpp │ │ │ ├── PythonThread.hpp │ │ │ ├── Pythonx86_64 │ │ │ │ ├── Python.h │ │ │ │ ├── abstract.h │ │ │ │ ├── bltinmodule.h │ │ │ │ ├── boolobject.h │ │ │ │ ├── bytearrayobject.h │ │ │ │ ├── bytesobject.h │ │ │ │ ├── ceval.h │ │ │ │ ├── codecs.h │ │ │ │ ├── compile.h │ │ │ │ ├── complexobject.h │ │ │ │ ├── cpython │ │ │ │ │ ├── abstract.h │ │ │ │ │ ├── bytearrayobject.h │ │ │ │ │ ├── bytesobject.h │ │ │ │ │ ├── cellobject.h │ │ │ │ │ ├── ceval.h │ │ │ │ │ ├── classobject.h │ │ │ │ │ ├── code.h │ │ │ │ │ ├── compile.h │ │ │ │ │ ├── complexobject.h │ │ │ │ │ ├── context.h │ │ │ │ │ ├── descrobject.h │ │ │ │ │ ├── dictobject.h │ │ │ │ │ ├── fileobject.h │ │ │ │ │ ├── fileutils.h │ │ │ │ │ ├── floatobject.h │ │ │ │ │ ├── frameobject.h │ │ │ │ │ ├── funcobject.h │ │ │ │ │ ├── genobject.h │ │ │ │ │ ├── import.h │ │ │ │ │ ├── initconfig.h │ │ │ │ │ ├── interpreteridobject.h │ │ │ │ │ ├── listobject.h │ │ │ │ │ ├── longintrepr.h │ │ │ │ │ ├── longobject.h │ │ │ │ │ ├── memoryobject.h │ │ │ │ │ ├── methodobject.h │ │ │ │ │ ├── modsupport.h │ │ │ │ │ ├── object.h │ │ │ │ │ ├── objimpl.h │ │ │ │ │ ├── odictobject.h │ │ │ │ │ ├── picklebufobject.h │ │ │ │ │ ├── pthread_stubs.h │ │ │ │ │ ├── pyctype.h │ │ │ │ │ ├── pydebug.h │ │ │ │ │ ├── pyerrors.h │ │ │ │ │ ├── pyfpe.h │ │ │ │ │ ├── pyframe.h │ │ │ │ │ ├── pylifecycle.h │ │ │ │ │ ├── pymem.h │ │ │ │ │ ├── pystate.h │ │ │ │ │ ├── pythonrun.h │ │ │ │ │ ├── pythread.h │ │ │ │ │ ├── pytime.h │ │ │ │ │ ├── setobject.h │ │ │ │ │ ├── sysmodule.h │ │ │ │ │ ├── traceback.h │ │ │ │ │ ├── tupleobject.h │ │ │ │ │ ├── unicodeobject.h │ │ │ │ │ ├── warnings.h │ │ │ │ │ └── weakrefobject.h │ │ │ │ ├── datetime.h │ │ │ │ ├── descrobject.h │ │ │ │ ├── dictobject.h │ │ │ │ ├── dynamic_annotations.h │ │ │ │ ├── enumobject.h │ │ │ │ ├── errcode.h │ │ │ │ ├── exports.h │ │ │ │ ├── fileobject.h │ │ │ │ ├── fileutils.h │ │ │ │ ├── floatobject.h │ │ │ │ ├── frameobject.h │ │ │ │ ├── genericaliasobject.h │ │ │ │ ├── import.h │ │ │ │ ├── internal │ │ │ │ │ ├── pycore_abstract.h │ │ │ │ │ ├── pycore_asdl.h │ │ │ │ │ ├── pycore_ast.h │ │ │ │ │ ├── pycore_ast_state.h │ │ │ │ │ ├── pycore_atexit.h │ │ │ │ │ ├── pycore_atomic.h │ │ │ │ │ ├── pycore_atomic_funcs.h │ │ │ │ │ ├── pycore_bitutils.h │ │ │ │ │ ├── pycore_blocks_output_buffer.h │ │ │ │ │ ├── pycore_bytes_methods.h │ │ │ │ │ ├── pycore_bytesobject.h │ │ │ │ │ ├── pycore_call.h │ │ │ │ │ ├── pycore_ceval.h │ │ │ │ │ ├── pycore_ceval_state.h │ │ │ │ │ ├── pycore_code.h │ │ │ │ │ ├── pycore_compile.h │ │ │ │ │ ├── pycore_condvar.h │ │ │ │ │ ├── pycore_context.h │ │ │ │ │ ├── pycore_descrobject.h │ │ │ │ │ ├── pycore_dict.h │ │ │ │ │ ├── pycore_dict_state.h │ │ │ │ │ ├── pycore_dtoa.h │ │ │ │ │ ├── pycore_emscripten_signal.h │ │ │ │ │ ├── pycore_exceptions.h │ │ │ │ │ ├── pycore_faulthandler.h │ │ │ │ │ ├── pycore_fileutils.h │ │ │ │ │ ├── pycore_fileutils_windows.h │ │ │ │ │ ├── pycore_floatobject.h │ │ │ │ │ ├── pycore_flowgraph.h │ │ │ │ │ ├── pycore_format.h │ │ │ │ │ ├── pycore_frame.h │ │ │ │ │ ├── pycore_function.h │ │ │ │ │ ├── pycore_gc.h │ │ │ │ │ ├── pycore_genobject.h │ │ │ │ │ ├── pycore_getopt.h │ │ │ │ │ ├── pycore_gil.h │ │ │ │ │ ├── pycore_global_objects.h │ │ │ │ │ ├── pycore_global_objects_fini_generated.h │ │ │ │ │ ├── pycore_global_strings.h │ │ │ │ │ ├── pycore_hamt.h │ │ │ │ │ ├── pycore_hashtable.h │ │ │ │ │ ├── pycore_import.h │ │ │ │ │ ├── pycore_initconfig.h │ │ │ │ │ ├── pycore_instruments.h │ │ │ │ │ ├── pycore_interp.h │ │ │ │ │ ├── pycore_intrinsics.h │ │ │ │ │ ├── pycore_list.h │ │ │ │ │ ├── pycore_long.h │ │ │ │ │ ├── pycore_memoryobject.h │ │ │ │ │ ├── pycore_moduleobject.h │ │ │ │ │ ├── pycore_namespace.h │ │ │ │ │ ├── pycore_object.h │ │ │ │ │ ├── pycore_object_state.h │ │ │ │ │ ├── pycore_obmalloc.h │ │ │ │ │ ├── pycore_obmalloc_init.h │ │ │ │ │ ├── pycore_opcode.h │ │ │ │ │ ├── pycore_opcode_utils.h │ │ │ │ │ ├── pycore_parser.h │ │ │ │ │ ├── pycore_pathconfig.h │ │ │ │ │ ├── pycore_pyarena.h │ │ │ │ │ ├── pycore_pyerrors.h │ │ │ │ │ ├── pycore_pyhash.h │ │ │ │ │ ├── pycore_pylifecycle.h │ │ │ │ │ ├── pycore_pymath.h │ │ │ │ │ ├── pycore_pymem.h │ │ │ │ │ ├── pycore_pymem_init.h │ │ │ │ │ ├── pycore_pystate.h │ │ │ │ │ ├── pycore_pythread.h │ │ │ │ │ ├── pycore_range.h │ │ │ │ │ ├── pycore_runtime.h │ │ │ │ │ ├── pycore_runtime_init.h │ │ │ │ │ ├── pycore_runtime_init_generated.h │ │ │ │ │ ├── pycore_signal.h │ │ │ │ │ ├── pycore_sliceobject.h │ │ │ │ │ ├── pycore_strhex.h │ │ │ │ │ ├── pycore_structseq.h │ │ │ │ │ ├── pycore_symtable.h │ │ │ │ │ ├── pycore_sysmodule.h │ │ │ │ │ ├── pycore_time.h │ │ │ │ │ ├── pycore_token.h │ │ │ │ │ ├── pycore_traceback.h │ │ │ │ │ ├── pycore_tracemalloc.h │ │ │ │ │ ├── pycore_tuple.h │ │ │ │ │ ├── pycore_typeobject.h │ │ │ │ │ ├── pycore_typevarobject.h │ │ │ │ │ ├── pycore_ucnhash.h │ │ │ │ │ ├── pycore_unicodeobject.h │ │ │ │ │ ├── pycore_unicodeobject_generated.h │ │ │ │ │ ├── pycore_unionobject.h │ │ │ │ │ └── pycore_warnings.h │ │ │ │ ├── interpreteridobject.h │ │ │ │ ├── intrcheck.h │ │ │ │ ├── iterobject.h │ │ │ │ ├── listobject.h │ │ │ │ ├── longobject.h │ │ │ │ ├── marshal.h │ │ │ │ ├── memoryobject.h │ │ │ │ ├── methodobject.h │ │ │ │ ├── modsupport.h │ │ │ │ ├── moduleobject.h │ │ │ │ ├── object.h │ │ │ │ ├── objimpl.h │ │ │ │ ├── opcode.h │ │ │ │ ├── osdefs.h │ │ │ │ ├── osmodule.h │ │ │ │ ├── patchlevel.h │ │ │ │ ├── py_curses.h │ │ │ │ ├── pybuffer.h │ │ │ │ ├── pycapsule.h │ │ │ │ ├── pyconfig.h │ │ │ │ ├── pydtrace.h │ │ │ │ ├── pyerrors.h │ │ │ │ ├── pyexpat.h │ │ │ │ ├── pyframe.h │ │ │ │ ├── pyhash.h │ │ │ │ ├── pylifecycle.h │ │ │ │ ├── pymacconfig.h │ │ │ │ ├── pymacro.h │ │ │ │ ├── pymath.h │ │ │ │ ├── pymem.h │ │ │ │ ├── pyport.h │ │ │ │ ├── pystate.h │ │ │ │ ├── pystats.h │ │ │ │ ├── pystrcmp.h │ │ │ │ ├── pystrtod.h │ │ │ │ ├── pythonrun.h │ │ │ │ ├── pythread.h │ │ │ │ ├── pytypedefs.h │ │ │ │ ├── rangeobject.h │ │ │ │ ├── setobject.h │ │ │ │ ├── sliceobject.h │ │ │ │ ├── structmember.h │ │ │ │ ├── structseq.h │ │ │ │ ├── sysmodule.h │ │ │ │ ├── traceback.h │ │ │ │ ├── tracemalloc.h │ │ │ │ ├── tupleobject.h │ │ │ │ ├── typeslots.h │ │ │ │ ├── unicodeobject.h │ │ │ │ ├── warnings.h │ │ │ │ └── weakrefobject.h │ │ │ ├── StdAfx.cpp │ │ │ ├── StdAfx.h │ │ │ ├── conversion.hpp │ │ │ ├── py_helpers │ │ │ │ ├── python_helpers.cpp │ │ │ │ ├── python_helpers.hpp │ │ │ │ ├── python_processing.cpp │ │ │ │ └── python_processing.hpp │ │ │ ├── python64 │ │ │ │ ├── Python.h │ │ │ │ ├── abstract.h │ │ │ │ ├── bltinmodule.h │ │ │ │ ├── boolobject.h │ │ │ │ ├── bytearrayobject.h │ │ │ │ ├── bytesobject.h │ │ │ │ ├── ceval.h │ │ │ │ ├── codecs.h │ │ │ │ ├── compile.h │ │ │ │ ├── complexobject.h │ │ │ │ ├── cpython │ │ │ │ │ ├── abstract.h │ │ │ │ │ ├── bytearrayobject.h │ │ │ │ │ ├── bytesobject.h │ │ │ │ │ ├── cellobject.h │ │ │ │ │ ├── ceval.h │ │ │ │ │ ├── classobject.h │ │ │ │ │ ├── code.h │ │ │ │ │ ├── compile.h │ │ │ │ │ ├── complexobject.h │ │ │ │ │ ├── context.h │ │ │ │ │ ├── descrobject.h │ │ │ │ │ ├── dictobject.h │ │ │ │ │ ├── fileobject.h │ │ │ │ │ ├── fileutils.h │ │ │ │ │ ├── floatobject.h │ │ │ │ │ ├── frameobject.h │ │ │ │ │ ├── funcobject.h │ │ │ │ │ ├── genobject.h │ │ │ │ │ ├── import.h │ │ │ │ │ ├── initconfig.h │ │ │ │ │ ├── interpreteridobject.h │ │ │ │ │ ├── listobject.h │ │ │ │ │ ├── longintrepr.h │ │ │ │ │ ├── longobject.h │ │ │ │ │ ├── memoryobject.h │ │ │ │ │ ├── methodobject.h │ │ │ │ │ ├── modsupport.h │ │ │ │ │ ├── object.h │ │ │ │ │ ├── objimpl.h │ │ │ │ │ ├── odictobject.h │ │ │ │ │ ├── picklebufobject.h │ │ │ │ │ ├── pthread_stubs.h │ │ │ │ │ ├── pyctype.h │ │ │ │ │ ├── pydebug.h │ │ │ │ │ ├── pyerrors.h │ │ │ │ │ ├── pyfpe.h │ │ │ │ │ ├── pyframe.h │ │ │ │ │ ├── pylifecycle.h │ │ │ │ │ ├── pymem.h │ │ │ │ │ ├── pystate.h │ │ │ │ │ ├── pythonrun.h │ │ │ │ │ ├── pythread.h │ │ │ │ │ ├── pytime.h │ │ │ │ │ ├── setobject.h │ │ │ │ │ ├── sysmodule.h │ │ │ │ │ ├── traceback.h │ │ │ │ │ ├── tupleobject.h │ │ │ │ │ ├── unicodeobject.h │ │ │ │ │ ├── warnings.h │ │ │ │ │ └── weakrefobject.h │ │ │ │ ├── datetime.h │ │ │ │ ├── descrobject.h │ │ │ │ ├── dictobject.h │ │ │ │ ├── dynamic_annotations.h │ │ │ │ ├── enumobject.h │ │ │ │ ├── errcode.h │ │ │ │ ├── exports.h │ │ │ │ ├── fileobject.h │ │ │ │ ├── fileutils.h │ │ │ │ ├── floatobject.h │ │ │ │ ├── frameobject.h │ │ │ │ ├── genericaliasobject.h │ │ │ │ ├── import.h │ │ │ │ ├── internal │ │ │ │ │ ├── pycore_abstract.h │ │ │ │ │ ├── pycore_asdl.h │ │ │ │ │ ├── pycore_ast.h │ │ │ │ │ ├── pycore_ast_state.h │ │ │ │ │ ├── pycore_atexit.h │ │ │ │ │ ├── pycore_atomic.h │ │ │ │ │ ├── pycore_atomic_funcs.h │ │ │ │ │ ├── pycore_bitutils.h │ │ │ │ │ ├── pycore_blocks_output_buffer.h │ │ │ │ │ ├── pycore_bytes_methods.h │ │ │ │ │ ├── pycore_bytesobject.h │ │ │ │ │ ├── pycore_call.h │ │ │ │ │ ├── pycore_ceval.h │ │ │ │ │ ├── pycore_ceval_state.h │ │ │ │ │ ├── pycore_code.h │ │ │ │ │ ├── pycore_compile.h │ │ │ │ │ ├── pycore_condvar.h │ │ │ │ │ ├── pycore_context.h │ │ │ │ │ ├── pycore_descrobject.h │ │ │ │ │ ├── pycore_dict.h │ │ │ │ │ ├── pycore_dict_state.h │ │ │ │ │ ├── pycore_dtoa.h │ │ │ │ │ ├── pycore_emscripten_signal.h │ │ │ │ │ ├── pycore_exceptions.h │ │ │ │ │ ├── pycore_faulthandler.h │ │ │ │ │ ├── pycore_fileutils.h │ │ │ │ │ ├── pycore_fileutils_windows.h │ │ │ │ │ ├── pycore_floatobject.h │ │ │ │ │ ├── pycore_flowgraph.h │ │ │ │ │ ├── pycore_format.h │ │ │ │ │ ├── pycore_frame.h │ │ │ │ │ ├── pycore_function.h │ │ │ │ │ ├── pycore_gc.h │ │ │ │ │ ├── pycore_genobject.h │ │ │ │ │ ├── pycore_getopt.h │ │ │ │ │ ├── pycore_gil.h │ │ │ │ │ ├── pycore_global_objects.h │ │ │ │ │ ├── pycore_global_objects_fini_generated.h │ │ │ │ │ ├── pycore_global_strings.h │ │ │ │ │ ├── pycore_hamt.h │ │ │ │ │ ├── pycore_hashtable.h │ │ │ │ │ ├── pycore_import.h │ │ │ │ │ ├── pycore_initconfig.h │ │ │ │ │ ├── pycore_instruments.h │ │ │ │ │ ├── pycore_interp.h │ │ │ │ │ ├── pycore_intrinsics.h │ │ │ │ │ ├── pycore_list.h │ │ │ │ │ ├── pycore_long.h │ │ │ │ │ ├── pycore_memoryobject.h │ │ │ │ │ ├── pycore_moduleobject.h │ │ │ │ │ ├── pycore_namespace.h │ │ │ │ │ ├── pycore_object.h │ │ │ │ │ ├── pycore_object_state.h │ │ │ │ │ ├── pycore_obmalloc.h │ │ │ │ │ ├── pycore_obmalloc_init.h │ │ │ │ │ ├── pycore_opcode.h │ │ │ │ │ ├── pycore_opcode_utils.h │ │ │ │ │ ├── pycore_parser.h │ │ │ │ │ ├── pycore_pathconfig.h │ │ │ │ │ ├── pycore_pyarena.h │ │ │ │ │ ├── pycore_pyerrors.h │ │ │ │ │ ├── pycore_pyhash.h │ │ │ │ │ ├── pycore_pylifecycle.h │ │ │ │ │ ├── pycore_pymath.h │ │ │ │ │ ├── pycore_pymem.h │ │ │ │ │ ├── pycore_pymem_init.h │ │ │ │ │ ├── pycore_pystate.h │ │ │ │ │ ├── pycore_pythread.h │ │ │ │ │ ├── pycore_range.h │ │ │ │ │ ├── pycore_runtime.h │ │ │ │ │ ├── pycore_runtime_init.h │ │ │ │ │ ├── pycore_runtime_init_generated.h │ │ │ │ │ ├── pycore_signal.h │ │ │ │ │ ├── pycore_sliceobject.h │ │ │ │ │ ├── pycore_strhex.h │ │ │ │ │ ├── pycore_structseq.h │ │ │ │ │ ├── pycore_symtable.h │ │ │ │ │ ├── pycore_sysmodule.h │ │ │ │ │ ├── pycore_time.h │ │ │ │ │ ├── pycore_token.h │ │ │ │ │ ├── pycore_traceback.h │ │ │ │ │ ├── pycore_tracemalloc.h │ │ │ │ │ ├── pycore_tuple.h │ │ │ │ │ ├── pycore_typeobject.h │ │ │ │ │ ├── pycore_typevarobject.h │ │ │ │ │ ├── pycore_ucnhash.h │ │ │ │ │ ├── pycore_unicodeobject.h │ │ │ │ │ ├── pycore_unicodeobject_generated.h │ │ │ │ │ ├── pycore_unionobject.h │ │ │ │ │ └── pycore_warnings.h │ │ │ │ ├── interpreteridobject.h │ │ │ │ ├── intrcheck.h │ │ │ │ ├── iterobject.h │ │ │ │ ├── listobject.h │ │ │ │ ├── longobject.h │ │ │ │ ├── marshal.h │ │ │ │ ├── memoryobject.h │ │ │ │ ├── methodobject.h │ │ │ │ ├── modsupport.h │ │ │ │ ├── moduleobject.h │ │ │ │ ├── object.h │ │ │ │ ├── objimpl.h │ │ │ │ ├── opcode.h │ │ │ │ ├── osdefs.h │ │ │ │ ├── osmodule.h │ │ │ │ ├── patchlevel.h │ │ │ │ ├── py_curses.h │ │ │ │ ├── pybuffer.h │ │ │ │ ├── pycapsule.h │ │ │ │ ├── pyconfig.h │ │ │ │ ├── pydtrace.h │ │ │ │ ├── pyerrors.h │ │ │ │ ├── pyexpat.h │ │ │ │ ├── pyframe.h │ │ │ │ ├── pyhash.h │ │ │ │ ├── pylifecycle.h │ │ │ │ ├── pymacconfig.h │ │ │ │ ├── pymacro.h │ │ │ │ ├── pymath.h │ │ │ │ ├── pymem.h │ │ │ │ ├── pyport.h │ │ │ │ ├── pystate.h │ │ │ │ ├── pystats.h │ │ │ │ ├── pystrcmp.h │ │ │ │ ├── pystrtod.h │ │ │ │ ├── pythonrun.h │ │ │ │ ├── pythread.h │ │ │ │ ├── pytypedefs.h │ │ │ │ ├── rangeobject.h │ │ │ │ ├── setobject.h │ │ │ │ ├── sliceobject.h │ │ │ │ ├── structmember.h │ │ │ │ ├── structseq.h │ │ │ │ ├── sysmodule.h │ │ │ │ ├── traceback.h │ │ │ │ ├── tracemalloc.h │ │ │ │ ├── tupleobject.h │ │ │ │ ├── typeslots.h │ │ │ │ ├── unicodeobject.h │ │ │ │ ├── warnings.h │ │ │ │ └── weakrefobject.h │ │ │ ├── util.cpp │ │ │ └── util.hpp │ │ ├── jniLibs │ │ │ ├── arm64-v8a │ │ │ │ └── libpython3.12.so │ │ │ └── x86_64 │ │ │ │ └── libpython3.12.so │ │ └── res │ │ │ ├── drawable-v24 │ │ │ └── ic_launcher_foreground.xml │ │ │ ├── drawable │ │ │ └── ic_launcher_background.xml │ │ │ ├── layout │ │ │ ├── activity_main.xml │ │ │ └── content_main.xml │ │ │ ├── menu │ │ │ └── menu_main.xml │ │ │ ├── mipmap-anydpi-v26 │ │ │ ├── ic_launcher.xml │ │ │ └── ic_launcher_round.xml │ │ │ ├── mipmap-hdpi │ │ │ ├── ic_launcher.png │ │ │ └── ic_launcher_round.png │ │ │ ├── mipmap-mdpi │ │ │ ├── ic_launcher.png │ │ │ └── ic_launcher_round.png │ │ │ ├── mipmap-xhdpi │ │ │ ├── ic_launcher.png │ │ │ └── ic_launcher_round.png │ │ │ ├── mipmap-xxhdpi │ │ │ ├── ic_launcher.png │ │ │ └── ic_launcher_round.png │ │ │ ├── mipmap-xxxhdpi │ │ │ ├── ic_launcher.png │ │ │ └── ic_launcher_round.png │ │ │ └── values │ │ │ ├── colors.xml │ │ │ ├── dimens.xml │ │ │ ├── strings.xml │ │ │ └── styles.xml │ │ └── test │ │ └── java │ │ └── com │ │ └── example │ │ └── pythontest │ │ └── ExampleUnitTest.java ├── build.gradle ├── gradle.properties ├── gradle │ └── wrapper │ │ ├── gradle-wrapper.jar │ │ └── gradle-wrapper.properties ├── gradlew ├── gradlew.bat └── settings.gradle ├── LICENSE ├── README.md ├── build.sh ├── clean.sh ├── devscripts ├── env.sh └── import_all.py ├── docker-build.sh └── src └── .keep /.gitattributes: -------------------------------------------------------------------------------- 1 | *.sh text eol=lf 2 | *.patch text eol=lf 3 | *.py text eol=lf 4 | -------------------------------------------------------------------------------- /.gitignore: -------------------------------------------------------------------------------- 1 | /build 2 | /src/* 3 | !/src/.keep 4 | *.pyc 5 | .mypy_cache/ 6 | .gnupg/ 7 | /sdk/* 8 | !/sdk/.keep 9 | AndroidApp/.idea 10 | -------------------------------------------------------------------------------- /Android/bldlibrary.patch: -------------------------------------------------------------------------------- 1 | --- Python-3.12.1-original/configure 2023-11-22 09:33:49 2 | +++ Python-3.12.1/configure 2023-11-22 10:13:05 3 | @@ -7484,6 +7484,7 @@ 4 | 5 | case $ac_sys_system in 6 | CYGWIN*) 7 | LDLIBRARY='libpython$(LDVERSION).dll.a' 8 | + BLDLIBRARY='-L. -lpython$(LDVERSION)' 9 | DLLLIBRARY='libpython$(LDVERSION).dll' 10 | ;; 11 | SunOS*) 12 | --- Python-3.12.1-original/configure 2023-11-22 09:33:49 13 | +++ Python-3.12.1/configure 2023-11-22 10:13:05 14 | @@ -24378,7 +24378,7 @@ 15 | # On Android and Cygwin the shared libraries must be linked with libpython. 16 | 17 | if test "$PY_ENABLE_SHARED" = "1" && ( test -n "$ANDROID_API_LEVEL" || test "$MACHDEP" = "cygwin"); then 18 | - LIBPYTHON="-lpython${VERSION}${ABIFLAGS}" 19 | + LIBPYTHON="$BLDLIBRARY" 20 | else 21 | LIBPYTHON='' 22 | fi 23 | --- Python-3.12.1-original/Modules/makesetup 2023-10-02 12:48:14 24 | +++ Python-3.12.1/Modules/makesetup 2023-11-22 10:11:40 25 | @@ -86,18 +86,6 @@ 26 | # Newline for sed i and a commands 27 | NL='\ 28 | ' 29 | - 30 | -# Setup to link with extra libraries when making shared extensions. 31 | -# Currently, only Cygwin needs this baggage. 32 | -case `uname -s` in 33 | -CYGWIN*) if test $libdir = . 34 | - then 35 | - ExtraLibDir=. 36 | - else 37 | - ExtraLibDir='$(LIBPL)' 38 | - fi 39 | - ExtraLibs="-L$ExtraLibDir -lpython\$(LDVERSION)";; 40 | -esac 41 | 42 | # Main loop 43 | for i in ${*-Setup} 44 | @@ -286,7 +274,7 @@ 45 | ;; 46 | esac 47 | rule="$file: $objs" 48 | - rule="$rule; \$(BLDSHARED) $objs $libs $ExtraLibs -o $file" 49 | + rule="$rule; \$(BLDSHARED) $objs $libs \$(LIBPYTHON) -o $file" 50 | echo "$rule" >>$rulesf 51 | done 52 | done -------------------------------------------------------------------------------- /Android/configure.py: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env python3 2 | import os 3 | 4 | from util import ARCHITECTURES, env_vars, parse_args 5 | 6 | def main(): 7 | args, remaining = parse_args() 8 | os.environ.update(env_vars(args.target_arch_name, args.android_api_level)) 9 | 10 | # CPython requires explicit --build, and its value does not matter 11 | # (e.g., x86_64-linux-gnu should also work on macOS) 12 | cmd = [ 13 | 'bash', './configure', 14 | '--host=' + ARCHITECTURES[args.target_arch_name].ANDROID_TARGET, 15 | '--build=x86_64-linux-gnu', 16 | 'ac_cv_file__dev_ptmx=yes', 17 | 'ac_cv_file__dev_ptc=no', 18 | 'ac_cv_buggy_getaddrinfo=no', # for IPv6 functionality 19 | ] 20 | 21 | os.execvp('bash', cmd + remaining) 22 | 23 | if __name__ == '__main__': 24 | main() 25 | -------------------------------------------------------------------------------- /Android/grph.patch: -------------------------------------------------------------------------------- 1 | --- /android-ndk-r26b/toolchains/llvm/prebuilt/linux-x86_64/sysroot/usr/include/grp.h 2023-10-05 20:43:06.000000000 -0500 2 | +++ /android-ndk-r26b/toolchains/llvm/prebuilt/linux-x86_64/sysroot/usr/include/grp.h 2023-10-11 15:13:45.525034100 -0500 3 | @@ -52,12 +52,12 @@ 4 | 5 | /* Note: Android has thousands and thousands of ids to iterate through. */ 6 | 7 | -#if __ANDROID_API__ >= 26 8 | -struct group* _Nullable getgrent(void) __INTRODUCED_IN(26); 9 | +#if __ANDROID_API__ >= 23 10 | +struct group* _Nullable getgrent(void) __INTRODUCED_IN(23); 11 | 12 | -void setgrent(void) __INTRODUCED_IN(26); 13 | -void endgrent(void) __INTRODUCED_IN(26); 14 | -#endif /* __ANDROID_API__ >= 26 */ 15 | +void setgrent(void) __INTRODUCED_IN(23); 16 | +void endgrent(void) __INTRODUCED_IN(23); 17 | +#endif /* __ANDROID_API__ >= 23 */ 18 | 19 | 20 | #if __ANDROID_API__ >= 24 21 | -------------------------------------------------------------------------------- /Android/patchTrampc.patch: -------------------------------------------------------------------------------- 1 | --- a/Android/deps/libffi-3.4.4/src/tramp.c 2022-10-23 10:23:27.000000000 -0500 2 | +++ b/Android/deps/libffi-3.4.4/src/tramp.c 2023-10-10 15:04:02.008920000 -0500 3 | @@ -249,6 +249,8 @@ 4 | return 1; 5 | } 6 | 7 | +int open_temp_exec_file (void); 8 | + 9 | #endif /* defined (__linux__) || defined (__CYGWIN__) */ 10 | 11 | #if defined (__linux__) || defined (__CYGWIN__) 12 | -------------------------------------------------------------------------------- /Android/trampc.patch: -------------------------------------------------------------------------------- 1 | --- a/Android/deps/libffi-3.4.4/src/tramp.c 2022-10-23 10:23:27.000000000 -0500 2 | +++ b/Android/deps/libffi-3.4.4/src/tramp.c 2023-10-10 15:04:02.008920000 -0500 3 | @@ -249,6 +249,8 @@ 4 | return 1; 5 | } 6 | 7 | +int open_temp_exec_file (void); 8 | + 9 | #endif /* defined (__linux__) || defined (__CYGWIN__) */ 10 | 11 | #if defined (__linux__) || defined (__CYGWIN__) 12 | -------------------------------------------------------------------------------- /Android/unversioned-libpython.patch: -------------------------------------------------------------------------------- 1 | diff --git a/configure.ac b/configure.ac 2 | index 73ee71c6d2..a62edaebae 100644 3 | --- a/configure.ac 4 | +++ b/configure.ac 5 | @@ -1121,7 +1121,10 @@ if test $enable_shared = "yes"; then 6 | LDLIBRARY='libpython$(LDVERSION).so' 7 | BLDLIBRARY='-L. -lpython$(LDVERSION)' 8 | RUNSHARED=LD_LIBRARY_PATH=`pwd`${LD_LIBRARY_PATH:+:${LD_LIBRARY_PATH}} 9 | - INSTSONAME="$LDLIBRARY".$SOVERSION 10 | + if test $ac_sys_system != Linux-android 11 | + then 12 | + INSTSONAME="$LDLIBRARY".$SOVERSION 13 | + fi 14 | if test "$with_pydebug" != yes 15 | then 16 | PY3LIBRARY=libpython3.so 17 | 18 | -------------------------------------------------------------------------------- /AndroidApp/.gitignore: -------------------------------------------------------------------------------- 1 | *.iml 2 | .gradle 3 | /local.properties 4 | /.idea/caches 5 | /.idea/libraries 6 | /.idea/modules.xml 7 | /.idea/workspace.xml 8 | /.idea/navEditor.xml 9 | /.idea/assetWizardSettings.xml 10 | .DS_Store 11 | /build 12 | /captures 13 | .externalNativeBuild 14 | .cxx 15 | .idea 16 | -------------------------------------------------------------------------------- /AndroidApp/app/.gitignore: -------------------------------------------------------------------------------- 1 | /build 2 | -------------------------------------------------------------------------------- /AndroidApp/app/proguard-rules.pro: -------------------------------------------------------------------------------- 1 | # Add project specific ProGuard rules here. 2 | # You can control the set of applied configuration files using the 3 | # proguardFiles setting in build.gradle. 4 | # 5 | # For more details, see 6 | # http://developer.android.com/guide/developing/tools/proguard.html 7 | 8 | # If your project uses WebView with JS, uncomment the following 9 | # and specify the fully qualified class name to the JavaScript interface 10 | # class: 11 | #-keepclassmembers class fqcn.of.javascript.interface.for.webview { 12 | # public *; 13 | #} 14 | 15 | # Uncomment this to preserve the line number information for 16 | # debugging stack traces. 17 | #-keepattributes SourceFile,LineNumberTable 18 | 19 | # If you keep the line number information, uncomment this to 20 | # hide the original source file name. 21 | #-renamesourcefileattribute SourceFile 22 | -------------------------------------------------------------------------------- /AndroidApp/app/src/androidTest/java/com/example/pythontest/Common.java: -------------------------------------------------------------------------------- 1 | package com.example.pythontest; 2 | 3 | import android.content.Context; 4 | import android.os.Build; 5 | 6 | public class Common 7 | { 8 | 9 | public static String getEngineRootDirectory(Context aContext) 10 | { 11 | return aContext.getExternalFilesDir(null).getAbsolutePath(); 12 | } 13 | 14 | public static boolean is64bitProcessor() 15 | { 16 | // The SUPPORTED_ABIS is a String Array with all of the architectures the CPU supports, we are specifically looking to see 17 | // if this one supports 64bit 18 | return (Build.SUPPORTED_64_BIT_ABIS.length > 0); 19 | } 20 | 21 | 22 | } 23 | -------------------------------------------------------------------------------- /AndroidApp/app/src/androidTest/java/com/example/pythontest/ExampleInstrumentedTest.java: -------------------------------------------------------------------------------- 1 | package com.example.pythontest; 2 | 3 | import android.content.Context; 4 | 5 | import androidx.test.platform.app.InstrumentationRegistry; 6 | import androidx.test.ext.junit.runners.AndroidJUnit4; 7 | 8 | import org.junit.Test; 9 | import org.junit.runner.RunWith; 10 | 11 | import static org.junit.Assert.*; 12 | 13 | /** 14 | * Instrumented test, which will execute on an Android device. 15 | * 16 | * @see Testing documentation 17 | */ 18 | @RunWith(AndroidJUnit4.class) 19 | public class ExampleInstrumentedTest 20 | { 21 | @Test 22 | public void useAppContext() 23 | { 24 | // Context of the app under test. 25 | Context appContext = InstrumentationRegistry.getInstrumentation().getTargetContext(); 26 | 27 | assertEquals("com.example.pythontest", appContext.getPackageName()); 28 | } 29 | } 30 | -------------------------------------------------------------------------------- /AndroidApp/app/src/main/AndroidManifest.xml: -------------------------------------------------------------------------------- 1 | 2 | 4 | 5 | 13 | 17 | 18 | 19 | 20 | 21 | 22 | 23 | 24 | 25 | -------------------------------------------------------------------------------- /AndroidApp/app/src/main/assets/Python64.zip: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/GRRedWings/python3-android/d16218a8511e240d23b166ccaf4a384dd0a924bd/AndroidApp/app/src/main/assets/Python64.zip -------------------------------------------------------------------------------- /AndroidApp/app/src/main/assets/Pythonx86_64.zip: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/GRRedWings/python3-android/d16218a8511e240d23b166ccaf4a384dd0a924bd/AndroidApp/app/src/main/assets/Pythonx86_64.zip -------------------------------------------------------------------------------- /AndroidApp/app/src/main/assets/main.py: -------------------------------------------------------------------------------- 1 | 2 | def main(): 3 | import os 4 | dir_path = os.path.dirname(os.path.realpath(__file__)) 5 | out_file = '{}/HelloWorld.txt'.format(dir_path) 6 | with open(out_file, 'a') as the_file: 7 | the_file.write('It works!\n') 8 | 9 | import time 10 | print(time.time()) 11 | with open(out_file, 'a') as the_file: 12 | the_file.write('It Still works!\n') 13 | 14 | import sys 15 | print(sys.version) 16 | print(sys.version_info) 17 | 18 | print('You should see this #1') 19 | try: 20 | import __phello__ 21 | except Exception as e: 22 | print(Exception, e) 23 | print('You should NOT see this!!!!') 24 | finally: 25 | print('You should see this #2') 26 | 27 | 28 | if __name__ == '__main__': 29 | main() 30 | 31 | 32 | -------------------------------------------------------------------------------- /AndroidApp/app/src/main/jni/PythonThread.hpp: -------------------------------------------------------------------------------- 1 | /* DO NOT EDIT THIS FILE - it is machine generated */ 2 | 3 | #include 4 | #include 5 | 6 | #pragma once 7 | 8 | #ifdef __cplusplus 9 | extern "C" { 10 | #endif 11 | 12 | /* 13 | * Class: com_example_pythontest_PythonThread 14 | * Method: initPython 15 | * Signature: ()I 16 | */ 17 | JNIEXPORT jint JNICALL Java_com_example_pythontest_PythonThread_initPython 18 | (JNIEnv *, jobject, jstring initSetupDirectory); 19 | 20 | /* 21 | * Class: com_example_pythontest_PythonThread 22 | * Method: cleanupPython 23 | * Signature: ()I 24 | */ 25 | JNIEXPORT jint JNICALL Java_com_example_pythontest_PythonThread_cleanupPython 26 | (JNIEnv *, jobject); 27 | 28 | /* 29 | * Class: com_example_pythontest_PythonThread 30 | * Method: runPython 31 | * Signature: ()I 32 | */ 33 | JNIEXPORT jlong JNICALL Java_com_example_pythontest_PythonThread_runPython 34 | (JNIEnv *, jobject, jstring filename); 35 | 36 | 37 | 38 | #ifdef __cplusplus 39 | } 40 | #endif 41 | 42 | -------------------------------------------------------------------------------- /AndroidApp/app/src/main/jni/Pythonx86_64/bltinmodule.h: -------------------------------------------------------------------------------- 1 | #ifndef Py_BLTINMODULE_H 2 | #define Py_BLTINMODULE_H 3 | #ifdef __cplusplus 4 | extern "C" { 5 | #endif 6 | 7 | PyAPI_DATA(PyTypeObject) PyFilter_Type; 8 | PyAPI_DATA(PyTypeObject) PyMap_Type; 9 | PyAPI_DATA(PyTypeObject) PyZip_Type; 10 | 11 | #ifdef __cplusplus 12 | } 13 | #endif 14 | #endif /* !Py_BLTINMODULE_H */ 15 | -------------------------------------------------------------------------------- /AndroidApp/app/src/main/jni/Pythonx86_64/boolobject.h: -------------------------------------------------------------------------------- 1 | /* Boolean object interface */ 2 | 3 | #ifndef Py_BOOLOBJECT_H 4 | #define Py_BOOLOBJECT_H 5 | #ifdef __cplusplus 6 | extern "C" { 7 | #endif 8 | 9 | 10 | // PyBool_Type is declared by object.h 11 | 12 | #define PyBool_Check(x) Py_IS_TYPE((x), &PyBool_Type) 13 | 14 | /* Py_False and Py_True are the only two bools in existence. */ 15 | 16 | /* Don't use these directly */ 17 | PyAPI_DATA(PyLongObject) _Py_FalseStruct; 18 | PyAPI_DATA(PyLongObject) _Py_TrueStruct; 19 | 20 | /* Use these macros */ 21 | #define Py_False _PyObject_CAST(&_Py_FalseStruct) 22 | #define Py_True _PyObject_CAST(&_Py_TrueStruct) 23 | 24 | // Test if an object is the True singleton, the same as "x is True" in Python. 25 | PyAPI_FUNC(int) Py_IsTrue(PyObject *x); 26 | #define Py_IsTrue(x) Py_Is((x), Py_True) 27 | 28 | // Test if an object is the False singleton, the same as "x is False" in Python. 29 | PyAPI_FUNC(int) Py_IsFalse(PyObject *x); 30 | #define Py_IsFalse(x) Py_Is((x), Py_False) 31 | 32 | /* Macros for returning Py_True or Py_False, respectively */ 33 | #define Py_RETURN_TRUE return Py_True 34 | #define Py_RETURN_FALSE return Py_False 35 | 36 | /* Function to return a bool from a C long */ 37 | PyAPI_FUNC(PyObject *) PyBool_FromLong(long); 38 | 39 | #ifdef __cplusplus 40 | } 41 | #endif 42 | #endif /* !Py_BOOLOBJECT_H */ 43 | -------------------------------------------------------------------------------- /AndroidApp/app/src/main/jni/Pythonx86_64/bytearrayobject.h: -------------------------------------------------------------------------------- 1 | /* ByteArray object interface */ 2 | 3 | #ifndef Py_BYTEARRAYOBJECT_H 4 | #define Py_BYTEARRAYOBJECT_H 5 | #ifdef __cplusplus 6 | extern "C" { 7 | #endif 8 | 9 | /* Type PyByteArrayObject represents a mutable array of bytes. 10 | * The Python API is that of a sequence; 11 | * the bytes are mapped to ints in [0, 256). 12 | * Bytes are not characters; they may be used to encode characters. 13 | * The only way to go between bytes and str/unicode is via encoding 14 | * and decoding. 15 | * For the convenience of C programmers, the bytes type is considered 16 | * to contain a char pointer, not an unsigned char pointer. 17 | */ 18 | 19 | /* Type object */ 20 | PyAPI_DATA(PyTypeObject) PyByteArray_Type; 21 | PyAPI_DATA(PyTypeObject) PyByteArrayIter_Type; 22 | 23 | /* Type check macros */ 24 | #define PyByteArray_Check(self) PyObject_TypeCheck((self), &PyByteArray_Type) 25 | #define PyByteArray_CheckExact(self) Py_IS_TYPE((self), &PyByteArray_Type) 26 | 27 | /* Direct API functions */ 28 | PyAPI_FUNC(PyObject *) PyByteArray_FromObject(PyObject *); 29 | PyAPI_FUNC(PyObject *) PyByteArray_Concat(PyObject *, PyObject *); 30 | PyAPI_FUNC(PyObject *) PyByteArray_FromStringAndSize(const char *, Py_ssize_t); 31 | PyAPI_FUNC(Py_ssize_t) PyByteArray_Size(PyObject *); 32 | PyAPI_FUNC(char *) PyByteArray_AsString(PyObject *); 33 | PyAPI_FUNC(int) PyByteArray_Resize(PyObject *, Py_ssize_t); 34 | 35 | #ifndef Py_LIMITED_API 36 | # define Py_CPYTHON_BYTEARRAYOBJECT_H 37 | # include "cpython/bytearrayobject.h" 38 | # undef Py_CPYTHON_BYTEARRAYOBJECT_H 39 | #endif 40 | 41 | #ifdef __cplusplus 42 | } 43 | #endif 44 | #endif /* !Py_BYTEARRAYOBJECT_H */ 45 | -------------------------------------------------------------------------------- /AndroidApp/app/src/main/jni/Pythonx86_64/compile.h: -------------------------------------------------------------------------------- 1 | #ifndef Py_COMPILE_H 2 | #define Py_COMPILE_H 3 | #ifdef __cplusplus 4 | extern "C" { 5 | #endif 6 | 7 | /* These definitions must match corresponding definitions in graminit.h. */ 8 | #define Py_single_input 256 9 | #define Py_file_input 257 10 | #define Py_eval_input 258 11 | #define Py_func_type_input 345 12 | 13 | #ifndef Py_LIMITED_API 14 | # define Py_CPYTHON_COMPILE_H 15 | # include "cpython/compile.h" 16 | # undef Py_CPYTHON_COMPILE_H 17 | #endif 18 | 19 | #ifdef __cplusplus 20 | } 21 | #endif 22 | #endif /* !Py_COMPILE_H */ 23 | -------------------------------------------------------------------------------- /AndroidApp/app/src/main/jni/Pythonx86_64/complexobject.h: -------------------------------------------------------------------------------- 1 | /* Complex number structure */ 2 | 3 | #ifndef Py_COMPLEXOBJECT_H 4 | #define Py_COMPLEXOBJECT_H 5 | #ifdef __cplusplus 6 | extern "C" { 7 | #endif 8 | 9 | /* Complex object interface */ 10 | 11 | PyAPI_DATA(PyTypeObject) PyComplex_Type; 12 | 13 | #define PyComplex_Check(op) PyObject_TypeCheck((op), &PyComplex_Type) 14 | #define PyComplex_CheckExact(op) Py_IS_TYPE((op), &PyComplex_Type) 15 | 16 | PyAPI_FUNC(PyObject *) PyComplex_FromDoubles(double real, double imag); 17 | 18 | PyAPI_FUNC(double) PyComplex_RealAsDouble(PyObject *op); 19 | PyAPI_FUNC(double) PyComplex_ImagAsDouble(PyObject *op); 20 | 21 | #ifndef Py_LIMITED_API 22 | # define Py_CPYTHON_COMPLEXOBJECT_H 23 | # include "cpython/complexobject.h" 24 | # undef Py_CPYTHON_COMPLEXOBJECT_H 25 | #endif 26 | 27 | #ifdef __cplusplus 28 | } 29 | #endif 30 | #endif /* !Py_COMPLEXOBJECT_H */ 31 | -------------------------------------------------------------------------------- /AndroidApp/app/src/main/jni/Pythonx86_64/cpython/bytearrayobject.h: -------------------------------------------------------------------------------- 1 | #ifndef Py_CPYTHON_BYTEARRAYOBJECT_H 2 | # error "this header file must not be included directly" 3 | #endif 4 | 5 | /* Object layout */ 6 | typedef struct { 7 | PyObject_VAR_HEAD 8 | Py_ssize_t ob_alloc; /* How many bytes allocated in ob_bytes */ 9 | char *ob_bytes; /* Physical backing buffer */ 10 | char *ob_start; /* Logical start inside ob_bytes */ 11 | Py_ssize_t ob_exports; /* How many buffer exports */ 12 | } PyByteArrayObject; 13 | 14 | PyAPI_DATA(char) _PyByteArray_empty_string[]; 15 | 16 | /* Macros and static inline functions, trading safety for speed */ 17 | #define _PyByteArray_CAST(op) \ 18 | (assert(PyByteArray_Check(op)), _Py_CAST(PyByteArrayObject*, op)) 19 | 20 | static inline char* PyByteArray_AS_STRING(PyObject *op) 21 | { 22 | PyByteArrayObject *self = _PyByteArray_CAST(op); 23 | if (Py_SIZE(self)) { 24 | return self->ob_start; 25 | } 26 | return _PyByteArray_empty_string; 27 | } 28 | #define PyByteArray_AS_STRING(self) PyByteArray_AS_STRING(_PyObject_CAST(self)) 29 | 30 | static inline Py_ssize_t PyByteArray_GET_SIZE(PyObject *op) { 31 | PyByteArrayObject *self = _PyByteArray_CAST(op); 32 | return Py_SIZE(self); 33 | } 34 | #define PyByteArray_GET_SIZE(self) PyByteArray_GET_SIZE(_PyObject_CAST(self)) 35 | -------------------------------------------------------------------------------- /AndroidApp/app/src/main/jni/Pythonx86_64/cpython/cellobject.h: -------------------------------------------------------------------------------- 1 | /* Cell object interface */ 2 | 3 | #ifndef Py_LIMITED_API 4 | #ifndef Py_CELLOBJECT_H 5 | #define Py_CELLOBJECT_H 6 | #ifdef __cplusplus 7 | extern "C" { 8 | #endif 9 | 10 | typedef struct { 11 | PyObject_HEAD 12 | /* Content of the cell or NULL when empty */ 13 | PyObject *ob_ref; 14 | } PyCellObject; 15 | 16 | PyAPI_DATA(PyTypeObject) PyCell_Type; 17 | 18 | #define PyCell_Check(op) Py_IS_TYPE((op), &PyCell_Type) 19 | 20 | PyAPI_FUNC(PyObject *) PyCell_New(PyObject *); 21 | PyAPI_FUNC(PyObject *) PyCell_Get(PyObject *); 22 | PyAPI_FUNC(int) PyCell_Set(PyObject *, PyObject *); 23 | 24 | static inline PyObject* PyCell_GET(PyObject *op) { 25 | PyCellObject *cell; 26 | assert(PyCell_Check(op)); 27 | cell = _Py_CAST(PyCellObject*, op); 28 | return cell->ob_ref; 29 | } 30 | #define PyCell_GET(op) PyCell_GET(_PyObject_CAST(op)) 31 | 32 | static inline void PyCell_SET(PyObject *op, PyObject *value) { 33 | PyCellObject *cell; 34 | assert(PyCell_Check(op)); 35 | cell = _Py_CAST(PyCellObject*, op); 36 | cell->ob_ref = value; 37 | } 38 | #define PyCell_SET(op, value) PyCell_SET(_PyObject_CAST(op), (value)) 39 | 40 | #ifdef __cplusplus 41 | } 42 | #endif 43 | #endif /* !Py_TUPLEOBJECT_H */ 44 | #endif /* Py_LIMITED_API */ 45 | -------------------------------------------------------------------------------- /AndroidApp/app/src/main/jni/Pythonx86_64/cpython/ceval.h: -------------------------------------------------------------------------------- 1 | #ifndef Py_CPYTHON_CEVAL_H 2 | # error "this header file must not be included directly" 3 | #endif 4 | 5 | PyAPI_FUNC(void) PyEval_SetProfile(Py_tracefunc, PyObject *); 6 | PyAPI_FUNC(void) PyEval_SetProfileAllThreads(Py_tracefunc, PyObject *); 7 | PyAPI_DATA(int) _PyEval_SetProfile(PyThreadState *tstate, Py_tracefunc func, PyObject *arg); 8 | PyAPI_FUNC(void) PyEval_SetTrace(Py_tracefunc, PyObject *); 9 | PyAPI_FUNC(void) PyEval_SetTraceAllThreads(Py_tracefunc, PyObject *); 10 | PyAPI_FUNC(int) _PyEval_SetTrace(PyThreadState *tstate, Py_tracefunc func, PyObject *arg); 11 | 12 | /* Helper to look up a builtin object */ 13 | PyAPI_FUNC(PyObject *) _PyEval_GetBuiltin(PyObject *); 14 | PyAPI_FUNC(PyObject *) _PyEval_GetBuiltinId(_Py_Identifier *); 15 | /* Look at the current frame's (if any) code's co_flags, and turn on 16 | the corresponding compiler flags in cf->cf_flags. Return 1 if any 17 | flag was set, else return 0. */ 18 | PyAPI_FUNC(int) PyEval_MergeCompilerFlags(PyCompilerFlags *cf); 19 | 20 | PyAPI_FUNC(PyObject *) _PyEval_EvalFrameDefault(PyThreadState *tstate, struct _PyInterpreterFrame *f, int exc); 21 | 22 | PyAPI_FUNC(void) _PyEval_SetSwitchInterval(unsigned long microseconds); 23 | PyAPI_FUNC(unsigned long) _PyEval_GetSwitchInterval(void); 24 | 25 | PyAPI_FUNC(int) _PyEval_MakePendingCalls(PyThreadState *); 26 | 27 | PyAPI_FUNC(Py_ssize_t) PyUnstable_Eval_RequestCodeExtraIndex(freefunc); 28 | // Old name -- remove when this API changes: 29 | _Py_DEPRECATED_EXTERNALLY(3.12) static inline Py_ssize_t 30 | _PyEval_RequestCodeExtraIndex(freefunc f) { 31 | return PyUnstable_Eval_RequestCodeExtraIndex(f); 32 | } 33 | 34 | PyAPI_FUNC(int) _PyEval_SliceIndex(PyObject *, Py_ssize_t *); 35 | PyAPI_FUNC(int) _PyEval_SliceIndexNotNone(PyObject *, Py_ssize_t *); 36 | -------------------------------------------------------------------------------- /AndroidApp/app/src/main/jni/Pythonx86_64/cpython/complexobject.h: -------------------------------------------------------------------------------- 1 | #ifndef Py_CPYTHON_COMPLEXOBJECT_H 2 | # error "this header file must not be included directly" 3 | #endif 4 | 5 | typedef struct { 6 | double real; 7 | double imag; 8 | } Py_complex; 9 | 10 | /* Operations on complex numbers from complexmodule.c */ 11 | 12 | PyAPI_FUNC(Py_complex) _Py_c_sum(Py_complex, Py_complex); 13 | PyAPI_FUNC(Py_complex) _Py_c_diff(Py_complex, Py_complex); 14 | PyAPI_FUNC(Py_complex) _Py_c_neg(Py_complex); 15 | PyAPI_FUNC(Py_complex) _Py_c_prod(Py_complex, Py_complex); 16 | PyAPI_FUNC(Py_complex) _Py_c_quot(Py_complex, Py_complex); 17 | PyAPI_FUNC(Py_complex) _Py_c_pow(Py_complex, Py_complex); 18 | PyAPI_FUNC(double) _Py_c_abs(Py_complex); 19 | 20 | /* Complex object interface */ 21 | 22 | /* 23 | PyComplexObject represents a complex number with double-precision 24 | real and imaginary parts. 25 | */ 26 | typedef struct { 27 | PyObject_HEAD 28 | Py_complex cval; 29 | } PyComplexObject; 30 | 31 | PyAPI_FUNC(PyObject *) PyComplex_FromCComplex(Py_complex); 32 | 33 | PyAPI_FUNC(Py_complex) PyComplex_AsCComplex(PyObject *op); 34 | 35 | #ifdef Py_BUILD_CORE 36 | /* Format the object based on the format_spec, as defined in PEP 3101 37 | (Advanced String Formatting). */ 38 | extern int _PyComplex_FormatAdvancedWriter( 39 | _PyUnicodeWriter *writer, 40 | PyObject *obj, 41 | PyObject *format_spec, 42 | Py_ssize_t start, 43 | Py_ssize_t end); 44 | #endif // Py_BUILD_CORE 45 | -------------------------------------------------------------------------------- /AndroidApp/app/src/main/jni/Pythonx86_64/cpython/fileobject.h: -------------------------------------------------------------------------------- 1 | #ifndef Py_CPYTHON_FILEOBJECT_H 2 | # error "this header file must not be included directly" 3 | #endif 4 | 5 | PyAPI_FUNC(char *) Py_UniversalNewlineFgets(char *, int, FILE*, PyObject *); 6 | PyAPI_FUNC(char *) _Py_UniversalNewlineFgetsWithSize(char *, int, FILE*, PyObject *, size_t*); 7 | 8 | /* The std printer acts as a preliminary sys.stderr until the new io 9 | infrastructure is in place. */ 10 | PyAPI_FUNC(PyObject *) PyFile_NewStdPrinter(int); 11 | PyAPI_DATA(PyTypeObject) PyStdPrinter_Type; 12 | 13 | typedef PyObject * (*Py_OpenCodeHookFunction)(PyObject *, void *); 14 | 15 | PyAPI_FUNC(PyObject *) PyFile_OpenCode(const char *utf8path); 16 | PyAPI_FUNC(PyObject *) PyFile_OpenCodeObject(PyObject *path); 17 | PyAPI_FUNC(int) PyFile_SetOpenCodeHook(Py_OpenCodeHookFunction hook, void *userData); 18 | 19 | PyAPI_FUNC(int) _PyLong_FileDescriptor_Converter(PyObject *, void *); 20 | -------------------------------------------------------------------------------- /AndroidApp/app/src/main/jni/Pythonx86_64/cpython/fileutils.h: -------------------------------------------------------------------------------- 1 | #ifndef Py_CPYTHON_FILEUTILS_H 2 | # error "this header file must not be included directly" 3 | #endif 4 | 5 | // Used by _testcapi which must not use the internal C API 6 | PyAPI_FUNC(FILE*) _Py_fopen_obj( 7 | PyObject *path, 8 | const char *mode); 9 | -------------------------------------------------------------------------------- /AndroidApp/app/src/main/jni/Pythonx86_64/cpython/floatobject.h: -------------------------------------------------------------------------------- 1 | #ifndef Py_CPYTHON_FLOATOBJECT_H 2 | # error "this header file must not be included directly" 3 | #endif 4 | 5 | typedef struct { 6 | PyObject_HEAD 7 | double ob_fval; 8 | } PyFloatObject; 9 | 10 | #define _PyFloat_CAST(op) \ 11 | (assert(PyFloat_Check(op)), _Py_CAST(PyFloatObject*, op)) 12 | 13 | // Static inline version of PyFloat_AsDouble() trading safety for speed. 14 | // It doesn't check if op is a double object. 15 | static inline double PyFloat_AS_DOUBLE(PyObject *op) { 16 | return _PyFloat_CAST(op)->ob_fval; 17 | } 18 | #define PyFloat_AS_DOUBLE(op) PyFloat_AS_DOUBLE(_PyObject_CAST(op)) 19 | 20 | 21 | PyAPI_FUNC(int) PyFloat_Pack2(double x, char *p, int le); 22 | PyAPI_FUNC(int) PyFloat_Pack4(double x, char *p, int le); 23 | PyAPI_FUNC(int) PyFloat_Pack8(double x, char *p, int le); 24 | 25 | PyAPI_FUNC(double) PyFloat_Unpack2(const char *p, int le); 26 | PyAPI_FUNC(double) PyFloat_Unpack4(const char *p, int le); 27 | PyAPI_FUNC(double) PyFloat_Unpack8(const char *p, int le); 28 | -------------------------------------------------------------------------------- /AndroidApp/app/src/main/jni/Pythonx86_64/cpython/frameobject.h: -------------------------------------------------------------------------------- 1 | /* Frame object interface */ 2 | 3 | #ifndef Py_CPYTHON_FRAMEOBJECT_H 4 | # error "this header file must not be included directly" 5 | #endif 6 | 7 | /* Standard object interface */ 8 | 9 | PyAPI_FUNC(PyFrameObject *) PyFrame_New(PyThreadState *, PyCodeObject *, 10 | PyObject *, PyObject *); 11 | 12 | /* The rest of the interface is specific for frame objects */ 13 | 14 | /* Conversions between "fast locals" and locals in dictionary */ 15 | 16 | PyAPI_FUNC(void) PyFrame_LocalsToFast(PyFrameObject *, int); 17 | 18 | /* -- Caveat emptor -- 19 | * The concept of entry frames is an implementation detail of the CPython 20 | * interpreter. This API is considered unstable and is provided for the 21 | * convenience of debuggers, profilers and state-inspecting tools. Notice that 22 | * this API can be changed in future minor versions if the underlying frame 23 | * mechanism change or the concept of an 'entry frame' or its semantics becomes 24 | * obsolete or outdated. */ 25 | 26 | PyAPI_FUNC(int) _PyFrame_IsEntryFrame(PyFrameObject *frame); 27 | 28 | PyAPI_FUNC(int) PyFrame_FastToLocalsWithError(PyFrameObject *f); 29 | PyAPI_FUNC(void) PyFrame_FastToLocals(PyFrameObject *); 30 | -------------------------------------------------------------------------------- /AndroidApp/app/src/main/jni/Pythonx86_64/cpython/interpreteridobject.h: -------------------------------------------------------------------------------- 1 | #ifndef Py_CPYTHON_INTERPRETERIDOBJECT_H 2 | # error "this header file must not be included directly" 3 | #endif 4 | 5 | /* Interpreter ID Object */ 6 | 7 | PyAPI_DATA(PyTypeObject) _PyInterpreterID_Type; 8 | 9 | PyAPI_FUNC(PyObject *) _PyInterpreterID_New(int64_t); 10 | PyAPI_FUNC(PyObject *) _PyInterpreterState_GetIDObject(PyInterpreterState *); 11 | PyAPI_FUNC(PyInterpreterState *) _PyInterpreterID_LookUp(PyObject *); 12 | -------------------------------------------------------------------------------- /AndroidApp/app/src/main/jni/Pythonx86_64/cpython/odictobject.h: -------------------------------------------------------------------------------- 1 | #ifndef Py_ODICTOBJECT_H 2 | #define Py_ODICTOBJECT_H 3 | #ifdef __cplusplus 4 | extern "C" { 5 | #endif 6 | 7 | 8 | /* OrderedDict */ 9 | /* This API is optional and mostly redundant. */ 10 | 11 | #ifndef Py_LIMITED_API 12 | 13 | typedef struct _odictobject PyODictObject; 14 | 15 | PyAPI_DATA(PyTypeObject) PyODict_Type; 16 | PyAPI_DATA(PyTypeObject) PyODictIter_Type; 17 | PyAPI_DATA(PyTypeObject) PyODictKeys_Type; 18 | PyAPI_DATA(PyTypeObject) PyODictItems_Type; 19 | PyAPI_DATA(PyTypeObject) PyODictValues_Type; 20 | 21 | #define PyODict_Check(op) PyObject_TypeCheck((op), &PyODict_Type) 22 | #define PyODict_CheckExact(op) Py_IS_TYPE((op), &PyODict_Type) 23 | #define PyODict_SIZE(op) PyDict_GET_SIZE((op)) 24 | 25 | PyAPI_FUNC(PyObject *) PyODict_New(void); 26 | PyAPI_FUNC(int) PyODict_SetItem(PyObject *od, PyObject *key, PyObject *item); 27 | PyAPI_FUNC(int) PyODict_DelItem(PyObject *od, PyObject *key); 28 | 29 | /* wrappers around PyDict* functions */ 30 | #define PyODict_GetItem(od, key) PyDict_GetItem(_PyObject_CAST(od), (key)) 31 | #define PyODict_GetItemWithError(od, key) \ 32 | PyDict_GetItemWithError(_PyObject_CAST(od), (key)) 33 | #define PyODict_Contains(od, key) PyDict_Contains(_PyObject_CAST(od), (key)) 34 | #define PyODict_Size(od) PyDict_Size(_PyObject_CAST(od)) 35 | #define PyODict_GetItemString(od, key) \ 36 | PyDict_GetItemString(_PyObject_CAST(od), (key)) 37 | 38 | #endif 39 | 40 | #ifdef __cplusplus 41 | } 42 | #endif 43 | #endif /* !Py_ODICTOBJECT_H */ 44 | -------------------------------------------------------------------------------- /AndroidApp/app/src/main/jni/Pythonx86_64/cpython/picklebufobject.h: -------------------------------------------------------------------------------- 1 | /* PickleBuffer object. This is built-in for ease of use from third-party 2 | * C extensions. 3 | */ 4 | 5 | #ifndef Py_PICKLEBUFOBJECT_H 6 | #define Py_PICKLEBUFOBJECT_H 7 | #ifdef __cplusplus 8 | extern "C" { 9 | #endif 10 | 11 | #ifndef Py_LIMITED_API 12 | 13 | PyAPI_DATA(PyTypeObject) PyPickleBuffer_Type; 14 | 15 | #define PyPickleBuffer_Check(op) Py_IS_TYPE((op), &PyPickleBuffer_Type) 16 | 17 | /* Create a PickleBuffer redirecting to the given buffer-enabled object */ 18 | PyAPI_FUNC(PyObject *) PyPickleBuffer_FromObject(PyObject *); 19 | /* Get the PickleBuffer's underlying view to the original object 20 | * (NULL if released) 21 | */ 22 | PyAPI_FUNC(const Py_buffer *) PyPickleBuffer_GetBuffer(PyObject *); 23 | /* Release the PickleBuffer. Returns 0 on success, -1 on error. */ 24 | PyAPI_FUNC(int) PyPickleBuffer_Release(PyObject *); 25 | 26 | #endif /* !Py_LIMITED_API */ 27 | 28 | #ifdef __cplusplus 29 | } 30 | #endif 31 | #endif /* !Py_PICKLEBUFOBJECT_H */ 32 | -------------------------------------------------------------------------------- /AndroidApp/app/src/main/jni/Pythonx86_64/cpython/pyctype.h: -------------------------------------------------------------------------------- 1 | #ifndef Py_LIMITED_API 2 | #ifndef PYCTYPE_H 3 | #define PYCTYPE_H 4 | #ifdef __cplusplus 5 | extern "C" { 6 | #endif 7 | 8 | #define PY_CTF_LOWER 0x01 9 | #define PY_CTF_UPPER 0x02 10 | #define PY_CTF_ALPHA (PY_CTF_LOWER|PY_CTF_UPPER) 11 | #define PY_CTF_DIGIT 0x04 12 | #define PY_CTF_ALNUM (PY_CTF_ALPHA|PY_CTF_DIGIT) 13 | #define PY_CTF_SPACE 0x08 14 | #define PY_CTF_XDIGIT 0x10 15 | 16 | PyAPI_DATA(const unsigned int) _Py_ctype_table[256]; 17 | 18 | /* Unlike their C counterparts, the following macros are not meant to 19 | * handle an int with any of the values [EOF, 0-UCHAR_MAX]. The argument 20 | * must be a signed/unsigned char. */ 21 | #define Py_ISLOWER(c) (_Py_ctype_table[Py_CHARMASK(c)] & PY_CTF_LOWER) 22 | #define Py_ISUPPER(c) (_Py_ctype_table[Py_CHARMASK(c)] & PY_CTF_UPPER) 23 | #define Py_ISALPHA(c) (_Py_ctype_table[Py_CHARMASK(c)] & PY_CTF_ALPHA) 24 | #define Py_ISDIGIT(c) (_Py_ctype_table[Py_CHARMASK(c)] & PY_CTF_DIGIT) 25 | #define Py_ISXDIGIT(c) (_Py_ctype_table[Py_CHARMASK(c)] & PY_CTF_XDIGIT) 26 | #define Py_ISALNUM(c) (_Py_ctype_table[Py_CHARMASK(c)] & PY_CTF_ALNUM) 27 | #define Py_ISSPACE(c) (_Py_ctype_table[Py_CHARMASK(c)] & PY_CTF_SPACE) 28 | 29 | PyAPI_DATA(const unsigned char) _Py_ctype_tolower[256]; 30 | PyAPI_DATA(const unsigned char) _Py_ctype_toupper[256]; 31 | 32 | #define Py_TOLOWER(c) (_Py_ctype_tolower[Py_CHARMASK(c)]) 33 | #define Py_TOUPPER(c) (_Py_ctype_toupper[Py_CHARMASK(c)]) 34 | 35 | #ifdef __cplusplus 36 | } 37 | #endif 38 | #endif /* !PYCTYPE_H */ 39 | #endif /* !Py_LIMITED_API */ 40 | -------------------------------------------------------------------------------- /AndroidApp/app/src/main/jni/Pythonx86_64/cpython/pydebug.h: -------------------------------------------------------------------------------- 1 | #ifndef Py_LIMITED_API 2 | #ifndef Py_PYDEBUG_H 3 | #define Py_PYDEBUG_H 4 | #ifdef __cplusplus 5 | extern "C" { 6 | #endif 7 | 8 | Py_DEPRECATED(3.12) PyAPI_DATA(int) Py_DebugFlag; 9 | Py_DEPRECATED(3.12) PyAPI_DATA(int) Py_VerboseFlag; 10 | Py_DEPRECATED(3.12) PyAPI_DATA(int) Py_QuietFlag; 11 | Py_DEPRECATED(3.12) PyAPI_DATA(int) Py_InteractiveFlag; 12 | Py_DEPRECATED(3.12) PyAPI_DATA(int) Py_InspectFlag; 13 | Py_DEPRECATED(3.12) PyAPI_DATA(int) Py_OptimizeFlag; 14 | Py_DEPRECATED(3.12) PyAPI_DATA(int) Py_NoSiteFlag; 15 | Py_DEPRECATED(3.12) PyAPI_DATA(int) Py_BytesWarningFlag; 16 | Py_DEPRECATED(3.12) PyAPI_DATA(int) Py_FrozenFlag; 17 | Py_DEPRECATED(3.12) PyAPI_DATA(int) Py_IgnoreEnvironmentFlag; 18 | Py_DEPRECATED(3.12) PyAPI_DATA(int) Py_DontWriteBytecodeFlag; 19 | Py_DEPRECATED(3.12) PyAPI_DATA(int) Py_NoUserSiteDirectory; 20 | Py_DEPRECATED(3.12) PyAPI_DATA(int) Py_UnbufferedStdioFlag; 21 | Py_DEPRECATED(3.12) PyAPI_DATA(int) Py_HashRandomizationFlag; 22 | Py_DEPRECATED(3.12) PyAPI_DATA(int) Py_IsolatedFlag; 23 | 24 | #ifdef MS_WINDOWS 25 | Py_DEPRECATED(3.12) PyAPI_DATA(int) Py_LegacyWindowsFSEncodingFlag; 26 | Py_DEPRECATED(3.12) PyAPI_DATA(int) Py_LegacyWindowsStdioFlag; 27 | #endif 28 | 29 | /* this is a wrapper around getenv() that pays attention to 30 | Py_IgnoreEnvironmentFlag. It should be used for getting variables like 31 | PYTHONPATH and PYTHONHOME from the environment */ 32 | PyAPI_FUNC(char*) Py_GETENV(const char *name); 33 | 34 | #ifdef __cplusplus 35 | } 36 | #endif 37 | #endif /* !Py_PYDEBUG_H */ 38 | #endif /* Py_LIMITED_API */ 39 | -------------------------------------------------------------------------------- /AndroidApp/app/src/main/jni/Pythonx86_64/cpython/pyfpe.h: -------------------------------------------------------------------------------- 1 | #ifndef Py_PYFPE_H 2 | #define Py_PYFPE_H 3 | /* Header excluded from the stable API */ 4 | #ifndef Py_LIMITED_API 5 | 6 | /* These macros used to do something when Python was built with --with-fpectl, 7 | * but support for that was dropped in 3.7. We continue to define them though, 8 | * to avoid breaking API users. 9 | */ 10 | 11 | #define PyFPE_START_PROTECT(err_string, leave_stmt) 12 | #define PyFPE_END_PROTECT(v) 13 | 14 | #endif /* !defined(Py_LIMITED_API) */ 15 | #endif /* !Py_PYFPE_H */ 16 | -------------------------------------------------------------------------------- /AndroidApp/app/src/main/jni/Pythonx86_64/cpython/pyframe.h: -------------------------------------------------------------------------------- 1 | #ifndef Py_CPYTHON_PYFRAME_H 2 | # error "this header file must not be included directly" 3 | #endif 4 | 5 | PyAPI_DATA(PyTypeObject) PyFrame_Type; 6 | 7 | #define PyFrame_Check(op) Py_IS_TYPE((op), &PyFrame_Type) 8 | 9 | PyAPI_FUNC(PyFrameObject *) PyFrame_GetBack(PyFrameObject *frame); 10 | PyAPI_FUNC(PyObject *) PyFrame_GetLocals(PyFrameObject *frame); 11 | 12 | PyAPI_FUNC(PyObject *) PyFrame_GetGlobals(PyFrameObject *frame); 13 | PyAPI_FUNC(PyObject *) PyFrame_GetBuiltins(PyFrameObject *frame); 14 | 15 | PyAPI_FUNC(PyObject *) PyFrame_GetGenerator(PyFrameObject *frame); 16 | PyAPI_FUNC(int) PyFrame_GetLasti(PyFrameObject *frame); 17 | PyAPI_FUNC(PyObject*) PyFrame_GetVar(PyFrameObject *frame, PyObject *name); 18 | PyAPI_FUNC(PyObject*) PyFrame_GetVarString(PyFrameObject *frame, const char *name); 19 | 20 | /* The following functions are for use by debuggers and other tools 21 | * implementing custom frame evaluators with PEP 523. */ 22 | 23 | struct _PyInterpreterFrame; 24 | 25 | /* Returns the code object of the frame (strong reference). 26 | * Does not raise an exception. */ 27 | PyAPI_FUNC(PyObject *) PyUnstable_InterpreterFrame_GetCode(struct _PyInterpreterFrame *frame); 28 | 29 | /* Returns a byte ofsset into the last executed instruction. 30 | * Does not raise an exception. */ 31 | PyAPI_FUNC(int) PyUnstable_InterpreterFrame_GetLasti(struct _PyInterpreterFrame *frame); 32 | 33 | /* Returns the currently executing line number, or -1 if there is no line number. 34 | * Does not raise an exception. */ 35 | PyAPI_FUNC(int) PyUnstable_InterpreterFrame_GetLine(struct _PyInterpreterFrame *frame); 36 | -------------------------------------------------------------------------------- /AndroidApp/app/src/main/jni/Pythonx86_64/cpython/pythread.h: -------------------------------------------------------------------------------- 1 | #ifndef Py_CPYTHON_PYTHREAD_H 2 | # error "this header file must not be included directly" 3 | #endif 4 | 5 | #define PYTHREAD_INVALID_THREAD_ID ((unsigned long)-1) 6 | 7 | #ifdef HAVE_FORK 8 | /* Private function to reinitialize a lock at fork in the child process. 9 | Reset the lock to the unlocked state. 10 | Return 0 on success, return -1 on error. */ 11 | PyAPI_FUNC(int) _PyThread_at_fork_reinit(PyThread_type_lock *lock); 12 | #endif /* HAVE_FORK */ 13 | 14 | #ifdef HAVE_PTHREAD_H 15 | /* Darwin needs pthread.h to know type name the pthread_key_t. */ 16 | # include 17 | # define NATIVE_TSS_KEY_T pthread_key_t 18 | #elif defined(NT_THREADS) 19 | /* In Windows, native TSS key type is DWORD, 20 | but hardcode the unsigned long to avoid errors for include directive. 21 | */ 22 | # define NATIVE_TSS_KEY_T unsigned long 23 | #elif defined(HAVE_PTHREAD_STUBS) 24 | # include "cpython/pthread_stubs.h" 25 | # define NATIVE_TSS_KEY_T pthread_key_t 26 | #else 27 | # error "Require native threads. See https://bugs.python.org/issue31370" 28 | #endif 29 | 30 | /* When Py_LIMITED_API is not defined, the type layout of Py_tss_t is 31 | exposed to allow static allocation in the API clients. Even in this case, 32 | you must handle TSS keys through API functions due to compatibility. 33 | */ 34 | struct _Py_tss_t { 35 | int _is_initialized; 36 | NATIVE_TSS_KEY_T _key; 37 | }; 38 | 39 | #undef NATIVE_TSS_KEY_T 40 | 41 | /* When static allocation, you must initialize with Py_tss_NEEDS_INIT. */ 42 | #define Py_tss_NEEDS_INIT {0} 43 | -------------------------------------------------------------------------------- /AndroidApp/app/src/main/jni/Pythonx86_64/cpython/sysmodule.h: -------------------------------------------------------------------------------- 1 | #ifndef Py_CPYTHON_SYSMODULE_H 2 | # error "this header file must not be included directly" 3 | #endif 4 | 5 | PyAPI_FUNC(PyObject *) _PySys_GetAttr(PyThreadState *tstate, 6 | PyObject *name); 7 | 8 | PyAPI_FUNC(size_t) _PySys_GetSizeOf(PyObject *); 9 | 10 | typedef int(*Py_AuditHookFunction)(const char *, PyObject *, void *); 11 | 12 | PyAPI_FUNC(int) PySys_Audit( 13 | const char *event, 14 | const char *argFormat, 15 | ...); 16 | PyAPI_FUNC(int) PySys_AddAuditHook(Py_AuditHookFunction, void*); 17 | -------------------------------------------------------------------------------- /AndroidApp/app/src/main/jni/Pythonx86_64/cpython/traceback.h: -------------------------------------------------------------------------------- 1 | #ifndef Py_CPYTHON_TRACEBACK_H 2 | # error "this header file must not be included directly" 3 | #endif 4 | 5 | typedef struct _traceback PyTracebackObject; 6 | 7 | struct _traceback { 8 | PyObject_HEAD 9 | PyTracebackObject *tb_next; 10 | PyFrameObject *tb_frame; 11 | int tb_lasti; 12 | int tb_lineno; 13 | }; 14 | 15 | PyAPI_FUNC(int) _Py_DisplaySourceLine(PyObject *, PyObject *, int, int, int *, PyObject **); 16 | PyAPI_FUNC(void) _PyTraceback_Add(const char *, const char *, int); 17 | -------------------------------------------------------------------------------- /AndroidApp/app/src/main/jni/Pythonx86_64/cpython/tupleobject.h: -------------------------------------------------------------------------------- 1 | #ifndef Py_CPYTHON_TUPLEOBJECT_H 2 | # error "this header file must not be included directly" 3 | #endif 4 | 5 | typedef struct { 6 | PyObject_VAR_HEAD 7 | /* ob_item contains space for 'ob_size' elements. 8 | Items must normally not be NULL, except during construction when 9 | the tuple is not yet visible outside the function that builds it. */ 10 | PyObject *ob_item[1]; 11 | } PyTupleObject; 12 | 13 | PyAPI_FUNC(int) _PyTuple_Resize(PyObject **, Py_ssize_t); 14 | PyAPI_FUNC(void) _PyTuple_MaybeUntrack(PyObject *); 15 | 16 | /* Cast argument to PyTupleObject* type. */ 17 | #define _PyTuple_CAST(op) \ 18 | (assert(PyTuple_Check(op)), _Py_CAST(PyTupleObject*, (op))) 19 | 20 | // Macros and static inline functions, trading safety for speed 21 | 22 | static inline Py_ssize_t PyTuple_GET_SIZE(PyObject *op) { 23 | PyTupleObject *tuple = _PyTuple_CAST(op); 24 | return Py_SIZE(tuple); 25 | } 26 | #define PyTuple_GET_SIZE(op) PyTuple_GET_SIZE(_PyObject_CAST(op)) 27 | 28 | #define PyTuple_GET_ITEM(op, index) (_PyTuple_CAST(op)->ob_item[(index)]) 29 | 30 | /* Function *only* to be used to fill in brand new tuples */ 31 | static inline void 32 | PyTuple_SET_ITEM(PyObject *op, Py_ssize_t index, PyObject *value) { 33 | PyTupleObject *tuple = _PyTuple_CAST(op); 34 | tuple->ob_item[index] = value; 35 | } 36 | #define PyTuple_SET_ITEM(op, index, value) \ 37 | PyTuple_SET_ITEM(_PyObject_CAST(op), (index), _PyObject_CAST(value)) 38 | 39 | PyAPI_FUNC(void) _PyTuple_DebugMallocStats(FILE *out); 40 | -------------------------------------------------------------------------------- /AndroidApp/app/src/main/jni/Pythonx86_64/cpython/warnings.h: -------------------------------------------------------------------------------- 1 | #ifndef Py_CPYTHON_WARNINGS_H 2 | # error "this header file must not be included directly" 3 | #endif 4 | 5 | PyAPI_FUNC(int) PyErr_WarnExplicitObject( 6 | PyObject *category, 7 | PyObject *message, 8 | PyObject *filename, 9 | int lineno, 10 | PyObject *module, 11 | PyObject *registry); 12 | 13 | PyAPI_FUNC(int) PyErr_WarnExplicitFormat( 14 | PyObject *category, 15 | const char *filename, int lineno, 16 | const char *module, PyObject *registry, 17 | const char *format, ...); 18 | 19 | // DEPRECATED: Use PyErr_WarnEx() instead. 20 | #define PyErr_Warn(category, msg) PyErr_WarnEx((category), (msg), 1) 21 | -------------------------------------------------------------------------------- /AndroidApp/app/src/main/jni/Pythonx86_64/enumobject.h: -------------------------------------------------------------------------------- 1 | #ifndef Py_ENUMOBJECT_H 2 | #define Py_ENUMOBJECT_H 3 | 4 | /* Enumerate Object */ 5 | 6 | #ifdef __cplusplus 7 | extern "C" { 8 | #endif 9 | 10 | PyAPI_DATA(PyTypeObject) PyEnum_Type; 11 | PyAPI_DATA(PyTypeObject) PyReversed_Type; 12 | 13 | #ifdef __cplusplus 14 | } 15 | #endif 16 | 17 | #endif /* !Py_ENUMOBJECT_H */ 18 | -------------------------------------------------------------------------------- /AndroidApp/app/src/main/jni/Pythonx86_64/exports.h: -------------------------------------------------------------------------------- 1 | #ifndef Py_EXPORTS_H 2 | #define Py_EXPORTS_H 3 | 4 | #if defined(_WIN32) || defined(__CYGWIN__) 5 | #if defined(Py_ENABLE_SHARED) 6 | #define Py_IMPORTED_SYMBOL __declspec(dllimport) 7 | #define Py_EXPORTED_SYMBOL __declspec(dllexport) 8 | #define Py_LOCAL_SYMBOL 9 | #else 10 | #define Py_IMPORTED_SYMBOL 11 | #define Py_EXPORTED_SYMBOL 12 | #define Py_LOCAL_SYMBOL 13 | #endif 14 | #else 15 | /* 16 | * If we only ever used gcc >= 5, we could use __has_attribute(visibility) 17 | * as a cross-platform way to determine if visibility is supported. However, 18 | * we may still need to support gcc >= 4, as some Ubuntu LTS and Centos versions 19 | * have 4 < gcc < 5. 20 | */ 21 | #ifndef __has_attribute 22 | #define __has_attribute(x) 0 // Compatibility with non-clang compilers. 23 | #endif 24 | #if (defined(__GNUC__) && (__GNUC__ >= 4)) ||\ 25 | (defined(__clang__) && __has_attribute(visibility)) 26 | #define Py_IMPORTED_SYMBOL __attribute__ ((visibility ("default"))) 27 | #define Py_EXPORTED_SYMBOL __attribute__ ((visibility ("default"))) 28 | #define Py_LOCAL_SYMBOL __attribute__ ((visibility ("hidden"))) 29 | #else 30 | #define Py_IMPORTED_SYMBOL 31 | #define Py_EXPORTED_SYMBOL 32 | #define Py_LOCAL_SYMBOL 33 | #endif 34 | #endif 35 | 36 | #endif /* Py_EXPORTS_H */ 37 | -------------------------------------------------------------------------------- /AndroidApp/app/src/main/jni/Pythonx86_64/fileutils.h: -------------------------------------------------------------------------------- 1 | #ifndef Py_FILEUTILS_H 2 | #define Py_FILEUTILS_H 3 | #ifdef __cplusplus 4 | extern "C" { 5 | #endif 6 | 7 | #if !defined(Py_LIMITED_API) || Py_LIMITED_API+0 >= 0x03050000 8 | PyAPI_FUNC(wchar_t *) Py_DecodeLocale( 9 | const char *arg, 10 | size_t *size); 11 | 12 | PyAPI_FUNC(char*) Py_EncodeLocale( 13 | const wchar_t *text, 14 | size_t *error_pos); 15 | #endif 16 | 17 | #ifndef Py_LIMITED_API 18 | # define Py_CPYTHON_FILEUTILS_H 19 | # include "cpython/fileutils.h" 20 | # undef Py_CPYTHON_FILEUTILS_H 21 | #endif 22 | 23 | #ifdef __cplusplus 24 | } 25 | #endif 26 | #endif /* !Py_FILEUTILS_H */ 27 | -------------------------------------------------------------------------------- /AndroidApp/app/src/main/jni/Pythonx86_64/floatobject.h: -------------------------------------------------------------------------------- 1 | 2 | /* Float object interface */ 3 | 4 | /* 5 | PyFloatObject represents a (double precision) floating point number. 6 | */ 7 | 8 | #ifndef Py_FLOATOBJECT_H 9 | #define Py_FLOATOBJECT_H 10 | #ifdef __cplusplus 11 | extern "C" { 12 | #endif 13 | 14 | PyAPI_DATA(PyTypeObject) PyFloat_Type; 15 | 16 | #define PyFloat_Check(op) PyObject_TypeCheck(op, &PyFloat_Type) 17 | #define PyFloat_CheckExact(op) Py_IS_TYPE((op), &PyFloat_Type) 18 | 19 | #define Py_RETURN_NAN return PyFloat_FromDouble(Py_NAN) 20 | 21 | #define Py_RETURN_INF(sign) \ 22 | do { \ 23 | if (copysign(1., sign) == 1.) { \ 24 | return PyFloat_FromDouble(Py_HUGE_VAL); \ 25 | } \ 26 | else { \ 27 | return PyFloat_FromDouble(-Py_HUGE_VAL); \ 28 | } \ 29 | } while(0) 30 | 31 | PyAPI_FUNC(double) PyFloat_GetMax(void); 32 | PyAPI_FUNC(double) PyFloat_GetMin(void); 33 | PyAPI_FUNC(PyObject*) PyFloat_GetInfo(void); 34 | 35 | /* Return Python float from string PyObject. */ 36 | PyAPI_FUNC(PyObject*) PyFloat_FromString(PyObject*); 37 | 38 | /* Return Python float from C double. */ 39 | PyAPI_FUNC(PyObject*) PyFloat_FromDouble(double); 40 | 41 | /* Extract C double from Python float. The macro version trades safety for 42 | speed. */ 43 | PyAPI_FUNC(double) PyFloat_AsDouble(PyObject*); 44 | 45 | #ifndef Py_LIMITED_API 46 | # define Py_CPYTHON_FLOATOBJECT_H 47 | # include "cpython/floatobject.h" 48 | # undef Py_CPYTHON_FLOATOBJECT_H 49 | #endif 50 | 51 | #ifdef __cplusplus 52 | } 53 | #endif 54 | #endif /* !Py_FLOATOBJECT_H */ 55 | -------------------------------------------------------------------------------- /AndroidApp/app/src/main/jni/Pythonx86_64/frameobject.h: -------------------------------------------------------------------------------- 1 | /* Frame object interface */ 2 | 3 | #ifndef Py_FRAMEOBJECT_H 4 | #define Py_FRAMEOBJECT_H 5 | #ifdef __cplusplus 6 | extern "C" { 7 | #endif 8 | 9 | #include "pyframe.h" 10 | 11 | #ifndef Py_LIMITED_API 12 | # define Py_CPYTHON_FRAMEOBJECT_H 13 | # include "cpython/frameobject.h" 14 | # undef Py_CPYTHON_FRAMEOBJECT_H 15 | #endif 16 | 17 | #ifdef __cplusplus 18 | } 19 | #endif 20 | #endif /* !Py_FRAMEOBJECT_H */ 21 | -------------------------------------------------------------------------------- /AndroidApp/app/src/main/jni/Pythonx86_64/genericaliasobject.h: -------------------------------------------------------------------------------- 1 | // Implementation of PEP 585: support list[int] etc. 2 | #ifndef Py_GENERICALIASOBJECT_H 3 | #define Py_GENERICALIASOBJECT_H 4 | #ifdef __cplusplus 5 | extern "C" { 6 | #endif 7 | 8 | PyAPI_FUNC(PyObject *) Py_GenericAlias(PyObject *, PyObject *); 9 | PyAPI_DATA(PyTypeObject) Py_GenericAliasType; 10 | 11 | #ifdef __cplusplus 12 | } 13 | #endif 14 | #endif /* !Py_GENERICALIASOBJECT_H */ 15 | -------------------------------------------------------------------------------- /AndroidApp/app/src/main/jni/Pythonx86_64/internal/pycore_abstract.h: -------------------------------------------------------------------------------- 1 | #ifndef Py_INTERNAL_ABSTRACT_H 2 | #define Py_INTERNAL_ABSTRACT_H 3 | #ifdef __cplusplus 4 | extern "C" { 5 | #endif 6 | 7 | #ifndef Py_BUILD_CORE 8 | # error "this header requires Py_BUILD_CORE define" 9 | #endif 10 | 11 | // Fast inlined version of PyIndex_Check() 12 | static inline int 13 | _PyIndex_Check(PyObject *obj) 14 | { 15 | PyNumberMethods *tp_as_number = Py_TYPE(obj)->tp_as_number; 16 | return (tp_as_number != NULL && tp_as_number->nb_index != NULL); 17 | } 18 | 19 | PyObject *_PyNumber_PowerNoMod(PyObject *lhs, PyObject *rhs); 20 | PyObject *_PyNumber_InPlacePowerNoMod(PyObject *lhs, PyObject *rhs); 21 | 22 | #ifdef __cplusplus 23 | } 24 | #endif 25 | #endif /* !Py_INTERNAL_ABSTRACT_H */ 26 | -------------------------------------------------------------------------------- /AndroidApp/app/src/main/jni/Pythonx86_64/internal/pycore_atexit.h: -------------------------------------------------------------------------------- 1 | #ifndef Py_INTERNAL_ATEXIT_H 2 | #define Py_INTERNAL_ATEXIT_H 3 | #ifdef __cplusplus 4 | extern "C" { 5 | #endif 6 | 7 | #ifndef Py_BUILD_CORE 8 | # error "this header requires Py_BUILD_CORE define" 9 | #endif 10 | 11 | 12 | //############### 13 | // runtime atexit 14 | 15 | typedef void (*atexit_callbackfunc)(void); 16 | 17 | struct _atexit_runtime_state { 18 | PyThread_type_lock mutex; 19 | #define NEXITFUNCS 32 20 | atexit_callbackfunc callbacks[NEXITFUNCS]; 21 | int ncallbacks; 22 | }; 23 | 24 | 25 | //################### 26 | // interpreter atexit 27 | 28 | struct atexit_callback; 29 | typedef struct atexit_callback { 30 | atexit_datacallbackfunc func; 31 | void *data; 32 | struct atexit_callback *next; 33 | } atexit_callback; 34 | 35 | typedef struct { 36 | PyObject *func; 37 | PyObject *args; 38 | PyObject *kwargs; 39 | } atexit_py_callback; 40 | 41 | struct atexit_state { 42 | atexit_callback *ll_callbacks; 43 | atexit_callback *last_ll_callback; 44 | 45 | // XXX The rest of the state could be moved to the atexit module state 46 | // and a low-level callback added for it during module exec. 47 | // For the moment we leave it here. 48 | atexit_py_callback **callbacks; 49 | int ncallbacks; 50 | int callback_len; 51 | }; 52 | 53 | 54 | #ifdef __cplusplus 55 | } 56 | #endif 57 | #endif /* !Py_INTERNAL_ATEXIT_H */ 58 | -------------------------------------------------------------------------------- /AndroidApp/app/src/main/jni/Pythonx86_64/internal/pycore_bytesobject.h: -------------------------------------------------------------------------------- 1 | #ifndef Py_INTERNAL_BYTESOBJECT_H 2 | #define Py_INTERNAL_BYTESOBJECT_H 3 | #ifdef __cplusplus 4 | extern "C" { 5 | #endif 6 | 7 | #ifndef Py_BUILD_CORE 8 | # error "this header requires Py_BUILD_CORE define" 9 | #endif 10 | 11 | 12 | /* Substring Search. 13 | 14 | Returns the index of the first occurrence of 15 | a substring ("needle") in a larger text ("haystack"). 16 | If the needle is not found, return -1. 17 | If the needle is found, add offset to the index. 18 | */ 19 | 20 | PyAPI_FUNC(Py_ssize_t) 21 | _PyBytes_Find(const char *haystack, Py_ssize_t len_haystack, 22 | const char *needle, Py_ssize_t len_needle, 23 | Py_ssize_t offset); 24 | 25 | /* Same as above, but search right-to-left */ 26 | PyAPI_FUNC(Py_ssize_t) 27 | _PyBytes_ReverseFind(const char *haystack, Py_ssize_t len_haystack, 28 | const char *needle, Py_ssize_t len_needle, 29 | Py_ssize_t offset); 30 | 31 | 32 | /** Helper function to implement the repeat and inplace repeat methods on a buffer 33 | * 34 | * len_dest is assumed to be an integer multiple of len_src. 35 | * If src equals dest, then assume the operation is inplace. 36 | * 37 | * This method repeately doubles the number of bytes copied to reduce 38 | * the number of invocations of memcpy. 39 | */ 40 | PyAPI_FUNC(void) 41 | _PyBytes_Repeat(char* dest, Py_ssize_t len_dest, 42 | const char* src, Py_ssize_t len_src); 43 | 44 | #ifdef __cplusplus 45 | } 46 | #endif 47 | #endif /* !Py_INTERNAL_BYTESOBJECT_H */ 48 | -------------------------------------------------------------------------------- /AndroidApp/app/src/main/jni/Pythonx86_64/internal/pycore_context.h: -------------------------------------------------------------------------------- 1 | #ifndef Py_INTERNAL_CONTEXT_H 2 | #define Py_INTERNAL_CONTEXT_H 3 | 4 | #ifndef Py_BUILD_CORE 5 | # error "this header requires Py_BUILD_CORE define" 6 | #endif 7 | 8 | #include "pycore_hamt.h" /* PyHamtObject */ 9 | 10 | 11 | extern PyTypeObject _PyContextTokenMissing_Type; 12 | 13 | /* runtime lifecycle */ 14 | 15 | PyStatus _PyContext_Init(PyInterpreterState *); 16 | void _PyContext_Fini(PyInterpreterState *); 17 | 18 | 19 | /* other API */ 20 | 21 | typedef struct { 22 | PyObject_HEAD 23 | } _PyContextTokenMissing; 24 | 25 | #ifndef WITH_FREELISTS 26 | // without freelists 27 | # define PyContext_MAXFREELIST 0 28 | #endif 29 | 30 | #ifndef PyContext_MAXFREELIST 31 | # define PyContext_MAXFREELIST 255 32 | #endif 33 | 34 | struct _Py_context_state { 35 | #if PyContext_MAXFREELIST > 0 36 | // List of free PyContext objects 37 | PyContext *freelist; 38 | int numfree; 39 | #endif 40 | }; 41 | 42 | struct _pycontextobject { 43 | PyObject_HEAD 44 | PyContext *ctx_prev; 45 | PyHamtObject *ctx_vars; 46 | PyObject *ctx_weakreflist; 47 | int ctx_entered; 48 | }; 49 | 50 | 51 | struct _pycontextvarobject { 52 | PyObject_HEAD 53 | PyObject *var_name; 54 | PyObject *var_default; 55 | PyObject *var_cached; 56 | uint64_t var_cached_tsid; 57 | uint64_t var_cached_tsver; 58 | Py_hash_t var_hash; 59 | }; 60 | 61 | 62 | struct _pycontexttokenobject { 63 | PyObject_HEAD 64 | PyContext *tok_ctx; 65 | PyContextVar *tok_var; 66 | PyObject *tok_oldval; 67 | int tok_used; 68 | }; 69 | 70 | 71 | #endif /* !Py_INTERNAL_CONTEXT_H */ 72 | -------------------------------------------------------------------------------- /AndroidApp/app/src/main/jni/Pythonx86_64/internal/pycore_descrobject.h: -------------------------------------------------------------------------------- 1 | #ifndef Py_INTERNAL_DESCROBJECT_H 2 | #define Py_INTERNAL_DESCROBJECT_H 3 | #ifdef __cplusplus 4 | extern "C" { 5 | #endif 6 | 7 | #ifndef Py_BUILD_CORE 8 | # error "this header requires Py_BUILD_CORE define" 9 | #endif 10 | 11 | typedef struct { 12 | PyObject_HEAD 13 | PyObject *prop_get; 14 | PyObject *prop_set; 15 | PyObject *prop_del; 16 | PyObject *prop_doc; 17 | PyObject *prop_name; 18 | int getter_doc; 19 | } propertyobject; 20 | 21 | typedef propertyobject _PyPropertyObject; 22 | 23 | #ifdef __cplusplus 24 | } 25 | #endif 26 | #endif /* !Py_INTERNAL_DESCROBJECT_H */ 27 | -------------------------------------------------------------------------------- /AndroidApp/app/src/main/jni/Pythonx86_64/internal/pycore_dict_state.h: -------------------------------------------------------------------------------- 1 | #ifndef Py_INTERNAL_DICT_STATE_H 2 | #define Py_INTERNAL_DICT_STATE_H 3 | #ifdef __cplusplus 4 | extern "C" { 5 | #endif 6 | 7 | #ifndef Py_BUILD_CORE 8 | # error "this header requires Py_BUILD_CORE define" 9 | #endif 10 | 11 | 12 | #ifndef WITH_FREELISTS 13 | // without freelists 14 | # define PyDict_MAXFREELIST 0 15 | #endif 16 | 17 | #ifndef PyDict_MAXFREELIST 18 | # define PyDict_MAXFREELIST 80 19 | #endif 20 | 21 | #define DICT_MAX_WATCHERS 8 22 | 23 | struct _Py_dict_state { 24 | /*Global counter used to set ma_version_tag field of dictionary. 25 | * It is incremented each time that a dictionary is created and each 26 | * time that a dictionary is modified. */ 27 | uint64_t global_version; 28 | uint32_t next_keys_version; 29 | 30 | #if PyDict_MAXFREELIST > 0 31 | /* Dictionary reuse scheme to save calls to malloc and free */ 32 | PyDictObject *free_list[PyDict_MAXFREELIST]; 33 | PyDictKeysObject *keys_free_list[PyDict_MAXFREELIST]; 34 | int numfree; 35 | int keys_numfree; 36 | #endif 37 | 38 | PyDict_WatchCallback watchers[DICT_MAX_WATCHERS]; 39 | }; 40 | 41 | #define _dict_state_INIT \ 42 | { \ 43 | .next_keys_version = 2, \ 44 | } 45 | 46 | 47 | #ifdef __cplusplus 48 | } 49 | #endif 50 | #endif /* !Py_INTERNAL_DICT_STATE_H */ 51 | -------------------------------------------------------------------------------- /AndroidApp/app/src/main/jni/Pythonx86_64/internal/pycore_emscripten_signal.h: -------------------------------------------------------------------------------- 1 | #ifndef Py_EMSCRIPTEN_SIGNAL_H 2 | #define Py_EMSCRIPTEN_SIGNAL_H 3 | 4 | #if defined(__EMSCRIPTEN__) 5 | 6 | void 7 | _Py_CheckEmscriptenSignals(void); 8 | 9 | void 10 | _Py_CheckEmscriptenSignalsPeriodically(void); 11 | 12 | #define _Py_CHECK_EMSCRIPTEN_SIGNALS() _Py_CheckEmscriptenSignals() 13 | 14 | #define _Py_CHECK_EMSCRIPTEN_SIGNALS_PERIODICALLY() _Py_CheckEmscriptenSignalsPeriodically() 15 | 16 | extern int Py_EMSCRIPTEN_SIGNAL_HANDLING; 17 | 18 | #else 19 | 20 | #define _Py_CHECK_EMSCRIPTEN_SIGNALS() 21 | #define _Py_CHECK_EMSCRIPTEN_SIGNALS_PERIODICALLY() 22 | 23 | #endif // defined(__EMSCRIPTEN__) 24 | 25 | #endif // ndef Py_EMSCRIPTEN_SIGNAL_H 26 | -------------------------------------------------------------------------------- /AndroidApp/app/src/main/jni/Pythonx86_64/internal/pycore_exceptions.h: -------------------------------------------------------------------------------- 1 | #ifndef Py_INTERNAL_EXCEPTIONS_H 2 | #define Py_INTERNAL_EXCEPTIONS_H 3 | #ifdef __cplusplus 4 | extern "C" { 5 | #endif 6 | 7 | #ifndef Py_BUILD_CORE 8 | # error "this header requires Py_BUILD_CORE define" 9 | #endif 10 | 11 | 12 | /* runtime lifecycle */ 13 | 14 | extern PyStatus _PyExc_InitState(PyInterpreterState *); 15 | extern PyStatus _PyExc_InitGlobalObjects(PyInterpreterState *); 16 | extern int _PyExc_InitTypes(PyInterpreterState *); 17 | extern void _PyExc_Fini(PyInterpreterState *); 18 | 19 | 20 | /* other API */ 21 | 22 | struct _Py_exc_state { 23 | // The dict mapping from errno codes to OSError subclasses 24 | PyObject *errnomap; 25 | PyBaseExceptionObject *memerrors_freelist; 26 | int memerrors_numfree; 27 | // The ExceptionGroup type 28 | PyObject *PyExc_ExceptionGroup; 29 | }; 30 | 31 | extern void _PyExc_ClearExceptionGroupType(PyInterpreterState *); 32 | 33 | 34 | #ifdef __cplusplus 35 | } 36 | #endif 37 | #endif /* !Py_INTERNAL_EXCEPTIONS_H */ 38 | -------------------------------------------------------------------------------- /AndroidApp/app/src/main/jni/Pythonx86_64/internal/pycore_format.h: -------------------------------------------------------------------------------- 1 | #ifndef Py_INTERNAL_FORMAT_H 2 | #define Py_INTERNAL_FORMAT_H 3 | #ifdef __cplusplus 4 | extern "C" { 5 | #endif 6 | 7 | #ifndef Py_BUILD_CORE 8 | # error "this header requires Py_BUILD_CORE define" 9 | #endif 10 | 11 | /* Format codes 12 | * F_LJUST '-' 13 | * F_SIGN '+' 14 | * F_BLANK ' ' 15 | * F_ALT '#' 16 | * F_ZERO '0' 17 | */ 18 | #define F_LJUST (1<<0) 19 | #define F_SIGN (1<<1) 20 | #define F_BLANK (1<<2) 21 | #define F_ALT (1<<3) 22 | #define F_ZERO (1<<4) 23 | 24 | #ifdef __cplusplus 25 | } 26 | #endif 27 | #endif /* !Py_INTERNAL_FORMAT_H */ 28 | -------------------------------------------------------------------------------- /AndroidApp/app/src/main/jni/Pythonx86_64/internal/pycore_function.h: -------------------------------------------------------------------------------- 1 | #ifndef Py_INTERNAL_FUNCTION_H 2 | #define Py_INTERNAL_FUNCTION_H 3 | #ifdef __cplusplus 4 | extern "C" { 5 | #endif 6 | 7 | #ifndef Py_BUILD_CORE 8 | # error "this header requires Py_BUILD_CORE define" 9 | #endif 10 | 11 | #define FUNC_MAX_WATCHERS 8 12 | 13 | struct _py_func_state { 14 | uint32_t next_version; 15 | }; 16 | 17 | extern PyFunctionObject* _PyFunction_FromConstructor(PyFrameConstructor *constr); 18 | 19 | extern uint32_t _PyFunction_GetVersionForCurrentState(PyFunctionObject *func); 20 | extern PyObject *_Py_set_function_type_params( 21 | PyThreadState* unused, PyObject *func, PyObject *type_params); 22 | 23 | #ifdef __cplusplus 24 | } 25 | #endif 26 | #endif /* !Py_INTERNAL_FUNCTION_H */ 27 | -------------------------------------------------------------------------------- /AndroidApp/app/src/main/jni/Pythonx86_64/internal/pycore_genobject.h: -------------------------------------------------------------------------------- 1 | #ifndef Py_INTERNAL_GENOBJECT_H 2 | #define Py_INTERNAL_GENOBJECT_H 3 | #ifdef __cplusplus 4 | extern "C" { 5 | #endif 6 | 7 | #ifndef Py_BUILD_CORE 8 | # error "this header requires Py_BUILD_CORE define" 9 | #endif 10 | 11 | extern PyObject *_PyGen_yf(PyGenObject *); 12 | extern PyObject *_PyCoro_GetAwaitableIter(PyObject *o); 13 | extern PyObject *_PyAsyncGenValueWrapperNew(PyThreadState *state, PyObject *); 14 | 15 | /* runtime lifecycle */ 16 | 17 | extern void _PyAsyncGen_Fini(PyInterpreterState *); 18 | 19 | 20 | /* other API */ 21 | 22 | #ifndef WITH_FREELISTS 23 | // without freelists 24 | # define _PyAsyncGen_MAXFREELIST 0 25 | #endif 26 | 27 | #ifndef _PyAsyncGen_MAXFREELIST 28 | # define _PyAsyncGen_MAXFREELIST 80 29 | #endif 30 | 31 | struct _Py_async_gen_state { 32 | #if _PyAsyncGen_MAXFREELIST > 0 33 | /* Freelists boost performance 6-10%; they also reduce memory 34 | fragmentation, as _PyAsyncGenWrappedValue and PyAsyncGenASend 35 | are short-living objects that are instantiated for every 36 | __anext__() call. */ 37 | struct _PyAsyncGenWrappedValue* value_freelist[_PyAsyncGen_MAXFREELIST]; 38 | int value_numfree; 39 | 40 | struct PyAsyncGenASend* asend_freelist[_PyAsyncGen_MAXFREELIST]; 41 | int asend_numfree; 42 | #endif 43 | }; 44 | 45 | 46 | #ifdef __cplusplus 47 | } 48 | #endif 49 | #endif /* !Py_INTERNAL_GENOBJECT_H */ 50 | -------------------------------------------------------------------------------- /AndroidApp/app/src/main/jni/Pythonx86_64/internal/pycore_getopt.h: -------------------------------------------------------------------------------- 1 | #ifndef Py_INTERNAL_PYGETOPT_H 2 | #define Py_INTERNAL_PYGETOPT_H 3 | 4 | #ifndef Py_BUILD_CORE 5 | # error "this header requires Py_BUILD_CORE define" 6 | #endif 7 | 8 | extern int _PyOS_opterr; 9 | extern Py_ssize_t _PyOS_optind; 10 | extern const wchar_t *_PyOS_optarg; 11 | 12 | extern void _PyOS_ResetGetOpt(void); 13 | 14 | typedef struct { 15 | const wchar_t *name; 16 | int has_arg; 17 | int val; 18 | } _PyOS_LongOption; 19 | 20 | extern int _PyOS_GetOpt(Py_ssize_t argc, wchar_t * const *argv, int *longindex); 21 | 22 | #endif /* !Py_INTERNAL_PYGETOPT_H */ 23 | -------------------------------------------------------------------------------- /AndroidApp/app/src/main/jni/Pythonx86_64/internal/pycore_gil.h: -------------------------------------------------------------------------------- 1 | #ifndef Py_INTERNAL_GIL_H 2 | #define Py_INTERNAL_GIL_H 3 | #ifdef __cplusplus 4 | extern "C" { 5 | #endif 6 | 7 | #ifndef Py_BUILD_CORE 8 | # error "this header requires Py_BUILD_CORE define" 9 | #endif 10 | 11 | #include "pycore_atomic.h" /* _Py_atomic_address */ 12 | #include "pycore_condvar.h" /* PyCOND_T */ 13 | 14 | #ifndef Py_HAVE_CONDVAR 15 | # error You need either a POSIX-compatible or a Windows system! 16 | #endif 17 | 18 | /* Enable if you want to force the switching of threads at least 19 | every `interval`. */ 20 | #undef FORCE_SWITCHING 21 | #define FORCE_SWITCHING 22 | 23 | struct _gil_runtime_state { 24 | /* microseconds (the Python API uses seconds, though) */ 25 | unsigned long interval; 26 | /* Last PyThreadState holding / having held the GIL. This helps us 27 | know whether anyone else was scheduled after we dropped the GIL. */ 28 | _Py_atomic_address last_holder; 29 | /* Whether the GIL is already taken (-1 if uninitialized). This is 30 | atomic because it can be read without any lock taken in ceval.c. */ 31 | _Py_atomic_int locked; 32 | /* Number of GIL switches since the beginning. */ 33 | unsigned long switch_number; 34 | /* This condition variable allows one or several threads to wait 35 | until the GIL is released. In addition, the mutex also protects 36 | the above variables. */ 37 | PyCOND_T cond; 38 | PyMUTEX_T mutex; 39 | #ifdef FORCE_SWITCHING 40 | /* This condition variable helps the GIL-releasing thread wait for 41 | a GIL-awaiting thread to be scheduled and take the GIL. */ 42 | PyCOND_T switch_cond; 43 | PyMUTEX_T switch_mutex; 44 | #endif 45 | }; 46 | 47 | #ifdef __cplusplus 48 | } 49 | #endif 50 | #endif /* !Py_INTERNAL_GIL_H */ 51 | -------------------------------------------------------------------------------- /AndroidApp/app/src/main/jni/Pythonx86_64/internal/pycore_intrinsics.h: -------------------------------------------------------------------------------- 1 | // Auto-generated by Tools/build/generate_opcode_h.py from Lib/opcode.py 2 | 3 | /* Unary Functions: */ 4 | #define INTRINSIC_1_INVALID 0 5 | #define INTRINSIC_PRINT 1 6 | #define INTRINSIC_IMPORT_STAR 2 7 | #define INTRINSIC_STOPITERATION_ERROR 3 8 | #define INTRINSIC_ASYNC_GEN_WRAP 4 9 | #define INTRINSIC_UNARY_POSITIVE 5 10 | #define INTRINSIC_LIST_TO_TUPLE 6 11 | #define INTRINSIC_TYPEVAR 7 12 | #define INTRINSIC_PARAMSPEC 8 13 | #define INTRINSIC_TYPEVARTUPLE 9 14 | #define INTRINSIC_SUBSCRIPT_GENERIC 10 15 | #define INTRINSIC_TYPEALIAS 11 16 | 17 | #define MAX_INTRINSIC_1 11 18 | 19 | 20 | /* Binary Functions: */ 21 | #define INTRINSIC_2_INVALID 0 22 | #define INTRINSIC_PREP_RERAISE_STAR 1 23 | #define INTRINSIC_TYPEVAR_WITH_BOUND 2 24 | #define INTRINSIC_TYPEVAR_WITH_CONSTRAINTS 3 25 | #define INTRINSIC_SET_FUNCTION_TYPE_PARAMS 4 26 | 27 | #define MAX_INTRINSIC_2 4 28 | 29 | typedef PyObject *(*instrinsic_func1)(PyThreadState* tstate, PyObject *value); 30 | typedef PyObject *(*instrinsic_func2)(PyThreadState* tstate, PyObject *value1, PyObject *value2); 31 | extern const instrinsic_func1 _PyIntrinsics_UnaryFunctions[]; 32 | extern const instrinsic_func2 _PyIntrinsics_BinaryFunctions[]; 33 | -------------------------------------------------------------------------------- /AndroidApp/app/src/main/jni/Pythonx86_64/internal/pycore_memoryobject.h: -------------------------------------------------------------------------------- 1 | #ifndef Py_INTERNAL_MEMORYOBJECT_H 2 | #define Py_INTERNAL_MEMORYOBJECT_H 3 | #ifdef __cplusplus 4 | extern "C" { 5 | #endif 6 | 7 | #ifndef Py_BUILD_CORE 8 | # error "this header requires Py_BUILD_CORE define" 9 | #endif 10 | 11 | PyObject * 12 | _PyMemoryView_FromBufferProc(PyObject *v, int flags, 13 | getbufferproc bufferproc); 14 | 15 | #ifdef __cplusplus 16 | } 17 | #endif 18 | #endif /* !Py_INTERNAL_MEMORYOBJECT_H */ 19 | -------------------------------------------------------------------------------- /AndroidApp/app/src/main/jni/Pythonx86_64/internal/pycore_moduleobject.h: -------------------------------------------------------------------------------- 1 | #ifndef Py_INTERNAL_MODULEOBJECT_H 2 | #define Py_INTERNAL_MODULEOBJECT_H 3 | #ifdef __cplusplus 4 | extern "C" { 5 | #endif 6 | 7 | #ifndef Py_BUILD_CORE 8 | # error "this header requires Py_BUILD_CORE define" 9 | #endif 10 | 11 | typedef struct { 12 | PyObject_HEAD 13 | PyObject *md_dict; 14 | PyModuleDef *md_def; 15 | void *md_state; 16 | PyObject *md_weaklist; 17 | // for logging purposes after md_dict is cleared 18 | PyObject *md_name; 19 | } PyModuleObject; 20 | 21 | static inline PyModuleDef* _PyModule_GetDef(PyObject *mod) { 22 | assert(PyModule_Check(mod)); 23 | return ((PyModuleObject *)mod)->md_def; 24 | } 25 | 26 | static inline void* _PyModule_GetState(PyObject* mod) { 27 | assert(PyModule_Check(mod)); 28 | return ((PyModuleObject *)mod)->md_state; 29 | } 30 | 31 | static inline PyObject* _PyModule_GetDict(PyObject *mod) { 32 | assert(PyModule_Check(mod)); 33 | PyObject *dict = ((PyModuleObject *)mod) -> md_dict; 34 | // _PyModule_GetDict(mod) must not be used after calling module_clear(mod) 35 | assert(dict != NULL); 36 | return dict; 37 | } 38 | 39 | PyObject* _Py_module_getattro_impl(PyModuleObject *m, PyObject *name, int suppress); 40 | PyObject* _Py_module_getattro(PyModuleObject *m, PyObject *name); 41 | 42 | #ifdef __cplusplus 43 | } 44 | #endif 45 | #endif /* !Py_INTERNAL_MODULEOBJECT_H */ 46 | -------------------------------------------------------------------------------- /AndroidApp/app/src/main/jni/Pythonx86_64/internal/pycore_namespace.h: -------------------------------------------------------------------------------- 1 | // Simple namespace object interface 2 | 3 | #ifndef Py_INTERNAL_NAMESPACE_H 4 | #define Py_INTERNAL_NAMESPACE_H 5 | #ifdef __cplusplus 6 | extern "C" { 7 | #endif 8 | 9 | #ifndef Py_BUILD_CORE 10 | # error "this header requires Py_BUILD_CORE define" 11 | #endif 12 | 13 | PyAPI_DATA(PyTypeObject) _PyNamespace_Type; 14 | 15 | PyAPI_FUNC(PyObject *) _PyNamespace_New(PyObject *kwds); 16 | 17 | #ifdef __cplusplus 18 | } 19 | #endif 20 | #endif // !Py_INTERNAL_NAMESPACE_H 21 | -------------------------------------------------------------------------------- /AndroidApp/app/src/main/jni/Pythonx86_64/internal/pycore_object_state.h: -------------------------------------------------------------------------------- 1 | #ifndef Py_INTERNAL_OBJECT_STATE_H 2 | #define Py_INTERNAL_OBJECT_STATE_H 3 | #ifdef __cplusplus 4 | extern "C" { 5 | #endif 6 | 7 | #ifndef Py_BUILD_CORE 8 | # error "this header requires Py_BUILD_CORE define" 9 | #endif 10 | 11 | struct _py_object_runtime_state { 12 | #ifdef Py_REF_DEBUG 13 | Py_ssize_t interpreter_leaks; 14 | #endif 15 | int _not_used; 16 | }; 17 | 18 | struct _py_object_state { 19 | #ifdef Py_REF_DEBUG 20 | Py_ssize_t reftotal; 21 | #endif 22 | #ifdef Py_TRACE_REFS 23 | /* Head of circular doubly-linked list of all objects. These are linked 24 | * together via the _ob_prev and _ob_next members of a PyObject, which 25 | * exist only in a Py_TRACE_REFS build. 26 | */ 27 | PyObject refchain; 28 | #endif 29 | int _not_used; 30 | }; 31 | 32 | 33 | #ifdef __cplusplus 34 | } 35 | #endif 36 | #endif /* !Py_INTERNAL_OBJECT_STATE_H */ 37 | -------------------------------------------------------------------------------- /AndroidApp/app/src/main/jni/Pythonx86_64/internal/pycore_parser.h: -------------------------------------------------------------------------------- 1 | #ifndef Py_INTERNAL_PARSER_H 2 | #define Py_INTERNAL_PARSER_H 3 | #ifdef __cplusplus 4 | extern "C" { 5 | #endif 6 | 7 | #ifndef Py_BUILD_CORE 8 | # error "this header requires Py_BUILD_CORE define" 9 | #endif 10 | 11 | 12 | #include "pycore_ast.h" // struct _expr 13 | #include "pycore_global_strings.h" // _Py_DECLARE_STR() 14 | #include "pycore_pyarena.h" // PyArena 15 | 16 | 17 | #ifdef Py_DEBUG 18 | #define _PYPEGEN_NSTATISTICS 2000 19 | #endif 20 | 21 | struct _parser_runtime_state { 22 | #ifdef Py_DEBUG 23 | long memo_statistics[_PYPEGEN_NSTATISTICS]; 24 | #else 25 | int _not_used; 26 | #endif 27 | struct _expr dummy_name; 28 | }; 29 | 30 | _Py_DECLARE_STR(empty, "") 31 | #define _parser_runtime_state_INIT \ 32 | { \ 33 | .dummy_name = { \ 34 | .kind = Name_kind, \ 35 | .v.Name.id = &_Py_STR(empty), \ 36 | .v.Name.ctx = Load, \ 37 | .lineno = 1, \ 38 | .col_offset = 0, \ 39 | .end_lineno = 1, \ 40 | .end_col_offset = 0, \ 41 | }, \ 42 | } 43 | 44 | extern struct _mod* _PyParser_ASTFromString( 45 | const char *str, 46 | PyObject* filename, 47 | int mode, 48 | PyCompilerFlags *flags, 49 | PyArena *arena); 50 | 51 | extern struct _mod* _PyParser_ASTFromFile( 52 | FILE *fp, 53 | PyObject *filename_ob, 54 | const char *enc, 55 | int mode, 56 | const char *ps1, 57 | const char *ps2, 58 | PyCompilerFlags *flags, 59 | int *errcode, 60 | PyArena *arena); 61 | 62 | 63 | #ifdef __cplusplus 64 | } 65 | #endif 66 | #endif /* !Py_INTERNAL_PARSER_H */ 67 | -------------------------------------------------------------------------------- /AndroidApp/app/src/main/jni/Pythonx86_64/internal/pycore_pathconfig.h: -------------------------------------------------------------------------------- 1 | #ifndef Py_INTERNAL_PATHCONFIG_H 2 | #define Py_INTERNAL_PATHCONFIG_H 3 | #ifdef __cplusplus 4 | extern "C" { 5 | #endif 6 | 7 | #ifndef Py_BUILD_CORE 8 | # error "this header requires Py_BUILD_CORE define" 9 | #endif 10 | 11 | PyAPI_FUNC(void) _PyPathConfig_ClearGlobal(void); 12 | extern PyStatus _PyPathConfig_ReadGlobal(PyConfig *config); 13 | extern PyStatus _PyPathConfig_UpdateGlobal(const PyConfig *config); 14 | extern const wchar_t * _PyPathConfig_GetGlobalModuleSearchPath(void); 15 | 16 | extern int _PyPathConfig_ComputeSysPath0( 17 | const PyWideStringList *argv, 18 | PyObject **path0); 19 | 20 | 21 | #ifdef __cplusplus 22 | } 23 | #endif 24 | #endif /* !Py_INTERNAL_PATHCONFIG_H */ 25 | -------------------------------------------------------------------------------- /AndroidApp/app/src/main/jni/Pythonx86_64/internal/pycore_pyhash.h: -------------------------------------------------------------------------------- 1 | #ifndef Py_INTERNAL_HASH_H 2 | #define Py_INTERNAL_HASH_H 3 | 4 | #ifndef Py_BUILD_CORE 5 | # error "this header requires Py_BUILD_CORE define" 6 | #endif 7 | 8 | 9 | struct pyhash_runtime_state { 10 | struct { 11 | #ifndef MS_WINDOWS 12 | int fd; 13 | dev_t st_dev; 14 | ino_t st_ino; 15 | #else 16 | // This is a placeholder so the struct isn't empty on Windows. 17 | int _not_used; 18 | #endif 19 | } urandom_cache; 20 | }; 21 | 22 | #ifndef MS_WINDOWS 23 | # define _py_urandom_cache_INIT \ 24 | { \ 25 | .fd = -1, \ 26 | } 27 | #else 28 | # define _py_urandom_cache_INIT {0} 29 | #endif 30 | 31 | #define pyhash_state_INIT \ 32 | { \ 33 | .urandom_cache = _py_urandom_cache_INIT, \ 34 | } 35 | 36 | 37 | uint64_t _Py_KeyedHash(uint64_t, const char *, Py_ssize_t); 38 | 39 | 40 | #endif // Py_INTERNAL_HASH_H 41 | -------------------------------------------------------------------------------- /AndroidApp/app/src/main/jni/Pythonx86_64/internal/pycore_range.h: -------------------------------------------------------------------------------- 1 | #ifndef Py_INTERNAL_RANGE_H 2 | #define Py_INTERNAL_RANGE_H 3 | #ifdef __cplusplus 4 | extern "C" { 5 | #endif 6 | 7 | #ifndef Py_BUILD_CORE 8 | # error "this header requires Py_BUILD_CORE define" 9 | #endif 10 | 11 | typedef struct { 12 | PyObject_HEAD 13 | long start; 14 | long step; 15 | long len; 16 | } _PyRangeIterObject; 17 | 18 | #ifdef __cplusplus 19 | } 20 | #endif 21 | #endif /* !Py_INTERNAL_RANGE_H */ 22 | -------------------------------------------------------------------------------- /AndroidApp/app/src/main/jni/Pythonx86_64/internal/pycore_sliceobject.h: -------------------------------------------------------------------------------- 1 | #ifndef Py_INTERNAL_SLICEOBJECT_H 2 | #define Py_INTERNAL_SLICEOBJECT_H 3 | #ifdef __cplusplus 4 | extern "C" { 5 | #endif 6 | 7 | #ifndef Py_BUILD_CORE 8 | # error "this header requires Py_BUILD_CORE define" 9 | #endif 10 | 11 | 12 | /* runtime lifecycle */ 13 | 14 | extern void _PySlice_Fini(PyInterpreterState *); 15 | 16 | extern PyObject * 17 | _PyBuildSlice_ConsumeRefs(PyObject *start, PyObject *stop); 18 | 19 | #ifdef __cplusplus 20 | } 21 | #endif 22 | #endif /* !Py_INTERNAL_SLICEOBJECT_H */ 23 | -------------------------------------------------------------------------------- /AndroidApp/app/src/main/jni/Pythonx86_64/internal/pycore_strhex.h: -------------------------------------------------------------------------------- 1 | #ifndef Py_INTERNAL_STRHEX_H 2 | #define Py_INTERNAL_STRHEX_H 3 | #ifdef __cplusplus 4 | extern "C" { 5 | #endif 6 | 7 | #ifndef Py_BUILD_CORE 8 | # error "this header requires Py_BUILD_CORE define" 9 | #endif 10 | 11 | // Returns a str() containing the hex representation of argbuf. 12 | PyAPI_FUNC(PyObject*) _Py_strhex(const 13 | char* argbuf, 14 | const Py_ssize_t arglen); 15 | 16 | // Returns a bytes() containing the ASCII hex representation of argbuf. 17 | PyAPI_FUNC(PyObject*) _Py_strhex_bytes( 18 | const char* argbuf, 19 | const Py_ssize_t arglen); 20 | 21 | // These variants include support for a separator between every N bytes: 22 | PyAPI_FUNC(PyObject*) _Py_strhex_with_sep( 23 | const char* argbuf, 24 | const Py_ssize_t arglen, 25 | PyObject* sep, 26 | const int bytes_per_group); 27 | PyAPI_FUNC(PyObject*) _Py_strhex_bytes_with_sep( 28 | const char* argbuf, 29 | const Py_ssize_t arglen, 30 | PyObject* sep, 31 | const int bytes_per_group); 32 | 33 | #ifdef __cplusplus 34 | } 35 | #endif 36 | #endif /* !Py_INTERNAL_STRHEX_H */ 37 | -------------------------------------------------------------------------------- /AndroidApp/app/src/main/jni/Pythonx86_64/internal/pycore_structseq.h: -------------------------------------------------------------------------------- 1 | #ifndef Py_INTERNAL_STRUCTSEQ_H 2 | #define Py_INTERNAL_STRUCTSEQ_H 3 | #ifdef __cplusplus 4 | extern "C" { 5 | #endif 6 | 7 | #ifndef Py_BUILD_CORE 8 | # error "this header requires Py_BUILD_CORE define" 9 | #endif 10 | 11 | 12 | /* other API */ 13 | 14 | PyAPI_FUNC(PyTypeObject *) _PyStructSequence_NewType( 15 | PyStructSequence_Desc *desc, 16 | unsigned long tp_flags); 17 | 18 | extern int _PyStructSequence_InitBuiltinWithFlags( 19 | PyInterpreterState *interp, 20 | PyTypeObject *type, 21 | PyStructSequence_Desc *desc, 22 | unsigned long tp_flags); 23 | 24 | static inline int 25 | _PyStructSequence_InitBuiltin(PyInterpreterState *interp, 26 | PyTypeObject *type, 27 | PyStructSequence_Desc *desc) 28 | { 29 | return _PyStructSequence_InitBuiltinWithFlags(interp, type, desc, 0); 30 | } 31 | 32 | extern void _PyStructSequence_FiniBuiltin( 33 | PyInterpreterState *interp, 34 | PyTypeObject *type); 35 | 36 | #ifdef __cplusplus 37 | } 38 | #endif 39 | #endif /* !Py_INTERNAL_STRUCTSEQ_H */ 40 | -------------------------------------------------------------------------------- /AndroidApp/app/src/main/jni/Pythonx86_64/internal/pycore_sysmodule.h: -------------------------------------------------------------------------------- 1 | #ifndef Py_INTERNAL_SYSMODULE_H 2 | #define Py_INTERNAL_SYSMODULE_H 3 | #ifdef __cplusplus 4 | extern "C" { 5 | #endif 6 | 7 | #ifndef Py_BUILD_CORE 8 | # error "this header requires Py_BUILD_CORE define" 9 | #endif 10 | 11 | PyAPI_FUNC(int) _PySys_Audit( 12 | PyThreadState *tstate, 13 | const char *event, 14 | const char *argFormat, 15 | ...); 16 | 17 | /* We want minimal exposure of this function, so use extern rather than 18 | PyAPI_FUNC() to not export the symbol. */ 19 | extern void _PySys_ClearAuditHooks(PyThreadState *tstate); 20 | 21 | PyAPI_FUNC(int) _PySys_SetAttr(PyObject *, PyObject *); 22 | 23 | extern int _PySys_ClearAttrString(PyInterpreterState *interp, 24 | const char *name, int verbose); 25 | 26 | #ifdef __cplusplus 27 | } 28 | #endif 29 | #endif /* !Py_INTERNAL_SYSMODULE_H */ 30 | -------------------------------------------------------------------------------- /AndroidApp/app/src/main/jni/Pythonx86_64/internal/pycore_time.h: -------------------------------------------------------------------------------- 1 | #ifndef Py_INTERNAL_TIME_H 2 | #define Py_INTERNAL_TIME_H 3 | #ifdef __cplusplus 4 | extern "C" { 5 | #endif 6 | 7 | #ifndef Py_BUILD_CORE 8 | # error "this header requires Py_BUILD_CORE define" 9 | #endif 10 | 11 | 12 | struct _time_runtime_state { 13 | #ifdef HAVE_TIMES 14 | int ticks_per_second_initialized; 15 | long ticks_per_second; 16 | #else 17 | int _not_used; 18 | #endif 19 | }; 20 | 21 | 22 | #ifdef __cplusplus 23 | } 24 | #endif 25 | #endif /* !Py_INTERNAL_TIME_H */ 26 | -------------------------------------------------------------------------------- /AndroidApp/app/src/main/jni/Pythonx86_64/internal/pycore_typevarobject.h: -------------------------------------------------------------------------------- 1 | #ifndef Py_INTERNAL_TYPEVAROBJECT_H 2 | #define Py_INTERNAL_TYPEVAROBJECT_H 3 | #ifdef __cplusplus 4 | extern "C" { 5 | #endif 6 | 7 | #ifndef Py_BUILD_CORE 8 | # error "this header requires Py_BUILD_CORE define" 9 | #endif 10 | 11 | extern PyObject *_Py_make_typevar(PyObject *, PyObject *, PyObject *); 12 | extern PyObject *_Py_make_paramspec(PyThreadState *, PyObject *); 13 | extern PyObject *_Py_make_typevartuple(PyThreadState *, PyObject *); 14 | extern PyObject *_Py_make_typealias(PyThreadState *, PyObject *); 15 | extern PyObject *_Py_subscript_generic(PyThreadState *, PyObject *); 16 | extern int _Py_initialize_generic(PyInterpreterState *); 17 | extern void _Py_clear_generic_types(PyInterpreterState *); 18 | 19 | extern PyTypeObject _PyTypeAlias_Type; 20 | 21 | #ifdef __cplusplus 22 | } 23 | #endif 24 | #endif /* !Py_INTERNAL_TYPEVAROBJECT_H */ 25 | -------------------------------------------------------------------------------- /AndroidApp/app/src/main/jni/Pythonx86_64/internal/pycore_ucnhash.h: -------------------------------------------------------------------------------- 1 | /* Unicode name database interface */ 2 | #ifndef Py_INTERNAL_UCNHASH_H 3 | #define Py_INTERNAL_UCNHASH_H 4 | #ifdef __cplusplus 5 | extern "C" { 6 | #endif 7 | 8 | #ifndef Py_BUILD_CORE 9 | # error "this header requires Py_BUILD_CORE define" 10 | #endif 11 | 12 | /* revised ucnhash CAPI interface (exported through a "wrapper") */ 13 | 14 | #define PyUnicodeData_CAPSULE_NAME "unicodedata._ucnhash_CAPI" 15 | 16 | typedef struct { 17 | 18 | /* Get name for a given character code. 19 | Returns non-zero if success, zero if not. 20 | Does not set Python exceptions. */ 21 | int (*getname)(Py_UCS4 code, char* buffer, int buflen, 22 | int with_alias_and_seq); 23 | 24 | /* Get character code for a given name. 25 | Same error handling as for getname(). */ 26 | int (*getcode)(const char* name, int namelen, Py_UCS4* code, 27 | int with_named_seq); 28 | 29 | } _PyUnicode_Name_CAPI; 30 | 31 | #ifdef __cplusplus 32 | } 33 | #endif 34 | #endif /* !Py_INTERNAL_UCNHASH_H */ 35 | -------------------------------------------------------------------------------- /AndroidApp/app/src/main/jni/Pythonx86_64/internal/pycore_unionobject.h: -------------------------------------------------------------------------------- 1 | #ifndef Py_INTERNAL_UNIONOBJECT_H 2 | #define Py_INTERNAL_UNIONOBJECT_H 3 | #ifdef __cplusplus 4 | extern "C" { 5 | #endif 6 | 7 | #ifndef Py_BUILD_CORE 8 | # error "this header requires Py_BUILD_CORE define" 9 | #endif 10 | 11 | extern PyTypeObject _PyUnion_Type; 12 | #define _PyUnion_Check(op) Py_IS_TYPE((op), &_PyUnion_Type) 13 | extern PyObject *_Py_union_type_or(PyObject *, PyObject *); 14 | 15 | #define _PyGenericAlias_Check(op) PyObject_TypeCheck((op), &Py_GenericAliasType) 16 | extern PyObject *_Py_subs_parameters(PyObject *, PyObject *, PyObject *, PyObject *); 17 | extern PyObject *_Py_make_parameters(PyObject *); 18 | extern PyObject *_Py_union_args(PyObject *self); 19 | 20 | #ifdef __cplusplus 21 | } 22 | #endif 23 | #endif /* !Py_INTERNAL_UNIONOBJECT_H */ 24 | -------------------------------------------------------------------------------- /AndroidApp/app/src/main/jni/Pythonx86_64/internal/pycore_warnings.h: -------------------------------------------------------------------------------- 1 | #ifndef Py_INTERNAL_WARNINGS_H 2 | #define Py_INTERNAL_WARNINGS_H 3 | #ifdef __cplusplus 4 | extern "C" { 5 | #endif 6 | 7 | #ifndef Py_BUILD_CORE 8 | # error "this header requires Py_BUILD_CORE define" 9 | #endif 10 | 11 | struct _warnings_runtime_state { 12 | /* Both 'filters' and 'onceregistry' can be set in warnings.py; 13 | get_warnings_attr() will reset these variables accordingly. */ 14 | PyObject *filters; /* List */ 15 | PyObject *once_registry; /* Dict */ 16 | PyObject *default_action; /* String */ 17 | long filters_version; 18 | }; 19 | 20 | extern int _PyWarnings_InitState(PyInterpreterState *interp); 21 | 22 | PyAPI_FUNC(PyObject*) _PyWarnings_Init(void); 23 | 24 | extern void _PyErr_WarnUnawaitedCoroutine(PyObject *coro); 25 | 26 | #ifdef __cplusplus 27 | } 28 | #endif 29 | #endif /* !Py_INTERNAL_WARNINGS_H */ 30 | -------------------------------------------------------------------------------- /AndroidApp/app/src/main/jni/Pythonx86_64/interpreteridobject.h: -------------------------------------------------------------------------------- 1 | #ifndef Py_INTERPRETERIDOBJECT_H 2 | #define Py_INTERPRETERIDOBJECT_H 3 | 4 | #ifdef __cplusplus 5 | extern "C" { 6 | #endif 7 | 8 | #ifndef Py_LIMITED_API 9 | # define Py_CPYTHON_INTERPRETERIDOBJECT_H 10 | # include "cpython/interpreteridobject.h" 11 | # undef Py_CPYTHON_INTERPRETERIDOBJECT_H 12 | #endif 13 | 14 | #ifdef __cplusplus 15 | } 16 | #endif 17 | #endif /* !Py_INTERPRETERIDOBJECT_H */ 18 | -------------------------------------------------------------------------------- /AndroidApp/app/src/main/jni/Pythonx86_64/intrcheck.h: -------------------------------------------------------------------------------- 1 | #ifndef Py_INTRCHECK_H 2 | #define Py_INTRCHECK_H 3 | #ifdef __cplusplus 4 | extern "C" { 5 | #endif 6 | 7 | PyAPI_FUNC(int) PyOS_InterruptOccurred(void); 8 | #ifdef HAVE_FORK 9 | #if !defined(Py_LIMITED_API) || Py_LIMITED_API+0 >= 0x03070000 10 | PyAPI_FUNC(void) PyOS_BeforeFork(void); 11 | PyAPI_FUNC(void) PyOS_AfterFork_Parent(void); 12 | PyAPI_FUNC(void) PyOS_AfterFork_Child(void); 13 | #endif 14 | #endif 15 | /* Deprecated, please use PyOS_AfterFork_Child() instead */ 16 | Py_DEPRECATED(3.7) PyAPI_FUNC(void) PyOS_AfterFork(void); 17 | 18 | #ifndef Py_LIMITED_API 19 | PyAPI_FUNC(int) _PyOS_IsMainThread(void); 20 | 21 | #ifdef MS_WINDOWS 22 | /* windows.h is not included by Python.h so use void* instead of HANDLE */ 23 | PyAPI_FUNC(void*) _PyOS_SigintEvent(void); 24 | #endif 25 | #endif /* !Py_LIMITED_API */ 26 | 27 | #ifdef __cplusplus 28 | } 29 | #endif 30 | #endif /* !Py_INTRCHECK_H */ 31 | -------------------------------------------------------------------------------- /AndroidApp/app/src/main/jni/Pythonx86_64/iterobject.h: -------------------------------------------------------------------------------- 1 | #ifndef Py_ITEROBJECT_H 2 | #define Py_ITEROBJECT_H 3 | /* Iterators (the basic kind, over a sequence) */ 4 | #ifdef __cplusplus 5 | extern "C" { 6 | #endif 7 | 8 | PyAPI_DATA(PyTypeObject) PySeqIter_Type; 9 | PyAPI_DATA(PyTypeObject) PyCallIter_Type; 10 | #ifdef Py_BUILD_CORE 11 | extern PyTypeObject _PyAnextAwaitable_Type; 12 | #endif 13 | 14 | #define PySeqIter_Check(op) Py_IS_TYPE((op), &PySeqIter_Type) 15 | 16 | PyAPI_FUNC(PyObject *) PySeqIter_New(PyObject *); 17 | 18 | 19 | #define PyCallIter_Check(op) Py_IS_TYPE((op), &PyCallIter_Type) 20 | 21 | PyAPI_FUNC(PyObject *) PyCallIter_New(PyObject *, PyObject *); 22 | 23 | #ifdef __cplusplus 24 | } 25 | #endif 26 | #endif /* !Py_ITEROBJECT_H */ 27 | 28 | -------------------------------------------------------------------------------- /AndroidApp/app/src/main/jni/Pythonx86_64/marshal.h: -------------------------------------------------------------------------------- 1 | 2 | /* Interface for marshal.c */ 3 | 4 | #ifndef Py_MARSHAL_H 5 | #define Py_MARSHAL_H 6 | #ifndef Py_LIMITED_API 7 | 8 | #ifdef __cplusplus 9 | extern "C" { 10 | #endif 11 | 12 | PyAPI_FUNC(PyObject *) PyMarshal_ReadObjectFromString(const char *, 13 | Py_ssize_t); 14 | PyAPI_FUNC(PyObject *) PyMarshal_WriteObjectToString(PyObject *, int); 15 | 16 | #define Py_MARSHAL_VERSION 4 17 | 18 | PyAPI_FUNC(long) PyMarshal_ReadLongFromFile(FILE *); 19 | PyAPI_FUNC(int) PyMarshal_ReadShortFromFile(FILE *); 20 | PyAPI_FUNC(PyObject *) PyMarshal_ReadObjectFromFile(FILE *); 21 | PyAPI_FUNC(PyObject *) PyMarshal_ReadLastObjectFromFile(FILE *); 22 | 23 | PyAPI_FUNC(void) PyMarshal_WriteLongToFile(long, FILE *, int); 24 | PyAPI_FUNC(void) PyMarshal_WriteObjectToFile(PyObject *, FILE *, int); 25 | 26 | #ifdef __cplusplus 27 | } 28 | #endif 29 | 30 | #endif /* Py_LIMITED_API */ 31 | #endif /* !Py_MARSHAL_H */ 32 | -------------------------------------------------------------------------------- /AndroidApp/app/src/main/jni/Pythonx86_64/memoryobject.h: -------------------------------------------------------------------------------- 1 | /* Memory view object. In Python this is available as "memoryview". */ 2 | 3 | #ifndef Py_MEMORYOBJECT_H 4 | #define Py_MEMORYOBJECT_H 5 | #ifdef __cplusplus 6 | extern "C" { 7 | #endif 8 | 9 | PyAPI_DATA(PyTypeObject) PyMemoryView_Type; 10 | 11 | #define PyMemoryView_Check(op) Py_IS_TYPE((op), &PyMemoryView_Type) 12 | 13 | PyAPI_FUNC(PyObject *) PyMemoryView_FromObject(PyObject *base); 14 | #if !defined(Py_LIMITED_API) || Py_LIMITED_API+0 >= 0x03030000 15 | PyAPI_FUNC(PyObject *) PyMemoryView_FromMemory(char *mem, Py_ssize_t size, 16 | int flags); 17 | #endif 18 | #if !defined(Py_LIMITED_API) || Py_LIMITED_API+0 >= 0x030b0000 19 | PyAPI_FUNC(PyObject *) PyMemoryView_FromBuffer(const Py_buffer *info); 20 | #endif 21 | PyAPI_FUNC(PyObject *) PyMemoryView_GetContiguous(PyObject *base, 22 | int buffertype, 23 | char order); 24 | 25 | #ifndef Py_LIMITED_API 26 | # define Py_CPYTHON_MEMORYOBJECT_H 27 | # include "cpython/memoryobject.h" 28 | # undef Py_CPYTHON_MEMORYOBJECT_H 29 | #endif 30 | 31 | #ifdef __cplusplus 32 | } 33 | #endif 34 | #endif /* !Py_MEMORYOBJECT_H */ 35 | -------------------------------------------------------------------------------- /AndroidApp/app/src/main/jni/Pythonx86_64/osdefs.h: -------------------------------------------------------------------------------- 1 | #ifndef Py_OSDEFS_H 2 | #define Py_OSDEFS_H 3 | #ifdef __cplusplus 4 | extern "C" { 5 | #endif 6 | 7 | 8 | /* Operating system dependencies */ 9 | 10 | #ifdef MS_WINDOWS 11 | #define SEP L'\\' 12 | #define ALTSEP L'/' 13 | #define MAXPATHLEN 256 14 | #define DELIM L';' 15 | #endif 16 | 17 | #ifdef __VXWORKS__ 18 | #define DELIM L';' 19 | #endif 20 | 21 | /* Filename separator */ 22 | #ifndef SEP 23 | #define SEP L'/' 24 | #endif 25 | 26 | /* Max pathname length */ 27 | #ifdef __hpux 28 | #include 29 | #include 30 | #ifndef PATH_MAX 31 | #define PATH_MAX MAXPATHLEN 32 | #endif 33 | #endif 34 | 35 | #ifndef MAXPATHLEN 36 | #if defined(PATH_MAX) && PATH_MAX > 1024 37 | #define MAXPATHLEN PATH_MAX 38 | #else 39 | #define MAXPATHLEN 1024 40 | #endif 41 | #endif 42 | 43 | /* Search path entry delimiter */ 44 | #ifndef DELIM 45 | #define DELIM L':' 46 | #endif 47 | 48 | #ifdef __cplusplus 49 | } 50 | #endif 51 | #endif /* !Py_OSDEFS_H */ 52 | -------------------------------------------------------------------------------- /AndroidApp/app/src/main/jni/Pythonx86_64/osmodule.h: -------------------------------------------------------------------------------- 1 | 2 | /* os module interface */ 3 | 4 | #ifndef Py_OSMODULE_H 5 | #define Py_OSMODULE_H 6 | #ifdef __cplusplus 7 | extern "C" { 8 | #endif 9 | 10 | #if !defined(Py_LIMITED_API) || Py_LIMITED_API+0 >= 0x03060000 11 | PyAPI_FUNC(PyObject *) PyOS_FSPath(PyObject *path); 12 | #endif 13 | 14 | #ifdef __cplusplus 15 | } 16 | #endif 17 | #endif /* !Py_OSMODULE_H */ 18 | -------------------------------------------------------------------------------- /AndroidApp/app/src/main/jni/Pythonx86_64/patchlevel.h: -------------------------------------------------------------------------------- 1 | 2 | /* Python version identification scheme. 3 | 4 | When the major or minor version changes, the VERSION variable in 5 | configure.ac must also be changed. 6 | 7 | There is also (independent) API version information in modsupport.h. 8 | */ 9 | 10 | /* Values for PY_RELEASE_LEVEL */ 11 | #define PY_RELEASE_LEVEL_ALPHA 0xA 12 | #define PY_RELEASE_LEVEL_BETA 0xB 13 | #define PY_RELEASE_LEVEL_GAMMA 0xC /* For release candidates */ 14 | #define PY_RELEASE_LEVEL_FINAL 0xF /* Serial should be 0 here */ 15 | /* Higher for patch releases */ 16 | 17 | /* Version parsed out into numeric values */ 18 | /*--start constants--*/ 19 | #define PY_MAJOR_VERSION 3 20 | #define PY_MINOR_VERSION 12 21 | #define PY_MICRO_VERSION 4 22 | #define PY_RELEASE_LEVEL PY_RELEASE_LEVEL_FINAL 23 | #define PY_RELEASE_SERIAL 0 24 | 25 | /* Version as a string */ 26 | #define PY_VERSION "3.12.4" 27 | /*--end constants--*/ 28 | 29 | /* Version as a single 4-byte hex number, e.g. 0x010502B2 == 1.5.2b2. 30 | Use this for numeric comparisons, e.g. #if PY_VERSION_HEX >= ... */ 31 | #define PY_VERSION_HEX ((PY_MAJOR_VERSION << 24) | \ 32 | (PY_MINOR_VERSION << 16) | \ 33 | (PY_MICRO_VERSION << 8) | \ 34 | (PY_RELEASE_LEVEL << 4) | \ 35 | (PY_RELEASE_SERIAL << 0)) 36 | -------------------------------------------------------------------------------- /AndroidApp/app/src/main/jni/Pythonx86_64/pyframe.h: -------------------------------------------------------------------------------- 1 | /* Limited C API of PyFrame API 2 | * 3 | * Include "frameobject.h" to get the PyFrameObject structure. 4 | */ 5 | 6 | #ifndef Py_PYFRAME_H 7 | #define Py_PYFRAME_H 8 | #ifdef __cplusplus 9 | extern "C" { 10 | #endif 11 | 12 | /* Return the line of code the frame is currently executing. */ 13 | PyAPI_FUNC(int) PyFrame_GetLineNumber(PyFrameObject *); 14 | 15 | PyAPI_FUNC(PyCodeObject *) PyFrame_GetCode(PyFrameObject *frame); 16 | 17 | #ifndef Py_LIMITED_API 18 | # define Py_CPYTHON_PYFRAME_H 19 | # include "cpython/pyframe.h" 20 | # undef Py_CPYTHON_PYFRAME_H 21 | #endif 22 | 23 | #ifdef __cplusplus 24 | } 25 | #endif 26 | #endif /* !Py_PYFRAME_H */ 27 | -------------------------------------------------------------------------------- /AndroidApp/app/src/main/jni/Pythonx86_64/pystrcmp.h: -------------------------------------------------------------------------------- 1 | #ifndef Py_STRCMP_H 2 | #define Py_STRCMP_H 3 | 4 | #ifdef __cplusplus 5 | extern "C" { 6 | #endif 7 | 8 | PyAPI_FUNC(int) PyOS_mystrnicmp(const char *, const char *, Py_ssize_t); 9 | PyAPI_FUNC(int) PyOS_mystricmp(const char *, const char *); 10 | 11 | #ifdef MS_WINDOWS 12 | #define PyOS_strnicmp strnicmp 13 | #define PyOS_stricmp stricmp 14 | #else 15 | #define PyOS_strnicmp PyOS_mystrnicmp 16 | #define PyOS_stricmp PyOS_mystricmp 17 | #endif 18 | 19 | #ifdef __cplusplus 20 | } 21 | #endif 22 | 23 | #endif /* !Py_STRCMP_H */ 24 | -------------------------------------------------------------------------------- /AndroidApp/app/src/main/jni/Pythonx86_64/pystrtod.h: -------------------------------------------------------------------------------- 1 | #ifndef Py_STRTOD_H 2 | #define Py_STRTOD_H 3 | 4 | #ifdef __cplusplus 5 | extern "C" { 6 | #endif 7 | 8 | 9 | PyAPI_FUNC(double) PyOS_string_to_double(const char *str, 10 | char **endptr, 11 | PyObject *overflow_exception); 12 | 13 | /* The caller is responsible for calling PyMem_Free to free the buffer 14 | that's is returned. */ 15 | PyAPI_FUNC(char *) PyOS_double_to_string(double val, 16 | char format_code, 17 | int precision, 18 | int flags, 19 | int *type); 20 | 21 | #ifndef Py_LIMITED_API 22 | PyAPI_FUNC(PyObject *) _Py_string_to_number_with_underscores( 23 | const char *str, Py_ssize_t len, const char *what, PyObject *obj, void *arg, 24 | PyObject *(*innerfunc)(const char *, Py_ssize_t, void *)); 25 | 26 | PyAPI_FUNC(double) _Py_parse_inf_or_nan(const char *p, char **endptr); 27 | #endif 28 | 29 | 30 | /* PyOS_double_to_string's "flags" parameter can be set to 0 or more of: */ 31 | #define Py_DTSF_SIGN 0x01 /* always add the sign */ 32 | #define Py_DTSF_ADD_DOT_0 0x02 /* if the result is an integer add ".0" */ 33 | #define Py_DTSF_ALT 0x04 /* "alternate" formatting. it's format_code 34 | specific */ 35 | #define Py_DTSF_NO_NEG_0 0x08 /* negative zero result is coerced to 0 */ 36 | 37 | /* PyOS_double_to_string's "type", if non-NULL, will be set to one of: */ 38 | #define Py_DTST_FINITE 0 39 | #define Py_DTST_INFINITE 1 40 | #define Py_DTST_NAN 2 41 | 42 | #ifdef __cplusplus 43 | } 44 | #endif 45 | 46 | #endif /* !Py_STRTOD_H */ 47 | -------------------------------------------------------------------------------- /AndroidApp/app/src/main/jni/Pythonx86_64/pythonrun.h: -------------------------------------------------------------------------------- 1 | 2 | /* Interfaces to parse and execute pieces of python code */ 3 | 4 | #ifndef Py_PYTHONRUN_H 5 | #define Py_PYTHONRUN_H 6 | #ifdef __cplusplus 7 | extern "C" { 8 | #endif 9 | 10 | PyAPI_FUNC(PyObject *) Py_CompileString(const char *, const char *, int); 11 | 12 | PyAPI_FUNC(void) PyErr_Print(void); 13 | PyAPI_FUNC(void) PyErr_PrintEx(int); 14 | PyAPI_FUNC(void) PyErr_Display(PyObject *, PyObject *, PyObject *); 15 | 16 | #if !defined(Py_LIMITED_API) || Py_LIMITED_API+0 >= 0x030C0000 17 | PyAPI_FUNC(void) PyErr_DisplayException(PyObject *); 18 | #endif 19 | 20 | 21 | /* Stuff with no proper home (yet) */ 22 | PyAPI_DATA(int) (*PyOS_InputHook)(void); 23 | 24 | /* Stack size, in "pointers" (so we get extra safety margins 25 | on 64-bit platforms). On a 32-bit platform, this translates 26 | to an 8k margin. */ 27 | #define PYOS_STACK_MARGIN 2048 28 | 29 | #if defined(WIN32) && !defined(MS_WIN64) && !defined(_M_ARM) && defined(_MSC_VER) && _MSC_VER >= 1300 30 | /* Enable stack checking under Microsoft C */ 31 | // When changing the platforms, ensure PyOS_CheckStack() docs are still correct 32 | #define USE_STACKCHECK 33 | #endif 34 | 35 | #ifdef USE_STACKCHECK 36 | /* Check that we aren't overflowing our stack */ 37 | PyAPI_FUNC(int) PyOS_CheckStack(void); 38 | #endif 39 | 40 | #ifndef Py_LIMITED_API 41 | # define Py_CPYTHON_PYTHONRUN_H 42 | # include "cpython/pythonrun.h" 43 | # undef Py_CPYTHON_PYTHONRUN_H 44 | #endif 45 | 46 | #ifdef __cplusplus 47 | } 48 | #endif 49 | #endif /* !Py_PYTHONRUN_H */ 50 | -------------------------------------------------------------------------------- /AndroidApp/app/src/main/jni/Pythonx86_64/pytypedefs.h: -------------------------------------------------------------------------------- 1 | // Forward declarations of types of the Python C API. 2 | // Declare them at the same place since redefining typedef is a C11 feature. 3 | // Only use a forward declaration if there is an interdependency between two 4 | // header files. 5 | 6 | #ifndef Py_PYTYPEDEFS_H 7 | #define Py_PYTYPEDEFS_H 8 | #ifdef __cplusplus 9 | extern "C" { 10 | #endif 11 | 12 | typedef struct PyModuleDef PyModuleDef; 13 | typedef struct PyModuleDef_Slot PyModuleDef_Slot; 14 | typedef struct PyMethodDef PyMethodDef; 15 | typedef struct PyGetSetDef PyGetSetDef; 16 | typedef struct PyMemberDef PyMemberDef; 17 | 18 | typedef struct _object PyObject; 19 | typedef struct _longobject PyLongObject; 20 | typedef struct _typeobject PyTypeObject; 21 | typedef struct PyCodeObject PyCodeObject; 22 | typedef struct _frame PyFrameObject; 23 | 24 | typedef struct _ts PyThreadState; 25 | typedef struct _is PyInterpreterState; 26 | 27 | #ifdef __cplusplus 28 | } 29 | #endif 30 | #endif // !Py_PYTYPEDEFS_H 31 | -------------------------------------------------------------------------------- /AndroidApp/app/src/main/jni/Pythonx86_64/rangeobject.h: -------------------------------------------------------------------------------- 1 | 2 | /* Range object interface */ 3 | 4 | #ifndef Py_RANGEOBJECT_H 5 | #define Py_RANGEOBJECT_H 6 | #ifdef __cplusplus 7 | extern "C" { 8 | #endif 9 | 10 | /* 11 | A range object represents an integer range. This is an immutable object; 12 | a range cannot change its value after creation. 13 | 14 | Range objects behave like the corresponding tuple objects except that 15 | they are represented by a start, stop, and step datamembers. 16 | */ 17 | 18 | PyAPI_DATA(PyTypeObject) PyRange_Type; 19 | PyAPI_DATA(PyTypeObject) PyRangeIter_Type; 20 | PyAPI_DATA(PyTypeObject) PyLongRangeIter_Type; 21 | 22 | #define PyRange_Check(op) Py_IS_TYPE((op), &PyRange_Type) 23 | 24 | #ifdef __cplusplus 25 | } 26 | #endif 27 | #endif /* !Py_RANGEOBJECT_H */ 28 | -------------------------------------------------------------------------------- /AndroidApp/app/src/main/jni/Pythonx86_64/setobject.h: -------------------------------------------------------------------------------- 1 | /* Set object interface */ 2 | 3 | #ifndef Py_SETOBJECT_H 4 | #define Py_SETOBJECT_H 5 | #ifdef __cplusplus 6 | extern "C" { 7 | #endif 8 | 9 | PyAPI_DATA(PyTypeObject) PySet_Type; 10 | PyAPI_DATA(PyTypeObject) PyFrozenSet_Type; 11 | PyAPI_DATA(PyTypeObject) PySetIter_Type; 12 | 13 | PyAPI_FUNC(PyObject *) PySet_New(PyObject *); 14 | PyAPI_FUNC(PyObject *) PyFrozenSet_New(PyObject *); 15 | 16 | PyAPI_FUNC(int) PySet_Add(PyObject *set, PyObject *key); 17 | PyAPI_FUNC(int) PySet_Clear(PyObject *set); 18 | PyAPI_FUNC(int) PySet_Contains(PyObject *anyset, PyObject *key); 19 | PyAPI_FUNC(int) PySet_Discard(PyObject *set, PyObject *key); 20 | PyAPI_FUNC(PyObject *) PySet_Pop(PyObject *set); 21 | PyAPI_FUNC(Py_ssize_t) PySet_Size(PyObject *anyset); 22 | 23 | #define PyFrozenSet_CheckExact(ob) Py_IS_TYPE((ob), &PyFrozenSet_Type) 24 | #define PyFrozenSet_Check(ob) \ 25 | (Py_IS_TYPE((ob), &PyFrozenSet_Type) || \ 26 | PyType_IsSubtype(Py_TYPE(ob), &PyFrozenSet_Type)) 27 | 28 | #define PyAnySet_CheckExact(ob) \ 29 | (Py_IS_TYPE((ob), &PySet_Type) || Py_IS_TYPE((ob), &PyFrozenSet_Type)) 30 | #define PyAnySet_Check(ob) \ 31 | (Py_IS_TYPE((ob), &PySet_Type) || Py_IS_TYPE((ob), &PyFrozenSet_Type) || \ 32 | PyType_IsSubtype(Py_TYPE(ob), &PySet_Type) || \ 33 | PyType_IsSubtype(Py_TYPE(ob), &PyFrozenSet_Type)) 34 | 35 | #define PySet_CheckExact(op) Py_IS_TYPE(op, &PySet_Type) 36 | #define PySet_Check(ob) \ 37 | (Py_IS_TYPE((ob), &PySet_Type) || \ 38 | PyType_IsSubtype(Py_TYPE(ob), &PySet_Type)) 39 | 40 | #ifndef Py_LIMITED_API 41 | # define Py_CPYTHON_SETOBJECT_H 42 | # include "cpython/setobject.h" 43 | # undef Py_CPYTHON_SETOBJECT_H 44 | #endif 45 | 46 | #ifdef __cplusplus 47 | } 48 | #endif 49 | #endif /* !Py_SETOBJECT_H */ 50 | -------------------------------------------------------------------------------- /AndroidApp/app/src/main/jni/Pythonx86_64/structseq.h: -------------------------------------------------------------------------------- 1 | 2 | /* Named tuple object interface */ 3 | 4 | #ifndef Py_STRUCTSEQ_H 5 | #define Py_STRUCTSEQ_H 6 | #ifdef __cplusplus 7 | extern "C" { 8 | #endif 9 | 10 | typedef struct PyStructSequence_Field { 11 | const char *name; 12 | const char *doc; 13 | } PyStructSequence_Field; 14 | 15 | typedef struct PyStructSequence_Desc { 16 | const char *name; 17 | const char *doc; 18 | PyStructSequence_Field *fields; 19 | int n_in_sequence; 20 | } PyStructSequence_Desc; 21 | 22 | PyAPI_DATA(const char * const) PyStructSequence_UnnamedField; 23 | 24 | #ifndef Py_LIMITED_API 25 | PyAPI_FUNC(void) PyStructSequence_InitType(PyTypeObject *type, 26 | PyStructSequence_Desc *desc); 27 | PyAPI_FUNC(int) PyStructSequence_InitType2(PyTypeObject *type, 28 | PyStructSequence_Desc *desc); 29 | #endif 30 | PyAPI_FUNC(PyTypeObject*) PyStructSequence_NewType(PyStructSequence_Desc *desc); 31 | 32 | PyAPI_FUNC(PyObject *) PyStructSequence_New(PyTypeObject* type); 33 | 34 | #ifndef Py_LIMITED_API 35 | typedef PyTupleObject PyStructSequence; 36 | 37 | /* Macro, *only* to be used to fill in brand new objects */ 38 | #define PyStructSequence_SET_ITEM(op, i, v) PyTuple_SET_ITEM((op), (i), (v)) 39 | 40 | #define PyStructSequence_GET_ITEM(op, i) PyTuple_GET_ITEM((op), (i)) 41 | #endif 42 | 43 | PyAPI_FUNC(void) PyStructSequence_SetItem(PyObject*, Py_ssize_t, PyObject*); 44 | PyAPI_FUNC(PyObject*) PyStructSequence_GetItem(PyObject*, Py_ssize_t); 45 | 46 | #ifdef __cplusplus 47 | } 48 | #endif 49 | #endif /* !Py_STRUCTSEQ_H */ 50 | -------------------------------------------------------------------------------- /AndroidApp/app/src/main/jni/Pythonx86_64/traceback.h: -------------------------------------------------------------------------------- 1 | #ifndef Py_TRACEBACK_H 2 | #define Py_TRACEBACK_H 3 | #ifdef __cplusplus 4 | extern "C" { 5 | #endif 6 | 7 | /* Traceback interface */ 8 | 9 | PyAPI_FUNC(int) PyTraceBack_Here(PyFrameObject *); 10 | PyAPI_FUNC(int) PyTraceBack_Print(PyObject *, PyObject *); 11 | 12 | /* Reveal traceback type so we can typecheck traceback objects */ 13 | PyAPI_DATA(PyTypeObject) PyTraceBack_Type; 14 | #define PyTraceBack_Check(v) Py_IS_TYPE((v), &PyTraceBack_Type) 15 | 16 | 17 | #ifndef Py_LIMITED_API 18 | # define Py_CPYTHON_TRACEBACK_H 19 | # include "cpython/traceback.h" 20 | # undef Py_CPYTHON_TRACEBACK_H 21 | #endif 22 | 23 | #ifdef __cplusplus 24 | } 25 | #endif 26 | #endif /* !Py_TRACEBACK_H */ 27 | -------------------------------------------------------------------------------- /AndroidApp/app/src/main/jni/Pythonx86_64/tupleobject.h: -------------------------------------------------------------------------------- 1 | /* Tuple object interface */ 2 | 3 | #ifndef Py_TUPLEOBJECT_H 4 | #define Py_TUPLEOBJECT_H 5 | #ifdef __cplusplus 6 | extern "C" { 7 | #endif 8 | 9 | /* 10 | Another generally useful object type is a tuple of object pointers. 11 | For Python, this is an immutable type. C code can change the tuple items 12 | (but not their number), and even use tuples as general-purpose arrays of 13 | object references, but in general only brand new tuples should be mutated, 14 | not ones that might already have been exposed to Python code. 15 | 16 | *** WARNING *** PyTuple_SetItem does not increment the new item's reference 17 | count, but does decrement the reference count of the item it replaces, 18 | if not nil. It does *decrement* the reference count if it is *not* 19 | inserted in the tuple. Similarly, PyTuple_GetItem does not increment the 20 | returned item's reference count. 21 | */ 22 | 23 | PyAPI_DATA(PyTypeObject) PyTuple_Type; 24 | PyAPI_DATA(PyTypeObject) PyTupleIter_Type; 25 | 26 | #define PyTuple_Check(op) \ 27 | PyType_FastSubclass(Py_TYPE(op), Py_TPFLAGS_TUPLE_SUBCLASS) 28 | #define PyTuple_CheckExact(op) Py_IS_TYPE((op), &PyTuple_Type) 29 | 30 | PyAPI_FUNC(PyObject *) PyTuple_New(Py_ssize_t size); 31 | PyAPI_FUNC(Py_ssize_t) PyTuple_Size(PyObject *); 32 | PyAPI_FUNC(PyObject *) PyTuple_GetItem(PyObject *, Py_ssize_t); 33 | PyAPI_FUNC(int) PyTuple_SetItem(PyObject *, Py_ssize_t, PyObject *); 34 | PyAPI_FUNC(PyObject *) PyTuple_GetSlice(PyObject *, Py_ssize_t, Py_ssize_t); 35 | PyAPI_FUNC(PyObject *) PyTuple_Pack(Py_ssize_t, ...); 36 | 37 | #ifndef Py_LIMITED_API 38 | # define Py_CPYTHON_TUPLEOBJECT_H 39 | # include "cpython/tupleobject.h" 40 | # undef Py_CPYTHON_TUPLEOBJECT_H 41 | #endif 42 | 43 | #ifdef __cplusplus 44 | } 45 | #endif 46 | #endif /* !Py_TUPLEOBJECT_H */ 47 | -------------------------------------------------------------------------------- /AndroidApp/app/src/main/jni/Pythonx86_64/warnings.h: -------------------------------------------------------------------------------- 1 | #ifndef Py_WARNINGS_H 2 | #define Py_WARNINGS_H 3 | #ifdef __cplusplus 4 | extern "C" { 5 | #endif 6 | 7 | PyAPI_FUNC(int) PyErr_WarnEx( 8 | PyObject *category, 9 | const char *message, /* UTF-8 encoded string */ 10 | Py_ssize_t stack_level); 11 | 12 | PyAPI_FUNC(int) PyErr_WarnFormat( 13 | PyObject *category, 14 | Py_ssize_t stack_level, 15 | const char *format, /* ASCII-encoded string */ 16 | ...); 17 | 18 | #if !defined(Py_LIMITED_API) || Py_LIMITED_API+0 >= 0x03060000 19 | /* Emit a ResourceWarning warning */ 20 | PyAPI_FUNC(int) PyErr_ResourceWarning( 21 | PyObject *source, 22 | Py_ssize_t stack_level, 23 | const char *format, /* ASCII-encoded string */ 24 | ...); 25 | #endif 26 | 27 | PyAPI_FUNC(int) PyErr_WarnExplicit( 28 | PyObject *category, 29 | const char *message, /* UTF-8 encoded string */ 30 | const char *filename, /* decoded from the filesystem encoding */ 31 | int lineno, 32 | const char *module, /* UTF-8 encoded string */ 33 | PyObject *registry); 34 | 35 | #ifndef Py_LIMITED_API 36 | # define Py_CPYTHON_WARNINGS_H 37 | # include "cpython/warnings.h" 38 | # undef Py_CPYTHON_WARNINGS_H 39 | #endif 40 | 41 | #ifdef __cplusplus 42 | } 43 | #endif 44 | #endif /* !Py_WARNINGS_H */ 45 | 46 | -------------------------------------------------------------------------------- /AndroidApp/app/src/main/jni/Pythonx86_64/weakrefobject.h: -------------------------------------------------------------------------------- 1 | /* Weak references objects for Python. */ 2 | 3 | #ifndef Py_WEAKREFOBJECT_H 4 | #define Py_WEAKREFOBJECT_H 5 | #ifdef __cplusplus 6 | extern "C" { 7 | #endif 8 | 9 | typedef struct _PyWeakReference PyWeakReference; 10 | 11 | PyAPI_DATA(PyTypeObject) _PyWeakref_RefType; 12 | PyAPI_DATA(PyTypeObject) _PyWeakref_ProxyType; 13 | PyAPI_DATA(PyTypeObject) _PyWeakref_CallableProxyType; 14 | 15 | #define PyWeakref_CheckRef(op) PyObject_TypeCheck((op), &_PyWeakref_RefType) 16 | #define PyWeakref_CheckRefExact(op) \ 17 | Py_IS_TYPE((op), &_PyWeakref_RefType) 18 | #define PyWeakref_CheckProxy(op) \ 19 | (Py_IS_TYPE((op), &_PyWeakref_ProxyType) \ 20 | || Py_IS_TYPE((op), &_PyWeakref_CallableProxyType)) 21 | 22 | #define PyWeakref_Check(op) \ 23 | (PyWeakref_CheckRef(op) || PyWeakref_CheckProxy(op)) 24 | 25 | 26 | PyAPI_FUNC(PyObject *) PyWeakref_NewRef(PyObject *ob, 27 | PyObject *callback); 28 | PyAPI_FUNC(PyObject *) PyWeakref_NewProxy(PyObject *ob, 29 | PyObject *callback); 30 | PyAPI_FUNC(PyObject *) PyWeakref_GetObject(PyObject *ref); 31 | 32 | 33 | #ifndef Py_LIMITED_API 34 | # define Py_CPYTHON_WEAKREFOBJECT_H 35 | # include "cpython/weakrefobject.h" 36 | # undef Py_CPYTHON_WEAKREFOBJECT_H 37 | #endif 38 | 39 | #ifdef __cplusplus 40 | } 41 | #endif 42 | #endif /* !Py_WEAKREFOBJECT_H */ 43 | -------------------------------------------------------------------------------- /AndroidApp/app/src/main/jni/StdAfx.cpp: -------------------------------------------------------------------------------- 1 | 2 | #include 3 | 4 | #include 5 | #include 6 | -------------------------------------------------------------------------------- /AndroidApp/app/src/main/jni/StdAfx.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | 4 | #include "StdAfx.h" 5 | #include 6 | #include 7 | #include 8 | #include 9 | 10 | #include "util.hpp" 11 | #include "conversion.hpp" 12 | 13 | 14 | -------------------------------------------------------------------------------- /AndroidApp/app/src/main/jni/python64/bltinmodule.h: -------------------------------------------------------------------------------- 1 | #ifndef Py_BLTINMODULE_H 2 | #define Py_BLTINMODULE_H 3 | #ifdef __cplusplus 4 | extern "C" { 5 | #endif 6 | 7 | PyAPI_DATA(PyTypeObject) PyFilter_Type; 8 | PyAPI_DATA(PyTypeObject) PyMap_Type; 9 | PyAPI_DATA(PyTypeObject) PyZip_Type; 10 | 11 | #ifdef __cplusplus 12 | } 13 | #endif 14 | #endif /* !Py_BLTINMODULE_H */ 15 | -------------------------------------------------------------------------------- /AndroidApp/app/src/main/jni/python64/boolobject.h: -------------------------------------------------------------------------------- 1 | /* Boolean object interface */ 2 | 3 | #ifndef Py_BOOLOBJECT_H 4 | #define Py_BOOLOBJECT_H 5 | #ifdef __cplusplus 6 | extern "C" { 7 | #endif 8 | 9 | 10 | // PyBool_Type is declared by object.h 11 | 12 | #define PyBool_Check(x) Py_IS_TYPE((x), &PyBool_Type) 13 | 14 | /* Py_False and Py_True are the only two bools in existence. */ 15 | 16 | /* Don't use these directly */ 17 | PyAPI_DATA(PyLongObject) _Py_FalseStruct; 18 | PyAPI_DATA(PyLongObject) _Py_TrueStruct; 19 | 20 | /* Use these macros */ 21 | #define Py_False _PyObject_CAST(&_Py_FalseStruct) 22 | #define Py_True _PyObject_CAST(&_Py_TrueStruct) 23 | 24 | // Test if an object is the True singleton, the same as "x is True" in Python. 25 | PyAPI_FUNC(int) Py_IsTrue(PyObject *x); 26 | #define Py_IsTrue(x) Py_Is((x), Py_True) 27 | 28 | // Test if an object is the False singleton, the same as "x is False" in Python. 29 | PyAPI_FUNC(int) Py_IsFalse(PyObject *x); 30 | #define Py_IsFalse(x) Py_Is((x), Py_False) 31 | 32 | /* Macros for returning Py_True or Py_False, respectively */ 33 | #define Py_RETURN_TRUE return Py_True 34 | #define Py_RETURN_FALSE return Py_False 35 | 36 | /* Function to return a bool from a C long */ 37 | PyAPI_FUNC(PyObject *) PyBool_FromLong(long); 38 | 39 | #ifdef __cplusplus 40 | } 41 | #endif 42 | #endif /* !Py_BOOLOBJECT_H */ 43 | -------------------------------------------------------------------------------- /AndroidApp/app/src/main/jni/python64/bytearrayobject.h: -------------------------------------------------------------------------------- 1 | /* ByteArray object interface */ 2 | 3 | #ifndef Py_BYTEARRAYOBJECT_H 4 | #define Py_BYTEARRAYOBJECT_H 5 | #ifdef __cplusplus 6 | extern "C" { 7 | #endif 8 | 9 | /* Type PyByteArrayObject represents a mutable array of bytes. 10 | * The Python API is that of a sequence; 11 | * the bytes are mapped to ints in [0, 256). 12 | * Bytes are not characters; they may be used to encode characters. 13 | * The only way to go between bytes and str/unicode is via encoding 14 | * and decoding. 15 | * For the convenience of C programmers, the bytes type is considered 16 | * to contain a char pointer, not an unsigned char pointer. 17 | */ 18 | 19 | /* Type object */ 20 | PyAPI_DATA(PyTypeObject) PyByteArray_Type; 21 | PyAPI_DATA(PyTypeObject) PyByteArrayIter_Type; 22 | 23 | /* Type check macros */ 24 | #define PyByteArray_Check(self) PyObject_TypeCheck((self), &PyByteArray_Type) 25 | #define PyByteArray_CheckExact(self) Py_IS_TYPE((self), &PyByteArray_Type) 26 | 27 | /* Direct API functions */ 28 | PyAPI_FUNC(PyObject *) PyByteArray_FromObject(PyObject *); 29 | PyAPI_FUNC(PyObject *) PyByteArray_Concat(PyObject *, PyObject *); 30 | PyAPI_FUNC(PyObject *) PyByteArray_FromStringAndSize(const char *, Py_ssize_t); 31 | PyAPI_FUNC(Py_ssize_t) PyByteArray_Size(PyObject *); 32 | PyAPI_FUNC(char *) PyByteArray_AsString(PyObject *); 33 | PyAPI_FUNC(int) PyByteArray_Resize(PyObject *, Py_ssize_t); 34 | 35 | #ifndef Py_LIMITED_API 36 | # define Py_CPYTHON_BYTEARRAYOBJECT_H 37 | # include "cpython/bytearrayobject.h" 38 | # undef Py_CPYTHON_BYTEARRAYOBJECT_H 39 | #endif 40 | 41 | #ifdef __cplusplus 42 | } 43 | #endif 44 | #endif /* !Py_BYTEARRAYOBJECT_H */ 45 | -------------------------------------------------------------------------------- /AndroidApp/app/src/main/jni/python64/compile.h: -------------------------------------------------------------------------------- 1 | #ifndef Py_COMPILE_H 2 | #define Py_COMPILE_H 3 | #ifdef __cplusplus 4 | extern "C" { 5 | #endif 6 | 7 | /* These definitions must match corresponding definitions in graminit.h. */ 8 | #define Py_single_input 256 9 | #define Py_file_input 257 10 | #define Py_eval_input 258 11 | #define Py_func_type_input 345 12 | 13 | #ifndef Py_LIMITED_API 14 | # define Py_CPYTHON_COMPILE_H 15 | # include "cpython/compile.h" 16 | # undef Py_CPYTHON_COMPILE_H 17 | #endif 18 | 19 | #ifdef __cplusplus 20 | } 21 | #endif 22 | #endif /* !Py_COMPILE_H */ 23 | -------------------------------------------------------------------------------- /AndroidApp/app/src/main/jni/python64/complexobject.h: -------------------------------------------------------------------------------- 1 | /* Complex number structure */ 2 | 3 | #ifndef Py_COMPLEXOBJECT_H 4 | #define Py_COMPLEXOBJECT_H 5 | #ifdef __cplusplus 6 | extern "C" { 7 | #endif 8 | 9 | /* Complex object interface */ 10 | 11 | PyAPI_DATA(PyTypeObject) PyComplex_Type; 12 | 13 | #define PyComplex_Check(op) PyObject_TypeCheck((op), &PyComplex_Type) 14 | #define PyComplex_CheckExact(op) Py_IS_TYPE((op), &PyComplex_Type) 15 | 16 | PyAPI_FUNC(PyObject *) PyComplex_FromDoubles(double real, double imag); 17 | 18 | PyAPI_FUNC(double) PyComplex_RealAsDouble(PyObject *op); 19 | PyAPI_FUNC(double) PyComplex_ImagAsDouble(PyObject *op); 20 | 21 | #ifndef Py_LIMITED_API 22 | # define Py_CPYTHON_COMPLEXOBJECT_H 23 | # include "cpython/complexobject.h" 24 | # undef Py_CPYTHON_COMPLEXOBJECT_H 25 | #endif 26 | 27 | #ifdef __cplusplus 28 | } 29 | #endif 30 | #endif /* !Py_COMPLEXOBJECT_H */ 31 | -------------------------------------------------------------------------------- /AndroidApp/app/src/main/jni/python64/cpython/bytearrayobject.h: -------------------------------------------------------------------------------- 1 | #ifndef Py_CPYTHON_BYTEARRAYOBJECT_H 2 | # error "this header file must not be included directly" 3 | #endif 4 | 5 | /* Object layout */ 6 | typedef struct { 7 | PyObject_VAR_HEAD 8 | Py_ssize_t ob_alloc; /* How many bytes allocated in ob_bytes */ 9 | char *ob_bytes; /* Physical backing buffer */ 10 | char *ob_start; /* Logical start inside ob_bytes */ 11 | Py_ssize_t ob_exports; /* How many buffer exports */ 12 | } PyByteArrayObject; 13 | 14 | PyAPI_DATA(char) _PyByteArray_empty_string[]; 15 | 16 | /* Macros and static inline functions, trading safety for speed */ 17 | #define _PyByteArray_CAST(op) \ 18 | (assert(PyByteArray_Check(op)), _Py_CAST(PyByteArrayObject*, op)) 19 | 20 | static inline char* PyByteArray_AS_STRING(PyObject *op) 21 | { 22 | PyByteArrayObject *self = _PyByteArray_CAST(op); 23 | if (Py_SIZE(self)) { 24 | return self->ob_start; 25 | } 26 | return _PyByteArray_empty_string; 27 | } 28 | #define PyByteArray_AS_STRING(self) PyByteArray_AS_STRING(_PyObject_CAST(self)) 29 | 30 | static inline Py_ssize_t PyByteArray_GET_SIZE(PyObject *op) { 31 | PyByteArrayObject *self = _PyByteArray_CAST(op); 32 | return Py_SIZE(self); 33 | } 34 | #define PyByteArray_GET_SIZE(self) PyByteArray_GET_SIZE(_PyObject_CAST(self)) 35 | -------------------------------------------------------------------------------- /AndroidApp/app/src/main/jni/python64/cpython/cellobject.h: -------------------------------------------------------------------------------- 1 | /* Cell object interface */ 2 | 3 | #ifndef Py_LIMITED_API 4 | #ifndef Py_CELLOBJECT_H 5 | #define Py_CELLOBJECT_H 6 | #ifdef __cplusplus 7 | extern "C" { 8 | #endif 9 | 10 | typedef struct { 11 | PyObject_HEAD 12 | /* Content of the cell or NULL when empty */ 13 | PyObject *ob_ref; 14 | } PyCellObject; 15 | 16 | PyAPI_DATA(PyTypeObject) PyCell_Type; 17 | 18 | #define PyCell_Check(op) Py_IS_TYPE((op), &PyCell_Type) 19 | 20 | PyAPI_FUNC(PyObject *) PyCell_New(PyObject *); 21 | PyAPI_FUNC(PyObject *) PyCell_Get(PyObject *); 22 | PyAPI_FUNC(int) PyCell_Set(PyObject *, PyObject *); 23 | 24 | static inline PyObject* PyCell_GET(PyObject *op) { 25 | PyCellObject *cell; 26 | assert(PyCell_Check(op)); 27 | cell = _Py_CAST(PyCellObject*, op); 28 | return cell->ob_ref; 29 | } 30 | #define PyCell_GET(op) PyCell_GET(_PyObject_CAST(op)) 31 | 32 | static inline void PyCell_SET(PyObject *op, PyObject *value) { 33 | PyCellObject *cell; 34 | assert(PyCell_Check(op)); 35 | cell = _Py_CAST(PyCellObject*, op); 36 | cell->ob_ref = value; 37 | } 38 | #define PyCell_SET(op, value) PyCell_SET(_PyObject_CAST(op), (value)) 39 | 40 | #ifdef __cplusplus 41 | } 42 | #endif 43 | #endif /* !Py_TUPLEOBJECT_H */ 44 | #endif /* Py_LIMITED_API */ 45 | -------------------------------------------------------------------------------- /AndroidApp/app/src/main/jni/python64/cpython/ceval.h: -------------------------------------------------------------------------------- 1 | #ifndef Py_CPYTHON_CEVAL_H 2 | # error "this header file must not be included directly" 3 | #endif 4 | 5 | PyAPI_FUNC(void) PyEval_SetProfile(Py_tracefunc, PyObject *); 6 | PyAPI_FUNC(void) PyEval_SetProfileAllThreads(Py_tracefunc, PyObject *); 7 | PyAPI_DATA(int) _PyEval_SetProfile(PyThreadState *tstate, Py_tracefunc func, PyObject *arg); 8 | PyAPI_FUNC(void) PyEval_SetTrace(Py_tracefunc, PyObject *); 9 | PyAPI_FUNC(void) PyEval_SetTraceAllThreads(Py_tracefunc, PyObject *); 10 | PyAPI_FUNC(int) _PyEval_SetTrace(PyThreadState *tstate, Py_tracefunc func, PyObject *arg); 11 | 12 | /* Helper to look up a builtin object */ 13 | PyAPI_FUNC(PyObject *) _PyEval_GetBuiltin(PyObject *); 14 | PyAPI_FUNC(PyObject *) _PyEval_GetBuiltinId(_Py_Identifier *); 15 | /* Look at the current frame's (if any) code's co_flags, and turn on 16 | the corresponding compiler flags in cf->cf_flags. Return 1 if any 17 | flag was set, else return 0. */ 18 | PyAPI_FUNC(int) PyEval_MergeCompilerFlags(PyCompilerFlags *cf); 19 | 20 | PyAPI_FUNC(PyObject *) _PyEval_EvalFrameDefault(PyThreadState *tstate, struct _PyInterpreterFrame *f, int exc); 21 | 22 | PyAPI_FUNC(void) _PyEval_SetSwitchInterval(unsigned long microseconds); 23 | PyAPI_FUNC(unsigned long) _PyEval_GetSwitchInterval(void); 24 | 25 | PyAPI_FUNC(int) _PyEval_MakePendingCalls(PyThreadState *); 26 | 27 | PyAPI_FUNC(Py_ssize_t) PyUnstable_Eval_RequestCodeExtraIndex(freefunc); 28 | // Old name -- remove when this API changes: 29 | _Py_DEPRECATED_EXTERNALLY(3.12) static inline Py_ssize_t 30 | _PyEval_RequestCodeExtraIndex(freefunc f) { 31 | return PyUnstable_Eval_RequestCodeExtraIndex(f); 32 | } 33 | 34 | PyAPI_FUNC(int) _PyEval_SliceIndex(PyObject *, Py_ssize_t *); 35 | PyAPI_FUNC(int) _PyEval_SliceIndexNotNone(PyObject *, Py_ssize_t *); 36 | -------------------------------------------------------------------------------- /AndroidApp/app/src/main/jni/python64/cpython/complexobject.h: -------------------------------------------------------------------------------- 1 | #ifndef Py_CPYTHON_COMPLEXOBJECT_H 2 | # error "this header file must not be included directly" 3 | #endif 4 | 5 | typedef struct { 6 | double real; 7 | double imag; 8 | } Py_complex; 9 | 10 | /* Operations on complex numbers from complexmodule.c */ 11 | 12 | PyAPI_FUNC(Py_complex) _Py_c_sum(Py_complex, Py_complex); 13 | PyAPI_FUNC(Py_complex) _Py_c_diff(Py_complex, Py_complex); 14 | PyAPI_FUNC(Py_complex) _Py_c_neg(Py_complex); 15 | PyAPI_FUNC(Py_complex) _Py_c_prod(Py_complex, Py_complex); 16 | PyAPI_FUNC(Py_complex) _Py_c_quot(Py_complex, Py_complex); 17 | PyAPI_FUNC(Py_complex) _Py_c_pow(Py_complex, Py_complex); 18 | PyAPI_FUNC(double) _Py_c_abs(Py_complex); 19 | 20 | /* Complex object interface */ 21 | 22 | /* 23 | PyComplexObject represents a complex number with double-precision 24 | real and imaginary parts. 25 | */ 26 | typedef struct { 27 | PyObject_HEAD 28 | Py_complex cval; 29 | } PyComplexObject; 30 | 31 | PyAPI_FUNC(PyObject *) PyComplex_FromCComplex(Py_complex); 32 | 33 | PyAPI_FUNC(Py_complex) PyComplex_AsCComplex(PyObject *op); 34 | 35 | #ifdef Py_BUILD_CORE 36 | /* Format the object based on the format_spec, as defined in PEP 3101 37 | (Advanced String Formatting). */ 38 | extern int _PyComplex_FormatAdvancedWriter( 39 | _PyUnicodeWriter *writer, 40 | PyObject *obj, 41 | PyObject *format_spec, 42 | Py_ssize_t start, 43 | Py_ssize_t end); 44 | #endif // Py_BUILD_CORE 45 | -------------------------------------------------------------------------------- /AndroidApp/app/src/main/jni/python64/cpython/fileobject.h: -------------------------------------------------------------------------------- 1 | #ifndef Py_CPYTHON_FILEOBJECT_H 2 | # error "this header file must not be included directly" 3 | #endif 4 | 5 | PyAPI_FUNC(char *) Py_UniversalNewlineFgets(char *, int, FILE*, PyObject *); 6 | PyAPI_FUNC(char *) _Py_UniversalNewlineFgetsWithSize(char *, int, FILE*, PyObject *, size_t*); 7 | 8 | /* The std printer acts as a preliminary sys.stderr until the new io 9 | infrastructure is in place. */ 10 | PyAPI_FUNC(PyObject *) PyFile_NewStdPrinter(int); 11 | PyAPI_DATA(PyTypeObject) PyStdPrinter_Type; 12 | 13 | typedef PyObject * (*Py_OpenCodeHookFunction)(PyObject *, void *); 14 | 15 | PyAPI_FUNC(PyObject *) PyFile_OpenCode(const char *utf8path); 16 | PyAPI_FUNC(PyObject *) PyFile_OpenCodeObject(PyObject *path); 17 | PyAPI_FUNC(int) PyFile_SetOpenCodeHook(Py_OpenCodeHookFunction hook, void *userData); 18 | 19 | PyAPI_FUNC(int) _PyLong_FileDescriptor_Converter(PyObject *, void *); 20 | -------------------------------------------------------------------------------- /AndroidApp/app/src/main/jni/python64/cpython/fileutils.h: -------------------------------------------------------------------------------- 1 | #ifndef Py_CPYTHON_FILEUTILS_H 2 | # error "this header file must not be included directly" 3 | #endif 4 | 5 | // Used by _testcapi which must not use the internal C API 6 | PyAPI_FUNC(FILE*) _Py_fopen_obj( 7 | PyObject *path, 8 | const char *mode); 9 | -------------------------------------------------------------------------------- /AndroidApp/app/src/main/jni/python64/cpython/floatobject.h: -------------------------------------------------------------------------------- 1 | #ifndef Py_CPYTHON_FLOATOBJECT_H 2 | # error "this header file must not be included directly" 3 | #endif 4 | 5 | typedef struct { 6 | PyObject_HEAD 7 | double ob_fval; 8 | } PyFloatObject; 9 | 10 | #define _PyFloat_CAST(op) \ 11 | (assert(PyFloat_Check(op)), _Py_CAST(PyFloatObject*, op)) 12 | 13 | // Static inline version of PyFloat_AsDouble() trading safety for speed. 14 | // It doesn't check if op is a double object. 15 | static inline double PyFloat_AS_DOUBLE(PyObject *op) { 16 | return _PyFloat_CAST(op)->ob_fval; 17 | } 18 | #define PyFloat_AS_DOUBLE(op) PyFloat_AS_DOUBLE(_PyObject_CAST(op)) 19 | 20 | 21 | PyAPI_FUNC(int) PyFloat_Pack2(double x, char *p, int le); 22 | PyAPI_FUNC(int) PyFloat_Pack4(double x, char *p, int le); 23 | PyAPI_FUNC(int) PyFloat_Pack8(double x, char *p, int le); 24 | 25 | PyAPI_FUNC(double) PyFloat_Unpack2(const char *p, int le); 26 | PyAPI_FUNC(double) PyFloat_Unpack4(const char *p, int le); 27 | PyAPI_FUNC(double) PyFloat_Unpack8(const char *p, int le); 28 | -------------------------------------------------------------------------------- /AndroidApp/app/src/main/jni/python64/cpython/frameobject.h: -------------------------------------------------------------------------------- 1 | /* Frame object interface */ 2 | 3 | #ifndef Py_CPYTHON_FRAMEOBJECT_H 4 | # error "this header file must not be included directly" 5 | #endif 6 | 7 | /* Standard object interface */ 8 | 9 | PyAPI_FUNC(PyFrameObject *) PyFrame_New(PyThreadState *, PyCodeObject *, 10 | PyObject *, PyObject *); 11 | 12 | /* The rest of the interface is specific for frame objects */ 13 | 14 | /* Conversions between "fast locals" and locals in dictionary */ 15 | 16 | PyAPI_FUNC(void) PyFrame_LocalsToFast(PyFrameObject *, int); 17 | 18 | /* -- Caveat emptor -- 19 | * The concept of entry frames is an implementation detail of the CPython 20 | * interpreter. This API is considered unstable and is provided for the 21 | * convenience of debuggers, profilers and state-inspecting tools. Notice that 22 | * this API can be changed in future minor versions if the underlying frame 23 | * mechanism change or the concept of an 'entry frame' or its semantics becomes 24 | * obsolete or outdated. */ 25 | 26 | PyAPI_FUNC(int) _PyFrame_IsEntryFrame(PyFrameObject *frame); 27 | 28 | PyAPI_FUNC(int) PyFrame_FastToLocalsWithError(PyFrameObject *f); 29 | PyAPI_FUNC(void) PyFrame_FastToLocals(PyFrameObject *); 30 | -------------------------------------------------------------------------------- /AndroidApp/app/src/main/jni/python64/cpython/import.h: -------------------------------------------------------------------------------- 1 | #ifndef Py_CPYTHON_IMPORT_H 2 | # error "this header file must not be included directly" 3 | #endif 4 | 5 | PyMODINIT_FUNC PyInit__imp(void); 6 | 7 | PyAPI_FUNC(int) _PyImport_IsInitialized(PyInterpreterState *); 8 | 9 | PyAPI_FUNC(PyObject *) _PyImport_GetModuleId(_Py_Identifier *name); 10 | PyAPI_FUNC(int) _PyImport_SetModule(PyObject *name, PyObject *module); 11 | PyAPI_FUNC(int) _PyImport_SetModuleString(const char *name, PyObject* module); 12 | 13 | PyAPI_FUNC(void) _PyImport_AcquireLock(PyInterpreterState *interp); 14 | PyAPI_FUNC(int) _PyImport_ReleaseLock(PyInterpreterState *interp); 15 | 16 | PyAPI_FUNC(int) _PyImport_FixupBuiltin( 17 | PyObject *mod, 18 | const char *name, /* UTF-8 encoded string */ 19 | PyObject *modules 20 | ); 21 | PyAPI_FUNC(int) _PyImport_FixupExtensionObject(PyObject*, PyObject *, 22 | PyObject *, PyObject *); 23 | 24 | struct _inittab { 25 | const char *name; /* ASCII encoded string */ 26 | PyObject* (*initfunc)(void); 27 | }; 28 | // This is not used after Py_Initialize() is called. 29 | PyAPI_DATA(struct _inittab *) PyImport_Inittab; 30 | PyAPI_FUNC(int) PyImport_ExtendInittab(struct _inittab *newtab); 31 | 32 | struct _frozen { 33 | const char *name; /* ASCII encoded string */ 34 | const unsigned char *code; 35 | int size; 36 | int is_package; 37 | PyObject *(*get_code)(void); 38 | }; 39 | 40 | /* Embedding apps may change this pointer to point to their favorite 41 | collection of frozen modules: */ 42 | 43 | PyAPI_DATA(const struct _frozen *) PyImport_FrozenModules; 44 | 45 | PyAPI_DATA(PyObject *) _PyImport_GetModuleAttr(PyObject *, PyObject *); 46 | PyAPI_DATA(PyObject *) _PyImport_GetModuleAttrString(const char *, const char *); 47 | -------------------------------------------------------------------------------- /AndroidApp/app/src/main/jni/python64/cpython/interpreteridobject.h: -------------------------------------------------------------------------------- 1 | #ifndef Py_CPYTHON_INTERPRETERIDOBJECT_H 2 | # error "this header file must not be included directly" 3 | #endif 4 | 5 | /* Interpreter ID Object */ 6 | 7 | PyAPI_DATA(PyTypeObject) _PyInterpreterID_Type; 8 | 9 | PyAPI_FUNC(PyObject *) _PyInterpreterID_New(int64_t); 10 | PyAPI_FUNC(PyObject *) _PyInterpreterState_GetIDObject(PyInterpreterState *); 11 | PyAPI_FUNC(PyInterpreterState *) _PyInterpreterID_LookUp(PyObject *); 12 | -------------------------------------------------------------------------------- /AndroidApp/app/src/main/jni/python64/cpython/odictobject.h: -------------------------------------------------------------------------------- 1 | #ifndef Py_ODICTOBJECT_H 2 | #define Py_ODICTOBJECT_H 3 | #ifdef __cplusplus 4 | extern "C" { 5 | #endif 6 | 7 | 8 | /* OrderedDict */ 9 | /* This API is optional and mostly redundant. */ 10 | 11 | #ifndef Py_LIMITED_API 12 | 13 | typedef struct _odictobject PyODictObject; 14 | 15 | PyAPI_DATA(PyTypeObject) PyODict_Type; 16 | PyAPI_DATA(PyTypeObject) PyODictIter_Type; 17 | PyAPI_DATA(PyTypeObject) PyODictKeys_Type; 18 | PyAPI_DATA(PyTypeObject) PyODictItems_Type; 19 | PyAPI_DATA(PyTypeObject) PyODictValues_Type; 20 | 21 | #define PyODict_Check(op) PyObject_TypeCheck((op), &PyODict_Type) 22 | #define PyODict_CheckExact(op) Py_IS_TYPE((op), &PyODict_Type) 23 | #define PyODict_SIZE(op) PyDict_GET_SIZE((op)) 24 | 25 | PyAPI_FUNC(PyObject *) PyODict_New(void); 26 | PyAPI_FUNC(int) PyODict_SetItem(PyObject *od, PyObject *key, PyObject *item); 27 | PyAPI_FUNC(int) PyODict_DelItem(PyObject *od, PyObject *key); 28 | 29 | /* wrappers around PyDict* functions */ 30 | #define PyODict_GetItem(od, key) PyDict_GetItem(_PyObject_CAST(od), (key)) 31 | #define PyODict_GetItemWithError(od, key) \ 32 | PyDict_GetItemWithError(_PyObject_CAST(od), (key)) 33 | #define PyODict_Contains(od, key) PyDict_Contains(_PyObject_CAST(od), (key)) 34 | #define PyODict_Size(od) PyDict_Size(_PyObject_CAST(od)) 35 | #define PyODict_GetItemString(od, key) \ 36 | PyDict_GetItemString(_PyObject_CAST(od), (key)) 37 | 38 | #endif 39 | 40 | #ifdef __cplusplus 41 | } 42 | #endif 43 | #endif /* !Py_ODICTOBJECT_H */ 44 | -------------------------------------------------------------------------------- /AndroidApp/app/src/main/jni/python64/cpython/picklebufobject.h: -------------------------------------------------------------------------------- 1 | /* PickleBuffer object. This is built-in for ease of use from third-party 2 | * C extensions. 3 | */ 4 | 5 | #ifndef Py_PICKLEBUFOBJECT_H 6 | #define Py_PICKLEBUFOBJECT_H 7 | #ifdef __cplusplus 8 | extern "C" { 9 | #endif 10 | 11 | #ifndef Py_LIMITED_API 12 | 13 | PyAPI_DATA(PyTypeObject) PyPickleBuffer_Type; 14 | 15 | #define PyPickleBuffer_Check(op) Py_IS_TYPE((op), &PyPickleBuffer_Type) 16 | 17 | /* Create a PickleBuffer redirecting to the given buffer-enabled object */ 18 | PyAPI_FUNC(PyObject *) PyPickleBuffer_FromObject(PyObject *); 19 | /* Get the PickleBuffer's underlying view to the original object 20 | * (NULL if released) 21 | */ 22 | PyAPI_FUNC(const Py_buffer *) PyPickleBuffer_GetBuffer(PyObject *); 23 | /* Release the PickleBuffer. Returns 0 on success, -1 on error. */ 24 | PyAPI_FUNC(int) PyPickleBuffer_Release(PyObject *); 25 | 26 | #endif /* !Py_LIMITED_API */ 27 | 28 | #ifdef __cplusplus 29 | } 30 | #endif 31 | #endif /* !Py_PICKLEBUFOBJECT_H */ 32 | -------------------------------------------------------------------------------- /AndroidApp/app/src/main/jni/python64/cpython/pyctype.h: -------------------------------------------------------------------------------- 1 | #ifndef Py_LIMITED_API 2 | #ifndef PYCTYPE_H 3 | #define PYCTYPE_H 4 | #ifdef __cplusplus 5 | extern "C" { 6 | #endif 7 | 8 | #define PY_CTF_LOWER 0x01 9 | #define PY_CTF_UPPER 0x02 10 | #define PY_CTF_ALPHA (PY_CTF_LOWER|PY_CTF_UPPER) 11 | #define PY_CTF_DIGIT 0x04 12 | #define PY_CTF_ALNUM (PY_CTF_ALPHA|PY_CTF_DIGIT) 13 | #define PY_CTF_SPACE 0x08 14 | #define PY_CTF_XDIGIT 0x10 15 | 16 | PyAPI_DATA(const unsigned int) _Py_ctype_table[256]; 17 | 18 | /* Unlike their C counterparts, the following macros are not meant to 19 | * handle an int with any of the values [EOF, 0-UCHAR_MAX]. The argument 20 | * must be a signed/unsigned char. */ 21 | #define Py_ISLOWER(c) (_Py_ctype_table[Py_CHARMASK(c)] & PY_CTF_LOWER) 22 | #define Py_ISUPPER(c) (_Py_ctype_table[Py_CHARMASK(c)] & PY_CTF_UPPER) 23 | #define Py_ISALPHA(c) (_Py_ctype_table[Py_CHARMASK(c)] & PY_CTF_ALPHA) 24 | #define Py_ISDIGIT(c) (_Py_ctype_table[Py_CHARMASK(c)] & PY_CTF_DIGIT) 25 | #define Py_ISXDIGIT(c) (_Py_ctype_table[Py_CHARMASK(c)] & PY_CTF_XDIGIT) 26 | #define Py_ISALNUM(c) (_Py_ctype_table[Py_CHARMASK(c)] & PY_CTF_ALNUM) 27 | #define Py_ISSPACE(c) (_Py_ctype_table[Py_CHARMASK(c)] & PY_CTF_SPACE) 28 | 29 | PyAPI_DATA(const unsigned char) _Py_ctype_tolower[256]; 30 | PyAPI_DATA(const unsigned char) _Py_ctype_toupper[256]; 31 | 32 | #define Py_TOLOWER(c) (_Py_ctype_tolower[Py_CHARMASK(c)]) 33 | #define Py_TOUPPER(c) (_Py_ctype_toupper[Py_CHARMASK(c)]) 34 | 35 | #ifdef __cplusplus 36 | } 37 | #endif 38 | #endif /* !PYCTYPE_H */ 39 | #endif /* !Py_LIMITED_API */ 40 | -------------------------------------------------------------------------------- /AndroidApp/app/src/main/jni/python64/cpython/pydebug.h: -------------------------------------------------------------------------------- 1 | #ifndef Py_LIMITED_API 2 | #ifndef Py_PYDEBUG_H 3 | #define Py_PYDEBUG_H 4 | #ifdef __cplusplus 5 | extern "C" { 6 | #endif 7 | 8 | Py_DEPRECATED(3.12) PyAPI_DATA(int) Py_DebugFlag; 9 | Py_DEPRECATED(3.12) PyAPI_DATA(int) Py_VerboseFlag; 10 | Py_DEPRECATED(3.12) PyAPI_DATA(int) Py_QuietFlag; 11 | Py_DEPRECATED(3.12) PyAPI_DATA(int) Py_InteractiveFlag; 12 | Py_DEPRECATED(3.12) PyAPI_DATA(int) Py_InspectFlag; 13 | Py_DEPRECATED(3.12) PyAPI_DATA(int) Py_OptimizeFlag; 14 | Py_DEPRECATED(3.12) PyAPI_DATA(int) Py_NoSiteFlag; 15 | Py_DEPRECATED(3.12) PyAPI_DATA(int) Py_BytesWarningFlag; 16 | Py_DEPRECATED(3.12) PyAPI_DATA(int) Py_FrozenFlag; 17 | Py_DEPRECATED(3.12) PyAPI_DATA(int) Py_IgnoreEnvironmentFlag; 18 | Py_DEPRECATED(3.12) PyAPI_DATA(int) Py_DontWriteBytecodeFlag; 19 | Py_DEPRECATED(3.12) PyAPI_DATA(int) Py_NoUserSiteDirectory; 20 | Py_DEPRECATED(3.12) PyAPI_DATA(int) Py_UnbufferedStdioFlag; 21 | Py_DEPRECATED(3.12) PyAPI_DATA(int) Py_HashRandomizationFlag; 22 | Py_DEPRECATED(3.12) PyAPI_DATA(int) Py_IsolatedFlag; 23 | 24 | #ifdef MS_WINDOWS 25 | Py_DEPRECATED(3.12) PyAPI_DATA(int) Py_LegacyWindowsFSEncodingFlag; 26 | Py_DEPRECATED(3.12) PyAPI_DATA(int) Py_LegacyWindowsStdioFlag; 27 | #endif 28 | 29 | /* this is a wrapper around getenv() that pays attention to 30 | Py_IgnoreEnvironmentFlag. It should be used for getting variables like 31 | PYTHONPATH and PYTHONHOME from the environment */ 32 | PyAPI_FUNC(char*) Py_GETENV(const char *name); 33 | 34 | #ifdef __cplusplus 35 | } 36 | #endif 37 | #endif /* !Py_PYDEBUG_H */ 38 | #endif /* Py_LIMITED_API */ 39 | -------------------------------------------------------------------------------- /AndroidApp/app/src/main/jni/python64/cpython/pyfpe.h: -------------------------------------------------------------------------------- 1 | #ifndef Py_PYFPE_H 2 | #define Py_PYFPE_H 3 | /* Header excluded from the stable API */ 4 | #ifndef Py_LIMITED_API 5 | 6 | /* These macros used to do something when Python was built with --with-fpectl, 7 | * but support for that was dropped in 3.7. We continue to define them though, 8 | * to avoid breaking API users. 9 | */ 10 | 11 | #define PyFPE_START_PROTECT(err_string, leave_stmt) 12 | #define PyFPE_END_PROTECT(v) 13 | 14 | #endif /* !defined(Py_LIMITED_API) */ 15 | #endif /* !Py_PYFPE_H */ 16 | -------------------------------------------------------------------------------- /AndroidApp/app/src/main/jni/python64/cpython/pyframe.h: -------------------------------------------------------------------------------- 1 | #ifndef Py_CPYTHON_PYFRAME_H 2 | # error "this header file must not be included directly" 3 | #endif 4 | 5 | PyAPI_DATA(PyTypeObject) PyFrame_Type; 6 | 7 | #define PyFrame_Check(op) Py_IS_TYPE((op), &PyFrame_Type) 8 | 9 | PyAPI_FUNC(PyFrameObject *) PyFrame_GetBack(PyFrameObject *frame); 10 | PyAPI_FUNC(PyObject *) PyFrame_GetLocals(PyFrameObject *frame); 11 | 12 | PyAPI_FUNC(PyObject *) PyFrame_GetGlobals(PyFrameObject *frame); 13 | PyAPI_FUNC(PyObject *) PyFrame_GetBuiltins(PyFrameObject *frame); 14 | 15 | PyAPI_FUNC(PyObject *) PyFrame_GetGenerator(PyFrameObject *frame); 16 | PyAPI_FUNC(int) PyFrame_GetLasti(PyFrameObject *frame); 17 | PyAPI_FUNC(PyObject*) PyFrame_GetVar(PyFrameObject *frame, PyObject *name); 18 | PyAPI_FUNC(PyObject*) PyFrame_GetVarString(PyFrameObject *frame, const char *name); 19 | 20 | /* The following functions are for use by debuggers and other tools 21 | * implementing custom frame evaluators with PEP 523. */ 22 | 23 | struct _PyInterpreterFrame; 24 | 25 | /* Returns the code object of the frame (strong reference). 26 | * Does not raise an exception. */ 27 | PyAPI_FUNC(PyObject *) PyUnstable_InterpreterFrame_GetCode(struct _PyInterpreterFrame *frame); 28 | 29 | /* Returns a byte ofsset into the last executed instruction. 30 | * Does not raise an exception. */ 31 | PyAPI_FUNC(int) PyUnstable_InterpreterFrame_GetLasti(struct _PyInterpreterFrame *frame); 32 | 33 | /* Returns the currently executing line number, or -1 if there is no line number. 34 | * Does not raise an exception. */ 35 | PyAPI_FUNC(int) PyUnstable_InterpreterFrame_GetLine(struct _PyInterpreterFrame *frame); 36 | -------------------------------------------------------------------------------- /AndroidApp/app/src/main/jni/python64/cpython/pythread.h: -------------------------------------------------------------------------------- 1 | #ifndef Py_CPYTHON_PYTHREAD_H 2 | # error "this header file must not be included directly" 3 | #endif 4 | 5 | #define PYTHREAD_INVALID_THREAD_ID ((unsigned long)-1) 6 | 7 | #ifdef HAVE_FORK 8 | /* Private function to reinitialize a lock at fork in the child process. 9 | Reset the lock to the unlocked state. 10 | Return 0 on success, return -1 on error. */ 11 | PyAPI_FUNC(int) _PyThread_at_fork_reinit(PyThread_type_lock *lock); 12 | #endif /* HAVE_FORK */ 13 | 14 | #ifdef HAVE_PTHREAD_H 15 | /* Darwin needs pthread.h to know type name the pthread_key_t. */ 16 | # include 17 | # define NATIVE_TSS_KEY_T pthread_key_t 18 | #elif defined(NT_THREADS) 19 | /* In Windows, native TSS key type is DWORD, 20 | but hardcode the unsigned long to avoid errors for include directive. 21 | */ 22 | # define NATIVE_TSS_KEY_T unsigned long 23 | #elif defined(HAVE_PTHREAD_STUBS) 24 | # include "cpython/pthread_stubs.h" 25 | # define NATIVE_TSS_KEY_T pthread_key_t 26 | #else 27 | # error "Require native threads. See https://bugs.python.org/issue31370" 28 | #endif 29 | 30 | /* When Py_LIMITED_API is not defined, the type layout of Py_tss_t is 31 | exposed to allow static allocation in the API clients. Even in this case, 32 | you must handle TSS keys through API functions due to compatibility. 33 | */ 34 | struct _Py_tss_t { 35 | int _is_initialized; 36 | NATIVE_TSS_KEY_T _key; 37 | }; 38 | 39 | #undef NATIVE_TSS_KEY_T 40 | 41 | /* When static allocation, you must initialize with Py_tss_NEEDS_INIT. */ 42 | #define Py_tss_NEEDS_INIT {0} 43 | -------------------------------------------------------------------------------- /AndroidApp/app/src/main/jni/python64/cpython/sysmodule.h: -------------------------------------------------------------------------------- 1 | #ifndef Py_CPYTHON_SYSMODULE_H 2 | # error "this header file must not be included directly" 3 | #endif 4 | 5 | PyAPI_FUNC(PyObject *) _PySys_GetAttr(PyThreadState *tstate, 6 | PyObject *name); 7 | 8 | PyAPI_FUNC(size_t) _PySys_GetSizeOf(PyObject *); 9 | 10 | typedef int(*Py_AuditHookFunction)(const char *, PyObject *, void *); 11 | 12 | PyAPI_FUNC(int) PySys_Audit( 13 | const char *event, 14 | const char *argFormat, 15 | ...); 16 | PyAPI_FUNC(int) PySys_AddAuditHook(Py_AuditHookFunction, void*); 17 | -------------------------------------------------------------------------------- /AndroidApp/app/src/main/jni/python64/cpython/traceback.h: -------------------------------------------------------------------------------- 1 | #ifndef Py_CPYTHON_TRACEBACK_H 2 | # error "this header file must not be included directly" 3 | #endif 4 | 5 | typedef struct _traceback PyTracebackObject; 6 | 7 | struct _traceback { 8 | PyObject_HEAD 9 | PyTracebackObject *tb_next; 10 | PyFrameObject *tb_frame; 11 | int tb_lasti; 12 | int tb_lineno; 13 | }; 14 | 15 | PyAPI_FUNC(int) _Py_DisplaySourceLine(PyObject *, PyObject *, int, int, int *, PyObject **); 16 | PyAPI_FUNC(void) _PyTraceback_Add(const char *, const char *, int); 17 | -------------------------------------------------------------------------------- /AndroidApp/app/src/main/jni/python64/cpython/tupleobject.h: -------------------------------------------------------------------------------- 1 | #ifndef Py_CPYTHON_TUPLEOBJECT_H 2 | # error "this header file must not be included directly" 3 | #endif 4 | 5 | typedef struct { 6 | PyObject_VAR_HEAD 7 | /* ob_item contains space for 'ob_size' elements. 8 | Items must normally not be NULL, except during construction when 9 | the tuple is not yet visible outside the function that builds it. */ 10 | PyObject *ob_item[1]; 11 | } PyTupleObject; 12 | 13 | PyAPI_FUNC(int) _PyTuple_Resize(PyObject **, Py_ssize_t); 14 | PyAPI_FUNC(void) _PyTuple_MaybeUntrack(PyObject *); 15 | 16 | /* Cast argument to PyTupleObject* type. */ 17 | #define _PyTuple_CAST(op) \ 18 | (assert(PyTuple_Check(op)), _Py_CAST(PyTupleObject*, (op))) 19 | 20 | // Macros and static inline functions, trading safety for speed 21 | 22 | static inline Py_ssize_t PyTuple_GET_SIZE(PyObject *op) { 23 | PyTupleObject *tuple = _PyTuple_CAST(op); 24 | return Py_SIZE(tuple); 25 | } 26 | #define PyTuple_GET_SIZE(op) PyTuple_GET_SIZE(_PyObject_CAST(op)) 27 | 28 | #define PyTuple_GET_ITEM(op, index) (_PyTuple_CAST(op)->ob_item[(index)]) 29 | 30 | /* Function *only* to be used to fill in brand new tuples */ 31 | static inline void 32 | PyTuple_SET_ITEM(PyObject *op, Py_ssize_t index, PyObject *value) { 33 | PyTupleObject *tuple = _PyTuple_CAST(op); 34 | tuple->ob_item[index] = value; 35 | } 36 | #define PyTuple_SET_ITEM(op, index, value) \ 37 | PyTuple_SET_ITEM(_PyObject_CAST(op), (index), _PyObject_CAST(value)) 38 | 39 | PyAPI_FUNC(void) _PyTuple_DebugMallocStats(FILE *out); 40 | -------------------------------------------------------------------------------- /AndroidApp/app/src/main/jni/python64/cpython/warnings.h: -------------------------------------------------------------------------------- 1 | #ifndef Py_CPYTHON_WARNINGS_H 2 | # error "this header file must not be included directly" 3 | #endif 4 | 5 | PyAPI_FUNC(int) PyErr_WarnExplicitObject( 6 | PyObject *category, 7 | PyObject *message, 8 | PyObject *filename, 9 | int lineno, 10 | PyObject *module, 11 | PyObject *registry); 12 | 13 | PyAPI_FUNC(int) PyErr_WarnExplicitFormat( 14 | PyObject *category, 15 | const char *filename, int lineno, 16 | const char *module, PyObject *registry, 17 | const char *format, ...); 18 | 19 | // DEPRECATED: Use PyErr_WarnEx() instead. 20 | #define PyErr_Warn(category, msg) PyErr_WarnEx((category), (msg), 1) 21 | -------------------------------------------------------------------------------- /AndroidApp/app/src/main/jni/python64/enumobject.h: -------------------------------------------------------------------------------- 1 | #ifndef Py_ENUMOBJECT_H 2 | #define Py_ENUMOBJECT_H 3 | 4 | /* Enumerate Object */ 5 | 6 | #ifdef __cplusplus 7 | extern "C" { 8 | #endif 9 | 10 | PyAPI_DATA(PyTypeObject) PyEnum_Type; 11 | PyAPI_DATA(PyTypeObject) PyReversed_Type; 12 | 13 | #ifdef __cplusplus 14 | } 15 | #endif 16 | 17 | #endif /* !Py_ENUMOBJECT_H */ 18 | -------------------------------------------------------------------------------- /AndroidApp/app/src/main/jni/python64/exports.h: -------------------------------------------------------------------------------- 1 | #ifndef Py_EXPORTS_H 2 | #define Py_EXPORTS_H 3 | 4 | #if defined(_WIN32) || defined(__CYGWIN__) 5 | #if defined(Py_ENABLE_SHARED) 6 | #define Py_IMPORTED_SYMBOL __declspec(dllimport) 7 | #define Py_EXPORTED_SYMBOL __declspec(dllexport) 8 | #define Py_LOCAL_SYMBOL 9 | #else 10 | #define Py_IMPORTED_SYMBOL 11 | #define Py_EXPORTED_SYMBOL 12 | #define Py_LOCAL_SYMBOL 13 | #endif 14 | #else 15 | /* 16 | * If we only ever used gcc >= 5, we could use __has_attribute(visibility) 17 | * as a cross-platform way to determine if visibility is supported. However, 18 | * we may still need to support gcc >= 4, as some Ubuntu LTS and Centos versions 19 | * have 4 < gcc < 5. 20 | */ 21 | #ifndef __has_attribute 22 | #define __has_attribute(x) 0 // Compatibility with non-clang compilers. 23 | #endif 24 | #if (defined(__GNUC__) && (__GNUC__ >= 4)) ||\ 25 | (defined(__clang__) && __has_attribute(visibility)) 26 | #define Py_IMPORTED_SYMBOL __attribute__ ((visibility ("default"))) 27 | #define Py_EXPORTED_SYMBOL __attribute__ ((visibility ("default"))) 28 | #define Py_LOCAL_SYMBOL __attribute__ ((visibility ("hidden"))) 29 | #else 30 | #define Py_IMPORTED_SYMBOL 31 | #define Py_EXPORTED_SYMBOL 32 | #define Py_LOCAL_SYMBOL 33 | #endif 34 | #endif 35 | 36 | #endif /* Py_EXPORTS_H */ 37 | -------------------------------------------------------------------------------- /AndroidApp/app/src/main/jni/python64/fileutils.h: -------------------------------------------------------------------------------- 1 | #ifndef Py_FILEUTILS_H 2 | #define Py_FILEUTILS_H 3 | #ifdef __cplusplus 4 | extern "C" { 5 | #endif 6 | 7 | #if !defined(Py_LIMITED_API) || Py_LIMITED_API+0 >= 0x03050000 8 | PyAPI_FUNC(wchar_t *) Py_DecodeLocale( 9 | const char *arg, 10 | size_t *size); 11 | 12 | PyAPI_FUNC(char*) Py_EncodeLocale( 13 | const wchar_t *text, 14 | size_t *error_pos); 15 | #endif 16 | 17 | #ifndef Py_LIMITED_API 18 | # define Py_CPYTHON_FILEUTILS_H 19 | # include "cpython/fileutils.h" 20 | # undef Py_CPYTHON_FILEUTILS_H 21 | #endif 22 | 23 | #ifdef __cplusplus 24 | } 25 | #endif 26 | #endif /* !Py_FILEUTILS_H */ 27 | -------------------------------------------------------------------------------- /AndroidApp/app/src/main/jni/python64/floatobject.h: -------------------------------------------------------------------------------- 1 | 2 | /* Float object interface */ 3 | 4 | /* 5 | PyFloatObject represents a (double precision) floating point number. 6 | */ 7 | 8 | #ifndef Py_FLOATOBJECT_H 9 | #define Py_FLOATOBJECT_H 10 | #ifdef __cplusplus 11 | extern "C" { 12 | #endif 13 | 14 | PyAPI_DATA(PyTypeObject) PyFloat_Type; 15 | 16 | #define PyFloat_Check(op) PyObject_TypeCheck(op, &PyFloat_Type) 17 | #define PyFloat_CheckExact(op) Py_IS_TYPE((op), &PyFloat_Type) 18 | 19 | #define Py_RETURN_NAN return PyFloat_FromDouble(Py_NAN) 20 | 21 | #define Py_RETURN_INF(sign) \ 22 | do { \ 23 | if (copysign(1., sign) == 1.) { \ 24 | return PyFloat_FromDouble(Py_HUGE_VAL); \ 25 | } \ 26 | else { \ 27 | return PyFloat_FromDouble(-Py_HUGE_VAL); \ 28 | } \ 29 | } while(0) 30 | 31 | PyAPI_FUNC(double) PyFloat_GetMax(void); 32 | PyAPI_FUNC(double) PyFloat_GetMin(void); 33 | PyAPI_FUNC(PyObject*) PyFloat_GetInfo(void); 34 | 35 | /* Return Python float from string PyObject. */ 36 | PyAPI_FUNC(PyObject*) PyFloat_FromString(PyObject*); 37 | 38 | /* Return Python float from C double. */ 39 | PyAPI_FUNC(PyObject*) PyFloat_FromDouble(double); 40 | 41 | /* Extract C double from Python float. The macro version trades safety for 42 | speed. */ 43 | PyAPI_FUNC(double) PyFloat_AsDouble(PyObject*); 44 | 45 | #ifndef Py_LIMITED_API 46 | # define Py_CPYTHON_FLOATOBJECT_H 47 | # include "cpython/floatobject.h" 48 | # undef Py_CPYTHON_FLOATOBJECT_H 49 | #endif 50 | 51 | #ifdef __cplusplus 52 | } 53 | #endif 54 | #endif /* !Py_FLOATOBJECT_H */ 55 | -------------------------------------------------------------------------------- /AndroidApp/app/src/main/jni/python64/frameobject.h: -------------------------------------------------------------------------------- 1 | /* Frame object interface */ 2 | 3 | #ifndef Py_FRAMEOBJECT_H 4 | #define Py_FRAMEOBJECT_H 5 | #ifdef __cplusplus 6 | extern "C" { 7 | #endif 8 | 9 | #include "pyframe.h" 10 | 11 | #ifndef Py_LIMITED_API 12 | # define Py_CPYTHON_FRAMEOBJECT_H 13 | # include "cpython/frameobject.h" 14 | # undef Py_CPYTHON_FRAMEOBJECT_H 15 | #endif 16 | 17 | #ifdef __cplusplus 18 | } 19 | #endif 20 | #endif /* !Py_FRAMEOBJECT_H */ 21 | -------------------------------------------------------------------------------- /AndroidApp/app/src/main/jni/python64/genericaliasobject.h: -------------------------------------------------------------------------------- 1 | // Implementation of PEP 585: support list[int] etc. 2 | #ifndef Py_GENERICALIASOBJECT_H 3 | #define Py_GENERICALIASOBJECT_H 4 | #ifdef __cplusplus 5 | extern "C" { 6 | #endif 7 | 8 | PyAPI_FUNC(PyObject *) Py_GenericAlias(PyObject *, PyObject *); 9 | PyAPI_DATA(PyTypeObject) Py_GenericAliasType; 10 | 11 | #ifdef __cplusplus 12 | } 13 | #endif 14 | #endif /* !Py_GENERICALIASOBJECT_H */ 15 | -------------------------------------------------------------------------------- /AndroidApp/app/src/main/jni/python64/internal/pycore_abstract.h: -------------------------------------------------------------------------------- 1 | #ifndef Py_INTERNAL_ABSTRACT_H 2 | #define Py_INTERNAL_ABSTRACT_H 3 | #ifdef __cplusplus 4 | extern "C" { 5 | #endif 6 | 7 | #ifndef Py_BUILD_CORE 8 | # error "this header requires Py_BUILD_CORE define" 9 | #endif 10 | 11 | // Fast inlined version of PyIndex_Check() 12 | static inline int 13 | _PyIndex_Check(PyObject *obj) 14 | { 15 | PyNumberMethods *tp_as_number = Py_TYPE(obj)->tp_as_number; 16 | return (tp_as_number != NULL && tp_as_number->nb_index != NULL); 17 | } 18 | 19 | PyObject *_PyNumber_PowerNoMod(PyObject *lhs, PyObject *rhs); 20 | PyObject *_PyNumber_InPlacePowerNoMod(PyObject *lhs, PyObject *rhs); 21 | 22 | #ifdef __cplusplus 23 | } 24 | #endif 25 | #endif /* !Py_INTERNAL_ABSTRACT_H */ 26 | -------------------------------------------------------------------------------- /AndroidApp/app/src/main/jni/python64/internal/pycore_atexit.h: -------------------------------------------------------------------------------- 1 | #ifndef Py_INTERNAL_ATEXIT_H 2 | #define Py_INTERNAL_ATEXIT_H 3 | #ifdef __cplusplus 4 | extern "C" { 5 | #endif 6 | 7 | #ifndef Py_BUILD_CORE 8 | # error "this header requires Py_BUILD_CORE define" 9 | #endif 10 | 11 | 12 | //############### 13 | // runtime atexit 14 | 15 | typedef void (*atexit_callbackfunc)(void); 16 | 17 | struct _atexit_runtime_state { 18 | PyThread_type_lock mutex; 19 | #define NEXITFUNCS 32 20 | atexit_callbackfunc callbacks[NEXITFUNCS]; 21 | int ncallbacks; 22 | }; 23 | 24 | 25 | //################### 26 | // interpreter atexit 27 | 28 | struct atexit_callback; 29 | typedef struct atexit_callback { 30 | atexit_datacallbackfunc func; 31 | void *data; 32 | struct atexit_callback *next; 33 | } atexit_callback; 34 | 35 | typedef struct { 36 | PyObject *func; 37 | PyObject *args; 38 | PyObject *kwargs; 39 | } atexit_py_callback; 40 | 41 | struct atexit_state { 42 | atexit_callback *ll_callbacks; 43 | atexit_callback *last_ll_callback; 44 | 45 | // XXX The rest of the state could be moved to the atexit module state 46 | // and a low-level callback added for it during module exec. 47 | // For the moment we leave it here. 48 | atexit_py_callback **callbacks; 49 | int ncallbacks; 50 | int callback_len; 51 | }; 52 | 53 | 54 | #ifdef __cplusplus 55 | } 56 | #endif 57 | #endif /* !Py_INTERNAL_ATEXIT_H */ 58 | -------------------------------------------------------------------------------- /AndroidApp/app/src/main/jni/python64/internal/pycore_bytesobject.h: -------------------------------------------------------------------------------- 1 | #ifndef Py_INTERNAL_BYTESOBJECT_H 2 | #define Py_INTERNAL_BYTESOBJECT_H 3 | #ifdef __cplusplus 4 | extern "C" { 5 | #endif 6 | 7 | #ifndef Py_BUILD_CORE 8 | # error "this header requires Py_BUILD_CORE define" 9 | #endif 10 | 11 | 12 | /* Substring Search. 13 | 14 | Returns the index of the first occurrence of 15 | a substring ("needle") in a larger text ("haystack"). 16 | If the needle is not found, return -1. 17 | If the needle is found, add offset to the index. 18 | */ 19 | 20 | PyAPI_FUNC(Py_ssize_t) 21 | _PyBytes_Find(const char *haystack, Py_ssize_t len_haystack, 22 | const char *needle, Py_ssize_t len_needle, 23 | Py_ssize_t offset); 24 | 25 | /* Same as above, but search right-to-left */ 26 | PyAPI_FUNC(Py_ssize_t) 27 | _PyBytes_ReverseFind(const char *haystack, Py_ssize_t len_haystack, 28 | const char *needle, Py_ssize_t len_needle, 29 | Py_ssize_t offset); 30 | 31 | 32 | /** Helper function to implement the repeat and inplace repeat methods on a buffer 33 | * 34 | * len_dest is assumed to be an integer multiple of len_src. 35 | * If src equals dest, then assume the operation is inplace. 36 | * 37 | * This method repeately doubles the number of bytes copied to reduce 38 | * the number of invocations of memcpy. 39 | */ 40 | PyAPI_FUNC(void) 41 | _PyBytes_Repeat(char* dest, Py_ssize_t len_dest, 42 | const char* src, Py_ssize_t len_src); 43 | 44 | #ifdef __cplusplus 45 | } 46 | #endif 47 | #endif /* !Py_INTERNAL_BYTESOBJECT_H */ 48 | -------------------------------------------------------------------------------- /AndroidApp/app/src/main/jni/python64/internal/pycore_context.h: -------------------------------------------------------------------------------- 1 | #ifndef Py_INTERNAL_CONTEXT_H 2 | #define Py_INTERNAL_CONTEXT_H 3 | 4 | #ifndef Py_BUILD_CORE 5 | # error "this header requires Py_BUILD_CORE define" 6 | #endif 7 | 8 | #include "pycore_hamt.h" /* PyHamtObject */ 9 | 10 | 11 | extern PyTypeObject _PyContextTokenMissing_Type; 12 | 13 | /* runtime lifecycle */ 14 | 15 | PyStatus _PyContext_Init(PyInterpreterState *); 16 | void _PyContext_Fini(PyInterpreterState *); 17 | 18 | 19 | /* other API */ 20 | 21 | typedef struct { 22 | PyObject_HEAD 23 | } _PyContextTokenMissing; 24 | 25 | #ifndef WITH_FREELISTS 26 | // without freelists 27 | # define PyContext_MAXFREELIST 0 28 | #endif 29 | 30 | #ifndef PyContext_MAXFREELIST 31 | # define PyContext_MAXFREELIST 255 32 | #endif 33 | 34 | struct _Py_context_state { 35 | #if PyContext_MAXFREELIST > 0 36 | // List of free PyContext objects 37 | PyContext *freelist; 38 | int numfree; 39 | #endif 40 | }; 41 | 42 | struct _pycontextobject { 43 | PyObject_HEAD 44 | PyContext *ctx_prev; 45 | PyHamtObject *ctx_vars; 46 | PyObject *ctx_weakreflist; 47 | int ctx_entered; 48 | }; 49 | 50 | 51 | struct _pycontextvarobject { 52 | PyObject_HEAD 53 | PyObject *var_name; 54 | PyObject *var_default; 55 | PyObject *var_cached; 56 | uint64_t var_cached_tsid; 57 | uint64_t var_cached_tsver; 58 | Py_hash_t var_hash; 59 | }; 60 | 61 | 62 | struct _pycontexttokenobject { 63 | PyObject_HEAD 64 | PyContext *tok_ctx; 65 | PyContextVar *tok_var; 66 | PyObject *tok_oldval; 67 | int tok_used; 68 | }; 69 | 70 | 71 | #endif /* !Py_INTERNAL_CONTEXT_H */ 72 | -------------------------------------------------------------------------------- /AndroidApp/app/src/main/jni/python64/internal/pycore_descrobject.h: -------------------------------------------------------------------------------- 1 | #ifndef Py_INTERNAL_DESCROBJECT_H 2 | #define Py_INTERNAL_DESCROBJECT_H 3 | #ifdef __cplusplus 4 | extern "C" { 5 | #endif 6 | 7 | #ifndef Py_BUILD_CORE 8 | # error "this header requires Py_BUILD_CORE define" 9 | #endif 10 | 11 | typedef struct { 12 | PyObject_HEAD 13 | PyObject *prop_get; 14 | PyObject *prop_set; 15 | PyObject *prop_del; 16 | PyObject *prop_doc; 17 | PyObject *prop_name; 18 | int getter_doc; 19 | } propertyobject; 20 | 21 | typedef propertyobject _PyPropertyObject; 22 | 23 | #ifdef __cplusplus 24 | } 25 | #endif 26 | #endif /* !Py_INTERNAL_DESCROBJECT_H */ 27 | -------------------------------------------------------------------------------- /AndroidApp/app/src/main/jni/python64/internal/pycore_dict_state.h: -------------------------------------------------------------------------------- 1 | #ifndef Py_INTERNAL_DICT_STATE_H 2 | #define Py_INTERNAL_DICT_STATE_H 3 | #ifdef __cplusplus 4 | extern "C" { 5 | #endif 6 | 7 | #ifndef Py_BUILD_CORE 8 | # error "this header requires Py_BUILD_CORE define" 9 | #endif 10 | 11 | 12 | #ifndef WITH_FREELISTS 13 | // without freelists 14 | # define PyDict_MAXFREELIST 0 15 | #endif 16 | 17 | #ifndef PyDict_MAXFREELIST 18 | # define PyDict_MAXFREELIST 80 19 | #endif 20 | 21 | #define DICT_MAX_WATCHERS 8 22 | 23 | struct _Py_dict_state { 24 | /*Global counter used to set ma_version_tag field of dictionary. 25 | * It is incremented each time that a dictionary is created and each 26 | * time that a dictionary is modified. */ 27 | uint64_t global_version; 28 | uint32_t next_keys_version; 29 | 30 | #if PyDict_MAXFREELIST > 0 31 | /* Dictionary reuse scheme to save calls to malloc and free */ 32 | PyDictObject *free_list[PyDict_MAXFREELIST]; 33 | PyDictKeysObject *keys_free_list[PyDict_MAXFREELIST]; 34 | int numfree; 35 | int keys_numfree; 36 | #endif 37 | 38 | PyDict_WatchCallback watchers[DICT_MAX_WATCHERS]; 39 | }; 40 | 41 | #define _dict_state_INIT \ 42 | { \ 43 | .next_keys_version = 2, \ 44 | } 45 | 46 | 47 | #ifdef __cplusplus 48 | } 49 | #endif 50 | #endif /* !Py_INTERNAL_DICT_STATE_H */ 51 | -------------------------------------------------------------------------------- /AndroidApp/app/src/main/jni/python64/internal/pycore_emscripten_signal.h: -------------------------------------------------------------------------------- 1 | #ifndef Py_EMSCRIPTEN_SIGNAL_H 2 | #define Py_EMSCRIPTEN_SIGNAL_H 3 | 4 | #if defined(__EMSCRIPTEN__) 5 | 6 | void 7 | _Py_CheckEmscriptenSignals(void); 8 | 9 | void 10 | _Py_CheckEmscriptenSignalsPeriodically(void); 11 | 12 | #define _Py_CHECK_EMSCRIPTEN_SIGNALS() _Py_CheckEmscriptenSignals() 13 | 14 | #define _Py_CHECK_EMSCRIPTEN_SIGNALS_PERIODICALLY() _Py_CheckEmscriptenSignalsPeriodically() 15 | 16 | extern int Py_EMSCRIPTEN_SIGNAL_HANDLING; 17 | 18 | #else 19 | 20 | #define _Py_CHECK_EMSCRIPTEN_SIGNALS() 21 | #define _Py_CHECK_EMSCRIPTEN_SIGNALS_PERIODICALLY() 22 | 23 | #endif // defined(__EMSCRIPTEN__) 24 | 25 | #endif // ndef Py_EMSCRIPTEN_SIGNAL_H 26 | -------------------------------------------------------------------------------- /AndroidApp/app/src/main/jni/python64/internal/pycore_exceptions.h: -------------------------------------------------------------------------------- 1 | #ifndef Py_INTERNAL_EXCEPTIONS_H 2 | #define Py_INTERNAL_EXCEPTIONS_H 3 | #ifdef __cplusplus 4 | extern "C" { 5 | #endif 6 | 7 | #ifndef Py_BUILD_CORE 8 | # error "this header requires Py_BUILD_CORE define" 9 | #endif 10 | 11 | 12 | /* runtime lifecycle */ 13 | 14 | extern PyStatus _PyExc_InitState(PyInterpreterState *); 15 | extern PyStatus _PyExc_InitGlobalObjects(PyInterpreterState *); 16 | extern int _PyExc_InitTypes(PyInterpreterState *); 17 | extern void _PyExc_Fini(PyInterpreterState *); 18 | 19 | 20 | /* other API */ 21 | 22 | struct _Py_exc_state { 23 | // The dict mapping from errno codes to OSError subclasses 24 | PyObject *errnomap; 25 | PyBaseExceptionObject *memerrors_freelist; 26 | int memerrors_numfree; 27 | // The ExceptionGroup type 28 | PyObject *PyExc_ExceptionGroup; 29 | }; 30 | 31 | extern void _PyExc_ClearExceptionGroupType(PyInterpreterState *); 32 | 33 | 34 | #ifdef __cplusplus 35 | } 36 | #endif 37 | #endif /* !Py_INTERNAL_EXCEPTIONS_H */ 38 | -------------------------------------------------------------------------------- /AndroidApp/app/src/main/jni/python64/internal/pycore_format.h: -------------------------------------------------------------------------------- 1 | #ifndef Py_INTERNAL_FORMAT_H 2 | #define Py_INTERNAL_FORMAT_H 3 | #ifdef __cplusplus 4 | extern "C" { 5 | #endif 6 | 7 | #ifndef Py_BUILD_CORE 8 | # error "this header requires Py_BUILD_CORE define" 9 | #endif 10 | 11 | /* Format codes 12 | * F_LJUST '-' 13 | * F_SIGN '+' 14 | * F_BLANK ' ' 15 | * F_ALT '#' 16 | * F_ZERO '0' 17 | */ 18 | #define F_LJUST (1<<0) 19 | #define F_SIGN (1<<1) 20 | #define F_BLANK (1<<2) 21 | #define F_ALT (1<<3) 22 | #define F_ZERO (1<<4) 23 | 24 | #ifdef __cplusplus 25 | } 26 | #endif 27 | #endif /* !Py_INTERNAL_FORMAT_H */ 28 | -------------------------------------------------------------------------------- /AndroidApp/app/src/main/jni/python64/internal/pycore_function.h: -------------------------------------------------------------------------------- 1 | #ifndef Py_INTERNAL_FUNCTION_H 2 | #define Py_INTERNAL_FUNCTION_H 3 | #ifdef __cplusplus 4 | extern "C" { 5 | #endif 6 | 7 | #ifndef Py_BUILD_CORE 8 | # error "this header requires Py_BUILD_CORE define" 9 | #endif 10 | 11 | #define FUNC_MAX_WATCHERS 8 12 | 13 | struct _py_func_state { 14 | uint32_t next_version; 15 | }; 16 | 17 | extern PyFunctionObject* _PyFunction_FromConstructor(PyFrameConstructor *constr); 18 | 19 | extern uint32_t _PyFunction_GetVersionForCurrentState(PyFunctionObject *func); 20 | extern PyObject *_Py_set_function_type_params( 21 | PyThreadState* unused, PyObject *func, PyObject *type_params); 22 | 23 | #ifdef __cplusplus 24 | } 25 | #endif 26 | #endif /* !Py_INTERNAL_FUNCTION_H */ 27 | -------------------------------------------------------------------------------- /AndroidApp/app/src/main/jni/python64/internal/pycore_genobject.h: -------------------------------------------------------------------------------- 1 | #ifndef Py_INTERNAL_GENOBJECT_H 2 | #define Py_INTERNAL_GENOBJECT_H 3 | #ifdef __cplusplus 4 | extern "C" { 5 | #endif 6 | 7 | #ifndef Py_BUILD_CORE 8 | # error "this header requires Py_BUILD_CORE define" 9 | #endif 10 | 11 | extern PyObject *_PyGen_yf(PyGenObject *); 12 | extern PyObject *_PyCoro_GetAwaitableIter(PyObject *o); 13 | extern PyObject *_PyAsyncGenValueWrapperNew(PyThreadState *state, PyObject *); 14 | 15 | /* runtime lifecycle */ 16 | 17 | extern void _PyAsyncGen_Fini(PyInterpreterState *); 18 | 19 | 20 | /* other API */ 21 | 22 | #ifndef WITH_FREELISTS 23 | // without freelists 24 | # define _PyAsyncGen_MAXFREELIST 0 25 | #endif 26 | 27 | #ifndef _PyAsyncGen_MAXFREELIST 28 | # define _PyAsyncGen_MAXFREELIST 80 29 | #endif 30 | 31 | struct _Py_async_gen_state { 32 | #if _PyAsyncGen_MAXFREELIST > 0 33 | /* Freelists boost performance 6-10%; they also reduce memory 34 | fragmentation, as _PyAsyncGenWrappedValue and PyAsyncGenASend 35 | are short-living objects that are instantiated for every 36 | __anext__() call. */ 37 | struct _PyAsyncGenWrappedValue* value_freelist[_PyAsyncGen_MAXFREELIST]; 38 | int value_numfree; 39 | 40 | struct PyAsyncGenASend* asend_freelist[_PyAsyncGen_MAXFREELIST]; 41 | int asend_numfree; 42 | #endif 43 | }; 44 | 45 | 46 | #ifdef __cplusplus 47 | } 48 | #endif 49 | #endif /* !Py_INTERNAL_GENOBJECT_H */ 50 | -------------------------------------------------------------------------------- /AndroidApp/app/src/main/jni/python64/internal/pycore_getopt.h: -------------------------------------------------------------------------------- 1 | #ifndef Py_INTERNAL_PYGETOPT_H 2 | #define Py_INTERNAL_PYGETOPT_H 3 | 4 | #ifndef Py_BUILD_CORE 5 | # error "this header requires Py_BUILD_CORE define" 6 | #endif 7 | 8 | extern int _PyOS_opterr; 9 | extern Py_ssize_t _PyOS_optind; 10 | extern const wchar_t *_PyOS_optarg; 11 | 12 | extern void _PyOS_ResetGetOpt(void); 13 | 14 | typedef struct { 15 | const wchar_t *name; 16 | int has_arg; 17 | int val; 18 | } _PyOS_LongOption; 19 | 20 | extern int _PyOS_GetOpt(Py_ssize_t argc, wchar_t * const *argv, int *longindex); 21 | 22 | #endif /* !Py_INTERNAL_PYGETOPT_H */ 23 | -------------------------------------------------------------------------------- /AndroidApp/app/src/main/jni/python64/internal/pycore_gil.h: -------------------------------------------------------------------------------- 1 | #ifndef Py_INTERNAL_GIL_H 2 | #define Py_INTERNAL_GIL_H 3 | #ifdef __cplusplus 4 | extern "C" { 5 | #endif 6 | 7 | #ifndef Py_BUILD_CORE 8 | # error "this header requires Py_BUILD_CORE define" 9 | #endif 10 | 11 | #include "pycore_atomic.h" /* _Py_atomic_address */ 12 | #include "pycore_condvar.h" /* PyCOND_T */ 13 | 14 | #ifndef Py_HAVE_CONDVAR 15 | # error You need either a POSIX-compatible or a Windows system! 16 | #endif 17 | 18 | /* Enable if you want to force the switching of threads at least 19 | every `interval`. */ 20 | #undef FORCE_SWITCHING 21 | #define FORCE_SWITCHING 22 | 23 | struct _gil_runtime_state { 24 | /* microseconds (the Python API uses seconds, though) */ 25 | unsigned long interval; 26 | /* Last PyThreadState holding / having held the GIL. This helps us 27 | know whether anyone else was scheduled after we dropped the GIL. */ 28 | _Py_atomic_address last_holder; 29 | /* Whether the GIL is already taken (-1 if uninitialized). This is 30 | atomic because it can be read without any lock taken in ceval.c. */ 31 | _Py_atomic_int locked; 32 | /* Number of GIL switches since the beginning. */ 33 | unsigned long switch_number; 34 | /* This condition variable allows one or several threads to wait 35 | until the GIL is released. In addition, the mutex also protects 36 | the above variables. */ 37 | PyCOND_T cond; 38 | PyMUTEX_T mutex; 39 | #ifdef FORCE_SWITCHING 40 | /* This condition variable helps the GIL-releasing thread wait for 41 | a GIL-awaiting thread to be scheduled and take the GIL. */ 42 | PyCOND_T switch_cond; 43 | PyMUTEX_T switch_mutex; 44 | #endif 45 | }; 46 | 47 | #ifdef __cplusplus 48 | } 49 | #endif 50 | #endif /* !Py_INTERNAL_GIL_H */ 51 | -------------------------------------------------------------------------------- /AndroidApp/app/src/main/jni/python64/internal/pycore_intrinsics.h: -------------------------------------------------------------------------------- 1 | // Auto-generated by Tools/build/generate_opcode_h.py from Lib/opcode.py 2 | 3 | /* Unary Functions: */ 4 | #define INTRINSIC_1_INVALID 0 5 | #define INTRINSIC_PRINT 1 6 | #define INTRINSIC_IMPORT_STAR 2 7 | #define INTRINSIC_STOPITERATION_ERROR 3 8 | #define INTRINSIC_ASYNC_GEN_WRAP 4 9 | #define INTRINSIC_UNARY_POSITIVE 5 10 | #define INTRINSIC_LIST_TO_TUPLE 6 11 | #define INTRINSIC_TYPEVAR 7 12 | #define INTRINSIC_PARAMSPEC 8 13 | #define INTRINSIC_TYPEVARTUPLE 9 14 | #define INTRINSIC_SUBSCRIPT_GENERIC 10 15 | #define INTRINSIC_TYPEALIAS 11 16 | 17 | #define MAX_INTRINSIC_1 11 18 | 19 | 20 | /* Binary Functions: */ 21 | #define INTRINSIC_2_INVALID 0 22 | #define INTRINSIC_PREP_RERAISE_STAR 1 23 | #define INTRINSIC_TYPEVAR_WITH_BOUND 2 24 | #define INTRINSIC_TYPEVAR_WITH_CONSTRAINTS 3 25 | #define INTRINSIC_SET_FUNCTION_TYPE_PARAMS 4 26 | 27 | #define MAX_INTRINSIC_2 4 28 | 29 | typedef PyObject *(*instrinsic_func1)(PyThreadState* tstate, PyObject *value); 30 | typedef PyObject *(*instrinsic_func2)(PyThreadState* tstate, PyObject *value1, PyObject *value2); 31 | extern const instrinsic_func1 _PyIntrinsics_UnaryFunctions[]; 32 | extern const instrinsic_func2 _PyIntrinsics_BinaryFunctions[]; 33 | -------------------------------------------------------------------------------- /AndroidApp/app/src/main/jni/python64/internal/pycore_memoryobject.h: -------------------------------------------------------------------------------- 1 | #ifndef Py_INTERNAL_MEMORYOBJECT_H 2 | #define Py_INTERNAL_MEMORYOBJECT_H 3 | #ifdef __cplusplus 4 | extern "C" { 5 | #endif 6 | 7 | #ifndef Py_BUILD_CORE 8 | # error "this header requires Py_BUILD_CORE define" 9 | #endif 10 | 11 | PyObject * 12 | _PyMemoryView_FromBufferProc(PyObject *v, int flags, 13 | getbufferproc bufferproc); 14 | 15 | #ifdef __cplusplus 16 | } 17 | #endif 18 | #endif /* !Py_INTERNAL_MEMORYOBJECT_H */ 19 | -------------------------------------------------------------------------------- /AndroidApp/app/src/main/jni/python64/internal/pycore_moduleobject.h: -------------------------------------------------------------------------------- 1 | #ifndef Py_INTERNAL_MODULEOBJECT_H 2 | #define Py_INTERNAL_MODULEOBJECT_H 3 | #ifdef __cplusplus 4 | extern "C" { 5 | #endif 6 | 7 | #ifndef Py_BUILD_CORE 8 | # error "this header requires Py_BUILD_CORE define" 9 | #endif 10 | 11 | typedef struct { 12 | PyObject_HEAD 13 | PyObject *md_dict; 14 | PyModuleDef *md_def; 15 | void *md_state; 16 | PyObject *md_weaklist; 17 | // for logging purposes after md_dict is cleared 18 | PyObject *md_name; 19 | } PyModuleObject; 20 | 21 | static inline PyModuleDef* _PyModule_GetDef(PyObject *mod) { 22 | assert(PyModule_Check(mod)); 23 | return ((PyModuleObject *)mod)->md_def; 24 | } 25 | 26 | static inline void* _PyModule_GetState(PyObject* mod) { 27 | assert(PyModule_Check(mod)); 28 | return ((PyModuleObject *)mod)->md_state; 29 | } 30 | 31 | static inline PyObject* _PyModule_GetDict(PyObject *mod) { 32 | assert(PyModule_Check(mod)); 33 | PyObject *dict = ((PyModuleObject *)mod) -> md_dict; 34 | // _PyModule_GetDict(mod) must not be used after calling module_clear(mod) 35 | assert(dict != NULL); 36 | return dict; 37 | } 38 | 39 | PyObject* _Py_module_getattro_impl(PyModuleObject *m, PyObject *name, int suppress); 40 | PyObject* _Py_module_getattro(PyModuleObject *m, PyObject *name); 41 | 42 | #ifdef __cplusplus 43 | } 44 | #endif 45 | #endif /* !Py_INTERNAL_MODULEOBJECT_H */ 46 | -------------------------------------------------------------------------------- /AndroidApp/app/src/main/jni/python64/internal/pycore_namespace.h: -------------------------------------------------------------------------------- 1 | // Simple namespace object interface 2 | 3 | #ifndef Py_INTERNAL_NAMESPACE_H 4 | #define Py_INTERNAL_NAMESPACE_H 5 | #ifdef __cplusplus 6 | extern "C" { 7 | #endif 8 | 9 | #ifndef Py_BUILD_CORE 10 | # error "this header requires Py_BUILD_CORE define" 11 | #endif 12 | 13 | PyAPI_DATA(PyTypeObject) _PyNamespace_Type; 14 | 15 | PyAPI_FUNC(PyObject *) _PyNamespace_New(PyObject *kwds); 16 | 17 | #ifdef __cplusplus 18 | } 19 | #endif 20 | #endif // !Py_INTERNAL_NAMESPACE_H 21 | -------------------------------------------------------------------------------- /AndroidApp/app/src/main/jni/python64/internal/pycore_object_state.h: -------------------------------------------------------------------------------- 1 | #ifndef Py_INTERNAL_OBJECT_STATE_H 2 | #define Py_INTERNAL_OBJECT_STATE_H 3 | #ifdef __cplusplus 4 | extern "C" { 5 | #endif 6 | 7 | #ifndef Py_BUILD_CORE 8 | # error "this header requires Py_BUILD_CORE define" 9 | #endif 10 | 11 | struct _py_object_runtime_state { 12 | #ifdef Py_REF_DEBUG 13 | Py_ssize_t interpreter_leaks; 14 | #endif 15 | int _not_used; 16 | }; 17 | 18 | struct _py_object_state { 19 | #ifdef Py_REF_DEBUG 20 | Py_ssize_t reftotal; 21 | #endif 22 | #ifdef Py_TRACE_REFS 23 | /* Head of circular doubly-linked list of all objects. These are linked 24 | * together via the _ob_prev and _ob_next members of a PyObject, which 25 | * exist only in a Py_TRACE_REFS build. 26 | */ 27 | PyObject refchain; 28 | #endif 29 | int _not_used; 30 | }; 31 | 32 | 33 | #ifdef __cplusplus 34 | } 35 | #endif 36 | #endif /* !Py_INTERNAL_OBJECT_STATE_H */ 37 | -------------------------------------------------------------------------------- /AndroidApp/app/src/main/jni/python64/internal/pycore_parser.h: -------------------------------------------------------------------------------- 1 | #ifndef Py_INTERNAL_PARSER_H 2 | #define Py_INTERNAL_PARSER_H 3 | #ifdef __cplusplus 4 | extern "C" { 5 | #endif 6 | 7 | #ifndef Py_BUILD_CORE 8 | # error "this header requires Py_BUILD_CORE define" 9 | #endif 10 | 11 | 12 | #include "pycore_ast.h" // struct _expr 13 | #include "pycore_global_strings.h" // _Py_DECLARE_STR() 14 | #include "pycore_pyarena.h" // PyArena 15 | 16 | 17 | #ifdef Py_DEBUG 18 | #define _PYPEGEN_NSTATISTICS 2000 19 | #endif 20 | 21 | struct _parser_runtime_state { 22 | #ifdef Py_DEBUG 23 | long memo_statistics[_PYPEGEN_NSTATISTICS]; 24 | #else 25 | int _not_used; 26 | #endif 27 | struct _expr dummy_name; 28 | }; 29 | 30 | _Py_DECLARE_STR(empty, "") 31 | #define _parser_runtime_state_INIT \ 32 | { \ 33 | .dummy_name = { \ 34 | .kind = Name_kind, \ 35 | .v.Name.id = &_Py_STR(empty), \ 36 | .v.Name.ctx = Load, \ 37 | .lineno = 1, \ 38 | .col_offset = 0, \ 39 | .end_lineno = 1, \ 40 | .end_col_offset = 0, \ 41 | }, \ 42 | } 43 | 44 | extern struct _mod* _PyParser_ASTFromString( 45 | const char *str, 46 | PyObject* filename, 47 | int mode, 48 | PyCompilerFlags *flags, 49 | PyArena *arena); 50 | 51 | extern struct _mod* _PyParser_ASTFromFile( 52 | FILE *fp, 53 | PyObject *filename_ob, 54 | const char *enc, 55 | int mode, 56 | const char *ps1, 57 | const char *ps2, 58 | PyCompilerFlags *flags, 59 | int *errcode, 60 | PyArena *arena); 61 | 62 | 63 | #ifdef __cplusplus 64 | } 65 | #endif 66 | #endif /* !Py_INTERNAL_PARSER_H */ 67 | -------------------------------------------------------------------------------- /AndroidApp/app/src/main/jni/python64/internal/pycore_pathconfig.h: -------------------------------------------------------------------------------- 1 | #ifndef Py_INTERNAL_PATHCONFIG_H 2 | #define Py_INTERNAL_PATHCONFIG_H 3 | #ifdef __cplusplus 4 | extern "C" { 5 | #endif 6 | 7 | #ifndef Py_BUILD_CORE 8 | # error "this header requires Py_BUILD_CORE define" 9 | #endif 10 | 11 | PyAPI_FUNC(void) _PyPathConfig_ClearGlobal(void); 12 | extern PyStatus _PyPathConfig_ReadGlobal(PyConfig *config); 13 | extern PyStatus _PyPathConfig_UpdateGlobal(const PyConfig *config); 14 | extern const wchar_t * _PyPathConfig_GetGlobalModuleSearchPath(void); 15 | 16 | extern int _PyPathConfig_ComputeSysPath0( 17 | const PyWideStringList *argv, 18 | PyObject **path0); 19 | 20 | 21 | #ifdef __cplusplus 22 | } 23 | #endif 24 | #endif /* !Py_INTERNAL_PATHCONFIG_H */ 25 | -------------------------------------------------------------------------------- /AndroidApp/app/src/main/jni/python64/internal/pycore_pyhash.h: -------------------------------------------------------------------------------- 1 | #ifndef Py_INTERNAL_HASH_H 2 | #define Py_INTERNAL_HASH_H 3 | 4 | #ifndef Py_BUILD_CORE 5 | # error "this header requires Py_BUILD_CORE define" 6 | #endif 7 | 8 | 9 | struct pyhash_runtime_state { 10 | struct { 11 | #ifndef MS_WINDOWS 12 | int fd; 13 | dev_t st_dev; 14 | ino_t st_ino; 15 | #else 16 | // This is a placeholder so the struct isn't empty on Windows. 17 | int _not_used; 18 | #endif 19 | } urandom_cache; 20 | }; 21 | 22 | #ifndef MS_WINDOWS 23 | # define _py_urandom_cache_INIT \ 24 | { \ 25 | .fd = -1, \ 26 | } 27 | #else 28 | # define _py_urandom_cache_INIT {0} 29 | #endif 30 | 31 | #define pyhash_state_INIT \ 32 | { \ 33 | .urandom_cache = _py_urandom_cache_INIT, \ 34 | } 35 | 36 | 37 | uint64_t _Py_KeyedHash(uint64_t, const char *, Py_ssize_t); 38 | 39 | 40 | #endif // Py_INTERNAL_HASH_H 41 | -------------------------------------------------------------------------------- /AndroidApp/app/src/main/jni/python64/internal/pycore_range.h: -------------------------------------------------------------------------------- 1 | #ifndef Py_INTERNAL_RANGE_H 2 | #define Py_INTERNAL_RANGE_H 3 | #ifdef __cplusplus 4 | extern "C" { 5 | #endif 6 | 7 | #ifndef Py_BUILD_CORE 8 | # error "this header requires Py_BUILD_CORE define" 9 | #endif 10 | 11 | typedef struct { 12 | PyObject_HEAD 13 | long start; 14 | long step; 15 | long len; 16 | } _PyRangeIterObject; 17 | 18 | #ifdef __cplusplus 19 | } 20 | #endif 21 | #endif /* !Py_INTERNAL_RANGE_H */ 22 | -------------------------------------------------------------------------------- /AndroidApp/app/src/main/jni/python64/internal/pycore_sliceobject.h: -------------------------------------------------------------------------------- 1 | #ifndef Py_INTERNAL_SLICEOBJECT_H 2 | #define Py_INTERNAL_SLICEOBJECT_H 3 | #ifdef __cplusplus 4 | extern "C" { 5 | #endif 6 | 7 | #ifndef Py_BUILD_CORE 8 | # error "this header requires Py_BUILD_CORE define" 9 | #endif 10 | 11 | 12 | /* runtime lifecycle */ 13 | 14 | extern void _PySlice_Fini(PyInterpreterState *); 15 | 16 | extern PyObject * 17 | _PyBuildSlice_ConsumeRefs(PyObject *start, PyObject *stop); 18 | 19 | #ifdef __cplusplus 20 | } 21 | #endif 22 | #endif /* !Py_INTERNAL_SLICEOBJECT_H */ 23 | -------------------------------------------------------------------------------- /AndroidApp/app/src/main/jni/python64/internal/pycore_strhex.h: -------------------------------------------------------------------------------- 1 | #ifndef Py_INTERNAL_STRHEX_H 2 | #define Py_INTERNAL_STRHEX_H 3 | #ifdef __cplusplus 4 | extern "C" { 5 | #endif 6 | 7 | #ifndef Py_BUILD_CORE 8 | # error "this header requires Py_BUILD_CORE define" 9 | #endif 10 | 11 | // Returns a str() containing the hex representation of argbuf. 12 | PyAPI_FUNC(PyObject*) _Py_strhex(const 13 | char* argbuf, 14 | const Py_ssize_t arglen); 15 | 16 | // Returns a bytes() containing the ASCII hex representation of argbuf. 17 | PyAPI_FUNC(PyObject*) _Py_strhex_bytes( 18 | const char* argbuf, 19 | const Py_ssize_t arglen); 20 | 21 | // These variants include support for a separator between every N bytes: 22 | PyAPI_FUNC(PyObject*) _Py_strhex_with_sep( 23 | const char* argbuf, 24 | const Py_ssize_t arglen, 25 | PyObject* sep, 26 | const int bytes_per_group); 27 | PyAPI_FUNC(PyObject*) _Py_strhex_bytes_with_sep( 28 | const char* argbuf, 29 | const Py_ssize_t arglen, 30 | PyObject* sep, 31 | const int bytes_per_group); 32 | 33 | #ifdef __cplusplus 34 | } 35 | #endif 36 | #endif /* !Py_INTERNAL_STRHEX_H */ 37 | -------------------------------------------------------------------------------- /AndroidApp/app/src/main/jni/python64/internal/pycore_structseq.h: -------------------------------------------------------------------------------- 1 | #ifndef Py_INTERNAL_STRUCTSEQ_H 2 | #define Py_INTERNAL_STRUCTSEQ_H 3 | #ifdef __cplusplus 4 | extern "C" { 5 | #endif 6 | 7 | #ifndef Py_BUILD_CORE 8 | # error "this header requires Py_BUILD_CORE define" 9 | #endif 10 | 11 | 12 | /* other API */ 13 | 14 | PyAPI_FUNC(PyTypeObject *) _PyStructSequence_NewType( 15 | PyStructSequence_Desc *desc, 16 | unsigned long tp_flags); 17 | 18 | extern int _PyStructSequence_InitBuiltinWithFlags( 19 | PyInterpreterState *interp, 20 | PyTypeObject *type, 21 | PyStructSequence_Desc *desc, 22 | unsigned long tp_flags); 23 | 24 | static inline int 25 | _PyStructSequence_InitBuiltin(PyInterpreterState *interp, 26 | PyTypeObject *type, 27 | PyStructSequence_Desc *desc) 28 | { 29 | return _PyStructSequence_InitBuiltinWithFlags(interp, type, desc, 0); 30 | } 31 | 32 | extern void _PyStructSequence_FiniBuiltin( 33 | PyInterpreterState *interp, 34 | PyTypeObject *type); 35 | 36 | #ifdef __cplusplus 37 | } 38 | #endif 39 | #endif /* !Py_INTERNAL_STRUCTSEQ_H */ 40 | -------------------------------------------------------------------------------- /AndroidApp/app/src/main/jni/python64/internal/pycore_sysmodule.h: -------------------------------------------------------------------------------- 1 | #ifndef Py_INTERNAL_SYSMODULE_H 2 | #define Py_INTERNAL_SYSMODULE_H 3 | #ifdef __cplusplus 4 | extern "C" { 5 | #endif 6 | 7 | #ifndef Py_BUILD_CORE 8 | # error "this header requires Py_BUILD_CORE define" 9 | #endif 10 | 11 | PyAPI_FUNC(int) _PySys_Audit( 12 | PyThreadState *tstate, 13 | const char *event, 14 | const char *argFormat, 15 | ...); 16 | 17 | /* We want minimal exposure of this function, so use extern rather than 18 | PyAPI_FUNC() to not export the symbol. */ 19 | extern void _PySys_ClearAuditHooks(PyThreadState *tstate); 20 | 21 | PyAPI_FUNC(int) _PySys_SetAttr(PyObject *, PyObject *); 22 | 23 | extern int _PySys_ClearAttrString(PyInterpreterState *interp, 24 | const char *name, int verbose); 25 | 26 | #ifdef __cplusplus 27 | } 28 | #endif 29 | #endif /* !Py_INTERNAL_SYSMODULE_H */ 30 | -------------------------------------------------------------------------------- /AndroidApp/app/src/main/jni/python64/internal/pycore_time.h: -------------------------------------------------------------------------------- 1 | #ifndef Py_INTERNAL_TIME_H 2 | #define Py_INTERNAL_TIME_H 3 | #ifdef __cplusplus 4 | extern "C" { 5 | #endif 6 | 7 | #ifndef Py_BUILD_CORE 8 | # error "this header requires Py_BUILD_CORE define" 9 | #endif 10 | 11 | 12 | struct _time_runtime_state { 13 | #ifdef HAVE_TIMES 14 | int ticks_per_second_initialized; 15 | long ticks_per_second; 16 | #else 17 | int _not_used; 18 | #endif 19 | }; 20 | 21 | 22 | #ifdef __cplusplus 23 | } 24 | #endif 25 | #endif /* !Py_INTERNAL_TIME_H */ 26 | -------------------------------------------------------------------------------- /AndroidApp/app/src/main/jni/python64/internal/pycore_typevarobject.h: -------------------------------------------------------------------------------- 1 | #ifndef Py_INTERNAL_TYPEVAROBJECT_H 2 | #define Py_INTERNAL_TYPEVAROBJECT_H 3 | #ifdef __cplusplus 4 | extern "C" { 5 | #endif 6 | 7 | #ifndef Py_BUILD_CORE 8 | # error "this header requires Py_BUILD_CORE define" 9 | #endif 10 | 11 | extern PyObject *_Py_make_typevar(PyObject *, PyObject *, PyObject *); 12 | extern PyObject *_Py_make_paramspec(PyThreadState *, PyObject *); 13 | extern PyObject *_Py_make_typevartuple(PyThreadState *, PyObject *); 14 | extern PyObject *_Py_make_typealias(PyThreadState *, PyObject *); 15 | extern PyObject *_Py_subscript_generic(PyThreadState *, PyObject *); 16 | extern int _Py_initialize_generic(PyInterpreterState *); 17 | extern void _Py_clear_generic_types(PyInterpreterState *); 18 | 19 | extern PyTypeObject _PyTypeAlias_Type; 20 | 21 | #ifdef __cplusplus 22 | } 23 | #endif 24 | #endif /* !Py_INTERNAL_TYPEVAROBJECT_H */ 25 | -------------------------------------------------------------------------------- /AndroidApp/app/src/main/jni/python64/internal/pycore_ucnhash.h: -------------------------------------------------------------------------------- 1 | /* Unicode name database interface */ 2 | #ifndef Py_INTERNAL_UCNHASH_H 3 | #define Py_INTERNAL_UCNHASH_H 4 | #ifdef __cplusplus 5 | extern "C" { 6 | #endif 7 | 8 | #ifndef Py_BUILD_CORE 9 | # error "this header requires Py_BUILD_CORE define" 10 | #endif 11 | 12 | /* revised ucnhash CAPI interface (exported through a "wrapper") */ 13 | 14 | #define PyUnicodeData_CAPSULE_NAME "unicodedata._ucnhash_CAPI" 15 | 16 | typedef struct { 17 | 18 | /* Get name for a given character code. 19 | Returns non-zero if success, zero if not. 20 | Does not set Python exceptions. */ 21 | int (*getname)(Py_UCS4 code, char* buffer, int buflen, 22 | int with_alias_and_seq); 23 | 24 | /* Get character code for a given name. 25 | Same error handling as for getname(). */ 26 | int (*getcode)(const char* name, int namelen, Py_UCS4* code, 27 | int with_named_seq); 28 | 29 | } _PyUnicode_Name_CAPI; 30 | 31 | #ifdef __cplusplus 32 | } 33 | #endif 34 | #endif /* !Py_INTERNAL_UCNHASH_H */ 35 | -------------------------------------------------------------------------------- /AndroidApp/app/src/main/jni/python64/internal/pycore_unionobject.h: -------------------------------------------------------------------------------- 1 | #ifndef Py_INTERNAL_UNIONOBJECT_H 2 | #define Py_INTERNAL_UNIONOBJECT_H 3 | #ifdef __cplusplus 4 | extern "C" { 5 | #endif 6 | 7 | #ifndef Py_BUILD_CORE 8 | # error "this header requires Py_BUILD_CORE define" 9 | #endif 10 | 11 | extern PyTypeObject _PyUnion_Type; 12 | #define _PyUnion_Check(op) Py_IS_TYPE((op), &_PyUnion_Type) 13 | extern PyObject *_Py_union_type_or(PyObject *, PyObject *); 14 | 15 | #define _PyGenericAlias_Check(op) PyObject_TypeCheck((op), &Py_GenericAliasType) 16 | extern PyObject *_Py_subs_parameters(PyObject *, PyObject *, PyObject *, PyObject *); 17 | extern PyObject *_Py_make_parameters(PyObject *); 18 | extern PyObject *_Py_union_args(PyObject *self); 19 | 20 | #ifdef __cplusplus 21 | } 22 | #endif 23 | #endif /* !Py_INTERNAL_UNIONOBJECT_H */ 24 | -------------------------------------------------------------------------------- /AndroidApp/app/src/main/jni/python64/internal/pycore_warnings.h: -------------------------------------------------------------------------------- 1 | #ifndef Py_INTERNAL_WARNINGS_H 2 | #define Py_INTERNAL_WARNINGS_H 3 | #ifdef __cplusplus 4 | extern "C" { 5 | #endif 6 | 7 | #ifndef Py_BUILD_CORE 8 | # error "this header requires Py_BUILD_CORE define" 9 | #endif 10 | 11 | struct _warnings_runtime_state { 12 | /* Both 'filters' and 'onceregistry' can be set in warnings.py; 13 | get_warnings_attr() will reset these variables accordingly. */ 14 | PyObject *filters; /* List */ 15 | PyObject *once_registry; /* Dict */ 16 | PyObject *default_action; /* String */ 17 | long filters_version; 18 | }; 19 | 20 | extern int _PyWarnings_InitState(PyInterpreterState *interp); 21 | 22 | PyAPI_FUNC(PyObject*) _PyWarnings_Init(void); 23 | 24 | extern void _PyErr_WarnUnawaitedCoroutine(PyObject *coro); 25 | 26 | #ifdef __cplusplus 27 | } 28 | #endif 29 | #endif /* !Py_INTERNAL_WARNINGS_H */ 30 | -------------------------------------------------------------------------------- /AndroidApp/app/src/main/jni/python64/interpreteridobject.h: -------------------------------------------------------------------------------- 1 | #ifndef Py_INTERPRETERIDOBJECT_H 2 | #define Py_INTERPRETERIDOBJECT_H 3 | 4 | #ifdef __cplusplus 5 | extern "C" { 6 | #endif 7 | 8 | #ifndef Py_LIMITED_API 9 | # define Py_CPYTHON_INTERPRETERIDOBJECT_H 10 | # include "cpython/interpreteridobject.h" 11 | # undef Py_CPYTHON_INTERPRETERIDOBJECT_H 12 | #endif 13 | 14 | #ifdef __cplusplus 15 | } 16 | #endif 17 | #endif /* !Py_INTERPRETERIDOBJECT_H */ 18 | -------------------------------------------------------------------------------- /AndroidApp/app/src/main/jni/python64/intrcheck.h: -------------------------------------------------------------------------------- 1 | #ifndef Py_INTRCHECK_H 2 | #define Py_INTRCHECK_H 3 | #ifdef __cplusplus 4 | extern "C" { 5 | #endif 6 | 7 | PyAPI_FUNC(int) PyOS_InterruptOccurred(void); 8 | #ifdef HAVE_FORK 9 | #if !defined(Py_LIMITED_API) || Py_LIMITED_API+0 >= 0x03070000 10 | PyAPI_FUNC(void) PyOS_BeforeFork(void); 11 | PyAPI_FUNC(void) PyOS_AfterFork_Parent(void); 12 | PyAPI_FUNC(void) PyOS_AfterFork_Child(void); 13 | #endif 14 | #endif 15 | /* Deprecated, please use PyOS_AfterFork_Child() instead */ 16 | Py_DEPRECATED(3.7) PyAPI_FUNC(void) PyOS_AfterFork(void); 17 | 18 | #ifndef Py_LIMITED_API 19 | PyAPI_FUNC(int) _PyOS_IsMainThread(void); 20 | 21 | #ifdef MS_WINDOWS 22 | /* windows.h is not included by Python.h so use void* instead of HANDLE */ 23 | PyAPI_FUNC(void*) _PyOS_SigintEvent(void); 24 | #endif 25 | #endif /* !Py_LIMITED_API */ 26 | 27 | #ifdef __cplusplus 28 | } 29 | #endif 30 | #endif /* !Py_INTRCHECK_H */ 31 | -------------------------------------------------------------------------------- /AndroidApp/app/src/main/jni/python64/iterobject.h: -------------------------------------------------------------------------------- 1 | #ifndef Py_ITEROBJECT_H 2 | #define Py_ITEROBJECT_H 3 | /* Iterators (the basic kind, over a sequence) */ 4 | #ifdef __cplusplus 5 | extern "C" { 6 | #endif 7 | 8 | PyAPI_DATA(PyTypeObject) PySeqIter_Type; 9 | PyAPI_DATA(PyTypeObject) PyCallIter_Type; 10 | #ifdef Py_BUILD_CORE 11 | extern PyTypeObject _PyAnextAwaitable_Type; 12 | #endif 13 | 14 | #define PySeqIter_Check(op) Py_IS_TYPE((op), &PySeqIter_Type) 15 | 16 | PyAPI_FUNC(PyObject *) PySeqIter_New(PyObject *); 17 | 18 | 19 | #define PyCallIter_Check(op) Py_IS_TYPE((op), &PyCallIter_Type) 20 | 21 | PyAPI_FUNC(PyObject *) PyCallIter_New(PyObject *, PyObject *); 22 | 23 | #ifdef __cplusplus 24 | } 25 | #endif 26 | #endif /* !Py_ITEROBJECT_H */ 27 | 28 | -------------------------------------------------------------------------------- /AndroidApp/app/src/main/jni/python64/marshal.h: -------------------------------------------------------------------------------- 1 | 2 | /* Interface for marshal.c */ 3 | 4 | #ifndef Py_MARSHAL_H 5 | #define Py_MARSHAL_H 6 | #ifndef Py_LIMITED_API 7 | 8 | #ifdef __cplusplus 9 | extern "C" { 10 | #endif 11 | 12 | PyAPI_FUNC(PyObject *) PyMarshal_ReadObjectFromString(const char *, 13 | Py_ssize_t); 14 | PyAPI_FUNC(PyObject *) PyMarshal_WriteObjectToString(PyObject *, int); 15 | 16 | #define Py_MARSHAL_VERSION 4 17 | 18 | PyAPI_FUNC(long) PyMarshal_ReadLongFromFile(FILE *); 19 | PyAPI_FUNC(int) PyMarshal_ReadShortFromFile(FILE *); 20 | PyAPI_FUNC(PyObject *) PyMarshal_ReadObjectFromFile(FILE *); 21 | PyAPI_FUNC(PyObject *) PyMarshal_ReadLastObjectFromFile(FILE *); 22 | 23 | PyAPI_FUNC(void) PyMarshal_WriteLongToFile(long, FILE *, int); 24 | PyAPI_FUNC(void) PyMarshal_WriteObjectToFile(PyObject *, FILE *, int); 25 | 26 | #ifdef __cplusplus 27 | } 28 | #endif 29 | 30 | #endif /* Py_LIMITED_API */ 31 | #endif /* !Py_MARSHAL_H */ 32 | -------------------------------------------------------------------------------- /AndroidApp/app/src/main/jni/python64/memoryobject.h: -------------------------------------------------------------------------------- 1 | /* Memory view object. In Python this is available as "memoryview". */ 2 | 3 | #ifndef Py_MEMORYOBJECT_H 4 | #define Py_MEMORYOBJECT_H 5 | #ifdef __cplusplus 6 | extern "C" { 7 | #endif 8 | 9 | PyAPI_DATA(PyTypeObject) PyMemoryView_Type; 10 | 11 | #define PyMemoryView_Check(op) Py_IS_TYPE((op), &PyMemoryView_Type) 12 | 13 | PyAPI_FUNC(PyObject *) PyMemoryView_FromObject(PyObject *base); 14 | #if !defined(Py_LIMITED_API) || Py_LIMITED_API+0 >= 0x03030000 15 | PyAPI_FUNC(PyObject *) PyMemoryView_FromMemory(char *mem, Py_ssize_t size, 16 | int flags); 17 | #endif 18 | #if !defined(Py_LIMITED_API) || Py_LIMITED_API+0 >= 0x030b0000 19 | PyAPI_FUNC(PyObject *) PyMemoryView_FromBuffer(const Py_buffer *info); 20 | #endif 21 | PyAPI_FUNC(PyObject *) PyMemoryView_GetContiguous(PyObject *base, 22 | int buffertype, 23 | char order); 24 | 25 | #ifndef Py_LIMITED_API 26 | # define Py_CPYTHON_MEMORYOBJECT_H 27 | # include "cpython/memoryobject.h" 28 | # undef Py_CPYTHON_MEMORYOBJECT_H 29 | #endif 30 | 31 | #ifdef __cplusplus 32 | } 33 | #endif 34 | #endif /* !Py_MEMORYOBJECT_H */ 35 | -------------------------------------------------------------------------------- /AndroidApp/app/src/main/jni/python64/osdefs.h: -------------------------------------------------------------------------------- 1 | #ifndef Py_OSDEFS_H 2 | #define Py_OSDEFS_H 3 | #ifdef __cplusplus 4 | extern "C" { 5 | #endif 6 | 7 | 8 | /* Operating system dependencies */ 9 | 10 | #ifdef MS_WINDOWS 11 | #define SEP L'\\' 12 | #define ALTSEP L'/' 13 | #define MAXPATHLEN 256 14 | #define DELIM L';' 15 | #endif 16 | 17 | #ifdef __VXWORKS__ 18 | #define DELIM L';' 19 | #endif 20 | 21 | /* Filename separator */ 22 | #ifndef SEP 23 | #define SEP L'/' 24 | #endif 25 | 26 | /* Max pathname length */ 27 | #ifdef __hpux 28 | #include 29 | #include 30 | #ifndef PATH_MAX 31 | #define PATH_MAX MAXPATHLEN 32 | #endif 33 | #endif 34 | 35 | #ifndef MAXPATHLEN 36 | #if defined(PATH_MAX) && PATH_MAX > 1024 37 | #define MAXPATHLEN PATH_MAX 38 | #else 39 | #define MAXPATHLEN 1024 40 | #endif 41 | #endif 42 | 43 | /* Search path entry delimiter */ 44 | #ifndef DELIM 45 | #define DELIM L':' 46 | #endif 47 | 48 | #ifdef __cplusplus 49 | } 50 | #endif 51 | #endif /* !Py_OSDEFS_H */ 52 | -------------------------------------------------------------------------------- /AndroidApp/app/src/main/jni/python64/osmodule.h: -------------------------------------------------------------------------------- 1 | 2 | /* os module interface */ 3 | 4 | #ifndef Py_OSMODULE_H 5 | #define Py_OSMODULE_H 6 | #ifdef __cplusplus 7 | extern "C" { 8 | #endif 9 | 10 | #if !defined(Py_LIMITED_API) || Py_LIMITED_API+0 >= 0x03060000 11 | PyAPI_FUNC(PyObject *) PyOS_FSPath(PyObject *path); 12 | #endif 13 | 14 | #ifdef __cplusplus 15 | } 16 | #endif 17 | #endif /* !Py_OSMODULE_H */ 18 | -------------------------------------------------------------------------------- /AndroidApp/app/src/main/jni/python64/patchlevel.h: -------------------------------------------------------------------------------- 1 | 2 | /* Python version identification scheme. 3 | 4 | When the major or minor version changes, the VERSION variable in 5 | configure.ac must also be changed. 6 | 7 | There is also (independent) API version information in modsupport.h. 8 | */ 9 | 10 | /* Values for PY_RELEASE_LEVEL */ 11 | #define PY_RELEASE_LEVEL_ALPHA 0xA 12 | #define PY_RELEASE_LEVEL_BETA 0xB 13 | #define PY_RELEASE_LEVEL_GAMMA 0xC /* For release candidates */ 14 | #define PY_RELEASE_LEVEL_FINAL 0xF /* Serial should be 0 here */ 15 | /* Higher for patch releases */ 16 | 17 | /* Version parsed out into numeric values */ 18 | /*--start constants--*/ 19 | #define PY_MAJOR_VERSION 3 20 | #define PY_MINOR_VERSION 12 21 | #define PY_MICRO_VERSION 4 22 | #define PY_RELEASE_LEVEL PY_RELEASE_LEVEL_FINAL 23 | #define PY_RELEASE_SERIAL 0 24 | 25 | /* Version as a string */ 26 | #define PY_VERSION "3.12.4" 27 | /*--end constants--*/ 28 | 29 | /* Version as a single 4-byte hex number, e.g. 0x010502B2 == 1.5.2b2. 30 | Use this for numeric comparisons, e.g. #if PY_VERSION_HEX >= ... */ 31 | #define PY_VERSION_HEX ((PY_MAJOR_VERSION << 24) | \ 32 | (PY_MINOR_VERSION << 16) | \ 33 | (PY_MICRO_VERSION << 8) | \ 34 | (PY_RELEASE_LEVEL << 4) | \ 35 | (PY_RELEASE_SERIAL << 0)) 36 | -------------------------------------------------------------------------------- /AndroidApp/app/src/main/jni/python64/pyframe.h: -------------------------------------------------------------------------------- 1 | /* Limited C API of PyFrame API 2 | * 3 | * Include "frameobject.h" to get the PyFrameObject structure. 4 | */ 5 | 6 | #ifndef Py_PYFRAME_H 7 | #define Py_PYFRAME_H 8 | #ifdef __cplusplus 9 | extern "C" { 10 | #endif 11 | 12 | /* Return the line of code the frame is currently executing. */ 13 | PyAPI_FUNC(int) PyFrame_GetLineNumber(PyFrameObject *); 14 | 15 | PyAPI_FUNC(PyCodeObject *) PyFrame_GetCode(PyFrameObject *frame); 16 | 17 | #ifndef Py_LIMITED_API 18 | # define Py_CPYTHON_PYFRAME_H 19 | # include "cpython/pyframe.h" 20 | # undef Py_CPYTHON_PYFRAME_H 21 | #endif 22 | 23 | #ifdef __cplusplus 24 | } 25 | #endif 26 | #endif /* !Py_PYFRAME_H */ 27 | -------------------------------------------------------------------------------- /AndroidApp/app/src/main/jni/python64/pystrcmp.h: -------------------------------------------------------------------------------- 1 | #ifndef Py_STRCMP_H 2 | #define Py_STRCMP_H 3 | 4 | #ifdef __cplusplus 5 | extern "C" { 6 | #endif 7 | 8 | PyAPI_FUNC(int) PyOS_mystrnicmp(const char *, const char *, Py_ssize_t); 9 | PyAPI_FUNC(int) PyOS_mystricmp(const char *, const char *); 10 | 11 | #ifdef MS_WINDOWS 12 | #define PyOS_strnicmp strnicmp 13 | #define PyOS_stricmp stricmp 14 | #else 15 | #define PyOS_strnicmp PyOS_mystrnicmp 16 | #define PyOS_stricmp PyOS_mystricmp 17 | #endif 18 | 19 | #ifdef __cplusplus 20 | } 21 | #endif 22 | 23 | #endif /* !Py_STRCMP_H */ 24 | -------------------------------------------------------------------------------- /AndroidApp/app/src/main/jni/python64/pystrtod.h: -------------------------------------------------------------------------------- 1 | #ifndef Py_STRTOD_H 2 | #define Py_STRTOD_H 3 | 4 | #ifdef __cplusplus 5 | extern "C" { 6 | #endif 7 | 8 | 9 | PyAPI_FUNC(double) PyOS_string_to_double(const char *str, 10 | char **endptr, 11 | PyObject *overflow_exception); 12 | 13 | /* The caller is responsible for calling PyMem_Free to free the buffer 14 | that's is returned. */ 15 | PyAPI_FUNC(char *) PyOS_double_to_string(double val, 16 | char format_code, 17 | int precision, 18 | int flags, 19 | int *type); 20 | 21 | #ifndef Py_LIMITED_API 22 | PyAPI_FUNC(PyObject *) _Py_string_to_number_with_underscores( 23 | const char *str, Py_ssize_t len, const char *what, PyObject *obj, void *arg, 24 | PyObject *(*innerfunc)(const char *, Py_ssize_t, void *)); 25 | 26 | PyAPI_FUNC(double) _Py_parse_inf_or_nan(const char *p, char **endptr); 27 | #endif 28 | 29 | 30 | /* PyOS_double_to_string's "flags" parameter can be set to 0 or more of: */ 31 | #define Py_DTSF_SIGN 0x01 /* always add the sign */ 32 | #define Py_DTSF_ADD_DOT_0 0x02 /* if the result is an integer add ".0" */ 33 | #define Py_DTSF_ALT 0x04 /* "alternate" formatting. it's format_code 34 | specific */ 35 | #define Py_DTSF_NO_NEG_0 0x08 /* negative zero result is coerced to 0 */ 36 | 37 | /* PyOS_double_to_string's "type", if non-NULL, will be set to one of: */ 38 | #define Py_DTST_FINITE 0 39 | #define Py_DTST_INFINITE 1 40 | #define Py_DTST_NAN 2 41 | 42 | #ifdef __cplusplus 43 | } 44 | #endif 45 | 46 | #endif /* !Py_STRTOD_H */ 47 | -------------------------------------------------------------------------------- /AndroidApp/app/src/main/jni/python64/pythonrun.h: -------------------------------------------------------------------------------- 1 | 2 | /* Interfaces to parse and execute pieces of python code */ 3 | 4 | #ifndef Py_PYTHONRUN_H 5 | #define Py_PYTHONRUN_H 6 | #ifdef __cplusplus 7 | extern "C" { 8 | #endif 9 | 10 | PyAPI_FUNC(PyObject *) Py_CompileString(const char *, const char *, int); 11 | 12 | PyAPI_FUNC(void) PyErr_Print(void); 13 | PyAPI_FUNC(void) PyErr_PrintEx(int); 14 | PyAPI_FUNC(void) PyErr_Display(PyObject *, PyObject *, PyObject *); 15 | 16 | #if !defined(Py_LIMITED_API) || Py_LIMITED_API+0 >= 0x030C0000 17 | PyAPI_FUNC(void) PyErr_DisplayException(PyObject *); 18 | #endif 19 | 20 | 21 | /* Stuff with no proper home (yet) */ 22 | PyAPI_DATA(int) (*PyOS_InputHook)(void); 23 | 24 | /* Stack size, in "pointers" (so we get extra safety margins 25 | on 64-bit platforms). On a 32-bit platform, this translates 26 | to an 8k margin. */ 27 | #define PYOS_STACK_MARGIN 2048 28 | 29 | #if defined(WIN32) && !defined(MS_WIN64) && !defined(_M_ARM) && defined(_MSC_VER) && _MSC_VER >= 1300 30 | /* Enable stack checking under Microsoft C */ 31 | // When changing the platforms, ensure PyOS_CheckStack() docs are still correct 32 | #define USE_STACKCHECK 33 | #endif 34 | 35 | #ifdef USE_STACKCHECK 36 | /* Check that we aren't overflowing our stack */ 37 | PyAPI_FUNC(int) PyOS_CheckStack(void); 38 | #endif 39 | 40 | #ifndef Py_LIMITED_API 41 | # define Py_CPYTHON_PYTHONRUN_H 42 | # include "cpython/pythonrun.h" 43 | # undef Py_CPYTHON_PYTHONRUN_H 44 | #endif 45 | 46 | #ifdef __cplusplus 47 | } 48 | #endif 49 | #endif /* !Py_PYTHONRUN_H */ 50 | -------------------------------------------------------------------------------- /AndroidApp/app/src/main/jni/python64/pytypedefs.h: -------------------------------------------------------------------------------- 1 | // Forward declarations of types of the Python C API. 2 | // Declare them at the same place since redefining typedef is a C11 feature. 3 | // Only use a forward declaration if there is an interdependency between two 4 | // header files. 5 | 6 | #ifndef Py_PYTYPEDEFS_H 7 | #define Py_PYTYPEDEFS_H 8 | #ifdef __cplusplus 9 | extern "C" { 10 | #endif 11 | 12 | typedef struct PyModuleDef PyModuleDef; 13 | typedef struct PyModuleDef_Slot PyModuleDef_Slot; 14 | typedef struct PyMethodDef PyMethodDef; 15 | typedef struct PyGetSetDef PyGetSetDef; 16 | typedef struct PyMemberDef PyMemberDef; 17 | 18 | typedef struct _object PyObject; 19 | typedef struct _longobject PyLongObject; 20 | typedef struct _typeobject PyTypeObject; 21 | typedef struct PyCodeObject PyCodeObject; 22 | typedef struct _frame PyFrameObject; 23 | 24 | typedef struct _ts PyThreadState; 25 | typedef struct _is PyInterpreterState; 26 | 27 | #ifdef __cplusplus 28 | } 29 | #endif 30 | #endif // !Py_PYTYPEDEFS_H 31 | -------------------------------------------------------------------------------- /AndroidApp/app/src/main/jni/python64/rangeobject.h: -------------------------------------------------------------------------------- 1 | 2 | /* Range object interface */ 3 | 4 | #ifndef Py_RANGEOBJECT_H 5 | #define Py_RANGEOBJECT_H 6 | #ifdef __cplusplus 7 | extern "C" { 8 | #endif 9 | 10 | /* 11 | A range object represents an integer range. This is an immutable object; 12 | a range cannot change its value after creation. 13 | 14 | Range objects behave like the corresponding tuple objects except that 15 | they are represented by a start, stop, and step datamembers. 16 | */ 17 | 18 | PyAPI_DATA(PyTypeObject) PyRange_Type; 19 | PyAPI_DATA(PyTypeObject) PyRangeIter_Type; 20 | PyAPI_DATA(PyTypeObject) PyLongRangeIter_Type; 21 | 22 | #define PyRange_Check(op) Py_IS_TYPE((op), &PyRange_Type) 23 | 24 | #ifdef __cplusplus 25 | } 26 | #endif 27 | #endif /* !Py_RANGEOBJECT_H */ 28 | -------------------------------------------------------------------------------- /AndroidApp/app/src/main/jni/python64/setobject.h: -------------------------------------------------------------------------------- 1 | /* Set object interface */ 2 | 3 | #ifndef Py_SETOBJECT_H 4 | #define Py_SETOBJECT_H 5 | #ifdef __cplusplus 6 | extern "C" { 7 | #endif 8 | 9 | PyAPI_DATA(PyTypeObject) PySet_Type; 10 | PyAPI_DATA(PyTypeObject) PyFrozenSet_Type; 11 | PyAPI_DATA(PyTypeObject) PySetIter_Type; 12 | 13 | PyAPI_FUNC(PyObject *) PySet_New(PyObject *); 14 | PyAPI_FUNC(PyObject *) PyFrozenSet_New(PyObject *); 15 | 16 | PyAPI_FUNC(int) PySet_Add(PyObject *set, PyObject *key); 17 | PyAPI_FUNC(int) PySet_Clear(PyObject *set); 18 | PyAPI_FUNC(int) PySet_Contains(PyObject *anyset, PyObject *key); 19 | PyAPI_FUNC(int) PySet_Discard(PyObject *set, PyObject *key); 20 | PyAPI_FUNC(PyObject *) PySet_Pop(PyObject *set); 21 | PyAPI_FUNC(Py_ssize_t) PySet_Size(PyObject *anyset); 22 | 23 | #define PyFrozenSet_CheckExact(ob) Py_IS_TYPE((ob), &PyFrozenSet_Type) 24 | #define PyFrozenSet_Check(ob) \ 25 | (Py_IS_TYPE((ob), &PyFrozenSet_Type) || \ 26 | PyType_IsSubtype(Py_TYPE(ob), &PyFrozenSet_Type)) 27 | 28 | #define PyAnySet_CheckExact(ob) \ 29 | (Py_IS_TYPE((ob), &PySet_Type) || Py_IS_TYPE((ob), &PyFrozenSet_Type)) 30 | #define PyAnySet_Check(ob) \ 31 | (Py_IS_TYPE((ob), &PySet_Type) || Py_IS_TYPE((ob), &PyFrozenSet_Type) || \ 32 | PyType_IsSubtype(Py_TYPE(ob), &PySet_Type) || \ 33 | PyType_IsSubtype(Py_TYPE(ob), &PyFrozenSet_Type)) 34 | 35 | #define PySet_CheckExact(op) Py_IS_TYPE(op, &PySet_Type) 36 | #define PySet_Check(ob) \ 37 | (Py_IS_TYPE((ob), &PySet_Type) || \ 38 | PyType_IsSubtype(Py_TYPE(ob), &PySet_Type)) 39 | 40 | #ifndef Py_LIMITED_API 41 | # define Py_CPYTHON_SETOBJECT_H 42 | # include "cpython/setobject.h" 43 | # undef Py_CPYTHON_SETOBJECT_H 44 | #endif 45 | 46 | #ifdef __cplusplus 47 | } 48 | #endif 49 | #endif /* !Py_SETOBJECT_H */ 50 | -------------------------------------------------------------------------------- /AndroidApp/app/src/main/jni/python64/structseq.h: -------------------------------------------------------------------------------- 1 | 2 | /* Named tuple object interface */ 3 | 4 | #ifndef Py_STRUCTSEQ_H 5 | #define Py_STRUCTSEQ_H 6 | #ifdef __cplusplus 7 | extern "C" { 8 | #endif 9 | 10 | typedef struct PyStructSequence_Field { 11 | const char *name; 12 | const char *doc; 13 | } PyStructSequence_Field; 14 | 15 | typedef struct PyStructSequence_Desc { 16 | const char *name; 17 | const char *doc; 18 | PyStructSequence_Field *fields; 19 | int n_in_sequence; 20 | } PyStructSequence_Desc; 21 | 22 | PyAPI_DATA(const char * const) PyStructSequence_UnnamedField; 23 | 24 | #ifndef Py_LIMITED_API 25 | PyAPI_FUNC(void) PyStructSequence_InitType(PyTypeObject *type, 26 | PyStructSequence_Desc *desc); 27 | PyAPI_FUNC(int) PyStructSequence_InitType2(PyTypeObject *type, 28 | PyStructSequence_Desc *desc); 29 | #endif 30 | PyAPI_FUNC(PyTypeObject*) PyStructSequence_NewType(PyStructSequence_Desc *desc); 31 | 32 | PyAPI_FUNC(PyObject *) PyStructSequence_New(PyTypeObject* type); 33 | 34 | #ifndef Py_LIMITED_API 35 | typedef PyTupleObject PyStructSequence; 36 | 37 | /* Macro, *only* to be used to fill in brand new objects */ 38 | #define PyStructSequence_SET_ITEM(op, i, v) PyTuple_SET_ITEM((op), (i), (v)) 39 | 40 | #define PyStructSequence_GET_ITEM(op, i) PyTuple_GET_ITEM((op), (i)) 41 | #endif 42 | 43 | PyAPI_FUNC(void) PyStructSequence_SetItem(PyObject*, Py_ssize_t, PyObject*); 44 | PyAPI_FUNC(PyObject*) PyStructSequence_GetItem(PyObject*, Py_ssize_t); 45 | 46 | #ifdef __cplusplus 47 | } 48 | #endif 49 | #endif /* !Py_STRUCTSEQ_H */ 50 | -------------------------------------------------------------------------------- /AndroidApp/app/src/main/jni/python64/traceback.h: -------------------------------------------------------------------------------- 1 | #ifndef Py_TRACEBACK_H 2 | #define Py_TRACEBACK_H 3 | #ifdef __cplusplus 4 | extern "C" { 5 | #endif 6 | 7 | /* Traceback interface */ 8 | 9 | PyAPI_FUNC(int) PyTraceBack_Here(PyFrameObject *); 10 | PyAPI_FUNC(int) PyTraceBack_Print(PyObject *, PyObject *); 11 | 12 | /* Reveal traceback type so we can typecheck traceback objects */ 13 | PyAPI_DATA(PyTypeObject) PyTraceBack_Type; 14 | #define PyTraceBack_Check(v) Py_IS_TYPE((v), &PyTraceBack_Type) 15 | 16 | 17 | #ifndef Py_LIMITED_API 18 | # define Py_CPYTHON_TRACEBACK_H 19 | # include "cpython/traceback.h" 20 | # undef Py_CPYTHON_TRACEBACK_H 21 | #endif 22 | 23 | #ifdef __cplusplus 24 | } 25 | #endif 26 | #endif /* !Py_TRACEBACK_H */ 27 | -------------------------------------------------------------------------------- /AndroidApp/app/src/main/jni/python64/tupleobject.h: -------------------------------------------------------------------------------- 1 | /* Tuple object interface */ 2 | 3 | #ifndef Py_TUPLEOBJECT_H 4 | #define Py_TUPLEOBJECT_H 5 | #ifdef __cplusplus 6 | extern "C" { 7 | #endif 8 | 9 | /* 10 | Another generally useful object type is a tuple of object pointers. 11 | For Python, this is an immutable type. C code can change the tuple items 12 | (but not their number), and even use tuples as general-purpose arrays of 13 | object references, but in general only brand new tuples should be mutated, 14 | not ones that might already have been exposed to Python code. 15 | 16 | *** WARNING *** PyTuple_SetItem does not increment the new item's reference 17 | count, but does decrement the reference count of the item it replaces, 18 | if not nil. It does *decrement* the reference count if it is *not* 19 | inserted in the tuple. Similarly, PyTuple_GetItem does not increment the 20 | returned item's reference count. 21 | */ 22 | 23 | PyAPI_DATA(PyTypeObject) PyTuple_Type; 24 | PyAPI_DATA(PyTypeObject) PyTupleIter_Type; 25 | 26 | #define PyTuple_Check(op) \ 27 | PyType_FastSubclass(Py_TYPE(op), Py_TPFLAGS_TUPLE_SUBCLASS) 28 | #define PyTuple_CheckExact(op) Py_IS_TYPE((op), &PyTuple_Type) 29 | 30 | PyAPI_FUNC(PyObject *) PyTuple_New(Py_ssize_t size); 31 | PyAPI_FUNC(Py_ssize_t) PyTuple_Size(PyObject *); 32 | PyAPI_FUNC(PyObject *) PyTuple_GetItem(PyObject *, Py_ssize_t); 33 | PyAPI_FUNC(int) PyTuple_SetItem(PyObject *, Py_ssize_t, PyObject *); 34 | PyAPI_FUNC(PyObject *) PyTuple_GetSlice(PyObject *, Py_ssize_t, Py_ssize_t); 35 | PyAPI_FUNC(PyObject *) PyTuple_Pack(Py_ssize_t, ...); 36 | 37 | #ifndef Py_LIMITED_API 38 | # define Py_CPYTHON_TUPLEOBJECT_H 39 | # include "cpython/tupleobject.h" 40 | # undef Py_CPYTHON_TUPLEOBJECT_H 41 | #endif 42 | 43 | #ifdef __cplusplus 44 | } 45 | #endif 46 | #endif /* !Py_TUPLEOBJECT_H */ 47 | -------------------------------------------------------------------------------- /AndroidApp/app/src/main/jni/python64/warnings.h: -------------------------------------------------------------------------------- 1 | #ifndef Py_WARNINGS_H 2 | #define Py_WARNINGS_H 3 | #ifdef __cplusplus 4 | extern "C" { 5 | #endif 6 | 7 | PyAPI_FUNC(int) PyErr_WarnEx( 8 | PyObject *category, 9 | const char *message, /* UTF-8 encoded string */ 10 | Py_ssize_t stack_level); 11 | 12 | PyAPI_FUNC(int) PyErr_WarnFormat( 13 | PyObject *category, 14 | Py_ssize_t stack_level, 15 | const char *format, /* ASCII-encoded string */ 16 | ...); 17 | 18 | #if !defined(Py_LIMITED_API) || Py_LIMITED_API+0 >= 0x03060000 19 | /* Emit a ResourceWarning warning */ 20 | PyAPI_FUNC(int) PyErr_ResourceWarning( 21 | PyObject *source, 22 | Py_ssize_t stack_level, 23 | const char *format, /* ASCII-encoded string */ 24 | ...); 25 | #endif 26 | 27 | PyAPI_FUNC(int) PyErr_WarnExplicit( 28 | PyObject *category, 29 | const char *message, /* UTF-8 encoded string */ 30 | const char *filename, /* decoded from the filesystem encoding */ 31 | int lineno, 32 | const char *module, /* UTF-8 encoded string */ 33 | PyObject *registry); 34 | 35 | #ifndef Py_LIMITED_API 36 | # define Py_CPYTHON_WARNINGS_H 37 | # include "cpython/warnings.h" 38 | # undef Py_CPYTHON_WARNINGS_H 39 | #endif 40 | 41 | #ifdef __cplusplus 42 | } 43 | #endif 44 | #endif /* !Py_WARNINGS_H */ 45 | 46 | -------------------------------------------------------------------------------- /AndroidApp/app/src/main/jni/python64/weakrefobject.h: -------------------------------------------------------------------------------- 1 | /* Weak references objects for Python. */ 2 | 3 | #ifndef Py_WEAKREFOBJECT_H 4 | #define Py_WEAKREFOBJECT_H 5 | #ifdef __cplusplus 6 | extern "C" { 7 | #endif 8 | 9 | typedef struct _PyWeakReference PyWeakReference; 10 | 11 | PyAPI_DATA(PyTypeObject) _PyWeakref_RefType; 12 | PyAPI_DATA(PyTypeObject) _PyWeakref_ProxyType; 13 | PyAPI_DATA(PyTypeObject) _PyWeakref_CallableProxyType; 14 | 15 | #define PyWeakref_CheckRef(op) PyObject_TypeCheck((op), &_PyWeakref_RefType) 16 | #define PyWeakref_CheckRefExact(op) \ 17 | Py_IS_TYPE((op), &_PyWeakref_RefType) 18 | #define PyWeakref_CheckProxy(op) \ 19 | (Py_IS_TYPE((op), &_PyWeakref_ProxyType) \ 20 | || Py_IS_TYPE((op), &_PyWeakref_CallableProxyType)) 21 | 22 | #define PyWeakref_Check(op) \ 23 | (PyWeakref_CheckRef(op) || PyWeakref_CheckProxy(op)) 24 | 25 | 26 | PyAPI_FUNC(PyObject *) PyWeakref_NewRef(PyObject *ob, 27 | PyObject *callback); 28 | PyAPI_FUNC(PyObject *) PyWeakref_NewProxy(PyObject *ob, 29 | PyObject *callback); 30 | PyAPI_FUNC(PyObject *) PyWeakref_GetObject(PyObject *ref); 31 | 32 | 33 | #ifndef Py_LIMITED_API 34 | # define Py_CPYTHON_WEAKREFOBJECT_H 35 | # include "cpython/weakrefobject.h" 36 | # undef Py_CPYTHON_WEAKREFOBJECT_H 37 | #endif 38 | 39 | #ifdef __cplusplus 40 | } 41 | #endif 42 | #endif /* !Py_WEAKREFOBJECT_H */ 43 | -------------------------------------------------------------------------------- /AndroidApp/app/src/main/jni/util.cpp: -------------------------------------------------------------------------------- 1 | 2 | 3 | #include "util.hpp" 4 | #include "Python.h" 5 | 6 | const char *cDirectorySlash = "/"; 7 | const char *cPythonPathSeperator = ":"; 8 | 9 | 10 | const std::wstring Utilities::getWStringFromJava(JNIEnv *env, jstring aString) 11 | { 12 | // For now I'm saying we only really support UTF8. When we need to support more, 13 | // well, that is when we spend more time on it. 14 | std::string lString = getStringFromJava(env, aString); 15 | 16 | // Convert our string to a wide string 17 | std::wstring lOutput(lString.begin(), lString.end()); 18 | 19 | return lOutput; 20 | } 21 | -------------------------------------------------------------------------------- /AndroidApp/app/src/main/jniLibs/arm64-v8a/libpython3.12.so: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/GRRedWings/python3-android/d16218a8511e240d23b166ccaf4a384dd0a924bd/AndroidApp/app/src/main/jniLibs/arm64-v8a/libpython3.12.so -------------------------------------------------------------------------------- /AndroidApp/app/src/main/jniLibs/x86_64/libpython3.12.so: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/GRRedWings/python3-android/d16218a8511e240d23b166ccaf4a384dd0a924bd/AndroidApp/app/src/main/jniLibs/x86_64/libpython3.12.so -------------------------------------------------------------------------------- /AndroidApp/app/src/main/res/layout/activity_main.xml: -------------------------------------------------------------------------------- 1 | 2 | 8 | 9 | 13 | 14 | 20 | 21 | 22 | 23 | 24 | 25 | 32 | 33 | -------------------------------------------------------------------------------- /AndroidApp/app/src/main/res/layout/content_main.xml: -------------------------------------------------------------------------------- 1 | 2 | 10 | 11 | 19 | 20 | -------------------------------------------------------------------------------- /AndroidApp/app/src/main/res/menu/menu_main.xml: -------------------------------------------------------------------------------- 1 | 5 | 10 | 11 | -------------------------------------------------------------------------------- /AndroidApp/app/src/main/res/mipmap-anydpi-v26/ic_launcher.xml: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | 5 | -------------------------------------------------------------------------------- /AndroidApp/app/src/main/res/mipmap-anydpi-v26/ic_launcher_round.xml: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | 5 | -------------------------------------------------------------------------------- /AndroidApp/app/src/main/res/mipmap-hdpi/ic_launcher.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/GRRedWings/python3-android/d16218a8511e240d23b166ccaf4a384dd0a924bd/AndroidApp/app/src/main/res/mipmap-hdpi/ic_launcher.png -------------------------------------------------------------------------------- /AndroidApp/app/src/main/res/mipmap-hdpi/ic_launcher_round.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/GRRedWings/python3-android/d16218a8511e240d23b166ccaf4a384dd0a924bd/AndroidApp/app/src/main/res/mipmap-hdpi/ic_launcher_round.png -------------------------------------------------------------------------------- /AndroidApp/app/src/main/res/mipmap-mdpi/ic_launcher.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/GRRedWings/python3-android/d16218a8511e240d23b166ccaf4a384dd0a924bd/AndroidApp/app/src/main/res/mipmap-mdpi/ic_launcher.png -------------------------------------------------------------------------------- /AndroidApp/app/src/main/res/mipmap-mdpi/ic_launcher_round.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/GRRedWings/python3-android/d16218a8511e240d23b166ccaf4a384dd0a924bd/AndroidApp/app/src/main/res/mipmap-mdpi/ic_launcher_round.png -------------------------------------------------------------------------------- /AndroidApp/app/src/main/res/mipmap-xhdpi/ic_launcher.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/GRRedWings/python3-android/d16218a8511e240d23b166ccaf4a384dd0a924bd/AndroidApp/app/src/main/res/mipmap-xhdpi/ic_launcher.png -------------------------------------------------------------------------------- /AndroidApp/app/src/main/res/mipmap-xhdpi/ic_launcher_round.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/GRRedWings/python3-android/d16218a8511e240d23b166ccaf4a384dd0a924bd/AndroidApp/app/src/main/res/mipmap-xhdpi/ic_launcher_round.png -------------------------------------------------------------------------------- /AndroidApp/app/src/main/res/mipmap-xxhdpi/ic_launcher.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/GRRedWings/python3-android/d16218a8511e240d23b166ccaf4a384dd0a924bd/AndroidApp/app/src/main/res/mipmap-xxhdpi/ic_launcher.png -------------------------------------------------------------------------------- /AndroidApp/app/src/main/res/mipmap-xxhdpi/ic_launcher_round.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/GRRedWings/python3-android/d16218a8511e240d23b166ccaf4a384dd0a924bd/AndroidApp/app/src/main/res/mipmap-xxhdpi/ic_launcher_round.png -------------------------------------------------------------------------------- /AndroidApp/app/src/main/res/mipmap-xxxhdpi/ic_launcher.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/GRRedWings/python3-android/d16218a8511e240d23b166ccaf4a384dd0a924bd/AndroidApp/app/src/main/res/mipmap-xxxhdpi/ic_launcher.png -------------------------------------------------------------------------------- /AndroidApp/app/src/main/res/mipmap-xxxhdpi/ic_launcher_round.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/GRRedWings/python3-android/d16218a8511e240d23b166ccaf4a384dd0a924bd/AndroidApp/app/src/main/res/mipmap-xxxhdpi/ic_launcher_round.png -------------------------------------------------------------------------------- /AndroidApp/app/src/main/res/values/colors.xml: -------------------------------------------------------------------------------- 1 | 2 | 3 | #008577 4 | #00574B 5 | #D81B60 6 | 7 | -------------------------------------------------------------------------------- /AndroidApp/app/src/main/res/values/dimens.xml: -------------------------------------------------------------------------------- 1 | 2 | 16dp 3 | 4 | -------------------------------------------------------------------------------- /AndroidApp/app/src/main/res/values/strings.xml: -------------------------------------------------------------------------------- 1 | 2 | PythonTest 3 | Settings 4 | 5 | -------------------------------------------------------------------------------- /AndroidApp/app/src/main/res/values/styles.xml: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | 10 | 11 | 15 | 16 |