From 786844e316552992bc7232ca55dc67720ac28d8f Mon Sep 17 00:00:00 2001 From: haokunzheng Date: Wed, 11 Jun 2025 10:32:55 +0800 Subject: [PATCH 1/4] add python lib --- .../include/Python-ast.h | 637 + .../python_build_dependency/include/Python.h | 159 + .../include/abstract.h | 1109 + .../python_build_dependency/include/accu.h | 37 + .../python_build_dependency/include/asdl.h | 46 + .../python_build_dependency/include/ast.h | 29 + .../python_build_dependency/include/bitset.h | 32 + .../include/bltinmodule.h | 14 + .../include/boolobject.h | 34 + .../include/bytearrayobject.h | 62 + .../include/bytes_methods.h | 69 + .../include/bytesobject.h | 224 + .../include/cellobject.h | 29 + .../python_build_dependency/include/ceval.h | 239 + .../include/classobject.h | 58 + .../python_build_dependency/include/code.h | 157 + .../python_build_dependency/include/codecs.h | 240 + .../python_build_dependency/include/compile.h | 93 + .../include/complexobject.h | 69 + .../python_build_dependency/include/context.h | 84 + .../include/datetime.h | 273 + .../include/descrobject.h | 110 + .../include/dictobject.h | 179 + .../python_build_dependency/include/dtoa.h | 19 + .../include/dynamic_annotations.h | 499 + .../include/enumobject.h | 17 + .../python_build_dependency/include/errcode.h | 38 + .../python_build_dependency/include/eval.h | 37 + .../include/fileobject.h | 55 + .../include/fileutils.h | 201 + .../include/floatobject.h | 130 + .../include/frameobject.h | 93 + .../include/funcobject.h | 103 + .../include/genobject.h | 105 + .../include/graminit.h | 89 + .../python_build_dependency/include/grammar.h | 94 + .../python_build_dependency/include/import.h | 151 + .../include/internal/ceval.h | 52 + .../include/internal/condvar.h | 91 + .../include/internal/context.h | 41 + .../include/internal/gil.h | 46 + .../include/internal/hamt.h | 113 + .../include/internal/hash.h | 6 + .../include/internal/import.h | 6 + .../include/internal/mem.h | 175 + .../include/internal/pygetopt.h | 19 + .../include/internal/pystate.h | 135 + .../include/internal/warnings.h | 21 + .../include/intrcheck.h | 33 + .../include/iterobject.h | 25 + .../include/listobject.h | 81 + .../include/longintrepr.h | 99 + .../include/longobject.h | 220 + .../python_build_dependency/include/marshal.h | 28 + .../include/memoryobject.h | 72 + .../include/metagrammar.h | 18 + .../include/methodobject.h | 135 + .../include/modsupport.h | 229 + .../include/moduleobject.h | 89 + .../include/namespaceobject.h | 19 + .../python_build_dependency/include/node.h | 44 + .../python_build_dependency/include/object.h | 1105 + .../python_build_dependency/include/objimpl.h | 374 + .../include/odictobject.h | 43 + .../python_build_dependency/include/opcode.h | 147 + .../python_build_dependency/include/osdefs.h | 47 + .../include/osmodule.h | 17 + .../include/parsetok.h | 108 + .../include/patchlevel.h | 35 + .../python_build_dependency/include/pgen.h | 18 + .../include/pgenheaders.h | 43 + .../include/py_curses.h | 159 + .../python_build_dependency/include/pyarena.h | 64 + .../include/pyatomic.h | 535 + .../include/pycapsule.h | 59 + .../include/pyconfig.h | 684 + .../python_build_dependency/include/pyctype.h | 33 + .../python_build_dependency/include/pydebug.h | 40 + .../include/pydtrace.d | 21 + .../include/pydtrace.h | 57 + .../include/pyerrors.h | 504 + .../python_build_dependency/include/pyexpat.h | 55 + .../python_build_dependency/include/pyfpe.h | 12 + .../python_build_dependency/include/pyhash.h | 145 + .../include/pylifecycle.h | 239 + .../include/pymacconfig.h | 102 + .../python_build_dependency/include/pymacro.h | 100 + .../python_build_dependency/include/pymath.h | 230 + .../python_build_dependency/include/pymem.h | 244 + .../python_build_dependency/include/pyport.h | 793 + .../python_build_dependency/include/pystate.h | 456 + .../include/pystrcmp.h | 23 + .../include/pystrhex.h | 19 + .../include/pystrtod.h | 45 + .../include/pythonrun.h | 181 + .../include/pythread.h | 155 + .../python_build_dependency/include/pytime.h | 246 + .../include/rangeobject.h | 27 + .../include/setobject.h | 108 + .../include/sliceobject.h | 63 + .../include/structmember.h | 74 + .../include/structseq.h | 49 + .../include/symtable.h | 118 + .../include/sysmodule.h | 48 + .../python_build_dependency/include/token.h | 92 + .../include/traceback.h | 119 + .../include/tupleobject.h | 73 + .../include/typeslots.h | 85 + .../python_build_dependency/include/ucnhash.h | 36 + .../include/unicodeobject.h | 2334 ++ .../include/warnings.h | 67 + .../include/weakrefobject.h | 86 + .../python_build_dependency/libs/python3.lib | Bin 0 -> 170564 bytes .../python_build_dependency/libs/python37.lib | Bin 0 -> 342642 bytes .../python_runtime_dependency/LICENSE.txt | 254 + .../python_runtime_dependency/get-pip.py | 32207 ++++++++++++++++ .../libcrypto-1_1.dll | Bin 0 -> 3399200 bytes .../python_runtime_dependency/libssl-1_1.dll | Bin 0 -> 689184 bytes .../python_runtime_dependency/python.exe | Bin 0 -> 100368 bytes .../python_runtime_dependency/python3.dll | Bin 0 -> 58896 bytes .../python_runtime_dependency/python37._pth | 5 + .../python_runtime_dependency/python37.dll | Bin 0 -> 3750416 bytes .../python_runtime_dependency/python37.zip | Bin 0 -> 2397995 bytes .../python_runtime_dependency/pythonw.exe | Bin 0 -> 98832 bytes .../python_runtime_dependency/sqlite3.dll | Bin 0 -> 1268752 bytes .../vcruntime140.dll | Bin 0 -> 87864 bytes 126 files changed, 50394 insertions(+) create mode 100644 Resources/python_build_dependency/include/Python-ast.h create mode 100644 Resources/python_build_dependency/include/Python.h create mode 100644 Resources/python_build_dependency/include/abstract.h create mode 100644 Resources/python_build_dependency/include/accu.h create mode 100644 Resources/python_build_dependency/include/asdl.h create mode 100644 Resources/python_build_dependency/include/ast.h create mode 100644 Resources/python_build_dependency/include/bitset.h create mode 100644 Resources/python_build_dependency/include/bltinmodule.h create mode 100644 Resources/python_build_dependency/include/boolobject.h create mode 100644 Resources/python_build_dependency/include/bytearrayobject.h create mode 100644 Resources/python_build_dependency/include/bytes_methods.h create mode 100644 Resources/python_build_dependency/include/bytesobject.h create mode 100644 Resources/python_build_dependency/include/cellobject.h create mode 100644 Resources/python_build_dependency/include/ceval.h create mode 100644 Resources/python_build_dependency/include/classobject.h create mode 100644 Resources/python_build_dependency/include/code.h create mode 100644 Resources/python_build_dependency/include/codecs.h create mode 100644 Resources/python_build_dependency/include/compile.h create mode 100644 Resources/python_build_dependency/include/complexobject.h create mode 100644 Resources/python_build_dependency/include/context.h create mode 100644 Resources/python_build_dependency/include/datetime.h create mode 100644 Resources/python_build_dependency/include/descrobject.h create mode 100644 Resources/python_build_dependency/include/dictobject.h create mode 100644 Resources/python_build_dependency/include/dtoa.h create mode 100644 Resources/python_build_dependency/include/dynamic_annotations.h create mode 100644 Resources/python_build_dependency/include/enumobject.h create mode 100644 Resources/python_build_dependency/include/errcode.h create mode 100644 Resources/python_build_dependency/include/eval.h create mode 100644 Resources/python_build_dependency/include/fileobject.h create mode 100644 Resources/python_build_dependency/include/fileutils.h create mode 100644 Resources/python_build_dependency/include/floatobject.h create mode 100644 Resources/python_build_dependency/include/frameobject.h create mode 100644 Resources/python_build_dependency/include/funcobject.h create mode 100644 Resources/python_build_dependency/include/genobject.h create mode 100644 Resources/python_build_dependency/include/graminit.h create mode 100644 Resources/python_build_dependency/include/grammar.h create mode 100644 Resources/python_build_dependency/include/import.h create mode 100644 Resources/python_build_dependency/include/internal/ceval.h create mode 100644 Resources/python_build_dependency/include/internal/condvar.h create mode 100644 Resources/python_build_dependency/include/internal/context.h create mode 100644 Resources/python_build_dependency/include/internal/gil.h create mode 100644 Resources/python_build_dependency/include/internal/hamt.h create mode 100644 Resources/python_build_dependency/include/internal/hash.h create mode 100644 Resources/python_build_dependency/include/internal/import.h create mode 100644 Resources/python_build_dependency/include/internal/mem.h create mode 100644 Resources/python_build_dependency/include/internal/pygetopt.h create mode 100644 Resources/python_build_dependency/include/internal/pystate.h create mode 100644 Resources/python_build_dependency/include/internal/warnings.h create mode 100644 Resources/python_build_dependency/include/intrcheck.h create mode 100644 Resources/python_build_dependency/include/iterobject.h create mode 100644 Resources/python_build_dependency/include/listobject.h create mode 100644 Resources/python_build_dependency/include/longintrepr.h create mode 100644 Resources/python_build_dependency/include/longobject.h create mode 100644 Resources/python_build_dependency/include/marshal.h create mode 100644 Resources/python_build_dependency/include/memoryobject.h create mode 100644 Resources/python_build_dependency/include/metagrammar.h create mode 100644 Resources/python_build_dependency/include/methodobject.h create mode 100644 Resources/python_build_dependency/include/modsupport.h create mode 100644 Resources/python_build_dependency/include/moduleobject.h create mode 100644 Resources/python_build_dependency/include/namespaceobject.h create mode 100644 Resources/python_build_dependency/include/node.h create mode 100644 Resources/python_build_dependency/include/object.h create mode 100644 Resources/python_build_dependency/include/objimpl.h create mode 100644 Resources/python_build_dependency/include/odictobject.h create mode 100644 Resources/python_build_dependency/include/opcode.h create mode 100644 Resources/python_build_dependency/include/osdefs.h create mode 100644 Resources/python_build_dependency/include/osmodule.h create mode 100644 Resources/python_build_dependency/include/parsetok.h create mode 100644 Resources/python_build_dependency/include/patchlevel.h create mode 100644 Resources/python_build_dependency/include/pgen.h create mode 100644 Resources/python_build_dependency/include/pgenheaders.h create mode 100644 Resources/python_build_dependency/include/py_curses.h create mode 100644 Resources/python_build_dependency/include/pyarena.h create mode 100644 Resources/python_build_dependency/include/pyatomic.h create mode 100644 Resources/python_build_dependency/include/pycapsule.h create mode 100644 Resources/python_build_dependency/include/pyconfig.h create mode 100644 Resources/python_build_dependency/include/pyctype.h create mode 100644 Resources/python_build_dependency/include/pydebug.h create mode 100644 Resources/python_build_dependency/include/pydtrace.d create mode 100644 Resources/python_build_dependency/include/pydtrace.h create mode 100644 Resources/python_build_dependency/include/pyerrors.h create mode 100644 Resources/python_build_dependency/include/pyexpat.h create mode 100644 Resources/python_build_dependency/include/pyfpe.h create mode 100644 Resources/python_build_dependency/include/pyhash.h create mode 100644 Resources/python_build_dependency/include/pylifecycle.h create mode 100644 Resources/python_build_dependency/include/pymacconfig.h create mode 100644 Resources/python_build_dependency/include/pymacro.h create mode 100644 Resources/python_build_dependency/include/pymath.h create mode 100644 Resources/python_build_dependency/include/pymem.h create mode 100644 Resources/python_build_dependency/include/pyport.h create mode 100644 Resources/python_build_dependency/include/pystate.h create mode 100644 Resources/python_build_dependency/include/pystrcmp.h create mode 100644 Resources/python_build_dependency/include/pystrhex.h create mode 100644 Resources/python_build_dependency/include/pystrtod.h create mode 100644 Resources/python_build_dependency/include/pythonrun.h create mode 100644 Resources/python_build_dependency/include/pythread.h create mode 100644 Resources/python_build_dependency/include/pytime.h create mode 100644 Resources/python_build_dependency/include/rangeobject.h create mode 100644 Resources/python_build_dependency/include/setobject.h create mode 100644 Resources/python_build_dependency/include/sliceobject.h create mode 100644 Resources/python_build_dependency/include/structmember.h create mode 100644 Resources/python_build_dependency/include/structseq.h create mode 100644 Resources/python_build_dependency/include/symtable.h create mode 100644 Resources/python_build_dependency/include/sysmodule.h create mode 100644 Resources/python_build_dependency/include/token.h create mode 100644 Resources/python_build_dependency/include/traceback.h create mode 100644 Resources/python_build_dependency/include/tupleobject.h create mode 100644 Resources/python_build_dependency/include/typeslots.h create mode 100644 Resources/python_build_dependency/include/ucnhash.h create mode 100644 Resources/python_build_dependency/include/unicodeobject.h create mode 100644 Resources/python_build_dependency/include/warnings.h create mode 100644 Resources/python_build_dependency/include/weakrefobject.h create mode 100644 Resources/python_build_dependency/libs/python3.lib create mode 100644 Resources/python_build_dependency/libs/python37.lib create mode 100644 Resources/python_runtime_dependency/LICENSE.txt create mode 100644 Resources/python_runtime_dependency/get-pip.py create mode 100644 Resources/python_runtime_dependency/libcrypto-1_1.dll create mode 100644 Resources/python_runtime_dependency/libssl-1_1.dll create mode 100644 Resources/python_runtime_dependency/python.exe create mode 100644 Resources/python_runtime_dependency/python3.dll create mode 100644 Resources/python_runtime_dependency/python37._pth create mode 100644 Resources/python_runtime_dependency/python37.dll create mode 100644 Resources/python_runtime_dependency/python37.zip create mode 100644 Resources/python_runtime_dependency/pythonw.exe create mode 100644 Resources/python_runtime_dependency/sqlite3.dll create mode 100644 Resources/python_runtime_dependency/vcruntime140.dll diff --git a/Resources/python_build_dependency/include/Python-ast.h b/Resources/python_build_dependency/include/Python-ast.h new file mode 100644 index 000000000..8e0f750a8 --- /dev/null +++ b/Resources/python_build_dependency/include/Python-ast.h @@ -0,0 +1,637 @@ +/* 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/Resources/python_build_dependency/include/Python.h b/Resources/python_build_dependency/include/Python.h new file mode 100644 index 000000000..54ea32148 --- /dev/null +++ b/Resources/python_build_dependency/include/Python.h @@ -0,0 +1,159 @@ +#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 + +#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 +#ifndef NULL +# error "Python.h requires that stdio.h define NULL." +#endif + +#include +#ifdef HAVE_ERRNO_H +#include +#endif +#include +#ifdef HAVE_UNISTD_H +#include +#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 +#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 +#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 + +#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/Resources/python_build_dependency/include/abstract.h b/Resources/python_build_dependency/include/abstract.h new file mode 100644 index 000000000..d8f648e26 --- /dev/null +++ b/Resources/python_build_dependency/include/abstract.h @@ -0,0 +1,1109 @@ +/* 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/Resources/python_build_dependency/include/accu.h b/Resources/python_build_dependency/include/accu.h new file mode 100644 index 000000000..3636ea6c9 --- /dev/null +++ b/Resources/python_build_dependency/include/accu.h @@ -0,0 +1,37 @@ +#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/Resources/python_build_dependency/include/asdl.h b/Resources/python_build_dependency/include/asdl.h new file mode 100644 index 000000000..35e9fa186 --- /dev/null +++ b/Resources/python_build_dependency/include/asdl.h @@ -0,0 +1,46 @@ +#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/Resources/python_build_dependency/include/ast.h b/Resources/python_build_dependency/include/ast.h new file mode 100644 index 000000000..5bc2b05b3 --- /dev/null +++ b/Resources/python_build_dependency/include/ast.h @@ -0,0 +1,29 @@ +#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/Resources/python_build_dependency/include/bitset.h b/Resources/python_build_dependency/include/bitset.h new file mode 100644 index 000000000..b22fa7781 --- /dev/null +++ b/Resources/python_build_dependency/include/bitset.h @@ -0,0 +1,32 @@ + +#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/Resources/python_build_dependency/include/bltinmodule.h b/Resources/python_build_dependency/include/bltinmodule.h new file mode 100644 index 000000000..868c9e644 --- /dev/null +++ b/Resources/python_build_dependency/include/bltinmodule.h @@ -0,0 +1,14 @@ +#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/Resources/python_build_dependency/include/boolobject.h b/Resources/python_build_dependency/include/boolobject.h new file mode 100644 index 000000000..7cc2f1fe2 --- /dev/null +++ b/Resources/python_build_dependency/include/boolobject.h @@ -0,0 +1,34 @@ +/* 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/Resources/python_build_dependency/include/bytearrayobject.h b/Resources/python_build_dependency/include/bytearrayobject.h new file mode 100644 index 000000000..a757b8805 --- /dev/null +++ b/Resources/python_build_dependency/include/bytearrayobject.h @@ -0,0 +1,62 @@ +/* ByteArray object interface */ + +#ifndef Py_BYTEARRAYOBJECT_H +#define Py_BYTEARRAYOBJECT_H +#ifdef __cplusplus +extern "C" { +#endif + +#include + +/* 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/Resources/python_build_dependency/include/bytes_methods.h b/Resources/python_build_dependency/include/bytes_methods.h new file mode 100644 index 000000000..8434a50a4 --- /dev/null +++ b/Resources/python_build_dependency/include/bytes_methods.h @@ -0,0 +1,69 @@ +#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/Resources/python_build_dependency/include/bytesobject.h b/Resources/python_build_dependency/include/bytesobject.h new file mode 100644 index 000000000..3fde4a221 --- /dev/null +++ b/Resources/python_build_dependency/include/bytesobject.h @@ -0,0 +1,224 @@ + +/* Bytes (String) object interface */ + +#ifndef Py_BYTESOBJECT_H +#define Py_BYTESOBJECT_H +#ifdef __cplusplus +extern "C" { +#endif + +#include + +/* +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/Resources/python_build_dependency/include/cellobject.h b/Resources/python_build_dependency/include/cellobject.h new file mode 100644 index 000000000..2f9b5b75d --- /dev/null +++ b/Resources/python_build_dependency/include/cellobject.h @@ -0,0 +1,29 @@ +/* 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/Resources/python_build_dependency/include/ceval.h b/Resources/python_build_dependency/include/ceval.h new file mode 100644 index 000000000..11283c0a5 --- /dev/null +++ b/Resources/python_build_dependency/include/ceval.h @@ -0,0 +1,239 @@ +#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/Resources/python_build_dependency/include/classobject.h b/Resources/python_build_dependency/include/classobject.h new file mode 100644 index 000000000..209f0f4a2 --- /dev/null +++ b/Resources/python_build_dependency/include/classobject.h @@ -0,0 +1,58 @@ +/* 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/Resources/python_build_dependency/include/code.h b/Resources/python_build_dependency/include/code.h new file mode 100644 index 000000000..2e661e8b3 --- /dev/null +++ b/Resources/python_build_dependency/include/code.h @@ -0,0 +1,157 @@ +/* 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/Resources/python_build_dependency/include/codecs.h b/Resources/python_build_dependency/include/codecs.h new file mode 100644 index 000000000..3ad0f2b5a --- /dev/null +++ b/Resources/python_build_dependency/include/codecs.h @@ -0,0 +1,240 @@ +#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/Resources/python_build_dependency/include/compile.h b/Resources/python_build_dependency/include/compile.h new file mode 100644 index 000000000..edb961f4d --- /dev/null +++ b/Resources/python_build_dependency/include/compile.h @@ -0,0 +1,93 @@ +#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/Resources/python_build_dependency/include/complexobject.h b/Resources/python_build_dependency/include/complexobject.h new file mode 100644 index 000000000..cb8c52c58 --- /dev/null +++ b/Resources/python_build_dependency/include/complexobject.h @@ -0,0 +1,69 @@ +/* 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/Resources/python_build_dependency/include/context.h b/Resources/python_build_dependency/include/context.h new file mode 100644 index 000000000..958128524 --- /dev/null +++ b/Resources/python_build_dependency/include/context.h @@ -0,0 +1,84 @@ +#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/Resources/python_build_dependency/include/datetime.h b/Resources/python_build_dependency/include/datetime.h new file mode 100644 index 000000000..059d5ecf7 --- /dev/null +++ b/Resources/python_build_dependency/include/datetime.h @@ -0,0 +1,273 @@ +/* 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/Resources/python_build_dependency/include/descrobject.h b/Resources/python_build_dependency/include/descrobject.h new file mode 100644 index 000000000..73bbb3fe5 --- /dev/null +++ b/Resources/python_build_dependency/include/descrobject.h @@ -0,0 +1,110 @@ +/* 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/Resources/python_build_dependency/include/dictobject.h b/Resources/python_build_dependency/include/dictobject.h new file mode 100644 index 000000000..28930f436 --- /dev/null +++ b/Resources/python_build_dependency/include/dictobject.h @@ -0,0 +1,179 @@ +#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/Resources/python_build_dependency/include/dtoa.h b/Resources/python_build_dependency/include/dtoa.h new file mode 100644 index 000000000..9bfb6251d --- /dev/null +++ b/Resources/python_build_dependency/include/dtoa.h @@ -0,0 +1,19 @@ +#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/Resources/python_build_dependency/include/dynamic_annotations.h b/Resources/python_build_dependency/include/dynamic_annotations.h new file mode 100644 index 000000000..0bd1a833c --- /dev/null +++ b/Resources/python_build_dependency/include/dynamic_annotations.h @@ -0,0 +1,499 @@ +/* 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 + 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/Resources/python_build_dependency/include/enumobject.h b/Resources/python_build_dependency/include/enumobject.h new file mode 100644 index 000000000..c14dbfc8c --- /dev/null +++ b/Resources/python_build_dependency/include/enumobject.h @@ -0,0 +1,17 @@ +#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/Resources/python_build_dependency/include/errcode.h b/Resources/python_build_dependency/include/errcode.h new file mode 100644 index 000000000..b37cd261d --- /dev/null +++ b/Resources/python_build_dependency/include/errcode.h @@ -0,0 +1,38 @@ +#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/Resources/python_build_dependency/include/eval.h b/Resources/python_build_dependency/include/eval.h new file mode 100644 index 000000000..2c1c2d054 --- /dev/null +++ b/Resources/python_build_dependency/include/eval.h @@ -0,0 +1,37 @@ + +/* 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/Resources/python_build_dependency/include/fileobject.h b/Resources/python_build_dependency/include/fileobject.h new file mode 100644 index 000000000..89e8dd6a2 --- /dev/null +++ b/Resources/python_build_dependency/include/fileobject.h @@ -0,0 +1,55 @@ +/* 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/Resources/python_build_dependency/include/fileutils.h b/Resources/python_build_dependency/include/fileutils.h new file mode 100644 index 000000000..419d49ab7 --- /dev/null +++ b/Resources/python_build_dependency/include/fileutils.h @@ -0,0 +1,201 @@ +#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/Resources/python_build_dependency/include/floatobject.h b/Resources/python_build_dependency/include/floatobject.h new file mode 100644 index 000000000..f1044d64c --- /dev/null +++ b/Resources/python_build_dependency/include/floatobject.h @@ -0,0 +1,130 @@ + +/* 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/Resources/python_build_dependency/include/frameobject.h b/Resources/python_build_dependency/include/frameobject.h new file mode 100644 index 000000000..a95baf886 --- /dev/null +++ b/Resources/python_build_dependency/include/frameobject.h @@ -0,0 +1,93 @@ + +/* 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/Resources/python_build_dependency/include/funcobject.h b/Resources/python_build_dependency/include/funcobject.h new file mode 100644 index 000000000..86674ac90 --- /dev/null +++ b/Resources/python_build_dependency/include/funcobject.h @@ -0,0 +1,103 @@ + +/* 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/Resources/python_build_dependency/include/genobject.h b/Resources/python_build_dependency/include/genobject.h new file mode 100644 index 000000000..16b983339 --- /dev/null +++ b/Resources/python_build_dependency/include/genobject.h @@ -0,0 +1,105 @@ + +/* 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/Resources/python_build_dependency/include/graminit.h b/Resources/python_build_dependency/include/graminit.h new file mode 100644 index 000000000..bdfe821ad --- /dev/null +++ b/Resources/python_build_dependency/include/graminit.h @@ -0,0 +1,89 @@ +/* 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/Resources/python_build_dependency/include/grammar.h b/Resources/python_build_dependency/include/grammar.h new file mode 100644 index 000000000..e1703f4b3 --- /dev/null +++ b/Resources/python_build_dependency/include/grammar.h @@ -0,0 +1,94 @@ + +/* 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/Resources/python_build_dependency/include/import.h b/Resources/python_build_dependency/include/import.h new file mode 100644 index 000000000..c66480347 --- /dev/null +++ b/Resources/python_build_dependency/include/import.h @@ -0,0 +1,151 @@ + +/* 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/Resources/python_build_dependency/include/internal/ceval.h b/Resources/python_build_dependency/include/internal/ceval.h new file mode 100644 index 000000000..cdabb9521 --- /dev/null +++ b/Resources/python_build_dependency/include/internal/ceval.h @@ -0,0 +1,52 @@ +#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/Resources/python_build_dependency/include/internal/condvar.h b/Resources/python_build_dependency/include/internal/condvar.h new file mode 100644 index 000000000..f9330890d --- /dev/null +++ b/Resources/python_build_dependency/include/internal/condvar.h @@ -0,0 +1,91 @@ +#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 /* _POSIX_THREADS */ +# endif +#endif + +#ifdef _POSIX_THREADS +/* + * POSIX support + */ +#define Py_HAVE_CONDVAR + +#include + +#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 + +/* 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/Resources/python_build_dependency/include/internal/context.h b/Resources/python_build_dependency/include/internal/context.h new file mode 100644 index 000000000..59f88f261 --- /dev/null +++ b/Resources/python_build_dependency/include/internal/context.h @@ -0,0 +1,41 @@ +#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/Resources/python_build_dependency/include/internal/gil.h b/Resources/python_build_dependency/include/internal/gil.h new file mode 100644 index 000000000..6139bd215 --- /dev/null +++ b/Resources/python_build_dependency/include/internal/gil.h @@ -0,0 +1,46 @@ +#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/Resources/python_build_dependency/include/internal/hamt.h b/Resources/python_build_dependency/include/internal/hamt.h new file mode 100644 index 000000000..29ad28b1d --- /dev/null +++ b/Resources/python_build_dependency/include/internal/hamt.h @@ -0,0 +1,113 @@ +#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/Resources/python_build_dependency/include/internal/hash.h b/Resources/python_build_dependency/include/internal/hash.h new file mode 100644 index 000000000..e14b80a7f --- /dev/null +++ b/Resources/python_build_dependency/include/internal/hash.h @@ -0,0 +1,6 @@ +#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/Resources/python_build_dependency/include/internal/import.h b/Resources/python_build_dependency/include/internal/import.h new file mode 100644 index 000000000..4746e7557 --- /dev/null +++ b/Resources/python_build_dependency/include/internal/import.h @@ -0,0 +1,6 @@ +#ifndef Py_INTERNAL_IMPORT_H +#define Py_INTERNAL_IMPORT_H + +extern const char *_Py_CheckHashBasedPycsMode; + +#endif diff --git a/Resources/python_build_dependency/include/internal/mem.h b/Resources/python_build_dependency/include/internal/mem.h new file mode 100644 index 000000000..5896e4a05 --- /dev/null +++ b/Resources/python_build_dependency/include/internal/mem.h @@ -0,0 +1,175 @@ +#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 + 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/Resources/python_build_dependency/include/internal/pygetopt.h b/Resources/python_build_dependency/include/internal/pygetopt.h new file mode 100644 index 000000000..8ef2ada72 --- /dev/null +++ b/Resources/python_build_dependency/include/internal/pygetopt.h @@ -0,0 +1,19 @@ +#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/Resources/python_build_dependency/include/internal/pystate.h b/Resources/python_build_dependency/include/internal/pystate.h new file mode 100644 index 000000000..5891339b5 --- /dev/null +++ b/Resources/python_build_dependency/include/internal/pystate.h @@ -0,0 +1,135 @@ +#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/Resources/python_build_dependency/include/internal/warnings.h b/Resources/python_build_dependency/include/internal/warnings.h new file mode 100644 index 000000000..2878a28a2 --- /dev/null +++ b/Resources/python_build_dependency/include/internal/warnings.h @@ -0,0 +1,21 @@ +#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/Resources/python_build_dependency/include/intrcheck.h b/Resources/python_build_dependency/include/intrcheck.h new file mode 100644 index 000000000..2e17336ca --- /dev/null +++ b/Resources/python_build_dependency/include/intrcheck.h @@ -0,0 +1,33 @@ + +#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/Resources/python_build_dependency/include/iterobject.h b/Resources/python_build_dependency/include/iterobject.h new file mode 100644 index 000000000..f61726f1f --- /dev/null +++ b/Resources/python_build_dependency/include/iterobject.h @@ -0,0 +1,25 @@ +#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/Resources/python_build_dependency/include/listobject.h b/Resources/python_build_dependency/include/listobject.h new file mode 100644 index 000000000..6057279d5 --- /dev/null +++ b/Resources/python_build_dependency/include/listobject.h @@ -0,0 +1,81 @@ + +/* 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/Resources/python_build_dependency/include/longintrepr.h b/Resources/python_build_dependency/include/longintrepr.h new file mode 100644 index 000000000..ff4155f96 --- /dev/null +++ b/Resources/python_build_dependency/include/longintrepr.h @@ -0,0 +1,99 @@ +#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/Resources/python_build_dependency/include/longobject.h b/Resources/python_build_dependency/include/longobject.h new file mode 100644 index 000000000..7bdd0472b --- /dev/null +++ b/Resources/python_build_dependency/include/longobject.h @@ -0,0 +1,220 @@ +#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/Resources/python_build_dependency/include/marshal.h b/Resources/python_build_dependency/include/marshal.h new file mode 100644 index 000000000..09d9337e5 --- /dev/null +++ b/Resources/python_build_dependency/include/marshal.h @@ -0,0 +1,28 @@ + +/* 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/Resources/python_build_dependency/include/memoryobject.h b/Resources/python_build_dependency/include/memoryobject.h new file mode 100644 index 000000000..990a716f2 --- /dev/null +++ b/Resources/python_build_dependency/include/memoryobject.h @@ -0,0 +1,72 @@ +/* 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/Resources/python_build_dependency/include/metagrammar.h b/Resources/python_build_dependency/include/metagrammar.h new file mode 100644 index 000000000..15c8ef8f3 --- /dev/null +++ b/Resources/python_build_dependency/include/metagrammar.h @@ -0,0 +1,18 @@ +#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/Resources/python_build_dependency/include/methodobject.h b/Resources/python_build_dependency/include/methodobject.h new file mode 100644 index 000000000..ea35d86bc --- /dev/null +++ b/Resources/python_build_dependency/include/methodobject.h @@ -0,0 +1,135 @@ + +/* 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/Resources/python_build_dependency/include/modsupport.h b/Resources/python_build_dependency/include/modsupport.h new file mode 100644 index 000000000..a238bef03 --- /dev/null +++ b/Resources/python_build_dependency/include/modsupport.h @@ -0,0 +1,229 @@ + +#ifndef Py_MODSUPPORT_H +#define Py_MODSUPPORT_H +#ifdef __cplusplus +extern "C" { +#endif + +/* Module support interface */ + +#include + +/* 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/Resources/python_build_dependency/include/moduleobject.h b/Resources/python_build_dependency/include/moduleobject.h new file mode 100644 index 000000000..1d8fe46de --- /dev/null +++ b/Resources/python_build_dependency/include/moduleobject.h @@ -0,0 +1,89 @@ + +/* 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/Resources/python_build_dependency/include/namespaceobject.h b/Resources/python_build_dependency/include/namespaceobject.h new file mode 100644 index 000000000..0c8d95c0f --- /dev/null +++ b/Resources/python_build_dependency/include/namespaceobject.h @@ -0,0 +1,19 @@ + +/* 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/Resources/python_build_dependency/include/node.h b/Resources/python_build_dependency/include/node.h new file mode 100644 index 000000000..40596dfec --- /dev/null +++ b/Resources/python_build_dependency/include/node.h @@ -0,0 +1,44 @@ + +/* 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/Resources/python_build_dependency/include/object.h b/Resources/python_build_dependency/include/object.h new file mode 100644 index 000000000..e212fca12 --- /dev/null +++ b/Resources/python_build_dependency/include/object.h @@ -0,0 +1,1105 @@ +#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 "." */ + 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 : 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/Resources/python_build_dependency/include/objimpl.h b/Resources/python_build_dependency/include/objimpl.h new file mode 100644 index 000000000..0436ba789 --- /dev/null +++ b/Resources/python_build_dependency/include/objimpl.h @@ -0,0 +1,374 @@ +/* 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/Resources/python_build_dependency/include/odictobject.h b/Resources/python_build_dependency/include/odictobject.h new file mode 100644 index 000000000..8378dc4bf --- /dev/null +++ b/Resources/python_build_dependency/include/odictobject.h @@ -0,0 +1,43 @@ +#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/Resources/python_build_dependency/include/opcode.h b/Resources/python_build_dependency/include/opcode.h new file mode 100644 index 000000000..fc6cbf3a7 --- /dev/null +++ b/Resources/python_build_dependency/include/opcode.h @@ -0,0 +1,147 @@ +/* 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/Resources/python_build_dependency/include/osdefs.h b/Resources/python_build_dependency/include/osdefs.h new file mode 100644 index 000000000..bd84c1c12 --- /dev/null +++ b/Resources/python_build_dependency/include/osdefs.h @@ -0,0 +1,47 @@ +#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 +#include +#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/Resources/python_build_dependency/include/osmodule.h b/Resources/python_build_dependency/include/osmodule.h new file mode 100644 index 000000000..9095c2fdd --- /dev/null +++ b/Resources/python_build_dependency/include/osmodule.h @@ -0,0 +1,17 @@ + +/* 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/Resources/python_build_dependency/include/parsetok.h b/Resources/python_build_dependency/include/parsetok.h new file mode 100644 index 000000000..c9407a3f7 --- /dev/null +++ b/Resources/python_build_dependency/include/parsetok.h @@ -0,0 +1,108 @@ + +/* 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/Resources/python_build_dependency/include/patchlevel.h b/Resources/python_build_dependency/include/patchlevel.h new file mode 100644 index 000000000..d823319e6 --- /dev/null +++ b/Resources/python_build_dependency/include/patchlevel.h @@ -0,0 +1,35 @@ + +/* 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/Resources/python_build_dependency/include/pgen.h b/Resources/python_build_dependency/include/pgen.h new file mode 100644 index 000000000..8a325ed07 --- /dev/null +++ b/Resources/python_build_dependency/include/pgen.h @@ -0,0 +1,18 @@ +#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/Resources/python_build_dependency/include/pgenheaders.h b/Resources/python_build_dependency/include/pgenheaders.h new file mode 100644 index 000000000..dbc5e0a5f --- /dev/null +++ b/Resources/python_build_dependency/include/pgenheaders.h @@ -0,0 +1,43 @@ +#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/Resources/python_build_dependency/include/py_curses.h b/Resources/python_build_dependency/include/py_curses.h new file mode 100644 index 000000000..0eebc362a --- /dev/null +++ b/Resources/python_build_dependency/include/py_curses.h @@ -0,0 +1,159 @@ + +#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 +#else +#include +#endif + +#ifdef HAVE_NCURSES_H +/* configure was checking , but we will + use , 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/Resources/python_build_dependency/include/pyarena.h b/Resources/python_build_dependency/include/pyarena.h new file mode 100644 index 000000000..db3ad0188 --- /dev/null +++ b/Resources/python_build_dependency/include/pyarena.h @@ -0,0 +1,64 @@ +/* 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/Resources/python_build_dependency/include/pyatomic.h b/Resources/python_build_dependency/include/pyatomic.h new file mode 100644 index 000000000..9a497a683 --- /dev/null +++ b/Resources/python_build_dependency/include/pyatomic.h @@ -0,0 +1,535 @@ +#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 +#endif + + +#if defined(_MSC_VER) +#include +#include +#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/Resources/python_build_dependency/include/pycapsule.h b/Resources/python_build_dependency/include/pycapsule.h new file mode 100644 index 000000000..d9ecda7a4 --- /dev/null +++ b/Resources/python_build_dependency/include/pycapsule.h @@ -0,0 +1,59 @@ + +/* 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/Resources/python_build_dependency/include/pyconfig.h b/Resources/python_build_dependency/include/pyconfig.h new file mode 100644 index 000000000..81e76562d --- /dev/null +++ b/Resources/python_build_dependency/include/pyconfig.h @@ -0,0 +1,684 @@ +#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 + +#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 +#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 +#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 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 +#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 header file. */ +#define HAVE_CONIO_H 1 + +/* Define to 1 if you have the 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 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 doesn't define. */ +/* #undef mode_t */ + +/* Define if you don't have dirent.h, but have ndir.h. */ +/* #undef NDIR */ + +/* Define to `long' if doesn't define. */ +/* #undef off_t */ + +/* Define to `int' if 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 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 and . */ +/* #undef TIME_WITH_SYS_TIME */ + +/* Define if your declares struct tm. */ +/* #define TM_IN_SYS_TIME 1 */ + +/* Define to `int' if 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 and + (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 header file. */ +/* #undef HAVE_DLFCN_H */ + +/* Define to 1 if you have the header file. */ +#define HAVE_ERRNO_H 1 + +/* Define if you have the header file. */ +#define HAVE_FCNTL_H 1 + +/* Define to 1 if you have the header file. */ +#define HAVE_PROCESS_H 1 + +/* Define to 1 if you have the header file. */ +#define HAVE_SIGNAL_H 1 + +/* Define if you have the prototypes. */ +#define HAVE_STDARG_PROTOTYPES + +/* Define if you have the header file. */ +#define HAVE_STDDEF_H 1 + +/* Define if you have the header file. */ +/* #undef HAVE_SYS_AUDIOIO_H */ + +/* Define if you have the header file. */ +/* #define HAVE_SYS_PARAM_H 1 */ + +/* Define if you have the header file. */ +/* #define HAVE_SYS_SELECT_H 1 */ + +/* Define to 1 if you have the header file. */ +#define HAVE_SYS_STAT_H 1 + +/* Define if you have the header file. */ +/* #define HAVE_SYS_TIME_H 1 */ + +/* Define if you have the header file. */ +/* #define HAVE_SYS_TIMES_H 1 */ + +/* Define to 1 if you have the header file. */ +#define HAVE_SYS_TYPES_H 1 + +/* Define if you have the header file. */ +/* #define HAVE_SYS_UN_H 1 */ + +/* Define if you have the header file. */ +/* #define HAVE_SYS_UTIME_H 1 */ + +/* Define if you have the header file. */ +/* #define HAVE_SYS_UTSNAME_H 1 */ + +/* Define if you have the header file. */ +/* #define HAVE_UNISTD_H 1 */ + +/* Define if you have the 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/Resources/python_build_dependency/include/pyctype.h b/Resources/python_build_dependency/include/pyctype.h new file mode 100644 index 000000000..6bce63eeb --- /dev/null +++ b/Resources/python_build_dependency/include/pyctype.h @@ -0,0 +1,33 @@ +#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/Resources/python_build_dependency/include/pydebug.h b/Resources/python_build_dependency/include/pydebug.h new file mode 100644 index 000000000..bd4aafe3b --- /dev/null +++ b/Resources/python_build_dependency/include/pydebug.h @@ -0,0 +1,40 @@ +#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/Resources/python_build_dependency/include/pydtrace.d b/Resources/python_build_dependency/include/pydtrace.d new file mode 100644 index 000000000..a6a5e7ec2 --- /dev/null +++ b/Resources/python_build_dependency/include/pydtrace.d @@ -0,0 +1,21 @@ +/* Python DTrace provider */ + +provider python { + probe function__entry(const char *, const char *, int); + probe function__return(const char *, const char *, int); + probe instance__new__start(const char *, const char *); + probe instance__new__done(const char *, const char *); + probe instance__delete__start(const char *, const char *); + probe instance__delete__done(const char *, const char *); + probe line(const char *, const char *, int); + probe gc__start(int); + probe gc__done(long); + probe import__find__load__start(const char *); + probe import__find__load__done(const char *, int); +}; + +#pragma D attributes Evolving/Evolving/Common provider python provider +#pragma D attributes Evolving/Evolving/Common provider python module +#pragma D attributes Evolving/Evolving/Common provider python function +#pragma D attributes Evolving/Evolving/Common provider python name +#pragma D attributes Evolving/Evolving/Common provider python args diff --git a/Resources/python_build_dependency/include/pydtrace.h b/Resources/python_build_dependency/include/pydtrace.h new file mode 100644 index 000000000..7a0427816 --- /dev/null +++ b/Resources/python_build_dependency/include/pydtrace.h @@ -0,0 +1,57 @@ +/* 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/Resources/python_build_dependency/include/pyerrors.h b/Resources/python_build_dependency/include/pyerrors.h new file mode 100644 index 000000000..f49d4e8bd --- /dev/null +++ b/Resources/python_build_dependency/include/pyerrors.h @@ -0,0 +1,504 @@ +#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 +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/Resources/python_build_dependency/include/pyexpat.h b/Resources/python_build_dependency/include/pyexpat.h new file mode 100644 index 000000000..07020b5dc --- /dev/null +++ b/Resources/python_build_dependency/include/pyexpat.h @@ -0,0 +1,55 @@ +/* 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/Resources/python_build_dependency/include/pyfpe.h b/Resources/python_build_dependency/include/pyfpe.h new file mode 100644 index 000000000..5a99e3979 --- /dev/null +++ b/Resources/python_build_dependency/include/pyfpe.h @@ -0,0 +1,12 @@ +#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/Resources/python_build_dependency/include/pyhash.h b/Resources/python_build_dependency/include/pyhash.h new file mode 100644 index 000000000..9cfd071ea --- /dev/null +++ b/Resources/python_build_dependency/include/pyhash.h @@ -0,0 +1,145 @@ +#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/Resources/python_build_dependency/include/pylifecycle.h b/Resources/python_build_dependency/include/pylifecycle.h new file mode 100644 index 000000000..79cfd6a0a --- /dev/null +++ b/Resources/python_build_dependency/include/pylifecycle.h @@ -0,0 +1,239 @@ + +/* 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 *) Anaconda_GetVersion(void); +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/Resources/python_build_dependency/include/pymacconfig.h b/Resources/python_build_dependency/include/pymacconfig.h new file mode 100644 index 000000000..9dde11bd5 --- /dev/null +++ b/Resources/python_build_dependency/include/pymacconfig.h @@ -0,0 +1,102 @@ +#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/Resources/python_build_dependency/include/pymacro.h b/Resources/python_build_dependency/include/pymacro.h new file mode 100644 index 000000000..3f6ddbe99 --- /dev/null +++ b/Resources/python_build_dependency/include/pymacro.h @@ -0,0 +1,100 @@ +#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/Resources/python_build_dependency/include/pymath.h b/Resources/python_build_dependency/include/pymath.h new file mode 100644 index 000000000..6cf69f98a --- /dev/null +++ b/Resources/python_build_dependency/include/pymath.h @@ -0,0 +1,230 @@ +#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/Resources/python_build_dependency/include/pymem.h b/Resources/python_build_dependency/include/pymem.h new file mode 100644 index 000000000..458a6489c --- /dev/null +++ b/Resources/python_build_dependency/include/pymem.h @@ -0,0 +1,244 @@ +/* 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/Resources/python_build_dependency/include/pyport.h b/Resources/python_build_dependency/include/pyport.h new file mode 100644 index 000000000..27e51b42c --- /dev/null +++ b/Resources/python_build_dependency/include/pyport.h @@ -0,0 +1,793 @@ +#ifndef Py_PYPORT_H +#define Py_PYPORT_H + +#include "pyconfig.h" /* include for defines */ + +#include + +/************************************************************************** +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 + +#ifdef HAVE_IEEEFP_H +#include /* needed for 'finite' declaration on some platforms */ +#endif + +#include /* Moved here from the math section, before extern "C" */ + +/******************************************** + * WRAPPER FOR and/or * + ********************************************/ + +#ifdef TIME_WITH_SYS_TIME +#include +#include +#else /* !TIME_WITH_SYS_TIME */ +#ifdef HAVE_SYS_TIME_H +#include +#else /* !HAVE_SYS_TIME_H */ +#include +#endif /* !HAVE_SYS_TIME_H */ +#endif /* !TIME_WITH_SYS_TIME */ + + +/****************************** + * WRAPPER FOR * + ******************************/ + +/* NB caller must include */ + +#ifdef HAVE_SYS_SELECT_H +#include +#endif /* !HAVE_SYS_SELECT_H */ + +/******************************* + * stat() and fstat() fiddling * + *******************************/ + +#ifdef HAVE_SYS_STAT_H +#include +#elif defined(HAVE_STAT_H) +#include +#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 /* 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 +#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 defines these symbols as real functions, + * with a slightly different signature. + * See issue #10910 + */ +#include +#include +#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/Resources/python_build_dependency/include/pystate.h b/Resources/python_build_dependency/include/pystate.h new file mode 100644 index 000000000..819c1427a --- /dev/null +++ b/Resources/python_build_dependency/include/pystate.h @@ -0,0 +1,456 @@ + +/* 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/Resources/python_build_dependency/include/pystrcmp.h b/Resources/python_build_dependency/include/pystrcmp.h new file mode 100644 index 000000000..edb12397e --- /dev/null +++ b/Resources/python_build_dependency/include/pystrcmp.h @@ -0,0 +1,23 @@ +#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/Resources/python_build_dependency/include/pystrhex.h b/Resources/python_build_dependency/include/pystrhex.h new file mode 100644 index 000000000..66a30e223 --- /dev/null +++ b/Resources/python_build_dependency/include/pystrhex.h @@ -0,0 +1,19 @@ +#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/Resources/python_build_dependency/include/pystrtod.h b/Resources/python_build_dependency/include/pystrtod.h new file mode 100644 index 000000000..c1e84de6f --- /dev/null +++ b/Resources/python_build_dependency/include/pystrtod.h @@ -0,0 +1,45 @@ +#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/Resources/python_build_dependency/include/pythonrun.h b/Resources/python_build_dependency/include/pythonrun.h new file mode 100644 index 000000000..6f0c6fc65 --- /dev/null +++ b/Resources/python_build_dependency/include/pythonrun.h @@ -0,0 +1,181 @@ + +/* 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/Resources/python_build_dependency/include/pythread.h b/Resources/python_build_dependency/include/pythread.h new file mode 100644 index 000000000..eb61033b2 --- /dev/null +++ b/Resources/python_build_dependency/include/pythread.h @@ -0,0 +1,155 @@ + +#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 +# 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/Resources/python_build_dependency/include/pytime.h b/Resources/python_build_dependency/include/pytime.h new file mode 100644 index 000000000..bdda1da2e --- /dev/null +++ b/Resources/python_build_dependency/include/pytime.h @@ -0,0 +1,246 @@ +#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/Resources/python_build_dependency/include/rangeobject.h b/Resources/python_build_dependency/include/rangeobject.h new file mode 100644 index 000000000..7e4dc2889 --- /dev/null +++ b/Resources/python_build_dependency/include/rangeobject.h @@ -0,0 +1,27 @@ + +/* 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/Resources/python_build_dependency/include/setobject.h b/Resources/python_build_dependency/include/setobject.h new file mode 100644 index 000000000..fc0ea8392 --- /dev/null +++ b/Resources/python_build_dependency/include/setobject.h @@ -0,0 +1,108 @@ +/* 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/Resources/python_build_dependency/include/sliceobject.h b/Resources/python_build_dependency/include/sliceobject.h new file mode 100644 index 000000000..c238b099e --- /dev/null +++ b/Resources/python_build_dependency/include/sliceobject.h @@ -0,0 +1,63 @@ +#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/Resources/python_build_dependency/include/structmember.h b/Resources/python_build_dependency/include/structmember.h new file mode 100644 index 000000000..b54f7081f --- /dev/null +++ b/Resources/python_build_dependency/include/structmember.h @@ -0,0 +1,74 @@ +#ifndef Py_STRUCTMEMBER_H +#define Py_STRUCTMEMBER_H +#ifdef __cplusplus +extern "C" { +#endif + + +/* Interface to map C struct members to Python object attributes */ + +#include /* 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/Resources/python_build_dependency/include/structseq.h b/Resources/python_build_dependency/include/structseq.h new file mode 100644 index 000000000..e5e5d5c57 --- /dev/null +++ b/Resources/python_build_dependency/include/structseq.h @@ -0,0 +1,49 @@ + +/* 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/Resources/python_build_dependency/include/symtable.h b/Resources/python_build_dependency/include/symtable.h new file mode 100644 index 000000000..007f88db4 --- /dev/null +++ b/Resources/python_build_dependency/include/symtable.h @@ -0,0 +1,118 @@ +#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/Resources/python_build_dependency/include/sysmodule.h b/Resources/python_build_dependency/include/sysmodule.h new file mode 100644 index 000000000..719ecfcf6 --- /dev/null +++ b/Resources/python_build_dependency/include/sysmodule.h @@ -0,0 +1,48 @@ + +/* 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/Resources/python_build_dependency/include/token.h b/Resources/python_build_dependency/include/token.h new file mode 100644 index 000000000..cd1cd00f0 --- /dev/null +++ b/Resources/python_build_dependency/include/token.h @@ -0,0 +1,92 @@ + +/* 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/Resources/python_build_dependency/include/traceback.h b/Resources/python_build_dependency/include/traceback.h new file mode 100644 index 000000000..b5874100f --- /dev/null +++ b/Resources/python_build_dependency/include/traceback.h @@ -0,0 +1,119 @@ + +#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 + File "xxx", line xxx in + ... + File "xxx", line xxx in + + 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/Resources/python_build_dependency/include/tupleobject.h b/Resources/python_build_dependency/include/tupleobject.h new file mode 100644 index 000000000..72a7d8d58 --- /dev/null +++ b/Resources/python_build_dependency/include/tupleobject.h @@ -0,0 +1,73 @@ + +/* 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/Resources/python_build_dependency/include/typeslots.h b/Resources/python_build_dependency/include/typeslots.h new file mode 100644 index 000000000..0ce6a377d --- /dev/null +++ b/Resources/python_build_dependency/include/typeslots.h @@ -0,0 +1,85 @@ +/* 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/Resources/python_build_dependency/include/ucnhash.h b/Resources/python_build_dependency/include/ucnhash.h new file mode 100644 index 000000000..45362e997 --- /dev/null +++ b/Resources/python_build_dependency/include/ucnhash.h @@ -0,0 +1,36 @@ +/* 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/Resources/python_build_dependency/include/unicodeobject.h b/Resources/python_build_dependency/include/unicodeobject.h new file mode 100644 index 000000000..45998a13a --- /dev/null +++ b/Resources/python_build_dependency/include/unicodeobject.h @@ -0,0 +1,2334 @@ +#ifndef Py_UNICODEOBJECT_H +#define Py_UNICODEOBJECT_H + +#include + +/* + +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 + +/* === 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 +#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/Resources/python_build_dependency/include/warnings.h b/Resources/python_build_dependency/include/warnings.h new file mode 100644 index 000000000..a675bb5df --- /dev/null +++ b/Resources/python_build_dependency/include/warnings.h @@ -0,0 +1,67 @@ +#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/Resources/python_build_dependency/include/weakrefobject.h b/Resources/python_build_dependency/include/weakrefobject.h new file mode 100644 index 000000000..17051568f --- /dev/null +++ b/Resources/python_build_dependency/include/weakrefobject.h @@ -0,0 +1,86 @@ +/* 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/Resources/python_build_dependency/libs/python3.lib b/Resources/python_build_dependency/libs/python3.lib new file mode 100644 index 0000000000000000000000000000000000000000..5d638a755daa52076201dbb9bedc4bd303cbcf93 GIT binary patch literal 170564 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 literal 0 HcmV?d00001 diff --git a/Resources/python_build_dependency/libs/python37.lib b/Resources/python_build_dependency/libs/python37.lib new file mode 100644 index 0000000000000000000000000000000000000000..f4e235191d8477bb73a882c35acda955721c6c46 GIT binary patch literal 342642 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 +ah=D<=O +VaA|NaUukZ1WpZv|Y%gPMX)j}KWN&bEX>V?GE^v9>J!^B@Mv~w4D`w%kBDqH*@%nPP;zg-b6s@gVCss +*HwzhOCE=UeZL?D0#K*?N}|NHf8ULYvTR9ts;uChb|Gd(liJ^h-VRun}?^(v|KToq-L7J03be6E&Nu_ +^1LqwAGcWtHZ$w9K?x=}N1#R!yPidXeVZ_9^n29;)f4QGd*f=8r1P>n6#YG-LOQDo#sn;pEMTGL)xrVGQ%&&y`(I4KJTenlEeS1+A4tB=%cA_9<nh1C +yyhXD!JP9(S2>P9q~+DCVw27DUUO6?HO`&^$LhL(NvRq1OzTGH4K&X(Z*uTuQDj;10J8=}%ypeE^Y|z +NEFQg3h%J7N>zWnoHGq)85N@T{#XVpe)>{{Az-$2%gUKO^)MC?YDjfru^|suOVMbLtYeqbFk{$m!$!d +Lcl&;I7f==`+OQ-RsNi*{_E0#+b+I%f)^QqDAn};eXj}}$2hN1FVQxsV(U=VpgtBl{mh=fe@^6Hn1i_ +5dCtI3P`H +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 +3}la4%nJZggdGZeeUMV{B2dXae9Y +?=zgZewZ5Fs$(Rwu=-&;?AL=GjAU6y|hGI@!T4Mj)^sPme!TBt44f`0YunO+`hgPomSk;EW28sPdkiz7TIQKLPp0&u%{K6{ZJE} +@C+Pc~O_L7*1RipO*=WGNwL-%v{f1QY-O00;mPT~AeNS!8^W1ONc22><{Y0001RX>c!JX>N37a&BR4F +Jo+JFKuCIZZ2?neO7I6+cpsXu3y0^7-j>ujD9tc0Y%$k0fMv$x=%qM(9%g_Ly-bW+0lmm_dQ2ScG9LZ +V1qAr&)q%uLg#t@#i?GpNyuT)s**ujBgh0d4OW>@WO<%vsvoQiLfcAey6oCknReM)zpVV^v&Pw8glT| +)n2&Fj4;%4$U<*=bNn}t%QNj*6oE4Q;g&c#eY(HpQg}TR5YW;>k2m}}$h&*V5d(L_fiKZckqGPYb5za8Z1qXivAL?4M +v5jz}F$~I5%4`Q`D}p+3N8`tVVG&$p$avWhhotx(K&0itI>`dcAQOmM3(4MeAq;-M+i~KCX^@4oJ2E> +TUEG0dSGJ?7X?Ha;#aqa2In&z-bg~nzlYIf8ubo7+wi}|PC615w1DC+&BUuz3B3BQ79w$f+7p4vjX05bGWL|vDsr6e*}zG`7M#NGNt&2KWsdfVm| +i$g&&~CB%Wo(%>Zm-$CmlwQ7W@*3lOAVB?;YS*gMudfEXS>&dRFeY{CyNain{gcq5Ni) +m*|fkf|9KrN^4|i~_$@E3C%yjN?np^D8EXz_Hf$#JW)8Il>t@dC@U7-`Ts6z@9U40I8&>eRhQve=y?; +>DnXu_aTR1zF~S05DxuDbSUS?Sv0~H_$_-|kD6AqJfCp8UFT&PM^~AzBmSKYl+qQWiCLm&m1tgyUN)F +8OGj+LtyXYZ&P5RYg&Klk=t8{r+={6K1@{JD)u7f)3uLURh&nefKv;Q`+?WfN^$*19RNjxo1PzYIOhw +>2tEoxl$UN-N)Bb^n|AP#yE~#9UC4tcJ?i}W +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 +KR6I$e$hGt6StaLW%QHV&QBYFLYdWJa +Eorx7~5g*2hkr_KVh*uE6KWU{=X%>Ygl5`i$rjEZm|IJhEQl2#}kGJ>H_4bR+Y_rioIH@|4aHG1Kld$ +xKlj5P)2EvFY9)oidvPGssZ1gII`rkW-2=LD!`*<4ycd?6u^BP%EG%^lJ@1s|YSu;rm?G;rx +fLjb +EeEvhlT?s1=(x;Sl|0YLh)}d5vi}z;n`NGC#ax~BuOv +D)0JtV(ve%^Rzg!jo`D2YvtzQyA9k-TiUiI7vscy`aX^WD +I11S)|%bie!YWtFc~usbE+8$;ZX-JM6UXVx0+lbyM`-cl$%9}$H1e5{77+v*4lneoP +1cXm0`z0V-C<`K>dXSnkQ%IOZ@JUAk3v7PfLlA|311=8x!>C(Z1|TQ{2}ao04qOFO0(?E>fS)0Wxqyt +XP<4P4u7L_@w(nV`AiSeM_7>?Q(!w&sEc&96!qzARYZRi38mLjQB6GE&beo$rXc#Fif8PsZ?KA@rP?J +IG2Yd74q>m1wNP>|;9JAPNj5?MZsYh*EO&2+6&^Xf;95 +eX`px?@Hwkn3$8H_?i^5ygUWRb2sk%m-sLYiyf}RHy-%K>y*5MMU)X2)h3yfYlfCPG&P|Y2;!09- +?2`#9y?kviek<&61s#r*qr|v1|r?PIg-diLXfXsJ#LC_rWMi7cR-tj9)!>&{>d{C$vb6!E~I%GI +rQM(-!{#aRb!p8xT0k(R9ZRcj)rReo*^Y*V@FTmf_aTKYghW1oK@YQib%LbcM>zRNyfpFe3XX{w0!ek +d+G2>OuV8gmFX~Gu5mhB{{4aN}SakE}cDGsfcBax*5=BZgiBvDu+ai7>yC@^xe#6@6Dm&Uosh+&)Yde +5ugfi&C)Kb$cE=7Z_i +WR}W9cbVU1*qeZ@qH$roF>d$S|dmu2;hI=2eVE16m%O?x3s4gn|(%dKhlxXQhrzp&&ee_T6hKlYijes +|I_AFe~dyun|924rYQjAG^NQ|+1HA7YQFG4akOr?!j^GNxIhObg-W-{3&5dzkf^EwP)|+j0jrJBaG>4 +<3b!-VE|2I002F`rn`YSj6MYS}ZCwULO0L*p-aebuJ@%{Dx>3E>A_FOHa%~Cb@5aaCfv$C&lqhY94h) +fWXe}EAN?0C7;loF}d1sgy{fEdA{Aks( +`Ld;PCcaO=4K-F1^{Lj)1dGZ?K(u6NuZm)_S9(l=cLSb^-h2_}d_)xs{#mj1kW0r!b0{rTJ6Bcddrbh +fW=d$=)&afM&fcs&ykC@Yuz$OBY}9O5P#)g{h$i$=RRe8JaCuXVR>U5K%KyBzcsazsJRZZ1Dz*H{K2` +L@kzxc3Pb(Mw+f9g5}B6Y%T^naH)``U;-;x+oz3dxJ~Yz`Ih!?&H&vp3X$LBd{dY3eq4@(`uDW{Ev9g +2Xc#dDmm4{1p4?0?0K_VSe9Th5;iI8z-w$5}$^VO2)EOu=<~x1%VG*b~3xhE>6O5T|im~v~X1#*E68I +G`g;EWm=Z;m_$JxX91}ze0QbC%aC}$|=Bmj>oVpwlaG2zQ>I_fdHdI5p-FksrjUOhPVSI05IGd5NP0k +9Ym^ccT&vVuawB|}}IeJT&MokAhZP=6{2N?J+=9nE}rsd+pc`Bwa1go(5B^D`*3D~fe`=*xIi2 +^ER$mFjZ^3|wIt5kVhGFK^n8$@zIgenJ+rMHOU1liMSPAv_bssHZj-6ycNtjO_-hoo;*%kf1DI=X(E0Ep~ +asrrH8S(AC%A_R+dP!~wVUDo2<@oO4D5O-N9GGUK6Ev;w`JL0JUujJ;|ZIt5Tytat|trors3$GHCc`N +>)cT)l%#N&GH<=Z2W!woP%2!>$8FBv&9`M4GCEG|k0CHPni4v$fuK7N8_qGGfz#zwp@R<*sxD1>iWvr +red6)G{bDp|@+yRkd^PbUdSbcol3)b&F&5jRGuEt?5i956m3wj1yZdGh~c5mtYrWiXCsGC&=}May;&# +B`TmG5n#yJ*I&m`);ek-D|sfj3#s+9aG#P)cIrJKnLR)#2c`+|EY}`un{pbqha`K;m&dmGh%JfV^9W( +sosH%l9>(=Mj)87d64BpSiPXtWrVLV2)coHwhi$b^CUJ#;_X3q!N<}Z#@k^w2iX(*5$zRri%fl +H=gn#~cb$?q8mQ1qR+_CZ_X@S9N8IkU)UQFL5pGO<8ku81X!nTi+8;dX&)+~!ykD&NrEsXu*r}RBDBr +LX6jH3^E7zXNHpVEYffl)-b&Yyn#mT@hoDM3T&JkU6Gw`AijRiI}o--Mm6V^pT3EP`fUu%Zv0#N(W;B +nok5m25&s2J?YNqBlew|EF*0;=K$RC!Qz!g;Pe)Cnm$fRcQP!!uF~cRIp*DCw?6e;G8$Yy>w=_Fhzw7 +0Ua%x2NP|Q|E}h&avrmNuCye0VKGmS6mEz2!N)J#(gN)1GDc1tvy6P{+`JEmEN0ss+)Slt0gAE|@)TDZJ +G=HGwLqK}8ab*N$uWqD?B*Ad6}hu6DeK%^ZuMk_mK@!N*E!Od(oh98!Bc^E&f9^CFJ5HV&#r6;5kuqsr(bxN|Mk9z;02;ZpLQ!~||pq2W%O1U@-hwZ?YU+P>6IXvJj$ +4^1sG3ShOU)BHQCQk&F>;*i!x?+sep +KPfZW_!_D^Mh#w@cEtX639Ui$*#K!EvaAhkr_ce|Yt7*ML5i3MR+BhL?D)oLpVRVmHl{~`^p&{Z49^3(e3gC@&aMUHHEDDKNp +tK8Vvz)o2`-= +#;n<5CWS&O+WJ1pUZ!sr-t&fz7pE7x?1{^=aijxYcC!tl< +?X_tc*WrKFaR~;V-7_7)bql6~6SZGyduU`aOec`z%DQ+N!mu2qFF#`ry5HF@YUcqyCwMxPrWbHd(orF +6KFymcS+CXt=)T1AbVRmOlo(0kvwN5kpkW*8a++o~hn*cArb5&p_QN?Z8YSoE`&$jIDWYiAR2~pfB#6 +lf9W$1-}LlWWV$_qhIioXe4D1$L}iw?K~z59lRBLUzJ3flLg;5393f;Mz$V}0Qk@6a`d8kkdT|E+4F9 +DhXX@q79_AUhdev$W5kSD2+%jZB*se*8$LH8)Oh89x=;k)W(!1d=lUx-^j;xK9w^8R^`$t`j&NP(kfg +v>ehWy^a0=P)h>@6aWAK2mldXPgP`1H>ds+008_(001BW003}la4%nJZggdGZeeUMV{BUU0w7gXIabfQN|>1vNr3uc_C{WD_3JlR@L32;=B;m9V_a`s;sku9kc5!zt8UYpF~ygm +gQNKtwkxiJ+!F~I@VVe&w-Du73H3ZT~oIm(p~udc3Hj^6>s+p=arQu6P;uaFqgXJg`O6#a>3<_@h*=S +Q4}o}nqFDo-2q$XXD!X0+{?wLt#@qGS9w?0r8F$STsx7K>TTV0@Ec^QU;Z^Kd#-zS`vzyM-`xJ~`aC^ +-dw%-oi}ydS*!R_b#V&>HR_v1{;^*U8g--*u`Rfq!roO8v}sN;Ft*6oU2xBNlWz5JmUWpO52dK@BztN +$68DN7FP(;8}*qPjmd59j+eN{7;oQX<{i)2vWuP;g$#SaPHflSrGEZ-$wCFppsp8{UG_@u1)}l`d=Vc +$YT&ZVOgt)Px>h)3Z?Dig%B7dk-v-g$|q#HXG_xHyrE}g&wa_uIm43*TQ`5>`COe>e(|?VA>6tzv_9z +|Iv$`^m3EdeOG`p1_Ryl{C; +3sG%3A?uBayJZHNdAi^|D&Osi-R>J;@DALXd5v^{OnMJCC1-@JMtl%$*JmZK9? +Y06gaBBYv`2GH?R)Uv8{eOv&{#xT%0bp2K3r;dv{;~{2USmu$B)6vF6r4aO{;9j)AVq$SQLE2(!Av$K +roM9b`qw=Qy^;m-SUtf{ny~Le~RoN(I>?QFbB~iHi8z_re^=imfx+|H*XGA6TI3?NbY&RWrWez4$C&c +M~`MEAudA@%pNjPqDim~cs%7K*mvq}{l5R{pTqU +?qp~(9SM3_J|Gf6KfSV9DM?lvzqWnVsFPmaSJ;>MnMY8Y2TJ|nU{dnG;TT3h{`uQ#7#eekNNb;atTwq +QA?4r65g|V!-yzDqRKabmb6DrTR(^b7G4h#8=Y;56&HcB#9rSX9-D^=QTZl$DY +@296g{0z%Vn!#L0n#dGNOg3;iWPs!&l&KktEOSrdPHQUqCK#khW5%FYDHK6oIbVdULdNgS}y<#`k(!o +l>{#wi>UdQ*CSM3EICzp+&uoR+l;{rRh)ULX^ +$vRF;KcUK_zIe9`x7J=pC}#jSzmMT65ty!_n0zOv2E8i^5ppVPITLTjX?icfz#vNzS$pxqX*WG|M2_& +_&vK9`8_6t9vSpJ7;nZRMa!Xe9%+Kt(D6sU96e`a`5r06$|c@Hvgdds@bJbB*=C*CaezwCHQRuE*8qv +ru1<59o!E#IwuXEVT9U!5rnCA;i5mf_WN&U(npZmXXcdlZ?1?ZTH^b +-vC{tb`W+;5E_JZ;tVvBQt-{*jk*Ih^ObCcf%yqEH!A&E}f(n4a~e}+X*tstoyo9?u+qfW-4?YjBEg5 +;f;HTZiCv3Xbm@TzDo(IHODt{Jj0(jc0O(#b^si+zS$Yagn&Sw7uhHCi=T3c&W;8dfARO}(dn2kUJUW +p1NjYrNEIPHu^FZyPxp_=>#+R|A+d2PPoM=GoD@#|Jv-A}qte>#FQv39$ZSXRF*apl7k!yG8>|1A_wC +0?Z>2rfFr$L1lwuQLA)*NPOcCXxj(I)$T)vM$+%lfQ^?44rtmXrWq0$Zs+tuHwZ02U2Vi&k7X|aIiEp +!Lfql2eV8HL3mE!&Vs}d2Pkb_~a5MRIyI)-1&o~6q9pv)J<0DK0zytIF_%LV=0bB@p5Th{QsZiNcS#d +lAY!$2Sh<+22p<#uvTH}gt2t+yrX;glJ_VHs|_l?Hl29vKsfPDha*Ago$ol|6WA-ZIb5MOC>$`0>vpn +*w6>lW**5MFBN1xbi(YV6pJ3aeDOZBTqlSdg|bopv(H?*nLmOS+O`J-{mkJb|-(NaO;jvpPJk@%06zk +-Uhl$Z2LZv~B@}tD>}qYJg9+*@M8ar+e3wfZ~kpWX3GKV(+qh$VxF!o{=e4svD3ZCUE1JyUpYrr1!(D +Ss*>9sRSutyQ&5>d^=O>=4$^HqQOUqb1N&jM}E+v;+x5r;LsqSF#-nRpuC4#Ks+`A15xL26kcYw!6@} ++6myirNx(>#zgvy{(BT+L(gMSO5@0weEU$*8p;9_BSkzo>hj3)-BI_ +RU65?k}>2X^DR829^%bt)ife6rm5lOe2ppf#meuQSM61j3ZN1H6i72v8ajYHAq$1n-ypht9bQ&Uj32_ +Wl81EY0WyDE%V00||xZO`2>YwpNr$T7OaD_q%IN|QgB2oK)v&*$gY-~VuVp5C6nyFRG}J=1`2uc`SsiLcj?Es=jWH{>G!8^&qIxF&i^MRDyzjOU0cHfQz|xT+gE8O)3&a4LCyLY +Fz&0q12+w;q3coPK4o7}ou|cO82d{lK5MUXfhoVP4!X6PmFj}VB0EunqP3#q_8=HBBkhc*rfo$(jiOasc;-wmfFV_%?)yGxg7poG+yZk&*a>)KRO&Dl +y1tkMr)EBBL0sM{*WUOZ1hd`VswqT|+FzvT6hF5Y%BuF@&koF$6?_=<&yk_h(lhKQNjIxgM&OzJuhIn +QodU*$6~Alk#GM3y3=_fYYMRWi0ArUL8x?fH=m0is3uoVX;+^5A|!vu`q77Cm!$`~baGTT{75?$W +&ES=Bd7bkrwU>mdIE{|@fu3|LYsYG4^?Hpo@vz%52w;*_RDF_>djI&1d|L+QN^VGQ3xR|5o3jVo;RcF +5A)oXl^T1ke_8NGlfh-D7;A=){uhXeB`FWoHVLmdVE!tB0*$Svhfc@dmg%uCjoCxPxC*fW<14Eq-`q6 +w8)d6B>&oSQ~PX7Jw*POn;J3h&VWkgW@JN4~_p(Reb!bCThd44&uSxX`iG9Ko|kh%^5Qy`>XRDZHVxW +$!!`{ug8+Jc#%_hVKOGRyKDVo=p7oWyt +FP?_lBUny))yi~ziIFi8j@mw6kCyRnW2I>wFh-rllFjtVv +b3tc2J@21o*`8zQ%?{CBMt^{gEN%)d~v^`jpeQ@zZ5Py^fk#G)bkSZ{K|T#*XpCw$BdIHg^|2)rSfkz +l1wM)_8G8TBS6gaVMd@XuM|Y!rqyO6YsRc%25Hmm1S#!PA!jqUk=VX8=bjYr +gR{g~2$$Gk9XWck7ruFPO)aG +812Foh*2Woik&FBpnIgvK6-`?I{k9MsGI&D?~Br`in=<4e=9s#t6;UM%@h)b!K7SGY4Kn78Xw_-U;gYE_=I(D}K+x8h5Y%U3y;Hc=|=G4$gK>zj|xqd8hf2;z-3YZD0*g$ji-0wt5 +nPCw`HuM_52#uv3d*b~XO;9=XM2;OhUZ7!jAbOduGb;l3q2FA^f@Cv_0cvSzO;T9!Ew_{KANyUr(2;n +*Rx|3H*jvBJ5IvINZnAIlR6thRHxqcMqq_myp1W9||bs8%JLD%1z#Y@~(xOq98`5D +^z)i&KsFO<|LGv|ncx5}}xraITGZ|+)f-zil^_#MP_xWgdR)khMHKyLO&ST2hEIW@fb-8X-5gn-ni({ +J{vd(O;hPiKiS8C$V9jz9Tb2}!u837>@!8h(ByZXnfiPG15u`WUtEt)4uf=`|z|!i&MW%!3pU*G`Q~i +8HacBhN!=P6}x=rc*MR9-$evFehk2rP|*B!eA1K1#NqL9FHhc&@6h)5~)Zbs)t%{hY5A!OI0p_*9SbR +=a8cs7@c&}WjKHqc>07qD;|fmI}sR`A1TSevRau@E!(9P-3%FoO5)ZW5lIWfgWcn1&#+2gfyC^2)$n; +(-K`XBbK5RF0y;8&34!=#;`PjB9A45)oSeCy2nBdKJ}q(XrwzwOl8hfrySzAVkYts6bH9kN<}-aaOJH +!L$@sx+myt_N!jA)@^?htI`W+C+$lE642h%Pi7n+QI`yHGt;~70wXfB|m&*|r=D?FV+>7lvqVPlyFocq)kC?59TpzeXMok~KZ%5bacSVMY55kneN>zDD?FLguTlFIoxH>4m +HD62bf*ug$+!?yuPUtK0Jv7OqXu;fFP+6FdOnkB;=~BmEkZ4V2ll?$mS5zokDNxyOk+9J{~&*WT|-v` +Tk*R=IzLzkJ0mHjs$!-5yliMCGvCr~2##JsgruH!%bfI6w?7NbOQ{SkLhZE>ojro6%fV((%siVSRatu +H8MKH+UKM;nTy>vDgUpFFH|Mg?Rsq4>|4THR>ithsMUVVQ+x9V>Z;pEgz86F)$w +pNW~7^7+9MEE)`YkK{OJ;k4JF`}|B?{u2H7;X$l61;X6m_4;)oaw=HB8dJX{Vv#x)s4}0*OIFtPy*ZU<4um-wL)PZoROWTV!D3Xe*nK)QEp_!u(uq~u0F +ObXigEOgL$jr~$2UA4ZTP5N84};n#7U*}HiG{L0KWJmqbK)?y$}1{lC1M>|Fo1lSABk>0<69|a&_aGI +<7gcrPmVtd|NlIz?YPM(RnRvB05)dPH&%3rFWLsk6W(30<3it&_H!KPk^)a)+y5InLJVgiP!_l82vsu +kC>gQbK$guNx(m>sMtESe+VM+{{}>?K4O}jhc)rk`@6aWAK2mldXPgSYRS;?LT0090I0012T003}la4%nJZggdGZeeUMV{B%ZW5@+ehpiK*Voo!5oDh6+HYWy@zF}fMAfuP$Ovy-dA5FPoShJH=A=nDKS$?Xu(tSv-1kA +bQX6Z!?-3t{{0~YF6i5V5z#etI +7El$e%vJqt4!j&v|H?EvXJC0=+l7zW!s}Ygi7*>8jwGXHk+)XarKq@0kW^vTm_LCxTJ>u~8b9tvFXS54=0e>TER$Me;xu?G>J8k?)qcEm=ydvqw;*(&(T +fd?G#@%k>j_4gcRa7Vri7nVc98!8M-I`rV}P3Enrahm#-esdLr?mlO5y4Kjy?~xw)rVE(0_5Mo7ciKYw6Wi7^0%ECqW_00LN<%->|j+>k(JA1Geh= +Z1)XKL-vyQH^_P%;x#-Vh_GGglFs=R}n{dUvfvw-e&1HKs@u+!H^;r0%N~p*a(lg623z +cU3jry1$Xg{_^DE!?i7Qpx6=5cQkhFOp+g)xh;)9S5yKyI&sof!KAN!F7>q&npakjW>?*;I1KH*|Na# +0IcU!tB+4WUg}RV)%`%IcfCi=MnK8qlo6;^zqorc5nbKH}IpP58cwH=g6IRV}p(qT=taS6Is~xdG;Kg +NlfqEmz!yS0CSBoWJ*z!RIHls~?^|6TRf +(?fKApj-0sTx<$DE_gBK#+1yAz +y0pXix?5HY4AOHjan$(1KO86Fxxm~JJ4F=Kr6JG0Nn!JwxF=xH|Tf&(TFlzK{-hN0#Hi>1QY-O00;mP +T~Ag0dH_pU0001V0000X0001RX>c!JX>N37a&BR4FJo+JFLQKZbaiuIV{c?-b1rasJ&UmofG`Ze_FT~ +ups+GP8$<;pC~3-=|G$6*Hp`aPQbN@*g$_`J<)t2scH*1-GZ9*mYV(2AoVfbRM)?f`T!O8zsV`QJ?77 +H)jX><@T+@d7A8~*OP)h>@6aWAK2mldXPgU!c)iII;001fv001HY003}la4%nJZggdGZeeUMV{dJ3VQ +yq|FJE72ZfSI1UoLQYombtD<1`R|&tEYL545K?@LXw;j=e*y1l&p-@UU8S-Nb3EI(D#~_5$L6XU0xir +_CPZ`jTcof1a<5(=<&US$<%94!Ks22_@7Xn3T|n21#|zRAG}8_Cdr(P2t$kRltqK)=`VX2eK$cI3g@^ZJq3v{V}Y!&=_vH@&;elYqIx}c}pKF4%!sl5UXYmV`48p3t=0{Iu +u3W_eZY4Rl40*_}~yu3v^nrj*+XAaDiv>*pObuxleM6wh&J#KCQfL*-{mdm6{#!P>x#18mxrI5aWP~HGojyZyF@P(N|pVTr-Mv@y}8c)`l6+~%##ti?R0RB>;@KjQ! +o0z}wJkOs#T{ft#E|L#{)SH>$;PHKL*sNzR!y_f+QnO+%h_hbg>s?QqfHAOM#nGxSjK)PVa`)RnoPcu +Xy^5tYod3n=0_n9PPd|9d1cVR1)1b$}FHxc5GW^e07+zyH`9{H>xdw=eShDU53dgIB%Y#VMg+mJp01Og%>f{+WGfxvcpGJV&W@`~q&xu +Akl{AnOb&JRaCJfeFbZrc>>2c6ujZ8;3^jr7_}-$t{l9yqcZepcN<5Q>HTP8SvOWK7_B?YYAnTo!PPSN^y*c@R^pQu+$+=X!2`I-z1J9BDLF5 +Q1DOl2LUOKJR{*Vh(^VKWJ1z*0AbbXmo9JfHew$7Tzo+(!tn&1D-Xn5CrN3ytjVk!i8s8LtBeOgUWp%T#VkV34G +Vi9uh$*-U5j5e+Dcf!==q*^G5c#irpj<4>LQFq!T9+-(SPy_tPjkaq|92lBD1zhHeQ{nyO^x6aXa`b6C4N +EHRn_n|EO+Xl`evc2>gy`^oyb_aXzaIrVNVC;V+f58wmeZ1~QFz@>3C4hLNArl6-ZKDSLKK$r+YekLY +$P78Kmn8V84;M4q!=KNwAA(D=z*?u*xi$tTT{gti4->oulo*cTzDDkHsqrF*Ws0-d258<$xVB|dpSW4 +{n1k#9EW~MSU=a>K%1n0Pon0(@8=|~2vpJXP5Rwu5>D!Q09Ekiz^cSso@-I+J0|XQR000O85nWGJmtj +CKg$Muuo*e)H9{>OVaA|NaUukZ1WpZv|Y%gPPZEaz0WOFZLVPj}zE^v9x8EbFjHuAfF1);?vQfn*Q;( +!B;^B#)a-d%x38ft+{IfpDw +4QCG*fUYzz0-z2gQN*MOps$JhcD)kat-{3-V-8il26(dZ7(L6 +_j~C3&5Ei8?7JHmpvwpFljt6wv12xoV6n`CdHmCHq8ACMx)oY!C1botZEjBG!%Ec6e!7vH~JVji3qq{ +{C-us?kyJ@9$x!Vr#%*+fu9<|6EJ16zT_@)0Qo&5x177AH}u;!4k>;-+;xE2VOmZKW}8iX}eK~w`x6w +pSQIXTQu-s1yOfS*Rw;xTxS;Te~D%DVjQbH}6|6>Z +~rCimW|n*7i$VPr=EFAbadP03s|{8lF&J5(@qV7W>8sFzm)~xH|AVECA70t+^V(g(KMws=2)7;0IH#_Yp(cF#v`3gQ&B`R +RaBX)euaYkRO!0pc^pJN!jkJoR_5U7gnGmN!6D7|1r#e2;X`@RkrYGlynS~^Yf$~1`<{`$w?p>2d>yVcnj|*h=tcEX!l7!E3a(tFBdOled>!uSjF)hwi+x>V +*jb^(9FQXtDf;BMfeYz(f9s;LV;_S_NJevif2AhNBdTrlcm&KU(an*(W=#>x4Q#2rcLtNT?WAs@&UiT +18P0xos>)sMG_gE^30Wg2>}cl#L}yk)<}W4Swg=4jbXUl3=KR2?2xQk?uSaewh;yEUQzwd**ZKILE8A0ni}+{gu(q!DI_69EIHBg#mk~qV`h;+0n#g6 +dUqd$zUFyGYZmx{U0Jk5S)2JUoy0Sd7byJkuI>1+C(z;(j%BnH)>`RK26U2ayO%@o1no5sp3|-c*jy8 +bCo}Td5YGQ4CI1RkB8oZAY`Yu`ZU&r8+)?ZDoj*)w|TKT2s1xBRGXyv)n7A90#)M2-HqORLq^s4!=9s +5o79P1|nM(jQN=C>C1$@9U^Bwh#McEDKt6f6|(j;=c=o+HEAnf$IX3I2 ++rv2z#{X2N__j1S3Osy?{y~5*h?oU;2+_3dBsjHGhaI#v8ha%^6&qEc%C-{mw)6NiGLn;yoiEIZGP_k +EBtX-EVwOMK}!2(}wHy5s`(Dj9X!+xkBi#Hqy&}nJKB5fJo{S})cYfI&}c;Ho!fC2xyr^ZA}{Y+JR!@ +kRNn%o>07&tYxYg^YG_7H|P0On^Duns?XdQ5)CjOF#f< +yt5n2Ig)tXKz(7XJeFJF8z~?Zn7m`8Waq6a}an5<=uGv;e(i+a!=gbbU}X$L3-!u@bU<(nl)WCLn$Qj +;kg{Lb%zF(pwam1X!vZ0p*+c)__cM|yE{WXAowK%pOw@do<<|tamB&+FU|edmsb3iz8nG2x0EgsZgO3PW~K=Qv +zFJ(o~|U14#=ICAC7aZ~=lMc%wkBLiOx#4k}au_~F@QZm+G3G5ELv_a8WE_G1Iv=G15RU!m>qd&IOo +kcb4>NaMU%==im==Yp&1OgkOMD)hKnb(p|&tkVOD(?3-@*`3G>BQwa^Bh<-k*;!wChJeB>%2FI44AxN +PDhNm9g=gBd7j3{VsUE21`T5~+h)op7LT=A<{%~INTH)8?9YCJ9$lY|}etpftfJ6_lBnOKC1J`Y$46t +VQ$5nT_sI*D%jWoXiP)h>@6aWAK2mldXPgNQ=Y>6=f005N+0018V003}la4%nJZggdGZeeUMV{dJ3VQ +yq|FJowBV{0yOd9_qcYvV8wz57=Tfr1TQv*$qf5_&7Ukg&akU=(}oXd_EneYE7?@5ospMh1{k6?u_j|K>*zJ}ol}5uHSJD>M39Iu|nI=H1-zqh$&aB1KqRWSEgUn&PUj}G +GB@#klohR8+Gw-;tMaOM5wRtg|fRuOIlNdosG;lvjTD0gM`@OU*CF`&(vm{9>!K{T%;5KTKj{n)Z=eJ +s|p3v~-0y85R$yzwEX9SW~)3J{Np+=3eMp<#R1yv?JgtwGTOu`2A>rNZh!k!EcY8~dx8XGWPrWQq$!x +&zV#^=CHOK-vKy>;f0!M7j8%B_p6Ifs`M +uTH=%Nae1BP^|JrgqXr|#(1RV;PqVl?}yhZAIKaT_Nh`2r|F+2_CcfnT7H`RCpKHqp>(|qNAKXG{BZ6 +1v@ddi8oz1HJD9OH@7cziXArJrnBme*aaA|NaUukZ1WpZv|Y%gPPZEaz0WOFZLZ*6dFWp +rt8ZZ2?nrB_*R<2Dd}_pcaejV{$%+PaS}yg-sVK+tq!*xm+<#8734cG%UmB;_2g|9gj&WS!2Yu3jXOG +vD09Aq$h3OAybZ$FfgJpX4KVlir%gA;gJHTrMc&yMMYtN=3FOpA!~sik)jFWG~xDSYkUYl9WeoV0!_x +SFWIr7l)x6`31v8_Ir#)NLQu;nS3e=migz4i^+W6#ga-E2s>oLD~LB#Ith|NzjsPWdxf32|iQFHhqNuup>6O6F{9<-BUCdFyt_S!SX!nCL(&8Y09K> +@<9AX}JcDuu;dKB(#GQIvXCeSDP*SWo!{Wc#P{oStoz58*w-y3j$U*m2(n*2i1kNf5KcbKMEQ|IjS;- +>K3WITla5Ptdi!Kd2~Q5pnbLaG0LfB4MpqhQ70)3uuh60FOn?XXkv$+*x(gY4s_<+61ed78e(U-eiJd +u{-aG4};{>Q&j})b+tS^Rn&Mh8J~kB*Als=QRMj{J6ubt|lY{wuWGuM>#tEoCz8(>+U}4ZBGVZ{r)x& +uh}aucGPYGK^0z2X+bfP!BfR4K=Q&4Sfm1OLItMmqh|B2A0(TmnQT}$tJqBfn#< +`ZaEl+bvnsaClg7)BqD+qOt+X$6=@iY5?xh))%{truU#-mhX+jqbF4cSN&HB;?kO&! +2qLey_P?Twxdejmmsf@<~3iDr}Z`MYZ`4Z3|1rS4%{8}-y$SG}(UooI0F-OBuemG}>bBFL+9`eLP0N^?e5?GUO +9P&|r<#{}DdL5gi?LSIf2+YC2(;45VhPVOe@K88lW`jTKkNYHSFpbi>vxWP?Jljg1a8oZE0CYi;!%<) +pDO39;E$jw&_jX)iUf%>QoNONVJMr<&FVJK3_A|7(~&xto@)PqnNA?PSv$SSQ$4ISHE6!T;|I +}y!Z-CTWT;xdH{KikMir*09?MoKXt{r!&zmi>mIK@W!YmJnc@s1 +1;_{5QaoPkNsAVwj%JLT0Y7Ey+CSMBLos*T(cv0fEUQzpVf-@!NS|_UKXN8%+h}7lo88Pt@Fh+mOofC*ol(2}ePk5s8G!LH?7w3cky +_whwYZ_c!JX>N37a&BR4FJo_QZDDR?b1!3WZ +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 +f@Gv`F1(-%7JX3mbY +-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 +bANC1Q3enP?DcekHmuT8^UF*px@M +6I+zM(OGVJxMVyboqPJVc700uaOqgWdMF7|1~_s^gj-cNQuC!ip7oGqTH|H>JRv=6>g(3fL|_1J|1U_ +(I6iX;d)nBQkPt2o7pliJ#?2@=kM(3k|%&z4!aLrTAXhkP`11IDdD7#druGtBGGkR`uN>})NtSyYN?; +Nq+?68b_10LrK!qEWsseF>e2FeB@}5{N~Bzbxz`+)vuMuZwr-a#Z2U4~*{zaC(4A{LH-r +OYgv6ac_R0!}MfOv1jZLKRlrmpO`TE2#v`|yffoNQ`WVO*+|=~u`| +JZXi^m{QD(+FCeFYb<+$gHw6ZS*5j0Gtyl$|kDcf=5^0+;6ToJ-jeV_Eo1T4Jqx}e+|HsqXD +lQwJT1cj<)nl!T;a_g7o%JPbtgZ#=IW1mI4v*_|kKVGbx$mR~d&zX+1EZai%_C)kPjcnYX%)Jxb5Hq1 +3g4javzS~zcuXF#h_K6Hc`uqh#A5Yv&m?cLGGdo|;E#AQW?aeJXUfXwIDVYtv8vs9sf8#LE{V3e^RE* +RZBq^z3iVo#5527y=zqCD@qMeLH{ge_xf +bu|A3e)Y2Np+<=5icQ-ab*CB{S+5Zm=DcJ_Cq!Tv&Z0ah&d&5Og>UW-=3)IebZ5pI6csdS7Ob}BVZ*Q +f06?owwRfxZAM=JU%h!sNDA&EVCIJ6z3k~?_?Ia7eufH4^4r_#msx)C%#+d^T+l&5C*)`Okbp{V3FSY +UmVNy=U!F=gNyv_ud-`X5 +kB0|XQR000O85nWGJ+}tD%1|I+b?t1_LApigXaA|NaUukZ1WpZv|Y%gPPZEaz0WOFZRZgX^DY-}!YdC +fg*bK6LA-~B6aaJdB5kr%{vmqpvngV(#RsH?1ez>RmsE>1s+YFRh&F3aC%Yv>y +z46Pa=&#JmA@~kZWTclOC72}>wk#AJ3)N?vy%%YhHEYqOyM4C-fF}Aj;zOF(+ig}YRp;nI0G~JFLtivvE2{1(zn|0do2;qQVwE<1m1b?))O +9Cc6x}AxOOaLmZvJ34HDTLjUEji-OQFGi{^rf=H*?t7r%z#DeLcmeT-ZyLKs|4ox|s(rDj2scGi*YSe +1nvAo>^lcdRo|lt#=Q$qRW<9mzk|a^|5H`3bEqt0;?+9cvUystb;XHT~n8;|4;PvDL*{WyD-+0HiG&p +iZ))op*Oy9n8k3R@pWI6Oa6b_H9+K|F_&Y#I5HIADStm;zgm?=-aP{x0l&-xdYeknapm;dOR_+6Y8cg +iT>v-1T0cy6AUc(;Z90`GG02t4@ugU2`Tjz5{qB6voZmi0ApZhb<|YhtNe$B$TLQDBl9eV%n8ZU29J9 +;xuKe=i)w9>Xc+Z;GAHSo+V7^vSi +$`5zU{+R`ati<56d;~&S}B_Vc#+n9x9huu2!vJdaApP3TloGA=qd+|wV&<=LZR!k5~PE@6cCaX +pd;<8rD)Qj6+<Sta4^p?kjj&?tZ&5fyb()8grsun#DBJ%x(9w|t_LAy@T-* +Yvj-1K+OQxQHZMv^_oXSkeXtZO+7V`+Yn(h~=rW$3p|VBbnJxTao?!9A0m#oJ(XS+rUKdr??DY&F49+ +}^PlI09FdcO#7FP=Scrk8aSgyBqgm6N5sk{0^fYl;yIPNT@4Zy2lr>C#j|$O{QU@VVnZcw +n^itr~Ejms#7Yg-Zn(jTQBb*B^$VDIo*4aX{-LeVy@qi{N~J{vwD_{nyF?!So-CrJ#|rDgf!a2kT`YbhTW`KFFYHU5da^>-hRwsENcf*0`iU`W8? +Kw4jh11dm{zb#N)w##QiVFUo!hE+zgKgyDs5AII^;NQ=fAjMsOcfi4#U;QE-i=4SnHv_om_A}GAgp+0 +|>n}=hc>c$#z$jsStsnl!KigHB^`>L+Qz_9oj4O(p1#zTi_FmhuPC(&$nr@p|vE!aE7J-UL71~q)=Zl +Jia%bogw7$jwTtGRRwBGkoV+3Xjfc*42$BFnLH61KpI;2Si(a2kL;-X$S)PRE^L^Rm9|lAnMZh5c$H% +3Wf^KyW;(tCJ3A1r1m36+ZzZf;$52I}d*ATj?~Y6fn6EBQagg +&bGr>0sR6)z9sC)F{=tj#ANOh!KvmHKo}qJ9cYw5AnSrntpFn++Bu24&x~kDO!C`%)$$8#^8^2ieyLF +Q-1&Z3yUAamRQm|d>gKH_ZdiZyjQr(@FK;RDMmK#%AChG6)=hPd` +^o&Hfc1+Deb#Q`z6?eqV-`EcA-N{Bo5y0cWA%>&;HLTxyrl>dQaBHAw_ZzW#CM42+ +`?eBPQaouFCzQSS>0cmOxE*t9(-zxoDHiQL`WvfZ-;*x~1JFfVH)qJp?D>n&Sv)kP-U*# +@3|-{497R|GM(o87C4va0;#cL%xxiS%LssXAMjQ-Y@L)iN_$=2xdvx>b!3nP&0$k2?I!)30mOnc7@|l +5QXJ$!Ccr(gCVIkYG?kHIH-pu*~`H9C{BnZ!Mv);p7Jb*!Q78*)I$(`Q^Ezkn~OywBnG{7OKsArHn$T +L;Txen1JgDIsagfait&Uv%*sY&OC-WYS1*>pD7LP-^AcZ-rJ?IWcvsDh(y2!Gx8!JC+TDR{6+XZK0}9 +3{CbA#2*?LX(x2T(Qbd>;E@7dNo3oupBpS=C~>l_-je4P*dnuTZA09ZO +T)Lj-%BY~2r-va_ntLtv7b;KxTEAA=>&?LHNS9H(7KfhmRsW#G0)^5Z-V!HJjbWWRIXU&~wMwgu;3%v +W5?4yuA^~PM)(1{8<_)EHO>V9XFnkAQU1ZrcG0l`M8;AWbq`8^7E(RB8N-^~r^W_RiK)iE_Lg79(%7T +d@oiF7p>k6b;6hOi(TDF!cSx- +!kY=(TQ&n4EIL%P+l$qun!54j1y7;B~OcvlkB8C+HMH~W_k>5$f~CEU{{K)6>?>QSA{?=766pMvN2k% +e;wJ!8W6rMK9OY$_*Z2Jobl(;Xvg@$QD5ob%wnbol2|aCPx0Zogr+@{#b@&XODfK&%YpU~hZD)(>_8ocKQ9WbQ{j+Jyg7bu +oPFYw&YhRHLS(_X(CAQ;)QR7wC8*);_VMpcO;)8V`dQgD{UwCqr0YWEFzFPB$CN3L^-!MC}tTM>otDB +t}E^T$rbi7Dazo0tH7=-f5#8h(fncaAxm1Imlc2gZBPAnZX9+Q0_vBY8;p&MIIy +{bb_tcqvObfx8`RX=kDctV1n>PHY6ospB=E(R$M%RTdA+V#|7D5M>4TZ8j}fB@|PNt|7`_-{0BG_%pR +3dYLfVX)eEXW&V%Mz7TP_lL(ULuW{Rp8@mPQxbj0vJZ3OFBUY3)<;<6O2A7mTGgpWaVMOR`Mb4BmLno+seaCWFG(IxbE9@9 +>YO)P;mTT~<@K6R1P$5^cG0UL75dEtny7R*l6gbB|^`_6_;DqktG7&9n`NTBPuK6vP)`mE5}Yt%e4(j +bF5DZlheI3+h+>yuzhkh6G8 +5Z`+m>T_|R3-@UlQ@L7bbLH>pPRj7Er<`TNh((93>q!kmYK^9pR291S>j-=>{w9fK@ouY;bPqQ#jA_A +PhP&X1(YonK*WaNOtY`I5EbTz7F2e)psISRs8bkTf&A!k|GC|AEbATyZ(l!qeMZ%1AB9uc$CYJ6eZG# +^2WA~_zK31(42;oJup35ixJHtX03^ofT8PuDu?!bwE5-{j)Sy$9s6FvpvAWo-yE^(vr}0~iT;uVb`^#_=o96Yp|oh8cM?N{ +}4Z(7;J1m+@5ad6C^oO@UL|m%m}^#-+&Lf!`x#B)EP*WoW;q^^b*4c6v+z7Dh*?V_}YQ(xPvnGg&Sj0dnRiLWxW`RBef{v6VMXURYN?1Rj^g&7Iv8u#}m=~3 +*VYytoRpzK8ud&ur2RBoyya3bNjkdE`o$z!VgagCxvSv_or2Gviv-bq&_Qe}-^TTYfX4-U9q_+d}5==KSrNq@Cl&YbUxnCyCA+fC!g&N?TC%rT#P*6Tzf68C{0MVy_p@WYQ>vKV^;NZum7&e|de#H{LwH+AN+{ +J@D|SOFy|`ibQqV>)8?XPZpc#)FVxxndccgJ*cex>6n7c?wpb9-Yn!?(t9_8i+|i +ly?h{3v5o4k;$obI40%F2a15W9sr52*(*T{z!?N$jgk!j!8z%d>SkEh*$P{(z&#QS6N +YFhyvC`5Bw@#Fa0abJP>EFwVtv7{4g-ero6lwx3GheiT(AU31lz~$86D+L%Rumu{^7g3zjt~aSkd46j +X|Lnv0yl+8X;I-U6)0wt0pvved#Yoxn7ca(?>Zv!9x1ob3T>XbhVV0qOQTaVD)l@KK +Dx$W!n}G);vF%_oFP3*T*c=v>ilETDi$DbdcrtTI%2n%2mL@{Z_5Q(ttiI$Q5#C0J)m*sN{vjf+OJT@ +Pe+9G6RfMMZ-{c}*qBkpqPL1BL^@-78hQBx^Uu+Q0m_6`ujug1rm6e&29cDF$Pkh0j0M(YD?D+4G5vT +0cceZHqVg;HCYHfgC44w42Sj{}O9LD&tBn!Uxj@-%T{TfR7}9s7<~Tb;*FfNUbtMw6o9Y>4r6+nZ%=k +lm$3~a#YGnJID??*_LdnF~?2iqV%v-`U9iDf;pjGU=h%DPgOwVjr#kq+#x +2braU08!q52Em&Ip$kXQx)zKjhf>0CZnmr+fGX|lHU;;D_Z9V#EWBv)J-`t;B;Sb6xAj^8@dul)|YvI +o+SSyNjR;E7?=8=s7S*i-ser2djy| +N4T=ax@^tIKBV|!3`xf#5I^gO3~{?LhwTpJhpKJRWa8kE*tB;< +#(8PFNJ2A5JWwn;EvKGNCk8=keQfV? +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 +F*09ffYyfqtj@%bNnj9O>OL-YAeJ2G!#@ ++?-Pn#P9B^29}{2@U@jjFh&>zA%!KkR-z@TwWAltUy4y2W$2oy`iO&WV#C#~tp!+|HCsF)!ylA?dT4ebNh9@D&k}lAlWYi|Ok?yVMIVV_41RS28IcwT70ython#qV64x5p1En{3by?TMHf?{bpC3HckjH=Jde#|wHAWK!iwBgrG?0KoXV4JtblBTfu&Pm7vLrRqh)tC +BoDx$YiJ@tbf@@QX* +|6orXmJWU3Rj<$vwLWLs`M(+#V?-r0di?_ZS=IKava9NL9}^D@7(}Tsqo$?(8OdoH9(pjNjvQS(&TdT +5(u&J$_}p|jiD2QZ$|vDL4R%Lq{5!BR12!mF+lZoz^T1$5DK>7^rwOmd?OJp0BRUCl2a@9Q`I1@tgop +j)Cl3xn3O>1pIFt5jV44AUoN# +-GlF@{9FOPL0FeuVt|Wnx8Ut`g_+*Q5xG7OkrYij)6{@6aWAK2mldXPgPg0^Dklt002Q2001BW +003}la4%nJZggdGZeeUMV{dJ3VQyq|FLPyKa${&NaCxm*TW{Mo6n^)wAXF5PR$J(>?Zul5bZNQ;%MEq +1b#M)pwP~BHOsOQ5#0&i2cMdO-C@JmB6u_3rbLV$14BwZ9)FdyqTQ0UEZhxv>rFmZeIw=3D*@M29wDi +9p_PH!q=_=<;=+QoUJr3gd&dWO0Jn?>oeu;UhoGlp5j)T>PmrtHLIg{d6iwfzJVCbv$t2bmv6>oetU9qI-d^-VGk=- +2Elh~Po*s65XYWrx~7_X`YqGhnr>x_vzE(@`*54Xb#X67p8V$B{r`}N`aY=~AceP77WsYOgp&CB; +@;YL!SaA}Aa!KhM)QO}B6h0b90X_h@#wW@o`HOq=hmz5rk_$GwbbVT480^p%^$TbwJoGL|(wVOij+4^ +^`^YMmr-h~*F!jrqipj&P6hzo~R0`O@P+YJcJuhXkC5ytMa +Oqh*0pE&3vJBFs;u14Z+yVQIte6!D&?9uc&K!TNSiVWfJ%js%w=v3M;#5INSbi$)?XJumG ++F6El)3a!32h-z@%2{;#?!3ojvSfx4OiMsbR>?dh*|EHwMZZEBA;3?H4TM|opdMY@fRi(mJFyc*p1YT +%r79VPUYpV-A?x5%JGZl~EUGeoISvDpG%=NxFtHpH7ul(+x?@7+wv9g%ZAhdh*pMuu(3UQ6Pf`w^wJS +^(*f3sM_Sg{DZZtw1srI>Pc;i}1D~wPh_8 +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 +HVvSzsVwU7g3{ll`|4h`z1&g;CN~iAy +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 +Md_r?6YJ+FoKNLHgzEWm=xMP2@jmvn +wmwMj*p^d)l$?{4FPxBY)#G&lTlL2yq@k)MwA-%v{f1QY-O00;mPT~AfQ>)- +c!JX>N37a&BR4FJx(RbaH88b#!TOZgVepXk}$=E^v8uQ^Ag$Fbuu(71o?UqWOT4TB%jFr&U$8mG+1XF ++;Q=p-I>+{rWn|!a#S16S4hX{GOfO*%2l+iROijv`$ReJ>x~0i<0zUSye3f=;b6i{No6;Kwy-xqFUe{G$ +j4@#3?e4z1ZAksN_q0qd>VXV+;l!K(wlkO|{@adg9x$`%sM~l)!7zj3Nlk +G8*#q?|=@Bl1VjMgpOw**IFc7_#iT>BdsjR9uQYE`I{Vn=%6m4lQ#P+PZgIQl)a=8?@5`zE)4o)7WVq +cp+ALR;R~Cekz$hM|VjPYTgUHZ_3l5B|#8#SWx>HJVl5XN}9xR8M&r=!oa_!b>`vnAridijV(qT6wR( +YNs^%cV`>R6sq69$nwx)RbAI0>!btCwio4gZN%5xDZjn*@zq_^?X0wHl(#zhcZSwleNA@*bc!JX>N37a&BR4FKKRMWq2 +=NUukY>bYEXCaCuWwQu548Nv%-G%qvMPN=z=v%+FIu&QD3@Qc_al0sv4;0|XQR000O85nWGJcig4T$EtoZp^z^a+5LX6Iv6Q)95v{rdI0k46+lv&)SX+pMg`u5WjZ +lA>9QZc{3;ZHm5<0-m}?$S?HneOcd~HdQ6_u4$8;pHkKIZ7$V(k<221I4ifirtO4&T{g8cLlSnXlC4x +KyOm~e-PZuFsqCz>lWj2Yi)w1~Ts611WqoUYHg;0qR#kbE?6OwL!B{JQ?WO8w>$cg7O}DLhRx9+hx0f +H@pVJ6WX?7h=Fz^4GRj{7lb%z~nZ{Eyj0{$-l`}{0DeS3ELU++G?iD~FGtE%j#lKkscnRop34$kJr-< +L{{f9N|L{*dhuJdb_Mwz9bFcV_laJ0xaS@vjR!RGsU0-n7p(%!+4=86&(acS(9L>!Pve)$~xK35HV2% +={$P4)`aJ&rIZ(ToPj5qOLuhwQbYJ;^N{xJ^9F#H4p*LF|qWc?DkCyGFI0tI=pydEr_SAR8oONn#Cxc +-b%@t@W}TT^<7!ngSAdI(-ax1&{G&WDu8dM}rLDY?)zL +i-aTLsfYjk;1DNF)63dN!LCaxKzr)`2v@p+O=xax3RRp(V~(h?D=Yx`ykn88@(P@0;dM029SuPcH;71 +0vO6Fs1nX>3uSzi6H-d3o_l2X@y;6;Vp;-tpC{5AcJUWWh- +ld9PRJr)TFSKFz5*=^=Lbs>OvIOVF6wHdocaM2IT$iczCmhjd)&b$%C7RZ)YnNlMC*mOUhzXKKRWZli +rj1Dgt7||BwtL)Nru4J{2!4c5Z6s4Ld92*Oi7E*NvL>j30^R+WW$cY^Oii5pPPV3jb=3UzND`KO6u5q+-j>SkX@i`fW9S`FxLB +z2~RH=OLtujSM{5YniVU%Kb$#G^QT0g7Igd4{t1{Jt)d9T=NL5e<|3mp}XiOEB*6mN3!_C!wq!d}=cA +L**Dstfr=xGYEvbO;aoa)p~n*c|KCA9lV_oNCVKCF0gRymzJK7IwGAH;KxBC-k$yV$_PHnq&8(S*^LJ +TR6SZi@l;kc0lbySdk6^8Op~n(u|Y#gfPROFi?N6sD-3SBYVsIp+ihY2JGO@yyi|6(#dWJ7o=o6}0#W +IZ(pGl0X~u2Ao_>usUAIGhz<*Wr&65)=8^m3$CrDA)M{|r+48a5CD^L<(Zc(=20oCfV?d8G=nHNQnEz +;nQSgM7Q8&KVp8TMP`#_-h2&W||+2EhDUn7pOEoDHuJ1TA-R#@9U<=8mbEObbRQA$vNIxW5X?LjS)~7zh#&K=2YERN@RcA +JTTN`XFB&^UOn9+21hP6t6>CsG5E{ks{waCbXKgc}I$4Fi6t|>t6M|rkCW(Qgk$=brgP(n=2KtF-4

x&eT052`01 +RR)z7fA|CDLSVYVmR1#*F8CkSA~1c1oCXwdJzT$$hiCV63fMbXuCoB}8e6Wk{9U#UsurOG>OTNrC`N~`4?e+Sv4Pm?9@P{OxdDo-VY_B{hF;-z+w98;i2UjW9RM +U1jd0zZ5WJYGK0rQ$$N+@u5IKm?b)5&YL(Z0LWdW4Wor0zhKmd8lZTWYIE!u3oE^{>A<1~>Vhand{H6hs#`6jE3Cg%IFlG<{7K)s@2B8{^S&epSuRL(XiFj+}Ftc7P(-2TXAg-Yx3&;w +~Fn<-F>k7k)J-TGo%VA&&E(;+ZG!R5>Z~ZD}A0pdmMs?+uqe*g77^YdA0TqMBRPX|80GvagchDru)*T +Ij`fCs-HUJSUyX1iw4BrNx$1*T_ExAOXU69BWIU+C1IO34}DQfq~9LW_7&Lce>IpCPs^5ArZrEBN<{o-hyg|r`2BdoV+gpQV2P!)}QbP8c@gv4=0b7$VR@>jbl1#nAUsH5F(nx-12$DnoOBf(hCX+=yyF~L} +HdCKmGd6rnM7_uGlw+BzK(Fo9vW!;T7#5wZ-rc1G@%#ZP;nwwfLNbK|7=|Ncnluzn?A&@gfxZ235fe4LCjZEB +ssNVRf?8?hKDMwjRZ!*C!fJtOFcYMK61k+aZRJexyGmc=kd3C)AIZq9(6&*Su_lq0MaXQ +*uV$EBegh?r9|PSETKY-VOrV9O$eEp492173VEqOlgYInQK5Bj^>?5zIy_^AI@tKu+mdW|*02FOh1HdLF>pWa)g2*QKFr@Mer(|-wOAF`IwxYw$&uMCftVXWsS*kYoC +HnwsUA^`2Nrl~{GahPJv2mUQ7$nthaKV;<$5@r@58onieX=G~%g77o-MDmsUO_^_Kh-z$mFg7lzAFZD +{4dkg9st`{V%UhvaotV!fv%umR>3rZ%ZJHkB<3{SNJ`v{!$WO>FBMhZyJO&m;+JplJtUxAm!7(X_{F0 +GTo20kjKy$sD$=46}*F5`R9>WQ&&^~>5gNZ0&g8sg|gW&mbA^aS9{>enjpy5KqfyHx|Ll&WPb1yh9yO +VOqVGJtr(i&X=a@D#x?~4)n%sYpg&eyV)?CnhqZq8Qq(gq@DKO!w5+_34m2 +?pWVm>@ftdFp8*HP}|AXC&Q9o{yGAM&ewoN;8~S>x}Nd4@gzphDpToqNpGOEl*3_|1{h$~e4OnTH^-S +Xn?pi)BoR)p*EOyj+1Rq_Zbn;*ZB$p;nZ_BuJ|aYc_&H6cg?iM^Av=FBexYu1yX0)Yf19D@5c!iiTvz +l-04e+V3y{+RGb?B(z&_SC){GQ`eYmw&RAq;FpDWpS3j*XK=aVlq;&ZH`djkDlNpe;Zh==Qay<2pgH6 +a3CAm|(afVs^T3q5%z$vjxCFaU5E(;MgL%>N`E$flQ*qan+*{)AdDE7<31j;HscHGA{NF^YpB|=K{b= +QIOLilTN)S>~D%fit-Ze!qf5NwD9q0J4@DjZzA}b1PeUugIqk_0&L#7m{szZNlpa2Z)4-&<(Z3f}N)` +PJwu~(ra-B|EF9)dw3#Ogigw$GzMnu+521Dxi0_=>D5n5&~Xl8dSC&zg0N+!jFxGqI1|h6|~uX&2mg9KQ{2t4&jW`hNC^1IJ=Hj(lKh0M +y+V|DAx$W%Cgjjgf01t27 +*`9Ztl@{!90f#nS)0;%KptQrzI%j8y<-IFY}^uotj&$A*s1N3sXWLF+o{j*(aDk*8?*rrc70`QxnuI} +c*4(z;>cwuu+l*W4kaKt7`H7B?*}$V80{1}5Z|^p!iSuA{|cl>VlxlCZYCts8xl=H#SqPPmxJ=L;Obe +#50xFl@cKKP7zzYN4I38an;K!j2|iVn?sV4~C`*IIK2H-2y*wHFL~S$ih?r@uvaOawW2#JTq?YgYh)eX{nn*!Ezk?c18?E +VQqLO%bp1UCYUXh_87fN%edQkGBgb30$8d^a*=oq$sl<=$e{R%9H)*UIh3E}J-FWcQ9d+gZ_)fYRZmu +m0L(}>d>pH!SPaRUD7uY8OU(J +m!wpwk~v;b19Ny=*5lRk%MNx)At_yX4lP7&6uwQ&3~eAa519dhr^Jv-v>t)!Bc3elxz-Kx`S`Y+pxz6kqv6-fz+PEne +g#cWXWhPx1|zu=$wj@mNI{BY0TL^P4r?4@yiE-wX%qt{;7pulSKAO;~)h=6kLd=)76z#l#UKJmkG>6@ +Q(v7GHhQ|F#U5U@S#j9FKsa|EYB(!?<{?(>8sSKppe@e4S`S>&4M1fEJ7y;d|Zx15ir?1QY-O00;mPT +~Af|Ue*v^BLD#0k^lfD0001RX>c!JX>N37a&BR4FKKRMWq2=eVPk7yXJubzX>Md?axQRr?LBLg+s2XK +_g9RmxCGimRE`D6kBDjAzn;<~;+DE9( +_uW3vslOLLWU)8b`t=yEoT#3FB&u^bUor$Vm$+xnbOeQBM_r&?N6zgWQX>O|eN-Uf0R@S}fuABX4B`z +g&-!^ZcdkGhttrWYag8Nl1dhEFG_pQtU%=UJ7I~QHwR?Ggh+4WUZmz%|ta?{C^lWMzb+FraI%)m{{2Y#d7&}DT#Up-|R%d=NsAe>cNjTtt?l!PwTEPHygQ +{QG;(Q;0M)X|#N1ArBY? +s$Xw`_I>*%x%}1zsBMi8O)n6uVZgJKI@Zehybp#v2gp1FVIkY$=4)U%kQ~y`;itczojohg{`36oyBANt|8BVFb=h6p +Zhxg;!>yIj(#?@+>mG3(?y{}ArEY(@uQscqmi?w#4)=&;)$&>{Ul%RYty8l#+<#vq1gHOtAD=(}{)h9 +kZ!JMyoSYN|Oh!?Ng}9h_tUZ~D35o)B-4AIA9 +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 +qr;)|CcGJlWfNgLysXQus^A-At_Pq?Aluci +WEzrAJeE`$k$y6W)!mNxX9l;prgnMZNhOp?6oDsB)klv;&15xS)Rruuw%K1@2 +L@K|&Zyd|@OfD{l4*#Kp~J^Ps~_b3aSYR}7w@virYt76(t-RLP87I=J%ZCh8qA&tJCnTlXpxhvG7y;m +PKdEAH6&fO5{0aln49jXbiE+A%g8!6^UhC~V}KuX6DNi?IpY=wC$k(6N0_wo7$5B&GF{nCl*sd&#Pd1 +v*y=G6Qk02_S6YvoPx28H%me!#dr_Xv+iQ(D@LxTY) +G9$?~{LKEVYeZ!g3EQL@-oZey#1QPohyfduf)J68%U(w0vA#D)KJmLAK(dQ-$FP!eYe-!EPm0as1>Zs4G#o5SG0esMmoNUn`;pDSQE^pf +MQ=KcyaQ!%g|79rV`_>l&@k6k3pVkHl~w!(GfTx9pfP_5?v7hwVcX$cN55rqb%$-DbP4Z*FR0NPd4Ql2!7RT*jIrQfM-p(MXNJ?i(mF +t24~9&Q@kZe~9v0$VAY-rQqFTLW4QcgurbmkDm!#~4IU%O|d%NCIBqnvbk78UN7hnpRS)Gg=R8e^X%4 +8rZ1@E5tkpknS7*zEdkC&LO-PwQuMOix57cU!sDUB_((Bkvh+h=&wMsL^A^rF-7jqeS{iGD-b6&g&=x +lFrWI4Pvx@2Ic?pT(SMsYVJ_CsV+p +8V0#K%8N!os{QM$qLnHiWVjN7h0@u>U0fQdruA1h@5C`_wog>-pc)>o;~uydG +H&l}*UzS#jR9meudM_Kr$LN8Iw2o@e0LYVlVz(8No+|)CK4y-O#Ej&R*>3YgF0#=#ENmlH4*2GaRXFq +}xIIZy$YZQapL?loc|3~O`o}nTQk0zzpIV+6xg+D6^+9$>86gS~Cj{Bo9Otef5g49TVsFlgH=w4dXv` +=`@*)SS_*B{$sk%W`fxZFKb!yDo9KxfT>hA_v5}yv$E4xiP)+X;FxRm+uLbqRDb6lE! +cgEQOI9-t$+o}b}0_?ukE%YfyvNhX^GU#`>#p3bGRt7RPF3U4!3QD}YId~lfxRUv2s6( +!NN4_)amJAnKy&IOT{v472(->o8XH&#AuP<`&``9or;n65eqG)a$TU?a@X6C{U1*F~kYQ2j<5QM%Nh; +!Qa8vSRBV3vZ8x^y}cmdiL`cGAn8ik@c8A{XNdGsMrCb7T(N}b}0PHriJ0YA7@1Bez*>PeX8LRk#_5G +0?hof&<~A!k(h)R`B#=_qC8mLA&~)4=S_K-=8ypXjRwf~gm5FjSobf}6PZ^TQmd2uc#y3!v5Gp85JBS +HKw>;Pa*`Ilo*d78j)77F&#BCe(3PKlw6O8JqgZLFbOfHz00c8FW~+$>i`TL>$_bm%zI^3Dn__?-~?N +RZl=PS8(8k4j}Ro&rNexEm_k+nmu##0o1g{i@D=GS3=5`3Fua+XL8LUAB0IZ>Cn_M)4+Kz#E|MZpv6+ ++A)utJB>Xy$yc%{|gn+7eXB +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 +a+Y;+ATN?z~R^B-fV%kg#vs=i;9)K`PRHa96 +F$3AM=W#2l^{>11i$ABj01+W57qQbQ)FpwIL}bsnF|s}-^w7s$uXV24!06KrlxN&f@yvz>Bah9mqM85 +clVZip>LXb+P)4)Up>Z_ew%Q@?%E+~>pkEEb;MtRom0suW)U>CaY5X*Fw{&{yJkMRuWp+2iAAhQ~k4w +YvQ*N+zzod50jM5__whT#FYarja+07G|zFbA*g<=&{X5ve3q+m +PTy9|snH15ir?1QY-O00;mPT~AeSHh~p-6aWB_L;wII0001RX>c!JX>N37a&BR4FKlmPVRUJ4ZgVeRU +ukY>bYEXCaCyx;2~mf!U&dZDC3dMMDcJ&vu4vLo9{tR2}_S#s=@Rt14XQ|t%?xM)B!Czb!c@91tc +4pNqrJzO(333R`H{qBoVi)CJvVpe6-GS5@JrT9UbUtOu}%6`q=i)CESQ#G+)^-6mmr+GG0S6j0pUx;$ +G1OURkJjhlf@k&k0k@#6=vWUyP7>Q%0;laCQsq!pNN8+qnrgDq-FV!-PR94CYUWJQ1k*N;#bS@Xt0zG +~C`tZ$R^v}azPeH6h~To!T~BW8AweI%3h+ip}*R&gq`8@sEhvJ +40jRaqj7sD5v*8QOJGi+ah7X&OahU!2q1povVtdjdRhqB3)0 +`zeC-pYb&ZQR>FbT@|w7h79fs0^}zs~fEd0oE}+8$?k +Cbc`aP&{lMEd~kMr^a9ASCv=G$U}0RA#Q=Ca5`no-qJRh@Kx~n)K*;Fy*VC8p-u`s-bM)%)r-Kj2XRs +IcgoY>}WwTuTxGx5eM`HIO9+t=%h|D~%(gev`OV3~^c77BSQ06_pO%R;Tm1Y%3X-*_aEYMtPQO>2fiP +K7o9H2E23AbqXixsS&#Z?M=3i6IZp=(VS0PbW}&f%ZO;qJq~g}kRK?b8Glyik)0v|Wp7oQWK6RH#J4( +STDTrwZ>UCM%(3SpsbtX%b0$N*J9Soiwon@|+cb_E`KBr&`jU_c5ChP?}84%W|pr#^Wnh&Z`M3|9H7t +#$&j{SZQ5JJ>Grz^vU;pOCk{bFRrOH%L`FTUB(lYsuGMBTtYCt#Y76g4Blm66siKvT%4_d7>o#Ld}v9 +}4`f*t8S!M`Nd(^xB%ymhkdJ=37?Pm1X|YBSwzkwvWO>R17~A;h9u3zLN4-R1@uV(XsptB0t{lJ8Ave+Rv{HqG)XZ2p>_WJ +szbHR~aWE5_pXQW0cHLTvD)#6sAshG~=?8>MoQnmmID21_H#weUhDSogTHmR<3xFmHC^Wuu +Niva%E)B<9uBO$8f0%#N(wp&&oy*)iUI6jWpx1aKXWwEO5LY1k{`dQ-LI8Bx|8Nm)m=;wujbY7T5r5X|UvmE~SnA@j9mX +7eHx8Rb}LZ!wNPQ_{ +QFG!6h8bj_t)1U(cc%JRk2d>W^HYyO;6uO&lUurDt$@MLaWUJ_#bNPdFVEyA_4M<| +Ej=XgMxzNx6DoP=L=_1*~3>)mMfidtG4TeLzESxF0GDu65Q_`&m4YOOD0bJ{m9L?-3_&wLi!g&b!8b)06K}#- +%e;8ggEC#~58%!UBuhe`E9^)DUR=Hm4Pwf&X_jOW(Mtc@xmyp%Cv(6QjA()j0w +VmuPCqN`9NGb#{d<;dJ1`JpauJkBnL?7IFg)J=$IkUXB6Q@o>Zx9N*Q=*m${;QLE`LTg#7`Pk)9$*7l +w!HU3VkkLbNm|q$VMwgd3llKxRK!=Gq2aBaEYgO#1|G*c)?w9ah$sx=;ke5JbcC{cK6w!HT2H*9p`Du +Koz?6j!(FMd}R%`H!49wIs#~ml10!ABX0_ZU54s~dX#j&9by%PSXz0Txxec +?bzv_H7+#?MN+Dhd?ntA57_{(e#ym@kd01?(6qY*F;g8WxTnvKaSHB#-KRtT)*4)4z+No>V7XcqK+%lQH1 +5n#DblFHFs&3hRq4~N8byb-ha(Fy?BAz<&iBONq1X|r%<3BrFIrc +^mG`i6sNi7P^nye9L7qY^VT%0W2|1)p-nJh-7@^2gm6HUHT#YF&L;4?8MG8mROBl+fba4*#eePU_>F-OM1 +oO$;gJB^5w)DE5^>ec(f2EYTT_RGhS_fjw4?eWyuvg`v9#&c>CUh#=;l!e2>FJa8*eB!T97T_N=4=6>R1_S`K+UAeg9?srScyUZ3&2_d+ex`FS+9aShooQ;Q~Vy5=m +e$Cujg*3FDO?`oFU=M(?7&vt5XNruz$&eB1qk^BWx?tH@aT#>OkF4>hj1@=T$X2W?#Gf@}6ZYw +&644oS6vriJO5qC&gCtPzhn5RKT4%>d%!od@@wUfZFZDUKFlh}7h7ibmCR-Zr}^WYK`+4Xgu2H)uOKx +r0yZ=J*D~4dG0w&v*A8U!Xz{AkXBvFY0e}H(^=FIW9;E#gAflO)O&|6I=q@SvTlF`$0UW3YiDs(FJS% +8iWQL`-lK*L$`I4*sf*C{TvNPzcMaTg_(0*74Jk?jq+V5zzSUW6>zo9RHMCajPt=1U9}8|J=YdxBaEZ +^;_HTC{(JV{vRaRF4#HHa;a*hX>8Vu_vO#VIyYpYN0(Qr|-6R^R3wxs99yYYi))RTbf054_K +Q?uI=j$EX7o3h8TE4EfMZ`AQmm|`JJ6Uz8Oy3W$!z7ysu-lfvhbw?k1=S=7E?e?@o_C*}gA?ScO_5A# +d_)bfRi01~)1eGSh%7d>z_|tChXd95Yxu_?um&YZ3{aSH+Z4R>(b&O8?c?3=pY0sO`zHSl +03f=eLQY3(4FpJ4{FMW8Jyb5($KvUqRbwOgR-^6LO(N64{4RlM*MCBuo*1wh7_su>{FiAZ{(k*OU`sW +o@6ra*DTx6n+ckMfj@gZ2VsFI7&KO(A74}RfE6=hTshFu0^VhR^ZYtT^{D_q~%R!PdoW;h}OXL}dv-M@>c`sN9MOZMu2 +r&(v(>;u{`{KUd#hU4Tk!Kzy!uBDO;vz&Naxvp^CA8TUYao&`n3mJ1tzbFrK#Q5&u9^J!O>W_#i6$2E +!G>;l!5yfvx@5#M>Da?t3H^RV{kGUi`T%4Ng;1BfT4_=zOXqRL6k}zB^<*8l&6)ZPGcX)vd=78;N!XZ +umcWB+FsZ9PoF;8ZNeIkT2!Vm8H;fHb@|=?xq>GUJ+$5oHz?vsuASy;Q$-}LaO$XYo>IZ#L)S-xSbqY +Jx9(y#&4lSzueS(&?WgAcx&_tfCe>AOuNv-E!J8%SVPnLOuI*YS^^Z_^R701=h6aSc+N#r^>Hzct?6d +ry195rj_*h^$`1>TQpJZ)_dZ@8HnNY)lD%-a5LOb~EWiXB|Yk%jIVcCJSoi3slJGy^JE_O&sCAn +;s-{S69;B`1s!795g4&3dqlq$(EHRvQIwb9?OqAv^YG&apjxhXnX5K +&v&N#Stt`Nbg<4+rci_vOI)A0@5lPv@-vd;XaG^` +86zY?BIqA4Rd@%`T4}h?_^XfybZoQv2VVv3Gk|Y0dal4D8Zn=-GptUDRiQ*1q=n&F;lk^E;k;(c_39s +YxYT`ywt@M3Obm=KvS>%u|9x}X5YknX*82&MCl}0=T@_!yXu%j94`Qz!8uRnDI-Oc-Z8bwBjgE_o-kAn4J@ukYv6tnJWL#J% +!1${DTv~+JR8n}mkr(z~Vn}>E`yNN~;94xx9)gS1&f<)SkG=7@qi6l??k_Y@TzmVb#2dahwtW>gtD-5 +Wf))UI#cWpWN6#m-e_je|kz_iG~qJ$cfmO|y=j=7e>X(j!*wu0E7d@;*Cw>t&lj&7PpfG3iGSmeNyQ` +%+AJPZ?)0-RX1(aUWCDOqiG887_p5|6%X1MPO6Q->MH>d|yV&cT>0;uQu03etGRH9IV}Q+Ww9Cd%^EL +b~}+9LwFH@WXn*w!z^)mEN|0$!r2aBM4niH=0>JiDR$TVWT6Kxys5uDX={6fyckvBmrnM9suP_90YE5 +*y@6aWAK2mldXPgRy}+yy@g005pC001Qb003}la4%nJZggdGZeeUMY;R*>bZKvHb1z?HX> +)XSbZKmJE^v9(SZj~lx)J^EUqNV5tek3P1O;vj7jAKpN6w3eB@>YIvf1=Hf7?nK2n2Gv2ZPD#wmmRVZZ+g^(tY7VFFw1##qOM9g{vWGXDUwC5 +#?ee;2o$M|R+bP<{D%KmpDhYF}Y{M4@o0O_M;eiYgw(qP`jiDXoZg1J1-w9arNt6~w!Zh +X9i1tou)sincT$G04f2CT%wkPjW)E?JDquI*?EU94(ER7TJ4s+K+u)VdNS+7<*Y4`m$N32%espBhnwv +xv5!mR%A`=6e>z>{jF?J38;{rk5r*D;VfAUfVE9)Q^3W-5iy}>mA +#%l@m!Fem?vJS;7t-ZI+?S%WEPd@(ywY0fjQwnJI@{g~_rCO6J8sNk;WYy`I~cr+ugb(Hb25ustHXF= +d3iv%{p<^X27WPa*vmK{#vZKl!+C^b&~W|Yudn|8s`%The_j8|74a2&jEa+;{Jj&JP`X$U5`<=(2# +Fk$Z`@c~6fHl9qF62#i%Qg!@Owv7hbtO&f{qk2H-?ngYqmxHLb0O;KfYHa7Q=f3`CACQMJD)pt(5)Vy +fmue$kfMlcUsi){(GyR1tmKKKolMzMJ*d)&h;(X)t?+9NJ&P1-TEXVDy83lfS)vSe2mG+yZ+dx(r4(T +rxA9>=c+r5A)Z|CVAN=V1E7B-h&tbH$-6HJg+5u2$MDrVS&zYT12fe(i7B=0{7XW5Zj!63R$bA-U6u7 +Nxedl(YHDISs945rh{YcZ>9Fg-Yl9hi$F-S@r^`VkP#Rn=kybAS{dGh(*Mfp}>V(;&7*t9aZ%11;eFd +(SZFQ#J@vp0ET5zM2$6v=gWO?)%MdQJLipAd8SV?ct-2Io(uN&-TPN->H#c8gfNK;>&OFLfN>Sq$Vyy^x<=t< +s`kdjLhl4Cse?8wbt)VkQkcTlp_Qt7O$%$P-||1A@GVUQALoEG3OyOyS$0U=v*MV +h8R5Of(2dBzE2MK52#-D+krKd1Q^o}|A29QnySBfA){t%v}B7`i{w)j+k)i5)q5c$h|8 +Yao+36LIF0C<6vA9C*cj*T_=Zh8pL8qseuRHh}Gn_x=19O(+Ykw9x>$YrwBJhjCvTPAo-_JY +G~UyLKaJF-fLowr9L%->RfGn3c&u?d1e;6||Dw}V9^L%|9EZ4qy3yqrZZ7CrCe_gHXQ~f<--k<&j6hSGPc%KsFs +@B4Es;$DU+~0`1-XcsIeu7R+?!FNWHQEP4l|5aqUA2TcxKCHY#QeA7-VV25e#d3Qx47&2T|*BTFVoP3 +GjjOLmENs>w+ab_-%8x)dwXauc;hZTR$NW1v_H4Cvvhhiv@1PP3qa2u*op64Lxn@u5qY=llq29wck~AjD`g4GO#GpcgPeYUqpKs*R<wJf;~5gV_l7i`PYBRf1X +xJN}8x#+yg`=^_wo|_3{UnV0vOjK$c$b5TsyBMoD8z6DF@FcP$Pcb7cHrf^YgQBaAC>+byI +T`9{oLRjaJwZ{-&SwrR&#w?y-_=}a(YNTeZF)l^a97M8j=a +A$ItxmiCCbF1qUn$N?qYqCCfI+=TxOjGT9u^aImvgr)WLB;%gVM@jq;cig+Z{0IhK6n2IRsQxo(d4WZ +6^WWOvK~}A)$VKL`6sEc&B!c2wmlNmCf*@`-C8pC@ukbfe*sWS0|XQR000O85nWGJjKt&=1_}TGyB+` +lB>(^baA|NaUukZ1WpZv|Y%gqYV_|e@Z*FrhUvqhLV{dL|X=g5Qd9_(xbKAHTeb=wRFb|ftG}CNn`k) +zi#+y1_ciq?%Crvw<3NMr +EYjpm?v)K80<#nqR@#pARY4U+n+D~agqLV@$cK1S^P2CwviBhkag4YLX;1kc-@vI)JWSh7j@ddcX}mD +uKiZonwNJXt(9tGb|;#2!+%wEx{)RReh{@b3Q3(R{g|$5z7bnh-%loFUQx5N&dv#BugtS)nwD6WrnAX +p@`}AzjnGV$4Ch|qI6tseTV}?P30{9HS2#us%ZXyg77IE;E>^rPn$#L)I$JDQF7xuFVd7EhhAjnT1p8 +C+=8rMciZyFdixbUC1;8!eu|_ej@9`W5)2xv9f<@akZ=eS)W+!P?i!C%1ML<#%27F +qz$pO!VXMK1Lgnm2^EmCYI_0K!_dHO?k8&9-Y<2*$HawPk}7Fd#CXpRQE~ylx9RF3hiBW0AAvj=jCvH +EUHu52t@mPjXg)bC!*vQ^GD+qzBL}?B08pD`DYRZ2_zLw>@Iaw&J8H*a{S7OP;}4WIWDpu5T~@<;;>y +Ch7S<&o8gef4aIzEh%r|axI#vMHaksi(m~A_5?Ph#Hn +~P*Duxl!7P(Yp_(WRa@j~tHqFr&XLm@JN*k=DpkxU41c01db<|TicEiAL4BBYu^5ULa#{0w2X=XNN!G +dnjMGgmmu+Lc(}5t)H@wW*l`IAOhz&Jcb8Xq9E0IZFI5-1FEP)ixor4#moZCHq0KFi9|2XppV#`(*dE +yp)28BR!Y10VN2yt(?PF`#Tl7Ug(o!a1ezdQ07^%o0djSh#Mo?0><0XCpvpVgojVr~wN$9oupi6 +UQ?!-*|#Rf%!HZ`g4jyjdX#{mZI4TQ9i* +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 +*JFRf`eRfr9_r-d|Ly&fiw +-P!C6qhcV>=}WO#h$a|g0_R!Xc>GZaB)U)WMAPJm;TJoD +c6@__js&s4*YM{&C=?f;W7c~AUe-PARP*5L=fo+u?%1b?ui;r4kn_8|aKH;t<7HV-?U3Z;&H^t+>HU^ +u!TjjSgWA3W@_=LxlNDd9&5-$ZbFx*N$9{5n#+flH+?^Z2vpJ$*BVL$j5Tpe|^v~Tf3 +|rOn3HHTpY(@TVTl4Pi#Gcyq=Jl+kFF$wJPF$!aNm-inuw{A-6{7MBl*dtCQbC(jH|oQ+iY)EJ4Q%W7mdIit+)A{&H!pojz=8@8s%VZg@DM%3pn +t4qjRQs&lkxgurx*0BH1c%%M6aT$9sFL#J$X7pK;hnzK=L%rN>ST6PvdqWpGx6!iCr%4f>d{Gmoj2>SMdxABNU62H!_x!yqexv?diR`DZ}A|9EU +bwPC)|`ziS!fo|g-2HGwd*G#c;r~DhKN><=)l|ii}eG~ue@L;R&Fa74*xjtzX54m3wnM03z5~R3NbVk>F8mV}!L|~oW) +j^pTXaMpGuW^orE1kRr-yzk!C*R>!uQ|(5cf0Kka6jsx|`f0YxQ+kr*!<)dz9RN=@#v9qx3uQ!VZHST +%%1d=F8kzhS@v&DEJppO9KQH0000801;hJRY7eZrAF=T}(lLqP&oeOpD^BSp=wdfBv9H+x>9C~{y3ZoqbJlPx+r|NV>&YzQP +rwUi4prpUM(Ww^?Vg#U-X*E1Ze?Bxq2N{?_S*^!&8VTC=d7WktV{}^87R +UkDU=}}-BUy|NJR$QqI<09p??_etw3wKhko<2eQYgEBN^ZKsyS~WvS6u+$P?4}{lb~xp0|8h%@_04eE +az6;c4+q?#bFCxNgW-T0umXb!nI^A%4-|6oJ3&qKN+nr4huB$RjN^gi&W;cTR-Yj28{36-!aRQuRsvy +`&}=sv66mYiZ+wEWU10Ra7<8gFvT>NpsPOlP>-sxB+hBRU@ZSe1Yaws7y~3A4LVR#NF9H~4|+zLV<8-Y1p<*Hb4ylvHb$GlzMW&L8lrW(st?z_Pij{NA9$)4aavktd) +yEhpEk#7{^~mz%Nb$g*~?qF1$--1@fDq69P1ZamM+ASXYy;9D#^2r%L@n-OhPNaDZj@62H+Fty^usgq +K?f(pV!fh=hXfgdBJzxBfouG0Ih5nGEI;Qv|ALkDR&w?^E^QgG9v`@WA=b_C=l?Tv}p*-Q|;K!MWF&) +>er*gqsSY*zxw5C*Fg3p>Hxo`bPxYs#5nx^E6aF>9H`IH8A +GGZWn=?7mj_exDZ$yA&pK^VMpZBbw7=d-izHPX_CqBY+q(^+WW5%DF+htU9Sz*@=c?PhkFRRD+jvzG; +`l_+>IBA^>{MzL49bVxz>yw|Pv%P2vzf+LL=G?+A9QcD$Lj9l9pK`(l_F(K_jK3$;kP@gi=s$mFNRGt +)Be&Y^Q@`44OQ@82 +{q+0@wsE_<;wG;XB9#zaxvpoANsj7Evp+cPhAb}gefpab~a9H5o}H&}cOJjRulUk(aetRv(TM{;D=INy +Ck*D!EqX;cA;L>pV{@^Wf(y&&>BUU$2vFZGINAzDkpY`B_>Ze@lv0lB%OsnQuhBFQAXmuSQ1#{?1-c= +=0*g&rhSLe>{Eq=d)Ko@S~G#&tIPAX{wfWl4s_3R?8$)CI5VuENlLDR;yAjQsw-rbKUAiQt4K&ph(o@F0 +on#6C-i;1vb->QSKwsn$PFt74*191MPVw~%tZXaN9n560WLapU;|06$~2>r#Kf06-JfmosXxKuhsdGvp1(tFQRvEUPLcXFH +WAFT%1I&PF|iGHo;!+%CzrxJP0^-{x +gzr(E^C;XSj8Iva_nT^s?@50gB`aUnXS5nU`r*9H>wKA~N3i6ITbW1VSmcYJVfl`Zo`G1G$zqGN*6a# +zNpj!!bMxiV(OI_2&jDN85@1Y>5)03_rNXz+5Y?P2p_$fq;ab%%=-DWWGLWq(0_||LOl4JxKgdd*W_7 +tg&w*GYgY1}b|Ieb#3su&8`UMOku>Yu1>1r&d{|?Mlazp$pWl|{+sQPRJ+6eWCiitZ%FkC-0P#oK@2y +R{G+u}>W9bxZinP;F{YT%lxmY}`k2+aWVF$=3gO3hf^GX29aykyx-V10UC`IrPj@RUapQlzxh!VWj3; +llbO+a`EX=K|G7nF&x5uireQ=OIu3;z}6^D-;?O?YvYKwW+|IrJx@`tN}(1O%Xl8N+>V)6S2F3!SD?M +)1%x5kXC!5%=3C8RJaZ;6jXszqZXUNG{Un&mU3fgNURJ`zyRedjbWD#)HrmzGnu=+K?hC!IeM78SZjE +ts<&lU&4`kE?Nw}sq&Cm#GE2o5Pf|yhdXn=5x8Ih;7F6xd5 +Yrz~*zr8f!kNl!x~a^hc)#Ry+b#`ayKe7%;(3~mPSnx=%) +vBv1hjNdS8pxBPAg2mN*ga9Vu5w#vST2%W^6=~8@k>bP4o1j@PuZB_GgBg<=5@^4o;ySAdEo~hY +J)mM3Jl^~g4D+Hru3LI*G5`0ogK^wS3TUfRixr}L1W2XtTjT9U0Fm*)SkyB?#5?0{vzK&Xh0BhkuQ|7 +_Y#pDhKVUQeVTvF($=WFzQM;0^^$^Nj7O}m*`>}%z;KqzPkiJHx0ut#X$qt>f?lDlT@M3|r)OJV#(!o +#8b1?nOA4>VAW^iB+&#QEvD`0lsAhk1y#$}qw}d6pumu0Z4FyMV^k{t1i-Hee|;3wWUzCYT37>Wk4s) +suq)i}PKU!UPZ|D$H$?(s#sME^E|71b(mTE}!&J`{JeFZ1cKjCLE5tgg&Exv28i5bK1u7@7>1Xo}QdQkBbCpzfRu1$MQxXu7 +Xm&(M8Kk-2Dktr~}!g7$)8@O4@h+>j1^V +pDU~=XT3~Ma~;fd)0Hq;Q9po661mTBP_!`Qq#a|8LF5i(U24LPrDk5<7ad>@u_M~wPe@NXRue-vPK;CzRV9510LpI<|h60`8OOH8!!tk=ooj`Kr0n{_Vrw-$sAgah36fR&pbP+PO#N1Drq~KGK4 +uF`mRvU7jzM)YKqWVuMdMuUFELl>}%Swi)NlHr_N7o5)9mo)v*21f``j_aMF7h;43Up9GlK?OYRsh{ +#R9vNY5v_kr?&d<(JEa<>pVZ{45n+Y)@Z9NrsqX8rj*62S6JU|i!FS=M3r9nnex&>jRG$TUtR>IO#0) +#)&0?=%hIPJ4(Wq4*A4OQ~nM;?rs0{&-9nf>_;{f(%b!3Bdw1{EM)lWo|mZ23j^g>`}#en6Pc?E7Zt| +`VQ+geQoau_lZtlWQCSWe#QSdc6?Ph79NdD`-v-B+PW)I??$qp{!I(IrlXW#oW>e}_Ev2jZgc_*tDq!`y_p#Tzf#HEQ~1`Y0^*TG9;VN5Wb)*5+Qa@?kv*Rx9? +v%YIp_b@N2qe_AKjZuEdoZ5sN<)ype_-}Mo*F`mZ{CEwjW4pk_-(%op`M5}m$4OOfRrUDEx4-($ug61 +6=2?%nZ9py`lHn$0a#!JX<>g@|0t+dyBxwt61zu+wYfl#JF6wd#TGC5DK%m-0Cq~#UoNcwGp7S}5Z>N +kgG&>N)emcDpgMX6d#k3J)oBFi?S#NZ}83n_J1w=Jgc3KnCuSRPV07sW2Fw6S@h`2xT6`0aX0~lHMA( +dk?>0$&52Lu0PxlLs`@iP}XT@a7InkvWe?M@u&qB+NPXzcqJ+I37CNt01)!dfFEdcGOLyw=Gh&Cv^F6buV+m&$-klWXLKPu8h>{KjBK+NHZVj=@;tH8{6rgDeZb4^k9W}g*M2~RQzLL;6c2cLWJ5u*$t +HFk{D|7T5RvcCew;0V@p>@)kcoxQ~elb-aO?qIukr_A*v8SLxe<@D5(R5W-ZFOvHbEPb~q;wsRrco4b +rVdum8XDqEk2svhK$az4F(G!4Z9mD)XWGc)5i!OiomZp$V5LHFg5y<6kqnoHiW=*r1G@b|w2KVF{fiUaras#ObH$s*%`Mi{W77K9EVYN9ux02v|k1z}V+b6#paC +iUzInomKAH|Z^EsXqaeZLgvemnfE1{>HtwGa0iz_Bf6A7CKG>FvFnu$vOr$f(o*?&h+2##`$pC>q?^gD&|hs2kU6&R--g=Gw$)OdRmgYqWpV5rLcy;lM%gPWCRyn**L1f_>P7 +OtehkiNBp>d0Ic^s-)78oy+TM?kU=bTBTLMXvPL+ikw&mH?8pP~4&)Iu^D~A2*R@^ldju8!>Fw)RgDr ++@#7v7Zx&W=T8y5|QJ6VFWzxHt=+7k@SC6My{hQb^8n8Ckb(rJFUs?GhQ)$$clw^8fScyM8Eu)XDgYU +r$^?La)#Wvbxp)!U1c7cWlV1l#DZMORWifu9d* +O|TcdIsLD9r*AJ#pABn9oAEsi7awwFcW_T)a0p6^AMoYQRtG#do%C34%Mx|ihoq!kbCtojJVQI^rV-M +e+*jhF+>-X)sfQ3Auw#LHmfRP*4!AihFs?Fvl}oPfOx9GXj<_$r(9kMZgh|GgT}B8E^ynGegj<$BE5^+sr=}1u#l9T +dBzEv3QF}6t88o{*urap>sVAD96_o2aic_tZvY3Z>6h^%@p@EXNp+hG!Kl3Vi>@#45dTmihb@`H0f!jwxMzH765kqw2UP5XTLm%bO;JEN5Bl!c;qQbl#hD0QzM5 +2~+SukGY%&Tr47QH4d(a&E2^pcNNnCNMDn@8_O3m6@*xJ2o5w`Js_^pg%o4$;6NoO@Oea3C=YhDbQ3i +JNfoZM60) +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 +JwLARxuy*d~(2K^Oc_-DrY{WCKk+xBK+b=wI0? +fOa??Hm()!~A=M6|rw)~d&WnK2=PfDR&|IzB9!>!zGngdI$<$Sj*8qq#F(C)qH%Ko9iV?`sY649RqvK +P8?0BWJTraaR56>FWy=>0T=15%mDrZ^bx6fbM@T+ +pFVy3Ap36C!u7EhF})sqyIE&F&}Q)t$dGM(VG$e#q#0;9fK=&n_1%gY?R)7g+2xgizP{AP1Lx +ukXP%x125@AW9e?ka%IjMtZOMk$~9wLCi4{zx+MFk8tJO%uUy&iUG`CuO$DJ_QvLICYPi2i|=r4nG(O +m687jV4d2D+PGqIO1f<9{g<=h74~&!4P5f^H@P&*6cI?f>QlVuY`G#KwZvD7~>b$vvPJh2<_``qQ)el +d;~ +zK?73Xw&MuQW*Sxc8HXie45KRpM6ElGevrKOO4F^{ym|~{Gkmz)ov-JToYQTso3o))dZWodOAD+%3g^ +E6NUxRZ;5iS*IOieb0pK$P&gBR?t +udzQi8)E|--0k`!}8Og?n1-^4@yykm2gvvOsK^*OYYZGi<$rbM734z;&MSeBvxpR9m$Av*eQw1AP83; +SxA~!?qNBO1_%caEMIb;q_8R~33(h!i`$< +*yng%o!|TO*N?1VsWi02Hb(|(JR|8);-d4$HuZwX>mL=q`yl9r``9#O@OW5}9+NGRo0wX=HZS6YBDyL +O2DM+X`AXqunOSb>ZmRMmtZ_};#Lw7T_T%hPfb)P-k+_s#YIj?pvw-78B-!E3|hvlcsAMVyCn+8INho +%VehlL15Z>Tz+w>eUVc{rQj4e`+6?@QI2__AGmcFcbHela~3?9i5JR(AQDvi_IouHkW}OfwZ$-1KEe_ +|7V=5Ka2w(^4=k%}!#N)NsI#slA{qW+n8lh6H9?GpNrZ9)GWAjad3N|4M+*TI`QR+Wb$bvm$QcWOPWoCs``cHtNSbh}QTO?I8h+g4O +q3{G0CWRQ?~4WE`FxZ&^65weRgUe?j(NGE8H5fG)tJ~Ud)Z@TnnY0Vd1&~JC9U#}sfG7JW{zJ$bfJOb +Cb#-2QrEl?;6R`v!O2XXbVhimNZ%Jv9up*RUV2kBC~7XjOF@LXu#mDHV?*5N2aRM3GBJ&tP#%ZBro)e +<|m9%lm>EKAsk?_wX-iKqHk6iF6|xNuD5X+*YR>$PKs+QwOkQS&s_ke|+xu?NkhQ@n`{OonstR;gITXcI4;&_G*aEfKp-dqAimjm~>mP1>U)n#d%w1uUMXa@9jED+P-j)23 +YJ#N4{ncqfD|1>Wdcq3hLoGKO_jupom!f8i3`;3%@K1_qf6+;k$>oCUh%o*VOvdfk^VB70#Bs_#-dXk +6^1Y}{(pK=<6s&Hk7omQ6-kR{$h^nzme;%cU#GS(IiRef&HO$WcUu&?Ofut;2A(Z7)ehH6plyCz67xg +^PN&HsTNoNc=2H7Qk3wYo-gpgCI{^cBZ~OSAjLLYMamrympu2V?PlVrRd=` +ie?zq%kiX>v*C0I+N2Uhu;6~ua`IPu73%KCJ7@NbC`<72ZjXNBxOweHwAmXULhMWmlu%ZsLU`8xxdcH +lGCX%P8pwv2l`g$;F!yV{7|YEPGyUCGMIJV7u*YoCF(V!aIWKqP^7Z1_X +@BtUX<3$&!#!aSJ>VtIc*pC8jU0ql9&0HnEQqAOB9urxA&DS#PT5<)gz0 +b9{www?DQsG +r_q)37LdxHude(HP$6~kF!Nbm`I}Bm7>ifNMz`Hv3uyDUG5;+k)`l_m*Z5bWk)%+TtjO2k&c+scp+sKJw23%X +JxNT$zABa|Hk{3zRPBdR{FLtGAUHk-|syQi;gP$S*2UZ~=0PGLuS6GV}Ae(jW>_^UC1zu6bpdMfrKTsd*(_T=DUVIXUt13bqQ-O2`_ObQF}36e`7X +0RT`-0|XQR000O85nWGJfsWVpSpxt7S_c3CD*ylhaA|NaUukZ1WpZv|Y%gtPbYWy+bYU-PZE$aLbZlv +2FJEJCZE#_9E^v8`RZWlEHW0o0R}6Gnd7%m|dRrhtH~mUcB;7;P9*V*qOXD@W6e*Cjy-JY(-ZzwNYnu +%kUo4U0n>TOX3{BVjkjUgeYc_Q!iCa#**aqKG8hYdIr)|1*Lq)&!$#}=MqPyUeZ#hU@G%|FtlNR4+}AG&&E`}@vBl1GG$w2_AQQJ#^Fu#9~VnDtuGbW=&J*Tk;PNbB` +`({GKHX`|8|Itn?FmKbrn4q|OUpFluuAha_Mfy;Le<)GFhi1VY!M;{(=+FFXnHS!5Ofp_vA=*JA__kk +?XB%n5F-!JD0o{*t7I~+r*NP35ClQ~F5@B?{g2Nfr=aexN1`#8$j2Z`cFTBuT%A=d(+*ZGSn%j^17i8 +1zfC`T_L4QFFG?&Nc>U;|~|`t(cJTj>x`+U)Xj`8l+n13tUp6(?^LUkJNUlzT~No~>V5->~*Y+5T_q< +Z!31{p%F=@3RwsGN^sp$!I+YuFvfZ;3{66-;BUVUAA;0iqA)z)8)q>L)j* +F@)5bbB1GhXdZgETvJw*$%BHn)R +%5MMVIKCChzg2O$nDwG{feDJ2F9UpW^;yuVQ7z9zXckG7Anl-(K8@783*8-qnH}bQlGfp+hc+qzN=iy +?^*#JV}HHWgTsL1*iRUUtHW2kVe?Ak9HsZVWcYH?Sv>7bKCrR8v7#+_H> +4fP_ig>n*M#1;$T!sVCn^yngC!1NuL{Z|H^~mUlgCDXGxWn{B0M;M%vwE_NO@qe>m^j?D@qes*19~-f +o(o*Fq~py45(7Ks(g+7xB2Fmm%^Mbofn012exK*37|d0Kv#-&RV?Sl%8~yCP)h>@6aWAK2mldXPgNqs +MaHxV008wL001fg003}la4%nJZggdGZeeUMZDn*}WMOn+FKKOXZ*p{OX<{#5WNCABb1ras#aV4{+%^* +a?q5O3A0pw_N^>v3bpapFt&>AhBr$sK6*$9?X^HZ(kwiu0#$Fr#@0}Tn5-Dld32?yWL%gEM;k?f?BU! +hqGfdQ6R%tD?=6B*q+C}@PlDF`}@PZre-YD&UwcKoAhkJaKZ7C~pRCcOnX4lH*t|!CdBL@F|R8=K%BU +Q7a=X04G`|BqoI(}OT@5!jnKE3BHlClpUTRhGy`}A+|c`KT{KbCV1 +0{$m;LZP%3Q0{p^0S+>9?3w)41(^~4>G0`}sX6RY_&kUM$2Q@E6CLT=3_a8E%ZnHvm?#v}TpM%+RaJ1 +e2WA`XQV5#ih>beuWu)i~>(v1Ay5=*mO)gXsEi&`YbusdOZ5pArW93ABq*V?MeS8F^E!PI}BtVzXD6r +DBf=H`XnH#fvEBi=Y8zSAS3a8{X(+TLxJi6GAtLOe$=)Udw~dD?VyV{I;NWK|SU+>oPdW|U%4#UFPOD +^-W8ex+F>M4?%HFED;y8TLttmYI!U|CQ}KR3*~e@TRB)Q>|#|D82{EU^-UGQW#mo%aWE0k58sPWkt3_?sw1J~51{@-PkhFxh8a5klQfD8_K_N<(fqO}lWj5U +KpB7cQ8lF&@dhJr)Ri9wfi)|+^l$H2Eu +m%b=VR-ThabWE(}`RsA7;6^^o-rGRm7*dSv{uT)V1~_9h=+Vsxw-7<613WgM1CqG%R8(K^%)7;?oj;N +A=2__18kEy=JKRflRA`Ne;6Lpgp?uk%Ye<~m6N3h1}E5tsp?Q~X&0w{f^jmdsK!y +fgY<0`)R_a{NEPj>hdt=rX|aQ$VT{6|%eDo25wja$C{1IkWD~%27hjNjt;V=VkvR9WN=$ZCDK!8L#bx +*>(*&M@;gpLYm1KK@zev9E~Y%n3d7h9P$MR9+rdWdi0B9_OXHB=T)Wdi7Z?NCBwFj%9Fo)Uf$$}H7!E}kVCfRcG*t>i3k_LkE0N@pHFf>VfD)+G2?OR(^5<;1 +U65e(SVOchL^@4_v*}p_X_=+KpNAm!pWOzA;I1F+%UTh)ReJAk%yu>x;SRHft&=X8-7Q}JTD8!#+Q=C +TbGN|`=mAVC2+hsLx08bXDm)%w*DRnT8L^9VK)zs6GgV!v2|Mv3i{Os~9THc+KI2oxqp6NgFboC?jho +;-+#(G+dZ5x#~La>0k@1gGHP&gndEtR&f_s@_)=V*J~bZPsFa>I+>X%QR6CjDIZy(J54-F_FE6&%D@e +ILa208|q!C4ftVt)5b5NHYy^u7i|4m+3rq`x@q8?+?7_k?%qcvn9lD@#Bzek6&%iA*OdsYtP;rWAR6?Nl3oDSvcK}QJHNSl_8H_WR +U`9Ss!h_&~FIn{Qajq3_2*1VjeHZyzV7{-ysjQ^S4ris@}x$_Ge7N>hEYZKs3&Q(p}`TjanVZLr^8^n;8H-YJcV{1xZ*VrUjz?`S4>7+Kci +rT|ji)9vlg)zGnaE=C5sP~d6X{*bz^kxzsuOTu<&l#(v4f-j$nKS<49bG|_;|^9fX-M9yNS3 +*&L2d=RnnlH0qKCk2b9R0ohO48Uk436F|J9vCKpRlwF+2SjFb@pgInesSry|PAdJx80hmz|jCy9GBz5 +zR3F(~_K!>QMc5LjdI_>`#TnIEgQtJWZ5LtVj$XARzw4AUG4l1VMXDLm*QsC!>jDYIY7jG+Z6@GyT+; +R?5!HdSd%mQHm9ZYjAO(}(*e9%Y_1eed3SBnN5iv#76-{3=9`riKanSF-^=VAxwwqbus-+cF{)dK%Gd +#C_sXm&y0ImCPSg6m-dZRxq;!LAjlEm4rajLKDomfC_3bY|NC%*Qzw`o1k(jk>4)sFqrL)81p)V{mW| +kQ?1i(-fQC3!2koSD9B^Dt3@;5hw!*OuH@LRf-pJlCs}I?%-NwyR*sUoe1N)9nw<{0V`o21x)msLq1m +?y)ASx72CF8Qo(Bqa3I^MFSf^XqNglwNyV>o`}g?!zkdI>KQ9ylZQ@0ft$Y`7W|_<&GrU+9fL7?c(~{ +SQ8MMDO>@CL+S26vcP|~2EL(&+K1?n0!6h{~KYJKt+H$vULy7ni-lY}o?(G;S|WuN9(mOgasv)9hE;#mN@6aWAK2mldXPgOc027)39001E!001cf003}la4%nJZggdGZeeUMZDn*}WMOn ++FKKOXZ*p{OX<{#5Wo~wJE^v9hS?g}xHWvOrPr;p{h^CnE0le^{Thze@$R%mKt~H`or0h +(KefRy&p)SF*IoG!FqG+qkTU)w~2`|Ebr8&s6_9|Ci_1~2Ccr?|q|7eFRwelxi=s +&v4@XfELE=;MTkKt)kH1;g~r3PL{QM~oKQQkIt@yMGOpgfBj|H6Q~-ZEBf5= +qk63tW|ceh(p$jXAW$+@9au +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 +DvvOtc{zzy_*Kfv;=%*(!JZFI% +|;11dE>*4Y{-t^nIbz{ZW+!d7@>w!ble +&23(Zxz&p=MrtYQv@EGMqPESzl-mNB>2HegEBe|v(7DLpzz*HdG0RXPDtn;d56r!DEmIc3nmmI)fW~>lCHFZn8C7$dGwj9wKj2r{606LfJ?Rh$bs1a*4HHi(>dNXahI$BhBRHft9M*9b;WAD3 +k!}FC}Axo67EcV#Q`63qWz?jVr?2;S6AT5t1GWqU=L>`r_$`<1YVPi^FPME#_qgvHQ+wLU|E<%u|?8_ ++_(;NA733!b>uoW=ftblgQB*z5f;SHaFF?$Rm|pes+9#owQi5FWr%%yUI}`GzU$wDy||+SU7haCeTH> +mJK4P+c1fo)nQy|L$3&Hn*VO9KQH0000801;hJRbuFkV`u{a0N4ot +044wc0B~t=FJEbHbY*gGVQepLZ)9a`b1!CZa&2LBUt@1>baHQOE^v9RRZDN&HW0q=ub8qIEuvMCs{j` +Tf*S3mIpolTVGy)5>t#)m3Q2k682;}aQZG{8I6x2`7R%wxH{U#Yw59|9)JuI2vg?iYaBa<3)Su9o@Ui +#OXrW4=<8F5h%DwC>{)oCYw(3RmAnwVw8oX3)MredKS~fz-ugJCNFg2Chqb1A=zcd)}7rPIp>x6FqwA +R?&Zr3Q`99$dQ3ID-pZ;h&VKp$i5FH}8RI2sFN5;=qeX*!6$&L`QNK)^^511GpcklJ~n6t)$C>>?WHP +8shwhby>Y+VDH6g?(ZrFr(Gee7qgCTRf75)Y5ZaL`nD@s$;pF7L0ny;0-14#(8^tOJ4pl8dvSa$#?bl +aQHnQ>&09iSAQVg<~E~4P!4^uPi+(Lm#tHU**=TAO7WNfxk?U_oYJJ?XG&?zBp81}TZ6g#4;vqYzB6< +6m!Lfnj`h?H7SW;{y>T8}hx2_NibX$IO)>hvyIx_3)Qasc1)a?2hWO=bWU`7b0$vN{aK)LV)Mmv!df~ +mDqI%fF)fLRLi7^R77e7#IZrtzFWzBqkv+c@&o3oBzwB8xPD7FL&9g)Q!f_qJ#H9T!+vk70Zy;`O$c$cAm)fO8SD8Y`vx(q!3t5 +olvt-U((+USM07vp|HtVhHp&NTUVlOiwQfwZ&3wLH+A@}q;B!cq6qKc{cWcGEBs3dHG`*Rsl%dyGs0P +D58gm4T_bD@_=xt&pTd?E4k8vbhJ>`ceFjIxVs*fwh~tP}h&q-lw(KGfBM_SLqJEh6a7V*4W4{J`BVp +ld=mC*>zB^{R>c-buJOS9Qy0eFdS##|#r^=;JkwR;nDV!XjjhT~^Y+`|1Rw`rjsVd(x5WVv&M&1iZDY-|=-g~K{Rd1`6<-$1(2No&}{UnM1|4JeQ7LX$1B$LLU>{qYp-YW*gDE=8r +5M#YW{JD@D%jDJZQX^Wqv5_h4@3P|#XOX6K>1i87tAks>@9)3QWrz$L_)^A0VbWG7cpTVY_nQVQsOIE +Pi&l{9C|n%?r)glBt5}X{?$w%e>h9n$kwt?u7`TxJ +p_xevY%#MtI=k?j$Q*QlqPIP@6aWAK2mldXPgO8+p}hzM0021(001ih00 +3}la4%nJZggdGZeeUMZEs{{Y;!MZZgX^DY;0k4X>V>{a%FIDa&#_md4*POZ`(Ey{_bCKP`=oJBs(aYw +FdSEbOQzqYmu#=f%2Iktdz+$E1%e&j^zhtp3vCgc!f1_{IOxf^|%Y;nW}f>pexq4fe>3QZQ?WE#?UG9=-K;0rXHbLTMhXGpVoC<0Uk5fJBl%n^)>2g< +=)Cs8tGe@|S|y8q~_bH*fo#j0gsO7T?Bq|J=Z*-#)?J?FRm}N`_;u!4V8T-~XA

8lTGvbmFGylM~;n6rJae0vcW2WX +OcKl}a#4n@xT=3I$Pm%<;JoY7Ae~GWlqiPn5TkaH7DNarknDt*iEQ^E3(h4WKS(E+@?8nhy?p)A-piv +DM1Al~?@DM3{Obe^~6@2>q@iI!qqU)sh?2}}07}qqJ!xWZtH1ke>%@@W{1#pB=ehI%RWf&YXND1h;8y +Fy&-qj3E)LZe)Kt4cX=6DhX7iNKHXIvW7a8ft;8rKNRcS~>J&j=s8$pF($m{X&gD_Hk&Hf4B>##yRH6 +4&?=>_Ovh1Rjpxq&z2|N$zA4c7^Gz@N%tk?iN1==j&BkHEC^7nATJ$+@*a&AzajNIaS_K%k3FF!22Q> +?0M;rBT{5zU1t03Ce!UH!`WybJZ9&)>+C=4W~Rs7I3t^Fv-jNeY@w$wivLhc0|XQR000O85nWGJQ3Xe +3zXSjP5)S|XB>(^baA|NaUukZ1WpZv|Y%gtZWMyn~FLYsYXJvF>aCvlSZ*DGddA(OlZ{s!)zUx;^okM +LvOQ6~IV!#D**a8KLZqVjt1X^06Y&H}rkW>tHvH!g@lp=|elFg|)#5Oh0kKa5ZtJ+u(u60RiO$ENKr9 +Ok~j{lI(r|`M<(rB(ycxY-Rl1{RgHOrobE{tV0&!6}i6`AK}_oDs4&r?~cy|8G8HC`&ma#PjZ%ac^nx +7k$hEPUpgn!bx7g=b+M`bYiJWZq=j6vn@9w~{V@v80WyxRU>hY-%J)l3a1;FhGmG?puE`dY>eK&t|g; +pPzKjYu705g#&*PP+Lm~j)C2;7pAULnBz`tO$0EyDUDuNLVmBylU2N1s2&U1xG7Ursz;h3KAIU8J +uFInc4@h;2Y0LO3=UT0^CaA$QJC9_FK34W4p`WsPDq7vG3y1?n18WY3Fsz`jaynedympvo6MYy~E__5 +2N5G7_Iwe(rG9ps%*<)}S`upbC^B)%P;w~vpQ`k#pBL_7{-q7+DZ#EVFQF}9*gu)NPn4A?}6#3Sh)eE +2o|+>dbd)S+izbIYq~j(4EYFL4KLAvusnHW*;=d)XOAfVj;s$S~9yOoik-`VbSj2W|xn^#P|g@H20$# +lWeOy{H&`#zT9R4$WSrQjxh*>SAUy=Ne7|PK{I;r0yvH5Z+D3y$~GLs00d0 +X`h-7SG3+P!_vl&F({K`p|orP>6{058ccsp;E4)^F|xsd6O@PVNA>C2LAR2SxzhrU2lHvfl~q1D^eecGIztGuEW-QCsy?ABp +F*lx$udp#}yygzc9H*m_bD-_gw?)Q)@dD+$Af$5w$mL!~QW+Z!2DJ@e0$qhvWYCaW~Np01*dKnLgqdF +)dIeK8S_Kj&T^f$4q1z>-gg}q3_<)%|OehBPG%SduX5zj^)N;jdRt6u0R|iVlL@14zl^6z$IoF6ytE~ +nnlN|Etv@O0MT9_2fqdJk +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 +nq|Yx{eMso&%RAFE*EZ@>Eq&)6@3a +&*8#J3w`rr9oeyD~?$z@>T>jcV4%IPIX_kUA5~#7H7`RZ3jVXzlYgCMppM6*EkjI%|0wv)o2DXCsfoC +IJmD6Dxu|Yh0`@8B0RwFi(w7il)c;|kMN9;v0y@nUkl>6%nhNc>tMV*im7Y#FEa1_dt{Xa82SD^-GJm +pENeQnRHDRz!~jTY_9hTa487PZac%5NCnL~UoN3U8g0;knMvN^WABg6f6#MzdZ`r9*^$|6M@2xCAq42 +5*QR`JzAK@W{o#q1m-=Zik5MO&fYP?D%eyT1^!_ex0*jI%Nv&;ZcIBKPUv;TJjMc_DthX@C6;i197up +DMNtCS;3`&dEfR?>$jZF#epY=9Wx>~7>$bMf|-@Px#XU}8l*-N(fk?G7xjue%9(vT)qS5p9-)eWL?uV +v)|(LGWhTGla~&nEED1F~gAO&wKG)zw=aZj2w8~?ps)Kck%8~P<_)}lVE}*FvM|wF<)V-nQ(ItP8~+R +Z$E(5E`i#Be>h>A?39E-$yhDP&>5fnwBrr&8z2%`oS_V0YsTslq@n;W3If-WU5vY4qX(vCw# +MNOav7OymON+9B9Vnrck1pQ+{F``(*Gy&EKElE+SnR|0;1`@B$v|Q5! +hTlHN&<#vh8SqfNGvHW2vqBd@J6%%As^CANIoR$LII?ch__54t3@em1G~chyBD|DO>WV?uMnEW$&a`6 +Yl2IxJvPj%Hjf``_t#h_a))|GuVbxFhg94Sz(1)ll{TXPM44=k;ExKNM&XEs(Co3rUU;yk(P?I#VcbV +a$Z-Eu>Cl!`WQeeLvg;~nFviUkErWc)MvJ+0X2rf)1yNJbC(t@U?c=gaZ7^4WTRD@$x&hm_BZ)+Y+Ww +@r2-Ks;ccat5dM1Hc`-Hf@FG3-aJU-DUti{rGv&d+ls@<~sQ97TM-j8VAt`$`NNCoXt3%U^)zyru-j# +vWHARWD=OBMaRS|CKAS7>{4Sj406xHNcUO^`Rabqs30SPbkmM%6W<*kM0BD!^(nj=WZMk@C~7Sz*R<*|7}CBlJ~1oL%D( +MqRoIk##ur!in}=VMzRLoeY-%c!WKKo+;S)JM;p?IsoTQ;QRidy-LPUejEy^EB +{AH-pbM6tTN9D|BUI+|Yvp&rWrI&^t5xHVJ}nlJ=F*nCE{L2MbFqP(ckk?#p;hCm5v*iPe4paz~o7gXF`Zrx +#XZ!4xb}ppZiKI8B* +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 +DyY0B#^*TB=Kj3%xKn?vvEKnB8&$Wg_ftj~;< +fGnOYm&i}I>;t=HRWc!Oe9fGlzx&v4ViMvz!i>D5U_)ojW8OU?+X($Y0(J%Gaudi6K>3CwKOT|q$?Kz +|qXSz98p05cTWCI8k}@b7(3WvB9cep#n9;F;=Dkwx7_ci^+hAa;!yPDrip{a9&cYf7{sZ*Q2Iz}|t-Q +3|)A6684c8!;cO;c#g(5{J?#7UVp$7PGJ-{IV|6g{(L_?2>oj^=(kCpE_mDVz%@qt%t +=+?fyP0r3aNTQiyMffZMLx3jCdhpkV~N4Z$W!Ggh~ +(}(-i$PgdEkQ>d0o`6p{h}u7tQDRGW<+1~WD_SiE2wCIYg8nOj*x+=p4mj&9;XkR=|U!MYx4W2HKl@h +25~N_ws^9DlE;{nQ4j!YXl7Vh@+A*ViFqqm(xV9`bjlK|T0h%|nfCKNj7a2rS>!yhIxN3hskv69S@DO}l2z= +Z_jfN&*)kH&vP)XZ%3Qjxp0@gKO*57zxInMD`SRM~Zifx5{s6o|=ajO!k2L%Y$zkEUVv)&Hm9P2y4#( +xDgf2$YUsIztC +A*&`R5*=G?9UQZ<%yuO`i@OqSNOwb-9oKdLpx&Cyq?Ke#`J +GtEo17V%oVPB4twFX<*X_@uaj{en?(NrP)h>@6aWAK2mldXPgOz4T1nRl007n<001KZ003}la4%nJZg +gdGZeeUMZe?_LZ*prdY+-tNUw3F_Wo#~Rd6ik+Z`(K$fA?QOXdhPIlZ9j-ee1>L()1c!w<*#T3)Bb%T +B2+=vZN!WCeC92_nR3~A|=adnukQT=KJF}Lna7<_x$<5zFdD~)ih6LlYy-0m7foK|H +co|-~#ItKgAo|k+pl%ZwJ$*n7;WOl +WnyuQK5{FK<5FU46JqF5i9r@ZaRq^_Q!N-3nb-r5@;)5GMsL#Cy^3j5plbt;HMgQprt=UPkN>v9HwOP +fS(BwxY3F%RHhf!KG*(EAyxYq223JkBFQb7rvFJ}yXYG44yOyq2$GD8gil7X)ggOB#fI<@rNnX|?3N6|AHph0d$)2fnj=7)_ +{o3B{yru=q-Z6#!vk#6?+_I*4f_Pd?btOb?i7DNI3VqN}OQ?aTn4lEZ@66r1kV-}21F+8I^DOO2~R0RrqS(P1%Ht~@?>Zs9wPe9H^9Nm3 +}B-Gwdj@!Vg=t{->_O$O_f$f+;f|Bt^7U-pYs^&CIVCEC?Bu|ib!tDN(oQxMGke}fflo<#l({YkRh=o +#bbc5acHIT8$d%wezMJhVf&Pra%Yq>^)}tE;iGBhBbcFLpU?X?8fBudW(@11kPm&O?0H>_3=4+$8E^y +QwRK$ZXE~^36!Wt-0V*4lu*aQ*w;+iMN*k?Ernz~tNsmvLDM{(85#xudv`}EK#hCAwZ`LZB6{Tz>hL5 +}G(=;R+0F)#_k|YWH#As3E-$4>c45C@0AuUTxE)>@>u9HLpoexzhTtn=jw1L6Ojq#)DAbb)^uPmI-U9 +F5@HAG7H8VW%G3geftAxKh~Ic&9Jzn+~99E%g(xnMrp*2PEXle3Nj;k!GMR)}&7fUv?KkX5mDVjWzXn +pnIilHh(mVxX%lP~B-kCANUi}L&u7;E!`ZC5HgW^N=26gLff^xs +9g_$Wp6}kT8#Unoe)NbMq-92Cm)FwEkjgaW1wvQYt0va8gwk;ug#Q~LLzNZwqYA{&ZYw5t=Y1&j(F;H +cPHlQUaQwUfY3~CN(0&MIM$jrOm>pRs>+JWCYHd7eW?%E_$J>+A*p{RO~SmjLdt8Z6G;pob%h)z!khEZEh}Tbc?+3%JeLTk%K{;iZeXGjY!kIBPn3REshsZ4}T*S?s&n +KWEirSyVjh;BU{LLVP^NMz1*=u3!!5A<%#oEG6MQ8o;B+QPn_bIl74a#?BZV5Cq%HG9;nwA47vWB_rL +|&a=n}UJRMWDAK(Qt=*RAeEvcinX(~agHrmjw)CsFL^QA!T;;hI4b?DhVNhRPL7$O9@H}kR9RV +%?mEdroskEf^dsx1(fIc$5(N)nlq9^id`V&|{%RH$E&H|Q-Z;lkyW)cS#tt{5Ap8FSewq&0uZLs!RQ$ +o}W-to3*=1|)pis@a|78w@t@8HirJpt!ScG)TgL)GbA5Ra|;Qf$d2pXt{ny8=I*PQ%ga7JBW_vrMBx`oz?tbPPmjM6bdc5^`n%zdn0>+y>N{F0O-$^xGN(HOQ>6hEFaOum +2&SyGYTB`${my$ku0*NJpBvb+uuL;gfpy7!&b(8a7#8bM&OQ4DQJQQ!ZkiHwlqf4k>10dtU+27wPtx>;c)J?N3bPb_O8vDyitho_Mq$z+TBI!RDYT)4NG7yLWbus+HOs8!CNq5P?** +V(CQl%r&WFMnyo+m(%COSBXe`CT>V9&|6cqBlK*yce`0qxZ*G==HqFF^3*GL)%t#xkmXsFQV_lc{{Q} +S1swzk)984EPePTFtcMo`~_3i<>3kdr+vU6&Mo0yLRd!e?k%%C}!)1y6q!?R16!&thgUlSqD?^nR>w& +O+kqzh_*6y0AoHD=p)aI3a@1O$}p5LoBlYKA?D2L~%~z=7yw>FrYW5;gkXkzd0>_z4+usi4;I=B?m0j +fW12Knz~^4lffhWBBvoTa1eJ +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 +$k-z!o +ce|cNv}9>>yVuaXReQ*Oc-8oq7Q&I-(V5&rqd%8>`WwK7rNcVS=Q!1b(<;ioD!FrO`uUJMPo}kUJyAQ +FK#4~P`Mbr^{C^gzSIf`wG1$QjDC!JCm4~2|Z-dP9k~WC= +mLc&7Pfnfq181AYP-pB>aqw?J-=_UJEsEExk86Q=_f$(;@XviZsye-!XL|Irov&wa4Ou^*(evRe) +twO-rK?n^=E7le+MV+EW(*NN-=Vr8dSusmJ)n>0r2xWgWG3_z4!i^^Q+*M{?Q$SKahwjAdUI3+H}TV;QwColJw?we8iK#Ajx`UZ{C?I@HxXni}dvm|o_;r3Bu|S%mB@8T_M +!u&-O1-VH~$-3z&1lA|6Ivup3a$dv?^+EKiS!35?w?Bg8^>eLNd4=7~@AxIssaYC??)%W`C6TLY^jOZ +;?$j0+fgj05f%{rOO_zJUwZWu`~a`4rVrdGI@{&)xLw}hoGnhL&$#ZM-8hbLYd&EpzOH|goRp2>TJ#u +huO8qzU$nb#}IjkzHws0F;mPxicGn<6Q;BBjzutoCy*PILRj$B@rFE5~3j)7*Rw;XGe~r%v@(HV+nhv +g(OWBd$XlV>0NVw`^=0j9xXpnvFe3UGv;MkH5{ju=Sh!P8$pZ4bivc==RI37XFQUujB;(@CiM-{q`+= +2ujL)9XmovH4L3wdHk~v`#TU!^Vp$>KiAZ<{Ek&>RL(L~QrNsn!o(kFt_q|=$JorQ#pp$nZZd14?>PW +V=TCI88!?7CZ6h_!Q%e>0Cd2vk4J!UQ^cn2OBXh=t^tf(3aZcB5-V4GRYfij3bfAtC{~A7U8~bslrqC +Zk)45AxM8To0s}Svff1wWy2yFg)5cs+l0uZTl6!u~E5Rr)$jX!9{ePLT2SL0ltuCKGnY<2auS+RetuI +X`vFdryAbp_H4A3B=uFvkV={id%KV@mJooZKp}Dv>daJEpkX%wuh{Yn|q)%hJ7r(SUqSZBkBZo!4n%u +ktbE^=7&4qy0ElCR+a&6Yv3%dz5Oj071cuZRKCapo19))XO +AY6f&_Pw`BXzJIxCXeZ*y-ajt#`_Es-1>%{5J5+&V*jD+!SW^~Yb=WnL~)lsdjynCBn&8-oPR +#*(H~JF1cU?D7CS%6iki`6)e8ozpw)Lx5GUM$^=BMY*zLcs!1)vpmTw(gRd%@W$*RkZ)ge969a=N#{{ +{v7<0|XQR000O85nWGJw6z-t!36*S=??$^9smFUaA|NaUukZ1WpZv|Y%gwQba!uZYcF+lX>4;YaCxOy +ZExE)5dQ98ad1B*25iGknkF%t0bPh7L7zrDY{yarf +@8>oL4XldH^NTZ_yr>P#e4{2XF#CEZslZqaU(USFy#!;o*TwPpw};C_V=t0Ykyh8n6g#mpKISp+xt_k +X|&MTFYG1~r1xaw*9|vIP-E7(uWl6<3OmBDk|f99xhXETwgt=+Dtnc=Gz_)zP_l{W1tnPhXxM&5qCU) +!FRq^f(TVj?bg$ESw!r2QNs|p9qCPcpEbQ$#oX0h)~TzMg&UQEukS40fvHKtHK2l#-d2*!75TBoOJ0; +uF)6*s>^tpDS0dn1RBNKFjxT(LQ5p&Du#{N8d4EqP8nepDub2UfTbuI)DNhEghQ3Za#?7M2sTXMPNmf +~1xh9fWXj4ANlaKL8_NVqGCQzjuYx6m#NUt-a1nR135o}7q(q`JEN|_K9stvv&{8ffMWv3?_aPy*6oF +{ljuF{#NS;J7=B#s6#E$hjEWgOStd>1c6uVwx5!u$RoEnM-nW{avVokSANEq}%12sU*dU)%9foe@Gh0 +Mn8*q|*n;ImMF-tz0NU@Vu0RaIqC_NmfYM_qteDxrQjpi*3^+=rfoFp()WhxJh-Rhr-lgHwPTm1A5aU +Kxo+3JpgC@Ut{r5|IE%g+s>YLXl^XVxeS~-96Q`IHyC&fSQiJqYL;YVICS +Uak~A_S6N +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 +Uf8Gw`OWXC<#WToyr4X +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 +=?VO9uM1`ZX+n?|d +U^ty2!1-R^>v%Av-UF$famli=1oA6W~~0Jl +o~^!<;xaR};;H|1t9H%CgqH67qWb|vUO+LVa$C36x2iRn8;lfkfI;u@IRhM(vaqVuOMpOV}|um-;m%$ +o9V7ao0*UgB_kVqnsfzORbTsa;Kd1h*QfOB!%)wGFA|)aG{1D3IF1VXM#}O>5CrpiDs}faf+W5-G$1a +_HdMPvvCHe(aLzUpemep9Gs49=Yu?>WSYZCz8;0z^@d8q$*y&+JHV!9O|ct$}Ii$H=qr_=Q4t6KW^Sh$CMx}7FGp?J3DBwQeXrNu#_r(IAq%6Cn?t~l|VV +P3an`EC}vcGrCDyU4NArQ6+U*9gaPjF)DW9wUxla+hZZ)Szp}WFp1bgD<@utS8M_E*Fps9LQJ#GOQE} +rzP)ylqWk@>U>Jb)KFqY`S|63aCXbq@W3O#mZ4@L|OC%J|k+>&|qy}(DLk2M%v;|QXMwpEqtsm!+rk4 +*Lo?2Ft%Y$04GI}djoSf*7VUH;BrYU3X`>9OA6Hz`UEqgJuh`A~o4Gjq6Y{14Abh(O2kiP^I_{W=DY6 +0@Xn=^iY +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 +Ws*wRW^98S +{EdVga=Q;YfCM5nJ685FZP$lX!8qVMx5>p>8T*n#`=Kpz|6fAMIOAB$f%-sb;fRlMF<7cMy~0$i3&jI +Vv@8B9bOGX2U_2UW8~&s4MA|C3Vg-iwpiQzRyLt8I{pC#*O5jPlO|N|>mpk +ch9i&4sw=8qJ4kpCHOGgAq;Sj%CFBqU0ji~7d@u2U-4^rjlk$3S$?P4^YCM9>9fw*HiKWH^a&YhDr)9 +FBBXn093meo3ru9S3=7xJsfnYV^{YpC0E$DUb0>t#$@86K%V`mrYEqxApczT+3?pfAJTE9It!NtHF)nY60LlYQU}ylOQ(eOnOb=lSwtItz +IXXX~>5|xfK~tMx!c|83tAX~N2X27EtlvRX8uIgYRxfBuFJ5yiE`4{!;r;!P0kztrACex3UiJm|_lKJ +BQ~i(|{I*xnB{y8014Ih4veOcit>IiQVv*FaL~*C#g)4Qo8EOr7OeN6nIoqhW# +T(v2DaImzY)kEU3{%+aLpy&swUui^8nd*E5&rd6TW;%Y0-r8F4*|qE~s2aXmuLoIWVT1ms=$)xDV(Bl +58~kKSPepuw|}g&-+U29pHS1wDGpDK?BRfdpvKxJ;+98&MtdzB-yRs)Ny}?Dc{(EQ@={;yE>pb{!!L5 +_Yv>(lI}uY*u&vBiQ3B9zaH;}h*?1Of1b*1u=Ris34I+ml+x`ij`(@+q7``-6-DF{A-0`2bG_b3S +=YZ0Hd#tmD!2cVBiT&oy_2yu84e_&DBpwIX;WfmoY41;#;G*}}X#l?rhH~wH&GLmziR;po-?JL8~1Z6 +uzPUqTKY-TKaLf7*Z3hwi$a;q1AMWZ1@jC_K}Xa@vTZ^{jfOQ=BUzO!=Je^H5OAkXYU;bBXDMvDblPj +q~Eq#woa6#tFqJW>C?ihi#HT!=zAzx%VSo?pHhQ1SUgZBR|6RzA!PK&=2Yy-JbD_;l@`Lb(RxM?eR!J +=BLj{v7OPP_)B!2rBKNl%75{T|BVuV3YQD|HItFxopNZfFG>0jR#)BFJ#M4e;l?>w3*$Uc0X4}9sLhb +O9KQH0000801;hJRs5~bF<$}z0DJ`i04e|g0B~t=FJEbHbY*gGVQepNaAk5~bZKvHb1!0bX>4RKZDn* +}WMOn+E^v8;R84Q&FbuuxR}kJ|HsBiAVHgk~J8bJd4jY24cSEt5SgkDyl$^yn-FuwIA_*%6#}O}j&*EHw_@`*$CjJx +S+~JRIMy((!j|A3n=rKsvY7CLkF(H0wzZsztM#tvhxev|Jy11uTl@FYEeDshZz`r<4;JlH<}FFw|gD>);paxBj3v{z6=v^bgj}fgWU1{ize)X +rGpSc;bv9^87&8z^E#2VxT2?qwd@{Phs71&H7G`5*9%}hMFlq><6@B@S=1v52(vSoyf$0jcD*#(kDdX +1$CZEzw1L&_3Zl*;0sO`=5epD{JcX^EpwygMGrLRkeBXxAMJ|??G?Wk8sAVx)#mwEzkBb_%gI#k{hjx +^PSyszCny?a=m>KXN7mbsl&kv(sXI!SUINrc7%QS>uUKedtYrx2~2MHTKi+sm!IWu>JPSTTVEnm0U(Y +{9%Cs|0pZZRjn>ibN9d2>>xd0 +TwI4kQhR*yA1ED%$85F7&RHJk3Q}7q%v?*9%AfzkRA0@#)#f7P`Xcd4`~^@;0|XQR000O85nWGJMiwm +ZbOHbXumu1BGXMYpaA|NaUukZ1WpZv|Y%gzcWpZJ3X>V?GFJg6RY-BHOWprU=VRT_%Wn^h|VPb4$E^v +8$R84Q&FbuuxR}kJ|HsE^OVI2@4J8bJd4jY2CcSE+ASgkDylAJXEev}-!@zT~8+miVB_#UY&%YLKhf_ +n}-RA{-ET0yUOvW2a-;Phx)1Rp?rlwpI^dq^asXDxqy<(0u&xsXAD03|a@Lv +zxg5Q|pJXyzkMTM@r?5Vc|yYrPXRc<(~_}#}-Xwm!fh8^!!rJQ>s|j?bsNrTXgQm +T5ZdCAeH}PuKqihJ&KYQ&*dQndRMs_DP^;xqWJnCeOEgp=%eK#Ep#+_*y*TVA#{%DfHcl@$@gKa$qr5$kC(pu0vjLliNv1qt`a;>KAd +P;QY5c_w@*OF!p4m4_7z4g%XJ!RErKrQvQq}rpZMmr}P*-L+%xcN>x=!hD{qYDW5NHbf_08@jK2CsB# +KA(=hY$Ekwd*b-yVQ!8z0rzB0<@L}P*&JHTUz4U&3!aTkJu%3qSFu_o_4c@22v4|uq}u9}iwW`-X%pf +6ya9>@@N{Fmc0mAlfZ^kkk>%3ii+4wEh#~1&pN4FGdKVC{f`~b_osE-1cW7+I>RwB=pj<9$FW5g&O9K +QH0000801;hJRWh^?E;0iE0G0><05Jdn0B~t=FJEbHbY*gGVQepNaAk5~bZKvHb1!0bX>4RKZDn*}WM +On+Uu}$c5El5-Q8T$O +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 +bbfB5US?}+_0D%0>351;n|h{?>rY<}BZk)HO&q +$Fe`PsGU>v%}^Jd0Kh;Bl**a(NMSpRP0DORb#o8iF{P(0bOQa^N@88hZXx#4d|Vvj}|+Br09K0=7`rH +ha1B(JU_D+d_C|9~;S$!x={0Y`*nI3#*zKa9=4h|Cg)cA})S +!rK6D8i$lW+o@9$IL(bYz54h?8&)S0!%3Sq5l}hKR{d4FZVO5ZzE&n5Ap;Y`-D*qOgXAA3nB2Pa*FZX +e%9Ve&kmMH8vsi%|GSGX=_*}{dO1}63mtA$m>wT9f0-?ExiySIh)!F3ZmHS?)yzhDE+qZx3)w#6tbbr +q$)_kM_#4ksr~wd&GqvL|Y8jaxr6=2)Xk@(IJqBURW+>Gv5zmP1Z<`a2BTcy-gr--O1=*QBYs|lm8mXZSg63wn02?3!xfoKMNoEr+r&I3B#vu^>Wy!)|IcXH}hTSE5 +JJ`=dmVVsQ+it%d`AMaPs2d?kb&5`hdACg_59o>5aX|uG)lfZTHn +z{uw)LiiWQ(Oq$%=2SO2-={J|Xx%+YGf|Nq0dF10!wWch6Xz;e`96{nnT43W#+~{>va#w{U4L8|6@p5=$R^RG!e34e}vAJ9goGtO>A5cpJ1QY-O00;mPT~Afv-4 +uH@0000p0000i0001RX>c!JX>N37a&BR4FK=*Va$$67Z*FrhX>N0LVQg$KUtei%X>?y-E^v8MQc`luF +H*?OPbtkwEmkN>%}FdtO;ISxSIEpOE=kPE$;?YvC`e4sPE1cN*5guAQsM#tP)h>@6aWAK2mldXPgN_^ +wh9>n002q_001)p003}la4%nJZggdGZeeUMZ*XODVRUJ4ZgVebZgX^DY-}%OWNCC^Vr*q!Y-ML*V|gx +cd3{vTj+-zLeD_yaNR<+a;{%ZBL!~}c%C%DaSXDj;FJK*bUEAc!-`6%cK$1J81Ux&tz|5E|%TCbpdZH +ktXN#@1mLT>NP}tsw#PHyl#|#SiZ;;5f92JYO{v2H9u`Im%>N9t(s{<&t1=hDGndp8=VjE4>4|CXx(zNZ`c#3 +~wqC6+?@V59sx+@(K`@J>seuV;pmu1cW$=+ceWu@0K^f^jjo)TVA=?$Mfu9AytEi?B}Rdh}`YopbZ-O$!2-f$2%H2LwLONA7yLy_)f_D3h(W$_R +E!alalIYy%H79w$`W`*;dJ>l`w~;nolbnf>MRQ71~9l+O1~NBEy?>-DYzhj^%YkEUmG);^Da2N{3xB$ +(!GyH4Xz;!mDiSD$|qe{Fm+4uIxeIo2cH+-=2OX{{c`-0|XQR000O85nWGJgX=+tWCZ{K2@n7PDgXcg +aA|NaUukZ1WpZv|Y%gzcWpZJ3X>V?GFKKRbbYX04FKlIJVPknNaCxm)dyCvQ5dYtwLO7J##HSCi;6h3 +-PzVhqf&P&OM{AG0%Gr`5$+x$JeD{tdKjcS_6uNM?E6qbQn%_JW$MG9zSa~B{Xv5l;87>9sl`KK)jBp +B+eAZxwp7t}-XBx$E97VkAr81tAa{kz?`7mr*?(Sa~WLhw|AQ?DnfKLelcm69qW-rJGzn(=l}aHOo2r4!Ti%rs02%L@|?6 +iUiN3p!artEnz8(9JUM-Rg*aFdVr%uFHuRghqRcimM;e8TV1$onq)in07XC?V^uKK=x4MI=P}rm +9yJI7sxVBWaBq$mXIpeWKPiYlndRdEB +8@lX{tZ$TIK;LthLELD|61V8?F(Q*O$WjJR~uNrn%#ymhr|5+%N3D13|vNv{_NQ5;-ei5 +7FM;5p1X>S@Fl;zN1Z*yHzeKjtL6HTo|qlnE^wXAn{smHac*LycO+@%!Lhe;0sdpR*XFV?$xM=8Sp4m9cdK>O!Vp7oB?_>po`H*admNZ>EN;Tf)XzWrCla+`g+K`Xs!5$Vs`itaZC6J +ML2FRTgq2|fNUXMjKk!WYK(TGylI3-MzI=EZvDpV5xBVvEhYvhm1dw$_$o>08vUP&KVQvw +%GH$DgTX7umrf0q?)&Plu#ILxF#)(CE#HoUyEqGPhE8Jzhe%>08=qY-Z!0O`f8^6?0Ma`&>)JGgP6x% +>o&X`0!Yq@8uV~f_FRi!*UDXdvK@I1xO~0bvv2U5Z`ON(&0XZ1^??A +wJ9kZONAft%{nwtn#5Z4l98Yg@HE;3>?+0d2sg%#Z)=XoOpKrj8UKr?SX0U +yn>-ZhA+ZMH*(_O3hHs#*;cyo5Rav89s^Fzw2w{7wt6Gau8LVZQ+{kG`%42d4n~S7>QE{kkWP&Vm7;-2rPaV?GFKKRbbYX04FL!8VWo#~RdCfg*bKJ&}-}x)X(A^1ZFF{Fm6c=MUC +rh-$iuE{=ik;9Z7`vDyVPXLoz>-?41?&;~*jH4(z-848{OJ{^PwX>x&D(#Qdzgq{;eA^Rw0FTX(tX3p+-)wFul~Z3O_jy;WPU)gtTk!!KkQwQ0 +*PTj_N1@C#in>s)gqz0Qg9!uE<5vfd6^Z}T&;={-mJ2+({lwR1rjyfqu(}2P- +!0TDfpZ`pVQy7zrQ$6AOGd}@n27#eaDX;Ra^e@4N={+d<=BV7NzE2Pl{#F-@en8ZnM5_`R55B;hNDe` +|kUqlTOd{&Dpk*M$a2$TUPR~Q~m1(D5A|T>2bDc4A552`M?TqLJ-)!iy%uhsSMOw^QB9dYJ{i5Y2V=OWmgHqJn>~b=$%FslIF7XL;6Vq11 +c>BK!pA-xiBaZ<&Bp2C47$`UhOD{1C^Y)tlx)huP$4Apd0tq-|jdr?524uuo229zQ-yU%mW3eR_QM=* +gqAN9nUiPmkvyfY|m`Tiyb%TVCq5m4{Oh^QXt@UyuKOItLcxtEs-kpJZj{WV&bhFWC~foA&D_U6Ek5x ++&q=ZYb-bTRK)Z{ifA<+Vy$8>E}vU9sCCJv~zWtb(aFP$=bf?cd&)QZYmU~(VAXv+7=Pqth4TlxlnZJ +P0?Q#Rm!xjTUpy3No?O{%N|g|k<-3TbG^zoB?t-7FKxL$ERrHd6y?`H)ZI$b;m-ir@_A% +(v>O$v-YEhffxb;eP*|m;4U9M(o|7-QEuCyByKMf$Yx3`CzhHll7**y|i2;bAQIHeVyrn9|0hZ3|DWf +=R2q6%+kd$P`T{`mB7FY6m^G=n6FkJxs=Bm`yMSnS?eH_P7n+~~#W0G3E%pUyVVLZcq8X;Yp9x$wx +ctXy@Yer3Z1ZWpAkfTU_Hr_Mi%Y+-ovssdBdK95ntnNp%q(!~c#L-d2Fk6|0!5&`6GJ~1W3(SGEsM9O +hxi7jHmjRKDh=W@m(*}0P5pAyY_6As@pyOr@tFTjjt(vxObX#r}{Hau?fQz_KYhIfb**F&kY!M2FN(@ +LJ+qV(EiVms8Tt$_>0b2AA|I6r|Ol4KPNqJv$?5BC4XnWX`3R8DJX}0}kT`5!-@a +q8k9Q5@8Kc?m~)3bI1I(0=80TZV)izY<>j{5P(9~Eft=P#cSvvmis%TiTZ=SZ7{R+|R47@bplSUuVqS +xM1Z*_iPbeLF+iiNTNXv+0JOYbycx@EM})i +CK{)Ap(}IGJEk3j9_c&aztWYdO^myNI>$=BnqJdowv_Wi4ibG@14x~}wm}W>aP>BF!|D@Z0!9Y;tVP% +)~4d~OEIs*OB!?=+QOm-L=U`-9mt&7q0I2>6mo~mI{Qm3&kn7pfDC(0Of{awd9Zsu(Lnk&E-jdER&ABxS=MS&0-*K~ +GWnnETY|0@=PmJ6U*{ex>!PioyH>#Tbq(NlfM(;V27TY&6rCpXA=HK3_P?!VGI +Cgv^o4j`G`%=p-xFff138_D(~nJ&g0w-_d3b)Joezt484BPDzB@%=#RsCgslg8$TJb6xPZ;6zeKhJ>4 +as>9uz!mjw9eAKevb&T)~lAgBz;j!de{g3N*E++cC_6)Pfhfx-QzfV(o_Gh)V04vgl(0YJ0zyDV(6-D +z~+$uIM|~?BSj>2lm_9$}EdM5is~UyDVVKuF>}+!9mTmz2R)@elOum%;l2*owpR2-ARb`!Ko +vIe%8JRXr{C<7tBGuZ+O4j{WrFyBrH*rAcWfY9#!+^!KIeJD4mjn`dh4va8&kY=io`My>=G +2E#GgAh7lD)kJsHrN;^Et*z3Ki$-qCUHz6~YnTofMgUf_|rqPoab|FHdc|h-C4^}_}Fo)x?J8iP}!## +jZr4%D+WS~<+*#5xVj1tzL10d)3Ub|tyGuQ8j*C9Zdy@eR`zz;5*Id@%AHG>pz*0pLVE?W*p+eRmg3o?>|k1n`x9vKx0d!0YV^w{*2eLOH0>V_2_64 +sIu?KwPJQBB(jq(`t|$VC=TufH$I7(8f8z5j5&H4Lt8q7XbFMyUoFo(`tXes`v59J`--=1e6j6F*Bl% +Qez1>6qpf3gLxPVMKrt(QbeK_LRtA>P+%zgx*eg(;(L^Xi-t_H#(*7@nIc;C_dqM9eNpDPK|u#c_5#G +3tfk+he@?|C3PniDa6~tC`k4xQQXoVi0L08^&(Dqz6-uZCf>;1B=AD7Sl7$chduW;{B{b2WfB$*zi3C +AnVP0ojl4fw!^qU5j5{Nq(8zA=z$X^z+Pb85is5?0|!ryYlm{z#AFb83&sx??11-V1MmK1Fo{Zz@ycT +y+jV~X0F!l`)*n^#-kbWA4sacBe7=Y!bF>-iqpkfbfcKuF*XfWh|6jNv)(2pqT3%=o-$wj_Hd3ceh{2S&4+%}rRkXrGZufFjs~z0}F5$7Zks?bgrt +dz_OJClEbym=?xcNJ}nj5Sgy2tDFKCnc@%{%!s{ne^v_2L9JdKzfhn5@geob?_WIlqgaO^Ze=%16z+6 +{Fw%y=V2q3>M9Y1(smRuxQ!7LU1L7!f@GnLYF_H$3D*r+o8|^DlPs~vUuGdY!l^4Sh1T(7K(g0|kgF# +cmq^fd@qoCoA1Zp&gujaI`lJJvN1f2v>2h@Oh;#>i9po=awM|s%RTGkk6Mm9DjESnp{J&V&F^%wA2f! +{O+Lhnof=mwSs_5l1cHsjaD#bpmH!li@6s+X{$Rew{MtjHbT%0rtL$wxV=2JjNn}Ev2Ju132GVQbgmx>?;GYvW8@d8j0K+9UU(3OPT^dec}mh}C)E>Hnuyp!@4Oa!z@fh2}h +C^xv1u`{O@+42g_w<-sT)p~zlnqBsN(;XfhT!0?iEE3?sL9=bLgQjQ>imuz}?%)q!KK#{XRRVSTvU*B=<9UVQMWjVNBgncvRH^EE5SMV8$?5lQA*lQTF-ry?5HpnjOe +}bqrRhY91@2@&F7W+p{R104VaoWY5q%)cUbPN#*peY`QsieYbXhZ3^I`>tg|-q^))$!5!nns(XL +dF-6WRsy7T|Go4>nOho-@%*koQ~q{w9T!O*g>R&fQL1_8Ms_?I`YPy%X4uVH-RMBgL3q97N@Pl4G<91 +I8!;v}aqhP_~>hx9`OYx2E`O$2zz=KGu6a05IHwC5q%rPH4wiG7&Qoa7|=e2hDe3}5N&5wNZFzP0uN{EYxQ~PV{l$35eo#k%9xX +h0gIZq(;g@c|Fp2Z83li+{<8zVBT(o1!|>ih!??*}q5hf{j7eUGx)&6X(IYD6QlctlKh#i<9ik1!u3f22@_%kbS%@QlX$Jo( +(cQ}Ao9biYj0Hyg4xfdT}V8}h4lN)Ifib+=Ic*B(K4DqTHbg{K^W_uo8%5Rz^70K0PweT^H!}z^K;-SupKo?z=E% +r)n#yTK4|!%uNo>fQvR&fq=3yV&;M57Ku*gJ`7CvX2M%^w1i!Pz$^(C#y5JIVd%+QRwyI108qp>Xppj +4sFVw6%;LB%+J2LPcD?p|B$I4Lm=;;VHBqPaoZL%LWp#4_w#}x(qAs5`o_m8K^R~#fM8PNNZd^K=En; +OgLO&9}8p9(d9G{aapj7D=5xN9NWgq=AWIaxE0yo3dZX`BF&D7{d5k{a(0V7x~m*7lUr>o;!4?bT~c> +&s1Ed~-LG6+}*EJy6#VoVG!>-vh85tvRt|9t%H^wrDb7bh>$=P%AqozC86fM{SnT`w(C7Ww)?Zss9$6g$J)l+hZF;0+ipm^ZPpQP()I`J>U~Ba^Oi!Pr5Z8_!D+uqPXYc*o38d(<3*f%s-9 +>yqjBDmgKNWfSEAp7$i7=Tvz*#qWK1F1f64nEl-Z(i!kM)Pg5rrSPMHJm)rUwtgy;9*Z8^lgY=`GbtS-ZtYDPu4@XM;e#0rv9Q@nLi| +=?zO7iT)2q?4PwzRosD=-x~H^aw3@Yss$O^yv2kv45$mlkDDu$tjd-ggZ4-^GpJ0|MrAXn*17)@q-SD +_$7M7QXu>7JJ@UKVbd@aHXh^&TL~+OSiH$q@Ebz*g56Y$vgaLea#s&T{g5x=Wa$k4?Qm_f5qh7zqb +Nnk`PV>q?9~)|-n{6S9+*On3;=LmmsD#|`(%X6|QHhq?Nu@M!O0}cICF=$X?+sJ_|eHhmVm_ND2o6o +?;v_r#f4o4AVz2EJ_2r;-k-bj0q+i1D}f8u`BRqz`8xcHqkDvZuIY1_fF`0+hO=}x9a!$?AQf%>iFAq +u#XBho9%+>)!px+k^>rjpDm$-JD>yhL1XV5*MDVdYX? +A3+R@mdf+S11;;4|3XgU%3$InO5*gw0#mXpXVAsjTd$XQkz1 +Dxz+o*fz;lH|mndBOA{H9?H2ue%5T|1Th~6!^2nY#sI-OEy<9Wvbc$6?nGliRXMt7 +2s#(r{MQZW3Um6*s3*zTIys4=NK}Q1t4hI-WNeuX&oH-Augtbf_JIrD`0YJ9k-a6vqIJiC%!Q`2ctIp +gIvcv-`3gSSDu*tqEXmqg#@zIZ@_Z;T^_1i44HNQ|D@HaQJ4Ad&NoFHj2g8YTMAAx;Ij`*j_E-ouCHa +^b&ENKVUtW0028m45Ih}w&lf3re!HkzzlE?At|3iY2R;Z{R##!@HDaxbK%IU!7lE|yh={&7lTc2`a5f +Z_HxCC2?N~HKysLq9HWQSnDe+{BuEWFKDDT2HIH!n3d08gi!_sKj$+di)~t1Nbj%5*ERnXXo`dZ4xGC(c*i>9{c2iBYnvpHyJ?u8uHs0%{TE%F=;CF+b +Iv-TE;eM)W(`2v}6$yz2;adj;Kz_4{?A?H14!5W~pKxgco`a<*@5};oVPgXh&jfD0=lP}`E<6Ej(~+` +EeOUR4JKVIZ1cmIbUW}rtN)#`X%I8wak{cAvkRooEY();^2>g^bBQRSjRuU@8U9kj^&!<^4RkG6Us9E +8cN#qqF0Eu^(3mEh!ss`)~&t+mr2?6FC^>#{ujblz$;>i~2P +RI|79tv13X;%ajb_yfwY_N??_c5w64P&P|BP5u+gv<RnP4=Jf ++lGNQ2J8;I6SItgc^*`giT~!=bjFBGhr{kFY$WImCS)d7XKU-;`6q6Mb&}!KeFrZniOi{{#seGnyH%j +Q_~d}8yi$TlXjm!gdG&_Wo|A4)vQClA@eud6kK|!!rG7jkWi-}(pwzGQ_7L5ftjCg9Hhu9VI~Tsf7c{ +=Sdo$kcjb&mujsG*5fWNX1j?hO^5#^CzT2jKvG?TY#v7GKe-9uIe$a>7sassc|@WA +H_pBa?669g0Q@Up-b@8)Hx +yh_OiQmZ&PvWd8#`1UW`1E>;?0?nU9YklZ(sf5s9v%jZ{h?;#seJ(BuB!T`QjWIP8zBb1Q!&*Rn!RQw +?A*n>F_%4dV)fQ$;h#n&2JeDJrhTSN1jiy6zkN6RK)(BnB+zUl;{K~*u~T(>910ie2deOK|9`J0A1b= +g5c6LCGX@!JBe2Hi>OK{^I}44)%Bx}TOu;c(*MY{jE*71~FAKUEg*ws>V|sgcg~gr~$>r_Baew2Y$8$ +BDWXBF3Usn`QP+{&3D-)R96sZ_^(xUNv#=y2F$LG-AFLwT|nAVsLog895o=|8?n{wBW<6%Qb29HKed@ +u@bm2?3|izjNa%9+aA@aH76z1R2ojG?)WfpMmE`G7m)355J{R{7LqC%DV@g~ztx3cy6`v=QU6jbF~jX +tVF?v1|xyJ~2&?`?w15>bsbJ%_o4*T>iZm-yBnW`M99KzoSedyyMHu90dnAo_U&eHn)vNce}+D^_UA; +sR?K4=^hLdSRPzoVlOQTgw?f5#iNf$xtCB-@2KM!bNCO>-jj44zmNz!mJDa!)fFy|;0M?4_(X%wcofu +CX?p8{6#b6$%dTr4#^)R0sX6Q8uMR+dcqI>oqy#YjIX~S0!Wk5F$H@+8ZvGzt^ZvaL0}9Zxk415Ks$$ +sQW5UTrMc0g2%I`aN4R1rRo0oy+mBL_7#eWV0=vTo9%V>w1-E-(pF5U@!oIOC0JEapS7vd(uyL` ++@g@|NzCI%TpoH#f##ArWK$0;+M6a1`*GN@~sr>qdS{6v)#6&32h~^`>2l(k0@?wCe43oSe6z^aB0++ +SdhmC5qn9H++m+he0s2pO`9x)*j2n66i8(xO%|@X9&R#4Un87YaPm#37Au+T$*vj2KVEc59O2(%uXOf +BGzHCg3h{vgYKak>lFjj7|W-@LkheZ5Tk; +@SkD=*1paUc(EaN}ppm#)$GiINd>SukJV~*XN#vkyWfoVjRBr+SO-Inx{^waS>CV;kNquSC%d!z;{0O=%2B~>E!N;Ek|WDa&^rLE+rF*JkA@t?`XP&~r=YKfxCSb8SQg5T^otc5DD>U^o7D0C*oIsU>d!3z%y_F0Uw? +OkQnEa +{!`r=OUo&v0Dm}&evClx?FE3%L@rt5v^C>F$9s%zXrg4zm1qZ;CQ`}-Yas%%sB`Rs41Cd=|urLMfubr +8+)YWiAC(lmL9)17)@yp1&Ms~n}5F*jYJz518QTSXgkzL@yo}a2{xVq%9$^iUeo;X3gcwy=#n$M7Sya3|5o`aL3Zyygf6>oq@RWIG$7Pq46Xup&q7iSkn-r|o+h9ue(CV=jlB?*l0i}DwGakNul(_?dm%x76PzmUHFO%zE;qWrP1xk^upW& +V()#SE_9cdY&6U6nwo=cMZq6h6YT5;u~Wyjzf*Mke_a(!3rz||f=n+Rz=0PJzhIXf8TH%1 +`gyP147Bl7^|k*&svnVAGmc%D%+S$qyIvyRN8S`h&6r_FoyRZ#V>xtWzfBA^!K$OFhvTk}eMj!=xS8e +Lk^L4nn(h5BP)h>@6aWAK2mldXPgR4?^4gUH008$20012T003}la4%nJZggdGZeeUMa%FKZUtei%X>? +y-E^v9RR?({4I1qjJSEw!p8+`o%0WTDGDGOx_ZQm|IDE2r}t4OXS=Qfo7`;KJEmalzF7uJy2)|@$WG@ +6-&Uk9ZvX_XMrTCSwY__QR{`OM`x>$SQPdmr$b1k*c^pqW*=BJa7e75OkYS0*a*3BHXWTd2tAaS)JA? +gJlc%B2O3pn9}im^$!BPA)r;mf~vgsWp6~Jr@uW1Jed5u8v&86~QI}a%n6RB4YoZUOz721Z%)XTmtw6 +Hp?hQFG@*69y5Yhz6Rvgw7R8_maWKW2@2_%-#|KqvmCR`Oz@Kxvs}Su2<^abL` +(`y-f9*n?;9peGcQz%8YP0nt~)xgLnIx+D*Okbjhf3Fqx?7fzXc%-L@t(-AIBKw?mZZ7Qke!aeJa3EnZg&P=XLpVX`Qi22dfp0(andZ(xbO{SSg)D3<;J;u;0F3`FMf(hVlO~^YKcIWdaCKdDslqSPUpsY96{v5ZqB7sPf{q>xpmo*Q4XyAiZ71GJ+d> +HauwIAdCoNH$gDr;4m5Os^41nF)Oz|-mXkQ%CzMMeP7|T#vRB2tn9d!iK7>cTQR{)ciNj`gs7PLaQCt +>Focb%=O;MH$GOC%&8>ioKT6^O5l8ok}TvUdBqH~qU?fJ7ud8_kI$llFt81>AHWT&Y=yP@zI9G@L +>0T+cs3`hUC?@1>|@-tXx!Jn+0Bf`eeIj4$Iu8lrQ^ocXqF<_Fd@%gg}4djIClzwhB(muc171wQL*h4&A5T +zsN-J<{hvhQ>0G%j%5`7NxS96@k;2Zw7%&ytLP)h>@6aWAK2mldXPgO6QvXK7~0084a001 +EX003}la4%nJZggdGZeeUMa%FKZV{dMAbaHiLbZ>HVE^vA68*7i_w(+}v1*>gqspnH3NYTQ9)1-Gf^n +f%uB$xKXuB*@zZR=JR6;axayV(EUnIS2WlI(Sw^aa#NZY^;*9L{@&bPxo8OA>im%1@ZC=yZT(LV|=dx8Sl`vYjX(MYjo4wr&mS=*qy{O@vV$Gg6@Q+XeQ5{6aI6LrnfHmE> +xjY4j@pyO=4tU`NIBe`7c-i2Z8^Kxy%ZoyZd)o7T-t6;|Re6QudP$ +b!7RwaYmfP8Qzws;xg4qmMk2@>mZU5@S7Kx63xk`AQ?(;iA^qih~$W`i0GBof_A(AY +gU?z>hSziC} +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 +>4HSS;Z|W-=1+od5OoD1Gs#qZj{m{N~3Q6 ++JJv{PH3zitMV8{Pjb=X!-3&S;{7BtA;<1TlligUgb(RJE_~eDzk#W&bu0$Oh>$yIy9S^t+ooD}3%P_>@lEpkv6Kx6L%UduTiGZgZM71o+jd>ibksk>zh;3W*C2#FFPHKI$j0I(y9VUqX +Jcu^r7x*)G)hxop)?hT;$lqVlQtd?jW0(iz{pCk@=_{jW_bRB*!lwIoC(!7m(UWM5XUvp&WO;(1=h}3 +3h;fVB@=s`0q$QPrEia*Ln9N!5==E|#($fv+qV7%|53l7)|k%6Gi-7^9lbbt{rc$5d8F6mZ@;`#Ur+a +v-+VO&aoZEG5xcN#S>EPNRU%B{HfwTR*uHAFpp9;6F-YJ?UwwT2*Yv07Z;zjU|LQ1x^63#1s$EMM%5) +QDwgGYju|V9BC_pk|g|4n;v&cXJ6|w~+shL>j*EwiC~Kavkkis$1qw!54@~}C_mAaZ-rH0|=;;O0&R|NtoRf_t$*T=DTzl%oE+?o^@XpFEL1#5-K@ +un)J>jC^MQ&n}%LVCSW2M0~3V*fk(oCgs4l0;g>eud3ED50766*hAaLo4?YHZmN0XrS$nVUR;(n2)fL +2Q{?vzIw#QE$ZP^#*GJcWsh7qd|A!WK5&IubFF&q030ad-R^V5-bD|y1c1uC4k0fq4Rl!zP^hqs=@Hd6^X|(kL7VC$w#30ZYJzTmAhnTg;%%p7`_1b+^MaKRUkFFkmadsP0<4`RO^^M&CwAB_g@A +I-*KX^OH&(>YK7^vDAk3#=mGG4$Rq-G)uHY;`-!5$LZTo%ir))ut=lnbd6=HEFiINNwwg6A|tleLTjBx6gU%M;giY`T&7SBt^06$AR|2d8z?^oY0b8Ch6RrT| +Yl${zR>n3gA7J#s@h@r2+Su;sDS0Im260L)ZKJ5K*-SLt)sU^fW%qny#f0;6~O>1)QlS08( +qL1riS5ud)JgR)d3x%Pd-4A9DTA72pZMQT*MobD9apVapOW>M;z@h31t0K#s)E0V53f0CZ*9fr-*{{I +C$`k_MDS;bN)BWQtB;*0hIDroC~XCqj^NJ69fQmtU9Q6{TP&u&%qevHVa2HsI?vHLlsPhsKpF)^yR_< +Ke>NBz&8D_QDryMj~&-xHR#AMgq^@N)8?XNnmjpP{2qA#sk()A_Mzr{PB~3{|HEUnT`_}V3W0u|Hu1_ +F>)-n@V9u}d!Vuzhc=8gE_%gmNoc!-SB-82?21$!ZdqJ!CiSgfJLsNx36R3Xh!UzswV +iY+qceIk=1pv9XNd+psBODKYnuNE>H&WKZ(1kEW>Xy +nYz>HFaLpmtp5=)hDe!8sH7LKQYK-`SPIzt$a@PJ09JqSCfPI|wv(PEiHZ9j)Doo@K_X3I{;c>$dVku +E5ZZ4mllekOstP`=GUhKLKL^`9UwlX8@x+hp~`Sa?rS|m#7YridhE^G^f)_(f60|(Patu@tAJn^Pd-n +^0JPHe!_9G1CqmjyxxLh$3Jwhv#5X{hUo=-rh%sFDHK?l|2Z1S4;b_F!Fp+s7Bg$r9p%@c70^s(3SFh +>ATDpPbGV?@5a<&T*ItN;CU0;Q!cB34+`lrmOS#DMD4KU*$Sf1(K`FZ8g7{HJGV{0n_AhqH$o9A9 +8TxE6hD(S@-7L?D5>!r)91b4(OL`7P)E7Fh{(swJP3 +RYJ?%SDT_fk@(5i3)cSD%Bi@5wp8oN$n3PBD3b#{xfOCeV)SPi?< +jpUqt)WzZ$4-B@YhNN{!6=N0}yZaulIH5qFnK3@9*koHKxKtE)z3N&Vo9#6Uxh&&=E-SJ)eg(YjsuIl +iz?*1++O=}T2dN$qDnCMG9vxGSc`RX}^3 +xOe3_wEJvx&QSocZBNyq%d51C0(+WBS{iU%5Xgml{QNI532`K8&V&Un9F}j(CSl?s?OL?221dKe0kv< +uIdykC#=s29vR*NoK-sF5b?d5)%f-heO&VnG6+YqcG^&$VIm^VDDgz^!PUbywXaH?NqmLoa=Kb27Ge% +h$CW4ieTtvyAV~d$?Iisjdyq@^rwgR*B+Au=%wSr@rZqI$?-)DN5==96Ldd<@S5MP?=zW)7nBCc<6&k +OpJBH1-pM`me97G8t49!6HTgAI$pxpwK$};$Ac=UGEQUIJ2u)l5&hd*wu!kFCMwvv)&8W&bstB19c+B +y0!21VS@t7jHjgCD{%jsvqqrd=j3V%0x84;pr-X1_~XS)~Te*)UTIgU2Qr|*$lLd}OQOo!a@0J +Ubv95P)Y7~NUN$kUv#Ff +L#9KRA#|aPTWQn6?-CwD?$4?Fy$b06K +1iMQ7kiAYI?%%8w(cu2M|C5K706O!P8f^vbYyt +WWkej?aHoqom(v*sEWtg2tLDBKP*Fl>M--m6pN#i`;-*tr0W~3W5p^6p4t8V0hK_&Jc+(iGCv{a%9tQ +_T07y1faD?g1eOo8oc&8E0J~B6TrV%HV_k7p}91BG}Ox}gyU&DrhUcyejbJ@O%HPm}+4hnhd(i|EaMA +U+wRv$)ZnP7x>EsI)<#38u=TF!K&VU;bwP{}FrIgChs9gp=`h6x7Qy5yuAc0LM;Xb%sYPM$i}N&;8SZ +8Q~aF7x}X(H8C!nc8CZjBam~7Hbme3-SemYGm}T$!a|e1;B8v9YAnb3VUNK33t9G#eslMl9|{SXD9Kq?uvt9IsF*JQZM3MjJ?0++|w~x#Be|z#G_HP1H)o< +7@E0uZKoA!eS6J=xS<=5+6DN_~^rFG4y)}Hh1`GkzSzhwYoR+59c&B;h6w@KIaq$6uxKk(nQ{koH)CA +UqO!;Dibt4YUUiPMqpcG)-uL}67NPkDfNZ8|01001)ZP#a5C4CY%mowu=2ANFdE8yqE*W7qoWViEA;m +a@!|7$xzuNIh1}Hb*3V*@K3^ocnq@rMQ{B~MJmy~0emjpy!O@K&L+s)&M$cys%RUrGZ)IH&`imlZrP3 +tG!0^1HOd4#}x1bkp^Gv+26nah2?Y+)6otq32ZB-b)BJYOXy6EWMZOBME%trg(_b+n3$IXuwm}u`Xmj +)Yv(r3Y*Bt&*72-AD8{=${R3T*Xtl^Y$)hqft04Es-pd;6l}{Da<{-t*Qi>aHj(Qt(jb-Z#H{@>}u8=nh|J2X$T_V4nkQ +_TBqbuiz&Nd@R;k1Ev%>4T$dG_N%$E%9DpTR%ry95hkp=E0t8BZmyfEtCOm^J^+FP39;hf+3%k{d-mk +nAD%rsfXO+_)}XVr$y0}X*KDJxh6G( +>BCuWSn0U%V2)O@Jck^l0tAK3O4Lc?M>@s=8%?YUnW4B~-ZQ|RDhBv*E?m;0k^RsWJfM(q48Mq+g4Id +dT_dYg+szkP)V8E6>d6)Z_yLVtos!dkjUVnU8k`$A6wBHoob9+ywFqoZoMfR*ft{om{h{+WO|XbW)Bn +vDHYEhso-Q-{p*y5BxNISc}o0Z>Z=1QY-O00;mPT~AfY+=~53Bme*qivR#10001RX>c!JX> +N37a&BR4FLGsZFLGsZUukZ0bYX04E^v9(J!y~IMwZ|ES8!v +83jhA~ig^tu*?-?>p+QqPiVy_7GsVL{`1JUcLKO-AmqFh-A~&b$eAc+hpDDcA^=Q{-Pc0GC3DXCwA?n +D3bynwmXsR+X~)SO)_A`aTq(1o!m=yhyCF+>4&ab56gBxRBcn#tEWZXi<6UTw{N=vN;m7FZR=h=sN3x +pT2((={i44ZhpN`U4*JD7R;Bv>TeaU*wK&;y?Jg0`xJ%@VGx*L=p(FdE>xFvr_o5y}&+mrA9!D(SJZc +V$HSYzK8$rBjJB6&85t~js7B6(i*@cV@v*&=x@{yBd9+yv?fluuCy+iwyD-dUHvBVrr3#NH7}txm +;*h_{PQzv@FEpGf5|T=0f_y>2Y=44x?;b#M);B*|J=489~ZEKoxK=e>cpb&>qizS#RuW1z&RwID>$J$Tmi12kRW!?UhyJ3tt*E!GG5;%QOUuv22d>ULc?u(o2z`}Kv`MT_s +mP?W_`sM52O1U^3%y?9dL_B$U5f9WYgD#fN4>j4L@2WnmdLcx~o4)85j`RYQ5+Iu%Y)~oEiFuUz3>`v +IbgV_CwaH93vQq+CM{m93zR&}4ylegWmT6NWYROO$;_gK*u@PwzA5g?eqt!S`>$kmI_f|84}8jwH);M +9xX3AZNfaThu0D(;xzp{zQwP*#f-qh_Xi8f#M)GUJ3M{b!%uqT7&sYD4A%cZ5br>H%ZSjRDvn_FelAz +^z0xp`y(7(|l-mK;3u6M`1nO7sEvi7|?0_myeAagarClJ$MNsx45((x>0tp`!m +t6Q7GuK!AFFcn&ON+#}&qz3%sQaiD_y26$g|y<*osF6L={!iRVjHa;j&FQnRwqJDuzY9R2$c=(cXpi_ffsbShE<1$>@kQ#Y)Z3 +tRt~FR-wK^~eUHq2RH>Z+L5d_=VI|Q6criEuIN1nI(=~A!SEg*T%1qC#xkt(U9%| +RU5mtU>e>N9YOKFPPCw{$Q8bUy(k;fK4>+K>&*mGg& +etz#c&h?K#qDczjtEdi1&JJvWuPi)db3D<`)Ut(2xc8yBa{Uai20vxXVN|8=Lt1Su?!$ +sBrSrl-2<& +vgD16lz?ln%?HG-WIGleaDUhnC>DTJ0f>hdD-b=}`VyoH_yQ_%?_rMupQD`N5PGSK#x^|4_t;9&9PIu +9wih*Q#`3Tv=@qvgOP0cGmFPpRG2o7fOUr?npnt`&GS-AzTNm{l#FLyU1jR3q1k)G8%4(>E^3IVe*G7 +__(f@Oly%-WN&p&118w+k98#PQn$C-Ld(@ptgXCszwwMu;x&pj!{5w$nc?ezY8cQjfgFGE>(9_qsV-K&W+=I(~W=w8&oCwag7tP +8Ea>P+y)i@r^3inC&XO4B`KOEQpAh{lrN#W{{&FQe}q_{ynF9Laz$SN%DJmHQ-k}`ryZ+n6(SHV&F0Bgl3c)qR%kW%oK=uy@{x)Vi$drBHYshe +bv$IqVuobAZA__j+N+dPubeu1W|cE4|X;y4Qnn#i^pnr;MW-p#tgvXXWIBqQnitjLl1VaU$!6A#0ro` +t9-zq$pq;rlc&c@s8=Ht*ToCU;Mvt0Y-G`12wv>0Jpmwe(uq*RYVpNmz +ViG;bTA8J9&}mH0oPH_aZ>G7B8a7etV< +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 +C1&QHms%BLlOT$h2P +;Q+e|J!84x53}QitHt8>|%tJz5kml$bOIaID!S~fj_S8?!*&<0*j!|maXY`UW%;RHPZ?=EzprC=@IVz +|*IV^ZLH7+-|{f`=)>`f$b{+8icqFN*s|A-#?97?k}%ngM^SC?g?;(*V!lequ_HAw0U^5m#=BNJx?A_ +8fGz)ECPsRkxvA`nt6(3B0O6iEupLdkmQuB_H$U34VtYe-f+rEXfqLyjCsZdv`5<4nibYB+p$j}C1{c ++fFsKK9Q;%P>MEN+BtS6;QFW=d!B9`7 +cIr6XQw3lzRD8{XRSErDB~wK@8R#luWHl)-?Tb%BsnTJ){{ +~**}6%HRj5kreHF1`=Y6a15eD69Z#W8GRUpbLX4YawXrxa3X`OK$(`}l!w26xF$fr)ExL+Sw*V|XxFC +mzM`1)on^DJGA^7jU`&t9WusiaTsDxL1kZ2-4rLRS{RuF)RAI-4_md0QL|O8>Le-+e2 +n4})#u!W@{?Hq>?DwH$XCA;b++Rd1awI&0b&kNOEM&xZm@HcPu?#Gcc@Tvc6vze&4^uNgCeR2AoM)v^ +6FRaR&n(BCpYub>jw;W@+H!AE1=WlSmr3?$K^)r7^`WV!yddt9lh2cR5GB7e>{-IoJ5X%5OU&zybHBL +YqhHGmA!Uppix{lzCgp%`EmPaxAEm=hg_TZ6kVdWE668cMS(HprD~eRyat1}e~mHgwQ{r@t^iFE6`4Njig6^`-l<8#=|Dk3q4HS}&>eU +21^A0>uxMfEEzcXa-oOvy)U46h?X)rhP55b-LZ^oY{EDu$#4H=T|l*1fY#6QSdQ;|zSC-K`5b>0+6CV +lh)EHHk8#QhU87%>p6Uc+?yMa|Eje<6JVm*VBS#;njR}F(`4J>QH|k7^bTa4#hRQi?iMn^$gev>65J!gnz;D3iJW9*OL0wWga<= +rSh!>(->E15Y*Ogx{eeslN#VFB{$oUMgQ`fKZMv!`}STIvyz%jpK;A|L~ +K(((&tGp!zxvw(VCnhQS_DUKT!$`cjS&8z<5v?B8oPB~{o7T71(d9iOXRYPNP4?Q4tg{Fb{+5R2FF;RzFX@W +Chm>mt8}!IvC|tUr%YW>C-;8L-Re%`grUkgB8mn0{9 +vE!a=d)8j6eTL{Nv){?m?K(2k;SIj4nHvGkYqK}h;Wf&X6wh4M?o4O|`9DY21xy=^>_3IXj?6oYSlN1$V@kp;5OSNVuT +{)d+x5=b2Ca;F!HBBiJ|0`ghO~l4C#@xHzWe***O&~k;DTt>u!8gC^jhOXAH~~7XBMjJmTrzY^On2fq +AE+#(23J4ePrxZhP~BL#s|~+d}fhAg_QxiKsIxZxOiB7ZL)OR{jwI9qDD=@-8||%CO<|Uw{lMLj@`~9 +?Xn4vF&KhxA1CS@M(n0FSe6v+nZIyZT(TZJBs{gw?TH@(r9r*y+T9-QZ+y}N-64QgV1ajSS#fF6|1=@-$%-@ +nR5{VV~LcSRcqt*~)lf*wG6=X_~WQz8oyk@lW2uK(Shig(Cgh~hPC$ibRNJ?X+`fm>03FCDq63}#(o(7x2_O1L`6tZXO+HH3w)$7-tRL0I!RC$^;bl=bOEla-9NvFvj99u}|>7=>h4Zj13 +YIVyE2obQnc62)nqXL|cNuR&vUZwuD;S?B2_~kG>!}Y^4t(r*v7nNwNKaGPf%G;dhzN)gcAb60z@=Wf +enh72hjs?;wnlzP?#r-(;{L`lt;PJ36V7&jWBVWUx{e>{eY5wU>Hf!}Fb7qTd6{$6k9U+eZXlx|Iib8 +J*}tg|cK;&9@*T!MJ8u^J*_*zNB<^KBp7%p-?eD$5Y(n=k+)pjcCcUw8A3*uJFHe{I5vo$E0IA{!`M}+0C{?)lbDWAGi3TxnKcW +aAZ;HzPv)ZEx)SYLi_s$!{e&>OP^Xz5*g4KF9UWw}Ao9Y8CshbIcqLMGKqUI9(glLT)SQ}mj3vKYo>X|*VFGDHAt&e9E(~TNAog=kMzW(&!>`C&&56Oe?P#65V{qw_z +Q}rcoWLI55%&#CuoKLxsP#fSNNa%_%2>$p3W8j2}0z;1;5K-&s +NY#aPYIAPvAy~#a)XNmwbhU!NcEhAG;lmSft~#am)1M$62&vONbwH>Rz0DeSYl0T>}X29{(`O(myM>V +IE?AaISeQSHzd06xzfQ#8&(~AF?mfsJs0l=^*!#H!q&NU|XV$eg-@!)^tWRnfUDL)R=QmgRg`*cpj0` +ZDDEEX0&ZDI(k}{u92&+x9@ +iASMIkWaXTT6QM1Ng{<_quuzO|tzr*jzGtzuJ}0KzMCRc}-DI#vo~-rqEjHCs4cxPi~hnO|1ol+_NeGlfp4&Cakay%8H&;W_yiZ$VSW|aC}#YTO +$EQwCm95KU}oV^#G=xjJd))j^*J~Xd|M~UK(hD1EtoIEeLYq2R~eCI*2rS1=eIRDt=5tS*&U%FyfS5Kl3k*N1$1^WljYp$r~oD +n>Ow!xvV}@l3Cp**i1->_&Flf+#(KrmdtY}@^=fx{o~{!q~*6sW&hK%lj_$Ud5jeVMR!6+Z+%9SI=qe +qg2YIBByov?>i~k^*qOSA`i`JOu7QyK`$QrY<(_gx!&z+Cxf0@0@-RtR?m|`Q%$eM8G!{Sl`NZVp#5y +*jp>TxUT-A~fhdtehcpACw)OgycBli-{SfX4cD>?xU^4#lv*8&g5lk%iXMVdO5Q`QW~D*3j-S7jKHL5 +E|?11|yRtovmcxVoh)A|PAfrz1Y@4&S>!%!2;dR8mPVlsCgwWC8`I{&5xC->EJ@b}^4vbQOyhvYNu~( +;;Z8|9JWU296>t$Mv8iW%VH`5zmSa)h=|nqB)Twc|n0Jw6Gv)VPjIvh9)DxI2}V?xdCcVv0j7h(hMqY +4o^mr18I-g9j>#L#GIMB|6B`d}oYB#q6`2@%M)BpOO-=wZSZybX +n^JyckU9lmj_%R}#uA@;jF9jqnkBwP;!VV{(fE?Cym`wPbm!WXMR!@=^$36GOl)~~HFNIQDB8R{N +Tq|w_utx5%+8u|CnxgRFR$M`dj1@U*#r9h>(6Ir`0E?`_2k8`zdV2O=m|Xd)?p=*5oy^;owZH1eDspN +Jc?pe2J-?>kN16X;u%X3twa4Hg6+JZizM|*OD6WM$)=fFC;if%@r@lE)N(`P{CDVT1#Y}zH&I;>6s#%W +THLLITgU0G8=oFU`sa!CVTN}cyB0K$W{pUA0_kL(mwKl5}c&t+Wds{uC@mIQ;Sd4c~w`#K^+dJ=M +XU%{lQ0ZI8&Prw|is-9ojKPzSN}qdLE%x{H)CB9E)cNl!xt35wk3sS@PQ3x09ul+Cz{+F(vLWCQXPua +#_6&;YH6Hnm%PIeyS1XBEzzQSWN-jw|MefWJ$ +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 +ShDigJC`DNLV};;`zHh;Gxn#*eA=P##uiE|aS +&PTmY*zoji$_!?@%6iN%#n6)JzuO=8j)J|GQpk6Gmm8=W0x=`UlUu3fC$-DWZ +Ap!DFGp-`lsNI6k@6o{BW>G@)F3lG-7y!Jci&>LnFl6_^pkg*PG7C=9D4NCNacMsy1=>c5;@O7!E +ET?h;)#yRC7Fkc?bg&P{|)4IxmGk@xHbt8*7`({neSH2sdopsT)n4Y96o{8^rCN}vOyx*n~Lc0w(T$+89t8nMUfgn;5j^Oafj>T`p?LZvTOo +4gG*g3>qJI=!fpwU^pfA9vFH9C-AKzMVYZ*#WKoQ0))sdkle4sb9G@*r?P1n9x+V}!6HAcOmam+T<$r +VjcAfXU^RM^4 +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 +1qa09glw9oQIbs2Txn+OU=WEsAUB9N^cOzJ0DQ +<|3Ski`c1v|QH2#jXY$BTXMg1 +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 +k$>cy?C3`s#CkK78%_WJa>f +c3uGhQ7v6nTc-vV8+b?qMc{`s7B>R4D0zt0e7@$^CFXTRFH`cJ$mndJ~sRyz5DY;AD=3}I|TPVk2yMC +{&z0oLEzgJZ!5<3$-}T9JCWV_s;$?x?DS=kAw-zZ8vU}zLyF$ +Y(90w&NZVEty?F9>PRXS!2Gz3+m* +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 +%^J0RNjTA>6Cv#(RF2W%?I)e +0GnSD!$>1;f9$x$B-&b6Km9yX_=qI`sJi0}E1aXo)8ZDy2%-5v^a|103H4**xhA?rur6Sz!WfqOl*gl6PmZ~Os&l5zbxI)`T +hXynl@oc-KNwJyhCbXg=I +h@pX5=9;q&f2gFy)l&N(B2}XePHTdAWFmodIfM34{_CmpX@%^lMbW3G2?@5aXGm`CZ0jg;RvBSJy5ggt=z3!|{vW*By2_VOkEb2huft}5#8C +2wD1Nv#-O4&AO^ikEg8SN5Ovc^N=@vEmh`bgs~$yK=hdnG1K~{|it{0|XQR000O85nWGJDb-rPyaoUO +NfrPAHvj+taA|NaUukZ1WpZv|Y%g+Ub8l>QbZKvHFLGsbZ)|pDY-wUIW^Z+FWM5-pZe(d>VRU74E^v9 +}SWR!+Mi9O8S1go6q(C7Mm!%75uag|ztkY)fYMOk +~2u{`+l*1t-U>4psX_*m+;g+b1h%I+)mf&YNHah`hScSMtcOut! +bfpmGbH~ZkW-cx&R-39hw7I#stSd!PP*}+-PPSC$+Qe0w-KIBeXKQ?OPx2*7_yHJE=%aURj57JDtphk^tX}If_-h3dMKYD&1A|));LT;_2%*XFsF +To(jGC6J~Oy1;a`_*`35u&-&Z@lX@g1} +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 +93k@h~2=tCJB=hjgvty8h-%NA{j2w +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 +VL-u({o2S$36%m$o&oqeU_Q)Q-YxV( +g@kRGBlE3iS{^0)jcup8M>;u~J$2pI@gA!o305>mF0J~~3<5fksfmKqxVazO((o +<9Y@7AQH-l(_tRf4~K@qbWkr2FXN0Nv#xZGbyr`mXVt4UPRt^{%?4F?M~vUA7)yag&*_dq3Cx58*hU& +wmt1E|ftAfCu)APk`k?x>YvV&4x1`M_}{=W4VaNNQtBXbYUMPVTENb&?`XP_S~AOAz@3CflP?Ay{KEr +@QvW8{?488NzEaS8RsDY*rSlUy}@MUUa)AJ_G+j`f(UQ~l)cGK1mqw{@N5IB+@mnw99e +lRVHvswO+uS7ZiaiwZX=-)>yE5d*o|fEcR@FTD16rgyEaDPu{NqVnB&O6!ipX4mob}w*I;XPFB&MZyx +*YsFzicu{^c+si@`O%BTc$&D(;QFZe{aBkC;Jn^)2@jYMM@)`QRh$QDB7+&KR6&ig^Z7ZEFCV)M9I*L +T|;i0ynr?hMFEM3CNw``k-T0MP5^CEX!lCfshqoim*XoM%mX6F`eNz|%NvmTVWgL0<$B{ +LITF6a@w_)>uvswun$44Uoj2i<6z`buaw0l^freb;J7Ib{BT~fo#_1~1DUc#y_B*ZRt_f}g;0Rvs0V@ +?ioNM9_wpWjAj(0e7A{vM_&m}}!BLX?_BbGDG4tUQ{=u$-b$ldk^$qjh`BeCtI>PQygQatwzBV`9+5aa@rM +c!2G3r@*>5>|iFwfX@}R0zAOhRMx{;(a;1 +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 +0O85nWGJ4;ZV{dJ6VRSBVd0kc8j@vd6eb-kEv +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 +Mym07ahuCAVum;#BXhjhaa?&6;cZwtTGA3q +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 +!_A3Fbgx!ZZpxNKz(BSyV9xe#4}QrRu7LifaL +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 +CO-52 +D#pq3W79mds9dvZS1o=C!)#B{3|jnp3L;zKe#ebL?!Vc{Vwrx^Me)GFFSi&QxoKYM8wEok_zd6H&KHT +T*8KWO_5Hw5rMWtqU8LZ-QS+pSo7UaZ>V%wo>H9=ALVVj~f@F*~SUYem&TK#p0jm6T)Bgkt3zX3|rRm@nfae}O&A?57ddY#dgof^WCDU#e6lH!ibKA>6U*pO>=#~Zi*S{N +5N1A%~!Ak6Y@?;>>ubO{78mNg~QC9rahO$D%4GFvHKQ?1HQ^7F8~v$i$o^Z8cTU6&*KdfxVSrY{^ +wHV^Qx$pDy03K$CT +rMssLKB>>q9LCV9UN!;n$`W|$8m|{=<;^+;rjDtef9Qo^X2`=+pC-FC~}fzt>vnlx}Xr!xtvIVKI4O1D@4KBKbyP_e@BZOHMJYz#>-Cy@O1 +$EPJt9;XQ2XhfNV0=cS&2kjR`BcmJ&^0=J{d^Ro+zGgypEc;!F%N*$*`;A+6WMB~J6Jptv>RLEQQRN& +W8DOJmx`1DSZsCLhn5?j!->R?lK +!Nai<8n7GD>!KUtW3|3V%v0^Ew`KTIl}W9T6WBEd~{FAKc@L@U*}35F9=@h%*@d!C}`HocMY0%MIR`NoXJdT(tgou*K5fN~95Q4`MknOXD;kJ`ZgH!uTxlF +-W3?Zb~7~U9x&Kk}F5CPI;^ghEN0&D8t`+x$-`XKDCv(6_c@F4p8CmKe{Dm$ZDLDL`vd*ffgJ2Z0qEW +J2MrXC@l`uNk7rofmcPhn59SN{X-8wZQ!x82aLR(E!X;~DKjmL<(*`z~;cZY6%lbAdkp;1nG5Wwn|um +x+Jyu3it^jBb#H?HUa26mz{`7}|uJLCsm?G>RQ$g6~*|&S93h0)JQe!SVsJw&e|XR{-1@dul~Xud`*g +@}kFarh@BmHSjkJEW10SFp{&<-y&|6?3|*XlcOM3owN@szOPy8+`SGtmJOlzG6XayVkYw==CQc0$^Bj +O>z>H_i4sMhaL0n^l^~d|u~EO{C)dV-z#k8NYaNnHY-nIZF{}?mI|+S`3{W!buzB6ues4W=8g5+746& +qAcU_Cyn2;vhXEjK{cUpM-3cPRKr`B$0K$e~juQ-Y@UZQYcz`gv4g-3$f6U1cl4^T@31QY-O00;mPT~ +Ad>gfX<@1^@ux5&!@l0001RX>c!JX>N37a&BR4FLiWjY;!MYVRL9@b1raswODO$+cpsX?q5NuA1VWmf +VEpOc*w9U&01q?Qlwdj!7yxErfoKosFGA%qv(I%y->1bIeWpj04*eneD1m9bH}4~UK;DgR=RDbmxHx6 +x$yf^7aO7Z)7|fHujZGpuP%R{T)!HLA9W$^esVJsFLmliV&avR%S?^LFWSNTP3g5MWHw-|QkThG7cdF +N67?xn^xf6yufgye?Q-eU?WlfpU>=YQ=Vg{joPTAlv8NC#uQQkA+NCw3RdO{?w^ecP1_QnB@*fWb{1H +xYxn4F$+XMRiL|mI&b!#Z%Bo1;b03-tVMcb=^q@KV7`Pxt-iy&0k-< +do9jIAa8*7-pHqn4VeXK%26lVJ4Og-re2aT)!f|SMPxFw5B{F^3T8hIy`;z)w5^@ex#XnjwG +ra>nMt%3$e4ZEGdp)d|ByiFdF)iS9tHGqlXFu{$*J>}lM$b0vl;ky4Z#_Tv+wDFx!2hB^SG2&<_+Y9SOFI9S+iH7plvJ-N +IS?J;_DqxqFrpz@NcU=0SIWwyOS2{oj(_!zchn-UB?VGS{Q%Cn9>0f4oHo}z1llWOJ0y@uW}a;yOTNp +-pG3pc?C-0(2{6mwvzzhIG1B^2b80P`dCRyQQoLw4=(VY0tbvOuaA+;VJ_}ZGCz1&$EUTEpoL~54XDA +6Ma1HYXsha%aXU5`5zsVNM$l7C>qbG7N1j`*VAsY^a*!fcfSLdYWwI7ZBS2jy7)F@o2bH230ZX)1P~% +iyLO^1js01ibz*|7BRH^v{ +PKT13${!5=sPki)vaLtjxsHou*l+U01Y?B7?egFy1KOv^F&*7w>7&l}um6sllwPRObUQsbx5QAQ}${R +nu7WYX_O;&l;2vE8hAT@P-_*A4+SWs`-7RSWe}6YO2DMY)Pe13&zJ_uFB&~6>&)ZArT8NJw6GOjfcZS +a%eZl&8erfs@)uG&{$B3gZeUOR2m>UOJlN5eGBI}oOYx>)Zs=ysG?P!Q0X<9c6|!o9L)5&ZvOxTCCJc_9TXMx!lhhfx+YejAHJ=MhmS9kH6Dx>0Q%W45QfxI>a5AI+q-&T7;6 +IBsqv|1^Chtv|~&^afn-|8;h>j;Z8i{LxVT+u$ZX9!gx-L%v6pP;GG*MBgrNhyihy5NE|C+8OoZQ%~_v>>gC66K;j=mO5Z+3V6;ceL5o5 +Hm|G#Z_a;cJw!_mXlEt%g>#au9sHsfwL?3awbqAdtFLU&%uV@y80rd;15ts0|XQR000O85nWGJ*MAYCq5%K^8v_ +6UEdT%jaA|NaUukZ1WpZv|Y%g_mX>4;ZX>Mv|V{~70Wn*=6Wpr|3ZgX&Na&#_md5w`#Yuhjo$KUlSZt +hD0nQ*qZK?~c+pwQW)PWNgQ`#fuvb>2x%ns2|e>tt}!%7PnU#UzRpy6u@V#XQ_)#}FYyyXZ;}Y?Ky_)jK$A5(rQE<~1K2+F8xSn=5%*3y2T)@{BtNQ?Ac^<%8r+R&63Q +p%gHklO4pPSp_I?u}N?)#U`EnHnf`mj#ZRQ_-O!Pqc$(A!>@d-OH29@sg%`=~4Ok?ro>#PcaWZD{eNq +ZQ=E6f9r&ej%ghH?lrbIXf?w@_uioP*ga5z*OW1jxWj{8<0}DG$#GQWBq8wPD#NArt +m0fV9Ux$FJUBjs>eDS#|LD5R!dt6sCQ*i>cSlFLWFJE6=osQX^s6GIREpj^R7R7qQ9YHr|=Wj1=u7<% +=u_?uZqipP&x2GR3Pv4wepIw|MKV7{~;O*VnKZa4PrCQjvB3E@Ol2n$X5uPAX6|V%FHp&h>Uhpi8Myj +4~%3>juLO?hZK)LgU0q)d*6lD;NMk6u?_PQ)SiTtWci<-az>uFgQWqA5|AxO=l3290Y1X^RbR3c?^X_ +kJJ8$l~ru~^ilVoP|eR)Q(Q312|$nr&AS&|RhK!tE^E*t95`SXIlGadZd)~GoN3}vVuCGr&eW>dvU4Kc9SHVD>A42Z!0yk7plGCkD}~sy1qJd_1r3RJ_?$t0Iq!^6pqFRg0H@`SZ(H&jI}Qn?Jq$&K@c ++oHFj6;T_MEIfNOJO6H(B`9dH^!6#kO=_3Zli2RAk2{W0qke*_FqA@dXco@`|zc%hWHjitbb2K27Aut +Q971b}y>-7ZQD^S8$BogNrXXiyO#;o~!+g7d<8zY!Oje4_Kv8~K9V0^6vsTP_u=+*|*t18%Bn9V^gQT +cejBV-7*27L!Siix$X5CC`~Q&>>Nt&I=ZJ5pOTtRuyjqS81TyNmT6+PcZQ5^n@-@DcE@rwn*P5LLNrW +VVwcOX+PX!3SjC)BvUIe>`&Qere2pLQHS)>jhezvk&Aq}zwF)oTS{R&93$m8AvAt&P&5x}O_djncSrV~c769@5q?6?>;5< +?X;HiXJkRv}4@Ee+Gs2|D;O%f!9N@`B8sI1i)!jK9=ssUrl(d~QiE4x?|kEJRsUk`TI$W`^IwGYaM+tk*!cfVSjj!+UO40^-Aay+hg$z9nFrdAb@al +l$fy_!O|lCs$yG?c@TQH4yLRqKEWYB2^Lt={TyS$V)z74pJtyErrY&y10}Ct}q$njNnVwT6X7npfqm@ +%~fL@g=u<#tiv;`O(rXnR*0!sbQ^Wm%{%?*uT4eg$1agJm5&XC?!8kL>4b`wk +>~Ow6;>IEsmS&s7BdqQSDvv#*JP7Ujn>2>zxbMX=%~t3z$=3@*7TAA#SQIlhp402Q(Gx%{w11$7H>-| +j^_l^RtL&OEUHk;m`Kq4iF$x_tqiChL-fzwt2VF*g#7!8Y64RYhF)c8Jm=p|f4RB1e0w!}Mnw3E`fNpcT^vrwO|`X;@yecGwlLyv^W)jQ-HRRt0)?jiHXBpF;I$_8=|T~v-S%& +z$-Ov1sLE4D4lPgnzO1ACoXrw&OalpaTM8&g7i +F(mHf#scTSKVVtNYhZi{KXYjY}A=cFp&aWD;4#afu6FQ!(PN +51Y!Q40$-Yo}ryl=-pvxx<`P>H=$@d~!35p1s!f!CHtn*}U1Gg0^V&5 +FjfJ%RgX3h|GwQz9-dIZ$F=(UAkoTG`d+<+mB}saXQg(_y&AP$vYP45L*_@+Sb8WL$U;%VlRMb&;2S> +0uRQIwZ?g480HY_PN5RQ-`q~NV9kmejs13D~JjG0CZ&pC$zfp|IRN+5n5iS}}JmqgKC%^`l`pFg1Q(Y +Gq0{_<&Sr*Y(`n!Z9OQ9v>X0?dfMy*gCme~y7SEn|=Vj-UMA+svH>Tu@f0LigFb2kLY-t@i7A-E0ziy +)v6Aol)h?hbM_QpfQ@ZU?ihtK +oH0y2@iH!t5#%vcQg4Z_4ihG{bq9c_9_Ex|-*H~-OCZwObQEjnt(|-n+=8lY^_*EkxT9)MXdQR6lR-| +uFU;q6*0Z}w>R=4xX&T4b(HL&hzcwr|u7((zg-IT%fE&m>tfBWR}HQ(RDImIWq~1P1+!I?o^rd_e_C1~CyUB7@Fk1lX%24W>8LV +50;%d4a?#H;~%Wb3bpiTGL(Au!EJ;^@0qwyNLPfbl6o(LRM^FbnA;7O9*$TNyjE(b<&pN17XI5Wv@7sy7R)_QFJu?rUkybk +=Na*b=*-7yx<8qSE1@LEA8ojt(A4;eFVIy==Eqf>f(+B0funM>cot3P5{0FM$qoINRQVCQZaow!F--h +tdm0kYV(cAljK!Fz&}gS{_Wgo_rtrVSfnfNYE?bT~Zake4ZfMU9CMz7^aN?z4zON7$=@bp5^BANqdZ+ +J=xqJL;FKlW9;3=fYRtb#}h}}zq%cuUGIj>I1Fv$LiHT9kKyJ{6uW25y~6*RFamDfY`_}qt$s1%t&{3 +!yY*Uw$8)AdxnVyHIctFFIPaNt*tbI(W-?z`>RQSDkk0daQD|l(&k*{?NzMAKXx!te22okDqU4OKK2M +uEvEWHQyXgJ@$7_t$zmeC!J6{i=+B7VHLPl+X%Mw#Bx&g91n1Zrc`;$ZaJDDC_`e%=r@wR?KW)kCgSg +Ox)%73H<{U%vGUln|*4ur|y-(p-M^t7$$E=N(ta2iY!dz>nRBa7KwaO;ExrNrn*`leK$l?Dl)zs^ +yHd=ea3ZT(HF-6D)V~%zhz}p)bvQi3nBLL@%@_Q@z=onSu4HU9rtUO2M^7IpXi!Ci(kf${sT};0|XQR +000O85nWGJ{KDw`ry2kNaZ~^R8vp4;ZZE163E^v9}JZp2@Hj>}4pu$^pXGhXK*@2V=XUAB^3POIW_hL{;f9FitTjV3Pr_v;4$f*g*L>?U=!wW*YbBpQuIqtP!k{77 +7`q*#=BUT(5tDdy#REsI8|RoUjLm`PE~b$KgOk-*1tEk#vk(4G~d!H#Xy)-pPHB-Yz%I}xg>vw3q=R! +vqGNj`m<xnw9yWR +&A5z_N_@8`@FTi+B%0}qAIC@)J0vcVJM;7-obo|<;83Ly^(cOmbo&`i!6sv3!G#q8VP@X&Z;;si=|Wz +_i473wD6a8GMBStesc+5Z9DQ^1Na95{`;cXhV<}dRwVWI;x)g0mE?Ic%cXu}W`3I#$x_z*?Q38@KmAn +}vQC;(H(UUjT~~UuZQo={cY3Xtjo&T-yBYejtxRVmy?gpT(OBjQVhIj-R#jF-@vSV%Ph$%(G@|depM1w;`-vS;ff$NRLyQC-7yHWKF!t?qu4HYC6S$tyVCbICe$=$(1!sFp +_t3Nt3lp^A!kwQl#f~UDjhg@^YT^I)Jps>*S}hj@MZMfAx4{eNhNi1X~Ma({%sg;?>u$e|Wba{5GqbH +pyjiYZ=iN1;|R=7AY{HYd<)MW8h^Ri>bJx#qjENQ%mXb(s*g6D&Sa*Tf=-qDQv4a&1&-{Q8(rhz%vvs +^S&tSb<)Ht``O~m6c7wMibc}JQy_2-puO>GSk<*u<`ubD)#cK>&yxx@NgAsrEn7RVEEIfov9mggleSs +K$h#P}uW5rVvB;K)W+-IJppxclgq41)}yU%%QmtFnN{z>8SGSo`6B&h`!MM+bHHanCmN0|p5+V>+QUh%;CUprQ9ZaaSgaqHE&c*lICDJymhF!b_tA(hV6>QvyIX3~Dlz?^^68W2k=~z|P;uQ` +EO`D;J7qdqK12EwtTZn%Q=>3Pt6bw`x;oy;_<~8^a^(I5hsU> +8$V_VEu2^iB<_*o<)B0q?Ftj~ym;X(%DbMa)-Nlw32d^{EY6LB=!GZ2r3e-g5+%X}aH=MUkZ4!>MYo? +Q2K1DZ?UbF>0%vEdk6bUPjB;|?Pyi{uiyVdc>5!*y~a0aS@i22#*A;{5!7F5X>6hF@SyJG!BhfhXL0( +xk=2>vv=fMWTf4x;zp;WMHN@iln4YU;#mz+Bz#+CC*>HzC8c-&E=2i*p;=4#5<6QN1r@B`=ncV;HZqq +@e?0S*#nH2NRYR5q|G4hh#*Gd(5~78YckMxy}4q$qpxP5u1V8@Cm1F5^7iWFI&f(ucyM!lF9rpZfhLN +oEh@sJxfcvb;Wb@&9}tJgt9UPt$hLbHT7suI+80N2neTtmfa^JH8%c{0l0njs7hwPI=-HuzJZA +@?N8=uVXZ{xbCm}(!wy>-7g-{Y4@f4i?TC^2vgD3iv0_aQQeGz{Z_hvzuZ3QqpX>-tl@(x@CfXg)?MF +VA>fmKa%Vcn~P7v#P9wIrzNW!*}4<)%Y_&VLfHOE>NOI{zek76i1!?9uojs3ok*Z%a{diB4*&1! +}3zVG1wg(1w2AE!iQ<#X8q!9=s1_h +SnVfaIcl5C=#)R)yz-Um=iosb9G~SX^G2f(yjSz{e3|8N+J@#|7FS=u30;Rv>KH}^Giw2v3k#(a` +st_7fJ&Xf_{;@@-WYtrIG?Ev20D>=9XuqAFftXyonvxO*%&0CXauf~3LG(mOXUUDX!?>3ebO;oBM|uum@@Z161Fc5eSQeMUOjXXc@|#8O*`ZZAmtIKAx}S{3b3+P})`7^ +yas#x!;l{L_JIPGQ+S#P)F3a3Fg>j8abZp*mPgLjxS!l`R>wnGT6l0=+f^^Y~j5!qioPuy93|8L6`Zz +Ty$XKo8ZsleJd5Bn1~O0F87^x5_GHjPpl-&>kD;5;;lOiN@*a+ZzUQl+{2Fe8zlh?p(?;Gm0=Bw^J&L +`J?r4=K}G=*{L2vLF~W3ZpwS+LU$r>&Qrif& +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 +iR(i6mw$yg5*I8t4#}xCCZO +W4KYaw{ChPwyYk-;%fJQ25<`Uu9ty{OMcLd*PNYO|HDJ=jcg%J{RIMgLsQ^t8|%9Dj_>$^VBO%m+LzjVFE4voi(Ed!3WE|>OTezC~^P)h>@6aWAK2mldXPgTK8t)tKb002A +)001BW003}la4%nJZggdGZeeUMb#!TLb1!gVV{2h&X>MmOaCv=IO^@3)5WVYH44lKth)uK&dZ>Xdx(H +ezK(PsuJ$12>XlW#KS0YuC@~-pi`$&CQankr8+x&Pl^XAQyYCB^+RlP2}F^x;qu+W&gR=S@4T23l!TJ +on3t2D0O^7GxP;|;yTs&oC +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 +jwr@7`U1xI`fdv5}wbcK6R-z8(L)r&x98MhV_ +3@ytY!BdZwj|pG7J +}Cex~cM>nwOVZa^d5`5(bgvdjWU+30v)J98w&$553%pbXRE_jb1ie?NF$^BlG5*kYNnAT^nuOacQ$LR +xgqPREbeLJK6IyBYCFr2^l9|xZJ9a)^TD*TYgPh8d!(H8a;Rn;Q|eWK_L^@&5*Pn|YxGk;puIej*Y5< +W50N(qC|;LZ_K&E^pYK;-+z)-?aH&hW?%JO9i>cxfH5qs<%N3c`QTc`@tU&Mnq{j?F0KXTmNLiLisx0 +x%nW1G@u27GaK53q&BHt1Ijm$>|zaugfTfzaeUstnr4O_D-OCnH3gxdJOYf2QLR{U`s0vet){Ou<$u) +Kr<3}>^_r_ChHw9*VNsEOS_FEMY(?u3m$bH*>|>E&aql~qDFiwcWU&;fiE2>18H~Dj7YNQ&iMN)5ZGr +e9C=C>JW5XY*rGkSOW6lkJ@fi(IH=;`0$mT+ES?@XBnGx^YgA;>^Z$_4#g%fwE~3E{=Ft!a5-{k_@4{ +!$+n<}$~jzX{p7_sPS~J;dKp9$pUzY8;vf!x{nO`Xmfg^gueE+aJ@Ccc-LA27_d? +PM3MZ>vu{SqYPA=4Iu@eaPd3}bvii4oHPB7vJ90#g*$E)Ucp0O0G29^zEM6p6Lt?M?!hiQGEzW5dl*xYpP)h>@6aWAK2mldXP +gTV_6jb2}000&q0018V003}la4%nJZggdGZeeUMb#!TLb1!sdZE#;?X>u-bdBs`lkK4Er|L(tnr{Hih +DyvQ3UDSu$?)s9TNj6RPE(P`iftDznx3Z{`^zOPr^0#+pNa|t9+a7Rj^&yeP;cy8|R_%d@W8rh_o1lAg8(!G_HNq5rZfvKqXyM*bT)k +4f>sEyEU8PrNQ!oH+$ahBD5C$elln`PHP;ZKXB>^e%=TJ7s%8C`?Emr{!yL_0)4I(x$YD(k{9Rgy83= +K8=2Pa=g$*;QQ~SS>^$3RWu3R4oj%TW%TG0`_kzwdPfISUA%Z=?obGi|m#-FG+`Z#^CwOcQ0OEW~eZpcTqx1t2fVAud?^gSF4xV#reha)iM&zR_qq{TOq1N&hxGCq;FS$%ZSr5(&8Tr;si^mP8QD +gemZOIf7AN%1Bmn*v;gvNj=Wlk((7}~D4w&$*PUN)kU_$_e?Od&Xl^q*-c4)w(r!CM0Yh$>!B@8xA5| +5{Taytp5PwWWj9NZcA3CP^9Hgj<_Dd;i^w^MO;+P3>z-W2JjbQ^QA=uuEjWq4SQ53zR9fok#Lh8WQV$ +1KO(m*jIQZ#x7F(7T0#YR*mnHr7S35cK5%xu*jL@GojtT>}syMZGS-l{^ke*Dz2G{SmHVwy07;~69RJ +6`R90dAW(3?zF|7c%EoFhHN(f-(3|VTzZnU>kWSYU0eCaG+kxhwrUgI1wN!dfXpV>js&jE+k{8&gP^# +qyefj(BPS{n6pZ`*=va0o-C}a_=ZB6d-;c|K~@t<%L>ls`^vIwy%*C;Xkqudp3()=Q;c#Zw0#huI>4o +i(36n*HxYZx@;Fvc@|_4^Q0$FXcd`KBa%OVXfbo1(`*T=0$7R8s*Wh%vH$Z3=06n(=92fB(JiUC{!Gs +Nv5e#~qK*CwG44=}H1G-05zw}5*W>wg%4yy8Tv +QF%*pZM&)O`)kgOJQC!Qpk^fGfw#nbKqCC7w8swIxovl6h)4(YATsa+Zh~MSz%Ol*Sb-W^(Oe$>OLKP_M +5z>gJl69rsTT9D7cqk7m|;IH2WIb?0{5C6h>gB=XPTMD6biQFpo&)>QuM?8jz>3g|>2s_F<+GxhxN@Q +DsfFSQOIobp=5JaR)|}w#P)e(4m$fv>uCv(Yd!@+IMJRJoXf=EPbVRd445Bd#2?oO`ySdBJ%QNH&)mrCn`wHtYkHYzs%1IA$jNNdVyH*m5{L@ej9bWQ1|z!ksE1A+_B +-as8Kh-}^<^Sy4ylP{SN}T0`AC~;+Xrri;&VZy)9s4ORPct$!T2!u_`x6jp8N@WFTjnwA}UHKYmsxPu +FNRNL*`)M1jAqy6PQh)s|~G}C8PB?nZvG<^{vM@c&*>k9#Y>xS%JeoP~gyk=g?T*XOnB$SOcS~!ZZl2 +ma1XKs^mXO0;kU!@}vftw80AADBx-(ug20CQmV^)K4ba&oiwN(hZ~-BcU$0l3_V*ZAC_g*$Y${oz42) +g%{vshD;5CWdcTRiKPH>6Gxnv45;}N(967^i4wyJG+k)TTik)(fm~?z-0TBS$a#|estr$;|U3MnK_5h +2)7K{UNY^;g9#4{fP*(uTKM3+x}^0p&CFMi}XxMlb>=5vcuG>n%Yw9^z`i@4U3A1XL_Us1NNq4hED~;iJ1N@v-v&qJ*WS(cCy=wgyjXdZm@f~I=_7J`dN1I{QT`Z?8_IQ)8&`Hdiv|%{PuUh|HB{ubm~4UX#wc3pTbbkjt=4e3KP +Sr+piYH%a&cLft_sP=$AkI5Oqmt)bP9WmhQjM{!kq5XnyO&-ndH>L2ZPI^9u4czIGL>yH+7pMi(d^Kc +39pq6oVA7+f(E|Fo;Ah%;VoKr_4D;b>j)+z*VwH$50a*~1lN(sCd_4lbve^C6~xSMPc(5~xp(2r^^K! +)<7IehbmyWMnadXAM=4y*YrfYQhH;4>TCs7d(i%^)d$So=;zvAv1~cYhG_e{4@de>KIR&A7x>rgd$nU +0s{ngw13-3bG2K8|LN!q_0GJ(b^!T!zy%-hVmiPs%+hSZo(>4-J>0|XQR000O85nWGJ +JA4;Zb#8EBV{2({XD)Dg?OJVf+_n+^e!l{x#tB) +SY0K%v9kp`CZRCumiS4oE8IKhWjU#b)h9mR=woq{3RB*bdr*j%Rd--lO_Tl4b=;O)T-dMDI^NrN0-&Yj6RwBuyn$1w}La`%n +fOsX$_cRtJNx?TFNut?ocKZJ9+c)pdj=$~f2aEawu>FDHvzbxbLlV_(y|{hG*d8m&fASfPPcq&=8fax +^70*tH3+dUiwc^K_Sk$X9K<=9|tI?PmHZhD}ahap(gQz3S9(z;dTed6}d%HF3vS44uU+s70%x^dRVS@ +I|@<2I>`yGPLGO=W7t&}KCQg67v3?ugV1p}K}b`Uw=35bBT@MMh0*!5bbYoNO-a|kiE=2sX7reqq(C9 +DuA8CNpj#u$Fcj20e2$i;T6rx6V|@A!`$Qo_`#pao7yT|smwx!@V>gB}%D+^i2FP8CUv@pcX`7glbZg +st#ToWroJ!r(~|HNSuSF|a$yC4&h#h+V>q%tZ@6MAw@mhD%vw#E$*7JAgbR2BxM}sB5>9_(g{eTX#BI +O6Njmb9P`Q5;@A$+4#u3 +Uli*|DA(yaDHE9Cb#4+!t|F=O +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 +Ei$LmAGTOnNo;xSbJTJ&bfI;`795# +iO(M_GienBBMna?5i^o&O}#Ya7Oei4{Ft_NQ~>p93+=~*~_+%Kv7>|&B78Won>*AGTENbCJz4cJJQE6 +dc8Ial&@m~)j2bZ7`-2AO1oi9BTRUG->X;?VOWlsaxi_K?v4$O>r&lZT#o&rI59v9$a*@o8jU*=Yw2k +o86M&f0KBhgpZv@ZM?n_Q8qjW +={8I9q7ZqivBpErtRlrPrLp`^1Ajjt!}Iy~PhiJFa&R}Gw`ac +!JX>N37a&BR4FLiWjY;!MnXk}$=E^v9BS8Z?GHW2>qU%{yuDglbx^rMFcXt#7L*0e?2wZMYFpe5R7E0 +F?8#dQt;_ucVD5@n}N7X*nd^6q%gJ@@dGB+2`(ZKX0~)rrz@DKuG0MYd9X;bKj;+-%5p!&psLyk@$XB +}p=y@y6QJa=nIKvz3w!VGZSV(J-y)ni0R_%6%R0XsOang$-}*H@9wfEynaKAG)^ohTnLL(ZkAfTK&u0 +7w{w}{=>{|Y+NUP*6uUO^knG*&XDGRtE4P!==CD +pvNzOdfT;_Jc~#`oUzeA!AcCP4HM9t4wf~LUx +x?cRx>+OQ;-Yz^Cn*=w5*)3BV0SZ?Bdm60WPRE3!@)N2F8;-6h*X(Fhn(Pl` +13RgJ__x5h9{l|wDO`L`aYz*@-GA7w6%VRMrvjvyx1Uhrm;6%1z +8>JXcJr2bh}GE1)3gmuA333MbQ~>9iqBMjknqcS|_51_tcgLbrf&nmkH!a-Lm3zOg#k0<^>dR$!nSvQ +4vtOE4gc4z8VUYP;XNg|u`5Vx&<;(`0}u$!@#{mw4~!$AmiBa6NcQ*88oQNPE8-xgh61bl$I9Fq^J69 +Hiz{i8<3Q;CxJEKrSghOFj-fv|AQ~2AK7`0PT3u3MA|}66-W><9_{agFz}LVB6&agiaY(px9aVlW?6Z +%>Ea3u-vtgZ7g@C;zEyGXU`00wXd39zHdSgq +6Xh!A4sk+1B23cgB8+0~V;A0`V*0oh_%F(}ZVVI{LjZu{%!2;xYH2dw=)K9OB3bMfVg`U`gnbJzTEl> +@a~2_PGquK^)VDwyDL^8;4n>NU|&<_(xiIj@b9$beK4!0|TRdkg;xkXW +X1mYdxJ82N+Sg+{|a&N#m>sj1_hgf;+56!NS|mj>91u=*ff)PLe=u^u}thVk_u1VkB6>9a_Wi9h(5Ns +CfuuHgwWwoWdARDAo<#plD0vHHE6)>1&LH5^*4 +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 +k!v7^u&XNZLg;{Ei0j@Xd(S1?UVDL%K?JZx +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 +5|;-S#P1p#qhqv&5_}CH#-r38 +r!Kwji+88$?>I8Y>0&3eBMG9RbO;l3)b@G){4fZj>A|>zO4AESEv}pgK`Si6B%I9DbK^5D5KPF5RM!j +=GMpkY^(le$A3Dnc&fF$VXuX4o^l%6VF%#Wg-JXsu4&OJ0#GtumX>;SHaq@{P1b=GnPvIc9Vb +eh}C)Tg;;<|tUG`Mp^HY&bwzBu-Y7IRE~hQ)pDk-QHS?qHAag7RDAY*s5!d0SEv69*0OBvO{Ba*!rM1 +KraD~T!rq2k5^QnX{yLMW08<~3(saO2YhqO?@xug&=Idj6`37 +4(eU^q%4so8vTG~<&GM~hD7(x7G?dE$wAh7rGBa}4@dlUCma{09d$ZO+`g&^jI(JhU+elI6Lb#fa@e3 +d6H-jS){{V~T3hX^KdJi#;yfJj|p$p@h);17*$iB%NY +4W)5Frr_PB?TTcF>)AYpZOK<1;A$1vp^*!zmE@ZdASe5o#G +o4~4dR_#mqgx*`YkF5(G{JXCGvaSk~JMoLg1NDD*WVxEzbYZS-3g}9|v;zrzI($Yqc@udP2WmfE+#kL +CKy&co9w+_Q48R9p}V=Vpt}%z2qPsTTydODF~g>exrODxpEPwkE +P3A#wc{z<8&3y?r5m6ey^y@;{0d)9kcU|l!{wl5UGuqv^8=5Xu1s;;M-zH~F2$mXM=2;I{4nSZ#MLG$fJolp0z=!bpKD +jvTxhPSVZCi7UO%@O9?P);9kz^QpXGw|u{>cs;Vn0S9By4k)=vYHK~$H@};f120f2;)?o9)zM4B2b8e +u*I2p6RGZG`3`iC=$Nx?$nY1;ft1EerZrB4J6<}|+ERK#~%Fx-lyED%R4sg+ko59TR)~o3ska&fUj># +KAZ8KX)u;N*NRXg{hABvrO?rHDM=*=JUxYIO6D`aMP-0!DS?xDUDjjS$?Qz5P^J(aHm$-KWwuT}S|8`rSu#IBFw``E +b41hWfcFu)#1p9pyXP=SJ?oUNzxSYH(Vg@*1w2rPb|B1Z7U>+J*aK3d{Rp?UXQN{)G&@WvG>#ZSGGT% +QeS{5-^{SM&o|HVE>&Q@zs6o!+^&oqj!k=AaQjx97N6fQ_+)q{F^cbZ|N_k&bGB4d0NDsv1HL88+U3x +yL=V(r*Hy*Py*>`(Ki0d^8mpBZDfE8F;z?9gEDsQZGu4M%Z2Gcq_@zGvU*;k+TqE{<9v)w+v6+{%VlyGJ@-4710fcpY5sbh}SPLEaUcin|E?^-6FT>Q3~bM? +xrvGpZO?XM?1Qt8eke*QABiOlzVi-A4vdAr~m?SWa~4mW~&~T43m9*OqMQ>?hr6`-tV+dyDUvE6uxiY +Y+;>6WVqh3avm1$soK37A^>;;#jWhx!M@c3TC4UEtEFG^fzuY0X#h_i;e*YCAyD5DDzLtV$Ic=Ib`y* +vu5KR5s{4Gef;x|d9SP%`QgWSqwzV|<1PvlRBt(d-z#hPgqQ%33A&kuc5b;3tLhE7$&WwhKu2!+hF_7 +^h3q7@bjTsV4)CF#j?ZnQrd1!HJZ77S}WD{|XIJgGr;+AQ1KT60tW2=q+)V|qg@0Srkk_3N8@_;<#Uc +)}a{A<;~>+y>>$_z;zc6MP5Q`kZFdXn%N=o1Ntmyd7@?dPZu_WHo`m6BE0Y7a^=a_My1x!)w`I~NMWy +7Z?nG1?BAmJNDWGpe#G&i?sNSi(x~*udv1y;YcwNoxsc2ej?5}#4THet)Zr+mJ3Cyn#*;}740x2`b&{iQ5JZ}M@wM87iLj?0vJ+v_k +P5LsQY2v{7Ddpl8tjkOd4P#z#-+W4|>DH6rpgy^Q$WDva!Z6BJyT-0Ef?1s=qx9T@FDihpEc+!XxS6- +?{_{PGCMi9JJY<+TP;-59tOvc +I2B_%%c2ZC>_J0B_XMw~|i53f8w%t8HhMW!n(sevUtd7AVa4q9nK2bmnEpD+~Al|7>jR&pU59QETLnop=LIp|A;0%SHA&{c_*PraiM0_6; +QeFYl$_0z9FD_U8|>g%)9)32cC*Na$J$}gz9`YBecLd)$QS#=6ePXE4tvD;CYL03tthX|*QKX-R*OOc +0$AS5fEH{vk*-lq`SdV{b&TU%_(_csKe22nv>3M=28Yk#A<8>!p<7KdWPS +_2zlR80i7s*2spGU>@V|MqvLzN(&Q-oMEzTLHZ=abB|pZ9zoVIaY{-w3chB5+K3nF0<))s@`$Zw#m@N +MP|A&B5oUBHY-iY3}3CJ?V?e0)6RfP0HCpWlNIz$O&*N-AlruaI5!CDb#XU8EbGhG+@>^crV<+hAZa* +Jf+Qu+4sXwBd#5x!ydI7=Q6kaoj@;_V1Uy5HCacA +Poh`PgPFY`GG6yn +HA=36*R-%;nOa+y)A;fb3)jWcs>nFm}vqkYkA3ad{&YSgX|@;^6n4q% +Ak_xwO9k_K8ZEYqxm_QxX*&aRE1Hb5Ny1+eFYgSv9ctZ6kKGPxRmVa;2tp5*s~8d{g6 +8Cje_M$SB|vB09G6}o==Gd$AdEb4S2>}wp~U$bZ-^6Ll|)`O;`hOQ_u0R}wn0j&jaR8Pk(X8um?WTd2 +Lip^aSI~YCvJ6`?bj2lME#b)-4`Sk#6E(pBa69K|sU*j;>*R($;fyH +#%;~M1o`ucDV<}>N^ND6ejGH?0sMu8s*JUVH4)j;I9KcVxEsHQ{_lhD_@4Aw1cpx7@EBjemWEJmSydq8^L*z*sKk +yA8eyc9Ztyp<(4JDbIAe#2eG3B-S}6rzpmK}CxUJTjia`jT%SpdJpdg9n%QbjYPcVBSf;Ae^Tpo#-=C +(a6t$c&yDEx{)!j(0V!)n)ogo`e!z4sE;MjkRF4LD}v`1J#4WUjq5Rb*H@E)s6= +V1j0lpzue4iZACD*rpIi%^@Q;@_^8(~bft!YALB!!$y@Jw9Nq@yYVj!Y3GJN2|K=<>`E3~67P7(VkkH +JYL=SoO9O=tYQgDYV?#CJa&p%SGXB%(VpE37;<4D%8+K-q@EgU{C@hHKVNFJduX%(jv(TWxn)Eyw#6N +MFilWjkDs`v{@INi<@(s-jWiF)v6sf{blxF4?+f0$Cq#jVh%)mOa8G1N2*Ef}SfR-TYyO2*KK+ULQYK +E_Bi4`fxFFqF?ID`?(viatc~&*5I6h7&n9{O!P--L+WJl+4teoU#R*i8)3L5Gc;>=VFI{S9AIR154mK +p|j`$|GTHt3x2j`%$o;k_tHP!X?f%;ya|wVE!k;=nj|^D6^%m*9Wy$9e|CC$0}Sm}XzosTR4H`2-S76 +NLaC0c(`V2A{9lu#eSn}LEpbe&Yd+I~n^z=zh?JE71G%UvcyWs`uCh;*ztE24ae_{P==iAuwF9-p-0R +>|9kb*g6hTQ=%D*u7@l&7c)3mt!ztTuYJ&DP6G(v0>q))AzE|je?5Qv@C__cA! +dBwrvbbYCa`wRgZ?x36wUCT(d{tO$UpN}kopc%%L?rRAD4+018$iFdjkyHM}Ic+e;M>>dCCJuCmE?_E +4;#pK7rsM8`Up`R*`#Hss$PudS%-aaXf56x_`so3ugf0-YWk_@?A~yxUe(;4yR@UOCYk2wF7gB3697Y<_k`j3C)k(68zQM$-3J2Ep#CuHF-cfyV`s?32R0) +CHj}P3PuT#vOToBZ(yFhVR=J`o(AU{O!Z4yDqDUyq%qSQLwH41fXXJr&0#FifjgKkGAoKL5WyD5T1mE +ry9@T8@HR+K_>7HzksxTXjD1CI762WcX0+QEg99F;l`mzk}V!_#1E0(c`k-< +H>Ed86QQH(|`gS&_;;-7d~BI|-D5fW(?S(?A&2BC&5!`lcvrz=bEdddaT-y>wN0bsB+4L^3oo2HiOtG +D01dixHKMM+&0C?hA=yv0K~Y$@JADtAu^AJ +C<;qz@p0bveQfIxXi+o1m3b$8FwSn<|6x!@cNbCp2(q{> +`Mbm#FwZCV4rIl0^K@>IxEUZ2vZnc7qEo%QxGzR%X+*#68v=4lK3sMCu*LiX=2Ndkm=?WqQ*Rf&OxS(I#Fu~g-Qnsuyul-%~H&kx8g;0{R +M=Ne?cT27d>8&r#)E44ARCeA1OyPYmZ_Dv;gHT(|o&Hlo_>Ig#`7l=df^DUbrGT4LPs-n%>Z5sz1-zc +s%n==Jfv|qp))@z$6TU!+E830}x?d@6aWAK2mldXPgSohyZc +@S003qa000*N003}la4%nWWo~3|axY(BX>MtBUtcb8d97DXkJ~m7z3W#H&Y^bdXpjwGneM3sNHkN~EQ3JcSI3FCoc{4*T7K@}+ZJOOuQy43h6I*=6C)JdqpccQW$ +rU+awgSq+8_`;Vju#D4!D?|iiQ2+6!kLDNn +bHp6e@(pLIvcyxQ0B#*?U*)?$kffyBjs!ivObz)bkyb_hXCE&K{nnEKy)7kqd_Q#Og8F<46umMy~+)C +XM9|s_K+fge1;^m#v8qcaM$wCoW6ov9QuGG;QD8mu#a@jc&0d^;}x*@S}>Tc1yl($mp2&N0rCzn^R|N +i~*-PNUdCEg$&;^V#EBiya*v|kHt%nkAt!z+}f9Ov8zib#P2B66fL-Bns_LvAAiI|@O=8A9dVIqD6Ss +%e-JFaeYSTCBnuBJ!T<*0U7qLyDSxI7`F<-Z%);1c+SM2AyJ@j3@W95dgTPjgn2E&l>{IBtm4^cgj@( +GMIYCjFc7dCEiy=I#$6+=AbWC!GQGX<=~R{zg=Cu%P!yk0Tg@2q+l0+FNbGf*T|Zd;306zvehaHRHCi +Id8BZ)M3O7gEpogCu$;iUVlW1OVcQa`_{d@xG0scx=os!`U27h^=wJ`e=jWk(~Kv*Z32HoA3^HPN0~fcb9rTZYdMlknt}F`l?G|JoIVu5k$O~|7jY5Z1UeqMf +ntUa_xW4ZFjanbd2NXmLyS^TI;ti3((Dw{#uQ=Ks^;7YuYI0N?{eU8h;!s0eFGpWpi_CH?TnIz09oZG +_+&a>Pv0)#4z*xpdM*$!{4wraIC{fU_?6kB4PQe@zQo|93x$s!#z5|&1$0JWD(+K9!Y8#4#By_M5!?~ +d;bfVZ;22W$e)h#qT#|?>aGTVnxlXJ4<%8t?QLemYs*WIg>xKeKO` +0v^^qaHDmO`t^yW`r=Aef{L&3B$988PhlMdtFJZjg=v(VAPJ#&G60hgO#_D6Wmytbwv^96+0Lv!Fbrk +ImR7v=ux>ThRG;F(g-Z(zgIPsKur_YCLx8ncrq_uLxCO_cX-we;MYT$-S +#9_C~u!Xxo(&%vq$s*NHP$PpFX@~hH;-u`QKr%d_t319=2 +VJ#be%av08~A54OqIQOC0H@x7PD@wiLxweIC2mw811&0B*Fz7`TX&sLqT8;zk`%M$@-2b`H)x8`J-?= +cf=AV13gyd>?cp4#PW1>j^Iov5`kzmd4Ml;_J^H*(Jk>-{CmKDnKYzbwnt?5v^6w1cU^#+Pmg^nhK=)tTZU$mVgLiA1JZ5_m{u1VCPx`^bmR4u +eIY%0P4yM+)SCaGpXvklT@1#C|ZtUrCi)=F>1p=Of_rZ45Fh_|BzmWDTpwO!!Ulp3VLzm2UxH49jWgMa@}csFR4nb +_9)JPW99>Ou`E@rveLO5hGHs}0`(Px#jITbOf4&j`F*!WD`dyrV6o+TOi@%T0K8(ciZx@r}%S&-S0b=9Ri<9v&q>j&yPCk +DapZy}<1LoQJl{gunj<101)j1WZh>edgk=*I=3IyoGlj>Lz<)5Bkm3F{o_U=0zFc@$qh9b+Pvc?kcGuEytQSec{qv#SZbj-alS +s{;AU`0{up4kzPF6wAlS`6*Tt1q(RmLJ}LQBliEWoR*py@?okL+$A5O;QF2^hTN%o_(-6%12Jg0Jn`dHCH=f4e(gB9{b>Mb_mB@3&U +kO^H$T{~p#~t0 c{Aypn=R#0;{Nu^Nm;45Y`aGKamu!Yz=7r*ZT3E<4uB!g%ce|>!|4i3Z~Wbb!p? +_>7c*8F#S*W#xGVeOB^+aZW-CIIx^j(|UOR?)3P592 +YtG=gS#1yHJ8PThLj}j2h{`L_(X4gyOZx&XQFX7Km8CS;JwGC?7q!%)~iZ=M4I!<0OfbD#{Cx&?}HoC +2_5cnsQ=VKfK+D)(`tNTD}a$Z@QhlWvb+l*k6Rf)Xu@PX`hrXrRQM26UMGD6Vs4uSy1j-97%8vBxl$6 +9f)cy^j;&3ZX0%J7`W +7?hO1MC4j+XKshT4bu@8@>FyY2K`ojnq+c=f8u($8b57j9Rv%>QB{kb)n}cXDQ${xu2D>CjNVG8xs)# +=(-mNUrfG)K3rGW{-ULI!Hh>?T?uW@)Ut)W30#$zxCjQ4{=gv7 +w9nHiQ@vqCx17gnJ(ceu|x*5;cO|LKFcE!I+y@^J;$g-qvaiDDmHCtd +P~4Iq(-`A859aUg;>!)WqT@>xkihiln_P(k$gBn(>IlxLziqBM49!WT~Mi3!tA$*T*p7gpdI3mMLK?s~riCu6QDGVq>UjTZN1QhfJ+{PLtk=N^LLn|8V6Wbb^0kt=Nz! +WTpS|6tuukDSoD0u7kh$Z*7Nk_H4{&tB_ZPZyiUE~2s*SQ-=^FdH8jNo6>8?<2RqMFsvq!sMOPNuEa> +nl`1bV;?&?^;(@_@7Q^rXf`;(0*uPv~!z%QQ=cAgU3?C9E)sq%A +Un63!jn0`Y{NENXHv1g{R2EZ2TcvkttE+0zHL+CMc#t|v*Sm9Xdo-Y(JpN6XMwaAYtpU#wBe<_sO`|D +A(k^E!z5tk%YMvVUig`@4;2=$K-ARH|;Mgn#cP}Y9@B&#m@_qZQ04^o=32(nQrT|O^RVC+cTEx*ETB9 +HnTQ>xmhEXCYPA&DyV^VLKESo>`Ai>p?z!WTsr0CM5Z!+7%9oo6P2aFv0trfSr)NFRGUIO2dS{mnxr- +mC;8zh&an{v}4t*o<`NH>$!rikk3@bi^+3t)DwUCT#saP^+7+5o75?KnlOaL^uY=uv_7id~;vaaIG~YQs$AL@bC5Z9=B4s#g#h(Qs +RF>fNL^!@ob4UkoLK!8Ddg`S$bHRT!2v%QekmhR#?I2p_84u1BZ#-5r8BN>=r-0*!PHIqI)Itt?Sr^X +2UG|Gf0pL#u39x?e!AGDtE&u1#ynO6OpSI(dPtzX!IM0-PAZlGeXi5|yB3>r3C)3W#CvJ2r*NFeI0OE +%(QqpL{EhLM%(}5Z|zNH?CGKe_gcT@LsuZ?W6@Y98v&O`a={F%oYp)Z4_WZ_^sK5$kCw%PJ(t*`^*b1 +IV$fk(4L>h_1KeRQd>EOxm{q|)?q<=}H0 +oIhPSw-Ngzc*bA&u`#I&JSyQdI3=~gJAS@ctek8P9Y1-k`g;|iwdy}o&HqE!T*I~%H_x&qgdFi*ApdX +^t~|b=gMk;!w#)1_6jIhNKGu-iMLy3Kp@ZwTnZm^cdS5}XQl!`gNGFlfygpr>o?H}fgud*yHD*2xpaj +ivrRJQ|hA9_r5ITzhVjx^sMHEW1PsgXn?<*+?WE0RDLeNLv)+mjuNkodl*3eqy&?cegS(V;tGnr_X;A +`kcanwN?!rU(E6{Ix<;97E(@Kq&+2og{mA(Z^5tE-DkncTApG*d{mDZjSSIQnH=MQ9|fqi{*1iYiW9+ +B!PkMd00W7+^du`Kb-z&s^pN^I!DP29n5SqHG)=TVc}JyOUX3@=ouU-HaOk$?#M?ekZ%5AQQo^)MF2r +;|FdSlW+b|JgGce<@KTCCbyErM|f+JF<|;grCx#^iLcG{QoU;<)#NI0y#&cFO77TBn*3GZ`UqwL#ba0 +eqtP+77c09XaP_0H;I$76I(OQjma-x%ubM`g*sI~lXBz6E&~DUgK)^v5C*C}cmB-KSjxgm&r!;2x4Za +M_{vs9&-1Apz?pa1Uiz8)>AB!hNAnxeTH0lC|IncdKV`V+3{Qf?!Sd#(OU# ++@zXLnWm?v~wJd(V>){1|urKw3{o(400cY1lOgg~9PaA4!R`IK3n_geJ-F-6Z>n_2%_(nZ(mLD+8a}t +76PdZKL(L2$Q8}gg~62ItYI03xgDXTI=S1J3X0P9F-lNB2;#D*SMS0_r*gH`SC+ab6UYH@IIO}<{YdW&C}+5M2Y}k+Qf?HePBZf+f%bXkVuH; +!SC<%Lz$Som^F=Ac9o$aEOO6H~%~f@ru&bx-?C=`jL3NU@VReJyPCH+es~H;%jTLrUPUDp|$a2gkx6L +ddE!OBY$!Y_}^}n4;0h`YQ(uiO}+i+ClSnm|f=?fSYWZR=Nvwx<~!40=T1{fGfCGPE($bZB^v?Zzu|5 +V%*#l0nN9zCbzJleYKVrs1L>YJlE%P>!$j+;kY7OD`RSFDr84sAy6p@8oOlXb*yMaT%(L7vVVsSid$$ +!bg7tY|Dx#mp-`?~_nz$JiE%NWtS`^IoXV`^grM1R|M*v9~okK)8#oTpOXAx_UZxf?GF(`?byey4ub6 +b|Te2zqf~Li2}-Ax)-y(-|ppWr=xFP(+95!i-*k+Tm|CoF|?Vg<-0ZL%XTIy9CU(WSnaciqDsI=Q{du=zfTf*JSZV9v3Zrk~Ks@*DM>9X6Zh}YR|F;H +tGvDR)A3GOM)zM17JdR5z1iJMz5;KfTBwHu%=qH}2%#wKCtAOYE7!)r+3a*zKU0=T}9%H0F-R`Xwj4^ +VrW#y0r3GFv9`W6%+~tihhB>}_g(PD1+-;I5i353+^?`kxPS=E6{f{KqFZ^203^fwU&lCw87ohnIaWc +%6L9x&ij%>N$+iT>mpGasdwEAx`|$+iybSOOVZ#z9!NQ7hBOhoTgdgdKuI&@DB5A{@hA_6GEh}Z$e4e +??Zq~&flVf--Z&^@Y^xQ)D5WorLXW>7O|0CC%%V*N~9MS&R=Zca1=JPxiKqV61;p;q=MIXKK0I{+g?{YfZ4KiEeW146*YgWw4+l`WivF4NIdh +P12?7=@V&WDi>4yk`6yZ(O-#_P#bUdM7b2!ZV +5%_{mafl-j&n7w!>6c?u$@%Am6%xOb_Y@-d+tE{4u8X%oU +c#*D6m?XHHbi3xi=@eBk^4_5Z?)^^=OFlFh5Cm@S89PzYoA;nH+j@oPm*tM#g#ggn67vkQfr>iR66sQ +lK*gegwtY@Knw7dFCYLeEn91xeeo~8!8a>f)M40detff3wms;0c7E0R|U-Xwi*;KT~(+gbkxCo$1c0D +2iL#HT_q0g+{Y8R=%e_@Y)7g8476wHpPNk;!wRydGYB#p$ymc3`~jkMERzS%4MTTIpR?=7p7J#aewyA +a*o{^eDjlbzodJdhci1l#R!*N%-|=_n5uH0lbRd6`#QfozX{Y)N!91GAdE`6#h#yNOG#OACtZen69pk +FcAP>}OSEuxfePQFnJY5=Ns1u01Fm0BGS&Tj|70AJxVX9l#!d7P8;IM_iR&~^?TEfzQ<>?{AX9%IA5I +$1_F_bb$>sn4NM{Hr?WVJ14YZ*mZ`rr+O)!pGvrzIB$NwsOf=&``-{~|L!7E@DLP{-=gK@R{zpI8=dYiMFAXVs0twL}bEfZ@bi(M-oy$7J8ug9ZRK9K+>x<7uE8Zs`fT +Q58&^2SBHFCs(P3=QF&#dua1_K*zTUh#(Am#yr}Ku^wN6wNVIYcilPy4Aq8@Gg|BM8Op@J599+@%ak4 +43|crK4KR0LKyxL!;W^*LAg;R+C>!9b4sE?sNE}J2lc%YKu}zIUNg<4G=;KN1U~EGhn<_&?JV_x1%oC +JSfFMrcb(58i`$SDT%+eZ4s&4CO5vQiJ?W1V{d-@nI7$*kFdi +tcPr_uk)tY7yO(ey-9tEK--ZQj^s4RGI5^y-Z{XvyqHGU$)$u`_k +ZNDjk2Uz|{a|S0fLfIlnrMi!2e_vBpbC`3eXaI2N4|WdJ$oh`z#u3?0JH|cXOqhyrZ@fJFG9q&ext1S +h^cebOTn!|cknQuDTRw|o@&_06^T@j$#Wc3?B^gwAi6$XoeX5;PK*g9b(omY`1 +E%$v)!0elwM;dM$CrFyK$hP-XW+7nnB)Esxa4O7Ak@g+{~+=N3MJgYi$Bi{`nk`q&~wG=|Q`5N0+N5x +vHoycYAdeTaE|M8FAk-#5#7}B0mf^lT(xl27yQZxsCsM|j#m32@CZcSS_h!Y>uzrMaUeSTr<)-<1uM9 +_hj&%OrN!-nw}U()05I6S%ADn7NwFE^JX#2%W>qtX(LMp8Bkomg!&Jq>~;9gGI?G+W=;&Yxi8g%6&NF +n-3miI5y_NP%&YpHn`5PFKlS6G62at3ym)y2)+I9W*{Eh1JeeW6*}shE^TBQkEf|tqU_~tSjw#3mF9Hf=exnP$@%2@gUl@vLlGC2oKg>9ZihGlQyhHG9P|K}A)k#W}}Sw@i|?c)ASqg2S +QIQ3q2xVeF}w>cL3IfRtyFkB!H>2FlrZ+dTOwm}!db5}hULG(G5GabB9z?2$CQg9sZLaK(7pKq|01twvJXf%1fH; +SC*5kLNxN-?cD?MbW`_mMV)5x#PIGlQlL>n(;2d+gYsGFmYM6*bNw{l?&BeLSL8ldJuvb@chvb#iCFu +I>+)kz2UJc4FvD;h~&eoG+Tv|G0N#3jBtumE8o(om3#L0m4-800;^2eUdBs0@CjFhQB`T?$9Yycjt;< +EO_P0Zb*c-me2|v!X6~@z{Loby-y9;)$T;f1<=}Y);ZXvUtN^?aV?H|$xyQrWa9~7(7Q8orpQMi5_%z +QTv+GP*21hfna3nTFsWq4(ggX0*d^g5yX=|ReyRLaW{YML2sbNIO&VW-3%V{t)(|Eln-xjn7d=t)~OV +s$IM}7wDBSoRg000>JF0vln2qz^2H6iyAj{_?*Q&~4YNNH3L{f1nc0&7^4p$Y&kHPIA6ji0L|ul8Q#g +KNe~B-6_I-1?83KF$fNB`V}}k*67+A&acyeK@YV(qdp7#~AswnoBxBpiy%K+_2^V`mJkDBsZ)%a=Jmy +p%AWi+k&4#E{MRP20qT@;GSdwC^?_ui&rF}o3n;hvdFtx$yxw_>?F4oLo`Zn3KL-Zgt>`8_1`p+?w!e +KHyj#fcMwMGer%{F}7WyX9AY^KD3(~7;^@<@CMY8?9B~Vklqt +1=u$P@4HqeDnjODj$1Y6IsS3wZzaybgy7r_9p}9CH1^s1mcyVz&aSksp$G@E6wPlyx_=@Qk^v@R`4zG +?cYX^wyy>hzTss%QN!1!0c#X{Gqc8dl6ZE%YT{&_KIB5L$)ZHM`%l|qw_>oLrlDT!1`-L{b#Dx0=iYc +>-9{GXxerwG$F%ob##p6j!C3Yh&>)i#W)GrHPV^AZirNDcP3GMcBDim|hxI^$TYO<~~&Yc0L_E4bGWq +k=W{%TlLGw~DKhV@_dEMiW#`Q_-{v-dRAK04#h0e@z3La!XdR5fRhXb^#iTxS~KU24~8hCVU9AzEdd1 +d6Z@7MszLIJMu$Q{Fq4uzI4(5LwK}s@30g)a#7JL=#xETcoxcg8PXMQn_)ov!~vg``EM=pnG&A9YY+O+B*r +sjeLU-1eE-91T|-m2EmTO{S>g&0{kHXhzIy?}rtXY7J6t$e2|iBLFE*Rl4O;3*cAqO*Y|>H5oNBSXw1 +uWMbk)z(OM7(cf8BMQI0acP!;gnBI1{xeC2S9oi-umn4EaeH06J ++$wW!D4L_m(dIX8XIbCZE%HIj>K*zaUBCM`lFQHk+6p3m(AUql?F{uMr$TZ_oWx}@+&qh+FGRUwe4@- ++Vx_WUfpy=O1pPyhz>c$&N3Shcs1`X3uE4_qTwm<1g%pBD7-p^Cg@EE(Foi%^3&yhrHAWEJ}s$H@xTy +m?#GuVjgn`KehZ9YQwRjGt7WiTA0jv49$>JQ$XN?0R8gPePlg7-xRSz~eRpdWE$Du&f?XF%DHH2GTWK +{6$xtJOr<&uaETUqsx_f6Mlo9PbT>dBacU7pO@HS9B%cxM00m+8xwdZV#%wW +YdD;iEA{s73Hf+^Eszjd=BwnmwcY6>gxEn-U7&5Q3BI^!DF1Ax&De_GnP!ccN!x=>}7?(2;pfXV-FX1 +E;w1vuBe-`#e`;f&$wSbj5f$GhWq)mxbr;x*+Z2p +e$u|}jo@jFwNmUFmqphdUut4-61=pKfV)4>qSVh+Vof$sSacrQ>%?(cBm?73P90}h%?d<8vL#Mo@%(| +-vC-i%$f{-#sp{N%~1rgn7s_8gn@(#Kvc;+ZA6**mzR;(Wp$CM5>p2>u +?BXKSH&ri~Zq9@dQ~_CJbvP;o$xXx_fQ8q}ipQQaQf!-WZG+CIHT&)B(Kjs)Ba8Y1XMxfiW37$X ++QVq0=!v7(YYi(12D|y8cXGG0IYwP0)pq}sWhjdlw1_E*3bsC=%=OYp)b0rr_3GpQ~a#&bQ3ON`V7=xWf$OZ_k=;|W8YMUH3cq9?u+3SH3 +>Z-2^{I!S$CN<=8^H^5=^7n_$zH9p@{!$95WxX+&cPAVgCV{0%RERaRaUMj``hk-9@o`nIqx! +4Q@-UqUv$^MX}F1BG}Y0n|-F`Na%9GD`YkiKx|r;$El9l0gN&a{KxxnaJI=C?SMVCEn90)AXG@6aWAK2mldXPg +Qi_ykA*K008nh0RSKX003}la4%nWWo~3|axZjwaA|I5UuAf7Wo~n6Z*FrgaCz;0|92a=@!;?JE4K8#$ +E8CvmXoH5TJ^iKJDnc2B$v|Gc_S5hs7P$)yfWcrem>J9z +>rGX+Nj94w6#R8wtycNGEvmAKJesJI%WXMtt7>J-Rhzud+Nw6cn``^3z24+ak~PVczNyDWd2w)XFr8+ +r)pVL1C#MGqd>$mPwgBx>v&rX0wvvL$rY_b+TfE7e2^AYYEw6`T{`zc{HO=3$+WxM}dDiA7{BIt8Rg~ +Gv{P?D5p}VVBZ4Hpk!CAN>#IyXewDA5=KBc@Q-4<-lbTRx0rvme^Z`_d +NS*yrlzRI(DT0x;zl`SmwEV4G6BMnd6IxCxHRj+@${zxeJiuJdYUzN>!7fhH`1egNVtYB!tTRjqn-c5v_@fjLQLuufssFM!b3o2)Hn#j0qp4 +_-chIsN@7kAZ=m)Z6@k7E>|*Hg7X{gu})9Czm;MO^*=B1f2;0{CRLGz_o6s16;(=9>`u3V0H~~nrTrkD;!$-(KtDLEQ6 +ti-dtAO)nY1p_7vp}HA!i!2F?Rc6#l(Vw&Nsao;8^Y^CJd57Kv{XefVPu{X?v|c^Vz$s~!FS?7emWUO +gURx0?JtwjFDlNfB2?JDG~;Yk9IXM0@y~44c4S5}+J@bEl8LtIAyQWUd6%MvA@NN{Y{GfEn97KDR=_dkF^VrhhrE4jk0WyQS|e=;@-J&HVm%>JoUiDR|FTobYOp3v~A_ToZP|l4 +~0hPJZU6LK7m6|g|kr!5-XA^JVi;8Sd5}CVnkE3K3GberVSi>$0$Pvl!!foSGalsUStam_RInIY)Z7- +(0Lc}IM48$1=2E;%~jD}>P0#l_blHiZvsY;&EW8uGj~)KJ*b35Dybk;O^#*qfD$N>SK}tsnrI^xj&kG`oV!ZGcbs; +(Y&#I6SAq(qbFyERsBKGN9A2#=_kSegObC9Sx{#V^}{=lR%Zrd}<5ADXj$m&2w5Z%)P&*>$Odp +jcvne;)@g6qL9RDb*Qe@YQ}L1q$>&@GjyO$AhaqHU<7BpNldGK6ek3pzERf=^WtgP^nC0*yhiZq1NYk(LeB)`}a0i= +CsTGjEkv|pyT=rZLq4PYsY}-w9^x=oI?L{-$T*F3NPOAFi!vc2I{NqnP`uK@GfD)W^=}QKrI9ufNiWK +>{RP0XYt+LABDrwod!xi*XU_d?I?$xSu%WO>S+!ZAna+|2FVHRS(nCw_{Oo3lyP2MFoo}12N#KQs(hR +nc|M}H2EiTX2{Od`#_+RjpJGD6@z!1ti;eVUJqh&d+f>hNoyG@~Dk9(T)@=Txivm?Gf;@y270Vxl&v}YwJMHf_>4hI#JJ?SNU7q +DU;$raE?||uE;cN#+5t7i3glJTYJm*_cMw(WRn6wPNdUla3M3^w^fz=E2dF%Ll%IfAG^?t +`gF3RC07{)_i$}D-%ZyyBPIE_ws63x-i&abd*Um<`(Ti0Cfu(4h*esOdHY^zMB?WU_r2+>BBKaLfML% +Oe5EAAwaBwEehpnAI93Ao}j9owiD4ja2RiOA~k*V +{b?(x>ma}l?y697CmlKA%o_JlbxM1{RftO*0Xa)81zno&hT#7u8ZY0pX6jJEvo5QNA?6dDNsju0mbtu +a2__~(Sd>mumfwJo-VfQ^|dWD16x3{-c-VM9XFF>HI5hdD_W5M1HXlZx)XX{Zjff<5R|0? +aNGEVScKFbO3K<;E3O%aeU8GdPn!lfLQuplfuYmffWDt2tW7j%qjw=jv^kM|FTUjLH0mLD)B54Su3_=)cWDrBBFUv?GV)o`g +G^0{4WKi#ibvRcMTcfVdHg6HSuk; +F_5q7Qatb5$8Rz%%c(z6&+skHlbfG{50+*?-n4Yb%Nu{nCmGVASbrNhXsvvw8{m##R^_lou{x=?ZG#?G8T$g#K7D|v +Bj2=#aN)dERNIDKJJ-d!VDSt{p<$0E-_H}(=}(ho&K_b7vZ!m+c(NrFH*Qq$RLHsDWg}Ub +LqXX;qscZn|(SheEs%q=U2cC;*tPm;!$cfXvq@M@A`={=Jetr;fISrZ#DkvvW-K2fUN7Fw{p2W=(+I> +`rNWw@(@EvypRN3bT;x+};-@JH*ir>@WGgyS|vf1@d4nITZl`P-M^|<4*9CvK)K +>KUfT$&26ieJ!Ylbw#q=FUIN9N@1Xa?;-J=wIlu9CwI5GyXZaofvQ8DNBSLj6t +VoX#1YGa+INtN5%q=uJY`4oiFic53r)K^GQ|UxA9H(p3A6v;gDapX;xHv{e?@Qt!Ys*HEvw +Ig9EHTAdv2_4$otYnPo##{FhL^iwEULNfw&)=)tLn9RhDSd0oovtjkc=ong}>brTLAV&iZ}76rB@eKe +K8EF13$EWCfQ<<;y2GtiC&pS2y-+S9yDF&>lxwf=bP0`d4KN-*Q+n5hBBahPimbi7BUT4>{ +e3~u(zHM6VqU9O~G32l0==UNWK9grHPZFoSqzx@iaJ2PRcXXTo_b)FD44YizTCFEPYwSgyIR0Y|6mH5ywRv)L>UNRS +U&Puh7#~Q?Xu-=?d^(=cMo7tPqjX-?6Hq%B(@8DL~q@!y;WF6!=gN2_L#PF9elH%^vsmw;qkjE^AiKR +=hj(x~@jozw8Z$XA%GQX>Dw~A6xr;?ZUeN&{bFiQPKcltU-Hrr|i^$v0a#n!pZBm9fn>yy(-edGgjRe +Y&s&jW#51%5$QHQh77(9 +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 +oS?FMAI4b +%uuV*xdhWW;2!oJa7BWYL+)PteE&xsk>42<<0W>~e!$Z~_d;dOA(JOR5w=Cf%&}bsX=fL4v+T&$9HRR +a9coMHi?Bf9^eHQ;X4E^5jQ7P^NQ52n`KN?XY={U0nb;6gzHhOf&aUo +AKk=s5XMK^!U^+J&VNNt}{GDf~Ml6}O*G7ae}~Y{X)8S5p+Lc4&)|f}YV9Zynm@*ON`PNma$bbjiUPp +=5~x=e>94;RL^=19Uh*o~=6pVyEe{L3Bcafi`tc-YtV&oajp_2Aj@L+}0R*$o%yxf0M6{pXi{|;n_ZF +zYYiiqjgi458ZAC8&Dy;+-`;5zzpa}k9aV;WAekj06)A;#zG3=?DN}Qb59sx_U5?R-A0et+DO{$H858 +?Ts}dG{G;UV1 +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 +@{6d3PB{3B^_mlq`*Dnkg_9ABw?v#5!KD>>aOZ +?>r*2xbtCo#TXDk`pJ!L8>-_u|P6O8|lDr%ztb`F`vJD7XE&WdD#BknZGoZ%Y!nKak6bM*M+(qpwDdB +=!_HJvSBFNVU8cXFm&-l`#3SryU6+0thq*dVQNV{c~G)6vyDkPOT-{4sG!+Uxu#kXlY1miMvZ#NkcvS +W#_ZwXO@5ah4*5%DJQS9yr|4jpdnT`!R+Rr4C(N!Jpk?j0#xpzNS+?n;chg+sj)eM{uL-zfZU3TITke +;WTfW~_VvRK819WBY>JCAHv7t}g4_BO{{5R!tgim3ND%GUcuTQtX;_!KRcw?9#;&{O~c;wVZnK?- +%g1+Hdjgw3`wdz?(&gCKr{E5QJKbb_A5nnO)X7ZlP#Z7Q5a>q*;p=)jUQb(Y;3v|P2>Q&}u;}$;4%Y0 +eTwIpWo?zG~udUDC*yu74DX)Akajk3+z4zSC1MHf$;zS5u+JsnGNAGCJY463(K7Y#S-wS*_%(z!diEH +1Dx-3zkd%*8Ku3Xp8bmETJO6RLgy;Q9HpszgB^bA_LuyA_N9(PNjnq03N5I(vRT0W#7@8{R*umkyTAV +N8DOUQi0?NBzj8HWrITqk_D+O%-zu*i6S{vBpWG>_R#h0Q~1!v?u5{r%r~fmem2rC^e?VT0mwe5}*TB +7sC^O+3zC3M1mG97SmOA0o&I_x;%1fyO(HNq6_@~qt3b>4u?-^Adi}CnY(Th=`8S48UbgYS$hKzYK4F +(@I?uT;TYyeaxQS5Hb+*H+L0AnnwucT)8+7H>12!KDl=g~BT3g1C!cf!xW@}pZ#|5DuFx67bbD1{lJe +!M$}s+le52vew8nl!zW&{_WNK-# +_Ggzgq%+M(ps@(I5UH&%RYamPhEe)L>Mp;VW%1wo)Sx)0>6o4skEFgG`oW?r#_xCM%_ +(1)dY{S>^elJNwc`c_Kxaj|7SXVXXP0(Q|d!Xsn<;lfv$P`SGx@*>{{=GUs^zpNy +Did{I1-Z?Tj;U#>|n3lwJYRu8x=qK}7rE7bI^4o~5D88}(G}w9=7ne-r +NCt8lLx+^HRK*Nqevc3axiz^5?P*YJa3Fx?u0N0z&wJPM)2h{hHFf5RAukoO<>3+>)Fm_)7Rm%OJcL} +@E1&IJWe>rBF(cinmh@*w%E=({fRHnKn|37waGTQuh&cG+(4_Mny=XzolHhUql=6m>2z28e&mnQ^LG@ + +Qnc*P6x?mla6iCjF~UWmf7cz-c!GuH@bqRdP6m91RMm&>%2m?(LR}`6U^};G!_NAA$9swbd366Zhut& +L@ZWX$nO|{<$tT_&LuF5e4#wLJ>oYbTjP7tEv<7)Ajs;P|M;_Pc-bCVTb8ab{Ye;>5W6%}lIY5r0Zjh +auMRKbHGr0h}Q5*wxE2UhGH9PG; +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 +J)E}rTUZPRE}?#yy2XO9KQH0000 +801;hJRl5-*v?>7r0M!8i02TlM0B~t=FJE?LZe(wAFLq^aWN&gVba-?vP%(1DAQ0?%1vBYy1d{BypmL +ozWH35Q#0UtW#QJ^ilVDG*h&h`=$ruG^=)_v*Y~6z)u?5d|_Hi~wE9gbWJgV~%ttWO4w +vo{~`BI4iBWOW6Y^lc+qQFHI{NAv(gP`9*2}#FcY5wkM*J%yi1@!RRFSbnBj2Y=|cdYyrEo;39TL~1t +=YaY|1&QL_LWs>@(s`d(j4!_mRm}JIl~d7`X?Kz6U`) +Goo~A_L}pBF^FN5F#4p}3x-^kjWj)UH2T)4`1QY-O00;mPT~Ad3bDXyj0RRBe0RR9b0001RX>c!Jc4c +m4Z*nhVVPj}zV{dMBa&K%eUtei%X>?y-E^v8mk3nk!F%X6C^DBn+q6dR3^db~0+ET%mLVM^fgzOlD*~ +~HFe@McbgJ|UU*iit<$AY7yEvUbQ`d^++uVc_U6nwr{N +M6K#dKx=c(wrGuySlsN|SyUSzdWW*}Zgg^QY%gD9ZDcNRd4*HUZrd;ryz47i`62zHbK)Mcbysb=UlhDpd1&8&p&G +R2QpDy_%kniDGY7HHC{mWsiIatbVT~>iYJfTJr8sN(Z&2k<3JjcJP+S{cxwE73GurmpELvUc<2Yls=; +RW@I_oS)~~NXW#YWVn?W57E=a;#GnRl>3=&E0&$$oeiUKaIq@g@q?B6YC{2B>b1_f;08mQ<1QY +-O00;mPT~Ae$=}f=>1pol46951s0001RX>c!Jc4cm4Z*nhVVPj}zV{dMBa&K%eVPs)&bY*fbaCx;@-E +Z4A5P$byLD(237p~y8+e-jHWQqF$v_a6g=-vccI>$t0Q6s51?y&!Tccesp(Mk6(0YN14c)Yvc?~X^$* +xl{*pReDG9Ij+}QsRDZHt=LF*xTis-`QG;lzrw(%VIK{%$)FNkwT&2^`{I9BX$DR1-mSHx`)?qi#PCzG9$2UdzQP9CAiq>2^%Re?4-<{2*yD9vj5kDJZyr5mf4#i=Zel6el +Q5xOEHuKe(V-LAiWxx885Y?80*>rY?TSDWN+bGi9;x4vtX(2{2TwMdQCQBUqLEJwx5vb#l|Z+ZGa5&Q +0@CX-2;bFF*Z*S1C-yXO}ZhL0#7c`h<;L~)-S!0ctF*^2!=z5TYCF4*+;a&z^OUar@l*PHe9pNUS?hmvv@!BMTUeC1CiyUTsv>o$-N6to?(98k9goe}EcH?4eRZ8h{&EnYRSgn5B{B9IG>RaSnC +|O$+UGI`!{&sD|-IMa;e-7zWX)2QWo;QXMcuWWkKYU4al3#w&m)1O{tEVV5~*IqGz8PL(btRw-I|1Xc +iKq{;~uanLO9$vH&B`1|#^RpXMIA_KknMGqIFPW=IIK$dvhS3|&KFJZTd>i_eeCU{DrbQLxRrKI|qjR +>=zSd%iX)L4xIQ>nrkxvfOr%0_*9v=a+Pr8RMtit14(J?NP+oJb!S5`bBDTF7{oVLI~69tb;zWmm}(i +E8>bH_@*}Lb}PhfF32UaCnpDZIa~B25M%B3*474Pw===51yLWA>is8qQ_i +u%33={ReGov#thxdtwLvfTvKKibV2C(~!@rxbS*i7(2hn=tPM969%n1|Zu#5To*DZN>`);~_WThDbc36)^@iWKrQC8Pl@(I$0K +5n&u~9t2uc%@RP&gZr6g*cL%@ZM9i!hB%SBE{V4r>7JO%)<$pYTN>VHF0NasyW$IU0wNM+^x5fQlNy_ +WZy|*nNer2lW6ldS0&3PH!?0j7FLq!h=j7Ne!^A5gS^8CKKh)7ixMs39({SdB>_P!W^laQIB-QnA%Wa +Pw#du(ODYX`qx^0n>2x*i`1X2(tPM0eq0R_$tTQY4Ev8^l-@W`f_EwDGs--pD{&(okrk1Z>vt4(RGc@wf-q`e +}n`9k3o~S4_|WT^%5M2Hs>xr+VNXcP>ZUb&GIfHFw*%5VV}IU=zu0zSgYV}-4=H#F;s4%+p6kB@UBV16V9muy@9kObf0Tf3=hunzxPP*74E~tm`Ym0?@}Uo +fqkEc!Jc4cm4Z*nhVVPj}zV{ +dMBa&K%eV_{=xWiD`eom5S4+b|5h`&SUnB?c0sE3iv|9{M#PKu{D*4!b3aO~+bf$&lnMUeW(P(uxzO9 +g4O(*pNv+K0cBj!2Id{*Z7B2cxS4{%1z-Hxc3vdy8QMX9;{4ZCag0$8bpKOJd-JEhvR96+RI#`oxn{c +(gMd<$z>E>TwFwp0wLv3VAj7e^>Fhvh1^(>Wu>s>K)nebE&=w=Fc-D*ARP$sg+-A?PUHwuk4r3#Z6K4 +WmqrWQByE!1n)2YvXasGnhnY#YQ52<0I0v`F;T>lg1|IPwihvGfgAMwjLzRzUiwzmzaIBCH;nDbM#}% +^&YmFVor(o9)9>Gqi8b^TpN?LT+k4EEX5i?Zi@#~CIWn2jFMOGxjQH*=iFNkrJrLV_wDYf*=<$*$bVa +Z=t!{$Vh%5dF^O(f1tnec*4$9SN&KfioHcl5Q@Cyaz0TXkCkU)27O^u>wt>H8Voq^{_N!)F4V1i+V%w +dOr|nX@wqaY}UVaL%DJ6_*apyHwsj2uW +&rzpM!_h?1C)RfQDMU&IyFq3@RKSbiXL2yX5Dft((Wk))G>l=~>DcLZWrBuSIrl*N3Osz6lBPb&>;?m +Wj8rVreRcy|x=qr7g!C>tTBHur|wVO9MJ%lbHpPyknjs;Lta{6ocJCgi2@I4y;08mQ<1QY-O00;mPT~ +Ae}HL1E!0RR9B0{{Rb0001RX>c!Jc4cm4Z*nhVVPj}zV{dMBa&K%eV{dJ6VRSBVd7Y9?Pr^VDhVT6ql +W?X%j299QMlp~OLy&{FX4wvQq}^R-rwISv0g6;3M(ttKosVbUdD{*=PVb(&_f+Do4_l_^Lgu)U0rYzp +S1@FK(IzT +O!((Q8;-AP)h>@6aWAK2mldXPgP$QNHORU001CB001Tc003}la4%nWWo~3|axY_HV`yb#Z*FvQZ)`7P +Z*FvQZ)|L3axQRry<2T_+c=W`u3v$pD`jd%q7^5bo%5AvE^(YH*JWl>v1fOyd>$1=LK4Rm$t6JB+O7T +X*WCa}fNxfkt5wxZBob%<{rYq_e8jFlz5m<%Lz41~yx5n?W-D*_lRRUmiV}6$0e2c=AXK`4X-!j?p$-2yUjPJrE4Jw(Wg6Wq9Y@NrUGJc>Z-2S`xsOVIBX~;^mCJTKoVbCox +|uUM{OL@!`Me*@VFd1ojCZ3l=imUL|1nOagmKzTr=71FXwfl7W5{!1CmYy<_>Beg1I4Uj63}Z-NO?@d +Yqy2OJD5xkXLc&tNsVoiPwk2|w0lxY>cSO<`Z|Hq0*Q-%XiUg@7@zm0%ajXiH-P_1ss3OAd0*n6Dn*z +Py|1dAF~cudkc0Z+ef0!;LtshIX2pP&sETcT;f*uh$y-!0 +`tMqxJ&Hfa3t2JFPoXB_z7E6zMCaYZl3G0_Ttl1ijvVOqf8)MKya%qRFlrQarAOZU)knm3ziy1hrSE# +cK{9moTNbJ8!YC8`46*nxd$~4Q%ogbxQ#u}~GBK!qjDVs%w{_XQelw(wKFmX_K5w1DA=X>&HIDoclRP +p~qt?>gw0L@^ElGc-kUb9`&>@WcVT|Py;kV&5T-mh7@XW>fZX(jOhS74?k>^)8MM;-@wVp#cw@YoAF{ +iNZ&TJKzc32=ffn|cQ@r2bxyYVRHo?QRvHz*O(VYX%>&3$lqAjAft6@QJO!iN-9`VhHh2=slD)uGoqL +>$x=_{UW%3?SbNC1C|zma&h=CqSVA|zJ~a{9VM3Kb7iJ5NcqQJVlYfd(5>f($ui6YsNwFJp*fi1JXx#N< +7Wo%Dk0}3e*mpV?DEX$qFSX%^xU8_c{qSnnLq6hUs=pSI3x1=SEJxjwAAVaI;6iL%JDto$XsipH*;T7 +ESg``FFkKMb*u(Idz6NJ3LoYZx?rFNtduJ_uW0neK8|v0%T$!(YDpw`s?>aS9AjDlmb;J&Og8_VRr0a<5_+y^mljRr4bkEt(@vI@<%#R|oP#?-LOB$S +EL%(;By0g5JWWJO>syr!y{2O@z*o~q)gRm6Z__7J<%F(-e=pN{^CaN~TwxO`5>jSaXz5vX{<6~FpZDu +^>~YJ{hS9>KFhlnRxvR;1W6P{XVK&mF$&g%yu`o6?vzR+;mhR+@NUN9Wk71dC +bTz`#Ja4w6a;-IpfX6faHbEo+*!3{wyCPlMh7Y`Pa|MS?E(2;XOF8G6nGZZkb~|_qqDuDx`>UPT#d&r +tS;m0`WZ)8YI~p_b@QBCv-&^Xke1*%%FGpUegucY0(|fK2kt`pFJReqP +qe&zs=2mHyadFVX~gf;xeGh9j0-IXkpc6%$u`cv$dIHuW`91d9ySQnjOi@Q4EqJK%tor~oSa31`ORO# +{b#GU+2j165d=qBk2U5V}gW6C11;b^@rU0v&E;Pz4$>dfoYcV&G>?RTuC~SXqM2Va`QbI(4T_hg}Tpv +R8L;1C8o7X-ZECSh1)MU>5(-+RRi?M~~7cdJ2rxFFF~Ahld#-rDXe8kS#_>;sTJzd9%ieTL=QRDB}-c +3*cWWVfmGY8nRIrAjt_q1mJPd8R+`wPgS|G1ZfsLgWWsZ^15Kr@~LXEK9Aa6u}(dPmORK6LDGVNKH2d +A|7R7kXxHa;LxEmzcD~&+@U={Cl|1jPBp|BF67(3OG!TJ!?L(Z##pXnK091JwY8u07s=ft|7AF8wPY{ +GOWF3HX^XvOx&)5w(IV#A4lmQAg1;$a19tZ1jzAye<7f@vuR49qd{Uvl<|v)S75bHdz*MNpg%4z_c +9VL78Buh1&`RrCKZ*MM;i<)2Y#V0UiM%!1Y^zbgAW$yHJQKRe2UC2pGcD)WZkMRbN^|R0x+|oikn>$0<29N1%a;0C&zf +H&3UinHh-A$GdtEJfiMu}!Ti +pioB0yw#8$+*zTLv9dGt>QlF>>5Rg@~p|!-#M56iaLzaPz)J3ak9t#!%XUYTy}yArnO|c0|}Pv_A*33 +?l~YZW)HfcF&u3r)vqE+mdic4LTFiDPt+wjuo^1EeFLteBDVKk4F12G+k#lpv#>LF$22%)?8Yv`w^%f +&0V#6AZ1RJjL|hHGXkQqn_~5@a>PDhgf~~^&e(g3QYx`HUA)1{tWLrZ2I9L-PU%$M$)@U$iUt5sAipi +cY*SZ@n%w8$do?4saN3TUaHJYwB4_`^kwDr-h}ViBPGm1?!qjYREjk-mZp2KKyR_Y>qPToMtkA;U(1K +21)qZr!XOnXeen|bHO`)d{(Y0Ppc+siH9zS4W&og~5FC@E|xy4j$KZFch?tr=GA9=RHdoNgFuoGkFH6 +k6=zysHrp{imPN@b4C)wkL~(>^R>){f}X9w;7;1qT3T1At0^ADL0nN@3bK=ai)aoirsEZxIvsNr7clW +h3SWn{@IUSIcNmR%YqEq&q;7K5a^;?Uih2Qde*-DtAF5Vt{YbpLQmjV(d79Df^Fe20wh)o40~wTg9UY +Ta{nbr)#E;PjfeH8O68tA%81kRZ>#I)OUtW?H}DIwkO?=q?1h}m`25MJ6}4v-iCNJ6?KJD0~khEe_~Y +-vC4=`dJZR0sM^w}=Dtv0qG`><`!OR)L>)0&4N67(csjNw3ia#P?d^;9En5?%8uAdDAIp?X9hsWkjZ{ +_Aic-ikte^L-kDr5T$<{{4jp57gue}al+Wnum>@OkgS#u4LcpA@DwXO!YySqork&|caySB8u^6HIaSbN2d+w19R7AV3f1os~*FC5_+H-*CYNTU_$I_?+(b>z_>^t_uo7am)E7NvsJ=DKbkl0jA5Mcjv@h=b +#Rw#rQsOFwSe>zq_y3pu6uIR3PPaBHlZY99ar@n61>qL~dv1&xuktEFaJ)KQ~ZEU>GOf^__TbT^hwco +mV^B!TFQ60CqZUcg^>d^M{tGnlKW1HuV^Qpev<9Gl8PHsmYO9pi(!XiUztw61I85YbuMm&fDpxY`eTw +$A(B-iG0rx2mq7XMzbt~R5A44y*P9lg58^kdhvJb%gP$MzkgVX5Qg2s)0wXNJVAwR;-4ZND*C?eEi>U +QaYqK){btu7Q_Y;dY)9XJn*7Lq%J36V|2&ea#FW%Hm-yC +=?ODdco=p2-xOx_+6RZ4Hp9Q7C8t=_PHsmQaIan2p9Alq+7^mhmpY8om4>B| +SJY#D388tUGV9ez3Gi-MF88Z;qP;EBTYn0C%ooex#STy6uEYu5s`N5DV%s3A9AIs;OVDsUlw71ZL(7rQA``%QftH|dgX+U<%xHsX@F>BP0WWi$0 +0;8FxD3~Fj?d;eYL$q2@p^7`(dMUb?BuYaYSG8eASGO-zFZ-yqR55H$Uq6=mPV59?818+0a+KlRJBUo +mk-#xN(Moo+8k7FMHr^)VwmSu4vxb0@J|`&o;B#Ls4v{m$~*kqZ=8nLdQ!Yx7imCk)7TeyfzrBsWJA@ +bD6Jr4w5q4ws@0$tntD^9r0P1f7|X65$Kl`4*hAMnVm^Uy?1)-ZPbA+7zc-J%H-Euss?6;J4OEh+Zue +Qal#rb+78FU0tI(Wa4@uZabdVdmkbaJ2Z2E2gRKGd|tG5>E{&7QVz~uh`P)h>@6aWAK2mldXPgMwkzg +4V8a$#_AWpXZXdA(OnZ{s!)z57=X& +LKAHDCq*d1n?ovCcpy0cCiVt1-gYoOCyVGiWEpHj{kk%kg_d*v_MgyK5W+3@bS&en-5)x=Pw_Bzj{=f +?rpnqYFURDdJnha!_CjXhzF+%@g$wMW^^&SNXAd9Ami!kQ%NSMN|C!2cdaaHy84jaj7F8SjR@4V6;Oq +0TI+)NEE_6ch`&g;;rmAYlctgFXf!Ic^j_RctrxObvB5Vd+m_tKE`CrErne)3&v-nJf1evzighv((%H +_GLW-&t$y}^!Rn%gwU=@f2y^-65TA8JABuk-8utG+tMORhiW^iD+=2v +-$7Rs0@moS_I-SQ8KyFKm@?5_&d@Pw#*rLvU&V3=i5QT4&!CE&v^12)IE`Zt~xUn`43aVp`@M)+Emc8yr5`8an@EwXtZSqxVlhcp!?qIQe@ +d!Eo-3n5o=-gKYKAhH?ey6f4uAMzmgkV9n4hW0$=EG^8Y5(+DbW1Ibu>LbivpVi{`luzG0b=O4#_Pku +$*@M4DKHAx`^U>lgmyzMX`34(kNE)AtYEMS_0SXIR>b2ZJp%jq4UpGh#Ykx-}Dmu?& +v2#LNr`}|sAqcqraq}l9&aPRocEt!?8|`-(psPEII8Lf~i8KS4yRG4abI?$1EU1dol4rrtyYgTdD;m| +r;A#o?xOomxl&Lte1fiiWIv4NZ2z!=r@6%RX1uBIvazl6ap{k`%QUwzZ&)#TY&YssHwEp(`y0nGQT69 +foGV7MtAFk0sfDR>I(|arykE4h_c~t3#O!v>xTr%iYPo`o%7dMAyiQhxhhScv* +pF&if4p7XZAN0F$f#o@{ugQzBolZOpZHGQkgw&w9Mc)U&?2fS$%vzvhnLt~ZN5i}O`-kV}{OiNr$J09xe>oD@Br%#Ei67;FCdsWbwm +&Y}sOlM-S|JetVR?wI7572zhp}(Ozz=}1|FJGmcExJL`xlmz#;3*^^K+lF&*#XY&Ea2^29`!`i`8)6Y +;R4?x1WH#J6IhhC&jK|GT*qu#1%9yrvo6gW*Fx=CNE|aTiG%b&lCb%ANacf{Z-mSicO)1t)2ziPc43Y +G(s_icCR911w8;sN<%Ncg>Qj6JkS3(@$Th& +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 +fc&_oGc%*g2{QIfa$gMU7E1i-oAzv@ok)ldA9 +(sI`V2yiYs`AxEoOJ6xM`nD9qrEUEuBPacgOA(YZhqZBORDkoQlApef~;H%4uac&{D_|f%ce4o)AR8A+?sgZ4gFs6oi))z_NGgtt`|zD1DT%U^+!d`~ERpkne +lr~EggyN0)7SUcqJ~S=?6p`|_7R@#f}NlJ^#^vPMb2)yHcC!TCMTZwR^%WJyuT?xT2Ttn3-+Pmc?Iv! +)3eD$Y#XI5tGKCZvFcuxnUq>>nMLV4%^Mch3m`EQznP{v$?5h!as!vNFlP_YaLp}zRK>nu?wORdTGch +^j?-;l_REur)%(SS;g4LsQ}$Z5vbfS(=?OgN&{%fIx8N2$-3e><=jqp%dDsO@ZkFzG&Xy1EVK$je3Mg +4-Aa6BfssWkpw6Ktr$S+a+oRwQuz^v2o1(=fcp6$4_%qr%n>A_aQFyfjsqZmnI!ZINPg<~Q~PEJ|#wL +y!NNtfA|`{mv3w@FaomM-tFK0LDD{L9tX%UiY+bn51x^*?wFX}789WPPjnlmIx`H&%=d5`rV +fW6lnRIZ*G?0sO@6BI9&RYW{qw^18gOR~)Zk<|kf%Y423_})N3&Pxv8jMRLPk+03#jnomPl`!pS&6Av +J7)IVTF8wd0~!rah&FU>3reDB!q1j(gj_S;Q9ApAC^RmJ;j+L4_}pUjT@*O;a2+hfcp~n(wK`E4!s#- +*TV5}3Zs^?$~QZ@JzKkYF5RD+N~K*EoJ* +?J0eDf~3a9~L$7KKqh0B@ZGAT?Dg~`%Bfqk{n50z@zs;8k2W^OOk-EkoetS9WTL+7?N)}_^1(1Eo>Y0 +f44P84P%8pbQ!Bg4rhG`5#VKzBblq`f5N@7MDluk8ZcYtb0cpnA_C +6`V_o70T4xD1lO^%tjW1t?b-C{oN)UrenPwfHwmVYSLPAq^Z2tQr(I!>?#+iFRCW#Kss1mbQrolT-d$65U#gP$tLdeTrZIuaT(iZXKjiFzIPiC3% +dklPqdd94hBshABGP?)g)<~4Pa%pGS`nV-e8kY4e0I(?`(slp?ohAp-M?sA3jXDekZ)^o8Zt_4Ehq{! +r5aE(0^QrIj@dbI}Xa^AlcLZhKd?}sHSttZeI*St0mEu$ui<;9sg`|<2-B%)jYN4$=y&u}lJj9=VgCW +kFr%ADWP29{7yfa#Cf2?JC{MC_0_2#B|aZ1wSFKl8fvM`SX+aS2KbED?v{^N3wDF3*9DFpSV|NMs`CLx +d)4~3Rq>~>AA`}-SdJ44miRZMrZyIq=)ivxoHe3Z99V-(Jyj=ZL~>~C?1f}Tp-8;Tv7N@6cVXJn9L-+O+`=>^qPu&<4rtni?Obh1p$G`Pr$SaZyIi^^t%#13 +J`WuS(#tDn@+j>i_9nNGvDAv!p~SR6m_ +_jyq+0E0}k?l3?}K2fiL7(LNBxVsGetsxp->~rQa|*_Bc3b0A3A&;kZNM^~m4caJu2SZF$X(y0(+~!t +Ifyr9S$jmh~#`5OAK8A|I#I&+##QOk0-X`F9Y5HR$Q$nS%OA++fFM9Hl3uC|m@_wI5~ScPe5?L>Tq@! +!|h>`sTyOgIPZSy8lPb{gjS5=y?#*3a`F2MkCs2NR-$&x2}~Kf1Na~uzXd68yIV@*FJlAPm{IcMVO#R +6XRjLqd5Bj2LhLhDa}a1t@vxl8!o>1QRKkg&(4eYfceV>-F@Hm885*>X1EsNdYgAws0R2ZgaxMozJ?c +k#y*>o+&|oG5na=iIHs=`ch~U`8t?z9pB~sdcX9detv>FjPR{=Thc|Y;?(UmYtLx0Fj8c|Sr$}&N?lP +Eu65^QXX +bE3{RdD>0|XQR000O85nWGJUefd&!2tjO2?PKDE&u=kaA|NaUv_0~WN&gWV_{=xWn*t{baHQOFJob2X +k~LRa%E&`b6;a&V`ybAaCv=GO^e$w5WVYHOp}WZj@d5s64*n#ZE0aCr5~_2qsrrCs3I9@oX!6Gj%>$v +AgNB)%zIC7KD>sX-#%bZC8GsOd7WE9IM6k6d+lU-!(3}&NDF*P^8R2=hC?fGjnLCcPf^DkL`+ +XJ2k7v%W-RLP#Ttzw#29kV>Y;xXcX>N;yq)<^o(&Kj+tt`1`s8bOzXFcx*_i3`qZwfcg##Q=>D1BBcT +w6(ypXrd6MKG3Nz`j4zs3BM!43-Nx^FuG$|>^Gt{#gdwk6L+?i)Uy0m^*2oWh*wPaiw<3snI$rsOVaA|NaUv_0~WN&gWV`Xx5X=Z6JUteuuX>MO%E^v8Gj=>GXFbGBOp2G4emJ$z8sfTXR4I;}S +DNX`toEUVn^mqh(v +wb8kxL4@-#CG{!^g+>l&v-7uU$onjI!`RZ5-!6>wW^F|Y_^n=mbPGRL5ocF67PR7MptxBi|&RyrdfhW +Vi)?VL*4^T@31QY-O00;mPT~AfamBcc!Jc4cm4Z*nhVWpZ?BW@#^DVPj=-bS +`jZZOpw{v!h6wE&9%{2s`Jc+jLKfd5~E>FbgD*Kn#MHYs?@(NPs}_>#w6d#E?5Ov#Pu8+_cyk3dh}X5 +cpc_n>O^nzbRe!NZQReUjL_DHDOSlitPH$Y?}TX&we}n*mxcOPZxYU*#CS#3jObIr$=~6qW<3S#s~_=P>RM0hJq=QWMG&;VI1_)1mc@iT(hLTwZ#=I1WPtJu_4e6LTq4WLm(R +l-6Y5+q&7sn!Ke+BZbD>3QyY}o(7|$=EsOj-2RI%^8;0D_;U>m6DZXLi4T)~hU=z?ACfLx(CVe{tvYa +ZwH%Ppp(G3&5&4&`?&od^ki4b^$!6T!n2n6YK1gK5n_wy*$U0rQQ_E3*>mjcKTfjyU?hxDF +g$hF_)0!RI%|j$XRxC)i+hbNWr#&=k;^sSDD9_gv1cyR9gb}*QH;9~Rr65NZ$64=;nnLSRD6m8dwA>9 +SsbDcP>30s0gF$0X8pGVnkAM$54LM&hHFy +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 +EX!L2H?bKU!{qT%g~;eH= +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 +Z{c-6w_r@2*FTGgMD-uf; +or9rqGMZASd?xss3!C_+SLmKlCGCpfYH8ir#|W3#JL8oxPLZb}2&294C5NGd+9g?&Dl~p>K1>Ti6;?%j-cc+*3kKL%CJO4sNf9G$I +Dgzgk2~owhe&m2SQKA`TsU7IWw$#uNaQ=PXuKF&-4r%zfD;z~?E%obh`)hdAy(vN@)F8% +~_KI7!NvQk11Rn%LP%inW +i6LyOR-W56n$QK09YQyo}Ss!j6Z$sGK&EM)if0^;wKKk^oLi}^#Q1PO%jA*(d +bnf}ATc5QGaBl95$g1viHM^ag?c{CXuj^zCg`n;rpWq7AV}ufW9IGHWx%ifp^pKLo0Puw^$YW7?+f&I +UYI|7U!bpE81PWB8auu-g70kL_xLNQdz#wsj<+o>c0tbJ(;+6=najn>O(Isw#>YcS +C4VSJyL5BmSZ2@uF`bKjTwrJ9sHnI*Y&B=tOn-5<9u+8%U8Q`<3?$1t^?Ro{PZkMn?t%y28me$P5DvO +HUJuYDBA$4U&cy%&cLl7O~Reka@NiwQCO3Zl@go+RELPa^;j~8AzHU_kgSC(PzBipO&H#{3C_T#M7@+5p`jCcdMk=$JMYsufxHo|Gsg!58AXys`#6gMESL;nyg5=?}+*R +_`d|g|DDr*8k7Gx=C7d`pe`OPa2LMPFBV%e^QzsDydochSDI(M#6REwuD{MU4PIFvNVJ5JhVX)yNxI- +I34j+{5D@?`f-k1t_?3$a^e;fikoc^d_{WF|e5uEj2Cr}lY_S0Yy-tx!O91{4FU1`gVo4n(h(&KF_{& +E9im(WR1(Siyj?mW?QA>CRioDWO(xqYrLH{Kb3risDko*-CH(%^574%u$C)XkyGxMnSZ@&9170IkTG= +GHXbMVosil$F&ThiG+uB^pBN8|L)R1#z6n-( +!qY0{oV#`yyUL(E_X4lyR68wTyu)s3!GG9G@(;;Cdf*(Zi0b2?t&DewL^~fmKPSiRUW(YCXgbnQq6fa +S1N2FyPdaA7%JNhg3=<|aP1n2^|j=JdeLEV?ybPq7L7*bKYA=(#s0Ir`>JW$

gcjP?dl +KCf$vSlk}dQwhdzuMPS3wndybnQ&0febQcyxHlWerf*X@C3|#Hh$*uEc0b56oNNYTi4i^NAC^hElSx} +H5fOfcDm-%#M+hchg(ShIA{6p{<@-|y~c%Xx*MP?Oi*6vA{aCQzWVt4kh>b6PXtJ$&;;^LNm(i4p6(_ +^xB87$<<3rQs`92s@oa{2{F`rA;fRk2~^md!+=!MBp8Z24bp(CagmnsX1Q`Cx`lFh|H!;Dvjw5Hrt}Z +|NZyPLX#2rnlL9f9T5rq}1KyW(v1*B*h#9lbY-uud+lgHSyYjSm>>lxX&=RNZNm~y`JyerYks_2rnA1GYP>Jb7Rz +>-oFmQ3OmJq8?txnOF&lP^XCh2{wSt}#Lf(QqZR38AIY~JUS!Ni0Lmw?F-V^Tmd?T2&jPpe6tB^t>f6 +1kV(>h~!;Q6~j&PnxH{&>fqs<3nVEw7`R;od6leyNn;#`UV5S7F7#)~OYlpda+PI9gYIum~jDi5}z{M +^$N0$E)rnyFRJ<-q?j{ff<}6*EvH7^=>T?X@~Q4DiOxtH=7GZRxHr?jRkFO5`R;KAIb)Q9{s^+9fP(A +w0&V2|1VGW0mXkZ(N8vT3L$U`p%@HDP?(@8nnV$jq8OY(aF{}Hlz{0kQ$guh8DBVDQc!?Q25^cqiwQh +I78^D7N&*EiyObHmHWd0LY{SGWI`Rej@T)L!{E9k!V**Rbq+}rmak@bDG8417eR049u;0KomMmbr^m{ +95oGdH=rR}Vevvi08JtO+VlI$Ke>J8pB +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 +l%b?C_z`pBI&kqZGbk!5! +1lYN{vNXZc*OTX8$rP^Mq@C6AqYh<3_)TanhS2OfDr;5bEy=}TCG3i38)ApFeo}x#8wobL4qCmIA&vF +&}NnqpXZx_Um*f=_Bgf`&@&LN0qdX~NF(Q)UGEwjBI`TEzlhn^W5`YICqh91ehu5=2xLTJ63n16TMrz +$Sq9=LNNRut2Mj_uh5_yGps109c64~_)yq<_h&6nqH68f`!dNS;E^ +BuIhriU?g0S!_3^OSE4{9>m4YxdzFmGKBm@B&W~HDU(wp{`3&`+hTIuUC_I}ielHh&L?h`y9iz9q3#2 +j&A5f+lqTavx*o*p?Ak_*U3H*D2O}oe6!TD&%oI-kh-o`|EXCv|HmgIS(+H&qEsD-17%V_u7&OLNH6>MnK^Nb$JQvAW*GPi`bfbg@*sY^k3xBFxJEkzMqt@2Bo&=W;A7 +`kT2pusb%lm*hTO*~_8Il%6Apl^jm1O5Y|)))?sFj5#kgPff|Wb@4La)yifc3kpA50yE^wkP9-A!aJ{&j@q9M6DdP^+ +iw|4QWu3tR+{LnadDxCsiKg$t`>6q$x@5h{)aR(uun_7md0o7$eoETbK_IJQ+nc1hjqK>a@i~Oxn7=~o)~Q{G%cRHd+xP=nz!W6zb53Z6UTc9sbeNSou|1niaq6?iv>M +V%t;g}2F}K&=hWt2-Vk^srAdpU+7OiM{bGctYL+5FzS2Qr5XFgk +K9iEzfzlx6&659kR&Vx^Xv2cA0Uc_o2Jcz5r|jG=@QukF@vmdq%aDG-sA9|HPJ^z!>oSrptnwLUtYwX +&8Yg({Ylm)Z`LvXA?|7=``83Grlri|d(q|#pnfE7m$)fJyG%?5ys4e+4En?QJgK@l@MA#3KEm$yj>^p?i8=YK#rhk1$c7IWmwSl61ty{H9CMALk{Sv2P95rH;7=^ +EjQthmi9eTc{AA7i$@6h5GX1dOvk}&{yZs!v{rO=(NZfoqP~fqDrFF8pk0xN|H +2*!WjBt{b{p>2GTJU=(kvdErJ5op*28)8PH*vZOV+Gw1fUi0Dz`|%uKRHQZNpZTi7;upQ0f8V^HwJ8h +>FK2oiA|B>6BLzwknokq-VerXE>Zfwj494<7Go$s%*Mb0^7SQ?vVG1l_2Hos_&>H@&#iH{hATzIb4MSRI0X?JW7Mi|iCE`5Bc|iudTj$8Xo*q`f%YMnjvo&sHcdQ21xjv!tf^(u{J98ROJpSBQS&z$PUsv+&g)&n|_O?gjjRp7e!?hr|Fj98MJcLt{1WY0i$)GYhZV +l+Aaas4oBWU$3V}TdH1}xt}h_%a;bjus`xxwAAE5<+ot +P%#QAW#9{M(3|4%N=!o!1y@+9 +k~=(p(p$9Rkx5p)K6X)rv2%5Y@JT4GV6AGPnuadl%|`wr}^iey|l^@)_xV{7da1ahA*Y;bPL}{7vfi} +BO_AJcjC+l>29A~-slz09D$u<3sX8@3rKsOEu+964wF?UxWEA7)~1)x?jPNLoV0eTG?*bm<)GR>0@>8KOO}*{LjJgThHK%YSL${ +a=%l5`Jv07#SE{8jY`Eo3BuJc$f!V*MU5C03#RoB|8_;t&rAA~6@4!`1O29he==R_GRUtWvcnhQnBDq +NIHJZ}I{WH%5w03^wU7Oj^_kNc8YV5s=~-cp+wtTgmB_nZJcCklw!`vbM;d)qDq%KNbe_Du>xpK@2-- +`^BQjz;zB{yL%1?W|o_yJO;zt76_t)DQuAfb25C-a6%H7FpQ@b5?J>1ta5k!dwRX0^qx+!(k6K_8_ZR +U`IHpR29od@QA=IZ-Vn(v8vVUdF4_)`|*D_f5G$J8~BcT*vyJrni*bf*J7X~Tl)FPBIV{AIVkF~?p4M +UYvF>@E?lt+DK2?L4DE@)HwP#-p%33L2%wza5U(Glx}oUqjBf$xnAQ5$J=)mqjf0ji%$Jz7M!7d_LYP +tQWpX&cHKNgxw!$&iuPxiUT8ZhQ{UfRX|~!V4uraDnq-B?MmY8FOoCBlyrs;5qsiL3yl9v)h>deru +1j=b$Xt~$ml@Uu~Js$d}E6d%dHC_%v!BL;ufuLjHOs*Z(*FK65bM9D5s$!*cqLb4f10ru3mSFvZEZmn +Jer1aIU!CBqHR3-W{Noe=ju9(NVkAzZII}_}gRgXwCSZE~gT`>2#0l!d0sxVKhWixwD1l@;5GqYT7N7 +a#h?s118FYyL)>ppP`#^R}80p@xDnt%a<6| +VD7?T7h)A`ImBS4ht`W{V&|o(6Em7_@Ov%x2THHCh6X0R|jJZ%TGB0ca<(o+sW64}R<2Br1Rr&0h-uw +%3X4r>`|QJFX!Wj<9vy9DgYv_mgwLPd&P$8k>X1dJQz7 +bj`%n0$eY3YUuqQDcb~zBlg!XpX`Y`34E|}p02X=uis@DDOc>-RVjQsU1t#15oJEJT_f&S&Q(X$I(id +88CjNQ|_;7fPR2O7(DoL*;L-^W9xcz+vOjN$hDeO|GQ*`zv5=Qvf>=^sVBmzG2=J}<_i$AfY7b%x#)z +FGYR+@&ri&u2Hmmv+=#2B2Y>}hJs4w2PX7Nh96o48#r+rjQRW(BIFm^w#o9N=P9CFZL`b6RxO2E&GP5 +AD$OVP`FE#qb+FsXQIa-SLEDH%p!HhjrDuNq$O!aJ9thct5+E(A*tzWRZis+}-mI61?3_i3e}}EcD*I +kCw#*K5t8*A9BV8DLR`8~9AME)2n)I$0(H>Gmigw4WUV)m{*&R6ezH#btDXa +sblAJc_i9WiX49VlfBhG!cTW2>%}0xNweBg91#~>HWLcG6syMTCr6&N#Tf+Oq)G=z7pOW9qcGo!~^SA +E`^!;4?udEWkOz|E2Yu4^BF_|XB1G_$zvwDHt)KUo1T4TMvcArk&BV&S`m)tPF1wtl`j6fPSW;uGHi( +ZkwVwyi%vZ&rUlH*5qf>fU2u7r}f;)$k{ID6j0!JrFPU(w&Qu-h%!sm+mIW-0D8_0m4g0=G>19x<@H7 +|9-TUa8TIs@xQ}6S~LuM=|6uq`C$LO)XO=vq{B#!)u>mT)d(k8;}|`YZxLOnIJ9ViTkp9w)@~D3 +&P8f!^#E1i`W7-r+%BqHW`THKsbvZ5^1_Vk;om7Tdjm!guxw(muCcAT$?*Ok<#b +!;&vEqa#{7dirrLklHpKFrW2QocO9*jwL_u(FUI)H>@jyk{g>M{Pk@@^56;Bj6gT{)Z>~0pJmGCA|!?GGUYfBYx|@E9O%KL1HvXBPdQ&>xK{0!x*TUuOPfqV4$fQ0n`Mx!^|dio` +M7~o&q+y0_rd3{3v`g>A^sHc!lkZ0%Ehw);fU4V8mhl8B0LfpTvRC4bYY&Hm%p}SDH2ifNJ0i34`;lG +?t3Cbta%)6v)d_K!zQG!K$KdW?>B(sBJcpp#aB+w>JaQ>l>Q}{i5mS)d<3k-!ftXbY+g@SAY-bafxXy +k)EL9=?9Wh<}jK^4b7SSIQZ^IWI*ouUMDy`2 +VCD@)j$@^~}!e2#Vpl<><7a;iY`e87BrOX>+t_;NTd}3wH*PmAm{o5t~ykh9zF8OB_*WXZTp`H}dHDp +XiRea#7HGq1ux8^}*yS#JZWnQ3!GDMwvy(;UJKdxGFY?yQ@Zu_E`U))PlSnkC4UBvQ{)?GUcQ%==j_py(m(vrIufd<6J^#khYjcv8Y +o;#;BWdMu||{{9}Un$+^;6+CG|6Pc639mXNTmZPPA +nEC$&}xsP!i(GbWfhe#YXj-v@u)o^C-MvHWC({KI$Q6UY7~mFB6To^B5$A9AvLJk}VcJPjOi@KeG{Xo +$?6Fg#~Swnmzj>!Y}GKkHS+1}HDIY$V*M2F+T+#`U|ZA79eKUFS9o9N{^qPqo@ZCBi1f3Y@rbU?-B*9 +l8>XY!`;hf%RTVnc1)YY!aDy!1;$8-+hzW%d$VdbFIRoT7mYr*GoaiMU%UX%M)ph_V3~fXXjSYhim2K +;{gtPu{|&IQph8KykN>>g62b}(v69YD3=X)yhAI0j2B0O-*JgOU$OU22kG`^oHcYR220D +F#7;bf?8?w$Y{i6n`PD=RNlTlT@J_F^*`{M3x(H&ti8W+Ff~%6D#&Ouu&-x<1=OE&X^%HylTPiK`{Qs +Oz|NE2tM5+Jb1mB}Bjt~@$(ksGJFuejWx`OSBWDJTBG(*7@gV8Ya;V1;PneOHJCL5Omc1&PkZk?ooz} +!lTDH`<5AsJxJ=r7vpwxjV3wABGelJv8&GMt0+t@N0HHvu;iWTNS8gYpfbe_4}V88GObLjl&V(2d|=_ +HRYgl{ZHzm=8oZr8;bL`^&eplbeJ*wmGLnn?BCEjuq$Eb*vDc#$Zh=-v@_NzXM(V3RrdVO_4@{v+3Td +Y$9>K$I4lYTH&E$4_r~Kpj%l-kR)4puKd}+^xrb-Pknj+1)~O4u&)lN>NiF$*|7143UtM6EG+t&RezD +LSvPtj{tcl&UE}XA5&GRV{_YZ?-(BPHE)n|q8qry$c@Q1>-S+y{)>EcMc3++K(ftDl +)#0d3xf5Chmh#H;CJHUQlg!>PCvvJ?`078xj0T&IL)LWDQPQ`W9k$+t2gHaMYBzdD$N{dO_cHdi{8-& +SnS1lh{gRso9LP`y0#H{{6tKd`|_k#MX!1U1*`)uH^Me&&Y>zncVnrVc+S}xA}t1N5hhLlAzq#iuD=I +pxr20vYwM2%B*t7ioGG7AX&&*e@~^V#UgDLJFi(Lh{uxBdpgyH?i4VsYo(VzCrsPJu((BFz`DG)@9uF +Oe}49Uyvx@o>*tq$U@bIANW$pKR#2G1NEF!;h<~@R*wT0_MIqv?zhv_~LN?*7lm-%BC<)XwiOpv;|Jb +M$aG90DU_ieMCpP~I93%~q2yldzlYHtICO*xg;ecqYC);dMf92eSfd?SynTf%v(@kUyr-5F|`kY)Jp< +qxA1s)j*1!mQd%}#!OsIHVKk2l>D1e6Vd9``nYwq93GfcEGJ@UGudlshQe_58QNu_Kk>vv_>_)&9f5F +~Rdf+QBvbWr|xGWQ}+_^)_|7A_wHWZ!qi{lceIbtYaDCR +SBxkHP64kvH1ucSFHgs5^c3Tb1}3`KBwSZSpnEkkO|-T62=a#3+kd&t$Hdd(fuW5

v2p&D9K`cn +#PtmQNsFue#CEpV+7I3dr$TxAk3eFYj=(r^hC=ppi>n0BC!GCB1@=Gu4-%PoJCr1_TRD{UjIZwhMP_hpC58M!~Q!v4@8<~<-D(Jm4$Oy1 +(Trw$Wr(=|E>qE;L9*vu|DLl4+)XFg^J#Gh}~6qwg8~wDmJGC +qH9sE!It;P?(`fEb~OBjsQ>3D`+|eN-S>NdL}`W~VVWjsl)?yvW=Mj7F_=IZm{>QU6ba ++hhkY){hDk6C#+6regg0RiECqpho^7~C0K@}bm1~UtF~J}yP%DE|&`?5UfI_T)t`NL}?+RWkeC9Y{7x +>l*nr&U0BmD{CS)ijr;cz +wWbMU7G*N+|CFfllbQPBqdiS^wVUZu4h)FYVL8MZy)!$WIt#1{9qBQ^?~v!fG+09MoT1a(=J8DB9MbI +Jb`2dC&X`jT;pjN3VHms(wFYDK9-@L0^5b_uOb}3tHMEB8BP%2K*IM^1~1)|yMEqgNcd06UC!BXjTut +y&yPs17a}EihG>ahT%Z;FYCuZ@=nU1bbKxmYtykjR;6L+&c`n0%(;?UWDtYqHeiy$O0D``s-2O5EguD +Kc>ah4Km`F&Y4+VosuSHY%P5U%z!tYruqbk3b601P&JB)eX9MzDxzfE6YPF!En%d9@_oY<##wURNNJH +PQG&PMfdU!rIE;S5|4zaHw1Eum|ryc^8bct>p&jXI#t;o5jhM4qxef8c7I3Hb+no|?UfGHHgmrO%%f^ +l}m(#bjV>;5%*@M6iI|OWo$l5P_s{&{%<+QnDwycOaM@6eYoO=iq9TyT-NrBv +hnIaSsXFnH!6-Gtw)sb0Thx6GI!xIRRv0#`GlC9JYpJRO@|=an!jZDZW`}|BnBjcG^MdXc#l7cv>9?M=a*a8)6S? +7BE=Vpnf|ZXFE!~qe+qwIv51kZbCwkV)p3-Z~Ri|Zcy5o%*nUXwS?r3viMy-F*SGyLom}n2jM@}4Jj? +7}dVME=8ZXT>kk#Dmux)`^pYix9-F$2ZDI9xpK%ZkoO;q6B$KQxL~a&1bNJ%a4RB?lFnGCGgLgKOxl?jyXO;zeqobiK5Z{C})jV)PI}@^WwdB_PVXG1xyUc$e!jKwZS +L+Nd1;{I9QMKOC|ui6-Mw2bz-;;5FZY90;Nkl+(CG;|q9<=BglW~Grp@z;oDGvkvq10t2x;d>=POQdV +_#t&bc`L^jbBuS^PU64xdqdl2CrdsA7KukaZ7sM6b?PTIq`fs@B_bxiay843L|&V`EhrzzJPGJfe6ojkIdTqj`SDL)G*=suecRqEJQdDf5Xxc(F^L`Yt|$UPtFyBxHQq$y8y?P97b)Te-u ++Iph;6#;T|~O&4Z2$Yx7I#Ire&4Sx_&*;AhCL(bH>5l-&eCQ**0!$M`0T9S0V#?ms=UA|Ed5;4&7z}f +86=b#QXFx7vFFYV#9j%X#sELVvA?B8YP2(1!aVQjhtVq=Mh`+g@gaga<|(FN)nyS3>;`^qNsxatq-3% +w`ByyKi#VO%n^E@8Enk`mWDS&?=7(uf2`Tu$T_ubgAwql@6|&;^ov3wl~jO|W|oiWt7J+rbs=)@%0P^%Ue*-?zG^v3W{@lzrrp2DqxHhbZ%S=jaFwU)r~ +q8j4ZyQpvWX^*}ZdnZ7pY423^jJXv&+>Y>_FB+5V6kH7d-2Dqkyt%4uf{^U%&yHnzfAQ>(;oNWb{1U7 +E{L+tda3}(!D23t-LVQ?QMKKI^_=BuK=fn~o +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 +W9jA6f(|i6GqO@a +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 +=_v}RUC9@lGO +p&{tRbB5@_3Zd-cf?-He41|?GZiyZcqI`(XeU6PNl6ORS8t=lWkR*-1&Ze7w&+n8U#o2Cyk0xStr>gJ +(`reVG^!M|RV6T@`bA$`APQlTKDFL~216p_tf$gZXVR^F>`8*W0S!kms6iv2lIx?4K^LTIkxETgoMks +TvD=%NDy@2dMUI#b?STb{n@4ilk-4KcuWgW{BAo>DawWM*S4{|$&mi@nFV`fVFH23@2(ZXc0(G^G^D; +5i;dh5L@44fTXZ`8Q#WWdrKOw5cxzyY--DM3DWk};lz*Rb^hgS=DlTm6cq9zv*)66F_;#7sP1Y!Kmh< +p>ABp2_~~;xhz~rEcyClqXX7NQ`pW^Cfh;*dRIoAbd1&q;(U$2L7qwhzn +;mg+rmedQ}JThXWbR$*G4Z{&PWcd#1`7uBcc!I8iQ)XMCRgOIn(Dre0kIO~sywcL>>o_0j)?Ht%I>OV +dbdM+W2b<-NU89RJ5FjEFKZtbVZSUUPoEi!Wh04om)>gO?te77yeOp92bj%c>YV^TzIgwx$>!zitGhD&y&fB&fR&j9cxuXo!(e;Z={<| +Us&%pXtx4q_OB!f2F6DRft^Q55m%*uw7gMeIG%4HC9Zn|V(c;O~PvI^N@{_PM;|E%4fi+~?_88xPv{b +@biJq@#C!Z?b=$5j#oy2)as;x6^g96RVFi$lccKXABJv_x9}$QQ?k&8~dW(Q+V6Uw%6nDu-^?kh-8=3 +ZI|0_vw_?`VL|Lnaa(ZoZj^2WZ(GowPE5W1so}R3*stgBeuS7zpoQakb?-L(xf$61HpF}jF%5m9`76Z +a%ZCxzpCRV`*#ADne7}-^0x`Yf7{(kAA#v_PRJ0$*p<1!K>l}SIR~y~)&q8oznqb?lab&{m>^k0YTaZ +g^0j?@MIo%=@snV@8nL<_A8d!{+%^azV2V)Ke$@i6aCdF5H9Ro=3$hN6NBy;>Y8baW9Fxz{ZDv1&sat +#tqiIFeFXfeG_g9k2v@mYA%V9v2oXSm>0Z_*Op83UZ1^) +W1YbLs+t8W)bQk1_?eyyipj6dG_p`&)FwHuCqk*NItHN1^3h4@}yMcx3^R?Cy&gd0)%_88Hb8(tCt_D +QrvT3f(YhaKH*IwZ5V~2jH+?wh(+c}T(Z$H#1@6czkwKThHQdZ!|6_zfTi10TCF?2fbq`Z*A*Tova|&qW%6t*E?-r;0HY +!0TUgXpZ06l*|ky)LY)Kz;{))h2d14X; +wJKDEH=1`ZUl@@b8dYyustUccO!$=W1v7B^Hu^6>M0V1Y<^Ukd=79Ln6Y#Ww9>(#;F;rUPTw}pazsK_ +v_+Y_qPKjG!B^OiO!q&7m{XhH%i;dp`0}&oe+DjJp8IEHp=bu9c1(dO4BwLukWYJmF~0B5@Y_vgk3x+ +1(K8I*^8nzt*k$hk(z{Cuz44IG$xA}Nxem4ylN8=3;5L>JA-kY@BRzXqW42FSlkY^@4ad+o&DrjQ{*1 +g(Z;uo#+o#wtYIkqm*a!S}yxi8ggA1{XWwv`D_&y4^q2BHvmhSCBI^AW{8z64bvtb)b?5MPNGtqa1!> +-QxrTY22H-eUL(eX-jo!oOP-46r)BeEDfvRFS3#Ql0d|HDy>=ghw#ixuC!KD>DSUr@zi*AL=i{edbUk +9}JO@cXFp`6_@fsPe}uev$?CSrpXF=^60yAka#%gb6?mhr$kbX8hi+S6XJs2XDME13|SVPBo$bWx6?8l~i`_PCWbN_#=i)dp#0$lPbJfi&<&w`OYt9epZ7bx}e2!FoLfdx6 +)1)bobEM2Y +Tt}O83d5m8c1{j`~xxxGUW2SV935e1yymCDBv8K9_ZY#ca?7{C>efD`aouaH?W%xDEG;I6oPooY_}%6 +pF5c8Yl|~3Gl!pi99?!p`JW>Dz^s~XL86~Q2V^Gk;f)feO%Rs!d)V-l>fEZw$941b#X2rYRwjaQRu_~$ +X9k=2>b0;sVZ1A{6SRKCv&jTy1Vl5NJth8B%DO88%`41`Wm=pG|H3G!FA{cGYV)5LcHok5}6C)j +v;nF=E_;8uZ5}Txq*qo2(zB$6$LEEy=|u_!?`Y}erievuOG(7zj}h^(VJ6h9%4Ro<=I79YfzPMhS;em +NgC{6%Ph-0^YGIGdCzPO9{oAxSp3pv1P9PZe~HJZkXPn`JRnyF35{z7l2&_&d2t5yyL-Qg=EnI|JbP` +mk&T)IhaMlDJwZNi0fx3wNcLR5Vy8C~f~-OKcoa!nC(P*?-s6Z&7-2@hIWLsXBN`GB6g6$`s^8mMAjJ +S&)$2jb(z_MHJ^@?YARkz*#AV@eI27Av=*k+1Pl$3s566@C^i&}*gQFYy4|0xl3mEXbbOXz1v1sy%z3 +@lI;pefX%>}B*Kb& +zsMvl-R{*XEItLD%{^JLN@ExaH&+#Ny1eD+*f?vxGT5jgi +!BATr%f|gi6RzcO>Xq_#&yYcvgAh@EP1XvpU0b+idd6WK{16D0nZ +Fj8*vdm?60DBTC@=GfHa`@~`0${r7kK;?VOY{^DZ!!F@La06bYm-hSJ%T1S43L^dZ{urVbSYjJt}B_m +$p_RPQBvREZIOO~}vL&PI7fO!DcM8b?>@}#QdQn>Nz>uYleVs6E1@ARsWZnDYIaxY+cl)`S*Z`Hl!3O +?0V%cPGC&~uybCcPyJa=O&_HxLMaw&3QOK)#b%g7hV +>wxePlj|lR2~W4h???s6>X>On<`6=ztVfq +Af1U{62Z!MFyb{+g#nB_!Uu83zG$XbC!4|a(D7GEry?><1*M8k@optC(3>a}T#C_EFXkO(st6^p0kB6XtElfwSFRnfghz5A{ylLHCd7+W +=*I>7Mb!>|5bR0ypj#z8#veaDOoT&}5STW_~8i+(&ZheGT--i5jufJp8?>QTSU&itbv?=-seH;GN3ud +*a(+6A$-YlE(JiB=4c#-Ls6^g_?W154_ua{;JhD>|&7D@$25lbArQu8h0oE7~9JkfMF|>@=eiSd(pin +gUfl`cxHV?iy=biF+l5Grs3!}VKD4?QmwCMTm%p7x`o7tKeLqnvxZ^bC|dqi3?jL2t;fDgec^MGcT@K +08aWx`d$-$p{gKYYE6c8NG*<)r;t@8#lZd}O2KW^R{xH>RIlNFBTgCpx1}yM=;+ft(I9mQ9SIGf)Avn +Df8sp%84cJTH-;TU*>Ay%K-iH*Fuky>e=D)rlA3O574*t{t-M!O3Yk&ej^P$F}o_SyzIgPw3Dj5<^;t +}@=mZP4%iXae!bbW`kGT?e(`{cFz^_rql4oYyvZp5>?gkD-me4T{%Gco64(DKu4R|O5{j%_d1LlJ3;B +Xt9CE~khliPMZkp8rbyGHcftTDb}y1S(CdDz$V`qwzA&Ef{zx$wV&_*$qbfm8P@j0vtD9to7b|b|vD) +i((A^)>egT&@);DG;vO}TQe%#S7kgqT73rj-39FYh7x)>Y7OA#s+e=Qs5ibCQHVD{98YWH1|mLpBy#s +bxiulc18JMx2wrsO7`LFzJteTtVMEy8H$d +N@0{jJ4zHNcQL7Gu*Rb%m~enFUmBpmXC2T_8=zYFXl?z-I_UiYF(oXNNr?~((8+~>Gg +I774WqynIoho-c&^Z&4^?Gn=>b-U=x+p#8Fym_Km$qsAMLg0QS +FLM(;R3fZ`9xK{W<$U^e1-ys3#z$L{dS$kv$2gX-<2S+R48<|GaLAvG^1*3fQ0Hg6>-br>URsIzBFGY ++J}Ur>U7Kd3c-$*eDZa5^%#hvlu3;DM<6JkmbNmh2e$X +d=2V5KMIjrKd=Kt9t(EaZ(c9lP%=6`URudw*bOZ+l7A$+IW)7f5sXUwjah~6m)8$H;N1xa_Q#6Hj$?) +e84^C>cJK*XebE0uiD+U-SuymvLxcQ)(>O&fx3AGbrLuSO?JEOUm|0=Bjf$}tK5X_2lQ~g +Rj`3=FZen=u6lx~da!uZ-E9N^L)owMZ1T+%)36_t_SMPjAi97Do7^{l%D+d)uVD8!kTCdoF?nMJKAa@ +jFKFi?N5>^Lu={kmpRE@7C(He8wZPAoyKQ1WbD!Wo+$V(HePRc;!<01|{$!6X@!B>pr##z*$QEQm`@Z +F-lzSFT3>=vYJ0MY6*caHmC?`7HmrRzmZ9z6Yq1{CJWDUYI +hz7+?b--D%Zyr!P=U>$npPzTW3srMaQRx_YaV}y4s=#IRAH25?v5?jLNrK0E6`q0`{gOU&SDR3M~XK=)Lxxk=?M4dvjq*?#;0=FfJJ-Ss@eOZ+@vS?YC`@SDtTT##j@4+`~ +p7~Jmw+xc}AyL*+8x<9I?w6=NaTvZ3&zYkyP6yUSGpOfifr=-ow=q2-P;f5t=-CA<89F$P+Hh(Cghh- +ct+95pvhR~`vhJGT1kwr1)D| +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

t-+h99wiX_#%`z +`6)@hro80Qi4;1GC)pPgA=m@n^-|mh&Lfy6i~9V!3dAZDp-U)APCb15Uq4esvwYEM@FDTg(fKREI>NN +NVL2HsaynVuvDf3WjF~v_xa~Di)5B}vc1B6KGb!UM&R7i26>>0S#YLB;Pq7=7@X~hYTB&Pc%8!X)bO& +2L1ii0ipq!;cWftSXm*tbo@yrS_q;`TLoP!RSWv^;%^UJm;a8#tvaF`xnc(utM)Zs+5;Z%e#4_;H)5% +2PkG!D8$Ai`v?0;yn8cSaDzOvq+CHcdWJ+TPUDGdUTB%BFEOa+fM*AtJLx*gHofvO<}p1|eMIH&D)z1 +FC0t~&!e!d)`F6Y=?V1T-SwA|0#lXm-2PTlb72*8agak?r_*T~R +)xn9Y9AjVu5UbKR;q)hCQ8c5t^y{*>JaT79TnMufI^Z3j2{363php>!aondwxCGflNIM+%@ +ebSd*kaJ(1i*S0J)VpJ{n`@F<+{1{>izN-AUn|JG*$)`Ye{#u +AI{`vUf;}*)+P;YahOV2mnDnVKMn{E54(|=pQ1du8Kcx0lbCLe)Ltj}w*X`@VpM;0`ns1An|G@6EK3 +$64+DuhAnq4mgVHiaTM!zc!JX>N37a&BR4FKusRWo&aVY-w(5E^v9(JZp2 +@#*yFoD<)9c#-^6ANk=J%xlN?dbfj38RHA&oD;*C6fmtq0EU?A^B-aZ6`}Jd<0G6cga=E%qiUI~RJv} +}Bo*tL$P1AN_+1Gj3G?m&bxuNW28#GkS~DxpDd%qqKef#F!`;%|e7tc>$oSXtyaimt+(}TlkF7WB=Z+@qr4xj$sJRO?01 +N?VgJdF_JXI3y`pv|wcUc7I6IoqQqVD|b7xrm7uMG-bAL?vg+z)H8gD!IOpMIj4XhPckEUaCaAUzJKQ +ERs(cyJ~P11n?XwcP`ew>cj;QrrwG*!f8db6z8Lbp6g*A&^)VgBwzz{>|l04EvpOO=kw=nzACTf%X-< +IC*r3S$d&Ng1oA*#;Ccuy0Q%eMo7ekFwq;h8zh)QEpVtbTvc|`^CvU~?55AhiG8_&-ima@0X%hLP%yA +F3Jhck-OvY5fC9@^==X@MEKS}Ncc`~*O1k*{Qag#&L^5*k`)%{qcXU^POt5t&fXdz}HNbSrV5lq +$u3X;xLujV$8Xc>?>!gv0rdgz6YMLV{oEoyWBj_^Fj35bF)li}eEjo`~0fIYO2!8c{bL4ljXuB;$r_R +}v5_#AVy`8xbeJoe7{(#vR2<-g=;l@=~fU0Vz|R%!)a}RUmoQR$NKBVVHm!De2my_K-+mLOih9C2oY# +d`P{TsJ3qj3UF!(vR7!{g#XJ-p@;%43whCB;@q_dbJI4U1%YJ%w*oX~))us-H6Uh}rWXX*DO?IbD1dj +$T5qqGZ68xu#X75S8@0@!-maOB$R?XA%Rx@eh&GBp=BuX6rMjCfkhoETgR{=<5U~dLSww%2lAoKhj$t +b$Aia?>Z7;IGj5yD};BX0V}Ok# +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 +B}_gNoQ$rBf&3C;zYu|2qbJ&_&<gbT^%GO +Iqz2K4Z^t|A29QBA)w|`0u_u7T1_obO^=qlP%VaCFlU5jO8 +VX@iva#O)3(BJeI73-NyznQ@R89E|F^%pl8{}%@mx{@46FLC!NJOl}F^TEi^@X*}V_ja&-VQkBBD01l +-%kU7Bk|zqlEE%tNfyNm2{MiMb3kKI!eBBzbQ@Ry=i2M)H8F>F}rdi{}REv +Dlwhge}_i{^5-g*20s=dN7y=+fKIR(s`*IwkcbkL9-H6B3&^0K_TC|m6C5ro4o`3hG_Zq(J})oWyoE1 +xOu2$=Tm0%y$TCf30OA4w03HAU +0B~t=FJEbHbY*gGVQepLZ)9a`b1!paXk~3>E^v8eP))1bFc7@!S1f*)783i=TcCyVNO|yhrI1r8#cZT +?B&tY8yZLzkzH3J*Nvey+GxF}tG)-f^DTs%VSTIJEkQ1==v?p%O`~$*{5*3V)k5r +CYh +~gPeK3ES}2o9`0Ay4sOi%j4`AuG8A%{}BYkHI2gKr8>3i|}L4t#j=k+);a7Yi7{*9J6rWYp9!u7tzt6 +4?+sk_aA0vI!tj`{QIgstbnE5u$M|6*xJqmTZ?*Nr_OGukFfj#-*c+9U4685y}GaHLB9ByowbeVM3Eiz@BHOg3>K*AzbQV?4#tBa#>5Pjjf_SWcHd_nTyP)qVYva3{rStu^@*@%Pw2b@xAm{VQrZPL(+7 +$SS+$qILB_Juvu}FnObfZ3x+32lJNgeIuo^PO5vqrzK~#-39pQ%FBkx2nQ|;MdZ+dcRAJsQ7ufMLqwt +cZt~B1IDRg?D?BJ`kRQk>(YnBAZk>24;n=~vWxAEi;LCH$`!sKBgmphhO37wYVo1Uz6>+?s)eG}sS-g +$f5ZFk~kw_EuewnYlY^%Z;iJxh9iN;YTu)>rhr3TiRYcPTU5k23R2>=4s)_$VdGp&vSBKk!+ePuP!*D +)XLIoW0&Lp_#Dzrjpt-=Y{o--7854|ofmGqs~P`2hF1HEWy<#+-9AX9sB=@`U$}zAKO__=jRqTWR5_@<^%Uq&-A+o(9#`zVJ|<43_L +;<2=;tvDv~0dD-a)ck81s$f3ax^b$NF*k{f=1-9^_PiJ$3a`LuIA7dF&AW{0Mblwj+vA9pq8iYQP3EGmfp;g-J)a_M?h-jrv??slE)dro6l}; +uGXm6dx`Q273W;Z(0&>eH9U8XI)L9Hj$HjWyu?AMlA_D!iKY&sXA5+@>(a(b-&jr1J2bzG&gD2<>tPX +{1AEzv@qnZSVQ|eC-TIH&1 +s2C*DhlXme>vCxdFRpwkR0NH@f|I5ptxK$ji?3Sz7);r@8-3ml?RhdYcXrKH8%X=P)T(sOipvzTPrR4 +r&VH{mStvznfN!mg=`Luvf-_G*d^k>eN{TwN-^oC=?n0KQaVd#TaGN;D#+4}kU16Hnklp3>4IE<}mx& +GjL&V+A!)^8!C0Y2>McpQ@OckSx*?$JflEFH;M}EaqpJVMnkn8fa#lT%wIj$+oq5`uywX-+i-=uiw7- +`UP(VcTJ9k8+)6&OGf*KFt(j+ok_8A46TY)Dz +ChRcy_nr4k1Tc>Ckegh$|5(yYxt8Z_7$9ah5*&=cGO!()@tzgOx6$UT*2oi^5U1_&k~(;E;bJja%Gkq +GT9`Awh11xr>#(Cs`lLfthb49)rBcC{e@4nTbFCxZ*a+aPOvrP`SW`F>DhjFg@CUllUDi|4QrWYMHW- +xX#hw%jR;fmy|+62e!fbVn(jxx{%LfN|!5ivaY`8_adUv`(kNjpY16-l*>AaE;4#8-~v4LH7ws0VKTa +F6+_1lgLor46*rBV{prx+`^ZAUr$oC|Mi6Z9DwIRRZYd>wOef!;QkoF7PWpvR58bw5H7XDh!%Vo{-`i +yg^VVg03>)IUKws2xSJN7v6m$vwb>WZt%`894T7s>He$3ST%)#0e_+5!jQflvI3nyaMP`gsD +-)IF2}lu1j~oQwp6fPc*1erQ+N%4&*tdN#EEDH)6GwnEaKoe6W53Wdx9u`SGUnZ0@ELV@$ulVxSo8pK +1%6lkxHWG?AwD+?B%Z;xAB30|XQR000O85nWGJih`)-&jJ7da|ZwbCjbBdaA|NaUukZ1WpZv|Y%gtZW +Myn~FLPyVWn*+{Z*E_3a%E<7E^v8uRZDN%Fbux?R}k4@Ezo+vfE^Z~1BO11Td)UqC<;Td=|+nzX`1{eJilSD62!5i%I)q#~Y|){vk(LGUXR%ns-+NsPOT7{v3H%137P^rQzXFZUV2|Fw>7g+@t&C_Gc?` +lXAT@cRR4AsE3aLD#i4Rpp%6O_OxPixb60h0A?5e%cTWl6r^K<^LIJaXUf{>;Lc^9TP32e2NTDbl6LO +yHbuyXjXmkz12d%rPyuy{%^-@%>H?>$#jtG+?545kpF!B+Ij!;4Tof;Z5KEqAJS2q@|ecTcGy5J~PK< +0ILiBiL<_+v{KmG}Z)yU1JJtO8B*re4@y3pq_7sP<|skr>-RhHaP1VIWfb-SF2<#1KxqW#6Znbx#E

Z2Nag!xJ)GdXs3kUO^m+f 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%0Au}mK0!2DG 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 literal 0 HcmV?d00001 diff --git a/Resources/python_runtime_dependency/LICENSE.txt b/Resources/python_runtime_dependency/LICENSE.txt new file mode 100644 index 000000000..3389149ab --- /dev/null +++ b/Resources/python_runtime_dependency/LICENSE.txt @@ -0,0 +1,254 @@ +A. HISTORY OF THE SOFTWARE +========================== + +Python was created in the early 1990s by Guido van Rossum at Stichting +Mathematisch Centrum (CWI, see http://www.cwi.nl) in the Netherlands +as a successor of a language called ABC. Guido remains Python's +principal author, although it includes many contributions from others. + +In 1995, Guido continued his work on Python at the Corporation for +National Research Initiatives (CNRI, see http://www.cnri.reston.va.us) +in Reston, Virginia where he released several versions of the +software. + +In May 2000, Guido and the Python core development team moved to +BeOpen.com to form the BeOpen PythonLabs team. In October of the same +year, the PythonLabs team moved to Digital Creations, which became +Zope Corporation. In 2001, the Python Software Foundation (PSF, see +https://www.python.org/psf/) was formed, a non-profit organization +created specifically to own Python-related Intellectual Property. +Zope Corporation was a sponsoring member of the PSF. + +All Python releases are Open Source (see http://www.opensource.org for +the Open Source Definition). Historically, most, but not all, Python +releases have also been GPL-compatible; the table below summarizes +the various releases. + + Release Derived Year Owner GPL- + from compatible? (1) + + 0.9.0 thru 1.2 1991-1995 CWI yes + 1.3 thru 1.5.2 1.2 1995-1999 CNRI yes + 1.6 1.5.2 2000 CNRI no + 2.0 1.6 2000 BeOpen.com no + 1.6.1 1.6 2001 CNRI yes (2) + 2.1 2.0+1.6.1 2001 PSF no + 2.0.1 2.0+1.6.1 2001 PSF yes + 2.1.1 2.1+2.0.1 2001 PSF yes + 2.1.2 2.1.1 2002 PSF yes + 2.1.3 2.1.2 2002 PSF yes + 2.2 and above 2.1.1 2001-now PSF yes + +Footnotes: + +(1) GPL-compatible doesn't mean that we're distributing Python under + the GPL. All Python licenses, unlike the GPL, let you distribute + a modified version without making your changes open source. The + GPL-compatible licenses make it possible to combine Python with + other software that is released under the GPL; the others don't. + +(2) According to Richard Stallman, 1.6.1 is not GPL-compatible, + because its license has a choice of law clause. According to + CNRI, however, Stallman's lawyer has told CNRI's lawyer that 1.6.1 + is "not incompatible" with the GPL. + +Thanks to the many outside volunteers who have worked under Guido's +direction to make these releases possible. + + +B. TERMS AND CONDITIONS FOR ACCESSING OR OTHERWISE USING PYTHON +=============================================================== + +PYTHON SOFTWARE FOUNDATION LICENSE VERSION 2 +-------------------------------------------- + +1. This LICENSE AGREEMENT is between the Python Software Foundation +("PSF"), and the Individual or Organization ("Licensee") accessing and +otherwise using this software ("Python") in source or binary form and +its associated documentation. + +2. Subject to the terms and conditions of this License Agreement, PSF hereby +grants Licensee a nonexclusive, royalty-free, world-wide license to reproduce, +analyze, test, perform and/or display publicly, prepare derivative works, +distribute, and otherwise use Python alone or in any derivative version, +provided, however, that PSF's License Agreement and PSF's notice of copyright, +i.e., "Copyright (c) 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010, +2011, 2012, 2013, 2014, 2015, 2016, 2017, 2018, 2019, 2020 Python Software Foundation; +All Rights Reserved" are retained in Python alone or in any derivative version +prepared by Licensee. + +3. In the event Licensee prepares a derivative work that is based on +or incorporates Python or any part thereof, and wants to make +the derivative work available to others as provided herein, then +Licensee hereby agrees to include in any such work a brief summary of +the changes made to Python. + +4. PSF is making Python available to Licensee on an "AS IS" +basis. PSF MAKES NO REPRESENTATIONS OR WARRANTIES, EXPRESS OR +IMPLIED. BY WAY OF EXAMPLE, BUT NOT LIMITATION, PSF MAKES NO AND +DISCLAIMS ANY REPRESENTATION OR WARRANTY OF MERCHANTABILITY OR FITNESS +FOR ANY PARTICULAR PURPOSE OR THAT THE USE OF PYTHON WILL NOT +INFRINGE ANY THIRD PARTY RIGHTS. + +5. PSF SHALL NOT BE LIABLE TO LICENSEE OR ANY OTHER USERS OF PYTHON +FOR ANY INCIDENTAL, SPECIAL, OR CONSEQUENTIAL DAMAGES OR LOSS AS +A RESULT OF MODIFYING, DISTRIBUTING, OR OTHERWISE USING PYTHON, +OR ANY DERIVATIVE THEREOF, EVEN IF ADVISED OF THE POSSIBILITY THEREOF. + +6. This License Agreement will automatically terminate upon a material +breach of its terms and conditions. + +7. Nothing in this License Agreement shall be deemed to create any +relationship of agency, partnership, or joint venture between PSF and +Licensee. This License Agreement does not grant permission to use PSF +trademarks or trade name in a trademark sense to endorse or promote +products or services of Licensee, or any third party. + +8. By copying, installing or otherwise using Python, Licensee +agrees to be bound by the terms and conditions of this License +Agreement. + + +BEOPEN.COM LICENSE AGREEMENT FOR PYTHON 2.0 +------------------------------------------- + +BEOPEN PYTHON OPEN SOURCE LICENSE AGREEMENT VERSION 1 + +1. This LICENSE AGREEMENT is between BeOpen.com ("BeOpen"), having an +office at 160 Saratoga Avenue, Santa Clara, CA 95051, and the +Individual or Organization ("Licensee") accessing and otherwise using +this software in source or binary form and its associated +documentation ("the Software"). + +2. Subject to the terms and conditions of this BeOpen Python License +Agreement, BeOpen hereby grants Licensee a non-exclusive, +royalty-free, world-wide license to reproduce, analyze, test, perform +and/or display publicly, prepare derivative works, distribute, and +otherwise use the Software alone or in any derivative version, +provided, however, that the BeOpen Python License is retained in the +Software, alone or in any derivative version prepared by Licensee. + +3. BeOpen is making the Software available to Licensee on an "AS IS" +basis. BEOPEN MAKES NO REPRESENTATIONS OR WARRANTIES, EXPRESS OR +IMPLIED. BY WAY OF EXAMPLE, BUT NOT LIMITATION, BEOPEN MAKES NO AND +DISCLAIMS ANY REPRESENTATION OR WARRANTY OF MERCHANTABILITY OR FITNESS +FOR ANY PARTICULAR PURPOSE OR THAT THE USE OF THE SOFTWARE WILL NOT +INFRINGE ANY THIRD PARTY RIGHTS. + +4. BEOPEN SHALL NOT BE LIABLE TO LICENSEE OR ANY OTHER USERS OF THE +SOFTWARE FOR ANY INCIDENTAL, SPECIAL, OR CONSEQUENTIAL DAMAGES OR LOSS +AS A RESULT OF USING, MODIFYING OR DISTRIBUTING THE SOFTWARE, OR ANY +DERIVATIVE THEREOF, EVEN IF ADVISED OF THE POSSIBILITY THEREOF. + +5. This License Agreement will automatically terminate upon a material +breach of its terms and conditions. + +6. This License Agreement shall be governed by and interpreted in all +respects by the law of the State of California, excluding conflict of +law provisions. Nothing in this License Agreement shall be deemed to +create any relationship of agency, partnership, or joint venture +between BeOpen and Licensee. This License Agreement does not grant +permission to use BeOpen trademarks or trade names in a trademark +sense to endorse or promote products or services of Licensee, or any +third party. As an exception, the "BeOpen Python" logos available at +http://www.pythonlabs.com/logos.html may be used according to the +permissions granted on that web page. + +7. By copying, installing or otherwise using the software, Licensee +agrees to be bound by the terms and conditions of this License +Agreement. + + +CNRI LICENSE AGREEMENT FOR PYTHON 1.6.1 +--------------------------------------- + +1. This LICENSE AGREEMENT is between the Corporation for National +Research Initiatives, having an office at 1895 Preston White Drive, +Reston, VA 20191 ("CNRI"), and the Individual or Organization +("Licensee") accessing and otherwise using Python 1.6.1 software in +source or binary form and its associated documentation. + +2. Subject to the terms and conditions of this License Agreement, CNRI +hereby grants Licensee a nonexclusive, royalty-free, world-wide +license to reproduce, analyze, test, perform and/or display publicly, +prepare derivative works, distribute, and otherwise use Python 1.6.1 +alone or in any derivative version, provided, however, that CNRI's +License Agreement and CNRI's notice of copyright, i.e., "Copyright (c) +1995-2001 Corporation for National Research Initiatives; All Rights +Reserved" are retained in Python 1.6.1 alone or in any derivative +version prepared by Licensee. Alternately, in lieu of CNRI's License +Agreement, Licensee may substitute the following text (omitting the +quotes): "Python 1.6.1 is made available subject to the terms and +conditions in CNRI's License Agreement. This Agreement together with +Python 1.6.1 may be located on the Internet using the following +unique, persistent identifier (known as a handle): 1895.22/1013. This +Agreement may also be obtained from a proxy server on the Internet +using the following URL: http://hdl.handle.net/1895.22/1013". + +3. In the event Licensee prepares a derivative work that is based on +or incorporates Python 1.6.1 or any part thereof, and wants to make +the derivative work available to others as provided herein, then +Licensee hereby agrees to include in any such work a brief summary of +the changes made to Python 1.6.1. + +4. CNRI is making Python 1.6.1 available to Licensee on an "AS IS" +basis. CNRI MAKES NO REPRESENTATIONS OR WARRANTIES, EXPRESS OR +IMPLIED. BY WAY OF EXAMPLE, BUT NOT LIMITATION, CNRI MAKES NO AND +DISCLAIMS ANY REPRESENTATION OR WARRANTY OF MERCHANTABILITY OR FITNESS +FOR ANY PARTICULAR PURPOSE OR THAT THE USE OF PYTHON 1.6.1 WILL NOT +INFRINGE ANY THIRD PARTY RIGHTS. + +5. CNRI SHALL NOT BE LIABLE TO LICENSEE OR ANY OTHER USERS OF PYTHON +1.6.1 FOR ANY INCIDENTAL, SPECIAL, OR CONSEQUENTIAL DAMAGES OR LOSS AS +A RESULT OF MODIFYING, DISTRIBUTING, OR OTHERWISE USING PYTHON 1.6.1, +OR ANY DERIVATIVE THEREOF, EVEN IF ADVISED OF THE POSSIBILITY THEREOF. + +6. This License Agreement will automatically terminate upon a material +breach of its terms and conditions. + +7. This License Agreement shall be governed by the federal +intellectual property law of the United States, including without +limitation the federal copyright law, and, to the extent such +U.S. federal law does not apply, by the law of the Commonwealth of +Virginia, excluding Virginia's conflict of law provisions. +Notwithstanding the foregoing, with regard to derivative works based +on Python 1.6.1 that incorporate non-separable material that was +previously distributed under the GNU General Public License (GPL), the +law of the Commonwealth of Virginia shall govern this License +Agreement only as to issues arising under or with respect to +Paragraphs 4, 5, and 7 of this License Agreement. Nothing in this +License Agreement shall be deemed to create any relationship of +agency, partnership, or joint venture between CNRI and Licensee. This +License Agreement does not grant permission to use CNRI trademarks or +trade name in a trademark sense to endorse or promote products or +services of Licensee, or any third party. + +8. By clicking on the "ACCEPT" button where indicated, or by copying, +installing or otherwise using Python 1.6.1, Licensee agrees to be +bound by the terms and conditions of this License Agreement. + + ACCEPT + + +CWI LICENSE AGREEMENT FOR PYTHON 0.9.0 THROUGH 1.2 +-------------------------------------------------- + +Copyright (c) 1991 - 1995, Stichting Mathematisch Centrum Amsterdam, +The Netherlands. All rights reserved. + +Permission to use, copy, modify, and distribute this software and its +documentation for any purpose and without fee is hereby granted, +provided that the above copyright notice appear in all copies and that +both that copyright notice and this permission notice appear in +supporting documentation, and that the name of Stichting Mathematisch +Centrum or CWI not be used in advertising or publicity pertaining to +distribution of the software without specific, written prior +permission. + +STICHTING MATHEMATISCH CENTRUM DISCLAIMS ALL WARRANTIES WITH REGARD TO +THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND +FITNESS, IN NO EVENT SHALL STICHTING MATHEMATISCH CENTRUM 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. diff --git a/Resources/python_runtime_dependency/get-pip.py b/Resources/python_runtime_dependency/get-pip.py new file mode 100644 index 000000000..acce1084e --- /dev/null +++ b/Resources/python_runtime_dependency/get-pip.py @@ -0,0 +1,32207 @@ +#!/usr/bin/env python +# +# Hi There! +# +# You may be wondering what this giant blob of binary data here is, you might +# even be worried that we're up to something nefarious (good for you for being +# paranoid!). This is a base85 encoding of a zip file, this zip file contains +# an entire copy of pip (version 22.3). +# +# Pip is a thing that installs packages, pip itself is a package that someone +# might want to install, especially if they're looking to run this get-pip.py +# script. Pip has a lot of code to deal with the security of installing +# packages, various edge cases on various platforms, and other such sort of +# "tribal knowledge" that has been encoded in its code base. Because of this +# we basically include an entire copy of pip inside this blob. We do this +# because the alternatives are attempt to implement a "minipip" that probably +# doesn't do things correctly and has weird edge cases, or compress pip itself +# down into a single file. +# +# If you're wondering how this is created, it is generated using +# `scripts/generate.py` in https://github.com/pypa/get-pip. + +import sys + +this_python = sys.version_info[:2] +min_version = (3, 7) +if this_python < min_version: + message_parts = [ + "This script does not work on Python {}.{}".format(*this_python), + "The minimum supported Python version is {}.{}.".format(*min_version), + "Please use https://bootstrap.pypa.io/pip/{}.{}/get-pip.py instead.".format(*this_python), + ] + print("ERROR: " + " ".join(message_parts)) + sys.exit(1) + + +import os.path +import pkgutil +import shutil +import tempfile +import argparse +import importlib +from base64 import b85decode + + +def include_setuptools(args): + """ + Install setuptools only if absent and not excluded. + """ + cli = not args.no_setuptools + env = not os.environ.get("PIP_NO_SETUPTOOLS") + absent = not importlib.util.find_spec("setuptools") + return cli and env and absent + + +def include_wheel(args): + """ + Install wheel only if absent and not excluded. + """ + cli = not args.no_wheel + env = not os.environ.get("PIP_NO_WHEEL") + absent = not importlib.util.find_spec("wheel") + return cli and env and absent + + +def determine_pip_install_arguments(): + pre_parser = argparse.ArgumentParser() + pre_parser.add_argument("--no-setuptools", action="store_true") + pre_parser.add_argument("--no-wheel", action="store_true") + pre, args = pre_parser.parse_known_args() + + args.append("pip") + + if include_setuptools(pre): + args.append("setuptools") + + if include_wheel(pre): + args.append("wheel") + + return ["install", "--upgrade", "--force-reinstall"] + args + + +def monkeypatch_for_cert(tmpdir): + """Patches `pip install` to provide default certificate with the lowest priority. + + This ensures that the bundled certificates are used unless the user specifies a + custom cert via any of pip's option passing mechanisms (config, env-var, CLI). + + A monkeypatch is the easiest way to achieve this, without messing too much with + the rest of pip's internals. + """ + from pip._internal.commands.install import InstallCommand + + # We want to be using the internal certificates. + cert_path = os.path.join(tmpdir, "cacert.pem") + with open(cert_path, "wb") as cert: + cert.write(pkgutil.get_data("pip._vendor.certifi", "cacert.pem")) + + install_parse_args = InstallCommand.parse_args + + def cert_parse_args(self, args): + if not self.parser.get_default_values().cert: + # There are no user provided cert -- force use of bundled cert + self.parser.defaults["cert"] = cert_path # calculated above + return install_parse_args(self, args) + + InstallCommand.parse_args = cert_parse_args + + +def bootstrap(tmpdir): + monkeypatch_for_cert(tmpdir) + + # Execute the included pip and use it to install the latest pip and + # setuptools from PyPI + from pip._internal.cli.main import main as pip_entry_point + args = determine_pip_install_arguments() + sys.exit(pip_entry_point(args)) + + +def main(): + tmpdir = None + try: + # Create a temporary working directory + tmpdir = tempfile.mkdtemp() + + # Unpack the zipfile into the temporary directory + pip_zip = os.path.join(tmpdir, "pip.zip") + with open(pip_zip, "wb") as fp: + fp.write(b85decode(DATA.replace(b"\n", b""))) + + # Add the zipfile to sys.path so that we can import it + sys.path.insert(0, pip_zip) + + # Run the bootstrap + bootstrap(tmpdir=tmpdir) + finally: + # Clean up our temporary working directory + if tmpdir: + shutil.rmtree(tmpdir, ignore_errors=True) + + +DATA = b""" +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 +bZX@t)|;tOe!5MON9Rve +@t^+4d&NoIMD_M@>h=JoMUKmSDL0A!(nco>t`apQjE~Ik?Q+{@pjMcV*AHp&4fCK=|FCDO{XjfaaIM| +pPqkgoLKyflPnWjCm-WClZTm#rN^XD!X+qBYk*oyYsZ=E`4@#5KYn2F$qsfRbydg8QwbRFbv;+(pEY3 +JyU-k^%$(X>Rz8m?7qU+{-X;%9M`hk+3cQqj_i0 +*ul&HQSUM`PKM^@6@gRi%FC=~;Gd&QQ7I97Dmw(qaifw#Q=wy;Ej&9} +v>haMA^&O#6u9`(PIxE~s_7XcB0sUZfs5BwQp9+$#b;={Y|-mUoRttX;>Zc^yf-s|Rf-k_EMFc*LN`k +SXu283ZkMBk21!Q6pPGPF(!vcn!2lNb@6aWAK2mldXPgR!Yd4o0(007xE0015U003}la4%nJZggdGZeeUMV{dL|X=in +EVRUJ4ZZ2?n%^Ur1j9DvPDK*~qjOWx>{Ik>2n%FKVWEy{QI+t8&d*&E;AYWnSLwCW8Z3q-#E4>` +<|-6m`uDCJMG7Kx`>;u3}hpm*yK>^$Gv7RHT7P~P!5{r7wPJn^wbtYaAmDYCo=aaLe^UqiNmxJouIJ~*x^(j07-tOJ87HVOa^FnPTPXMDaeBZ1GgUfWQ>AWBjv8gAqID +E}su&Wh7TBSuc_*oPgY%oF?M)*4#GgZscVDQuV+1rzM$&ZIu$7hG{k6~Se*oi_!Oe`&-jOU8$H+XI|I +6nK7;QFiNeY}MO6)Ts%Vk*>C(AZS+c%YX|iCQi0k5|W+(`W%RrJUKc}&M%LSFM(R3I@W +ZI%`c?een;%>cR0`aiboGV9iE;XC8y_yN6Gow>8}ky7laQS0S*Q^sUj?I)N+_4=xLG!Gy;TncK+db!r +rI5YtBFdG%pD55dWEw#<7FH;ok}I5IoTP^p+d%i +0YxhUm)8gze!~VY$Lr<QvSW +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 +Hb0fvpViVEgI8ogXOdDCv!Ut)| +b}OO4DuZOf>fAt~I$`h2yJiGgm(~DbQ|rVTj#_RCg5=)K_c~3svi&O* +pK~|bSD5O-B&$B4Hr)+z;i7z}}E=2(za>wrU>@g^6$5JJzIE2MD6` +Q&c?-in+2<|x)U(9`1Pj@~l5rtt&UtRfB2*;~x4TqV&9L-?44BC5N9#m>hD$;wk(s;o~rb;FbSC6><- +!yQlOhD0Osvn#SBY@4)$M2kMF+U9|_n`akDqVYBpt_3II#gV?qPib9aZt1!I6-W$mhu+!M~S`deCKyu +e#i9I-aD1=o_nX_d6|3v9<62vZ{}YS2D=v{VWn-mB$H4Lda`mF#IY)c`h&yL!A*-J!R~V +J&hhcvjQ%yY!_xun=HLmox6MeQKML>gbs633BN7_?Op@46=RXYZ!_kdzV?GE^v9>Jne4d#&-Yx6ccWNl@f`2lY +4VfsC58m*Sl+EKipk!E(*t$DRLw+rbvcE+N&!FDEbVy=xg*H`X+gjo{yQ~@XOY2f&#Zjviji6nRCvZI +o~7C^G-j8GB4vSRiaWd66Lzcs?|EHN|6WQO|X*w(b2^^R$`MyRU*af5AQF;o3|IDEViP|M7+tfq7=&_ ++lV0Dmg_iOiMtqI#dRL%{ya`gS)@U74a1MJToyqoeL*ncKlw42VTmheVj(rSU;!%`kWYdn5z9D{%D^q +x@<>$+jUbGPCh%RQCPD$`NhH#&6p_qj8i|aCZ~P7Ju~BQ?E^_FOAG_WQ~o$HZ+Lx$VA4ny0IW*N0Z^NuxT$gjNvbf&h +gL1+$I?;{?}5Y1CL3l)0{&?BI#BB*UYPOom+-lM+GOP`+=d`Is-HJx$=}E_h=MXOUY6l{RCxb(8BG6r_0?#~uj4QO!2@X>;|V}veUqgURwVd&A(!#TIm$Yq838UM0tzdU>|7 +$FC%Ed>gdXUvpV>{PZ@=UhhDJ#87YtH=L3krP#v3*-R>Yb#1kxt-Xw1*>kGA_*DEb0~RCXR|T!6f>T9#RB#mMM_8<<&#p;Q=i2Ftg6a5v_Q<88pcV=Gf`m$ +CGL&_id(lDtaNzj5QidoMQiX^9j0F_;$l70 +fy0u*;Crc-gZ1_dI5LK+Og2B6H7b|=(;LcN&A64n9$C=hVcVFt+XHjyr4;6G3cIl^M40?cC&VA1l5XO +Nl!>!fnP?Bf*8gPbm^I05;(_RUTiq1D9Gf#L7yl)}-B%lW*PMJ1Ev#D4m+etQD~IunnzM!WO~ACOk>E ++|sK#k+b82giJEr#UMd<8g^+9>$`!s0V8180~=Pn$GQ2Jw$JY1F1dM8I0Qn$82-paNN%ahj);MO}M#_ +Fj7qTvDPq;#A&K3ke2`?2K|VdMY!+q-EADn$hQ+fn>9u>!I8WwI9Mebrl3SkgOsdO4!-^3sI_9th}dy`3vMb^qH9Fsr#Su#Eu2Q|d=xQQ6JMGST#RaDnq$o2IyREje5_@Mb$d +xRzVY1dKa8;Nn?tNb!4Uht1qKBI9^;Giq=Ic8jeUFCmfk<_X!v|iN_ReocWJPZ^Z9-zc1@c1-+5#A#D +e2i01O;N;sruCbB-HXr%_`=?^|xccf;!9;rX|jq&w%pDpPV%gtwJw@0~NV +jU@yLOYd^WaQ5K3CDGN+!q{IvxtfVf=i6GS;E~sYq-~Ro(PoogNJ&3}lv;A9W{>>ZeUBa0=Xe&K&KVe;>m>?I=-zx2%H}Jp()H +uE^tLCgBz%I88+8_qKnqe4p-{gb#wF$Dz?ZF+jySV`_LwvwG5FwHB>)E(^SMjekVBDeeU?v?-rv>>rb +cS09S%^pk^O;0;s3gDTVJYZ-x%6I<54^Kr_MT2UoP=csArys<3clg^@+l>)s)8c9q4@HJOfkw3(uA)V +>4fe~H)Pdmk57acRRxDo^<)<)IRC!|Y?TfHejO_XBhI(yMfS4{%kME{(W1I-V()?&lbd&InTmX +y^K`$=HVOLv;+lfLsoFwRxw)P|OkKi$HovC)94>V2cY{N8L^h1w)WV;-)2C*-*Aqi>-0|haq+IKiQd6 +Qj?r=k_j7Pcjo`Rt3FeQX9#g21$BMpAMZ;7?>Ffmr^o;;5tYm;n6eg!C1w?Ps|ZEj+k*8eH(>Rd{mT) +G^&5}fA6)H1V9yFzIclv%MA*OucD`fU9s%yE-~+Vk~n9srP3s**OTU`fFA9*7nQM6k$i!Qmoa#kt>NO +YI;NW4!lLiu2QR@$J|DD3)Lf5N0IH0B8ntlFKk&#vw_q?>YF5o#RGK`+Wu2*^EyUSUu}^6IjfQ2P#Yd +j-+>hVJL5?H@jlI^qSlUS>G|$`~L^>iTm|hC)S7bwkwH2h#Q0_HxO>}{jn0>>(h&qXD1gY9y(3l`42C +qXK$Xr_1t8gidQM1B=wfqyk5ASFnlDyg)0Efc%v}KxejjGH6)#3iUFv8#E3&M5JyB+TwgzjZ{K9)^Q= +lEqUQRVjF$|eF)RC+Gup`KfNXEF6{MVCCD`t$!UR&uc~{sRUA@`_Tg=Nu6_1kz=`memIp{`!$hF1L-G~01Fn^vjJ& +qZeIH_$|7o^a#3@lSNY=xMEaVb*8cgU!cwAhgTU=fC23Mai}BF4xvn38%(e3JUQ8Cb&stybEwdxJ4IRpXb +E~w@0yP-*I1FpQ$T~LkoxGE +FsLtvTrM!=0s8P$>iL=cbPKZ;weqyVEp=evH4j@1fL{;wyaR<+lwqj!)76ElpMyHQ@kO-99T4FRfggV +&*;hLTaMQ*o|KGt*SuuV~#5^$~{qk)#+NBG(bLG&Yf{Y0^B7n$E#mw9JV-BYfjAu_uf-Tkan&b5t{y +Bc+>`(l7=We9=pY62Ri-db_JlB*yzF4glOPO3uQo1Z$ZJ-LEp7ri$5QHB*c2G`){R=J;Vjf`CPr=${E +cd7?Xm%Q?@iqXE>oUP2F2i>7$`<68 +I?L~g~RMNP&9Pqwc=mZ>lYTezRbjt^BWT-3vh%>N*m-0{pxyX9(RDOiGFq$GMQ+ED7tLsWTz_14@EaJ +R2M75s?3(dnU0;>dD;`AiYKFrZ`R*wINeZ17CbT#Pu#mmOz{+=T}0?6Iu=)2UpyS6C!-hHLgHk@wi6C +wL3PIK<)9WA+Zd$|MEK5{V~?*(I=849j0pIrTvdfhVnR~lg*_%@&njcy?Ej*f@XJ_T;{uHoL4vl>qQVq>u1pn$| +Ka}Iv(R2~7FvS6z$qn?*L7WI3a$;Tz>^|i?d$Qafj9(;j!}^5O#SmrVRvT9jgQ;_@^KC2oFg(QQ!@U1 +wXKy!z!d|deVS;weCHGxVkBgHy^Eqj)(LI`RSPeGIgBtX7WnoWQC4QcM>oa|Wiiyw9y+jaeKi5JUn!r +ldmWSybvXRZAjv-@wpsm!y|1WIgC&{4QW>Igmu-mMq4DUT~ZU4R~;&qjjaSqJ2!-eV0hZrHlR215+Ok +mP@NgbmY>tRFjU{E&X8*{N@Mt4;%J-eWX$&Smb8d#9yof_?Y(IoIg>*4o<_w{W0bTDJtE)g1iFcpwIx +{=%CB-kvXK!8G)epW=XsEr9SCj>W4*JS3|avtIZo7CLtaRPW4@J^|uNRFh$E_6~aN*8;6eE +QzP;2UUQ0AhR$yon@)jHrivae`MTZUBI>+kARSDgy^XiB-ikri&rOB;Vm03LTd6l+KmnXQWscjPfMdY +Mq&97(vEV*aYLab(~;(|Bs4#pfPP1`7FjoC?dzoUpFY{EJFz%$BIlsY26Tezt6E(wkEU$qPW^tHz_Ht ++yF-yHgQUCk14lk;ovo~kPEc8Aazuwl|hlj_J)iTVf^Cw?|n%Hlgy>z$UU^wEYw;eQ5=uO^y~Uy(LwI +lRhTX3V})K9cp(LfCm5Q>j#SvtO!Vvh@@pT8xCW~PAli60Eg?MFj41q!_j%%!uIIQe78hh|Ch?Y_EI7 +#+XB}PNeQ(t=~-G +uMZLdDI|c>k%@L*pbO>-RsU{DF0I16F6Lhj+ZYAB{{{>#S_#f!ofA1A{Zz&Hgo7TS7ITwAw6Wq3&g_& +0PbGvF&KYJQ+96S1BoNqy1_R=EqQ>d2kZUBWo_)8~`csyP&?DqbsC3RXIgx5L_A4a)d?Q$YmNOuL#_o +1eJ{n8yi0W0{B_$jKSd|+&z{lr=Uy+7|!k=+{0b_wOD}#aN1n4MKWD8sZ +R*f51%QWsEMR-waUtl8M9Xiy9hw<6>&s=BAo@yv)rhSRxR|J4BksN6x!vo2K0P;-#tV!kGpaic +Wl{8Xy|X3`j}XNJrxUZ)5a$?$RU+kPAT(uH##H;=r+ePwOB8_aut6=WSY86nS@Bymiy5&r?U1yLW}WC +6yO!aCW?g938x1{zRpqxw6h{ert|3_Pvwz +#mPNp%FfPE01}~5A!PoWWo~!d!i4nKnCw*`J`N@xO-<@5Y&R?Fqe_7iavj@k`lCWc8+P9(3xYmWY8Y3?w_oa!i5YZmUiY%GN`n0ivphCoc<)-x%U +U&C2JScDuM-%u$UW)|b6EJmNa88+6BP?32|x!b`ozD|fno+A)_5zr%Hya91klxW4Ifk22gp-}dfD$xB +j;fyOM9o*Cm#h>l{X=YXeWBjI}^v^``sS214`TRZa*7pcrzTumcq8TGHFWZq;qcEERSPQKIovY-=es- +15~BfD|P1?>3Xs_lue@O5x5xG23!KAjdj=F{BgkEoDJHRR>f8EePJ@`toR*8sFzg+F|riL#~7`lg6De +ikd@`1vglz7y*AoO>6o!E#HDKXGYEoqdpWo?>A(K|QnS0AFq45>x;7d)Up%MAi9(XGx+~&R@=qwB4eb +v*xka$O` +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 +lZevkHHj7W34_3WO+kX8#uY77WL +LaU`)$hY-D9}E^v9>8 +fkCaM)tdY#e_jo5~bOu=&>t61)4Nj1W218PP-qx1~V4N5^IWNIiwx6=zrh$-rPK7w_EH2D#jMlm$mG9RlOCz3}q({qV8q3ilS(>Di3Yb^{i@kJJ@7 +?HZp5@zc)WSVZO=z(3jPUfcD20&(Sl_06xE}M9N$WeOnpY`%H?);lsoibaX8EnCi>8 +CKwl^Hl&k(vaAh*13>T=7g@>h}9`~VPxpclVj4+h9)oJ7YaG`E@bH!DQji7nw{w#O?5pI3CM1;u4ke_u)ono7)mLwYOHrL{jaPs^Hj#}`ev74ls +4L)$k^CH10ol`P|=E!^N!)&-D|!|3vsLn*gry#Uqi1gKn>vOSmk{JKO7FQw+E=9Vay!AXm6PLeR75Bx +^t-sH9tyv}*IlP6#eS8dk-6Fg^8Rk<5p-U^n~A{}PqJNW$_h;$1cbXFnMwxM&534LSUH#v;WZMfaqmG +E`7Le`6pZH$-Az=U7XSe%nz%kyNl%EfL6Fs_@t6R@@u*|s^fz~#7$;tPKE>t| +{GO$m%hhUCh-;Q_o4V(qB$mopt{J$mgq?juC$359Atrq%fQ^T;78t?$JunXb!=l1HkXxj=lkLby8&PdA7?SL^fxiXHU#w^tS`u>uSOx_N4$C%OSkRGD!>>a^DQ#Lr8yPz4@ +2*jB`*nTnnKc&YHlhQHUbjoBRqzWF}3FyjT|8C5YjNrUvgY<=IzI|%B%LJWNib?OVxMa<`z7QBt!5Z!NlRf>w-0Pb<_}Ihtr0TO)`gW(-WPt86bY34_u$74;P! +L>r;3q=t!*zZ=SzlUw!o%v$5M(jqw3=zDj~*-X6hQ{|uhj#`ZV~4j-h@Im850$2KmdzyL6|DhN(QG8& +D~g2}=dj!Jy`K7I5r%zkPlbi3#EPAEZuIt?{Q1CS+a1r~VNq`3SrNU(%THZXH&ZiNR`lTBIr`?E7G#I +uG>|9u7~TY&7+nK_ImRVkzg3>MYR*%hS&?-?A2sPa0HBLiQ6eiDpzsM&i8u~~aG>hnGe;q9vCin}v$A +B>WW?Vvj10G17$fVhaq7G2Z&#CcF%F;ez>4+D?+9u_EZm6w@x0-P}BJ>dENcs6v8>4G9mlb1Ldsd>@V +AM3=C>0~l+d;lrXHJ1kcNup-b!4rf8wm=ce4^TM>LsO_d#XTWw6j(I$FzCVN)N_0rJUdxB+)(_m<8g9 +goHfCV +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 +2yRtP|lid=IP6k +g(sgW@c4O!d+Q^Uj8KW9E`EAbmShj#z@gO_qJ2mQWF6zWCs*7z#_WY<_-Q3_Brcws9p=VM0gaa`@>3d +V_}&P|1ohF|E6TnSyk_gzGBm!W`iREk&FC*AR^X^g-IQRv)NUy81NX#Xg#{w(~*gR6dn +>h9CK}MZ-?Bv-r5N^uEw5+`5dW?{A=BpN%^Ng9v(j4efm`V=kCM9d`Q6B05{)cQOqJxT1vL`M&1q^D)bBmC+j5J{J1rSox?07D>7W$Lk|p_KJ^KX2Mj&u;jo-w=O| +w)+yMhtrjXI|3JnMH`g1j2!qA^ER7w8sNKf>EdV5QW!0k=P}ZY(NvtvcAw>REFSu5C@*Icdtx6}jmmM +ZWR(_@GXqpvjt*ItP&WjM%JOFv{-rFJ_#4FGCjr#q4;l&oLOvO3i(}r91pxFSg^V=BbP)ys$}P!{S;S +68*>=ncwo~%btFg)goXl#nb_*Z{M%Ro@PI9xp8LkmUo{zjbLQ(zyj+-0kpk`PF^}X4WA#y|G8RfgNn^p`oZRl!{|iRP*3mb!B1O)n|O|M4zUi2ots<0ot|Ua!AO`n`_WN7hf@ +MnX`)T<3B8d>4)nd|^5}hs_H6TyqJ-q<`huylXDog?SB#y21Wg;NRd-s7I|Q#on?~;Ni3^kxVU@0+reyxXN-WwrU +QO6+|RG_2*Mq&Ou{_+JoK!`l%->xe1N39Qt=h%Au0)(P7&8ScgU8Gl))t5jn9svdVU-EBnf@niy|D`8 +EU`oW8NOwa3roEv_&%aQu|;c6*%}>}ld|-LXW>4IwA2zl{?r(P-XuLxW|Mn~>EKSuFE~)emE`@>a!0L +{%6bVwSoP0X!fwkYFD^nMNH8< +W*i(f`PQdklyC2^6)?nynXOc8d@b#(0}`rahpqbC%^#L}1JL%oVfusZkn +;S{}M4p2z9!t;fVNfdIMm$of~oU9@-%&Rm8?2{z=FOSUXd(RaX(4FIb#Zuc=Nh{zA7>5VP(dFjV5OS9 +fRT?v)rrY?#+J6o!?e~jOQmGn{JciQXA=HEwc@n{=<=np7P0#dZXLdF5*lLJZ-Gn|HdE^+*0asS^5J6 +K|v8qo-O!sn{g&-tVEab%G)@AJmv-rZinaVY+^UbmYvi()cvzETp^mY*|lods7Jcj +R%vF{00-vWgDZk9}*wIFHpxED3OXV8nUnv>HQZ6mnlN+(~Wzk9GVNdADY2AO<|hGdPdEP>rWv5cIlh@TINcozYz3Muy{KQoL|h?*`z4`Y&)LSLo?$!m)3>CSYx#O9KQH0000801;hJRnI3 +!o0JIv0HPiM03iSX0B~t=FJEbHbY*gGVQepBY-ulIVRL0)V{dJ3VQyqDaCyyHTW{kw7Jm1yAQTj17mk +2^4c5DzOfs#}sS{+J=>kDO&=PHPM;5iD6vtcizwdWQQ5RdD&g?@`AxI?h@Z7IV6h+s3gb|Oz%k_ +l_4j9!h*L@DuCSEb6OjiP8YQoBN%lC7&eDYedQSjhBdqw>wsXPoGKt(sL`l!Y)>Hs8&0duU!uBNDk1$ +>-79=v{M$)!Uy$R!Qsk%0mGnVdrgrn6h^w%fu>^Q}#jGa?0+CQt4b|Q?{&%Opg4)LKQK8k$I|3Y*eyk +$F!NSj5c`7P3NS_OKE^KPBImaCc9KSTJ{Vebm3IYp_5X+mf>Kn`FDQx7xg;N&tY(iFzrFotrzg#?M&H +YkqQ`Vb0gQH%1Zl_%!>Eg>_iDP=g`_xl$8Zvsk8z4c*OABK0Mq#Ox^4K!|kW}-Q!1o{W$+{!*AvfytD +hb_<3>n>!Q2#Y5uT$eEZ>c@rf_)mi+zQ$uTaURq#WyGkA|7(dQ&u9A`AfiQsvK6^@G4KG;qCr +t#5pXHxV16ox!6h0C!^8GCCK23hirIcZJ7SB- +=?|EZuuN$JB^emPr5zXcy1Pkv{=5i`F>eZX}{X +R|LRyYZxdOr$B_0)YE0J#%{MgAlbD{pv3xD<($yQ;vJiQ=M?$hYE(6g_m~wSkuRDebrQ{r=t*hhFZyt +ErN^SdY0L(uCkN_V|C?WrDo+;+4`GpP`ZoeC>GrUuPqH_H-?WBQK-^o1X8@`$3}g=QQ}B@7H30Mjy>d +$gm>I=hiRYMq$|K%FkEgWvJn!Y$O7{X1l9wYwy4HC@mbck;|_7(xjK+FUJunbQkTPyc?Py)@|PaDz}B +%fTRje)eX=9x+rSxwInaVk3gos)CIHT7y@-DIM +3=pL@8`ossZHwkX1mR)$|)|j*obd&;|PihCya9lI`UH5`UPfwcAk0#;;zXCw9MJ0!RuYt<1}o8k8iF& +xysYu!wClu1`)`lxyx#Mjg!~^AGC`ZLQhhi#o$6gx9lEA}UF%Ln9Pg&4n)KJ9LXXFd}`s(V}<$!3k4M +WeBNjHlG67X7Bl`BkfvH6-9%M(oR_o;OiH+j!9I}FgTj^sO`@-Hyela%sKFE;k7+