diff --git a/README.md b/README.md
index 4ae710c4fcd955201224d61a7c8159f4460367af..8f329f53b46b3e149ca1637b6985bf564316a9ec 100644
--- a/README.md
+++ b/README.md
@@ -5,10 +5,14 @@ This provides a set of scripts and a configuration file allowing to build TELEMA
## Prerequisites:
- **Git**: download it from [gitforwindows.org](https://gitforwindows.org/) and install it with the LFS extension.
-- **CMake**: install the latest 64 bits version available from [cmake.org](https://cmake.org), and ensure that CMake `bin` directory is added to your `PATH` environment variable.<br>
-Note: to install CMake without administrator rights, you need to download and extract the zip file and set your `PATH` manually.
-- **Mingw-w64**: download the 12.2 version from [winlibs](https://github.com/brechtsanders/winlibs_mingw/releases/download/12.2.0-15.0.7-10.0.0-msvcrt-r4/winlibs-x86_64-posix-seh-gcc-12.2.0-mingw-w64msvcrt-10.0.0-r4.zip) and extract it to `C:\`.<br>
+- **CMake**: install the latest 64 bits version available from [cmake.org](https://cmake.org), and ensure that CMake
+`bin` directory is added to your `PATH` environment variable.<br>
+Note: to install CMake without administrator rights, you need to download and extract the zip file and set your `PATH`
+manually.
+- **Mingw-w64**: download the latest version from [winlibs](https://github.com/brechtsanders/winlibs_mingw/releases/download/12.2.0-14.0.6-10.0.0-msvcrt-r2/winlibs-x86_64-posix-seh-gcc-12.2.0-mingw-w64msvcrt-10.0.0-r2.zip) and extract it to `C:\`.<br>
Note: if you don't install Mingw-w64 in `C:\`, you will need to add its `bin` directory to your `PATH`.
+- **Python**: download and install the 3.10 version from [python.org](https://www.python.org/ftp/python/3.10.9/python-3.10.9-amd64.exe).<br>
+Note: to install Python without administrator rights, you must uncheck the option `Use admin privileges when installing py.exe`.
## Proxy configuration
diff --git a/build-telemac-deps.bat b/build-telemac-deps.bat
index b4031811aaeb35623eb3b5e9bdc9d9452ed0eb5e..22d033e8f703d0967c292b9b7f5bb6753febfb62 100644
--- a/build-telemac-deps.bat
+++ b/build-telemac-deps.bat
@@ -1,7 +1,29 @@
@echo off
+rem Local variables only
+setlocal
+
+rem ****************************************
+rem Dependency versions must be defined here
+rem ****************************************
+set hdf5=hdf5-1.10.9
+set med=med-4.1.1
+set metis=metis-5.1.0
+set msmpi=msmpi-10.1.2
+set openblas=openblas-0.3.21
+set scalapack=scalapack-2.1.0
+set mumps=mumps-5.4.1
+set aed2=libaed2-1.2.0
+set gotm=gotm-2019-06-14-opentelemac
+
+rem *********************************************************************************
+rem Parse input arguments to determine where and how the dependencies should be built
+rem *********************************************************************************
+
rem Check that the installation path was provided
-if "%~1" == "" (
+set install_path=%~1
+if "%install_path:~0,1%" == "/" set install_path=
+if "%install_path%" == "" (
echo The syntax is:
echo:
echo %~n0 installation_path [compiler]
@@ -12,30 +34,27 @@ if "%~1" == "" (
exit /b 0
)
-rem Create it if it does not exist
-if not exist "%~1" (
- mkdir "%~1" || exit /b 0
-)
-
-rem Local variables only
-setlocal
-
-rem Create the installation path
-set install_path=%~1
+rem Ensure that the installation path is absolute and create it
+set install_path=%~f1
mkdir %install_path% 2>nul
-rem Keep the installation path using forward slashes for CMake (they are mandatory because ScaLAPACK is using a bugged CMake module)
+rem Convert directory separators to forward slashes for CMake (they are mandatory because ScaLAPACK uses a bugged CMake module)
set install_path=%install_path:\=/%
+rem Set the compiler (default is mingw)
if "%~2" == "" (
set compiler=mingw
) else (
set compiler=%~2
)
-rem Store compiler name
+rem Store the compiler name with the first letter capitalized
for /f "tokens=2 delims=:" %%a in ('"find "" ":%compiler:~,1%" 2>&1"') do set compiler_name=%%a%compiler:~1%
-rem Check that Git is available
+rem ***********************************************************************
+rem Check that all prerequisites (Git, Cmake and Python 3.10) are available
+rem ***********************************************************************
+
+rem Check for the presence of Git
set git_path=
for /f "delims=" %%a in ('"where git 2>nul"') do set git_path=%%a
if not defined git_path (
@@ -43,7 +62,7 @@ if not defined git_path (
exit /b 0
)
-rem Check that CMake is available
+rem Check for the presence of CMake
set cmake_path=
for /f "delims=,tokens=*" %%a in ('"where cmake 2>nul"') do set cmake_path=%%a
if not defined cmake_path (
@@ -51,26 +70,23 @@ if not defined cmake_path (
exit /b 0
)
-rem ***************************
-rem * Set dependency versions *
-rem ***************************
-set hdf5=hdf5-1.10.9
-set med=med-4.1.1
-set metis=metis-5.1.0
-set msmpi=msmpi-10.1.2
-set openblas=openblas-0.3.21
-set scalapack=scalapack-2.1.0
-set mumps=mumps-5.4.1
-set aed2=libaed2-1.2.0
-set gotm=gotm-2019-06-14-opentelemac
-set python=python-3.7.9
-rem GDAL, Fiona and Rasterio Python packages cannot be installed using PyPI on Windows
-rem Also, the version of Shapely that comes through pip is unstable
-rem Instead, we need to use unofficial wheels from Christoph Gohlke’s website
-set gdal=GDAL-3.4.2-cp37-cp37m-win_amd64.whl
-set fiona=Fiona-1.8.21-cp37-cp37m-win_amd64.whl
-set rasterio=rasterio-1.2.10-cp37-cp37m-win_amd64.whl
-set shapely=Shapely-1.8.1.post1-cp37-cp37m-win_amd64.whl
+rem Check for the presence of the Python launcher
+set py_path=
+for /f "delims=,tokens=*" %%a in ('"where py 2>nul"') do set py_path=%%a
+if not defined py_path (
+ echo Error: Python launcher not found. Please install Python 3.10 with the launcher.
+ exit /b 0
+)
+rem Check for the presence of Python 3.10
+py -0 2>nul | findstr /I /B /C:" -3.10-64" > nul 2>&1
+if %errorlevel% == 1 (
+ echo Error: Python 3.10 not found. You need to install it using the official installer.
+ exit /b 0
+)
+
+rem **********************
+rem Build the dependencies
+rem **********************
pushd %~dp0deps
@@ -111,7 +127,7 @@ call :build_scalapack || goto exit
call :build_mumps || goto exit
call :build_aed2 || goto exit
call :build_gotm || goto exit
-call :install_python || goto exit
+call :install_python_packages || goto exit
goto exit
:intel_build
@@ -121,21 +137,22 @@ call :build_metis || goto exit
rem call :build_mumps || goto exit
rem call :build_aed2 || goto exit
rem call :buid_gotm || goto exit
+call :install_python_packages || goto exit
goto exit
+rem ****
+rem HDF5
+rem ****
:build_hdf5
-rem ********
-rem * HDF5 *
-rem ********
call :download %hdf5% "https://support.hdfgroup.org/ftp/HDF5/releases/hdf5-1.10/hdf5-1.10.9/src/hdf5-1.10.9.zip" || exit /b 1
set cmake_config_options=-DONLY_SHARED_LIBS:BOOL=ON -DHDF5_GENERATE_HEADERS:BOOL=OFF -DBUILD_TESTING:BOOL=OFF -DHDF5_BUILD_EXAMPLES:BOOL=OFF -DHDF5_BUILD_TOOLS:BOOL=OFF -DHDF5_BUILD_UTILS:BOOL=OFF -DHDF5_BUILD_HL_LIB:BOOL=OFF -DHDF5_BUILD_HL_TOOLS:BOOL=OFF
call :cmake_build %hdf5% || exit /b 1
exit /b 0
+rem ***
+rem MED
+rem ***
:build_med
-rem *******
-rem * MED *
-rem *******
call :download %med% "https://files.salome-platform.org/Salome/other/med-4.1.1.tar.gz" || exit /b 1
set cmake_config_options=-DHDF5_ROOT_DIR:PATH=%install_path%/%hdf5% -DMEDFILE_BUILD_TESTS:BOOL=OFF -DMEDFILE_INSTALL_DOC:BOOL=OFF
if %compiler% == intel (
@@ -146,19 +163,19 @@ if %compiler% == intel (
call :cmake_build %med% || exit /b 1
exit /b 0
+rem *****
+rem METIS
+rem *****
:build_metis
-rem *********
-rem * METIS *
-rem *********
call :download %metis% "https://github.com/scivision/METIS/archive/refs/tags/v5.1.0.3.tar.gz" || exit /b 1
set cmake_config_options=-DBUILD_SHARED_LIBS:BOOL=OFF
call :cmake_build %metis% || exit /b 1
exit /b 0
+rem ******
+rem MS-MPI
+rem ******
:build_msmpi
-rem **********
-rem * MS-MPI *
-rem **********
echo Building %msmpi% with %compiler_name% compiler...
set carch=x86_64
pushd %msmpi%
@@ -194,29 +211,29 @@ xcopy /e/y sdk\build-x86_64 %install_path:/=\%\%msmpi%\
popd
exit /b 0
+rem ********
+rem OpenBLAS
+rem ********
:build_openblas
-rem ************
-rem * OpenBLAS *
-rem ************
call :download %openblas% "https://github.com/xianyi/OpenBLAS/archive/refs/tags/v0.3.21.tar.gz" || exit /b 1
set cmake_config_options=
call :cmake_build %openblas% || exit /b 1
exit /b 0
+rem *********
+rem ScaLAPACK
+rem *********
:build_scalapack
-rem *************
-rem * ScaLAPACK *
-rem *************
call :download %scalapack% "https://github.com/Reference-ScaLAPACK/scalapack/archive/refs/tags/v2.1.0.zip" || exit /b 1
rem We need to use a foward slash for lapack and blas libraries paths since CMake CheckFortranFunctionExists is bugged when using a backward slash
set cmake_config_options=-DMPI_BASE_DIR:PATH=%install_path%/%msmpi% -DLAPACK_LIBRARIES:STRING=%install_path%/%openblas%/lib/libopenblas.a -DBLAS_LIBRARIES:STRING=%install_path%/%openblas%/lib/libopenblas.a -DBUILD_TESTING:BOOL=OFF
call :cmake_build %scalapack% || exit /b 1
exit /b 0
+rem *****
+rem MUMPS
+rem *****
:build_mumps
-rem *********
-rem * MUMPS *
-rem *********
call :download %mumps% "https://github.com/scivision/mumps/archive/refs/tags/v5.4.1.11.zip" || exit /b 1
set cmake_config_options=-DBLAS_LIBRARY=%install_path%/%openblas%/lib/libopenblas.a -DLAPACK_LIBRARY=%install_path%/%openblas%/lib/libopenblas.a -DSCALAPACK_ROOT:PATH=%install_path%/%scalapack%
if %compiler% == mingw (
@@ -235,10 +252,10 @@ if %compiler% == mingw (
call :cmake_build %mumps% || exit /b 1
exit /b 0
+rem ****
+rem AED2
+rem ****
:build_aed2
-rem ********
-rem * AED2 *
-rem ********
call :download %aed2% "http://www.opentelemac.org/index.php/component/jdownloads/finish/39-manual-installation-sources/2126-aed2m/0?Itemid=55" || exit /b 1
echo Building libaed2 with %compiler_name% compiler...
set install_dir=%install_path:/=\%\%aed2%
@@ -256,50 +273,43 @@ exit /b 0
popd
exit /b 1
+rem ****
+rem GOTM
+rem ****
:build_gotm
-rem ********
-rem * GOTM *
-rem ********
call :download %gotm% "http://www.opentelemac.org/index.php/component/jdownloads/finish/39-manual-installation-sources/2127-gotm/0?Itemid=54" || exit /b 1
set cmake_config_options=-DBUILD_SHARED_LIBS:BOOL=ON -DGOTM_USE_NetCDF=OFF
call :cmake_build %gotm% || exit /b 1
exit /b 0
-:install_python
-if exist %install_path%\%python% (
- exit /b 0
-)
-
-pushd %install_path:/=\%
-
-echo Downloading and extracting %python%...
-curl -L https://www.python.org/ftp/python/3.7.9/python-3.7.9-embed-amd64.zip -o python.zip || goto install_error
-mkdir %python%
-tar -xvzf python.zip -C %python% || goto install_error
-del python.zip
-rem Remove the _pth file
-del %python%\python3*._pth
-
-rem Install Python SDK to be able to use f2py
-xcopy /e/y %~dp0pythonsdk\include %cd%\%python%\include\
-xcopy /e/y %~dp0pythonsdk\libs %cd%\%python%\libs\
-
-rem Download and install pip
-curl -O -J https://bootstrap.pypa.io/get-pip.py || goto install_error
-set path=%cd%\%python%\Scripts;%cd%\%python%;%path%
-python get-pip.py
-del get-pip.py
-
+rem ***************
+rem Python packages
+rem ***************
+:install_python_packages
rem Install all Python requirements for TELEMAC-MASCARET
echo Installing Python requirements...
-pip install -r %~dp0requirements.txt || goto install_error
+rem Create a virtual environment
+set python_dir=%install_path:/=\%\python
+rd /s/q %python_dir% 2>nul
+py -3.10 -m venv %python_dir% --prompt telemac
+rem Copy python310.dll to the virtual environment (required by F2PY)
+pushd %python_dir%
+py -3.10 -c "import os, sys, shutil; shutil.copy2(f'{os.path.dirname(sys.executable)}\\python310.dll', f'{os.getcwd()}\\Scripts')"
+rem Mingw also requires a definition file for F2PY in a "libs" subdirectory
+if %compiler% == mingw (
+ mkdir libs
+ pushd libs
+ py -3.10 -c "import os, sys; os.system(f'gendef {os.path.dirname(sys.executable)}\python310.dll')"
+ popd
+)
+popd
+rem Activate the virtual environment and install all Python requirements
+call %python_dir%\Scripts\activate.bat
+pushd %~dp0
+pip install -r python_requirements.txt || goto install_error
-rem Use GDAL, Fiona, Rasterio and Shapely unofficial wheels, to avoid building them locally
-pip install %~dp0wheels\%gdal%
-pip install %~dp0wheels\%fiona%
-pip install %~dp0wheels\%rasterio%
-pip install %~dp0wheels\%shapely%
-pip install geopandas
+rem Starting with Python 3.8, mpi4py requires MPI DLLs to be present in the module directory: copy them there
+xcopy /y %install_path:/=\%\%msmpi%\bin\msmpi*.dll %python_dir%\Lib\site-packages\mpi4py\ >nul
popd
exit /b 0
@@ -308,10 +318,10 @@ exit /b 0
popd
exit /b 1
+rem **************************************
+rem Download a library if not already done
+rem **************************************
:download
-rem ******************************************
-rem * Download a library if not already done *
-rem ******************************************
set lib=%~1
set url="%~2"
@@ -336,10 +346,10 @@ if exist %~dp0patches\%lib%.patch (
exit /b 0
+rem ********************
+rem CMake build function
+rem ********************
:cmake_build
-rem ************************
-rem * CMake build function *
-rem ************************
set lib=%~1
rem Set the number of build processes
diff --git a/config/pysource.win.bat b/config/pysource.win.bat
index 0b3a0550490b5698dd9e70c1183e82003ae7e2be..5715abd55c8ab8323e963feee035196c09de73ab 100644
--- a/config/pysource.win.bat
+++ b/config/pysource.win.bat
@@ -14,17 +14,9 @@ set SYSTELCFG=%HOMETEL%\configs\systel.edf.cfg
rem Name of the configuration to use
set USETELCFG=win
-rem Add Python to PATH, its modules to PYTHONPATH and set it as the
-rem default one to launch Python scripts from the command line
-setlocal enabledelayedexpansion
-set python=python-3.7.9
-endlocal & (
- set "PATH=%TELEMACDEPS%\%python%;%TELEMACDEPS%\%python%\Scripts;%PATH%"
- set "PYTHONPATH=%TELEMACDEPS%\%python%\Lib\site-packages"
- reg add HKCU\SOFTWARE\Classes\Python.File\shell\open\command /f /ve /d "\"%TELEMACDEPS%\%python%\python.exe\" \"%%1\" %%*" 1>nul
- reg delete HKCU\SOFTWARE\Classes\.py\OpenWithProgids /f >nul 2>&1
- reg add HKCU\SOFTWARE\Classes\.py\OpenWithProgids /f /v Python.File 1>nul
-)
+rem Activate TELEMAC Python environment and set it as the default
+rem one to launch Python scripts from the command line
+call %TELEMACDEPS%\python\Scripts\activate.bat
rem Add Mingw to PATH if it is found
call :find_mingw
@@ -37,7 +29,7 @@ set PYTHONPATH=%HOMETEL%\scripts\python3;%PYTHONPATH%
set PYTHONPATH=%HOMETEL%\builds\%USETELCFG%\wrap_api\lib;%PYTHONPATH%
rem External libraries versions
-rem HDF
+rem HDF5
set HDF5HOME=%TELEMACDEPS%\hdf5-1.10.9
set PATH=%HDF5HOME%\bin;%PATH%
rem MED
diff --git a/config/pysource.win.debug.bat b/config/pysource.win.debug.bat
index 28988e3bfe30d702caa0fb1601d8ae3b28e33249..af67ffe77f3e44590320e26e8c3d681a725b8a71 100644
--- a/config/pysource.win.debug.bat
+++ b/config/pysource.win.debug.bat
@@ -14,17 +14,9 @@ set SYSTELCFG=%HOMETEL%\configs\systel.edf.cfg
rem Name of the configuration to use
set USETELCFG=win.debug
-rem Add Python to PATH, its modules to PYTHONPATH and set it as the
-rem default one to launch Python scripts from the command line
-setlocal enabledelayedexpansion
-set python=python-3.7.9
-endlocal & (
- set "PATH=%TELEMACDEPS%\%python%;%TELEMACDEPS%\%python%\Scripts;%PATH%"
- set "PYTHONPATH=%TELEMACDEPS%\%python%\Lib\site-packages"
- reg add HKCU\SOFTWARE\Classes\Python.File\shell\open\command /f /ve /d "\"%TELEMACDEPS%\%python%\python.exe\" \"%%1\" %%*" 1>nul
- reg delete HKCU\SOFTWARE\Classes\.py\OpenWithProgids /f >nul 2>&1
- reg add HKCU\SOFTWARE\Classes\.py\OpenWithProgids /f /v Python.File 1>nul
-)
+rem Activate TELEMAC Python environment and set it as the default
+rem one to launch Python scripts from the command line
+call %TELEMACDEPS%\python\Scripts\activate.bat
rem Add Mingw to PATH if it is found
call :find_mingw
@@ -37,7 +29,7 @@ set PYTHONPATH=%HOMETEL%\scripts\python3;%PYTHONPATH%
set PYTHONPATH=%HOMETEL%\builds\%USETELCFG%\wrap_api\lib;%PYTHONPATH%
rem External libraries versions
-rem HDF
+rem HDF5
set HDF5HOME=%TELEMACDEPS%\hdf5-1.10.9
set PATH=%HDF5HOME%\bin;%PATH%
rem MED
diff --git a/python_requirements.txt b/python_requirements.txt
new file mode 100644
index 0000000000000000000000000000000000000000..18e3c75b72295809da50b029e8656fd9884261f9
--- /dev/null
+++ b/python_requirements.txt
@@ -0,0 +1,19 @@
+numpy
+scipy
+matplotlib
+mpi4py
+doxypypy
+jupyter
+openpyxl
+OWSLib
+pandas
+pyproj
+seaborn
+# GDAL, Fiona and Rasterio Python packages cannot be installed using PyPI on Windows
+# Also, the version of Shapely that comes through pip is unstable
+# Instead, we need to use unofficial wheels from Christoph Gohlke’s website
+.\wheels\GDAL-3.4.3-cp310-cp310-win_amd64.whl
+.\wheels\Fiona-1.8.21-cp310-cp310-win_amd64.whl
+.\wheels\rasterio-1.2.10-cp310-cp310-win_amd64.whl
+.\wheels\Shapely-1.8.2-cp310-cp310-win_amd64.whl
+geopandas
\ No newline at end of file
diff --git a/pythonsdk/include/Python-ast.h b/pythonsdk/include/Python-ast.h
deleted file mode 100644
index 7e6494ef870ba83b1cec05447e4e43842d36b606..0000000000000000000000000000000000000000
--- a/pythonsdk/include/Python-ast.h
+++ /dev/null
@@ -1,637 +0,0 @@
-/* File automatically generated by Parser/asdl_c.py. */
-
-#include "asdl.h"
-
-typedef struct _mod *mod_ty;
-
-typedef struct _stmt *stmt_ty;
-
-typedef struct _expr *expr_ty;
-
-typedef enum _expr_context { Load=1, Store=2, Del=3, AugLoad=4, AugStore=5,
- Param=6 } expr_context_ty;
-
-typedef struct _slice *slice_ty;
-
-typedef enum _boolop { And=1, Or=2 } boolop_ty;
-
-typedef enum _operator { Add=1, Sub=2, Mult=3, MatMult=4, Div=5, Mod=6, Pow=7,
- LShift=8, RShift=9, BitOr=10, BitXor=11, BitAnd=12,
- FloorDiv=13 } operator_ty;
-
-typedef enum _unaryop { Invert=1, Not=2, UAdd=3, USub=4 } unaryop_ty;
-
-typedef enum _cmpop { Eq=1, NotEq=2, Lt=3, LtE=4, Gt=5, GtE=6, Is=7, IsNot=8,
- In=9, NotIn=10 } cmpop_ty;
-
-typedef struct _comprehension *comprehension_ty;
-
-typedef struct _excepthandler *excepthandler_ty;
-
-typedef struct _arguments *arguments_ty;
-
-typedef struct _arg *arg_ty;
-
-typedef struct _keyword *keyword_ty;
-
-typedef struct _alias *alias_ty;
-
-typedef struct _withitem *withitem_ty;
-
-
-enum _mod_kind {Module_kind=1, Interactive_kind=2, Expression_kind=3,
- Suite_kind=4};
-struct _mod {
- enum _mod_kind kind;
- union {
- struct {
- asdl_seq *body;
- } Module;
-
- struct {
- asdl_seq *body;
- } Interactive;
-
- struct {
- expr_ty body;
- } Expression;
-
- struct {
- asdl_seq *body;
- } Suite;
-
- } v;
-};
-
-enum _stmt_kind {FunctionDef_kind=1, AsyncFunctionDef_kind=2, ClassDef_kind=3,
- Return_kind=4, Delete_kind=5, Assign_kind=6,
- AugAssign_kind=7, AnnAssign_kind=8, For_kind=9,
- AsyncFor_kind=10, While_kind=11, If_kind=12, With_kind=13,
- AsyncWith_kind=14, Raise_kind=15, Try_kind=16,
- Assert_kind=17, Import_kind=18, ImportFrom_kind=19,
- Global_kind=20, Nonlocal_kind=21, Expr_kind=22, Pass_kind=23,
- Break_kind=24, Continue_kind=25};
-struct _stmt {
- enum _stmt_kind kind;
- union {
- struct {
- identifier name;
- arguments_ty args;
- asdl_seq *body;
- asdl_seq *decorator_list;
- expr_ty returns;
- } FunctionDef;
-
- struct {
- identifier name;
- arguments_ty args;
- asdl_seq *body;
- asdl_seq *decorator_list;
- expr_ty returns;
- } AsyncFunctionDef;
-
- struct {
- identifier name;
- asdl_seq *bases;
- asdl_seq *keywords;
- asdl_seq *body;
- asdl_seq *decorator_list;
- } ClassDef;
-
- struct {
- expr_ty value;
- } Return;
-
- struct {
- asdl_seq *targets;
- } Delete;
-
- struct {
- asdl_seq *targets;
- expr_ty value;
- } Assign;
-
- struct {
- expr_ty target;
- operator_ty op;
- expr_ty value;
- } AugAssign;
-
- struct {
- expr_ty target;
- expr_ty annotation;
- expr_ty value;
- int simple;
- } AnnAssign;
-
- struct {
- expr_ty target;
- expr_ty iter;
- asdl_seq *body;
- asdl_seq *orelse;
- } For;
-
- struct {
- expr_ty target;
- expr_ty iter;
- asdl_seq *body;
- asdl_seq *orelse;
- } AsyncFor;
-
- struct {
- expr_ty test;
- asdl_seq *body;
- asdl_seq *orelse;
- } While;
-
- struct {
- expr_ty test;
- asdl_seq *body;
- asdl_seq *orelse;
- } If;
-
- struct {
- asdl_seq *items;
- asdl_seq *body;
- } With;
-
- struct {
- asdl_seq *items;
- asdl_seq *body;
- } AsyncWith;
-
- struct {
- expr_ty exc;
- expr_ty cause;
- } Raise;
-
- struct {
- asdl_seq *body;
- asdl_seq *handlers;
- asdl_seq *orelse;
- asdl_seq *finalbody;
- } Try;
-
- struct {
- expr_ty test;
- expr_ty msg;
- } Assert;
-
- struct {
- asdl_seq *names;
- } Import;
-
- struct {
- identifier module;
- asdl_seq *names;
- int level;
- } ImportFrom;
-
- struct {
- asdl_seq *names;
- } Global;
-
- struct {
- asdl_seq *names;
- } Nonlocal;
-
- struct {
- expr_ty value;
- } Expr;
-
- } v;
- int lineno;
- int col_offset;
-};
-
-enum _expr_kind {BoolOp_kind=1, BinOp_kind=2, UnaryOp_kind=3, Lambda_kind=4,
- IfExp_kind=5, Dict_kind=6, Set_kind=7, ListComp_kind=8,
- SetComp_kind=9, DictComp_kind=10, GeneratorExp_kind=11,
- Await_kind=12, Yield_kind=13, YieldFrom_kind=14,
- Compare_kind=15, Call_kind=16, Num_kind=17, Str_kind=18,
- FormattedValue_kind=19, JoinedStr_kind=20, Bytes_kind=21,
- NameConstant_kind=22, Ellipsis_kind=23, Constant_kind=24,
- Attribute_kind=25, Subscript_kind=26, Starred_kind=27,
- Name_kind=28, List_kind=29, Tuple_kind=30};
-struct _expr {
- enum _expr_kind kind;
- union {
- struct {
- boolop_ty op;
- asdl_seq *values;
- } BoolOp;
-
- struct {
- expr_ty left;
- operator_ty op;
- expr_ty right;
- } BinOp;
-
- struct {
- unaryop_ty op;
- expr_ty operand;
- } UnaryOp;
-
- struct {
- arguments_ty args;
- expr_ty body;
- } Lambda;
-
- struct {
- expr_ty test;
- expr_ty body;
- expr_ty orelse;
- } IfExp;
-
- struct {
- asdl_seq *keys;
- asdl_seq *values;
- } Dict;
-
- struct {
- asdl_seq *elts;
- } Set;
-
- struct {
- expr_ty elt;
- asdl_seq *generators;
- } ListComp;
-
- struct {
- expr_ty elt;
- asdl_seq *generators;
- } SetComp;
-
- struct {
- expr_ty key;
- expr_ty value;
- asdl_seq *generators;
- } DictComp;
-
- struct {
- expr_ty elt;
- asdl_seq *generators;
- } GeneratorExp;
-
- struct {
- expr_ty value;
- } Await;
-
- struct {
- expr_ty value;
- } Yield;
-
- struct {
- expr_ty value;
- } YieldFrom;
-
- struct {
- expr_ty left;
- asdl_int_seq *ops;
- asdl_seq *comparators;
- } Compare;
-
- struct {
- expr_ty func;
- asdl_seq *args;
- asdl_seq *keywords;
- } Call;
-
- struct {
- object n;
- } Num;
-
- struct {
- string s;
- } Str;
-
- struct {
- expr_ty value;
- int conversion;
- expr_ty format_spec;
- } FormattedValue;
-
- struct {
- asdl_seq *values;
- } JoinedStr;
-
- struct {
- bytes s;
- } Bytes;
-
- struct {
- singleton value;
- } NameConstant;
-
- struct {
- constant value;
- } Constant;
-
- struct {
- expr_ty value;
- identifier attr;
- expr_context_ty ctx;
- } Attribute;
-
- struct {
- expr_ty value;
- slice_ty slice;
- expr_context_ty ctx;
- } Subscript;
-
- struct {
- expr_ty value;
- expr_context_ty ctx;
- } Starred;
-
- struct {
- identifier id;
- expr_context_ty ctx;
- } Name;
-
- struct {
- asdl_seq *elts;
- expr_context_ty ctx;
- } List;
-
- struct {
- asdl_seq *elts;
- expr_context_ty ctx;
- } Tuple;
-
- } v;
- int lineno;
- int col_offset;
-};
-
-enum _slice_kind {Slice_kind=1, ExtSlice_kind=2, Index_kind=3};
-struct _slice {
- enum _slice_kind kind;
- union {
- struct {
- expr_ty lower;
- expr_ty upper;
- expr_ty step;
- } Slice;
-
- struct {
- asdl_seq *dims;
- } ExtSlice;
-
- struct {
- expr_ty value;
- } Index;
-
- } v;
-};
-
-struct _comprehension {
- expr_ty target;
- expr_ty iter;
- asdl_seq *ifs;
- int is_async;
-};
-
-enum _excepthandler_kind {ExceptHandler_kind=1};
-struct _excepthandler {
- enum _excepthandler_kind kind;
- union {
- struct {
- expr_ty type;
- identifier name;
- asdl_seq *body;
- } ExceptHandler;
-
- } v;
- int lineno;
- int col_offset;
-};
-
-struct _arguments {
- asdl_seq *args;
- arg_ty vararg;
- asdl_seq *kwonlyargs;
- asdl_seq *kw_defaults;
- arg_ty kwarg;
- asdl_seq *defaults;
-};
-
-struct _arg {
- identifier arg;
- expr_ty annotation;
- int lineno;
- int col_offset;
-};
-
-struct _keyword {
- identifier arg;
- expr_ty value;
-};
-
-struct _alias {
- identifier name;
- identifier asname;
-};
-
-struct _withitem {
- expr_ty context_expr;
- expr_ty optional_vars;
-};
-
-
-#define Module(a0, a1) _Py_Module(a0, a1)
-mod_ty _Py_Module(asdl_seq * body, PyArena *arena);
-#define Interactive(a0, a1) _Py_Interactive(a0, a1)
-mod_ty _Py_Interactive(asdl_seq * body, PyArena *arena);
-#define Expression(a0, a1) _Py_Expression(a0, a1)
-mod_ty _Py_Expression(expr_ty body, PyArena *arena);
-#define Suite(a0, a1) _Py_Suite(a0, a1)
-mod_ty _Py_Suite(asdl_seq * body, PyArena *arena);
-#define FunctionDef(a0, a1, a2, a3, a4, a5, a6, a7) _Py_FunctionDef(a0, a1, a2, a3, a4, a5, a6, a7)
-stmt_ty _Py_FunctionDef(identifier name, arguments_ty args, asdl_seq * body,
- asdl_seq * decorator_list, expr_ty returns, int lineno,
- int col_offset, PyArena *arena);
-#define AsyncFunctionDef(a0, a1, a2, a3, a4, a5, a6, a7) _Py_AsyncFunctionDef(a0, a1, a2, a3, a4, a5, a6, a7)
-stmt_ty _Py_AsyncFunctionDef(identifier name, arguments_ty args, asdl_seq *
- body, asdl_seq * decorator_list, expr_ty returns,
- int lineno, int col_offset, PyArena *arena);
-#define ClassDef(a0, a1, a2, a3, a4, a5, a6, a7) _Py_ClassDef(a0, a1, a2, a3, a4, a5, a6, a7)
-stmt_ty _Py_ClassDef(identifier name, asdl_seq * bases, asdl_seq * keywords,
- asdl_seq * body, asdl_seq * decorator_list, int lineno,
- int col_offset, PyArena *arena);
-#define Return(a0, a1, a2, a3) _Py_Return(a0, a1, a2, a3)
-stmt_ty _Py_Return(expr_ty value, int lineno, int col_offset, PyArena *arena);
-#define Delete(a0, a1, a2, a3) _Py_Delete(a0, a1, a2, a3)
-stmt_ty _Py_Delete(asdl_seq * targets, int lineno, int col_offset, PyArena
- *arena);
-#define Assign(a0, a1, a2, a3, a4) _Py_Assign(a0, a1, a2, a3, a4)
-stmt_ty _Py_Assign(asdl_seq * targets, expr_ty value, int lineno, int
- col_offset, PyArena *arena);
-#define AugAssign(a0, a1, a2, a3, a4, a5) _Py_AugAssign(a0, a1, a2, a3, a4, a5)
-stmt_ty _Py_AugAssign(expr_ty target, operator_ty op, expr_ty value, int
- lineno, int col_offset, PyArena *arena);
-#define AnnAssign(a0, a1, a2, a3, a4, a5, a6) _Py_AnnAssign(a0, a1, a2, a3, a4, a5, a6)
-stmt_ty _Py_AnnAssign(expr_ty target, expr_ty annotation, expr_ty value, int
- simple, int lineno, int col_offset, PyArena *arena);
-#define For(a0, a1, a2, a3, a4, a5, a6) _Py_For(a0, a1, a2, a3, a4, a5, a6)
-stmt_ty _Py_For(expr_ty target, expr_ty iter, asdl_seq * body, asdl_seq *
- orelse, int lineno, int col_offset, PyArena *arena);
-#define AsyncFor(a0, a1, a2, a3, a4, a5, a6) _Py_AsyncFor(a0, a1, a2, a3, a4, a5, a6)
-stmt_ty _Py_AsyncFor(expr_ty target, expr_ty iter, asdl_seq * body, asdl_seq *
- orelse, int lineno, int col_offset, PyArena *arena);
-#define While(a0, a1, a2, a3, a4, a5) _Py_While(a0, a1, a2, a3, a4, a5)
-stmt_ty _Py_While(expr_ty test, asdl_seq * body, asdl_seq * orelse, int lineno,
- int col_offset, PyArena *arena);
-#define If(a0, a1, a2, a3, a4, a5) _Py_If(a0, a1, a2, a3, a4, a5)
-stmt_ty _Py_If(expr_ty test, asdl_seq * body, asdl_seq * orelse, int lineno,
- int col_offset, PyArena *arena);
-#define With(a0, a1, a2, a3, a4) _Py_With(a0, a1, a2, a3, a4)
-stmt_ty _Py_With(asdl_seq * items, asdl_seq * body, int lineno, int col_offset,
- PyArena *arena);
-#define AsyncWith(a0, a1, a2, a3, a4) _Py_AsyncWith(a0, a1, a2, a3, a4)
-stmt_ty _Py_AsyncWith(asdl_seq * items, asdl_seq * body, int lineno, int
- col_offset, PyArena *arena);
-#define Raise(a0, a1, a2, a3, a4) _Py_Raise(a0, a1, a2, a3, a4)
-stmt_ty _Py_Raise(expr_ty exc, expr_ty cause, int lineno, int col_offset,
- PyArena *arena);
-#define Try(a0, a1, a2, a3, a4, a5, a6) _Py_Try(a0, a1, a2, a3, a4, a5, a6)
-stmt_ty _Py_Try(asdl_seq * body, asdl_seq * handlers, asdl_seq * orelse,
- asdl_seq * finalbody, int lineno, int col_offset, PyArena
- *arena);
-#define Assert(a0, a1, a2, a3, a4) _Py_Assert(a0, a1, a2, a3, a4)
-stmt_ty _Py_Assert(expr_ty test, expr_ty msg, int lineno, int col_offset,
- PyArena *arena);
-#define Import(a0, a1, a2, a3) _Py_Import(a0, a1, a2, a3)
-stmt_ty _Py_Import(asdl_seq * names, int lineno, int col_offset, PyArena
- *arena);
-#define ImportFrom(a0, a1, a2, a3, a4, a5) _Py_ImportFrom(a0, a1, a2, a3, a4, a5)
-stmt_ty _Py_ImportFrom(identifier module, asdl_seq * names, int level, int
- lineno, int col_offset, PyArena *arena);
-#define Global(a0, a1, a2, a3) _Py_Global(a0, a1, a2, a3)
-stmt_ty _Py_Global(asdl_seq * names, int lineno, int col_offset, PyArena
- *arena);
-#define Nonlocal(a0, a1, a2, a3) _Py_Nonlocal(a0, a1, a2, a3)
-stmt_ty _Py_Nonlocal(asdl_seq * names, int lineno, int col_offset, PyArena
- *arena);
-#define Expr(a0, a1, a2, a3) _Py_Expr(a0, a1, a2, a3)
-stmt_ty _Py_Expr(expr_ty value, int lineno, int col_offset, PyArena *arena);
-#define Pass(a0, a1, a2) _Py_Pass(a0, a1, a2)
-stmt_ty _Py_Pass(int lineno, int col_offset, PyArena *arena);
-#define Break(a0, a1, a2) _Py_Break(a0, a1, a2)
-stmt_ty _Py_Break(int lineno, int col_offset, PyArena *arena);
-#define Continue(a0, a1, a2) _Py_Continue(a0, a1, a2)
-stmt_ty _Py_Continue(int lineno, int col_offset, PyArena *arena);
-#define BoolOp(a0, a1, a2, a3, a4) _Py_BoolOp(a0, a1, a2, a3, a4)
-expr_ty _Py_BoolOp(boolop_ty op, asdl_seq * values, int lineno, int col_offset,
- PyArena *arena);
-#define BinOp(a0, a1, a2, a3, a4, a5) _Py_BinOp(a0, a1, a2, a3, a4, a5)
-expr_ty _Py_BinOp(expr_ty left, operator_ty op, expr_ty right, int lineno, int
- col_offset, PyArena *arena);
-#define UnaryOp(a0, a1, a2, a3, a4) _Py_UnaryOp(a0, a1, a2, a3, a4)
-expr_ty _Py_UnaryOp(unaryop_ty op, expr_ty operand, int lineno, int col_offset,
- PyArena *arena);
-#define Lambda(a0, a1, a2, a3, a4) _Py_Lambda(a0, a1, a2, a3, a4)
-expr_ty _Py_Lambda(arguments_ty args, expr_ty body, int lineno, int col_offset,
- PyArena *arena);
-#define IfExp(a0, a1, a2, a3, a4, a5) _Py_IfExp(a0, a1, a2, a3, a4, a5)
-expr_ty _Py_IfExp(expr_ty test, expr_ty body, expr_ty orelse, int lineno, int
- col_offset, PyArena *arena);
-#define Dict(a0, a1, a2, a3, a4) _Py_Dict(a0, a1, a2, a3, a4)
-expr_ty _Py_Dict(asdl_seq * keys, asdl_seq * values, int lineno, int
- col_offset, PyArena *arena);
-#define Set(a0, a1, a2, a3) _Py_Set(a0, a1, a2, a3)
-expr_ty _Py_Set(asdl_seq * elts, int lineno, int col_offset, PyArena *arena);
-#define ListComp(a0, a1, a2, a3, a4) _Py_ListComp(a0, a1, a2, a3, a4)
-expr_ty _Py_ListComp(expr_ty elt, asdl_seq * generators, int lineno, int
- col_offset, PyArena *arena);
-#define SetComp(a0, a1, a2, a3, a4) _Py_SetComp(a0, a1, a2, a3, a4)
-expr_ty _Py_SetComp(expr_ty elt, asdl_seq * generators, int lineno, int
- col_offset, PyArena *arena);
-#define DictComp(a0, a1, a2, a3, a4, a5) _Py_DictComp(a0, a1, a2, a3, a4, a5)
-expr_ty _Py_DictComp(expr_ty key, expr_ty value, asdl_seq * generators, int
- lineno, int col_offset, PyArena *arena);
-#define GeneratorExp(a0, a1, a2, a3, a4) _Py_GeneratorExp(a0, a1, a2, a3, a4)
-expr_ty _Py_GeneratorExp(expr_ty elt, asdl_seq * generators, int lineno, int
- col_offset, PyArena *arena);
-#define Await(a0, a1, a2, a3) _Py_Await(a0, a1, a2, a3)
-expr_ty _Py_Await(expr_ty value, int lineno, int col_offset, PyArena *arena);
-#define Yield(a0, a1, a2, a3) _Py_Yield(a0, a1, a2, a3)
-expr_ty _Py_Yield(expr_ty value, int lineno, int col_offset, PyArena *arena);
-#define YieldFrom(a0, a1, a2, a3) _Py_YieldFrom(a0, a1, a2, a3)
-expr_ty _Py_YieldFrom(expr_ty value, int lineno, int col_offset, PyArena
- *arena);
-#define Compare(a0, a1, a2, a3, a4, a5) _Py_Compare(a0, a1, a2, a3, a4, a5)
-expr_ty _Py_Compare(expr_ty left, asdl_int_seq * ops, asdl_seq * comparators,
- int lineno, int col_offset, PyArena *arena);
-#define Call(a0, a1, a2, a3, a4, a5) _Py_Call(a0, a1, a2, a3, a4, a5)
-expr_ty _Py_Call(expr_ty func, asdl_seq * args, asdl_seq * keywords, int
- lineno, int col_offset, PyArena *arena);
-#define Num(a0, a1, a2, a3) _Py_Num(a0, a1, a2, a3)
-expr_ty _Py_Num(object n, int lineno, int col_offset, PyArena *arena);
-#define Str(a0, a1, a2, a3) _Py_Str(a0, a1, a2, a3)
-expr_ty _Py_Str(string s, int lineno, int col_offset, PyArena *arena);
-#define FormattedValue(a0, a1, a2, a3, a4, a5) _Py_FormattedValue(a0, a1, a2, a3, a4, a5)
-expr_ty _Py_FormattedValue(expr_ty value, int conversion, expr_ty format_spec,
- int lineno, int col_offset, PyArena *arena);
-#define JoinedStr(a0, a1, a2, a3) _Py_JoinedStr(a0, a1, a2, a3)
-expr_ty _Py_JoinedStr(asdl_seq * values, int lineno, int col_offset, PyArena
- *arena);
-#define Bytes(a0, a1, a2, a3) _Py_Bytes(a0, a1, a2, a3)
-expr_ty _Py_Bytes(bytes s, int lineno, int col_offset, PyArena *arena);
-#define NameConstant(a0, a1, a2, a3) _Py_NameConstant(a0, a1, a2, a3)
-expr_ty _Py_NameConstant(singleton value, int lineno, int col_offset, PyArena
- *arena);
-#define Ellipsis(a0, a1, a2) _Py_Ellipsis(a0, a1, a2)
-expr_ty _Py_Ellipsis(int lineno, int col_offset, PyArena *arena);
-#define Constant(a0, a1, a2, a3) _Py_Constant(a0, a1, a2, a3)
-expr_ty _Py_Constant(constant value, int lineno, int col_offset, PyArena
- *arena);
-#define Attribute(a0, a1, a2, a3, a4, a5) _Py_Attribute(a0, a1, a2, a3, a4, a5)
-expr_ty _Py_Attribute(expr_ty value, identifier attr, expr_context_ty ctx, int
- lineno, int col_offset, PyArena *arena);
-#define Subscript(a0, a1, a2, a3, a4, a5) _Py_Subscript(a0, a1, a2, a3, a4, a5)
-expr_ty _Py_Subscript(expr_ty value, slice_ty slice, expr_context_ty ctx, int
- lineno, int col_offset, PyArena *arena);
-#define Starred(a0, a1, a2, a3, a4) _Py_Starred(a0, a1, a2, a3, a4)
-expr_ty _Py_Starred(expr_ty value, expr_context_ty ctx, int lineno, int
- col_offset, PyArena *arena);
-#define Name(a0, a1, a2, a3, a4) _Py_Name(a0, a1, a2, a3, a4)
-expr_ty _Py_Name(identifier id, expr_context_ty ctx, int lineno, int
- col_offset, PyArena *arena);
-#define List(a0, a1, a2, a3, a4) _Py_List(a0, a1, a2, a3, a4)
-expr_ty _Py_List(asdl_seq * elts, expr_context_ty ctx, int lineno, int
- col_offset, PyArena *arena);
-#define Tuple(a0, a1, a2, a3, a4) _Py_Tuple(a0, a1, a2, a3, a4)
-expr_ty _Py_Tuple(asdl_seq * elts, expr_context_ty ctx, int lineno, int
- col_offset, PyArena *arena);
-#define Slice(a0, a1, a2, a3) _Py_Slice(a0, a1, a2, a3)
-slice_ty _Py_Slice(expr_ty lower, expr_ty upper, expr_ty step, PyArena *arena);
-#define ExtSlice(a0, a1) _Py_ExtSlice(a0, a1)
-slice_ty _Py_ExtSlice(asdl_seq * dims, PyArena *arena);
-#define Index(a0, a1) _Py_Index(a0, a1)
-slice_ty _Py_Index(expr_ty value, PyArena *arena);
-#define comprehension(a0, a1, a2, a3, a4) _Py_comprehension(a0, a1, a2, a3, a4)
-comprehension_ty _Py_comprehension(expr_ty target, expr_ty iter, asdl_seq *
- ifs, int is_async, PyArena *arena);
-#define ExceptHandler(a0, a1, a2, a3, a4, a5) _Py_ExceptHandler(a0, a1, a2, a3, a4, a5)
-excepthandler_ty _Py_ExceptHandler(expr_ty type, identifier name, asdl_seq *
- body, int lineno, int col_offset, PyArena
- *arena);
-#define arguments(a0, a1, a2, a3, a4, a5, a6) _Py_arguments(a0, a1, a2, a3, a4, a5, a6)
-arguments_ty _Py_arguments(asdl_seq * args, arg_ty vararg, asdl_seq *
- kwonlyargs, asdl_seq * kw_defaults, arg_ty kwarg,
- asdl_seq * defaults, PyArena *arena);
-#define arg(a0, a1, a2, a3, a4) _Py_arg(a0, a1, a2, a3, a4)
-arg_ty _Py_arg(identifier arg, expr_ty annotation, int lineno, int col_offset,
- PyArena *arena);
-#define keyword(a0, a1, a2) _Py_keyword(a0, a1, a2)
-keyword_ty _Py_keyword(identifier arg, expr_ty value, PyArena *arena);
-#define alias(a0, a1, a2) _Py_alias(a0, a1, a2)
-alias_ty _Py_alias(identifier name, identifier asname, PyArena *arena);
-#define withitem(a0, a1, a2) _Py_withitem(a0, a1, a2)
-withitem_ty _Py_withitem(expr_ty context_expr, expr_ty optional_vars, PyArena
- *arena);
-
-PyObject* PyAST_mod2obj(mod_ty t);
-mod_ty PyAST_obj2mod(PyObject* ast, PyArena* arena, int mode);
-int PyAST_Check(PyObject* obj);
diff --git a/pythonsdk/include/Python.h b/pythonsdk/include/Python.h
deleted file mode 100644
index b68de5fd9ea2ab2841c5a5f7f2561fe7a7894d05..0000000000000000000000000000000000000000
--- a/pythonsdk/include/Python.h
+++ /dev/null
@@ -1,159 +0,0 @@
-#ifndef Py_PYTHON_H
-#define Py_PYTHON_H
-/* Since this is a "meta-include" file, no #ifdef __cplusplus / extern "C" { */
-
-/* Include nearly all Python header files */
-
-#include "patchlevel.h"
-#include "pyconfig.h"
-#include "pymacconfig.h"
-
-#include <limits.h>
-
-#ifndef UCHAR_MAX
-#error "Something's broken. UCHAR_MAX should be defined in limits.h."
-#endif
-
-#if UCHAR_MAX != 255
-#error "Python's source code assumes C's unsigned char is an 8-bit type."
-#endif
-
-#if defined(__sgi) && !defined(_SGI_MP_SOURCE)
-#define _SGI_MP_SOURCE
-#endif
-
-#include <stdio.h>
-#ifndef NULL
-# error "Python.h requires that stdio.h define NULL."
-#endif
-
-#include <string.h>
-#ifdef HAVE_ERRNO_H
-#include <errno.h>
-#endif
-#include <stdlib.h>
-#ifdef HAVE_UNISTD_H
-#include <unistd.h>
-#endif
-#ifdef HAVE_CRYPT_H
-#if defined(HAVE_CRYPT_R) && !defined(_GNU_SOURCE)
-/* Required for glibc to expose the crypt_r() function prototype. */
-# define _GNU_SOURCE
-# define _Py_GNU_SOURCE_FOR_CRYPT
-#endif
-#include <crypt.h>
-#ifdef _Py_GNU_SOURCE_FOR_CRYPT
-/* Don't leak the _GNU_SOURCE define to other headers. */
-# undef _GNU_SOURCE
-# undef _Py_GNU_SOURCE_FOR_CRYPT
-#endif
-#endif
-
-/* For size_t? */
-#ifdef HAVE_STDDEF_H
-#include <stddef.h>
-#endif
-
-/* CAUTION: Build setups should ensure that NDEBUG is defined on the
- * compiler command line when building Python in release mode; else
- * assert() calls won't be removed.
- */
-#include <assert.h>
-
-#include "pyport.h"
-#include "pymacro.h"
-
-/* A convenient way for code to know if clang's memory sanitizer is enabled. */
-#if defined(__has_feature)
-# if __has_feature(memory_sanitizer)
-# if !defined(_Py_MEMORY_SANITIZER)
-# define _Py_MEMORY_SANITIZER
-# endif
-# endif
-#endif
-
-#include "pyatomic.h"
-
-/* Debug-mode build with pymalloc implies PYMALLOC_DEBUG.
- * PYMALLOC_DEBUG is in error if pymalloc is not in use.
- */
-#if defined(Py_DEBUG) && defined(WITH_PYMALLOC) && !defined(PYMALLOC_DEBUG)
-#define PYMALLOC_DEBUG
-#endif
-#if defined(PYMALLOC_DEBUG) && !defined(WITH_PYMALLOC)
-#error "PYMALLOC_DEBUG requires WITH_PYMALLOC"
-#endif
-#include "pymath.h"
-#include "pytime.h"
-#include "pymem.h"
-
-#include "object.h"
-#include "objimpl.h"
-#include "typeslots.h"
-#include "pyhash.h"
-
-#include "pydebug.h"
-
-#include "bytearrayobject.h"
-#include "bytesobject.h"
-#include "unicodeobject.h"
-#include "longobject.h"
-#include "longintrepr.h"
-#include "boolobject.h"
-#include "floatobject.h"
-#include "complexobject.h"
-#include "rangeobject.h"
-#include "memoryobject.h"
-#include "tupleobject.h"
-#include "listobject.h"
-#include "dictobject.h"
-#include "odictobject.h"
-#include "enumobject.h"
-#include "setobject.h"
-#include "methodobject.h"
-#include "moduleobject.h"
-#include "funcobject.h"
-#include "classobject.h"
-#include "fileobject.h"
-#include "pycapsule.h"
-#include "traceback.h"
-#include "sliceobject.h"
-#include "cellobject.h"
-#include "iterobject.h"
-#include "genobject.h"
-#include "descrobject.h"
-#include "warnings.h"
-#include "weakrefobject.h"
-#include "structseq.h"
-#include "namespaceobject.h"
-
-#include "codecs.h"
-#include "pyerrors.h"
-
-#include "pystate.h"
-#include "context.h"
-
-#include "pyarena.h"
-#include "modsupport.h"
-#include "compile.h"
-#include "pythonrun.h"
-#include "pylifecycle.h"
-#include "ceval.h"
-#include "sysmodule.h"
-#include "osmodule.h"
-#include "intrcheck.h"
-#include "import.h"
-
-#include "abstract.h"
-#include "bltinmodule.h"
-
-#include "eval.h"
-
-#include "pyctype.h"
-#include "pystrtod.h"
-#include "pystrcmp.h"
-#include "dtoa.h"
-#include "fileutils.h"
-#include "pyfpe.h"
-
-#endif /* !Py_PYTHON_H */
diff --git a/pythonsdk/include/abstract.h b/pythonsdk/include/abstract.h
deleted file mode 100644
index 6e88c2a40db53006c946da027ce4ec0bb2eeaeaf..0000000000000000000000000000000000000000
--- a/pythonsdk/include/abstract.h
+++ /dev/null
@@ -1,1109 +0,0 @@
-/* Abstract Object Interface (many thanks to Jim Fulton) */
-
-#ifndef Py_ABSTRACTOBJECT_H
-#define Py_ABSTRACTOBJECT_H
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-/* === Object Protocol ================================================== */
-
-/* Implemented elsewhere:
-
- int PyObject_Print(PyObject *o, FILE *fp, int flags);
-
- Print an object 'o' on file 'fp'. Returns -1 on error. The flags argument
- is used to enable certain printing options. The only option currently
- supported is Py_Print_RAW.
-
- (What should be said about Py_Print_RAW?). */
-
-
-/* Implemented elsewhere:
-
- int PyObject_HasAttrString(PyObject *o, const char *attr_name);
-
- Returns 1 if object 'o' has the attribute attr_name, and 0 otherwise.
-
- This is equivalent to the Python expression: hasattr(o,attr_name).
-
- This function always succeeds. */
-
-
-/* Implemented elsewhere:
-
- PyObject* PyObject_GetAttrString(PyObject *o, const char *attr_name);
-
- Retrieve an attributed named attr_name form object o.
- Returns the attribute value on success, or NULL on failure.
-
- This is the equivalent of the Python expression: o.attr_name. */
-
-
-/* Implemented elsewhere:
-
- int PyObject_HasAttr(PyObject *o, PyObject *attr_name);
-
- Returns 1 if o has the attribute attr_name, and 0 otherwise.
-
- This is equivalent to the Python expression: hasattr(o,attr_name).
-
- This function always succeeds. */
-
-/* Implemented elsewhere:
-
- PyObject* PyObject_GetAttr(PyObject *o, PyObject *attr_name);
-
- Retrieve an attributed named 'attr_name' form object 'o'.
- Returns the attribute value on success, or NULL on failure.
-
- This is the equivalent of the Python expression: o.attr_name. */
-
-
-/* Implemented elsewhere:
-
- int PyObject_SetAttrString(PyObject *o, const char *attr_name, PyObject *v);
-
- Set the value of the attribute named attr_name, for object 'o',
- to the value 'v'. Raise an exception and return -1 on failure; return 0 on
- success.
-
- This is the equivalent of the Python statement o.attr_name=v. */
-
-
-/* Implemented elsewhere:
-
- int PyObject_SetAttr(PyObject *o, PyObject *attr_name, PyObject *v);
-
- Set the value of the attribute named attr_name, for object 'o', to the value
- 'v'. an exception and return -1 on failure; return 0 on success.
-
- This is the equivalent of the Python statement o.attr_name=v. */
-
-/* Implemented as a macro:
-
- int PyObject_DelAttrString(PyObject *o, const char *attr_name);
-
- Delete attribute named attr_name, for object o. Returns
- -1 on failure.
-
- This is the equivalent of the Python statement: del o.attr_name. */
-#define PyObject_DelAttrString(O,A) PyObject_SetAttrString((O),(A), NULL)
-
-
-/* Implemented as a macro:
-
- int PyObject_DelAttr(PyObject *o, PyObject *attr_name);
-
- Delete attribute named attr_name, for object o. Returns -1
- on failure. This is the equivalent of the Python
- statement: del o.attr_name. */
-#define PyObject_DelAttr(O,A) PyObject_SetAttr((O),(A), NULL)
-
-
-/* Implemented elsewhere:
-
- PyObject *PyObject_Repr(PyObject *o);
-
- Compute the string representation of object 'o'. Returns the
- string representation on success, NULL on failure.
-
- This is the equivalent of the Python expression: repr(o).
-
- Called by the repr() built-in function. */
-
-
-/* Implemented elsewhere:
-
- PyObject *PyObject_Str(PyObject *o);
-
- Compute the string representation of object, o. Returns the
- string representation on success, NULL on failure.
-
- This is the equivalent of the Python expression: str(o).
-
- Called by the str() and print() built-in functions. */
-
-
-/* Declared elsewhere
-
- PyAPI_FUNC(int) PyCallable_Check(PyObject *o);
-
- Determine if the object, o, is callable. Return 1 if the object is callable
- and 0 otherwise.
-
- This function always succeeds. */
-
-
-#ifdef PY_SSIZE_T_CLEAN
-# define PyObject_CallFunction _PyObject_CallFunction_SizeT
-# define PyObject_CallMethod _PyObject_CallMethod_SizeT
-# ifndef Py_LIMITED_API
-# define _PyObject_CallMethodId _PyObject_CallMethodId_SizeT
-# endif /* !Py_LIMITED_API */
-#endif
-
-
-/* Call a callable Python object 'callable' with arguments given by the
- tuple 'args' and keywords arguments given by the dictionary 'kwargs'.
-
- 'args' must not be NULL, use an empty tuple if no arguments are
- needed. If no named arguments are needed, 'kwargs' can be NULL.
-
- This is the equivalent of the Python expression:
- callable(*args, **kwargs). */
-PyAPI_FUNC(PyObject *) PyObject_Call(PyObject *callable,
- PyObject *args, PyObject *kwargs);
-
-#ifndef Py_LIMITED_API
-PyAPI_FUNC(PyObject*) _PyStack_AsTuple(
- PyObject *const *stack,
- Py_ssize_t nargs);
-
-PyAPI_FUNC(PyObject*) _PyStack_AsTupleSlice(
- PyObject *const *stack,
- Py_ssize_t nargs,
- Py_ssize_t start,
- Py_ssize_t end);
-
-/* Convert keyword arguments from the FASTCALL (stack: C array, kwnames: tuple)
- format to a Python dictionary ("kwargs" dict).
-
- The type of kwnames keys is not checked. The final function getting
- arguments is responsible to check if all keys are strings, for example using
- PyArg_ParseTupleAndKeywords() or PyArg_ValidateKeywordArguments().
-
- Duplicate keys are merged using the last value. If duplicate keys must raise
- an exception, the caller is responsible to implement an explicit keys on
- kwnames. */
-PyAPI_FUNC(PyObject *) _PyStack_AsDict(
- PyObject *const *values,
- PyObject *kwnames);
-
-/* Convert (args, nargs, kwargs: dict) into a (stack, nargs, kwnames: tuple).
-
- Return 0 on success, raise an exception and return -1 on error.
-
- Write the new stack into *p_stack. If *p_stack is differen than args, it
- must be released by PyMem_Free().
-
- The stack uses borrowed references.
-
- The type of keyword keys is not checked, these checks should be done
- later (ex: _PyArg_ParseStackAndKeywords). */
-PyAPI_FUNC(int) _PyStack_UnpackDict(
- PyObject *const *args,
- Py_ssize_t nargs,
- PyObject *kwargs,
- PyObject *const **p_stack,
- PyObject **p_kwnames);
-
-/* Suggested size (number of positional arguments) for arrays of PyObject*
- allocated on a C stack to avoid allocating memory on the heap memory. Such
- array is used to pass positional arguments to call functions of the
- _PyObject_FastCall() family.
-
- The size is chosen to not abuse the C stack and so limit the risk of stack
- overflow. The size is also chosen to allow using the small stack for most
- function calls of the Python standard library. On 64-bit CPU, it allocates
- 40 bytes on the stack. */
-#define _PY_FASTCALL_SMALL_STACK 5
-
-/* Return 1 if callable supports FASTCALL calling convention for positional
- arguments: see _PyObject_FastCallDict() and _PyObject_FastCallKeywords() */
-PyAPI_FUNC(int) _PyObject_HasFastCall(PyObject *callable);
-
-/* Call the callable object 'callable' with the "fast call" calling convention:
- args is a C array for positional arguments (nargs is the number of
- positional arguments), kwargs is a dictionary for keyword arguments.
-
- If nargs is equal to zero, args can be NULL. kwargs can be NULL.
- nargs must be greater or equal to zero.
-
- Return the result on success. Raise an exception and return NULL on
- error. */
-PyAPI_FUNC(PyObject *) _PyObject_FastCallDict(
- PyObject *callable,
- PyObject *const *args,
- Py_ssize_t nargs,
- PyObject *kwargs);
-
-/* Call the callable object 'callable' with the "fast call" calling convention:
- args is a C array for positional arguments followed by values of
- keyword arguments. Keys of keyword arguments are stored as a tuple
- of strings in kwnames. nargs is the number of positional parameters at
- the beginning of stack. The size of kwnames gives the number of keyword
- values in the stack after positional arguments.
-
- kwnames must only contains str strings, no subclass, and all keys must
- be unique.
-
- If nargs is equal to zero and there is no keyword argument (kwnames is
- NULL or its size is zero), args can be NULL.
-
- Return the result on success. Raise an exception and return NULL on
- error. */
-PyAPI_FUNC(PyObject *) _PyObject_FastCallKeywords(
- PyObject *callable,
- PyObject *const *args,
- Py_ssize_t nargs,
- PyObject *kwnames);
-
-#define _PyObject_FastCall(func, args, nargs) \
- _PyObject_FastCallDict((func), (args), (nargs), NULL)
-
-#define _PyObject_CallNoArg(func) \
- _PyObject_FastCallDict((func), NULL, 0, NULL)
-
-PyAPI_FUNC(PyObject *) _PyObject_Call_Prepend(
- PyObject *callable,
- PyObject *obj,
- PyObject *args,
- PyObject *kwargs);
-
-PyAPI_FUNC(PyObject *) _PyObject_FastCall_Prepend(
- PyObject *callable,
- PyObject *obj,
- PyObject *const *args,
- Py_ssize_t nargs);
-
-PyAPI_FUNC(PyObject *) _Py_CheckFunctionResult(PyObject *callable,
- PyObject *result,
- const char *where);
-#endif /* Py_LIMITED_API */
-
-
-/* Call a callable Python object 'callable', with arguments given by the
- tuple 'args'. If no arguments are needed, then 'args' can be NULL.
-
- Returns the result of the call on success, or NULL on failure.
-
- This is the equivalent of the Python expression:
- callable(*args). */
-PyAPI_FUNC(PyObject *) PyObject_CallObject(PyObject *callable,
- PyObject *args);
-
-/* Call a callable Python object, callable, with a variable number of C
- arguments. The C arguments are described using a mkvalue-style format
- string.
-
- The format may be NULL, indicating that no arguments are provided.
-
- Returns the result of the call on success, or NULL on failure.
-
- This is the equivalent of the Python expression:
- callable(arg1, arg2, ...). */
-PyAPI_FUNC(PyObject *) PyObject_CallFunction(PyObject *callable,
- const char *format, ...);
-
-/* Call the method named 'name' of object 'obj' with a variable number of
- C arguments. The C arguments are described by a mkvalue format string.
-
- The format can be NULL, indicating that no arguments are provided.
-
- Returns the result of the call on success, or NULL on failure.
-
- This is the equivalent of the Python expression:
- obj.name(arg1, arg2, ...). */
-PyAPI_FUNC(PyObject *) PyObject_CallMethod(PyObject *obj,
- const char *name,
- const char *format, ...);
-
-#ifndef Py_LIMITED_API
-/* Like PyObject_CallMethod(), but expect a _Py_Identifier*
- as the method name. */
-PyAPI_FUNC(PyObject *) _PyObject_CallMethodId(PyObject *obj,
- _Py_Identifier *name,
- const char *format, ...);
-#endif /* !Py_LIMITED_API */
-
-PyAPI_FUNC(PyObject *) _PyObject_CallFunction_SizeT(PyObject *callable,
- const char *format,
- ...);
-
-PyAPI_FUNC(PyObject *) _PyObject_CallMethod_SizeT(PyObject *obj,
- const char *name,
- const char *format,
- ...);
-
-#ifndef Py_LIMITED_API
-PyAPI_FUNC(PyObject *) _PyObject_CallMethodId_SizeT(PyObject *obj,
- _Py_Identifier *name,
- const char *format,
- ...);
-#endif /* !Py_LIMITED_API */
-
-/* Call a callable Python object 'callable' with a variable number of C
- arguments. The C arguments are provided as PyObject* values, terminated
- by a NULL.
-
- Returns the result of the call on success, or NULL on failure.
-
- This is the equivalent of the Python expression:
- callable(arg1, arg2, ...). */
-PyAPI_FUNC(PyObject *) PyObject_CallFunctionObjArgs(PyObject *callable,
- ...);
-
-/* Call the method named 'name' of object 'obj' with a variable number of
- C arguments. The C arguments are provided as PyObject* values, terminated
- by NULL.
-
- Returns the result of the call on success, or NULL on failure.
-
- This is the equivalent of the Python expression: obj.name(*args). */
-
-PyAPI_FUNC(PyObject *) PyObject_CallMethodObjArgs(
- PyObject *obj,
- PyObject *name,
- ...);
-
-#ifndef Py_LIMITED_API
-PyAPI_FUNC(PyObject *) _PyObject_CallMethodIdObjArgs(
- PyObject *obj,
- struct _Py_Identifier *name,
- ...);
-#endif /* !Py_LIMITED_API */
-
-
-/* Implemented elsewhere:
-
- Py_hash_t PyObject_Hash(PyObject *o);
-
- Compute and return the hash, hash_value, of an object, o. On
- failure, return -1.
-
- This is the equivalent of the Python expression: hash(o). */
-
-
-/* Implemented elsewhere:
-
- int PyObject_IsTrue(PyObject *o);
-
- Returns 1 if the object, o, is considered to be true, 0 if o is
- considered to be false and -1 on failure.
-
- This is equivalent to the Python expression: not not o. */
-
-
-/* Implemented elsewhere:
-
- int PyObject_Not(PyObject *o);
-
- Returns 0 if the object, o, is considered to be true, 1 if o is
- considered to be false and -1 on failure.
-
- This is equivalent to the Python expression: not o. */
-
-
-/* Get the type of an object.
-
- On success, returns a type object corresponding to the object type of object
- 'o'. On failure, returns NULL.
-
- This is equivalent to the Python expression: type(o) */
-PyAPI_FUNC(PyObject *) PyObject_Type(PyObject *o);
-
-
-/* Return the size of object 'o'. If the object 'o' provides both sequence and
- mapping protocols, the sequence size is returned.
-
- On error, -1 is returned.
-
- This is the equivalent to the Python expression: len(o) */
-PyAPI_FUNC(Py_ssize_t) PyObject_Size(PyObject *o);
-
-
-/* For DLL compatibility */
-#undef PyObject_Length
-PyAPI_FUNC(Py_ssize_t) PyObject_Length(PyObject *o);
-#define PyObject_Length PyObject_Size
-
-
-#ifndef Py_LIMITED_API
-PyAPI_FUNC(int) _PyObject_HasLen(PyObject *o);
-
-/* Guess the size of object 'o' using len(o) or o.__length_hint__().
- If neither of those return a non-negative value, then return the default
- value. If one of the calls fails, this function returns -1. */
-PyAPI_FUNC(Py_ssize_t) PyObject_LengthHint(PyObject *o, Py_ssize_t);
-#endif
-
-/* Return element of 'o' corresponding to the object 'key'. Return NULL
- on failure.
-
- This is the equivalent of the Python expression: o[key] */
-PyAPI_FUNC(PyObject *) PyObject_GetItem(PyObject *o, PyObject *key);
-
-
-/* Map the object 'key' to the value 'v' into 'o'.
-
- Raise an exception and return -1 on failure; return 0 on success.
-
- This is the equivalent of the Python statement: o[key]=v. */
-PyAPI_FUNC(int) PyObject_SetItem(PyObject *o, PyObject *key, PyObject *v);
-
-/* Remove the mapping for the string 'key' from the object 'o'.
- Returns -1 on failure.
-
- This is equivalent to the Python statement: del o[key]. */
-PyAPI_FUNC(int) PyObject_DelItemString(PyObject *o, const char *key);
-
-/* Delete the mapping for the object 'key' from the object 'o'.
- Returns -1 on failure.
-
- This is the equivalent of the Python statement: del o[key]. */
-PyAPI_FUNC(int) PyObject_DelItem(PyObject *o, PyObject *key);
-
-
-/* === Old Buffer API ============================================ */
-
-/* FIXME: usage of these should all be replaced in Python itself
- but for backwards compatibility we will implement them.
- Their usage without a corresponding "unlock" mechanism
- may create issues (but they would already be there). */
-
-/* Takes an arbitrary object which must support the (character, single segment)
- buffer interface and returns a pointer to a read-only memory location
- useable as character based input for subsequent processing.
-
- Return 0 on success. buffer and buffer_len are only set in case no error
- occurs. Otherwise, -1 is returned and an exception set. */
-PyAPI_FUNC(int) PyObject_AsCharBuffer(PyObject *obj,
- const char **buffer,
- Py_ssize_t *buffer_len)
- Py_DEPRECATED(3.0);
-
-/* Checks whether an arbitrary object supports the (character, single segment)
- buffer interface.
-
- Returns 1 on success, 0 on failure. */
-PyAPI_FUNC(int) PyObject_CheckReadBuffer(PyObject *obj)
- Py_DEPRECATED(3.0);
-
-/* Same as PyObject_AsCharBuffer() except that this API expects (readable,
- single segment) buffer interface and returns a pointer to a read-only memory
- location which can contain arbitrary data.
-
- 0 is returned on success. buffer and buffer_len are only set in case no
- error occurs. Otherwise, -1 is returned and an exception set. */
-PyAPI_FUNC(int) PyObject_AsReadBuffer(PyObject *obj,
- const void **buffer,
- Py_ssize_t *buffer_len)
- Py_DEPRECATED(3.0);
-
-/* Takes an arbitrary object which must support the (writable, single segment)
- buffer interface and returns a pointer to a writable memory location in
- buffer of size 'buffer_len'.
-
- Return 0 on success. buffer and buffer_len are only set in case no error
- occurs. Otherwise, -1 is returned and an exception set. */
-PyAPI_FUNC(int) PyObject_AsWriteBuffer(PyObject *obj,
- void **buffer,
- Py_ssize_t *buffer_len)
- Py_DEPRECATED(3.0);
-
-
-/* === New Buffer API ============================================ */
-
-#ifndef Py_LIMITED_API
-
-/* Return 1 if the getbuffer function is available, otherwise return 0. */
-#define PyObject_CheckBuffer(obj) \
- (((obj)->ob_type->tp_as_buffer != NULL) && \
- ((obj)->ob_type->tp_as_buffer->bf_getbuffer != NULL))
-
-/* This is a C-API version of the getbuffer function call. It checks
- to make sure object has the required function pointer and issues the
- call.
-
- Returns -1 and raises an error on failure and returns 0 on success. */
-PyAPI_FUNC(int) PyObject_GetBuffer(PyObject *obj, Py_buffer *view,
- int flags);
-
-/* Get the memory area pointed to by the indices for the buffer given.
- Note that view->ndim is the assumed size of indices. */
-PyAPI_FUNC(void *) PyBuffer_GetPointer(Py_buffer *view, Py_ssize_t *indices);
-
-/* Return the implied itemsize of the data-format area from a
- struct-style description. */
-PyAPI_FUNC(int) PyBuffer_SizeFromFormat(const char *);
-
-/* Implementation in memoryobject.c */
-PyAPI_FUNC(int) PyBuffer_ToContiguous(void *buf, Py_buffer *view,
- Py_ssize_t len, char order);
-
-PyAPI_FUNC(int) PyBuffer_FromContiguous(Py_buffer *view, void *buf,
- Py_ssize_t len, char order);
-
-/* Copy len bytes of data from the contiguous chunk of memory
- pointed to by buf into the buffer exported by obj. Return
- 0 on success and return -1 and raise a PyBuffer_Error on
- error (i.e. the object does not have a buffer interface or
- it is not working).
-
- If fort is 'F', then if the object is multi-dimensional,
- then the data will be copied into the array in
- Fortran-style (first dimension varies the fastest). If
- fort is 'C', then the data will be copied into the array
- in C-style (last dimension varies the fastest). If fort
- is 'A', then it does not matter and the copy will be made
- in whatever way is more efficient. */
-PyAPI_FUNC(int) PyObject_CopyData(PyObject *dest, PyObject *src);
-
-/* Copy the data from the src buffer to the buffer of destination. */
-PyAPI_FUNC(int) PyBuffer_IsContiguous(const Py_buffer *view, char fort);
-
-/*Fill the strides array with byte-strides of a contiguous
- (Fortran-style if fort is 'F' or C-style otherwise)
- array of the given shape with the given number of bytes
- per element. */
-PyAPI_FUNC(void) PyBuffer_FillContiguousStrides(int ndims,
- Py_ssize_t *shape,
- Py_ssize_t *strides,
- int itemsize,
- char fort);
-
-/* Fills in a buffer-info structure correctly for an exporter
- that can only share a contiguous chunk of memory of
- "unsigned bytes" of the given length.
-
- Returns 0 on success and -1 (with raising an error) on error. */
-PyAPI_FUNC(int) PyBuffer_FillInfo(Py_buffer *view, PyObject *o, void *buf,
- Py_ssize_t len, int readonly,
- int flags);
-
-/* Releases a Py_buffer obtained from getbuffer ParseTuple's "s*". */
-PyAPI_FUNC(void) PyBuffer_Release(Py_buffer *view);
-
-#endif /* Py_LIMITED_API */
-
-/* Takes an arbitrary object and returns the result of calling
- obj.__format__(format_spec). */
-PyAPI_FUNC(PyObject *) PyObject_Format(PyObject *obj,
- PyObject *format_spec);
-
-
-/* ==== Iterators ================================================ */
-
-/* Takes an object and returns an iterator for it.
- This is typically a new iterator but if the argument is an iterator, this
- returns itself. */
-PyAPI_FUNC(PyObject *) PyObject_GetIter(PyObject *);
-
-#define PyIter_Check(obj) \
- ((obj)->ob_type->tp_iternext != NULL && \
- (obj)->ob_type->tp_iternext != &_PyObject_NextNotImplemented)
-
-/* Takes an iterator object and calls its tp_iternext slot,
- returning the next value.
-
- If the iterator is exhausted, this returns NULL without setting an
- exception.
-
- NULL with an exception means an error occurred. */
-PyAPI_FUNC(PyObject *) PyIter_Next(PyObject *);
-
-
-/* === Number Protocol ================================================== */
-
-/* Returns 1 if the object 'o' provides numeric protocols, and 0 otherwise.
-
- This function always succeeds. */
-PyAPI_FUNC(int) PyNumber_Check(PyObject *o);
-
-/* Returns the result of adding o1 and o2, or NULL on failure.
-
- This is the equivalent of the Python expression: o1 + o2. */
-PyAPI_FUNC(PyObject *) PyNumber_Add(PyObject *o1, PyObject *o2);
-
-/* Returns the result of subtracting o2 from o1, or NULL on failure.
-
- This is the equivalent of the Python expression: o1 - o2. */
-PyAPI_FUNC(PyObject *) PyNumber_Subtract(PyObject *o1, PyObject *o2);
-
-/* Returns the result of multiplying o1 and o2, or NULL on failure.
-
- This is the equivalent of the Python expression: o1 * o2. */
-PyAPI_FUNC(PyObject *) PyNumber_Multiply(PyObject *o1, PyObject *o2);
-
-#if !defined(Py_LIMITED_API) || Py_LIMITED_API+0 >= 0x03050000
-/* This is the equivalent of the Python expression: o1 @ o2. */
-PyAPI_FUNC(PyObject *) PyNumber_MatrixMultiply(PyObject *o1, PyObject *o2);
-#endif
-
-/* Returns the result of dividing o1 by o2 giving an integral result,
- or NULL on failure.
-
- This is the equivalent of the Python expression: o1 // o2. */
-PyAPI_FUNC(PyObject *) PyNumber_FloorDivide(PyObject *o1, PyObject *o2);
-
-/* Returns the result of dividing o1 by o2 giving a float result, or NULL on
- failure.
-
- This is the equivalent of the Python expression: o1 / o2. */
-PyAPI_FUNC(PyObject *) PyNumber_TrueDivide(PyObject *o1, PyObject *o2);
-
-/* Returns the remainder of dividing o1 by o2, or NULL on failure.
-
- This is the equivalent of the Python expression: o1 % o2. */
-PyAPI_FUNC(PyObject *) PyNumber_Remainder(PyObject *o1, PyObject *o2);
-
-/* See the built-in function divmod.
-
- Returns NULL on failure.
-
- This is the equivalent of the Python expression: divmod(o1, o2). */
-PyAPI_FUNC(PyObject *) PyNumber_Divmod(PyObject *o1, PyObject *o2);
-
-/* See the built-in function pow. Returns NULL on failure.
-
- This is the equivalent of the Python expression: pow(o1, o2, o3),
- where o3 is optional. */
-PyAPI_FUNC(PyObject *) PyNumber_Power(PyObject *o1, PyObject *o2,
- PyObject *o3);
-
-/* Returns the negation of o on success, or NULL on failure.
-
- This is the equivalent of the Python expression: -o. */
-PyAPI_FUNC(PyObject *) PyNumber_Negative(PyObject *o);
-
-/* Returns the positive of o on success, or NULL on failure.
-
- This is the equivalent of the Python expression: +o. */
-PyAPI_FUNC(PyObject *) PyNumber_Positive(PyObject *o);
-
-/* Returns the absolute value of 'o', or NULL on failure.
-
- This is the equivalent of the Python expression: abs(o). */
-PyAPI_FUNC(PyObject *) PyNumber_Absolute(PyObject *o);
-
-/* Returns the bitwise negation of 'o' on success, or NULL on failure.
-
- This is the equivalent of the Python expression: ~o. */
-PyAPI_FUNC(PyObject *) PyNumber_Invert(PyObject *o);
-
-/* Returns the result of left shifting o1 by o2 on success, or NULL on failure.
-
- This is the equivalent of the Python expression: o1 << o2. */
-PyAPI_FUNC(PyObject *) PyNumber_Lshift(PyObject *o1, PyObject *o2);
-
-/* Returns the result of right shifting o1 by o2 on success, or NULL on
- failure.
-
- This is the equivalent of the Python expression: o1 >> o2. */
-PyAPI_FUNC(PyObject *) PyNumber_Rshift(PyObject *o1, PyObject *o2);
-
-/* Returns the result of bitwise and of o1 and o2 on success, or NULL on
- failure.
-
- This is the equivalent of the Python expression: o1 & o2. */
-PyAPI_FUNC(PyObject *) PyNumber_And(PyObject *o1, PyObject *o2);
-
-/* Returns the bitwise exclusive or of o1 by o2 on success, or NULL on failure.
-
- This is the equivalent of the Python expression: o1 ^ o2. */
-PyAPI_FUNC(PyObject *) PyNumber_Xor(PyObject *o1, PyObject *o2);
-
-/* Returns the result of bitwise or on o1 and o2 on success, or NULL on
- failure.
-
- This is the equivalent of the Python expression: o1 | o2. */
-PyAPI_FUNC(PyObject *) PyNumber_Or(PyObject *o1, PyObject *o2);
-
-#define PyIndex_Check(obj) \
- ((obj)->ob_type->tp_as_number != NULL && \
- (obj)->ob_type->tp_as_number->nb_index != NULL)
-
-/* Returns the object 'o' converted to a Python int, or NULL with an exception
- raised on failure. */
-PyAPI_FUNC(PyObject *) PyNumber_Index(PyObject *o);
-
-/* Returns the object 'o' converted to Py_ssize_t by going through
- PyNumber_Index() first.
-
- If an overflow error occurs while converting the int to Py_ssize_t, then the
- second argument 'exc' is the error-type to return. If it is NULL, then the
- overflow error is cleared and the value is clipped. */
-PyAPI_FUNC(Py_ssize_t) PyNumber_AsSsize_t(PyObject *o, PyObject *exc);
-
-/* Returns the object 'o' converted to an integer object on success, or NULL
- on failure.
-
- This is the equivalent of the Python expression: int(o). */
-PyAPI_FUNC(PyObject *) PyNumber_Long(PyObject *o);
-
-/* Returns the object 'o' converted to a float object on success, or NULL
- on failure.
-
- This is the equivalent of the Python expression: float(o). */
-PyAPI_FUNC(PyObject *) PyNumber_Float(PyObject *o);
-
-
-/* --- In-place variants of (some of) the above number protocol functions -- */
-
-/* Returns the result of adding o2 to o1, possibly in-place, or NULL
- on failure.
-
- This is the equivalent of the Python expression: o1 += o2. */
-PyAPI_FUNC(PyObject *) PyNumber_InPlaceAdd(PyObject *o1, PyObject *o2);
-
-/* Returns the result of subtracting o2 from o1, possibly in-place or
- NULL on failure.
-
- This is the equivalent of the Python expression: o1 -= o2. */
-PyAPI_FUNC(PyObject *) PyNumber_InPlaceSubtract(PyObject *o1, PyObject *o2);
-
-/* Returns the result of multiplying o1 by o2, possibly in-place, or NULL on
- failure.
-
- This is the equivalent of the Python expression: o1 *= o2. */
-PyAPI_FUNC(PyObject *) PyNumber_InPlaceMultiply(PyObject *o1, PyObject *o2);
-
-#if !defined(Py_LIMITED_API) || Py_LIMITED_API+0 >= 0x03050000
-/* This is the equivalent of the Python expression: o1 @= o2. */
-PyAPI_FUNC(PyObject *) PyNumber_InPlaceMatrixMultiply(PyObject *o1, PyObject *o2);
-#endif
-
-/* Returns the result of dividing o1 by o2 giving an integral result, possibly
- in-place, or NULL on failure.
-
- This is the equivalent of the Python expression: o1 /= o2. */
-PyAPI_FUNC(PyObject *) PyNumber_InPlaceFloorDivide(PyObject *o1,
- PyObject *o2);
-
-/* Returns the result of dividing o1 by o2 giving a float result, possibly
- in-place, or null on failure.
-
- This is the equivalent of the Python expression: o1 /= o2. */
-PyAPI_FUNC(PyObject *) PyNumber_InPlaceTrueDivide(PyObject *o1,
- PyObject *o2);
-
-/* Returns the remainder of dividing o1 by o2, possibly in-place, or NULL on
- failure.
-
- This is the equivalent of the Python expression: o1 %= o2. */
-PyAPI_FUNC(PyObject *) PyNumber_InPlaceRemainder(PyObject *o1, PyObject *o2);
-
-/* Returns the result of raising o1 to the power of o2, possibly in-place,
- or NULL on failure.
-
- This is the equivalent of the Python expression: o1 **= o2,
- or o1 = pow(o1, o2, o3) if o3 is present. */
-PyAPI_FUNC(PyObject *) PyNumber_InPlacePower(PyObject *o1, PyObject *o2,
- PyObject *o3);
-
-/* Returns the result of left shifting o1 by o2, possibly in-place, or NULL
- on failure.
-
- This is the equivalent of the Python expression: o1 <<= o2. */
-PyAPI_FUNC(PyObject *) PyNumber_InPlaceLshift(PyObject *o1, PyObject *o2);
-
-/* Returns the result of right shifting o1 by o2, possibly in-place or NULL
- on failure.
-
- This is the equivalent of the Python expression: o1 >>= o2. */
-PyAPI_FUNC(PyObject *) PyNumber_InPlaceRshift(PyObject *o1, PyObject *o2);
-
-/* Returns the result of bitwise and of o1 and o2, possibly in-place, or NULL
- on failure.
-
- This is the equivalent of the Python expression: o1 &= o2. */
-PyAPI_FUNC(PyObject *) PyNumber_InPlaceAnd(PyObject *o1, PyObject *o2);
-
-/* Returns the bitwise exclusive or of o1 by o2, possibly in-place, or NULL
- on failure.
-
- This is the equivalent of the Python expression: o1 ^= o2. */
-PyAPI_FUNC(PyObject *) PyNumber_InPlaceXor(PyObject *o1, PyObject *o2);
-
-/* Returns the result of bitwise or of o1 and o2, possibly in-place,
- or NULL on failure.
-
- This is the equivalent of the Python expression: o1 |= o2. */
-PyAPI_FUNC(PyObject *) PyNumber_InPlaceOr(PyObject *o1, PyObject *o2);
-
-/* Returns the integer n converted to a string with a base, with a base
- marker of 0b, 0o or 0x prefixed if applicable.
-
- If n is not an int object, it is converted with PyNumber_Index first. */
-PyAPI_FUNC(PyObject *) PyNumber_ToBase(PyObject *n, int base);
-
-
-/* === Sequence protocol ================================================ */
-
-/* Return 1 if the object provides sequence protocol, and zero
- otherwise.
-
- This function always succeeds. */
-PyAPI_FUNC(int) PySequence_Check(PyObject *o);
-
-/* Return the size of sequence object o, or -1 on failure. */
-PyAPI_FUNC(Py_ssize_t) PySequence_Size(PyObject *o);
-
-/* For DLL compatibility */
-#undef PySequence_Length
-PyAPI_FUNC(Py_ssize_t) PySequence_Length(PyObject *o);
-#define PySequence_Length PySequence_Size
-
-
-/* Return the concatenation of o1 and o2 on success, and NULL on failure.
-
- This is the equivalent of the Python expression: o1 + o2. */
-PyAPI_FUNC(PyObject *) PySequence_Concat(PyObject *o1, PyObject *o2);
-
-/* Return the result of repeating sequence object 'o' 'count' times,
- or NULL on failure.
-
- This is the equivalent of the Python expression: o * count. */
-PyAPI_FUNC(PyObject *) PySequence_Repeat(PyObject *o, Py_ssize_t count);
-
-/* Return the ith element of o, or NULL on failure.
-
- This is the equivalent of the Python expression: o[i]. */
-PyAPI_FUNC(PyObject *) PySequence_GetItem(PyObject *o, Py_ssize_t i);
-
-/* Return the slice of sequence object o between i1 and i2, or NULL on failure.
-
- This is the equivalent of the Python expression: o[i1:i2]. */
-PyAPI_FUNC(PyObject *) PySequence_GetSlice(PyObject *o, Py_ssize_t i1, Py_ssize_t i2);
-
-/* Assign object 'v' to the ith element of the sequence 'o'. Raise an exception
- and return -1 on failure; return 0 on success.
-
- This is the equivalent of the Python statement o[i] = v. */
-PyAPI_FUNC(int) PySequence_SetItem(PyObject *o, Py_ssize_t i, PyObject *v);
-
-/* Delete the 'i'-th element of the sequence 'v'. Returns -1 on failure.
-
- This is the equivalent of the Python statement: del o[i]. */
-PyAPI_FUNC(int) PySequence_DelItem(PyObject *o, Py_ssize_t i);
-
-/* Assign the sequence object 'v' to the slice in sequence object 'o',
- from 'i1' to 'i2'. Returns -1 on failure.
-
- This is the equivalent of the Python statement: o[i1:i2] = v. */
-PyAPI_FUNC(int) PySequence_SetSlice(PyObject *o, Py_ssize_t i1, Py_ssize_t i2,
- PyObject *v);
-
-/* Delete the slice in sequence object 'o' from 'i1' to 'i2'.
- Returns -1 on failure.
-
- This is the equivalent of the Python statement: del o[i1:i2]. */
-PyAPI_FUNC(int) PySequence_DelSlice(PyObject *o, Py_ssize_t i1, Py_ssize_t i2);
-
-/* Returns the sequence 'o' as a tuple on success, and NULL on failure.
-
- This is equivalent to the Python expression: tuple(o). */
-PyAPI_FUNC(PyObject *) PySequence_Tuple(PyObject *o);
-
-/* Returns the sequence 'o' as a list on success, and NULL on failure.
- This is equivalent to the Python expression: list(o) */
-PyAPI_FUNC(PyObject *) PySequence_List(PyObject *o);
-
-/* Return the sequence 'o' as a list, unless it's already a tuple or list.
-
- Use PySequence_Fast_GET_ITEM to access the members of this list, and
- PySequence_Fast_GET_SIZE to get its length.
-
- Returns NULL on failure. If the object does not support iteration, raises a
- TypeError exception with 'm' as the message text. */
-PyAPI_FUNC(PyObject *) PySequence_Fast(PyObject *o, const char* m);
-
-/* Return the size of the sequence 'o', assuming that 'o' was returned by
- PySequence_Fast and is not NULL. */
-#define PySequence_Fast_GET_SIZE(o) \
- (PyList_Check(o) ? PyList_GET_SIZE(o) : PyTuple_GET_SIZE(o))
-
-/* Return the 'i'-th element of the sequence 'o', assuming that o was returned
- by PySequence_Fast, and that i is within bounds. */
-#define PySequence_Fast_GET_ITEM(o, i)\
- (PyList_Check(o) ? PyList_GET_ITEM(o, i) : PyTuple_GET_ITEM(o, i))
-
-/* Assume tp_as_sequence and sq_item exist and that 'i' does not
- need to be corrected for a negative index. */
-#define PySequence_ITEM(o, i)\
- ( Py_TYPE(o)->tp_as_sequence->sq_item(o, i) )
-
-/* Return a pointer to the underlying item array for
- an object retured by PySequence_Fast */
-#define PySequence_Fast_ITEMS(sf) \
- (PyList_Check(sf) ? ((PyListObject *)(sf))->ob_item \
- : ((PyTupleObject *)(sf))->ob_item)
-
-/* Return the number of occurrences on value on 'o', that is, return
- the number of keys for which o[key] == value.
-
- On failure, return -1. This is equivalent to the Python expression:
- o.count(value). */
-PyAPI_FUNC(Py_ssize_t) PySequence_Count(PyObject *o, PyObject *value);
-
-/* Return 1 if 'ob' is in the sequence 'seq'; 0 if 'ob' is not in the sequence
- 'seq'; -1 on error.
-
- Use __contains__ if possible, else _PySequence_IterSearch(). */
-PyAPI_FUNC(int) PySequence_Contains(PyObject *seq, PyObject *ob);
-
-#ifndef Py_LIMITED_API
-#define PY_ITERSEARCH_COUNT 1
-#define PY_ITERSEARCH_INDEX 2
-#define PY_ITERSEARCH_CONTAINS 3
-
-/* Iterate over seq.
-
- Result depends on the operation:
-
- PY_ITERSEARCH_COUNT: return # of times obj appears in seq; -1 if
- error.
- PY_ITERSEARCH_INDEX: return 0-based index of first occurrence of
- obj in seq; set ValueError and return -1 if none found;
- also return -1 on error.
- PY_ITERSEARCH_CONTAINS: return 1 if obj in seq, else 0; -1 on
- error. */
-PyAPI_FUNC(Py_ssize_t) _PySequence_IterSearch(PyObject *seq,
- PyObject *obj, int operation);
-#endif
-
-
-/* For DLL-level backwards compatibility */
-#undef PySequence_In
-/* Determine if the sequence 'o' contains 'value'. If an item in 'o' is equal
- to 'value', return 1, otherwise return 0. On error, return -1.
-
- This is equivalent to the Python expression: value in o. */
-PyAPI_FUNC(int) PySequence_In(PyObject *o, PyObject *value);
-
-/* For source-level backwards compatibility */
-#define PySequence_In PySequence_Contains
-
-
-/* Return the first index for which o[i] == value.
- On error, return -1.
-
- This is equivalent to the Python expression: o.index(value). */
-PyAPI_FUNC(Py_ssize_t) PySequence_Index(PyObject *o, PyObject *value);
-
-
-/* --- In-place versions of some of the above Sequence functions --- */
-
-/* Append sequence 'o2' to sequence 'o1', in-place when possible. Return the
- resulting object, which could be 'o1', or NULL on failure.
-
- This is the equivalent of the Python expression: o1 += o2. */
-PyAPI_FUNC(PyObject *) PySequence_InPlaceConcat(PyObject *o1, PyObject *o2);
-
-/* Repeat sequence 'o' by 'count', in-place when possible. Return the resulting
- object, which could be 'o', or NULL on failure.
-
- This is the equivalent of the Python expression: o1 *= count. */
-PyAPI_FUNC(PyObject *) PySequence_InPlaceRepeat(PyObject *o, Py_ssize_t count);
-
-
-/* === Mapping protocol ================================================= */
-
-/* Return 1 if the object provides mapping protocol, and 0 otherwise.
-
- This function always succeeds. */
-PyAPI_FUNC(int) PyMapping_Check(PyObject *o);
-
-/* Returns the number of keys in mapping object 'o' on success, and -1 on
- failure. This is equivalent to the Python expression: len(o). */
-PyAPI_FUNC(Py_ssize_t) PyMapping_Size(PyObject *o);
-
-/* For DLL compatibility */
-#undef PyMapping_Length
-PyAPI_FUNC(Py_ssize_t) PyMapping_Length(PyObject *o);
-#define PyMapping_Length PyMapping_Size
-
-
-/* Implemented as a macro:
-
- int PyMapping_DelItemString(PyObject *o, const char *key);
-
- Remove the mapping for the string 'key' from the mapping 'o'. Returns -1 on
- failure.
-
- This is equivalent to the Python statement: del o[key]. */
-#define PyMapping_DelItemString(O,K) PyObject_DelItemString((O),(K))
-
-/* Implemented as a macro:
-
- int PyMapping_DelItem(PyObject *o, PyObject *key);
-
- Remove the mapping for the object 'key' from the mapping object 'o'.
- Returns -1 on failure.
-
- This is equivalent to the Python statement: del o[key]. */
-#define PyMapping_DelItem(O,K) PyObject_DelItem((O),(K))
-
-/* On success, return 1 if the mapping object 'o' has the key 'key',
- and 0 otherwise.
-
- This is equivalent to the Python expression: key in o.
-
- This function always succeeds. */
-PyAPI_FUNC(int) PyMapping_HasKeyString(PyObject *o, const char *key);
-
-/* Return 1 if the mapping object has the key 'key', and 0 otherwise.
-
- This is equivalent to the Python expression: key in o.
-
- This function always succeeds. */
-PyAPI_FUNC(int) PyMapping_HasKey(PyObject *o, PyObject *key);
-
-/* On success, return a list or tuple of the keys in mapping object 'o'.
- On failure, return NULL. */
-PyAPI_FUNC(PyObject *) PyMapping_Keys(PyObject *o);
-
-/* On success, return a list or tuple of the values in mapping object 'o'.
- On failure, return NULL. */
-PyAPI_FUNC(PyObject *) PyMapping_Values(PyObject *o);
-
-/* On success, return a list or tuple of the items in mapping object 'o',
- where each item is a tuple containing a key-value pair. On failure, return
- NULL. */
-PyAPI_FUNC(PyObject *) PyMapping_Items(PyObject *o);
-
-/* Return element of 'o' corresponding to the string 'key' or NULL on failure.
-
- This is the equivalent of the Python expression: o[key]. */
-PyAPI_FUNC(PyObject *) PyMapping_GetItemString(PyObject *o,
- const char *key);
-
-/* Map the string 'key' to the value 'v' in the mapping 'o'.
- Returns -1 on failure.
-
- This is the equivalent of the Python statement: o[key]=v. */
-PyAPI_FUNC(int) PyMapping_SetItemString(PyObject *o, const char *key,
- PyObject *value);
-
-/* isinstance(object, typeorclass) */
-PyAPI_FUNC(int) PyObject_IsInstance(PyObject *object, PyObject *typeorclass);
-
-/* issubclass(object, typeorclass) */
-PyAPI_FUNC(int) PyObject_IsSubclass(PyObject *object, PyObject *typeorclass);
-
-
-#ifndef Py_LIMITED_API
-PyAPI_FUNC(int) _PyObject_RealIsInstance(PyObject *inst, PyObject *cls);
-
-PyAPI_FUNC(int) _PyObject_RealIsSubclass(PyObject *derived, PyObject *cls);
-
-PyAPI_FUNC(char *const *) _PySequence_BytesToCharpArray(PyObject* self);
-
-PyAPI_FUNC(void) _Py_FreeCharPArray(char *const array[]);
-
-/* For internal use by buffer API functions */
-PyAPI_FUNC(void) _Py_add_one_to_index_F(int nd, Py_ssize_t *index,
- const Py_ssize_t *shape);
-PyAPI_FUNC(void) _Py_add_one_to_index_C(int nd, Py_ssize_t *index,
- const Py_ssize_t *shape);
-
-/* Convert Python int to Py_ssize_t. Do nothing if the argument is None. */
-PyAPI_FUNC(int) _Py_convert_optional_to_ssize_t(PyObject *, void *);
-#endif /* !Py_LIMITED_API */
-
-
-#ifdef __cplusplus
-}
-#endif
-#endif /* Py_ABSTRACTOBJECT_H */
diff --git a/pythonsdk/include/accu.h b/pythonsdk/include/accu.h
deleted file mode 100644
index 5856f117fe9f57201405612a7cfd48b5feb77b5d..0000000000000000000000000000000000000000
--- a/pythonsdk/include/accu.h
+++ /dev/null
@@ -1,37 +0,0 @@
-#ifndef Py_LIMITED_API
-#ifndef Py_ACCU_H
-#define Py_ACCU_H
-
-/*** This is a private API for use by the interpreter and the stdlib.
- *** Its definition may be changed or removed at any moment.
- ***/
-
-/*
- * A two-level accumulator of unicode objects that avoids both the overhead
- * of keeping a huge number of small separate objects, and the quadratic
- * behaviour of using a naive repeated concatenation scheme.
- */
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-#undef small /* defined by some Windows headers */
-
-typedef struct {
- PyObject *large; /* A list of previously accumulated large strings */
- PyObject *small; /* Pending small strings */
-} _PyAccu;
-
-PyAPI_FUNC(int) _PyAccu_Init(_PyAccu *acc);
-PyAPI_FUNC(int) _PyAccu_Accumulate(_PyAccu *acc, PyObject *unicode);
-PyAPI_FUNC(PyObject *) _PyAccu_FinishAsList(_PyAccu *acc);
-PyAPI_FUNC(PyObject *) _PyAccu_Finish(_PyAccu *acc);
-PyAPI_FUNC(void) _PyAccu_Destroy(_PyAccu *acc);
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif /* Py_ACCU_H */
-#endif /* Py_LIMITED_API */
diff --git a/pythonsdk/include/asdl.h b/pythonsdk/include/asdl.h
deleted file mode 100644
index 99c5580d09f021c1a0e8d0323088a74cad5d34e3..0000000000000000000000000000000000000000
--- a/pythonsdk/include/asdl.h
+++ /dev/null
@@ -1,46 +0,0 @@
-#ifndef Py_ASDL_H
-#define Py_ASDL_H
-
-typedef PyObject * identifier;
-typedef PyObject * string;
-typedef PyObject * bytes;
-typedef PyObject * object;
-typedef PyObject * singleton;
-typedef PyObject * constant;
-
-/* It would be nice if the code generated by asdl_c.py was completely
- independent of Python, but it is a goal the requires too much work
- at this stage. So, for example, I'll represent identifiers as
- interned Python strings.
-*/
-
-/* XXX A sequence should be typed so that its use can be typechecked. */
-
-typedef struct {
- Py_ssize_t size;
- void *elements[1];
-} asdl_seq;
-
-typedef struct {
- Py_ssize_t size;
- int elements[1];
-} asdl_int_seq;
-
-asdl_seq *_Py_asdl_seq_new(Py_ssize_t size, PyArena *arena);
-asdl_int_seq *_Py_asdl_int_seq_new(Py_ssize_t size, PyArena *arena);
-
-#define asdl_seq_GET(S, I) (S)->elements[(I)]
-#define asdl_seq_LEN(S) ((S) == NULL ? 0 : (S)->size)
-#ifdef Py_DEBUG
-#define asdl_seq_SET(S, I, V) \
- do { \
- Py_ssize_t _asdl_i = (I); \
- assert((S) != NULL); \
- assert(_asdl_i < (S)->size); \
- (S)->elements[_asdl_i] = (V); \
- } while (0)
-#else
-#define asdl_seq_SET(S, I, V) (S)->elements[I] = (V)
-#endif
-
-#endif /* !Py_ASDL_H */
diff --git a/pythonsdk/include/ast.h b/pythonsdk/include/ast.h
deleted file mode 100644
index 0c4bd7d0ebcf96d643b72fadc00ebf579a8919a0..0000000000000000000000000000000000000000
--- a/pythonsdk/include/ast.h
+++ /dev/null
@@ -1,29 +0,0 @@
-#ifndef Py_AST_H
-#define Py_AST_H
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-PyAPI_FUNC(int) PyAST_Validate(mod_ty);
-PyAPI_FUNC(mod_ty) PyAST_FromNode(
- const node *n,
- PyCompilerFlags *flags,
- const char *filename, /* decoded from the filesystem encoding */
- PyArena *arena);
-PyAPI_FUNC(mod_ty) PyAST_FromNodeObject(
- const node *n,
- PyCompilerFlags *flags,
- PyObject *filename,
- PyArena *arena);
-
-#ifndef Py_LIMITED_API
-
-/* _PyAST_ExprAsUnicode is defined in ast_unparse.c */
-PyAPI_FUNC(PyObject *) _PyAST_ExprAsUnicode(expr_ty);
-
-#endif /* !Py_LIMITED_API */
-
-#ifdef __cplusplus
-}
-#endif
-#endif /* !Py_AST_H */
diff --git a/pythonsdk/include/bitset.h b/pythonsdk/include/bitset.h
deleted file mode 100644
index 005eca14558d5f25e1898f681a027b261703d86f..0000000000000000000000000000000000000000
--- a/pythonsdk/include/bitset.h
+++ /dev/null
@@ -1,32 +0,0 @@
-
-#ifndef Py_BITSET_H
-#define Py_BITSET_H
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-/* Bitset interface */
-
-#define BYTE char
-
-typedef BYTE *bitset;
-
-bitset newbitset(int nbits);
-void delbitset(bitset bs);
-#define testbit(ss, ibit) (((ss)[BIT2BYTE(ibit)] & BIT2MASK(ibit)) != 0)
-int addbit(bitset bs, int ibit); /* Returns 0 if already set */
-int samebitset(bitset bs1, bitset bs2, int nbits);
-void mergebitset(bitset bs1, bitset bs2, int nbits);
-
-#define BITSPERBYTE (8*sizeof(BYTE))
-#define NBYTES(nbits) (((nbits) + BITSPERBYTE - 1) / BITSPERBYTE)
-
-#define BIT2BYTE(ibit) ((ibit) / BITSPERBYTE)
-#define BIT2SHIFT(ibit) ((ibit) % BITSPERBYTE)
-#define BIT2MASK(ibit) (1 << BIT2SHIFT(ibit))
-#define BYTE2BIT(ibyte) ((ibyte) * BITSPERBYTE)
-
-#ifdef __cplusplus
-}
-#endif
-#endif /* !Py_BITSET_H */
diff --git a/pythonsdk/include/bltinmodule.h b/pythonsdk/include/bltinmodule.h
deleted file mode 100644
index c04aceaaa644080d399dbb9db9a3e42277e3421e..0000000000000000000000000000000000000000
--- a/pythonsdk/include/bltinmodule.h
+++ /dev/null
@@ -1,14 +0,0 @@
-#ifndef Py_BLTINMODULE_H
-#define Py_BLTINMODULE_H
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-PyAPI_DATA(PyTypeObject) PyFilter_Type;
-PyAPI_DATA(PyTypeObject) PyMap_Type;
-PyAPI_DATA(PyTypeObject) PyZip_Type;
-
-#ifdef __cplusplus
-}
-#endif
-#endif /* !Py_BLTINMODULE_H */
diff --git a/pythonsdk/include/boolobject.h b/pythonsdk/include/boolobject.h
deleted file mode 100644
index 79501fd9578bdb047acd4cb854b9db49f24b1c8a..0000000000000000000000000000000000000000
--- a/pythonsdk/include/boolobject.h
+++ /dev/null
@@ -1,34 +0,0 @@
-/* Boolean object interface */
-
-#ifndef Py_BOOLOBJECT_H
-#define Py_BOOLOBJECT_H
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-
-PyAPI_DATA(PyTypeObject) PyBool_Type;
-
-#define PyBool_Check(x) (Py_TYPE(x) == &PyBool_Type)
-
-/* Py_False and Py_True are the only two bools in existence.
-Don't forget to apply Py_INCREF() when returning either!!! */
-
-/* Don't use these directly */
-PyAPI_DATA(struct _longobject) _Py_FalseStruct, _Py_TrueStruct;
-
-/* Use these macros */
-#define Py_False ((PyObject *) &_Py_FalseStruct)
-#define Py_True ((PyObject *) &_Py_TrueStruct)
-
-/* Macros for returning Py_True or Py_False, respectively */
-#define Py_RETURN_TRUE return Py_INCREF(Py_True), Py_True
-#define Py_RETURN_FALSE return Py_INCREF(Py_False), Py_False
-
-/* Function to return a bool from a C long */
-PyAPI_FUNC(PyObject *) PyBool_FromLong(long);
-
-#ifdef __cplusplus
-}
-#endif
-#endif /* !Py_BOOLOBJECT_H */
diff --git a/pythonsdk/include/bytearrayobject.h b/pythonsdk/include/bytearrayobject.h
deleted file mode 100644
index 0d93e06b9bb188bcb559f09ce97a34eeb4c1ca57..0000000000000000000000000000000000000000
--- a/pythonsdk/include/bytearrayobject.h
+++ /dev/null
@@ -1,62 +0,0 @@
-/* ByteArray object interface */
-
-#ifndef Py_BYTEARRAYOBJECT_H
-#define Py_BYTEARRAYOBJECT_H
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-#include <stdarg.h>
-
-/* Type PyByteArrayObject represents a mutable array of bytes.
- * The Python API is that of a sequence;
- * the bytes are mapped to ints in [0, 256).
- * Bytes are not characters; they may be used to encode characters.
- * The only way to go between bytes and str/unicode is via encoding
- * and decoding.
- * For the convenience of C programmers, the bytes type is considered
- * to contain a char pointer, not an unsigned char pointer.
- */
-
-/* Object layout */
-#ifndef Py_LIMITED_API
-typedef struct {
- PyObject_VAR_HEAD
- Py_ssize_t ob_alloc; /* How many bytes allocated in ob_bytes */
- char *ob_bytes; /* Physical backing buffer */
- char *ob_start; /* Logical start inside ob_bytes */
- /* XXX(nnorwitz): should ob_exports be Py_ssize_t? */
- int ob_exports; /* How many buffer exports */
-} PyByteArrayObject;
-#endif
-
-/* Type object */
-PyAPI_DATA(PyTypeObject) PyByteArray_Type;
-PyAPI_DATA(PyTypeObject) PyByteArrayIter_Type;
-
-/* Type check macros */
-#define PyByteArray_Check(self) PyObject_TypeCheck(self, &PyByteArray_Type)
-#define PyByteArray_CheckExact(self) (Py_TYPE(self) == &PyByteArray_Type)
-
-/* Direct API functions */
-PyAPI_FUNC(PyObject *) PyByteArray_FromObject(PyObject *);
-PyAPI_FUNC(PyObject *) PyByteArray_Concat(PyObject *, PyObject *);
-PyAPI_FUNC(PyObject *) PyByteArray_FromStringAndSize(const char *, Py_ssize_t);
-PyAPI_FUNC(Py_ssize_t) PyByteArray_Size(PyObject *);
-PyAPI_FUNC(char *) PyByteArray_AsString(PyObject *);
-PyAPI_FUNC(int) PyByteArray_Resize(PyObject *, Py_ssize_t);
-
-/* Macros, trading safety for speed */
-#ifndef Py_LIMITED_API
-#define PyByteArray_AS_STRING(self) \
- (assert(PyByteArray_Check(self)), \
- Py_SIZE(self) ? ((PyByteArrayObject *)(self))->ob_start : _PyByteArray_empty_string)
-#define PyByteArray_GET_SIZE(self) (assert(PyByteArray_Check(self)), Py_SIZE(self))
-
-PyAPI_DATA(char) _PyByteArray_empty_string[];
-#endif
-
-#ifdef __cplusplus
-}
-#endif
-#endif /* !Py_BYTEARRAYOBJECT_H */
diff --git a/pythonsdk/include/bytes_methods.h b/pythonsdk/include/bytes_methods.h
deleted file mode 100644
index ba3d12f0692df27f6ae6847aefe7775d7035883d..0000000000000000000000000000000000000000
--- a/pythonsdk/include/bytes_methods.h
+++ /dev/null
@@ -1,69 +0,0 @@
-#ifndef Py_LIMITED_API
-#ifndef Py_BYTES_CTYPE_H
-#define Py_BYTES_CTYPE_H
-
-/*
- * The internal implementation behind PyBytes (bytes) and PyByteArray (bytearray)
- * methods of the given names, they operate on ASCII byte strings.
- */
-extern PyObject* _Py_bytes_isspace(const char *cptr, Py_ssize_t len);
-extern PyObject* _Py_bytes_isalpha(const char *cptr, Py_ssize_t len);
-extern PyObject* _Py_bytes_isalnum(const char *cptr, Py_ssize_t len);
-extern PyObject* _Py_bytes_isascii(const char *cptr, Py_ssize_t len);
-extern PyObject* _Py_bytes_isdigit(const char *cptr, Py_ssize_t len);
-extern PyObject* _Py_bytes_islower(const char *cptr, Py_ssize_t len);
-extern PyObject* _Py_bytes_isupper(const char *cptr, Py_ssize_t len);
-extern PyObject* _Py_bytes_istitle(const char *cptr, Py_ssize_t len);
-
-/* These store their len sized answer in the given preallocated *result arg. */
-extern void _Py_bytes_lower(char *result, const char *cptr, Py_ssize_t len);
-extern void _Py_bytes_upper(char *result, const char *cptr, Py_ssize_t len);
-extern void _Py_bytes_title(char *result, const char *s, Py_ssize_t len);
-extern void _Py_bytes_capitalize(char *result, const char *s, Py_ssize_t len);
-extern void _Py_bytes_swapcase(char *result, const char *s, Py_ssize_t len);
-
-extern PyObject *_Py_bytes_find(const char *str, Py_ssize_t len, PyObject *args);
-extern PyObject *_Py_bytes_index(const char *str, Py_ssize_t len, PyObject *args);
-extern PyObject *_Py_bytes_rfind(const char *str, Py_ssize_t len, PyObject *args);
-extern PyObject *_Py_bytes_rindex(const char *str, Py_ssize_t len, PyObject *args);
-extern PyObject *_Py_bytes_count(const char *str, Py_ssize_t len, PyObject *args);
-extern int _Py_bytes_contains(const char *str, Py_ssize_t len, PyObject *arg);
-extern PyObject *_Py_bytes_startswith(const char *str, Py_ssize_t len, PyObject *args);
-extern PyObject *_Py_bytes_endswith(const char *str, Py_ssize_t len, PyObject *args);
-
-/* The maketrans() static method. */
-extern PyObject* _Py_bytes_maketrans(Py_buffer *frm, Py_buffer *to);
-
-/* Shared __doc__ strings. */
-extern const char _Py_isspace__doc__[];
-extern const char _Py_isalpha__doc__[];
-extern const char _Py_isalnum__doc__[];
-extern const char _Py_isascii__doc__[];
-extern const char _Py_isdigit__doc__[];
-extern const char _Py_islower__doc__[];
-extern const char _Py_isupper__doc__[];
-extern const char _Py_istitle__doc__[];
-extern const char _Py_lower__doc__[];
-extern const char _Py_upper__doc__[];
-extern const char _Py_title__doc__[];
-extern const char _Py_capitalize__doc__[];
-extern const char _Py_swapcase__doc__[];
-extern const char _Py_count__doc__[];
-extern const char _Py_find__doc__[];
-extern const char _Py_index__doc__[];
-extern const char _Py_rfind__doc__[];
-extern const char _Py_rindex__doc__[];
-extern const char _Py_startswith__doc__[];
-extern const char _Py_endswith__doc__[];
-extern const char _Py_maketrans__doc__[];
-extern const char _Py_expandtabs__doc__[];
-extern const char _Py_ljust__doc__[];
-extern const char _Py_rjust__doc__[];
-extern const char _Py_center__doc__[];
-extern const char _Py_zfill__doc__[];
-
-/* this is needed because some docs are shared from the .o, not static */
-#define PyDoc_STRVAR_shared(name,str) const char name[] = PyDoc_STR(str)
-
-#endif /* !Py_BYTES_CTYPE_H */
-#endif /* !Py_LIMITED_API */
diff --git a/pythonsdk/include/bytesobject.h b/pythonsdk/include/bytesobject.h
deleted file mode 100644
index fd08ba6efec54466cbeccd160731c32beb5d8e1a..0000000000000000000000000000000000000000
--- a/pythonsdk/include/bytesobject.h
+++ /dev/null
@@ -1,224 +0,0 @@
-
-/* Bytes (String) object interface */
-
-#ifndef Py_BYTESOBJECT_H
-#define Py_BYTESOBJECT_H
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-#include <stdarg.h>
-
-/*
-Type PyBytesObject represents a character string. An extra zero byte is
-reserved at the end to ensure it is zero-terminated, but a size is
-present so strings with null bytes in them can be represented. This
-is an immutable object type.
-
-There are functions to create new string objects, to test
-an object for string-ness, and to get the
-string value. The latter function returns a null pointer
-if the object is not of the proper type.
-There is a variant that takes an explicit size as well as a
-variant that assumes a zero-terminated string. Note that none of the
-functions should be applied to nil objects.
-*/
-
-/* Caching the hash (ob_shash) saves recalculation of a string's hash value.
- This significantly speeds up dict lookups. */
-
-#ifndef Py_LIMITED_API
-typedef struct {
- PyObject_VAR_HEAD
- Py_hash_t ob_shash;
- char ob_sval[1];
-
- /* Invariants:
- * ob_sval contains space for 'ob_size+1' elements.
- * ob_sval[ob_size] == 0.
- * ob_shash is the hash of the string or -1 if not computed yet.
- */
-} PyBytesObject;
-#endif
-
-PyAPI_DATA(PyTypeObject) PyBytes_Type;
-PyAPI_DATA(PyTypeObject) PyBytesIter_Type;
-
-#define PyBytes_Check(op) \
- PyType_FastSubclass(Py_TYPE(op), Py_TPFLAGS_BYTES_SUBCLASS)
-#define PyBytes_CheckExact(op) (Py_TYPE(op) == &PyBytes_Type)
-
-PyAPI_FUNC(PyObject *) PyBytes_FromStringAndSize(const char *, Py_ssize_t);
-PyAPI_FUNC(PyObject *) PyBytes_FromString(const char *);
-PyAPI_FUNC(PyObject *) PyBytes_FromObject(PyObject *);
-PyAPI_FUNC(PyObject *) PyBytes_FromFormatV(const char*, va_list)
- Py_GCC_ATTRIBUTE((format(printf, 1, 0)));
-PyAPI_FUNC(PyObject *) PyBytes_FromFormat(const char*, ...)
- Py_GCC_ATTRIBUTE((format(printf, 1, 2)));
-PyAPI_FUNC(Py_ssize_t) PyBytes_Size(PyObject *);
-PyAPI_FUNC(char *) PyBytes_AsString(PyObject *);
-PyAPI_FUNC(PyObject *) PyBytes_Repr(PyObject *, int);
-PyAPI_FUNC(void) PyBytes_Concat(PyObject **, PyObject *);
-PyAPI_FUNC(void) PyBytes_ConcatAndDel(PyObject **, PyObject *);
-#ifndef Py_LIMITED_API
-PyAPI_FUNC(int) _PyBytes_Resize(PyObject **, Py_ssize_t);
-PyAPI_FUNC(PyObject*) _PyBytes_FormatEx(
- const char *format,
- Py_ssize_t format_len,
- PyObject *args,
- int use_bytearray);
-PyAPI_FUNC(PyObject*) _PyBytes_FromHex(
- PyObject *string,
- int use_bytearray);
-#endif
-PyAPI_FUNC(PyObject *) PyBytes_DecodeEscape(const char *, Py_ssize_t,
- const char *, Py_ssize_t,
- const char *);
-#ifndef Py_LIMITED_API
-/* Helper for PyBytes_DecodeEscape that detects invalid escape chars. */
-PyAPI_FUNC(PyObject *) _PyBytes_DecodeEscape(const char *, Py_ssize_t,
- const char *, Py_ssize_t,
- const char *,
- const char **);
-#endif
-
-/* Macro, trading safety for speed */
-#ifndef Py_LIMITED_API
-#define PyBytes_AS_STRING(op) (assert(PyBytes_Check(op)), \
- (((PyBytesObject *)(op))->ob_sval))
-#define PyBytes_GET_SIZE(op) (assert(PyBytes_Check(op)),Py_SIZE(op))
-#endif
-
-/* _PyBytes_Join(sep, x) is like sep.join(x). sep must be PyBytesObject*,
- x must be an iterable object. */
-#ifndef Py_LIMITED_API
-PyAPI_FUNC(PyObject *) _PyBytes_Join(PyObject *sep, PyObject *x);
-#endif
-
-/* Provides access to the internal data buffer and size of a string
- object or the default encoded version of a Unicode object. Passing
- NULL as *len parameter will force the string buffer to be
- 0-terminated (passing a string with embedded NULL characters will
- cause an exception). */
-PyAPI_FUNC(int) PyBytes_AsStringAndSize(
- PyObject *obj, /* string or Unicode object */
- char **s, /* pointer to buffer variable */
- Py_ssize_t *len /* pointer to length variable or NULL
- (only possible for 0-terminated
- strings) */
- );
-
-/* Using the current locale, insert the thousands grouping
- into the string pointed to by buffer. For the argument descriptions,
- see Objects/stringlib/localeutil.h */
-#ifndef Py_LIMITED_API
-PyAPI_FUNC(Py_ssize_t) _PyBytes_InsertThousandsGroupingLocale(char *buffer,
- Py_ssize_t n_buffer,
- char *digits,
- Py_ssize_t n_digits,
- Py_ssize_t min_width);
-
-/* Using explicit passed-in values, insert the thousands grouping
- into the string pointed to by buffer. For the argument descriptions,
- see Objects/stringlib/localeutil.h */
-PyAPI_FUNC(Py_ssize_t) _PyBytes_InsertThousandsGrouping(char *buffer,
- Py_ssize_t n_buffer,
- char *digits,
- Py_ssize_t n_digits,
- Py_ssize_t min_width,
- const char *grouping,
- const char *thousands_sep);
-#endif
-
-/* Flags used by string formatting */
-#define F_LJUST (1<<0)
-#define F_SIGN (1<<1)
-#define F_BLANK (1<<2)
-#define F_ALT (1<<3)
-#define F_ZERO (1<<4)
-
-#ifndef Py_LIMITED_API
-/* The _PyBytesWriter structure is big: it contains an embedded "stack buffer".
- A _PyBytesWriter variable must be declared at the end of variables in a
- function to optimize the memory allocation on the stack. */
-typedef struct {
- /* bytes, bytearray or NULL (when the small buffer is used) */
- PyObject *buffer;
-
- /* Number of allocated size. */
- Py_ssize_t allocated;
-
- /* Minimum number of allocated bytes,
- incremented by _PyBytesWriter_Prepare() */
- Py_ssize_t min_size;
-
- /* If non-zero, use a bytearray instead of a bytes object for buffer. */
- int use_bytearray;
-
- /* If non-zero, overallocate the buffer (default: 0).
- This flag must be zero if use_bytearray is non-zero. */
- int overallocate;
-
- /* Stack buffer */
- int use_small_buffer;
- char small_buffer[512];
-} _PyBytesWriter;
-
-/* Initialize a bytes writer
-
- By default, the overallocation is disabled. Set the overallocate attribute
- to control the allocation of the buffer. */
-PyAPI_FUNC(void) _PyBytesWriter_Init(_PyBytesWriter *writer);
-
-/* Get the buffer content and reset the writer.
- Return a bytes object, or a bytearray object if use_bytearray is non-zero.
- Raise an exception and return NULL on error. */
-PyAPI_FUNC(PyObject *) _PyBytesWriter_Finish(_PyBytesWriter *writer,
- void *str);
-
-/* Deallocate memory of a writer (clear its internal buffer). */
-PyAPI_FUNC(void) _PyBytesWriter_Dealloc(_PyBytesWriter *writer);
-
-/* Allocate the buffer to write size bytes.
- Return the pointer to the beginning of buffer data.
- Raise an exception and return NULL on error. */
-PyAPI_FUNC(void*) _PyBytesWriter_Alloc(_PyBytesWriter *writer,
- Py_ssize_t size);
-
-/* Ensure that the buffer is large enough to write *size* bytes.
- Add size to the writer minimum size (min_size attribute).
-
- str is the current pointer inside the buffer.
- Return the updated current pointer inside the buffer.
- Raise an exception and return NULL on error. */
-PyAPI_FUNC(void*) _PyBytesWriter_Prepare(_PyBytesWriter *writer,
- void *str,
- Py_ssize_t size);
-
-/* Resize the buffer to make it larger.
- The new buffer may be larger than size bytes because of overallocation.
- Return the updated current pointer inside the buffer.
- Raise an exception and return NULL on error.
-
- Note: size must be greater than the number of allocated bytes in the writer.
-
- This function doesn't use the writer minimum size (min_size attribute).
-
- See also _PyBytesWriter_Prepare().
- */
-PyAPI_FUNC(void*) _PyBytesWriter_Resize(_PyBytesWriter *writer,
- void *str,
- Py_ssize_t size);
-
-/* Write bytes.
- Raise an exception and return NULL on error. */
-PyAPI_FUNC(void*) _PyBytesWriter_WriteBytes(_PyBytesWriter *writer,
- void *str,
- const void *bytes,
- Py_ssize_t size);
-#endif /* Py_LIMITED_API */
-
-#ifdef __cplusplus
-}
-#endif
-#endif /* !Py_BYTESOBJECT_H */
diff --git a/pythonsdk/include/cellobject.h b/pythonsdk/include/cellobject.h
deleted file mode 100644
index d38bf1308bc8af257eeee230700899cac5ba5ac7..0000000000000000000000000000000000000000
--- a/pythonsdk/include/cellobject.h
+++ /dev/null
@@ -1,29 +0,0 @@
-/* Cell object interface */
-#ifndef Py_LIMITED_API
-#ifndef Py_CELLOBJECT_H
-#define Py_CELLOBJECT_H
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-typedef struct {
- PyObject_HEAD
- PyObject *ob_ref; /* Content of the cell or NULL when empty */
-} PyCellObject;
-
-PyAPI_DATA(PyTypeObject) PyCell_Type;
-
-#define PyCell_Check(op) (Py_TYPE(op) == &PyCell_Type)
-
-PyAPI_FUNC(PyObject *) PyCell_New(PyObject *);
-PyAPI_FUNC(PyObject *) PyCell_Get(PyObject *);
-PyAPI_FUNC(int) PyCell_Set(PyObject *, PyObject *);
-
-#define PyCell_GET(op) (((PyCellObject *)(op))->ob_ref)
-#define PyCell_SET(op, v) (((PyCellObject *)(op))->ob_ref = v)
-
-#ifdef __cplusplus
-}
-#endif
-#endif /* !Py_TUPLEOBJECT_H */
-#endif /* Py_LIMITED_API */
diff --git a/pythonsdk/include/ceval.h b/pythonsdk/include/ceval.h
deleted file mode 100644
index 819bccfb2edc52ca25ffc1d97a41c2bc17cf4c5e..0000000000000000000000000000000000000000
--- a/pythonsdk/include/ceval.h
+++ /dev/null
@@ -1,239 +0,0 @@
-#ifndef Py_CEVAL_H
-#define Py_CEVAL_H
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-
-/* Interface to random parts in ceval.c */
-
-/* PyEval_CallObjectWithKeywords(), PyEval_CallObject(), PyEval_CallFunction
- * and PyEval_CallMethod are kept for backward compatibility: PyObject_Call(),
- * PyObject_CallFunction() and PyObject_CallMethod() are recommended to call
- * a callable object.
- */
-
-PyAPI_FUNC(PyObject *) PyEval_CallObjectWithKeywords(
- PyObject *callable,
- PyObject *args,
- PyObject *kwargs);
-
-/* Inline this */
-#define PyEval_CallObject(callable, arg) \
- PyEval_CallObjectWithKeywords(callable, arg, (PyObject *)NULL)
-
-PyAPI_FUNC(PyObject *) PyEval_CallFunction(PyObject *callable,
- const char *format, ...);
-PyAPI_FUNC(PyObject *) PyEval_CallMethod(PyObject *obj,
- const char *name,
- const char *format, ...);
-
-#ifndef Py_LIMITED_API
-PyAPI_FUNC(void) PyEval_SetProfile(Py_tracefunc, PyObject *);
-PyAPI_FUNC(void) PyEval_SetTrace(Py_tracefunc, PyObject *);
-PyAPI_FUNC(void) _PyEval_SetCoroutineOriginTrackingDepth(int new_depth);
-PyAPI_FUNC(int) _PyEval_GetCoroutineOriginTrackingDepth(void);
-PyAPI_FUNC(void) _PyEval_SetCoroutineWrapper(PyObject *);
-PyAPI_FUNC(PyObject *) _PyEval_GetCoroutineWrapper(void);
-PyAPI_FUNC(void) _PyEval_SetAsyncGenFirstiter(PyObject *);
-PyAPI_FUNC(PyObject *) _PyEval_GetAsyncGenFirstiter(void);
-PyAPI_FUNC(void) _PyEval_SetAsyncGenFinalizer(PyObject *);
-PyAPI_FUNC(PyObject *) _PyEval_GetAsyncGenFinalizer(void);
-#endif
-
-struct _frame; /* Avoid including frameobject.h */
-
-PyAPI_FUNC(PyObject *) PyEval_GetBuiltins(void);
-PyAPI_FUNC(PyObject *) PyEval_GetGlobals(void);
-PyAPI_FUNC(PyObject *) PyEval_GetLocals(void);
-PyAPI_FUNC(struct _frame *) PyEval_GetFrame(void);
-
-#ifndef Py_LIMITED_API
-/* Helper to look up a builtin object */
-PyAPI_FUNC(PyObject *) _PyEval_GetBuiltinId(_Py_Identifier *);
-/* Look at the current frame's (if any) code's co_flags, and turn on
- the corresponding compiler flags in cf->cf_flags. Return 1 if any
- flag was set, else return 0. */
-PyAPI_FUNC(int) PyEval_MergeCompilerFlags(PyCompilerFlags *cf);
-#endif
-
-PyAPI_FUNC(int) Py_AddPendingCall(int (*func)(void *), void *arg);
-PyAPI_FUNC(void) _PyEval_SignalReceived(void);
-PyAPI_FUNC(int) Py_MakePendingCalls(void);
-
-/* Protection against deeply nested recursive calls
-
- In Python 3.0, this protection has two levels:
- * normal anti-recursion protection is triggered when the recursion level
- exceeds the current recursion limit. It raises a RecursionError, and sets
- the "overflowed" flag in the thread state structure. This flag
- temporarily *disables* the normal protection; this allows cleanup code
- to potentially outgrow the recursion limit while processing the
- RecursionError.
- * "last chance" anti-recursion protection is triggered when the recursion
- level exceeds "current recursion limit + 50". By construction, this
- protection can only be triggered when the "overflowed" flag is set. It
- means the cleanup code has itself gone into an infinite loop, or the
- RecursionError has been mistakingly ignored. When this protection is
- triggered, the interpreter aborts with a Fatal Error.
-
- In addition, the "overflowed" flag is automatically reset when the
- recursion level drops below "current recursion limit - 50". This heuristic
- is meant to ensure that the normal anti-recursion protection doesn't get
- disabled too long.
-
- Please note: this scheme has its own limitations. See:
- http://mail.python.org/pipermail/python-dev/2008-August/082106.html
- for some observations.
-*/
-PyAPI_FUNC(void) Py_SetRecursionLimit(int);
-PyAPI_FUNC(int) Py_GetRecursionLimit(void);
-
-#define Py_EnterRecursiveCall(where) \
- (_Py_MakeRecCheck(PyThreadState_GET()->recursion_depth) && \
- _Py_CheckRecursiveCall(where))
-#define Py_LeaveRecursiveCall() \
- do{ if(_Py_MakeEndRecCheck(PyThreadState_GET()->recursion_depth)) \
- PyThreadState_GET()->overflowed = 0; \
- } while(0)
-PyAPI_FUNC(int) _Py_CheckRecursiveCall(const char *where);
-
-/* Due to the macros in which it's used, _Py_CheckRecursionLimit is in
- the stable ABI. It should be removed therefrom when possible.
-*/
-PyAPI_DATA(int) _Py_CheckRecursionLimit;
-
-#ifdef USE_STACKCHECK
-/* With USE_STACKCHECK, trigger stack checks in _Py_CheckRecursiveCall()
- on every 64th call to Py_EnterRecursiveCall.
-*/
-# define _Py_MakeRecCheck(x) \
- (++(x) > _Py_CheckRecursionLimit || \
- ++(PyThreadState_GET()->stackcheck_counter) > 64)
-#else
-# define _Py_MakeRecCheck(x) (++(x) > _Py_CheckRecursionLimit)
-#endif
-
-/* Compute the "lower-water mark" for a recursion limit. When
- * Py_LeaveRecursiveCall() is called with a recursion depth below this mark,
- * the overflowed flag is reset to 0. */
-#define _Py_RecursionLimitLowerWaterMark(limit) \
- (((limit) > 200) \
- ? ((limit) - 50) \
- : (3 * ((limit) >> 2)))
-
-#define _Py_MakeEndRecCheck(x) \
- (--(x) < _Py_RecursionLimitLowerWaterMark(_Py_CheckRecursionLimit))
-
-#define Py_ALLOW_RECURSION \
- do { unsigned char _old = PyThreadState_GET()->recursion_critical;\
- PyThreadState_GET()->recursion_critical = 1;
-
-#define Py_END_ALLOW_RECURSION \
- PyThreadState_GET()->recursion_critical = _old; \
- } while(0);
-
-PyAPI_FUNC(const char *) PyEval_GetFuncName(PyObject *);
-PyAPI_FUNC(const char *) PyEval_GetFuncDesc(PyObject *);
-
-PyAPI_FUNC(PyObject *) PyEval_EvalFrame(struct _frame *);
-PyAPI_FUNC(PyObject *) PyEval_EvalFrameEx(struct _frame *f, int exc);
-#ifndef Py_LIMITED_API
-PyAPI_FUNC(PyObject *) _PyEval_EvalFrameDefault(struct _frame *f, int exc);
-#endif
-
-/* Interface for threads.
-
- A module that plans to do a blocking system call (or something else
- that lasts a long time and doesn't touch Python data) can allow other
- threads to run as follows:
-
- ...preparations here...
- Py_BEGIN_ALLOW_THREADS
- ...blocking system call here...
- Py_END_ALLOW_THREADS
- ...interpret result here...
-
- The Py_BEGIN_ALLOW_THREADS/Py_END_ALLOW_THREADS pair expands to a
- {}-surrounded block.
- To leave the block in the middle (e.g., with return), you must insert
- a line containing Py_BLOCK_THREADS before the return, e.g.
-
- if (...premature_exit...) {
- Py_BLOCK_THREADS
- PyErr_SetFromErrno(PyExc_OSError);
- return NULL;
- }
-
- An alternative is:
-
- Py_BLOCK_THREADS
- if (...premature_exit...) {
- PyErr_SetFromErrno(PyExc_OSError);
- return NULL;
- }
- Py_UNBLOCK_THREADS
-
- For convenience, that the value of 'errno' is restored across
- Py_END_ALLOW_THREADS and Py_BLOCK_THREADS.
-
- WARNING: NEVER NEST CALLS TO Py_BEGIN_ALLOW_THREADS AND
- Py_END_ALLOW_THREADS!!!
-
- The function PyEval_InitThreads() should be called only from
- init_thread() in "_threadmodule.c".
-
- Note that not yet all candidates have been converted to use this
- mechanism!
-*/
-
-PyAPI_FUNC(PyThreadState *) PyEval_SaveThread(void);
-PyAPI_FUNC(void) PyEval_RestoreThread(PyThreadState *);
-
-PyAPI_FUNC(int) PyEval_ThreadsInitialized(void);
-PyAPI_FUNC(void) PyEval_InitThreads(void);
-#ifndef Py_LIMITED_API
-PyAPI_FUNC(void) _PyEval_FiniThreads(void);
-#endif /* !Py_LIMITED_API */
-PyAPI_FUNC(void) PyEval_AcquireLock(void) Py_DEPRECATED(3.2);
-PyAPI_FUNC(void) PyEval_ReleaseLock(void) /* Py_DEPRECATED(3.2) */;
-PyAPI_FUNC(void) PyEval_AcquireThread(PyThreadState *tstate);
-PyAPI_FUNC(void) PyEval_ReleaseThread(PyThreadState *tstate);
-PyAPI_FUNC(void) PyEval_ReInitThreads(void);
-
-#ifndef Py_LIMITED_API
-PyAPI_FUNC(void) _PyEval_SetSwitchInterval(unsigned long microseconds);
-PyAPI_FUNC(unsigned long) _PyEval_GetSwitchInterval(void);
-#endif
-
-#ifndef Py_LIMITED_API
-PyAPI_FUNC(Py_ssize_t) _PyEval_RequestCodeExtraIndex(freefunc);
-#endif
-
-#define Py_BEGIN_ALLOW_THREADS { \
- PyThreadState *_save; \
- _save = PyEval_SaveThread();
-#define Py_BLOCK_THREADS PyEval_RestoreThread(_save);
-#define Py_UNBLOCK_THREADS _save = PyEval_SaveThread();
-#define Py_END_ALLOW_THREADS PyEval_RestoreThread(_save); \
- }
-
-#ifndef Py_LIMITED_API
-PyAPI_FUNC(int) _PyEval_SliceIndex(PyObject *, Py_ssize_t *);
-PyAPI_FUNC(int) _PyEval_SliceIndexNotNone(PyObject *, Py_ssize_t *);
-PyAPI_FUNC(void) _PyEval_SignalAsyncExc(void);
-#endif
-
-/* Masks and values used by FORMAT_VALUE opcode. */
-#define FVC_MASK 0x3
-#define FVC_NONE 0x0
-#define FVC_STR 0x1
-#define FVC_REPR 0x2
-#define FVC_ASCII 0x3
-#define FVS_MASK 0x4
-#define FVS_HAVE_SPEC 0x4
-
-#ifdef __cplusplus
-}
-#endif
-#endif /* !Py_CEVAL_H */
diff --git a/pythonsdk/include/classobject.h b/pythonsdk/include/classobject.h
deleted file mode 100644
index f0a0255cec9f0c432a67b0d578739e338ca426a6..0000000000000000000000000000000000000000
--- a/pythonsdk/include/classobject.h
+++ /dev/null
@@ -1,58 +0,0 @@
-/* Former class object interface -- now only bound methods are here */
-
-/* Revealing some structures (not for general use) */
-
-#ifndef Py_LIMITED_API
-#ifndef Py_CLASSOBJECT_H
-#define Py_CLASSOBJECT_H
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-typedef struct {
- PyObject_HEAD
- PyObject *im_func; /* The callable object implementing the method */
- PyObject *im_self; /* The instance it is bound to */
- PyObject *im_weakreflist; /* List of weak references */
-} PyMethodObject;
-
-PyAPI_DATA(PyTypeObject) PyMethod_Type;
-
-#define PyMethod_Check(op) ((op)->ob_type == &PyMethod_Type)
-
-PyAPI_FUNC(PyObject *) PyMethod_New(PyObject *, PyObject *);
-
-PyAPI_FUNC(PyObject *) PyMethod_Function(PyObject *);
-PyAPI_FUNC(PyObject *) PyMethod_Self(PyObject *);
-
-/* Macros for direct access to these values. Type checks are *not*
- done, so use with care. */
-#define PyMethod_GET_FUNCTION(meth) \
- (((PyMethodObject *)meth) -> im_func)
-#define PyMethod_GET_SELF(meth) \
- (((PyMethodObject *)meth) -> im_self)
-
-PyAPI_FUNC(int) PyMethod_ClearFreeList(void);
-
-typedef struct {
- PyObject_HEAD
- PyObject *func;
-} PyInstanceMethodObject;
-
-PyAPI_DATA(PyTypeObject) PyInstanceMethod_Type;
-
-#define PyInstanceMethod_Check(op) ((op)->ob_type == &PyInstanceMethod_Type)
-
-PyAPI_FUNC(PyObject *) PyInstanceMethod_New(PyObject *);
-PyAPI_FUNC(PyObject *) PyInstanceMethod_Function(PyObject *);
-
-/* Macros for direct access to these values. Type checks are *not*
- done, so use with care. */
-#define PyInstanceMethod_GET_FUNCTION(meth) \
- (((PyInstanceMethodObject *)meth) -> func)
-
-#ifdef __cplusplus
-}
-#endif
-#endif /* !Py_CLASSOBJECT_H */
-#endif /* Py_LIMITED_API */
diff --git a/pythonsdk/include/code.h b/pythonsdk/include/code.h
deleted file mode 100644
index 811a9d333479a01907244c84ed293a809283a17d..0000000000000000000000000000000000000000
--- a/pythonsdk/include/code.h
+++ /dev/null
@@ -1,157 +0,0 @@
-/* Definitions for bytecode */
-
-#ifndef Py_LIMITED_API
-#ifndef Py_CODE_H
-#define Py_CODE_H
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-typedef uint16_t _Py_CODEUNIT;
-
-#ifdef WORDS_BIGENDIAN
-# define _Py_OPCODE(word) ((word) >> 8)
-# define _Py_OPARG(word) ((word) & 255)
-#else
-# define _Py_OPCODE(word) ((word) & 255)
-# define _Py_OPARG(word) ((word) >> 8)
-#endif
-
-/* Bytecode object */
-typedef struct {
- PyObject_HEAD
- int co_argcount; /* #arguments, except *args */
- int co_kwonlyargcount; /* #keyword only arguments */
- int co_nlocals; /* #local variables */
- int co_stacksize; /* #entries needed for evaluation stack */
- int co_flags; /* CO_..., see below */
- int co_firstlineno; /* first source line number */
- PyObject *co_code; /* instruction opcodes */
- PyObject *co_consts; /* list (constants used) */
- PyObject *co_names; /* list of strings (names used) */
- PyObject *co_varnames; /* tuple of strings (local variable names) */
- PyObject *co_freevars; /* tuple of strings (free variable names) */
- PyObject *co_cellvars; /* tuple of strings (cell variable names) */
- /* The rest aren't used in either hash or comparisons, except for co_name,
- used in both. This is done to preserve the name and line number
- for tracebacks and debuggers; otherwise, constant de-duplication
- would collapse identical functions/lambdas defined on different lines.
- */
- Py_ssize_t *co_cell2arg; /* Maps cell vars which are arguments. */
- PyObject *co_filename; /* unicode (where it was loaded from) */
- PyObject *co_name; /* unicode (name, for reference) */
- PyObject *co_lnotab; /* string (encoding addr<->lineno mapping) See
- Objects/lnotab_notes.txt for details. */
- void *co_zombieframe; /* for optimization only (see frameobject.c) */
- PyObject *co_weakreflist; /* to support weakrefs to code objects */
- /* Scratch space for extra data relating to the code object.
- Type is a void* to keep the format private in codeobject.c to force
- people to go through the proper APIs. */
- void *co_extra;
-} PyCodeObject;
-
-/* Masks for co_flags above */
-#define CO_OPTIMIZED 0x0001
-#define CO_NEWLOCALS 0x0002
-#define CO_VARARGS 0x0004
-#define CO_VARKEYWORDS 0x0008
-#define CO_NESTED 0x0010
-#define CO_GENERATOR 0x0020
-/* The CO_NOFREE flag is set if there are no free or cell variables.
- This information is redundant, but it allows a single flag test
- to determine whether there is any extra work to be done when the
- call frame it setup.
-*/
-#define CO_NOFREE 0x0040
-
-/* The CO_COROUTINE flag is set for coroutine functions (defined with
- ``async def`` keywords) */
-#define CO_COROUTINE 0x0080
-#define CO_ITERABLE_COROUTINE 0x0100
-#define CO_ASYNC_GENERATOR 0x0200
-
-/* These are no longer used. */
-#if 0
-#define CO_GENERATOR_ALLOWED 0x1000
-#endif
-#define CO_FUTURE_DIVISION 0x2000
-#define CO_FUTURE_ABSOLUTE_IMPORT 0x4000 /* do absolute imports by default */
-#define CO_FUTURE_WITH_STATEMENT 0x8000
-#define CO_FUTURE_PRINT_FUNCTION 0x10000
-#define CO_FUTURE_UNICODE_LITERALS 0x20000
-
-#define CO_FUTURE_BARRY_AS_BDFL 0x40000
-#define CO_FUTURE_GENERATOR_STOP 0x80000
-#define CO_FUTURE_ANNOTATIONS 0x100000
-
-/* This value is found in the co_cell2arg array when the associated cell
- variable does not correspond to an argument. */
-#define CO_CELL_NOT_AN_ARG (-1)
-
-/* This should be defined if a future statement modifies the syntax.
- For example, when a keyword is added.
-*/
-#define PY_PARSER_REQUIRES_FUTURE_KEYWORD
-
-#define CO_MAXBLOCKS 20 /* Max static block nesting within a function */
-
-PyAPI_DATA(PyTypeObject) PyCode_Type;
-
-#define PyCode_Check(op) (Py_TYPE(op) == &PyCode_Type)
-#define PyCode_GetNumFree(op) (PyTuple_GET_SIZE((op)->co_freevars))
-
-/* Public interface */
-PyAPI_FUNC(PyCodeObject *) PyCode_New(
- int, int, int, int, int, PyObject *, PyObject *,
- PyObject *, PyObject *, PyObject *, PyObject *,
- PyObject *, PyObject *, int, PyObject *);
- /* same as struct above */
-
-/* Creates a new empty code object with the specified source location. */
-PyAPI_FUNC(PyCodeObject *)
-PyCode_NewEmpty(const char *filename, const char *funcname, int firstlineno);
-
-/* Return the line number associated with the specified bytecode index
- in this code object. If you just need the line number of a frame,
- use PyFrame_GetLineNumber() instead. */
-PyAPI_FUNC(int) PyCode_Addr2Line(PyCodeObject *, int);
-
-/* for internal use only */
-typedef struct _addr_pair {
- int ap_lower;
- int ap_upper;
-} PyAddrPair;
-
-#ifndef Py_LIMITED_API
-/* Update *bounds to describe the first and one-past-the-last instructions in the
- same line as lasti. Return the number of that line.
-*/
-PyAPI_FUNC(int) _PyCode_CheckLineNumber(PyCodeObject* co,
- int lasti, PyAddrPair *bounds);
-
-/* Create a comparable key used to compare constants taking in account the
- * object type. It is used to make sure types are not coerced (e.g., float and
- * complex) _and_ to distinguish 0.0 from -0.0 e.g. on IEEE platforms
- *
- * Return (type(obj), obj, ...): a tuple with variable size (at least 2 items)
- * depending on the type and the value. The type is the first item to not
- * compare bytes and str which can raise a BytesWarning exception. */
-PyAPI_FUNC(PyObject*) _PyCode_ConstantKey(PyObject *obj);
-#endif
-
-PyAPI_FUNC(PyObject*) PyCode_Optimize(PyObject *code, PyObject* consts,
- PyObject *names, PyObject *lnotab);
-
-
-#ifndef Py_LIMITED_API
-PyAPI_FUNC(int) _PyCode_GetExtra(PyObject *code, Py_ssize_t index,
- void **extra);
-PyAPI_FUNC(int) _PyCode_SetExtra(PyObject *code, Py_ssize_t index,
- void *extra);
-#endif
-
-#ifdef __cplusplus
-}
-#endif
-#endif /* !Py_CODE_H */
-#endif /* Py_LIMITED_API */
diff --git a/pythonsdk/include/codecs.h b/pythonsdk/include/codecs.h
deleted file mode 100644
index a269f18f7b85ff0c0289e702a436a3d43f380717..0000000000000000000000000000000000000000
--- a/pythonsdk/include/codecs.h
+++ /dev/null
@@ -1,240 +0,0 @@
-#ifndef Py_CODECREGISTRY_H
-#define Py_CODECREGISTRY_H
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-/* ------------------------------------------------------------------------
-
- Python Codec Registry and support functions
-
-
-Written by Marc-Andre Lemburg (mal@lemburg.com).
-
-Copyright (c) Corporation for National Research Initiatives.
-
- ------------------------------------------------------------------------ */
-
-/* Register a new codec search function.
-
- As side effect, this tries to load the encodings package, if not
- yet done, to make sure that it is always first in the list of
- search functions.
-
- The search_function's refcount is incremented by this function. */
-
-PyAPI_FUNC(int) PyCodec_Register(
- PyObject *search_function
- );
-
-/* Codec registry lookup API.
-
- Looks up the given encoding and returns a CodecInfo object with
- function attributes which implement the different aspects of
- processing the encoding.
-
- The encoding string is looked up converted to all lower-case
- characters. This makes encodings looked up through this mechanism
- effectively case-insensitive.
-
- If no codec is found, a KeyError is set and NULL returned.
-
- As side effect, this tries to load the encodings package, if not
- yet done. This is part of the lazy load strategy for the encodings
- package.
-
- */
-
-#ifndef Py_LIMITED_API
-PyAPI_FUNC(PyObject *) _PyCodec_Lookup(
- const char *encoding
- );
-
-PyAPI_FUNC(int) _PyCodec_Forget(
- const char *encoding
- );
-#endif
-
-/* Codec registry encoding check API.
-
- Returns 1/0 depending on whether there is a registered codec for
- the given encoding.
-
-*/
-
-PyAPI_FUNC(int) PyCodec_KnownEncoding(
- const char *encoding
- );
-
-/* Generic codec based encoding API.
-
- object is passed through the encoder function found for the given
- encoding using the error handling method defined by errors. errors
- may be NULL to use the default method defined for the codec.
-
- Raises a LookupError in case no encoder can be found.
-
- */
-
-PyAPI_FUNC(PyObject *) PyCodec_Encode(
- PyObject *object,
- const char *encoding,
- const char *errors
- );
-
-/* Generic codec based decoding API.
-
- object is passed through the decoder function found for the given
- encoding using the error handling method defined by errors. errors
- may be NULL to use the default method defined for the codec.
-
- Raises a LookupError in case no encoder can be found.
-
- */
-
-PyAPI_FUNC(PyObject *) PyCodec_Decode(
- PyObject *object,
- const char *encoding,
- const char *errors
- );
-
-#ifndef Py_LIMITED_API
-/* Text codec specific encoding and decoding API.
-
- Checks the encoding against a list of codecs which do not
- implement a str<->bytes encoding before attempting the
- operation.
-
- Please note that these APIs are internal and should not
- be used in Python C extensions.
-
- XXX (ncoghlan): should we make these, or something like them, public
- in Python 3.5+?
-
- */
-PyAPI_FUNC(PyObject *) _PyCodec_LookupTextEncoding(
- const char *encoding,
- const char *alternate_command
- );
-
-PyAPI_FUNC(PyObject *) _PyCodec_EncodeText(
- PyObject *object,
- const char *encoding,
- const char *errors
- );
-
-PyAPI_FUNC(PyObject *) _PyCodec_DecodeText(
- PyObject *object,
- const char *encoding,
- const char *errors
- );
-
-/* These two aren't actually text encoding specific, but _io.TextIOWrapper
- * is the only current API consumer.
- */
-PyAPI_FUNC(PyObject *) _PyCodecInfo_GetIncrementalDecoder(
- PyObject *codec_info,
- const char *errors
- );
-
-PyAPI_FUNC(PyObject *) _PyCodecInfo_GetIncrementalEncoder(
- PyObject *codec_info,
- const char *errors
- );
-#endif
-
-
-
-/* --- Codec Lookup APIs --------------------------------------------------
-
- All APIs return a codec object with incremented refcount and are
- based on _PyCodec_Lookup(). The same comments w/r to the encoding
- name also apply to these APIs.
-
-*/
-
-/* Get an encoder function for the given encoding. */
-
-PyAPI_FUNC(PyObject *) PyCodec_Encoder(
- const char *encoding
- );
-
-/* Get a decoder function for the given encoding. */
-
-PyAPI_FUNC(PyObject *) PyCodec_Decoder(
- const char *encoding
- );
-
-/* Get an IncrementalEncoder object for the given encoding. */
-
-PyAPI_FUNC(PyObject *) PyCodec_IncrementalEncoder(
- const char *encoding,
- const char *errors
- );
-
-/* Get an IncrementalDecoder object function for the given encoding. */
-
-PyAPI_FUNC(PyObject *) PyCodec_IncrementalDecoder(
- const char *encoding,
- const char *errors
- );
-
-/* Get a StreamReader factory function for the given encoding. */
-
-PyAPI_FUNC(PyObject *) PyCodec_StreamReader(
- const char *encoding,
- PyObject *stream,
- const char *errors
- );
-
-/* Get a StreamWriter factory function for the given encoding. */
-
-PyAPI_FUNC(PyObject *) PyCodec_StreamWriter(
- const char *encoding,
- PyObject *stream,
- const char *errors
- );
-
-/* Unicode encoding error handling callback registry API */
-
-/* Register the error handling callback function error under the given
- name. This function will be called by the codec when it encounters
- unencodable characters/undecodable bytes and doesn't know the
- callback name, when name is specified as the error parameter
- in the call to the encode/decode function.
- Return 0 on success, -1 on error */
-PyAPI_FUNC(int) PyCodec_RegisterError(const char *name, PyObject *error);
-
-/* Lookup the error handling callback function registered under the given
- name. As a special case NULL can be passed, in which case
- the error handling callback for "strict" will be returned. */
-PyAPI_FUNC(PyObject *) PyCodec_LookupError(const char *name);
-
-/* raise exc as an exception */
-PyAPI_FUNC(PyObject *) PyCodec_StrictErrors(PyObject *exc);
-
-/* ignore the unicode error, skipping the faulty input */
-PyAPI_FUNC(PyObject *) PyCodec_IgnoreErrors(PyObject *exc);
-
-/* replace the unicode encode error with ? or U+FFFD */
-PyAPI_FUNC(PyObject *) PyCodec_ReplaceErrors(PyObject *exc);
-
-/* replace the unicode encode error with XML character references */
-PyAPI_FUNC(PyObject *) PyCodec_XMLCharRefReplaceErrors(PyObject *exc);
-
-/* replace the unicode encode error with backslash escapes (\x, \u and \U) */
-PyAPI_FUNC(PyObject *) PyCodec_BackslashReplaceErrors(PyObject *exc);
-
-#if !defined(Py_LIMITED_API) || Py_LIMITED_API+0 >= 0x03050000
-/* replace the unicode encode error with backslash escapes (\N, \x, \u and \U) */
-PyAPI_FUNC(PyObject *) PyCodec_NameReplaceErrors(PyObject *exc);
-#endif
-
-#ifndef Py_LIMITED_API
-PyAPI_DATA(const char *) Py_hexdigits;
-#endif
-
-#ifdef __cplusplus
-}
-#endif
-#endif /* !Py_CODECREGISTRY_H */
diff --git a/pythonsdk/include/compile.h b/pythonsdk/include/compile.h
deleted file mode 100644
index 1dbf03248ed87a4ecf80a3a71d8f5a75a1152bce..0000000000000000000000000000000000000000
--- a/pythonsdk/include/compile.h
+++ /dev/null
@@ -1,93 +0,0 @@
-#ifndef Py_COMPILE_H
-#define Py_COMPILE_H
-
-#ifndef Py_LIMITED_API
-#include "code.h"
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-/* Public interface */
-struct _node; /* Declare the existence of this type */
-PyAPI_FUNC(PyCodeObject *) PyNode_Compile(struct _node *, const char *);
-/* XXX (ncoghlan): Unprefixed type name in a public API! */
-
-#define PyCF_MASK (CO_FUTURE_DIVISION | CO_FUTURE_ABSOLUTE_IMPORT | \
- CO_FUTURE_WITH_STATEMENT | CO_FUTURE_PRINT_FUNCTION | \
- CO_FUTURE_UNICODE_LITERALS | CO_FUTURE_BARRY_AS_BDFL | \
- CO_FUTURE_GENERATOR_STOP | CO_FUTURE_ANNOTATIONS)
-#define PyCF_MASK_OBSOLETE (CO_NESTED)
-#define PyCF_SOURCE_IS_UTF8 0x0100
-#define PyCF_DONT_IMPLY_DEDENT 0x0200
-#define PyCF_ONLY_AST 0x0400
-#define PyCF_IGNORE_COOKIE 0x0800
-
-#ifndef Py_LIMITED_API
-typedef struct {
- int cf_flags; /* bitmask of CO_xxx flags relevant to future */
-} PyCompilerFlags;
-#endif
-
-/* Future feature support */
-
-typedef struct {
- int ff_features; /* flags set by future statements */
- int ff_lineno; /* line number of last future statement */
-} PyFutureFeatures;
-
-#define FUTURE_NESTED_SCOPES "nested_scopes"
-#define FUTURE_GENERATORS "generators"
-#define FUTURE_DIVISION "division"
-#define FUTURE_ABSOLUTE_IMPORT "absolute_import"
-#define FUTURE_WITH_STATEMENT "with_statement"
-#define FUTURE_PRINT_FUNCTION "print_function"
-#define FUTURE_UNICODE_LITERALS "unicode_literals"
-#define FUTURE_BARRY_AS_BDFL "barry_as_FLUFL"
-#define FUTURE_GENERATOR_STOP "generator_stop"
-#define FUTURE_ANNOTATIONS "annotations"
-
-struct _mod; /* Declare the existence of this type */
-#define PyAST_Compile(mod, s, f, ar) PyAST_CompileEx(mod, s, f, -1, ar)
-PyAPI_FUNC(PyCodeObject *) PyAST_CompileEx(
- struct _mod *mod,
- const char *filename, /* decoded from the filesystem encoding */
- PyCompilerFlags *flags,
- int optimize,
- PyArena *arena);
-PyAPI_FUNC(PyCodeObject *) PyAST_CompileObject(
- struct _mod *mod,
- PyObject *filename,
- PyCompilerFlags *flags,
- int optimize,
- PyArena *arena);
-PyAPI_FUNC(PyFutureFeatures *) PyFuture_FromAST(
- struct _mod * mod,
- const char *filename /* decoded from the filesystem encoding */
- );
-PyAPI_FUNC(PyFutureFeatures *) PyFuture_FromASTObject(
- struct _mod * mod,
- PyObject *filename
- );
-
-/* _Py_Mangle is defined in compile.c */
-PyAPI_FUNC(PyObject*) _Py_Mangle(PyObject *p, PyObject *name);
-
-#define PY_INVALID_STACK_EFFECT INT_MAX
-PyAPI_FUNC(int) PyCompile_OpcodeStackEffect(int opcode, int oparg);
-
-PyAPI_FUNC(int) _PyAST_Optimize(struct _mod *, PyArena *arena, int optimize);
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif /* !Py_LIMITED_API */
-
-/* These definitions must match corresponding definitions in graminit.h.
- There's code in compile.c that checks that they are the same. */
-#define Py_single_input 256
-#define Py_file_input 257
-#define Py_eval_input 258
-
-#endif /* !Py_COMPILE_H */
diff --git a/pythonsdk/include/complexobject.h b/pythonsdk/include/complexobject.h
deleted file mode 100644
index a189212d082d0802f67943bf5b78106041df0492..0000000000000000000000000000000000000000
--- a/pythonsdk/include/complexobject.h
+++ /dev/null
@@ -1,69 +0,0 @@
-/* Complex number structure */
-
-#ifndef Py_COMPLEXOBJECT_H
-#define Py_COMPLEXOBJECT_H
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-#ifndef Py_LIMITED_API
-typedef struct {
- double real;
- double imag;
-} Py_complex;
-
-/* Operations on complex numbers from complexmodule.c */
-
-PyAPI_FUNC(Py_complex) _Py_c_sum(Py_complex, Py_complex);
-PyAPI_FUNC(Py_complex) _Py_c_diff(Py_complex, Py_complex);
-PyAPI_FUNC(Py_complex) _Py_c_neg(Py_complex);
-PyAPI_FUNC(Py_complex) _Py_c_prod(Py_complex, Py_complex);
-PyAPI_FUNC(Py_complex) _Py_c_quot(Py_complex, Py_complex);
-PyAPI_FUNC(Py_complex) _Py_c_pow(Py_complex, Py_complex);
-PyAPI_FUNC(double) _Py_c_abs(Py_complex);
-#endif
-
-/* Complex object interface */
-
-/*
-PyComplexObject represents a complex number with double-precision
-real and imaginary parts.
-*/
-#ifndef Py_LIMITED_API
-typedef struct {
- PyObject_HEAD
- Py_complex cval;
-} PyComplexObject;
-#endif
-
-PyAPI_DATA(PyTypeObject) PyComplex_Type;
-
-#define PyComplex_Check(op) PyObject_TypeCheck(op, &PyComplex_Type)
-#define PyComplex_CheckExact(op) (Py_TYPE(op) == &PyComplex_Type)
-
-#ifndef Py_LIMITED_API
-PyAPI_FUNC(PyObject *) PyComplex_FromCComplex(Py_complex);
-#endif
-PyAPI_FUNC(PyObject *) PyComplex_FromDoubles(double real, double imag);
-
-PyAPI_FUNC(double) PyComplex_RealAsDouble(PyObject *op);
-PyAPI_FUNC(double) PyComplex_ImagAsDouble(PyObject *op);
-#ifndef Py_LIMITED_API
-PyAPI_FUNC(Py_complex) PyComplex_AsCComplex(PyObject *op);
-#endif
-
-/* Format the object based on the format_spec, as defined in PEP 3101
- (Advanced String Formatting). */
-#ifndef Py_LIMITED_API
-PyAPI_FUNC(int) _PyComplex_FormatAdvancedWriter(
- _PyUnicodeWriter *writer,
- PyObject *obj,
- PyObject *format_spec,
- Py_ssize_t start,
- Py_ssize_t end);
-#endif
-
-#ifdef __cplusplus
-}
-#endif
-#endif /* !Py_COMPLEXOBJECT_H */
diff --git a/pythonsdk/include/context.h b/pythonsdk/include/context.h
deleted file mode 100644
index cb21c42986d04aeac38d742053fda5e93c5a1986..0000000000000000000000000000000000000000
--- a/pythonsdk/include/context.h
+++ /dev/null
@@ -1,84 +0,0 @@
-#ifndef Py_CONTEXT_H
-#define Py_CONTEXT_H
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-#ifndef Py_LIMITED_API
-
-
-PyAPI_DATA(PyTypeObject) PyContext_Type;
-typedef struct _pycontextobject PyContext;
-
-PyAPI_DATA(PyTypeObject) PyContextVar_Type;
-typedef struct _pycontextvarobject PyContextVar;
-
-PyAPI_DATA(PyTypeObject) PyContextToken_Type;
-typedef struct _pycontexttokenobject PyContextToken;
-
-
-#define PyContext_CheckExact(o) (Py_TYPE(o) == &PyContext_Type)
-#define PyContextVar_CheckExact(o) (Py_TYPE(o) == &PyContextVar_Type)
-#define PyContextToken_CheckExact(o) (Py_TYPE(o) == &PyContextToken_Type)
-
-
-PyAPI_FUNC(PyObject *) PyContext_New(void);
-PyAPI_FUNC(PyObject *) PyContext_Copy(PyObject *);
-PyAPI_FUNC(PyObject *) PyContext_CopyCurrent(void);
-
-PyAPI_FUNC(int) PyContext_Enter(PyObject *);
-PyAPI_FUNC(int) PyContext_Exit(PyObject *);
-
-
-/* Create a new context variable.
-
- default_value can be NULL.
-*/
-PyAPI_FUNC(PyObject *) PyContextVar_New(
- const char *name, PyObject *default_value);
-
-
-/* Get a value for the variable.
-
- Returns -1 if an error occurred during lookup.
-
- Returns 0 if value either was or was not found.
-
- If value was found, *value will point to it.
- If not, it will point to:
-
- - default_value, if not NULL;
- - the default value of "var", if not NULL;
- - NULL.
-
- '*value' will be a new ref, if not NULL.
-*/
-PyAPI_FUNC(int) PyContextVar_Get(
- PyObject *var, PyObject *default_value, PyObject **value);
-
-
-/* Set a new value for the variable.
- Returns NULL if an error occurs.
-*/
-PyAPI_FUNC(PyObject *) PyContextVar_Set(PyObject *var, PyObject *value);
-
-
-/* Reset a variable to its previous value.
- Returns 0 on success, -1 on error.
-*/
-PyAPI_FUNC(int) PyContextVar_Reset(PyObject *var, PyObject *token);
-
-
-/* This method is exposed only for CPython tests. Don not use it. */
-PyAPI_FUNC(PyObject *) _PyContext_NewHamtForTests(void);
-
-
-PyAPI_FUNC(int) PyContext_ClearFreeList(void);
-
-
-#endif /* !Py_LIMITED_API */
-
-#ifdef __cplusplus
-}
-#endif
-#endif /* !Py_CONTEXT_H */
diff --git a/pythonsdk/include/datetime.h b/pythonsdk/include/datetime.h
deleted file mode 100644
index 792c00f1b23194e8ab60ea89c6e1a3d882afc1e8..0000000000000000000000000000000000000000
--- a/pythonsdk/include/datetime.h
+++ /dev/null
@@ -1,273 +0,0 @@
-/* datetime.h
- */
-#ifndef Py_LIMITED_API
-#ifndef DATETIME_H
-#define DATETIME_H
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-/* Fields are packed into successive bytes, each viewed as unsigned and
- * big-endian, unless otherwise noted:
- *
- * byte offset
- * 0 year 2 bytes, 1-9999
- * 2 month 1 byte, 1-12
- * 3 day 1 byte, 1-31
- * 4 hour 1 byte, 0-23
- * 5 minute 1 byte, 0-59
- * 6 second 1 byte, 0-59
- * 7 usecond 3 bytes, 0-999999
- * 10
- */
-
-/* # of bytes for year, month, and day. */
-#define _PyDateTime_DATE_DATASIZE 4
-
-/* # of bytes for hour, minute, second, and usecond. */
-#define _PyDateTime_TIME_DATASIZE 6
-
-/* # of bytes for year, month, day, hour, minute, second, and usecond. */
-#define _PyDateTime_DATETIME_DATASIZE 10
-
-
-typedef struct
-{
- PyObject_HEAD
- Py_hash_t hashcode; /* -1 when unknown */
- int days; /* -MAX_DELTA_DAYS <= days <= MAX_DELTA_DAYS */
- int seconds; /* 0 <= seconds < 24*3600 is invariant */
- int microseconds; /* 0 <= microseconds < 1000000 is invariant */
-} PyDateTime_Delta;
-
-typedef struct
-{
- PyObject_HEAD /* a pure abstract base class */
-} PyDateTime_TZInfo;
-
-
-/* The datetime and time types have hashcodes, and an optional tzinfo member,
- * present if and only if hastzinfo is true.
- */
-#define _PyTZINFO_HEAD \
- PyObject_HEAD \
- Py_hash_t hashcode; \
- char hastzinfo; /* boolean flag */
-
-/* No _PyDateTime_BaseTZInfo is allocated; it's just to have something
- * convenient to cast to, when getting at the hastzinfo member of objects
- * starting with _PyTZINFO_HEAD.
- */
-typedef struct
-{
- _PyTZINFO_HEAD
-} _PyDateTime_BaseTZInfo;
-
-/* All time objects are of PyDateTime_TimeType, but that can be allocated
- * in two ways, with or without a tzinfo member. Without is the same as
- * tzinfo == None, but consumes less memory. _PyDateTime_BaseTime is an
- * internal struct used to allocate the right amount of space for the
- * "without" case.
- */
-#define _PyDateTime_TIMEHEAD \
- _PyTZINFO_HEAD \
- unsigned char data[_PyDateTime_TIME_DATASIZE];
-
-typedef struct
-{
- _PyDateTime_TIMEHEAD
-} _PyDateTime_BaseTime; /* hastzinfo false */
-
-typedef struct
-{
- _PyDateTime_TIMEHEAD
- unsigned char fold;
- PyObject *tzinfo;
-} PyDateTime_Time; /* hastzinfo true */
-
-
-/* All datetime objects are of PyDateTime_DateTimeType, but that can be
- * allocated in two ways too, just like for time objects above. In addition,
- * the plain date type is a base class for datetime, so it must also have
- * a hastzinfo member (although it's unused there).
- */
-typedef struct
-{
- _PyTZINFO_HEAD
- unsigned char data[_PyDateTime_DATE_DATASIZE];
-} PyDateTime_Date;
-
-#define _PyDateTime_DATETIMEHEAD \
- _PyTZINFO_HEAD \
- unsigned char data[_PyDateTime_DATETIME_DATASIZE];
-
-typedef struct
-{
- _PyDateTime_DATETIMEHEAD
-} _PyDateTime_BaseDateTime; /* hastzinfo false */
-
-typedef struct
-{
- _PyDateTime_DATETIMEHEAD
- unsigned char fold;
- PyObject *tzinfo;
-} PyDateTime_DateTime; /* hastzinfo true */
-
-
-/* Apply for date and datetime instances. */
-#define PyDateTime_GET_YEAR(o) ((((PyDateTime_Date*)o)->data[0] << 8) | \
- ((PyDateTime_Date*)o)->data[1])
-#define PyDateTime_GET_MONTH(o) (((PyDateTime_Date*)o)->data[2])
-#define PyDateTime_GET_DAY(o) (((PyDateTime_Date*)o)->data[3])
-
-#define PyDateTime_DATE_GET_HOUR(o) (((PyDateTime_DateTime*)o)->data[4])
-#define PyDateTime_DATE_GET_MINUTE(o) (((PyDateTime_DateTime*)o)->data[5])
-#define PyDateTime_DATE_GET_SECOND(o) (((PyDateTime_DateTime*)o)->data[6])
-#define PyDateTime_DATE_GET_MICROSECOND(o) \
- ((((PyDateTime_DateTime*)o)->data[7] << 16) | \
- (((PyDateTime_DateTime*)o)->data[8] << 8) | \
- ((PyDateTime_DateTime*)o)->data[9])
-#define PyDateTime_DATE_GET_FOLD(o) (((PyDateTime_DateTime*)o)->fold)
-
-/* Apply for time instances. */
-#define PyDateTime_TIME_GET_HOUR(o) (((PyDateTime_Time*)o)->data[0])
-#define PyDateTime_TIME_GET_MINUTE(o) (((PyDateTime_Time*)o)->data[1])
-#define PyDateTime_TIME_GET_SECOND(o) (((PyDateTime_Time*)o)->data[2])
-#define PyDateTime_TIME_GET_MICROSECOND(o) \
- ((((PyDateTime_Time*)o)->data[3] << 16) | \
- (((PyDateTime_Time*)o)->data[4] << 8) | \
- ((PyDateTime_Time*)o)->data[5])
-#define PyDateTime_TIME_GET_FOLD(o) (((PyDateTime_Time*)o)->fold)
-
-/* Apply for time delta instances */
-#define PyDateTime_DELTA_GET_DAYS(o) (((PyDateTime_Delta*)o)->days)
-#define PyDateTime_DELTA_GET_SECONDS(o) (((PyDateTime_Delta*)o)->seconds)
-#define PyDateTime_DELTA_GET_MICROSECONDS(o) \
- (((PyDateTime_Delta*)o)->microseconds)
-
-
-/* Define structure for C API. */
-typedef struct {
- /* type objects */
- PyTypeObject *DateType;
- PyTypeObject *DateTimeType;
- PyTypeObject *TimeType;
- PyTypeObject *DeltaType;
- PyTypeObject *TZInfoType;
-
- /* singletons */
- PyObject *TimeZone_UTC;
-
- /* constructors */
- PyObject *(*Date_FromDate)(int, int, int, PyTypeObject*);
- PyObject *(*DateTime_FromDateAndTime)(int, int, int, int, int, int, int,
- PyObject*, PyTypeObject*);
- PyObject *(*Time_FromTime)(int, int, int, int, PyObject*, PyTypeObject*);
- PyObject *(*Delta_FromDelta)(int, int, int, int, PyTypeObject*);
- PyObject *(*TimeZone_FromTimeZone)(PyObject *offset, PyObject *name);
-
- /* constructors for the DB API */
- PyObject *(*DateTime_FromTimestamp)(PyObject*, PyObject*, PyObject*);
- PyObject *(*Date_FromTimestamp)(PyObject*, PyObject*);
-
- /* PEP 495 constructors */
- PyObject *(*DateTime_FromDateAndTimeAndFold)(int, int, int, int, int, int, int,
- PyObject*, int, PyTypeObject*);
- PyObject *(*Time_FromTimeAndFold)(int, int, int, int, PyObject*, int, PyTypeObject*);
-
-} PyDateTime_CAPI;
-
-#define PyDateTime_CAPSULE_NAME "datetime.datetime_CAPI"
-
-
-#ifdef Py_BUILD_CORE
-
-/* Macros for type checking when building the Python core. */
-#define PyDate_Check(op) PyObject_TypeCheck(op, &PyDateTime_DateType)
-#define PyDate_CheckExact(op) (Py_TYPE(op) == &PyDateTime_DateType)
-
-#define PyDateTime_Check(op) PyObject_TypeCheck(op, &PyDateTime_DateTimeType)
-#define PyDateTime_CheckExact(op) (Py_TYPE(op) == &PyDateTime_DateTimeType)
-
-#define PyTime_Check(op) PyObject_TypeCheck(op, &PyDateTime_TimeType)
-#define PyTime_CheckExact(op) (Py_TYPE(op) == &PyDateTime_TimeType)
-
-#define PyDelta_Check(op) PyObject_TypeCheck(op, &PyDateTime_DeltaType)
-#define PyDelta_CheckExact(op) (Py_TYPE(op) == &PyDateTime_DeltaType)
-
-#define PyTZInfo_Check(op) PyObject_TypeCheck(op, &PyDateTime_TZInfoType)
-#define PyTZInfo_CheckExact(op) (Py_TYPE(op) == &PyDateTime_TZInfoType)
-
-#else
-
-/* Define global variable for the C API and a macro for setting it. */
-static PyDateTime_CAPI *PyDateTimeAPI = NULL;
-
-#define PyDateTime_IMPORT \
- PyDateTimeAPI = (PyDateTime_CAPI *)PyCapsule_Import(PyDateTime_CAPSULE_NAME, 0)
-
-/* Macro for access to the UTC singleton */
-#define PyDateTime_TimeZone_UTC PyDateTimeAPI->TimeZone_UTC
-
-/* Macros for type checking when not building the Python core. */
-#define PyDate_Check(op) PyObject_TypeCheck(op, PyDateTimeAPI->DateType)
-#define PyDate_CheckExact(op) (Py_TYPE(op) == PyDateTimeAPI->DateType)
-
-#define PyDateTime_Check(op) PyObject_TypeCheck(op, PyDateTimeAPI->DateTimeType)
-#define PyDateTime_CheckExact(op) (Py_TYPE(op) == PyDateTimeAPI->DateTimeType)
-
-#define PyTime_Check(op) PyObject_TypeCheck(op, PyDateTimeAPI->TimeType)
-#define PyTime_CheckExact(op) (Py_TYPE(op) == PyDateTimeAPI->TimeType)
-
-#define PyDelta_Check(op) PyObject_TypeCheck(op, PyDateTimeAPI->DeltaType)
-#define PyDelta_CheckExact(op) (Py_TYPE(op) == PyDateTimeAPI->DeltaType)
-
-#define PyTZInfo_Check(op) PyObject_TypeCheck(op, PyDateTimeAPI->TZInfoType)
-#define PyTZInfo_CheckExact(op) (Py_TYPE(op) == PyDateTimeAPI->TZInfoType)
-
-/* Macros for accessing constructors in a simplified fashion. */
-#define PyDate_FromDate(year, month, day) \
- PyDateTimeAPI->Date_FromDate(year, month, day, PyDateTimeAPI->DateType)
-
-#define PyDateTime_FromDateAndTime(year, month, day, hour, min, sec, usec) \
- PyDateTimeAPI->DateTime_FromDateAndTime(year, month, day, hour, \
- min, sec, usec, Py_None, PyDateTimeAPI->DateTimeType)
-
-#define PyDateTime_FromDateAndTimeAndFold(year, month, day, hour, min, sec, usec, fold) \
- PyDateTimeAPI->DateTime_FromDateAndTimeAndFold(year, month, day, hour, \
- min, sec, usec, Py_None, fold, PyDateTimeAPI->DateTimeType)
-
-#define PyTime_FromTime(hour, minute, second, usecond) \
- PyDateTimeAPI->Time_FromTime(hour, minute, second, usecond, \
- Py_None, PyDateTimeAPI->TimeType)
-
-#define PyTime_FromTimeAndFold(hour, minute, second, usecond, fold) \
- PyDateTimeAPI->Time_FromTimeAndFold(hour, minute, second, usecond, \
- Py_None, fold, PyDateTimeAPI->TimeType)
-
-#define PyDelta_FromDSU(days, seconds, useconds) \
- PyDateTimeAPI->Delta_FromDelta(days, seconds, useconds, 1, \
- PyDateTimeAPI->DeltaType)
-
-#define PyTimeZone_FromOffset(offset) \
- PyDateTimeAPI->TimeZone_FromTimeZone(offset, NULL)
-
-#define PyTimeZone_FromOffsetAndName(offset, name) \
- PyDateTimeAPI->TimeZone_FromTimeZone(offset, name)
-
-/* Macros supporting the DB API. */
-#define PyDateTime_FromTimestamp(args) \
- PyDateTimeAPI->DateTime_FromTimestamp( \
- (PyObject*) (PyDateTimeAPI->DateTimeType), args, NULL)
-
-#define PyDate_FromTimestamp(args) \
- PyDateTimeAPI->Date_FromTimestamp( \
- (PyObject*) (PyDateTimeAPI->DateType), args)
-
-#endif /* Py_BUILD_CORE */
-
-#ifdef __cplusplus
-}
-#endif
-#endif
-#endif /* !Py_LIMITED_API */
diff --git a/pythonsdk/include/descrobject.h b/pythonsdk/include/descrobject.h
deleted file mode 100644
index a75536f395f22b30a98722da7af059cba85f3685..0000000000000000000000000000000000000000
--- a/pythonsdk/include/descrobject.h
+++ /dev/null
@@ -1,110 +0,0 @@
-/* Descriptors */
-#ifndef Py_DESCROBJECT_H
-#define Py_DESCROBJECT_H
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-typedef PyObject *(*getter)(PyObject *, void *);
-typedef int (*setter)(PyObject *, PyObject *, void *);
-
-typedef struct PyGetSetDef {
- const char *name;
- getter get;
- setter set;
- const char *doc;
- void *closure;
-} PyGetSetDef;
-
-#ifndef Py_LIMITED_API
-typedef PyObject *(*wrapperfunc)(PyObject *self, PyObject *args,
- void *wrapped);
-
-typedef PyObject *(*wrapperfunc_kwds)(PyObject *self, PyObject *args,
- void *wrapped, PyObject *kwds);
-
-struct wrapperbase {
- const char *name;
- int offset;
- void *function;
- wrapperfunc wrapper;
- const char *doc;
- int flags;
- PyObject *name_strobj;
-};
-
-/* Flags for above struct */
-#define PyWrapperFlag_KEYWORDS 1 /* wrapper function takes keyword args */
-
-/* Various kinds of descriptor objects */
-
-typedef struct {
- PyObject_HEAD
- PyTypeObject *d_type;
- PyObject *d_name;
- PyObject *d_qualname;
-} PyDescrObject;
-
-#define PyDescr_COMMON PyDescrObject d_common
-
-#define PyDescr_TYPE(x) (((PyDescrObject *)(x))->d_type)
-#define PyDescr_NAME(x) (((PyDescrObject *)(x))->d_name)
-
-typedef struct {
- PyDescr_COMMON;
- PyMethodDef *d_method;
-} PyMethodDescrObject;
-
-typedef struct {
- PyDescr_COMMON;
- struct PyMemberDef *d_member;
-} PyMemberDescrObject;
-
-typedef struct {
- PyDescr_COMMON;
- PyGetSetDef *d_getset;
-} PyGetSetDescrObject;
-
-typedef struct {
- PyDescr_COMMON;
- struct wrapperbase *d_base;
- void *d_wrapped; /* This can be any function pointer */
-} PyWrapperDescrObject;
-#endif /* Py_LIMITED_API */
-
-PyAPI_DATA(PyTypeObject) PyClassMethodDescr_Type;
-PyAPI_DATA(PyTypeObject) PyGetSetDescr_Type;
-PyAPI_DATA(PyTypeObject) PyMemberDescr_Type;
-PyAPI_DATA(PyTypeObject) PyMethodDescr_Type;
-PyAPI_DATA(PyTypeObject) PyWrapperDescr_Type;
-PyAPI_DATA(PyTypeObject) PyDictProxy_Type;
-#ifndef Py_LIMITED_API
-PyAPI_DATA(PyTypeObject) _PyMethodWrapper_Type;
-#endif /* Py_LIMITED_API */
-
-PyAPI_FUNC(PyObject *) PyDescr_NewMethod(PyTypeObject *, PyMethodDef *);
-PyAPI_FUNC(PyObject *) PyDescr_NewClassMethod(PyTypeObject *, PyMethodDef *);
-struct PyMemberDef; /* forward declaration for following prototype */
-PyAPI_FUNC(PyObject *) PyDescr_NewMember(PyTypeObject *,
- struct PyMemberDef *);
-PyAPI_FUNC(PyObject *) PyDescr_NewGetSet(PyTypeObject *,
- struct PyGetSetDef *);
-#ifndef Py_LIMITED_API
-
-PyAPI_FUNC(PyObject *) _PyMethodDescr_FastCallKeywords(
- PyObject *descrobj, PyObject *const *stack, Py_ssize_t nargs, PyObject *kwnames);
-PyAPI_FUNC(PyObject *) PyDescr_NewWrapper(PyTypeObject *,
- struct wrapperbase *, void *);
-#define PyDescr_IsData(d) (Py_TYPE(d)->tp_descr_set != NULL)
-#endif
-
-PyAPI_FUNC(PyObject *) PyDictProxy_New(PyObject *);
-PyAPI_FUNC(PyObject *) PyWrapper_New(PyObject *, PyObject *);
-
-
-PyAPI_DATA(PyTypeObject) PyProperty_Type;
-#ifdef __cplusplus
-}
-#endif
-#endif /* !Py_DESCROBJECT_H */
-
diff --git a/pythonsdk/include/dictobject.h b/pythonsdk/include/dictobject.h
deleted file mode 100644
index ee728ec73bc2b7efc94538dc9f9b817f7d7b750a..0000000000000000000000000000000000000000
--- a/pythonsdk/include/dictobject.h
+++ /dev/null
@@ -1,179 +0,0 @@
-#ifndef Py_DICTOBJECT_H
-#define Py_DICTOBJECT_H
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-
-/* Dictionary object type -- mapping from hashable object to object */
-
-/* The distribution includes a separate file, Objects/dictnotes.txt,
- describing explorations into dictionary design and optimization.
- It covers typical dictionary use patterns, the parameters for
- tuning dictionaries, and several ideas for possible optimizations.
-*/
-
-#ifndef Py_LIMITED_API
-
-typedef struct _dictkeysobject PyDictKeysObject;
-
-/* The ma_values pointer is NULL for a combined table
- * or points to an array of PyObject* for a split table
- */
-typedef struct {
- PyObject_HEAD
-
- /* Number of items in the dictionary */
- Py_ssize_t ma_used;
-
- /* Dictionary version: globally unique, value change each time
- the dictionary is modified */
- uint64_t ma_version_tag;
-
- PyDictKeysObject *ma_keys;
-
- /* If ma_values is NULL, the table is "combined": keys and values
- are stored in ma_keys.
-
- If ma_values is not NULL, the table is splitted:
- keys are stored in ma_keys and values are stored in ma_values */
- PyObject **ma_values;
-} PyDictObject;
-
-typedef struct {
- PyObject_HEAD
- PyDictObject *dv_dict;
-} _PyDictViewObject;
-
-#endif /* Py_LIMITED_API */
-
-PyAPI_DATA(PyTypeObject) PyDict_Type;
-PyAPI_DATA(PyTypeObject) PyDictIterKey_Type;
-PyAPI_DATA(PyTypeObject) PyDictIterValue_Type;
-PyAPI_DATA(PyTypeObject) PyDictIterItem_Type;
-PyAPI_DATA(PyTypeObject) PyDictKeys_Type;
-PyAPI_DATA(PyTypeObject) PyDictItems_Type;
-PyAPI_DATA(PyTypeObject) PyDictValues_Type;
-
-#define PyDict_Check(op) \
- PyType_FastSubclass(Py_TYPE(op), Py_TPFLAGS_DICT_SUBCLASS)
-#define PyDict_CheckExact(op) (Py_TYPE(op) == &PyDict_Type)
-#define PyDictKeys_Check(op) PyObject_TypeCheck(op, &PyDictKeys_Type)
-#define PyDictItems_Check(op) PyObject_TypeCheck(op, &PyDictItems_Type)
-#define PyDictValues_Check(op) PyObject_TypeCheck(op, &PyDictValues_Type)
-/* This excludes Values, since they are not sets. */
-# define PyDictViewSet_Check(op) \
- (PyDictKeys_Check(op) || PyDictItems_Check(op))
-
-
-PyAPI_FUNC(PyObject *) PyDict_New(void);
-PyAPI_FUNC(PyObject *) PyDict_GetItem(PyObject *mp, PyObject *key);
-#ifndef Py_LIMITED_API
-PyAPI_FUNC(PyObject *) _PyDict_GetItem_KnownHash(PyObject *mp, PyObject *key,
- Py_hash_t hash);
-#endif
-PyAPI_FUNC(PyObject *) PyDict_GetItemWithError(PyObject *mp, PyObject *key);
-#ifndef Py_LIMITED_API
-PyAPI_FUNC(PyObject *) _PyDict_GetItemIdWithError(PyObject *dp,
- struct _Py_Identifier *key);
-PyAPI_FUNC(PyObject *) PyDict_SetDefault(
- PyObject *mp, PyObject *key, PyObject *defaultobj);
-#endif
-PyAPI_FUNC(int) PyDict_SetItem(PyObject *mp, PyObject *key, PyObject *item);
-#ifndef Py_LIMITED_API
-PyAPI_FUNC(int) _PyDict_SetItem_KnownHash(PyObject *mp, PyObject *key,
- PyObject *item, Py_hash_t hash);
-#endif
-PyAPI_FUNC(int) PyDict_DelItem(PyObject *mp, PyObject *key);
-#ifndef Py_LIMITED_API
-PyAPI_FUNC(int) _PyDict_DelItem_KnownHash(PyObject *mp, PyObject *key,
- Py_hash_t hash);
-PyAPI_FUNC(int) _PyDict_DelItemIf(PyObject *mp, PyObject *key,
- int (*predicate)(PyObject *value));
-#endif
-PyAPI_FUNC(void) PyDict_Clear(PyObject *mp);
-PyAPI_FUNC(int) PyDict_Next(
- PyObject *mp, Py_ssize_t *pos, PyObject **key, PyObject **value);
-#ifndef Py_LIMITED_API
-PyDictKeysObject *_PyDict_NewKeysForClass(void);
-PyAPI_FUNC(PyObject *) PyObject_GenericGetDict(PyObject *, void *);
-PyAPI_FUNC(int) _PyDict_Next(
- PyObject *mp, Py_ssize_t *pos, PyObject **key, PyObject **value, Py_hash_t *hash);
-PyObject *_PyDictView_New(PyObject *, PyTypeObject *);
-#endif
-PyAPI_FUNC(PyObject *) PyDict_Keys(PyObject *mp);
-PyAPI_FUNC(PyObject *) PyDict_Values(PyObject *mp);
-PyAPI_FUNC(PyObject *) PyDict_Items(PyObject *mp);
-PyAPI_FUNC(Py_ssize_t) PyDict_Size(PyObject *mp);
-PyAPI_FUNC(PyObject *) PyDict_Copy(PyObject *mp);
-PyAPI_FUNC(int) PyDict_Contains(PyObject *mp, PyObject *key);
-#ifndef Py_LIMITED_API
-/* Get the number of items of a dictionary. */
-#define PyDict_GET_SIZE(mp) (assert(PyDict_Check(mp)),((PyDictObject *)mp)->ma_used)
-PyAPI_FUNC(int) _PyDict_Contains(PyObject *mp, PyObject *key, Py_hash_t hash);
-PyAPI_FUNC(PyObject *) _PyDict_NewPresized(Py_ssize_t minused);
-PyAPI_FUNC(void) _PyDict_MaybeUntrack(PyObject *mp);
-PyAPI_FUNC(int) _PyDict_HasOnlyStringKeys(PyObject *mp);
-Py_ssize_t _PyDict_KeysSize(PyDictKeysObject *keys);
-PyAPI_FUNC(Py_ssize_t) _PyDict_SizeOf(PyDictObject *);
-PyAPI_FUNC(PyObject *) _PyDict_Pop(PyObject *, PyObject *, PyObject *);
-PyObject *_PyDict_Pop_KnownHash(PyObject *, PyObject *, Py_hash_t, PyObject *);
-PyObject *_PyDict_FromKeys(PyObject *, PyObject *, PyObject *);
-#define _PyDict_HasSplitTable(d) ((d)->ma_values != NULL)
-
-PyAPI_FUNC(int) PyDict_ClearFreeList(void);
-#endif
-
-/* PyDict_Update(mp, other) is equivalent to PyDict_Merge(mp, other, 1). */
-PyAPI_FUNC(int) PyDict_Update(PyObject *mp, PyObject *other);
-
-/* PyDict_Merge updates/merges from a mapping object (an object that
- supports PyMapping_Keys() and PyObject_GetItem()). If override is true,
- the last occurrence of a key wins, else the first. The Python
- dict.update(other) is equivalent to PyDict_Merge(dict, other, 1).
-*/
-PyAPI_FUNC(int) PyDict_Merge(PyObject *mp,
- PyObject *other,
- int override);
-
-#ifndef Py_LIMITED_API
-/* Like PyDict_Merge, but override can be 0, 1 or 2. If override is 0,
- the first occurrence of a key wins, if override is 1, the last occurrence
- of a key wins, if override is 2, a KeyError with conflicting key as
- argument is raised.
-*/
-PyAPI_FUNC(int) _PyDict_MergeEx(PyObject *mp, PyObject *other, int override);
-PyAPI_FUNC(PyObject *) _PyDictView_Intersect(PyObject* self, PyObject *other);
-#endif
-
-/* PyDict_MergeFromSeq2 updates/merges from an iterable object producing
- iterable objects of length 2. If override is true, the last occurrence
- of a key wins, else the first. The Python dict constructor dict(seq2)
- is equivalent to dict={}; PyDict_MergeFromSeq(dict, seq2, 1).
-*/
-PyAPI_FUNC(int) PyDict_MergeFromSeq2(PyObject *d,
- PyObject *seq2,
- int override);
-
-PyAPI_FUNC(PyObject *) PyDict_GetItemString(PyObject *dp, const char *key);
-#ifndef Py_LIMITED_API
-PyAPI_FUNC(PyObject *) _PyDict_GetItemId(PyObject *dp, struct _Py_Identifier *key);
-#endif /* !Py_LIMITED_API */
-PyAPI_FUNC(int) PyDict_SetItemString(PyObject *dp, const char *key, PyObject *item);
-#ifndef Py_LIMITED_API
-PyAPI_FUNC(int) _PyDict_SetItemId(PyObject *dp, struct _Py_Identifier *key, PyObject *item);
-#endif /* !Py_LIMITED_API */
-PyAPI_FUNC(int) PyDict_DelItemString(PyObject *dp, const char *key);
-
-#ifndef Py_LIMITED_API
-PyAPI_FUNC(int) _PyDict_DelItemId(PyObject *mp, struct _Py_Identifier *key);
-PyAPI_FUNC(void) _PyDict_DebugMallocStats(FILE *out);
-
-int _PyObjectDict_SetItem(PyTypeObject *tp, PyObject **dictptr, PyObject *name, PyObject *value);
-PyObject *_PyDict_LoadGlobal(PyDictObject *, PyDictObject *, PyObject *);
-#endif
-
-#ifdef __cplusplus
-}
-#endif
-#endif /* !Py_DICTOBJECT_H */
diff --git a/pythonsdk/include/dtoa.h b/pythonsdk/include/dtoa.h
deleted file mode 100644
index 0901d8fb4836ca838d28ae2b8b5f6489c1a9a560..0000000000000000000000000000000000000000
--- a/pythonsdk/include/dtoa.h
+++ /dev/null
@@ -1,19 +0,0 @@
-#ifndef Py_LIMITED_API
-#ifndef PY_NO_SHORT_FLOAT_REPR
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-PyAPI_FUNC(double) _Py_dg_strtod(const char *str, char **ptr);
-PyAPI_FUNC(char *) _Py_dg_dtoa(double d, int mode, int ndigits,
- int *decpt, int *sign, char **rve);
-PyAPI_FUNC(void) _Py_dg_freedtoa(char *s);
-PyAPI_FUNC(double) _Py_dg_stdnan(int sign);
-PyAPI_FUNC(double) _Py_dg_infinity(int sign);
-
-
-#ifdef __cplusplus
-}
-#endif
-#endif
-#endif
diff --git a/pythonsdk/include/dynamic_annotations.h b/pythonsdk/include/dynamic_annotations.h
deleted file mode 100644
index 03448a2d5251f935a2ddbd98aef804cb6067b08c..0000000000000000000000000000000000000000
--- a/pythonsdk/include/dynamic_annotations.h
+++ /dev/null
@@ -1,499 +0,0 @@
-/* Copyright (c) 2008-2009, Google Inc.
- * All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
- *
- * * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- * * Neither the name of Google Inc. nor the names of its
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- *
- * ---
- * Author: Kostya Serebryany
- * Copied to CPython by Jeffrey Yasskin, with all macros renamed to
- * start with _Py_ to avoid colliding with users embedding Python, and
- * with deprecated macros removed.
- */
-
-/* This file defines dynamic annotations for use with dynamic analysis
- tool such as valgrind, PIN, etc.
-
- Dynamic annotation is a source code annotation that affects
- the generated code (that is, the annotation is not a comment).
- Each such annotation is attached to a particular
- instruction and/or to a particular object (address) in the program.
-
- The annotations that should be used by users are macros in all upper-case
- (e.g., _Py_ANNOTATE_NEW_MEMORY).
-
- Actual implementation of these macros may differ depending on the
- dynamic analysis tool being used.
-
- See http://code.google.com/p/data-race-test/ for more information.
-
- This file supports the following dynamic analysis tools:
- - None (DYNAMIC_ANNOTATIONS_ENABLED is not defined or zero).
- Macros are defined empty.
- - ThreadSanitizer, Helgrind, DRD (DYNAMIC_ANNOTATIONS_ENABLED is 1).
- Macros are defined as calls to non-inlinable empty functions
- that are intercepted by Valgrind. */
-
-#ifndef __DYNAMIC_ANNOTATIONS_H__
-#define __DYNAMIC_ANNOTATIONS_H__
-
-#ifndef DYNAMIC_ANNOTATIONS_ENABLED
-# define DYNAMIC_ANNOTATIONS_ENABLED 0
-#endif
-
-#if DYNAMIC_ANNOTATIONS_ENABLED != 0
-
- /* -------------------------------------------------------------
- Annotations useful when implementing condition variables such as CondVar,
- using conditional critical sections (Await/LockWhen) and when constructing
- user-defined synchronization mechanisms.
-
- The annotations _Py_ANNOTATE_HAPPENS_BEFORE() and
- _Py_ANNOTATE_HAPPENS_AFTER() can be used to define happens-before arcs in
- user-defined synchronization mechanisms: the race detector will infer an
- arc from the former to the latter when they share the same argument
- pointer.
-
- Example 1 (reference counting):
-
- void Unref() {
- _Py_ANNOTATE_HAPPENS_BEFORE(&refcount_);
- if (AtomicDecrementByOne(&refcount_) == 0) {
- _Py_ANNOTATE_HAPPENS_AFTER(&refcount_);
- delete this;
- }
- }
-
- Example 2 (message queue):
-
- void MyQueue::Put(Type *e) {
- MutexLock lock(&mu_);
- _Py_ANNOTATE_HAPPENS_BEFORE(e);
- PutElementIntoMyQueue(e);
- }
-
- Type *MyQueue::Get() {
- MutexLock lock(&mu_);
- Type *e = GetElementFromMyQueue();
- _Py_ANNOTATE_HAPPENS_AFTER(e);
- return e;
- }
-
- Note: when possible, please use the existing reference counting and message
- queue implementations instead of inventing new ones. */
-
- /* Report that wait on the condition variable at address "cv" has succeeded
- and the lock at address "lock" is held. */
-#define _Py_ANNOTATE_CONDVAR_LOCK_WAIT(cv, lock) \
- AnnotateCondVarWait(__FILE__, __LINE__, cv, lock)
-
- /* Report that wait on the condition variable at "cv" has succeeded. Variant
- w/o lock. */
-#define _Py_ANNOTATE_CONDVAR_WAIT(cv) \
- AnnotateCondVarWait(__FILE__, __LINE__, cv, NULL)
-
- /* Report that we are about to signal on the condition variable at address
- "cv". */
-#define _Py_ANNOTATE_CONDVAR_SIGNAL(cv) \
- AnnotateCondVarSignal(__FILE__, __LINE__, cv)
-
- /* Report that we are about to signal_all on the condition variable at "cv". */
-#define _Py_ANNOTATE_CONDVAR_SIGNAL_ALL(cv) \
- AnnotateCondVarSignalAll(__FILE__, __LINE__, cv)
-
- /* Annotations for user-defined synchronization mechanisms. */
-#define _Py_ANNOTATE_HAPPENS_BEFORE(obj) _Py_ANNOTATE_CONDVAR_SIGNAL(obj)
-#define _Py_ANNOTATE_HAPPENS_AFTER(obj) _Py_ANNOTATE_CONDVAR_WAIT(obj)
-
- /* Report that the bytes in the range [pointer, pointer+size) are about
- to be published safely. The race checker will create a happens-before
- arc from the call _Py_ANNOTATE_PUBLISH_MEMORY_RANGE(pointer, size) to
- subsequent accesses to this memory.
- Note: this annotation may not work properly if the race detector uses
- sampling, i.e. does not observe all memory accesses.
- */
-#define _Py_ANNOTATE_PUBLISH_MEMORY_RANGE(pointer, size) \
- AnnotatePublishMemoryRange(__FILE__, __LINE__, pointer, size)
-
- /* Instruct the tool to create a happens-before arc between mu->Unlock() and
- mu->Lock(). This annotation may slow down the race detector and hide real
- races. Normally it is used only when it would be difficult to annotate each
- of the mutex's critical sections individually using the annotations above.
- This annotation makes sense only for hybrid race detectors. For pure
- happens-before detectors this is a no-op. For more details see
- http://code.google.com/p/data-race-test/wiki/PureHappensBeforeVsHybrid . */
-#define _Py_ANNOTATE_PURE_HAPPENS_BEFORE_MUTEX(mu) \
- AnnotateMutexIsUsedAsCondVar(__FILE__, __LINE__, mu)
-
- /* -------------------------------------------------------------
- Annotations useful when defining memory allocators, or when memory that
- was protected in one way starts to be protected in another. */
-
- /* Report that a new memory at "address" of size "size" has been allocated.
- This might be used when the memory has been retrieved from a free list and
- is about to be reused, or when the locking discipline for a variable
- changes. */
-#define _Py_ANNOTATE_NEW_MEMORY(address, size) \
- AnnotateNewMemory(__FILE__, __LINE__, address, size)
-
- /* -------------------------------------------------------------
- Annotations useful when defining FIFO queues that transfer data between
- threads. */
-
- /* Report that the producer-consumer queue (such as ProducerConsumerQueue) at
- address "pcq" has been created. The _Py_ANNOTATE_PCQ_* annotations should
- be used only for FIFO queues. For non-FIFO queues use
- _Py_ANNOTATE_HAPPENS_BEFORE (for put) and _Py_ANNOTATE_HAPPENS_AFTER (for
- get). */
-#define _Py_ANNOTATE_PCQ_CREATE(pcq) \
- AnnotatePCQCreate(__FILE__, __LINE__, pcq)
-
- /* Report that the queue at address "pcq" is about to be destroyed. */
-#define _Py_ANNOTATE_PCQ_DESTROY(pcq) \
- AnnotatePCQDestroy(__FILE__, __LINE__, pcq)
-
- /* Report that we are about to put an element into a FIFO queue at address
- "pcq". */
-#define _Py_ANNOTATE_PCQ_PUT(pcq) \
- AnnotatePCQPut(__FILE__, __LINE__, pcq)
-
- /* Report that we've just got an element from a FIFO queue at address "pcq". */
-#define _Py_ANNOTATE_PCQ_GET(pcq) \
- AnnotatePCQGet(__FILE__, __LINE__, pcq)
-
- /* -------------------------------------------------------------
- Annotations that suppress errors. It is usually better to express the
- program's synchronization using the other annotations, but these can
- be used when all else fails. */
-
- /* Report that we may have a benign race at "pointer", with size
- "sizeof(*(pointer))". "pointer" must be a non-void* pointer. Insert at the
- point where "pointer" has been allocated, preferably close to the point
- where the race happens. See also _Py_ANNOTATE_BENIGN_RACE_STATIC. */
-#define _Py_ANNOTATE_BENIGN_RACE(pointer, description) \
- AnnotateBenignRaceSized(__FILE__, __LINE__, pointer, \
- sizeof(*(pointer)), description)
-
- /* Same as _Py_ANNOTATE_BENIGN_RACE(address, description), but applies to
- the memory range [address, address+size). */
-#define _Py_ANNOTATE_BENIGN_RACE_SIZED(address, size, description) \
- AnnotateBenignRaceSized(__FILE__, __LINE__, address, size, description)
-
- /* Request the analysis tool to ignore all reads in the current thread
- until _Py_ANNOTATE_IGNORE_READS_END is called.
- Useful to ignore intentional racey reads, while still checking
- other reads and all writes.
- See also _Py_ANNOTATE_UNPROTECTED_READ. */
-#define _Py_ANNOTATE_IGNORE_READS_BEGIN() \
- AnnotateIgnoreReadsBegin(__FILE__, __LINE__)
-
- /* Stop ignoring reads. */
-#define _Py_ANNOTATE_IGNORE_READS_END() \
- AnnotateIgnoreReadsEnd(__FILE__, __LINE__)
-
- /* Similar to _Py_ANNOTATE_IGNORE_READS_BEGIN, but ignore writes. */
-#define _Py_ANNOTATE_IGNORE_WRITES_BEGIN() \
- AnnotateIgnoreWritesBegin(__FILE__, __LINE__)
-
- /* Stop ignoring writes. */
-#define _Py_ANNOTATE_IGNORE_WRITES_END() \
- AnnotateIgnoreWritesEnd(__FILE__, __LINE__)
-
- /* Start ignoring all memory accesses (reads and writes). */
-#define _Py_ANNOTATE_IGNORE_READS_AND_WRITES_BEGIN() \
- do {\
- _Py_ANNOTATE_IGNORE_READS_BEGIN();\
- _Py_ANNOTATE_IGNORE_WRITES_BEGIN();\
- }while(0)\
-
- /* Stop ignoring all memory accesses. */
-#define _Py_ANNOTATE_IGNORE_READS_AND_WRITES_END() \
- do {\
- _Py_ANNOTATE_IGNORE_WRITES_END();\
- _Py_ANNOTATE_IGNORE_READS_END();\
- }while(0)\
-
- /* Similar to _Py_ANNOTATE_IGNORE_READS_BEGIN, but ignore synchronization events:
- RWLOCK* and CONDVAR*. */
-#define _Py_ANNOTATE_IGNORE_SYNC_BEGIN() \
- AnnotateIgnoreSyncBegin(__FILE__, __LINE__)
-
- /* Stop ignoring sync events. */
-#define _Py_ANNOTATE_IGNORE_SYNC_END() \
- AnnotateIgnoreSyncEnd(__FILE__, __LINE__)
-
-
- /* Enable (enable!=0) or disable (enable==0) race detection for all threads.
- This annotation could be useful if you want to skip expensive race analysis
- during some period of program execution, e.g. during initialization. */
-#define _Py_ANNOTATE_ENABLE_RACE_DETECTION(enable) \
- AnnotateEnableRaceDetection(__FILE__, __LINE__, enable)
-
- /* -------------------------------------------------------------
- Annotations useful for debugging. */
-
- /* Request to trace every access to "address". */
-#define _Py_ANNOTATE_TRACE_MEMORY(address) \
- AnnotateTraceMemory(__FILE__, __LINE__, address)
-
- /* Report the current thread name to a race detector. */
-#define _Py_ANNOTATE_THREAD_NAME(name) \
- AnnotateThreadName(__FILE__, __LINE__, name)
-
- /* -------------------------------------------------------------
- Annotations useful when implementing locks. They are not
- normally needed by modules that merely use locks.
- The "lock" argument is a pointer to the lock object. */
-
- /* Report that a lock has been created at address "lock". */
-#define _Py_ANNOTATE_RWLOCK_CREATE(lock) \
- AnnotateRWLockCreate(__FILE__, __LINE__, lock)
-
- /* Report that the lock at address "lock" is about to be destroyed. */
-#define _Py_ANNOTATE_RWLOCK_DESTROY(lock) \
- AnnotateRWLockDestroy(__FILE__, __LINE__, lock)
-
- /* Report that the lock at address "lock" has been acquired.
- is_w=1 for writer lock, is_w=0 for reader lock. */
-#define _Py_ANNOTATE_RWLOCK_ACQUIRED(lock, is_w) \
- AnnotateRWLockAcquired(__FILE__, __LINE__, lock, is_w)
-
- /* Report that the lock at address "lock" is about to be released. */
-#define _Py_ANNOTATE_RWLOCK_RELEASED(lock, is_w) \
- AnnotateRWLockReleased(__FILE__, __LINE__, lock, is_w)
-
- /* -------------------------------------------------------------
- Annotations useful when implementing barriers. They are not
- normally needed by modules that merely use barriers.
- The "barrier" argument is a pointer to the barrier object. */
-
- /* Report that the "barrier" has been initialized with initial "count".
- If 'reinitialization_allowed' is true, initialization is allowed to happen
- multiple times w/o calling barrier_destroy() */
-#define _Py_ANNOTATE_BARRIER_INIT(barrier, count, reinitialization_allowed) \
- AnnotateBarrierInit(__FILE__, __LINE__, barrier, count, \
- reinitialization_allowed)
-
- /* Report that we are about to enter barrier_wait("barrier"). */
-#define _Py_ANNOTATE_BARRIER_WAIT_BEFORE(barrier) \
- AnnotateBarrierWaitBefore(__FILE__, __LINE__, barrier)
-
- /* Report that we just exited barrier_wait("barrier"). */
-#define _Py_ANNOTATE_BARRIER_WAIT_AFTER(barrier) \
- AnnotateBarrierWaitAfter(__FILE__, __LINE__, barrier)
-
- /* Report that the "barrier" has been destroyed. */
-#define _Py_ANNOTATE_BARRIER_DESTROY(barrier) \
- AnnotateBarrierDestroy(__FILE__, __LINE__, barrier)
-
- /* -------------------------------------------------------------
- Annotations useful for testing race detectors. */
-
- /* Report that we expect a race on the variable at "address".
- Use only in unit tests for a race detector. */
-#define _Py_ANNOTATE_EXPECT_RACE(address, description) \
- AnnotateExpectRace(__FILE__, __LINE__, address, description)
-
- /* A no-op. Insert where you like to test the interceptors. */
-#define _Py_ANNOTATE_NO_OP(arg) \
- AnnotateNoOp(__FILE__, __LINE__, arg)
-
- /* Force the race detector to flush its state. The actual effect depends on
- * the implementation of the detector. */
-#define _Py_ANNOTATE_FLUSH_STATE() \
- AnnotateFlushState(__FILE__, __LINE__)
-
-
-#else /* DYNAMIC_ANNOTATIONS_ENABLED == 0 */
-
-#define _Py_ANNOTATE_RWLOCK_CREATE(lock) /* empty */
-#define _Py_ANNOTATE_RWLOCK_DESTROY(lock) /* empty */
-#define _Py_ANNOTATE_RWLOCK_ACQUIRED(lock, is_w) /* empty */
-#define _Py_ANNOTATE_RWLOCK_RELEASED(lock, is_w) /* empty */
-#define _Py_ANNOTATE_BARRIER_INIT(barrier, count, reinitialization_allowed) /* */
-#define _Py_ANNOTATE_BARRIER_WAIT_BEFORE(barrier) /* empty */
-#define _Py_ANNOTATE_BARRIER_WAIT_AFTER(barrier) /* empty */
-#define _Py_ANNOTATE_BARRIER_DESTROY(barrier) /* empty */
-#define _Py_ANNOTATE_CONDVAR_LOCK_WAIT(cv, lock) /* empty */
-#define _Py_ANNOTATE_CONDVAR_WAIT(cv) /* empty */
-#define _Py_ANNOTATE_CONDVAR_SIGNAL(cv) /* empty */
-#define _Py_ANNOTATE_CONDVAR_SIGNAL_ALL(cv) /* empty */
-#define _Py_ANNOTATE_HAPPENS_BEFORE(obj) /* empty */
-#define _Py_ANNOTATE_HAPPENS_AFTER(obj) /* empty */
-#define _Py_ANNOTATE_PUBLISH_MEMORY_RANGE(address, size) /* empty */
-#define _Py_ANNOTATE_UNPUBLISH_MEMORY_RANGE(address, size) /* empty */
-#define _Py_ANNOTATE_SWAP_MEMORY_RANGE(address, size) /* empty */
-#define _Py_ANNOTATE_PCQ_CREATE(pcq) /* empty */
-#define _Py_ANNOTATE_PCQ_DESTROY(pcq) /* empty */
-#define _Py_ANNOTATE_PCQ_PUT(pcq) /* empty */
-#define _Py_ANNOTATE_PCQ_GET(pcq) /* empty */
-#define _Py_ANNOTATE_NEW_MEMORY(address, size) /* empty */
-#define _Py_ANNOTATE_EXPECT_RACE(address, description) /* empty */
-#define _Py_ANNOTATE_BENIGN_RACE(address, description) /* empty */
-#define _Py_ANNOTATE_BENIGN_RACE_SIZED(address, size, description) /* empty */
-#define _Py_ANNOTATE_PURE_HAPPENS_BEFORE_MUTEX(mu) /* empty */
-#define _Py_ANNOTATE_MUTEX_IS_USED_AS_CONDVAR(mu) /* empty */
-#define _Py_ANNOTATE_TRACE_MEMORY(arg) /* empty */
-#define _Py_ANNOTATE_THREAD_NAME(name) /* empty */
-#define _Py_ANNOTATE_IGNORE_READS_BEGIN() /* empty */
-#define _Py_ANNOTATE_IGNORE_READS_END() /* empty */
-#define _Py_ANNOTATE_IGNORE_WRITES_BEGIN() /* empty */
-#define _Py_ANNOTATE_IGNORE_WRITES_END() /* empty */
-#define _Py_ANNOTATE_IGNORE_READS_AND_WRITES_BEGIN() /* empty */
-#define _Py_ANNOTATE_IGNORE_READS_AND_WRITES_END() /* empty */
-#define _Py_ANNOTATE_IGNORE_SYNC_BEGIN() /* empty */
-#define _Py_ANNOTATE_IGNORE_SYNC_END() /* empty */
-#define _Py_ANNOTATE_ENABLE_RACE_DETECTION(enable) /* empty */
-#define _Py_ANNOTATE_NO_OP(arg) /* empty */
-#define _Py_ANNOTATE_FLUSH_STATE() /* empty */
-
-#endif /* DYNAMIC_ANNOTATIONS_ENABLED */
-
-/* Use the macros above rather than using these functions directly. */
-#ifdef __cplusplus
-extern "C" {
-#endif
-void AnnotateRWLockCreate(const char *file, int line,
- const volatile void *lock);
-void AnnotateRWLockDestroy(const char *file, int line,
- const volatile void *lock);
-void AnnotateRWLockAcquired(const char *file, int line,
- const volatile void *lock, long is_w);
-void AnnotateRWLockReleased(const char *file, int line,
- const volatile void *lock, long is_w);
-void AnnotateBarrierInit(const char *file, int line,
- const volatile void *barrier, long count,
- long reinitialization_allowed);
-void AnnotateBarrierWaitBefore(const char *file, int line,
- const volatile void *barrier);
-void AnnotateBarrierWaitAfter(const char *file, int line,
- const volatile void *barrier);
-void AnnotateBarrierDestroy(const char *file, int line,
- const volatile void *barrier);
-void AnnotateCondVarWait(const char *file, int line,
- const volatile void *cv,
- const volatile void *lock);
-void AnnotateCondVarSignal(const char *file, int line,
- const volatile void *cv);
-void AnnotateCondVarSignalAll(const char *file, int line,
- const volatile void *cv);
-void AnnotatePublishMemoryRange(const char *file, int line,
- const volatile void *address,
- long size);
-void AnnotateUnpublishMemoryRange(const char *file, int line,
- const volatile void *address,
- long size);
-void AnnotatePCQCreate(const char *file, int line,
- const volatile void *pcq);
-void AnnotatePCQDestroy(const char *file, int line,
- const volatile void *pcq);
-void AnnotatePCQPut(const char *file, int line,
- const volatile void *pcq);
-void AnnotatePCQGet(const char *file, int line,
- const volatile void *pcq);
-void AnnotateNewMemory(const char *file, int line,
- const volatile void *address,
- long size);
-void AnnotateExpectRace(const char *file, int line,
- const volatile void *address,
- const char *description);
-void AnnotateBenignRace(const char *file, int line,
- const volatile void *address,
- const char *description);
-void AnnotateBenignRaceSized(const char *file, int line,
- const volatile void *address,
- long size,
- const char *description);
-void AnnotateMutexIsUsedAsCondVar(const char *file, int line,
- const volatile void *mu);
-void AnnotateTraceMemory(const char *file, int line,
- const volatile void *arg);
-void AnnotateThreadName(const char *file, int line,
- const char *name);
-void AnnotateIgnoreReadsBegin(const char *file, int line);
-void AnnotateIgnoreReadsEnd(const char *file, int line);
-void AnnotateIgnoreWritesBegin(const char *file, int line);
-void AnnotateIgnoreWritesEnd(const char *file, int line);
-void AnnotateEnableRaceDetection(const char *file, int line, int enable);
-void AnnotateNoOp(const char *file, int line,
- const volatile void *arg);
-void AnnotateFlushState(const char *file, int line);
-
-/* Return non-zero value if running under valgrind.
-
- If "valgrind.h" is included into dynamic_annotations.c,
- the regular valgrind mechanism will be used.
- See http://valgrind.org/docs/manual/manual-core-adv.html about
- RUNNING_ON_VALGRIND and other valgrind "client requests".
- The file "valgrind.h" may be obtained by doing
- svn co svn://svn.valgrind.org/valgrind/trunk/include
-
- If for some reason you can't use "valgrind.h" or want to fake valgrind,
- there are two ways to make this function return non-zero:
- - Use environment variable: export RUNNING_ON_VALGRIND=1
- - Make your tool intercept the function RunningOnValgrind() and
- change its return value.
- */
-int RunningOnValgrind(void);
-
-#ifdef __cplusplus
-}
-#endif
-
-#if DYNAMIC_ANNOTATIONS_ENABLED != 0 && defined(__cplusplus)
-
- /* _Py_ANNOTATE_UNPROTECTED_READ is the preferred way to annotate racey reads.
-
- Instead of doing
- _Py_ANNOTATE_IGNORE_READS_BEGIN();
- ... = x;
- _Py_ANNOTATE_IGNORE_READS_END();
- one can use
- ... = _Py_ANNOTATE_UNPROTECTED_READ(x); */
- template <class T>
- inline T _Py_ANNOTATE_UNPROTECTED_READ(const volatile T &x) {
- _Py_ANNOTATE_IGNORE_READS_BEGIN();
- T res = x;
- _Py_ANNOTATE_IGNORE_READS_END();
- return res;
- }
- /* Apply _Py_ANNOTATE_BENIGN_RACE_SIZED to a static variable. */
-#define _Py_ANNOTATE_BENIGN_RACE_STATIC(static_var, description) \
- namespace { \
- class static_var ## _annotator { \
- public: \
- static_var ## _annotator() { \
- _Py_ANNOTATE_BENIGN_RACE_SIZED(&static_var, \
- sizeof(static_var), \
- # static_var ": " description); \
- } \
- }; \
- static static_var ## _annotator the ## static_var ## _annotator;\
- }
-#else /* DYNAMIC_ANNOTATIONS_ENABLED == 0 */
-
-#define _Py_ANNOTATE_UNPROTECTED_READ(x) (x)
-#define _Py_ANNOTATE_BENIGN_RACE_STATIC(static_var, description) /* empty */
-
-#endif /* DYNAMIC_ANNOTATIONS_ENABLED */
-
-#endif /* __DYNAMIC_ANNOTATIONS_H__ */
diff --git a/pythonsdk/include/enumobject.h b/pythonsdk/include/enumobject.h
deleted file mode 100644
index 42dc2d27de4f3a89043a3ff79506b6d7c261dfe5..0000000000000000000000000000000000000000
--- a/pythonsdk/include/enumobject.h
+++ /dev/null
@@ -1,17 +0,0 @@
-#ifndef Py_ENUMOBJECT_H
-#define Py_ENUMOBJECT_H
-
-/* Enumerate Object */
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-PyAPI_DATA(PyTypeObject) PyEnum_Type;
-PyAPI_DATA(PyTypeObject) PyReversed_Type;
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif /* !Py_ENUMOBJECT_H */
diff --git a/pythonsdk/include/errcode.h b/pythonsdk/include/errcode.h
deleted file mode 100644
index 68104c1ca011154015e331b55c424507d6df25ce..0000000000000000000000000000000000000000
--- a/pythonsdk/include/errcode.h
+++ /dev/null
@@ -1,38 +0,0 @@
-#ifndef Py_ERRCODE_H
-#define Py_ERRCODE_H
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-
-/* Error codes passed around between file input, tokenizer, parser and
- interpreter. This is necessary so we can turn them into Python
- exceptions at a higher level. Note that some errors have a
- slightly different meaning when passed from the tokenizer to the
- parser than when passed from the parser to the interpreter; e.g.
- the parser only returns E_EOF when it hits EOF immediately, and it
- never returns E_OK. */
-
-#define E_OK 10 /* No error */
-#define E_EOF 11 /* End Of File */
-#define E_INTR 12 /* Interrupted */
-#define E_TOKEN 13 /* Bad token */
-#define E_SYNTAX 14 /* Syntax error */
-#define E_NOMEM 15 /* Ran out of memory */
-#define E_DONE 16 /* Parsing complete */
-#define E_ERROR 17 /* Execution error */
-#define E_TABSPACE 18 /* Inconsistent mixing of tabs and spaces */
-#define E_OVERFLOW 19 /* Node had too many children */
-#define E_TOODEEP 20 /* Too many indentation levels */
-#define E_DEDENT 21 /* No matching outer block for dedent */
-#define E_DECODE 22 /* Error in decoding into Unicode */
-#define E_EOFS 23 /* EOF in triple-quoted string */
-#define E_EOLS 24 /* EOL in single-quoted string */
-#define E_LINECONT 25 /* Unexpected characters after a line continuation */
-#define E_IDENTIFIER 26 /* Invalid characters in identifier */
-#define E_BADSINGLE 27 /* Ill-formed single statement input */
-
-#ifdef __cplusplus
-}
-#endif
-#endif /* !Py_ERRCODE_H */
diff --git a/pythonsdk/include/eval.h b/pythonsdk/include/eval.h
deleted file mode 100644
index 06dd9883c9ecb63d208a579e88c131f9ce505727..0000000000000000000000000000000000000000
--- a/pythonsdk/include/eval.h
+++ /dev/null
@@ -1,37 +0,0 @@
-
-/* Interface to execute compiled code */
-
-#ifndef Py_EVAL_H
-#define Py_EVAL_H
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-PyAPI_FUNC(PyObject *) PyEval_EvalCode(PyObject *, PyObject *, PyObject *);
-
-PyAPI_FUNC(PyObject *) PyEval_EvalCodeEx(PyObject *co,
- PyObject *globals,
- PyObject *locals,
- PyObject *const *args, int argc,
- PyObject *const *kwds, int kwdc,
- PyObject *const *defs, int defc,
- PyObject *kwdefs, PyObject *closure);
-
-#ifndef Py_LIMITED_API
-PyAPI_FUNC(PyObject *) _PyEval_EvalCodeWithName(
- PyObject *co,
- PyObject *globals, PyObject *locals,
- PyObject *const *args, Py_ssize_t argcount,
- PyObject *const *kwnames, PyObject *const *kwargs,
- Py_ssize_t kwcount, int kwstep,
- PyObject *const *defs, Py_ssize_t defcount,
- PyObject *kwdefs, PyObject *closure,
- PyObject *name, PyObject *qualname);
-
-PyAPI_FUNC(PyObject *) _PyEval_CallTracing(PyObject *func, PyObject *args);
-#endif
-
-#ifdef __cplusplus
-}
-#endif
-#endif /* !Py_EVAL_H */
diff --git a/pythonsdk/include/fileobject.h b/pythonsdk/include/fileobject.h
deleted file mode 100644
index 520d3bc5ba61c7869cf30c13d33708b4926fbd5b..0000000000000000000000000000000000000000
--- a/pythonsdk/include/fileobject.h
+++ /dev/null
@@ -1,55 +0,0 @@
-/* File object interface (what's left of it -- see io.py) */
-
-#ifndef Py_FILEOBJECT_H
-#define Py_FILEOBJECT_H
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-#define PY_STDIOTEXTMODE "b"
-
-PyAPI_FUNC(PyObject *) PyFile_FromFd(int, const char *, const char *, int,
- const char *, const char *,
- const char *, int);
-PyAPI_FUNC(PyObject *) PyFile_GetLine(PyObject *, int);
-PyAPI_FUNC(int) PyFile_WriteObject(PyObject *, PyObject *, int);
-PyAPI_FUNC(int) PyFile_WriteString(const char *, PyObject *);
-PyAPI_FUNC(int) PyObject_AsFileDescriptor(PyObject *);
-#ifndef Py_LIMITED_API
-PyAPI_FUNC(char *) Py_UniversalNewlineFgets(char *, int, FILE*, PyObject *);
-#endif
-
-/* The default encoding used by the platform file system APIs
- If non-NULL, this is different than the default encoding for strings
-*/
-PyAPI_DATA(const char *) Py_FileSystemDefaultEncoding;
-#if !defined(Py_LIMITED_API) || Py_LIMITED_API+0 >= 0x03060000
-PyAPI_DATA(const char *) Py_FileSystemDefaultEncodeErrors;
-#endif
-PyAPI_DATA(int) Py_HasFileSystemDefaultEncoding;
-
-#if !defined(Py_LIMITED_API) || Py_LIMITED_API+0 >= 0x03070000
-PyAPI_DATA(int) Py_UTF8Mode;
-#endif
-
-/* Internal API
-
- The std printer acts as a preliminary sys.stderr until the new io
- infrastructure is in place. */
-#ifndef Py_LIMITED_API
-PyAPI_FUNC(PyObject *) PyFile_NewStdPrinter(int);
-PyAPI_DATA(PyTypeObject) PyStdPrinter_Type;
-#endif /* Py_LIMITED_API */
-
-/* A routine to check if a file descriptor can be select()-ed. */
-#ifdef _MSC_VER
- /* On Windows, any socket fd can be select()-ed, no matter how high */
- #define _PyIsSelectable_fd(FD) (1)
-#else
- #define _PyIsSelectable_fd(FD) ((unsigned int)(FD) < (unsigned int)FD_SETSIZE)
-#endif
-
-#ifdef __cplusplus
-}
-#endif
-#endif /* !Py_FILEOBJECT_H */
diff --git a/pythonsdk/include/fileutils.h b/pythonsdk/include/fileutils.h
deleted file mode 100644
index 415b5b3c09b4b04ff43bbf4b47de86e14051cb07..0000000000000000000000000000000000000000
--- a/pythonsdk/include/fileutils.h
+++ /dev/null
@@ -1,201 +0,0 @@
-#ifndef Py_FILEUTILS_H
-#define Py_FILEUTILS_H
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-#if !defined(Py_LIMITED_API) || Py_LIMITED_API+0 >= 0x03050000
-PyAPI_FUNC(wchar_t *) Py_DecodeLocale(
- const char *arg,
- size_t *size);
-
-PyAPI_FUNC(char*) Py_EncodeLocale(
- const wchar_t *text,
- size_t *error_pos);
-
-PyAPI_FUNC(char*) _Py_EncodeLocaleRaw(
- const wchar_t *text,
- size_t *error_pos);
-#endif
-
-#ifdef Py_BUILD_CORE
-PyAPI_FUNC(int) _Py_DecodeUTF8Ex(
- const char *arg,
- Py_ssize_t arglen,
- wchar_t **wstr,
- size_t *wlen,
- const char **reason,
- int surrogateescape);
-
-PyAPI_FUNC(int) _Py_EncodeUTF8Ex(
- const wchar_t *text,
- char **str,
- size_t *error_pos,
- const char **reason,
- int raw_malloc,
- int surrogateescape);
-
-PyAPI_FUNC(wchar_t*) _Py_DecodeUTF8_surrogateescape(
- const char *arg,
- Py_ssize_t arglen);
-
-PyAPI_FUNC(int) _Py_DecodeLocaleEx(
- const char *arg,
- wchar_t **wstr,
- size_t *wlen,
- const char **reason,
- int current_locale,
- int surrogateescape);
-
-PyAPI_FUNC(int) _Py_EncodeLocaleEx(
- const wchar_t *text,
- char **str,
- size_t *error_pos,
- const char **reason,
- int current_locale,
- int surrogateescape);
-#endif
-
-#ifndef Py_LIMITED_API
-PyAPI_FUNC(PyObject *) _Py_device_encoding(int);
-
-#if defined(MS_WINDOWS) || defined(__APPLE__)
- /* On Windows, the count parameter of read() is an int (bpo-9015, bpo-9611).
- On macOS 10.13, read() and write() with more than INT_MAX bytes
- fail with EINVAL (bpo-24658). */
-# define _PY_READ_MAX INT_MAX
-# define _PY_WRITE_MAX INT_MAX
-#else
- /* write() should truncate the input to PY_SSIZE_T_MAX bytes,
- but it's safer to do it ourself to have a portable behaviour */
-# define _PY_READ_MAX PY_SSIZE_T_MAX
-# define _PY_WRITE_MAX PY_SSIZE_T_MAX
-#endif
-
-#ifdef MS_WINDOWS
-struct _Py_stat_struct {
- unsigned long st_dev;
- uint64_t st_ino;
- unsigned short st_mode;
- int st_nlink;
- int st_uid;
- int st_gid;
- unsigned long st_rdev;
- __int64 st_size;
- time_t st_atime;
- int st_atime_nsec;
- time_t st_mtime;
- int st_mtime_nsec;
- time_t st_ctime;
- int st_ctime_nsec;
- unsigned long st_file_attributes;
-};
-#else
-# define _Py_stat_struct stat
-#endif
-
-PyAPI_FUNC(int) _Py_fstat(
- int fd,
- struct _Py_stat_struct *status);
-
-PyAPI_FUNC(int) _Py_fstat_noraise(
- int fd,
- struct _Py_stat_struct *status);
-
-PyAPI_FUNC(int) _Py_stat(
- PyObject *path,
- struct stat *status);
-
-PyAPI_FUNC(int) _Py_open(
- const char *pathname,
- int flags);
-
-PyAPI_FUNC(int) _Py_open_noraise(
- const char *pathname,
- int flags);
-
-PyAPI_FUNC(FILE *) _Py_wfopen(
- const wchar_t *path,
- const wchar_t *mode);
-
-PyAPI_FUNC(FILE*) _Py_fopen(
- const char *pathname,
- const char *mode);
-
-PyAPI_FUNC(FILE*) _Py_fopen_obj(
- PyObject *path,
- const char *mode);
-
-PyAPI_FUNC(Py_ssize_t) _Py_read(
- int fd,
- void *buf,
- size_t count);
-
-PyAPI_FUNC(Py_ssize_t) _Py_write(
- int fd,
- const void *buf,
- size_t count);
-
-PyAPI_FUNC(Py_ssize_t) _Py_write_noraise(
- int fd,
- const void *buf,
- size_t count);
-
-#ifdef HAVE_READLINK
-PyAPI_FUNC(int) _Py_wreadlink(
- const wchar_t *path,
- wchar_t *buf,
- size_t bufsiz);
-#endif
-
-#ifdef HAVE_REALPATH
-PyAPI_FUNC(wchar_t*) _Py_wrealpath(
- const wchar_t *path,
- wchar_t *resolved_path,
- size_t resolved_path_size);
-#endif
-
-PyAPI_FUNC(wchar_t*) _Py_wgetcwd(
- wchar_t *buf,
- size_t size);
-
-PyAPI_FUNC(int) _Py_get_inheritable(int fd);
-
-PyAPI_FUNC(int) _Py_set_inheritable(int fd, int inheritable,
- int *atomic_flag_works);
-
-PyAPI_FUNC(int) _Py_set_inheritable_async_safe(int fd, int inheritable,
- int *atomic_flag_works);
-
-PyAPI_FUNC(int) _Py_dup(int fd);
-
-#ifndef MS_WINDOWS
-PyAPI_FUNC(int) _Py_get_blocking(int fd);
-
-PyAPI_FUNC(int) _Py_set_blocking(int fd, int blocking);
-#endif /* !MS_WINDOWS */
-
-PyAPI_FUNC(int) _Py_GetLocaleconvNumeric(
- PyObject **decimal_point,
- PyObject **thousands_sep,
- const char **grouping);
-
-#endif /* Py_LIMITED_API */
-
-#ifdef Py_BUILD_CORE
-PyAPI_FUNC(int) _Py_GetForceASCII(void);
-
-/* Reset "force ASCII" mode (if it was initialized).
-
- This function should be called when Python changes the LC_CTYPE locale,
- so the "force ASCII" mode can be detected again on the new locale
- encoding. */
-PyAPI_FUNC(void) _Py_ResetForceASCII(void);
-#endif
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif /* !Py_FILEUTILS_H */
diff --git a/pythonsdk/include/floatobject.h b/pythonsdk/include/floatobject.h
deleted file mode 100644
index cc906f11f0fe01880b7e1b2aa63ada87bef0f8dc..0000000000000000000000000000000000000000
--- a/pythonsdk/include/floatobject.h
+++ /dev/null
@@ -1,130 +0,0 @@
-
-/* Float object interface */
-
-/*
-PyFloatObject represents a (double precision) floating point number.
-*/
-
-#ifndef Py_FLOATOBJECT_H
-#define Py_FLOATOBJECT_H
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-#ifndef Py_LIMITED_API
-typedef struct {
- PyObject_HEAD
- double ob_fval;
-} PyFloatObject;
-#endif
-
-PyAPI_DATA(PyTypeObject) PyFloat_Type;
-
-#define PyFloat_Check(op) PyObject_TypeCheck(op, &PyFloat_Type)
-#define PyFloat_CheckExact(op) (Py_TYPE(op) == &PyFloat_Type)
-
-#ifdef Py_NAN
-#define Py_RETURN_NAN return PyFloat_FromDouble(Py_NAN)
-#endif
-
-#define Py_RETURN_INF(sign) do \
- if (copysign(1., sign) == 1.) { \
- return PyFloat_FromDouble(Py_HUGE_VAL); \
- } else { \
- return PyFloat_FromDouble(-Py_HUGE_VAL); \
- } while(0)
-
-PyAPI_FUNC(double) PyFloat_GetMax(void);
-PyAPI_FUNC(double) PyFloat_GetMin(void);
-PyAPI_FUNC(PyObject *) PyFloat_GetInfo(void);
-
-/* Return Python float from string PyObject. */
-PyAPI_FUNC(PyObject *) PyFloat_FromString(PyObject*);
-
-/* Return Python float from C double. */
-PyAPI_FUNC(PyObject *) PyFloat_FromDouble(double);
-
-/* Extract C double from Python float. The macro version trades safety for
- speed. */
-PyAPI_FUNC(double) PyFloat_AsDouble(PyObject *);
-#ifndef Py_LIMITED_API
-#define PyFloat_AS_DOUBLE(op) (((PyFloatObject *)(op))->ob_fval)
-#endif
-
-#ifndef Py_LIMITED_API
-/* _PyFloat_{Pack,Unpack}{4,8}
- *
- * The struct and pickle (at least) modules need an efficient platform-
- * independent way to store floating-point values as byte strings.
- * The Pack routines produce a string from a C double, and the Unpack
- * routines produce a C double from such a string. The suffix (4 or 8)
- * specifies the number of bytes in the string.
- *
- * On platforms that appear to use (see _PyFloat_Init()) IEEE-754 formats
- * these functions work by copying bits. On other platforms, the formats the
- * 4- byte format is identical to the IEEE-754 single precision format, and
- * the 8-byte format to the IEEE-754 double precision format, although the
- * packing of INFs and NaNs (if such things exist on the platform) isn't
- * handled correctly, and attempting to unpack a string containing an IEEE
- * INF or NaN will raise an exception.
- *
- * On non-IEEE platforms with more precision, or larger dynamic range, than
- * 754 supports, not all values can be packed; on non-IEEE platforms with less
- * precision, or smaller dynamic range, not all values can be unpacked. What
- * happens in such cases is partly accidental (alas).
- */
-
-/* The pack routines write 2, 4 or 8 bytes, starting at p. le is a bool
- * argument, true if you want the string in little-endian format (exponent
- * last, at p+1, p+3 or p+7), false if you want big-endian format (exponent
- * first, at p).
- * Return value: 0 if all is OK, -1 if error (and an exception is
- * set, most likely OverflowError).
- * There are two problems on non-IEEE platforms:
- * 1): What this does is undefined if x is a NaN or infinity.
- * 2): -0.0 and +0.0 produce the same string.
- */
-PyAPI_FUNC(int) _PyFloat_Pack2(double x, unsigned char *p, int le);
-PyAPI_FUNC(int) _PyFloat_Pack4(double x, unsigned char *p, int le);
-PyAPI_FUNC(int) _PyFloat_Pack8(double x, unsigned char *p, int le);
-
-/* Needed for the old way for marshal to store a floating point number.
- Returns the string length copied into p, -1 on error.
- */
-PyAPI_FUNC(int) _PyFloat_Repr(double x, char *p, size_t len);
-
-/* Used to get the important decimal digits of a double */
-PyAPI_FUNC(int) _PyFloat_Digits(char *buf, double v, int *signum);
-PyAPI_FUNC(void) _PyFloat_DigitsInit(void);
-
-/* The unpack routines read 2, 4 or 8 bytes, starting at p. le is a bool
- * argument, true if the string is in little-endian format (exponent
- * last, at p+1, p+3 or p+7), false if big-endian (exponent first, at p).
- * Return value: The unpacked double. On error, this is -1.0 and
- * PyErr_Occurred() is true (and an exception is set, most likely
- * OverflowError). Note that on a non-IEEE platform this will refuse
- * to unpack a string that represents a NaN or infinity.
- */
-PyAPI_FUNC(double) _PyFloat_Unpack2(const unsigned char *p, int le);
-PyAPI_FUNC(double) _PyFloat_Unpack4(const unsigned char *p, int le);
-PyAPI_FUNC(double) _PyFloat_Unpack8(const unsigned char *p, int le);
-
-/* free list api */
-PyAPI_FUNC(int) PyFloat_ClearFreeList(void);
-
-PyAPI_FUNC(void) _PyFloat_DebugMallocStats(FILE* out);
-
-/* Format the object based on the format_spec, as defined in PEP 3101
- (Advanced String Formatting). */
-PyAPI_FUNC(int) _PyFloat_FormatAdvancedWriter(
- _PyUnicodeWriter *writer,
- PyObject *obj,
- PyObject *format_spec,
- Py_ssize_t start,
- Py_ssize_t end);
-#endif /* Py_LIMITED_API */
-
-#ifdef __cplusplus
-}
-#endif
-#endif /* !Py_FLOATOBJECT_H */
diff --git a/pythonsdk/include/frameobject.h b/pythonsdk/include/frameobject.h
deleted file mode 100644
index 60f0ae144fae1430c55c52a9b56238a49c4a01fe..0000000000000000000000000000000000000000
--- a/pythonsdk/include/frameobject.h
+++ /dev/null
@@ -1,93 +0,0 @@
-
-/* Frame object interface */
-
-#ifndef Py_LIMITED_API
-#ifndef Py_FRAMEOBJECT_H
-#define Py_FRAMEOBJECT_H
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-typedef struct {
- int b_type; /* what kind of block this is */
- int b_handler; /* where to jump to find handler */
- int b_level; /* value stack level to pop to */
-} PyTryBlock;
-
-typedef struct _frame {
- PyObject_VAR_HEAD
- struct _frame *f_back; /* previous frame, or NULL */
- PyCodeObject *f_code; /* code segment */
- PyObject *f_builtins; /* builtin symbol table (PyDictObject) */
- PyObject *f_globals; /* global symbol table (PyDictObject) */
- PyObject *f_locals; /* local symbol table (any mapping) */
- PyObject **f_valuestack; /* points after the last local */
- /* Next free slot in f_valuestack. Frame creation sets to f_valuestack.
- Frame evaluation usually NULLs it, but a frame that yields sets it
- to the current stack top. */
- PyObject **f_stacktop;
- PyObject *f_trace; /* Trace function */
- char f_trace_lines; /* Emit per-line trace events? */
- char f_trace_opcodes; /* Emit per-opcode trace events? */
-
- /* Borrowed reference to a generator, or NULL */
- PyObject *f_gen;
-
- int f_lasti; /* Last instruction if called */
- /* Call PyFrame_GetLineNumber() instead of reading this field
- directly. As of 2.3 f_lineno is only valid when tracing is
- active (i.e. when f_trace is set). At other times we use
- PyCode_Addr2Line to calculate the line from the current
- bytecode index. */
- int f_lineno; /* Current line number */
- int f_iblock; /* index in f_blockstack */
- char f_executing; /* whether the frame is still executing */
- PyTryBlock f_blockstack[CO_MAXBLOCKS]; /* for try and loop blocks */
- PyObject *f_localsplus[1]; /* locals+stack, dynamically sized */
-} PyFrameObject;
-
-
-/* Standard object interface */
-
-PyAPI_DATA(PyTypeObject) PyFrame_Type;
-
-#define PyFrame_Check(op) (Py_TYPE(op) == &PyFrame_Type)
-
-PyAPI_FUNC(PyFrameObject *) PyFrame_New(PyThreadState *, PyCodeObject *,
- PyObject *, PyObject *);
-
-/* only internal use */
-PyFrameObject* _PyFrame_New_NoTrack(PyThreadState *, PyCodeObject *,
- PyObject *, PyObject *);
-
-
-/* The rest of the interface is specific for frame objects */
-
-/* Block management functions */
-
-PyAPI_FUNC(void) PyFrame_BlockSetup(PyFrameObject *, int, int, int);
-PyAPI_FUNC(PyTryBlock *) PyFrame_BlockPop(PyFrameObject *);
-
-/* Extend the value stack */
-
-PyAPI_FUNC(PyObject **) PyFrame_ExtendStack(PyFrameObject *, int, int);
-
-/* Conversions between "fast locals" and locals in dictionary */
-
-PyAPI_FUNC(void) PyFrame_LocalsToFast(PyFrameObject *, int);
-
-PyAPI_FUNC(int) PyFrame_FastToLocalsWithError(PyFrameObject *f);
-PyAPI_FUNC(void) PyFrame_FastToLocals(PyFrameObject *);
-
-PyAPI_FUNC(int) PyFrame_ClearFreeList(void);
-
-PyAPI_FUNC(void) _PyFrame_DebugMallocStats(FILE *out);
-
-/* Return the line of code the frame is currently executing. */
-PyAPI_FUNC(int) PyFrame_GetLineNumber(PyFrameObject *);
-
-#ifdef __cplusplus
-}
-#endif
-#endif /* !Py_FRAMEOBJECT_H */
-#endif /* Py_LIMITED_API */
diff --git a/pythonsdk/include/funcobject.h b/pythonsdk/include/funcobject.h
deleted file mode 100644
index 05254a8b913acd3367d40a39ee2dfe3fc1bcf564..0000000000000000000000000000000000000000
--- a/pythonsdk/include/funcobject.h
+++ /dev/null
@@ -1,103 +0,0 @@
-
-/* Function object interface */
-#ifndef Py_LIMITED_API
-#ifndef Py_FUNCOBJECT_H
-#define Py_FUNCOBJECT_H
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-/* Function objects and code objects should not be confused with each other:
- *
- * Function objects are created by the execution of the 'def' statement.
- * They reference a code object in their __code__ attribute, which is a
- * purely syntactic object, i.e. nothing more than a compiled version of some
- * source code lines. There is one code object per source code "fragment",
- * but each code object can be referenced by zero or many function objects
- * depending only on how many times the 'def' statement in the source was
- * executed so far.
- */
-
-typedef struct {
- PyObject_HEAD
- PyObject *func_code; /* A code object, the __code__ attribute */
- PyObject *func_globals; /* A dictionary (other mappings won't do) */
- PyObject *func_defaults; /* NULL or a tuple */
- PyObject *func_kwdefaults; /* NULL or a dict */
- PyObject *func_closure; /* NULL or a tuple of cell objects */
- PyObject *func_doc; /* The __doc__ attribute, can be anything */
- PyObject *func_name; /* The __name__ attribute, a string object */
- PyObject *func_dict; /* The __dict__ attribute, a dict or NULL */
- PyObject *func_weakreflist; /* List of weak references */
- PyObject *func_module; /* The __module__ attribute, can be anything */
- PyObject *func_annotations; /* Annotations, a dict or NULL */
- PyObject *func_qualname; /* The qualified name */
-
- /* Invariant:
- * func_closure contains the bindings for func_code->co_freevars, so
- * PyTuple_Size(func_closure) == PyCode_GetNumFree(func_code)
- * (func_closure may be NULL if PyCode_GetNumFree(func_code) == 0).
- */
-} PyFunctionObject;
-
-PyAPI_DATA(PyTypeObject) PyFunction_Type;
-
-#define PyFunction_Check(op) (Py_TYPE(op) == &PyFunction_Type)
-
-PyAPI_FUNC(PyObject *) PyFunction_New(PyObject *, PyObject *);
-PyAPI_FUNC(PyObject *) PyFunction_NewWithQualName(PyObject *, PyObject *, PyObject *);
-PyAPI_FUNC(PyObject *) PyFunction_GetCode(PyObject *);
-PyAPI_FUNC(PyObject *) PyFunction_GetGlobals(PyObject *);
-PyAPI_FUNC(PyObject *) PyFunction_GetModule(PyObject *);
-PyAPI_FUNC(PyObject *) PyFunction_GetDefaults(PyObject *);
-PyAPI_FUNC(int) PyFunction_SetDefaults(PyObject *, PyObject *);
-PyAPI_FUNC(PyObject *) PyFunction_GetKwDefaults(PyObject *);
-PyAPI_FUNC(int) PyFunction_SetKwDefaults(PyObject *, PyObject *);
-PyAPI_FUNC(PyObject *) PyFunction_GetClosure(PyObject *);
-PyAPI_FUNC(int) PyFunction_SetClosure(PyObject *, PyObject *);
-PyAPI_FUNC(PyObject *) PyFunction_GetAnnotations(PyObject *);
-PyAPI_FUNC(int) PyFunction_SetAnnotations(PyObject *, PyObject *);
-
-#ifndef Py_LIMITED_API
-PyAPI_FUNC(PyObject *) _PyFunction_FastCallDict(
- PyObject *func,
- PyObject *const *args,
- Py_ssize_t nargs,
- PyObject *kwargs);
-
-PyAPI_FUNC(PyObject *) _PyFunction_FastCallKeywords(
- PyObject *func,
- PyObject *const *stack,
- Py_ssize_t nargs,
- PyObject *kwnames);
-#endif
-
-/* Macros for direct access to these values. Type checks are *not*
- done, so use with care. */
-#define PyFunction_GET_CODE(func) \
- (((PyFunctionObject *)func) -> func_code)
-#define PyFunction_GET_GLOBALS(func) \
- (((PyFunctionObject *)func) -> func_globals)
-#define PyFunction_GET_MODULE(func) \
- (((PyFunctionObject *)func) -> func_module)
-#define PyFunction_GET_DEFAULTS(func) \
- (((PyFunctionObject *)func) -> func_defaults)
-#define PyFunction_GET_KW_DEFAULTS(func) \
- (((PyFunctionObject *)func) -> func_kwdefaults)
-#define PyFunction_GET_CLOSURE(func) \
- (((PyFunctionObject *)func) -> func_closure)
-#define PyFunction_GET_ANNOTATIONS(func) \
- (((PyFunctionObject *)func) -> func_annotations)
-
-/* The classmethod and staticmethod types lives here, too */
-PyAPI_DATA(PyTypeObject) PyClassMethod_Type;
-PyAPI_DATA(PyTypeObject) PyStaticMethod_Type;
-
-PyAPI_FUNC(PyObject *) PyClassMethod_New(PyObject *);
-PyAPI_FUNC(PyObject *) PyStaticMethod_New(PyObject *);
-
-#ifdef __cplusplus
-}
-#endif
-#endif /* !Py_FUNCOBJECT_H */
-#endif /* Py_LIMITED_API */
diff --git a/pythonsdk/include/genobject.h b/pythonsdk/include/genobject.h
deleted file mode 100644
index 709ff2ac299fbdb8774c6eb94181992cb11d0bf7..0000000000000000000000000000000000000000
--- a/pythonsdk/include/genobject.h
+++ /dev/null
@@ -1,105 +0,0 @@
-
-/* Generator object interface */
-
-#ifndef Py_LIMITED_API
-#ifndef Py_GENOBJECT_H
-#define Py_GENOBJECT_H
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-struct _frame; /* Avoid including frameobject.h */
-
-/* _PyGenObject_HEAD defines the initial segment of generator
- and coroutine objects. */
-#define _PyGenObject_HEAD(prefix) \
- PyObject_HEAD \
- /* Note: gi_frame can be NULL if the generator is "finished" */ \
- struct _frame *prefix##_frame; \
- /* True if generator is being executed. */ \
- char prefix##_running; \
- /* The code object backing the generator */ \
- PyObject *prefix##_code; \
- /* List of weak reference. */ \
- PyObject *prefix##_weakreflist; \
- /* Name of the generator. */ \
- PyObject *prefix##_name; \
- /* Qualified name of the generator. */ \
- PyObject *prefix##_qualname; \
- _PyErr_StackItem prefix##_exc_state;
-
-typedef struct {
- /* The gi_ prefix is intended to remind of generator-iterator. */
- _PyGenObject_HEAD(gi)
-} PyGenObject;
-
-PyAPI_DATA(PyTypeObject) PyGen_Type;
-
-#define PyGen_Check(op) PyObject_TypeCheck(op, &PyGen_Type)
-#define PyGen_CheckExact(op) (Py_TYPE(op) == &PyGen_Type)
-
-PyAPI_FUNC(PyObject *) PyGen_New(struct _frame *);
-PyAPI_FUNC(PyObject *) PyGen_NewWithQualName(struct _frame *,
- PyObject *name, PyObject *qualname);
-PyAPI_FUNC(int) PyGen_NeedsFinalizing(PyGenObject *);
-PyAPI_FUNC(int) _PyGen_SetStopIterationValue(PyObject *);
-PyAPI_FUNC(int) _PyGen_FetchStopIterationValue(PyObject **);
-PyAPI_FUNC(PyObject *) _PyGen_Send(PyGenObject *, PyObject *);
-PyObject *_PyGen_yf(PyGenObject *);
-PyAPI_FUNC(void) _PyGen_Finalize(PyObject *self);
-
-#ifndef Py_LIMITED_API
-typedef struct {
- _PyGenObject_HEAD(cr)
- PyObject *cr_origin;
-} PyCoroObject;
-
-PyAPI_DATA(PyTypeObject) PyCoro_Type;
-PyAPI_DATA(PyTypeObject) _PyCoroWrapper_Type;
-
-PyAPI_DATA(PyTypeObject) _PyAIterWrapper_Type;
-
-#define PyCoro_CheckExact(op) (Py_TYPE(op) == &PyCoro_Type)
-PyObject *_PyCoro_GetAwaitableIter(PyObject *o);
-PyAPI_FUNC(PyObject *) PyCoro_New(struct _frame *,
- PyObject *name, PyObject *qualname);
-
-/* Asynchronous Generators */
-
-typedef struct {
- _PyGenObject_HEAD(ag)
- PyObject *ag_finalizer;
-
- /* Flag is set to 1 when hooks set up by sys.set_asyncgen_hooks
- were called on the generator, to avoid calling them more
- than once. */
- int ag_hooks_inited;
-
- /* Flag is set to 1 when aclose() is called for the first time, or
- when a StopAsyncIteration exception is raised. */
- int ag_closed;
-} PyAsyncGenObject;
-
-PyAPI_DATA(PyTypeObject) PyAsyncGen_Type;
-PyAPI_DATA(PyTypeObject) _PyAsyncGenASend_Type;
-PyAPI_DATA(PyTypeObject) _PyAsyncGenWrappedValue_Type;
-PyAPI_DATA(PyTypeObject) _PyAsyncGenAThrow_Type;
-
-PyAPI_FUNC(PyObject *) PyAsyncGen_New(struct _frame *,
- PyObject *name, PyObject *qualname);
-
-#define PyAsyncGen_CheckExact(op) (Py_TYPE(op) == &PyAsyncGen_Type)
-
-PyObject *_PyAsyncGenValueWrapperNew(PyObject *);
-
-int PyAsyncGen_ClearFreeLists(void);
-
-#endif
-
-#undef _PyGenObject_HEAD
-
-#ifdef __cplusplus
-}
-#endif
-#endif /* !Py_GENOBJECT_H */
-#endif /* Py_LIMITED_API */
diff --git a/pythonsdk/include/graminit.h b/pythonsdk/include/graminit.h
deleted file mode 100644
index a8bc18aff8b9f2fa89f1ed466c314476c4927208..0000000000000000000000000000000000000000
--- a/pythonsdk/include/graminit.h
+++ /dev/null
@@ -1,89 +0,0 @@
-/* Generated by Parser/pgen */
-
-#define single_input 256
-#define file_input 257
-#define eval_input 258
-#define decorator 259
-#define decorators 260
-#define decorated 261
-#define async_funcdef 262
-#define funcdef 263
-#define parameters 264
-#define typedargslist 265
-#define tfpdef 266
-#define varargslist 267
-#define vfpdef 268
-#define stmt 269
-#define simple_stmt 270
-#define small_stmt 271
-#define expr_stmt 272
-#define annassign 273
-#define testlist_star_expr 274
-#define augassign 275
-#define del_stmt 276
-#define pass_stmt 277
-#define flow_stmt 278
-#define break_stmt 279
-#define continue_stmt 280
-#define return_stmt 281
-#define yield_stmt 282
-#define raise_stmt 283
-#define import_stmt 284
-#define import_name 285
-#define import_from 286
-#define import_as_name 287
-#define dotted_as_name 288
-#define import_as_names 289
-#define dotted_as_names 290
-#define dotted_name 291
-#define global_stmt 292
-#define nonlocal_stmt 293
-#define assert_stmt 294
-#define compound_stmt 295
-#define async_stmt 296
-#define if_stmt 297
-#define while_stmt 298
-#define for_stmt 299
-#define try_stmt 300
-#define with_stmt 301
-#define with_item 302
-#define except_clause 303
-#define suite 304
-#define test 305
-#define test_nocond 306
-#define lambdef 307
-#define lambdef_nocond 308
-#define or_test 309
-#define and_test 310
-#define not_test 311
-#define comparison 312
-#define comp_op 313
-#define star_expr 314
-#define expr 315
-#define xor_expr 316
-#define and_expr 317
-#define shift_expr 318
-#define arith_expr 319
-#define term 320
-#define factor 321
-#define power 322
-#define atom_expr 323
-#define atom 324
-#define testlist_comp 325
-#define trailer 326
-#define subscriptlist 327
-#define subscript 328
-#define sliceop 329
-#define exprlist 330
-#define testlist 331
-#define dictorsetmaker 332
-#define classdef 333
-#define arglist 334
-#define argument 335
-#define comp_iter 336
-#define sync_comp_for 337
-#define comp_for 338
-#define comp_if 339
-#define encoding_decl 340
-#define yield_expr 341
-#define yield_arg 342
diff --git a/pythonsdk/include/grammar.h b/pythonsdk/include/grammar.h
deleted file mode 100644
index ec8781be1c7d7a883aac445982496b2257cb07a2..0000000000000000000000000000000000000000
--- a/pythonsdk/include/grammar.h
+++ /dev/null
@@ -1,94 +0,0 @@
-
-/* Grammar interface */
-
-#ifndef Py_GRAMMAR_H
-#define Py_GRAMMAR_H
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-#include "bitset.h" /* Sigh... */
-
-/* A label of an arc */
-
-typedef struct {
- int lb_type;
- char *lb_str;
-} label;
-
-#define EMPTY 0 /* Label number 0 is by definition the empty label */
-
-/* A list of labels */
-
-typedef struct {
- int ll_nlabels;
- label *ll_label;
-} labellist;
-
-/* An arc from one state to another */
-
-typedef struct {
- short a_lbl; /* Label of this arc */
- short a_arrow; /* State where this arc goes to */
-} arc;
-
-/* A state in a DFA */
-
-typedef struct {
- int s_narcs;
- arc *s_arc; /* Array of arcs */
-
- /* Optional accelerators */
- int s_lower; /* Lowest label index */
- int s_upper; /* Highest label index */
- int *s_accel; /* Accelerator */
- int s_accept; /* Nonzero for accepting state */
-} state;
-
-/* A DFA */
-
-typedef struct {
- int d_type; /* Non-terminal this represents */
- char *d_name; /* For printing */
- int d_initial; /* Initial state */
- int d_nstates;
- state *d_state; /* Array of states */
- bitset d_first;
-} dfa;
-
-/* A grammar */
-
-typedef struct {
- int g_ndfas;
- dfa *g_dfa; /* Array of DFAs */
- labellist g_ll;
- int g_start; /* Start symbol of the grammar */
- int g_accel; /* Set if accelerators present */
-} grammar;
-
-/* FUNCTIONS */
-
-grammar *newgrammar(int start);
-void freegrammar(grammar *g);
-dfa *adddfa(grammar *g, int type, const char *name);
-int addstate(dfa *d);
-void addarc(dfa *d, int from, int to, int lbl);
-dfa *PyGrammar_FindDFA(grammar *g, int type);
-
-int addlabel(labellist *ll, int type, const char *str);
-int findlabel(labellist *ll, int type, const char *str);
-const char *PyGrammar_LabelRepr(label *lb);
-void translatelabels(grammar *g);
-
-void addfirstsets(grammar *g);
-
-void PyGrammar_AddAccelerators(grammar *g);
-void PyGrammar_RemoveAccelerators(grammar *);
-
-void printgrammar(grammar *g, FILE *fp);
-void printnonterminals(grammar *g, FILE *fp);
-
-#ifdef __cplusplus
-}
-#endif
-#endif /* !Py_GRAMMAR_H */
diff --git a/pythonsdk/include/import.h b/pythonsdk/include/import.h
deleted file mode 100644
index 1bb108aebf552a7754d3e9b23b8aa399c27f6f59..0000000000000000000000000000000000000000
--- a/pythonsdk/include/import.h
+++ /dev/null
@@ -1,151 +0,0 @@
-
-/* Module definition and import interface */
-
-#ifndef Py_IMPORT_H
-#define Py_IMPORT_H
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-#ifndef Py_LIMITED_API
-PyAPI_FUNC(_PyInitError) _PyImportZip_Init(void);
-
-PyMODINIT_FUNC PyInit__imp(void);
-#endif /* !Py_LIMITED_API */
-PyAPI_FUNC(long) PyImport_GetMagicNumber(void);
-PyAPI_FUNC(const char *) PyImport_GetMagicTag(void);
-PyAPI_FUNC(PyObject *) PyImport_ExecCodeModule(
- const char *name, /* UTF-8 encoded string */
- PyObject *co
- );
-PyAPI_FUNC(PyObject *) PyImport_ExecCodeModuleEx(
- const char *name, /* UTF-8 encoded string */
- PyObject *co,
- const char *pathname /* decoded from the filesystem encoding */
- );
-PyAPI_FUNC(PyObject *) PyImport_ExecCodeModuleWithPathnames(
- const char *name, /* UTF-8 encoded string */
- PyObject *co,
- const char *pathname, /* decoded from the filesystem encoding */
- const char *cpathname /* decoded from the filesystem encoding */
- );
-#if !defined(Py_LIMITED_API) || Py_LIMITED_API+0 >= 0x03030000
-PyAPI_FUNC(PyObject *) PyImport_ExecCodeModuleObject(
- PyObject *name,
- PyObject *co,
- PyObject *pathname,
- PyObject *cpathname
- );
-#endif
-PyAPI_FUNC(PyObject *) PyImport_GetModuleDict(void);
-#if !defined(Py_LIMITED_API) || Py_LIMITED_API+0 >= 0x03070000
-PyAPI_FUNC(PyObject *) PyImport_GetModule(PyObject *name);
-#endif
-#ifndef Py_LIMITED_API
-PyAPI_FUNC(int) _PyImport_IsInitialized(PyInterpreterState *);
-PyAPI_FUNC(PyObject *) _PyImport_GetModuleId(struct _Py_Identifier *name);
-PyAPI_FUNC(PyObject *) _PyImport_AddModuleObject(PyObject *name,
- PyObject *modules);
-PyAPI_FUNC(int) _PyImport_SetModule(PyObject *name, PyObject *module);
-PyAPI_FUNC(int) _PyImport_SetModuleString(const char *name, PyObject* module);
-#endif
-#if !defined(Py_LIMITED_API) || Py_LIMITED_API+0 >= 0x03030000
-PyAPI_FUNC(PyObject *) PyImport_AddModuleObject(
- PyObject *name
- );
-#endif
-PyAPI_FUNC(PyObject *) PyImport_AddModule(
- const char *name /* UTF-8 encoded string */
- );
-PyAPI_FUNC(PyObject *) PyImport_ImportModule(
- const char *name /* UTF-8 encoded string */
- );
-PyAPI_FUNC(PyObject *) PyImport_ImportModuleNoBlock(
- const char *name /* UTF-8 encoded string */
- );
-PyAPI_FUNC(PyObject *) PyImport_ImportModuleLevel(
- const char *name, /* UTF-8 encoded string */
- PyObject *globals,
- PyObject *locals,
- PyObject *fromlist,
- int level
- );
-#if !defined(Py_LIMITED_API) || Py_LIMITED_API+0 >= 0x03050000
-PyAPI_FUNC(PyObject *) PyImport_ImportModuleLevelObject(
- PyObject *name,
- PyObject *globals,
- PyObject *locals,
- PyObject *fromlist,
- int level
- );
-#endif
-
-#define PyImport_ImportModuleEx(n, g, l, f) \
- PyImport_ImportModuleLevel(n, g, l, f, 0)
-
-PyAPI_FUNC(PyObject *) PyImport_GetImporter(PyObject *path);
-PyAPI_FUNC(PyObject *) PyImport_Import(PyObject *name);
-PyAPI_FUNC(PyObject *) PyImport_ReloadModule(PyObject *m);
-PyAPI_FUNC(void) PyImport_Cleanup(void);
-#if !defined(Py_LIMITED_API) || Py_LIMITED_API+0 >= 0x03030000
-PyAPI_FUNC(int) PyImport_ImportFrozenModuleObject(
- PyObject *name
- );
-#endif
-PyAPI_FUNC(int) PyImport_ImportFrozenModule(
- const char *name /* UTF-8 encoded string */
- );
-
-#ifndef Py_LIMITED_API
-PyAPI_FUNC(void) _PyImport_AcquireLock(void);
-PyAPI_FUNC(int) _PyImport_ReleaseLock(void);
-
-PyAPI_FUNC(void) _PyImport_ReInitLock(void);
-
-PyAPI_FUNC(PyObject *) _PyImport_FindBuiltin(
- const char *name, /* UTF-8 encoded string */
- PyObject *modules
- );
-PyAPI_FUNC(PyObject *) _PyImport_FindExtensionObject(PyObject *, PyObject *);
-PyAPI_FUNC(PyObject *) _PyImport_FindExtensionObjectEx(PyObject *, PyObject *,
- PyObject *);
-PyAPI_FUNC(int) _PyImport_FixupBuiltin(
- PyObject *mod,
- const char *name, /* UTF-8 encoded string */
- PyObject *modules
- );
-PyAPI_FUNC(int) _PyImport_FixupExtensionObject(PyObject*, PyObject *,
- PyObject *, PyObject *);
-
-struct _inittab {
- const char *name; /* ASCII encoded string */
- PyObject* (*initfunc)(void);
-};
-PyAPI_DATA(struct _inittab *) PyImport_Inittab;
-PyAPI_FUNC(int) PyImport_ExtendInittab(struct _inittab *newtab);
-#endif /* Py_LIMITED_API */
-
-PyAPI_DATA(PyTypeObject) PyNullImporter_Type;
-
-PyAPI_FUNC(int) PyImport_AppendInittab(
- const char *name, /* ASCII encoded string */
- PyObject* (*initfunc)(void)
- );
-
-#ifndef Py_LIMITED_API
-struct _frozen {
- const char *name; /* ASCII encoded string */
- const unsigned char *code;
- int size;
-};
-
-/* Embedding apps may change this pointer to point to their favorite
- collection of frozen modules: */
-
-PyAPI_DATA(const struct _frozen *) PyImport_FrozenModules;
-#endif
-
-#ifdef __cplusplus
-}
-#endif
-#endif /* !Py_IMPORT_H */
diff --git a/pythonsdk/include/internal/ceval.h b/pythonsdk/include/internal/ceval.h
deleted file mode 100644
index b47b998855f815cf8b185aeae92413872959e7af..0000000000000000000000000000000000000000
--- a/pythonsdk/include/internal/ceval.h
+++ /dev/null
@@ -1,52 +0,0 @@
-#ifndef Py_INTERNAL_CEVAL_H
-#define Py_INTERNAL_CEVAL_H
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-#include "pyatomic.h"
-#include "pythread.h"
-
-struct _pending_calls {
- unsigned long main_thread;
- PyThread_type_lock lock;
- /* Request for running pending calls. */
- _Py_atomic_int calls_to_do;
- /* Request for looking at the `async_exc` field of the current
- thread state.
- Guarded by the GIL. */
- int async_exc;
-#define NPENDINGCALLS 32
- struct {
- int (*func)(void *);
- void *arg;
- } calls[NPENDINGCALLS];
- int first;
- int last;
-};
-
-#include "internal/gil.h"
-
-struct _ceval_runtime_state {
- int recursion_limit;
- /* Records whether tracing is on for any thread. Counts the number
- of threads for which tstate->c_tracefunc is non-NULL, so if the
- value is 0, we know we don't have to check this thread's
- c_tracefunc. This speeds up the if statement in
- PyEval_EvalFrameEx() after fast_next_opcode. */
- int tracing_possible;
- /* This single variable consolidates all requests to break out of
- the fast path in the eval loop. */
- _Py_atomic_int eval_breaker;
- /* Request for dropping the GIL */
- _Py_atomic_int gil_drop_request;
- struct _pending_calls pending;
- struct _gil_runtime_state gil;
-};
-
-PyAPI_FUNC(void) _PyEval_Initialize(struct _ceval_runtime_state *);
-
-#ifdef __cplusplus
-}
-#endif
-#endif /* !Py_INTERNAL_CEVAL_H */
diff --git a/pythonsdk/include/internal/condvar.h b/pythonsdk/include/internal/condvar.h
deleted file mode 100644
index ba6daaaff8d02525c57f7b48c20b29d4bcfdbb43..0000000000000000000000000000000000000000
--- a/pythonsdk/include/internal/condvar.h
+++ /dev/null
@@ -1,91 +0,0 @@
-#ifndef Py_INTERNAL_CONDVAR_H
-#define Py_INTERNAL_CONDVAR_H
-
-#ifndef _POSIX_THREADS
-/* This means pthreads are not implemented in libc headers, hence the macro
- not present in unistd.h. But they still can be implemented as an external
- library (e.g. gnu pth in pthread emulation) */
-# ifdef HAVE_PTHREAD_H
-# include <pthread.h> /* _POSIX_THREADS */
-# endif
-#endif
-
-#ifdef _POSIX_THREADS
-/*
- * POSIX support
- */
-#define Py_HAVE_CONDVAR
-
-#include <pthread.h>
-
-#define PyMUTEX_T pthread_mutex_t
-#define PyCOND_T pthread_cond_t
-
-#elif defined(NT_THREADS)
-/*
- * Windows (XP, 2003 server and later, as well as (hopefully) CE) support
- *
- * Emulated condition variables ones that work with XP and later, plus
- * example native support on VISTA and onwards.
- */
-#define Py_HAVE_CONDVAR
-
-/* include windows if it hasn't been done before */
-#define WIN32_LEAN_AND_MEAN
-#include <windows.h>
-
-/* options */
-/* non-emulated condition variables are provided for those that want
- * to target Windows Vista. Modify this macro to enable them.
- */
-#ifndef _PY_EMULATED_WIN_CV
-#define _PY_EMULATED_WIN_CV 1 /* use emulated condition variables */
-#endif
-
-/* fall back to emulation if not targeting Vista */
-#if !defined NTDDI_VISTA || NTDDI_VERSION < NTDDI_VISTA
-#undef _PY_EMULATED_WIN_CV
-#define _PY_EMULATED_WIN_CV 1
-#endif
-
-#if _PY_EMULATED_WIN_CV
-
-typedef CRITICAL_SECTION PyMUTEX_T;
-
-/* The ConditionVariable object. From XP onwards it is easily emulated
- with a Semaphore.
- Semaphores are available on Windows XP (2003 server) and later.
- We use a Semaphore rather than an auto-reset event, because although
- an auto-resent event might appear to solve the lost-wakeup bug (race
- condition between releasing the outer lock and waiting) because it
- maintains state even though a wait hasn't happened, there is still
- a lost wakeup problem if more than one thread are interrupted in the
- critical place. A semaphore solves that, because its state is
- counted, not Boolean.
- Because it is ok to signal a condition variable with no one
- waiting, we need to keep track of the number of
- waiting threads. Otherwise, the semaphore's state could rise
- without bound. This also helps reduce the number of "spurious wakeups"
- that would otherwise happen.
- */
-
-typedef struct _PyCOND_T
-{
- HANDLE sem;
- int waiting; /* to allow PyCOND_SIGNAL to be a no-op */
-} PyCOND_T;
-
-#else /* !_PY_EMULATED_WIN_CV */
-
-/* Use native Win7 primitives if build target is Win7 or higher */
-
-/* SRWLOCK is faster and better than CriticalSection */
-typedef SRWLOCK PyMUTEX_T;
-
-typedef CONDITION_VARIABLE PyCOND_T;
-
-#endif /* _PY_EMULATED_WIN_CV */
-
-#endif /* _POSIX_THREADS, NT_THREADS */
-
-#endif /* Py_INTERNAL_CONDVAR_H */
diff --git a/pythonsdk/include/internal/context.h b/pythonsdk/include/internal/context.h
deleted file mode 100644
index dd87f0ba20a38f98688fdc6e81a8d5b9204d7999..0000000000000000000000000000000000000000
--- a/pythonsdk/include/internal/context.h
+++ /dev/null
@@ -1,41 +0,0 @@
-#ifndef Py_INTERNAL_CONTEXT_H
-#define Py_INTERNAL_CONTEXT_H
-
-
-#include "internal/hamt.h"
-
-
-struct _pycontextobject {
- PyObject_HEAD
- PyContext *ctx_prev;
- PyHamtObject *ctx_vars;
- PyObject *ctx_weakreflist;
- int ctx_entered;
-};
-
-
-struct _pycontextvarobject {
- PyObject_HEAD
- PyObject *var_name;
- PyObject *var_default;
- PyObject *var_cached;
- uint64_t var_cached_tsid;
- uint64_t var_cached_tsver;
- Py_hash_t var_hash;
-};
-
-
-struct _pycontexttokenobject {
- PyObject_HEAD
- PyContext *tok_ctx;
- PyContextVar *tok_var;
- PyObject *tok_oldval;
- int tok_used;
-};
-
-
-int _PyContext_Init(void);
-void _PyContext_Fini(void);
-
-
-#endif /* !Py_INTERNAL_CONTEXT_H */
diff --git a/pythonsdk/include/internal/gil.h b/pythonsdk/include/internal/gil.h
deleted file mode 100644
index aacebfd372e9ce80a3dabf37a7e321f91659177b..0000000000000000000000000000000000000000
--- a/pythonsdk/include/internal/gil.h
+++ /dev/null
@@ -1,46 +0,0 @@
-#ifndef Py_INTERNAL_GIL_H
-#define Py_INTERNAL_GIL_H
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-#include "pyatomic.h"
-
-#include "internal/condvar.h"
-#ifndef Py_HAVE_CONDVAR
-#error You need either a POSIX-compatible or a Windows system!
-#endif
-
-/* Enable if you want to force the switching of threads at least
- every `interval`. */
-#undef FORCE_SWITCHING
-#define FORCE_SWITCHING
-
-struct _gil_runtime_state {
- /* microseconds (the Python API uses seconds, though) */
- unsigned long interval;
- /* Last PyThreadState holding / having held the GIL. This helps us
- know whether anyone else was scheduled after we dropped the GIL. */
- _Py_atomic_address last_holder;
- /* Whether the GIL is already taken (-1 if uninitialized). This is
- atomic because it can be read without any lock taken in ceval.c. */
- _Py_atomic_int locked;
- /* Number of GIL switches since the beginning. */
- unsigned long switch_number;
- /* This condition variable allows one or several threads to wait
- until the GIL is released. In addition, the mutex also protects
- the above variables. */
- PyCOND_T cond;
- PyMUTEX_T mutex;
-#ifdef FORCE_SWITCHING
- /* This condition variable helps the GIL-releasing thread wait for
- a GIL-awaiting thread to be scheduled and take the GIL. */
- PyCOND_T switch_cond;
- PyMUTEX_T switch_mutex;
-#endif
-};
-
-#ifdef __cplusplus
-}
-#endif
-#endif /* !Py_INTERNAL_GIL_H */
diff --git a/pythonsdk/include/internal/hamt.h b/pythonsdk/include/internal/hamt.h
deleted file mode 100644
index 2606ddbf86106dce2e9ce0ec77265332c93cca7e..0000000000000000000000000000000000000000
--- a/pythonsdk/include/internal/hamt.h
+++ /dev/null
@@ -1,113 +0,0 @@
-#ifndef Py_INTERNAL_HAMT_H
-#define Py_INTERNAL_HAMT_H
-
-
-#define _Py_HAMT_MAX_TREE_DEPTH 7
-
-
-#define PyHamt_Check(o) (Py_TYPE(o) == &_PyHamt_Type)
-
-
-/* Abstract tree node. */
-typedef struct {
- PyObject_HEAD
-} PyHamtNode;
-
-
-/* An HAMT immutable mapping collection. */
-typedef struct {
- PyObject_HEAD
- PyHamtNode *h_root;
- PyObject *h_weakreflist;
- Py_ssize_t h_count;
-} PyHamtObject;
-
-
-/* A struct to hold the state of depth-first traverse of the tree.
-
- HAMT is an immutable collection. Iterators will hold a strong reference
- to it, and every node in the HAMT has strong references to its children.
-
- So for iterators, we can implement zero allocations and zero reference
- inc/dec depth-first iteration.
-
- - i_nodes: an array of seven pointers to tree nodes
- - i_level: the current node in i_nodes
- - i_pos: an array of positions within nodes in i_nodes.
-*/
-typedef struct {
- PyHamtNode *i_nodes[_Py_HAMT_MAX_TREE_DEPTH];
- Py_ssize_t i_pos[_Py_HAMT_MAX_TREE_DEPTH];
- int8_t i_level;
-} PyHamtIteratorState;
-
-
-/* Base iterator object.
-
- Contains the iteration state, a pointer to the HAMT tree,
- and a pointer to the 'yield function'. The latter is a simple
- function that returns a key/value tuple for the 'Items' iterator,
- just a key for the 'Keys' iterator, and a value for the 'Values'
- iterator.
-*/
-typedef struct {
- PyObject_HEAD
- PyHamtObject *hi_obj;
- PyHamtIteratorState hi_iter;
- binaryfunc hi_yield;
-} PyHamtIterator;
-
-
-PyAPI_DATA(PyTypeObject) _PyHamt_Type;
-PyAPI_DATA(PyTypeObject) _PyHamt_ArrayNode_Type;
-PyAPI_DATA(PyTypeObject) _PyHamt_BitmapNode_Type;
-PyAPI_DATA(PyTypeObject) _PyHamt_CollisionNode_Type;
-PyAPI_DATA(PyTypeObject) _PyHamtKeys_Type;
-PyAPI_DATA(PyTypeObject) _PyHamtValues_Type;
-PyAPI_DATA(PyTypeObject) _PyHamtItems_Type;
-
-
-/* Create a new HAMT immutable mapping. */
-PyHamtObject * _PyHamt_New(void);
-
-/* Return a new collection based on "o", but with an additional
- key/val pair. */
-PyHamtObject * _PyHamt_Assoc(PyHamtObject *o, PyObject *key, PyObject *val);
-
-/* Return a new collection based on "o", but without "key". */
-PyHamtObject * _PyHamt_Without(PyHamtObject *o, PyObject *key);
-
-/* Find "key" in the "o" collection.
-
- Return:
- - -1: An error occurred.
- - 0: "key" wasn't found in "o".
- - 1: "key" is in "o"; "*val" is set to its value (a borrowed ref).
-*/
-int _PyHamt_Find(PyHamtObject *o, PyObject *key, PyObject **val);
-
-/* Check if "v" is equal to "w".
-
- Return:
- - 0: v != w
- - 1: v == w
- - -1: An error occurred.
-*/
-int _PyHamt_Eq(PyHamtObject *v, PyHamtObject *w);
-
-/* Return the size of "o"; equivalent of "len(o)". */
-Py_ssize_t _PyHamt_Len(PyHamtObject *o);
-
-/* Return a Keys iterator over "o". */
-PyObject * _PyHamt_NewIterKeys(PyHamtObject *o);
-
-/* Return a Values iterator over "o". */
-PyObject * _PyHamt_NewIterValues(PyHamtObject *o);
-
-/* Return a Items iterator over "o". */
-PyObject * _PyHamt_NewIterItems(PyHamtObject *o);
-
-int _PyHamt_Init(void);
-void _PyHamt_Fini(void);
-
-#endif /* !Py_INTERNAL_HAMT_H */
diff --git a/pythonsdk/include/internal/hash.h b/pythonsdk/include/internal/hash.h
deleted file mode 100644
index cfea96fdfff6952aca052f5ae1dc2bf6f0c9af6f..0000000000000000000000000000000000000000
--- a/pythonsdk/include/internal/hash.h
+++ /dev/null
@@ -1,6 +0,0 @@
-#ifndef Py_INTERNAL_HASH_H
-#define Py_INTERNAL_HASH_H
-
-uint64_t _Py_KeyedHash(uint64_t, const char *, Py_ssize_t);
-
-#endif
diff --git a/pythonsdk/include/internal/import.h b/pythonsdk/include/internal/import.h
deleted file mode 100644
index 9aba6fe35877e7c1760bfa0b3e523e4868d7972c..0000000000000000000000000000000000000000
--- a/pythonsdk/include/internal/import.h
+++ /dev/null
@@ -1,6 +0,0 @@
-#ifndef Py_INTERNAL_IMPORT_H
-#define Py_INTERNAL_IMPORT_H
-
-extern const char *_Py_CheckHashBasedPycsMode;
-
-#endif
diff --git a/pythonsdk/include/internal/mem.h b/pythonsdk/include/internal/mem.h
deleted file mode 100644
index 7b0b4890a86c9f31821c5cf25f54280d720c729c..0000000000000000000000000000000000000000
--- a/pythonsdk/include/internal/mem.h
+++ /dev/null
@@ -1,175 +0,0 @@
-#ifndef Py_INTERNAL_MEM_H
-#define Py_INTERNAL_MEM_H
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-#include "objimpl.h"
-#include "pymem.h"
-
-
-/* GC runtime state */
-
-/* If we change this, we need to change the default value in the
- signature of gc.collect. */
-#define NUM_GENERATIONS 3
-
-/*
- NOTE: about the counting of long-lived objects.
-
- To limit the cost of garbage collection, there are two strategies;
- - make each collection faster, e.g. by scanning fewer objects
- - do less collections
- This heuristic is about the latter strategy.
-
- In addition to the various configurable thresholds, we only trigger a
- full collection if the ratio
- long_lived_pending / long_lived_total
- is above a given value (hardwired to 25%).
-
- The reason is that, while "non-full" collections (i.e., collections of
- the young and middle generations) will always examine roughly the same
- number of objects -- determined by the aforementioned thresholds --,
- the cost of a full collection is proportional to the total number of
- long-lived objects, which is virtually unbounded.
-
- Indeed, it has been remarked that doing a full collection every
- <constant number> of object creations entails a dramatic performance
- degradation in workloads which consist in creating and storing lots of
- long-lived objects (e.g. building a large list of GC-tracked objects would
- show quadratic performance, instead of linear as expected: see issue #4074).
-
- Using the above ratio, instead, yields amortized linear performance in
- the total number of objects (the effect of which can be summarized
- thusly: "each full garbage collection is more and more costly as the
- number of objects grows, but we do fewer and fewer of them").
-
- This heuristic was suggested by Martin von Löwis on python-dev in
- June 2008. His original analysis and proposal can be found at:
- http://mail.python.org/pipermail/python-dev/2008-June/080579.html
-*/
-
-/*
- NOTE: about untracking of mutable objects.
-
- Certain types of container cannot participate in a reference cycle, and
- so do not need to be tracked by the garbage collector. Untracking these
- objects reduces the cost of garbage collections. However, determining
- which objects may be untracked is not free, and the costs must be
- weighed against the benefits for garbage collection.
-
- There are two possible strategies for when to untrack a container:
-
- i) When the container is created.
- ii) When the container is examined by the garbage collector.
-
- Tuples containing only immutable objects (integers, strings etc, and
- recursively, tuples of immutable objects) do not need to be tracked.
- The interpreter creates a large number of tuples, many of which will
- not survive until garbage collection. It is therefore not worthwhile
- to untrack eligible tuples at creation time.
-
- Instead, all tuples except the empty tuple are tracked when created.
- During garbage collection it is determined whether any surviving tuples
- can be untracked. A tuple can be untracked if all of its contents are
- already not tracked. Tuples are examined for untracking in all garbage
- collection cycles. It may take more than one cycle to untrack a tuple.
-
- Dictionaries containing only immutable objects also do not need to be
- tracked. Dictionaries are untracked when created. If a tracked item is
- inserted into a dictionary (either as a key or value), the dictionary
- becomes tracked. During a full garbage collection (all generations),
- the collector will untrack any dictionaries whose contents are not
- tracked.
-
- The module provides the python function is_tracked(obj), which returns
- the CURRENT tracking status of the object. Subsequent garbage
- collections may change the tracking status of the object.
-
- Untracking of certain containers was introduced in issue #4688, and
- the algorithm was refined in response to issue #14775.
-*/
-
-struct gc_generation {
- PyGC_Head head;
- int threshold; /* collection threshold */
- int count; /* count of allocations or collections of younger
- generations */
-};
-
-/* Running stats per generation */
-struct gc_generation_stats {
- /* total number of collections */
- Py_ssize_t collections;
- /* total number of collected objects */
- Py_ssize_t collected;
- /* total number of uncollectable objects (put into gc.garbage) */
- Py_ssize_t uncollectable;
-};
-
-struct _gc_runtime_state {
- /* List of objects that still need to be cleaned up, singly linked
- * via their gc headers' gc_prev pointers. */
- PyObject *trash_delete_later;
- /* Current call-stack depth of tp_dealloc calls. */
- int trash_delete_nesting;
-
- int enabled;
- int debug;
- /* linked lists of container objects */
- struct gc_generation generations[NUM_GENERATIONS];
- PyGC_Head *generation0;
- /* a permanent generation which won't be collected */
- struct gc_generation permanent_generation;
- struct gc_generation_stats generation_stats[NUM_GENERATIONS];
- /* true if we are currently running the collector */
- int collecting;
- /* list of uncollectable objects */
- PyObject *garbage;
- /* a list of callbacks to be invoked when collection is performed */
- PyObject *callbacks;
- /* This is the number of objects that survived the last full
- collection. It approximates the number of long lived objects
- tracked by the GC.
-
- (by "full collection", we mean a collection of the oldest
- generation). */
- Py_ssize_t long_lived_total;
- /* This is the number of objects that survived all "non-full"
- collections, and are awaiting to undergo a full collection for
- the first time. */
- Py_ssize_t long_lived_pending;
-};
-
-PyAPI_FUNC(void) _PyGC_Initialize(struct _gc_runtime_state *);
-
-#define _PyGC_generation0 _PyRuntime.gc.generation0
-
-/* Heuristic checking if a pointer value is newly allocated
- (uninitialized) or newly freed. The pointer is not dereferenced, only the
- pointer value is checked.
-
- The heuristic relies on the debug hooks on Python memory allocators which
- fills newly allocated memory with CLEANBYTE (0xCD) and newly freed memory
- with DEADBYTE (0xDD). Detect also "untouchable bytes" marked
- with FORBIDDENBYTE (0xFD). */
-static inline int _PyMem_IsPtrFreed(void *ptr)
-{
- uintptr_t value = (uintptr_t)ptr;
-#if SIZEOF_VOID_P == 8
- return (value == (uintptr_t)0xCDCDCDCDCDCDCDCD
- || value == (uintptr_t)0xDDDDDDDDDDDDDDDD
- || value == (uintptr_t)0xFDFDFDFDFDFDFDFD);
-#elif SIZEOF_VOID_P == 4
- return (value == (uintptr_t)0xCDCDCDCD
- || value == (uintptr_t)0xDDDDDDDD
- || value == (uintptr_t)0xFDFDFDFD);
-#else
-# error "unknown pointer size"
-#endif
-}
-
-#ifdef __cplusplus
-}
-#endif
-#endif /* !Py_INTERNAL_MEM_H */
diff --git a/pythonsdk/include/internal/pygetopt.h b/pythonsdk/include/internal/pygetopt.h
deleted file mode 100644
index d2228311fb17248e500c7014a213033684acb376..0000000000000000000000000000000000000000
--- a/pythonsdk/include/internal/pygetopt.h
+++ /dev/null
@@ -1,19 +0,0 @@
-#ifndef Py_INTERNAL_PYGETOPT_H
-#define Py_INTERNAL_PYGETOPT_H
-
-extern int _PyOS_opterr;
-extern int _PyOS_optind;
-extern wchar_t *_PyOS_optarg;
-
-extern void _PyOS_ResetGetOpt(void);
-
-typedef struct {
- const wchar_t *name;
- int has_arg;
- int val;
-} _PyOS_LongOption;
-
-extern int _PyOS_GetOpt(int argc, wchar_t **argv, wchar_t *optstring,
- const _PyOS_LongOption *longopts, int *longindex);
-
-#endif /* !Py_INTERNAL_PYGETOPT_H */
diff --git a/pythonsdk/include/internal/pystate.h b/pythonsdk/include/internal/pystate.h
deleted file mode 100644
index 91b6aaa51d5152376b3d3d37fdda0252f1a5b5ab..0000000000000000000000000000000000000000
--- a/pythonsdk/include/internal/pystate.h
+++ /dev/null
@@ -1,135 +0,0 @@
-#ifndef Py_INTERNAL_PYSTATE_H
-#define Py_INTERNAL_PYSTATE_H
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-#include "pystate.h"
-#include "pyatomic.h"
-#include "pythread.h"
-
-#include "internal/mem.h"
-#include "internal/ceval.h"
-#include "internal/warnings.h"
-
-
-/* GIL state */
-
-struct _gilstate_runtime_state {
- int check_enabled;
- /* Assuming the current thread holds the GIL, this is the
- PyThreadState for the current thread. */
- _Py_atomic_address tstate_current;
- PyThreadFrameGetter getframe;
- /* The single PyInterpreterState used by this process'
- GILState implementation
- */
- /* TODO: Given interp_main, it may be possible to kill this ref */
- PyInterpreterState *autoInterpreterState;
- Py_tss_t autoTSSkey;
-};
-
-/* hook for PyEval_GetFrame(), requested for Psyco */
-#define _PyThreadState_GetFrame _PyRuntime.gilstate.getframe
-
-/* Issue #26558: Flag to disable PyGILState_Check().
- If set to non-zero, PyGILState_Check() always return 1. */
-#define _PyGILState_check_enabled _PyRuntime.gilstate.check_enabled
-
-
-typedef struct {
- /* Full path to the Python program */
- wchar_t *program_full_path;
- wchar_t *prefix;
-#ifdef MS_WINDOWS
- wchar_t *dll_path;
-#else
- wchar_t *exec_prefix;
-#endif
- /* Set by Py_SetPath(), or computed by _PyPathConfig_Init() */
- wchar_t *module_search_path;
- /* Python program name */
- wchar_t *program_name;
- /* Set by Py_SetPythonHome() or PYTHONHOME environment variable */
- wchar_t *home;
-} _PyPathConfig;
-
-#define _PyPathConfig_INIT {.module_search_path = NULL}
-/* Note: _PyPathConfig_INIT sets other fields to 0/NULL */
-
-PyAPI_DATA(_PyPathConfig) _Py_path_config;
-
-PyAPI_FUNC(_PyInitError) _PyPathConfig_Calculate(
- _PyPathConfig *config,
- const _PyCoreConfig *core_config);
-PyAPI_FUNC(void) _PyPathConfig_Clear(_PyPathConfig *config);
-
-
-/* interpreter state */
-
-PyAPI_FUNC(PyInterpreterState *) _PyInterpreterState_LookUpID(PY_INT64_T);
-
-PyAPI_FUNC(int) _PyInterpreterState_IDInitref(PyInterpreterState *);
-PyAPI_FUNC(void) _PyInterpreterState_IDIncref(PyInterpreterState *);
-PyAPI_FUNC(void) _PyInterpreterState_IDDecref(PyInterpreterState *);
-
-/* Full Python runtime state */
-
-typedef struct pyruntimestate {
- int initialized;
- int core_initialized;
- PyThreadState *finalizing;
-
- struct pyinterpreters {
- PyThread_type_lock mutex;
- PyInterpreterState *head;
- PyInterpreterState *main;
- /* _next_interp_id is an auto-numbered sequence of small
- integers. It gets initialized in _PyInterpreterState_Init(),
- which is called in Py_Initialize(), and used in
- PyInterpreterState_New(). A negative interpreter ID
- indicates an error occurred. The main interpreter will
- always have an ID of 0. Overflow results in a RuntimeError.
- If that becomes a problem later then we can adjust, e.g. by
- using a Python int. */
- int64_t next_id;
- } interpreters;
-
-#define NEXITFUNCS 32
- void (*exitfuncs[NEXITFUNCS])(void);
- int nexitfuncs;
-
- struct _gc_runtime_state gc;
- struct _warnings_runtime_state warnings;
- struct _ceval_runtime_state ceval;
- struct _gilstate_runtime_state gilstate;
-
- // XXX Consolidate globals found via the check-c-globals script.
-} _PyRuntimeState;
-
-#define _PyRuntimeState_INIT {.initialized = 0, .core_initialized = 0}
-/* Note: _PyRuntimeState_INIT sets other fields to 0/NULL */
-
-PyAPI_DATA(_PyRuntimeState) _PyRuntime;
-PyAPI_FUNC(_PyInitError) _PyRuntimeState_Init(_PyRuntimeState *);
-PyAPI_FUNC(void) _PyRuntimeState_Fini(_PyRuntimeState *);
-
-/* Initialize _PyRuntimeState.
- Return NULL on success, or return an error message on failure. */
-PyAPI_FUNC(_PyInitError) _PyRuntime_Initialize(void);
-
-PyAPI_FUNC(void) _PyRuntime_Finalize(void);
-
-
-#define _Py_CURRENTLY_FINALIZING(tstate) \
- (_PyRuntime.finalizing == tstate)
-
-
-/* Other */
-
-PyAPI_FUNC(_PyInitError) _PyInterpreterState_Enable(_PyRuntimeState *);
-
-#ifdef __cplusplus
-}
-#endif
-#endif /* !Py_INTERNAL_PYSTATE_H */
diff --git a/pythonsdk/include/internal/warnings.h b/pythonsdk/include/internal/warnings.h
deleted file mode 100644
index 5a0559f204a46883c934059bc152caa24bd50d97..0000000000000000000000000000000000000000
--- a/pythonsdk/include/internal/warnings.h
+++ /dev/null
@@ -1,21 +0,0 @@
-#ifndef Py_INTERNAL_WARNINGS_H
-#define Py_INTERNAL_WARNINGS_H
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-#include "object.h"
-
-struct _warnings_runtime_state {
- /* Both 'filters' and 'onceregistry' can be set in warnings.py;
- get_warnings_attr() will reset these variables accordingly. */
- PyObject *filters; /* List */
- PyObject *once_registry; /* Dict */
- PyObject *default_action; /* String */
- long filters_version;
-};
-
-#ifdef __cplusplus
-}
-#endif
-#endif /* !Py_INTERNAL_WARNINGS_H */
diff --git a/pythonsdk/include/intrcheck.h b/pythonsdk/include/intrcheck.h
deleted file mode 100644
index 0fcb231b2a9ba8b323d5943e0a39dda210c75774..0000000000000000000000000000000000000000
--- a/pythonsdk/include/intrcheck.h
+++ /dev/null
@@ -1,33 +0,0 @@
-
-#ifndef Py_INTRCHECK_H
-#define Py_INTRCHECK_H
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-PyAPI_FUNC(int) PyOS_InterruptOccurred(void);
-PyAPI_FUNC(void) PyOS_InitInterrupts(void);
-#ifdef HAVE_FORK
-#if !defined(Py_LIMITED_API) || Py_LIMITED_API+0 >= 0x03070000
-PyAPI_FUNC(void) PyOS_BeforeFork(void);
-PyAPI_FUNC(void) PyOS_AfterFork_Parent(void);
-PyAPI_FUNC(void) PyOS_AfterFork_Child(void);
-#endif
-#endif
-/* Deprecated, please use PyOS_AfterFork_Child() instead */
-PyAPI_FUNC(void) PyOS_AfterFork(void) Py_DEPRECATED(3.7);
-
-#ifndef Py_LIMITED_API
-PyAPI_FUNC(int) _PyOS_IsMainThread(void);
-PyAPI_FUNC(void) _PySignal_AfterFork(void);
-
-#ifdef MS_WINDOWS
-/* windows.h is not included by Python.h so use void* instead of HANDLE */
-PyAPI_FUNC(void*) _PyOS_SigintEvent(void);
-#endif
-#endif /* !Py_LIMITED_API */
-
-#ifdef __cplusplus
-}
-#endif
-#endif /* !Py_INTRCHECK_H */
diff --git a/pythonsdk/include/iterobject.h b/pythonsdk/include/iterobject.h
deleted file mode 100644
index 610362ad433290142a41c85d7b74d30c5d7fb423..0000000000000000000000000000000000000000
--- a/pythonsdk/include/iterobject.h
+++ /dev/null
@@ -1,25 +0,0 @@
-#ifndef Py_ITEROBJECT_H
-#define Py_ITEROBJECT_H
-/* Iterators (the basic kind, over a sequence) */
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-PyAPI_DATA(PyTypeObject) PySeqIter_Type;
-PyAPI_DATA(PyTypeObject) PyCallIter_Type;
-PyAPI_DATA(PyTypeObject) PyCmpWrapper_Type;
-
-#define PySeqIter_Check(op) (Py_TYPE(op) == &PySeqIter_Type)
-
-PyAPI_FUNC(PyObject *) PySeqIter_New(PyObject *);
-
-
-#define PyCallIter_Check(op) (Py_TYPE(op) == &PyCallIter_Type)
-
-PyAPI_FUNC(PyObject *) PyCallIter_New(PyObject *, PyObject *);
-
-#ifdef __cplusplus
-}
-#endif
-#endif /* !Py_ITEROBJECT_H */
-
diff --git a/pythonsdk/include/listobject.h b/pythonsdk/include/listobject.h
deleted file mode 100644
index 867f179d4c3d5a21ea39f39cf0fbb5b2a1f975d1..0000000000000000000000000000000000000000
--- a/pythonsdk/include/listobject.h
+++ /dev/null
@@ -1,81 +0,0 @@
-
-/* List object interface */
-
-/*
-Another generally useful object type is a list of object pointers.
-This is a mutable type: the list items can be changed, and items can be
-added or removed. Out-of-range indices or non-list objects are ignored.
-
-*** WARNING *** PyList_SetItem does not increment the new item's reference
-count, but does decrement the reference count of the item it replaces,
-if not nil. It does *decrement* the reference count if it is *not*
-inserted in the list. Similarly, PyList_GetItem does not increment the
-returned item's reference count.
-*/
-
-#ifndef Py_LISTOBJECT_H
-#define Py_LISTOBJECT_H
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-#ifndef Py_LIMITED_API
-typedef struct {
- PyObject_VAR_HEAD
- /* Vector of pointers to list elements. list[0] is ob_item[0], etc. */
- PyObject **ob_item;
-
- /* ob_item contains space for 'allocated' elements. The number
- * currently in use is ob_size.
- * Invariants:
- * 0 <= ob_size <= allocated
- * len(list) == ob_size
- * ob_item == NULL implies ob_size == allocated == 0
- * list.sort() temporarily sets allocated to -1 to detect mutations.
- *
- * Items must normally not be NULL, except during construction when
- * the list is not yet visible outside the function that builds it.
- */
- Py_ssize_t allocated;
-} PyListObject;
-#endif
-
-PyAPI_DATA(PyTypeObject) PyList_Type;
-PyAPI_DATA(PyTypeObject) PyListIter_Type;
-PyAPI_DATA(PyTypeObject) PyListRevIter_Type;
-PyAPI_DATA(PyTypeObject) PySortWrapper_Type;
-
-#define PyList_Check(op) \
- PyType_FastSubclass(Py_TYPE(op), Py_TPFLAGS_LIST_SUBCLASS)
-#define PyList_CheckExact(op) (Py_TYPE(op) == &PyList_Type)
-
-PyAPI_FUNC(PyObject *) PyList_New(Py_ssize_t size);
-PyAPI_FUNC(Py_ssize_t) PyList_Size(PyObject *);
-PyAPI_FUNC(PyObject *) PyList_GetItem(PyObject *, Py_ssize_t);
-PyAPI_FUNC(int) PyList_SetItem(PyObject *, Py_ssize_t, PyObject *);
-PyAPI_FUNC(int) PyList_Insert(PyObject *, Py_ssize_t, PyObject *);
-PyAPI_FUNC(int) PyList_Append(PyObject *, PyObject *);
-PyAPI_FUNC(PyObject *) PyList_GetSlice(PyObject *, Py_ssize_t, Py_ssize_t);
-PyAPI_FUNC(int) PyList_SetSlice(PyObject *, Py_ssize_t, Py_ssize_t, PyObject *);
-PyAPI_FUNC(int) PyList_Sort(PyObject *);
-PyAPI_FUNC(int) PyList_Reverse(PyObject *);
-PyAPI_FUNC(PyObject *) PyList_AsTuple(PyObject *);
-#ifndef Py_LIMITED_API
-PyAPI_FUNC(PyObject *) _PyList_Extend(PyListObject *, PyObject *);
-
-PyAPI_FUNC(int) PyList_ClearFreeList(void);
-PyAPI_FUNC(void) _PyList_DebugMallocStats(FILE *out);
-#endif
-
-/* Macro, trading safety for speed */
-#ifndef Py_LIMITED_API
-#define PyList_GET_ITEM(op, i) (((PyListObject *)(op))->ob_item[i])
-#define PyList_SET_ITEM(op, i, v) (((PyListObject *)(op))->ob_item[i] = (v))
-#define PyList_GET_SIZE(op) (assert(PyList_Check(op)),Py_SIZE(op))
-#define _PyList_ITEMS(op) (((PyListObject *)(op))->ob_item)
-#endif
-
-#ifdef __cplusplus
-}
-#endif
-#endif /* !Py_LISTOBJECT_H */
diff --git a/pythonsdk/include/longintrepr.h b/pythonsdk/include/longintrepr.h
deleted file mode 100644
index cc02f2b33ddb9042ac464f7a7201120f9d612668..0000000000000000000000000000000000000000
--- a/pythonsdk/include/longintrepr.h
+++ /dev/null
@@ -1,99 +0,0 @@
-#ifndef Py_LIMITED_API
-#ifndef Py_LONGINTREPR_H
-#define Py_LONGINTREPR_H
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-
-/* This is published for the benefit of "friends" marshal.c and _decimal.c. */
-
-/* Parameters of the integer representation. There are two different
- sets of parameters: one set for 30-bit digits, stored in an unsigned 32-bit
- integer type, and one set for 15-bit digits with each digit stored in an
- unsigned short. The value of PYLONG_BITS_IN_DIGIT, defined either at
- configure time or in pyport.h, is used to decide which digit size to use.
-
- Type 'digit' should be able to hold 2*PyLong_BASE-1, and type 'twodigits'
- should be an unsigned integer type able to hold all integers up to
- PyLong_BASE*PyLong_BASE-1. x_sub assumes that 'digit' is an unsigned type,
- and that overflow is handled by taking the result modulo 2**N for some N >
- PyLong_SHIFT. The majority of the code doesn't care about the precise
- value of PyLong_SHIFT, but there are some notable exceptions:
-
- - long_pow() requires that PyLong_SHIFT be divisible by 5
-
- - PyLong_{As,From}ByteArray require that PyLong_SHIFT be at least 8
-
- - long_hash() requires that PyLong_SHIFT is *strictly* less than the number
- of bits in an unsigned long, as do the PyLong <-> long (or unsigned long)
- conversion functions
-
- - the Python int <-> size_t/Py_ssize_t conversion functions expect that
- PyLong_SHIFT is strictly less than the number of bits in a size_t
-
- - the marshal code currently expects that PyLong_SHIFT is a multiple of 15
-
- - NSMALLNEGINTS and NSMALLPOSINTS should be small enough to fit in a single
- digit; with the current values this forces PyLong_SHIFT >= 9
-
- The values 15 and 30 should fit all of the above requirements, on any
- platform.
-*/
-
-#if PYLONG_BITS_IN_DIGIT == 30
-typedef uint32_t digit;
-typedef int32_t sdigit; /* signed variant of digit */
-typedef uint64_t twodigits;
-typedef int64_t stwodigits; /* signed variant of twodigits */
-#define PyLong_SHIFT 30
-#define _PyLong_DECIMAL_SHIFT 9 /* max(e such that 10**e fits in a digit) */
-#define _PyLong_DECIMAL_BASE ((digit)1000000000) /* 10 ** DECIMAL_SHIFT */
-#elif PYLONG_BITS_IN_DIGIT == 15
-typedef unsigned short digit;
-typedef short sdigit; /* signed variant of digit */
-typedef unsigned long twodigits;
-typedef long stwodigits; /* signed variant of twodigits */
-#define PyLong_SHIFT 15
-#define _PyLong_DECIMAL_SHIFT 4 /* max(e such that 10**e fits in a digit) */
-#define _PyLong_DECIMAL_BASE ((digit)10000) /* 10 ** DECIMAL_SHIFT */
-#else
-#error "PYLONG_BITS_IN_DIGIT should be 15 or 30"
-#endif
-#define PyLong_BASE ((digit)1 << PyLong_SHIFT)
-#define PyLong_MASK ((digit)(PyLong_BASE - 1))
-
-#if PyLong_SHIFT % 5 != 0
-#error "longobject.c requires that PyLong_SHIFT be divisible by 5"
-#endif
-
-/* Long integer representation.
- The absolute value of a number is equal to
- SUM(for i=0 through abs(ob_size)-1) ob_digit[i] * 2**(SHIFT*i)
- Negative numbers are represented with ob_size < 0;
- zero is represented by ob_size == 0.
- In a normalized number, ob_digit[abs(ob_size)-1] (the most significant
- digit) is never zero. Also, in all cases, for all valid i,
- 0 <= ob_digit[i] <= MASK.
- The allocation function takes care of allocating extra memory
- so that ob_digit[0] ... ob_digit[abs(ob_size)-1] are actually available.
-
- CAUTION: Generic code manipulating subtypes of PyVarObject has to
- aware that ints abuse ob_size's sign bit.
-*/
-
-struct _longobject {
- PyObject_VAR_HEAD
- digit ob_digit[1];
-};
-
-PyAPI_FUNC(PyLongObject *) _PyLong_New(Py_ssize_t);
-
-/* Return a copy of src. */
-PyAPI_FUNC(PyObject *) _PyLong_Copy(PyLongObject *src);
-
-#ifdef __cplusplus
-}
-#endif
-#endif /* !Py_LONGINTREPR_H */
-#endif /* Py_LIMITED_API */
diff --git a/pythonsdk/include/longobject.h b/pythonsdk/include/longobject.h
deleted file mode 100644
index 2f79798dfcdb92c5387155d2fd5e0f7fcbee022c..0000000000000000000000000000000000000000
--- a/pythonsdk/include/longobject.h
+++ /dev/null
@@ -1,220 +0,0 @@
-#ifndef Py_LONGOBJECT_H
-#define Py_LONGOBJECT_H
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-
-/* Long (arbitrary precision) integer object interface */
-
-typedef struct _longobject PyLongObject; /* Revealed in longintrepr.h */
-
-PyAPI_DATA(PyTypeObject) PyLong_Type;
-
-#define PyLong_Check(op) \
- PyType_FastSubclass(Py_TYPE(op), Py_TPFLAGS_LONG_SUBCLASS)
-#define PyLong_CheckExact(op) (Py_TYPE(op) == &PyLong_Type)
-
-PyAPI_FUNC(PyObject *) PyLong_FromLong(long);
-PyAPI_FUNC(PyObject *) PyLong_FromUnsignedLong(unsigned long);
-PyAPI_FUNC(PyObject *) PyLong_FromSize_t(size_t);
-PyAPI_FUNC(PyObject *) PyLong_FromSsize_t(Py_ssize_t);
-PyAPI_FUNC(PyObject *) PyLong_FromDouble(double);
-PyAPI_FUNC(long) PyLong_AsLong(PyObject *);
-PyAPI_FUNC(long) PyLong_AsLongAndOverflow(PyObject *, int *);
-PyAPI_FUNC(Py_ssize_t) PyLong_AsSsize_t(PyObject *);
-PyAPI_FUNC(size_t) PyLong_AsSize_t(PyObject *);
-PyAPI_FUNC(unsigned long) PyLong_AsUnsignedLong(PyObject *);
-PyAPI_FUNC(unsigned long) PyLong_AsUnsignedLongMask(PyObject *);
-#ifndef Py_LIMITED_API
-PyAPI_FUNC(int) _PyLong_AsInt(PyObject *);
-#endif
-PyAPI_FUNC(PyObject *) PyLong_GetInfo(void);
-
-/* It may be useful in the future. I've added it in the PyInt -> PyLong
- cleanup to keep the extra information. [CH] */
-#define PyLong_AS_LONG(op) PyLong_AsLong(op)
-
-/* Issue #1983: pid_t can be longer than a C long on some systems */
-#if !defined(SIZEOF_PID_T) || SIZEOF_PID_T == SIZEOF_INT
-#define _Py_PARSE_PID "i"
-#define PyLong_FromPid PyLong_FromLong
-#define PyLong_AsPid PyLong_AsLong
-#elif SIZEOF_PID_T == SIZEOF_LONG
-#define _Py_PARSE_PID "l"
-#define PyLong_FromPid PyLong_FromLong
-#define PyLong_AsPid PyLong_AsLong
-#elif defined(SIZEOF_LONG_LONG) && SIZEOF_PID_T == SIZEOF_LONG_LONG
-#define _Py_PARSE_PID "L"
-#define PyLong_FromPid PyLong_FromLongLong
-#define PyLong_AsPid PyLong_AsLongLong
-#else
-#error "sizeof(pid_t) is neither sizeof(int), sizeof(long) or sizeof(long long)"
-#endif /* SIZEOF_PID_T */
-
-#if SIZEOF_VOID_P == SIZEOF_INT
-# define _Py_PARSE_INTPTR "i"
-# define _Py_PARSE_UINTPTR "I"
-#elif SIZEOF_VOID_P == SIZEOF_LONG
-# define _Py_PARSE_INTPTR "l"
-# define _Py_PARSE_UINTPTR "k"
-#elif defined(SIZEOF_LONG_LONG) && SIZEOF_VOID_P == SIZEOF_LONG_LONG
-# define _Py_PARSE_INTPTR "L"
-# define _Py_PARSE_UINTPTR "K"
-#else
-# error "void* different in size from int, long and long long"
-#endif /* SIZEOF_VOID_P */
-
-/* Used by Python/mystrtoul.c, _PyBytes_FromHex(),
- _PyBytes_DecodeEscapeRecode(), etc. */
-#ifndef Py_LIMITED_API
-PyAPI_DATA(unsigned char) _PyLong_DigitValue[256];
-#endif
-
-/* _PyLong_Frexp returns a double x and an exponent e such that the
- true value is approximately equal to x * 2**e. e is >= 0. x is
- 0.0 if and only if the input is 0 (in which case, e and x are both
- zeroes); otherwise, 0.5 <= abs(x) < 1.0. On overflow, which is
- possible if the number of bits doesn't fit into a Py_ssize_t, sets
- OverflowError and returns -1.0 for x, 0 for e. */
-#ifndef Py_LIMITED_API
-PyAPI_FUNC(double) _PyLong_Frexp(PyLongObject *a, Py_ssize_t *e);
-#endif
-
-PyAPI_FUNC(double) PyLong_AsDouble(PyObject *);
-PyAPI_FUNC(PyObject *) PyLong_FromVoidPtr(void *);
-PyAPI_FUNC(void *) PyLong_AsVoidPtr(PyObject *);
-
-PyAPI_FUNC(PyObject *) PyLong_FromLongLong(long long);
-PyAPI_FUNC(PyObject *) PyLong_FromUnsignedLongLong(unsigned long long);
-PyAPI_FUNC(long long) PyLong_AsLongLong(PyObject *);
-PyAPI_FUNC(unsigned long long) PyLong_AsUnsignedLongLong(PyObject *);
-PyAPI_FUNC(unsigned long long) PyLong_AsUnsignedLongLongMask(PyObject *);
-PyAPI_FUNC(long long) PyLong_AsLongLongAndOverflow(PyObject *, int *);
-
-PyAPI_FUNC(PyObject *) PyLong_FromString(const char *, char **, int);
-#ifndef Py_LIMITED_API
-PyAPI_FUNC(PyObject *) PyLong_FromUnicode(Py_UNICODE*, Py_ssize_t, int) Py_DEPRECATED(3.3);
-PyAPI_FUNC(PyObject *) PyLong_FromUnicodeObject(PyObject *u, int base);
-PyAPI_FUNC(PyObject *) _PyLong_FromBytes(const char *, Py_ssize_t, int);
-#endif
-
-#ifndef Py_LIMITED_API
-/* _PyLong_Sign. Return 0 if v is 0, -1 if v < 0, +1 if v > 0.
- v must not be NULL, and must be a normalized long.
- There are no error cases.
-*/
-PyAPI_FUNC(int) _PyLong_Sign(PyObject *v);
-
-
-/* _PyLong_NumBits. Return the number of bits needed to represent the
- absolute value of a long. For example, this returns 1 for 1 and -1, 2
- for 2 and -2, and 2 for 3 and -3. It returns 0 for 0.
- v must not be NULL, and must be a normalized long.
- (size_t)-1 is returned and OverflowError set if the true result doesn't
- fit in a size_t.
-*/
-PyAPI_FUNC(size_t) _PyLong_NumBits(PyObject *v);
-
-/* _PyLong_DivmodNear. Given integers a and b, compute the nearest
- integer q to the exact quotient a / b, rounding to the nearest even integer
- in the case of a tie. Return (q, r), where r = a - q*b. The remainder r
- will satisfy abs(r) <= abs(b)/2, with equality possible only if q is
- even.
-*/
-PyAPI_FUNC(PyObject *) _PyLong_DivmodNear(PyObject *, PyObject *);
-
-/* _PyLong_FromByteArray: View the n unsigned bytes as a binary integer in
- base 256, and return a Python int with the same numeric value.
- If n is 0, the integer is 0. Else:
- If little_endian is 1/true, bytes[n-1] is the MSB and bytes[0] the LSB;
- else (little_endian is 0/false) bytes[0] is the MSB and bytes[n-1] the
- LSB.
- If is_signed is 0/false, view the bytes as a non-negative integer.
- If is_signed is 1/true, view the bytes as a 2's-complement integer,
- non-negative if bit 0x80 of the MSB is clear, negative if set.
- Error returns:
- + Return NULL with the appropriate exception set if there's not
- enough memory to create the Python int.
-*/
-PyAPI_FUNC(PyObject *) _PyLong_FromByteArray(
- const unsigned char* bytes, size_t n,
- int little_endian, int is_signed);
-
-/* _PyLong_AsByteArray: Convert the least-significant 8*n bits of long
- v to a base-256 integer, stored in array bytes. Normally return 0,
- return -1 on error.
- If little_endian is 1/true, store the MSB at bytes[n-1] and the LSB at
- bytes[0]; else (little_endian is 0/false) store the MSB at bytes[0] and
- the LSB at bytes[n-1].
- If is_signed is 0/false, it's an error if v < 0; else (v >= 0) n bytes
- are filled and there's nothing special about bit 0x80 of the MSB.
- If is_signed is 1/true, bytes is filled with the 2's-complement
- representation of v's value. Bit 0x80 of the MSB is the sign bit.
- Error returns (-1):
- + is_signed is 0 and v < 0. TypeError is set in this case, and bytes
- isn't altered.
- + n isn't big enough to hold the full mathematical value of v. For
- example, if is_signed is 0 and there are more digits in the v than
- fit in n; or if is_signed is 1, v < 0, and n is just 1 bit shy of
- being large enough to hold a sign bit. OverflowError is set in this
- case, but bytes holds the least-significant n bytes of the true value.
-*/
-PyAPI_FUNC(int) _PyLong_AsByteArray(PyLongObject* v,
- unsigned char* bytes, size_t n,
- int little_endian, int is_signed);
-
-/* _PyLong_FromNbInt: Convert the given object to a PyLongObject
- using the nb_int slot, if available. Raise TypeError if either the
- nb_int slot is not available or the result of the call to nb_int
- returns something not of type int.
-*/
-PyAPI_FUNC(PyLongObject *)_PyLong_FromNbInt(PyObject *);
-
-/* _PyLong_Format: Convert the long to a string object with given base,
- appending a base prefix of 0[box] if base is 2, 8 or 16. */
-PyAPI_FUNC(PyObject *) _PyLong_Format(PyObject *obj, int base);
-
-PyAPI_FUNC(int) _PyLong_FormatWriter(
- _PyUnicodeWriter *writer,
- PyObject *obj,
- int base,
- int alternate);
-
-PyAPI_FUNC(char*) _PyLong_FormatBytesWriter(
- _PyBytesWriter *writer,
- char *str,
- PyObject *obj,
- int base,
- int alternate);
-
-/* Format the object based on the format_spec, as defined in PEP 3101
- (Advanced String Formatting). */
-PyAPI_FUNC(int) _PyLong_FormatAdvancedWriter(
- _PyUnicodeWriter *writer,
- PyObject *obj,
- PyObject *format_spec,
- Py_ssize_t start,
- Py_ssize_t end);
-#endif /* Py_LIMITED_API */
-
-/* These aren't really part of the int object, but they're handy. The
- functions are in Python/mystrtoul.c.
- */
-PyAPI_FUNC(unsigned long) PyOS_strtoul(const char *, char **, int);
-PyAPI_FUNC(long) PyOS_strtol(const char *, char **, int);
-
-#ifndef Py_LIMITED_API
-/* For use by the gcd function in mathmodule.c */
-PyAPI_FUNC(PyObject *) _PyLong_GCD(PyObject *, PyObject *);
-#endif /* !Py_LIMITED_API */
-
-#ifndef Py_LIMITED_API
-PyAPI_DATA(PyObject *) _PyLong_Zero;
-PyAPI_DATA(PyObject *) _PyLong_One;
-#endif
-
-#ifdef __cplusplus
-}
-#endif
-#endif /* !Py_LONGOBJECT_H */
diff --git a/pythonsdk/include/marshal.h b/pythonsdk/include/marshal.h
deleted file mode 100644
index de9dfbbf259402a628b9a09a9a6531843c827e06..0000000000000000000000000000000000000000
--- a/pythonsdk/include/marshal.h
+++ /dev/null
@@ -1,28 +0,0 @@
-
-/* Interface for marshal.c */
-
-#ifndef Py_MARSHAL_H
-#define Py_MARSHAL_H
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-#define Py_MARSHAL_VERSION 4
-
-PyAPI_FUNC(void) PyMarshal_WriteLongToFile(long, FILE *, int);
-PyAPI_FUNC(void) PyMarshal_WriteObjectToFile(PyObject *, FILE *, int);
-PyAPI_FUNC(PyObject *) PyMarshal_WriteObjectToString(PyObject *, int);
-
-#ifndef Py_LIMITED_API
-PyAPI_FUNC(long) PyMarshal_ReadLongFromFile(FILE *);
-PyAPI_FUNC(int) PyMarshal_ReadShortFromFile(FILE *);
-PyAPI_FUNC(PyObject *) PyMarshal_ReadObjectFromFile(FILE *);
-PyAPI_FUNC(PyObject *) PyMarshal_ReadLastObjectFromFile(FILE *);
-#endif
-PyAPI_FUNC(PyObject *) PyMarshal_ReadObjectFromString(const char *,
- Py_ssize_t);
-
-#ifdef __cplusplus
-}
-#endif
-#endif /* !Py_MARSHAL_H */
diff --git a/pythonsdk/include/memoryobject.h b/pythonsdk/include/memoryobject.h
deleted file mode 100644
index 82c5f5bda71b5617fd7150d3dac53fdd4eae89bc..0000000000000000000000000000000000000000
--- a/pythonsdk/include/memoryobject.h
+++ /dev/null
@@ -1,72 +0,0 @@
-/* Memory view object. In Python this is available as "memoryview". */
-
-#ifndef Py_MEMORYOBJECT_H
-#define Py_MEMORYOBJECT_H
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-#ifndef Py_LIMITED_API
-PyAPI_DATA(PyTypeObject) _PyManagedBuffer_Type;
-#endif
-PyAPI_DATA(PyTypeObject) PyMemoryView_Type;
-
-#define PyMemoryView_Check(op) (Py_TYPE(op) == &PyMemoryView_Type)
-
-#ifndef Py_LIMITED_API
-/* Get a pointer to the memoryview's private copy of the exporter's buffer. */
-#define PyMemoryView_GET_BUFFER(op) (&((PyMemoryViewObject *)(op))->view)
-/* Get a pointer to the exporting object (this may be NULL!). */
-#define PyMemoryView_GET_BASE(op) (((PyMemoryViewObject *)(op))->view.obj)
-#endif
-
-PyAPI_FUNC(PyObject *) PyMemoryView_FromObject(PyObject *base);
-#if !defined(Py_LIMITED_API) || Py_LIMITED_API+0 >= 0x03030000
-PyAPI_FUNC(PyObject *) PyMemoryView_FromMemory(char *mem, Py_ssize_t size,
- int flags);
-#endif
-#ifndef Py_LIMITED_API
-PyAPI_FUNC(PyObject *) PyMemoryView_FromBuffer(Py_buffer *info);
-#endif
-PyAPI_FUNC(PyObject *) PyMemoryView_GetContiguous(PyObject *base,
- int buffertype,
- char order);
-
-
-/* The structs are declared here so that macros can work, but they shouldn't
- be considered public. Don't access their fields directly, use the macros
- and functions instead! */
-#ifndef Py_LIMITED_API
-#define _Py_MANAGED_BUFFER_RELEASED 0x001 /* access to exporter blocked */
-#define _Py_MANAGED_BUFFER_FREE_FORMAT 0x002 /* free format */
-typedef struct {
- PyObject_HEAD
- int flags; /* state flags */
- Py_ssize_t exports; /* number of direct memoryview exports */
- Py_buffer master; /* snapshot buffer obtained from the original exporter */
-} _PyManagedBufferObject;
-
-
-/* memoryview state flags */
-#define _Py_MEMORYVIEW_RELEASED 0x001 /* access to master buffer blocked */
-#define _Py_MEMORYVIEW_C 0x002 /* C-contiguous layout */
-#define _Py_MEMORYVIEW_FORTRAN 0x004 /* Fortran contiguous layout */
-#define _Py_MEMORYVIEW_SCALAR 0x008 /* scalar: ndim = 0 */
-#define _Py_MEMORYVIEW_PIL 0x010 /* PIL-style layout */
-
-typedef struct {
- PyObject_VAR_HEAD
- _PyManagedBufferObject *mbuf; /* managed buffer */
- Py_hash_t hash; /* hash value for read-only views */
- int flags; /* state flags */
- Py_ssize_t exports; /* number of buffer re-exports */
- Py_buffer view; /* private copy of the exporter's view */
- PyObject *weakreflist;
- Py_ssize_t ob_array[1]; /* shape, strides, suboffsets */
-} PyMemoryViewObject;
-#endif
-
-#ifdef __cplusplus
-}
-#endif
-#endif /* !Py_MEMORYOBJECT_H */
diff --git a/pythonsdk/include/metagrammar.h b/pythonsdk/include/metagrammar.h
deleted file mode 100644
index 1fb471a0f97f2afbac28db4755114e9e54bfffbd..0000000000000000000000000000000000000000
--- a/pythonsdk/include/metagrammar.h
+++ /dev/null
@@ -1,18 +0,0 @@
-#ifndef Py_METAGRAMMAR_H
-#define Py_METAGRAMMAR_H
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-
-#define MSTART 256
-#define RULE 257
-#define RHS 258
-#define ALT 259
-#define ITEM 260
-#define ATOM 261
-
-#ifdef __cplusplus
-}
-#endif
-#endif /* !Py_METAGRAMMAR_H */
diff --git a/pythonsdk/include/methodobject.h b/pythonsdk/include/methodobject.h
deleted file mode 100644
index 2f600679b4e3c3e76a73d36d08d8812706216327..0000000000000000000000000000000000000000
--- a/pythonsdk/include/methodobject.h
+++ /dev/null
@@ -1,135 +0,0 @@
-
-/* Method object interface */
-
-#ifndef Py_METHODOBJECT_H
-#define Py_METHODOBJECT_H
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-/* This is about the type 'builtin_function_or_method',
- not Python methods in user-defined classes. See classobject.h
- for the latter. */
-
-PyAPI_DATA(PyTypeObject) PyCFunction_Type;
-
-#define PyCFunction_Check(op) (Py_TYPE(op) == &PyCFunction_Type)
-
-typedef PyObject *(*PyCFunction)(PyObject *, PyObject *);
-typedef PyObject *(*_PyCFunctionFast) (PyObject *, PyObject *const *, Py_ssize_t);
-typedef PyObject *(*PyCFunctionWithKeywords)(PyObject *, PyObject *,
- PyObject *);
-typedef PyObject *(*_PyCFunctionFastWithKeywords) (PyObject *,
- PyObject *const *, Py_ssize_t,
- PyObject *);
-typedef PyObject *(*PyNoArgsFunction)(PyObject *);
-
-PyAPI_FUNC(PyCFunction) PyCFunction_GetFunction(PyObject *);
-PyAPI_FUNC(PyObject *) PyCFunction_GetSelf(PyObject *);
-PyAPI_FUNC(int) PyCFunction_GetFlags(PyObject *);
-
-/* Macros for direct access to these values. Type checks are *not*
- done, so use with care. */
-#ifndef Py_LIMITED_API
-#define PyCFunction_GET_FUNCTION(func) \
- (((PyCFunctionObject *)func) -> m_ml -> ml_meth)
-#define PyCFunction_GET_SELF(func) \
- (((PyCFunctionObject *)func) -> m_ml -> ml_flags & METH_STATIC ? \
- NULL : ((PyCFunctionObject *)func) -> m_self)
-#define PyCFunction_GET_FLAGS(func) \
- (((PyCFunctionObject *)func) -> m_ml -> ml_flags)
-#endif
-PyAPI_FUNC(PyObject *) PyCFunction_Call(PyObject *, PyObject *, PyObject *);
-
-#ifndef Py_LIMITED_API
-PyAPI_FUNC(PyObject *) _PyCFunction_FastCallDict(PyObject *func,
- PyObject *const *args,
- Py_ssize_t nargs,
- PyObject *kwargs);
-
-PyAPI_FUNC(PyObject *) _PyCFunction_FastCallKeywords(PyObject *func,
- PyObject *const *stack,
- Py_ssize_t nargs,
- PyObject *kwnames);
-#endif
-
-struct PyMethodDef {
- const char *ml_name; /* The name of the built-in function/method */
- PyCFunction ml_meth; /* The C function that implements it */
- int ml_flags; /* Combination of METH_xxx flags, which mostly
- describe the args expected by the C func */
- const char *ml_doc; /* The __doc__ attribute, or NULL */
-};
-typedef struct PyMethodDef PyMethodDef;
-
-#define PyCFunction_New(ML, SELF) PyCFunction_NewEx((ML), (SELF), NULL)
-PyAPI_FUNC(PyObject *) PyCFunction_NewEx(PyMethodDef *, PyObject *,
- PyObject *);
-
-/* Flag passed to newmethodobject */
-/* #define METH_OLDARGS 0x0000 -- unsupported now */
-#define METH_VARARGS 0x0001
-#define METH_KEYWORDS 0x0002
-/* METH_NOARGS and METH_O must not be combined with the flags above. */
-#define METH_NOARGS 0x0004
-#define METH_O 0x0008
-
-/* METH_CLASS and METH_STATIC are a little different; these control
- the construction of methods for a class. These cannot be used for
- functions in modules. */
-#define METH_CLASS 0x0010
-#define METH_STATIC 0x0020
-
-/* METH_COEXIST allows a method to be entered even though a slot has
- already filled the entry. When defined, the flag allows a separate
- method, "__contains__" for example, to coexist with a defined
- slot like sq_contains. */
-
-#define METH_COEXIST 0x0040
-
-#ifndef Py_LIMITED_API
-#define METH_FASTCALL 0x0080
-#endif
-
-/* This bit is preserved for Stackless Python */
-#ifdef STACKLESS
-#define METH_STACKLESS 0x0100
-#else
-#define METH_STACKLESS 0x0000
-#endif
-
-#ifndef Py_LIMITED_API
-typedef struct {
- PyObject_HEAD
- PyMethodDef *m_ml; /* Description of the C function to call */
- PyObject *m_self; /* Passed as 'self' arg to the C func, can be NULL */
- PyObject *m_module; /* The __module__ attribute, can be anything */
- PyObject *m_weakreflist; /* List of weak references */
-} PyCFunctionObject;
-
-PyAPI_FUNC(PyObject *) _PyMethodDef_RawFastCallDict(
- PyMethodDef *method,
- PyObject *self,
- PyObject *const *args,
- Py_ssize_t nargs,
- PyObject *kwargs);
-
-PyAPI_FUNC(PyObject *) _PyMethodDef_RawFastCallKeywords(
- PyMethodDef *method,
- PyObject *self,
- PyObject *const *args,
- Py_ssize_t nargs,
- PyObject *kwnames);
-#endif
-
-PyAPI_FUNC(int) PyCFunction_ClearFreeList(void);
-
-#ifndef Py_LIMITED_API
-PyAPI_FUNC(void) _PyCFunction_DebugMallocStats(FILE *out);
-PyAPI_FUNC(void) _PyMethod_DebugMallocStats(FILE *out);
-#endif
-
-#ifdef __cplusplus
-}
-#endif
-#endif /* !Py_METHODOBJECT_H */
diff --git a/pythonsdk/include/modsupport.h b/pythonsdk/include/modsupport.h
deleted file mode 100644
index 1d30cb460f425b9ee288e70ca7cc98c6e79239ed..0000000000000000000000000000000000000000
--- a/pythonsdk/include/modsupport.h
+++ /dev/null
@@ -1,229 +0,0 @@
-
-#ifndef Py_MODSUPPORT_H
-#define Py_MODSUPPORT_H
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-/* Module support interface */
-
-#include <stdarg.h>
-
-/* If PY_SSIZE_T_CLEAN is defined, each functions treats #-specifier
- to mean Py_ssize_t */
-#ifdef PY_SSIZE_T_CLEAN
-#define PyArg_Parse _PyArg_Parse_SizeT
-#define PyArg_ParseTuple _PyArg_ParseTuple_SizeT
-#define PyArg_ParseTupleAndKeywords _PyArg_ParseTupleAndKeywords_SizeT
-#define PyArg_VaParse _PyArg_VaParse_SizeT
-#define PyArg_VaParseTupleAndKeywords _PyArg_VaParseTupleAndKeywords_SizeT
-#define Py_BuildValue _Py_BuildValue_SizeT
-#define Py_VaBuildValue _Py_VaBuildValue_SizeT
-#ifndef Py_LIMITED_API
-#define _Py_VaBuildStack _Py_VaBuildStack_SizeT
-#endif
-#else
-#ifndef Py_LIMITED_API
-PyAPI_FUNC(PyObject *) _Py_VaBuildValue_SizeT(const char *, va_list);
-PyAPI_FUNC(PyObject **) _Py_VaBuildStack_SizeT(
- PyObject **small_stack,
- Py_ssize_t small_stack_len,
- const char *format,
- va_list va,
- Py_ssize_t *p_nargs);
-#endif /* !Py_LIMITED_API */
-#endif
-
-/* Due to a glitch in 3.2, the _SizeT versions weren't exported from the DLL. */
-#if !defined(PY_SSIZE_T_CLEAN) || !defined(Py_LIMITED_API) || Py_LIMITED_API+0 >= 0x03030000
-PyAPI_FUNC(int) PyArg_Parse(PyObject *, const char *, ...);
-PyAPI_FUNC(int) PyArg_ParseTuple(PyObject *, const char *, ...);
-PyAPI_FUNC(int) PyArg_ParseTupleAndKeywords(PyObject *, PyObject *,
- const char *, char **, ...);
-PyAPI_FUNC(int) PyArg_VaParse(PyObject *, const char *, va_list);
-PyAPI_FUNC(int) PyArg_VaParseTupleAndKeywords(PyObject *, PyObject *,
- const char *, char **, va_list);
-#endif
-PyAPI_FUNC(int) PyArg_ValidateKeywordArguments(PyObject *);
-PyAPI_FUNC(int) PyArg_UnpackTuple(PyObject *, const char *, Py_ssize_t, Py_ssize_t, ...);
-PyAPI_FUNC(PyObject *) Py_BuildValue(const char *, ...);
-PyAPI_FUNC(PyObject *) _Py_BuildValue_SizeT(const char *, ...);
-
-
-#ifndef Py_LIMITED_API
-PyAPI_FUNC(int) _PyArg_UnpackStack(
- PyObject *const *args,
- Py_ssize_t nargs,
- const char *name,
- Py_ssize_t min,
- Py_ssize_t max,
- ...);
-
-PyAPI_FUNC(int) _PyArg_NoKeywords(const char *funcname, PyObject *kwargs);
-PyAPI_FUNC(int) _PyArg_NoPositional(const char *funcname, PyObject *args);
-#define _PyArg_NoKeywords(funcname, kwargs) \
- ((kwargs) == NULL || _PyArg_NoKeywords((funcname), (kwargs)))
-#define _PyArg_NoPositional(funcname, args) \
- ((args) == NULL || _PyArg_NoPositional((funcname), (args)))
-
-#endif
-
-PyAPI_FUNC(PyObject *) Py_VaBuildValue(const char *, va_list);
-#ifndef Py_LIMITED_API
-PyAPI_FUNC(PyObject **) _Py_VaBuildStack(
- PyObject **small_stack,
- Py_ssize_t small_stack_len,
- const char *format,
- va_list va,
- Py_ssize_t *p_nargs);
-#endif
-
-#ifndef Py_LIMITED_API
-typedef struct _PyArg_Parser {
- const char *format;
- const char * const *keywords;
- const char *fname;
- const char *custom_msg;
- int pos; /* number of positional-only arguments */
- int min; /* minimal number of arguments */
- int max; /* maximal number of positional arguments */
- PyObject *kwtuple; /* tuple of keyword parameter names */
- struct _PyArg_Parser *next;
-} _PyArg_Parser;
-#ifdef PY_SSIZE_T_CLEAN
-#define _PyArg_ParseTupleAndKeywordsFast _PyArg_ParseTupleAndKeywordsFast_SizeT
-#define _PyArg_ParseStack _PyArg_ParseStack_SizeT
-#define _PyArg_ParseStackAndKeywords _PyArg_ParseStackAndKeywords_SizeT
-#define _PyArg_VaParseTupleAndKeywordsFast _PyArg_VaParseTupleAndKeywordsFast_SizeT
-#endif
-PyAPI_FUNC(int) _PyArg_ParseTupleAndKeywordsFast(PyObject *, PyObject *,
- struct _PyArg_Parser *, ...);
-PyAPI_FUNC(int) _PyArg_ParseStack(
- PyObject *const *args,
- Py_ssize_t nargs,
- const char *format,
- ...);
-PyAPI_FUNC(int) _PyArg_ParseStackAndKeywords(
- PyObject *const *args,
- Py_ssize_t nargs,
- PyObject *kwnames,
- struct _PyArg_Parser *,
- ...);
-PyAPI_FUNC(int) _PyArg_VaParseTupleAndKeywordsFast(PyObject *, PyObject *,
- struct _PyArg_Parser *, va_list);
-void _PyArg_Fini(void);
-#endif /* Py_LIMITED_API */
-
-PyAPI_FUNC(int) PyModule_AddObject(PyObject *, const char *, PyObject *);
-PyAPI_FUNC(int) PyModule_AddIntConstant(PyObject *, const char *, long);
-PyAPI_FUNC(int) PyModule_AddStringConstant(PyObject *, const char *, const char *);
-#define PyModule_AddIntMacro(m, c) PyModule_AddIntConstant(m, #c, c)
-#define PyModule_AddStringMacro(m, c) PyModule_AddStringConstant(m, #c, c)
-
-#if !defined(Py_LIMITED_API) || Py_LIMITED_API+0 >= 0x03050000
-/* New in 3.5 */
-PyAPI_FUNC(int) PyModule_SetDocString(PyObject *, const char *);
-PyAPI_FUNC(int) PyModule_AddFunctions(PyObject *, PyMethodDef *);
-PyAPI_FUNC(int) PyModule_ExecDef(PyObject *module, PyModuleDef *def);
-#endif
-
-#define Py_CLEANUP_SUPPORTED 0x20000
-
-#define PYTHON_API_VERSION 1013
-#define PYTHON_API_STRING "1013"
-/* The API version is maintained (independently from the Python version)
- so we can detect mismatches between the interpreter and dynamically
- loaded modules. These are diagnosed by an error message but
- the module is still loaded (because the mismatch can only be tested
- after loading the module). The error message is intended to
- explain the core dump a few seconds later.
-
- The symbol PYTHON_API_STRING defines the same value as a string
- literal. *** PLEASE MAKE SURE THE DEFINITIONS MATCH. ***
-
- Please add a line or two to the top of this log for each API
- version change:
-
- 22-Feb-2006 MvL 1013 PEP 353 - long indices for sequence lengths
-
- 19-Aug-2002 GvR 1012 Changes to string object struct for
- interning changes, saving 3 bytes.
-
- 17-Jul-2001 GvR 1011 Descr-branch, just to be on the safe side
-
- 25-Jan-2001 FLD 1010 Parameters added to PyCode_New() and
- PyFrame_New(); Python 2.1a2
-
- 14-Mar-2000 GvR 1009 Unicode API added
-
- 3-Jan-1999 GvR 1007 Decided to change back! (Don't reuse 1008!)
-
- 3-Dec-1998 GvR 1008 Python 1.5.2b1
-
- 18-Jan-1997 GvR 1007 string interning and other speedups
-
- 11-Oct-1996 GvR renamed Py_Ellipses to Py_Ellipsis :-(
-
- 30-Jul-1996 GvR Slice and ellipses syntax added
-
- 23-Jul-1996 GvR For 1.4 -- better safe than sorry this time :-)
-
- 7-Nov-1995 GvR Keyword arguments (should've been done at 1.3 :-( )
-
- 10-Jan-1995 GvR Renamed globals to new naming scheme
-
- 9-Jan-1995 GvR Initial version (incompatible with older API)
-*/
-
-/* The PYTHON_ABI_VERSION is introduced in PEP 384. For the lifetime of
- Python 3, it will stay at the value of 3; changes to the limited API
- must be performed in a strictly backwards-compatible manner. */
-#define PYTHON_ABI_VERSION 3
-#define PYTHON_ABI_STRING "3"
-
-#ifdef Py_TRACE_REFS
- /* When we are tracing reference counts, rename module creation functions so
- modules compiled with incompatible settings will generate a
- link-time error. */
- #define PyModule_Create2 PyModule_Create2TraceRefs
- #define PyModule_FromDefAndSpec2 PyModule_FromDefAndSpec2TraceRefs
-#endif
-
-PyAPI_FUNC(PyObject *) PyModule_Create2(struct PyModuleDef*,
- int apiver);
-#ifndef Py_LIMITED_API
-PyAPI_FUNC(PyObject *) _PyModule_CreateInitialized(struct PyModuleDef*,
- int apiver);
-#endif
-
-#ifdef Py_LIMITED_API
-#define PyModule_Create(module) \
- PyModule_Create2(module, PYTHON_ABI_VERSION)
-#else
-#define PyModule_Create(module) \
- PyModule_Create2(module, PYTHON_API_VERSION)
-#endif
-
-#if !defined(Py_LIMITED_API) || Py_LIMITED_API+0 >= 0x03050000
-/* New in 3.5 */
-PyAPI_FUNC(PyObject *) PyModule_FromDefAndSpec2(PyModuleDef *def,
- PyObject *spec,
- int module_api_version);
-
-#ifdef Py_LIMITED_API
-#define PyModule_FromDefAndSpec(module, spec) \
- PyModule_FromDefAndSpec2(module, spec, PYTHON_ABI_VERSION)
-#else
-#define PyModule_FromDefAndSpec(module, spec) \
- PyModule_FromDefAndSpec2(module, spec, PYTHON_API_VERSION)
-#endif /* Py_LIMITED_API */
-#endif /* New in 3.5 */
-
-#ifndef Py_LIMITED_API
-PyAPI_DATA(const char *) _Py_PackageContext;
-#endif
-
-#ifdef __cplusplus
-}
-#endif
-#endif /* !Py_MODSUPPORT_H */
diff --git a/pythonsdk/include/moduleobject.h b/pythonsdk/include/moduleobject.h
deleted file mode 100644
index c134437d633f72c64b41d35c8ad643bdd0252ab5..0000000000000000000000000000000000000000
--- a/pythonsdk/include/moduleobject.h
+++ /dev/null
@@ -1,89 +0,0 @@
-
-/* Module object interface */
-
-#ifndef Py_MODULEOBJECT_H
-#define Py_MODULEOBJECT_H
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-PyAPI_DATA(PyTypeObject) PyModule_Type;
-
-#define PyModule_Check(op) PyObject_TypeCheck(op, &PyModule_Type)
-#define PyModule_CheckExact(op) (Py_TYPE(op) == &PyModule_Type)
-
-#if !defined(Py_LIMITED_API) || Py_LIMITED_API+0 >= 0x03030000
-PyAPI_FUNC(PyObject *) PyModule_NewObject(
- PyObject *name
- );
-#endif
-PyAPI_FUNC(PyObject *) PyModule_New(
- const char *name /* UTF-8 encoded string */
- );
-PyAPI_FUNC(PyObject *) PyModule_GetDict(PyObject *);
-#if !defined(Py_LIMITED_API) || Py_LIMITED_API+0 >= 0x03030000
-PyAPI_FUNC(PyObject *) PyModule_GetNameObject(PyObject *);
-#endif
-PyAPI_FUNC(const char *) PyModule_GetName(PyObject *);
-PyAPI_FUNC(const char *) PyModule_GetFilename(PyObject *) Py_DEPRECATED(3.2);
-PyAPI_FUNC(PyObject *) PyModule_GetFilenameObject(PyObject *);
-#ifndef Py_LIMITED_API
-PyAPI_FUNC(void) _PyModule_Clear(PyObject *);
-PyAPI_FUNC(void) _PyModule_ClearDict(PyObject *);
-#endif
-PyAPI_FUNC(struct PyModuleDef*) PyModule_GetDef(PyObject*);
-PyAPI_FUNC(void*) PyModule_GetState(PyObject*);
-
-#if !defined(Py_LIMITED_API) || Py_LIMITED_API+0 >= 0x03050000
-/* New in 3.5 */
-PyAPI_FUNC(PyObject *) PyModuleDef_Init(struct PyModuleDef*);
-PyAPI_DATA(PyTypeObject) PyModuleDef_Type;
-#endif
-
-typedef struct PyModuleDef_Base {
- PyObject_HEAD
- PyObject* (*m_init)(void);
- Py_ssize_t m_index;
- PyObject* m_copy;
-} PyModuleDef_Base;
-
-#define PyModuleDef_HEAD_INIT { \
- PyObject_HEAD_INIT(NULL) \
- NULL, /* m_init */ \
- 0, /* m_index */ \
- NULL, /* m_copy */ \
- }
-
-struct PyModuleDef_Slot;
-#if !defined(Py_LIMITED_API) || Py_LIMITED_API+0 >= 0x03050000
-/* New in 3.5 */
-typedef struct PyModuleDef_Slot{
- int slot;
- void *value;
-} PyModuleDef_Slot;
-
-#define Py_mod_create 1
-#define Py_mod_exec 2
-
-#ifndef Py_LIMITED_API
-#define _Py_mod_LAST_SLOT 2
-#endif
-
-#endif /* New in 3.5 */
-
-typedef struct PyModuleDef{
- PyModuleDef_Base m_base;
- const char* m_name;
- const char* m_doc;
- Py_ssize_t m_size;
- PyMethodDef *m_methods;
- struct PyModuleDef_Slot* m_slots;
- traverseproc m_traverse;
- inquiry m_clear;
- freefunc m_free;
-} PyModuleDef;
-
-#ifdef __cplusplus
-}
-#endif
-#endif /* !Py_MODULEOBJECT_H */
diff --git a/pythonsdk/include/namespaceobject.h b/pythonsdk/include/namespaceobject.h
deleted file mode 100644
index 35146e5c9083c7c9bf08b266dfdceff7cc41494e..0000000000000000000000000000000000000000
--- a/pythonsdk/include/namespaceobject.h
+++ /dev/null
@@ -1,19 +0,0 @@
-
-/* simple namespace object interface */
-
-#ifndef NAMESPACEOBJECT_H
-#define NAMESPACEOBJECT_H
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-#ifndef Py_LIMITED_API
-PyAPI_DATA(PyTypeObject) _PyNamespace_Type;
-
-PyAPI_FUNC(PyObject *) _PyNamespace_New(PyObject *kwds);
-#endif /* !Py_LIMITED_API */
-
-#ifdef __cplusplus
-}
-#endif
-#endif /* !NAMESPACEOBJECT_H */
diff --git a/pythonsdk/include/node.h b/pythonsdk/include/node.h
deleted file mode 100644
index cd6f1639df293e82063b00d92ab0b5485e00feef..0000000000000000000000000000000000000000
--- a/pythonsdk/include/node.h
+++ /dev/null
@@ -1,44 +0,0 @@
-
-/* Parse tree node interface */
-
-#ifndef Py_NODE_H
-#define Py_NODE_H
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-typedef struct _node {
- short n_type;
- char *n_str;
- int n_lineno;
- int n_col_offset;
- int n_nchildren;
- struct _node *n_child;
-} node;
-
-PyAPI_FUNC(node *) PyNode_New(int type);
-PyAPI_FUNC(int) PyNode_AddChild(node *n, int type,
- char *str, int lineno, int col_offset);
-PyAPI_FUNC(void) PyNode_Free(node *n);
-#ifndef Py_LIMITED_API
-PyAPI_FUNC(Py_ssize_t) _PyNode_SizeOf(node *n);
-#endif
-
-/* Node access functions */
-#define NCH(n) ((n)->n_nchildren)
-
-#define CHILD(n, i) (&(n)->n_child[i])
-#define RCHILD(n, i) (CHILD(n, NCH(n) + i))
-#define TYPE(n) ((n)->n_type)
-#define STR(n) ((n)->n_str)
-#define LINENO(n) ((n)->n_lineno)
-
-/* Assert that the type of a node is what we expect */
-#define REQ(n, type) assert(TYPE(n) == (type))
-
-PyAPI_FUNC(void) PyNode_ListTree(node *);
-
-#ifdef __cplusplus
-}
-#endif
-#endif /* !Py_NODE_H */
diff --git a/pythonsdk/include/object.h b/pythonsdk/include/object.h
deleted file mode 100644
index b3107abeaa3cb5379e27ebe26fcc6ff1661626c9..0000000000000000000000000000000000000000
--- a/pythonsdk/include/object.h
+++ /dev/null
@@ -1,1105 +0,0 @@
-#ifndef Py_OBJECT_H
-#define Py_OBJECT_H
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-
-/* Object and type object interface */
-
-/*
-Objects are structures allocated on the heap. Special rules apply to
-the use of objects to ensure they are properly garbage-collected.
-Objects are never allocated statically or on the stack; they must be
-accessed through special macros and functions only. (Type objects are
-exceptions to the first rule; the standard types are represented by
-statically initialized type objects, although work on type/class unification
-for Python 2.2 made it possible to have heap-allocated type objects too).
-
-An object has a 'reference count' that is increased or decreased when a
-pointer to the object is copied or deleted; when the reference count
-reaches zero there are no references to the object left and it can be
-removed from the heap.
-
-An object has a 'type' that determines what it represents and what kind
-of data it contains. An object's type is fixed when it is created.
-Types themselves are represented as objects; an object contains a
-pointer to the corresponding type object. The type itself has a type
-pointer pointing to the object representing the type 'type', which
-contains a pointer to itself!.
-
-Objects do not float around in memory; once allocated an object keeps
-the same size and address. Objects that must hold variable-size data
-can contain pointers to variable-size parts of the object. Not all
-objects of the same type have the same size; but the size cannot change
-after allocation. (These restrictions are made so a reference to an
-object can be simply a pointer -- moving an object would require
-updating all the pointers, and changing an object's size would require
-moving it if there was another object right next to it.)
-
-Objects are always accessed through pointers of the type 'PyObject *'.
-The type 'PyObject' is a structure that only contains the reference count
-and the type pointer. The actual memory allocated for an object
-contains other data that can only be accessed after casting the pointer
-to a pointer to a longer structure type. This longer type must start
-with the reference count and type fields; the macro PyObject_HEAD should be
-used for this (to accommodate for future changes). The implementation
-of a particular object type can cast the object pointer to the proper
-type and back.
-
-A standard interface exists for objects that contain an array of items
-whose size is determined when the object is allocated.
-*/
-
-/* Py_DEBUG implies Py_TRACE_REFS. */
-#if defined(Py_DEBUG) && !defined(Py_TRACE_REFS)
-#define Py_TRACE_REFS
-#endif
-
-/* Py_TRACE_REFS implies Py_REF_DEBUG. */
-#if defined(Py_TRACE_REFS) && !defined(Py_REF_DEBUG)
-#define Py_REF_DEBUG
-#endif
-
-#if defined(Py_LIMITED_API) && defined(Py_REF_DEBUG)
-#error Py_LIMITED_API is incompatible with Py_DEBUG, Py_TRACE_REFS, and Py_REF_DEBUG
-#endif
-
-
-#ifdef Py_TRACE_REFS
-/* Define pointers to support a doubly-linked list of all live heap objects. */
-#define _PyObject_HEAD_EXTRA \
- struct _object *_ob_next; \
- struct _object *_ob_prev;
-
-#define _PyObject_EXTRA_INIT 0, 0,
-
-#else
-#define _PyObject_HEAD_EXTRA
-#define _PyObject_EXTRA_INIT
-#endif
-
-/* PyObject_HEAD defines the initial segment of every PyObject. */
-#define PyObject_HEAD PyObject ob_base;
-
-#define PyObject_HEAD_INIT(type) \
- { _PyObject_EXTRA_INIT \
- 1, type },
-
-#define PyVarObject_HEAD_INIT(type, size) \
- { PyObject_HEAD_INIT(type) size },
-
-/* PyObject_VAR_HEAD defines the initial segment of all variable-size
- * container objects. These end with a declaration of an array with 1
- * element, but enough space is malloc'ed so that the array actually
- * has room for ob_size elements. Note that ob_size is an element count,
- * not necessarily a byte count.
- */
-#define PyObject_VAR_HEAD PyVarObject ob_base;
-#define Py_INVALID_SIZE (Py_ssize_t)-1
-
-/* Nothing is actually declared to be a PyObject, but every pointer to
- * a Python object can be cast to a PyObject*. This is inheritance built
- * by hand. Similarly every pointer to a variable-size Python object can,
- * in addition, be cast to PyVarObject*.
- */
-typedef struct _object {
- _PyObject_HEAD_EXTRA
- Py_ssize_t ob_refcnt;
- struct _typeobject *ob_type;
-} PyObject;
-
-typedef struct {
- PyObject ob_base;
- Py_ssize_t ob_size; /* Number of items in variable part */
-} PyVarObject;
-
-#define Py_REFCNT(ob) (((PyObject*)(ob))->ob_refcnt)
-#define Py_TYPE(ob) (((PyObject*)(ob))->ob_type)
-#define Py_SIZE(ob) (((PyVarObject*)(ob))->ob_size)
-
-#ifndef Py_LIMITED_API
-/********************* String Literals ****************************************/
-/* This structure helps managing static strings. The basic usage goes like this:
- Instead of doing
-
- r = PyObject_CallMethod(o, "foo", "args", ...);
-
- do
-
- _Py_IDENTIFIER(foo);
- ...
- r = _PyObject_CallMethodId(o, &PyId_foo, "args", ...);
-
- PyId_foo is a static variable, either on block level or file level. On first
- usage, the string "foo" is interned, and the structures are linked. On interpreter
- shutdown, all strings are released (through _PyUnicode_ClearStaticStrings).
-
- Alternatively, _Py_static_string allows choosing the variable name.
- _PyUnicode_FromId returns a borrowed reference to the interned string.
- _PyObject_{Get,Set,Has}AttrId are __getattr__ versions using _Py_Identifier*.
-*/
-typedef struct _Py_Identifier {
- struct _Py_Identifier *next;
- const char* string;
- PyObject *object;
-} _Py_Identifier;
-
-#define _Py_static_string_init(value) { .next = NULL, .string = value, .object = NULL }
-#define _Py_static_string(varname, value) static _Py_Identifier varname = _Py_static_string_init(value)
-#define _Py_IDENTIFIER(varname) _Py_static_string(PyId_##varname, #varname)
-
-#endif /* !Py_LIMITED_API */
-
-/*
-Type objects contain a string containing the type name (to help somewhat
-in debugging), the allocation parameters (see PyObject_New() and
-PyObject_NewVar()),
-and methods for accessing objects of the type. Methods are optional, a
-nil pointer meaning that particular kind of access is not available for
-this type. The Py_DECREF() macro uses the tp_dealloc method without
-checking for a nil pointer; it should always be implemented except if
-the implementation can guarantee that the reference count will never
-reach zero (e.g., for statically allocated type objects).
-
-NB: the methods for certain type groups are now contained in separate
-method blocks.
-*/
-
-typedef PyObject * (*unaryfunc)(PyObject *);
-typedef PyObject * (*binaryfunc)(PyObject *, PyObject *);
-typedef PyObject * (*ternaryfunc)(PyObject *, PyObject *, PyObject *);
-typedef int (*inquiry)(PyObject *);
-typedef Py_ssize_t (*lenfunc)(PyObject *);
-typedef PyObject *(*ssizeargfunc)(PyObject *, Py_ssize_t);
-typedef PyObject *(*ssizessizeargfunc)(PyObject *, Py_ssize_t, Py_ssize_t);
-typedef int(*ssizeobjargproc)(PyObject *, Py_ssize_t, PyObject *);
-typedef int(*ssizessizeobjargproc)(PyObject *, Py_ssize_t, Py_ssize_t, PyObject *);
-typedef int(*objobjargproc)(PyObject *, PyObject *, PyObject *);
-
-#ifndef Py_LIMITED_API
-/* buffer interface */
-typedef struct bufferinfo {
- void *buf;
- PyObject *obj; /* owned reference */
- Py_ssize_t len;
- Py_ssize_t itemsize; /* This is Py_ssize_t so it can be
- pointed to by strides in simple case.*/
- int readonly;
- int ndim;
- char *format;
- Py_ssize_t *shape;
- Py_ssize_t *strides;
- Py_ssize_t *suboffsets;
- void *internal;
-} Py_buffer;
-
-typedef int (*getbufferproc)(PyObject *, Py_buffer *, int);
-typedef void (*releasebufferproc)(PyObject *, Py_buffer *);
-
-/* Maximum number of dimensions */
-#define PyBUF_MAX_NDIM 64
-
-/* Flags for getting buffers */
-#define PyBUF_SIMPLE 0
-#define PyBUF_WRITABLE 0x0001
-/* we used to include an E, backwards compatible alias */
-#define PyBUF_WRITEABLE PyBUF_WRITABLE
-#define PyBUF_FORMAT 0x0004
-#define PyBUF_ND 0x0008
-#define PyBUF_STRIDES (0x0010 | PyBUF_ND)
-#define PyBUF_C_CONTIGUOUS (0x0020 | PyBUF_STRIDES)
-#define PyBUF_F_CONTIGUOUS (0x0040 | PyBUF_STRIDES)
-#define PyBUF_ANY_CONTIGUOUS (0x0080 | PyBUF_STRIDES)
-#define PyBUF_INDIRECT (0x0100 | PyBUF_STRIDES)
-
-#define PyBUF_CONTIG (PyBUF_ND | PyBUF_WRITABLE)
-#define PyBUF_CONTIG_RO (PyBUF_ND)
-
-#define PyBUF_STRIDED (PyBUF_STRIDES | PyBUF_WRITABLE)
-#define PyBUF_STRIDED_RO (PyBUF_STRIDES)
-
-#define PyBUF_RECORDS (PyBUF_STRIDES | PyBUF_WRITABLE | PyBUF_FORMAT)
-#define PyBUF_RECORDS_RO (PyBUF_STRIDES | PyBUF_FORMAT)
-
-#define PyBUF_FULL (PyBUF_INDIRECT | PyBUF_WRITABLE | PyBUF_FORMAT)
-#define PyBUF_FULL_RO (PyBUF_INDIRECT | PyBUF_FORMAT)
-
-
-#define PyBUF_READ 0x100
-#define PyBUF_WRITE 0x200
-
-/* End buffer interface */
-#endif /* Py_LIMITED_API */
-
-typedef int (*objobjproc)(PyObject *, PyObject *);
-typedef int (*visitproc)(PyObject *, void *);
-typedef int (*traverseproc)(PyObject *, visitproc, void *);
-
-#ifndef Py_LIMITED_API
-typedef struct {
- /* Number implementations must check *both*
- arguments for proper type and implement the necessary conversions
- in the slot functions themselves. */
-
- binaryfunc nb_add;
- binaryfunc nb_subtract;
- binaryfunc nb_multiply;
- binaryfunc nb_remainder;
- binaryfunc nb_divmod;
- ternaryfunc nb_power;
- unaryfunc nb_negative;
- unaryfunc nb_positive;
- unaryfunc nb_absolute;
- inquiry nb_bool;
- unaryfunc nb_invert;
- binaryfunc nb_lshift;
- binaryfunc nb_rshift;
- binaryfunc nb_and;
- binaryfunc nb_xor;
- binaryfunc nb_or;
- unaryfunc nb_int;
- void *nb_reserved; /* the slot formerly known as nb_long */
- unaryfunc nb_float;
-
- binaryfunc nb_inplace_add;
- binaryfunc nb_inplace_subtract;
- binaryfunc nb_inplace_multiply;
- binaryfunc nb_inplace_remainder;
- ternaryfunc nb_inplace_power;
- binaryfunc nb_inplace_lshift;
- binaryfunc nb_inplace_rshift;
- binaryfunc nb_inplace_and;
- binaryfunc nb_inplace_xor;
- binaryfunc nb_inplace_or;
-
- binaryfunc nb_floor_divide;
- binaryfunc nb_true_divide;
- binaryfunc nb_inplace_floor_divide;
- binaryfunc nb_inplace_true_divide;
-
- unaryfunc nb_index;
-
- binaryfunc nb_matrix_multiply;
- binaryfunc nb_inplace_matrix_multiply;
-} PyNumberMethods;
-
-typedef struct {
- lenfunc sq_length;
- binaryfunc sq_concat;
- ssizeargfunc sq_repeat;
- ssizeargfunc sq_item;
- void *was_sq_slice;
- ssizeobjargproc sq_ass_item;
- void *was_sq_ass_slice;
- objobjproc sq_contains;
-
- binaryfunc sq_inplace_concat;
- ssizeargfunc sq_inplace_repeat;
-} PySequenceMethods;
-
-typedef struct {
- lenfunc mp_length;
- binaryfunc mp_subscript;
- objobjargproc mp_ass_subscript;
-} PyMappingMethods;
-
-typedef struct {
- unaryfunc am_await;
- unaryfunc am_aiter;
- unaryfunc am_anext;
-} PyAsyncMethods;
-
-typedef struct {
- getbufferproc bf_getbuffer;
- releasebufferproc bf_releasebuffer;
-} PyBufferProcs;
-#endif /* Py_LIMITED_API */
-
-typedef void (*freefunc)(void *);
-typedef void (*destructor)(PyObject *);
-#ifndef Py_LIMITED_API
-/* We can't provide a full compile-time check that limited-API
- users won't implement tp_print. However, not defining printfunc
- and making tp_print of a different function pointer type
- should at least cause a warning in most cases. */
-typedef int (*printfunc)(PyObject *, FILE *, int);
-#endif
-typedef PyObject *(*getattrfunc)(PyObject *, char *);
-typedef PyObject *(*getattrofunc)(PyObject *, PyObject *);
-typedef int (*setattrfunc)(PyObject *, char *, PyObject *);
-typedef int (*setattrofunc)(PyObject *, PyObject *, PyObject *);
-typedef PyObject *(*reprfunc)(PyObject *);
-typedef Py_hash_t (*hashfunc)(PyObject *);
-typedef PyObject *(*richcmpfunc) (PyObject *, PyObject *, int);
-typedef PyObject *(*getiterfunc) (PyObject *);
-typedef PyObject *(*iternextfunc) (PyObject *);
-typedef PyObject *(*descrgetfunc) (PyObject *, PyObject *, PyObject *);
-typedef int (*descrsetfunc) (PyObject *, PyObject *, PyObject *);
-typedef int (*initproc)(PyObject *, PyObject *, PyObject *);
-typedef PyObject *(*newfunc)(struct _typeobject *, PyObject *, PyObject *);
-typedef PyObject *(*allocfunc)(struct _typeobject *, Py_ssize_t);
-
-#ifdef Py_LIMITED_API
-typedef struct _typeobject PyTypeObject; /* opaque */
-#else
-typedef struct _typeobject {
- PyObject_VAR_HEAD
- const char *tp_name; /* For printing, in format "<module>.<name>" */
- Py_ssize_t tp_basicsize, tp_itemsize; /* For allocation */
-
- /* Methods to implement standard operations */
-
- destructor tp_dealloc;
- printfunc tp_print;
- getattrfunc tp_getattr;
- setattrfunc tp_setattr;
- PyAsyncMethods *tp_as_async; /* formerly known as tp_compare (Python 2)
- or tp_reserved (Python 3) */
- reprfunc tp_repr;
-
- /* Method suites for standard classes */
-
- PyNumberMethods *tp_as_number;
- PySequenceMethods *tp_as_sequence;
- PyMappingMethods *tp_as_mapping;
-
- /* More standard operations (here for binary compatibility) */
-
- hashfunc tp_hash;
- ternaryfunc tp_call;
- reprfunc tp_str;
- getattrofunc tp_getattro;
- setattrofunc tp_setattro;
-
- /* Functions to access object as input/output buffer */
- PyBufferProcs *tp_as_buffer;
-
- /* Flags to define presence of optional/expanded features */
- unsigned long tp_flags;
-
- const char *tp_doc; /* Documentation string */
-
- /* Assigned meaning in release 2.0 */
- /* call function for all accessible objects */
- traverseproc tp_traverse;
-
- /* delete references to contained objects */
- inquiry tp_clear;
-
- /* Assigned meaning in release 2.1 */
- /* rich comparisons */
- richcmpfunc tp_richcompare;
-
- /* weak reference enabler */
- Py_ssize_t tp_weaklistoffset;
-
- /* Iterators */
- getiterfunc tp_iter;
- iternextfunc tp_iternext;
-
- /* Attribute descriptor and subclassing stuff */
- struct PyMethodDef *tp_methods;
- struct PyMemberDef *tp_members;
- struct PyGetSetDef *tp_getset;
- struct _typeobject *tp_base;
- PyObject *tp_dict;
- descrgetfunc tp_descr_get;
- descrsetfunc tp_descr_set;
- Py_ssize_t tp_dictoffset;
- initproc tp_init;
- allocfunc tp_alloc;
- newfunc tp_new;
- freefunc tp_free; /* Low-level free-memory routine */
- inquiry tp_is_gc; /* For PyObject_IS_GC */
- PyObject *tp_bases;
- PyObject *tp_mro; /* method resolution order */
- PyObject *tp_cache;
- PyObject *tp_subclasses;
- PyObject *tp_weaklist;
- destructor tp_del;
-
- /* Type attribute cache version tag. Added in version 2.6 */
- unsigned int tp_version_tag;
-
- destructor tp_finalize;
-
-#ifdef COUNT_ALLOCS
- /* these must be last and never explicitly initialized */
- Py_ssize_t tp_allocs;
- Py_ssize_t tp_frees;
- Py_ssize_t tp_maxalloc;
- struct _typeobject *tp_prev;
- struct _typeobject *tp_next;
-#endif
-} PyTypeObject;
-#endif
-
-typedef struct{
- int slot; /* slot id, see below */
- void *pfunc; /* function pointer */
-} PyType_Slot;
-
-typedef struct{
- const char* name;
- int basicsize;
- int itemsize;
- unsigned int flags;
- PyType_Slot *slots; /* terminated by slot==0. */
-} PyType_Spec;
-
-PyAPI_FUNC(PyObject*) PyType_FromSpec(PyType_Spec*);
-#if !defined(Py_LIMITED_API) || Py_LIMITED_API+0 >= 0x03030000
-PyAPI_FUNC(PyObject*) PyType_FromSpecWithBases(PyType_Spec*, PyObject*);
-#endif
-#if !defined(Py_LIMITED_API) || Py_LIMITED_API+0 >= 0x03040000
-PyAPI_FUNC(void*) PyType_GetSlot(PyTypeObject*, int);
-#endif
-
-#ifndef Py_LIMITED_API
-/* The *real* layout of a type object when allocated on the heap */
-typedef struct _heaptypeobject {
- /* Note: there's a dependency on the order of these members
- in slotptr() in typeobject.c . */
- PyTypeObject ht_type;
- PyAsyncMethods as_async;
- PyNumberMethods as_number;
- PyMappingMethods as_mapping;
- PySequenceMethods as_sequence; /* as_sequence comes after as_mapping,
- so that the mapping wins when both
- the mapping and the sequence define
- a given operator (e.g. __getitem__).
- see add_operators() in typeobject.c . */
- PyBufferProcs as_buffer;
- PyObject *ht_name, *ht_slots, *ht_qualname;
- struct _dictkeysobject *ht_cached_keys;
- /* here are optional user slots, followed by the members. */
-} PyHeapTypeObject;
-
-/* access macro to the members which are floating "behind" the object */
-#define PyHeapType_GET_MEMBERS(etype) \
- ((PyMemberDef *)(((char *)etype) + Py_TYPE(etype)->tp_basicsize))
-#endif
-
-/* Generic type check */
-PyAPI_FUNC(int) PyType_IsSubtype(PyTypeObject *, PyTypeObject *);
-#define PyObject_TypeCheck(ob, tp) \
- (Py_TYPE(ob) == (tp) || PyType_IsSubtype(Py_TYPE(ob), (tp)))
-
-PyAPI_DATA(PyTypeObject) PyType_Type; /* built-in 'type' */
-PyAPI_DATA(PyTypeObject) PyBaseObject_Type; /* built-in 'object' */
-PyAPI_DATA(PyTypeObject) PySuper_Type; /* built-in 'super' */
-
-PyAPI_FUNC(unsigned long) PyType_GetFlags(PyTypeObject*);
-
-#define PyType_Check(op) \
- PyType_FastSubclass(Py_TYPE(op), Py_TPFLAGS_TYPE_SUBCLASS)
-#define PyType_CheckExact(op) (Py_TYPE(op) == &PyType_Type)
-
-PyAPI_FUNC(int) PyType_Ready(PyTypeObject *);
-PyAPI_FUNC(PyObject *) PyType_GenericAlloc(PyTypeObject *, Py_ssize_t);
-PyAPI_FUNC(PyObject *) PyType_GenericNew(PyTypeObject *,
- PyObject *, PyObject *);
-#ifndef Py_LIMITED_API
-PyAPI_FUNC(const char *) _PyType_Name(PyTypeObject *);
-PyAPI_FUNC(PyObject *) _PyType_Lookup(PyTypeObject *, PyObject *);
-PyAPI_FUNC(PyObject *) _PyType_LookupId(PyTypeObject *, _Py_Identifier *);
-PyAPI_FUNC(PyObject *) _PyObject_LookupSpecial(PyObject *, _Py_Identifier *);
-PyAPI_FUNC(PyTypeObject *) _PyType_CalculateMetaclass(PyTypeObject *, PyObject *);
-#endif
-PyAPI_FUNC(unsigned int) PyType_ClearCache(void);
-PyAPI_FUNC(void) PyType_Modified(PyTypeObject *);
-
-#ifndef Py_LIMITED_API
-PyAPI_FUNC(PyObject *) _PyType_GetDocFromInternalDoc(const char *, const char *);
-PyAPI_FUNC(PyObject *) _PyType_GetTextSignatureFromInternalDoc(const char *, const char *);
-#endif
-
-/* Generic operations on objects */
-#ifndef Py_LIMITED_API
-struct _Py_Identifier;
-PyAPI_FUNC(int) PyObject_Print(PyObject *, FILE *, int);
-PyAPI_FUNC(void) _Py_BreakPoint(void);
-PyAPI_FUNC(void) _PyObject_Dump(PyObject *);
-PyAPI_FUNC(int) _PyObject_IsFreed(PyObject *);
-#endif
-PyAPI_FUNC(PyObject *) PyObject_Repr(PyObject *);
-PyAPI_FUNC(PyObject *) PyObject_Str(PyObject *);
-PyAPI_FUNC(PyObject *) PyObject_ASCII(PyObject *);
-PyAPI_FUNC(PyObject *) PyObject_Bytes(PyObject *);
-PyAPI_FUNC(PyObject *) PyObject_RichCompare(PyObject *, PyObject *, int);
-PyAPI_FUNC(int) PyObject_RichCompareBool(PyObject *, PyObject *, int);
-PyAPI_FUNC(PyObject *) PyObject_GetAttrString(PyObject *, const char *);
-PyAPI_FUNC(int) PyObject_SetAttrString(PyObject *, const char *, PyObject *);
-PyAPI_FUNC(int) PyObject_HasAttrString(PyObject *, const char *);
-PyAPI_FUNC(PyObject *) PyObject_GetAttr(PyObject *, PyObject *);
-PyAPI_FUNC(int) PyObject_SetAttr(PyObject *, PyObject *, PyObject *);
-PyAPI_FUNC(int) PyObject_HasAttr(PyObject *, PyObject *);
-#ifndef Py_LIMITED_API
-PyAPI_FUNC(int) _PyObject_IsAbstract(PyObject *);
-PyAPI_FUNC(PyObject *) _PyObject_GetAttrId(PyObject *, struct _Py_Identifier *);
-PyAPI_FUNC(int) _PyObject_SetAttrId(PyObject *, struct _Py_Identifier *, PyObject *);
-PyAPI_FUNC(int) _PyObject_HasAttrId(PyObject *, struct _Py_Identifier *);
-/* Replacements of PyObject_GetAttr() and _PyObject_GetAttrId() which
- don't raise AttributeError.
-
- Return 1 and set *result != NULL if an attribute is found.
- Return 0 and set *result == NULL if an attribute is not found;
- an AttributeError is silenced.
- Return -1 and set *result == NULL if an error other than AttributeError
- is raised.
-*/
-PyAPI_FUNC(int) _PyObject_LookupAttr(PyObject *, PyObject *, PyObject **);
-PyAPI_FUNC(int) _PyObject_LookupAttrId(PyObject *, struct _Py_Identifier *, PyObject **);
-PyAPI_FUNC(PyObject **) _PyObject_GetDictPtr(PyObject *);
-#endif
-PyAPI_FUNC(PyObject *) PyObject_SelfIter(PyObject *);
-#ifndef Py_LIMITED_API
-PyAPI_FUNC(PyObject *) _PyObject_NextNotImplemented(PyObject *);
-#endif
-PyAPI_FUNC(PyObject *) PyObject_GenericGetAttr(PyObject *, PyObject *);
-PyAPI_FUNC(int) PyObject_GenericSetAttr(PyObject *,
- PyObject *, PyObject *);
-#if !defined(Py_LIMITED_API) || Py_LIMITED_API+0 >= 0x03030000
-PyAPI_FUNC(int) PyObject_GenericSetDict(PyObject *, PyObject *, void *);
-#endif
-PyAPI_FUNC(Py_hash_t) PyObject_Hash(PyObject *);
-PyAPI_FUNC(Py_hash_t) PyObject_HashNotImplemented(PyObject *);
-PyAPI_FUNC(int) PyObject_IsTrue(PyObject *);
-PyAPI_FUNC(int) PyObject_Not(PyObject *);
-PyAPI_FUNC(int) PyCallable_Check(PyObject *);
-
-PyAPI_FUNC(void) PyObject_ClearWeakRefs(PyObject *);
-#ifndef Py_LIMITED_API
-PyAPI_FUNC(void) PyObject_CallFinalizer(PyObject *);
-PyAPI_FUNC(int) PyObject_CallFinalizerFromDealloc(PyObject *);
-#endif
-
-#ifndef Py_LIMITED_API
-/* Same as PyObject_Generic{Get,Set}Attr, but passing the attributes
- dict as the last parameter. */
-PyAPI_FUNC(PyObject *)
-_PyObject_GenericGetAttrWithDict(PyObject *, PyObject *, PyObject *, int);
-PyAPI_FUNC(int)
-_PyObject_GenericSetAttrWithDict(PyObject *, PyObject *,
- PyObject *, PyObject *);
-#endif /* !Py_LIMITED_API */
-
-/* Helper to look up a builtin object */
-#ifndef Py_LIMITED_API
-PyAPI_FUNC(PyObject *)
-_PyObject_GetBuiltin(const char *name);
-#endif
-
-/* PyObject_Dir(obj) acts like Python builtins.dir(obj), returning a
- list of strings. PyObject_Dir(NULL) is like builtins.dir(),
- returning the names of the current locals. In this case, if there are
- no current locals, NULL is returned, and PyErr_Occurred() is false.
-*/
-PyAPI_FUNC(PyObject *) PyObject_Dir(PyObject *);
-
-
-/* Helpers for printing recursive container types */
-PyAPI_FUNC(int) Py_ReprEnter(PyObject *);
-PyAPI_FUNC(void) Py_ReprLeave(PyObject *);
-
-/* Flag bits for printing: */
-#define Py_PRINT_RAW 1 /* No string quotes etc. */
-
-/*
-`Type flags (tp_flags)
-
-These flags are used to extend the type structure in a backwards-compatible
-fashion. Extensions can use the flags to indicate (and test) when a given
-type structure contains a new feature. The Python core will use these when
-introducing new functionality between major revisions (to avoid mid-version
-changes in the PYTHON_API_VERSION).
-
-Arbitration of the flag bit positions will need to be coordinated among
-all extension writers who publicly release their extensions (this will
-be fewer than you might expect!)..
-
-Most flags were removed as of Python 3.0 to make room for new flags. (Some
-flags are not for backwards compatibility but to indicate the presence of an
-optional feature; these flags remain of course.)
-
-Type definitions should use Py_TPFLAGS_DEFAULT for their tp_flags value.
-
-Code can use PyType_HasFeature(type_ob, flag_value) to test whether the
-given type object has a specified feature.
-*/
-
-/* Set if the type object is dynamically allocated */
-#define Py_TPFLAGS_HEAPTYPE (1UL << 9)
-
-/* Set if the type allows subclassing */
-#define Py_TPFLAGS_BASETYPE (1UL << 10)
-
-/* Set if the type is 'ready' -- fully initialized */
-#define Py_TPFLAGS_READY (1UL << 12)
-
-/* Set while the type is being 'readied', to prevent recursive ready calls */
-#define Py_TPFLAGS_READYING (1UL << 13)
-
-/* Objects support garbage collection (see objimp.h) */
-#define Py_TPFLAGS_HAVE_GC (1UL << 14)
-
-/* These two bits are preserved for Stackless Python, next after this is 17 */
-#ifdef STACKLESS
-#define Py_TPFLAGS_HAVE_STACKLESS_EXTENSION (3UL << 15)
-#else
-#define Py_TPFLAGS_HAVE_STACKLESS_EXTENSION 0
-#endif
-
-/* Objects support type attribute cache */
-#define Py_TPFLAGS_HAVE_VERSION_TAG (1UL << 18)
-#define Py_TPFLAGS_VALID_VERSION_TAG (1UL << 19)
-
-/* Type is abstract and cannot be instantiated */
-#define Py_TPFLAGS_IS_ABSTRACT (1UL << 20)
-
-/* These flags are used to determine if a type is a subclass. */
-#define Py_TPFLAGS_LONG_SUBCLASS (1UL << 24)
-#define Py_TPFLAGS_LIST_SUBCLASS (1UL << 25)
-#define Py_TPFLAGS_TUPLE_SUBCLASS (1UL << 26)
-#define Py_TPFLAGS_BYTES_SUBCLASS (1UL << 27)
-#define Py_TPFLAGS_UNICODE_SUBCLASS (1UL << 28)
-#define Py_TPFLAGS_DICT_SUBCLASS (1UL << 29)
-#define Py_TPFLAGS_BASE_EXC_SUBCLASS (1UL << 30)
-#define Py_TPFLAGS_TYPE_SUBCLASS (1UL << 31)
-
-#define Py_TPFLAGS_DEFAULT ( \
- Py_TPFLAGS_HAVE_STACKLESS_EXTENSION | \
- Py_TPFLAGS_HAVE_VERSION_TAG | \
- 0)
-
-/* NOTE: The following flags reuse lower bits (removed as part of the
- * Python 3.0 transition). */
-
-/* Type structure has tp_finalize member (3.4) */
-#define Py_TPFLAGS_HAVE_FINALIZE (1UL << 0)
-
-#ifdef Py_LIMITED_API
-#define PyType_HasFeature(t,f) ((PyType_GetFlags(t) & (f)) != 0)
-#else
-#define PyType_HasFeature(t,f) (((t)->tp_flags & (f)) != 0)
-#endif
-#define PyType_FastSubclass(t,f) PyType_HasFeature(t,f)
-
-
-/*
-The macros Py_INCREF(op) and Py_DECREF(op) are used to increment or decrement
-reference counts. Py_DECREF calls the object's deallocator function when
-the refcount falls to 0; for
-objects that don't contain references to other objects or heap memory
-this can be the standard function free(). Both macros can be used
-wherever a void expression is allowed. The argument must not be a
-NULL pointer. If it may be NULL, use Py_XINCREF/Py_XDECREF instead.
-The macro _Py_NewReference(op) initialize reference counts to 1, and
-in special builds (Py_REF_DEBUG, Py_TRACE_REFS) performs additional
-bookkeeping appropriate to the special build.
-
-We assume that the reference count field can never overflow; this can
-be proven when the size of the field is the same as the pointer size, so
-we ignore the possibility. Provided a C int is at least 32 bits (which
-is implicitly assumed in many parts of this code), that's enough for
-about 2**31 references to an object.
-
-XXX The following became out of date in Python 2.2, but I'm not sure
-XXX what the full truth is now. Certainly, heap-allocated type objects
-XXX can and should be deallocated.
-Type objects should never be deallocated; the type pointer in an object
-is not considered to be a reference to the type object, to save
-complications in the deallocation function. (This is actually a
-decision that's up to the implementer of each new type so if you want,
-you can count such references to the type object.)
-*/
-
-/* First define a pile of simple helper macros, one set per special
- * build symbol. These either expand to the obvious things, or to
- * nothing at all when the special mode isn't in effect. The main
- * macros can later be defined just once then, yet expand to different
- * things depending on which special build options are and aren't in effect.
- * Trust me <wink>: while painful, this is 20x easier to understand than,
- * e.g, defining _Py_NewReference five different times in a maze of nested
- * #ifdefs (we used to do that -- it was impenetrable).
- */
-#ifdef Py_REF_DEBUG
-PyAPI_DATA(Py_ssize_t) _Py_RefTotal;
-PyAPI_FUNC(void) _Py_NegativeRefcount(const char *fname,
- int lineno, PyObject *op);
-PyAPI_FUNC(Py_ssize_t) _Py_GetRefTotal(void);
-#define _Py_INC_REFTOTAL _Py_RefTotal++
-#define _Py_DEC_REFTOTAL _Py_RefTotal--
-#define _Py_REF_DEBUG_COMMA ,
-#define _Py_CHECK_REFCNT(OP) \
-{ if (((PyObject*)OP)->ob_refcnt < 0) \
- _Py_NegativeRefcount(__FILE__, __LINE__, \
- (PyObject *)(OP)); \
-}
-/* Py_REF_DEBUG also controls the display of refcounts and memory block
- * allocations at the interactive prompt and at interpreter shutdown
- */
-PyAPI_FUNC(void) _PyDebug_PrintTotalRefs(void);
-#else
-#define _Py_INC_REFTOTAL
-#define _Py_DEC_REFTOTAL
-#define _Py_REF_DEBUG_COMMA
-#define _Py_CHECK_REFCNT(OP) /* a semicolon */;
-#endif /* Py_REF_DEBUG */
-
-#ifdef COUNT_ALLOCS
-PyAPI_FUNC(void) inc_count(PyTypeObject *);
-PyAPI_FUNC(void) dec_count(PyTypeObject *);
-#define _Py_INC_TPALLOCS(OP) inc_count(Py_TYPE(OP))
-#define _Py_INC_TPFREES(OP) dec_count(Py_TYPE(OP))
-#define _Py_DEC_TPFREES(OP) Py_TYPE(OP)->tp_frees--
-#define _Py_COUNT_ALLOCS_COMMA ,
-#else
-#define _Py_INC_TPALLOCS(OP)
-#define _Py_INC_TPFREES(OP)
-#define _Py_DEC_TPFREES(OP)
-#define _Py_COUNT_ALLOCS_COMMA
-#endif /* COUNT_ALLOCS */
-
-#ifdef Py_TRACE_REFS
-/* Py_TRACE_REFS is such major surgery that we call external routines. */
-PyAPI_FUNC(void) _Py_NewReference(PyObject *);
-PyAPI_FUNC(void) _Py_ForgetReference(PyObject *);
-PyAPI_FUNC(void) _Py_Dealloc(PyObject *);
-PyAPI_FUNC(void) _Py_PrintReferences(FILE *);
-PyAPI_FUNC(void) _Py_PrintReferenceAddresses(FILE *);
-PyAPI_FUNC(void) _Py_AddToAllObjects(PyObject *, int force);
-
-#else
-/* Without Py_TRACE_REFS, there's little enough to do that we expand code
- * inline.
- */
-#define _Py_NewReference(op) ( \
- _Py_INC_TPALLOCS(op) _Py_COUNT_ALLOCS_COMMA \
- _Py_INC_REFTOTAL _Py_REF_DEBUG_COMMA \
- Py_REFCNT(op) = 1)
-
-#define _Py_ForgetReference(op) _Py_INC_TPFREES(op)
-
-#ifdef Py_LIMITED_API
-PyAPI_FUNC(void) _Py_Dealloc(PyObject *);
-#else
-#define _Py_Dealloc(op) ( \
- _Py_INC_TPFREES(op) _Py_COUNT_ALLOCS_COMMA \
- (*Py_TYPE(op)->tp_dealloc)((PyObject *)(op)))
-#endif
-#endif /* !Py_TRACE_REFS */
-
-#define Py_INCREF(op) ( \
- _Py_INC_REFTOTAL _Py_REF_DEBUG_COMMA \
- ((PyObject *)(op))->ob_refcnt++)
-
-#define Py_DECREF(op) \
- do { \
- PyObject *_py_decref_tmp = (PyObject *)(op); \
- if (_Py_DEC_REFTOTAL _Py_REF_DEBUG_COMMA \
- --(_py_decref_tmp)->ob_refcnt != 0) \
- _Py_CHECK_REFCNT(_py_decref_tmp) \
- else \
- _Py_Dealloc(_py_decref_tmp); \
- } while (0)
-
-/* Safely decref `op` and set `op` to NULL, especially useful in tp_clear
- * and tp_dealloc implementations.
- *
- * Note that "the obvious" code can be deadly:
- *
- * Py_XDECREF(op);
- * op = NULL;
- *
- * Typically, `op` is something like self->containee, and `self` is done
- * using its `containee` member. In the code sequence above, suppose
- * `containee` is non-NULL with a refcount of 1. Its refcount falls to
- * 0 on the first line, which can trigger an arbitrary amount of code,
- * possibly including finalizers (like __del__ methods or weakref callbacks)
- * coded in Python, which in turn can release the GIL and allow other threads
- * to run, etc. Such code may even invoke methods of `self` again, or cause
- * cyclic gc to trigger, but-- oops! --self->containee still points to the
- * object being torn down, and it may be in an insane state while being torn
- * down. This has in fact been a rich historic source of miserable (rare &
- * hard-to-diagnose) segfaulting (and other) bugs.
- *
- * The safe way is:
- *
- * Py_CLEAR(op);
- *
- * That arranges to set `op` to NULL _before_ decref'ing, so that any code
- * triggered as a side-effect of `op` getting torn down no longer believes
- * `op` points to a valid object.
- *
- * There are cases where it's safe to use the naive code, but they're brittle.
- * For example, if `op` points to a Python integer, you know that destroying
- * one of those can't cause problems -- but in part that relies on that
- * Python integers aren't currently weakly referencable. Best practice is
- * to use Py_CLEAR() even if you can't think of a reason for why you need to.
- */
-#define Py_CLEAR(op) \
- do { \
- PyObject *_py_tmp = (PyObject *)(op); \
- if (_py_tmp != NULL) { \
- (op) = NULL; \
- Py_DECREF(_py_tmp); \
- } \
- } while (0)
-
-/* Macros to use in case the object pointer may be NULL: */
-#define Py_XINCREF(op) \
- do { \
- PyObject *_py_xincref_tmp = (PyObject *)(op); \
- if (_py_xincref_tmp != NULL) \
- Py_INCREF(_py_xincref_tmp); \
- } while (0)
-
-#define Py_XDECREF(op) \
- do { \
- PyObject *_py_xdecref_tmp = (PyObject *)(op); \
- if (_py_xdecref_tmp != NULL) \
- Py_DECREF(_py_xdecref_tmp); \
- } while (0)
-
-#ifndef Py_LIMITED_API
-/* Safely decref `op` and set `op` to `op2`.
- *
- * As in case of Py_CLEAR "the obvious" code can be deadly:
- *
- * Py_DECREF(op);
- * op = op2;
- *
- * The safe way is:
- *
- * Py_SETREF(op, op2);
- *
- * That arranges to set `op` to `op2` _before_ decref'ing, so that any code
- * triggered as a side-effect of `op` getting torn down no longer believes
- * `op` points to a valid object.
- *
- * Py_XSETREF is a variant of Py_SETREF that uses Py_XDECREF instead of
- * Py_DECREF.
- */
-
-#define Py_SETREF(op, op2) \
- do { \
- PyObject *_py_tmp = (PyObject *)(op); \
- (op) = (op2); \
- Py_DECREF(_py_tmp); \
- } while (0)
-
-#define Py_XSETREF(op, op2) \
- do { \
- PyObject *_py_tmp = (PyObject *)(op); \
- (op) = (op2); \
- Py_XDECREF(_py_tmp); \
- } while (0)
-
-#endif /* ifndef Py_LIMITED_API */
-
-/*
-These are provided as conveniences to Python runtime embedders, so that
-they can have object code that is not dependent on Python compilation flags.
-*/
-PyAPI_FUNC(void) Py_IncRef(PyObject *);
-PyAPI_FUNC(void) Py_DecRef(PyObject *);
-
-#ifndef Py_LIMITED_API
-PyAPI_DATA(PyTypeObject) _PyNone_Type;
-PyAPI_DATA(PyTypeObject) _PyNotImplemented_Type;
-#endif /* !Py_LIMITED_API */
-
-/*
-_Py_NoneStruct is an object of undefined type which can be used in contexts
-where NULL (nil) is not suitable (since NULL often means 'error').
-
-Don't forget to apply Py_INCREF() when returning this value!!!
-*/
-PyAPI_DATA(PyObject) _Py_NoneStruct; /* Don't use this directly */
-#define Py_None (&_Py_NoneStruct)
-
-/* Macro for returning Py_None from a function */
-#define Py_RETURN_NONE return Py_INCREF(Py_None), Py_None
-
-/*
-Py_NotImplemented is a singleton used to signal that an operation is
-not implemented for a given type combination.
-*/
-PyAPI_DATA(PyObject) _Py_NotImplementedStruct; /* Don't use this directly */
-#define Py_NotImplemented (&_Py_NotImplementedStruct)
-
-/* Macro for returning Py_NotImplemented from a function */
-#define Py_RETURN_NOTIMPLEMENTED \
- return Py_INCREF(Py_NotImplemented), Py_NotImplemented
-
-/* Rich comparison opcodes */
-#define Py_LT 0
-#define Py_LE 1
-#define Py_EQ 2
-#define Py_NE 3
-#define Py_GT 4
-#define Py_GE 5
-
-/*
- * Macro for implementing rich comparisons
- *
- * Needs to be a macro because any C-comparable type can be used.
- */
-#define Py_RETURN_RICHCOMPARE(val1, val2, op) \
- do { \
- switch (op) { \
- case Py_EQ: if ((val1) == (val2)) Py_RETURN_TRUE; Py_RETURN_FALSE; \
- case Py_NE: if ((val1) != (val2)) Py_RETURN_TRUE; Py_RETURN_FALSE; \
- case Py_LT: if ((val1) < (val2)) Py_RETURN_TRUE; Py_RETURN_FALSE; \
- case Py_GT: if ((val1) > (val2)) Py_RETURN_TRUE; Py_RETURN_FALSE; \
- case Py_LE: if ((val1) <= (val2)) Py_RETURN_TRUE; Py_RETURN_FALSE; \
- case Py_GE: if ((val1) >= (val2)) Py_RETURN_TRUE; Py_RETURN_FALSE; \
- default: \
- Py_UNREACHABLE(); \
- } \
- } while (0)
-
-#ifndef Py_LIMITED_API
-/* Maps Py_LT to Py_GT, ..., Py_GE to Py_LE.
- * Defined in object.c.
- */
-PyAPI_DATA(int) _Py_SwappedOp[];
-#endif /* !Py_LIMITED_API */
-
-
-/*
-More conventions
-================
-
-Argument Checking
------------------
-
-Functions that take objects as arguments normally don't check for nil
-arguments, but they do check the type of the argument, and return an
-error if the function doesn't apply to the type.
-
-Failure Modes
--------------
-
-Functions may fail for a variety of reasons, including running out of
-memory. This is communicated to the caller in two ways: an error string
-is set (see errors.h), and the function result differs: functions that
-normally return a pointer return NULL for failure, functions returning
-an integer return -1 (which could be a legal return value too!), and
-other functions return 0 for success and -1 for failure.
-Callers should always check for errors before using the result. If
-an error was set, the caller must either explicitly clear it, or pass
-the error on to its caller.
-
-Reference Counts
-----------------
-
-It takes a while to get used to the proper usage of reference counts.
-
-Functions that create an object set the reference count to 1; such new
-objects must be stored somewhere or destroyed again with Py_DECREF().
-Some functions that 'store' objects, such as PyTuple_SetItem() and
-PyList_SetItem(),
-don't increment the reference count of the object, since the most
-frequent use is to store a fresh object. Functions that 'retrieve'
-objects, such as PyTuple_GetItem() and PyDict_GetItemString(), also
-don't increment
-the reference count, since most frequently the object is only looked at
-quickly. Thus, to retrieve an object and store it again, the caller
-must call Py_INCREF() explicitly.
-
-NOTE: functions that 'consume' a reference count, like
-PyList_SetItem(), consume the reference even if the object wasn't
-successfully stored, to simplify error handling.
-
-It seems attractive to make other functions that take an object as
-argument consume a reference count; however, this may quickly get
-confusing (even the current practice is already confusing). Consider
-it carefully, it may save lots of calls to Py_INCREF() and Py_DECREF() at
-times.
-*/
-
-
-/* Trashcan mechanism, thanks to Christian Tismer.
-
-When deallocating a container object, it's possible to trigger an unbounded
-chain of deallocations, as each Py_DECREF in turn drops the refcount on "the
-next" object in the chain to 0. This can easily lead to stack faults, and
-especially in threads (which typically have less stack space to work with).
-
-A container object that participates in cyclic gc can avoid this by
-bracketing the body of its tp_dealloc function with a pair of macros:
-
-static void
-mytype_dealloc(mytype *p)
-{
- ... declarations go here ...
-
- PyObject_GC_UnTrack(p); // must untrack first
- Py_TRASHCAN_SAFE_BEGIN(p)
- ... The body of the deallocator goes here, including all calls ...
- ... to Py_DECREF on contained objects. ...
- Py_TRASHCAN_SAFE_END(p)
-}
-
-CAUTION: Never return from the middle of the body! If the body needs to
-"get out early", put a label immediately before the Py_TRASHCAN_SAFE_END
-call, and goto it. Else the call-depth counter (see below) will stay
-above 0 forever, and the trashcan will never get emptied.
-
-How it works: The BEGIN macro increments a call-depth counter. So long
-as this counter is small, the body of the deallocator is run directly without
-further ado. But if the counter gets large, it instead adds p to a list of
-objects to be deallocated later, skips the body of the deallocator, and
-resumes execution after the END macro. The tp_dealloc routine then returns
-without deallocating anything (and so unbounded call-stack depth is avoided).
-
-When the call stack finishes unwinding again, code generated by the END macro
-notices this, and calls another routine to deallocate all the objects that
-may have been added to the list of deferred deallocations. In effect, a
-chain of N deallocations is broken into (N-1)/(PyTrash_UNWIND_LEVEL-1) pieces,
-with the call stack never exceeding a depth of PyTrash_UNWIND_LEVEL.
-*/
-
-#ifndef Py_LIMITED_API
-/* This is the old private API, invoked by the macros before 3.2.4.
- Kept for binary compatibility of extensions using the stable ABI. */
-PyAPI_FUNC(void) _PyTrash_deposit_object(PyObject*);
-PyAPI_FUNC(void) _PyTrash_destroy_chain(void);
-#endif /* !Py_LIMITED_API */
-
-/* The new thread-safe private API, invoked by the macros below. */
-PyAPI_FUNC(void) _PyTrash_thread_deposit_object(PyObject*);
-PyAPI_FUNC(void) _PyTrash_thread_destroy_chain(void);
-
-#define PyTrash_UNWIND_LEVEL 50
-
-#define Py_TRASHCAN_SAFE_BEGIN(op) \
- do { \
- PyThreadState *_tstate = PyThreadState_GET(); \
- if (_tstate->trash_delete_nesting < PyTrash_UNWIND_LEVEL) { \
- ++_tstate->trash_delete_nesting;
- /* The body of the deallocator is here. */
-#define Py_TRASHCAN_SAFE_END(op) \
- --_tstate->trash_delete_nesting; \
- if (_tstate->trash_delete_later && _tstate->trash_delete_nesting <= 0) \
- _PyTrash_thread_destroy_chain(); \
- } \
- else \
- _PyTrash_thread_deposit_object((PyObject*)op); \
- } while (0);
-
-#ifndef Py_LIMITED_API
-PyAPI_FUNC(void)
-_PyDebugAllocatorStats(FILE *out, const char *block_name, int num_blocks,
- size_t sizeof_block);
-PyAPI_FUNC(void)
-_PyObject_DebugTypeStats(FILE *out);
-#endif /* ifndef Py_LIMITED_API */
-
-#ifdef __cplusplus
-}
-#endif
-#endif /* !Py_OBJECT_H */
diff --git a/pythonsdk/include/objimpl.h b/pythonsdk/include/objimpl.h
deleted file mode 100644
index 67c17854f959512c516e18ca334e8ee794ff5960..0000000000000000000000000000000000000000
--- a/pythonsdk/include/objimpl.h
+++ /dev/null
@@ -1,374 +0,0 @@
-/* The PyObject_ memory family: high-level object memory interfaces.
- See pymem.h for the low-level PyMem_ family.
-*/
-
-#ifndef Py_OBJIMPL_H
-#define Py_OBJIMPL_H
-
-#include "pymem.h"
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-/* BEWARE:
-
- Each interface exports both functions and macros. Extension modules should
- use the functions, to ensure binary compatibility across Python versions.
- Because the Python implementation is free to change internal details, and
- the macros may (or may not) expose details for speed, if you do use the
- macros you must recompile your extensions with each Python release.
-
- Never mix calls to PyObject_ memory functions with calls to the platform
- malloc/realloc/ calloc/free, or with calls to PyMem_.
-*/
-
-/*
-Functions and macros for modules that implement new object types.
-
- - PyObject_New(type, typeobj) allocates memory for a new object of the given
- type, and initializes part of it. 'type' must be the C structure type used
- to represent the object, and 'typeobj' the address of the corresponding
- type object. Reference count and type pointer are filled in; the rest of
- the bytes of the object are *undefined*! The resulting expression type is
- 'type *'. The size of the object is determined by the tp_basicsize field
- of the type object.
-
- - PyObject_NewVar(type, typeobj, n) is similar but allocates a variable-size
- object with room for n items. In addition to the refcount and type pointer
- fields, this also fills in the ob_size field.
-
- - PyObject_Del(op) releases the memory allocated for an object. It does not
- run a destructor -- it only frees the memory. PyObject_Free is identical.
-
- - PyObject_Init(op, typeobj) and PyObject_InitVar(op, typeobj, n) don't
- allocate memory. Instead of a 'type' parameter, they take a pointer to a
- new object (allocated by an arbitrary allocator), and initialize its object
- header fields.
-
-Note that objects created with PyObject_{New, NewVar} are allocated using the
-specialized Python allocator (implemented in obmalloc.c), if WITH_PYMALLOC is
-enabled. In addition, a special debugging allocator is used if PYMALLOC_DEBUG
-is also #defined.
-
-In case a specific form of memory management is needed (for example, if you
-must use the platform malloc heap(s), or shared memory, or C++ local storage or
-operator new), you must first allocate the object with your custom allocator,
-then pass its pointer to PyObject_{Init, InitVar} for filling in its Python-
-specific fields: reference count, type pointer, possibly others. You should
-be aware that Python has no control over these objects because they don't
-cooperate with the Python memory manager. Such objects may not be eligible
-for automatic garbage collection and you have to make sure that they are
-released accordingly whenever their destructor gets called (cf. the specific
-form of memory management you're using).
-
-Unless you have specific memory management requirements, use
-PyObject_{New, NewVar, Del}.
-*/
-
-/*
- * Raw object memory interface
- * ===========================
- */
-
-/* Functions to call the same malloc/realloc/free as used by Python's
- object allocator. If WITH_PYMALLOC is enabled, these may differ from
- the platform malloc/realloc/free. The Python object allocator is
- designed for fast, cache-conscious allocation of many "small" objects,
- and with low hidden memory overhead.
-
- PyObject_Malloc(0) returns a unique non-NULL pointer if possible.
-
- PyObject_Realloc(NULL, n) acts like PyObject_Malloc(n).
- PyObject_Realloc(p != NULL, 0) does not return NULL, or free the memory
- at p.
-
- Returned pointers must be checked for NULL explicitly; no action is
- performed on failure other than to return NULL (no warning it printed, no
- exception is set, etc).
-
- For allocating objects, use PyObject_{New, NewVar} instead whenever
- possible. The PyObject_{Malloc, Realloc, Free} family is exposed
- so that you can exploit Python's small-block allocator for non-object
- uses. If you must use these routines to allocate object memory, make sure
- the object gets initialized via PyObject_{Init, InitVar} after obtaining
- the raw memory.
-*/
-PyAPI_FUNC(void *) PyObject_Malloc(size_t size);
-#if !defined(Py_LIMITED_API) || Py_LIMITED_API+0 >= 0x03050000
-PyAPI_FUNC(void *) PyObject_Calloc(size_t nelem, size_t elsize);
-#endif
-PyAPI_FUNC(void *) PyObject_Realloc(void *ptr, size_t new_size);
-PyAPI_FUNC(void) PyObject_Free(void *ptr);
-
-#ifndef Py_LIMITED_API
-/* This function returns the number of allocated memory blocks, regardless of size */
-PyAPI_FUNC(Py_ssize_t) _Py_GetAllocatedBlocks(void);
-#endif /* !Py_LIMITED_API */
-
-/* Macros */
-#ifdef WITH_PYMALLOC
-#ifndef Py_LIMITED_API
-PyAPI_FUNC(int) _PyObject_DebugMallocStats(FILE *out);
-#endif /* #ifndef Py_LIMITED_API */
-#endif
-
-/* Macros */
-#define PyObject_MALLOC PyObject_Malloc
-#define PyObject_REALLOC PyObject_Realloc
-#define PyObject_FREE PyObject_Free
-#define PyObject_Del PyObject_Free
-#define PyObject_DEL PyObject_Free
-
-
-/*
- * Generic object allocator interface
- * ==================================
- */
-
-/* Functions */
-PyAPI_FUNC(PyObject *) PyObject_Init(PyObject *, PyTypeObject *);
-PyAPI_FUNC(PyVarObject *) PyObject_InitVar(PyVarObject *,
- PyTypeObject *, Py_ssize_t);
-PyAPI_FUNC(PyObject *) _PyObject_New(PyTypeObject *);
-PyAPI_FUNC(PyVarObject *) _PyObject_NewVar(PyTypeObject *, Py_ssize_t);
-
-#define PyObject_New(type, typeobj) \
- ( (type *) _PyObject_New(typeobj) )
-#define PyObject_NewVar(type, typeobj, n) \
- ( (type *) _PyObject_NewVar((typeobj), (n)) )
-
-/* Macros trading binary compatibility for speed. See also pymem.h.
- Note that these macros expect non-NULL object pointers.*/
-#define PyObject_INIT(op, typeobj) \
- ( Py_TYPE(op) = (typeobj), _Py_NewReference((PyObject *)(op)), (op) )
-#define PyObject_INIT_VAR(op, typeobj, size) \
- ( Py_SIZE(op) = (size), PyObject_INIT((op), (typeobj)) )
-
-#define _PyObject_SIZE(typeobj) ( (typeobj)->tp_basicsize )
-
-/* _PyObject_VAR_SIZE returns the number of bytes (as size_t) allocated for a
- vrbl-size object with nitems items, exclusive of gc overhead (if any). The
- value is rounded up to the closest multiple of sizeof(void *), in order to
- ensure that pointer fields at the end of the object are correctly aligned
- for the platform (this is of special importance for subclasses of, e.g.,
- str or int, so that pointers can be stored after the embedded data).
-
- Note that there's no memory wastage in doing this, as malloc has to
- return (at worst) pointer-aligned memory anyway.
-*/
-#if ((SIZEOF_VOID_P - 1) & SIZEOF_VOID_P) != 0
-# error "_PyObject_VAR_SIZE requires SIZEOF_VOID_P be a power of 2"
-#endif
-
-#define _PyObject_VAR_SIZE(typeobj, nitems) \
- _Py_SIZE_ROUND_UP((typeobj)->tp_basicsize + \
- (nitems)*(typeobj)->tp_itemsize, \
- SIZEOF_VOID_P)
-
-#define PyObject_NEW(type, typeobj) \
-( (type *) PyObject_Init( \
- (PyObject *) PyObject_MALLOC( _PyObject_SIZE(typeobj) ), (typeobj)) )
-
-#define PyObject_NEW_VAR(type, typeobj, n) \
-( (type *) PyObject_InitVar( \
- (PyVarObject *) PyObject_MALLOC(_PyObject_VAR_SIZE((typeobj),(n)) ),\
- (typeobj), (n)) )
-
-/* This example code implements an object constructor with a custom
- allocator, where PyObject_New is inlined, and shows the important
- distinction between two steps (at least):
- 1) the actual allocation of the object storage;
- 2) the initialization of the Python specific fields
- in this storage with PyObject_{Init, InitVar}.
-
- PyObject *
- YourObject_New(...)
- {
- PyObject *op;
-
- op = (PyObject *) Your_Allocator(_PyObject_SIZE(YourTypeStruct));
- if (op == NULL)
- return PyErr_NoMemory();
-
- PyObject_Init(op, &YourTypeStruct);
-
- op->ob_field = value;
- ...
- return op;
- }
-
- Note that in C++, the use of the new operator usually implies that
- the 1st step is performed automatically for you, so in a C++ class
- constructor you would start directly with PyObject_Init/InitVar
-*/
-
-#ifndef Py_LIMITED_API
-typedef struct {
- /* user context passed as the first argument to the 2 functions */
- void *ctx;
-
- /* allocate an arena of size bytes */
- void* (*alloc) (void *ctx, size_t size);
-
- /* free an arena */
- void (*free) (void *ctx, void *ptr, size_t size);
-} PyObjectArenaAllocator;
-
-/* Get the arena allocator. */
-PyAPI_FUNC(void) PyObject_GetArenaAllocator(PyObjectArenaAllocator *allocator);
-
-/* Set the arena allocator. */
-PyAPI_FUNC(void) PyObject_SetArenaAllocator(PyObjectArenaAllocator *allocator);
-#endif
-
-
-/*
- * Garbage Collection Support
- * ==========================
- */
-
-/* C equivalent of gc.collect() which ignores the state of gc.enabled. */
-PyAPI_FUNC(Py_ssize_t) PyGC_Collect(void);
-
-#ifndef Py_LIMITED_API
-PyAPI_FUNC(Py_ssize_t) _PyGC_CollectNoFail(void);
-PyAPI_FUNC(Py_ssize_t) _PyGC_CollectIfEnabled(void);
-#endif
-
-/* Test if a type has a GC head */
-#define PyType_IS_GC(t) PyType_HasFeature((t), Py_TPFLAGS_HAVE_GC)
-
-/* Test if an object has a GC head */
-#define PyObject_IS_GC(o) (PyType_IS_GC(Py_TYPE(o)) && \
- (Py_TYPE(o)->tp_is_gc == NULL || Py_TYPE(o)->tp_is_gc(o)))
-
-PyAPI_FUNC(PyVarObject *) _PyObject_GC_Resize(PyVarObject *, Py_ssize_t);
-#define PyObject_GC_Resize(type, op, n) \
- ( (type *) _PyObject_GC_Resize((PyVarObject *)(op), (n)) )
-
-/* GC information is stored BEFORE the object structure. */
-#ifndef Py_LIMITED_API
-typedef union _gc_head {
- struct {
- union _gc_head *gc_next;
- union _gc_head *gc_prev;
- Py_ssize_t gc_refs;
- } gc;
- long double dummy; /* force worst-case alignment */
- // malloc returns memory block aligned for any built-in types and
- // long double is the largest standard C type.
- // On amd64 linux, long double requires 16 byte alignment.
- // See bpo-27987 for more discussion.
-} PyGC_Head;
-
-extern PyGC_Head *_PyGC_generation0;
-
-#define _Py_AS_GC(o) ((PyGC_Head *)(o)-1)
-
-/* Bit 0 is set when tp_finalize is called */
-#define _PyGC_REFS_MASK_FINALIZED (1 << 0)
-/* The (N-1) most significant bits contain the gc state / refcount */
-#define _PyGC_REFS_SHIFT (1)
-#define _PyGC_REFS_MASK (((size_t) -1) << _PyGC_REFS_SHIFT)
-
-#define _PyGCHead_REFS(g) ((g)->gc.gc_refs >> _PyGC_REFS_SHIFT)
-#define _PyGCHead_SET_REFS(g, v) do { \
- (g)->gc.gc_refs = ((g)->gc.gc_refs & ~_PyGC_REFS_MASK) \
- | (((size_t)(v)) << _PyGC_REFS_SHIFT); \
- } while (0)
-#define _PyGCHead_DECREF(g) ((g)->gc.gc_refs -= 1 << _PyGC_REFS_SHIFT)
-
-#define _PyGCHead_FINALIZED(g) (((g)->gc.gc_refs & _PyGC_REFS_MASK_FINALIZED) != 0)
-#define _PyGCHead_SET_FINALIZED(g, v) do { \
- (g)->gc.gc_refs = ((g)->gc.gc_refs & ~_PyGC_REFS_MASK_FINALIZED) \
- | (v != 0); \
- } while (0)
-
-#define _PyGC_FINALIZED(o) _PyGCHead_FINALIZED(_Py_AS_GC(o))
-#define _PyGC_SET_FINALIZED(o, v) _PyGCHead_SET_FINALIZED(_Py_AS_GC(o), v)
-
-#define _PyGC_REFS(o) _PyGCHead_REFS(_Py_AS_GC(o))
-
-#define _PyGC_REFS_UNTRACKED (-2)
-#define _PyGC_REFS_REACHABLE (-3)
-#define _PyGC_REFS_TENTATIVELY_UNREACHABLE (-4)
-
-/* Tell the GC to track this object. NB: While the object is tracked the
- * collector it must be safe to call the ob_traverse method. */
-#define _PyObject_GC_TRACK(o) do { \
- PyGC_Head *g = _Py_AS_GC(o); \
- if (_PyGCHead_REFS(g) != _PyGC_REFS_UNTRACKED) \
- Py_FatalError("GC object already tracked"); \
- _PyGCHead_SET_REFS(g, _PyGC_REFS_REACHABLE); \
- g->gc.gc_next = _PyGC_generation0; \
- g->gc.gc_prev = _PyGC_generation0->gc.gc_prev; \
- g->gc.gc_prev->gc.gc_next = g; \
- _PyGC_generation0->gc.gc_prev = g; \
- } while (0);
-
-/* Tell the GC to stop tracking this object.
- * gc_next doesn't need to be set to NULL, but doing so is a good
- * way to provoke memory errors if calling code is confused.
- */
-#define _PyObject_GC_UNTRACK(o) do { \
- PyGC_Head *g = _Py_AS_GC(o); \
- assert(_PyGCHead_REFS(g) != _PyGC_REFS_UNTRACKED); \
- _PyGCHead_SET_REFS(g, _PyGC_REFS_UNTRACKED); \
- g->gc.gc_prev->gc.gc_next = g->gc.gc_next; \
- g->gc.gc_next->gc.gc_prev = g->gc.gc_prev; \
- g->gc.gc_next = NULL; \
- } while (0);
-
-/* True if the object is currently tracked by the GC. */
-#define _PyObject_GC_IS_TRACKED(o) \
- (_PyGC_REFS(o) != _PyGC_REFS_UNTRACKED)
-
-/* True if the object may be tracked by the GC in the future, or already is.
- This can be useful to implement some optimizations. */
-#define _PyObject_GC_MAY_BE_TRACKED(obj) \
- (PyObject_IS_GC(obj) && \
- (!PyTuple_CheckExact(obj) || _PyObject_GC_IS_TRACKED(obj)))
-#endif /* Py_LIMITED_API */
-
-#ifndef Py_LIMITED_API
-PyAPI_FUNC(PyObject *) _PyObject_GC_Malloc(size_t size);
-PyAPI_FUNC(PyObject *) _PyObject_GC_Calloc(size_t size);
-#endif /* !Py_LIMITED_API */
-PyAPI_FUNC(PyObject *) _PyObject_GC_New(PyTypeObject *);
-PyAPI_FUNC(PyVarObject *) _PyObject_GC_NewVar(PyTypeObject *, Py_ssize_t);
-PyAPI_FUNC(void) PyObject_GC_Track(void *);
-PyAPI_FUNC(void) PyObject_GC_UnTrack(void *);
-PyAPI_FUNC(void) PyObject_GC_Del(void *);
-
-#define PyObject_GC_New(type, typeobj) \
- ( (type *) _PyObject_GC_New(typeobj) )
-#define PyObject_GC_NewVar(type, typeobj, n) \
- ( (type *) _PyObject_GC_NewVar((typeobj), (n)) )
-
-
-/* Utility macro to help write tp_traverse functions.
- * To use this macro, the tp_traverse function must name its arguments
- * "visit" and "arg". This is intended to keep tp_traverse functions
- * looking as much alike as possible.
- */
-#define Py_VISIT(op) \
- do { \
- if (op) { \
- int vret = visit((PyObject *)(op), arg); \
- if (vret) \
- return vret; \
- } \
- } while (0)
-
-
-/* Test if a type supports weak references */
-#define PyType_SUPPORTS_WEAKREFS(t) ((t)->tp_weaklistoffset > 0)
-
-#define PyObject_GET_WEAKREFS_LISTPTR(o) \
- ((PyObject **) (((char *) (o)) + Py_TYPE(o)->tp_weaklistoffset))
-
-#ifdef __cplusplus
-}
-#endif
-#endif /* !Py_OBJIMPL_H */
diff --git a/pythonsdk/include/odictobject.h b/pythonsdk/include/odictobject.h
deleted file mode 100644
index 8edbf22cffa26896d82e70f738a8cacfa36de2ff..0000000000000000000000000000000000000000
--- a/pythonsdk/include/odictobject.h
+++ /dev/null
@@ -1,43 +0,0 @@
-#ifndef Py_ODICTOBJECT_H
-#define Py_ODICTOBJECT_H
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-
-/* OrderedDict */
-/* This API is optional and mostly redundant. */
-
-#ifndef Py_LIMITED_API
-
-typedef struct _odictobject PyODictObject;
-
-PyAPI_DATA(PyTypeObject) PyODict_Type;
-PyAPI_DATA(PyTypeObject) PyODictIter_Type;
-PyAPI_DATA(PyTypeObject) PyODictKeys_Type;
-PyAPI_DATA(PyTypeObject) PyODictItems_Type;
-PyAPI_DATA(PyTypeObject) PyODictValues_Type;
-
-#define PyODict_Check(op) PyObject_TypeCheck(op, &PyODict_Type)
-#define PyODict_CheckExact(op) (Py_TYPE(op) == &PyODict_Type)
-#define PyODict_SIZE(op) PyDict_GET_SIZE((op))
-
-PyAPI_FUNC(PyObject *) PyODict_New(void);
-PyAPI_FUNC(int) PyODict_SetItem(PyObject *od, PyObject *key, PyObject *item);
-PyAPI_FUNC(int) PyODict_DelItem(PyObject *od, PyObject *key);
-
-/* wrappers around PyDict* functions */
-#define PyODict_GetItem(od, key) PyDict_GetItem((PyObject *)od, key)
-#define PyODict_GetItemWithError(od, key) \
- PyDict_GetItemWithError((PyObject *)od, key)
-#define PyODict_Contains(od, key) PyDict_Contains((PyObject *)od, key)
-#define PyODict_Size(od) PyDict_Size((PyObject *)od)
-#define PyODict_GetItemString(od, key) \
- PyDict_GetItemString((PyObject *)od, key)
-
-#endif
-
-#ifdef __cplusplus
-}
-#endif
-#endif /* !Py_ODICTOBJECT_H */
diff --git a/pythonsdk/include/opcode.h b/pythonsdk/include/opcode.h
deleted file mode 100644
index e1a706a1c426ccd04658eaf312cecd1f23a0b735..0000000000000000000000000000000000000000
--- a/pythonsdk/include/opcode.h
+++ /dev/null
@@ -1,147 +0,0 @@
-/* Auto-generated by Tools/scripts/generate_opcode_h.py */
-#ifndef Py_OPCODE_H
-#define Py_OPCODE_H
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-
- /* Instruction opcodes for compiled code */
-#define POP_TOP 1
-#define ROT_TWO 2
-#define ROT_THREE 3
-#define DUP_TOP 4
-#define DUP_TOP_TWO 5
-#define NOP 9
-#define UNARY_POSITIVE 10
-#define UNARY_NEGATIVE 11
-#define UNARY_NOT 12
-#define UNARY_INVERT 15
-#define BINARY_MATRIX_MULTIPLY 16
-#define INPLACE_MATRIX_MULTIPLY 17
-#define BINARY_POWER 19
-#define BINARY_MULTIPLY 20
-#define BINARY_MODULO 22
-#define BINARY_ADD 23
-#define BINARY_SUBTRACT 24
-#define BINARY_SUBSCR 25
-#define BINARY_FLOOR_DIVIDE 26
-#define BINARY_TRUE_DIVIDE 27
-#define INPLACE_FLOOR_DIVIDE 28
-#define INPLACE_TRUE_DIVIDE 29
-#define GET_AITER 50
-#define GET_ANEXT 51
-#define BEFORE_ASYNC_WITH 52
-#define INPLACE_ADD 55
-#define INPLACE_SUBTRACT 56
-#define INPLACE_MULTIPLY 57
-#define INPLACE_MODULO 59
-#define STORE_SUBSCR 60
-#define DELETE_SUBSCR 61
-#define BINARY_LSHIFT 62
-#define BINARY_RSHIFT 63
-#define BINARY_AND 64
-#define BINARY_XOR 65
-#define BINARY_OR 66
-#define INPLACE_POWER 67
-#define GET_ITER 68
-#define GET_YIELD_FROM_ITER 69
-#define PRINT_EXPR 70
-#define LOAD_BUILD_CLASS 71
-#define YIELD_FROM 72
-#define GET_AWAITABLE 73
-#define INPLACE_LSHIFT 75
-#define INPLACE_RSHIFT 76
-#define INPLACE_AND 77
-#define INPLACE_XOR 78
-#define INPLACE_OR 79
-#define BREAK_LOOP 80
-#define WITH_CLEANUP_START 81
-#define WITH_CLEANUP_FINISH 82
-#define RETURN_VALUE 83
-#define IMPORT_STAR 84
-#define SETUP_ANNOTATIONS 85
-#define YIELD_VALUE 86
-#define POP_BLOCK 87
-#define END_FINALLY 88
-#define POP_EXCEPT 89
-#define HAVE_ARGUMENT 90
-#define STORE_NAME 90
-#define DELETE_NAME 91
-#define UNPACK_SEQUENCE 92
-#define FOR_ITER 93
-#define UNPACK_EX 94
-#define STORE_ATTR 95
-#define DELETE_ATTR 96
-#define STORE_GLOBAL 97
-#define DELETE_GLOBAL 98
-#define LOAD_CONST 100
-#define LOAD_NAME 101
-#define BUILD_TUPLE 102
-#define BUILD_LIST 103
-#define BUILD_SET 104
-#define BUILD_MAP 105
-#define LOAD_ATTR 106
-#define COMPARE_OP 107
-#define IMPORT_NAME 108
-#define IMPORT_FROM 109
-#define JUMP_FORWARD 110
-#define JUMP_IF_FALSE_OR_POP 111
-#define JUMP_IF_TRUE_OR_POP 112
-#define JUMP_ABSOLUTE 113
-#define POP_JUMP_IF_FALSE 114
-#define POP_JUMP_IF_TRUE 115
-#define LOAD_GLOBAL 116
-#define CONTINUE_LOOP 119
-#define SETUP_LOOP 120
-#define SETUP_EXCEPT 121
-#define SETUP_FINALLY 122
-#define LOAD_FAST 124
-#define STORE_FAST 125
-#define DELETE_FAST 126
-#define RAISE_VARARGS 130
-#define CALL_FUNCTION 131
-#define MAKE_FUNCTION 132
-#define BUILD_SLICE 133
-#define LOAD_CLOSURE 135
-#define LOAD_DEREF 136
-#define STORE_DEREF 137
-#define DELETE_DEREF 138
-#define CALL_FUNCTION_KW 141
-#define CALL_FUNCTION_EX 142
-#define SETUP_WITH 143
-#define EXTENDED_ARG 144
-#define LIST_APPEND 145
-#define SET_ADD 146
-#define MAP_ADD 147
-#define LOAD_CLASSDEREF 148
-#define BUILD_LIST_UNPACK 149
-#define BUILD_MAP_UNPACK 150
-#define BUILD_MAP_UNPACK_WITH_CALL 151
-#define BUILD_TUPLE_UNPACK 152
-#define BUILD_SET_UNPACK 153
-#define SETUP_ASYNC_WITH 154
-#define FORMAT_VALUE 155
-#define BUILD_CONST_KEY_MAP 156
-#define BUILD_STRING 157
-#define BUILD_TUPLE_UNPACK_WITH_CALL 158
-#define LOAD_METHOD 160
-#define CALL_METHOD 161
-
-/* EXCEPT_HANDLER is a special, implicit block type which is created when
- entering an except handler. It is not an opcode but we define it here
- as we want it to be available to both frameobject.c and ceval.c, while
- remaining private.*/
-#define EXCEPT_HANDLER 257
-
-
-enum cmp_op {PyCmp_LT=Py_LT, PyCmp_LE=Py_LE, PyCmp_EQ=Py_EQ, PyCmp_NE=Py_NE,
- PyCmp_GT=Py_GT, PyCmp_GE=Py_GE, PyCmp_IN, PyCmp_NOT_IN,
- PyCmp_IS, PyCmp_IS_NOT, PyCmp_EXC_MATCH, PyCmp_BAD};
-
-#define HAS_ARG(op) ((op) >= HAVE_ARGUMENT)
-
-#ifdef __cplusplus
-}
-#endif
-#endif /* !Py_OPCODE_H */
diff --git a/pythonsdk/include/osdefs.h b/pythonsdk/include/osdefs.h
deleted file mode 100644
index b6a126449c0722ef04ba4559cf86eec5d4ee0b7a..0000000000000000000000000000000000000000
--- a/pythonsdk/include/osdefs.h
+++ /dev/null
@@ -1,47 +0,0 @@
-#ifndef Py_OSDEFS_H
-#define Py_OSDEFS_H
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-
-/* Operating system dependencies */
-
-#ifdef MS_WINDOWS
-#define SEP L'\\'
-#define ALTSEP L'/'
-#define MAXPATHLEN 256
-#define DELIM L';'
-#endif
-
-/* Filename separator */
-#ifndef SEP
-#define SEP L'/'
-#endif
-
-/* Max pathname length */
-#ifdef __hpux
-#include <sys/param.h>
-#include <limits.h>
-#ifndef PATH_MAX
-#define PATH_MAX MAXPATHLEN
-#endif
-#endif
-
-#ifndef MAXPATHLEN
-#if defined(PATH_MAX) && PATH_MAX > 1024
-#define MAXPATHLEN PATH_MAX
-#else
-#define MAXPATHLEN 1024
-#endif
-#endif
-
-/* Search path entry delimiter */
-#ifndef DELIM
-#define DELIM L':'
-#endif
-
-#ifdef __cplusplus
-}
-#endif
-#endif /* !Py_OSDEFS_H */
diff --git a/pythonsdk/include/osmodule.h b/pythonsdk/include/osmodule.h
deleted file mode 100644
index af50850296d6184d93bb7ae061740b9a000cb15c..0000000000000000000000000000000000000000
--- a/pythonsdk/include/osmodule.h
+++ /dev/null
@@ -1,17 +0,0 @@
-
-/* os module interface */
-
-#ifndef Py_OSMODULE_H
-#define Py_OSMODULE_H
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-#if !defined(Py_LIMITED_API) || Py_LIMITED_API+0 >= 0x03060000
-PyAPI_FUNC(PyObject *) PyOS_FSPath(PyObject *path);
-#endif
-
-#ifdef __cplusplus
-}
-#endif
-#endif /* !Py_OSMODULE_H */
diff --git a/pythonsdk/include/parsetok.h b/pythonsdk/include/parsetok.h
deleted file mode 100644
index f3837a9692cddfe21eb293d8889ced262586add9..0000000000000000000000000000000000000000
--- a/pythonsdk/include/parsetok.h
+++ /dev/null
@@ -1,108 +0,0 @@
-
-/* Parser-tokenizer link interface */
-#ifndef Py_LIMITED_API
-#ifndef Py_PARSETOK_H
-#define Py_PARSETOK_H
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-typedef struct {
- int error;
-#ifndef PGEN
- /* The filename is useless for pgen, see comment in tok_state structure */
- PyObject *filename;
-#endif
- int lineno;
- int offset;
- char *text; /* UTF-8-encoded string */
- int token;
- int expected;
-} perrdetail;
-
-#if 0
-#define PyPARSE_YIELD_IS_KEYWORD 0x0001
-#endif
-
-#define PyPARSE_DONT_IMPLY_DEDENT 0x0002
-
-#if 0
-#define PyPARSE_WITH_IS_KEYWORD 0x0003
-#define PyPARSE_PRINT_IS_FUNCTION 0x0004
-#define PyPARSE_UNICODE_LITERALS 0x0008
-#endif
-
-#define PyPARSE_IGNORE_COOKIE 0x0010
-#define PyPARSE_BARRY_AS_BDFL 0x0020
-
-PyAPI_FUNC(node *) PyParser_ParseString(const char *, grammar *, int,
- perrdetail *);
-PyAPI_FUNC(node *) PyParser_ParseFile (FILE *, const char *, grammar *, int,
- const char *, const char *,
- perrdetail *);
-
-PyAPI_FUNC(node *) PyParser_ParseStringFlags(const char *, grammar *, int,
- perrdetail *, int);
-PyAPI_FUNC(node *) PyParser_ParseFileFlags(
- FILE *fp,
- const char *filename, /* decoded from the filesystem encoding */
- const char *enc,
- grammar *g,
- int start,
- const char *ps1,
- const char *ps2,
- perrdetail *err_ret,
- int flags);
-PyAPI_FUNC(node *) PyParser_ParseFileFlagsEx(
- FILE *fp,
- const char *filename, /* decoded from the filesystem encoding */
- const char *enc,
- grammar *g,
- int start,
- const char *ps1,
- const char *ps2,
- perrdetail *err_ret,
- int *flags);
-PyAPI_FUNC(node *) PyParser_ParseFileObject(
- FILE *fp,
- PyObject *filename,
- const char *enc,
- grammar *g,
- int start,
- const char *ps1,
- const char *ps2,
- perrdetail *err_ret,
- int *flags);
-
-PyAPI_FUNC(node *) PyParser_ParseStringFlagsFilename(
- const char *s,
- const char *filename, /* decoded from the filesystem encoding */
- grammar *g,
- int start,
- perrdetail *err_ret,
- int flags);
-PyAPI_FUNC(node *) PyParser_ParseStringFlagsFilenameEx(
- const char *s,
- const char *filename, /* decoded from the filesystem encoding */
- grammar *g,
- int start,
- perrdetail *err_ret,
- int *flags);
-PyAPI_FUNC(node *) PyParser_ParseStringObject(
- const char *s,
- PyObject *filename,
- grammar *g,
- int start,
- perrdetail *err_ret,
- int *flags);
-
-/* Note that the following functions are defined in pythonrun.c,
- not in parsetok.c */
-PyAPI_FUNC(void) PyParser_SetError(perrdetail *);
-PyAPI_FUNC(void) PyParser_ClearError(perrdetail *);
-
-#ifdef __cplusplus
-}
-#endif
-#endif /* !Py_PARSETOK_H */
-#endif /* !Py_LIMITED_API */
diff --git a/pythonsdk/include/patchlevel.h b/pythonsdk/include/patchlevel.h
deleted file mode 100644
index c45ba7c64241ace081d8d05b59b0a60572c29d1b..0000000000000000000000000000000000000000
--- a/pythonsdk/include/patchlevel.h
+++ /dev/null
@@ -1,35 +0,0 @@
-
-/* Python version identification scheme.
-
- When the major or minor version changes, the VERSION variable in
- configure.ac must also be changed.
-
- There is also (independent) API version information in modsupport.h.
-*/
-
-/* Values for PY_RELEASE_LEVEL */
-#define PY_RELEASE_LEVEL_ALPHA 0xA
-#define PY_RELEASE_LEVEL_BETA 0xB
-#define PY_RELEASE_LEVEL_GAMMA 0xC /* For release candidates */
-#define PY_RELEASE_LEVEL_FINAL 0xF /* Serial should be 0 here */
- /* Higher for patch releases */
-
-/* Version parsed out into numeric values */
-/*--start constants--*/
-#define PY_MAJOR_VERSION 3
-#define PY_MINOR_VERSION 7
-#define PY_MICRO_VERSION 9
-#define PY_RELEASE_LEVEL PY_RELEASE_LEVEL_FINAL
-#define PY_RELEASE_SERIAL 0
-
-/* Version as a string */
-#define PY_VERSION "3.7.9"
-/*--end constants--*/
-
-/* Version as a single 4-byte hex number, e.g. 0x010502B2 == 1.5.2b2.
- Use this for numeric comparisons, e.g. #if PY_VERSION_HEX >= ... */
-#define PY_VERSION_HEX ((PY_MAJOR_VERSION << 24) | \
- (PY_MINOR_VERSION << 16) | \
- (PY_MICRO_VERSION << 8) | \
- (PY_RELEASE_LEVEL << 4) | \
- (PY_RELEASE_SERIAL << 0))
diff --git a/pythonsdk/include/pgen.h b/pythonsdk/include/pgen.h
deleted file mode 100644
index af84852b39572cde449d4b285243d54489ed25e0..0000000000000000000000000000000000000000
--- a/pythonsdk/include/pgen.h
+++ /dev/null
@@ -1,18 +0,0 @@
-#ifndef Py_PGEN_H
-#define Py_PGEN_H
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-
-/* Parser generator interface */
-
-extern grammar *meta_grammar(void);
-
-struct _node;
-extern grammar *pgen(struct _node *);
-
-#ifdef __cplusplus
-}
-#endif
-#endif /* !Py_PGEN_H */
diff --git a/pythonsdk/include/pgenheaders.h b/pythonsdk/include/pgenheaders.h
deleted file mode 100644
index 0997b0f3cb2883a21fb7faaa2605b0351d6bc608..0000000000000000000000000000000000000000
--- a/pythonsdk/include/pgenheaders.h
+++ /dev/null
@@ -1,43 +0,0 @@
-#ifndef Py_PGENHEADERS_H
-#define Py_PGENHEADERS_H
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-
-/* Include files and extern declarations used by most of the parser. */
-
-#include "Python.h"
-
-PyAPI_FUNC(void) PySys_WriteStdout(const char *format, ...)
- Py_GCC_ATTRIBUTE((format(printf, 1, 2)));
-PyAPI_FUNC(void) PySys_WriteStderr(const char *format, ...)
- Py_GCC_ATTRIBUTE((format(printf, 1, 2)));
-
-#define addarc _Py_addarc
-#define addbit _Py_addbit
-#define adddfa _Py_adddfa
-#define addfirstsets _Py_addfirstsets
-#define addlabel _Py_addlabel
-#define addstate _Py_addstate
-#define delbitset _Py_delbitset
-#define dumptree _Py_dumptree
-#define findlabel _Py_findlabel
-#define freegrammar _Py_freegrammar
-#define mergebitset _Py_mergebitset
-#define meta_grammar _Py_meta_grammar
-#define newbitset _Py_newbitset
-#define newgrammar _Py_newgrammar
-#define pgen _Py_pgen
-#define printgrammar _Py_printgrammar
-#define printnonterminals _Py_printnonterminals
-#define printtree _Py_printtree
-#define samebitset _Py_samebitset
-#define showtree _Py_showtree
-#define tok_dump _Py_tok_dump
-#define translatelabels _Py_translatelabels
-
-#ifdef __cplusplus
-}
-#endif
-#endif /* !Py_PGENHEADERS_H */
diff --git a/pythonsdk/include/py_curses.h b/pythonsdk/include/py_curses.h
deleted file mode 100644
index 1fdb6eac321fd4d51fb1661ed2b72f775fa88a97..0000000000000000000000000000000000000000
--- a/pythonsdk/include/py_curses.h
+++ /dev/null
@@ -1,159 +0,0 @@
-
-#ifndef Py_CURSES_H
-#define Py_CURSES_H
-
-#ifdef __APPLE__
-/*
-** On Mac OS X 10.2 [n]curses.h and stdlib.h use different guards
-** against multiple definition of wchar_t.
-*/
-#ifdef _BSD_WCHAR_T_DEFINED_
-#define _WCHAR_T
-#endif
-#endif /* __APPLE__ */
-
-/* On FreeBSD, [n]curses.h and stdlib.h/wchar.h use different guards
- against multiple definition of wchar_t and wint_t. */
-#if defined(__FreeBSD__) && defined(_XOPEN_SOURCE_EXTENDED)
-# ifndef __wchar_t
-# define __wchar_t
-# endif
-# ifndef __wint_t
-# define __wint_t
-# endif
-#endif
-
-#if !defined(HAVE_CURSES_IS_PAD) && defined(WINDOW_HAS_FLAGS)
-/* The following definition is necessary for ncurses 5.7; without it,
- some of [n]curses.h set NCURSES_OPAQUE to 1, and then Python
- can't get at the WINDOW flags field. */
-#define NCURSES_OPAQUE 0
-#endif
-
-#ifdef HAVE_NCURSES_H
-#include <ncurses.h>
-#else
-#include <curses.h>
-#endif
-
-#ifdef HAVE_NCURSES_H
-/* configure was checking <curses.h>, but we will
- use <ncurses.h>, which has some or all these features. */
-#if !defined(WINDOW_HAS_FLAGS) && !(NCURSES_OPAQUE+0)
-#define WINDOW_HAS_FLAGS 1
-#endif
-#if !defined(HAVE_CURSES_IS_PAD) && NCURSES_VERSION_PATCH+0 >= 20090906
-#define HAVE_CURSES_IS_PAD 1
-#endif
-#ifndef MVWDELCH_IS_EXPRESSION
-#define MVWDELCH_IS_EXPRESSION 1
-#endif
-#endif
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-#define PyCurses_API_pointers 4
-
-/* Type declarations */
-
-typedef struct {
- PyObject_HEAD
- WINDOW *win;
- char *encoding;
-} PyCursesWindowObject;
-
-#define PyCursesWindow_Check(v) (Py_TYPE(v) == &PyCursesWindow_Type)
-
-#define PyCurses_CAPSULE_NAME "_curses._C_API"
-
-
-#ifdef CURSES_MODULE
-/* This section is used when compiling _cursesmodule.c */
-
-#else
-/* This section is used in modules that use the _cursesmodule API */
-
-static void **PyCurses_API;
-
-#define PyCursesWindow_Type (*(PyTypeObject *) PyCurses_API[0])
-#define PyCursesSetupTermCalled {if (! ((int (*)(void))PyCurses_API[1]) () ) return NULL;}
-#define PyCursesInitialised {if (! ((int (*)(void))PyCurses_API[2]) () ) return NULL;}
-#define PyCursesInitialisedColor {if (! ((int (*)(void))PyCurses_API[3]) () ) return NULL;}
-
-#define import_curses() \
- PyCurses_API = (void **)PyCapsule_Import(PyCurses_CAPSULE_NAME, 1);
-
-#endif
-
-/* general error messages */
-static const char catchall_ERR[] = "curses function returned ERR";
-static const char catchall_NULL[] = "curses function returned NULL";
-
-/* Function Prototype Macros - They are ugly but very, very useful. ;-)
-
- X - function name
- TYPE - parameter Type
- ERGSTR - format string for construction of the return value
- PARSESTR - format string for argument parsing
- */
-
-#define NoArgNoReturnFunction(X) \
-static PyObject *PyCurses_ ## X (PyObject *self) \
-{ \
- PyCursesInitialised \
- return PyCursesCheckERR(X(), # X); }
-
-#define NoArgOrFlagNoReturnFunction(X) \
-static PyObject *PyCurses_ ## X (PyObject *self, PyObject *args) \
-{ \
- int flag = 0; \
- PyCursesInitialised \
- switch(PyTuple_Size(args)) { \
- case 0: \
- return PyCursesCheckERR(X(), # X); \
- case 1: \
- if (!PyArg_ParseTuple(args, "i;True(1) or False(0)", &flag)) return NULL; \
- if (flag) return PyCursesCheckERR(X(), # X); \
- else return PyCursesCheckERR(no ## X (), # X); \
- default: \
- PyErr_SetString(PyExc_TypeError, # X " requires 0 or 1 arguments"); \
- return NULL; } }
-
-#define NoArgReturnIntFunction(X) \
-static PyObject *PyCurses_ ## X (PyObject *self) \
-{ \
- PyCursesInitialised \
- return PyLong_FromLong((long) X()); }
-
-
-#define NoArgReturnStringFunction(X) \
-static PyObject *PyCurses_ ## X (PyObject *self) \
-{ \
- PyCursesInitialised \
- return PyBytes_FromString(X()); }
-
-#define NoArgTrueFalseFunction(X) \
-static PyObject *PyCurses_ ## X (PyObject *self) \
-{ \
- PyCursesInitialised \
- if (X () == FALSE) { \
- Py_RETURN_FALSE; \
- } \
- Py_RETURN_TRUE; }
-
-#define NoArgNoReturnVoidFunction(X) \
-static PyObject *PyCurses_ ## X (PyObject *self) \
-{ \
- PyCursesInitialised \
- X(); \
- Py_RETURN_NONE; }
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif /* !defined(Py_CURSES_H) */
-
-
diff --git a/pythonsdk/include/pyarena.h b/pythonsdk/include/pyarena.h
deleted file mode 100644
index 97791bec8d1b8776a104304971b29c861e20a64e..0000000000000000000000000000000000000000
--- a/pythonsdk/include/pyarena.h
+++ /dev/null
@@ -1,64 +0,0 @@
-/* An arena-like memory interface for the compiler.
- */
-
-#ifndef Py_LIMITED_API
-#ifndef Py_PYARENA_H
-#define Py_PYARENA_H
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
- typedef struct _arena PyArena;
-
- /* PyArena_New() and PyArena_Free() create a new arena and free it,
- respectively. Once an arena has been created, it can be used
- to allocate memory via PyArena_Malloc(). Pointers to PyObject can
- also be registered with the arena via PyArena_AddPyObject(), and the
- arena will ensure that the PyObjects stay alive at least until
- PyArena_Free() is called. When an arena is freed, all the memory it
- allocated is freed, the arena releases internal references to registered
- PyObject*, and none of its pointers are valid.
- XXX (tim) What does "none of its pointers are valid" mean? Does it
- XXX mean that pointers previously obtained via PyArena_Malloc() are
- XXX no longer valid? (That's clearly true, but not sure that's what
- XXX the text is trying to say.)
-
- PyArena_New() returns an arena pointer. On error, it
- returns a negative number and sets an exception.
- XXX (tim): Not true. On error, PyArena_New() actually returns NULL,
- XXX and looks like it may or may not set an exception (e.g., if the
- XXX internal PyList_New(0) returns NULL, PyArena_New() passes that on
- XXX and an exception is set; OTOH, if the internal
- XXX block_new(DEFAULT_BLOCK_SIZE) returns NULL, that's passed on but
- XXX an exception is not set in that case).
- */
- PyAPI_FUNC(PyArena *) PyArena_New(void);
- PyAPI_FUNC(void) PyArena_Free(PyArena *);
-
- /* Mostly like malloc(), return the address of a block of memory spanning
- * `size` bytes, or return NULL (without setting an exception) if enough
- * new memory can't be obtained. Unlike malloc(0), PyArena_Malloc() with
- * size=0 does not guarantee to return a unique pointer (the pointer
- * returned may equal one or more other pointers obtained from
- * PyArena_Malloc()).
- * Note that pointers obtained via PyArena_Malloc() must never be passed to
- * the system free() or realloc(), or to any of Python's similar memory-
- * management functions. PyArena_Malloc()-obtained pointers remain valid
- * until PyArena_Free(ar) is called, at which point all pointers obtained
- * from the arena `ar` become invalid simultaneously.
- */
- PyAPI_FUNC(void *) PyArena_Malloc(PyArena *, size_t size);
-
- /* This routine isn't a proper arena allocation routine. It takes
- * a PyObject* and records it so that it can be DECREFed when the
- * arena is freed.
- */
- PyAPI_FUNC(int) PyArena_AddPyObject(PyArena *, PyObject *);
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif /* !Py_PYARENA_H */
-#endif /* Py_LIMITED_API */
diff --git a/pythonsdk/include/pyatomic.h b/pythonsdk/include/pyatomic.h
deleted file mode 100644
index b90085271bc2697090f5cf853ac8e00ddcaec0e6..0000000000000000000000000000000000000000
--- a/pythonsdk/include/pyatomic.h
+++ /dev/null
@@ -1,535 +0,0 @@
-#ifndef Py_ATOMIC_H
-#define Py_ATOMIC_H
-#ifdef Py_BUILD_CORE
-
-#include "dynamic_annotations.h"
-
-#include "pyconfig.h"
-
-#if defined(HAVE_STD_ATOMIC)
-#include <stdatomic.h>
-#endif
-
-
-#if defined(_MSC_VER)
-#include <intrin.h>
-#include <immintrin.h>
-#endif
-
-/* This is modeled after the atomics interface from C1x, according to
- * the draft at
- * http://www.open-std.org/JTC1/SC22/wg14/www/docs/n1425.pdf.
- * Operations and types are named the same except with a _Py_ prefix
- * and have the same semantics.
- *
- * Beware, the implementations here are deep magic.
- */
-
-#if defined(HAVE_STD_ATOMIC)
-
-typedef enum _Py_memory_order {
- _Py_memory_order_relaxed = memory_order_relaxed,
- _Py_memory_order_acquire = memory_order_acquire,
- _Py_memory_order_release = memory_order_release,
- _Py_memory_order_acq_rel = memory_order_acq_rel,
- _Py_memory_order_seq_cst = memory_order_seq_cst
-} _Py_memory_order;
-
-typedef struct _Py_atomic_address {
- atomic_uintptr_t _value;
-} _Py_atomic_address;
-
-typedef struct _Py_atomic_int {
- atomic_int _value;
-} _Py_atomic_int;
-
-#define _Py_atomic_signal_fence(/*memory_order*/ ORDER) \
- atomic_signal_fence(ORDER)
-
-#define _Py_atomic_thread_fence(/*memory_order*/ ORDER) \
- atomic_thread_fence(ORDER)
-
-#define _Py_atomic_store_explicit(ATOMIC_VAL, NEW_VAL, ORDER) \
- atomic_store_explicit(&(ATOMIC_VAL)->_value, NEW_VAL, ORDER)
-
-#define _Py_atomic_load_explicit(ATOMIC_VAL, ORDER) \
- atomic_load_explicit(&(ATOMIC_VAL)->_value, ORDER)
-
-/* Use builtin atomic operations in GCC >= 4.7 */
-#elif defined(HAVE_BUILTIN_ATOMIC)
-
-typedef enum _Py_memory_order {
- _Py_memory_order_relaxed = __ATOMIC_RELAXED,
- _Py_memory_order_acquire = __ATOMIC_ACQUIRE,
- _Py_memory_order_release = __ATOMIC_RELEASE,
- _Py_memory_order_acq_rel = __ATOMIC_ACQ_REL,
- _Py_memory_order_seq_cst = __ATOMIC_SEQ_CST
-} _Py_memory_order;
-
-typedef struct _Py_atomic_address {
- uintptr_t _value;
-} _Py_atomic_address;
-
-typedef struct _Py_atomic_int {
- int _value;
-} _Py_atomic_int;
-
-#define _Py_atomic_signal_fence(/*memory_order*/ ORDER) \
- __atomic_signal_fence(ORDER)
-
-#define _Py_atomic_thread_fence(/*memory_order*/ ORDER) \
- __atomic_thread_fence(ORDER)
-
-#define _Py_atomic_store_explicit(ATOMIC_VAL, NEW_VAL, ORDER) \
- (assert((ORDER) == __ATOMIC_RELAXED \
- || (ORDER) == __ATOMIC_SEQ_CST \
- || (ORDER) == __ATOMIC_RELEASE), \
- __atomic_store_n(&(ATOMIC_VAL)->_value, NEW_VAL, ORDER))
-
-#define _Py_atomic_load_explicit(ATOMIC_VAL, ORDER) \
- (assert((ORDER) == __ATOMIC_RELAXED \
- || (ORDER) == __ATOMIC_SEQ_CST \
- || (ORDER) == __ATOMIC_ACQUIRE \
- || (ORDER) == __ATOMIC_CONSUME), \
- __atomic_load_n(&(ATOMIC_VAL)->_value, ORDER))
-
-/* Only support GCC (for expression statements) and x86 (for simple
- * atomic semantics) and MSVC x86/x64/ARM */
-#elif defined(__GNUC__) && (defined(__i386__) || defined(__amd64))
-typedef enum _Py_memory_order {
- _Py_memory_order_relaxed,
- _Py_memory_order_acquire,
- _Py_memory_order_release,
- _Py_memory_order_acq_rel,
- _Py_memory_order_seq_cst
-} _Py_memory_order;
-
-typedef struct _Py_atomic_address {
- uintptr_t _value;
-} _Py_atomic_address;
-
-typedef struct _Py_atomic_int {
- int _value;
-} _Py_atomic_int;
-
-
-static __inline__ void
-_Py_atomic_signal_fence(_Py_memory_order order)
-{
- if (order != _Py_memory_order_relaxed)
- __asm__ volatile("":::"memory");
-}
-
-static __inline__ void
-_Py_atomic_thread_fence(_Py_memory_order order)
-{
- if (order != _Py_memory_order_relaxed)
- __asm__ volatile("mfence":::"memory");
-}
-
-/* Tell the race checker about this operation's effects. */
-static __inline__ void
-_Py_ANNOTATE_MEMORY_ORDER(const volatile void *address, _Py_memory_order order)
-{
- (void)address; /* shut up -Wunused-parameter */
- switch(order) {
- case _Py_memory_order_release:
- case _Py_memory_order_acq_rel:
- case _Py_memory_order_seq_cst:
- _Py_ANNOTATE_HAPPENS_BEFORE(address);
- break;
- case _Py_memory_order_relaxed:
- case _Py_memory_order_acquire:
- break;
- }
- switch(order) {
- case _Py_memory_order_acquire:
- case _Py_memory_order_acq_rel:
- case _Py_memory_order_seq_cst:
- _Py_ANNOTATE_HAPPENS_AFTER(address);
- break;
- case _Py_memory_order_relaxed:
- case _Py_memory_order_release:
- break;
- }
-}
-
-#define _Py_atomic_store_explicit(ATOMIC_VAL, NEW_VAL, ORDER) \
- __extension__ ({ \
- __typeof__(ATOMIC_VAL) atomic_val = ATOMIC_VAL; \
- __typeof__(atomic_val->_value) new_val = NEW_VAL;\
- volatile __typeof__(new_val) *volatile_data = &atomic_val->_value; \
- _Py_memory_order order = ORDER; \
- _Py_ANNOTATE_MEMORY_ORDER(atomic_val, order); \
- \
- /* Perform the operation. */ \
- _Py_ANNOTATE_IGNORE_WRITES_BEGIN(); \
- switch(order) { \
- case _Py_memory_order_release: \
- _Py_atomic_signal_fence(_Py_memory_order_release); \
- /* fallthrough */ \
- case _Py_memory_order_relaxed: \
- *volatile_data = new_val; \
- break; \
- \
- case _Py_memory_order_acquire: \
- case _Py_memory_order_acq_rel: \
- case _Py_memory_order_seq_cst: \
- __asm__ volatile("xchg %0, %1" \
- : "+r"(new_val) \
- : "m"(atomic_val->_value) \
- : "memory"); \
- break; \
- } \
- _Py_ANNOTATE_IGNORE_WRITES_END(); \
- })
-
-#define _Py_atomic_load_explicit(ATOMIC_VAL, ORDER) \
- __extension__ ({ \
- __typeof__(ATOMIC_VAL) atomic_val = ATOMIC_VAL; \
- __typeof__(atomic_val->_value) result; \
- volatile __typeof__(result) *volatile_data = &atomic_val->_value; \
- _Py_memory_order order = ORDER; \
- _Py_ANNOTATE_MEMORY_ORDER(atomic_val, order); \
- \
- /* Perform the operation. */ \
- _Py_ANNOTATE_IGNORE_READS_BEGIN(); \
- switch(order) { \
- case _Py_memory_order_release: \
- case _Py_memory_order_acq_rel: \
- case _Py_memory_order_seq_cst: \
- /* Loads on x86 are not releases by default, so need a */ \
- /* thread fence. */ \
- _Py_atomic_thread_fence(_Py_memory_order_release); \
- break; \
- default: \
- /* No fence */ \
- break; \
- } \
- result = *volatile_data; \
- switch(order) { \
- case _Py_memory_order_acquire: \
- case _Py_memory_order_acq_rel: \
- case _Py_memory_order_seq_cst: \
- /* Loads on x86 are automatically acquire operations so */ \
- /* can get by with just a compiler fence. */ \
- _Py_atomic_signal_fence(_Py_memory_order_acquire); \
- break; \
- default: \
- /* No fence */ \
- break; \
- } \
- _Py_ANNOTATE_IGNORE_READS_END(); \
- result; \
- })
-
-#elif defined(_MSC_VER)
-/* _Interlocked* functions provide a full memory barrier and are therefore
- enough for acq_rel and seq_cst. If the HLE variants aren't available
- in hardware they will fall back to a full memory barrier as well.
-
- This might affect performance but likely only in some very specific and
- hard to meassure scenario.
-*/
-#if defined(_M_IX86) || defined(_M_X64)
-typedef enum _Py_memory_order {
- _Py_memory_order_relaxed,
- _Py_memory_order_acquire,
- _Py_memory_order_release,
- _Py_memory_order_acq_rel,
- _Py_memory_order_seq_cst
-} _Py_memory_order;
-
-typedef struct _Py_atomic_address {
- volatile uintptr_t _value;
-} _Py_atomic_address;
-
-typedef struct _Py_atomic_int {
- volatile int _value;
-} _Py_atomic_int;
-
-
-#if defined(_M_X64)
-#define _Py_atomic_store_64bit(ATOMIC_VAL, NEW_VAL, ORDER) \
- switch (ORDER) { \
- case _Py_memory_order_acquire: \
- _InterlockedExchange64_HLEAcquire((__int64 volatile*)ATOMIC_VAL, (__int64)NEW_VAL); \
- break; \
- case _Py_memory_order_release: \
- _InterlockedExchange64_HLERelease((__int64 volatile*)ATOMIC_VAL, (__int64)NEW_VAL); \
- break; \
- default: \
- _InterlockedExchange64((__int64 volatile*)ATOMIC_VAL, (__int64)NEW_VAL); \
- break; \
- }
-#else
-#define _Py_atomic_store_64bit(ATOMIC_VAL, NEW_VAL, ORDER) ((void)0);
-#endif
-
-#define _Py_atomic_store_32bit(ATOMIC_VAL, NEW_VAL, ORDER) \
- switch (ORDER) { \
- case _Py_memory_order_acquire: \
- _InterlockedExchange_HLEAcquire((volatile long*)ATOMIC_VAL, (int)NEW_VAL); \
- break; \
- case _Py_memory_order_release: \
- _InterlockedExchange_HLERelease((volatile long*)ATOMIC_VAL, (int)NEW_VAL); \
- break; \
- default: \
- _InterlockedExchange((volatile long*)ATOMIC_VAL, (int)NEW_VAL); \
- break; \
- }
-
-#if defined(_M_X64)
-/* This has to be an intptr_t for now.
- gil_created() uses -1 as a sentinel value, if this returns
- a uintptr_t it will do an unsigned compare and crash
-*/
-inline intptr_t _Py_atomic_load_64bit(volatile uintptr_t* value, int order) {
- __int64 old;
- switch (order) {
- case _Py_memory_order_acquire:
- {
- do {
- old = *value;
- } while(_InterlockedCompareExchange64_HLEAcquire((volatile __int64*)value, old, old) != old);
- break;
- }
- case _Py_memory_order_release:
- {
- do {
- old = *value;
- } while(_InterlockedCompareExchange64_HLERelease((volatile __int64*)value, old, old) != old);
- break;
- }
- case _Py_memory_order_relaxed:
- old = *value;
- break;
- default:
- {
- do {
- old = *value;
- } while(_InterlockedCompareExchange64((volatile __int64*)value, old, old) != old);
- break;
- }
- }
- return old;
-}
-
-#else
-#define _Py_atomic_load_64bit(ATOMIC_VAL, ORDER) *ATOMIC_VAL
-#endif
-
-inline int _Py_atomic_load_32bit(volatile int* value, int order) {
- long old;
- switch (order) {
- case _Py_memory_order_acquire:
- {
- do {
- old = *value;
- } while(_InterlockedCompareExchange_HLEAcquire((volatile long*)value, old, old) != old);
- break;
- }
- case _Py_memory_order_release:
- {
- do {
- old = *value;
- } while(_InterlockedCompareExchange_HLERelease((volatile long*)value, old, old) != old);
- break;
- }
- case _Py_memory_order_relaxed:
- old = *value;
- break;
- default:
- {
- do {
- old = *value;
- } while(_InterlockedCompareExchange((volatile long*)value, old, old) != old);
- break;
- }
- }
- return old;
-}
-
-#define _Py_atomic_store_explicit(ATOMIC_VAL, NEW_VAL, ORDER) \
- if (sizeof(*ATOMIC_VAL._value) == 8) { \
- _Py_atomic_store_64bit((volatile long long*)ATOMIC_VAL._value, NEW_VAL, ORDER) } else { \
- _Py_atomic_store_32bit((volatile long*)ATOMIC_VAL._value, NEW_VAL, ORDER) }
-
-#define _Py_atomic_load_explicit(ATOMIC_VAL, ORDER) \
- ( \
- sizeof(*(ATOMIC_VAL._value)) == 8 ? \
- _Py_atomic_load_64bit((volatile long long*)ATOMIC_VAL._value, ORDER) : \
- _Py_atomic_load_32bit((volatile long*)ATOMIC_VAL._value, ORDER) \
- )
-#elif defined(_M_ARM) || defined(_M_ARM64)
-typedef enum _Py_memory_order {
- _Py_memory_order_relaxed,
- _Py_memory_order_acquire,
- _Py_memory_order_release,
- _Py_memory_order_acq_rel,
- _Py_memory_order_seq_cst
-} _Py_memory_order;
-
-typedef struct _Py_atomic_address {
- volatile uintptr_t _value;
-} _Py_atomic_address;
-
-typedef struct _Py_atomic_int {
- volatile int _value;
-} _Py_atomic_int;
-
-
-#if defined(_M_ARM64)
-#define _Py_atomic_store_64bit(ATOMIC_VAL, NEW_VAL, ORDER) \
- switch (ORDER) { \
- case _Py_memory_order_acquire: \
- _InterlockedExchange64_acq((__int64 volatile*)ATOMIC_VAL, (__int64)NEW_VAL); \
- break; \
- case _Py_memory_order_release: \
- _InterlockedExchange64_rel((__int64 volatile*)ATOMIC_VAL, (__int64)NEW_VAL); \
- break; \
- default: \
- _InterlockedExchange64((__int64 volatile*)ATOMIC_VAL, (__int64)NEW_VAL); \
- break; \
- }
-#else
-#define _Py_atomic_store_64bit(ATOMIC_VAL, NEW_VAL, ORDER) ((void)0);
-#endif
-
-#define _Py_atomic_store_32bit(ATOMIC_VAL, NEW_VAL, ORDER) \
- switch (ORDER) { \
- case _Py_memory_order_acquire: \
- _InterlockedExchange_acq((volatile long*)ATOMIC_VAL, (int)NEW_VAL); \
- break; \
- case _Py_memory_order_release: \
- _InterlockedExchange_rel((volatile long*)ATOMIC_VAL, (int)NEW_VAL); \
- break; \
- default: \
- _InterlockedExchange((volatile long*)ATOMIC_VAL, (int)NEW_VAL); \
- break; \
- }
-
-#if defined(_M_ARM64)
-/* This has to be an intptr_t for now.
- gil_created() uses -1 as a sentinel value, if this returns
- a uintptr_t it will do an unsigned compare and crash
-*/
-inline intptr_t _Py_atomic_load_64bit(volatile uintptr_t* value, int order) {
- uintptr_t old;
- switch (order) {
- case _Py_memory_order_acquire:
- {
- do {
- old = *value;
- } while(_InterlockedCompareExchange64_acq(value, old, old) != old);
- break;
- }
- case _Py_memory_order_release:
- {
- do {
- old = *value;
- } while(_InterlockedCompareExchange64_rel(value, old, old) != old);
- break;
- }
- case _Py_memory_order_relaxed:
- old = *value;
- break;
- default:
- {
- do {
- old = *value;
- } while(_InterlockedCompareExchange64(value, old, old) != old);
- break;
- }
- }
- return old;
-}
-
-#else
-#define _Py_atomic_load_64bit(ATOMIC_VAL, ORDER) *ATOMIC_VAL
-#endif
-
-inline int _Py_atomic_load_32bit(volatile int* value, int order) {
- int old;
- switch (order) {
- case _Py_memory_order_acquire:
- {
- do {
- old = *value;
- } while(_InterlockedCompareExchange_acq(value, old, old) != old);
- break;
- }
- case _Py_memory_order_release:
- {
- do {
- old = *value;
- } while(_InterlockedCompareExchange_rel(value, old, old) != old);
- break;
- }
- case _Py_memory_order_relaxed:
- old = *value;
- break;
- default:
- {
- do {
- old = *value;
- } while(_InterlockedCompareExchange(value, old, old) != old);
- break;
- }
- }
- return old;
-}
-
-#define _Py_atomic_store_explicit(ATOMIC_VAL, NEW_VAL, ORDER) \
- if (sizeof(*ATOMIC_VAL._value) == 8) { \
- _Py_atomic_store_64bit(ATOMIC_VAL._value, NEW_VAL, ORDER) } else { \
- _Py_atomic_store_32bit(ATOMIC_VAL._value, NEW_VAL, ORDER) }
-
-#define _Py_atomic_load_explicit(ATOMIC_VAL, ORDER) \
- ( \
- sizeof(*(ATOMIC_VAL._value)) == 8 ? \
- _Py_atomic_load_64bit(ATOMIC_VAL._value, ORDER) : \
- _Py_atomic_load_32bit(ATOMIC_VAL._value, ORDER) \
- )
-#endif
-#else /* !gcc x86 !_msc_ver */
-typedef enum _Py_memory_order {
- _Py_memory_order_relaxed,
- _Py_memory_order_acquire,
- _Py_memory_order_release,
- _Py_memory_order_acq_rel,
- _Py_memory_order_seq_cst
-} _Py_memory_order;
-
-typedef struct _Py_atomic_address {
- uintptr_t _value;
-} _Py_atomic_address;
-
-typedef struct _Py_atomic_int {
- int _value;
-} _Py_atomic_int;
-/* Fall back to other compilers and processors by assuming that simple
- volatile accesses are atomic. This is false, so people should port
- this. */
-#define _Py_atomic_signal_fence(/*memory_order*/ ORDER) ((void)0)
-#define _Py_atomic_thread_fence(/*memory_order*/ ORDER) ((void)0)
-#define _Py_atomic_store_explicit(ATOMIC_VAL, NEW_VAL, ORDER) \
- ((ATOMIC_VAL)->_value = NEW_VAL)
-#define _Py_atomic_load_explicit(ATOMIC_VAL, ORDER) \
- ((ATOMIC_VAL)->_value)
-#endif
-
-/* Standardized shortcuts. */
-#define _Py_atomic_store(ATOMIC_VAL, NEW_VAL) \
- _Py_atomic_store_explicit(ATOMIC_VAL, NEW_VAL, _Py_memory_order_seq_cst)
-#define _Py_atomic_load(ATOMIC_VAL) \
- _Py_atomic_load_explicit(ATOMIC_VAL, _Py_memory_order_seq_cst)
-
-/* Python-local extensions */
-
-#define _Py_atomic_store_relaxed(ATOMIC_VAL, NEW_VAL) \
- _Py_atomic_store_explicit(ATOMIC_VAL, NEW_VAL, _Py_memory_order_relaxed)
-#define _Py_atomic_load_relaxed(ATOMIC_VAL) \
- _Py_atomic_load_explicit(ATOMIC_VAL, _Py_memory_order_relaxed)
-#endif /* Py_BUILD_CORE */
-#endif /* Py_ATOMIC_H */
diff --git a/pythonsdk/include/pycapsule.h b/pythonsdk/include/pycapsule.h
deleted file mode 100644
index 358501e3e4601a4df8e09eb60efcccb540de1445..0000000000000000000000000000000000000000
--- a/pythonsdk/include/pycapsule.h
+++ /dev/null
@@ -1,59 +0,0 @@
-
-/* Capsule objects let you wrap a C "void *" pointer in a Python
- object. They're a way of passing data through the Python interpreter
- without creating your own custom type.
-
- Capsules are used for communication between extension modules.
- They provide a way for an extension module to export a C interface
- to other extension modules, so that extension modules can use the
- Python import mechanism to link to one another.
-
- For more information, please see "c-api/capsule.html" in the
- documentation.
-*/
-
-#ifndef Py_CAPSULE_H
-#define Py_CAPSULE_H
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-PyAPI_DATA(PyTypeObject) PyCapsule_Type;
-
-typedef void (*PyCapsule_Destructor)(PyObject *);
-
-#define PyCapsule_CheckExact(op) (Py_TYPE(op) == &PyCapsule_Type)
-
-
-PyAPI_FUNC(PyObject *) PyCapsule_New(
- void *pointer,
- const char *name,
- PyCapsule_Destructor destructor);
-
-PyAPI_FUNC(void *) PyCapsule_GetPointer(PyObject *capsule, const char *name);
-
-PyAPI_FUNC(PyCapsule_Destructor) PyCapsule_GetDestructor(PyObject *capsule);
-
-PyAPI_FUNC(const char *) PyCapsule_GetName(PyObject *capsule);
-
-PyAPI_FUNC(void *) PyCapsule_GetContext(PyObject *capsule);
-
-PyAPI_FUNC(int) PyCapsule_IsValid(PyObject *capsule, const char *name);
-
-PyAPI_FUNC(int) PyCapsule_SetPointer(PyObject *capsule, void *pointer);
-
-PyAPI_FUNC(int) PyCapsule_SetDestructor(PyObject *capsule, PyCapsule_Destructor destructor);
-
-PyAPI_FUNC(int) PyCapsule_SetName(PyObject *capsule, const char *name);
-
-PyAPI_FUNC(int) PyCapsule_SetContext(PyObject *capsule, void *context);
-
-PyAPI_FUNC(void *) PyCapsule_Import(
- const char *name, /* UTF-8 encoded string */
- int no_block);
-
-
-#ifdef __cplusplus
-}
-#endif
-#endif /* !Py_CAPSULE_H */
diff --git a/pythonsdk/include/pyconfig.h b/pythonsdk/include/pyconfig.h
deleted file mode 100644
index 5d579a20e71a3d347604610539f36b539f529d19..0000000000000000000000000000000000000000
--- a/pythonsdk/include/pyconfig.h
+++ /dev/null
@@ -1,684 +0,0 @@
-#ifndef Py_CONFIG_H
-#define Py_CONFIG_H
-
-/* pyconfig.h. NOT Generated automatically by configure.
-
-This is a manually maintained version used for the Watcom,
-Borland and Microsoft Visual C++ compilers. It is a
-standard part of the Python distribution.
-
-WINDOWS DEFINES:
-The code specific to Windows should be wrapped around one of
-the following #defines
-
-MS_WIN64 - Code specific to the MS Win64 API
-MS_WIN32 - Code specific to the MS Win32 (and Win64) API (obsolete, this covers all supported APIs)
-MS_WINDOWS - Code specific to Windows, but all versions.
-Py_ENABLE_SHARED - Code if the Python core is built as a DLL.
-
-Also note that neither "_M_IX86" or "_MSC_VER" should be used for
-any purpose other than "Windows Intel x86 specific" and "Microsoft
-compiler specific". Therefore, these should be very rare.
-
-
-NOTE: The following symbols are deprecated:
-NT, USE_DL_EXPORT, USE_DL_IMPORT, DL_EXPORT, DL_IMPORT
-MS_CORE_DLL.
-
-WIN32 is still required for the locale module.
-
-*/
-
-/* Deprecated USE_DL_EXPORT macro - please use Py_BUILD_CORE */
-#ifdef USE_DL_EXPORT
-# define Py_BUILD_CORE
-#endif /* USE_DL_EXPORT */
-
-/* Visual Studio 2005 introduces deprecation warnings for
- "insecure" and POSIX functions. The insecure functions should
- be replaced by *_s versions (according to Microsoft); the
- POSIX functions by _* versions (which, according to Microsoft,
- would be ISO C conforming). Neither renaming is feasible, so
- we just silence the warnings. */
-
-#ifndef _CRT_SECURE_NO_DEPRECATE
-#define _CRT_SECURE_NO_DEPRECATE 1
-#endif
-#ifndef _CRT_NONSTDC_NO_DEPRECATE
-#define _CRT_NONSTDC_NO_DEPRECATE 1
-#endif
-
-#define HAVE_IO_H
-#define HAVE_SYS_UTIME_H
-#define HAVE_TEMPNAM
-#define HAVE_TMPFILE
-#define HAVE_TMPNAM
-#define HAVE_CLOCK
-#define HAVE_STRERROR
-
-#include <io.h>
-
-#define HAVE_HYPOT
-#define HAVE_STRFTIME
-#define DONT_HAVE_SIG_ALARM
-#define DONT_HAVE_SIG_PAUSE
-#define LONG_BIT 32
-#define WORD_BIT 32
-
-#define MS_WIN32 /* only support win32 and greater. */
-#define MS_WINDOWS
-#ifndef PYTHONPATH
-# define PYTHONPATH L".\\DLLs;.\\lib"
-#endif
-#define NT_THREADS
-#define WITH_THREAD
-#ifndef NETSCAPE_PI
-#define USE_SOCKET
-#endif
-
-
-/* Compiler specific defines */
-
-/* ------------------------------------------------------------------------*/
-/* Microsoft C defines _MSC_VER */
-#ifdef _MSC_VER
-
-/* We want COMPILER to expand to a string containing _MSC_VER's *value*.
- * This is horridly tricky, because the stringization operator only works
- * on macro arguments, and doesn't evaluate macros passed *as* arguments.
- * Attempts simpler than the following appear doomed to produce "_MSC_VER"
- * literally in the string.
- */
-#define _Py_PASTE_VERSION(SUFFIX) \
- ("[MSC v." _Py_STRINGIZE(_MSC_VER) " " SUFFIX "]")
-/* e.g., this produces, after compile-time string catenation,
- * ("[MSC v.1200 32 bit (Intel)]")
- *
- * _Py_STRINGIZE(_MSC_VER) expands to
- * _Py_STRINGIZE1((_MSC_VER)) expands to
- * _Py_STRINGIZE2(_MSC_VER) but as this call is the result of token-pasting
- * it's scanned again for macros and so further expands to (under MSVC 6)
- * _Py_STRINGIZE2(1200) which then expands to
- * "1200"
- */
-#define _Py_STRINGIZE(X) _Py_STRINGIZE1((X))
-#define _Py_STRINGIZE1(X) _Py_STRINGIZE2 ## X
-#define _Py_STRINGIZE2(X) #X
-
-/* MSVC defines _WINxx to differentiate the windows platform types
-
- Note that for compatibility reasons _WIN32 is defined on Win32
- *and* on Win64. For the same reasons, in Python, MS_WIN32 is
- defined on Win32 *and* Win64. Win32 only code must therefore be
- guarded as follows:
- #if defined(MS_WIN32) && !defined(MS_WIN64)
-*/
-#ifdef _WIN64
-#define MS_WIN64
-#endif
-
-/* set the COMPILER */
-#ifdef MS_WIN64
-#if defined(_M_X64) || defined(_M_AMD64)
-#if defined(__INTEL_COMPILER)
-#define COMPILER ("[ICC v." _Py_STRINGIZE(__INTEL_COMPILER) " 64 bit (amd64) with MSC v." _Py_STRINGIZE(_MSC_VER) " CRT]")
-#else
-#define COMPILER _Py_PASTE_VERSION("64 bit (AMD64)")
-#endif /* __INTEL_COMPILER */
-#define PYD_PLATFORM_TAG "win_amd64"
-#else
-#define COMPILER _Py_PASTE_VERSION("64 bit (Unknown)")
-#endif
-#endif /* MS_WIN64 */
-
-/* set the version macros for the windows headers */
-/* Python 3.5+ requires Windows Vista or greater */
-#define Py_WINVER 0x0600 /* _WIN32_WINNT_VISTA */
-#define Py_NTDDI NTDDI_VISTA
-
-/* We only set these values when building Python - we don't want to force
- these values on extensions, as that will affect the prototypes and
- structures exposed in the Windows headers. Even when building Python, we
- allow a single source file to override this - they may need access to
- structures etc so it can optionally use new Windows features if it
- determines at runtime they are available.
-*/
-#if defined(Py_BUILD_CORE) || defined(Py_BUILD_CORE_BUILTIN) || defined(Py_BUILD_CORE_MODULE)
-#ifndef NTDDI_VERSION
-#define NTDDI_VERSION Py_NTDDI
-#endif
-#ifndef WINVER
-#define WINVER Py_WINVER
-#endif
-#ifndef _WIN32_WINNT
-#define _WIN32_WINNT Py_WINVER
-#endif
-#endif
-
-/* _W64 is not defined for VC6 or eVC4 */
-#ifndef _W64
-#define _W64
-#endif
-
-/* Define like size_t, omitting the "unsigned" */
-#ifdef MS_WIN64
-typedef __int64 ssize_t;
-#else
-typedef _W64 int ssize_t;
-#endif
-#define HAVE_SSIZE_T 1
-
-#if defined(MS_WIN32) && !defined(MS_WIN64)
-#if defined(_M_IX86)
-#if defined(__INTEL_COMPILER)
-#define COMPILER ("[ICC v." _Py_STRINGIZE(__INTEL_COMPILER) " 32 bit (Intel) with MSC v." _Py_STRINGIZE(_MSC_VER) " CRT]")
-#else
-#define COMPILER _Py_PASTE_VERSION("32 bit (Intel)")
-#endif /* __INTEL_COMPILER */
-#define PYD_PLATFORM_TAG "win32"
-#elif defined(_M_ARM)
-#define COMPILER _Py_PASTE_VERSION("32 bit (ARM)")
-#define PYD_PLATFORM_TAG "win_arm"
-#else
-#define COMPILER _Py_PASTE_VERSION("32 bit (Unknown)")
-#endif
-#endif /* MS_WIN32 && !MS_WIN64 */
-
-typedef int pid_t;
-
-#include <float.h>
-#define Py_IS_NAN _isnan
-#define Py_IS_INFINITY(X) (!_finite(X) && !_isnan(X))
-#define Py_IS_FINITE(X) _finite(X)
-#define copysign _copysign
-
-/* Side by Side assemblies supported in VS 2005 and VS 2008 but not 2010*/
-#if _MSC_VER >= 1400 && _MSC_VER < 1600
-#define HAVE_SXS 1
-#endif
-
-/* define some ANSI types that are not defined in earlier Win headers */
-#if _MSC_VER >= 1200
-/* This file only exists in VC 6.0 or higher */
-#include <basetsd.h>
-#endif
-
-#endif /* _MSC_VER */
-
-/* ------------------------------------------------------------------------*/
-/* egcs/gnu-win32 defines __GNUC__ and _WIN32 */
-#if defined(__GNUC__) && defined(_WIN32)
-/* XXX These defines are likely incomplete, but should be easy to fix.
- They should be complete enough to build extension modules. */
-/* Suggested by Rene Liebscher <R.Liebscher@gmx.de> to avoid a GCC 2.91.*
- bug that requires structure imports. More recent versions of the
- compiler don't exhibit this bug.
-*/
-#if (__GNUC__==2) && (__GNUC_MINOR__<=91)
-#warning "Please use an up-to-date version of gcc! (>2.91 recommended)"
-#endif
-
-#define COMPILER "[gcc]"
-#define PY_LONG_LONG long long
-#define PY_LLONG_MIN LLONG_MIN
-#define PY_LLONG_MAX LLONG_MAX
-#define PY_ULLONG_MAX ULLONG_MAX
-#endif /* GNUC */
-
-/* ------------------------------------------------------------------------*/
-/* lcc-win32 defines __LCC__ */
-#if defined(__LCC__)
-/* XXX These defines are likely incomplete, but should be easy to fix.
- They should be complete enough to build extension modules. */
-
-#define COMPILER "[lcc-win32]"
-typedef int pid_t;
-/* __declspec() is supported here too - do nothing to get the defaults */
-
-#endif /* LCC */
-
-/* ------------------------------------------------------------------------*/
-/* End of compilers - finish up */
-
-#ifndef NO_STDIO_H
-# include <stdio.h>
-#endif
-
-/* 64 bit ints are usually spelt __int64 unless compiler has overridden */
-#ifndef PY_LONG_LONG
-# define PY_LONG_LONG __int64
-# define PY_LLONG_MAX _I64_MAX
-# define PY_LLONG_MIN _I64_MIN
-# define PY_ULLONG_MAX _UI64_MAX
-#endif
-
-/* For Windows the Python core is in a DLL by default. Test
-Py_NO_ENABLE_SHARED to find out. Also support MS_NO_COREDLL for b/w compat */
-#if !defined(MS_NO_COREDLL) && !defined(Py_NO_ENABLE_SHARED)
-# define Py_ENABLE_SHARED 1 /* standard symbol for shared library */
-# define MS_COREDLL /* deprecated old symbol */
-#endif /* !MS_NO_COREDLL && ... */
-
-/* All windows compilers that use this header support __declspec */
-#define HAVE_DECLSPEC_DLL
-
-/* For an MSVC DLL, we can nominate the .lib files used by extensions */
-#ifdef MS_COREDLL
-# if !defined(Py_BUILD_CORE) && !defined(Py_BUILD_CORE_BUILTIN)
- /* not building the core - must be an ext */
-# if defined(_MSC_VER)
- /* So MSVC users need not specify the .lib
- file in their Makefile (other compilers are
- generally taken care of by distutils.) */
-# if defined(_DEBUG)
-# pragma comment(lib,"python37_d.lib")
-# elif defined(Py_LIMITED_API)
-# pragma comment(lib,"python3.lib")
-# else
-# pragma comment(lib,"python37.lib")
-# endif /* _DEBUG */
-# endif /* _MSC_VER */
-# endif /* Py_BUILD_CORE */
-#endif /* MS_COREDLL */
-
-#if defined(MS_WIN64)
-/* maintain "win32" sys.platform for backward compatibility of Python code,
- the Win64 API should be close enough to the Win32 API to make this
- preferable */
-# define PLATFORM "win32"
-# define SIZEOF_VOID_P 8
-# define SIZEOF_TIME_T 8
-# define SIZEOF_OFF_T 4
-# define SIZEOF_FPOS_T 8
-# define SIZEOF_HKEY 8
-# define SIZEOF_SIZE_T 8
-/* configure.ac defines HAVE_LARGEFILE_SUPPORT iff
- sizeof(off_t) > sizeof(long), and sizeof(PY_LONG_LONG) >= sizeof(off_t).
- On Win64 the second condition is not true, but if fpos_t replaces off_t
- then this is true. The uses of HAVE_LARGEFILE_SUPPORT imply that Win64
- should define this. */
-# define HAVE_LARGEFILE_SUPPORT
-#elif defined(MS_WIN32)
-# define PLATFORM "win32"
-# define HAVE_LARGEFILE_SUPPORT
-# define SIZEOF_VOID_P 4
-# define SIZEOF_OFF_T 4
-# define SIZEOF_FPOS_T 8
-# define SIZEOF_HKEY 4
-# define SIZEOF_SIZE_T 4
- /* MS VS2005 changes time_t to a 64-bit type on all platforms */
-# if defined(_MSC_VER) && _MSC_VER >= 1400
-# define SIZEOF_TIME_T 8
-# else
-# define SIZEOF_TIME_T 4
-# endif
-#endif
-
-#ifdef _DEBUG
-# define Py_DEBUG
-#endif
-
-
-#ifdef MS_WIN32
-
-#define SIZEOF_SHORT 2
-#define SIZEOF_INT 4
-#define SIZEOF_LONG 4
-#define SIZEOF_LONG_LONG 8
-#define SIZEOF_DOUBLE 8
-#define SIZEOF_FLOAT 4
-
-/* VC 7.1 has them and VC 6.0 does not. VC 6.0 has a version number of 1200.
- Microsoft eMbedded Visual C++ 4.0 has a version number of 1201 and doesn't
- define these.
- If some compiler does not provide them, modify the #if appropriately. */
-#if defined(_MSC_VER)
-#if _MSC_VER > 1300
-#define HAVE_UINTPTR_T 1
-#define HAVE_INTPTR_T 1
-#else
-/* VC6, VS 2002 and eVC4 don't support the C99 LL suffix for 64-bit integer literals */
-#define Py_LL(x) x##I64
-#endif /* _MSC_VER > 1300 */
-#endif /* _MSC_VER */
-
-#endif
-
-/* define signed and unsigned exact-width 32-bit and 64-bit types, used in the
- implementation of Python integers. */
-#define PY_UINT32_T uint32_t
-#define PY_UINT64_T uint64_t
-#define PY_INT32_T int32_t
-#define PY_INT64_T int64_t
-
-/* Fairly standard from here! */
-
-/* Define to 1 if you have the `copysign' function. */
-#define HAVE_COPYSIGN 1
-
-/* Define to 1 if you have the `round' function. */
-#if _MSC_VER >= 1800
-#define HAVE_ROUND 1
-#endif
-
-/* Define to 1 if you have the `isinf' macro. */
-#define HAVE_DECL_ISINF 1
-
-/* Define to 1 if you have the `isnan' function. */
-#define HAVE_DECL_ISNAN 1
-
-/* Define if on AIX 3.
- System headers sometimes define this.
- We just want to avoid a redefinition error message. */
-#ifndef _ALL_SOURCE
-/* #undef _ALL_SOURCE */
-#endif
-
-/* Define to empty if the keyword does not work. */
-/* #define const */
-
-/* Define to 1 if you have the <conio.h> header file. */
-#define HAVE_CONIO_H 1
-
-/* Define to 1 if you have the <direct.h> header file. */
-#define HAVE_DIRECT_H 1
-
-/* Define if you have dirent.h. */
-/* #define DIRENT 1 */
-
-/* Define to the type of elements in the array set by `getgroups'.
- Usually this is either `int' or `gid_t'. */
-/* #undef GETGROUPS_T */
-
-/* Define to `int' if <sys/types.h> doesn't define. */
-/* #undef gid_t */
-
-/* Define if your struct tm has tm_zone. */
-/* #undef HAVE_TM_ZONE */
-
-/* Define if you don't have tm_zone but do have the external array
- tzname. */
-#define HAVE_TZNAME
-
-/* Define to `int' if <sys/types.h> doesn't define. */
-/* #undef mode_t */
-
-/* Define if you don't have dirent.h, but have ndir.h. */
-/* #undef NDIR */
-
-/* Define to `long' if <sys/types.h> doesn't define. */
-/* #undef off_t */
-
-/* Define to `int' if <sys/types.h> doesn't define. */
-/* #undef pid_t */
-
-/* Define if the system does not provide POSIX.1 features except
- with this defined. */
-/* #undef _POSIX_1_SOURCE */
-
-/* Define if you need to in order for stat and other things to work. */
-/* #undef _POSIX_SOURCE */
-
-/* Define as the return type of signal handlers (int or void). */
-#define RETSIGTYPE void
-
-/* Define to `unsigned' if <sys/types.h> doesn't define. */
-/* #undef size_t */
-
-/* Define if you have the ANSI C header files. */
-#define STDC_HEADERS 1
-
-/* Define if you don't have dirent.h, but have sys/dir.h. */
-/* #undef SYSDIR */
-
-/* Define if you don't have dirent.h, but have sys/ndir.h. */
-/* #undef SYSNDIR */
-
-/* Define if you can safely include both <sys/time.h> and <time.h>. */
-/* #undef TIME_WITH_SYS_TIME */
-
-/* Define if your <sys/time.h> declares struct tm. */
-/* #define TM_IN_SYS_TIME 1 */
-
-/* Define to `int' if <sys/types.h> doesn't define. */
-/* #undef uid_t */
-
-/* Define if the closedir function returns void instead of int. */
-/* #undef VOID_CLOSEDIR */
-
-/* Define if getpgrp() must be called as getpgrp(0)
- and (consequently) setpgrp() as setpgrp(0, 0). */
-/* #undef GETPGRP_HAVE_ARGS */
-
-/* Define this if your time.h defines altzone */
-/* #define HAVE_ALTZONE */
-
-/* Define if you have the putenv function. */
-#define HAVE_PUTENV
-
-/* Define if your compiler supports function prototypes */
-#define HAVE_PROTOTYPES
-
-/* Define if you can safely include both <sys/select.h> and <sys/time.h>
- (which you can't on SCO ODT 3.0). */
-/* #undef SYS_SELECT_WITH_SYS_TIME */
-
-/* Define if you want build the _decimal module using a coroutine-local rather
- than a thread-local context */
-#define WITH_DECIMAL_CONTEXTVAR 1
-
-/* Define if you want documentation strings in extension modules */
-#define WITH_DOC_STRINGS 1
-
-/* Define if you want to compile in rudimentary thread support */
-/* #undef WITH_THREAD */
-
-/* Define if you want to use the GNU readline library */
-/* #define WITH_READLINE 1 */
-
-/* Use Python's own small-block memory-allocator. */
-#define WITH_PYMALLOC 1
-
-/* Define if you have clock. */
-/* #define HAVE_CLOCK */
-
-/* Define when any dynamic module loading is enabled */
-#define HAVE_DYNAMIC_LOADING
-
-/* Define if you have ftime. */
-#define HAVE_FTIME
-
-/* Define if you have getpeername. */
-#define HAVE_GETPEERNAME
-
-/* Define if you have getpgrp. */
-/* #undef HAVE_GETPGRP */
-
-/* Define if you have getpid. */
-#define HAVE_GETPID
-
-/* Define if you have gettimeofday. */
-/* #undef HAVE_GETTIMEOFDAY */
-
-/* Define if you have getwd. */
-/* #undef HAVE_GETWD */
-
-/* Define if you have lstat. */
-/* #undef HAVE_LSTAT */
-
-/* Define if you have the mktime function. */
-#define HAVE_MKTIME
-
-/* Define if you have nice. */
-/* #undef HAVE_NICE */
-
-/* Define if you have readlink. */
-/* #undef HAVE_READLINK */
-
-/* Define if you have setpgid. */
-/* #undef HAVE_SETPGID */
-
-/* Define if you have setpgrp. */
-/* #undef HAVE_SETPGRP */
-
-/* Define if you have setsid. */
-/* #undef HAVE_SETSID */
-
-/* Define if you have setvbuf. */
-#define HAVE_SETVBUF
-
-/* Define if you have siginterrupt. */
-/* #undef HAVE_SIGINTERRUPT */
-
-/* Define if you have symlink. */
-/* #undef HAVE_SYMLINK */
-
-/* Define if you have tcgetpgrp. */
-/* #undef HAVE_TCGETPGRP */
-
-/* Define if you have tcsetpgrp. */
-/* #undef HAVE_TCSETPGRP */
-
-/* Define if you have times. */
-/* #undef HAVE_TIMES */
-
-/* Define if you have uname. */
-/* #undef HAVE_UNAME */
-
-/* Define if you have waitpid. */
-/* #undef HAVE_WAITPID */
-
-/* Define to 1 if you have the `wcsftime' function. */
-#if defined(_MSC_VER) && _MSC_VER >= 1310
-#define HAVE_WCSFTIME 1
-#endif
-
-/* Define to 1 if you have the `wcscoll' function. */
-#define HAVE_WCSCOLL 1
-
-/* Define to 1 if you have the `wcsxfrm' function. */
-#define HAVE_WCSXFRM 1
-
-/* Define if the zlib library has inflateCopy */
-#define HAVE_ZLIB_COPY 1
-
-/* Define if you have the <dlfcn.h> header file. */
-/* #undef HAVE_DLFCN_H */
-
-/* Define to 1 if you have the <errno.h> header file. */
-#define HAVE_ERRNO_H 1
-
-/* Define if you have the <fcntl.h> header file. */
-#define HAVE_FCNTL_H 1
-
-/* Define to 1 if you have the <process.h> header file. */
-#define HAVE_PROCESS_H 1
-
-/* Define to 1 if you have the <signal.h> header file. */
-#define HAVE_SIGNAL_H 1
-
-/* Define if you have the <stdarg.h> prototypes. */
-#define HAVE_STDARG_PROTOTYPES
-
-/* Define if you have the <stddef.h> header file. */
-#define HAVE_STDDEF_H 1
-
-/* Define if you have the <sys/audioio.h> header file. */
-/* #undef HAVE_SYS_AUDIOIO_H */
-
-/* Define if you have the <sys/param.h> header file. */
-/* #define HAVE_SYS_PARAM_H 1 */
-
-/* Define if you have the <sys/select.h> header file. */
-/* #define HAVE_SYS_SELECT_H 1 */
-
-/* Define to 1 if you have the <sys/stat.h> header file. */
-#define HAVE_SYS_STAT_H 1
-
-/* Define if you have the <sys/time.h> header file. */
-/* #define HAVE_SYS_TIME_H 1 */
-
-/* Define if you have the <sys/times.h> header file. */
-/* #define HAVE_SYS_TIMES_H 1 */
-
-/* Define to 1 if you have the <sys/types.h> header file. */
-#define HAVE_SYS_TYPES_H 1
-
-/* Define if you have the <sys/un.h> header file. */
-/* #define HAVE_SYS_UN_H 1 */
-
-/* Define if you have the <sys/utime.h> header file. */
-/* #define HAVE_SYS_UTIME_H 1 */
-
-/* Define if you have the <sys/utsname.h> header file. */
-/* #define HAVE_SYS_UTSNAME_H 1 */
-
-/* Define if you have the <unistd.h> header file. */
-/* #define HAVE_UNISTD_H 1 */
-
-/* Define if you have the <utime.h> header file. */
-/* #define HAVE_UTIME_H 1 */
-
-/* Define if the compiler provides a wchar.h header file. */
-#define HAVE_WCHAR_H 1
-
-/* The size of `wchar_t', as computed by sizeof. */
-#define SIZEOF_WCHAR_T 2
-
-/* The size of `_Bool', as computed by sizeof. */
-#define SIZEOF__BOOL 1
-
-/* The size of `pid_t', as computed by sizeof. */
-#define SIZEOF_PID_T SIZEOF_INT
-
-/* Define if you have the dl library (-ldl). */
-/* #undef HAVE_LIBDL */
-
-/* Define if you have the mpc library (-lmpc). */
-/* #undef HAVE_LIBMPC */
-
-/* Define if you have the nsl library (-lnsl). */
-#define HAVE_LIBNSL 1
-
-/* Define if you have the seq library (-lseq). */
-/* #undef HAVE_LIBSEQ */
-
-/* Define if you have the socket library (-lsocket). */
-#define HAVE_LIBSOCKET 1
-
-/* Define if you have the sun library (-lsun). */
-/* #undef HAVE_LIBSUN */
-
-/* Define if you have the termcap library (-ltermcap). */
-/* #undef HAVE_LIBTERMCAP */
-
-/* Define if you have the termlib library (-ltermlib). */
-/* #undef HAVE_LIBTERMLIB */
-
-/* Define if you have the thread library (-lthread). */
-/* #undef HAVE_LIBTHREAD */
-
-/* WinSock does not use a bitmask in select, and uses
- socket handles greater than FD_SETSIZE */
-#define Py_SOCKET_FD_CAN_BE_GE_FD_SETSIZE
-
-/* Define if C doubles are 64-bit IEEE 754 binary format, stored with the
- least significant byte first */
-#define DOUBLE_IS_LITTLE_ENDIAN_IEEE754 1
-
-/* Define to 1 if you have the `erf' function. */
-#define HAVE_ERF 1
-
-/* Define to 1 if you have the `erfc' function. */
-#define HAVE_ERFC 1
-
-/* Define if you have the 'inet_pton' function. */
-#define HAVE_INET_PTON 1
-
-/* framework name */
-#define _PYTHONFRAMEWORK ""
-
-/* Define if libssl has X509_VERIFY_PARAM_set1_host and related function */
-#define HAVE_X509_VERIFY_PARAM_SET1_HOST 1
-
-#endif /* !Py_CONFIG_H */
diff --git a/pythonsdk/include/pyctype.h b/pythonsdk/include/pyctype.h
deleted file mode 100644
index ee22795a7006c45e853fa3a1edc4bf190db47f67..0000000000000000000000000000000000000000
--- a/pythonsdk/include/pyctype.h
+++ /dev/null
@@ -1,33 +0,0 @@
-#ifndef Py_LIMITED_API
-#ifndef PYCTYPE_H
-#define PYCTYPE_H
-
-#define PY_CTF_LOWER 0x01
-#define PY_CTF_UPPER 0x02
-#define PY_CTF_ALPHA (PY_CTF_LOWER|PY_CTF_UPPER)
-#define PY_CTF_DIGIT 0x04
-#define PY_CTF_ALNUM (PY_CTF_ALPHA|PY_CTF_DIGIT)
-#define PY_CTF_SPACE 0x08
-#define PY_CTF_XDIGIT 0x10
-
-PyAPI_DATA(const unsigned int) _Py_ctype_table[256];
-
-/* Unlike their C counterparts, the following macros are not meant to
- * handle an int with any of the values [EOF, 0-UCHAR_MAX]. The argument
- * must be a signed/unsigned char. */
-#define Py_ISLOWER(c) (_Py_ctype_table[Py_CHARMASK(c)] & PY_CTF_LOWER)
-#define Py_ISUPPER(c) (_Py_ctype_table[Py_CHARMASK(c)] & PY_CTF_UPPER)
-#define Py_ISALPHA(c) (_Py_ctype_table[Py_CHARMASK(c)] & PY_CTF_ALPHA)
-#define Py_ISDIGIT(c) (_Py_ctype_table[Py_CHARMASK(c)] & PY_CTF_DIGIT)
-#define Py_ISXDIGIT(c) (_Py_ctype_table[Py_CHARMASK(c)] & PY_CTF_XDIGIT)
-#define Py_ISALNUM(c) (_Py_ctype_table[Py_CHARMASK(c)] & PY_CTF_ALNUM)
-#define Py_ISSPACE(c) (_Py_ctype_table[Py_CHARMASK(c)] & PY_CTF_SPACE)
-
-PyAPI_DATA(const unsigned char) _Py_ctype_tolower[256];
-PyAPI_DATA(const unsigned char) _Py_ctype_toupper[256];
-
-#define Py_TOLOWER(c) (_Py_ctype_tolower[Py_CHARMASK(c)])
-#define Py_TOUPPER(c) (_Py_ctype_toupper[Py_CHARMASK(c)])
-
-#endif /* !PYCTYPE_H */
-#endif /* !Py_LIMITED_API */
diff --git a/pythonsdk/include/pydebug.h b/pythonsdk/include/pydebug.h
deleted file mode 100644
index c983d0a9a31ac07674f94f9a0bfa98f5b21e2ee7..0000000000000000000000000000000000000000
--- a/pythonsdk/include/pydebug.h
+++ /dev/null
@@ -1,40 +0,0 @@
-#ifndef Py_LIMITED_API
-#ifndef Py_PYDEBUG_H
-#define Py_PYDEBUG_H
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-/* These global variable are defined in pylifecycle.c */
-/* XXX (ncoghlan): move these declarations to pylifecycle.h? */
-PyAPI_DATA(int) Py_DebugFlag;
-PyAPI_DATA(int) Py_VerboseFlag;
-PyAPI_DATA(int) Py_QuietFlag;
-PyAPI_DATA(int) Py_InteractiveFlag;
-PyAPI_DATA(int) Py_InspectFlag;
-PyAPI_DATA(int) Py_OptimizeFlag;
-PyAPI_DATA(int) Py_NoSiteFlag;
-PyAPI_DATA(int) Py_BytesWarningFlag;
-PyAPI_DATA(int) Py_FrozenFlag;
-PyAPI_DATA(int) Py_IgnoreEnvironmentFlag;
-PyAPI_DATA(int) Py_DontWriteBytecodeFlag;
-PyAPI_DATA(int) Py_NoUserSiteDirectory;
-PyAPI_DATA(int) Py_UnbufferedStdioFlag;
-PyAPI_DATA(int) Py_HashRandomizationFlag;
-PyAPI_DATA(int) Py_IsolatedFlag;
-
-#ifdef MS_WINDOWS
-PyAPI_DATA(int) Py_LegacyWindowsFSEncodingFlag;
-PyAPI_DATA(int) Py_LegacyWindowsStdioFlag;
-#endif
-
-/* this is a wrapper around getenv() that pays attention to
- Py_IgnoreEnvironmentFlag. It should be used for getting variables like
- PYTHONPATH and PYTHONHOME from the environment */
-#define Py_GETENV(s) (Py_IgnoreEnvironmentFlag ? NULL : getenv(s))
-
-#ifdef __cplusplus
-}
-#endif
-#endif /* !Py_PYDEBUG_H */
-#endif /* Py_LIMITED_API */
diff --git a/pythonsdk/include/pydtrace.h b/pythonsdk/include/pydtrace.h
deleted file mode 100644
index 2c5b0e9c144ee840c093f887752a1a1aab4efd13..0000000000000000000000000000000000000000
--- a/pythonsdk/include/pydtrace.h
+++ /dev/null
@@ -1,57 +0,0 @@
-/* Static DTrace probes interface */
-
-#ifndef Py_DTRACE_H
-#define Py_DTRACE_H
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-#ifdef WITH_DTRACE
-
-#include "pydtrace_probes.h"
-
-/* pydtrace_probes.h, on systems with DTrace, is auto-generated to include
- `PyDTrace_{PROBE}` and `PyDTrace_{PROBE}_ENABLED()` macros for every probe
- defined in pydtrace_provider.d.
-
- Calling these functions must be guarded by a `PyDTrace_{PROBE}_ENABLED()`
- check to minimize performance impact when probing is off. For example:
-
- if (PyDTrace_FUNCTION_ENTRY_ENABLED())
- PyDTrace_FUNCTION_ENTRY(f);
-*/
-
-#else
-
-/* Without DTrace, compile to nothing. */
-
-static inline void PyDTrace_LINE(const char *arg0, const char *arg1, int arg2) {}
-static inline void PyDTrace_FUNCTION_ENTRY(const char *arg0, const char *arg1, int arg2) {}
-static inline void PyDTrace_FUNCTION_RETURN(const char *arg0, const char *arg1, int arg2) {}
-static inline void PyDTrace_GC_START(int arg0) {}
-static inline void PyDTrace_GC_DONE(Py_ssize_t arg0) {}
-static inline void PyDTrace_INSTANCE_NEW_START(int arg0) {}
-static inline void PyDTrace_INSTANCE_NEW_DONE(int arg0) {}
-static inline void PyDTrace_INSTANCE_DELETE_START(int arg0) {}
-static inline void PyDTrace_INSTANCE_DELETE_DONE(int arg0) {}
-static inline void PyDTrace_IMPORT_FIND_LOAD_START(const char *arg0) {}
-static inline void PyDTrace_IMPORT_FIND_LOAD_DONE(const char *arg0, int arg1) {}
-
-static inline int PyDTrace_LINE_ENABLED(void) { return 0; }
-static inline int PyDTrace_FUNCTION_ENTRY_ENABLED(void) { return 0; }
-static inline int PyDTrace_FUNCTION_RETURN_ENABLED(void) { return 0; }
-static inline int PyDTrace_GC_START_ENABLED(void) { return 0; }
-static inline int PyDTrace_GC_DONE_ENABLED(void) { return 0; }
-static inline int PyDTrace_INSTANCE_NEW_START_ENABLED(void) { return 0; }
-static inline int PyDTrace_INSTANCE_NEW_DONE_ENABLED(void) { return 0; }
-static inline int PyDTrace_INSTANCE_DELETE_START_ENABLED(void) { return 0; }
-static inline int PyDTrace_INSTANCE_DELETE_DONE_ENABLED(void) { return 0; }
-static inline int PyDTrace_IMPORT_FIND_LOAD_START_ENABLED(void) { return 0; }
-static inline int PyDTrace_IMPORT_FIND_LOAD_DONE_ENABLED(void) { return 0; }
-
-#endif /* !WITH_DTRACE */
-
-#ifdef __cplusplus
-}
-#endif
-#endif /* !Py_DTRACE_H */
diff --git a/pythonsdk/include/pyerrors.h b/pythonsdk/include/pyerrors.h
deleted file mode 100644
index 221b88927b46f1a45a4c0130c8573ade01bb5d60..0000000000000000000000000000000000000000
--- a/pythonsdk/include/pyerrors.h
+++ /dev/null
@@ -1,504 +0,0 @@
-#ifndef Py_ERRORS_H
-#define Py_ERRORS_H
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-/* Error objects */
-
-#ifndef Py_LIMITED_API
-/* PyException_HEAD defines the initial segment of every exception class. */
-#define PyException_HEAD PyObject_HEAD PyObject *dict;\
- PyObject *args; PyObject *traceback;\
- PyObject *context; PyObject *cause;\
- char suppress_context;
-
-typedef struct {
- PyException_HEAD
-} PyBaseExceptionObject;
-
-typedef struct {
- PyException_HEAD
- PyObject *msg;
- PyObject *filename;
- PyObject *lineno;
- PyObject *offset;
- PyObject *text;
- PyObject *print_file_and_line;
-} PySyntaxErrorObject;
-
-typedef struct {
- PyException_HEAD
- PyObject *msg;
- PyObject *name;
- PyObject *path;
-} PyImportErrorObject;
-
-typedef struct {
- PyException_HEAD
- PyObject *encoding;
- PyObject *object;
- Py_ssize_t start;
- Py_ssize_t end;
- PyObject *reason;
-} PyUnicodeErrorObject;
-
-typedef struct {
- PyException_HEAD
- PyObject *code;
-} PySystemExitObject;
-
-typedef struct {
- PyException_HEAD
- PyObject *myerrno;
- PyObject *strerror;
- PyObject *filename;
- PyObject *filename2;
-#ifdef MS_WINDOWS
- PyObject *winerror;
-#endif
- Py_ssize_t written; /* only for BlockingIOError, -1 otherwise */
-} PyOSErrorObject;
-
-typedef struct {
- PyException_HEAD
- PyObject *value;
-} PyStopIterationObject;
-
-/* Compatibility typedefs */
-typedef PyOSErrorObject PyEnvironmentErrorObject;
-#ifdef MS_WINDOWS
-typedef PyOSErrorObject PyWindowsErrorObject;
-#endif
-#endif /* !Py_LIMITED_API */
-
-/* Error handling definitions */
-
-PyAPI_FUNC(void) PyErr_SetNone(PyObject *);
-PyAPI_FUNC(void) PyErr_SetObject(PyObject *, PyObject *);
-#ifndef Py_LIMITED_API
-PyAPI_FUNC(void) _PyErr_SetKeyError(PyObject *);
-_PyErr_StackItem *_PyErr_GetTopmostException(PyThreadState *tstate);
-#endif
-PyAPI_FUNC(void) PyErr_SetString(
- PyObject *exception,
- const char *string /* decoded from utf-8 */
- );
-PyAPI_FUNC(PyObject *) PyErr_Occurred(void);
-PyAPI_FUNC(void) PyErr_Clear(void);
-PyAPI_FUNC(void) PyErr_Fetch(PyObject **, PyObject **, PyObject **);
-PyAPI_FUNC(void) PyErr_Restore(PyObject *, PyObject *, PyObject *);
-#if !defined(Py_LIMITED_API) || Py_LIMITED_API+0 >= 0x03030000
-PyAPI_FUNC(void) PyErr_GetExcInfo(PyObject **, PyObject **, PyObject **);
-PyAPI_FUNC(void) PyErr_SetExcInfo(PyObject *, PyObject *, PyObject *);
-#endif
-
-#if defined(__clang__) || \
- (defined(__GNUC__) && \
- ((__GNUC__ >= 3) || \
- (__GNUC__ == 2) && (__GNUC_MINOR__ >= 5)))
-#define _Py_NO_RETURN __attribute__((__noreturn__))
-#else
-#define _Py_NO_RETURN
-#endif
-
-/* Defined in Python/pylifecycle.c */
-PyAPI_FUNC(void) Py_FatalError(const char *message) _Py_NO_RETURN;
-
-#if defined(Py_DEBUG) || defined(Py_LIMITED_API)
-#define _PyErr_OCCURRED() PyErr_Occurred()
-#else
-#define _PyErr_OCCURRED() (PyThreadState_GET()->curexc_type)
-#endif
-
-/* Error testing and normalization */
-PyAPI_FUNC(int) PyErr_GivenExceptionMatches(PyObject *, PyObject *);
-PyAPI_FUNC(int) PyErr_ExceptionMatches(PyObject *);
-PyAPI_FUNC(void) PyErr_NormalizeException(PyObject**, PyObject**, PyObject**);
-
-/* Traceback manipulation (PEP 3134) */
-PyAPI_FUNC(int) PyException_SetTraceback(PyObject *, PyObject *);
-PyAPI_FUNC(PyObject *) PyException_GetTraceback(PyObject *);
-
-/* Cause manipulation (PEP 3134) */
-PyAPI_FUNC(PyObject *) PyException_GetCause(PyObject *);
-PyAPI_FUNC(void) PyException_SetCause(PyObject *, PyObject *);
-
-/* Context manipulation (PEP 3134) */
-PyAPI_FUNC(PyObject *) PyException_GetContext(PyObject *);
-PyAPI_FUNC(void) PyException_SetContext(PyObject *, PyObject *);
-#ifndef Py_LIMITED_API
-PyAPI_FUNC(void) _PyErr_ChainExceptions(PyObject *, PyObject *, PyObject *);
-#endif
-
-/* */
-
-#define PyExceptionClass_Check(x) \
- (PyType_Check((x)) && \
- PyType_FastSubclass((PyTypeObject*)(x), Py_TPFLAGS_BASE_EXC_SUBCLASS))
-
-#define PyExceptionInstance_Check(x) \
- PyType_FastSubclass((x)->ob_type, Py_TPFLAGS_BASE_EXC_SUBCLASS)
-
-#define PyExceptionClass_Name(x) \
- ((char *)(((PyTypeObject*)(x))->tp_name))
-
-#define PyExceptionInstance_Class(x) ((PyObject*)((x)->ob_type))
-
-
-/* Predefined exceptions */
-
-PyAPI_DATA(PyObject *) PyExc_BaseException;
-PyAPI_DATA(PyObject *) PyExc_Exception;
-#if !defined(Py_LIMITED_API) || Py_LIMITED_API+0 >= 0x03050000
-PyAPI_DATA(PyObject *) PyExc_StopAsyncIteration;
-#endif
-PyAPI_DATA(PyObject *) PyExc_StopIteration;
-PyAPI_DATA(PyObject *) PyExc_GeneratorExit;
-PyAPI_DATA(PyObject *) PyExc_ArithmeticError;
-PyAPI_DATA(PyObject *) PyExc_LookupError;
-
-PyAPI_DATA(PyObject *) PyExc_AssertionError;
-PyAPI_DATA(PyObject *) PyExc_AttributeError;
-PyAPI_DATA(PyObject *) PyExc_BufferError;
-PyAPI_DATA(PyObject *) PyExc_EOFError;
-PyAPI_DATA(PyObject *) PyExc_FloatingPointError;
-PyAPI_DATA(PyObject *) PyExc_OSError;
-PyAPI_DATA(PyObject *) PyExc_ImportError;
-#if !defined(Py_LIMITED_API) || Py_LIMITED_API+0 >= 0x03060000
-PyAPI_DATA(PyObject *) PyExc_ModuleNotFoundError;
-#endif
-PyAPI_DATA(PyObject *) PyExc_IndexError;
-PyAPI_DATA(PyObject *) PyExc_KeyError;
-PyAPI_DATA(PyObject *) PyExc_KeyboardInterrupt;
-PyAPI_DATA(PyObject *) PyExc_MemoryError;
-PyAPI_DATA(PyObject *) PyExc_NameError;
-PyAPI_DATA(PyObject *) PyExc_OverflowError;
-PyAPI_DATA(PyObject *) PyExc_RuntimeError;
-#if !defined(Py_LIMITED_API) || Py_LIMITED_API+0 >= 0x03050000
-PyAPI_DATA(PyObject *) PyExc_RecursionError;
-#endif
-PyAPI_DATA(PyObject *) PyExc_NotImplementedError;
-PyAPI_DATA(PyObject *) PyExc_SyntaxError;
-PyAPI_DATA(PyObject *) PyExc_IndentationError;
-PyAPI_DATA(PyObject *) PyExc_TabError;
-PyAPI_DATA(PyObject *) PyExc_ReferenceError;
-PyAPI_DATA(PyObject *) PyExc_SystemError;
-PyAPI_DATA(PyObject *) PyExc_SystemExit;
-PyAPI_DATA(PyObject *) PyExc_TypeError;
-PyAPI_DATA(PyObject *) PyExc_UnboundLocalError;
-PyAPI_DATA(PyObject *) PyExc_UnicodeError;
-PyAPI_DATA(PyObject *) PyExc_UnicodeEncodeError;
-PyAPI_DATA(PyObject *) PyExc_UnicodeDecodeError;
-PyAPI_DATA(PyObject *) PyExc_UnicodeTranslateError;
-PyAPI_DATA(PyObject *) PyExc_ValueError;
-PyAPI_DATA(PyObject *) PyExc_ZeroDivisionError;
-
-#if !defined(Py_LIMITED_API) || Py_LIMITED_API+0 >= 0x03030000
-PyAPI_DATA(PyObject *) PyExc_BlockingIOError;
-PyAPI_DATA(PyObject *) PyExc_BrokenPipeError;
-PyAPI_DATA(PyObject *) PyExc_ChildProcessError;
-PyAPI_DATA(PyObject *) PyExc_ConnectionError;
-PyAPI_DATA(PyObject *) PyExc_ConnectionAbortedError;
-PyAPI_DATA(PyObject *) PyExc_ConnectionRefusedError;
-PyAPI_DATA(PyObject *) PyExc_ConnectionResetError;
-PyAPI_DATA(PyObject *) PyExc_FileExistsError;
-PyAPI_DATA(PyObject *) PyExc_FileNotFoundError;
-PyAPI_DATA(PyObject *) PyExc_InterruptedError;
-PyAPI_DATA(PyObject *) PyExc_IsADirectoryError;
-PyAPI_DATA(PyObject *) PyExc_NotADirectoryError;
-PyAPI_DATA(PyObject *) PyExc_PermissionError;
-PyAPI_DATA(PyObject *) PyExc_ProcessLookupError;
-PyAPI_DATA(PyObject *) PyExc_TimeoutError;
-#endif
-
-
-/* Compatibility aliases */
-PyAPI_DATA(PyObject *) PyExc_EnvironmentError;
-PyAPI_DATA(PyObject *) PyExc_IOError;
-#ifdef MS_WINDOWS
-PyAPI_DATA(PyObject *) PyExc_WindowsError;
-#endif
-
-/* Predefined warning categories */
-PyAPI_DATA(PyObject *) PyExc_Warning;
-PyAPI_DATA(PyObject *) PyExc_UserWarning;
-PyAPI_DATA(PyObject *) PyExc_DeprecationWarning;
-PyAPI_DATA(PyObject *) PyExc_PendingDeprecationWarning;
-PyAPI_DATA(PyObject *) PyExc_SyntaxWarning;
-PyAPI_DATA(PyObject *) PyExc_RuntimeWarning;
-PyAPI_DATA(PyObject *) PyExc_FutureWarning;
-PyAPI_DATA(PyObject *) PyExc_ImportWarning;
-PyAPI_DATA(PyObject *) PyExc_UnicodeWarning;
-PyAPI_DATA(PyObject *) PyExc_BytesWarning;
-PyAPI_DATA(PyObject *) PyExc_ResourceWarning;
-
-
-/* Convenience functions */
-
-PyAPI_FUNC(int) PyErr_BadArgument(void);
-PyAPI_FUNC(PyObject *) PyErr_NoMemory(void);
-PyAPI_FUNC(PyObject *) PyErr_SetFromErrno(PyObject *);
-PyAPI_FUNC(PyObject *) PyErr_SetFromErrnoWithFilenameObject(
- PyObject *, PyObject *);
-#if !defined(Py_LIMITED_API) || Py_LIMITED_API+0 >= 0x03040000
-PyAPI_FUNC(PyObject *) PyErr_SetFromErrnoWithFilenameObjects(
- PyObject *, PyObject *, PyObject *);
-#endif
-PyAPI_FUNC(PyObject *) PyErr_SetFromErrnoWithFilename(
- PyObject *exc,
- const char *filename /* decoded from the filesystem encoding */
- );
-#if defined(MS_WINDOWS) && !defined(Py_LIMITED_API)
-PyAPI_FUNC(PyObject *) PyErr_SetFromErrnoWithUnicodeFilename(
- PyObject *, const Py_UNICODE *) Py_DEPRECATED(3.3);
-#endif /* MS_WINDOWS */
-
-PyAPI_FUNC(PyObject *) PyErr_Format(
- PyObject *exception,
- const char *format, /* ASCII-encoded string */
- ...
- );
-#if !defined(Py_LIMITED_API) || Py_LIMITED_API+0 >= 0x03050000
-PyAPI_FUNC(PyObject *) PyErr_FormatV(
- PyObject *exception,
- const char *format,
- va_list vargs);
-#endif
-
-#ifndef Py_LIMITED_API
-/* Like PyErr_Format(), but saves current exception as __context__ and
- __cause__.
- */
-PyAPI_FUNC(PyObject *) _PyErr_FormatFromCause(
- PyObject *exception,
- const char *format, /* ASCII-encoded string */
- ...
- );
-#endif
-
-#ifdef MS_WINDOWS
-PyAPI_FUNC(PyObject *) PyErr_SetFromWindowsErrWithFilename(
- int ierr,
- const char *filename /* decoded from the filesystem encoding */
- );
-#ifndef Py_LIMITED_API
-/* XXX redeclare to use WSTRING */
-PyAPI_FUNC(PyObject *) PyErr_SetFromWindowsErrWithUnicodeFilename(
- int, const Py_UNICODE *) Py_DEPRECATED(3.3);
-#endif
-PyAPI_FUNC(PyObject *) PyErr_SetFromWindowsErr(int);
-PyAPI_FUNC(PyObject *) PyErr_SetExcFromWindowsErrWithFilenameObject(
- PyObject *,int, PyObject *);
-#if !defined(Py_LIMITED_API) || Py_LIMITED_API+0 >= 0x03040000
-PyAPI_FUNC(PyObject *) PyErr_SetExcFromWindowsErrWithFilenameObjects(
- PyObject *,int, PyObject *, PyObject *);
-#endif
-PyAPI_FUNC(PyObject *) PyErr_SetExcFromWindowsErrWithFilename(
- PyObject *exc,
- int ierr,
- const char *filename /* decoded from the filesystem encoding */
- );
-#ifndef Py_LIMITED_API
-PyAPI_FUNC(PyObject *) PyErr_SetExcFromWindowsErrWithUnicodeFilename(
- PyObject *,int, const Py_UNICODE *) Py_DEPRECATED(3.3);
-#endif
-PyAPI_FUNC(PyObject *) PyErr_SetExcFromWindowsErr(PyObject *, int);
-#endif /* MS_WINDOWS */
-
-#if !defined(Py_LIMITED_API) || Py_LIMITED_API+0 >= 0x03060000
-PyAPI_FUNC(PyObject *) PyErr_SetImportErrorSubclass(PyObject *, PyObject *,
- PyObject *, PyObject *);
-#endif
-#if !defined(Py_LIMITED_API) || Py_LIMITED_API+0 >= 0x03030000
-PyAPI_FUNC(PyObject *) PyErr_SetImportError(PyObject *, PyObject *,
- PyObject *);
-#endif
-
-/* Export the old function so that the existing API remains available: */
-PyAPI_FUNC(void) PyErr_BadInternalCall(void);
-PyAPI_FUNC(void) _PyErr_BadInternalCall(const char *filename, int lineno);
-/* Mask the old API with a call to the new API for code compiled under
- Python 2.0: */
-#define PyErr_BadInternalCall() _PyErr_BadInternalCall(__FILE__, __LINE__)
-
-/* Function to create a new exception */
-PyAPI_FUNC(PyObject *) PyErr_NewException(
- const char *name, PyObject *base, PyObject *dict);
-PyAPI_FUNC(PyObject *) PyErr_NewExceptionWithDoc(
- const char *name, const char *doc, PyObject *base, PyObject *dict);
-PyAPI_FUNC(void) PyErr_WriteUnraisable(PyObject *);
-
-/* In exceptions.c */
-#ifndef Py_LIMITED_API
-/* Helper that attempts to replace the current exception with one of the
- * same type but with a prefix added to the exception text. The resulting
- * exception description looks like:
- *
- * prefix (exc_type: original_exc_str)
- *
- * Only some exceptions can be safely replaced. If the function determines
- * it isn't safe to perform the replacement, it will leave the original
- * unmodified exception in place.
- *
- * Returns a borrowed reference to the new exception (if any), NULL if the
- * existing exception was left in place.
- */
-PyAPI_FUNC(PyObject *) _PyErr_TrySetFromCause(
- const char *prefix_format, /* ASCII-encoded string */
- ...
- );
-#endif
-
-
-/* In signalmodule.c */
-PyAPI_FUNC(int) PyErr_CheckSignals(void);
-PyAPI_FUNC(void) PyErr_SetInterrupt(void);
-
-/* In signalmodule.c */
-#ifndef Py_LIMITED_API
-int PySignal_SetWakeupFd(int fd);
-#endif
-
-/* Support for adding program text to SyntaxErrors */
-PyAPI_FUNC(void) PyErr_SyntaxLocation(
- const char *filename, /* decoded from the filesystem encoding */
- int lineno);
-PyAPI_FUNC(void) PyErr_SyntaxLocationEx(
- const char *filename, /* decoded from the filesystem encoding */
- int lineno,
- int col_offset);
-#ifndef Py_LIMITED_API
-PyAPI_FUNC(void) PyErr_SyntaxLocationObject(
- PyObject *filename,
- int lineno,
- int col_offset);
-#endif
-PyAPI_FUNC(PyObject *) PyErr_ProgramText(
- const char *filename, /* decoded from the filesystem encoding */
- int lineno);
-#ifndef Py_LIMITED_API
-PyAPI_FUNC(PyObject *) PyErr_ProgramTextObject(
- PyObject *filename,
- int lineno);
-#endif
-
-/* The following functions are used to create and modify unicode
- exceptions from C */
-
-/* create a UnicodeDecodeError object */
-PyAPI_FUNC(PyObject *) PyUnicodeDecodeError_Create(
- const char *encoding, /* UTF-8 encoded string */
- const char *object,
- Py_ssize_t length,
- Py_ssize_t start,
- Py_ssize_t end,
- const char *reason /* UTF-8 encoded string */
- );
-
-/* create a UnicodeEncodeError object */
-#ifndef Py_LIMITED_API
-PyAPI_FUNC(PyObject *) PyUnicodeEncodeError_Create(
- const char *encoding, /* UTF-8 encoded string */
- const Py_UNICODE *object,
- Py_ssize_t length,
- Py_ssize_t start,
- Py_ssize_t end,
- const char *reason /* UTF-8 encoded string */
- ) Py_DEPRECATED(3.3);
-#endif
-
-/* create a UnicodeTranslateError object */
-#ifndef Py_LIMITED_API
-PyAPI_FUNC(PyObject *) PyUnicodeTranslateError_Create(
- const Py_UNICODE *object,
- Py_ssize_t length,
- Py_ssize_t start,
- Py_ssize_t end,
- const char *reason /* UTF-8 encoded string */
- ) Py_DEPRECATED(3.3);
-PyAPI_FUNC(PyObject *) _PyUnicodeTranslateError_Create(
- PyObject *object,
- Py_ssize_t start,
- Py_ssize_t end,
- const char *reason /* UTF-8 encoded string */
- );
-#endif
-
-/* get the encoding attribute */
-PyAPI_FUNC(PyObject *) PyUnicodeEncodeError_GetEncoding(PyObject *);
-PyAPI_FUNC(PyObject *) PyUnicodeDecodeError_GetEncoding(PyObject *);
-
-/* get the object attribute */
-PyAPI_FUNC(PyObject *) PyUnicodeEncodeError_GetObject(PyObject *);
-PyAPI_FUNC(PyObject *) PyUnicodeDecodeError_GetObject(PyObject *);
-PyAPI_FUNC(PyObject *) PyUnicodeTranslateError_GetObject(PyObject *);
-
-/* get the value of the start attribute (the int * may not be NULL)
- return 0 on success, -1 on failure */
-PyAPI_FUNC(int) PyUnicodeEncodeError_GetStart(PyObject *, Py_ssize_t *);
-PyAPI_FUNC(int) PyUnicodeDecodeError_GetStart(PyObject *, Py_ssize_t *);
-PyAPI_FUNC(int) PyUnicodeTranslateError_GetStart(PyObject *, Py_ssize_t *);
-
-/* assign a new value to the start attribute
- return 0 on success, -1 on failure */
-PyAPI_FUNC(int) PyUnicodeEncodeError_SetStart(PyObject *, Py_ssize_t);
-PyAPI_FUNC(int) PyUnicodeDecodeError_SetStart(PyObject *, Py_ssize_t);
-PyAPI_FUNC(int) PyUnicodeTranslateError_SetStart(PyObject *, Py_ssize_t);
-
-/* get the value of the end attribute (the int *may not be NULL)
- return 0 on success, -1 on failure */
-PyAPI_FUNC(int) PyUnicodeEncodeError_GetEnd(PyObject *, Py_ssize_t *);
-PyAPI_FUNC(int) PyUnicodeDecodeError_GetEnd(PyObject *, Py_ssize_t *);
-PyAPI_FUNC(int) PyUnicodeTranslateError_GetEnd(PyObject *, Py_ssize_t *);
-
-/* assign a new value to the end attribute
- return 0 on success, -1 on failure */
-PyAPI_FUNC(int) PyUnicodeEncodeError_SetEnd(PyObject *, Py_ssize_t);
-PyAPI_FUNC(int) PyUnicodeDecodeError_SetEnd(PyObject *, Py_ssize_t);
-PyAPI_FUNC(int) PyUnicodeTranslateError_SetEnd(PyObject *, Py_ssize_t);
-
-/* get the value of the reason attribute */
-PyAPI_FUNC(PyObject *) PyUnicodeEncodeError_GetReason(PyObject *);
-PyAPI_FUNC(PyObject *) PyUnicodeDecodeError_GetReason(PyObject *);
-PyAPI_FUNC(PyObject *) PyUnicodeTranslateError_GetReason(PyObject *);
-
-/* assign a new value to the reason attribute
- return 0 on success, -1 on failure */
-PyAPI_FUNC(int) PyUnicodeEncodeError_SetReason(
- PyObject *exc,
- const char *reason /* UTF-8 encoded string */
- );
-PyAPI_FUNC(int) PyUnicodeDecodeError_SetReason(
- PyObject *exc,
- const char *reason /* UTF-8 encoded string */
- );
-PyAPI_FUNC(int) PyUnicodeTranslateError_SetReason(
- PyObject *exc,
- const char *reason /* UTF-8 encoded string */
- );
-
-/* These APIs aren't really part of the error implementation, but
- often needed to format error messages; the native C lib APIs are
- not available on all platforms, which is why we provide emulations
- for those platforms in Python/mysnprintf.c,
- WARNING: The return value of snprintf varies across platforms; do
- not rely on any particular behavior; eventually the C99 defn may
- be reliable.
-*/
-#if defined(MS_WIN32) && !defined(HAVE_SNPRINTF)
-# define HAVE_SNPRINTF
-# define snprintf _snprintf
-# define vsnprintf _vsnprintf
-#endif
-
-#include <stdarg.h>
-PyAPI_FUNC(int) PyOS_snprintf(char *str, size_t size, const char *format, ...)
- Py_GCC_ATTRIBUTE((format(printf, 3, 4)));
-PyAPI_FUNC(int) PyOS_vsnprintf(char *str, size_t size, const char *format, va_list va)
- Py_GCC_ATTRIBUTE((format(printf, 3, 0)));
-
-#ifdef __cplusplus
-}
-#endif
-#endif /* !Py_ERRORS_H */
diff --git a/pythonsdk/include/pyexpat.h b/pythonsdk/include/pyexpat.h
deleted file mode 100644
index 5f5d381aa2394ccb2d397f0e29cf56e1e4c83548..0000000000000000000000000000000000000000
--- a/pythonsdk/include/pyexpat.h
+++ /dev/null
@@ -1,55 +0,0 @@
-/* Stuff to export relevant 'expat' entry points from pyexpat to other
- * parser modules, such as cElementTree. */
-
-/* note: you must import expat.h before importing this module! */
-
-#define PyExpat_CAPI_MAGIC "pyexpat.expat_CAPI 1.1"
-#define PyExpat_CAPSULE_NAME "pyexpat.expat_CAPI"
-
-struct PyExpat_CAPI
-{
- char* magic; /* set to PyExpat_CAPI_MAGIC */
- int size; /* set to sizeof(struct PyExpat_CAPI) */
- int MAJOR_VERSION;
- int MINOR_VERSION;
- int MICRO_VERSION;
- /* pointers to selected expat functions. add new functions at
- the end, if needed */
- const XML_LChar * (*ErrorString)(enum XML_Error code);
- enum XML_Error (*GetErrorCode)(XML_Parser parser);
- XML_Size (*GetErrorColumnNumber)(XML_Parser parser);
- XML_Size (*GetErrorLineNumber)(XML_Parser parser);
- enum XML_Status (*Parse)(
- XML_Parser parser, const char *s, int len, int isFinal);
- XML_Parser (*ParserCreate_MM)(
- const XML_Char *encoding, const XML_Memory_Handling_Suite *memsuite,
- const XML_Char *namespaceSeparator);
- void (*ParserFree)(XML_Parser parser);
- void (*SetCharacterDataHandler)(
- XML_Parser parser, XML_CharacterDataHandler handler);
- void (*SetCommentHandler)(
- XML_Parser parser, XML_CommentHandler handler);
- void (*SetDefaultHandlerExpand)(
- XML_Parser parser, XML_DefaultHandler handler);
- void (*SetElementHandler)(
- XML_Parser parser, XML_StartElementHandler start,
- XML_EndElementHandler end);
- void (*SetNamespaceDeclHandler)(
- XML_Parser parser, XML_StartNamespaceDeclHandler start,
- XML_EndNamespaceDeclHandler end);
- void (*SetProcessingInstructionHandler)(
- XML_Parser parser, XML_ProcessingInstructionHandler handler);
- void (*SetUnknownEncodingHandler)(
- XML_Parser parser, XML_UnknownEncodingHandler handler,
- void *encodingHandlerData);
- void (*SetUserData)(XML_Parser parser, void *userData);
- void (*SetStartDoctypeDeclHandler)(XML_Parser parser,
- XML_StartDoctypeDeclHandler start);
- enum XML_Status (*SetEncoding)(XML_Parser parser, const XML_Char *encoding);
- int (*DefaultUnknownEncodingHandler)(
- void *encodingHandlerData, const XML_Char *name, XML_Encoding *info);
- /* might be none for expat < 2.1.0 */
- int (*SetHashSalt)(XML_Parser parser, unsigned long hash_salt);
- /* always add new stuff to the end! */
-};
-
diff --git a/pythonsdk/include/pyfpe.h b/pythonsdk/include/pyfpe.h
deleted file mode 100644
index 30baacaa58b87ae6a5e26c514f444d8cca7b245e..0000000000000000000000000000000000000000
--- a/pythonsdk/include/pyfpe.h
+++ /dev/null
@@ -1,12 +0,0 @@
-#ifndef Py_PYFPE_H
-#define Py_PYFPE_H
-
-/* These macros used to do something when Python was built with --with-fpectl,
- * but support for that was dropped in 3.7. We continue to define them though,
- * to avoid breaking API users.
- */
-
-#define PyFPE_START_PROTECT(err_string, leave_stmt)
-#define PyFPE_END_PROTECT(v)
-
-#endif /* !Py_PYFPE_H */
diff --git a/pythonsdk/include/pyhash.h b/pythonsdk/include/pyhash.h
deleted file mode 100644
index df3a808c29a16a2740cd86c46adf5b42376c18f7..0000000000000000000000000000000000000000
--- a/pythonsdk/include/pyhash.h
+++ /dev/null
@@ -1,145 +0,0 @@
-#ifndef Py_HASH_H
-
-#define Py_HASH_H
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-/* Helpers for hash functions */
-#ifndef Py_LIMITED_API
-PyAPI_FUNC(Py_hash_t) _Py_HashDouble(double);
-PyAPI_FUNC(Py_hash_t) _Py_HashPointer(void*);
-PyAPI_FUNC(Py_hash_t) _Py_HashBytes(const void*, Py_ssize_t);
-#endif
-
-/* Prime multiplier used in string and various other hashes. */
-#define _PyHASH_MULTIPLIER 1000003UL /* 0xf4243 */
-
-/* Parameters used for the numeric hash implementation. See notes for
- _Py_HashDouble in Python/pyhash.c. Numeric hashes are based on
- reduction modulo the prime 2**_PyHASH_BITS - 1. */
-
-#if SIZEOF_VOID_P >= 8
-# define _PyHASH_BITS 61
-#else
-# define _PyHASH_BITS 31
-#endif
-
-#define _PyHASH_MODULUS (((size_t)1 << _PyHASH_BITS) - 1)
-#define _PyHASH_INF 314159
-#define _PyHASH_NAN 0
-#define _PyHASH_IMAG _PyHASH_MULTIPLIER
-
-
-/* hash secret
- *
- * memory layout on 64 bit systems
- * cccccccc cccccccc cccccccc uc -- unsigned char[24]
- * pppppppp ssssssss ........ fnv -- two Py_hash_t
- * k0k0k0k0 k1k1k1k1 ........ siphash -- two uint64_t
- * ........ ........ ssssssss djbx33a -- 16 bytes padding + one Py_hash_t
- * ........ ........ eeeeeeee pyexpat XML hash salt
- *
- * memory layout on 32 bit systems
- * cccccccc cccccccc cccccccc uc
- * ppppssss ........ ........ fnv -- two Py_hash_t
- * k0k0k0k0 k1k1k1k1 ........ siphash -- two uint64_t (*)
- * ........ ........ ssss.... djbx33a -- 16 bytes padding + one Py_hash_t
- * ........ ........ eeee.... pyexpat XML hash salt
- *
- * (*) The siphash member may not be available on 32 bit platforms without
- * an unsigned int64 data type.
- */
-#ifndef Py_LIMITED_API
-typedef union {
- /* ensure 24 bytes */
- unsigned char uc[24];
- /* two Py_hash_t for FNV */
- struct {
- Py_hash_t prefix;
- Py_hash_t suffix;
- } fnv;
- /* two uint64 for SipHash24 */
- struct {
- uint64_t k0;
- uint64_t k1;
- } siphash;
- /* a different (!) Py_hash_t for small string optimization */
- struct {
- unsigned char padding[16];
- Py_hash_t suffix;
- } djbx33a;
- struct {
- unsigned char padding[16];
- Py_hash_t hashsalt;
- } expat;
-} _Py_HashSecret_t;
-PyAPI_DATA(_Py_HashSecret_t) _Py_HashSecret;
-#endif
-
-#ifdef Py_DEBUG
-PyAPI_DATA(int) _Py_HashSecret_Initialized;
-#endif
-
-
-/* hash function definition */
-#ifndef Py_LIMITED_API
-typedef struct {
- Py_hash_t (*const hash)(const void *, Py_ssize_t);
- const char *name;
- const int hash_bits;
- const int seed_bits;
-} PyHash_FuncDef;
-
-PyAPI_FUNC(PyHash_FuncDef*) PyHash_GetFuncDef(void);
-#endif
-
-
-/* cutoff for small string DJBX33A optimization in range [1, cutoff).
- *
- * About 50% of the strings in a typical Python application are smaller than
- * 6 to 7 chars. However DJBX33A is vulnerable to hash collision attacks.
- * NEVER use DJBX33A for long strings!
- *
- * A Py_HASH_CUTOFF of 0 disables small string optimization. 32 bit platforms
- * should use a smaller cutoff because it is easier to create colliding
- * strings. A cutoff of 7 on 64bit platforms and 5 on 32bit platforms should
- * provide a decent safety margin.
- */
-#ifndef Py_HASH_CUTOFF
-# define Py_HASH_CUTOFF 0
-#elif (Py_HASH_CUTOFF > 7 || Py_HASH_CUTOFF < 0)
-# error Py_HASH_CUTOFF must in range 0...7.
-#endif /* Py_HASH_CUTOFF */
-
-
-/* hash algorithm selection
- *
- * The values for Py_HASH_SIPHASH24 and Py_HASH_FNV are hard-coded in the
- * configure script.
- *
- * - FNV is available on all platforms and architectures.
- * - SIPHASH24 only works on plaforms that don't require aligned memory for integers.
- * - With EXTERNAL embedders can provide an alternative implementation with::
- *
- * PyHash_FuncDef PyHash_Func = {...};
- *
- * XXX: Figure out __declspec() for extern PyHash_FuncDef.
- */
-#define Py_HASH_EXTERNAL 0
-#define Py_HASH_SIPHASH24 1
-#define Py_HASH_FNV 2
-
-#ifndef Py_HASH_ALGORITHM
-# ifndef HAVE_ALIGNED_REQUIRED
-# define Py_HASH_ALGORITHM Py_HASH_SIPHASH24
-# else
-# define Py_HASH_ALGORITHM Py_HASH_FNV
-# endif /* uint64_t && uint32_t && aligned */
-#endif /* Py_HASH_ALGORITHM */
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif /* !Py_HASH_H */
diff --git a/pythonsdk/include/pylifecycle.h b/pythonsdk/include/pylifecycle.h
deleted file mode 100644
index 104a3dcf11e56936af362c626ebcc8c31aadef41..0000000000000000000000000000000000000000
--- a/pythonsdk/include/pylifecycle.h
+++ /dev/null
@@ -1,238 +0,0 @@
-
-/* Interfaces to configure, query, create & destroy the Python runtime */
-
-#ifndef Py_PYLIFECYCLE_H
-#define Py_PYLIFECYCLE_H
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-#ifndef Py_LIMITED_API
-typedef struct {
- const char *prefix;
- const char *msg;
- int user_err;
-} _PyInitError;
-
-/* Almost all errors causing Python initialization to fail */
-#ifdef _MSC_VER
- /* Visual Studio 2015 doesn't implement C99 __func__ in C */
-# define _Py_INIT_GET_FUNC() __FUNCTION__
-#else
-# define _Py_INIT_GET_FUNC() __func__
-#endif
-
-#define _Py_INIT_OK() \
- (_PyInitError){.prefix = NULL, .msg = NULL, .user_err = 0}
-#define _Py_INIT_ERR(MSG) \
- (_PyInitError){.prefix = _Py_INIT_GET_FUNC(), .msg = (MSG), .user_err = 0}
-/* Error that can be fixed by the user like invalid input parameter.
- Don't abort() the process on such error. */
-#define _Py_INIT_USER_ERR(MSG) \
- (_PyInitError){.prefix = _Py_INIT_GET_FUNC(), .msg = (MSG), .user_err = 1}
-#define _Py_INIT_NO_MEMORY() _Py_INIT_USER_ERR("memory allocation failed")
-#define _Py_INIT_FAILED(err) \
- (err.msg != NULL)
-
-#endif
-
-
-PyAPI_FUNC(void) Py_SetProgramName(const wchar_t *);
-PyAPI_FUNC(wchar_t *) Py_GetProgramName(void);
-
-PyAPI_FUNC(void) Py_SetPythonHome(const wchar_t *);
-PyAPI_FUNC(wchar_t *) Py_GetPythonHome(void);
-
-#ifndef Py_LIMITED_API
-PyAPI_FUNC(void) _Py_SetProgramFullPath(const wchar_t *);
-
-/* Only used by applications that embed the interpreter and need to
- * override the standard encoding determination mechanism
- */
-PyAPI_FUNC(int) Py_SetStandardStreamEncoding(const char *encoding,
- const char *errors);
-
-/* PEP 432 Multi-phase initialization API (Private while provisional!) */
-PyAPI_FUNC(_PyInitError) _Py_InitializeCore(
- PyInterpreterState **interp_p,
- const _PyCoreConfig *config);
-PyAPI_FUNC(int) _Py_IsCoreInitialized(void);
-PyAPI_FUNC(_PyInitError) _Py_InitializeFromConfig(
- const _PyCoreConfig *config);
-#ifdef Py_BUILD_CORE
-PyAPI_FUNC(void) _Py_Initialize_ReadEnvVarsNoAlloc(void);
-#endif
-
-PyAPI_FUNC(PyObject *) _Py_GetGlobalVariablesAsDict(void);
-
-PyAPI_FUNC(_PyInitError) _PyCoreConfig_Read(_PyCoreConfig *);
-PyAPI_FUNC(void) _PyCoreConfig_Clear(_PyCoreConfig *);
-PyAPI_FUNC(int) _PyCoreConfig_Copy(
- _PyCoreConfig *config,
- const _PyCoreConfig *config2);
-PyAPI_FUNC(PyObject *) _PyCoreConfig_AsDict(const _PyCoreConfig *config);
-PyAPI_FUNC(void) _PyCoreConfig_SetGlobalConfig(
- const _PyCoreConfig *config);
-
-
-PyAPI_FUNC(_PyInitError) _PyMainInterpreterConfig_Read(
- _PyMainInterpreterConfig *config,
- const _PyCoreConfig *core_config);
-PyAPI_FUNC(void) _PyMainInterpreterConfig_Clear(_PyMainInterpreterConfig *);
-PyAPI_FUNC(int) _PyMainInterpreterConfig_Copy(
- _PyMainInterpreterConfig *config,
- const _PyMainInterpreterConfig *config2);
-/* Used by _testcapi.get_main_config() */
-PyAPI_FUNC(PyObject*) _PyMainInterpreterConfig_AsDict(
- const _PyMainInterpreterConfig *config);
-
-PyAPI_FUNC(_PyInitError) _Py_InitializeMainInterpreter(
- PyInterpreterState *interp,
- const _PyMainInterpreterConfig *config);
-#endif /* !defined(Py_LIMITED_API) */
-
-
-/* Initialization and finalization */
-PyAPI_FUNC(void) Py_Initialize(void);
-PyAPI_FUNC(void) Py_InitializeEx(int);
-#ifndef Py_LIMITED_API
-PyAPI_FUNC(void) _Py_FatalInitError(_PyInitError err) _Py_NO_RETURN;
-#endif
-PyAPI_FUNC(void) Py_Finalize(void);
-#if !defined(Py_LIMITED_API) || Py_LIMITED_API+0 >= 0x03060000
-PyAPI_FUNC(int) Py_FinalizeEx(void);
-#endif
-PyAPI_FUNC(int) Py_IsInitialized(void);
-
-/* Subinterpreter support */
-PyAPI_FUNC(PyThreadState *) Py_NewInterpreter(void);
-PyAPI_FUNC(void) Py_EndInterpreter(PyThreadState *);
-
-
-/* Py_PyAtExit is for the atexit module, Py_AtExit is for low-level
- * exit functions.
- */
-#ifndef Py_LIMITED_API
-PyAPI_FUNC(void) _Py_PyAtExit(void (*func)(PyObject *), PyObject *);
-#endif
-PyAPI_FUNC(int) Py_AtExit(void (*func)(void));
-
-PyAPI_FUNC(void) Py_Exit(int) _Py_NO_RETURN;
-
-/* Restore signals that the interpreter has called SIG_IGN on to SIG_DFL. */
-#ifndef Py_LIMITED_API
-PyAPI_FUNC(void) _Py_RestoreSignals(void);
-
-PyAPI_FUNC(int) Py_FdIsInteractive(FILE *, const char *);
-#endif
-
-/* Bootstrap __main__ (defined in Modules/main.c) */
-PyAPI_FUNC(int) Py_Main(int argc, wchar_t **argv);
-#ifdef Py_BUILD_CORE
-PyAPI_FUNC(int) _Py_UnixMain(int argc, char **argv);
-#endif
-
-/* In getpath.c */
-PyAPI_FUNC(wchar_t *) Py_GetProgramFullPath(void);
-PyAPI_FUNC(wchar_t *) Py_GetPrefix(void);
-PyAPI_FUNC(wchar_t *) Py_GetExecPrefix(void);
-PyAPI_FUNC(wchar_t *) Py_GetPath(void);
-#ifdef Py_BUILD_CORE
-PyAPI_FUNC(_PyInitError) _PyPathConfig_Init(const _PyCoreConfig *core_config);
-PyAPI_FUNC(int) _PyPathConfig_ComputeArgv0(
- int argc, wchar_t **argv,
- PyObject **argv0_p);
-PyAPI_FUNC(int) _Py_FindEnvConfigValue(
- FILE *env_file,
- const wchar_t *key,
- wchar_t *value,
- size_t value_size);
-#endif
-PyAPI_FUNC(void) Py_SetPath(const wchar_t *);
-#ifdef MS_WINDOWS
-int _Py_CheckPython3(void);
-#endif
-
-/* In their own files */
-PyAPI_FUNC(const char *) Py_GetVersion(void);
-PyAPI_FUNC(const char *) Py_GetPlatform(void);
-PyAPI_FUNC(const char *) Py_GetCopyright(void);
-PyAPI_FUNC(const char *) Py_GetCompiler(void);
-PyAPI_FUNC(const char *) Py_GetBuildInfo(void);
-#ifndef Py_LIMITED_API
-PyAPI_FUNC(const char *) _Py_gitidentifier(void);
-PyAPI_FUNC(const char *) _Py_gitversion(void);
-#endif
-
-/* Internal -- various one-time initializations */
-#ifndef Py_LIMITED_API
-PyAPI_FUNC(PyObject *) _PyBuiltin_Init(void);
-PyAPI_FUNC(_PyInitError) _PySys_BeginInit(PyObject **sysmod);
-PyAPI_FUNC(int) _PySys_EndInit(PyObject *sysdict, _PyMainInterpreterConfig *config);
-PyAPI_FUNC(_PyInitError) _PyImport_Init(PyInterpreterState *interp);
-PyAPI_FUNC(void) _PyExc_Init(PyObject * bltinmod);
-PyAPI_FUNC(_PyInitError) _PyImportHooks_Init(void);
-PyAPI_FUNC(int) _PyFrame_Init(void);
-PyAPI_FUNC(int) _PyFloat_Init(void);
-PyAPI_FUNC(int) PyByteArray_Init(void);
-PyAPI_FUNC(_PyInitError) _Py_HashRandomization_Init(const _PyCoreConfig *);
-#endif
-#ifdef Py_BUILD_CORE
-PyAPI_FUNC(int) _Py_ReadHashSeed(
- const char *seed_text,
- int *use_hash_seed,
- unsigned long *hash_seed);
-#endif
-
-/* Various internal finalizers */
-
-#ifdef Py_BUILD_CORE
-PyAPI_FUNC(void) _PyExc_Fini(void);
-PyAPI_FUNC(void) _PyImport_Fini(void);
-PyAPI_FUNC(void) _PyImport_Fini2(void);
-PyAPI_FUNC(void) _PyGC_DumpShutdownStats(void);
-PyAPI_FUNC(void) _PyGC_Fini(void);
-PyAPI_FUNC(void) _PyType_Fini(void);
-PyAPI_FUNC(void) _Py_HashRandomization_Fini(void);
-#endif /* Py_BUILD_CORE */
-
-#ifndef Py_LIMITED_API
-PyAPI_FUNC(void) PyMethod_Fini(void);
-PyAPI_FUNC(void) PyFrame_Fini(void);
-PyAPI_FUNC(void) PyCFunction_Fini(void);
-PyAPI_FUNC(void) PyDict_Fini(void);
-PyAPI_FUNC(void) PyTuple_Fini(void);
-PyAPI_FUNC(void) PyList_Fini(void);
-PyAPI_FUNC(void) PySet_Fini(void);
-PyAPI_FUNC(void) PyBytes_Fini(void);
-PyAPI_FUNC(void) PyByteArray_Fini(void);
-PyAPI_FUNC(void) PyFloat_Fini(void);
-PyAPI_FUNC(void) PyOS_FiniInterrupts(void);
-PyAPI_FUNC(void) PySlice_Fini(void);
-PyAPI_FUNC(void) PyAsyncGen_Fini(void);
-
-PyAPI_FUNC(int) _Py_IsFinalizing(void);
-#endif /* !Py_LIMITED_API */
-
-/* Signals */
-typedef void (*PyOS_sighandler_t)(int);
-PyAPI_FUNC(PyOS_sighandler_t) PyOS_getsig(int);
-PyAPI_FUNC(PyOS_sighandler_t) PyOS_setsig(int, PyOS_sighandler_t);
-
-#ifndef Py_LIMITED_API
-/* Random */
-PyAPI_FUNC(int) _PyOS_URandom(void *buffer, Py_ssize_t size);
-PyAPI_FUNC(int) _PyOS_URandomNonblock(void *buffer, Py_ssize_t size);
-#endif /* !Py_LIMITED_API */
-
-/* Legacy locale support */
-#ifndef Py_LIMITED_API
-PyAPI_FUNC(void) _Py_CoerceLegacyLocale(const _PyCoreConfig *config);
-PyAPI_FUNC(int) _Py_LegacyLocaleDetected(void);
-PyAPI_FUNC(char *) _Py_SetLocaleFromEnv(int category);
-#endif
-
-#ifdef __cplusplus
-}
-#endif
-#endif /* !Py_PYLIFECYCLE_H */
diff --git a/pythonsdk/include/pymacconfig.h b/pythonsdk/include/pymacconfig.h
deleted file mode 100644
index a1eccea4a513ed84904681a517f268d91fc93a40..0000000000000000000000000000000000000000
--- a/pythonsdk/include/pymacconfig.h
+++ /dev/null
@@ -1,102 +0,0 @@
-#ifndef PYMACCONFIG_H
-#define PYMACCONFIG_H
- /*
- * This file moves some of the autoconf magic to compile-time
- * when building on MacOSX. This is needed for building 4-way
- * universal binaries and for 64-bit universal binaries because
- * the values redefined below aren't configure-time constant but
- * only compile-time constant in these scenarios.
- */
-
-#if defined(__APPLE__)
-
-# undef SIZEOF_LONG
-# undef SIZEOF_PTHREAD_T
-# undef SIZEOF_SIZE_T
-# undef SIZEOF_TIME_T
-# undef SIZEOF_VOID_P
-# undef SIZEOF__BOOL
-# undef SIZEOF_UINTPTR_T
-# undef SIZEOF_PTHREAD_T
-# undef WORDS_BIGENDIAN
-# undef DOUBLE_IS_ARM_MIXED_ENDIAN_IEEE754
-# undef DOUBLE_IS_BIG_ENDIAN_IEEE754
-# undef DOUBLE_IS_LITTLE_ENDIAN_IEEE754
-# undef HAVE_GCC_ASM_FOR_X87
-
-# undef VA_LIST_IS_ARRAY
-# if defined(__LP64__) && defined(__x86_64__)
-# define VA_LIST_IS_ARRAY 1
-# endif
-
-# undef HAVE_LARGEFILE_SUPPORT
-# ifndef __LP64__
-# define HAVE_LARGEFILE_SUPPORT 1
-# endif
-
-# undef SIZEOF_LONG
-# ifdef __LP64__
-# define SIZEOF__BOOL 1
-# define SIZEOF__BOOL 1
-# define SIZEOF_LONG 8
-# define SIZEOF_PTHREAD_T 8
-# define SIZEOF_SIZE_T 8
-# define SIZEOF_TIME_T 8
-# define SIZEOF_VOID_P 8
-# define SIZEOF_UINTPTR_T 8
-# define SIZEOF_PTHREAD_T 8
-# else
-# ifdef __ppc__
-# define SIZEOF__BOOL 4
-# else
-# define SIZEOF__BOOL 1
-# endif
-# define SIZEOF_LONG 4
-# define SIZEOF_PTHREAD_T 4
-# define SIZEOF_SIZE_T 4
-# define SIZEOF_TIME_T 4
-# define SIZEOF_VOID_P 4
-# define SIZEOF_UINTPTR_T 4
-# define SIZEOF_PTHREAD_T 4
-# endif
-
-# if defined(__LP64__)
- /* MacOSX 10.4 (the first release to support 64-bit code
- * at all) only supports 64-bit in the UNIX layer.
- * Therefore suppress the toolbox-glue in 64-bit mode.
- */
-
- /* In 64-bit mode setpgrp always has no arguments, in 32-bit
- * mode that depends on the compilation environment
- */
-# undef SETPGRP_HAVE_ARG
-
-# endif
-
-#ifdef __BIG_ENDIAN__
-#define WORDS_BIGENDIAN 1
-#define DOUBLE_IS_BIG_ENDIAN_IEEE754
-#else
-#define DOUBLE_IS_LITTLE_ENDIAN_IEEE754
-#endif /* __BIG_ENDIAN */
-
-#ifdef __i386__
-# define HAVE_GCC_ASM_FOR_X87
-#endif
-
- /*
- * The definition in pyconfig.h is only valid on the OS release
- * where configure ran on and not necessarily for all systems where
- * the executable can be used on.
- *
- * Specifically: OSX 10.4 has limited supported for '%zd', while
- * 10.5 has full support for '%zd'. A binary built on 10.5 won't
- * work properly on 10.4 unless we suppress the definition
- * of PY_FORMAT_SIZE_T
- */
-#undef PY_FORMAT_SIZE_T
-
-
-#endif /* defined(_APPLE__) */
-
-#endif /* PYMACCONFIG_H */
diff --git a/pythonsdk/include/pymacro.h b/pythonsdk/include/pymacro.h
deleted file mode 100644
index e8f9a6678f723e2e05fa5279400e4a9924b91653..0000000000000000000000000000000000000000
--- a/pythonsdk/include/pymacro.h
+++ /dev/null
@@ -1,100 +0,0 @@
-#ifndef Py_PYMACRO_H
-#define Py_PYMACRO_H
-
-/* Minimum value between x and y */
-#define Py_MIN(x, y) (((x) > (y)) ? (y) : (x))
-
-/* Maximum value between x and y */
-#define Py_MAX(x, y) (((x) > (y)) ? (x) : (y))
-
-/* Absolute value of the number x */
-#define Py_ABS(x) ((x) < 0 ? -(x) : (x))
-
-#define _Py_XSTRINGIFY(x) #x
-
-/* Convert the argument to a string. For example, Py_STRINGIFY(123) is replaced
- with "123" by the preprocessor. Defines are also replaced by their value.
- For example Py_STRINGIFY(__LINE__) is replaced by the line number, not
- by "__LINE__". */
-#define Py_STRINGIFY(x) _Py_XSTRINGIFY(x)
-
-/* Get the size of a structure member in bytes */
-#define Py_MEMBER_SIZE(type, member) sizeof(((type *)0)->member)
-
-/* Argument must be a char or an int in [-128, 127] or [0, 255]. */
-#define Py_CHARMASK(c) ((unsigned char)((c) & 0xff))
-
-/* Assert a build-time dependency, as an expression.
-
- Your compile will fail if the condition isn't true, or can't be evaluated
- by the compiler. This can be used in an expression: its value is 0.
-
- Example:
-
- #define foo_to_char(foo) \
- ((char *)(foo) \
- + Py_BUILD_ASSERT_EXPR(offsetof(struct foo, string) == 0))
-
- Written by Rusty Russell, public domain, http://ccodearchive.net/ */
-#define Py_BUILD_ASSERT_EXPR(cond) \
- (sizeof(char [1 - 2*!(cond)]) - 1)
-
-#define Py_BUILD_ASSERT(cond) do { \
- (void)Py_BUILD_ASSERT_EXPR(cond); \
- } while(0)
-
-/* Get the number of elements in a visible array
-
- This does not work on pointers, or arrays declared as [], or function
- parameters. With correct compiler support, such usage will cause a build
- error (see Py_BUILD_ASSERT_EXPR).
-
- Written by Rusty Russell, public domain, http://ccodearchive.net/
-
- Requires at GCC 3.1+ */
-#if (defined(__GNUC__) && !defined(__STRICT_ANSI__) && \
- (((__GNUC__ == 3) && (__GNUC_MINOR__ >= 1)) || (__GNUC__ >= 4)))
-/* Two gcc extensions.
- &a[0] degrades to a pointer: a different type from an array */
-#define Py_ARRAY_LENGTH(array) \
- (sizeof(array) / sizeof((array)[0]) \
- + Py_BUILD_ASSERT_EXPR(!__builtin_types_compatible_p(typeof(array), \
- typeof(&(array)[0]))))
-#else
-#define Py_ARRAY_LENGTH(array) \
- (sizeof(array) / sizeof((array)[0]))
-#endif
-
-
-/* Define macros for inline documentation. */
-#define PyDoc_VAR(name) static char name[]
-#define PyDoc_STRVAR(name,str) PyDoc_VAR(name) = PyDoc_STR(str)
-#ifdef WITH_DOC_STRINGS
-#define PyDoc_STR(str) str
-#else
-#define PyDoc_STR(str) ""
-#endif
-
-/* Below "a" is a power of 2. */
-/* Round down size "n" to be a multiple of "a". */
-#define _Py_SIZE_ROUND_DOWN(n, a) ((size_t)(n) & ~(size_t)((a) - 1))
-/* Round up size "n" to be a multiple of "a". */
-#define _Py_SIZE_ROUND_UP(n, a) (((size_t)(n) + \
- (size_t)((a) - 1)) & ~(size_t)((a) - 1))
-/* Round pointer "p" down to the closest "a"-aligned address <= "p". */
-#define _Py_ALIGN_DOWN(p, a) ((void *)((uintptr_t)(p) & ~(uintptr_t)((a) - 1)))
-/* Round pointer "p" up to the closest "a"-aligned address >= "p". */
-#define _Py_ALIGN_UP(p, a) ((void *)(((uintptr_t)(p) + \
- (uintptr_t)((a) - 1)) & ~(uintptr_t)((a) - 1)))
-/* Check if pointer "p" is aligned to "a"-bytes boundary. */
-#define _Py_IS_ALIGNED(p, a) (!((uintptr_t)(p) & (uintptr_t)((a) - 1)))
-
-#ifdef __GNUC__
-#define Py_UNUSED(name) _unused_ ## name __attribute__((unused))
-#else
-#define Py_UNUSED(name) _unused_ ## name
-#endif
-
-#define Py_UNREACHABLE() abort()
-
-#endif /* Py_PYMACRO_H */
diff --git a/pythonsdk/include/pymath.h b/pythonsdk/include/pymath.h
deleted file mode 100644
index f4a7f852cee20da8accd11072ddf455be390af65..0000000000000000000000000000000000000000
--- a/pythonsdk/include/pymath.h
+++ /dev/null
@@ -1,230 +0,0 @@
-#ifndef Py_PYMATH_H
-#define Py_PYMATH_H
-
-#include "pyconfig.h" /* include for defines */
-
-/**************************************************************************
-Symbols and macros to supply platform-independent interfaces to mathematical
-functions and constants
-**************************************************************************/
-
-/* Python provides implementations for copysign, round and hypot in
- * Python/pymath.c just in case your math library doesn't provide the
- * functions.
- *
- *Note: PC/pyconfig.h defines copysign as _copysign
- */
-#ifndef HAVE_COPYSIGN
-extern double copysign(double, double);
-#endif
-
-#ifndef HAVE_ROUND
-extern double round(double);
-#endif
-
-#ifndef HAVE_HYPOT
-extern double hypot(double, double);
-#endif
-
-/* extra declarations */
-#ifndef _MSC_VER
-#ifndef __STDC__
-extern double fmod (double, double);
-extern double frexp (double, int *);
-extern double ldexp (double, int);
-extern double modf (double, double *);
-extern double pow(double, double);
-#endif /* __STDC__ */
-#endif /* _MSC_VER */
-
-/* High precision definition of pi and e (Euler)
- * The values are taken from libc6's math.h.
- */
-#ifndef Py_MATH_PIl
-#define Py_MATH_PIl 3.1415926535897932384626433832795029L
-#endif
-#ifndef Py_MATH_PI
-#define Py_MATH_PI 3.14159265358979323846
-#endif
-
-#ifndef Py_MATH_El
-#define Py_MATH_El 2.7182818284590452353602874713526625L
-#endif
-
-#ifndef Py_MATH_E
-#define Py_MATH_E 2.7182818284590452354
-#endif
-
-/* Tau (2pi) to 40 digits, taken from tauday.com/tau-digits. */
-#ifndef Py_MATH_TAU
-#define Py_MATH_TAU 6.2831853071795864769252867665590057683943L
-#endif
-
-
-/* On x86, Py_FORCE_DOUBLE forces a floating-point number out of an x87 FPU
- register and into a 64-bit memory location, rounding from extended
- precision to double precision in the process. On other platforms it does
- nothing. */
-
-/* we take double rounding as evidence of x87 usage */
-#ifndef Py_LIMITED_API
-#ifndef Py_FORCE_DOUBLE
-# ifdef X87_DOUBLE_ROUNDING
-PyAPI_FUNC(double) _Py_force_double(double);
-# define Py_FORCE_DOUBLE(X) (_Py_force_double(X))
-# else
-# define Py_FORCE_DOUBLE(X) (X)
-# endif
-#endif
-#endif
-
-#ifndef Py_LIMITED_API
-#ifdef HAVE_GCC_ASM_FOR_X87
-PyAPI_FUNC(unsigned short) _Py_get_387controlword(void);
-PyAPI_FUNC(void) _Py_set_387controlword(unsigned short);
-#endif
-#endif
-
-/* Py_IS_NAN(X)
- * Return 1 if float or double arg is a NaN, else 0.
- * Caution:
- * X is evaluated more than once.
- * This may not work on all platforms. Each platform has *some*
- * way to spell this, though -- override in pyconfig.h if you have
- * a platform where it doesn't work.
- * Note: PC/pyconfig.h defines Py_IS_NAN as _isnan
- */
-#ifndef Py_IS_NAN
-#if defined HAVE_DECL_ISNAN && HAVE_DECL_ISNAN == 1
-#define Py_IS_NAN(X) isnan(X)
-#else
-#define Py_IS_NAN(X) ((X) != (X))
-#endif
-#endif
-
-/* Py_IS_INFINITY(X)
- * Return 1 if float or double arg is an infinity, else 0.
- * Caution:
- * X is evaluated more than once.
- * This implementation may set the underflow flag if |X| is very small;
- * it really can't be implemented correctly (& easily) before C99.
- * Override in pyconfig.h if you have a better spelling on your platform.
- * Py_FORCE_DOUBLE is used to avoid getting false negatives from a
- * non-infinite value v sitting in an 80-bit x87 register such that
- * v becomes infinite when spilled from the register to 64-bit memory.
- * Note: PC/pyconfig.h defines Py_IS_INFINITY as _isinf
- */
-#ifndef Py_IS_INFINITY
-# if defined HAVE_DECL_ISINF && HAVE_DECL_ISINF == 1
-# define Py_IS_INFINITY(X) isinf(X)
-# else
-# define Py_IS_INFINITY(X) ((X) && \
- (Py_FORCE_DOUBLE(X)*0.5 == Py_FORCE_DOUBLE(X)))
-# endif
-#endif
-
-/* Py_IS_FINITE(X)
- * Return 1 if float or double arg is neither infinite nor NAN, else 0.
- * Some compilers (e.g. VisualStudio) have intrisics for this, so a special
- * macro for this particular test is useful
- * Note: PC/pyconfig.h defines Py_IS_FINITE as _finite
- */
-#ifndef Py_IS_FINITE
-#if defined HAVE_DECL_ISFINITE && HAVE_DECL_ISFINITE == 1
-#define Py_IS_FINITE(X) isfinite(X)
-#elif defined HAVE_FINITE
-#define Py_IS_FINITE(X) finite(X)
-#else
-#define Py_IS_FINITE(X) (!Py_IS_INFINITY(X) && !Py_IS_NAN(X))
-#endif
-#endif
-
-/* HUGE_VAL is supposed to expand to a positive double infinity. Python
- * uses Py_HUGE_VAL instead because some platforms are broken in this
- * respect. We used to embed code in pyport.h to try to worm around that,
- * but different platforms are broken in conflicting ways. If you're on
- * a platform where HUGE_VAL is defined incorrectly, fiddle your Python
- * config to #define Py_HUGE_VAL to something that works on your platform.
- */
-#ifndef Py_HUGE_VAL
-#define Py_HUGE_VAL HUGE_VAL
-#endif
-
-/* Py_NAN
- * A value that evaluates to a NaN. On IEEE 754 platforms INF*0 or
- * INF/INF works. Define Py_NO_NAN in pyconfig.h if your platform
- * doesn't support NaNs.
- */
-#if !defined(Py_NAN) && !defined(Py_NO_NAN)
-#if !defined(__INTEL_COMPILER)
- #define Py_NAN (Py_HUGE_VAL * 0.)
-#else /* __INTEL_COMPILER */
- #if defined(ICC_NAN_STRICT)
- #pragma float_control(push)
- #pragma float_control(precise, on)
- #pragma float_control(except, on)
- #if defined(_MSC_VER)
- __declspec(noinline)
- #else /* Linux */
- __attribute__((noinline))
- #endif /* _MSC_VER */
- static double __icc_nan()
- {
- return sqrt(-1.0);
- }
- #pragma float_control (pop)
- #define Py_NAN __icc_nan()
- #else /* ICC_NAN_RELAXED as default for Intel Compiler */
- static const union { unsigned char buf[8]; double __icc_nan; } __nan_store = {0,0,0,0,0,0,0xf8,0x7f};
- #define Py_NAN (__nan_store.__icc_nan)
- #endif /* ICC_NAN_STRICT */
-#endif /* __INTEL_COMPILER */
-#endif
-
-/* Py_OVERFLOWED(X)
- * Return 1 iff a libm function overflowed. Set errno to 0 before calling
- * a libm function, and invoke this macro after, passing the function
- * result.
- * Caution:
- * This isn't reliable. C99 no longer requires libm to set errno under
- * any exceptional condition, but does require +- HUGE_VAL return
- * values on overflow. A 754 box *probably* maps HUGE_VAL to a
- * double infinity, and we're cool if that's so, unless the input
- * was an infinity and an infinity is the expected result. A C89
- * system sets errno to ERANGE, so we check for that too. We're
- * out of luck if a C99 754 box doesn't map HUGE_VAL to +Inf, or
- * if the returned result is a NaN, or if a C89 box returns HUGE_VAL
- * in non-overflow cases.
- * X is evaluated more than once.
- * Some platforms have better way to spell this, so expect some #ifdef'ery.
- *
- * OpenBSD uses 'isinf()' because a compiler bug on that platform causes
- * the longer macro version to be mis-compiled. This isn't optimal, and
- * should be removed once a newer compiler is available on that platform.
- * The system that had the failure was running OpenBSD 3.2 on Intel, with
- * gcc 2.95.3.
- *
- * According to Tim's checkin, the FreeBSD systems use isinf() to work
- * around a FPE bug on that platform.
- */
-#if defined(__FreeBSD__) || defined(__OpenBSD__)
-#define Py_OVERFLOWED(X) isinf(X)
-#else
-#define Py_OVERFLOWED(X) ((X) != 0.0 && (errno == ERANGE || \
- (X) == Py_HUGE_VAL || \
- (X) == -Py_HUGE_VAL))
-#endif
-
-/* Return whether integral type *type* is signed or not. */
-#define _Py_IntegralTypeSigned(type) ((type)(-1) < 0)
-/* Return the maximum value of integral type *type*. */
-#define _Py_IntegralTypeMax(type) ((_Py_IntegralTypeSigned(type)) ? (((((type)1 << (sizeof(type)*CHAR_BIT - 2)) - 1) << 1) + 1) : ~(type)0)
-/* Return the minimum value of integral type *type*. */
-#define _Py_IntegralTypeMin(type) ((_Py_IntegralTypeSigned(type)) ? -_Py_IntegralTypeMax(type) - 1 : 0)
-/* Check whether *v* is in the range of integral type *type*. This is most
- * useful if *v* is floating-point, since demoting a floating-point *v* to an
- * integral type that cannot represent *v*'s integral part is undefined
- * behavior. */
-#define _Py_InIntegralTypeRange(type, v) (_Py_IntegralTypeMin(type) <= v && v <= _Py_IntegralTypeMax(type))
-
-#endif /* Py_PYMATH_H */
diff --git a/pythonsdk/include/pymem.h b/pythonsdk/include/pymem.h
deleted file mode 100644
index bbf3e7968cc66e5122838ff568362252dd3b7c80..0000000000000000000000000000000000000000
--- a/pythonsdk/include/pymem.h
+++ /dev/null
@@ -1,244 +0,0 @@
-/* The PyMem_ family: low-level memory allocation interfaces.
- See objimpl.h for the PyObject_ memory family.
-*/
-
-#ifndef Py_PYMEM_H
-#define Py_PYMEM_H
-
-#include "pyport.h"
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-#ifndef Py_LIMITED_API
-PyAPI_FUNC(void *) PyMem_RawMalloc(size_t size);
-PyAPI_FUNC(void *) PyMem_RawCalloc(size_t nelem, size_t elsize);
-PyAPI_FUNC(void *) PyMem_RawRealloc(void *ptr, size_t new_size);
-PyAPI_FUNC(void) PyMem_RawFree(void *ptr);
-
-/* Configure the Python memory allocators. Pass NULL to use default
- allocators. */
-PyAPI_FUNC(int) _PyMem_SetupAllocators(const char *opt);
-
-/* Try to get the allocators name set by _PyMem_SetupAllocators(). */
-PyAPI_FUNC(const char*) _PyMem_GetAllocatorsName(void);
-
-/* Track an allocated memory block in the tracemalloc module.
- Return 0 on success, return -1 on error (failed to allocate memory to store
- the trace).
-
- Return -2 if tracemalloc is disabled.
-
- If memory block is already tracked, update the existing trace. */
-PyAPI_FUNC(int) PyTraceMalloc_Track(
- unsigned int domain,
- uintptr_t ptr,
- size_t size);
-
-/* Untrack an allocated memory block in the tracemalloc module.
- Do nothing if the block was not tracked.
-
- Return -2 if tracemalloc is disabled, otherwise return 0. */
-PyAPI_FUNC(int) PyTraceMalloc_Untrack(
- unsigned int domain,
- uintptr_t ptr);
-
-/* Get the traceback where a memory block was allocated.
-
- Return a tuple of (filename: str, lineno: int) tuples.
-
- Return None if the tracemalloc module is disabled or if the memory block
- is not tracked by tracemalloc.
-
- Raise an exception and return NULL on error. */
-PyAPI_FUNC(PyObject*) _PyTraceMalloc_GetTraceback(
- unsigned int domain,
- uintptr_t ptr);
-#endif /* !defined(Py_LIMITED_API) */
-
-
-/* BEWARE:
-
- Each interface exports both functions and macros. Extension modules should
- use the functions, to ensure binary compatibility across Python versions.
- Because the Python implementation is free to change internal details, and
- the macros may (or may not) expose details for speed, if you do use the
- macros you must recompile your extensions with each Python release.
-
- Never mix calls to PyMem_ with calls to the platform malloc/realloc/
- calloc/free. For example, on Windows different DLLs may end up using
- different heaps, and if you use PyMem_Malloc you'll get the memory from the
- heap used by the Python DLL; it could be a disaster if you free()'ed that
- directly in your own extension. Using PyMem_Free instead ensures Python
- can return the memory to the proper heap. As another example, in
- PYMALLOC_DEBUG mode, Python wraps all calls to all PyMem_ and PyObject_
- memory functions in special debugging wrappers that add additional
- debugging info to dynamic memory blocks. The system routines have no idea
- what to do with that stuff, and the Python wrappers have no idea what to do
- with raw blocks obtained directly by the system routines then.
-
- The GIL must be held when using these APIs.
-*/
-
-/*
- * Raw memory interface
- * ====================
- */
-
-/* Functions
-
- Functions supplying platform-independent semantics for malloc/realloc/
- free. These functions make sure that allocating 0 bytes returns a distinct
- non-NULL pointer (whenever possible -- if we're flat out of memory, NULL
- may be returned), even if the platform malloc and realloc don't.
- Returned pointers must be checked for NULL explicitly. No action is
- performed on failure (no exception is set, no warning is printed, etc).
-*/
-
-PyAPI_FUNC(void *) PyMem_Malloc(size_t size);
-#if !defined(Py_LIMITED_API) || Py_LIMITED_API+0 >= 0x03050000
-PyAPI_FUNC(void *) PyMem_Calloc(size_t nelem, size_t elsize);
-#endif
-PyAPI_FUNC(void *) PyMem_Realloc(void *ptr, size_t new_size);
-PyAPI_FUNC(void) PyMem_Free(void *ptr);
-
-#ifndef Py_LIMITED_API
-/* strdup() using PyMem_RawMalloc() */
-PyAPI_FUNC(char *) _PyMem_RawStrdup(const char *str);
-
-/* strdup() using PyMem_Malloc() */
-PyAPI_FUNC(char *) _PyMem_Strdup(const char *str);
-
-/* wcsdup() using PyMem_RawMalloc() */
-PyAPI_FUNC(wchar_t*) _PyMem_RawWcsdup(const wchar_t *str);
-#endif
-
-/* Macros. */
-
-/* PyMem_MALLOC(0) means malloc(1). Some systems would return NULL
- for malloc(0), which would be treated as an error. Some platforms
- would return a pointer with no memory behind it, which would break
- pymalloc. To solve these problems, allocate an extra byte. */
-/* Returns NULL to indicate error if a negative size or size larger than
- Py_ssize_t can represent is supplied. Helps prevents security holes. */
-#define PyMem_MALLOC(n) PyMem_Malloc(n)
-#define PyMem_REALLOC(p, n) PyMem_Realloc(p, n)
-#define PyMem_FREE(p) PyMem_Free(p)
-
-/*
- * Type-oriented memory interface
- * ==============================
- *
- * Allocate memory for n objects of the given type. Returns a new pointer
- * or NULL if the request was too large or memory allocation failed. Use
- * these macros rather than doing the multiplication yourself so that proper
- * overflow checking is always done.
- */
-
-#define PyMem_New(type, n) \
- ( ((size_t)(n) > PY_SSIZE_T_MAX / sizeof(type)) ? NULL : \
- ( (type *) PyMem_Malloc((n) * sizeof(type)) ) )
-#define PyMem_NEW(type, n) \
- ( ((size_t)(n) > PY_SSIZE_T_MAX / sizeof(type)) ? NULL : \
- ( (type *) PyMem_MALLOC((n) * sizeof(type)) ) )
-
-/*
- * The value of (p) is always clobbered by this macro regardless of success.
- * The caller MUST check if (p) is NULL afterwards and deal with the memory
- * error if so. This means the original value of (p) MUST be saved for the
- * caller's memory error handler to not lose track of it.
- */
-#define PyMem_Resize(p, type, n) \
- ( (p) = ((size_t)(n) > PY_SSIZE_T_MAX / sizeof(type)) ? NULL : \
- (type *) PyMem_Realloc((p), (n) * sizeof(type)) )
-#define PyMem_RESIZE(p, type, n) \
- ( (p) = ((size_t)(n) > PY_SSIZE_T_MAX / sizeof(type)) ? NULL : \
- (type *) PyMem_REALLOC((p), (n) * sizeof(type)) )
-
-/* PyMem{Del,DEL} are left over from ancient days, and shouldn't be used
- * anymore. They're just confusing aliases for PyMem_{Free,FREE} now.
- */
-#define PyMem_Del PyMem_Free
-#define PyMem_DEL PyMem_FREE
-
-#ifndef Py_LIMITED_API
-typedef enum {
- /* PyMem_RawMalloc(), PyMem_RawRealloc() and PyMem_RawFree() */
- PYMEM_DOMAIN_RAW,
-
- /* PyMem_Malloc(), PyMem_Realloc() and PyMem_Free() */
- PYMEM_DOMAIN_MEM,
-
- /* PyObject_Malloc(), PyObject_Realloc() and PyObject_Free() */
- PYMEM_DOMAIN_OBJ
-} PyMemAllocatorDomain;
-
-typedef struct {
- /* user context passed as the first argument to the 4 functions */
- void *ctx;
-
- /* allocate a memory block */
- void* (*malloc) (void *ctx, size_t size);
-
- /* allocate a memory block initialized by zeros */
- void* (*calloc) (void *ctx, size_t nelem, size_t elsize);
-
- /* allocate or resize a memory block */
- void* (*realloc) (void *ctx, void *ptr, size_t new_size);
-
- /* release a memory block */
- void (*free) (void *ctx, void *ptr);
-} PyMemAllocatorEx;
-
-/* Get the memory block allocator of the specified domain. */
-PyAPI_FUNC(void) PyMem_GetAllocator(PyMemAllocatorDomain domain,
- PyMemAllocatorEx *allocator);
-
-/* Set the memory block allocator of the specified domain.
-
- The new allocator must return a distinct non-NULL pointer when requesting
- zero bytes.
-
- For the PYMEM_DOMAIN_RAW domain, the allocator must be thread-safe: the GIL
- is not held when the allocator is called.
-
- If the new allocator is not a hook (don't call the previous allocator), the
- PyMem_SetupDebugHooks() function must be called to reinstall the debug hooks
- on top on the new allocator. */
-PyAPI_FUNC(void) PyMem_SetAllocator(PyMemAllocatorDomain domain,
- PyMemAllocatorEx *allocator);
-
-/* Setup hooks to detect bugs in the following Python memory allocator
- functions:
-
- - PyMem_RawMalloc(), PyMem_RawRealloc(), PyMem_RawFree()
- - PyMem_Malloc(), PyMem_Realloc(), PyMem_Free()
- - PyObject_Malloc(), PyObject_Realloc() and PyObject_Free()
-
- Newly allocated memory is filled with the byte 0xCB, freed memory is filled
- with the byte 0xDB. Additional checks:
-
- - detect API violations, ex: PyObject_Free() called on a buffer allocated
- by PyMem_Malloc()
- - detect write before the start of the buffer (buffer underflow)
- - detect write after the end of the buffer (buffer overflow)
-
- The function does nothing if Python is not compiled is debug mode. */
-PyAPI_FUNC(void) PyMem_SetupDebugHooks(void);
-#endif
-
-#ifdef Py_BUILD_CORE
-/* Set the memory allocator of the specified domain to the default.
- Save the old allocator into *old_alloc if it's non-NULL.
- Return on success, or return -1 if the domain is unknown. */
-PyAPI_FUNC(int) _PyMem_SetDefaultAllocator(
- PyMemAllocatorDomain domain,
- PyMemAllocatorEx *old_alloc);
-#endif
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif /* !Py_PYMEM_H */
diff --git a/pythonsdk/include/pyport.h b/pythonsdk/include/pyport.h
deleted file mode 100644
index 5c9bc5cb20d6dcf0074a6ea12e685a64a9b2f82d..0000000000000000000000000000000000000000
--- a/pythonsdk/include/pyport.h
+++ /dev/null
@@ -1,793 +0,0 @@
-#ifndef Py_PYPORT_H
-#define Py_PYPORT_H
-
-#include "pyconfig.h" /* include for defines */
-
-#include <inttypes.h>
-
-/**************************************************************************
-Symbols and macros to supply platform-independent interfaces to basic
-C language & library operations whose spellings vary across platforms.
-
-Please try to make documentation here as clear as possible: by definition,
-the stuff here is trying to illuminate C's darkest corners.
-
-Config #defines referenced here:
-
-SIGNED_RIGHT_SHIFT_ZERO_FILLS
-Meaning: To be defined iff i>>j does not extend the sign bit when i is a
- signed integral type and i < 0.
-Used in: Py_ARITHMETIC_RIGHT_SHIFT
-
-Py_DEBUG
-Meaning: Extra checks compiled in for debug mode.
-Used in: Py_SAFE_DOWNCAST
-
-**************************************************************************/
-
-/* typedefs for some C9X-defined synonyms for integral types.
- *
- * The names in Python are exactly the same as the C9X names, except with a
- * Py_ prefix. Until C9X is universally implemented, this is the only way
- * to ensure that Python gets reliable names that don't conflict with names
- * in non-Python code that are playing their own tricks to define the C9X
- * names.
- *
- * NOTE: don't go nuts here! Python has no use for *most* of the C9X
- * integral synonyms. Only define the ones we actually need.
- */
-
-/* long long is required. Ensure HAVE_LONG_LONG is defined for compatibility. */
-#ifndef HAVE_LONG_LONG
-#define HAVE_LONG_LONG 1
-#endif
-#ifndef PY_LONG_LONG
-#define PY_LONG_LONG long long
-/* If LLONG_MAX is defined in limits.h, use that. */
-#define PY_LLONG_MIN LLONG_MIN
-#define PY_LLONG_MAX LLONG_MAX
-#define PY_ULLONG_MAX ULLONG_MAX
-#endif
-
-#define PY_UINT32_T uint32_t
-#define PY_UINT64_T uint64_t
-
-/* Signed variants of the above */
-#define PY_INT32_T int32_t
-#define PY_INT64_T int64_t
-
-/* If PYLONG_BITS_IN_DIGIT is not defined then we'll use 30-bit digits if all
- the necessary integer types are available, and we're on a 64-bit platform
- (as determined by SIZEOF_VOID_P); otherwise we use 15-bit digits. */
-
-#ifndef PYLONG_BITS_IN_DIGIT
-#if SIZEOF_VOID_P >= 8
-#define PYLONG_BITS_IN_DIGIT 30
-#else
-#define PYLONG_BITS_IN_DIGIT 15
-#endif
-#endif
-
-/* uintptr_t is the C9X name for an unsigned integral type such that a
- * legitimate void* can be cast to uintptr_t and then back to void* again
- * without loss of information. Similarly for intptr_t, wrt a signed
- * integral type.
- */
-typedef uintptr_t Py_uintptr_t;
-typedef intptr_t Py_intptr_t;
-
-/* Py_ssize_t is a signed integral type such that sizeof(Py_ssize_t) ==
- * sizeof(size_t). C99 doesn't define such a thing directly (size_t is an
- * unsigned integral type). See PEP 353 for details.
- */
-#ifdef HAVE_SSIZE_T
-typedef ssize_t Py_ssize_t;
-#elif SIZEOF_VOID_P == SIZEOF_SIZE_T
-typedef Py_intptr_t Py_ssize_t;
-#else
-# error "Python needs a typedef for Py_ssize_t in pyport.h."
-#endif
-
-/* Py_hash_t is the same size as a pointer. */
-#define SIZEOF_PY_HASH_T SIZEOF_SIZE_T
-typedef Py_ssize_t Py_hash_t;
-/* Py_uhash_t is the unsigned equivalent needed to calculate numeric hash. */
-#define SIZEOF_PY_UHASH_T SIZEOF_SIZE_T
-typedef size_t Py_uhash_t;
-
-/* Only used for compatibility with code that may not be PY_SSIZE_T_CLEAN. */
-#ifdef PY_SSIZE_T_CLEAN
-typedef Py_ssize_t Py_ssize_clean_t;
-#else
-typedef int Py_ssize_clean_t;
-#endif
-
-/* Largest possible value of size_t. */
-#define PY_SIZE_MAX SIZE_MAX
-
-/* Largest positive value of type Py_ssize_t. */
-#define PY_SSIZE_T_MAX ((Py_ssize_t)(((size_t)-1)>>1))
-/* Smallest negative value of type Py_ssize_t. */
-#define PY_SSIZE_T_MIN (-PY_SSIZE_T_MAX-1)
-
-/* PY_FORMAT_SIZE_T is a platform-specific modifier for use in a printf
- * format to convert an argument with the width of a size_t or Py_ssize_t.
- * C99 introduced "z" for this purpose, but not all platforms support that;
- * e.g., MS compilers use "I" instead.
- *
- * These "high level" Python format functions interpret "z" correctly on
- * all platforms (Python interprets the format string itself, and does whatever
- * the platform C requires to convert a size_t/Py_ssize_t argument):
- *
- * PyBytes_FromFormat
- * PyErr_Format
- * PyBytes_FromFormatV
- * PyUnicode_FromFormatV
- *
- * Lower-level uses require that you interpolate the correct format modifier
- * yourself (e.g., calling printf, fprintf, sprintf, PyOS_snprintf); for
- * example,
- *
- * Py_ssize_t index;
- * fprintf(stderr, "index %" PY_FORMAT_SIZE_T "d sucks\n", index);
- *
- * That will expand to %ld, or %Id, or to something else correct for a
- * Py_ssize_t on the platform.
- */
-#ifndef PY_FORMAT_SIZE_T
-# if SIZEOF_SIZE_T == SIZEOF_INT && !defined(__APPLE__)
-# define PY_FORMAT_SIZE_T ""
-# elif SIZEOF_SIZE_T == SIZEOF_LONG
-# define PY_FORMAT_SIZE_T "l"
-# elif defined(MS_WINDOWS)
-# define PY_FORMAT_SIZE_T "I"
-# else
-# error "This platform's pyconfig.h needs to define PY_FORMAT_SIZE_T"
-# endif
-#endif
-
-/* Py_LOCAL can be used instead of static to get the fastest possible calling
- * convention for functions that are local to a given module.
- *
- * Py_LOCAL_INLINE does the same thing, and also explicitly requests inlining,
- * for platforms that support that.
- *
- * If PY_LOCAL_AGGRESSIVE is defined before python.h is included, more
- * "aggressive" inlining/optimization is enabled for the entire module. This
- * may lead to code bloat, and may slow things down for those reasons. It may
- * also lead to errors, if the code relies on pointer aliasing. Use with
- * care.
- *
- * NOTE: You can only use this for functions that are entirely local to a
- * module; functions that are exported via method tables, callbacks, etc,
- * should keep using static.
- */
-
-#if defined(_MSC_VER)
-#if defined(PY_LOCAL_AGGRESSIVE)
-/* enable more aggressive optimization for visual studio */
-#pragma optimize("agtw", on)
-#endif
-/* ignore warnings if the compiler decides not to inline a function */
-#pragma warning(disable: 4710)
-/* fastest possible local call under MSVC */
-#define Py_LOCAL(type) static type __fastcall
-#define Py_LOCAL_INLINE(type) static __inline type __fastcall
-#else
-#define Py_LOCAL(type) static type
-#define Py_LOCAL_INLINE(type) static inline type
-#endif
-
-/* Py_MEMCPY is kept for backwards compatibility,
- * see https://bugs.python.org/issue28126 */
-#define Py_MEMCPY memcpy
-
-#include <stdlib.h>
-
-#ifdef HAVE_IEEEFP_H
-#include <ieeefp.h> /* needed for 'finite' declaration on some platforms */
-#endif
-
-#include <math.h> /* Moved here from the math section, before extern "C" */
-
-/********************************************
- * WRAPPER FOR <time.h> and/or <sys/time.h> *
- ********************************************/
-
-#ifdef TIME_WITH_SYS_TIME
-#include <sys/time.h>
-#include <time.h>
-#else /* !TIME_WITH_SYS_TIME */
-#ifdef HAVE_SYS_TIME_H
-#include <sys/time.h>
-#else /* !HAVE_SYS_TIME_H */
-#include <time.h>
-#endif /* !HAVE_SYS_TIME_H */
-#endif /* !TIME_WITH_SYS_TIME */
-
-
-/******************************
- * WRAPPER FOR <sys/select.h> *
- ******************************/
-
-/* NB caller must include <sys/types.h> */
-
-#ifdef HAVE_SYS_SELECT_H
-#include <sys/select.h>
-#endif /* !HAVE_SYS_SELECT_H */
-
-/*******************************
- * stat() and fstat() fiddling *
- *******************************/
-
-#ifdef HAVE_SYS_STAT_H
-#include <sys/stat.h>
-#elif defined(HAVE_STAT_H)
-#include <stat.h>
-#endif
-
-#ifndef S_IFMT
-/* VisualAge C/C++ Failed to Define MountType Field in sys/stat.h */
-#define S_IFMT 0170000
-#endif
-
-#ifndef S_IFLNK
-/* Windows doesn't define S_IFLNK but posixmodule.c maps
- * IO_REPARSE_TAG_SYMLINK to S_IFLNK */
-# define S_IFLNK 0120000
-#endif
-
-#ifndef S_ISREG
-#define S_ISREG(x) (((x) & S_IFMT) == S_IFREG)
-#endif
-
-#ifndef S_ISDIR
-#define S_ISDIR(x) (((x) & S_IFMT) == S_IFDIR)
-#endif
-
-#ifndef S_ISCHR
-#define S_ISCHR(x) (((x) & S_IFMT) == S_IFCHR)
-#endif
-
-#ifdef __cplusplus
-/* Move this down here since some C++ #include's don't like to be included
- inside an extern "C" */
-extern "C" {
-#endif
-
-
-/* Py_ARITHMETIC_RIGHT_SHIFT
- * C doesn't define whether a right-shift of a signed integer sign-extends
- * or zero-fills. Here a macro to force sign extension:
- * Py_ARITHMETIC_RIGHT_SHIFT(TYPE, I, J)
- * Return I >> J, forcing sign extension. Arithmetically, return the
- * floor of I/2**J.
- * Requirements:
- * I should have signed integer type. In the terminology of C99, this can
- * be either one of the five standard signed integer types (signed char,
- * short, int, long, long long) or an extended signed integer type.
- * J is an integer >= 0 and strictly less than the number of bits in the
- * type of I (because C doesn't define what happens for J outside that
- * range either).
- * TYPE used to specify the type of I, but is now ignored. It's been left
- * in for backwards compatibility with versions <= 2.6 or 3.0.
- * Caution:
- * I may be evaluated more than once.
- */
-#ifdef SIGNED_RIGHT_SHIFT_ZERO_FILLS
-#define Py_ARITHMETIC_RIGHT_SHIFT(TYPE, I, J) \
- ((I) < 0 ? -1-((-1-(I)) >> (J)) : (I) >> (J))
-#else
-#define Py_ARITHMETIC_RIGHT_SHIFT(TYPE, I, J) ((I) >> (J))
-#endif
-
-/* Py_FORCE_EXPANSION(X)
- * "Simply" returns its argument. However, macro expansions within the
- * argument are evaluated. This unfortunate trickery is needed to get
- * token-pasting to work as desired in some cases.
- */
-#define Py_FORCE_EXPANSION(X) X
-
-/* Py_SAFE_DOWNCAST(VALUE, WIDE, NARROW)
- * Cast VALUE to type NARROW from type WIDE. In Py_DEBUG mode, this
- * assert-fails if any information is lost.
- * Caution:
- * VALUE may be evaluated more than once.
- */
-#ifdef Py_DEBUG
-#define Py_SAFE_DOWNCAST(VALUE, WIDE, NARROW) \
- (assert((WIDE)(NARROW)(VALUE) == (VALUE)), (NARROW)(VALUE))
-#else
-#define Py_SAFE_DOWNCAST(VALUE, WIDE, NARROW) (NARROW)(VALUE)
-#endif
-
-/* Py_SET_ERRNO_ON_MATH_ERROR(x)
- * If a libm function did not set errno, but it looks like the result
- * overflowed or not-a-number, set errno to ERANGE or EDOM. Set errno
- * to 0 before calling a libm function, and invoke this macro after,
- * passing the function result.
- * Caution:
- * This isn't reliable. See Py_OVERFLOWED comments.
- * X is evaluated more than once.
- */
-#if defined(__FreeBSD__) || defined(__OpenBSD__) || (defined(__hpux) && defined(__ia64))
-#define _Py_SET_EDOM_FOR_NAN(X) if (isnan(X)) errno = EDOM;
-#else
-#define _Py_SET_EDOM_FOR_NAN(X) ;
-#endif
-#define Py_SET_ERRNO_ON_MATH_ERROR(X) \
- do { \
- if (errno == 0) { \
- if ((X) == Py_HUGE_VAL || (X) == -Py_HUGE_VAL) \
- errno = ERANGE; \
- else _Py_SET_EDOM_FOR_NAN(X) \
- } \
- } while(0)
-
-/* Py_SET_ERANGE_IF_OVERFLOW(x)
- * An alias of Py_SET_ERRNO_ON_MATH_ERROR for backward-compatibility.
- */
-#define Py_SET_ERANGE_IF_OVERFLOW(X) Py_SET_ERRNO_ON_MATH_ERROR(X)
-
-/* Py_ADJUST_ERANGE1(x)
- * Py_ADJUST_ERANGE2(x, y)
- * Set errno to 0 before calling a libm function, and invoke one of these
- * macros after, passing the function result(s) (Py_ADJUST_ERANGE2 is useful
- * for functions returning complex results). This makes two kinds of
- * adjustments to errno: (A) If it looks like the platform libm set
- * errno=ERANGE due to underflow, clear errno. (B) If it looks like the
- * platform libm overflowed but didn't set errno, force errno to ERANGE. In
- * effect, we're trying to force a useful implementation of C89 errno
- * behavior.
- * Caution:
- * This isn't reliable. See Py_OVERFLOWED comments.
- * X and Y may be evaluated more than once.
- */
-#define Py_ADJUST_ERANGE1(X) \
- do { \
- if (errno == 0) { \
- if ((X) == Py_HUGE_VAL || (X) == -Py_HUGE_VAL) \
- errno = ERANGE; \
- } \
- else if (errno == ERANGE && (X) == 0.0) \
- errno = 0; \
- } while(0)
-
-#define Py_ADJUST_ERANGE2(X, Y) \
- do { \
- if ((X) == Py_HUGE_VAL || (X) == -Py_HUGE_VAL || \
- (Y) == Py_HUGE_VAL || (Y) == -Py_HUGE_VAL) { \
- if (errno == 0) \
- errno = ERANGE; \
- } \
- else if (errno == ERANGE) \
- errno = 0; \
- } while(0)
-
-/* The functions _Py_dg_strtod and _Py_dg_dtoa in Python/dtoa.c (which are
- * required to support the short float repr introduced in Python 3.1) require
- * that the floating-point unit that's being used for arithmetic operations
- * on C doubles is set to use 53-bit precision. It also requires that the
- * FPU rounding mode is round-half-to-even, but that's less often an issue.
- *
- * If your FPU isn't already set to 53-bit precision/round-half-to-even, and
- * you want to make use of _Py_dg_strtod and _Py_dg_dtoa, then you should
- *
- * #define HAVE_PY_SET_53BIT_PRECISION 1
- *
- * and also give appropriate definitions for the following three macros:
- *
- * _PY_SET_53BIT_PRECISION_START : store original FPU settings, and
- * set FPU to 53-bit precision/round-half-to-even
- * _PY_SET_53BIT_PRECISION_END : restore original FPU settings
- * _PY_SET_53BIT_PRECISION_HEADER : any variable declarations needed to
- * use the two macros above.
- *
- * The macros are designed to be used within a single C function: see
- * Python/pystrtod.c for an example of their use.
- */
-
-/* get and set x87 control word for gcc/x86 */
-#ifdef HAVE_GCC_ASM_FOR_X87
-#define HAVE_PY_SET_53BIT_PRECISION 1
-/* _Py_get/set_387controlword functions are defined in Python/pymath.c */
-#define _Py_SET_53BIT_PRECISION_HEADER \
- unsigned short old_387controlword, new_387controlword
-#define _Py_SET_53BIT_PRECISION_START \
- do { \
- old_387controlword = _Py_get_387controlword(); \
- new_387controlword = (old_387controlword & ~0x0f00) | 0x0200; \
- if (new_387controlword != old_387controlword) \
- _Py_set_387controlword(new_387controlword); \
- } while (0)
-#define _Py_SET_53BIT_PRECISION_END \
- if (new_387controlword != old_387controlword) \
- _Py_set_387controlword(old_387controlword)
-#endif
-
-/* get and set x87 control word for VisualStudio/x86 */
-#if defined(_MSC_VER) && !defined(_WIN64) /* x87 not supported in 64-bit */
-#define HAVE_PY_SET_53BIT_PRECISION 1
-#define _Py_SET_53BIT_PRECISION_HEADER \
- unsigned int old_387controlword, new_387controlword, out_387controlword
-/* We use the __control87_2 function to set only the x87 control word.
- The SSE control word is unaffected. */
-#define _Py_SET_53BIT_PRECISION_START \
- do { \
- __control87_2(0, 0, &old_387controlword, NULL); \
- new_387controlword = \
- (old_387controlword & ~(_MCW_PC | _MCW_RC)) | (_PC_53 | _RC_NEAR); \
- if (new_387controlword != old_387controlword) \
- __control87_2(new_387controlword, _MCW_PC | _MCW_RC, \
- &out_387controlword, NULL); \
- } while (0)
-#define _Py_SET_53BIT_PRECISION_END \
- do { \
- if (new_387controlword != old_387controlword) \
- __control87_2(old_387controlword, _MCW_PC | _MCW_RC, \
- &out_387controlword, NULL); \
- } while (0)
-#endif
-
-#ifdef HAVE_GCC_ASM_FOR_MC68881
-#define HAVE_PY_SET_53BIT_PRECISION 1
-#define _Py_SET_53BIT_PRECISION_HEADER \
- unsigned int old_fpcr, new_fpcr
-#define _Py_SET_53BIT_PRECISION_START \
- do { \
- __asm__ ("fmove.l %%fpcr,%0" : "=g" (old_fpcr)); \
- /* Set double precision / round to nearest. */ \
- new_fpcr = (old_fpcr & ~0xf0) | 0x80; \
- if (new_fpcr != old_fpcr) \
- __asm__ volatile ("fmove.l %0,%%fpcr" : : "g" (new_fpcr)); \
- } while (0)
-#define _Py_SET_53BIT_PRECISION_END \
- do { \
- if (new_fpcr != old_fpcr) \
- __asm__ volatile ("fmove.l %0,%%fpcr" : : "g" (old_fpcr)); \
- } while (0)
-#endif
-
-/* default definitions are empty */
-#ifndef HAVE_PY_SET_53BIT_PRECISION
-#define _Py_SET_53BIT_PRECISION_HEADER
-#define _Py_SET_53BIT_PRECISION_START
-#define _Py_SET_53BIT_PRECISION_END
-#endif
-
-/* If we can't guarantee 53-bit precision, don't use the code
- in Python/dtoa.c, but fall back to standard code. This
- means that repr of a float will be long (17 sig digits).
-
- Realistically, there are two things that could go wrong:
-
- (1) doubles aren't IEEE 754 doubles, or
- (2) we're on x86 with the rounding precision set to 64-bits
- (extended precision), and we don't know how to change
- the rounding precision.
- */
-
-#if !defined(DOUBLE_IS_LITTLE_ENDIAN_IEEE754) && \
- !defined(DOUBLE_IS_BIG_ENDIAN_IEEE754) && \
- !defined(DOUBLE_IS_ARM_MIXED_ENDIAN_IEEE754)
-#define PY_NO_SHORT_FLOAT_REPR
-#endif
-
-/* double rounding is symptomatic of use of extended precision on x86. If
- we're seeing double rounding, and we don't have any mechanism available for
- changing the FPU rounding precision, then don't use Python/dtoa.c. */
-#if defined(X87_DOUBLE_ROUNDING) && !defined(HAVE_PY_SET_53BIT_PRECISION)
-#define PY_NO_SHORT_FLOAT_REPR
-#endif
-
-
-/* Py_DEPRECATED(version)
- * Declare a variable, type, or function deprecated.
- * Usage:
- * extern int old_var Py_DEPRECATED(2.3);
- * typedef int T1 Py_DEPRECATED(2.4);
- * extern int x() Py_DEPRECATED(2.5);
- */
-#if defined(__GNUC__) \
- && ((__GNUC__ >= 4) || (__GNUC__ == 3) && (__GNUC_MINOR__ >= 1))
-#define Py_DEPRECATED(VERSION_UNUSED) __attribute__((__deprecated__))
-#else
-#define Py_DEPRECATED(VERSION_UNUSED)
-#endif
-
-
-/* _Py_HOT_FUNCTION
- * The hot attribute on a function is used to inform the compiler that the
- * function is a hot spot of the compiled program. The function is optimized
- * more aggressively and on many target it is placed into special subsection of
- * the text section so all hot functions appears close together improving
- * locality.
- *
- * Usage:
- * int _Py_HOT_FUNCTION x(void) { return 3; }
- *
- * Issue #28618: This attribute must not be abused, otherwise it can have a
- * negative effect on performance. Only the functions were Python spend most of
- * its time must use it. Use a profiler when running performance benchmark
- * suite to find these functions.
- */
-#if defined(__GNUC__) \
- && ((__GNUC__ >= 5) || (__GNUC__ == 4) && (__GNUC_MINOR__ >= 3))
-#define _Py_HOT_FUNCTION __attribute__((hot))
-#else
-#define _Py_HOT_FUNCTION
-#endif
-
-/* _Py_NO_INLINE
- * Disable inlining on a function. For example, it helps to reduce the C stack
- * consumption.
- *
- * Usage:
- * int _Py_NO_INLINE x(void) { return 3; }
- */
-#if defined(__GNUC__) || defined(__clang__)
-# define _Py_NO_INLINE __attribute__((noinline))
-#else
-# define _Py_NO_INLINE
-#endif
-
-/**************************************************************************
-Prototypes that are missing from the standard include files on some systems
-(and possibly only some versions of such systems.)
-
-Please be conservative with adding new ones, document them and enclose them
-in platform-specific #ifdefs.
-**************************************************************************/
-
-#ifdef SOLARIS
-/* Unchecked */
-extern int gethostname(char *, int);
-#endif
-
-#ifdef HAVE__GETPTY
-#include <sys/types.h> /* we need to import mode_t */
-extern char * _getpty(int *, int, mode_t, int);
-#endif
-
-/* On QNX 6, struct termio must be declared by including sys/termio.h
- if TCGETA, TCSETA, TCSETAW, or TCSETAF are used. sys/termio.h must
- be included before termios.h or it will generate an error. */
-#if defined(HAVE_SYS_TERMIO_H) && !defined(__hpux)
-#include <sys/termio.h>
-#endif
-
-
-/* On 4.4BSD-descendants, ctype functions serves the whole range of
- * wchar_t character set rather than single byte code points only.
- * This characteristic can break some operations of string object
- * including str.upper() and str.split() on UTF-8 locales. This
- * workaround was provided by Tim Robbins of FreeBSD project.
- */
-
-#if defined(__APPLE__)
-# define _PY_PORT_CTYPE_UTF8_ISSUE
-#endif
-
-#ifdef _PY_PORT_CTYPE_UTF8_ISSUE
-#ifndef __cplusplus
- /* The workaround below is unsafe in C++ because
- * the <locale> defines these symbols as real functions,
- * with a slightly different signature.
- * See issue #10910
- */
-#include <ctype.h>
-#include <wctype.h>
-#undef isalnum
-#define isalnum(c) iswalnum(btowc(c))
-#undef isalpha
-#define isalpha(c) iswalpha(btowc(c))
-#undef islower
-#define islower(c) iswlower(btowc(c))
-#undef isspace
-#define isspace(c) iswspace(btowc(c))
-#undef isupper
-#define isupper(c) iswupper(btowc(c))
-#undef tolower
-#define tolower(c) towlower(btowc(c))
-#undef toupper
-#define toupper(c) towupper(btowc(c))
-#endif
-#endif
-
-
-/* Declarations for symbol visibility.
-
- PyAPI_FUNC(type): Declares a public Python API function and return type
- PyAPI_DATA(type): Declares public Python data and its type
- PyMODINIT_FUNC: A Python module init function. If these functions are
- inside the Python core, they are private to the core.
- If in an extension module, it may be declared with
- external linkage depending on the platform.
-
- As a number of platforms support/require "__declspec(dllimport/dllexport)",
- we support a HAVE_DECLSPEC_DLL macro to save duplication.
-*/
-
-/*
- All windows ports, except cygwin, are handled in PC/pyconfig.h.
-
- Cygwin is the only other autoconf platform requiring special
- linkage handling and it uses __declspec().
-*/
-#if defined(__CYGWIN__)
-# define HAVE_DECLSPEC_DLL
-#endif
-
-/* only get special linkage if built as shared or platform is Cygwin */
-#if defined(Py_ENABLE_SHARED) || defined(__CYGWIN__)
-# if defined(HAVE_DECLSPEC_DLL)
-# if defined(Py_BUILD_CORE) || defined(Py_BUILD_CORE_BUILTIN)
-# define PyAPI_FUNC(RTYPE) __declspec(dllexport) RTYPE
-# define PyAPI_DATA(RTYPE) extern __declspec(dllexport) RTYPE
- /* module init functions inside the core need no external linkage */
- /* except for Cygwin to handle embedding */
-# if defined(__CYGWIN__)
-# define PyMODINIT_FUNC __declspec(dllexport) PyObject*
-# else /* __CYGWIN__ */
-# define PyMODINIT_FUNC PyObject*
-# endif /* __CYGWIN__ */
-# else /* Py_BUILD_CORE */
- /* Building an extension module, or an embedded situation */
- /* public Python functions and data are imported */
- /* Under Cygwin, auto-import functions to prevent compilation */
- /* failures similar to those described at the bottom of 4.1: */
- /* http://docs.python.org/extending/windows.html#a-cookbook-approach */
-# if !defined(__CYGWIN__)
-# define PyAPI_FUNC(RTYPE) __declspec(dllimport) RTYPE
-# endif /* !__CYGWIN__ */
-# define PyAPI_DATA(RTYPE) extern __declspec(dllimport) RTYPE
- /* module init functions outside the core must be exported */
-# if defined(__cplusplus)
-# define PyMODINIT_FUNC extern "C" __declspec(dllexport) PyObject*
-# else /* __cplusplus */
-# define PyMODINIT_FUNC __declspec(dllexport) PyObject*
-# endif /* __cplusplus */
-# endif /* Py_BUILD_CORE */
-# endif /* HAVE_DECLSPEC_DLL */
-#endif /* Py_ENABLE_SHARED */
-
-/* If no external linkage macros defined by now, create defaults */
-#ifndef PyAPI_FUNC
-# define PyAPI_FUNC(RTYPE) RTYPE
-#endif
-#ifndef PyAPI_DATA
-# define PyAPI_DATA(RTYPE) extern RTYPE
-#endif
-#ifndef PyMODINIT_FUNC
-# if defined(__cplusplus)
-# define PyMODINIT_FUNC extern "C" PyObject*
-# else /* __cplusplus */
-# define PyMODINIT_FUNC PyObject*
-# endif /* __cplusplus */
-#endif
-
-/* limits.h constants that may be missing */
-
-#ifndef INT_MAX
-#define INT_MAX 2147483647
-#endif
-
-#ifndef LONG_MAX
-#if SIZEOF_LONG == 4
-#define LONG_MAX 0X7FFFFFFFL
-#elif SIZEOF_LONG == 8
-#define LONG_MAX 0X7FFFFFFFFFFFFFFFL
-#else
-#error "could not set LONG_MAX in pyport.h"
-#endif
-#endif
-
-#ifndef LONG_MIN
-#define LONG_MIN (-LONG_MAX-1)
-#endif
-
-#ifndef LONG_BIT
-#define LONG_BIT (8 * SIZEOF_LONG)
-#endif
-
-#if LONG_BIT != 8 * SIZEOF_LONG
-/* 04-Oct-2000 LONG_BIT is apparently (mis)defined as 64 on some recent
- * 32-bit platforms using gcc. We try to catch that here at compile-time
- * rather than waiting for integer multiplication to trigger bogus
- * overflows.
- */
-#error "LONG_BIT definition appears wrong for platform (bad gcc/glibc config?)."
-#endif
-
-#ifdef __cplusplus
-}
-#endif
-
-/*
- * Hide GCC attributes from compilers that don't support them.
- */
-#if (!defined(__GNUC__) || __GNUC__ < 2 || \
- (__GNUC__ == 2 && __GNUC_MINOR__ < 7) )
-#define Py_GCC_ATTRIBUTE(x)
-#else
-#define Py_GCC_ATTRIBUTE(x) __attribute__(x)
-#endif
-
-/*
- * Specify alignment on compilers that support it.
- */
-#if defined(__GNUC__) && __GNUC__ >= 3
-#define Py_ALIGNED(x) __attribute__((aligned(x)))
-#else
-#define Py_ALIGNED(x)
-#endif
-
-/* Eliminate end-of-loop code not reached warnings from SunPro C
- * when using do{...}while(0) macros
- */
-#ifdef __SUNPRO_C
-#pragma error_messages (off,E_END_OF_LOOP_CODE_NOT_REACHED)
-#endif
-
-#ifndef Py_LL
-#define Py_LL(x) x##LL
-#endif
-
-#ifndef Py_ULL
-#define Py_ULL(x) Py_LL(x##U)
-#endif
-
-#define Py_VA_COPY va_copy
-
-/*
- * Convenient macros to deal with endianness of the platform. WORDS_BIGENDIAN is
- * detected by configure and defined in pyconfig.h. The code in pyconfig.h
- * also takes care of Apple's universal builds.
- */
-
-#ifdef WORDS_BIGENDIAN
-#define PY_BIG_ENDIAN 1
-#define PY_LITTLE_ENDIAN 0
-#else
-#define PY_BIG_ENDIAN 0
-#define PY_LITTLE_ENDIAN 1
-#endif
-
-#if defined(Py_BUILD_CORE) || defined(Py_BUILD_CORE_BUILTIN)
-/*
- * Macros to protect CRT calls against instant termination when passed an
- * invalid parameter (issue23524).
- */
-#if defined _MSC_VER && _MSC_VER >= 1900
-
-extern _invalid_parameter_handler _Py_silent_invalid_parameter_handler;
-#define _Py_BEGIN_SUPPRESS_IPH { _invalid_parameter_handler _Py_old_handler = \
- _set_thread_local_invalid_parameter_handler(_Py_silent_invalid_parameter_handler);
-#define _Py_END_SUPPRESS_IPH _set_thread_local_invalid_parameter_handler(_Py_old_handler); }
-
-#else
-
-#define _Py_BEGIN_SUPPRESS_IPH
-#define _Py_END_SUPPRESS_IPH
-
-#endif /* _MSC_VER >= 1900 */
-#endif /* Py_BUILD_CORE */
-
-#ifdef __ANDROID__
-/* The Android langinfo.h header is not used. */
-#undef HAVE_LANGINFO_H
-#undef CODESET
-#endif
-
-/* Maximum value of the Windows DWORD type */
-#define PY_DWORD_MAX 4294967295U
-
-/* This macro used to tell whether Python was built with multithreading
- * enabled. Now multithreading is always enabled, but keep the macro
- * for compatibility.
- */
-#ifndef WITH_THREAD
-#define WITH_THREAD
-#endif
-
-#endif /* Py_PYPORT_H */
diff --git a/pythonsdk/include/pystate.h b/pythonsdk/include/pystate.h
deleted file mode 100644
index 28eb707ca8489e968490008c72f4fdac507ca5ad..0000000000000000000000000000000000000000
--- a/pythonsdk/include/pystate.h
+++ /dev/null
@@ -1,456 +0,0 @@
-
-/* Thread and interpreter state structures and their interfaces */
-
-
-#ifndef Py_PYSTATE_H
-#define Py_PYSTATE_H
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-#include "pythread.h"
-
-/* This limitation is for performance and simplicity. If needed it can be
-removed (with effort). */
-#define MAX_CO_EXTRA_USERS 255
-
-/* State shared between threads */
-
-struct _ts; /* Forward */
-struct _is; /* Forward */
-struct _frame; /* Forward declaration for PyFrameObject. */
-
-#ifdef Py_LIMITED_API
-typedef struct _is PyInterpreterState;
-#else
-typedef PyObject* (*_PyFrameEvalFunction)(struct _frame *, int);
-
-
-typedef struct {
- int install_signal_handlers; /* Install signal handlers? -1 means unset */
-
- int ignore_environment; /* -E, Py_IgnoreEnvironmentFlag */
- int use_hash_seed; /* PYTHONHASHSEED=x */
- unsigned long hash_seed;
- const char *allocator; /* Memory allocator: _PyMem_SetupAllocators() */
- int dev_mode; /* PYTHONDEVMODE, -X dev */
- int faulthandler; /* PYTHONFAULTHANDLER, -X faulthandler */
- int tracemalloc; /* PYTHONTRACEMALLOC, -X tracemalloc=N */
- int import_time; /* PYTHONPROFILEIMPORTTIME, -X importtime */
- int show_ref_count; /* -X showrefcount */
- int show_alloc_count; /* -X showalloccount */
- int dump_refs; /* PYTHONDUMPREFS */
- int malloc_stats; /* PYTHONMALLOCSTATS */
- int coerce_c_locale; /* PYTHONCOERCECLOCALE, -1 means unknown */
- int coerce_c_locale_warn; /* PYTHONCOERCECLOCALE=warn */
- int utf8_mode; /* PYTHONUTF8, -X utf8; -1 means unknown */
-
- wchar_t *program_name; /* Program name, see also Py_GetProgramName() */
- int argc; /* Number of command line arguments,
- -1 means unset */
- wchar_t **argv; /* Command line arguments */
- wchar_t *program; /* argv[0] or "" */
-
- int nxoption; /* Number of -X options */
- wchar_t **xoptions; /* -X options */
-
- int nwarnoption; /* Number of warnings options */
- wchar_t **warnoptions; /* Warnings options */
-
- /* Path configuration inputs */
- wchar_t *module_search_path_env; /* PYTHONPATH environment variable */
- wchar_t *home; /* PYTHONHOME environment variable,
- see also Py_SetPythonHome(). */
-
- /* Path configuration outputs */
- int nmodule_search_path; /* Number of sys.path paths,
- -1 means unset */
- wchar_t **module_search_paths; /* sys.path paths */
- wchar_t *executable; /* sys.executable */
- wchar_t *prefix; /* sys.prefix */
- wchar_t *base_prefix; /* sys.base_prefix */
- wchar_t *exec_prefix; /* sys.exec_prefix */
- wchar_t *base_exec_prefix; /* sys.base_exec_prefix */
-
- /* Private fields */
- int _disable_importlib; /* Needed by freeze_importlib */
-} _PyCoreConfig;
-
-#define _PyCoreConfig_INIT \
- (_PyCoreConfig){ \
- .install_signal_handlers = -1, \
- .ignore_environment = -1, \
- .use_hash_seed = -1, \
- .coerce_c_locale = -1, \
- .faulthandler = -1, \
- .tracemalloc = -1, \
- .utf8_mode = -1, \
- .argc = -1, \
- .nmodule_search_path = -1}
-/* Note: _PyCoreConfig_INIT sets other fields to 0/NULL */
-
-/* Placeholders while working on the new configuration API
- *
- * See PEP 432 for final anticipated contents
- */
-typedef struct {
- int install_signal_handlers; /* Install signal handlers? -1 means unset */
- PyObject *argv; /* sys.argv list, can be NULL */
- PyObject *executable; /* sys.executable str */
- PyObject *prefix; /* sys.prefix str */
- PyObject *base_prefix; /* sys.base_prefix str, can be NULL */
- PyObject *exec_prefix; /* sys.exec_prefix str */
- PyObject *base_exec_prefix; /* sys.base_exec_prefix str, can be NULL */
- PyObject *warnoptions; /* sys.warnoptions list, can be NULL */
- PyObject *xoptions; /* sys._xoptions dict, can be NULL */
- PyObject *module_search_path; /* sys.path list */
-} _PyMainInterpreterConfig;
-
-#define _PyMainInterpreterConfig_INIT \
- (_PyMainInterpreterConfig){.install_signal_handlers = -1}
-/* Note: _PyMainInterpreterConfig_INIT sets other fields to 0/NULL */
-
-typedef struct _is {
-
- struct _is *next;
- struct _ts *tstate_head;
-
- int64_t id;
- int64_t id_refcount;
- PyThread_type_lock id_mutex;
-
- PyObject *modules;
- PyObject *modules_by_index;
- PyObject *sysdict;
- PyObject *builtins;
- PyObject *importlib;
-
- /* Used in Python/sysmodule.c. */
- int check_interval;
-
- /* Used in Modules/_threadmodule.c. */
- long num_threads;
- /* Support for runtime thread stack size tuning.
- A value of 0 means using the platform's default stack size
- or the size specified by the THREAD_STACK_SIZE macro. */
- /* Used in Python/thread.c. */
- size_t pythread_stacksize;
-
- PyObject *codec_search_path;
- PyObject *codec_search_cache;
- PyObject *codec_error_registry;
- int codecs_initialized;
- int fscodec_initialized;
-
- _PyCoreConfig core_config;
- _PyMainInterpreterConfig config;
-#ifdef HAVE_DLOPEN
- int dlopenflags;
-#endif
-
- PyObject *builtins_copy;
- PyObject *import_func;
- /* Initialized to PyEval_EvalFrameDefault(). */
- _PyFrameEvalFunction eval_frame;
-
- Py_ssize_t co_extra_user_count;
- freefunc co_extra_freefuncs[MAX_CO_EXTRA_USERS];
-
-#ifdef HAVE_FORK
- PyObject *before_forkers;
- PyObject *after_forkers_parent;
- PyObject *after_forkers_child;
-#endif
- /* AtExit module */
- void (*pyexitfunc)(PyObject *);
- PyObject *pyexitmodule;
-
- uint64_t tstate_next_unique_id;
-} PyInterpreterState;
-#endif /* !Py_LIMITED_API */
-
-
-/* State unique per thread */
-
-#ifndef Py_LIMITED_API
-/* Py_tracefunc return -1 when raising an exception, or 0 for success. */
-typedef int (*Py_tracefunc)(PyObject *, struct _frame *, int, PyObject *);
-
-/* The following values are used for 'what' for tracefunc functions
- *
- * To add a new kind of trace event, also update "trace_init" in
- * Python/sysmodule.c to define the Python level event name
- */
-#define PyTrace_CALL 0
-#define PyTrace_EXCEPTION 1
-#define PyTrace_LINE 2
-#define PyTrace_RETURN 3
-#define PyTrace_C_CALL 4
-#define PyTrace_C_EXCEPTION 5
-#define PyTrace_C_RETURN 6
-#define PyTrace_OPCODE 7
-#endif /* Py_LIMITED_API */
-
-#ifdef Py_LIMITED_API
-typedef struct _ts PyThreadState;
-#else
-
-typedef struct _err_stackitem {
- /* This struct represents an entry on the exception stack, which is a
- * per-coroutine state. (Coroutine in the computer science sense,
- * including the thread and generators).
- * This ensures that the exception state is not impacted by "yields"
- * from an except handler.
- */
- PyObject *exc_type, *exc_value, *exc_traceback;
-
- struct _err_stackitem *previous_item;
-
-} _PyErr_StackItem;
-
-
-typedef struct _ts {
- /* See Python/ceval.c for comments explaining most fields */
-
- struct _ts *prev;
- struct _ts *next;
- PyInterpreterState *interp;
-
- /* Borrowed reference to the current frame (it can be NULL) */
- struct _frame *frame;
- int recursion_depth;
- char overflowed; /* The stack has overflowed. Allow 50 more calls
- to handle the runtime error. */
- char recursion_critical; /* The current calls must not cause
- a stack overflow. */
- int stackcheck_counter;
-
- /* 'tracing' keeps track of the execution depth when tracing/profiling.
- This is to prevent the actual trace/profile code from being recorded in
- the trace/profile. */
- int tracing;
- int use_tracing;
-
- Py_tracefunc c_profilefunc;
- Py_tracefunc c_tracefunc;
- PyObject *c_profileobj;
- PyObject *c_traceobj;
-
- /* The exception currently being raised */
- PyObject *curexc_type;
- PyObject *curexc_value;
- PyObject *curexc_traceback;
-
- /* The exception currently being handled, if no coroutines/generators
- * are present. Always last element on the stack referred to be exc_info.
- */
- _PyErr_StackItem exc_state;
-
- /* Pointer to the top of the stack of the exceptions currently
- * being handled */
- _PyErr_StackItem *exc_info;
-
- PyObject *dict; /* Stores per-thread state */
-
- int gilstate_counter;
-
- PyObject *async_exc; /* Asynchronous exception to raise */
- unsigned long thread_id; /* Thread id where this tstate was created */
-
- int trash_delete_nesting;
- PyObject *trash_delete_later;
-
- /* Called when a thread state is deleted normally, but not when it
- * is destroyed after fork().
- * Pain: to prevent rare but fatal shutdown errors (issue 18808),
- * Thread.join() must wait for the join'ed thread's tstate to be unlinked
- * from the tstate chain. That happens at the end of a thread's life,
- * in pystate.c.
- * The obvious way doesn't quite work: create a lock which the tstate
- * unlinking code releases, and have Thread.join() wait to acquire that
- * lock. The problem is that we _are_ at the end of the thread's life:
- * if the thread holds the last reference to the lock, decref'ing the
- * lock will delete the lock, and that may trigger arbitrary Python code
- * if there's a weakref, with a callback, to the lock. But by this time
- * _PyThreadState_Current is already NULL, so only the simplest of C code
- * can be allowed to run (in particular it must not be possible to
- * release the GIL).
- * So instead of holding the lock directly, the tstate holds a weakref to
- * the lock: that's the value of on_delete_data below. Decref'ing a
- * weakref is harmless.
- * on_delete points to _threadmodule.c's static release_sentinel() function.
- * After the tstate is unlinked, release_sentinel is called with the
- * weakref-to-lock (on_delete_data) argument, and release_sentinel releases
- * the indirectly held lock.
- */
- void (*on_delete)(void *);
- void *on_delete_data;
-
- int coroutine_origin_tracking_depth;
-
- PyObject *coroutine_wrapper;
- int in_coroutine_wrapper;
-
- PyObject *async_gen_firstiter;
- PyObject *async_gen_finalizer;
-
- PyObject *context;
- uint64_t context_ver;
-
- /* Unique thread state id. */
- uint64_t id;
-
- /* XXX signal handlers should also be here */
-
-} PyThreadState;
-#endif /* !Py_LIMITED_API */
-
-
-PyAPI_FUNC(PyInterpreterState *) PyInterpreterState_New(void);
-PyAPI_FUNC(void) PyInterpreterState_Clear(PyInterpreterState *);
-PyAPI_FUNC(void) PyInterpreterState_Delete(PyInterpreterState *);
-#if !defined(Py_LIMITED_API) || Py_LIMITED_API+0 >= 0x03070000
-/* New in 3.7 */
-PyAPI_FUNC(int64_t) PyInterpreterState_GetID(PyInterpreterState *);
-#endif
-#ifndef Py_LIMITED_API
-PyAPI_FUNC(int) _PyState_AddModule(PyObject*, struct PyModuleDef*);
-#endif /* !Py_LIMITED_API */
-#if !defined(Py_LIMITED_API) || Py_LIMITED_API+0 >= 0x03030000
-/* New in 3.3 */
-PyAPI_FUNC(int) PyState_AddModule(PyObject*, struct PyModuleDef*);
-PyAPI_FUNC(int) PyState_RemoveModule(struct PyModuleDef*);
-#endif
-PyAPI_FUNC(PyObject*) PyState_FindModule(struct PyModuleDef*);
-#ifndef Py_LIMITED_API
-PyAPI_FUNC(void) _PyState_ClearModules(void);
-#endif
-
-PyAPI_FUNC(PyThreadState *) PyThreadState_New(PyInterpreterState *);
-#ifndef Py_LIMITED_API
-PyAPI_FUNC(PyThreadState *) _PyThreadState_Prealloc(PyInterpreterState *);
-PyAPI_FUNC(void) _PyThreadState_Init(PyThreadState *);
-#endif /* !Py_LIMITED_API */
-PyAPI_FUNC(void) PyThreadState_Clear(PyThreadState *);
-PyAPI_FUNC(void) PyThreadState_Delete(PyThreadState *);
-#ifndef Py_LIMITED_API
-PyAPI_FUNC(void) _PyThreadState_DeleteExcept(PyThreadState *tstate);
-#endif /* !Py_LIMITED_API */
-PyAPI_FUNC(void) PyThreadState_DeleteCurrent(void);
-#ifndef Py_LIMITED_API
-PyAPI_FUNC(void) _PyGILState_Reinit(void);
-#endif /* !Py_LIMITED_API */
-
-/* Return the current thread state. The global interpreter lock must be held.
- * When the current thread state is NULL, this issues a fatal error (so that
- * the caller needn't check for NULL). */
-PyAPI_FUNC(PyThreadState *) PyThreadState_Get(void);
-
-#ifndef Py_LIMITED_API
-/* Similar to PyThreadState_Get(), but don't issue a fatal error
- * if it is NULL. */
-PyAPI_FUNC(PyThreadState *) _PyThreadState_UncheckedGet(void);
-#endif /* !Py_LIMITED_API */
-
-PyAPI_FUNC(PyThreadState *) PyThreadState_Swap(PyThreadState *);
-PyAPI_FUNC(PyObject *) PyThreadState_GetDict(void);
-PyAPI_FUNC(int) PyThreadState_SetAsyncExc(unsigned long, PyObject *);
-
-
-/* Variable and macro for in-line access to current thread state */
-
-/* Assuming the current thread holds the GIL, this is the
- PyThreadState for the current thread. */
-#ifdef Py_BUILD_CORE
-# define _PyThreadState_Current _PyRuntime.gilstate.tstate_current
-# define PyThreadState_GET() \
- ((PyThreadState*)_Py_atomic_load_relaxed(&_PyThreadState_Current))
-#else
-# define PyThreadState_GET() PyThreadState_Get()
-#endif
-
-typedef
- enum {PyGILState_LOCKED, PyGILState_UNLOCKED}
- PyGILState_STATE;
-
-
-/* Ensure that the current thread is ready to call the Python
- C API, regardless of the current state of Python, or of its
- thread lock. This may be called as many times as desired
- by a thread so long as each call is matched with a call to
- PyGILState_Release(). In general, other thread-state APIs may
- be used between _Ensure() and _Release() calls, so long as the
- thread-state is restored to its previous state before the Release().
- For example, normal use of the Py_BEGIN_ALLOW_THREADS/
- Py_END_ALLOW_THREADS macros are acceptable.
-
- The return value is an opaque "handle" to the thread state when
- PyGILState_Ensure() was called, and must be passed to
- PyGILState_Release() to ensure Python is left in the same state. Even
- though recursive calls are allowed, these handles can *not* be shared -
- each unique call to PyGILState_Ensure must save the handle for its
- call to PyGILState_Release.
-
- When the function returns, the current thread will hold the GIL.
-
- Failure is a fatal error.
-*/
-PyAPI_FUNC(PyGILState_STATE) PyGILState_Ensure(void);
-
-/* Release any resources previously acquired. After this call, Python's
- state will be the same as it was prior to the corresponding
- PyGILState_Ensure() call (but generally this state will be unknown to
- the caller, hence the use of the GILState API.)
-
- Every call to PyGILState_Ensure must be matched by a call to
- PyGILState_Release on the same thread.
-*/
-PyAPI_FUNC(void) PyGILState_Release(PyGILState_STATE);
-
-/* Helper/diagnostic function - get the current thread state for
- this thread. May return NULL if no GILState API has been used
- on the current thread. Note that the main thread always has such a
- thread-state, even if no auto-thread-state call has been made
- on the main thread.
-*/
-PyAPI_FUNC(PyThreadState *) PyGILState_GetThisThreadState(void);
-
-#ifndef Py_LIMITED_API
-/* Helper/diagnostic function - return 1 if the current thread
- currently holds the GIL, 0 otherwise.
-
- The function returns 1 if _PyGILState_check_enabled is non-zero. */
-PyAPI_FUNC(int) PyGILState_Check(void);
-
-/* Unsafe function to get the single PyInterpreterState used by this process'
- GILState implementation.
-
- Return NULL before _PyGILState_Init() is called and after _PyGILState_Fini()
- is called. */
-PyAPI_FUNC(PyInterpreterState *) _PyGILState_GetInterpreterStateUnsafe(void);
-#endif /* !Py_LIMITED_API */
-
-
-/* The implementation of sys._current_frames() Returns a dict mapping
- thread id to that thread's current frame.
-*/
-#ifndef Py_LIMITED_API
-PyAPI_FUNC(PyObject *) _PyThread_CurrentFrames(void);
-#endif
-
-/* Routines for advanced debuggers, requested by David Beazley.
- Don't use unless you know what you are doing! */
-#ifndef Py_LIMITED_API
-PyAPI_FUNC(PyInterpreterState *) PyInterpreterState_Main(void);
-PyAPI_FUNC(PyInterpreterState *) PyInterpreterState_Head(void);
-PyAPI_FUNC(PyInterpreterState *) PyInterpreterState_Next(PyInterpreterState *);
-PyAPI_FUNC(PyThreadState *) PyInterpreterState_ThreadHead(PyInterpreterState *);
-PyAPI_FUNC(PyThreadState *) PyThreadState_Next(PyThreadState *);
-
-typedef struct _frame *(*PyThreadFrameGetter)(PyThreadState *self_);
-#endif
-
-#ifdef __cplusplus
-}
-#endif
-#endif /* !Py_PYSTATE_H */
diff --git a/pythonsdk/include/pystrcmp.h b/pythonsdk/include/pystrcmp.h
deleted file mode 100644
index eccabdce0b69d1961784a4d9c5b7f845e48be0dd..0000000000000000000000000000000000000000
--- a/pythonsdk/include/pystrcmp.h
+++ /dev/null
@@ -1,23 +0,0 @@
-#ifndef Py_STRCMP_H
-#define Py_STRCMP_H
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-PyAPI_FUNC(int) PyOS_mystrnicmp(const char *, const char *, Py_ssize_t);
-PyAPI_FUNC(int) PyOS_mystricmp(const char *, const char *);
-
-#ifdef MS_WINDOWS
-#define PyOS_strnicmp strnicmp
-#define PyOS_stricmp stricmp
-#else
-#define PyOS_strnicmp PyOS_mystrnicmp
-#define PyOS_stricmp PyOS_mystricmp
-#endif
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif /* !Py_STRCMP_H */
diff --git a/pythonsdk/include/pystrhex.h b/pythonsdk/include/pystrhex.h
deleted file mode 100644
index 1ce3a5edc7385f061f3b45c8857429dbbf0f7fde..0000000000000000000000000000000000000000
--- a/pythonsdk/include/pystrhex.h
+++ /dev/null
@@ -1,19 +0,0 @@
-#ifndef Py_STRHEX_H
-#define Py_STRHEX_H
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-#ifndef Py_LIMITED_API
-/* Returns a str() containing the hex representation of argbuf. */
-PyAPI_FUNC(PyObject*) _Py_strhex(const char* argbuf, const Py_ssize_t arglen);
-/* Returns a bytes() containing the ASCII hex representation of argbuf. */
-PyAPI_FUNC(PyObject*) _Py_strhex_bytes(const char* argbuf, const Py_ssize_t arglen);
-#endif /* !Py_LIMITED_API */
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif /* !Py_STRHEX_H */
diff --git a/pythonsdk/include/pystrtod.h b/pythonsdk/include/pystrtod.h
deleted file mode 100644
index ba2e8d00f589f513afe661aba1d413793a773e4a..0000000000000000000000000000000000000000
--- a/pythonsdk/include/pystrtod.h
+++ /dev/null
@@ -1,45 +0,0 @@
-#ifndef Py_STRTOD_H
-#define Py_STRTOD_H
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-
-PyAPI_FUNC(double) PyOS_string_to_double(const char *str,
- char **endptr,
- PyObject *overflow_exception);
-
-/* The caller is responsible for calling PyMem_Free to free the buffer
- that's is returned. */
-PyAPI_FUNC(char *) PyOS_double_to_string(double val,
- char format_code,
- int precision,
- int flags,
- int *type);
-
-#ifndef Py_LIMITED_API
-PyAPI_FUNC(PyObject *) _Py_string_to_number_with_underscores(
- const char *str, Py_ssize_t len, const char *what, PyObject *obj, void *arg,
- PyObject *(*innerfunc)(const char *, Py_ssize_t, void *));
-
-PyAPI_FUNC(double) _Py_parse_inf_or_nan(const char *p, char **endptr);
-#endif
-
-
-/* PyOS_double_to_string's "flags" parameter can be set to 0 or more of: */
-#define Py_DTSF_SIGN 0x01 /* always add the sign */
-#define Py_DTSF_ADD_DOT_0 0x02 /* if the result is an integer add ".0" */
-#define Py_DTSF_ALT 0x04 /* "alternate" formatting. it's format_code
- specific */
-
-/* PyOS_double_to_string's "type", if non-NULL, will be set to one of: */
-#define Py_DTST_FINITE 0
-#define Py_DTST_INFINITE 1
-#define Py_DTST_NAN 2
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif /* !Py_STRTOD_H */
diff --git a/pythonsdk/include/pythonrun.h b/pythonsdk/include/pythonrun.h
deleted file mode 100644
index 818cef22d1b3d701e61c9a08856c247e1fe0c71c..0000000000000000000000000000000000000000
--- a/pythonsdk/include/pythonrun.h
+++ /dev/null
@@ -1,181 +0,0 @@
-
-/* Interfaces to parse and execute pieces of python code */
-
-#ifndef Py_PYTHONRUN_H
-#define Py_PYTHONRUN_H
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-#ifndef Py_LIMITED_API
-PyAPI_FUNC(int) PyRun_SimpleStringFlags(const char *, PyCompilerFlags *);
-PyAPI_FUNC(int) PyRun_AnyFileFlags(FILE *, const char *, PyCompilerFlags *);
-PyAPI_FUNC(int) PyRun_AnyFileExFlags(
- FILE *fp,
- const char *filename, /* decoded from the filesystem encoding */
- int closeit,
- PyCompilerFlags *flags);
-PyAPI_FUNC(int) PyRun_SimpleFileExFlags(
- FILE *fp,
- const char *filename, /* decoded from the filesystem encoding */
- int closeit,
- PyCompilerFlags *flags);
-PyAPI_FUNC(int) PyRun_InteractiveOneFlags(
- FILE *fp,
- const char *filename, /* decoded from the filesystem encoding */
- PyCompilerFlags *flags);
-PyAPI_FUNC(int) PyRun_InteractiveOneObject(
- FILE *fp,
- PyObject *filename,
- PyCompilerFlags *flags);
-PyAPI_FUNC(int) PyRun_InteractiveLoopFlags(
- FILE *fp,
- const char *filename, /* decoded from the filesystem encoding */
- PyCompilerFlags *flags);
-
-PyAPI_FUNC(struct _mod *) PyParser_ASTFromString(
- const char *s,
- const char *filename, /* decoded from the filesystem encoding */
- int start,
- PyCompilerFlags *flags,
- PyArena *arena);
-PyAPI_FUNC(struct _mod *) PyParser_ASTFromStringObject(
- const char *s,
- PyObject *filename,
- int start,
- PyCompilerFlags *flags,
- PyArena *arena);
-PyAPI_FUNC(struct _mod *) PyParser_ASTFromFile(
- FILE *fp,
- const char *filename, /* decoded from the filesystem encoding */
- const char* enc,
- int start,
- const char *ps1,
- const char *ps2,
- PyCompilerFlags *flags,
- int *errcode,
- PyArena *arena);
-PyAPI_FUNC(struct _mod *) PyParser_ASTFromFileObject(
- FILE *fp,
- PyObject *filename,
- const char* enc,
- int start,
- const char *ps1,
- const char *ps2,
- PyCompilerFlags *flags,
- int *errcode,
- PyArena *arena);
-#endif
-
-#ifndef PyParser_SimpleParseString
-#define PyParser_SimpleParseString(S, B) \
- PyParser_SimpleParseStringFlags(S, B, 0)
-#define PyParser_SimpleParseFile(FP, S, B) \
- PyParser_SimpleParseFileFlags(FP, S, B, 0)
-#endif
-PyAPI_FUNC(struct _node *) PyParser_SimpleParseStringFlags(const char *, int,
- int);
-#if !defined(Py_LIMITED_API) || Py_LIMITED_API+0 >= 0x03030000
-PyAPI_FUNC(struct _node *) PyParser_SimpleParseStringFlagsFilename(const char *,
- const char *,
- int, int);
-#endif
-PyAPI_FUNC(struct _node *) PyParser_SimpleParseFileFlags(FILE *, const char *,
- int, int);
-
-#ifndef Py_LIMITED_API
-PyAPI_FUNC(PyObject *) PyRun_StringFlags(const char *, int, PyObject *,
- PyObject *, PyCompilerFlags *);
-
-PyAPI_FUNC(PyObject *) PyRun_FileExFlags(
- FILE *fp,
- const char *filename, /* decoded from the filesystem encoding */
- int start,
- PyObject *globals,
- PyObject *locals,
- int closeit,
- PyCompilerFlags *flags);
-#endif
-
-#ifdef Py_LIMITED_API
-PyAPI_FUNC(PyObject *) Py_CompileString(const char *, const char *, int);
-#else
-#define Py_CompileString(str, p, s) Py_CompileStringExFlags(str, p, s, NULL, -1)
-#define Py_CompileStringFlags(str, p, s, f) Py_CompileStringExFlags(str, p, s, f, -1)
-PyAPI_FUNC(PyObject *) Py_CompileStringExFlags(
- const char *str,
- const char *filename, /* decoded from the filesystem encoding */
- int start,
- PyCompilerFlags *flags,
- int optimize);
-PyAPI_FUNC(PyObject *) Py_CompileStringObject(
- const char *str,
- PyObject *filename, int start,
- PyCompilerFlags *flags,
- int optimize);
-#endif
-PyAPI_FUNC(struct symtable *) Py_SymtableString(
- const char *str,
- const char *filename, /* decoded from the filesystem encoding */
- int start);
-#ifndef Py_LIMITED_API
-PyAPI_FUNC(struct symtable *) Py_SymtableStringObject(
- const char *str,
- PyObject *filename,
- int start);
-#endif
-
-PyAPI_FUNC(void) PyErr_Print(void);
-PyAPI_FUNC(void) PyErr_PrintEx(int);
-PyAPI_FUNC(void) PyErr_Display(PyObject *, PyObject *, PyObject *);
-
-#ifndef Py_LIMITED_API
-/* Use macros for a bunch of old variants */
-#define PyRun_String(str, s, g, l) PyRun_StringFlags(str, s, g, l, NULL)
-#define PyRun_AnyFile(fp, name) PyRun_AnyFileExFlags(fp, name, 0, NULL)
-#define PyRun_AnyFileEx(fp, name, closeit) \
- PyRun_AnyFileExFlags(fp, name, closeit, NULL)
-#define PyRun_AnyFileFlags(fp, name, flags) \
- PyRun_AnyFileExFlags(fp, name, 0, flags)
-#define PyRun_SimpleString(s) PyRun_SimpleStringFlags(s, NULL)
-#define PyRun_SimpleFile(f, p) PyRun_SimpleFileExFlags(f, p, 0, NULL)
-#define PyRun_SimpleFileEx(f, p, c) PyRun_SimpleFileExFlags(f, p, c, NULL)
-#define PyRun_InteractiveOne(f, p) PyRun_InteractiveOneFlags(f, p, NULL)
-#define PyRun_InteractiveLoop(f, p) PyRun_InteractiveLoopFlags(f, p, NULL)
-#define PyRun_File(fp, p, s, g, l) \
- PyRun_FileExFlags(fp, p, s, g, l, 0, NULL)
-#define PyRun_FileEx(fp, p, s, g, l, c) \
- PyRun_FileExFlags(fp, p, s, g, l, c, NULL)
-#define PyRun_FileFlags(fp, p, s, g, l, flags) \
- PyRun_FileExFlags(fp, p, s, g, l, 0, flags)
-#endif
-
-/* Stuff with no proper home (yet) */
-#ifndef Py_LIMITED_API
-PyAPI_FUNC(char *) PyOS_Readline(FILE *, FILE *, const char *);
-#endif
-PyAPI_DATA(int) (*PyOS_InputHook)(void);
-PyAPI_DATA(char) *(*PyOS_ReadlineFunctionPointer)(FILE *, FILE *, const char *);
-#ifndef Py_LIMITED_API
-PyAPI_DATA(PyThreadState*) _PyOS_ReadlineTState;
-#endif
-
-/* Stack size, in "pointers" (so we get extra safety margins
- on 64-bit platforms). On a 32-bit platform, this translates
- to an 8k margin. */
-#define PYOS_STACK_MARGIN 2048
-
-#if defined(WIN32) && !defined(MS_WIN64) && defined(_MSC_VER) && _MSC_VER >= 1300
-/* Enable stack checking under Microsoft C */
-#define USE_STACKCHECK
-#endif
-
-#ifdef USE_STACKCHECK
-/* Check that we aren't overflowing our stack */
-PyAPI_FUNC(int) PyOS_CheckStack(void);
-#endif
-
-#ifdef __cplusplus
-}
-#endif
-#endif /* !Py_PYTHONRUN_H */
diff --git a/pythonsdk/include/pythread.h b/pythonsdk/include/pythread.h
deleted file mode 100644
index a1e37fb3db4c67a24a3f3cfaccc2c554218cc5b4..0000000000000000000000000000000000000000
--- a/pythonsdk/include/pythread.h
+++ /dev/null
@@ -1,155 +0,0 @@
-
-#ifndef Py_PYTHREAD_H
-#define Py_PYTHREAD_H
-
-typedef void *PyThread_type_lock;
-typedef void *PyThread_type_sema;
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-/* Return status codes for Python lock acquisition. Chosen for maximum
- * backwards compatibility, ie failure -> 0, success -> 1. */
-typedef enum PyLockStatus {
- PY_LOCK_FAILURE = 0,
- PY_LOCK_ACQUIRED = 1,
- PY_LOCK_INTR
-} PyLockStatus;
-
-#ifndef Py_LIMITED_API
-#define PYTHREAD_INVALID_THREAD_ID ((unsigned long)-1)
-#endif
-
-PyAPI_FUNC(void) PyThread_init_thread(void);
-PyAPI_FUNC(unsigned long) PyThread_start_new_thread(void (*)(void *), void *);
-PyAPI_FUNC(void) PyThread_exit_thread(void);
-PyAPI_FUNC(unsigned long) PyThread_get_thread_ident(void);
-
-PyAPI_FUNC(PyThread_type_lock) PyThread_allocate_lock(void);
-PyAPI_FUNC(void) PyThread_free_lock(PyThread_type_lock);
-PyAPI_FUNC(int) PyThread_acquire_lock(PyThread_type_lock, int);
-#define WAIT_LOCK 1
-#define NOWAIT_LOCK 0
-
-/* PY_TIMEOUT_T is the integral type used to specify timeouts when waiting
- on a lock (see PyThread_acquire_lock_timed() below).
- PY_TIMEOUT_MAX is the highest usable value (in microseconds) of that
- type, and depends on the system threading API.
-
- NOTE: this isn't the same value as `_thread.TIMEOUT_MAX`. The _thread
- module exposes a higher-level API, with timeouts expressed in seconds
- and floating-point numbers allowed.
-*/
-#define PY_TIMEOUT_T long long
-
-#if defined(_POSIX_THREADS)
- /* PyThread_acquire_lock_timed() uses _PyTime_FromNanoseconds(us * 1000),
- convert microseconds to nanoseconds. */
-# define PY_TIMEOUT_MAX (PY_LLONG_MAX / 1000)
-#elif defined (NT_THREADS)
- /* In the NT API, the timeout is a DWORD and is expressed in milliseconds */
-# if 0xFFFFFFFFLL * 1000 < PY_LLONG_MAX
-# define PY_TIMEOUT_MAX (0xFFFFFFFFLL * 1000)
-# else
-# define PY_TIMEOUT_MAX PY_LLONG_MAX
-# endif
-#else
-# define PY_TIMEOUT_MAX PY_LLONG_MAX
-#endif
-
-
-/* If microseconds == 0, the call is non-blocking: it returns immediately
- even when the lock can't be acquired.
- If microseconds > 0, the call waits up to the specified duration.
- If microseconds < 0, the call waits until success (or abnormal failure)
-
- microseconds must be less than PY_TIMEOUT_MAX. Behaviour otherwise is
- undefined.
-
- If intr_flag is true and the acquire is interrupted by a signal, then the
- call will return PY_LOCK_INTR. The caller may reattempt to acquire the
- lock.
-*/
-PyAPI_FUNC(PyLockStatus) PyThread_acquire_lock_timed(PyThread_type_lock,
- PY_TIMEOUT_T microseconds,
- int intr_flag);
-
-PyAPI_FUNC(void) PyThread_release_lock(PyThread_type_lock);
-
-PyAPI_FUNC(size_t) PyThread_get_stacksize(void);
-PyAPI_FUNC(int) PyThread_set_stacksize(size_t);
-
-#if !defined(Py_LIMITED_API) || Py_LIMITED_API+0 >= 0x03030000
-PyAPI_FUNC(PyObject*) PyThread_GetInfo(void);
-#endif
-
-
-/* Thread Local Storage (TLS) API
- TLS API is DEPRECATED. Use Thread Specific Storage (TSS) API.
-
- The existing TLS API has used int to represent TLS keys across all
- platforms, but it is not POSIX-compliant. Therefore, the new TSS API uses
- opaque data type to represent TSS keys to be compatible (see PEP 539).
-*/
-PyAPI_FUNC(int) PyThread_create_key(void) Py_DEPRECATED(3.7);
-PyAPI_FUNC(void) PyThread_delete_key(int key) Py_DEPRECATED(3.7);
-PyAPI_FUNC(int) PyThread_set_key_value(int key, void *value) Py_DEPRECATED(3.7);
-PyAPI_FUNC(void *) PyThread_get_key_value(int key) Py_DEPRECATED(3.7);
-PyAPI_FUNC(void) PyThread_delete_key_value(int key) Py_DEPRECATED(3.7);
-
-/* Cleanup after a fork */
-PyAPI_FUNC(void) PyThread_ReInitTLS(void) Py_DEPRECATED(3.7);
-
-
-#if !defined(Py_LIMITED_API) || Py_LIMITED_API+0 >= 0x03070000
-/* New in 3.7 */
-/* Thread Specific Storage (TSS) API */
-
-typedef struct _Py_tss_t Py_tss_t; /* opaque */
-
-#ifndef Py_LIMITED_API
-#if defined(_POSIX_THREADS)
- /* Darwin needs pthread.h to know type name the pthread_key_t. */
-# include <pthread.h>
-# define NATIVE_TSS_KEY_T pthread_key_t
-#elif defined(NT_THREADS)
- /* In Windows, native TSS key type is DWORD,
- but hardcode the unsigned long to avoid errors for include directive.
- */
-# define NATIVE_TSS_KEY_T unsigned long
-#else
-# error "Require native threads. See https://bugs.python.org/issue31370"
-#endif
-
-/* When Py_LIMITED_API is not defined, the type layout of Py_tss_t is
- exposed to allow static allocation in the API clients. Even in this case,
- you must handle TSS keys through API functions due to compatibility.
-*/
-struct _Py_tss_t {
- int _is_initialized;
- NATIVE_TSS_KEY_T _key;
-};
-
-#undef NATIVE_TSS_KEY_T
-
-/* When static allocation, you must initialize with Py_tss_NEEDS_INIT. */
-#define Py_tss_NEEDS_INIT {0}
-#endif /* !Py_LIMITED_API */
-
-PyAPI_FUNC(Py_tss_t *) PyThread_tss_alloc(void);
-PyAPI_FUNC(void) PyThread_tss_free(Py_tss_t *key);
-
-/* The parameter key must not be NULL. */
-PyAPI_FUNC(int) PyThread_tss_is_created(Py_tss_t *key);
-PyAPI_FUNC(int) PyThread_tss_create(Py_tss_t *key);
-PyAPI_FUNC(void) PyThread_tss_delete(Py_tss_t *key);
-PyAPI_FUNC(int) PyThread_tss_set(Py_tss_t *key, void *value);
-PyAPI_FUNC(void *) PyThread_tss_get(Py_tss_t *key);
-#endif /* New in 3.7 */
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif /* !Py_PYTHREAD_H */
diff --git a/pythonsdk/include/pytime.h b/pythonsdk/include/pytime.h
deleted file mode 100644
index dde92ee0b5e9c25b4ebea9ee78c69d48ce2e0b80..0000000000000000000000000000000000000000
--- a/pythonsdk/include/pytime.h
+++ /dev/null
@@ -1,246 +0,0 @@
-#ifndef Py_LIMITED_API
-#ifndef Py_PYTIME_H
-#define Py_PYTIME_H
-
-#include "pyconfig.h" /* include for defines */
-#include "object.h"
-
-/**************************************************************************
-Symbols and macros to supply platform-independent interfaces to time related
-functions and constants
-**************************************************************************/
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-/* _PyTime_t: Python timestamp with subsecond precision. It can be used to
- store a duration, and so indirectly a date (related to another date, like
- UNIX epoch). */
-typedef int64_t _PyTime_t;
-#define _PyTime_MIN INT64_MIN
-#define _PyTime_MAX INT64_MAX
-
-typedef enum {
- /* Round towards minus infinity (-inf).
- For example, used to read a clock. */
- _PyTime_ROUND_FLOOR=0,
- /* Round towards infinity (+inf).
- For example, used for timeout to wait "at least" N seconds. */
- _PyTime_ROUND_CEILING=1,
- /* Round to nearest with ties going to nearest even integer.
- For example, used to round from a Python float. */
- _PyTime_ROUND_HALF_EVEN=2,
- /* Round away from zero
- For example, used for timeout. _PyTime_ROUND_CEILING rounds
- -1e-9 to 0 milliseconds which causes bpo-31786 issue.
- _PyTime_ROUND_UP rounds -1e-9 to -1 millisecond which keeps
- the timeout sign as expected. select.poll(timeout) must block
- for negative values." */
- _PyTime_ROUND_UP=3,
- /* _PyTime_ROUND_TIMEOUT (an alias for _PyTime_ROUND_UP) should be
- used for timeouts. */
- _PyTime_ROUND_TIMEOUT = _PyTime_ROUND_UP
-} _PyTime_round_t;
-
-
-/* Convert a time_t to a PyLong. */
-PyAPI_FUNC(PyObject *) _PyLong_FromTime_t(
- time_t sec);
-
-/* Convert a PyLong to a time_t. */
-PyAPI_FUNC(time_t) _PyLong_AsTime_t(
- PyObject *obj);
-
-/* Convert a number of seconds, int or float, to time_t. */
-PyAPI_FUNC(int) _PyTime_ObjectToTime_t(
- PyObject *obj,
- time_t *sec,
- _PyTime_round_t);
-
-/* Convert a number of seconds, int or float, to a timeval structure.
- usec is in the range [0; 999999] and rounded towards zero.
- For example, -1.2 is converted to (-2, 800000). */
-PyAPI_FUNC(int) _PyTime_ObjectToTimeval(
- PyObject *obj,
- time_t *sec,
- long *usec,
- _PyTime_round_t);
-
-/* Convert a number of seconds, int or float, to a timespec structure.
- nsec is in the range [0; 999999999] and rounded towards zero.
- For example, -1.2 is converted to (-2, 800000000). */
-PyAPI_FUNC(int) _PyTime_ObjectToTimespec(
- PyObject *obj,
- time_t *sec,
- long *nsec,
- _PyTime_round_t);
-
-
-/* Create a timestamp from a number of seconds. */
-PyAPI_FUNC(_PyTime_t) _PyTime_FromSeconds(int seconds);
-
-/* Macro to create a timestamp from a number of seconds, no integer overflow.
- Only use the macro for small values, prefer _PyTime_FromSeconds(). */
-#define _PYTIME_FROMSECONDS(seconds) \
- ((_PyTime_t)(seconds) * (1000 * 1000 * 1000))
-
-/* Create a timestamp from a number of nanoseconds. */
-PyAPI_FUNC(_PyTime_t) _PyTime_FromNanoseconds(_PyTime_t ns);
-
-/* Create a timestamp from nanoseconds (Python int). */
-PyAPI_FUNC(int) _PyTime_FromNanosecondsObject(_PyTime_t *t,
- PyObject *obj);
-
-/* Convert a number of seconds (Python float or int) to a timetamp.
- Raise an exception and return -1 on error, return 0 on success. */
-PyAPI_FUNC(int) _PyTime_FromSecondsObject(_PyTime_t *t,
- PyObject *obj,
- _PyTime_round_t round);
-
-/* Convert a number of milliseconds (Python float or int, 10^-3) to a timetamp.
- Raise an exception and return -1 on error, return 0 on success. */
-PyAPI_FUNC(int) _PyTime_FromMillisecondsObject(_PyTime_t *t,
- PyObject *obj,
- _PyTime_round_t round);
-
-/* Convert a timestamp to a number of seconds as a C double. */
-PyAPI_FUNC(double) _PyTime_AsSecondsDouble(_PyTime_t t);
-
-/* Convert timestamp to a number of milliseconds (10^-3 seconds). */
-PyAPI_FUNC(_PyTime_t) _PyTime_AsMilliseconds(_PyTime_t t,
- _PyTime_round_t round);
-
-/* Convert timestamp to a number of microseconds (10^-6 seconds). */
-PyAPI_FUNC(_PyTime_t) _PyTime_AsMicroseconds(_PyTime_t t,
- _PyTime_round_t round);
-
-/* Convert timestamp to a number of nanoseconds (10^-9 seconds) as a Python int
- object. */
-PyAPI_FUNC(PyObject *) _PyTime_AsNanosecondsObject(_PyTime_t t);
-
-/* Create a timestamp from a timeval structure.
- Raise an exception and return -1 on overflow, return 0 on success. */
-PyAPI_FUNC(int) _PyTime_FromTimeval(_PyTime_t *tp, struct timeval *tv);
-
-/* Convert a timestamp to a timeval structure (microsecond resolution).
- tv_usec is always positive.
- Raise an exception and return -1 if the conversion overflowed,
- return 0 on success. */
-PyAPI_FUNC(int) _PyTime_AsTimeval(_PyTime_t t,
- struct timeval *tv,
- _PyTime_round_t round);
-
-/* Similar to _PyTime_AsTimeval(), but don't raise an exception on error. */
-PyAPI_FUNC(int) _PyTime_AsTimeval_noraise(_PyTime_t t,
- struct timeval *tv,
- _PyTime_round_t round);
-
-/* Convert a timestamp to a number of seconds (secs) and microseconds (us).
- us is always positive. This function is similar to _PyTime_AsTimeval()
- except that secs is always a time_t type, whereas the timeval structure
- uses a C long for tv_sec on Windows.
- Raise an exception and return -1 if the conversion overflowed,
- return 0 on success. */
-PyAPI_FUNC(int) _PyTime_AsTimevalTime_t(
- _PyTime_t t,
- time_t *secs,
- int *us,
- _PyTime_round_t round);
-
-#if defined(HAVE_CLOCK_GETTIME) || defined(HAVE_KQUEUE)
-/* Create a timestamp from a timespec structure.
- Raise an exception and return -1 on overflow, return 0 on success. */
-PyAPI_FUNC(int) _PyTime_FromTimespec(_PyTime_t *tp, struct timespec *ts);
-
-/* Convert a timestamp to a timespec structure (nanosecond resolution).
- tv_nsec is always positive.
- Raise an exception and return -1 on error, return 0 on success. */
-PyAPI_FUNC(int) _PyTime_AsTimespec(_PyTime_t t, struct timespec *ts);
-#endif
-
-/* Compute ticks * mul / div.
- The caller must ensure that ((div - 1) * mul) cannot overflow. */
-PyAPI_FUNC(_PyTime_t) _PyTime_MulDiv(_PyTime_t ticks,
- _PyTime_t mul,
- _PyTime_t div);
-
-/* Get the current time from the system clock.
-
- The function cannot fail. _PyTime_Init() ensures that the system clock
- works. */
-PyAPI_FUNC(_PyTime_t) _PyTime_GetSystemClock(void);
-
-/* Get the time of a monotonic clock, i.e. a clock that cannot go backwards.
- The clock is not affected by system clock updates. The reference point of
- the returned value is undefined, so that only the difference between the
- results of consecutive calls is valid.
-
- The function cannot fail. _PyTime_Init() ensures that a monotonic clock
- is available and works. */
-PyAPI_FUNC(_PyTime_t) _PyTime_GetMonotonicClock(void);
-
-
-/* Structure used by time.get_clock_info() */
-typedef struct {
- const char *implementation;
- int monotonic;
- int adjustable;
- double resolution;
-} _Py_clock_info_t;
-
-/* Get the current time from the system clock.
- * Fill clock information if info is not NULL.
- * Raise an exception and return -1 on error, return 0 on success.
- */
-PyAPI_FUNC(int) _PyTime_GetSystemClockWithInfo(
- _PyTime_t *t,
- _Py_clock_info_t *info);
-
-/* Get the time of a monotonic clock, i.e. a clock that cannot go backwards.
- The clock is not affected by system clock updates. The reference point of
- the returned value is undefined, so that only the difference between the
- results of consecutive calls is valid.
-
- Fill info (if set) with information of the function used to get the time.
-
- Return 0 on success, raise an exception and return -1 on error. */
-PyAPI_FUNC(int) _PyTime_GetMonotonicClockWithInfo(
- _PyTime_t *t,
- _Py_clock_info_t *info);
-
-
-/* Initialize time.
- Return 0 on success, raise an exception and return -1 on error. */
-PyAPI_FUNC(int) _PyTime_Init(void);
-
-/* Converts a timestamp to the Gregorian time, using the local time zone.
- Return 0 on success, raise an exception and return -1 on error. */
-PyAPI_FUNC(int) _PyTime_localtime(time_t t, struct tm *tm);
-
-/* Converts a timestamp to the Gregorian time, assuming UTC.
- Return 0 on success, raise an exception and return -1 on error. */
-PyAPI_FUNC(int) _PyTime_gmtime(time_t t, struct tm *tm);
-
-/* Get the performance counter: clock with the highest available resolution to
- measure a short duration.
-
- The function cannot fail. _PyTime_Init() ensures that the system clock
- works. */
-PyAPI_FUNC(_PyTime_t) _PyTime_GetPerfCounter(void);
-
-/* Get the performance counter: clock with the highest available resolution to
- measure a short duration.
-
- Fill info (if set) with information of the function used to get the time.
-
- Return 0 on success, raise an exception and return -1 on error. */
-PyAPI_FUNC(int) _PyTime_GetPerfCounterWithInfo(
- _PyTime_t *t,
- _Py_clock_info_t *info);
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif /* Py_PYTIME_H */
-#endif /* Py_LIMITED_API */
diff --git a/pythonsdk/include/rangeobject.h b/pythonsdk/include/rangeobject.h
deleted file mode 100644
index b9a136d0c47433d97980a1f37194bf9282d4f0b8..0000000000000000000000000000000000000000
--- a/pythonsdk/include/rangeobject.h
+++ /dev/null
@@ -1,27 +0,0 @@
-
-/* Range object interface */
-
-#ifndef Py_RANGEOBJECT_H
-#define Py_RANGEOBJECT_H
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-/*
-A range object represents an integer range. This is an immutable object;
-a range cannot change its value after creation.
-
-Range objects behave like the corresponding tuple objects except that
-they are represented by a start, stop, and step datamembers.
-*/
-
-PyAPI_DATA(PyTypeObject) PyRange_Type;
-PyAPI_DATA(PyTypeObject) PyRangeIter_Type;
-PyAPI_DATA(PyTypeObject) PyLongRangeIter_Type;
-
-#define PyRange_Check(op) (Py_TYPE(op) == &PyRange_Type)
-
-#ifdef __cplusplus
-}
-#endif
-#endif /* !Py_RANGEOBJECT_H */
diff --git a/pythonsdk/include/setobject.h b/pythonsdk/include/setobject.h
deleted file mode 100644
index b2f796396364c8d5337a8310aed4119531871c5c..0000000000000000000000000000000000000000
--- a/pythonsdk/include/setobject.h
+++ /dev/null
@@ -1,108 +0,0 @@
-/* Set object interface */
-
-#ifndef Py_SETOBJECT_H
-#define Py_SETOBJECT_H
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-#ifndef Py_LIMITED_API
-
-/* There are three kinds of entries in the table:
-
-1. Unused: key == NULL and hash == 0
-2. Dummy: key == dummy and hash == -1
-3. Active: key != NULL and key != dummy and hash != -1
-
-The hash field of Unused slots is always zero.
-
-The hash field of Dummy slots are set to -1
-meaning that dummy entries can be detected by
-either entry->key==dummy or by entry->hash==-1.
-*/
-
-#define PySet_MINSIZE 8
-
-typedef struct {
- PyObject *key;
- Py_hash_t hash; /* Cached hash code of the key */
-} setentry;
-
-/* The SetObject data structure is shared by set and frozenset objects.
-
-Invariant for sets:
- - hash is -1
-
-Invariants for frozensets:
- - data is immutable.
- - hash is the hash of the frozenset or -1 if not computed yet.
-
-*/
-
-typedef struct {
- PyObject_HEAD
-
- Py_ssize_t fill; /* Number active and dummy entries*/
- Py_ssize_t used; /* Number active entries */
-
- /* The table contains mask + 1 slots, and that's a power of 2.
- * We store the mask instead of the size because the mask is more
- * frequently needed.
- */
- Py_ssize_t mask;
-
- /* The table points to a fixed-size smalltable for small tables
- * or to additional malloc'ed memory for bigger tables.
- * The table pointer is never NULL which saves us from repeated
- * runtime null-tests.
- */
- setentry *table;
- Py_hash_t hash; /* Only used by frozenset objects */
- Py_ssize_t finger; /* Search finger for pop() */
-
- setentry smalltable[PySet_MINSIZE];
- PyObject *weakreflist; /* List of weak references */
-} PySetObject;
-
-#define PySet_GET_SIZE(so) (assert(PyAnySet_Check(so)),(((PySetObject *)(so))->used))
-
-PyAPI_DATA(PyObject *) _PySet_Dummy;
-
-PyAPI_FUNC(int) _PySet_NextEntry(PyObject *set, Py_ssize_t *pos, PyObject **key, Py_hash_t *hash);
-PyAPI_FUNC(int) _PySet_Update(PyObject *set, PyObject *iterable);
-PyAPI_FUNC(int) PySet_ClearFreeList(void);
-
-#endif /* Section excluded by Py_LIMITED_API */
-
-PyAPI_DATA(PyTypeObject) PySet_Type;
-PyAPI_DATA(PyTypeObject) PyFrozenSet_Type;
-PyAPI_DATA(PyTypeObject) PySetIter_Type;
-
-PyAPI_FUNC(PyObject *) PySet_New(PyObject *);
-PyAPI_FUNC(PyObject *) PyFrozenSet_New(PyObject *);
-
-PyAPI_FUNC(int) PySet_Add(PyObject *set, PyObject *key);
-PyAPI_FUNC(int) PySet_Clear(PyObject *set);
-PyAPI_FUNC(int) PySet_Contains(PyObject *anyset, PyObject *key);
-PyAPI_FUNC(int) PySet_Discard(PyObject *set, PyObject *key);
-PyAPI_FUNC(PyObject *) PySet_Pop(PyObject *set);
-PyAPI_FUNC(Py_ssize_t) PySet_Size(PyObject *anyset);
-
-#define PyFrozenSet_CheckExact(ob) (Py_TYPE(ob) == &PyFrozenSet_Type)
-#define PyAnySet_CheckExact(ob) \
- (Py_TYPE(ob) == &PySet_Type || Py_TYPE(ob) == &PyFrozenSet_Type)
-#define PyAnySet_Check(ob) \
- (Py_TYPE(ob) == &PySet_Type || Py_TYPE(ob) == &PyFrozenSet_Type || \
- PyType_IsSubtype(Py_TYPE(ob), &PySet_Type) || \
- PyType_IsSubtype(Py_TYPE(ob), &PyFrozenSet_Type))
-#define PySet_Check(ob) \
- (Py_TYPE(ob) == &PySet_Type || \
- PyType_IsSubtype(Py_TYPE(ob), &PySet_Type))
-#define PyFrozenSet_Check(ob) \
- (Py_TYPE(ob) == &PyFrozenSet_Type || \
- PyType_IsSubtype(Py_TYPE(ob), &PyFrozenSet_Type))
-
-#ifdef __cplusplus
-}
-#endif
-#endif /* !Py_SETOBJECT_H */
diff --git a/pythonsdk/include/sliceobject.h b/pythonsdk/include/sliceobject.h
deleted file mode 100644
index e0e68c22e36c841cc98e1c37d0eeb53479604bca..0000000000000000000000000000000000000000
--- a/pythonsdk/include/sliceobject.h
+++ /dev/null
@@ -1,63 +0,0 @@
-#ifndef Py_SLICEOBJECT_H
-#define Py_SLICEOBJECT_H
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-/* The unique ellipsis object "..." */
-
-PyAPI_DATA(PyObject) _Py_EllipsisObject; /* Don't use this directly */
-
-#define Py_Ellipsis (&_Py_EllipsisObject)
-
-/* Slice object interface */
-
-/*
-
-A slice object containing start, stop, and step data members (the
-names are from range). After much talk with Guido, it was decided to
-let these be any arbitrary python type. Py_None stands for omitted values.
-*/
-#ifndef Py_LIMITED_API
-typedef struct {
- PyObject_HEAD
- PyObject *start, *stop, *step; /* not NULL */
-} PySliceObject;
-#endif
-
-PyAPI_DATA(PyTypeObject) PySlice_Type;
-PyAPI_DATA(PyTypeObject) PyEllipsis_Type;
-
-#define PySlice_Check(op) (Py_TYPE(op) == &PySlice_Type)
-
-PyAPI_FUNC(PyObject *) PySlice_New(PyObject* start, PyObject* stop,
- PyObject* step);
-#ifndef Py_LIMITED_API
-PyAPI_FUNC(PyObject *) _PySlice_FromIndices(Py_ssize_t start, Py_ssize_t stop);
-PyAPI_FUNC(int) _PySlice_GetLongIndices(PySliceObject *self, PyObject *length,
- PyObject **start_ptr, PyObject **stop_ptr,
- PyObject **step_ptr);
-#endif
-PyAPI_FUNC(int) PySlice_GetIndices(PyObject *r, Py_ssize_t length,
- Py_ssize_t *start, Py_ssize_t *stop, Py_ssize_t *step);
-PyAPI_FUNC(int) PySlice_GetIndicesEx(PyObject *r, Py_ssize_t length,
- Py_ssize_t *start, Py_ssize_t *stop,
- Py_ssize_t *step, Py_ssize_t *slicelength) Py_DEPRECATED(3.7);
-
-#if !defined(Py_LIMITED_API) || (Py_LIMITED_API+0 >= 0x03050400 && Py_LIMITED_API+0 < 0x03060000) || Py_LIMITED_API+0 >= 0x03060100
-#define PySlice_GetIndicesEx(slice, length, start, stop, step, slicelen) ( \
- PySlice_Unpack((slice), (start), (stop), (step)) < 0 ? \
- ((*(slicelen) = 0), -1) : \
- ((*(slicelen) = PySlice_AdjustIndices((length), (start), (stop), *(step))), \
- 0))
-PyAPI_FUNC(int) PySlice_Unpack(PyObject *slice,
- Py_ssize_t *start, Py_ssize_t *stop, Py_ssize_t *step);
-PyAPI_FUNC(Py_ssize_t) PySlice_AdjustIndices(Py_ssize_t length,
- Py_ssize_t *start, Py_ssize_t *stop,
- Py_ssize_t step);
-#endif
-
-#ifdef __cplusplus
-}
-#endif
-#endif /* !Py_SLICEOBJECT_H */
diff --git a/pythonsdk/include/structmember.h b/pythonsdk/include/structmember.h
deleted file mode 100644
index af01afe72b6e8387b6e752ceae5cb4f7f84353db..0000000000000000000000000000000000000000
--- a/pythonsdk/include/structmember.h
+++ /dev/null
@@ -1,74 +0,0 @@
-#ifndef Py_STRUCTMEMBER_H
-#define Py_STRUCTMEMBER_H
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-
-/* Interface to map C struct members to Python object attributes */
-
-#include <stddef.h> /* For offsetof */
-
-/* An array of PyMemberDef structures defines the name, type and offset
- of selected members of a C structure. These can be read by
- PyMember_GetOne() and set by PyMember_SetOne() (except if their READONLY
- flag is set). The array must be terminated with an entry whose name
- pointer is NULL. */
-
-typedef struct PyMemberDef {
- const char *name;
- int type;
- Py_ssize_t offset;
- int flags;
- const char *doc;
-} PyMemberDef;
-
-/* Types */
-#define T_SHORT 0
-#define T_INT 1
-#define T_LONG 2
-#define T_FLOAT 3
-#define T_DOUBLE 4
-#define T_STRING 5
-#define T_OBJECT 6
-/* XXX the ordering here is weird for binary compatibility */
-#define T_CHAR 7 /* 1-character string */
-#define T_BYTE 8 /* 8-bit signed int */
-/* unsigned variants: */
-#define T_UBYTE 9
-#define T_USHORT 10
-#define T_UINT 11
-#define T_ULONG 12
-
-/* Added by Jack: strings contained in the structure */
-#define T_STRING_INPLACE 13
-
-/* Added by Lillo: bools contained in the structure (assumed char) */
-#define T_BOOL 14
-
-#define T_OBJECT_EX 16 /* Like T_OBJECT, but raises AttributeError
- when the value is NULL, instead of
- converting to None. */
-#define T_LONGLONG 17
-#define T_ULONGLONG 18
-
-#define T_PYSSIZET 19 /* Py_ssize_t */
-#define T_NONE 20 /* Value is always None */
-
-
-/* Flags */
-#define READONLY 1
-#define READ_RESTRICTED 2
-#define PY_WRITE_RESTRICTED 4
-#define RESTRICTED (READ_RESTRICTED | PY_WRITE_RESTRICTED)
-
-
-/* Current API, use this */
-PyAPI_FUNC(PyObject *) PyMember_GetOne(const char *, struct PyMemberDef *);
-PyAPI_FUNC(int) PyMember_SetOne(char *, struct PyMemberDef *, PyObject *);
-
-
-#ifdef __cplusplus
-}
-#endif
-#endif /* !Py_STRUCTMEMBER_H */
diff --git a/pythonsdk/include/structseq.h b/pythonsdk/include/structseq.h
deleted file mode 100644
index 3a6b2693a7e7dc8dcdc80ffac8ceca53ea6e1c17..0000000000000000000000000000000000000000
--- a/pythonsdk/include/structseq.h
+++ /dev/null
@@ -1,49 +0,0 @@
-
-/* Named tuple object interface */
-
-#ifndef Py_STRUCTSEQ_H
-#define Py_STRUCTSEQ_H
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-typedef struct PyStructSequence_Field {
- const char *name;
- const char *doc;
-} PyStructSequence_Field;
-
-typedef struct PyStructSequence_Desc {
- const char *name;
- const char *doc;
- struct PyStructSequence_Field *fields;
- int n_in_sequence;
-} PyStructSequence_Desc;
-
-extern char* PyStructSequence_UnnamedField;
-
-#ifndef Py_LIMITED_API
-PyAPI_FUNC(void) PyStructSequence_InitType(PyTypeObject *type,
- PyStructSequence_Desc *desc);
-PyAPI_FUNC(int) PyStructSequence_InitType2(PyTypeObject *type,
- PyStructSequence_Desc *desc);
-#endif
-PyAPI_FUNC(PyTypeObject*) PyStructSequence_NewType(PyStructSequence_Desc *desc);
-
-PyAPI_FUNC(PyObject *) PyStructSequence_New(PyTypeObject* type);
-
-#ifndef Py_LIMITED_API
-typedef PyTupleObject PyStructSequence;
-
-/* Macro, *only* to be used to fill in brand new objects */
-#define PyStructSequence_SET_ITEM(op, i, v) PyTuple_SET_ITEM(op, i, v)
-
-#define PyStructSequence_GET_ITEM(op, i) PyTuple_GET_ITEM(op, i)
-#endif
-
-PyAPI_FUNC(void) PyStructSequence_SetItem(PyObject*, Py_ssize_t, PyObject*);
-PyAPI_FUNC(PyObject*) PyStructSequence_GetItem(PyObject*, Py_ssize_t);
-
-#ifdef __cplusplus
-}
-#endif
-#endif /* !Py_STRUCTSEQ_H */
diff --git a/pythonsdk/include/symtable.h b/pythonsdk/include/symtable.h
deleted file mode 100644
index 1fb0db63ef3c15f62383419f1320d4d909b09990..0000000000000000000000000000000000000000
--- a/pythonsdk/include/symtable.h
+++ /dev/null
@@ -1,118 +0,0 @@
-#ifndef Py_LIMITED_API
-#ifndef Py_SYMTABLE_H
-#define Py_SYMTABLE_H
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-/* XXX(ncoghlan): This is a weird mix of public names and interpreter internal
- * names.
- */
-
-typedef enum _block_type { FunctionBlock, ClassBlock, ModuleBlock }
- _Py_block_ty;
-
-struct _symtable_entry;
-
-struct symtable {
- PyObject *st_filename; /* name of file being compiled,
- decoded from the filesystem encoding */
- struct _symtable_entry *st_cur; /* current symbol table entry */
- struct _symtable_entry *st_top; /* symbol table entry for module */
- PyObject *st_blocks; /* dict: map AST node addresses
- * to symbol table entries */
- PyObject *st_stack; /* list: stack of namespace info */
- PyObject *st_global; /* borrowed ref to st_top->ste_symbols */
- int st_nblocks; /* number of blocks used. kept for
- consistency with the corresponding
- compiler structure */
- PyObject *st_private; /* name of current class or NULL */
- PyFutureFeatures *st_future; /* module's future features that affect
- the symbol table */
- int recursion_depth; /* current recursion depth */
- int recursion_limit; /* recursion limit */
-};
-
-typedef struct _symtable_entry {
- PyObject_HEAD
- PyObject *ste_id; /* int: key in ste_table->st_blocks */
- PyObject *ste_symbols; /* dict: variable names to flags */
- PyObject *ste_name; /* string: name of current block */
- PyObject *ste_varnames; /* list of function parameters */
- PyObject *ste_children; /* list of child blocks */
- PyObject *ste_directives;/* locations of global and nonlocal statements */
- _Py_block_ty ste_type; /* module, class, or function */
- int ste_nested; /* true if block is nested */
- unsigned ste_free : 1; /* true if block has free variables */
- unsigned ste_child_free : 1; /* true if a child block has free vars,
- including free refs to globals */
- unsigned ste_generator : 1; /* true if namespace is a generator */
- unsigned ste_coroutine : 1; /* true if namespace is a coroutine */
- unsigned ste_varargs : 1; /* true if block has varargs */
- unsigned ste_varkeywords : 1; /* true if block has varkeywords */
- unsigned ste_returns_value : 1; /* true if namespace uses return with
- an argument */
- unsigned ste_needs_class_closure : 1; /* for class scopes, true if a
- closure over __class__
- should be created */
- int ste_lineno; /* first line of block */
- int ste_col_offset; /* offset of first line of block */
- int ste_opt_lineno; /* lineno of last exec or import * */
- int ste_opt_col_offset; /* offset of last exec or import * */
- struct symtable *ste_table;
-} PySTEntryObject;
-
-PyAPI_DATA(PyTypeObject) PySTEntry_Type;
-
-#define PySTEntry_Check(op) (Py_TYPE(op) == &PySTEntry_Type)
-
-PyAPI_FUNC(int) PyST_GetScope(PySTEntryObject *, PyObject *);
-
-PyAPI_FUNC(struct symtable *) PySymtable_Build(
- mod_ty mod,
- const char *filename, /* decoded from the filesystem encoding */
- PyFutureFeatures *future);
-PyAPI_FUNC(struct symtable *) PySymtable_BuildObject(
- mod_ty mod,
- PyObject *filename,
- PyFutureFeatures *future);
-PyAPI_FUNC(PySTEntryObject *) PySymtable_Lookup(struct symtable *, void *);
-
-PyAPI_FUNC(void) PySymtable_Free(struct symtable *);
-
-/* Flags for def-use information */
-
-#define DEF_GLOBAL 1 /* global stmt */
-#define DEF_LOCAL 2 /* assignment in code block */
-#define DEF_PARAM 2<<1 /* formal parameter */
-#define DEF_NONLOCAL 2<<2 /* nonlocal stmt */
-#define USE 2<<3 /* name is used */
-#define DEF_FREE 2<<4 /* name used but not defined in nested block */
-#define DEF_FREE_CLASS 2<<5 /* free variable from class's method */
-#define DEF_IMPORT 2<<6 /* assignment occurred via import */
-#define DEF_ANNOT 2<<7 /* this name is annotated */
-
-#define DEF_BOUND (DEF_LOCAL | DEF_PARAM | DEF_IMPORT)
-
-/* GLOBAL_EXPLICIT and GLOBAL_IMPLICIT are used internally by the symbol
- table. GLOBAL is returned from PyST_GetScope() for either of them.
- It is stored in ste_symbols at bits 12-15.
-*/
-#define SCOPE_OFFSET 11
-#define SCOPE_MASK (DEF_GLOBAL | DEF_LOCAL | DEF_PARAM | DEF_NONLOCAL)
-
-#define LOCAL 1
-#define GLOBAL_EXPLICIT 2
-#define GLOBAL_IMPLICIT 3
-#define FREE 4
-#define CELL 5
-
-#define GENERATOR 1
-#define GENERATOR_EXPRESSION 2
-
-#ifdef __cplusplus
-}
-#endif
-#endif /* !Py_SYMTABLE_H */
-#endif /* Py_LIMITED_API */
diff --git a/pythonsdk/include/sysmodule.h b/pythonsdk/include/sysmodule.h
deleted file mode 100644
index 29a3ed9e3fe49bf47ad50e10d72b23a52f57f955..0000000000000000000000000000000000000000
--- a/pythonsdk/include/sysmodule.h
+++ /dev/null
@@ -1,48 +0,0 @@
-
-/* System module interface */
-
-#ifndef Py_SYSMODULE_H
-#define Py_SYSMODULE_H
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-PyAPI_FUNC(PyObject *) PySys_GetObject(const char *);
-PyAPI_FUNC(int) PySys_SetObject(const char *, PyObject *);
-#ifndef Py_LIMITED_API
-PyAPI_FUNC(PyObject *) _PySys_GetObjectId(_Py_Identifier *key);
-PyAPI_FUNC(int) _PySys_SetObjectId(_Py_Identifier *key, PyObject *);
-#endif
-
-PyAPI_FUNC(void) PySys_SetArgv(int, wchar_t **);
-PyAPI_FUNC(void) PySys_SetArgvEx(int, wchar_t **, int);
-PyAPI_FUNC(void) PySys_SetPath(const wchar_t *);
-
-PyAPI_FUNC(void) PySys_WriteStdout(const char *format, ...)
- Py_GCC_ATTRIBUTE((format(printf, 1, 2)));
-PyAPI_FUNC(void) PySys_WriteStderr(const char *format, ...)
- Py_GCC_ATTRIBUTE((format(printf, 1, 2)));
-PyAPI_FUNC(void) PySys_FormatStdout(const char *format, ...);
-PyAPI_FUNC(void) PySys_FormatStderr(const char *format, ...);
-
-PyAPI_FUNC(void) PySys_ResetWarnOptions(void);
-PyAPI_FUNC(void) PySys_AddWarnOption(const wchar_t *);
-PyAPI_FUNC(void) PySys_AddWarnOptionUnicode(PyObject *);
-PyAPI_FUNC(int) PySys_HasWarnOptions(void);
-
-PyAPI_FUNC(void) PySys_AddXOption(const wchar_t *);
-PyAPI_FUNC(PyObject *) PySys_GetXOptions(void);
-
-#ifndef Py_LIMITED_API
-PyAPI_FUNC(size_t) _PySys_GetSizeOf(PyObject *);
-#endif
-
-#ifdef Py_BUILD_CORE
-PyAPI_FUNC(int) _PySys_AddXOptionWithError(const wchar_t *s);
-PyAPI_FUNC(int) _PySys_AddWarnOptionWithError(PyObject *option);
-#endif
-
-#ifdef __cplusplus
-}
-#endif
-#endif /* !Py_SYSMODULE_H */
diff --git a/pythonsdk/include/token.h b/pythonsdk/include/token.h
deleted file mode 100644
index bd06007aa1273d9b912cf495f80775081f3563eb..0000000000000000000000000000000000000000
--- a/pythonsdk/include/token.h
+++ /dev/null
@@ -1,92 +0,0 @@
-
-/* Token types */
-#ifndef Py_LIMITED_API
-#ifndef Py_TOKEN_H
-#define Py_TOKEN_H
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-#undef TILDE /* Prevent clash of our definition with system macro. Ex AIX, ioctl.h */
-
-#define ENDMARKER 0
-#define NAME 1
-#define NUMBER 2
-#define STRING 3
-#define NEWLINE 4
-#define INDENT 5
-#define DEDENT 6
-#define LPAR 7
-#define RPAR 8
-#define LSQB 9
-#define RSQB 10
-#define COLON 11
-#define COMMA 12
-#define SEMI 13
-#define PLUS 14
-#define MINUS 15
-#define STAR 16
-#define SLASH 17
-#define VBAR 18
-#define AMPER 19
-#define LESS 20
-#define GREATER 21
-#define EQUAL 22
-#define DOT 23
-#define PERCENT 24
-#define LBRACE 25
-#define RBRACE 26
-#define EQEQUAL 27
-#define NOTEQUAL 28
-#define LESSEQUAL 29
-#define GREATEREQUAL 30
-#define TILDE 31
-#define CIRCUMFLEX 32
-#define LEFTSHIFT 33
-#define RIGHTSHIFT 34
-#define DOUBLESTAR 35
-#define PLUSEQUAL 36
-#define MINEQUAL 37
-#define STAREQUAL 38
-#define SLASHEQUAL 39
-#define PERCENTEQUAL 40
-#define AMPEREQUAL 41
-#define VBAREQUAL 42
-#define CIRCUMFLEXEQUAL 43
-#define LEFTSHIFTEQUAL 44
-#define RIGHTSHIFTEQUAL 45
-#define DOUBLESTAREQUAL 46
-#define DOUBLESLASH 47
-#define DOUBLESLASHEQUAL 48
-#define AT 49
-#define ATEQUAL 50
-#define RARROW 51
-#define ELLIPSIS 52
-/* Don't forget to update the table _PyParser_TokenNames in tokenizer.c! */
-#define OP 53
-#define ERRORTOKEN 54
-/* These aren't used by the C tokenizer but are needed for tokenize.py */
-#define COMMENT 55
-#define NL 56
-#define ENCODING 57
-#define N_TOKENS 58
-
-/* Special definitions for cooperation with parser */
-
-#define NT_OFFSET 256
-
-#define ISTERMINAL(x) ((x) < NT_OFFSET)
-#define ISNONTERMINAL(x) ((x) >= NT_OFFSET)
-#define ISEOF(x) ((x) == ENDMARKER)
-
-
-PyAPI_DATA(const char *) _PyParser_TokenNames[]; /* Token names */
-PyAPI_FUNC(int) PyToken_OneChar(int);
-PyAPI_FUNC(int) PyToken_TwoChars(int, int);
-PyAPI_FUNC(int) PyToken_ThreeChars(int, int, int);
-
-#ifdef __cplusplus
-}
-#endif
-#endif /* !Py_TOKEN_H */
-#endif /* Py_LIMITED_API */
diff --git a/pythonsdk/include/traceback.h b/pythonsdk/include/traceback.h
deleted file mode 100644
index 5cd333e6b62652ef687824db41f4b09dca7fc2e7..0000000000000000000000000000000000000000
--- a/pythonsdk/include/traceback.h
+++ /dev/null
@@ -1,119 +0,0 @@
-
-#ifndef Py_TRACEBACK_H
-#define Py_TRACEBACK_H
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-#include "pystate.h"
-
-struct _frame;
-
-/* Traceback interface */
-#ifndef Py_LIMITED_API
-typedef struct _traceback {
- PyObject_HEAD
- struct _traceback *tb_next;
- struct _frame *tb_frame;
- int tb_lasti;
- int tb_lineno;
-} PyTracebackObject;
-#endif
-
-PyAPI_FUNC(int) PyTraceBack_Here(struct _frame *);
-PyAPI_FUNC(int) PyTraceBack_Print(PyObject *, PyObject *);
-#ifndef Py_LIMITED_API
-PyAPI_FUNC(int) _Py_DisplaySourceLine(PyObject *, PyObject *, int, int);
-PyAPI_FUNC(void) _PyTraceback_Add(const char *, const char *, int);
-#endif
-
-/* Reveal traceback type so we can typecheck traceback objects */
-PyAPI_DATA(PyTypeObject) PyTraceBack_Type;
-#define PyTraceBack_Check(v) (Py_TYPE(v) == &PyTraceBack_Type)
-
-#ifndef Py_LIMITED_API
-/* Write the Python traceback into the file 'fd'. For example:
-
- Traceback (most recent call first):
- File "xxx", line xxx in <xxx>
- File "xxx", line xxx in <xxx>
- ...
- File "xxx", line xxx in <xxx>
-
- This function is written for debug purpose only, to dump the traceback in
- the worst case: after a segmentation fault, at fatal error, etc. That's why,
- it is very limited. Strings are truncated to 100 characters and encoded to
- ASCII with backslashreplace. It doesn't write the source code, only the
- function name, filename and line number of each frame. Write only the first
- 100 frames: if the traceback is truncated, write the line " ...".
-
- This function is signal safe. */
-
-PyAPI_FUNC(void) _Py_DumpTraceback(
- int fd,
- PyThreadState *tstate);
-
-/* Write the traceback of all threads into the file 'fd'. current_thread can be
- NULL.
-
- Return NULL on success, or an error message on error.
-
- This function is written for debug purpose only. It calls
- _Py_DumpTraceback() for each thread, and so has the same limitations. It
- only write the traceback of the first 100 threads: write "..." if there are
- more threads.
-
- If current_tstate is NULL, the function tries to get the Python thread state
- of the current thread. It is not an error if the function is unable to get
- the current Python thread state.
-
- If interp is NULL, the function tries to get the interpreter state from
- the current Python thread state, or from
- _PyGILState_GetInterpreterStateUnsafe() in last resort.
-
- It is better to pass NULL to interp and current_tstate, the function tries
- different options to retrieve these informations.
-
- This function is signal safe. */
-
-PyAPI_FUNC(const char*) _Py_DumpTracebackThreads(
- int fd,
- PyInterpreterState *interp,
- PyThreadState *current_tstate);
-#endif /* !Py_LIMITED_API */
-
-#ifndef Py_LIMITED_API
-
-/* Write a Unicode object into the file descriptor fd. Encode the string to
- ASCII using the backslashreplace error handler.
-
- Do nothing if text is not a Unicode object. The function accepts Unicode
- string which is not ready (PyUnicode_WCHAR_KIND).
-
- This function is signal safe. */
-PyAPI_FUNC(void) _Py_DumpASCII(int fd, PyObject *text);
-
-/* Format an integer as decimal into the file descriptor fd.
-
- This function is signal safe. */
-PyAPI_FUNC(void) _Py_DumpDecimal(
- int fd,
- unsigned long value);
-
-/* Format an integer as hexadecimal into the file descriptor fd with at least
- width digits.
-
- The maximum width is sizeof(unsigned long)*2 digits.
-
- This function is signal safe. */
-PyAPI_FUNC(void) _Py_DumpHexadecimal(
- int fd,
- unsigned long value,
- Py_ssize_t width);
-
-#endif /* !Py_LIMITED_API */
-
-#ifdef __cplusplus
-}
-#endif
-#endif /* !Py_TRACEBACK_H */
diff --git a/pythonsdk/include/tupleobject.h b/pythonsdk/include/tupleobject.h
deleted file mode 100644
index c418238f862431790f80a45ebd2b12ea13676f48..0000000000000000000000000000000000000000
--- a/pythonsdk/include/tupleobject.h
+++ /dev/null
@@ -1,73 +0,0 @@
-
-/* Tuple object interface */
-
-#ifndef Py_TUPLEOBJECT_H
-#define Py_TUPLEOBJECT_H
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-/*
-Another generally useful object type is a tuple of object pointers.
-For Python, this is an immutable type. C code can change the tuple items
-(but not their number), and even use tuples as general-purpose arrays of
-object references, but in general only brand new tuples should be mutated,
-not ones that might already have been exposed to Python code.
-
-*** WARNING *** PyTuple_SetItem does not increment the new item's reference
-count, but does decrement the reference count of the item it replaces,
-if not nil. It does *decrement* the reference count if it is *not*
-inserted in the tuple. Similarly, PyTuple_GetItem does not increment the
-returned item's reference count.
-*/
-
-#ifndef Py_LIMITED_API
-typedef struct {
- PyObject_VAR_HEAD
- PyObject *ob_item[1];
-
- /* ob_item contains space for 'ob_size' elements.
- * Items must normally not be NULL, except during construction when
- * the tuple is not yet visible outside the function that builds it.
- */
-} PyTupleObject;
-#endif
-
-PyAPI_DATA(PyTypeObject) PyTuple_Type;
-PyAPI_DATA(PyTypeObject) PyTupleIter_Type;
-
-#define PyTuple_Check(op) \
- PyType_FastSubclass(Py_TYPE(op), Py_TPFLAGS_TUPLE_SUBCLASS)
-#define PyTuple_CheckExact(op) (Py_TYPE(op) == &PyTuple_Type)
-
-PyAPI_FUNC(PyObject *) PyTuple_New(Py_ssize_t size);
-PyAPI_FUNC(Py_ssize_t) PyTuple_Size(PyObject *);
-PyAPI_FUNC(PyObject *) PyTuple_GetItem(PyObject *, Py_ssize_t);
-PyAPI_FUNC(int) PyTuple_SetItem(PyObject *, Py_ssize_t, PyObject *);
-PyAPI_FUNC(PyObject *) PyTuple_GetSlice(PyObject *, Py_ssize_t, Py_ssize_t);
-#ifndef Py_LIMITED_API
-PyAPI_FUNC(int) _PyTuple_Resize(PyObject **, Py_ssize_t);
-#endif
-PyAPI_FUNC(PyObject *) PyTuple_Pack(Py_ssize_t, ...);
-#ifndef Py_LIMITED_API
-PyAPI_FUNC(void) _PyTuple_MaybeUntrack(PyObject *);
-#endif
-
-/* Macro, trading safety for speed */
-#ifndef Py_LIMITED_API
-#define PyTuple_GET_ITEM(op, i) (((PyTupleObject *)(op))->ob_item[i])
-#define PyTuple_GET_SIZE(op) (assert(PyTuple_Check(op)),Py_SIZE(op))
-
-/* Macro, *only* to be used to fill in brand new tuples */
-#define PyTuple_SET_ITEM(op, i, v) (((PyTupleObject *)(op))->ob_item[i] = v)
-#endif
-
-PyAPI_FUNC(int) PyTuple_ClearFreeList(void);
-#ifndef Py_LIMITED_API
-PyAPI_FUNC(void) _PyTuple_DebugMallocStats(FILE *out);
-#endif /* Py_LIMITED_API */
-
-#ifdef __cplusplus
-}
-#endif
-#endif /* !Py_TUPLEOBJECT_H */
diff --git a/pythonsdk/include/typeslots.h b/pythonsdk/include/typeslots.h
deleted file mode 100644
index bf382f07e2735b958d7188b02927370f46c512a6..0000000000000000000000000000000000000000
--- a/pythonsdk/include/typeslots.h
+++ /dev/null
@@ -1,85 +0,0 @@
-/* Do not renumber the file; these numbers are part of the stable ABI. */
-/* Disabled, see #10181 */
-#undef Py_bf_getbuffer
-#undef Py_bf_releasebuffer
-#define Py_mp_ass_subscript 3
-#define Py_mp_length 4
-#define Py_mp_subscript 5
-#define Py_nb_absolute 6
-#define Py_nb_add 7
-#define Py_nb_and 8
-#define Py_nb_bool 9
-#define Py_nb_divmod 10
-#define Py_nb_float 11
-#define Py_nb_floor_divide 12
-#define Py_nb_index 13
-#define Py_nb_inplace_add 14
-#define Py_nb_inplace_and 15
-#define Py_nb_inplace_floor_divide 16
-#define Py_nb_inplace_lshift 17
-#define Py_nb_inplace_multiply 18
-#define Py_nb_inplace_or 19
-#define Py_nb_inplace_power 20
-#define Py_nb_inplace_remainder 21
-#define Py_nb_inplace_rshift 22
-#define Py_nb_inplace_subtract 23
-#define Py_nb_inplace_true_divide 24
-#define Py_nb_inplace_xor 25
-#define Py_nb_int 26
-#define Py_nb_invert 27
-#define Py_nb_lshift 28
-#define Py_nb_multiply 29
-#define Py_nb_negative 30
-#define Py_nb_or 31
-#define Py_nb_positive 32
-#define Py_nb_power 33
-#define Py_nb_remainder 34
-#define Py_nb_rshift 35
-#define Py_nb_subtract 36
-#define Py_nb_true_divide 37
-#define Py_nb_xor 38
-#define Py_sq_ass_item 39
-#define Py_sq_concat 40
-#define Py_sq_contains 41
-#define Py_sq_inplace_concat 42
-#define Py_sq_inplace_repeat 43
-#define Py_sq_item 44
-#define Py_sq_length 45
-#define Py_sq_repeat 46
-#define Py_tp_alloc 47
-#define Py_tp_base 48
-#define Py_tp_bases 49
-#define Py_tp_call 50
-#define Py_tp_clear 51
-#define Py_tp_dealloc 52
-#define Py_tp_del 53
-#define Py_tp_descr_get 54
-#define Py_tp_descr_set 55
-#define Py_tp_doc 56
-#define Py_tp_getattr 57
-#define Py_tp_getattro 58
-#define Py_tp_hash 59
-#define Py_tp_init 60
-#define Py_tp_is_gc 61
-#define Py_tp_iter 62
-#define Py_tp_iternext 63
-#define Py_tp_methods 64
-#define Py_tp_new 65
-#define Py_tp_repr 66
-#define Py_tp_richcompare 67
-#define Py_tp_setattr 68
-#define Py_tp_setattro 69
-#define Py_tp_str 70
-#define Py_tp_traverse 71
-#define Py_tp_members 72
-#define Py_tp_getset 73
-#define Py_tp_free 74
-#define Py_nb_matrix_multiply 75
-#define Py_nb_inplace_matrix_multiply 76
-#define Py_am_await 77
-#define Py_am_aiter 78
-#define Py_am_anext 79
-#if !defined(Py_LIMITED_API) || Py_LIMITED_API+0 >= 0x03050000
-/* New in 3.5 */
-#define Py_tp_finalize 80
-#endif
diff --git a/pythonsdk/include/ucnhash.h b/pythonsdk/include/ucnhash.h
deleted file mode 100644
index 6d1a29fbe47bcf944db9dc46e08053ee76a69c49..0000000000000000000000000000000000000000
--- a/pythonsdk/include/ucnhash.h
+++ /dev/null
@@ -1,36 +0,0 @@
-/* Unicode name database interface */
-#ifndef Py_LIMITED_API
-#ifndef Py_UCNHASH_H
-#define Py_UCNHASH_H
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-/* revised ucnhash CAPI interface (exported through a "wrapper") */
-
-#define PyUnicodeData_CAPSULE_NAME "unicodedata.ucnhash_CAPI"
-
-typedef struct {
-
- /* Size of this struct */
- int size;
-
- /* Get name for a given character code. Returns non-zero if
- success, zero if not. Does not set Python exceptions.
- If self is NULL, data come from the default version of the database.
- If it is not NULL, it should be a unicodedata.ucd_X_Y_Z object */
- int (*getname)(PyObject *self, Py_UCS4 code, char* buffer, int buflen,
- int with_alias_and_seq);
-
- /* Get character code for a given name. Same error handling
- as for getname. */
- int (*getcode)(PyObject *self, const char* name, int namelen, Py_UCS4* code,
- int with_named_seq);
-
-} _PyUnicode_Name_CAPI;
-
-#ifdef __cplusplus
-}
-#endif
-#endif /* !Py_UCNHASH_H */
-#endif /* !Py_LIMITED_API */
diff --git a/pythonsdk/include/unicodeobject.h b/pythonsdk/include/unicodeobject.h
deleted file mode 100644
index bfc125771e838c92b1f25a94ca0efc309bfd2556..0000000000000000000000000000000000000000
--- a/pythonsdk/include/unicodeobject.h
+++ /dev/null
@@ -1,2334 +0,0 @@
-#ifndef Py_UNICODEOBJECT_H
-#define Py_UNICODEOBJECT_H
-
-#include <stdarg.h>
-
-/*
-
-Unicode implementation based on original code by Fredrik Lundh,
-modified by Marc-Andre Lemburg (mal@lemburg.com) according to the
-Unicode Integration Proposal. (See
-http://www.egenix.com/files/python/unicode-proposal.txt).
-
-Copyright (c) Corporation for National Research Initiatives.
-
-
- Original header:
- --------------------------------------------------------------------
-
- * Yet another Unicode string type for Python. This type supports the
- * 16-bit Basic Multilingual Plane (BMP) only.
- *
- * Written by Fredrik Lundh, January 1999.
- *
- * Copyright (c) 1999 by Secret Labs AB.
- * Copyright (c) 1999 by Fredrik Lundh.
- *
- * fredrik@pythonware.com
- * http://www.pythonware.com
- *
- * --------------------------------------------------------------------
- * This Unicode String Type is
- *
- * Copyright (c) 1999 by Secret Labs AB
- * Copyright (c) 1999 by Fredrik Lundh
- *
- * By obtaining, using, and/or copying this software and/or its
- * associated documentation, you agree that you have read, understood,
- * and will comply with the following terms and conditions:
- *
- * Permission to use, copy, modify, and distribute this software and its
- * associated documentation for any purpose and without fee is hereby
- * granted, provided that the above copyright notice appears in all
- * copies, and that both that copyright notice and this permission notice
- * appear in supporting documentation, and that the name of Secret Labs
- * AB or the author not be used in advertising or publicity pertaining to
- * distribution of the software without specific, written prior
- * permission.
- *
- * SECRET LABS AB AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH REGARD TO
- * THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND
- * FITNESS. IN NO EVENT SHALL SECRET LABS AB OR THE AUTHOR BE LIABLE FOR
- * ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
- * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
- * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT
- * OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
- * -------------------------------------------------------------------- */
-
-#include <ctype.h>
-
-/* === Internal API ======================================================= */
-
-/* --- Internal Unicode Format -------------------------------------------- */
-
-/* Python 3.x requires unicode */
-#define Py_USING_UNICODE
-
-#ifndef SIZEOF_WCHAR_T
-#error Must define SIZEOF_WCHAR_T
-#endif
-
-#define Py_UNICODE_SIZE SIZEOF_WCHAR_T
-
-/* If wchar_t can be used for UCS-4 storage, set Py_UNICODE_WIDE.
- Otherwise, Unicode strings are stored as UCS-2 (with limited support
- for UTF-16) */
-
-#if Py_UNICODE_SIZE >= 4
-#define Py_UNICODE_WIDE
-#endif
-
-/* Set these flags if the platform has "wchar.h" and the
- wchar_t type is a 16-bit unsigned type */
-/* #define HAVE_WCHAR_H */
-/* #define HAVE_USABLE_WCHAR_T */
-
-/* Py_UNICODE was the native Unicode storage format (code unit) used by
- Python and represents a single Unicode element in the Unicode type.
- With PEP 393, Py_UNICODE is deprecated and replaced with a
- typedef to wchar_t. */
-
-#ifndef Py_LIMITED_API
-#define PY_UNICODE_TYPE wchar_t
-typedef wchar_t Py_UNICODE /* Py_DEPRECATED(3.3) */;
-#endif
-
-/* If the compiler provides a wchar_t type we try to support it
- through the interface functions PyUnicode_FromWideChar(),
- PyUnicode_AsWideChar() and PyUnicode_AsWideCharString(). */
-
-#ifdef HAVE_USABLE_WCHAR_T
-# ifndef HAVE_WCHAR_H
-# define HAVE_WCHAR_H
-# endif
-#endif
-
-#ifdef HAVE_WCHAR_H
-# include <wchar.h>
-#endif
-
-/* Py_UCS4 and Py_UCS2 are typedefs for the respective
- unicode representations. */
-typedef uint32_t Py_UCS4;
-typedef uint16_t Py_UCS2;
-typedef uint8_t Py_UCS1;
-
-/* --- Internal Unicode Operations ---------------------------------------- */
-
-/* Since splitting on whitespace is an important use case, and
- whitespace in most situations is solely ASCII whitespace, we
- optimize for the common case by using a quick look-up table
- _Py_ascii_whitespace (see below) with an inlined check.
-
- */
-#ifndef Py_LIMITED_API
-#define Py_UNICODE_ISSPACE(ch) \
- ((ch) < 128U ? _Py_ascii_whitespace[(ch)] : _PyUnicode_IsWhitespace(ch))
-
-#define Py_UNICODE_ISLOWER(ch) _PyUnicode_IsLowercase(ch)
-#define Py_UNICODE_ISUPPER(ch) _PyUnicode_IsUppercase(ch)
-#define Py_UNICODE_ISTITLE(ch) _PyUnicode_IsTitlecase(ch)
-#define Py_UNICODE_ISLINEBREAK(ch) _PyUnicode_IsLinebreak(ch)
-
-#define Py_UNICODE_TOLOWER(ch) _PyUnicode_ToLowercase(ch)
-#define Py_UNICODE_TOUPPER(ch) _PyUnicode_ToUppercase(ch)
-#define Py_UNICODE_TOTITLE(ch) _PyUnicode_ToTitlecase(ch)
-
-#define Py_UNICODE_ISDECIMAL(ch) _PyUnicode_IsDecimalDigit(ch)
-#define Py_UNICODE_ISDIGIT(ch) _PyUnicode_IsDigit(ch)
-#define Py_UNICODE_ISNUMERIC(ch) _PyUnicode_IsNumeric(ch)
-#define Py_UNICODE_ISPRINTABLE(ch) _PyUnicode_IsPrintable(ch)
-
-#define Py_UNICODE_TODECIMAL(ch) _PyUnicode_ToDecimalDigit(ch)
-#define Py_UNICODE_TODIGIT(ch) _PyUnicode_ToDigit(ch)
-#define Py_UNICODE_TONUMERIC(ch) _PyUnicode_ToNumeric(ch)
-
-#define Py_UNICODE_ISALPHA(ch) _PyUnicode_IsAlpha(ch)
-
-#define Py_UNICODE_ISALNUM(ch) \
- (Py_UNICODE_ISALPHA(ch) || \
- Py_UNICODE_ISDECIMAL(ch) || \
- Py_UNICODE_ISDIGIT(ch) || \
- Py_UNICODE_ISNUMERIC(ch))
-
-#define Py_UNICODE_COPY(target, source, length) \
- memcpy((target), (source), (length)*sizeof(Py_UNICODE))
-
-#define Py_UNICODE_FILL(target, value, length) \
- do {Py_ssize_t i_; Py_UNICODE *t_ = (target); Py_UNICODE v_ = (value);\
- for (i_ = 0; i_ < (length); i_++) t_[i_] = v_;\
- } while (0)
-
-/* macros to work with surrogates */
-#define Py_UNICODE_IS_SURROGATE(ch) (0xD800 <= (ch) && (ch) <= 0xDFFF)
-#define Py_UNICODE_IS_HIGH_SURROGATE(ch) (0xD800 <= (ch) && (ch) <= 0xDBFF)
-#define Py_UNICODE_IS_LOW_SURROGATE(ch) (0xDC00 <= (ch) && (ch) <= 0xDFFF)
-/* Join two surrogate characters and return a single Py_UCS4 value. */
-#define Py_UNICODE_JOIN_SURROGATES(high, low) \
- (((((Py_UCS4)(high) & 0x03FF) << 10) | \
- ((Py_UCS4)(low) & 0x03FF)) + 0x10000)
-/* high surrogate = top 10 bits added to D800 */
-#define Py_UNICODE_HIGH_SURROGATE(ch) (0xD800 - (0x10000 >> 10) + ((ch) >> 10))
-/* low surrogate = bottom 10 bits added to DC00 */
-#define Py_UNICODE_LOW_SURROGATE(ch) (0xDC00 + ((ch) & 0x3FF))
-
-/* Check if substring matches at given offset. The offset must be
- valid, and the substring must not be empty. */
-
-#define Py_UNICODE_MATCH(string, offset, substring) \
- ((*((string)->wstr + (offset)) == *((substring)->wstr)) && \
- ((*((string)->wstr + (offset) + (substring)->wstr_length-1) == *((substring)->wstr + (substring)->wstr_length-1))) && \
- !memcmp((string)->wstr + (offset), (substring)->wstr, (substring)->wstr_length*sizeof(Py_UNICODE)))
-
-#endif /* Py_LIMITED_API */
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-/* --- Unicode Type ------------------------------------------------------- */
-
-#ifndef Py_LIMITED_API
-
-/* ASCII-only strings created through PyUnicode_New use the PyASCIIObject
- structure. state.ascii and state.compact are set, and the data
- immediately follow the structure. utf8_length and wstr_length can be found
- in the length field; the utf8 pointer is equal to the data pointer. */
-typedef struct {
- /* There are 4 forms of Unicode strings:
-
- - compact ascii:
-
- * structure = PyASCIIObject
- * test: PyUnicode_IS_COMPACT_ASCII(op)
- * kind = PyUnicode_1BYTE_KIND
- * compact = 1
- * ascii = 1
- * ready = 1
- * (length is the length of the utf8 and wstr strings)
- * (data starts just after the structure)
- * (since ASCII is decoded from UTF-8, the utf8 string are the data)
-
- - compact:
-
- * structure = PyCompactUnicodeObject
- * test: PyUnicode_IS_COMPACT(op) && !PyUnicode_IS_ASCII(op)
- * kind = PyUnicode_1BYTE_KIND, PyUnicode_2BYTE_KIND or
- PyUnicode_4BYTE_KIND
- * compact = 1
- * ready = 1
- * ascii = 0
- * utf8 is not shared with data
- * utf8_length = 0 if utf8 is NULL
- * wstr is shared with data and wstr_length=length
- if kind=PyUnicode_2BYTE_KIND and sizeof(wchar_t)=2
- or if kind=PyUnicode_4BYTE_KIND and sizeof(wchar_t)=4
- * wstr_length = 0 if wstr is NULL
- * (data starts just after the structure)
-
- - legacy string, not ready:
-
- * structure = PyUnicodeObject
- * test: kind == PyUnicode_WCHAR_KIND
- * length = 0 (use wstr_length)
- * hash = -1
- * kind = PyUnicode_WCHAR_KIND
- * compact = 0
- * ascii = 0
- * ready = 0
- * interned = SSTATE_NOT_INTERNED
- * wstr is not NULL
- * data.any is NULL
- * utf8 is NULL
- * utf8_length = 0
-
- - legacy string, ready:
-
- * structure = PyUnicodeObject structure
- * test: !PyUnicode_IS_COMPACT(op) && kind != PyUnicode_WCHAR_KIND
- * kind = PyUnicode_1BYTE_KIND, PyUnicode_2BYTE_KIND or
- PyUnicode_4BYTE_KIND
- * compact = 0
- * ready = 1
- * data.any is not NULL
- * utf8 is shared and utf8_length = length with data.any if ascii = 1
- * utf8_length = 0 if utf8 is NULL
- * wstr is shared with data.any and wstr_length = length
- if kind=PyUnicode_2BYTE_KIND and sizeof(wchar_t)=2
- or if kind=PyUnicode_4BYTE_KIND and sizeof(wchar_4)=4
- * wstr_length = 0 if wstr is NULL
-
- Compact strings use only one memory block (structure + characters),
- whereas legacy strings use one block for the structure and one block
- for characters.
-
- Legacy strings are created by PyUnicode_FromUnicode() and
- PyUnicode_FromStringAndSize(NULL, size) functions. They become ready
- when PyUnicode_READY() is called.
-
- See also _PyUnicode_CheckConsistency().
- */
- PyObject_HEAD
- Py_ssize_t length; /* Number of code points in the string */
- Py_hash_t hash; /* Hash value; -1 if not set */
- struct {
- /*
- SSTATE_NOT_INTERNED (0)
- SSTATE_INTERNED_MORTAL (1)
- SSTATE_INTERNED_IMMORTAL (2)
-
- If interned != SSTATE_NOT_INTERNED, the two references from the
- dictionary to this object are *not* counted in ob_refcnt.
- */
- unsigned int interned:2;
- /* Character size:
-
- - PyUnicode_WCHAR_KIND (0):
-
- * character type = wchar_t (16 or 32 bits, depending on the
- platform)
-
- - PyUnicode_1BYTE_KIND (1):
-
- * character type = Py_UCS1 (8 bits, unsigned)
- * all characters are in the range U+0000-U+00FF (latin1)
- * if ascii is set, all characters are in the range U+0000-U+007F
- (ASCII), otherwise at least one character is in the range
- U+0080-U+00FF
-
- - PyUnicode_2BYTE_KIND (2):
-
- * character type = Py_UCS2 (16 bits, unsigned)
- * all characters are in the range U+0000-U+FFFF (BMP)
- * at least one character is in the range U+0100-U+FFFF
-
- - PyUnicode_4BYTE_KIND (4):
-
- * character type = Py_UCS4 (32 bits, unsigned)
- * all characters are in the range U+0000-U+10FFFF
- * at least one character is in the range U+10000-U+10FFFF
- */
- unsigned int kind:3;
- /* Compact is with respect to the allocation scheme. Compact unicode
- objects only require one memory block while non-compact objects use
- one block for the PyUnicodeObject struct and another for its data
- buffer. */
- unsigned int compact:1;
- /* The string only contains characters in the range U+0000-U+007F (ASCII)
- and the kind is PyUnicode_1BYTE_KIND. If ascii is set and compact is
- set, use the PyASCIIObject structure. */
- unsigned int ascii:1;
- /* The ready flag indicates whether the object layout is initialized
- completely. This means that this is either a compact object, or
- the data pointer is filled out. The bit is redundant, and helps
- to minimize the test in PyUnicode_IS_READY(). */
- unsigned int ready:1;
- /* Padding to ensure that PyUnicode_DATA() is always aligned to
- 4 bytes (see issue #19537 on m68k). */
- unsigned int :24;
- } state;
- wchar_t *wstr; /* wchar_t representation (null-terminated) */
-} PyASCIIObject;
-
-/* Non-ASCII strings allocated through PyUnicode_New use the
- PyCompactUnicodeObject structure. state.compact is set, and the data
- immediately follow the structure. */
-typedef struct {
- PyASCIIObject _base;
- Py_ssize_t utf8_length; /* Number of bytes in utf8, excluding the
- * terminating \0. */
- char *utf8; /* UTF-8 representation (null-terminated) */
- Py_ssize_t wstr_length; /* Number of code points in wstr, possible
- * surrogates count as two code points. */
-} PyCompactUnicodeObject;
-
-/* Strings allocated through PyUnicode_FromUnicode(NULL, len) use the
- PyUnicodeObject structure. The actual string data is initially in the wstr
- block, and copied into the data block using _PyUnicode_Ready. */
-typedef struct {
- PyCompactUnicodeObject _base;
- union {
- void *any;
- Py_UCS1 *latin1;
- Py_UCS2 *ucs2;
- Py_UCS4 *ucs4;
- } data; /* Canonical, smallest-form Unicode buffer */
-} PyUnicodeObject;
-#endif
-
-PyAPI_DATA(PyTypeObject) PyUnicode_Type;
-PyAPI_DATA(PyTypeObject) PyUnicodeIter_Type;
-
-#define PyUnicode_Check(op) \
- PyType_FastSubclass(Py_TYPE(op), Py_TPFLAGS_UNICODE_SUBCLASS)
-#define PyUnicode_CheckExact(op) (Py_TYPE(op) == &PyUnicode_Type)
-
-/* Fast access macros */
-#ifndef Py_LIMITED_API
-
-#define PyUnicode_WSTR_LENGTH(op) \
- (PyUnicode_IS_COMPACT_ASCII(op) ? \
- ((PyASCIIObject*)op)->length : \
- ((PyCompactUnicodeObject*)op)->wstr_length)
-
-/* Returns the deprecated Py_UNICODE representation's size in code units
- (this includes surrogate pairs as 2 units).
- If the Py_UNICODE representation is not available, it will be computed
- on request. Use PyUnicode_GET_LENGTH() for the length in code points. */
-
-#define PyUnicode_GET_SIZE(op) \
- (assert(PyUnicode_Check(op)), \
- (((PyASCIIObject *)(op))->wstr) ? \
- PyUnicode_WSTR_LENGTH(op) : \
- ((void)PyUnicode_AsUnicode((PyObject *)(op)), \
- assert(((PyASCIIObject *)(op))->wstr), \
- PyUnicode_WSTR_LENGTH(op)))
- /* Py_DEPRECATED(3.3) */
-
-#define PyUnicode_GET_DATA_SIZE(op) \
- (PyUnicode_GET_SIZE(op) * Py_UNICODE_SIZE)
- /* Py_DEPRECATED(3.3) */
-
-/* Alias for PyUnicode_AsUnicode(). This will create a wchar_t/Py_UNICODE
- representation on demand. Using this macro is very inefficient now,
- try to port your code to use the new PyUnicode_*BYTE_DATA() macros or
- use PyUnicode_WRITE() and PyUnicode_READ(). */
-
-#define PyUnicode_AS_UNICODE(op) \
- (assert(PyUnicode_Check(op)), \
- (((PyASCIIObject *)(op))->wstr) ? (((PyASCIIObject *)(op))->wstr) : \
- PyUnicode_AsUnicode((PyObject *)(op)))
- /* Py_DEPRECATED(3.3) */
-
-#define PyUnicode_AS_DATA(op) \
- ((const char *)(PyUnicode_AS_UNICODE(op)))
- /* Py_DEPRECATED(3.3) */
-
-
-/* --- Flexible String Representation Helper Macros (PEP 393) -------------- */
-
-/* Values for PyASCIIObject.state: */
-
-/* Interning state. */
-#define SSTATE_NOT_INTERNED 0
-#define SSTATE_INTERNED_MORTAL 1
-#define SSTATE_INTERNED_IMMORTAL 2
-
-/* Return true if the string contains only ASCII characters, or 0 if not. The
- string may be compact (PyUnicode_IS_COMPACT_ASCII) or not, but must be
- ready. */
-#define PyUnicode_IS_ASCII(op) \
- (assert(PyUnicode_Check(op)), \
- assert(PyUnicode_IS_READY(op)), \
- ((PyASCIIObject*)op)->state.ascii)
-
-/* Return true if the string is compact or 0 if not.
- No type checks or Ready calls are performed. */
-#define PyUnicode_IS_COMPACT(op) \
- (((PyASCIIObject*)(op))->state.compact)
-
-/* Return true if the string is a compact ASCII string (use PyASCIIObject
- structure), or 0 if not. No type checks or Ready calls are performed. */
-#define PyUnicode_IS_COMPACT_ASCII(op) \
- (((PyASCIIObject*)op)->state.ascii && PyUnicode_IS_COMPACT(op))
-
-enum PyUnicode_Kind {
-/* String contains only wstr byte characters. This is only possible
- when the string was created with a legacy API and _PyUnicode_Ready()
- has not been called yet. */
- PyUnicode_WCHAR_KIND = 0,
-/* Return values of the PyUnicode_KIND() macro: */
- PyUnicode_1BYTE_KIND = 1,
- PyUnicode_2BYTE_KIND = 2,
- PyUnicode_4BYTE_KIND = 4
-};
-
-/* Return pointers to the canonical representation cast to unsigned char,
- Py_UCS2, or Py_UCS4 for direct character access.
- No checks are performed, use PyUnicode_KIND() before to ensure
- these will work correctly. */
-
-#define PyUnicode_1BYTE_DATA(op) ((Py_UCS1*)PyUnicode_DATA(op))
-#define PyUnicode_2BYTE_DATA(op) ((Py_UCS2*)PyUnicode_DATA(op))
-#define PyUnicode_4BYTE_DATA(op) ((Py_UCS4*)PyUnicode_DATA(op))
-
-/* Return one of the PyUnicode_*_KIND values defined above. */
-#define PyUnicode_KIND(op) \
- (assert(PyUnicode_Check(op)), \
- assert(PyUnicode_IS_READY(op)), \
- ((PyASCIIObject *)(op))->state.kind)
-
-/* Return a void pointer to the raw unicode buffer. */
-#define _PyUnicode_COMPACT_DATA(op) \
- (PyUnicode_IS_ASCII(op) ? \
- ((void*)((PyASCIIObject*)(op) + 1)) : \
- ((void*)((PyCompactUnicodeObject*)(op) + 1)))
-
-#define _PyUnicode_NONCOMPACT_DATA(op) \
- (assert(((PyUnicodeObject*)(op))->data.any), \
- ((((PyUnicodeObject *)(op))->data.any)))
-
-#define PyUnicode_DATA(op) \
- (assert(PyUnicode_Check(op)), \
- PyUnicode_IS_COMPACT(op) ? _PyUnicode_COMPACT_DATA(op) : \
- _PyUnicode_NONCOMPACT_DATA(op))
-
-/* In the access macros below, "kind" may be evaluated more than once.
- All other macro parameters are evaluated exactly once, so it is safe
- to put side effects into them (such as increasing the index). */
-
-/* Write into the canonical representation, this macro does not do any sanity
- checks and is intended for usage in loops. The caller should cache the
- kind and data pointers obtained from other macro calls.
- index is the index in the string (starts at 0) and value is the new
- code point value which should be written to that location. */
-#define PyUnicode_WRITE(kind, data, index, value) \
- do { \
- switch ((kind)) { \
- case PyUnicode_1BYTE_KIND: { \
- ((Py_UCS1 *)(data))[(index)] = (Py_UCS1)(value); \
- break; \
- } \
- case PyUnicode_2BYTE_KIND: { \
- ((Py_UCS2 *)(data))[(index)] = (Py_UCS2)(value); \
- break; \
- } \
- default: { \
- assert((kind) == PyUnicode_4BYTE_KIND); \
- ((Py_UCS4 *)(data))[(index)] = (Py_UCS4)(value); \
- } \
- } \
- } while (0)
-
-/* Read a code point from the string's canonical representation. No checks
- or ready calls are performed. */
-#define PyUnicode_READ(kind, data, index) \
- ((Py_UCS4) \
- ((kind) == PyUnicode_1BYTE_KIND ? \
- ((const Py_UCS1 *)(data))[(index)] : \
- ((kind) == PyUnicode_2BYTE_KIND ? \
- ((const Py_UCS2 *)(data))[(index)] : \
- ((const Py_UCS4 *)(data))[(index)] \
- ) \
- ))
-
-/* PyUnicode_READ_CHAR() is less efficient than PyUnicode_READ() because it
- calls PyUnicode_KIND() and might call it twice. For single reads, use
- PyUnicode_READ_CHAR, for multiple consecutive reads callers should
- cache kind and use PyUnicode_READ instead. */
-#define PyUnicode_READ_CHAR(unicode, index) \
- (assert(PyUnicode_Check(unicode)), \
- assert(PyUnicode_IS_READY(unicode)), \
- (Py_UCS4) \
- (PyUnicode_KIND((unicode)) == PyUnicode_1BYTE_KIND ? \
- ((const Py_UCS1 *)(PyUnicode_DATA((unicode))))[(index)] : \
- (PyUnicode_KIND((unicode)) == PyUnicode_2BYTE_KIND ? \
- ((const Py_UCS2 *)(PyUnicode_DATA((unicode))))[(index)] : \
- ((const Py_UCS4 *)(PyUnicode_DATA((unicode))))[(index)] \
- ) \
- ))
-
-/* Returns the length of the unicode string. The caller has to make sure that
- the string has it's canonical representation set before calling
- this macro. Call PyUnicode_(FAST_)Ready to ensure that. */
-#define PyUnicode_GET_LENGTH(op) \
- (assert(PyUnicode_Check(op)), \
- assert(PyUnicode_IS_READY(op)), \
- ((PyASCIIObject *)(op))->length)
-
-
-/* Fast check to determine whether an object is ready. Equivalent to
- PyUnicode_IS_COMPACT(op) || ((PyUnicodeObject*)(op))->data.any) */
-
-#define PyUnicode_IS_READY(op) (((PyASCIIObject*)op)->state.ready)
-
-/* PyUnicode_READY() does less work than _PyUnicode_Ready() in the best
- case. If the canonical representation is not yet set, it will still call
- _PyUnicode_Ready().
- Returns 0 on success and -1 on errors. */
-#define PyUnicode_READY(op) \
- (assert(PyUnicode_Check(op)), \
- (PyUnicode_IS_READY(op) ? \
- 0 : _PyUnicode_Ready((PyObject *)(op))))
-
-/* Return a maximum character value which is suitable for creating another
- string based on op. This is always an approximation but more efficient
- than iterating over the string. */
-#define PyUnicode_MAX_CHAR_VALUE(op) \
- (assert(PyUnicode_IS_READY(op)), \
- (PyUnicode_IS_ASCII(op) ? \
- (0x7f) : \
- (PyUnicode_KIND(op) == PyUnicode_1BYTE_KIND ? \
- (0xffU) : \
- (PyUnicode_KIND(op) == PyUnicode_2BYTE_KIND ? \
- (0xffffU) : \
- (0x10ffffU)))))
-
-#endif
-
-/* --- Constants ---------------------------------------------------------- */
-
-/* This Unicode character will be used as replacement character during
- decoding if the errors argument is set to "replace". Note: the
- Unicode character U+FFFD is the official REPLACEMENT CHARACTER in
- Unicode 3.0. */
-
-#define Py_UNICODE_REPLACEMENT_CHARACTER ((Py_UCS4) 0xFFFD)
-
-/* === Public API ========================================================= */
-
-/* --- Plain Py_UNICODE --------------------------------------------------- */
-
-/* With PEP 393, this is the recommended way to allocate a new unicode object.
- This function will allocate the object and its buffer in a single memory
- block. Objects created using this function are not resizable. */
-#ifndef Py_LIMITED_API
-PyAPI_FUNC(PyObject*) PyUnicode_New(
- Py_ssize_t size, /* Number of code points in the new string */
- Py_UCS4 maxchar /* maximum code point value in the string */
- );
-#endif
-
-/* Initializes the canonical string representation from the deprecated
- wstr/Py_UNICODE representation. This function is used to convert Unicode
- objects which were created using the old API to the new flexible format
- introduced with PEP 393.
-
- Don't call this function directly, use the public PyUnicode_READY() macro
- instead. */
-#ifndef Py_LIMITED_API
-PyAPI_FUNC(int) _PyUnicode_Ready(
- PyObject *unicode /* Unicode object */
- );
-#endif
-
-/* Get a copy of a Unicode string. */
-#ifndef Py_LIMITED_API
-PyAPI_FUNC(PyObject*) _PyUnicode_Copy(
- PyObject *unicode
- );
-#endif
-
-/* Copy character from one unicode object into another, this function performs
- character conversion when necessary and falls back to memcpy() if possible.
-
- Fail if to is too small (smaller than *how_many* or smaller than
- len(from)-from_start), or if kind(from[from_start:from_start+how_many]) >
- kind(to), or if *to* has more than 1 reference.
-
- Return the number of written character, or return -1 and raise an exception
- on error.
-
- Pseudo-code:
-
- how_many = min(how_many, len(from) - from_start)
- to[to_start:to_start+how_many] = from[from_start:from_start+how_many]
- return how_many
-
- Note: The function doesn't write a terminating null character.
- */
-#ifndef Py_LIMITED_API
-PyAPI_FUNC(Py_ssize_t) PyUnicode_CopyCharacters(
- PyObject *to,
- Py_ssize_t to_start,
- PyObject *from,
- Py_ssize_t from_start,
- Py_ssize_t how_many
- );
-
-/* Unsafe version of PyUnicode_CopyCharacters(): don't check arguments and so
- may crash if parameters are invalid (e.g. if the output string
- is too short). */
-PyAPI_FUNC(void) _PyUnicode_FastCopyCharacters(
- PyObject *to,
- Py_ssize_t to_start,
- PyObject *from,
- Py_ssize_t from_start,
- Py_ssize_t how_many
- );
-#endif
-
-#ifndef Py_LIMITED_API
-/* Fill a string with a character: write fill_char into
- unicode[start:start+length].
-
- Fail if fill_char is bigger than the string maximum character, or if the
- string has more than 1 reference.
-
- Return the number of written character, or return -1 and raise an exception
- on error. */
-PyAPI_FUNC(Py_ssize_t) PyUnicode_Fill(
- PyObject *unicode,
- Py_ssize_t start,
- Py_ssize_t length,
- Py_UCS4 fill_char
- );
-
-/* Unsafe version of PyUnicode_Fill(): don't check arguments and so may crash
- if parameters are invalid (e.g. if length is longer than the string). */
-PyAPI_FUNC(void) _PyUnicode_FastFill(
- PyObject *unicode,
- Py_ssize_t start,
- Py_ssize_t length,
- Py_UCS4 fill_char
- );
-#endif
-
-/* Create a Unicode Object from the Py_UNICODE buffer u of the given
- size.
-
- u may be NULL which causes the contents to be undefined. It is the
- user's responsibility to fill in the needed data afterwards. Note
- that modifying the Unicode object contents after construction is
- only allowed if u was set to NULL.
-
- The buffer is copied into the new object. */
-
-#ifndef Py_LIMITED_API
-PyAPI_FUNC(PyObject*) PyUnicode_FromUnicode(
- const Py_UNICODE *u, /* Unicode buffer */
- Py_ssize_t size /* size of buffer */
- ) /* Py_DEPRECATED(3.3) */;
-#endif
-
-/* Similar to PyUnicode_FromUnicode(), but u points to UTF-8 encoded bytes */
-PyAPI_FUNC(PyObject*) PyUnicode_FromStringAndSize(
- const char *u, /* UTF-8 encoded string */
- Py_ssize_t size /* size of buffer */
- );
-
-/* Similar to PyUnicode_FromUnicode(), but u points to null-terminated
- UTF-8 encoded bytes. The size is determined with strlen(). */
-PyAPI_FUNC(PyObject*) PyUnicode_FromString(
- const char *u /* UTF-8 encoded string */
- );
-
-#ifndef Py_LIMITED_API
-/* Create a new string from a buffer of Py_UCS1, Py_UCS2 or Py_UCS4 characters.
- Scan the string to find the maximum character. */
-PyAPI_FUNC(PyObject*) PyUnicode_FromKindAndData(
- int kind,
- const void *buffer,
- Py_ssize_t size);
-
-/* Create a new string from a buffer of ASCII characters.
- WARNING: Don't check if the string contains any non-ASCII character. */
-PyAPI_FUNC(PyObject*) _PyUnicode_FromASCII(
- const char *buffer,
- Py_ssize_t size);
-#endif
-
-#if !defined(Py_LIMITED_API) || Py_LIMITED_API+0 >= 0x03030000
-PyAPI_FUNC(PyObject*) PyUnicode_Substring(
- PyObject *str,
- Py_ssize_t start,
- Py_ssize_t end);
-#endif
-
-#ifndef Py_LIMITED_API
-/* Compute the maximum character of the substring unicode[start:end].
- Return 127 for an empty string. */
-PyAPI_FUNC(Py_UCS4) _PyUnicode_FindMaxChar (
- PyObject *unicode,
- Py_ssize_t start,
- Py_ssize_t end);
-#endif
-
-#if !defined(Py_LIMITED_API) || Py_LIMITED_API+0 >= 0x03030000
-/* Copy the string into a UCS4 buffer including the null character if copy_null
- is set. Return NULL and raise an exception on error. Raise a SystemError if
- the buffer is smaller than the string. Return buffer on success.
-
- buflen is the length of the buffer in (Py_UCS4) characters. */
-PyAPI_FUNC(Py_UCS4*) PyUnicode_AsUCS4(
- PyObject *unicode,
- Py_UCS4* buffer,
- Py_ssize_t buflen,
- int copy_null);
-
-/* Copy the string into a UCS4 buffer. A new buffer is allocated using
- * PyMem_Malloc; if this fails, NULL is returned with a memory error
- exception set. */
-PyAPI_FUNC(Py_UCS4*) PyUnicode_AsUCS4Copy(PyObject *unicode);
-#endif
-
-#ifndef Py_LIMITED_API
-/* Return a read-only pointer to the Unicode object's internal
- Py_UNICODE buffer.
- If the wchar_t/Py_UNICODE representation is not yet available, this
- function will calculate it. */
-
-PyAPI_FUNC(Py_UNICODE *) PyUnicode_AsUnicode(
- PyObject *unicode /* Unicode object */
- ) /* Py_DEPRECATED(3.3) */;
-
-/* Similar to PyUnicode_AsUnicode(), but raises a ValueError if the string
- contains null characters. */
-PyAPI_FUNC(const Py_UNICODE *) _PyUnicode_AsUnicode(
- PyObject *unicode /* Unicode object */
- );
-
-/* Return a read-only pointer to the Unicode object's internal
- Py_UNICODE buffer and save the length at size.
- If the wchar_t/Py_UNICODE representation is not yet available, this
- function will calculate it. */
-
-PyAPI_FUNC(Py_UNICODE *) PyUnicode_AsUnicodeAndSize(
- PyObject *unicode, /* Unicode object */
- Py_ssize_t *size /* location where to save the length */
- ) /* Py_DEPRECATED(3.3) */;
-#endif
-
-#if !defined(Py_LIMITED_API) || Py_LIMITED_API+0 >= 0x03030000
-/* Get the length of the Unicode object. */
-
-PyAPI_FUNC(Py_ssize_t) PyUnicode_GetLength(
- PyObject *unicode
-);
-#endif
-
-/* Get the number of Py_UNICODE units in the
- string representation. */
-
-PyAPI_FUNC(Py_ssize_t) PyUnicode_GetSize(
- PyObject *unicode /* Unicode object */
- ) Py_DEPRECATED(3.3);
-
-#if !defined(Py_LIMITED_API) || Py_LIMITED_API+0 >= 0x03030000
-/* Read a character from the string. */
-
-PyAPI_FUNC(Py_UCS4) PyUnicode_ReadChar(
- PyObject *unicode,
- Py_ssize_t index
- );
-
-/* Write a character to the string. The string must have been created through
- PyUnicode_New, must not be shared, and must not have been hashed yet.
-
- Return 0 on success, -1 on error. */
-
-PyAPI_FUNC(int) PyUnicode_WriteChar(
- PyObject *unicode,
- Py_ssize_t index,
- Py_UCS4 character
- );
-#endif
-
-#ifndef Py_LIMITED_API
-/* Get the maximum ordinal for a Unicode character. */
-PyAPI_FUNC(Py_UNICODE) PyUnicode_GetMax(void) Py_DEPRECATED(3.3);
-#endif
-
-/* Resize a Unicode object. The length is the number of characters, except
- if the kind of the string is PyUnicode_WCHAR_KIND: in this case, the length
- is the number of Py_UNICODE characters.
-
- *unicode is modified to point to the new (resized) object and 0
- returned on success.
-
- Try to resize the string in place (which is usually faster than allocating
- a new string and copy characters), or create a new string.
-
- Error handling is implemented as follows: an exception is set, -1
- is returned and *unicode left untouched.
-
- WARNING: The function doesn't check string content, the result may not be a
- string in canonical representation. */
-
-PyAPI_FUNC(int) PyUnicode_Resize(
- PyObject **unicode, /* Pointer to the Unicode object */
- Py_ssize_t length /* New length */
- );
-
-/* Decode obj to a Unicode object.
-
- bytes, bytearray and other bytes-like objects are decoded according to the
- given encoding and error handler. The encoding and error handler can be
- NULL to have the interface use UTF-8 and "strict".
-
- All other objects (including Unicode objects) raise an exception.
-
- The API returns NULL in case of an error. The caller is responsible
- for decref'ing the returned objects.
-
-*/
-
-PyAPI_FUNC(PyObject*) PyUnicode_FromEncodedObject(
- PyObject *obj, /* Object */
- const char *encoding, /* encoding */
- const char *errors /* error handling */
- );
-
-/* Copy an instance of a Unicode subtype to a new true Unicode object if
- necessary. If obj is already a true Unicode object (not a subtype), return
- the reference with *incremented* refcount.
-
- The API returns NULL in case of an error. The caller is responsible
- for decref'ing the returned objects.
-
-*/
-
-PyAPI_FUNC(PyObject*) PyUnicode_FromObject(
- PyObject *obj /* Object */
- );
-
-PyAPI_FUNC(PyObject *) PyUnicode_FromFormatV(
- const char *format, /* ASCII-encoded string */
- va_list vargs
- );
-PyAPI_FUNC(PyObject *) PyUnicode_FromFormat(
- const char *format, /* ASCII-encoded string */
- ...
- );
-
-#ifndef Py_LIMITED_API
-typedef struct {
- PyObject *buffer;
- void *data;
- enum PyUnicode_Kind kind;
- Py_UCS4 maxchar;
- Py_ssize_t size;
- Py_ssize_t pos;
-
- /* minimum number of allocated characters (default: 0) */
- Py_ssize_t min_length;
-
- /* minimum character (default: 127, ASCII) */
- Py_UCS4 min_char;
-
- /* If non-zero, overallocate the buffer (default: 0). */
- unsigned char overallocate;
-
- /* If readonly is 1, buffer is a shared string (cannot be modified)
- and size is set to 0. */
- unsigned char readonly;
-} _PyUnicodeWriter ;
-
-/* Initialize a Unicode writer.
- *
- * By default, the minimum buffer size is 0 character and overallocation is
- * disabled. Set min_length, min_char and overallocate attributes to control
- * the allocation of the buffer. */
-PyAPI_FUNC(void)
-_PyUnicodeWriter_Init(_PyUnicodeWriter *writer);
-
-/* Prepare the buffer to write 'length' characters
- with the specified maximum character.
-
- Return 0 on success, raise an exception and return -1 on error. */
-#define _PyUnicodeWriter_Prepare(WRITER, LENGTH, MAXCHAR) \
- (((MAXCHAR) <= (WRITER)->maxchar \
- && (LENGTH) <= (WRITER)->size - (WRITER)->pos) \
- ? 0 \
- : (((LENGTH) == 0) \
- ? 0 \
- : _PyUnicodeWriter_PrepareInternal((WRITER), (LENGTH), (MAXCHAR))))
-
-/* Don't call this function directly, use the _PyUnicodeWriter_Prepare() macro
- instead. */
-PyAPI_FUNC(int)
-_PyUnicodeWriter_PrepareInternal(_PyUnicodeWriter *writer,
- Py_ssize_t length, Py_UCS4 maxchar);
-
-/* Prepare the buffer to have at least the kind KIND.
- For example, kind=PyUnicode_2BYTE_KIND ensures that the writer will
- support characters in range U+000-U+FFFF.
-
- Return 0 on success, raise an exception and return -1 on error. */
-#define _PyUnicodeWriter_PrepareKind(WRITER, KIND) \
- (assert((KIND) != PyUnicode_WCHAR_KIND), \
- (KIND) <= (WRITER)->kind \
- ? 0 \
- : _PyUnicodeWriter_PrepareKindInternal((WRITER), (KIND)))
-
-/* Don't call this function directly, use the _PyUnicodeWriter_PrepareKind()
- macro instead. */
-PyAPI_FUNC(int)
-_PyUnicodeWriter_PrepareKindInternal(_PyUnicodeWriter *writer,
- enum PyUnicode_Kind kind);
-
-/* Append a Unicode character.
- Return 0 on success, raise an exception and return -1 on error. */
-PyAPI_FUNC(int)
-_PyUnicodeWriter_WriteChar(_PyUnicodeWriter *writer,
- Py_UCS4 ch
- );
-
-/* Append a Unicode string.
- Return 0 on success, raise an exception and return -1 on error. */
-PyAPI_FUNC(int)
-_PyUnicodeWriter_WriteStr(_PyUnicodeWriter *writer,
- PyObject *str /* Unicode string */
- );
-
-/* Append a substring of a Unicode string.
- Return 0 on success, raise an exception and return -1 on error. */
-PyAPI_FUNC(int)
-_PyUnicodeWriter_WriteSubstring(_PyUnicodeWriter *writer,
- PyObject *str, /* Unicode string */
- Py_ssize_t start,
- Py_ssize_t end
- );
-
-/* Append an ASCII-encoded byte string.
- Return 0 on success, raise an exception and return -1 on error. */
-PyAPI_FUNC(int)
-_PyUnicodeWriter_WriteASCIIString(_PyUnicodeWriter *writer,
- const char *str, /* ASCII-encoded byte string */
- Py_ssize_t len /* number of bytes, or -1 if unknown */
- );
-
-/* Append a latin1-encoded byte string.
- Return 0 on success, raise an exception and return -1 on error. */
-PyAPI_FUNC(int)
-_PyUnicodeWriter_WriteLatin1String(_PyUnicodeWriter *writer,
- const char *str, /* latin1-encoded byte string */
- Py_ssize_t len /* length in bytes */
- );
-
-/* Get the value of the writer as a Unicode string. Clear the
- buffer of the writer. Raise an exception and return NULL
- on error. */
-PyAPI_FUNC(PyObject *)
-_PyUnicodeWriter_Finish(_PyUnicodeWriter *writer);
-
-/* Deallocate memory of a writer (clear its internal buffer). */
-PyAPI_FUNC(void)
-_PyUnicodeWriter_Dealloc(_PyUnicodeWriter *writer);
-#endif
-
-#ifndef Py_LIMITED_API
-/* Format the object based on the format_spec, as defined in PEP 3101
- (Advanced String Formatting). */
-PyAPI_FUNC(int) _PyUnicode_FormatAdvancedWriter(
- _PyUnicodeWriter *writer,
- PyObject *obj,
- PyObject *format_spec,
- Py_ssize_t start,
- Py_ssize_t end);
-#endif
-
-PyAPI_FUNC(void) PyUnicode_InternInPlace(PyObject **);
-PyAPI_FUNC(void) PyUnicode_InternImmortal(PyObject **);
-PyAPI_FUNC(PyObject *) PyUnicode_InternFromString(
- const char *u /* UTF-8 encoded string */
- );
-#ifndef Py_LIMITED_API
-PyAPI_FUNC(void) _Py_ReleaseInternedUnicodeStrings(void);
-#endif
-
-/* Use only if you know it's a string */
-#define PyUnicode_CHECK_INTERNED(op) \
- (((PyASCIIObject *)(op))->state.interned)
-
-/* --- wchar_t support for platforms which support it --------------------- */
-
-#ifdef HAVE_WCHAR_H
-
-/* Create a Unicode Object from the wchar_t buffer w of the given
- size.
-
- The buffer is copied into the new object. */
-
-PyAPI_FUNC(PyObject*) PyUnicode_FromWideChar(
- const wchar_t *w, /* wchar_t buffer */
- Py_ssize_t size /* size of buffer */
- );
-
-/* Copies the Unicode Object contents into the wchar_t buffer w. At
- most size wchar_t characters are copied.
-
- Note that the resulting wchar_t string may or may not be
- 0-terminated. It is the responsibility of the caller to make sure
- that the wchar_t string is 0-terminated in case this is required by
- the application.
-
- Returns the number of wchar_t characters copied (excluding a
- possibly trailing 0-termination character) or -1 in case of an
- error. */
-
-PyAPI_FUNC(Py_ssize_t) PyUnicode_AsWideChar(
- PyObject *unicode, /* Unicode object */
- wchar_t *w, /* wchar_t buffer */
- Py_ssize_t size /* size of buffer */
- );
-
-/* Convert the Unicode object to a wide character string. The output string
- always ends with a nul character. If size is not NULL, write the number of
- wide characters (excluding the null character) into *size.
-
- Returns a buffer allocated by PyMem_Malloc() (use PyMem_Free() to free it)
- on success. On error, returns NULL, *size is undefined and raises a
- MemoryError. */
-
-PyAPI_FUNC(wchar_t*) PyUnicode_AsWideCharString(
- PyObject *unicode, /* Unicode object */
- Py_ssize_t *size /* number of characters of the result */
- );
-
-#ifndef Py_LIMITED_API
-PyAPI_FUNC(void*) _PyUnicode_AsKind(PyObject *s, unsigned int kind);
-#endif
-
-#endif
-
-/* --- Unicode ordinals --------------------------------------------------- */
-
-/* Create a Unicode Object from the given Unicode code point ordinal.
-
- The ordinal must be in range(0x110000). A ValueError is
- raised in case it is not.
-
-*/
-
-PyAPI_FUNC(PyObject*) PyUnicode_FromOrdinal(int ordinal);
-
-/* --- Free-list management ----------------------------------------------- */
-
-/* Clear the free list used by the Unicode implementation.
-
- This can be used to release memory used for objects on the free
- list back to the Python memory allocator.
-
-*/
-
-PyAPI_FUNC(int) PyUnicode_ClearFreeList(void);
-
-/* === Builtin Codecs =====================================================
-
- Many of these APIs take two arguments encoding and errors. These
- parameters encoding and errors have the same semantics as the ones
- of the builtin str() API.
-
- Setting encoding to NULL causes the default encoding (UTF-8) to be used.
-
- Error handling is set by errors which may also be set to NULL
- meaning to use the default handling defined for the codec. Default
- error handling for all builtin codecs is "strict" (ValueErrors are
- raised).
-
- The codecs all use a similar interface. Only deviation from the
- generic ones are documented.
-
-*/
-
-/* --- Manage the default encoding ---------------------------------------- */
-
-/* Returns a pointer to the default encoding (UTF-8) of the
- Unicode object unicode and the size of the encoded representation
- in bytes stored in *size.
-
- In case of an error, no *size is set.
-
- This function caches the UTF-8 encoded string in the unicodeobject
- and subsequent calls will return the same string. The memory is released
- when the unicodeobject is deallocated.
-
- _PyUnicode_AsStringAndSize is a #define for PyUnicode_AsUTF8AndSize to
- support the previous internal function with the same behaviour.
-
- *** This API is for interpreter INTERNAL USE ONLY and will likely
- *** be removed or changed in the future.
-
- *** If you need to access the Unicode object as UTF-8 bytes string,
- *** please use PyUnicode_AsUTF8String() instead.
-*/
-
-#ifndef Py_LIMITED_API
-PyAPI_FUNC(const char *) PyUnicode_AsUTF8AndSize(
- PyObject *unicode,
- Py_ssize_t *size);
-#define _PyUnicode_AsStringAndSize PyUnicode_AsUTF8AndSize
-#endif
-
-/* Returns a pointer to the default encoding (UTF-8) of the
- Unicode object unicode.
-
- Like PyUnicode_AsUTF8AndSize(), this also caches the UTF-8 representation
- in the unicodeobject.
-
- _PyUnicode_AsString is a #define for PyUnicode_AsUTF8 to
- support the previous internal function with the same behaviour.
-
- Use of this API is DEPRECATED since no size information can be
- extracted from the returned data.
-
- *** This API is for interpreter INTERNAL USE ONLY and will likely
- *** be removed or changed for Python 3.1.
-
- *** If you need to access the Unicode object as UTF-8 bytes string,
- *** please use PyUnicode_AsUTF8String() instead.
-
-*/
-
-#ifndef Py_LIMITED_API
-PyAPI_FUNC(const char *) PyUnicode_AsUTF8(PyObject *unicode);
-#define _PyUnicode_AsString PyUnicode_AsUTF8
-#endif
-
-/* Returns "utf-8". */
-
-PyAPI_FUNC(const char*) PyUnicode_GetDefaultEncoding(void);
-
-/* --- Generic Codecs ----------------------------------------------------- */
-
-/* Create a Unicode object by decoding the encoded string s of the
- given size. */
-
-PyAPI_FUNC(PyObject*) PyUnicode_Decode(
- const char *s, /* encoded string */
- Py_ssize_t size, /* size of buffer */
- const char *encoding, /* encoding */
- const char *errors /* error handling */
- );
-
-/* Decode a Unicode object unicode and return the result as Python
- object.
-
- This API is DEPRECATED. The only supported standard encoding is rot13.
- Use PyCodec_Decode() to decode with rot13 and non-standard codecs
- that decode from str. */
-
-PyAPI_FUNC(PyObject*) PyUnicode_AsDecodedObject(
- PyObject *unicode, /* Unicode object */
- const char *encoding, /* encoding */
- const char *errors /* error handling */
- ) Py_DEPRECATED(3.6);
-
-/* Decode a Unicode object unicode and return the result as Unicode
- object.
-
- This API is DEPRECATED. The only supported standard encoding is rot13.
- Use PyCodec_Decode() to decode with rot13 and non-standard codecs
- that decode from str to str. */
-
-PyAPI_FUNC(PyObject*) PyUnicode_AsDecodedUnicode(
- PyObject *unicode, /* Unicode object */
- const char *encoding, /* encoding */
- const char *errors /* error handling */
- ) Py_DEPRECATED(3.6);
-
-/* Encodes a Py_UNICODE buffer of the given size and returns a
- Python string object. */
-
-#ifndef Py_LIMITED_API
-PyAPI_FUNC(PyObject*) PyUnicode_Encode(
- const Py_UNICODE *s, /* Unicode char buffer */
- Py_ssize_t size, /* number of Py_UNICODE chars to encode */
- const char *encoding, /* encoding */
- const char *errors /* error handling */
- ) Py_DEPRECATED(3.3);
-#endif
-
-/* Encodes a Unicode object and returns the result as Python
- object.
-
- This API is DEPRECATED. It is superseded by PyUnicode_AsEncodedString()
- since all standard encodings (except rot13) encode str to bytes.
- Use PyCodec_Encode() for encoding with rot13 and non-standard codecs
- that encode form str to non-bytes. */
-
-PyAPI_FUNC(PyObject*) PyUnicode_AsEncodedObject(
- PyObject *unicode, /* Unicode object */
- const char *encoding, /* encoding */
- const char *errors /* error handling */
- ) Py_DEPRECATED(3.6);
-
-/* Encodes a Unicode object and returns the result as Python string
- object. */
-
-PyAPI_FUNC(PyObject*) PyUnicode_AsEncodedString(
- PyObject *unicode, /* Unicode object */
- const char *encoding, /* encoding */
- const char *errors /* error handling */
- );
-
-/* Encodes a Unicode object and returns the result as Unicode
- object.
-
- This API is DEPRECATED. The only supported standard encodings is rot13.
- Use PyCodec_Encode() to encode with rot13 and non-standard codecs
- that encode from str to str. */
-
-PyAPI_FUNC(PyObject*) PyUnicode_AsEncodedUnicode(
- PyObject *unicode, /* Unicode object */
- const char *encoding, /* encoding */
- const char *errors /* error handling */
- ) Py_DEPRECATED(3.6);
-
-/* Build an encoding map. */
-
-PyAPI_FUNC(PyObject*) PyUnicode_BuildEncodingMap(
- PyObject* string /* 256 character map */
- );
-
-/* --- UTF-7 Codecs ------------------------------------------------------- */
-
-PyAPI_FUNC(PyObject*) PyUnicode_DecodeUTF7(
- const char *string, /* UTF-7 encoded string */
- Py_ssize_t length, /* size of string */
- const char *errors /* error handling */
- );
-
-PyAPI_FUNC(PyObject*) PyUnicode_DecodeUTF7Stateful(
- const char *string, /* UTF-7 encoded string */
- Py_ssize_t length, /* size of string */
- const char *errors, /* error handling */
- Py_ssize_t *consumed /* bytes consumed */
- );
-
-#ifndef Py_LIMITED_API
-PyAPI_FUNC(PyObject*) PyUnicode_EncodeUTF7(
- const Py_UNICODE *data, /* Unicode char buffer */
- Py_ssize_t length, /* number of Py_UNICODE chars to encode */
- int base64SetO, /* Encode RFC2152 Set O characters in base64 */
- int base64WhiteSpace, /* Encode whitespace (sp, ht, nl, cr) in base64 */
- const char *errors /* error handling */
- ) Py_DEPRECATED(3.3);
-PyAPI_FUNC(PyObject*) _PyUnicode_EncodeUTF7(
- PyObject *unicode, /* Unicode object */
- int base64SetO, /* Encode RFC2152 Set O characters in base64 */
- int base64WhiteSpace, /* Encode whitespace (sp, ht, nl, cr) in base64 */
- const char *errors /* error handling */
- );
-#endif
-
-/* --- UTF-8 Codecs ------------------------------------------------------- */
-
-PyAPI_FUNC(PyObject*) PyUnicode_DecodeUTF8(
- const char *string, /* UTF-8 encoded string */
- Py_ssize_t length, /* size of string */
- const char *errors /* error handling */
- );
-
-PyAPI_FUNC(PyObject*) PyUnicode_DecodeUTF8Stateful(
- const char *string, /* UTF-8 encoded string */
- Py_ssize_t length, /* size of string */
- const char *errors, /* error handling */
- Py_ssize_t *consumed /* bytes consumed */
- );
-
-PyAPI_FUNC(PyObject*) PyUnicode_AsUTF8String(
- PyObject *unicode /* Unicode object */
- );
-
-#ifndef Py_LIMITED_API
-PyAPI_FUNC(PyObject*) _PyUnicode_AsUTF8String(
- PyObject *unicode,
- const char *errors);
-
-PyAPI_FUNC(PyObject*) PyUnicode_EncodeUTF8(
- const Py_UNICODE *data, /* Unicode char buffer */
- Py_ssize_t length, /* number of Py_UNICODE chars to encode */
- const char *errors /* error handling */
- ) Py_DEPRECATED(3.3);
-#endif
-
-/* --- UTF-32 Codecs ------------------------------------------------------ */
-
-/* Decodes length bytes from a UTF-32 encoded buffer string and returns
- the corresponding Unicode object.
-
- errors (if non-NULL) defines the error handling. It defaults
- to "strict".
-
- If byteorder is non-NULL, the decoder starts decoding using the
- given byte order:
-
- *byteorder == -1: little endian
- *byteorder == 0: native order
- *byteorder == 1: big endian
-
- In native mode, the first four bytes of the stream are checked for a
- BOM mark. If found, the BOM mark is analysed, the byte order
- adjusted and the BOM skipped. In the other modes, no BOM mark
- interpretation is done. After completion, *byteorder is set to the
- current byte order at the end of input data.
-
- If byteorder is NULL, the codec starts in native order mode.
-
-*/
-
-PyAPI_FUNC(PyObject*) PyUnicode_DecodeUTF32(
- const char *string, /* UTF-32 encoded string */
- Py_ssize_t length, /* size of string */
- const char *errors, /* error handling */
- int *byteorder /* pointer to byteorder to use
- 0=native;-1=LE,1=BE; updated on
- exit */
- );
-
-PyAPI_FUNC(PyObject*) PyUnicode_DecodeUTF32Stateful(
- const char *string, /* UTF-32 encoded string */
- Py_ssize_t length, /* size of string */
- const char *errors, /* error handling */
- int *byteorder, /* pointer to byteorder to use
- 0=native;-1=LE,1=BE; updated on
- exit */
- Py_ssize_t *consumed /* bytes consumed */
- );
-
-/* Returns a Python string using the UTF-32 encoding in native byte
- order. The string always starts with a BOM mark. */
-
-PyAPI_FUNC(PyObject*) PyUnicode_AsUTF32String(
- PyObject *unicode /* Unicode object */
- );
-
-/* Returns a Python string object holding the UTF-32 encoded value of
- the Unicode data.
-
- If byteorder is not 0, output is written according to the following
- byte order:
-
- byteorder == -1: little endian
- byteorder == 0: native byte order (writes a BOM mark)
- byteorder == 1: big endian
-
- If byteorder is 0, the output string will always start with the
- Unicode BOM mark (U+FEFF). In the other two modes, no BOM mark is
- prepended.
-
-*/
-
-#ifndef Py_LIMITED_API
-PyAPI_FUNC(PyObject*) PyUnicode_EncodeUTF32(
- const Py_UNICODE *data, /* Unicode char buffer */
- Py_ssize_t length, /* number of Py_UNICODE chars to encode */
- const char *errors, /* error handling */
- int byteorder /* byteorder to use 0=BOM+native;-1=LE,1=BE */
- ) Py_DEPRECATED(3.3);
-PyAPI_FUNC(PyObject*) _PyUnicode_EncodeUTF32(
- PyObject *object, /* Unicode object */
- const char *errors, /* error handling */
- int byteorder /* byteorder to use 0=BOM+native;-1=LE,1=BE */
- );
-#endif
-
-/* --- UTF-16 Codecs ------------------------------------------------------ */
-
-/* Decodes length bytes from a UTF-16 encoded buffer string and returns
- the corresponding Unicode object.
-
- errors (if non-NULL) defines the error handling. It defaults
- to "strict".
-
- If byteorder is non-NULL, the decoder starts decoding using the
- given byte order:
-
- *byteorder == -1: little endian
- *byteorder == 0: native order
- *byteorder == 1: big endian
-
- In native mode, the first two bytes of the stream are checked for a
- BOM mark. If found, the BOM mark is analysed, the byte order
- adjusted and the BOM skipped. In the other modes, no BOM mark
- interpretation is done. After completion, *byteorder is set to the
- current byte order at the end of input data.
-
- If byteorder is NULL, the codec starts in native order mode.
-
-*/
-
-PyAPI_FUNC(PyObject*) PyUnicode_DecodeUTF16(
- const char *string, /* UTF-16 encoded string */
- Py_ssize_t length, /* size of string */
- const char *errors, /* error handling */
- int *byteorder /* pointer to byteorder to use
- 0=native;-1=LE,1=BE; updated on
- exit */
- );
-
-PyAPI_FUNC(PyObject*) PyUnicode_DecodeUTF16Stateful(
- const char *string, /* UTF-16 encoded string */
- Py_ssize_t length, /* size of string */
- const char *errors, /* error handling */
- int *byteorder, /* pointer to byteorder to use
- 0=native;-1=LE,1=BE; updated on
- exit */
- Py_ssize_t *consumed /* bytes consumed */
- );
-
-/* Returns a Python string using the UTF-16 encoding in native byte
- order. The string always starts with a BOM mark. */
-
-PyAPI_FUNC(PyObject*) PyUnicode_AsUTF16String(
- PyObject *unicode /* Unicode object */
- );
-
-/* Returns a Python string object holding the UTF-16 encoded value of
- the Unicode data.
-
- If byteorder is not 0, output is written according to the following
- byte order:
-
- byteorder == -1: little endian
- byteorder == 0: native byte order (writes a BOM mark)
- byteorder == 1: big endian
-
- If byteorder is 0, the output string will always start with the
- Unicode BOM mark (U+FEFF). In the other two modes, no BOM mark is
- prepended.
-
- Note that Py_UNICODE data is being interpreted as UTF-16 reduced to
- UCS-2. This trick makes it possible to add full UTF-16 capabilities
- at a later point without compromising the APIs.
-
-*/
-
-#ifndef Py_LIMITED_API
-PyAPI_FUNC(PyObject*) PyUnicode_EncodeUTF16(
- const Py_UNICODE *data, /* Unicode char buffer */
- Py_ssize_t length, /* number of Py_UNICODE chars to encode */
- const char *errors, /* error handling */
- int byteorder /* byteorder to use 0=BOM+native;-1=LE,1=BE */
- ) Py_DEPRECATED(3.3);
-PyAPI_FUNC(PyObject*) _PyUnicode_EncodeUTF16(
- PyObject* unicode, /* Unicode object */
- const char *errors, /* error handling */
- int byteorder /* byteorder to use 0=BOM+native;-1=LE,1=BE */
- );
-#endif
-
-/* --- Unicode-Escape Codecs ---------------------------------------------- */
-
-PyAPI_FUNC(PyObject*) PyUnicode_DecodeUnicodeEscape(
- const char *string, /* Unicode-Escape encoded string */
- Py_ssize_t length, /* size of string */
- const char *errors /* error handling */
- );
-
-#ifndef Py_LIMITED_API
-/* Helper for PyUnicode_DecodeUnicodeEscape that detects invalid escape
- chars. */
-PyAPI_FUNC(PyObject*) _PyUnicode_DecodeUnicodeEscape(
- const char *string, /* Unicode-Escape encoded string */
- Py_ssize_t length, /* size of string */
- const char *errors, /* error handling */
- const char **first_invalid_escape /* on return, points to first
- invalid escaped char in
- string. */
-);
-#endif
-
-PyAPI_FUNC(PyObject*) PyUnicode_AsUnicodeEscapeString(
- PyObject *unicode /* Unicode object */
- );
-
-#ifndef Py_LIMITED_API
-PyAPI_FUNC(PyObject*) PyUnicode_EncodeUnicodeEscape(
- const Py_UNICODE *data, /* Unicode char buffer */
- Py_ssize_t length /* Number of Py_UNICODE chars to encode */
- ) Py_DEPRECATED(3.3);
-#endif
-
-/* --- Raw-Unicode-Escape Codecs ------------------------------------------ */
-
-PyAPI_FUNC(PyObject*) PyUnicode_DecodeRawUnicodeEscape(
- const char *string, /* Raw-Unicode-Escape encoded string */
- Py_ssize_t length, /* size of string */
- const char *errors /* error handling */
- );
-
-PyAPI_FUNC(PyObject*) PyUnicode_AsRawUnicodeEscapeString(
- PyObject *unicode /* Unicode object */
- );
-
-#ifndef Py_LIMITED_API
-PyAPI_FUNC(PyObject*) PyUnicode_EncodeRawUnicodeEscape(
- const Py_UNICODE *data, /* Unicode char buffer */
- Py_ssize_t length /* Number of Py_UNICODE chars to encode */
- ) Py_DEPRECATED(3.3);
-#endif
-
-/* --- Unicode Internal Codec ---------------------------------------------
-
- Only for internal use in _codecsmodule.c */
-
-#ifndef Py_LIMITED_API
-PyObject *_PyUnicode_DecodeUnicodeInternal(
- const char *string,
- Py_ssize_t length,
- const char *errors
- );
-#endif
-
-/* --- Latin-1 Codecs -----------------------------------------------------
-
- Note: Latin-1 corresponds to the first 256 Unicode ordinals.
-
-*/
-
-PyAPI_FUNC(PyObject*) PyUnicode_DecodeLatin1(
- const char *string, /* Latin-1 encoded string */
- Py_ssize_t length, /* size of string */
- const char *errors /* error handling */
- );
-
-PyAPI_FUNC(PyObject*) PyUnicode_AsLatin1String(
- PyObject *unicode /* Unicode object */
- );
-
-#ifndef Py_LIMITED_API
-PyAPI_FUNC(PyObject*) _PyUnicode_AsLatin1String(
- PyObject* unicode,
- const char* errors);
-
-PyAPI_FUNC(PyObject*) PyUnicode_EncodeLatin1(
- const Py_UNICODE *data, /* Unicode char buffer */
- Py_ssize_t length, /* Number of Py_UNICODE chars to encode */
- const char *errors /* error handling */
- ) Py_DEPRECATED(3.3);
-#endif
-
-/* --- ASCII Codecs -------------------------------------------------------
-
- Only 7-bit ASCII data is excepted. All other codes generate errors.
-
-*/
-
-PyAPI_FUNC(PyObject*) PyUnicode_DecodeASCII(
- const char *string, /* ASCII encoded string */
- Py_ssize_t length, /* size of string */
- const char *errors /* error handling */
- );
-
-PyAPI_FUNC(PyObject*) PyUnicode_AsASCIIString(
- PyObject *unicode /* Unicode object */
- );
-
-#ifndef Py_LIMITED_API
-PyAPI_FUNC(PyObject*) _PyUnicode_AsASCIIString(
- PyObject* unicode,
- const char* errors);
-
-PyAPI_FUNC(PyObject*) PyUnicode_EncodeASCII(
- const Py_UNICODE *data, /* Unicode char buffer */
- Py_ssize_t length, /* Number of Py_UNICODE chars to encode */
- const char *errors /* error handling */
- ) Py_DEPRECATED(3.3);
-#endif
-
-/* --- Character Map Codecs -----------------------------------------------
-
- This codec uses mappings to encode and decode characters.
-
- Decoding mappings must map byte ordinals (integers in the range from 0 to
- 255) to Unicode strings, integers (which are then interpreted as Unicode
- ordinals) or None. Unmapped data bytes (ones which cause a LookupError)
- as well as mapped to None, 0xFFFE or '\ufffe' are treated as "undefined
- mapping" and cause an error.
-
- Encoding mappings must map Unicode ordinal integers to bytes objects,
- integers in the range from 0 to 255 or None. Unmapped character
- ordinals (ones which cause a LookupError) as well as mapped to
- None are treated as "undefined mapping" and cause an error.
-
-*/
-
-PyAPI_FUNC(PyObject*) PyUnicode_DecodeCharmap(
- const char *string, /* Encoded string */
- Py_ssize_t length, /* size of string */
- PyObject *mapping, /* decoding mapping */
- const char *errors /* error handling */
- );
-
-PyAPI_FUNC(PyObject*) PyUnicode_AsCharmapString(
- PyObject *unicode, /* Unicode object */
- PyObject *mapping /* encoding mapping */
- );
-
-#ifndef Py_LIMITED_API
-PyAPI_FUNC(PyObject*) PyUnicode_EncodeCharmap(
- const Py_UNICODE *data, /* Unicode char buffer */
- Py_ssize_t length, /* Number of Py_UNICODE chars to encode */
- PyObject *mapping, /* encoding mapping */
- const char *errors /* error handling */
- ) Py_DEPRECATED(3.3);
-PyAPI_FUNC(PyObject*) _PyUnicode_EncodeCharmap(
- PyObject *unicode, /* Unicode object */
- PyObject *mapping, /* encoding mapping */
- const char *errors /* error handling */
- );
-#endif
-
-/* Translate a Py_UNICODE buffer of the given length by applying a
- character mapping table to it and return the resulting Unicode
- object.
-
- The mapping table must map Unicode ordinal integers to Unicode strings,
- Unicode ordinal integers or None (causing deletion of the character).
-
- Mapping tables may be dictionaries or sequences. Unmapped character
- ordinals (ones which cause a LookupError) are left untouched and
- are copied as-is.
-
-*/
-
-#ifndef Py_LIMITED_API
-PyAPI_FUNC(PyObject *) PyUnicode_TranslateCharmap(
- const Py_UNICODE *data, /* Unicode char buffer */
- Py_ssize_t length, /* Number of Py_UNICODE chars to encode */
- PyObject *table, /* Translate table */
- const char *errors /* error handling */
- ) Py_DEPRECATED(3.3);
-#endif
-
-#ifdef MS_WINDOWS
-
-/* --- MBCS codecs for Windows -------------------------------------------- */
-
-PyAPI_FUNC(PyObject*) PyUnicode_DecodeMBCS(
- const char *string, /* MBCS encoded string */
- Py_ssize_t length, /* size of string */
- const char *errors /* error handling */
- );
-
-PyAPI_FUNC(PyObject*) PyUnicode_DecodeMBCSStateful(
- const char *string, /* MBCS encoded string */
- Py_ssize_t length, /* size of string */
- const char *errors, /* error handling */
- Py_ssize_t *consumed /* bytes consumed */
- );
-
-#if !defined(Py_LIMITED_API) || Py_LIMITED_API+0 >= 0x03030000
-PyAPI_FUNC(PyObject*) PyUnicode_DecodeCodePageStateful(
- int code_page, /* code page number */
- const char *string, /* encoded string */
- Py_ssize_t length, /* size of string */
- const char *errors, /* error handling */
- Py_ssize_t *consumed /* bytes consumed */
- );
-#endif
-
-PyAPI_FUNC(PyObject*) PyUnicode_AsMBCSString(
- PyObject *unicode /* Unicode object */
- );
-
-#ifndef Py_LIMITED_API
-PyAPI_FUNC(PyObject*) PyUnicode_EncodeMBCS(
- const Py_UNICODE *data, /* Unicode char buffer */
- Py_ssize_t length, /* number of Py_UNICODE chars to encode */
- const char *errors /* error handling */
- ) Py_DEPRECATED(3.3);
-#endif
-
-#if !defined(Py_LIMITED_API) || Py_LIMITED_API+0 >= 0x03030000
-PyAPI_FUNC(PyObject*) PyUnicode_EncodeCodePage(
- int code_page, /* code page number */
- PyObject *unicode, /* Unicode object */
- const char *errors /* error handling */
- );
-#endif
-
-#endif /* MS_WINDOWS */
-
-#ifndef Py_LIMITED_API
-/* --- Decimal Encoder ---------------------------------------------------- */
-
-/* Takes a Unicode string holding a decimal value and writes it into
- an output buffer using standard ASCII digit codes.
-
- The output buffer has to provide at least length+1 bytes of storage
- area. The output string is 0-terminated.
-
- The encoder converts whitespace to ' ', decimal characters to their
- corresponding ASCII digit and all other Latin-1 characters except
- \0 as-is. Characters outside this range (Unicode ordinals 1-256)
- are treated as errors. This includes embedded NULL bytes.
-
- Error handling is defined by the errors argument:
-
- NULL or "strict": raise a ValueError
- "ignore": ignore the wrong characters (these are not copied to the
- output buffer)
- "replace": replaces illegal characters with '?'
-
- Returns 0 on success, -1 on failure.
-
-*/
-
-PyAPI_FUNC(int) PyUnicode_EncodeDecimal(
- Py_UNICODE *s, /* Unicode buffer */
- Py_ssize_t length, /* Number of Py_UNICODE chars to encode */
- char *output, /* Output buffer; must have size >= length */
- const char *errors /* error handling */
- ) /* Py_DEPRECATED(3.3) */;
-
-/* Transforms code points that have decimal digit property to the
- corresponding ASCII digit code points.
-
- Returns a new Unicode string on success, NULL on failure.
-*/
-
-PyAPI_FUNC(PyObject*) PyUnicode_TransformDecimalToASCII(
- Py_UNICODE *s, /* Unicode buffer */
- Py_ssize_t length /* Number of Py_UNICODE chars to transform */
- ) /* Py_DEPRECATED(3.3) */;
-
-/* Coverts a Unicode object holding a decimal value to an ASCII string
- for using in int, float and complex parsers.
- Transforms code points that have decimal digit property to the
- corresponding ASCII digit code points. Transforms spaces to ASCII.
- Transforms code points starting from the first non-ASCII code point that
- is neither a decimal digit nor a space to the end into '?'. */
-
-PyAPI_FUNC(PyObject*) _PyUnicode_TransformDecimalAndSpaceToASCII(
- PyObject *unicode /* Unicode object */
- );
-#endif
-
-/* --- Locale encoding --------------------------------------------------- */
-
-#if !defined(Py_LIMITED_API) || Py_LIMITED_API+0 >= 0x03030000
-/* Decode a string from the current locale encoding. The decoder is strict if
- *surrogateescape* is equal to zero, otherwise it uses the 'surrogateescape'
- error handler (PEP 383) to escape undecodable bytes. If a byte sequence can
- be decoded as a surrogate character and *surrogateescape* is not equal to
- zero, the byte sequence is escaped using the 'surrogateescape' error handler
- instead of being decoded. *str* must end with a null character but cannot
- contain embedded null characters. */
-
-PyAPI_FUNC(PyObject*) PyUnicode_DecodeLocaleAndSize(
- const char *str,
- Py_ssize_t len,
- const char *errors);
-
-/* Similar to PyUnicode_DecodeLocaleAndSize(), but compute the string
- length using strlen(). */
-
-PyAPI_FUNC(PyObject*) PyUnicode_DecodeLocale(
- const char *str,
- const char *errors);
-
-/* Encode a Unicode object to the current locale encoding. The encoder is
- strict is *surrogateescape* is equal to zero, otherwise the
- "surrogateescape" error handler is used. Return a bytes object. The string
- cannot contain embedded null characters. */
-
-PyAPI_FUNC(PyObject*) PyUnicode_EncodeLocale(
- PyObject *unicode,
- const char *errors
- );
-#endif
-
-/* --- File system encoding ---------------------------------------------- */
-
-/* ParseTuple converter: encode str objects to bytes using
- PyUnicode_EncodeFSDefault(); bytes objects are output as-is. */
-
-PyAPI_FUNC(int) PyUnicode_FSConverter(PyObject*, void*);
-
-/* ParseTuple converter: decode bytes objects to unicode using
- PyUnicode_DecodeFSDefaultAndSize(); str objects are output as-is. */
-
-PyAPI_FUNC(int) PyUnicode_FSDecoder(PyObject*, void*);
-
-/* Decode a null-terminated string using Py_FileSystemDefaultEncoding
- and the "surrogateescape" error handler.
-
- If Py_FileSystemDefaultEncoding is not set, fall back to the locale
- encoding.
-
- Use PyUnicode_DecodeFSDefaultAndSize() if the string length is known.
-*/
-
-PyAPI_FUNC(PyObject*) PyUnicode_DecodeFSDefault(
- const char *s /* encoded string */
- );
-
-/* Decode a string using Py_FileSystemDefaultEncoding
- and the "surrogateescape" error handler.
-
- If Py_FileSystemDefaultEncoding is not set, fall back to the locale
- encoding.
-*/
-
-PyAPI_FUNC(PyObject*) PyUnicode_DecodeFSDefaultAndSize(
- const char *s, /* encoded string */
- Py_ssize_t size /* size */
- );
-
-/* Encode a Unicode object to Py_FileSystemDefaultEncoding with the
- "surrogateescape" error handler, and return bytes.
-
- If Py_FileSystemDefaultEncoding is not set, fall back to the locale
- encoding.
-*/
-
-PyAPI_FUNC(PyObject*) PyUnicode_EncodeFSDefault(
- PyObject *unicode
- );
-
-/* --- Methods & Slots ----------------------------------------------------
-
- These are capable of handling Unicode objects and strings on input
- (we refer to them as strings in the descriptions) and return
- Unicode objects or integers as appropriate. */
-
-/* Concat two strings giving a new Unicode string. */
-
-PyAPI_FUNC(PyObject*) PyUnicode_Concat(
- PyObject *left, /* Left string */
- PyObject *right /* Right string */
- );
-
-/* Concat two strings and put the result in *pleft
- (sets *pleft to NULL on error) */
-
-PyAPI_FUNC(void) PyUnicode_Append(
- PyObject **pleft, /* Pointer to left string */
- PyObject *right /* Right string */
- );
-
-/* Concat two strings, put the result in *pleft and drop the right object
- (sets *pleft to NULL on error) */
-
-PyAPI_FUNC(void) PyUnicode_AppendAndDel(
- PyObject **pleft, /* Pointer to left string */
- PyObject *right /* Right string */
- );
-
-/* Split a string giving a list of Unicode strings.
-
- If sep is NULL, splitting will be done at all whitespace
- substrings. Otherwise, splits occur at the given separator.
-
- At most maxsplit splits will be done. If negative, no limit is set.
-
- Separators are not included in the resulting list.
-
-*/
-
-PyAPI_FUNC(PyObject*) PyUnicode_Split(
- PyObject *s, /* String to split */
- PyObject *sep, /* String separator */
- Py_ssize_t maxsplit /* Maxsplit count */
- );
-
-/* Dito, but split at line breaks.
-
- CRLF is considered to be one line break. Line breaks are not
- included in the resulting list. */
-
-PyAPI_FUNC(PyObject*) PyUnicode_Splitlines(
- PyObject *s, /* String to split */
- int keepends /* If true, line end markers are included */
- );
-
-/* Partition a string using a given separator. */
-
-PyAPI_FUNC(PyObject*) PyUnicode_Partition(
- PyObject *s, /* String to partition */
- PyObject *sep /* String separator */
- );
-
-/* Partition a string using a given separator, searching from the end of the
- string. */
-
-PyAPI_FUNC(PyObject*) PyUnicode_RPartition(
- PyObject *s, /* String to partition */
- PyObject *sep /* String separator */
- );
-
-/* Split a string giving a list of Unicode strings.
-
- If sep is NULL, splitting will be done at all whitespace
- substrings. Otherwise, splits occur at the given separator.
-
- At most maxsplit splits will be done. But unlike PyUnicode_Split
- PyUnicode_RSplit splits from the end of the string. If negative,
- no limit is set.
-
- Separators are not included in the resulting list.
-
-*/
-
-PyAPI_FUNC(PyObject*) PyUnicode_RSplit(
- PyObject *s, /* String to split */
- PyObject *sep, /* String separator */
- Py_ssize_t maxsplit /* Maxsplit count */
- );
-
-/* Translate a string by applying a character mapping table to it and
- return the resulting Unicode object.
-
- The mapping table must map Unicode ordinal integers to Unicode strings,
- Unicode ordinal integers or None (causing deletion of the character).
-
- Mapping tables may be dictionaries or sequences. Unmapped character
- ordinals (ones which cause a LookupError) are left untouched and
- are copied as-is.
-
-*/
-
-PyAPI_FUNC(PyObject *) PyUnicode_Translate(
- PyObject *str, /* String */
- PyObject *table, /* Translate table */
- const char *errors /* error handling */
- );
-
-/* Join a sequence of strings using the given separator and return
- the resulting Unicode string. */
-
-PyAPI_FUNC(PyObject*) PyUnicode_Join(
- PyObject *separator, /* Separator string */
- PyObject *seq /* Sequence object */
- );
-
-#ifndef Py_LIMITED_API
-PyAPI_FUNC(PyObject *) _PyUnicode_JoinArray(
- PyObject *separator,
- PyObject *const *items,
- Py_ssize_t seqlen
- );
-#endif /* Py_LIMITED_API */
-
-/* Return 1 if substr matches str[start:end] at the given tail end, 0
- otherwise. */
-
-PyAPI_FUNC(Py_ssize_t) PyUnicode_Tailmatch(
- PyObject *str, /* String */
- PyObject *substr, /* Prefix or Suffix string */
- Py_ssize_t start, /* Start index */
- Py_ssize_t end, /* Stop index */
- int direction /* Tail end: -1 prefix, +1 suffix */
- );
-
-/* Return the first position of substr in str[start:end] using the
- given search direction or -1 if not found. -2 is returned in case
- an error occurred and an exception is set. */
-
-PyAPI_FUNC(Py_ssize_t) PyUnicode_Find(
- PyObject *str, /* String */
- PyObject *substr, /* Substring to find */
- Py_ssize_t start, /* Start index */
- Py_ssize_t end, /* Stop index */
- int direction /* Find direction: +1 forward, -1 backward */
- );
-
-#if !defined(Py_LIMITED_API) || Py_LIMITED_API+0 >= 0x03030000
-/* Like PyUnicode_Find, but search for single character only. */
-PyAPI_FUNC(Py_ssize_t) PyUnicode_FindChar(
- PyObject *str,
- Py_UCS4 ch,
- Py_ssize_t start,
- Py_ssize_t end,
- int direction
- );
-#endif
-
-/* Count the number of occurrences of substr in str[start:end]. */
-
-PyAPI_FUNC(Py_ssize_t) PyUnicode_Count(
- PyObject *str, /* String */
- PyObject *substr, /* Substring to count */
- Py_ssize_t start, /* Start index */
- Py_ssize_t end /* Stop index */
- );
-
-/* Replace at most maxcount occurrences of substr in str with replstr
- and return the resulting Unicode object. */
-
-PyAPI_FUNC(PyObject *) PyUnicode_Replace(
- PyObject *str, /* String */
- PyObject *substr, /* Substring to find */
- PyObject *replstr, /* Substring to replace */
- Py_ssize_t maxcount /* Max. number of replacements to apply;
- -1 = all */
- );
-
-/* Compare two strings and return -1, 0, 1 for less than, equal,
- greater than resp.
- Raise an exception and return -1 on error. */
-
-PyAPI_FUNC(int) PyUnicode_Compare(
- PyObject *left, /* Left string */
- PyObject *right /* Right string */
- );
-
-#ifndef Py_LIMITED_API
-/* Test whether a unicode is equal to ASCII identifier. Return 1 if true,
- 0 otherwise. The right argument must be ASCII identifier.
- Any error occurs inside will be cleared before return. */
-
-PyAPI_FUNC(int) _PyUnicode_EqualToASCIIId(
- PyObject *left, /* Left string */
- _Py_Identifier *right /* Right identifier */
- );
-#endif
-
-/* Compare a Unicode object with C string and return -1, 0, 1 for less than,
- equal, and greater than, respectively. It is best to pass only
- ASCII-encoded strings, but the function interprets the input string as
- ISO-8859-1 if it contains non-ASCII characters.
- This function does not raise exceptions. */
-
-PyAPI_FUNC(int) PyUnicode_CompareWithASCIIString(
- PyObject *left,
- const char *right /* ASCII-encoded string */
- );
-
-#ifndef Py_LIMITED_API
-/* Test whether a unicode is equal to ASCII string. Return 1 if true,
- 0 otherwise. The right argument must be ASCII-encoded string.
- Any error occurs inside will be cleared before return. */
-
-PyAPI_FUNC(int) _PyUnicode_EqualToASCIIString(
- PyObject *left,
- const char *right /* ASCII-encoded string */
- );
-#endif
-
-/* Rich compare two strings and return one of the following:
-
- - NULL in case an exception was raised
- - Py_True or Py_False for successful comparisons
- - Py_NotImplemented in case the type combination is unknown
-
- Possible values for op:
-
- Py_GT, Py_GE, Py_EQ, Py_NE, Py_LT, Py_LE
-
-*/
-
-PyAPI_FUNC(PyObject *) PyUnicode_RichCompare(
- PyObject *left, /* Left string */
- PyObject *right, /* Right string */
- int op /* Operation: Py_EQ, Py_NE, Py_GT, etc. */
- );
-
-/* Apply an argument tuple or dictionary to a format string and return
- the resulting Unicode string. */
-
-PyAPI_FUNC(PyObject *) PyUnicode_Format(
- PyObject *format, /* Format string */
- PyObject *args /* Argument tuple or dictionary */
- );
-
-/* Checks whether element is contained in container and return 1/0
- accordingly.
-
- element has to coerce to a one element Unicode string. -1 is
- returned in case of an error. */
-
-PyAPI_FUNC(int) PyUnicode_Contains(
- PyObject *container, /* Container string */
- PyObject *element /* Element string */
- );
-
-/* Checks whether argument is a valid identifier. */
-
-PyAPI_FUNC(int) PyUnicode_IsIdentifier(PyObject *s);
-
-#ifndef Py_LIMITED_API
-/* Externally visible for str.strip(unicode) */
-PyAPI_FUNC(PyObject *) _PyUnicode_XStrip(
- PyObject *self,
- int striptype,
- PyObject *sepobj
- );
-#endif
-
-/* Using explicit passed-in values, insert the thousands grouping
- into the string pointed to by buffer. For the argument descriptions,
- see Objects/stringlib/localeutil.h */
-#ifndef Py_LIMITED_API
-PyAPI_FUNC(Py_ssize_t) _PyUnicode_InsertThousandsGrouping(
- _PyUnicodeWriter *writer,
- Py_ssize_t n_buffer,
- PyObject *digits,
- Py_ssize_t d_pos,
- Py_ssize_t n_digits,
- Py_ssize_t min_width,
- const char *grouping,
- PyObject *thousands_sep,
- Py_UCS4 *maxchar);
-#endif
-/* === Characters Type APIs =============================================== */
-
-/* Helper array used by Py_UNICODE_ISSPACE(). */
-
-#ifndef Py_LIMITED_API
-PyAPI_DATA(const unsigned char) _Py_ascii_whitespace[];
-
-/* These should not be used directly. Use the Py_UNICODE_IS* and
- Py_UNICODE_TO* macros instead.
-
- These APIs are implemented in Objects/unicodectype.c.
-
-*/
-
-PyAPI_FUNC(int) _PyUnicode_IsLowercase(
- Py_UCS4 ch /* Unicode character */
- );
-
-PyAPI_FUNC(int) _PyUnicode_IsUppercase(
- Py_UCS4 ch /* Unicode character */
- );
-
-PyAPI_FUNC(int) _PyUnicode_IsTitlecase(
- Py_UCS4 ch /* Unicode character */
- );
-
-PyAPI_FUNC(int) _PyUnicode_IsXidStart(
- Py_UCS4 ch /* Unicode character */
- );
-
-PyAPI_FUNC(int) _PyUnicode_IsXidContinue(
- Py_UCS4 ch /* Unicode character */
- );
-
-PyAPI_FUNC(int) _PyUnicode_IsWhitespace(
- const Py_UCS4 ch /* Unicode character */
- );
-
-PyAPI_FUNC(int) _PyUnicode_IsLinebreak(
- const Py_UCS4 ch /* Unicode character */
- );
-
-PyAPI_FUNC(Py_UCS4) _PyUnicode_ToLowercase(
- Py_UCS4 ch /* Unicode character */
- ) /* Py_DEPRECATED(3.3) */;
-
-PyAPI_FUNC(Py_UCS4) _PyUnicode_ToUppercase(
- Py_UCS4 ch /* Unicode character */
- ) /* Py_DEPRECATED(3.3) */;
-
-PyAPI_FUNC(Py_UCS4) _PyUnicode_ToTitlecase(
- Py_UCS4 ch /* Unicode character */
- ) Py_DEPRECATED(3.3);
-
-PyAPI_FUNC(int) _PyUnicode_ToLowerFull(
- Py_UCS4 ch, /* Unicode character */
- Py_UCS4 *res
- );
-
-PyAPI_FUNC(int) _PyUnicode_ToTitleFull(
- Py_UCS4 ch, /* Unicode character */
- Py_UCS4 *res
- );
-
-PyAPI_FUNC(int) _PyUnicode_ToUpperFull(
- Py_UCS4 ch, /* Unicode character */
- Py_UCS4 *res
- );
-
-PyAPI_FUNC(int) _PyUnicode_ToFoldedFull(
- Py_UCS4 ch, /* Unicode character */
- Py_UCS4 *res
- );
-
-PyAPI_FUNC(int) _PyUnicode_IsCaseIgnorable(
- Py_UCS4 ch /* Unicode character */
- );
-
-PyAPI_FUNC(int) _PyUnicode_IsCased(
- Py_UCS4 ch /* Unicode character */
- );
-
-PyAPI_FUNC(int) _PyUnicode_ToDecimalDigit(
- Py_UCS4 ch /* Unicode character */
- );
-
-PyAPI_FUNC(int) _PyUnicode_ToDigit(
- Py_UCS4 ch /* Unicode character */
- );
-
-PyAPI_FUNC(double) _PyUnicode_ToNumeric(
- Py_UCS4 ch /* Unicode character */
- );
-
-PyAPI_FUNC(int) _PyUnicode_IsDecimalDigit(
- Py_UCS4 ch /* Unicode character */
- );
-
-PyAPI_FUNC(int) _PyUnicode_IsDigit(
- Py_UCS4 ch /* Unicode character */
- );
-
-PyAPI_FUNC(int) _PyUnicode_IsNumeric(
- Py_UCS4 ch /* Unicode character */
- );
-
-PyAPI_FUNC(int) _PyUnicode_IsPrintable(
- Py_UCS4 ch /* Unicode character */
- );
-
-PyAPI_FUNC(int) _PyUnicode_IsAlpha(
- Py_UCS4 ch /* Unicode character */
- );
-
-PyAPI_FUNC(size_t) Py_UNICODE_strlen(
- const Py_UNICODE *u
- ) Py_DEPRECATED(3.3);
-
-PyAPI_FUNC(Py_UNICODE*) Py_UNICODE_strcpy(
- Py_UNICODE *s1,
- const Py_UNICODE *s2) Py_DEPRECATED(3.3);
-
-PyAPI_FUNC(Py_UNICODE*) Py_UNICODE_strcat(
- Py_UNICODE *s1, const Py_UNICODE *s2) Py_DEPRECATED(3.3);
-
-PyAPI_FUNC(Py_UNICODE*) Py_UNICODE_strncpy(
- Py_UNICODE *s1,
- const Py_UNICODE *s2,
- size_t n) Py_DEPRECATED(3.3);
-
-PyAPI_FUNC(int) Py_UNICODE_strcmp(
- const Py_UNICODE *s1,
- const Py_UNICODE *s2
- ) Py_DEPRECATED(3.3);
-
-PyAPI_FUNC(int) Py_UNICODE_strncmp(
- const Py_UNICODE *s1,
- const Py_UNICODE *s2,
- size_t n
- ) Py_DEPRECATED(3.3);
-
-PyAPI_FUNC(Py_UNICODE*) Py_UNICODE_strchr(
- const Py_UNICODE *s,
- Py_UNICODE c
- ) Py_DEPRECATED(3.3);
-
-PyAPI_FUNC(Py_UNICODE*) Py_UNICODE_strrchr(
- const Py_UNICODE *s,
- Py_UNICODE c
- ) Py_DEPRECATED(3.3);
-
-PyAPI_FUNC(PyObject*) _PyUnicode_FormatLong(PyObject *, int, int, int);
-
-/* Create a copy of a unicode string ending with a nul character. Return NULL
- and raise a MemoryError exception on memory allocation failure, otherwise
- return a new allocated buffer (use PyMem_Free() to free the buffer). */
-
-PyAPI_FUNC(Py_UNICODE*) PyUnicode_AsUnicodeCopy(
- PyObject *unicode
- ) Py_DEPRECATED(3.3);
-#endif /* Py_LIMITED_API */
-
-#if defined(Py_DEBUG) && !defined(Py_LIMITED_API)
-PyAPI_FUNC(int) _PyUnicode_CheckConsistency(
- PyObject *op,
- int check_content);
-#elif !defined(NDEBUG)
-/* For asserts that call _PyUnicode_CheckConsistency(), which would
- * otherwise be a problem when building with asserts but without Py_DEBUG. */
-#define _PyUnicode_CheckConsistency(op, check_content) PyUnicode_Check(op)
-#endif
-
-#ifndef Py_LIMITED_API
-/* Return an interned Unicode object for an Identifier; may fail if there is no memory.*/
-PyAPI_FUNC(PyObject*) _PyUnicode_FromId(_Py_Identifier*);
-/* Clear all static strings. */
-PyAPI_FUNC(void) _PyUnicode_ClearStaticStrings(void);
-
-/* Fast equality check when the inputs are known to be exact unicode types
- and where the hash values are equal (i.e. a very probable match) */
-PyAPI_FUNC(int) _PyUnicode_EQ(PyObject *, PyObject *);
-#endif /* !Py_LIMITED_API */
-
-#ifdef __cplusplus
-}
-#endif
-#endif /* !Py_UNICODEOBJECT_H */
diff --git a/pythonsdk/include/warnings.h b/pythonsdk/include/warnings.h
deleted file mode 100644
index a1ec42525b427e5423a70570d12d7f43a9926237..0000000000000000000000000000000000000000
--- a/pythonsdk/include/warnings.h
+++ /dev/null
@@ -1,67 +0,0 @@
-#ifndef Py_WARNINGS_H
-#define Py_WARNINGS_H
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-#ifndef Py_LIMITED_API
-PyAPI_FUNC(PyObject*) _PyWarnings_Init(void);
-#endif
-
-PyAPI_FUNC(int) PyErr_WarnEx(
- PyObject *category,
- const char *message, /* UTF-8 encoded string */
- Py_ssize_t stack_level);
-PyAPI_FUNC(int) PyErr_WarnFormat(
- PyObject *category,
- Py_ssize_t stack_level,
- const char *format, /* ASCII-encoded string */
- ...);
-
-#if !defined(Py_LIMITED_API) || Py_LIMITED_API+0 >= 0x03060000
-/* Emit a ResourceWarning warning */
-PyAPI_FUNC(int) PyErr_ResourceWarning(
- PyObject *source,
- Py_ssize_t stack_level,
- const char *format, /* ASCII-encoded string */
- ...);
-#endif
-#ifndef Py_LIMITED_API
-PyAPI_FUNC(int) PyErr_WarnExplicitObject(
- PyObject *category,
- PyObject *message,
- PyObject *filename,
- int lineno,
- PyObject *module,
- PyObject *registry);
-#endif
-PyAPI_FUNC(int) PyErr_WarnExplicit(
- PyObject *category,
- const char *message, /* UTF-8 encoded string */
- const char *filename, /* decoded from the filesystem encoding */
- int lineno,
- const char *module, /* UTF-8 encoded string */
- PyObject *registry);
-
-#ifndef Py_LIMITED_API
-PyAPI_FUNC(int)
-PyErr_WarnExplicitFormat(PyObject *category,
- const char *filename, int lineno,
- const char *module, PyObject *registry,
- const char *format, ...);
-#endif
-
-/* DEPRECATED: Use PyErr_WarnEx() instead. */
-#ifndef Py_LIMITED_API
-#define PyErr_Warn(category, msg) PyErr_WarnEx(category, msg, 1)
-#endif
-
-#ifndef Py_LIMITED_API
-void _PyErr_WarnUnawaitedCoroutine(PyObject *coro);
-#endif
-
-#ifdef __cplusplus
-}
-#endif
-#endif /* !Py_WARNINGS_H */
-
diff --git a/pythonsdk/include/weakrefobject.h b/pythonsdk/include/weakrefobject.h
deleted file mode 100644
index 87acf95c2c8873a22967c5a24bcb6044ea211e4b..0000000000000000000000000000000000000000
--- a/pythonsdk/include/weakrefobject.h
+++ /dev/null
@@ -1,86 +0,0 @@
-/* Weak references objects for Python. */
-
-#ifndef Py_WEAKREFOBJECT_H
-#define Py_WEAKREFOBJECT_H
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-
-typedef struct _PyWeakReference PyWeakReference;
-
-/* PyWeakReference is the base struct for the Python ReferenceType, ProxyType,
- * and CallableProxyType.
- */
-#ifndef Py_LIMITED_API
-struct _PyWeakReference {
- PyObject_HEAD
-
- /* The object to which this is a weak reference, or Py_None if none.
- * Note that this is a stealth reference: wr_object's refcount is
- * not incremented to reflect this pointer.
- */
- PyObject *wr_object;
-
- /* A callable to invoke when wr_object dies, or NULL if none. */
- PyObject *wr_callback;
-
- /* A cache for wr_object's hash code. As usual for hashes, this is -1
- * if the hash code isn't known yet.
- */
- Py_hash_t hash;
-
- /* If wr_object is weakly referenced, wr_object has a doubly-linked NULL-
- * terminated list of weak references to it. These are the list pointers.
- * If wr_object goes away, wr_object is set to Py_None, and these pointers
- * have no meaning then.
- */
- PyWeakReference *wr_prev;
- PyWeakReference *wr_next;
-};
-#endif
-
-PyAPI_DATA(PyTypeObject) _PyWeakref_RefType;
-PyAPI_DATA(PyTypeObject) _PyWeakref_ProxyType;
-PyAPI_DATA(PyTypeObject) _PyWeakref_CallableProxyType;
-
-#define PyWeakref_CheckRef(op) PyObject_TypeCheck(op, &_PyWeakref_RefType)
-#define PyWeakref_CheckRefExact(op) \
- (Py_TYPE(op) == &_PyWeakref_RefType)
-#define PyWeakref_CheckProxy(op) \
- ((Py_TYPE(op) == &_PyWeakref_ProxyType) || \
- (Py_TYPE(op) == &_PyWeakref_CallableProxyType))
-
-#define PyWeakref_Check(op) \
- (PyWeakref_CheckRef(op) || PyWeakref_CheckProxy(op))
-
-
-PyAPI_FUNC(PyObject *) PyWeakref_NewRef(PyObject *ob,
- PyObject *callback);
-PyAPI_FUNC(PyObject *) PyWeakref_NewProxy(PyObject *ob,
- PyObject *callback);
-PyAPI_FUNC(PyObject *) PyWeakref_GetObject(PyObject *ref);
-
-#ifndef Py_LIMITED_API
-PyAPI_FUNC(Py_ssize_t) _PyWeakref_GetWeakrefCount(PyWeakReference *head);
-
-PyAPI_FUNC(void) _PyWeakref_ClearRef(PyWeakReference *self);
-#endif
-
-/* Explanation for the Py_REFCNT() check: when a weakref's target is part
- of a long chain of deallocations which triggers the trashcan mechanism,
- clearing the weakrefs can be delayed long after the target's refcount
- has dropped to zero. In the meantime, code accessing the weakref will
- be able to "see" the target object even though it is supposed to be
- unreachable. See issue #16602. */
-
-#define PyWeakref_GET_OBJECT(ref) \
- (Py_REFCNT(((PyWeakReference *)(ref))->wr_object) > 0 \
- ? ((PyWeakReference *)(ref))->wr_object \
- : Py_None)
-
-
-#ifdef __cplusplus
-}
-#endif
-#endif /* !Py_WEAKREFOBJECT_H */
diff --git a/pythonsdk/libs/libpython37.a b/pythonsdk/libs/libpython37.a
deleted file mode 100644
index dabc65697caa7016ae61801c2bfc5310a6a3a06b..0000000000000000000000000000000000000000
Binary files a/pythonsdk/libs/libpython37.a and /dev/null differ
diff --git a/pythonsdk/libs/python3.lib b/pythonsdk/libs/python3.lib
deleted file mode 100644
index c0bca487269aec9a80ea651a6945d0cc00ae0c8a..0000000000000000000000000000000000000000
Binary files a/pythonsdk/libs/python3.lib and /dev/null differ
diff --git a/pythonsdk/libs/python37.lib b/pythonsdk/libs/python37.lib
deleted file mode 100644
index 535fea812146aa5e5af1e9f3b2089b0019c0f1e7..0000000000000000000000000000000000000000
Binary files a/pythonsdk/libs/python37.lib and /dev/null differ
diff --git a/requirements.txt b/requirements.txt
deleted file mode 100644
index fb4dcd6c782332e8787da4708acea0ad888824ae..0000000000000000000000000000000000000000
--- a/requirements.txt
+++ /dev/null
@@ -1,21 +0,0 @@
-adao
-openturns
-OWSLib
-jupyter
-zipp
-ipython
-ipywidgets
-mpi4py
-pyproj
-folium
-pandas
-numpy
-scipy
-kiwisolver
-matplotlib
-pandas
-alphashape
-openpyxl
-pylint
-doxypypy
-pyqt5
diff --git a/wheels/Fiona-1.8.21-cp310-cp310-win_amd64.whl b/wheels/Fiona-1.8.21-cp310-cp310-win_amd64.whl
new file mode 100644
index 0000000000000000000000000000000000000000..287107918d44d9bb12eae70e249a00896da23d2a
--- /dev/null
+++ b/wheels/Fiona-1.8.21-cp310-cp310-win_amd64.whl
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:20cb819eef56c57f356cce4fea3b0384da956aab20beed4b2826b73acf1a04b5
+size 540558
diff --git a/wheels/Fiona-1.8.21-cp37-cp37m-win_amd64.whl b/wheels/Fiona-1.8.21-cp37-cp37m-win_amd64.whl
deleted file mode 100644
index 51eb5b2860fd1a65e61e8aab2366ef1077bd1b1f..0000000000000000000000000000000000000000
--- a/wheels/Fiona-1.8.21-cp37-cp37m-win_amd64.whl
+++ /dev/null
@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:b0dcebaf5f68da5a95f4fed98857a11b2de9bc88aaabd333a4b717b35dfbe415
-size 532168
diff --git a/wheels/GDAL-3.4.2-cp37-cp37m-win_amd64.whl b/wheels/GDAL-3.4.2-cp37-cp37m-win_amd64.whl
deleted file mode 100644
index 794c56f8a214b5a14c483aac24bc52a81795a960..0000000000000000000000000000000000000000
--- a/wheels/GDAL-3.4.2-cp37-cp37m-win_amd64.whl
+++ /dev/null
@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:f85da79cdf1f7f9e20a3cc9c66d68dc72fc6a6eeb389b0661257fe8a4965ed24
-size 25616046
diff --git a/wheels/GDAL-3.4.3-cp310-cp310-win_amd64.whl b/wheels/GDAL-3.4.3-cp310-cp310-win_amd64.whl
new file mode 100644
index 0000000000000000000000000000000000000000..7bf8778a05b8f8bea84043f57907c8dead0aa4a7
--- /dev/null
+++ b/wheels/GDAL-3.4.3-cp310-cp310-win_amd64.whl
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:9893da5532a6c5dadc1fc3bc402ae29d161b7cf190d778f129da84d0e50baa29
+size 25754978
diff --git a/wheels/Shapely-1.8.1.post1-cp37-cp37m-win_amd64.whl b/wheels/Shapely-1.8.1.post1-cp37-cp37m-win_amd64.whl
deleted file mode 100644
index 545605b12d523cec523b70d03835ac9b0b081523..0000000000000000000000000000000000000000
--- a/wheels/Shapely-1.8.1.post1-cp37-cp37m-win_amd64.whl
+++ /dev/null
@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:1a7b1e9695cc44fd1c590980e4615735bd117827b9c4572b0166c6aae344def6
-size 984994
diff --git a/wheels/Shapely-1.8.2-cp310-cp310-win_amd64.whl b/wheels/Shapely-1.8.2-cp310-cp310-win_amd64.whl
new file mode 100644
index 0000000000000000000000000000000000000000..5f57e66fbd755284448e7befbded92cc40e17368
--- /dev/null
+++ b/wheels/Shapely-1.8.2-cp310-cp310-win_amd64.whl
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:b2e5d9af166ab78d9b6abfb2659a41b28af2999f57e8afd878bf8686f6a20b78
+size 988260
diff --git a/wheels/rasterio-1.2.10-cp310-cp310-win_amd64.whl b/wheels/rasterio-1.2.10-cp310-cp310-win_amd64.whl
new file mode 100644
index 0000000000000000000000000000000000000000..b9d13eacdb9d42ab09d35d1f76156d45910b5a5b
--- /dev/null
+++ b/wheels/rasterio-1.2.10-cp310-cp310-win_amd64.whl
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:5631b57d5f45646bdbfb8b43f84ec7aba67ca30983781f26e430251dfad89e7f
+size 1193598
diff --git a/wheels/rasterio-1.2.10-cp37-cp37m-win_amd64.whl b/wheels/rasterio-1.2.10-cp37-cp37m-win_amd64.whl
deleted file mode 100644
index 5ad52d115366eb3329dce55e44326f0c23e862a6..0000000000000000000000000000000000000000
--- a/wheels/rasterio-1.2.10-cp37-cp37m-win_amd64.whl
+++ /dev/null
@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:820e8701231c4e426fa29df964b75c1d8d076ec03f31b57667f385a7aca45f65
-size 1139006