@@@ cython and python3

[mLib-python] / atom-base.c

/* -*-c-*-
 *
 * Atom stuff
 *
 * (c) 2005 Straylight/Edgeware
 */

/*----- Licensing notice --------------------------------------------------*
 *
 * This file is part of the Python interface to mLib.
 *
 * mLib/Python 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.
 *
 * mLib/Python 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 mLib/Python; if not, write to the Free Software Foundation,
 * Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
 */

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

#include <Python.h>

#include <mLib/atom.h>
#include <mLib/assoc.h>
#include <mLib/dstr.h>

#include "atom.h"
#include "grim.h"

/*----- Data structures ---------------------------------------------------*/

typedef struct entry {
  assoc_base _b;
  PyObject *a;
} entry;

/*----- Static variables --------------------------------------------------*/

static assoc_table obarray;

/*----- Main code ---------------------------------------------------------*/

PyObject *atom_pywrap(atom *a)
{
  entry *e = 0;
  atom_pyobj *ao;
  unsigned f = 0;

  e = assoc_find(&obarray, a, sizeof(entry), &f);
  if (!f) {
    ao = PyObject_NEW(atom_pyobj, &atom_pytype); ao->a = a;
    e->a = (PyObject *)ao;
  }

  /* If we just created the new `Atom' object, we get a reference, which
   * belongs to the `obarray' table.  So when we return it to the caller, we
   * always need to increment it.
   */
  RETURN_OBJ(e->a);
}

PyObject *atom_pyintern(PyObject *x)
{
  atom *a;
  const void *p;
  Py_ssize_t n;

  if (ATOM_PYCHECK(x))
    RETURN_OBJ(x);
  if (x == Py_None)
    a = atom_gensym(ATOM_GLOBAL);
  else if (!TEXT_CHECK(x))
    { PyErr_SetString(PyExc_TypeError, "string wanted"); return (0); }
  else {
    TEXT_PTRLEN(x, &p, &n); if (!p) return (0);
    a = atom_nintern(ATOM_GLOBAL, p, n);
  }
  return (atom_pywrap(a));
}

static void atom_pydealloc(PyObject *me)
  { fprintf(stderr, "ouch!  freeing atom\n"); abort();	}

static PyObject *atom_pynew(PyTypeObject *ty, PyObject *arg, PyObject *kw)
{
  PyObject *name = Py_None;
  static const char *const kwlist[] = { "name", 0 };

  if (!PyArg_ParseTupleAndKeywords(arg, kw, "|O:new", KWLIST, &name))
    return (0);
  return (atom_pyintern(name));
}

static PyObject *aget_name(PyObject *me, void *hunoz)
  { return (TEXT_FROMSTRLEN(ATOM_NAME(ATOM_A(me)), ATOM_LEN(ATOM_A(me)))); }

static PyObject *aget_internedp(PyObject *me, void *hunoz)
{
  PyObject *rc = (ATOM_A(me)->f & ATOMF_GENSYM) ? Py_False : Py_True;
  RETURN_OBJ(rc);
}

static PyGetSetDef atom_pygetset[] = {
#define GETSETNAME(op, name) a##op##_##name
  GET	(name,			"A.name -> NAME")
  GET	(internedp,		"A.internedp -> BOOL")
#undef GETSETNAME
  { 0 }
};

static PyObject *atom_pyrichcompare(PyObject *x, PyObject *y, int op)
{
  PyObject *rc = 0;

  switch (op) {
    case Py_EQ: rc = (x == y) ? Py_True : Py_False; break;
    case Py_NE: rc = (x != y) ? Py_True : Py_False; break;
    default:
      PyErr_SetString(PyExc_TypeError, "atoms are unordered");
      return (0);
  }
  RETURN_OBJ(rc);
}

static PyObject *atom_pyrepr(PyObject *me)
{
  PyObject *s, *sr = 0;
  PyObject *rc = 0;
  char *p;
  Py_ssize_t n;
  dstr d = DSTR_INIT;

  if ((s = aget_name(me, 0)) == 0 ||
      (sr = PyObject_Repr(s)) == 0)
    goto done;
  if (!TEXT_CHECK(sr))
    { PyErr_SetString(PyExc_TypeError, "string wanted"); goto done; }
  TEXT_PTRLEN(sr, &p, &n); if (!p) goto done;
  dstr_puts(&d, "Atom(");
  dstr_putm(&d, p, n);
  dstr_puts(&d, ")");
  rc = TEXT_FROMSTRLEN(d.buf, d.len);
done:
  Py_XDECREF(s);
  Py_XDECREF(sr);
  dstr_destroy(&d);
  return (rc);
}

static Py_hash_t atom_pyhash(PyObject *me)
  { Py_hash_t h = ATOM_HASH(ATOM_A(me)); if (h == -1) h = -2; return (h); }

PyTypeObject atom_pytype = {
  PyVarObject_HEAD_INIT(0, 0)		/* Header */
  "mLib.Atom",				/* @tp_name@ */
  sizeof(atom_pyobj),			/* @tp_basicsize@ */
  0,					/* @tp_itemsize@ */

  atom_pydealloc,			/* @tp_dealloc@ */
  0,					/* @tp_print@ */
  0,					/* @tp_getattr@ */
  0,					/* @tp_setattr@ */
  0,					/* @tp_compare@ */
  atom_pyrepr,				/* @tp_repr@ */
  0,					/* @tp_as_number@ */
  0,					/* @tp_as_sequence@ */
  0,					/* @tp_as_mapping@ */
  atom_pyhash,				/* @tp_hash@ */
  0,					/* @tp_call@ */
  atom_pyrepr,				/* @tp_str@ */
  0,					/* @tp_getattro@ */
  0,					/* @tp_setattro@ */
  0,					/* @tp_as_buffer@ */
  Py_TPFLAGS_DEFAULT,			/* @tp_flags@ */

  /* @tp_doc@ */
"Atom.",

  0,					/* @tp_traverse@ */
  0,					/* @tp_clear@ */
  atom_pyrichcompare,			/* @tp_richcompare@ */
  0,					/* @tp_weaklistoffset@ */
  0,					/* @tp_iter@ */
  0,					/* @tp_iternexr@ */
  0,					/* @tp_methods@ */
  0,					/* @tp_members@ */
  atom_pygetset,			/* @tp_getset@ */
  0,					/* @tp_base@ */
  0,					/* @tp_dict@ */
  0,					/* @tp_descr_get@ */
  0,					/* @tp_descr_set@ */
  0,					/* @tp_dictoffset@ */
  0,					/* @tp_init@ */
  PyType_GenericAlloc,			/* @tp_alloc@ */
  atom_pynew,				/* @tp_new@ */
  0,					/* @tp_free@ */
  0					/* @tp_is_gc@ */
};

void atom_pysetup(void)
  { assoc_create(&obarray); PyType_Ready(&atom_pytype); }

/*----- That's all, folks -------------------------------------------------*/