Changeset 51

Show
Ignore:
Timestamp:
12/04/06 17:17:31 (2 years ago)
Author:
KirkMcDonald
Message:

Support for one-at-a-time compilation. (Preparing for GDC support.)

Files:

Legend:

Unmodified
Added
Removed
Modified
Copied
Moved

  • trunk/dcompiler.py

    r49 r51  
    242242        # compiling all at once works. This flags allows me to test each form 
    243243        # easily. Supporting the one-by-one form is synonymous with GDC support. 
    244         ONE_BY_ONE = False 
     244        ONE_BY_ONE = True 
    245245        if ONE_BY_ONE: 
    246246            for source in sources: 
    …… 
    516516        self._debugOpt = '-fdebug=%s' 
    517517        # _defaultOptimizeOpts 
    518         self._defaultOptimizeOpts = ['-fdebug', '-funittest'] 
     518        self._defaultOptimizeOpts = ['-fdebug'] 
    519519        # _debugOptimizeOpts 
    520         self._debugOptimizeOpts = self._defaultOptimizeOpts + ['-g'] 
     520        self._debugOptimizeOpts = self._defaultOptimizeOpts + ['-g', '-funittest'] 
    521521        # _releaseOptimizeOpts 
    522522        self._releaseOptimizeOpts = ['-fversion=Optimized', '-frelease', '-O3', '-finline-functions'] 

  • trunk/html_doc/install.html

    r49 r51  
    2929<p>Pyd requires Python 2.4 or newer and the latest version of DMD.</p> 
    3030 
    31 <p>At the moment, Pyd is only supported on Windows using the <a href="http://digitalmars.com/d/index.html">DMD</a> compiler. GDC support has been written, but Pyd cannot yet be compiled with GDC (due to <a href="http://d.puremagic.com/issues/show_bug.cgi?id=311">this bug</a>). Once GDC support is available, Pyd should work on Linux. Support for Derek Parnell's <code>bud</code> is also planned.</p> 
     31<p>At the moment, Pyd is only supported on Windows using the <a href="http://digitalmars.com/d/index.html">DMD</a> compiler. Linux support is contingent on GDC catching up to at least DMD 0.176. Support for Derek Parnell's <code>bud</code> is also planned.</p> 
    3232 
    3333<p>Because Pyd is still in development, it is only available via Subversion. The repository is located <a href="http://svn.dsource.org/projects/pyd/trunk">here</a>.</p> 

  • trunk/infrastructure/pyd/class_wrap.d

    r50 r51  
    2222module pyd.class_wrap; 
    2323 
    24 private { 
    25     import python; 
    26  
    27     import pyd.ctor_wrap; 
    28     import pyd.def; 
    29     import pyd.exception; 
    30     import pyd.func_wrap; 
    31     version(Pyd_with_StackThreads) { 
    32         import pyd.iteration; 
    33     } 
    34     import pyd.make_object; 
    35     import pyd.op_wrap; 
    36  
    37     import meta.Default; 
    38     import meta.Nameof; 
    39  
    40     import std.string; 
    41     import std.traits; 
    42 } 
     24import python; 
     25 
     26import pyd.ctor_wrap; 
     27import pyd.def; 
     28import pyd.exception; 
     29import pyd.func_wrap; 
     30version(Pyd_with_StackThreads) { 
     31    import pyd.iteration; 
     32} 
     33import pyd.make_object; 
     34import pyd.op_wrap; 
     35 
     36import meta.Default; 
     37import meta.Nameof; 
     38 
     39import std.string; 
     40import std.traits; 
    4341 
    4442bool[TypeInfo] wrapped_classes; 
    …… 
    364362 * calls to the wrapped_class member functions. 
    365363 */ 
    366 void finalize_class(CLS) (CLS cls) { 
     364void finalize_class(CLS) (CLS cls, char[] modulename="") { 
    367365    alias typeof(cls.t) T; 
    368366    alias wrapped_class_type!(T) type; 
    …… 
    371369     
    372370    assert(Pyd_Module_p !is null, "Must initialize module before wrapping classes."); 
    373     char[] module_name = toString(PyModule_GetName(Pyd_Module_p)); 
     371    char[] module_name = toString(PyModule_GetName(Pyd_Module_p(modulename))); 
    374372    // Fill in missing values 
    375373    type.ob_type      = PyType_Type_p(); 
    …… 
    426424    } 
    427425    Py_INCREF(cast(PyObject*)&type); 
    428     PyModule_AddObject(Pyd_Module_p, name, cast(PyObject*)&type); 
     426    PyModule_AddObject(Pyd_Module_p(modulename), name, cast(PyObject*)&type); 
    429427    is_wrapped!(T) = true; 
    430428    wrapped_classes[typeid(T)] = true; 

  • trunk/infrastructure/pyd/def.d

    r50 r51  
    2929private import meta.Nameof; 
    3030 
    31 private 
    32 PyMethodDef module_global_methods[] = [ 
     31private PyMethodDef module_global_methods[] = [ 
    3332    { null, null, 0, null } 
    3433]; 
    3534 
    36 private 
    37 PyObject* m_module; 
     35private PyMethodDef[][char[]] module_methods; 
     36private PyObject*[char[]] pyd_modules; 
    3837 
    39 PyObject* Pyd_Module_p() { 
    40     return m_module; 
     38PyObject* Pyd_Module_p(char[] modulename="") { 
     39    return pyd_modules[modulename]; 
    4140} 
    4241 
    …… 
    7372 *It's greater than 10!) 
    7473 */ 
    75 template def(alias fn, char[] name = symbolnameof!(fn), fn_t=typeof(&fn), uint MIN_ARGS = minArgs!(fn, fn_t)) { 
     74void def(alias fn, char[] name = symbolnameof!(fn), fn_t=typeof(&fn), uint MIN_ARGS = minArgs!(fn, fn_t)) () { 
     75    def!("", fn, name, fn_t, MIN_ARGS)(); 
     76} 
     77 
     78void def(char[] modulename, alias fn, char[] name = symbolnameof!(fn), fn_t=typeof(&fn), uint MIN_ARGS = minArgs!(fn, fn_t)) () { 
    7679    pragma(msg, "def: " ~ name); 
    77     void def() { 
    78         PyMethodDef empty; 
    79         alias module_global_methods list; 
     80    PyMethodDef empty; 
     81    if (!(modulename in module_methods)) { 
     82        module_methods[modulename] = (PyMethodDef[]).init; 
     83        module_methods[modulename] ~= empty; 
     84    } 
     85    PyMethodDef[]* list = &module_methods[modulename]; 
    8086 
    81         list[length-1].ml_name = name ~ \0; 
    82         list[length-1].ml_meth = &function_wrap!(fn, MIN_ARGS, fn_t).func; 
    83         list[length-1].ml_flags = METH_VARARGS; 
    84         list[length-1].ml_doc = ""; 
    85         list ~= empty; 
    86     } 
     87    (*list)[length-1].ml_name = name ~ \0; 
     88    (*list)[length-1].ml_meth = &function_wrap!(fn, MIN_ARGS, fn_t).func; 
     89    (*list)[length-1].ml_flags = METH_VARARGS; 
     90    (*list)[length-1].ml_doc = ""; 
     91    (*list) ~= empty; 
    8792} 
    8893 
    …… 
    9297PyObject* module_init(char[] name) { 
    9398    //_loadPythonSupport(); 
    94     m_module = Py_InitModule(name ~ \0, module_global_methods); 
    95     return m_module; 
     99    pyd_modules[""] = Py_InitModule(name ~ \0, module_methods[""].ptr); 
     100    return pyd_modules[""]; 
    96101} 
    97102 
     103/** 
     104 * Module initialization function. Should be called after the last call to def. 
     105 */ 
     106PyObject* add_module(char[] name) { 
     107    pyd_modules[name] = Py_InitModule(name ~ \0, module_methods[name].ptr); 
     108    return pyd_modules[name]; 
     109} 
     110 

  • trunk/infrastructure/pyd/dg_convert.d

    r45 r51  
    2828module pyd.dg_convert; 
    2929 
    30 private import std.traits; 
     30import std.traits; 
    3131 
    3232template fn_to_dgT(Fn) { 

  • trunk/infrastructure/pyd/iteration.d

    r49 r51  
    2727module pyd.iteration; 
    2828 
    29 private { 
    30     import python; 
     29import python; 
    3130 
    32     import pyd.class_wrap; 
    33     import pyd.dg_convert; 
    34     import pyd.exception; 
    35     import pyd.make_object; 
     31import pyd.class_wrap; 
     32import pyd.dg_convert; 
     33import pyd.exception; 
     34import pyd.make_object; 
    3635 
    37     import std.traits; 
     36import std.traits; 
    3837 
    39     import st.stackcontext; 
    40 } 
     38import st.stackcontext; 
    4139 
    4240// This exception is for yielding a PyObject* from within a StackContext. 

  • trunk/infrastructure/pyd/make_object.d

    r50 r51  
    3535module pyd.make_object; 
    3636 
    37 private import python; 
    38  
    39 private import std.string; 
    40  
    41 private import pyd.pydobject; 
    42 private import pyd.class_wrap; 
    43 private import pyd.func_wrap; 
    44 private import pyd.exception; 
     37import python; 
     38 
     39import std.string; 
     40 
     41import pyd.pydobject; 
     42import pyd.class_wrap; 
     43import pyd.func_wrap; 
     44import pyd.exception; 
    4545 
    4646private template isArray(T) { 
    …… 
    227227        return Py_None; 
    228228    } else static if (is(T == class)) { 
     229        static if (is(T == Object)) { 
     230            pragma(msg, "d_type: T is Object"); 
     231        } 
    229232        // We can only convert to a class if it has been wrapped, and of course 
    230233        // we can only convert the object if it is the wrapped type. 
    …… 
    290293} 
    291294 
     295alias d_type!(Object) d_type_Object; 
     296 
    292297private 
    293298void could_not_convert(T) (PyObject* o) { 

  • trunk/infrastructure/pyd/op_wrap.d

    r50 r51  
    2222module pyd.op_wrap; 
    2323 
    24 private import python; 
    25  
    26 private import pyd.class_wrap; 
    27 private import pyd.dg_convert; 
    28 private import pyd.func_wrap; 
    29 private import pyd.exception; 
    30 private import pyd.make_object; 
    31  
    32 private import meta.Nameof; 
    33  
    34 private import std.traits; 
     24import python; 
     25 
     26import pyd.class_wrap; 
     27import pyd.dg_convert; 
     28import pyd.func_wrap; 
     29import pyd.exception; 
     30import pyd.make_object; 
     31 
     32import meta.Nameof; 
     33 
     34import std.traits; 
    3535 
    3636version(Python_2_5_Or_Later) { 
    …… 
    123123    alias ParameterTypeTuple!(opfn) Info; 
    124124    alias ReturnType!(opfn) Ret; 
     125    alias dg_wrapper!(T, typeof(&opfn)) get_dg; 
    125126    extern(C) 
    126127    PyObject* func(PyObject* self, PyObject* o) { 
    127128        return exception_catcher(delegate PyObject*() { 
    128             auto dg = dg_wrapper((cast(wrap_object*)self).d_obj, &opfn); 
     129            auto dg = get_dg((cast(wrap_object*)self).d_obj, &opfn); 
    129130            pragma(msg, prettytypeof!(typeof(dg))); 
    130131            pragma(msg, symbolnameof!(opfn)); 
    …… 
    193194        } 
    194195    } else { 
     196        alias method_wrap!(T, T.opIndex, typeof(&T.opIndex)) opindex_methodT; 
    195197        extern(C) 
    196198        PyObject* func(PyObject* self, PyObject* key) { 
    …… 
    205207                return null; 
    206208            } 
    207             return method_wrap!(T, T.opIndex, typeof(&T.opIndex)).func(self, key); 
     209            return opindex_methodT.func(self, key); 
    208210        } 
    209211    } 

  • trunk/infrastructure/pyd/pyd.d

    r49 r51  
    2727module pyd.pyd; 
    2828 
    29 public import pyd.def; 
    30 public import pyd.class_wrap; 
    31 //public import pyd.ctor_wrap; 
    32 public import pyd.pydobject; 
    33 public import pyd.exception; 
    34 public import pyd.func_wrap; 
    35 public import pyd.make_object; 
     29public { 
     30    import pyd.class_wrap; 
     31    import pyd.def; 
     32    import pyd.exception; 
     33    import pyd.func_wrap; 
     34    import pyd.make_object; 
     35    import pyd.pydobject; 
    3636 
     37    // Importing these is only needed as a workaround to bug #311 
     38    import pyd.ctor_wrap; 
     39    import pyd.dg_convert; 
     40    import pyd.exception; 
     41    import pyd.func_wrap; 
     42    import pyd.iteration; 
     43} 
     44