[pyke] / pyke.c

/* -*-c-*-
 *
 * Pyke: the Python Kit for Extensions
 *
 * (c) 2019 Straylight/Edgeware
 */

/*----- Licensing notice --------------------------------------------------*
 *
 * This file is part of Pyke: the Python Kit for Extensions.
 *
 * Pyke is free software: you can redistribute it and/or modify it under
 * the terms of the GNU General Public License as published by the Free
 * Software Foundation; either version 2 of the License, or (at your
 * option) any later version.
 *
 * Pyke is distributed in the hope that it will be useful, but WITHOUT
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
 * for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with Pyke.  If not, write to the Free Software Foundation, Inc.,
 * 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
 */

/*----- Header files ------------------------------------------------------*/

#include "pyke.h"

/*----- External variables ------------------------------------------------*/

PyObject *modname;
PyObject *home_module;

/*----- Conversions -------------------------------------------------------*/

PyObject *getulong(unsigned long w)
{
  if (w <= LONG_MAX) return (PyInt_FromLong(w));
  else return (PyLong_FromUnsignedLong(w));
}

PyObject *getbool(int b)
  { if (b) RETURN_TRUE; else RETURN_FALSE; }

int convulong(PyObject *o, void *pp)
{
  unsigned long *p = pp;
  PyObject *t;

  if (!o) VALERR("can't delete");
#ifdef PY2
  if (PyInt_Check(o)) {
    long i = PyInt_AS_LONG(o);
    if (i < 0) VALERR("must be nonnegative");
    *p = i;
  } else
#endif
  {
    if ((t = PyNumber_Long(o)) == 0) goto end;
    *p = PyLong_AsUnsignedLong(t);
    Py_DECREF(t);
    if (PyErr_Occurred()) goto end;
  }
  return (1);
end:
  return (0);
}

int convuint(PyObject *o, void *pp)
{
  unsigned long u;
  unsigned *p = pp;

  if (!convulong(o, &u)) goto end;
  if (u > UINT_MAX) VALERR("out of range");
  *p = u;
  return (1);
end:
  return (0);
}

int convszt(PyObject *o, void *pp)
{
  unsigned long u;
  size_t *p = pp;

  if (!convulong(o, &u)) goto end;
  if (u > ~(size_t)0) VALERR("out of range");
  *p = u;
  return (1);
end:
  return (0);
}

int convbool(PyObject *o, void *pp)
{
  if (!o) VALERR("can't delete");
  *(int *)pp = PyObject_IsTrue(o);
  return (1);
end:
  return (0);
}

int convbin(PyObject *o, void *pp)
{
  struct bin *r = pp;

  if (BIN_CHECK(o)) {
    r->p = BIN_PTR(o);
    r->sz = BIN_LEN(o);
    return (1);
  }
#ifdef PY2
  if (PyUnicode_Check(o)) {
    o = _PyUnicode_AsDefaultEncodedString(o, 0);
    if (!o) return (0);
    r->p = PyString_AS_STRING(o);
    r->sz = PyString_GET_SIZE(o);
    return (1);
  }
#endif
  return (PyObject_AsReadBuffer(o, &r->p, &r->sz) ? 0 : 1);
}

/*----- Miscellaneous utilities -------------------------------------------*/

PyObject *abstract_pynew(PyTypeObject *ty, PyObject *arg, PyObject *kw)
{
  PyErr_SetString(PyExc_TypeError, "can't instantiate this class");
  return (0);
}

PyObject *enrich_compare(int op, int cmp)
{
  int r = -1;

  switch (op) {
    case Py_LT: r = cmp <  0; break;
    case Py_LE: r = cmp <= 0; break;
    case Py_EQ: r = cmp == 0; break;
    case Py_NE: r = cmp != 0; break;
    case Py_GE: r = cmp >= 0; break;
    case Py_GT: r = cmp >  0; break;
    default: assert(0);
  }
  return (getbool(r));
}

/*----- Saving and restoring exceptions ----------------------------------*/

