← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/_patiencediff_c.c

  • Committer: Canonical.com Patch Queue Manager
  • Date: 2008-04-07 07:52:50 UTC
  • mfrom: (3340.1.1 208418-1.4)
  • Revision ID: pqm@pqm.ubuntu.com-20080407075250-phs53xnslo8boaeo
Return the correct knit serialisation method in _StreamAccess.
        (Andrew Bennetts, Martin Pool, Robert Collins)

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/_patiencediff_c.c
13
13
 
14
14
 You should have received a copy of the GNU General Public License
15
15
 along with this program; if not, write to the Free Software
16
 
 Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 
16
 Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
17
17
 
18
18
 Function equate_lines based on bdiff.c from Mercurial.
19
19
   Copyright (C) 2005, 2006 Matt Mackall <mpm@selenic.com>
27
27
#include <string.h>
28
28
#include <Python.h>
29
29
 
30
 
#include "python-compat.h"
 
30
 
 
31
/* http://www.python.org/dev/peps/pep-0353/ */
 
32
#if PY_VERSION_HEX < 0x02050000 && !defined(PY_SSIZE_T_MIN)
 
33
typedef int Py_ssize_t;
 
34
#define PY_SSIZE_T_MAX INT_MAX
 
35
#define PY_SSIZE_T_MIN INT_MIN
 
36
#endif
31
37
 
32
38
 
33
39
#if defined(__GNUC__)
298
304
        apos = SENTINEL;
299
305
        /* loop through all lines in the linked list */
300
306
        for (i = h[equiv].a_pos; i != SENTINEL; i = lines_a[i].next) {
301
 
            /* the index is lower than alo, continue to the next line */
 
307
            /* the index is lower than alo, the the next line */
302
308
            if (i < alo) {
303
309
                h[equiv].a_pos = i;
304
310
                continue;
319
325
        /* check for duplicates of this line in lines_b[blo:bhi] */
320
326
        /* loop through all lines in the linked list */
321
327
        for (i = h[equiv].b_pos; i != SENTINEL; i = lines_b[i].next) {
322
 
            /* the index is lower than blo, continue to the next line */
 
328
            /* the index is lower than blo, the the next line */
323
329
            if (i < blo) {
324
330
                h[equiv].b_pos = i;
325
331
                continue;
535
541
}
536
542
 
537
543
 
538
 
static void
539
 
delete_lines(struct line *lines, Py_ssize_t size)
540
 
{
541
 
    struct line *line = lines;
542
 
    while (size-- > 0) {
543
 
        Py_XDECREF(line->data);
544
 
        line++;
545
 
    }
546
 
    free(lines);
547
 
}
548
 
 
549
 
 
550
544
static Py_ssize_t
551
545
load_lines(PyObject *orig, struct line **lines)
552
546
{
565
559
        return 0;
566
560
    }
567
561
 
568
 
    /* Allocate a memory block for line data, initialized to 0 */
569
 
    line = *lines = (struct line *)calloc(size, sizeof(struct line));
 
562
    line = *lines = (struct line *)malloc(sizeof(struct line) * size);
570
563
    if (line == NULL) {
571
564
        PyErr_NoMemory();
572
565
        Py_DECREF(seq);
575
568
 
576
569
    for (i = 0; i < size; i++) {
577
570
        item = PySequence_Fast_GET_ITEM(seq, i);
578
 
        Py_INCREF(item);
579
571
        line->data = item;
580
572
        line->hash = PyObject_Hash(item);
581
573
        if (line->hash == (-1)) {
589
581
 
590
582
    cleanup:
591
583
    Py_DECREF(seq);
592
 
    if (size == -1) {
593
 
        /* Error -- cleanup unused object references */
594
 
        delete_lines(*lines, i);
595
 
        *lines = NULL;
596
 
    }
597
584
    return size;
598
585
}
599
586
 
646
633
    free(backpointers);
647
634
    free(matches);
648
635
    free(hashtable.table);
649
 
    delete_lines(b, bsize);
650
 
    delete_lines(a, asize);
 
636
    free(b);
 
637
    free(a);
651
638
    return res;
652
639
 
653
640
error:
654
641
    free(backpointers);
655
642
    free(matches);
656
643
    free(hashtable.table);
657
 
    delete_lines(b, bsize);
658
 
    delete_lines(a, asize);
 
644
    free(b);
 
645
    free(a);
659
646
    return NULL;
660
647
}
661
648
 
724
711
    free(backpointers);
725
712
    free(matches.matches);
726
713
    free(hashtable.table);
727
 
    delete_lines(b, bsize);
728
 
    delete_lines(a, asize);
 
714
    free(b);
 
715
    free(a);
729
716
    Py_RETURN_NONE;
730
717
 
731
718
error:
732
719
    free(backpointers);
733
720
    free(matches.matches);
734
721
    free(hashtable.table);
735
 
    delete_lines(b, bsize);
736
 
    delete_lines(a, asize);
 
722
    free(b);
 
723
    free(a);
737
724
    return NULL;
738
725
}
739
726
 
768
755
        self->backpointers = (Py_ssize_t *)malloc(sizeof(Py_ssize_t) * self->bsize * 4);
769
756
        if (self->backpointers == NULL) {
770
757
            Py_DECREF(self);
771
 
            PyErr_NoMemory();
772
758
            return NULL;
773
759
        }
774
760
 
783
769
{
784
770
    free(self->backpointers);
785
771
    free(self->hashtable.table);
786
 
    delete_lines(self->b, self->bsize);
787
 
    delete_lines(self->a, self->asize);
 
772
    free(self->b);
 
773
    free(self->a);
788
774
    self->ob_type->tp_free((PyObject *)self);
789
775
}
790
776