Changeset 982


Ignore:
Timestamp:
Apr 22, 2019, 2:35:34 PM (5 months ago)
Author:
cito
Message:

Use PEP7 to format control structures in C Code

File:
1 edited

Legend:

Unmodified
Added
Removed
  • trunk/pgmodule.c

    r981 r982  
    4141#include "py3c.h"
    4242
    43 static PyObject *Error, *Warning, *InterfaceError,
    44     *DatabaseError, *InternalError, *OperationalError, *ProgrammingError,
    45     *IntegrityError, *DataError, *NotSupportedError;
     43static PyObject *Error, *Warning, *InterfaceError, *DatabaseError,
     44                *InternalError, *OperationalError, *ProgrammingError,
     45                *IntegrityError, *DataError, *NotSupportedError;
    4646
    4747#define _TOSTRING(x) #x
     
    5454
    5555/* default values */
    56 #define PG_ARRAYSIZE        1
     56#define PG_ARRAYSIZE 1
    5757
    5858/* flags for object validity checks */
    59 #define CHECK_OPEN          1
    60 #define CHECK_CLOSE         2
    61 #define CHECK_CNX           4
    62 #define CHECK_RESULT        8
    63 #define CHECK_DQL           16
     59#define CHECK_OPEN   1
     60#define CHECK_CLOSE  2
     61#define CHECK_CNX    4
     62#define CHECK_RESULT 8
     63#define CHECK_DQL   16
    6464
    6565/* query result types */
    66 #define RESULT_EMPTY        1
    67 #define RESULT_DML          2
    68 #define RESULT_DDL          3
    69 #define RESULT_DQL          4
     66#define RESULT_EMPTY 1
     67#define RESULT_DML   2
     68#define RESULT_DDL   3
     69#define RESULT_DQL   4
    7070
    7171/* flags for move methods */
    72 #define QUERY_MOVEFIRST     1
    73 #define QUERY_MOVELAST      2
    74 #define QUERY_MOVENEXT      3
    75 #define QUERY_MOVEPREV      4
    76 
    77 #define MAX_BUFFER_SIZE 8192    /* maximum transaction size */
    78 #define MAX_ARRAY_DEPTH 16      /* maximum allowed depth of an array */
     72#define QUERY_MOVEFIRST 1
     73#define QUERY_MOVELAST  2
     74#define QUERY_MOVENEXT  3
     75#define QUERY_MOVEPREV  4
     76
     77#define MAX_BUFFER_SIZE 8192  /* maximum transaction size */
     78#define MAX_ARRAY_DEPTH 16    /* maximum allowed depth of an array */
    7979
    8080/* MODULE GLOBAL VARIABLES */
     
    8989#endif  /* DEFAULT_VARS */
    9090
    91 static PyObject *decimal = NULL, /* decimal type */
    92                 *dictiter = NULL, /* function for getting named results */
    93                 *namediter = NULL, /* function for getting named results */
    94                 *namednext = NULL, /* function for getting one named result */
     91static PyObject *decimal = NULL,    /* decimal type */
     92                *dictiter = NULL,   /* function for getting named results */
     93                *namediter = NULL,  /* function for getting named results */
     94                *namednext = NULL,  /* function for getting one named result */
    9595                *scalariter = NULL, /* function for getting scalar results */
    9696                *jsondecode = NULL; /* function for decoding json strings */
    9797static const char *date_format = NULL; /* date format that is always assumed */
    98 static char decimal_point = '.'; /* decimal point used in money values */
    99 static int bool_as_text = 0; /* whether bool shall be returned as text */
    100 static int array_as_text = 0; /* whether arrays shall be returned as text */
    101 static int bytea_escaped = 0; /* whether bytea shall be returned escaped */
     98static char decimal_point = '.';    /* decimal point used in money values */
     99static int bool_as_text = 0;   /* whether bool shall be returned as text */
     100static int array_as_text = 0;  /* whether arrays shall be returned as text */
     101static int bytea_escaped = 0;  /* whether bytea shall be returned escaped */
    102102
    103103static int pg_encoding_utf8 = 0;
     
    143143{
    144144    PyObject_HEAD
    145     int         valid;              /* validity flag */
    146     PGconn     *cnx;                /* Postgres connection handle */
    147     const char *date_format;        /* date format derived from datestyle */
    148     PyObject   *cast_hook;          /* external typecast method */
    149     PyObject   *notice_receiver;    /* current notice receiver */
     145    int        valid;             /* validity flag */
     146    PGconn     *cnx;              /* Postgres connection handle */
     147    const char *date_format;      /* date format derived from datestyle */
     148    PyObject   *cast_hook;        /* external typecast method */
     149    PyObject   *notice_receiver;  /* current notice receiver */
    150150}   connObject;
    151151#define is_connObject(v) (PyType(v) == &connType)
     
    154154{
    155155    PyObject_HEAD
    156     int         valid;          /* validity flag */
    157     connObject *pgcnx;          /* parent connection object */
    158     PGresult    *result;        /* result content */
    159     int         encoding;       /* client encoding */
    160     int         result_type;    /* result type (DDL/DML/DQL) */
    161     long        arraysize;      /* array size for fetch method */
    162     int         current_row;    /* currently selected row */
    163     int         max_row;        /* number of rows in the result */
    164     int         num_fields;     /* number of fields in each row */
     156    int        valid;        /* validity flag */
     157    connObject *pgcnx;       /* parent connection object */
     158    PGresult   *result;      /* result content */
     159    int        encoding;     /* client encoding */
     160    int        result_type;  /* result type (DDL/DML/DQL) */
     161    long       arraysize;    /* array size for fetch method */
     162    int        current_row;  /* currently selected row */
     163    int        max_row;      /* number of rows in the result */
     164    int        num_fields;   /* number of fields in each row */
    165165}   sourceObject;
    166166#define is_sourceObject(v) (PyType(v) == &sourceType)
     
    169169{
    170170    PyObject_HEAD
    171     connObject *pgcnx;          /* parent connection object */
    172     PGresult    const *res;     /* an error or warning */
     171    connObject *pgcnx;    /* parent connection object */
     172    PGresult const *res;  /* an error or warning */
    173173}   noticeObject;
    174174#define is_noticeObject(v) (PyType(v) == &noticeType)
     
    177177{
    178178    PyObject_HEAD
    179     connObject *pgcnx;          /* parent connection object */
    180     PGresult   *result;         /* result content */
    181     int         encoding;       /* client encoding */
    182     int         current_row;    /* currently selected row */
    183     int         max_row;        /* number of rows in the result */
    184     int         num_fields;     /* number of fields in each row */
    185     int        *col_types;      /* PyGreSQL column types */
     179    connObject *pgcnx;       /* parent connection object */
     180    PGresult   *result;      /* result content */
     181    int        encoding;     /* client encoding */
     182    int        current_row;  /* currently selected row */
     183    int        max_row;      /* number of rows in the result */
     184    int        num_fields;   /* number of fields in each row */
     185    int        *col_types;   /* PyGreSQL column types */
    186186}   queryObject;
    187187#define is_queryObject(v) (PyType(v) == &queryType)
     
    191191{
    192192    PyObject_HEAD
    193     connObject *pgcnx;          /* parent connection object */
    194     Oid         lo_oid;         /* large object oid */
    195     int         lo_fd;          /* large object fd */
     193    connObject *pgcnx;  /* parent connection object */
     194    Oid lo_oid;         /* large object oid */
     195    int lo_fd;          /* large object fd */
    196196}   largeObject;
    197197#define is_largeObject(v) (PyType(v) == &largeType)
     
    257257    int t;
    258258
    259     switch (pgtype)
    260     {
     259    switch (pgtype) {
    261260        /* simple types */
    262261
     
    373372    int *types, *t, j;
    374373
    375     if (!(types = PyMem_Malloc(sizeof(int) * nfields)))
    376         return (int *)PyErr_NoMemory();
    377 
    378     for (j = 0, t=types; j < nfields; ++j)
     374    if (!(types = PyMem_Malloc(sizeof(int) * nfields))) {
     375        return (int*) PyErr_NoMemory();
     376    }
     377
     378    for (j = 0, t = types; j < nfields; ++j) {
    379379        *t++ = get_type(PQftype(result, j));
     380    }
    380381
    381382    return types;
     
    387388cast_bytea_text(char *s)
    388389{
    389     PyObject   *obj;
    390     char       *tmp_str;
    391     size_t      str_len;
     390    PyObject *obj;
     391    char *tmp_str;
     392    size_t str_len;
    392393
    393394    /* this function should not be called when bytea_escaped is set */
    394     tmp_str = (char *)PQunescapeBytea((unsigned char*)s, &str_len);
     395    tmp_str = (char *) PQunescapeBytea((unsigned char*) s, &str_len);
    395396    obj = PyBytes_FromStringAndSize(tmp_str, str_len);
    396     if (tmp_str)
     397    if (tmp_str) {
    397398        PQfreemem(tmp_str);
     399    }
    398400    return obj;
    399401}
     
    404406cast_sized_text(char *s, Py_ssize_t size, int encoding, int type)
    405407{
    406     PyObject   *obj, *tmp_obj;
    407     char       *tmp_str;
    408     size_t      str_len;
    409 
    410     switch (type) /* this must be the PyGreSQL internal type */
    411     {
     408    PyObject *obj, *tmp_obj;
     409    char *tmp_str;
     410    size_t str_len;
     411
     412    switch (type) { /* this must be the PyGreSQL internal type */
     413
    412414        case PYGRES_BYTEA:
    413415            /* this type should not be passed when bytea_escaped is set */
    414416            /* we need to add a null byte */
    415417            tmp_str = (char *) PyMem_Malloc(size + 1);
    416             if (!tmp_str) return PyErr_NoMemory();
     418            if (!tmp_str) {
     419                return PyErr_NoMemory();
     420            }
    417421            memcpy(tmp_str, s, size);
    418422            s = tmp_str; *(s + size) = '\0';
    419             tmp_str = (char *)PQunescapeBytea((unsigned char*)s, &str_len);
     423            tmp_str = (char *) PQunescapeBytea((unsigned char*) s, &str_len);
    420424            PyMem_Free(s);
    421425            if (!tmp_str) return PyErr_NoMemory();
    422426            obj = PyBytes_FromStringAndSize(tmp_str, str_len);
    423             if (tmp_str)
     427            if (tmp_str) {
    424428                PQfreemem(tmp_str);
     429            }
    425430            break;
    426431
     
    428433            /* this type should only be passed when jsondecode is set */
    429434            obj = get_decoded_string(s, size, encoding);
    430             if (obj && jsondecode) /* was able to decode */
    431             {
     435            if (obj && jsondecode) { /* was able to decode */
    432436                tmp_obj = Py_BuildValue("(O)", obj);
    433437                obj = PyObject_CallObject(jsondecode, tmp_obj);
     
    452456static PyObject *
    453457cast_other(char *s, Py_ssize_t size, int encoding, Oid pgtype,
    454     PyObject *cast_hook)
     458           PyObject *cast_hook)
    455459{
    456460    PyObject *obj;
     
    458462    obj = cast_sized_text(s, size, encoding, PYGRES_TEXT);
    459463
    460     if (cast_hook)
    461     {
     464    if (cast_hook) {
    462465        PyObject *tmp_obj = obj;
    463466        obj = PyObject_CallFunction(cast_hook, "(OI)", obj, pgtype);
     
    472475cast_sized_simple(char *s, Py_ssize_t size, int type)
    473476{
    474     PyObject   *obj, *tmp_obj;
    475     char        buf[64], *t;
    476     int         i, j, n;
    477 
    478     switch (type) /* this must be the PyGreSQL internal type */
    479     {
     477    PyObject *obj, *tmp_obj;
     478    char buf[64], *t;
     479    int i, j, n;
     480
     481    switch (type) { /* this must be the PyGreSQL internal type */
     482
    480483        case PYGRES_INT:
    481             n = sizeof(buf)/sizeof(buf[0]) - 1;
    482             if ((int)size < n) n = (int)size;
    483             for (i = 0, t = buf; i < n; ++i) *t++ = *s++;
     484            n = sizeof(buf) / sizeof(buf[0]) - 1;
     485            if ((int) size < n) {
     486                n = (int) size;
     487            }
     488            for (i = 0, t = buf; i < n; ++i) {
     489                *t++ = *s++;
     490            }
    484491            *t = '\0';
    485492            obj = PyInt_FromString(buf, NULL, 10);
     
    487494
    488495        case PYGRES_LONG:
    489             n = sizeof(buf)/sizeof(buf[0]) - 1;
    490             if ((int)size < n) n = (int)size;
    491             for (i = 0, t = buf; i < n; ++i) *t++ = *s++;
     496            n = sizeof(buf) / sizeof(buf[0]) - 1;
     497            if ((int) size < n) {
     498                n = (int) size;
     499            }
     500            for (i = 0, t = buf; i < n; ++i) {
     501                *t++ = *s++;
     502            }
    492503            *t = '\0';
    493504            obj = PyLong_FromString(buf, NULL, 10);
     
    502513        case PYGRES_MONEY:
    503514            /* this type should only be passed when decimal_point is set */
    504             n = sizeof(buf)/sizeof(buf[0]) - 1;
    505             for (i = 0, j = 0; i < size && j < n; ++i, ++s)
    506             {
    507                 if (*s >= '0' && *s <= '9')
     515            n = sizeof(buf) / sizeof(buf[0]) - 1;
     516            for (i = 0, j = 0; i < size && j < n; ++i, ++s) {
     517                if (*s >= '0' && *s <= '9') {
    508518                    buf[j++] = *s;
    509                 else if (*s == decimal_point)
     519                }
     520                else if (*s == decimal_point) {
    510521                    buf[j++] = '.';
    511                 else if (*s == '(' || *s == '-')
     522                }
     523                else if (*s == '(' || *s == '-') {
    512524                    buf[j++] = '-';
    513             }
    514             if (decimal)
    515             {
     525                }
     526            }
     527            if (decimal) {
    516528                buf[j] = '\0';
    517529                obj = PyObject_CallFunction(decimal, "(s)", buf);
    518530            }
    519             else
    520             {
     531            else {
    521532                tmp_obj = PyStr_FromString(buf);
    522533                obj = PyFloat_FromString(tmp_obj);
     
    535546        case PYGRES_BOOL:
    536547            /* convert to bool only if bool_as_text is not set */
    537             if (bool_as_text)
    538             {
     548            if (bool_as_text) {
    539549                obj = PyStr_FromString(*s == 't' ? "t" : "f");
    540550            }
    541             else
    542             {
     551            else {
    543552                obj = *s == 't' ? Py_True : Py_False;
    544553                Py_INCREF(obj);
     
    559568cast_unsized_simple(char *s, int type)
    560569{
    561     PyObject   *obj, *tmp_obj;
    562     char        buf[64];
    563     int         j, n;
    564 
    565     switch (type) /* this must be the PyGreSQL internal type */
    566     {
     570    PyObject *obj, *tmp_obj;
     571    char buf[64];
     572    int j, n;
     573
     574    switch (type) { /* this must be the PyGreSQL internal type */
     575
    567576        case PYGRES_INT:
    568577            obj = PyInt_FromString(s, NULL, 10);
     
    581590        case PYGRES_MONEY:
    582591            /* this type should only be passed when decimal_point is set */
    583             n = sizeof(buf)/sizeof(buf[0]) - 1;
    584             for (j = 0; *s && j < n; ++s)
    585             {
    586                 if (*s >= '0' && *s <= '9')
     592            n = sizeof(buf) / sizeof(buf[0]) - 1;
     593            for (j = 0; *s && j < n; ++s) {
     594                if (*s >= '0' && *s <= '9') {
    587595                    buf[j++] = *s;
    588                 else if (*s == decimal_point)
     596                }
     597                else if (*s == decimal_point) {
    589598                    buf[j++] = '.';
    590                 else if (*s == '(' || *s == '-')
     599                }
     600                else if (*s == '(' || *s == '-') {
    591601                    buf[j++] = '-';
     602                }
    592603            }
    593604            buf[j] = '\0'; s = buf;
     
    595606
    596607        case PYGRES_DECIMAL:
    597             if (decimal)
    598             {
     608            if (decimal) {
    599609                obj = PyObject_CallFunction(decimal, "(s)", s);
    600610            }
    601             else
    602             {
     611            else {
    603612                tmp_obj = PyStr_FromString(s);
    604613                obj = PyFloat_FromString(tmp_obj);
     
    609618        case PYGRES_BOOL:
    610619            /* convert to bool only if bool_as_text is not set */
    611             if (bool_as_text)
    612             {
     620            if (bool_as_text) {
    613621                obj = PyStr_FromString(*s == 't' ? "t" : "f");
    614622            }
    615             else
    616             {
     623            else {
    617624                obj = *s == 't' ? Py_True : Py_False;
    618625                Py_INCREF(obj);
     
    629636
    630637/* quick case insensitive check if given sized string is null */
    631 #define STR_IS_NULL(s, n) (n == 4 \
    632     && (s[0] == 'n' || s[0] == 'N') \
    633     && (s[1] == 'u' || s[1] == 'U') \
    634     && (s[2] == 'l' || s[2] == 'L') \
    635     && (s[3] == 'l' || s[3] == 'L'))
     638#define STR_IS_NULL(s, n) (n == 4 && \
     639    (s[0] == 'n' || s[0] == 'N') && \
     640    (s[1] == 'u' || s[1] == 'U') && \
     641    (s[2] == 'l' || s[2] == 'L') && \
     642    (s[3] == 'l' || s[3] == 'L'))
    636643
    637644/* Cast string s with size and encoding to a Python list,
     
    644651     int type, PyObject *cast, char delim)
    645652{
    646     PyObject   *result, *stack[MAX_ARRAY_DEPTH];
    647     char       *end = s + size, *t;
    648     int         depth, ranges = 0, level = 0;
    649 
    650     if (type)
    651     {
     653    PyObject *result, *stack[MAX_ARRAY_DEPTH];
     654    char *end = s + size, *t;
     655    int depth, ranges = 0, level = 0;
     656
     657    if (type) {
    652658        type &= ~PYGRES_ARRAY; /* get the base type */
    653659        if (!type) type = PYGRES_TEXT;
    654660    }
    655     if (!delim)
     661    if (!delim) {
    656662        delim = ',';
    657     else if (delim == '{' || delim =='}' || delim=='\\')
    658     {
     663    }
     664    else if (delim == '{' || delim =='}' || delim=='\\') {
    659665        PyErr_SetString(PyExc_ValueError, "Invalid array delimiter");
    660666        return NULL;
     
    663669    /* strip blanks at the beginning */
    664670    while (s != end && *s == ' ') ++s;
    665     if (*s == '[') /* dimension ranges */
    666     {
     671    if (*s == '[') { /* dimension ranges */
    667672        int valid;
    668673
    669         for (valid = 0; !valid;)
    670         {
     674        for (valid = 0; !valid;) {
    671675            if (s == end || *s++ != '[') break;
    672676            while (s != end && *s == ' ') ++s;
     
    681685            while (s != end && *s == ' ') ++s;
    682686            ++ranges;
    683             if (s != end && *s == '=')
    684             {
     687            if (s != end && *s == '=') {
    685688                do ++s; while (s != end && *s == ' ');
    686689                valid = 1;
    687690            }
    688691        }
    689         if (!valid)
    690         {
     692        if (!valid) {
    691693            PyErr_SetString(PyExc_ValueError, "Invalid array dimensions");
    692694            return NULL;
    693695        }
    694696    }
    695     for (t = s, depth = 0; t != end && (*t == '{' || *t == ' '); ++t)
     697    for (t = s, depth = 0; t != end && (*t == '{' || *t == ' '); ++t) {
    696698        if (*t == '{') ++depth;
    697     if (!depth)
    698     {
     699    }
     700    if (!depth) {
    699701        PyErr_SetString(PyExc_ValueError,
    700             "Array must start with a left brace");
    701         return NULL;
    702     }
    703     if (ranges && depth != ranges)
    704     {
     702                        "Array must start with a left brace");
     703        return NULL;
     704    }
     705    if (ranges && depth != ranges) {
    705706        PyErr_SetString(PyExc_ValueError,
    706             "Array dimensions do not match content");
    707         return NULL;
    708     }
    709     if (depth > MAX_ARRAY_DEPTH)
    710     {
     707                        "Array dimensions do not match content");
     708        return NULL;
     709    }
     710    if (depth > MAX_ARRAY_DEPTH) {
    711711        PyErr_SetString(PyExc_ValueError, "Array is too deeply nested");
    712712        return NULL;
     
    717717    do ++s; while (s != end && *s == ' ');
    718718    /* everything is set up, start parsing the array */
    719     while (s != end)
    720     {
    721         if (*s == '}')
    722         {
     719    while (s != end) {
     720        if (*s == '}') {
    723721            PyObject *subresult;
    724722
     
    726724            do ++s; while (s != end && *s == ' ');
    727725            if (s == end) break; /* error */
    728             if (*s == delim)
    729             {
     726            if (*s == delim) {
    730727                do ++s; while (s != end && *s == ' ');
    731728                if (s == end) break; /* error */
    732                 if (*s != '{')
    733                 {
     729                if (*s != '{') {
    734730                    PyErr_SetString(PyExc_ValueError,
    735                         "Subarray expected but not found");
     731                                    "Subarray expected but not found");
    736732                    Py_DECREF(result); return NULL;
    737733                }
     
    740736            subresult = result;
    741737            result = stack[--level];
    742             if (PyList_Append(result, subresult))
    743             {
     738            if (PyList_Append(result, subresult)) {
    744739                Py_DECREF(result); return NULL;
    745740            }
    746741        }
    747         else if (level == depth) /* we expect elements at this level */
    748         {
    749             PyObject   *element;
    750             char       *estr;
    751             Py_ssize_t  esize;
     742        else if (level == depth) { /* we expect elements at this level */
     743            PyObject *element;
     744            char *estr;
     745            Py_ssize_t esize;
    752746            int escaped = 0;
    753747
    754             if (*s == '{')
    755             {
     748            if (*s == '{') {
    756749                PyErr_SetString(PyExc_ValueError,
    757                     "Subarray found where not expected");
     750                                "Subarray found where not expected");
    758751                Py_DECREF(result); return NULL;
    759752            }
    760             if (*s == '"') /* quoted element */
    761             {
     753            if (*s == '"') { /* quoted element */
    762754                estr = ++s;
    763                 while (s != end && *s != '"')
    764                 {
    765                     if (*s == '\\')
    766                     {
     755                while (s != end && *s != '"') {
     756                    if (*s == '\\') {
    767757                        ++s; if (s == end) break;
    768758                        escaped = 1;
     
    773763                do ++s; while (s != end && *s == ' ');
    774764            }
    775             else /* unquoted element */
    776             {
     765            else { /* unquoted element */
    777766                estr = s;
    778767                /* can contain blanks inside */
    779768                while (s != end && *s != '"' &&
    780                     *s != '{' && *s != '}' && *s != delim)
     769                       *s != '{' && *s != '}' && *s != delim)
    781770                {
    782                     if (*s == '\\')
    783                     {
     771                    if (*s == '\\') {
    784772                        ++s; if (s == end) break;
    785773                        escaped = 1;
     
    788776                }
    789777                t = s; while (t > estr && *(t - 1) == ' ') --t;
    790                 if (!(esize = t - estr))
    791                 {
     778                if (!(esize = t - estr)) {
    792779                    s = end; break; /* error */
    793780                }
     
    796783            }
    797784            if (s == end) break; /* error */
    798             if (estr)
    799             {
    800                 if (escaped)
    801                 {
    802                     char       *r;
    803                     Py_ssize_t  i;
     785            if (estr) {
     786                if (escaped) {
     787                    char *r;
     788                    Py_ssize_t i;
    804789
    805790                    /* create unescaped string */
    806791                    t = estr;
    807792                    estr = (char *) PyMem_Malloc(esize);
    808                     if (!estr)
    809                     {
     793                    if (!estr) {
    810794                        Py_DECREF(result); return PyErr_NoMemory();
    811795                    }
    812                     for (i = 0, r = estr; i < esize; ++i)
    813                     {
     796                    for (i = 0, r = estr; i < esize; ++i) {
    814797                        if (*t == '\\') ++t, ++i;
    815798                        *r++ = *t++;
     
    817800                    esize = r - estr;
    818801                }
    819                 if (type) /* internal casting of base type */
    820                 {
     802                if (type) { /* internal casting of base type */
    821803                    if (type & PYGRES_TEXT)
    822804                        element = cast_sized_text(estr, esize, encoding, type);
     
    824806                        element = cast_sized_simple(estr, esize, type);
    825807                }
    826                 else /* external casting of base type */
    827                 {
     808                else { /* external casting of base type */
    828809#if IS_PY3
    829810                    element = encoding == pg_encoding_ascii ? NULL :
     
    832813#endif
    833814                    element = PyBytes_FromStringAndSize(estr, esize);
    834                     if (element && cast)
    835                     {
     815                    if (element && cast) {
    836816                        PyObject *tmp = element;
    837817                        element = PyObject_CallFunctionObjArgs(
     
    841821                }
    842822                if (escaped) PyMem_Free(estr);
    843                 if (!element)
    844                 {
     823                if (!element) {
    845824                    Py_DECREF(result); return NULL;
    846825                }
    847826            }
    848             else
    849             {
     827            else {
    850828                Py_INCREF(Py_None); element = Py_None;
    851829            }
    852             if (PyList_Append(result, element))
    853             {
     830            if (PyList_Append(result, element)) {
    854831                Py_DECREF(element); Py_DECREF(result); return NULL;
    855832            }
    856833            Py_DECREF(element);
    857             if (*s == delim)
    858             {
     834            if (*s == delim) {
    859835                do ++s; while (s != end && *s == ' ');
    860836                if (s == end) break; /* error */
     
    862838            else if (*s != '}') break; /* error */
    863839        }
    864         else /* we expect arrays at this level */
    865         {
    866             if (*s != '{')
    867             {
     840        else { /* we expect arrays at this level */
     841            if (*s != '{') {
    868842                PyErr_SetString(PyExc_ValueError,
    869                     "Subarray must start with a left brace");
     843                                "Subarray must start with a left brace");
    870844                Py_DECREF(result); return NULL;
    871845            }
     
    876850        }
    877851    }
    878     if (s == end || *s != '}')
    879     {
     852    if (s == end || *s != '}') {
    880853        PyErr_SetString(PyExc_ValueError,
    881             "Unexpected end of array");
     854                        "Unexpected end of array");
    882855        Py_DECREF(result); return NULL;
    883856    }
    884857    do ++s; while (s != end && *s == ' ');
    885     if (s != end)
    886     {
     858    if (s != end) {
    887859        PyErr_SetString(PyExc_ValueError,
    888             "Unexpected characters after end of array");
     860                        "Unexpected characters after end of array");
    889861        Py_DECREF(result); return NULL;
    890862    }
     
    903875     int *type, PyObject *cast, Py_ssize_t len, char delim)
    904876{
    905     PyObject   *result, *ret;
    906     char       *end = s + size, *t;
    907     Py_ssize_t  i;
    908 
    909     if (!delim)
     877    PyObject *result, *ret;
     878    char *end = s + size, *t;
     879    Py_ssize_t i;
     880
     881    if (!delim) {
    910882        delim = ',';
    911     else if (delim == '(' || delim ==')' || delim=='\\')
    912     {
     883    }
     884    else if (delim == '(' || delim ==')' || delim=='\\') {
    913885        PyErr_SetString(PyExc_ValueError, "Invalid record delimiter");
    914886        return NULL;
     
    917889    /* strip blanks at the beginning */
    918890    while (s != end && *s == ' ') ++s;
    919     if (s == end || *s != '(')
    920     {
     891    if (s == end || *s != '(') {
    921892        PyErr_SetString(PyExc_ValueError,
    922             "Record must start with a left parenthesis");
     893                        "Record must start with a left parenthesis");
    923894        return NULL;
    924895    }
     
    927898    i = 0;
    928899    /* everything is set up, start parsing the record */
    929     while (++s != end)
    930     {
    931         PyObject   *element;
    932 
    933         if (*s == ')' || *s == delim)
    934         {
     900    while (++s != end) {
     901        PyObject *element;
     902
     903        if (*s == ')' || *s == delim) {
    935904            Py_INCREF(Py_None); element = Py_None;
    936905        }
    937         else
    938         {
    939             char       *estr;
    940             Py_ssize_t  esize;
     906        else {
     907            char *estr;
     908            Py_ssize_t esize;
    941909            int quoted = 0, escaped = 0;
    942910
     
    945913            if (quoted) ++s;
    946914            esize = 0;
    947             while (s != end)
    948             {
     915            while (s != end) {
    949916                if (!quoted && (*s == ')' || *s == delim))
    950917                    break;
    951                 if (*s == '"')
    952                 {
     918                if (*s == '"') {
    953919                    ++s; if (s == end) break;
    954                     if (!(quoted && *s == '"'))
    955                     {
     920                    if (!(quoted && *s == '"')) {
    956921                        quoted = !quoted; continue;
    957922                    }
    958923                }
    959                 if (*s == '\\')
    960                 {
     924                if (*s == '\\') {
    961925                    ++s; if (s == end) break;
    962926                }
     
    964928            }
    965929            if (s == end) break; /* error */
    966             if (estr + esize != s)
    967             {
    968                 char       *r;
     930            if (estr + esize != s) {
     931                char *r;
    969932
    970933                escaped = 1;
     
    972935                t = estr;
    973936                estr = (char *) PyMem_Malloc(esize);
    974                 if (!estr)
    975                 {
     937                if (!estr) {
    976938                    Py_DECREF(result); return PyErr_NoMemory();
    977939                }
    978940                quoted = 0;
    979941                r = estr;
    980                 while (t != s)
    981                 {
    982                     if (*t == '"')
    983                     {
     942                while (t != s) {
     943                    if (*t == '"') {
    984944                        ++t;
    985                         if (!(quoted && *t == '"'))
    986                         {
     945                        if (!(quoted && *t == '"')) {
    987946                            quoted = !quoted; continue;
    988947                        }
     
    992951                }
    993952            }
    994             if (type) /* internal casting of element type */
    995             {
     953            if (type) { /* internal casting of element type */
    996954                int etype = type[i];
    997955
     
    1004962                    element = cast_sized_simple(estr, esize, etype);
    1005963            }
    1006             else /* external casting of base type */
    1007             {
     964            else { /* external casting of base type */
    1008965#if IS_PY3
    1009966                element = encoding == pg_encoding_ascii ? NULL :
     
    1012969#endif
    1013970                element = PyBytes_FromStringAndSize(estr, esize);
    1014                 if (element && cast)
    1015                 {
    1016                     if (len)
    1017                     {
     971                if (element && cast) {
     972                    if (len) {
    1018973                        PyObject *ecast = PySequence_GetItem(cast, i);
    1019974
    1020                         if (ecast)
    1021                         {
    1022                             if (ecast != Py_None)
    1023                             {
     975                        if (ecast) {
     976                            if (ecast != Py_None) {
    1024977                                PyObject *tmp = element;
    1025978                                element = PyObject_CallFunctionObjArgs(
     
    1028981                            }
    1029982                        }
    1030                         else
    1031                         {
     983                        else {
    1032984                            Py_DECREF(element); element = NULL;
    1033985                        }
    1034986                    }
    1035                     else
    1036                     {
     987                    else {
    1037988                        PyObject *tmp = element;
    1038989                        element = PyObject_CallFunctionObjArgs(
     
    1043994            }
    1044995            if (escaped) PyMem_Free(estr);
    1045             if (!element)
    1046             {
     996            if (!element) {
    1047997                Py_DECREF(result); return NULL;
    1048998            }
    1049999        }
    1050         if (PyList_Append(result, element))
    1051         {
     1000        if (PyList_Append(result, element)) {
    10521001            Py_DECREF(element); Py_DECREF(result); return NULL;
    10531002        }
     
    10551004        if (len) ++i;
    10561005        if (*s != delim) break; /* no next record */
    1057         if (len && i >= len)
    1058         {
     1006        if (len && i >= len) {
    10591007            PyErr_SetString(PyExc_ValueError, "Too many columns");
    10601008            Py_DECREF(result); return NULL;
    10611009        }
    10621010    }
    1063     if (s == end || *s != ')')
    1064     {
     1011    if (s == end || *s != ')') {
    10651012        PyErr_SetString(PyExc_ValueError, "Unexpected end of record");
    10661013        Py_DECREF(result); return NULL;
    10671014    }
    10681015    do ++s; while (s != end && *s == ' ');
    1069     if (s != end)
    1070     {
     1016    if (s != end) {
    10711017        PyErr_SetString(PyExc_ValueError,
    1072             "Unexpected characters after end of record");
     1018                        "Unexpected characters after end of record");
    10731019        Py_DECREF(result); return NULL;
    10741020    }
    1075     if (len && i < len)
    1076     {
     1021    if (len && i < len) {
    10771022        PyErr_SetString(PyExc_ValueError, "Too few columns");
    10781023        Py_DECREF(result); return NULL;
     
    10901035cast_hstore(char *s, Py_ssize_t size, int encoding)
    10911036{
    1092     PyObject   *result;
    1093     char       *end = s + size;
     1037    PyObject *result;
     1038    char *end = s + size;
    10941039
    10951040    result = PyDict_New();
    10961041
    10971042    /* everything is set up, start parsing the record */
    1098     while (s != end)
    1099     {
    1100         char       *key, *val;
    1101         PyObject   *key_obj, *val_obj;
    1102         Py_ssize_t  key_esc = 0, val_esc = 0, size;
    1103         int         quoted;
     1043    while (s != end) {
     1044        char *key, *val;
     1045        PyObject *key_obj, *val_obj;
     1046        Py_ssize_t key_esc = 0, val_esc = 0, size;
     1047        int quoted;
    11041048
    11051049        while (s != end && *s == ' ') ++s;
    11061050        if (s == end) break;
    11071051        quoted = *s == '"';
    1108         if (quoted)
    1109         {
     1052        if (quoted) {
    11101053            key = ++s;
    1111             while (s != end)
    1112             {
     1054            while (s != end) {
    11131055                if (*s == '"') break;
    1114                 if (*s == '\\')
    1115                 {
     1056                if (*s == '\\') {
    11161057                    if (++s == end) break;
    11171058                    ++key_esc;
     
    11191060                ++s;
    11201061            }
    1121             if (s == end)
    1122             {
     1062            if (s == end) {
    11231063                PyErr_SetString(PyExc_ValueError, "Unterminated quote");
    11241064                Py_DECREF(result); return NULL;
    11251065            }
    11261066        }
    1127         else
    1128         {
     1067        else {
    11291068            key = s;
    1130             while (s != end)
    1131             {
     1069            while (s != end) {
    11321070                if (*s == '=' || *s == ' ') break;
    1133                 if (*s == '\\')
    1134                 {
     1071                if (*s == '\\') {
    11351072                    if (++s == end) break;
    11361073                    ++key_esc;
     
    11381075                ++s;
    11391076            }
    1140             if (s == key)
    1141             {
     1077            if (s == key) {
    11421078                PyErr_SetString(PyExc_ValueError, "Missing key");
    11431079                Py_DECREF(result); return NULL;
     
    11451081        }
    11461082        size = s - key - key_esc;
    1147         if (key_esc)
    1148         {
     1083        if (key_esc) {
    11491084            char *r = key, *t;
    11501085            key = (char *) PyMem_Malloc(size);
    1151             if (!key)
    1152             {
     1086            if (!key) {
    11531087                Py_DECREF(result); return PyErr_NoMemory();
    11541088            }
    11551089            t = key;
    1156             while (r != s)
    1157             {
    1158                 if (*r == '\\')
    1159                 {
     1090            while (r != s) {
     1091                if (*r == '\\') {
    11601092                    ++r; if (r == s) break;
    11611093                }
     
    11651097        key_obj = cast_sized_text(key, size, encoding, PYGRES_TEXT);
    11661098        if (key_esc) PyMem_Free(key);
    1167         if (!key_obj)
    1168         {
     1099        if (!key_obj) {
    11691100            Py_DECREF(result); return NULL;
    11701101        }
    11711102        if (quoted) ++s;
    11721103        while (s != end && *s == ' ') ++s;
    1173         if (s == end || *s++ != '=' || s == end || *s++ != '>')
    1174         {
     1104        if (s == end || *s++ != '=' || s == end || *s++ != '>') {
    11751105            PyErr_SetString(PyExc_ValueError, "Invalid characters after key");
    11761106            Py_DECREF(key_obj); Py_DECREF(result); return NULL;
     
    11781108        while (s != end && *s == ' ') ++s;
    11791109        quoted = *s == '"';
    1180         if (quoted)
    1181         {
     1110        if (quoted) {
    11821111            val = ++s;
    1183             while (s != end)
    1184             {
     1112            while (s != end) {
    11851113                if (*s == '"') break;
    1186                 if (*s == '\\')
    1187                 {
     1114                if (*s == '\\') {
    11881115                    if (++s == end) break;
    11891116                    ++val_esc;
     
    11911118                ++s;
    11921119            }
    1193             if (s == end)
    1194             {
     1120            if (s == end) {
    11951121                PyErr_SetString(PyExc_ValueError, "Unterminated quote");
    11961122                Py_DECREF(result); return NULL;
    11971123            }
    11981124        }
    1199         else
    1200         {
     1125        else {
    12011126            val = s;
    1202             while (s != end)
    1203             {
     1127            while (s != end) {
    12041128                if (*s == ',' || *s == ' ') break;
    1205                 if (*s == '\\')
    1206                 {
     1129                if (*s == '\\') {
    12071130                    if (++s == end) break;
    12081131                    ++val_esc;
     
    12101133                ++s;
    12111134            }
    1212             if (s == val)
    1213             {
     1135            if (s == val) {
    12141136                PyErr_SetString(PyExc_ValueError, "Missing value");
    12151137                Py_DECREF(key_obj); Py_DECREF(result); return NULL;
     
    12181140                val = NULL;
    12191141        }
    1220         if (val)
    1221         {
     1142        if (val) {
    12221143            size = s - val - val_esc;
    1223             if (val_esc)
    1224             {
     1144            if (val_esc) {
    12251145                char *r = val, *t;
    12261146                val = (char *) PyMem_Malloc(size);
    1227                 if (!val)
    1228                 {
     1147                if (!val) {
    12291148                    Py_DECREF(key_obj); Py_DECREF(result);
    12301149                    return PyErr_NoMemory();
    12311150                }
    12321151                t = val;
    1233                 while (r != s)
    1234                 {
    1235                     if (*r == '\\')
    1236                     {
     1152                while (r != s) {
     1153                    if (*r == '\\') {
    12371154                        ++r; if (r == s) break;
    12381155                    }
     
    12421159            val_obj = cast_sized_text(val, size, encoding, PYGRES_TEXT);
    12431160            if (val_esc) PyMem_Free(val);
    1244             if (!val_obj)
    1245             {
     1161            if (!val_obj) {
    12461162                Py_DECREF(key_obj); Py_DECREF(result); return NULL;
    12471163            }
    12481164        }
    1249         else
    1250         {
     1165        else {
    12511166            Py_INCREF(Py_None); val_obj = Py_None;
    12521167        }
    12531168        if (quoted) ++s;
    12541169        while (s != end && *s == ' ') ++s;
    1255         if (s != end)
    1256         {
    1257             if (*s++ != ',')
    1258             {
     1170        if (s != end) {
     1171            if (*s++ != ',') {
    12591172                PyErr_SetString(PyExc_ValueError,
    1260                     "Invalid characters after val");
     1173                                "Invalid characters after val");
    12611174                Py_DECREF(key_obj); Py_DECREF(val_obj);
    12621175                Py_DECREF(result); return NULL;
    12631176            }
    12641177            while (s != end && *s == ' ') ++s;
    1265             if (s == end)
    1266             {
     1178            if (s == end) {
    12671179                PyErr_SetString(PyExc_ValueError, "Missing entry");
    12681180                Py_DECREF(key_obj); Py_DECREF(val_obj);
     
    12841196    PyObject *func = self->notice_receiver;
    12851197
    1286     if (func)
    1287     {
     1198    if (func) {
    12881199        noticeObject *notice = PyObject_NEW(noticeObject, &noticeType);
    12891200        PyObject *ret;
    1290         if (notice)
    1291         {
     1201        if (notice) {
    12921202            notice->pgcnx = arg;
    12931203            notice->res = res;
    12941204        }
    1295         else
    1296         {
     1205        else {
    12971206            Py_INCREF(Py_None);
    1298             notice = (noticeObject *)(void *)Py_None;
     1207            notice = (noticeObject *)(void *) Py_None;
    12991208        }
    13001209        ret = PyObject_CallFunction(func, "(O)", notice);
     
    13101219    switch (sqlstate[0]) {
    13111220        case '0':
    1312             switch (sqlstate[1])
    1313             {
     1221            switch (sqlstate[1]) {
    13141222                case 'A':
    13151223                    return NotSupportedError;
     
    13171225            break;
    13181226        case '2':
    1319             switch (sqlstate[1])
    1320             {
     1227            switch (sqlstate[1]) {
    13211228                case '0':
    13221229                case '1':
     
    13401247            break;
    13411248        case '3':
    1342             switch (sqlstate[1])
    1343             {
     1249            switch (sqlstate[1]) {
    13441250                case '4':
    13451251                    return OperationalError;
     
    13541260            break;
    13551261        case '4':
    1356             switch (sqlstate[1])
    1357             {
     1262            switch (sqlstate[1]) {
    13581263                case '0':
    13591264                    return OperationalError;
     
    13791284    const char *msg, int encoding, const char *sqlstate)
    13801285{
    1381     PyObject   *err_obj, *msg_obj, *sql_obj = NULL;
     1286    PyObject *err_obj, *msg_obj, *sql_obj = NULL;
    13821287
    13831288#if IS_PY3
    13841289    if (encoding == -1) /* unknown */
    1385     {
    13861290        msg_obj = PyUnicode_DecodeLocale(msg, NULL);
    1387     }
    13881291    else
    13891292        msg_obj = get_decoded_string(msg, strlen(msg), encoding);
     
    13921295    msg_obj = PyBytes_FromString(msg);
    13931296
    1394     if (sqlstate)
     1297    if (sqlstate) {
    13951298        sql_obj = PyStr_FromStringAndSize(sqlstate, 5);
    1396     else
    1397     {
     1299    }
     1300    else {
    13981301        Py_INCREF(Py_None); sql_obj = Py_None;
    13991302    }
    14001303
    14011304    err_obj = PyObject_CallFunctionObjArgs(type, msg_obj, NULL);
    1402     if (err_obj)
    1403     {
     1305    if (err_obj) {
    14041306        Py_DECREF(msg_obj);
    14051307        PyObject_SetAttrString(err_obj, "sqlstate", sql_obj);
     
    14081310        Py_DECREF(err_obj);
    14091311    }
    1410     else
    1411     {
     1312    else {
    14121313        PyErr_SetString(type, msg);
    14131314    }
     
    14251326set_error(PyObject *type, const char * msg, PGconn *cnx, PGresult *result)
    14261327{
    1427     char *sqlstate = NULL; int encoding = pg_encoding_ascii;
    1428 
    1429     if (cnx)
    1430     {
     1328    char *sqlstate = NULL;
     1329    int encoding = pg_encoding_ascii;
     1330
     1331    if (cnx) {
    14311332        char *err_msg = PQerrorMessage(cnx);
    1432         if (err_msg)
    1433         {
     1333        if (err_msg) {
    14341334            msg = err_msg;
    14351335            encoding = PQclientEncoding(cnx);
    14361336        }
    14371337    }
    1438     if (result)
    1439     {
     1338    if (result) {
    14401339        sqlstate = PQresultErrorField(result, PG_DIAG_SQLSTATE);
    14411340        if (sqlstate) type = get_error_type(sqlstate);
     
    14491348check_cnx_obj(connObject *self)
    14501349{
    1451     if (!self || !self->valid || !self->cnx)
    1452     {
     1350    if (!self || !self->valid || !self->cnx) {
    14531351        set_error_msg(OperationalError, "Connection has been closed");
    14541352        return 0;
     
    14681366    const int n = PQnfields(res);
    14691367
    1470     if (n > 0)
    1471     {
     1368    if (n > 0) {
    14721369        char * const aligns = (char *) PyMem_Malloc(n * sizeof(char));
    14731370        int * const sizes = (int *) PyMem_Malloc(n * sizeof(int));
    14741371
    1475         if (aligns && sizes)
    1476         {
     1372        if (aligns && sizes) {
    14771373            const int m = PQntuples(res);
    14781374            int i, j;
     
    14811377
    14821378            /* calculate sizes and alignments */
    1483             for (j = 0; j < n; ++j)
    1484             {
     1379            for (j = 0; j < n; ++j) {
    14851380                const char * const s = PQfname(res, j);
    14861381                const int format = PQfformat(res, j);
    14871382
    1488                 sizes[j] = s ? (int)strlen(s) : 0;
    1489                 if (format)
    1490                 {
     1383                sizes[j] = s ? (int) strlen(s) : 0;
     1384                if (format) {
    14911385                    aligns[j] = '\0';
    14921386                    if (m && sizes[j] < 8)
     
    14941388                        sizes[j] = 8;
    14951389                }
    1496                 else
    1497                 {
     1390                else {
    14981391                    const Oid ftype = PQftype(res, j);
    14991392
    1500                     switch (ftype)
    1501                     {
     1393                    switch (ftype) {
    15021394                        case INT2OID:
    15031395                        case INT4OID:
     
    15171409                }
    15181410            }
    1519             for (i = 0; i < m; ++i)
    1520             {
    1521                 for (j = 0; j < n; ++j)
    1522                 {
    1523                     if (aligns[j])
    1524                     {
     1411            for (i = 0; i < m; ++i) {
     1412                for (j = 0; j < n; ++j) {
     1413                    if (aligns[j]) {
    15251414                        const int k = PQgetlength(res, i, j);
    15261415
     
    15401429            /* is the buffer size that needs to be allocated */
    15411430            buffer = (char *) PyMem_Malloc(size);
    1542             if (buffer)
    1543             {
     1431            if (buffer) {
    15441432                char *p = buffer;
    15451433                PyObject *result;
    15461434
    15471435                /* create the header */
    1548                 for (j = 0; j < n; ++j)
    1549                 {
     1436                for (j = 0; j < n; ++j) {
    15501437                    const char * const s = PQfname(res, j);
    15511438                    const int k = sizes[j];
    1552                     const int h = (k - (int)strlen(s)) / 2;
     1439                    const int h = (k - (int) strlen(s)) / 2;
    15531440
    15541441                    sprintf(p, "%*s", h, "");
     
    15591446                }
    15601447                *p++ = '\n';
    1561                 for (j = 0; j < n; ++j)
    1562                 {
     1448                for (j = 0; j < n; ++j) {
    15631449                    int k = sizes[j];
    15641450
     
    15701456                *p++ = '\n';
    15711457                /* create the body */
    1572                 for (i = 0; i < m; ++i)
    1573                 {
    1574                     for (j = 0; j < n; ++j)
    1575                     {
     1458                for (i = 0; i < m; ++i) {
     1459                    for (j = 0; j < n; ++j) {
    15761460                        const char align = aligns[j];
    15771461                        const int k = sizes[j];
    15781462
    1579                         if (align)
    1580                         {
    1581                             sprintf(p, align == 'r' ?
    1582                                 "%*s" : "%-*s", k,
    1583                                 PQgetvalue(res, i, j));
     1463                        if (align) {
     1464                            sprintf(p, align == 'r' ? "%*s" : "%-*s", k,
     1465                                    PQgetvalue(res, i, j));
    15841466                        }
    1585                         else
    1586                         {
     1467                        else {
    15871468                            sprintf(p, "%-*s", k,
    1588                                 PQgetisnull(res, i, j) ?
    1589                                 "" : "<binary>");
     1469                                    PQgetisnull(res, i, j) ? "" : "<binary>");
    15901470                        }
    15911471                        p += k;
     
    16041484                return result;
    16051485            }
    1606             else
    1607             {
     1486            else {
    16081487                PyMem_Free(aligns); PyMem_Free(sizes); return PyErr_NoMemory();
    16091488            }
    16101489        }
    1611         else
    1612         {
     1490        else {
    16131491            PyMem_Free(aligns); PyMem_Free(sizes); return PyErr_NoMemory();
    16141492        }
     
    16301508        return 0;
    16311509
    1632     if (!self->lo_oid)
    1633     {
     1510    if (!self->lo_oid) {
    16341511        set_error_msg(IntegrityError, "Object is not valid (null oid)");
    16351512        return 0;
    16361513    }
    16371514
    1638     if (level & CHECK_OPEN)
    1639     {
    1640         if (self->lo_fd < 0)
    1641         {
     1515    if (level & CHECK_OPEN) {
     1516        if (self->lo_fd < 0) {
    16421517            PyErr_SetString(PyExc_IOError, "Object is not opened");
    16431518            return 0;
     
    16451520    }
    16461521
    1647     if (level & CHECK_CLOSE)
    1648     {
    1649         if (self->lo_fd >= 0)
    1650         {
     1522    if (level & CHECK_CLOSE) {
     1523        if (self->lo_fd >= 0) {
    16511524            PyErr_SetString(PyExc_IOError, "Object is already opened");
    16521525            return 0;
     
    16631536    largeObject *large_obj;
    16641537
    1665     if (!(large_obj = PyObject_NEW(largeObject, &largeType)))
    1666         return NULL;
     1538    if (!(large_obj = PyObject_NEW(largeObject, &largeType))) {
     1539        return NULL;
     1540    }
    16671541
    16681542    Py_XINCREF(pgcnx);
     
    16931567largeOpen(largeObject *self, PyObject *args)
    16941568{
    1695     int         mode,
    1696                 fd;
     1569    int mode, fd;
    16971570
    16981571    /* gets arguments */
    1699     if (!PyArg_ParseTuple(args, "i", &mode))
    1700     {
     1572    if (!PyArg_ParseTuple(args, "i", &mode)) {
    17011573        PyErr_SetString(PyExc_TypeError,
    1702             "The open() method takes an integer argument");
     1574                        "The open() method takes an integer argument");
    17031575        return NULL;
    17041576    }
    17051577
    17061578    /* check validity */
    1707     if (!check_lo_obj(self, CHECK_CLOSE))
    1708         return NULL;
     1579    if (!check_lo_obj(self, CHECK_CLOSE)) {
     1580        return NULL;
     1581    }
    17091582
    17101583    /* opens large object */
    1711     if ((fd = lo_open(self->pgcnx->cnx, self->lo_oid, mode)) == -1)
    1712     {
     1584    if ((fd = lo_open(self->pgcnx->cnx, self->lo_oid, mode)) == -1) {
    17131585        PyErr_SetString(PyExc_IOError, "Can't open large object");
    17141586        return NULL;
     
    17291601{
    17301602    /* checks validity */
    1731     if (!check_lo_obj(self, CHECK_OPEN))
    1732         return NULL;
     1603    if (!check_lo_obj(self, CHECK_OPEN)) {
     1604        return NULL;
     1605    }
    17331606
    17341607    /* closes large object */
    1735     if (lo_close(self->pgcnx->cnx, self->lo_fd))
    1736     {
     1608    if (lo_close(self->pgcnx->cnx, self->lo_fd)) {
    17371609        PyErr_SetString(PyExc_IOError, "Error while closing large object fd");
    17381610        return NULL;
     
    17531625largeRead(largeObject *self, PyObject *args)
    17541626{
    1755     int         size;
    1756     PyObject   *buffer;
     1627    int size;
     1628    PyObject *buffer;
    17571629
    17581630    /* gets arguments */
    1759     if (!PyArg_ParseTuple(args, "i", &size))
    1760     {
     1631    if (!PyArg_ParseTuple(args, "i", &size)) {
    17611632        PyErr_SetString(PyExc_TypeError,
    1762             "Method read() takes an integer argument");
    1763         return NULL;
    1764     }
    1765 
    1766     if (size <= 0)
    1767     {
     1633                        "Method read() takes an integer argument");
     1634        return NULL;
     1635    }
     1636
     1637    if (size <= 0) {
    17681638        PyErr_SetString(PyExc_ValueError,
    1769             "Method read() takes a positive integer as argument");
     1639                        "Method read() takes a positive integer as argument");
    17701640        return NULL;
    17711641    }
    17721642
    17731643    /* checks validity */
    1774     if (!check_lo_obj(self, CHECK_OPEN))
    1775         return NULL;
     1644    if (!check_lo_obj(self, CHECK_OPEN)) {
     1645        return NULL;
     1646    }
    17761647
    17771648    /* allocate buffer and runs read */
     
    17791650
    17801651    if ((size = lo_read(self->pgcnx->cnx, self->lo_fd,
    1781         PyBytes_AS_STRING((PyBytesObject *)(buffer)), size)) == -1)
     1652        PyBytes_AS_STRING((PyBytesObject *) (buffer)), size)) == -1)
    17821653    {
    17831654        PyErr_SetString(PyExc_IOError, "Error while reading");
     
    17991670largeWrite(largeObject *self, PyObject *args)
    18001671{
    1801     char       *buffer;
    1802     int         size,
    1803                 bufsize;
     1672    char *buffer;
     1673    int size, bufsize;
    18041674
    18051675    /* gets arguments */
    1806     if (!PyArg_ParseTuple(args, "s#", &buffer, &bufsize))
    1807     {
     1676    if (!PyArg_ParseTuple(args, "s#", &buffer, &bufsize)) {
    18081677        PyErr_SetString(PyExc_TypeError,
    1809             "Method write() expects a sized string as argument");
     1678                        "Method write() expects a sized string as argument");
    18101679        return NULL;
    18111680    }
    18121681
    18131682    /* checks validity */
    1814     if (!check_lo_obj(self, CHECK_OPEN))
    1815         return NULL;
     1683    if (!check_lo_obj(self, CHECK_OPEN)) {
     1684        return NULL;
     1685    }
    18161686
    18171687    /* sends query */
     
    18381708{
    18391709    /* offset and whence are initialized to keep compiler happy */
    1840     int         ret,
    1841                 offset = 0,
    1842                 whence = 0;
     1710    int ret, offset = 0, whence = 0;
    18431711
    18441712    /* gets arguments */
    1845     if (!PyArg_ParseTuple(args, "ii", &offset, &whence))
    1846     {
     1713    if (!PyArg_ParseTuple(args, "ii", &offset, &whence)) {
    18471714        PyErr_SetString(PyExc_TypeError,
    1848             "Method lseek() expects two integer arguments");
     1715                        "Method lseek() expects two integer arguments");
    18491716        return NULL;
    18501717    }
    18511718
    18521719    /* checks validity */
    1853     if (!check_lo_obj(self, CHECK_OPEN))
    1854         return NULL;
     1720    if (!check_lo_obj(self, CHECK_OPEN)) {
     1721        return NULL;
     1722    }
    18551723
    18561724    /* sends query */
    1857     if ((ret = lo_lseek(self->pgcnx->cnx, self->lo_fd, offset, whence)) == -1)
     1725    if ((ret = lo_lseek(
     1726        self->pgcnx->cnx, self->lo_fd, offset, whence)) == -1)
    18581727    {
    18591728        PyErr_SetString(PyExc_IOError, "Error while moving cursor");
     
    18731742largeSize(largeObject *self, PyObject *noargs)
    18741743{
    1875     int         start,
    1876                 end;
     1744    int start, end;
    18771745
    18781746    /* checks validity */
    1879     if (!check_lo_obj(self, CHECK_OPEN))
    1880         return NULL;
     1747    if (!check_lo_obj(self, CHECK_OPEN)) {
     1748        return NULL;
     1749    }
    18811750
    18821751    /* gets current position */
    1883     if ((start = lo_tell(self->pgcnx->cnx, self->lo_fd)) == -1)
    1884     {
     1752    if ((start = lo_tell(self->pgcnx->cnx, self->lo_fd)) == -1) {
    18851753        PyErr_SetString(PyExc_IOError, "Error while getting current position");
    18861754        return NULL;
     
    18881756
    18891757    /* gets end position */
    1890     if ((end = lo_lseek(self->pgcnx->cnx, self->lo_fd, 0, SEEK_END)) == -1)
    1891     {
     1758    if ((end = lo_lseek(self->pgcnx->cnx, self->lo_fd, 0, SEEK_END)) == -1) {
    18921759        PyErr_SetString(PyExc_IOError, "Error while getting end position");
    18931760        return NULL;
     
    18991766    {
    19001767        PyErr_SetString(PyExc_IOError,
    1901             "Error while moving back to first position");
     1768                        "Error while moving back to first position");
    19021769        return NULL;
    19031770    }
     
    19151782largeTell(largeObject *self, PyObject *noargs)
    19161783{
    1917     int         start;
     1784    int start;
    19181785
    19191786    /* checks validity */
    1920     if (!check_lo_obj(self, CHECK_OPEN))
    1921         return NULL;
     1787    if (!check_lo_obj(self, CHECK_OPEN)) {
     1788        return NULL;
     1789    }
    19221790
    19231791    /* gets current position */
    1924     if ((start = lo_tell(self->pgcnx->cnx, self->lo_fd)) == -1)
    1925     {
     1792    if ((start = lo_tell(self->pgcnx->cnx, self->lo_fd)) == -1) {
    19261793        PyErr_SetString(PyExc_IOError, "Error while getting position");
    19271794        return NULL;
     
    19431810
    19441811    /* checks validity */
    1945     if (!check_lo_obj(self, CHECK_CLOSE))
    1946         return NULL;
     1812    if (!check_lo_obj(self, CHECK_CLOSE)) {
     1813        return NULL;
     1814    }
    19471815
    19481816    /* gets arguments */
    1949     if (!PyArg_ParseTuple(args, "s", &name))
    1950     {
     1817    if (!PyArg_ParseTuple(args, "s", &name)) {
    19511818        PyErr_SetString(PyExc_TypeError,
    1952             "The method export() takes a filename as argument");
     1819                        "The method export() takes a filename as argument");
    19531820        return NULL;
    19541821    }
    19551822
    19561823    /* runs command */
    1957     if (lo_export(self->pgcnx->cnx, self->lo_oid, name) != 1)
    1958     {
     1824    if (lo_export(self->pgcnx->cnx, self->lo_oid, name) != 1) {
    19591825        PyErr_SetString(PyExc_IOError, "Error while exporting large object");
    19601826        return NULL;
     
    19741840{
    19751841    /* checks validity */
    1976     if (!check_lo_obj(self, CHECK_CLOSE))
    1977         return NULL;
     1842    if (!check_lo_obj(self, CHECK_CLOSE)) {
     1843        return NULL;
     1844    }
    19781845
    19791846    /* deletes the object, invalidate it on success */
    1980     if (lo_unlink(self->pgcnx->cnx, self->lo_oid) != 1)
    1981     {
     1847    if (lo_unlink(self->pgcnx->cnx, self->lo_oid) != 1) {
    19821848        PyErr_SetString(PyExc_IOError, "Error while unlinking large object");
    19831849        return NULL;
     
    19951861    PyObject *attrs;
    19961862
    1997     attrs = PyObject_Dir(PyObject_Type((PyObject *)self));
    1998     PyObject_CallMethod(attrs, "extend", "[sss]",
    1999         "oid", "pgcnx", "error");
     1863    attrs = PyObject_Dir(PyObject_Type((PyObject *) self));
     1864    PyObject_CallMethod(
     1865        attrs, "extend", "[sss]", "oid", "pgcnx", "error");
    20001866
    20011867    return attrs;
     
    20261892
    20271893    /* associated pg connection object */
    2028     if (!strcmp(name, "pgcnx"))
    2029     {
    2030         if (check_lo_obj(self, 0))
    2031         {
     1894    if (!strcmp(name, "pgcnx")) {
     1895        if (check_lo_obj(self, 0)) {
    20321896            Py_INCREF(self->pgcnx);
    20331897            return (PyObject *) (self->pgcnx);
     
    20391903
    20401904    /* large object oid */
    2041     if (!strcmp(name, "oid"))
    2042     {
     1905    if (!strcmp(name, "oid")) {
    20431906        if (check_lo_obj(self, 0))
    20441907            return PyInt_FromLong(self->lo_oid);
     
    20601923largeStr(largeObject *self)
    20611924{
    2062     char        str[80];
     1925    char str[80];
    20631926    sprintf(str, self->lo_fd >= 0 ?
    20641927            "Opened large object, oid %ld" :
     
    21101973connDelete(connObject *self)
    21111974{
    2112     if (self->cnx)
    2113     {
     1975    if (self->cnx) {
    21141976        Py_BEGIN_ALLOW_THREADS
    21151977        PQfinish(self->cnx);
     
    21311993
    21321994    /* checks validity */
    2133     if (!check_cnx_obj(self))
    2134         return NULL;
     1995    if (!check_cnx_obj(self)) {
     1996        return NULL;
     1997    }
    21351998
    21361999    /* allocates new query object */
    2137     if (!(source_obj = PyObject_NEW(sourceObject, &sourceType)))
    2138         return NULL;
     2000    if (!(source_obj = PyObject_NEW(sourceObject, &sourceType))) {
     2001        return NULL;
     2002    }
    21392003
    21402004    /* initializes internal parameters */
     
    21542018_connQuery(connObject *self, PyObject *args, int prepared)
    21552019{
    2156     PyObject    *query_str_obj;
    2157     PyObject    *param_obj = NULL;
    2158     char        *query;
    2159     PGresult    *result;
    2160     queryObject *query_obj;
    2161     int         encoding,
    2162                 status,
    2163                 nparms = 0;
    2164 
    2165     if (!self->cnx)
    2166     {
     2020    PyObject *query_str_obj, *param_obj = NULL;
     2021    PGresult* result;
     2022    queryObject* query_obj;
     2023    char *query;
     2024    int encoding, status, nparms = 0;
     2025
     2026    if (!self->cnx) {
    21672027        PyErr_SetString(PyExc_TypeError, "Connection is not valid");
    21682028        return NULL;
     
    21702030
    21712031    /* get query args */
    2172     if (!PyArg_ParseTuple(args, "O|O", &query_str_obj, &param_obj))
    2173     {
     2032    if (!PyArg_ParseTuple(args, "O|O", &query_str_obj, &param_obj)) {
    21742033        return NULL;
    21752034    }
     
    21772036    encoding = PQclientEncoding(self->cnx);
    21782037
    2179     if (PyBytes_Check(query_str_obj))
    2180     {
     2038    if (PyBytes_Check(query_str_obj)) {
    21812039        query = PyBytes_AsString(query_str_obj);
    21822040        query_str_obj = NULL;
    21832041    }
    2184     else if (PyUnicode_Check(query_str_obj))
    2185     {
     2042    else if (PyUnicode_Check(query_str_obj)) {
    21862043        query_str_obj = get_encoded_string(query_str_obj, encoding);
    21872044        if (!query_str_obj) return NULL; /* pass the UnicodeEncodeError */
    21882045        query = PyBytes_AsString(query_str_obj);
    21892046    }
    2190     else
    2191     {
     2047    else {
    21922048        PyErr_SetString(PyExc_TypeError,
    2193             "Method query() expects a string as first argument");
     2049                        "Method query() expects a string as first argument");
    21942050        return NULL;
    21952051    }
     
    21992055     * caller passes no arguments to db.query(), and historic behaviour was
    22002056     * to call PQexec() in that case, which can execute multiple commands. */
    2201     if (param_obj)
    2202     {
    2203         param_obj = PySequence_Fast(param_obj,
    2204             "Method query() expects a sequence as second argument");
    2205         if (!param_obj)
    2206         {
     2057    if (param_obj) {
     2058        param_obj = PySequence_Fast(
     2059            param_obj, "Method query() expects a sequence as second argument");
     2060        if (!param_obj) {
    22072061            Py_XDECREF(query_str_obj);
    22082062            return NULL;
    22092063        }
    2210         nparms = (int)PySequence_Fast_GET_SIZE(param_obj);
     2064        nparms = (int) PySequence_Fast_GET_SIZE(param_obj);
    22112065
    22122066        /* if there's a single argument and it's a list or tuple, it
    22132067         * contains the positional arguments. */
    2214         if (nparms == 1)
    2215         {
     2068        if (nparms == 1) {
    22162069            PyObject *first_obj = PySequence_Fast_GET_ITEM(param_obj, 0);
    2217             if (PyList_Check(first_obj) || PyTuple_Check(first_obj))
    2218             {
     2070            if (PyList_Check(first_obj) || PyTuple_Check(first_obj)) {
    22192071                Py_DECREF(param_obj);
    22202072                param_obj = PySequence_Fast(first_obj, NULL);
    2221                 nparms = (int)PySequence_Fast_GET_SIZE(param_obj);
     2073                nparms = (int) PySequence_Fast_GET_SIZE(param_obj);
    22222074            }
    22232075        }
     
    22252077
    22262078    /* gets result */
    2227     if (nparms)
    2228     {
     2079    if (nparms) {
    22292080        /* prepare arguments */
    2230         PyObject    **str, **s;
    2231         const char  **parms, **p;
     2081        PyObject **str, **s;
     2082        const char **parms, **p;
    22322083        register int i;
    22332084
    2234         str = (PyObject **)PyMem_Malloc(nparms * sizeof(*str));
    2235         parms = (const char **)PyMem_Malloc(nparms * sizeof(*parms));
    2236         if (!str || !parms)
    2237         {
    2238             PyMem_Free((void *)parms); PyMem_Free(str);
     2085        str = (PyObject **) PyMem_Malloc(nparms * sizeof(*str));
     2086        parms = (const char **) PyMem_Malloc(nparms * sizeof(*parms));
     2087        if (!str || !parms) {
     2088            PyMem_Free((void *) parms); PyMem_Free(str);
    22392089            Py_XDECREF(query_str_obj); Py_XDECREF(param_obj);
    22402090            return PyErr_NoMemory();
     
    22442094         * the caller to pass whatever they like, and prevents us
    22452095         * from having to map types to OIDs */
    2246         for (i = 0, s=str, p=parms; i < nparms; ++i, ++p)
    2247         {
     2096        for (i = 0, s = str, p = parms; i < nparms; ++i, ++p) {
    22482097            PyObject *obj = PySequence_Fast_GET_ITEM(param_obj, i);
    22492098
    2250             if (obj == Py_None)
    2251             {
     2099            if (obj == Py_None) {
    22522100                *p = NULL;
    22532101            }
    2254             else if (PyBytes_Check(obj))
    2255             {
     2102            else if (PyBytes_Check(obj)) {
    22562103                *p = PyBytes_AsString(obj);
    22572104            }
    2258             else if (PyUnicode_Check(obj))
    2259             {
     2105            else if (PyUnicode_Check(obj)) {
    22602106                PyObject *str_obj = get_encoded_string(obj, encoding);
    2261                 if (!str_obj)
    2262                 {
    2263                     PyMem_Free((void *)parms);
     2107                if (!str_obj) {
     2108                    PyMem_Free((void *) parms);
    22642109                    while (s != str) { s--; Py_DECREF(*s); }
    22652110                    PyMem_Free(str);
     
    22722117                *p = PyBytes_AsString(str_obj);
    22732118            }
    2274             else
    2275             {
     2119            else {
    22762120                PyObject *str_obj = PyObject_Str(obj);
    2277                 if (!str_obj)
    2278                 {
    2279                     PyMem_Free((void *)parms);
     2121                if (!str_obj) {
     2122                    PyMem_Free((void *) parms);
    22802123                    while (s != str) { s--; Py_DECREF(*s); }
    22812124                    PyMem_Free(str);
    22822125                    Py_XDECREF(query_str_obj);
    22832126                    Py_XDECREF(param_obj);
    2284                     PyErr_SetString(PyExc_TypeError,
     2127                    PyErr_SetString(
     2128                        PyExc_TypeError,
    22852129                        "Query parameter has no string representation");
    22862130                    return NULL;
     
    22992143        Py_END_ALLOW_THREADS
    23002144
    2301         PyMem_Free((void *)parms);
     2145        PyMem_Free((void *) parms);
    23022146        while (s != str) { s--; Py_DECREF(*s); }
    23032147        PyMem_Free(str);
    23042148    }
    2305     else
    2306     {
     2149    else {
    23072150        Py_BEGIN_ALLOW_THREADS
    23082151        result = prepared ?
     
    23182161
    23192162    /* checks result validity */
    2320     if (!result)
    2321     {
     2163    if (!result) {
    23222164        PyErr_SetString(PyExc_ValueError, PQerrorMessage(self->cnx));
    23232165        return NULL;
     
    23292171
    23302172    /* checks result status */
    2331     if ((status = PQresultStatus(result)) != PGRES_TUPLES_OK)
    2332     {
    2333         switch (status)
    2334         {
     2173    if ((status = PQresultStatus(result)) != PGRES_TUPLES_OK) {
     2174        switch (status) {
    23352175            case PGRES_EMPTY_QUERY:
    23362176                PyErr_SetString(PyExc_ValueError, "Empty query");
     
    23432183                break;
    23442184            case PGRES_COMMAND_OK:
    2345                 {                       /* INSERT, UPDATE, DELETE */
    2346                     Oid     oid = PQoidValue(result);
    2347                     if (oid == InvalidOid)  /* not a single insert */
    2348                     {
    2349                         char    *ret = PQcmdTuples(result);
    2350 
    2351                         if (ret[0])     /* return number of rows affected */
    2352                         {
     2185                {   /* INSERT, UPDATE, DELETE */
     2186                    Oid oid = PQoidValue(result);
     2187
     2188                    if (oid == InvalidOid) {  /* not a single insert */
     2189                        char *ret = PQcmdTuples(result);
     2190
     2191                        if (ret[0]) {  /* return number of rows affected */
    23532192                            PyObject *obj = PyStr_FromString(ret);
    23542193                            PQclear(result);
     
    23632202                    return PyInt_FromLong(oid);
    23642203                }
    2365             case PGRES_COPY_OUT:        /* no data will be received */
     2204            case PGRES_COPY_OUT: /* no data will be received */
    23662205            case PGRES_COPY_IN:
    23672206                PQclear(result);
     
    23732212
    23742213        PQclear(result);
    2375         return NULL;            /* error detected on query */
     2214        return NULL; /* error detected on query */
    23762215    }
    23772216
     
    24302269connPrepare(connObject *self, PyObject *args)
    24312270{
    2432     char        *name, *query;
    2433     int         name_length, query_length;
    2434     PGresult    *result;
    2435 
    2436     if (!self->cnx)
    2437     {
     2271    char *name, *query;
     2272    int name_length, query_length;
     2273    PGresult *result;
     2274
     2275    if (!self->cnx) {
    24382276        PyErr_SetString(PyExc_TypeError, "Connection is not valid");
    24392277        return NULL;
     
    24452283    {
    24462284        PyErr_SetString(PyExc_TypeError,
    2447             "Method prepare() takes two string arguments");
     2285                        "Method prepare() takes two string arguments");
    24482286        return NULL;
    24492287    }
     
    24532291    result = PQprepare(self->cnx, name, query, 0, NULL);
    24542292    Py_END_ALLOW_THREADS
    2455     if (result && PQresultStatus(result) == PGRES_COMMAND_OK)
    2456     {
     2293    if (result && PQresultStatus(result) == PGRES_COMMAND_OK) {
    24572294        PQclear(result);
    24582295        Py_INCREF(Py_None);
     
    24742311connDescribePrepared(connObject *self, PyObject *args)
    24752312{
    2476     char        *name;
    2477     int         name_length;
    2478     PGresult    *result;
    2479 
    2480     if (!self->cnx)
    2481     {
     2313    char *name;
     2314    int name_length;
     2315    PGresult *result;
     2316
     2317    if (!self->cnx) {
    24822318        PyErr_SetString(PyExc_TypeError, "Connection is not valid");
    24832319        return NULL;
     
    24852321
    24862322    /* reads args */
    2487     if (!PyArg_ParseTuple(args, "s#",
    2488         &name, &name_length))
    2489     {
     2323    if (!PyArg_ParseTuple(args, "s#", &name, &name_length)) {
    24902324        PyErr_SetString(PyExc_TypeError,
    2491             "Method prepare() takes a string argument");
     2325                        "Method prepare() takes a string argument");
    24922326        return NULL;
    24932327    }
     
    24972331    result = PQdescribePrepared(self->cnx, name);
    24982332    Py_END_ALLOW_THREADS
    2499     if (result && PQresultStatus(result) == PGRES_COMMAND_OK)
    2500     {
     2333    if (result && PQresultStatus(result) == PGRES_COMMAND_OK) {
    25012334        queryObject *query_obj = PyObject_NEW(queryObject, &queryType);
    25022335        if (!query_obj)
     
    25302363    int line_length;
    25312364
    2532     if (!self->cnx)
    2533     {
     2365    if (!self->cnx) {
    25342366        PyErr_SetString(PyExc_TypeError, "Connection is not valid");
    25352367        return NULL;
     
    25372369
    25382370    /* reads args */
    2539     if (!PyArg_ParseTuple(args, "s#", &line, &line_length))
    2540     {
     2371    if (!PyArg_ParseTuple(args, "s#", &line, &line_length)) {
    25412372        PyErr_SetString(PyExc_TypeError,
    2542             "Method putline() takes a string argument");
     2373                        "Method putline() takes a string argument");
    25432374        return NULL;
    25442375    }
    25452376
    25462377    /* sends line to backend */
    2547     if (PQputline(self->cnx, line))
    2548     {
     2378    if (PQputline(self->cnx, line)) {
    25492379        PyErr_SetString(PyExc_IOError, PQerrorMessage(self->cnx));
    25502380        return NULL;
     
    25612391connGetLine(connObject *self, PyObject *noargs)
    25622392{
    2563     char        line[MAX_BUFFER_SIZE];
    2564     PyObject   *str = NULL;     /* GCC */
    2565 
    2566     if (!self->cnx)
    2567     {
     2393    char line[MAX_BUFFER_SIZE];
     2394    PyObject *str = NULL;     /* GCC */
     2395
     2396    if (!self->cnx) {
    25682397        PyErr_SetString(PyExc_TypeError, "Connection is not valid");
    25692398        return NULL;
     
    25712400
    25722401    /* gets line */
    2573     switch (PQgetline(self->cnx, line, MAX_BUFFER_SIZE))
    2574     {
     2402    switch (PQgetline(self->cnx, line, MAX_BUFFER_SIZE)) {
    25752403        case 0:
    25762404            str = PyStr_FromString(line);
     
    25962424connEndCopy(connObject *self, PyObject *noargs)
    25972425{
    2598     if (!self->cnx)
    2599     {
     2426    if (!self->cnx) {
    26002427        PyErr_SetString(PyExc_TypeError, "Connection is not valid");
    26012428        return NULL;
     
    26032430
    26042431    /* ends direct copy */
    2605     if (PQendcopy(self->cnx))
    2606     {
     2432    if (PQendcopy(self->cnx)) {
    26072433        PyErr_SetString(PyExc_IOError, PQerrorMessage(self->cnx));
    26082434        return NULL;
     
    26282454connInsertTable(connObject *self, PyObject *args)
    26292455{
    2630     PGresult    *result;
    2631     char        *table,
    2632                 *buffer,
    2633                 *bufpt;
    2634     int         encoding;
    2635     size_t      bufsiz;
    2636     PyObject    *list,
    2637                 *sublist,
    2638                 *item;
    2639     PyObject    *(*getitem) (PyObject *, Py_ssize_t);
    2640     PyObject    *(*getsubitem) (PyObject *, Py_ssize_t);
    2641     Py_ssize_t  i,
    2642                 j,
    2643                 m,
    2644                 n;
    2645 
    2646     if (!self->cnx)
    2647     {
     2456    PGresult *result;
     2457    char *table, *buffer, *bufpt;
     2458    int encoding;
     2459    size_t bufsiz;
     2460    PyObject *list, *sublist, *item;
     2461    PyObject *(*getitem) (PyObject *, Py_ssize_t);
     2462    PyObject *(*getsubitem) (PyObject *, Py_ssize_t);
     2463    Py_ssize_t i, j, m, n;
     2464
     2465    if (!self->cnx) {
    26482466        PyErr_SetString(PyExc_TypeError, "Connection is not valid");
    26492467        return NULL;
     
    26512469
    26522470    /* gets arguments */
    2653     if (!PyArg_ParseTuple(args, "sO:filter", &table, &list))
    2654     {
    2655         PyErr_SetString(PyExc_TypeError,
     2471    if (!PyArg_ParseTuple(args, "sO:filter", &table, &list)) {
     2472        PyErr_SetString(
     2473            PyExc_TypeError,
    26562474            "Method inserttable() expects a string and a list as arguments");
    26572475        return NULL;
     
    26592477
    26602478    /* checks list type */
    2661     if (PyTuple_Check(list))
    2662     {
     2479    if (PyTuple_Check(list)) {
    26632480        m = PyTuple_Size(list);
    26642481        getitem = PyTuple_GetItem;
    26652482    }
    2666     else if (PyList_Check(list))
    2667     {
     2483    else if (PyList_Check(list)) {
    26682484        m = PyList_Size(list);
    26692485        getitem = PyList_GetItem;
    26702486    }
    2671     else
    2672     {
    2673         PyErr_SetString(PyExc_TypeError,
     2487    else {
     2488        PyErr_SetString(
     2489            PyExc_TypeError,
    26742490            "Method inserttable() expects some kind of array"
    26752491            " as second argument");
     
    26882504    Py_END_ALLOW_THREADS
    26892505
    2690     if (!result)
    2691     {
     2506    if (!result) {
    26922507        PyMem_Free(buffer);
    26932508        PyErr_SetString(PyExc_ValueError, PQerrorMessage(self->cnx));
     
    27022517
    27032518    /* feed table */
    2704     for (i = 0; i < m; ++i)
    2705     {
     2519    for (i = 0; i < m; ++i) {
    27062520        sublist = getitem(list, i);
    2707         if (PyTuple_Check(sublist))
    2708         {
     2521        if (PyTuple_Check(sublist)) {
    27092522            j = PyTuple_Size(sublist);
    27102523            getsubitem = PyTuple_GetItem;
    27112524        }
    2712         else if (PyList_Check(sublist))
    2713         {
     2525        else if (PyList_Check(sublist)) {
    27142526            j = PyList_Size(sublist);
    27152527            getsubitem = PyList_GetItem;
    27162528        }
    2717         else
    2718         {
    2719             PyErr_SetString(PyExc_TypeError,
     2529        else {
     2530            PyErr_SetString(
     2531                PyExc_TypeError,
    27202532                "Second arg must contain some kind of arrays");
    27212533            return NULL;
    27222534        }
    2723         if (i)
    2724         {
    2725             if (j != n)
    2726             {
     2535        if (i) {
     2536            if (j != n) {
    27272537                PyMem_Free(buffer);
    2728                 PyErr_SetString(PyExc_TypeError,
     2538                PyErr_SetString(
     2539                    PyExc_TypeError,
    27292540                    "Arrays contained in second arg must have same size");
    27302541                return NULL;
    27312542            }
    27322543        }
    2733         else
    2734         {
     2544        else {
    27352545            n = j; /* never used before this assignment */
    27362546        }
     
    27402550        bufsiz = MAX_BUFFER_SIZE - 1;
    27412551
    2742         for (j = 0; j < n; ++j)
    2743         {
    2744             if (j)
    2745             {
     2552        for (j = 0; j < n; ++j) {
     2553            if (j) {
    27462554                *bufpt++ = '\t'; --bufsiz;
    27472555            }
     
    27502558
    27512559            /* convert item to string and append to buffer */
    2752             if (item == Py_None)
    2753             {
    2754                 if (bufsiz > 2)
    2755                 {
     2560            if (item == Py_None) {
     2561                if (bufsiz > 2) {
    27562562                    *bufpt++ = '\\'; *bufpt++ = 'N';
    27572563                    bufsiz -= 2;
     
    27602566                    bufsiz = 0;
    27612567            }
    2762             else if (PyBytes_Check(item))
    2763             {
     2568            else if (PyBytes_Check(item)) {
    27642569                const char* t = PyBytes_AsString(item);
    2765                 while (*t && bufsiz)
    2766                 {
    2767                     if (*t == '\\' || *t == '\t' || *t == '\n')
    2768                     {
     2570
     2571                while (*t && bufsiz) {
     2572                    if (*t == '\\' || *t == '\t' || *t == '\n') {
    27692573                        *bufpt++ = '\\'; --bufsiz;
    27702574                        if (!bufsiz) break;
     
    27732577                }
    27742578            }
    2775             else if (PyUnicode_Check(item))
    2776             {
     2579            else if (PyUnicode_Check(item)) {
    27772580                PyObject *s = get_encoded_string(item, encoding);
    2778                 if (!s)
    2779                 {
     2581                if (!s) {
    27802582                    PyMem_Free(buffer);
    27812583                    return NULL; /* pass the UnicodeEncodeError */
    27822584                }
    2783                 else
    2784                 {
     2585                else {
    27852586                    const char* t = PyBytes_AsString(s);
    2786                     while (*t && bufsiz)
    2787                     {
    2788                         if (*t == '\\' || *t == '\t' || *t == '\n')
    2789                         {
     2587
     2588                    while (*t && bufsiz) {
     2589                        if (*t == '\\' || *t == '\t' || *t == '\n') {
    27902590                            *bufpt++ = '\\'; --bufsiz;
    27912591                            if (!bufsiz) break;
     
    27962596                }
    27972597            }
    2798             else if (PyInt_Check(item) || PyLong_Check(item))
    2799             {
     2598            else if (PyInt_Check(item) || PyLong_Check(item)) {
    28002599                PyObject* s = PyObject_Str(item);
    28012600                const char* t = PyStr_AsString(s);
    2802                 while (*t && bufsiz)
    2803                 {
     2601
     2602                while (*t && bufsiz) {
    28042603                    *bufpt++ = *t++; --bufsiz;
    28052604                }
    28062605                Py_DECREF(s);
    28072606            }
    2808             else
    2809             {
     2607            else {
    28102608                PyObject* s = PyObject_Repr(item);
    28112609                const char* t = PyStr_AsString(s);
    2812                 while (*t && bufsiz)
    2813                 {
    2814                     if (*t == '\\' || *t == '\t' || *t == '\n')
    2815                     {
     2610
     2611                while (*t && bufsiz) {
     2612                    if (*t == '\\' || *t == '\t' || *t == '\n') {
    28162613                        *bufpt++ = '\\'; --bufsiz;
    28172614                        if (!bufsiz) break;
     
    28222619            }
    28232620
    2824             if (bufsiz <= 0)
    2825             {
     2621            if (bufsiz <= 0) {
    28262622                PyMem_Free(buffer); return PyErr_NoMemory();
    28272623            }
     
    28322628
    28332629        /* sends data */
    2834         if (PQputline(self->cnx, buffer))
    2835         {
     2630        if (PQputline(self->cnx, buffer)) {
    28362631            PyErr_SetString(PyExc_IOError, PQerrorMessage(self->cnx));
    28372632            PQendcopy(self->cnx);
     
    28422637
    28432638    /* ends query */
    2844     if (PQputline(self->cnx, "\\.\n"))
    2845     {
     2639    if (PQputline(self->cnx, "\\.\n")) {
    28462640        PyErr_SetString(PyExc_IOError, PQerrorMessage(self->cnx));
    28472641        PQendcopy(self->cnx);
     
    28502644    }
    28512645
    2852     if (PQendcopy(self->cnx))
    2853     {
     2646    if (PQendcopy(self->cnx)) {
    28542647        PyErr_SetString(PyExc_IOError, PQerrorMessage(self->cnx));
    28552648        PyMem_Free(buffer);
     
    28712664connTransaction(connObject *self, PyObject *noargs)
    28722665{
    2873     if (!self->cnx)
    2874     {
     2666    if (!self->cnx) {
    28752667        PyErr_SetString(PyExc_TypeError, "Connection is not valid");
    28762668        return NULL;
     
    28892681    const char *name;
    28902682
    2891     if (!self->cnx)
    2892     {
     2683    if (!self->cnx) {
    28932684        PyErr_SetString(PyExc_TypeError, "Connection is not valid");
    28942685        return NULL;
     
    28962687
    28972688    /* get query args */
    2898     if (!PyArg_ParseTuple(args, "s", &name))
    2899     {
     2689    if (!PyArg_ParseTuple(args, "s", &name)) {
    29002690        PyErr_SetString(PyExc_TypeError,
    2901             "Method parameter() takes a string as argument");
     2691                        "Method parameter() takes a string as argument");
    29022692        return NULL;
    29032693    }
     
    29172707date_style_to_format(const char *s)
    29182708{
    2919     static const char *formats[] = {
    2920         "%Y-%m-%d",     /* 0 = ISO */
    2921         "%m-%d-%Y",     /* 1 = Postgres, MDY */
    2922         "%d-%m-%Y",     /* 2 = Postgres, DMY */
    2923         "%m/%d/%Y",     /* 3 = SQL, MDY */
    2924         "%d/%m/%Y",     /* 4 = SQL, DMY */
    2925         "%d.%m.%Y"};    /* 5 = German */
    2926 
    2927     switch (s ? *s : 'I')
     2709    static const char *formats[] =
    29282710    {
     2711        "%Y-%m-%d",  /* 0 = ISO */
     2712        "%m-%d-%Y",  /* 1 = Postgres, MDY */
     2713        "%d-%m-%Y",  /* 2 = Postgres, DMY */
     2714        "%m/%d/%Y",  /* 3 = SQL, MDY */
     2715        "%d/%m/%Y",  /* 4 = SQL, DMY */
     2716        "%d.%m.%Y"   /* 5 = German */
     2717    };
     2718
     2719    switch (s ? *s : 'I') {
    29292720        case 'P': /* Postgres */
    29302721            s = strchr(s + 1, ',');
     
    29462737date_format_to_style(const char *s)
    29472738{
    2948     static const char *datestyle[] = {
     2739    static const char *datestyle[] =
     2740    {
    29492741        "ISO, YMD",         /* 0 = %Y-%m-%d */
    29502742        "Postgres, MDY",    /* 1 = %m-%d-%Y */
     
    29522744        "SQL, MDY",         /* 3 = %m/%d/%Y */
    29532745        "SQL, DMY",         /* 4 = %d/%m/%Y */
    2954         "German, DMY"};     /* 5 = %d.%m.%Y */
    2955 
    2956     switch (s ? s[1] : 'Y')
    2957     {
     2746        "German, DMY"       /* 5 = %d.%m.%Y */
     2747    };
     2748
     2749    switch (s ? s[1] : 'Y') {
    29582750        case 'm':
    2959             switch (s[2])
    2960             {
     2751            switch (s[2]) {
    29612752                case '/':
    29622753                    return datestyle[3]; /* SQL, MDY */
     
    29652756            }
    29662757        case 'd':
    2967             switch (s[2])
    2968             {
     2758            switch (s[2]) {
    29692759                case '/':
    29702760                    return datestyle[4]; /* SQL, DMY */
     
    29882778    const char *fmt;
    29892779
    2990     if (!self->cnx)
    2991     {
     2780    if (!self->cnx) {
    29922781        PyErr_SetString(PyExc_TypeError, "Connection is not valid");
    29932782        return NULL;
     
    29962785    /* check if the date format is cached in the connection */
    29972786    fmt = self->date_format;
    2998     if (!fmt)
    2999     {
     2787    if (!fmt) {
    30002788        fmt = date_style_to_format(PQparameterStatus(self->cnx, "DateStyle"));
    30012789        self->date_format = fmt; /* cache the result */
     
    30142802connEscapeLiteral(connObject *self, PyObject *string)
    30152803{
    3016     PyObject   *tmp_obj = NULL, /* auxiliary string object */
    3017                *to_obj; /* string object to return */
    3018     char       *from, /* our string argument as encoded string */
    3019                *to; /* the result as encoded string */
    3020     Py_ssize_t  from_length; /* length of string */
    3021     size_t      to_length; /* length of result */
    3022     int         encoding = -1; /* client encoding */
    3023 
    3024     if (PyBytes_Check(string))
    3025     {
     2804    PyObject *tmp_obj = NULL,  /* auxiliary string object */
     2805             *to_obj;          /* string object to return */
     2806    char *from,  /* our string argument as encoded string */
     2807         *to;    /* the result as encoded string */
     2808    Py_ssize_t from_length;   /* length of string */
     2809    size_t to_length;         /* length of result */
     2810    int encoding = -1;        /* client encoding */
     2811
     2812    if (PyBytes_Check(string)) {
    30262813        PyBytes_AsStringAndSize(string, &from, &from_length);
    30272814    }
    3028     else if (PyUnicode_Check(string))
    3029     {
     2815    else if (PyUnicode_Check(string)) {
    30302816        encoding = PQclientEncoding(self->cnx);
    30312817        tmp_obj = get_encoded_string(string, encoding);
     
    30332819        PyBytes_AsStringAndSize(tmp_obj, &from, &from_length);
    30342820    }
    3035     else
    3036     {
    3037         PyErr_SetString(PyExc_TypeError,
     2821    else {
     2822        PyErr_SetString(
     2823            PyExc_TypeError,
    30382824            "Method escape_literal() expects a string as argument");
    30392825        return NULL;
    30402826    }
    30412827
    3042     to = PQescapeLiteral(self->cnx, from, (size_t)from_length);
     2828    to = PQescapeLiteral(self->cnx, from, (size_t) from_length);
    30432829    to_length = strlen(to);
    30442830
     
    30612847connEscapeIdentifier(connObject *self, PyObject *string)
    30622848{
    3063     PyObject   *tmp_obj = NULL, /* auxiliary string object */
    3064                *to_obj; /* string object to return */
    3065     char       *from, /* our string argument as encoded string */
    3066                *to; /* the result as encoded string */
    3067     Py_ssize_t  from_length; /* length of string */
    3068     size_t      to_length; /* length of result */
    3069     int         encoding = -1; /* client encoding */
    3070 
    3071     if (PyBytes_Check(string))
    3072     {
     2849    PyObject *tmp_obj = NULL,  /* auxiliary string object */
     2850             *to_obj;          /* string object to return */
     2851    char *from,  /* our string argument as encoded string */
     2852         *to;    /* the result as encoded string */
     2853    Py_ssize_t from_length;   /* length of string */
     2854    size_t to_length;         /* length of result */
     2855    int encoding = -1;        /* client encoding */
     2856
     2857    if (PyBytes_Check(string)) {
    30732858        PyBytes_AsStringAndSize(string, &from, &from_length);
    30742859    }
    3075     else if (PyUnicode_Check(string))
    3076     {
     2860    else if (PyUnicode_Check(string)) {
    30772861        encoding = PQclientEncoding(self->cnx);
    30782862        tmp_obj = get_encoded_string(string, encoding);
     
    30802864        PyBytes_AsStringAndSize(tmp_obj, &from, &from_length);
    30812865    }
    3082     else
    3083     {
    3084         PyErr_SetString(PyExc_TypeError,
     2866    else {
     2867        PyErr_SetString(
     2868            PyExc_TypeError,
    30852869            "Method escape_identifier() expects a string as argument");
    30862870        return NULL;
    30872871    }
    30882872
    3089     to = PQescapeIdentifier(self->cnx, from, (size_t)from_length);
     2873    to = PQescapeIdentifier(self->cnx, from, (size_t) from_length);
    30902874    to_length = strlen(to);
    30912875
     
    31012885}
    31022886
    3103 #endif  /* ESCAPING_FUNCS */
     2887#endif /* ESCAPING_FUNCS */
    31042888
    31052889/* escape string */
     
    31102894connEscapeString(connObject *self, PyObject *string)
    31112895{
    3112     PyObject   *tmp_obj = NULL, /* auxiliary string object */
    3113                *to_obj; /* string object to return */
    3114     char       *from, /* our string argument as encoded string */
    3115                *to; /* the result as encoded string */
    3116     Py_ssize_t  from_length; /* length of string */
    3117     size_t      to_length; /* length of result */
    3118     int         encoding = -1; /* client encoding */
    3119 
    3120     if (PyBytes_Check(string))
    3121     {
     2896    PyObject *tmp_obj = NULL,  /* auxiliary string object */
     2897             *to_obj;          /* string object to return */
     2898    char *from,  /* our string argument as encoded string */
     2899         *to;    /* the result as encoded string */
     2900    Py_ssize_t from_length;   /* length of string */
     2901    size_t to_length;         /* length of result */
     2902    int encoding = -1;        /* client encoding */
     2903
     2904    if (PyBytes_Check(string)) {
    31222905        PyBytes_AsStringAndSize(string, &from, &from_length);
    31232906    }
    3124     else if (PyUnicode_Check(string))
    3125     {
     2907    else if (PyUnicode_Check(string)) {
    31262908        encoding = PQclientEncoding(self->cnx);
    31272909        tmp_obj = get_encoded_string(string, encoding);
     
    31292911        PyBytes_AsStringAndSize(tmp_obj, &from, &from_length);
    31302912    }
    3131     else
    3132     {
    3133         PyErr_SetString(PyExc_TypeError,
     2913    else {
     2914        PyErr_SetString(
     2915            PyExc_TypeError,
    31342916            "Method escape_string() expects a string as argument");
    31352917        return NULL;
     
    31372919
    31382920    to_length = 2*from_length + 1;
    3139     if ((Py_ssize_t)to_length < from_length) /* overflow */
    3140     {
     2921    if ((Py_ssize_t) to_length < from_length) { /* overflow */
    31412922        to_length = from_length;
    31422923        from_length = (from_length - 1)/2;
    31432924    }
    3144     to = (char *)PyMem_Malloc(to_length);
     2925    to = (char *) PyMem_Malloc(to_length);
    31452926    to_length = PQescapeStringConn(self->cnx,
    3146         to, from, (size_t)from_length, NULL);
     2927        to, from, (size_t) from_length, NULL);
    31472928
    31482929    Py_XDECREF(tmp_obj);
     
    31632944connEscapeBytea(connObject *self, PyObject *data)
    31642945{
    3165     PyObject   *tmp_obj = NULL, /* auxiliary string object */
    3166                *to_obj; /* string object to return */
    3167     char       *from, /* our string argument as encoded string */
    3168                *to; /* the result as encoded string */
    3169     Py_ssize_t  from_length; /* length of string */
    3170     size_t      to_length; /* length of result */
    3171     int         encoding = -1; /* client encoding */
    3172 
    3173     if (PyBytes_Check(data))
    3174     {
     2946    PyObject *tmp_obj = NULL,  /* auxiliary string object */
     2947             *to_obj;          /* string object to return */
     2948    char *from,  /* our string argument as encoded string */
     2949         *to;    /* the result as encoded string */
     2950    Py_ssize_t from_length;    /* length of string */
     2951    size_t to_length;          /* length of result */
     2952    int encoding = -1;         /* client encoding */
     2953
     2954    if (PyBytes_Check(data)) {
    31752955        PyBytes_AsStringAndSize(data, &from, &from_length);
    31762956    }
    3177     else if (PyUnicode_Check(data))
    3178     {
     2957    else if (PyUnicode_Check(data)) {
    31792958        encoding = PQclientEncoding(self->cnx);
    31802959        tmp_obj = get_encoded_string(data, encoding);
     
    31822961        PyBytes_AsStringAndSize(tmp_obj, &from, &from_length);
    31832962    }
    3184     else
    3185     {
    3186         PyErr_SetString(PyExc_TypeError,
     2963    else {
     2964        PyErr_SetString(
     2965            PyExc_TypeError,
    31872966            "Method escape_bytea() expects a string as argument");
    31882967        return NULL;
    31892968    }
    31902969
    3191     to = (char *)PQescapeByteaConn(self->cnx,
    3192         (unsigned char *)from, (size_t)from_length, &to_length);
     2970    to = (char *) PQescapeByteaConn(self->cnx,
     2971        (unsigned char *) from, (size_t) from_length, &to_length);
    31932972
    31942973    Py_XDECREF(tmp_obj);
     
    32112990connCreateLO(connObject *self, PyObject *args)
    32122991{
    3213     int         mode;
    3214     Oid         lo_oid;
     2992    int mode;
     2993    Oid lo_oid;
    32152994
    32162995    /* checks validity */
    3217     if (!check_cnx_obj(self))
    3218         return NULL;
     2996    if (!check_cnx_obj(self)) {
     2997        return NULL;
     2998    }
    32192999
    32203000    /* gets arguments */
    3221     if (!PyArg_ParseTuple(args, "i", &mode))
    3222     {
     3001    if (!PyArg_ParseTuple(args, "i", &mode)) {
    32233002        PyErr_SetString(PyExc_TypeError,
    3224             "Method locreate() takes an integer argument");
     3003                        "Method locreate() takes an integer argument");
    32253004        return NULL;
    32263005    }
     
    32283007    /* creates large object */
    32293008    lo_oid = lo_creat(self->cnx, mode);
    3230     if (lo_oid == 0)
    3231     {
     3009    if (lo_oid == 0) {
    32323010        set_error_msg(OperationalError, "Can't create large object");
    32333011        return NULL;
     
    32443022connGetLO(connObject *self, PyObject *args)
    32453023{
    3246     int         oid;
    3247     Oid         lo_oid;
     3024    int oid;
     3025    Oid lo_oid;
    32483026
    32493027    /* checks validity */
    3250     if (!check_cnx_obj(self))
    3251         return NULL;
     3028    if (!check_cnx_obj(self)) {
     3029        return NULL;
     3030    }
    32523031
    32533032    /* gets arguments */
    3254     if (!PyArg_ParseTuple(args, "i", &oid))
    3255     {
     3033    if (!PyArg_ParseTuple(args, "i", &oid)) {
    32563034        PyErr_SetString(PyExc_TypeError,
    3257             "Method getlo() takes an integer argument");
    3258         return NULL;
    3259     }
    3260 
    3261     lo_oid = (Oid)oid;
    3262     if (lo_oid == 0)
    3263     {
     3035                        "Method getlo() takes an integer argument");
     3036        return NULL;
     3037    }
     3038
     3039    lo_oid = (Oid) oid;
     3040    if (lo_oid == 0) {
    32643041        PyErr_SetString(PyExc_ValueError, "The object oid can't be null");
    32653042        return NULL;
     
    32773054connImportLO(connObject *self, PyObject *args)
    32783055{
    3279     char   *name;
    3280     Oid     lo_oid;
     3056    char *name;
     3057    Oid lo_oid;
    32813058
    32823059    /* checks validity */
    3283     if (!check_cnx_obj(self))
    3284         return NULL;
     3060    if (!check_cnx_obj(self)) {
     3061        return NULL;
     3062    }
    32853063
    32863064    /* gets arguments */
    3287     if (!PyArg_ParseTuple(args, "s", &name))
    3288     {
     3065    if (!PyArg_ParseTuple(args, "s", &name)) {
    32893066        PyErr_SetString(PyExc_TypeError,
    3290             "Method loimport() takes a string argument");
     3067                        "Method loimport() takes a string argument");
    32913068        return NULL;
    32923069    }
     
    32943071    /* imports file and checks result */
    32953072    lo_oid = lo_import(self->cnx, name);
    3296     if (lo_oid == 0)
    3297     {
     3073    if (lo_oid == 0) {
    32983074        set_error_msg(OperationalError, "Can't create large object");
    32993075        return NULL;
     
    33133089connReset(connObject *self, PyObject *noargs)
    33143090{
    3315     if (!self->cnx)
    3316     {
     3091    if (!self->cnx) {
    33173092        PyErr_SetString(PyExc_TypeError, "Connection is not valid");
    33183093        return NULL;
     
    33323107connCancel(connObject *self, PyObject *noargs)
    33333108{
    3334     if (!self->cnx)
    3335     {
     3109    if (!self->cnx) {
    33363110        PyErr_SetString(PyExc_TypeError, "Connection is not valid");
    33373111        return NULL;
     
    33493123connFileno(connObject *self, PyObject *noargs)
    33503124{
    3351     if (!self->cnx)
    3352     {
     3125    if (!self->cnx) {
    33533126        PyErr_SetString(PyExc_TypeError, "Connection is not valid");
    33543127        return NULL;
     
    33713144    PyObject *ret = NULL;
    33723145
    3373     if (func == Py_None)
    3374     {
     3146    if (func == Py_None) {
    33753147        Py_XDECREF(self->cast_hook);
    33763148        self->cast_hook = NULL;
    33773149        Py_INCREF(Py_None); ret = Py_None;
    33783150    }
    3379     else if (PyCallable_Check(func))
    3380     {
     3151    else if (PyCallable_Check(func)) {
    33813152        Py_XINCREF(func); Py_XDECREF(self->cast_hook);
    33823153        self->cast_hook = func;
    33833154        Py_INCREF(Py_None); ret = Py_None;
    33843155    }
    3385     else
     3156    else {
    33863157        PyErr_SetString(PyExc_TypeError,
    3387             "Method set_cast_hook() expects"
    3388              " a callable or None as argument");
     3158                        "Method set_cast_hook() expects"
     3159                        " a callable or None as argument");
     3160    }
    33893161
    33903162    return ret;
     
    34163188    PyObject *ret = NULL;
    34173189
    3418     if (func == Py_None)
    3419     {
     3190    if (func == Py_None) {
    34203191        Py_XDECREF(self->notice_receiver);
    34213192        self->notice_receiver = NULL;
    34223193        Py_INCREF(Py_None); ret = Py_None;
    34233194    }
    3424     else if (PyCallable_Check(func))
    3425     {
     3195    else if (PyCallable_Check(func)) {
    34263196        Py_XINCREF(func); Py_XDECREF(self->notice_receiver);
    34273197        self->notice_receiver = func;
     
    34293199        Py_INCREF(Py_None); ret = Py_None;
    34303200    }
    3431     else
     3201    else {
    34323202        PyErr_SetString(PyExc_TypeError,
    3433             "Method set_notice_receiver() expects"
    3434              " a callable or None as argument");
     3203                        "Method set_notice_receiver() expects"
     3204                        " a callable or None as argument");
     3205    }
    34353206
    34363207    return ret;
     
    34633234{
    34643235    /* connection object cannot already be closed */
    3465     if (!self->cnx)
    3466     {
     3236    if (!self->cnx) {
    34673237        set_error_msg(InternalError, "Connection already closed");
    34683238        return NULL;
     
    34853255connGetNotify(connObject *self, PyObject *noargs)
    34863256{
    3487     PGnotify   *notify;
    3488 
    3489     if (!self->cnx)
    3490     {
     3257    PGnotify *notify;
     3258
     3259    if (!self->cnx) {
    34913260        PyErr_SetString(PyExc_TypeError, "Connection is not valid");
    34923261        return NULL;
     
    34963265    PQconsumeInput(self->cnx);
    34973266
    3498     if (!(notify = PQnotifies(self->cnx)))
    3499     {
     3267    if (!(notify = PQnotifies(self->cnx))) {
    35003268        Py_INCREF(Py_None);
    35013269        return Py_None;
    35023270    }
    3503     else
    3504     {
    3505         PyObject   *notify_result,
    3506                    *temp;
    3507 
    3508         if (!(temp = PyStr_FromString(notify->relname)))
     3271    else {
     3272        PyObject *notify_result, *tmp;
     3273
     3274        if (!(tmp = PyStr_FromString(notify->relname))) {
    35093275            return NULL;
    3510 
    3511         if (!(notify_result = PyTuple_New(3)))
     3276        }
     3277
     3278        if (!(notify_result = PyTuple_New(3))) {
    35123279            return NULL;
    3513 
    3514         PyTuple_SET_ITEM(notify_result, 0, temp);
    3515 
    3516         if (!(temp = PyInt_FromLong(notify->be_pid)))
    3517         {
     3280        }
     3281
     3282        PyTuple_SET_ITEM(notify_result, 0, tmp);
     3283
     3284        if (!(tmp = PyInt_FromLong(notify->be_pid))) {
    35183285            Py_DECREF(notify_result);
    35193286            return NULL;
    35203287        }
    35213288
    3522         PyTuple_SET_ITEM(notify_result, 1, temp);
     3289        PyTuple_SET_ITEM(notify_result, 1, tmp);
    35233290
    35243291        /* extra exists even in old versions that did not support it */
    3525         if (!(temp = PyStr_FromString(notify->extra)))
    3526         {
     3292        if (!(tmp = PyStr_FromString(notify->extra))) {
    35273293            Py_DECREF(notify_result);
    35283294            return NULL;
    35293295        }
    35303296
    3531         PyTuple_SET_ITEM(notify_result, 2, temp);
     3297        PyTuple_SET_ITEM(notify_result, 2, tmp);
    35323298
    35333299        PQfreemem(notify);
     
    35433309    PyObject *attrs;
    35443310
    3545     attrs = PyObject_Dir(PyObject_Type((PyObject *)self));
    3546     PyObject_CallMethod(attrs, "extend", "[sssssssss]",
     3311    attrs = PyObject_Dir(PyObject_Type((PyObject *) self));
     3312    PyObject_CallMethod(
     3313        attrs, "extend", "[sssssssss]",
    35473314        "host", "port", "db", "options", "error", "status", "user",
    35483315        "protocol_version", "server_version");
     
    35903357    {"escape_identifier", (PyCFunction) connEscapeIdentifier, METH_O,
    35913358            connEscapeIdentifier__doc__},
    3592 #endif  /* ESCAPING_FUNCS */
     3359#endif /* ESCAPING_FUNCS */
    35933360    {"escape_string", (PyCFunction) connEscapeString, METH_O,
    35943361            connEscapeString__doc__},
     
    36243391
    36253392    /* first exception - close which returns a different error */
    3626     if (strcmp(name, "close") && !self->cnx)
    3627     {
     3393    if (strcmp(name, "close") && !self->cnx) {
    36283394        PyErr_SetString(PyExc_TypeError, "Connection is not valid");
    36293395        return NULL;
     
    36333399
    36343400    /* postmaster host */
    3635     if (!strcmp(name, "host"))
    3636     {
     3401    if (!strcmp(name, "host")) {
    36373402        char *r = PQhost(self->cnx);
    36383403        if (!r || r[0] == '/') /* Pg >= 9.6 can return a Unix socket path */
     
    37153480check_source_obj(sourceObject *self, int level)
    37163481{
    3717     if (!self->valid)
    3718     {
     3482    if (!self->valid) {
    37193483        set_error_msg(OperationalError, "Object has been closed");
    37203484        return 0;
    37213485    }
    37223486
    3723     if ((level & CHECK_RESULT) && !self->result)
    3724     {
     3487    if ((level & CHECK_RESULT) && !self->result) {
    37253488        set_error_msg(DatabaseError, "No result");
    37263489        return 0;
    37273490    }
    37283491
    3729     if ((level & CHECK_DQL) && self->result_type != RESULT_DQL)
    3730     {
     3492    if ((level & CHECK_DQL) && self->result_type != RESULT_DQL) {
    37313493        set_error_msg(DatabaseError, "Last query did not return tuples");
    37323494        return 0;
    37333495    }
    37343496
    3735     if ((level & CHECK_CNX) && !check_cnx_obj(self->pgcnx))
     3497    if ((level & CHECK_CNX) && !check_cnx_obj(self->pgcnx)) {
    37363498        return 0;
     3499    }
    37373500
    37383501    return 1;
     
    37593522{
    37603523    /* frees result if necessary and invalidates object */
    3761     if (self->result)
    3762     {
     3524    if (self->result) {
    37633525        PQclear(self->result);
    37643526        self->result_type = RESULT_EMPTY;
     
    37833545sourceExecute(sourceObject *self, PyObject *sql)
    37843546{
    3785     PyObject   *tmp_obj = NULL; /* auxiliary string object */
    3786     char       *query;
    3787     int         encoding;
     3547    PyObject *tmp_obj = NULL; /* auxiliary string object */
     3548    char *query;
     3549    int encoding;
    37883550
    37893551    /* checks validity */
    3790     if (!check_source_obj(self, CHECK_CNX))
    3791         return NULL;
     3552    if (!check_source_obj(self, CHECK_CNX)) {
     3553        return NULL;
     3554    }
    37923555
    37933556    encoding = PQclientEncoding(self->pgcnx->cnx);
    37943557
    3795     if (PyBytes_Check(sql))
    3796     {
     3558    if (PyBytes_Check(sql)) {
    37973559        query = PyBytes_AsString(sql);
    37983560    }
    3799     else if (PyUnicode_Check(sql))
    3800     {
     3561    else if (PyUnicode_Check(sql)) {
    38013562        tmp_obj = get_encoded_string(sql, encoding);
    38023563        if (!tmp_obj) return NULL; /* pass the UnicodeEncodeError */
    38033564        query = PyBytes_AsString(tmp_obj);
    38043565    }
    3805     else
    3806     {
     3566    else {
    38073567        PyErr_SetString(PyExc_TypeError,
    3808             "Method execute() expects a string as argument");
     3568                        "Method execute() expects a string as argument");
    38093569        return NULL;
    38103570    }
    38113571
    38123572    /* frees previous result */
    3813     if (self->result)
    3814     {
     3573    if (self->result) {
    38153574        PQclear(self->result);
    38163575        self->result = NULL;
     
    38303589
    38313590    /* checks result validity */
    3832     if (!self->result)
    3833     {
     3591    if (!self->result) {
    38343592        PyErr_SetString(PyExc_ValueError, PQerrorMessage(self->pgcnx->cnx));
    38353593        return NULL;
     
    38413599
    38423600    /* checks result status */
    3843     switch (PQresultStatus(self->result))
    3844     {
     3601    switch (PQresultStatus(self->result)) {
    38453602        /* query succeeded */
    38463603        case PGRES_TUPLES_OK:   /* DQL: returns None (DB-SIG compliant) */
     
    38543611        case PGRES_COPY_IN:
    38553612            {
    3856                 long    num_rows;
    3857                 char   *temp;
    3858                 temp = PQcmdTuples(self->result);
    3859                 if (temp[0])
    3860                 {
     3613                long num_rows;
     3614                char *tmp;
     3615
     3616                tmp = PQcmdTuples(self->result);
     3617                if (tmp[0]) {
    38613618                    self->result_type = RESULT_DML;
    3862                     num_rows = atol(temp);
     3619                    num_rows = atol(tmp);
    38633620                }
    3864                 else
    3865                 {
     3621                else {
    38663622                    self->result_type = RESULT_DDL;
    38673623                    num_rows = -1;
     
    38813637            break;
    38823638        default:
    3883             set_error_msg(InternalError, "Internal error: "
    3884                 "unknown result status");
     3639            set_error_msg(InternalError,
     3640                          "Internal error: unknown result status");
    38853641    }
    38863642
     
    38993655sourceStatusOID(sourceObject *self, PyObject *noargs)
    39003656{
    3901     Oid         oid;
     3657    Oid oid;
    39023658
    39033659    /* checks validity */
    3904     if (!check_source_obj(self, CHECK_RESULT))
    3905         return NULL;
     3660    if (!check_source_obj(self, CHECK_RESULT)) {
     3661        return NULL;
     3662    }
    39063663
    39073664    /* retrieves oid status */
    3908     if ((oid = PQoidValue(self->result)) == InvalidOid)
    3909     {
     3665    if ((oid = PQoidValue(self->result)) == InvalidOid) {
    39103666        Py_INCREF(Py_None);
    39113667        return Py_None;
     
    39243680sourceFetch(sourceObject *self, PyObject *args)
    39253681{
    3926     PyObject   *reslist;
    3927     int         i,
    3928                 k;
    3929     long        size;
     3682    PyObject *reslist;
     3683    int i, k;
     3684    long size;
    39303685#if IS_PY3
    3931     int         encoding;
     3686    int encoding;
    39323687#endif
    39333688
    39343689    /* checks validity */
    3935     if (!check_source_obj(self, CHECK_RESULT | CHECK_DQL | CHECK_CNX))
    3936         return NULL;
     3690    if (!check_source_obj(self, CHECK_RESULT | CHECK_DQL | CHECK_CNX)) {
     3691        return NULL;
     3692    }
    39373693
    39383694    /* checks args */
    39393695    size = self->arraysize;
    3940     if (!PyArg_ParseTuple(args, "|l", &size))
    3941     {
     3696    if (!PyArg_ParseTuple(args, "|l", &size)) {
    39423697        PyErr_SetString(PyExc_TypeError,
    3943             "fetch(num), with num (integer, optional)");
     3698                        "fetch(num), with num (integer, optional)");
    39443699        return NULL;
    39453700    }
     
    39473702    /* seeks last line */
    39483703    /* limit size to be within the amount of data we actually have */
    3949     if (size == -1 || (self->max_row - self->current_row) < size)
     3704    if (size == -1 || (self->max_row - self->current_row) < size) {
    39503705        size = self->max_row - self->current_row;
     3706    }
    39513707
    39523708    /* allocate list for result */
     
    39583714
    39593715    /* builds result */
    3960     for (i = 0, k = self->current_row; i < size; ++i, ++k)
    3961     {
    3962         PyObject   *rowtuple;
    3963         int         j;
    3964 
    3965         if (!(rowtuple = PyTuple_New(self->num_fields)))
    3966         {
     3716    for (i = 0, k = self->current_row; i < size; ++i, ++k) {
     3717        PyObject *rowtuple;
     3718        int j;
     3719
     3720        if (!(rowtuple = PyTuple_New(self->num_fields))) {
    39673721            Py_DECREF(reslist); return NULL;
    39683722        }
    39693723
    3970         for (j = 0; j < self->num_fields; ++j)
    3971         {
    3972             PyObject   *str;
    3973 
    3974             if (PQgetisnull(self->result, k, j))
    3975             {
     3724        for (j = 0; j < self->num_fields; ++j) {
     3725            PyObject *str;
     3726
     3727            if (PQgetisnull(self->result, k, j)) {
    39763728                Py_INCREF(Py_None);
    39773729                str = Py_None;
    39783730            }
    3979             else
    3980             {
     3731            else {
    39813732                char *s = PQgetvalue(self->result, k, j);
    39823733                Py_ssize_t size = PQgetlength(self->result, k, j);
    39833734#if IS_PY3
    3984                 if (PQfformat(self->result, j) == 0) /* textual format */
    3985                 {
     3735                if (PQfformat(self->result, j) == 0) { /* textual format */
    39863736                    str = get_decoded_string(s, size, encoding);
    39873737                    if (!str) /* cannot decode */
     
    39953745        }
    39963746
    3997         if (PyList_Append(reslist, rowtuple))
    3998         {
     3747        if (PyList_Append(reslist, rowtuple)) {
    39993748            Py_DECREF(rowtuple); Py_DECREF(reslist); return NULL;
    40003749        }
     
    40113760{
    40123761    /* checks validity */
    4013     if (!check_source_obj(self, CHECK_RESULT | CHECK_DQL))
    4014         return NULL;
     3762    if (!check_source_obj(self, CHECK_RESULT | CHECK_DQL)) {
     3763        return NULL;
     3764    }
    40153765
    40163766    /* changes the current row */
    4017     switch (move)
    4018     {
     3767    switch (move) {
    40193768        case QUERY_MOVEFIRST:
    40203769            self->current_row = 0;
     
    40843833sourcePutData(sourceObject *self, PyObject *buffer)
    40853834{
    4086     PyObject   *tmp_obj = NULL; /* an auxiliary object */
    4087     char       *buf; /* the buffer as encoded string */
    4088     Py_ssize_t  nbytes; /* length of string */
    4089     char       *errormsg = NULL; /* error message */
    4090     int         res; /* direct result of the operation */
    4091     PyObject   *ret; /* return value */
     3835    PyObject *tmp_obj = NULL; /* an auxiliary object */
     3836    char *buf;                /* the buffer as encoded string */
     3837    Py_ssize_t nbytes;        /* length of string */
     3838    char *errormsg = NULL;    /* error message */
     3839    int res;                  /* direct result of the operation */
     3840    PyObject *ret;            /* return value */
    40923841
    40933842    /* checks validity */
    4094     if (!check_source_obj(self, CHECK_CNX))
    4095         return NULL;
     3843    if (!check_source_obj(self, CHECK_CNX)) {
     3844        return NULL;
     3845    }
    40963846
    40973847    /* make sure that the connection object is valid */
    4098     if (!self->pgcnx->cnx)
    4099         return NULL;
    4100 
    4101     if (buffer == Py_None)
    4102     {
     3848    if (!self->pgcnx->cnx) {
     3849        return NULL;
     3850    }
     3851
     3852    if (buffer == Py_None) {
    41033853        /* pass None for terminating the operation */
    41043854        buf = errormsg = NULL;
    41053855    }
    4106     else if (PyBytes_Check(buffer))
    4107     {
     3856    else if (PyBytes_Check(buffer)) {
    41083857        /* or pass a byte string */
    41093858        PyBytes_AsStringAndSize(buffer, &buf, &nbytes);
    41103859    }
    4111     else if (PyUnicode_Check(buffer))
    4112     {
     3860    else if (PyUnicode_Check(buffer)) {
    41133861        /* or pass a unicode string */
    41143862        tmp_obj = get_encoded_string(
     
    41173865        PyBytes_AsStringAndSize(tmp_obj, &buf, &nbytes);
    41183866    }
    4119     else if (PyErr_GivenExceptionMatches(buffer, PyExc_BaseException))
    4120     {
     3867    else if (PyErr_GivenExceptionMatches(buffer, PyExc_BaseException)) {
    41213868        /* or pass a Python exception for sending an error message */
    41223869        tmp_obj = PyObject_Str(buffer);
    4123         if (PyUnicode_Check(tmp_obj))
    4124         {
     3870        if (PyUnicode_Check(tmp_obj)) {
    41253871            PyObject *obj = tmp_obj;
     3872
    41263873            tmp_obj = get_encoded_string(
    41273874                obj, PQclientEncoding(self->pgcnx->cnx));
     
    41323879        buf = NULL;
    41333880    }
    4134     else
    4135     {
     3881    else {
    41363882        PyErr_SetString(PyExc_TypeError,
    4137             "Method putdata() expects a buffer, None"
    4138              " or an exception as argument");
     3883                        "Method putdata() expects a buffer, None"
     3884                        " or an exception as argument");
    41393885        return NULL;
    41403886    }
     
    41423888    /* checks validity */
    41433889    if (!check_source_obj(self, CHECK_CNX | CHECK_RESULT) ||
    4144             PQresultStatus(self->result) != PGRES_COPY_IN)
     3890        PQresultStatus(self->result) != PGRES_COPY_IN)
    41453891    {
    41463892        PyErr_SetString(PyExc_IOError,
    4147             "Connection is invalid or not in copy_in state");
     3893                        "Connection is invalid or not in copy_in state");
    41483894        Py_XDECREF(tmp_obj);
    41493895        return NULL;
    41503896    }
    41513897
    4152     if (buf)
    4153     {
    4154         res = nbytes ? PQputCopyData(self->pgcnx->cnx, buf, (int)nbytes) : 1;
    4155     }
    4156     else
    4157     {
     3898    if (buf) {
     3899        res = nbytes ? PQputCopyData(self->pgcnx->cnx, buf, (int) nbytes) : 1;
     3900    }
     3901    else {
    41583902        res = PQputCopyEnd(self->pgcnx->cnx, errormsg);
    41593903    }
     
    41613905    Py_XDECREF(tmp_obj);
    41623906
    4163     if (res != 1)
    4164     {
     3907    if (res != 1) {
    41653908        PyErr_SetString(PyExc_IOError, PQerrorMessage(self->pgcnx->cnx));
    41663909        return NULL;
    41673910    }
    41683911
    4169     if (buf) /* buffer has been sent */
    4170     {
     3912    if (buf) { /* buffer has been sent */
    41713913        ret = Py_None;
    41723914        Py_INCREF(ret);
    41733915    }
    4174     else /* copy is done */
    4175     {
    4176         PGresult   *result; /* final result of the operation */
     3916    else { /* copy is done */
     3917        PGresult *result; /* final result of the operation */
    41773918
    41783919        Py_BEGIN_ALLOW_THREADS;
     
    41803921        Py_END_ALLOW_THREADS;
    41813922
    4182         if (PQresultStatus(result) == PGRES_COMMAND_OK)
    4183         {
    4184             char   *temp;
    4185             long    num_rows;
    4186 
    4187             temp = PQcmdTuples(result);
    4188             num_rows = temp[0] ? atol(temp) : -1;
     3923        if (PQresultStatus(result) == PGRES_COMMAND_OK) {
     3924            char *tmp;
     3925            long num_rows;
     3926
     3927            tmp = PQcmdTuples(result);
     3928            num_rows = tmp[0] ? atol(tmp) : -1;
    41893929            ret = PyInt_FromLong(num_rows);
    41903930        }
    4191         else
    4192         {
     3931        else {
    41933932            if (!errormsg) errormsg = PQerrorMessage(self->pgcnx->cnx);
    41943933            PyErr_SetString(PyExc_IOError, errormsg);
     
    42113950sourceGetData(sourceObject *self, PyObject *args)
    42123951{
    4213     int        *decode = 0; /* decode flag */
    4214     char       *buffer; /* the copied buffer as encoded byte string */
    4215     Py_ssize_t  nbytes; /* length of the byte string */
    4216     PyObject   *ret; /* return value */
     3952    int *decode = 0;    /* decode flag */
     3953    char *buffer;      /* the copied buffer as encoded byte string */
     3954    Py_ssize_t nbytes; /* length of the byte string */
     3955    PyObject *ret;      /* return value */
    42173956
    42183957    /* checks validity */
    4219     if (!check_source_obj(self, CHECK_CNX))
    4220         return NULL;
     3958    if (!check_source_obj(self, CHECK_CNX)) {
     3959        return NULL;
     3960    }
    42213961
    42223962    /* make sure that the connection object is valid */
    4223     if (!self->pgcnx->cnx)
    4224         return NULL;
    4225 
    4226     if (!PyArg_ParseTuple(args, "|i", &decode))
    4227         return NULL;
     3963    if (!self->pgcnx->cnx) {
     3964        return NULL;
     3965    }
     3966
     3967    if (!PyArg_ParseTuple(args, "|i", &decode)) {
     3968        return NULL;
     3969    }
    42283970
    42293971    /* checks validity */
    42303972    if (!check_source_obj(self, CHECK_CNX | CHECK_RESULT) ||
    4231             PQresultStatus(self->result) != PGRES_COPY_OUT)
     3973        PQresultStatus(self->result) != PGRES_COPY_OUT)
    42323974    {
    42333975        PyErr_SetString(PyExc_IOError,
    4234             "Connection is invalid or not in copy_out state");
     3976                        "Connection is invalid or not in copy_out state");
    42353977        return NULL;
    42363978    }
     
    42383980    nbytes = PQgetCopyData(self->pgcnx->cnx, &buffer, 0);
    42393981
    4240     if (!nbytes || nbytes < -1) /* an error occurred */
    4241     {
     3982    if (!nbytes || nbytes < -1) { /* an error occurred */
    42423983        PyErr_SetString(PyExc_IOError, PQerrorMessage(self->pgcnx->cnx));
    42433984        return NULL;
    42443985    }
    42453986
    4246     if (nbytes == -1) /* copy is done */
    4247     {
    4248         PGresult   *result; /* final result of the operation */
     3987    if (nbytes == -1) { /* copy is done */
     3988        PGresult *result; /* final result of the operation */
    42493989
    42503990        Py_BEGIN_ALLOW_THREADS;
     
    42523992        Py_END_ALLOW_THREADS;
    42533993
    4254         if (PQresultStatus(result) == PGRES_COMMAND_OK)
    4255         {
    4256             char   *temp;
    4257             long    num_rows;
    4258 
    4259             temp = PQcmdTuples(result);
    4260             num_rows = temp[0] ? atol(temp) : -1;
     3994        if (PQresultStatus(result) == PGRES_COMMAND_OK) {
     3995            char *tmp;
     3996            long num_rows;
     3997
     3998            tmp = PQcmdTuples(result);
     3999            num_rows = tmp[0] ? atol(tmp) : -1;
    42614000            ret = PyInt_FromLong(num_rows);
    42624001        }
    4263         else
    4264         {
     4002        else {
    42654003            PyErr_SetString(PyExc_IOError, PQerrorMessage(self->pgcnx->cnx));
    42664004            ret = NULL;
     
    42714009        self->result_type = RESULT_EMPTY;
    42724010    }
    4273     else /* a row has been returned */
    4274     {
     4011    else { /* a row has been returned */
    42754012        ret = decode ? get_decoded_string(
    42764013                buffer, nbytes, PQclientEncoding(self->pgcnx->cnx)) :
     
    42864023sourceFieldindex(sourceObject *self, PyObject *param, const char *usage)
    42874024{
    4288     int         num;
     4025    int num;
    42894026
    42904027    /* checks validity */
     
    42934030
    42944031    /* gets field number */
    4295     if (PyStr_Check(param))
     4032    if (PyStr_Check(param)) {
    42964033        num = PQfnumber(self->result, PyBytes_AsString(param));
    4297     else if (PyInt_Check(param))
    4298         num = (int)PyInt_AsLong(param);
    4299     else
    4300     {
     4034    }
     4035    else if (PyInt_Check(param)) {
     4036        num = (int) PyInt_AsLong(param);
     4037    }
     4038    else {
    43014039        PyErr_SetString(PyExc_TypeError, usage);
    43024040        return -1;
     
    43044042
    43054043    /* checks field validity */
    4306     if (num < 0 || num >= self->num_fields)
    4307     {
     4044    if (num < 0 || num >= self->num_fields) {
    43084045        PyErr_SetString(PyExc_ValueError, "Unknown field");
    43094046        return -1;
     
    43214058    /* allocates tuple */
    43224059    result = PyTuple_New(5);
    4323     if (!result)
    4324         return NULL;
     4060    if (!result) {
     4061        return NULL;
     4062    }
    43254063
    43264064    /* affects field information */
     
    43454083sourceListInfo(sourceObject *self, PyObject *noargs)
    43464084{
    4347     int         i;
    4348     PyObject   *result,
    4349                *info;
     4085    PyObject *result, *info;
     4086    int i;
    43504087
    43514088    /* checks validity */
    4352     if (!check_source_obj(self, CHECK_RESULT | CHECK_DQL))
    4353         return NULL;
     4089    if (!check_source_obj(self, CHECK_RESULT | CHECK_DQL)) {
     4090        return NULL;
     4091    }
    43544092
    43554093    /* builds result */
    4356     if (!(result = PyTuple_New(self->num_fields)))
    4357         return NULL;
    4358 
    4359     for (i = 0; i < self->num_fields; ++i)
    4360     {
     4094    if (!(result = PyTuple_New(self->num_fields))) {
     4095        return NULL;
     4096    }
     4097
     4098    for (i = 0; i < self->num_fields; ++i) {
    43614099        info = pgsource_buildinfo(self, i);
    4362         if (!info)
    4363         {
     4100        if (!info) {
    43644101            Py_DECREF(result);
    43654102            return NULL;
     
    43794116sourceFieldInfo(sourceObject *self, PyObject *desc)
    43804117{
    4381     int         num;
     4118    int num;
    43824119
    43834120    /* checks args and validity */
    4384     if ((num = sourceFieldindex(self, desc,
    4385             "Method fieldinfo() needs a string or integer as argument")) == -1)
    4386         return NULL;
     4121    if ((num = sourceFieldindex(
     4122        self, desc,
     4123        "Method fieldinfo() needs a string or integer as argument")) == -1)
     4124    {
     4125        return NULL;
     4126    }
    43874127
    43884128    /* returns result */
     
    43974137sourceField(sourceObject *self, PyObject *desc)
    43984138{
    4399     int         num;
     4139    int num;
    44004140
    44014141    /* checks args and validity */
    4402     if ((num = sourceFieldindex(self, desc,
    4403             "Method field() needs a string or integer as argument")) == -1)
    4404         return NULL;
     4142    if ((num = sourceFieldindex(
     4143        self, desc,
     4144        "Method field() needs a string or integer as argument")) == -1)
     4145    {
     4146        return NULL;
     4147    }
    44054148
    44064149    return PyStr_FromString(
     
    44144157    PyObject *attrs;
    44154158
    4416     attrs = PyObject_Dir(PyObject_Type((PyObject *)self));
    4417     PyObject_CallMethod(attrs, "extend", "[sssss]",
     4159    attrs = PyObject_Dir(PyObject_Type((PyObject *) self));
     4160    PyObject_CallMethod(
     4161        attrs, "extend", "[sssss]",
    44184162        "pgcnx", "arraysize", "resulttype", "ntuples", "nfields");
    44194163
     
    44574201
    44584202    /* pg connection object */
    4459     if (!strcmp(name, "pgcnx"))
    4460     {
    4461         if (check_source_obj(self, 0))
    4462         {
     4203    if (!strcmp(name, "pgcnx")) {
     4204        if (check_source_obj(self, 0)) {
    44634205            Py_INCREF(self->pgcnx);
    44644206            return (PyObject *) (self->pgcnx);
     
    44934235{
    44944236    /* arraysize */
    4495     if (!strcmp(name, "arraysize"))
    4496     {
    4497         if (!PyInt_Check(v))
    4498         {
     4237    if (!strcmp(name, "arraysize")) {
     4238        if (!PyInt_Check(v)) {
    44994239            PyErr_SetString(PyExc_TypeError, "arraysize must be integer");
    45004240            return -1;
     
    45144254sourceStr(sourceObject *self)
    45154255{
    4516     switch (self->result_type)
    4517     {
     4256    switch (self->result_type) {
    45184257        case RESULT_DQL:
    45194258            return format_result(self->result);
     
    45704309pgConnect(PyObject *self, PyObject *args, PyObject *dict)
    45714310{
    4572     static const char *kwlist[] = {"dbname", "host", "port", "opt",
    4573     "user", "passwd", NULL};
    4574 
    4575     char       *pghost,
    4576                *pgopt,
    4577                *pgdbname,
    4578                *pguser,
    4579                *pgpasswd;
    4580     int         pgport;
    4581     char        port_buffer[20];
     4311    static const char *kwlist[] =
     4312    {
     4313        "dbname", "host", "port", "opt", "user", "passwd", NULL
     4314    };
     4315
     4316    char *pghost, *pgopt, *pgdbname, *pguser, *pgpasswd;
     4317    int pgport;
     4318    char port_buffer[20];
    45824319    connObject *conn_obj;
    45834320
     
    45914328     * I try to assign all those constant strings to it.
    45924329     */
    4593     if (!PyArg_ParseTupleAndKeywords(args, dict, "|zzizzz", (char **) kwlist,
     4330    if (!PyArg_ParseTupleAndKeywords(
     4331        args, dict, "|zzizzz", (char**)kwlist,
    45944332        &pgdbname, &pghost, &pgport, &pgopt, &pguser, &pgpasswd))
    4595         return NULL;
     4333    {
     4334        return NULL;
     4335    }
    45964336
    45974337#ifdef DEFAULT_VARS
     
    46014341
    46024342    if ((pgport == -1) && (pg_default_port != Py_None))
    4603         pgport = (int)PyInt_AsLong(pg_default_port);
     4343        pgport = (int) PyInt_AsLong(pg_default_port);
    46044344
    46054345    if ((!pgopt) && (pg_default_opt != Py_None))
     
    46164356#endif /* DEFAULT_VARS */
    46174357
    4618     if (!(conn_obj = PyObject_NEW(connObject, &connType)))
    4619     {
     4358    if (!(conn_obj = PyObject_NEW(connObject, &connType))) {
    46204359        set_error_msg(InternalError, "Can't create new connection object");
    46214360        return NULL;
     
    46284367    conn_obj->notice_receiver = NULL;
    46294368
    4630     if (pgport != -1)
    4631     {
     4369    if (pgport != -1) {
    46324370        memset(port_buffer, 0, sizeof(port_buffer));
    46334371        sprintf(port_buffer, "%d", pgport);
     
    46394377    Py_END_ALLOW_THREADS
    46404378
    4641     if (PQstatus(conn_obj->cnx) == CONNECTION_BAD)
    4642     {
     4379    if (PQstatus(conn_obj->cnx) == CONNECTION_BAD) {
    46434380        set_error(InternalError, "Cannot connect", conn_obj->cnx, NULL);
    46444381        Py_XDECREF(conn_obj);
     
    46534390{
    46544391    Py_XDECREF(self->pgcnx);
    4655     if (self->col_types)
     4392    if (self->col_types) {
    46564393        PyMem_Free(self->col_types);
    4657     if (self->result)
     4394    }
     4395    if (self->result) {
    46584396        PQclear(self->result);
     4397    }
    46594398
    46604399    PyObject_Del(self);
     
    46784417queryListfields(queryObject *self, PyObject *noargs)
    46794418{
    4680     int         i;
    4681     char       *name;
    4682     PyObject   *fieldstuple,
    4683                *str;
     4419    int i;
     4420    char *name;
     4421    PyObject *fieldstuple, *str;
    46844422
    46854423    /* builds tuple */
    46864424    fieldstuple = PyTuple_New(self->num_fields);
    46874425    if (fieldstuple) {
    4688         for (i = 0; i < self->num_fields; ++i)
    4689         {
     4426        for (i = 0; i < self->num_fields; ++i) {
    46904427            name = PQfname(self->result, i);
    46914428            str = PyStr_FromString(name);
     
    47034440queryFieldname(queryObject *self, PyObject *args)
    47044441{
    4705     int     i;
    4706     char   *name;
     4442    int i;
     4443    char *name;
    47074444
    47084445    /* gets args */
    4709     if (!PyArg_ParseTuple(args, "i", &i))
    4710     {
     4446    if (!PyArg_ParseTuple(args, "i", &i)) {
    47114447        PyErr_SetString(PyExc_TypeError,
    4712             "Method fieldname() takes an integer as argument");
     4448                        "Method fieldname() takes an integer as argument");
    47134449        return NULL;
    47144450    }
    47154451
    47164452    /* checks number validity */
    4717     if (i >= self->num_fields)
    4718     {
     4453    if (i >= self->num_fields) {
    47194454        PyErr_SetString(PyExc_ValueError, "Invalid field number");
    47204455        return NULL;
     
    47334468queryFieldnum(queryObject *self, PyObject *args)
    47344469{
    4735     int     num;
    4736     char   *name;
     4470    int num;
     4471    char *name;
    47374472
    47384473    /* gets args */
    4739     if (!PyArg_ParseTuple(args, "s", &name))
    4740     {
     4474    if (!PyArg_ParseTuple(args, "s", &name)) {
    47414475        PyErr_SetString(PyExc_TypeError,
    4742             "Method fieldnum() takes a string as argument");
     4476                        "Method fieldnum() takes a string as argument");
    47434477        return NULL;
    47444478    }
    47454479
    47464480    /* gets field number */
    4747     if ((num = PQfnumber(self->result, name)) == -1)
    4748     {
     4481    if ((num = PQfnumber(self->result, name)) == -1) {
    47494482        PyErr_SetString(PyExc_ValueError, "Unknown field");
    47504483        return NULL;
     
    47604493    self->current_row = 0;
    47614494    Py_INCREF(self);
    4762     return (PyObject*)self;
     4495    return (PyObject*) self;
    47634496}
    47644497
     
    47674500getValueInColumn(queryObject *self, int column)
    47684501{
    4769     if (PQgetisnull(self->result, self->current_row, column))
    4770     {
     4502    char *s;
     4503    int type;
     4504
     4505    if (PQgetisnull(self->result, self->current_row, column)) {
    47714506        Py_INCREF(Py_None);
    47724507        return Py_None;
     
    47754510    /* get the string representation of the value */
    47764511    /* note: this is always null-terminated text format */
    4777     char   *s = PQgetvalue(self->result, self->current_row, column);
     4512    s = PQgetvalue(self->result, self->current_row, column);
    47784513    /* get the PyGreSQL type of the column */
    4779     int     type = self->col_types[column];
     4514    type = self->col_types[column];
     4515
    47804516    /* cast the string representation into a Python object */
    47814517    if (type & PYGRES_ARRAY)
     
    48014537queryGetRowAsTuple(queryObject *self)
    48024538{
    4803     PyObject   *row_tuple = NULL;
    4804     int         j;
    4805 
    4806     if (!(row_tuple = PyTuple_New(self->num_fields))) return NULL;
    4807 
    4808     for (j = 0; j < self->num_fields; ++j)
    4809     {
     4539    PyObject *row_tuple = NULL;
     4540    int j;
     4541
     4542    if (!(row_tuple = PyTuple_New(self->num_fields))) {
     4543        return NULL;
     4544    }
     4545
     4546    for (j = 0; j < self->num_fields; ++j) {
    48104547        PyObject *val = getValueInColumn(self, j);
    4811         if (!val)
    4812         {
     4548        if (!val) {
    48134549            Py_DECREF(row_tuple); return NULL;
    48144550        }
     
    48244560queryNext(queryObject *self, PyObject *noargs)
    48254561{
    4826     PyObject   *row_tuple = NULL;
     4562    PyObject *row_tuple = NULL;
    48274563
    48284564    if (self->current_row >= self->max_row) {
     
    48904626queryGetresult(queryObject *self, PyObject *noargs)
    48914627{
    4892     PyObject   *result_list;
    4893     int         i;
    4894 
    4895     if (!(result_list = PyList_New(self->max_row))) return NULL;
    4896 
    4897     for (i = self->current_row = 0; i < self->max_row; ++i)
    4898     {
    4899         PyObject   *row_tuple = queryNext(self, noargs);
    4900         if (!row_tuple)
    4901         {
     4628    PyObject *result_list;
     4629    int i;
     4630
     4631    if (!(result_list = PyList_New(self->max_row))) {
     4632        return NULL;
     4633    }
     4634
     4635    for (i = self->current_row = 0; i < self->max_row; ++i) {
     4636        PyObject *row_tuple = queryNext(self, noargs);
     4637
     4638        if (!row_tuple) {
    49024639            Py_DECREF(result_list); return NULL;
    49034640        }
     
    49124649queryGetRowAsDict(queryObject *self)
    49134650{
    4914     PyObject   *row_dict = NULL;
    4915     int         j;
    4916 
    4917     if (!(row_dict = PyDict_New())) return NULL;
    4918 
    4919     for (j = 0; j < self->num_fields; ++j)
    4920     {
     4651    PyObject *row_dict = NULL;
     4652    int j;
     4653
     4654    if (!(row_dict = PyDict_New())) {
     4655        return NULL;
     4656    }
     4657
     4658    for (j = 0; j < self->num_fields; ++j) {
    49214659        PyObject *val = getValueInColumn(self, j);
    4922         if (!val)
    4923         {
     4660
     4661        if (!val) {
    49244662            Py_DECREF(row_dict); return NULL;
    49254663        }
     
    49354673queryNextDict(queryObject *self, PyObject *noargs)
    49364674{
    4937     PyObject   *row_dict = NULL;
     4675    PyObject *row_dict = NULL;
    49384676
    49394677    if (self->current_row >= self->max_row) {
     
    50034741queryDictresult(queryObject *self, PyObject *noargs)
    50044742{
    5005     PyObject   *result_list;
    5006     int         i;
    5007 
    5008     if (!(result_list = PyList_New(self->max_row))) return NULL;
    5009 
    5010     for (i = self->current_row = 0; i < self->max_row; ++i)
    5011     {
    5012         PyObject   *row_dict = queryNextDict(self, noargs);
    5013         if (!row_dict)
    5014         {
     4743    PyObject *result_list;
     4744    int i;
     4745
     4746    if (!(result_list = PyList_New(self->max_row))) {
     4747        return NULL;
     4748    }
     4749
     4750    for (i = self->current_row = 0; i < self->max_row; ++i) {
     4751        PyObject *row_dict = queryNextDict(self, noargs);
     4752
     4753        if (!row_dict) {
    50154754            Py_DECREF(result_list); return NULL;
    50164755        }
     
    50304769queryDictiter(queryObject *self, PyObject *noargs)
    50314770{
    5032     if (!dictiter)
     4771    if (!dictiter) {
    50334772        return queryDictresult(self, noargs);
     4773    }
    50344774
    50354775    return PyObject_CallFunction(dictiter, "(O)", self);
     
    50464786queryOnenamed(queryObject *self, PyObject *noargs)
    50474787{
    5048     if (!namednext)
     4788    if (!namednext) {
    50494789        return queryOne(self, noargs);
     4790    }
    50504791
    50514792    if (self->current_row >= self->max_row) {
     
    50664807querySinglenamed(queryObject *self, PyObject *noargs)
    50674808{
    5068     if (!namednext)
     4809    if (!namednext) {
    50694810        return querySingle(self, noargs);
     4811    }
    50704812
    50714813    if (self->max_row != 1) {
     
    50884830queryNamedresult(queryObject *self, PyObject *noargs)
    50894831{
    5090     PyObject   *res, *res_list;
    5091 
    5092     if (!namediter)
     4832    PyObject *res, *res_list;
     4833
     4834    if (!namediter) {
    50934835        return queryGetresult(self, noargs);
     4836    }
    50944837
    50954838    res = PyObject_CallFunction(namediter, "(O)", self);
     
    51104853queryNamediter(queryObject *self, PyObject *noargs)
    51114854{
    5112     PyObject   *res, *res_iter;
    5113 
    5114     if (!namediter)
     4855    PyObject *res, *res_iter;
     4856
     4857    if (!namediter) {
    51154858        return queryGetIter(self);
     4859    }
    51164860
    51174861    res = PyObject_CallFunction(namediter, "(O)", self);
    51184862    if (!res) return NULL;
    51194863    if (!PyList_Check(res)) return res;
    5120     res_iter = (Py_TYPE(res)->tp_iter)((PyObject *)self);
     4864    res_iter = (Py_TYPE(res)->tp_iter)((PyObject *) self);
    51214865    Py_DECREF(res);
    51224866    return res_iter;
     
    51324876queryScalarresult(queryObject *self, PyObject *noargs)
    51334877{
    5134     PyObject   *result_list;
     4878    PyObject *result_list;
    51354879
    51364880    if (!self->num_fields) {
     
    51394883    }
    51404884
    5141     if (!(result_list = PyList_New(self->max_row))) return NULL;
    5142 
    5143     for (self->current_row = 0; self->current_row < self->max_row;
    5144         ++self->current_row)
     4885    if (!(result_list = PyList_New(self->max_row))) {
     4886        return NULL;
     4887    }
     4888
     4889    for (self->current_row = 0;
     4890         self->current_row < self->max_row;
     4891         ++self->current_row)
    51454892    {
    5146         PyObject   *value = getValueInColumn(self, 0);
    5147         if (!value)
    5148         {
     4893        PyObject *value = getValueInColumn(self, 0);
     4894
     4895        if (!value) {
    51494896            Py_DECREF(result_list); return NULL;
    51504897        }
     
    51644911queryScalariter(queryObject *self, PyObject *noargs)
    51654912{
    5166     if (!scalariter)
     4913    if (!scalariter) {
    51674914        return queryScalarresult(self, noargs);
     4915    }
    51684916
    51694917    if (!self->num_fields) {
     
    52344982queryLen(PyObject *self)
    52354983{
    5236     PyObject   *tmp;
    5237     long        len;
    5238 
    5239     tmp = PyLong_FromLong(((queryObject*)self)->max_row);
     4984    PyObject *tmp;
     4985    long len;
     4986
     4987    tmp = PyLong_FromLong(((queryObject*) self)->max_row);
    52404988    len = PyLong_AsSsize_t(tmp);
    52414989    Py_DECREF(tmp);
     
    52474995queryGetItem(PyObject *self, Py_ssize_t i)
    52484996{
    5249     queryObject    *q = (queryObject *)self;
    5250     PyObject       *tmp;
    5251     long            row;
     4997    queryObject *q = (queryObject *) self;
     4998    PyObject *tmp;
     4999    long row;
    52525000
    52535001    tmp = PyLong_FromSize_t(i);
     
    52725020    int fieldcode;
    52735021
    5274     if (!res)
    5275     {
     5022    if (!res) {
    52765023        PyErr_SetString(PyExc_TypeError, "Cannot get current notice");
    52775024        return NULL;
     
    52795026
    52805027    /* pg connection object */
    5281     if (!strcmp(name, "pgcnx"))
    5282     {
    5283         if (self->pgcnx && check_cnx_obj(self->pgcnx))
    5284         {
     5028    if (!strcmp(name, "pgcnx")) {
     5029        if (self->pgcnx && check_cnx_obj(self->pgcnx)) {
    52855030            Py_INCREF(self->pgcnx);
    52865031            return (PyObject *) self->pgcnx;
    52875032        }
    5288         else
    5289         {
     5033        else {
    52905034            Py_INCREF(Py_None);
    52915035            return Py_None;
     
    52945038
    52955039    /* full message */
    5296     if (!strcmp(name, "message"))
     5040    if (!strcmp(name, "message")) {
    52975041        return PyStr_FromString(PQresultErrorMessage(res));
     5042    }
    52985043
    52995044    /* other possible fields */
     
    53075052    else if (!strcmp(name, "hint"))
    53085053        fieldcode = PG_DIAG_MESSAGE_HINT;
    5309     if (fieldcode)
    5310     {
     5054    if (fieldcode) {
    53115055        char *s = PQresultErrorField(res, fieldcode);
    5312         if (s)
     5056        if (s) {
    53135057            return PyStr_FromString(s);
    5314         else
    5315         {
     5058        }
     5059        else {
    53165060            Py_INCREF(Py_None); return Py_None;
    53175061        }
     
    53345078    PyObject *attrs;
    53355079
    5336     attrs = PyObject_Dir(PyObject_Type((PyObject *)self));
    5337     PyObject_CallMethod(attrs, "extend", "[ssssss]",
     5080    attrs = PyObject_Dir(PyObject_Type((PyObject *) self));
     5081    PyObject_CallMethod(
     5082        attrs, "extend", "[ssssss]",
    53385083        "pgcnx", "severity", "message", "primary", "detail", "hint");
    53395084
     
    54635208    0,                          /* tp_richcompare */
    54645209    0,                          /* tp_weaklistoffset */
    5465     (getiterfunc)queryGetIter, /* tp_iter */
    5466     (iternextfunc)queryNext,    /* tp_iternext */
     5210    (getiterfunc) queryGetIter, /* tp_iter */
     5211    (iternextfunc) queryNext,   /* tp_iternext */
    54675212    queryMethods,               /* tp_methods */
    54685213};
     
    54795224pgEscapeString(PyObject *self, PyObject *string)
    54805225{
    5481     PyObject   *tmp_obj = NULL, /* auxiliary string object */
    5482                *to_obj; /* string object to return */
    5483     char       *from, /* our string argument as encoded string */
    5484                *to; /* the result as encoded string */
    5485     Py_ssize_t  from_length; /* length of string */
    5486     size_t      to_length; /* length of result */
    5487     int         encoding = -1; /* client encoding */
    5488 
    5489     if (PyBytes_Check(string))
    5490     {
     5226    PyObject *tmp_obj = NULL,  /* auxiliary string object */
     5227             *to_obj;          /* string object to return */
     5228    char *from,  /* our string argument as encoded string */
     5229         *to;    /* the result as encoded string */
     5230    Py_ssize_t from_length;    /* length of string */
     5231    size_t to_length;          /* length of result */
     5232    int encoding = -1;         /* client encoding */
     5233
     5234    if (PyBytes_Check(string)) {
    54915235        PyBytes_AsStringAndSize(string, &from, &from_length);
    54925236    }
    5493     else if (PyUnicode_Check(string))
    5494     {
     5237    else if (PyUnicode_Check(string)) {
    54955238        encoding = pg_encoding_ascii;
    54965239        tmp_obj = get_encoded_string(string, encoding);
     
    54985241        PyBytes_AsStringAndSize(tmp_obj, &from, &from_length);
    54995242    }
    5500     else
    5501     {
     5243    else {
    55025244        PyErr_SetString(PyExc_TypeError,
    5503             "Method escape_string() expects a string as argument");
     5245                        "Method escape_string() expects a string as argument");
    55045246        return NULL;
    55055247    }
    55065248
    55075249    to_length = 2*from_length + 1;
    5508     if ((Py_ssize_t)to_length < from_length) /* overflow */
    5509     {
     5250    if ((Py_ssize_t ) to_length < from_length) { /* overflow */
    55105251        to_length = from_length;
    55115252        from_length = (from_length - 1)/2;
    55125253    }
    5513     to = (char *)PyMem_Malloc(to_length);
    5514     to_length = (int)PQescapeString(to, from, (size_t)from_length);
     5254    to = (char *) PyMem_Malloc(to_length);
     5255    to_length = (int) PQescapeString(to, from, (size_t) from_length);
    55155256
    55165257    Py_XDECREF(tmp_obj);
     
    55315272pgEscapeBytea(PyObject *self, PyObject *data)
    55325273{
    5533     PyObject   *tmp_obj = NULL, /* auxiliary string object */
    5534                *to_obj; /* string object to return */
    5535     char       *from, /* our string argument as encoded string */
    5536                *to; /* the result as encoded string */
    5537     Py_ssize_t  from_length; /* length of string */
    5538     size_t      to_length; /* length of result */
    5539     int         encoding = -1; /* client encoding */
    5540 
    5541     if (PyBytes_Check(data))
    5542     {
     5274    PyObject *tmp_obj = NULL,  /* auxiliary string object */
     5275             *to_obj;          /* string object to return */
     5276    char *from,  /* our string argument as encoded string */
     5277         *to;    /* the result as encoded string */
     5278    Py_ssize_t from_length;    /* length of string */
     5279    size_t to_length;          /* length of result */
     5280    int encoding = -1;         /* client encoding */
     5281
     5282    if (PyBytes_Check(data)) {
    55435283        PyBytes_AsStringAndSize(data, &from, &from_length);
    55445284    }
    5545     else if (PyUnicode_Check(data))
    5546     {
     5285    else if (PyUnicode_Check(data)) {
    55475286        encoding = pg_encoding_ascii;
    55485287        tmp_obj = get_encoded_string(data, encoding);
     
    55505289        PyBytes_AsStringAndSize(tmp_obj, &from, &from_length);
    55515290    }
    5552     else
    5553     {
     5291    else {
    55545292        PyErr_SetString(PyExc_TypeError,
    5555             "Method escape_bytea() expects a string as argument");
    5556         return NULL;
    5557     }
    5558 
    5559     to = (char *)PQescapeBytea(
    5560         (unsigned char*)from, (size_t)from_length, &to_length);
     5293                        "Method escape_bytea() expects a string as argument");
     5294        return NULL;
     5295    }
     5296
     5297    to = (char *) PQescapeBytea(
     5298        (unsigned char*) from, (size_t) from_length, &to_length);
    55615299
    55625300    Py_XDECREF(tmp_obj);
     
    55785316pgUnescapeBytea(PyObject *self, PyObject *data)
    55795317{
    5580     PyObject   *tmp_obj = NULL, /* auxiliary string object */
    5581                *to_obj; /* string object to return */
    5582     char       *from, /* our string argument as encoded string */
    5583                *to; /* the result as encoded string */
    5584     Py_ssize_t  from_length; /* length of string */
    5585     size_t      to_length; /* length of result */
    5586 
    5587     if (PyBytes_Check(data))
    5588     {
     5318    PyObject *tmp_obj = NULL,  /* auxiliary string object */
     5319             *to_obj;          /* string object to return */
     5320    char *from,  /* our string argument as encoded string */
     5321         *to;    /* the result as encoded string */
     5322    Py_ssize_t from_length;    /* length of string */
     5323    size_t to_length;          /* length of result */
     5324
     5325    if (PyBytes_Check(data)) {
    55895326        PyBytes_AsStringAndSize(data, &from, &from_length);
    55905327    }
    5591     else if (PyUnicode_Check(data))
    5592     {
     5328    else if (PyUnicode_Check(data)) {
    55935329        tmp_obj = get_encoded_string(data, pg_encoding_ascii);
    55945330        if (!tmp_obj) return NULL; /* pass the UnicodeEncodeError */
    55955331        PyBytes_AsStringAndSize(tmp_obj, &from, &from_length);
    55965332    }
    5597     else
    5598     {
    5599         PyErr_SetString(PyExc_TypeError,
     5333    else {
     5334        PyErr_SetString(
     5335            PyExc_TypeError,
    56005336            "Method unescape_bytea() expects a string as argument");
    56015337        return NULL;
    56025338    }
    56035339
    5604     to = (char *)PQunescapeBytea((unsigned char*)from, &to_length);
     5340    to = (char *) PQunescapeBytea((unsigned char*) from, &to_length);
    56055341
    56065342    Py_XDECREF(tmp_obj);
     
    56215357pgSetDatestyle(PyObject *self, PyObject *args)
    56225358{
    5623     const char     *datestyle = NULL;
     5359    const char *datestyle = NULL;
    56245360
    56255361    /* gets arguments */
    5626     if (!PyArg_ParseTuple(args, "z", &datestyle))
    5627     {
    5628         PyErr_SetString(PyExc_TypeError,
     5362    if (!PyArg_ParseTuple(args, "z", &datestyle)) {
     5363        PyErr_SetString(
     5364            PyExc_TypeError,
    56295365            "Function set_datestyle() expects a string or None as argument");
    56305366        return NULL;
     
    56435379pgGetDatestyle(PyObject *self, PyObject *noargs)
    56445380{
    5645     if (date_format)
    5646     {
     5381    if (date_format) {
    56475382        return PyStr_FromString(date_format_to_style(date_format));
    56485383    }
    5649     else
    5650     {
     5384    else {
    56515385        Py_INCREF(Py_None); return Py_None;
    56525386    }
     
    56635397    char s[2];
    56645398
    5665     if (decimal_point)
    5666     {
     5399    if (decimal_point) {
    56675400        s[0] = decimal_point; s[1] = '\0';
    56685401        ret = PyStr_FromString(s);
    56695402    }
    5670     else
    5671     {
     5403    else {
    56725404        Py_INCREF(Py_None); ret = Py_None;
    56735405    }
     
    56875419
    56885420    /* gets arguments */
    5689     if (PyArg_ParseTuple(args, "z", &s))
    5690     {
     5421    if (PyArg_ParseTuple(args, "z", &s)) {
    56915422        if (!s)
    56925423            s = "\0";
     
    56955426    }
    56965427
    5697     if (s)
    5698     {
     5428    if (s) {
    56995429        decimal_point = *s;
    57005430        Py_INCREF(Py_None); ret = Py_None;
    57015431    }
    5702     else
     5432    else {
    57035433        PyErr_SetString(PyExc_TypeError,
    5704             "Function set_decimal_mark() expects"
    5705             " a decimal mark character as argument");
    5706 
     5434                        "Function set_decimal_mark() expects"
     5435                        " a decimal mark character as argument");
     5436    }
    57075437    return ret;
    57085438}
     
    57325462    PyObject *ret = NULL;
    57335463
    5734     if (cls == Py_None)
    5735     {
     5464    if (cls == Py_None) {
    57365465        Py_XDECREF(decimal); decimal = NULL;
    57375466        Py_INCREF(Py_None); ret = Py_None;
    57385467    }
    5739     else if (PyCallable_Check(cls))
    5740     {
     5468    else if (PyCallable_Check(cls)) {
    57415469        Py_XINCREF(cls); Py_XDECREF(decimal); decimal = cls;
    57425470        Py_INCREF(Py_None); ret = Py_None;
    57435471    }
    5744     else
     5472    else {
    57455473        PyErr_SetString(PyExc_TypeError,
    5746             "Function set_decimal() expects"
    5747              " a callable or None as argument");
     5474                        "Function set_decimal() expects"
     5475                        " a callable or None as argument");
     5476    }
    57485477
    57495478    return ret;
     
    57735502{
    57745503    PyObject *ret = NULL;
    5775     int         i;
     5504    int i;
    57765505
    57775506    /* gets arguments */
    5778     if (PyArg_ParseTuple(args, "i", &i))
    5779     {
     5507    if (PyArg_ParseTuple(args, "i", &i)) {
    57805508        bool_as_text = i ? 0 : 1;
    57815509        Py_INCREF(Py_None); ret = Py_None;
    57825510    }
    5783     else
    5784         PyErr_SetString(PyExc_TypeError,
     5511    else {
     5512        PyErr_SetString(
     5513            PyExc_TypeError,
    57855514            "Function set_bool() expects a boolean value as argument");
     5515    }
    57865516
    57875517    return ret;
     
    58085538
    58095539static PyObject *
    5810 pgSetArray(PyObject *self, PyObject *args)
    5811 {
    5812     PyObject *ret = NULL;
    5813     int         i;
     5540pgSetArray(PyObject* self, PyObject* args)
     5541{
     5542    PyObject* ret = NULL;
     5543    int i;
    58145544
    58155545    /* gets arguments */
    5816     if (PyArg_ParseTuple(args, "i", &i))
    5817     {
     5546    if (PyArg_ParseTuple(args, "i", &i)) {
    58185547        array_as_text = i ? 0 : 1;
    58195548        Py_INCREF(Py_None); ret = Py_None;
    58205549    }
    5821     else
    5822         PyErr_SetString(PyExc_TypeError,
     5550    else {
     5551        PyErr_SetString(
     5552            PyExc_TypeError,
    58235553            "Function set_array() expects a boolean value as argument");
     5554    }
    58245555
    58255556    return ret;
     
    58495580{
    58505581    PyObject *ret = NULL;
    5851     int         i;
     5582    int i;
    58525583
    58535584    /* gets arguments */
    5854     if (PyArg_ParseTuple(args, "i", &i))
    5855     {
     5585    if (PyArg_ParseTuple(args, "i", &i)) {
    58565586        bytea_escaped = i ? 1 : 0;
    58575587        Py_INCREF(Py_None); ret = Py_None;
    58585588    }
    5859     else
    5860         PyErr_SetString(PyExc_TypeError,
     5589    else {
     5590        PyErr_SetString(
     5591            PyExc_TypeError,
    58615592            "Function set_bytea_escaped() expects a boolean value as argument");
     5593    }
    58625594
    58635595    return ret;
     
    58775609        &PyFunction_Type, &namediter,
    58785610        &PyFunction_Type, &namednext,
    5879         &PyFunction_Type, &scalariter)) return NULL;
     5611        &PyFunction_Type, &scalariter))
     5612    {
     5613        return NULL;
     5614    }
    58805615
    58815616    Py_INCREF(Py_None);
     
    59095644    PyObject *ret = NULL;
    59105645
    5911     if (func == Py_None)
    5912     {
     5646    if (func == Py_None) {
    59135647        Py_XDECREF(jsondecode); jsondecode = NULL;
    59145648        Py_INCREF(Py_None); ret = Py_None;
    59155649    }
    5916     else if (PyCallable_Check(func))
    5917     {
     5650    else if (PyCallable_Check(func)) {
    59185651        Py_XINCREF(func); Py_XDECREF(jsondecode); jsondecode = func;
    59195652        Py_INCREF(Py_None); ret = Py_None;
    59205653    }
    5921     else
     5654    else {
    59225655        PyErr_SetString(PyExc_TypeError,
    5923             "Function jsondecode() expects"
    5924              " a callable or None as argument");
     5656                        "Function jsondecode() expects"
     5657                        " a callable or None as argument");
     5658    }
    59255659
    59265660    return ret;
     
    59475681pgSetDefHost(PyObject *self, PyObject *args)
    59485682{
    5949     char       *temp = NULL;
    5950     PyObject   *old;
     5683    char *tmp = NULL;
     5684    PyObject *old;
    59515685
    59525686    /* gets arguments */
    5953     if (!PyArg_ParseTuple(args, "z", &temp))
    5954     {
    5955         PyErr_SetString(PyExc_TypeError,
     5687    if (!PyArg_ParseTuple(args, "z", &tmp)) {
     5688        PyErr_SetString(
     5689            PyExc_TypeError,
    59565690            "Function set_defhost() expects a string or None as argument");
    59575691        return NULL;
     
    59615695    old = pg_default_host;
    59625696
    5963     if (temp)
    5964         pg_default_host = PyStr_FromString(temp);
    5965     else
    5966     {
     5697    if (tmp) {
     5698        pg_default_host = PyStr_FromString(tmp);
     5699    }
     5700    else {
    59675701        Py_INCREF(Py_None);
    59685702        pg_default_host = Py_None;
     
    59905724pgSetDefBase(PyObject *self, PyObject *args)
    59915725{
    5992     char       *temp = NULL;
    5993     PyObject   *old;
     5726    char *tmp = NULL;
     5727    PyObject *old;
    59945728
    59955729    /* gets arguments */
    5996     if (!PyArg_ParseTuple(args, "z", &temp))
    5997     {
    5998         PyErr_SetString(PyExc_TypeError,
     5730    if (!PyArg_ParseTuple(args, "z", &tmp)) {
     5731        PyErr_SetString(
     5732            PyExc_TypeError,
    59995733            "Function set_defbase() Argument a string or None as argument");
    60005734        return NULL;
     
    60045738    old = pg_default_base;
    60055739
    6006     if (temp)
    6007         pg_default_base = PyStr_FromString(temp);
    6008     else
    6009     {
     5740    if (tmp) {
     5741        pg_default_base = PyStr_FromString(tmp);
     5742    }
     5743    else {
    60105744        Py_INCREF(Py_None);
    60115745        pg_default_base = Py_None;
     
    60335767pgSetDefOpt(PyObject *self, PyObject *args)
    60345768{
    6035     char       *temp = NULL;
    6036     PyObject   *old;
     5769    char *tmp = NULL;
     5770    PyObject *old;
    60375771
    60385772    /* gets arguments */
    6039     if (!PyArg_ParseTuple(args, "z", &temp))
    6040     {
    6041         PyErr_SetString(PyExc_TypeError,
     5773    if (!PyArg_ParseTuple(args, "z", &tmp)) {
     5774        PyErr_SetString(
     5775            PyExc_TypeError,
    60425776            "Function set_defopt() expects a string or None as argument");
    60435777        return NULL;
     
    60475781    old = pg_default_opt;
    60485782
    6049     if (temp)
    6050         pg_default_opt = PyStr_FromString(temp);
    6051     else
    6052     {
     5783    if (tmp) {
     5784        pg_default_opt = PyStr_FromString(tmp);
     5785    }
     5786    else {
    60535787        Py_INCREF(Py_None);
    60545788        pg_default_opt = Py_None;
     
    60775811pgSetDefUser(PyObject *self, PyObject *args)
    60785812{
    6079     char       *temp = NULL;
    6080     PyObject   *old;
     5813    char *tmp = NULL;
     5814    PyObject *old;
    60815815
    60825816    /* gets arguments */
    6083     if (!PyArg_ParseTuple(args, "z", &temp))
    6084     {
    6085         PyErr_SetString(PyExc_TypeError,
     5817    if (!PyArg_ParseTuple(args, "z", &tmp)) {
     5818        PyErr_SetString(
     5819            PyExc_TypeError,
    60865820            "Function set_defuser() expects a string or None as argument");
    60875821        return NULL;
     
    60915825    old = pg_default_user;
    60925826
    6093     if (temp)
    6094         pg_default_user = PyStr_FromString(temp);
    6095     else
    6096     {
     5827    if (tmp) {
     5828        pg_default_user = PyStr_FromString(tmp);
     5829    }
     5830    else {
    60975831        Py_INCREF(Py_None);
    60985832        pg_default_user = Py_None;
     
    61095843pgSetDefPassword(PyObject *self, PyObject *args)
    61105844{
    6111     char       *temp = NULL;
     5845    char *tmp = NULL;
    61125846
    61135847    /* gets arguments */
    6114     if (!PyArg_ParseTuple(args, "z", &temp))
    6115     {
    6116         PyErr_SetString(PyExc_TypeError,
     5848    if (!PyArg_ParseTuple(args, "z", &tmp)) {
     5849        PyErr_SetString(
     5850            PyExc_TypeError,
    61175851            "Function set_defpasswd() expects a string or None as argument");
    61185852        return NULL;
    61195853    }
    61205854
    6121     if (temp)
    6122         pg_default_passwd = PyStr_FromString(temp);
    6123     else
    6124     {
     5855    if (tmp) {
     5856        pg_default_passwd = PyStr_FromString(tmp);
     5857    }
     5858    else {
    61255859        Py_INCREF(Py_None);
    61265860        pg_default_passwd = Py_None;
     
    61495883pgSetDefPort(PyObject *self, PyObject *args)
    61505884{
    6151     long int    port = -2;
    6152     PyObject   *old;
     5885    long int port = -2;
     5886    PyObject *old;
    61535887
    61545888    /* gets arguments */
    6155     if ((!PyArg_ParseTuple(args, "l", &port)) || (port < -1))
    6156     {
     5889    if ((!PyArg_ParseTuple(args, "l", &port)) || (port < -1)) {
    61575890        PyErr_SetString(PyExc_TypeError,
    6158             "Function set_deport expects"
    6159              " a positive integer or -1 as argument");
     5891                        "Function set_deport expects"
     5892                        " a positive integer or -1 as argument");
    61605893        return NULL;
    61615894    }
     
    61645897    old = pg_default_port;
    61655898
    6166     if (port != -1)
     5899    if (port != -1) {
    61675900        pg_default_port = PyInt_FromLong(port);
    6168     else
    6169     {
     5901    }
     5902    else {
    61705903        Py_INCREF(Py_None);
    61715904        pg_default_port = Py_None;
     
    61845917{
    61855918    static const char *kwlist[] = {"string", "cast", "delim", NULL};
    6186     PyObject   *string_obj, *cast_obj = NULL, *ret;
    6187     char       *string, delim = ',';
    6188     Py_ssize_t  size;
    6189     int         encoding;
    6190 
    6191     if (!PyArg_ParseTupleAndKeywords(args, dict, "O|Oc",
    6192             (char **) kwlist, &string_obj, &cast_obj, &delim))
    6193         return NULL;
    6194 
    6195     if (PyBytes_Check(string_obj))
     5919    PyObject *string_obj, *cast_obj = NULL, *ret;
     5920    char *string, delim = ',';
     5921    Py_ssize_t size;
     5922    int encoding;
     5923
     5924    if (!PyArg_ParseTupleAndKeywords(
     5925        args, dict, "O|Oc",
     5926        (char**) kwlist, &string_obj, &cast_obj, &delim))
    61965927    {
     5928        return NULL;
     5929    }
     5930
     5931    if (PyBytes_Check(string_obj)) {
    61975932        PyBytes_AsStringAndSize(string_obj, &string, &size);
    61985933        string_obj = NULL;
    61995934        encoding = pg_encoding_ascii;
    62005935    }
    6201     else if (PyUnicode_Check(string_obj))
    6202     {
     5936    else if (PyUnicode_Check(string_obj)) {
    62035937        string_obj = PyUnicode_AsUTF8String(string_obj);
    62045938        if (!string_obj) return NULL; /* pass the UnicodeEncodeError */
     
    62065940        encoding = pg_encoding_utf8;
    62075941    }
    6208     else
    6209     {
    6210         PyErr_SetString(PyExc_TypeError,
     5942    else {
     5943        PyErr_SetString(
     5944            PyExc_TypeError,
    62115945            "Function cast_array() expects a string as first argument");
    62125946        return NULL;
    62135947    }
    62145948
    6215     if (!cast_obj || cast_obj == Py_None)
    6216     {
    6217         if (cast_obj)
    6218         {
     5949    if (!cast_obj || cast_obj == Py_None) {
     5950        if (cast_obj) {
    62195951            Py_DECREF(cast_obj); cast_obj = NULL;
    62205952        }
    62215953    }
    6222     else if (!PyCallable_Check(cast_obj))
    6223     {
    6224         PyErr_SetString(PyExc_TypeError,
     5954    else if (!PyCallable_Check(cast_obj)) {
     5955        PyErr_SetString(
     5956            PyExc_TypeError,
    62255957            "Function cast_array() expects a callable as second argument");
    62265958        return NULL;
     
    62425974{
    62435975    static const char *kwlist[] = {"string", "cast", "delim", NULL};
    6244     PyObject   *string_obj, *cast_obj = NULL, *ret;
    6245     char       *string, delim = ',';
    6246     Py_ssize_t  size, len;
    6247     int         encoding;
    6248 
    6249     if (!PyArg_ParseTupleAndKeywords(args, dict, "O|Oc",
    6250             (char **) kwlist, &string_obj, &cast_obj, &delim))
    6251         return NULL;
    6252 
    6253     if (PyBytes_Check(string_obj))
     5976    PyObject *string_obj, *cast_obj = NULL, *ret;
     5977    char *string, delim = ',';
     5978    Py_ssize_t size, len;
     5979    int encoding;
     5980
     5981    if (!PyArg_ParseTupleAndKeywords(
     5982        args, dict, "O|Oc",
     5983        (char**) kwlist, &string_obj, &cast_obj, &delim))
    62545984    {
     5985        return NULL;
     5986    }
     5987
     5988    if (PyBytes_Check(string_obj)) {
    62555989        PyBytes_AsStringAndSize(string_obj, &string, &size);
    62565990        string_obj = NULL;
    62575991        encoding = pg_encoding_ascii;
    62585992    }
    6259     else if (PyUnicode_Check(string_obj))
    6260     {
     5993    else if (PyUnicode_Check(string_obj)) {
    62615994        string_obj = PyUnicode_AsUTF8String(string_obj);
    62625995        if (!string_obj) return NULL; /* pass the UnicodeEncodeError */
     
    62645997        encoding = pg_encoding_utf8;
    62655998    }
    6266     else
    6267     {
     5999    else {
     6000        PyErr_SetString(
     6001            PyExc_TypeError,
     6002            "Function cast_record() expects a string as first argument");
     6003        return NULL;
     6004    }
     6005
     6006    if (!cast_obj || PyCallable_Check(cast_obj)) {
     6007        len = 0;
     6008    }
     6009    else if (cast_obj == Py_None) {
     6010        Py_DECREF(cast_obj); cast_obj = NULL; len = 0;
     6011    }
     6012    else if (PyTuple_Check(cast_obj) || PyList_Check(cast_obj)) {
     6013        len = PySequence_Size(cast_obj);
     6014        if (!len) {
     6015            Py_DECREF(cast_obj); cast_obj = NULL;
     6016        }
     6017    }
     6018    else {
    62686019        PyErr_SetString(PyExc_TypeError,
    6269             "Function cast_record() expects a string as first argument");
    6270         return NULL;
    6271     }
    6272 
    6273     if (!cast_obj || PyCallable_Check(cast_obj))
    6274     {
    6275         len = 0;
    6276     }
    6277     else if (cast_obj == Py_None)
    6278     {
    6279         Py_DECREF(cast_obj); cast_obj = NULL; len = 0;
    6280     }
    6281     else if (PyTuple_Check(cast_obj) || PyList_Check(cast_obj))
    6282     {
    6283         len = PySequence_Size(cast_obj);
    6284         if (!len)
    6285         {
    6286             Py_DECREF(cast_obj); cast_obj = NULL;
    6287         }
    6288     }
    6289     else
    6290     {
    6291         PyErr_SetString(PyExc_TypeError,
    6292             "Function cast_record() expects a callable"
    6293              " or tuple or list of callables as second argument");
     6020                        "Function cast_record() expects a callable"
     6021                        " or tuple or list of callables as second argument");
    62946022        return NULL;
    62956023    }
     
    63096037pgCastHStore(PyObject *self, PyObject *string)
    63106038{
    6311     PyObject   *tmp_obj = NULL, *ret;
    6312     char       *s;
    6313     Py_ssize_t  size;
    6314     int         encoding;
    6315 
    6316     if (PyBytes_Check(string))
    6317     {
     6039    PyObject *tmp_obj = NULL, *ret;
     6040    char *s;
     6041    Py_ssize_t size;
     6042    int encoding;
     6043
     6044    if (PyBytes_Check(string)) {
    63186045        PyBytes_AsStringAndSize(string, &s, &size);
    63196046        encoding = pg_encoding_ascii;
    63206047    }
    6321     else if (PyUnicode_Check(string))
    6322     {
     6048    else if (PyUnicode_Check(string)) {
    63236049        tmp_obj = PyUnicode_AsUTF8String(string);
    63246050        if (!tmp_obj) return NULL; /* pass the UnicodeEncodeError */
     
    63266052        encoding = pg_encoding_utf8;
    63276053    }
    6328     else
    6329     {
    6330         PyErr_SetString(PyExc_TypeError,
     6054    else {
     6055        PyErr_SetString(
     6056            PyExc_TypeError,
    63316057            "Function cast_hstore() expects a string as first argument");
    63326058        return NULL;
     
    64126138MODULE_INIT_FUNC(_pg)
    64136139{
    6414     PyObject   *mod, *dict, *s;
     6140    PyObject *mod, *dict, *s;
    64156141
    64166142    /* Create the module and add the functions */
     
    64406166        || PyType_Ready(&largeType)
    64416167#endif
    6442         ) return NULL;
     6168        )
     6169    {
     6170        return NULL;
     6171    }
    64436172
    64446173    dict = PyModule_GetDict(mod);
     
    64576186    PyDict_SetItemString(dict, "DatabaseError", DatabaseError);
    64586187
    6459     InternalError = PyErr_NewException("pg.InternalError", DatabaseError, NULL);
     6188    InternalError =
     6189        PyErr_NewException("pg.InternalError", DatabaseError, NULL);
    64606190    PyDict_SetItemString(dict, "InternalError", InternalError);
    64616191
     
    65326262
    65336263    /* Check for errors */
    6534     if (PyErr_Occurred())
    6535         return NULL;
     6264    if (PyErr_Occurred()) {
     6265        return NULL;
     6266    }
    65366267
    65376268    return mod;
Note: See TracChangeset for help on using the changeset viewer.