void report_lost_exception_v(struct excinfo *exc,
			     const char *why, va_list ap)
{
  PyObject *hookfn = 0;
  PyObject *whyobj = 0;
  PyObject *obj = 0;

  /* Make sure we start out without a pending exception, or this will get
   * really confusing.
   */
  assert(!PyErr_Occurred());

  /* Format the explanation. */
  if (why) whyobj = TEXT_VFORMAT(why, ap);
  else { whyobj = Py_None; Py_INCREF(whyobj); }

  /* Find our home module's `lostexchook' function.  This won't work if
   * there's no module, or the function isn't defined, or it's `None'.
   */
  if (!home_module) goto sys;
  hookfn = PyObject_GetAttrString(home_module, "lostexchook");
  if (hookfn == Py_None) goto sys;
  else if (hookfn) ;
  else if (!PyErr_ExceptionMatches(PyExc_AttributeError)) goto ouch;
  else { PyErr_Clear(); goto sys; }

  /* Call the hook function. */
  obj = PyObject_CallFunction(hookfn, "(OOOO)",
			      whyobj, exc->ty, exc->val, exc->tb);
  if (!obj) goto ouch;
  goto end;

  /* Something went wrong reporting the problem. */
ouch:
  PySys_WriteStderr("\n!!! FAILURE REPORTING LOST EXCEPTION\n");
  PyErr_Print();
  /* drop through... */

  /* There was no hook, so try to do something sensible using
   * `sys.excepthook'.
   */
sys:
  PySys_WriteStderr("\n!!! LOST EXCEPTION: %s\n", TEXT_PTR(whyobj));
  RESTORE_EXCINFO(exc);
  PyErr_Print();
  /* drop through... */

  /* Clean up afterwards. */
end:
  Py_XDECREF(hookfn);
  Py_XDECREF(whyobj);
  Py_XDECREF(obj);
}

void report_lost_exception(struct excinfo *exc, const char *why, ...)
{
  va_list ap;

  va_start(ap, why);
  report_lost_exception_v(exc, why, ap);
  va_end(ap);
}

void stash_exception(struct excinfo *exc, const char *why, ...)
{
  va_list ap;
  struct excinfo stash;

  if (!exc->ty)
    STASH_EXCINFO(exc);
  else {
    va_start(ap, why);
    STASH_EXCINFO(&stash);
    report_lost_exception_v(&stash, why, ap);
    va_end(ap);
  }
}

void restore_exception(struct excinfo *exc, const char *why, ...)
{
  va_list ap;
  struct excinfo stash;

  if (!PyErr_Occurred())
    RESTORE_EXCINFO(exc);
  else {
    va_start(ap, why);
    STASH_EXCINFO(&stash);
    report_lost_exception_v(exc, why, ap);
    RESTORE_EXCINFO(&stash);
    va_end(ap);
  }
}

/*----- Type definitions --------------------------------------------------*/

static const PyTypeObject emptytype = { 0 };

