← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/_patiencediff_c.c

  • Committer: Martin Pool
  • Date: 2010-02-25 06:17:27 UTC
  • mfrom: (5055 +trunk)
  • mto: This revision was merged to the branch mainline in revision 5057.
  • Revision ID: mbp@sourcefrog.net-20100225061727-4sd9lt0qmdc6087t
merge news

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/_patiencediff_c.c
1
1
/*
2
 
 Copyright (C) 2007 Canonical Ltd
 
2
 Copyright (C) 2007, 2010 Canonical Ltd
3
3
 
4
4
 This program is free software; you can redistribute it and/or modify
5
5
 it under the terms of the GNU General Public License as published by
46
46
#define SENTINEL -1
47
47
 
48
48
 
 
49
/* malloc returns NULL on some platforms if you try to allocate nothing,
 
50
 * causing <https://bugs.edge.launchpad.net/bzr/+bug/511267> and
 
51
 * <https://bugs.edge.launchpad.net/bzr/+bug/331095>.  On glibc it passes, but
 
52
 * let's make it fail to aid testing. */
 
53
#define guarded_malloc(x) ( (x) ? malloc(x) : NULL )
 
54
 
49
55
enum {
50
56
    OP_EQUAL = 0,
51
57
    OP_INSERT,
183
189
    while (hsize < bsize + 1)
184
190
        hsize *= 2;
185
191
 
186
 
    hashtable = (struct bucket *)malloc(sizeof(struct bucket) * hsize);
 
192
    /* can't be 0 */
 
193
    hashtable = (struct bucket *) guarded_malloc(sizeof(struct bucket) * hsize);
187
194
    if (hashtable == NULL) {
188
195
        PyErr_NoMemory();
189
196
        return 0;
460
467
    last_a_pos = alo - 1;
461
468
    last_b_pos = blo - 1;
462
469
 
463
 
    lcs = (struct matching_line *)malloc(sizeof(struct matching_line) * (bhi - blo));
 
470
    lcs = (struct matching_line *)guarded_malloc(sizeof(struct matching_line) * (bhi - blo));
464
471
    if (lcs == NULL)
465
472
        return 0;
466
473
 
620
627
    if (!equate_lines(&hashtable, a, b, asize, bsize))
621
628
        goto error;
622
629
 
623
 
    matches = (struct matching_line *)malloc(sizeof(struct matching_line) * bsize);
624
 
    if (matches == NULL)
625
 
        goto error;
 
630
    if (bsize > 0) {
 
631
        matches = (struct matching_line *)guarded_malloc(sizeof(struct matching_line) * bsize);
 
632
        if (matches == NULL)
 
633
            goto error;
626
634
 
627
 
    backpointers = (Py_ssize_t *)malloc(sizeof(Py_ssize_t) * bsize * 4);
628
 
    if (backpointers == NULL)
629
 
        goto error;
 
635
        backpointers = (Py_ssize_t *)guarded_malloc(sizeof(Py_ssize_t) * bsize * 4);
 
636
        if (backpointers == NULL)
 
637
            goto error;
 
638
    }
630
639
 
631
640
    nmatches = unique_lcs(matches, &hashtable, backpointers, a, b, 0, 0, asize, bsize);
632
641
 
692
701
        goto error;
693
702
 
694
703
    matches.count = 0;
695
 
    matches.matches = (struct matching_block *)malloc(sizeof(struct matching_block) * bsize);
696
 
    if (matches.matches == NULL)
697
 
        goto error;
698
 
 
699
 
    backpointers = (Py_ssize_t *)malloc(sizeof(Py_ssize_t) * bsize * 4);
700
 
    if (backpointers == NULL)
701
 
        goto error;
 
704
 
 
705
    if (bsize > 0) {
 
706
        matches.matches = (struct matching_block *)guarded_malloc(sizeof(struct matching_block) * bsize);
 
707
        if (matches.matches == NULL)
 
708
            goto error;
 
709
 
 
710
        backpointers = (Py_ssize_t *)guarded_malloc(sizeof(Py_ssize_t) * bsize * 4);
 
711
        if (backpointers == NULL)
 
712
            goto error;
 
713
    } else {
 
714
        matches.matches = NULL;
 
715
        backpointers = NULL;
 
716
    }
702
717
 
703
718
    res = recurse_matches(&matches, &hashtable, backpointers,
704
719
                          a, b, alo, blo, ahi, bhi, maxrecursion);
765
780
            return NULL;
766
781
        }
767
782
 
768
 
        self->backpointers = (Py_ssize_t *)malloc(sizeof(Py_ssize_t) * self->bsize * 4);
769
 
        if (self->backpointers == NULL) {
770
 
            Py_DECREF(self);
771
 
            PyErr_NoMemory();
772
 
            return NULL;
 
783
        if (self->bsize > 0) {
 
784
            self->backpointers = (Py_ssize_t *)guarded_malloc(sizeof(Py_ssize_t) * self->bsize * 4);
 
785
            if (self->backpointers == NULL) {
 
786
                Py_DECREF(self);
 
787
                PyErr_NoMemory();
 
788
                return NULL;
 
789
            }
 
790
        } else {
 
791
            self->backpointers = NULL;
773
792
        }
774
793
 
775
794
    }
812
831
    struct matching_blocks matches;
813
832
 
814
833
    matches.count = 0;
815
 
    matches.matches = (struct matching_block *)malloc(sizeof(struct matching_block) * self->bsize);
816
 
    if (matches.matches == NULL)
817
 
        return PyErr_NoMemory();
 
834
    if (self->bsize > 0) {
 
835
        matches.matches = (struct matching_block *)
 
836
            guarded_malloc(sizeof(struct matching_block) * self->bsize);
 
837
        if (matches.matches == NULL)
 
838
            return PyErr_NoMemory();
 
839
    } else
 
840
        matches.matches = NULL;
818
841
 
819
842
    res = recurse_matches(&matches, &self->hashtable, self->backpointers,
820
843
                          self->a, self->b, 0, 0,
900
923
    struct matching_blocks matches;
901
924
 
902
925
    matches.count = 0;
903
 
    matches.matches = (struct matching_block *)malloc(sizeof(struct matching_block) * (self->bsize + 1));
 
926
    matches.matches = (struct matching_block *)guarded_malloc(sizeof(struct matching_block) * (self->bsize + 1));
904
927
    if (matches.matches == NULL)
905
928
        return PyErr_NoMemory();
906
929
 
1013
1036
        return NULL;
1014
1037
 
1015
1038
    matches.count = 0;
1016
 
    matches.matches = (struct matching_block *)malloc(sizeof(struct matching_block) * (self->bsize + 1));
 
1039
    matches.matches = (struct matching_block *)guarded_malloc(sizeof(struct matching_block) * (self->bsize + 1));
1017
1040
    if (matches.matches == NULL)
1018
1041
        return PyErr_NoMemory();
1019
1042
 
1031
1054
    matches.count++;
1032
1055
 
1033
1056
    ncodes = 0;
1034
 
    codes = (struct opcode *)malloc(sizeof(struct opcode) * matches.count * 2);
 
1057
    codes = (struct opcode *)guarded_malloc(sizeof(struct opcode) * matches.count * 2);
1035
1058
    if (codes == NULL) {
1036
1059
        free(matches.matches);
1037
1060
        return PyErr_NoMemory();
1252
1275
    PyModule_AddObject(m, "PatienceSequenceMatcher_c",
1253
1276
                       (PyObject *)&PatienceSequenceMatcherType);
1254
1277
}
 
1278
 
 
1279
 
 
1280
/* vim: sw=4 et 
 
1281
 */