| hg-reviewers |
This allows handling revlog containing more than 33554432 (INT_MAX /
sizeof(nodetreenode)) revisions on x64 platforms.
| Automatic diff as part of commit; lint not applicable. |
| Automatic diff as part of commit; unit tests not applicable. |
| /* | /* | ||||
| parsers.c - efficient content parsing | parsers.c - efficient content parsing | ||||
| Copyright 2008 Matt Mackall <mpm@selenic.com> and others | Copyright 2008 Matt Mackall <mpm@selenic.com> and others | ||||
| This software may be used and distributed according to the terms of | This software may be used and distributed according to the terms of | ||||
| the GNU General Public License, incorporated herein by reference. | the GNU General Public License, incorporated herein by reference. | ||||
| */ | */ | ||||
| #define PY_SSIZE_T_CLEAN | #define PY_SSIZE_T_CLEAN | ||||
| #include <Python.h> | #include <Python.h> | ||||
| #include <assert.h> | #include <assert.h> | ||||
| #include <ctype.h> | #include <ctype.h> | ||||
| #include <limits.h> | #include <limits.h> | ||||
| #include <stddef.h> | #include <stddef.h> | ||||
| #include <stdint.h> | |||||
| #include <stdlib.h> | #include <stdlib.h> | ||||
| #include <string.h> | #include <string.h> | ||||
| #include "bitmanipulation.h" | #include "bitmanipulation.h" | ||||
| #include "charencode.h" | #include "charencode.h" | ||||
| #include "revlog.h" | #include "revlog.h" | ||||
| #include "util.h" | #include "util.h" | ||||
| * Positive value is index of the next node in the trie | * Positive value is index of the next node in the trie | ||||
| * Negative value is a leaf: -(rev + 2) | * Negative value is a leaf: -(rev + 2) | ||||
| * Zero is empty | * Zero is empty | ||||
| */ | */ | ||||
| typedef struct { | typedef struct { | ||||
| indexObject *index; | indexObject *index; | ||||
| nodetreenode *nodes; | nodetreenode *nodes; | ||||
| Py_ssize_t nodelen; | Py_ssize_t nodelen; | ||||
| unsigned length; /* # nodes in use */ | size_t length; /* # nodes in use */ | ||||
| unsigned capacity; /* # nodes allocated */ | size_t capacity; /* # nodes allocated */ | ||||
| int depth; /* maximum depth of tree */ | int depth; /* maximum depth of tree */ | ||||
| int splits; /* # splits performed */ | int splits; /* # splits performed */ | ||||
| } nodetree; | } nodetree; | ||||
| typedef struct { | typedef struct { | ||||
| PyObject_HEAD /* ; */ | PyObject_HEAD /* ; */ | ||||
| nodetree nt; | nodetree nt; | ||||
| } nodetreeObject; | } nodetreeObject; | ||||
| /* | /* | ||||
| } | } | ||||
| /* multiple matches against an ambiguous prefix */ | /* multiple matches against an ambiguous prefix */ | ||||
| return -4; | return -4; | ||||
| } | } | ||||
| static int nt_new(nodetree *self) | static int nt_new(nodetree *self) | ||||
| { | { | ||||
| if (self->length == self->capacity) { | if (self->length == self->capacity) { | ||||
| unsigned newcapacity; | size_t newcapacity; | ||||
| nodetreenode *newnodes; | nodetreenode *newnodes; | ||||
| newcapacity = self->capacity * 2; | newcapacity = self->capacity * 2; | ||||
| if (newcapacity >= INT_MAX / sizeof(nodetreenode)) { | if (newcapacity >= SIZE_MAX / sizeof(nodetreenode)) { | ||||
| PyErr_SetString(PyExc_MemoryError, | PyErr_SetString(PyExc_MemoryError, | ||||
| "overflow in nt_new"); | "overflow in nt_new"); | ||||
| return -1; | return -1; | ||||
| } | } | ||||
| newnodes = | newnodes = | ||||
| realloc(self->nodes, newcapacity * sizeof(nodetreenode)); | realloc(self->nodes, newcapacity * sizeof(nodetreenode)); | ||||
| if (newnodes == NULL) { | if (newnodes == NULL) { | ||||
| PyErr_SetString(PyExc_MemoryError, "out of memory"); | PyErr_SetString(PyExc_MemoryError, "out of memory"); | ||||
| self->index = index; | self->index = index; | ||||
| /* The input capacity is in terms of revisions, while the field is in | /* The input capacity is in terms of revisions, while the field is in | ||||
| * terms of nodetree nodes. */ | * terms of nodetree nodes. */ | ||||
| self->capacity = (capacity < 4 ? 4 : capacity / 2); | self->capacity = (capacity < 4 ? 4 : capacity / 2); | ||||
| self->nodelen = index->nodelen; | self->nodelen = index->nodelen; | ||||
| self->depth = 0; | self->depth = 0; | ||||
| self->splits = 0; | self->splits = 0; | ||||
| if ((size_t)self->capacity > INT_MAX / sizeof(nodetreenode)) { | if (self->capacity > SIZE_MAX / sizeof(nodetreenode)) { | ||||
| PyErr_SetString(PyExc_ValueError, "overflow in init_nt"); | PyErr_SetString(PyExc_ValueError, "overflow in init_nt"); | ||||
| return -1; | return -1; | ||||
| } | } | ||||
| self->nodes = calloc(self->capacity, sizeof(nodetreenode)); | self->nodes = calloc(self->capacity, sizeof(nodetreenode)); | ||||
| if (self->nodes == NULL) { | if (self->nodes == NULL) { | ||||
| PyErr_NoMemory(); | PyErr_NoMemory(); | ||||
| return -1; | return -1; | ||||
| } | } | ||||