void *newtype(PyTypeObject *metaty,
	      const PyTypeObject *skel,
	      const char *name)
{
  PyHeapTypeObject *ty =
    (PyHeapTypeObject *)_PyObject_GC_Malloc(_PyObject_VAR_SIZE(metaty, 0));
  if (!skel) skel = &emptytype;
  memcpy(ty, skel, sizeof(*skel));
#define COPY(blah) do {							\
    if (ty->ht_type.tp_as_##blah) {					\
      memcpy(&ty->as_##blah,						\
	     ty->ht_type.tp_as_##blah,					\
	     sizeof(ty->as_##blah));					\
      ty->ht_type.tp_as_##blah = &ty->as_##blah;			\
    }									\
  } while (0)
  COPY(number);
  COPY(sequence);
  COPY(mapping);
  COPY(buffer);
#undef COPY
  if (name)
    ty->ht_name = TEXT_FROMSTR(name);
  else if (ty->ht_type.tp_name)
    ty->ht_name = TEXT_FROMSTR(ty->ht_type.tp_name);
  else
    ty->ht_name = 0;
  if (ty->ht_name)
    ty->ht_type.tp_name = TEXT_STR(ty->ht_name);
  ty->ht_slots = 0;
#ifdef PY3
  ty->ht_qualname = 0;
#endif
  (void)PyObject_INIT(&ty->ht_type, metaty);
  Py_INCREF(metaty);
  return (ty);
}

void typeready(PyTypeObject *ty)
{
#ifdef PY3
  PyHeapTypeObject *hty = (PyHeapTypeObject *)ty;
  hty->ht_qualname = hty->ht_name;
#endif
  PyType_Ready(ty);
  PyDict_SetItemString(ty->tp_dict, "__module__", modname);
}

PyTypeObject *inittype(const PyTypeObject *tyskel,
		       PyTypeObject *base, PyTypeObject *meta)
{
  PyTypeObject *ty = newtype(meta, tyskel, 0);
  if (base) { ty->tp_base = base; Py_INCREF(base); }
  ty->tp_flags |= Py_TPFLAGS_HEAPTYPE;
  typeready(ty);
  return (ty);
}

/*----- Populating modules ------------------------------------------------*/

PyObject *mkexc(PyObject *mod, PyObject *base,
		const char *name, const PyMethodDef *mm)
{
  PyObject *nameobj = 0;
  PyObject *dict = 0;
  PyObject *exc = 0;
  PyObject *func = 0;
  PyObject *meth = 0;

  if ((dict = PyDict_New()) == 0) goto fail;

  if (mm) {
    while (mm->ml_name) {
      if ((func = PyCFunction_NewEx((/*unconst*/ PyMethodDef *)mm,
				    0, mod)) == 0 ||
	  (meth = PY23(PyMethod_New(func, 0, exc),
		       PyInstanceMethod_New(func))) == 0 ||
	  PyDict_SetItemString(dict, mm->ml_name, meth))
	goto fail;
      Py_DECREF(func); func = 0;
      Py_DECREF(meth); meth = 0;
      mm++;
    }
  }

  if ((nameobj = TEXT_FORMAT("%s.%s", PyModule_GetName(mod), name)) == 0 ||
      (exc = PyErr_NewException(TEXT_STR(nameobj), base, dict)) == 0)
    goto fail;

done:
  Py_XDECREF(nameobj);
  Py_XDECREF(dict);
  return (exc);

fail:
  Py_XDECREF(exc);
  Py_XDECREF(func);
  Py_XDECREF(meth);
  exc = 0;
  goto done;
}

void setconstants(PyObject *mod, const struct nameval *c)
{
  PyObject *x;
  unsigned long u;

  while (c->name) {
    u = c->value;
    if (u <= LONG_MAX) x = PyInt_FromLong(u);
    else if (c->f&CF_SIGNED) x = PyInt_FromLong(-1 - (long)(ULONG_MAX - u));
    else x = PyLong_FromUnsignedLong(u);
    PyModule_AddObject(mod, (/*unconst*/ char *)c->name, x);
    c++;
  }
}

/*----- Submodules --------------------------------------------------------*/

static PyMethodDef *global_methods;
static size_t nmethods, methodsz;

void addmethods(const PyMethodDef *m)
{
  size_t n, want, newsz;

  for (n = 0; m[n].ml_name; n++);
  want = nmethods + n + 1;
  if (want > methodsz) {
    newsz = methodsz ? 2*methodsz : 16;
    while (want > newsz) newsz *= 2;
    if (!global_methods)
      global_methods = PyObject_Malloc(newsz*sizeof(PyMethodDef));
    else
      global_methods = PyObject_Realloc(global_methods,
					newsz*sizeof(PyMethodDef));
    assert(global_methods);
    methodsz = newsz;
  }
  memcpy(global_methods + nmethods, m, n*sizeof(PyMethodDef));
  nmethods += n;
  global_methods[nmethods].ml_name = 0;
}

PyMethodDef *donemethods(void) { return (global_methods); }

/*----- Low-level Python interface ----------------------------------------*/

static PyObject *meth__set_home_module(PyObject *me, PyObject *arg)
{
  PyObject *mod;

  if (!PyArg_ParseTuple(arg, "O!:_set_home_module", &PyModule_Type, &mod))
    return (0);
  Py_XDECREF(home_module); home_module = mod; Py_INCREF(home_module);
  RETURN_NONE;
}

static const PyMethodDef methods[] = {
#define METHNAME(func) meth_##func
  METH	(_set_home_module, "_set_home_module(MOD)")
#undef METHNAME
  { 0 }
};

void pyke_core_pyinit(void) { addmethods(methods); }
void pyke_core_pyinsert(PyObject *mod) { ; }

/*----- That's all, folks -------------------------------------------------*/
Commit	Line	Data
c1756f78 MW	1	/* --c--
	2	*
	3	* Pyke: the Python Kit for Extensions
	4	*
	5	* (c) 2019 Straylight/Edgeware
	6	*/
	7
	8	/----- Licensing notice --------------------------------------------------
	9	*
	10	* This file is part of Pyke: the Python Kit for Extensions.
	11	*
	12	* Pyke is free software: you can redistribute it and/or modify it under
	13	* the terms of the GNU General Public License as published by the Free
	14	* Software Foundation; either version 2 of the License, or (at your
	15	* option) any later version.
	16	*
	17	* Pyke is distributed in the hope that it will be useful, but WITHOUT
	18	* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
	19	* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
	20	* for more details.
	21	*
	22	* You should have received a copy of the GNU General Public License
	23	* along with Pyke. If not, write to the Free Software Foundation, Inc.,
	24	* 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
	25	*/
	26
	27	/----- Header files ------------------------------------------------------/
	28
	29	#include "pyke.h"
	30
	31	/----- External variables ------------------------------------------------/
	32
	33	PyObject *modname;
	34	PyObject *home_module;
	35
	36	/----- Conversions -------------------------------------------------------/
	37
	38	PyObject *getulong(unsigned long w)
	39	{
	40	if (w <= LONG_MAX) return (PyInt_FromLong(w));
	41	else return (PyLong_FromUnsignedLong(w));
	42	}
	43
	44	PyObject *getbool(int b)
	45	{ if (b) RETURN_TRUE; else RETURN_FALSE; }
	46
	47	int convulong(PyObject o, void pp)
	48	{
c1756f78 MW	49	unsigned long *p = pp;
	50	PyObject *t;
	51
	52	if (!o) VALERR("can't delete");
c80de12d	53	#ifdef PY2
c1756f78	54	if (PyInt_Check(o)) {
83a72c0d	55	long i = PyInt_AS_LONG(o);
c1756f78 MW	56	if (i < 0) VALERR("must be nonnegative");
c1756f78 MW	57	*p = i;
83a72c0d	58	} else
c80de12d	59	#endif
83a72c0d	60	{
c1756f78 MW	61	if ((t = PyNumber_Long(o)) == 0) goto end;
	62	*p = PyLong_AsUnsignedLong(t);
	63	Py_DECREF(t);
	64	if (PyErr_Occurred()) goto end;
	65	}
	66	return (1);
	67	end:
	68	return (0);
	69	}
	70
	71	int convuint(PyObject o, void pp)
	72	{
	73	unsigned long u;
	74	unsigned *p = pp;
	75
	76	if (!convulong(o, &u)) goto end;
	77	if (u > UINT_MAX) VALERR("out of range");
	78	*p = u;
	79	return (1);
	80	end:
	81	return (0);
	82	}
	83
	84	int convszt(PyObject o, void pp)
	85	{
	86	unsigned long u;
	87	size_t *p = pp;
	88
	89	if (!convulong(o, &u)) goto end;
	90	if (u > ~(size_t)0) VALERR("out of range");
	91	*p = u;
	92	return (1);
	93	end:
	94	return (0);
	95	}
	96
	97	int convbool(PyObject o, void pp)
	98	{
	99	if (!o) VALERR("can't delete");
	100	(int )pp = PyObject_IsTrue(o);
	101	return (1);
	102	end:
	103	return (0);
	104	}
	105
7e18a150 MW	106	int convbin(PyObject o, void pp)
	107	{
	108	struct bin *r = pp;
	109
e0a7dece MW	110	if (BIN_CHECK(o)) {
	111	r->p = BIN_PTR(o);
	112	r->sz = BIN_LEN(o);
7e18a150 MW	113	return (1);
7e18a150 MW	114	}
c80de12d	115	#ifdef PY2
7e18a150 MW	116	if (PyUnicode_Check(o)) {
	117	o = _PyUnicode_AsDefaultEncodedString(o, 0);
	118	if (!o) return (0);
	119	r->p = PyString_AS_STRING(o);
	120	r->sz = PyString_GET_SIZE(o);
	121	return (1);
	122	}
c80de12d	123	#endif
7e18a150 MW	124	return (PyObject_AsReadBuffer(o, &r->p, &r->sz) ? 0 : 1);
	125	}
	126
c1756f78 MW	127	/----- Miscellaneous utilities -------------------------------------------/
	128
	129	PyObject abstract_pynew(PyTypeObject ty, PyObject arg, PyObject kw)
	130	{
	131	PyErr_SetString(PyExc_TypeError, "can't instantiate this class");
	132	return (0);
	133	}
	134
1c0e9c88 MW	135	PyObject *enrich_compare(int op, int cmp)
	136	{
	137	int r = -1;
	138
	139	switch (op) {
	140	case Py_LT: r = cmp < 0; break;
	141	case Py_LE: r = cmp <= 0; break;
	142	case Py_EQ: r = cmp == 0; break;
	143	case Py_NE: r = cmp != 0; break;
	144	case Py_GE: r = cmp >= 0; break;
	145	case Py_GT: r = cmp > 0; break;
	146	default: assert(0);
	147	}
	148	return (getbool(r));
	149	}
	150
c1756f78 MW	151	/----- Saving and restoring exceptions ----------------------------------/
	152
	153	void report_lost_exception_v(struct excinfo *exc,
	154	const char *why, va_list ap)
	155	{
	156	PyObject *hookfn = 0;
	157	PyObject *whyobj = 0;
	158	PyObject *obj = 0;
	159
	160	/* Make sure we start out without a pending exception, or this will get
	161	* really confusing.
	162	*/
	163	assert(!PyErr_Occurred());
	164
	165	/* Format the explanation. */
e0a7dece	166	if (why) whyobj = TEXT_VFORMAT(why, ap);
c1756f78 MW	167	else { whyobj = Py_None; Py_INCREF(whyobj); }
	168
	169	/* Find our home module's `lostexchook' function. This won't work if
	170	* there's no module, or the function isn't defined, or it's `None'.
	171	*/
	172	if (!home_module) goto sys;
	173	hookfn = PyObject_GetAttrString(home_module, "lostexchook");
	174	if (hookfn == Py_None) goto sys;
	175	else if (hookfn) ;
	176	else if (!PyErr_ExceptionMatches(PyExc_AttributeError)) goto ouch;
	177	else { PyErr_Clear(); goto sys; }
	178
	179	/* Call the hook function. */
	180	obj = PyObject_CallFunction(hookfn, "(OOOO)",
	181	whyobj, exc->ty, exc->val, exc->tb);
	182	if (!obj) goto ouch;
	183	goto end;
	184
	185	/* Something went wrong reporting the problem. */
	186	ouch:
	187	PySys_WriteStderr("\n!!! FAILURE REPORTING LOST EXCEPTION\n");
	188	PyErr_Print();
	189	/* drop through... */
	190
	191	/* There was no hook, so try to do something sensible using
	192	* `sys.excepthook'.
	193	*/
	194	sys:
e0a7dece	195	PySys_WriteStderr("\n!!! LOST EXCEPTION: %s\n", TEXT_PTR(whyobj));
c1756f78 MW	196	RESTORE_EXCINFO(exc);
	197	PyErr_Print();
	198	/* drop through... */
	199
	200	/* Clean up afterwards. */
	201	end:
	202	Py_XDECREF(hookfn);
	203	Py_XDECREF(whyobj);
	204	Py_XDECREF(obj);
	205	}
	206
	207	void report_lost_exception(struct excinfo exc, const char why, ...)
	208	{
	209	va_list ap;
	210
	211	va_start(ap, why);
	212	report_lost_exception_v(exc, why, ap);
	213	va_end(ap);
	214	}
	215
	216	void stash_exception(struct excinfo exc, const char why, ...)
	217	{
	218	va_list ap;
	219	struct excinfo stash;
	220
	221	if (!exc->ty)
	222	STASH_EXCINFO(exc);
	223	else {
	224	va_start(ap, why);
	225	STASH_EXCINFO(&stash);
	226	report_lost_exception_v(&stash, why, ap);
	227	va_end(ap);
	228	}
	229	}
	230
	231	void restore_exception(struct excinfo exc, const char why, ...)
	232	{
	233	va_list ap;
	234	struct excinfo stash;
	235
	236	if (!PyErr_Occurred())
	237	RESTORE_EXCINFO(exc);
	238	else {
	239	va_start(ap, why);
	240	STASH_EXCINFO(&stash);
	241	report_lost_exception_v(exc, why, ap);
	242	RESTORE_EXCINFO(&stash);
	243	va_end(ap);
	244	}
	245	}
	246
	247	/----- Type definitions --------------------------------------------------/
	248
	249	static const PyTypeObject emptytype = { 0 };
	250
	251	void newtype(PyTypeObject metaty,
	252	const PyTypeObject *skel,
	253	const char *name)
	254	{
	255	PyHeapTypeObject *ty =
	256	(PyHeapTypeObject *)_PyObject_GC_Malloc(_PyObject_VAR_SIZE(metaty, 0));
	257	if (!skel) skel = &emptytype;
	258	memcpy(ty, skel, sizeof(*skel));
c1756f78 MW	259	#define COPY(blah) do { \
	260	if (ty->ht_type.tp_as_##blah) { \
	261	memcpy(&ty->as_##blah, \
	262	ty->ht_type.tp_as_##blah, \
	263	sizeof(ty->as_##blah)); \
	264	ty->ht_type.tp_as_##blah = &ty->as_##blah; \
	265	} \
	266	} while (0)
	267	COPY(number);
	268	COPY(sequence);
	269	COPY(mapping);
	270	COPY(buffer);
	271	#undef COPY
	272	if (name)
e0a7dece	273	ty->ht_name = TEXT_FROMSTR(name);
c1756f78	274	else if (ty->ht_type.tp_name)
e0a7dece MW	275	ty->ht_name = TEXT_FROMSTR(ty->ht_type.tp_name);
	276	else
	277	ty->ht_name = 0;
c1756f78	278	if (ty->ht_name)
e0a7dece	279	ty->ht_type.tp_name = TEXT_STR(ty->ht_name);
1b026fd1	280	ty->ht_slots = 0;
c80de12d MW	281	#ifdef PY3
	282	ty->ht_qualname = 0;
	283	#endif
c1756f78 MW	284	(void)PyObject_INIT(&ty->ht_type, metaty);
	285	Py_INCREF(metaty);
	286	return (ty);
	287	}
	288
	289	void typeready(PyTypeObject *ty)
	290	{
c80de12d MW	291	#ifdef PY3
	292	PyHeapTypeObject hty = (PyHeapTypeObject )ty;
	293	hty->ht_qualname = hty->ht_name;
	294	#endif
c1756f78 MW	295	PyType_Ready(ty);
	296	PyDict_SetItemString(ty->tp_dict, "__module__", modname);
	297	}
	298
747ddb1b MW	299	PyTypeObject inittype(const PyTypeObject tyskel,
747ddb1b MW	300	PyTypeObject base, PyTypeObject meta)
c1756f78 MW	301	{
c1756f78 MW	302	PyTypeObject *ty = newtype(meta, tyskel, 0);
747ddb1b	303	if (base) { ty->tp_base = base; Py_INCREF(base); }
c1756f78 MW	304	ty->tp_flags \|= Py_TPFLAGS_HEAPTYPE;
	305	typeready(ty);
	306	return (ty);
	307	}
	308
	309	/----- Populating modules ------------------------------------------------/
	310
	311	PyObject mkexc(PyObject mod, PyObject *base,
87fa2d56	312	const char name, const PyMethodDef mm)
c1756f78 MW	313	{
	314	PyObject *nameobj = 0;
	315	PyObject *dict = 0;
	316	PyObject *exc = 0;
	317	PyObject *func = 0;
	318	PyObject *meth = 0;
	319
	320	if ((dict = PyDict_New()) == 0) goto fail;
	321
	322	if (mm) {
	323	while (mm->ml_name) {
87fa2d56 MW	324	if ((func = PyCFunction_NewEx((/unconst/ PyMethodDef *)mm,
87fa2d56 MW	325	0, mod)) == 0 \|\|
c80de12d MW	326	(meth = PY23(PyMethod_New(func, 0, exc),
c80de12d MW	327	PyInstanceMethod_New(func))) == 0 \|\|
c1756f78 MW	328	PyDict_SetItemString(dict, mm->ml_name, meth))
	329	goto fail;
	330	Py_DECREF(func); func = 0;
	331	Py_DECREF(meth); meth = 0;
	332	mm++;
	333	}
	334	}
	335
e0a7dece MW	336	if ((nameobj = TEXT_FORMAT("%s.%s", PyModule_GetName(mod), name)) == 0 \|\|
e0a7dece MW	337	(exc = PyErr_NewException(TEXT_STR(nameobj), base, dict)) == 0)
c1756f78 MW	338	goto fail;
	339
	340	done:
	341	Py_XDECREF(nameobj);
	342	Py_XDECREF(dict);
	343	return (exc);
	344
	345	fail:
	346	Py_XDECREF(exc);
	347	Py_XDECREF(func);
	348	Py_XDECREF(meth);
	349	exc = 0;
	350	goto done;
	351	}
	352
	353	void setconstants(PyObject mod, const struct nameval c)
	354	{
	355	PyObject *x;
	356	unsigned long u;
	357
	358	while (c->name) {
	359	u = c->value;
	360	if (u <= LONG_MAX) x = PyInt_FromLong(u);
	361	else if (c->f&CF_SIGNED) x = PyInt_FromLong(-1 - (long)(ULONG_MAX - u));
	362	else x = PyLong_FromUnsignedLong(u);
	363	PyModule_AddObject(mod, (/unconst/ char *)c->name, x);
	364	c++;
	365	}
	366	}
	367
	368	/----- Submodules --------------------------------------------------------/
	369
	370	static PyMethodDef *global_methods;
	371	static size_t nmethods, methodsz;
	372
	373	void addmethods(const PyMethodDef *m)
	374	{
	375	size_t n, want, newsz;
	376
	377	for (n = 0; m[n].ml_name; n++);
	378	want = nmethods + n + 1;
	379	if (want > methodsz) {
	380	newsz = methodsz ? 2*methodsz : 16;
	381	while (want > newsz) newsz *= 2;
	382	if (!global_methods)
	383	global_methods = PyObject_Malloc(newsz*sizeof(PyMethodDef));
	384	else
	385	global_methods = PyObject_Realloc(global_methods,
	386	newsz*sizeof(PyMethodDef));
	387	assert(global_methods);
	388	methodsz = newsz;
	389	}
	390	memcpy(global_methods + nmethods, m, n*sizeof(PyMethodDef));
	391	nmethods += n;
	392	global_methods[nmethods].ml_name = 0;
	393	}
	394
	395	PyMethodDef *donemethods(void) { return (global_methods); }
	396
	397	/----- Low-level Python interface ----------------------------------------/
	398
	399	static PyObject meth__set_home_module(PyObject me, PyObject *arg)
	400	{
	401	PyObject *mod;
402
403	if (!PyArg_ParseTuple(arg, "O!:_set_home_module", &PyModule_Type, &mod))
404	return (0);
405	Py_XDECREF(home_module); home_module = mod; Py_INCREF(home_module);
406	RETURN_NONE;
407	}
408
409	static const PyMethodDef methods[] = {
410	#define METHNAME(func) meth_##func
411	METH (_set_home_module, "_set_home_module(MOD)")
412	#undef METHNAME
413	{ 0 }
414	};
415
416	void pyke_core_pyinit(void) { addmethods(methods); }
417	void pyke_core_pyinsert(PyObject *mod) { ; }
418
419	/----- That's all, folks -------------------------------------------------/