~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: 2010-02-11 06:15:33 UTC
mfrom: (5025.1.6 331095-malloc)
Revision ID: pqm@pqm.ubuntu.com-20100211061533-5glf4faoutadhql9

(mbp) avoid malloc(0)

files modified:
NEWS

bzrlib/_patiencediff_c.c

Show diffs side-by-side

added added

removed removed

bzrlib/_patiencediff_c.c

This program is free software; you can redistribute it and/or modify

it under the terms of the GNU General Public License as published by

#define SENTINEL -1

/* malloc returns NULL on some platforms if you try to allocate nothing,

* causing <https://bugs.edge.launchpad.net/bzr/+bug/511267> and

* <https://bugs.edge.launchpad.net/bzr/+bug/331095>. On glibc it passes, but

* let's make it fail to aid testing. */

#define guarded_malloc(x) ( (x) ? malloc(x) : NULL )

enum {

OP_EQUAL = 0,

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

Older »