← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/_patiencediff_c.c

  • Committer: Aaron Bentley
  • Date: 2007-12-20 00:15:34 UTC
  • mfrom: (3131 +trunk)
  • mto: This revision was merged to the branch mainline in revision 3132.
  • Revision ID: aaron.bentley@utoronto.ca-20071220001534-hufz1x7smg3l3en6
Merge bzr.dev

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/_patiencediff_c.c
70
70
 
71
71
 
72
72
struct line {
73
 
    int hash;          /* hash code of the string */
 
73
    long hash;         /* hash code of the string/object */
74
74
    Py_ssize_t next;   /* next line from the same equivalence class */
75
75
    Py_ssize_t equiv;  /* equivalence class */
76
 
    Py_ssize_t len;
77
 
    const char *data;
 
76
    PyObject *data;
78
77
};
79
78
 
80
79
 
151
150
static inline int
152
151
compare_lines(struct line *a, struct line *b)
153
152
{
154
 
    return ((a->hash != b->hash) || (a->len != b->len) ||
155
 
            memcmp(a->data, b->data, a->len));
 
153
    return ((a->hash != b->hash)
 
154
            || PyObject_Compare(a->data, b->data));
156
155
}
157
156
 
158
157
 
545
544
static Py_ssize_t
546
545
load_lines(PyObject *orig, struct line **lines)
547
546
{
548
 
    Py_ssize_t size, i, j;
549
 
    int h;
550
 
    char *p;
 
547
    Py_ssize_t size, i;
551
548
    struct line *line;
552
549
    PyObject *seq, *item;
553
550
 
571
568
 
572
569
    for (i = 0; i < size; i++) {
573
570
        item = PySequence_Fast_GET_ITEM(seq, i);
574
 
        if (!PyString_Check(item)){
575
 
            PyErr_Format(PyExc_TypeError,
576
 
                     "sequence item %zd: expected string,"
577
 
                     " %.80s found",
578
 
                     i, item->ob_type->tp_name);
579
 
            Py_DECREF(seq);
580
 
            return -1;
 
571
        line->data = item;
 
572
        line->hash = PyObject_Hash(item);
 
573
        if (line->hash == (-1)) {
 
574
            /* Propogate the hash exception */
 
575
            size = -1;
 
576
            goto cleanup;
581
577
        }
582
 
        line->len = PyString_GET_SIZE(item);
583
 
        line->data = p = PyString_AS_STRING(item);
584
 
        /* 'djb2' hash. This gives us a nice compromise between fast hash
585
 
            function and a hash with less collisions. The algorithm doesn't
586
 
            use the hash for actual lookups, only for building the table
587
 
            so a better hash function wouldn't bring us much benefit, but
588
 
            would make this loading code slower. */
589
 
        h = 5381;
590
 
        for (j = 0; j < line->len; j++)
591
 
            h = ((h << 5) + h) + *p++;
592
 
        line->hash = h;
593
578
        line->next = SENTINEL;
594
579
        line++;
595
580
    }
596
581
 
 
582
    cleanup:
597
583
    Py_DECREF(seq);
598
584
    return size;
599
585
}