From 3444d7cff4ee1d960381d66332ad2d1029ba396a Mon Sep 17 00:00:00 2001 From: ikun97 Date: Fri, 20 Sep 2024 19:58:50 +0800 Subject: [PATCH 1/3] Dev missing item tips (#17) --- .../workflow/import-modal/index.tsx | 23 ++++-------------- .../components/workflow/node-card/index.tsx | 19 ++++++++++++--- .../components/workflow/node-form/index.tsx | 15 +++++++++++- .../workflow/nodes/widget-node/index.tsx | 24 +++++++++++++++++-- .../src/stores/workflow/schema-provider.tsx | 10 ++++---- .../src/stores/workflow/workflow-store.tsx | 20 +++++++++++++++- .../src/components/control/index.tsx | 19 ++++++++++++++- .../src/components/provider/index.tsx | 6 ++++- web/packages/form-engine/src/index.tsx | 3 +++ 9 files changed, 107 insertions(+), 32 deletions(-) diff --git a/web/apps/web/src/components/workflow/import-modal/index.tsx b/web/apps/web/src/components/workflow/import-modal/index.tsx index c5b0745c..98076943 100644 --- a/web/apps/web/src/components/workflow/import-modal/index.tsx +++ b/web/apps/web/src/components/workflow/import-modal/index.tsx @@ -39,7 +39,6 @@ const ImportModal: React.FC<{ onOpenChange: (open: boolean) => void; }> = ({ open, onOpenChange }) => { const [openTips, setOpenTips] = useBoolean(false); - const [isExpand, isExpandAction] = useBoolean(false); const [fileUrl, setFileUrl] = useState(); const [workflow, setWorkflow] = useState(); const { existedInfo, importWorkflow, setExistedInfo } = useWorkflowStore( @@ -204,31 +203,17 @@ const ImportModal: React.FC<{ - Warning + Missing Items The following items are missing.
- Replace it with installed models/widgets, or contact us to add - it to the standard environment. + If this workflow would run in MyShell, please replace the + missing models/widgets with similar installed ones, or contact + us to add them to the standard environment. -
isExpandAction.toggle()}> - - {isExpand ? 'Show Less' : 'View Detail'} - - -
{!isEmpty(existedInfo.non_existed_models) ? (
diff --git a/web/apps/web/src/components/workflow/node-card/index.tsx b/web/apps/web/src/components/workflow/node-card/index.tsx index 5b005804..9053d6ad 100644 --- a/web/apps/web/src/components/workflow/node-card/index.tsx +++ b/web/apps/web/src/components/workflow/node-card/index.tsx @@ -14,9 +14,19 @@ const NodeCard: React.FC< NodeData & { children: React.ReactNode; selected?: boolean; + has_error?: boolean; mode?: string; } -> = ({ id, children, runtime_data, selected, name, display_name, mode }) => { +> = ({ + id, + children, + runtime_data, + selected, + name, + display_name, + mode, + has_error, +}) => { const selectRef = useRef(null); const active = useHover(selectRef); const isUndefined = mode === 'undefined'; @@ -35,7 +45,9 @@ const NodeCard: React.FC< }, { '!border-critical': - runtime_data?.node_status === NodeStatusEnum.failed || isUndefined, + runtime_data?.node_status === NodeStatusEnum.failed || + isUndefined || + has_error, }, { '!border-brand': runtime_data?.node_status === NodeStatusEnum.start, @@ -48,13 +60,14 @@ const NodeCard: React.FC< {isUndefined ? (
- Undefined Widget + Missing Widget Replace it with installed widgets, or contact us to add it to diff --git a/web/apps/web/src/components/workflow/node-form/index.tsx b/web/apps/web/src/components/workflow/node-form/index.tsx index 596f2c01..85120a00 100644 --- a/web/apps/web/src/components/workflow/node-form/index.tsx +++ b/web/apps/web/src/components/workflow/node-form/index.tsx @@ -44,10 +44,22 @@ interface NodeFormProps { loading?: boolean; modeMap?: Record; onModeChange?: (name: string, mode: TFieldMode) => void; + onStatusChange?: (status: { [key: string]: string }) => void; } const NodeForm = forwardRef( - ({ values, onChange, schema, loading, onModeChange, modeMap }, ref) => { + ( + { + values, + onChange, + schema, + loading, + onModeChange, + onStatusChange, + modeMap, + }, + ref, + ) => { const { schema: formSchema, formKey } = useSchemaContext(state => ({ schema: state.schema, formKey: state.formKey, @@ -78,6 +90,7 @@ const NodeForm = forwardRef( schema={currentSchema} modeMap={modeMap} onModeChange={onModeChange} + onStatusChange={onStatusChange} components={{ Input, Select, diff --git a/web/apps/web/src/components/workflow/nodes/widget-node/index.tsx b/web/apps/web/src/components/workflow/nodes/widget-node/index.tsx index 1f4e1693..e59df964 100644 --- a/web/apps/web/src/components/workflow/nodes/widget-node/index.tsx +++ b/web/apps/web/src/components/workflow/nodes/widget-node/index.tsx @@ -6,7 +6,13 @@ import { import { TValues, TFieldMode } from '@shellagent/form-engine'; import { FormRef } from '@shellagent/ui'; import { useKeyPress } from 'ahooks'; -import React, { useCallback, useRef, useEffect } from 'react'; +import React, { + useCallback, + useRef, + useEffect, + useState, + useMemo, +} from 'react'; import { useShallow } from 'zustand/react/shallow'; import { useWorkflowState } from '@/stores/workflow/use-workflow-state'; @@ -21,6 +27,7 @@ import { useDuplicateState } from './hook/use-duplicate-state'; import { EventType, useEventEmitter } from '../../emitter'; import NodeCard from '../../node-card'; import NodeForm from '../../node-form'; +import { some } from 'lodash-es'; const WidgetNode: React.FC> = ({ id, @@ -29,6 +36,7 @@ const WidgetNode: React.FC> = ({ }) => { const formRef = useRef(null); const nodeRef = useRef(null); + const statusRef = useRef({}); const { duplicateState } = useDuplicateState(id); const { onDelNode } = useReactFlowStore(state => ({ onDelNode: state.onDelNode, @@ -37,6 +45,8 @@ const WidgetNode: React.FC> = ({ setCurrentCopyId: state.setCurrentCopyId, })); + const [hasError, setHasError] = useState(false); + const { setNodeData, nodeData, @@ -144,14 +154,24 @@ const WidgetNode: React.FC> = ({ } }); + const onStatusChange = (obj: { [key: string]: string }) => { + statusRef.current = { ...statusRef.current, ...obj }; + setHasError(some(statusRef.current, value => value === 'missOption')); + }; + return ( - + value === 'missOption')} + {...data}> diff --git a/web/apps/web/src/stores/workflow/schema-provider.tsx b/web/apps/web/src/stores/workflow/schema-provider.tsx index 3723f4a3..24e3e3b4 100644 --- a/web/apps/web/src/stores/workflow/schema-provider.tsx +++ b/web/apps/web/src/stores/workflow/schema-provider.tsx @@ -52,14 +52,16 @@ export const useSchemaContext = ( export interface SchemaProviderProps { id: string; - name: string | undefined; - display_name: string | undefined; + name?: string; + mode?: string; + display_name?: string; children: React.ReactNode | React.ReactNode[]; output?: Record; } export const SchemaProvider: React.FC = ({ name = '', + mode, display_name = '', id, children, @@ -122,7 +124,7 @@ export const SchemaProvider: React.FC = ({ memoized.schema = endSchema; } else if (!isEmpty(currentWidgetSchema)) { const schema = getSchemaByWidget({ - name: display_name, + name: mode === 'undefined' ? name : display_name, inputSchema: currentWidgetSchema?.input_schema, outputSchema: currentWidgetSchema?.output_schema, fieldsModeMap: currentFieldsModeMap, @@ -142,7 +144,7 @@ export const SchemaProvider: React.FC = ({ outputs: memoized.outputRefTypes, }); return memoized; - }, [id, name, display_name, currentWidgetSchema, currentFieldsModeMap]); + }, [id, mode, name, display_name, currentWidgetSchema, currentFieldsModeMap]); const formKey = useMemo(() => { return `${JSON.stringify({ diff --git a/web/apps/web/src/stores/workflow/workflow-store.tsx b/web/apps/web/src/stores/workflow/workflow-store.tsx index 52c8f726..452498c5 100644 --- a/web/apps/web/src/stores/workflow/workflow-store.tsx +++ b/web/apps/web/src/stores/workflow/workflow-store.tsx @@ -395,7 +395,6 @@ export const createWorkflowStore = () => { ); } if (type === EventStatusEnum.workflow_end) { - get().flowInstance?.fitView(); set( produce(state => { state.loading.workflowRunning = false; @@ -453,11 +452,30 @@ export const createWorkflowStore = () => { return nodes; }); if (data?.node_status === NodeStatusEnum.failed) { + get().flowInstance?.fitView({ + minZoom: 0.8, + maxZoom: 1.5, + nodes: [{ id: data?.node_id as string }], + padding: 400, + }); + // 设置为选中状态，放到最上层 + get().flowInstance?.setNodes(nodes => + nodes.map(node => + node.id === data?.node_id + ? { + ...node, + selected: true, + } + : node, + ), + ); set( produce(state => { state.loading.workflowRunning = false; }), ); + } else { + get().flowInstance?.fitView(); } } }, diff --git a/web/packages/form-engine/src/components/control/index.tsx b/web/packages/form-engine/src/components/control/index.tsx index 6a5a9e3a..0ef87223 100644 --- a/web/packages/form-engine/src/components/control/index.tsx +++ b/web/packages/form-engine/src/components/control/index.tsx @@ -14,6 +14,7 @@ import { TooltipContent, IconButton, Switch, + Text, } from '@shellagent/ui'; import { isEmpty, omit } from 'lodash-es'; import React, { useMemo, useRef, useState } from 'react'; @@ -37,7 +38,7 @@ type Mode = 'raw' | 'ui' | 'ref'; */ const Control: React.FC = props => { const { name } = props; - const { fields, components, remove, modeMap, onModeChange } = + const { fields, components, remove, modeMap, onModeChange, onStatusChange } = useFormEngineContext(); const { setValue, getValues } = useFormContext(); const { schema, state, parent } = fields[name] || {}; @@ -284,11 +285,27 @@ const Control: React.FC = props => { if (xOnChangePropsName) { newField[xOnChangePropsName] = field.onChange; } + const missOption = + xComponentProps?.options?.length && + newField[valuePropsName] && + !xComponentProps?.options?.find( + (item: { value: string }) => + item.value === (newField[valuePropsName] as unknown as string), + ); + if (missOption !== undefined) { + onStatusChange?.({ [name]: missOption ? 'missOption' : '' }); + } const FormItemWithDesc = (!checked && xSwithable) || xHiddenControl ? null : (
{renderFormItem()} {fieldState.error ? : null} + {missOption ? ( + + {newField[valuePropsName] as unknown as string} is + undefined. + + ) : null}
); diff --git a/web/packages/form-engine/src/components/provider/index.tsx b/web/packages/form-engine/src/components/provider/index.tsx index 5e302500..b04194ce 100644 --- a/web/packages/form-engine/src/components/provider/index.tsx +++ b/web/packages/form-engine/src/components/provider/index.tsx @@ -26,6 +26,7 @@ const FormEngineContext = createContext<{ reorder: (path: TPath, startIndex: number, endIndex: number) => void; modeMap?: Record; onModeChange?: (name: string, mode: TFieldMode) => void; + onStatusChange?: (obj: { [key: string]: string }) => void; }>({ components: {}, fields: {}, @@ -42,6 +43,7 @@ export interface IFormEngineProviderProps { layout?: 'Horizontal' | 'Vertical'; modeMap?: Record; onModeChange?: (name: string, mode: TFieldMode) => void; + onStatusChange?: (obj: { [key: string]: string }) => void; children: React.ReactNode | React.ReactNode[]; } @@ -52,7 +54,8 @@ export const useFormEngineContext = () => { const Counter: { [path: string]: number } = {}; export const FormEngineProvider: React.FC = props => { - const { children, fields, components, parent, layout } = props; + const { children, fields, components, parent, layout, onStatusChange } = + props; const { getValues, setValue } = useFormContext(); const [modeMap, setModeMap] = useImmer(props.modeMap || {}); @@ -178,6 +181,7 @@ export const FormEngineProvider: React.FC = props => { reorder, modeMap, onModeChange, + onStatusChange, }}> {children} diff --git a/web/packages/form-engine/src/index.tsx b/web/packages/form-engine/src/index.tsx index 6ebc82d3..ce0751fe 100644 --- a/web/packages/form-engine/src/index.tsx +++ b/web/packages/form-engine/src/index.tsx @@ -37,6 +37,7 @@ export interface IFormEngineProps { children?: React.ReactNode; modeMap?: Record; onModeChange?: (name: string, mode: TFieldMode) => void; + onStatusChange?: (obj: { [key: string]: string }) => void; } const FormEngine = forwardRef((props, ref) => { @@ -52,6 +53,7 @@ const FormEngine = forwardRef((props, ref) => { onModeChange, onChange, onSubmit, + onStatusChange, } = props; const [fields, setFields] = useState(createFields(schema, values)); @@ -107,6 +109,7 @@ const FormEngine = forwardRef((props, ref) => { Date: Fri, 20 Sep 2024 20:06:35 +0800 Subject: [PATCH 2/3] Dev update libraries (#18) Co-authored-by: yuxumin <1090414006@qq.com> --- .../Library/bin/libomp140.x86_64.dll | Bin 0 -> 698888 bytes .ci/python_dependencies_wins/include/Python.h | 148 +++ .../include/abstract.h | 873 ++++++++++++ .../include/bltinmodule.h | 14 + .../include/boolobject.h | 43 + .../include/bytearrayobject.h | 46 + .../include/bytesobject.h | 69 + .../include/cellobject.h | 29 + .ci/python_dependencies_wins/include/ceval.h | 158 +++ .../include/classobject.h | 57 + .ci/python_dependencies_wins/include/code.h | 20 + .ci/python_dependencies_wins/include/codecs.h | 248 ++++ .../include/compile.h | 25 + .../include/complexobject.h | 69 + .../include/context.h | 81 ++ .../include/cpython/abstract.h | 373 ++++++ .../include/cpython/bytearrayobject.h | 20 + .../include/cpython/bytesobject.h | 118 ++ .../include/cpython/ceval.h | 30 + .../include/cpython/code.h | 184 +++ .../include/cpython/compile.h | 54 + .../include/cpython/dictobject.h | 84 ++ .../include/cpython/fileobject.h | 18 + .../include/cpython/fileutils.h | 172 +++ .../include/cpython/frameobject.h | 94 ++ .../include/cpython/import.h | 46 + .../include/cpython/initconfig.h | 249 ++++ .../include/cpython/interpreteridobject.h | 11 + .../include/cpython/listobject.h | 34 + .../include/cpython/methodobject.h | 35 + .../include/cpython/object.h | 552 ++++++++ .../include/cpython/objimpl.h | 100 ++ .../include/cpython/odictobject.h | 43 + .../include/cpython/picklebufobject.h | 31 + .../include/cpython/pyctype.h | 39 + .../include/cpython/pydebug.h | 38 + .../include/cpython/pyerrors.h | 214 +++ .../include/cpython/pyfpe.h | 15 + .../include/cpython/pylifecycle.h | 64 + .../include/cpython/pymem.h | 98 ++ .../include/cpython/pystate.h | 305 +++++ .../include/cpython/pythonrun.h | 121 ++ .../include/cpython/pytime.h | 247 ++++ .../include/cpython/sysmodule.h | 16 + .../include/cpython/traceback.h | 14 + .../include/cpython/tupleobject.h | 28 + .../include/cpython/unicodeobject.h | 1169 +++++++++++++++++ .../include/datetime.h | 267 ++++ .../include/descrobject.h | 108 ++ .../include/dictobject.h | 97 ++ .../include/dynamic_annotations.h | 499 +++++++ .../include/enumobject.h | 17 + .../include/errcode.h | 38 + .ci/python_dependencies_wins/include/eval.h | 27 + .../include/exports.h | 30 + .../include/fileobject.h | 49 + .../include/fileutils.h | 26 + .../include/floatobject.h | 118 ++ .../include/frameobject.h | 20 + .../include/funcobject.h | 110 ++ .../include/genericaliasobject.h | 14 + .../include/genobject.h | 100 ++ .../include/greenlet/greenlet.h | 164 +++ .ci/python_dependencies_wins/include/import.h | 98 ++ .../include/insightface/mesh_core.h | 83 ++ .../include/internal/pycore_abstract.h | 22 + .../include/internal/pycore_accu.h | 39 + .../include/internal/pycore_asdl.h | 112 ++ .../include/internal/pycore_ast.h | 855 ++++++++++++ .../include/internal/pycore_ast_state.h | 255 ++++ .../include/internal/pycore_atomic.h | 557 ++++++++ .../include/internal/pycore_atomic_funcs.h | 94 ++ .../include/internal/pycore_bitutils.h | 176 +++ .../internal/pycore_blocks_output_buffer.h | 317 +++++ .../include/internal/pycore_bytes_methods.h | 73 + .../include/internal/pycore_call.h | 39 + .../include/internal/pycore_ceval.h | 114 ++ .../include/internal/pycore_code.h | 34 + .../include/internal/pycore_compile.h | 44 + .../include/internal/pycore_condvar.h | 95 ++ .../include/internal/pycore_context.h | 42 + .../include/internal/pycore_dtoa.h | 23 + .../include/internal/pycore_fileutils.h | 71 + .../include/internal/pycore_format.h | 27 + .../include/internal/pycore_gc.h | 181 +++ .../include/internal/pycore_getopt.h | 22 + .../include/internal/pycore_gil.h | 50 + .../include/internal/pycore_hamt.h | 128 ++ .../include/internal/pycore_hashtable.h | 148 +++ .../include/internal/pycore_import.h | 17 + .../include/internal/pycore_initconfig.h | 178 +++ .../include/internal/pycore_interp.h | 339 +++++ .../include/internal/pycore_list.h | 20 + .../include/internal/pycore_long.h | 75 ++ .../include/internal/pycore_moduleobject.h | 42 + .../include/internal/pycore_object.h | 186 +++ .../include/internal/pycore_parser.h | 31 + .../include/internal/pycore_pathconfig.h | 73 + .../include/internal/pycore_pyarena.h | 64 + .../include/internal/pycore_pyerrors.h | 96 ++ .../include/internal/pycore_pyhash.h | 10 + .../include/internal/pycore_pylifecycle.h | 141 ++ .../include/internal/pycore_pymem.h | 101 ++ .../include/internal/pycore_pystate.h | 153 +++ .../include/internal/pycore_runtime.h | 157 +++ .../include/internal/pycore_structseq.h | 21 + .../include/internal/pycore_symtable.h | 133 ++ .../include/internal/pycore_sysmodule.h | 24 + .../include/internal/pycore_traceback.h | 93 ++ .../include/internal/pycore_tuple.h | 20 + .../include/internal/pycore_ucnhash.h | 34 + .../include/internal/pycore_unionobject.h | 22 + .../include/internal/pycore_warnings.h | 25 + .../include/interpreteridobject.h | 17 + .../include/intrcheck.h | 30 + .../include/iterobject.h | 27 + .../include/listobject.h | 52 + .../include/longintrepr.h | 99 ++ .../include/longobject.h | 220 ++++ .../include/marshal.h | 28 + .../include/memoryobject.h | 72 + .../include/methodobject.h | 116 ++ .../include/modsupport.h | 263 ++++ .../include/moduleobject.h | 96 ++ .../include/namespaceobject.h | 19 + .ci/python_dependencies_wins/include/object.h | 749 +++++++++++ .../include/objimpl.h | 215 +++ .ci/python_dependencies_wins/include/opcode.h | 172 +++ .ci/python_dependencies_wins/include/osdefs.h | 51 + .../include/osmodule.h | 17 + .../include/patchlevel.h | 35 + .../include/py_curses.h | 99 ++ .../include/pycapsule.h | 59 + .../include/pyconfig.h | 690 ++++++++++ .../include/pydtrace.h | 59 + .../include/pyerrors.h | 324 +++++ .../include/pyexpat.h | 55 + .../include/pyframe.h | 22 + .ci/python_dependencies_wins/include/pyhash.h | 144 ++ .../include/pylifecycle.h | 74 ++ .../include/pymacconfig.h | 102 ++ .../include/pymacro.h | 132 ++ .ci/python_dependencies_wins/include/pymath.h | 230 ++++ .ci/python_dependencies_wins/include/pymem.h | 104 ++ .ci/python_dependencies_wins/include/pyport.h | 889 +++++++++++++ .../include/pystate.h | 150 +++ .../include/pystrcmp.h | 23 + .../include/pystrhex.h | 22 + .../include/pystrtod.h | 45 + .../include/pythonrun.h | 44 + .../include/pythread.h | 169 +++ .../include/rangeobject.h | 27 + .../include/setobject.h | 110 ++ .../include/sliceobject.h | 65 + .../include/structmember.h | 75 ++ .../include/structseq.h | 49 + .../include/sysmodule.h | 41 + .ci/python_dependencies_wins/include/token.h | 97 ++ .../include/traceback.h | 26 + .../include/tracemalloc.h | 38 + .../include/tupleobject.h | 46 + .../include/typeslots.h | 94 ++ .../include/unicodeobject.h | 1053 +++++++++++++++ .../include/warnings.h | 67 + .../include/weakrefobject.h | 86 ++ .../libs/_tkinter.lib | Bin 0 -> 1750 bytes .ci/python_dependencies_wins/libs/python3.lib | Bin 0 -> 180006 bytes .../libs/python310.lib | Bin 0 -> 356438 bytes .ci/windows_base_files/run.bat | 44 + .github/workflows/stable-release.yaml | 167 +++ proconfig/widgets/imagen_widgets/__init__.py | 5 +- .../tools/web/extensions/EG_GN_NODES/wbksh.js | 75 ++ ...t, eventually I'll have stuff in here..txt | 0 .../web/extensions/dzNodes/dz_comfy_shared.js | 341 +++++ .../tools/web/extensions/dzNodes/dz_debug.js | 109 ++ .../web/extensions/dzNodes/dz_mtb_widgets.js | 908 +++++++++++++ .../web/extensions/dzNodes/dz_node_palette.js | 42 + .../web/extensions/dzNodes/dz_parse-css.js | 362 +++++ 178 files changed, 23574 insertions(+), 1 deletion(-) create mode 100644 .ci/python_dependencies_wins/Library/bin/libomp140.x86_64.dll create mode 100644 .ci/python_dependencies_wins/include/Python.h create mode 100644 .ci/python_dependencies_wins/include/abstract.h create mode 100644 .ci/python_dependencies_wins/include/bltinmodule.h create mode 100644 .ci/python_dependencies_wins/include/boolobject.h create mode 100644 .ci/python_dependencies_wins/include/bytearrayobject.h create mode 100644 .ci/python_dependencies_wins/include/bytesobject.h create mode 100644 .ci/python_dependencies_wins/include/cellobject.h create mode 100644 .ci/python_dependencies_wins/include/ceval.h create mode 100644 .ci/python_dependencies_wins/include/classobject.h create mode 100644 .ci/python_dependencies_wins/include/code.h create mode 100644 .ci/python_dependencies_wins/include/codecs.h create mode 100644 .ci/python_dependencies_wins/include/compile.h create mode 100644 .ci/python_dependencies_wins/include/complexobject.h create mode 100644 .ci/python_dependencies_wins/include/context.h create mode 100644 .ci/python_dependencies_wins/include/cpython/abstract.h create mode 100644 .ci/python_dependencies_wins/include/cpython/bytearrayobject.h create mode 100644 .ci/python_dependencies_wins/include/cpython/bytesobject.h create mode 100644 .ci/python_dependencies_wins/include/cpython/ceval.h create mode 100644 .ci/python_dependencies_wins/include/cpython/code.h create mode 100644 .ci/python_dependencies_wins/include/cpython/compile.h create mode 100644 .ci/python_dependencies_wins/include/cpython/dictobject.h create mode 100644 .ci/python_dependencies_wins/include/cpython/fileobject.h create mode 100644 .ci/python_dependencies_wins/include/cpython/fileutils.h create mode 100644 .ci/python_dependencies_wins/include/cpython/frameobject.h create mode 100644 .ci/python_dependencies_wins/include/cpython/import.h create mode 100644 .ci/python_dependencies_wins/include/cpython/initconfig.h create mode 100644 .ci/python_dependencies_wins/include/cpython/interpreteridobject.h create mode 100644 .ci/python_dependencies_wins/include/cpython/listobject.h create mode 100644 .ci/python_dependencies_wins/include/cpython/methodobject.h create mode 100644 .ci/python_dependencies_wins/include/cpython/object.h create mode 100644 .ci/python_dependencies_wins/include/cpython/objimpl.h create mode 100644 .ci/python_dependencies_wins/include/cpython/odictobject.h create mode 100644 .ci/python_dependencies_wins/include/cpython/picklebufobject.h create mode 100644 .ci/python_dependencies_wins/include/cpython/pyctype.h create mode 100644 .ci/python_dependencies_wins/include/cpython/pydebug.h create mode 100644 .ci/python_dependencies_wins/include/cpython/pyerrors.h create mode 100644 .ci/python_dependencies_wins/include/cpython/pyfpe.h create mode 100644 .ci/python_dependencies_wins/include/cpython/pylifecycle.h create mode 100644 .ci/python_dependencies_wins/include/cpython/pymem.h create mode 100644 .ci/python_dependencies_wins/include/cpython/pystate.h create mode 100644 .ci/python_dependencies_wins/include/cpython/pythonrun.h create mode 100644 .ci/python_dependencies_wins/include/cpython/pytime.h create mode 100644 .ci/python_dependencies_wins/include/cpython/sysmodule.h create mode 100644 .ci/python_dependencies_wins/include/cpython/traceback.h create mode 100644 .ci/python_dependencies_wins/include/cpython/tupleobject.h create mode 100644 .ci/python_dependencies_wins/include/cpython/unicodeobject.h create mode 100644 .ci/python_dependencies_wins/include/datetime.h create mode 100644 .ci/python_dependencies_wins/include/descrobject.h create mode 100644 .ci/python_dependencies_wins/include/dictobject.h create mode 100644 .ci/python_dependencies_wins/include/dynamic_annotations.h create mode 100644 .ci/python_dependencies_wins/include/enumobject.h create mode 100644 .ci/python_dependencies_wins/include/errcode.h create mode 100644 .ci/python_dependencies_wins/include/eval.h create mode 100644 .ci/python_dependencies_wins/include/exports.h create mode 100644 .ci/python_dependencies_wins/include/fileobject.h create mode 100644 .ci/python_dependencies_wins/include/fileutils.h create mode 100644 .ci/python_dependencies_wins/include/floatobject.h create mode 100644 .ci/python_dependencies_wins/include/frameobject.h create mode 100644 .ci/python_dependencies_wins/include/funcobject.h create mode 100644 .ci/python_dependencies_wins/include/genericaliasobject.h create mode 100644 .ci/python_dependencies_wins/include/genobject.h create mode 100644 .ci/python_dependencies_wins/include/greenlet/greenlet.h create mode 100644 .ci/python_dependencies_wins/include/import.h create mode 100644 .ci/python_dependencies_wins/include/insightface/mesh_core.h create mode 100644 .ci/python_dependencies_wins/include/internal/pycore_abstract.h create mode 100644 .ci/python_dependencies_wins/include/internal/pycore_accu.h create mode 100644 .ci/python_dependencies_wins/include/internal/pycore_asdl.h create mode 100644 .ci/python_dependencies_wins/include/internal/pycore_ast.h create mode 100644 .ci/python_dependencies_wins/include/internal/pycore_ast_state.h create mode 100644 .ci/python_dependencies_wins/include/internal/pycore_atomic.h create mode 100644 .ci/python_dependencies_wins/include/internal/pycore_atomic_funcs.h create mode 100644 .ci/python_dependencies_wins/include/internal/pycore_bitutils.h create mode 100644 .ci/python_dependencies_wins/include/internal/pycore_blocks_output_buffer.h create mode 100644 .ci/python_dependencies_wins/include/internal/pycore_bytes_methods.h create mode 100644 .ci/python_dependencies_wins/include/internal/pycore_call.h create mode 100644 .ci/python_dependencies_wins/include/internal/pycore_ceval.h create mode 100644 .ci/python_dependencies_wins/include/internal/pycore_code.h create mode 100644 .ci/python_dependencies_wins/include/internal/pycore_compile.h create mode 100644 .ci/python_dependencies_wins/include/internal/pycore_condvar.h create mode 100644 .ci/python_dependencies_wins/include/internal/pycore_context.h create mode 100644 .ci/python_dependencies_wins/include/internal/pycore_dtoa.h create mode 100644 .ci/python_dependencies_wins/include/internal/pycore_fileutils.h create mode 100644 .ci/python_dependencies_wins/include/internal/pycore_format.h create mode 100644 .ci/python_dependencies_wins/include/internal/pycore_gc.h create mode 100644 .ci/python_dependencies_wins/include/internal/pycore_getopt.h create mode 100644 .ci/python_dependencies_wins/include/internal/pycore_gil.h create mode 100644 .ci/python_dependencies_wins/include/internal/pycore_hamt.h create mode 100644 .ci/python_dependencies_wins/include/internal/pycore_hashtable.h create mode 100644 .ci/python_dependencies_wins/include/internal/pycore_import.h create mode 100644 .ci/python_dependencies_wins/include/internal/pycore_initconfig.h create mode 100644 .ci/python_dependencies_wins/include/internal/pycore_interp.h create mode 100644 .ci/python_dependencies_wins/include/internal/pycore_list.h create mode 100644 .ci/python_dependencies_wins/include/internal/pycore_long.h create mode 100644 .ci/python_dependencies_wins/include/internal/pycore_moduleobject.h create mode 100644 .ci/python_dependencies_wins/include/internal/pycore_object.h create mode 100644 .ci/python_dependencies_wins/include/internal/pycore_parser.h create mode 100644 .ci/python_dependencies_wins/include/internal/pycore_pathconfig.h create mode 100644 .ci/python_dependencies_wins/include/internal/pycore_pyarena.h create mode 100644 .ci/python_dependencies_wins/include/internal/pycore_pyerrors.h create mode 100644 .ci/python_dependencies_wins/include/internal/pycore_pyhash.h create mode 100644 .ci/python_dependencies_wins/include/internal/pycore_pylifecycle.h create mode 100644 .ci/python_dependencies_wins/include/internal/pycore_pymem.h create mode 100644 .ci/python_dependencies_wins/include/internal/pycore_pystate.h create mode 100644 .ci/python_dependencies_wins/include/internal/pycore_runtime.h create mode 100644 .ci/python_dependencies_wins/include/internal/pycore_structseq.h create mode 100644 .ci/python_dependencies_wins/include/internal/pycore_symtable.h create mode 100644 .ci/python_dependencies_wins/include/internal/pycore_sysmodule.h create mode 100644 .ci/python_dependencies_wins/include/internal/pycore_traceback.h create mode 100644 .ci/python_dependencies_wins/include/internal/pycore_tuple.h create mode 100644 .ci/python_dependencies_wins/include/internal/pycore_ucnhash.h create mode 100644 .ci/python_dependencies_wins/include/internal/pycore_unionobject.h create mode 100644 .ci/python_dependencies_wins/include/internal/pycore_warnings.h create mode 100644 .ci/python_dependencies_wins/include/interpreteridobject.h create mode 100644 .ci/python_dependencies_wins/include/intrcheck.h create mode 100644 .ci/python_dependencies_wins/include/iterobject.h create mode 100644 .ci/python_dependencies_wins/include/listobject.h create mode 100644 .ci/python_dependencies_wins/include/longintrepr.h create mode 100644 .ci/python_dependencies_wins/include/longobject.h create mode 100644 .ci/python_dependencies_wins/include/marshal.h create mode 100644 .ci/python_dependencies_wins/include/memoryobject.h create mode 100644 .ci/python_dependencies_wins/include/methodobject.h create mode 100644 .ci/python_dependencies_wins/include/modsupport.h create mode 100644 .ci/python_dependencies_wins/include/moduleobject.h create mode 100644 .ci/python_dependencies_wins/include/namespaceobject.h create mode 100644 .ci/python_dependencies_wins/include/object.h create mode 100644 .ci/python_dependencies_wins/include/objimpl.h create mode 100644 .ci/python_dependencies_wins/include/opcode.h create mode 100644 .ci/python_dependencies_wins/include/osdefs.h create mode 100644 .ci/python_dependencies_wins/include/osmodule.h create mode 100644 .ci/python_dependencies_wins/include/patchlevel.h create mode 100644 .ci/python_dependencies_wins/include/py_curses.h create mode 100644 .ci/python_dependencies_wins/include/pycapsule.h create mode 100644 .ci/python_dependencies_wins/include/pyconfig.h create mode 100644 .ci/python_dependencies_wins/include/pydtrace.h create mode 100644 .ci/python_dependencies_wins/include/pyerrors.h create mode 100644 .ci/python_dependencies_wins/include/pyexpat.h create mode 100644 .ci/python_dependencies_wins/include/pyframe.h create mode 100644 .ci/python_dependencies_wins/include/pyhash.h create mode 100644 .ci/python_dependencies_wins/include/pylifecycle.h create mode 100644 .ci/python_dependencies_wins/include/pymacconfig.h create mode 100644 .ci/python_dependencies_wins/include/pymacro.h create mode 100644 .ci/python_dependencies_wins/include/pymath.h create mode 100644 .ci/python_dependencies_wins/include/pymem.h create mode 100644 .ci/python_dependencies_wins/include/pyport.h create mode 100644 .ci/python_dependencies_wins/include/pystate.h create mode 100644 .ci/python_dependencies_wins/include/pystrcmp.h create mode 100644 .ci/python_dependencies_wins/include/pystrhex.h create mode 100644 .ci/python_dependencies_wins/include/pystrtod.h create mode 100644 .ci/python_dependencies_wins/include/pythonrun.h create mode 100644 .ci/python_dependencies_wins/include/pythread.h create mode 100644 .ci/python_dependencies_wins/include/rangeobject.h create mode 100644 .ci/python_dependencies_wins/include/setobject.h create mode 100644 .ci/python_dependencies_wins/include/sliceobject.h create mode 100644 .ci/python_dependencies_wins/include/structmember.h create mode 100644 .ci/python_dependencies_wins/include/structseq.h create mode 100644 .ci/python_dependencies_wins/include/sysmodule.h create mode 100644 .ci/python_dependencies_wins/include/token.h create mode 100644 .ci/python_dependencies_wins/include/traceback.h create mode 100644 .ci/python_dependencies_wins/include/tracemalloc.h create mode 100644 .ci/python_dependencies_wins/include/tupleobject.h create mode 100644 .ci/python_dependencies_wins/include/typeslots.h create mode 100644 .ci/python_dependencies_wins/include/unicodeobject.h create mode 100644 .ci/python_dependencies_wins/include/warnings.h create mode 100644 .ci/python_dependencies_wins/include/weakrefobject.h create mode 100644 .ci/python_dependencies_wins/libs/_tkinter.lib create mode 100644 .ci/python_dependencies_wins/libs/python3.lib create mode 100644 .ci/python_dependencies_wins/libs/python310.lib create mode 100644 .ci/windows_base_files/run.bat create mode 100644 .github/workflows/stable-release.yaml create mode 100644 proconfig/widgets/tools/web/extensions/EG_GN_NODES/wbksh.js create mode 100644 proconfig/widgets/tools/web/extensions/FizzleDorf/Folder here to satisfy init, eventually I'll have stuff in here..txt create mode 100644 proconfig/widgets/tools/web/extensions/dzNodes/dz_comfy_shared.js create mode 100644 proconfig/widgets/tools/web/extensions/dzNodes/dz_debug.js create mode 100644 proconfig/widgets/tools/web/extensions/dzNodes/dz_mtb_widgets.js create mode 100644 proconfig/widgets/tools/web/extensions/dzNodes/dz_node_palette.js create mode 100644 proconfig/widgets/tools/web/extensions/dzNodes/dz_parse-css.js diff --git a/.ci/python_dependencies_wins/Library/bin/libomp140.x86_64.dll b/.ci/python_dependencies_wins/Library/bin/libomp140.x86_64.dll new file mode 100644 index 0000000000000000000000000000000000000000..d9fc0644b9f7b0739d565f3a56af8896f88f0ca1 GIT binary patch literal 698888 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

DGl=PqT6 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�Y*02w@N}1`6~71&8#gP#0<2)t&tiSo$#E6ymalDI_jG>9ixotPxS8HAUm zW7WVdZP?_i@23L}Z8yv^4c%qnl>VN6p_A2UW-2wipI~4`h6WsU36^wVi&Nhl*g5~+ zGu_fi9uLL3jXJ9huG}dQ!%vE* zpX17|=qy`BSzmLOwcCtnS>pMQ>=GoY!0)jEFLOEz3`!M{ybT=vmcB%e5$)7xNzd

WwD=}97t{p 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࿹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 + +#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 +#ifndef MS_WINDOWS +#include +#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 sanitizers are enabled. */ +#if defined(__has_feature) +# if __has_feature(memory_sanitizer) +# if !defined(_Py_MEMORY_SANITIZER) +# define _Py_MEMORY_SANITIZER +# endif +# endif +# if __has_feature(address_sanitizer) +# if !defined(_Py_ADDRESS_SANITIZER) +# define _Py_ADDRESS_SANITIZER +# endif +# endif +#elif defined(__GNUC__) +# if defined(__SANITIZE_ADDRESS__) +# define _Py_ADDRESS_SANITIZER +# endif +#endif + +#include "pymath.h" +#include "pymem.h" + +#include "object.h" +#include "objimpl.h" +#include "typeslots.h" +#include "pyhash.h" + +#include "cpython/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 "cpython/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 "code.h" +#include "pyframe.h" +#include "traceback.h" +#include "sliceobject.h" +#include "cellobject.h" +#include "iterobject.h" +#include "cpython/initconfig.h" +#include "genobject.h" +#include "descrobject.h" +#include "genericaliasobject.h" +#include "warnings.h" +#include "weakrefobject.h" +#include "structseq.h" +#include "namespaceobject.h" +#include "cpython/picklebufobject.h" +#include "cpython/pytime.h" + +#include "codecs.h" +#include "pyerrors.h" +#include "pythread.h" +#include "pystate.h" +#include "context.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 "cpython/pyctype.h" +#include "pystrtod.h" +#include "pystrcmp.h" +#include "fileutils.h" +#include "cpython/pyfpe.h" +#include "tracemalloc.h" + +#endif /* !Py_PYTHON_H */ diff --git a/.ci/python_dependencies_wins/include/abstract.h b/.ci/python_dependencies_wins/include/abstract.h new file mode 100644 index 00000000..8da8d983 --- /dev/null +++ b/.ci/python_dependencies_wins/include/abstract.h @@ -0,0 +1,873 @@ +/* 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 +#endif + + +#if !defined(Py_LIMITED_API) || Py_LIMITED_API+0 >= 0x03090000 +/* Call a callable Python object without any arguments */ +PyAPI_FUNC(PyObject *) PyObject_CallNoArgs(PyObject *func); +#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); + + +/* 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, ...); + +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, + ...); + +/* 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, + ...); + + +/* 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 + +/* 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 + usable 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. */ +Py_DEPRECATED(3.0) +PyAPI_FUNC(int) PyObject_AsCharBuffer(PyObject *obj, + const char **buffer, + Py_ssize_t *buffer_len); + +/* Checks whether an arbitrary object supports the (character, single segment) + buffer interface. + + Returns 1 on success, 0 on failure. */ +Py_DEPRECATED(3.0) PyAPI_FUNC(int) PyObject_CheckReadBuffer(PyObject *obj); + +/* 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. */ +Py_DEPRECATED(3.0) +PyAPI_FUNC(int) PyObject_AsReadBuffer(PyObject *obj, + const void **buffer, + Py_ssize_t *buffer_len); + +/* 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. */ +Py_DEPRECATED(3.0) +PyAPI_FUNC(int) PyObject_AsWriteBuffer(PyObject *obj, + void **buffer, + Py_ssize_t *buffer_len); + + +/* === New Buffer 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 *); + +/* Takes an AsyncIterable object and returns an AsyncIterator for it. + This is typically a new iterator but if the argument is an AsyncIterator, + this returns itself. */ +PyAPI_FUNC(PyObject *) PyObject_GetAIter(PyObject *); + +/* Returns non-zero if the object 'obj' provides iterator protocols, and 0 otherwise. + + This function always succeeds. */ +PyAPI_FUNC(int) PyIter_Check(PyObject *); + +/* Returns non-zero if the object 'obj' provides AsyncIterator protocols, and 0 otherwise. + + This function always succeeds. */ +PyAPI_FUNC(int) PyAIter_Check(PyObject *); + +/* 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 *); + +#if !defined(Py_LIMITED_API) || Py_LIMITED_API+0 >= 0x030A0000 + +/* Takes generator, coroutine or iterator object and sends the value into it. + Returns: + - PYGEN_RETURN (0) if generator has returned. + 'result' parameter is filled with return value + - PYGEN_ERROR (-1) if exception was raised. + 'result' parameter is NULL + - PYGEN_NEXT (1) if generator has yielded. + 'result' parameter is filled with yielded value. */ +PyAPI_FUNC(PySendResult) PyIter_Send(PyObject *, PyObject *, PyObject **); +#endif + + +/* === 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); + +/* Returns 1 if obj is an index integer (has the nb_index slot of the + tp_as_number structure filled in), and 0 otherwise. */ +PyAPI_FUNC(int) PyIndex_Check(PyObject *); + +/* 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)) + +/* Return a pointer to the underlying item array for + an object returned 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); + +/* 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 +# define Py_CPYTHON_ABSTRACTOBJECT_H +# include "cpython/abstract.h" +# undef Py_CPYTHON_ABSTRACTOBJECT_H +#endif + +#ifdef __cplusplus +} +#endif +#endif /* Py_ABSTRACTOBJECT_H */ diff --git a/.ci/python_dependencies_wins/include/bltinmodule.h b/.ci/python_dependencies_wins/include/bltinmodule.h new file mode 100644 index 00000000..c04aceaa --- /dev/null +++ b/.ci/python_dependencies_wins/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/.ci/python_dependencies_wins/include/boolobject.h b/.ci/python_dependencies_wins/include/boolobject.h new file mode 100644 index 00000000..b4860659 --- /dev/null +++ b/.ci/python_dependencies_wins/include/boolobject.h @@ -0,0 +1,43 @@ +/* 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_IS_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; +PyAPI_DATA(struct _longobject) _Py_TrueStruct; + +/* Use these macros */ +#define Py_False ((PyObject *) &_Py_FalseStruct) +#define Py_True ((PyObject *) &_Py_TrueStruct) + +// Test if an object is the True singleton, the same as "x is True" in Python. +PyAPI_FUNC(int) Py_IsTrue(PyObject *x); +#define Py_IsTrue(x) Py_Is((x), Py_True) + +// Test if an object is the False singleton, the same as "x is False" in Python. +PyAPI_FUNC(int) Py_IsFalse(PyObject *x); +#define Py_IsFalse(x) Py_Is((x), Py_False) + +/* Macros for returning Py_True or Py_False, respectively */ +#define Py_RETURN_TRUE return Py_NewRef(Py_True) +#define Py_RETURN_FALSE return Py_NewRef(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/.ci/python_dependencies_wins/include/bytearrayobject.h b/.ci/python_dependencies_wins/include/bytearrayobject.h new file mode 100644 index 00000000..1ef0cf3b --- /dev/null +++ b/.ci/python_dependencies_wins/include/bytearrayobject.h @@ -0,0 +1,46 @@ +/* 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. + */ + +/* 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_IS_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); + +#ifndef Py_LIMITED_API +# define Py_CPYTHON_BYTEARRAYOBJECT_H +# include "cpython/bytearrayobject.h" +# undef Py_CPYTHON_BYTEARRAYOBJECT_H +#endif + +#ifdef __cplusplus +} +#endif +#endif /* !Py_BYTEARRAYOBJECT_H */ diff --git a/.ci/python_dependencies_wins/include/bytesobject.h b/.ci/python_dependencies_wins/include/bytesobject.h new file mode 100644 index 00000000..373ee9a5 --- /dev/null +++ b/.ci/python_dependencies_wins/include/bytesobject.h @@ -0,0 +1,69 @@ + +/* Bytes object interface */ + +#ifndef Py_BYTESOBJECT_H +#define Py_BYTESOBJECT_H +#ifdef __cplusplus +extern "C" { +#endif + +#include + +/* +Type PyBytesObject represents a byte 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 bytes objects, to test +an object for bytes-ness, and to get the +byte 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 NULL pointer. +*/ + +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_IS_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 *); +PyAPI_FUNC(PyObject *) PyBytes_DecodeEscape(const char *, Py_ssize_t, + const char *, Py_ssize_t, + const char *); + +/* Provides access to the internal data buffer and size of a bytes object. + Passing NULL as len parameter will force the string buffer to be + 0-terminated (passing a string with embedded NUL characters will + cause an exception). */ +PyAPI_FUNC(int) PyBytes_AsStringAndSize( + PyObject *obj, /* bytes object */ + char **s, /* pointer to buffer variable */ + Py_ssize_t *len /* pointer to length variable or NULL */ + ); + +#ifndef Py_LIMITED_API +# define Py_CPYTHON_BYTESOBJECT_H +# include "cpython/bytesobject.h" +# undef Py_CPYTHON_BYTESOBJECT_H +#endif + +#ifdef __cplusplus +} +#endif +#endif /* !Py_BYTESOBJECT_H */ diff --git a/.ci/python_dependencies_wins/include/cellobject.h b/.ci/python_dependencies_wins/include/cellobject.h new file mode 100644 index 00000000..9411eb42 --- /dev/null +++ b/.ci/python_dependencies_wins/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_IS_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) ((void)(((PyCellObject *)(op))->ob_ref = v)) + +#ifdef __cplusplus +} +#endif +#endif /* !Py_TUPLEOBJECT_H */ +#endif /* Py_LIMITED_API */ diff --git a/.ci/python_dependencies_wins/include/ceval.h b/.ci/python_dependencies_wins/include/ceval.h new file mode 100644 index 00000000..b2a14cee --- /dev/null +++ b/.ci/python_dependencies_wins/include/ceval.h @@ -0,0 +1,158 @@ +#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 deprecated. Since they are officially part of the + * stable ABI (PEP 384), they must be kept for backward compatibility. + * PyObject_Call(), PyObject_CallFunction() and PyObject_CallMethod() are + * recommended to call a callable object. + */ + +Py_DEPRECATED(3.9) PyAPI_FUNC(PyObject *) PyEval_CallObjectWithKeywords( + PyObject *callable, + PyObject *args, + PyObject *kwargs); + +/* Deprecated since PyEval_CallObjectWithKeywords is deprecated */ +#define PyEval_CallObject(callable, arg) \ + PyEval_CallObjectWithKeywords(callable, arg, (PyObject *)NULL) + +Py_DEPRECATED(3.9) PyAPI_FUNC(PyObject *) PyEval_CallFunction( + PyObject *callable, const char *format, ...); +Py_DEPRECATED(3.9) PyAPI_FUNC(PyObject *) PyEval_CallMethod( + PyObject *obj, const char *name, const char *format, ...); + +PyAPI_FUNC(PyObject *) PyEval_GetBuiltins(void); +PyAPI_FUNC(PyObject *) PyEval_GetGlobals(void); +PyAPI_FUNC(PyObject *) PyEval_GetLocals(void); +PyAPI_FUNC(PyFrameObject *) PyEval_GetFrame(void); + +PyAPI_FUNC(int) Py_AddPendingCall(int (*func)(void *), void *arg); +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); + +PyAPI_FUNC(int) Py_EnterRecursiveCall(const char *where); +PyAPI_FUNC(void) Py_LeaveRecursiveCall(void); + +PyAPI_FUNC(const char *) PyEval_GetFuncName(PyObject *); +PyAPI_FUNC(const char *) PyEval_GetFuncDesc(PyObject *); + +PyAPI_FUNC(PyObject *) PyEval_EvalFrame(PyFrameObject *); +PyAPI_FUNC(PyObject *) PyEval_EvalFrameEx(PyFrameObject *f, int exc); + +/* 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!!! + + 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 *); + +Py_DEPRECATED(3.9) PyAPI_FUNC(int) PyEval_ThreadsInitialized(void); +Py_DEPRECATED(3.9) PyAPI_FUNC(void) PyEval_InitThreads(void); +/* PyEval_AcquireLock() and PyEval_ReleaseLock() are part of stable ABI. + * They will be removed from this header file in the future version. + * But they will be remained in ABI until Python 4.0. + */ +Py_DEPRECATED(3.2) PyAPI_FUNC(void) PyEval_AcquireLock(void); +Py_DEPRECATED(3.2) PyAPI_FUNC(void) PyEval_ReleaseLock(void); +PyAPI_FUNC(void) PyEval_AcquireThread(PyThreadState *tstate); +PyAPI_FUNC(void) PyEval_ReleaseThread(PyThreadState *tstate); + +#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); \ + } + +/* 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 + +#ifndef Py_LIMITED_API +# define Py_CPYTHON_CEVAL_H +# include "cpython/ceval.h" +# undef Py_CPYTHON_CEVAL_H +#endif + +#ifdef __cplusplus +} +#endif +#endif /* !Py_CEVAL_H */ diff --git a/.ci/python_dependencies_wins/include/classobject.h b/.ci/python_dependencies_wins/include/classobject.h new file mode 100644 index 00000000..5ee99b3b --- /dev/null +++ b/.ci/python_dependencies_wins/include/classobject.h @@ -0,0 +1,57 @@ +/* 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 */ + vectorcallfunc vectorcall; +} PyMethodObject; + +PyAPI_DATA(PyTypeObject) PyMethod_Type; + +#define PyMethod_Check(op) Py_IS_TYPE(op, &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) + +typedef struct { + PyObject_HEAD + PyObject *func; +} PyInstanceMethodObject; + +PyAPI_DATA(PyTypeObject) PyInstanceMethod_Type; + +#define PyInstanceMethod_Check(op) Py_IS_TYPE(op, &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/.ci/python_dependencies_wins/include/code.h b/.ci/python_dependencies_wins/include/code.h new file mode 100644 index 00000000..1f948e52 --- /dev/null +++ b/.ci/python_dependencies_wins/include/code.h @@ -0,0 +1,20 @@ +/* Definitions for bytecode */ + +#ifndef Py_CODE_H +#define Py_CODE_H +#ifdef __cplusplus +extern "C" { +#endif + +typedef struct PyCodeObject PyCodeObject; + +#ifndef Py_LIMITED_API +# define Py_CPYTHON_CODE_H +# include "cpython/code.h" +# undef Py_CPYTHON_CODE_H +#endif + +#ifdef __cplusplus +} +#endif +#endif /* !Py_CODE_H */ diff --git a/.ci/python_dependencies_wins/include/codecs.h b/.ci/python_dependencies_wins/include/codecs.h new file mode 100644 index 00000000..cc2a776d --- /dev/null +++ b/.ci/python_dependencies_wins/include/codecs.h @@ -0,0 +1,248 @@ +#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 + ); + +/* Unregister a codec search function and clear the registry's cache. + If the search function is not registered, do nothing. + Return 0 on success. Raise an exception and return -1 on error. */ + +PyAPI_FUNC(int) PyCodec_Unregister( + 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/.ci/python_dependencies_wins/include/compile.h b/.ci/python_dependencies_wins/include/compile.h new file mode 100644 index 00000000..f33fc539 --- /dev/null +++ b/.ci/python_dependencies_wins/include/compile.h @@ -0,0 +1,25 @@ +#ifndef Py_COMPILE_H +#define Py_COMPILE_H +#ifdef __cplusplus +extern "C" { +#endif + +/* These definitions must match corresponding definitions in graminit.h. */ +#define Py_single_input 256 +#define Py_file_input 257 +#define Py_eval_input 258 +#define Py_func_type_input 345 + +/* This doesn't need to match anything */ +#define Py_fstring_input 800 + +#ifndef Py_LIMITED_API +# define Py_CPYTHON_COMPILE_H +# include "cpython/compile.h" +# undef Py_CPYTHON_COMPILE_H +#endif + +#ifdef __cplusplus +} +#endif +#endif /* !Py_COMPILE_H */ diff --git a/.ci/python_dependencies_wins/include/complexobject.h b/.ci/python_dependencies_wins/include/complexobject.h new file mode 100644 index 00000000..a912a55f --- /dev/null +++ b/.ci/python_dependencies_wins/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_IS_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/.ci/python_dependencies_wins/include/context.h b/.ci/python_dependencies_wins/include/context.h new file mode 100644 index 00000000..e1a0f0fb --- /dev/null +++ b/.ci/python_dependencies_wins/include/context.h @@ -0,0 +1,81 @@ +#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_IS_TYPE(o, &PyContext_Type) +#define PyContextVar_CheckExact(o) Py_IS_TYPE(o, &PyContextVar_Type) +#define PyContextToken_CheckExact(o) Py_IS_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); + + +#endif /* !Py_LIMITED_API */ + +#ifdef __cplusplus +} +#endif +#endif /* !Py_CONTEXT_H */ diff --git a/.ci/python_dependencies_wins/include/cpython/abstract.h b/.ci/python_dependencies_wins/include/cpython/abstract.h new file mode 100644 index 00000000..01afb81a --- /dev/null +++ b/.ci/python_dependencies_wins/include/cpython/abstract.h @@ -0,0 +1,373 @@ +#ifndef Py_CPYTHON_ABSTRACTOBJECT_H +# error "this header file must not be included directly" +#endif + +/* === Object Protocol ================================================== */ + +#ifdef PY_SSIZE_T_CLEAN +# define _PyObject_CallMethodId _PyObject_CallMethodId_SizeT +#endif + +/* 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); + +/* 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_Vectorcall() 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 + +PyAPI_FUNC(PyObject *) _Py_CheckFunctionResult( + PyThreadState *tstate, + PyObject *callable, + PyObject *result, + const char *where); + +/* === Vectorcall protocol (PEP 590) ============================= */ + +/* Call callable using tp_call. Arguments are like PyObject_Vectorcall() + or PyObject_FastCallDict() (both forms are supported), + except that nargs is plainly the number of arguments without flags. */ +PyAPI_FUNC(PyObject *) _PyObject_MakeTpCall( + PyThreadState *tstate, + PyObject *callable, + PyObject *const *args, Py_ssize_t nargs, + PyObject *keywords); + +#define PY_VECTORCALL_ARGUMENTS_OFFSET ((size_t)1 << (8 * sizeof(size_t) - 1)) + +static inline Py_ssize_t +PyVectorcall_NARGS(size_t n) +{ + return n & ~PY_VECTORCALL_ARGUMENTS_OFFSET; +} + +static inline vectorcallfunc +PyVectorcall_Function(PyObject *callable) +{ + PyTypeObject *tp; + Py_ssize_t offset; + vectorcallfunc ptr; + + assert(callable != NULL); + tp = Py_TYPE(callable); + if (!PyType_HasFeature(tp, Py_TPFLAGS_HAVE_VECTORCALL)) { + return NULL; + } + assert(PyCallable_Check(callable)); + offset = tp->tp_vectorcall_offset; + assert(offset > 0); + memcpy(&ptr, (char *) callable + offset, sizeof(ptr)); + return ptr; +} + +/* Call the callable object 'callable' with the "vectorcall" calling + convention. + + args is a C array for positional arguments. + + nargsf is the number of positional arguments plus optionally the flag + PY_VECTORCALL_ARGUMENTS_OFFSET which means that the caller is allowed to + modify args[-1]. + + kwnames is a tuple of keyword names. The values of the keyword arguments + are stored in "args" after the positional arguments (note that the number + of keyword arguments does not change nargsf). kwnames can also be NULL if + there are no keyword arguments. + + keywords must only contain strings and all keys must be unique. + + Return the result on success. Raise an exception and return NULL on + error. */ +static inline PyObject * +_PyObject_VectorcallTstate(PyThreadState *tstate, PyObject *callable, + PyObject *const *args, size_t nargsf, + PyObject *kwnames) +{ + vectorcallfunc func; + PyObject *res; + + assert(kwnames == NULL || PyTuple_Check(kwnames)); + assert(args != NULL || PyVectorcall_NARGS(nargsf) == 0); + + func = PyVectorcall_Function(callable); + if (func == NULL) { + Py_ssize_t nargs = PyVectorcall_NARGS(nargsf); + return _PyObject_MakeTpCall(tstate, callable, args, nargs, kwnames); + } + res = func(callable, args, nargsf, kwnames); + return _Py_CheckFunctionResult(tstate, callable, res, NULL); +} + +static inline PyObject * +PyObject_Vectorcall(PyObject *callable, PyObject *const *args, + size_t nargsf, PyObject *kwnames) +{ + PyThreadState *tstate = PyThreadState_Get(); + return _PyObject_VectorcallTstate(tstate, callable, + args, nargsf, kwnames); +} + +// Backwards compatibility aliases for API that was provisional in Python 3.8 +#define _PyObject_Vectorcall PyObject_Vectorcall +#define _PyObject_VectorcallMethod PyObject_VectorcallMethod +#define _PyObject_FastCallDict PyObject_VectorcallDict +#define _PyVectorcall_Function PyVectorcall_Function +#define _PyObject_CallOneArg PyObject_CallOneArg +#define _PyObject_CallMethodNoArgs PyObject_CallMethodNoArgs +#define _PyObject_CallMethodOneArg PyObject_CallMethodOneArg + +/* Same as PyObject_Vectorcall except that keyword arguments are passed as + dict, which may be NULL if there are no keyword arguments. */ +PyAPI_FUNC(PyObject *) PyObject_VectorcallDict( + PyObject *callable, + PyObject *const *args, + size_t nargsf, + PyObject *kwargs); + +/* Call "callable" (which must support vectorcall) with positional arguments + "tuple" and keyword arguments "dict". "dict" may also be NULL */ +PyAPI_FUNC(PyObject *) PyVectorcall_Call(PyObject *callable, PyObject *tuple, PyObject *dict); + +static inline PyObject * +_PyObject_FastCallTstate(PyThreadState *tstate, PyObject *func, PyObject *const *args, Py_ssize_t nargs) +{ + return _PyObject_VectorcallTstate(tstate, func, args, (size_t)nargs, NULL); +} + +/* Same as PyObject_Vectorcall except without keyword arguments */ +static inline PyObject * +_PyObject_FastCall(PyObject *func, PyObject *const *args, Py_ssize_t nargs) +{ + PyThreadState *tstate = PyThreadState_Get(); + return _PyObject_FastCallTstate(tstate, func, args, nargs); +} + +/* Call a callable without any arguments + Private static inline function variant of public function + PyObject_CallNoArgs(). */ +static inline PyObject * +_PyObject_CallNoArg(PyObject *func) { + PyThreadState *tstate = PyThreadState_Get(); + return _PyObject_VectorcallTstate(tstate, func, NULL, 0, NULL); +} + +static inline PyObject * +PyObject_CallOneArg(PyObject *func, PyObject *arg) +{ + PyObject *_args[2]; + PyObject **args; + PyThreadState *tstate; + size_t nargsf; + + assert(arg != NULL); + args = _args + 1; // For PY_VECTORCALL_ARGUMENTS_OFFSET + args[0] = arg; + tstate = PyThreadState_Get(); + nargsf = 1 | PY_VECTORCALL_ARGUMENTS_OFFSET; + return _PyObject_VectorcallTstate(tstate, func, args, nargsf, NULL); +} + +PyAPI_FUNC(PyObject *) PyObject_VectorcallMethod( + PyObject *name, PyObject *const *args, + size_t nargsf, PyObject *kwnames); + +static inline PyObject * +PyObject_CallMethodNoArgs(PyObject *self, PyObject *name) +{ + return PyObject_VectorcallMethod(name, &self, + 1 | PY_VECTORCALL_ARGUMENTS_OFFSET, NULL); +} + +static inline PyObject * +PyObject_CallMethodOneArg(PyObject *self, PyObject *name, PyObject *arg) +{ + PyObject *args[2] = {self, arg}; + + assert(arg != NULL); + return PyObject_VectorcallMethod(name, args, + 2 | PY_VECTORCALL_ARGUMENTS_OFFSET, NULL); +} + +/* 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, ...); + +PyAPI_FUNC(PyObject *) _PyObject_CallMethodId_SizeT(PyObject *obj, + _Py_Identifier *name, + const char *format, + ...); + +PyAPI_FUNC(PyObject *) _PyObject_CallMethodIdObjArgs( + PyObject *obj, + struct _Py_Identifier *name, + ...); + +static inline PyObject * +_PyObject_VectorcallMethodId( + _Py_Identifier *name, PyObject *const *args, + size_t nargsf, PyObject *kwnames) +{ + PyObject *oname = _PyUnicode_FromId(name); /* borrowed */ + if (!oname) { + return NULL; + } + return PyObject_VectorcallMethod(oname, args, nargsf, kwnames); +} + +static inline PyObject * +_PyObject_CallMethodIdNoArgs(PyObject *self, _Py_Identifier *name) +{ + return _PyObject_VectorcallMethodId(name, &self, + 1 | PY_VECTORCALL_ARGUMENTS_OFFSET, NULL); +} + +static inline PyObject * +_PyObject_CallMethodIdOneArg(PyObject *self, _Py_Identifier *name, PyObject *arg) +{ + PyObject *args[2] = {self, arg}; + + assert(arg != NULL); + return _PyObject_VectorcallMethodId(name, args, + 2 | PY_VECTORCALL_ARGUMENTS_OFFSET, NULL); +} + +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); + +/* === New Buffer API ============================================ */ + +/* Return 1 if the getbuffer function is available, otherwise return 0. */ +PyAPI_FUNC(int) PyObject_CheckBuffer(PyObject *obj); + +/* 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(Py_ssize_t) PyBuffer_SizeFromFormat(const char *format); + +/* 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); + +/* === Sequence protocol ================================================ */ + +/* 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) ) + +#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); + +/* === Mapping protocol ================================================= */ + +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 *); + +/* Same as PyNumber_Index but can return an instance of a subclass of int. */ +PyAPI_FUNC(PyObject *) _PyNumber_Index(PyObject *o); diff --git a/.ci/python_dependencies_wins/include/cpython/bytearrayobject.h b/.ci/python_dependencies_wins/include/cpython/bytearrayobject.h new file mode 100644 index 00000000..061de138 --- /dev/null +++ b/.ci/python_dependencies_wins/include/cpython/bytearrayobject.h @@ -0,0 +1,20 @@ +#ifndef Py_CPYTHON_BYTEARRAYOBJECT_H +# error "this header file must not be included directly" +#endif + +/* Object layout */ +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 */ + Py_ssize_t ob_exports; /* How many buffer exports */ +} PyByteArrayObject; + +/* Macros, trading safety for speed */ +#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[]; diff --git a/.ci/python_dependencies_wins/include/cpython/bytesobject.h b/.ci/python_dependencies_wins/include/cpython/bytesobject.h new file mode 100644 index 00000000..b134904e --- /dev/null +++ b/.ci/python_dependencies_wins/include/cpython/bytesobject.h @@ -0,0 +1,118 @@ +#ifndef Py_CPYTHON_BYTESOBJECT_H +# error "this header file must not be included directly" +#endif + +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 byte string or -1 if not computed yet. + */ +} PyBytesObject; + +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); + +/* Helper for PyBytes_DecodeEscape that detects invalid escape chars. */ +PyAPI_FUNC(PyObject *) _PyBytes_DecodeEscape(const char *, Py_ssize_t, + const char *, const char **); + +/* Macro, trading safety for speed */ +#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)) + +/* _PyBytes_Join(sep, x) is like sep.join(x). sep must be PyBytesObject*, + x must be an iterable object. */ +PyAPI_FUNC(PyObject *) _PyBytes_Join(PyObject *sep, PyObject *x); + + +/* 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); diff --git a/.ci/python_dependencies_wins/include/cpython/ceval.h b/.ci/python_dependencies_wins/include/cpython/ceval.h new file mode 100644 index 00000000..bd996113 --- /dev/null +++ b/.ci/python_dependencies_wins/include/cpython/ceval.h @@ -0,0 +1,30 @@ +#ifndef Py_CPYTHON_CEVAL_H +# error "this header file must not be included directly" +#endif + +PyAPI_FUNC(void) PyEval_SetProfile(Py_tracefunc, PyObject *); +PyAPI_DATA(int) _PyEval_SetProfile(PyThreadState *tstate, Py_tracefunc func, PyObject *arg); +PyAPI_FUNC(void) PyEval_SetTrace(Py_tracefunc, PyObject *); +PyAPI_FUNC(int) _PyEval_SetTrace(PyThreadState *tstate, Py_tracefunc func, PyObject *arg); +PyAPI_FUNC(int) _PyEval_GetCoroutineOriginTrackingDepth(void); +PyAPI_FUNC(int) _PyEval_SetAsyncGenFirstiter(PyObject *); +PyAPI_FUNC(PyObject *) _PyEval_GetAsyncGenFirstiter(void); +PyAPI_FUNC(int) _PyEval_SetAsyncGenFinalizer(PyObject *); +PyAPI_FUNC(PyObject *) _PyEval_GetAsyncGenFinalizer(void); + +/* 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); + +PyAPI_FUNC(PyObject *) _PyEval_EvalFrameDefault(PyThreadState *tstate, PyFrameObject *f, int exc); + +PyAPI_FUNC(void) _PyEval_SetSwitchInterval(unsigned long microseconds); +PyAPI_FUNC(unsigned long) _PyEval_GetSwitchInterval(void); + +PyAPI_FUNC(Py_ssize_t) _PyEval_RequestCodeExtraIndex(freefunc); + +PyAPI_FUNC(int) _PyEval_SliceIndex(PyObject *, Py_ssize_t *); +PyAPI_FUNC(int) _PyEval_SliceIndexNotNone(PyObject *, Py_ssize_t *); diff --git a/.ci/python_dependencies_wins/include/cpython/code.h b/.ci/python_dependencies_wins/include/cpython/code.h new file mode 100644 index 00000000..1381564b --- /dev/null +++ b/.ci/python_dependencies_wins/include/cpython/code.h @@ -0,0 +1,184 @@ +#ifndef Py_CPYTHON_CODE_H +# error "this header file must not be included directly" +#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 + +typedef struct _PyOpcache _PyOpcache; + +/* Bytecode object */ +struct PyCodeObject { + PyObject_HEAD + int co_argcount; /* #arguments, except *args */ + int co_posonlyargcount; /* #positional only arguments */ + 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_linetable; /* 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; + + /* Per opcodes just-in-time cache + * + * To reduce cache size, we use indirect mapping from opcode index to + * cache object: + * cache = co_opcache[co_opcache_map[next_instr - first_instr] - 1] + */ + + // co_opcache_map is indexed by (next_instr - first_instr). + // * 0 means there is no cache for this opcode. + // * n > 0 means there is cache in co_opcache[n-1]. + unsigned char *co_opcache_map; + _PyOpcache *co_opcache; + int co_opcache_flag; // used to determine when create a cache. + unsigned char co_opcache_size; // length of co_opcache. +}; + +/* 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 + +/* bpo-39562: These constant values are changed in Python 3.9 + to prevent collision with compiler flags. CO_FUTURE_ and PyCF_ + constants must be kept unique. PyCF_ constants can use bits from + 0x0100 to 0x10000. CO_FUTURE_ constants use bits starting at 0x20000. */ +#define CO_FUTURE_DIVISION 0x20000 +#define CO_FUTURE_ABSOLUTE_IMPORT 0x40000 /* do absolute imports by default */ +#define CO_FUTURE_WITH_STATEMENT 0x80000 +#define CO_FUTURE_PRINT_FUNCTION 0x100000 +#define CO_FUTURE_UNICODE_LITERALS 0x200000 + +#define CO_FUTURE_BARRY_AS_BDFL 0x400000 +#define CO_FUTURE_GENERATOR_STOP 0x800000 +#define CO_FUTURE_ANNOTATIONS 0x1000000 + +/* 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_IS_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 *); + +PyAPI_FUNC(PyCodeObject *) PyCode_NewWithPosOnlyArgs( + int, 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 */ +struct _opaque { + int computed_line; + const char *lo_next; + const char *limit; +}; + +typedef struct _line_offsets { + int ar_start; + int ar_end; + int ar_line; + struct _opaque opaque; +} PyCodeAddressRange; + +/* 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(int lasti, PyCodeAddressRange *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); + +PyAPI_FUNC(PyObject*) PyCode_Optimize(PyObject *code, PyObject* consts, + PyObject *names, PyObject *lnotab); + + +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); + +/** API for initializing the line number table. */ +int _PyCode_InitAddressRange(PyCodeObject* co, PyCodeAddressRange *bounds); + +/** Out of process API for initializing the line number table. */ +void PyLineTable_InitAddressRange(const char *linetable, Py_ssize_t length, int firstlineno, PyCodeAddressRange *range); + +/** API for traversing the line number table. */ +int PyLineTable_NextAddressRange(PyCodeAddressRange *range); +int PyLineTable_PreviousAddressRange(PyCodeAddressRange *range); + + diff --git a/.ci/python_dependencies_wins/include/cpython/compile.h b/.ci/python_dependencies_wins/include/cpython/compile.h new file mode 100644 index 00000000..7cfbe715 --- /dev/null +++ b/.ci/python_dependencies_wins/include/cpython/compile.h @@ -0,0 +1,54 @@ +#ifndef Py_CPYTHON_COMPILE_H +# error "this header file must not be included directly" +#endif + +/* Public interface */ +#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) + +/* bpo-39562: CO_FUTURE_ and PyCF_ constants must be kept unique. + PyCF_ constants can use bits from 0x0100 to 0x10000. + CO_FUTURE_ constants use bits starting at 0x20000. */ +#define PyCF_SOURCE_IS_UTF8 0x0100 +#define PyCF_DONT_IMPLY_DEDENT 0x0200 +#define PyCF_ONLY_AST 0x0400 +#define PyCF_IGNORE_COOKIE 0x0800 +#define PyCF_TYPE_COMMENTS 0x1000 +#define PyCF_ALLOW_TOP_LEVEL_AWAIT 0x2000 +#define PyCF_ALLOW_INCOMPLETE_INPUT 0x4000 +#define PyCF_COMPILE_MASK (PyCF_ONLY_AST | PyCF_ALLOW_TOP_LEVEL_AWAIT | \ + PyCF_TYPE_COMMENTS | PyCF_DONT_IMPLY_DEDENT | \ + PyCF_ALLOW_INCOMPLETE_INPUT) + +typedef struct { + int cf_flags; /* bitmask of CO_xxx flags relevant to future */ + int cf_feature_version; /* minor Python version (PyCF_ONLY_AST) */ +} PyCompilerFlags; + +#define _PyCompilerFlags_INIT \ + (PyCompilerFlags){.cf_flags = 0, .cf_feature_version = PY_MINOR_VERSION} + +/* 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" + +#define PY_INVALID_STACK_EFFECT INT_MAX +PyAPI_FUNC(int) PyCompile_OpcodeStackEffect(int opcode, int oparg); +PyAPI_FUNC(int) PyCompile_OpcodeStackEffectWithJump(int opcode, int oparg, int jump); diff --git a/.ci/python_dependencies_wins/include/cpython/dictobject.h b/.ci/python_dependencies_wins/include/cpython/dictobject.h new file mode 100644 index 00000000..1888dd81 --- /dev/null +++ b/.ci/python_dependencies_wins/include/cpython/dictobject.h @@ -0,0 +1,84 @@ +#ifndef Py_CPYTHON_DICTOBJECT_H +# error "this header file must not be included directly" +#endif + +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 split: + keys are stored in ma_keys and values are stored in ma_values */ + PyObject **ma_values; +} PyDictObject; + +PyAPI_FUNC(PyObject *) _PyDict_GetItem_KnownHash(PyObject *mp, PyObject *key, + Py_hash_t hash); +PyAPI_FUNC(PyObject *) _PyDict_GetItemIdWithError(PyObject *dp, + struct _Py_Identifier *key); +PyAPI_FUNC(PyObject *) _PyDict_GetItemStringWithError(PyObject *, const char *); +PyAPI_FUNC(PyObject *) PyDict_SetDefault( + PyObject *mp, PyObject *key, PyObject *defaultobj); +PyAPI_FUNC(int) _PyDict_SetItem_KnownHash(PyObject *mp, PyObject *key, + PyObject *item, Py_hash_t hash); +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)); +PyDictKeysObject *_PyDict_NewKeysForClass(void); +PyAPI_FUNC(int) _PyDict_Next( + PyObject *mp, Py_ssize_t *pos, PyObject **key, PyObject **value, Py_hash_t *hash); + +/* 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_KnownHash(PyObject *, PyObject *, Py_hash_t); +PyAPI_FUNC(int) _PyDict_ContainsId(PyObject *, struct _Py_Identifier *); +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) + +/* 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(int) _PyDict_SetItemId(PyObject *dp, struct _Py_Identifier *key, PyObject *item); + +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 *); +Py_ssize_t _PyDict_GetItemHint(PyDictObject *, PyObject *, Py_ssize_t, PyObject **); + +/* _PyDictView */ + +typedef struct { + PyObject_HEAD + PyDictObject *dv_dict; +} _PyDictViewObject; + +PyAPI_FUNC(PyObject *) _PyDictView_New(PyObject *, PyTypeObject *); +PyAPI_FUNC(PyObject *) _PyDictView_Intersect(PyObject* self, PyObject *other); diff --git a/.ci/python_dependencies_wins/include/cpython/fileobject.h b/.ci/python_dependencies_wins/include/cpython/fileobject.h new file mode 100644 index 00000000..e077bb3f --- /dev/null +++ b/.ci/python_dependencies_wins/include/cpython/fileobject.h @@ -0,0 +1,18 @@ +#ifndef Py_CPYTHON_FILEOBJECT_H +# error "this header file must not be included directly" +#endif + +PyAPI_FUNC(char *) Py_UniversalNewlineFgets(char *, int, FILE*, PyObject *); + +/* The std printer acts as a preliminary sys.stderr until the new io + infrastructure is in place. */ +PyAPI_FUNC(PyObject *) PyFile_NewStdPrinter(int); +PyAPI_DATA(PyTypeObject) PyStdPrinter_Type; + +typedef PyObject * (*Py_OpenCodeHookFunction)(PyObject *, void *); + +PyAPI_FUNC(PyObject *) PyFile_OpenCode(const char *utf8path); +PyAPI_FUNC(PyObject *) PyFile_OpenCodeObject(PyObject *path); +PyAPI_FUNC(int) PyFile_SetOpenCodeHook(Py_OpenCodeHookFunction hook, void *userData); + +PyAPI_FUNC(int) _PyLong_FileDescriptor_Converter(PyObject *, void *); diff --git a/.ci/python_dependencies_wins/include/cpython/fileutils.h b/.ci/python_dependencies_wins/include/cpython/fileutils.h new file mode 100644 index 00000000..7d10f615 --- /dev/null +++ b/.ci/python_dependencies_wins/include/cpython/fileutils.h @@ -0,0 +1,172 @@ +#ifndef Py_CPYTHON_FILEUTILS_H +# error "this header file must not be included directly" +#endif + +typedef enum { + _Py_ERROR_UNKNOWN=0, + _Py_ERROR_STRICT, + _Py_ERROR_SURROGATEESCAPE, + _Py_ERROR_REPLACE, + _Py_ERROR_IGNORE, + _Py_ERROR_BACKSLASHREPLACE, + _Py_ERROR_SURROGATEPASS, + _Py_ERROR_XMLCHARREFREPLACE, + _Py_ERROR_OTHER +} _Py_error_handler; + +PyAPI_FUNC(_Py_error_handler) _Py_GetErrorHandler(const char *errors); + +PyAPI_FUNC(int) _Py_DecodeLocaleEx( + const char *arg, + wchar_t **wstr, + size_t *wlen, + const char **reason, + int current_locale, + _Py_error_handler errors); + +PyAPI_FUNC(int) _Py_EncodeLocaleEx( + const wchar_t *text, + char **str, + size_t *error_pos, + const char **reason, + int current_locale, + _Py_error_handler errors); + +PyAPI_FUNC(char*) _Py_EncodeLocaleRaw( + const wchar_t *text, + size_t *error_pos); + +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; + unsigned long st_reparse_tag; +}; +#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_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, + /* Number of characters of 'buf' buffer + including the trailing NUL character */ + size_t buflen); +#endif + +#ifdef HAVE_REALPATH +PyAPI_FUNC(wchar_t*) _Py_wrealpath( + const wchar_t *path, + wchar_t *resolved_path, + /* Number of characters of 'resolved_path' buffer + including the trailing NUL character */ + size_t resolved_path_len); +#endif + +#ifndef MS_WINDOWS +PyAPI_FUNC(int) _Py_isabs(const wchar_t *path); +#endif + +PyAPI_FUNC(int) _Py_abspath(const wchar_t *path, wchar_t **abspath_p); + +PyAPI_FUNC(wchar_t*) _Py_wgetcwd( + wchar_t *buf, + /* Number of characters of 'buf' buffer + including the trailing NUL character */ + size_t buflen); + +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); +#else /* MS_WINDOWS */ +PyAPI_FUNC(void*) _Py_get_osfhandle_noraise(int fd); + +PyAPI_FUNC(void*) _Py_get_osfhandle(int fd); + +PyAPI_FUNC(int) _Py_open_osfhandle_noraise(void *handle, int flags); + +PyAPI_FUNC(int) _Py_open_osfhandle(void *handle, int flags); +#endif /* MS_WINDOWS */ diff --git a/.ci/python_dependencies_wins/include/cpython/frameobject.h b/.ci/python_dependencies_wins/include/cpython/frameobject.h new file mode 100644 index 00000000..4e568da2 --- /dev/null +++ b/.ci/python_dependencies_wins/include/cpython/frameobject.h @@ -0,0 +1,94 @@ +/* Frame object interface */ + +#ifndef Py_CPYTHON_FRAMEOBJECT_H +# error "this header file must not be included directly" +#endif + +/* These values are chosen so that the inline functions below all + * compare f_state to zero. + */ +enum _framestate { + FRAME_CREATED = -2, + FRAME_SUSPENDED = -1, + FRAME_EXECUTING = 0, + FRAME_RETURNED = 1, + FRAME_UNWINDING = 2, + FRAME_RAISED = 3, + FRAME_CLEARED = 4 +}; + +typedef signed char PyFrameState; + +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; + +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 */ + PyObject *f_trace; /* Trace function */ + int f_stackdepth; /* Depth of value stack */ + 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 */ + int f_lineno; /* Current line number. Only valid if non-zero */ + int f_iblock; /* index in f_blockstack */ + PyFrameState f_state; /* What state the frame is in */ + PyTryBlock f_blockstack[CO_MAXBLOCKS]; /* for try and loop blocks */ + PyObject *f_localsplus[1]; /* locals+stack, dynamically sized */ +}; + +static inline int _PyFrame_IsRunnable(struct _frame *f) { + return f->f_state < FRAME_EXECUTING; +} + +static inline int _PyFrame_IsExecuting(struct _frame *f) { + return f->f_state == FRAME_EXECUTING; +} + +static inline int _PyFrameHasCompleted(struct _frame *f) { + return f->f_state > FRAME_EXECUTING; +} + +/* Standard object interface */ + +PyAPI_DATA(PyTypeObject) PyFrame_Type; + +#define PyFrame_Check(op) Py_IS_TYPE(op, &PyFrame_Type) + +PyAPI_FUNC(PyFrameObject *) PyFrame_New(PyThreadState *, PyCodeObject *, + PyObject *, PyObject *); + +/* only internal use */ +PyFrameObject* +_PyFrame_New_NoTrack(PyThreadState *, PyFrameConstructor *, 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 *); + +/* 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(void) _PyFrame_DebugMallocStats(FILE *out); + +PyAPI_FUNC(PyFrameObject *) PyFrame_GetBack(PyFrameObject *frame); diff --git a/.ci/python_dependencies_wins/include/cpython/import.h b/.ci/python_dependencies_wins/include/cpython/import.h new file mode 100644 index 00000000..092fe466 --- /dev/null +++ b/.ci/python_dependencies_wins/include/cpython/import.h @@ -0,0 +1,46 @@ +#ifndef Py_CPYTHON_IMPORT_H +# error "this header file must not be included directly" +#endif + +PyMODINIT_FUNC PyInit__imp(void); + +PyAPI_FUNC(int) _PyImport_IsInitialized(PyInterpreterState *); + +PyAPI_FUNC(PyObject *) _PyImport_GetModuleId(struct _Py_Identifier *name); +PyAPI_FUNC(int) _PyImport_SetModule(PyObject *name, PyObject *module); +PyAPI_FUNC(int) _PyImport_SetModuleString(const char *name, PyObject* module); + +PyAPI_FUNC(void) _PyImport_AcquireLock(void); +PyAPI_FUNC(int) _PyImport_ReleaseLock(void); + +/* Obsolete since 3.5, will be removed in 3.11. */ +Py_DEPRECATED(3.10) PyAPI_FUNC(PyObject *) _PyImport_FindExtensionObject(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); + +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; + +PyAPI_DATA(PyObject *) _PyImport_GetModuleAttr(PyObject *, PyObject *); +PyAPI_DATA(PyObject *) _PyImport_GetModuleAttrString(const char *, const char *); diff --git a/.ci/python_dependencies_wins/include/cpython/initconfig.h b/.ci/python_dependencies_wins/include/cpython/initconfig.h new file mode 100644 index 00000000..06c12ca1 --- /dev/null +++ b/.ci/python_dependencies_wins/include/cpython/initconfig.h @@ -0,0 +1,249 @@ +#ifndef Py_PYCORECONFIG_H +#define Py_PYCORECONFIG_H +#ifndef Py_LIMITED_API +#ifdef __cplusplus +extern "C" { +#endif + +/* --- PyStatus ----------------------------------------------- */ + +typedef struct { + enum { + _PyStatus_TYPE_OK=0, + _PyStatus_TYPE_ERROR=1, + _PyStatus_TYPE_EXIT=2 + } _type; + const char *func; + const char *err_msg; + int exitcode; +} PyStatus; + +PyAPI_FUNC(PyStatus) PyStatus_Ok(void); +PyAPI_FUNC(PyStatus) PyStatus_Error(const char *err_msg); +PyAPI_FUNC(PyStatus) PyStatus_NoMemory(void); +PyAPI_FUNC(PyStatus) PyStatus_Exit(int exitcode); +PyAPI_FUNC(int) PyStatus_IsError(PyStatus err); +PyAPI_FUNC(int) PyStatus_IsExit(PyStatus err); +PyAPI_FUNC(int) PyStatus_Exception(PyStatus err); + +/* --- PyWideStringList ------------------------------------------------ */ + +typedef struct { + /* If length is greater than zero, items must be non-NULL + and all items strings must be non-NULL */ + Py_ssize_t length; + wchar_t **items; +} PyWideStringList; + +PyAPI_FUNC(PyStatus) PyWideStringList_Append(PyWideStringList *list, + const wchar_t *item); +PyAPI_FUNC(PyStatus) PyWideStringList_Insert(PyWideStringList *list, + Py_ssize_t index, + const wchar_t *item); + + +/* --- PyPreConfig ----------------------------------------------- */ + +typedef struct PyPreConfig { + int _config_init; /* _PyConfigInitEnum value */ + + /* Parse Py_PreInitializeFromBytesArgs() arguments? + See PyConfig.parse_argv */ + int parse_argv; + + /* If greater than 0, enable isolated mode: sys.path contains + neither the script's directory nor the user's site-packages directory. + + Set to 1 by the -I command line option. If set to -1 (default), inherit + Py_IsolatedFlag value. */ + int isolated; + + /* If greater than 0: use environment variables. + Set to 0 by -E command line option. If set to -1 (default), it is + set to !Py_IgnoreEnvironmentFlag. */ + int use_environment; + + /* Set the LC_CTYPE locale to the user preferred locale? If equals to 0, + set coerce_c_locale and coerce_c_locale_warn to 0. */ + int configure_locale; + + /* Coerce the LC_CTYPE locale if it's equal to "C"? (PEP 538) + + Set to 0 by PYTHONCOERCECLOCALE=0. Set to 1 by PYTHONCOERCECLOCALE=1. + Set to 2 if the user preferred LC_CTYPE locale is "C". + + If it is equal to 1, LC_CTYPE locale is read to decide if it should be + coerced or not (ex: PYTHONCOERCECLOCALE=1). Internally, it is set to 2 + if the LC_CTYPE locale must be coerced. + + Disable by default (set to 0). Set it to -1 to let Python decide if it + should be enabled or not. */ + int coerce_c_locale; + + /* Emit a warning if the LC_CTYPE locale is coerced? + + Set to 1 by PYTHONCOERCECLOCALE=warn. + + Disable by default (set to 0). Set it to -1 to let Python decide if it + should be enabled or not. */ + int coerce_c_locale_warn; + +#ifdef MS_WINDOWS + /* If greater than 1, use the "mbcs" encoding instead of the UTF-8 + encoding for the filesystem encoding. + + Set to 1 if the PYTHONLEGACYWINDOWSFSENCODING environment variable is + set to a non-empty string. If set to -1 (default), inherit + Py_LegacyWindowsFSEncodingFlag value. + + See PEP 529 for more details. */ + int legacy_windows_fs_encoding; +#endif + + /* Enable UTF-8 mode? (PEP 540) + + Disabled by default (equals to 0). + + Set to 1 by "-X utf8" and "-X utf8=1" command line options. + Set to 1 by PYTHONUTF8=1 environment variable. + + Set to 0 by "-X utf8=0" and PYTHONUTF8=0. + + If equals to -1, it is set to 1 if the LC_CTYPE locale is "C" or + "POSIX", otherwise it is set to 0. Inherit Py_UTF8Mode value value. */ + int utf8_mode; + + /* If non-zero, enable the Python Development Mode. + + Set to 1 by the -X dev command line option. Set by the PYTHONDEVMODE + environment variable. */ + int dev_mode; + + /* Memory allocator: PYTHONMALLOC env var. + See PyMemAllocatorName for valid values. */ + int allocator; +} PyPreConfig; + +PyAPI_FUNC(void) PyPreConfig_InitPythonConfig(PyPreConfig *config); +PyAPI_FUNC(void) PyPreConfig_InitIsolatedConfig(PyPreConfig *config); + + +/* --- PyConfig ---------------------------------------------- */ + +/* This structure is best documented in the Doc/c-api/init_config.rst file. */ +typedef struct PyConfig { + int _config_init; /* _PyConfigInitEnum value */ + + int isolated; + int use_environment; + int dev_mode; + int install_signal_handlers; + int use_hash_seed; + unsigned long hash_seed; + int faulthandler; + int tracemalloc; + int import_time; + int show_ref_count; + int dump_refs; + int malloc_stats; + wchar_t *filesystem_encoding; + wchar_t *filesystem_errors; + wchar_t *pycache_prefix; + int parse_argv; + PyWideStringList orig_argv; + PyWideStringList argv; + PyWideStringList xoptions; + PyWideStringList warnoptions; + int site_import; + int bytes_warning; + int warn_default_encoding; + int inspect; + int interactive; + int optimization_level; + int parser_debug; + int write_bytecode; + int verbose; + int quiet; + int user_site_directory; + int configure_c_stdio; + int buffered_stdio; + wchar_t *stdio_encoding; + wchar_t *stdio_errors; +#ifdef MS_WINDOWS + int legacy_windows_stdio; +#endif + wchar_t *check_hash_pycs_mode; + + /* --- Path configuration inputs ------------ */ + int pathconfig_warnings; + wchar_t *program_name; + wchar_t *pythonpath_env; + wchar_t *home; + wchar_t *platlibdir; + + /* --- Path configuration outputs ----------- */ + int module_search_paths_set; + PyWideStringList module_search_paths; + wchar_t *executable; + wchar_t *base_executable; + wchar_t *prefix; + wchar_t *base_prefix; + wchar_t *exec_prefix; + wchar_t *base_exec_prefix; + + /* --- Parameter only used by Py_Main() ---------- */ + int skip_source_first_line; + wchar_t *run_command; + wchar_t *run_module; + wchar_t *run_filename; + + /* --- Private fields ---------------------------- */ + + // Install importlib? If equals to 0, importlib is not initialized at all. + // Needed by freeze_importlib. + int _install_importlib; + + // If equal to 0, stop Python initialization before the "main" phase. + int _init_main; + + // If non-zero, disallow threads, subprocesses, and fork. + // Default: 0. + int _isolated_interpreter; +} PyConfig; + +PyAPI_FUNC(void) PyConfig_InitPythonConfig(PyConfig *config); +PyAPI_FUNC(void) PyConfig_InitIsolatedConfig(PyConfig *config); +PyAPI_FUNC(void) PyConfig_Clear(PyConfig *); +PyAPI_FUNC(PyStatus) PyConfig_SetString( + PyConfig *config, + wchar_t **config_str, + const wchar_t *str); +PyAPI_FUNC(PyStatus) PyConfig_SetBytesString( + PyConfig *config, + wchar_t **config_str, + const char *str); +PyAPI_FUNC(PyStatus) PyConfig_Read(PyConfig *config); +PyAPI_FUNC(PyStatus) PyConfig_SetBytesArgv( + PyConfig *config, + Py_ssize_t argc, + char * const *argv); +PyAPI_FUNC(PyStatus) PyConfig_SetArgv(PyConfig *config, + Py_ssize_t argc, + wchar_t * const *argv); +PyAPI_FUNC(PyStatus) PyConfig_SetWideStringList(PyConfig *config, + PyWideStringList *list, + Py_ssize_t length, wchar_t **items); + + +/* --- Helper functions --------------------------------------- */ + +/* Get the original command line arguments, before Python modified them. + + See also PyConfig.orig_argv. */ +PyAPI_FUNC(void) Py_GetArgcArgv(int *argc, wchar_t ***argv); + +#ifdef __cplusplus +} +#endif +#endif /* !Py_LIMITED_API */ +#endif /* !Py_PYCORECONFIG_H */ diff --git a/.ci/python_dependencies_wins/include/cpython/interpreteridobject.h b/.ci/python_dependencies_wins/include/cpython/interpreteridobject.h new file mode 100644 index 00000000..8506ce01 --- /dev/null +++ b/.ci/python_dependencies_wins/include/cpython/interpreteridobject.h @@ -0,0 +1,11 @@ +#ifndef Py_CPYTHON_INTERPRETERIDOBJECT_H +# error "this header file must not be included directly" +#endif + +/* Interpreter ID Object */ + +PyAPI_DATA(PyTypeObject) _PyInterpreterID_Type; + +PyAPI_FUNC(PyObject *) _PyInterpreterID_New(int64_t); +PyAPI_FUNC(PyObject *) _PyInterpreterState_GetIDObject(PyInterpreterState *); +PyAPI_FUNC(PyInterpreterState *) _PyInterpreterID_LookUp(PyObject *); diff --git a/.ci/python_dependencies_wins/include/cpython/listobject.h b/.ci/python_dependencies_wins/include/cpython/listobject.h new file mode 100644 index 00000000..ec1441b5 --- /dev/null +++ b/.ci/python_dependencies_wins/include/cpython/listobject.h @@ -0,0 +1,34 @@ +#ifndef Py_CPYTHON_LISTOBJECT_H +# error "this header file must not be included directly" +#endif + +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; + +PyAPI_FUNC(PyObject *) _PyList_Extend(PyListObject *, PyObject *); +PyAPI_FUNC(void) _PyList_DebugMallocStats(FILE *out); + +/* Macro, trading safety for speed */ + +/* Cast argument to PyListObject* type. */ +#define _PyList_CAST(op) (assert(PyList_Check(op)), (PyListObject *)(op)) + +#define PyList_GET_ITEM(op, i) (_PyList_CAST(op)->ob_item[i]) +#define PyList_SET_ITEM(op, i, v) ((void)(_PyList_CAST(op)->ob_item[i] = (v))) +#define PyList_GET_SIZE(op) Py_SIZE(_PyList_CAST(op)) diff --git a/.ci/python_dependencies_wins/include/cpython/methodobject.h b/.ci/python_dependencies_wins/include/cpython/methodobject.h new file mode 100644 index 00000000..a2c4857e --- /dev/null +++ b/.ci/python_dependencies_wins/include/cpython/methodobject.h @@ -0,0 +1,35 @@ +#ifndef Py_CPYTHON_METHODOBJECT_H +# error "this header file must not be included directly" +#endif + +PyAPI_DATA(PyTypeObject) PyCMethod_Type; + +#define PyCMethod_CheckExact(op) Py_IS_TYPE(op, &PyCMethod_Type) +#define PyCMethod_Check(op) PyObject_TypeCheck(op, &PyCMethod_Type) + +/* Macros for direct access to these values. Type checks are *not* + done, so use with care. */ +#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) +#define PyCFunction_GET_CLASS(func) \ + (((PyCFunctionObject *)func) -> m_ml -> ml_flags & METH_METHOD ? \ + ((PyCMethodObject *)func) -> mm_class : NULL) + +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 */ + vectorcallfunc vectorcall; +} PyCFunctionObject; + +typedef struct { + PyCFunctionObject func; + PyTypeObject *mm_class; /* Class that defines this method */ +} PyCMethodObject; diff --git a/.ci/python_dependencies_wins/include/cpython/object.h b/.ci/python_dependencies_wins/include/cpython/object.h new file mode 100644 index 00000000..ef14188c --- /dev/null +++ b/.ci/python_dependencies_wins/include/cpython/object.h @@ -0,0 +1,552 @@ +#ifndef Py_CPYTHON_OBJECT_H +# error "this header file must not be included directly" +#endif + +PyAPI_FUNC(void) _Py_NewReference(PyObject *op); + +#ifdef Py_TRACE_REFS +/* Py_TRACE_REFS is such major surgery that we call external routines. */ +PyAPI_FUNC(void) _Py_ForgetReference(PyObject *); +#endif + +#ifdef Py_REF_DEBUG +PyAPI_FUNC(Py_ssize_t) _Py_GetRefTotal(void); +#endif + + +/********************* 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. + + 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 { + const char* string; + // Index in PyInterpreterState.unicode.ids.array. It is process-wide + // unique and must be initialized to -1. + Py_ssize_t index; +} _Py_Identifier; + +#define _Py_static_string_init(value) { .string = value, .index = -1 } +#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) + +/* 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 *); + +typedef PyObject *(*vectorcallfunc)(PyObject *callable, PyObject *const *args, + size_t nargsf, PyObject *kwnames); + +/* 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 */ + + +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 PySendResult (*sendfunc)(PyObject *iter, PyObject *value, PyObject **result); + +typedef struct { + unaryfunc am_await; + unaryfunc am_aiter; + unaryfunc am_anext; + sendfunc am_send; +} PyAsyncMethods; + +typedef struct { + getbufferproc bf_getbuffer; + releasebufferproc bf_releasebuffer; +} PyBufferProcs; + +/* Allow printfunc in the tp_vectorcall_offset slot for + * backwards-compatibility */ +typedef Py_ssize_t printfunc; + +// If this structure is modified, Doc/includes/typestruct.h should be updated +// as well. +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; + Py_ssize_t tp_vectorcall_offset; + 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; + // Strong reference on a heap type, borrowed reference on a static type + 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; + vectorcallfunc tp_vectorcall; +}; + +/* 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; + PyObject *ht_module; + /* 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)) + +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 *); +PyAPI_FUNC(PyObject *) _PyType_GetDocFromInternalDoc(const char *, const char *); +PyAPI_FUNC(PyObject *) _PyType_GetTextSignatureFromInternalDoc(const char *, const char *); +struct PyModuleDef; +PyAPI_FUNC(PyObject *) _PyType_GetModuleByDef(PyTypeObject *, struct PyModuleDef *); + +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 *); + +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 *); +/* 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(int) _PyObject_GetMethod(PyObject *obj, PyObject *name, PyObject **method); + +PyAPI_FUNC(PyObject **) _PyObject_GetDictPtr(PyObject *); +PyAPI_FUNC(PyObject *) _PyObject_NextNotImplemented(PyObject *); +PyAPI_FUNC(void) PyObject_CallFinalizer(PyObject *); +PyAPI_FUNC(int) PyObject_CallFinalizerFromDealloc(PyObject *); + +/* 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 *); + +PyAPI_FUNC(PyObject *) _PyObject_FunctionStr(PyObject *); + +/* 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_CAST(op); \ + (op) = (op2); \ + Py_DECREF(_py_tmp); \ + } while (0) + +#define Py_XSETREF(op, op2) \ + do { \ + PyObject *_py_tmp = _PyObject_CAST(op); \ + (op) = (op2); \ + Py_XDECREF(_py_tmp); \ + } while (0) + + +PyAPI_DATA(PyTypeObject) _PyNone_Type; +PyAPI_DATA(PyTypeObject) _PyNotImplemented_Type; + +/* Maps Py_LT to Py_GT, ..., Py_GE to Py_LE. + * Defined in object.c. + */ +PyAPI_DATA(int) _Py_SwappedOp[]; + +PyAPI_FUNC(void) +_PyDebugAllocatorStats(FILE *out, const char *block_name, int num_blocks, + size_t sizeof_block); +PyAPI_FUNC(void) +_PyObject_DebugTypeStats(FILE *out); + +/* Define a pair of assertion macros: + _PyObject_ASSERT_FROM(), _PyObject_ASSERT_WITH_MSG() and _PyObject_ASSERT(). + + These work like the regular C assert(), in that they will abort the + process with a message on stderr if the given condition fails to hold, + but compile away to nothing if NDEBUG is defined. + + However, before aborting, Python will also try to call _PyObject_Dump() on + the given object. This may be of use when investigating bugs in which a + particular object is corrupt (e.g. buggy a tp_visit method in an extension + module breaking the garbage collector), to help locate the broken objects. + + The WITH_MSG variant allows you to supply an additional message that Python + will attempt to print to stderr, after the object dump. */ +#ifdef NDEBUG + /* No debugging: compile away the assertions: */ +# define _PyObject_ASSERT_FROM(obj, expr, msg, filename, lineno, func) \ + ((void)0) +#else + /* With debugging: generate checks: */ +# define _PyObject_ASSERT_FROM(obj, expr, msg, filename, lineno, func) \ + ((expr) \ + ? (void)(0) \ + : _PyObject_AssertFailed((obj), Py_STRINGIFY(expr), \ + (msg), (filename), (lineno), (func))) +#endif + +#define _PyObject_ASSERT_WITH_MSG(obj, expr, msg) \ + _PyObject_ASSERT_FROM(obj, expr, msg, __FILE__, __LINE__, __func__) +#define _PyObject_ASSERT(obj, expr) \ + _PyObject_ASSERT_WITH_MSG(obj, expr, NULL) + +#define _PyObject_ASSERT_FAILED_MSG(obj, msg) \ + _PyObject_AssertFailed((obj), NULL, (msg), __FILE__, __LINE__, __func__) + +/* Declare and define _PyObject_AssertFailed() even when NDEBUG is defined, + to avoid causing compiler/linker errors when building extensions without + NDEBUG against a Python built with NDEBUG defined. + + msg, expr and function can be NULL. */ +PyAPI_FUNC(void) _Py_NO_RETURN _PyObject_AssertFailed( + PyObject *obj, + const char *expr, + const char *msg, + const char *file, + int line, + const char *function); + +/* Check if an object is consistent. For example, ensure that the reference + counter is greater than or equal to 1, and ensure that ob_type is not NULL. + + Call _PyObject_AssertFailed() if the object is inconsistent. + + If check_content is zero, only check header fields: reduce the overhead. + + The function always return 1. The return value is just here to be able to + write: + + assert(_PyObject_CheckConsistency(obj, 1)); */ +PyAPI_FUNC(int) _PyObject_CheckConsistency( + PyObject *op, + int check_content); + + +/* 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 overflows, +especially in threads (which typically have less stack space to work with). + +A container object 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_BEGIN(p, mytype_dealloc) + ... The body of the deallocator goes here, including all calls ... + ... to Py_DECREF on contained objects. ... + Py_TRASHCAN_END // there should be no code after this +} + +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_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. + +Since the tp_dealloc of a subclass typically calls the tp_dealloc of the base +class, we need to ensure that the trashcan is only triggered on the tp_dealloc +of the actual class being deallocated. Otherwise we might end up with a +partially-deallocated object. To check this, the tp_dealloc function must be +passed as second argument to Py_TRASHCAN_BEGIN(). +*/ + +/* 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); + +/* This is the old private API, invoked by the macros before 3.9. + Kept for binary compatibility of extensions using the stable ABI. */ +PyAPI_FUNC(void) _PyTrash_thread_deposit_object(PyObject*); +PyAPI_FUNC(void) _PyTrash_thread_destroy_chain(void); + +/* Forward declarations for PyThreadState */ +struct _ts; + +/* Python 3.9 private API, invoked by the macros below. */ +PyAPI_FUNC(int) _PyTrash_begin(struct _ts *tstate, PyObject *op); +PyAPI_FUNC(void) _PyTrash_end(struct _ts *tstate); +/* Python 3.10 private API, invoked by the Py_TRASHCAN_BEGIN(). */ +PyAPI_FUNC(int) _PyTrash_cond(PyObject *op, destructor dealloc); + +#define PyTrash_UNWIND_LEVEL 50 + +#define Py_TRASHCAN_BEGIN_CONDITION(op, cond) \ + do { \ + PyThreadState *_tstate = NULL; \ + /* If "cond" is false, then _tstate remains NULL and the deallocator \ + * is run normally without involving the trashcan */ \ + if (cond) { \ + _tstate = PyThreadState_Get(); \ + if (_PyTrash_begin(_tstate, _PyObject_CAST(op))) { \ + break; \ + } \ + } + /* The body of the deallocator is here. */ +#define Py_TRASHCAN_END \ + if (_tstate) { \ + _PyTrash_end(_tstate); \ + } \ + } while (0); + +#define Py_TRASHCAN_BEGIN(op, dealloc) \ + Py_TRASHCAN_BEGIN_CONDITION(op, \ + _PyTrash_cond(_PyObject_CAST(op), (destructor)dealloc)) + +/* For backwards compatibility, these macros enable the trashcan + * unconditionally */ +#define Py_TRASHCAN_SAFE_BEGIN(op) Py_TRASHCAN_BEGIN_CONDITION(op, 1) +#define Py_TRASHCAN_SAFE_END(op) Py_TRASHCAN_END diff --git a/.ci/python_dependencies_wins/include/cpython/objimpl.h b/.ci/python_dependencies_wins/include/cpython/objimpl.h new file mode 100644 index 00000000..5e9aa203 --- /dev/null +++ b/.ci/python_dependencies_wins/include/cpython/objimpl.h @@ -0,0 +1,100 @@ +#ifndef Py_CPYTHON_OBJIMPL_H +# error "this header file must not be included directly" +#endif + +#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) + + +/* 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. */ + +/* This function returns the number of allocated memory blocks, regardless of size */ +PyAPI_FUNC(Py_ssize_t) _Py_GetAllocatedBlocks(void); + +/* Macros */ +#ifdef WITH_PYMALLOC +PyAPI_FUNC(int) _PyObject_DebugMallocStats(FILE *out); +#endif + + +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); + + +/* Test if an object implements the garbage collector protocol */ +PyAPI_FUNC(int) PyObject_IS_GC(PyObject *obj); + + +/* Code built with Py_BUILD_CORE must include pycore_gc.h instead which + defines a different _PyGC_FINALIZED() macro. */ +#ifndef Py_BUILD_CORE + // Kept for backward compatibility with Python 3.8 +# define _PyGC_FINALIZED(o) PyObject_GC_IsFinalized(o) +#endif + +PyAPI_FUNC(PyObject *) _PyObject_GC_Malloc(size_t size); +PyAPI_FUNC(PyObject *) _PyObject_GC_Calloc(size_t size); + + +/* Test if a type supports weak references */ +#define PyType_SUPPORTS_WEAKREFS(t) ((t)->tp_weaklistoffset > 0) + +PyAPI_FUNC(PyObject **) PyObject_GET_WEAKREFS_LISTPTR(PyObject *op); diff --git a/.ci/python_dependencies_wins/include/cpython/odictobject.h b/.ci/python_dependencies_wins/include/cpython/odictobject.h new file mode 100644 index 00000000..881e7ebc --- /dev/null +++ b/.ci/python_dependencies_wins/include/cpython/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_IS_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_CAST(od), key) +#define PyODict_GetItemWithError(od, key) \ + PyDict_GetItemWithError(_PyObject_CAST(od), key) +#define PyODict_Contains(od, key) PyDict_Contains(_PyObject_CAST(od), key) +#define PyODict_Size(od) PyDict_Size(_PyObject_CAST(od)) +#define PyODict_GetItemString(od, key) \ + PyDict_GetItemString(_PyObject_CAST(od), key) + +#endif + +#ifdef __cplusplus +} +#endif +#endif /* !Py_ODICTOBJECT_H */ diff --git a/.ci/python_dependencies_wins/include/cpython/picklebufobject.h b/.ci/python_dependencies_wins/include/cpython/picklebufobject.h new file mode 100644 index 00000000..5d0b0cfa --- /dev/null +++ b/.ci/python_dependencies_wins/include/cpython/picklebufobject.h @@ -0,0 +1,31 @@ +/* PickleBuffer object. This is built-in for ease of use from third-party + * C extensions. + */ + +#ifndef Py_PICKLEBUFOBJECT_H +#define Py_PICKLEBUFOBJECT_H +#ifdef __cplusplus +extern "C" { +#endif + +#ifndef Py_LIMITED_API + +PyAPI_DATA(PyTypeObject) PyPickleBuffer_Type; + +#define PyPickleBuffer_Check(op) Py_IS_TYPE(op, &PyPickleBuffer_Type) + +/* Create a PickleBuffer redirecting to the given buffer-enabled object */ +PyAPI_FUNC(PyObject *) PyPickleBuffer_FromObject(PyObject *); +/* Get the PickleBuffer's underlying view to the original object + * (NULL if released) + */ +PyAPI_FUNC(const Py_buffer *) PyPickleBuffer_GetBuffer(PyObject *); +/* Release the PickleBuffer. Returns 0 on success, -1 on error. */ +PyAPI_FUNC(int) PyPickleBuffer_Release(PyObject *); + +#endif /* !Py_LIMITED_API */ + +#ifdef __cplusplus +} +#endif +#endif /* !Py_PICKLEBUFOBJECT_H */ diff --git a/.ci/python_dependencies_wins/include/cpython/pyctype.h b/.ci/python_dependencies_wins/include/cpython/pyctype.h new file mode 100644 index 00000000..8f4bd79c --- /dev/null +++ b/.ci/python_dependencies_wins/include/cpython/pyctype.h @@ -0,0 +1,39 @@ +#ifndef Py_LIMITED_API +#ifndef PYCTYPE_H +#define PYCTYPE_H +#ifdef __cplusplus +extern "C" { +#endif + +#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)]) + +#ifdef __cplusplus +} +#endif +#endif /* !PYCTYPE_H */ +#endif /* !Py_LIMITED_API */ diff --git a/.ci/python_dependencies_wins/include/cpython/pydebug.h b/.ci/python_dependencies_wins/include/cpython/pydebug.h new file mode 100644 index 00000000..e34cf907 --- /dev/null +++ b/.ci/python_dependencies_wins/include/cpython/pydebug.h @@ -0,0 +1,38 @@ +#ifndef Py_LIMITED_API +#ifndef Py_PYDEBUG_H +#define Py_PYDEBUG_H +#ifdef __cplusplus +extern "C" { +#endif + +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/.ci/python_dependencies_wins/include/cpython/pyerrors.h b/.ci/python_dependencies_wins/include/cpython/pyerrors.h new file mode 100644 index 00000000..1543cfc3 --- /dev/null +++ b/.ci/python_dependencies_wins/include/cpython/pyerrors.h @@ -0,0 +1,214 @@ +#ifndef Py_CPYTHON_ERRORS_H +# error "this header file must not be included directly" +#endif + +/* Error objects */ + +/* 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 *end_lineno; + PyObject *end_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; + +typedef struct { + PyException_HEAD + PyObject *name; +} PyNameErrorObject; + +typedef struct { + PyException_HEAD + PyObject *obj; + PyObject *name; +} PyAttributeErrorObject; + +/* Compatibility typedefs */ +typedef PyOSErrorObject PyEnvironmentErrorObject; +#ifdef MS_WINDOWS +typedef PyOSErrorObject PyWindowsErrorObject; +#endif + +/* Error handling definitions */ + +PyAPI_FUNC(void) _PyErr_SetKeyError(PyObject *); +PyAPI_FUNC(_PyErr_StackItem*) _PyErr_GetTopmostException(PyThreadState *tstate); +PyAPI_FUNC(void) _PyErr_GetExcInfo(PyThreadState *, PyObject **, PyObject **, PyObject **); + +/* Context manipulation (PEP 3134) */ + +PyAPI_FUNC(void) _PyErr_ChainExceptions(PyObject *, PyObject *, PyObject *); + +/* Convenience functions */ + +#ifdef MS_WINDOWS +Py_DEPRECATED(3.3) +PyAPI_FUNC(PyObject *) PyErr_SetFromErrnoWithUnicodeFilename( + PyObject *, const Py_UNICODE *); +#endif /* MS_WINDOWS */ + +/* Like PyErr_Format(), but saves current exception as __context__ and + __cause__. + */ +PyAPI_FUNC(PyObject *) _PyErr_FormatFromCause( + PyObject *exception, + const char *format, /* ASCII-encoded string */ + ... + ); + +#ifdef MS_WINDOWS +/* XXX redeclare to use WSTRING */ +Py_DEPRECATED(3.3) +PyAPI_FUNC(PyObject *) PyErr_SetFromWindowsErrWithUnicodeFilename( + int, const Py_UNICODE *); +Py_DEPRECATED(3.3) +PyAPI_FUNC(PyObject *) PyErr_SetExcFromWindowsErrWithUnicodeFilename( + PyObject *,int, const Py_UNICODE *); +#endif + +/* In exceptions.c */ + +/* 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 */ + ... + ); + +/* In signalmodule.c */ + +int PySignal_SetWakeupFd(int fd); +PyAPI_FUNC(int) _PyErr_CheckSignals(void); + +/* Support for adding program text to SyntaxErrors */ + +PyAPI_FUNC(void) PyErr_SyntaxLocationObject( + PyObject *filename, + int lineno, + int col_offset); + +PyAPI_FUNC(void) PyErr_RangedSyntaxLocationObject( + PyObject *filename, + int lineno, + int col_offset, + int end_lineno, + int end_col_offset); + +PyAPI_FUNC(PyObject *) PyErr_ProgramTextObject( + PyObject *filename, + int lineno); + +/* Create a UnicodeEncodeError object. + * + * TODO: This API will be removed in Python 3.11. + */ +Py_DEPRECATED(3.3) 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 */ + ); + +/* Create a UnicodeTranslateError object. + * + * TODO: This API will be removed in Python 3.11. + */ +Py_DEPRECATED(3.3) 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 */ + ); + +PyAPI_FUNC(PyObject *) _PyErr_ProgramDecodedTextObject( + PyObject *filename, + int lineno, + const char* encoding); + +PyAPI_FUNC(PyObject *) _PyUnicodeTranslateError_Create( + PyObject *object, + Py_ssize_t start, + Py_ssize_t end, + const char *reason /* UTF-8 encoded string */ + ); + +PyAPI_FUNC(void) _PyErr_WriteUnraisableMsg( + const char *err_msg, + PyObject *obj); + +PyAPI_FUNC(void) _Py_NO_RETURN _Py_FatalErrorFunc( + const char *func, + const char *message); + +PyAPI_FUNC(void) _Py_NO_RETURN _Py_FatalErrorFormat( + const char *func, + const char *format, + ...); + +#define Py_FatalError(message) _Py_FatalErrorFunc(__func__, message) diff --git a/.ci/python_dependencies_wins/include/cpython/pyfpe.h b/.ci/python_dependencies_wins/include/cpython/pyfpe.h new file mode 100644 index 00000000..d5a52617 --- /dev/null +++ b/.ci/python_dependencies_wins/include/cpython/pyfpe.h @@ -0,0 +1,15 @@ +#ifndef Py_PYFPE_H +#define Py_PYFPE_H +/* Header excluded from the stable API */ +#ifndef Py_LIMITED_API + +/* 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 /* !defined(Py_LIMITED_API) */ +#endif /* !Py_PYFPE_H */ diff --git a/.ci/python_dependencies_wins/include/cpython/pylifecycle.h b/.ci/python_dependencies_wins/include/cpython/pylifecycle.h new file mode 100644 index 00000000..5993e6dd --- /dev/null +++ b/.ci/python_dependencies_wins/include/cpython/pylifecycle.h @@ -0,0 +1,64 @@ +#ifndef Py_CPYTHON_PYLIFECYCLE_H +# error "this header file must not be included directly" +#endif + +/* Py_FrozenMain is kept out of the Limited API until documented and present + in all builds of Python */ +PyAPI_FUNC(int) Py_FrozenMain(int argc, char **argv); + +/* 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(PyStatus) Py_PreInitialize( + const PyPreConfig *src_config); +PyAPI_FUNC(PyStatus) Py_PreInitializeFromBytesArgs( + const PyPreConfig *src_config, + Py_ssize_t argc, + char **argv); +PyAPI_FUNC(PyStatus) Py_PreInitializeFromArgs( + const PyPreConfig *src_config, + Py_ssize_t argc, + wchar_t **argv); + +PyAPI_FUNC(int) _Py_IsCoreInitialized(void); + + +/* Initialization and finalization */ + +PyAPI_FUNC(PyStatus) Py_InitializeFromConfig( + const PyConfig *config); +PyAPI_FUNC(PyStatus) _Py_InitializeMain(void); + +PyAPI_FUNC(int) Py_RunMain(void); + + +PyAPI_FUNC(void) _Py_NO_RETURN Py_ExitStatusException(PyStatus err); + +/* Restore signals that the interpreter has called SIG_IGN on to SIG_DFL. */ +PyAPI_FUNC(void) _Py_RestoreSignals(void); + +PyAPI_FUNC(int) Py_FdIsInteractive(FILE *, const char *); +PyAPI_FUNC(int) _Py_FdIsInteractive(FILE *fp, PyObject *filename); + +PyAPI_FUNC(void) _Py_SetProgramFullPath(const wchar_t *); + +PyAPI_FUNC(const char *) _Py_gitidentifier(void); +PyAPI_FUNC(const char *) _Py_gitversion(void); + +PyAPI_FUNC(int) _Py_IsFinalizing(void); + +/* Random */ +PyAPI_FUNC(int) _PyOS_URandom(void *buffer, Py_ssize_t size); +PyAPI_FUNC(int) _PyOS_URandomNonblock(void *buffer, Py_ssize_t size); + +/* Legacy locale support */ +PyAPI_FUNC(int) _Py_CoerceLegacyLocale(int warn); +PyAPI_FUNC(int) _Py_LegacyLocaleDetected(int warn); +PyAPI_FUNC(char *) _Py_SetLocaleFromEnv(int category); + +PyAPI_FUNC(PyThreadState *) _Py_NewInterpreter(int isolated_subinterpreter); diff --git a/.ci/python_dependencies_wins/include/cpython/pymem.h b/.ci/python_dependencies_wins/include/cpython/pymem.h new file mode 100644 index 00000000..9db440d1 --- /dev/null +++ b/.ci/python_dependencies_wins/include/cpython/pymem.h @@ -0,0 +1,98 @@ +#ifndef Py_CPYTHON_PYMEM_H +# error "this header file must not be included directly" +#endif + +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); + +/* Try to get the allocators name set by _PyMem_SetupAllocators(). */ +PyAPI_FUNC(const char*) _PyMem_GetCurrentAllocatorName(void); + +/* 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); + + +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 enum { + PYMEM_ALLOCATOR_NOT_SET = 0, + PYMEM_ALLOCATOR_DEFAULT = 1, + PYMEM_ALLOCATOR_DEBUG = 2, + PYMEM_ALLOCATOR_MALLOC = 3, + PYMEM_ALLOCATOR_MALLOC_DEBUG = 4, +#ifdef WITH_PYMALLOC + PYMEM_ALLOCATOR_PYMALLOC = 5, + PYMEM_ALLOCATOR_PYMALLOC_DEBUG = 6, +#endif +} PyMemAllocatorName; + + +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); diff --git a/.ci/python_dependencies_wins/include/cpython/pystate.h b/.ci/python_dependencies_wins/include/cpython/pystate.h new file mode 100644 index 00000000..06781a16 --- /dev/null +++ b/.ci/python_dependencies_wins/include/cpython/pystate.h @@ -0,0 +1,305 @@ +#ifndef Py_CPYTHON_PYSTATE_H +# error "this header file must not be included directly" +#endif + +PyAPI_FUNC(int) _PyInterpreterState_RequiresIDRef(PyInterpreterState *); +PyAPI_FUNC(void) _PyInterpreterState_RequireIDRef(PyInterpreterState *, int); + +PyAPI_FUNC(PyObject *) _PyInterpreterState_GetMainModule(PyInterpreterState *); + +/* State unique per thread */ + +/* Py_tracefunc return -1 when raising an exception, or 0 for success. */ +typedef int (*Py_tracefunc)(PyObject *, PyFrameObject *, 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 + + +typedef struct _cframe { + /* This struct will be threaded through the C stack + * allowing fast access to per-thread state that needs + * to be accessed quickly by the interpreter, but can + * be modified outside of the interpreter. + * + * WARNING: This makes data on the C stack accessible from + * heap objects. Care must be taken to maintain stack + * discipline and make sure that instances of this struct cannot + * accessed outside of their lifetime. + */ + int use_tracing; + struct _cframe *previous; +} CFrame; + +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; + + +// The PyThreadState typedef is in Include/pystate.h. +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) */ + PyFrameObject *frame; + int recursion_depth; + int recursion_headroom; /* Allow 50 more calls to handle any errors. */ + 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; + + /* Pointer to current CFrame in the C stack frame of the currently, + * or most recently, executing _PyEval_EvalFrameDefault. */ + CFrame *cframe; + + 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 + * _PyRuntime.gilstate.tstate_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 *async_gen_firstiter; + PyObject *async_gen_finalizer; + + PyObject *context; + uint64_t context_ver; + + /* Unique thread state id. */ + uint64_t id; + + CFrame root_cframe; + + /* XXX signal handlers should also be here */ + +}; + +// Alias for backward compatibility with Python 3.8 +#define _PyInterpreterState_Get PyInterpreterState_Get + +PyAPI_FUNC(PyThreadState *) _PyThreadState_Prealloc(PyInterpreterState *); + +/* Similar to PyThreadState_Get(), but don't issue a fatal error + * if it is NULL. */ +PyAPI_FUNC(PyThreadState *) _PyThreadState_UncheckedGet(void); + +PyAPI_FUNC(PyObject *) _PyThreadState_GetDict(PyThreadState *tstate); + +/* PyGILState */ + +/* 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); + +/* Get the single PyInterpreterState used by this process' GILState + implementation. + + This function doesn't check for error. Return NULL before _PyGILState_Init() + is called and after _PyGILState_Fini() is called. + + See also _PyInterpreterState_Get() and _PyInterpreterState_GET(). */ +PyAPI_FUNC(PyInterpreterState *) _PyGILState_GetInterpreterStateUnsafe(void); + +/* The implementation of sys._current_frames() Returns a dict mapping + thread id to that thread's current frame. +*/ +PyAPI_FUNC(PyObject *) _PyThread_CurrentFrames(void); + +/* The implementation of sys._current_exceptions() Returns a dict mapping + thread id to that thread's current exception. +*/ +PyAPI_FUNC(PyObject *) _PyThread_CurrentExceptions(void); + +/* Routines for advanced debuggers, requested by David Beazley. + Don't use unless you know what you are doing! */ +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 *); +PyAPI_FUNC(void) PyThreadState_DeleteCurrent(void); + +/* Frame evaluation API */ + +typedef PyObject* (*_PyFrameEvalFunction)(PyThreadState *tstate, PyFrameObject *, int); + +PyAPI_FUNC(_PyFrameEvalFunction) _PyInterpreterState_GetEvalFrameFunc( + PyInterpreterState *interp); +PyAPI_FUNC(void) _PyInterpreterState_SetEvalFrameFunc( + PyInterpreterState *interp, + _PyFrameEvalFunction eval_frame); + +PyAPI_FUNC(const PyConfig*) _PyInterpreterState_GetConfig(PyInterpreterState *interp); + +/* Get a copy of the current interpreter configuration. + + Return 0 on success. Raise an exception and return -1 on error. + + The caller must initialize 'config', using PyConfig_InitPythonConfig() + for example. + + Python must be preinitialized to call this method. + The caller must hold the GIL. */ +PyAPI_FUNC(int) _PyInterpreterState_GetConfigCopy( + struct PyConfig *config); + +/* Set the configuration of the current interpreter. + + This function should be called during or just after the Python + initialization. + + Update the sys module with the new configuration. If the sys module was + modified directly after the Python initialization, these changes are lost. + + Some configuration like faulthandler or warnoptions can be updated in the + configuration, but don't reconfigure Python (don't enable/disable + faulthandler and don't reconfigure warnings filters). + + Return 0 on success. Raise an exception and return -1 on error. + + The configuration should come from _PyInterpreterState_GetConfigCopy(). */ +PyAPI_FUNC(int) _PyInterpreterState_SetConfig( + const struct PyConfig *config); + +// Get the configuration of the current interpreter. +// The caller must hold the GIL. +PyAPI_FUNC(const PyConfig*) _Py_GetConfig(void); + + +/* cross-interpreter data */ + +struct _xid; + +// _PyCrossInterpreterData is similar to Py_buffer as an effectively +// opaque struct that holds data outside the object machinery. This +// is necessary to pass safely between interpreters in the same process. +typedef struct _xid { + // data is the cross-interpreter-safe derivation of a Python object + // (see _PyObject_GetCrossInterpreterData). It will be NULL if the + // new_object func (below) encodes the data. + void *data; + // obj is the Python object from which the data was derived. This + // is non-NULL only if the data remains bound to the object in some + // way, such that the object must be "released" (via a decref) when + // the data is released. In that case the code that sets the field, + // likely a registered "crossinterpdatafunc", is responsible for + // ensuring it owns the reference (i.e. incref). + PyObject *obj; + // interp is the ID of the owning interpreter of the original + // object. It corresponds to the active interpreter when + // _PyObject_GetCrossInterpreterData() was called. This should only + // be set by the cross-interpreter machinery. + // + // We use the ID rather than the PyInterpreterState to avoid issues + // with deleted interpreters. Note that IDs are never re-used, so + // each one will always correspond to a specific interpreter + // (whether still alive or not). + int64_t interp; + // new_object is a function that returns a new object in the current + // interpreter given the data. The resulting object (a new + // reference) will be equivalent to the original object. This field + // is required. + PyObject *(*new_object)(struct _xid *); + // free is called when the data is released. If it is NULL then + // nothing will be done to free the data. For some types this is + // okay (e.g. bytes) and for those types this field should be set + // to NULL. However, for most the data was allocated just for + // cross-interpreter use, so it must be freed when + // _PyCrossInterpreterData_Release is called or the memory will + // leak. In that case, at the very least this field should be set + // to PyMem_RawFree (the default if not explicitly set to NULL). + // The call will happen with the original interpreter activated. + void (*free)(void *); +} _PyCrossInterpreterData; + +PyAPI_FUNC(int) _PyObject_GetCrossInterpreterData(PyObject *, _PyCrossInterpreterData *); +PyAPI_FUNC(PyObject *) _PyCrossInterpreterData_NewObject(_PyCrossInterpreterData *); +PyAPI_FUNC(void) _PyCrossInterpreterData_Release(_PyCrossInterpreterData *); + +PyAPI_FUNC(int) _PyObject_CheckCrossInterpreterData(PyObject *); + +/* cross-interpreter data registry */ + +typedef int (*crossinterpdatafunc)(PyObject *, struct _xid *); + +PyAPI_FUNC(int) _PyCrossInterpreterData_RegisterClass(PyTypeObject *, crossinterpdatafunc); +PyAPI_FUNC(crossinterpdatafunc) _PyCrossInterpreterData_Lookup(PyObject *); diff --git a/.ci/python_dependencies_wins/include/cpython/pythonrun.h b/.ci/python_dependencies_wins/include/cpython/pythonrun.h new file mode 100644 index 00000000..cf0e6776 --- /dev/null +++ b/.ci/python_dependencies_wins/include/cpython/pythonrun.h @@ -0,0 +1,121 @@ +#ifndef Py_CPYTHON_PYTHONRUN_H +# error "this header file must not be included directly" +#endif + +PyAPI_FUNC(int) PyRun_SimpleStringFlags(const char *, PyCompilerFlags *); +PyAPI_FUNC(int) _PyRun_SimpleFileObject( + FILE *fp, + PyObject *filename, + int closeit, + PyCompilerFlags *flags); +PyAPI_FUNC(int) PyRun_AnyFileExFlags( + FILE *fp, + const char *filename, /* decoded from the filesystem encoding */ + int closeit, + PyCompilerFlags *flags); +PyAPI_FUNC(int) _PyRun_AnyFileObject( + FILE *fp, + PyObject *filename, + 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(int) _PyRun_InteractiveLoopObject( + FILE *fp, + PyObject *filename, + PyCompilerFlags *flags); + + +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); + + +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); + +#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(const char *) _Py_SourceAsString( + PyObject *cmd, + const char *funcname, + const char *what, + PyCompilerFlags *cf, + PyObject **cmd_copy); + + +/* A function flavor is also exported by libpython. It is required when + libpython is accessed directly rather than using header files which defines + macros below. On Windows, for example, PyAPI_FUNC() uses dllexport to + export functions in pythonXX.dll. */ +PyAPI_FUNC(PyObject *) PyRun_String(const char *str, int s, PyObject *g, PyObject *l); +PyAPI_FUNC(int) PyRun_AnyFile(FILE *fp, const char *name); +PyAPI_FUNC(int) PyRun_AnyFileEx(FILE *fp, const char *name, int closeit); +PyAPI_FUNC(int) PyRun_AnyFileFlags(FILE *, const char *, PyCompilerFlags *); +PyAPI_FUNC(int) PyRun_SimpleString(const char *s); +PyAPI_FUNC(int) PyRun_SimpleFile(FILE *f, const char *p); +PyAPI_FUNC(int) PyRun_SimpleFileEx(FILE *f, const char *p, int c); +PyAPI_FUNC(int) PyRun_InteractiveOne(FILE *f, const char *p); +PyAPI_FUNC(int) PyRun_InteractiveLoop(FILE *f, const char *p); +PyAPI_FUNC(PyObject *) PyRun_File(FILE *fp, const char *p, int s, PyObject *g, PyObject *l); +PyAPI_FUNC(PyObject *) PyRun_FileEx(FILE *fp, const char *p, int s, PyObject *g, PyObject *l, int c); +PyAPI_FUNC(PyObject *) PyRun_FileFlags(FILE *fp, const char *p, int s, PyObject *g, PyObject *l, PyCompilerFlags *flags); + +/* 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) + + +/* Stuff with no proper home (yet) */ +PyAPI_FUNC(char *) PyOS_Readline(FILE *, FILE *, const char *); +PyAPI_DATA(PyThreadState*) _PyOS_ReadlineTState; +PyAPI_DATA(char) *(*PyOS_ReadlineFunctionPointer)(FILE *, FILE *, const char *); diff --git a/.ci/python_dependencies_wins/include/cpython/pytime.h b/.ci/python_dependencies_wins/include/cpython/pytime.h new file mode 100644 index 00000000..656fe38f --- /dev/null +++ b/.ci/python_dependencies_wins/include/cpython/pytime.h @@ -0,0 +1,247 @@ +#ifndef Py_LIMITED_API +#ifndef Py_PYTIME_H +#define Py_PYTIME_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 timestamp. + 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 timestamp. + 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); + +/* 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. + + If the internal clock fails, silently ignore the error and return 0. + On integer overflow, silently ignore the overflow and truncated the clock to + _PyTime_MIN or _PyTime_MAX. + + Use _PyTime_GetSystemClockWithInfo() to check for failure. */ +PyAPI_FUNC(_PyTime_t) _PyTime_GetSystemClock(void); + +/* Get the current time from the system clock. + * On success, set *t and *info (if not NULL), and return 0. + * On error, raise an exception and return -1. + */ +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. + + If the internal clock fails, silently ignore the error and return 0. + On integer overflow, silently ignore the overflow and truncated the clock to + _PyTime_MIN or _PyTime_MAX. + + Use _PyTime_GetMonotonicClockWithInfo() to check for failure. */ +PyAPI_FUNC(_PyTime_t) _PyTime_GetMonotonicClock(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. + + 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); + + +/* 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. + + If the internal clock fails, silently ignore the error and return 0. + On integer overflow, silently ignore the overflow and truncated the clock to + _PyTime_MIN or _PyTime_MAX. + + Use _PyTime_GetPerfCounterWithInfo() to check for failure. */ +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/.ci/python_dependencies_wins/include/cpython/sysmodule.h b/.ci/python_dependencies_wins/include/cpython/sysmodule.h new file mode 100644 index 00000000..6aeba9cc --- /dev/null +++ b/.ci/python_dependencies_wins/include/cpython/sysmodule.h @@ -0,0 +1,16 @@ +#ifndef Py_CPYTHON_SYSMODULE_H +# error "this header file must not be included directly" +#endif + +PyAPI_FUNC(PyObject *) _PySys_GetObjectId(_Py_Identifier *key); +PyAPI_FUNC(int) _PySys_SetObjectId(_Py_Identifier *key, PyObject *); + +PyAPI_FUNC(size_t) _PySys_GetSizeOf(PyObject *); + +typedef int(*Py_AuditHookFunction)(const char *, PyObject *, void *); + +PyAPI_FUNC(int) PySys_Audit( + const char *event, + const char *argFormat, + ...); +PyAPI_FUNC(int) PySys_AddAuditHook(Py_AuditHookFunction, void*); diff --git a/.ci/python_dependencies_wins/include/cpython/traceback.h b/.ci/python_dependencies_wins/include/cpython/traceback.h new file mode 100644 index 00000000..665587d1 --- /dev/null +++ b/.ci/python_dependencies_wins/include/cpython/traceback.h @@ -0,0 +1,14 @@ +#ifndef Py_CPYTHON_TRACEBACK_H +# error "this header file must not be included directly" +#endif + +typedef struct _traceback { + PyObject_HEAD + struct _traceback *tb_next; + PyFrameObject *tb_frame; + int tb_lasti; + int tb_lineno; +} PyTracebackObject; + +PyAPI_FUNC(int) _Py_DisplaySourceLine(PyObject *, PyObject *, int, int); +PyAPI_FUNC(void) _PyTraceback_Add(const char *, const char *, int); diff --git a/.ci/python_dependencies_wins/include/cpython/tupleobject.h b/.ci/python_dependencies_wins/include/cpython/tupleobject.h new file mode 100644 index 00000000..141aa0f6 --- /dev/null +++ b/.ci/python_dependencies_wins/include/cpython/tupleobject.h @@ -0,0 +1,28 @@ +#ifndef Py_CPYTHON_TUPLEOBJECT_H +# error "this header file must not be included directly" +#endif + +typedef struct { + PyObject_VAR_HEAD + /* 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. */ + PyObject *ob_item[1]; +} PyTupleObject; + +PyAPI_FUNC(int) _PyTuple_Resize(PyObject **, Py_ssize_t); +PyAPI_FUNC(void) _PyTuple_MaybeUntrack(PyObject *); + +/* Macros trading safety for speed */ + +/* Cast argument to PyTupleObject* type. */ +#define _PyTuple_CAST(op) (assert(PyTuple_Check(op)), (PyTupleObject *)(op)) + +#define PyTuple_GET_SIZE(op) Py_SIZE(_PyTuple_CAST(op)) + +#define PyTuple_GET_ITEM(op, i) (_PyTuple_CAST(op)->ob_item[i]) + +/* Macro, *only* to be used to fill in brand new tuples */ +#define PyTuple_SET_ITEM(op, i, v) ((void)(_PyTuple_CAST(op)->ob_item[i] = v)) + +PyAPI_FUNC(void) _PyTuple_DebugMallocStats(FILE *out); diff --git a/.ci/python_dependencies_wins/include/cpython/unicodeobject.h b/.ci/python_dependencies_wins/include/cpython/unicodeobject.h new file mode 100644 index 00000000..7d00d861 --- /dev/null +++ b/.ci/python_dependencies_wins/include/cpython/unicodeobject.h @@ -0,0 +1,1169 @@ +#ifndef Py_CPYTHON_UNICODEOBJECT_H +# error "this header file must not be included directly" +#endif + +/* 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. */ +#define PY_UNICODE_TYPE wchar_t +/* Py_DEPRECATED(3.3) */ typedef wchar_t Py_UNICODE; + +/* --- Internal Unicode Operations ---------------------------------------- */ + +#ifndef USE_UNICODE_WCHAR_CACHE +# define USE_UNICODE_WCHAR_CACHE 1 +#endif /* USE_UNICODE_WCHAR_CACHE */ + +/* 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. + + */ +#define Py_UNICODE_ISSPACE(ch) \ + ((Py_UCS4)(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)) + +Py_DEPRECATED(3.3) static inline void +Py_UNICODE_COPY(Py_UNICODE *target, const Py_UNICODE *source, Py_ssize_t length) { + memcpy(target, source, (size_t)(length) * sizeof(Py_UNICODE)); +} + +Py_DEPRECATED(3.3) static inline void +Py_UNICODE_FILL(Py_UNICODE *target, Py_UNICODE value, Py_ssize_t length) { + Py_ssize_t i; + for (i = 0; i < length; i++) { + target[i] = value; + } +} + +/* 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)) + +/* --- Unicode Type ------------------------------------------------------- */ + +/* 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; + +PyAPI_FUNC(int) _PyUnicode_CheckConsistency( + PyObject *op, + int check_content); + +/* Fast access macros */ + +/* 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. */ + +/* Py_DEPRECATED(3.3) */ +#define PyUnicode_GET_SIZE(op) \ + (assert(PyUnicode_Check(op)), \ + (((PyASCIIObject *)(op))->wstr) ? \ + PyUnicode_WSTR_LENGTH(op) : \ + ((void)PyUnicode_AsUnicode(_PyObject_CAST(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) + +/* 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(). */ + +/* Py_DEPRECATED(3.3) */ +#define PyUnicode_AS_UNICODE(op) \ + (assert(PyUnicode_Check(op)), \ + (((PyASCIIObject *)(op))->wstr) ? (((PyASCIIObject *)(op))->wstr) : \ + PyUnicode_AsUnicode(_PyObject_CAST(op))) + +/* Py_DEPRECATED(3.3) */ +#define PyUnicode_AS_DATA(op) \ + ((const char *)(PyUnicode_AS_UNICODE(op))) + + +/* --- 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_CAST(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))))) + +Py_DEPRECATED(3.3) +static inline Py_ssize_t _PyUnicode_get_wstr_length(PyObject *op) { + return PyUnicode_IS_COMPACT_ASCII(op) ? + ((PyASCIIObject*)op)->length : + ((PyCompactUnicodeObject*)op)->wstr_length; +} +#define PyUnicode_WSTR_LENGTH(op) _PyUnicode_get_wstr_length((PyObject*)op) + +/* === 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. */ +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 */ + ); + +/* 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. */ +PyAPI_FUNC(int) _PyUnicode_Ready( + PyObject *unicode /* Unicode object */ + ); + +/* Get a copy of a Unicode string. */ +PyAPI_FUNC(PyObject*) _PyUnicode_Copy( + PyObject *unicode + ); + +/* 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. + */ +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 + ); + +/* 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 + ); + +/* 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. */ +Py_DEPRECATED(3.3) PyAPI_FUNC(PyObject*) PyUnicode_FromUnicode( + const Py_UNICODE *u, /* Unicode buffer */ + Py_ssize_t size /* size of buffer */ + ); + +/* 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); + +/* 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); + +/* 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. */ +Py_DEPRECATED(3.3) PyAPI_FUNC(Py_UNICODE *) PyUnicode_AsUnicode( + PyObject *unicode /* Unicode object */ + ); + +/* 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. */ + +Py_DEPRECATED(3.3) PyAPI_FUNC(Py_UNICODE *) PyUnicode_AsUnicodeAndSize( + PyObject *unicode, /* Unicode object */ + Py_ssize_t *size /* location where to save the length */ + ); + + +/* --- _PyUnicodeWriter 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); + + +/* 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); + +/* --- Manage the default encoding ---------------------------------------- */ + +/* 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. +*/ + +PyAPI_FUNC(const char *) PyUnicode_AsUTF8(PyObject *unicode); + +#define _PyUnicode_AsString PyUnicode_AsUTF8 + +/* --- Generic Codecs ----------------------------------------------------- */ + +/* Encodes a Py_UNICODE buffer of the given size and returns a + Python string object. */ +Py_DEPRECATED(3.3) 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 */ + ); + +/* --- UTF-7 Codecs ------------------------------------------------------- */ + +Py_DEPRECATED(3.3) 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 */ + ); + +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 */ + ); + +/* --- UTF-8 Codecs ------------------------------------------------------- */ + +PyAPI_FUNC(PyObject*) _PyUnicode_AsUTF8String( + PyObject *unicode, + const char *errors); + +Py_DEPRECATED(3.3) 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 */ + ); + +/* --- UTF-32 Codecs ------------------------------------------------------ */ + +Py_DEPRECATED(3.3) 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 */ + ); + +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 */ + ); + +/* --- UTF-16 Codecs ------------------------------------------------------ */ + +/* 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. + +*/ +Py_DEPRECATED(3.3) 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 */ + ); + +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 */ + ); + +/* --- Unicode-Escape Codecs ---------------------------------------------- */ + +/* Variant of PyUnicode_DecodeUnicodeEscape that supports partial decoding. */ +PyAPI_FUNC(PyObject*) _PyUnicode_DecodeUnicodeEscapeStateful( + const char *string, /* Unicode-Escape encoded string */ + Py_ssize_t length, /* size of string */ + const char *errors, /* error handling */ + Py_ssize_t *consumed /* bytes consumed */ +); + +/* Helper for PyUnicode_DecodeUnicodeEscape that detects invalid escape + chars. */ +PyAPI_FUNC(PyObject*) _PyUnicode_DecodeUnicodeEscapeInternal( + const char *string, /* Unicode-Escape encoded string */ + Py_ssize_t length, /* size of string */ + const char *errors, /* error handling */ + Py_ssize_t *consumed, /* bytes consumed */ + const char **first_invalid_escape /* on return, points to first + invalid escaped char in + string. */ +); + +Py_DEPRECATED(3.3) PyAPI_FUNC(PyObject*) PyUnicode_EncodeUnicodeEscape( + const Py_UNICODE *data, /* Unicode char buffer */ + Py_ssize_t length /* Number of Py_UNICODE chars to encode */ + ); + +/* --- Raw-Unicode-Escape Codecs ------------------------------------------ */ + +Py_DEPRECATED(3.3) PyAPI_FUNC(PyObject*) PyUnicode_EncodeRawUnicodeEscape( + const Py_UNICODE *data, /* Unicode char buffer */ + Py_ssize_t length /* Number of Py_UNICODE chars to encode */ + ); + +/* Variant of PyUnicode_DecodeRawUnicodeEscape that supports partial decoding. */ +PyAPI_FUNC(PyObject*) _PyUnicode_DecodeRawUnicodeEscapeStateful( + const char *string, /* Unicode-Escape encoded string */ + Py_ssize_t length, /* size of string */ + const char *errors, /* error handling */ + Py_ssize_t *consumed /* bytes consumed */ +); + +/* --- Latin-1 Codecs ----------------------------------------------------- */ + +PyAPI_FUNC(PyObject*) _PyUnicode_AsLatin1String( + PyObject* unicode, + const char* errors); + +Py_DEPRECATED(3.3) 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 */ + ); + +/* --- ASCII Codecs ------------------------------------------------------- */ + +PyAPI_FUNC(PyObject*) _PyUnicode_AsASCIIString( + PyObject* unicode, + const char* errors); + +Py_DEPRECATED(3.3) 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 */ + ); + +/* --- Character Map Codecs ----------------------------------------------- */ + +Py_DEPRECATED(3.3) 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 */ + ); + +PyAPI_FUNC(PyObject*) _PyUnicode_EncodeCharmap( + PyObject *unicode, /* Unicode object */ + PyObject *mapping, /* encoding mapping */ + const char *errors /* error handling */ + ); + +/* 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. + +*/ +Py_DEPRECATED(3.3) 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 */ + ); + +/* --- MBCS codecs for Windows -------------------------------------------- */ + +#ifdef MS_WINDOWS +Py_DEPRECATED(3.3) 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 */ + ); +#endif + +/* --- 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. + +*/ + +Py_DEPRECATED(3.3) 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 */ + ); + +/* 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. +*/ + +Py_DEPRECATED(3.3) +PyAPI_FUNC(PyObject*) PyUnicode_TransformDecimalToASCII( + Py_UNICODE *s, /* Unicode buffer */ + Py_ssize_t length /* Number of Py_UNICODE chars to transform */ + ); + +/* 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 */ + ); + +/* --- Methods & Slots ---------------------------------------------------- */ + +PyAPI_FUNC(PyObject *) _PyUnicode_JoinArray( + PyObject *separator, + PyObject *const *items, + Py_ssize_t seqlen + ); + +/* 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 */ + ); + +/* 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 */ + ); + +/* Externally visible for str.strip(unicode) */ +PyAPI_FUNC(PyObject *) _PyUnicode_XStrip( + PyObject *self, + int striptype, + PyObject *sepobj + ); + +/* 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) _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); + +/* === Characters Type APIs =============================================== */ + +/* Helper array used by Py_UNICODE_ISSPACE(). */ + +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 */ + ); + +/* Py_DEPRECATED(3.3) */ 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 */ + ); + +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(PyObject*) _PyUnicode_FormatLong(PyObject *, int, int, int); + +/* Return an interned Unicode object for an Identifier; may fail if there is no memory.*/ +PyAPI_FUNC(PyObject*) _PyUnicode_FromId(_Py_Identifier*); + +/* 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 *); + +PyAPI_FUNC(int) _PyUnicode_WideCharString_Converter(PyObject *, void *); +PyAPI_FUNC(int) _PyUnicode_WideCharString_Opt_Converter(PyObject *, void *); + +PyAPI_FUNC(Py_ssize_t) _PyUnicode_ScanIdentifier(PyObject *); diff --git a/.ci/python_dependencies_wins/include/datetime.h b/.ci/python_dependencies_wins/include/datetime.h new file mode 100644 index 00000000..d4e5c177 --- /dev/null +++ b/.ci/python_dependencies_wins/include/datetime.h @@ -0,0 +1,267 @@ +/* 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. */ + +// o is a pointer to a time or a datetime object. +#define _PyDateTime_HAS_TZINFO(o) (((_PyDateTime_BaseTZInfo *)(o))->hastzinfo) + +#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) +#define PyDateTime_DATE_GET_TZINFO(o) (_PyDateTime_HAS_TZINFO(o) ? \ + ((PyDateTime_DateTime *)(o))->tzinfo : Py_None) + +/* 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) +#define PyDateTime_TIME_GET_TZINFO(o) (_PyDateTime_HAS_TZINFO(o) ? \ + ((PyDateTime_Time *)(o))->tzinfo : Py_None) + +/* 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" + + +/* This block is only used as part of the public API and should not be + * included in _datetimemodule.c, which does not use the C API capsule. + * See bpo-35081 for more details. + * */ +#ifndef _PY_DATETIME_IMPL +/* 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_IS_TYPE(op, PyDateTimeAPI->DateType) + +#define PyDateTime_Check(op) PyObject_TypeCheck(op, PyDateTimeAPI->DateTimeType) +#define PyDateTime_CheckExact(op) Py_IS_TYPE(op, PyDateTimeAPI->DateTimeType) + +#define PyTime_Check(op) PyObject_TypeCheck(op, PyDateTimeAPI->TimeType) +#define PyTime_CheckExact(op) Py_IS_TYPE(op, PyDateTimeAPI->TimeType) + +#define PyDelta_Check(op) PyObject_TypeCheck(op, PyDateTimeAPI->DeltaType) +#define PyDelta_CheckExact(op) Py_IS_TYPE(op, PyDateTimeAPI->DeltaType) + +#define PyTZInfo_Check(op) PyObject_TypeCheck(op, PyDateTimeAPI->TZInfoType) +#define PyTZInfo_CheckExact(op) Py_IS_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 /* !defined(_PY_DATETIME_IMPL) */ + +#ifdef __cplusplus +} +#endif +#endif +#endif /* !Py_LIMITED_API */ diff --git a/.ci/python_dependencies_wins/include/descrobject.h b/.ci/python_dependencies_wins/include/descrobject.h new file mode 100644 index 00000000..d52b9f5c --- /dev/null +++ b/.ci/python_dependencies_wins/include/descrobject.h @@ -0,0 +1,108 @@ +/* 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; + vectorcallfunc vectorcall; +} 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 *) PyDescr_NewWrapper(PyTypeObject *, + struct wrapperbase *, void *); +PyAPI_FUNC(int) PyDescr_IsData(PyObject *); +#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/.ci/python_dependencies_wins/include/dictobject.h b/.ci/python_dependencies_wins/include/dictobject.h new file mode 100644 index 00000000..82ec40e6 --- /dev/null +++ b/.ci/python_dependencies_wins/include/dictobject.h @@ -0,0 +1,97 @@ +#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. +*/ + +PyAPI_DATA(PyTypeObject) PyDict_Type; + +#define PyDict_Check(op) \ + PyType_FastSubclass(Py_TYPE(op), Py_TPFLAGS_DICT_SUBCLASS) +#define PyDict_CheckExact(op) Py_IS_TYPE(op, &PyDict_Type) + +PyAPI_FUNC(PyObject *) PyDict_New(void); +PyAPI_FUNC(PyObject *) PyDict_GetItem(PyObject *mp, PyObject *key); +PyAPI_FUNC(PyObject *) PyDict_GetItemWithError(PyObject *mp, PyObject *key); +PyAPI_FUNC(int) PyDict_SetItem(PyObject *mp, PyObject *key, PyObject *item); +PyAPI_FUNC(int) PyDict_DelItem(PyObject *mp, PyObject *key); +PyAPI_FUNC(void) PyDict_Clear(PyObject *mp); +PyAPI_FUNC(int) PyDict_Next( + PyObject *mp, Py_ssize_t *pos, PyObject **key, PyObject **value); +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); + +/* 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); + +/* 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); +PyAPI_FUNC(int) PyDict_SetItemString(PyObject *dp, const char *key, PyObject *item); +PyAPI_FUNC(int) PyDict_DelItemString(PyObject *dp, const char *key); +#if !defined(Py_LIMITED_API) || Py_LIMITED_API+0 >= 0x030A0000 +PyAPI_FUNC(PyObject *) PyObject_GenericGetDict(PyObject *, void *); +#endif + +/* Dictionary (keys, values, items) views */ + +PyAPI_DATA(PyTypeObject) PyDictKeys_Type; +PyAPI_DATA(PyTypeObject) PyDictValues_Type; +PyAPI_DATA(PyTypeObject) PyDictItems_Type; + +#define PyDictKeys_Check(op) PyObject_TypeCheck(op, &PyDictKeys_Type) +#define PyDictValues_Check(op) PyObject_TypeCheck(op, &PyDictValues_Type) +#define PyDictItems_Check(op) PyObject_TypeCheck(op, &PyDictItems_Type) +/* This excludes Values, since they are not sets. */ +# define PyDictViewSet_Check(op) \ + (PyDictKeys_Check(op) || PyDictItems_Check(op)) + +/* Dictionary (key, value, items) iterators */ + +PyAPI_DATA(PyTypeObject) PyDictIterKey_Type; +PyAPI_DATA(PyTypeObject) PyDictIterValue_Type; +PyAPI_DATA(PyTypeObject) PyDictIterItem_Type; + +PyAPI_DATA(PyTypeObject) PyDictRevIterKey_Type; +PyAPI_DATA(PyTypeObject) PyDictRevIterItem_Type; +PyAPI_DATA(PyTypeObject) PyDictRevIterValue_Type; + + +#ifndef Py_LIMITED_API +# define Py_CPYTHON_DICTOBJECT_H +# include "cpython/dictobject.h" +# undef Py_CPYTHON_DICTOBJECT_H +#endif + +#ifdef __cplusplus +} +#endif +#endif /* !Py_DICTOBJECT_H */ diff --git a/.ci/python_dependencies_wins/include/dynamic_annotations.h b/.ci/python_dependencies_wins/include/dynamic_annotations.h new file mode 100644 index 00000000..3c08818b --- /dev/null +++ b/.ci/python_dependencies_wins/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 https://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 + https://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/.ci/python_dependencies_wins/include/enumobject.h b/.ci/python_dependencies_wins/include/enumobject.h new file mode 100644 index 00000000..42dc2d27 --- /dev/null +++ b/.ci/python_dependencies_wins/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/.ci/python_dependencies_wins/include/errcode.h b/.ci/python_dependencies_wins/include/errcode.h new file mode 100644 index 00000000..66ef202b --- /dev/null +++ b/.ci/python_dependencies_wins/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_BADSINGLE 27 /* Ill-formed single statement input */ +#define E_INTERACT_STOP 28 /* Interactive mode stopped tokenization */ + +#ifdef __cplusplus +} +#endif +#endif /* !Py_ERRCODE_H */ diff --git a/.ci/python_dependencies_wins/include/eval.h b/.ci/python_dependencies_wins/include/eval.h new file mode 100644 index 00000000..13eaddb5 --- /dev/null +++ b/.ci/python_dependencies_wins/include/eval.h @@ -0,0 +1,27 @@ + +/* 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_CallTracing(PyObject *func, PyObject *args); +#endif + +#ifdef __cplusplus +} +#endif +#endif /* !Py_EVAL_H */ diff --git a/.ci/python_dependencies_wins/include/exports.h b/.ci/python_dependencies_wins/include/exports.h new file mode 100644 index 00000000..20a74bb9 --- /dev/null +++ b/.ci/python_dependencies_wins/include/exports.h @@ -0,0 +1,30 @@ +#ifndef Py_EXPORTS_H +#define Py_EXPORTS_H + +#if defined(_WIN32) || defined(__CYGWIN__) + #define Py_IMPORTED_SYMBOL __declspec(dllimport) + #define Py_EXPORTED_SYMBOL __declspec(dllexport) + #define Py_LOCAL_SYMBOL +#else +/* + * If we only ever used gcc >= 5, we could use __has_attribute(visibility) + * as a cross-platform way to determine if visibility is supported. However, + * we may still need to support gcc >= 4, as some Ubuntu LTS and Centos versions + * have 4 < gcc < 5. + */ + #ifndef __has_attribute + #define __has_attribute(x) 0 // Compatibility with non-clang compilers. + #endif + #if (defined(__GNUC__) && (__GNUC__ >= 4)) ||\ + (defined(__clang__) && __has_attribute(visibility)) + #define Py_IMPORTED_SYMBOL __attribute__ ((visibility ("default"))) + #define Py_EXPORTED_SYMBOL __attribute__ ((visibility ("default"))) + #define Py_LOCAL_SYMBOL __attribute__ ((visibility ("hidden"))) + #else + #define Py_IMPORTED_SYMBOL + #define Py_EXPORTED_SYMBOL + #define Py_LOCAL_SYMBOL + #endif +#endif + +#endif /* Py_EXPORTS_H */ diff --git a/.ci/python_dependencies_wins/include/fileobject.h b/.ci/python_dependencies_wins/include/fileobject.h new file mode 100644 index 00000000..cf7ba8df --- /dev/null +++ b/.ci/python_dependencies_wins/include/fileobject.h @@ -0,0 +1,49 @@ +/* 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 *); + +/* 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 + +/* 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 + +#ifndef Py_LIMITED_API +# define Py_CPYTHON_FILEOBJECT_H +# include "cpython/fileobject.h" +# undef Py_CPYTHON_FILEOBJECT_H +#endif + +#ifdef __cplusplus +} +#endif +#endif /* !Py_FILEOBJECT_H */ diff --git a/.ci/python_dependencies_wins/include/fileutils.h b/.ci/python_dependencies_wins/include/fileutils.h new file mode 100644 index 00000000..9483bd01 --- /dev/null +++ b/.ci/python_dependencies_wins/include/fileutils.h @@ -0,0 +1,26 @@ +#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); +#endif + +#ifndef Py_LIMITED_API +# define Py_CPYTHON_FILEUTILS_H +# include "cpython/fileutils.h" +# undef Py_CPYTHON_FILEUTILS_H +#endif + +#ifdef __cplusplus +} +#endif +#endif /* !Py_FILEUTILS_H */ diff --git a/.ci/python_dependencies_wins/include/floatobject.h b/.ci/python_dependencies_wins/include/floatobject.h new file mode 100644 index 00000000..475f6add --- /dev/null +++ b/.ci/python_dependencies_wins/include/floatobject.h @@ -0,0 +1,118 @@ + +/* 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_IS_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); + +/* 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); + +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/.ci/python_dependencies_wins/include/frameobject.h b/.ci/python_dependencies_wins/include/frameobject.h new file mode 100644 index 00000000..36e2ab33 --- /dev/null +++ b/.ci/python_dependencies_wins/include/frameobject.h @@ -0,0 +1,20 @@ +/* Frame object interface */ + +#ifndef Py_FRAMEOBJECT_H +#define Py_FRAMEOBJECT_H +#ifdef __cplusplus +extern "C" { +#endif + +#include "pyframe.h" + +#ifndef Py_LIMITED_API +# define Py_CPYTHON_FRAMEOBJECT_H +# include "cpython/frameobject.h" +# undef Py_CPYTHON_FRAMEOBJECT_H +#endif + +#ifdef __cplusplus +} +#endif +#endif /* !Py_FRAMEOBJECT_H */ diff --git a/.ci/python_dependencies_wins/include/funcobject.h b/.ci/python_dependencies_wins/include/funcobject.h new file mode 100644 index 00000000..ce70da02 --- /dev/null +++ b/.ci/python_dependencies_wins/include/funcobject.h @@ -0,0 +1,110 @@ + +/* Function object interface */ +#ifndef Py_LIMITED_API +#ifndef Py_FUNCOBJECT_H +#define Py_FUNCOBJECT_H +#ifdef __cplusplus +extern "C" { +#endif + + +#define COMMON_FIELDS(PREFIX) \ + PyObject *PREFIX ## globals; \ + PyObject *PREFIX ## builtins; \ + PyObject *PREFIX ## name; \ + PyObject *PREFIX ## qualname; \ + PyObject *PREFIX ## code; /* A code object, the __code__ attribute */ \ + PyObject *PREFIX ## defaults; /* NULL or a tuple */ \ + PyObject *PREFIX ## kwdefaults; /* NULL or a dict */ \ + PyObject *PREFIX ## closure; /* NULL or a tuple of cell objects */ + +typedef struct { + COMMON_FIELDS(fc_) +} PyFrameConstructor; + +/* 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 + COMMON_FIELDS(func_) + PyObject *func_doc; /* The __doc__ attribute, can be anything */ + 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 */ + vectorcallfunc vectorcall; + + /* 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_IS_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_Vectorcall( + PyObject *func, + PyObject *const *stack, + size_t nargsf, + 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) + +#define PyFunction_AS_FRAME_CONSTRUCTOR(func) \ + ((PyFrameConstructor *)&((PyFunctionObject *)(func))->func_globals) + +/* 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/.ci/python_dependencies_wins/include/genericaliasobject.h b/.ci/python_dependencies_wins/include/genericaliasobject.h new file mode 100644 index 00000000..70096093 --- /dev/null +++ b/.ci/python_dependencies_wins/include/genericaliasobject.h @@ -0,0 +1,14 @@ +// Implementation of PEP 585: support list[int] etc. +#ifndef Py_GENERICALIASOBJECT_H +#define Py_GENERICALIASOBJECT_H +#ifdef __cplusplus +extern "C" { +#endif + +PyAPI_FUNC(PyObject *) Py_GenericAlias(PyObject *, PyObject *); +PyAPI_DATA(PyTypeObject) Py_GenericAliasType; + +#ifdef __cplusplus +} +#endif +#endif /* !Py_GENERICALIASOBJECT_H */ diff --git a/.ci/python_dependencies_wins/include/genobject.h b/.ci/python_dependencies_wins/include/genobject.h new file mode 100644 index 00000000..e6d38d35 --- /dev/null +++ b/.ci/python_dependencies_wins/include/genobject.h @@ -0,0 +1,100 @@ + +/* Generator object interface */ + +#ifndef Py_LIMITED_API +#ifndef Py_GENOBJECT_H +#define Py_GENOBJECT_H +#ifdef __cplusplus +extern "C" { +#endif + +#include "pystate.h" /* _PyErr_StackItem */ +#include "abstract.h" /* PySendResult */ + +/* _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" */ \ + PyFrameObject *prefix##_frame; \ + /* 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_IS_TYPE(op, &PyGen_Type) + +PyAPI_FUNC(PyObject *) PyGen_New(PyFrameObject *); +PyAPI_FUNC(PyObject *) PyGen_NewWithQualName(PyFrameObject *, + PyObject *name, PyObject *qualname); +PyAPI_FUNC(int) _PyGen_SetStopIterationValue(PyObject *); +PyAPI_FUNC(int) _PyGen_FetchStopIterationValue(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; + +#define PyCoro_CheckExact(op) Py_IS_TYPE(op, &PyCoro_Type) +PyObject *_PyCoro_GetAwaitableIter(PyObject *o); +PyAPI_FUNC(PyObject *) PyCoro_New(PyFrameObject *, + 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; + + int ag_running_async; +} 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(PyFrameObject *, + PyObject *name, PyObject *qualname); + +#define PyAsyncGen_CheckExact(op) Py_IS_TYPE(op, &PyAsyncGen_Type) + +PyObject *_PyAsyncGenValueWrapperNew(PyObject *); + +#endif + +#undef _PyGenObject_HEAD + +#ifdef __cplusplus +} +#endif +#endif /* !Py_GENOBJECT_H */ +#endif /* Py_LIMITED_API */ diff --git a/.ci/python_dependencies_wins/include/greenlet/greenlet.h b/.ci/python_dependencies_wins/include/greenlet/greenlet.h new file mode 100644 index 00000000..d02a16e4 --- /dev/null +++ b/.ci/python_dependencies_wins/include/greenlet/greenlet.h @@ -0,0 +1,164 @@ +/* -*- indent-tabs-mode: nil; tab-width: 4; -*- */ + +/* Greenlet object interface */ + +#ifndef Py_GREENLETOBJECT_H +#define Py_GREENLETOBJECT_H + + +#include + +#ifdef __cplusplus +extern "C" { +#endif + +/* This is deprecated and undocumented. It does not change. */ +#define GREENLET_VERSION "1.0.0" + +#ifndef GREENLET_MODULE +#define implementation_ptr_t void* +#endif + +typedef struct _greenlet { + PyObject_HEAD + PyObject* weakreflist; + PyObject* dict; + implementation_ptr_t pimpl; +} PyGreenlet; + +#define PyGreenlet_Check(op) (op && PyObject_TypeCheck(op, &PyGreenlet_Type)) + + +/* C API functions */ + +/* Total number of symbols that are exported */ +#define PyGreenlet_API_pointers 12 + +#define PyGreenlet_Type_NUM 0 +#define PyExc_GreenletError_NUM 1 +#define PyExc_GreenletExit_NUM 2 + +#define PyGreenlet_New_NUM 3 +#define PyGreenlet_GetCurrent_NUM 4 +#define PyGreenlet_Throw_NUM 5 +#define PyGreenlet_Switch_NUM 6 +#define PyGreenlet_SetParent_NUM 7 + +#define PyGreenlet_MAIN_NUM 8 +#define PyGreenlet_STARTED_NUM 9 +#define PyGreenlet_ACTIVE_NUM 10 +#define PyGreenlet_GET_PARENT_NUM 11 + +#ifndef GREENLET_MODULE +/* This section is used by modules that uses the greenlet C API */ +static void** _PyGreenlet_API = NULL; + +# define PyGreenlet_Type \ + (*(PyTypeObject*)_PyGreenlet_API[PyGreenlet_Type_NUM]) + +# define PyExc_GreenletError \ + ((PyObject*)_PyGreenlet_API[PyExc_GreenletError_NUM]) + +# define PyExc_GreenletExit \ + ((PyObject*)_PyGreenlet_API[PyExc_GreenletExit_NUM]) + +/* + * PyGreenlet_New(PyObject *args) + * + * greenlet.greenlet(run, parent=None) + */ +# define PyGreenlet_New \ + (*(PyGreenlet * (*)(PyObject * run, PyGreenlet * parent)) \ + _PyGreenlet_API[PyGreenlet_New_NUM]) + +/* + * PyGreenlet_GetCurrent(void) + * + * greenlet.getcurrent() + */ +# define PyGreenlet_GetCurrent \ + (*(PyGreenlet * (*)(void)) _PyGreenlet_API[PyGreenlet_GetCurrent_NUM]) + +/* + * PyGreenlet_Throw( + * PyGreenlet *greenlet, + * PyObject *typ, + * PyObject *val, + * PyObject *tb) + * + * g.throw(...) + */ +# define PyGreenlet_Throw \ + (*(PyObject * (*)(PyGreenlet * self, \ + PyObject * typ, \ + PyObject * val, \ + PyObject * tb)) \ + _PyGreenlet_API[PyGreenlet_Throw_NUM]) + +/* + * PyGreenlet_Switch(PyGreenlet *greenlet, PyObject *args) + * + * g.switch(*args, **kwargs) + */ +# define PyGreenlet_Switch \ + (*(PyObject * \ + (*)(PyGreenlet * greenlet, PyObject * args, PyObject * kwargs)) \ + _PyGreenlet_API[PyGreenlet_Switch_NUM]) + +/* + * PyGreenlet_SetParent(PyObject *greenlet, PyObject *new_parent) + * + * g.parent = new_parent + */ +# define PyGreenlet_SetParent \ + (*(int (*)(PyGreenlet * greenlet, PyGreenlet * nparent)) \ + _PyGreenlet_API[PyGreenlet_SetParent_NUM]) + +/* + * PyGreenlet_GetParent(PyObject* greenlet) + * + * return greenlet.parent; + * + * This could return NULL even if there is no exception active. + * If it does not return NULL, you are responsible for decrementing the + * reference count. + */ +# define PyGreenlet_GetParent \ + (*(PyGreenlet* (*)(PyGreenlet*)) \ + _PyGreenlet_API[PyGreenlet_GET_PARENT_NUM]) + +/* + * deprecated, undocumented alias. + */ +# define PyGreenlet_GET_PARENT PyGreenlet_GetParent + +# define PyGreenlet_MAIN \ + (*(int (*)(PyGreenlet*)) \ + _PyGreenlet_API[PyGreenlet_MAIN_NUM]) + +# define PyGreenlet_STARTED \ + (*(int (*)(PyGreenlet*)) \ + _PyGreenlet_API[PyGreenlet_STARTED_NUM]) + +# define PyGreenlet_ACTIVE \ + (*(int (*)(PyGreenlet*)) \ + _PyGreenlet_API[PyGreenlet_ACTIVE_NUM]) + + + + +/* Macro that imports greenlet and initializes C API */ +/* NOTE: This has actually moved to ``greenlet._greenlet._C_API``, but we + keep the older definition to be sure older code that might have a copy of + the header still works. */ +# define PyGreenlet_Import() \ + { \ + _PyGreenlet_API = (void**)PyCapsule_Import("greenlet._C_API", 0); \ + } + +#endif /* GREENLET_MODULE */ + +#ifdef __cplusplus +} +#endif +#endif /* !Py_GREENLETOBJECT_H */ diff --git a/.ci/python_dependencies_wins/include/import.h b/.ci/python_dependencies_wins/include/import.h new file mode 100644 index 00000000..468a6734 --- /dev/null +++ b/.ci/python_dependencies_wins/include/import.h @@ -0,0 +1,98 @@ +/* Module definition and import interface */ + +#ifndef Py_IMPORT_H +#define Py_IMPORT_H +#ifdef __cplusplus +extern "C" { +#endif + +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 +#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); +#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 */ + ); + +PyAPI_FUNC(int) PyImport_AppendInittab( + const char *name, /* ASCII encoded string */ + PyObject* (*initfunc)(void) + ); + +#ifndef Py_LIMITED_API +# define Py_CPYTHON_IMPORT_H +# include "cpython/import.h" +# undef Py_CPYTHON_IMPORT_H +#endif + +#ifdef __cplusplus +} +#endif +#endif /* !Py_IMPORT_H */ diff --git a/.ci/python_dependencies_wins/include/insightface/mesh_core.h b/.ci/python_dependencies_wins/include/insightface/mesh_core.h new file mode 100644 index 00000000..3eb00290 --- /dev/null +++ b/.ci/python_dependencies_wins/include/insightface/mesh_core.h @@ -0,0 +1,83 @@ +#ifndef MESH_CORE_HPP_ +#define MESH_CORE_HPP_ + +#include +#include +#include +#include +#include +#include + +using namespace std; + +class point +{ + public: + float x; + float y; + + float dot(point p) + { + return this->x * p.x + this->y * p.y; + } + + point operator-(const point& p) + { + point np; + np.x = this->x - p.x; + np.y = this->y - p.y; + return np; + } + + point operator+(const point& p) + { + point np; + np.x = this->x + p.x; + np.y = this->y + p.y; + return np; + } + + point operator*(float s) + { + point np; + np.x = s * this->x; + np.y = s * this->y; + return np; + } +}; + + +bool isPointInTri(point p, point p0, point p1, point p2, int h, int w); +void get_point_weight(float* weight, point p, point p0, point p1, point p2); + +void _get_normal_core( + float* normal, float* tri_normal, int* triangles, + int ntri); + +void _rasterize_triangles_core( + float* vertices, int* triangles, + float* depth_buffer, int* triangle_buffer, float* barycentric_weight, + int nver, int ntri, + int h, int w); + +void _render_colors_core( + float* image, float* vertices, int* triangles, + float* colors, + float* depth_buffer, + int nver, int ntri, + int h, int w, int c); + +void _render_texture_core( + float* image, float* vertices, int* triangles, + float* texture, float* tex_coords, int* tex_triangles, + float* depth_buffer, + int nver, int tex_nver, int ntri, + int h, int w, int c, + int tex_h, int tex_w, int tex_c, + int mapping_type); + +void _write_obj_with_colors_texture(string filename, string mtl_name, + float* vertices, int* triangles, float* colors, float* uv_coords, + int nver, int ntri, int ntexver); + +#endif \ No newline at end of file diff --git a/.ci/python_dependencies_wins/include/internal/pycore_abstract.h b/.ci/python_dependencies_wins/include/internal/pycore_abstract.h new file mode 100644 index 00000000..15aa7f58 --- /dev/null +++ b/.ci/python_dependencies_wins/include/internal/pycore_abstract.h @@ -0,0 +1,22 @@ +#ifndef Py_INTERNAL_ABSTRACT_H +#define Py_INTERNAL_ABSTRACT_H +#ifdef __cplusplus +extern "C" { +#endif + +#ifndef Py_BUILD_CORE +# error "this header requires Py_BUILD_CORE define" +#endif + +// Fast inlined version of PyIndex_Check() +static inline int +_PyIndex_Check(PyObject *obj) +{ + PyNumberMethods *tp_as_number = Py_TYPE(obj)->tp_as_number; + return (tp_as_number != NULL && tp_as_number->nb_index != NULL); +} + +#ifdef __cplusplus +} +#endif +#endif /* !Py_INTERNAL_ABSTRACT_H */ diff --git a/.ci/python_dependencies_wins/include/internal/pycore_accu.h b/.ci/python_dependencies_wins/include/internal/pycore_accu.h new file mode 100644 index 00000000..344a9c6c --- /dev/null +++ b/.ci/python_dependencies_wins/include/internal/pycore_accu.h @@ -0,0 +1,39 @@ +#ifndef Py_LIMITED_API +#ifndef Py_INTERNAL_ACCU_H +#define Py_INTERNAL_ACCU_H +#ifdef __cplusplus +extern "C" { +#endif + +/*** This is a private API for use by the interpreter and the stdlib. + *** Its definition may be changed or removed at any moment. + ***/ + +#ifndef Py_BUILD_CORE +# error "this header requires Py_BUILD_CORE define" +#endif + +/* + * 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. + */ + +#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_INTERNAL_ACCU_H */ +#endif /* !Py_LIMITED_API */ diff --git a/.ci/python_dependencies_wins/include/internal/pycore_asdl.h b/.ci/python_dependencies_wins/include/internal/pycore_asdl.h new file mode 100644 index 00000000..a2cb8c08 --- /dev/null +++ b/.ci/python_dependencies_wins/include/internal/pycore_asdl.h @@ -0,0 +1,112 @@ +#ifndef Py_INTERNAL_ASDL_H +#define Py_INTERNAL_ASDL_H +#ifdef __cplusplus +extern "C" { +#endif + +#ifndef Py_BUILD_CORE +# error "this header requires Py_BUILD_CORE define" +#endif + +#include "pycore_pyarena.h" // _PyArena_Malloc() + +typedef PyObject * identifier; +typedef PyObject * string; +typedef PyObject * object; +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. +*/ + +#define _ASDL_SEQ_HEAD \ + Py_ssize_t size; \ + void **elements; + +typedef struct { + _ASDL_SEQ_HEAD +} asdl_seq; + +typedef struct { + _ASDL_SEQ_HEAD + void *typed_elements[1]; +} asdl_generic_seq; + +typedef struct { + _ASDL_SEQ_HEAD + PyObject *typed_elements[1]; +} asdl_identifier_seq; + +typedef struct { + _ASDL_SEQ_HEAD + int typed_elements[1]; +} asdl_int_seq; + +asdl_generic_seq *_Py_asdl_generic_seq_new(Py_ssize_t size, PyArena *arena); +asdl_identifier_seq *_Py_asdl_identifier_seq_new(Py_ssize_t size, PyArena *arena); +asdl_int_seq *_Py_asdl_int_seq_new(Py_ssize_t size, PyArena *arena); + + +#define GENERATE_ASDL_SEQ_CONSTRUCTOR(NAME, TYPE) \ +asdl_ ## NAME ## _seq *_Py_asdl_ ## NAME ## _seq_new(Py_ssize_t size, PyArena *arena) \ +{ \ + asdl_ ## NAME ## _seq *seq = NULL; \ + size_t n; \ + /* check size is sane */ \ + if (size < 0 || \ + (size && (((size_t)size - 1) > (SIZE_MAX / sizeof(void *))))) { \ + PyErr_NoMemory(); \ + return NULL; \ + } \ + n = (size ? (sizeof(TYPE *) * (size - 1)) : 0); \ + /* check if size can be added safely */ \ + if (n > SIZE_MAX - sizeof(asdl_ ## NAME ## _seq)) { \ + PyErr_NoMemory(); \ + return NULL; \ + } \ + n += sizeof(asdl_ ## NAME ## _seq); \ + seq = (asdl_ ## NAME ## _seq *)_PyArena_Malloc(arena, n); \ + if (!seq) { \ + PyErr_NoMemory(); \ + return NULL; \ + } \ + memset(seq, 0, n); \ + seq->size = size; \ + seq->elements = (void**)seq->typed_elements; \ + return seq; \ +} + +#define asdl_seq_GET_UNTYPED(S, I) (S)->elements[(I)] +#define asdl_seq_GET(S, I) (S)->typed_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(0 <= _asdl_i && _asdl_i < (S)->size); \ + (S)->typed_elements[_asdl_i] = (V); \ + } while (0) +#else +# define asdl_seq_SET(S, I, V) (S)->typed_elements[I] = (V) +#endif + +#ifdef Py_DEBUG +# define asdl_seq_SET_UNTYPED(S, I, V) \ + do { \ + Py_ssize_t _asdl_i = (I); \ + assert((S) != NULL); \ + assert(0 <= _asdl_i && _asdl_i < (S)->size); \ + (S)->elements[_asdl_i] = (V); \ + } while (0) +#else +# define asdl_seq_SET_UNTYPED(S, I, V) (S)->elements[I] = (V) +#endif + +#ifdef __cplusplus +} +#endif +#endif /* !Py_INTERNAL_ASDL_H */ diff --git a/.ci/python_dependencies_wins/include/internal/pycore_ast.h b/.ci/python_dependencies_wins/include/internal/pycore_ast.h new file mode 100644 index 00000000..4e5a5c7a --- /dev/null +++ b/.ci/python_dependencies_wins/include/internal/pycore_ast.h @@ -0,0 +1,855 @@ +// File automatically generated by Parser/asdl_c.py. + +#ifndef Py_INTERNAL_AST_H +#define Py_INTERNAL_AST_H +#ifdef __cplusplus +extern "C" { +#endif + +#ifndef Py_BUILD_CORE +# error "this header requires Py_BUILD_CORE define" +#endif + +#include "pycore_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 } expr_context_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; + +typedef struct _match_case *match_case_ty; + +typedef struct _pattern *pattern_ty; + +typedef struct _type_ignore *type_ignore_ty; + + +typedef struct { + _ASDL_SEQ_HEAD + mod_ty typed_elements[1]; +} asdl_mod_seq; + +asdl_mod_seq *_Py_asdl_mod_seq_new(Py_ssize_t size, PyArena *arena); + +typedef struct { + _ASDL_SEQ_HEAD + stmt_ty typed_elements[1]; +} asdl_stmt_seq; + +asdl_stmt_seq *_Py_asdl_stmt_seq_new(Py_ssize_t size, PyArena *arena); + +typedef struct { + _ASDL_SEQ_HEAD + expr_ty typed_elements[1]; +} asdl_expr_seq; + +asdl_expr_seq *_Py_asdl_expr_seq_new(Py_ssize_t size, PyArena *arena); + +typedef struct { + _ASDL_SEQ_HEAD + comprehension_ty typed_elements[1]; +} asdl_comprehension_seq; + +asdl_comprehension_seq *_Py_asdl_comprehension_seq_new(Py_ssize_t size, PyArena + *arena); + +typedef struct { + _ASDL_SEQ_HEAD + excepthandler_ty typed_elements[1]; +} asdl_excepthandler_seq; + +asdl_excepthandler_seq *_Py_asdl_excepthandler_seq_new(Py_ssize_t size, PyArena + *arena); + +typedef struct { + _ASDL_SEQ_HEAD + arguments_ty typed_elements[1]; +} asdl_arguments_seq; + +asdl_arguments_seq *_Py_asdl_arguments_seq_new(Py_ssize_t size, PyArena *arena); + +typedef struct { + _ASDL_SEQ_HEAD + arg_ty typed_elements[1]; +} asdl_arg_seq; + +asdl_arg_seq *_Py_asdl_arg_seq_new(Py_ssize_t size, PyArena *arena); + +typedef struct { + _ASDL_SEQ_HEAD + keyword_ty typed_elements[1]; +} asdl_keyword_seq; + +asdl_keyword_seq *_Py_asdl_keyword_seq_new(Py_ssize_t size, PyArena *arena); + +typedef struct { + _ASDL_SEQ_HEAD + alias_ty typed_elements[1]; +} asdl_alias_seq; + +asdl_alias_seq *_Py_asdl_alias_seq_new(Py_ssize_t size, PyArena *arena); + +typedef struct { + _ASDL_SEQ_HEAD + withitem_ty typed_elements[1]; +} asdl_withitem_seq; + +asdl_withitem_seq *_Py_asdl_withitem_seq_new(Py_ssize_t size, PyArena *arena); + +typedef struct { + _ASDL_SEQ_HEAD + match_case_ty typed_elements[1]; +} asdl_match_case_seq; + +asdl_match_case_seq *_Py_asdl_match_case_seq_new(Py_ssize_t size, PyArena + *arena); + +typedef struct { + _ASDL_SEQ_HEAD + pattern_ty typed_elements[1]; +} asdl_pattern_seq; + +asdl_pattern_seq *_Py_asdl_pattern_seq_new(Py_ssize_t size, PyArena *arena); + +typedef struct { + _ASDL_SEQ_HEAD + type_ignore_ty typed_elements[1]; +} asdl_type_ignore_seq; + +asdl_type_ignore_seq *_Py_asdl_type_ignore_seq_new(Py_ssize_t size, PyArena + *arena); + + +enum _mod_kind {Module_kind=1, Interactive_kind=2, Expression_kind=3, + FunctionType_kind=4}; +struct _mod { + enum _mod_kind kind; + union { + struct { + asdl_stmt_seq *body; + asdl_type_ignore_seq *type_ignores; + } Module; + + struct { + asdl_stmt_seq *body; + } Interactive; + + struct { + expr_ty body; + } Expression; + + struct { + asdl_expr_seq *argtypes; + expr_ty returns; + } FunctionType; + + } 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, Match_kind=15, Raise_kind=16, Try_kind=17, + Assert_kind=18, Import_kind=19, ImportFrom_kind=20, + Global_kind=21, Nonlocal_kind=22, Expr_kind=23, Pass_kind=24, + Break_kind=25, Continue_kind=26}; +struct _stmt { + enum _stmt_kind kind; + union { + struct { + identifier name; + arguments_ty args; + asdl_stmt_seq *body; + asdl_expr_seq *decorator_list; + expr_ty returns; + string type_comment; + } FunctionDef; + + struct { + identifier name; + arguments_ty args; + asdl_stmt_seq *body; + asdl_expr_seq *decorator_list; + expr_ty returns; + string type_comment; + } AsyncFunctionDef; + + struct { + identifier name; + asdl_expr_seq *bases; + asdl_keyword_seq *keywords; + asdl_stmt_seq *body; + asdl_expr_seq *decorator_list; + } ClassDef; + + struct { + expr_ty value; + } Return; + + struct { + asdl_expr_seq *targets; + } Delete; + + struct { + asdl_expr_seq *targets; + expr_ty value; + string type_comment; + } 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_stmt_seq *body; + asdl_stmt_seq *orelse; + string type_comment; + } For; + + struct { + expr_ty target; + expr_ty iter; + asdl_stmt_seq *body; + asdl_stmt_seq *orelse; + string type_comment; + } AsyncFor; + + struct { + expr_ty test; + asdl_stmt_seq *body; + asdl_stmt_seq *orelse; + } While; + + struct { + expr_ty test; + asdl_stmt_seq *body; + asdl_stmt_seq *orelse; + } If; + + struct { + asdl_withitem_seq *items; + asdl_stmt_seq *body; + string type_comment; + } With; + + struct { + asdl_withitem_seq *items; + asdl_stmt_seq *body; + string type_comment; + } AsyncWith; + + struct { + expr_ty subject; + asdl_match_case_seq *cases; + } Match; + + struct { + expr_ty exc; + expr_ty cause; + } Raise; + + struct { + asdl_stmt_seq *body; + asdl_excepthandler_seq *handlers; + asdl_stmt_seq *orelse; + asdl_stmt_seq *finalbody; + } Try; + + struct { + expr_ty test; + expr_ty msg; + } Assert; + + struct { + asdl_alias_seq *names; + } Import; + + struct { + identifier module; + asdl_alias_seq *names; + int level; + } ImportFrom; + + struct { + asdl_identifier_seq *names; + } Global; + + struct { + asdl_identifier_seq *names; + } Nonlocal; + + struct { + expr_ty value; + } Expr; + + } v; + int lineno; + int col_offset; + int end_lineno; + int end_col_offset; +}; + +enum _expr_kind {BoolOp_kind=1, NamedExpr_kind=2, BinOp_kind=3, UnaryOp_kind=4, + Lambda_kind=5, IfExp_kind=6, Dict_kind=7, Set_kind=8, + ListComp_kind=9, SetComp_kind=10, DictComp_kind=11, + GeneratorExp_kind=12, Await_kind=13, Yield_kind=14, + YieldFrom_kind=15, Compare_kind=16, Call_kind=17, + FormattedValue_kind=18, JoinedStr_kind=19, Constant_kind=20, + Attribute_kind=21, Subscript_kind=22, Starred_kind=23, + Name_kind=24, List_kind=25, Tuple_kind=26, Slice_kind=27}; +struct _expr { + enum _expr_kind kind; + union { + struct { + boolop_ty op; + asdl_expr_seq *values; + } BoolOp; + + struct { + expr_ty target; + expr_ty value; + } NamedExpr; + + 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_expr_seq *keys; + asdl_expr_seq *values; + } Dict; + + struct { + asdl_expr_seq *elts; + } Set; + + struct { + expr_ty elt; + asdl_comprehension_seq *generators; + } ListComp; + + struct { + expr_ty elt; + asdl_comprehension_seq *generators; + } SetComp; + + struct { + expr_ty key; + expr_ty value; + asdl_comprehension_seq *generators; + } DictComp; + + struct { + expr_ty elt; + asdl_comprehension_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_expr_seq *comparators; + } Compare; + + struct { + expr_ty func; + asdl_expr_seq *args; + asdl_keyword_seq *keywords; + } Call; + + struct { + expr_ty value; + int conversion; + expr_ty format_spec; + } FormattedValue; + + struct { + asdl_expr_seq *values; + } JoinedStr; + + struct { + constant value; + string kind; + } Constant; + + struct { + expr_ty value; + identifier attr; + expr_context_ty ctx; + } Attribute; + + struct { + expr_ty value; + expr_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_expr_seq *elts; + expr_context_ty ctx; + } List; + + struct { + asdl_expr_seq *elts; + expr_context_ty ctx; + } Tuple; + + struct { + expr_ty lower; + expr_ty upper; + expr_ty step; + } Slice; + + } v; + int lineno; + int col_offset; + int end_lineno; + int end_col_offset; +}; + +struct _comprehension { + expr_ty target; + expr_ty iter; + asdl_expr_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_stmt_seq *body; + } ExceptHandler; + + } v; + int lineno; + int col_offset; + int end_lineno; + int end_col_offset; +}; + +struct _arguments { + asdl_arg_seq *posonlyargs; + asdl_arg_seq *args; + arg_ty vararg; + asdl_arg_seq *kwonlyargs; + asdl_expr_seq *kw_defaults; + arg_ty kwarg; + asdl_expr_seq *defaults; +}; + +struct _arg { + identifier arg; + expr_ty annotation; + string type_comment; + int lineno; + int col_offset; + int end_lineno; + int end_col_offset; +}; + +struct _keyword { + identifier arg; + expr_ty value; + int lineno; + int col_offset; + int end_lineno; + int end_col_offset; +}; + +struct _alias { + identifier name; + identifier asname; + int lineno; + int col_offset; + int end_lineno; + int end_col_offset; +}; + +struct _withitem { + expr_ty context_expr; + expr_ty optional_vars; +}; + +struct _match_case { + pattern_ty pattern; + expr_ty guard; + asdl_stmt_seq *body; +}; + +enum _pattern_kind {MatchValue_kind=1, MatchSingleton_kind=2, + MatchSequence_kind=3, MatchMapping_kind=4, + MatchClass_kind=5, MatchStar_kind=6, MatchAs_kind=7, + MatchOr_kind=8}; +struct _pattern { + enum _pattern_kind kind; + union { + struct { + expr_ty value; + } MatchValue; + + struct { + constant value; + } MatchSingleton; + + struct { + asdl_pattern_seq *patterns; + } MatchSequence; + + struct { + asdl_expr_seq *keys; + asdl_pattern_seq *patterns; + identifier rest; + } MatchMapping; + + struct { + expr_ty cls; + asdl_pattern_seq *patterns; + asdl_identifier_seq *kwd_attrs; + asdl_pattern_seq *kwd_patterns; + } MatchClass; + + struct { + identifier name; + } MatchStar; + + struct { + pattern_ty pattern; + identifier name; + } MatchAs; + + struct { + asdl_pattern_seq *patterns; + } MatchOr; + + } v; + int lineno; + int col_offset; + int end_lineno; + int end_col_offset; +}; + +enum _type_ignore_kind {TypeIgnore_kind=1}; +struct _type_ignore { + enum _type_ignore_kind kind; + union { + struct { + int lineno; + string tag; + } TypeIgnore; + + } v; +}; + + +// Note: these macros affect function definitions, not only call sites. +mod_ty _PyAST_Module(asdl_stmt_seq * body, asdl_type_ignore_seq * type_ignores, + PyArena *arena); +mod_ty _PyAST_Interactive(asdl_stmt_seq * body, PyArena *arena); +mod_ty _PyAST_Expression(expr_ty body, PyArena *arena); +mod_ty _PyAST_FunctionType(asdl_expr_seq * argtypes, expr_ty returns, PyArena + *arena); +stmt_ty _PyAST_FunctionDef(identifier name, arguments_ty args, asdl_stmt_seq * + body, asdl_expr_seq * decorator_list, expr_ty + returns, string type_comment, int lineno, int + col_offset, int end_lineno, int end_col_offset, + PyArena *arena); +stmt_ty _PyAST_AsyncFunctionDef(identifier name, arguments_ty args, + asdl_stmt_seq * body, asdl_expr_seq * + decorator_list, expr_ty returns, string + type_comment, int lineno, int col_offset, int + end_lineno, int end_col_offset, PyArena *arena); +stmt_ty _PyAST_ClassDef(identifier name, asdl_expr_seq * bases, + asdl_keyword_seq * keywords, asdl_stmt_seq * body, + asdl_expr_seq * decorator_list, int lineno, int + col_offset, int end_lineno, int end_col_offset, PyArena + *arena); +stmt_ty _PyAST_Return(expr_ty value, int lineno, int col_offset, int + end_lineno, int end_col_offset, PyArena *arena); +stmt_ty _PyAST_Delete(asdl_expr_seq * targets, int lineno, int col_offset, int + end_lineno, int end_col_offset, PyArena *arena); +stmt_ty _PyAST_Assign(asdl_expr_seq * targets, expr_ty value, string + type_comment, int lineno, int col_offset, int end_lineno, + int end_col_offset, PyArena *arena); +stmt_ty _PyAST_AugAssign(expr_ty target, operator_ty op, expr_ty value, int + lineno, int col_offset, int end_lineno, int + end_col_offset, PyArena *arena); +stmt_ty _PyAST_AnnAssign(expr_ty target, expr_ty annotation, expr_ty value, int + simple, int lineno, int col_offset, int end_lineno, + int end_col_offset, PyArena *arena); +stmt_ty _PyAST_For(expr_ty target, expr_ty iter, asdl_stmt_seq * body, + asdl_stmt_seq * orelse, string type_comment, int lineno, int + col_offset, int end_lineno, int end_col_offset, PyArena + *arena); +stmt_ty _PyAST_AsyncFor(expr_ty target, expr_ty iter, asdl_stmt_seq * body, + asdl_stmt_seq * orelse, string type_comment, int + lineno, int col_offset, int end_lineno, int + end_col_offset, PyArena *arena); +stmt_ty _PyAST_While(expr_ty test, asdl_stmt_seq * body, asdl_stmt_seq * + orelse, int lineno, int col_offset, int end_lineno, int + end_col_offset, PyArena *arena); +stmt_ty _PyAST_If(expr_ty test, asdl_stmt_seq * body, asdl_stmt_seq * orelse, + int lineno, int col_offset, int end_lineno, int + end_col_offset, PyArena *arena); +stmt_ty _PyAST_With(asdl_withitem_seq * items, asdl_stmt_seq * body, string + type_comment, int lineno, int col_offset, int end_lineno, + int end_col_offset, PyArena *arena); +stmt_ty _PyAST_AsyncWith(asdl_withitem_seq * items, asdl_stmt_seq * body, + string type_comment, int lineno, int col_offset, int + end_lineno, int end_col_offset, PyArena *arena); +stmt_ty _PyAST_Match(expr_ty subject, asdl_match_case_seq * cases, int lineno, + int col_offset, int end_lineno, int end_col_offset, + PyArena *arena); +stmt_ty _PyAST_Raise(expr_ty exc, expr_ty cause, int lineno, int col_offset, + int end_lineno, int end_col_offset, PyArena *arena); +stmt_ty _PyAST_Try(asdl_stmt_seq * body, asdl_excepthandler_seq * handlers, + asdl_stmt_seq * orelse, asdl_stmt_seq * finalbody, int + lineno, int col_offset, int end_lineno, int end_col_offset, + PyArena *arena); +stmt_ty _PyAST_Assert(expr_ty test, expr_ty msg, int lineno, int col_offset, + int end_lineno, int end_col_offset, PyArena *arena); +stmt_ty _PyAST_Import(asdl_alias_seq * names, int lineno, int col_offset, int + end_lineno, int end_col_offset, PyArena *arena); +stmt_ty _PyAST_ImportFrom(identifier module, asdl_alias_seq * names, int level, + int lineno, int col_offset, int end_lineno, int + end_col_offset, PyArena *arena); +stmt_ty _PyAST_Global(asdl_identifier_seq * names, int lineno, int col_offset, + int end_lineno, int end_col_offset, PyArena *arena); +stmt_ty _PyAST_Nonlocal(asdl_identifier_seq * names, int lineno, int + col_offset, int end_lineno, int end_col_offset, PyArena + *arena); +stmt_ty _PyAST_Expr(expr_ty value, int lineno, int col_offset, int end_lineno, + int end_col_offset, PyArena *arena); +stmt_ty _PyAST_Pass(int lineno, int col_offset, int end_lineno, int + end_col_offset, PyArena *arena); +stmt_ty _PyAST_Break(int lineno, int col_offset, int end_lineno, int + end_col_offset, PyArena *arena); +stmt_ty _PyAST_Continue(int lineno, int col_offset, int end_lineno, int + end_col_offset, PyArena *arena); +expr_ty _PyAST_BoolOp(boolop_ty op, asdl_expr_seq * values, int lineno, int + col_offset, int end_lineno, int end_col_offset, PyArena + *arena); +expr_ty _PyAST_NamedExpr(expr_ty target, expr_ty value, int lineno, int + col_offset, int end_lineno, int end_col_offset, + PyArena *arena); +expr_ty _PyAST_BinOp(expr_ty left, operator_ty op, expr_ty right, int lineno, + int col_offset, int end_lineno, int end_col_offset, + PyArena *arena); +expr_ty _PyAST_UnaryOp(unaryop_ty op, expr_ty operand, int lineno, int + col_offset, int end_lineno, int end_col_offset, PyArena + *arena); +expr_ty _PyAST_Lambda(arguments_ty args, expr_ty body, int lineno, int + col_offset, int end_lineno, int end_col_offset, PyArena + *arena); +expr_ty _PyAST_IfExp(expr_ty test, expr_ty body, expr_ty orelse, int lineno, + int col_offset, int end_lineno, int end_col_offset, + PyArena *arena); +expr_ty _PyAST_Dict(asdl_expr_seq * keys, asdl_expr_seq * values, int lineno, + int col_offset, int end_lineno, int end_col_offset, PyArena + *arena); +expr_ty _PyAST_Set(asdl_expr_seq * elts, int lineno, int col_offset, int + end_lineno, int end_col_offset, PyArena *arena); +expr_ty _PyAST_ListComp(expr_ty elt, asdl_comprehension_seq * generators, int + lineno, int col_offset, int end_lineno, int + end_col_offset, PyArena *arena); +expr_ty _PyAST_SetComp(expr_ty elt, asdl_comprehension_seq * generators, int + lineno, int col_offset, int end_lineno, int + end_col_offset, PyArena *arena); +expr_ty _PyAST_DictComp(expr_ty key, expr_ty value, asdl_comprehension_seq * + generators, int lineno, int col_offset, int end_lineno, + int end_col_offset, PyArena *arena); +expr_ty _PyAST_GeneratorExp(expr_ty elt, asdl_comprehension_seq * generators, + int lineno, int col_offset, int end_lineno, int + end_col_offset, PyArena *arena); +expr_ty _PyAST_Await(expr_ty value, int lineno, int col_offset, int end_lineno, + int end_col_offset, PyArena *arena); +expr_ty _PyAST_Yield(expr_ty value, int lineno, int col_offset, int end_lineno, + int end_col_offset, PyArena *arena); +expr_ty _PyAST_YieldFrom(expr_ty value, int lineno, int col_offset, int + end_lineno, int end_col_offset, PyArena *arena); +expr_ty _PyAST_Compare(expr_ty left, asdl_int_seq * ops, asdl_expr_seq * + comparators, int lineno, int col_offset, int end_lineno, + int end_col_offset, PyArena *arena); +expr_ty _PyAST_Call(expr_ty func, asdl_expr_seq * args, asdl_keyword_seq * + keywords, int lineno, int col_offset, int end_lineno, int + end_col_offset, PyArena *arena); +expr_ty _PyAST_FormattedValue(expr_ty value, int conversion, expr_ty + format_spec, int lineno, int col_offset, int + end_lineno, int end_col_offset, PyArena *arena); +expr_ty _PyAST_JoinedStr(asdl_expr_seq * values, int lineno, int col_offset, + int end_lineno, int end_col_offset, PyArena *arena); +expr_ty _PyAST_Constant(constant value, string kind, int lineno, int + col_offset, int end_lineno, int end_col_offset, PyArena + *arena); +expr_ty _PyAST_Attribute(expr_ty value, identifier attr, expr_context_ty ctx, + int lineno, int col_offset, int end_lineno, int + end_col_offset, PyArena *arena); +expr_ty _PyAST_Subscript(expr_ty value, expr_ty slice, expr_context_ty ctx, int + lineno, int col_offset, int end_lineno, int + end_col_offset, PyArena *arena); +expr_ty _PyAST_Starred(expr_ty value, expr_context_ty ctx, int lineno, int + col_offset, int end_lineno, int end_col_offset, PyArena + *arena); +expr_ty _PyAST_Name(identifier id, expr_context_ty ctx, int lineno, int + col_offset, int end_lineno, int end_col_offset, PyArena + *arena); +expr_ty _PyAST_List(asdl_expr_seq * elts, expr_context_ty ctx, int lineno, int + col_offset, int end_lineno, int end_col_offset, PyArena + *arena); +expr_ty _PyAST_Tuple(asdl_expr_seq * elts, expr_context_ty ctx, int lineno, int + col_offset, int end_lineno, int end_col_offset, PyArena + *arena); +expr_ty _PyAST_Slice(expr_ty lower, expr_ty upper, expr_ty step, int lineno, + int col_offset, int end_lineno, int end_col_offset, + PyArena *arena); +comprehension_ty _PyAST_comprehension(expr_ty target, expr_ty iter, + asdl_expr_seq * ifs, int is_async, + PyArena *arena); +excepthandler_ty _PyAST_ExceptHandler(expr_ty type, identifier name, + asdl_stmt_seq * body, int lineno, int + col_offset, int end_lineno, int + end_col_offset, PyArena *arena); +arguments_ty _PyAST_arguments(asdl_arg_seq * posonlyargs, asdl_arg_seq * args, + arg_ty vararg, asdl_arg_seq * kwonlyargs, + asdl_expr_seq * kw_defaults, arg_ty kwarg, + asdl_expr_seq * defaults, PyArena *arena); +arg_ty _PyAST_arg(identifier arg, expr_ty annotation, string type_comment, int + lineno, int col_offset, int end_lineno, int end_col_offset, + PyArena *arena); +keyword_ty _PyAST_keyword(identifier arg, expr_ty value, int lineno, int + col_offset, int end_lineno, int end_col_offset, + PyArena *arena); +alias_ty _PyAST_alias(identifier name, identifier asname, int lineno, int + col_offset, int end_lineno, int end_col_offset, PyArena + *arena); +withitem_ty _PyAST_withitem(expr_ty context_expr, expr_ty optional_vars, + PyArena *arena); +match_case_ty _PyAST_match_case(pattern_ty pattern, expr_ty guard, + asdl_stmt_seq * body, PyArena *arena); +pattern_ty _PyAST_MatchValue(expr_ty value, int lineno, int col_offset, int + end_lineno, int end_col_offset, PyArena *arena); +pattern_ty _PyAST_MatchSingleton(constant value, int lineno, int col_offset, + int end_lineno, int end_col_offset, PyArena + *arena); +pattern_ty _PyAST_MatchSequence(asdl_pattern_seq * patterns, int lineno, int + col_offset, int end_lineno, int end_col_offset, + PyArena *arena); +pattern_ty _PyAST_MatchMapping(asdl_expr_seq * keys, asdl_pattern_seq * + patterns, identifier rest, int lineno, int + col_offset, int end_lineno, int end_col_offset, + PyArena *arena); +pattern_ty _PyAST_MatchClass(expr_ty cls, asdl_pattern_seq * patterns, + asdl_identifier_seq * kwd_attrs, asdl_pattern_seq + * kwd_patterns, int lineno, int col_offset, int + end_lineno, int end_col_offset, PyArena *arena); +pattern_ty _PyAST_MatchStar(identifier name, int lineno, int col_offset, int + end_lineno, int end_col_offset, PyArena *arena); +pattern_ty _PyAST_MatchAs(pattern_ty pattern, identifier name, int lineno, int + col_offset, int end_lineno, int end_col_offset, + PyArena *arena); +pattern_ty _PyAST_MatchOr(asdl_pattern_seq * patterns, int lineno, int + col_offset, int end_lineno, int end_col_offset, + PyArena *arena); +type_ignore_ty _PyAST_TypeIgnore(int lineno, string tag, PyArena *arena); + + +PyObject* PyAST_mod2obj(mod_ty t); +mod_ty PyAST_obj2mod(PyObject* ast, PyArena* arena, int mode); +int PyAST_Check(PyObject* obj); + +extern int _PyAST_Validate(mod_ty); + +/* _PyAST_ExprAsUnicode is defined in ast_unparse.c */ +extern PyObject* _PyAST_ExprAsUnicode(expr_ty); + +/* Return the borrowed reference to the first literal string in the + sequence of statements or NULL if it doesn't start from a literal string. + Doesn't set exception. */ +extern PyObject* _PyAST_GetDocString(asdl_stmt_seq *); + +#ifdef __cplusplus +} +#endif +#endif /* !Py_INTERNAL_AST_H */ diff --git a/.ci/python_dependencies_wins/include/internal/pycore_ast_state.h b/.ci/python_dependencies_wins/include/internal/pycore_ast_state.h new file mode 100644 index 00000000..9080f0f8 --- /dev/null +++ b/.ci/python_dependencies_wins/include/internal/pycore_ast_state.h @@ -0,0 +1,255 @@ +// File automatically generated by Parser/asdl_c.py. + +#ifndef Py_INTERNAL_AST_STATE_H +#define Py_INTERNAL_AST_STATE_H +#ifdef __cplusplus +extern "C" { +#endif + +#ifndef Py_BUILD_CORE +# error "this header requires Py_BUILD_CORE define" +#endif + +struct ast_state { + int initialized; + PyObject *AST_type; + PyObject *Add_singleton; + PyObject *Add_type; + PyObject *And_singleton; + PyObject *And_type; + PyObject *AnnAssign_type; + PyObject *Assert_type; + PyObject *Assign_type; + PyObject *AsyncFor_type; + PyObject *AsyncFunctionDef_type; + PyObject *AsyncWith_type; + PyObject *Attribute_type; + PyObject *AugAssign_type; + PyObject *Await_type; + PyObject *BinOp_type; + PyObject *BitAnd_singleton; + PyObject *BitAnd_type; + PyObject *BitOr_singleton; + PyObject *BitOr_type; + PyObject *BitXor_singleton; + PyObject *BitXor_type; + PyObject *BoolOp_type; + PyObject *Break_type; + PyObject *Call_type; + PyObject *ClassDef_type; + PyObject *Compare_type; + PyObject *Constant_type; + PyObject *Continue_type; + PyObject *Del_singleton; + PyObject *Del_type; + PyObject *Delete_type; + PyObject *DictComp_type; + PyObject *Dict_type; + PyObject *Div_singleton; + PyObject *Div_type; + PyObject *Eq_singleton; + PyObject *Eq_type; + PyObject *ExceptHandler_type; + PyObject *Expr_type; + PyObject *Expression_type; + PyObject *FloorDiv_singleton; + PyObject *FloorDiv_type; + PyObject *For_type; + PyObject *FormattedValue_type; + PyObject *FunctionDef_type; + PyObject *FunctionType_type; + PyObject *GeneratorExp_type; + PyObject *Global_type; + PyObject *GtE_singleton; + PyObject *GtE_type; + PyObject *Gt_singleton; + PyObject *Gt_type; + PyObject *IfExp_type; + PyObject *If_type; + PyObject *ImportFrom_type; + PyObject *Import_type; + PyObject *In_singleton; + PyObject *In_type; + PyObject *Interactive_type; + PyObject *Invert_singleton; + PyObject *Invert_type; + PyObject *IsNot_singleton; + PyObject *IsNot_type; + PyObject *Is_singleton; + PyObject *Is_type; + PyObject *JoinedStr_type; + PyObject *LShift_singleton; + PyObject *LShift_type; + PyObject *Lambda_type; + PyObject *ListComp_type; + PyObject *List_type; + PyObject *Load_singleton; + PyObject *Load_type; + PyObject *LtE_singleton; + PyObject *LtE_type; + PyObject *Lt_singleton; + PyObject *Lt_type; + PyObject *MatMult_singleton; + PyObject *MatMult_type; + PyObject *MatchAs_type; + PyObject *MatchClass_type; + PyObject *MatchMapping_type; + PyObject *MatchOr_type; + PyObject *MatchSequence_type; + PyObject *MatchSingleton_type; + PyObject *MatchStar_type; + PyObject *MatchValue_type; + PyObject *Match_type; + PyObject *Mod_singleton; + PyObject *Mod_type; + PyObject *Module_type; + PyObject *Mult_singleton; + PyObject *Mult_type; + PyObject *Name_type; + PyObject *NamedExpr_type; + PyObject *Nonlocal_type; + PyObject *NotEq_singleton; + PyObject *NotEq_type; + PyObject *NotIn_singleton; + PyObject *NotIn_type; + PyObject *Not_singleton; + PyObject *Not_type; + PyObject *Or_singleton; + PyObject *Or_type; + PyObject *Pass_type; + PyObject *Pow_singleton; + PyObject *Pow_type; + PyObject *RShift_singleton; + PyObject *RShift_type; + PyObject *Raise_type; + PyObject *Return_type; + PyObject *SetComp_type; + PyObject *Set_type; + PyObject *Slice_type; + PyObject *Starred_type; + PyObject *Store_singleton; + PyObject *Store_type; + PyObject *Sub_singleton; + PyObject *Sub_type; + PyObject *Subscript_type; + PyObject *Try_type; + PyObject *Tuple_type; + PyObject *TypeIgnore_type; + PyObject *UAdd_singleton; + PyObject *UAdd_type; + PyObject *USub_singleton; + PyObject *USub_type; + PyObject *UnaryOp_type; + PyObject *While_type; + PyObject *With_type; + PyObject *YieldFrom_type; + PyObject *Yield_type; + PyObject *__dict__; + PyObject *__doc__; + PyObject *__match_args__; + PyObject *__module__; + PyObject *_attributes; + PyObject *_fields; + PyObject *alias_type; + PyObject *annotation; + PyObject *arg; + PyObject *arg_type; + PyObject *args; + PyObject *argtypes; + PyObject *arguments_type; + PyObject *asname; + PyObject *ast; + PyObject *attr; + PyObject *bases; + PyObject *body; + PyObject *boolop_type; + PyObject *cases; + PyObject *cause; + PyObject *cls; + PyObject *cmpop_type; + PyObject *col_offset; + PyObject *comparators; + PyObject *comprehension_type; + PyObject *context_expr; + PyObject *conversion; + PyObject *ctx; + PyObject *decorator_list; + PyObject *defaults; + PyObject *elt; + PyObject *elts; + PyObject *end_col_offset; + PyObject *end_lineno; + PyObject *exc; + PyObject *excepthandler_type; + PyObject *expr_context_type; + PyObject *expr_type; + PyObject *finalbody; + PyObject *format_spec; + PyObject *func; + PyObject *generators; + PyObject *guard; + PyObject *handlers; + PyObject *id; + PyObject *ifs; + PyObject *is_async; + PyObject *items; + PyObject *iter; + PyObject *key; + PyObject *keys; + PyObject *keyword_type; + PyObject *keywords; + PyObject *kind; + PyObject *kw_defaults; + PyObject *kwarg; + PyObject *kwd_attrs; + PyObject *kwd_patterns; + PyObject *kwonlyargs; + PyObject *left; + PyObject *level; + PyObject *lineno; + PyObject *lower; + PyObject *match_case_type; + PyObject *mod_type; + PyObject *module; + PyObject *msg; + PyObject *name; + PyObject *names; + PyObject *op; + PyObject *operand; + PyObject *operator_type; + PyObject *ops; + PyObject *optional_vars; + PyObject *orelse; + PyObject *pattern; + PyObject *pattern_type; + PyObject *patterns; + PyObject *posonlyargs; + PyObject *rest; + PyObject *returns; + PyObject *right; + PyObject *simple; + PyObject *slice; + PyObject *step; + PyObject *stmt_type; + PyObject *subject; + PyObject *tag; + PyObject *target; + PyObject *targets; + PyObject *test; + PyObject *type; + PyObject *type_comment; + PyObject *type_ignore_type; + PyObject *type_ignores; + PyObject *unaryop_type; + PyObject *upper; + PyObject *value; + PyObject *values; + PyObject *vararg; + PyObject *withitem_type; +}; + +#ifdef __cplusplus +} +#endif +#endif /* !Py_INTERNAL_AST_STATE_H */ + diff --git a/.ci/python_dependencies_wins/include/internal/pycore_atomic.h b/.ci/python_dependencies_wins/include/internal/pycore_atomic.h new file mode 100644 index 00000000..34536f5f --- /dev/null +++ b/.ci/python_dependencies_wins/include/internal/pycore_atomic.h @@ -0,0 +1,557 @@ +#ifndef Py_ATOMIC_H +#define Py_ATOMIC_H +#ifdef __cplusplus +extern "C" { +#endif + +#ifndef Py_BUILD_CORE +# error "this header requires Py_BUILD_CORE define" +#endif + +#include "dynamic_annotations.h" /* _Py_ANNOTATE_MEMORY_ORDER */ +#include "pyconfig.h" + +#ifdef HAVE_STD_ATOMIC +# include +#endif + + +#if defined(_MSC_VER) +#include +#if defined(_M_IX86) || defined(_M_X64) +# include +#endif +#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 and clang +#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 measure 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)->_value), (__int64)(NEW_VAL)); \ + break; \ + case _Py_memory_order_release: \ + _InterlockedExchange64_HLERelease((__int64 volatile*)&((ATOMIC_VAL)->_value), (__int64)(NEW_VAL)); \ + break; \ + default: \ + _InterlockedExchange64((__int64 volatile*)&((ATOMIC_VAL)->_value), (__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)->_value), (int)(NEW_VAL)); \ + break; \ + case _Py_memory_order_release: \ + _InterlockedExchange_HLERelease((volatile long*)&((ATOMIC_VAL)->_value), (int)(NEW_VAL)); \ + break; \ + default: \ + _InterlockedExchange((volatile long*)&((ATOMIC_VAL)->_value), (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_impl(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; +} + +#define _Py_atomic_load_64bit(ATOMIC_VAL, ORDER) \ + _Py_atomic_load_64bit_impl((volatile uintptr_t*)&((ATOMIC_VAL)->_value), (ORDER)) + +#else +#define _Py_atomic_load_64bit(ATOMIC_VAL, ORDER) ((ATOMIC_VAL)->_value) +#endif + +inline int _Py_atomic_load_32bit_impl(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_load_32bit(ATOMIC_VAL, ORDER) \ + _Py_atomic_load_32bit_impl((volatile int*)&((ATOMIC_VAL)->_value), (ORDER)) + +#define _Py_atomic_store_explicit(ATOMIC_VAL, NEW_VAL, ORDER) \ + if (sizeof((ATOMIC_VAL)->_value) == 8) { \ + _Py_atomic_store_64bit((ATOMIC_VAL), NEW_VAL, ORDER) } else { \ + _Py_atomic_store_32bit((ATOMIC_VAL), NEW_VAL, ORDER) } + +#define _Py_atomic_load_explicit(ATOMIC_VAL, ORDER) \ + ( \ + sizeof((ATOMIC_VAL)->_value) == 8 ? \ + _Py_atomic_load_64bit((ATOMIC_VAL), ORDER) : \ + _Py_atomic_load_32bit((ATOMIC_VAL), 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)->_value), (__int64)NEW_VAL); \ + break; \ + case _Py_memory_order_release: \ + _InterlockedExchange64_rel((__int64 volatile*)&((ATOMIC_VAL)->_value), (__int64)NEW_VAL); \ + break; \ + default: \ + _InterlockedExchange64((__int64 volatile*)&((ATOMIC_VAL)->_value), (__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)->_value), (int)NEW_VAL); \ + break; \ + case _Py_memory_order_release: \ + _InterlockedExchange_rel((volatile long*)&((ATOMIC_VAL)->_value), (int)NEW_VAL); \ + break; \ + default: \ + _InterlockedExchange((volatile long*)&((ATOMIC_VAL)->_value), (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_impl(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; +} + +#define _Py_atomic_load_64bit(ATOMIC_VAL, ORDER) \ + _Py_atomic_load_64bit_impl((volatile uintptr_t*)&((ATOMIC_VAL)->_value), (ORDER)) + +#else +#define _Py_atomic_load_64bit(ATOMIC_VAL, ORDER) ((ATOMIC_VAL)->_value) +#endif + +inline int _Py_atomic_load_32bit_impl(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_load_32bit(ATOMIC_VAL, ORDER) \ + _Py_atomic_load_32bit_impl((volatile int*)&((ATOMIC_VAL)->_value), (ORDER)) + +#define _Py_atomic_store_explicit(ATOMIC_VAL, NEW_VAL, ORDER) \ + if (sizeof((ATOMIC_VAL)->_value) == 8) { \ + _Py_atomic_store_64bit((ATOMIC_VAL), (NEW_VAL), (ORDER)) } else { \ + _Py_atomic_store_32bit((ATOMIC_VAL), (NEW_VAL), (ORDER)) } + +#define _Py_atomic_load_explicit(ATOMIC_VAL, ORDER) \ + ( \ + sizeof((ATOMIC_VAL)->_value) == 8 ? \ + _Py_atomic_load_64bit((ATOMIC_VAL), (ORDER)) : \ + _Py_atomic_load_32bit((ATOMIC_VAL), (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) + +#ifdef __cplusplus +} +#endif +#endif /* Py_ATOMIC_H */ diff --git a/.ci/python_dependencies_wins/include/internal/pycore_atomic_funcs.h b/.ci/python_dependencies_wins/include/internal/pycore_atomic_funcs.h new file mode 100644 index 00000000..a59b88f6 --- /dev/null +++ b/.ci/python_dependencies_wins/include/internal/pycore_atomic_funcs.h @@ -0,0 +1,94 @@ +/* Atomic functions: similar to pycore_atomic.h, but don't need + to declare variables as atomic. + + Py_ssize_t type: + + * value = _Py_atomic_size_get(&var) + * _Py_atomic_size_set(&var, value) + + Use sequentially-consistent ordering (__ATOMIC_SEQ_CST memory order): + enforce total ordering with all other atomic functions. +*/ +#ifndef Py_ATOMIC_FUNC_H +#define Py_ATOMIC_FUNC_H +#ifdef __cplusplus +extern "C" { +#endif + +#ifndef Py_BUILD_CORE +# error "this header requires Py_BUILD_CORE define" +#endif + +#if defined(_MSC_VER) +# include // _InterlockedExchange() +#endif + + +// Use builtin atomic operations in GCC >= 4.7 and clang +#ifdef HAVE_BUILTIN_ATOMIC + +static inline Py_ssize_t _Py_atomic_size_get(Py_ssize_t *var) +{ + return __atomic_load_n(var, __ATOMIC_SEQ_CST); +} + +static inline void _Py_atomic_size_set(Py_ssize_t *var, Py_ssize_t value) +{ + __atomic_store_n(var, value, __ATOMIC_SEQ_CST); +} + +#elif defined(_MSC_VER) + +static inline Py_ssize_t _Py_atomic_size_get(Py_ssize_t *var) +{ +#if SIZEOF_VOID_P == 8 + Py_BUILD_ASSERT(sizeof(__int64) == sizeof(*var)); + volatile __int64 *volatile_var = (volatile __int64 *)var; + __int64 old; + do { + old = *volatile_var; + } while(_InterlockedCompareExchange64(volatile_var, old, old) != old); +#else + Py_BUILD_ASSERT(sizeof(long) == sizeof(*var)); + volatile long *volatile_var = (volatile long *)var; + long old; + do { + old = *volatile_var; + } while(_InterlockedCompareExchange(volatile_var, old, old) != old); +#endif + return old; +} + +static inline void _Py_atomic_size_set(Py_ssize_t *var, Py_ssize_t value) +{ +#if SIZEOF_VOID_P == 8 + Py_BUILD_ASSERT(sizeof(__int64) == sizeof(*var)); + volatile __int64 *volatile_var = (volatile __int64 *)var; + _InterlockedExchange64(volatile_var, value); +#else + Py_BUILD_ASSERT(sizeof(long) == sizeof(*var)); + volatile long *volatile_var = (volatile long *)var; + _InterlockedExchange(volatile_var, value); +#endif +} + +#else +// Fallback implementation using volatile + +static inline Py_ssize_t _Py_atomic_size_get(Py_ssize_t *var) +{ + volatile Py_ssize_t *volatile_var = (volatile Py_ssize_t *)var; + return *volatile_var; +} + +static inline void _Py_atomic_size_set(Py_ssize_t *var, Py_ssize_t value) +{ + volatile Py_ssize_t *volatile_var = (volatile Py_ssize_t *)var; + *volatile_var = value; +} +#endif + +#ifdef __cplusplus +} +#endif +#endif /* Py_ATOMIC_FUNC_H */ diff --git a/.ci/python_dependencies_wins/include/internal/pycore_bitutils.h b/.ci/python_dependencies_wins/include/internal/pycore_bitutils.h new file mode 100644 index 00000000..41bd024e --- /dev/null +++ b/.ci/python_dependencies_wins/include/internal/pycore_bitutils.h @@ -0,0 +1,176 @@ +/* Bit and bytes utilities. + + Bytes swap functions, reverse order of bytes: + + - _Py_bswap16(uint16_t) + - _Py_bswap32(uint32_t) + - _Py_bswap64(uint64_t) +*/ + +#ifndef Py_INTERNAL_BITUTILS_H +#define Py_INTERNAL_BITUTILS_H +#ifdef __cplusplus +extern "C" { +#endif + +#ifndef Py_BUILD_CORE +# error "this header requires Py_BUILD_CORE define" +#endif + +#if defined(__GNUC__) \ + && ((__GNUC__ >= 5) || (__GNUC__ == 4) && (__GNUC_MINOR__ >= 8)) + /* __builtin_bswap16() is available since GCC 4.8, + __builtin_bswap32() is available since GCC 4.3, + __builtin_bswap64() is available since GCC 4.3. */ +# define _PY_HAVE_BUILTIN_BSWAP +#endif + +#ifdef _MSC_VER + /* Get _byteswap_ushort(), _byteswap_ulong(), _byteswap_uint64() */ +# include +#endif + +static inline uint16_t +_Py_bswap16(uint16_t word) +{ +#if defined(_PY_HAVE_BUILTIN_BSWAP) || _Py__has_builtin(__builtin_bswap16) + return __builtin_bswap16(word); +#elif defined(_MSC_VER) + Py_BUILD_ASSERT(sizeof(word) == sizeof(unsigned short)); + return _byteswap_ushort(word); +#else + // Portable implementation which doesn't rely on circular bit shift + return ( ((word & UINT16_C(0x00FF)) << 8) + | ((word & UINT16_C(0xFF00)) >> 8)); +#endif +} + +static inline uint32_t +_Py_bswap32(uint32_t word) +{ +#if defined(_PY_HAVE_BUILTIN_BSWAP) || _Py__has_builtin(__builtin_bswap32) + return __builtin_bswap32(word); +#elif defined(_MSC_VER) + Py_BUILD_ASSERT(sizeof(word) == sizeof(unsigned long)); + return _byteswap_ulong(word); +#else + // Portable implementation which doesn't rely on circular bit shift + return ( ((word & UINT32_C(0x000000FF)) << 24) + | ((word & UINT32_C(0x0000FF00)) << 8) + | ((word & UINT32_C(0x00FF0000)) >> 8) + | ((word & UINT32_C(0xFF000000)) >> 24)); +#endif +} + +static inline uint64_t +_Py_bswap64(uint64_t word) +{ +#if defined(_PY_HAVE_BUILTIN_BSWAP) || _Py__has_builtin(__builtin_bswap64) + return __builtin_bswap64(word); +#elif defined(_MSC_VER) + return _byteswap_uint64(word); +#else + // Portable implementation which doesn't rely on circular bit shift + return ( ((word & UINT64_C(0x00000000000000FF)) << 56) + | ((word & UINT64_C(0x000000000000FF00)) << 40) + | ((word & UINT64_C(0x0000000000FF0000)) << 24) + | ((word & UINT64_C(0x00000000FF000000)) << 8) + | ((word & UINT64_C(0x000000FF00000000)) >> 8) + | ((word & UINT64_C(0x0000FF0000000000)) >> 24) + | ((word & UINT64_C(0x00FF000000000000)) >> 40) + | ((word & UINT64_C(0xFF00000000000000)) >> 56)); +#endif +} + + +// Population count: count the number of 1's in 'x' +// (number of bits set to 1), also known as the hamming weight. +// +// Implementation note. CPUID is not used, to test if x86 POPCNT instruction +// can be used, to keep the implementation simple. For example, Visual Studio +// __popcnt() is not used this reason. The clang and GCC builtin function can +// use the x86 POPCNT instruction if the target architecture has SSE4a or +// newer. +static inline int +_Py_popcount32(uint32_t x) +{ +#if (defined(__clang__) || defined(__GNUC__)) + +#if SIZEOF_INT >= 4 + Py_BUILD_ASSERT(sizeof(x) <= sizeof(unsigned int)); + return __builtin_popcount(x); +#else + // The C standard guarantees that unsigned long will always be big enough + // to hold a uint32_t value without losing information. + Py_BUILD_ASSERT(sizeof(x) <= sizeof(unsigned long)); + return __builtin_popcountl(x); +#endif + +#else + // 32-bit SWAR (SIMD Within A Register) popcount + + // Binary: 0 1 0 1 ... + const uint32_t M1 = 0x55555555; + // Binary: 00 11 00 11. .. + const uint32_t M2 = 0x33333333; + // Binary: 0000 1111 0000 1111 ... + const uint32_t M4 = 0x0F0F0F0F; + // 256**4 + 256**3 + 256**2 + 256**1 + const uint32_t SUM = 0x01010101; + + // Put count of each 2 bits into those 2 bits + x = x - ((x >> 1) & M1); + // Put count of each 4 bits into those 4 bits + x = (x & M2) + ((x >> 2) & M2); + // Put count of each 8 bits into those 8 bits + x = (x + (x >> 4)) & M4; + // Sum of the 4 byte counts + return (uint32_t)((uint64_t)x * (uint64_t)SUM) >> 24; +#endif +} + + +// Return the index of the most significant 1 bit in 'x'. This is the smallest +// integer k such that x < 2**k. Equivalent to floor(log2(x)) + 1 for x != 0. +static inline int +_Py_bit_length(unsigned long x) +{ +#if (defined(__clang__) || defined(__GNUC__)) + if (x != 0) { + // __builtin_clzl() is available since GCC 3.4. + // Undefined behavior for x == 0. + return (int)sizeof(unsigned long) * 8 - __builtin_clzl(x); + } + else { + return 0; + } +#elif defined(_MSC_VER) + // _BitScanReverse() is documented to search 32 bits. + Py_BUILD_ASSERT(sizeof(unsigned long) <= 4); + unsigned long msb; + if (_BitScanReverse(&msb, x)) { + return (int)msb + 1; + } + else { + return 0; + } +#else + const int BIT_LENGTH_TABLE[32] = { + 0, 1, 2, 2, 3, 3, 3, 3, 4, 4, 4, 4, 4, 4, 4, 4, + 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5 + }; + int msb = 0; + while (x >= 32) { + msb += 6; + x >>= 6; + } + msb += BIT_LENGTH_TABLE[x]; + return msb; +#endif +} + + +#ifdef __cplusplus +} +#endif +#endif /* !Py_INTERNAL_BITUTILS_H */ diff --git a/.ci/python_dependencies_wins/include/internal/pycore_blocks_output_buffer.h b/.ci/python_dependencies_wins/include/internal/pycore_blocks_output_buffer.h new file mode 100644 index 00000000..8e8daedb --- /dev/null +++ b/.ci/python_dependencies_wins/include/internal/pycore_blocks_output_buffer.h @@ -0,0 +1,317 @@ +/* + _BlocksOutputBuffer is used to maintain an output buffer + that has unpredictable size. Suitable for compression/decompression + API (bz2/lzma/zlib) that has stream->next_out and stream->avail_out: + + stream->next_out: point to the next output position. + stream->avail_out: the number of available bytes left in the buffer. + + It maintains a list of bytes object, so there is no overhead of resizing + the buffer. + + Usage: + + 1, Initialize the struct instance like this: + _BlocksOutputBuffer buffer = {.list = NULL}; + Set .list to NULL for _BlocksOutputBuffer_OnError() + + 2, Initialize the buffer use one of these functions: + _BlocksOutputBuffer_InitAndGrow() + _BlocksOutputBuffer_InitWithSize() + + 3, If (avail_out == 0), grow the buffer: + _BlocksOutputBuffer_Grow() + + 4, Get the current outputted data size: + _BlocksOutputBuffer_GetDataSize() + + 5, Finish the buffer, and return a bytes object: + _BlocksOutputBuffer_Finish() + + 6, Clean up the buffer when an error occurred: + _BlocksOutputBuffer_OnError() +*/ + +#ifndef Py_INTERNAL_BLOCKS_OUTPUT_BUFFER_H +#define Py_INTERNAL_BLOCKS_OUTPUT_BUFFER_H +#ifdef __cplusplus +extern "C" { +#endif + +#include "Python.h" + +typedef struct { + // List of bytes objects + PyObject *list; + // Number of whole allocated size + Py_ssize_t allocated; + // Max length of the buffer, negative number means unlimited length. + Py_ssize_t max_length; +} _BlocksOutputBuffer; + +static const char unable_allocate_msg[] = "Unable to allocate output buffer."; + +/* In 32-bit build, the max block size should <= INT32_MAX. */ +#define OUTPUT_BUFFER_MAX_BLOCK_SIZE (256*1024*1024) + +/* Block size sequence */ +#define KB (1024) +#define MB (1024*1024) +static const Py_ssize_t BUFFER_BLOCK_SIZE[] = + { 32*KB, 64*KB, 256*KB, 1*MB, 4*MB, 8*MB, 16*MB, 16*MB, + 32*MB, 32*MB, 32*MB, 32*MB, 64*MB, 64*MB, 128*MB, 128*MB, + OUTPUT_BUFFER_MAX_BLOCK_SIZE }; +#undef KB +#undef MB + +/* According to the block sizes defined by BUFFER_BLOCK_SIZE, the whole + allocated size growth step is: + 1 32 KB +32 KB + 2 96 KB +64 KB + 3 352 KB +256 KB + 4 1.34 MB +1 MB + 5 5.34 MB +4 MB + 6 13.34 MB +8 MB + 7 29.34 MB +16 MB + 8 45.34 MB +16 MB + 9 77.34 MB +32 MB + 10 109.34 MB +32 MB + 11 141.34 MB +32 MB + 12 173.34 MB +32 MB + 13 237.34 MB +64 MB + 14 301.34 MB +64 MB + 15 429.34 MB +128 MB + 16 557.34 MB +128 MB + 17 813.34 MB +256 MB + 18 1069.34 MB +256 MB + 19 1325.34 MB +256 MB + 20 1581.34 MB +256 MB + 21 1837.34 MB +256 MB + 22 2093.34 MB +256 MB + ... +*/ + +/* Initialize the buffer, and grow the buffer. + + max_length: Max length of the buffer, -1 for unlimited length. + + On success, return allocated size (>=0) + On failure, return -1 +*/ +static inline Py_ssize_t +_BlocksOutputBuffer_InitAndGrow(_BlocksOutputBuffer *buffer, + const Py_ssize_t max_length, + void **next_out) +{ + PyObject *b; + Py_ssize_t block_size; + + // ensure .list was set to NULL + assert(buffer->list == NULL); + + // get block size + if (0 <= max_length && max_length < BUFFER_BLOCK_SIZE[0]) { + block_size = max_length; + } else { + block_size = BUFFER_BLOCK_SIZE[0]; + } + + // the first block + b = PyBytes_FromStringAndSize(NULL, block_size); + if (b == NULL) { + return -1; + } + + // create the list + buffer->list = PyList_New(1); + if (buffer->list == NULL) { + Py_DECREF(b); + return -1; + } + PyList_SET_ITEM(buffer->list, 0, b); + + // set variables + buffer->allocated = block_size; + buffer->max_length = max_length; + + *next_out = PyBytes_AS_STRING(b); + return block_size; +} + +/* Initialize the buffer, with an initial size. + + Check block size limit in the outer wrapper function. For example, some libs + accept UINT32_MAX as the maximum block size, then init_size should <= it. + + On success, return allocated size (>=0) + On failure, return -1 +*/ +static inline Py_ssize_t +_BlocksOutputBuffer_InitWithSize(_BlocksOutputBuffer *buffer, + const Py_ssize_t init_size, + void **next_out) +{ + PyObject *b; + + // ensure .list was set to NULL + assert(buffer->list == NULL); + + // the first block + b = PyBytes_FromStringAndSize(NULL, init_size); + if (b == NULL) { + PyErr_SetString(PyExc_MemoryError, unable_allocate_msg); + return -1; + } + + // create the list + buffer->list = PyList_New(1); + if (buffer->list == NULL) { + Py_DECREF(b); + return -1; + } + PyList_SET_ITEM(buffer->list, 0, b); + + // set variables + buffer->allocated = init_size; + buffer->max_length = -1; + + *next_out = PyBytes_AS_STRING(b); + return init_size; +} + +/* Grow the buffer. The avail_out must be 0, please check it before calling. + + On success, return allocated size (>=0) + On failure, return -1 +*/ +static inline Py_ssize_t +_BlocksOutputBuffer_Grow(_BlocksOutputBuffer *buffer, + void **next_out, + const Py_ssize_t avail_out) +{ + PyObject *b; + const Py_ssize_t list_len = Py_SIZE(buffer->list); + Py_ssize_t block_size; + + // ensure no gaps in the data + if (avail_out != 0) { + PyErr_SetString(PyExc_SystemError, + "avail_out is non-zero in _BlocksOutputBuffer_Grow()."); + return -1; + } + + // get block size + if (list_len < (Py_ssize_t) Py_ARRAY_LENGTH(BUFFER_BLOCK_SIZE)) { + block_size = BUFFER_BLOCK_SIZE[list_len]; + } else { + block_size = BUFFER_BLOCK_SIZE[Py_ARRAY_LENGTH(BUFFER_BLOCK_SIZE) - 1]; + } + + // check max_length + if (buffer->max_length >= 0) { + // if (rest == 0), should not grow the buffer. + Py_ssize_t rest = buffer->max_length - buffer->allocated; + assert(rest > 0); + + // block_size of the last block + if (block_size > rest) { + block_size = rest; + } + } + + // check buffer->allocated overflow + if (block_size > PY_SSIZE_T_MAX - buffer->allocated) { + PyErr_SetString(PyExc_MemoryError, unable_allocate_msg); + return -1; + } + + // create the block + b = PyBytes_FromStringAndSize(NULL, block_size); + if (b == NULL) { + PyErr_SetString(PyExc_MemoryError, unable_allocate_msg); + return -1; + } + if (PyList_Append(buffer->list, b) < 0) { + Py_DECREF(b); + return -1; + } + Py_DECREF(b); + + // set variables + buffer->allocated += block_size; + + *next_out = PyBytes_AS_STRING(b); + return block_size; +} + +/* Return the current outputted data size. */ +static inline Py_ssize_t +_BlocksOutputBuffer_GetDataSize(_BlocksOutputBuffer *buffer, + const Py_ssize_t avail_out) +{ + return buffer->allocated - avail_out; +} + +/* Finish the buffer. + + Return a bytes object on success + Return NULL on failure +*/ +static inline PyObject * +_BlocksOutputBuffer_Finish(_BlocksOutputBuffer *buffer, + const Py_ssize_t avail_out) +{ + PyObject *result, *block; + const Py_ssize_t list_len = Py_SIZE(buffer->list); + + // fast path for single block + if ((list_len == 1 && avail_out == 0) || + (list_len == 2 && Py_SIZE(PyList_GET_ITEM(buffer->list, 1)) == avail_out)) + { + block = PyList_GET_ITEM(buffer->list, 0); + Py_INCREF(block); + + Py_CLEAR(buffer->list); + return block; + } + + // final bytes object + result = PyBytes_FromStringAndSize(NULL, buffer->allocated - avail_out); + if (result == NULL) { + PyErr_SetString(PyExc_MemoryError, unable_allocate_msg); + return NULL; + } + + // memory copy + if (list_len > 0) { + char *posi = PyBytes_AS_STRING(result); + + // blocks except the last one + Py_ssize_t i = 0; + for (; i < list_len-1; i++) { + block = PyList_GET_ITEM(buffer->list, i); + memcpy(posi, PyBytes_AS_STRING(block), Py_SIZE(block)); + posi += Py_SIZE(block); + } + // the last block + block = PyList_GET_ITEM(buffer->list, i); + memcpy(posi, PyBytes_AS_STRING(block), Py_SIZE(block) - avail_out); + } else { + assert(Py_SIZE(result) == 0); + } + + Py_CLEAR(buffer->list); + return result; +} + +/* Clean up the buffer when an error occurred. */ +static inline void +_BlocksOutputBuffer_OnError(_BlocksOutputBuffer *buffer) +{ + Py_CLEAR(buffer->list); +} + +#ifdef __cplusplus +} +#endif +#endif /* Py_INTERNAL_BLOCKS_OUTPUT_BUFFER_H */ \ No newline at end of file diff --git a/.ci/python_dependencies_wins/include/internal/pycore_bytes_methods.h b/.ci/python_dependencies_wins/include/internal/pycore_bytes_methods.h new file mode 100644 index 00000000..cc3a303f --- /dev/null +++ b/.ci/python_dependencies_wins/include/internal/pycore_bytes_methods.h @@ -0,0 +1,73 @@ +#ifndef Py_LIMITED_API +#ifndef Py_BYTES_CTYPE_H +#define Py_BYTES_CTYPE_H + +#ifndef Py_BUILD_CORE +# error "this header requires Py_BUILD_CORE define" +#endif + +/* + * 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/.ci/python_dependencies_wins/include/internal/pycore_call.h b/.ci/python_dependencies_wins/include/internal/pycore_call.h new file mode 100644 index 00000000..6b301264 --- /dev/null +++ b/.ci/python_dependencies_wins/include/internal/pycore_call.h @@ -0,0 +1,39 @@ +#ifndef Py_INTERNAL_CALL_H +#define Py_INTERNAL_CALL_H +#ifdef __cplusplus +extern "C" { +#endif + +#ifndef Py_BUILD_CORE +# error "this header requires Py_BUILD_CORE define" +#endif + +PyAPI_FUNC(PyObject *) _PyObject_Call_Prepend( + PyThreadState *tstate, + PyObject *callable, + PyObject *obj, + PyObject *args, + PyObject *kwargs); + +PyAPI_FUNC(PyObject *) _PyObject_FastCallDictTstate( + PyThreadState *tstate, + PyObject *callable, + PyObject *const *args, + size_t nargsf, + PyObject *kwargs); + +PyAPI_FUNC(PyObject *) _PyObject_Call( + PyThreadState *tstate, + PyObject *callable, + PyObject *args, + PyObject *kwargs); + +static inline PyObject * +_PyObject_CallNoArgTstate(PyThreadState *tstate, PyObject *func) { + return _PyObject_VectorcallTstate(tstate, func, NULL, 0, NULL); +} + +#ifdef __cplusplus +} +#endif +#endif /* !Py_INTERNAL_CALL_H */ diff --git a/.ci/python_dependencies_wins/include/internal/pycore_ceval.h b/.ci/python_dependencies_wins/include/internal/pycore_ceval.h new file mode 100644 index 00000000..be534a3c --- /dev/null +++ b/.ci/python_dependencies_wins/include/internal/pycore_ceval.h @@ -0,0 +1,114 @@ +#ifndef Py_INTERNAL_CEVAL_H +#define Py_INTERNAL_CEVAL_H +#ifdef __cplusplus +extern "C" { +#endif + +#ifndef Py_BUILD_CORE +# error "this header requires Py_BUILD_CORE define" +#endif + +/* Forward declarations */ +struct pyruntimestate; +struct _ceval_runtime_state; + +#include "pycore_interp.h" /* PyInterpreterState.eval_frame */ + +extern void _Py_FinishPendingCalls(PyThreadState *tstate); +extern void _PyEval_InitRuntimeState(struct _ceval_runtime_state *); +extern int _PyEval_InitState(struct _ceval_state *ceval); +extern void _PyEval_FiniState(struct _ceval_state *ceval); +PyAPI_FUNC(void) _PyEval_SignalReceived(PyInterpreterState *interp); +PyAPI_FUNC(int) _PyEval_AddPendingCall( + PyInterpreterState *interp, + int (*func)(void *), + void *arg); +PyAPI_FUNC(void) _PyEval_SignalAsyncExc(PyInterpreterState *interp); +#ifdef HAVE_FORK +extern PyStatus _PyEval_ReInitThreads(PyThreadState *tstate); +#endif +PyAPI_FUNC(void) _PyEval_SetCoroutineOriginTrackingDepth( + PyThreadState *tstate, + int new_depth); + +void _PyEval_Fini(void); + + +extern PyObject* _PyEval_GetBuiltins(PyThreadState *tstate); +extern PyObject *_PyEval_BuiltinsFromGlobals( + PyThreadState *tstate, + PyObject *globals); + + +static inline PyObject* +_PyEval_EvalFrame(PyThreadState *tstate, PyFrameObject *f, int throwflag) +{ + return tstate->interp->eval_frame(tstate, f, throwflag); +} + +extern PyObject * +_PyEval_Vector(PyThreadState *tstate, + PyFrameConstructor *desc, PyObject *locals, + PyObject* const* args, size_t argcount, + PyObject *kwnames); + +#ifdef EXPERIMENTAL_ISOLATED_SUBINTERPRETERS +extern int _PyEval_ThreadsInitialized(PyInterpreterState *interp); +#else +extern int _PyEval_ThreadsInitialized(struct pyruntimestate *runtime); +#endif +extern PyStatus _PyEval_InitGIL(PyThreadState *tstate); +extern void _PyEval_FiniGIL(PyInterpreterState *interp); + +extern void _PyEval_ReleaseLock(PyThreadState *tstate); + +extern void _PyEval_DeactivateOpCache(void); + + +/* --- _Py_EnterRecursiveCall() ----------------------------------------- */ + +#ifdef USE_STACKCHECK +/* With USE_STACKCHECK macro defined, trigger stack checks in + _Py_CheckRecursiveCall() on every 64th call to Py_EnterRecursiveCall. */ +static inline int _Py_MakeRecCheck(PyThreadState *tstate) { + return (++tstate->recursion_depth > tstate->interp->ceval.recursion_limit + || ++tstate->stackcheck_counter > 64); +} +#else +static inline int _Py_MakeRecCheck(PyThreadState *tstate) { + return (++tstate->recursion_depth > tstate->interp->ceval.recursion_limit); +} +#endif + +PyAPI_FUNC(int) _Py_CheckRecursiveCall( + PyThreadState *tstate, + const char *where); + +static inline int _Py_EnterRecursiveCall(PyThreadState *tstate, + const char *where) { + return (_Py_MakeRecCheck(tstate) && _Py_CheckRecursiveCall(tstate, where)); +} + +static inline int _Py_EnterRecursiveCall_inline(const char *where) { + PyThreadState *tstate = PyThreadState_GET(); + return _Py_EnterRecursiveCall(tstate, where); +} + +#define Py_EnterRecursiveCall(where) _Py_EnterRecursiveCall_inline(where) + +static inline void _Py_LeaveRecursiveCall(PyThreadState *tstate) { + tstate->recursion_depth--; +} + +static inline void _Py_LeaveRecursiveCall_inline(void) { + PyThreadState *tstate = PyThreadState_GET(); + _Py_LeaveRecursiveCall(tstate); +} + +#define Py_LeaveRecursiveCall() _Py_LeaveRecursiveCall_inline() + + +#ifdef __cplusplus +} +#endif +#endif /* !Py_INTERNAL_CEVAL_H */ diff --git a/.ci/python_dependencies_wins/include/internal/pycore_code.h b/.ci/python_dependencies_wins/include/internal/pycore_code.h new file mode 100644 index 00000000..69baba09 --- /dev/null +++ b/.ci/python_dependencies_wins/include/internal/pycore_code.h @@ -0,0 +1,34 @@ +#ifndef Py_INTERNAL_CODE_H +#define Py_INTERNAL_CODE_H +#ifdef __cplusplus +extern "C" { +#endif + +typedef struct { + PyObject *ptr; /* Cached pointer (borrowed reference) */ + uint64_t globals_ver; /* ma_version of global dict */ + uint64_t builtins_ver; /* ma_version of builtin dict */ +} _PyOpcache_LoadGlobal; + +typedef struct { + PyTypeObject *type; + Py_ssize_t hint; + unsigned int tp_version_tag; +} _PyOpCodeOpt_LoadAttr; + +struct _PyOpcache { + union { + _PyOpcache_LoadGlobal lg; + _PyOpCodeOpt_LoadAttr la; + } u; + char optimized; +}; + +/* Private API */ +int _PyCode_InitOpcache(PyCodeObject *co); + + +#ifdef __cplusplus +} +#endif +#endif /* !Py_INTERNAL_CODE_H */ diff --git a/.ci/python_dependencies_wins/include/internal/pycore_compile.h b/.ci/python_dependencies_wins/include/internal/pycore_compile.h new file mode 100644 index 00000000..986365eb --- /dev/null +++ b/.ci/python_dependencies_wins/include/internal/pycore_compile.h @@ -0,0 +1,44 @@ +#ifndef Py_INTERNAL_COMPILE_H +#define Py_INTERNAL_COMPILE_H +#ifdef __cplusplus +extern "C" { +#endif + +#ifndef Py_BUILD_CORE +# error "this header requires Py_BUILD_CORE define" +#endif + +struct _arena; // Type defined in pycore_pyarena.h +struct _mod; // Type defined in pycore_ast.h + +// Export the symbol for test_peg_generator (built as a library) +PyAPI_FUNC(PyCodeObject*) _PyAST_Compile( + struct _mod *mod, + PyObject *filename, + PyCompilerFlags *flags, + int optimize, + struct _arena *arena); +extern PyFutureFeatures* _PyFuture_FromAST( + struct _mod * mod, + PyObject *filename + ); + +extern PyObject* _Py_Mangle(PyObject *p, PyObject *name); + +typedef struct { + int optimize; + int ff_features; + + int recursion_depth; /* current recursion depth */ + int recursion_limit; /* recursion limit */ +} _PyASTOptimizeState; + +extern int _PyAST_Optimize( + struct _mod *, + struct _arena *arena, + _PyASTOptimizeState *state); + +#ifdef __cplusplus +} +#endif +#endif /* !Py_INTERNAL_COMPILE_H */ diff --git a/.ci/python_dependencies_wins/include/internal/pycore_condvar.h b/.ci/python_dependencies_wins/include/internal/pycore_condvar.h new file mode 100644 index 00000000..6e98673d --- /dev/null +++ b/.ci/python_dependencies_wins/include/internal/pycore_condvar.h @@ -0,0 +1,95 @@ +#ifndef Py_INTERNAL_CONDVAR_H +#define Py_INTERNAL_CONDVAR_H + +#ifndef Py_BUILD_CORE +# error "this header requires Py_BUILD_CORE define" +#endif + +#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/.ci/python_dependencies_wins/include/internal/pycore_context.h b/.ci/python_dependencies_wins/include/internal/pycore_context.h new file mode 100644 index 00000000..4236f58e --- /dev/null +++ b/.ci/python_dependencies_wins/include/internal/pycore_context.h @@ -0,0 +1,42 @@ +#ifndef Py_INTERNAL_CONTEXT_H +#define Py_INTERNAL_CONTEXT_H + +#ifndef Py_BUILD_CORE +# error "this header requires Py_BUILD_CORE define" +#endif + +#include "pycore_hamt.h" /* PyHamtObject */ + +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(PyInterpreterState *interp); + +#endif /* !Py_INTERNAL_CONTEXT_H */ diff --git a/.ci/python_dependencies_wins/include/internal/pycore_dtoa.h b/.ci/python_dependencies_wins/include/internal/pycore_dtoa.h new file mode 100644 index 00000000..4cf08f61 --- /dev/null +++ b/.ci/python_dependencies_wins/include/internal/pycore_dtoa.h @@ -0,0 +1,23 @@ +#ifndef PY_NO_SHORT_FLOAT_REPR +#ifdef __cplusplus +extern "C" { +#endif + +#ifndef Py_BUILD_CORE +# error "this header requires Py_BUILD_CORE define" +#endif + +/* These functions are used by modules compiled as C extension like math: + they must be exported. */ + +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 /* !PY_NO_SHORT_FLOAT_REPR */ diff --git a/.ci/python_dependencies_wins/include/internal/pycore_fileutils.h b/.ci/python_dependencies_wins/include/internal/pycore_fileutils.h new file mode 100644 index 00000000..8282908e --- /dev/null +++ b/.ci/python_dependencies_wins/include/internal/pycore_fileutils.h @@ -0,0 +1,71 @@ +#ifndef Py_INTERNAL_FILEUTILS_H +#define Py_INTERNAL_FILEUTILS_H +#ifdef __cplusplus +extern "C" { +#endif + +#ifndef Py_BUILD_CORE +# error "Py_BUILD_CORE must be defined to include this header" +#endif + +#include /* struct lconv */ + +PyAPI_DATA(int) _Py_HasFileSystemDefaultEncodeErrors; + +PyAPI_FUNC(int) _Py_DecodeUTF8Ex( + const char *arg, + Py_ssize_t arglen, + wchar_t **wstr, + size_t *wlen, + const char **reason, + _Py_error_handler errors); + +PyAPI_FUNC(int) _Py_EncodeUTF8Ex( + const wchar_t *text, + char **str, + size_t *error_pos, + const char **reason, + int raw_malloc, + _Py_error_handler errors); + +PyAPI_FUNC(wchar_t*) _Py_DecodeUTF8_surrogateescape( + const char *arg, + Py_ssize_t arglen, + size_t *wlen); + +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); + + +PyAPI_FUNC(int) _Py_GetLocaleconvNumeric( + struct lconv *lc, + PyObject **decimal_point, + PyObject **thousands_sep); + +PyAPI_FUNC(void) _Py_closerange(int first, int last); + +PyAPI_FUNC(wchar_t*) _Py_GetLocaleEncoding(void); +PyAPI_FUNC(PyObject*) _Py_GetLocaleEncodingObject(void); + +#ifdef HAVE_NON_UNICODE_WCHAR_T_REPRESENTATION +extern int _Py_LocaleUsesNonUnicodeWchar(void); + +extern wchar_t* _Py_DecodeNonUnicodeWchar( + const wchar_t* native, + Py_ssize_t size); + +extern int _Py_EncodeNonUnicodeWchar_InPlace( + wchar_t* unicode, + Py_ssize_t size); +#endif + +#ifdef __cplusplus +} +#endif +#endif /* !Py_INTERNAL_FILEUTILS_H */ diff --git a/.ci/python_dependencies_wins/include/internal/pycore_format.h b/.ci/python_dependencies_wins/include/internal/pycore_format.h new file mode 100644 index 00000000..49c937a0 --- /dev/null +++ b/.ci/python_dependencies_wins/include/internal/pycore_format.h @@ -0,0 +1,27 @@ +#ifndef Py_INTERNAL_FORMAT_H +#define Py_INTERNAL_FORMAT_H +#ifdef __cplusplus +extern "C" { +#endif + +#ifndef Py_BUILD_CORE +# error "this header requires Py_BUILD_CORE define" +#endif + +/* Format codes + * F_LJUST '-' + * F_SIGN '+' + * F_BLANK ' ' + * F_ALT '#' + * F_ZERO '0' + */ +#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) + +#ifdef __cplusplus +} +#endif +#endif /* !Py_INTERNAL_FORMAT_H */ diff --git a/.ci/python_dependencies_wins/include/internal/pycore_gc.h b/.ci/python_dependencies_wins/include/internal/pycore_gc.h new file mode 100644 index 00000000..85c94cc6 --- /dev/null +++ b/.ci/python_dependencies_wins/include/internal/pycore_gc.h @@ -0,0 +1,181 @@ +#ifndef Py_INTERNAL_GC_H +#define Py_INTERNAL_GC_H +#ifdef __cplusplus +extern "C" { +#endif + +#ifndef Py_BUILD_CORE +# error "this header requires Py_BUILD_CORE define" +#endif + +/* GC information is stored BEFORE the object structure. */ +typedef struct { + // Pointer to next object in the list. + // 0 means the object is not tracked + uintptr_t _gc_next; + + // Pointer to previous object in the list. + // Lowest two bits are used for flags documented later. + uintptr_t _gc_prev; +} PyGC_Head; + +#define _Py_AS_GC(o) ((PyGC_Head *)(o)-1) + +/* True if the object is currently tracked by the GC. */ +#define _PyObject_GC_IS_TRACKED(o) (_Py_AS_GC(o)->_gc_next != 0) + +/* 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))) + + +/* Bit flags for _gc_prev */ +/* Bit 0 is set when tp_finalize is called */ +#define _PyGC_PREV_MASK_FINALIZED (1) +/* Bit 1 is set when the object is in generation which is GCed currently. */ +#define _PyGC_PREV_MASK_COLLECTING (2) +/* The (N-2) most significant bits contain the real address. */ +#define _PyGC_PREV_SHIFT (2) +#define _PyGC_PREV_MASK (((uintptr_t) -1) << _PyGC_PREV_SHIFT) + +// Lowest bit of _gc_next is used for flags only in GC. +// But it is always 0 for normal code. +#define _PyGCHead_NEXT(g) ((PyGC_Head*)(g)->_gc_next) +#define _PyGCHead_SET_NEXT(g, p) ((g)->_gc_next = (uintptr_t)(p)) + +// Lowest two bits of _gc_prev is used for _PyGC_PREV_MASK_* flags. +#define _PyGCHead_PREV(g) ((PyGC_Head*)((g)->_gc_prev & _PyGC_PREV_MASK)) +#define _PyGCHead_SET_PREV(g, p) do { \ + assert(((uintptr_t)p & ~_PyGC_PREV_MASK) == 0); \ + (g)->_gc_prev = ((g)->_gc_prev & ~_PyGC_PREV_MASK) \ + | ((uintptr_t)(p)); \ + } while (0) + +#define _PyGCHead_FINALIZED(g) \ + (((g)->_gc_prev & _PyGC_PREV_MASK_FINALIZED) != 0) +#define _PyGCHead_SET_FINALIZED(g) \ + ((g)->_gc_prev |= _PyGC_PREV_MASK_FINALIZED) + +#define _PyGC_FINALIZED(o) \ + _PyGCHead_FINALIZED(_Py_AS_GC(o)) +#define _PyGC_SET_FINALIZED(o) \ + _PyGCHead_SET_FINALIZED(_Py_AS_GC(o)) + + +/* 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 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; +}; + +extern void _PyGC_InitState(struct _gc_runtime_state *); + +extern Py_ssize_t _PyGC_CollectNoFail(PyThreadState *tstate); + + +// Functions to clear types free lists +extern void _PyFrame_ClearFreeList(PyInterpreterState *interp); +extern void _PyTuple_ClearFreeList(PyInterpreterState *interp); +extern void _PyFloat_ClearFreeList(PyInterpreterState *interp); +extern void _PyList_ClearFreeList(PyInterpreterState *interp); +extern void _PyDict_ClearFreeList(PyInterpreterState *interp); +extern void _PyAsyncGen_ClearFreeLists(PyInterpreterState *interp); +extern void _PyContext_ClearFreeList(PyInterpreterState *interp); + +#ifdef __cplusplus +} +#endif +#endif /* !Py_INTERNAL_GC_H */ diff --git a/.ci/python_dependencies_wins/include/internal/pycore_getopt.h b/.ci/python_dependencies_wins/include/internal/pycore_getopt.h new file mode 100644 index 00000000..d045469c --- /dev/null +++ b/.ci/python_dependencies_wins/include/internal/pycore_getopt.h @@ -0,0 +1,22 @@ +#ifndef Py_INTERNAL_PYGETOPT_H +#define Py_INTERNAL_PYGETOPT_H + +#ifndef Py_BUILD_CORE +# error "this header requires Py_BUILD_CORE define" +#endif + +extern int _PyOS_opterr; +extern Py_ssize_t _PyOS_optind; +extern const 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(Py_ssize_t argc, wchar_t * const *argv, int *longindex); + +#endif /* !Py_INTERNAL_PYGETOPT_H */ diff --git a/.ci/python_dependencies_wins/include/internal/pycore_gil.h b/.ci/python_dependencies_wins/include/internal/pycore_gil.h new file mode 100644 index 00000000..e1c8923c --- /dev/null +++ b/.ci/python_dependencies_wins/include/internal/pycore_gil.h @@ -0,0 +1,50 @@ +#ifndef Py_INTERNAL_GIL_H +#define Py_INTERNAL_GIL_H +#ifdef __cplusplus +extern "C" { +#endif + +#ifndef Py_BUILD_CORE +# error "this header requires Py_BUILD_CORE define" +#endif + +#include "pycore_atomic.h" /* _Py_atomic_address */ +#include "pycore_condvar.h" /* PyCOND_T */ + +#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/.ci/python_dependencies_wins/include/internal/pycore_hamt.h b/.ci/python_dependencies_wins/include/internal/pycore_hamt.h new file mode 100644 index 00000000..f467b719 --- /dev/null +++ b/.ci/python_dependencies_wins/include/internal/pycore_hamt.h @@ -0,0 +1,128 @@ +#ifndef Py_INTERNAL_HAMT_H +#define Py_INTERNAL_HAMT_H + +#ifndef Py_BUILD_CORE +# error "this header requires Py_BUILD_CORE define" +#endif + + +/* +HAMT tree is shaped by hashes of keys. Every group of 5 bits of a hash denotes +the exact position of the key in one level of the tree. Since we're using +32 bit hashes, we can have at most 7 such levels. Although if there are +two distinct keys with equal hashes, they will have to occupy the same +cell in the 7th level of the tree -- so we'd put them in a "collision" node. +Which brings the total possible tree depth to 8. Read more about the actual +layout of the HAMT tree in `hamt.c`. + +This constant is used to define a datastucture for storing iteration state. +*/ +#define _Py_HAMT_MAX_TREE_DEPTH 8 + + +#define PyHamt_Check(o) Py_IS_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/.ci/python_dependencies_wins/include/internal/pycore_hashtable.h b/.ci/python_dependencies_wins/include/internal/pycore_hashtable.h new file mode 100644 index 00000000..8fa411a1 --- /dev/null +++ b/.ci/python_dependencies_wins/include/internal/pycore_hashtable.h @@ -0,0 +1,148 @@ +#ifndef Py_INTERNAL_HASHTABLE_H +#define Py_INTERNAL_HASHTABLE_H +#ifdef __cplusplus +extern "C" { +#endif + +#ifndef Py_BUILD_CORE +# error "this header requires Py_BUILD_CORE define" +#endif + +/* Single linked list */ + +typedef struct _Py_slist_item_s { + struct _Py_slist_item_s *next; +} _Py_slist_item_t; + +typedef struct { + _Py_slist_item_t *head; +} _Py_slist_t; + +#define _Py_SLIST_ITEM_NEXT(ITEM) (((_Py_slist_item_t *)ITEM)->next) + +#define _Py_SLIST_HEAD(SLIST) (((_Py_slist_t *)SLIST)->head) + + +/* _Py_hashtable: table entry */ + +typedef struct { + /* used by _Py_hashtable_t.buckets to link entries */ + _Py_slist_item_t _Py_slist_item; + + Py_uhash_t key_hash; + void *key; + void *value; +} _Py_hashtable_entry_t; + + +/* _Py_hashtable: prototypes */ + +/* Forward declaration */ +struct _Py_hashtable_t; +typedef struct _Py_hashtable_t _Py_hashtable_t; + +typedef Py_uhash_t (*_Py_hashtable_hash_func) (const void *key); +typedef int (*_Py_hashtable_compare_func) (const void *key1, const void *key2); +typedef void (*_Py_hashtable_destroy_func) (void *key); +typedef _Py_hashtable_entry_t* (*_Py_hashtable_get_entry_func)(_Py_hashtable_t *ht, + const void *key); + +typedef struct { + // Allocate a memory block + void* (*malloc) (size_t size); + + // Release a memory block + void (*free) (void *ptr); +} _Py_hashtable_allocator_t; + + +/* _Py_hashtable: table */ +struct _Py_hashtable_t { + size_t nentries; // Total number of entries in the table + size_t nbuckets; + _Py_slist_t *buckets; + + _Py_hashtable_get_entry_func get_entry_func; + _Py_hashtable_hash_func hash_func; + _Py_hashtable_compare_func compare_func; + _Py_hashtable_destroy_func key_destroy_func; + _Py_hashtable_destroy_func value_destroy_func; + _Py_hashtable_allocator_t alloc; +}; + +/* Hash a pointer (void*) */ +PyAPI_FUNC(Py_uhash_t) _Py_hashtable_hash_ptr(const void *key); + +/* Comparison using memcmp() */ +PyAPI_FUNC(int) _Py_hashtable_compare_direct( + const void *key1, + const void *key2); + +PyAPI_FUNC(_Py_hashtable_t *) _Py_hashtable_new( + _Py_hashtable_hash_func hash_func, + _Py_hashtable_compare_func compare_func); + +PyAPI_FUNC(_Py_hashtable_t *) _Py_hashtable_new_full( + _Py_hashtable_hash_func hash_func, + _Py_hashtable_compare_func compare_func, + _Py_hashtable_destroy_func key_destroy_func, + _Py_hashtable_destroy_func value_destroy_func, + _Py_hashtable_allocator_t *allocator); + +PyAPI_FUNC(void) _Py_hashtable_destroy(_Py_hashtable_t *ht); + +PyAPI_FUNC(void) _Py_hashtable_clear(_Py_hashtable_t *ht); + +typedef int (*_Py_hashtable_foreach_func) (_Py_hashtable_t *ht, + const void *key, const void *value, + void *user_data); + +/* Call func() on each entry of the hashtable. + Iteration stops if func() result is non-zero, in this case it's the result + of the call. Otherwise, the function returns 0. */ +PyAPI_FUNC(int) _Py_hashtable_foreach( + _Py_hashtable_t *ht, + _Py_hashtable_foreach_func func, + void *user_data); + +PyAPI_FUNC(size_t) _Py_hashtable_size(const _Py_hashtable_t *ht); + +/* Add a new entry to the hash. The key must not be present in the hash table. + Return 0 on success, -1 on memory error. */ +PyAPI_FUNC(int) _Py_hashtable_set( + _Py_hashtable_t *ht, + const void *key, + void *value); + + +/* Get an entry. + Return NULL if the key does not exist. */ +static inline _Py_hashtable_entry_t * +_Py_hashtable_get_entry(_Py_hashtable_t *ht, const void *key) +{ + return ht->get_entry_func(ht, key); +} + + +/* Get value from an entry. + Return NULL if the entry is not found. + + Use _Py_hashtable_get_entry() to distinguish entry value equal to NULL + and entry not found. */ +PyAPI_FUNC(void*) _Py_hashtable_get(_Py_hashtable_t *ht, const void *key); + + +/* Remove a key and its associated value without calling key and value destroy + functions. + + Return the removed value if the key was found. + Return NULL if the key was not found. */ +PyAPI_FUNC(void*) _Py_hashtable_steal( + _Py_hashtable_t *ht, + const void *key); + + +#ifdef __cplusplus +} +#endif +#endif /* !Py_INTERNAL_HASHTABLE_H */ diff --git a/.ci/python_dependencies_wins/include/internal/pycore_import.h b/.ci/python_dependencies_wins/include/internal/pycore_import.h new file mode 100644 index 00000000..e629c0b7 --- /dev/null +++ b/.ci/python_dependencies_wins/include/internal/pycore_import.h @@ -0,0 +1,17 @@ +#ifndef Py_LIMITED_API +#ifndef Py_INTERNAL_IMPORT_H +#define Py_INTERNAL_IMPORT_H +#ifdef __cplusplus +extern "C" { +#endif + +#ifdef HAVE_FORK +extern PyStatus _PyImport_ReInitLock(void); +#endif +extern PyObject* _PyImport_BootstrapImp(PyThreadState *tstate); + +#ifdef __cplusplus +} +#endif +#endif /* !Py_INTERNAL_IMPORT_H */ +#endif /* !Py_LIMITED_API */ diff --git a/.ci/python_dependencies_wins/include/internal/pycore_initconfig.h b/.ci/python_dependencies_wins/include/internal/pycore_initconfig.h new file mode 100644 index 00000000..fe15af11 --- /dev/null +++ b/.ci/python_dependencies_wins/include/internal/pycore_initconfig.h @@ -0,0 +1,178 @@ +#ifndef Py_INTERNAL_CORECONFIG_H +#define Py_INTERNAL_CORECONFIG_H +#ifdef __cplusplus +extern "C" { +#endif + +#ifndef Py_BUILD_CORE +# error "this header requires Py_BUILD_CORE define" +#endif + +/* Forward declaration */ +struct pyruntimestate; + +/* --- PyStatus ----------------------------------------------- */ + +/* Almost all errors causing Python initialization to fail */ +#ifdef _MSC_VER + /* Visual Studio 2015 doesn't implement C99 __func__ in C */ +# define _PyStatus_GET_FUNC() __FUNCTION__ +#else +# define _PyStatus_GET_FUNC() __func__ +#endif + +#define _PyStatus_OK() \ + (PyStatus){._type = _PyStatus_TYPE_OK,} + /* other fields are set to 0 */ +#define _PyStatus_ERR(ERR_MSG) \ + (PyStatus){ \ + ._type = _PyStatus_TYPE_ERROR, \ + .func = _PyStatus_GET_FUNC(), \ + .err_msg = (ERR_MSG)} + /* other fields are set to 0 */ +#define _PyStatus_NO_MEMORY() _PyStatus_ERR("memory allocation failed") +#define _PyStatus_EXIT(EXITCODE) \ + (PyStatus){ \ + ._type = _PyStatus_TYPE_EXIT, \ + .exitcode = (EXITCODE)} +#define _PyStatus_IS_ERROR(err) \ + (err._type == _PyStatus_TYPE_ERROR) +#define _PyStatus_IS_EXIT(err) \ + (err._type == _PyStatus_TYPE_EXIT) +#define _PyStatus_EXCEPTION(err) \ + (err._type != _PyStatus_TYPE_OK) +#define _PyStatus_UPDATE_FUNC(err) \ + do { err.func = _PyStatus_GET_FUNC(); } while (0) + +PyObject* _PyErr_SetFromPyStatus(PyStatus status); + +/* --- PyWideStringList ------------------------------------------------ */ + +#define _PyWideStringList_INIT (PyWideStringList){.length = 0, .items = NULL} + +#ifndef NDEBUG +PyAPI_FUNC(int) _PyWideStringList_CheckConsistency(const PyWideStringList *list); +#endif +PyAPI_FUNC(void) _PyWideStringList_Clear(PyWideStringList *list); +PyAPI_FUNC(int) _PyWideStringList_Copy(PyWideStringList *list, + const PyWideStringList *list2); +PyAPI_FUNC(PyStatus) _PyWideStringList_Extend(PyWideStringList *list, + const PyWideStringList *list2); +PyAPI_FUNC(PyObject*) _PyWideStringList_AsList(const PyWideStringList *list); + + +/* --- _PyArgv ---------------------------------------------------- */ + +typedef struct _PyArgv { + Py_ssize_t argc; + int use_bytes_argv; + char * const *bytes_argv; + wchar_t * const *wchar_argv; +} _PyArgv; + +PyAPI_FUNC(PyStatus) _PyArgv_AsWstrList(const _PyArgv *args, + PyWideStringList *list); + + +/* --- Helper functions ------------------------------------------- */ + +PyAPI_FUNC(int) _Py_str_to_int( + const char *str, + int *result); +PyAPI_FUNC(const wchar_t*) _Py_get_xoption( + const PyWideStringList *xoptions, + const wchar_t *name); +PyAPI_FUNC(const char*) _Py_GetEnv( + int use_environment, + const char *name); +PyAPI_FUNC(void) _Py_get_env_flag( + int use_environment, + int *flag, + const char *name); + +/* Py_GetArgcArgv() helper */ +PyAPI_FUNC(void) _Py_ClearArgcArgv(void); + + +/* --- _PyPreCmdline ------------------------------------------------- */ + +typedef struct { + PyWideStringList argv; + PyWideStringList xoptions; /* "-X value" option */ + int isolated; /* -I option */ + int use_environment; /* -E option */ + int dev_mode; /* -X dev and PYTHONDEVMODE */ + int warn_default_encoding; /* -X warn_default_encoding and PYTHONWARNDEFAULTENCODING */ +} _PyPreCmdline; + +#define _PyPreCmdline_INIT \ + (_PyPreCmdline){ \ + .use_environment = -1, \ + .isolated = -1, \ + .dev_mode = -1} +/* Note: _PyPreCmdline_INIT sets other fields to 0/NULL */ + +extern void _PyPreCmdline_Clear(_PyPreCmdline *cmdline); +extern PyStatus _PyPreCmdline_SetArgv(_PyPreCmdline *cmdline, + const _PyArgv *args); +extern PyStatus _PyPreCmdline_SetConfig( + const _PyPreCmdline *cmdline, + PyConfig *config); +extern PyStatus _PyPreCmdline_Read(_PyPreCmdline *cmdline, + const PyPreConfig *preconfig); + + +/* --- PyPreConfig ----------------------------------------------- */ + +PyAPI_FUNC(void) _PyPreConfig_InitCompatConfig(PyPreConfig *preconfig); +extern void _PyPreConfig_InitFromConfig( + PyPreConfig *preconfig, + const PyConfig *config); +extern PyStatus _PyPreConfig_InitFromPreConfig( + PyPreConfig *preconfig, + const PyPreConfig *config2); +extern PyObject* _PyPreConfig_AsDict(const PyPreConfig *preconfig); +extern void _PyPreConfig_GetConfig(PyPreConfig *preconfig, + const PyConfig *config); +extern PyStatus _PyPreConfig_Read(PyPreConfig *preconfig, + const _PyArgv *args); +extern PyStatus _PyPreConfig_Write(const PyPreConfig *preconfig); + + +/* --- PyConfig ---------------------------------------------- */ + +typedef enum { + /* Py_Initialize() API: backward compatibility with Python 3.6 and 3.7 */ + _PyConfig_INIT_COMPAT = 1, + _PyConfig_INIT_PYTHON = 2, + _PyConfig_INIT_ISOLATED = 3 +} _PyConfigInitEnum; + +PyAPI_FUNC(void) _PyConfig_InitCompatConfig(PyConfig *config); +extern PyStatus _PyConfig_Copy( + PyConfig *config, + const PyConfig *config2); +extern PyStatus _PyConfig_InitPathConfig( + PyConfig *config, + int compute_path_config); +extern PyStatus _PyConfig_Read(PyConfig *config, int compute_path_config); +extern PyStatus _PyConfig_Write(const PyConfig *config, + struct pyruntimestate *runtime); +extern PyStatus _PyConfig_SetPyArgv( + PyConfig *config, + const _PyArgv *args); + +PyAPI_FUNC(PyObject*) _PyConfig_AsDict(const PyConfig *config); +PyAPI_FUNC(int) _PyConfig_FromDict(PyConfig *config, PyObject *dict); + +extern int _Py_global_config_int_max_str_digits; + + +/* --- Function used for testing ---------------------------------- */ + +PyAPI_FUNC(PyObject*) _Py_GetConfigsAsDict(void); + +#ifdef __cplusplus +} +#endif +#endif /* !Py_INTERNAL_CORECONFIG_H */ diff --git a/.ci/python_dependencies_wins/include/internal/pycore_interp.h b/.ci/python_dependencies_wins/include/internal/pycore_interp.h new file mode 100644 index 00000000..2301cf37 --- /dev/null +++ b/.ci/python_dependencies_wins/include/internal/pycore_interp.h @@ -0,0 +1,339 @@ +#ifndef Py_INTERNAL_INTERP_H +#define Py_INTERNAL_INTERP_H +#ifdef __cplusplus +extern "C" { +#endif + +#ifndef Py_BUILD_CORE +# error "this header requires Py_BUILD_CORE define" +#endif + +#include "pycore_atomic.h" // _Py_atomic_address +#include "pycore_ast_state.h" // struct ast_state +#include "pycore_gil.h" // struct _gil_runtime_state +#include "pycore_gc.h" // struct _gc_runtime_state +#include "pycore_warnings.h" // struct _warnings_runtime_state + +struct _pending_calls { + 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; +}; + +struct _ceval_state { + int recursion_limit; + /* 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; +#ifdef EXPERIMENTAL_ISOLATED_SUBINTERPRETERS + struct _gil_runtime_state gil; +#endif +}; + +/* fs_codec.encoding is initialized to NULL. + Later, it is set to a non-NULL string by _PyUnicode_InitEncodings(). */ +struct _Py_unicode_fs_codec { + char *encoding; // Filesystem encoding (encoded to UTF-8) + int utf8; // encoding=="utf-8"? + char *errors; // Filesystem errors (encoded to UTF-8) + _Py_error_handler error_handler; +}; + +struct _Py_bytes_state { + PyObject *empty_string; + PyBytesObject *characters[256]; +}; + +struct _Py_unicode_ids { + Py_ssize_t size; + PyObject **array; +}; + +struct _Py_unicode_state { + // The empty Unicode object is a singleton to improve performance. + PyObject *empty_string; + /* Single character Unicode strings in the Latin-1 range are being + shared as well. */ + PyObject *latin1[256]; + struct _Py_unicode_fs_codec fs_codec; + + // Unused member kept for ABI backward compatibility with Python 3.10.0: + // see bpo-46006. + PyObject *unused_interned; + + // Unicode identifiers (_Py_Identifier): see _PyUnicode_FromId() + struct _Py_unicode_ids ids; +}; + +struct _Py_float_state { + /* Special free list + free_list is a singly-linked list of available PyFloatObjects, + linked via abuse of their ob_type members. */ + int numfree; + PyFloatObject *free_list; +}; + +/* Speed optimization to avoid frequent malloc/free of small tuples */ +#ifndef PyTuple_MAXSAVESIZE + // Largest tuple to save on free list +# define PyTuple_MAXSAVESIZE 20 +#endif +#ifndef PyTuple_MAXFREELIST + // Maximum number of tuples of each size to save +# define PyTuple_MAXFREELIST 2000 +#endif + +struct _Py_tuple_state { +#if PyTuple_MAXSAVESIZE > 0 + /* Entries 1 up to PyTuple_MAXSAVESIZE are free lists, + entry 0 is the empty tuple () of which at most one instance + will be allocated. */ + PyTupleObject *free_list[PyTuple_MAXSAVESIZE]; + int numfree[PyTuple_MAXSAVESIZE]; +#endif +}; + +/* Empty list reuse scheme to save calls to malloc and free */ +#ifndef PyList_MAXFREELIST +# define PyList_MAXFREELIST 80 +#endif + +struct _Py_list_state { + PyListObject *free_list[PyList_MAXFREELIST]; + int numfree; +}; + +#ifndef PyDict_MAXFREELIST +# define PyDict_MAXFREELIST 80 +#endif + +struct _Py_dict_state { + /* Dictionary reuse scheme to save calls to malloc and free */ + PyDictObject *free_list[PyDict_MAXFREELIST]; + int numfree; + PyDictKeysObject *keys_free_list[PyDict_MAXFREELIST]; + int keys_numfree; +}; + +struct _Py_frame_state { + PyFrameObject *free_list; + /* number of frames currently in free_list */ + int numfree; +}; + +#ifndef _PyAsyncGen_MAXFREELIST +# define _PyAsyncGen_MAXFREELIST 80 +#endif + +struct _Py_async_gen_state { + /* Freelists boost performance 6-10%; they also reduce memory + fragmentation, as _PyAsyncGenWrappedValue and PyAsyncGenASend + are short-living objects that are instantiated for every + __anext__() call. */ + struct _PyAsyncGenWrappedValue* value_freelist[_PyAsyncGen_MAXFREELIST]; + int value_numfree; + + struct PyAsyncGenASend* asend_freelist[_PyAsyncGen_MAXFREELIST]; + int asend_numfree; +}; + +struct _Py_context_state { + // List of free PyContext objects + PyContext *freelist; + int numfree; +}; + +struct _Py_exc_state { + // The dict mapping from errno codes to OSError subclasses + PyObject *errnomap; + PyBaseExceptionObject *memerrors_freelist; + int memerrors_numfree; +}; + + +// atexit state +typedef struct { + PyObject *func; + PyObject *args; + PyObject *kwargs; +} atexit_callback; + +struct atexit_state { + atexit_callback **callbacks; + int ncallbacks; + int callback_len; +}; + + +// Type attribute lookup cache: speed up attribute and method lookups, +// see _PyType_Lookup(). +struct type_cache_entry { + unsigned int version; // initialized from type->tp_version_tag + PyObject *name; // reference to exactly a str or None + PyObject *value; // borrowed reference or NULL +}; + +#define MCACHE_SIZE_EXP 12 +#define MCACHE_STATS 0 + +struct type_cache { + struct type_cache_entry hashtable[1 << MCACHE_SIZE_EXP]; +#if MCACHE_STATS + size_t hits; + size_t misses; + size_t collisions; +#endif +}; + + +/* interpreter state */ + +#define _PY_NSMALLPOSINTS 257 +#define _PY_NSMALLNEGINTS 5 + +// _PyLong_GetZero() and _PyLong_GetOne() must always be available +#if _PY_NSMALLPOSINTS < 2 +# error "_PY_NSMALLPOSINTS must be greater than 1" +#endif + +// The PyInterpreterState typedef is in Include/pystate.h. +struct _is { + + struct _is *next; + struct _ts *tstate_head; + + /* Reference to the _PyRuntime global variable. This field exists + to not have to pass runtime in addition to tstate to a function. + Get runtime from tstate: tstate->interp->runtime. */ + struct pyruntimestate *runtime; + + int64_t id; + int64_t id_refcount; + int requires_idref; + PyThread_type_lock id_mutex; + + int finalizing; + + struct _ceval_state ceval; + struct _gc_runtime_state gc; + + // sys.modules dictionary + PyObject *modules; + PyObject *modules_by_index; + // Dictionary of the sys module + PyObject *sysdict; + // Dictionary of the builtins module + PyObject *builtins; + // importlib module + PyObject *importlib; + + /* 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; + + PyConfig config; +#ifdef HAVE_DLOPEN + int dlopenflags; +#endif + + PyObject *dict; /* Stores per-interpreter state */ + + 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 + + uint64_t tstate_next_unique_id; + + struct _warnings_runtime_state warnings; + struct atexit_state atexit; + + PyObject *audit_hooks; + + /* Small integers are preallocated in this array so that they + can be shared. + The integers that are preallocated are those in the range + -_PY_NSMALLNEGINTS (inclusive) to _PY_NSMALLPOSINTS (not inclusive). + */ + PyLongObject* small_ints[_PY_NSMALLNEGINTS + _PY_NSMALLPOSINTS]; + struct _Py_bytes_state bytes; + struct _Py_unicode_state unicode; + struct _Py_float_state float_state; + /* Using a cache is very effective since typically only a single slice is + created and then deleted again. */ + PySliceObject *slice_cache; + + struct _Py_tuple_state tuple; + struct _Py_list_state list; + struct _Py_dict_state dict_state; + struct _Py_frame_state frame; + struct _Py_async_gen_state async_gen; + struct _Py_context_state context; + struct _Py_exc_state exc_state; + + struct ast_state ast; + struct type_cache type_cache; + + int int_max_str_digits; +}; + +extern void _PyInterpreterState_ClearModules(PyInterpreterState *interp); +extern void _PyInterpreterState_Clear(PyThreadState *tstate); + + +/* cross-interpreter data registry */ + +/* For now we use a global registry of shareable classes. An + alternative would be to add a tp_* slot for a class's + crossinterpdatafunc. It would be simpler and more efficient. */ + +struct _xidregitem; + +struct _xidregitem { + PyTypeObject *cls; + crossinterpdatafunc getdata; + struct _xidregitem *next; +}; + +PyAPI_FUNC(struct _is*) _PyInterpreterState_LookUpID(int64_t); + +PyAPI_FUNC(int) _PyInterpreterState_IDInitref(struct _is *); +PyAPI_FUNC(int) _PyInterpreterState_IDIncref(struct _is *); +PyAPI_FUNC(void) _PyInterpreterState_IDDecref(struct _is *); + +#ifdef __cplusplus +} +#endif +#endif /* !Py_INTERNAL_INTERP_H */ diff --git a/.ci/python_dependencies_wins/include/internal/pycore_list.h b/.ci/python_dependencies_wins/include/internal/pycore_list.h new file mode 100644 index 00000000..9704e00d --- /dev/null +++ b/.ci/python_dependencies_wins/include/internal/pycore_list.h @@ -0,0 +1,20 @@ +#ifndef Py_INTERNAL_LIST_H +#define Py_INTERNAL_LIST_H +#ifdef __cplusplus +extern "C" { +#endif + +#ifndef Py_BUILD_CORE +# error "this header requires Py_BUILD_CORE define" +#endif + +#include "listobject.h" // _PyList_CAST() + + +#define _PyList_ITEMS(op) (_PyList_CAST(op)->ob_item) + + +#ifdef __cplusplus +} +#endif +#endif /* !Py_INTERNAL_LIST_H */ diff --git a/.ci/python_dependencies_wins/include/internal/pycore_long.h b/.ci/python_dependencies_wins/include/internal/pycore_long.h new file mode 100644 index 00000000..bc55640c --- /dev/null +++ b/.ci/python_dependencies_wins/include/internal/pycore_long.h @@ -0,0 +1,75 @@ +#ifndef Py_INTERNAL_LONG_H +#define Py_INTERNAL_LONG_H +#ifdef __cplusplus +extern "C" { +#endif + +#ifndef Py_BUILD_CORE +# error "this header requires Py_BUILD_CORE define" +#endif + +#include "pycore_interp.h" // PyInterpreterState.small_ints +#include "pycore_pystate.h" // _PyThreadState_GET() + +/* + * Default int base conversion size limitation: Denial of Service prevention. + * + * Chosen such that this isn't wildly slow on modern hardware and so that + * everyone's existing deployed numpy test suite passes before + * https://github.com/numpy/numpy/issues/22098 is widely available. + * + * $ python -m timeit -s 's = "1"*4300' 'int(s)' + * 2000 loops, best of 5: 125 usec per loop + * $ python -m timeit -s 's = "1"*4300; v = int(s)' 'str(v)' + * 1000 loops, best of 5: 311 usec per loop + * (zen2 cloud VM) + * + * 4300 decimal digits fits a ~14284 bit number. + */ +#define _PY_LONG_DEFAULT_MAX_STR_DIGITS 4300 +/* + * Threshold for max digits check. For performance reasons int() and + * int.__str__() don't checks values that are smaller than this + * threshold. Acts as a guaranteed minimum size limit for bignums that + * applications can expect from CPython. + * + * % python -m timeit -s 's = "1"*640; v = int(s)' 'str(int(s))' + * 20000 loops, best of 5: 12 usec per loop + * + * "640 digits should be enough for anyone." - gps + * fits a ~2126 bit decimal number. + */ +#define _PY_LONG_MAX_STR_DIGITS_THRESHOLD 640 + +#if ((_PY_LONG_DEFAULT_MAX_STR_DIGITS != 0) && \ + (_PY_LONG_DEFAULT_MAX_STR_DIGITS < _PY_LONG_MAX_STR_DIGITS_THRESHOLD)) +# error "_PY_LONG_DEFAULT_MAX_STR_DIGITS smaller than threshold." +#endif + +// Don't call this function but _PyLong_GetZero() and _PyLong_GetOne() +static inline PyObject* __PyLong_GetSmallInt_internal(int value) +{ + PyInterpreterState *interp = _PyInterpreterState_GET(); + assert(-_PY_NSMALLNEGINTS <= value && value < _PY_NSMALLPOSINTS); + size_t index = _PY_NSMALLNEGINTS + value; + PyObject *obj = (PyObject*)interp->small_ints[index]; + // _PyLong_GetZero(), _PyLong_GetOne() and get_small_int() must not be + // called before _PyLong_Init() nor after _PyLong_Fini(). + assert(obj != NULL); + return obj; +} + +// Return a borrowed reference to the zero singleton. +// The function cannot return NULL. +static inline PyObject* _PyLong_GetZero(void) +{ return __PyLong_GetSmallInt_internal(0); } + +// Return a borrowed reference to the one singleton. +// The function cannot return NULL. +static inline PyObject* _PyLong_GetOne(void) +{ return __PyLong_GetSmallInt_internal(1); } + +#ifdef __cplusplus +} +#endif +#endif /* !Py_INTERNAL_LONG_H */ diff --git a/.ci/python_dependencies_wins/include/internal/pycore_moduleobject.h b/.ci/python_dependencies_wins/include/internal/pycore_moduleobject.h new file mode 100644 index 00000000..6db5b40d --- /dev/null +++ b/.ci/python_dependencies_wins/include/internal/pycore_moduleobject.h @@ -0,0 +1,42 @@ +#ifndef Py_INTERNAL_MODULEOBJECT_H +#define Py_INTERNAL_MODULEOBJECT_H +#ifdef __cplusplus +extern "C" { +#endif + +#ifndef Py_BUILD_CORE +# error "this header requires Py_BUILD_CORE define" +#endif + +typedef struct { + PyObject_HEAD + PyObject *md_dict; + struct PyModuleDef *md_def; + void *md_state; + PyObject *md_weaklist; + // for logging purposes after md_dict is cleared + PyObject *md_name; +} PyModuleObject; + +static inline PyModuleDef* _PyModule_GetDef(PyObject *mod) { + assert(PyModule_Check(mod)); + return ((PyModuleObject *)mod)->md_def; +} + +static inline void* _PyModule_GetState(PyObject* mod) { + assert(PyModule_Check(mod)); + return ((PyModuleObject *)mod)->md_state; +} + +static inline PyObject* _PyModule_GetDict(PyObject *mod) { + assert(PyModule_Check(mod)); + PyObject *dict = ((PyModuleObject *)mod) -> md_dict; + // _PyModule_GetDict(mod) must not be used after calling module_clear(mod) + assert(dict != NULL); + return dict; +} + +#ifdef __cplusplus +} +#endif +#endif /* !Py_INTERNAL_MODULEOBJECT_H */ diff --git a/.ci/python_dependencies_wins/include/internal/pycore_object.h b/.ci/python_dependencies_wins/include/internal/pycore_object.h new file mode 100644 index 00000000..5c1d8177 --- /dev/null +++ b/.ci/python_dependencies_wins/include/internal/pycore_object.h @@ -0,0 +1,186 @@ +#ifndef Py_INTERNAL_OBJECT_H +#define Py_INTERNAL_OBJECT_H +#ifdef __cplusplus +extern "C" { +#endif + +#ifndef Py_BUILD_CORE +# error "this header requires Py_BUILD_CORE define" +#endif + +#include "pycore_gc.h" // _PyObject_GC_IS_TRACKED() +#include "pycore_interp.h" // PyInterpreterState.gc +#include "pycore_pystate.h" // _PyInterpreterState_GET() + +PyAPI_FUNC(int) _PyType_CheckConsistency(PyTypeObject *type); +PyAPI_FUNC(int) _PyDict_CheckConsistency(PyObject *mp, int check_content); + +/* Update the Python traceback of an object. This function must be called + when a memory block is reused from a free list. + + Internal function called by _Py_NewReference(). */ +extern int _PyTraceMalloc_NewReference(PyObject *op); + +// Fast inlined version of PyType_HasFeature() +static inline int +_PyType_HasFeature(PyTypeObject *type, unsigned long feature) { + return ((type->tp_flags & feature) != 0); +} + +extern void _PyType_InitCache(PyInterpreterState *interp); + +/* Only private in Python 3.10 and 3.9.8+; public in 3.11 */ +extern PyObject *_PyType_GetQualName(PyTypeObject *type); + +/* Inline functions trading binary compatibility for speed: + _PyObject_Init() is the fast version of PyObject_Init(), and + _PyObject_InitVar() is the fast version of PyObject_InitVar(). + + These inline functions must not be called with op=NULL. */ +static inline void +_PyObject_Init(PyObject *op, PyTypeObject *typeobj) +{ + assert(op != NULL); + Py_SET_TYPE(op, typeobj); + if (_PyType_HasFeature(typeobj, Py_TPFLAGS_HEAPTYPE)) { + Py_INCREF(typeobj); + } + _Py_NewReference(op); +} + +static inline void +_PyObject_InitVar(PyVarObject *op, PyTypeObject *typeobj, Py_ssize_t size) +{ + assert(op != NULL); + Py_SET_SIZE(op, size); + _PyObject_Init((PyObject *)op, typeobj); +} + + +/* Tell the GC to track this object. + * + * The object must not be tracked by the GC. + * + * NB: While the object is tracked by the collector, it must be safe to call the + * ob_traverse method. + * + * Internal note: interp->gc.generation0->_gc_prev doesn't have any bit flags + * because it's not object header. So we don't use _PyGCHead_PREV() and + * _PyGCHead_SET_PREV() for it to avoid unnecessary bitwise operations. + * + * See also the public PyObject_GC_Track() function. + */ +static inline void _PyObject_GC_TRACK( +// The preprocessor removes _PyObject_ASSERT_FROM() calls if NDEBUG is defined +#ifndef NDEBUG + const char *filename, int lineno, +#endif + PyObject *op) +{ + _PyObject_ASSERT_FROM(op, !_PyObject_GC_IS_TRACKED(op), + "object already tracked by the garbage collector", + filename, lineno, __func__); + + PyGC_Head *gc = _Py_AS_GC(op); + _PyObject_ASSERT_FROM(op, + (gc->_gc_prev & _PyGC_PREV_MASK_COLLECTING) == 0, + "object is in generation which is garbage collected", + filename, lineno, __func__); + + PyInterpreterState *interp = _PyInterpreterState_GET(); + PyGC_Head *generation0 = interp->gc.generation0; + PyGC_Head *last = (PyGC_Head*)(generation0->_gc_prev); + _PyGCHead_SET_NEXT(last, gc); + _PyGCHead_SET_PREV(gc, last); + _PyGCHead_SET_NEXT(gc, generation0); + generation0->_gc_prev = (uintptr_t)gc; +} + +/* Tell the GC to stop tracking this object. + * + * Internal note: This may be called while GC. So _PyGC_PREV_MASK_COLLECTING + * must be cleared. But _PyGC_PREV_MASK_FINALIZED bit is kept. + * + * The object must be tracked by the GC. + * + * See also the public PyObject_GC_UnTrack() which accept an object which is + * not tracked. + */ +static inline void _PyObject_GC_UNTRACK( +// The preprocessor removes _PyObject_ASSERT_FROM() calls if NDEBUG is defined +#ifndef NDEBUG + const char *filename, int lineno, +#endif + PyObject *op) +{ + _PyObject_ASSERT_FROM(op, _PyObject_GC_IS_TRACKED(op), + "object not tracked by the garbage collector", + filename, lineno, __func__); + + PyGC_Head *gc = _Py_AS_GC(op); + PyGC_Head *prev = _PyGCHead_PREV(gc); + PyGC_Head *next = _PyGCHead_NEXT(gc); + _PyGCHead_SET_NEXT(prev, next); + _PyGCHead_SET_PREV(next, prev); + gc->_gc_next = 0; + gc->_gc_prev &= _PyGC_PREV_MASK_FINALIZED; +} + +// Macros to accept any type for the parameter, and to automatically pass +// the filename and the filename (if NDEBUG is not defined) where the macro +// is called. +#ifdef NDEBUG +# define _PyObject_GC_TRACK(op) \ + _PyObject_GC_TRACK(_PyObject_CAST(op)) +# define _PyObject_GC_UNTRACK(op) \ + _PyObject_GC_UNTRACK(_PyObject_CAST(op)) +#else +# define _PyObject_GC_TRACK(op) \ + _PyObject_GC_TRACK(__FILE__, __LINE__, _PyObject_CAST(op)) +# define _PyObject_GC_UNTRACK(op) \ + _PyObject_GC_UNTRACK(__FILE__, __LINE__, _PyObject_CAST(op)) +#endif + +#ifdef Py_REF_DEBUG +extern void _PyDebug_PrintTotalRefs(void); +#endif + +#ifdef Py_TRACE_REFS +extern void _Py_AddToAllObjects(PyObject *op, int force); +extern void _Py_PrintReferences(FILE *); +extern void _Py_PrintReferenceAddresses(FILE *); +#endif + +static inline PyObject ** +_PyObject_GET_WEAKREFS_LISTPTR(PyObject *op) +{ + Py_ssize_t offset = Py_TYPE(op)->tp_weaklistoffset; + return (PyObject **)((char *)op + offset); +} + +// Fast inlined version of PyObject_IS_GC() +static inline int +_PyObject_IS_GC(PyObject *obj) +{ + return (PyType_IS_GC(Py_TYPE(obj)) + && (Py_TYPE(obj)->tp_is_gc == NULL + || Py_TYPE(obj)->tp_is_gc(obj))); +} + +// Fast inlined version of PyType_IS_GC() +#define _PyType_IS_GC(t) _PyType_HasFeature((t), Py_TPFLAGS_HAVE_GC) + +// Usage: assert(_Py_CheckSlotResult(obj, "__getitem__", result != NULL)); +extern int _Py_CheckSlotResult( + PyObject *obj, + const char *slot_name, + int success); + +// PyType_Ready() must be called if _PyType_IsReady() is false. +// See also the Py_TPFLAGS_READY flag. +#define _PyType_IsReady(type) ((type)->tp_dict != NULL) + +#ifdef __cplusplus +} +#endif +#endif /* !Py_INTERNAL_OBJECT_H */ diff --git a/.ci/python_dependencies_wins/include/internal/pycore_parser.h b/.ci/python_dependencies_wins/include/internal/pycore_parser.h new file mode 100644 index 00000000..20bffe99 --- /dev/null +++ b/.ci/python_dependencies_wins/include/internal/pycore_parser.h @@ -0,0 +1,31 @@ +#ifndef Py_INTERNAL_PARSER_H +#define Py_INTERNAL_PARSER_H +#ifdef __cplusplus +extern "C" { +#endif + +#ifndef Py_BUILD_CORE +# error "this header requires Py_BUILD_CORE define" +#endif + +extern struct _mod* _PyParser_ASTFromString( + const char *str, + PyObject* filename, + int mode, + PyCompilerFlags *flags, + PyArena *arena); +extern struct _mod* _PyParser_ASTFromFile( + FILE *fp, + PyObject *filename_ob, + const char *enc, + int mode, + const char *ps1, + const char *ps2, + PyCompilerFlags *flags, + int *errcode, + PyArena *arena); + +#ifdef __cplusplus +} +#endif +#endif /* !Py_INTERNAL_PARSER_H */ diff --git a/.ci/python_dependencies_wins/include/internal/pycore_pathconfig.h b/.ci/python_dependencies_wins/include/internal/pycore_pathconfig.h new file mode 100644 index 00000000..72a6ba18 --- /dev/null +++ b/.ci/python_dependencies_wins/include/internal/pycore_pathconfig.h @@ -0,0 +1,73 @@ +#ifndef Py_INTERNAL_PATHCONFIG_H +#define Py_INTERNAL_PATHCONFIG_H +#ifdef __cplusplus +extern "C" { +#endif + +#ifndef Py_BUILD_CORE +# error "this header requires Py_BUILD_CORE define" +#endif + +typedef struct _PyPathConfig { + /* Full path to the Python program */ + wchar_t *program_full_path; + wchar_t *prefix; + wchar_t *exec_prefix; + /* Set by Py_SetPath(), or computed by _PyConfig_InitPathConfig() */ + wchar_t *module_search_path; + /* Python program name */ + wchar_t *program_name; + /* Set by Py_SetPythonHome() or PYTHONHOME environment variable */ + wchar_t *home; +#ifdef MS_WINDOWS + /* isolated and site_import are used to set Py_IsolatedFlag and + Py_NoSiteFlag flags on Windows in read_pth_file(). These fields + are ignored when their value are equal to -1 (unset). */ + int isolated; + int site_import; + /* Set when a venv is detected */ + wchar_t *base_executable; +#endif +} _PyPathConfig; + +#ifdef MS_WINDOWS +# define _PyPathConfig_INIT \ + {.module_search_path = NULL, \ + .isolated = -1, \ + .site_import = -1} +#else +# define _PyPathConfig_INIT \ + {.module_search_path = NULL} +#endif +/* Note: _PyPathConfig_INIT sets other fields to 0/NULL */ + +PyAPI_DATA(_PyPathConfig) _Py_path_config; +#ifdef MS_WINDOWS +PyAPI_DATA(wchar_t*) _Py_dll_path; +#endif + +extern void _PyPathConfig_ClearGlobal(void); + +extern PyStatus _PyPathConfig_Calculate( + _PyPathConfig *pathconfig, + const PyConfig *config); +extern int _PyPathConfig_ComputeSysPath0( + const PyWideStringList *argv, + PyObject **path0); +extern PyStatus _Py_FindEnvConfigValue( + FILE *env_file, + const wchar_t *key, + wchar_t **value_p); + +#ifdef MS_WINDOWS +extern wchar_t* _Py_GetDLLPath(void); +#endif + +extern PyStatus _PyConfig_WritePathConfig(const PyConfig *config); +extern void _Py_DumpPathConfig(PyThreadState *tstate); +extern PyObject* _PyPathConfig_AsDict(void); + +#ifdef __cplusplus +} +#endif +#endif /* !Py_INTERNAL_PATHCONFIG_H */ diff --git a/.ci/python_dependencies_wins/include/internal/pycore_pyarena.h b/.ci/python_dependencies_wins/include/internal/pycore_pyarena.h new file mode 100644 index 00000000..6d6ddc5a --- /dev/null +++ b/.ci/python_dependencies_wins/include/internal/pycore_pyarena.h @@ -0,0 +1,64 @@ +/* An arena-like memory interface for the compiler. + */ + +#ifndef Py_INTERNAL_PYARENA_H +#define Py_INTERNAL_PYARENA_H +#ifdef __cplusplus +extern "C" { +#endif + +#ifndef Py_BUILD_CORE +# error "this header requires Py_BUILD_CORE define" +#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_INTERNAL_PYARENA_H */ diff --git a/.ci/python_dependencies_wins/include/internal/pycore_pyerrors.h b/.ci/python_dependencies_wins/include/internal/pycore_pyerrors.h new file mode 100644 index 00000000..99c5fd46 --- /dev/null +++ b/.ci/python_dependencies_wins/include/internal/pycore_pyerrors.h @@ -0,0 +1,96 @@ +#ifndef Py_INTERNAL_PYERRORS_H +#define Py_INTERNAL_PYERRORS_H +#ifdef __cplusplus +extern "C" { +#endif + +#ifndef Py_BUILD_CORE +# error "this header requires Py_BUILD_CORE define" +#endif + +static inline PyObject* _PyErr_Occurred(PyThreadState *tstate) +{ + assert(tstate != NULL); + return tstate->curexc_type; +} + +static inline void _PyErr_ClearExcState(_PyErr_StackItem *exc_state) +{ + PyObject *t, *v, *tb; + t = exc_state->exc_type; + v = exc_state->exc_value; + tb = exc_state->exc_traceback; + exc_state->exc_type = NULL; + exc_state->exc_value = NULL; + exc_state->exc_traceback = NULL; + Py_XDECREF(t); + Py_XDECREF(v); + Py_XDECREF(tb); +} + + +PyAPI_FUNC(void) _PyErr_Fetch( + PyThreadState *tstate, + PyObject **type, + PyObject **value, + PyObject **traceback); + +PyAPI_FUNC(int) _PyErr_ExceptionMatches( + PyThreadState *tstate, + PyObject *exc); + +PyAPI_FUNC(void) _PyErr_Restore( + PyThreadState *tstate, + PyObject *type, + PyObject *value, + PyObject *traceback); + +PyAPI_FUNC(void) _PyErr_SetObject( + PyThreadState *tstate, + PyObject *type, + PyObject *value); + +PyAPI_FUNC(void) _PyErr_ChainStackItem( + _PyErr_StackItem *exc_info); + +PyAPI_FUNC(void) _PyErr_Clear(PyThreadState *tstate); + +PyAPI_FUNC(void) _PyErr_SetNone(PyThreadState *tstate, PyObject *exception); + +PyAPI_FUNC(PyObject *) _PyErr_NoMemory(PyThreadState *tstate); + +PyAPI_FUNC(void) _PyErr_SetString( + PyThreadState *tstate, + PyObject *exception, + const char *string); + +PyAPI_FUNC(PyObject *) _PyErr_Format( + PyThreadState *tstate, + PyObject *exception, + const char *format, + ...); + +PyAPI_FUNC(void) _PyErr_NormalizeException( + PyThreadState *tstate, + PyObject **exc, + PyObject **val, + PyObject **tb); + +PyAPI_FUNC(PyObject *) _PyErr_FormatFromCauseTstate( + PyThreadState *tstate, + PyObject *exception, + const char *format, + ...); + +PyAPI_FUNC(int) _PyErr_CheckSignalsTstate(PyThreadState *tstate); + +PyAPI_FUNC(void) _Py_DumpExtensionModules(int fd, PyInterpreterState *interp); + +extern PyObject* _Py_Offer_Suggestions(PyObject* exception); +PyAPI_FUNC(Py_ssize_t) _Py_UTF8_Edit_Cost(PyObject *str_a, PyObject *str_b, + Py_ssize_t max_cost); + +#ifdef __cplusplus +} +#endif +#endif /* !Py_INTERNAL_PYERRORS_H */ diff --git a/.ci/python_dependencies_wins/include/internal/pycore_pyhash.h b/.ci/python_dependencies_wins/include/internal/pycore_pyhash.h new file mode 100644 index 00000000..53d44d90 --- /dev/null +++ b/.ci/python_dependencies_wins/include/internal/pycore_pyhash.h @@ -0,0 +1,10 @@ +#ifndef Py_INTERNAL_HASH_H +#define Py_INTERNAL_HASH_H + +#ifndef Py_BUILD_CORE +# error "this header requires Py_BUILD_CORE define" +#endif + +uint64_t _Py_KeyedHash(uint64_t, const char *, Py_ssize_t); + +#endif diff --git a/.ci/python_dependencies_wins/include/internal/pycore_pylifecycle.h b/.ci/python_dependencies_wins/include/internal/pycore_pylifecycle.h new file mode 100644 index 00000000..98bdba2f --- /dev/null +++ b/.ci/python_dependencies_wins/include/internal/pycore_pylifecycle.h @@ -0,0 +1,141 @@ +#ifndef Py_INTERNAL_LIFECYCLE_H +#define Py_INTERNAL_LIFECYCLE_H +#ifdef __cplusplus +extern "C" { +#endif + +#ifndef Py_BUILD_CORE +# error "this header requires Py_BUILD_CORE define" +#endif + +#ifdef HAVE_SIGNAL_H +#include +#endif + +#include "pycore_runtime.h" // _PyRuntimeState + +#ifndef NSIG +# if defined(_NSIG) +# define NSIG _NSIG /* For BSD/SysV */ +# elif defined(_SIGMAX) +# define NSIG (_SIGMAX + 1) /* For QNX */ +# elif defined(SIGMAX) +# define NSIG (SIGMAX + 1) /* For djgpp */ +# else +# define NSIG 64 /* Use a reasonable default value */ +# endif +#endif + +/* Forward declarations */ +struct _PyArgv; +struct pyruntimestate; + +/* True if the main interpreter thread exited due to an unhandled + * KeyboardInterrupt exception, suggesting the user pressed ^C. */ +PyAPI_DATA(int) _Py_UnhandledKeyboardInterrupt; + +extern int _Py_SetFileSystemEncoding( + const char *encoding, + const char *errors); +extern void _Py_ClearFileSystemEncoding(void); +extern PyStatus _PyUnicode_InitEncodings(PyThreadState *tstate); +#ifdef MS_WINDOWS +extern int _PyUnicode_EnableLegacyWindowsFSEncoding(void); +#endif + +PyAPI_FUNC(void) _Py_ClearStandardStreamEncoding(void); + +PyAPI_FUNC(int) _Py_IsLocaleCoercionTarget(const char *ctype_loc); + +/* Various one-time initializers */ + +extern PyStatus _PyUnicode_Init(PyInterpreterState *interp); +extern PyStatus _PyUnicode_InitTypes(void); +extern PyStatus _PyBytes_Init(PyInterpreterState *interp); +extern int _PyStructSequence_Init(void); +extern int _PyLong_Init(PyInterpreterState *interp); +extern int _PyLong_InitTypes(void); +extern PyStatus _PyTuple_Init(PyInterpreterState *interp); +extern PyStatus _PyFaulthandler_Init(int enable); +extern int _PyTraceMalloc_Init(int enable); +extern PyObject * _PyBuiltin_Init(PyInterpreterState *interp); +extern PyStatus _PySys_Create( + PyThreadState *tstate, + PyObject **sysmod_p); +extern PyStatus _PySys_ReadPreinitWarnOptions(PyWideStringList *options); +extern PyStatus _PySys_ReadPreinitXOptions(PyConfig *config); +extern int _PySys_UpdateConfig(PyThreadState *tstate); +extern PyStatus _PyExc_Init(PyInterpreterState *interp); +extern PyStatus _PyErr_InitTypes(void); +extern PyStatus _PyBuiltins_AddExceptions(PyObject * bltinmod); +extern void _PyFloat_Init(void); +extern int _PyFloat_InitTypes(void); +extern PyStatus _Py_HashRandomization_Init(const PyConfig *); + +extern PyStatus _PyTypes_Init(void); +extern PyStatus _PyTypes_InitSlotDefs(void); +extern PyStatus _PyImportZip_Init(PyThreadState *tstate); +extern PyStatus _PyGC_Init(PyInterpreterState *interp); +extern PyStatus _PyAtExit_Init(PyInterpreterState *interp); + + +/* Various internal finalizers */ + +extern void _PyFrame_Fini(PyInterpreterState *interp); +extern void _PyDict_Fini(PyInterpreterState *interp); +extern void _PyTuple_Fini(PyInterpreterState *interp); +extern void _PyList_Fini(PyInterpreterState *interp); +extern void _PyBytes_Fini(PyInterpreterState *interp); +extern void _PyFloat_Fini(PyInterpreterState *interp); +extern void _PySlice_Fini(PyInterpreterState *interp); +extern void _PyAsyncGen_Fini(PyInterpreterState *interp); + +extern int _PySignal_Init(int install_signal_handlers); +extern void _PySignal_Fini(void); + +extern void _PyExc_Fini(PyInterpreterState *interp); +extern void _PyImport_Fini(void); +extern void _PyImport_Fini2(void); +extern void _PyGC_Fini(PyInterpreterState *interp); +extern void _PyType_Fini(PyInterpreterState *interp); +extern void _Py_HashRandomization_Fini(void); +extern void _PyUnicode_Fini(PyInterpreterState *interp); +extern void _PyUnicode_ClearInterned(PyInterpreterState *interp); +extern void _PyLong_Fini(PyInterpreterState *interp); +extern void _PyFaulthandler_Fini(void); +extern void _PyHash_Fini(void); +extern void _PyTraceMalloc_Fini(void); +extern void _PyWarnings_Fini(PyInterpreterState *interp); +extern void _PyAST_Fini(PyInterpreterState *interp); +extern void _PyAtExit_Fini(PyInterpreterState *interp); + +extern PyStatus _PyGILState_Init(_PyRuntimeState *runtime); +extern PyStatus _PyGILState_SetTstate(PyThreadState *tstate); +extern void _PyGILState_Fini(PyInterpreterState *interp); + +PyAPI_FUNC(void) _PyGC_DumpShutdownStats(PyInterpreterState *interp); + +PyAPI_FUNC(PyStatus) _Py_PreInitializeFromPyArgv( + const PyPreConfig *src_config, + const struct _PyArgv *args); +PyAPI_FUNC(PyStatus) _Py_PreInitializeFromConfig( + const PyConfig *config, + const struct _PyArgv *args); + + +PyAPI_FUNC(int) _Py_HandleSystemExit(int *exitcode_p); + +PyAPI_FUNC(PyObject*) _PyErr_WriteUnraisableDefaultHook(PyObject *unraisable); + +PyAPI_FUNC(void) _PyErr_Print(PyThreadState *tstate); +PyAPI_FUNC(void) _PyErr_Display(PyObject *file, PyObject *exception, + PyObject *value, PyObject *tb); + +PyAPI_FUNC(void) _PyThreadState_DeleteCurrent(PyThreadState *tstate); + +extern void _PyAtExit_Call(PyInterpreterState *interp); + +#ifdef __cplusplus +} +#endif +#endif /* !Py_INTERNAL_LIFECYCLE_H */ diff --git a/.ci/python_dependencies_wins/include/internal/pycore_pymem.h b/.ci/python_dependencies_wins/include/internal/pycore_pymem.h new file mode 100644 index 00000000..fb83264d --- /dev/null +++ b/.ci/python_dependencies_wins/include/internal/pycore_pymem.h @@ -0,0 +1,101 @@ +#ifndef Py_INTERNAL_PYMEM_H +#define Py_INTERNAL_PYMEM_H +#ifdef __cplusplus +extern "C" { +#endif + +#ifndef Py_BUILD_CORE +# error "this header requires Py_BUILD_CORE define" +#endif + +#include "pymem.h" // PyMemAllocatorName + + +/* 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); + +/* Special bytes broadcast into debug memory blocks at appropriate times. + Strings of these are unlikely to be valid addresses, floats, ints or + 7-bit ASCII. + + - PYMEM_CLEANBYTE: clean (newly allocated) memory + - PYMEM_DEADBYTE dead (newly freed) memory + - PYMEM_FORBIDDENBYTE: untouchable bytes at each end of a block + + Byte patterns 0xCB, 0xDB and 0xFB have been replaced with 0xCD, 0xDD and + 0xFD to use the same values than Windows CRT debug malloc() and free(). + If modified, _PyMem_IsPtrFreed() should be updated as well. */ +#define PYMEM_CLEANBYTE 0xCD +#define PYMEM_DEADBYTE 0xDD +#define PYMEM_FORBIDDENBYTE 0xFD + +/* Heuristic checking if a pointer value is newly allocated + (uninitialized), newly freed or NULL (is equal to zero). + + 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(const void *ptr) +{ + uintptr_t value = (uintptr_t)ptr; +#if SIZEOF_VOID_P == 8 + return (value == 0 + || value == (uintptr_t)0xCDCDCDCDCDCDCDCD + || value == (uintptr_t)0xDDDDDDDDDDDDDDDD + || value == (uintptr_t)0xFDFDFDFDFDFDFDFD); +#elif SIZEOF_VOID_P == 4 + return (value == 0 + || value == (uintptr_t)0xCDCDCDCD + || value == (uintptr_t)0xDDDDDDDD + || value == (uintptr_t)0xFDFDFDFD); +#else +# error "unknown pointer size" +#endif +} + +PyAPI_FUNC(int) _PyMem_GetAllocatorName( + const char *name, + PyMemAllocatorName *allocator); + +/* Configure the Python memory allocators. + Pass PYMEM_ALLOCATOR_DEFAULT to use default allocators. + PYMEM_ALLOCATOR_NOT_SET does nothing. */ +PyAPI_FUNC(int) _PyMem_SetupAllocators(PyMemAllocatorName allocator); + +struct _PyTraceMalloc_Config { + /* Module initialized? + Variable protected by the GIL */ + enum { + TRACEMALLOC_NOT_INITIALIZED, + TRACEMALLOC_INITIALIZED, + TRACEMALLOC_FINALIZED + } initialized; + + /* Is tracemalloc tracing memory allocations? + Variable protected by the GIL */ + int tracing; + + /* limit of the number of frames in a traceback, 1 by default. + Variable protected by the GIL. */ + int max_nframe; +}; + +#define _PyTraceMalloc_Config_INIT \ + {.initialized = TRACEMALLOC_NOT_INITIALIZED, \ + .tracing = 0, \ + .max_nframe = 1} + +PyAPI_DATA(struct _PyTraceMalloc_Config) _Py_tracemalloc_config; + + +#ifdef __cplusplus +} +#endif +#endif /* !Py_INTERNAL_PYMEM_H */ diff --git a/.ci/python_dependencies_wins/include/internal/pycore_pystate.h b/.ci/python_dependencies_wins/include/internal/pycore_pystate.h new file mode 100644 index 00000000..5ef5e590 --- /dev/null +++ b/.ci/python_dependencies_wins/include/internal/pycore_pystate.h @@ -0,0 +1,153 @@ +#ifndef Py_INTERNAL_PYSTATE_H +#define Py_INTERNAL_PYSTATE_H +#ifdef __cplusplus +extern "C" { +#endif + +#ifndef Py_BUILD_CORE +# error "this header requires Py_BUILD_CORE define" +#endif + +#include "pycore_runtime.h" /* PyRuntimeState */ + + +/* Check if the current thread is the main thread. + Use _Py_IsMainInterpreter() to check if it's the main interpreter. */ +static inline int +_Py_IsMainThread(void) +{ + unsigned long thread = PyThread_get_thread_ident(); + return (thread == _PyRuntime.main_thread); +} + + +static inline int +_Py_IsMainInterpreter(PyInterpreterState *interp) +{ + /* Use directly _PyRuntime rather than tstate->interp->runtime, since + this function is used in performance critical code path (ceval) */ + return (interp == _PyRuntime.interpreters.main); +} + + +/* Only handle signals on the main thread of the main interpreter. */ +static inline int +_Py_ThreadCanHandleSignals(PyInterpreterState *interp) +{ + return (_Py_IsMainThread() && interp == _PyRuntime.interpreters.main); +} + + +/* Only execute pending calls on the main thread. */ +static inline int +_Py_ThreadCanHandlePendingCalls(void) +{ + return _Py_IsMainThread(); +} + + +/* Variable and macro for in-line access to current thread + and interpreter state */ + +#ifdef EXPERIMENTAL_ISOLATED_SUBINTERPRETERS +PyAPI_FUNC(PyThreadState*) _PyThreadState_GetTSS(void); +#endif + +static inline PyThreadState* +_PyRuntimeState_GetThreadState(_PyRuntimeState *runtime) +{ +#ifdef EXPERIMENTAL_ISOLATED_SUBINTERPRETERS + return _PyThreadState_GetTSS(); +#else + return (PyThreadState*)_Py_atomic_load_relaxed(&runtime->gilstate.tstate_current); +#endif +} + +/* Get the current Python thread state. + + Efficient macro reading directly the 'gilstate.tstate_current' atomic + variable. The macro is unsafe: it does not check for error and it can + return NULL. + + The caller must hold the GIL. + + See also PyThreadState_Get() and PyThreadState_GET(). */ +static inline PyThreadState* +_PyThreadState_GET(void) +{ +#ifdef EXPERIMENTAL_ISOLATED_SUBINTERPRETERS + return _PyThreadState_GetTSS(); +#else + return _PyRuntimeState_GetThreadState(&_PyRuntime); +#endif +} + +/* Redefine PyThreadState_GET() as an alias to _PyThreadState_GET() */ +#undef PyThreadState_GET +#define PyThreadState_GET() _PyThreadState_GET() + +PyAPI_FUNC(void) _Py_NO_RETURN _Py_FatalError_TstateNULL(const char *func); + +static inline void +_Py_EnsureFuncTstateNotNULL(const char *func, PyThreadState *tstate) +{ + if (tstate == NULL) { + _Py_FatalError_TstateNULL(func); + } +} + +// Call Py_FatalError() if tstate is NULL +#define _Py_EnsureTstateNotNULL(tstate) \ + _Py_EnsureFuncTstateNotNULL(__func__, tstate) + + +/* Get the current interpreter state. + + The macro is unsafe: it does not check for error and it can return NULL. + + The caller must hold the GIL. + + See also _PyInterpreterState_Get() + and _PyGILState_GetInterpreterStateUnsafe(). */ +static inline PyInterpreterState* _PyInterpreterState_GET(void) { + PyThreadState *tstate = _PyThreadState_GET(); +#ifdef Py_DEBUG + _Py_EnsureTstateNotNULL(tstate); +#endif + return tstate->interp; +} + + +/* Other */ + +PyAPI_FUNC(void) _PyThreadState_Init( + PyThreadState *tstate); +PyAPI_FUNC(void) _PyThreadState_DeleteExcept( + _PyRuntimeState *runtime, + PyThreadState *tstate); + +PyAPI_FUNC(PyThreadState *) _PyThreadState_Swap( + struct _gilstate_runtime_state *gilstate, + PyThreadState *newts); + +PyAPI_FUNC(PyStatus) _PyInterpreterState_Enable(_PyRuntimeState *runtime); + +#ifdef HAVE_FORK +extern PyStatus _PyInterpreterState_DeleteExceptMain(_PyRuntimeState *runtime); +extern PyStatus _PyGILState_Reinit(_PyRuntimeState *runtime); +extern void _PySignal_AfterFork(void); +#endif + + +PyAPI_FUNC(int) _PyState_AddModule( + PyThreadState *tstate, + PyObject* module, + struct PyModuleDef* def); + + +PyAPI_FUNC(int) _PyOS_InterruptOccurred(PyThreadState *tstate); + +#ifdef __cplusplus +} +#endif +#endif /* !Py_INTERNAL_PYSTATE_H */ diff --git a/.ci/python_dependencies_wins/include/internal/pycore_runtime.h b/.ci/python_dependencies_wins/include/internal/pycore_runtime.h new file mode 100644 index 00000000..ad747219 --- /dev/null +++ b/.ci/python_dependencies_wins/include/internal/pycore_runtime.h @@ -0,0 +1,157 @@ +#ifndef Py_INTERNAL_RUNTIME_H +#define Py_INTERNAL_RUNTIME_H +#ifdef __cplusplus +extern "C" { +#endif + +#ifndef Py_BUILD_CORE +# error "this header requires Py_BUILD_CORE define" +#endif + +#include "pycore_atomic.h" /* _Py_atomic_address */ +#include "pycore_gil.h" // struct _gil_runtime_state + +/* ceval state */ + +struct _ceval_runtime_state { + /* Request for checking signals. It is shared by all interpreters (see + bpo-40513). Any thread of any interpreter can receive a signal, but only + the main thread of the main interpreter can handle signals: see + _Py_ThreadCanHandleSignals(). */ + _Py_atomic_int signals_pending; +#ifndef EXPERIMENTAL_ISOLATED_SUBINTERPRETERS + struct _gil_runtime_state gil; +#endif +}; + +/* GIL state */ + +struct _gilstate_runtime_state { + /* bpo-26558: Flag to disable PyGILState_Check(). + If set to non-zero, PyGILState_Check() always return 1. */ + int check_enabled; + /* Assuming the current thread holds the GIL, this is the + PyThreadState for the current thread. */ + _Py_atomic_address tstate_current; + /* 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; +}; + +/* Runtime audit hook state */ + +typedef struct _Py_AuditHookEntry { + struct _Py_AuditHookEntry *next; + Py_AuditHookFunction hookCFunction; + void *userData; +} _Py_AuditHookEntry; + +struct _Py_unicode_runtime_ids { + PyThread_type_lock lock; + // next_index value must be preserved when Py_Initialize()/Py_Finalize() + // is called multiple times: see _PyUnicode_FromId() implementation. + Py_ssize_t next_index; +}; + +/* Full Python runtime state */ + +typedef struct pyruntimestate { + /* Is running Py_PreInitialize()? */ + int preinitializing; + + /* Is Python preinitialized? Set to 1 by Py_PreInitialize() */ + int preinitialized; + + /* Is Python core initialized? Set to 1 by _Py_InitializeCore() */ + int core_initialized; + + /* Is Python fully initialized? Set to 1 by Py_Initialize() */ + int initialized; + + /* Set by Py_FinalizeEx(). Only reset to NULL if Py_Initialize() + is called again. + + Use _PyRuntimeState_GetFinalizing() and _PyRuntimeState_SetFinalizing() + to access it, don't access it directly. */ + _Py_atomic_address _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; + // XXX Remove this field once we have a tp_* slot. + struct _xidregistry { + PyThread_type_lock mutex; + struct _xidregitem *head; + } xidregistry; + + unsigned long main_thread; + +#define NEXITFUNCS 32 + void (*exitfuncs[NEXITFUNCS])(void); + int nexitfuncs; + + struct _ceval_runtime_state ceval; + struct _gilstate_runtime_state gilstate; + + PyPreConfig preconfig; + + // Audit values must be preserved when Py_Initialize()/Py_Finalize() + // is called multiple times. + Py_OpenCodeHookFunction open_code_hook; + void *open_code_userdata; + _Py_AuditHookEntry *audit_hook_head; + + struct _Py_unicode_runtime_ids unicode_ids; + + // XXX Consolidate globals found via the check-c-globals script. +} _PyRuntimeState; + +#define _PyRuntimeState_INIT \ + {.preinitialized = 0, .core_initialized = 0, .initialized = 0} +/* Note: _PyRuntimeState_INIT sets other fields to 0/NULL */ + + +PyAPI_DATA(_PyRuntimeState) _PyRuntime; + +PyAPI_FUNC(PyStatus) _PyRuntimeState_Init(_PyRuntimeState *runtime); +PyAPI_FUNC(void) _PyRuntimeState_Fini(_PyRuntimeState *runtime); + +#ifdef HAVE_FORK +extern PyStatus _PyRuntimeState_ReInitThreads(_PyRuntimeState *runtime); +#endif + +/* Initialize _PyRuntimeState. + Return NULL on success, or return an error message on failure. */ +PyAPI_FUNC(PyStatus) _PyRuntime_Initialize(void); + +PyAPI_FUNC(void) _PyRuntime_Finalize(void); + + +static inline PyThreadState* +_PyRuntimeState_GetFinalizing(_PyRuntimeState *runtime) { + return (PyThreadState*)_Py_atomic_load_relaxed(&runtime->_finalizing); +} + +static inline void +_PyRuntimeState_SetFinalizing(_PyRuntimeState *runtime, PyThreadState *tstate) { + _Py_atomic_store_relaxed(&runtime->_finalizing, (uintptr_t)tstate); +} + +#ifdef __cplusplus +} +#endif +#endif /* !Py_INTERNAL_RUNTIME_H */ diff --git a/.ci/python_dependencies_wins/include/internal/pycore_structseq.h b/.ci/python_dependencies_wins/include/internal/pycore_structseq.h new file mode 100644 index 00000000..2792ec17 --- /dev/null +++ b/.ci/python_dependencies_wins/include/internal/pycore_structseq.h @@ -0,0 +1,21 @@ +#ifndef Py_INTERNAL_STRUCTSEQ_H +#define Py_INTERNAL_STRUCTSEQ_H +#ifdef __cplusplus +extern "C" { +#endif + +#ifndef Py_BUILD_CORE +# error "this header requires Py_BUILD_CORE define" +#endif + + +PyAPI_FUNC(int) _PyStructSequence_InitType( + PyTypeObject *type, + PyStructSequence_Desc *desc, + unsigned long tp_flags); + + +#ifdef __cplusplus +} +#endif +#endif /* !Py_INTERNAL_STRUCTSEQ_H */ diff --git a/.ci/python_dependencies_wins/include/internal/pycore_symtable.h b/.ci/python_dependencies_wins/include/internal/pycore_symtable.h new file mode 100644 index 00000000..4e73fe37 --- /dev/null +++ b/.ci/python_dependencies_wins/include/internal/pycore_symtable.h @@ -0,0 +1,133 @@ +#ifndef Py_INTERNAL_SYMTABLE_H +#define Py_INTERNAL_SYMTABLE_H +#ifdef __cplusplus +extern "C" { +#endif + +#ifndef Py_BUILD_CORE +# error "this header requires Py_BUILD_CORE define" +#endif + +struct _mod; // Type defined in pycore_ast.h + +typedef enum _block_type { FunctionBlock, ClassBlock, ModuleBlock, AnnotationBlock } + _Py_block_ty; + +typedef enum _comprehension_type { + NoComprehension = 0, + ListComprehension = 1, + DictComprehension = 2, + SetComprehension = 3, + GeneratorExpression = 4 } _Py_comprehension_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 */ + _Py_comprehension_ty ste_comprehension; /* Kind of comprehension (if any) */ + 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 */ + unsigned ste_comp_iter_target : 1; /* true if visiting comprehension target */ + int ste_comp_iter_expr; /* non-zero if visiting a comprehension range expression */ + int ste_lineno; /* first line of block */ + int ste_col_offset; /* offset of first line of block */ + int ste_end_lineno; /* end line of block */ + int ste_end_col_offset; /* end 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; + +extern PyTypeObject PySTEntry_Type; + +#define PySTEntry_Check(op) Py_IS_TYPE(op, &PySTEntry_Type) + +extern int _PyST_GetScope(PySTEntryObject *, PyObject *); + +extern struct symtable* _PySymtable_Build( + struct _mod *mod, + PyObject *filename, + PyFutureFeatures *future); +PyAPI_FUNC(PySTEntryObject *) PySymtable_Lookup(struct symtable *, void *); + +extern 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_COMP_ITER 2<<8 /* this name is a comprehension iteration variable */ + +#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 + +// Used by symtablemodule.c +extern struct symtable* _Py_SymtableStringObjectFlags( + const char *str, + PyObject *filename, + int start, + PyCompilerFlags *flags); + +#ifdef __cplusplus +} +#endif +#endif /* !Py_INTERNAL_SYMTABLE_H */ diff --git a/.ci/python_dependencies_wins/include/internal/pycore_sysmodule.h b/.ci/python_dependencies_wins/include/internal/pycore_sysmodule.h new file mode 100644 index 00000000..363eb873 --- /dev/null +++ b/.ci/python_dependencies_wins/include/internal/pycore_sysmodule.h @@ -0,0 +1,24 @@ +#ifndef Py_INTERNAL_SYSMODULE_H +#define Py_INTERNAL_SYSMODULE_H +#ifdef __cplusplus +extern "C" { +#endif + +#ifndef Py_BUILD_CORE +# error "this header requires Py_BUILD_CORE define" +#endif + +PyAPI_FUNC(int) _PySys_Audit( + PyThreadState *tstate, + const char *event, + const char *argFormat, + ...); + +/* We want minimal exposure of this function, so use extern rather than + PyAPI_FUNC() to not export the symbol. */ +extern void _PySys_ClearAuditHooks(PyThreadState *tstate); + +#ifdef __cplusplus +} +#endif +#endif /* !Py_INTERNAL_SYSMODULE_H */ diff --git a/.ci/python_dependencies_wins/include/internal/pycore_traceback.h b/.ci/python_dependencies_wins/include/internal/pycore_traceback.h new file mode 100644 index 00000000..025ddb1d --- /dev/null +++ b/.ci/python_dependencies_wins/include/internal/pycore_traceback.h @@ -0,0 +1,93 @@ +#ifndef Py_INTERNAL_TRACEBACK_H +#define Py_INTERNAL_TRACEBACK_H +#ifdef __cplusplus +extern "C" { +#endif + +#ifndef Py_BUILD_CORE +# error "this header requires Py_BUILD_CORE define" +#endif + +/* Forward declaration */ +struct _is; + +/* 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 this information. + + This function is signal safe. */ + +PyAPI_FUNC(const char*) _Py_DumpTracebackThreads( + int fd, + struct _is *interp, + PyThreadState *current_tstate); + +/* 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, + size_t value); + +/* Format an integer as hexadecimal with width digits into fd file descriptor. + The function is signal safe. */ +PyAPI_FUNC(void) _Py_DumpHexadecimal( + int fd, + uintptr_t value, + Py_ssize_t width); + +PyAPI_FUNC(PyObject*) _PyTraceBack_FromFrame( + PyObject *tb_next, + PyFrameObject *frame); + +#ifdef __cplusplus +} +#endif +#endif /* !Py_INTERNAL_TRACEBACK_H */ diff --git a/.ci/python_dependencies_wins/include/internal/pycore_tuple.h b/.ci/python_dependencies_wins/include/internal/pycore_tuple.h new file mode 100644 index 00000000..28f3e0c6 --- /dev/null +++ b/.ci/python_dependencies_wins/include/internal/pycore_tuple.h @@ -0,0 +1,20 @@ +#ifndef Py_INTERNAL_TUPLE_H +#define Py_INTERNAL_TUPLE_H +#ifdef __cplusplus +extern "C" { +#endif + +#ifndef Py_BUILD_CORE +# error "this header requires Py_BUILD_CORE define" +#endif + +#include "tupleobject.h" /* _PyTuple_CAST() */ + +#define _PyTuple_ITEMS(op) (_PyTuple_CAST(op)->ob_item) + +PyAPI_FUNC(PyObject *) _PyTuple_FromArray(PyObject *const *, Py_ssize_t); + +#ifdef __cplusplus +} +#endif +#endif /* !Py_INTERNAL_TUPLE_H */ diff --git a/.ci/python_dependencies_wins/include/internal/pycore_ucnhash.h b/.ci/python_dependencies_wins/include/internal/pycore_ucnhash.h new file mode 100644 index 00000000..c7b559fc --- /dev/null +++ b/.ci/python_dependencies_wins/include/internal/pycore_ucnhash.h @@ -0,0 +1,34 @@ +/* Unicode name database interface */ +#ifndef Py_INTERNAL_UCNHASH_H +#define Py_INTERNAL_UCNHASH_H +#ifdef __cplusplus +extern "C" { +#endif + +#ifndef Py_BUILD_CORE +# error "this header requires Py_BUILD_CORE define" +#endif + +/* revised ucnhash CAPI interface (exported through a "wrapper") */ + +#define PyUnicodeData_CAPSULE_NAME "unicodedata._ucnhash_CAPI" + +typedef struct { + + /* Get name for a given character code. + Returns non-zero if success, zero if not. + Does not set Python exceptions. */ + int (*getname)(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)(const char* name, int namelen, Py_UCS4* code, + int with_named_seq); + +} _PyUnicode_Name_CAPI; + +#ifdef __cplusplus +} +#endif +#endif /* !Py_INTERNAL_UCNHASH_H */ diff --git a/.ci/python_dependencies_wins/include/internal/pycore_unionobject.h b/.ci/python_dependencies_wins/include/internal/pycore_unionobject.h new file mode 100644 index 00000000..469b9c44 --- /dev/null +++ b/.ci/python_dependencies_wins/include/internal/pycore_unionobject.h @@ -0,0 +1,22 @@ +#ifndef Py_INTERNAL_UNIONOBJECT_H +#define Py_INTERNAL_UNIONOBJECT_H +#ifdef __cplusplus +extern "C" { +#endif + +#ifndef Py_BUILD_CORE +# error "this header requires Py_BUILD_CORE define" +#endif + +extern PyTypeObject _PyUnion_Type; +#define _PyUnion_Check(op) Py_IS_TYPE(op, &_PyUnion_Type) +extern PyObject *_Py_union_type_or(PyObject *, PyObject *); + +#define _PyGenericAlias_Check(op) PyObject_TypeCheck(op, &Py_GenericAliasType) +extern PyObject *_Py_subs_parameters(PyObject *, PyObject *, PyObject *, PyObject *); +extern PyObject *_Py_make_parameters(PyObject *); + +#ifdef __cplusplus +} +#endif +#endif /* !Py_INTERNAL_UNIONOBJECT_H */ diff --git a/.ci/python_dependencies_wins/include/internal/pycore_warnings.h b/.ci/python_dependencies_wins/include/internal/pycore_warnings.h new file mode 100644 index 00000000..e7521c10 --- /dev/null +++ b/.ci/python_dependencies_wins/include/internal/pycore_warnings.h @@ -0,0 +1,25 @@ +#ifndef Py_INTERNAL_WARNINGS_H +#define Py_INTERNAL_WARNINGS_H +#ifdef __cplusplus +extern "C" { +#endif + +#ifndef Py_BUILD_CORE +# error "this header requires Py_BUILD_CORE define" +#endif + +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; +}; + +extern int _PyWarnings_InitState(PyInterpreterState *interp); + +#ifdef __cplusplus +} +#endif +#endif /* !Py_INTERNAL_WARNINGS_H */ diff --git a/.ci/python_dependencies_wins/include/interpreteridobject.h b/.ci/python_dependencies_wins/include/interpreteridobject.h new file mode 100644 index 00000000..c8b5f953 --- /dev/null +++ b/.ci/python_dependencies_wins/include/interpreteridobject.h @@ -0,0 +1,17 @@ +#ifndef Py_INTERPRETERIDOBJECT_H +#define Py_INTERPRETERIDOBJECT_H + +#ifdef __cplusplus +extern "C" { +#endif + +#ifndef Py_LIMITED_API +# define Py_CPYTHON_INTERPRETERIDOBJECT_H +# include "cpython/interpreteridobject.h" +# undef Py_CPYTHON_INTERPRETERIDOBJECT_H +#endif + +#ifdef __cplusplus +} +#endif +#endif /* !Py_INTERPRETERIDOBJECT_H */ diff --git a/.ci/python_dependencies_wins/include/intrcheck.h b/.ci/python_dependencies_wins/include/intrcheck.h new file mode 100644 index 00000000..86597870 --- /dev/null +++ b/.ci/python_dependencies_wins/include/intrcheck.h @@ -0,0 +1,30 @@ +#ifndef Py_INTRCHECK_H +#define Py_INTRCHECK_H +#ifdef __cplusplus +extern "C" { +#endif + +PyAPI_FUNC(int) PyOS_InterruptOccurred(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 */ +Py_DEPRECATED(3.7) PyAPI_FUNC(void) PyOS_AfterFork(void); + +#ifndef Py_LIMITED_API +PyAPI_FUNC(int) _PyOS_IsMainThread(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/.ci/python_dependencies_wins/include/iterobject.h b/.ci/python_dependencies_wins/include/iterobject.h new file mode 100644 index 00000000..38ce0acf --- /dev/null +++ b/.ci/python_dependencies_wins/include/iterobject.h @@ -0,0 +1,27 @@ +#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; +#ifdef Py_BUILD_CORE +extern PyTypeObject _PyAnextAwaitable_Type; +#endif + +#define PySeqIter_Check(op) Py_IS_TYPE(op, &PySeqIter_Type) + +PyAPI_FUNC(PyObject *) PySeqIter_New(PyObject *); + + +#define PyCallIter_Check(op) Py_IS_TYPE(op, &PyCallIter_Type) + +PyAPI_FUNC(PyObject *) PyCallIter_New(PyObject *, PyObject *); + +#ifdef __cplusplus +} +#endif +#endif /* !Py_ITEROBJECT_H */ + diff --git a/.ci/python_dependencies_wins/include/listobject.h b/.ci/python_dependencies_wins/include/listobject.h new file mode 100644 index 00000000..28273493 --- /dev/null +++ b/.ci/python_dependencies_wins/include/listobject.h @@ -0,0 +1,52 @@ +/* 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 + +PyAPI_DATA(PyTypeObject) PyList_Type; +PyAPI_DATA(PyTypeObject) PyListIter_Type; +PyAPI_DATA(PyTypeObject) PyListRevIter_Type; + +#define PyList_Check(op) \ + PyType_FastSubclass(Py_TYPE(op), Py_TPFLAGS_LIST_SUBCLASS) +#define PyList_CheckExact(op) Py_IS_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 +# define Py_CPYTHON_LISTOBJECT_H +# include "cpython/listobject.h" +# undef Py_CPYTHON_LISTOBJECT_H +#endif + +#ifdef __cplusplus +} +#endif +#endif /* !Py_LISTOBJECT_H */ diff --git a/.ci/python_dependencies_wins/include/longintrepr.h b/.ci/python_dependencies_wins/include/longintrepr.h new file mode 100644 index 00000000..cc02f2b3 --- /dev/null +++ b/.ci/python_dependencies_wins/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/.ci/python_dependencies_wins/include/longobject.h b/.ci/python_dependencies_wins/include/longobject.h new file mode 100644 index 00000000..8b85ae97 --- /dev/null +++ b/.ci/python_dependencies_wins/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_IS_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 */ + +#ifndef Py_LIMITED_API +PyAPI_FUNC(int) _PyLong_UnsignedShort_Converter(PyObject *, void *); +PyAPI_FUNC(int) _PyLong_UnsignedInt_Converter(PyObject *, void *); +PyAPI_FUNC(int) _PyLong_UnsignedLong_Converter(PyObject *, void *); +PyAPI_FUNC(int) _PyLong_UnsignedLongLong_Converter(PyObject *, void *); +PyAPI_FUNC(int) _PyLong_Size_t_Converter(PyObject *, void *); +#endif + +/* Used by Python/mystrtoul.c, _PyBytes_FromHex(), + _PyBytes_DecodeEscape(), 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_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_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_FUNC(PyObject *) _PyLong_Rshift(PyObject *, size_t); +PyAPI_FUNC(PyObject *) _PyLong_Lshift(PyObject *, size_t); +#endif + +#ifdef __cplusplus +} +#endif +#endif /* !Py_LONGOBJECT_H */ diff --git a/.ci/python_dependencies_wins/include/marshal.h b/.ci/python_dependencies_wins/include/marshal.h new file mode 100644 index 00000000..de9dfbbf --- /dev/null +++ b/.ci/python_dependencies_wins/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/.ci/python_dependencies_wins/include/memoryobject.h b/.ci/python_dependencies_wins/include/memoryobject.h new file mode 100644 index 00000000..3a7f2c20 --- /dev/null +++ b/.ci/python_dependencies_wins/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_IS_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/.ci/python_dependencies_wins/include/methodobject.h b/.ci/python_dependencies_wins/include/methodobject.h new file mode 100644 index 00000000..2456329c --- /dev/null +++ b/.ci/python_dependencies_wins/include/methodobject.h @@ -0,0 +1,116 @@ + +/* 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_CheckExact(op) Py_IS_TYPE(op, &PyCFunction_Type) +#define PyCFunction_Check(op) PyObject_TypeCheck(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 *(*PyCMethod)(PyObject *, PyTypeObject *, PyObject *const *, + size_t, PyObject *); + +PyAPI_FUNC(PyCFunction) PyCFunction_GetFunction(PyObject *); +PyAPI_FUNC(PyObject *) PyCFunction_GetSelf(PyObject *); +PyAPI_FUNC(int) PyCFunction_GetFlags(PyObject *); + +Py_DEPRECATED(3.9) PyAPI_FUNC(PyObject *) PyCFunction_Call(PyObject *, PyObject *, PyObject *); + +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; + +/* PyCFunction_New is declared as a function for stable ABI (declaration is + * needed for e.g. GCC with -fvisibility=hidden), but redefined as a macro + * that calls PyCFunction_NewEx. */ +PyAPI_FUNC(PyObject *) PyCFunction_New(PyMethodDef *, PyObject *); +#define PyCFunction_New(ML, SELF) PyCFunction_NewEx((ML), (SELF), NULL) + +/* PyCFunction_NewEx is similar: on 3.9+, this calls PyCMethod_New. */ +PyAPI_FUNC(PyObject *) PyCFunction_NewEx(PyMethodDef *, PyObject *, + PyObject *); + +#if !defined(Py_LIMITED_API) || Py_LIMITED_API+0 >= 0x03090000 +#define PyCFunction_NewEx(ML, SELF, MOD) PyCMethod_New((ML), (SELF), (MOD), NULL) +PyAPI_FUNC(PyObject *) PyCMethod_New(PyMethodDef *, PyObject *, + PyObject *, PyTypeObject *); +#endif + + +/* 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 + +#if !defined(Py_LIMITED_API) || Py_LIMITED_API+0 >= 0x030a0000 +# define METH_FASTCALL 0x0080 +#endif + +/* This bit is preserved for Stackless Python */ +#ifdef STACKLESS +# define METH_STACKLESS 0x0100 +#else +# define METH_STACKLESS 0x0000 +#endif + +/* METH_METHOD means the function stores an + * additional reference to the class that defines it; + * both self and class are passed to it. + * It uses PyCMethodObject instead of PyCFunctionObject. + * May not be combined with METH_NOARGS, METH_O, METH_CLASS or METH_STATIC. + */ + +#if !defined(Py_LIMITED_API) || Py_LIMITED_API+0 >= 0x03090000 +#define METH_METHOD 0x0200 +#endif + + +#ifndef Py_LIMITED_API + +#define Py_CPYTHON_METHODOBJECT_H +#include "cpython/methodobject.h" +#undef Py_CPYTHON_METHODOBJECT_H + +#endif + +#ifdef __cplusplus +} +#endif +#endif /* !Py_METHODOBJECT_H */ diff --git a/.ci/python_dependencies_wins/include/modsupport.h b/.ci/python_dependencies_wins/include/modsupport.h new file mode 100644 index 00000000..2c18c207 --- /dev/null +++ b/.ci/python_dependencies_wins/include/modsupport.h @@ -0,0 +1,263 @@ + +#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_NoKwnames(const char *funcname, PyObject *kwnames); +PyAPI_FUNC(int) _PyArg_NoPositional(const char *funcname, PyObject *args); +#define _PyArg_NoKeywords(funcname, kwargs) \ + ((kwargs) == NULL || _PyArg_NoKeywords((funcname), (kwargs))) +#define _PyArg_NoKwnames(funcname, kwnames) \ + ((kwnames) == NULL || _PyArg_NoKwnames((funcname), (kwnames))) +#define _PyArg_NoPositional(funcname, args) \ + ((args) == NULL || _PyArg_NoPositional((funcname), (args))) + +PyAPI_FUNC(void) _PyArg_BadArgument(const char *, const char *, const char *, PyObject *); +PyAPI_FUNC(int) _PyArg_CheckPositional(const char *, Py_ssize_t, + Py_ssize_t, Py_ssize_t); +#define _PyArg_CheckPositional(funcname, nargs, min, max) \ + (((min) <= (nargs) && (nargs) <= (max)) \ + || _PyArg_CheckPositional((funcname), (nargs), (min), (max))) + +#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); +PyAPI_FUNC(PyObject * const *) _PyArg_UnpackKeywords( + PyObject *const *args, Py_ssize_t nargs, + PyObject *kwargs, PyObject *kwnames, + struct _PyArg_Parser *parser, + int minpos, int maxpos, int minkw, + PyObject **buf); +#define _PyArg_UnpackKeywords(args, nargs, kwargs, kwnames, parser, minpos, maxpos, minkw, buf) \ + (((minkw) == 0 && (kwargs) == NULL && (kwnames) == NULL && \ + (minpos) <= (nargs) && (nargs) <= (maxpos) && args != NULL) ? (args) : \ + _PyArg_UnpackKeywords((args), (nargs), (kwargs), (kwnames), (parser), \ + (minpos), (maxpos), (minkw), (buf))) + +void _PyArg_Fini(void); +#endif /* Py_LIMITED_API */ + +// Add an attribute with name 'name' and value 'obj' to the module 'mod. +// On success, return 0 on success. +// On error, raise an exception and return -1. +PyAPI_FUNC(int) PyModule_AddObjectRef(PyObject *mod, const char *name, PyObject *value); + +// Similar to PyModule_AddObjectRef() but steal a reference to 'obj' +// (Py_DECREF(obj)) on success (if it returns 0). +PyAPI_FUNC(int) PyModule_AddObject(PyObject *mod, const char *, PyObject *value); + +PyAPI_FUNC(int) PyModule_AddIntConstant(PyObject *, const char *, long); +PyAPI_FUNC(int) PyModule_AddStringConstant(PyObject *, const char *, const char *); +#if !defined(Py_LIMITED_API) || Py_LIMITED_API+0 >= 0x03090000 +/* New in 3.9 */ +PyAPI_FUNC(int) PyModule_AddType(PyObject *module, PyTypeObject *type); +#endif /* Py_LIMITED_API */ +#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/.ci/python_dependencies_wins/include/moduleobject.h b/.ci/python_dependencies_wins/include/moduleobject.h new file mode 100644 index 00000000..872622b3 --- /dev/null +++ b/.ci/python_dependencies_wins/include/moduleobject.h @@ -0,0 +1,96 @@ + +/* 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_IS_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 *); +Py_DEPRECATED(3.2) PyAPI_FUNC(const char *) PyModule_GetFilename(PyObject *); +PyAPI_FUNC(PyObject *) PyModule_GetFilenameObject(PyObject *); +#ifndef Py_LIMITED_API +PyAPI_FUNC(void) _PyModule_Clear(PyObject *); +PyAPI_FUNC(void) _PyModule_ClearDict(PyObject *); +PyAPI_FUNC(int) _PyModuleSpec_IsInitializing(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; + + +// Internal C API +#ifdef Py_BUILD_CORE +extern int _PyModule_IsExtension(PyObject *obj); +#endif + +#ifdef __cplusplus +} +#endif +#endif /* !Py_MODULEOBJECT_H */ diff --git a/.ci/python_dependencies_wins/include/namespaceobject.h b/.ci/python_dependencies_wins/include/namespaceobject.h new file mode 100644 index 00000000..35146e5c --- /dev/null +++ b/.ci/python_dependencies_wins/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/.ci/python_dependencies_wins/include/object.h b/.ci/python_dependencies_wins/include/object.h new file mode 100644 index 00000000..19cb3c5e --- /dev/null +++ b/.ci/python_dependencies_wins/include/object.h @@ -0,0 +1,749 @@ +#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_REF_DEBUG. */ +#if defined(Py_DEBUG) && !defined(Py_REF_DEBUG) +# define Py_REF_DEBUG +#endif + +#if defined(Py_LIMITED_API) && defined(Py_TRACE_REFS) +# error Py_LIMITED_API is incompatible with Py_TRACE_REFS +#endif + +/* PyTypeObject structure is defined in cpython/object.h. + In Py_LIMITED_API, PyTypeObject is an opaque structure. */ +typedef struct _typeobject PyTypeObject; + +#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; + PyTypeObject *ob_type; +} PyObject; + +/* Cast argument to PyObject* type. */ +#define _PyObject_CAST(op) ((PyObject*)(op)) +#define _PyObject_CAST_CONST(op) ((const PyObject*)(op)) + +typedef struct { + PyObject ob_base; + Py_ssize_t ob_size; /* Number of items in variable part */ +} PyVarObject; + +/* Cast argument to PyVarObject* type. */ +#define _PyVarObject_CAST(op) ((PyVarObject*)(op)) +#define _PyVarObject_CAST_CONST(op) ((const PyVarObject*)(op)) + + +// Test if the 'x' object is the 'y' object, the same as "x is y" in Python. +PyAPI_FUNC(int) Py_Is(PyObject *x, PyObject *y); +#define Py_Is(x, y) ((x) == (y)) + + +static inline Py_ssize_t _Py_REFCNT(const PyObject *ob) { + return ob->ob_refcnt; +} +#define Py_REFCNT(ob) _Py_REFCNT(_PyObject_CAST_CONST(ob)) + + +// bpo-39573: The Py_SET_TYPE() function must be used to set an object type. +#define Py_TYPE(ob) (_PyObject_CAST(ob)->ob_type) + +// bpo-39573: The Py_SET_SIZE() function must be used to set an object size. +#define Py_SIZE(ob) (_PyVarObject_CAST(ob)->ob_size) + + +static inline int _Py_IS_TYPE(const PyObject *ob, const PyTypeObject *type) { + // bpo-44378: Don't use Py_TYPE() since Py_TYPE() requires a non-const + // object. + return ob->ob_type == type; +} +#define Py_IS_TYPE(ob, type) _Py_IS_TYPE(_PyObject_CAST_CONST(ob), type) + + +static inline void _Py_SET_REFCNT(PyObject *ob, Py_ssize_t refcnt) { + ob->ob_refcnt = refcnt; +} +#define Py_SET_REFCNT(ob, refcnt) _Py_SET_REFCNT(_PyObject_CAST(ob), refcnt) + + +static inline void _Py_SET_TYPE(PyObject *ob, PyTypeObject *type) { + ob->ob_type = type; +} +#define Py_SET_TYPE(ob, type) _Py_SET_TYPE(_PyObject_CAST(ob), type) + + +static inline void _Py_SET_SIZE(PyVarObject *ob, Py_ssize_t size) { + ob->ob_size = size; +} +#define Py_SET_SIZE(ob, size) _Py_SET_SIZE(_PyVarObject_CAST(ob), size) + + +/* +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 *); + +typedef int (*objobjproc)(PyObject *, PyObject *); +typedef int (*visitproc)(PyObject *, void *); +typedef int (*traverseproc)(PyObject *, visitproc, void *); + + +typedef void (*freefunc)(void *); +typedef void (*destructor)(PyObject *); +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)(PyTypeObject *, PyObject *, PyObject *); +typedef PyObject *(*allocfunc)(PyTypeObject *, Py_ssize_t); + +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 +#if !defined(Py_LIMITED_API) || Py_LIMITED_API+0 >= 0x03090000 +PyAPI_FUNC(PyObject*) PyType_FromModuleAndSpec(PyObject *, PyType_Spec *, PyObject *); +PyAPI_FUNC(PyObject *) PyType_GetModule(struct _typeobject *); +PyAPI_FUNC(void *) PyType_GetModuleState(struct _typeobject *); +#endif + +/* Generic type check */ +PyAPI_FUNC(int) PyType_IsSubtype(PyTypeObject *, PyTypeObject *); + +static inline int _PyObject_TypeCheck(PyObject *ob, PyTypeObject *type) { + return Py_IS_TYPE(ob, type) || PyType_IsSubtype(Py_TYPE(ob), type); +} +#define PyObject_TypeCheck(ob, type) _PyObject_TypeCheck(_PyObject_CAST(ob), type) + +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*); + +PyAPI_FUNC(int) PyType_Ready(PyTypeObject *); +PyAPI_FUNC(PyObject *) PyType_GenericAlloc(PyTypeObject *, Py_ssize_t); +PyAPI_FUNC(PyObject *) PyType_GenericNew(PyTypeObject *, + PyObject *, PyObject *); +PyAPI_FUNC(unsigned int) PyType_ClearCache(void); +PyAPI_FUNC(void) PyType_Modified(PyTypeObject *); + +/* Generic operations on objects */ +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 *); +PyAPI_FUNC(PyObject *) PyObject_SelfIter(PyObject *); +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 *); + +/* 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 change expected features and behavior for a +particular type. + +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. +*/ + +#ifndef Py_LIMITED_API +/* Set if instances of the type object are treated as sequences for pattern matching */ +#define Py_TPFLAGS_SEQUENCE (1 << 5) +/* Set if instances of the type object are treated as mappings for pattern matching */ +#define Py_TPFLAGS_MAPPING (1 << 6) +#endif + +/* Disallow creating instances of the type: set tp_new to NULL and don't create + * the "__new__" key in the type dictionary. */ +#define Py_TPFLAGS_DISALLOW_INSTANTIATION (1UL << 7) + +/* Set if the type object is immutable: type attributes cannot be set nor deleted */ +#define Py_TPFLAGS_IMMUTABLETYPE (1UL << 8) + +/* 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 implements the vectorcall protocol (PEP 590) */ +#ifndef Py_LIMITED_API +#define Py_TPFLAGS_HAVE_VECTORCALL (1UL << 11) +// Backwards compatibility alias for API that was provisional in Python 3.8 +#define _Py_TPFLAGS_HAVE_VECTORCALL Py_TPFLAGS_HAVE_VECTORCALL +#endif + +/* 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 objimpl.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 behave like an unbound method */ +#define Py_TPFLAGS_METHOD_DESCRIPTOR (1UL << 17) + +/* Object has up-to-date type attribute cache */ +#define Py_TPFLAGS_VALID_VERSION_TAG (1UL << 19) + +/* Type is abstract and cannot be instantiated */ +#define Py_TPFLAGS_IS_ABSTRACT (1UL << 20) + +// This undocumented flag gives certain built-ins their unique pattern-matching +// behavior, which allows a single positional subpattern to match against the +// subject itself (rather than a mapped attribute on it): +#define _Py_TPFLAGS_MATCH_SELF (1UL << 22) + +/* 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 | \ + 0) + +/* NOTE: Some of the following flags reuse lower bits (removed as part of the + * Python 3.0 transition). */ + +/* The following flags are kept for compatibility; in previous + * versions they indicated presence of newer tp_* fields on the + * type struct. + * Starting with 3.8, binary compatibility of C extensions across + * feature releases of Python is not supported anymore (except when + * using the stable ABI, in which all classes are created dynamically, + * using the interpreter's memory layout.) + * Note that older extensions using the stable ABI set these flags, + * so the bits must not be repurposed. + */ +#define Py_TPFLAGS_HAVE_FINALIZE (1UL << 0) +#define Py_TPFLAGS_HAVE_VERSION_TAG (1UL << 18) + + +/* +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.) +*/ + +#ifdef Py_REF_DEBUG +PyAPI_DATA(Py_ssize_t) _Py_RefTotal; +PyAPI_FUNC(void) _Py_NegativeRefcount(const char *filename, int lineno, + PyObject *op); +#endif /* Py_REF_DEBUG */ + +PyAPI_FUNC(void) _Py_Dealloc(PyObject *); + +/* +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 *); + +// Similar to Py_IncRef() and Py_DecRef() but the argument must be non-NULL. +// Private functions used by Py_INCREF() and Py_DECREF(). +PyAPI_FUNC(void) _Py_IncRef(PyObject *); +PyAPI_FUNC(void) _Py_DecRef(PyObject *); + +static inline void _Py_INCREF(PyObject *op) +{ +#if defined(Py_REF_DEBUG) && defined(Py_LIMITED_API) && Py_LIMITED_API+0 >= 0x030A0000 + // Stable ABI for Python 3.10 built in debug mode. + _Py_IncRef(op); +#else + // Non-limited C API and limited C API for Python 3.9 and older access + // directly PyObject.ob_refcnt. +#ifdef Py_REF_DEBUG + _Py_RefTotal++; +#endif + op->ob_refcnt++; +#endif +} +#define Py_INCREF(op) _Py_INCREF(_PyObject_CAST(op)) + +static inline void _Py_DECREF( +#if defined(Py_REF_DEBUG) && !(defined(Py_LIMITED_API) && Py_LIMITED_API+0 >= 0x030A0000) + const char *filename, int lineno, +#endif + PyObject *op) +{ +#if defined(Py_REF_DEBUG) && defined(Py_LIMITED_API) && Py_LIMITED_API+0 >= 0x030A0000 + // Stable ABI for Python 3.10 built in debug mode. + _Py_DecRef(op); +#else + // Non-limited C API and limited C API for Python 3.9 and older access + // directly PyObject.ob_refcnt. +#ifdef Py_REF_DEBUG + _Py_RefTotal--; +#endif + if (--op->ob_refcnt != 0) { +#ifdef Py_REF_DEBUG + if (op->ob_refcnt < 0) { + _Py_NegativeRefcount(filename, lineno, op); + } +#endif + } + else { + _Py_Dealloc(op); + } +#endif +} +#if defined(Py_REF_DEBUG) && !(defined(Py_LIMITED_API) && Py_LIMITED_API+0 >= 0x030A0000) +# define Py_DECREF(op) _Py_DECREF(__FILE__, __LINE__, _PyObject_CAST(op)) +#else +# define Py_DECREF(op) _Py_DECREF(_PyObject_CAST(op)) +#endif + + +/* 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_CAST(op); \ + if (_py_tmp != NULL) { \ + (op) = NULL; \ + Py_DECREF(_py_tmp); \ + } \ + } while (0) + +/* Function to use in case the object pointer can be NULL: */ +static inline void _Py_XINCREF(PyObject *op) +{ + if (op != NULL) { + Py_INCREF(op); + } +} + +#define Py_XINCREF(op) _Py_XINCREF(_PyObject_CAST(op)) + +static inline void _Py_XDECREF(PyObject *op) +{ + if (op != NULL) { + Py_DECREF(op); + } +} + +#define Py_XDECREF(op) _Py_XDECREF(_PyObject_CAST(op)) + +// Create a new strong reference to an object: +// increment the reference count of the object and return the object. +PyAPI_FUNC(PyObject*) Py_NewRef(PyObject *obj); + +// Similar to Py_NewRef(), but the object can be NULL. +PyAPI_FUNC(PyObject*) Py_XNewRef(PyObject *obj); + +static inline PyObject* _Py_NewRef(PyObject *obj) +{ + Py_INCREF(obj); + return obj; +} + +static inline PyObject* _Py_XNewRef(PyObject *obj) +{ + Py_XINCREF(obj); + return obj; +} + +// Py_NewRef() and Py_XNewRef() are exported as functions for the stable ABI. +// Names overridden with macros by static inline functions for best +// performances. +#define Py_NewRef(obj) _Py_NewRef(_PyObject_CAST(obj)) +#define Py_XNewRef(obj) _Py_XNewRef(_PyObject_CAST(obj)) + + +/* +_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) + +// Test if an object is the None singleton, the same as "x is None" in Python. +PyAPI_FUNC(int) Py_IsNone(PyObject *x); +#define Py_IsNone(x) Py_Is((x), Py_None) + +/* Macro for returning Py_None from a function */ +#define Py_RETURN_NONE return Py_NewRef(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_NewRef(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 + +#if !defined(Py_LIMITED_API) || Py_LIMITED_API+0 >= 0x030A0000 +/* Result of calling PyIter_Send */ +typedef enum { + PYGEN_RETURN = 0, + PYGEN_ERROR = -1, + PYGEN_NEXT = 1, +} PySendResult; +#endif + +/* + * 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) + + +/* +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. +*/ + +#ifndef Py_LIMITED_API +# define Py_CPYTHON_OBJECT_H +# include "cpython/object.h" +# undef Py_CPYTHON_OBJECT_H +#endif + + +static inline int +PyType_HasFeature(PyTypeObject *type, unsigned long feature) +{ + unsigned long flags; +#ifdef Py_LIMITED_API + // PyTypeObject is opaque in the limited C API + flags = PyType_GetFlags(type); +#else + flags = type->tp_flags; +#endif + return ((flags & feature) != 0); +} + +#define PyType_FastSubclass(type, flag) PyType_HasFeature(type, flag) + +static inline int _PyType_Check(PyObject *op) { + return PyType_FastSubclass(Py_TYPE(op), Py_TPFLAGS_TYPE_SUBCLASS); +} +#define PyType_Check(op) _PyType_Check(_PyObject_CAST(op)) + +static inline int _PyType_CheckExact(PyObject *op) { + return Py_IS_TYPE(op, &PyType_Type); +} +#define PyType_CheckExact(op) _PyType_CheckExact(_PyObject_CAST(op)) + +#ifdef __cplusplus +} +#endif +#endif /* !Py_OBJECT_H */ diff --git a/.ci/python_dependencies_wins/include/objimpl.h b/.ci/python_dependencies_wins/include/objimpl.h new file mode 100644 index 00000000..2c9f308c --- /dev/null +++ b/.ci/python_dependencies_wins/include/objimpl.h @@ -0,0 +1,215 @@ +/* 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_Free(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 Py_DEBUG +macro 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); + + +// Deprecated aliases only kept for backward compatibility. +// PyObject_Del and PyObject_DEL are defined with no parameter to be able to +// use them as function pointers (ex: tp_free = PyObject_Del). +#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); + +#define PyObject_INIT(op, typeobj) \ + PyObject_Init(_PyObject_CAST(op), (typeobj)) +#define PyObject_INIT_VAR(op, typeobj, size) \ + PyObject_InitVar(_PyVarObject_CAST(op), (typeobj), (size)) + + +PyAPI_FUNC(PyObject *) _PyObject_New(PyTypeObject *); +PyAPI_FUNC(PyVarObject *) _PyObject_NewVar(PyTypeObject *, Py_ssize_t); + +#define PyObject_New(type, typeobj) ((type *)_PyObject_New(typeobj)) + +// Alias to PyObject_New(). In Python 3.8, PyObject_NEW() called directly +// PyObject_MALLOC() with _PyObject_SIZE(). +#define PyObject_NEW(type, typeobj) PyObject_New(type, typeobj) + +#define PyObject_NewVar(type, typeobj, n) \ + ( (type *) _PyObject_NewVar((typeobj), (n)) ) + +// Alias to PyObject_NewVar(). In Python 3.8, PyObject_NEW_VAR() called +// directly PyObject_MALLOC() with _PyObject_VAR_SIZE(). +#define PyObject_NEW_VAR(type, typeobj, n) PyObject_NewVar(type, typeobj, n) + + +/* + * Garbage Collection Support + * ========================== + */ + +/* C equivalent of gc.collect(). */ +PyAPI_FUNC(Py_ssize_t) PyGC_Collect(void); +/* C API for controlling the state of the garbage collector */ +PyAPI_FUNC(int) PyGC_Enable(void); +PyAPI_FUNC(int) PyGC_Disable(void); +PyAPI_FUNC(int) PyGC_IsEnabled(void); + +/* Test if a type has a GC head */ +#define PyType_IS_GC(t) PyType_HasFeature((t), Py_TPFLAGS_HAVE_GC) + +PyAPI_FUNC(PyVarObject *) _PyObject_GC_Resize(PyVarObject *, Py_ssize_t); +#define PyObject_GC_Resize(type, op, n) \ + ( (type *) _PyObject_GC_Resize(_PyVarObject_CAST(op), (n)) ) + + + +PyAPI_FUNC(PyObject *) _PyObject_GC_New(PyTypeObject *); +PyAPI_FUNC(PyVarObject *) _PyObject_GC_NewVar(PyTypeObject *, Py_ssize_t); + +/* Tell the GC to track this object. + * + * See also private _PyObject_GC_TRACK() macro. */ +PyAPI_FUNC(void) PyObject_GC_Track(void *); + +/* Tell the GC to stop tracking this object. + * + * See also private _PyObject_GC_UNTRACK() macro. */ +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)) ) + +PyAPI_FUNC(int) PyObject_GC_IsTracked(PyObject *); +PyAPI_FUNC(int) PyObject_GC_IsFinalized(PyObject *); + +/* 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_CAST(op), arg); \ + if (vret) \ + return vret; \ + } \ + } while (0) + +#ifndef Py_LIMITED_API +# define Py_CPYTHON_OBJIMPL_H +# include "cpython/objimpl.h" +# undef Py_CPYTHON_OBJIMPL_H +#endif + +#ifdef __cplusplus +} +#endif +#endif /* !Py_OBJIMPL_H */ diff --git a/.ci/python_dependencies_wins/include/opcode.h b/.ci/python_dependencies_wins/include/opcode.h new file mode 100644 index 00000000..8c62f466 --- /dev/null +++ b/.ci/python_dependencies_wins/include/opcode.h @@ -0,0 +1,172 @@ +/* Auto-generated by Tools/scripts/generate_opcode_h.py from Lib/opcode.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 ROT_FOUR 6 +#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_LEN 30 +#define MATCH_MAPPING 31 +#define MATCH_SEQUENCE 32 +#define MATCH_KEYS 33 +#define COPY_DICT_WITHOUT_KEYS 34 +#define WITH_EXCEPT_START 49 +#define GET_AITER 50 +#define GET_ANEXT 51 +#define BEFORE_ASYNC_WITH 52 +#define END_ASYNC_FOR 54 +#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 LOAD_ASSERTION_ERROR 74 +#define INPLACE_LSHIFT 75 +#define INPLACE_RSHIFT 76 +#define INPLACE_AND 77 +#define INPLACE_XOR 78 +#define INPLACE_OR 79 +#define LIST_TO_TUPLE 82 +#define RETURN_VALUE 83 +#define IMPORT_STAR 84 +#define SETUP_ANNOTATIONS 85 +#define YIELD_VALUE 86 +#define POP_BLOCK 87 +#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 ROT_N 99 +#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 IS_OP 117 +#define CONTAINS_OP 118 +#define RERAISE 119 +#define JUMP_IF_NOT_EXC_MATCH 121 +#define SETUP_FINALLY 122 +#define LOAD_FAST 124 +#define STORE_FAST 125 +#define DELETE_FAST 126 +#define GEN_START 129 +#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 MATCH_CLASS 152 +#define SETUP_ASYNC_WITH 154 +#define FORMAT_VALUE 155 +#define BUILD_CONST_KEY_MAP 156 +#define BUILD_STRING 157 +#define LOAD_METHOD 160 +#define CALL_METHOD 161 +#define LIST_EXTEND 162 +#define SET_UPDATE 163 +#define DICT_MERGE 164 +#define DICT_UPDATE 165 +#ifdef NEED_OPCODE_JUMP_TABLES +static uint32_t _PyOpcode_RelativeJump[8] = { + 0U, + 0U, + 536870912U, + 67125248U, + 67141632U, + 0U, + 0U, + 0U, +}; +static uint32_t _PyOpcode_Jump[8] = { + 0U, + 0U, + 536870912U, + 101695488U, + 67141632U, + 0U, + 0U, + 0U, +}; +#endif /* OPCODE_TABLES */ + +/* 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 + +#define HAS_ARG(op) ((op) >= HAVE_ARGUMENT) + +#ifdef __cplusplus +} +#endif +#endif /* !Py_OPCODE_H */ diff --git a/.ci/python_dependencies_wins/include/osdefs.h b/.ci/python_dependencies_wins/include/osdefs.h new file mode 100644 index 00000000..4ff50cbb --- /dev/null +++ b/.ci/python_dependencies_wins/include/osdefs.h @@ -0,0 +1,51 @@ +#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 + +#ifdef __VXWORKS__ +#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/.ci/python_dependencies_wins/include/osmodule.h b/.ci/python_dependencies_wins/include/osmodule.h new file mode 100644 index 00000000..af508502 --- /dev/null +++ b/.ci/python_dependencies_wins/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/.ci/python_dependencies_wins/include/patchlevel.h b/.ci/python_dependencies_wins/include/patchlevel.h new file mode 100644 index 00000000..674e99bd --- /dev/null +++ b/.ci/python_dependencies_wins/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 10 +#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.10.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/.ci/python_dependencies_wins/include/py_curses.h b/.ci/python_dependencies_wins/include/py_curses.h new file mode 100644 index 00000000..b65aaa7b --- /dev/null +++ b/.ci/python_dependencies_wins/include/py_curses.h @@ -0,0 +1,99 @@ + +#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_IS_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"; + +#ifdef __cplusplus +} +#endif + +#endif /* !defined(Py_CURSES_H) */ + diff --git a/.ci/python_dependencies_wins/include/pycapsule.h b/.ci/python_dependencies_wins/include/pycapsule.h new file mode 100644 index 00000000..9387a1c7 --- /dev/null +++ b/.ci/python_dependencies_wins/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_IS_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/.ci/python_dependencies_wins/include/pyconfig.h b/.ci/python_dependencies_wins/include/pyconfig.h new file mode 100644 index 00000000..651f6ecf --- /dev/null +++ b/.ci/python_dependencies_wins/include/pyconfig.h @@ -0,0 +1,690 @@ +#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" +#elif defined(_M_ARM64) +#define COMPILER _Py_PASTE_VERSION("64 bit (ARM64)") +#define PYD_PLATFORM_TAG "win_arm64" +#else +#define COMPILER _Py_PASTE_VERSION("64 bit (Unknown)") +#endif +#endif /* MS_WIN64 */ + +/* set the version macros for the windows headers */ +/* Python 3.9+ requires Windows 8 or greater */ +#define Py_WINVER 0x0602 /* _WIN32_WINNT_WIN8 */ +#define Py_NTDDI NTDDI_WIN8 + +/* 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 Py_ssize_t; +#else +typedef _W64 int Py_ssize_t; +#endif +#define HAVE_PY_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_arm32" +#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 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,"python310_d.lib") +# elif defined(Py_LIMITED_API) +# pragma comment(lib,"python3.lib") +# else +# pragma comment(lib,"python310.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 +# define ALIGNOF_SIZE_T 8 +/* configure.ac defines HAVE_LARGEFILE_SUPPORT iff + sizeof(off_t) > sizeof(long), and sizeof(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 +# define ALIGNOF_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 ALIGNOF_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 to 1 if you have the declaration of `tzname', and to 0 if you don't. + */ +#define HAVE_DECL_TZNAME 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 + +#define PLATLIBDIR "lib" + +#endif /* !Py_CONFIG_H */ diff --git a/.ci/python_dependencies_wins/include/pydtrace.h b/.ci/python_dependencies_wins/include/pydtrace.h new file mode 100644 index 00000000..8fac2004 --- /dev/null +++ b/.ci/python_dependencies_wins/include/pydtrace.h @@ -0,0 +1,59 @@ +/* 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 void PyDTrace_AUDIT(const char *arg0, void *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; } +static inline int PyDTrace_AUDIT_ENABLED(void) { return 0; } + +#endif /* !WITH_DTRACE */ + +#ifdef __cplusplus +} +#endif +#endif /* !Py_DTRACE_H */ diff --git a/.ci/python_dependencies_wins/include/pyerrors.h b/.ci/python_dependencies_wins/include/pyerrors.h new file mode 100644 index 00000000..e39ee5a8 --- /dev/null +++ b/.ci/python_dependencies_wins/include/pyerrors.h @@ -0,0 +1,324 @@ +#ifndef Py_ERRORS_H +#define Py_ERRORS_H +#ifdef __cplusplus +extern "C" { +#endif + +#include // va_list + +/* Error handling definitions */ + +PyAPI_FUNC(void) PyErr_SetNone(PyObject *); +PyAPI_FUNC(void) PyErr_SetObject(PyObject *, PyObject *); +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 + +/* Defined in Python/pylifecycle.c + + The Py_FatalError() function is replaced with a macro which logs + automatically the name of the current function, unless the Py_LIMITED_API + macro is defined. */ +PyAPI_FUNC(void) _Py_NO_RETURN Py_FatalError(const char *message); + +/* 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 *); + +/* */ + +#define PyExceptionClass_Check(x) \ + (PyType_Check((x)) && \ + PyType_FastSubclass((PyTypeObject*)(x), Py_TPFLAGS_BASE_EXC_SUBCLASS)) + +#define PyExceptionInstance_Check(x) \ + PyType_FastSubclass(Py_TYPE(x), Py_TPFLAGS_BASE_EXC_SUBCLASS) + +PyAPI_FUNC(const char *) PyExceptionClass_Name(PyObject *); + +#define PyExceptionInstance_Class(x) ((PyObject*)Py_TYPE(x)) + + +/* 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_EncodingWarning; +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 */ + ); + +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 + +#ifdef MS_WINDOWS +PyAPI_FUNC(PyObject *) PyErr_SetFromWindowsErrWithFilename( + int ierr, + const char *filename /* decoded from the filesystem encoding */ + ); +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 */ + ); +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 signalmodule.c */ +PyAPI_FUNC(int) PyErr_CheckSignals(void); +PyAPI_FUNC(void) PyErr_SetInterrupt(void); +#if !defined(Py_LIMITED_API) || Py_LIMITED_API+0 >= 0x030A0000 +PyAPI_FUNC(int) PyErr_SetInterruptEx(int signum); +#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); +PyAPI_FUNC(PyObject *) PyErr_ProgramText( + const char *filename, /* decoded from the filesystem encoding */ + int lineno); + +/* 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 */ + ); + +/* 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 */ + ); + +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))); + +#ifndef Py_LIMITED_API +# define Py_CPYTHON_ERRORS_H +# include "cpython/pyerrors.h" +# undef Py_CPYTHON_ERRORS_H +#endif + +#ifdef __cplusplus +} +#endif +#endif /* !Py_ERRORS_H */ diff --git a/.ci/python_dependencies_wins/include/pyexpat.h b/.ci/python_dependencies_wins/include/pyexpat.h new file mode 100644 index 00000000..5f5d381a --- /dev/null +++ b/.ci/python_dependencies_wins/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/.ci/python_dependencies_wins/include/pyframe.h b/.ci/python_dependencies_wins/include/pyframe.h new file mode 100644 index 00000000..a2576902 --- /dev/null +++ b/.ci/python_dependencies_wins/include/pyframe.h @@ -0,0 +1,22 @@ +/* Limited C API of PyFrame API + * + * Include "frameobject.h" to get the PyFrameObject structure. + */ + +#ifndef Py_PYFRAME_H +#define Py_PYFRAME_H +#ifdef __cplusplus +extern "C" { +#endif + +typedef struct _frame PyFrameObject; + +/* Return the line of code the frame is currently executing. */ +PyAPI_FUNC(int) PyFrame_GetLineNumber(PyFrameObject *); + +PyAPI_FUNC(PyCodeObject *) PyFrame_GetCode(PyFrameObject *frame); + +#ifdef __cplusplus +} +#endif +#endif /* !Py_PYFRAME_H */ diff --git a/.ci/python_dependencies_wins/include/pyhash.h b/.ci/python_dependencies_wins/include/pyhash.h new file mode 100644 index 00000000..4878b75b --- /dev/null +++ b/.ci/python_dependencies_wins/include/pyhash.h @@ -0,0 +1,144 @@ +#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(PyObject *, double); +PyAPI_FUNC(Py_hash_t) _Py_HashPointer(const void*); +// Similar to _Py_HashPointer(), but don't replace -1 with -2 +PyAPI_FUNC(Py_hash_t) _Py_HashPointerRaw(const 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_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; + +#ifdef Py_DEBUG +PyAPI_DATA(int) _Py_HashSecret_Initialized; +#endif + + +/* hash function definition */ +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 platforms 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/.ci/python_dependencies_wins/include/pylifecycle.h b/.ci/python_dependencies_wins/include/pylifecycle.h new file mode 100644 index 00000000..0601eb5e --- /dev/null +++ b/.ci/python_dependencies_wins/include/pylifecycle.h @@ -0,0 +1,74 @@ + +/* Interfaces to configure, query, create & destroy the Python runtime */ + +#ifndef Py_PYLIFECYCLE_H +#define Py_PYLIFECYCLE_H +#ifdef __cplusplus +extern "C" { +#endif + + +/* Initialization and finalization */ +PyAPI_FUNC(void) Py_Initialize(void); +PyAPI_FUNC(void) Py_InitializeEx(int); +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. + */ +PyAPI_FUNC(int) Py_AtExit(void (*func)(void)); + +PyAPI_FUNC(void) _Py_NO_RETURN Py_Exit(int); + +/* Bootstrap __main__ (defined in Modules/main.c) */ +PyAPI_FUNC(int) Py_Main(int argc, wchar_t **argv); +PyAPI_FUNC(int) Py_BytesMain(int argc, char **argv); + +/* In pathconfig.c */ +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); + +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); +PyAPI_FUNC(void) Py_SetPath(const wchar_t *); +#ifdef MS_WINDOWS +int _Py_CheckPython3(void); +#endif + +/* In their own files */ +PyAPI_FUNC(const char *) Py_GetVersion(void); +PyAPI_FUNC(const char *) Py_GetPlatform(void); +PyAPI_FUNC(const char *) Py_GetCopyright(void); +PyAPI_FUNC(const char *) Py_GetCompiler(void); +PyAPI_FUNC(const char *) Py_GetBuildInfo(void); + +/* 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 +# define Py_CPYTHON_PYLIFECYCLE_H +# include "cpython/pylifecycle.h" +# undef Py_CPYTHON_PYLIFECYCLE_H +#endif + +#ifdef __cplusplus +} +#endif +#endif /* !Py_PYLIFECYCLE_H */ diff --git a/.ci/python_dependencies_wins/include/pymacconfig.h b/.ci/python_dependencies_wins/include/pymacconfig.h new file mode 100644 index 00000000..a1eccea4 --- /dev/null +++ b/.ci/python_dependencies_wins/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/.ci/python_dependencies_wins/include/pymacro.h b/.ci/python_dependencies_wins/include/pymacro.h new file mode 100644 index 00000000..7bfee70e --- /dev/null +++ b/.ci/python_dependencies_wins/include/pymacro.h @@ -0,0 +1,132 @@ +#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 const 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))) + +/* Use this for unused arguments in a function definition to silence compiler + * warnings. Example: + * + * int func(int a, int Py_UNUSED(b)) { return a; } + */ +#if defined(__GNUC__) || defined(__clang__) +# define Py_UNUSED(name) _unused_ ## name __attribute__((unused)) +#else +# define Py_UNUSED(name) _unused_ ## name +#endif + +#if defined(RANDALL_WAS_HERE) +# define Py_UNREACHABLE() \ + Py_FatalError( \ + "If you're seeing this, the code is in what I thought was\n" \ + "an unreachable state.\n\n" \ + "I could give you advice for what to do, but honestly, why\n" \ + "should you trust me? I clearly screwed this up. I'm writing\n" \ + "a message that should never appear, yet I know it will\n" \ + "probably appear someday.\n\n" \ + "On a deep level, I know I'm not up to this task.\n" \ + "I'm so sorry.\n" \ + "https://xkcd.com/2200") +#elif defined(Py_DEBUG) +# define Py_UNREACHABLE() \ + Py_FatalError( \ + "We've reached an unreachable state. Anything is possible.\n" \ + "The limits were in our heads all along. Follow your dreams.\n" \ + "https://xkcd.com/2200") +#elif defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 5)) +# define Py_UNREACHABLE() __builtin_unreachable() +#elif defined(__clang__) || defined(__INTEL_COMPILER) +# define Py_UNREACHABLE() __builtin_unreachable() +#elif defined(_MSC_VER) +# define Py_UNREACHABLE() __assume(0) +#else +# define Py_UNREACHABLE() \ + Py_FatalError("Unreachable C code path reached") +#endif + +#endif /* Py_PYMACRO_H */ diff --git a/.ci/python_dependencies_wins/include/pymath.h b/.ci/python_dependencies_wins/include/pymath.h new file mode 100644 index 00000000..abe3e9c3 --- /dev/null +++ b/.ci/python_dependencies_wins/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 intrinsics 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/.ci/python_dependencies_wins/include/pymem.h b/.ci/python_dependencies_wins/include/pymem.h new file mode 100644 index 00000000..a7c88086 --- /dev/null +++ b/.ci/python_dependencies_wins/include/pymem.h @@ -0,0 +1,104 @@ +/* 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 + +/* 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 + a debug build (Py_DEBUG macro), 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); +PyAPI_FUNC(void *) PyMem_Calloc(size_t nelem, size_t elsize); +PyAPI_FUNC(void *) PyMem_Realloc(void *ptr, size_t new_size); +PyAPI_FUNC(void) PyMem_Free(void *ptr); + +/* + * 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)) ) ) + +/* + * 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)) ) + + +// Deprecated aliases only kept for backward compatibility. +// PyMem_Del and PyMem_DEL are defined with no parameter to be able to use +// them as function pointers (ex: dealloc = PyMem_Del). +#define PyMem_MALLOC(n) PyMem_Malloc(n) +#define PyMem_NEW(type, n) PyMem_New(type, n) +#define PyMem_REALLOC(p, n) PyMem_Realloc(p, n) +#define PyMem_RESIZE(p, type, n) PyMem_Resize(p, type, n) +#define PyMem_FREE(p) PyMem_Free(p) +#define PyMem_Del PyMem_Free +#define PyMem_DEL PyMem_Free + + +#ifndef Py_LIMITED_API +# define Py_CPYTHON_PYMEM_H +# include "cpython/pymem.h" +# undef Py_CPYTHON_PYMEM_H +#endif + +#ifdef __cplusplus +} +#endif + +#endif /* !Py_PYMEM_H */ diff --git a/.ci/python_dependencies_wins/include/pyport.h b/.ci/python_dependencies_wins/include/pyport.h new file mode 100644 index 00000000..f17729bc --- /dev/null +++ b/.ci/python_dependencies_wins/include/pyport.h @@ -0,0 +1,889 @@ +#ifndef Py_PYPORT_H +#define Py_PYPORT_H + +#include "pyconfig.h" /* include for defines */ + +#include + + +/* Defines to build Python and its standard library: + * + * - Py_BUILD_CORE: Build Python core. Give access to Python internals, but + * should not be used by third-party modules. + * - Py_BUILD_CORE_BUILTIN: Build a Python stdlib module as a built-in module. + * - Py_BUILD_CORE_MODULE: Build a Python stdlib module as a dynamic library. + * + * Py_BUILD_CORE_BUILTIN and Py_BUILD_CORE_MODULE imply Py_BUILD_CORE. + * + * On Windows, Py_BUILD_CORE_MODULE exports "PyInit_xxx" symbol, whereas + * Py_BUILD_CORE_BUILTIN does not. + */ +#if defined(Py_BUILD_CORE_BUILTIN) && !defined(Py_BUILD_CORE) +# define Py_BUILD_CORE +#endif +#if defined(Py_BUILD_CORE_MODULE) && !defined(Py_BUILD_CORE) +# define Py_BUILD_CORE +#endif + + +/************************************************************************** +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_PY_SSIZE_T + +#elif 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) + +/* Macro kept for backward compatibility: use "z" in new code. + * + * 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 old MSVCs had not supported it. + * Since MSVC supports "z" since (at least) 2015, we can just use "z" + * for new code. + * + * 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 %zd or to something else correct for a Py_ssize_t on + * the platform. + */ +#ifndef PY_FORMAT_SIZE_T +# define PY_FORMAT_SIZE_T "z" +#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 MSVC */ + /* active in both release and debug builds - see bpo-43271 */ +# pragma optimize("gt", 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) && !defined(_M_ARM) /* x87 not supported in 64-bit or ARM */ +#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. + * The macro must be placed before the declaration. + * Usage: + * Py_DEPRECATED(3.3) extern int old_var; + * Py_DEPRECATED(3.4) typedef int T1; + * Py_DEPRECATED(3.8) PyAPI_FUNC(int) Py_OldFunction(void); + */ +#if defined(__GNUC__) \ + && ((__GNUC__ >= 4) || (__GNUC__ == 3) && (__GNUC_MINOR__ >= 1)) +#define Py_DEPRECATED(VERSION_UNUSED) __attribute__((__deprecated__)) +#elif defined(_MSC_VER) +#define Py_DEPRECATED(VERSION) __declspec(deprecated( \ + "deprecated in " #VERSION)) +#else +#define Py_DEPRECATED(VERSION_UNUSED) +#endif + +#if defined(__clang__) +#define _Py_COMP_DIAG_PUSH _Pragma("clang diagnostic push") +#define _Py_COMP_DIAG_IGNORE_DEPR_DECLS \ + _Pragma("clang diagnostic ignored \"-Wdeprecated-declarations\"") +#define _Py_COMP_DIAG_POP _Pragma("clang diagnostic pop") +#elif defined(__GNUC__) \ + && ((__GNUC__ >= 5) || (__GNUC__ == 4) && (__GNUC_MINOR__ >= 6)) +#define _Py_COMP_DIAG_PUSH _Pragma("GCC diagnostic push") +#define _Py_COMP_DIAG_IGNORE_DEPR_DECLS \ + _Pragma("GCC diagnostic ignored \"-Wdeprecated-declarations\"") +#define _Py_COMP_DIAG_POP _Pragma("GCC diagnostic pop") +#elif defined(_MSC_VER) +#define _Py_COMP_DIAG_PUSH __pragma(warning(push)) +#define _Py_COMP_DIAG_IGNORE_DEPR_DECLS __pragma(warning(disable: 4996)) +#define _Py_COMP_DIAG_POP __pragma(warning(pop)) +#else +#define _Py_COMP_DIAG_PUSH +#define _Py_COMP_DIAG_IGNORE_DEPR_DECLS +#define _Py_COMP_DIAG_POP +#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(_MSC_VER) +# define _Py_NO_INLINE __declspec(noinline) +#elif 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 + +#include "exports.h" + +/* 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_MODULE) +# define PyAPI_FUNC(RTYPE) Py_EXPORTED_SYMBOL RTYPE +# define PyAPI_DATA(RTYPE) extern Py_EXPORTED_SYMBOL RTYPE + /* module init functions inside the core need no external linkage */ + /* except for Cygwin to handle embedding */ +# if defined(__CYGWIN__) +# define PyMODINIT_FUNC Py_EXPORTED_SYMBOL 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) Py_IMPORTED_SYMBOL RTYPE +# endif /* !__CYGWIN__ */ +# define PyAPI_DATA(RTYPE) extern Py_IMPORTED_SYMBOL RTYPE + /* module init functions outside the core must be exported */ +# if defined(__cplusplus) +# define PyMODINIT_FUNC extern "C" Py_EXPORTED_SYMBOL PyObject* +# else /* __cplusplus */ +# define PyMODINIT_FUNC Py_EXPORTED_SYMBOL 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) Py_EXPORTED_SYMBOL RTYPE +#endif +#ifndef PyAPI_DATA +# define PyAPI_DATA(RTYPE) extern Py_EXPORTED_SYMBOL RTYPE +#endif +#ifndef PyMODINIT_FUNC +# if defined(__cplusplus) +# define PyMODINIT_FUNC extern "C" Py_EXPORTED_SYMBOL PyObject* +# else /* __cplusplus */ +# define PyMODINIT_FUNC Py_EXPORTED_SYMBOL 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 + +#ifdef Py_BUILD_CORE +/* + * 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 + +/* Check that ALT_SOABI is consistent with Py_TRACE_REFS: + ./configure --with-trace-refs should must be used to define Py_TRACE_REFS */ +#if defined(ALT_SOABI) && defined(Py_TRACE_REFS) +# error "Py_TRACE_REFS ABI is not compatible with release and debug ABI" +#endif + +#if defined(__ANDROID__) || defined(__VXWORKS__) + // Use UTF-8 as the locale encoding, ignore the LC_CTYPE locale. + // See _Py_GetLocaleEncoding(), PyUnicode_DecodeLocale() + // and PyUnicode_EncodeLocale(). +# define _Py_FORCE_UTF8_LOCALE +#endif + +#if defined(_Py_FORCE_UTF8_LOCALE) || defined(__APPLE__) + // Use UTF-8 as the filesystem encoding. + // See PyUnicode_DecodeFSDefaultAndSize(), PyUnicode_EncodeFSDefault(), + // Py_DecodeLocale() and Py_EncodeLocale(). +# define _Py_FORCE_UTF8_FS_ENCODING +#endif + +/* Mark a function which cannot return. Example: + PyAPI_FUNC(void) _Py_NO_RETURN PyThread_exit_thread(void); + + XLC support is intentionally omitted due to bpo-40244 */ +#ifndef _Py_NO_RETURN +#if defined(__clang__) || \ + (defined(__GNUC__) && \ + ((__GNUC__ >= 3) || \ + (__GNUC__ == 2) && (__GNUC_MINOR__ >= 5))) +# define _Py_NO_RETURN __attribute__((__noreturn__)) +#elif defined(_MSC_VER) +# define _Py_NO_RETURN __declspec(noreturn) +#else +# define _Py_NO_RETURN +#endif +#endif + + +// Preprocessor check for a builtin preprocessor function. Always return 0 +// if __has_builtin() macro is not defined. +// +// __has_builtin() is available on clang and GCC 10. +#ifdef __has_builtin +# define _Py__has_builtin(x) __has_builtin(x) +#else +# define _Py__has_builtin(x) 0 +#endif + + +#endif /* Py_PYPORT_H */ diff --git a/.ci/python_dependencies_wins/include/pystate.h b/.ci/python_dependencies_wins/include/pystate.h new file mode 100644 index 00000000..d9f31e36 --- /dev/null +++ b/.ci/python_dependencies_wins/include/pystate.h @@ -0,0 +1,150 @@ +/* Thread and interpreter state structures and their interfaces */ + + +#ifndef Py_PYSTATE_H +#define Py_PYSTATE_H +#ifdef __cplusplus +extern "C" { +#endif + +/* This limitation is for performance and simplicity. If needed it can be +removed (with effort). */ +#define MAX_CO_EXTRA_USERS 255 + +/* Forward declarations for PyFrameObject, PyThreadState + and PyInterpreterState */ +struct _ts; +struct _is; + +/* struct _ts is defined in cpython/pystate.h */ +typedef struct _ts PyThreadState; +/* struct _is is defined in internal/pycore_interp.h */ +typedef struct _is PyInterpreterState; + +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 >= 0x03090000 +/* New in 3.9 */ +/* Get the current interpreter state. + + Issue a fatal error if there no current Python thread state or no current + interpreter. It cannot return NULL. + + The caller must hold the GIL. */ +PyAPI_FUNC(PyInterpreterState *) PyInterpreterState_Get(void); +#endif + +#if !defined(Py_LIMITED_API) || Py_LIMITED_API+0 >= 0x03080000 +/* New in 3.8 */ +PyAPI_FUNC(PyObject *) PyInterpreterState_GetDict(PyInterpreterState *); +#endif + +#if !defined(Py_LIMITED_API) || Py_LIMITED_API+0 >= 0x03070000 +/* New in 3.7 */ +PyAPI_FUNC(int64_t) PyInterpreterState_GetID(PyInterpreterState *); +#endif +#if !defined(Py_LIMITED_API) || Py_LIMITED_API+0 >= 0x03030000 + +/* State unique per thread */ + +/* 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*); + +PyAPI_FUNC(PyThreadState *) PyThreadState_New(PyInterpreterState *); +PyAPI_FUNC(void) PyThreadState_Clear(PyThreadState *); +PyAPI_FUNC(void) PyThreadState_Delete(PyThreadState *); + +/* Get the current thread state. + + When the current thread state is NULL, this issues a fatal error (so that + the caller needn't check for NULL). + + The caller must hold the GIL. + + See also PyThreadState_GET() and _PyThreadState_GET(). */ +PyAPI_FUNC(PyThreadState *) PyThreadState_Get(void); + +/* Get the current Python thread state. + + Macro using PyThreadState_Get() or _PyThreadState_GET() depending if + pycore_pystate.h is included or not (this header redefines the macro). + + If PyThreadState_Get() is used, issue a fatal error if the current thread + state is NULL. + + See also PyThreadState_Get() and _PyThreadState_GET(). */ +#define PyThreadState_GET() PyThreadState_Get() + +PyAPI_FUNC(PyThreadState *) PyThreadState_Swap(PyThreadState *); +PyAPI_FUNC(PyObject *) PyThreadState_GetDict(void); +PyAPI_FUNC(int) PyThreadState_SetAsyncExc(unsigned long, PyObject *); + +#if !defined(Py_LIMITED_API) || Py_LIMITED_API+0 >= 0x03090000 +/* New in 3.9 */ +PyAPI_FUNC(PyInterpreterState*) PyThreadState_GetInterpreter(PyThreadState *tstate); +PyAPI_FUNC(PyFrameObject*) PyThreadState_GetFrame(PyThreadState *tstate); +PyAPI_FUNC(uint64_t) PyThreadState_GetID(PyThreadState *tstate); +#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 +# define Py_CPYTHON_PYSTATE_H +# include "cpython/pystate.h" +# undef Py_CPYTHON_PYSTATE_H +#endif + +#ifdef __cplusplus +} +#endif +#endif /* !Py_PYSTATE_H */ diff --git a/.ci/python_dependencies_wins/include/pystrcmp.h b/.ci/python_dependencies_wins/include/pystrcmp.h new file mode 100644 index 00000000..eccabdce --- /dev/null +++ b/.ci/python_dependencies_wins/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/.ci/python_dependencies_wins/include/pystrhex.h b/.ci/python_dependencies_wins/include/pystrhex.h new file mode 100644 index 00000000..bccae77a --- /dev/null +++ b/.ci/python_dependencies_wins/include/pystrhex.h @@ -0,0 +1,22 @@ +#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); +/* These variants include support for a separator between every N bytes: */ +PyAPI_FUNC(PyObject*) _Py_strhex_with_sep(const char* argbuf, const Py_ssize_t arglen, const PyObject* sep, const int bytes_per_group); +PyAPI_FUNC(PyObject*) _Py_strhex_bytes_with_sep(const char* argbuf, const Py_ssize_t arglen, const PyObject* sep, const int bytes_per_group); +#endif /* !Py_LIMITED_API */ + +#ifdef __cplusplus +} +#endif + +#endif /* !Py_STRHEX_H */ diff --git a/.ci/python_dependencies_wins/include/pystrtod.h b/.ci/python_dependencies_wins/include/pystrtod.h new file mode 100644 index 00000000..ba2e8d00 --- /dev/null +++ b/.ci/python_dependencies_wins/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/.ci/python_dependencies_wins/include/pythonrun.h b/.ci/python_dependencies_wins/include/pythonrun.h new file mode 100644 index 00000000..bade2cc3 --- /dev/null +++ b/.ci/python_dependencies_wins/include/pythonrun.h @@ -0,0 +1,44 @@ + +/* Interfaces to parse and execute pieces of python code */ + +#ifndef Py_PYTHONRUN_H +#define Py_PYTHONRUN_H +#ifdef __cplusplus +extern "C" { +#endif + +PyAPI_FUNC(PyObject *) Py_CompileString(const char *, const char *, int); + +PyAPI_FUNC(void) PyErr_Print(void); +PyAPI_FUNC(void) PyErr_PrintEx(int); +PyAPI_FUNC(void) PyErr_Display(PyObject *, PyObject *, PyObject *); + + +/* Stuff with no proper home (yet) */ +PyAPI_DATA(int) (*PyOS_InputHook)(void); + +/* 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(_M_ARM) && 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 + +#ifndef Py_LIMITED_API +# define Py_CPYTHON_PYTHONRUN_H +# include "cpython/pythonrun.h" +# undef Py_CPYTHON_PYTHONRUN_H +#endif + +#ifdef __cplusplus +} +#endif +#endif /* !Py_PYTHONRUN_H */ diff --git a/.ci/python_dependencies_wins/include/pythread.h b/.ci/python_dependencies_wins/include/pythread.h new file mode 100644 index 00000000..739594a8 --- /dev/null +++ b/.ci/python_dependencies_wins/include/pythread.h @@ -0,0 +1,169 @@ + +#ifndef Py_PYTHREAD_H +#define Py_PYTHREAD_H + +typedef void *PyThread_type_lock; + +#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) _Py_NO_RETURN PyThread_exit_thread(void); +PyAPI_FUNC(unsigned long) PyThread_get_thread_ident(void); + +#if defined(__APPLE__) || defined(__linux__) || defined(__FreeBSD__) || defined(__OpenBSD__) || defined(__NetBSD__) || defined(_WIN32) || defined(_AIX) +#define PY_HAVE_THREAD_NATIVE_ID +PyAPI_FUNC(unsigned long) PyThread_get_thread_native_id(void); +#endif + +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 + +#ifndef Py_LIMITED_API +#ifdef HAVE_FORK +/* Private function to reinitialize a lock at fork in the child process. + Reset the lock to the unlocked state. + Return 0 on success, return -1 on error. */ +PyAPI_FUNC(int) _PyThread_at_fork_reinit(PyThread_type_lock *lock); +#endif /* HAVE_FORK */ +#endif /* !Py_LIMITED_API */ + +/* 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 (LLONG_MAX / 1000) +#elif defined (NT_THREADS) + /* In the NT API, the timeout is a DWORD and is expressed in milliseconds */ +# if 0xFFFFFFFFLL * 1000 < LLONG_MAX +# define PY_TIMEOUT_MAX (0xFFFFFFFFLL * 1000) +# else +# define PY_TIMEOUT_MAX LLONG_MAX +# endif +#else +# define PY_TIMEOUT_MAX 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). +*/ +Py_DEPRECATED(3.7) 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); + +/* Cleanup after a fork */ +Py_DEPRECATED(3.7) PyAPI_FUNC(void) PyThread_ReInitTLS(void); + + +#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/.ci/python_dependencies_wins/include/rangeobject.h b/.ci/python_dependencies_wins/include/rangeobject.h new file mode 100644 index 00000000..d2105d02 --- /dev/null +++ b/.ci/python_dependencies_wins/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_IS_TYPE(op, &PyRange_Type) + +#ifdef __cplusplus +} +#endif +#endif /* !Py_RANGEOBJECT_H */ diff --git a/.ci/python_dependencies_wins/include/setobject.h b/.ci/python_dependencies_wins/include/setobject.h new file mode 100644 index 00000000..7f6d0f8e --- /dev/null +++ b/.ci/python_dependencies_wins/include/setobject.h @@ -0,0 +1,110 @@ +/* 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); + +#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_IS_TYPE(ob, &PyFrozenSet_Type) +#define PyFrozenSet_Check(ob) \ + (Py_IS_TYPE(ob, &PyFrozenSet_Type) || \ + PyType_IsSubtype(Py_TYPE(ob), &PyFrozenSet_Type)) + +#define PyAnySet_CheckExact(ob) \ + (Py_IS_TYPE(ob, &PySet_Type) || Py_IS_TYPE(ob, &PyFrozenSet_Type)) +#define PyAnySet_Check(ob) \ + (Py_IS_TYPE(ob, &PySet_Type) || Py_IS_TYPE(ob, &PyFrozenSet_Type) || \ + PyType_IsSubtype(Py_TYPE(ob), &PySet_Type) || \ + PyType_IsSubtype(Py_TYPE(ob), &PyFrozenSet_Type)) + +#define PySet_CheckExact(op) Py_IS_TYPE(op, &PySet_Type) +#define PySet_Check(ob) \ + (Py_IS_TYPE(ob, &PySet_Type) || \ + PyType_IsSubtype(Py_TYPE(ob), &PySet_Type)) + +#ifdef __cplusplus +} +#endif +#endif /* !Py_SETOBJECT_H */ diff --git a/.ci/python_dependencies_wins/include/sliceobject.h b/.ci/python_dependencies_wins/include/sliceobject.h new file mode 100644 index 00000000..c4150604 --- /dev/null +++ b/.ci/python_dependencies_wins/include/sliceobject.h @@ -0,0 +1,65 @@ +#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_IS_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); +Py_DEPRECATED(3.7) +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); + +#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/.ci/python_dependencies_wins/include/structmember.h b/.ci/python_dependencies_wins/include/structmember.h new file mode 100644 index 00000000..9c00e638 --- /dev/null +++ b/.ci/python_dependencies_wins/include/structmember.h @@ -0,0 +1,75 @@ +#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) + +#define PY_AUDIT_READ READ_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/.ci/python_dependencies_wins/include/structseq.h b/.ci/python_dependencies_wins/include/structseq.h new file mode 100644 index 00000000..e67bfda7 --- /dev/null +++ b/.ci/python_dependencies_wins/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 const char * const 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/.ci/python_dependencies_wins/include/sysmodule.h b/.ci/python_dependencies_wins/include/sysmodule.h new file mode 100644 index 00000000..38874425 --- /dev/null +++ b/.ci/python_dependencies_wins/include/sysmodule.h @@ -0,0 +1,41 @@ + +/* 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 *); + +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 +# define Py_CPYTHON_SYSMODULE_H +# include "cpython/sysmodule.h" +# undef Py_CPYTHON_SYSMODULE_H +#endif + +#ifdef __cplusplus +} +#endif +#endif /* !Py_SYSMODULE_H */ diff --git a/.ci/python_dependencies_wins/include/token.h b/.ci/python_dependencies_wins/include/token.h new file mode 100644 index 00000000..6f7ad99c --- /dev/null +++ b/.ci/python_dependencies_wins/include/token.h @@ -0,0 +1,97 @@ +/* Auto-generated by Tools/scripts/generate_token.py */ + +/* 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 +#define COLONEQUAL 53 +#define OP 54 +#define AWAIT 55 +#define ASYNC 56 +#define TYPE_IGNORE 57 +#define TYPE_COMMENT 58 +#define SOFT_KEYWORD 59 +#define ERRORTOKEN 60 +#define N_TOKENS 64 +#define NT_OFFSET 256 + +/* Special definitions for cooperation with parser */ + +#define ISTERMINAL(x) ((x) < NT_OFFSET) +#define ISNONTERMINAL(x) ((x) >= NT_OFFSET) +#define ISEOF(x) ((x) == ENDMARKER) +#define ISWHITESPACE(x) ((x) == ENDMARKER || \ + (x) == NEWLINE || \ + (x) == INDENT || \ + (x) == DEDENT) + + +PyAPI_DATA(const char * const) _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/.ci/python_dependencies_wins/include/traceback.h b/.ci/python_dependencies_wins/include/traceback.h new file mode 100644 index 00000000..b4466f51 --- /dev/null +++ b/.ci/python_dependencies_wins/include/traceback.h @@ -0,0 +1,26 @@ +#ifndef Py_TRACEBACK_H +#define Py_TRACEBACK_H +#ifdef __cplusplus +extern "C" { +#endif + +/* Traceback interface */ + +PyAPI_FUNC(int) PyTraceBack_Here(PyFrameObject *); +PyAPI_FUNC(int) PyTraceBack_Print(PyObject *, PyObject *); + +/* Reveal traceback type so we can typecheck traceback objects */ +PyAPI_DATA(PyTypeObject) PyTraceBack_Type; +#define PyTraceBack_Check(v) Py_IS_TYPE(v, &PyTraceBack_Type) + + +#ifndef Py_LIMITED_API +# define Py_CPYTHON_TRACEBACK_H +# include "cpython/traceback.h" +# undef Py_CPYTHON_TRACEBACK_H +#endif + +#ifdef __cplusplus +} +#endif +#endif /* !Py_TRACEBACK_H */ diff --git a/.ci/python_dependencies_wins/include/tracemalloc.h b/.ci/python_dependencies_wins/include/tracemalloc.h new file mode 100644 index 00000000..05b4cc16 --- /dev/null +++ b/.ci/python_dependencies_wins/include/tracemalloc.h @@ -0,0 +1,38 @@ +#ifndef Py_TRACEMALLOC_H +#define Py_TRACEMALLOC_H + +#ifndef Py_LIMITED_API +/* 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 + +#endif /* !Py_TRACEMALLOC_H */ diff --git a/.ci/python_dependencies_wins/include/tupleobject.h b/.ci/python_dependencies_wins/include/tupleobject.h new file mode 100644 index 00000000..19f9997e --- /dev/null +++ b/.ci/python_dependencies_wins/include/tupleobject.h @@ -0,0 +1,46 @@ +/* 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. +*/ + +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_IS_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); +PyAPI_FUNC(PyObject *) PyTuple_Pack(Py_ssize_t, ...); + +#ifndef Py_LIMITED_API +# define Py_CPYTHON_TUPLEOBJECT_H +# include "cpython/tupleobject.h" +# undef Py_CPYTHON_TUPLEOBJECT_H +#endif + +#ifdef __cplusplus +} +#endif +#endif /* !Py_TUPLEOBJECT_H */ diff --git a/.ci/python_dependencies_wins/include/typeslots.h b/.ci/python_dependencies_wins/include/typeslots.h new file mode 100644 index 00000000..b85dbcc4 --- /dev/null +++ b/.ci/python_dependencies_wins/include/typeslots.h @@ -0,0 +1,94 @@ +/* Do not renumber the file; these numbers are part of the stable ABI. */ +#if defined(Py_LIMITED_API) +/* Disabled, see #10181 */ +#undef Py_bf_getbuffer +#undef Py_bf_releasebuffer +#else +#define Py_bf_getbuffer 1 +#define Py_bf_releasebuffer 2 +#endif +#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 +#if !defined(Py_LIMITED_API) || Py_LIMITED_API+0 >= 0x030A0000 +/* New in 3.10 */ +#define Py_am_send 81 +#endif diff --git a/.ci/python_dependencies_wins/include/unicodeobject.h b/.ci/python_dependencies_wins/include/unicodeobject.h new file mode 100644 index 00000000..eb87535c --- /dev/null +++ b/.ci/python_dependencies_wins/include/unicodeobject.h @@ -0,0 +1,1053 @@ +#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 */ + +/* 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; + +#ifdef __cplusplus +extern "C" { +#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_IS_TYPE(op, &PyUnicode_Type) + +/* --- 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 ========================================================= */ + +/* 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 */ + ); + +#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 + +#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 + +#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. */ + +Py_DEPRECATED(3.3) PyAPI_FUNC(Py_ssize_t) PyUnicode_GetSize( + PyObject *unicode /* Unicode object */ + ); + +#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 + +/* 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 */ + ... + ); + +PyAPI_FUNC(void) PyUnicode_InternInPlace(PyObject **); +PyAPI_FUNC(PyObject *) PyUnicode_InternFromString( + const char *u /* UTF-8 encoded string */ + ); + +// PyUnicode_InternImmortal() is deprecated since Python 3.10 +// and will be removed in Python 3.12. Use PyUnicode_InternInPlace() instead. +Py_DEPRECATED(3.10) PyAPI_FUNC(void) PyUnicode_InternImmortal(PyObject **); + +/* 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 */ + ); + +#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); + +/* === 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 "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. */ + +Py_DEPRECATED(3.6) PyAPI_FUNC(PyObject*) PyUnicode_AsDecodedObject( + PyObject *unicode, /* Unicode object */ + const char *encoding, /* encoding */ + const char *errors /* error handling */ + ); + +/* 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. */ + +Py_DEPRECATED(3.6) PyAPI_FUNC(PyObject*) PyUnicode_AsDecodedUnicode( + PyObject *unicode, /* Unicode object */ + const char *encoding, /* encoding */ + const char *errors /* error handling */ + ); + +/* 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. */ + +Py_DEPRECATED(3.6) PyAPI_FUNC(PyObject*) PyUnicode_AsEncodedObject( + PyObject *unicode, /* Unicode object */ + const char *encoding, /* encoding */ + const char *errors /* error handling */ + ); + +/* 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. */ + +Py_DEPRECATED(3.6) PyAPI_FUNC(PyObject*) PyUnicode_AsEncodedUnicode( + PyObject *unicode, /* Unicode object */ + const char *encoding, /* encoding */ + const char *errors /* error handling */ + ); + +/* 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 */ + ); + +/* --- 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 */ + ); + +/* 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. +*/ + +#if !defined(Py_LIMITED_API) || Py_LIMITED_API+0 >= 0x030A0000 +PyAPI_FUNC(const char *) PyUnicode_AsUTF8AndSize( + PyObject *unicode, + Py_ssize_t *size); +#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. + +*/ + +/* --- 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 */ + ); + +/* --- 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 */ + ); + +PyAPI_FUNC(PyObject*) PyUnicode_AsUnicodeEscapeString( + PyObject *unicode /* Unicode object */ + ); + +/* --- 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 */ + ); + +/* --- 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 */ + ); + +/* --- 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 */ + ); + +/* --- 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 */ + ); + +/* --- MBCS codecs for Windows -------------------------------------------- */ + +#ifdef MS_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 */ + ); + +#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 */ + +/* --- 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 */ + ); + +/* 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 */ + ); + +/* 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 */ + ); + +/* 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); + +/* === Characters Type APIs =============================================== */ + +#ifndef Py_LIMITED_API +# define Py_CPYTHON_UNICODEOBJECT_H +# include "cpython/unicodeobject.h" +# undef Py_CPYTHON_UNICODEOBJECT_H +#endif + +#ifdef __cplusplus +} +#endif +#endif /* !Py_UNICODEOBJECT_H */ diff --git a/.ci/python_dependencies_wins/include/warnings.h b/.ci/python_dependencies_wins/include/warnings.h new file mode 100644 index 00000000..a1ec4252 --- /dev/null +++ b/.ci/python_dependencies_wins/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/.ci/python_dependencies_wins/include/weakrefobject.h b/.ci/python_dependencies_wins/include/weakrefobject.h new file mode 100644 index 00000000..36890820 --- /dev/null +++ b/.ci/python_dependencies_wins/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_IS_TYPE(op, &_PyWeakref_RefType) +#define PyWeakref_CheckProxy(op) \ + (Py_IS_TYPE(op, &_PyWeakref_ProxyType) || \ + Py_IS_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/.ci/python_dependencies_wins/libs/_tkinter.lib b/.ci/python_dependencies_wins/libs/_tkinter.lib new file mode 100644 index 0000000000000000000000000000000000000000..ae5b8aecd7a3c8c7d1c1b4dbaf9d3fbbbbcf2b05 GIT binary patch literal 1750 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ⅅejUq#BUR~*#)i89O^@fb7^)s^h{*CH0C+s7I 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 literal 0 HcmV?d00001 diff --git a/.ci/python_dependencies_wins/libs/python310.lib b/.ci/python_dependencies_wins/libs/python310.lib new file mode 100644 index 0000000000000000000000000000000000000000..108e702748a83e91b8ae952310e20ff350235ea8 GIT binary patch literal 356438 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 TUV-x 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

0pK2CvxR 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

}yVtOFcm*;z&VyNgY# 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 literal 0 HcmV?d00001 diff --git a/.ci/windows_base_files/run.bat b/.ci/windows_base_files/run.bat new file mode 100644 index 00000000..31a83ff6 --- /dev/null +++ b/.ci/windows_base_files/run.bat @@ -0,0 +1,44 @@ +@echo off +setlocal +chcp 65001 >nul +:: Check for administrator privileges + +:: Attempt to create a directory in the system folder, which requires admin privileges +mkdir "%windir%\System32\dummy" >nul 2>&1 + +:: Check if the last operation was successful +if '%errorlevel%' == '0' ( + :: Remove the created directory + rmdir "%windir%\System32\dummy" +) else ( + echo Please run as administrator. 请以管理员方式运行 + pause + exit /b +) + +cd /d %~dp0 +cd ShellAgent + +del "proconfig\widgets\imagen_widgets\library\comfy_custom_nodes\ComfyUI_FizzNodes\javascript\Folder here to satisfy init, eventually I'll have stuff in here..txt" + +set PATH=..\git\bin;%PATH% +set MYSHELL_KEY=OPENSOURCE_FIXED + +git config --global core.longpaths true + +if not exist "output" ( + mkdir "output" +) + +if not exist "servers\web" ( + mkdir -p "servers\web" +) + +if not exist "models\model_status.json" ( + echo {} > "models\model_status.json" +) + +..\python_embeded\python.exe -m pip install -e . +..\python_embeded\python.exe servers\main.py + +pause \ No newline at end of file diff --git a/.github/workflows/stable-release.yaml b/.github/workflows/stable-release.yaml new file mode 100644 index 00000000..f456c7d2 --- /dev/null +++ b/.github/workflows/stable-release.yaml @@ -0,0 +1,167 @@ + +name: "Release To HF" + +on: + workflow_dispatch: + inputs: + git_tag: + description: 'Git Branch Tag' + required: true + type: string + default: "main" + cu: + description: 'CUDA Version' + required: true + type: string + default: "124" + python_minor: + description: 'Python Minor Version' + required: true + type: string + default: "10" + python_patch: + description: 'Python Patch Version' + required: true + type: string + default: "10" + version: + description: 'Release Version Tag' + required: true + type: string + default: "beta" + +jobs: + build: + runs-on: ubuntu-latest + + steps: + - uses: actions/checkout@v3 + ref: ${{ inputs.git_tag }} + + - uses: pnpm/action-setup@v2 + with: + version: 9 + run_install: false + + - uses: actions/setup-node@v4 + with: + node-version: "20" + cache: "pnpm" + cache-dependency-path: "web/pnpm-lock.yaml" + + - working-directory: "./web" + run: pnpm install + + - working-directory: "./web" + run: pnpm turbo run build --filter=web + + - uses: actions/upload-artifact@v3 + with: + name: web-build + path: web/apps/web/dist + + package_shellagent_windows: + permissions: + contents: "write" + packages: "write" + pull-requests: "read" + needs: build + runs-on: windows-latest + steps: + - uses: actions/checkout@v4 + with: + ref: ${{ inputs.git_tag }} + fetch-depth: 0 + persist-credentials: false + submodules: recursive + - uses: actions/setup-python@v5 + with: + python-version: 3.${{ inputs.python_minor }}.${{ inputs.python_patch }} + + - name: Download web-build artifact + uses: actions/download-artifact@v3 + with: + name: web-build + path: ./servers/web-build + + - shell: bash + run: | + cd .. + cp -r ShellAgent ShellAgent_copy + + curl -L https://huggingface.co/XuminYu/git_embed/resolve/main/git.7z?download=true -o git.7z + "C:\Program Files\7-Zip\7z.exe" x git.7z -ogit + + curl https://www.python.org/ftp/python/3.${{ inputs.python_minor }}.${{ inputs.python_patch }}/python-3.${{ inputs.python_minor }}.${{ inputs.python_patch }}-embed-amd64.zip -o python_embeded.zip + unzip python_embeded.zip -d python_embeded + + cd python_embeded + + echo 'import site' >> ./python3${{ inputs.python_minor }}._pth + curl https://bootstrap.pypa.io/get-pip.py -o get-pip.py + ./python.exe get-pip.py + cp -r ../ShellAgent/.ci/python_dependencies_wins/include ./include + cp -r ../ShellAgent/.ci/python_dependencies_wins/Library ./Library + cp -r ../ShellAgent/.ci/python_dependencies_wins/libs ./libs + ./python.exe -s -m pip install torch torchvision torchaudio --index-url https://download.pytorch.org/whl/cu${{ inputs.cu }} + ./python.exe -s -m pip install --use-pep517 pygit2 Cython scikit_build_core enscons pytoml cmake==3.21 + ./python.exe -s -m pip install --use-pep517 -r ../ShellAgent/requirements.txt + ./python.exe -s -m pip install onnx==1.16.1 flask PyExecJS docx2txt fuzzywuzzy git cloudpickle + sed -i '1i../ShellAgent' ./python3${{ inputs.python_minor }}._pth + + cd .. + + mkdir ShellAgent_windows_portable + mv python_embeded ShellAgent_windows_portable + mv git ShellAgent_windows_portable + mv ShellAgent_copy ShellAgent_windows_portable/ShellAgent + + cd ShellAgent_windows_portable + cp -r ShellAgent/.ci/windows_base_files/* ./ + + cd ShellAgent + + mkdir -p models/insightface/models + ls models/insightface/ + curl -L https://huggingface.co/MonsterMMORPG/tools/resolve/main/antelopev2.zip -o models/insightface/models/antelopev2.zip + ls models/insightface/models/ + unzip models/insightface/models/antelopev2.zip -d models/insightface/models/ + + mkdir -p models/vae_approx + ls models + git clone --depth 1 https://github.com/comfyanonymous/taesd + cp taesd/*.pth models/vae_approx + + ../python_embeded/python.exe -m pip install -e . + ../python_embeded/python.exe -m pip show proconfig + # ../python_embeded/python.exe servers/main.py + + cd .. + cd .. + + "C:\Program Files\7-Zip\7z.exe" a -t7z -m0=lzma2 -mx=8 -mfb=64 -md=32m -ms=on -mf=BCJ2 ShellAgent_windows_portable.7z ShellAgent_windows_portable/* + mv ShellAgent_windows_portable.7z ShellAgent/ShellAgent_windows_portable.7z + + ls + + - name: Install Hugging Face Hub SDK + run: pip install huggingface_hub + + - name: Upload binaries to Hugging Face + run: | + from huggingface_hub import HfApi + api = HfApi() + + # Set repository and file paths + repo_id = "myshell-ai/ShellAgent" + file_path = "ShellAgent_windows_portable.7z" + + # Upload the file to Hugging Face repository + api.upload_file( + path_or_fileobj=file_path, + path_in_repo="ShellAgent_${{ inputs.version }}.7z", + repo_id=repo_id, + repo_type="model", # or 'dataset' depending on your use case + token="${{ secrets.HF_TOKEN }}" + ) + shell: python diff --git a/proconfig/widgets/imagen_widgets/__init__.py b/proconfig/widgets/imagen_widgets/__init__.py index 1b56b99c..dafbb8f7 100644 --- a/proconfig/widgets/imagen_widgets/__init__.py +++ b/proconfig/widgets/imagen_widgets/__init__.py @@ -1,6 +1,7 @@ import sys import importlib import os +import asyncio absolute_path = os.path.abspath(os.path.join("proconfig", "widgets", "imagen_widgets", "library", "ComfyUI")) sys.path.append(absolute_path) @@ -8,7 +9,9 @@ from proconfig.widgets.utils import load_module from server import PromptServer -prompt_server = PromptServer(None) +loop = asyncio.new_event_loop() +asyncio.set_event_loop(loop) +prompt_server = PromptServer(loop) sys.modules["custom_nodes"] = load_module("", "proconfig/widgets/imagen_widgets/library/comfy_custom_nodes") diff --git a/proconfig/widgets/tools/web/extensions/EG_GN_NODES/wbksh.js b/proconfig/widgets/tools/web/extensions/EG_GN_NODES/wbksh.js new file mode 100644 index 00000000..808dbc6a --- /dev/null +++ b/proconfig/widgets/tools/web/extensions/EG_GN_NODES/wbksh.js @@ -0,0 +1,75 @@ + +import { app } from "/scripts/app.js"; +import { ComfyWidgets } from "/scripts/widgets.js"; + +app.registerExtension({ + name: "Comfy.wbksh", + async beforeRegisterNodeDef(nodeType, nodeData, app) { + // --- EG_WB_KSH Node + if (nodeData.name === "EG_WB_KSH") { + // Node Created + const onNodeCreated = nodeType.prototype.onNodeCreated; + nodeType.prototype.onNodeCreated = function () { + const ret = onNodeCreated + ? onNodeCreated.apply(this, arguments) + : undefined; + + let EG_WB_KSH = app.graph._nodes.filter( + (wi) => wi.type == nodeData.name + ), + nodeName = `${nodeData.name}_${EG_WB_KSH.length}`; + + console.log(`Create ${nodeData.name}: ${nodeName}`); + + const wi = ComfyWidgets.STRING( + this, + nodeName, + [ + "STRING", + { + default: "", + placeholder: "Text output...", + multiline: true, + }, + ], + app + ); + wi.widget.inputEl.readOnly = true; + return ret; + }; + // Function set value + const outSet = function (texts) { + if (texts.length > 0) { + let widget_id = this?.widgets.findIndex( + (w) => w.type == "customtext" + ); + + if (Array.isArray(texts)) + texts = texts + .filter((word) => word.trim() !== "") + .map((word) => word.trim()) + .join(" "); + + this.widgets[widget_id].value = texts; + app.graph.setDirtyCanvas(true); + } + }; + + // onExecuted + const onExecuted = nodeType.prototype.onExecuted; + nodeType.prototype.onExecuted = function (texts) { + onExecuted?.apply(this, arguments); + outSet.call(this, texts?.string); + }; + // onConfigure + const onConfigure = nodeType.prototype.onConfigure; + nodeType.prototype.onConfigure = function (w) { + onConfigure?.apply(this, arguments); + if (w?.widgets_values?.length) { + outSet.call(this, w.widgets_values); + } + }; + } + // --- EG_WB_KSH Node + }, +}); diff --git a/proconfig/widgets/tools/web/extensions/FizzleDorf/Folder here to satisfy init, eventually I'll have stuff in here..txt b/proconfig/widgets/tools/web/extensions/FizzleDorf/Folder here to satisfy init, eventually I'll have stuff in here..txt new file mode 100644 index 00000000..e69de29b diff --git a/proconfig/widgets/tools/web/extensions/dzNodes/dz_comfy_shared.js b/proconfig/widgets/tools/web/extensions/dzNodes/dz_comfy_shared.js new file mode 100644 index 00000000..c09aeb82 --- /dev/null +++ b/proconfig/widgets/tools/web/extensions/dzNodes/dz_comfy_shared.js @@ -0,0 +1,341 @@ +/** + * File: dz_comfy_shared.js + * Author: Mel Massadian + * + * Copyright (c) 2023 Mel Massadian + * + */ + +import { app } from '../../scripts/app.js' + +export const log = (...args) => { + if (window.DZ?.DEBUG) { + console.debug(...args) + } +} + +//- WIDGET UTILS +export const CONVERTED_TYPE = 'converted-widget' + +export const hasWidgets = (node) => { + if (!node.widgets || !node.widgets?.[Symbol.iterator]) { + return false + } + return true +} + +export const cleanupNode = (node) => { + if (!hasWidgets(node)) { + return + } + + for (const w of node.widgets) { + if (w.canvas) { + w.canvas.remove() + } + if (w.inputEl) { + w.inputEl.remove() + } + // calls the widget remove callback + w.onRemoved?.() + } +} + +export function offsetDOMWidget( + widget, + ctx, + node, + widgetWidth, + widgetY, + height +) { + const margin = 10 + const elRect = ctx.canvas.getBoundingClientRect() + const transform = new DOMMatrix() + .scaleSelf( + elRect.width / ctx.canvas.width, + elRect.height / ctx.canvas.height + ) + .multiplySelf(ctx.getTransform()) + .translateSelf(margin, margin + widgetY) + + const scale = new DOMMatrix().scaleSelf(transform.a, transform.d) + Object.assign(widget.inputEl.style, { + transformOrigin: '0 0', + transform: scale, + left: `${transform.a + transform.e}px`, + top: `${transform.d + transform.f}px`, + width: `${widgetWidth - margin * 2}px`, + // height: `${(widget.parent?.inputHeight || 32) - (margin * 2)}px`, + height: `${(height || widget.parent?.inputHeight || 32) - margin * 2}px`, + + position: 'absolute', + background: !node.color ? '' : node.color, + color: !node.color ? '' : 'white', + zIndex: 5, //app.graph._nodes.indexOf(node), + }) +} + +/** + * Extracts the type and link type from a widget config object. + * @param {*} config + * @returns + */ +export function getWidgetType(config) { + // Special handling for COMBO so we restrict links based on the entries + let type = config?.[0] + let linkType = type + if (type instanceof Array) { + type = 'COMBO' + linkType = linkType.join(',') + } + return { type, linkType } +} + +export const dynamic_connection = ( + node, + index, + connected, + connectionPrefix = 'input_', + connectionType = 'PSDLAYER' +) => { + // remove all non connected inputs + if (!connected && node.inputs.length > 1) { + log(`Removing input ${index} (${node.inputs[index].name})`) + if (node.widgets) { + const w = node.widgets.find((w) => w.name === node.inputs[index].name) + if (w) { + w.onRemoved?.() + node.widgets.length = node.widgets.length - 1 + } + } + node.removeInput(index) + + // make inputs sequential again + for (let i = 0; i < node.inputs.length; i++) { + node.inputs[i].label = `${connectionPrefix}${i + 1}` + } + } + + // add an extra input + if (node.inputs[node.inputs.length - 1].link != undefined) { + log( + `Adding input ${node.inputs.length + 1} (${connectionPrefix}${ + node.inputs.length + 1 + })` + ) + + node.addInput( + `${connectionPrefix}${node.inputs.length + 1}`, + connectionType + ) + } +} + +/** + * Appends a callback to the extra menu options of a given node type. + * @param {*} nodeType + * @param {*} cb + */ +export function addMenuHandler(nodeType, cb) { + const getOpts = nodeType.prototype.getExtraMenuOptions + nodeType.prototype.getExtraMenuOptions = function () { + const r = getOpts.apply(this, arguments) + cb.apply(this, arguments) + return r + } +} + +export function hideWidget(node, widget, suffix = '') { + widget.origType = widget.type + widget.hidden = true + widget.origComputeSize = widget.computeSize + widget.origSerializeValue = widget.serializeValue + widget.computeSize = () => [0, -4] // -4 is due to the gap litegraph adds between widgets automatically + widget.type = CONVERTED_TYPE + suffix + widget.serializeValue = () => { + // Prevent serializing the widget if we have no input linked + const { link } = node.inputs.find((i) => i.widget?.name === widget.name) + if (link == null) { + return undefined + } + return widget.origSerializeValue + ? widget.origSerializeValue() + : widget.value + } + + // Hide any linked widgets, e.g. seed+seedControl + if (widget.linkedWidgets) { + for (const w of widget.linkedWidgets) { + hideWidget(node, w, ':' + widget.name) + } + } +} + +export function showWidget(widget) { + widget.type = widget.origType + widget.computeSize = widget.origComputeSize + widget.serializeValue = widget.origSerializeValue + + delete widget.origType + delete widget.origComputeSize + delete widget.origSerializeValue + + // Hide any linked widgets, e.g. seed+seedControl + if (widget.linkedWidgets) { + for (const w of widget.linkedWidgets) { + showWidget(w) + } + } +} + +export function convertToWidget(node, widget) { + showWidget(widget) + const sz = node.size + node.removeInput(node.inputs.findIndex((i) => i.widget?.name === widget.name)) + + for (const widget of node.widgets) { + widget.last_y -= LiteGraph.NODE_SLOT_HEIGHT + } + + // Restore original size but grow if needed + node.setSize([Math.max(sz[0], node.size[0]), Math.max(sz[1], node.size[1])]) +} + +export function convertToInput(node, widget, config) { + hideWidget(node, widget) + + const { linkType } = getWidgetType(config) + + // Add input and store widget config for creating on primitive node + const sz = node.size + node.addInput(widget.name, linkType, { + widget: { name: widget.name, config }, + }) + + for (const widget of node.widgets) { + widget.last_y += LiteGraph.NODE_SLOT_HEIGHT + } + + // Restore original size but grow if needed + node.setSize([Math.max(sz[0], node.size[0]), Math.max(sz[1], node.size[1])]) +} + +export function hideWidgetForGood(node, widget, suffix = '') { + widget.origType = widget.type + widget.origComputeSize = widget.computeSize + widget.origSerializeValue = widget.serializeValue + widget.computeSize = () => [0, -4] // -4 is due to the gap litegraph adds between widgets automatically + widget.type = CONVERTED_TYPE + suffix + // widget.serializeValue = () => { + // // Prevent serializing the widget if we have no input linked + // const w = node.inputs?.find((i) => i.widget?.name === widget.name); + // if (w?.link == null) { + // return undefined; + // } + // return widget.origSerializeValue ? widget.origSerializeValue() : widget.value; + // }; + + // Hide any linked widgets, e.g. seed+seedControl + if (widget.linkedWidgets) { + for (const w of widget.linkedWidgets) { + hideWidgetForGood(node, w, ':' + widget.name) + } + } +} + +export function fixWidgets(node) { + if (node.inputs) { + for (const input of node.inputs) { + log(input) + if (input.widget || node.widgets) { + // if (newTypes.includes(input.type)) { + const matching_widget = node.widgets.find((w) => w.name === input.name) + if (matching_widget) { + // if (matching_widget.hidden) { + // log(`Already hidden skipping ${matching_widget.name}`) + // continue + // } + const w = node.widgets.find((w) => w.name === matching_widget.name) + if (w && w.type != CONVERTED_TYPE) { + log(w) + log(`hidding ${w.name}(${w.type}) from ${node.type}`) + log(node) + hideWidget(node, w) + } else { + log(`converting to widget ${w}`) + + convertToWidget(node, input) + } + } + } + } + } +} +export function inner_value_change(widget, value, event = undefined) { + if (widget.type == 'number' || widget.type == 'BBOX') { + value = Number(value) + } else if (widget.type == 'BOOL') { + value = Boolean(value) + } + widget.value = value + if ( + widget.options && + widget.options.property && + node.properties[widget.options.property] !== undefined + ) { + node.setProperty(widget.options.property, value) + } + if (widget.callback) { + widget.callback(widget.value, app.canvas, node, pos, event) + } +} + +//- COLOR UTILS +export function isColorBright(rgb, threshold = 240) { + const brightess = getBrightness(rgb) + return brightess > threshold +} + +function getBrightness(rgbObj) { + return Math.round( + (parseInt(rgbObj[0]) * 299 + + parseInt(rgbObj[1]) * 587 + + parseInt(rgbObj[2]) * 114) / + 1000 + ) +} + +//- HTML / CSS UTILS +export function defineClass(className, classStyles) { + const styleSheets = document.styleSheets + + // Helper function to check if the class exists in a style sheet + function classExistsInStyleSheet(styleSheet) { + const rules = styleSheet.rules || styleSheet.cssRules + for (const rule of rules) { + if (rule.selectorText === `.${className}`) { + return true + } + } + return false + } + + // Check if the class is already defined in any of the style sheets + let classExists = false + for (const styleSheet of styleSheets) { + if (classExistsInStyleSheet(styleSheet)) { + classExists = true + break + } + } + + // If the class doesn't exist, add the new class definition to the first style sheet + if (!classExists) { + if (styleSheets[0].insertRule) { + styleSheets[0].insertRule(`.${className} { ${classStyles} }`, 0) + } else if (styleSheets[0].addRule) { + styleSheets[0].addRule(`.${className}`, classStyles, 0) + } + } +} diff --git a/proconfig/widgets/tools/web/extensions/dzNodes/dz_debug.js b/proconfig/widgets/tools/web/extensions/dzNodes/dz_debug.js new file mode 100644 index 00000000..1fae3d17 --- /dev/null +++ b/proconfig/widgets/tools/web/extensions/dzNodes/dz_debug.js @@ -0,0 +1,109 @@ +/** + * File: debug.js + * Project: comfy_DZ + * Author: Mel Massadian + * + * Copyright (c) 2023 Mel Massadian + * + */ + +import { app } from '../../scripts/app.js' + +import * as shared from './dz_comfy_shared.js' +import { log } from './dz_comfy_shared.js' +import { DZWidgets } from './dz_DZ_widgets.js' + +// TODO: respect inputs order... + +function escapeHtml(unsafe) { + return unsafe + .replace(/&/g, '&') + .replace(//g, '>') + .replace(/"/g, '"') + .replace(/'/g, ''') +} +app.registerExtension({ + name: 'DZ.Debug', + async beforeRegisterNodeDef(nodeType, nodeData, app) { + if (nodeData.name === 'Debug (DZ)') { + const onConnectionsChange = nodeType.prototype.onConnectionsChange + nodeType.prototype.onConnectionsChange = function ( + type, + index, + connected, + link_info + ) { + const r = onConnectionsChange + ? onConnectionsChange.apply(this, arguments) + : undefined + // TODO: remove all widgets on disconnect once computed + shared.dynamic_connection(this, index, connected, 'anything_', '*') + + //- infer type + if (link_info) { + const fromNode = this.graph._nodes.find( + (otherNode) => otherNode.id == link_info.origin_id + ) + const type = fromNode.outputs[link_info.origin_slot].type + this.inputs[index].type = type + // this.inputs[index].label = type.toLowerCase() + } + //- restore dynamic input + if (!connected) { + this.inputs[index].type = '*' + this.inputs[index].label = `anything_${index + 1}` + } + } + + const onExecuted = nodeType.prototype.onExecuted + nodeType.prototype.onExecuted = function (message) { + onExecuted?.apply(this, arguments) + + const prefix = 'anything_' + + if (this.widgets) { + // const pos = this.widgets.findIndex((w) => w.name === "anything_1"); + // if (pos !== -1) { + for (let i = 0; i < this.widgets.length; i++) { + this.widgets[i].onRemoved?.() + } + this.widgets.length = 0 + } + let widgetI = 1 + if (message.text) { + for (const txt of message.text) { + const w = this.addCustomWidget( + DZWidgets.DEBUG_STRING(`${prefix}_${widgetI}`, escapeHtml(txt)) + ) + w.parent = this + widgetI++ + } + } + if (message.b64_images) { + for (const img of message.b64_images) { + const w = this.addCustomWidget( + DZWidgets.DEBUG_IMG(`${prefix}_${widgetI}`, img) + ) + w.parent = this + widgetI++ + } + // this.onResize?.(this.size); + // this.resize?.(this.size) + } + + this.setSize(this.computeSize()) + + this.onRemoved = function () { + // When removing this node we need to remove the input from the DOM + for (let y in this.widgets) { + if (this.widgets[y].canvas) { + this.widgets[y].canvas.remove() + } + this.widgets[y].onRemoved?.() + } + } + } + } + }, +}) diff --git a/proconfig/widgets/tools/web/extensions/dzNodes/dz_mtb_widgets.js b/proconfig/widgets/tools/web/extensions/dzNodes/dz_mtb_widgets.js new file mode 100644 index 00000000..a9e15a40 --- /dev/null +++ b/proconfig/widgets/tools/web/extensions/dzNodes/dz_mtb_widgets.js @@ -0,0 +1,908 @@ +/** + * File: DZ_widgets.js + * Project: comfy_DZ + * Author: Mel Massadian + * + * Copyright (c) 2023 Mel Massadian + * + */ + +import { app } from '../../scripts/app.js' +import { api } from '../../scripts/api.js' + +import parseCss from './dz_parse-css.js' +import * as shared from './dz_comfy_shared.js' +import { log } from './dz_comfy_shared.js' + +const newTypes = [, /*'BOOL'*/ 'COLOR', 'BBOX'] + +const withFont = (ctx, font, cb) => { + const oldFont = ctx.font + ctx.font = font + cb() + ctx.font = oldFont +} + +const calculateTextDimensions = (ctx, value, width, fontSize = 16) => { + const words = value.split(' ') + const lines = [] + let currentLine = '' + for (const word of words) { + const testLine = currentLine.length === 0 ? word : `${currentLine} ${word}` + const testWidth = ctx.measureText(testLine).width + if (testWidth > width) { + lines.push(currentLine) + currentLine = word + } else { + currentLine = testLine + } + } + if (lines.length === 0) lines.push(value) + const textHeight = (lines.length + 1) * fontSize + const maxLineWidth = lines.reduce( + (maxWidth, line) => Math.max(maxWidth, ctx.measureText(line).width), + 0 + ) + return { textHeight, maxLineWidth } +} + +export const DZWidgets = { + BBOX: (key, val) => { + /** @type {import("./types/litegraph").IWidget} */ + const widget = { + name: key, + type: 'BBOX', + // options: val, + y: 0, + value: val?.default || [0, 0, 0, 0], + options: {}, + + draw: function (ctx, node, widget_width, widgetY, height) { + const hide = this.type !== 'BBOX' && app.canvas.ds.scale > 0.5 + + const show_text = true + const outline_color = LiteGraph.WIDGET_OUTLINE_COLOR + const background_color = LiteGraph.WIDGET_BGCOLOR + const text_color = LiteGraph.WIDGET_TEXT_COLOR + const secondary_text_color = LiteGraph.WIDGET_SECONDARY_TEXT_COLOR + const H = LiteGraph.NODE_WIDGET_HEIGHT + + let margin = 15 + let numWidgets = 4 // Number of stacked widgets + + if (hide) return + + for (let i = 0; i < numWidgets; i++) { + let currentY = widgetY + i * (H + margin) // Adjust Y position for each widget + + ctx.textAlign = 'left' + ctx.strokeStyle = outline_color + ctx.fillStyle = background_color + ctx.beginPath() + if (show_text) + ctx.roundRect(margin, currentY, widget_width - margin * 2, H, [ + H * 0.5, + ]) + else ctx.rect(margin, currentY, widget_width - margin * 2, H) + ctx.fill() + if (show_text) { + if (!this.disabled) ctx.stroke() + ctx.fillStyle = text_color + if (!this.disabled) { + ctx.beginPath() + ctx.moveTo(margin + 16, currentY + 5) + ctx.lineTo(margin + 6, currentY + H * 0.5) + ctx.lineTo(margin + 16, currentY + H - 5) + ctx.fill() + ctx.beginPath() + ctx.moveTo(widget_width - margin - 16, currentY + 5) + ctx.lineTo(widget_width - margin - 6, currentY + H * 0.5) + ctx.lineTo(widget_width - margin - 16, currentY + H - 5) + ctx.fill() + } + ctx.fillStyle = secondary_text_color + ctx.fillText( + this.label || this.name, + margin * 2 + 5, + currentY + H * 0.7 + ) + ctx.fillStyle = text_color + ctx.textAlign = 'right' + + ctx.fillText( + Number(this.value).toFixed( + this.options?.precision !== undefined + ? this.options.precision + : 3 + ), + widget_width - margin * 2 - 20, + currentY + H * 0.7 + ) + } + } + }, + mouse: function (event, pos, node) { + let old_value = this.value + let x = pos[0] - node.pos[0] + let y = pos[1] - node.pos[1] + let width = node.size[0] + let H = LiteGraph.NODE_WIDGET_HEIGHT + let margin = 5 + let numWidgets = 4 // Number of stacked widgets + + for (let i = 0; i < numWidgets; i++) { + let currentY = y + i * (H + margin) // Adjust Y position for each widget + + if ( + event.type == LiteGraph.pointerevents_method + 'move' && + this.type == 'BBOX' + ) { + if (event.deltaX) + this.value += event.deltaX * 0.1 * (this.options?.step || 1) + if (this.options.min != null && this.value < this.options.min) { + this.value = this.options.min + } + if (this.options.max != null && this.value > this.options.max) { + this.value = this.options.max + } + } else if (event.type == LiteGraph.pointerevents_method + 'down') { + let values = this.options?.values + if (values && values.constructor === Function) { + values = this.options.values(w, node) + } + let values_list = null + + let delta = x < 40 ? -1 : x > widget_width - 40 ? 1 : 0 + if (this.type == 'BBOX') { + this.value += delta * 0.1 * (this.options.step || 1) + if (this.options.min != null && this.value < this.options.min) { + this.value = this.options.min + } + if (this.options.max != null && this.value > this.options.max) { + this.value = this.options.max + } + } else if (delta) { + //clicked in arrow, used for combos + let index = -1 + this.last_mouseclick = 0 //avoids dobl click event + if (values.constructor === Object) + index = values_list.indexOf(String(this.value)) + delta + else index = values_list.indexOf(this.value) + delta + if (index >= values_list.length) { + index = values_list.length - 1 + } + if (index < 0) { + index = 0 + } + if (values.constructor === Array) this.value = values[index] + else this.value = index + } + } //end mousedown + else if ( + event.type == LiteGraph.pointerevents_method + 'up' && + this.type == 'BBOX' + ) { + let delta = x < 40 ? -1 : x > widget_width - 40 ? 1 : 0 + if (event.click_time < 200 && delta == 0) { + this.prompt( + 'Value', + this.value, + function (v) { + // check if v is a valid equation or a number + if (/^[0-9+\-*/()\s]+|\d+\.\d+$/.test(v)) { + try { + //solve the equation if possible + v = eval(v) + } catch (e) {} + } + this.value = Number(v) + shared.inner_value_change(this, this.value, event) + }.bind(w), + event + ) + } + } + + if (old_value != this.value) + setTimeout( + function () { + shared.inner_value_change(this, this.value, event) + }.bind(this), + 20 + ) + + app.canvas.setDirty(true) + } + }, + computeSize: function (width) { + return [width, LiteGraph.NODE_WIDGET_HEIGHT * 4] + }, + // onDrawBackground: function (ctx) { + // if (!this.flags.collapsed) return; + // this.inputEl.style.display = "block"; + // this.inputEl.style.top = this.graphcanvas.offsetTop + this.pos[1] + "px"; + // this.inputEl.style.left = this.graphcanvas.offsetLeft + this.pos[0] + "px"; + // }, + // onInputChange: function (e) { + // const property = e.target.dataset.property; + // const bbox = this.getInputData(0); + // if (!bbox) return; + // bbox[property] = parseFloat(e.target.value); + // this.setOutputData(0, bbox); + // } + } + + widget.desc = 'Represents a Bounding Box with x, y, width, and height.' + return widget + }, + + COLOR: (key, val, compute = false) => { + /** @type {import("/types/litegraph").IWidget} */ + const widget = {} + widget.y = 0 + widget.name = key + widget.type = 'COLOR' + widget.options = { default: '#ff0000' } + widget.value = val || '#ff0000' + widget.draw = function (ctx, node, widgetWidth, widgetY, height) { + const hide = this.type !== 'COLOR' && app.canvas.ds.scale > 0.5 + if (hide) { + return + } + const border = 3 + ctx.fillStyle = '#000' + ctx.fillRect(0, widgetY, widgetWidth, height) + ctx.fillStyle = this.value + ctx.fillRect( + border, + widgetY + border, + widgetWidth - border * 2, + height - border * 2 + ) + const color = parseCss(this.value.default || this.value) + if (!color) { + return + } + ctx.fillStyle = shared.isColorBright(color.values, 125) ? '#000' : '#fff' + + ctx.font = '14px Arial' + ctx.textAlign = 'center' + ctx.fillText(this.name, widgetWidth * 0.5, widgetY + 14) + } + widget.mouse = function (e, pos, node) { + if (e.type === 'pointerdown') { + const widgets = node.widgets.filter((w) => w.type === 'COLOR') + + for (const w of widgets) { + // color picker + const rect = [w.last_y, w.last_y + 32] + if (pos[1] > rect[0] && pos[1] < rect[1]) { + const picker = document.createElement('input') + picker.type = 'color' + picker.value = this.value + + picker.style.position = 'absolute' + picker.style.left = '999999px' //(window.innerWidth / 2) + "px"; + picker.style.top = '999999px' //(window.innerHeight / 2) + "px"; + + document.body.appendChild(picker) + + picker.addEventListener('change', () => { + this.value = picker.value + node.graph._version++ + node.setDirtyCanvas(true, true) + picker.remove() + }) + + picker.click() + } + } + } + } + widget.computeSize = function (width) { + return [width, 32] + } + + return widget + }, + + DEBUG_IMG: (name, val) => { + const w = { + name, + type: 'image', + value: val, + draw: function (ctx, node, widgetWidth, widgetY, height) { + const [cw, ch] = this.computeSize(widgetWidth) + shared.offsetDOMWidget(this, ctx, node, widgetWidth, widgetY, ch) + }, + computeSize: function (width) { + const ratio = this.inputRatio || 1 + if (width) { + return [width, width / ratio + 4] + } + return [128, 128] + }, + onRemoved: function () { + if (this.inputEl) { + this.inputEl.remove() + } + }, + } + + w.inputEl = document.createElement('img') + w.inputEl.src = w.value + w.inputEl.onload = function () { + w.inputRatio = w.inputEl.naturalWidth / w.inputEl.naturalHeight + } + document.body.appendChild(w.inputEl) + return w + }, + DEBUG_STRING: (name, val) => { + const fontSize = 16 + const w = { + name, + type: 'debug_text', + + draw: function (ctx, node, widgetWidth, widgetY, height) { + // const [cw, ch] = this.computeSize(widgetWidth) + shared.offsetDOMWidget(this, ctx, node, widgetWidth, widgetY, height) + }, + computeSize(width) { + if (!this.value) { + return [32, 32] + } + if (!width) { + console.debug(`No width ${this.parent.size}`) + } + let dimensions + withFont(app.ctx, `${fontSize}px monospace`, () => { + dimensions = calculateTextDimensions(app.ctx, this.value, width) + }) + const widgetWidth = Math.max( + width || this.width || 32, + dimensions.maxLineWidth + ) + const widgetHeight = dimensions.textHeight * 1.5 + return [widgetWidth, widgetHeight] + }, + onRemoved: function () { + if (this.inputEl) { + this.inputEl.remove() + } + }, + get value() { + return this.inputEl.innerHTML + }, + set value(val) { + this.inputEl.innerHTML = val + this.parent?.setSize?.(this.parent?.computeSize()) + }, + } + + w.inputEl = document.createElement('p') + w.inputEl.style = ` + text-align: center; + font-size: ${fontSize}px; + color: var(--input-text); + line-height: 0; + font-family: monospace; + ` + w.value = val + document.body.appendChild(w.inputEl) + + return w + }, +} + +/** + * @returns {import("./types/comfy").ComfyExtension} extension + */ +const DZ_widgets = { + name: 'DZ.widgets', + + init: async () => { + log('Registering DZ.widgets') + try { + const res = await api.fetchApi('/DZ/debug') + const msg = await res.json() + if (!window.DZ) { + window.DZ = {} + } + window.DZ.DEBUG = msg.enabled + } catch (e) { + console.error('Error:', error) + } + }, + + setup: () => { + app.ui.settings.addSetting({ + id: 'DZ.Debug.enabled', + name: '[DZ] Enable Debug (py and js)', + type: 'boolean', + defaultValue: false, + + tooltip: + 'This will enable debug messages in the console and in the python console respectively', + attrs: { + style: { + fontFamily: 'monospace', + }, + }, + async onChange(value) { + if (value) { + console.log('Enabled DEBUG mode') + } + if (!window.DZ) { + window.DZ = {} + } + window.DZ.DEBUG = value + await api + .fetchApi('/DZ/debug', { + method: 'POST', + body: JSON.stringify({ + enabled: value, + }), + }) + .then((response) => {}) + .catch((error) => { + console.error('Error:', error) + }) + }, + }) + }, + + getCustomWidgets: function () { + return { + BOOL: (node, inputName, inputData, app) => { + console.debug('Registering bool') + + return { + widget: node.addCustomWidget( + DZWidgets.BOOL(inputName, inputData[1]?.default || false) + ), + minWidth: 150, + minHeight: 30, + } + }, + + COLOR: (node, inputName, inputData, app) => { + console.debug('Registering color') + return { + widget: node.addCustomWidget( + DZWidgets.COLOR(inputName, inputData[1]?.default || '#ff0000') + ), + minWidth: 150, + minHeight: 30, + } + }, + // BBOX: (node, inputName, inputData, app) => { + // console.debug("Registering bbox") + // return { + // widget: node.addCustomWidget(DZWidgets.BBOX(inputName, inputData[1]?.default || [0, 0, 0, 0])), + // minWidth: 150, + // minHeight: 30, + // } + + // } + } + }, + /** + * @param {import("./types/comfy").NodeType} nodeType + * @param {import("./types/comfy").NodeDef} nodeData + * @param {import("./types/comfy").App} app + */ + async beforeRegisterNodeDef(nodeType, nodeData, app) { + // const rinputs = nodeData.input?.required + + let has_custom = false + if (nodeData.input && nodeData.input.required) { + for (const i of Object.keys(nodeData.input.required)) { + const input_type = nodeData.input.required[i][0] + + if (newTypes.includes(input_type)) { + has_custom = true + break + } + } + } + if (has_custom) { + //- Add widgets on node creation + const onNodeCreated = nodeType.prototype.onNodeCreated + nodeType.prototype.onNodeCreated = function () { + const r = onNodeCreated + ? onNodeCreated.apply(this, arguments) + : undefined + this.serialize_widgets = true + this.setSize?.(this.computeSize()) + + this.onRemoved = function () { + // When removing this node we need to remove the input from the DOM + shared.cleanupNode(this) + } + return r + } + + //- Extra menus + const origGetExtraMenuOptions = nodeType.prototype.getExtraMenuOptions + nodeType.prototype.getExtraMenuOptions = function (_, options) { + const r = origGetExtraMenuOptions + ? origGetExtraMenuOptions.apply(this, arguments) + : undefined + if (this.widgets) { + let toInput = [] + let toWidget = [] + for (const w of this.widgets) { + if (w.type === shared.CONVERTED_TYPE) { + //- This is already handled by widgetinputs.js + // toWidget.push({ + // content: `Convert ${w.name} to widget`, + // callback: () => shared.convertToWidget(this, w), + // }); + } else if (newTypes.includes(w.type)) { + const config = nodeData?.input?.required[w.name] || + nodeData?.input?.optional?.[w.name] || [w.type, w.options || {}] + + toInput.push({ + content: `Convert ${w.name} to input`, + callback: () => shared.convertToInput(this, w, config), + }) + } + } + if (toInput.length) { + options.push(...toInput, null) + } + + if (toWidget.length) { + options.push(...toWidget, null) + } + } + + return r + } + } + + //- Extending Python Nodes + switch (nodeData.name) { + case 'Psd Save (DZ)': { + const onConnectionsChange = nodeType.prototype.onConnectionsChange + nodeType.prototype.onConnectionsChange = function ( + type, + index, + connected, + link_info + ) { + const r = onConnectionsChange + ? onConnectionsChange.apply(this, arguments) + : undefined + shared.dynamic_connection(this, index, connected) + return r + } + break + } + //TODO: remove this non sense + case 'Get Batch From History (DZ)': { + const onNodeCreated = nodeType.prototype.onNodeCreated + nodeType.prototype.onNodeCreated = function () { + const r = onNodeCreated + ? onNodeCreated.apply(this, arguments) + : undefined + const internal_count = this.widgets.find( + (w) => w.name === 'internal_count' + ) + shared.hideWidgetForGood(this, internal_count) + internal_count.afterQueued = function () { + this.value++ + } + + return r + } + + const onExecuted = nodeType.prototype.onExecuted + nodeType.prototype.onExecuted = function (message) { + const r = onExecuted ? onExecuted.apply(this, message) : undefined + return r + } + + break + } + case 'Save Gif (DZ)': + case 'Save Animated Image (DZ)': { + const onExecuted = nodeType.prototype.onExecuted + nodeType.prototype.onExecuted = function (message) { + const prefix = 'anything_' + const r = onExecuted ? onExecuted.apply(this, message) : undefined + + if (this.widgets) { + const pos = this.widgets.findIndex((w) => w.name === `${prefix}_0`) + if (pos !== -1) { + for (let i = pos; i < this.widgets.length; i++) { + this.widgets[i].onRemoved?.() + } + this.widgets.length = pos + } + + let imgURLs = [] + if (message) { + if (message.gif) { + imgURLs = imgURLs.concat( + message.gif.map((params) => { + return api.apiURL( + '/view?' + new URLSearchParams(params).toString() + ) + }) + ) + } + if (message.apng) { + imgURLs = imgURLs.concat( + message.apng.map((params) => { + return api.apiURL( + '/view?' + new URLSearchParams(params).toString() + ) + }) + ) + } + let i = 0 + for (const img of imgURLs) { + const w = this.addCustomWidget( + DZWidgets.DEBUG_IMG(`${prefix}_${i}`, img) + ) + w.parent = this + i++ + } + } + const onRemoved = this.onRemoved + this.onRemoved = () => { + shared.cleanupNode(this) + return onRemoved?.() + } + } + this.setSize?.(this.computeSize()) + return r + } + + break + } + case 'Animation Builder (DZ)': { + const onNodeCreated = nodeType.prototype.onNodeCreated + nodeType.prototype.onNodeCreated = function () { + const r = onNodeCreated + ? onNodeCreated.apply(this, arguments) + : undefined + + this.changeMode(LiteGraph.ALWAYS) + + const raw_iteration = this.widgets.find( + (w) => w.name === 'raw_iteration' + ) + const raw_loop = this.widgets.find((w) => w.name === 'raw_loop') + + const total_frames = this.widgets.find( + (w) => w.name === 'total_frames' + ) + const loop_count = this.widgets.find((w) => w.name === 'loop_count') + + shared.hideWidgetForGood(this, raw_iteration) + shared.hideWidgetForGood(this, raw_loop) + + raw_iteration._value = 0 + + const value_preview = this.addCustomWidget( + DZWidgets['DEBUG_STRING']('value_preview', 'Idle') + ) + value_preview.parent = this + + const loop_preview = this.addCustomWidget( + DZWidgets['DEBUG_STRING']('loop_preview', 'Iteration: Idle') + ) + loop_preview.parent = this + + const onReset = () => { + raw_iteration.value = 0 + raw_loop.value = 0 + + value_preview.value = 'Idle' + loop_preview.value = 'Iteration: Idle' + + app.canvas.setDirty(true) + } + + const reset_button = this.addWidget( + 'button', + `Reset`, + 'reset', + onReset + ) + + const run_button = this.addWidget('button', `Queue`, 'queue', () => { + onReset() // this could maybe be a setting or checkbox + app.queuePrompt(0, total_frames.value * loop_count.value) + window.DZ?.notify?.( + `Started a queue of ${total_frames.value} frames (for ${ + loop_count.value + } loop, so ${total_frames.value * loop_count.value})`, + 5000 + ) + }) + + this.onRemoved = () => { + shared.cleanupNode(this) + app.canvas.setDirty(true) + } + + raw_iteration.afterQueued = function () { + this.value++ + raw_loop.value = Math.floor(this.value / total_frames.value) + + value_preview.value = `frame: ${ + raw_iteration.value % total_frames.value + } / ${total_frames.value - 1}` + + if (raw_loop.value + 1 > loop_count.value) { + loop_preview.value = 'Done 😎!' + } else { + loop_preview.value = `current loop: ${raw_loop.value + 1}/${ + loop_count.value + }` + } + } + + return r + } + + break + } + case 'Text Encore Frames (DZ)': { + const onConnectionsChange = nodeType.prototype.onConnectionsChange + nodeType.prototype.onConnectionsChange = function ( + type, + index, + connected, + link_info + ) { + const r = onConnectionsChange + ? onConnectionsChange.apply(this, arguments) + : undefined + + shared.dynamic_connection(this, index, connected) + return r + } + break + } + case 'Interpolate Clip Sequential (DZ)': { + const onNodeCreated = nodeType.prototype.onNodeCreated + nodeType.prototype.onNodeCreated = function () { + const r = onNodeCreated + ? onNodeCreated.apply(this, arguments) + : undefined + const addReplacement = () => { + const input = this.addInput( + `replacement_${this.widgets.length}`, + 'STRING', + '' + ) + console.log(input) + this.addWidget('STRING', `replacement_${this.widgets.length}`, '') + } + //- add + this.addWidget('button', '+', 'add', function (value, widget, node) { + console.log('Button clicked', value, widget, node) + addReplacement() + }) + //- remove + this.addWidget( + 'button', + '-', + 'remove', + function (value, widget, node) { + console.log(`Button clicked: ${value}`, widget, node) + } + ) + + return r + } + break + } + case 'Styles Loader (DZ)': { + const origGetExtraMenuOptions = nodeType.prototype.getExtraMenuOptions + nodeType.prototype.getExtraMenuOptions = function (_, options) { + const r = origGetExtraMenuOptions + ? origGetExtraMenuOptions.apply(this, arguments) + : undefined + + const getStyle = async (node) => { + try { + const getStyles = await api.fetchApi('/DZ/actions', { + method: 'POST', + body: JSON.stringify({ + name: 'getStyles', + args: + node.widgets && node.widgets[0].value + ? node.widgets[0].value + : '', + }), + }) + + const output = await getStyles.json() + return output?.result + } catch (e) { + console.error(e) + } + } + const extracters = [ + { + content: 'Extract Positive to Text node', + callback: async () => { + const style = await getStyle(this) + if (style && style.length >= 1) { + if (style[0]) { + window.DZ?.notify?.( + `Extracted positive from ${this.widgets[0].value}` + ) + const tn = LiteGraph.createNode('Text box') + app.graph.add(tn) + tn.title = `${this.widgets[0].value} (Positive)` + tn.widgets[0].value = style[0] + } else { + window.DZ?.notify?.( + `No positive to extract for ${this.widgets[0].value}` + ) + } + } + }, + }, + { + content: 'Extract Negative to Text node', + callback: async () => { + const style = await getStyle(this) + if (style && style.length >= 2) { + if (style[1]) { + window.DZ?.notify?.( + `Extracted negative from ${this.widgets[0].value}` + ) + const tn = LiteGraph.createNode('Text box') + app.graph.add(tn) + tn.title = `${this.widgets[0].value} (Negative)` + tn.widgets[0].value = style[1] + } else { + window.DZ.notify( + `No negative to extract for ${this.widgets[0].value}` + ) + } + } + }, + }, + ] + options.push(...extracters) + } + + break + } + case 'Save Tensors (DZ)': { + const onDrawBackground = nodeType.prototype.onDrawBackground + nodeType.prototype.onDrawBackground = function (ctx, canvas) { + const r = onDrawBackground + ? onDrawBackground.apply(this, arguments) + : undefined + // // draw a circle on the top right of the node, with text inside + // ctx.fillStyle = "#fff"; + // ctx.beginPath(); + // ctx.arc(this.size[0] - this.node_width * 0.5, this.size[1] - this.node_height * 0.5, this.node_width * 0.5, 0, Math.PI * 2); + // ctx.fill(); + + // ctx.fillStyle = "#000"; + // ctx.textAlign = "center"; + // ctx.font = "bold 12px Arial"; + // ctx.fillText("Save Tensors", this.size[0] - this.node_width * 0.5, this.size[1] - this.node_height * 0.5); + + return r + } + break + } + default: { + break + } + } + }, +} + +app.registerExtension(DZ_widgets) diff --git a/proconfig/widgets/tools/web/extensions/dzNodes/dz_node_palette.js b/proconfig/widgets/tools/web/extensions/dzNodes/dz_node_palette.js new file mode 100644 index 00000000..63565005 --- /dev/null +++ b/proconfig/widgets/tools/web/extensions/dzNodes/dz_node_palette.js @@ -0,0 +1,42 @@ +import { app } from "../../scripts/app.js"; + + +app.registerExtension({ + name: "ColorOverlay", + async nodeCreated(node) { + // 判断是否为layer节点 + if(!node.comfyClass.startsWith("Layer")) { + return; + } + + if(node.comfyClass.startsWith("LayerStyle:")) { + node.color = "rgba(20, 95, 121, 0.7)"; +// node.bgcolor = "rgba(50, 241, 255, 0.15)"; + } + + if(node.comfyClass.startsWith("LayerColor:")) { + node.color = "rgba(27, 89, 123, 0.7)"; +// node.bgcolor = "rgba(43, 209, 255, 0.15)"; + } + + if(node.comfyClass.startsWith("LayerMask:")) { + node.color = "rgba(27, 80, 119, 0.7)"; +// node.bgcolor = "rgba(4, 174, 255, 0.15)"; + } + + if(node.comfyClass.startsWith("LayerUtility:")) { + node.color = "rgba(38, 73, 116, 0.7)"; +// node.bgcolor = "rgba(23, 113, 255, 0.15)"; + } + + if(node.comfyClass.startsWith("LayerFilter:")) { + node.color = "rgba(34, 67, 111, 0.7)"; +// node.bgcolor = "rgba(19, 85, 255, 0.15)"; + } + + +// if(node.comfyClass === "LayerStyle: ColorOverlay"){ +// node.setSize([600, 120]); +// } + } +}); \ No newline at end of file diff --git a/proconfig/widgets/tools/web/extensions/dzNodes/dz_parse-css.js b/proconfig/widgets/tools/web/extensions/dzNodes/dz_parse-css.js new file mode 100644 index 00000000..1ae53b04 --- /dev/null +++ b/proconfig/widgets/tools/web/extensions/dzNodes/dz_parse-css.js @@ -0,0 +1,362 @@ + +// #region patterns +const float = '-?\\d*(?:\\.\\d+)'; +export const number = `(${float}?)`; +export const percentage = `(${float}?%)`; +export const numberOrPercentage = `(${float}?%?)`; +const clamp = (num, min, max) => Math.min(Math.max(min, num), max); + +const hexCharacters = 'a-f\\d'; +const match3or4Hex = `#?[${hexCharacters}]{3}[${hexCharacters}]?`; +const match6or8Hex = `#?[${hexCharacters}]{6}([${hexCharacters}]{2})?`; +const nonHexChars = new RegExp(`[^#${hexCharacters}]`, 'gi'); +const validHexSize = new RegExp(`^${match3or4Hex}$|^${match6or8Hex}$`, 'i'); + + +export const hex_pattern = new RegExp(/^#([a-f0-9]{3,4}|[a-f0-9]{4}(?:[a-f0-9]{2}){1,2})\b$/, "i"); + +export const hsl3_pattern = new RegExp(`^ + hsla?\\( + \\s*(-?\\d*(?:\\.\\d+)?(?:deg|rad|turn)?)\\s*, + \\s*${percentage}\\s*, + \\s*${percentage}\\s* + (?:,\\s*${numberOrPercentage}\\s*)? + \\) + $ +`.replace(/\n|\s/g, '')) + +export const hsl4_pattern = new RegExp(`^ + hsla?\\( + \\s*(-?\\d*(?:\\.\\d+)?(?:deg|rad|turn)?)\\s* + \\s+${percentage} + \\s+${percentage} + \\s*(?:\\s*\\/\\s*${numberOrPercentage}\\s*)? + \\) + $ +`.replace(/\n|\s/g, '')) + +export const rgb3_pattern = new RegExp(`^ + rgba?\\( + \\s*${number}\\s*, + \\s*${number}\\s*, + \\s*${number}\\s* + (?:,\\s*${numberOrPercentage}\\s*)? + \\) + $ +`.replace(/\n|\s/g, '')) + +export const rgb4_pattern = new RegExp(`^ + rgba?\\( + \\s*${number} + \\s+${number} + \\s+${number} + \\s*(?:\\s*\\/\\s*${numberOrPercentage}\\s*)? + \\) +$ +`.replace(/\n|\s/g, '')); + +export const transparent_pattern = new RegExp(/^transparent$/, 'i'); +// #endregion + + +// #region utils + + +/* 500 => 255, -10 => 0, 128 => 128 */ +const parseRGB = (num) => { + let n = num; + if (typeof n !== 'number') { + n = n.endsWith('%') ? (parseFloat(n) * 255) / 100 : parseFloat(n); + } + return clamp(Math.round(n), 0, 255); +}; + +/* 200 => 100, -100 => 0, 50 => 50 */ +const parsePercentage = (percentage) => clamp(parseFloat(percentage), 0, 100); + +/* '50%' => 5.0, 200 => 1, -10 => 0 */ +function parseAlpha(alpha) { + let a = alpha; + if (typeof a !== 'number') { + a = a.endsWith('%') ? parseFloat(a) / 100 : parseFloat(a); + } + return clamp(a, 0, 1); +} + +export function getHEX(hex) { + const [r, g, b, a] = hex2Rgb(hex, { format: 'array' }); + return getRGB([null, ...[r, g, b, a]]); +} + +export function getHSL([, h, s, l, a = 1]) { + let hh = h; + if (hh.endsWith('turn')) { + hh = (parseFloat(hh) * 360) / 1; + } else if (hh.endsWith('rad')) { + hh = Math.round((parseFloat(hh) * 180) / Math.PI); + } else { + hh = parseFloat(hh); + } + return { + type: 'hsl', + values: [hh, parsePercentage(s), parsePercentage(l)], + alpha: parseAlpha(a === null ? 1 : a) + }; +} + +export function getRGB([, r, g, b, a = 1]) { + return { + type: 'rgb', + values: [r, g, b].map(parseRGB), + alpha: parseAlpha(a === null ? 1 : a) + }; +} +export function hex2Rgb(hex, options = {}) { + if (typeof hex !== 'string' || nonHexChars.test(hex) || !validHexSize.test(hex)) { + throw new TypeError('Expected a valid hex string'); + } + + hex = hex.replace(/^#/, ''); + let alphaFromHex = 1; + + if (hex.length === 8) { + alphaFromHex = Number.parseInt(hex.slice(6, 8), 16) / 255; + hex = hex.slice(0, 6); + } + + if (hex.length === 4) { + alphaFromHex = Number.parseInt(hex.slice(3, 4).repeat(2), 16) / 255; + hex = hex.slice(0, 3); + } + + if (hex.length === 3) { + hex = hex[0] + hex[0] + hex[1] + hex[1] + hex[2] + hex[2]; + } + + const number = Number.parseInt(hex, 16); + const red = number >> 16; + const green = (number >> 8) & 255; + const blue = number & 255; + const alpha = typeof options.alpha === 'number' ? options.alpha : alphaFromHex; + + if (options.format === 'array') { + return [red, green, blue, alpha]; + } + + if (options.format === 'css') { + const alphaString = alpha === 1 ? '' : ` / ${Number((alpha * 100).toFixed(2))}%`; + return `rgb(${red} ${green} ${blue}${alphaString})`; + } + + return {red, green, blue, alpha}; +} +// #endregion + + +// #region colorNames +export const colorName = { + aliceblue: [240, 248, 255], + antiquewhite: [250, 235, 215], + aqua: [0, 255, 255], + aquamarine: [127, 255, 212], + azure: [240, 255, 255], + beige: [245, 245, 220], + bisque: [255, 228, 196], + black: [0, 0, 0], + blanchedalmond: [255, 235, 205], + blue: [0, 0, 255], + blueviolet: [138, 43, 226], + brown: [165, 42, 42], + burlywood: [222, 184, 135], + cadetblue: [95, 158, 160], + chartreuse: [127, 255, 0], + chocolate: [210, 105, 30], + coral: [255, 127, 80], + cornflowerblue: [100, 149, 237], + cornsilk: [255, 248, 220], + crimson: [220, 20, 60], + cyan: [0, 255, 255], + darkblue: [0, 0, 139], + darkcyan: [0, 139, 139], + darkgoldenrod: [184, 134, 11], + darkgray: [169, 169, 169], + darkgreen: [0, 100, 0], + darkgrey: [169, 169, 169], + darkkhaki: [189, 183, 107], + darkmagenta: [139, 0, 139], + darkolivegreen: [85, 107, 47], + darkorange: [255, 140, 0], + darkorchid: [153, 50, 204], + darkred: [139, 0, 0], + darksalmon: [233, 150, 122], + darkseagreen: [143, 188, 143], + darkslateblue: [72, 61, 139], + darkslategray: [47, 79, 79], + darkslategrey: [47, 79, 79], + darkturquoise: [0, 206, 209], + darkviolet: [148, 0, 211], + deeppink: [255, 20, 147], + deepskyblue: [0, 191, 255], + dimgray: [105, 105, 105], + dimgrey: [105, 105, 105], + dodgerblue: [30, 144, 255], + firebrick: [178, 34, 34], + floralwhite: [255, 250, 240], + forestgreen: [34, 139, 34], + fuchsia: [255, 0, 255], + gainsboro: [220, 220, 220], + ghostwhite: [248, 248, 255], + gold: [255, 215, 0], + goldenrod: [218, 165, 32], + gray: [128, 128, 128], + green: [0, 128, 0], + greenyellow: [173, 255, 47], + grey: [128, 128, 128], + honeydew: [240, 255, 240], + hotpink: [255, 105, 180], + indianred: [205, 92, 92], + indigo: [75, 0, 130], + ivory: [255, 255, 240], + khaki: [240, 230, 140], + lavender: [230, 230, 250], + lavenderblush: [255, 240, 245], + lawngreen: [124, 252, 0], + lemonchiffon: [255, 250, 205], + lightblue: [173, 216, 230], + lightcoral: [240, 128, 128], + lightcyan: [224, 255, 255], + lightgoldenrodyellow: [250, 250, 210], + lightgray: [211, 211, 211], + lightgreen: [144, 238, 144], + lightgrey: [211, 211, 211], + lightpink: [255, 182, 193], + lightsalmon: [255, 160, 122], + lightseagreen: [32, 178, 170], + lightskyblue: [135, 206, 250], + lightslategray: [119, 136, 153], + lightslategrey: [119, 136, 153], + lightsteelblue: [176, 196, 222], + lightyellow: [255, 255, 224], + lime: [0, 255, 0], + limegreen: [50, 205, 50], + linen: [250, 240, 230], + magenta: [255, 0, 255], + maroon: [128, 0, 0], + mediumaquamarine: [102, 205, 170], + mediumblue: [0, 0, 205], + mediumorchid: [186, 85, 211], + mediumpurple: [147, 112, 219], + mediumseagreen: [60, 179, 113], + mediumslateblue: [123, 104, 238], + mediumspringgreen: [0, 250, 154], + mediumturquoise: [72, 209, 204], + mediumvioletred: [199, 21, 133], + midnightblue: [25, 25, 112], + mintcream: [245, 255, 250], + mistyrose: [255, 228, 225], + moccasin: [255, 228, 181], + navajowhite: [255, 222, 173], + navy: [0, 0, 128], + oldlace: [253, 245, 230], + olive: [128, 128, 0], + olivedrab: [107, 142, 35], + orange: [255, 165, 0], + orangered: [255, 69, 0], + orchid: [218, 112, 214], + palegoldenrod: [238, 232, 170], + palegreen: [152, 251, 152], + paleturquoise: [175, 238, 238], + palevioletred: [219, 112, 147], + papayawhip: [255, 239, 213], + peachpuff: [255, 218, 185], + peru: [205, 133, 63], + pink: [255, 192, 203], + plum: [221, 160, 221], + powderblue: [176, 224, 230], + purple: [128, 0, 128], + rebeccapurple: [102, 51, 153], + red: [255, 0, 0], + rosybrown: [188, 143, 143], + royalblue: [65, 105, 225], + saddlebrown: [139, 69, 19], + salmon: [250, 128, 114], + sandybrown: [244, 164, 96], + seagreen: [46, 139, 87], + seashell: [255, 245, 238], + sienna: [160, 82, 45], + silver: [192, 192, 192], + skyblue: [135, 206, 235], + slateblue: [106, 90, 205], + slategray: [112, 128, 144], + slategrey: [112, 128, 144], + snow: [255, 250, 250], + springgreen: [0, 255, 127], + steelblue: [70, 130, 180], + tan: [210, 180, 140], + teal: [0, 128, 128], + thistle: [216, 191, 216], + tomato: [255, 99, 71], + turquoise: [64, 224, 208], + violet: [238, 130, 238], + wheat: [245, 222, 179], + white: [255, 255, 255], + whitesmoke: [245, 245, 245], + yellow: [255, 255, 0], + yellowgreen: [154, 205, 50] +} +// #endregion + + +export const parseCSSColor = (str, debug=false) => { + if (typeof str !== 'string') { + console.error(`parseCSSColor: expected a string found ${typeof str}`,str); + return null; + } + + const hex = hex_pattern.exec(str); + if (hex) { + if (debug){ + console.debug('parseCSSColor: hex', hex); + } + return getHEX(hex[0]); + } + + const hsl = hsl4_pattern.exec(str) || hsl3_pattern.exec(str); + if (hsl) { + if (debug){ + console.debug('parseCSSColor: hsl', hsl); + } + return getHSL(hsl); + } + + const rgb = + rgb4_pattern.exec(str) || + rgb3_pattern.exec(str) + if (rgb) { + if (debug){ + console.debug('parseCSSColor: rgb', rgb); + } + return getRGB(rgb); + } + + if (transparent_pattern.exec(str)) { + if (debug){ + console.debug('parseCSSColor: transparent'); + } + return getRGB([null, 0, 0, 0, 0]); + } + + const cn = colorName[str.toLowerCase()]; + if (cn) { + if (debug){ + console.debug('parseCSSColor: colorName', cn); + } + return getRGB([null, cn[0], cn[1], cn[2], 1]); + } + + console.error('parseCSSColor: unknown color', str); + return null; +}; + +export default parseCSSColor; + From a2e17f4a9f1b77e89ee91201b7cbca4cdb855f57 Mon Sep 17 00:00:00 2001 From: Xumin Yu <1090414006@qq.com> Date: Fri, 20 Sep 2024 20:14:54 +0800 Subject: [PATCH 3/3] Dev update libraries (#19) Co-authored-by: wl-zhao --- .github/workflows/package-and-upload.yaml | 167 ++++++++++++++++++++++ 1 file changed, 167 insertions(+) create mode 100644 .github/workflows/package-and-upload.yaml diff --git a/.github/workflows/package-and-upload.yaml b/.github/workflows/package-and-upload.yaml new file mode 100644 index 00000000..062e322f --- /dev/null +++ b/.github/workflows/package-and-upload.yaml @@ -0,0 +1,167 @@ + +name: "Release To HF" + +on: + workflow_dispatch: + inputs: + git_tag: + description: 'Git Branch Tag' + required: true + type: string + default: "main" + cu: + description: 'CUDA Version' + required: true + type: string + default: "124" + python_minor: + description: 'Python Minor Version' + required: true + type: string + default: "10" + python_patch: + description: 'Python Patch Version' + required: true + type: string + default: "10" + version: + description: 'Release Version Tag' + required: true + type: string + default: "beta" + +jobs: + build: + runs-on: ubuntu-latest + + steps: + - uses: actions/checkout@v4 + ref: ${{ inputs.git_tag }} + + - uses: pnpm/action-setup@v2 + with: + version: 9 + run_install: false + + - uses: actions/setup-node@v4 + with: + node-version: "20" + cache: "pnpm" + cache-dependency-path: "web/pnpm-lock.yaml" + + - working-directory: "./web" + run: pnpm install + + - working-directory: "./web" + run: pnpm turbo run build --filter=web + + - uses: actions/upload-artifact@v3 + with: + name: web-build + path: web/apps/web/dist + + package_shellagent_windows: + permissions: + contents: "write" + packages: "write" + pull-requests: "read" + needs: build + runs-on: windows-latest + steps: + - uses: actions/checkout@v4 + with: + ref: ${{ inputs.git_tag }} + fetch-depth: 0 + persist-credentials: false + submodules: recursive + - uses: actions/setup-python@v5 + with: + python-version: 3.${{ inputs.python_minor }}.${{ inputs.python_patch }} + + - name: Download web-build artifact + uses: actions/download-artifact@v3 + with: + name: web-build + path: ./servers/web-build + + - shell: bash + run: | + cd .. + cp -r ShellAgent ShellAgent_copy + + curl -L https://huggingface.co/XuminYu/git_embed/resolve/main/git.7z?download=true -o git.7z + "C:\Program Files\7-Zip\7z.exe" x git.7z -ogit + + curl https://www.python.org/ftp/python/3.${{ inputs.python_minor }}.${{ inputs.python_patch }}/python-3.${{ inputs.python_minor }}.${{ inputs.python_patch }}-embed-amd64.zip -o python_embeded.zip + unzip python_embeded.zip -d python_embeded + + cd python_embeded + + echo 'import site' >> ./python3${{ inputs.python_minor }}._pth + curl https://bootstrap.pypa.io/get-pip.py -o get-pip.py + ./python.exe get-pip.py + cp -r ../ShellAgent/.ci/python_dependencies_wins/include ./include + cp -r ../ShellAgent/.ci/python_dependencies_wins/Library ./Library + cp -r ../ShellAgent/.ci/python_dependencies_wins/libs ./libs + ./python.exe -s -m pip install torch torchvision torchaudio --index-url https://download.pytorch.org/whl/cu${{ inputs.cu }} + ./python.exe -s -m pip install --use-pep517 pygit2 Cython scikit_build_core enscons pytoml cmake==3.21 + ./python.exe -s -m pip install --use-pep517 -r ../ShellAgent/requirements.txt + ./python.exe -s -m pip install onnx==1.16.1 flask PyExecJS docx2txt fuzzywuzzy git cloudpickle + sed -i '1i../ShellAgent' ./python3${{ inputs.python_minor }}._pth + + cd .. + + mkdir ShellAgent_windows_portable + mv python_embeded ShellAgent_windows_portable + mv git ShellAgent_windows_portable + mv ShellAgent_copy ShellAgent_windows_portable/ShellAgent + + cd ShellAgent_windows_portable + cp -r ShellAgent/.ci/windows_base_files/* ./ + + cd ShellAgent + + mkdir -p models/insightface/models + ls models/insightface/ + curl -L https://huggingface.co/MonsterMMORPG/tools/resolve/main/antelopev2.zip -o models/insightface/models/antelopev2.zip + ls models/insightface/models/ + unzip models/insightface/models/antelopev2.zip -d models/insightface/models/ + + mkdir -p models/vae_approx + ls models + git clone --depth 1 https://github.com/comfyanonymous/taesd + cp taesd/*.pth models/vae_approx + + ../python_embeded/python.exe -m pip install -e . + ../python_embeded/python.exe -m pip show proconfig + # ../python_embeded/python.exe servers/main.py + + cd .. + cd .. + + "C:\Program Files\7-Zip\7z.exe" a -t7z -m0=lzma2 -mx=8 -mfb=64 -md=32m -ms=on -mf=BCJ2 ShellAgent_windows_portable.7z ShellAgent_windows_portable/* + mv ShellAgent_windows_portable.7z ShellAgent/ShellAgent_windows_portable.7z + + ls + + - name: Install Hugging Face Hub SDK + run: pip install huggingface_hub + + - name: Upload binaries to Hugging Face + run: | + from huggingface_hub import HfApi + api = HfApi() + + # Set repository and file paths + repo_id = "myshell-ai/ShellAgent" + file_path = "ShellAgent_windows_portable.7z" + + # Upload the file to Hugging Face repository + api.upload_file( + path_or_fileobj=file_path, + path_in_repo="ShellAgent_${{ inputs.version }}.7z", + repo_id=repo_id, + repo_type="model", # or 'dataset' depending on your use case + token="${{ secrets.HF_TOKEN }}" + ) + shell: python