Ignore:
Timestamp:
Mar 19, 2014, 11:11:30 AM (11 years ago)
Author:
dmik
Message:

python: Update vendor to 2.7.6.

File:
1 edited

Legend:

Unmodified
Added
Removed

  • python/vendor/current/Modules/dbmmodule.c

    r2 r388  
    3333
    3434typedef struct {
    35         PyObject_HEAD
    36         int di_size;    /* -1 means recompute */
    37         DBM *di_dbm;
     35    PyObject_HEAD
     36    int di_size;        /* -1 means recompute */
     37    DBM *di_dbm;
    3838} dbmobject;
    3939
    … …  
    5050newdbmobject(char *file, int flags, int mode)
    5151{
    52         dbmobject *dp;
    53 
    54         dp = PyObject_New(dbmobject, &Dbmtype);
    55         if (dp == NULL)
    56                 return NULL;
    57         dp->di_size = -1;
    58         if ( (dp->di_dbm = dbm_open(file, flags, mode)) == 0 ) {
    59                 PyErr_SetFromErrno(DbmError);
    60                 Py_DECREF(dp);
    61                 return NULL;
    62         }
    63         return (PyObject *)dp;
     52    dbmobject *dp;
     53
     54    dp = PyObject_New(dbmobject, &Dbmtype);
     55    if (dp == NULL)
     56        return NULL;
     57    dp->di_size = -1;
     58    if ( (dp->di_dbm = dbm_open(file, flags, mode)) == 0 ) {
     59        PyErr_SetFromErrno(DbmError);
     60        Py_DECREF(dp);
     61        return NULL;
     62    }
     63    return (PyObject *)dp;
    6464}
    6565
    … …  
    6969dbm_dealloc(register dbmobject *dp)
    7070{
    71         if ( dp->di_dbm )
    72                 dbm_close(dp->di_dbm);
    73         PyObject_Del(dp);
     71    if ( dp->di_dbm )
     72        dbm_close(dp->di_dbm);
     73    PyObject_Del(dp);
    7474}
    7575
    … …  
    7777dbm_length(dbmobject *dp)
    7878{
    79         if (dp->di_dbm == NULL) {
    80                  PyErr_SetString(DbmError, "DBM object has already been closed");
    81                  return -1;
    82         }
    83         if ( dp->di_size < 0 ) {
    84                 datum key;
    85                 int size;
    86 
    87                 size = 0;
    88                 for ( key=dbm_firstkey(dp->di_dbm); key.dptr;
    89                       key = dbm_nextkey(dp->di_dbm))
    90                         size++;
    91                 dp->di_size = size;
    92         }
    93         return dp->di_size;
     79    if (dp->di_dbm == NULL) {
     80             PyErr_SetString(DbmError, "DBM object has already been closed");
     81             return -1;
     82    }
     83    if ( dp->di_size < 0 ) {
     84        datum key;
     85        int size;
     86
     87        size = 0;
     88        for ( key=dbm_firstkey(dp->di_dbm); key.dptr;
     89              key = dbm_nextkey(dp->di_dbm))
     90            size++;
     91        dp->di_size = size;
     92    }
     93    return dp->di_size;
    9494}
    9595
    … …  
    9797dbm_subscript(dbmobject *dp, register PyObject *key)
    9898{
    99         datum drec, krec;
    100         int tmp_size;
    101        
    102         if (!PyArg_Parse(key, "s#", &krec.dptr, &tmp_size) )
    103                 return NULL;
    104        
    105         krec.dsize = tmp_size;
    106         check_dbmobject_open(dp);
    107         drec = dbm_fetch(dp->di_dbm, krec);
    108         if ( drec.dptr == 0 ) {
    109                 PyErr_SetString(PyExc_KeyError,
    110                                 PyString_AS_STRING((PyStringObject *)key));
    111                 return NULL;
    112         }
    113         if ( dbm_error(dp->di_dbm) ) {
    114                 dbm_clearerr(dp->di_dbm);
    115                 PyErr_SetString(DbmError, "");
    116                 return NULL;
    117         }
    118         return PyString_FromStringAndSize(drec.dptr, drec.dsize);
     99    datum drec, krec;
     100    int tmp_size;
     101
     102    if (!PyArg_Parse(key, "s#", &krec.dptr, &tmp_size) )
     103        return NULL;
     104
     105    krec.dsize = tmp_size;
     106    check_dbmobject_open(dp);
     107    drec = dbm_fetch(dp->di_dbm, krec);
     108    if ( drec.dptr == 0 ) {
     109        PyErr_SetString(PyExc_KeyError,
     110                        PyString_AS_STRING((PyStringObject *)key));
     111        return NULL;
     112    }
     113    if ( dbm_error(dp->di_dbm) ) {
     114        dbm_clearerr(dp->di_dbm);
     115        PyErr_SetString(DbmError, "");
     116        return NULL;
     117    }
     118    return PyString_FromStringAndSize(drec.dptr, drec.dsize);
    119119}
    120120
    … …  
    122122dbm_ass_sub(dbmobject *dp, PyObject *v, PyObject *w)
    123123{
    124         datum krec, drec;
    125         int tmp_size;
    126        
    127         if ( !PyArg_Parse(v, "s#", &krec.dptr, &tmp_size) ) {
    128                 PyErr_SetString(PyExc_TypeError,
    129                                 "dbm mappings have string indices only");
    130                 return -1;
    131         }
    132         krec.dsize = tmp_size;
    133         if (dp->di_dbm == NULL) {
    134                  PyErr_SetString(DbmError, "DBM object has already been closed");
    135                  return -1;
     124    datum krec, drec;
     125    int tmp_size;
     126
     127    if ( !PyArg_Parse(v, "s#", &krec.dptr, &tmp_size) ) {
     128        PyErr_SetString(PyExc_TypeError,
     129                        "dbm mappings have string indices only");
     130        return -1;
     131    }
     132    krec.dsize = tmp_size;
     133    if (dp->di_dbm == NULL) {
     134             PyErr_SetString(DbmError, "DBM object has already been closed");
     135             return -1;
     136    }
     137    dp->di_size = -1;
     138    if (w == NULL) {
     139        if ( dbm_delete(dp->di_dbm, krec) < 0 ) {
     140            dbm_clearerr(dp->di_dbm);
     141            PyErr_SetString(PyExc_KeyError,
     142                          PyString_AS_STRING((PyStringObject *)v));
     143            return -1;
    136144        }
    137         dp->di_size = -1;
    138         if (w == NULL) {
    139                 if ( dbm_delete(dp->di_dbm, krec) < 0 ) {
    140                         dbm_clearerr(dp->di_dbm);
    141                         PyErr_SetString(PyExc_KeyError,
    142                                       PyString_AS_STRING((PyStringObject *)v));
    143                         return -1;
    144                 }
    145         } else {
    146                 if ( !PyArg_Parse(w, "s#", &drec.dptr, &tmp_size) ) {
    147                         PyErr_SetString(PyExc_TypeError,
    148                                      "dbm mappings have string elements only");
    149                         return -1;
    150                 }
    151                 drec.dsize = tmp_size;
    152                 if ( dbm_store(dp->di_dbm, krec, drec, DBM_REPLACE) < 0 ) {
    153                         dbm_clearerr(dp->di_dbm);
    154                         PyErr_SetString(DbmError,
    155                                         "cannot add item to database");
    156                         return -1;
    157                 }
    158         }
    159         if ( dbm_error(dp->di_dbm) ) {
    160                 dbm_clearerr(dp->di_dbm);
    161                 PyErr_SetString(DbmError, "");
    162                 return -1;
    163         }
    164         return 0;
     145    } else {
     146        if ( !PyArg_Parse(w, "s#", &drec.dptr, &tmp_size) ) {
     147            PyErr_SetString(PyExc_TypeError,
     148                         "dbm mappings have string elements only");
     149            return -1;
     150        }
     151        drec.dsize = tmp_size;
     152        if ( dbm_store(dp->di_dbm, krec, drec, DBM_REPLACE) < 0 ) {
     153            dbm_clearerr(dp->di_dbm);
     154            PyErr_SetString(DbmError,
     155                            "cannot add item to database");
     156            return -1;
     157        }
     158    }
     159    if ( dbm_error(dp->di_dbm) ) {
     160        dbm_clearerr(dp->di_dbm);
     161        PyErr_SetString(DbmError, "");
     162        return -1;
     163    }
     164    return 0;
    165165}
    166166
    … …  
    168168dbm_contains(register dbmobject *dp, PyObject *v)
    169169{
    170         datum key, val;
    171 
    172         if (PyString_AsStringAndSize(v, (char **)&key.dptr,
    173                                      (Py_ssize_t *)&key.dsize)) {
    174                 return -1;
    175         }
    176 
    177         /* Expand check_dbmobject_open to return -1 */
    178         if (dp->di_dbm == NULL) {
    179                 PyErr_SetString(DbmError, "DBM object has already been closed");
    180                 return -1;
    181         }
    182         val = dbm_fetch(dp->di_dbm, key);
    183         return val.dptr != NULL;
     170    datum key, val;
     171    char *ptr;
     172    Py_ssize_t size;
     173
     174    if (PyString_AsStringAndSize(v, &ptr, &size))
     175        return -1;
     176    key.dptr = ptr;
     177    key.dsize = size;
     178
     179    /* Expand check_dbmobject_open to return -1 */
     180    if (dp->di_dbm == NULL) {
     181        PyErr_SetString(DbmError, "DBM object has already been closed");
     182        return -1;
     183    }
     184    val = dbm_fetch(dp->di_dbm, key);
     185    return val.dptr != NULL;
    184186}
    185187
    … …  
    198200
    199201static PyMappingMethods dbm_as_mapping = {
    200         (lenfunc)dbm_length,            /*mp_length*/
    201         (binaryfunc)dbm_subscript,      /*mp_subscript*/
    202         (objobjargproc)dbm_ass_sub,     /*mp_ass_subscript*/
     202    (lenfunc)dbm_length,                /*mp_length*/
     203    (binaryfunc)dbm_subscript,          /*mp_subscript*/
     204    (objobjargproc)dbm_ass_sub,         /*mp_ass_subscript*/
    203205};
    204206
    … …  
    206208dbm__close(register dbmobject *dp, PyObject *unused)
    207209{
    208         if (dp->di_dbm)
    209                 dbm_close(dp->di_dbm);
    210         dp->di_dbm = NULL;
    211         Py_INCREF(Py_None);
    212         return Py_None;
     210    if (dp->di_dbm)
     211        dbm_close(dp->di_dbm);
     212    dp->di_dbm = NULL;
     213    Py_INCREF(Py_None);
     214    return Py_None;
    213215}
    214216
    … …  
    216218dbm_keys(register dbmobject *dp, PyObject *unused)
    217219{
    218         register PyObject *v, *item;
    219         datum key;
    220         int err;
    221 
    222         check_dbmobject_open(dp);
    223         v = PyList_New(0);
    224         if (v == NULL)
    225                 return NULL;
    226         for (key = dbm_firstkey(dp->di_dbm); key.dptr;
    227              key = dbm_nextkey(dp->di_dbm)) {
    228                 item = PyString_FromStringAndSize(key.dptr, key.dsize);
    229                 if (item == NULL) {
    230                         Py_DECREF(v);
    231                         return NULL;
    232                 }
    233                 err = PyList_Append(v, item);
    234                 Py_DECREF(item);
    235                 if (err != 0) {
    236                         Py_DECREF(v);
    237                         return NULL;
    238                 }
    239         }
    240         return v;
     220    register PyObject *v, *item;
     221    datum key;
     222    int err;
     223
     224    check_dbmobject_open(dp);
     225    v = PyList_New(0);
     226    if (v == NULL)
     227        return NULL;
     228    for (key = dbm_firstkey(dp->di_dbm); key.dptr;
     229         key = dbm_nextkey(dp->di_dbm)) {
     230        item = PyString_FromStringAndSize(key.dptr, key.dsize);
     231        if (item == NULL) {
     232            Py_DECREF(v);
     233            return NULL;
     234        }
     235        err = PyList_Append(v, item);
     236        Py_DECREF(item);
     237        if (err != 0) {
     238            Py_DECREF(v);
     239            return NULL;
     240        }
     241    }
     242    return v;
    241243}
    242244
    … …  
    244246dbm_has_key(register dbmobject *dp, PyObject *args)
    245247{
    246         char *tmp_ptr;
    247         datum key, val;
    248         int tmp_size;
    249        
    250         if (!PyArg_ParseTuple(args, "s#:has_key", &tmp_ptr, &tmp_size))
    251                 return NULL;
    252         key.dptr = tmp_ptr;
    253         key.dsize = tmp_size;
    254         check_dbmobject_open(dp);
    255         val = dbm_fetch(dp->di_dbm, key);
    256         return PyInt_FromLong(val.dptr != NULL);
     248    char *tmp_ptr;
     249    datum key, val;
     250    int tmp_size;
     251
     252    if (!PyArg_ParseTuple(args, "s#:has_key", &tmp_ptr, &tmp_size))
     253        return NULL;
     254    key.dptr = tmp_ptr;
     255    key.dsize = tmp_size;
     256    check_dbmobject_open(dp);
     257    val = dbm_fetch(dp->di_dbm, key);
     258    return PyInt_FromLong(val.dptr != NULL);
    257259}
    258260
    … …  
    260262dbm_get(register dbmobject *dp, PyObject *args)
    261263{
    262         datum key, val;
    263         PyObject *defvalue = Py_None;
    264         char *tmp_ptr;
    265         int tmp_size;
    266 
    267         if (!PyArg_ParseTuple(args, "s#|O:get",
    268                               &tmp_ptr, &tmp_size, &defvalue))
    269                 return NULL;
    270         key.dptr = tmp_ptr;
    271         key.dsize = tmp_size;
    272         check_dbmobject_open(dp);
    273         val = dbm_fetch(dp->di_dbm, key);
    274         if (val.dptr != NULL)
    275                 return PyString_FromStringAndSize(val.dptr, val.dsize);
    276         else {
    277                 Py_INCREF(defvalue);
    278                 return defvalue;
    279         }
     264    datum key, val;
     265    PyObject *defvalue = Py_None;
     266    char *tmp_ptr;
     267    int tmp_size;
     268
     269    if (!PyArg_ParseTuple(args, "s#|O:get",
     270                          &tmp_ptr, &tmp_size, &defvalue))
     271        return NULL;
     272    key.dptr = tmp_ptr;
     273    key.dsize = tmp_size;
     274    check_dbmobject_open(dp);
     275    val = dbm_fetch(dp->di_dbm, key);
     276    if (val.dptr != NULL)
     277        return PyString_FromStringAndSize(val.dptr, val.dsize);
     278    else {
     279        Py_INCREF(defvalue);
     280        return defvalue;
     281    }
    280282}
    281283
    … …  
    283285dbm_setdefault(register dbmobject *dp, PyObject *args)
    284286{
    285         datum key, val;
    286         PyObject *defvalue = NULL;
    287         char *tmp_ptr;
    288         int tmp_size;
    289 
    290         if (!PyArg_ParseTuple(args, "s#|S:setdefault",
    291                               &tmp_ptr, &tmp_size, &defvalue))
    292                 return NULL;
    293         key.dptr = tmp_ptr;
    294         key.dsize = tmp_size;
    295         check_dbmobject_open(dp);
    296         val = dbm_fetch(dp->di_dbm, key);
    297         if (val.dptr != NULL)
    298                 return PyString_FromStringAndSize(val.dptr, val.dsize);
    299         if (defvalue == NULL) {
    300                 defvalue = PyString_FromStringAndSize(NULL, 0);
    301                 if (defvalue == NULL)
    302                         return NULL;
    303         }
    304         else
    305                 Py_INCREF(defvalue);
    306         val.dptr = PyString_AS_STRING(defvalue);
    307         val.dsize = PyString_GET_SIZE(defvalue);
    308         if (dbm_store(dp->di_dbm, key, val, DBM_INSERT) < 0) {
    309                 dbm_clearerr(dp->di_dbm);
    310                 PyErr_SetString(DbmError, "cannot add item to database");
    311                 return NULL;
    312         }
    313         return defvalue;
     287    datum key, val;
     288    PyObject *defvalue = NULL;
     289    char *tmp_ptr;
     290    int tmp_size;
     291
     292    if (!PyArg_ParseTuple(args, "s#|S:setdefault",
     293                          &tmp_ptr, &tmp_size, &defvalue))
     294        return NULL;
     295    key.dptr = tmp_ptr;
     296    key.dsize = tmp_size;
     297    check_dbmobject_open(dp);
     298    val = dbm_fetch(dp->di_dbm, key);
     299    if (val.dptr != NULL)
     300        return PyString_FromStringAndSize(val.dptr, val.dsize);
     301    if (defvalue == NULL) {
     302        defvalue = PyString_FromStringAndSize(NULL, 0);
     303        if (defvalue == NULL)
     304            return NULL;
     305    }
     306    else
     307        Py_INCREF(defvalue);
     308    val.dptr = PyString_AS_STRING(defvalue);
     309    val.dsize = PyString_GET_SIZE(defvalue);
     310    if (dbm_store(dp->di_dbm, key, val, DBM_INSERT) < 0) {
     311        dbm_clearerr(dp->di_dbm);
     312        PyErr_SetString(DbmError, "cannot add item to database");
     313        return NULL;
     314    }
     315    return defvalue;
    314316}
    315317
    316318static PyMethodDef dbm_methods[] = {
    317         {"close",       (PyCFunction)dbm__close,        METH_NOARGS,
    318         "close()\nClose the database."},
    319         {"keys",        (PyCFunction)dbm_keys,          METH_NOARGS,
    320         "keys() -> list\nReturn a list of all keys in the database."},
    321         {"has_key",     (PyCFunction)dbm_has_key,       METH_VARARGS,
    322         "has_key(key} -> boolean\nReturn true iff key is in the database."},
    323         {"get",         (PyCFunction)dbm_get,           METH_VARARGS,
    324         "get(key[, default]) -> value\n"
    325         "Return the value for key if present, otherwise default."},
    326         {"setdefault",  (PyCFunction)dbm_setdefault,    METH_VARARGS,
    327         "setdefault(key[, default]) -> value\n"
    328         "Return the value for key if present, otherwise default.  If key\n"
    329         "is not in the database, it is inserted with default as the value."},
    330         {NULL,          NULL}           /* sentinel */
     319    {"close",           (PyCFunction)dbm__close,        METH_NOARGS,
     320    "close()\nClose the database."},
     321    {"keys",            (PyCFunction)dbm_keys,          METH_NOARGS,
     322    "keys() -> list\nReturn a list of all keys in the database."},
     323    {"has_key",         (PyCFunction)dbm_has_key,       METH_VARARGS,
     324    "has_key(key} -> boolean\nReturn true iff key is in the database."},
     325    {"get",             (PyCFunction)dbm_get,           METH_VARARGS,
     326    "get(key[, default]) -> value\n"
     327    "Return the value for key if present, otherwise default."},
     328    {"setdefault",      (PyCFunction)dbm_setdefault,    METH_VARARGS,
     329    "setdefault(key[, default]) -> value\n"
     330    "Return the value for key if present, otherwise default.  If key\n"
     331    "is not in the database, it is inserted with default as the value."},
     332    {NULL,              NULL}           /* sentinel */
    331333};
    332334
    … …  
    334336dbm_getattr(dbmobject *dp, char *name)
    335337{
    336         return Py_FindMethod(dbm_methods, (PyObject *)dp, name);
     338    return Py_FindMethod(dbm_methods, (PyObject *)dp, name);
    337339}
    338340
    339341static PyTypeObject Dbmtype = {
    340         PyVarObject_HEAD_INIT(NULL, 0)
    341         "dbm.dbm",
    342         sizeof(dbmobject),
    343         0,
    344         (destructor)dbm_dealloc,  /*tp_dealloc*/
    345         0,                        /*tp_print*/
    346         (getattrfunc)dbm_getattr, /*tp_getattr*/
    347         0,                        /*tp_setattr*/
    348         0,                        /*tp_compare*/
    349         0,                        /*tp_repr*/
    350         0,                        /*tp_as_number*/
     342    PyVarObject_HEAD_INIT(NULL, 0)
     343    "dbm.dbm",
     344    sizeof(dbmobject),
     345    0,
     346    (destructor)dbm_dealloc,  /*tp_dealloc*/
     347    0,                            /*tp_print*/
     348    (getattrfunc)dbm_getattr, /*tp_getattr*/
     349    0,                            /*tp_setattr*/
     350    0,                            /*tp_compare*/
     351    0,                            /*tp_repr*/
     352    0,                            /*tp_as_number*/
    351353    &dbm_as_sequence,     /*tp_as_sequence*/
    352         &dbm_as_mapping,          /*tp_as_mapping*/
     354    &dbm_as_mapping,              /*tp_as_mapping*/
    353355    0,                    /*tp_hash*/
    354356    0,                    /*tp_call*/
    … …  
    365367dbmopen(PyObject *self, PyObject *args)
    366368{
    367         char *name;
    368         char *flags = "r";
    369         int iflags;
    370         int mode = 0666;
    371 
    372         if ( !PyArg_ParseTuple(args, "s|si:open", &name, &flags, &mode) )
    373                 return NULL;
    374         if ( strcmp(flags, "r") == 0 )
    375                 iflags = O_RDONLY;
    376         else if ( strcmp(flags, "w") == 0 )
    377                 iflags = O_RDWR;
    378         else if ( strcmp(flags, "rw") == 0 ) /* B/W compat */
    379                 iflags = O_RDWR|O_CREAT;
    380         else if ( strcmp(flags, "c") == 0 )
    381                 iflags = O_RDWR|O_CREAT;
    382         else if ( strcmp(flags, "n") == 0 )
    383                 iflags = O_RDWR|O_CREAT|O_TRUNC;
    384         else {
    385                 PyErr_SetString(DbmError,
    386                                 "arg 2 to open should be 'r', 'w', 'c', or 'n'");
    387                 return NULL;
    388         }
    389         return newdbmobject(name, iflags, mode);
     369    char *name;
     370    char *flags = "r";
     371    int iflags;
     372    int mode = 0666;
     373
     374    if ( !PyArg_ParseTuple(args, "s|si:open", &name, &flags, &mode) )
     375        return NULL;
     376    if ( strcmp(flags, "r") == 0 )
     377        iflags = O_RDONLY;
     378    else if ( strcmp(flags, "w") == 0 )
     379        iflags = O_RDWR;
     380    else if ( strcmp(flags, "rw") == 0 ) /* B/W compat */
     381        iflags = O_RDWR|O_CREAT;
     382    else if ( strcmp(flags, "c") == 0 )
     383        iflags = O_RDWR|O_CREAT;
     384    else if ( strcmp(flags, "n") == 0 )
     385        iflags = O_RDWR|O_CREAT|O_TRUNC;
     386    else {
     387        PyErr_SetString(DbmError,
     388                        "arg 2 to open should be 'r', 'w', 'c', or 'n'");
     389        return NULL;
     390    }
     391    return newdbmobject(name, iflags, mode);
    390392}
    391393
    392394static PyMethodDef dbmmodule_methods[] = {
    393         { "open", (PyCFunction)dbmopen, METH_VARARGS,
    394           "open(path[, flag[, mode]]) -> mapping\n"
    395           "Return a database object."},
    396         { 0, 0 },
     395    { "open", (PyCFunction)dbmopen, METH_VARARGS,
     396      "open(path[, flag[, mode]]) -> mapping\n"
     397      "Return a database object."},
     398    { 0, 0 },
    397399};
    398400
    399401PyMODINIT_FUNC
    400402initdbm(void) {
    401         PyObject *m, *d, *s;
    402 
    403         Dbmtype.ob_type = &PyType_Type;
    404         m = Py_InitModule("dbm", dbmmodule_methods);
    405         if (m == NULL)
    406                 return;
    407         d = PyModule_GetDict(m);
    408         if (DbmError == NULL)
    409                 DbmError = PyErr_NewException("dbm.error", NULL, NULL);
    410         s = PyString_FromString(which_dbm);
    411         if (s != NULL) {
    412                 PyDict_SetItemString(d, "library", s);
    413                 Py_DECREF(s);
    414         }
    415         if (DbmError != NULL)
    416                 PyDict_SetItemString(d, "error", DbmError);
    417 }
     403    PyObject *m, *d, *s;
     404
     405    Dbmtype.ob_type = &PyType_Type;
     406    m = Py_InitModule("dbm", dbmmodule_methods);
     407    if (m == NULL)
     408        return;
     409    d = PyModule_GetDict(m);
     410    if (DbmError == NULL)
     411        DbmError = PyErr_NewException("dbm.error", NULL, NULL);
     412    s = PyString_FromString(which_dbm);
     413    if (s != NULL) {
     414        PyDict_SetItemString(d, "library", s);
     415        Py_DECREF(s);
     416    }
     417    if (DbmError != NULL)
     418        PyDict_SetItemString(d, "error", DbmError);
     419}
Note: See TracChangeset for help on using the changeset viewer.