GitHub/gf-core
1
0
Fork 1
mirror of https://github.com/GrammaticalFramework/gf-core.git synced 2026-04-09 04:59:31 -06:00
Code Issues Packages Projects Releases Wiki Activity

Merge branch 'majestic' into majestic-macos

Browse Source
This commit is contained in:
John J. Camilleri
2021-10-18 14:27:30 +02:00
parent ac93f2dd10 0e98c30973
commit 42c1ec4448
6 changed files with 192 additions and 82 deletions
Download Patch File Download Diff File Expand all files Collapse all files

192
src/runtime/python/expr.c
View File

@@ -22,55 +22,123 @@ Type_init(TypeObject *self, PyObject *args, PyObject *kwds)
{
PyObject* hypos;
PyObject* name;
PyObject* exprs;
if (!PyArg_ParseTuple(args, "OUO", &hypos, &name, &exprs)) {
return -1;
}
if (!PySequence_Check(hypos)) {
PyErr_SetString(PyExc_TypeError, "hypotheses must be iterable");
return -1;
}
if (!PySequence_Check(exprs)) {
PyErr_SetString(PyExc_TypeError, "expressions must be a sequence");
PyObject* exprs = NULL;
switch (PyTuple_Size(args)) {
case 1:
hypos = NULL;
name = PyTuple_GET_ITEM(args, 0);
exprs = NULL;
if (!PyUnicode_Check(name)) {
PyErr_SetString(PyExc_TypeError, "category must be a string");
return -1;
}
break;
case 2:
if (PySequence_Check(PyTuple_GET_ITEM(args, 0)) &&
PyUnicode_Check(PyTuple_GET_ITEM(args, 1))) {
hypos = PyTuple_GET_ITEM(args, 0);
name = PyTuple_GET_ITEM(args, 1);
exprs = NULL;
} else if (PyUnicode_Check(PyTuple_GET_ITEM(args, 0)) &&
PySequence_Check(PyTuple_GET_ITEM(args, 1))) {
hypos = NULL;
name = PyTuple_GET_ITEM(args, 0);
exprs = PyTuple_GET_ITEM(args, 1);
} else {
PyErr_SetString(PyExc_TypeError, "The arguments must be hypotheses and category or category and expressions");
return -1;
}
break;
case 3:
hypos = PyTuple_GET_ITEM(args, 0);
name = PyTuple_GET_ITEM(args, 1);
exprs = PyTuple_GET_ITEM(args, 2);
if (!PySequence_Check(hypos)) {
PyErr_SetString(PyExc_TypeError, "hypotheses must be a sequence");
return -1;
}
if (!PyUnicode_Check(name)) {
PyErr_SetString(PyExc_TypeError, "category must be a string");
return -1;
}
if (!PySequence_Check(exprs)) {
PyErr_SetString(PyExc_TypeError, "expressions must be a sequence");
return -1;
}
break;
default:
PyErr_SetString(PyExc_TypeError, "1, 2 or 3 arguments are expected");
return -1;
}
for (Py_ssize_t i = 0; i < PySequence_Size(hypos); i++) {
// if (!PyObject_TypeCheck(PySequence_GetItem(hypos, i), &pgf_HypoType)) {
// PyErr_SetString(PyExc_TypeError, "invalid hypo in Type initialisation");
// return -1;
// }
PyObject *tup = PySequence_GetItem(hypos, i);
if (!PyObject_TypeCheck(tup, &PyTuple_Type)) {
PyErr_SetString(PyExc_TypeError, "hypothesis must be a tuple");
return -1;
}
if (!PyLong_Check(PyTuple_GetItem(tup, 0))) {
PyErr_SetString(PyExc_TypeError, "hypothesis bind type must be a boolean");
return -1;
}
if (!PyUnicode_Check(PyTuple_GetItem(tup, 1))) {
PyErr_SetString(PyExc_TypeError, "hypothesis variable must be a string");
return -1;
}
if (!PyObject_TypeCheck(PyTuple_GetItem(tup, 2), &pgf_TypeType)) {
PyErr_SetString(PyExc_TypeError, "hypothesis type must be a Type");
return -1;
if (hypos != NULL) {
Py_ssize_t n_hypos = PySequence_Size(hypos);
self->hypos = PyTuple_New(n_hypos);
for (Py_ssize_t i = 0; i < n_hypos; i++) {
PyObject *item = PySequence_GetItem(hypos, i);
if (PyTuple_Check(item) && PyTuple_Size(item) == 3) {
if (!PyBool_Check(PyTuple_GetItem(item, 0))) {
PyErr_SetString(PyExc_TypeError, "hypothesis bind type must be a boolean");
return -1;
}
if (!PyUnicode_Check(PyTuple_GetItem(item, 1))) {
PyErr_SetString(PyExc_TypeError, "hypothesis variable must be a string");
return -1;
}
if (!PyObject_TypeCheck(PyTuple_GetItem(item, 2), &pgf_TypeType)) {
PyErr_SetString(PyExc_TypeError, "hypothesis type must be a Type");
return -1;
}
Py_INCREF(item);
PyTuple_SET_ITEM(self->hypos, i, item);
} else if (PyObject_TypeCheck(item, &pgf_TypeType)) {
PyObject *wildcard = PyUnicode_FromString("_");
PyObject *tuple = PyTuple_Pack(3, Py_True,
PyUnicode_FromString("_"),
item);
Py_DECREF(wildcard);
PyTuple_SET_ITEM(self->hypos, i, tuple);
} else if (PyUnicode_Check(item)) {
Py_INCREF(item);
TypeObject *pytype = (TypeObject *)pgf_TypeType.tp_alloc(&pgf_TypeType, 0);
pytype->hypos = PyTuple_New(0);
pytype->name = item;
pytype->exprs = PyTuple_New(0);
PyObject *wildcard = PyUnicode_FromString("_");
PyObject *tuple = PyTuple_Pack(3, Py_True,
wildcard,
pytype);
Py_DECREF(wildcard);
Py_DECREF(pytype);
PyTuple_SET_ITEM(self->hypos, i, tuple);
} else {
PyErr_SetString(PyExc_TypeError, "Each hypothesis must be either a tuple of size 3, a type or a string");
return -1;
}
}
} else {
self->hypos = PyTuple_New(0);
}
for (Py_ssize_t i = 0; i < PySequence_Size(exprs); i++) {
if (!PyObject_TypeCheck(PySequence_GetItem(exprs, i), &pgf_ExprType)) {
PyErr_SetString(PyExc_TypeError, "invalid expression in Type initialisation");
return -1;
}
}
self->hypos = PySequence_Tuple(hypos);
self->name = name;
self->exprs = PySequence_Tuple(exprs);
Py_INCREF(self->hypos);
Py_INCREF(self->name);
Py_INCREF(self->exprs);
if (exprs != NULL) {
Py_ssize_t n_exprs = PySequence_Size(exprs);
self->exprs = PyTuple_New(n_exprs);
for (Py_ssize_t i = 0; i < n_exprs; i++) {
PyObject *expr = PySequence_GetItem(exprs, i);
if (!PyObject_TypeCheck(expr, &pgf_ExprType)) {
PyErr_SetString(PyExc_TypeError, "invalid expression in Type initialisation");
return -1;
}
PyTuple_SET_ITEM(self->exprs, i, expr);
}
} else {
self->exprs = PyTuple_New(0);
}
return 0;
}
@@ -131,7 +199,49 @@ done:
}
}
static PyObject*
Type_unpack(TypeObject* self, PyObject *fargs)
{
return Py_BuildValue("OOO", self->hypos, self->name, self->exprs);
}
static PyObject*
Type_reduce_ex(TypeObject* self, PyObject *args)
{
int protocol;
if (!PyArg_ParseTuple(args, "i", &protocol))
return NULL;
PyObject* myModule = PyImport_ImportModule("pgf");
if (myModule == NULL)
return NULL;
PyObject* py_readType = PyObject_GetAttrString(myModule, "readType");
Py_DECREF(myModule);
if (py_readType == NULL)
return NULL;
PyObject* py_str = Type_str(self);
if (py_str == NULL) {
Py_DECREF(py_readType);
return NULL;
}
PyObject* py_tuple =
Py_BuildValue("O(O)", py_readType, py_str);
Py_DECREF(py_str);
Py_DECREF(py_readType);
return py_tuple;
}
static PyMethodDef Type_methods[] = {
{"unpack", (PyCFunction)Type_unpack, METH_VARARGS,
"Decomposes a type into its components"
},
{"__reduce_ex__", (PyCFunction)Type_reduce_ex, METH_VARARGS,
"This method allows for transparent pickling/unpickling of types."
},
{NULL} /* Sentinel */
};

57
src/runtime/python/ffi.c
View File

@@ -69,39 +69,34 @@ PySequence_AsHypos(PyObject *pyseq, Py_ssize_t *n_hypos)
PgfTypeHypo *hypos = PyMem_RawMalloc(sizeof(PgfTypeHypo)*n);
for (Py_ssize_t i = 0; i < n; i++) {
// PyObject *item = PySequence_GetItem(pyseq, i);
// if (!PyObject_TypeCheck(item, &pgf_HypoType)) {
// PyErr_SetString(PyExc_TypeError, "hypothesis must be of type Hypo");
// return NULL;
// }
// HypoObject *hypo = (HypoObject *)item;
// hypos[i].bind_type = hypo->bind_type == Py_True ? 0 : 1;
// hypos[i].cid = PyUnicode_AsPgfText(hypo->cid);
// hypos[i].type = (PgfType) hypo->type;
PyObject *tup = PySequence_GetItem(pyseq, i);
if (!PyTuple_Check(tup)) {
if (!PyTuple_Check(tup) || PyTuple_Size(tup) != 3) {
PyErr_SetString(PyExc_TypeError, "hypothesis must be a tuple");
FreeHypos(hypos, i);
return NULL;
}
PyObject *t0 = PyTuple_GetItem(tup, 0);
if (!PyLong_Check(t0)) {
PyObject *t0 = PyTuple_GET_ITEM(tup, 0);
if (!PyBool_Check(t0)) {
PyErr_SetString(PyExc_TypeError, "hypothesis bind type must be an boolean");
FreeHypos(hypos, i);
return NULL;
}
hypos[i].bind_type = t0 == Py_True ? 0 : 1;
hypos[i].bind_type = t0 == Py_True ? PGF_BIND_TYPE_EXPLICIT : PGF_BIND_TYPE_IMPLICIT;
PyObject *t1 = PyTuple_GetItem(tup, 1);
PyObject *t1 = PyTuple_GET_ITEM(tup, 1);
if (!PyUnicode_Check(t1)) {
PyErr_SetString(PyExc_TypeError, "hypothesis variable must be a string");
FreeHypos(hypos, i);
return NULL;
}
hypos[i].cid = PyUnicode_AsPgfText(t1);
PyObject *t2 = PyTuple_GetItem(tup, 2);
PyObject *t2 = PyTuple_GET_ITEM(tup, 2);
if (!PyObject_TypeCheck(t2, &pgf_TypeType)) {
PyErr_SetString(PyExc_TypeError, "hypothesis type must be a Type");
FreePgfText(hypos[i].cid);
FreeHypos(hypos, i);
return NULL;
}
hypos[i].type = (PgfType) t2;
@@ -113,37 +108,29 @@ PySequence_AsHypos(PyObject *pyseq, Py_ssize_t *n_hypos)
}
PyObject *
PyList_FromHypos(PgfTypeHypo *hypos, const size_t n_hypos)
PyTuple_FromHypos(PgfTypeHypo *hypos, const size_t n_hypos)
{
PyObject *pylist = PyList_New(n_hypos);
if (pylist == NULL) {
PyObject *pytuple = PyTuple_New(n_hypos);
if (pytuple == NULL) {
return NULL;
}
for (size_t i = 0; i < n_hypos; i++) {
// HypoObject *hypo = PyObject_New(HypoObject, &pgf_HypoType);
// hypo->bind_type = hypos[i].bind_type == 0 ? Py_True : Py_False;
// hypo->cid = PyUnicode_FromStringAndSize(hypos[i].cid->text, hypos[i].cid->size);
// hypo->type = (TypeObject *)hypos[i].type;
// Py_INCREF(hypo->bind_type);
// Py_INCREF(hypo->type);
// PyList_SetItem(pylist, i, (PyObject *)hypo);
PyObject *tup = PyTuple_New(3);
PyObject *bt = hypos[i].bind_type == 0 ? Py_True : Py_False;
PyTuple_SetItem(tup, 0, bt);
PyTuple_SetItem(tup, 1, PyUnicode_FromStringAndSize(hypos[i].cid->text, hypos[i].cid->size));
PyTuple_SetItem(tup, 2, (PyObject *)hypos[i].type);
PyTuple_SET_ITEM(tup, 0, bt);
PyTuple_SET_ITEM(tup, 1, PyUnicode_FromStringAndSize(hypos[i].cid->text, hypos[i].cid->size));
PyTuple_SET_ITEM(tup, 2, (PyObject *)hypos[i].type);
Py_INCREF(bt);
Py_INCREF(hypos[i].type);
PyList_SetItem(pylist, i, tup);
PyTuple_SET_ITEM(pytuple, i, tup);
}
if (PyErr_Occurred()) {
Py_DECREF(pylist);
Py_DECREF(pytuple);
return NULL;
}
return pylist;
return pytuple;
}
PgfPrintContext *
@@ -331,12 +318,12 @@ dtyp(PgfUnmarshaller *this, int n_hypos, PgfTypeHypo *hypos, PgfText *cat, int n
{
TypeObject *pytype = (TypeObject *)pgf_TypeType.tp_alloc(&pgf_TypeType, 0);
pytype->hypos = PySequence_Tuple(PyList_FromHypos(hypos, n_hypos));
pytype->hypos = PyTuple_FromHypos(hypos, n_hypos);
pytype->name = PyUnicode_FromStringAndSize(cat->text, cat->size);
pytype->exprs = PyTuple_New(n_exprs);
for (int i = 0; i < n_exprs; i++) {
PyObject *expr = (PyObject *)exprs[i];
PyTuple_SetItem(pytype->exprs, i, expr);
PyTuple_SET_ITEM(pytype->exprs, i, expr);
Py_INCREF(expr);
}

2
src/runtime/python/ffi.h
View File

@@ -21,7 +21,7 @@ PgfText *PyUnicode_AsPgfText(PyObject *pystr);
PyObject *PyUnicode_FromPgfText(PgfText *text);
PgfTypeHypo *PySequence_AsHypos(PyObject *pyseq, Py_ssize_t *n_hypos);
PyObject *PyList_FromHypos(PgfTypeHypo *hypos, const size_t n_hypos);
PyObject *PyTuple_FromHypos(PgfTypeHypo *hypos, const size_t n_hypos);
PgfPrintContext *PyList_AsPgfPrintContext(PyObject *pylist);

2
src/runtime/python/pypgf.c
View File

@@ -148,7 +148,7 @@ PGF_categoryContext(PGFObject *self, PyObject *args)
Py_RETURN_NONE;
}
PyObject *contexts = PyList_FromHypos(hypos, n_hypos);
PyObject *contexts = PyTuple_FromHypos(hypos, n_hypos);
for (size_t i = 0; i < n_hypos; i++) {
free(hypos[i].cid);

16
src/runtime/python/tests/test_basic.py
View File

@@ -104,10 +104,10 @@ def test_functionsByCat_non_existent(PGF):
assert PGF.functionsByCat("X") == []
def test_categoryContext_1(PGF):
assert PGF.categoryContext("N") == []
assert PGF.categoryContext("N") == ()
def test_categoryContext_2(PGF):
assert PGF.categoryContext("S") == []
assert PGF.categoryContext("S") == ()
def test_categoryContext_3(PGF):
cxt = PGF.categoryContext("P")
@@ -215,6 +215,18 @@ def test_showType_9(PGF):
type = Type([mkDepHypo("x", Type([], "N", [])), mkDepHypo("y", Type([], "P", [ExprVar(0)]))], "S", [])
assert showType(["n"], type) == "(x : N) -> (y : P x) -> S"
def test_Type_overloading_1(PGF):
assert Type([],"A",[]) == Type("A")
def test_Type_overloading_2(PGF):
assert Type([(True,"_",Type("A"))],"B",[]) == Type(["A"],"B")
def test_Type_overloading_3(PGF):
assert Type([(True,"_",Type("A"))],"B",[]) == Type([Type("A")],"B")
def test_Type_overloading_4(PGF):
assert Type([],"A",[Expr(3)]) == Type("A",[Expr(3)])
def test_Type_getters():
h0 = mkDepHypo("x", Type([], "N", []))
e0 = ExprVar(0)

5
src/runtime/python/tests/test_transactions.py
View File

@@ -89,7 +89,8 @@ def test_extended_categories(gr2):
assert gr2.categories == ["Float","Int","N","P","Q","S","String"]
def test_extended_category_context(gr2):
assert gr2.categoryContext("Q") == [(BIND_TYPE_EXPLICIT, "x", ty)]
print(gr2.categoryContext("Q"))
assert gr2.categoryContext("Q") == ((BIND_TYPE_EXPLICIT, "x", ty),)
def test_extended_function_type(gr2):
assert gr2.functionType("foo") == ty
@@ -112,7 +113,7 @@ def test_branched_categories(gr3):
assert gr3.categories == ["Float","Int","N","P","R","S","String"]
def test_branched_category_context(gr3):
assert gr3.categoryContext("R") == [(BIND_TYPE_EXPLICIT, "x", ty)]
assert gr3.categoryContext("R") == ((BIND_TYPE_EXPLICIT, "x", ty),)
def test_branched_function_type(gr3):
assert gr3.functionType("bar") == ty