add hg and python

cinap_lenrek committed 15 years ago

Commit 4bb9e221 parent 987265c3706 files · +1228772 −-233Browse files

Showing the changes to sys/src/cmd/python/Include (80 of 3706 files). Show all

Unified · Split

80 files

sys/src/cmd/python/Include/Python-ast.h +501 −0
sys/src/cmd/python/Include/Python.h +173 −0
sys/src/cmd/python/Include/abstract.h +1276 −0
sys/src/cmd/python/Include/asdl.h +45 −0
sys/src/cmd/python/Include/ast.h +13 −0
sys/src/cmd/python/Include/bitset.h +32 −0
sys/src/cmd/python/Include/boolobject.h +36 −0
sys/src/cmd/python/Include/bufferobject.h +33 −0
sys/src/cmd/python/Include/cStringIO.h +70 −0
sys/src/cmd/python/Include/cellobject.h +28 −0
sys/src/cmd/python/Include/ceval.h +157 −0
sys/src/cmd/python/Include/classobject.h +81 −0
sys/src/cmd/python/Include/cobject.h +54 −0
sys/src/cmd/python/Include/code.h +94 −0
sys/src/cmd/python/Include/codecs.h +167 −0
sys/src/cmd/python/Include/compile.h +39 −0
sys/src/cmd/python/Include/complexobject.h +58 −0
sys/src/cmd/python/Include/datetime.h +245 −0
sys/src/cmd/python/Include/descrobject.h +91 −0
sys/src/cmd/python/Include/dictobject.h +141 −0
sys/src/cmd/python/Include/enumobject.h +17 −0
sys/src/cmd/python/Include/errcode.h +36 −0
sys/src/cmd/python/Include/eval.h +25 −0
sys/src/cmd/python/Include/fileobject.h +63 −0
sys/src/cmd/python/Include/floatobject.h +100 −0
sys/src/cmd/python/Include/frameobject.h +81 −0
sys/src/cmd/python/Include/funcobject.h +76 −0
sys/src/cmd/python/Include/genobject.h +37 −0
sys/src/cmd/python/Include/graminit.h +84 −0
sys/src/cmd/python/Include/grammar.h +93 −0
sys/src/cmd/python/Include/import.h +64 −0
sys/src/cmd/python/Include/intobject.h +64 −0
sys/src/cmd/python/Include/intrcheck.h +15 −0
sys/src/cmd/python/Include/iterobject.h +23 −0
sys/src/cmd/python/Include/listobject.h +67 −0
sys/src/cmd/python/Include/longintrepr.h +63 −0
sys/src/cmd/python/Include/longobject.h +114 −0
sys/src/cmd/python/Include/marshal.h +25 −0
sys/src/cmd/python/Include/metagrammar.h +18 −0
sys/src/cmd/python/Include/methodobject.h +91 −0
sys/src/cmd/python/Include/modsupport.h +133 −0
sys/src/cmd/python/Include/moduleobject.h +24 −0
sys/src/cmd/python/Include/node.h +40 −0
sys/src/cmd/python/Include/object.h +868 −0
sys/src/cmd/python/Include/objimpl.h +336 −0
sys/src/cmd/python/Include/opcode.h +152 −0
sys/src/cmd/python/Include/osdefs.h +55 −0
sys/src/cmd/python/Include/parsetok.h +50 −0
sys/src/cmd/python/Include/patchlevel.h +40 −0
sys/src/cmd/python/Include/pgen.h +18 −0
sys/src/cmd/python/Include/pgenheaders.h +42 −0
sys/src/cmd/python/Include/py_curses.h +176 −0
sys/src/cmd/python/Include/pyarena.h +62 −0
sys/src/cmd/python/Include/pydebug.h +34 −0
sys/src/cmd/python/Include/pyerrors.h +334 −0
sys/src/cmd/python/Include/pyexpat.h +47 −0
sys/src/cmd/python/Include/pyfpe.h +176 −0
sys/src/cmd/python/Include/pygetopt.h +17 −0
sys/src/cmd/python/Include/pymactoolbox.h +189 −0
sys/src/cmd/python/Include/pymem.h +105 −0
sys/src/cmd/python/Include/pyport.h +771 −0
sys/src/cmd/python/Include/pystate.h +195 −0
sys/src/cmd/python/Include/pystrtod.h +18 −0
sys/src/cmd/python/Include/pythonrun.h +171 −0
sys/src/cmd/python/Include/pythread.h +47 −0
sys/src/cmd/python/Include/rangeobject.h +28 −0
sys/src/cmd/python/Include/setobject.h +93 −0
sys/src/cmd/python/Include/sliceobject.h +43 −0
sys/src/cmd/python/Include/stringobject.h +183 −0
sys/src/cmd/python/Include/structmember.h +93 −0
sys/src/cmd/python/Include/structseq.h +41 −0
sys/src/cmd/python/Include/symtable.h +103 −0
sys/src/cmd/python/Include/sysmodule.h +30 −0
sys/src/cmd/python/Include/timefuncs.h +23 −0
sys/src/cmd/python/Include/token.h +83 −0
sys/src/cmd/python/Include/traceback.h +30 −0
sys/src/cmd/python/Include/tupleobject.h +57 −0
sys/src/cmd/python/Include/ucnhash.h +31 −0
sys/src/cmd/python/Include/unicodeobject.h +1265 −0
sys/src/cmd/python/Include/weakrefobject.h +75 −0

sys/src/cmd/python/Include/Python-ast.h+501−0

@@ -0,0 +1,501 @@
	1	/* File automatically generated by Parser/asdl_c.py */
	2
	3	#include "asdl.h"
	4
	5	typedef struct _mod *mod_ty;
	6
	7	typedef struct _stmt *stmt_ty;
	8
	9	typedef struct _expr *expr_ty;
	10
	11	typedef enum _expr_context { Load=1, Store=2, Del=3, AugLoad=4, AugStore=5,
	12	Param=6 } expr_context_ty;
	13
	14	typedef struct _slice *slice_ty;
	15
	16	typedef enum _boolop { And=1, Or=2 } boolop_ty;
	17
	18	typedef enum _operator { Add=1, Sub=2, Mult=3, Div=4, Mod=5, Pow=6, LShift=7,
	19	RShift=8, BitOr=9, BitXor=10, BitAnd=11, FloorDiv=12 }
	20	operator_ty;
	21
	22	typedef enum _unaryop { Invert=1, Not=2, UAdd=3, USub=4 } unaryop_ty;
	23
	24	typedef enum _cmpop { Eq=1, NotEq=2, Lt=3, LtE=4, Gt=5, GtE=6, Is=7, IsNot=8,
	25	In=9, NotIn=10 } cmpop_ty;
	26
	27	typedef struct _comprehension *comprehension_ty;
	28
	29	typedef struct _excepthandler *excepthandler_ty;
	30
	31	typedef struct _arguments *arguments_ty;
	32
	33	typedef struct _keyword *keyword_ty;
	34
	35	typedef struct _alias *alias_ty;
	36
	37
	38	enum _mod_kind {Module_kind=1, Interactive_kind=2, Expression_kind=3,
	39	Suite_kind=4};
	40	struct _mod {
	41	enum _mod_kind kind;
	42	union {
	43	struct {
	44	asdl_seq *body;
	45	} Module;
	46
	47	struct {
	48	asdl_seq *body;
	49	} Interactive;
	50
	51	struct {
	52	expr_ty body;
	53	} Expression;
	54
	55	struct {
	56	asdl_seq *body;
	57	} Suite;
	58
	59	} v;
	60	};
	61
	62	enum _stmt_kind {FunctionDef_kind=1, ClassDef_kind=2, Return_kind=3,
	63	Delete_kind=4, Assign_kind=5, AugAssign_kind=6, Print_kind=7,
	64	For_kind=8, While_kind=9, If_kind=10, With_kind=11,
	65	Raise_kind=12, TryExcept_kind=13, TryFinally_kind=14,
	66	Assert_kind=15, Import_kind=16, ImportFrom_kind=17,
	67	Exec_kind=18, Global_kind=19, Expr_kind=20, Pass_kind=21,
	68	Break_kind=22, Continue_kind=23};
	69	struct _stmt {
	70	enum _stmt_kind kind;
	71	union {
	72	struct {
	73	identifier name;
	74	arguments_ty args;
	75	asdl_seq *body;
	76	asdl_seq *decorators;
	77	} FunctionDef;
	78
	79	struct {
	80	identifier name;
	81	asdl_seq *bases;
	82	asdl_seq *body;
	83	} ClassDef;
	84
	85	struct {
	86	expr_ty value;
	87	} Return;
	88
	89	struct {
	90	asdl_seq *targets;
	91	} Delete;
	92
	93	struct {
	94	asdl_seq *targets;
	95	expr_ty value;
	96	} Assign;
	97
	98	struct {
	99	expr_ty target;
	100	operator_ty op;
	101	expr_ty value;
	102	} AugAssign;
	103
	104	struct {
	105	expr_ty dest;
	106	asdl_seq *values;
	107	bool nl;
	108	} Print;
	109
	110	struct {
	111	expr_ty target;
	112	expr_ty iter;
	113	asdl_seq *body;
	114	asdl_seq *orelse;
	115	} For;
	116
	117	struct {
	118	expr_ty test;
	119	asdl_seq *body;
	120	asdl_seq *orelse;
	121	} While;
	122
	123	struct {
	124	expr_ty test;
	125	asdl_seq *body;
	126	asdl_seq *orelse;
	127	} If;
	128
	129	struct {
	130	expr_ty context_expr;
	131	expr_ty optional_vars;
	132	asdl_seq *body;
	133	} With;
	134
	135	struct {
	136	expr_ty type;
	137	expr_ty inst;
	138	expr_ty tback;
	139	} Raise;
	140
	141	struct {
	142	asdl_seq *body;
	143	asdl_seq *handlers;
	144	asdl_seq *orelse;
	145	} TryExcept;
	146
	147	struct {
	148	asdl_seq *body;
	149	asdl_seq *finalbody;
	150	} TryFinally;
	151
	152	struct {
	153	expr_ty test;
	154	expr_ty msg;
	155	} Assert;
	156
	157	struct {
	158	asdl_seq *names;
	159	} Import;
	160
	161	struct {
	162	identifier module;
	163	asdl_seq *names;
	164	int level;
	165	} ImportFrom;
	166
	167	struct {
	168	expr_ty body;
	169	expr_ty globals;
	170	expr_ty locals;
	171	} Exec;
	172
	173	struct {
	174	asdl_seq *names;
	175	} Global;
	176
	177	struct {
	178	expr_ty value;
	179	} Expr;
	180
	181	} v;
	182	int lineno;
	183	int col_offset;
	184	};
	185
	186	enum _expr_kind {BoolOp_kind=1, BinOp_kind=2, UnaryOp_kind=3, Lambda_kind=4,
	187	IfExp_kind=5, Dict_kind=6, ListComp_kind=7,
	188	GeneratorExp_kind=8, Yield_kind=9, Compare_kind=10,
	189	Call_kind=11, Repr_kind=12, Num_kind=13, Str_kind=14,
	190	Attribute_kind=15, Subscript_kind=16, Name_kind=17,
	191	List_kind=18, Tuple_kind=19};
	192	struct _expr {
	193	enum _expr_kind kind;
	194	union {
	195	struct {
	196	boolop_ty op;
	197	asdl_seq *values;
	198	} BoolOp;
	199
	200	struct {
	201	expr_ty left;
	202	operator_ty op;
	203	expr_ty right;
	204	} BinOp;
	205
	206	struct {
	207	unaryop_ty op;
	208	expr_ty operand;
	209	} UnaryOp;
	210
	211	struct {
	212	arguments_ty args;
	213	expr_ty body;
	214	} Lambda;
	215
	216	struct {
	217	expr_ty test;
	218	expr_ty body;
	219	expr_ty orelse;
	220	} IfExp;
	221
	222	struct {
	223	asdl_seq *keys;
	224	asdl_seq *values;
	225	} Dict;
	226
	227	struct {
	228	expr_ty elt;
	229	asdl_seq *generators;
	230	} ListComp;
	231
	232	struct {
	233	expr_ty elt;
	234	asdl_seq *generators;
	235	} GeneratorExp;
	236
	237	struct {
	238	expr_ty value;
	239	} Yield;
	240
	241	struct {
	242	expr_ty left;
	243	asdl_int_seq *ops;
	244	asdl_seq *comparators;
	245	} Compare;
	246
	247	struct {
	248	expr_ty func;
	249	asdl_seq *args;
	250	asdl_seq *keywords;
	251	expr_ty starargs;
	252	expr_ty kwargs;
	253	} Call;
	254
	255	struct {
	256	expr_ty value;
	257	} Repr;
	258
	259	struct {
	260	object n;
	261	} Num;
	262
	263	struct {
	264	string s;
	265	} Str;
	266
	267	struct {
	268	expr_ty value;
	269	identifier attr;
	270	expr_context_ty ctx;
	271	} Attribute;
	272
	273	struct {
	274	expr_ty value;
	275	slice_ty slice;
	276	expr_context_ty ctx;
	277	} Subscript;
	278
	279	struct {
	280	identifier id;
	281	expr_context_ty ctx;
	282	} Name;
	283
	284	struct {
	285	asdl_seq *elts;
	286	expr_context_ty ctx;
	287	} List;
	288
	289	struct {
	290	asdl_seq *elts;
	291	expr_context_ty ctx;
	292	} Tuple;
	293
	294	} v;
	295	int lineno;
	296	int col_offset;
	297	};
	298
	299	enum _slice_kind {Ellipsis_kind=1, Slice_kind=2, ExtSlice_kind=3, Index_kind=4};
	300	struct _slice {
	301	enum _slice_kind kind;
	302	union {
	303	struct {
	304	expr_ty lower;
	305	expr_ty upper;
	306	expr_ty step;
	307	} Slice;
	308
	309	struct {
	310	asdl_seq *dims;
	311	} ExtSlice;
	312
	313	struct {
	314	expr_ty value;
	315	} Index;
	316
	317	} v;
	318	};
	319
	320	struct _comprehension {
	321	expr_ty target;
	322	expr_ty iter;
	323	asdl_seq *ifs;
	324	};
	325
	326	struct _excepthandler {
	327	expr_ty type;
	328	expr_ty name;
	329	asdl_seq *body;
	330	int lineno;
	331	int col_offset;
	332	};
	333
	334	struct _arguments {
	335	asdl_seq *args;
	336	identifier vararg;
	337	identifier kwarg;
	338	asdl_seq *defaults;
	339	};
	340
	341	struct _keyword {
	342	identifier arg;
	343	expr_ty value;
	344	};
	345
	346	struct _alias {
	347	identifier name;
	348	identifier asname;
	349	};
	350
	351
	352	#define Module(a0, a1) _Py_Module(a0, a1)
	353	mod_ty _Py_Module(asdl_seq * body, PyArena *arena);
	354	#define Interactive(a0, a1) _Py_Interactive(a0, a1)
	355	mod_ty _Py_Interactive(asdl_seq * body, PyArena *arena);
	356	#define Expression(a0, a1) _Py_Expression(a0, a1)
	357	mod_ty _Py_Expression(expr_ty body, PyArena *arena);
	358	#define Suite(a0, a1) _Py_Suite(a0, a1)
	359	mod_ty _Py_Suite(asdl_seq * body, PyArena *arena);
	360	#define FunctionDef(a0, a1, a2, a3, a4, a5, a6) _Py_FunctionDef(a0, a1, a2, a3, a4, a5, a6)
	361	stmt_ty _Py_FunctionDef(identifier name, arguments_ty args, asdl_seq * body,
	362	asdl_seq * decorators, int lineno, int col_offset,
	363	PyArena *arena);
	364	#define ClassDef(a0, a1, a2, a3, a4, a5) _Py_ClassDef(a0, a1, a2, a3, a4, a5)
	365	stmt_ty _Py_ClassDef(identifier name, asdl_seq * bases, asdl_seq * body, int
	366	lineno, int col_offset, PyArena *arena);
	367	#define Return(a0, a1, a2, a3) _Py_Return(a0, a1, a2, a3)
	368	stmt_ty _Py_Return(expr_ty value, int lineno, int col_offset, PyArena *arena);
	369	#define Delete(a0, a1, a2, a3) _Py_Delete(a0, a1, a2, a3)
	370	stmt_ty _Py_Delete(asdl_seq * targets, int lineno, int col_offset, PyArena
	371	*arena);
	372	#define Assign(a0, a1, a2, a3, a4) _Py_Assign(a0, a1, a2, a3, a4)
	373	stmt_ty _Py_Assign(asdl_seq * targets, expr_ty value, int lineno, int
	374	col_offset, PyArena *arena);
	375	#define AugAssign(a0, a1, a2, a3, a4, a5) _Py_AugAssign(a0, a1, a2, a3, a4, a5)
	376	stmt_ty _Py_AugAssign(expr_ty target, operator_ty op, expr_ty value, int
	377	lineno, int col_offset, PyArena *arena);
	378	#define Print(a0, a1, a2, a3, a4, a5) _Py_Print(a0, a1, a2, a3, a4, a5)
	379	stmt_ty _Py_Print(expr_ty dest, asdl_seq * values, bool nl, int lineno, int
	380	col_offset, PyArena *arena);
	381	#define For(a0, a1, a2, a3, a4, a5, a6) _Py_For(a0, a1, a2, a3, a4, a5, a6)
	382	stmt_ty _Py_For(expr_ty target, expr_ty iter, asdl_seq * body, asdl_seq *
	383	orelse, int lineno, int col_offset, PyArena *arena);
	384	#define While(a0, a1, a2, a3, a4, a5) _Py_While(a0, a1, a2, a3, a4, a5)
	385	stmt_ty _Py_While(expr_ty test, asdl_seq * body, asdl_seq * orelse, int lineno,
	386	int col_offset, PyArena *arena);
	387	#define If(a0, a1, a2, a3, a4, a5) _Py_If(a0, a1, a2, a3, a4, a5)
	388	stmt_ty _Py_If(expr_ty test, asdl_seq * body, asdl_seq * orelse, int lineno,
	389	int col_offset, PyArena *arena);
	390	#define With(a0, a1, a2, a3, a4, a5) _Py_With(a0, a1, a2, a3, a4, a5)
	391	stmt_ty _Py_With(expr_ty context_expr, expr_ty optional_vars, asdl_seq * body,
	392	int lineno, int col_offset, PyArena *arena);
	393	#define Raise(a0, a1, a2, a3, a4, a5) _Py_Raise(a0, a1, a2, a3, a4, a5)
	394	stmt_ty _Py_Raise(expr_ty type, expr_ty inst, expr_ty tback, int lineno, int
	395	col_offset, PyArena *arena);
	396	#define TryExcept(a0, a1, a2, a3, a4, a5) _Py_TryExcept(a0, a1, a2, a3, a4, a5)
	397	stmt_ty _Py_TryExcept(asdl_seq * body, asdl_seq * handlers, asdl_seq * orelse,
	398	int lineno, int col_offset, PyArena *arena);
	399	#define TryFinally(a0, a1, a2, a3, a4) _Py_TryFinally(a0, a1, a2, a3, a4)
	400	stmt_ty _Py_TryFinally(asdl_seq * body, asdl_seq * finalbody, int lineno, int
	401	col_offset, PyArena *arena);
	402	#define Assert(a0, a1, a2, a3, a4) _Py_Assert(a0, a1, a2, a3, a4)
	403	stmt_ty _Py_Assert(expr_ty test, expr_ty msg, int lineno, int col_offset,
	404	PyArena *arena);
	405	#define Import(a0, a1, a2, a3) _Py_Import(a0, a1, a2, a3)
	406	stmt_ty _Py_Import(asdl_seq * names, int lineno, int col_offset, PyArena
	407	*arena);
	408	#define ImportFrom(a0, a1, a2, a3, a4, a5) _Py_ImportFrom(a0, a1, a2, a3, a4, a5)
	409	stmt_ty _Py_ImportFrom(identifier module, asdl_seq * names, int level, int
	410	lineno, int col_offset, PyArena *arena);
	411	#define Exec(a0, a1, a2, a3, a4, a5) _Py_Exec(a0, a1, a2, a3, a4, a5)
	412	stmt_ty _Py_Exec(expr_ty body, expr_ty globals, expr_ty locals, int lineno, int
	413	col_offset, PyArena *arena);
	414	#define Global(a0, a1, a2, a3) _Py_Global(a0, a1, a2, a3)
	415	stmt_ty _Py_Global(asdl_seq * names, int lineno, int col_offset, PyArena
	416	*arena);
	417	#define Expr(a0, a1, a2, a3) _Py_Expr(a0, a1, a2, a3)
	418	stmt_ty _Py_Expr(expr_ty value, int lineno, int col_offset, PyArena *arena);
	419	#define Pass(a0, a1, a2) _Py_Pass(a0, a1, a2)
	420	stmt_ty _Py_Pass(int lineno, int col_offset, PyArena *arena);
	421	#define Break(a0, a1, a2) _Py_Break(a0, a1, a2)
	422	stmt_ty _Py_Break(int lineno, int col_offset, PyArena *arena);
	423	#define Continue(a0, a1, a2) _Py_Continue(a0, a1, a2)
	424	stmt_ty _Py_Continue(int lineno, int col_offset, PyArena *arena);
	425	#define BoolOp(a0, a1, a2, a3, a4) _Py_BoolOp(a0, a1, a2, a3, a4)
	426	expr_ty _Py_BoolOp(boolop_ty op, asdl_seq * values, int lineno, int col_offset,
	427	PyArena *arena);
	428	#define BinOp(a0, a1, a2, a3, a4, a5) _Py_BinOp(a0, a1, a2, a3, a4, a5)
	429	expr_ty _Py_BinOp(expr_ty left, operator_ty op, expr_ty right, int lineno, int
	430	col_offset, PyArena *arena);
	431	#define UnaryOp(a0, a1, a2, a3, a4) _Py_UnaryOp(a0, a1, a2, a3, a4)
	432	expr_ty _Py_UnaryOp(unaryop_ty op, expr_ty operand, int lineno, int col_offset,
	433	PyArena *arena);
	434	#define Lambda(a0, a1, a2, a3, a4) _Py_Lambda(a0, a1, a2, a3, a4)
	435	expr_ty _Py_Lambda(arguments_ty args, expr_ty body, int lineno, int col_offset,
	436	PyArena *arena);
	437	#define IfExp(a0, a1, a2, a3, a4, a5) _Py_IfExp(a0, a1, a2, a3, a4, a5)
	438	expr_ty _Py_IfExp(expr_ty test, expr_ty body, expr_ty orelse, int lineno, int
	439	col_offset, PyArena *arena);
	440	#define Dict(a0, a1, a2, a3, a4) _Py_Dict(a0, a1, a2, a3, a4)
	441	expr_ty _Py_Dict(asdl_seq * keys, asdl_seq * values, int lineno, int
	442	col_offset, PyArena *arena);
	443	#define ListComp(a0, a1, a2, a3, a4) _Py_ListComp(a0, a1, a2, a3, a4)
	444	expr_ty _Py_ListComp(expr_ty elt, asdl_seq * generators, int lineno, int
	445	col_offset, PyArena *arena);
	446	#define GeneratorExp(a0, a1, a2, a3, a4) _Py_GeneratorExp(a0, a1, a2, a3, a4)
	447	expr_ty _Py_GeneratorExp(expr_ty elt, asdl_seq * generators, int lineno, int
	448	col_offset, PyArena *arena);
	449	#define Yield(a0, a1, a2, a3) _Py_Yield(a0, a1, a2, a3)
	450	expr_ty _Py_Yield(expr_ty value, int lineno, int col_offset, PyArena *arena);
	451	#define Compare(a0, a1, a2, a3, a4, a5) _Py_Compare(a0, a1, a2, a3, a4, a5)
	452	expr_ty _Py_Compare(expr_ty left, asdl_int_seq * ops, asdl_seq * comparators,
	453	int lineno, int col_offset, PyArena *arena);
	454	#define Call(a0, a1, a2, a3, a4, a5, a6, a7) _Py_Call(a0, a1, a2, a3, a4, a5, a6, a7)
	455	expr_ty _Py_Call(expr_ty func, asdl_seq * args, asdl_seq * keywords, expr_ty
	456	starargs, expr_ty kwargs, int lineno, int col_offset, PyArena
	457	*arena);
	458	#define Repr(a0, a1, a2, a3) _Py_Repr(a0, a1, a2, a3)
	459	expr_ty _Py_Repr(expr_ty value, int lineno, int col_offset, PyArena *arena);
	460	#define Num(a0, a1, a2, a3) _Py_Num(a0, a1, a2, a3)
	461	expr_ty _Py_Num(object n, int lineno, int col_offset, PyArena *arena);
	462	#define Str(a0, a1, a2, a3) _Py_Str(a0, a1, a2, a3)
	463	expr_ty _Py_Str(string s, int lineno, int col_offset, PyArena *arena);
	464	#define Attribute(a0, a1, a2, a3, a4, a5) _Py_Attribute(a0, a1, a2, a3, a4, a5)
	465	expr_ty _Py_Attribute(expr_ty value, identifier attr, expr_context_ty ctx, int
	466	lineno, int col_offset, PyArena *arena);
	467	#define Subscript(a0, a1, a2, a3, a4, a5) _Py_Subscript(a0, a1, a2, a3, a4, a5)
	468	expr_ty _Py_Subscript(expr_ty value, slice_ty slice, expr_context_ty ctx, int
	469	lineno, int col_offset, PyArena *arena);
	470	#define Name(a0, a1, a2, a3, a4) _Py_Name(a0, a1, a2, a3, a4)
	471	expr_ty _Py_Name(identifier id, expr_context_ty ctx, int lineno, int
	472	col_offset, PyArena *arena);
	473	#define List(a0, a1, a2, a3, a4) _Py_List(a0, a1, a2, a3, a4)
	474	expr_ty _Py_List(asdl_seq * elts, expr_context_ty ctx, int lineno, int
	475	col_offset, PyArena *arena);
	476	#define Tuple(a0, a1, a2, a3, a4) _Py_Tuple(a0, a1, a2, a3, a4)
	477	expr_ty _Py_Tuple(asdl_seq * elts, expr_context_ty ctx, int lineno, int
	478	col_offset, PyArena *arena);
	479	#define Ellipsis(a0) _Py_Ellipsis(a0)
	480	slice_ty _Py_Ellipsis(PyArena *arena);
	481	#define Slice(a0, a1, a2, a3) _Py_Slice(a0, a1, a2, a3)
	482	slice_ty _Py_Slice(expr_ty lower, expr_ty upper, expr_ty step, PyArena *arena);
	483	#define ExtSlice(a0, a1) _Py_ExtSlice(a0, a1)
	484	slice_ty _Py_ExtSlice(asdl_seq * dims, PyArena *arena);
	485	#define Index(a0, a1) _Py_Index(a0, a1)
	486	slice_ty _Py_Index(expr_ty value, PyArena *arena);
	487	#define comprehension(a0, a1, a2, a3) _Py_comprehension(a0, a1, a2, a3)
	488	comprehension_ty _Py_comprehension(expr_ty target, expr_ty iter, asdl_seq *
	489	ifs, PyArena *arena);
	490	#define excepthandler(a0, a1, a2, a3, a4, a5) _Py_excepthandler(a0, a1, a2, a3, a4, a5)
	491	excepthandler_ty _Py_excepthandler(expr_ty type, expr_ty name, asdl_seq * body,
	492	int lineno, int col_offset, PyArena *arena);
	493	#define arguments(a0, a1, a2, a3, a4) _Py_arguments(a0, a1, a2, a3, a4)
	494	arguments_ty _Py_arguments(asdl_seq * args, identifier vararg, identifier
	495	kwarg, asdl_seq * defaults, PyArena *arena);
	496	#define keyword(a0, a1, a2) _Py_keyword(a0, a1, a2)
	497	keyword_ty _Py_keyword(identifier arg, expr_ty value, PyArena *arena);
	498	#define alias(a0, a1, a2) _Py_alias(a0, a1, a2)
	499	alias_ty _Py_alias(identifier name, identifier asname, PyArena *arena);
	500
	501	PyObject* PyAST_mod2obj(mod_ty t);

sys/src/cmd/python/Include/Python.h+173−0

@@ -0,0 +1,173 @@
	1	#ifndef Py_PYTHON_H
	2	#define Py_PYTHON_H
	3	/* Since this is a "meta-include" file, no #ifdef __cplusplus / extern "C" { */
	4
	5	/* Include nearly all Python header files */
	6
	7	#include "patchlevel.h"
	8	#include "pyconfig.h"
	9
	10	/* Cyclic gc is always enabled, starting with release 2.3a1. Supply the
	11	* old symbol for the benefit of extension modules written before then
	12	* that may be conditionalizing on it. The core doesn't use it anymore.
	13	*/
	14	#ifndef WITH_CYCLE_GC
	15	#define WITH_CYCLE_GC 1
	16	#endif
	17
	18	#include <limits.h>
	19
	20	#ifndef UCHAR_MAX
	21	#error "Something's broken. UCHAR_MAX should be defined in limits.h."
	22	#endif
	23
	24	#if UCHAR_MAX != 255
	25	#error "Python's source code assumes C's unsigned char is an 8-bit type."
	26	#endif
	27
	28	#if defined(__sgi) && defined(WITH_THREAD) && !defined(_SGI_MP_SOURCE)
	29	#define _SGI_MP_SOURCE
	30	#endif
	31
	32	#include <stdio.h>
	33	#ifndef NULL
	34	# error "Python.h requires that stdio.h define NULL."
	35	#endif
	36
	37	#include <string.h>
	38	#ifdef HAVE_ERRNO_H
	39	#include <errno.h>
	40	#endif
	41	#include <stdlib.h>
	42	#ifdef HAVE_UNISTD_H
	43	#include <unistd.h>
	44	#endif
	45
	46	/* For uintptr_t, intptr_t */
	47	#ifdef HAVE_STDDEF_H
	48	#include <stddef.h>
	49	#endif
	50
	51	/* CAUTION: Build setups should ensure that NDEBUG is defined on the
	52	* compiler command line when building Python in release mode; else
	53	* assert() calls won't be removed.
	54	*/
	55	#include <assert.h>
	56
	57	#include "pyport.h"
	58
	59	/* pyconfig.h or pyport.h may or may not define DL_IMPORT */
	60	#ifndef DL_IMPORT /* declarations for DLL import/export */
	61	#define DL_IMPORT(RTYPE) RTYPE
	62	#endif
	63	#ifndef DL_EXPORT /* declarations for DLL import/export */
	64	#define DL_EXPORT(RTYPE) RTYPE
	65	#endif
	66
	67	/* Debug-mode build with pymalloc implies PYMALLOC_DEBUG.
	68	* PYMALLOC_DEBUG is in error if pymalloc is not in use.
	69	*/
	70	#if defined(Py_DEBUG) && defined(WITH_PYMALLOC) && !defined(PYMALLOC_DEBUG)
	71	#define PYMALLOC_DEBUG
	72	#endif
	73	#if defined(PYMALLOC_DEBUG) && !defined(WITH_PYMALLOC)
	74	#error "PYMALLOC_DEBUG requires WITH_PYMALLOC"
	75	#endif
	76	#include "pymem.h"
	77
	78	#include "object.h"
	79	#include "objimpl.h"
	80
	81	#include "pydebug.h"
	82
	83	#include "unicodeobject.h"
	84	#include "intobject.h"
	85	#include "boolobject.h"
	86	#include "longobject.h"
	87	#include "floatobject.h"
	88	#ifndef WITHOUT_COMPLEX
	89	#include "complexobject.h"
	90	#endif
	91	#include "rangeobject.h"
	92	#include "stringobject.h"
	93	#include "bufferobject.h"
	94	#include "tupleobject.h"
	95	#include "listobject.h"
	96	#include "dictobject.h"
	97	#include "enumobject.h"
	98	#include "setobject.h"
	99	#include "methodobject.h"
	100	#include "moduleobject.h"
	101	#include "funcobject.h"
	102	#include "classobject.h"
	103	#include "fileobject.h"
	104	#include "cobject.h"
	105	#include "traceback.h"
	106	#include "sliceobject.h"
	107	#include "cellobject.h"
	108	#include "iterobject.h"
	109	#include "genobject.h"
	110	#include "descrobject.h"
	111	#include "weakrefobject.h"
	112
	113	#include "codecs.h"
	114	#include "pyerrors.h"
	115
	116	#include "pystate.h"
	117
	118	#include "pyarena.h"
	119	#include "modsupport.h"
	120	#include "pythonrun.h"
	121	#include "ceval.h"
	122	#include "sysmodule.h"
	123	#include "intrcheck.h"
	124	#include "import.h"
	125
	126	#include "abstract.h"
	127
	128	#include "compile.h"
	129	#include "eval.h"
	130
	131	#include "pystrtod.h"
	132
	133	/* _Py_Mangle is defined in compile.c */
	134	PyAPI_FUNC(PyObject) _Py_Mangle(PyObject p, PyObject *name);
	135
	136	/* PyArg_GetInt is deprecated and should not be used, use PyArg_Parse(). */
	137	#define PyArg_GetInt(v, a) PyArg_Parse((v), "i", (a))
	138
	139	/* PyArg_NoArgs should not be necessary.
	140	Set ml_flags in the PyMethodDef to METH_NOARGS. */
	141	#define PyArg_NoArgs(v) PyArg_Parse(v, "")
	142
	143	/* Convert a possibly signed character to a nonnegative int */
	144	/* XXX This assumes characters are 8 bits wide */
	145	#ifdef __CHAR_UNSIGNED__
	146	#define Py_CHARMASK(c) (c)
	147	#else
	148	#define Py_CHARMASK(c) ((c) & 0xff)
	149	#endif
	150
	151	#include "pyfpe.h"
	152
	153	/* These definitions must match corresponding definitions in graminit.h.
	154	There's code in compile.c that checks that they are the same. */
	155	#define Py_single_input 256
	156	#define Py_file_input 257
	157	#define Py_eval_input 258
	158
	159	#ifdef HAVE_PTH
	160	/* GNU pth user-space thread support */
	161	#include <pth.h>
	162	#endif
	163
	164	/* Define macros for inline documentation. */
	165	#define PyDoc_VAR(name) static char name[]
	166	#define PyDoc_STRVAR(name,str) PyDoc_VAR(name) = PyDoc_STR(str)
	167	#ifdef WITH_DOC_STRINGS
	168	#define PyDoc_STR(str) str
	169	#else
	170	#define PyDoc_STR(str) ""
	171	#endif
	172
	173	#endif /* !Py_PYTHON_H */

sys/src/cmd/python/Include/abstract.h+1276−0

@@ -0,0 +1,1276 @@
	1	#ifndef Py_ABSTRACTOBJECT_H
	2	#define Py_ABSTRACTOBJECT_H
	3	#ifdef __cplusplus
	4	extern "C" {
	5	#endif
	6
	7	#ifdef PY_SSIZE_T_CLEAN
	8	#define PyObject_CallFunction _PyObject_CallFunction_SizeT
	9	#define PyObject_CallMethod _PyObject_CallMethod_SizeT
	10	#endif
	11
	12	/* Abstract Object Interface (many thanks to Jim Fulton) */
	13
	14	/*
	15	PROPOSAL: A Generic Python Object Interface for Python C Modules
	16
	17	Problem
	18
	19	Python modules written in C that must access Python objects must do
	20	so through routines whose interfaces are described by a set of
	21	include files. Unfortunately, these routines vary according to the
	22	object accessed. To use these routines, the C programmer must check
	23	the type of the object being used and must call a routine based on
	24	the object type. For example, to access an element of a sequence,
	25	the programmer must determine whether the sequence is a list or a
	26	tuple:
	27
	28	if(is_tupleobject(o))
	29	e=gettupleitem(o,i)
	30	else if(is_listitem(o))
	31	e=getlistitem(o,i)
	32
	33	If the programmer wants to get an item from another type of object
	34	that provides sequence behavior, there is no clear way to do it
	35	correctly.
	36
	37	The persistent programmer may peruse object.h and find that the
	38	_typeobject structure provides a means of invoking up to (currently
	39	about) 41 special operators. So, for example, a routine can get an
	40	item from any object that provides sequence behavior. However, to
	41	use this mechanism, the programmer must make their code dependent on
	42	the current Python implementation.
	43
	44	Also, certain semantics, especially memory management semantics, may
	45	differ by the type of object being used. Unfortunately, these
	46	semantics are not clearly described in the current include files.
	47	An abstract interface providing more consistent semantics is needed.
	48
	49	Proposal
	50
	51	I propose the creation of a standard interface (with an associated
	52	library of routines and/or macros) for generically obtaining the
	53	services of Python objects. This proposal can be viewed as one
	54	components of a Python C interface consisting of several components.
	55
	56	From the viewpoint of C access to Python services, we have (as
	57	suggested by Guido in off-line discussions):
	58
	59	- "Very high level layer": two or three functions that let you exec or
	60	eval arbitrary Python code given as a string in a module whose name is
	61	given, passing C values in and getting C values out using
	62	mkvalue/getargs style format strings. This does not require the user
	63	to declare any variables of type "PyObject *". This should be enough
	64	to write a simple application that gets Python code from the user,
	65	execs it, and returns the output or errors. (Error handling must also
	66	be part of this API.)
	67
	68	- "Abstract objects layer": which is the subject of this proposal.
	69	It has many functions operating on objects, and lest you do many
	70	things from C that you can also write in Python, without going
	71	through the Python parser.
	72
	73	- "Concrete objects layer": This is the public type-dependent
	74	interface provided by the standard built-in types, such as floats,
	75	strings, and lists. This interface exists and is currently
	76	documented by the collection of include files provided with the
	77	Python distributions.
	78
	79	From the point of view of Python accessing services provided by C
	80	modules:
	81
	82	- "Python module interface": this interface consist of the basic
	83	routines used to define modules and their members. Most of the
	84	current extensions-writing guide deals with this interface.
	85
	86	- "Built-in object interface": this is the interface that a new
	87	built-in type must provide and the mechanisms and rules that a
	88	developer of a new built-in type must use and follow.
	89
	90	This proposal is a "first-cut" that is intended to spur
	91	discussion. See especially the lists of notes.
	92
	93	The Python C object interface will provide four protocols: object,
	94	numeric, sequence, and mapping. Each protocol consists of a
	95	collection of related operations. If an operation that is not
	96	provided by a particular type is invoked, then a standard exception,
	97	NotImplementedError is raised with a operation name as an argument.
	98	In addition, for convenience this interface defines a set of
	99	constructors for building objects of built-in types. This is needed
	100	so new objects can be returned from C functions that otherwise treat
	101	objects generically.
	102
	103	Memory Management
	104
	105	For all of the functions described in this proposal, if a function
	106	retains a reference to a Python object passed as an argument, then the
	107	function will increase the reference count of the object. It is
	108	unnecessary for the caller to increase the reference count of an
	109	argument in anticipation of the object's retention.
	110
	111	All Python objects returned from functions should be treated as new
	112	objects. Functions that return objects assume that the caller will
	113	retain a reference and the reference count of the object has already
	114	been incremented to account for this fact. A caller that does not
	115	retain a reference to an object that is returned from a function
	116	must decrement the reference count of the object (using
	117	DECREF(object)) to prevent memory leaks.
	118
	119	Note that the behavior mentioned here is different from the current
	120	behavior for some objects (e.g. lists and tuples) when certain
	121	type-specific routines are called directly (e.g. setlistitem). The
	122	proposed abstraction layer will provide a consistent memory
	123	management interface, correcting for inconsistent behavior for some
	124	built-in types.
	125
	126	Protocols
	127
	128	xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx*/
	129
	130	/* Object Protocol: */
	131
	132	/* Implemented elsewhere:
	133
	134	int PyObject_Print(PyObject o, FILE fp, int flags);
	135
	136	Print an object, o, on file, fp. Returns -1 on
	137	error. The flags argument is used to enable certain printing
	138	options. The only option currently supported is Py_Print_RAW.
	139
	140	(What should be said about Py_Print_RAW?)
	141
	142	*/
	143
	144	/* Implemented elsewhere:
	145
	146	int PyObject_HasAttrString(PyObject o, char attr_name);
	147
	148	Returns 1 if o has the attribute attr_name, and 0 otherwise.
	149	This is equivalent to the Python expression:
	150	hasattr(o,attr_name).
	151
	152	This function always succeeds.
	153
	154	*/
	155
	156	/* Implemented elsewhere:
	157
	158	PyObject* PyObject_GetAttrString(PyObject o, char attr_name);
	159
	160	Retrieve an attributed named attr_name form object o.
	161	Returns the attribute value on success, or NULL on failure.
	162	This is the equivalent of the Python expression: o.attr_name.
	163
	164	*/
	165
	166	/* Implemented elsewhere:
	167
	168	int PyObject_HasAttr(PyObject o, PyObject attr_name);
	169
	170	Returns 1 if o has the attribute attr_name, and 0 otherwise.
	171	This is equivalent to the Python expression:
	172	hasattr(o,attr_name).
	173
	174	This function always succeeds.
	175
	176	*/
	177
	178	/* Implemented elsewhere:
	179
	180	PyObject* PyObject_GetAttr(PyObject o, PyObject attr_name);
	181
	182	Retrieve an attributed named attr_name form object o.
	183	Returns the attribute value on success, or NULL on failure.
	184	This is the equivalent of the Python expression: o.attr_name.
	185
	186	*/
	187
	188
	189	/* Implemented elsewhere:
	190
	191	int PyObject_SetAttrString(PyObject o, char attr_name, PyObject *v);
	192
	193	Set the value of the attribute named attr_name, for object o,
	194	to the value, v. Returns -1 on failure. This is
	195	the equivalent of the Python statement: o.attr_name=v.
	196
	197	*/
	198
	199	/* Implemented elsewhere:
	200
	201	int PyObject_SetAttr(PyObject o, PyObject attr_name, PyObject *v);
	202
	203	Set the value of the attribute named attr_name, for object o,
	204	to the value, v. Returns -1 on failure. This is
	205	the equivalent of the Python statement: o.attr_name=v.
	206
	207	*/
	208
	209	/* implemented as a macro:
	210
	211	int PyObject_DelAttrString(PyObject o, char attr_name);
	212
	213	Delete attribute named attr_name, for object o. Returns
	214	-1 on failure. This is the equivalent of the Python
	215	statement: del o.attr_name.
	216
	217	*/
	218	#define PyObject_DelAttrString(O,A) PyObject_SetAttrString((O),(A),NULL)
	219
	220	/* implemented as a macro:
	221
	222	int PyObject_DelAttr(PyObject o, PyObject attr_name);
	223
	224	Delete attribute named attr_name, for object o. Returns -1
	225	on failure. This is the equivalent of the Python
	226	statement: del o.attr_name.
	227
	228	*/
	229	#define PyObject_DelAttr(O,A) PyObject_SetAttr((O),(A),NULL)
	230
	231	PyAPI_FUNC(int) PyObject_Cmp(PyObject o1, PyObject o2, int *result);
	232
	233	/*
	234	Compare the values of o1 and o2 using a routine provided by
	235	o1, if one exists, otherwise with a routine provided by o2.
	236	The result of the comparison is returned in result. Returns
	237	-1 on failure. This is the equivalent of the Python
	238	statement: result=cmp(o1,o2).
	239
	240	*/
	241
	242	/* Implemented elsewhere:
	243
	244	int PyObject_Compare(PyObject o1, PyObject o2);
	245
	246	Compare the values of o1 and o2 using a routine provided by
	247	o1, if one exists, otherwise with a routine provided by o2.
	248	Returns the result of the comparison on success. On error,
	249	the value returned is undefined. This is equivalent to the
	250	Python expression: cmp(o1,o2).
	251
	252	*/
	253
	254	/* Implemented elsewhere:
	255
	256	PyObject PyObject_Repr(PyObject o);
	257
	258	Compute the string representation of object, o. Returns the
	259	string representation on success, NULL on failure. This is
	260	the equivalent of the Python expression: repr(o).
	261
	262	Called by the repr() built-in function and by reverse quotes.
	263
	264	*/
	265
	266	/* Implemented elsewhere:
	267
	268	PyObject PyObject_Str(PyObject o);
	269
	270	Compute the string representation of object, o. Returns the
	271	string representation on success, NULL on failure. This is
	272	the equivalent of the Python expression: str(o).)
	273
	274	Called by the str() built-in function and by the print
	275	statement.
	276
	277	*/
	278
	279	/* Implemented elsewhere:
	280
	281	PyObject PyObject_Unicode(PyObject o);
	282
	283	Compute the unicode representation of object, o. Returns the
	284	unicode representation on success, NULL on failure. This is
	285	the equivalent of the Python expression: unistr(o).)
	286
	287	Called by the unistr() built-in function.
	288
	289	*/
	290
	291	/* Declared elsewhere
	292
	293	PyAPI_FUNC(int) PyCallable_Check(PyObject *o);
	294
	295	Determine if the object, o, is callable. Return 1 if the
	296	object is callable and 0 otherwise.
	297
	298	This function always succeeds.
	299
	300	*/
	301
	302
	303
	304	PyAPI_FUNC(PyObject ) PyObject_Call(PyObject callable_object,
	305	PyObject args, PyObject kw);
	306
	307	/*
	308	Call a callable Python object, callable_object, with
	309	arguments and keywords arguments. The 'args' argument can not be
	310	NULL, but the 'kw' argument can be NULL.
	311
	312	*/
	313
	314	PyAPI_FUNC(PyObject ) PyObject_CallObject(PyObject callable_object,
	315	PyObject *args);
	316
	317	/*
	318	Call a callable Python object, callable_object, with
	319	arguments given by the tuple, args. If no arguments are
	320	needed, then args may be NULL. Returns the result of the
	321	call on success, or NULL on failure. This is the equivalent
	322	of the Python expression: apply(o,args).
	323
	324	*/
	325
	326	PyAPI_FUNC(PyObject ) PyObject_CallFunction(PyObject callable_object,
	327	char *format, ...);
	328
	329	/*
	330	Call a callable Python object, callable_object, with a
	331	variable number of C arguments. The C arguments are described
	332	using a mkvalue-style format string. The format may be NULL,
	333	indicating that no arguments are provided. Returns the
	334	result of the call on success, or NULL on failure. This is
	335	the equivalent of the Python expression: apply(o,args).
	336
	337	*/
	338
	339
	340	PyAPI_FUNC(PyObject ) PyObject_CallMethod(PyObject o, char *m,
	341	char *format, ...);
	342
	343	/*
	344	Call the method named m of object o with a variable number of
	345	C arguments. The C arguments are described by a mkvalue
	346	format string. The format may be NULL, indicating that no
	347	arguments are provided. Returns the result of the call on
	348	success, or NULL on failure. This is the equivalent of the
	349	Python expression: o.method(args).
	350	*/
	351
	352	PyAPI_FUNC(PyObject ) _PyObject_CallFunction_SizeT(PyObject callable,
	353	char *format, ...);
	354	PyAPI_FUNC(PyObject ) _PyObject_CallMethod_SizeT(PyObject o,
	355	char *name,
	356	char *format, ...);
	357
	358	PyAPI_FUNC(PyObject ) PyObject_CallFunctionObjArgs(PyObject callable,
	359	...);
	360
	361	/*
	362	Call a callable Python object, callable_object, with a
	363	variable number of C arguments. The C arguments are provided
	364	as PyObject * values, terminated by a NULL. Returns the
	365	result of the call on success, or NULL on failure. This is
	366	the equivalent of the Python expression: apply(o,args).
	367	*/
	368
	369
	370	PyAPI_FUNC(PyObject ) PyObject_CallMethodObjArgs(PyObject o,
	371	PyObject *m, ...);
	372
	373	/*
	374	Call the method named m of object o with a variable number of
	375	C arguments. The C arguments are provided as PyObject *
	376	values, terminated by NULL. Returns the result of the call
	377	on success, or NULL on failure. This is the equivalent of
	378	the Python expression: o.method(args).
	379	*/
	380
	381
	382	/* Implemented elsewhere:
	383
	384	long PyObject_Hash(PyObject *o);
	385
	386	Compute and return the hash, hash_value, of an object, o. On
	387	failure, return -1. This is the equivalent of the Python
	388	expression: hash(o).
	389
	390	*/
	391
	392
	393	/* Implemented elsewhere:
	394
	395	int PyObject_IsTrue(PyObject *o);
	396
	397	Returns 1 if the object, o, is considered to be true, 0 if o is
	398	considered to be false and -1 on failure. This is equivalent to the
	399	Python expression: not not o
	400
	401	*/
	402
	403	/* Implemented elsewhere:
	404
	405	int PyObject_Not(PyObject *o);
	406
	407	Returns 0 if the object, o, is considered to be true, 1 if o is
	408	considered to be false and -1 on failure. This is equivalent to the
	409	Python expression: not o
	410
	411	*/
	412
	413	PyAPI_FUNC(PyObject ) PyObject_Type(PyObject o);
	414
	415	/*
	416	On success, returns a type object corresponding to the object
	417	type of object o. On failure, returns NULL. This is
	418	equivalent to the Python expression: type(o).
	419	*/
	420
	421	PyAPI_FUNC(Py_ssize_t) PyObject_Size(PyObject *o);
	422
	423	/*
	424	Return the size of object o. If the object, o, provides
	425	both sequence and mapping protocols, the sequence size is
	426	returned. On error, -1 is returned. This is the equivalent
	427	to the Python expression: len(o).
	428
	429	*/
	430
	431	/* For DLL compatibility */
	432	#undef PyObject_Length
	433	PyAPI_FUNC(Py_ssize_t) PyObject_Length(PyObject *o);
	434	#define PyObject_Length PyObject_Size
	435
	436	PyAPI_FUNC(Py_ssize_t) _PyObject_LengthHint(PyObject *o);
	437
	438	/*
	439	Return the size of object o. If the object, o, provides
	440	both sequence and mapping protocols, the sequence size is
	441	returned. On error, -1 is returned. If the object provides
	442	a __length_hint__() method, its value is returned. This is an
	443	internal undocumented API provided for performance reasons;
	444	for compatibility, don't use it outside the core. This is the
	445	equivalent to the Python expression:
	446	try:
	447	return len(o)
	448	except (AttributeError, TypeError):
	449	exc_type, exc_value, exc_tb = sys.exc_info()
	450	try:
	451	return o.__length_hint__()
	452	except:
	453	pass
	454	raise exc_type, exc_value, exc_tb
	455	*/
	456
	457	PyAPI_FUNC(PyObject ) PyObject_GetItem(PyObject o, PyObject *key);
	458
	459	/*
	460	Return element of o corresponding to the object, key, or NULL
	461	on failure. This is the equivalent of the Python expression:
	462	o[key].
	463
	464	*/
	465
	466	PyAPI_FUNC(int) PyObject_SetItem(PyObject o, PyObject key, PyObject *v);
	467
	468	/*
	469	Map the object, key, to the value, v. Returns
	470	-1 on failure. This is the equivalent of the Python
	471	statement: o[key]=v.
	472	*/
	473
	474	PyAPI_FUNC(int) PyObject_DelItemString(PyObject o, char key);
	475
	476	/*
	477	Remove the mapping for object, key, from the object *o.
	478	Returns -1 on failure. This is equivalent to
	479	the Python statement: del o[key].
	480	*/
	481
	482	PyAPI_FUNC(int) PyObject_DelItem(PyObject o, PyObject key);
	483
	484	/*
	485	Delete the mapping for key from *o. Returns -1 on failure.
	486	This is the equivalent of the Python statement: del o[key].
	487	*/
	488
	489	PyAPI_FUNC(int) PyObject_AsCharBuffer(PyObject *obj,
	490	const char **buffer,
	491	Py_ssize_t *buffer_len);
	492
	493	/*
	494	Takes an arbitrary object which must support the (character,
	495	single segment) buffer interface and returns a pointer to a
	496	read-only memory location useable as character based input
	497	for subsequent processing.
	498
	499	0 is returned on success. buffer and buffer_len are only
	500	set in case no error occurs. Otherwise, -1 is returned and
	501	an exception set.
	502
	503	*/
	504
	505	PyAPI_FUNC(int) PyObject_CheckReadBuffer(PyObject *obj);
	506
	507	/*
	508	Checks whether an arbitrary object supports the (character,
	509	single segment) buffer interface. Returns 1 on success, 0
	510	on failure.
	511
	512	*/
	513
	514	PyAPI_FUNC(int) PyObject_AsReadBuffer(PyObject *obj,
	515	const void **buffer,
	516	Py_ssize_t *buffer_len);
	517
	518	/*
	519	Same as PyObject_AsCharBuffer() except that this API expects
	520	(readable, single segment) buffer interface and returns a
	521	pointer to a read-only memory location which can contain
	522	arbitrary data.
	523
	524	0 is returned on success. buffer and buffer_len are only
	525	set in case no error occurrs. Otherwise, -1 is returned and
	526	an exception set.
	527
	528	*/
	529
	530	PyAPI_FUNC(int) PyObject_AsWriteBuffer(PyObject *obj,
	531	void **buffer,
	532	Py_ssize_t *buffer_len);
	533
	534	/*
	535	Takes an arbitrary object which must support the (writeable,
	536	single segment) buffer interface and returns a pointer to a
	537	writeable memory location in buffer of size buffer_len.
	538
	539	0 is returned on success. buffer and buffer_len are only
	540	set in case no error occurrs. Otherwise, -1 is returned and
	541	an exception set.
	542
	543	*/
	544
	545	/* Iterators */
	546
	547	PyAPI_FUNC(PyObject ) PyObject_GetIter(PyObject );
	548	/* Takes an object and returns an iterator for it.
	549	This is typically a new iterator but if the argument
	550	is an iterator, this returns itself. */
	551
	552	#define PyIter_Check(obj) \
	553	(PyType_HasFeature((obj)->ob_type, Py_TPFLAGS_HAVE_ITER) && \
	554	(obj)->ob_type->tp_iternext != NULL)
	555
	556	PyAPI_FUNC(PyObject ) PyIter_Next(PyObject );
	557	/* Takes an iterator object and calls its tp_iternext slot,
	558	returning the next value. If the iterator is exhausted,
	559	this returns NULL without setting an exception.
	560	NULL with an exception means an error occurred. */
	561
	562	/* Number Protocol:*/
	563
	564	PyAPI_FUNC(int) PyNumber_Check(PyObject *o);
	565
	566	/*
	567	Returns 1 if the object, o, provides numeric protocols, and
	568	false otherwise.
	569
	570	This function always succeeds.
	571
	572	*/
	573
	574	PyAPI_FUNC(PyObject ) PyNumber_Add(PyObject o1, PyObject *o2);
	575
	576	/*
	577	Returns the result of adding o1 and o2, or null on failure.
	578	This is the equivalent of the Python expression: o1+o2.
	579
	580
	581	*/
	582
	583	PyAPI_FUNC(PyObject ) PyNumber_Subtract(PyObject o1, PyObject *o2);
	584
	585	/*
	586	Returns the result of subtracting o2 from o1, or null on
	587	failure. This is the equivalent of the Python expression:
	588	o1-o2.
	589
	590	*/
	591
	592	PyAPI_FUNC(PyObject ) PyNumber_Multiply(PyObject o1, PyObject *o2);
	593
	594	/*
	595	Returns the result of multiplying o1 and o2, or null on
	596	failure. This is the equivalent of the Python expression:
	597	o1*o2.
	598
	599
	600	*/
	601
	602	PyAPI_FUNC(PyObject ) PyNumber_Divide(PyObject o1, PyObject *o2);
	603
	604	/*
	605	Returns the result of dividing o1 by o2, or null on failure.
	606	This is the equivalent of the Python expression: o1/o2.
	607
	608
	609	*/
	610
	611	PyAPI_FUNC(PyObject ) PyNumber_FloorDivide(PyObject o1, PyObject *o2);
	612
	613	/*
	614	Returns the result of dividing o1 by o2 giving an integral result,
	615	or null on failure.
	616	This is the equivalent of the Python expression: o1//o2.
	617
	618
	619	*/
	620
	621	PyAPI_FUNC(PyObject ) PyNumber_TrueDivide(PyObject o1, PyObject *o2);
	622
	623	/*
	624	Returns the result of dividing o1 by o2 giving a float result,
	625	or null on failure.
	626	This is the equivalent of the Python expression: o1/o2.
	627
	628
	629	*/
	630
	631	PyAPI_FUNC(PyObject ) PyNumber_Remainder(PyObject o1, PyObject *o2);
	632
	633	/*
	634	Returns the remainder of dividing o1 by o2, or null on
	635	failure. This is the equivalent of the Python expression:
	636	o1%o2.
	637
	638
	639	*/
	640
	641	PyAPI_FUNC(PyObject ) PyNumber_Divmod(PyObject o1, PyObject *o2);
	642
	643	/*
	644	See the built-in function divmod. Returns NULL on failure.
	645	This is the equivalent of the Python expression:
	646	divmod(o1,o2).
	647
	648
	649	*/
	650
	651	PyAPI_FUNC(PyObject ) PyNumber_Power(PyObject o1, PyObject *o2,
	652	PyObject *o3);
	653
	654	/*
	655	See the built-in function pow. Returns NULL on failure.
	656	This is the equivalent of the Python expression:
	657	pow(o1,o2,o3), where o3 is optional.
	658
	659	*/
	660
	661	PyAPI_FUNC(PyObject ) PyNumber_Negative(PyObject o);
	662
	663	/*
	664	Returns the negation of o on success, or null on failure.
	665	This is the equivalent of the Python expression: -o.
	666
	667	*/
	668
	669	PyAPI_FUNC(PyObject ) PyNumber_Positive(PyObject o);
	670
	671	/*
	672	Returns the (what?) of o on success, or NULL on failure.
	673	This is the equivalent of the Python expression: +o.
	674
	675	*/
	676
	677	PyAPI_FUNC(PyObject ) PyNumber_Absolute(PyObject o);
	678
	679	/*
	680	Returns the absolute value of o, or null on failure. This is
	681	the equivalent of the Python expression: abs(o).
	682
	683	*/
	684
	685	PyAPI_FUNC(PyObject ) PyNumber_Invert(PyObject o);
	686
	687	/*
	688	Returns the bitwise negation of o on success, or NULL on
	689	failure. This is the equivalent of the Python expression:
	690	~o.
	691
	692
	693	*/
	694
	695	PyAPI_FUNC(PyObject ) PyNumber_Lshift(PyObject o1, PyObject *o2);
	696
	697	/*
	698	Returns the result of left shifting o1 by o2 on success, or
	699	NULL on failure. This is the equivalent of the Python
	700	expression: o1 << o2.
	701
	702
	703	*/
	704
	705	PyAPI_FUNC(PyObject ) PyNumber_Rshift(PyObject o1, PyObject *o2);
	706
	707	/*
	708	Returns the result of right shifting o1 by o2 on success, or
	709	NULL on failure. This is the equivalent of the Python
	710	expression: o1 >> o2.
	711
	712	*/
	713
	714	PyAPI_FUNC(PyObject ) PyNumber_And(PyObject o1, PyObject *o2);
	715
	716	/*
	717	Returns the result of bitwise and of o1 and o2 on success, or
	718	NULL on failure. This is the equivalent of the Python
	719	expression: o1&o2.
	720
	721
	722	*/
	723
	724	PyAPI_FUNC(PyObject ) PyNumber_Xor(PyObject o1, PyObject *o2);
	725
	726	/*
	727	Returns the bitwise exclusive or of o1 by o2 on success, or
	728	NULL on failure. This is the equivalent of the Python
	729	expression: o1^o2.
	730
	731
	732	*/
	733
	734	PyAPI_FUNC(PyObject ) PyNumber_Or(PyObject o1, PyObject *o2);
	735
	736	/*
	737	Returns the result of bitwise or on o1 and o2 on success, or
	738	NULL on failure. This is the equivalent of the Python
	739	expression: o1\|o2.
	740
	741	*/
	742
	743	/* Implemented elsewhere:
	744
	745	int PyNumber_Coerce(PyObject p1, PyObject p2);
	746
	747	This function takes the addresses of two variables of type
	748	PyObject*.
	749
	750	If the objects pointed to by p1 and p2 have the same type,
	751	increment their reference count and return 0 (success).
	752	If the objects can be converted to a common numeric type,
	753	replace p1 and p2 by their converted value (with 'new'
	754	reference counts), and return 0.
	755	If no conversion is possible, or if some other error occurs,
	756	return -1 (failure) and don't increment the reference counts.
	757	The call PyNumber_Coerce(&o1, &o2) is equivalent to the Python
	758	statement o1, o2 = coerce(o1, o2).
	759
	760	*/
	761
	762	#define PyIndex_Check(obj) \
	763	((obj)->ob_type->tp_as_number != NULL && \
	764	PyType_HasFeature((obj)->ob_type, Py_TPFLAGS_HAVE_INDEX) && \
	765	(obj)->ob_type->tp_as_number->nb_index != NULL)
	766
	767	PyAPI_FUNC(PyObject ) PyNumber_Index(PyObject o);
	768
	769	/*
	770	Returns the object converted to a Python long or int
	771	or NULL with an error raised on failure.
	772	*/
	773
	774	PyAPI_FUNC(Py_ssize_t) PyNumber_AsSsize_t(PyObject o, PyObject exc);
	775
	776	/*
	777	Returns the object converted to Py_ssize_t by going through
	778	PyNumber_Index first. If an overflow error occurs while
	779	converting the int-or-long to Py_ssize_t, then the second argument
	780	is the error-type to return. If it is NULL, then the overflow error
	781	is cleared and the value is clipped.
	782	*/
	783
	784	PyAPI_FUNC(PyObject ) PyNumber_Int(PyObject o);
	785
	786	/*
	787	Returns the o converted to an integer object on success, or
	788	NULL on failure. This is the equivalent of the Python
	789	expression: int(o).
	790
	791	*/
	792
	793	PyAPI_FUNC(PyObject ) PyNumber_Long(PyObject o);
	794
	795	/*
	796	Returns the o converted to a long integer object on success,
	797	or NULL on failure. This is the equivalent of the Python
	798	expression: long(o).
	799
	800	*/
	801
	802	PyAPI_FUNC(PyObject ) PyNumber_Float(PyObject o);
	803
	804	/*
	805	Returns the o converted to a float object on success, or NULL
	806	on failure. This is the equivalent of the Python expression:
	807	float(o).
	808	*/
	809
	810	/* In-place variants of (some of) the above number protocol functions */
	811
	812	PyAPI_FUNC(PyObject ) PyNumber_InPlaceAdd(PyObject o1, PyObject *o2);
	813
	814	/*
	815	Returns the result of adding o2 to o1, possibly in-place, or null
	816	on failure. This is the equivalent of the Python expression:
	817	o1 += o2.
	818
	819	*/
	820
	821	PyAPI_FUNC(PyObject ) PyNumber_InPlaceSubtract(PyObject o1, PyObject *o2);
	822
	823	/*
	824	Returns the result of subtracting o2 from o1, possibly in-place or
	825	null on failure. This is the equivalent of the Python expression:
	826	o1 -= o2.
	827
	828	*/
	829
	830	PyAPI_FUNC(PyObject ) PyNumber_InPlaceMultiply(PyObject o1, PyObject *o2);
	831
	832	/*
	833	Returns the result of multiplying o1 by o2, possibly in-place, or
	834	null on failure. This is the equivalent of the Python expression:
	835	o1 *= o2.
	836
	837	*/
	838
	839	PyAPI_FUNC(PyObject ) PyNumber_InPlaceDivide(PyObject o1, PyObject *o2);
	840
	841	/*
	842	Returns the result of dividing o1 by o2, possibly in-place, or null
	843	on failure. This is the equivalent of the Python expression:
	844	o1 /= o2.
	845
	846	*/
	847
	848	PyAPI_FUNC(PyObject ) PyNumber_InPlaceFloorDivide(PyObject o1,
	849	PyObject *o2);
	850
	851	/*
	852	Returns the result of dividing o1 by o2 giving an integral result,
	853	possibly in-place, or null on failure.
	854	This is the equivalent of the Python expression:
	855	o1 /= o2.
	856
	857	*/
	858
	859	PyAPI_FUNC(PyObject ) PyNumber_InPlaceTrueDivide(PyObject o1,
	860	PyObject *o2);
	861
	862	/*
	863	Returns the result of dividing o1 by o2 giving a float result,
	864	possibly in-place, or null on failure.
	865	This is the equivalent of the Python expression:
	866	o1 /= o2.
	867
	868	*/
	869
	870	PyAPI_FUNC(PyObject ) PyNumber_InPlaceRemainder(PyObject o1, PyObject *o2);
	871
	872	/*
	873	Returns the remainder of dividing o1 by o2, possibly in-place, or
	874	null on failure. This is the equivalent of the Python expression:
	875	o1 %= o2.
	876
	877	*/
	878
	879	PyAPI_FUNC(PyObject ) PyNumber_InPlacePower(PyObject o1, PyObject *o2,
	880	PyObject *o3);
	881
	882	/*
	883	Returns the result of raising o1 to the power of o2, possibly
	884	in-place, or null on failure. This is the equivalent of the Python
	885	expression: o1 **= o2, or pow(o1, o2, o3) if o3 is present.
	886
	887	*/
	888
	889	PyAPI_FUNC(PyObject ) PyNumber_InPlaceLshift(PyObject o1, PyObject *o2);
	890
	891	/*
	892	Returns the result of left shifting o1 by o2, possibly in-place, or
	893	null on failure. This is the equivalent of the Python expression:
	894	o1 <<= o2.
	895
	896	*/
	897
	898	PyAPI_FUNC(PyObject ) PyNumber_InPlaceRshift(PyObject o1, PyObject *o2);
	899
	900	/*
	901	Returns the result of right shifting o1 by o2, possibly in-place or
	902	null on failure. This is the equivalent of the Python expression:
	903	o1 >>= o2.
	904
	905	*/
	906
	907	PyAPI_FUNC(PyObject ) PyNumber_InPlaceAnd(PyObject o1, PyObject *o2);
	908
	909	/*
	910	Returns the result of bitwise and of o1 and o2, possibly in-place,
	911	or null on failure. This is the equivalent of the Python
	912	expression: o1 &= o2.
	913
	914	*/
	915
	916	PyAPI_FUNC(PyObject ) PyNumber_InPlaceXor(PyObject o1, PyObject *o2);
	917
	918	/*
	919	Returns the bitwise exclusive or of o1 by o2, possibly in-place, or
	920	null on failure. This is the equivalent of the Python expression:
	921	o1 ^= o2.
	922
	923	*/
	924
	925	PyAPI_FUNC(PyObject ) PyNumber_InPlaceOr(PyObject o1, PyObject *o2);
	926
	927	/*
	928	Returns the result of bitwise or of o1 and o2, possibly in-place,
	929	or null on failure. This is the equivalent of the Python
	930	expression: o1 \|= o2.
	931
	932	*/
	933
	934
	935	/* Sequence protocol:*/
	936
	937	PyAPI_FUNC(int) PySequence_Check(PyObject *o);
	938
	939	/*
	940	Return 1 if the object provides sequence protocol, and zero
	941	otherwise.
	942
	943	This function always succeeds.
	944
	945	*/
	946
	947	PyAPI_FUNC(Py_ssize_t) PySequence_Size(PyObject *o);
	948
	949	/*
	950	Return the size of sequence object o, or -1 on failure.
	951
	952	*/
	953
	954	/* For DLL compatibility */
	955	#undef PySequence_Length
	956	PyAPI_FUNC(Py_ssize_t) PySequence_Length(PyObject *o);
	957	#define PySequence_Length PySequence_Size
	958
	959
	960	PyAPI_FUNC(PyObject ) PySequence_Concat(PyObject o1, PyObject *o2);
	961
	962	/*
	963	Return the concatenation of o1 and o2 on success, and NULL on
	964	failure. This is the equivalent of the Python
	965	expression: o1+o2.
	966
	967	*/
	968
	969	PyAPI_FUNC(PyObject ) PySequence_Repeat(PyObject o, Py_ssize_t count);
	970
	971	/*
	972	Return the result of repeating sequence object o count times,
	973	or NULL on failure. This is the equivalent of the Python
	974	expression: o1*count.
	975
	976	*/
	977
	978	PyAPI_FUNC(PyObject ) PySequence_GetItem(PyObject o, Py_ssize_t i);
	979
	980	/*
	981	Return the ith element of o, or NULL on failure. This is the
	982	equivalent of the Python expression: o[i].
	983	*/
	984
	985	PyAPI_FUNC(PyObject ) PySequence_GetSlice(PyObject o, Py_ssize_t i1, Py_ssize_t i2);
	986
	987	/*
	988	Return the slice of sequence object o between i1 and i2, or
	989	NULL on failure. This is the equivalent of the Python
	990	expression: o[i1:i2].
	991
	992	*/
	993
	994	PyAPI_FUNC(int) PySequence_SetItem(PyObject o, Py_ssize_t i, PyObject v);
	995
	996	/*
	997	Assign object v to the ith element of o. Returns
	998	-1 on failure. This is the equivalent of the Python
	999	statement: o[i]=v.
	1000
	1001	*/
	1002
	1003	PyAPI_FUNC(int) PySequence_DelItem(PyObject *o, Py_ssize_t i);
	1004
	1005	/*
	1006	Delete the ith element of object v. Returns
	1007	-1 on failure. This is the equivalent of the Python
	1008	statement: del o[i].
	1009	*/
	1010
	1011	PyAPI_FUNC(int) PySequence_SetSlice(PyObject *o, Py_ssize_t i1, Py_ssize_t i2,
	1012	PyObject *v);
	1013
	1014	/*
	1015	Assign the sequence object, v, to the slice in sequence
	1016	object, o, from i1 to i2. Returns -1 on failure. This is the
	1017	equivalent of the Python statement: o[i1:i2]=v.
	1018	*/
	1019
	1020	PyAPI_FUNC(int) PySequence_DelSlice(PyObject *o, Py_ssize_t i1, Py_ssize_t i2);
	1021
	1022	/*
	1023	Delete the slice in sequence object, o, from i1 to i2.
	1024	Returns -1 on failure. This is the equivalent of the Python
	1025	statement: del o[i1:i2].
	1026	*/
	1027
	1028	PyAPI_FUNC(PyObject ) PySequence_Tuple(PyObject o);
	1029
	1030	/*
	1031	Returns the sequence, o, as a tuple on success, and NULL on failure.
	1032	This is equivalent to the Python expression: tuple(o)
	1033	*/
	1034
	1035
	1036	PyAPI_FUNC(PyObject ) PySequence_List(PyObject o);
	1037	/*
	1038	Returns the sequence, o, as a list on success, and NULL on failure.
	1039	This is equivalent to the Python expression: list(o)
	1040	*/
	1041
	1042	PyAPI_FUNC(PyObject ) PySequence_Fast(PyObject o, const char* m);
	1043	/*
	1044	Returns the sequence, o, as a tuple, unless it's already a
	1045	tuple or list. Use PySequence_Fast_GET_ITEM to access the
	1046	members of this list, and PySequence_Fast_GET_SIZE to get its length.
	1047
	1048	Returns NULL on failure. If the object does not support iteration,
	1049	raises a TypeError exception with m as the message text.
	1050	*/
	1051
	1052	#define PySequence_Fast_GET_SIZE(o) \
	1053	(PyList_Check(o) ? PyList_GET_SIZE(o) : PyTuple_GET_SIZE(o))
	1054	/*
	1055	Return the size of o, assuming that o was returned by
	1056	PySequence_Fast and is not NULL.
	1057	*/
	1058
	1059	#define PySequence_Fast_GET_ITEM(o, i)\
	1060	(PyList_Check(o) ? PyList_GET_ITEM(o, i) : PyTuple_GET_ITEM(o, i))
	1061	/*
	1062	Return the ith element of o, assuming that o was returned by
	1063	PySequence_Fast, and that i is within bounds.
	1064	*/
	1065
	1066	#define PySequence_ITEM(o, i)\
	1067	( o->ob_type->tp_as_sequence->sq_item(o, i) )
	1068	/* Assume tp_as_sequence and sq_item exist and that i does not
	1069	need to be corrected for a negative index
	1070	*/
	1071
	1072	#define PySequence_Fast_ITEMS(sf) \
	1073	(PyList_Check(sf) ? ((PyListObject *)(sf))->ob_item \
	1074	: ((PyTupleObject *)(sf))->ob_item)
	1075	/* Return a pointer to the underlying item array for
	1076	an object retured by PySequence_Fast */
	1077
	1078	PyAPI_FUNC(Py_ssize_t) PySequence_Count(PyObject o, PyObject value);
	1079
	1080	/*
	1081	Return the number of occurrences on value on o, that is,
	1082	return the number of keys for which o[key]==value. On
	1083	failure, return -1. This is equivalent to the Python
	1084	expression: o.count(value).
	1085	*/
	1086
	1087	PyAPI_FUNC(int) PySequence_Contains(PyObject seq, PyObject ob);
	1088	/*
	1089	Return -1 if error; 1 if ob in seq; 0 if ob not in seq.
	1090	Use __contains__ if possible, else _PySequence_IterSearch().
	1091	*/
	1092
	1093	#define PY_ITERSEARCH_COUNT 1
	1094	#define PY_ITERSEARCH_INDEX 2
	1095	#define PY_ITERSEARCH_CONTAINS 3
	1096	PyAPI_FUNC(Py_ssize_t) _PySequence_IterSearch(PyObject *seq,
	1097	PyObject *obj, int operation);
	1098	/*
	1099	Iterate over seq. Result depends on the operation:
	1100	PY_ITERSEARCH_COUNT: return # of times obj appears in seq; -1 if
	1101	error.
	1102	PY_ITERSEARCH_INDEX: return 0-based index of first occurrence of
	1103	obj in seq; set ValueError and return -1 if none found;
	1104	also return -1 on error.
	1105	PY_ITERSEARCH_CONTAINS: return 1 if obj in seq, else 0; -1 on
	1106	error.
	1107	*/
	1108
	1109	/* For DLL-level backwards compatibility */
	1110	#undef PySequence_In
	1111	PyAPI_FUNC(int) PySequence_In(PyObject o, PyObject value);
	1112
	1113	/* For source-level backwards compatibility */
	1114	#define PySequence_In PySequence_Contains
	1115
	1116	/*
	1117	Determine if o contains value. If an item in o is equal to
	1118	X, return 1, otherwise return 0. On error, return -1. This
	1119	is equivalent to the Python expression: value in o.
	1120	*/
	1121
	1122	PyAPI_FUNC(Py_ssize_t) PySequence_Index(PyObject o, PyObject value);
	1123
	1124	/*
	1125	Return the first index for which o[i]=value. On error,
	1126	return -1. This is equivalent to the Python
	1127	expression: o.index(value).
	1128	*/
	1129
	1130	/* In-place versions of some of the above Sequence functions. */
	1131
	1132	PyAPI_FUNC(PyObject ) PySequence_InPlaceConcat(PyObject o1, PyObject *o2);
	1133
	1134	/*
	1135	Append o2 to o1, in-place when possible. Return the resulting
	1136	object, which could be o1, or NULL on failure. This is the
	1137	equivalent of the Python expression: o1 += o2.
	1138
	1139	*/
	1140
	1141	PyAPI_FUNC(PyObject ) PySequence_InPlaceRepeat(PyObject o, Py_ssize_t count);
	1142
	1143	/*
	1144	Repeat o1 by count, in-place when possible. Return the resulting
	1145	object, which could be o1, or NULL on failure. This is the
	1146	equivalent of the Python expression: o1 *= count.
	1147
	1148	*/
	1149
	1150	/* Mapping protocol:*/
	1151
	1152	PyAPI_FUNC(int) PyMapping_Check(PyObject *o);
	1153
	1154	/*
	1155	Return 1 if the object provides mapping protocol, and zero
	1156	otherwise.
	1157
	1158	This function always succeeds.
	1159	*/
	1160
	1161	PyAPI_FUNC(Py_ssize_t) PyMapping_Size(PyObject *o);
	1162
	1163	/*
	1164	Returns the number of keys in object o on success, and -1 on
	1165	failure. For objects that do not provide sequence protocol,
	1166	this is equivalent to the Python expression: len(o).
	1167	*/
	1168
	1169	/* For DLL compatibility */
	1170	#undef PyMapping_Length
	1171	PyAPI_FUNC(Py_ssize_t) PyMapping_Length(PyObject *o);
	1172	#define PyMapping_Length PyMapping_Size
	1173
	1174
	1175	/* implemented as a macro:
	1176
	1177	int PyMapping_DelItemString(PyObject o, char key);
	1178
	1179	Remove the mapping for object, key, from the object *o.
	1180	Returns -1 on failure. This is equivalent to
	1181	the Python statement: del o[key].
	1182	*/
	1183	#define PyMapping_DelItemString(O,K) PyObject_DelItemString((O),(K))
	1184
	1185	/* implemented as a macro:
	1186
	1187	int PyMapping_DelItem(PyObject o, PyObject key);
	1188
	1189	Remove the mapping for object, key, from the object *o.
	1190	Returns -1 on failure. This is equivalent to
	1191	the Python statement: del o[key].
	1192	*/
	1193	#define PyMapping_DelItem(O,K) PyObject_DelItem((O),(K))
	1194
	1195	PyAPI_FUNC(int) PyMapping_HasKeyString(PyObject o, char key);
	1196
	1197	/*
	1198	On success, return 1 if the mapping object has the key, key,
	1199	and 0 otherwise. This is equivalent to the Python expression:
	1200	o.has_key(key).
	1201
	1202	This function always succeeds.
	1203	*/
	1204
	1205	PyAPI_FUNC(int) PyMapping_HasKey(PyObject o, PyObject key);
	1206
	1207	/*
	1208	Return 1 if the mapping object has the key, key,
	1209	and 0 otherwise. This is equivalent to the Python expression:
	1210	o.has_key(key).
	1211
	1212	This function always succeeds.
	1213
	1214	*/
	1215
	1216	/* Implemented as macro:
	1217
	1218	PyObject PyMapping_Keys(PyObject o);
	1219
	1220	On success, return a list of the keys in object o. On
	1221	failure, return NULL. This is equivalent to the Python
	1222	expression: o.keys().
	1223	*/
	1224	#define PyMapping_Keys(O) PyObject_CallMethod(O,"keys",NULL)
	1225
	1226	/* Implemented as macro:
	1227
	1228	PyObject PyMapping_Values(PyObject o);
	1229
	1230	On success, return a list of the values in object o. On
	1231	failure, return NULL. This is equivalent to the Python
	1232	expression: o.values().
	1233	*/
	1234	#define PyMapping_Values(O) PyObject_CallMethod(O,"values",NULL)
	1235
	1236	/* Implemented as macro:
	1237
	1238	PyObject PyMapping_Items(PyObject o);
	1239
	1240	On success, return a list of the items in object o, where
	1241	each item is a tuple containing a key-value pair. On
	1242	failure, return NULL. This is equivalent to the Python
	1243	expression: o.items().
	1244
	1245	*/
	1246	#define PyMapping_Items(O) PyObject_CallMethod(O,"items",NULL)
	1247
	1248	PyAPI_FUNC(PyObject ) PyMapping_GetItemString(PyObject o, char *key);
	1249
	1250	/*
	1251	Return element of o corresponding to the object, key, or NULL
	1252	on failure. This is the equivalent of the Python expression:
	1253	o[key].
	1254	*/
	1255
	1256	PyAPI_FUNC(int) PyMapping_SetItemString(PyObject o, char key,
	1257	PyObject *value);
	1258
	1259	/*
	1260	Map the object, key, to the value, v. Returns
	1261	-1 on failure. This is the equivalent of the Python
	1262	statement: o[key]=v.
	1263	*/
	1264
	1265
	1266	PyAPI_FUNC(int) PyObject_IsInstance(PyObject object, PyObject typeorclass);
	1267	/* isinstance(object, typeorclass) */
	1268
	1269	PyAPI_FUNC(int) PyObject_IsSubclass(PyObject object, PyObject typeorclass);
	1270	/* issubclass(object, typeorclass) */
	1271
	1272
	1273	#ifdef __cplusplus
	1274	}
	1275	#endif
	1276	#endif /* Py_ABSTRACTOBJECT_H */

sys/src/cmd/python/Include/asdl.h+45−0

@@ -0,0 +1,45 @@
	1	#ifndef Py_ASDL_H
	2	#define Py_ASDL_H
	3
	4	typedef PyObject * identifier;
	5	typedef PyObject * string;
	6	typedef PyObject * object;
	7
	8	#ifndef __cplusplus
	9	typedef enum {false, true} bool;
	10	#endif
	11
	12	/* It would be nice if the code generated by asdl_c.py was completely
	13	independent of Python, but it is a goal the requires too much work
	14	at this stage. So, for example, I'll represent identifiers as
	15	interned Python strings.
	16	*/
	17
	18	/* XXX A sequence should be typed so that its use can be typechecked. */
	19
	20	typedef struct {
	21	int size;
	22	void *elements[1];
	23	} asdl_seq;
	24
	25	typedef struct {
	26	int size;
	27	int elements[1];
	28	} asdl_int_seq;
	29
	30	asdl_seq asdl_seq_new(int size, PyArena arena);
	31	asdl_int_seq asdl_int_seq_new(int size, PyArena arena);
	32
	33	#define asdl_seq_GET(S, I) (S)->elements[(I)]
	34	#define asdl_seq_LEN(S) ((S) == NULL ? 0 : (S)->size)
	35	#ifdef Py_DEBUG
	36	#define asdl_seq_SET(S, I, V) { \
	37	int _asdl_i = (I); \
	38	assert((S) && _asdl_i < (S)->size); \
	39	(S)->elements[_asdl_i] = (V); \
	40	}
	41	#else
	42	#define asdl_seq_SET(S, I, V) (S)->elements[I] = (V)
	43	#endif
	44
	45	#endif /* !Py_ASDL_H */

sys/src/cmd/python/Include/ast.h+13−0

@@ -0,0 +1,13 @@
	1	#ifndef Py_AST_H
	2	#define Py_AST_H
	3	#ifdef __cplusplus
	4	extern "C" {
	5	#endif
	6
	7	PyAPI_FUNC(mod_ty) PyAST_FromNode(const node , PyCompilerFlags flags,
	8	const char , PyArena );
	9
	10	#ifdef __cplusplus
	11	}
	12	#endif
	13	#endif /* !Py_AST_H */

sys/src/cmd/python/Include/bitset.h+32−0

@@ -0,0 +1,32 @@
	1
	2	#ifndef Py_BITSET_H
	3	#define Py_BITSET_H
	4	#ifdef __cplusplus
	5	extern "C" {
	6	#endif
	7
	8	/* Bitset interface */
	9
	10	#define BYTE char
	11
	12	typedef BYTE *bitset;
	13
	14	bitset newbitset(int nbits);
	15	void delbitset(bitset bs);
	16	#define testbit(ss, ibit) (((ss)[BIT2BYTE(ibit)] & BIT2MASK(ibit)) != 0)
	17	int addbit(bitset bs, int ibit); /* Returns 0 if already set */
	18	int samebitset(bitset bs1, bitset bs2, int nbits);
	19	void mergebitset(bitset bs1, bitset bs2, int nbits);
	20
	21	#define BITSPERBYTE (8*sizeof(BYTE))
	22	#define NBYTES(nbits) (((nbits) + BITSPERBYTE - 1) / BITSPERBYTE)
	23
	24	#define BIT2BYTE(ibit) ((ibit) / BITSPERBYTE)
	25	#define BIT2SHIFT(ibit) ((ibit) % BITSPERBYTE)
	26	#define BIT2MASK(ibit) (1 << BIT2SHIFT(ibit))
	27	#define BYTE2BIT(ibyte) ((ibyte) * BITSPERBYTE)
	28
	29	#ifdef __cplusplus
	30	}
	31	#endif
	32	#endif /* !Py_BITSET_H */

sys/src/cmd/python/Include/boolobject.h+36−0

@@ -0,0 +1,36 @@
	1	/* Boolean object interface */
	2
	3	#ifndef Py_BOOLOBJECT_H
	4	#define Py_BOOLOBJECT_H
	5	#ifdef __cplusplus
	6	extern "C" {
	7	#endif
	8
	9
	10	typedef PyIntObject PyBoolObject;
	11
	12	PyAPI_DATA(PyTypeObject) PyBool_Type;
	13
	14	#define PyBool_Check(x) ((x)->ob_type == &PyBool_Type)
	15
	16	/* Py_False and Py_True are the only two bools in existence.
	17	Don't forget to apply Py_INCREF() when returning either!!! */
	18
	19	/* Don't use these directly */
	20	PyAPI_DATA(PyIntObject) _Py_ZeroStruct, _Py_TrueStruct;
	21
	22	/* Use these macros */
	23	#define Py_False ((PyObject *) &_Py_ZeroStruct)
	24	#define Py_True ((PyObject *) &_Py_TrueStruct)
	25
	26	/* Macros for returning Py_True or Py_False, respectively */
	27	#define Py_RETURN_TRUE return Py_INCREF(Py_True), Py_True
	28	#define Py_RETURN_FALSE return Py_INCREF(Py_False), Py_False
	29
	30	/* Function to return a bool from a C long */
	31	PyAPI_FUNC(PyObject *) PyBool_FromLong(long);
	32
	33	#ifdef __cplusplus
	34	}
	35	#endif
	36	#endif /* !Py_BOOLOBJECT_H */

sys/src/cmd/python/Include/bufferobject.h+33−0

@@ -0,0 +1,33 @@
	1
	2	/* Buffer object interface */
	3
	4	/* Note: the object's structure is private */
	5
	6	#ifndef Py_BUFFEROBJECT_H
	7	#define Py_BUFFEROBJECT_H
	8	#ifdef __cplusplus
	9	extern "C" {
	10	#endif
	11
	12
	13	PyAPI_DATA(PyTypeObject) PyBuffer_Type;
	14
	15	#define PyBuffer_Check(op) ((op)->ob_type == &PyBuffer_Type)
	16
	17	#define Py_END_OF_BUFFER (-1)
	18
	19	PyAPI_FUNC(PyObject ) PyBuffer_FromObject(PyObject base,
	20	Py_ssize_t offset, Py_ssize_t size);
	21	PyAPI_FUNC(PyObject ) PyBuffer_FromReadWriteObject(PyObject base,
	22	Py_ssize_t offset,
	23	Py_ssize_t size);
	24
	25	PyAPI_FUNC(PyObject ) PyBuffer_FromMemory(void ptr, Py_ssize_t size);
	26	PyAPI_FUNC(PyObject ) PyBuffer_FromReadWriteMemory(void ptr, Py_ssize_t size);
	27
	28	PyAPI_FUNC(PyObject *) PyBuffer_New(Py_ssize_t size);
	29
	30	#ifdef __cplusplus
	31	}
	32	#endif
	33	#endif /* !Py_BUFFEROBJECT_H */

sys/src/cmd/python/Include/cStringIO.h+70−0

@@ -0,0 +1,70 @@
	1	#ifndef Py_CSTRINGIO_H
	2	#define Py_CSTRINGIO_H
	3	#ifdef __cplusplus
	4	extern "C" {
	5	#endif
	6	/*
	7
	8	This header provides access to cStringIO objects from C.
	9	Functions are provided for calling cStringIO objects and
	10	macros are provided for testing whether you have cStringIO
	11	objects.
	12
	13	Before calling any of the functions or macros, you must initialize
	14	the routines with:
	15
	16	PycString_IMPORT
	17
	18	This would typically be done in your init function.
	19
	20	*/
	21	#define PycString_IMPORT \
	22	PycStringIO = (struct PycStringIO_CAPI*)PyCObject_Import("cStringIO", \
	23	"cStringIO_CAPI")
	24
	25	/* Basic functions to manipulate cStringIO objects from C */
	26
	27	static struct PycStringIO_CAPI {
	28
	29	/* Read a string from an input object. If the last argument
	30	is -1, the remainder will be read.
	31	*/
	32	int(cread)(PyObject , char **, Py_ssize_t);
	33
	34	/* Read a line from an input object. Returns the length of the read
	35	line as an int and a pointer inside the object buffer as char** (so
	36	the caller doesn't have to provide its own buffer as destination).
	37	*/
	38	int(creadline)(PyObject , char **);
	39
	40	/* Write a string to an output object*/
	41	int(cwrite)(PyObject , const char *, Py_ssize_t);
	42
	43	/* Get the output object as a Python string (returns new reference). */
	44	PyObject (cgetvalue)(PyObject *);
	45
	46	/* Create a new output object */
	47	PyObject (NewOutput)(int);
	48
	49	/* Create an input object from a Python string
	50	(copies the Python string reference).
	51	*/
	52	PyObject (NewInput)(PyObject *);
	53
	54	/* The Python types for cStringIO input and output objects.
	55	Note that you can do input on an output object.
	56	*/
	57	PyTypeObject InputType, OutputType;
	58
	59	} *PycStringIO;
	60
	61	/* These can be used to test if you have one */
	62	#define PycStringIO_InputCheck(O) \
	63	((O)->ob_type==PycStringIO->InputType)
	64	#define PycStringIO_OutputCheck(O) \
	65	((O)->ob_type==PycStringIO->OutputType)
	66
	67	#ifdef __cplusplus
	68	}
	69	#endif
	70	#endif /* !Py_CSTRINGIO_H */

sys/src/cmd/python/Include/cellobject.h+28−0

@@ -0,0 +1,28 @@
	1	/* Cell object interface */
	2
	3	#ifndef Py_CELLOBJECT_H
	4	#define Py_CELLOBJECT_H
	5	#ifdef __cplusplus
	6	extern "C" {
	7	#endif
	8
	9	typedef struct {
	10	PyObject_HEAD
	11	PyObject ob_ref; / Content of the cell or NULL when empty */
	12	} PyCellObject;
	13
	14	PyAPI_DATA(PyTypeObject) PyCell_Type;
	15
	16	#define PyCell_Check(op) ((op)->ob_type == &PyCell_Type)
	17
	18	PyAPI_FUNC(PyObject ) PyCell_New(PyObject );
	19	PyAPI_FUNC(PyObject ) PyCell_Get(PyObject );
	20	PyAPI_FUNC(int) PyCell_Set(PyObject , PyObject );
	21
	22	#define PyCell_GET(op) (((PyCellObject *)(op))->ob_ref)
	23	#define PyCell_SET(op, v) (((PyCellObject *)(op))->ob_ref = v)
	24
	25	#ifdef __cplusplus
	26	}
	27	#endif
	28	#endif /* !Py_TUPLEOBJECT_H */

sys/src/cmd/python/Include/ceval.h+157−0

@@ -0,0 +1,157 @@
	1	#ifndef Py_CEVAL_H
	2	#define Py_CEVAL_H
	3	#ifdef __cplusplus
	4	extern "C" {
	5	#endif
	6
	7
	8	/* Interface to random parts in ceval.c */
	9
	10	PyAPI_FUNC(PyObject *) PyEval_CallObjectWithKeywords(
	11	PyObject , PyObject , PyObject *);
	12
	13	/* DLL-level Backwards compatibility: */
	14	#undef PyEval_CallObject
	15	PyAPI_FUNC(PyObject ) PyEval_CallObject(PyObject , PyObject *);
	16
	17	/* Inline this */
	18	#define PyEval_CallObject(func,arg) \
	19	PyEval_CallObjectWithKeywords(func, arg, (PyObject *)NULL)
	20
	21	PyAPI_FUNC(PyObject ) PyEval_CallFunction(PyObject obj,
	22	const char *format, ...);
	23	PyAPI_FUNC(PyObject ) PyEval_CallMethod(PyObject obj,
	24	const char *methodname,
	25	const char *format, ...);
	26
	27	PyAPI_FUNC(void) PyEval_SetProfile(Py_tracefunc, PyObject *);
	28	PyAPI_FUNC(void) PyEval_SetTrace(Py_tracefunc, PyObject *);
	29
	30	struct _frame; /* Avoid including frameobject.h */
	31
	32	PyAPI_FUNC(PyObject *) PyEval_GetBuiltins(void);
	33	PyAPI_FUNC(PyObject *) PyEval_GetGlobals(void);
	34	PyAPI_FUNC(PyObject *) PyEval_GetLocals(void);
	35	PyAPI_FUNC(struct _frame *) PyEval_GetFrame(void);
	36	PyAPI_FUNC(int) PyEval_GetRestricted(void);
	37
	38	/* Look at the current frame's (if any) code's co_flags, and turn on
	39	the corresponding compiler flags in cf->cf_flags. Return 1 if any
	40	flag was set, else return 0. */
	41	PyAPI_FUNC(int) PyEval_MergeCompilerFlags(PyCompilerFlags *cf);
	42
	43	PyAPI_FUNC(int) Py_FlushLine(void);
	44
	45	PyAPI_FUNC(int) Py_AddPendingCall(int (func)(void ), void *arg);
	46	PyAPI_FUNC(int) Py_MakePendingCalls(void);
	47
	48	/* Protection against deeply nested recursive calls */
	49	PyAPI_FUNC(void) Py_SetRecursionLimit(int);
	50	PyAPI_FUNC(int) Py_GetRecursionLimit(void);
	51
	52	#define Py_EnterRecursiveCall(where) \
	53	(_Py_MakeRecCheck(PyThreadState_GET()->recursion_depth) && \
	54	_Py_CheckRecursiveCall(where))
	55	#define Py_LeaveRecursiveCall() \
	56	(--PyThreadState_GET()->recursion_depth)
	57	PyAPI_FUNC(int) _Py_CheckRecursiveCall(char *where);
	58	PyAPI_DATA(int) _Py_CheckRecursionLimit;
	59	#ifdef USE_STACKCHECK
	60	# define _Py_MakeRecCheck(x) (++(x) > --_Py_CheckRecursionLimit)
	61	#else
	62	# define _Py_MakeRecCheck(x) (++(x) > _Py_CheckRecursionLimit)
	63	#endif
	64
	65	PyAPI_FUNC(const char ) PyEval_GetFuncName(PyObject );
	66	PyAPI_FUNC(const char ) PyEval_GetFuncDesc(PyObject );
	67
	68	PyAPI_FUNC(PyObject ) PyEval_GetCallStats(PyObject );
	69	PyAPI_FUNC(PyObject ) PyEval_EvalFrame(struct _frame );
	70	PyAPI_FUNC(PyObject ) PyEval_EvalFrameEx(struct _frame f, int exc);
	71
	72	/* this used to be handled on a per-thread basis - now just two globals */
	73	PyAPI_DATA(volatile int) _Py_Ticker;
	74	PyAPI_DATA(int) _Py_CheckInterval;
	75
	76	/* Interface for threads.
	77
	78	A module that plans to do a blocking system call (or something else
	79	that lasts a long time and doesn't touch Python data) can allow other
	80	threads to run as follows:
	81
	82	...preparations here...
	83	Py_BEGIN_ALLOW_THREADS
	84	...blocking system call here...
	85	Py_END_ALLOW_THREADS
	86	...interpret result here...
	87
	88	The Py_BEGIN_ALLOW_THREADS/Py_END_ALLOW_THREADS pair expands to a
	89	{}-surrounded block.
	90	To leave the block in the middle (e.g., with return), you must insert
	91	a line containing Py_BLOCK_THREADS before the return, e.g.
	92
	93	if (...premature_exit...) {
	94	Py_BLOCK_THREADS
	95	PyErr_SetFromErrno(PyExc_IOError);
	96	return NULL;
	97	}
	98
	99	An alternative is:
	100
	101	Py_BLOCK_THREADS
	102	if (...premature_exit...) {
	103	PyErr_SetFromErrno(PyExc_IOError);
	104	return NULL;
	105	}
	106	Py_UNBLOCK_THREADS
	107
	108	For convenience, that the value of 'errno' is restored across
	109	Py_END_ALLOW_THREADS and Py_BLOCK_THREADS.
	110
	111	WARNING: NEVER NEST CALLS TO Py_BEGIN_ALLOW_THREADS AND
	112	Py_END_ALLOW_THREADS!!!
	113
	114	The function PyEval_InitThreads() should be called only from
	115	initthread() in "threadmodule.c".
	116
	117	Note that not yet all candidates have been converted to use this
	118	mechanism!
	119	*/
	120
	121	PyAPI_FUNC(PyThreadState *) PyEval_SaveThread(void);
	122	PyAPI_FUNC(void) PyEval_RestoreThread(PyThreadState *);
	123
	124	#ifdef WITH_THREAD
	125
	126	PyAPI_FUNC(int) PyEval_ThreadsInitialized(void);
	127	PyAPI_FUNC(void) PyEval_InitThreads(void);
	128	PyAPI_FUNC(void) PyEval_AcquireLock(void);
	129	PyAPI_FUNC(void) PyEval_ReleaseLock(void);
	130	PyAPI_FUNC(void) PyEval_AcquireThread(PyThreadState *tstate);
	131	PyAPI_FUNC(void) PyEval_ReleaseThread(PyThreadState *tstate);
	132	PyAPI_FUNC(void) PyEval_ReInitThreads(void);
	133
	134	#define Py_BEGIN_ALLOW_THREADS { \
	135	PyThreadState *_save; \
	136	_save = PyEval_SaveThread();
	137	#define Py_BLOCK_THREADS PyEval_RestoreThread(_save);
	138	#define Py_UNBLOCK_THREADS _save = PyEval_SaveThread();
	139	#define Py_END_ALLOW_THREADS PyEval_RestoreThread(_save); \
	140	}
	141
	142	#else /* !WITH_THREAD */
	143
	144	#define Py_BEGIN_ALLOW_THREADS {
	145	#define Py_BLOCK_THREADS
	146	#define Py_UNBLOCK_THREADS
	147	#define Py_END_ALLOW_THREADS }
	148
	149	#endif /* !WITH_THREAD */
	150
	151	PyAPI_FUNC(int) _PyEval_SliceIndex(PyObject , Py_ssize_t );
	152
	153
	154	#ifdef __cplusplus
	155	}
	156	#endif
	157	#endif /* !Py_CEVAL_H */

sys/src/cmd/python/Include/classobject.h+81−0

@@ -0,0 +1,81 @@
	1
	2	/* Class object interface */
	3
	4	/* Revealing some structures (not for general use) */
	5
	6	#ifndef Py_CLASSOBJECT_H
	7	#define Py_CLASSOBJECT_H
	8	#ifdef __cplusplus
	9	extern "C" {
	10	#endif
	11
	12	typedef struct {
	13	PyObject_HEAD
	14	PyObject cl_bases; / A tuple of class objects */
	15	PyObject cl_dict; / A dictionary */
	16	PyObject cl_name; / A string */
	17	/* The following three are functions or NULL */
	18	PyObject *cl_getattr;
	19	PyObject *cl_setattr;
	20	PyObject *cl_delattr;
	21	} PyClassObject;
	22
	23	typedef struct {
	24	PyObject_HEAD
	25	PyClassObject in_class; / The class object */
	26	PyObject in_dict; / A dictionary */
	27	PyObject in_weakreflist; / List of weak references */
	28	} PyInstanceObject;
	29
	30	typedef struct {
	31	PyObject_HEAD
	32	PyObject im_func; / The callable object implementing the method */
	33	PyObject im_self; / The instance it is bound to, or NULL */
	34	PyObject im_class; / The class that asked for the method */
	35	PyObject im_weakreflist; / List of weak references */
	36	} PyMethodObject;
	37
	38	PyAPI_DATA(PyTypeObject) PyClass_Type, PyInstance_Type, PyMethod_Type;
	39
	40	#define PyClass_Check(op) ((op)->ob_type == &PyClass_Type)
	41	#define PyInstance_Check(op) ((op)->ob_type == &PyInstance_Type)
	42	#define PyMethod_Check(op) ((op)->ob_type == &PyMethod_Type)
	43
	44	PyAPI_FUNC(PyObject ) PyClass_New(PyObject , PyObject , PyObject );
	45	PyAPI_FUNC(PyObject ) PyInstance_New(PyObject , PyObject *,
	46	PyObject *);
	47	PyAPI_FUNC(PyObject ) PyInstance_NewRaw(PyObject , PyObject *);
	48	PyAPI_FUNC(PyObject ) PyMethod_New(PyObject , PyObject , PyObject );
	49
	50	PyAPI_FUNC(PyObject ) PyMethod_Function(PyObject );
	51	PyAPI_FUNC(PyObject ) PyMethod_Self(PyObject );
	52	PyAPI_FUNC(PyObject ) PyMethod_Class(PyObject );
	53
	54	/* Look up attribute with name (a string) on instance object pinst, using
	55	* only the instance and base class dicts. If a descriptor is found in
	56	* a class dict, the descriptor is returned without calling it.
	57	* Returns NULL if nothing found, else a borrowed reference to the
	58	* value associated with name in the dict in which name was found.
	59	* The point of this routine is that it never calls arbitrary Python
	60	* code, so is always "safe": all it does is dict lookups. The function
	61	* can't fail, never sets an exception, and NULL is not an error (it just
	62	* means "not found").
	63	*/
	64	PyAPI_FUNC(PyObject ) _PyInstance_Lookup(PyObject pinst, PyObject *name);
	65
	66	/* Macros for direct access to these values. Type checks are not
	67	done, so use with care. */
	68	#define PyMethod_GET_FUNCTION(meth) \
	69	(((PyMethodObject *)meth) -> im_func)
	70	#define PyMethod_GET_SELF(meth) \
	71	(((PyMethodObject *)meth) -> im_self)
	72	#define PyMethod_GET_CLASS(meth) \
	73	(((PyMethodObject *)meth) -> im_class)
	74
	75	PyAPI_FUNC(int) PyClass_IsSubclass(PyObject , PyObject );
	76
	77
	78	#ifdef __cplusplus
	79	}
	80	#endif
	81	#endif /* !Py_CLASSOBJECT_H */

sys/src/cmd/python/Include/cobject.h+54−0

@@ -0,0 +1,54 @@
	1
	2	/* C objects to be exported from one extension module to another.
	3
	4	C objects are used for communication between extension modules.
	5	They provide a way for an extension module to export a C interface
	6	to other extension modules, so that extension modules can use the
	7	Python import mechanism to link to one another.
	8
	9	*/
	10
	11	#ifndef Py_COBJECT_H
	12	#define Py_COBJECT_H
	13	#ifdef __cplusplus
	14	extern "C" {
	15	#endif
	16
	17	PyAPI_DATA(PyTypeObject) PyCObject_Type;
	18
	19	#define PyCObject_Check(op) ((op)->ob_type == &PyCObject_Type)
	20
	21	/* Create a PyCObject from a pointer to a C object and an optional
	22	destructor function. If the second argument is non-null, then it
	23	will be called with the first argument if and when the PyCObject is
	24	destroyed.
	25
	26	*/
	27	PyAPI_FUNC(PyObject *) PyCObject_FromVoidPtr(
	28	void cobj, void (destruct)(void*));
	29
	30
	31	/* Create a PyCObject from a pointer to a C object, a description object,
	32	and an optional destructor function. If the third argument is non-null,
	33	then it will be called with the first and second arguments if and when
	34	the PyCObject is destroyed.
	35	*/
	36	PyAPI_FUNC(PyObject *) PyCObject_FromVoidPtrAndDesc(
	37	void cobj, void desc, void (destruct)(void,void*));
	38
	39	/* Retrieve a pointer to a C object from a PyCObject. */
	40	PyAPI_FUNC(void ) PyCObject_AsVoidPtr(PyObject );
	41
	42	/* Retrieve a pointer to a description object from a PyCObject. */
	43	PyAPI_FUNC(void ) PyCObject_GetDesc(PyObject );
	44
	45	/* Import a pointer to a C object from a module using a PyCObject. */
	46	PyAPI_FUNC(void ) PyCObject_Import(char module_name, char *cobject_name);
	47
	48	/* Modify a C object. Fails (==0) if object has a destructor. */
	49	PyAPI_FUNC(int) PyCObject_SetVoidPtr(PyObject self, void cobj);
	50
	51	#ifdef __cplusplus
	52	}
	53	#endif
	54	#endif /* !Py_COBJECT_H */

sys/src/cmd/python/Include/code.h+94−0

@@ -0,0 +1,94 @@
	1	/* Definitions for bytecode */
	2
	3	#ifndef Py_CODE_H
	4	#define Py_CODE_H
	5	#ifdef __cplusplus
	6	extern "C" {
	7	#endif
	8
	9	/* Bytecode object */
	10	typedef struct {
	11	PyObject_HEAD
	12	int co_argcount; /* #arguments, except args /
	13	int co_nlocals; /* #local variables */
	14	int co_stacksize; /* #entries needed for evaluation stack */
	15	int co_flags; /* CO_..., see below */
	16	PyObject co_code; / instruction opcodes */
	17	PyObject co_consts; / list (constants used) */
	18	PyObject co_names; / list of strings (names used) */
	19	PyObject co_varnames; / tuple of strings (local variable names) */
	20	PyObject co_freevars; / tuple of strings (free variable names) */
	21	PyObject co_cellvars; / tuple of strings (cell variable names) */
	22	/* The rest doesn't count for hash/cmp */
	23	PyObject co_filename; / string (where it was loaded from) */
	24	PyObject co_name; / string (name, for reference) */
	25	int co_firstlineno; /* first source line number */
	26	PyObject co_lnotab; / string (encoding addr<->lineno mapping) */
	27	void co_zombieframe; / for optimization only (see frameobject.c) */
	28	} PyCodeObject;
	29
	30	/* Masks for co_flags above */
	31	#define CO_OPTIMIZED 0x0001
	32	#define CO_NEWLOCALS 0x0002
	33	#define CO_VARARGS 0x0004
	34	#define CO_VARKEYWORDS 0x0008
	35	#define CO_NESTED 0x0010
	36	#define CO_GENERATOR 0x0020
	37	/* The CO_NOFREE flag is set if there are no free or cell variables.
	38	This information is redundant, but it allows a single flag test
	39	to determine whether there is any extra work to be done when the
	40	call frame it setup.
	41	*/
	42	#define CO_NOFREE 0x0040
	43
	44	#if 0
	45	/* This is no longer used. Stopped defining in 2.5, do not re-use. */
	46	#define CO_GENERATOR_ALLOWED 0x1000
	47	#endif
	48	#define CO_FUTURE_DIVISION 0x2000
	49	#define CO_FUTURE_ABSOLUTE_IMPORT 0x4000 /* do absolute imports by default */
	50	#define CO_FUTURE_WITH_STATEMENT 0x8000
	51
	52	/* This should be defined if a future statement modifies the syntax.
	53	For example, when a keyword is added.
	54	*/
	55	#define PY_PARSER_REQUIRES_FUTURE_KEYWORD
	56
	57	#define CO_MAXBLOCKS 20 /* Max static block nesting within a function */
	58
	59	PyAPI_DATA(PyTypeObject) PyCode_Type;
	60
	61	#define PyCode_Check(op) ((op)->ob_type == &PyCode_Type)
	62	#define PyCode_GetNumFree(op) (PyTuple_GET_SIZE((op)->co_freevars))
	63
	64	/* Public interface */
	65	PyAPI_FUNC(PyCodeObject *) PyCode_New(
	66	int, int, int, int, PyObject , PyObject , PyObject , PyObject ,
	67	PyObject , PyObject , PyObject , PyObject , int, PyObject *);
	68	/* same as struct above */
	69	PyAPI_FUNC(int) PyCode_Addr2Line(PyCodeObject *, int);
	70
	71	/* for internal use only */
	72	#define _PyCode_GETCODEPTR(co, pp) \
	73	((*(co)->co_code->ob_type->tp_as_buffer->bf_getreadbuffer) \
	74	((co)->co_code, 0, (void **)(pp)))
	75
	76	typedef struct _addr_pair {
	77	int ap_lower;
	78	int ap_upper;
	79	} PyAddrPair;
	80
	81	/* Check whether lasti (an instruction offset) falls outside bounds
	82	and whether it is a line number that should be traced. Returns
	83	a line number if it should be traced or -1 if the line should not.
	84
	85	If lasti is not within bounds, updates bounds.
	86	*/
	87
	88	PyAPI_FUNC(int) PyCode_CheckLineNumber(PyCodeObject* co,
	89	int lasti, PyAddrPair *bounds);
	90
	91	#ifdef __cplusplus
	92	}
	93	#endif
	94	#endif /* !Py_CODE_H */

sys/src/cmd/python/Include/codecs.h+167−0

@@ -0,0 +1,167 @@
	1	#ifndef Py_CODECREGISTRY_H
	2	#define Py_CODECREGISTRY_H
	3	#ifdef __cplusplus
	4	extern "C" {
	5	#endif
	6
	7	/* ------------------------------------------------------------------------
	8
	9	Python Codec Registry and support functions
	10
	11
	12	Written by Marc-Andre Lemburg (mal@lemburg.com).
	13
	14	Copyright (c) Corporation for National Research Initiatives.
	15
	16	------------------------------------------------------------------------ */
	17
	18	/* Register a new codec search function.
	19
	20	As side effect, this tries to load the encodings package, if not
	21	yet done, to make sure that it is always first in the list of
	22	search functions.
	23
	24	The search_function's refcount is incremented by this function. */
	25
	26	PyAPI_FUNC(int) PyCodec_Register(
	27	PyObject *search_function
	28	);
	29
	30	/* Codec register lookup API.
	31
	32	Looks up the given encoding and returns a CodecInfo object with
	33	function attributes which implement the different aspects of
	34	processing the encoding.
	35
	36	The encoding string is looked up converted to all lower-case
	37	characters. This makes encodings looked up through this mechanism
	38	effectively case-insensitive.
	39
	40	If no codec is found, a KeyError is set and NULL returned.
	41
	42	As side effect, this tries to load the encodings package, if not
	43	yet done. This is part of the lazy load strategy for the encodings
	44	package.
	45
	46	*/
	47
	48	PyAPI_FUNC(PyObject *) _PyCodec_Lookup(
	49	const char *encoding
	50	);
	51
	52	/* Generic codec based encoding API.
	53
	54	object is passed through the encoder function found for the given
	55	encoding using the error handling method defined by errors. errors
	56	may be NULL to use the default method defined for the codec.
	57
	58	Raises a LookupError in case no encoder can be found.
	59
	60	*/
	61
	62	PyAPI_FUNC(PyObject *) PyCodec_Encode(
	63	PyObject *object,
	64	const char *encoding,
	65	const char *errors
	66	);
	67
	68	/* Generic codec based decoding API.
	69
	70	object is passed through the decoder function found for the given
	71	encoding using the error handling method defined by errors. errors
	72	may be NULL to use the default method defined for the codec.
	73
	74	Raises a LookupError in case no encoder can be found.
	75
	76	*/
	77
	78	PyAPI_FUNC(PyObject *) PyCodec_Decode(
	79	PyObject *object,
	80	const char *encoding,
	81	const char *errors
	82	);
	83
	84	/* --- Codec Lookup APIs --------------------------------------------------
	85
	86	All APIs return a codec object with incremented refcount and are
	87	based on _PyCodec_Lookup(). The same comments w/r to the encoding
	88	name also apply to these APIs.
	89
	90	*/
	91
	92	/* Get an encoder function for the given encoding. */
	93
	94	PyAPI_FUNC(PyObject *) PyCodec_Encoder(
	95	const char *encoding
	96	);
	97
	98	/* Get a decoder function for the given encoding. */
	99
	100	PyAPI_FUNC(PyObject *) PyCodec_Decoder(
	101	const char *encoding
	102	);
	103
	104	/* Get a IncrementalEncoder object for the given encoding. */
	105
	106	PyAPI_FUNC(PyObject *) PyCodec_IncrementalEncoder(
	107	const char *encoding,
	108	const char *errors
	109	);
	110
	111	/* Get a IncrementalDecoder object function for the given encoding. */
	112
	113	PyAPI_FUNC(PyObject *) PyCodec_IncrementalDecoder(
	114	const char *encoding,
	115	const char *errors
	116	);
	117
	118	/* Get a StreamReader factory function for the given encoding. */
	119
	120	PyAPI_FUNC(PyObject *) PyCodec_StreamReader(
	121	const char *encoding,
	122	PyObject *stream,
	123	const char *errors
	124	);
	125
	126	/* Get a StreamWriter factory function for the given encoding. */
	127
	128	PyAPI_FUNC(PyObject *) PyCodec_StreamWriter(
	129	const char *encoding,
	130	PyObject *stream,
	131	const char *errors
	132	);
	133
	134	/* Unicode encoding error handling callback registry API */
	135
	136	/* Register the error handling callback function error under the name
	137	name. This function will be called by the codec when it encounters
	138	unencodable characters/undecodable bytes and doesn't know the
	139	callback name, when name is specified as the error parameter
	140	in the call to the encode/decode function.
	141	Return 0 on success, -1 on error */
	142	PyAPI_FUNC(int) PyCodec_RegisterError(const char name, PyObject error);
	143
	144	/* Lookup the error handling callback function registered under the
	145	name error. As a special case NULL can be passed, in which case
	146	the error handling callback for "strict" will be returned. */
	147	PyAPI_FUNC(PyObject ) PyCodec_LookupError(const char name);
	148
	149	/* raise exc as an exception */
	150	PyAPI_FUNC(PyObject ) PyCodec_StrictErrors(PyObject exc);
	151
	152	/* ignore the unicode error, skipping the faulty input */
	153	PyAPI_FUNC(PyObject ) PyCodec_IgnoreErrors(PyObject exc);
	154
	155	/* replace the unicode error with ? or U+FFFD */
	156	PyAPI_FUNC(PyObject ) PyCodec_ReplaceErrors(PyObject exc);
	157
	158	/* replace the unicode encode error with XML character references */
	159	PyAPI_FUNC(PyObject ) PyCodec_XMLCharRefReplaceErrors(PyObject exc);
	160
	161	/* replace the unicode encode error with backslash escapes (\x, \u and \U) */
	162	PyAPI_FUNC(PyObject ) PyCodec_BackslashReplaceErrors(PyObject exc);
	163
	164	#ifdef __cplusplus
	165	}
	166	#endif
	167	#endif /* !Py_CODECREGISTRY_H */

sys/src/cmd/python/Include/compile.h+39−0

@@ -0,0 +1,39 @@
	1
	2	#ifndef Py_COMPILE_H
	3	#define Py_COMPILE_H
	4
	5	#include "code.h"
	6
	7	#ifdef __cplusplus
	8	extern "C" {
	9	#endif
	10
	11	/* Public interface */
	12	struct _node; /* Declare the existence of this type */
	13	PyAPI_FUNC(PyCodeObject ) PyNode_Compile(struct _node , const char *);
	14
	15	/* Future feature support */
	16
	17	typedef struct {
	18	int ff_features; /* flags set by future statements */
	19	int ff_lineno; /* line number of last future statement */
	20	} PyFutureFeatures;
	21
	22	#define FUTURE_NESTED_SCOPES "nested_scopes"
	23	#define FUTURE_GENERATORS "generators"
	24	#define FUTURE_DIVISION "division"
	25	#define FUTURE_ABSOLUTE_IMPORT "absolute_import"
	26	#define FUTURE_WITH_STATEMENT "with_statement"
	27
	28	struct _mod; /* Declare the existence of this type */
	29	PyAPI_FUNC(PyCodeObject ) PyAST_Compile(struct _mod , const char *,
	30	PyCompilerFlags , PyArena );
	31	PyAPI_FUNC(PyFutureFeatures ) PyFuture_FromAST(struct _mod , const char *);
	32
	33	#define ERR_LATE_FUTURE \
	34	"from __future__ imports must occur at the beginning of the file"
	35
	36	#ifdef __cplusplus
	37	}
	38	#endif
	39	#endif /* !Py_COMPILE_H */

sys/src/cmd/python/Include/complexobject.h+58−0

@@ -0,0 +1,58 @@
	1	/* Complex number structure */
	2
	3	#ifndef Py_COMPLEXOBJECT_H
	4	#define Py_COMPLEXOBJECT_H
	5	#ifdef __cplusplus
	6	extern "C" {
	7	#endif
	8
	9	typedef struct {
	10	double real;
	11	double imag;
	12	} Py_complex;
	13
	14	/* Operations on complex numbers from complexmodule.c */
	15
	16	#define c_sum _Py_c_sum
	17	#define c_diff _Py_c_diff
	18	#define c_neg _Py_c_neg
	19	#define c_prod _Py_c_prod
	20	#define c_quot _Py_c_quot
	21	#define c_pow _Py_c_pow
	22
	23	PyAPI_FUNC(Py_complex) c_sum(Py_complex, Py_complex);
	24	PyAPI_FUNC(Py_complex) c_diff(Py_complex, Py_complex);
	25	PyAPI_FUNC(Py_complex) c_neg(Py_complex);
	26	PyAPI_FUNC(Py_complex) c_prod(Py_complex, Py_complex);
	27	PyAPI_FUNC(Py_complex) c_quot(Py_complex, Py_complex);
	28	PyAPI_FUNC(Py_complex) c_pow(Py_complex, Py_complex);
	29
	30
	31	/* Complex object interface */
	32
	33	/*
	34	PyComplexObject represents a complex number with double-precision
	35	real and imaginary parts.
	36	*/
	37
	38	typedef struct {
	39	PyObject_HEAD
	40	Py_complex cval;
	41	} PyComplexObject;
	42
	43	PyAPI_DATA(PyTypeObject) PyComplex_Type;
	44
	45	#define PyComplex_Check(op) PyObject_TypeCheck(op, &PyComplex_Type)
	46	#define PyComplex_CheckExact(op) ((op)->ob_type == &PyComplex_Type)
	47
	48	PyAPI_FUNC(PyObject *) PyComplex_FromCComplex(Py_complex);
	49	PyAPI_FUNC(PyObject *) PyComplex_FromDoubles(double real, double imag);
	50
	51	PyAPI_FUNC(double) PyComplex_RealAsDouble(PyObject *op);
	52	PyAPI_FUNC(double) PyComplex_ImagAsDouble(PyObject *op);
	53	PyAPI_FUNC(Py_complex) PyComplex_AsCComplex(PyObject *op);
	54
	55	#ifdef __cplusplus
	56	}
	57	#endif
	58	#endif /* !Py_COMPLEXOBJECT_H */

sys/src/cmd/python/Include/datetime.h+245−0

@@ -0,0 +1,245 @@
	1	/* datetime.h
	2	*/
	3
	4	#ifndef DATETIME_H
	5	#define DATETIME_H
	6	#ifdef __cplusplus
	7	extern "C" {
	8	#endif
	9
	10	/* Fields are packed into successive bytes, each viewed as unsigned and
	11	* big-endian, unless otherwise noted:
	12	*
	13	* byte offset
	14	* 0 year 2 bytes, 1-9999
	15	* 2 month 1 byte, 1-12
	16	* 3 day 1 byte, 1-31
	17	* 4 hour 1 byte, 0-23
	18	* 5 minute 1 byte, 0-59
	19	* 6 second 1 byte, 0-59
	20	* 7 usecond 3 bytes, 0-999999
	21	* 10
	22	*/
	23
	24	/* # of bytes for year, month, and day. */
	25	#define _PyDateTime_DATE_DATASIZE 4
	26
	27	/* # of bytes for hour, minute, second, and usecond. */
	28	#define _PyDateTime_TIME_DATASIZE 6
	29
	30	/* # of bytes for year, month, day, hour, minute, second, and usecond. */
	31	#define _PyDateTime_DATETIME_DATASIZE 10
	32
	33
	34	typedef struct
	35	{
	36	PyObject_HEAD
	37	long hashcode; /* -1 when unknown */
	38	int days; /* -MAX_DELTA_DAYS <= days <= MAX_DELTA_DAYS */
	39	int seconds; /* 0 <= seconds < 243600 is invariant /
	40	int microseconds; /* 0 <= microseconds < 1000000 is invariant */
	41	} PyDateTime_Delta;
	42
	43	typedef struct
	44	{
	45	PyObject_HEAD /* a pure abstract base clase */
	46	} PyDateTime_TZInfo;
	47
	48
	49	/* The datetime and time types have hashcodes, and an optional tzinfo member,
	50	* present if and only if hastzinfo is true.
	51	*/
	52	#define _PyTZINFO_HEAD \
	53	PyObject_HEAD \
	54	long hashcode; \
	55	char hastzinfo; /* boolean flag */
	56
	57	/* No _PyDateTime_BaseTZInfo is allocated; it's just to have something
	58	* convenient to cast to, when getting at the hastzinfo member of objects
	59	* starting with _PyTZINFO_HEAD.
	60	*/
	61	typedef struct
	62	{
	63	_PyTZINFO_HEAD
	64	} _PyDateTime_BaseTZInfo;
	65
	66	/* All time objects are of PyDateTime_TimeType, but that can be allocated
	67	* in two ways, with or without a tzinfo member. Without is the same as
	68	* tzinfo == None, but consumes less memory. _PyDateTime_BaseTime is an
	69	* internal struct used to allocate the right amount of space for the
	70	* "without" case.
	71	*/
	72	#define _PyDateTime_TIMEHEAD \
	73	_PyTZINFO_HEAD \
	74	unsigned char data[_PyDateTime_TIME_DATASIZE];
	75
	76	typedef struct
	77	{
	78	_PyDateTime_TIMEHEAD
	79	} _PyDateTime_BaseTime; /* hastzinfo false */
	80
	81	typedef struct
	82	{
	83	_PyDateTime_TIMEHEAD
	84	PyObject *tzinfo;
	85	} PyDateTime_Time; /* hastzinfo true */
	86
	87
	88	/* All datetime objects are of PyDateTime_DateTimeType, but that can be
	89	* allocated in two ways too, just like for time objects above. In addition,
	90	* the plain date type is a base class for datetime, so it must also have
	91	* a hastzinfo member (although it's unused there).
	92	*/
	93	typedef struct
	94	{
	95	_PyTZINFO_HEAD
	96	unsigned char data[_PyDateTime_DATE_DATASIZE];
	97	} PyDateTime_Date;
	98
	99	#define _PyDateTime_DATETIMEHEAD \
	100	_PyTZINFO_HEAD \
	101	unsigned char data[_PyDateTime_DATETIME_DATASIZE];
	102
	103	typedef struct
	104	{
	105	_PyDateTime_DATETIMEHEAD
	106	} _PyDateTime_BaseDateTime; /* hastzinfo false */
	107
	108	typedef struct
	109	{
	110	_PyDateTime_DATETIMEHEAD
	111	PyObject *tzinfo;
	112	} PyDateTime_DateTime; /* hastzinfo true */
	113
	114
	115	/* Apply for date and datetime instances. */
	116	#define PyDateTime_GET_YEAR(o) ((((PyDateTime_Date*)o)->data[0] << 8) \| \
	117	((PyDateTime_Date*)o)->data[1])
	118	#define PyDateTime_GET_MONTH(o) (((PyDateTime_Date*)o)->data[2])
	119	#define PyDateTime_GET_DAY(o) (((PyDateTime_Date*)o)->data[3])
	120
	121	#define PyDateTime_DATE_GET_HOUR(o) (((PyDateTime_DateTime*)o)->data[4])
	122	#define PyDateTime_DATE_GET_MINUTE(o) (((PyDateTime_DateTime*)o)->data[5])
	123	#define PyDateTime_DATE_GET_SECOND(o) (((PyDateTime_DateTime*)o)->data[6])
	124	#define PyDateTime_DATE_GET_MICROSECOND(o) \
	125	((((PyDateTime_DateTime*)o)->data[7] << 16) \| \
	126	(((PyDateTime_DateTime*)o)->data[8] << 8) \| \
	127	((PyDateTime_DateTime*)o)->data[9])
	128
	129	/* Apply for time instances. */
	130	#define PyDateTime_TIME_GET_HOUR(o) (((PyDateTime_Time*)o)->data[0])
	131	#define PyDateTime_TIME_GET_MINUTE(o) (((PyDateTime_Time*)o)->data[1])
	132	#define PyDateTime_TIME_GET_SECOND(o) (((PyDateTime_Time*)o)->data[2])
	133	#define PyDateTime_TIME_GET_MICROSECOND(o) \
	134	((((PyDateTime_Time*)o)->data[3] << 16) \| \
	135	(((PyDateTime_Time*)o)->data[4] << 8) \| \
	136	((PyDateTime_Time*)o)->data[5])
	137
	138
	139	/* Define structure for C API. */
	140	typedef struct {
	141	/* type objects */
	142	PyTypeObject *DateType;
	143	PyTypeObject *DateTimeType;
	144	PyTypeObject *TimeType;
	145	PyTypeObject *DeltaType;
	146	PyTypeObject *TZInfoType;
	147
	148	/* constructors */
	149	PyObject (Date_FromDate)(int, int, int, PyTypeObject*);
	150	PyObject (DateTime_FromDateAndTime)(int, int, int, int, int, int, int,
	151	PyObject, PyTypeObject);
	152	PyObject (Time_FromTime)(int, int, int, int, PyObject, PyTypeObject);
	153	PyObject (Delta_FromDelta)(int, int, int, int, PyTypeObject*);
	154
	155	/* constructors for the DB API */
	156	PyObject (DateTime_FromTimestamp)(PyObject, PyObject, PyObject*);
	157	PyObject (Date_FromTimestamp)(PyObject, PyObject);
	158
	159	} PyDateTime_CAPI;
	160
	161
	162	/* "magic" constant used to partially protect against developer mistakes. */
	163	#define DATETIME_API_MAGIC 0x414548d5
	164
	165	#ifdef Py_BUILD_CORE
	166
	167	/* Macros for type checking when building the Python core. */
	168	#define PyDate_Check(op) PyObject_TypeCheck(op, &PyDateTime_DateType)
	169	#define PyDate_CheckExact(op) ((op)->ob_type == &PyDateTime_DateType)
	170
	171	#define PyDateTime_Check(op) PyObject_TypeCheck(op, &PyDateTime_DateTimeType)
	172	#define PyDateTime_CheckExact(op) ((op)->ob_type == &PyDateTime_DateTimeType)
	173
	174	#define PyTime_Check(op) PyObject_TypeCheck(op, &PyDateTime_TimeType)
	175	#define PyTime_CheckExact(op) ((op)->ob_type == &PyDateTime_TimeType)
	176
	177	#define PyDelta_Check(op) PyObject_TypeCheck(op, &PyDateTime_DeltaType)
	178	#define PyDelta_CheckExact(op) ((op)->ob_type == &PyDateTime_DeltaType)
	179
	180	#define PyTZInfo_Check(op) PyObject_TypeCheck(op, &PyDateTime_TZInfoType)
	181	#define PyTZInfo_CheckExact(op) ((op)->ob_type == &PyDateTime_TZInfoType)
	182
	183	#else
	184
	185	/* Define global variable for the C API and a macro for setting it. */
	186	static PyDateTime_CAPI *PyDateTimeAPI;
	187
	188	#define PyDateTime_IMPORT \
	189	PyDateTimeAPI = (PyDateTime_CAPI*) PyCObject_Import("datetime", \
	190	"datetime_CAPI")
	191
	192	/* This macro would be used if PyCObject_ImportEx() was created.
	193	#define PyDateTime_IMPORT \
	194	PyDateTimeAPI = (PyDateTime_CAPI*) PyCObject_ImportEx("datetime", \
	195	"datetime_CAPI", \
	196	DATETIME_API_MAGIC)
	197	*/
	198
	199	/* Macros for type checking when not building the Python core. */
	200	#define PyDate_Check(op) PyObject_TypeCheck(op, PyDateTimeAPI->DateType)
	201	#define PyDate_CheckExact(op) ((op)->ob_type == PyDateTimeAPI->DateType)
	202
	203	#define PyDateTime_Check(op) PyObject_TypeCheck(op, PyDateTimeAPI->DateTimeType)
	204	#define PyDateTime_CheckExact(op) ((op)->ob_type == PyDateTimeAPI->DateTimeType)
	205
	206	#define PyTime_Check(op) PyObject_TypeCheck(op, PyDateTimeAPI->TimeType)
	207	#define PyTime_CheckExact(op) ((op)->ob_type == PyDateTimeAPI->TimeType)
	208
	209	#define PyDelta_Check(op) PyObject_TypeCheck(op, PyDateTimeAPI->DeltaType)
	210	#define PyDelta_CheckExact(op) ((op)->ob_type == PyDateTimeAPI->DeltaType)
	211
	212	#define PyTZInfo_Check(op) PyObject_TypeCheck(op, PyDateTimeAPI->TZInfoType)
	213	#define PyTZInfo_CheckExact(op) ((op)->ob_type == PyDateTimeAPI->TZInfoType)
	214
	215	/* Macros for accessing constructors in a simplified fashion. */
	216	#define PyDate_FromDate(year, month, day) \
	217	PyDateTimeAPI->Date_FromDate(year, month, day, PyDateTimeAPI->DateType)
	218
	219	#define PyDateTime_FromDateAndTime(year, month, day, hour, min, sec, usec) \
	220	PyDateTimeAPI->DateTime_FromDateAndTime(year, month, day, hour, \
	221	min, sec, usec, Py_None, PyDateTimeAPI->DateTimeType)
	222
	223	#define PyTime_FromTime(hour, minute, second, usecond) \
	224	PyDateTimeAPI->Time_FromTime(hour, minute, second, usecond, \
	225	Py_None, PyDateTimeAPI->TimeType)
	226
	227	#define PyDelta_FromDSU(days, seconds, useconds) \
	228	PyDateTimeAPI->Delta_FromDelta(days, seconds, useconds, 1, \
	229	PyDateTimeAPI->DeltaType)
	230
	231	/* Macros supporting the DB API. */
	232	#define PyDateTime_FromTimestamp(args) \
	233	PyDateTimeAPI->DateTime_FromTimestamp( \
	234	(PyObject*) (PyDateTimeAPI->DateTimeType), args, NULL)
	235
	236	#define PyDate_FromTimestamp(args) \
	237	PyDateTimeAPI->Date_FromTimestamp( \
	238	(PyObject*) (PyDateTimeAPI->DateType), args)
	239
	240	#endif /* Py_BUILD_CORE */
	241
	242	#ifdef __cplusplus
	243	}
	244	#endif
	245	#endif

sys/src/cmd/python/Include/descrobject.h+91−0

@@ -0,0 +1,91 @@
	1	/* Descriptors */
	2	#ifndef Py_DESCROBJECT_H
	3	#define Py_DESCROBJECT_H
	4	#ifdef __cplusplus
	5	extern "C" {
	6	#endif
	7
	8	typedef PyObject (getter)(PyObject , void );
	9	typedef int (setter)(PyObject , PyObject , void );
	10
	11	typedef struct PyGetSetDef {
	12	char *name;
	13	getter get;
	14	setter set;
	15	char *doc;
	16	void *closure;
	17	} PyGetSetDef;
	18
	19	typedef PyObject (wrapperfunc)(PyObject self, PyObject args,
	20	void *wrapped);
	21
	22	typedef PyObject (wrapperfunc_kwds)(PyObject self, PyObject args,
	23	void wrapped, PyObject kwds);
	24
	25	struct wrapperbase {
	26	char *name;
	27	int offset;
	28	void *function;
	29	wrapperfunc wrapper;
	30	char *doc;
	31	int flags;
	32	PyObject *name_strobj;
	33	};
	34
	35	/* Flags for above struct */
	36	#define PyWrapperFlag_KEYWORDS 1 /* wrapper function takes keyword args */
	37
	38	/* Various kinds of descriptor objects */
	39
	40	#define PyDescr_COMMON \
	41	PyObject_HEAD \
	42	PyTypeObject *d_type; \
	43	PyObject *d_name
	44
	45	typedef struct {
	46	PyDescr_COMMON;
	47	} PyDescrObject;
	48
	49	typedef struct {
	50	PyDescr_COMMON;
	51	PyMethodDef *d_method;
	52	} PyMethodDescrObject;
	53
	54	typedef struct {
	55	PyDescr_COMMON;
	56	struct PyMemberDef *d_member;
	57	} PyMemberDescrObject;
	58
	59	typedef struct {
	60	PyDescr_COMMON;
	61	PyGetSetDef *d_getset;
	62	} PyGetSetDescrObject;
	63
	64	typedef struct {
	65	PyDescr_COMMON;
	66	struct wrapperbase *d_base;
	67	void d_wrapped; / This can be any function pointer */
	68	} PyWrapperDescrObject;
	69
	70	PyAPI_DATA(PyTypeObject) PyWrapperDescr_Type;
	71
	72	PyAPI_FUNC(PyObject ) PyDescr_NewMethod(PyTypeObject , PyMethodDef *);
	73	PyAPI_FUNC(PyObject ) PyDescr_NewClassMethod(PyTypeObject , PyMethodDef *);
	74	PyAPI_FUNC(PyObject ) PyDescr_NewMember(PyTypeObject ,
	75	struct PyMemberDef *);
	76	PyAPI_FUNC(PyObject ) PyDescr_NewGetSet(PyTypeObject ,
	77	struct PyGetSetDef *);
	78	PyAPI_FUNC(PyObject ) PyDescr_NewWrapper(PyTypeObject ,
	79	struct wrapperbase , void );
	80	#define PyDescr_IsData(d) ((d)->ob_type->tp_descr_set != NULL)
	81
	82	PyAPI_FUNC(PyObject ) PyDictProxy_New(PyObject );
	83	PyAPI_FUNC(PyObject ) PyWrapper_New(PyObject , PyObject *);
	84
	85
	86	PyAPI_DATA(PyTypeObject) PyProperty_Type;
	87	#ifdef __cplusplus
	88	}
	89	#endif
	90	#endif /* !Py_DESCROBJECT_H */
	91

sys/src/cmd/python/Include/dictobject.h+141−0

@@ -0,0 +1,141 @@
	1	#ifndef Py_DICTOBJECT_H
	2	#define Py_DICTOBJECT_H
	3	#ifdef __cplusplus
	4	extern "C" {
	5	#endif
	6
	7
	8	/* Dictionary object type -- mapping from hashable object to object */
	9
	10	/* The distribution includes a separate file, Objects/dictnotes.txt,
	11	describing explorations into dictionary design and optimization.
	12	It covers typical dictionary use patterns, the parameters for
	13	tuning dictionaries, and several ideas for possible optimizations.
	14	*/
	15
	16	/*
	17	There are three kinds of slots in the table:
	18
	19	1. Unused. me_key == me_value == NULL
	20	Does not hold an active (key, value) pair now and never did. Unused can
	21	transition to Active upon key insertion. This is the only case in which
	22	me_key is NULL, and is each slot's initial state.
	23
	24	2. Active. me_key != NULL and me_key != dummy and me_value != NULL
	25	Holds an active (key, value) pair. Active can transition to Dummy upon
	26	key deletion. This is the only case in which me_value != NULL.
	27
	28	3. Dummy. me_key == dummy and me_value == NULL
	29	Previously held an active (key, value) pair, but that was deleted and an
	30	active pair has not yet overwritten the slot. Dummy can transition to
	31	Active upon key insertion. Dummy slots cannot be made Unused again
	32	(cannot have me_key set to NULL), else the probe sequence in case of
	33	collision would have no way to know they were once active.
	34
	35	Note: .popitem() abuses the me_hash field of an Unused or Dummy slot to
	36	hold a search finger. The me_hash field of Unused or Dummy slots has no
	37	meaning otherwise.
	38	*/
	39
	40	/* PyDict_MINSIZE is the minimum size of a dictionary. This many slots are
	41	* allocated directly in the dict object (in the ma_smalltable member).
	42	* It must be a power of 2, and at least 4. 8 allows dicts with no more
	43	* than 5 active entries to live in ma_smalltable (and so avoid an
	44	* additional malloc); instrumentation suggested this suffices for the
	45	* majority of dicts (consisting mostly of usually-small instance dicts and
	46	* usually-small dicts created to pass keyword arguments).
	47	*/
	48	#define PyDict_MINSIZE 8
	49
	50	typedef struct {
	51	/* Cached hash code of me_key. Note that hash codes are C longs.
	52	* We have to use Py_ssize_t instead because dict_popitem() abuses
	53	* me_hash to hold a search finger.
	54	*/
	55	Py_ssize_t me_hash;
	56	PyObject *me_key;
	57	PyObject *me_value;
	58	} PyDictEntry;
	59
	60	/*
	61	To ensure the lookup algorithm terminates, there must be at least one Unused
	62	slot (NULL key) in the table.
	63	The value ma_fill is the number of non-NULL keys (sum of Active and Dummy);
	64	ma_used is the number of non-NULL, non-dummy keys (== the number of non-NULL
	65	values == the number of Active items).
	66	To avoid slowing down lookups on a near-full table, we resize the table when
	67	it's two-thirds full.
	68	*/
	69	typedef struct _dictobject PyDictObject;
	70	struct _dictobject {
	71	PyObject_HEAD
	72	Py_ssize_t ma_fill; /* # Active + # Dummy */
	73	Py_ssize_t ma_used; /* # Active */
	74
	75	/* The table contains ma_mask + 1 slots, and that's a power of 2.
	76	* We store the mask instead of the size because the mask is more
	77	* frequently needed.
	78	*/
	79	Py_ssize_t ma_mask;
	80
	81	/* ma_table points to ma_smalltable for small tables, else to
	82	* additional malloc'ed memory. ma_table is never NULL! This rule
	83	* saves repeated runtime null-tests in the workhorse getitem and
	84	* setitem calls.
	85	*/
	86	PyDictEntry *ma_table;
	87	PyDictEntry (ma_lookup)(PyDictObject mp, PyObject key, long hash);
	88	PyDictEntry ma_smalltable[PyDict_MINSIZE];
	89	};
	90
	91	PyAPI_DATA(PyTypeObject) PyDict_Type;
	92
	93	#define PyDict_Check(op) PyObject_TypeCheck(op, &PyDict_Type)
	94	#define PyDict_CheckExact(op) ((op)->ob_type == &PyDict_Type)
	95
	96	PyAPI_FUNC(PyObject *) PyDict_New(void);
	97	PyAPI_FUNC(PyObject ) PyDict_GetItem(PyObject mp, PyObject *key);
	98	PyAPI_FUNC(int) PyDict_SetItem(PyObject mp, PyObject key, PyObject *item);
	99	PyAPI_FUNC(int) PyDict_DelItem(PyObject mp, PyObject key);
	100	PyAPI_FUNC(void) PyDict_Clear(PyObject *mp);
	101	PyAPI_FUNC(int) PyDict_Next(
	102	PyObject mp, Py_ssize_t pos, PyObject key, PyObject value);
	103	PyAPI_FUNC(int) _PyDict_Next(
	104	PyObject mp, Py_ssize_t pos, PyObject key, PyObject value, long *hash);
	105	PyAPI_FUNC(PyObject ) PyDict_Keys(PyObject mp);
	106	PyAPI_FUNC(PyObject ) PyDict_Values(PyObject mp);
	107	PyAPI_FUNC(PyObject ) PyDict_Items(PyObject mp);
	108	PyAPI_FUNC(Py_ssize_t) PyDict_Size(PyObject *mp);
	109	PyAPI_FUNC(PyObject ) PyDict_Copy(PyObject mp);
	110	PyAPI_FUNC(int) PyDict_Contains(PyObject mp, PyObject key);
	111	PyAPI_FUNC(int) _PyDict_Contains(PyObject mp, PyObject key, long hash);
	112
	113	/* PyDict_Update(mp, other) is equivalent to PyDict_Merge(mp, other, 1). */
	114	PyAPI_FUNC(int) PyDict_Update(PyObject mp, PyObject other);
	115
	116	/* PyDict_Merge updates/merges from a mapping object (an object that
	117	supports PyMapping_Keys() and PyObject_GetItem()). If override is true,
	118	the last occurrence of a key wins, else the first. The Python
	119	dict.update(other) is equivalent to PyDict_Merge(dict, other, 1).
	120	*/
	121	PyAPI_FUNC(int) PyDict_Merge(PyObject *mp,
	122	PyObject *other,
	123	int override);
	124
	125	/* PyDict_MergeFromSeq2 updates/merges from an iterable object producing
	126	iterable objects of length 2. If override is true, the last occurrence
	127	of a key wins, else the first. The Python dict constructor dict(seq2)
	128	is equivalent to dict={}; PyDict_MergeFromSeq(dict, seq2, 1).
	129	*/
	130	PyAPI_FUNC(int) PyDict_MergeFromSeq2(PyObject *d,
	131	PyObject *seq2,
	132	int override);
	133
	134	PyAPI_FUNC(PyObject ) PyDict_GetItemString(PyObject dp, const char *key);
	135	PyAPI_FUNC(int) PyDict_SetItemString(PyObject dp, const char key, PyObject *item);
	136	PyAPI_FUNC(int) PyDict_DelItemString(PyObject dp, const char key);
	137
	138	#ifdef __cplusplus
	139	}
	140	#endif
	141	#endif /* !Py_DICTOBJECT_H */

sys/src/cmd/python/Include/enumobject.h+17−0

@@ -0,0 +1,17 @@
	1	#ifndef Py_ENUMOBJECT_H
	2	#define Py_ENUMOBJECT_H
	3
	4	/* Enumerate Object */
	5
	6	#ifdef __cplusplus
	7	extern "C" {
	8	#endif
	9
	10	PyAPI_DATA(PyTypeObject) PyEnum_Type;
	11	PyAPI_DATA(PyTypeObject) PyReversed_Type;
	12
	13	#ifdef __cplusplus
	14	}
	15	#endif
	16
	17	#endif /* !Py_ENUMOBJECT_H */

sys/src/cmd/python/Include/errcode.h+36−0

@@ -0,0 +1,36 @@
	1	#ifndef Py_ERRCODE_H
	2	#define Py_ERRCODE_H
	3	#ifdef __cplusplus
	4	extern "C" {
	5	#endif
	6
	7
	8	/* Error codes passed around between file input, tokenizer, parser and
	9	interpreter. This is necessary so we can turn them into Python
	10	exceptions at a higher level. Note that some errors have a
	11	slightly different meaning when passed from the tokenizer to the
	12	parser than when passed from the parser to the interpreter; e.g.
	13	the parser only returns E_EOF when it hits EOF immediately, and it
	14	never returns E_OK. */
	15
	16	#define E_OK 10 /* No error */
	17	#define E_EOF 11 /* End Of File */
	18	#define E_INTR 12 /* Interrupted */
	19	#define E_TOKEN 13 /* Bad token */
	20	#define E_SYNTAX 14 /* Syntax error */
	21	#define E_NOMEM 15 /* Ran out of memory */
	22	#define E_DONE 16 /* Parsing complete */
	23	#define E_ERROR 17 /* Execution error */
	24	#define E_TABSPACE 18 /* Inconsistent mixing of tabs and spaces */
	25	#define E_OVERFLOW 19 /* Node had too many children */
	26	#define E_TOODEEP 20 /* Too many indentation levels */
	27	#define E_DEDENT 21 /* No matching outer block for dedent */
	28	#define E_DECODE 22 /* Error in decoding into Unicode */
	29	#define E_EOFS 23 /* EOF in triple-quoted string */
	30	#define E_EOLS 24 /* EOL in single-quoted string */
	31	#define E_LINECONT 25 /* Unexpected characters after a line continuation */
	32
	33	#ifdef __cplusplus
	34	}
	35	#endif
	36	#endif /* !Py_ERRCODE_H */

sys/src/cmd/python/Include/eval.h+25−0

@@ -0,0 +1,25 @@
	1
	2	/* Interface to execute compiled code */
	3
	4	#ifndef Py_EVAL_H
	5	#define Py_EVAL_H
	6	#ifdef __cplusplus
	7	extern "C" {
	8	#endif
	9
	10	PyAPI_FUNC(PyObject ) PyEval_EvalCode(PyCodeObject , PyObject , PyObject );
	11
	12	PyAPI_FUNC(PyObject ) PyEval_EvalCodeEx(PyCodeObject co,
	13	PyObject *globals,
	14	PyObject *locals,
	15	PyObject **args, int argc,
	16	PyObject **kwds, int kwdc,
	17	PyObject **defs, int defc,
	18	PyObject *closure);
	19
	20	PyAPI_FUNC(PyObject ) _PyEval_CallTracing(PyObject func, PyObject *args);
	21
	22	#ifdef __cplusplus
	23	}
	24	#endif
	25	#endif /* !Py_EVAL_H */

sys/src/cmd/python/Include/fileobject.h+63−0

@@ -0,0 +1,63 @@
	1
	2	/* File object interface */
	3
	4	#ifndef Py_FILEOBJECT_H
	5	#define Py_FILEOBJECT_H
	6	#ifdef __cplusplus
	7	extern "C" {
	8	#endif
	9
	10	typedef struct {
	11	PyObject_HEAD
	12	FILE *f_fp;
	13	PyObject *f_name;
	14	PyObject *f_mode;
	15	int (f_close)(FILE );
	16	int f_softspace; /* Flag used by 'print' command */
	17	int f_binary; /* Flag which indicates whether the file is
	18	open in binary (1) or text (0) mode */
	19	char* f_buf; /* Allocated readahead buffer */
	20	char* f_bufend; /* Points after last occupied position */
	21	char* f_bufptr; /* Current buffer position */
	22	char f_setbuf; / Buffer for setbuf(3) and setvbuf(3) */
	23	int f_univ_newline; /* Handle any newline convention */
	24	int f_newlinetypes; /* Types of newlines seen */
	25	int f_skipnextlf; /* Skip next \n */
	26	PyObject *f_encoding;
	27	PyObject weakreflist; / List of weak references */
	28	} PyFileObject;
	29
	30	PyAPI_DATA(PyTypeObject) PyFile_Type;
	31
	32	#define PyFile_Check(op) PyObject_TypeCheck(op, &PyFile_Type)
	33	#define PyFile_CheckExact(op) ((op)->ob_type == &PyFile_Type)
	34
	35	PyAPI_FUNC(PyObject ) PyFile_FromString(char , char *);
	36	PyAPI_FUNC(void) PyFile_SetBufSize(PyObject *, int);
	37	PyAPI_FUNC(int) PyFile_SetEncoding(PyObject , const char );
	38	PyAPI_FUNC(PyObject ) PyFile_FromFile(FILE , char , char ,
	39	int ()(FILE ));
	40	PyAPI_FUNC(FILE ) PyFile_AsFile(PyObject );
	41	PyAPI_FUNC(PyObject ) PyFile_Name(PyObject );
	42	PyAPI_FUNC(PyObject ) PyFile_GetLine(PyObject , int);
	43	PyAPI_FUNC(int) PyFile_WriteObject(PyObject , PyObject , int);
	44	PyAPI_FUNC(int) PyFile_SoftSpace(PyObject *, int);
	45	PyAPI_FUNC(int) PyFile_WriteString(const char , PyObject );
	46	PyAPI_FUNC(int) PyObject_AsFileDescriptor(PyObject *);
	47
	48	/* The default encoding used by the platform file system APIs
	49	If non-NULL, this is different than the default encoding for strings
	50	*/
	51	PyAPI_DATA(const char *) Py_FileSystemDefaultEncoding;
	52
	53	/* Routines to replace fread() and fgets() which accept any of \r, \n
	54	or \r\n as line terminators.
	55	*/
	56	#define PY_STDIOTEXTMODE "b"
	57	char Py_UniversalNewlineFgets(char , int, FILE, PyObject );
	58	size_t Py_UniversalNewlineFread(char , size_t, FILE , PyObject *);
	59
	60	#ifdef __cplusplus
	61	}
	62	#endif
	63	#endif /* !Py_FILEOBJECT_H */

sys/src/cmd/python/Include/floatobject.h+100−0

@@ -0,0 +1,100 @@
	1
	2	/* Float object interface */
	3
	4	/*
	5	PyFloatObject represents a (double precision) floating point number.
	6	*/
	7
	8	#ifndef Py_FLOATOBJECT_H
	9	#define Py_FLOATOBJECT_H
	10	#ifdef __cplusplus
	11	extern "C" {
	12	#endif
	13
	14	typedef struct {
	15	PyObject_HEAD
	16	double ob_fval;
	17	} PyFloatObject;
	18
	19	PyAPI_DATA(PyTypeObject) PyFloat_Type;
	20
	21	#define PyFloat_Check(op) PyObject_TypeCheck(op, &PyFloat_Type)
	22	#define PyFloat_CheckExact(op) ((op)->ob_type == &PyFloat_Type)
	23
	24	/* Return Python float from string PyObject. Second argument ignored on
	25	input, and, if non-NULL, NULL is stored into *junk (this tried to serve a
	26	purpose once but can't be made to work as intended). */
	27	PyAPI_FUNC(PyObject ) PyFloat_FromString(PyObject, char** junk);
	28
	29	/* Return Python float from C double. */
	30	PyAPI_FUNC(PyObject *) PyFloat_FromDouble(double);
	31
	32	/* Extract C double from Python float. The macro version trades safety for
	33	speed. */
	34	PyAPI_FUNC(double) PyFloat_AsDouble(PyObject *);
	35	#define PyFloat_AS_DOUBLE(op) (((PyFloatObject *)(op))->ob_fval)
	36
	37	/* Write repr(v) into the char buffer argument, followed by null byte. The
	38	buffer must be "big enough"; >= 100 is very safe.
	39	PyFloat_AsReprString(buf, x) strives to print enough digits so that
	40	PyFloat_FromString(buf) then reproduces x exactly. */
	41	PyAPI_FUNC(void) PyFloat_AsReprString(char, PyFloatObject v);
	42
	43	/* Write str(v) into the char buffer argument, followed by null byte. The
	44	buffer must be "big enough"; >= 100 is very safe. Note that it's
	45	unusual to be able to get back the float you started with from
	46	PyFloat_AsString's result -- use PyFloat_AsReprString() if you want to
	47	preserve precision across conversions. */
	48	PyAPI_FUNC(void) PyFloat_AsString(char, PyFloatObject v);
	49
	50	/* _PyFloat_{Pack,Unpack}{4,8}
	51	*
	52	* The struct and pickle (at least) modules need an efficient platform-
	53	* independent way to store floating-point values as byte strings.
	54	* The Pack routines produce a string from a C double, and the Unpack
	55	* routines produce a C double from such a string. The suffix (4 or 8)
	56	* specifies the number of bytes in the string.
	57	*
	58	* On platforms that appear to use (see _PyFloat_Init()) IEEE-754 formats
	59	* these functions work by copying bits. On other platforms, the formats the
	60	* 4- byte format is identical to the IEEE-754 single precision format, and
	61	* the 8-byte format to the IEEE-754 double precision format, although the
	62	* packing of INFs and NaNs (if such things exist on the platform) isn't
	63	* handled correctly, and attempting to unpack a string containing an IEEE
	64	* INF or NaN will raise an exception.
	65	*
	66	* On non-IEEE platforms with more precision, or larger dynamic range, than
	67	* 754 supports, not all values can be packed; on non-IEEE platforms with less
	68	* precision, or smaller dynamic range, not all values can be unpacked. What
	69	* happens in such cases is partly accidental (alas).
	70	*/
	71
	72	/* The pack routines write 4 or 8 bytes, starting at p. le is a bool
	73	* argument, true if you want the string in little-endian format (exponent
	74	* last, at p+3 or p+7), false if you want big-endian format (exponent
	75	* first, at p).
	76	* Return value: 0 if all is OK, -1 if error (and an exception is
	77	* set, most likely OverflowError).
	78	* There are two problems on non-IEEE platforms:
	79	* 1): What this does is undefined if x is a NaN or infinity.
	80	* 2): -0.0 and +0.0 produce the same string.
	81	*/
	82	PyAPI_FUNC(int) _PyFloat_Pack4(double x, unsigned char *p, int le);
	83	PyAPI_FUNC(int) _PyFloat_Pack8(double x, unsigned char *p, int le);
	84
	85	/* The unpack routines read 4 or 8 bytes, starting at p. le is a bool
	86	* argument, true if the string is in little-endian format (exponent
	87	* last, at p+3 or p+7), false if big-endian (exponent first, at p).
	88	* Return value: The unpacked double. On error, this is -1.0 and
	89	* PyErr_Occurred() is true (and an exception is set, most likely
	90	* OverflowError). Note that on a non-IEEE platform this will refuse
	91	* to unpack a string that represents a NaN or infinity.
	92	*/
	93	PyAPI_FUNC(double) _PyFloat_Unpack4(const unsigned char *p, int le);
	94	PyAPI_FUNC(double) _PyFloat_Unpack8(const unsigned char *p, int le);
	95
	96
	97	#ifdef __cplusplus
	98	}
	99	#endif
	100	#endif /* !Py_FLOATOBJECT_H */

sys/src/cmd/python/Include/frameobject.h+81−0

@@ -0,0 +1,81 @@
	1
	2	/* Frame object interface */
	3
	4	#ifndef Py_FRAMEOBJECT_H
	5	#define Py_FRAMEOBJECT_H
	6	#ifdef __cplusplus
	7	extern "C" {
	8	#endif
	9
	10	typedef struct {
	11	int b_type; /* what kind of block this is */
	12	int b_handler; /* where to jump to find handler */
	13	int b_level; /* value stack level to pop to */
	14	} PyTryBlock;
	15
	16	typedef struct _frame {
	17	PyObject_VAR_HEAD
	18	struct _frame f_back; / previous frame, or NULL */
	19	PyCodeObject f_code; / code segment */
	20	PyObject f_builtins; / builtin symbol table (PyDictObject) */
	21	PyObject f_globals; / global symbol table (PyDictObject) */
	22	PyObject f_locals; / local symbol table (any mapping) */
	23	PyObject *f_valuestack; / points after the last local */
	24	/* Next free slot in f_valuestack. Frame creation sets to f_valuestack.
	25	Frame evaluation usually NULLs it, but a frame that yields sets it
	26	to the current stack top. */
	27	PyObject **f_stacktop;
	28	PyObject f_trace; / Trace function */
	29
	30	/* If an exception is raised in this frame, the next three are used to
	31	* record the exception info (if any) originally in the thread state. See
	32	* comments before set_exc_info() -- it's not obvious.
	33	* Invariant: if _type is NULL, then so are _value and _traceback.
	34	* Desired invariant: all three are NULL, or all three are non-NULL. That
	35	* one isn't currently true, but "should be".
	36	*/
	37	PyObject f_exc_type, f_exc_value, *f_exc_traceback;
	38
	39	PyThreadState *f_tstate;
	40	int f_lasti; /* Last instruction if called */
	41	/* As of 2.3 f_lineno is only valid when tracing is active (i.e. when
	42	f_trace is set) -- at other times use PyCode_Addr2Line instead. */
	43	int f_lineno; /* Current line number */
	44	int f_iblock; /* index in f_blockstack */
	45	PyTryBlock f_blockstack[CO_MAXBLOCKS]; /* for try and loop blocks */
	46	PyObject f_localsplus[1]; / locals+stack, dynamically sized */
	47	} PyFrameObject;
	48
	49
	50	/* Standard object interface */
	51
	52	PyAPI_DATA(PyTypeObject) PyFrame_Type;
	53
	54	#define PyFrame_Check(op) ((op)->ob_type == &PyFrame_Type)
	55	#define PyFrame_IsRestricted(f) \
	56	((f)->f_builtins != (f)->f_tstate->interp->builtins)
	57
	58	PyAPI_FUNC(PyFrameObject ) PyFrame_New(PyThreadState , PyCodeObject *,
	59	PyObject , PyObject );
	60
	61
	62	/* The rest of the interface is specific for frame objects */
	63
	64	/* Block management functions */
	65
	66	PyAPI_FUNC(void) PyFrame_BlockSetup(PyFrameObject *, int, int, int);
	67	PyAPI_FUNC(PyTryBlock ) PyFrame_BlockPop(PyFrameObject );
	68
	69	/* Extend the value stack */
	70
	71	PyAPI_FUNC(PyObject *) PyFrame_ExtendStack(PyFrameObject , int, int);
	72
	73	/* Conversions between "fast locals" and locals in dictionary */
	74
	75	PyAPI_FUNC(void) PyFrame_LocalsToFast(PyFrameObject *, int);
	76	PyAPI_FUNC(void) PyFrame_FastToLocals(PyFrameObject *);
	77
	78	#ifdef __cplusplus
	79	}
	80	#endif
	81	#endif /* !Py_FRAMEOBJECT_H */

sys/src/cmd/python/Include/funcobject.h+76−0

@@ -0,0 +1,76 @@
	1
	2	/* Function object interface */
	3
	4	#ifndef Py_FUNCOBJECT_H
	5	#define Py_FUNCOBJECT_H
	6	#ifdef __cplusplus
	7	extern "C" {
	8	#endif
	9
	10	/* Function objects and code objects should not be confused with each other:
	11	*
	12	* Function objects are created by the execution of the 'def' statement.
	13	* They reference a code object in their func_code attribute, which is a
	14	* purely syntactic object, i.e. nothing more than a compiled version of some
	15	* source code lines. There is one code object per source code "fragment",
	16	* but each code object can be referenced by zero or many function objects
	17	* depending only on how many times the 'def' statement in the source was
	18	* executed so far.
	19	*/
	20
	21	typedef struct {
	22	PyObject_HEAD
	23	PyObject func_code; / A code object */
	24	PyObject func_globals; / A dictionary (other mappings won't do) */
	25	PyObject func_defaults; / NULL or a tuple */
	26	PyObject func_closure; / NULL or a tuple of cell objects */
	27	PyObject func_doc; / The __doc__ attribute, can be anything */
	28	PyObject func_name; / The __name__ attribute, a string object */
	29	PyObject func_dict; / The __dict__ attribute, a dict or NULL */
	30	PyObject func_weakreflist; / List of weak references */
	31	PyObject func_module; / The __module__ attribute, can be anything */
	32
	33	/* Invariant:
	34	* func_closure contains the bindings for func_code->co_freevars, so
	35	* PyTuple_Size(func_closure) == PyCode_GetNumFree(func_code)
	36	* (func_closure may be NULL if PyCode_GetNumFree(func_code) == 0).
	37	*/
	38	} PyFunctionObject;
	39
	40	PyAPI_DATA(PyTypeObject) PyFunction_Type;
	41
	42	#define PyFunction_Check(op) ((op)->ob_type == &PyFunction_Type)
	43
	44	PyAPI_FUNC(PyObject ) PyFunction_New(PyObject , PyObject *);
	45	PyAPI_FUNC(PyObject ) PyFunction_GetCode(PyObject );
	46	PyAPI_FUNC(PyObject ) PyFunction_GetGlobals(PyObject );
	47	PyAPI_FUNC(PyObject ) PyFunction_GetModule(PyObject );
	48	PyAPI_FUNC(PyObject ) PyFunction_GetDefaults(PyObject );
	49	PyAPI_FUNC(int) PyFunction_SetDefaults(PyObject , PyObject );
	50	PyAPI_FUNC(PyObject ) PyFunction_GetClosure(PyObject );
	51	PyAPI_FUNC(int) PyFunction_SetClosure(PyObject , PyObject );
	52
	53	/* Macros for direct access to these values. Type checks are not
	54	done, so use with care. */
	55	#define PyFunction_GET_CODE(func) \
	56	(((PyFunctionObject *)func) -> func_code)
	57	#define PyFunction_GET_GLOBALS(func) \
	58	(((PyFunctionObject *)func) -> func_globals)
	59	#define PyFunction_GET_MODULE(func) \
	60	(((PyFunctionObject *)func) -> func_module)
	61	#define PyFunction_GET_DEFAULTS(func) \
	62	(((PyFunctionObject *)func) -> func_defaults)
	63	#define PyFunction_GET_CLOSURE(func) \
	64	(((PyFunctionObject *)func) -> func_closure)
	65
	66	/* The classmethod and staticmethod types lives here, too */
	67	PyAPI_DATA(PyTypeObject) PyClassMethod_Type;
	68	PyAPI_DATA(PyTypeObject) PyStaticMethod_Type;
	69
	70	PyAPI_FUNC(PyObject ) PyClassMethod_New(PyObject );
	71	PyAPI_FUNC(PyObject ) PyStaticMethod_New(PyObject );
	72
	73	#ifdef __cplusplus
	74	}
	75	#endif
	76	#endif /* !Py_FUNCOBJECT_H */

sys/src/cmd/python/Include/genobject.h+37−0

@@ -0,0 +1,37 @@
	1
	2	/* Generator object interface */
	3
	4	#ifndef Py_GENOBJECT_H
	5	#define Py_GENOBJECT_H
	6	#ifdef __cplusplus
	7	extern "C" {
	8	#endif
	9
	10	struct _frame; /* Avoid including frameobject.h */
	11
	12	typedef struct {
	13	PyObject_HEAD
	14	/* The gi_ prefix is intended to remind of generator-iterator. */
	15
	16	/* Note: gi_frame can be NULL if the generator is "finished" */
	17	struct _frame *gi_frame;
	18
	19	/* True if generator is being executed. */
	20	int gi_running;
	21
	22	/* List of weak reference. */
	23	PyObject *gi_weakreflist;
	24	} PyGenObject;
	25
	26	PyAPI_DATA(PyTypeObject) PyGen_Type;
	27
	28	#define PyGen_Check(op) PyObject_TypeCheck(op, &PyGen_Type)
	29	#define PyGen_CheckExact(op) ((op)->ob_type == &PyGen_Type)
	30
	31	PyAPI_FUNC(PyObject ) PyGen_New(struct _frame );
	32	PyAPI_FUNC(int) PyGen_NeedsFinalizing(PyGenObject *);
	33
	34	#ifdef __cplusplus
	35	}
	36	#endif
	37	#endif /* !Py_GENOBJECT_H */

sys/src/cmd/python/Include/graminit.h+84−0

@@ -0,0 +1,84 @@
	1	#define single_input 256
	2	#define file_input 257
	3	#define eval_input 258
	4	#define decorator 259
	5	#define decorators 260
	6	#define funcdef 261
	7	#define parameters 262
	8	#define varargslist 263
	9	#define fpdef 264
	10	#define fplist 265
	11	#define stmt 266
	12	#define simple_stmt 267
	13	#define small_stmt 268
	14	#define expr_stmt 269
	15	#define augassign 270
	16	#define print_stmt 271
	17	#define del_stmt 272
	18	#define pass_stmt 273
	19	#define flow_stmt 274
	20	#define break_stmt 275
	21	#define continue_stmt 276
	22	#define return_stmt 277
	23	#define yield_stmt 278
	24	#define raise_stmt 279
	25	#define import_stmt 280
	26	#define import_name 281
	27	#define import_from 282
	28	#define import_as_name 283
	29	#define dotted_as_name 284
	30	#define import_as_names 285
	31	#define dotted_as_names 286
	32	#define dotted_name 287
	33	#define global_stmt 288
	34	#define exec_stmt 289
	35	#define assert_stmt 290
	36	#define compound_stmt 291
	37	#define if_stmt 292
	38	#define while_stmt 293
	39	#define for_stmt 294
	40	#define try_stmt 295
	41	#define with_stmt 296
	42	#define with_var 297
	43	#define except_clause 298
	44	#define suite 299
	45	#define testlist_safe 300
	46	#define old_test 301
	47	#define old_lambdef 302
	48	#define test 303
	49	#define or_test 304
	50	#define and_test 305
	51	#define not_test 306
	52	#define comparison 307
	53	#define comp_op 308
	54	#define expr 309
	55	#define xor_expr 310
	56	#define and_expr 311
	57	#define shift_expr 312
	58	#define arith_expr 313
	59	#define term 314
	60	#define factor 315
	61	#define power 316
	62	#define atom 317
	63	#define listmaker 318
	64	#define testlist_gexp 319
	65	#define lambdef 320
	66	#define trailer 321
	67	#define subscriptlist 322
	68	#define subscript 323
	69	#define sliceop 324
	70	#define exprlist 325
	71	#define testlist 326
	72	#define dictmaker 327
	73	#define classdef 328
	74	#define arglist 329
	75	#define argument 330
	76	#define list_iter 331
	77	#define list_for 332
	78	#define list_if 333
	79	#define gen_iter 334
	80	#define gen_for 335
	81	#define gen_if 336
	82	#define testlist1 337
	83	#define encoding_decl 338
	84	#define yield_expr 339

sys/src/cmd/python/Include/grammar.h+93−0

@@ -0,0 +1,93 @@
	1
	2	/* Grammar interface */
	3
	4	#ifndef Py_GRAMMAR_H
	5	#define Py_GRAMMAR_H
	6	#ifdef __cplusplus
	7	extern "C" {
	8	#endif
	9
	10	#include "bitset.h" /* Sigh... */
	11
	12	/* A label of an arc */
	13
	14	typedef struct {
	15	int lb_type;
	16	char *lb_str;
	17	} label;
	18
	19	#define EMPTY 0 /* Label number 0 is by definition the empty label */
	20
	21	/* A list of labels */
	22
	23	typedef struct {
	24	int ll_nlabels;
	25	label *ll_label;
	26	} labellist;
	27
	28	/* An arc from one state to another */
	29
	30	typedef struct {
	31	short a_lbl; /* Label of this arc */
	32	short a_arrow; /* State where this arc goes to */
	33	} arc;
	34
	35	/* A state in a DFA */
	36
	37	typedef struct {
	38	int s_narcs;
	39	arc s_arc; / Array of arcs */
	40
	41	/* Optional accelerators */
	42	int s_lower; /* Lowest label index */
	43	int s_upper; /* Highest label index */
	44	int s_accel; / Accelerator */
	45	int s_accept; /* Nonzero for accepting state */
	46	} state;
	47
	48	/* A DFA */
	49
	50	typedef struct {
	51	int d_type; /* Non-terminal this represents */
	52	char d_name; / For printing */
	53	int d_initial; /* Initial state */
	54	int d_nstates;
	55	state d_state; / Array of states */
	56	bitset d_first;
	57	} dfa;
	58
	59	/* A grammar */
	60
	61	typedef struct {
	62	int g_ndfas;
	63	dfa g_dfa; / Array of DFAs */
	64	labellist g_ll;
	65	int g_start; /* Start symbol of the grammar */
	66	int g_accel; /* Set if accelerators present */
	67	} grammar;
	68
	69	/* FUNCTIONS */
	70
	71	grammar *newgrammar(int start);
	72	dfa adddfa(grammar g, int type, char *name);
	73	int addstate(dfa *d);
	74	void addarc(dfa *d, int from, int to, int lbl);
	75	dfa PyGrammar_FindDFA(grammar g, int type);
	76
	77	int addlabel(labellist ll, int type, char str);
	78	int findlabel(labellist ll, int type, char str);
	79	char PyGrammar_LabelRepr(label lb);
	80	void translatelabels(grammar *g);
	81
	82	void addfirstsets(grammar *g);
	83
	84	void PyGrammar_AddAccelerators(grammar *g);
	85	void PyGrammar_RemoveAccelerators(grammar *);
	86
	87	void printgrammar(grammar g, FILE fp);
	88	void printnonterminals(grammar g, FILE fp);
	89
	90	#ifdef __cplusplus
	91	}
	92	#endif
	93	#endif /* !Py_GRAMMAR_H */

sys/src/cmd/python/Include/import.h+64−0

@@ -0,0 +1,64 @@
	1
	2	/* Module definition and import interface */
	3
	4	#ifndef Py_IMPORT_H
	5	#define Py_IMPORT_H
	6	#ifdef __cplusplus
	7	extern "C" {
	8	#endif
	9
	10	PyAPI_FUNC(long) PyImport_GetMagicNumber(void);
	11	PyAPI_FUNC(PyObject ) PyImport_ExecCodeModule(char name, PyObject *co);
	12	PyAPI_FUNC(PyObject *) PyImport_ExecCodeModuleEx(
	13	char name, PyObject co, char *pathname);
	14	PyAPI_FUNC(PyObject *) PyImport_GetModuleDict(void);
	15	PyAPI_FUNC(PyObject ) PyImport_AddModule(const char name);
	16	PyAPI_FUNC(PyObject ) PyImport_ImportModule(const char name);
	17	PyAPI_FUNC(PyObject ) PyImport_ImportModuleLevel(char name,
	18	PyObject globals, PyObject locals, PyObject *fromlist, int level);
	19
	20	/* For DLL compatibility */
	21	#undef PyImport_ImportModuleEx
	22	PyAPI_FUNC(PyObject *) PyImport_ImportModuleEx(
	23	char name, PyObject globals, PyObject locals, PyObject fromlist);
	24	#define PyImport_ImportModuleEx(n, g, l, f) \
	25	PyImport_ImportModuleLevel(n, g, l, f, -1)
	26
	27	PyAPI_FUNC(PyObject ) PyImport_Import(PyObject name);
	28	PyAPI_FUNC(PyObject ) PyImport_ReloadModule(PyObject m);
	29	PyAPI_FUNC(void) PyImport_Cleanup(void);
	30	PyAPI_FUNC(int) PyImport_ImportFrozenModule(char *);
	31
	32	PyAPI_FUNC(struct filedescr *) _PyImport_FindModule(
	33	const char , PyObject , char , size_t, FILE , PyObject *);
	34	PyAPI_FUNC(int) _PyImport_IsScript(struct filedescr *);
	35	PyAPI_FUNC(void) _PyImport_ReInitLock(void);
	36
	37	PyAPI_FUNC(PyObject )_PyImport_FindExtension(char , char *);
	38	PyAPI_FUNC(PyObject )_PyImport_FixupExtension(char , char *);
	39
	40	struct _inittab {
	41	char *name;
	42	void (*initfunc)(void);
	43	};
	44
	45	PyAPI_DATA(struct _inittab *) PyImport_Inittab;
	46
	47	PyAPI_FUNC(int) PyImport_AppendInittab(char name, void (initfunc)(void));
	48	PyAPI_FUNC(int) PyImport_ExtendInittab(struct _inittab *newtab);
	49
	50	struct _frozen {
	51	char *name;
	52	unsigned char *code;
	53	int size;
	54	};
	55
	56	/* Embedding apps may change this pointer to point to their favorite
	57	collection of frozen modules: */
	58
	59	PyAPI_DATA(struct _frozen *) PyImport_FrozenModules;
	60
	61	#ifdef __cplusplus
	62	}
	63	#endif
	64	#endif /* !Py_IMPORT_H */

sys/src/cmd/python/Include/intobject.h+64−0

@@ -0,0 +1,64 @@
	1
	2	/* Integer object interface */
	3
	4	/*
	5	PyIntObject represents a (long) integer. This is an immutable object;
	6	an integer cannot change its value after creation.
	7
	8	There are functions to create new integer objects, to test an object
	9	for integer-ness, and to get the integer value. The latter functions
	10	returns -1 and sets errno to EBADF if the object is not an PyIntObject.
	11	None of the functions should be applied to nil objects.
	12
	13	The type PyIntObject is (unfortunately) exposed here so we can declare
	14	_Py_TrueStruct and _Py_ZeroStruct in boolobject.h; don't use this.
	15	*/
	16
	17	#ifndef Py_INTOBJECT_H
	18	#define Py_INTOBJECT_H
	19	#ifdef __cplusplus
	20	extern "C" {
	21	#endif
	22
	23	typedef struct {
	24	PyObject_HEAD
	25	long ob_ival;
	26	} PyIntObject;
	27
	28	PyAPI_DATA(PyTypeObject) PyInt_Type;
	29
	30	#define PyInt_Check(op) PyObject_TypeCheck(op, &PyInt_Type)
	31	#define PyInt_CheckExact(op) ((op)->ob_type == &PyInt_Type)
	32
	33	PyAPI_FUNC(PyObject ) PyInt_FromString(char, char**, int);
	34	#ifdef Py_USING_UNICODE
	35	PyAPI_FUNC(PyObject ) PyInt_FromUnicode(Py_UNICODE, Py_ssize_t, int);
	36	#endif
	37	PyAPI_FUNC(PyObject *) PyInt_FromLong(long);
	38	PyAPI_FUNC(PyObject *) PyInt_FromSize_t(size_t);
	39	PyAPI_FUNC(PyObject *) PyInt_FromSsize_t(Py_ssize_t);
	40	PyAPI_FUNC(long) PyInt_AsLong(PyObject *);
	41	PyAPI_FUNC(Py_ssize_t) PyInt_AsSsize_t(PyObject *);
	42	PyAPI_FUNC(unsigned long) PyInt_AsUnsignedLongMask(PyObject *);
	43	#ifdef HAVE_LONG_LONG
	44	PyAPI_FUNC(unsigned PY_LONG_LONG) PyInt_AsUnsignedLongLongMask(PyObject *);
	45	#endif
	46
	47	PyAPI_FUNC(long) PyInt_GetMax(void);
	48
	49	/* Macro, trading safety for speed */
	50	#define PyInt_AS_LONG(op) (((PyIntObject *)(op))->ob_ival)
	51
	52	/* These aren't really part of the Int object, but they're handy; the protos
	53	* are necessary for systems that need the magic of PyAPI_FUNC and that want
	54	* to have stropmodule as a dynamically loaded module instead of building it
	55	* into the main Python shared library/DLL. Guido thinks I'm weird for
	56	* building it this way. :-) [cjh]
	57	*/
	58	PyAPI_FUNC(unsigned long) PyOS_strtoul(char , char *, int);
	59	PyAPI_FUNC(long) PyOS_strtol(char , char *, int);
	60
	61	#ifdef __cplusplus
	62	}
	63	#endif
	64	#endif /* !Py_INTOBJECT_H */

sys/src/cmd/python/Include/intrcheck.h+15−0

@@ -0,0 +1,15 @@
	1
	2	#ifndef Py_INTRCHECK_H
	3	#define Py_INTRCHECK_H
	4	#ifdef __cplusplus
	5	extern "C" {
	6	#endif
	7
	8	PyAPI_FUNC(int) PyOS_InterruptOccurred(void);
	9	PyAPI_FUNC(void) PyOS_InitInterrupts(void);
	10	PyAPI_FUNC(void) PyOS_AfterFork(void);
	11
	12	#ifdef __cplusplus
	13	}
	14	#endif
	15	#endif /* !Py_INTRCHECK_H */

sys/src/cmd/python/Include/iterobject.h+23−0

@@ -0,0 +1,23 @@
	1	#ifndef Py_ITEROBJECT_H
	2	#define Py_ITEROBJECT_H
	3	/* Iterators (the basic kind, over a sequence) */
	4	#ifdef __cplusplus
	5	extern "C" {
	6	#endif
	7
	8	PyAPI_DATA(PyTypeObject) PySeqIter_Type;
	9
	10	#define PySeqIter_Check(op) ((op)->ob_type == &PySeqIter_Type)
	11
	12	PyAPI_FUNC(PyObject ) PySeqIter_New(PyObject );
	13
	14	PyAPI_DATA(PyTypeObject) PyCallIter_Type;
	15
	16	#define PyCallIter_Check(op) ((op)->ob_type == &PyCallIter_Type)
	17
	18	PyAPI_FUNC(PyObject ) PyCallIter_New(PyObject , PyObject *);
	19	#ifdef __cplusplus
	20	}
	21	#endif
	22	#endif /* !Py_ITEROBJECT_H */
	23

sys/src/cmd/python/Include/listobject.h+67−0

@@ -0,0 +1,67 @@
	1
	2	/* List object interface */
	3
	4	/*
	5	Another generally useful object type is an list of object pointers.
	6	This is a mutable type: the list items can be changed, and items can be
	7	added or removed. Out-of-range indices or non-list objects are ignored.
	8
	9	* WARNING * PyList_SetItem does not increment the new item's reference
	10	count, but does decrement the reference count of the item it replaces,
	11	if not nil. It does decrement the reference count if it is not
	12	inserted in the list. Similarly, PyList_GetItem does not increment the
	13	returned item's reference count.
	14	*/
	15
	16	#ifndef Py_LISTOBJECT_H
	17	#define Py_LISTOBJECT_H
	18	#ifdef __cplusplus
	19	extern "C" {
	20	#endif
	21
	22	typedef struct {
	23	PyObject_VAR_HEAD
	24	/* Vector of pointers to list elements. list[0] is ob_item[0], etc. */
	25	PyObject **ob_item;
	26
	27	/* ob_item contains space for 'allocated' elements. The number
	28	* currently in use is ob_size.
	29	* Invariants:
	30	* 0 <= ob_size <= allocated
	31	* len(list) == ob_size
	32	* ob_item == NULL implies ob_size == allocated == 0
	33	* list.sort() temporarily sets allocated to -1 to detect mutations.
	34	*
	35	* Items must normally not be NULL, except during construction when
	36	* the list is not yet visible outside the function that builds it.
	37	*/
	38	Py_ssize_t allocated;
	39	} PyListObject;
	40
	41	PyAPI_DATA(PyTypeObject) PyList_Type;
	42
	43	#define PyList_Check(op) PyObject_TypeCheck(op, &PyList_Type)
	44	#define PyList_CheckExact(op) ((op)->ob_type == &PyList_Type)
	45
	46	PyAPI_FUNC(PyObject *) PyList_New(Py_ssize_t size);
	47	PyAPI_FUNC(Py_ssize_t) PyList_Size(PyObject *);
	48	PyAPI_FUNC(PyObject ) PyList_GetItem(PyObject , Py_ssize_t);
	49	PyAPI_FUNC(int) PyList_SetItem(PyObject , Py_ssize_t, PyObject );
	50	PyAPI_FUNC(int) PyList_Insert(PyObject , Py_ssize_t, PyObject );
	51	PyAPI_FUNC(int) PyList_Append(PyObject , PyObject );
	52	PyAPI_FUNC(PyObject ) PyList_GetSlice(PyObject , Py_ssize_t, Py_ssize_t);
	53	PyAPI_FUNC(int) PyList_SetSlice(PyObject , Py_ssize_t, Py_ssize_t, PyObject );
	54	PyAPI_FUNC(int) PyList_Sort(PyObject *);
	55	PyAPI_FUNC(int) PyList_Reverse(PyObject *);
	56	PyAPI_FUNC(PyObject ) PyList_AsTuple(PyObject );
	57	PyAPI_FUNC(PyObject ) _PyList_Extend(PyListObject , PyObject *);
	58
	59	/* Macro, trading safety for speed */
	60	#define PyList_GET_ITEM(op, i) (((PyListObject *)(op))->ob_item[i])
	61	#define PyList_SET_ITEM(op, i, v) (((PyListObject *)(op))->ob_item[i] = (v))
	62	#define PyList_GET_SIZE(op) (((PyListObject *)(op))->ob_size)
	63
	64	#ifdef __cplusplus
	65	}
	66	#endif
	67	#endif /* !Py_LISTOBJECT_H */

sys/src/cmd/python/Include/longintrepr.h+63−0

@@ -0,0 +1,63 @@
	1	#ifndef Py_LONGINTREPR_H
	2	#define Py_LONGINTREPR_H
	3	#ifdef __cplusplus
	4	extern "C" {
	5	#endif
	6
	7
	8	/* This is published for the benefit of "friend" marshal.c only. */
	9
	10	/* Parameters of the long integer representation.
	11	These shouldn't have to be changed as C should guarantee that a short
	12	contains at least 16 bits, but it's made changeable anyway.
	13	Note: 'digit' should be able to hold 2*MASK+1, and 'twodigits'
	14	should be able to hold the intermediate results in 'mul'
	15	(at most (BASE-1)(2BASE+1) == MASK(2MASK+3)).
	16	Also, x_sub assumes that 'digit' is an unsigned type, and overflow
	17	is handled by taking the result mod 2**N for some N > SHIFT.
	18	And, at some places it is assumed that MASK fits in an int, as well.
	19	long_pow() requires that SHIFT be divisible by 5. */
	20
	21	typedef unsigned short digit;
	22	typedef unsigned int wdigit; /* digit widened to parameter size */
	23	#define BASE_TWODIGITS_TYPE long
	24	typedef unsigned BASE_TWODIGITS_TYPE twodigits;
	25	typedef BASE_TWODIGITS_TYPE stwodigits; /* signed variant of twodigits */
	26
	27	#define SHIFT 15
	28	#define BASE ((digit)1 << SHIFT)
	29	#define MASK ((int)(BASE - 1))
	30
	31	#if SHIFT % 5 != 0
	32	#error "longobject.c requires that SHIFT be divisible by 5"
	33	#endif
	34
	35	/* Long integer representation.
	36	The absolute value of a number is equal to
	37	SUM(for i=0 through abs(ob_size)-1) ob_digit[i] * 2*(SHIFTi)
	38	Negative numbers are represented with ob_size < 0;
	39	zero is represented by ob_size == 0.
	40	In a normalized number, ob_digit[abs(ob_size)-1] (the most significant
	41	digit) is never zero. Also, in all cases, for all valid i,
	42	0 <= ob_digit[i] <= MASK.
	43	The allocation function takes care of allocating extra memory
	44	so that ob_digit[0] ... ob_digit[abs(ob_size)-1] are actually available.
	45
	46	CAUTION: Generic code manipulating subtypes of PyVarObject has to
	47	aware that longs abuse ob_size's sign bit.
	48	*/
	49
	50	struct _longobject {
	51	PyObject_VAR_HEAD
	52	digit ob_digit[1];
	53	};
	54
	55	PyAPI_FUNC(PyLongObject *) _PyLong_New(Py_ssize_t);
	56
	57	/* Return a copy of src. */
	58	PyAPI_FUNC(PyObject ) _PyLong_Copy(PyLongObject src);
	59
	60	#ifdef __cplusplus
	61	}
	62	#endif
	63	#endif /* !Py_LONGINTREPR_H */

sys/src/cmd/python/Include/longobject.h+114−0

@@ -0,0 +1,114 @@
	1	#ifndef Py_LONGOBJECT_H
	2	#define Py_LONGOBJECT_H
	3	#ifdef __cplusplus
	4	extern "C" {
	5	#endif
	6
	7
	8	/* Long (arbitrary precision) integer object interface */
	9
	10	typedef struct _longobject PyLongObject; /* Revealed in longintrepr.h */
	11
	12	PyAPI_DATA(PyTypeObject) PyLong_Type;
	13
	14	#define PyLong_Check(op) PyObject_TypeCheck(op, &PyLong_Type)
	15	#define PyLong_CheckExact(op) ((op)->ob_type == &PyLong_Type)
	16
	17	PyAPI_FUNC(PyObject *) PyLong_FromLong(long);
	18	PyAPI_FUNC(PyObject *) PyLong_FromUnsignedLong(unsigned long);
	19	PyAPI_FUNC(PyObject *) PyLong_FromDouble(double);
	20	PyAPI_FUNC(long) PyLong_AsLong(PyObject *);
	21	PyAPI_FUNC(unsigned long) PyLong_AsUnsignedLong(PyObject *);
	22	PyAPI_FUNC(unsigned long) PyLong_AsUnsignedLongMask(PyObject *);
	23
	24	/* For use by intobject.c only */
	25	PyAPI_FUNC(Py_ssize_t) _PyLong_AsSsize_t(PyObject *);
	26	PyAPI_FUNC(PyObject *) _PyLong_FromSize_t(size_t);
	27	PyAPI_FUNC(PyObject *) _PyLong_FromSsize_t(Py_ssize_t);
	28	PyAPI_DATA(int) _PyLong_DigitValue[256];
	29
	30	/* _PyLong_AsScaledDouble returns a double x and an exponent e such that
	31	the true value is approximately equal to x * 2*(SHIFTe). e is >= 0.
	32	x is 0.0 if and only if the input is 0 (in which case, e and x are both
	33	zeroes). Overflow is impossible. Note that the exponent returned must
	34	be multiplied by SHIFT! There may not be enough room in an int to store
	35	eSHIFT directly. /
	36	PyAPI_FUNC(double) _PyLong_AsScaledDouble(PyObject vv, int e);
	37
	38	PyAPI_FUNC(double) PyLong_AsDouble(PyObject *);
	39	PyAPI_FUNC(PyObject ) PyLong_FromVoidPtr(void );
	40	PyAPI_FUNC(void ) PyLong_AsVoidPtr(PyObject );
	41
	42	#ifdef HAVE_LONG_LONG
	43	PyAPI_FUNC(PyObject *) PyLong_FromLongLong(PY_LONG_LONG);
	44	PyAPI_FUNC(PyObject *) PyLong_FromUnsignedLongLong(unsigned PY_LONG_LONG);
	45	PyAPI_FUNC(PY_LONG_LONG) PyLong_AsLongLong(PyObject *);
	46	PyAPI_FUNC(unsigned PY_LONG_LONG) PyLong_AsUnsignedLongLong(PyObject *);
	47	PyAPI_FUNC(unsigned PY_LONG_LONG) PyLong_AsUnsignedLongLongMask(PyObject *);
	48	#endif /* HAVE_LONG_LONG */
	49
	50	PyAPI_FUNC(PyObject ) PyLong_FromString(char , char **, int);
	51	#ifdef Py_USING_UNICODE
	52	PyAPI_FUNC(PyObject ) PyLong_FromUnicode(Py_UNICODE, Py_ssize_t, int);
	53	#endif
	54
	55	/* _PyLong_Sign. Return 0 if v is 0, -1 if v < 0, +1 if v > 0.
	56	v must not be NULL, and must be a normalized long.
	57	There are no error cases.
	58	*/
	59	PyAPI_FUNC(int) _PyLong_Sign(PyObject *v);
	60
	61
	62	/* _PyLong_NumBits. Return the number of bits needed to represent the
	63	absolute value of a long. For example, this returns 1 for 1 and -1, 2
	64	for 2 and -2, and 2 for 3 and -3. It returns 0 for 0.
	65	v must not be NULL, and must be a normalized long.
	66	(size_t)-1 is returned and OverflowError set if the true result doesn't
	67	fit in a size_t.
	68	*/
	69	PyAPI_FUNC(size_t) _PyLong_NumBits(PyObject *v);
	70
	71	/* _PyLong_FromByteArray: View the n unsigned bytes as a binary integer in
	72	base 256, and return a Python long with the same numeric value.
	73	If n is 0, the integer is 0. Else:
	74	If little_endian is 1/true, bytes[n-1] is the MSB and bytes[0] the LSB;
	75	else (little_endian is 0/false) bytes[0] is the MSB and bytes[n-1] the
	76	LSB.
	77	If is_signed is 0/false, view the bytes as a non-negative integer.
	78	If is_signed is 1/true, view the bytes as a 2's-complement integer,
	79	non-negative if bit 0x80 of the MSB is clear, negative if set.
	80	Error returns:
	81	+ Return NULL with the appropriate exception set if there's not
	82	enough memory to create the Python long.
	83	*/
	84	PyAPI_FUNC(PyObject *) _PyLong_FromByteArray(
	85	const unsigned char* bytes, size_t n,
	86	int little_endian, int is_signed);
	87
	88	/* _PyLong_AsByteArray: Convert the least-significant 8*n bits of long
	89	v to a base-256 integer, stored in array bytes. Normally return 0,
	90	return -1 on error.
	91	If little_endian is 1/true, store the MSB at bytes[n-1] and the LSB at
	92	bytes[0]; else (little_endian is 0/false) store the MSB at bytes[0] and
	93	the LSB at bytes[n-1].
	94	If is_signed is 0/false, it's an error if v < 0; else (v >= 0) n bytes
	95	are filled and there's nothing special about bit 0x80 of the MSB.
	96	If is_signed is 1/true, bytes is filled with the 2's-complement
	97	representation of v's value. Bit 0x80 of the MSB is the sign bit.
	98	Error returns (-1):
	99	+ is_signed is 0 and v < 0. TypeError is set in this case, and bytes
	100	isn't altered.
	101	+ n isn't big enough to hold the full mathematical value of v. For
	102	example, if is_signed is 0 and there are more digits in the v than
	103	fit in n; or if is_signed is 1, v < 0, and n is just 1 bit shy of
	104	being large enough to hold a sign bit. OverflowError is set in this
	105	case, but bytes holds the least-signficant n bytes of the true value.
	106	*/
	107	PyAPI_FUNC(int) _PyLong_AsByteArray(PyLongObject* v,
	108	unsigned char* bytes, size_t n,
	109	int little_endian, int is_signed);
	110
	111	#ifdef __cplusplus
	112	}
	113	#endif
	114	#endif /* !Py_LONGOBJECT_H */

sys/src/cmd/python/Include/marshal.h+25−0

@@ -0,0 +1,25 @@
	1
	2	/* Interface for marshal.c */
	3
	4	#ifndef Py_MARSHAL_H
	5	#define Py_MARSHAL_H
	6	#ifdef __cplusplus
	7	extern "C" {
	8	#endif
	9
	10	#define Py_MARSHAL_VERSION 2
	11
	12	PyAPI_FUNC(void) PyMarshal_WriteLongToFile(long, FILE *, int);
	13	PyAPI_FUNC(void) PyMarshal_WriteObjectToFile(PyObject , FILE , int);
	14	PyAPI_FUNC(PyObject ) PyMarshal_WriteObjectToString(PyObject , int);
	15
	16	PyAPI_FUNC(long) PyMarshal_ReadLongFromFile(FILE *);
	17	PyAPI_FUNC(int) PyMarshal_ReadShortFromFile(FILE *);
	18	PyAPI_FUNC(PyObject ) PyMarshal_ReadObjectFromFile(FILE );
	19	PyAPI_FUNC(PyObject ) PyMarshal_ReadLastObjectFromFile(FILE );
	20	PyAPI_FUNC(PyObject ) PyMarshal_ReadObjectFromString(char , Py_ssize_t);
	21
	22	#ifdef __cplusplus
	23	}
	24	#endif
	25	#endif /* !Py_MARSHAL_H */

sys/src/cmd/python/Include/metagrammar.h+18−0

@@ -0,0 +1,18 @@
	1	#ifndef Py_METAGRAMMAR_H
	2	#define Py_METAGRAMMAR_H
	3	#ifdef __cplusplus
	4	extern "C" {
	5	#endif
	6
	7
	8	#define MSTART 256
	9	#define RULE 257
	10	#define RHS 258
	11	#define ALT 259
	12	#define ITEM 260
	13	#define ATOM 261
	14
	15	#ifdef __cplusplus
	16	}
	17	#endif
	18	#endif /* !Py_METAGRAMMAR_H */

sys/src/cmd/python/Include/methodobject.h+91−0

@@ -0,0 +1,91 @@
	1
	2	/* Method object interface */
	3
	4	#ifndef Py_METHODOBJECT_H
	5	#define Py_METHODOBJECT_H
	6	#ifdef __cplusplus
	7	extern "C" {
	8	#endif
	9
	10	/* This is about the type 'builtin_function_or_method',
	11	not Python methods in user-defined classes. See classobject.h
	12	for the latter. */
	13
	14	PyAPI_DATA(PyTypeObject) PyCFunction_Type;
	15
	16	#define PyCFunction_Check(op) ((op)->ob_type == &PyCFunction_Type)
	17
	18	typedef PyObject (PyCFunction)(PyObject , PyObject );
	19	typedef PyObject (PyCFunctionWithKeywords)(PyObject , PyObject ,
	20	PyObject *);
	21	typedef PyObject (PyNoArgsFunction)(PyObject *);
	22
	23	PyAPI_FUNC(PyCFunction) PyCFunction_GetFunction(PyObject *);
	24	PyAPI_FUNC(PyObject ) PyCFunction_GetSelf(PyObject );
	25	PyAPI_FUNC(int) PyCFunction_GetFlags(PyObject *);
	26
	27	/* Macros for direct access to these values. Type checks are not
	28	done, so use with care. */
	29	#define PyCFunction_GET_FUNCTION(func) \
	30	(((PyCFunctionObject *)func) -> m_ml -> ml_meth)
	31	#define PyCFunction_GET_SELF(func) \
	32	(((PyCFunctionObject *)func) -> m_self)
	33	#define PyCFunction_GET_FLAGS(func) \
	34	(((PyCFunctionObject *)func) -> m_ml -> ml_flags)
	35	PyAPI_FUNC(PyObject ) PyCFunction_Call(PyObject , PyObject , PyObject );
	36
	37	struct PyMethodDef {
	38	const char ml_name; / The name of the built-in function/method */
	39	PyCFunction ml_meth; /* The C function that implements it */
	40	int ml_flags; /* Combination of METH_xxx flags, which mostly
	41	describe the args expected by the C func */
	42	const char ml_doc; / The __doc__ attribute, or NULL */
	43	};
	44	typedef struct PyMethodDef PyMethodDef;
	45
	46	PyAPI_FUNC(PyObject ) Py_FindMethod(PyMethodDef[], PyObject , const char *);
	47
	48	#define PyCFunction_New(ML, SELF) PyCFunction_NewEx((ML), (SELF), NULL)
	49	PyAPI_FUNC(PyObject ) PyCFunction_NewEx(PyMethodDef , PyObject *,
	50	PyObject *);
	51
	52	/* Flag passed to newmethodobject */
	53	#define METH_OLDARGS 0x0000
	54	#define METH_VARARGS 0x0001
	55	#define METH_KEYWORDS 0x0002
	56	/* METH_NOARGS and METH_O must not be combined with the flags above. */
	57	#define METH_NOARGS 0x0004
	58	#define METH_O 0x0008
	59
	60	/* METH_CLASS and METH_STATIC are a little different; these control
	61	the construction of methods for a class. These cannot be used for
	62	functions in modules. */
	63	#define METH_CLASS 0x0010
	64	#define METH_STATIC 0x0020
	65
	66	/* METH_COEXIST allows a method to be entered eventhough a slot has
	67	already filled the entry. When defined, the flag allows a separate
	68	method, "__contains__" for example, to coexist with a defined
	69	slot like sq_contains. */
	70
	71	#define METH_COEXIST 0x0040
	72
	73	typedef struct PyMethodChain {
	74	PyMethodDef methods; / Methods of this type */
	75	struct PyMethodChain link; / NULL or base type */
	76	} PyMethodChain;
	77
	78	PyAPI_FUNC(PyObject ) Py_FindMethodInChain(PyMethodChain , PyObject *,
	79	const char *);
	80
	81	typedef struct {
	82	PyObject_HEAD
	83	PyMethodDef m_ml; / Description of the C function to call */
	84	PyObject m_self; / Passed as 'self' arg to the C func, can be NULL */
	85	PyObject m_module; / The __module__ attribute, can be anything */
	86	} PyCFunctionObject;
	87
	88	#ifdef __cplusplus
	89	}
	90	#endif
	91	#endif /* !Py_METHODOBJECT_H */

sys/src/cmd/python/Include/modsupport.h+133−0

@@ -0,0 +1,133 @@
	1
	2	#ifndef Py_MODSUPPORT_H
	3	#define Py_MODSUPPORT_H
	4	#ifdef __cplusplus
	5	extern "C" {
	6	#endif
	7
	8	/* Module support interface */
	9
	10	#include <stdarg.h>
	11
	12	/* If PY_SSIZE_T_CLEAN is defined, each functions treats #-specifier
	13	to mean Py_ssize_t */
	14	#ifdef PY_SSIZE_T_CLEAN
	15	#define PyArg_Parse _PyArg_Parse_SizeT
	16	#define PyArg_ParseTuple _PyArg_ParseTuple_SizeT
	17	#define PyArg_ParseTupleAndKeywords _PyArg_ParseTupleAndKeywords_SizeT
	18	#define PyArg_VaParse _PyArg_VaParse_SizeT
	19	#define PyArg_VaParseTupleAndKeywords _PyArg_VaParseTupleAndKeywords_SizeT
	20	#define Py_BuildValue _Py_BuildValue_SizeT
	21	#define Py_VaBuildValue _Py_VaBuildValue_SizeT
	22	#else
	23	PyAPI_FUNC(PyObject ) _Py_VaBuildValue_SizeT(const char , va_list);
	24	#endif
	25
	26	PyAPI_FUNC(int) PyArg_Parse(PyObject , const char , ...);
	27	PyAPI_FUNC(int) PyArg_ParseTuple(PyObject , const char , ...);
	28	PyAPI_FUNC(int) PyArg_ParseTupleAndKeywords(PyObject , PyObject ,
	29	const char , char *, ...);
	30	PyAPI_FUNC(int) PyArg_UnpackTuple(PyObject , const char , Py_ssize_t, Py_ssize_t, ...);
	31	PyAPI_FUNC(PyObject ) Py_BuildValue(const char , ...);
	32	PyAPI_FUNC(PyObject ) _Py_BuildValue_SizeT(const char , ...);
	33	PyAPI_FUNC(int) _PyArg_NoKeywords(const char funcname, PyObject kw);
	34
	35	PyAPI_FUNC(int) PyArg_VaParse(PyObject , const char , va_list);
	36	PyAPI_FUNC(int) PyArg_VaParseTupleAndKeywords(PyObject , PyObject ,
	37	const char , char *, va_list);
	38	PyAPI_FUNC(PyObject ) Py_VaBuildValue(const char , va_list);
	39
	40	PyAPI_FUNC(int) PyModule_AddObject(PyObject , const char , PyObject *);
	41	PyAPI_FUNC(int) PyModule_AddIntConstant(PyObject , const char , long);
	42	PyAPI_FUNC(int) PyModule_AddStringConstant(PyObject , const char , const char *);
	43
	44
	45	#define PYTHON_API_VERSION 1013
	46	#define PYTHON_API_STRING "1013"
	47	/* The API version is maintained (independently from the Python version)
	48	so we can detect mismatches between the interpreter and dynamically
	49	loaded modules. These are diagnosed by an error message but
	50	the module is still loaded (because the mismatch can only be tested
	51	after loading the module). The error message is intended to
	52	explain the core dump a few seconds later.
	53
	54	The symbol PYTHON_API_STRING defines the same value as a string
	55	literal. * PLEASE MAKE SURE THE DEFINITIONS MATCH. *
	56
	57	Please add a line or two to the top of this log for each API
	58	version change:
	59
	60	22-Feb-2006 MvL 1013 PEP 353 - long indices for sequence lengths
	61
	62	19-Aug-2002 GvR 1012 Changes to string object struct for
	63	interning changes, saving 3 bytes.
	64
	65	17-Jul-2001 GvR 1011 Descr-branch, just to be on the safe side
	66
	67	25-Jan-2001 FLD 1010 Parameters added to PyCode_New() and
	68	PyFrame_New(); Python 2.1a2
	69
	70	14-Mar-2000 GvR 1009 Unicode API added
	71
	72	3-Jan-1999 GvR 1007 Decided to change back! (Don't reuse 1008!)
	73
	74	3-Dec-1998 GvR 1008 Python 1.5.2b1
	75
	76	18-Jan-1997 GvR 1007 string interning and other speedups
	77
	78	11-Oct-1996 GvR renamed Py_Ellipses to Py_Ellipsis :-(
	79
	80	30-Jul-1996 GvR Slice and ellipses syntax added
	81
	82	23-Jul-1996 GvR For 1.4 -- better safe than sorry this time :-)
	83
	84	7-Nov-1995 GvR Keyword arguments (should've been done at 1.3 :-( )
	85
	86	10-Jan-1995 GvR Renamed globals to new naming scheme
	87
	88	9-Jan-1995 GvR Initial version (incompatible with older API)
	89	*/
	90
	91	#ifdef MS_WINDOWS
	92	/* Special defines for Windows versions used to live here. Things
	93	have changed, and the "Version" is now in a global string variable.
	94	Reason for this is that this for easier branding of a "custom DLL"
	95	without actually needing a recompile. */
	96	#endif /* MS_WINDOWS */
	97
	98	#if SIZEOF_SIZE_T != SIZEOF_INT
	99	/* On a 64-bit system, rename the Py_InitModule4 so that 2.4
	100	modules cannot get loaded into a 2.5 interpreter */
	101	#define Py_InitModule4 Py_InitModule4_64
	102	#endif
	103
	104	#ifdef Py_TRACE_REFS
	105	/* When we are tracing reference counts, rename Py_InitModule4 so
	106	modules compiled with incompatible settings will generate a
	107	link-time error. */
	108	#if SIZEOF_SIZE_T != SIZEOF_INT
	109	#undef Py_InitModule4
	110	#define Py_InitModule4 Py_InitModule4TraceRefs_64
	111	#else
	112	#define Py_InitModule4 Py_InitModule4TraceRefs
	113	#endif
	114	#endif
	115
	116	PyAPI_FUNC(PyObject ) Py_InitModule4(const char name, PyMethodDef *methods,
	117	const char doc, PyObject self,
	118	int apiver);
	119
	120	#define Py_InitModule(name, methods) \
	121	Py_InitModule4(name, methods, (char )NULL, (PyObject )NULL, \
	122	PYTHON_API_VERSION)
	123
	124	#define Py_InitModule3(name, methods, doc) \
	125	Py_InitModule4(name, methods, doc, (PyObject *)NULL, \
	126	PYTHON_API_VERSION)
	127
	128	PyAPI_DATA(char *) _Py_PackageContext;
	129
	130	#ifdef __cplusplus
	131	}
	132	#endif
	133	#endif /* !Py_MODSUPPORT_H */

sys/src/cmd/python/Include/moduleobject.h+24−0

@@ -0,0 +1,24 @@
	1
	2	/* Module object interface */
	3
	4	#ifndef Py_MODULEOBJECT_H
	5	#define Py_MODULEOBJECT_H
	6	#ifdef __cplusplus
	7	extern "C" {
	8	#endif
	9
	10	PyAPI_DATA(PyTypeObject) PyModule_Type;
	11
	12	#define PyModule_Check(op) PyObject_TypeCheck(op, &PyModule_Type)
	13	#define PyModule_CheckExact(op) ((op)->ob_type == &PyModule_Type)
	14
	15	PyAPI_FUNC(PyObject ) PyModule_New(const char );
	16	PyAPI_FUNC(PyObject ) PyModule_GetDict(PyObject );
	17	PyAPI_FUNC(char ) PyModule_GetName(PyObject );
	18	PyAPI_FUNC(char ) PyModule_GetFilename(PyObject );
	19	PyAPI_FUNC(void) _PyModule_Clear(PyObject *);
	20
	21	#ifdef __cplusplus
	22	}
	23	#endif
	24	#endif /* !Py_MODULEOBJECT_H */

sys/src/cmd/python/Include/node.h+40−0

@@ -0,0 +1,40 @@
	1
	2	/* Parse tree node interface */
	3
	4	#ifndef Py_NODE_H
	5	#define Py_NODE_H
	6	#ifdef __cplusplus
	7	extern "C" {
	8	#endif
	9
	10	typedef struct _node {
	11	short n_type;
	12	char *n_str;
	13	int n_lineno;
	14	int n_col_offset;
	15	int n_nchildren;
	16	struct _node *n_child;
	17	} node;
	18
	19	PyAPI_FUNC(node *) PyNode_New(int type);
	20	PyAPI_FUNC(int) PyNode_AddChild(node *n, int type,
	21	char *str, int lineno, int col_offset);
	22	PyAPI_FUNC(void) PyNode_Free(node *n);
	23
	24	/* Node access functions */
	25	#define NCH(n) ((n)->n_nchildren)
	26
	27	#define CHILD(n, i) (&(n)->n_child[i])
	28	#define RCHILD(n, i) (CHILD(n, NCH(n) + i))
	29	#define TYPE(n) ((n)->n_type)
	30	#define STR(n) ((n)->n_str)
	31
	32	/* Assert that the type of a node is what we expect */
	33	#define REQ(n, type) assert(TYPE(n) == (type))
	34
	35	PyAPI_FUNC(void) PyNode_ListTree(node *);
	36
	37	#ifdef __cplusplus
	38	}
	39	#endif
	40	#endif /* !Py_NODE_H */

sys/src/cmd/python/Include/object.h+868−0

@@ -0,0 +1,868 @@
	1	#ifndef Py_OBJECT_H
	2	#define Py_OBJECT_H
	3	#ifdef __cplusplus
	4	extern "C" {
	5	#endif
	6
	7
	8	/* Object and type object interface */
	9
	10	/*
	11	Objects are structures allocated on the heap. Special rules apply to
	12	the use of objects to ensure they are properly garbage-collected.
	13	Objects are never allocated statically or on the stack; they must be
	14	accessed through special macros and functions only. (Type objects are
	15	exceptions to the first rule; the standard types are represented by
	16	statically initialized type objects, although work on type/class unification
	17	for Python 2.2 made it possible to have heap-allocated type objects too).
	18
	19	An object has a 'reference count' that is increased or decreased when a
	20	pointer to the object is copied or deleted; when the reference count
	21	reaches zero there are no references to the object left and it can be
	22	removed from the heap.
	23
	24	An object has a 'type' that determines what it represents and what kind
	25	of data it contains. An object's type is fixed when it is created.
	26	Types themselves are represented as objects; an object contains a
	27	pointer to the corresponding type object. The type itself has a type
	28	pointer pointing to the object representing the type 'type', which
	29	contains a pointer to itself!).
	30
	31	Objects do not float around in memory; once allocated an object keeps
	32	the same size and address. Objects that must hold variable-size data
	33	can contain pointers to variable-size parts of the object. Not all
	34	objects of the same type have the same size; but the size cannot change
	35	after allocation. (These restrictions are made so a reference to an
	36	object can be simply a pointer -- moving an object would require
	37	updating all the pointers, and changing an object's size would require
	38	moving it if there was another object right next to it.)
	39
	40	Objects are always accessed through pointers of the type 'PyObject *'.
	41	The type 'PyObject' is a structure that only contains the reference count
	42	and the type pointer. The actual memory allocated for an object
	43	contains other data that can only be accessed after casting the pointer
	44	to a pointer to a longer structure type. This longer type must start
	45	with the reference count and type fields; the macro PyObject_HEAD should be
	46	used for this (to accommodate for future changes). The implementation
	47	of a particular object type can cast the object pointer to the proper
	48	type and back.
	49
	50	A standard interface exists for objects that contain an array of items
	51	whose size is determined when the object is allocated.
	52	*/
	53
	54	/* Py_DEBUG implies Py_TRACE_REFS. */
	55	#if defined(Py_DEBUG) && !defined(Py_TRACE_REFS)
	56	#define Py_TRACE_REFS
	57	#endif
	58
	59	/* Py_TRACE_REFS implies Py_REF_DEBUG. */
	60	#if defined(Py_TRACE_REFS) && !defined(Py_REF_DEBUG)
	61	#define Py_REF_DEBUG
	62	#endif
	63
	64	#ifdef Py_TRACE_REFS
	65	/* Define pointers to support a doubly-linked list of all live heap objects. */
	66	#define _PyObject_HEAD_EXTRA \
	67	struct _object *_ob_next; \
	68	struct _object *_ob_prev;
	69
	70	#define _PyObject_EXTRA_INIT 0, 0,
	71
	72	#else
	73	#define _PyObject_HEAD_EXTRA
	74	#define _PyObject_EXTRA_INIT
	75	#endif
	76
	77	/* PyObject_HEAD defines the initial segment of every PyObject. */
	78	#define PyObject_HEAD \
	79	_PyObject_HEAD_EXTRA \
	80	Py_ssize_t ob_refcnt; \
	81	struct _typeobject *ob_type;
	82
	83	#define PyObject_HEAD_INIT(type) \
	84	_PyObject_EXTRA_INIT \
	85	1, type,
	86
	87	/* PyObject_VAR_HEAD defines the initial segment of all variable-size
	88	* container objects. These end with a declaration of an array with 1
	89	* element, but enough space is malloc'ed so that the array actually
	90	* has room for ob_size elements. Note that ob_size is an element count,
	91	* not necessarily a byte count.
	92	*/
	93	#define PyObject_VAR_HEAD \
	94	PyObject_HEAD \
	95	Py_ssize_t ob_size; /* Number of items in variable part */
	96	#define Py_INVALID_SIZE (Py_ssize_t)-1
	97
	98	/* Nothing is actually declared to be a PyObject, but every pointer to
	99	* a Python object can be cast to a PyObject*. This is inheritance built
	100	* by hand. Similarly every pointer to a variable-size Python object can,
	101	* in addition, be cast to PyVarObject*.
	102	*/
	103	typedef struct _object {
	104	PyObject_HEAD
	105	} PyObject;
	106
	107	typedef struct {
	108	PyObject_VAR_HEAD
	109	} PyVarObject;
	110
	111
	112	/*
	113	Type objects contain a string containing the type name (to help somewhat
	114	in debugging), the allocation parameters (see PyObject_New() and
	115	PyObject_NewVar()),
	116	and methods for accessing objects of the type. Methods are optional, a
	117	nil pointer meaning that particular kind of access is not available for
	118	this type. The Py_DECREF() macro uses the tp_dealloc method without
	119	checking for a nil pointer; it should always be implemented except if
	120	the implementation can guarantee that the reference count will never
	121	reach zero (e.g., for statically allocated type objects).
	122
	123	NB: the methods for certain type groups are now contained in separate
	124	method blocks.
	125	*/
	126
	127	typedef PyObject * (unaryfunc)(PyObject );
	128	typedef PyObject * (binaryfunc)(PyObject , PyObject *);
	129	typedef PyObject * (ternaryfunc)(PyObject , PyObject , PyObject );
	130	typedef int (inquiry)(PyObject );
	131	typedef Py_ssize_t (lenfunc)(PyObject );
	132	typedef int (coercion)(PyObject , PyObject *);
	133	typedef PyObject (intargfunc)(PyObject *, int) Py_DEPRECATED(2.5);
	134	typedef PyObject (intintargfunc)(PyObject *, int, int) Py_DEPRECATED(2.5);
	135	typedef PyObject (ssizeargfunc)(PyObject *, Py_ssize_t);
	136	typedef PyObject (ssizessizeargfunc)(PyObject *, Py_ssize_t, Py_ssize_t);
	137	typedef int(intobjargproc)(PyObject , int, PyObject *);
	138	typedef int(intintobjargproc)(PyObject , int, int, PyObject *);
	139	typedef int(ssizeobjargproc)(PyObject , Py_ssize_t, PyObject *);
	140	typedef int(ssizessizeobjargproc)(PyObject , Py_ssize_t, Py_ssize_t, PyObject *);
	141	typedef int(objobjargproc)(PyObject , PyObject , PyObject );
	142
	143	/* int-based buffer interface */
	144	typedef int (getreadbufferproc)(PyObject , int, void **);
	145	typedef int (getwritebufferproc)(PyObject , int, void **);
	146	typedef int (getsegcountproc)(PyObject , int *);
	147	typedef int (getcharbufferproc)(PyObject , int, char **);
	148	/* ssize_t-based buffer interface */
	149	typedef Py_ssize_t (readbufferproc)(PyObject , Py_ssize_t, void **);
	150	typedef Py_ssize_t (writebufferproc)(PyObject , Py_ssize_t, void **);
	151	typedef Py_ssize_t (segcountproc)(PyObject , Py_ssize_t *);
	152	typedef Py_ssize_t (charbufferproc)(PyObject , Py_ssize_t, char **);
	153
	154	typedef int (objobjproc)(PyObject , PyObject *);
	155	typedef int (visitproc)(PyObject , void *);
	156	typedef int (traverseproc)(PyObject , visitproc, void *);
	157
	158	typedef struct {
	159	/* For numbers without flag bit Py_TPFLAGS_CHECKTYPES set, all
	160	arguments are guaranteed to be of the object's type (modulo
	161	coercion hacks -- i.e. if the type's coercion function
	162	returns other types, then these are allowed as well). Numbers that
	163	have the Py_TPFLAGS_CHECKTYPES flag bit set should check both
	164	arguments for proper type and implement the necessary conversions
	165	in the slot functions themselves. */
	166
	167	binaryfunc nb_add;
	168	binaryfunc nb_subtract;
	169	binaryfunc nb_multiply;
	170	binaryfunc nb_divide;
	171	binaryfunc nb_remainder;
	172	binaryfunc nb_divmod;
	173	ternaryfunc nb_power;
	174	unaryfunc nb_negative;
	175	unaryfunc nb_positive;
	176	unaryfunc nb_absolute;
	177	inquiry nb_nonzero;
	178	unaryfunc nb_invert;
	179	binaryfunc nb_lshift;
	180	binaryfunc nb_rshift;
	181	binaryfunc nb_and;
	182	binaryfunc nb_xor;
	183	binaryfunc nb_or;
	184	coercion nb_coerce;
	185	unaryfunc nb_int;
	186	unaryfunc nb_long;
	187	unaryfunc nb_float;
	188	unaryfunc nb_oct;
	189	unaryfunc nb_hex;
	190	/* Added in release 2.0 */
	191	binaryfunc nb_inplace_add;
	192	binaryfunc nb_inplace_subtract;
	193	binaryfunc nb_inplace_multiply;
	194	binaryfunc nb_inplace_divide;
	195	binaryfunc nb_inplace_remainder;
	196	ternaryfunc nb_inplace_power;
	197	binaryfunc nb_inplace_lshift;
	198	binaryfunc nb_inplace_rshift;
	199	binaryfunc nb_inplace_and;
	200	binaryfunc nb_inplace_xor;
	201	binaryfunc nb_inplace_or;
	202
	203	/* Added in release 2.2 */
	204	/* The following require the Py_TPFLAGS_HAVE_CLASS flag */
	205	binaryfunc nb_floor_divide;
	206	binaryfunc nb_true_divide;
	207	binaryfunc nb_inplace_floor_divide;
	208	binaryfunc nb_inplace_true_divide;
	209
	210	/* Added in release 2.5 */
	211	unaryfunc nb_index;
	212	} PyNumberMethods;
	213
	214	typedef struct {
	215	lenfunc sq_length;
	216	binaryfunc sq_concat;
	217	ssizeargfunc sq_repeat;
	218	ssizeargfunc sq_item;
	219	ssizessizeargfunc sq_slice;
	220	ssizeobjargproc sq_ass_item;
	221	ssizessizeobjargproc sq_ass_slice;
	222	objobjproc sq_contains;
	223	/* Added in release 2.0 */
	224	binaryfunc sq_inplace_concat;
	225	ssizeargfunc sq_inplace_repeat;
	226	} PySequenceMethods;
	227
	228	typedef struct {
	229	lenfunc mp_length;
	230	binaryfunc mp_subscript;
	231	objobjargproc mp_ass_subscript;
	232	} PyMappingMethods;
	233
	234	typedef struct {
	235	readbufferproc bf_getreadbuffer;
	236	writebufferproc bf_getwritebuffer;
	237	segcountproc bf_getsegcount;
	238	charbufferproc bf_getcharbuffer;
	239	} PyBufferProcs;
	240
	241
	242	typedef void (freefunc)(void );
	243	typedef void (destructor)(PyObject );
	244	typedef int (printfunc)(PyObject , FILE *, int);
	245	typedef PyObject (getattrfunc)(PyObject , char );
	246	typedef PyObject (getattrofunc)(PyObject , PyObject );
	247	typedef int (setattrfunc)(PyObject , char , PyObject );
	248	typedef int (setattrofunc)(PyObject , PyObject , PyObject );
	249	typedef int (cmpfunc)(PyObject , PyObject *);
	250	typedef PyObject (reprfunc)(PyObject *);
	251	typedef long (hashfunc)(PyObject );
	252	typedef PyObject (richcmpfunc) (PyObject , PyObject , int);
	253	typedef PyObject (getiterfunc) (PyObject *);
	254	typedef PyObject (iternextfunc) (PyObject *);
	255	typedef PyObject (descrgetfunc) (PyObject , PyObject , PyObject *);
	256	typedef int (descrsetfunc) (PyObject , PyObject , PyObject );
	257	typedef int (initproc)(PyObject , PyObject , PyObject );
	258	typedef PyObject (newfunc)(struct _typeobject , PyObject , PyObject *);
	259	typedef PyObject (allocfunc)(struct _typeobject *, Py_ssize_t);
	260
	261	typedef struct _typeobject {
	262	PyObject_VAR_HEAD
	263	const char tp_name; / For printing, in format "<module>.<name>" */
	264	Py_ssize_t tp_basicsize, tp_itemsize; /* For allocation */
	265
	266	/* Methods to implement standard operations */
	267
	268	destructor tp_dealloc;
	269	printfunc tp_print;
	270	getattrfunc tp_getattr;
	271	setattrfunc tp_setattr;
	272	cmpfunc tp_compare;
	273	reprfunc tp_repr;
	274
	275	/* Method suites for standard classes */
	276
	277	PyNumberMethods *tp_as_number;
	278	PySequenceMethods *tp_as_sequence;
	279	PyMappingMethods *tp_as_mapping;
	280
	281	/* More standard operations (here for binary compatibility) */
	282
	283	hashfunc tp_hash;
	284	ternaryfunc tp_call;
	285	reprfunc tp_str;
	286	getattrofunc tp_getattro;
	287	setattrofunc tp_setattro;
	288
	289	/* Functions to access object as input/output buffer */
	290	PyBufferProcs *tp_as_buffer;
	291
	292	/* Flags to define presence of optional/expanded features */
	293	long tp_flags;
	294
	295	const char tp_doc; / Documentation string */
	296
	297	/* Assigned meaning in release 2.0 */
	298	/* call function for all accessible objects */
	299	traverseproc tp_traverse;
	300
	301	/* delete references to contained objects */
	302	inquiry tp_clear;
	303
	304	/* Assigned meaning in release 2.1 */
	305	/* rich comparisons */
	306	richcmpfunc tp_richcompare;
	307
	308	/* weak reference enabler */
	309	Py_ssize_t tp_weaklistoffset;
	310
	311	/* Added in release 2.2 */
	312	/* Iterators */
	313	getiterfunc tp_iter;
	314	iternextfunc tp_iternext;
	315
	316	/* Attribute descriptor and subclassing stuff */
	317	struct PyMethodDef *tp_methods;
	318	struct PyMemberDef *tp_members;
	319	struct PyGetSetDef *tp_getset;
	320	struct _typeobject *tp_base;
	321	PyObject *tp_dict;
	322	descrgetfunc tp_descr_get;
	323	descrsetfunc tp_descr_set;
	324	Py_ssize_t tp_dictoffset;
	325	initproc tp_init;
	326	allocfunc tp_alloc;
	327	newfunc tp_new;
	328	freefunc tp_free; /* Low-level free-memory routine */
	329	inquiry tp_is_gc; /* For PyObject_IS_GC */
	330	PyObject *tp_bases;
	331	PyObject tp_mro; / method resolution order */
	332	PyObject *tp_cache;
	333	PyObject *tp_subclasses;
	334	PyObject *tp_weaklist;
	335	destructor tp_del;
	336
	337	#ifdef COUNT_ALLOCS
	338	/* these must be last and never explicitly initialized */
	339	Py_ssize_t tp_allocs;
	340	Py_ssize_t tp_frees;
	341	Py_ssize_t tp_maxalloc;
	342	struct _typeobject *tp_prev;
	343	struct _typeobject *tp_next;
	344	#endif
	345	} PyTypeObject;
	346
	347
	348	/* The real layout of a type object when allocated on the heap */
	349	typedef struct _heaptypeobject {
	350	/* Note: there's a dependency on the order of these members
	351	in slotptr() in typeobject.c . */
	352	PyTypeObject ht_type;
	353	PyNumberMethods as_number;
	354	PyMappingMethods as_mapping;
	355	PySequenceMethods as_sequence; /* as_sequence comes after as_mapping,
	356	so that the mapping wins when both
	357	the mapping and the sequence define
	358	a given operator (e.g. __getitem__).
	359	see add_operators() in typeobject.c . */
	360	PyBufferProcs as_buffer;
	361	PyObject ht_name, ht_slots;
	362	/* here are optional user slots, followed by the members. */
	363	} PyHeapTypeObject;
	364
	365	/* access macro to the members which are floating "behind" the object */
	366	#define PyHeapType_GET_MEMBERS(etype) \
	367	((PyMemberDef )(((char )etype) + (etype)->ht_type.ob_type->tp_basicsize))
	368
	369
	370	/* Generic type check */
	371	PyAPI_FUNC(int) PyType_IsSubtype(PyTypeObject , PyTypeObject );
	372	#define PyObject_TypeCheck(ob, tp) \
	373	((ob)->ob_type == (tp) \|\| PyType_IsSubtype((ob)->ob_type, (tp)))
	374
	375	PyAPI_DATA(PyTypeObject) PyType_Type; /* built-in 'type' */
	376	PyAPI_DATA(PyTypeObject) PyBaseObject_Type; /* built-in 'object' */
	377	PyAPI_DATA(PyTypeObject) PySuper_Type; /* built-in 'super' */
	378
	379	#define PyType_Check(op) PyObject_TypeCheck(op, &PyType_Type)
	380	#define PyType_CheckExact(op) ((op)->ob_type == &PyType_Type)
	381
	382	PyAPI_FUNC(int) PyType_Ready(PyTypeObject *);
	383	PyAPI_FUNC(PyObject ) PyType_GenericAlloc(PyTypeObject , Py_ssize_t);
	384	PyAPI_FUNC(PyObject ) PyType_GenericNew(PyTypeObject ,
	385	PyObject , PyObject );
	386	PyAPI_FUNC(PyObject ) _PyType_Lookup(PyTypeObject , PyObject *);
	387
	388	/* Generic operations on objects */
	389	PyAPI_FUNC(int) PyObject_Print(PyObject , FILE , int);
	390	PyAPI_FUNC(void) _PyObject_Dump(PyObject *);
	391	PyAPI_FUNC(PyObject ) PyObject_Repr(PyObject );
	392	PyAPI_FUNC(PyObject ) _PyObject_Str(PyObject );
	393	PyAPI_FUNC(PyObject ) PyObject_Str(PyObject );
	394	#ifdef Py_USING_UNICODE
	395	PyAPI_FUNC(PyObject ) PyObject_Unicode(PyObject );
	396	#endif
	397	PyAPI_FUNC(int) PyObject_Compare(PyObject , PyObject );
	398	PyAPI_FUNC(PyObject ) PyObject_RichCompare(PyObject , PyObject *, int);
	399	PyAPI_FUNC(int) PyObject_RichCompareBool(PyObject , PyObject , int);
	400	PyAPI_FUNC(PyObject ) PyObject_GetAttrString(PyObject , const char *);
	401	PyAPI_FUNC(int) PyObject_SetAttrString(PyObject , const char , PyObject *);
	402	PyAPI_FUNC(int) PyObject_HasAttrString(PyObject , const char );
	403	PyAPI_FUNC(PyObject ) PyObject_GetAttr(PyObject , PyObject *);
	404	PyAPI_FUNC(int) PyObject_SetAttr(PyObject , PyObject , PyObject *);
	405	PyAPI_FUNC(int) PyObject_HasAttr(PyObject , PyObject );
	406	PyAPI_FUNC(PyObject *) _PyObject_GetDictPtr(PyObject );
	407	PyAPI_FUNC(PyObject ) PyObject_SelfIter(PyObject );
	408	PyAPI_FUNC(PyObject ) PyObject_GenericGetAttr(PyObject , PyObject *);
	409	PyAPI_FUNC(int) PyObject_GenericSetAttr(PyObject *,
	410	PyObject , PyObject );
	411	PyAPI_FUNC(long) PyObject_Hash(PyObject *);
	412	PyAPI_FUNC(int) PyObject_IsTrue(PyObject *);
	413	PyAPI_FUNC(int) PyObject_Not(PyObject *);
	414	PyAPI_FUNC(int) PyCallable_Check(PyObject *);
	415	PyAPI_FUNC(int) PyNumber_Coerce(PyObject , PyObject );
	416	PyAPI_FUNC(int) PyNumber_CoerceEx(PyObject , PyObject );
	417
	418	PyAPI_FUNC(void) PyObject_ClearWeakRefs(PyObject *);
	419
	420	/* A slot function whose address we need to compare */
	421	extern int _PyObject_SlotCompare(PyObject , PyObject );
	422
	423
	424	/* PyObject_Dir(obj) acts like Python __builtin__.dir(obj), returning a
	425	list of strings. PyObject_Dir(NULL) is like __builtin__.dir(),
	426	returning the names of the current locals. In this case, if there are
	427	no current locals, NULL is returned, and PyErr_Occurred() is false.
	428	*/
	429	PyAPI_FUNC(PyObject ) PyObject_Dir(PyObject );
	430
	431
	432	/* Helpers for printing recursive container types */
	433	PyAPI_FUNC(int) Py_ReprEnter(PyObject *);
	434	PyAPI_FUNC(void) Py_ReprLeave(PyObject *);
	435
	436	/* Helpers for hash functions */
	437	PyAPI_FUNC(long) _Py_HashDouble(double);
	438	PyAPI_FUNC(long) _Py_HashPointer(void*);
	439
	440	/* Helper for passing objects to printf and the like */
	441	#define PyObject_REPR(obj) PyString_AS_STRING(PyObject_Repr(obj))
	442
	443	/* Flag bits for printing: */
	444	#define Py_PRINT_RAW 1 /* No string quotes etc. */
	445
	446	/*
	447	`Type flags (tp_flags)
	448
	449	These flags are used to extend the type structure in a backwards-compatible
	450	fashion. Extensions can use the flags to indicate (and test) when a given
	451	type structure contains a new feature. The Python core will use these when
	452	introducing new functionality between major revisions (to avoid mid-version
	453	changes in the PYTHON_API_VERSION).
	454
	455	Arbitration of the flag bit positions will need to be coordinated among
	456	all extension writers who publically release their extensions (this will
	457	be fewer than you might expect!)..
	458
	459	Python 1.5.2 introduced the bf_getcharbuffer slot into PyBufferProcs.
	460
	461	Type definitions should use Py_TPFLAGS_DEFAULT for their tp_flags value.
	462
	463	Code can use PyType_HasFeature(type_ob, flag_value) to test whether the
	464	given type object has a specified feature.
	465	*/
	466
	467	/* PyBufferProcs contains bf_getcharbuffer */
	468	#define Py_TPFLAGS_HAVE_GETCHARBUFFER (1L<<0)
	469
	470	/* PySequenceMethods contains sq_contains */
	471	#define Py_TPFLAGS_HAVE_SEQUENCE_IN (1L<<1)
	472
	473	/* This is here for backwards compatibility. Extensions that use the old GC
	474	* API will still compile but the objects will not be tracked by the GC. */
	475	#define Py_TPFLAGS_GC 0 /* used to be (1L<<2) */
	476
	477	/* PySequenceMethods and PyNumberMethods contain in-place operators */
	478	#define Py_TPFLAGS_HAVE_INPLACEOPS (1L<<3)
	479
	480	/* PyNumberMethods do their own coercion */
	481	#define Py_TPFLAGS_CHECKTYPES (1L<<4)
	482
	483	/* tp_richcompare is defined */
	484	#define Py_TPFLAGS_HAVE_RICHCOMPARE (1L<<5)
	485
	486	/* Objects which are weakly referencable if their tp_weaklistoffset is >0 */
	487	#define Py_TPFLAGS_HAVE_WEAKREFS (1L<<6)
	488
	489	/* tp_iter is defined */
	490	#define Py_TPFLAGS_HAVE_ITER (1L<<7)
	491
	492	/* New members introduced by Python 2.2 exist */
	493	#define Py_TPFLAGS_HAVE_CLASS (1L<<8)
	494
	495	/* Set if the type object is dynamically allocated */
	496	#define Py_TPFLAGS_HEAPTYPE (1L<<9)
	497
	498	/* Set if the type allows subclassing */
	499	#define Py_TPFLAGS_BASETYPE (1L<<10)
	500
	501	/* Set if the type is 'ready' -- fully initialized */
	502	#define Py_TPFLAGS_READY (1L<<12)
	503
	504	/* Set while the type is being 'readied', to prevent recursive ready calls */
	505	#define Py_TPFLAGS_READYING (1L<<13)
	506
	507	/* Objects support garbage collection (see objimp.h) */
	508	#define Py_TPFLAGS_HAVE_GC (1L<<14)
	509
	510	/* These two bits are preserved for Stackless Python, next after this is 17 */
	511	#ifdef STACKLESS
	512	#define Py_TPFLAGS_HAVE_STACKLESS_EXTENSION (3L<<15)
	513	#else
	514	#define Py_TPFLAGS_HAVE_STACKLESS_EXTENSION 0
	515	#endif
	516
	517	/* Objects support nb_index in PyNumberMethods */
	518	#define Py_TPFLAGS_HAVE_INDEX (1L<<17)
	519
	520	#define Py_TPFLAGS_DEFAULT ( \
	521	Py_TPFLAGS_HAVE_GETCHARBUFFER \| \
	522	Py_TPFLAGS_HAVE_SEQUENCE_IN \| \
	523	Py_TPFLAGS_HAVE_INPLACEOPS \| \
	524	Py_TPFLAGS_HAVE_RICHCOMPARE \| \
	525	Py_TPFLAGS_HAVE_WEAKREFS \| \
	526	Py_TPFLAGS_HAVE_ITER \| \
	527	Py_TPFLAGS_HAVE_CLASS \| \
	528	Py_TPFLAGS_HAVE_STACKLESS_EXTENSION \| \
	529	Py_TPFLAGS_HAVE_INDEX \| \
	530	0)
	531
	532	#define PyType_HasFeature(t,f) (((t)->tp_flags & (f)) != 0)
	533
	534
	535	/*
	536	The macros Py_INCREF(op) and Py_DECREF(op) are used to increment or decrement
	537	reference counts. Py_DECREF calls the object's deallocator function when
	538	the refcount falls to 0; for
	539	objects that don't contain references to other objects or heap memory
	540	this can be the standard function free(). Both macros can be used
	541	wherever a void expression is allowed. The argument must not be a
	542	NIL pointer. If it may be NIL, use Py_XINCREF/Py_XDECREF instead.
	543	The macro _Py_NewReference(op) initialize reference counts to 1, and
	544	in special builds (Py_REF_DEBUG, Py_TRACE_REFS) performs additional
	545	bookkeeping appropriate to the special build.
	546
	547	We assume that the reference count field can never overflow; this can
	548	be proven when the size of the field is the same as the pointer size, so
	549	we ignore the possibility. Provided a C int is at least 32 bits (which
	550	is implicitly assumed in many parts of this code), that's enough for
	551	about 2**31 references to an object.
	552
	553	XXX The following became out of date in Python 2.2, but I'm not sure
	554	XXX what the full truth is now. Certainly, heap-allocated type objects
	555	XXX can and should be deallocated.
	556	Type objects should never be deallocated; the type pointer in an object
	557	is not considered to be a reference to the type object, to save
	558	complications in the deallocation function. (This is actually a
	559	decision that's up to the implementer of each new type so if you want,
	560	you can count such references to the type object.)
	561
	562	* WARNING* The Py_DECREF macro must have a side-effect-free argument
	563	since it may evaluate its argument multiple times. (The alternative
	564	would be to mace it a proper function or assign it to a global temporary
	565	variable first, both of which are slower; and in a multi-threaded
	566	environment the global variable trick is not safe.)
	567	*/
	568
	569	/* First define a pile of simple helper macros, one set per special
	570	* build symbol. These either expand to the obvious things, or to
	571	* nothing at all when the special mode isn't in effect. The main
	572	* macros can later be defined just once then, yet expand to different
	573	* things depending on which special build options are and aren't in effect.
	574	* Trust me <wink>: while painful, this is 20x easier to understand than,
	575	* e.g, defining _Py_NewReference five different times in a maze of nested
	576	* #ifdefs (we used to do that -- it was impenetrable).
	577	*/
	578	#ifdef Py_REF_DEBUG
	579	PyAPI_DATA(Py_ssize_t) _Py_RefTotal;
	580	PyAPI_FUNC(void) _Py_NegativeRefcount(const char *fname,
	581	int lineno, PyObject *op);
	582	PyAPI_FUNC(PyObject *) _PyDict_Dummy(void);
	583	PyAPI_FUNC(PyObject *) _PySet_Dummy(void);
	584	PyAPI_FUNC(Py_ssize_t) _Py_GetRefTotal(void);
	585	#define _Py_INC_REFTOTAL _Py_RefTotal++
	586	#define _Py_DEC_REFTOTAL _Py_RefTotal--
	587	#define _Py_REF_DEBUG_COMMA ,
	588	#define _Py_CHECK_REFCNT(OP) \
	589	{ if ((OP)->ob_refcnt < 0) \
	590	_Py_NegativeRefcount(__FILE__, __LINE__, \
	591	(PyObject *)(OP)); \
	592	}
	593	#else
	594	#define _Py_INC_REFTOTAL
	595	#define _Py_DEC_REFTOTAL
	596	#define _Py_REF_DEBUG_COMMA
	597	#define _Py_CHECK_REFCNT(OP) /* a semicolon */;
	598	#endif /* Py_REF_DEBUG */
	599
	600	#ifdef COUNT_ALLOCS
	601	PyAPI_FUNC(void) inc_count(PyTypeObject *);
	602	PyAPI_FUNC(void) dec_count(PyTypeObject *);
	603	#define _Py_INC_TPALLOCS(OP) inc_count((OP)->ob_type)
	604	#define _Py_INC_TPFREES(OP) dec_count((OP)->ob_type)
	605	#define _Py_DEC_TPFREES(OP) (OP)->ob_type->tp_frees--
	606	#define _Py_COUNT_ALLOCS_COMMA ,
	607	#else
	608	#define _Py_INC_TPALLOCS(OP)
	609	#define _Py_INC_TPFREES(OP)
	610	#define _Py_DEC_TPFREES(OP)
	611	#define _Py_COUNT_ALLOCS_COMMA
	612	#endif /* COUNT_ALLOCS */
	613
	614	#ifdef Py_TRACE_REFS
	615	/* Py_TRACE_REFS is such major surgery that we call external routines. */
	616	PyAPI_FUNC(void) _Py_NewReference(PyObject *);
	617	PyAPI_FUNC(void) _Py_ForgetReference(PyObject *);
	618	PyAPI_FUNC(void) _Py_Dealloc(PyObject *);
	619	PyAPI_FUNC(void) _Py_PrintReferences(FILE *);
	620	PyAPI_FUNC(void) _Py_PrintReferenceAddresses(FILE *);
	621	PyAPI_FUNC(void) _Py_AddToAllObjects(PyObject *, int force);
	622
	623	#else
	624	/* Without Py_TRACE_REFS, there's little enough to do that we expand code
	625	* inline.
	626	*/
	627	#define _Py_NewReference(op) ( \
	628	_Py_INC_TPALLOCS(op) _Py_COUNT_ALLOCS_COMMA \
	629	_Py_INC_REFTOTAL _Py_REF_DEBUG_COMMA \
	630	(op)->ob_refcnt = 1)
	631
	632	#define _Py_ForgetReference(op) _Py_INC_TPFREES(op)
	633
	634	#define _Py_Dealloc(op) ( \
	635	_Py_INC_TPFREES(op) _Py_COUNT_ALLOCS_COMMA \
	636	((op)->ob_type->tp_dealloc)((PyObject )(op)))
	637	#endif /* !Py_TRACE_REFS */
	638
	639	#define Py_INCREF(op) ( \
	640	_Py_INC_REFTOTAL _Py_REF_DEBUG_COMMA \
	641	(op)->ob_refcnt++)
	642
	643	#define Py_DECREF(op) \
	644	if (_Py_DEC_REFTOTAL _Py_REF_DEBUG_COMMA \
	645	--(op)->ob_refcnt != 0) \
	646	_Py_CHECK_REFCNT(op) \
	647	else \
	648	_Py_Dealloc((PyObject *)(op))
	649
	650	/* Safely decref `op` and set `op` to NULL, especially useful in tp_clear
	651	* and tp_dealloc implementatons.
	652	*
	653	* Note that "the obvious" code can be deadly:
	654	*
	655	* Py_XDECREF(op);
	656	* op = NULL;
	657	*
	658	* Typically, `op` is something like self->containee, and `self` is done
	659	* using its `containee` member. In the code sequence above, suppose
	660	* `containee` is non-NULL with a refcount of 1. Its refcount falls to
	661	* 0 on the first line, which can trigger an arbitrary amount of code,
	662	* possibly including finalizers (like __del__ methods or weakref callbacks)
	663	* coded in Python, which in turn can release the GIL and allow other threads
	664	* to run, etc. Such code may even invoke methods of `self` again, or cause
	665	* cyclic gc to trigger, but-- oops! --self->containee still points to the
	666	* object being torn down, and it may be in an insane state while being torn
	667	* down. This has in fact been a rich historic source of miserable (rare &
	668	* hard-to-diagnose) segfaulting (and other) bugs.
	669	*
	670	* The safe way is:
	671	*
	672	* Py_CLEAR(op);
	673	*
	674	* That arranges to set `op` to NULL _before_ decref'ing, so that any code
	675	* triggered as a side-effect of `op` getting torn down no longer believes
	676	* `op` points to a valid object.
	677	*
	678	* There are cases where it's safe to use the naive code, but they're brittle.
	679	* For example, if `op` points to a Python integer, you know that destroying
	680	* one of those can't cause problems -- but in part that relies on that
	681	* Python integers aren't currently weakly referencable. Best practice is
	682	* to use Py_CLEAR() even if you can't think of a reason for why you need to.
	683	*/
	684	#define Py_CLEAR(op) \
	685	do { \
	686	if (op) { \
	687	PyObject tmp = (PyObject )(op); \
	688	(op) = NULL; \
	689	Py_DECREF(tmp); \
	690	} \
	691	} while (0)
	692
	693	/* Macros to use in case the object pointer may be NULL: */
	694	#define Py_XINCREF(op) if ((op) == NULL) ; else Py_INCREF(op)
	695	#define Py_XDECREF(op) if ((op) == NULL) ; else Py_DECREF(op)
	696
	697	/*
	698	These are provided as conveniences to Python runtime embedders, so that
	699	they can have object code that is not dependent on Python compilation flags.
	700	*/
	701	PyAPI_FUNC(void) Py_IncRef(PyObject *);
	702	PyAPI_FUNC(void) Py_DecRef(PyObject *);
	703
	704	/*
	705	_Py_NoneStruct is an object of undefined type which can be used in contexts
	706	where NULL (nil) is not suitable (since NULL often means 'error').
	707
	708	Don't forget to apply Py_INCREF() when returning this value!!!
	709	*/
	710	PyAPI_DATA(PyObject) _Py_NoneStruct; /* Don't use this directly */
	711	#define Py_None (&_Py_NoneStruct)
	712
	713	/* Macro for returning Py_None from a function */
	714	#define Py_RETURN_NONE return Py_INCREF(Py_None), Py_None
	715
	716	/*
	717	Py_NotImplemented is a singleton used to signal that an operation is
	718	not implemented for a given type combination.
	719	*/
	720	PyAPI_DATA(PyObject) _Py_NotImplementedStruct; /* Don't use this directly */
	721	#define Py_NotImplemented (&_Py_NotImplementedStruct)
	722
	723	/* Rich comparison opcodes */
	724	#define Py_LT 0
	725	#define Py_LE 1
	726	#define Py_EQ 2
	727	#define Py_NE 3
	728	#define Py_GT 4
	729	#define Py_GE 5
	730
	731	/* Maps Py_LT to Py_GT, ..., Py_GE to Py_LE.
	732	* Defined in object.c.
	733	*/
	734	PyAPI_DATA(int) _Py_SwappedOp[];
	735
	736	/*
	737	Define staticforward and statichere for source compatibility with old
	738	C extensions.
	739
	740	The staticforward define was needed to support certain broken C
	741	compilers (notably SCO ODT 3.0, perhaps early AIX as well) botched the
	742	static keyword when it was used with a forward declaration of a static
	743	initialized structure. Standard C allows the forward declaration with
	744	static, and we've decided to stop catering to broken C compilers.
	745	(In fact, we expect that the compilers are all fixed eight years later.)
	746	*/
	747
	748	#define staticforward static
	749	#define statichere static
	750
	751
	752	/*
	753	More conventions
	754	================
	755
	756	Argument Checking
	757	-----------------
	758
	759	Functions that take objects as arguments normally don't check for nil
	760	arguments, but they do check the type of the argument, and return an
	761	error if the function doesn't apply to the type.
	762
	763	Failure Modes
	764	-------------
	765
	766	Functions may fail for a variety of reasons, including running out of
	767	memory. This is communicated to the caller in two ways: an error string
	768	is set (see errors.h), and the function result differs: functions that
	769	normally return a pointer return NULL for failure, functions returning
	770	an integer return -1 (which could be a legal return value too!), and
	771	other functions return 0 for success and -1 for failure.
	772	Callers should always check for errors before using the result. If
	773	an error was set, the caller must either explicitly clear it, or pass
	774	the error on to its caller.
	775
	776	Reference Counts
	777	----------------
	778
	779	It takes a while to get used to the proper usage of reference counts.
	780
	781	Functions that create an object set the reference count to 1; such new
	782	objects must be stored somewhere or destroyed again with Py_DECREF().
	783	Some functions that 'store' objects, such as PyTuple_SetItem() and
	784	PyList_SetItem(),
	785	don't increment the reference count of the object, since the most
	786	frequent use is to store a fresh object. Functions that 'retrieve'
	787	objects, such as PyTuple_GetItem() and PyDict_GetItemString(), also
	788	don't increment
	789	the reference count, since most frequently the object is only looked at
	790	quickly. Thus, to retrieve an object and store it again, the caller
	791	must call Py_INCREF() explicitly.
	792
	793	NOTE: functions that 'consume' a reference count, like
	794	PyList_SetItem(), consume the reference even if the object wasn't
	795	successfully stored, to simplify error handling.
	796
	797	It seems attractive to make other functions that take an object as
	798	argument consume a reference count; however, this may quickly get
	799	confusing (even the current practice is already confusing). Consider
	800	it carefully, it may save lots of calls to Py_INCREF() and Py_DECREF() at
	801	times.
	802	*/
	803
	804
	805	/* Trashcan mechanism, thanks to Christian Tismer.
	806
	807	When deallocating a container object, it's possible to trigger an unbounded
	808	chain of deallocations, as each Py_DECREF in turn drops the refcount on "the
	809	next" object in the chain to 0. This can easily lead to stack faults, and
	810	especially in threads (which typically have less stack space to work with).
	811
	812	A container object that participates in cyclic gc can avoid this by
	813	bracketing the body of its tp_dealloc function with a pair of macros:
	814
	815	static void
	816	mytype_dealloc(mytype *p)
	817	{
	818	... declarations go here ...
	819
	820	PyObject_GC_UnTrack(p); // must untrack first
	821	Py_TRASHCAN_SAFE_BEGIN(p)
	822	... The body of the deallocator goes here, including all calls ...
	823	... to Py_DECREF on contained objects. ...
	824	Py_TRASHCAN_SAFE_END(p)
	825	}
	826
	827	CAUTION: Never return from the middle of the body! If the body needs to
	828	"get out early", put a label immediately before the Py_TRASHCAN_SAFE_END
	829	call, and goto it. Else the call-depth counter (see below) will stay
	830	above 0 forever, and the trashcan will never get emptied.
	831
	832	How it works: The BEGIN macro increments a call-depth counter. So long
	833	as this counter is small, the body of the deallocator is run directly without
	834	further ado. But if the counter gets large, it instead adds p to a list of
	835	objects to be deallocated later, skips the body of the deallocator, and
	836	resumes execution after the END macro. The tp_dealloc routine then returns
	837	without deallocating anything (and so unbounded call-stack depth is avoided).
	838
	839	When the call stack finishes unwinding again, code generated by the END macro
	840	notices this, and calls another routine to deallocate all the objects that
	841	may have been added to the list of deferred deallocations. In effect, a
	842	chain of N deallocations is broken into N / PyTrash_UNWIND_LEVEL pieces,
	843	with the call stack never exceeding a depth of PyTrash_UNWIND_LEVEL.
	844	*/
	845
	846	PyAPI_FUNC(void) _PyTrash_deposit_object(PyObject*);
	847	PyAPI_FUNC(void) _PyTrash_destroy_chain(void);
	848	PyAPI_DATA(int) _PyTrash_delete_nesting;
	849	PyAPI_DATA(PyObject *) _PyTrash_delete_later;
	850
	851	#define PyTrash_UNWIND_LEVEL 50
	852
	853	#define Py_TRASHCAN_SAFE_BEGIN(op) \
	854	if (_PyTrash_delete_nesting < PyTrash_UNWIND_LEVEL) { \
	855	++_PyTrash_delete_nesting;
	856	/* The body of the deallocator is here. */
	857	#define Py_TRASHCAN_SAFE_END(op) \
	858	--_PyTrash_delete_nesting; \
	859	if (_PyTrash_delete_later && _PyTrash_delete_nesting <= 0) \
	860	_PyTrash_destroy_chain(); \
	861	} \
	862	else \
	863	_PyTrash_deposit_object((PyObject*)op);
	864
	865	#ifdef __cplusplus
	866	}
	867	#endif
	868	#endif /* !Py_OBJECT_H */

sys/src/cmd/python/Include/objimpl.h+336−0

@@ -0,0 +1,336 @@
	1	/* The PyObject_ memory family: high-level object memory interfaces.
	2	See pymem.h for the low-level PyMem_ family.
	3	*/
	4
	5	#ifndef Py_OBJIMPL_H
	6	#define Py_OBJIMPL_H
	7
	8	#include "pymem.h"
	9
	10	#ifdef __cplusplus
	11	extern "C" {
	12	#endif
	13
	14	/* BEWARE:
	15
	16	Each interface exports both functions and macros. Extension modules should
	17	use the functions, to ensure binary compatibility across Python versions.
	18	Because the Python implementation is free to change internal details, and
	19	the macros may (or may not) expose details for speed, if you do use the
	20	macros you must recompile your extensions with each Python release.
	21
	22	Never mix calls to PyObject_ memory functions with calls to the platform
	23	malloc/realloc/ calloc/free, or with calls to PyMem_.
	24	*/
	25
	26	/*
	27	Functions and macros for modules that implement new object types.
	28
	29	- PyObject_New(type, typeobj) allocates memory for a new object of the given
	30	type, and initializes part of it. 'type' must be the C structure type used
	31	to represent the object, and 'typeobj' the address of the corresponding
	32	type object. Reference count and type pointer are filled in; the rest of
	33	the bytes of the object are undefined! The resulting expression type is
	34	'type *'. The size of the object is determined by the tp_basicsize field
	35	of the type object.
	36
	37	- PyObject_NewVar(type, typeobj, n) is similar but allocates a variable-size
	38	object with room for n items. In addition to the refcount and type pointer
	39	fields, this also fills in the ob_size field.
	40
	41	- PyObject_Del(op) releases the memory allocated for an object. It does not
	42	run a destructor -- it only frees the memory. PyObject_Free is identical.
	43
	44	- PyObject_Init(op, typeobj) and PyObject_InitVar(op, typeobj, n) don't
	45	allocate memory. Instead of a 'type' parameter, they take a pointer to a
	46	new object (allocated by an arbitrary allocator), and initialize its object
	47	header fields.
	48
	49	Note that objects created with PyObject_{New, NewVar} are allocated using the
	50	specialized Python allocator (implemented in obmalloc.c), if WITH_PYMALLOC is
	51	enabled. In addition, a special debugging allocator is used if PYMALLOC_DEBUG
	52	is also #defined.
	53
	54	In case a specific form of memory management is needed (for example, if you
	55	must use the platform malloc heap(s), or shared memory, or C++ local storage or
	56	operator new), you must first allocate the object with your custom allocator,
	57	then pass its pointer to PyObject_{Init, InitVar} for filling in its Python-
	58	specific fields: reference count, type pointer, possibly others. You should
	59	be aware that Python no control over these objects because they don't
	60	cooperate with the Python memory manager. Such objects may not be eligible
	61	for automatic garbage collection and you have to make sure that they are
	62	released accordingly whenever their destructor gets called (cf. the specific
	63	form of memory management you're using).
	64
	65	Unless you have specific memory management requirements, use
	66	PyObject_{New, NewVar, Del}.
	67	*/
	68
	69	/*
	70	* Raw object memory interface
	71	* ===========================
	72	*/
	73
	74	/* Functions to call the same malloc/realloc/free as used by Python's
	75	object allocator. If WITH_PYMALLOC is enabled, these may differ from
	76	the platform malloc/realloc/free. The Python object allocator is
	77	designed for fast, cache-conscious allocation of many "small" objects,
	78	and with low hidden memory overhead.
	79
	80	PyObject_Malloc(0) returns a unique non-NULL pointer if possible.
	81
	82	PyObject_Realloc(NULL, n) acts like PyObject_Malloc(n).
	83	PyObject_Realloc(p != NULL, 0) does not return NULL, or free the memory
	84	at p.
	85
	86	Returned pointers must be checked for NULL explicitly; no action is
	87	performed on failure other than to return NULL (no warning it printed, no
	88	exception is set, etc).
	89
	90	For allocating objects, use PyObject_{New, NewVar} instead whenever
	91	possible. The PyObject_{Malloc, Realloc, Free} family is exposed
	92	so that you can exploit Python's small-block allocator for non-object
	93	uses. If you must use these routines to allocate object memory, make sure
	94	the object gets initialized via PyObject_{Init, InitVar} after obtaining
	95	the raw memory.
	96	*/
	97	PyAPI_FUNC(void *) PyObject_Malloc(size_t);
	98	PyAPI_FUNC(void ) PyObject_Realloc(void , size_t);
	99	PyAPI_FUNC(void) PyObject_Free(void *);
	100
	101
	102	/* Macros */
	103	#ifdef WITH_PYMALLOC
	104	#ifdef PYMALLOC_DEBUG /* WITH_PYMALLOC && PYMALLOC_DEBUG */
	105	PyAPI_FUNC(void *) _PyObject_DebugMalloc(size_t nbytes);
	106	PyAPI_FUNC(void ) _PyObject_DebugRealloc(void p, size_t nbytes);
	107	PyAPI_FUNC(void) _PyObject_DebugFree(void *p);
	108	PyAPI_FUNC(void) _PyObject_DebugDumpAddress(const void *p);
	109	PyAPI_FUNC(void) _PyObject_DebugCheckAddress(const void *p);
	110	PyAPI_FUNC(void) _PyObject_DebugMallocStats(void);
	111	#define PyObject_MALLOC _PyObject_DebugMalloc
	112	#define PyObject_Malloc _PyObject_DebugMalloc
	113	#define PyObject_REALLOC _PyObject_DebugRealloc
	114	#define PyObject_Realloc _PyObject_DebugRealloc
	115	#define PyObject_FREE _PyObject_DebugFree
	116	#define PyObject_Free _PyObject_DebugFree
	117
	118	#else /* WITH_PYMALLOC && ! PYMALLOC_DEBUG */
	119	#define PyObject_MALLOC PyObject_Malloc
	120	#define PyObject_REALLOC PyObject_Realloc
	121	#define PyObject_FREE PyObject_Free
	122	#endif
	123
	124	#else /* ! WITH_PYMALLOC */
	125	#define PyObject_MALLOC PyMem_MALLOC
	126	#define PyObject_REALLOC PyMem_REALLOC
	127	#define PyObject_FREE PyMem_FREE
	128
	129	#endif /* WITH_PYMALLOC */
	130
	131	#define PyObject_Del PyObject_Free
	132	#define PyObject_DEL PyObject_FREE
	133
	134	/* for source compatibility with 2.2 */
	135	#define _PyObject_Del PyObject_Free
	136
	137	/*
	138	* Generic object allocator interface
	139	* ==================================
	140	*/
	141
	142	/* Functions */
	143	PyAPI_FUNC(PyObject ) PyObject_Init(PyObject , PyTypeObject *);
	144	PyAPI_FUNC(PyVarObject ) PyObject_InitVar(PyVarObject ,
	145	PyTypeObject *, Py_ssize_t);
	146	PyAPI_FUNC(PyObject ) _PyObject_New(PyTypeObject );
	147	PyAPI_FUNC(PyVarObject ) _PyObject_NewVar(PyTypeObject , Py_ssize_t);
	148
	149	#define PyObject_New(type, typeobj) \
	150	( (type *) _PyObject_New(typeobj) )
	151	#define PyObject_NewVar(type, typeobj, n) \
	152	( (type *) _PyObject_NewVar((typeobj), (n)) )
	153
	154	/* Macros trading binary compatibility for speed. See also pymem.h.
	155	Note that these macros expect non-NULL object pointers.*/
	156	#define PyObject_INIT(op, typeobj) \
	157	( (op)->ob_type = (typeobj), _Py_NewReference((PyObject *)(op)), (op) )
	158	#define PyObject_INIT_VAR(op, typeobj, size) \
	159	( (op)->ob_size = (size), PyObject_INIT((op), (typeobj)) )
	160
	161	#define _PyObject_SIZE(typeobj) ( (typeobj)->tp_basicsize )
	162
	163	/* _PyObject_VAR_SIZE returns the number of bytes (as size_t) allocated for a
	164	vrbl-size object with nitems items, exclusive of gc overhead (if any). The
	165	value is rounded up to the closest multiple of sizeof(void *), in order to
	166	ensure that pointer fields at the end of the object are correctly aligned
	167	for the platform (this is of special importance for subclasses of, e.g.,
	168	str or long, so that pointers can be stored after the embedded data).
	169
	170	Note that there's no memory wastage in doing this, as malloc has to
	171	return (at worst) pointer-aligned memory anyway.
	172	*/
	173	#if ((SIZEOF_VOID_P - 1) & SIZEOF_VOID_P) != 0
	174	# error "_PyObject_VAR_SIZE requires SIZEOF_VOID_P be a power of 2"
	175	#endif
	176
	177	#define _PyObject_VAR_SIZE(typeobj, nitems) \
	178	(size_t) \
	179	( ( (typeobj)->tp_basicsize + \
	180	(nitems)*(typeobj)->tp_itemsize + \
	181	(SIZEOF_VOID_P - 1) \
	182	) & ~(SIZEOF_VOID_P - 1) \
	183	)
	184
	185	#define PyObject_NEW(type, typeobj) \
	186	( (type *) PyObject_Init( \
	187	(PyObject *) PyObject_MALLOC( _PyObject_SIZE(typeobj) ), (typeobj)) )
	188
	189	#define PyObject_NEW_VAR(type, typeobj, n) \
	190	( (type *) PyObject_InitVar( \
	191	(PyVarObject *) PyObject_MALLOC(_PyObject_VAR_SIZE((typeobj),(n)) ),\
	192	(typeobj), (n)) )
	193
	194	/* This example code implements an object constructor with a custom
	195	allocator, where PyObject_New is inlined, and shows the important
	196	distinction between two steps (at least):
	197	1) the actual allocation of the object storage;
	198	2) the initialization of the Python specific fields
	199	in this storage with PyObject_{Init, InitVar}.
	200
	201	PyObject *
	202	YourObject_New(...)
	203	{
	204	PyObject *op;
	205
	206	op = (PyObject *) Your_Allocator(_PyObject_SIZE(YourTypeStruct));
	207	if (op == NULL)
	208	return PyErr_NoMemory();
	209
	210	PyObject_Init(op, &YourTypeStruct);
	211
	212	op->ob_field = value;
	213	...
	214	return op;
	215	}
	216
	217	Note that in C++, the use of the new operator usually implies that
	218	the 1st step is performed automatically for you, so in a C++ class
	219	constructor you would start directly with PyObject_Init/InitVar
	220	*/
	221
	222	/*
	223	* Garbage Collection Support
	224	* ==========================
	225	*/
	226
	227	/* C equivalent of gc.collect(). */
	228	PyAPI_FUNC(Py_ssize_t) PyGC_Collect(void);
	229
	230	/* Test if a type has a GC head */
	231	#define PyType_IS_GC(t) PyType_HasFeature((t), Py_TPFLAGS_HAVE_GC)
	232
	233	/* Test if an object has a GC head */
	234	#define PyObject_IS_GC(o) (PyType_IS_GC((o)->ob_type) && \
	235	((o)->ob_type->tp_is_gc == NULL \|\| (o)->ob_type->tp_is_gc(o)))
	236
	237	PyAPI_FUNC(PyVarObject ) _PyObject_GC_Resize(PyVarObject , Py_ssize_t);
	238	#define PyObject_GC_Resize(type, op, n) \
	239	( (type ) _PyObject_GC_Resize((PyVarObject )(op), (n)) )
	240
	241	/* for source compatibility with 2.2 */
	242	#define _PyObject_GC_Del PyObject_GC_Del
	243
	244	/* GC information is stored BEFORE the object structure. */
	245	typedef union _gc_head {
	246	struct {
	247	union _gc_head *gc_next;
	248	union _gc_head *gc_prev;
	249	Py_ssize_t gc_refs;
	250	} gc;
	251	long double dummy; /* force worst-case alignment */
	252	} PyGC_Head;
	253
	254	extern PyGC_Head *_PyGC_generation0;
	255
	256	#define _Py_AS_GC(o) ((PyGC_Head *)(o)-1)
	257
	258	#define _PyGC_REFS_UNTRACKED (-2)
	259	#define _PyGC_REFS_REACHABLE (-3)
	260	#define _PyGC_REFS_TENTATIVELY_UNREACHABLE (-4)
	261
	262	/* Tell the GC to track this object. NB: While the object is tracked the
	263	* collector it must be safe to call the ob_traverse method. */
	264	#define _PyObject_GC_TRACK(o) do { \
	265	PyGC_Head *g = _Py_AS_GC(o); \
	266	if (g->gc.gc_refs != _PyGC_REFS_UNTRACKED) \
	267	Py_FatalError("GC object already tracked"); \
	268	g->gc.gc_refs = _PyGC_REFS_REACHABLE; \
	269	g->gc.gc_next = _PyGC_generation0; \
	270	g->gc.gc_prev = _PyGC_generation0->gc.gc_prev; \
	271	g->gc.gc_prev->gc.gc_next = g; \
	272	_PyGC_generation0->gc.gc_prev = g; \
	273	} while (0);
	274
	275	/* Tell the GC to stop tracking this object.
	276	* gc_next doesn't need to be set to NULL, but doing so is a good
	277	* way to provoke memory errors if calling code is confused.
	278	*/
	279	#define _PyObject_GC_UNTRACK(o) do { \
	280	PyGC_Head *g = _Py_AS_GC(o); \
	281	assert(g->gc.gc_refs != _PyGC_REFS_UNTRACKED); \
	282	g->gc.gc_refs = _PyGC_REFS_UNTRACKED; \
	283	g->gc.gc_prev->gc.gc_next = g->gc.gc_next; \
	284	g->gc.gc_next->gc.gc_prev = g->gc.gc_prev; \
	285	g->gc.gc_next = NULL; \
	286	} while (0);
	287
	288	PyAPI_FUNC(PyObject *) _PyObject_GC_Malloc(size_t);
	289	PyAPI_FUNC(PyObject ) _PyObject_GC_New(PyTypeObject );
	290	PyAPI_FUNC(PyVarObject ) _PyObject_GC_NewVar(PyTypeObject , Py_ssize_t);
	291	PyAPI_FUNC(void) PyObject_GC_Track(void *);
	292	PyAPI_FUNC(void) PyObject_GC_UnTrack(void *);
	293	PyAPI_FUNC(void) PyObject_GC_Del(void *);
	294
	295	#define PyObject_GC_New(type, typeobj) \
	296	( (type *) _PyObject_GC_New(typeobj) )
	297	#define PyObject_GC_NewVar(type, typeobj, n) \
	298	( (type *) _PyObject_GC_NewVar((typeobj), (n)) )
	299
	300
	301	/* Utility macro to help write tp_traverse functions.
	302	* To use this macro, the tp_traverse function must name its arguments
	303	* "visit" and "arg". This is intended to keep tp_traverse functions
	304	* looking as much alike as possible.
	305	*/
	306	#define Py_VISIT(op) \
	307	do { \
	308	if (op) { \
	309	int vret = visit((PyObject *)(op), arg); \
	310	if (vret) \
	311	return vret; \
	312	} \
	313	} while (0)
	314
	315	/* This is here for the sake of backwards compatibility. Extensions that
	316	* use the old GC API will still compile but the objects will not be
	317	* tracked by the GC. */
	318	#define PyGC_HEAD_SIZE 0
	319	#define PyObject_GC_Init(op)
	320	#define PyObject_GC_Fini(op)
	321	#define PyObject_AS_GC(op) (op)
	322	#define PyObject_FROM_GC(op) (op)
	323
	324
	325	/* Test if a type supports weak references */
	326	#define PyType_SUPPORTS_WEAKREFS(t) \
	327	(PyType_HasFeature((t), Py_TPFLAGS_HAVE_WEAKREFS) \
	328	&& ((t)->tp_weaklistoffset > 0))
	329
	330	#define PyObject_GET_WEAKREFS_LISTPTR(o) \
	331	((PyObject *) (((char ) (o)) + (o)->ob_type->tp_weaklistoffset))
	332
	333	#ifdef __cplusplus
	334	}
	335	#endif
	336	#endif /* !Py_OBJIMPL_H */

sys/src/cmd/python/Include/opcode.h+152−0

@@ -0,0 +1,152 @@
	1	#ifndef Py_OPCODE_H
	2	#define Py_OPCODE_H
	3	#ifdef __cplusplus
	4	extern "C" {
	5	#endif
	6
	7
	8	/* Instruction opcodes for compiled code */
	9
	10	#define STOP_CODE 0
	11	#define POP_TOP 1
	12	#define ROT_TWO 2
	13	#define ROT_THREE 3
	14	#define DUP_TOP 4
	15	#define ROT_FOUR 5
	16	#define NOP 9
	17
	18	#define UNARY_POSITIVE 10
	19	#define UNARY_NEGATIVE 11
	20	#define UNARY_NOT 12
	21	#define UNARY_CONVERT 13
	22
	23	#define UNARY_INVERT 15
	24
	25	#define LIST_APPEND 18
	26	#define BINARY_POWER 19
	27
	28	#define BINARY_MULTIPLY 20
	29	#define BINARY_DIVIDE 21
	30	#define BINARY_MODULO 22
	31	#define BINARY_ADD 23
	32	#define BINARY_SUBTRACT 24
	33	#define BINARY_SUBSCR 25
	34	#define BINARY_FLOOR_DIVIDE 26
	35	#define BINARY_TRUE_DIVIDE 27
	36	#define INPLACE_FLOOR_DIVIDE 28
	37	#define INPLACE_TRUE_DIVIDE 29
	38
	39	#define SLICE 30
	40	/* Also uses 31-33 */
	41
	42	#define STORE_SLICE 40
	43	/* Also uses 41-43 */
	44
	45	#define DELETE_SLICE 50
	46	/* Also uses 51-53 */
	47
	48	#define INPLACE_ADD 55
	49	#define INPLACE_SUBTRACT 56
	50	#define INPLACE_MULTIPLY 57
	51	#define INPLACE_DIVIDE 58
	52	#define INPLACE_MODULO 59
	53	#define STORE_SUBSCR 60
	54	#define DELETE_SUBSCR 61
	55
	56	#define BINARY_LSHIFT 62
	57	#define BINARY_RSHIFT 63
	58	#define BINARY_AND 64
	59	#define BINARY_XOR 65
	60	#define BINARY_OR 66
	61	#define INPLACE_POWER 67
	62	#define GET_ITER 68
	63
	64	#define PRINT_EXPR 70
	65	#define PRINT_ITEM 71
	66	#define PRINT_NEWLINE 72
	67	#define PRINT_ITEM_TO 73
	68	#define PRINT_NEWLINE_TO 74
	69	#define INPLACE_LSHIFT 75
	70	#define INPLACE_RSHIFT 76
	71	#define INPLACE_AND 77
	72	#define INPLACE_XOR 78
	73	#define INPLACE_OR 79
	74	#define BREAK_LOOP 80
	75	#define WITH_CLEANUP 81
	76	#define LOAD_LOCALS 82
	77	#define RETURN_VALUE 83
	78	#define IMPORT_STAR 84
	79	#define EXEC_STMT 85
	80	#define YIELD_VALUE 86
	81	#define POP_BLOCK 87
	82	#define END_FINALLY 88
	83	#define BUILD_CLASS 89
	84
	85	#define HAVE_ARGUMENT 90 /* Opcodes from here have an argument: */
	86
	87	#define STORE_NAME 90 /* Index in name list */
	88	#define DELETE_NAME 91 /* "" */
	89	#define UNPACK_SEQUENCE 92 /* Number of sequence items */
	90	#define FOR_ITER 93
	91
	92	#define STORE_ATTR 95 /* Index in name list */
	93	#define DELETE_ATTR 96 /* "" */
	94	#define STORE_GLOBAL 97 /* "" */
	95	#define DELETE_GLOBAL 98 /* "" */
	96	#define DUP_TOPX 99 /* number of items to duplicate */
	97	#define LOAD_CONST 100 /* Index in const list */
	98	#define LOAD_NAME 101 /* Index in name list */
	99	#define BUILD_TUPLE 102 /* Number of tuple items */
	100	#define BUILD_LIST 103 /* Number of list items */
	101	#define BUILD_MAP 104 /* Always zero for now */
	102	#define LOAD_ATTR 105 /* Index in name list */
	103	#define COMPARE_OP 106 /* Comparison operator */
	104	#define IMPORT_NAME 107 /* Index in name list */
	105	#define IMPORT_FROM 108 /* Index in name list */
	106
	107	#define JUMP_FORWARD 110 /* Number of bytes to skip */
	108	#define JUMP_IF_FALSE 111 /* "" */
	109	#define JUMP_IF_TRUE 112 /* "" */
	110	#define JUMP_ABSOLUTE 113 /* Target byte offset from beginning of code */
	111
	112	#define LOAD_GLOBAL 116 /* Index in name list */
	113
	114	#define CONTINUE_LOOP 119 /* Start of loop (absolute) */
	115	#define SETUP_LOOP 120 /* Target address (absolute) */
	116	#define SETUP_EXCEPT 121 /* "" */
	117	#define SETUP_FINALLY 122 /* "" */
	118
	119	#define LOAD_FAST 124 /* Local variable number */
	120	#define STORE_FAST 125 /* Local variable number */
	121	#define DELETE_FAST 126 /* Local variable number */
	122
	123	#define RAISE_VARARGS 130 /* Number of raise arguments (1, 2 or 3) */
	124	/* CALL_FUNCTION_XXX opcodes defined below depend on this definition */
	125	#define CALL_FUNCTION 131 /* #args + (#kwargs<<8) */
	126	#define MAKE_FUNCTION 132 /* #defaults */
	127	#define BUILD_SLICE 133 /* Number of items */
	128
	129	#define MAKE_CLOSURE 134 /* #free vars */
	130	#define LOAD_CLOSURE 135 /* Load free variable from closure */
	131	#define LOAD_DEREF 136 /* Load and dereference from closure cell */
	132	#define STORE_DEREF 137 /* Store into cell */
	133
	134	/* The next 3 opcodes must be contiguous and satisfy
	135	(CALL_FUNCTION_VAR - CALL_FUNCTION) & 3 == 1 */
	136	#define CALL_FUNCTION_VAR 140 /* #args + (#kwargs<<8) */
	137	#define CALL_FUNCTION_KW 141 /* #args + (#kwargs<<8) */
	138	#define CALL_FUNCTION_VAR_KW 142 /* #args + (#kwargs<<8) */
	139
	140	/* Support for opargs more than 16 bits long */
	141	#define EXTENDED_ARG 143
	142
	143
	144	enum cmp_op {PyCmp_LT=Py_LT, PyCmp_LE=Py_LE, PyCmp_EQ=Py_EQ, PyCmp_NE=Py_NE, PyCmp_GT=Py_GT, PyCmp_GE=Py_GE,
	145	PyCmp_IN, PyCmp_NOT_IN, PyCmp_IS, PyCmp_IS_NOT, PyCmp_EXC_MATCH, PyCmp_BAD};
	146
	147	#define HAS_ARG(op) ((op) >= HAVE_ARGUMENT)
	148
	149	#ifdef __cplusplus
	150	}
	151	#endif
	152	#endif /* !Py_OPCODE_H */

sys/src/cmd/python/Include/osdefs.h+55−0

@@ -0,0 +1,55 @@
	1	#ifndef Py_OSDEFS_H
	2	#define Py_OSDEFS_H
	3	#ifdef __cplusplus
	4	extern "C" {
	5	#endif
	6
	7
	8	/* Operating system dependencies */
	9
	10	/* Mod by chrish: QNX has WATCOM, but isn't DOS */
	11	#if !defined(__QNX__)
	12	#if defined(MS_WINDOWS) \|\| defined(__BORLANDC__) \|\| defined(__WATCOMC__) \|\| defined(__DJGPP__) \|\| defined(PYOS_OS2)
	13	#if defined(PYOS_OS2) && defined(PYCC_GCC)
	14	#define MAXPATHLEN 260
	15	#define SEP '/'
	16	#define ALTSEP '\\'
	17	#else
	18	#define SEP '\\'
	19	#define ALTSEP '/'
	20	#define MAXPATHLEN 256
	21	#endif
	22	#define DELIM ';'
	23	#endif
	24	#endif
	25
	26	#ifdef RISCOS
	27	#define SEP '.'
	28	#define MAXPATHLEN 256
	29	#define DELIM ','
	30	#endif
	31
	32
	33	/* Filename separator */
	34	#ifndef SEP
	35	#define SEP '/'
	36	#endif
	37
	38	/* Max pathname length */
	39	#ifndef MAXPATHLEN
	40	#if defined(PATH_MAX) && PATH_MAX > 1024
	41	#define MAXPATHLEN PATH_MAX
	42	#else
	43	#define MAXPATHLEN 1024
	44	#endif
	45	#endif
	46
	47	/* Search path entry delimiter */
	48	#ifndef DELIM
	49	#define DELIM ':'
	50	#endif
	51
	52	#ifdef __cplusplus
	53	}
	54	#endif
	55	#endif /* !Py_OSDEFS_H */

sys/src/cmd/python/Include/parsetok.h+50−0

@@ -0,0 +1,50 @@
	1
	2	/* Parser-tokenizer link interface */
	3
	4	#ifndef Py_PARSETOK_H
	5	#define Py_PARSETOK_H
	6	#ifdef __cplusplus
	7	extern "C" {
	8	#endif
	9
	10	typedef struct {
	11	int error;
	12	const char *filename;
	13	int lineno;
	14	int offset;
	15	char *text;
	16	int token;
	17	int expected;
	18	} perrdetail;
	19
	20	#if 0
	21	#define PyPARSE_YIELD_IS_KEYWORD 0x0001
	22	#endif
	23
	24	#define PyPARSE_DONT_IMPLY_DEDENT 0x0002
	25
	26	#define PyPARSE_WITH_IS_KEYWORD 0x0003
	27
	28	PyAPI_FUNC(node ) PyParser_ParseString(const char , grammar *, int,
	29	perrdetail *);
	30	PyAPI_FUNC(node ) PyParser_ParseFile (FILE , const char , grammar , int,
	31	char , char , perrdetail *);
	32
	33	PyAPI_FUNC(node ) PyParser_ParseStringFlags(const char , grammar *, int,
	34	perrdetail *, int);
	35	PyAPI_FUNC(node ) PyParser_ParseFileFlags(FILE , const char , grammar ,
	36	int, char , char ,
	37	perrdetail *, int);
	38
	39	PyAPI_FUNC(node ) PyParser_ParseStringFlagsFilename(const char ,
	40	const char *,
	41	grammar *, int,
	42	perrdetail *, int);
	43
	44	/* Note that he following function is defined in pythonrun.c not parsetok.c. */
	45	PyAPI_FUNC(void) PyParser_SetError(perrdetail *);
	46
	47	#ifdef __cplusplus
	48	}
	49	#endif
	50	#endif /* !Py_PARSETOK_H */

sys/src/cmd/python/Include/patchlevel.h+40−0

@@ -0,0 +1,40 @@
	1
	2	/* Newfangled version identification scheme.
	3
	4	This scheme was added in Python 1.5.2b2; before that time, only PATCHLEVEL
	5	was available. To test for presence of the scheme, test for
	6	defined(PY_MAJOR_VERSION).
	7
	8	When the major or minor version changes, the VERSION variable in
	9	configure.in must also be changed.
	10
	11	There is also (independent) API version information in modsupport.h.
	12	*/
	13
	14	/* Values for PY_RELEASE_LEVEL */
	15	#define PY_RELEASE_LEVEL_ALPHA 0xA
	16	#define PY_RELEASE_LEVEL_BETA 0xB
	17	#define PY_RELEASE_LEVEL_GAMMA 0xC /* For release candidates */
	18	#define PY_RELEASE_LEVEL_FINAL 0xF /* Serial should be 0 here */
	19	/* Higher for patch releases */
	20
	21	/* Version parsed out into numeric values */
	22	#define PY_MAJOR_VERSION 2
	23	#define PY_MINOR_VERSION 5
	24	#define PY_MICRO_VERSION 1
	25	#define PY_RELEASE_LEVEL PY_RELEASE_LEVEL_FINAL
	26	#define PY_RELEASE_SERIAL 0
	27
	28	/* Version as a string */
	29	#define PY_VERSION "2.5.1"
	30
	31	/* Subversion Revision number of this file (not of the repository) */
	32	#define PY_PATCHLEVEL_REVISION "$Revision: 54863 $"
	33
	34	/* Version as a single 4-byte hex number, e.g. 0x010502B2 == 1.5.2b2.
	35	Use this for numeric comparisons, e.g. #if PY_VERSION_HEX >= ... */
	36	#define PY_VERSION_HEX ((PY_MAJOR_VERSION << 24) \| \
	37	(PY_MINOR_VERSION << 16) \| \
	38	(PY_MICRO_VERSION << 8) \| \
	39	(PY_RELEASE_LEVEL << 4) \| \
	40	(PY_RELEASE_SERIAL << 0))

sys/src/cmd/python/Include/pgen.h+18−0

@@ -0,0 +1,18 @@
	1	#ifndef Py_PGEN_H
	2	#define Py_PGEN_H
	3	#ifdef __cplusplus
	4	extern "C" {
	5	#endif
	6
	7
	8	/* Parser generator interface */
	9
	10	extern grammar *meta_grammar(void);
	11
	12	struct _node;
	13	extern grammar pgen(struct _node );
	14
	15	#ifdef __cplusplus
	16	}
	17	#endif
	18	#endif /* !Py_PGEN_H */

sys/src/cmd/python/Include/pgenheaders.h+42−0

@@ -0,0 +1,42 @@
	1	#ifndef Py_PGENHEADERS_H
	2	#define Py_PGENHEADERS_H
	3	#ifdef __cplusplus
	4	extern "C" {
	5	#endif
	6
	7
	8	/* Include files and extern declarations used by most of the parser. */
	9
	10	#include "Python.h"
	11
	12	PyAPI_FUNC(void) PySys_WriteStdout(const char *format, ...)
	13	Py_GCC_ATTRIBUTE((format(printf, 1, 2)));
	14	PyAPI_FUNC(void) PySys_WriteStderr(const char *format, ...)
	15	Py_GCC_ATTRIBUTE((format(printf, 1, 2)));
	16
	17	#define addarc _Py_addarc
	18	#define addbit _Py_addbit
	19	#define adddfa _Py_adddfa
	20	#define addfirstsets _Py_addfirstsets
	21	#define addlabel _Py_addlabel
	22	#define addstate _Py_addstate
	23	#define delbitset _Py_delbitset
	24	#define dumptree _Py_dumptree
	25	#define findlabel _Py_findlabel
	26	#define mergebitset _Py_mergebitset
	27	#define meta_grammar _Py_meta_grammar
	28	#define newbitset _Py_newbitset
	29	#define newgrammar _Py_newgrammar
	30	#define pgen _Py_pgen
	31	#define printgrammar _Py_printgrammar
	32	#define printnonterminals _Py_printnonterminals
	33	#define printtree _Py_printtree
	34	#define samebitset _Py_samebitset
	35	#define showtree _Py_showtree
	36	#define tok_dump _Py_tok_dump
	37	#define translatelabels _Py_translatelabels
	38
	39	#ifdef __cplusplus
	40	}
	41	#endif
	42	#endif /* !Py_PGENHEADERS_H */

sys/src/cmd/python/Include/py_curses.h+176−0

@@ -0,0 +1,176 @@
	1
	2	#ifndef Py_CURSES_H
	3	#define Py_CURSES_H
	4
	5	#ifdef __APPLE__
	6	/*
	7	** On Mac OS X 10.2 [n]curses.h and stdlib.h use different guards
	8	** against multiple definition of wchar_t.
	9	*/
	10	#ifdef _BSD_WCHAR_T_DEFINED_
	11	#define _WCHAR_T
	12	#endif
	13	#endif
	14
	15	#ifdef __FreeBSD__
	16	/*
	17	** On FreeBSD, [n]curses.h and stdlib.h/wchar.h use different guards
	18	** against multiple definition of wchar_t and wint_t.
	19	*/
	20	#ifdef _XOPEN_SOURCE_EXTENDED
	21	#ifndef __FreeBSD_version
	22	#include <osreldate.h>
	23	#endif
	24	#if __FreeBSD_version >= 500000
	25	#ifndef __wchar_t
	26	#define __wchar_t
	27	#endif
	28	#ifndef __wint_t
	29	#define __wint_t
	30	#endif
	31	#else
	32	#ifndef _WCHAR_T
	33	#define _WCHAR_T
	34	#endif
	35	#ifndef _WINT_T
	36	#define _WINT_T
	37	#endif
	38	#endif
	39	#endif
	40	#endif
	41
	42	#ifdef HAVE_NCURSES_H
	43	#include <ncurses.h>
	44	#else
	45	#include <curses.h>
	46	#ifdef HAVE_TERM_H
	47	/* for tigetstr, which is not declared in SysV curses */
	48	#include <term.h>
	49	#endif
	50	#endif
	51
	52	#ifdef HAVE_NCURSES_H
	53	/* configure was checking <curses.h>, but we will
	54	use <ncurses.h>, which has all these features. */
	55	#ifndef WINDOW_HAS_FLAGS
	56	#define WINDOW_HAS_FLAGS 1
	57	#endif
	58	#ifndef MVWDELCH_IS_EXPRESSION
	59	#define MVWDELCH_IS_EXPRESSION 1
	60	#endif
	61	#endif
	62
	63	#ifdef __cplusplus
	64	extern "C" {
	65	#endif
	66
	67	#define PyCurses_API_pointers 4
	68
	69	/* Type declarations */
	70
	71	typedef struct {
	72	PyObject_HEAD
	73	WINDOW *win;
	74	} PyCursesWindowObject;
	75
	76	#define PyCursesWindow_Check(v) ((v)->ob_type == &PyCursesWindow_Type)
	77
	78	#ifdef CURSES_MODULE
	79	/* This section is used when compiling _cursesmodule.c */
	80
	81	#else
	82	/* This section is used in modules that use the _cursesmodule API */
	83
	84	static void **PyCurses_API;
	85
	86	#define PyCursesWindow_Type ((PyTypeObject ) PyCurses_API[0])
	87	#define PyCursesSetupTermCalled {if (! ((int (*)(void))PyCurses_API[1]) () ) return NULL;}
	88	#define PyCursesInitialised {if (! ((int (*)(void))PyCurses_API[2]) () ) return NULL;}
	89	#define PyCursesInitialisedColor {if (! ((int (*)(void))PyCurses_API[3]) () ) return NULL;}
	90
	91	#define import_curses() \
	92	{ \
	93	PyObject *module = PyImport_ImportModule("_curses"); \
	94	if (module != NULL) { \
	95	PyObject *module_dict = PyModule_GetDict(module); \
	96	PyObject *c_api_object = PyDict_GetItemString(module_dict, "_C_API"); \
	97	if (PyCObject_Check(c_api_object)) { \
	98	PyCurses_API = (void **)PyCObject_AsVoidPtr(c_api_object); \
	99	} \
	100	} \
	101	}
	102	#endif
	103
	104	/* general error messages */
	105	static char *catchall_ERR = "curses function returned ERR";
	106	static char *catchall_NULL = "curses function returned NULL";
	107
	108	/* Function Prototype Macros - They are ugly but very, very useful. ;-)
	109
	110	X - function name
	111	TYPE - parameter Type
	112	ERGSTR - format string for construction of the return value
	113	PARSESTR - format string for argument parsing
	114	*/
	115
	116	#define NoArgNoReturnFunction(X) \
	117	static PyObject PyCurses_ ## X (PyObject self) \
	118	{ \
	119	PyCursesInitialised \
	120	return PyCursesCheckERR(X(), # X); }
	121
	122	#define NoArgOrFlagNoReturnFunction(X) \
	123	static PyObject PyCurses_ ## X (PyObject self, PyObject *args) \
	124	{ \
	125	int flag = 0; \
	126	PyCursesInitialised \
	127	switch(PyTuple_Size(args)) { \
	128	case 0: \
	129	return PyCursesCheckERR(X(), # X); \
	130	case 1: \
	131	if (!PyArg_ParseTuple(args, "i;True(1) or False(0)", &flag)) return NULL; \
	132	if (flag) return PyCursesCheckERR(X(), # X); \
	133	else return PyCursesCheckERR(no ## X (), # X); \
	134	default: \
	135	PyErr_SetString(PyExc_TypeError, # X " requires 0 or 1 arguments"); \
	136	return NULL; } }
	137
	138	#define NoArgReturnIntFunction(X) \
	139	static PyObject PyCurses_ ## X (PyObject self) \
	140	{ \
	141	PyCursesInitialised \
	142	return PyInt_FromLong((long) X()); }
	143
	144
	145	#define NoArgReturnStringFunction(X) \
	146	static PyObject PyCurses_ ## X (PyObject self) \
	147	{ \
	148	PyCursesInitialised \
	149	return PyString_FromString(X()); }
	150
	151	#define NoArgTrueFalseFunction(X) \
	152	static PyObject PyCurses_ ## X (PyObject self) \
	153	{ \
	154	PyCursesInitialised \
	155	if (X () == FALSE) { \
	156	Py_INCREF(Py_False); \
	157	return Py_False; \
	158	} \
	159	Py_INCREF(Py_True); \
	160	return Py_True; }
	161
	162	#define NoArgNoReturnVoidFunction(X) \
	163	static PyObject PyCurses_ ## X (PyObject self) \
	164	{ \
	165	PyCursesInitialised \
	166	X(); \
	167	Py_INCREF(Py_None); \
	168	return Py_None; }
	169
	170	#ifdef __cplusplus
	171	}
	172	#endif
	173
	174	#endif /* !defined(Py_CURSES_H) */
	175
	176

sys/src/cmd/python/Include/pyarena.h+62−0

@@ -0,0 +1,62 @@
	1	/* An arena-like memory interface for the compiler.
	2	*/
	3
	4	#ifndef Py_PYARENA_H
	5	#define Py_PYARENA_H
	6
	7	#ifdef __cplusplus
	8	extern "C" {
	9	#endif
	10
	11	typedef struct _arena PyArena;
	12
	13	/* PyArena_New() and PyArena_Free() create a new arena and free it,
	14	respectively. Once an arena has been created, it can be used
	15	to allocate memory via PyArena_Malloc(). Pointers to PyObject can
	16	also be registered with the arena via PyArena_AddPyObject(), and the
	17	arena will ensure that the PyObjects stay alive at least until
	18	PyArena_Free() is called. When an arena is freed, all the memory it
	19	allocated is freed, the arena releases internal references to registered
	20	PyObject*, and none of its pointers are valid.
	21	XXX (tim) What does "none of its pointers are valid" mean? Does it
	22	XXX mean that pointers previously obtained via PyArena_Malloc() are
	23	XXX no longer valid? (That's clearly true, but not sure that's what
	24	XXX the text is trying to say.)
	25
	26	PyArena_New() returns an arena pointer. On error, it
	27	returns a negative number and sets an exception.
	28	XXX (tim): Not true. On error, PyArena_New() actually returns NULL,
	29	XXX and looks like it may or may not set an exception (e.g., if the
	30	XXX internal PyList_New(0) returns NULL, PyArena_New() passes that on
	31	XXX and an exception is set; OTOH, if the internal
	32	XXX block_new(DEFAULT_BLOCK_SIZE) returns NULL, that's passed on but
	33	XXX an exception is not set in that case).
	34	*/
	35	PyAPI_FUNC(PyArena *) PyArena_New(void);
	36	PyAPI_FUNC(void) PyArena_Free(PyArena *);
	37
	38	/* Mostly like malloc(), return the address of a block of memory spanning
	39	* `size` bytes, or return NULL (without setting an exception) if enough
	40	* new memory can't be obtained. Unlike malloc(0), PyArena_Malloc() with
	41	* size=0 does not guarantee to return a unique pointer (the pointer
	42	* returned may equal one or more other pointers obtained from
	43	* PyArena_Malloc()).
	44	* Note that pointers obtained via PyArena_Malloc() must never be passed to
	45	* the system free() or realloc(), or to any of Python's similar memory-
	46	* management functions. PyArena_Malloc()-obtained pointers remain valid
	47	* until PyArena_Free(ar) is called, at which point all pointers obtained
	48	* from the arena `ar` become invalid simultaneously.
	49	*/
	50	PyAPI_FUNC(void ) PyArena_Malloc(PyArena , size_t size);
	51
	52	/* This routine isn't a proper arena allocation routine. It takes
	53	* a PyObject* and records it so that it can be DECREFed when the
	54	* arena is freed.
	55	*/
	56	PyAPI_FUNC(int) PyArena_AddPyObject(PyArena , PyObject );
	57
	58	#ifdef __cplusplus
	59	}
	60	#endif
	61
	62	#endif /* !Py_PYARENA_H */

sys/src/cmd/python/Include/pydebug.h+34−0

@@ -0,0 +1,34 @@
	1
	2	#ifndef Py_PYDEBUG_H
	3	#define Py_PYDEBUG_H
	4	#ifdef __cplusplus
	5	extern "C" {
	6	#endif
	7
	8	PyAPI_DATA(int) Py_DebugFlag;
	9	PyAPI_DATA(int) Py_VerboseFlag;
	10	PyAPI_DATA(int) Py_InteractiveFlag;
	11	PyAPI_DATA(int) Py_OptimizeFlag;
	12	PyAPI_DATA(int) Py_NoSiteFlag;
	13	PyAPI_DATA(int) Py_UseClassExceptionsFlag;
	14	PyAPI_DATA(int) Py_FrozenFlag;
	15	PyAPI_DATA(int) Py_TabcheckFlag;
	16	PyAPI_DATA(int) Py_UnicodeFlag;
	17	PyAPI_DATA(int) Py_IgnoreEnvironmentFlag;
	18	PyAPI_DATA(int) Py_DivisionWarningFlag;
	19	/* _XXX Py_QnewFlag should go away in 3.0. It's true iff -Qnew is passed,
	20	on the command line, and is used in 2.2 by ceval.c to make all "/" divisions
	21	true divisions (which they will be in 3.0). */
	22	PyAPI_DATA(int) _Py_QnewFlag;
	23
	24	/* this is a wrapper around getenv() that pays attention to
	25	Py_IgnoreEnvironmentFlag. It should be used for getting variables like
	26	PYTHONPATH and PYTHONHOME from the environment */
	27	#define Py_GETENV(s) (Py_IgnoreEnvironmentFlag ? NULL : getenv(s))
	28
	29	PyAPI_FUNC(void) Py_FatalError(const char *message);
	30
	31	#ifdef __cplusplus
	32	}
	33	#endif
	34	#endif /* !Py_PYDEBUG_H */

sys/src/cmd/python/Include/pyerrors.h+334−0

@@ -0,0 +1,334 @@
	1	#ifndef Py_ERRORS_H
	2	#define Py_ERRORS_H
	3	#ifdef __cplusplus
	4	extern "C" {
	5	#endif
	6
	7	/* Error objects */
	8
	9	typedef struct {
	10	PyObject_HEAD
	11	PyObject *dict;
	12	PyObject *args;
	13	PyObject *message;
	14	} PyBaseExceptionObject;
	15
	16	typedef struct {
	17	PyObject_HEAD
	18	PyObject *dict;
	19	PyObject *args;
	20	PyObject *message;
	21	PyObject *msg;
	22	PyObject *filename;
	23	PyObject *lineno;
	24	PyObject *offset;
	25	PyObject *text;
	26	PyObject *print_file_and_line;
	27	} PySyntaxErrorObject;
	28
	29	#ifdef Py_USING_UNICODE
	30	typedef struct {
	31	PyObject_HEAD
	32	PyObject *dict;
	33	PyObject *args;
	34	PyObject *message;
	35	PyObject *encoding;
	36	PyObject *object;
	37	PyObject *start;
	38	PyObject *end;
	39	PyObject *reason;
	40	} PyUnicodeErrorObject;
	41	#endif
	42
	43	typedef struct {
	44	PyObject_HEAD
	45	PyObject *dict;
	46	PyObject *args;
	47	PyObject *message;
	48	PyObject *code;
	49	} PySystemExitObject;
	50
	51	typedef struct {
	52	PyObject_HEAD
	53	PyObject *dict;
	54	PyObject *args;
	55	PyObject *message;
	56	PyObject *myerrno;
	57	PyObject *strerror;
	58	PyObject *filename;
	59	} PyEnvironmentErrorObject;
	60
	61	#ifdef MS_WINDOWS
	62	typedef struct {
	63	PyObject_HEAD
	64	PyObject *dict;
	65	PyObject *args;
	66	PyObject *message;
	67	PyObject *myerrno;
	68	PyObject *strerror;
	69	PyObject *filename;
	70	PyObject *winerror;
	71	} PyWindowsErrorObject;
	72	#endif
	73
	74	/* Error handling definitions */
	75
	76	PyAPI_FUNC(void) PyErr_SetNone(PyObject *);
	77	PyAPI_FUNC(void) PyErr_SetObject(PyObject , PyObject );
	78	PyAPI_FUNC(void) PyErr_SetString(PyObject , const char );
	79	PyAPI_FUNC(PyObject *) PyErr_Occurred(void);
	80	PyAPI_FUNC(void) PyErr_Clear(void);
	81	PyAPI_FUNC(void) PyErr_Fetch(PyObject , PyObject , PyObject **);
	82	PyAPI_FUNC(void) PyErr_Restore(PyObject , PyObject , PyObject *);
	83
	84	#ifdef Py_DEBUG
	85	#define _PyErr_OCCURRED() PyErr_Occurred()
	86	#else
	87	#define _PyErr_OCCURRED() (_PyThreadState_Current->curexc_type)
	88	#endif
	89
	90	/* Error testing and normalization */
	91	PyAPI_FUNC(int) PyErr_GivenExceptionMatches(PyObject , PyObject );
	92	PyAPI_FUNC(int) PyErr_ExceptionMatches(PyObject *);
	93	PyAPI_FUNC(void) PyErr_NormalizeException(PyObject, PyObject, PyObject**);
	94
	95	/* */
	96
	97	#define PyExceptionClass_Check(x) \
	98	(PyClass_Check((x)) \
	99	\|\| (PyType_Check((x)) && PyType_IsSubtype( \
	100	(PyTypeObject)(x), (PyTypeObject)PyExc_BaseException)))
	101
	102
	103	#define PyExceptionInstance_Check(x) \
	104	(PyInstance_Check((x)) \|\| \
	105	(PyType_IsSubtype((x)->ob_type, (PyTypeObject*)PyExc_BaseException)))
	106
	107	#define PyExceptionClass_Name(x) \
	108	(PyClass_Check((x)) \
	109	? PyString_AS_STRING(((PyClassObject*)(x))->cl_name) \
	110	: (char )(((PyTypeObject)(x))->tp_name))
	111
	112	#define PyExceptionInstance_Class(x) \
	113	((PyInstance_Check((x)) \
	114	? (PyObject)((PyInstanceObject)(x))->in_class \
	115	: (PyObject*)((x)->ob_type)))
	116
	117
	118	/* Predefined exceptions */
	119
	120	PyAPI_DATA(PyObject *) PyExc_BaseException;
	121	PyAPI_DATA(PyObject *) PyExc_Exception;
	122	PyAPI_DATA(PyObject *) PyExc_StopIteration;
	123	PyAPI_DATA(PyObject *) PyExc_GeneratorExit;
	124	PyAPI_DATA(PyObject *) PyExc_StandardError;
	125	PyAPI_DATA(PyObject *) PyExc_ArithmeticError;
	126	PyAPI_DATA(PyObject *) PyExc_LookupError;
	127
	128	PyAPI_DATA(PyObject *) PyExc_AssertionError;
	129	PyAPI_DATA(PyObject *) PyExc_AttributeError;
	130	PyAPI_DATA(PyObject *) PyExc_EOFError;
	131	PyAPI_DATA(PyObject *) PyExc_FloatingPointError;
	132	PyAPI_DATA(PyObject *) PyExc_EnvironmentError;
	133	PyAPI_DATA(PyObject *) PyExc_IOError;
	134	PyAPI_DATA(PyObject *) PyExc_OSError;
	135	PyAPI_DATA(PyObject *) PyExc_ImportError;
	136	PyAPI_DATA(PyObject *) PyExc_IndexError;
	137	PyAPI_DATA(PyObject *) PyExc_KeyError;
	138	PyAPI_DATA(PyObject *) PyExc_KeyboardInterrupt;
	139	PyAPI_DATA(PyObject *) PyExc_MemoryError;
	140	PyAPI_DATA(PyObject *) PyExc_NameError;
	141	PyAPI_DATA(PyObject *) PyExc_OverflowError;
	142	PyAPI_DATA(PyObject *) PyExc_RuntimeError;
	143	PyAPI_DATA(PyObject *) PyExc_NotImplementedError;
	144	PyAPI_DATA(PyObject *) PyExc_SyntaxError;
	145	PyAPI_DATA(PyObject *) PyExc_IndentationError;
	146	PyAPI_DATA(PyObject *) PyExc_TabError;
	147	PyAPI_DATA(PyObject *) PyExc_ReferenceError;
	148	PyAPI_DATA(PyObject *) PyExc_SystemError;
	149	PyAPI_DATA(PyObject *) PyExc_SystemExit;
	150	PyAPI_DATA(PyObject *) PyExc_TypeError;
	151	PyAPI_DATA(PyObject *) PyExc_UnboundLocalError;
	152	PyAPI_DATA(PyObject *) PyExc_UnicodeError;
	153	PyAPI_DATA(PyObject *) PyExc_UnicodeEncodeError;
	154	PyAPI_DATA(PyObject *) PyExc_UnicodeDecodeError;
	155	PyAPI_DATA(PyObject *) PyExc_UnicodeTranslateError;
	156	PyAPI_DATA(PyObject *) PyExc_ValueError;
	157	PyAPI_DATA(PyObject *) PyExc_ZeroDivisionError;
	158	#ifdef MS_WINDOWS
	159	PyAPI_DATA(PyObject *) PyExc_WindowsError;
	160	#endif
	161	#ifdef __VMS
	162	PyAPI_DATA(PyObject *) PyExc_VMSError;
	163	#endif
	164
	165	PyAPI_DATA(PyObject *) PyExc_MemoryErrorInst;
	166
	167	/* Predefined warning categories */
	168	PyAPI_DATA(PyObject *) PyExc_Warning;
	169	PyAPI_DATA(PyObject *) PyExc_UserWarning;
	170	PyAPI_DATA(PyObject *) PyExc_DeprecationWarning;
	171	PyAPI_DATA(PyObject *) PyExc_PendingDeprecationWarning;
	172	PyAPI_DATA(PyObject *) PyExc_SyntaxWarning;
	173	PyAPI_DATA(PyObject *) PyExc_RuntimeWarning;
	174	PyAPI_DATA(PyObject *) PyExc_FutureWarning;
	175	PyAPI_DATA(PyObject *) PyExc_ImportWarning;
	176	PyAPI_DATA(PyObject *) PyExc_UnicodeWarning;
	177
	178
	179	/* Convenience functions */
	180
	181	PyAPI_FUNC(int) PyErr_BadArgument(void);
	182	PyAPI_FUNC(PyObject *) PyErr_NoMemory(void);
	183	PyAPI_FUNC(PyObject ) PyErr_SetFromErrno(PyObject );
	184	PyAPI_FUNC(PyObject *) PyErr_SetFromErrnoWithFilenameObject(
	185	PyObject , PyObject );
	186	PyAPI_FUNC(PyObject ) PyErr_SetFromErrnoWithFilename(PyObject , char *);
	187	#ifdef Py_WIN_WIDE_FILENAMES
	188	PyAPI_FUNC(PyObject *) PyErr_SetFromErrnoWithUnicodeFilename(
	189	PyObject , Py_UNICODE );
	190	#endif /* Py_WIN_WIDE_FILENAMES */
	191
	192	PyAPI_FUNC(PyObject ) PyErr_Format(PyObject , const char *, ...)
	193	Py_GCC_ATTRIBUTE((format(printf, 2, 3)));
	194
	195	#ifdef MS_WINDOWS
	196	PyAPI_FUNC(PyObject *) PyErr_SetFromWindowsErrWithFilenameObject(
	197	int, const char *);
	198	PyAPI_FUNC(PyObject *) PyErr_SetFromWindowsErrWithFilename(
	199	int, const char *);
	200	#ifdef Py_WIN_WIDE_FILENAMES
	201	PyAPI_FUNC(PyObject *) PyErr_SetFromWindowsErrWithUnicodeFilename(
	202	int, const Py_UNICODE *);
	203	#endif /* Py_WIN_WIDE_FILENAMES */
	204	PyAPI_FUNC(PyObject *) PyErr_SetFromWindowsErr(int);
	205	PyAPI_FUNC(PyObject *) PyErr_SetExcFromWindowsErrWithFilenameObject(
	206	PyObject ,int, PyObject );
	207	PyAPI_FUNC(PyObject *) PyErr_SetExcFromWindowsErrWithFilename(
	208	PyObject ,int, const char );
	209	#ifdef Py_WIN_WIDE_FILENAMES
	210	PyAPI_FUNC(PyObject *) PyErr_SetExcFromWindowsErrWithUnicodeFilename(
	211	PyObject ,int, const Py_UNICODE );
	212	#endif /* Py_WIN_WIDE_FILENAMES */
	213	PyAPI_FUNC(PyObject ) PyErr_SetExcFromWindowsErr(PyObject , int);
	214	#endif /* MS_WINDOWS */
	215
	216	/* Export the old function so that the existing API remains available: */
	217	PyAPI_FUNC(void) PyErr_BadInternalCall(void);
	218	PyAPI_FUNC(void) _PyErr_BadInternalCall(char *filename, int lineno);
	219	/* Mask the old API with a call to the new API for code compiled under
	220	Python 2.0: */
	221	#define PyErr_BadInternalCall() _PyErr_BadInternalCall(__FILE__, __LINE__)
	222
	223	/* Function to create a new exception */
	224	PyAPI_FUNC(PyObject ) PyErr_NewException(char name, PyObject *base,
	225	PyObject *dict);
	226	PyAPI_FUNC(void) PyErr_WriteUnraisable(PyObject *);
	227
	228	/* Issue a warning or exception */
	229	PyAPI_FUNC(int) PyErr_WarnEx(PyObject category, const char msg,
	230	Py_ssize_t stack_level);
	231	PyAPI_FUNC(int) PyErr_WarnExplicit(PyObject , const char ,
	232	const char *, int,
	233	const char , PyObject );
	234	/* PyErr_Warn is only for backwards compatability and will be removed.
	235	Use PyErr_WarnEx instead. */
	236	#define PyErr_Warn(category, msg) PyErr_WarnEx(category, msg, 1)
	237
	238	/* In sigcheck.c or signalmodule.c */
	239	PyAPI_FUNC(int) PyErr_CheckSignals(void);
	240	PyAPI_FUNC(void) PyErr_SetInterrupt(void);
	241
	242	/* Support for adding program text to SyntaxErrors */
	243	PyAPI_FUNC(void) PyErr_SyntaxLocation(const char *, int);
	244	PyAPI_FUNC(PyObject ) PyErr_ProgramText(const char , int);
	245
	246	#ifdef Py_USING_UNICODE
	247	/* The following functions are used to create and modify unicode
	248	exceptions from C */
	249
	250	/* create a UnicodeDecodeError object */
	251	PyAPI_FUNC(PyObject *) PyUnicodeDecodeError_Create(
	252	const char , const char , Py_ssize_t, Py_ssize_t, Py_ssize_t, const char *);
	253
	254	/* create a UnicodeEncodeError object */
	255	PyAPI_FUNC(PyObject *) PyUnicodeEncodeError_Create(
	256	const char , const Py_UNICODE , Py_ssize_t, Py_ssize_t, Py_ssize_t, const char *);
	257
	258	/* create a UnicodeTranslateError object */
	259	PyAPI_FUNC(PyObject *) PyUnicodeTranslateError_Create(
	260	const Py_UNICODE , Py_ssize_t, Py_ssize_t, Py_ssize_t, const char );
	261
	262	/* get the encoding attribute */
	263	PyAPI_FUNC(PyObject ) PyUnicodeEncodeError_GetEncoding(PyObject );
	264	PyAPI_FUNC(PyObject ) PyUnicodeDecodeError_GetEncoding(PyObject );
	265
	266	/* get the object attribute */
	267	PyAPI_FUNC(PyObject ) PyUnicodeEncodeError_GetObject(PyObject );
	268	PyAPI_FUNC(PyObject ) PyUnicodeDecodeError_GetObject(PyObject );
	269	PyAPI_FUNC(PyObject ) PyUnicodeTranslateError_GetObject(PyObject );
	270
	271	/* get the value of the start attribute (the int * may not be NULL)
	272	return 0 on success, -1 on failure */
	273	PyAPI_FUNC(int) PyUnicodeEncodeError_GetStart(PyObject , Py_ssize_t );
	274	PyAPI_FUNC(int) PyUnicodeDecodeError_GetStart(PyObject , Py_ssize_t );
	275	PyAPI_FUNC(int) PyUnicodeTranslateError_GetStart(PyObject , Py_ssize_t );
	276
	277	/* assign a new value to the start attribute
	278	return 0 on success, -1 on failure */
	279	PyAPI_FUNC(int) PyUnicodeEncodeError_SetStart(PyObject *, Py_ssize_t);
	280	PyAPI_FUNC(int) PyUnicodeDecodeError_SetStart(PyObject *, Py_ssize_t);
	281	PyAPI_FUNC(int) PyUnicodeTranslateError_SetStart(PyObject *, Py_ssize_t);
	282
	283	/* get the value of the end attribute (the int *may not be NULL)
	284	return 0 on success, -1 on failure */
	285	PyAPI_FUNC(int) PyUnicodeEncodeError_GetEnd(PyObject , Py_ssize_t );
	286	PyAPI_FUNC(int) PyUnicodeDecodeError_GetEnd(PyObject , Py_ssize_t );
	287	PyAPI_FUNC(int) PyUnicodeTranslateError_GetEnd(PyObject , Py_ssize_t );
	288
	289	/* assign a new value to the end attribute
	290	return 0 on success, -1 on failure */
	291	PyAPI_FUNC(int) PyUnicodeEncodeError_SetEnd(PyObject *, Py_ssize_t);
	292	PyAPI_FUNC(int) PyUnicodeDecodeError_SetEnd(PyObject *, Py_ssize_t);
	293	PyAPI_FUNC(int) PyUnicodeTranslateError_SetEnd(PyObject *, Py_ssize_t);
	294
	295	/* get the value of the reason attribute */
	296	PyAPI_FUNC(PyObject ) PyUnicodeEncodeError_GetReason(PyObject );
	297	PyAPI_FUNC(PyObject ) PyUnicodeDecodeError_GetReason(PyObject );
	298	PyAPI_FUNC(PyObject ) PyUnicodeTranslateError_GetReason(PyObject );
	299
	300	/* assign a new value to the reason attribute
	301	return 0 on success, -1 on failure */
	302	PyAPI_FUNC(int) PyUnicodeEncodeError_SetReason(
	303	PyObject , const char );
	304	PyAPI_FUNC(int) PyUnicodeDecodeError_SetReason(
	305	PyObject , const char );
	306	PyAPI_FUNC(int) PyUnicodeTranslateError_SetReason(
	307	PyObject , const char );
	308	#endif
	309
	310
	311	/* These APIs aren't really part of the error implementation, but
	312	often needed to format error messages; the native C lib APIs are
	313	not available on all platforms, which is why we provide emulations
	314	for those platforms in Python/mysnprintf.c,
	315	WARNING: The return value of snprintf varies across platforms; do
	316	not rely on any particular behavior; eventually the C99 defn may
	317	be reliable.
	318	*/
	319	#if defined(MS_WIN32) && !defined(HAVE_SNPRINTF)
	320	# define HAVE_SNPRINTF
	321	# define snprintf _snprintf
	322	# define vsnprintf _vsnprintf
	323	#endif
	324
	325	#include <stdarg.h>
	326	PyAPI_FUNC(int) PyOS_snprintf(char str, size_t size, const char format, ...)
	327	Py_GCC_ATTRIBUTE((format(printf, 3, 4)));
	328	PyAPI_FUNC(int) PyOS_vsnprintf(char str, size_t size, const char format, va_list va)
	329	Py_GCC_ATTRIBUTE((format(printf, 3, 0)));
	330
	331	#ifdef __cplusplus
	332	}
	333	#endif
	334	#endif /* !Py_ERRORS_H */

sys/src/cmd/python/Include/pyexpat.h+47−0

@@ -0,0 +1,47 @@
	1	/* Stuff to export relevant 'expat' entry points from pyexpat to other
	2	* parser modules, such as cElementTree. */
	3
	4	/* note: you must import expat.h before importing this module! */
	5
	6	#define PyExpat_CAPI_MAGIC "pyexpat.expat_CAPI 1.0"
	7
	8	struct PyExpat_CAPI
	9	{
	10	char* magic; /* set to PyExpat_CAPI_MAGIC */
	11	int size; /* set to sizeof(struct PyExpat_CAPI) */
	12	int MAJOR_VERSION;
	13	int MINOR_VERSION;
	14	int MICRO_VERSION;
	15	/* pointers to selected expat functions. add new functions at
	16	the end, if needed */
	17	const XML_LChar * (*ErrorString)(enum XML_Error code);
	18	enum XML_Error (*GetErrorCode)(XML_Parser parser);
	19	XML_Size (*GetErrorColumnNumber)(XML_Parser parser);
	20	XML_Size (*GetErrorLineNumber)(XML_Parser parser);
	21	enum XML_Status (*Parse)(
	22	XML_Parser parser, const char *s, int len, int isFinal);
	23	XML_Parser (*ParserCreate_MM)(
	24	const XML_Char encoding, const XML_Memory_Handling_Suite memsuite,
	25	const XML_Char *namespaceSeparator);
	26	void (*ParserFree)(XML_Parser parser);
	27	void (*SetCharacterDataHandler)(
	28	XML_Parser parser, XML_CharacterDataHandler handler);
	29	void (*SetCommentHandler)(
	30	XML_Parser parser, XML_CommentHandler handler);
	31	void (*SetDefaultHandlerExpand)(
	32	XML_Parser parser, XML_DefaultHandler handler);
	33	void (*SetElementHandler)(
	34	XML_Parser parser, XML_StartElementHandler start,
	35	XML_EndElementHandler end);
	36	void (*SetNamespaceDeclHandler)(
	37	XML_Parser parser, XML_StartNamespaceDeclHandler start,
	38	XML_EndNamespaceDeclHandler end);
	39	void (*SetProcessingInstructionHandler)(
	40	XML_Parser parser, XML_ProcessingInstructionHandler handler);
	41	void (*SetUnknownEncodingHandler)(
	42	XML_Parser parser, XML_UnknownEncodingHandler handler,
	43	void *encodingHandlerData);
	44	void (SetUserData)(XML_Parser parser, void userData);
	45	/* always add new stuff to the end! */
	46	};
	47

sys/src/cmd/python/Include/pyfpe.h+176−0

@@ -0,0 +1,176 @@
	1	#ifndef Py_PYFPE_H
	2	#define Py_PYFPE_H
	3	#ifdef __cplusplus
	4	extern "C" {
	5	#endif
	6	/*
	7	---------------------------------------------------------------------
	8	/ Copyright (c) 1996. \
	9	\| The Regents of the University of California. \|
	10	\| All rights reserved. \|
	11	\| \|
	12	\| Permission to use, copy, modify, and distribute this software for \|
	13	\| any purpose without fee is hereby granted, provided that this en- \|
	14	\| tire notice is included in all copies of any software which is or \|
	15	\| includes a copy or modification of this software and in all \|
	16	\| copies of the supporting documentation for such software. \|
	17	\| \|
	18	\| This work was produced at the University of California, Lawrence \|
	19	\| Livermore National Laboratory under contract no. W-7405-ENG-48 \|
	20	\| between the U.S. Department of Energy and The Regents of the \|
	21	\| University of California for the operation of UC LLNL. \|
	22	\| \|
	23	\| DISCLAIMER \|
	24	\| \|
	25	\| This software was prepared as an account of work sponsored by an \|
	26	\| agency of the United States Government. Neither the United States \|
	27	\| Government nor the University of California nor any of their em- \|
	28	\| ployees, makes any warranty, express or implied, or assumes any \|
	29	\| liability or responsibility for the accuracy, completeness, or \|
	30	\| usefulness of any information, apparatus, product, or process \|
	31	\| disclosed, or represents that its use would not infringe \|
	32	\| privately-owned rights. Reference herein to any specific commer- \|
	33	\| cial products, process, or service by trade name, trademark, \|
	34	\| manufacturer, or otherwise, does not necessarily constitute or \|
	35	\| imply its endorsement, recommendation, or favoring by the United \|
	36	\| States Government or the University of California. The views and \|
	37	\| opinions of authors expressed herein do not necessarily state or \|
	38	\| reflect those of the United States Government or the University \|
	39	\| of California, and shall not be used for advertising or product \|
	40	\ endorsement purposes. /
	41	---------------------------------------------------------------------
	42	*/
	43
	44	/*
	45	* Define macros for handling SIGFPE.
	46	* Lee Busby, LLNL, November, 1996
	47	* busby1@llnl.gov
	48	*
	49	*********************************************
	50	* Overview of the system for handling SIGFPE:
	51	*
	52	* This file (Include/pyfpe.h) defines a couple of "wrapper" macros for
	53	* insertion into your Python C code of choice. Their proper use is
	54	* discussed below. The file Python/pyfpe.c defines a pair of global
	55	* variables PyFPE_jbuf and PyFPE_counter which are used by the signal
	56	* handler for SIGFPE to decide if a particular exception was protected
	57	* by the macros. The signal handler itself, and code for enabling the
	58	* generation of SIGFPE in the first place, is in a (new) Python module
	59	* named fpectl. This module is standard in every respect. It can be loaded
	60	* either statically or dynamically as you choose, and like any other
	61	* Python module, has no effect until you import it.
	62	*
	63	* In the general case, there are three steps toward handling SIGFPE in any
	64	* Python code:
	65	*
	66	* 1) Add the *_PROTECT macros to your C code as required to protect
	67	* dangerous floating point sections.
	68	*
	69	* 2) Turn on the inclusion of the code by adding the ``--with-fpectl''
	70	* flag at the time you run configure. If the fpectl or other modules
	71	* which use the *_PROTECT macros are to be dynamically loaded, be
	72	* sure they are compiled with WANT_SIGFPE_HANDLER defined.
	73	*
	74	* 3) When python is built and running, import fpectl, and execute
	75	* fpectl.turnon_sigfpe(). This sets up the signal handler and enables
	76	* generation of SIGFPE whenever an exception occurs. From this point
	77	* on, any properly trapped SIGFPE should result in the Python
	78	* FloatingPointError exception.
	79	*
	80	* Step 1 has been done already for the Python kernel code, and should be
	81	* done soon for the NumPy array package. Step 2 is usually done once at
	82	* python install time. Python's behavior with respect to SIGFPE is not
	83	* changed unless you also do step 3. Thus you can control this new
	84	* facility at compile time, or run time, or both.
	85	*
	86	********************************
	87	* Using the macros in your code:
	88	*
	89	* static PyObject foobar(PyObject self,PyObject *args)
	90	* {
	91	* ....
	92	* PyFPE_START_PROTECT("Error in foobar", return 0)
	93	* result = dangerous_op(somearg1, somearg2, ...);
	94	* PyFPE_END_PROTECT(result)
	95	* ....
	96	* }
	97	*
	98	* If a floating point error occurs in dangerous_op, foobar returns 0 (NULL),
	99	* after setting the associated value of the FloatingPointError exception to
	100	* "Error in foobar". ``Dangerous_op'' can be a single operation, or a block
	101	* of code, function calls, or any combination, so long as no alternate
	102	* return is possible before the PyFPE_END_PROTECT macro is reached.
	103	*
	104	* The macros can only be used in a function context where an error return
	105	* can be recognized as signaling a Python exception. (Generally, most
	106	* functions that return a PyObject * will qualify.)
	107	*
	108	* Guido's original design suggestion for PyFPE_START_PROTECT and
	109	* PyFPE_END_PROTECT had them open and close a local block, with a locally
	110	* defined jmp_buf and jmp_buf pointer. This would allow recursive nesting
	111	* of the macros. The Ansi C standard makes it clear that such local
	112	* variables need to be declared with the "volatile" type qualifier to keep
	113	* setjmp from corrupting their values. Some current implementations seem
	114	* to be more restrictive. For example, the HPUX man page for setjmp says
	115	*
	116	* Upon the return from a setjmp() call caused by a longjmp(), the
	117	* values of any non-static local variables belonging to the routine
	118	* from which setjmp() was called are undefined. Code which depends on
	119	* such values is not guaranteed to be portable.
	120	*
	121	* I therefore decided on a more limited form of nesting, using a counter
	122	* variable (PyFPE_counter) to keep track of any recursion. If an exception
	123	* occurs in an ``inner'' pair of macros, the return will apparently
	124	* come from the outermost level.
	125	*
	126	*/
	127
	128	#ifdef WANT_SIGFPE_HANDLER
	129	#include <signal.h>
	130	#include <setjmp.h>
	131	#include <math.h>
	132	extern jmp_buf PyFPE_jbuf;
	133	extern int PyFPE_counter;
	134	extern double PyFPE_dummy(void *);
	135
	136	#define PyFPE_START_PROTECT(err_string, leave_stmt) \
	137	if (!PyFPE_counter++ && setjmp(PyFPE_jbuf)) { \
	138	PyErr_SetString(PyExc_FloatingPointError, err_string); \
	139	PyFPE_counter = 0; \
	140	leave_stmt; \
	141	}
	142
	143	/*
	144	* This (following) is a heck of a way to decrement a counter. However,
	145	* unless the macro argument is provided, code optimizers will sometimes move
	146	* this statement so that it gets executed before the unsafe expression
	147	* which we're trying to protect. That pretty well messes things up,
	148	* of course.
	149	*
	150	* If the expression(s) you're trying to protect don't happen to return a
	151	* value, you will need to manufacture a dummy result just to preserve the
	152	* correct ordering of statements. Note that the macro passes the address
	153	* of its argument (so you need to give it something which is addressable).
	154	* If your expression returns multiple results, pass the last such result
	155	* to PyFPE_END_PROTECT.
	156	*
	157	* Note that PyFPE_dummy returns a double, which is cast to int.
	158	* This seeming insanity is to tickle the Floating Point Unit (FPU).
	159	* If an exception has occurred in a preceding floating point operation,
	160	* some architectures (notably Intel 80x86) will not deliver the interrupt
	161	* until the next floating point operation. This is painful if you've
	162	* already decremented PyFPE_counter.
	163	*/
	164	#define PyFPE_END_PROTECT(v) PyFPE_counter -= (int)PyFPE_dummy(&(v));
	165
	166	#else
	167
	168	#define PyFPE_START_PROTECT(err_string, leave_stmt)
	169	#define PyFPE_END_PROTECT(v)
	170
	171	#endif
	172
	173	#ifdef __cplusplus
	174	}
	175	#endif
	176	#endif /* !Py_PYFPE_H */

sys/src/cmd/python/Include/pygetopt.h+17−0

@@ -0,0 +1,17 @@
	1
	2	#ifndef Py_PYGETOPT_H
	3	#define Py_PYGETOPT_H
	4	#ifdef __cplusplus
	5	extern "C" {
	6	#endif
	7
	8	PyAPI_DATA(int) _PyOS_opterr;
	9	PyAPI_DATA(int) _PyOS_optind;
	10	PyAPI_DATA(char *) _PyOS_optarg;
	11
	12	PyAPI_FUNC(int) _PyOS_GetOpt(int argc, char *argv, char optstring);
	13
	14	#ifdef __cplusplus
	15	}
	16	#endif
	17	#endif /* !Py_PYGETOPT_H */

sys/src/cmd/python/Include/pymactoolbox.h+189−0

@@ -0,0 +1,189 @@
	1	/*
	2	** pymactoolbox.h - globals defined in mactoolboxglue.c
	3	*/
	4	#ifndef Py_PYMACTOOLBOX_H
	5	#define Py_PYMACTOOLBOX_H
	6	#ifdef __cplusplus
	7	extern "C" {
	8	#endif
	9
	10	#include <Carbon/Carbon.h>
	11	#include <QuickTime/QuickTime.h>
	12
	13	/*
	14	** Helper routines for error codes and such.
	15	*/
	16	char PyMac_StrError(int); / strerror with mac errors */
	17	extern PyObject PyMac_OSErrException; / Exception for OSErr */
	18	PyObject PyMac_GetOSErrException(void); / Initialize & return it */
	19	PyObject PyErr_Mac(PyObject , int); /* Exception with a mac error */
	20	PyObject PyMac_Error(OSErr); / Uses PyMac_GetOSErrException */
	21	extern OSErr PyMac_GetFullPathname(FSSpec , char , int); /* convert
	22	fsspec->path */
	23	/*
	24	** These conversion routines are defined in mactoolboxglue.c itself.
	25	*/
	26	int PyMac_GetOSType(PyObject , OSType ); /* argument parser for OSType */
	27	PyObject PyMac_BuildOSType(OSType); / Convert OSType to PyObject */
	28
	29	PyObject PyMac_BuildNumVersion(NumVersion);/ Convert NumVersion to PyObject */
	30
	31	int PyMac_GetStr255(PyObject , Str255); / argument parser for Str255 */
	32	PyObject PyMac_BuildStr255(Str255); / Convert Str255 to PyObject */
	33	PyObject PyMac_BuildOptStr255(Str255); / Convert Str255 to PyObject,
	34	NULL to None */
	35
	36	int PyMac_GetRect(PyObject , Rect ); /* argument parser for Rect */
	37	PyObject PyMac_BuildRect(Rect ); /* Convert Rect to PyObject */
	38
	39	int PyMac_GetPoint(PyObject , Point ); /* argument parser for Point */
	40	PyObject PyMac_BuildPoint(Point); / Convert Point to PyObject */
	41
	42	int PyMac_GetEventRecord(PyObject , EventRecord ); /* argument parser for
	43	EventRecord */
	44	PyObject PyMac_BuildEventRecord(EventRecord ); /* Convert EventRecord to
	45	PyObject */
	46
	47	int PyMac_GetFixed(PyObject , Fixed ); /* argument parser for Fixed */
	48	PyObject PyMac_BuildFixed(Fixed); / Convert Fixed to PyObject */
	49	int PyMac_Getwide(PyObject , wide ); /* argument parser for wide */
	50	PyObject PyMac_Buildwide(wide ); /* Convert wide to PyObject */
	51
	52	/*
	53	** The rest of the routines are implemented by extension modules. If they are
	54	** dynamically loaded mactoolboxglue will contain a stub implementation of the
	55	** routine, which imports the module, whereupon the module's init routine will
	56	** communicate the routine pointer back to the stub.
	57	** If USE_TOOLBOX_OBJECT_GLUE is not defined there is no glue code, and the
	58	** extension modules simply declare the routine. This is the case for static
	59	** builds (and could be the case for MacPython CFM builds, because CFM extension
	60	** modules can reference each other without problems).
	61	*/
	62
	63	#ifdef USE_TOOLBOX_OBJECT_GLUE
	64	/*
	65	** These macros are used in the module init code. If we use toolbox object glue
	66	** it sets the function pointer to point to the real function.
	67	*/
	68	#define PyMac_INIT_TOOLBOX_OBJECT_NEW(object, rtn) { \
	69	extern PyObject (PyMacGluePtr_##rtn)(object); \
	70	PyMacGluePtr_##rtn = _##rtn; \
	71	}
	72	#define PyMac_INIT_TOOLBOX_OBJECT_CONVERT(object, rtn) { \
	73	extern int (PyMacGluePtr_##rtn)(PyObject , object *); \
	74	PyMacGluePtr_##rtn = _##rtn; \
	75	}
	76	#else
	77	/*
	78	** If we don't use toolbox object glue the init macros are empty. Moreover, we define
	79	** _xxx_New to be the same as xxx_New, and the code in mactoolboxglue isn't included.
	80	*/
	81	#define PyMac_INIT_TOOLBOX_OBJECT_NEW(object, rtn)
	82	#define PyMac_INIT_TOOLBOX_OBJECT_CONVERT(object, rtn)
	83	#endif /* USE_TOOLBOX_OBJECT_GLUE */
	84
	85	/* macfs exports */
	86	int PyMac_GetFSSpec(PyObject , FSSpec ); /* argument parser for FSSpec */
	87	PyObject PyMac_BuildFSSpec(FSSpec ); /* Convert FSSpec to PyObject */
	88
	89	int PyMac_GetFSRef(PyObject , FSRef ); /* argument parser for FSRef */
	90	PyObject PyMac_BuildFSRef(FSRef ); /* Convert FSRef to PyObject */
	91
	92	/* AE exports */
	93	extern PyObject AEDesc_New(AppleEvent ); /* XXXX Why passed by address?? */
	94	extern PyObject AEDesc_NewBorrowed(AppleEvent );
	95	extern int AEDesc_Convert(PyObject , AppleEvent );
	96
	97	/* Cm exports */
	98	extern PyObject *CmpObj_New(Component);
	99	extern int CmpObj_Convert(PyObject , Component );
	100	extern PyObject *CmpInstObj_New(ComponentInstance);
	101	extern int CmpInstObj_Convert(PyObject , ComponentInstance );
	102
	103	/* Ctl exports */
	104	extern PyObject *CtlObj_New(ControlHandle);
	105	extern int CtlObj_Convert(PyObject , ControlHandle );
	106
	107	/* Dlg exports */
	108	extern PyObject *DlgObj_New(DialogPtr);
	109	extern int DlgObj_Convert(PyObject , DialogPtr );
	110	extern PyObject *DlgObj_WhichDialog(DialogPtr);
	111
	112	/* Drag exports */
	113	extern PyObject *DragObj_New(DragReference);
	114	extern int DragObj_Convert(PyObject , DragReference );
	115
	116	/* List exports */
	117	extern PyObject *ListObj_New(ListHandle);
	118	extern int ListObj_Convert(PyObject , ListHandle );
	119
	120	/* Menu exports */
	121	extern PyObject *MenuObj_New(MenuHandle);
	122	extern int MenuObj_Convert(PyObject , MenuHandle );
	123
	124	/* Qd exports */
	125	extern PyObject *GrafObj_New(GrafPtr);
	126	extern int GrafObj_Convert(PyObject , GrafPtr );
	127	extern PyObject *BMObj_New(BitMapPtr);
	128	extern int BMObj_Convert(PyObject , BitMapPtr );
	129	extern PyObject QdRGB_New(RGBColor );
	130	extern int QdRGB_Convert(PyObject , RGBColor );
	131
	132	/* Qdoffs exports */
	133	extern PyObject *GWorldObj_New(GWorldPtr);
	134	extern int GWorldObj_Convert(PyObject , GWorldPtr );
	135
	136	/* Qt exports */
	137	extern PyObject *TrackObj_New(Track);
	138	extern int TrackObj_Convert(PyObject , Track );
	139	extern PyObject *MovieObj_New(Movie);
	140	extern int MovieObj_Convert(PyObject , Movie );
	141	extern PyObject *MovieCtlObj_New(MovieController);
	142	extern int MovieCtlObj_Convert(PyObject , MovieController );
	143	extern PyObject *TimeBaseObj_New(TimeBase);
	144	extern int TimeBaseObj_Convert(PyObject , TimeBase );
	145	extern PyObject *UserDataObj_New(UserData);
	146	extern int UserDataObj_Convert(PyObject , UserData );
	147	extern PyObject *MediaObj_New(Media);
	148	extern int MediaObj_Convert(PyObject , Media );
	149
	150	/* Res exports */
	151	extern PyObject *ResObj_New(Handle);
	152	extern int ResObj_Convert(PyObject , Handle );
	153	extern PyObject *OptResObj_New(Handle);
	154	extern int OptResObj_Convert(PyObject , Handle );
	155
	156	/* TE exports */
	157	extern PyObject *TEObj_New(TEHandle);
	158	extern int TEObj_Convert(PyObject , TEHandle );
	159
	160	/* Win exports */
	161	extern PyObject *WinObj_New(WindowPtr);
	162	extern int WinObj_Convert(PyObject , WindowPtr );
	163	extern PyObject *WinObj_WhichWindow(WindowPtr);
	164
	165	/* CF exports */
	166	extern PyObject *CFObj_New(CFTypeRef);
	167	extern int CFObj_Convert(PyObject , CFTypeRef );
	168	extern PyObject *CFTypeRefObj_New(CFTypeRef);
	169	extern int CFTypeRefObj_Convert(PyObject , CFTypeRef );
	170	extern PyObject *CFStringRefObj_New(CFStringRef);
	171	extern int CFStringRefObj_Convert(PyObject , CFStringRef );
	172	extern PyObject *CFMutableStringRefObj_New(CFMutableStringRef);
	173	extern int CFMutableStringRefObj_Convert(PyObject , CFMutableStringRef );
	174	extern PyObject *CFArrayRefObj_New(CFArrayRef);
	175	extern int CFArrayRefObj_Convert(PyObject , CFArrayRef );
	176	extern PyObject *CFMutableArrayRefObj_New(CFMutableArrayRef);
	177	extern int CFMutableArrayRefObj_Convert(PyObject , CFMutableArrayRef );
	178	extern PyObject *CFDictionaryRefObj_New(CFDictionaryRef);
	179	extern int CFDictionaryRefObj_Convert(PyObject , CFDictionaryRef );
	180	extern PyObject *CFMutableDictionaryRefObj_New(CFMutableDictionaryRef);
	181	extern int CFMutableDictionaryRefObj_Convert(PyObject , CFMutableDictionaryRef );
	182	extern PyObject *CFURLRefObj_New(CFURLRef);
	183	extern int CFURLRefObj_Convert(PyObject , CFURLRef );
	184	extern int OptionalCFURLRefObj_Convert(PyObject , CFURLRef );
	185
	186	#ifdef __cplusplus
	187	}
	188	#endif
	189	#endif

sys/src/cmd/python/Include/pymem.h+105−0

@@ -0,0 +1,105 @@
	1	/* The PyMem_ family: low-level memory allocation interfaces.
	2	See objimpl.h for the PyObject_ memory family.
	3	*/
	4
	5	#ifndef Py_PYMEM_H
	6	#define Py_PYMEM_H
	7
	8	#include "pyport.h"
	9
	10	#ifdef __cplusplus
	11	extern "C" {
	12	#endif
	13
	14	/* BEWARE:
	15
	16	Each interface exports both functions and macros. Extension modules should
	17	use the functions, to ensure binary compatibility across Python versions.
	18	Because the Python implementation is free to change internal details, and
	19	the macros may (or may not) expose details for speed, if you do use the
	20	macros you must recompile your extensions with each Python release.
	21
	22	Never mix calls to PyMem_ with calls to the platform malloc/realloc/
	23	calloc/free. For example, on Windows different DLLs may end up using
	24	different heaps, and if you use PyMem_Malloc you'll get the memory from the
	25	heap used by the Python DLL; it could be a disaster if you free()'ed that
	26	directly in your own extension. Using PyMem_Free instead ensures Python
	27	can return the memory to the proper heap. As another example, in
	28	PYMALLOC_DEBUG mode, Python wraps all calls to all PyMem_ and PyObject_
	29	memory functions in special debugging wrappers that add additional
	30	debugging info to dynamic memory blocks. The system routines have no idea
	31	what to do with that stuff, and the Python wrappers have no idea what to do
	32	with raw blocks obtained directly by the system routines then.
	33	*/
	34
	35	/*
	36	* Raw memory interface
	37	* ====================
	38	*/
	39
	40	/* Functions
	41
	42	Functions supplying platform-independent semantics for malloc/realloc/
	43	free. These functions make sure that allocating 0 bytes returns a distinct
	44	non-NULL pointer (whenever possible -- if we're flat out of memory, NULL
	45	may be returned), even if the platform malloc and realloc don't.
	46	Returned pointers must be checked for NULL explicitly. No action is
	47	performed on failure (no exception is set, no warning is printed, etc).
	48	*/
	49
	50	PyAPI_FUNC(void *) PyMem_Malloc(size_t);
	51	PyAPI_FUNC(void ) PyMem_Realloc(void , size_t);
	52	PyAPI_FUNC(void) PyMem_Free(void *);
	53
	54	/* Starting from Python 1.6, the wrappers Py_{Malloc,Realloc,Free} are
	55	no longer supported. They used to call PyErr_NoMemory() on failure. */
	56
	57	/* Macros. */
	58	#ifdef PYMALLOC_DEBUG
	59	/* Redirect all memory operations to Python's debugging allocator. */
	60	#define PyMem_MALLOC PyObject_MALLOC
	61	#define PyMem_REALLOC PyObject_REALLOC
	62	#define PyMem_FREE PyObject_FREE
	63
	64	#else /* ! PYMALLOC_DEBUG */
	65
	66	/* PyMem_MALLOC(0) means malloc(1). Some systems would return NULL
	67	for malloc(0), which would be treated as an error. Some platforms
	68	would return a pointer with no memory behind it, which would break
	69	pymalloc. To solve these problems, allocate an extra byte. */
	70	#define PyMem_MALLOC(n) malloc((n) ? (n) : 1)
	71	#define PyMem_REALLOC(p, n) realloc((p), (n) ? (n) : 1)
	72	#define PyMem_FREE free
	73
	74	#endif /* PYMALLOC_DEBUG */
	75
	76	/*
	77	* Type-oriented memory interface
	78	* ==============================
	79	*
	80	* These are carried along for historical reasons. There's rarely a good
	81	* reason to use them anymore (you can just as easily do the multiply and
	82	* cast yourself).
	83	*/
	84
	85	#define PyMem_New(type, n) \
	86	( (type ) PyMem_Malloc((n) sizeof(type)) )
	87	#define PyMem_NEW(type, n) \
	88	( (type ) PyMem_MALLOC((n) sizeof(type)) )
	89
	90	#define PyMem_Resize(p, type, n) \
	91	( (p) = (type ) PyMem_Realloc((p), (n) sizeof(type)) )
	92	#define PyMem_RESIZE(p, type, n) \
	93	( (p) = (type ) PyMem_REALLOC((p), (n) sizeof(type)) )
	94
	95	/* PyMem{Del,DEL} are left over from ancient days, and shouldn't be used
	96	* anymore. They're just confusing aliases for PyMem_{Free,FREE} now.
	97	*/
	98	#define PyMem_Del PyMem_Free
	99	#define PyMem_DEL PyMem_FREE
	100
	101	#ifdef __cplusplus
	102	}
	103	#endif
	104
	105	#endif /* !Py_PYMEM_H */

sys/src/cmd/python/Include/pyport.h+771−0

@@ -0,0 +1,771 @@
	1	#ifndef Py_PYPORT_H
	2	#define Py_PYPORT_H
	3
	4	#include "pyconfig.h" /* include for defines */
	5
	6	#ifdef HAVE_STDINT_H
	7	#include <stdint.h>
	8	#endif
	9
	10	/**************************************************************************
	11	Symbols and macros to supply platform-independent interfaces to basic
	12	C language & library operations whose spellings vary across platforms.
	13
	14	Please try to make documentation here as clear as possible: by definition,
	15	the stuff here is trying to illuminate C's darkest corners.
	16
	17	Config #defines referenced here:
	18
	19	SIGNED_RIGHT_SHIFT_ZERO_FILLS
	20	Meaning: To be defined iff i>>j does not extend the sign bit when i is a
	21	signed integral type and i < 0.
	22	Used in: Py_ARITHMETIC_RIGHT_SHIFT
	23
	24	Py_DEBUG
	25	Meaning: Extra checks compiled in for debug mode.
	26	Used in: Py_SAFE_DOWNCAST
	27
	28	HAVE_UINTPTR_T
	29	Meaning: The C9X type uintptr_t is supported by the compiler
	30	Used in: Py_uintptr_t
	31
	32	HAVE_LONG_LONG
	33	Meaning: The compiler supports the C type "long long"
	34	Used in: PY_LONG_LONG
	35
	36	**************************************************************************/
	37
	38
	39	/* For backward compatibility only. Obsolete, do not use. */
	40	#ifdef HAVE_PROTOTYPES
	41	#define Py_PROTO(x) x
	42	#else
	43	#define Py_PROTO(x) ()
	44	#endif
	45	#ifndef Py_FPROTO
	46	#define Py_FPROTO(x) Py_PROTO(x)
	47	#endif
	48
	49	/* typedefs for some C9X-defined synonyms for integral types.
	50	*
	51	* The names in Python are exactly the same as the C9X names, except with a
	52	* Py_ prefix. Until C9X is universally implemented, this is the only way
	53	* to ensure that Python gets reliable names that don't conflict with names
	54	* in non-Python code that are playing their own tricks to define the C9X
	55	* names.
	56	*
	57	* NOTE: don't go nuts here! Python has no use for most of the C9X
	58	* integral synonyms. Only define the ones we actually need.
	59	*/
	60
	61	#ifdef HAVE_LONG_LONG
	62	#ifndef PY_LONG_LONG
	63	#define PY_LONG_LONG long long
	64	#endif
	65	#endif /* HAVE_LONG_LONG */
	66
	67	/* uintptr_t is the C9X name for an unsigned integral type such that a
	68	* legitimate void* can be cast to uintptr_t and then back to void* again
	69	* without loss of information. Similarly for intptr_t, wrt a signed
	70	* integral type.
	71	*/
	72	#ifdef HAVE_UINTPTR_T
	73	typedef uintptr_t Py_uintptr_t;
	74	typedef intptr_t Py_intptr_t;
	75
	76	#elif SIZEOF_VOID_P <= SIZEOF_INT
	77	typedef unsigned int Py_uintptr_t;
	78	typedef int Py_intptr_t;
	79
	80	#elif SIZEOF_VOID_P <= SIZEOF_LONG
	81	typedef unsigned long Py_uintptr_t;
	82	typedef long Py_intptr_t;
	83
	84	#elif defined(HAVE_LONG_LONG) && (SIZEOF_VOID_P <= SIZEOF_LONG_LONG)
	85	typedef unsigned PY_LONG_LONG Py_uintptr_t;
	86	typedef PY_LONG_LONG Py_intptr_t;
	87
	88	#else
	89	# error "Python needs a typedef for Py_uintptr_t in pyport.h."
	90	#endif /* HAVE_UINTPTR_T */
	91
	92	/* Py_ssize_t is a signed integral type such that sizeof(Py_ssize_t) ==
	93	* sizeof(size_t). C99 doesn't define such a thing directly (size_t is an
	94	* unsigned integral type). See PEP 353 for details.
	95	*/
	96	#ifdef HAVE_SSIZE_T
	97	typedef ssize_t Py_ssize_t;
	98	#elif SIZEOF_VOID_P == SIZEOF_SIZE_T
	99	typedef Py_intptr_t Py_ssize_t;
	100	#else
	101	# error "Python needs a typedef for Py_ssize_t in pyport.h."
	102	#endif
	103
	104	/* Largest positive value of type Py_ssize_t. */
	105	#define PY_SSIZE_T_MAX ((Py_ssize_t)(((size_t)-1)>>1))
	106	/* Smallest negative value of type Py_ssize_t. */
	107	#define PY_SSIZE_T_MIN (-PY_SSIZE_T_MAX-1)
	108
	109	/* PY_FORMAT_SIZE_T is a platform-specific modifier for use in a printf
	110	* format to convert an argument with the width of a size_t or Py_ssize_t.
	111	* C99 introduced "z" for this purpose, but not all platforms support that;
	112	* e.g., MS compilers use "I" instead.
	113	*
	114	* These "high level" Python format functions interpret "z" correctly on
	115	* all platforms (Python interprets the format string itself, and does whatever
	116	* the platform C requires to convert a size_t/Py_ssize_t argument):
	117	*
	118	* PyString_FromFormat
	119	* PyErr_Format
	120	* PyString_FromFormatV
	121	*
	122	* Lower-level uses require that you interpolate the correct format modifier
	123	* yourself (e.g., calling printf, fprintf, sprintf, PyOS_snprintf); for
	124	* example,
	125	*
	126	* Py_ssize_t index;
	127	* fprintf(stderr, "index %" PY_FORMAT_SIZE_T "d sucks\n", index);
	128	*
	129	* That will expand to %ld, or %Id, or to something else correct for a
	130	* Py_ssize_t on the platform.
	131	*/
	132	#ifndef PY_FORMAT_SIZE_T
	133	# if SIZEOF_SIZE_T == SIZEOF_INT && !defined(__APPLE__)
	134	# define PY_FORMAT_SIZE_T ""
	135	# elif SIZEOF_SIZE_T == SIZEOF_LONG
	136	# define PY_FORMAT_SIZE_T "l"
	137	# elif defined(MS_WINDOWS)
	138	# define PY_FORMAT_SIZE_T "I"
	139	# else
	140	# error "This platform's pyconfig.h needs to define PY_FORMAT_SIZE_T"
	141	# endif
	142	#endif
	143
	144	/* Py_LOCAL can be used instead of static to get the fastest possible calling
	145	* convention for functions that are local to a given module.
	146	*
	147	* Py_LOCAL_INLINE does the same thing, and also explicitly requests inlining,
	148	* for platforms that support that.
	149	*
	150	* If PY_LOCAL_AGGRESSIVE is defined before python.h is included, more
	151	* "aggressive" inlining/optimizaion is enabled for the entire module. This
	152	* may lead to code bloat, and may slow things down for those reasons. It may
	153	* also lead to errors, if the code relies on pointer aliasing. Use with
	154	* care.
	155	*
	156	* NOTE: You can only use this for functions that are entirely local to a
	157	* module; functions that are exported via method tables, callbacks, etc,
	158	* should keep using static.
	159	*/
	160
	161	#undef USE_INLINE /* XXX - set via configure? */
	162
	163	#if defined(_MSC_VER)
	164	#if defined(PY_LOCAL_AGGRESSIVE)
	165	/* enable more aggressive optimization for visual studio */
	166	#pragma optimize("agtw", on)
	167	#endif
	168	/* ignore warnings if the compiler decides not to inline a function */
	169	#pragma warning(disable: 4710)
	170	/* fastest possible local call under MSVC */
	171	#define Py_LOCAL(type) static type __fastcall
	172	#define Py_LOCAL_INLINE(type) static __inline type __fastcall
	173	#elif defined(USE_INLINE)
	174	#define Py_LOCAL(type) static type
	175	#define Py_LOCAL_INLINE(type) static inline type
	176	#else
	177	#define Py_LOCAL(type) static type
	178	#define Py_LOCAL_INLINE(type) static type
	179	#endif
	180
	181	/* Py_MEMCPY can be used instead of memcpy in cases where the copied blocks
	182	* are often very short. While most platforms have highly optimized code for
	183	* large transfers, the setup costs for memcpy are often quite high. MEMCPY
	184	* solves this by doing short copies "in line".
	185	*/
	186
	187	#if defined(_MSC_VER)
	188	#define Py_MEMCPY(target, source, length) do { \
	189	size_t i_, n_ = (length); \
	190	char t_ = (void) (target); \
	191	const char s_ = (void) (source); \
	192	if (n_ >= 16) \
	193	memcpy(t_, s_, n_); \
	194	else \
	195	for (i_ = 0; i_ < n_; i_++) \
	196	t_[i_] = s_[i_]; \
	197	} while (0)
	198	#else
	199	#define Py_MEMCPY memcpy
	200	#endif
	201
	202	#include <stdlib.h>
	203
	204	#include <math.h> /* Moved here from the math section, before extern "C" */
	205
	206	/********************************************
	207	* WRAPPER FOR <time.h> and/or <sys/time.h> *
	208	********************************************/
	209
	210	#ifdef TIME_WITH_SYS_TIME
	211	#include <sys/time.h>
	212	#include <time.h>
	213	#else /* !TIME_WITH_SYS_TIME */
	214	#ifdef HAVE_SYS_TIME_H
	215	#include <sys/time.h>
	216	#else /* !HAVE_SYS_TIME_H */
	217	#include <time.h>
	218	#endif /* !HAVE_SYS_TIME_H */
	219	#endif /* !TIME_WITH_SYS_TIME */
	220
	221
	222	/******************************
	223	* WRAPPER FOR <sys/select.h> *
	224	******************************/
	225
	226	/* NB caller must include <sys/types.h> */
	227
	228	#ifdef HAVE_SYS_SELECT_H
	229
	230	#include <sys/select.h>
	231
	232	#endif /* !HAVE_SYS_SELECT_H */
	233
	234	/*******************************
	235	* stat() and fstat() fiddling *
	236	*******************************/
	237
	238	/* We expect that stat and fstat exist on most systems.
	239	* It's confirmed on Unix, Mac and Windows.
	240	* If you don't have them, add
	241	* #define DONT_HAVE_STAT
	242	* and/or
	243	* #define DONT_HAVE_FSTAT
	244	* to your pyconfig.h. Python code beyond this should check HAVE_STAT and
	245	* HAVE_FSTAT instead.
	246	* Also
	247	* #define HAVE_SYS_STAT_H
	248	* if <sys/stat.h> exists on your platform, and
	249	* #define HAVE_STAT_H
	250	* if <stat.h> does.
	251	*/
	252	#ifndef DONT_HAVE_STAT
	253	#define HAVE_STAT
	254	#endif
	255
	256	#ifndef DONT_HAVE_FSTAT
	257	#define HAVE_FSTAT
	258	#endif
	259
	260	#ifdef RISCOS
	261	#include <sys/types.h>
	262	#include "unixstuff.h"
	263	#endif
	264
	265	#ifdef HAVE_SYS_STAT_H
	266	#if defined(PYOS_OS2) && defined(PYCC_GCC)
	267	#include <sys/types.h>
	268	#endif
	269	#include <sys/stat.h>
	270	#elif defined(HAVE_STAT_H)
	271	#include <stat.h>
	272	#endif
	273
	274	#if defined(PYCC_VACPP)
	275	/* VisualAge C/C++ Failed to Define MountType Field in sys/stat.h */
	276	#define S_IFMT (S_IFDIR\|S_IFCHR\|S_IFREG)
	277	#endif
	278
	279	#ifndef S_ISREG
	280	#define S_ISREG(x) (((x) & S_IFMT) == S_IFREG)
	281	#endif
	282
	283	#ifndef S_ISDIR
	284	#define S_ISDIR(x) (((x) & S_IFMT) == S_IFDIR)
	285	#endif
	286
	287
	288	#ifdef __cplusplus
	289	/* Move this down here since some C++ #include's don't like to be included
	290	inside an extern "C" */
	291	extern "C" {
	292	#endif
	293
	294
	295	/* Py_ARITHMETIC_RIGHT_SHIFT
	296	* C doesn't define whether a right-shift of a signed integer sign-extends
	297	* or zero-fills. Here a macro to force sign extension:
	298	* Py_ARITHMETIC_RIGHT_SHIFT(TYPE, I, J)
	299	* Return I >> J, forcing sign extension.
	300	* Requirements:
	301	* I is of basic signed type TYPE (char, short, int, long, or long long).
	302	* TYPE is one of char, short, int, long, or long long, although long long
	303	* must not be used except on platforms that support it.
	304	* J is an integer >= 0 and strictly less than the number of bits in TYPE
	305	* (because C doesn't define what happens for J outside that range either).
	306	* Caution:
	307	* I may be evaluated more than once.
	308	*/
	309	#ifdef SIGNED_RIGHT_SHIFT_ZERO_FILLS
	310	#define Py_ARITHMETIC_RIGHT_SHIFT(TYPE, I, J) \
	311	((I) < 0 ? ~((~(unsigned TYPE)(I)) >> (J)) : (I) >> (J))
	312	#else
	313	#define Py_ARITHMETIC_RIGHT_SHIFT(TYPE, I, J) ((I) >> (J))
	314	#endif
	315
	316	/* Py_FORCE_EXPANSION(X)
	317	* "Simply" returns its argument. However, macro expansions within the
	318	* argument are evaluated. This unfortunate trickery is needed to get
	319	* token-pasting to work as desired in some cases.
	320	*/
	321	#define Py_FORCE_EXPANSION(X) X
	322
	323	/* Py_SAFE_DOWNCAST(VALUE, WIDE, NARROW)
	324	* Cast VALUE to type NARROW from type WIDE. In Py_DEBUG mode, this
	325	* assert-fails if any information is lost.
	326	* Caution:
	327	* VALUE may be evaluated more than once.
	328	*/
	329	#ifdef Py_DEBUG
	330	#define Py_SAFE_DOWNCAST(VALUE, WIDE, NARROW) \
	331	(assert((WIDE)(NARROW)(VALUE) == (VALUE)), (NARROW)(VALUE))
	332	#else
	333	#define Py_SAFE_DOWNCAST(VALUE, WIDE, NARROW) (NARROW)(VALUE)
	334	#endif
	335
	336	/* Py_IS_NAN(X)
	337	* Return 1 if float or double arg is a NaN, else 0.
	338	* Caution:
	339	* X is evaluated more than once.
	340	* This may not work on all platforms. Each platform has some
	341	* way to spell this, though -- override in pyconfig.h if you have
	342	* a platform where it doesn't work.
	343	*/
	344	#ifndef Py_IS_NAN
	345	#define Py_IS_NAN(X) ((X) != (X))
	346	#endif
	347
	348	/* Py_IS_INFINITY(X)
	349	* Return 1 if float or double arg is an infinity, else 0.
	350	* Caution:
	351	* X is evaluated more than once.
	352	* This implementation may set the underflow flag if \|X\| is very small;
	353	* it really can't be implemented correctly (& easily) before C99.
	354	* Override in pyconfig.h if you have a better spelling on your platform.
	355	*/
	356	#ifndef Py_IS_INFINITY
	357	#define Py_IS_INFINITY(X) ((X) && (X)*0.5 == (X))
	358	#endif
	359
	360	/* Py_IS_FINITE(X)
	361	* Return 1 if float or double arg is neither infinite nor NAN, else 0.
	362	* Some compilers (e.g. VisualStudio) have intrisics for this, so a special
	363	* macro for this particular test is useful
	364	*/
	365	#ifndef Py_IS_FINITE
	366	#define Py_IS_FINITE(X) (!Py_IS_INFINITY(X) && !Py_IS_NAN(X))
	367	#endif
	368
	369	/* HUGE_VAL is supposed to expand to a positive double infinity. Python
	370	* uses Py_HUGE_VAL instead because some platforms are broken in this
	371	* respect. We used to embed code in pyport.h to try to worm around that,
	372	* but different platforms are broken in conflicting ways. If you're on
	373	* a platform where HUGE_VAL is defined incorrectly, fiddle your Python
	374	* config to #define Py_HUGE_VAL to something that works on your platform.
	375	*/
	376	#ifndef Py_HUGE_VAL
	377	#define Py_HUGE_VAL HUGE_VAL
	378	#endif
	379
	380	/* Py_OVERFLOWED(X)
	381	* Return 1 iff a libm function overflowed. Set errno to 0 before calling
	382	* a libm function, and invoke this macro after, passing the function
	383	* result.
	384	* Caution:
	385	* This isn't reliable. C99 no longer requires libm to set errno under
	386	* any exceptional condition, but does require +- HUGE_VAL return
	387	* values on overflow. A 754 box probably maps HUGE_VAL to a
	388	* double infinity, and we're cool if that's so, unless the input
	389	* was an infinity and an infinity is the expected result. A C89
	390	* system sets errno to ERANGE, so we check for that too. We're
	391	* out of luck if a C99 754 box doesn't map HUGE_VAL to +Inf, or
	392	* if the returned result is a NaN, or if a C89 box returns HUGE_VAL
	393	* in non-overflow cases.
	394	* X is evaluated more than once.
	395	* Some platforms have better way to spell this, so expect some #ifdef'ery.
	396	*
	397	* OpenBSD uses 'isinf()' because a compiler bug on that platform causes
	398	* the longer macro version to be mis-compiled. This isn't optimal, and
	399	* should be removed once a newer compiler is available on that platform.
	400	* The system that had the failure was running OpenBSD 3.2 on Intel, with
	401	* gcc 2.95.3.
	402	*
	403	* According to Tim's checkin, the FreeBSD systems use isinf() to work
	404	* around a FPE bug on that platform.
	405	*/
	406	#if defined(__FreeBSD__) \|\| defined(__OpenBSD__)
	407	#define Py_OVERFLOWED(X) isinf(X)
	408	#else
	409	#define Py_OVERFLOWED(X) ((X) != 0.0 && (errno == ERANGE \|\| \
	410	(X) == Py_HUGE_VAL \|\| \
	411	(X) == -Py_HUGE_VAL))
	412	#endif
	413
	414	/* Py_SET_ERRNO_ON_MATH_ERROR(x)
	415	* If a libm function did not set errno, but it looks like the result
	416	* overflowed or not-a-number, set errno to ERANGE or EDOM. Set errno
	417	* to 0 before calling a libm function, and invoke this macro after,
	418	* passing the function result.
	419	* Caution:
	420	* This isn't reliable. See Py_OVERFLOWED comments.
	421	* X is evaluated more than once.
	422	*/
	423	#if defined(__FreeBSD__) \|\| defined(__OpenBSD__) \|\| (defined(__hpux) && defined(__ia64))
	424	#define _Py_SET_EDOM_FOR_NAN(X) if (isnan(X)) errno = EDOM;
	425	#else
	426	#define _Py_SET_EDOM_FOR_NAN(X) ;
	427	#endif
	428	#define Py_SET_ERRNO_ON_MATH_ERROR(X) \
	429	do { \
	430	if (errno == 0) { \
	431	if ((X) == Py_HUGE_VAL \|\| (X) == -Py_HUGE_VAL) \
	432	errno = ERANGE; \
	433	else _Py_SET_EDOM_FOR_NAN(X) \
	434	} \
	435	} while(0)
	436
	437	/* Py_SET_ERANGE_ON_OVERFLOW(x)
	438	* An alias of Py_SET_ERRNO_ON_MATH_ERROR for backward-compatibility.
	439	*/
	440	#define Py_SET_ERANGE_IF_OVERFLOW(X) Py_SET_ERRNO_ON_MATH_ERROR(X)
	441
	442	/* Py_ADJUST_ERANGE1(x)
	443	* Py_ADJUST_ERANGE2(x, y)
	444	* Set errno to 0 before calling a libm function, and invoke one of these
	445	* macros after, passing the function result(s) (Py_ADJUST_ERANGE2 is useful
	446	* for functions returning complex results). This makes two kinds of
	447	* adjustments to errno: (A) If it looks like the platform libm set
	448	* errno=ERANGE due to underflow, clear errno. (B) If it looks like the
	449	* platform libm overflowed but didn't set errno, force errno to ERANGE. In
	450	* effect, we're trying to force a useful implementation of C89 errno
	451	* behavior.
	452	* Caution:
	453	* This isn't reliable. See Py_OVERFLOWED comments.
	454	* X and Y may be evaluated more than once.
	455	*/
	456	#define Py_ADJUST_ERANGE1(X) \
	457	do { \
	458	if (errno == 0) { \
	459	if ((X) == Py_HUGE_VAL \|\| (X) == -Py_HUGE_VAL) \
	460	errno = ERANGE; \
	461	} \
	462	else if (errno == ERANGE && (X) == 0.0) \
	463	errno = 0; \
	464	} while(0)
	465
	466	#define Py_ADJUST_ERANGE2(X, Y) \
	467	do { \
	468	if ((X) == Py_HUGE_VAL \|\| (X) == -Py_HUGE_VAL \|\| \
	469	(Y) == Py_HUGE_VAL \|\| (Y) == -Py_HUGE_VAL) { \
	470	if (errno == 0) \
	471	errno = ERANGE; \
	472	} \
	473	else if (errno == ERANGE) \
	474	errno = 0; \
	475	} while(0)
	476
	477	/* Py_DEPRECATED(version)
	478	* Declare a variable, type, or function deprecated.
	479	* Usage:
	480	* extern int old_var Py_DEPRECATED(2.3);
	481	* typedef int T1 Py_DEPRECATED(2.4);
	482	* extern int x() Py_DEPRECATED(2.5);
	483	*/
	484	#if defined(__GNUC__) && ((__GNUC__ >= 4) \|\| \
	485	(__GNUC__ == 3) && (__GNUC_MINOR__ >= 1))
	486	#define Py_DEPRECATED(VERSION_UNUSED) __attribute__((__deprecated__))
	487	#else
	488	#define Py_DEPRECATED(VERSION_UNUSED)
	489	#endif
	490
	491	/**************************************************************************
	492	Prototypes that are missing from the standard include files on some systems
	493	(and possibly only some versions of such systems.)
	494
	495	Please be conservative with adding new ones, document them and enclose them
	496	in platform-specific #ifdefs.
	497	**************************************************************************/
	498
	499	#ifdef SOLARIS
	500	/* Unchecked */
	501	extern int gethostname(char *, int);
	502	#endif
	503
	504	#ifdef __BEOS__
	505	/* Unchecked */
	506	/* It's in the libs, but not the headers... - [cjh] */
	507	int shutdown( int, int );
	508	#endif
	509
	510	#ifdef HAVE__GETPTY
	511	#include <sys/types.h> /* we need to import mode_t */
	512	extern char * _getpty(int *, int, mode_t, int);
	513	#endif
	514
	515	#if defined(HAVE_OPENPTY) \|\| defined(HAVE_FORKPTY)
	516	#if !defined(HAVE_PTY_H) && !defined(HAVE_LIBUTIL_H)
	517	/* BSDI does not supply a prototype for the 'openpty' and 'forkpty'
	518	functions, even though they are included in libutil. */
	519	#include <termios.h>
	520	extern int openpty(int , int , char , struct termios , struct winsize *);
	521	extern int forkpty(int , char , struct termios , struct winsize );
	522	#endif /* !defined(HAVE_PTY_H) && !defined(HAVE_LIBUTIL_H) */
	523	#endif /* defined(HAVE_OPENPTY) \|\| defined(HAVE_FORKPTY) */
	524
	525
	526	/* These are pulled from various places. It isn't obvious on what platforms
	527	they are necessary, nor what the exact prototype should look like (which
	528	is likely to vary between platforms!) If you find you need one of these
	529	declarations, please move them to a platform-specific block and include
	530	proper prototypes. */
	531	#if 0
	532
	533	/* From Modules/resource.c */
	534	extern int getrusage();
	535	extern int getpagesize();
	536
	537	/* From Python/sysmodule.c and Modules/posixmodule.c */
	538	extern int fclose(FILE *);
	539
	540	/* From Modules/posixmodule.c */
	541	extern int fdatasync(int);
	542	#endif /* 0 */
	543
	544
	545	/************************
	546	* WRAPPER FOR <math.h> *
	547	************************/
	548
	549	#ifndef HAVE_HYPOT
	550	extern double hypot(double, double);
	551	#endif
	552
	553
	554	/* On 4.4BSD-descendants, ctype functions serves the whole range of
	555	* wchar_t character set rather than single byte code points only.
	556	* This characteristic can break some operations of string object
	557	* including str.upper() and str.split() on UTF-8 locales. This
	558	* workaround was provided by Tim Robbins of FreeBSD project.
	559	*/
	560
	561	#ifdef __FreeBSD__
	562	#include <osreldate.h>
	563	#if __FreeBSD_version > 500039
	564	#include <ctype.h>
	565	#include <wctype.h>
	566	#undef isalnum
	567	#define isalnum(c) iswalnum(btowc(c))
	568	#undef isalpha
	569	#define isalpha(c) iswalpha(btowc(c))
	570	#undef islower
	571	#define islower(c) iswlower(btowc(c))
	572	#undef isspace
	573	#define isspace(c) iswspace(btowc(c))
	574	#undef isupper
	575	#define isupper(c) iswupper(btowc(c))
	576	#undef tolower
	577	#define tolower(c) towlower(btowc(c))
	578	#undef toupper
	579	#define toupper(c) towupper(btowc(c))
	580	#endif
	581	#endif
	582
	583
	584	/* Declarations for symbol visibility.
	585
	586	PyAPI_FUNC(type): Declares a public Python API function and return type
	587	PyAPI_DATA(type): Declares public Python data and its type
	588	PyMODINIT_FUNC: A Python module init function. If these functions are
	589	inside the Python core, they are private to the core.
	590	If in an extension module, it may be declared with
	591	external linkage depending on the platform.
	592
	593	As a number of platforms support/require "__declspec(dllimport/dllexport)",
	594	we support a HAVE_DECLSPEC_DLL macro to save duplication.
	595	*/
	596
	597	/*
	598	All windows ports, except cygwin, are handled in PC/pyconfig.h.
	599
	600	BeOS and cygwin are the only other autoconf platform requiring special
	601	linkage handling and both of these use __declspec().
	602	*/
	603	#if defined(__CYGWIN__) \|\| defined(__BEOS__)
	604	# define HAVE_DECLSPEC_DLL
	605	#endif
	606
	607	/* only get special linkage if built as shared or platform is Cygwin */
	608	#if defined(Py_ENABLE_SHARED) \|\| defined(__CYGWIN__)
	609	# if defined(HAVE_DECLSPEC_DLL)
	610	# ifdef Py_BUILD_CORE
	611	# define PyAPI_FUNC(RTYPE) __declspec(dllexport) RTYPE
	612	# define PyAPI_DATA(RTYPE) extern __declspec(dllexport) RTYPE
	613	/* module init functions inside the core need no external linkage */
	614	/* except for Cygwin to handle embedding (FIXME: BeOS too?) */
	615	# if defined(__CYGWIN__)
	616	# define PyMODINIT_FUNC __declspec(dllexport) void
	617	# else /* __CYGWIN__ */
	618	# define PyMODINIT_FUNC void
	619	# endif /* __CYGWIN__ */
	620	# else /* Py_BUILD_CORE */
	621	/* Building an extension module, or an embedded situation */
	622	/* public Python functions and data are imported */
	623	/* Under Cygwin, auto-import functions to prevent compilation */
	624	/* failures similar to http://python.org/doc/FAQ.html#3.24 */
	625	# if !defined(__CYGWIN__)
	626	# define PyAPI_FUNC(RTYPE) __declspec(dllimport) RTYPE
	627	# endif /* !__CYGWIN__ */
	628	# define PyAPI_DATA(RTYPE) extern __declspec(dllimport) RTYPE
	629	/* module init functions outside the core must be exported */
	630	# if defined(__cplusplus)
	631	# define PyMODINIT_FUNC extern "C" __declspec(dllexport) void
	632	# else /* __cplusplus */
	633	# define PyMODINIT_FUNC __declspec(dllexport) void
	634	# endif /* __cplusplus */
	635	# endif /* Py_BUILD_CORE */
	636	# endif /* HAVE_DECLSPEC */
	637	#endif /* Py_ENABLE_SHARED */
	638
	639	/* If no external linkage macros defined by now, create defaults */
	640	#ifndef PyAPI_FUNC
	641	# define PyAPI_FUNC(RTYPE) RTYPE
	642	#endif
	643	#ifndef PyAPI_DATA
	644	# define PyAPI_DATA(RTYPE) extern RTYPE
	645	#endif
	646	#ifndef PyMODINIT_FUNC
	647	# if defined(__cplusplus)
	648	# define PyMODINIT_FUNC extern "C" void
	649	# else /* __cplusplus */
	650	# define PyMODINIT_FUNC void
	651	# endif /* __cplusplus */
	652	#endif
	653
	654	/* Deprecated DL_IMPORT and DL_EXPORT macros */
	655	#if defined(Py_ENABLE_SHARED) && defined (HAVE_DECLSPEC_DLL)
	656	# if defined(Py_BUILD_CORE)
	657	# define DL_IMPORT(RTYPE) __declspec(dllexport) RTYPE
	658	# define DL_EXPORT(RTYPE) __declspec(dllexport) RTYPE
	659	# else
	660	# define DL_IMPORT(RTYPE) __declspec(dllimport) RTYPE
	661	# define DL_EXPORT(RTYPE) __declspec(dllexport) RTYPE
	662	# endif
	663	#endif
	664	#ifndef DL_EXPORT
	665	# define DL_EXPORT(RTYPE) RTYPE
	666	#endif
	667	#ifndef DL_IMPORT
	668	# define DL_IMPORT(RTYPE) RTYPE
	669	#endif
	670	/* End of deprecated DL_* macros */
	671
	672	/* If the fd manipulation macros aren't defined,
	673	here is a set that should do the job */
	674
	675	#if 0 /* disabled and probably obsolete */
	676
	677	#ifndef FD_SETSIZE
	678	#define FD_SETSIZE 256
	679	#endif
	680
	681	#ifndef FD_SET
	682
	683	typedef long fd_mask;
	684
	685	#define NFDBITS (sizeof(fd_mask) * NBBY) /* bits per mask */
	686	#ifndef howmany
	687	#define howmany(x, y) (((x)+((y)-1))/(y))
	688	#endif /* howmany */
	689
	690	typedef struct fd_set {
	691	fd_mask fds_bits[howmany(FD_SETSIZE, NFDBITS)];
	692	} fd_set;
	693
	694	#define FD_SET(n, p) ((p)->fds_bits[(n)/NFDBITS] \|= (1 << ((n) % NFDBITS)))
	695	#define FD_CLR(n, p) ((p)->fds_bits[(n)/NFDBITS] &= ~(1 << ((n) % NFDBITS)))
	696	#define FD_ISSET(n, p) ((p)->fds_bits[(n)/NFDBITS] & (1 << ((n) % NFDBITS)))
	697	#define FD_ZERO(p) memset((char )(p), '\0', sizeof((p)))
	698
	699	#endif /* FD_SET */
	700
	701	#endif /* fd manipulation macros */
	702
	703
	704	/* limits.h constants that may be missing */
	705
	706	#ifndef INT_MAX
	707	#define INT_MAX 2147483647
	708	#endif
	709
	710	#ifndef LONG_MAX
	711	#if SIZEOF_LONG == 4
	712	#define LONG_MAX 0X7FFFFFFFL
	713	#elif SIZEOF_LONG == 8
	714	#define LONG_MAX 0X7FFFFFFFFFFFFFFFL
	715	#else
	716	#error "could not set LONG_MAX in pyport.h"
	717	#endif
	718	#endif
	719
	720	#ifndef LONG_MIN
	721	#define LONG_MIN (-LONG_MAX-1)
	722	#endif
	723
	724	#ifndef LONG_BIT
	725	#define LONG_BIT (8 * SIZEOF_LONG)
	726	#endif
	727
	728	#if LONG_BIT != 8 * SIZEOF_LONG
	729	/* 04-Oct-2000 LONG_BIT is apparently (mis)defined as 64 on some recent
	730	* 32-bit platforms using gcc. We try to catch that here at compile-time
	731	* rather than waiting for integer multiplication to trigger bogus
	732	* overflows.
	733	*/
	734	#error "LONG_BIT definition appears wrong for platform (bad gcc/glibc config?)."
	735	#endif
	736
	737	#ifdef __cplusplus
	738	}
	739	#endif
	740
	741	/*
	742	* Hide GCC attributes from compilers that don't support them.
	743	*/
	744	#if (!defined(__GNUC__) \|\| __GNUC__ < 2 \|\| \
	745	(__GNUC__ == 2 && __GNUC_MINOR__ < 7) ) && \
	746	!defined(RISCOS)
	747	#define Py_GCC_ATTRIBUTE(x)
	748	#else
	749	#define Py_GCC_ATTRIBUTE(x) __attribute__(x)
	750	#endif
	751
	752	/* Eliminate end-of-loop code not reached warnings from SunPro C
	753	* when using do{...}while(0) macros
	754	*/
	755	#ifdef __SUNPRO_C
	756	#pragma error_messages (off,E_END_OF_LOOP_CODE_NOT_REACHED)
	757	#endif
	758
	759	/*
	760	* Older Microsoft compilers don't support the C99 long long literal suffixes,
	761	* so these will be defined in PC/pyconfig.h for those compilers.
	762	*/
	763	#ifndef Py_LL
	764	#define Py_LL(x) x##LL
	765	#endif
	766
	767	#ifndef Py_ULL
	768	#define Py_ULL(x) Py_LL(x##U)
	769	#endif
	770
	771	#endif /* Py_PYPORT_H */

sys/src/cmd/python/Include/pystate.h+195−0

@@ -0,0 +1,195 @@
	1
	2	/* Thread and interpreter state structures and their interfaces */
	3
	4
	5	#ifndef Py_PYSTATE_H
	6	#define Py_PYSTATE_H
	7	#ifdef __cplusplus
	8	extern "C" {
	9	#endif
	10
	11	/* State shared between threads */
	12
	13	struct _ts; /* Forward */
	14	struct _is; /* Forward */
	15
	16	typedef struct _is {
	17
	18	struct _is *next;
	19	struct _ts *tstate_head;
	20
	21	PyObject *modules;
	22	PyObject *sysdict;
	23	PyObject *builtins;
	24	PyObject *modules_reloading;
	25
	26	PyObject *codec_search_path;
	27	PyObject *codec_search_cache;
	28	PyObject *codec_error_registry;
	29
	30	#ifdef HAVE_DLOPEN
	31	int dlopenflags;
	32	#endif
	33	#ifdef WITH_TSC
	34	int tscdump;
	35	#endif
	36
	37	} PyInterpreterState;
	38
	39
	40	/* State unique per thread */
	41
	42	struct _frame; /* Avoid including frameobject.h */
	43
	44	/* Py_tracefunc return -1 when raising an exception, or 0 for success. */
	45	typedef int (Py_tracefunc)(PyObject , struct _frame , int, PyObject );
	46
	47	/* The following values are used for 'what' for tracefunc functions: */
	48	#define PyTrace_CALL 0
	49	#define PyTrace_EXCEPTION 1
	50	#define PyTrace_LINE 2
	51	#define PyTrace_RETURN 3
	52	#define PyTrace_C_CALL 4
	53	#define PyTrace_C_EXCEPTION 5
	54	#define PyTrace_C_RETURN 6
	55
	56	typedef struct _ts {
	57	/* See Python/ceval.c for comments explaining most fields */
	58
	59	struct _ts *next;
	60	PyInterpreterState *interp;
	61
	62	struct _frame *frame;
	63	int recursion_depth;
	64	/* 'tracing' keeps track of the execution depth when tracing/profiling.
	65	This is to prevent the actual trace/profile code from being recorded in
	66	the trace/profile. */
	67	int tracing;
	68	int use_tracing;
	69
	70	Py_tracefunc c_profilefunc;
	71	Py_tracefunc c_tracefunc;
	72	PyObject *c_profileobj;
	73	PyObject *c_traceobj;
	74
	75	PyObject *curexc_type;
	76	PyObject *curexc_value;
	77	PyObject *curexc_traceback;
	78
	79	PyObject *exc_type;
	80	PyObject *exc_value;
	81	PyObject *exc_traceback;
	82
	83	PyObject dict; / Stores per-thread state */
	84
	85	/* tick_counter is incremented whenever the check_interval ticker
	86	* reaches zero. The purpose is to give a useful measure of the number
	87	* of interpreted bytecode instructions in a given thread. This
	88	* extremely lightweight statistic collector may be of interest to
	89	* profilers (like psyco.jit()), although nothing in the core uses it.
	90	*/
	91	int tick_counter;
	92
	93	int gilstate_counter;
	94
	95	PyObject async_exc; / Asynchronous exception to raise */
	96	long thread_id; /* Thread id where this tstate was created */
	97
	98	/* XXX signal handlers should also be here */
	99
	100	} PyThreadState;
	101
	102
	103	PyAPI_FUNC(PyInterpreterState *) PyInterpreterState_New(void);
	104	PyAPI_FUNC(void) PyInterpreterState_Clear(PyInterpreterState *);
	105	PyAPI_FUNC(void) PyInterpreterState_Delete(PyInterpreterState *);
	106
	107	PyAPI_FUNC(PyThreadState ) PyThreadState_New(PyInterpreterState );
	108	PyAPI_FUNC(void) PyThreadState_Clear(PyThreadState *);
	109	PyAPI_FUNC(void) PyThreadState_Delete(PyThreadState *);
	110	#ifdef WITH_THREAD
	111	PyAPI_FUNC(void) PyThreadState_DeleteCurrent(void);
	112	#endif
	113
	114	PyAPI_FUNC(PyThreadState *) PyThreadState_Get(void);
	115	PyAPI_FUNC(PyThreadState ) PyThreadState_Swap(PyThreadState );
	116	PyAPI_FUNC(PyObject *) PyThreadState_GetDict(void);
	117	PyAPI_FUNC(int) PyThreadState_SetAsyncExc(long, PyObject *);
	118
	119
	120	/* Variable and macro for in-line access to current thread state */
	121
	122	PyAPI_DATA(PyThreadState *) _PyThreadState_Current;
	123
	124	#ifdef Py_DEBUG
	125	#define PyThreadState_GET() PyThreadState_Get()
	126	#else
	127	#define PyThreadState_GET() (_PyThreadState_Current)
	128	#endif
	129
	130	typedef
	131	enum {PyGILState_LOCKED, PyGILState_UNLOCKED}
	132	PyGILState_STATE;
	133
	134	/* Ensure that the current thread is ready to call the Python
	135	C API, regardless of the current state of Python, or of its
	136	thread lock. This may be called as many times as desired
	137	by a thread so long as each call is matched with a call to
	138	PyGILState_Release(). In general, other thread-state APIs may
	139	be used between _Ensure() and _Release() calls, so long as the
	140	thread-state is restored to its previous state before the Release().
	141	For example, normal use of the Py_BEGIN_ALLOW_THREADS/
	142	Py_END_ALLOW_THREADS macros are acceptable.
	143
	144	The return value is an opaque "handle" to the thread state when
	145	PyGILState_Ensure() was called, and must be passed to
	146	PyGILState_Release() to ensure Python is left in the same state. Even
	147	though recursive calls are allowed, these handles can not be shared -
	148	each unique call to PyGILState_Ensure must save the handle for its
	149	call to PyGILState_Release.
	150
	151	When the function returns, the current thread will hold the GIL.
	152
	153	Failure is a fatal error.
	154	*/
	155	PyAPI_FUNC(PyGILState_STATE) PyGILState_Ensure(void);
	156
	157	/* Release any resources previously acquired. After this call, Python's
	158	state will be the same as it was prior to the corresponding
	159	PyGILState_Ensure() call (but generally this state will be unknown to
	160	the caller, hence the use of the GILState API.)
	161
	162	Every call to PyGILState_Ensure must be matched by a call to
	163	PyGILState_Release on the same thread.
	164	*/
	165	PyAPI_FUNC(void) PyGILState_Release(PyGILState_STATE);
	166
	167	/* Helper/diagnostic function - get the current thread state for
	168	this thread. May return NULL if no GILState API has been used
	169	on the current thread. Note the main thread always has such a
	170	thread-state, even if no auto-thread-state call has been made
	171	on the main thread.
	172	*/
	173	PyAPI_FUNC(PyThreadState *) PyGILState_GetThisThreadState(void);
	174
	175	/* The implementation of sys._current_frames() Returns a dict mapping
	176	thread id to that thread's current frame.
	177	*/
	178	PyAPI_FUNC(PyObject *) _PyThread_CurrentFrames(void);
	179
	180	/* Routines for advanced debuggers, requested by David Beazley.
	181	Don't use unless you know what you are doing! */
	182	PyAPI_FUNC(PyInterpreterState *) PyInterpreterState_Head(void);
	183	PyAPI_FUNC(PyInterpreterState ) PyInterpreterState_Next(PyInterpreterState );
	184	PyAPI_FUNC(PyThreadState ) PyInterpreterState_ThreadHead(PyInterpreterState );
	185	PyAPI_FUNC(PyThreadState ) PyThreadState_Next(PyThreadState );
	186
	187	typedef struct _frame (PyThreadFrameGetter)(PyThreadState *self_);
	188
	189	/* hook for PyEval_GetFrame(), requested for Psyco */
	190	PyAPI_DATA(PyThreadFrameGetter) _PyThreadState_GetFrame;
	191
	192	#ifdef __cplusplus
	193	}
	194	#endif
	195	#endif /* !Py_PYSTATE_H */

sys/src/cmd/python/Include/pystrtod.h+18−0

@@ -0,0 +1,18 @@
	1	#ifndef Py_STRTOD_H
	2	#define Py_STRTOD_H
	3
	4	#ifdef __cplusplus
	5	extern "C" {
	6	#endif
	7
	8
	9	PyAPI_FUNC(double) PyOS_ascii_strtod(const char str, char *ptr);
	10	PyAPI_FUNC(double) PyOS_ascii_atof(const char *str);
	11	PyAPI_FUNC(char ) PyOS_ascii_formatd(char buffer, size_t buf_len, const char *format, double d);
	12
	13
	14	#ifdef __cplusplus
	15	}
	16	#endif
	17
	18	#endif /* !Py_STRTOD_H */

sys/src/cmd/python/Include/pythonrun.h+171−0

@@ -0,0 +1,171 @@
	1
	2	/* Interfaces to parse and execute pieces of python code */
	3
	4	#ifndef Py_PYTHONRUN_H
	5	#define Py_PYTHONRUN_H
	6	#ifdef __cplusplus
	7	extern "C" {
	8	#endif
	9
	10	#define PyCF_MASK (CO_FUTURE_DIVISION \| CO_FUTURE_ABSOLUTE_IMPORT \| \
	11	CO_FUTURE_WITH_STATEMENT)
	12	#define PyCF_MASK_OBSOLETE (CO_NESTED)
	13	#define PyCF_SOURCE_IS_UTF8 0x0100
	14	#define PyCF_DONT_IMPLY_DEDENT 0x0200
	15	#define PyCF_ONLY_AST 0x0400
	16
	17	typedef struct {
	18	int cf_flags; /* bitmask of CO_xxx flags relevant to future */
	19	} PyCompilerFlags;
	20
	21	PyAPI_FUNC(void) Py_SetProgramName(char *);
	22	PyAPI_FUNC(char *) Py_GetProgramName(void);
	23
	24	PyAPI_FUNC(void) Py_SetPythonHome(char *);
	25	PyAPI_FUNC(char *) Py_GetPythonHome(void);
	26
	27	PyAPI_FUNC(void) Py_Initialize(void);
	28	PyAPI_FUNC(void) Py_InitializeEx(int);
	29	PyAPI_FUNC(void) Py_Finalize(void);
	30	PyAPI_FUNC(int) Py_IsInitialized(void);
	31	PyAPI_FUNC(PyThreadState *) Py_NewInterpreter(void);
	32	PyAPI_FUNC(void) Py_EndInterpreter(PyThreadState *);
	33
	34	PyAPI_FUNC(int) PyRun_AnyFileFlags(FILE , const char , PyCompilerFlags *);
	35	PyAPI_FUNC(int) PyRun_AnyFileExFlags(FILE , const char , int, PyCompilerFlags *);
	36	PyAPI_FUNC(int) PyRun_SimpleStringFlags(const char , PyCompilerFlags );
	37	PyAPI_FUNC(int) PyRun_SimpleFileExFlags(FILE , const char , int, PyCompilerFlags *);
	38	PyAPI_FUNC(int) PyRun_InteractiveOneFlags(FILE , const char , PyCompilerFlags *);
	39	PyAPI_FUNC(int) PyRun_InteractiveLoopFlags(FILE , const char , PyCompilerFlags *);
	40
	41	PyAPI_FUNC(struct _mod ) PyParser_ASTFromString(const char , const char *,
	42	int, PyCompilerFlags *flags,
	43	PyArena *);
	44	PyAPI_FUNC(struct _mod ) PyParser_ASTFromFile(FILE , const char *, int,
	45	char , char ,
	46	PyCompilerFlags , int ,
	47	PyArena *);
	48	#define PyParser_SimpleParseString(S, B) \
	49	PyParser_SimpleParseStringFlags(S, B, 0)
	50	#define PyParser_SimpleParseFile(FP, S, B) \
	51	PyParser_SimpleParseFileFlags(FP, S, B, 0)
	52	PyAPI_FUNC(struct _node ) PyParser_SimpleParseStringFlags(const char , int,
	53	int);
	54	PyAPI_FUNC(struct _node ) PyParser_SimpleParseFileFlags(FILE , const char *,
	55	int, int);
	56
	57	PyAPI_FUNC(PyObject ) PyRun_StringFlags(const char , int, PyObject *,
	58	PyObject , PyCompilerFlags );
	59
	60	PyAPI_FUNC(PyObject ) PyRun_FileExFlags(FILE , const char *, int,
	61	PyObject , PyObject , int,
	62	PyCompilerFlags *);
	63
	64	#define Py_CompileString(str, p, s) Py_CompileStringFlags(str, p, s, NULL)
	65	PyAPI_FUNC(PyObject ) Py_CompileStringFlags(const char , const char *, int,
	66	PyCompilerFlags *);
	67	PyAPI_FUNC(struct symtable ) Py_SymtableString(const char , const char *, int);
	68
	69	PyAPI_FUNC(void) PyErr_Print(void);
	70	PyAPI_FUNC(void) PyErr_PrintEx(int);
	71	PyAPI_FUNC(void) PyErr_Display(PyObject , PyObject , PyObject *);
	72
	73	PyAPI_FUNC(int) Py_AtExit(void (*func)(void));
	74
	75	PyAPI_FUNC(void) Py_Exit(int);
	76
	77	PyAPI_FUNC(int) Py_FdIsInteractive(FILE , const char );
	78
	79	/* Bootstrap */
	80	PyAPI_FUNC(int) Py_Main(int argc, char **argv);
	81
	82	/* Use macros for a bunch of old variants */
	83	#define PyRun_String(str, s, g, l) PyRun_StringFlags(str, s, g, l, NULL)
	84	#define PyRun_AnyFile(fp, name) PyRun_AnyFileExFlags(fp, name, 0, NULL)
	85	#define PyRun_AnyFileEx(fp, name, closeit) \
	86	PyRun_AnyFileExFlags(fp, name, closeit, NULL)
	87	#define PyRun_AnyFileFlags(fp, name, flags) \
	88	PyRun_AnyFileExFlags(fp, name, 0, flags)
	89	#define PyRun_SimpleString(s) PyRun_SimpleStringFlags(s, NULL)
	90	#define PyRun_SimpleFile(f, p) PyRun_SimpleFileExFlags(f, p, 0, NULL)
	91	#define PyRun_SimpleFileEx(f, p, c) PyRun_SimpleFileExFlags(f, p, c, NULL)
	92	#define PyRun_InteractiveOne(f, p) PyRun_InteractiveOneFlags(f, p, NULL)
	93	#define PyRun_InteractiveLoop(f, p) PyRun_InteractiveLoopFlags(f, p, NULL)
	94	#define PyRun_File(fp, p, s, g, l) \
	95	PyRun_FileExFlags(fp, p, s, g, l, 0, NULL)
	96	#define PyRun_FileEx(fp, p, s, g, l, c) \
	97	PyRun_FileExFlags(fp, p, s, g, l, c, NULL)
	98	#define PyRun_FileFlags(fp, p, s, g, l, flags) \
	99	PyRun_FileExFlags(fp, p, s, g, l, 0, flags)
	100
	101	/* In getpath.c */
	102	PyAPI_FUNC(char *) Py_GetProgramFullPath(void);
	103	PyAPI_FUNC(char *) Py_GetPrefix(void);
	104	PyAPI_FUNC(char *) Py_GetExecPrefix(void);
	105	PyAPI_FUNC(char *) Py_GetPath(void);
	106
	107	/* In their own files */
	108	PyAPI_FUNC(const char *) Py_GetVersion(void);
	109	PyAPI_FUNC(const char *) Py_GetPlatform(void);
	110	PyAPI_FUNC(const char *) Py_GetCopyright(void);
	111	PyAPI_FUNC(const char *) Py_GetCompiler(void);
	112	PyAPI_FUNC(const char *) Py_GetBuildInfo(void);
	113	PyAPI_FUNC(const char *) _Py_svnversion(void);
	114	PyAPI_FUNC(const char *) Py_SubversionRevision(void);
	115	PyAPI_FUNC(const char *) Py_SubversionShortBranch(void);
	116
	117	/* Internal -- various one-time initializations */
	118	PyAPI_FUNC(PyObject *) _PyBuiltin_Init(void);
	119	PyAPI_FUNC(PyObject *) _PySys_Init(void);
	120	PyAPI_FUNC(void) _PyImport_Init(void);
	121	PyAPI_FUNC(void) _PyExc_Init(void);
	122	PyAPI_FUNC(void) _PyImportHooks_Init(void);
	123	PyAPI_FUNC(int) _PyFrame_Init(void);
	124	PyAPI_FUNC(int) _PyInt_Init(void);
	125	PyAPI_FUNC(void) _PyFloat_Init(void);
	126
	127	/* Various internal finalizers */
	128	PyAPI_FUNC(void) _PyExc_Fini(void);
	129	PyAPI_FUNC(void) _PyImport_Fini(void);
	130	PyAPI_FUNC(void) PyMethod_Fini(void);
	131	PyAPI_FUNC(void) PyFrame_Fini(void);
	132	PyAPI_FUNC(void) PyCFunction_Fini(void);
	133	PyAPI_FUNC(void) PyTuple_Fini(void);
	134	PyAPI_FUNC(void) PyList_Fini(void);
	135	PyAPI_FUNC(void) PySet_Fini(void);
	136	PyAPI_FUNC(void) PyString_Fini(void);
	137	PyAPI_FUNC(void) PyInt_Fini(void);
	138	PyAPI_FUNC(void) PyFloat_Fini(void);
	139	PyAPI_FUNC(void) PyOS_FiniInterrupts(void);
	140
	141	/* Stuff with no proper home (yet) */
	142	PyAPI_FUNC(char ) PyOS_Readline(FILE , FILE , char );
	143	PyAPI_DATA(int) (*PyOS_InputHook)(void);
	144	PyAPI_DATA(char) (PyOS_ReadlineFunctionPointer)(FILE , FILE , char *);
	145	PyAPI_DATA(PyThreadState*) _PyOS_ReadlineTState;
	146
	147	/* Stack size, in "pointers" (so we get extra safety margins
	148	on 64-bit platforms). On a 32-bit platform, this translates
	149	to a 8k margin. */
	150	#define PYOS_STACK_MARGIN 2048
	151
	152	#if defined(WIN32) && !defined(MS_WIN64) && defined(_MSC_VER)
	153	/* Enable stack checking under Microsoft C */
	154	#define USE_STACKCHECK
	155	#endif
	156
	157	#ifdef USE_STACKCHECK
	158	/* Check that we aren't overflowing our stack */
	159	PyAPI_FUNC(int) PyOS_CheckStack(void);
	160	#endif
	161
	162	/* Signals */
	163	typedef void (*PyOS_sighandler_t)(int);
	164	PyAPI_FUNC(PyOS_sighandler_t) PyOS_getsig(int);
	165	PyAPI_FUNC(PyOS_sighandler_t) PyOS_setsig(int, PyOS_sighandler_t);
	166
	167
	168	#ifdef __cplusplus
	169	}
	170	#endif
	171	#endif /* !Py_PYTHONRUN_H */

sys/src/cmd/python/Include/pythread.h+47−0

@@ -0,0 +1,47 @@
	1
	2	#ifndef Py_PYTHREAD_H
	3	#define Py_PYTHREAD_H
	4
	5	#define NO_EXIT_PROG /* don't define PyThread_exit_prog() */
	6	/* (the result is no use of signals on SGI) */
	7
	8	typedef void *PyThread_type_lock;
	9	typedef void *PyThread_type_sema;
	10
	11	#ifdef __cplusplus
	12	extern "C" {
	13	#endif
	14
	15	PyAPI_FUNC(void) PyThread_init_thread(void);
	16	PyAPI_FUNC(long) PyThread_start_new_thread(void ()(void ), void *);
	17	PyAPI_FUNC(void) PyThread_exit_thread(void);
	18	PyAPI_FUNC(void) PyThread__PyThread_exit_thread(void);
	19	PyAPI_FUNC(long) PyThread_get_thread_ident(void);
	20
	21	PyAPI_FUNC(PyThread_type_lock) PyThread_allocate_lock(void);
	22	PyAPI_FUNC(void) PyThread_free_lock(PyThread_type_lock);
	23	PyAPI_FUNC(int) PyThread_acquire_lock(PyThread_type_lock, int);
	24	#define WAIT_LOCK 1
	25	#define NOWAIT_LOCK 0
	26	PyAPI_FUNC(void) PyThread_release_lock(PyThread_type_lock);
	27
	28	PyAPI_FUNC(size_t) PyThread_get_stacksize(void);
	29	PyAPI_FUNC(int) PyThread_set_stacksize(size_t);
	30
	31	#ifndef NO_EXIT_PROG
	32	PyAPI_FUNC(void) PyThread_exit_prog(int);
	33	PyAPI_FUNC(void) PyThread__PyThread_exit_prog(int);
	34	#endif
	35
	36	/* Thread Local Storage (TLS) API */
	37	PyAPI_FUNC(int) PyThread_create_key(void);
	38	PyAPI_FUNC(void) PyThread_delete_key(int);
	39	PyAPI_FUNC(int) PyThread_set_key_value(int, void *);
	40	PyAPI_FUNC(void *) PyThread_get_key_value(int);
	41	PyAPI_FUNC(void) PyThread_delete_key_value(int key);
	42
	43	#ifdef __cplusplus
	44	}
	45	#endif
	46
	47	#endif /* !Py_PYTHREAD_H */

sys/src/cmd/python/Include/rangeobject.h+28−0

@@ -0,0 +1,28 @@
	1
	2	/* Range object interface */
	3
	4	#ifndef Py_RANGEOBJECT_H
	5	#define Py_RANGEOBJECT_H
	6	#ifdef __cplusplus
	7	extern "C" {
	8	#endif
	9
	10	/* This is about the type 'xrange', not the built-in function range(), which
	11	returns regular lists. */
	12
	13	/*
	14	A range object represents an integer range. This is an immutable object;
	15	a range cannot change its value after creation.
	16
	17	Range objects behave like the corresponding tuple objects except that
	18	they are represented by a start, stop, and step datamembers.
	19	*/
	20
	21	PyAPI_DATA(PyTypeObject) PyRange_Type;
	22
	23	#define PyRange_Check(op) ((op)->ob_type == &PyRange_Type)
	24
	25	#ifdef __cplusplus
	26	}
	27	#endif
	28	#endif /* !Py_RANGEOBJECT_H */

sys/src/cmd/python/Include/setobject.h+93−0

@@ -0,0 +1,93 @@
	1	/* Set object interface */
	2
	3	#ifndef Py_SETOBJECT_H
	4	#define Py_SETOBJECT_H
	5	#ifdef __cplusplus
	6	extern "C" {
	7	#endif
	8
	9
	10	/*
	11	There are three kinds of slots in the table:
	12
	13	1. Unused: key == NULL
	14	2. Active: key != NULL and key != dummy
	15	3. Dummy: key == dummy
	16
	17	Note: .pop() abuses the hash field of an Unused or Dummy slot to
	18	hold a search finger. The hash field of Unused or Dummy slots has
	19	no meaning otherwise.
	20	*/
	21
	22	#define PySet_MINSIZE 8
	23
	24	typedef struct {
	25	long hash; /* cached hash code for the entry key */
	26	PyObject *key;
	27	} setentry;
	28
	29
	30	/*
	31	This data structure is shared by set and frozenset objects.
	32	*/
	33
	34	typedef struct _setobject PySetObject;
	35	struct _setobject {
	36	PyObject_HEAD
	37
	38	Py_ssize_t fill; /* # Active + # Dummy */
	39	Py_ssize_t used; /* # Active */
	40
	41	/* The table contains mask + 1 slots, and that's a power of 2.
	42	* We store the mask instead of the size because the mask is more
	43	* frequently needed.
	44	*/
	45	Py_ssize_t mask;
	46
	47	/* table points to smalltable for small tables, else to
	48	* additional malloc'ed memory. table is never NULL! This rule
	49	* saves repeated runtime null-tests.
	50	*/
	51	setentry *table;
	52	setentry (lookup)(PySetObject so, PyObject key, long hash);
	53	setentry smalltable[PySet_MINSIZE];
	54
	55	long hash; /* only used by frozenset objects */
	56	PyObject weakreflist; / List of weak references */
	57	};
	58
	59	PyAPI_DATA(PyTypeObject) PySet_Type;
	60	PyAPI_DATA(PyTypeObject) PyFrozenSet_Type;
	61
	62	/* Invariants for frozensets:
	63	* data is immutable.
	64	* hash is the hash of the frozenset or -1 if not computed yet.
	65	* Invariants for sets:
	66	* hash is -1
	67	*/
	68
	69	#define PyFrozenSet_CheckExact(ob) ((ob)->ob_type == &PyFrozenSet_Type)
	70	#define PyAnySet_CheckExact(ob) \
	71	((ob)->ob_type == &PySet_Type \|\| (ob)->ob_type == &PyFrozenSet_Type)
	72	#define PyAnySet_Check(ob) \
	73	((ob)->ob_type == &PySet_Type \|\| (ob)->ob_type == &PyFrozenSet_Type \|\| \
	74	PyType_IsSubtype((ob)->ob_type, &PySet_Type) \|\| \
	75	PyType_IsSubtype((ob)->ob_type, &PyFrozenSet_Type))
	76
	77	PyAPI_FUNC(PyObject ) PySet_New(PyObject );
	78	PyAPI_FUNC(PyObject ) PyFrozenSet_New(PyObject );
	79	PyAPI_FUNC(Py_ssize_t) PySet_Size(PyObject *anyset);
	80	#define PySet_GET_SIZE(so) (((PySetObject *)(so))->used)
	81	PyAPI_FUNC(int) PySet_Clear(PyObject *set);
	82	PyAPI_FUNC(int) PySet_Contains(PyObject anyset, PyObject key);
	83	PyAPI_FUNC(int) PySet_Discard(PyObject set, PyObject key);
	84	PyAPI_FUNC(int) PySet_Add(PyObject set, PyObject key);
	85	PyAPI_FUNC(int) _PySet_Next(PyObject set, Py_ssize_t pos, PyObject **key);
	86	PyAPI_FUNC(int) _PySet_NextEntry(PyObject set, Py_ssize_t pos, PyObject *key, long hash);
	87	PyAPI_FUNC(PyObject ) PySet_Pop(PyObject set);
	88	PyAPI_FUNC(int) _PySet_Update(PyObject set, PyObject iterable);
	89
	90	#ifdef __cplusplus
	91	}
	92	#endif
	93	#endif /* !Py_SETOBJECT_H */

sys/src/cmd/python/Include/sliceobject.h+43−0

@@ -0,0 +1,43 @@
	1	#ifndef Py_SLICEOBJECT_H
	2	#define Py_SLICEOBJECT_H
	3	#ifdef __cplusplus
	4	extern "C" {
	5	#endif
	6
	7	/* The unique ellipsis object "..." */
	8
	9	PyAPI_DATA(PyObject) _Py_EllipsisObject; /* Don't use this directly */
	10
	11	#define Py_Ellipsis (&_Py_EllipsisObject)
	12
	13	/* Slice object interface */
	14
	15	/*
	16
	17	A slice object containing start, stop, and step data members (the
	18	names are from range). After much talk with Guido, it was decided to
	19	let these be any arbitrary python type. Py_None stands for omitted values.
	20	*/
	21
	22	typedef struct {
	23	PyObject_HEAD
	24	PyObject start, stop, step; / not NULL */
	25	} PySliceObject;
	26
	27	PyAPI_DATA(PyTypeObject) PySlice_Type;
	28
	29	#define PySlice_Check(op) ((op)->ob_type == &PySlice_Type)
	30
	31	PyAPI_FUNC(PyObject ) PySlice_New(PyObject start, PyObject* stop,
	32	PyObject* step);
	33	PyAPI_FUNC(PyObject *) _PySlice_FromIndices(Py_ssize_t start, Py_ssize_t stop);
	34	PyAPI_FUNC(int) PySlice_GetIndices(PySliceObject *r, Py_ssize_t length,
	35	Py_ssize_t start, Py_ssize_t stop, Py_ssize_t *step);
	36	PyAPI_FUNC(int) PySlice_GetIndicesEx(PySliceObject *r, Py_ssize_t length,
	37	Py_ssize_t start, Py_ssize_t stop,
	38	Py_ssize_t step, Py_ssize_t slicelength);
	39
	40	#ifdef __cplusplus
	41	}
	42	#endif
	43	#endif /* !Py_SLICEOBJECT_H */

sys/src/cmd/python/Include/stringobject.h+183−0

@@ -0,0 +1,183 @@
	1
	2	/* String object interface */
	3
	4	#ifndef Py_STRINGOBJECT_H
	5	#define Py_STRINGOBJECT_H
	6	#ifdef __cplusplus
	7	extern "C" {
	8	#endif
	9
	10	#include <stdarg.h>
	11
	12	/*
	13	Type PyStringObject represents a character string. An extra zero byte is
	14	reserved at the end to ensure it is zero-terminated, but a size is
	15	present so strings with null bytes in them can be represented. This
	16	is an immutable object type.
	17
	18	There are functions to create new string objects, to test
	19	an object for string-ness, and to get the
	20	string value. The latter function returns a null pointer
	21	if the object is not of the proper type.
	22	There is a variant that takes an explicit size as well as a
	23	variant that assumes a zero-terminated string. Note that none of the
	24	functions should be applied to nil objects.
	25	*/
	26
	27	/* Caching the hash (ob_shash) saves recalculation of a string's hash value.
	28	Interning strings (ob_sstate) tries to ensure that only one string
	29	object with a given value exists, so equality tests can be one pointer
	30	comparison. This is generally restricted to strings that "look like"
	31	Python identifiers, although the intern() builtin can be used to force
	32	interning of any string.
	33	Together, these sped the interpreter by up to 20%. */
	34
	35	typedef struct {
	36	PyObject_VAR_HEAD
	37	long ob_shash;
	38	int ob_sstate;
	39	char ob_sval[1];
	40
	41	/* Invariants:
	42	* ob_sval contains space for 'ob_size+1' elements.
	43	* ob_sval[ob_size] == 0.
	44	* ob_shash is the hash of the string or -1 if not computed yet.
	45	* ob_sstate != 0 iff the string object is in stringobject.c's
	46	* 'interned' dictionary; in this case the two references
	47	* from 'interned' to this object are not counted in ob_refcnt.
	48	*/
	49	} PyStringObject;
	50
	51	#define SSTATE_NOT_INTERNED 0
	52	#define SSTATE_INTERNED_MORTAL 1
	53	#define SSTATE_INTERNED_IMMORTAL 2
	54
	55	PyAPI_DATA(PyTypeObject) PyBaseString_Type;
	56	PyAPI_DATA(PyTypeObject) PyString_Type;
	57
	58	#define PyString_Check(op) PyObject_TypeCheck(op, &PyString_Type)
	59	#define PyString_CheckExact(op) ((op)->ob_type == &PyString_Type)
	60
	61	PyAPI_FUNC(PyObject ) PyString_FromStringAndSize(const char , Py_ssize_t);
	62	PyAPI_FUNC(PyObject ) PyString_FromString(const char );
	63	PyAPI_FUNC(PyObject ) PyString_FromFormatV(const char, va_list)
	64	Py_GCC_ATTRIBUTE((format(printf, 1, 0)));
	65	PyAPI_FUNC(PyObject ) PyString_FromFormat(const char, ...)
	66	Py_GCC_ATTRIBUTE((format(printf, 1, 2)));
	67	PyAPI_FUNC(Py_ssize_t) PyString_Size(PyObject *);
	68	PyAPI_FUNC(char ) PyString_AsString(PyObject );
	69	PyAPI_FUNC(PyObject ) PyString_Repr(PyObject , int);
	70	PyAPI_FUNC(void) PyString_Concat(PyObject *, PyObject );
	71	PyAPI_FUNC(void) PyString_ConcatAndDel(PyObject *, PyObject );
	72	PyAPI_FUNC(int) _PyString_Resize(PyObject **, Py_ssize_t);
	73	PyAPI_FUNC(int) _PyString_Eq(PyObject , PyObject);
	74	PyAPI_FUNC(PyObject ) PyString_Format(PyObject , PyObject *);
	75	PyAPI_FUNC(PyObject ) _PyString_FormatLong(PyObject, int, int,
	76	int, char*, int);
	77	PyAPI_FUNC(PyObject ) PyString_DecodeEscape(const char , Py_ssize_t,
	78	const char *, Py_ssize_t,
	79	const char *);
	80
	81	PyAPI_FUNC(void) PyString_InternInPlace(PyObject **);
	82	PyAPI_FUNC(void) PyString_InternImmortal(PyObject **);
	83	PyAPI_FUNC(PyObject ) PyString_InternFromString(const char );
	84	PyAPI_FUNC(void) _Py_ReleaseInternedStrings(void);
	85
	86	/* Use only if you know it's a string */
	87	#define PyString_CHECK_INTERNED(op) (((PyStringObject *)(op))->ob_sstate)
	88
	89	/* Macro, trading safety for speed */
	90	#define PyString_AS_STRING(op) (((PyStringObject *)(op))->ob_sval)
	91	#define PyString_GET_SIZE(op) (((PyStringObject *)(op))->ob_size)
	92
	93	/* _PyString_Join(sep, x) is like sep.join(x). sep must be PyStringObject*,
	94	x must be an iterable object. */
	95	PyAPI_FUNC(PyObject ) _PyString_Join(PyObject sep, PyObject *x);
	96
	97	/* --- Generic Codecs ----------------------------------------------------- */
	98
	99	/* Create an object by decoding the encoded string s of the
	100	given size. */
	101
	102	PyAPI_FUNC(PyObject*) PyString_Decode(
	103	const char s, / encoded string */
	104	Py_ssize_t size, /* size of buffer */
	105	const char encoding, / encoding */
	106	const char errors / error handling */
	107	);
	108
	109	/* Encodes a char buffer of the given size and returns a
	110	Python object. */
	111
	112	PyAPI_FUNC(PyObject*) PyString_Encode(
	113	const char s, / string char buffer */
	114	Py_ssize_t size, /* number of chars to encode */
	115	const char encoding, / encoding */
	116	const char errors / error handling */
	117	);
	118
	119	/* Encodes a string object and returns the result as Python
	120	object. */
	121
	122	PyAPI_FUNC(PyObject*) PyString_AsEncodedObject(
	123	PyObject str, / string object */
	124	const char encoding, / encoding */
	125	const char errors / error handling */
	126	);
	127
	128	/* Encodes a string object and returns the result as Python string
	129	object.
	130
	131	If the codec returns an Unicode object, the object is converted
	132	back to a string using the default encoding.
	133
	134	DEPRECATED - use PyString_AsEncodedObject() instead. */
	135
	136	PyAPI_FUNC(PyObject*) PyString_AsEncodedString(
	137	PyObject str, / string object */
	138	const char encoding, / encoding */
	139	const char errors / error handling */
	140	);
	141
	142	/* Decodes a string object and returns the result as Python
	143	object. */
	144
	145	PyAPI_FUNC(PyObject*) PyString_AsDecodedObject(
	146	PyObject str, / string object */
	147	const char encoding, / encoding */
	148	const char errors / error handling */
	149	);
	150
	151	/* Decodes a string object and returns the result as Python string
	152	object.
	153
	154	If the codec returns an Unicode object, the object is converted
	155	back to a string using the default encoding.
	156
	157	DEPRECATED - use PyString_AsDecodedObject() instead. */
	158
	159	PyAPI_FUNC(PyObject*) PyString_AsDecodedString(
	160	PyObject str, / string object */
	161	const char encoding, / encoding */
	162	const char errors / error handling */
	163	);
	164
	165	/* Provides access to the internal data buffer and size of a string
	166	object or the default encoded version of an Unicode object. Passing
	167	NULL as *len parameter will force the string buffer to be
	168	0-terminated (passing a string with embedded NULL characters will
	169	cause an exception). */
	170
	171	PyAPI_FUNC(int) PyString_AsStringAndSize(
	172	register PyObject obj, / string or Unicode object */
	173	register char *s, / pointer to buffer variable */
	174	register Py_ssize_t len / pointer to length variable or NULL
	175	(only possible for 0-terminated
	176	strings) */
	177	);
	178
	179
	180	#ifdef __cplusplus
	181	}
	182	#endif
	183	#endif /* !Py_STRINGOBJECT_H */

sys/src/cmd/python/Include/structmember.h+93−0

@@ -0,0 +1,93 @@
	1	#ifndef Py_STRUCTMEMBER_H
	2	#define Py_STRUCTMEMBER_H
	3	#ifdef __cplusplus
	4	extern "C" {
	5	#endif
	6
	7
	8	/* Interface to map C struct members to Python object attributes */
	9
	10	#include <stddef.h> /* For offsetof */
	11
	12	/* The offsetof() macro calculates the offset of a structure member
	13	in its structure. Unfortunately this cannot be written down
	14	portably, hence it is provided by a Standard C header file.
	15	For pre-Standard C compilers, here is a version that usually works
	16	(but watch out!): */
	17
	18	#ifndef offsetof
	19	#define offsetof(type, member) ( (int) & ((type*)0) -> member )
	20	#endif
	21
	22	/* An array of memberlist structures defines the name, type and offset
	23	of selected members of a C structure. These can be read by
	24	PyMember_Get() and set by PyMember_Set() (except if their READONLY flag
	25	is set). The array must be terminated with an entry whose name
	26	pointer is NULL. */
	27
	28	struct memberlist {
	29	/* Obsolete version, for binary backwards compatibility */
	30	char *name;
	31	int type;
	32	int offset;
	33	int flags;
	34	};
	35
	36	typedef struct PyMemberDef {
	37	/* Current version, use this */
	38	char *name;
	39	int type;
	40	Py_ssize_t offset;
	41	int flags;
	42	char *doc;
	43	} PyMemberDef;
	44
	45	/* Types */
	46	#define T_SHORT 0
	47	#define T_INT 1
	48	#define T_LONG 2
	49	#define T_FLOAT 3
	50	#define T_DOUBLE 4
	51	#define T_STRING 5
	52	#define T_OBJECT 6
	53	/* XXX the ordering here is weird for binary compatibility */
	54	#define T_CHAR 7 /* 1-character string */
	55	#define T_BYTE 8 /* 8-bit signed int */
	56	/* unsigned variants: */
	57	#define T_UBYTE 9
	58	#define T_USHORT 10
	59	#define T_UINT 11
	60	#define T_ULONG 12
	61
	62	/* Added by Jack: strings contained in the structure */
	63	#define T_STRING_INPLACE 13
	64
	65	#define T_OBJECT_EX 16 /* Like T_OBJECT, but raises AttributeError
	66	when the value is NULL, instead of
	67	converting to None. */
	68	#ifdef HAVE_LONG_LONG
	69	#define T_LONGLONG 17
	70	#define T_ULONGLONG 18
	71	#endif /* HAVE_LONG_LONG */
	72
	73	/* Flags */
	74	#define READONLY 1
	75	#define RO READONLY /* Shorthand */
	76	#define READ_RESTRICTED 2
	77	#define WRITE_RESTRICTED 4
	78	#define RESTRICTED (READ_RESTRICTED \| WRITE_RESTRICTED)
	79
	80
	81	/* Obsolete API, for binary backwards compatibility */
	82	PyAPI_FUNC(PyObject ) PyMember_Get(const char , struct memberlist , const char );
	83	PyAPI_FUNC(int) PyMember_Set(char , struct memberlist , const char , PyObject );
	84
	85	/* Current API, use this */
	86	PyAPI_FUNC(PyObject ) PyMember_GetOne(const char , struct PyMemberDef *);
	87	PyAPI_FUNC(int) PyMember_SetOne(char , struct PyMemberDef , PyObject *);
	88
	89
	90	#ifdef __cplusplus
	91	}
	92	#endif
	93	#endif /* !Py_STRUCTMEMBER_H */

sys/src/cmd/python/Include/structseq.h+41−0

@@ -0,0 +1,41 @@
	1
	2	/* Tuple object interface */
	3
	4	#ifndef Py_STRUCTSEQ_H
	5	#define Py_STRUCTSEQ_H
	6	#ifdef __cplusplus
	7	extern "C" {
	8	#endif
	9
	10	typedef struct PyStructSequence_Field {
	11	char *name;
	12	char *doc;
	13	} PyStructSequence_Field;
	14
	15	typedef struct PyStructSequence_Desc {
	16	char *name;
	17	char *doc;
	18	struct PyStructSequence_Field *fields;
	19	int n_in_sequence;
	20	} PyStructSequence_Desc;
	21
	22	extern char* PyStructSequence_UnnamedField;
	23
	24	PyAPI_FUNC(void) PyStructSequence_InitType(PyTypeObject *type,
	25	PyStructSequence_Desc *desc);
	26
	27	PyAPI_FUNC(PyObject ) PyStructSequence_New(PyTypeObject type);
	28
	29	typedef struct {
	30	PyObject_VAR_HEAD
	31	PyObject *ob_item[1];
	32	} PyStructSequence;
	33
	34	/* Macro, only to be used to fill in brand new objects */
	35	#define PyStructSequence_SET_ITEM(op, i, v) \
	36	(((PyStructSequence *)(op))->ob_item[i] = v)
	37
	38	#ifdef __cplusplus
	39	}
	40	#endif
	41	#endif /* !Py_STRUCTSEQ_H */

sys/src/cmd/python/Include/symtable.h+103−0

@@ -0,0 +1,103 @@
	1	#ifndef Py_SYMTABLE_H
	2	#define Py_SYMTABLE_H
	3
	4	#ifdef __cplusplus
	5	extern "C" {
	6	#endif
	7
	8	typedef enum _block_type { FunctionBlock, ClassBlock, ModuleBlock }
	9	_Py_block_ty;
	10
	11	struct _symtable_entry;
	12
	13	struct symtable {
	14	const char st_filename; / name of file being compiled */
	15	struct _symtable_entry st_cur; / current symbol table entry */
	16	struct _symtable_entry st_top; / module entry */
	17	PyObject st_symbols; / dictionary of symbol table entries */
	18	PyObject st_stack; / stack of namespace info */
	19	PyObject st_global; / borrowed ref to MODULE in st_symbols */
	20	int st_nblocks; /* number of blocks */
	21	PyObject st_private; / name of current class or NULL */
	22	int st_tmpname; /* temporary name counter */
	23	PyFutureFeatures st_future; / module's future features */
	24	};
	25
	26	typedef struct _symtable_entry {
	27	PyObject_HEAD
	28	PyObject ste_id; / int: key in st_symbols */
	29	PyObject ste_symbols; / dict: name to flags */
	30	PyObject ste_name; / string: name of block */
	31	PyObject ste_varnames; / list of variable names */
	32	PyObject ste_children; / list of child ids */
	33	_Py_block_ty ste_type; /* module, class, or function */
	34	int ste_unoptimized; /* false if namespace is optimized */
	35	unsigned ste_nested : 1; /* true if block is nested */
	36	unsigned ste_free : 1; /* true if block has free variables */
	37	unsigned ste_child_free : 1; /* true if a child block has free vars,
	38	including free refs to globals */
	39	unsigned ste_generator : 1; /* true if namespace is a generator */
	40	unsigned ste_varargs : 1; /* true if block has varargs */
	41	unsigned ste_varkeywords : 1; /* true if block has varkeywords */
	42	unsigned ste_returns_value : 1; /* true if namespace uses return with
	43	an argument */
	44	int ste_lineno; /* first line of block */
	45	int ste_opt_lineno; /* lineno of last exec or import * */
	46	int ste_tmpname; /* counter for listcomp temp vars */
	47	struct symtable *ste_table;
	48	} PySTEntryObject;
	49
	50	PyAPI_DATA(PyTypeObject) PySTEntry_Type;
	51
	52	#define PySTEntry_Check(op) ((op)->ob_type == &PySTEntry_Type)
	53
	54	PyAPI_FUNC(int) PyST_GetScope(PySTEntryObject , PyObject );
	55
	56	PyAPI_FUNC(struct symtable ) PySymtable_Build(mod_ty, const char ,
	57	PyFutureFeatures *);
	58	PyAPI_FUNC(PySTEntryObject ) PySymtable_Lookup(struct symtable , void *);
	59
	60	PyAPI_FUNC(void) PySymtable_Free(struct symtable *);
	61
	62	/* Flags for def-use information */
	63
	64	#define DEF_GLOBAL 1 /* global stmt */
	65	#define DEF_LOCAL 2 /* assignment in code block */
	66	#define DEF_PARAM 2<<1 /* formal parameter */
	67	#define USE 2<<2 /* name is used */
	68	#define DEF_STAR 2<<3 /* parameter is star arg */
	69	#define DEF_DOUBLESTAR 2<<4 /* parameter is star-star arg */
	70	#define DEF_INTUPLE 2<<5 /* name defined in tuple in parameters */
	71	#define DEF_FREE 2<<6 /* name used but not defined in nested block */
	72	#define DEF_FREE_GLOBAL 2<<7 /* free variable is actually implicit global */
	73	#define DEF_FREE_CLASS 2<<8 /* free variable from class's method */
	74	#define DEF_IMPORT 2<<9 /* assignment occurred via import */
	75
	76	#define DEF_BOUND (DEF_LOCAL \| DEF_PARAM \| DEF_IMPORT)
	77
	78	/* GLOBAL_EXPLICIT and GLOBAL_IMPLICIT are used internally by the symbol
	79	table. GLOBAL is returned from PyST_GetScope() for either of them.
	80	It is stored in ste_symbols at bits 12-14.
	81	*/
	82	#define SCOPE_OFF 11
	83	#define SCOPE_MASK 7
	84
	85	#define LOCAL 1
	86	#define GLOBAL_EXPLICIT 2
	87	#define GLOBAL_IMPLICIT 3
	88	#define FREE 4
	89	#define CELL 5
	90
	91	/* The following three names are used for the ste_unoptimized bit field */
	92	#define OPT_IMPORT_STAR 1
	93	#define OPT_EXEC 2
	94	#define OPT_BARE_EXEC 4
	95	#define OPT_TOPLEVEL 8 /* top-level names, including eval and exec */
	96
	97	#define GENERATOR 1
	98	#define GENERATOR_EXPRESSION 2
	99
	100	#ifdef __cplusplus
	101	}
	102	#endif
	103	#endif /* !Py_SYMTABLE_H */

sys/src/cmd/python/Include/sysmodule.h+30−0

@@ -0,0 +1,30 @@
	1
	2	/* System module interface */
	3
	4	#ifndef Py_SYSMODULE_H
	5	#define Py_SYSMODULE_H
	6	#ifdef __cplusplus
	7	extern "C" {
	8	#endif
	9
	10	PyAPI_FUNC(PyObject ) PySys_GetObject(char );
	11	PyAPI_FUNC(int) PySys_SetObject(char , PyObject );
	12	PyAPI_FUNC(FILE ) PySys_GetFile(char , FILE *);
	13	PyAPI_FUNC(void) PySys_SetArgv(int, char **);
	14	PyAPI_FUNC(void) PySys_SetPath(char *);
	15
	16	PyAPI_FUNC(void) PySys_WriteStdout(const char *format, ...)
	17	Py_GCC_ATTRIBUTE((format(printf, 1, 2)));
	18	PyAPI_FUNC(void) PySys_WriteStderr(const char *format, ...)
	19	Py_GCC_ATTRIBUTE((format(printf, 1, 2)));
	20
	21	PyAPI_DATA(PyObject ) _PySys_TraceFunc, _PySys_ProfileFunc;
	22	PyAPI_DATA(int) _PySys_CheckInterval;
	23
	24	PyAPI_FUNC(void) PySys_ResetWarnOptions(void);
	25	PyAPI_FUNC(void) PySys_AddWarnOption(char *);
	26
	27	#ifdef __cplusplus
	28	}
	29	#endif
	30	#endif /* !Py_SYSMODULE_H */

sys/src/cmd/python/Include/timefuncs.h+23−0

@@ -0,0 +1,23 @@
	1	/* timefuncs.h
	2	*/
	3
	4	/* Utility function related to timemodule.c. */
	5
	6	#ifndef TIMEFUNCS_H
	7	#define TIMEFUNCS_H
	8	#ifdef __cplusplus
	9	extern "C" {
	10	#endif
	11
	12
	13	/* Cast double x to time_t, but raise ValueError if x is too large
	14	* to fit in a time_t. ValueError is set on return iff the return
	15	* value is (time_t)-1 and PyErr_Occurred().
	16	*/
	17	PyAPI_FUNC(time_t) _PyTime_DoubleToTimet(double x);
	18
	19
	20	#ifdef __cplusplus
	21	}
	22	#endif
	23	#endif /* TIMEFUNCS_H */

sys/src/cmd/python/Include/token.h+83−0

@@ -0,0 +1,83 @@
	1
	2	/* Token types */
	3
	4	#ifndef Py_TOKEN_H
	5	#define Py_TOKEN_H
	6	#ifdef __cplusplus
	7	extern "C" {
	8	#endif
	9
	10	#define ENDMARKER 0
	11	#define NAME 1
	12	#define NUMBER 2
	13	#define STRING 3
	14	#define NEWLINE 4
	15	#define INDENT 5
	16	#define DEDENT 6
	17	#define LPAR 7
	18	#define RPAR 8
	19	#define LSQB 9
	20	#define RSQB 10
	21	#define COLON 11
	22	#define COMMA 12
	23	#define SEMI 13
	24	#define PLUS 14
	25	#define MINUS 15
	26	#define STAR 16
	27	#define SLASH 17
	28	#define VBAR 18
	29	#define AMPER 19
	30	#define LESS 20
	31	#define GREATER 21
	32	#define EQUAL 22
	33	#define DOT 23
	34	#define PERCENT 24
	35	#define BACKQUOTE 25
	36	#define LBRACE 26
	37	#define RBRACE 27
	38	#define EQEQUAL 28
	39	#define NOTEQUAL 29
	40	#define LESSEQUAL 30
	41	#define GREATEREQUAL 31
	42	#define TILDE 32
	43	#define CIRCUMFLEX 33
	44	#define LEFTSHIFT 34
	45	#define RIGHTSHIFT 35
	46	#define DOUBLESTAR 36
	47	#define PLUSEQUAL 37
	48	#define MINEQUAL 38
	49	#define STAREQUAL 39
	50	#define SLASHEQUAL 40
	51	#define PERCENTEQUAL 41
	52	#define AMPEREQUAL 42
	53	#define VBAREQUAL 43
	54	#define CIRCUMFLEXEQUAL 44
	55	#define LEFTSHIFTEQUAL 45
	56	#define RIGHTSHIFTEQUAL 46
	57	#define DOUBLESTAREQUAL 47
	58	#define DOUBLESLASH 48
	59	#define DOUBLESLASHEQUAL 49
	60	#define AT 50
	61	/* Don't forget to update the table _PyParser_TokenNames in tokenizer.c! */
	62	#define OP 51
	63	#define ERRORTOKEN 52
	64	#define N_TOKENS 53
	65
	66	/* Special definitions for cooperation with parser */
	67
	68	#define NT_OFFSET 256
	69
	70	#define ISTERMINAL(x) ((x) < NT_OFFSET)
	71	#define ISNONTERMINAL(x) ((x) >= NT_OFFSET)
	72	#define ISEOF(x) ((x) == ENDMARKER)
	73
	74
	75	PyAPI_DATA(char ) _PyParser_TokenNames[]; / Token names */
	76	PyAPI_FUNC(int) PyToken_OneChar(int);
	77	PyAPI_FUNC(int) PyToken_TwoChars(int, int);
	78	PyAPI_FUNC(int) PyToken_ThreeChars(int, int, int);
	79
	80	#ifdef __cplusplus
	81	}
	82	#endif
	83	#endif /* !Py_TOKEN_H */

sys/src/cmd/python/Include/traceback.h+30−0

@@ -0,0 +1,30 @@
	1
	2	#ifndef Py_TRACEBACK_H
	3	#define Py_TRACEBACK_H
	4	#ifdef __cplusplus
	5	extern "C" {
	6	#endif
	7
	8	struct _frame;
	9
	10	/* Traceback interface */
	11
	12	typedef struct _traceback {
	13	PyObject_HEAD
	14	struct _traceback *tb_next;
	15	struct _frame *tb_frame;
	16	int tb_lasti;
	17	int tb_lineno;
	18	} PyTracebackObject;
	19
	20	PyAPI_FUNC(int) PyTraceBack_Here(struct _frame *);
	21	PyAPI_FUNC(int) PyTraceBack_Print(PyObject , PyObject );
	22
	23	/* Reveal traceback type so we can typecheck traceback objects */
	24	PyAPI_DATA(PyTypeObject) PyTraceBack_Type;
	25	#define PyTraceBack_Check(v) ((v)->ob_type == &PyTraceBack_Type)
	26
	27	#ifdef __cplusplus
	28	}
	29	#endif
	30	#endif /* !Py_TRACEBACK_H */

sys/src/cmd/python/Include/tupleobject.h+57−0

@@ -0,0 +1,57 @@
	1
	2	/* Tuple object interface */
	3
	4	#ifndef Py_TUPLEOBJECT_H
	5	#define Py_TUPLEOBJECT_H
	6	#ifdef __cplusplus
	7	extern "C" {
	8	#endif
	9
	10	/*
	11	Another generally useful object type is a tuple of object pointers.
	12	For Python, this is an immutable type. C code can change the tuple items
	13	(but not their number), and even use tuples are general-purpose arrays of
	14	object references, but in general only brand new tuples should be mutated,
	15	not ones that might already have been exposed to Python code.
	16
	17	* WARNING * PyTuple_SetItem does not increment the new item's reference
	18	count, but does decrement the reference count of the item it replaces,
	19	if not nil. It does decrement the reference count if it is not
	20	inserted in the tuple. Similarly, PyTuple_GetItem does not increment the
	21	returned item's reference count.
	22	*/
	23
	24	typedef struct {
	25	PyObject_VAR_HEAD
	26	PyObject *ob_item[1];
	27
	28	/* ob_item contains space for 'ob_size' elements.
	29	* Items must normally not be NULL, except during construction when
	30	* the tuple is not yet visible outside the function that builds it.
	31	*/
	32	} PyTupleObject;
	33
	34	PyAPI_DATA(PyTypeObject) PyTuple_Type;
	35
	36	#define PyTuple_Check(op) PyObject_TypeCheck(op, &PyTuple_Type)
	37	#define PyTuple_CheckExact(op) ((op)->ob_type == &PyTuple_Type)
	38
	39	PyAPI_FUNC(PyObject *) PyTuple_New(Py_ssize_t size);
	40	PyAPI_FUNC(Py_ssize_t) PyTuple_Size(PyObject *);
	41	PyAPI_FUNC(PyObject ) PyTuple_GetItem(PyObject , Py_ssize_t);
	42	PyAPI_FUNC(int) PyTuple_SetItem(PyObject , Py_ssize_t, PyObject );
	43	PyAPI_FUNC(PyObject ) PyTuple_GetSlice(PyObject , Py_ssize_t, Py_ssize_t);
	44	PyAPI_FUNC(int) _PyTuple_Resize(PyObject **, Py_ssize_t);
	45	PyAPI_FUNC(PyObject *) PyTuple_Pack(Py_ssize_t, ...);
	46
	47	/* Macro, trading safety for speed */
	48	#define PyTuple_GET_ITEM(op, i) (((PyTupleObject *)(op))->ob_item[i])
	49	#define PyTuple_GET_SIZE(op) (((PyTupleObject *)(op))->ob_size)
	50
	51	/* Macro, only to be used to fill in brand new tuples */
	52	#define PyTuple_SET_ITEM(op, i, v) (((PyTupleObject *)(op))->ob_item[i] = v)
	53
	54	#ifdef __cplusplus
	55	}
	56	#endif
	57	#endif /* !Py_TUPLEOBJECT_H */

sys/src/cmd/python/Include/ucnhash.h+31−0

@@ -0,0 +1,31 @@
	1	/* Unicode name database interface */
	2
	3	#ifndef Py_UCNHASH_H
	4	#define Py_UCNHASH_H
	5	#ifdef __cplusplus
	6	extern "C" {
	7	#endif
	8
	9	/* revised ucnhash CAPI interface (exported through a PyCObject) */
	10
	11	typedef struct {
	12
	13	/* Size of this struct */
	14	int size;
	15
	16	/* Get name for a given character code. Returns non-zero if
	17	success, zero if not. Does not set Python exceptions.
	18	If self is NULL, data come from the default version of the database.
	19	If it is not NULL, it should be a unicodedata.ucd_X_Y_Z object */
	20	int (getname)(PyObject self, Py_UCS4 code, char* buffer, int buflen);
	21
	22	/* Get character code for a given name. Same error handling
	23	as for getname. */
	24	int (getcode)(PyObject self, const char* name, int namelen, Py_UCS4* code);
	25
	26	} _PyUnicode_Name_CAPI;
	27
	28	#ifdef __cplusplus
	29	}
	30	#endif
	31	#endif /* !Py_UCNHASH_H */

sys/src/cmd/python/Include/unicodeobject.h+1265−0

@@ -0,0 +1,1265 @@
	1	#ifndef Py_UNICODEOBJECT_H
	2	#define Py_UNICODEOBJECT_H
	3
	4	/*
	5
	6	Unicode implementation based on original code by Fredrik Lundh,
	7	modified by Marc-Andre Lemburg (mal@lemburg.com) according to the
	8	Unicode Integration Proposal (see file Misc/unicode.txt).
	9
	10	Copyright (c) Corporation for National Research Initiatives.
	11
	12
	13	Original header:
	14	--------------------------------------------------------------------
	15
	16	* Yet another Unicode string type for Python. This type supports the
	17	* 16-bit Basic Multilingual Plane (BMP) only.
	18	*
	19	* Written by Fredrik Lundh, January 1999.
	20	*
	21	* Copyright (c) 1999 by Secret Labs AB.
	22	* Copyright (c) 1999 by Fredrik Lundh.
	23	*
	24	* fredrik@pythonware.com
	25	* http://www.pythonware.com
	26	*
	27	* --------------------------------------------------------------------
	28	* This Unicode String Type is
	29	*
	30	* Copyright (c) 1999 by Secret Labs AB
	31	* Copyright (c) 1999 by Fredrik Lundh
	32	*
	33	* By obtaining, using, and/or copying this software and/or its
	34	* associated documentation, you agree that you have read, understood,
	35	* and will comply with the following terms and conditions:
	36	*
	37	* Permission to use, copy, modify, and distribute this software and its
	38	* associated documentation for any purpose and without fee is hereby
	39	* granted, provided that the above copyright notice appears in all
	40	* copies, and that both that copyright notice and this permission notice
	41	* appear in supporting documentation, and that the name of Secret Labs
	42	* AB or the author not be used in advertising or publicity pertaining to
	43	* distribution of the software without specific, written prior
	44	* permission.
	45	*
	46	* SECRET LABS AB AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH REGARD TO
	47	* THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND
	48	* FITNESS. IN NO EVENT SHALL SECRET LABS AB OR THE AUTHOR BE LIABLE FOR
	49	* ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
	50	* WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
	51	* ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT
	52	* OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
	53	* -------------------------------------------------------------------- */
	54
	55	#include <ctype.h>
	56
	57	/* === Internal API ======================================================= */
	58
	59	/* --- Internal Unicode Format -------------------------------------------- */
	60
	61	#ifndef Py_USING_UNICODE
	62
	63	#define PyUnicode_Check(op) 0
	64	#define PyUnicode_CheckExact(op) 0
	65
	66	#else
	67
	68	/* FIXME: MvL's new implementation assumes that Py_UNICODE_SIZE is
	69	properly set, but the default rules below doesn't set it. I'll
	70	sort this out some other day -- fredrik@pythonware.com */
	71
	72	#ifndef Py_UNICODE_SIZE
	73	#error Must define Py_UNICODE_SIZE
	74	#endif
	75
	76	/* Setting Py_UNICODE_WIDE enables UCS-4 storage. Otherwise, Unicode
	77	strings are stored as UCS-2 (with limited support for UTF-16) */
	78
	79	#if Py_UNICODE_SIZE >= 4
	80	#define Py_UNICODE_WIDE
	81	#endif
	82
	83	/* Set these flags if the platform has "wchar.h", "wctype.h" and the
	84	wchar_t type is a 16-bit unsigned type */
	85	/* #define HAVE_WCHAR_H */
	86	/* #define HAVE_USABLE_WCHAR_T */
	87
	88	/* Defaults for various platforms */
	89	#ifndef PY_UNICODE_TYPE
	90
	91	/* Windows has a usable wchar_t type (unless we're using UCS-4) */
	92	# if defined(MS_WIN32) && Py_UNICODE_SIZE == 2
	93	# define HAVE_USABLE_WCHAR_T
	94	# define PY_UNICODE_TYPE wchar_t
	95	# endif
	96
	97	# if defined(Py_UNICODE_WIDE)
	98	# define PY_UNICODE_TYPE Py_UCS4
	99	# endif
	100
	101	#endif
	102
	103	/* If the compiler provides a wchar_t type we try to support it
	104	through the interface functions PyUnicode_FromWideChar() and
	105	PyUnicode_AsWideChar(). */
	106
	107	#ifdef HAVE_USABLE_WCHAR_T
	108	# ifndef HAVE_WCHAR_H
	109	# define HAVE_WCHAR_H
	110	# endif
	111	#endif
	112
	113	#ifdef HAVE_WCHAR_H
	114	/* Work around a cosmetic bug in BSDI 4.x wchar.h; thanks to Thomas Wouters */
	115	# ifdef _HAVE_BSDI
	116	# include <time.h>
	117	# endif
	118	# include <wchar.h>
	119	#endif
	120
	121	/*
	122	* Use this typedef when you need to represent a UTF-16 surrogate pair
	123	* as single unsigned integer.
	124	*/
	125	#if SIZEOF_INT >= 4
	126	typedef unsigned int Py_UCS4;
	127	#elif SIZEOF_LONG >= 4
	128	typedef unsigned long Py_UCS4;
	129	#endif
	130
	131	typedef PY_UNICODE_TYPE Py_UNICODE;
	132
	133	/* --- UCS-2/UCS-4 Name Mangling ------------------------------------------ */
	134
	135	/* Unicode API names are mangled to assure that UCS-2 and UCS-4 builds
	136	produce different external names and thus cause import errors in
	137	case Python interpreters and extensions with mixed compiled in
	138	Unicode width assumptions are combined. */
	139
	140	#ifndef Py_UNICODE_WIDE
	141
	142	# define PyUnicode_AsASCIIString PyUnicodeUCS2_AsASCIIString
	143	# define PyUnicode_AsCharmapString PyUnicodeUCS2_AsCharmapString
	144	# define PyUnicode_AsEncodedObject PyUnicodeUCS2_AsEncodedObject
	145	# define PyUnicode_AsEncodedString PyUnicodeUCS2_AsEncodedString
	146	# define PyUnicode_AsLatin1String PyUnicodeUCS2_AsLatin1String
	147	# define PyUnicode_AsRawUnicodeEscapeString PyUnicodeUCS2_AsRawUnicodeEscapeString
	148	# define PyUnicode_AsUTF16String PyUnicodeUCS2_AsUTF16String
	149	# define PyUnicode_AsUTF8String PyUnicodeUCS2_AsUTF8String
	150	# define PyUnicode_AsUnicode PyUnicodeUCS2_AsUnicode
	151	# define PyUnicode_AsUnicodeEscapeString PyUnicodeUCS2_AsUnicodeEscapeString
	152	# define PyUnicode_AsWideChar PyUnicodeUCS2_AsWideChar
	153	# define PyUnicode_Compare PyUnicodeUCS2_Compare
	154	# define PyUnicode_Concat PyUnicodeUCS2_Concat
	155	# define PyUnicode_Contains PyUnicodeUCS2_Contains
	156	# define PyUnicode_Count PyUnicodeUCS2_Count
	157	# define PyUnicode_Decode PyUnicodeUCS2_Decode
	158	# define PyUnicode_DecodeASCII PyUnicodeUCS2_DecodeASCII
	159	# define PyUnicode_DecodeCharmap PyUnicodeUCS2_DecodeCharmap
	160	# define PyUnicode_DecodeLatin1 PyUnicodeUCS2_DecodeLatin1
	161	# define PyUnicode_DecodeRawUnicodeEscape PyUnicodeUCS2_DecodeRawUnicodeEscape
	162	# define PyUnicode_DecodeUTF16 PyUnicodeUCS2_DecodeUTF16
	163	# define PyUnicode_DecodeUTF16Stateful PyUnicodeUCS2_DecodeUTF16Stateful
	164	# define PyUnicode_DecodeUTF8 PyUnicodeUCS2_DecodeUTF8
	165	# define PyUnicode_DecodeUTF8Stateful PyUnicodeUCS2_DecodeUTF8Stateful
	166	# define PyUnicode_DecodeUnicodeEscape PyUnicodeUCS2_DecodeUnicodeEscape
	167	# define PyUnicode_Encode PyUnicodeUCS2_Encode
	168	# define PyUnicode_EncodeASCII PyUnicodeUCS2_EncodeASCII
	169	# define PyUnicode_EncodeCharmap PyUnicodeUCS2_EncodeCharmap
	170	# define PyUnicode_EncodeDecimal PyUnicodeUCS2_EncodeDecimal
	171	# define PyUnicode_EncodeLatin1 PyUnicodeUCS2_EncodeLatin1
	172	# define PyUnicode_EncodeRawUnicodeEscape PyUnicodeUCS2_EncodeRawUnicodeEscape
	173	# define PyUnicode_EncodeUTF16 PyUnicodeUCS2_EncodeUTF16
	174	# define PyUnicode_EncodeUTF8 PyUnicodeUCS2_EncodeUTF8
	175	# define PyUnicode_EncodeUnicodeEscape PyUnicodeUCS2_EncodeUnicodeEscape
	176	# define PyUnicode_Find PyUnicodeUCS2_Find
	177	# define PyUnicode_Format PyUnicodeUCS2_Format
	178	# define PyUnicode_FromEncodedObject PyUnicodeUCS2_FromEncodedObject
	179	# define PyUnicode_FromObject PyUnicodeUCS2_FromObject
	180	# define PyUnicode_FromOrdinal PyUnicodeUCS2_FromOrdinal
	181	# define PyUnicode_FromUnicode PyUnicodeUCS2_FromUnicode
	182	# define PyUnicode_FromWideChar PyUnicodeUCS2_FromWideChar
	183	# define PyUnicode_GetDefaultEncoding PyUnicodeUCS2_GetDefaultEncoding
	184	# define PyUnicode_GetMax PyUnicodeUCS2_GetMax
	185	# define PyUnicode_GetSize PyUnicodeUCS2_GetSize
	186	# define PyUnicode_Join PyUnicodeUCS2_Join
	187	# define PyUnicode_Partition PyUnicodeUCS2_Partition
	188	# define PyUnicode_RPartition PyUnicodeUCS2_RPartition
	189	# define PyUnicode_RSplit PyUnicodeUCS2_RSplit
	190	# define PyUnicode_Replace PyUnicodeUCS2_Replace
	191	# define PyUnicode_Resize PyUnicodeUCS2_Resize
	192	# define PyUnicode_RichCompare PyUnicodeUCS2_RichCompare
	193	# define PyUnicode_SetDefaultEncoding PyUnicodeUCS2_SetDefaultEncoding
	194	# define PyUnicode_Split PyUnicodeUCS2_Split
	195	# define PyUnicode_Splitlines PyUnicodeUCS2_Splitlines
	196	# define PyUnicode_Tailmatch PyUnicodeUCS2_Tailmatch
	197	# define PyUnicode_Translate PyUnicodeUCS2_Translate
	198	# define PyUnicode_TranslateCharmap PyUnicodeUCS2_TranslateCharmap
	199	# define _PyUnicode_AsDefaultEncodedString _PyUnicodeUCS2_AsDefaultEncodedString
	200	# define _PyUnicode_Fini _PyUnicodeUCS2_Fini
	201	# define _PyUnicode_Init _PyUnicodeUCS2_Init
	202	# define _PyUnicode_IsAlpha _PyUnicodeUCS2_IsAlpha
	203	# define _PyUnicode_IsDecimalDigit _PyUnicodeUCS2_IsDecimalDigit
	204	# define _PyUnicode_IsDigit _PyUnicodeUCS2_IsDigit
	205	# define _PyUnicode_IsLinebreak _PyUnicodeUCS2_IsLinebreak
	206	# define _PyUnicode_IsLowercase _PyUnicodeUCS2_IsLowercase
	207	# define _PyUnicode_IsNumeric _PyUnicodeUCS2_IsNumeric
	208	# define _PyUnicode_IsTitlecase _PyUnicodeUCS2_IsTitlecase
	209	# define _PyUnicode_IsUppercase _PyUnicodeUCS2_IsUppercase
	210	# define _PyUnicode_IsWhitespace _PyUnicodeUCS2_IsWhitespace
	211	# define _PyUnicode_ToDecimalDigit _PyUnicodeUCS2_ToDecimalDigit
	212	# define _PyUnicode_ToDigit _PyUnicodeUCS2_ToDigit
	213	# define _PyUnicode_ToLowercase _PyUnicodeUCS2_ToLowercase
	214	# define _PyUnicode_ToNumeric _PyUnicodeUCS2_ToNumeric
	215	# define _PyUnicode_ToTitlecase _PyUnicodeUCS2_ToTitlecase
	216	# define _PyUnicode_ToUppercase _PyUnicodeUCS2_ToUppercase
	217
	218	#else
	219
	220	# define PyUnicode_AsASCIIString PyUnicodeUCS4_AsASCIIString
	221	# define PyUnicode_AsCharmapString PyUnicodeUCS4_AsCharmapString
	222	# define PyUnicode_AsEncodedObject PyUnicodeUCS4_AsEncodedObject
	223	# define PyUnicode_AsEncodedString PyUnicodeUCS4_AsEncodedString
	224	# define PyUnicode_AsLatin1String PyUnicodeUCS4_AsLatin1String
	225	# define PyUnicode_AsRawUnicodeEscapeString PyUnicodeUCS4_AsRawUnicodeEscapeString
	226	# define PyUnicode_AsUTF16String PyUnicodeUCS4_AsUTF16String
	227	# define PyUnicode_AsUTF8String PyUnicodeUCS4_AsUTF8String
	228	# define PyUnicode_AsUnicode PyUnicodeUCS4_AsUnicode
	229	# define PyUnicode_AsUnicodeEscapeString PyUnicodeUCS4_AsUnicodeEscapeString
	230	# define PyUnicode_AsWideChar PyUnicodeUCS4_AsWideChar
	231	# define PyUnicode_Compare PyUnicodeUCS4_Compare
	232	# define PyUnicode_Concat PyUnicodeUCS4_Concat
	233	# define PyUnicode_Contains PyUnicodeUCS4_Contains
	234	# define PyUnicode_Count PyUnicodeUCS4_Count
	235	# define PyUnicode_Decode PyUnicodeUCS4_Decode
	236	# define PyUnicode_DecodeASCII PyUnicodeUCS4_DecodeASCII
	237	# define PyUnicode_DecodeCharmap PyUnicodeUCS4_DecodeCharmap
	238	# define PyUnicode_DecodeLatin1 PyUnicodeUCS4_DecodeLatin1
	239	# define PyUnicode_DecodeRawUnicodeEscape PyUnicodeUCS4_DecodeRawUnicodeEscape
	240	# define PyUnicode_DecodeUTF16 PyUnicodeUCS4_DecodeUTF16
	241	# define PyUnicode_DecodeUTF16Stateful PyUnicodeUCS4_DecodeUTF16Stateful
	242	# define PyUnicode_DecodeUTF8 PyUnicodeUCS4_DecodeUTF8
	243	# define PyUnicode_DecodeUTF8Stateful PyUnicodeUCS4_DecodeUTF8Stateful
	244	# define PyUnicode_DecodeUnicodeEscape PyUnicodeUCS4_DecodeUnicodeEscape
	245	# define PyUnicode_Encode PyUnicodeUCS4_Encode
	246	# define PyUnicode_EncodeASCII PyUnicodeUCS4_EncodeASCII
	247	# define PyUnicode_EncodeCharmap PyUnicodeUCS4_EncodeCharmap
	248	# define PyUnicode_EncodeDecimal PyUnicodeUCS4_EncodeDecimal
	249	# define PyUnicode_EncodeLatin1 PyUnicodeUCS4_EncodeLatin1
	250	# define PyUnicode_EncodeRawUnicodeEscape PyUnicodeUCS4_EncodeRawUnicodeEscape
	251	# define PyUnicode_EncodeUTF16 PyUnicodeUCS4_EncodeUTF16
	252	# define PyUnicode_EncodeUTF8 PyUnicodeUCS4_EncodeUTF8
	253	# define PyUnicode_EncodeUnicodeEscape PyUnicodeUCS4_EncodeUnicodeEscape
	254	# define PyUnicode_Find PyUnicodeUCS4_Find
	255	# define PyUnicode_Format PyUnicodeUCS4_Format
	256	# define PyUnicode_FromEncodedObject PyUnicodeUCS4_FromEncodedObject
	257	# define PyUnicode_FromObject PyUnicodeUCS4_FromObject
	258	# define PyUnicode_FromOrdinal PyUnicodeUCS4_FromOrdinal
	259	# define PyUnicode_FromUnicode PyUnicodeUCS4_FromUnicode
	260	# define PyUnicode_FromWideChar PyUnicodeUCS4_FromWideChar
	261	# define PyUnicode_GetDefaultEncoding PyUnicodeUCS4_GetDefaultEncoding
	262	# define PyUnicode_GetMax PyUnicodeUCS4_GetMax
	263	# define PyUnicode_GetSize PyUnicodeUCS4_GetSize
	264	# define PyUnicode_Join PyUnicodeUCS4_Join
	265	# define PyUnicode_Partition PyUnicodeUCS4_Partition
	266	# define PyUnicode_RPartition PyUnicodeUCS4_RPartition
	267	# define PyUnicode_RSplit PyUnicodeUCS4_RSplit
	268	# define PyUnicode_Replace PyUnicodeUCS4_Replace
	269	# define PyUnicode_Resize PyUnicodeUCS4_Resize
	270	# define PyUnicode_RichCompare PyUnicodeUCS4_RichCompare
	271	# define PyUnicode_SetDefaultEncoding PyUnicodeUCS4_SetDefaultEncoding
	272	# define PyUnicode_Split PyUnicodeUCS4_Split
	273	# define PyUnicode_Splitlines PyUnicodeUCS4_Splitlines
	274	# define PyUnicode_Tailmatch PyUnicodeUCS4_Tailmatch
	275	# define PyUnicode_Translate PyUnicodeUCS4_Translate
	276	# define PyUnicode_TranslateCharmap PyUnicodeUCS4_TranslateCharmap
	277	# define _PyUnicode_AsDefaultEncodedString _PyUnicodeUCS4_AsDefaultEncodedString
	278	# define _PyUnicode_Fini _PyUnicodeUCS4_Fini
	279	# define _PyUnicode_Init _PyUnicodeUCS4_Init
	280	# define _PyUnicode_IsAlpha _PyUnicodeUCS4_IsAlpha
	281	# define _PyUnicode_IsDecimalDigit _PyUnicodeUCS4_IsDecimalDigit
	282	# define _PyUnicode_IsDigit _PyUnicodeUCS4_IsDigit
	283	# define _PyUnicode_IsLinebreak _PyUnicodeUCS4_IsLinebreak
	284	# define _PyUnicode_IsLowercase _PyUnicodeUCS4_IsLowercase
	285	# define _PyUnicode_IsNumeric _PyUnicodeUCS4_IsNumeric
	286	# define _PyUnicode_IsTitlecase _PyUnicodeUCS4_IsTitlecase
	287	# define _PyUnicode_IsUppercase _PyUnicodeUCS4_IsUppercase
	288	# define _PyUnicode_IsWhitespace _PyUnicodeUCS4_IsWhitespace
	289	# define _PyUnicode_ToDecimalDigit _PyUnicodeUCS4_ToDecimalDigit
	290	# define _PyUnicode_ToDigit _PyUnicodeUCS4_ToDigit
	291	# define _PyUnicode_ToLowercase _PyUnicodeUCS4_ToLowercase
	292	# define _PyUnicode_ToNumeric _PyUnicodeUCS4_ToNumeric
	293	# define _PyUnicode_ToTitlecase _PyUnicodeUCS4_ToTitlecase
	294	# define _PyUnicode_ToUppercase _PyUnicodeUCS4_ToUppercase
	295
	296
	297	#endif
	298
	299	/* --- Internal Unicode Operations ---------------------------------------- */
	300
	301	/* If you want Python to use the compiler's wctype.h functions instead
	302	of the ones supplied with Python, define WANT_WCTYPE_FUNCTIONS or
	303	configure Python using --with-wctype-functions. This reduces the
	304	interpreter's code size. */
	305
	306	#if defined(HAVE_USABLE_WCHAR_T) && defined(WANT_WCTYPE_FUNCTIONS)
	307
	308	#include <wctype.h>
	309
	310	#define Py_UNICODE_ISSPACE(ch) iswspace(ch)
	311
	312	#define Py_UNICODE_ISLOWER(ch) iswlower(ch)
	313	#define Py_UNICODE_ISUPPER(ch) iswupper(ch)
	314	#define Py_UNICODE_ISTITLE(ch) _PyUnicode_IsTitlecase(ch)
	315	#define Py_UNICODE_ISLINEBREAK(ch) _PyUnicode_IsLinebreak(ch)
	316
	317	#define Py_UNICODE_TOLOWER(ch) towlower(ch)
	318	#define Py_UNICODE_TOUPPER(ch) towupper(ch)
	319	#define Py_UNICODE_TOTITLE(ch) _PyUnicode_ToTitlecase(ch)
	320
	321	#define Py_UNICODE_ISDECIMAL(ch) _PyUnicode_IsDecimalDigit(ch)
	322	#define Py_UNICODE_ISDIGIT(ch) _PyUnicode_IsDigit(ch)
	323	#define Py_UNICODE_ISNUMERIC(ch) _PyUnicode_IsNumeric(ch)
	324
	325	#define Py_UNICODE_TODECIMAL(ch) _PyUnicode_ToDecimalDigit(ch)
	326	#define Py_UNICODE_TODIGIT(ch) _PyUnicode_ToDigit(ch)
	327	#define Py_UNICODE_TONUMERIC(ch) _PyUnicode_ToNumeric(ch)
	328
	329	#define Py_UNICODE_ISALPHA(ch) iswalpha(ch)
	330
	331	#else
	332
	333	#define Py_UNICODE_ISSPACE(ch) _PyUnicode_IsWhitespace(ch)
	334
	335	#define Py_UNICODE_ISLOWER(ch) _PyUnicode_IsLowercase(ch)
	336	#define Py_UNICODE_ISUPPER(ch) _PyUnicode_IsUppercase(ch)
	337	#define Py_UNICODE_ISTITLE(ch) _PyUnicode_IsTitlecase(ch)
	338	#define Py_UNICODE_ISLINEBREAK(ch) _PyUnicode_IsLinebreak(ch)
	339
	340	#define Py_UNICODE_TOLOWER(ch) _PyUnicode_ToLowercase(ch)
	341	#define Py_UNICODE_TOUPPER(ch) _PyUnicode_ToUppercase(ch)
	342	#define Py_UNICODE_TOTITLE(ch) _PyUnicode_ToTitlecase(ch)
	343
	344	#define Py_UNICODE_ISDECIMAL(ch) _PyUnicode_IsDecimalDigit(ch)
	345	#define Py_UNICODE_ISDIGIT(ch) _PyUnicode_IsDigit(ch)
	346	#define Py_UNICODE_ISNUMERIC(ch) _PyUnicode_IsNumeric(ch)
	347
	348	#define Py_UNICODE_TODECIMAL(ch) _PyUnicode_ToDecimalDigit(ch)
	349	#define Py_UNICODE_TODIGIT(ch) _PyUnicode_ToDigit(ch)
	350	#define Py_UNICODE_TONUMERIC(ch) _PyUnicode_ToNumeric(ch)
	351
	352	#define Py_UNICODE_ISALPHA(ch) _PyUnicode_IsAlpha(ch)
	353
	354	#endif
	355
	356	#define Py_UNICODE_ISALNUM(ch) \
	357	(Py_UNICODE_ISALPHA(ch) \|\| \
	358	Py_UNICODE_ISDECIMAL(ch) \|\| \
	359	Py_UNICODE_ISDIGIT(ch) \|\| \
	360	Py_UNICODE_ISNUMERIC(ch))
	361
	362	#define Py_UNICODE_COPY(target, source, length) \
	363	Py_MEMCPY((target), (source), (length)*sizeof(Py_UNICODE))
	364
	365	#define Py_UNICODE_FILL(target, value, length) do\
	366	{Py_ssize_t i_; Py_UNICODE *t_ = (target); Py_UNICODE v_ = (value);\
	367	for (i_ = 0; i_ < (length); i_++) t_[i_] = v_;\
	368	} while (0)
	369
	370	/* check if substring matches at given offset. the offset must be
	371	valid, and the substring must not be empty */
	372	#define Py_UNICODE_MATCH(string, offset, substring) \
	373	((((string)->str + (offset)) == ((substring)->str)) && \
	374	((((string)->str + (offset) + (substring)->length-1) == ((substring)->str + (substring)->length-1))) && \
	375	!memcmp((string)->str + (offset), (substring)->str, (substring)->length*sizeof(Py_UNICODE)))
	376
	377	#ifdef __cplusplus
	378	extern "C" {
	379	#endif
	380
	381	/* --- Unicode Type ------------------------------------------------------- */
	382
	383	typedef struct {
	384	PyObject_HEAD
	385	Py_ssize_t length; /* Length of raw Unicode data in buffer */
	386	Py_UNICODE str; / Raw Unicode buffer */
	387	long hash; /* Hash value; -1 if not set */
	388	PyObject defenc; / (Default) Encoded version as Python
	389	string, or NULL; this is used for
	390	implementing the buffer protocol */
	391	} PyUnicodeObject;
	392
	393	PyAPI_DATA(PyTypeObject) PyUnicode_Type;
	394
	395	#define PyUnicode_Check(op) PyObject_TypeCheck(op, &PyUnicode_Type)
	396	#define PyUnicode_CheckExact(op) ((op)->ob_type == &PyUnicode_Type)
	397
	398	/* Fast access macros */
	399	#define PyUnicode_GET_SIZE(op) \
	400	(((PyUnicodeObject *)(op))->length)
	401	#define PyUnicode_GET_DATA_SIZE(op) \
	402	(((PyUnicodeObject )(op))->length sizeof(Py_UNICODE))
	403	#define PyUnicode_AS_UNICODE(op) \
	404	(((PyUnicodeObject *)(op))->str)
	405	#define PyUnicode_AS_DATA(op) \
	406	((const char )((PyUnicodeObject )(op))->str)
	407
	408	/* --- Constants ---------------------------------------------------------- */
	409
	410	/* This Unicode character will be used as replacement character during
	411	decoding if the errors argument is set to "replace". Note: the
	412	Unicode character U+FFFD is the official REPLACEMENT CHARACTER in
	413	Unicode 3.0. */
	414
	415	#define Py_UNICODE_REPLACEMENT_CHARACTER ((Py_UNICODE) 0xFFFD)
	416
	417	/* === Public API ========================================================= */
	418
	419	/* --- Plain Py_UNICODE --------------------------------------------------- */
	420
	421	/* Create a Unicode Object from the Py_UNICODE buffer u of the given
	422	size.
	423
	424	u may be NULL which causes the contents to be undefined. It is the
	425	user's responsibility to fill in the needed data afterwards. Note
	426	that modifying the Unicode object contents after construction is
	427	only allowed if u was set to NULL.
	428
	429	The buffer is copied into the new object. */
	430
	431	PyAPI_FUNC(PyObject*) PyUnicode_FromUnicode(
	432	const Py_UNICODE u, / Unicode buffer */
	433	Py_ssize_t size /* size of buffer */
	434	);
	435
	436	/* Return a read-only pointer to the Unicode object's internal
	437	Py_UNICODE buffer. */
	438
	439	PyAPI_FUNC(Py_UNICODE *) PyUnicode_AsUnicode(
	440	PyObject unicode / Unicode object */
	441	);
	442
	443	/* Get the length of the Unicode object. */
	444
	445	PyAPI_FUNC(Py_ssize_t) PyUnicode_GetSize(
	446	PyObject unicode / Unicode object */
	447	);
	448
	449	/* Get the maximum ordinal for a Unicode character. */
	450	PyAPI_FUNC(Py_UNICODE) PyUnicode_GetMax(void);
	451
	452	/* Resize an already allocated Unicode object to the new size length.
	453
	454	*unicode is modified to point to the new (resized) object and 0
	455	returned on success.
	456
	457	This API may only be called by the function which also called the
	458	Unicode constructor. The refcount on the object must be 1. Otherwise,
	459	an error is returned.
	460
	461	Error handling is implemented as follows: an exception is set, -1
	462	is returned and *unicode left untouched.
	463
	464	*/
	465
	466	PyAPI_FUNC(int) PyUnicode_Resize(
	467	PyObject *unicode, / Pointer to the Unicode object */
	468	Py_ssize_t length /* New length */
	469	);
	470
	471	/* Coerce obj to an Unicode object and return a reference with
	472	incremented refcount.
	473
	474	Coercion is done in the following way:
	475
	476	1. String and other char buffer compatible objects are decoded
	477	under the assumptions that they contain data using the current
	478	default encoding. Decoding is done in "strict" mode.
	479
	480	2. All other objects (including Unicode objects) raise an
	481	exception.
	482
	483	The API returns NULL in case of an error. The caller is responsible
	484	for decref'ing the returned objects.
	485
	486	*/
	487
	488	PyAPI_FUNC(PyObject*) PyUnicode_FromEncodedObject(
	489	register PyObject obj, / Object */
	490	const char encoding, / encoding */
	491	const char errors / error handling */
	492	);
	493
	494	/* Coerce obj to an Unicode object and return a reference with
	495	incremented refcount.
	496
	497	Unicode objects are passed back as-is (subclasses are converted to
	498	true Unicode objects), all other objects are delegated to
	499	PyUnicode_FromEncodedObject(obj, NULL, "strict") which results in
	500	using the default encoding as basis for decoding the object.
	501
	502	The API returns NULL in case of an error. The caller is responsible
	503	for decref'ing the returned objects.
	504
	505	*/
	506
	507	PyAPI_FUNC(PyObject*) PyUnicode_FromObject(
	508	register PyObject obj / Object */
	509	);
	510
	511	/* --- wchar_t support for platforms which support it --------------------- */
	512
	513	#ifdef HAVE_WCHAR_H
	514
	515	/* Create a Unicode Object from the whcar_t buffer w of the given
	516	size.
	517
	518	The buffer is copied into the new object. */
	519
	520	PyAPI_FUNC(PyObject*) PyUnicode_FromWideChar(
	521	register const wchar_t w, / wchar_t buffer */
	522	Py_ssize_t size /* size of buffer */
	523	);
	524
	525	/* Copies the Unicode Object contents into the wchar_t buffer w. At
	526	most size wchar_t characters are copied.
	527
	528	Note that the resulting wchar_t string may or may not be
	529	0-terminated. It is the responsibility of the caller to make sure
	530	that the wchar_t string is 0-terminated in case this is required by
	531	the application.
	532
	533	Returns the number of wchar_t characters copied (excluding a
	534	possibly trailing 0-termination character) or -1 in case of an
	535	error. */
	536
	537	PyAPI_FUNC(Py_ssize_t) PyUnicode_AsWideChar(
	538	PyUnicodeObject unicode, / Unicode object */
	539	register wchar_t w, / wchar_t buffer */
	540	Py_ssize_t size /* size of buffer */
	541	);
	542
	543	#endif
	544
	545	/* --- Unicode ordinals --------------------------------------------------- */
	546
	547	/* Create a Unicode Object from the given Unicode code point ordinal.
	548
	549	The ordinal must be in range(0x10000) on narrow Python builds
	550	(UCS2), and range(0x110000) on wide builds (UCS4). A ValueError is
	551	raised in case it is not.
	552
	553	*/
	554
	555	PyAPI_FUNC(PyObject*) PyUnicode_FromOrdinal(int ordinal);
	556
	557	/* === Builtin Codecs =====================================================
	558
	559	Many of these APIs take two arguments encoding and errors. These
	560	parameters encoding and errors have the same semantics as the ones
	561	of the builtin unicode() API.
	562
	563	Setting encoding to NULL causes the default encoding to be used.
	564
	565	Error handling is set by errors which may also be set to NULL
	566	meaning to use the default handling defined for the codec. Default
	567	error handling for all builtin codecs is "strict" (ValueErrors are
	568	raised).
	569
	570	The codecs all use a similar interface. Only deviation from the
	571	generic ones are documented.
	572
	573	*/
	574
	575	/* --- Manage the default encoding ---------------------------------------- */
	576
	577	/* Return a Python string holding the default encoded value of the
	578	Unicode object.
	579
	580	The resulting string is cached in the Unicode object for subsequent
	581	usage by this function. The cached version is needed to implement
	582	the character buffer interface and will live (at least) as long as
	583	the Unicode object itself.
	584
	585	The refcount of the string is not incremented.
	586
	587	* Exported for internal use by the interpreter only !!! *
	588
	589	*/
	590
	591	PyAPI_FUNC(PyObject *) _PyUnicode_AsDefaultEncodedString(
	592	PyObject , const char );
	593
	594	/* Returns the currently active default encoding.
	595
	596	The default encoding is currently implemented as run-time settable
	597	process global. This may change in future versions of the
	598	interpreter to become a parameter which is managed on a per-thread
	599	basis.
	600
	601	*/
	602
	603	PyAPI_FUNC(const char*) PyUnicode_GetDefaultEncoding(void);
	604
	605	/* Sets the currently active default encoding.
	606
	607	Returns 0 on success, -1 in case of an error.
	608
	609	*/
	610
	611	PyAPI_FUNC(int) PyUnicode_SetDefaultEncoding(
	612	const char encoding / Encoding name in standard form */
	613	);
	614
	615	/* --- Generic Codecs ----------------------------------------------------- */
	616
	617	/* Create a Unicode object by decoding the encoded string s of the
	618	given size. */
	619
	620	PyAPI_FUNC(PyObject*) PyUnicode_Decode(
	621	const char s, / encoded string */
	622	Py_ssize_t size, /* size of buffer */
	623	const char encoding, / encoding */
	624	const char errors / error handling */
	625	);
	626
	627	/* Encodes a Py_UNICODE buffer of the given size and returns a
	628	Python string object. */
	629
	630	PyAPI_FUNC(PyObject*) PyUnicode_Encode(
	631	const Py_UNICODE s, / Unicode char buffer */
	632	Py_ssize_t size, /* number of Py_UNICODE chars to encode */
	633	const char encoding, / encoding */
	634	const char errors / error handling */
	635	);
	636
	637	/* Encodes a Unicode object and returns the result as Python
	638	object. */
	639
	640	PyAPI_FUNC(PyObject*) PyUnicode_AsEncodedObject(
	641	PyObject unicode, / Unicode object */
	642	const char encoding, / encoding */
	643	const char errors / error handling */
	644	);
	645
	646	/* Encodes a Unicode object and returns the result as Python string
	647	object. */
	648
	649	PyAPI_FUNC(PyObject*) PyUnicode_AsEncodedString(
	650	PyObject unicode, / Unicode object */
	651	const char encoding, / encoding */
	652	const char errors / error handling */
	653	);
	654
	655	PyAPI_FUNC(PyObject*) PyUnicode_BuildEncodingMap(
	656	PyObject* string /* 256 character map */
	657	);
	658
	659
	660	/* --- UTF-7 Codecs ------------------------------------------------------- */
	661
	662	PyAPI_FUNC(PyObject*) PyUnicode_DecodeUTF7(
	663	const char string, / UTF-7 encoded string */
	664	Py_ssize_t length, /* size of string */
	665	const char errors / error handling */
	666	);
	667
	668	PyAPI_FUNC(PyObject*) PyUnicode_EncodeUTF7(
	669	const Py_UNICODE data, / Unicode char buffer */
	670	Py_ssize_t length, /* number of Py_UNICODE chars to encode */
	671	int encodeSetO, /* force the encoder to encode characters in
	672	Set O, as described in RFC2152 */
	673	int encodeWhiteSpace, /* force the encoder to encode space, tab,
	674	carriage return and linefeed characters */
	675	const char errors / error handling */
	676	);
	677
	678	/* --- UTF-8 Codecs ------------------------------------------------------- */
	679
	680	PyAPI_FUNC(PyObject*) PyUnicode_DecodeUTF8(
	681	const char string, / UTF-8 encoded string */
	682	Py_ssize_t length, /* size of string */
	683	const char errors / error handling */
	684	);
	685
	686	PyAPI_FUNC(PyObject*) PyUnicode_DecodeUTF8Stateful(
	687	const char string, / UTF-8 encoded string */
	688	Py_ssize_t length, /* size of string */
	689	const char errors, / error handling */
	690	Py_ssize_t consumed / bytes consumed */
	691	);
	692
	693	PyAPI_FUNC(PyObject*) PyUnicode_AsUTF8String(
	694	PyObject unicode / Unicode object */
	695	);
	696
	697	PyAPI_FUNC(PyObject*) PyUnicode_EncodeUTF8(
	698	const Py_UNICODE data, / Unicode char buffer */
	699	Py_ssize_t length, /* number of Py_UNICODE chars to encode */
	700	const char errors / error handling */
	701	);
	702
	703	/* --- UTF-16 Codecs ------------------------------------------------------ */
	704
	705	/* Decodes length bytes from a UTF-16 encoded buffer string and returns
	706	the corresponding Unicode object.
	707
	708	errors (if non-NULL) defines the error handling. It defaults
	709	to "strict".
	710
	711	If byteorder is non-NULL, the decoder starts decoding using the
	712	given byte order:
	713
	714	*byteorder == -1: little endian
	715	*byteorder == 0: native order
	716	*byteorder == 1: big endian
	717
	718	In native mode, the first two bytes of the stream are checked for a
	719	BOM mark. If found, the BOM mark is analysed, the byte order
	720	adjusted and the BOM skipped. In the other modes, no BOM mark
	721	interpretation is done. After completion, *byteorder is set to the
	722	current byte order at the end of input data.
	723
	724	If byteorder is NULL, the codec starts in native order mode.
	725
	726	*/
	727
	728	PyAPI_FUNC(PyObject*) PyUnicode_DecodeUTF16(
	729	const char string, / UTF-16 encoded string */
	730	Py_ssize_t length, /* size of string */
	731	const char errors, / error handling */
	732	int byteorder / pointer to byteorder to use
	733	0=native;-1=LE,1=BE; updated on
	734	exit */
	735	);
	736
	737	PyAPI_FUNC(PyObject*) PyUnicode_DecodeUTF16Stateful(
	738	const char string, / UTF-16 encoded string */
	739	Py_ssize_t length, /* size of string */
	740	const char errors, / error handling */
	741	int byteorder, / pointer to byteorder to use
	742	0=native;-1=LE,1=BE; updated on
	743	exit */
	744	Py_ssize_t consumed / bytes consumed */
	745	);
	746
	747	/* Returns a Python string using the UTF-16 encoding in native byte
	748	order. The string always starts with a BOM mark. */
	749
	750	PyAPI_FUNC(PyObject*) PyUnicode_AsUTF16String(
	751	PyObject unicode / Unicode object */
	752	);
	753
	754	/* Returns a Python string object holding the UTF-16 encoded value of
	755	the Unicode data.
	756
	757	If byteorder is not 0, output is written according to the following
	758	byte order:
	759
	760	byteorder == -1: little endian
	761	byteorder == 0: native byte order (writes a BOM mark)
	762	byteorder == 1: big endian
	763
	764	If byteorder is 0, the output string will always start with the
	765	Unicode BOM mark (U+FEFF). In the other two modes, no BOM mark is
	766	prepended.
	767
	768	Note that Py_UNICODE data is being interpreted as UTF-16 reduced to
	769	UCS-2. This trick makes it possible to add full UTF-16 capabilities
	770	at a later point without compromising the APIs.
	771
	772	*/
	773
	774	PyAPI_FUNC(PyObject*) PyUnicode_EncodeUTF16(
	775	const Py_UNICODE data, / Unicode char buffer */
	776	Py_ssize_t length, /* number of Py_UNICODE chars to encode */
	777	const char errors, / error handling */
	778	int byteorder /* byteorder to use 0=BOM+native;-1=LE,1=BE */
	779	);
	780
	781	/* --- Unicode-Escape Codecs ---------------------------------------------- */
	782
	783	PyAPI_FUNC(PyObject*) PyUnicode_DecodeUnicodeEscape(
	784	const char string, / Unicode-Escape encoded string */
	785	Py_ssize_t length, /* size of string */
	786	const char errors / error handling */
	787	);
	788
	789	PyAPI_FUNC(PyObject*) PyUnicode_AsUnicodeEscapeString(
	790	PyObject unicode / Unicode object */
	791	);
	792
	793	PyAPI_FUNC(PyObject*) PyUnicode_EncodeUnicodeEscape(
	794	const Py_UNICODE data, / Unicode char buffer */
	795	Py_ssize_t length /* Number of Py_UNICODE chars to encode */
	796	);
	797
	798	/* --- Raw-Unicode-Escape Codecs ------------------------------------------ */
	799
	800	PyAPI_FUNC(PyObject*) PyUnicode_DecodeRawUnicodeEscape(
	801	const char string, / Raw-Unicode-Escape encoded string */
	802	Py_ssize_t length, /* size of string */
	803	const char errors / error handling */
	804	);
	805
	806	PyAPI_FUNC(PyObject*) PyUnicode_AsRawUnicodeEscapeString(
	807	PyObject unicode / Unicode object */
	808	);
	809
	810	PyAPI_FUNC(PyObject*) PyUnicode_EncodeRawUnicodeEscape(
	811	const Py_UNICODE data, / Unicode char buffer */
	812	Py_ssize_t length /* Number of Py_UNICODE chars to encode */
	813	);
	814
	815	/* --- Unicode Internal Codec ---------------------------------------------
	816
	817	Only for internal use in _codecsmodule.c */
	818
	819	PyObject *_PyUnicode_DecodeUnicodeInternal(
	820	const char *string,
	821	Py_ssize_t length,
	822	const char *errors
	823	);
	824
	825	/* --- Latin-1 Codecs -----------------------------------------------------
	826
	827	Note: Latin-1 corresponds to the first 256 Unicode ordinals.
	828
	829	*/
	830
	831	PyAPI_FUNC(PyObject*) PyUnicode_DecodeLatin1(
	832	const char string, / Latin-1 encoded string */
	833	Py_ssize_t length, /* size of string */
	834	const char errors / error handling */
	835	);
	836
	837	PyAPI_FUNC(PyObject*) PyUnicode_AsLatin1String(
	838	PyObject unicode / Unicode object */
	839	);
	840
	841	PyAPI_FUNC(PyObject*) PyUnicode_EncodeLatin1(
	842	const Py_UNICODE data, / Unicode char buffer */
	843	Py_ssize_t length, /* Number of Py_UNICODE chars to encode */
	844	const char errors / error handling */
	845	);
	846
	847	/* --- ASCII Codecs -------------------------------------------------------
	848
	849	Only 7-bit ASCII data is excepted. All other codes generate errors.
	850
	851	*/
	852
	853	PyAPI_FUNC(PyObject*) PyUnicode_DecodeASCII(
	854	const char string, / ASCII encoded string */
	855	Py_ssize_t length, /* size of string */
	856	const char errors / error handling */
	857	);
	858
	859	PyAPI_FUNC(PyObject*) PyUnicode_AsASCIIString(
	860	PyObject unicode / Unicode object */
	861	);
	862
	863	PyAPI_FUNC(PyObject*) PyUnicode_EncodeASCII(
	864	const Py_UNICODE data, / Unicode char buffer */
	865	Py_ssize_t length, /* Number of Py_UNICODE chars to encode */
	866	const char errors / error handling */
	867	);
	868
	869	/* --- Character Map Codecs -----------------------------------------------
	870
	871	This codec uses mappings to encode and decode characters.
	872
	873	Decoding mappings must map single string characters to single
	874	Unicode characters, integers (which are then interpreted as Unicode
	875	ordinals) or None (meaning "undefined mapping" and causing an
	876	error).
	877
	878	Encoding mappings must map single Unicode characters to single
	879	string characters, integers (which are then interpreted as Latin-1
	880	ordinals) or None (meaning "undefined mapping" and causing an
	881	error).
	882
	883	If a character lookup fails with a LookupError, the character is
	884	copied as-is meaning that its ordinal value will be interpreted as
	885	Unicode or Latin-1 ordinal resp. Because of this mappings only need
	886	to contain those mappings which map characters to different code
	887	points.
	888
	889	*/
	890
	891	PyAPI_FUNC(PyObject*) PyUnicode_DecodeCharmap(
	892	const char string, / Encoded string */
	893	Py_ssize_t length, /* size of string */
	894	PyObject mapping, / character mapping
	895	(char ordinal -> unicode ordinal) */
	896	const char errors / error handling */
	897	);
	898
	899	PyAPI_FUNC(PyObject*) PyUnicode_AsCharmapString(
	900	PyObject unicode, / Unicode object */
	901	PyObject mapping / character mapping
	902	(unicode ordinal -> char ordinal) */
	903	);
	904
	905	PyAPI_FUNC(PyObject*) PyUnicode_EncodeCharmap(
	906	const Py_UNICODE data, / Unicode char buffer */
	907	Py_ssize_t length, /* Number of Py_UNICODE chars to encode */
	908	PyObject mapping, / character mapping
	909	(unicode ordinal -> char ordinal) */
	910	const char errors / error handling */
	911	);
	912
	913	/* Translate a Py_UNICODE buffer of the given length by applying a
	914	character mapping table to it and return the resulting Unicode
	915	object.
	916
	917	The mapping table must map Unicode ordinal integers to Unicode
	918	ordinal integers or None (causing deletion of the character).
	919
	920	Mapping tables may be dictionaries or sequences. Unmapped character
	921	ordinals (ones which cause a LookupError) are left untouched and
	922	are copied as-is.
	923
	924	*/
	925
	926	PyAPI_FUNC(PyObject *) PyUnicode_TranslateCharmap(
	927	const Py_UNICODE data, / Unicode char buffer */
	928	Py_ssize_t length, /* Number of Py_UNICODE chars to encode */
	929	PyObject table, / Translate table */
	930	const char errors / error handling */
	931	);
	932
	933	#ifdef MS_WIN32
	934
	935	/* --- MBCS codecs for Windows -------------------------------------------- */
	936
	937	PyAPI_FUNC(PyObject*) PyUnicode_DecodeMBCS(
	938	const char string, / MBCS encoded string */
	939	Py_ssize_t length, /* size of string */
	940	const char errors / error handling */
	941	);
	942
	943	PyAPI_FUNC(PyObject*) PyUnicode_DecodeMBCSStateful(
	944	const char string, / MBCS encoded string */
	945	Py_ssize_t length, /* size of string */
	946	const char errors, / error handling */
	947	Py_ssize_t consumed / bytes consumed */
	948	);
	949
	950	PyAPI_FUNC(PyObject*) PyUnicode_AsMBCSString(
	951	PyObject unicode / Unicode object */
	952	);
	953
	954	PyAPI_FUNC(PyObject*) PyUnicode_EncodeMBCS(
	955	const Py_UNICODE data, / Unicode char buffer */
	956	Py_ssize_t length, /* Number of Py_UNICODE chars to encode */
	957	const char errors / error handling */
	958	);
	959
	960	#endif /* MS_WIN32 */
	961
	962	/* --- Decimal Encoder ---------------------------------------------------- */
	963
	964	/* Takes a Unicode string holding a decimal value and writes it into
	965	an output buffer using standard ASCII digit codes.
	966
	967	The output buffer has to provide at least length+1 bytes of storage
	968	area. The output string is 0-terminated.
	969
	970	The encoder converts whitespace to ' ', decimal characters to their
	971	corresponding ASCII digit and all other Latin-1 characters except
	972	\0 as-is. Characters outside this range (Unicode ordinals 1-256)
	973	are treated as errors. This includes embedded NULL bytes.
	974
	975	Error handling is defined by the errors argument:
	976
	977	NULL or "strict": raise a ValueError
	978	"ignore": ignore the wrong characters (these are not copied to the
	979	output buffer)
	980	"replace": replaces illegal characters with '?'
	981
	982	Returns 0 on success, -1 on failure.
	983
	984	*/
	985
	986	PyAPI_FUNC(int) PyUnicode_EncodeDecimal(
	987	Py_UNICODE s, / Unicode buffer */
	988	Py_ssize_t length, /* Number of Py_UNICODE chars to encode */
	989	char output, / Output buffer; must have size >= length */
	990	const char errors / error handling */
	991	);
	992
	993	/* --- Methods & Slots ----------------------------------------------------
	994
	995	These are capable of handling Unicode objects and strings on input
	996	(we refer to them as strings in the descriptions) and return
	997	Unicode objects or integers as apporpriate. */
	998
	999	/* Concat two strings giving a new Unicode string. */
	1000
	1001	PyAPI_FUNC(PyObject*) PyUnicode_Concat(
	1002	PyObject left, / Left string */
	1003	PyObject right / Right string */
	1004	);
	1005
	1006	/* Split a string giving a list of Unicode strings.
	1007
	1008	If sep is NULL, splitting will be done at all whitespace
	1009	substrings. Otherwise, splits occur at the given separator.
	1010
	1011	At most maxsplit splits will be done. If negative, no limit is set.
	1012
	1013	Separators are not included in the resulting list.
	1014
	1015	*/
	1016
	1017	PyAPI_FUNC(PyObject*) PyUnicode_Split(
	1018	PyObject s, / String to split */
	1019	PyObject sep, / String separator */
	1020	Py_ssize_t maxsplit /* Maxsplit count */
	1021	);
	1022
	1023	/* Dito, but split at line breaks.
	1024
	1025	CRLF is considered to be one line break. Line breaks are not
	1026	included in the resulting list. */
	1027
	1028	PyAPI_FUNC(PyObject*) PyUnicode_Splitlines(
	1029	PyObject s, / String to split */
	1030	int keepends /* If true, line end markers are included */
	1031	);
	1032
	1033	/* Partition a string using a given separator. */
	1034
	1035	PyAPI_FUNC(PyObject*) PyUnicode_Partition(
	1036	PyObject s, / String to partition */
	1037	PyObject sep / String separator */
	1038	);
	1039
	1040	/* Partition a string using a given separator, searching from the end of the
	1041	string. */
	1042
	1043	PyAPI_FUNC(PyObject*) PyUnicode_RPartition(
	1044	PyObject s, / String to partition */
	1045	PyObject sep / String separator */
	1046	);
	1047
	1048	/* Split a string giving a list of Unicode strings.
	1049
	1050	If sep is NULL, splitting will be done at all whitespace
	1051	substrings. Otherwise, splits occur at the given separator.
	1052
	1053	At most maxsplit splits will be done. But unlike PyUnicode_Split
	1054	PyUnicode_RSplit splits from the end of the string. If negative,
	1055	no limit is set.
	1056
	1057	Separators are not included in the resulting list.
	1058
	1059	*/
	1060
	1061	PyAPI_FUNC(PyObject*) PyUnicode_RSplit(
	1062	PyObject s, / String to split */
	1063	PyObject sep, / String separator */
	1064	Py_ssize_t maxsplit /* Maxsplit count */
	1065	);
	1066
	1067	/* Translate a string by applying a character mapping table to it and
	1068	return the resulting Unicode object.
	1069
	1070	The mapping table must map Unicode ordinal integers to Unicode
	1071	ordinal integers or None (causing deletion of the character).
	1072
	1073	Mapping tables may be dictionaries or sequences. Unmapped character
	1074	ordinals (ones which cause a LookupError) are left untouched and
	1075	are copied as-is.
	1076
	1077	*/
	1078
	1079	PyAPI_FUNC(PyObject *) PyUnicode_Translate(
	1080	PyObject str, / String */
	1081	PyObject table, / Translate table */
	1082	const char errors / error handling */
	1083	);
	1084
	1085	/* Join a sequence of strings using the given separator and return
	1086	the resulting Unicode string. */
	1087
	1088	PyAPI_FUNC(PyObject*) PyUnicode_Join(
	1089	PyObject separator, / Separator string */
	1090	PyObject seq / Sequence object */
	1091	);
	1092
	1093	/* Return 1 if substr matches str[start:end] at the given tail end, 0
	1094	otherwise. */
	1095
	1096	PyAPI_FUNC(Py_ssize_t) PyUnicode_Tailmatch(
	1097	PyObject str, / String */
	1098	PyObject substr, / Prefix or Suffix string */
	1099	Py_ssize_t start, /* Start index */
	1100	Py_ssize_t end, /* Stop index */
	1101	int direction /* Tail end: -1 prefix, +1 suffix */
	1102	);
	1103
	1104	/* Return the first position of substr in str[start:end] using the
	1105	given search direction or -1 if not found. -2 is returned in case
	1106	an error occurred and an exception is set. */
	1107
	1108	PyAPI_FUNC(Py_ssize_t) PyUnicode_Find(
	1109	PyObject str, / String */
	1110	PyObject substr, / Substring to find */
	1111	Py_ssize_t start, /* Start index */
	1112	Py_ssize_t end, /* Stop index */
	1113	int direction /* Find direction: +1 forward, -1 backward */
	1114	);
	1115
	1116	/* Count the number of occurrences of substr in str[start:end]. */
	1117
	1118	PyAPI_FUNC(Py_ssize_t) PyUnicode_Count(
	1119	PyObject str, / String */
	1120	PyObject substr, / Substring to count */
	1121	Py_ssize_t start, /* Start index */
	1122	Py_ssize_t end /* Stop index */
	1123	);
	1124
	1125	/* Replace at most maxcount occurrences of substr in str with replstr
	1126	and return the resulting Unicode object. */
	1127
	1128	PyAPI_FUNC(PyObject *) PyUnicode_Replace(
	1129	PyObject str, / String */
	1130	PyObject substr, / Substring to find */
	1131	PyObject replstr, / Substring to replace */
	1132	Py_ssize_t maxcount /* Max. number of replacements to apply;
	1133	-1 = all */
	1134	);
	1135
	1136	/* Compare two strings and return -1, 0, 1 for less than, equal,
	1137	greater than resp. */
	1138
	1139	PyAPI_FUNC(int) PyUnicode_Compare(
	1140	PyObject left, / Left string */
	1141	PyObject right / Right string */
	1142	);
	1143
	1144	/* Rich compare two strings and return one of the following:
	1145
	1146	- NULL in case an exception was raised
	1147	- Py_True or Py_False for successfuly comparisons
	1148	- Py_NotImplemented in case the type combination is unknown
	1149
	1150	Note that Py_EQ and Py_NE comparisons can cause a UnicodeWarning in
	1151	case the conversion of the arguments to Unicode fails with a
	1152	UnicodeDecodeError.
	1153
	1154	Possible values for op:
	1155
	1156	Py_GT, Py_GE, Py_EQ, Py_NE, Py_LT, Py_LE
	1157
	1158	*/
	1159
	1160	PyAPI_FUNC(PyObject *) PyUnicode_RichCompare(
	1161	PyObject left, / Left string */
	1162	PyObject right, / Right string */
	1163	int op /* Operation: Py_EQ, Py_NE, Py_GT, etc. */
	1164	);
	1165
	1166	/* Apply a argument tuple or dictionary to a format string and return
	1167	the resulting Unicode string. */
	1168
	1169	PyAPI_FUNC(PyObject *) PyUnicode_Format(
	1170	PyObject format, / Format string */
	1171	PyObject args / Argument tuple or dictionary */
	1172	);
	1173
	1174	/* Checks whether element is contained in container and return 1/0
	1175	accordingly.
	1176
	1177	element has to coerce to an one element Unicode string. -1 is
	1178	returned in case of an error. */
	1179
	1180	PyAPI_FUNC(int) PyUnicode_Contains(
	1181	PyObject container, / Container string */
	1182	PyObject element / Element string */
	1183	);
	1184
	1185	/* Externally visible for str.strip(unicode) */
	1186	PyAPI_FUNC(PyObject *) _PyUnicode_XStrip(
	1187	PyUnicodeObject *self,
	1188	int striptype,
	1189	PyObject *sepobj
	1190	);
	1191
	1192	/* === Characters Type APIs =============================================== */
	1193
	1194	/* These should not be used directly. Use the Py_UNICODE_IS* and
	1195	Py_UNICODE_TO* macros instead.
	1196
	1197	These APIs are implemented in Objects/unicodectype.c.
	1198
	1199	*/
	1200
	1201	PyAPI_FUNC(int) _PyUnicode_IsLowercase(
	1202	Py_UNICODE ch /* Unicode character */
	1203	);
	1204
	1205	PyAPI_FUNC(int) _PyUnicode_IsUppercase(
	1206	Py_UNICODE ch /* Unicode character */
	1207	);
	1208
	1209	PyAPI_FUNC(int) _PyUnicode_IsTitlecase(
	1210	Py_UNICODE ch /* Unicode character */
	1211	);
	1212
	1213	PyAPI_FUNC(int) _PyUnicode_IsWhitespace(
	1214	const Py_UNICODE ch /* Unicode character */
	1215	);
	1216
	1217	PyAPI_FUNC(int) _PyUnicode_IsLinebreak(
	1218	const Py_UNICODE ch /* Unicode character */
	1219	);
	1220
	1221	PyAPI_FUNC(Py_UNICODE) _PyUnicode_ToLowercase(
	1222	Py_UNICODE ch /* Unicode character */
	1223	);
	1224
	1225	PyAPI_FUNC(Py_UNICODE) _PyUnicode_ToUppercase(
	1226	Py_UNICODE ch /* Unicode character */
	1227	);
	1228
	1229	PyAPI_FUNC(Py_UNICODE) _PyUnicode_ToTitlecase(
	1230	Py_UNICODE ch /* Unicode character */
	1231	);
	1232
	1233	PyAPI_FUNC(int) _PyUnicode_ToDecimalDigit(
	1234	Py_UNICODE ch /* Unicode character */
	1235	);
	1236
	1237	PyAPI_FUNC(int) _PyUnicode_ToDigit(
	1238	Py_UNICODE ch /* Unicode character */
	1239	);
	1240
	1241	PyAPI_FUNC(double) _PyUnicode_ToNumeric(
	1242	Py_UNICODE ch /* Unicode character */
	1243	);
	1244
	1245	PyAPI_FUNC(int) _PyUnicode_IsDecimalDigit(
	1246	Py_UNICODE ch /* Unicode character */
	1247	);
	1248
	1249	PyAPI_FUNC(int) _PyUnicode_IsDigit(
	1250	Py_UNICODE ch /* Unicode character */
	1251	);
	1252
	1253	PyAPI_FUNC(int) _PyUnicode_IsNumeric(
	1254	Py_UNICODE ch /* Unicode character */
	1255	);
	1256
	1257	PyAPI_FUNC(int) _PyUnicode_IsAlpha(
	1258	Py_UNICODE ch /* Unicode character */
	1259	);
	1260
	1261	#ifdef __cplusplus
	1262	}
	1263	#endif
	1264	#endif /* Py_USING_UNICODE */
	1265	#endif /* !Py_UNICODEOBJECT_H */

sys/src/cmd/python/Include/weakrefobject.h+75−0

@@ -0,0 +1,75 @@
	1	/* Weak references objects for Python. */
	2
	3	#ifndef Py_WEAKREFOBJECT_H
	4	#define Py_WEAKREFOBJECT_H
	5	#ifdef __cplusplus
	6	extern "C" {
	7	#endif
	8
	9
	10	typedef struct _PyWeakReference PyWeakReference;
	11
	12	/* PyWeakReference is the base struct for the Python ReferenceType, ProxyType,
	13	* and CallableProxyType.
	14	*/
	15	struct _PyWeakReference {
	16	PyObject_HEAD
	17
	18	/* The object to which this is a weak reference, or Py_None if none.
	19	* Note that this is a stealth reference: wr_object's refcount is
	20	* not incremented to reflect this pointer.
	21	*/
	22	PyObject *wr_object;
	23
	24	/* A callable to invoke when wr_object dies, or NULL if none. */
	25	PyObject *wr_callback;
	26
	27	/* A cache for wr_object's hash code. As usual for hashes, this is -1
	28	* if the hash code isn't known yet.
	29	*/
	30	long hash;
	31
	32	/* If wr_object is weakly referenced, wr_object has a doubly-linked NULL-
	33	* terminated list of weak references to it. These are the list pointers.
	34	* If wr_object goes away, wr_object is set to Py_None, and these pointers
	35	* have no meaning then.
	36	*/
	37	PyWeakReference *wr_prev;
	38	PyWeakReference *wr_next;
	39	};
	40
	41	PyAPI_DATA(PyTypeObject) _PyWeakref_RefType;
	42	PyAPI_DATA(PyTypeObject) _PyWeakref_ProxyType;
	43	PyAPI_DATA(PyTypeObject) _PyWeakref_CallableProxyType;
	44
	45	#define PyWeakref_CheckRef(op) PyObject_TypeCheck(op, &_PyWeakref_RefType)
	46	#define PyWeakref_CheckRefExact(op) \
	47	((op)->ob_type == &_PyWeakref_RefType)
	48	#define PyWeakref_CheckProxy(op) \
	49	(((op)->ob_type == &_PyWeakref_ProxyType) \|\| \
	50	((op)->ob_type == &_PyWeakref_CallableProxyType))
	51
	52	/* This macro calls PyWeakref_CheckRef() last since that can involve a
	53	function call; this makes it more likely that the function call
	54	will be avoided. */
	55	#define PyWeakref_Check(op) \
	56	(PyWeakref_CheckRef(op) \|\| PyWeakref_CheckProxy(op))
	57
	58
	59	PyAPI_FUNC(PyObject ) PyWeakref_NewRef(PyObject ob,
	60	PyObject *callback);
	61	PyAPI_FUNC(PyObject ) PyWeakref_NewProxy(PyObject ob,
	62	PyObject *callback);
	63	PyAPI_FUNC(PyObject ) PyWeakref_GetObject(PyObject ref);
	64
	65	PyAPI_FUNC(Py_ssize_t) _PyWeakref_GetWeakrefCount(PyWeakReference *head);
	66
	67	PyAPI_FUNC(void) _PyWeakref_ClearRef(PyWeakReference *self);
	68
	69	#define PyWeakref_GET_OBJECT(ref) (((PyWeakReference *)(ref))->wr_object)
	70
	71
	72	#ifdef __cplusplus
	73	}
	74	#endif
	75	#endif /* !Py_WEAKREFOBJECT_H */