root/releases/pkgcore/0.2.3/src/depset.c @ ferringb%2540gmail.com-20070212040248-yk0xjuw7uw000agr

Revision ferringb%2540gmail.com-20070212040248-yk0xjuw7uw000agr, 16.1 KB (checked in by Brian Harring <ferringb@…>, 2 years ago)

few tweaks to logic flow, and arg ordering.
Line 
1/*
2 * Copyright: 2006 Brian Harring <ferringb@gmail.com>
3 * License: GPL2
4 *
5 * C version of some of pkgcore (for extra speed).
6 */
7
8/* This does not really do anything since we do not use the "#"
9 * specifier in a PyArg_Parse or similar call, but hey, not using it
10 * means we are Py_ssize_t-clean too!
11 */
12
13#define PY_SSIZE_T_CLEAN
14
15#include <Python.h>
16#include "py24-compatibility.h"
17
18// exceptions, loaded during initialization.
19static PyObject *pkgcore_depset_ParseErrorExc = NULL;
20static PyObject *pkgcore_depset_ValContains = NULL;
21static PyObject *pkgcore_depset_PkgCond = NULL;
22static PyObject *pkgcore_depset_PkgAnd = NULL;
23static PyObject *pkgcore_depset_PkgOr = NULL;
24
25#define ISDIGIT(c) ('0' <= (c) && '9' >= (c))
26#define ISALPHA(c) (('a' <= (c) && 'z' >= (c)) || ('A' <= (c) && 'Z' >= (c)))
27#define ISLOWER(c) ('a' <= (c) && 'z' >= (c))
28#define ISALNUM(c) (ISALPHA(c) || ISDIGIT(c))
29
30static void
31_Err_SetParse(PyObject *dep_str, PyObject *msg, char *tok_start, char *tok_end)
32{
33    PyObject *ret;
34    PyObject *args = Py_BuildValue("(S)", dep_str);
35    if(!args)
36        return;
37    PyObject *kwds = Py_BuildValue("{sSss#}", "msg", msg,
38        "token", tok_start, tok_end - tok_start);
39    if(kwds) {
40        ret = PyObject_Call(pkgcore_depset_ParseErrorExc, args, kwds);
41        if(ret) {
42            PyErr_SetObject(pkgcore_depset_ParseErrorExc, ret);
43            Py_DECREF(ret);
44        }
45        Py_DECREF(kwds);
46    }
47    Py_DECREF(args);
48}
49
50static void
51Err_WrapException(PyObject *dep_str, char *tok_start,
52    char *tok_end)
53{
54    PyObject *type, *val, *tb;
55    PyErr_Fetch(&type, &val, &tb);
56    if(val) {
57        _Err_SetParse(dep_str, val, tok_start, tok_end);
58    }
59    Py_XDECREF(type);
60    Py_XDECREF(val);
61    Py_XDECREF(tb);
62}
63
64static void
65Err_SetParse(PyObject *dep_str, char *msg, char *tok_start, char *tok_end)
66{
67    PyObject *s = PyString_FromString(msg);
68    if(!s)
69        return;
70    _Err_SetParse(dep_str, s, tok_start, tok_end);
71    Py_DECREF(s);
72}
73
74static inline PyObject *
75make_use_conditional(char *use_start, char *use_end, PyObject *payload)
76{
77    PyObject *val;
78    if('!' == *use_start) {
79        PyObject *kwds = Py_BuildValue("{sO}", "negate", Py_True);
80        if(!kwds)
81            return NULL;
82        PyObject *args = Py_BuildValue("(s#)", use_start + 1,
83            use_end - use_start -1);
84        if(!args) {
85            Py_DECREF(kwds);
86            return NULL;
87        }
88        val = PyObject_Call(pkgcore_depset_ValContains, args, kwds);
89        Py_DECREF(args);
90        Py_DECREF(kwds);
91    } else {
92        val = PyObject_CallFunction(pkgcore_depset_ValContains, "s#",
93            use_start, use_end - use_start);
94    }
95    if(!val)
96        return NULL;
97   
98    PyObject *restriction = PyObject_CallFunction(pkgcore_depset_PkgCond,
99        "sOO", "use", val, payload);
100    Py_DECREF(val);
101    return restriction;
102}
103
104#define SKIP_SPACES(ptr)     \
105while ('\t' == *(ptr) || ' ' == *(ptr) || '\n' == *(ptr)) (ptr)++;
106
107#define SKIP_NONSPACES(ptr)                                                  \
108while('\t' != *(ptr) && ' ' != *(ptr) && '\n' != *(ptr) && '\0' != *(ptr))  \
109    (ptr)++;
110
111#define ISSPACE(ptr) ('\t' == *(ptr) || ' ' == *(ptr) || '\n' == *(ptr))
112
113static PyObject *
114internal_parse_depset(PyObject *dep_str, char **ptr, int *has_conditionals,
115    PyObject *element_func,
116    PyObject *and_func, PyObject *or_func,
117    char initial_frame)
118{
119    char *start = *ptr;
120    char *p = NULL;
121    PyObject *restrictions = NULL;
122    PyObject *item = NULL;
123    PyObject *tmp = NULL;
124    PyObject *kwds = NULL;
125
126    // should just use alloca here.
127
128    #define PARSE_DEPSET_STACK_STORAGE 16
129    PyObject *stack_restricts[PARSE_DEPSET_STACK_STORAGE];
130    Py_ssize_t item_count = 0, tup_size = PARSE_DEPSET_STACK_STORAGE;
131
132    SKIP_SPACES(start);
133    p = start;
134    while('\0' != *start) {
135        start = p;
136        SKIP_NONSPACES(p);
137        if('(' == *start) {
138            // new and frame.
139            if(!and_func) {
140                Err_SetParse(dep_str, "this depset doesn't support and blocks",
141                start, p);
142                goto internal_parse_depset_error;
143            }
144            if(p - start != 1) {
145                Err_SetParse(dep_str,
146                    "either a space or end of string is required after (",
147                    start, p);
148                goto internal_parse_depset_error;
149            }
150            if(!(tmp = internal_parse_depset(dep_str, &p, has_conditionals,
151                element_func, and_func, or_func, 0)))
152                goto internal_parse_depset_error;
153
154            if(tmp == Py_None) {
155                Py_DECREF(tmp);
156                Err_SetParse(dep_str, "empty payload", start, p);
157                goto internal_parse_depset_error;
158            } else if(!PyTuple_CheckExact(tmp)) {
159                item = tmp;
160            } else {
161                if(!(kwds = Py_BuildValue("{sO}", "finalize", Py_True))) {
162                    Py_DECREF(tmp);
163                    goto internal_parse_depset_error;
164                }
165
166                item = PyObject_Call(and_func, tmp, kwds);
167                Py_DECREF(kwds);
168                Py_DECREF(tmp);
169                if(!item)
170                    goto internal_parse_depset_error;
171            }
172
173        } else if(')' == *start) {
174            // end of a frame
175            if(initial_frame) {
176                Err_SetParse(dep_str, ") found without matching (",
177                    NULL, NULL);
178                goto internal_parse_depset_error;
179            }
180            if(p - start != 1) {
181                Err_SetParse(dep_str,
182                    "either a space or end of string is required after )",
183                    start, p);
184                goto internal_parse_depset_error;
185            }
186
187            if(!*p)
188                p--;
189            break;
190
191        } else if('?' == p[-1]) {
192            // use conditional
193            if (p - start == 1 || ('!' == *start && p - start == 2)) {
194                Err_SetParse(dep_str, "empty use conditional", start, p);
195                goto internal_parse_depset_error;
196            }
197            char *conditional_end = p - 1;
198            SKIP_SPACES(p);
199            if ('(' != *p) {
200                Err_SetParse(dep_str,
201                    "( has to be the next token for a conditional",
202                    start, p);
203                goto internal_parse_depset_error;
204            } else if(!ISSPACE(p + 1) || '\0' == p[1]) {
205                Err_SetParse(dep_str,
206                    "( has to be followed by whitespace",
207                    start, p);
208                goto internal_parse_depset_error;
209            }
210            p++;
211            if(!(tmp = internal_parse_depset(dep_str, &p, has_conditionals,
212                element_func, and_func, or_func, 0)))
213                goto internal_parse_depset_error;
214
215            if(tmp == Py_None) {
216                Py_DECREF(tmp);
217                Err_SetParse(dep_str, "empty payload", start, p);
218                goto internal_parse_depset_error;
219
220            } else if(!PyTuple_CheckExact(tmp)) {
221                item = PyTuple_New(1);
222                if(!tmp) {
223                    Py_DECREF(item);
224                    goto internal_parse_depset_error;
225                }
226                PyTuple_SET_ITEM(item, 0, tmp);
227                tmp = item;
228            }
229            item = make_use_conditional(start, conditional_end, tmp);
230            Py_DECREF(tmp);
231            if(!item)
232                goto internal_parse_depset_error;
233            *has_conditionals = 1;
234
235        } else if ('|' == *start) {
236            if('|' != start[1] || !or_func) {
237                Err_SetParse(dep_str,
238                    "stray |, or this depset doesn't support or blocks",
239                    NULL, NULL);
240                goto internal_parse_depset_error;
241            }
242
243            if(p - start != 2) {
244                Err_SetParse(dep_str, "|| must have space followed by a (",
245                    start, p);
246                goto internal_parse_depset_error;
247            }
248            SKIP_SPACES(p);
249            if ('(' != *p || (!ISSPACE(p + 1) && '\0' != p[1])) {
250                Err_SetParse(dep_str,
251                    "( has to be the next token for a conditional",
252                    start, p);
253                goto internal_parse_depset_error;
254            }
255            p++;
256            if(!(tmp = internal_parse_depset(dep_str, &p, has_conditionals,
257                element_func, and_func, or_func, 0)))
258                goto internal_parse_depset_error;
259           
260            if(tmp == Py_None) {
261                Py_DECREF(tmp);
262                Err_SetParse(dep_str, "empty payload", start, p);
263                goto internal_parse_depset_error;
264            } else if (!PyTuple_CheckExact(tmp)) {
265                item = tmp;
266            } else {
267                if(!(kwds = Py_BuildValue("{sO}", "finalize", Py_True))) {
268                    Py_DECREF(tmp);
269                    goto internal_parse_depset_error;
270                }
271                item = PyObject_Call(or_func, tmp, kwds);
272                Py_DECREF(kwds);
273                Py_DECREF(tmp);
274                if(!item)
275                    goto internal_parse_depset_error;
276            }
277        } else {
278            char *ptr_s = start;
279            while (ptr_s < p) {
280                if('|' == *ptr_s || ')' == *ptr_s || '(' == *ptr_s) {
281                    Err_SetParse(dep_str,
282                        "stray character detected in item", start ,p);
283                    goto internal_parse_depset_error;
284                }
285                ptr_s++;
286            }
287            item = PyObject_CallFunction(element_func, "s#", start, p - start);
288            if(!item) {
289                Err_WrapException(dep_str, start, p);
290                goto internal_parse_depset_error;
291            }
292            assert(!PyErr_Occurred());
293        }
294
295        // append it.
296        if(item_count == tup_size) {
297            if(!restrictions) {
298                // switch over.
299                restrictions = PyTuple_New(PARSE_DEPSET_STACK_STORAGE << 1);
300                if(!restrictions) {
301                    Py_DECREF(item);
302                    goto internal_parse_depset_error;
303                }
304                for(item_count=0; item_count < PARSE_DEPSET_STACK_STORAGE;
305                    item_count++) {
306                    PyTuple_SET_ITEM(restrictions, item_count,
307                        stack_restricts[item_count]);
308                }
309            } else if(_PyTuple_Resize(&restrictions, tup_size * 2)) {
310                Py_DECREF(item);
311                goto internal_parse_depset_error;
312            }
313            tup_size *= 2;
314            // now we're using restrictions.
315        }
316        if(restrictions) {
317            PyTuple_SET_ITEM(restrictions, item_count, item);
318        } else {
319            stack_restricts[item_count] = item;
320        }
321        item_count++;
322        SKIP_SPACES(p);
323        start = p;
324    }
325
326    if(initial_frame) {
327        if(*p) {
328            Err_SetParse(dep_str, "stray ')' encountered", start, p);
329            goto internal_parse_depset_error;
330        }
331    } else {
332        if('\0' == *p) {
333            Err_SetParse(dep_str, "depset lacks closure", *ptr, p);
334            goto internal_parse_depset_error;
335        }
336        p++;
337    }
338
339    if(!restrictions) {
340        if(item_count == 0) {
341            restrictions = Py_None;
342            Py_INCREF(restrictions);
343        } else if(item_count == 1) {
344            restrictions = stack_restricts[0];
345        } else {
346            restrictions = PyTuple_New(item_count);
347            if(!restrictions)
348                goto internal_parse_depset_error;
349            item_count--;
350            while(item_count >= 0) {
351                PyTuple_SET_ITEM(restrictions, item_count,
352                    stack_restricts[item_count]);
353                item_count--;
354            }
355        }
356    } else if(item_count < tup_size) {
357        if(_PyTuple_Resize(&restrictions, item_count))
358            goto internal_parse_depset_error;
359    }
360    *ptr = p;
361    return restrictions;
362   
363    internal_parse_depset_error:
364    if(item_count) {
365        if(!restrictions) {
366            item_count--;
367            while(item_count >= 0) {
368                Py_DECREF(stack_restricts[item_count]);
369                item_count--;
370            }
371        } else
372            Py_DECREF(restrictions);
373    }
374    // dealloc.
375    return NULL;
376}           
377
378static PyObject *
379pkgcore_parse_depset(PyObject *self, PyObject *args)
380{
381    PyObject *dep_str, *element_func;
382    PyObject *and_func = NULL, *or_func = NULL;
383    if(!PyArg_ParseTuple(args, "SO|OO", &dep_str, &element_func, &and_func,
384        &or_func))
385        return NULL;
386
387    int has_conditionals = 0;
388
389    if(and_func == Py_None)
390        and_func = NULL;
391    if(or_func == Py_None)
392        or_func = NULL;
393
394    char *p = PyString_AsString(dep_str);
395    if(!p)
396        return NULL;
397    PyObject *ret = internal_parse_depset(dep_str, &p, &has_conditionals,
398        element_func, and_func, or_func, 1);
399    if(!ret)
400        return NULL;
401    if(!PyTuple_Check(ret)) {
402        PyObject *tmp;
403        if(ret == Py_None) {
404            tmp = PyTuple_New(0);
405        } else {
406            tmp = PyTuple_New(1);
407            PyTuple_SET_ITEM(tmp, 0, ret);
408        }
409        if(!tmp) {
410            Py_DECREF(ret);
411            return NULL;
412        }
413        ret = tmp;
414    }
415    PyObject *conditionals_bool = has_conditionals ? Py_True : Py_False;
416    Py_INCREF(conditionals_bool);
417   
418    PyObject *final = PyTuple_New(2);
419    if(!final) {
420        Py_DECREF(ret);
421        Py_DECREF(conditionals_bool);
422        return NULL;
423    }
424    PyTuple_SET_ITEM(final, 0, conditionals_bool);
425    PyTuple_SET_ITEM(final, 1, ret);
426    return final;
427}
428
429static PyMethodDef pkgcore_depset_methods[] = {
430    {"parse_depset", (PyCFunction)pkgcore_parse_depset, METH_VARARGS,
431        "initialize a depset instance"},
432    {NULL}
433};
434
435
436PyDoc_STRVAR(
437    pkgcore_depset_documentation,
438    "cpython depset parsing functionality");
439
440
441static int
442load_external_objects()
443{
444    PyObject *s, *m = NULL;
445    #define LOAD_MODULE(module)         \
446    s = PyString_FromString(module);    \
447    if(!s)                              \
448        return 1;                       \
449    m = PyImport_Import(s);             \
450    Py_DECREF(s);                       \
451    if(!m)                              \
452        return 1;
453       
454    if(!pkgcore_depset_ParseErrorExc) {
455        LOAD_MODULE("pkgcore.ebuild.errors");
456        pkgcore_depset_ParseErrorExc = PyObject_GetAttrString(m,
457            "ParseError");
458        Py_DECREF(m);
459        if(!pkgcore_depset_ParseErrorExc) {
460            return 1;
461        }
462    }
463    if(!pkgcore_depset_ValContains) {
464        LOAD_MODULE("pkgcore.restrictions.values");
465        pkgcore_depset_ValContains = PyObject_GetAttrString(m,
466            "ContainmentMatch");
467        Py_DECREF(m);
468        if(!pkgcore_depset_ValContains)
469            return 1;
470    }
471    if(!pkgcore_depset_PkgCond) {
472        LOAD_MODULE("pkgcore.restrictions.packages");
473        pkgcore_depset_PkgCond = PyObject_GetAttrString(m,
474            "Conditional");
475        Py_DECREF(m);
476        if(!pkgcore_depset_PkgCond)
477            return 1;
478    }
479
480    if(!pkgcore_depset_PkgAnd || !pkgcore_depset_PkgOr) {
481        LOAD_MODULE("pkgcore.restrictions.boolean");
482    } else
483        m = NULL;
484       
485    #undef LOAD_MODULE
486
487    #define LOAD_ATTR(ptr, attr)                            \
488    if(!(ptr)) {                                            \
489        if(!((ptr) = PyObject_GetAttrString(m, (attr)))) {  \
490            Py_DECREF(m);                                   \
491            return 1;                                       \
492        }                                                   \
493    }
494    LOAD_ATTR(pkgcore_depset_PkgAnd, "AndRestriction");
495    LOAD_ATTR(pkgcore_depset_PkgOr, "OrRestriction");
496    #undef LOAD_ATTR
497
498    Py_CLEAR(m);
499    return 0;
500}
501
502
503PyMODINIT_FUNC
504init_depset()
505{
506    // first get the exceptions we use.
507    if(load_external_objects())
508        /* XXX this returns *before* we called Py_InitModule3, so it
509         * triggers a SystemError. But if we initialize the module
510         * first python code can get at uninitialized pointers through
511         * our exported functions, which would be worse.
512         */
513         return;
514
515    if (!Py_InitModule3("_depset", pkgcore_depset_methods,
516                        pkgcore_depset_documentation))
517        return;
518
519    /* Success! */
520}
Note: See TracBrowser for help on using the browser.