#define PY_SSIZE_T_CLEAN #include #include "structmember.h" #include #if PY_MAJOR_VERSION >= 3 #define PyIntObject PyLongObject #define PyInt_Type PyLong_Type #define PyInt_Check(op) PyLong_Check(op) #define PyInt_CheckExact(op) PyLong_CheckExact(op) #define PyInt_FromString PyLong_FromString #define PyInt_FromUnicode PyLong_FromUnicode #define PyInt_FromLong PyLong_FromLong #define PyInt_FromSize_t PyLong_FromSize_t #define PyInt_FromSsize_t PyLong_FromSsize_t #define PyInt_AsLong PyLong_AsLong #define PyInt_AS_LONG PyLong_AS_LONG #define PyInt_AsSsize_t PyLong_AsSsize_t #define PyInt_AsUnsignedLongMask PyLong_AsUnsignedLongMask #define PyInt_AsUnsignedLongLongMask PyLong_AsUnsignedLongLongMask #endif #if PY_MAJOR_VERSION >= 3 #define PyString_Check PyUnicode_Check #define PyString_FromStringAndSize PyUnicode_FromStringAndSize #define PyString_FromFormat PyUnicode_FromFormat #define PyString_Concat(ps,s) {PyObject* tmp = *(ps); *(ps) = PyUnicode_Concat(tmp,s); Py_DECREF(tmp);} #endif static PyObject* PGFError; static PyObject* ParseError; static PyObject* TypeError; typedef struct { PyObject_HEAD PgfPGF* pgf; } PGFObject; // typedef struct { // PyObject_HEAD // PyObject* master; // GuPool* pool; // PgfExpr expr; // } ExprObject; // // static ExprObject* // Expr_new(PyTypeObject *type, PyObject *args, PyObject *kwds) // { // ExprObject* self = (ExprObject *)type->tp_alloc(type, 0); // if (self != NULL) { // self->master = NULL; // self->pool = NULL; // self->expr = gu_null_variant; // } // // return self; // } // // static void // Expr_dealloc(ExprObject* self) // { // if (self->master != NULL) { // Py_DECREF(self->master); // } // if (self->pool != NULL) { // gu_pool_free(self->pool); // } // // Py_TYPE(self)->tp_free((PyObject*)self); // } // // static PyObject* // Expr_getattro(ExprObject *self, PyObject *attr_name); // // static int // Expr_initMeta(ExprObject *self); // // static int // Expr_initLiteral(ExprObject *self, PyObject *lit); // // static int // Expr_initApp(ExprObject *self, const char* fname, PyObject *args); // // static ExprObject* // Expr_call(ExprObject* e, PyObject* args, PyObject* kw); // // static PyObject* // Expr_unpack(ExprObject* self, PyObject *args); // // static PyObject* // Expr_visit(ExprObject* self, PyObject *args); // // static PyObject* // Expr_reduce_ex(ExprObject* self, PyObject *args); // // static int // Expr_init(ExprObject *self, PyObject *args, PyObject *kwds) // { // Py_ssize_t tuple_size = PyTuple_Size(args); // // if (tuple_size == 0) { // return Expr_initMeta(self); // } else if (tuple_size == 1) { // PyObject* lit = NULL; // if (!PyArg_ParseTuple(args, "O", &lit)) // return -1; // return Expr_initLiteral(self, lit); // } else if (tuple_size == 2) { // const char* fname; // PyObject* list = NULL; // if (!PyArg_ParseTuple(args, "sO!", &fname, &PyList_Type, &list)) // return -1; // return Expr_initApp(self, fname, list); // } else { // PyErr_Format(PyExc_TypeError, "function takes 0, 1 or 2 arguments (%d given)", (int) tuple_size); // return -1; // } // // return 0; // } // // static PyObject * // Expr_repr(ExprObject *self) // { // GuPool* tmp_pool = gu_local_pool(); // // GuExn* err = gu_exn(tmp_pool); // GuStringBuf* sbuf = gu_new_string_buf(tmp_pool); // GuOut* out = gu_string_buf_out(sbuf); // // pgf_print_expr(self->expr, NULL, 0, out, err); // // PyObject* pystr = PyString_FromStringAndSize(gu_string_buf_data(sbuf), // gu_string_buf_length(sbuf)); // // gu_pool_free(tmp_pool); // return pystr; // } // // static PyObject * // Expr_richcompare(ExprObject *e1, ExprObject *e2, int op) // { // bool cmp = pgf_expr_eq(e1->expr,e2->expr); // // if (op == Py_EQ) { // if (cmp) Py_RETURN_TRUE; else Py_RETURN_FALSE; // } else if (op == Py_NE) { // if (cmp) Py_RETURN_FALSE; else Py_RETURN_TRUE; // } else { // PyErr_SetString(PyExc_TypeError, "the operation is not supported"); // return NULL; // } // } // // static long // Expr_hash(ExprObject *e) // { // return (long) pgf_expr_hash(0, e->expr); // } // // static PyMethodDef Expr_methods[] = { // {"unpack", (PyCFunction)Expr_unpack, METH_VARARGS, // "Decomposes an expression into its components" // }, // {"visit", (PyCFunction)Expr_visit, METH_VARARGS, // "Implementation of the visitor pattern for abstract syntax trees. " // "If e is an expression equal to f a1 .. an then " // "e.visit(self) calls method self.on_f(a1,..an). " // "If the method doesn't exist then the method self.default(e) " // "is called." // }, // {"__reduce_ex__", (PyCFunction)Expr_reduce_ex, METH_VARARGS, // "This method allows for transparent pickling/unpickling of expressions." // }, // {NULL} /* Sentinel */ // }; // // static PyGetSetDef Expr_getseters[] = { // {"fun", // NULL, NULL, // "this is the function in a function application", // NULL}, // {"arg", // NULL, NULL, // "this is the argument in a function application", // NULL}, // {"val", // NULL, NULL, // "this is the value of a literal", // NULL}, // {"id", // NULL, NULL, // "this is the id of a meta variable", // NULL}, // {"name", // NULL, NULL, // "this is the name of a function", // NULL}, // {"index", // NULL, NULL, // "this is the de Bruijn index of a variable", // NULL}, // {NULL} /* Sentinel */ // }; // // static PyTypeObject pgf_ExprType = { // PyVarObject_HEAD_INIT(NULL, 0) // //0, /*ob_size*/ // "pgf.Expr", /*tp_name*/ // sizeof(ExprObject), /*tp_basicsize*/ // 0, /*tp_itemsize*/ // (destructor)Expr_dealloc, /*tp_dealloc*/ // 0, /*tp_print*/ // 0, /*tp_getattr*/ // 0, /*tp_setattr*/ // 0, /*tp_compare*/ // 0, /*tp_repr*/ // 0, /*tp_as_number*/ // 0, /*tp_as_sequence*/ // 0, /*tp_as_mapping*/ // (hashfunc) Expr_hash, /*tp_hash */ // (ternaryfunc) Expr_call, /*tp_call*/ // (reprfunc) Expr_repr, /*tp_str*/ // (getattrofunc) Expr_getattro,/*tp_getattro*/ // 0, /*tp_setattro*/ // 0, /*tp_as_buffer*/ // Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE, /*tp_flags*/ // "abstract syntax tree", /*tp_doc*/ // 0, /*tp_traverse */ // 0, /*tp_clear */ // (richcmpfunc) Expr_richcompare, /*tp_richcompare */ // 0, /*tp_weaklistoffset */ // 0, /*tp_iter */ // 0, /*tp_iternext */ // Expr_methods, /*tp_methods */ // 0, /*tp_members */ // Expr_getseters, /*tp_getset */ // 0, /*tp_base */ // 0, /*tp_dict */ // 0, /*tp_descr_get */ // 0, /*tp_descr_set */ // 0, /*tp_dictoffset */ // (initproc)Expr_init, /*tp_init */ // 0, /*tp_alloc */ // (newfunc) Expr_new, /*tp_new */ // }; // // static int // Expr_initMeta(ExprObject *self) // { // self->master = NULL; // self->pool = gu_new_pool(); // PgfExprMeta* e = // gu_new_variant(PGF_EXPR_META, // PgfExprMeta, // &self->expr, self->pool); // e->id = 0; // return 0; // } // // static int // Expr_initLiteral(ExprObject *self, PyObject *lit) // { // self->master = NULL; // self->pool = gu_new_pool(); // PgfExprLit* e = // gu_new_variant(PGF_EXPR_LIT, // PgfExprLit, // &self->expr, self->pool); // e->lit = gu_null_variant; // // if (PyString_Check(lit)) { // char* s; // Py_ssize_t len; // // #if PY_MAJOR_VERSION >= 3 // PyObject* bytes = PyUnicode_AsUTF8String(lit); // if (bytes == NULL) // return -1; // if (PyBytes_AsStringAndSize(bytes,&s,&len) < 0) // return -1; // #else // if (PyString_AsStringAndSize(lit,&s,&len) < 0) // return -1; // #endif // // PgfLiteralStr* slit = // gu_new_flex_variant(PGF_LITERAL_STR, // PgfLiteralStr, // val, len+1, // &e->lit, self->pool); // memcpy(slit->val, s, len+1); // // #if PY_MAJOR_VERSION >= 3 // Py_DECREF(bytes); // #endif // } else if (PyInt_Check(lit)) { // PgfLiteralInt* ilit = // gu_new_variant(PGF_LITERAL_INT, // PgfLiteralInt, // &e->lit, self->pool); // ilit->val = PyInt_AsLong(lit); // } else if (PyFloat_Check(lit)) { // PgfLiteralFlt* flit = // gu_new_variant(PGF_LITERAL_FLT, // PgfLiteralFlt, // &e->lit, self->pool); // flit->val = PyFloat_AsDouble(lit); // } else { // PyErr_SetString(PyExc_TypeError, "the literal must be a string, an integer, or a float"); // return -1; // } // return 0; // } // // static int // Expr_initApp(ExprObject *self, const char* fname, PyObject *args) // { // Py_ssize_t n_args = PyList_Size(args); // // self->master = PyTuple_New(n_args); // if (self->master == NULL) // return -1; // // self->pool = gu_new_pool(); // PgfExprFun* e = // gu_new_flex_variant(PGF_EXPR_FUN, // PgfExprFun, // fun, strlen(fname)+1, // &self->expr, self->pool); // strcpy(e->fun, fname); // // for (Py_ssize_t i = 0; i < n_args; i++) { // PyObject* obj = PyList_GetItem(args, i); // if (obj->ob_type != &pgf_ExprType) { // PyErr_SetString(PyExc_TypeError, "the arguments in the list must be expressions"); // return -1; // } // // PyTuple_SetItem(self->master, i, obj); // Py_INCREF(obj); // // PgfExpr fun = self->expr; // PgfExpr arg = ((ExprObject*) obj)->expr; // // PgfExprApp* e = // gu_new_variant(PGF_EXPR_APP, // PgfExprApp, // &self->expr, self->pool); // e->fun = fun; // e->arg = arg; // } // // return 0; // } // // static ExprObject* // Expr_call(ExprObject* self, PyObject* args, PyObject* kw) // { // ExprObject* pyexpr = (ExprObject*) pgf_ExprType.tp_alloc(&pgf_ExprType, 0); // if (pyexpr == NULL) // return NULL; // // size_t n_args = PyTuple_Size(args); // // pyexpr->master = PyTuple_New(n_args+1); // if (pyexpr->master == NULL) { // Py_DECREF(pyexpr); // return NULL; // } // // PyTuple_SetItem(pyexpr->master, 0, (PyObject*) self); // Py_INCREF(self); // // pyexpr->pool = gu_new_pool(); // pyexpr->expr = self->expr; // // for (Py_ssize_t i = 0; i < n_args; i++) { // PyObject* obj = PyTuple_GetItem(args, i); // if (obj->ob_type != &pgf_ExprType) { // PyErr_SetString(PyExc_TypeError, "the arguments must be expressions"); // return NULL; // } // // PyTuple_SetItem(pyexpr->master, i+1, obj); // Py_INCREF(obj); // // PgfExpr fun = pyexpr->expr; // PgfExpr arg = ((ExprObject*) obj)->expr; // // PgfExprApp* e = // gu_new_variant(PGF_EXPR_APP, // PgfExprApp, // &pyexpr->expr, pyexpr->pool); // e->fun = fun; // e->arg = arg; // } // // return pyexpr; // } // // static PyObject* // Expr_unpack(ExprObject* self, PyObject *fargs) // { // PgfExpr expr = self->expr; // PyObject* args = PyList_New(0); // // for (;;) { // GuVariantInfo i = gu_variant_open(expr); // switch (i.tag) { // case PGF_EXPR_ABS: { // PgfExprAbs* eabs = i.data; // // ExprObject* py_body = (ExprObject*) pgf_ExprType.tp_alloc(&pgf_ExprType, 0); // if (py_body == NULL) { // Py_DECREF(args); // return NULL; // } // py_body->pool = NULL; // py_body->master = (self->master) ? self->master : (PyObject*) self; // py_body->expr = eabs->body; // Py_INCREF(py_body->master); // // PyObject* py_bindtype = // (eabs->bind_type == PGF_BIND_TYPE_EXPLICIT) ? Py_True // : Py_False; // PyObject* py_var = PyString_FromString(eabs->id); // PyObject* res = // Py_BuildValue("OOOO", py_bindtype, py_var, py_body, args); // Py_DECREF(py_var); // Py_DECREF(py_body); // Py_DECREF(args); // return res; // } // case PGF_EXPR_APP: { // PgfExprApp* eapp = i.data; // // ExprObject* pyexpr = (ExprObject*) pgf_ExprType.tp_alloc(&pgf_ExprType, 0); // if (pyexpr == NULL) { // Py_DECREF(args); // return NULL; // } // pyexpr->pool = NULL; // pyexpr->master = (self->master) ? self->master : (PyObject*) self; // pyexpr->expr = eapp->arg; // Py_INCREF(pyexpr->master); // // if (PyList_Insert(args, 0, (PyObject*) pyexpr) == -1) { // Py_DECREF(args); // return NULL; // } // // Py_DECREF((PyObject*) pyexpr); // // expr = eapp->fun; // break; // } // case PGF_EXPR_LIT: { // PgfExprLit* elit = i.data; // // Py_DECREF(args); // // GuVariantInfo i = gu_variant_open(elit->lit); // switch (i.tag) { // case PGF_LITERAL_STR: { // PgfLiteralStr* lstr = i.data; // return PyString_FromString(lstr->val); // } // case PGF_LITERAL_INT: { // PgfLiteralInt* lint = i.data; // return PyInt_FromLong(lint->val); // } // case PGF_LITERAL_FLT: { // PgfLiteralFlt* lflt = i.data; // return PyFloat_FromDouble(lflt->val); // } // default: // gu_impossible(); // return NULL; // } // } // case PGF_EXPR_META: { // PyObject* res = Py_BuildValue("OO", Py_None, args); // Py_DECREF(args); // return res; // } // case PGF_EXPR_FUN: { // PgfExprFun* efun = i.data; // PyObject* fun = PyString_FromString(efun->fun); // PyObject* res = Py_BuildValue("OO", fun, args); // Py_DECREF(fun); // Py_DECREF(args); // return res; // } // case PGF_EXPR_VAR: { // PgfExprVar* evar = i.data; // PyObject* res = Py_BuildValue("iO", evar->var, args); // Py_DECREF(args); // return res; // } // case PGF_EXPR_TYPED: { // PgfExprTyped* etyped = i.data; // expr = etyped->expr; // break; // } // case PGF_EXPR_IMPL_ARG: { // PgfExprImplArg* eimpl = i.data; // expr = eimpl->expr; // break; // } // default: // gu_impossible(); // return NULL; // } // } // return NULL; // } // // static PyObject* // Expr_visit(ExprObject* self, PyObject *args) // { // PyObject* py_visitor = NULL; // PgfExpr expr = self->expr; // if (!PyArg_ParseTuple(args, "O", &py_visitor)) // return NULL; // // GuPool* tmp_pool = gu_local_pool(); // // PgfApplication* app = pgf_expr_unapply(expr, tmp_pool); // if (app != NULL) { // char* method_name = gu_malloc(tmp_pool, strlen(app->fun)+4); // strcpy(method_name, "on_"); // strcat(method_name, app->fun); // // if (PyObject_HasAttrString(py_visitor, method_name)) { // PyObject* method_args = PyTuple_New(app->n_args); // if (method_args == NULL) { // gu_pool_free(tmp_pool); // return NULL; // } // // for (size_t i = 0; i < app->n_args; i++) { // ExprObject* pyarg = (ExprObject*) pgf_ExprType.tp_alloc(&pgf_ExprType, 0); // if (pyarg == NULL) { // Py_DECREF(args); // gu_pool_free(tmp_pool); // return NULL; // } // pyarg->pool = NULL; // pyarg->master = (self->master) ? self->master : (PyObject*) self; // pyarg->expr = app->args[i]; // Py_INCREF(pyarg->master); // // if (PyTuple_SetItem(method_args, i, (PyObject*) pyarg) == -1) { // Py_DECREF(args); // gu_pool_free(tmp_pool); // return NULL; // } // } // // PyObject* method = // PyObject_GetAttrString(py_visitor, method_name); // if (method == NULL) { // Py_DECREF(args); // gu_pool_free(tmp_pool); // return NULL; // } // // gu_pool_free(tmp_pool); // // return PyObject_CallObject(method, method_args); // } // } // // gu_pool_free(tmp_pool); // // return PyObject_CallMethod(py_visitor, "default", "O", self); // } // // static PyObject* // Expr_reduce_ex(ExprObject* 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_readExpr = PyObject_GetAttrString(myModule, "readExpr"); // Py_DECREF(myModule); // if (py_readExpr == NULL) // return NULL; // // PyObject* py_str = Expr_repr(self); // if (py_str == NULL) { // Py_DECREF(py_readExpr); // return NULL; // } // // PyObject* py_tuple = // Py_BuildValue("O(O)", py_readExpr, py_str); // // Py_DECREF(py_str); // Py_DECREF(py_readExpr); // // return py_tuple; // } // // static PyObject* // Expr_getattro(ExprObject *self, PyObject *attr_name) { // #if PY_MAJOR_VERSION >= 3 // #define IS_ATTR(attr) (PyUnicode_CompareWithASCIIString(attr_name,attr) == 0) // #else // const char* name = PyString_AsString(attr_name); // #define IS_ATTR(attr) (strcmp(name, attr) == 0) // #endif // // PgfExpr expr = self->expr; // // redo:; // GuVariantInfo i = gu_variant_open(expr); // switch (i.tag) { // case PGF_EXPR_APP: { // PgfExprApp* eapp = i.data; // // ExprObject* pyexpr = (ExprObject*) pgf_ExprType.tp_alloc(&pgf_ExprType, 0); // if (pyexpr == NULL) // return NULL; // pyexpr->pool = NULL; // pyexpr->master = (self->master) ? self->master : (PyObject*) self; // pyexpr->expr = gu_null_variant; // Py_INCREF(pyexpr->master); // // if (IS_ATTR("fun")) { // pyexpr->expr = eapp->fun; // return ((PyObject*) pyexpr); // } else if (IS_ATTR("arg")) { // pyexpr->expr = eapp->arg; // return ((PyObject*) pyexpr); // } else { // Py_DECREF(pyexpr); // } // break; // } // case PGF_EXPR_LIT: { // PgfExprLit* elit = i.data; // // if (IS_ATTR("val")) { // GuVariantInfo i = gu_variant_open(elit->lit); // switch (i.tag) { // case PGF_LITERAL_INT: { // PgfLiteralInt* lint = i.data; // return PyInt_FromLong(lint->val); // } // case PGF_LITERAL_FLT: { // PgfLiteralFlt* lflt = i.data; // return PyFloat_FromDouble(lflt->val); // } // case PGF_LITERAL_STR: { // PgfLiteralStr* lstr = i.data; // return PyString_FromString(lstr->val); // } // } // } // break; // } // case PGF_EXPR_META: { // PgfExprMeta* emeta = i.data; // if (IS_ATTR("id")) // return PyInt_FromLong(emeta->id); // break; // } // case PGF_EXPR_FUN: { // PgfExprFun* efun = i.data; // if (IS_ATTR("name")) { // return PyString_FromString(efun->fun); // } // break; // } // case PGF_EXPR_VAR: { // PgfExprVar* evar = i.data; // if (IS_ATTR("index")) { // return PyInt_FromLong(evar->var); // } // break; // } // case PGF_EXPR_TYPED: { // PgfExprTyped* etyped = i.data; // expr = etyped->expr; // goto redo; // } // case PGF_EXPR_IMPL_ARG: { // PgfExprImplArg* eimpl = i.data; // expr = eimpl->expr; // goto redo; // } // default: // gu_impossible(); // } // // return PyObject_GenericGetAttr((PyObject*)self, attr_name); // } // // typedef struct { // PyObject_HEAD // PyObject* master; // GuPool* pool; // PgfType* type; // } TypeObject; // // static PyTypeObject pgf_TypeType; // // static TypeObject* // Type_new(PyTypeObject *type, PyObject *args, PyObject *kwds) // { // TypeObject* self = (TypeObject *)type->tp_alloc(type, 0); // if (self != NULL) { // self->master = NULL; // self->pool = NULL; // self->type = NULL; // } // // return self; // } // // static void // Type_dealloc(TypeObject* self) // { // if (self->master != NULL) { // Py_DECREF(self->master); // } // if (self->pool != NULL) { // gu_pool_free(self->pool); // } // // Py_TYPE(self)->tp_free((PyObject*)self); // } // // static int // Type_init(TypeObject *self, PyObject *args, PyObject *kwds) // { // PyObject* py_hypos; // const char* catname_s; // PyObject* py_exprs; // size_t n_exprs; // size_t n_hypos; // // if (PyTuple_Size(args) == 1) { // py_hypos = NULL; // py_exprs = NULL; // n_exprs = 0; // n_hypos = 0; // if (!PyArg_ParseTuple(args, "s", &catname_s)) // return -1; // } else { // if (!PyArg_ParseTuple(args, "O!sO!", // &PyList_Type, &py_hypos, // &catname_s, // &PyList_Type, &py_exprs)) // return -1; // // n_exprs = PyList_Size(py_exprs); // n_hypos = PyList_Size(py_hypos); // } // // self->pool = gu_new_pool(); // self->master = // (n_exprs+n_hypos > 0) ? PyTuple_New(n_exprs+n_hypos) : NULL; // // self->type = gu_new_flex(self->pool, PgfType, exprs, n_exprs); // // self->type->hypos = // gu_new_seq(PgfHypo, n_hypos, self->pool); // // for (size_t i = 0; i < n_hypos; i++) { // PyObject* obj = PyList_GetItem(py_hypos, i); // PyObject* py_bindtype; // PgfCId cid; // PyObject* py_type; // // if (Py_TYPE(obj) == &pgf_TypeType) { // py_bindtype = Py_True; // cid = "_"; // py_type = obj; // } else { // if (!PyTuple_Check(obj) || // PyTuple_GET_SIZE(obj) != 3) { // PyErr_SetString(PyExc_TypeError, "the arguments in the first list must be triples of (boolean,string,pgf.Type)"); // return -1; // } // // py_bindtype = PyTuple_GetItem(obj, 0); // if (!PyBool_Check(py_bindtype)) { // PyErr_SetString(PyExc_TypeError, "the arguments in the first list must be triples of (boolean,string,pgf.Type)"); // return -1; // } // // PyObject* py_var = PyTuple_GetItem(obj, 1); // if (!PyString_Check(py_var)) { // PyErr_SetString(PyExc_TypeError, "the arguments in the first list must be triples of (boolean,string,pgf.Type)"); // return -1; // } // // { // char* s; // Py_ssize_t len; // // #if PY_MAJOR_VERSION >= 3 // PyObject* bytes = PyUnicode_AsUTF8String(py_var); // if (bytes == NULL) // return -1; // if (PyBytes_AsStringAndSize(bytes,&s,&len) < 0) // return -1; // #else // if (PyString_AsStringAndSize(py_var,&s,&len) < 0) // return -1; // #endif // // cid = gu_malloc(self->pool, len+1); // memcpy((char*)cid, s, len+1); // // #if PY_MAJOR_VERSION >= 3 // Py_DECREF(bytes); // #endif // } // // py_type = PyTuple_GetItem(obj, 2); // if (Py_TYPE(py_type) != &pgf_TypeType) { // PyErr_SetString(PyExc_TypeError, "the arguments in the first list must be triples of (boolean,string,pgf.Type)"); // return -1; // } // } // // PgfHypo* hypo = gu_seq_index(self->type->hypos, PgfHypo, i); // hypo->bind_type = // (py_bindtype == Py_True) ? PGF_BIND_TYPE_EXPLICIT // : PGF_BIND_TYPE_IMPLICIT; // hypo->cid = cid; // hypo->type = ((TypeObject*) py_type)->type; // // PyTuple_SetItem(self->master, i, py_type); // Py_INCREF(py_type); // } // // self->type->cid = gu_string_copy(catname_s, self->pool); // // self->type->n_exprs = n_exprs; // for (Py_ssize_t i = 0; i < n_exprs; i++) { // PyObject* obj = PyList_GetItem(py_exprs, i); // if (Py_TYPE(obj) != &pgf_ExprType) { // PyErr_SetString(PyExc_TypeError, "the arguments in the second list must be expressions"); // return -1; // } // // PyTuple_SetItem(self->master, n_hypos+i, obj); // Py_INCREF(obj); // // self->type->exprs[i] = ((ExprObject*) obj)->expr; // } // // return 0; // } // // static PyObject * // Type_repr(TypeObject *self) // { // GuPool* tmp_pool = gu_local_pool(); // // GuExn* err = gu_exn(tmp_pool); // GuStringBuf* sbuf = gu_new_string_buf(tmp_pool); // GuOut* out = gu_string_buf_out(sbuf); // // pgf_print_type(self->type, NULL, 0, out, err); // // PyObject* pystr = PyString_FromStringAndSize(gu_string_buf_data(sbuf), // gu_string_buf_length(sbuf)); // // gu_pool_free(tmp_pool); // return pystr; // } // // static PyObject * // Type_richcompare(TypeObject *t1, TypeObject *t2, int op) // { // bool cmp = pgf_type_eq(t1->type,t2->type); // // if (op == Py_EQ) { // if (cmp) Py_RETURN_TRUE; else Py_RETURN_FALSE; // } else if (op == Py_NE) { // if (cmp) Py_RETURN_FALSE; else Py_RETURN_TRUE; // } else { // PyErr_SetString(PyExc_TypeError, "the operation is not supported"); // return NULL; // } // } // // static PyObject* // Type_getHypos(TypeObject *self, void *closure) // { // PgfType* type = self->type; // // PyObject* py_hypos = PyList_New(0); // if (py_hypos == NULL) // return NULL; // // size_t n_hypos = gu_seq_length(type->hypos); // for (size_t i = 0; i < n_hypos; i++) { // PgfHypo* hypo = gu_seq_index(type->hypos, PgfHypo, i); // // PyObject* py_bindtype = // (hypo->bind_type == PGF_BIND_TYPE_EXPLICIT) ? Py_True // : Py_False; // // PyObject* py_var = PyString_FromString(hypo->cid); // if (py_var == NULL) // goto fail; // // TypeObject* py_type = (TypeObject*) pgf_TypeType.tp_alloc(&pgf_TypeType, 0); // if (py_type == NULL) { // Py_DECREF(py_var); // goto fail; // } // // py_type->pool = NULL; // py_type->master = (PyObject*) self; // py_type->type = hypo->type; // Py_INCREF(self); // // PyObject* py_hypo = // Py_BuildValue("OOO", py_bindtype, py_var, py_type); // Py_DECREF(py_var); // Py_DECREF(py_type); // // if (py_hypo == NULL) // goto fail; // // if (PyList_Append(py_hypos, (PyObject*) py_hypo) == -1) // goto fail; // // Py_DECREF(py_hypo); // } // // return py_hypos; // // fail: // Py_DECREF(py_hypos); // return NULL; // } // // static PyObject* // Type_getCat(TypeObject *self, void *closure) // { // return PyString_FromString(self->type->cid); // } // // static PyObject* // Type_getExprs(TypeObject *self, void *closure) // { // PgfType* type = self->type; // // PyObject* py_exprs = PyList_New(0); // if (py_exprs == NULL) // return NULL; // // for (size_t i = 0; i < type->n_exprs; i++) { // ExprObject* py_expr = // (ExprObject*) pgf_ExprType.tp_alloc(&pgf_ExprType, 0); // if (py_expr == NULL) // goto fail; // py_expr->pool = NULL; // py_expr->master = (PyObject*) self; // py_expr->expr = type->exprs[i]; // Py_INCREF(py_expr->master); // // if (PyList_Append(py_exprs, (PyObject*) py_expr) == -1) // goto fail; // // Py_DECREF((PyObject*) py_expr); // } // // return py_exprs; // // fail: // Py_DECREF(py_exprs); // return NULL; // } // // static PyObject* // Type_unpack(TypeObject* self, PyObject *fargs) // { // PyObject* res = NULL; // PyObject* py_hypos = NULL; // PyObject* py_cat = NULL; // PyObject* py_exprs = NULL; // // py_hypos = Type_getHypos(self, NULL); // if (py_hypos == NULL) // goto fail; // // py_cat = Type_getCat(self, NULL); // if (py_cat == NULL) // goto fail; // // py_exprs = Type_getExprs(self, NULL); // if (py_exprs == NULL) // goto fail; // // res = Py_BuildValue("OOO", py_hypos, py_cat, py_exprs); // // fail: // Py_XDECREF(py_hypos); // Py_XDECREF(py_cat); // Py_XDECREF(py_exprs); // return res; // } // // 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_repr(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 */ // }; // // static PyGetSetDef Type_getseters[] = { // {"hypos", // (getter)Type_getHypos, NULL, // "this is the list of hypotheses in the type signature", // NULL}, // {"cat", // (getter)Type_getCat, NULL, // "this is the name of the category", // NULL}, // {"exprs", // (getter)Type_getExprs, NULL, // "this is the list of indices for the category", // NULL}, // {NULL} /* Sentinel */ // }; // // static PyTypeObject pgf_TypeType = { // PyVarObject_HEAD_INIT(NULL, 0) // //0, /*ob_size*/ // "pgf.Type", /*tp_name*/ // sizeof(TypeObject), /*tp_basicsize*/ // 0, /*tp_itemsize*/ // (destructor)Type_dealloc, /*tp_dealloc*/ // 0, /*tp_print*/ // 0, /*tp_getattr*/ // 0, /*tp_setattr*/ // 0, /*tp_compare*/ // 0, /*tp_repr*/ // 0, /*tp_as_number*/ // 0, /*tp_as_sequence*/ // 0, /*tp_as_mapping*/ // 0, /*tp_hash */ // 0, /*tp_call*/ // (reprfunc) Type_repr, /*tp_str*/ // 0, /*tp_getattro*/ // 0, /*tp_setattro*/ // 0, /*tp_as_buffer*/ // Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE, /*tp_flags*/ // "abstract syntax type", /*tp_doc*/ // 0, /*tp_traverse */ // 0, /*tp_clear */ // (richcmpfunc) Type_richcompare, /*tp_richcompare */ // 0, /*tp_weaklistoffset */ // 0, /*tp_iter */ // 0, /*tp_iternext */ // Type_methods, /*tp_methods */ // 0, /*tp_members */ // Type_getseters, /*tp_getset */ // 0, /*tp_base */ // 0, /*tp_dict */ // 0, /*tp_descr_get */ // 0, /*tp_descr_set */ // 0, /*tp_dictoffset */ // (initproc)Type_init, /*tp_init */ // 0, /*tp_alloc */ // (newfunc) Type_new, /*tp_new */ // }; // // typedef struct IterObject { // PyObject_HEAD // PyObject* source; // PyObject* container; // GuPool* pool; // int max_count; // int counter; // GuEnum* res; // PyObject* (*fetch)(struct IterObject* self); // } IterObject; // // static PyObject* // Iter_fetch_expr(IterObject* self) // { // PgfExprProb* ep = gu_next(self->res, PgfExprProb*, self->pool); // if (ep == NULL) // return NULL; // // ExprObject* pyexpr = (ExprObject*) pgf_ExprType.tp_alloc(&pgf_ExprType, 0); // if (pyexpr == NULL) // return NULL; // pyexpr->pool = NULL; // pyexpr->expr = ep->expr; // pyexpr->master = self->container; // Py_XINCREF(self->container); // // PyObject* res = Py_BuildValue("(f,O)", ep->prob, pyexpr); // Py_DECREF(pyexpr); // // return res; // } // // static PyObject* // Iter_fetch_token(IterObject* self) // { // PgfTokenProb* tp = gu_next(self->res, PgfTokenProb*, self->pool); // if (tp == NULL) // return NULL; // // PyObject* py_tok = PyString_FromString(tp->tok); // PyObject* py_cat = PyString_FromString(tp->cat); // PyObject* py_fun = PyString_FromString(tp->fun); // PyObject* res = Py_BuildValue("(f,O,O,O)", tp->prob, py_tok, py_cat, py_fun); // Py_DECREF(py_fun); // Py_DECREF(py_cat); // Py_DECREF(py_tok); // // return res; // } // // // static IterObject* // Iter_new(PyTypeObject *type, PyObject *args, PyObject *kwds) // { // IterObject* self = (IterObject *)type->tp_alloc(type, 0); // if (self != NULL) { // self->source = NULL; // self->container = NULL; // self->pool = NULL; // self->max_count = -1; // self->counter = 0; // self->res = NULL; // } // // return self; // } // // static void // Iter_dealloc(IterObject* self) // { // if (self->pool != NULL) // gu_pool_free(self->pool); // // Py_XDECREF(self->source); // // Py_XDECREF(self->container); // // Py_TYPE(self)->tp_free((PyObject*)self); // } // // static int // Iter_init(IterObject *self, PyObject *args, PyObject *kwds) // { // return -1; // } // // static PyObject* // Iter_iter(IterObject *self) // { // Py_INCREF(self); // return (PyObject*) self; // } // // static PyObject* // Iter_iternext(IterObject *self) // { // if (self->max_count >= 0 && self->counter >= self->max_count) { // return NULL; // } // self->counter++; // // return self->fetch(self); // } // // static PyMethodDef Iter_methods[] = { // {NULL} /* Sentinel */ // }; // // static PyTypeObject pgf_IterType = { // PyVarObject_HEAD_INIT(NULL, 0) // //0, /*ob_size*/ // "pgf.Iter", /*tp_name*/ // sizeof(IterObject), /*tp_basicsize*/ // 0, /*tp_itemsize*/ // (destructor)Iter_dealloc, /*tp_dealloc*/ // 0, /*tp_print*/ // 0, /*tp_getattr*/ // 0, /*tp_setattr*/ // 0, /*tp_compare*/ // 0, /*tp_repr*/ // 0, /*tp_as_number*/ // 0, /*tp_as_sequence*/ // 0, /*tp_as_mapping*/ // 0, /*tp_hash */ // 0, /*tp_call*/ // 0, /*tp_str*/ // 0, /*tp_getattro*/ // 0, /*tp_setattro*/ // 0, /*tp_as_buffer*/ // Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE, /*tp_flags*/ // "an iterator over a sequence of expressions",/*tp_doc*/ // 0, /*tp_traverse */ // 0, /*tp_clear */ // 0, /*tp_richcompare */ // 0, /*tp_weaklistoffset */ // (getiterfunc) Iter_iter, /*tp_iter */ // (iternextfunc) Iter_iternext, /*tp_iternext */ // Iter_methods, /*tp_methods */ // 0, /*tp_members */ // 0, /*tp_getset */ // 0, /*tp_base */ // 0, /*tp_dict */ // 0, /*tp_descr_get */ // 0, /*tp_descr_set */ // 0, /*tp_dictoffset */ // (initproc)Iter_init, /*tp_init */ // 0, /*tp_alloc */ // (newfunc) Iter_new, /*tp_new */ // }; // // typedef struct { // PyObject_HEAD // PGFObject* grammar; // PgfConcr* concr; // } ConcrObject; // // static ConcrObject* // Concr_new(PyTypeObject *type, PyObject *args, PyObject *kwds) // { // ConcrObject* self = (ConcrObject *)type->tp_alloc(type, 0); // if (self != NULL) { // self->grammar = NULL; // self->concr = NULL; // } // // return self; // } // // static void // Concr_dealloc(ConcrObject* self) // { // Py_XDECREF(self->grammar); // Py_TYPE(self)->tp_free((PyObject*)self); // } // // static int // Concr_init(ConcrObject *self, PyObject *args, PyObject *kwds) // { // return -1; // } // // static PyObject* // Concr_printName(ConcrObject* self, PyObject *args) // { // GuString id; // if (!PyArg_ParseTuple(args, "s", &id)) // return NULL; // // GuString name = pgf_print_name(self->concr, id); // if (name == NULL) // Py_RETURN_NONE; // // return PyString_FromString(name); // } // // #if ( (PY_VERSION_HEX < 0x02070000) \ // || ((PY_VERSION_HEX >= 0x03000000) \ // && (PY_VERSION_HEX < 0x03010000)) ) // // #define PyPool_New(pool) \ // PyCObject_FromVoidPtr(pool, gu_pool_free) // // #else // // #define PGF_CONTAINER_NAME "pgf.Container" // // static void pypgf_container_descructor(PyObject *capsule) // { // GuPool* pool = PyCapsule_GetPointer(capsule, PGF_CONTAINER_NAME); // gu_pool_free(pool); // } // // #define PyPool_New(pool) \ // PyCapsule_New(pool, PGF_CONTAINER_NAME, \ // pypgf_container_descructor) // // #endif // // typedef struct { // PgfLiteralCallback callback; // PyObject* pycallback; // GuFinalizer fin; // } PyPgfLiteralCallback; // // #if PY_MAJOR_VERSION >= 3 // static size_t // utf8_to_unicode_offset(GuString sentence, size_t offset) // { // const uint8_t* start = (uint8_t*) sentence; // const uint8_t* end = start+offset; // // size_t chars = 0; // while (start < end) { // gu_utf8_decode(&start); // chars++; // } // // return chars; // } // // static size_t // unicode_to_utf8_offset(GuString sentence, size_t chars) // { // const uint8_t* start = (uint8_t*) sentence; // const uint8_t* end = start; // // while (chars > 0) { // GuUCS ucs = gu_utf8_decode(&end); // if (ucs == 0) // break; // chars--; // } // // return (end-start); // } // #endif // // static PgfExprProb* // pypgf_literal_callback_match(PgfLiteralCallback* self, PgfConcr* concr, // GuString ann, // GuString sentence, size_t* poffset, // GuPool *out_pool) // { // PyPgfLiteralCallback* callback = // gu_container(self, PyPgfLiteralCallback, callback); // // PyObject* result = // PyObject_CallFunction(callback->pycallback, "si", // ann, // #if PY_MAJOR_VERSION >= 3 // utf8_to_unicode_offset(sentence, *poffset) // #else // *poffset // #endif // ); // if (result == NULL) { // PyErr_Print(); // return NULL; // } // // if (result == Py_None) { // Py_DECREF(result); // return NULL; // } // // PgfExprProb* ep = gu_new(PgfExprProb, out_pool); // // ExprObject* pyexpr; // #if PY_MAJOR_VERSION >= 3 // int chars; // if (!PyArg_ParseTuple(result, "Ofi", &pyexpr, &ep->prob, &chars)) // return NULL; // *poffset = unicode_to_utf8_offset(sentence, chars); // #else // if (!PyArg_ParseTuple(result, "Ofi", &pyexpr, &ep->prob, poffset)) // return NULL; // #endif // // ep->expr = pgf_clone_expr(pyexpr->expr, out_pool); // // Py_DECREF(result); // // return ep; // } // // static GuEnum* // pypgf_literal_callback_predict(PgfLiteralCallback* self, PgfConcr* concr, // GuString ann, // GuString prefix, // GuPool *out_pool) // { // return NULL; // } // // static void // pypgf_literal_callback_fin(GuFinalizer* self) // { // PyPgfLiteralCallback* callback = // gu_container(self, PyPgfLiteralCallback, fin); // // Py_XDECREF(callback->pycallback); // } // // static PgfCallbacksMap* // pypgf_new_callbacks_map(PgfConcr* concr, PyObject *py_callbacks, // GuPool* pool) // { // PgfCallbacksMap* callbacks = // pgf_new_callbacks_map(concr, pool); // // if (py_callbacks == NULL) // return callbacks; // // size_t n_callbacks = PyList_Size(py_callbacks); // for (size_t i = 0; i < n_callbacks; i++) { // PyObject* item = // PyList_GetItem(py_callbacks, i); // // PyObject* pycallback = NULL; // const char* cat = NULL; // if (!PyArg_ParseTuple(item, "sO", &cat, &pycallback)) // return NULL; // // PyPgfLiteralCallback* callback = gu_new(PyPgfLiteralCallback, pool); // callback->callback.match = pypgf_literal_callback_match; // callback->callback.predict = pypgf_literal_callback_predict; // callback->pycallback = pycallback; // callback->fin.fn = pypgf_literal_callback_fin; // // Py_XINCREF(callback->pycallback); // // gu_pool_finally(pool, &callback->fin); // // pgf_callbacks_map_add_literal(concr, callbacks, // cat, &callback->callback); // } // // return callbacks; // } // // static PgfType* // pgf_type_from_object(PyObject* obj, GuPool* pool) { // if (PyString_Check(obj)) { // PgfType* type = gu_new_flex(pool, PgfType, exprs, 0); // type->hypos = gu_empty_seq(); // type->cid = ""; // type->n_exprs = 0; // return type; // } else if (obj->ob_type == &pgf_TypeType) { // return ((TypeObject*) obj)->type; // } else { // PyErr_SetString(PyExc_TypeError, "the start category should be a string or a type"); // return NULL; // } // } // // static IterObject* // Concr_parse(ConcrObject* self, PyObject *args, PyObject *keywds) // { // static char *kwlist[] = {"sentence", "cat", "n", "heuristics", "callbacks", NULL}; // // const char *sentence = NULL; // PyObject* start = NULL; // int max_count = -1; // double heuristics = -1; // PyObject* py_callbacks = NULL; // if (!PyArg_ParseTupleAndKeywords(args, keywds, "s|OidO!", kwlist, // &sentence, &start, &max_count, // &heuristics, // &PyList_Type, &py_callbacks)) // return NULL; // // IterObject* pyres = (IterObject*) // pgf_IterType.tp_alloc(&pgf_IterType, 0); // if (pyres == NULL) { // return NULL; // } // // pyres->source = (PyObject*) self->grammar; // Py_XINCREF(pyres->source); // // GuPool* out_pool = gu_new_pool(); // // PyObject* py_pool = PyPool_New(out_pool); // pyres->container = PyTuple_Pack(2, pyres->source, py_pool); // Py_DECREF(py_pool); // // pyres->pool = gu_new_pool(); // pyres->max_count = max_count; // pyres->counter = 0; // pyres->fetch = Iter_fetch_expr; // // GuExn* parse_err = gu_exn(pyres->pool); // // PgfCallbacksMap* callbacks = // pypgf_new_callbacks_map(self->concr, py_callbacks, pyres->pool); // if (callbacks == NULL) { // Py_DECREF(pyres); // return NULL; // } // // sentence = gu_string_copy(sentence, pyres->pool); // // PgfType* type; // if (start == NULL) { // type = pgf_start_cat(self->grammar->pgf, pyres->pool); // } else { // type = pgf_type_from_object(start, pyres->pool); // } // if (type == NULL) { // Py_DECREF(pyres); // return NULL; // } // // pyres->res = // pgf_parse_with_heuristics(self->concr, type, sentence, // heuristics, callbacks, parse_err, // pyres->pool, out_pool); // // if (!gu_ok(parse_err)) { // if (gu_exn_caught(parse_err, PgfExn)) { // GuString msg = (GuString) gu_exn_caught_data(parse_err); // PyErr_SetString(PGFError, msg); // } else if (gu_exn_caught(parse_err, PgfParseError)) { // PgfParseError* err = (PgfParseError*) gu_exn_caught_data(parse_err); // PyObject* py_offset = PyInt_FromLong(err->offset); // if (err->incomplete) { // PyObject_SetAttrString(ParseError, "incomplete", Py_True); // PyObject_SetAttrString(ParseError, "offset", py_offset); // PyErr_Format(ParseError, "The sentence is incomplete"); // } else { // PyObject* py_tok = PyString_FromStringAndSize(err->token_ptr, // err->token_len); // PyObject_SetAttrString(ParseError, "incomplete", Py_False); // PyObject_SetAttrString(ParseError, "offset", py_offset); // PyObject_SetAttrString(ParseError, "token", py_tok); // #if PY_MAJOR_VERSION >= 3 // PyErr_Format(ParseError, "Unexpected token: \"%U\"", py_tok); // #else // PyErr_Format(ParseError, "Unexpected token: \"%s\"", PyString_AsString(py_tok)); // #endif // Py_DECREF(py_tok); // } // Py_DECREF(py_offset); // } // // Py_DECREF(pyres); // pyres = NULL; // } // // return pyres; // } // // static IterObject* // Concr_complete(ConcrObject* self, PyObject *args, PyObject *keywds) // { // static char *kwlist[] = {"sentence", "cat", "prefix", "n", NULL}; // // const char *sentence = NULL; // PyObject* start = NULL; // GuString prefix = ""; // int max_count = -1; // if (!PyArg_ParseTupleAndKeywords(args, keywds, "s|Osi", kwlist, // &sentence, &start, // &prefix, &max_count)) // return NULL; // // IterObject* pyres = (IterObject*) // pgf_IterType.tp_alloc(&pgf_IterType, 0); // if (pyres == NULL) { // return NULL; // } // // pyres->source = (PyObject*) self->grammar; // Py_XINCREF(pyres->source); // // pyres->container = NULL; // // pyres->pool = gu_new_pool(); // pyres->max_count = max_count; // pyres->counter = 0; // pyres->fetch = Iter_fetch_token; // // GuPool *tmp_pool = gu_local_pool(); // // GuExn* parse_err = gu_new_exn(tmp_pool); // // PgfType* type; // if (start == NULL) { // type = pgf_start_cat(self->grammar->pgf, pyres->pool); // } else { // type = pgf_type_from_object(start, pyres->pool); // } // if (type == NULL) { // Py_DECREF(pyres); // return NULL; // } // // pyres->res = // pgf_complete(self->concr, type, sentence, prefix, parse_err, pyres->pool); // // if (!gu_ok(parse_err)) { // Py_DECREF(pyres); // pyres = NULL; // // if (gu_exn_caught(parse_err, PgfExn)) { // GuString msg = (GuString) gu_exn_caught_data(parse_err); // PyErr_SetString(PGFError, msg); // } else if (gu_exn_caught(parse_err, PgfParseError)) { // GuString tok = (GuString) gu_exn_caught_data(parse_err); // PyObject* py_tok = PyString_FromString(tok); // PyObject_SetAttrString(ParseError, "token", py_tok); // PyErr_Format(ParseError, "Unexpected token: \"%s\"", tok); // Py_DECREF(py_tok); // } // } // // gu_pool_free(tmp_pool); // // return pyres; // } // // static PyObject* // Concr_parseval(ConcrObject* self, PyObject *args) { // ExprObject* pyexpr = NULL; // PyObject* start = NULL; // if (!PyArg_ParseTuple(args, "O!s", &pgf_ExprType, &pyexpr, &start)) // return NULL; // // GuPool* tmp_pool = gu_local_pool(); // // double precision = 0; // double recall = 0; // double exact = 0; // // PgfType* type = pgf_type_from_object(start, tmp_pool); // if (type == NULL) { // return NULL; // } // // if (!pgf_parseval(self->concr, pyexpr->expr, type, // &precision, &recall, &exact)) // return NULL; // // gu_pool_free(tmp_pool); // // return Py_BuildValue("ddd", precision, recall, exact); // } // // static IterObject* // Concr_lookupSentence(ConcrObject* self, PyObject *args, PyObject *keywds) // { // static char *kwlist[] = {"sentence", "cat", NULL}; // // const char *sentence = NULL; // PyObject* start = NULL; // int max_count = -1; // if (!PyArg_ParseTupleAndKeywords(args, keywds, "s|O", kwlist, // &sentence, &start, &max_count)) // return NULL; // // IterObject* pyres = (IterObject*) // pgf_IterType.tp_alloc(&pgf_IterType, 0); // if (pyres == NULL) { // return NULL; // } // // pyres->source = (PyObject*) self->grammar; // Py_XINCREF(pyres->source); // // GuPool* out_pool = gu_new_pool(); // // PyObject* py_pool = PyPool_New(out_pool); // pyres->container = PyTuple_Pack(2, pyres->source, py_pool); // Py_DECREF(py_pool); // // pyres->pool = gu_new_pool(); // pyres->max_count = max_count; // pyres->counter = 0; // pyres->fetch = Iter_fetch_expr; // // sentence = gu_string_copy(sentence, pyres->pool); // // PgfType* type; // if (start == NULL) { // type = pgf_start_cat(self->grammar->pgf, pyres->pool); // } else { // type = pgf_type_from_object(start, pyres->pool); // } // if (type == NULL) { // Py_DECREF(pyres); // return NULL; // } // // pyres->res = // pgf_lookup_sentence(self->concr, type, sentence, // pyres->pool, out_pool); // // return pyres; // } // // static PyObject* // Concr_linearize(ConcrObject* self, PyObject *args) // { // ExprObject* pyexpr; // if (!PyArg_ParseTuple(args, "O!", &pgf_ExprType, &pyexpr)) // return NULL; // // GuPool* tmp_pool = gu_local_pool(); // GuExn* err = gu_exn(tmp_pool); // GuStringBuf* sbuf = gu_new_string_buf(tmp_pool); // GuOut* out = gu_string_buf_out(sbuf); // // pgf_linearize(self->concr, pyexpr->expr, out, err); // if (!gu_ok(err)) { // if (gu_exn_caught(err, PgfLinNonExist)) { // gu_pool_free(tmp_pool); // Py_RETURN_NONE; // } // else if (gu_exn_caught(err, PgfExn)) { // GuString msg = (GuString) gu_exn_caught_data(err); // PyErr_SetString(PGFError, msg); // gu_pool_free(tmp_pool); // return NULL; // } else { // PyErr_SetString(PGFError, "The abstract tree cannot be linearized"); // gu_pool_free(tmp_pool); // return NULL; // } // } // // PyObject* pystr = PyString_FromStringAndSize(gu_string_buf_data(sbuf), // gu_string_buf_length(sbuf)); // // gu_pool_free(tmp_pool); // return pystr; // } // // static PyObject* // Iter_fetch_linearization(IterObject* self) // { // GuPool* tmp_pool = gu_local_pool(); // GuExn* err = gu_new_exn(tmp_pool); // // restart:; // GuStringBuf* sbuf = gu_new_string_buf(tmp_pool); // GuOut* out = gu_string_buf_out(sbuf); // // // PgfCncTree ctree = gu_next(self->res, PgfCncTree, tmp_pool); // if (gu_variant_is_null(ctree)) { // gu_pool_free(tmp_pool); // return NULL; // } // ctree = pgf_lzr_wrap_linref(ctree, tmp_pool); // to reduce tuple of strings to a single string; // // // Linearize the concrete tree as a simple sequence of strings. // ConcrObject* pyconcr = (ConcrObject*)self->container; // pgf_lzr_linearize_simple(pyconcr->concr, ctree, 0, out, err, tmp_pool); // // if (!gu_ok(err)) { // if (gu_exn_caught(err, PgfLinNonExist)) { // // encountered nonExist. Unfortunately there // // might be some output printed already. The // // right solution should be to use GuStringBuf. // gu_exn_clear(err); // goto restart; // } // else if (gu_exn_caught(err, PgfExn)) { // GuString msg = (GuString) gu_exn_caught_data(err); // PyErr_SetString(PGFError, msg); // gu_pool_free(tmp_pool); // return NULL; // } else { // PyErr_SetString(PGFError, "The abstract tree cannot be linearized"); // gu_pool_free(tmp_pool); // return NULL; // } // } // // PyObject* pystr = PyString_FromStringAndSize(gu_string_buf_data(sbuf), // gu_string_buf_length(sbuf)); // gu_pool_free(tmp_pool); // return pystr; // } // // static PyObject* // Concr_linearizeAll(ConcrObject* self, PyObject *args, PyObject *keywds) // { // static char *kwlist[] = {"expression", "n", NULL}; // ExprObject* pyexpr = NULL; // int max_count = -1; // if (!PyArg_ParseTupleAndKeywords(args, keywds, "O!|i", kwlist, // &pgf_ExprType, &pyexpr, &max_count)) // return NULL; // // GuPool* pool = gu_new_pool(); // // GuExn* err = gu_exn(pool); // GuEnum* cts = pgf_lzr_concretize(self->concr, pyexpr->expr, err, pool); // if (!gu_ok(err)) { // if (gu_exn_caught(err, PgfExn)) { // GuString msg = (GuString) gu_exn_caught_data(err); // PyErr_SetString(PGFError, msg); // gu_pool_free(pool); // return NULL; // } else { // PyErr_SetString(PGFError, "The abstract tree cannot be linearized"); // gu_pool_free(pool); // return NULL; // } // } // // IterObject* pyres = (IterObject*) pgf_IterType.tp_alloc(&pgf_IterType, 0); // if (pyres == NULL) { // gu_pool_free(pool); // return NULL; // } // // pyres->source = (PyObject*)pyexpr; // Py_INCREF(pyres->source); // pyres->container = (PyObject*)self; // Py_INCREF(pyres->container); // pyres->pool = pool; // pyres->max_count = max_count; // pyres->counter = 0; // pyres->fetch = Iter_fetch_linearization; // pyres->res = cts; // // return (PyObject*)pyres; // } // // static PyObject* // Concr_tabularLinearize(ConcrObject* self, PyObject *args) // { // ExprObject* pyexpr; // if (!PyArg_ParseTuple(args, "O!", &pgf_ExprType, &pyexpr)) // return NULL; // // PyObject* table = PyDict_New(); // if (table == NULL) // return NULL; // // GuPool* tmp_pool = gu_local_pool(); // GuExn* err = gu_exn(tmp_pool); // // GuEnum* cts = // pgf_lzr_concretize(self->concr, // pyexpr->expr, // err, // tmp_pool); // if (!gu_ok(err)) { // if (gu_exn_caught(err, PgfLinNonExist)) // Py_RETURN_NONE; // else if (gu_exn_caught(err, PgfExn)) { // GuString msg = (GuString) gu_exn_caught_data(err); // PyErr_SetString(PGFError, msg); // return NULL; // } else { // PyErr_SetString(PGFError, "The abstract tree cannot be linearized"); // return NULL; // } // } // // PgfCncTree ctree = gu_next(cts, PgfCncTree, tmp_pool); // if (gu_variant_is_null(ctree)) { // gu_pool_free(tmp_pool); // return NULL; // } // // size_t n_lins; // GuString* labels; // pgf_lzr_get_table(self->concr, ctree, &n_lins, &labels); // // GuStringBuf* sbuf = gu_new_string_buf(tmp_pool); // GuOut* out = gu_string_buf_out(sbuf); // // for (size_t lin_idx = 0; lin_idx < n_lins; lin_idx++) { // // // pgf_lzr_linearize_simple(self->concr, ctree, lin_idx, out, err, tmp_pool); // // PyObject* pystr = NULL; // if (gu_ok(err)) { // pystr = PyString_FromStringAndSize(gu_string_buf_data(sbuf), // gu_string_buf_length(sbuf)); // } else { // gu_exn_clear(err); // pystr = Py_None; // Py_INCREF(pystr); // } // // gu_string_buf_flush(sbuf); // // if (PyDict_SetItemString(table, labels[lin_idx], pystr) < 0) // return NULL; // // Py_XDECREF(pystr); // } // // gu_pool_free(tmp_pool); // // return table; // } // // // typedef struct { // PyObject_HEAD // PyObject* cat; // int fid; // PyObject* ann; // PyObject* fun; // PyObject* children; // } BracketObject; // // static void // Bracket_dealloc(BracketObject* self) // { // Py_XDECREF(self->cat); // Py_XDECREF(self->fun); // Py_XDECREF(self->children); // Py_TYPE(self)->tp_free((PyObject*)self); // } // // static PyObject * // Bracket_repr(BracketObject *self) // { // PyObject *repr = // #if PY_MAJOR_VERSION >= 3 // PyString_FromFormat("(%U:%d", self->cat, self->fid); // #else // PyString_FromFormat("(%s:%d", PyString_AsString(self->cat), self->fid); // #endif // if (repr == NULL) { // return NULL; // } // // PyObject *space = PyString_FromString(" "); // // size_t len = PyList_Size(self->children); // for (size_t i = 0; i < len; i++) { // PyObject *child = PyList_GetItem(self->children, i); // // PyString_Concat(&repr, space); // if (repr == NULL) { // Py_DECREF(space); // return NULL; // } // // PyObject *child_str = Py_TYPE(child)->tp_str(child); // if (child_str == NULL) { // Py_DECREF(repr); // Py_DECREF(space); // return NULL; // } // // PyString_Concat(&repr, child_str); // if (repr == NULL) { // Py_DECREF(space); // return NULL; // } // // Py_DECREF(child_str); // } // // Py_DECREF(space); // // PyObject *str = PyString_FromString(")"); // PyString_Concat(&repr, str); // if (repr == NULL) { // Py_DECREF(str); // return NULL; // } // Py_DECREF(str); // // return repr; // } // // static PyMemberDef Bracket_members[] = { // {"cat", T_OBJECT_EX, offsetof(BracketObject, cat), 0, // "the syntactic category for this bracket"}, // {"fun", T_OBJECT_EX, offsetof(BracketObject, fun), 0, // "the abstract function for this bracket"}, // {"fid", T_INT, offsetof(BracketObject, fid), 0, // "an id which identifies this bracket in the bracketed string. If there are discontinuous phrases this id will be shared for all brackets belonging to the same phrase."}, // {"ann", T_OBJECT_EX, offsetof(BracketObject, ann), 0, // "the analysis of the constituent"}, // {"children", T_OBJECT_EX, offsetof(BracketObject, children), 0, // "a list with the children of this bracket"}, // {NULL} /* Sentinel */ // }; // // static PyTypeObject pgf_BracketType = { // PyVarObject_HEAD_INIT(NULL, 0) // //0, /*ob_size*/ // "pgf.Bracket", /*tp_name*/ // sizeof(BracketObject), /*tp_basicsize*/ // 0, /*tp_itemsize*/ // (destructor)Bracket_dealloc,/*tp_dealloc*/ // 0, /*tp_print*/ // 0, /*tp_getattr*/ // 0, /*tp_setattr*/ // 0, /*tp_compare*/ // 0, /*tp_repr*/ // 0, /*tp_as_number*/ // 0, /*tp_as_sequence*/ // 0, /*tp_as_mapping*/ // 0, /*tp_hash */ // 0, /*tp_call*/ // (reprfunc) Bracket_repr, /*tp_str*/ // 0, /*tp_getattro*/ // 0, /*tp_setattro*/ // 0, /*tp_as_buffer*/ // Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE, /*tp_flags*/ // "a linearization bracket", /*tp_doc*/ // 0, /*tp_traverse */ // 0, /*tp_clear */ // 0, /*tp_richcompare */ // 0, /*tp_weaklistoffset */ // 0, /*tp_iter */ // 0, /*tp_iternext */ // 0, /*tp_methods */ // Bracket_members, /*tp_members */ // 0, /*tp_getset */ // 0, /*tp_base */ // 0, /*tp_dict */ // 0, /*tp_descr_get */ // 0, /*tp_descr_set */ // 0, /*tp_dictoffset */ // 0, /*tp_init */ // 0, /*tp_alloc */ // 0, /*tp_new */ // }; // // typedef struct { // PyObject_HEAD // } BINDObject; // // static PyObject * // BIND_repr(BINDObject *self) // { // return PyString_FromString("&+"); // } // // static PyTypeObject pgf_BINDType = { // PyVarObject_HEAD_INIT(NULL, 0) // //0, /*ob_size*/ // "pgf.BIND", /*tp_name*/ // sizeof(BINDObject), /*tp_basicsize*/ // 0, /*tp_itemsize*/ // 0, /*tp_dealloc*/ // 0, /*tp_print*/ // 0, /*tp_getattr*/ // 0, /*tp_setattr*/ // 0, /*tp_compare*/ // 0, /*tp_repr*/ // 0, /*tp_as_number*/ // 0, /*tp_as_sequence*/ // 0, /*tp_as_mapping*/ // 0, /*tp_hash */ // 0, /*tp_call*/ // (reprfunc) BIND_repr, /*tp_str*/ // 0, /*tp_getattro*/ // 0, /*tp_setattro*/ // 0, /*tp_as_buffer*/ // Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE, /*tp_flags*/ // "a marker for BIND in a bracketed string", /*tp_doc*/ // 0, /*tp_traverse */ // 0, /*tp_clear */ // 0, /*tp_richcompare */ // 0, /*tp_weaklistoffset */ // 0, /*tp_iter */ // 0, /*tp_iternext */ // 0, /*tp_methods */ // 0, /*tp_members */ // 0, /*tp_getset */ // 0, /*tp_base */ // 0, /*tp_dict */ // 0, /*tp_descr_get */ // 0, /*tp_descr_set */ // 0, /*tp_dictoffset */ // 0, /*tp_init */ // 0, /*tp_alloc */ // 0, /*tp_new */ // }; // // typedef struct { // PgfLinFuncs* funcs; // GuBuf* stack; // PyObject* list; // } PgfBracketLznState; // // static void // pgf_bracket_lzn_symbol_token(PgfLinFuncs** funcs, PgfToken tok) // { // PgfBracketLznState* state = gu_container(funcs, PgfBracketLznState, funcs); // // PyObject* str = PyString_FromString(tok); // PyList_Append(state->list, str); // Py_DECREF(str); // } // // static void // pgf_bracket_lzn_begin_phrase(PgfLinFuncs** funcs, PgfCId cat, int fid, GuString ann, PgfCId fun) // { // PgfBracketLznState* state = gu_container(funcs, PgfBracketLznState, funcs); // // gu_buf_push(state->stack, PyObject*, state->list); // state->list = PyList_New(0); // } // // static void // pgf_bracket_lzn_end_phrase(PgfLinFuncs** funcs, PgfCId cat, int fid, GuString ann, PgfCId fun) // { // PgfBracketLznState* state = gu_container(funcs, PgfBracketLznState, funcs); // // PyObject* parent = gu_buf_pop(state->stack, PyObject*); // // if (PyList_Size(state->list) > 0) { // BracketObject* bracket = (BracketObject *) // pgf_BracketType.tp_alloc(&pgf_BracketType, 0); // if (bracket != NULL) { // bracket->cat = PyString_FromString(cat); // bracket->fid = fid; // bracket->ann = PyString_FromString(ann); // bracket->fun = PyString_FromString(fun); // bracket->children = state->list; // PyList_Append(parent, (PyObject*) bracket); // Py_DECREF(bracket); // } // } else { // Py_DECREF(state->list); // } // // state->list = parent; // } // // static void // pgf_bracket_lzn_symbol_bind(PgfLinFuncs** funcs) // { // PgfBracketLznState* state = gu_container(funcs, PgfBracketLznState, funcs); // // PyObject* bind = pgf_BINDType.tp_alloc(&pgf_BINDType, 0); // PyList_Append(state->list, bind); // Py_DECREF(bind); // } // // static void // pgf_bracket_lzn_symbol_meta(PgfLinFuncs** funcs, PgfMetaId meta_id) // { // pgf_bracket_lzn_symbol_token(funcs, "?"); // } // // static PgfLinFuncs pgf_bracket_lin_funcs = { // .symbol_token = pgf_bracket_lzn_symbol_token, // .begin_phrase = pgf_bracket_lzn_begin_phrase, // .end_phrase = pgf_bracket_lzn_end_phrase, // .symbol_ne = NULL, // .symbol_bind = pgf_bracket_lzn_symbol_bind, // .symbol_capit = NULL, // .symbol_meta = pgf_bracket_lzn_symbol_meta // }; // // static PyObject* // Concr_bracketedLinearize(ConcrObject* self, PyObject *args) // { // ExprObject* pyexpr; // if (!PyArg_ParseTuple(args, "O!", &pgf_ExprType, &pyexpr)) // return NULL; // // GuPool* tmp_pool = gu_local_pool(); // GuExn* err = gu_exn(tmp_pool); // // GuEnum* cts = // pgf_lzr_concretize(self->concr, pyexpr->expr, err, tmp_pool); // if (!gu_ok(err)) { // if (gu_exn_caught(err, PgfExn)) { // GuString msg = (GuString) gu_exn_caught_data(err); // PyErr_SetString(PGFError, msg); // return NULL; // } else { // PyErr_SetString(PGFError, "The abstract tree cannot be concretized"); // } // } // // PgfCncTree ctree = gu_next(cts, PgfCncTree, tmp_pool); // if (gu_variant_is_null(ctree)) { // PyErr_SetString(PGFError, "The abstract tree cannot be concretized"); // gu_pool_free(tmp_pool); // return NULL; // } // // PyObject* list = PyList_New(0); // // ctree = pgf_lzr_wrap_linref(ctree, tmp_pool); // // PgfBracketLznState state; // state.funcs = &pgf_bracket_lin_funcs; // state.stack = gu_new_buf(PyObject*, tmp_pool); // state.list = list; // pgf_lzr_linearize(self->concr, ctree, 0, &state.funcs, tmp_pool); // // gu_pool_free(tmp_pool); // // return list; // } // // static PyObject* // Iter_fetch_bracketedLinearization(IterObject* self) // { // GuPool* tmp_pool = gu_local_pool(); // GuExn* err = gu_exn(tmp_pool); // // restart:; // // PgfCncTree ctree = gu_next(self->res, PgfCncTree, tmp_pool); // if (gu_variant_is_null(ctree)) { // gu_pool_free(tmp_pool); // return NULL; // } // // PyObject* list = PyList_New(0); // ctree = pgf_lzr_wrap_linref(ctree, tmp_pool); // // ConcrObject* pyconcr = (ConcrObject*) self->container; // // PgfBracketLznState state; // state.funcs = &pgf_bracket_lin_funcs; // state.stack = gu_new_buf(PyObject*, tmp_pool); // state.list = list; // pgf_lzr_linearize(pyconcr->concr, ctree, 0, &state.funcs, tmp_pool); // // if (!gu_ok(err)) { // if (gu_exn_caught(err, PgfLinNonExist)) { // // encountered nonExist. Unfortunately there // // might be some output printed already. The // // right solution should be to use GuStringBuf. // gu_exn_clear(err); // goto restart; // } // else if (gu_exn_caught(err, PgfExn)) { // GuString msg = (GuString) gu_exn_caught_data(err); // PyErr_SetString(PGFError, msg); // gu_pool_free(tmp_pool); // return NULL; // } else { // PyErr_SetString(PGFError, "The abstract tree cannot be linearized"); // gu_pool_free(tmp_pool); // return NULL; // } // } // // gu_pool_free(tmp_pool); // return list; // } // // static PyObject* // Concr_bracketedLinearizeAll(ConcrObject* self, PyObject *args, PyObject *keywds) // { // static char *kwlist[] = {"expression", "n", NULL}; // ExprObject* pyexpr = NULL; // int max_count = -1; // // if (!PyArg_ParseTupleAndKeywords(args, keywds, "O!|i", kwlist, // &pgf_ExprType, &pyexpr, &max_count)) // return NULL; // // GuPool* pool = gu_new_pool(); // GuExn* err = gu_exn(pool); // // GuEnum* cts = // pgf_lzr_concretize(self->concr, pyexpr->expr, err, pool); // if (!gu_ok(err)) { // if (gu_exn_caught(err, PgfExn)) { // GuString msg = (GuString) gu_exn_caught_data(err); // PyErr_SetString(PGFError, msg); // } else { // PyErr_SetString(PGFError, "The abstract tree cannot be concretized"); // } // return NULL; // } // // IterObject* pyres = (IterObject*) pgf_IterType.tp_alloc(&pgf_IterType, 0); // if (pyres == NULL) { // gu_pool_free(pool); // return NULL; // } // // pyres->source = (PyObject*)pyexpr; // Py_INCREF(pyres->source); // pyres->container = (PyObject*)self; // Py_INCREF(pyres->container); // pyres->pool = pool; // pyres->max_count = max_count; // pyres->counter = 0; // pyres->fetch = Iter_fetch_bracketedLinearization; // pyres->res = cts; // // return (PyObject*)pyres; // } // // static PyObject* // Concr_hasLinearization(ConcrObject* self, PyObject *args) // { // PgfCId id; // if (!PyArg_ParseTuple(args, "s", &id)) // return NULL; // // if (pgf_has_linearization(self->concr, id)) // Py_RETURN_TRUE; // else // Py_RETURN_FALSE; // } // // static PyObject* // Concr_getName(ConcrObject *self, void *closure) // { // return PyString_FromString(pgf_concrete_name(self->concr)); // } // // static PyObject* // Concr_getLanguageCode(ConcrObject *self, void *closure) // { // GuString code = pgf_language_code(self->concr); // if (code == NULL) // Py_RETURN_NONE; // return PyString_FromString(code); // } // // static PyObject* // Concr_graphvizParseTree(ConcrObject* self, PyObject *args) { // ExprObject* pyexpr; // if (!PyArg_ParseTuple(args, "O!", &pgf_ExprType, &pyexpr)) // return NULL; // // GuPool* tmp_pool = gu_local_pool(); // GuExn* err = gu_exn(tmp_pool); // GuStringBuf* sbuf = gu_new_string_buf(tmp_pool); // GuOut* out = gu_string_buf_out(sbuf); // // pgf_graphviz_parse_tree(self->concr, pyexpr->expr, pgf_default_graphviz_options, out, err); // if (!gu_ok(err)) { // if (gu_exn_caught(err, PgfExn)) { // GuString msg = (GuString) gu_exn_caught_data(err); // PyErr_SetString(PGFError, msg); // } else { // PyErr_SetString(PGFError, "The parse tree cannot be visualized"); // } // return NULL; // } // // PyObject* pystr = PyString_FromStringAndSize(gu_string_buf_data(sbuf), // gu_string_buf_length(sbuf)); // // gu_pool_free(tmp_pool); // return pystr; // } // // typedef struct { // PgfMorphoCallback fn; // PyObject* analyses; // } PyMorphoCallback; // // static void // pypgf_collect_morpho(PgfMorphoCallback* self, // PgfCId lemma, GuString analysis, prob_t prob, // GuExn* err) // { // PyMorphoCallback* callback = (PyMorphoCallback*) self; // // PyObject* py_lemma = PyString_FromString(lemma); // PyObject* py_analysis = PyString_FromString(analysis); // PyObject* res = // Py_BuildValue("OOf", py_lemma, py_analysis, prob); // // if (PyList_Append(callback->analyses, res) != 0) { // gu_raise(err, PgfExn); // } // // Py_DECREF(py_lemma); // Py_DECREF(py_analysis); // Py_DECREF(res); // } // // static PyObject* // Concr_lookupMorpho(ConcrObject* self, PyObject *args) { // GuString sent; // if (!PyArg_ParseTuple(args, "s", &sent)) // return NULL; // // GuPool *tmp_pool = gu_local_pool(); // GuExn* err = gu_exn(tmp_pool); // // PyObject* analyses = PyList_New(0); // // PyMorphoCallback callback = { { pypgf_collect_morpho }, analyses }; // pgf_lookup_morpho(self->concr, sent, &callback.fn, err); // if (!gu_ok(err)) { // if (gu_exn_caught(err, PgfExn)) { // GuString msg = (GuString) gu_exn_caught_data(err); // PyErr_SetString(PGFError, msg); // } else { // PyErr_SetString(PGFError, "The lookup failed"); // } // Py_DECREF(analyses); // analyses = NULL; // } // // gu_pool_free(tmp_pool); // // return analyses; // } // // #define PGF_MORPHOCALLBACK_NAME "pgf.MorphoCallback" // // static void // pypgf_morphocallback_destructor(PyObject *capsule) // { // PyMorphoCallback* callback = // PyCapsule_GetPointer(capsule, PGF_MORPHOCALLBACK_NAME); // Py_XDECREF(callback->analyses); // } // // static PyObject* // Iter_fetch_cohort(IterObject* self) // { // PgfCohortRange range = // gu_next(self->res, PgfCohortRange, self->pool); // if (range.buf == NULL) // return NULL; // // PyObject* py_start = PyLong_FromSize_t(range.start.pos); // if (py_start == NULL) // return NULL; // PyObject* py_end = PyLong_FromSize_t(range.end.pos); // if (py_end == NULL) { // Py_DECREF(py_start); // return NULL; // } // // PyMorphoCallback* callback = // PyCapsule_GetPointer(PyTuple_GetItem(self->container, 0), // PGF_MORPHOCALLBACK_NAME); // // PyObject* py_slice = // PySlice_New(py_start, py_end, NULL); // if (py_slice == NULL) { // Py_DECREF(py_start); // Py_DECREF(py_end); // return NULL; // } // // PyObject* py_w = // PyObject_GetItem(PyTuple_GetItem(self->container, 1), py_slice); // // PyObject* res = // PyTuple_Pack(4, py_start, py_w, callback->analyses, py_end); // // Py_DECREF(callback->analyses); // callback->analyses = PyList_New(0); // // Py_DECREF(py_w); // Py_DECREF(py_slice); // Py_DECREF(py_end); // Py_DECREF(py_start); // // return res; // } // // static PyObject* // Concr_lookupCohorts(ConcrObject* self, PyObject *args) // { // PyObject* py_sent = NULL; // if (!PyArg_ParseTuple(args, "U", &py_sent)) // return NULL; // // IterObject* pyres = (IterObject*) // pgf_IterType.tp_alloc(&pgf_IterType, 0); // if (pyres == NULL) // return NULL; // // pyres->pool = gu_new_pool(); // pyres->source = (PyObject*) self->grammar; // Py_XINCREF(pyres->source); // // PyMorphoCallback* callback = gu_new(PyMorphoCallback,pyres->pool); // callback->fn.callback = pypgf_collect_morpho; // callback->analyses = PyList_New(0); // PyObject* capsule = // PyCapsule_New(callback, PGF_MORPHOCALLBACK_NAME, // pypgf_morphocallback_destructor); // if (capsule == NULL) { // Py_DECREF(pyres); // return NULL; // } // // #if PY_MAJOR_VERSION >= 3 // PyObject* bytes = PyUnicode_AsUTF8String(py_sent); // if (!bytes) // return NULL; // GuString sent = PyBytes_AsString(bytes); // if (!sent) { // Py_DECREF(bytes); // return NULL; // } // #else // GuString sent = PyString_AsString(py_sent); // if (!sent) // return NULL; // #endif // // // pyres->container = // #if PY_MAJOR_VERSION >= 3 // PyTuple_Pack(3, capsule, py_sent, bytes); // Py_DECREF(bytes); // #else // PyTuple_Pack(2, capsule, py_sent); // #endif // pyres->max_count = -1; // pyres->counter = 0; // pyres->fetch = Iter_fetch_cohort; // // Py_DECREF(capsule); // // GuExn* err = gu_new_exn(pyres->pool); // pyres->res = pgf_lookup_cohorts(self->concr, sent, // &callback->fn, pyres->pool, err); // if (pyres->res == NULL) { // Py_DECREF(pyres); // return NULL; // } // // return (PyObject*) pyres; // } // // static PyObject* // Iter_fetch_fullform(IterObject* self) // { // PgfFullFormEntry* entry = // gu_next(self->res, PgfFullFormEntry*, self->pool); // if (entry == NULL) // return NULL; // // PyObject* res = NULL; // PyObject* py_tokens = NULL; // PyObject* py_analyses = NULL; // // GuString tokens = // pgf_fullform_get_string(entry); // // py_tokens = PyString_FromString(tokens); // if (py_tokens == NULL) // goto done; // // py_analyses = PyList_New(0); // if (py_analyses == NULL) // goto done; // // GuPool* tmp_pool = gu_local_pool(); // GuExn* err = gu_new_exn(tmp_pool); // // PyMorphoCallback callback = { { pypgf_collect_morpho }, py_analyses }; // pgf_fullform_get_analyses(entry, &callback.fn, err); // // if (!gu_ok(err)) // goto done; // // res = Py_BuildValue("OO", py_tokens, py_analyses); // // done: // Py_XDECREF(py_tokens); // Py_XDECREF(py_analyses); // // return res; // } // // static PyObject* // Concr_fullFormLexicon(ConcrObject* self, PyObject *args) // { // IterObject* pyres = (IterObject*) // pgf_IterType.tp_alloc(&pgf_IterType, 0); // if (pyres == NULL) // return NULL; // // pyres->source = (PyObject*) self->grammar; // Py_XINCREF(pyres->source); // // pyres->container = NULL; // pyres->pool = gu_new_pool(); // pyres->max_count = -1; // pyres->counter = 0; // pyres->fetch = Iter_fetch_fullform; // // pyres->res = pgf_fullform_lexicon(self->concr, pyres->pool); // if (pyres->res == NULL) { // Py_DECREF(pyres); // return NULL; // } // // return (PyObject*) pyres; // } // // static PyObject* // Concr_load(ConcrObject* self, PyObject *args) // { // const char *fpath; // if (!PyArg_ParseTuple(args, "s", &fpath)) // return NULL; // // GuPool* tmp_pool = gu_local_pool(); // // // Create an exception frame that catches all errors. // GuExn* err = gu_new_exn(tmp_pool); // // FILE* infile = fopen(fpath, "rb"); // if (infile == NULL) { // PyErr_SetFromErrnoWithFilename(PyExc_IOError, fpath); // return NULL; // } // // // Create an input stream from the input file // GuIn* in = gu_file_in(infile, tmp_pool); // // // Read the PGF grammar. // pgf_concrete_load(self->concr, in, err); // if (!gu_ok(err)) { // fclose(infile); // if (gu_exn_caught(err, GuErrno)) { // errno = *((GuErrno*) gu_exn_caught_data(err)); // PyErr_SetFromErrnoWithFilename(PyExc_IOError, fpath); // } else if (gu_exn_caught(err, PgfExn)) { // GuString msg = (GuString) gu_exn_caught_data(err); // PyErr_SetString(PGFError, msg); // } else { // PyErr_SetString(PGFError, "The language cannot be loaded"); // } // gu_pool_free(tmp_pool); // return NULL; // } // // gu_pool_free(tmp_pool); // // fclose(infile); // // Py_RETURN_NONE; // } // // static PyObject* // Concr_unload(ConcrObject* self, PyObject *args) // { // if (!PyArg_ParseTuple(args, "")) // return NULL; // // pgf_concrete_unload(self->concr); // // Py_RETURN_NONE; // } // // static PyGetSetDef Concr_getseters[] = { // {"name", // (getter)Concr_getName, NULL, // "the name of the concrete syntax", // }, // {"languageCode", // (getter)Concr_getLanguageCode, NULL, // "the language code for this concrete syntax", // }, // {NULL} /* Sentinel */ // }; // // static PyMethodDef Concr_methods[] = { // {"printName", (PyCFunction)Concr_printName, METH_VARARGS, // "Returns the print name of a function or category" // }, // {"parse", (PyCFunction)Concr_parse, METH_VARARGS | METH_KEYWORDS, // "Parses a string and returns an iterator over the abstract trees for this sentence\n\n" // "Named arguments:\n" // "- sentence (string)\n" // "- cat (string); OPTIONAL, default: the startcat of the grammar\n" // "- n (int), max. trees; OPTIONAL, default: extract all trees\n" // "- heuristics (double >= 0.0); OPTIONAL, default: taken from the flags in the grammar\n" // "- callbacks (list of category and callback); OPTIONAL, default: built-in callbacks only for Int, String and Float" // }, // {"complete", (PyCFunction)Concr_complete, METH_VARARGS | METH_KEYWORDS, // "Parses a partial string and returns a list with the top n possible next tokens" // }, // {"parseval", (PyCFunction)Concr_parseval, METH_VARARGS, // "Computes precision, recall and exact match for the parser on a given abstract tree" // }, // {"lookupSentence", (PyCFunction)Concr_lookupSentence, METH_VARARGS | METH_KEYWORDS, // "Looks up a sentence from the grammar by a sequence of keywords\n\n" // "Named arguments:\n" // "- sentence (string) or tokens (list of strings)\n" // "- cat (string); OPTIONAL, default: the startcat of the grammar\n" // "- n (int), max. trees; OPTIONAL, default: extract all trees" // }, // {"linearize", (PyCFunction)Concr_linearize, METH_VARARGS, // "Takes an abstract tree and linearizes it to a string" // }, // {"linearizeAll", (PyCFunction)Concr_linearizeAll, METH_VARARGS | METH_KEYWORDS, // "Takes an abstract tree and linearizes with all variants" // }, // {"tabularLinearize", (PyCFunction)Concr_tabularLinearize, METH_VARARGS, // "Takes an abstract tree and linearizes it to a table containing all fields" // }, // {"bracketedLinearize", (PyCFunction)Concr_bracketedLinearize, METH_VARARGS, // "Takes an abstract tree and linearizes it to a bracketed string" // }, // {"bracketedLinearizeAll", (PyCFunction)Concr_bracketedLinearizeAll, METH_VARARGS | METH_KEYWORDS, // "Takes an abstract tree and linearizes all variants into bracketed strings" // }, // {"hasLinearization", (PyCFunction)Concr_hasLinearization, METH_VARARGS, // "hasLinearization(f) returns true if the function f has linearization in the concrete syntax" // }, // {"graphvizParseTree", (PyCFunction)Concr_graphvizParseTree, METH_VARARGS, // "Renders an abstract syntax tree as a parse tree in Graphviz format" // }, // {"lookupMorpho", (PyCFunction)Concr_lookupMorpho, METH_VARARGS, // "Looks up a word in the lexicon of the grammar" // }, // {"lookupCohorts", (PyCFunction)Concr_lookupCohorts, METH_VARARGS, // "Takes a sentence and returns all matches for lexical items from the grammar in that sentence" // }, // {"fullFormLexicon", (PyCFunction)Concr_fullFormLexicon, METH_VARARGS, // "Enumerates all words in the lexicon (useful for extracting full form lexicons)" // }, // {"load", (PyCFunction)Concr_load, METH_VARARGS, // "Loads the concrete syntax from a .pgf_c file" // }, // {"unload", (PyCFunction)Concr_unload, METH_VARARGS, // "Unloads the concrete syntax" // }, // {NULL} /* Sentinel */ // }; // // static PyTypeObject pgf_ConcrType = { // PyVarObject_HEAD_INIT(NULL, 0) // //0, /*ob_size*/ // "pgf.Concr", /*tp_name*/ // sizeof(ConcrObject), /*tp_basicsize*/ // 0, /*tp_itemsize*/ // (destructor)Concr_dealloc, /*tp_dealloc*/ // 0, /*tp_print*/ // 0, /*tp_getattr*/ // 0, /*tp_setattr*/ // 0, /*tp_compare*/ // 0, /*tp_repr*/ // 0, /*tp_as_number*/ // 0, /*tp_as_sequence*/ // 0, /*tp_as_mapping*/ // 0, /*tp_hash */ // 0, /*tp_call*/ // 0, /*tp_str*/ // 0, /*tp_getattro*/ // 0, /*tp_setattro*/ // 0, /*tp_as_buffer*/ // Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE, /*tp_flags*/ // "concrete syntax", /*tp_doc*/ // 0, /*tp_traverse */ // 0, /*tp_clear */ // 0, /*tp_richcompare */ // 0, /*tp_weaklistoffset */ // 0, /*tp_iter */ // 0, /*tp_iternext */ // Concr_methods, /*tp_methods */ // 0, /*tp_members */ // Concr_getseters, /*tp_getset */ // 0, /*tp_base */ // 0, /*tp_dict */ // 0, /*tp_descr_get */ // 0, /*tp_descr_set */ // 0, /*tp_dictoffset */ // (initproc)Concr_init, /*tp_init */ // 0, /*tp_alloc */ // (newfunc)Concr_new, /*tp_new */ // }; static void PGF_dealloc(PGFObject* self) { pgf_free(self->pgf); Py_TYPE(self)->tp_free((PyObject*)self); } typedef struct { PgfItor fn; PGFObject* grammar; void* collection; } PyPGFClosure; // static void // pgf_collect_langs_seq(GuMapItor* fn, const void* key, void* value, GuExn* err) // { // PgfConcr* concr = *((PgfConcr**) value); // PyPGFClosure* clo = (PyPGFClosure*) fn; // // gu_buf_push((GuBuf*) clo->collection, PgfConcr*, concr); // } static PyObject* PGF_repr(PGFObject *self) { // GuPool* tmp_pool = gu_local_pool(); // // GuExn* err = gu_exn(tmp_pool); // GuStringBuf* sbuf = gu_new_string_buf(tmp_pool); // GuOut* out = gu_string_buf_out(sbuf); // // GuBuf* languages = gu_new_buf(PgfConcr*, tmp_pool); // // PyPGFClosure clo = { { pgf_collect_langs_seq }, self, languages }; // pgf_iter_languages(self->pgf, &clo.fn, err); // // pgf_print(self->pgf, gu_buf_length(languages), // gu_buf_data(languages), // out, err); // // PyObject* pystr = PyString_FromStringAndSize(gu_string_buf_data(sbuf), // gu_string_buf_length(sbuf)); // // gu_pool_free(tmp_pool); // return pystr; return NULL; } static PyObject* PGF_getAbstractName(PGFObject *self, void *closure) { PgfText* txt = pgf_abstract_name(self->pgf); return PyString_FromStringAndSize(txt->text, txt->size); } // static void // pgf_collect_langs_dict(GuMapItor* fn, const void* key, void* value, GuExn* err) // { // PgfCId name = (PgfCId) key; // PgfConcr* concr = *((PgfConcr**) value); // PyPGFClosure* clo = (PyPGFClosure*) fn; // // PyObject* py_name = NULL; // PyObject* py_lang = NULL; // // py_name = PyString_FromString(name); // if (py_name == NULL) { // gu_raise(err, PgfExn); // goto end; // } // // py_lang = pgf_ConcrType.tp_alloc(&pgf_ConcrType, 0); // if (py_lang == NULL) { // gu_raise(err, PgfExn); // goto end; // } // // ((ConcrObject *) py_lang)->concr = concr; // ((ConcrObject *) py_lang)->grammar = clo->grammar; // Py_INCREF(clo->grammar); // // if (PyDict_SetItem((PyObject*) clo->collection, py_name, py_lang) != 0) { // gu_raise(err, PgfExn); // goto end; // } // // end: // Py_XDECREF(py_lang); // Py_XDECREF(py_name); // } // // static PyObject* // PGF_getLanguages(PGFObject *self, void *closure) // { // PyObject* languages = PyDict_New(); // if (languages == NULL) // return NULL; // // GuPool* tmp_pool = gu_local_pool(); // // // Create an exception frame that catches all errors. // GuExn* err = gu_new_exn(tmp_pool); // // PyPGFClosure clo = { { pgf_collect_langs_dict }, self, languages }; // pgf_iter_languages(self->pgf, &clo.fn, err); // if (!gu_ok(err)) { // Py_DECREF(languages); // gu_pool_free(tmp_pool); // return NULL; // } // // PyObject* proxy = PyDictProxy_New(languages); // // Py_DECREF(languages); // gu_pool_free(tmp_pool); // // return proxy; // } // // static void // pgf_collect_cats(GuMapItor* fn, const void* key, void* value, GuExn* err) // { // PgfCId name = (PgfCId) key; // PyPGFClosure* clo = (PyPGFClosure*) fn; // // PyObject* py_name = NULL; // // py_name = PyString_FromString(name); // if (py_name == NULL) { // gu_raise(err, PgfExn); // goto end; // } // // if (PyList_Append((PyObject*) clo->collection, py_name) != 0) { // gu_raise(err, PgfExn); // goto end; // } // // end: // Py_XDECREF(py_name); // } static void pgf_collect_cats(PgfItor* fn, PgfText* key, void* value, PgfExn *err) { PgfText* name = key; PyPGFClosure* clo = (PyPGFClosure*) fn; PyObject* py_name = NULL; py_name = PyString_FromStringAndSize(name->text, name->size); if (py_name == NULL) { err->type = PGF_EXN_OTHER_ERROR; goto end; } if (PyList_Append((PyObject*) clo->collection, py_name) != 0) { err->type = PGF_EXN_OTHER_ERROR; goto end; } end: Py_XDECREF(py_name); } static PyObject* PGF_getCategories(PGFObject *self, void *closure) { PyObject* categories = PyList_New(0); if (categories == NULL) return NULL; PgfExn err; PyPGFClosure clo = { { pgf_collect_cats }, self, categories }; pgf_iter_categories(self->pgf, &clo.fn, &err); if (err.type != PGF_EXN_NONE) { Py_DECREF(categories); return NULL; } return categories; } // static TypeObject* // PGF_getStartCat(PGFObject *self, void *closure) // { // TypeObject* pytype = (TypeObject*) pgf_TypeType.tp_alloc(&pgf_TypeType, 0); // if (pytype == NULL) // return NULL; // // pytype->pool = gu_new_pool(); // pytype->type = pgf_start_cat(self->pgf, pytype->pool); // pytype->master = NULL; // // if (pytype->type == NULL) { // PyErr_SetString(PGFError, "The start category cannot be found"); // Py_DECREF(pytype); // return NULL; // } // // return pytype; // } static void pgf_collect_funs(PgfItor* fn, PgfText* key, void* value, PgfExn *err) { PgfText* name = key; PyPGFClosure* clo = (PyPGFClosure*) fn; PyObject* py_name = NULL; py_name = PyString_FromStringAndSize(name->text, name->size); if (py_name == NULL) { err->type = PGF_EXN_OTHER_ERROR; goto end; } if (PyList_Append((PyObject*) clo->collection, py_name) != 0) { err->type = PGF_EXN_OTHER_ERROR; goto end; } end: Py_XDECREF(py_name); } static PyObject* PGF_getFunctions(PGFObject *self, void *closure) { PyObject* functions = PyList_New(0); if (functions == NULL) return NULL; PgfExn err; PyPGFClosure clo = { { pgf_collect_funs }, self, functions }; pgf_iter_functions(self->pgf, &clo.fn, &err); if (err.type != PGF_EXN_NONE) { Py_DECREF(functions); return NULL; } return functions; } static PyObject* PGF_functionsByCat(PGFObject* self, PyObject *args) { const char* c; if (!PyArg_ParseTuple(args, "s", &c)) return NULL; const size_t s = strlen(c); PgfText* catname = (PgfText*) alloca(sizeof(PgfText)+s); strcpy(catname->text, c); catname->size = s; PyObject* functions = PyList_New(0); if (functions == NULL) { return NULL; } PgfExn err; PyPGFClosure clo = { { pgf_collect_funs }, self, functions }; pgf_iter_functions_by_cat(self->pgf, catname, &clo.fn, &err); if (err.type != PGF_EXN_NONE) { Py_DECREF(functions); return NULL; } return functions; } // static TypeObject* // PGF_functionType(PGFObject* self, PyObject *args) // { // PgfCId funname; // if (!PyArg_ParseTuple(args, "s", &funname)) // return NULL; // // PgfType* type = // pgf_function_type(self->pgf, funname); // if (type == NULL) { // PyErr_Format(PyExc_KeyError, "Function '%s' is not defined", funname); // return NULL; // } // // TypeObject* pytype = (TypeObject*) pgf_TypeType.tp_alloc(&pgf_TypeType, 0); // if (pytype == NULL) // return NULL; // pytype->pool = NULL; // pytype->type = type; // pytype->master = (PyObject*) self; // Py_XINCREF(self); // // return pytype; // } // // static IterObject* // PGF_generateAll(PGFObject* self, PyObject *args, PyObject *keywds) // { // static char *kwlist[] = {"cat", "n", NULL}; // // PyObject* start = NULL; // int max_count = -1; // if (!PyArg_ParseTupleAndKeywords(args, keywds, "O|i", kwlist, // &start, &max_count)) // return NULL; // // IterObject* pyres = (IterObject*) // pgf_IterType.tp_alloc(&pgf_IterType, 0); // if (pyres == NULL) { // return NULL; // } // // pyres->source = (PyObject*) self; // Py_INCREF(self); // // GuPool* out_pool = gu_new_pool(); // // PyObject* py_pool = PyPool_New(out_pool); // pyres->container = PyTuple_Pack(2, pyres->source, py_pool); // Py_DECREF(py_pool); // // pyres->pool = gu_new_pool(); // pyres->max_count = max_count; // pyres->counter = 0; // pyres->fetch = Iter_fetch_expr; // // GuExn* err = gu_exn(pyres->pool); // // PgfType* type = pgf_type_from_object(start, pyres->pool); // if (type == NULL) { // Py_DECREF(pyres); // return NULL; // } // // pyres->res = // pgf_generate_all(self->pgf, type, err, pyres->pool, out_pool); // if (pyres->res == NULL) { // Py_DECREF(pyres); // return NULL; // } // // return pyres; // } // // static ExprObject* // PGF_compute(PGFObject* self, PyObject *args) // { // ExprObject* py_expr = NULL; // if (!PyArg_ParseTuple(args, "O!", &pgf_ExprType, &py_expr)) // return NULL; // // ExprObject* py_expr_res = (ExprObject*) pgf_ExprType.tp_alloc(&pgf_ExprType, 0); // if (py_expr_res == NULL) // return NULL; // // GuPool* tmp_pool = gu_new_pool(); // GuExn* err = gu_new_exn(tmp_pool); // // py_expr_res->pool = gu_new_pool(); // py_expr_res->expr = pgf_compute(self->pgf, py_expr->expr, err, // tmp_pool, py_expr_res->pool); // py_expr_res->master = (PyObject*) self; // Py_INCREF(py_expr_res->master); // // if (!gu_ok(err)) { // GuString msg = (GuString) gu_exn_caught_data(err); // PyErr_SetString(PGFError, msg); // // Py_DECREF(py_expr_res); // gu_pool_free(tmp_pool); // return NULL; // } // // gu_pool_free(tmp_pool); // return py_expr_res; // } // // static ExprObject* // PGF_checkExpr(PGFObject* self, PyObject *args) // { // ExprObject* py_expr = NULL; // TypeObject* py_type = NULL; // if (!PyArg_ParseTuple(args, "O!O!", &pgf_ExprType, &py_expr, &pgf_TypeType, &py_type)) // return NULL; // // ExprObject* new_pyexpr = (ExprObject*) pgf_ExprType.tp_alloc(&pgf_ExprType, 0); // if (new_pyexpr == NULL) // return NULL; // // new_pyexpr->pool = gu_new_pool(); // new_pyexpr->expr = py_expr->expr; // new_pyexpr->master = NULL; // // GuPool* tmp_pool = gu_local_pool(); // GuExn* exn = gu_new_exn(tmp_pool); // // pgf_check_expr(self->pgf, &new_pyexpr->expr, py_type->type, // exn, new_pyexpr->pool); // if (!gu_ok(exn)) { // if (gu_exn_caught(exn, PgfExn)) { // GuString msg = (GuString) gu_exn_caught_data(exn); // PyErr_SetString(PGFError, msg); // } else if (gu_exn_caught(exn, PgfTypeError)) { // GuString msg = (GuString) gu_exn_caught_data(exn); // PyErr_SetString(TypeError, msg); // } // // Py_DECREF(new_pyexpr); // gu_pool_free(tmp_pool); // return NULL; // } // // gu_pool_free(tmp_pool); // // return new_pyexpr; // } // // static PyObject* // PGF_inferExpr(PGFObject* self, PyObject *args) // { // ExprObject* py_expr = NULL; // if (!PyArg_ParseTuple(args, "O!", &pgf_ExprType, &py_expr)) // return NULL; // // ExprObject* new_pyexpr = (ExprObject*) pgf_ExprType.tp_alloc(&pgf_ExprType, 0); // if (new_pyexpr == NULL) // return NULL; // // new_pyexpr->pool = gu_new_pool(); // new_pyexpr->expr = py_expr->expr; // new_pyexpr->master = NULL; // // TypeObject* new_pytype = (TypeObject*) pgf_TypeType.tp_alloc(&pgf_TypeType, 0); // if (new_pytype == NULL) { // Py_DECREF(new_pyexpr); // return NULL; // } // // new_pytype->pool = NULL; // new_pytype->type = NULL; // new_pytype->master = (PyObject*) new_pyexpr; // Py_INCREF(new_pyexpr); // // GuPool* tmp_pool = gu_local_pool(); // GuExn* exn = gu_new_exn(tmp_pool); // // new_pytype->type = // pgf_infer_expr(self->pgf, &new_pyexpr->expr, // exn, new_pyexpr->pool); // if (!gu_ok(exn)) { // if (gu_exn_caught(exn, PgfExn)) { // GuString msg = (GuString) gu_exn_caught_data(exn); // PyErr_SetString(PGFError, msg); // } else if (gu_exn_caught(exn, PgfTypeError)) { // GuString msg = (GuString) gu_exn_caught_data(exn); // PyErr_SetString(TypeError, msg); // } // // Py_DECREF(new_pyexpr); // Py_DECREF(new_pytype); // gu_pool_free(tmp_pool); // return NULL; // } // // gu_pool_free(tmp_pool); // // PyObject* res = // Py_BuildValue("OO", new_pyexpr, new_pytype); // // Py_DECREF(new_pyexpr); // Py_DECREF(new_pytype); // // return res; // } // // static TypeObject* // PGF_checkType(PGFObject* self, PyObject *args) // { // TypeObject* py_type = NULL; // if (!PyArg_ParseTuple(args, "O!", &pgf_TypeType, &py_type)) // return NULL; // // TypeObject* new_pytype = (TypeObject*) pgf_TypeType.tp_alloc(&pgf_TypeType, 0); // if (new_pytype == NULL) { // return NULL; // } // // new_pytype->pool = gu_new_pool(); // new_pytype->type = py_type->type; // new_pytype->master = NULL; // // GuPool* tmp_pool = gu_local_pool(); // GuExn* exn = gu_new_exn(tmp_pool); // // pgf_check_type(self->pgf, &new_pytype->type, // exn, new_pytype->pool); // if (!gu_ok(exn)) { // if (gu_exn_caught(exn, PgfExn)) { // GuString msg = (GuString) gu_exn_caught_data(exn); // PyErr_SetString(PGFError, msg); // } else if (gu_exn_caught(exn, PgfTypeError)) { // GuString msg = (GuString) gu_exn_caught_data(exn); // PyErr_SetString(TypeError, msg); // } // // gu_pool_free(tmp_pool); // return NULL; // } // // gu_pool_free(tmp_pool); // // return new_pytype; // } // // static PyObject* // PGF_graphvizAbstractTree(PGFObject* self, PyObject *args) { // ExprObject* pyexpr; // if (!PyArg_ParseTuple(args, "O!", &pgf_ExprType, &pyexpr)) // return NULL; // // GuPool* tmp_pool = gu_local_pool(); // GuExn* err = gu_new_exn(tmp_pool); // GuStringBuf* sbuf = gu_new_string_buf(tmp_pool); // GuOut* out = gu_string_buf_out(sbuf); // // pgf_graphviz_abstract_tree(self->pgf, pyexpr->expr, pgf_default_graphviz_options, out, err); // if (!gu_ok(err)) { // PyErr_SetString(PGFError, "The abstract tree cannot be visualized"); // return NULL; // } // // PyObject* pystr = PyString_FromStringAndSize(gu_string_buf_data(sbuf), // gu_string_buf_length(sbuf)); // // gu_pool_free(tmp_pool); // return pystr; // } // // static void // pgf_embed_funs(GuMapItor* fn, const void* key, void* value, GuExn* err) // { // PyPGFClosure* clo = (PyPGFClosure*) fn; // // PgfCId name = (PgfCId) key; // // ExprObject* pyexpr = (ExprObject*) pgf_ExprType.tp_alloc(&pgf_ExprType, 0); // if (pyexpr == NULL) { // gu_raise(err, PgfExn); // return; // } // // pyexpr->master = (PyObject*) clo->grammar; // pyexpr->expr = pgf_fun_get_ep(value)->expr; // // Py_INCREF(pyexpr->master); // // if (PyModule_AddObject((PyObject*) clo->collection, name, (PyObject*) pyexpr) != 0) { // Py_DECREF(pyexpr); // gu_raise(err, PgfExn); // } // } // // static PyObject* // PGF_embed(PGFObject* self, PyObject *args) // { // PgfCId modname; // if (!PyArg_ParseTuple(args, "s", &modname)) // return NULL; // // PyObject *m = PyImport_AddModule(modname); // if (m == NULL) // return NULL; // // GuPool* tmp_pool = gu_local_pool(); // // // Create an exception frame that catches all errors. // GuExn* err = gu_new_exn(tmp_pool); // // PyPGFClosure clo = { { pgf_embed_funs }, self, m }; // pgf_iter_functions(self->pgf, &clo.fn, err); // if (!gu_ok(err)) { // Py_DECREF(m); // gu_pool_free(tmp_pool); // return NULL; // } // // gu_pool_free(tmp_pool); // // Py_INCREF(m); // return m; // } static PyGetSetDef PGF_getseters[] = { {"abstractName", (getter)PGF_getAbstractName, NULL, "the abstract syntax name", NULL}, // {"languages", // (getter)PGF_getLanguages, NULL, // "a map containing all concrete languages in the grammar", // NULL}, {"categories", (getter)PGF_getCategories, NULL, "a list containing all categories in the grammar", NULL}, // {"startCat", // (getter)PGF_getStartCat, NULL, // "the start category for the grammar", // NULL}, {"functions", (getter)PGF_getFunctions, NULL, "a list containing all functions in the grammar", NULL}, {NULL} /* Sentinel */ }; static PyMemberDef PGF_members[] = { {NULL} /* Sentinel */ }; static PyMethodDef PGF_methods[] = { {"functionsByCat", (PyCFunction)PGF_functionsByCat, METH_VARARGS, "Returns the list of functions for a given category" }, // {"functionType", (PyCFunction)PGF_functionType, METH_VARARGS, // "Returns the type of a function" // }, // {"generateAll", (PyCFunction)PGF_generateAll, METH_VARARGS | METH_KEYWORDS, // "Generates abstract syntax trees of given category in decreasing probability order" // }, // {"compute", (PyCFunction)PGF_compute, METH_VARARGS, // "Computes the normal form of an abstract syntax tree" // }, // {"checkExpr", (PyCFunction)PGF_checkExpr, METH_VARARGS, // "Type checks an abstract syntax expression and returns the updated expression" // }, // {"inferExpr", (PyCFunction)PGF_inferExpr, METH_VARARGS, // "Type checks an abstract syntax expression and returns the updated expression" // }, // {"checkType", (PyCFunction)PGF_checkType, METH_VARARGS, // "Type checks an abstract syntax type and returns the updated type" // }, // {"graphvizAbstractTree", (PyCFunction)PGF_graphvizAbstractTree, METH_VARARGS, // "Renders an abstract syntax tree in a Graphviz format" // }, // {"embed", (PyCFunction)PGF_embed, METH_VARARGS, // "embed(mod_name) creates a Python module with name mod_name, which " // "contains one Python object for every abstract function in the grammar. " // "The module can be imported to make it easier to construct abstract " // "syntax trees." // }, {NULL} /* Sentinel */ }; static PyTypeObject pgf_PGFType = { PyVarObject_HEAD_INIT(NULL, 0) //0, /*ob_size*/ "pgf.PGF", /*tp_name*/ sizeof(PGFObject), /*tp_basicsize*/ 0, /*tp_itemsize*/ (destructor)PGF_dealloc, /*tp_dealloc*/ 0, /*tp_print*/ 0, /*tp_getattr*/ 0, /*tp_setattr*/ 0, /*tp_compare*/ 0, /*tp_repr*/ 0, /*tp_as_number*/ 0, /*tp_as_sequence*/ 0, /*tp_as_mapping*/ 0, /*tp_hash */ 0, /*tp_call*/ (reprfunc) PGF_repr, /*tp_str*/ 0, /*tp_getattro*/ 0, /*tp_setattro*/ 0, /*tp_as_buffer*/ Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE, /*tp_flags*/ "PGF object", /*tp_doc*/ 0, /*tp_traverse */ 0, /*tp_clear */ 0, /*tp_richcompare */ 0, /*tp_weaklistoffset */ 0, /*tp_iter */ 0, /*tp_iternext */ PGF_methods, /*tp_methods */ PGF_members, /*tp_members */ PGF_getseters, /*tp_getset */ 0, /*tp_base */ 0, /*tp_dict */ 0, /*tp_descr_get */ 0, /*tp_descr_set */ 0, /*tp_dictoffset */ 0, /*tp_init */ 0, /*tp_alloc */ 0, /*tp_new */ }; static PGFObject* pgf_readPGF(PyObject *self, PyObject *args) { const char *fpath; if (!PyArg_ParseTuple(args, "s", &fpath)) return NULL; PGFObject* py_pgf = (PGFObject*) pgf_PGFType.tp_alloc(&pgf_PGFType, 0); // Read the PGF grammar. PgfExn err; py_pgf->pgf = pgf_read_pgf(fpath, &err); if (err.type == PGF_EXN_SYSTEM_ERROR) { errno = err.code; PyErr_SetFromErrnoWithFilename(PyExc_IOError, fpath); Py_DECREF(py_pgf); return NULL; } else if (err.type == PGF_EXN_PGF_ERROR) { PyErr_SetString(PGFError, err.msg); free((char*) err.msg); Py_DECREF(py_pgf); return NULL; } return py_pgf; } static PGFObject* pgf_bootNGF(PyObject *self, PyObject *args) { const char *fpath; // pgf const char *npath; // ngf if (!PyArg_ParseTuple(args, "ss", &fpath, &npath)) return NULL; PGFObject* py_pgf = (PGFObject*) pgf_PGFType.tp_alloc(&pgf_PGFType, 0); // Read the PGF grammar. PgfExn err; py_pgf->pgf = pgf_boot_ngf(fpath, npath, &err); if (err.type == PGF_EXN_SYSTEM_ERROR) { errno = err.code; PyErr_SetFromErrnoWithFilename(PyExc_IOError, npath); Py_DECREF(py_pgf); return NULL; } else if (err.type == PGF_EXN_PGF_ERROR) { PyErr_SetString(PGFError, err.msg); free((char*) err.msg); Py_DECREF(py_pgf); return NULL; } return py_pgf; } static PGFObject* pgf_readNGF(PyObject *self, PyObject *args) { const char *fpath; if (!PyArg_ParseTuple(args, "s", &fpath)) return NULL; PGFObject* py_pgf = (PGFObject*) pgf_PGFType.tp_alloc(&pgf_PGFType, 0); // Read the NGF grammar. PgfExn err; py_pgf->pgf = pgf_read_ngf(fpath, &err); if (err.type == PGF_EXN_SYSTEM_ERROR) { errno = err.code; PyErr_SetFromErrnoWithFilename(PyExc_IOError, fpath); Py_DECREF(py_pgf); return NULL; } else if (err.type == PGF_EXN_PGF_ERROR) { PyErr_SetString(PGFError, err.msg); free((char*) err.msg); Py_DECREF(py_pgf); return NULL; } return py_pgf; } // static ExprObject* // pgf_readExpr(PyObject *self, PyObject *args) { // Py_ssize_t len; // const uint8_t *buf; // if (!PyArg_ParseTuple(args, "s#", &buf, &len)) // return NULL; // // ExprObject* pyexpr = (ExprObject*) pgf_ExprType.tp_alloc(&pgf_ExprType, 0); // if (pyexpr == NULL) // return NULL; // // GuPool* tmp_pool = gu_local_pool(); // GuIn* in = gu_data_in(buf, len, tmp_pool); // GuExn* err = gu_new_exn(tmp_pool); // // pyexpr->pool = gu_new_pool(); // pyexpr->expr = pgf_read_expr(in, pyexpr->pool, tmp_pool, err); // pyexpr->master = NULL; // // if (!gu_ok(err) || gu_variant_is_null(pyexpr->expr)) { // PyErr_SetString(PGFError, "The expression cannot be parsed"); // Py_DECREF(pyexpr); // gu_pool_free(tmp_pool); // return NULL; // } // // gu_pool_free(tmp_pool); // return pyexpr; // } // // static TypeObject* // pgf_readType(PyObject *self, PyObject *args) { // Py_ssize_t len; // const uint8_t *buf; // if (!PyArg_ParseTuple(args, "s#", &buf, &len)) // return NULL; // // TypeObject* pytype = (TypeObject*) pgf_TypeType.tp_alloc(&pgf_TypeType, 0); // if (pytype == NULL) // return NULL; // // GuPool* tmp_pool = gu_local_pool(); // GuIn* in = gu_data_in(buf, len, tmp_pool); // GuExn* err = gu_new_exn(tmp_pool); // // pytype->pool = gu_new_pool(); // pytype->type = pgf_read_type(in, pytype->pool, tmp_pool, err); // pytype->master = NULL; // // if (!gu_ok(err) || pytype->type == NULL) { // PyErr_SetString(PGFError, "The type cannot be parsed"); // Py_DECREF(pytype); // gu_pool_free(tmp_pool); // return NULL; // } // // gu_pool_free(tmp_pool); // return pytype; // } static PyMethodDef module_methods[] = { {"readPGF", (void*)pgf_readPGF, METH_VARARGS, "Reads a PGF file into memory"}, {"bootNGF", (void*)pgf_bootNGF, METH_VARARGS, "Reads a PGF file into memory and stores the unpacked data in an NGF file"}, {"readNGF", (void*)pgf_readNGF, METH_VARARGS, "Reads an NGF file into memory"}, // {"readExpr", (void*)pgf_readExpr, METH_VARARGS, // "Parses a string as an abstract tree"}, // {"readType", (void*)pgf_readType, METH_VARARGS, // "Parses a string as an abstract type"}, {NULL, NULL, 0, NULL} /* Sentinel */ }; #if PY_MAJOR_VERSION >= 3 #define MOD_ERROR_VAL NULL #define MOD_SUCCESS_VAL(val) val #define MOD_INIT(name) PyMODINIT_FUNC PyInit_##name(void) #define MOD_DEF(ob, name, doc, methods) \ static struct PyModuleDef moduledef = { \ PyModuleDef_HEAD_INIT, name, doc, -1, methods, }; \ ob = PyModule_Create(&moduledef); #else #define MOD_ERROR_VAL #define MOD_SUCCESS_VAL(val) #define MOD_INIT(name) void init##name(void) #define MOD_DEF(ob, name, doc, methods) \ ob = Py_InitModule3(name, methods, doc); #endif MOD_INIT(pgf) { PyObject *m; if (PyType_Ready(&pgf_PGFType) < 0) return MOD_ERROR_VAL; // if (PyType_Ready(&pgf_ConcrType) < 0) // return MOD_ERROR_VAL; // // if (PyType_Ready(&pgf_BracketType) < 0) // return MOD_ERROR_VAL; // // if (PyType_Ready(&pgf_BINDType) < 0) // return MOD_ERROR_VAL; // // if (PyType_Ready(&pgf_ExprType) < 0) // return MOD_ERROR_VAL; // // if (PyType_Ready(&pgf_TypeType) < 0) // return MOD_ERROR_VAL; // // if (PyType_Ready(&pgf_IterType) < 0) // return MOD_ERROR_VAL; MOD_DEF(m, "pgf", "The Runtime for Portable Grammar Format in Python", module_methods); if (m == NULL) return MOD_ERROR_VAL; PGFError = PyErr_NewException("pgf.PGFError", NULL, NULL); PyModule_AddObject(m, "PGFError", PGFError); Py_INCREF(PGFError); PyObject *dict = PyDict_New(); PyDict_SetItemString(dict, "token", PyString_FromStringAndSize("", 0)); ParseError = PyErr_NewException("pgf.ParseError", NULL, dict); PyModule_AddObject(m, "ParseError", ParseError); Py_INCREF(ParseError); TypeError = PyErr_NewException("pgf.TypeError", NULL, NULL); PyModule_AddObject(m, "TypeError", TypeError); Py_INCREF(TypeError); // PyModule_AddObject(m, "Expr", (PyObject *) &pgf_ExprType); // Py_INCREF(&pgf_ExprType); // // PyModule_AddObject(m, "Type", (PyObject *) &pgf_TypeType); // Py_INCREF(&pgf_TypeType); // // PyModule_AddObject(m, "PGF", (PyObject *) &pgf_PGFType); // Py_INCREF(&pgf_PGFType); // // PyModule_AddObject(m, "Concr", (PyObject *) &pgf_ConcrType); // Py_INCREF(&pgf_ConcrType); // // PyModule_AddObject(m, "Iter", (PyObject *) &pgf_IterType); // Py_INCREF(&pgf_IterType); // // PyModule_AddObject(m, "Bracket", (PyObject *) &pgf_BracketType); // Py_INCREF(&pgf_BracketType); // // PyModule_AddObject(m, "BIND", (PyObject *) &pgf_BINDType); // Py_INCREF(&pgf_BINDType); return MOD_SUCCESS_VAL(m); }