├── .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