Mercurial > hg
annotate mercurial/pure/parsers.py @ 39217:5961517fd2a8
index: rename _fix_index() since it no longer fixes the index
Since c0d411ea6639 (index: drop support for negative indexes into the
index, 2018-07-20), it always returns the input (unless it raises).
Differential Revision: https://phab.mercurial-scm.org/D4334
author | Martin von Zweigbergk <martinvonz@google.com> |
---|---|
date | Sun, 19 Aug 2018 22:30:32 -0700 |
parents | ec6d5a9d1631 |
children | 2372284d9457 |
rev | line source |
---|---|
7700
f410c552fa15
pure Python implementation of parsers.c
Martin Geisler <mg@daimi.au.dk>
parents:
diff
changeset
|
1 # parsers.py - Python implementation of parsers.c |
f410c552fa15
pure Python implementation of parsers.c
Martin Geisler <mg@daimi.au.dk>
parents:
diff
changeset
|
2 # |
f410c552fa15
pure Python implementation of parsers.c
Martin Geisler <mg@daimi.au.dk>
parents:
diff
changeset
|
3 # Copyright 2009 Matt Mackall <mpm@selenic.com> and others |
f410c552fa15
pure Python implementation of parsers.c
Martin Geisler <mg@daimi.au.dk>
parents:
diff
changeset
|
4 # |
8225
46293a0c7e9f
updated license to be explicit about GPL version 2
Martin Geisler <mg@lazybytes.net>
parents:
7945
diff
changeset
|
5 # This software may be used and distributed according to the terms of the |
10263 | 6 # GNU General Public License version 2 or any later version. |
7700
f410c552fa15
pure Python implementation of parsers.c
Martin Geisler <mg@daimi.au.dk>
parents:
diff
changeset
|
7 |
27339
6ab8c6511a6a
parsers: use absolute_import
Gregory Szorc <gregory.szorc@gmail.com>
parents:
24634
diff
changeset
|
8 from __future__ import absolute_import |
6ab8c6511a6a
parsers: use absolute_import
Gregory Szorc <gregory.szorc@gmail.com>
parents:
24634
diff
changeset
|
9 |
6ab8c6511a6a
parsers: use absolute_import
Gregory Szorc <gregory.szorc@gmail.com>
parents:
24634
diff
changeset
|
10 import struct |
6ab8c6511a6a
parsers: use absolute_import
Gregory Szorc <gregory.szorc@gmail.com>
parents:
24634
diff
changeset
|
11 import zlib |
6ab8c6511a6a
parsers: use absolute_import
Gregory Szorc <gregory.szorc@gmail.com>
parents:
24634
diff
changeset
|
12 |
32372
df448de7cf3b
parsers: switch to policy importer
Yuya Nishihara <yuya@tcha.org>
parents:
31529
diff
changeset
|
13 from ..node import nullid |
df448de7cf3b
parsers: switch to policy importer
Yuya Nishihara <yuya@tcha.org>
parents:
31529
diff
changeset
|
14 from .. import pycompat |
36958
644a02f6b34f
util: prefer "bytesio" to "stringio"
Gregory Szorc <gregory.szorc@gmail.com>
parents:
34331
diff
changeset
|
15 stringio = pycompat.bytesio |
7700
f410c552fa15
pure Python implementation of parsers.c
Martin Geisler <mg@daimi.au.dk>
parents:
diff
changeset
|
16 |
31220
37596c980662
parsers: alias long to int on Python 3
Pulkit Goyal <7895pulkit@gmail.com>
parents:
29133
diff
changeset
|
17 |
7700
f410c552fa15
pure Python implementation of parsers.c
Martin Geisler <mg@daimi.au.dk>
parents:
diff
changeset
|
18 _pack = struct.pack |
f410c552fa15
pure Python implementation of parsers.c
Martin Geisler <mg@daimi.au.dk>
parents:
diff
changeset
|
19 _unpack = struct.unpack |
f410c552fa15
pure Python implementation of parsers.c
Martin Geisler <mg@daimi.au.dk>
parents:
diff
changeset
|
20 _compress = zlib.compress |
f410c552fa15
pure Python implementation of parsers.c
Martin Geisler <mg@daimi.au.dk>
parents:
diff
changeset
|
21 _decompress = zlib.decompress |
f410c552fa15
pure Python implementation of parsers.c
Martin Geisler <mg@daimi.au.dk>
parents:
diff
changeset
|
22 |
21809
e250b8300e6e
parsers: inline fields of dirstate values in C version
Siddharth Agarwal <sid0@fb.com>
parents:
19652
diff
changeset
|
23 # Some code below makes tuples directly because it's more convenient. However, |
e250b8300e6e
parsers: inline fields of dirstate values in C version
Siddharth Agarwal <sid0@fb.com>
parents:
19652
diff
changeset
|
24 # code outside this module should always use dirstatetuple. |
e250b8300e6e
parsers: inline fields of dirstate values in C version
Siddharth Agarwal <sid0@fb.com>
parents:
19652
diff
changeset
|
25 def dirstatetuple(*x): |
e250b8300e6e
parsers: inline fields of dirstate values in C version
Siddharth Agarwal <sid0@fb.com>
parents:
19652
diff
changeset
|
26 # x is a tuple |
e250b8300e6e
parsers: inline fields of dirstate values in C version
Siddharth Agarwal <sid0@fb.com>
parents:
19652
diff
changeset
|
27 return x |
e250b8300e6e
parsers: inline fields of dirstate values in C version
Siddharth Agarwal <sid0@fb.com>
parents:
19652
diff
changeset
|
28 |
29133
255274719dc1
pure: write a really lazy version of pure indexObject
Maciej Fijalkowski <fijall@gmail.com>
parents:
28861
diff
changeset
|
29 indexformatng = ">Qiiiiii20s12x" |
255274719dc1
pure: write a really lazy version of pure indexObject
Maciej Fijalkowski <fijall@gmail.com>
parents:
28861
diff
changeset
|
30 indexfirst = struct.calcsize('Q') |
255274719dc1
pure: write a really lazy version of pure indexObject
Maciej Fijalkowski <fijall@gmail.com>
parents:
28861
diff
changeset
|
31 sizeint = struct.calcsize('i') |
255274719dc1
pure: write a really lazy version of pure indexObject
Maciej Fijalkowski <fijall@gmail.com>
parents:
28861
diff
changeset
|
32 indexsize = struct.calcsize(indexformatng) |
255274719dc1
pure: write a really lazy version of pure indexObject
Maciej Fijalkowski <fijall@gmail.com>
parents:
28861
diff
changeset
|
33 |
255274719dc1
pure: write a really lazy version of pure indexObject
Maciej Fijalkowski <fijall@gmail.com>
parents:
28861
diff
changeset
|
34 def gettype(q): |
255274719dc1
pure: write a really lazy version of pure indexObject
Maciej Fijalkowski <fijall@gmail.com>
parents:
28861
diff
changeset
|
35 return int(q & 0xFFFF) |
7945
94d7e14cfa42
pure/parsers: fix circular imports, import mercurial modules properly
Matt Mackall <mpm@selenic.com>
parents:
7873
diff
changeset
|
36 |
29133
255274719dc1
pure: write a really lazy version of pure indexObject
Maciej Fijalkowski <fijall@gmail.com>
parents:
28861
diff
changeset
|
37 def offset_type(offset, type): |
31529
61ff3852f6ed
pure: use int instead of long
Martin von Zweigbergk <martinvonz@google.com>
parents:
31220
diff
changeset
|
38 return int(int(offset) << 16 | type) |
29133
255274719dc1
pure: write a really lazy version of pure indexObject
Maciej Fijalkowski <fijall@gmail.com>
parents:
28861
diff
changeset
|
39 |
255274719dc1
pure: write a really lazy version of pure indexObject
Maciej Fijalkowski <fijall@gmail.com>
parents:
28861
diff
changeset
|
40 class BaseIndexObject(object): |
255274719dc1
pure: write a really lazy version of pure indexObject
Maciej Fijalkowski <fijall@gmail.com>
parents:
28861
diff
changeset
|
41 def __len__(self): |
38851
781b2720d2ac
index: don't include nullid in len()
Martin von Zweigbergk <martinvonz@google.com>
parents:
38850
diff
changeset
|
42 return self._lgt + len(self._extra) |
29133
255274719dc1
pure: write a really lazy version of pure indexObject
Maciej Fijalkowski <fijall@gmail.com>
parents:
28861
diff
changeset
|
43 |
38850
6104b203bec8
index: replace insert(-1, e) method by append(e) method
Martin von Zweigbergk <martinvonz@google.com>
parents:
38848
diff
changeset
|
44 def append(self, tup): |
29133
255274719dc1
pure: write a really lazy version of pure indexObject
Maciej Fijalkowski <fijall@gmail.com>
parents:
28861
diff
changeset
|
45 self._extra.append(tup) |
7945
94d7e14cfa42
pure/parsers: fix circular imports, import mercurial modules properly
Matt Mackall <mpm@selenic.com>
parents:
7873
diff
changeset
|
46 |
39217
5961517fd2a8
index: rename _fix_index() since it no longer fixes the index
Martin von Zweigbergk <martinvonz@google.com>
parents:
39216
diff
changeset
|
47 def _check_index(self, i): |
29133
255274719dc1
pure: write a really lazy version of pure indexObject
Maciej Fijalkowski <fijall@gmail.com>
parents:
28861
diff
changeset
|
48 if not isinstance(i, int): |
255274719dc1
pure: write a really lazy version of pure indexObject
Maciej Fijalkowski <fijall@gmail.com>
parents:
28861
diff
changeset
|
49 raise TypeError("expecting int indexes") |
39216
ec6d5a9d1631
index: don't include nullid in boundary check in pure code
Martin von Zweigbergk <martinvonz@google.com>
parents:
39047
diff
changeset
|
50 if i < 0 or i >= len(self): |
29133
255274719dc1
pure: write a really lazy version of pure indexObject
Maciej Fijalkowski <fijall@gmail.com>
parents:
28861
diff
changeset
|
51 raise IndexError |
7945
94d7e14cfa42
pure/parsers: fix circular imports, import mercurial modules properly
Matt Mackall <mpm@selenic.com>
parents:
7873
diff
changeset
|
52 |
29133
255274719dc1
pure: write a really lazy version of pure indexObject
Maciej Fijalkowski <fijall@gmail.com>
parents:
28861
diff
changeset
|
53 def __getitem__(self, i): |
39047
a1f934573c0b
parsers: adjust pure-python version to mimic a3dacabd476b
Augie Fackler <augie@google.com>
parents:
38851
diff
changeset
|
54 if i == -1: |
38847
f3d394ea17db
index: handle index[-1] as nullid more explicitly
Martin von Zweigbergk <martinvonz@google.com>
parents:
36958
diff
changeset
|
55 return (0, 0, 0, -1, -1, -1, -1, nullid) |
39217
5961517fd2a8
index: rename _fix_index() since it no longer fixes the index
Martin von Zweigbergk <martinvonz@google.com>
parents:
39216
diff
changeset
|
56 self._check_index(i) |
29133
255274719dc1
pure: write a really lazy version of pure indexObject
Maciej Fijalkowski <fijall@gmail.com>
parents:
28861
diff
changeset
|
57 if i >= self._lgt: |
255274719dc1
pure: write a really lazy version of pure indexObject
Maciej Fijalkowski <fijall@gmail.com>
parents:
28861
diff
changeset
|
58 return self._extra[i - self._lgt] |
255274719dc1
pure: write a really lazy version of pure indexObject
Maciej Fijalkowski <fijall@gmail.com>
parents:
28861
diff
changeset
|
59 index = self._calculate_index(i) |
255274719dc1
pure: write a really lazy version of pure indexObject
Maciej Fijalkowski <fijall@gmail.com>
parents:
28861
diff
changeset
|
60 r = struct.unpack(indexformatng, self._data[index:index + indexsize]) |
255274719dc1
pure: write a really lazy version of pure indexObject
Maciej Fijalkowski <fijall@gmail.com>
parents:
28861
diff
changeset
|
61 if i == 0: |
255274719dc1
pure: write a really lazy version of pure indexObject
Maciej Fijalkowski <fijall@gmail.com>
parents:
28861
diff
changeset
|
62 e = list(r) |
255274719dc1
pure: write a really lazy version of pure indexObject
Maciej Fijalkowski <fijall@gmail.com>
parents:
28861
diff
changeset
|
63 type = gettype(e[0]) |
255274719dc1
pure: write a really lazy version of pure indexObject
Maciej Fijalkowski <fijall@gmail.com>
parents:
28861
diff
changeset
|
64 e[0] = offset_type(0, type) |
255274719dc1
pure: write a really lazy version of pure indexObject
Maciej Fijalkowski <fijall@gmail.com>
parents:
28861
diff
changeset
|
65 return tuple(e) |
255274719dc1
pure: write a really lazy version of pure indexObject
Maciej Fijalkowski <fijall@gmail.com>
parents:
28861
diff
changeset
|
66 return r |
255274719dc1
pure: write a really lazy version of pure indexObject
Maciej Fijalkowski <fijall@gmail.com>
parents:
28861
diff
changeset
|
67 |
255274719dc1
pure: write a really lazy version of pure indexObject
Maciej Fijalkowski <fijall@gmail.com>
parents:
28861
diff
changeset
|
68 class IndexObject(BaseIndexObject): |
255274719dc1
pure: write a really lazy version of pure indexObject
Maciej Fijalkowski <fijall@gmail.com>
parents:
28861
diff
changeset
|
69 def __init__(self, data): |
255274719dc1
pure: write a really lazy version of pure indexObject
Maciej Fijalkowski <fijall@gmail.com>
parents:
28861
diff
changeset
|
70 assert len(data) % indexsize == 0 |
255274719dc1
pure: write a really lazy version of pure indexObject
Maciej Fijalkowski <fijall@gmail.com>
parents:
28861
diff
changeset
|
71 self._data = data |
255274719dc1
pure: write a really lazy version of pure indexObject
Maciej Fijalkowski <fijall@gmail.com>
parents:
28861
diff
changeset
|
72 self._lgt = len(data) // indexsize |
255274719dc1
pure: write a really lazy version of pure indexObject
Maciej Fijalkowski <fijall@gmail.com>
parents:
28861
diff
changeset
|
73 self._extra = [] |
255274719dc1
pure: write a really lazy version of pure indexObject
Maciej Fijalkowski <fijall@gmail.com>
parents:
28861
diff
changeset
|
74 |
255274719dc1
pure: write a really lazy version of pure indexObject
Maciej Fijalkowski <fijall@gmail.com>
parents:
28861
diff
changeset
|
75 def _calculate_index(self, i): |
255274719dc1
pure: write a really lazy version of pure indexObject
Maciej Fijalkowski <fijall@gmail.com>
parents:
28861
diff
changeset
|
76 return i * indexsize |
13253 | 77 |
29133
255274719dc1
pure: write a really lazy version of pure indexObject
Maciej Fijalkowski <fijall@gmail.com>
parents:
28861
diff
changeset
|
78 def __delitem__(self, i): |
34331
531332502568
style: always use `x is not None` instead of `not x is None`
Alex Gaynor <agaynor@mozilla.com>
parents:
32372
diff
changeset
|
79 if not isinstance(i, slice) or not i.stop == -1 or i.step is not None: |
29133
255274719dc1
pure: write a really lazy version of pure indexObject
Maciej Fijalkowski <fijall@gmail.com>
parents:
28861
diff
changeset
|
80 raise ValueError("deleting slices only supports a:-1 with step 1") |
39217
5961517fd2a8
index: rename _fix_index() since it no longer fixes the index
Martin von Zweigbergk <martinvonz@google.com>
parents:
39216
diff
changeset
|
81 i = i.start |
5961517fd2a8
index: rename _fix_index() since it no longer fixes the index
Martin von Zweigbergk <martinvonz@google.com>
parents:
39216
diff
changeset
|
82 self._check_index(i) |
29133
255274719dc1
pure: write a really lazy version of pure indexObject
Maciej Fijalkowski <fijall@gmail.com>
parents:
28861
diff
changeset
|
83 if i < self._lgt: |
255274719dc1
pure: write a really lazy version of pure indexObject
Maciej Fijalkowski <fijall@gmail.com>
parents:
28861
diff
changeset
|
84 self._data = self._data[:i * indexsize] |
255274719dc1
pure: write a really lazy version of pure indexObject
Maciej Fijalkowski <fijall@gmail.com>
parents:
28861
diff
changeset
|
85 self._lgt = i |
255274719dc1
pure: write a really lazy version of pure indexObject
Maciej Fijalkowski <fijall@gmail.com>
parents:
28861
diff
changeset
|
86 self._extra = [] |
255274719dc1
pure: write a really lazy version of pure indexObject
Maciej Fijalkowski <fijall@gmail.com>
parents:
28861
diff
changeset
|
87 else: |
255274719dc1
pure: write a really lazy version of pure indexObject
Maciej Fijalkowski <fijall@gmail.com>
parents:
28861
diff
changeset
|
88 self._extra = self._extra[:i - self._lgt] |
255274719dc1
pure: write a really lazy version of pure indexObject
Maciej Fijalkowski <fijall@gmail.com>
parents:
28861
diff
changeset
|
89 |
255274719dc1
pure: write a really lazy version of pure indexObject
Maciej Fijalkowski <fijall@gmail.com>
parents:
28861
diff
changeset
|
90 class InlinedIndexObject(BaseIndexObject): |
255274719dc1
pure: write a really lazy version of pure indexObject
Maciej Fijalkowski <fijall@gmail.com>
parents:
28861
diff
changeset
|
91 def __init__(self, data, inline=0): |
255274719dc1
pure: write a really lazy version of pure indexObject
Maciej Fijalkowski <fijall@gmail.com>
parents:
28861
diff
changeset
|
92 self._data = data |
255274719dc1
pure: write a really lazy version of pure indexObject
Maciej Fijalkowski <fijall@gmail.com>
parents:
28861
diff
changeset
|
93 self._lgt = self._inline_scan(None) |
255274719dc1
pure: write a really lazy version of pure indexObject
Maciej Fijalkowski <fijall@gmail.com>
parents:
28861
diff
changeset
|
94 self._inline_scan(self._lgt) |
255274719dc1
pure: write a really lazy version of pure indexObject
Maciej Fijalkowski <fijall@gmail.com>
parents:
28861
diff
changeset
|
95 self._extra = [] |
7700
f410c552fa15
pure Python implementation of parsers.c
Martin Geisler <mg@daimi.au.dk>
parents:
diff
changeset
|
96 |
29133
255274719dc1
pure: write a really lazy version of pure indexObject
Maciej Fijalkowski <fijall@gmail.com>
parents:
28861
diff
changeset
|
97 def _inline_scan(self, lgt): |
255274719dc1
pure: write a really lazy version of pure indexObject
Maciej Fijalkowski <fijall@gmail.com>
parents:
28861
diff
changeset
|
98 off = 0 |
255274719dc1
pure: write a really lazy version of pure indexObject
Maciej Fijalkowski <fijall@gmail.com>
parents:
28861
diff
changeset
|
99 if lgt is not None: |
255274719dc1
pure: write a really lazy version of pure indexObject
Maciej Fijalkowski <fijall@gmail.com>
parents:
28861
diff
changeset
|
100 self._offsets = [0] * lgt |
255274719dc1
pure: write a really lazy version of pure indexObject
Maciej Fijalkowski <fijall@gmail.com>
parents:
28861
diff
changeset
|
101 count = 0 |
255274719dc1
pure: write a really lazy version of pure indexObject
Maciej Fijalkowski <fijall@gmail.com>
parents:
28861
diff
changeset
|
102 while off <= len(self._data) - indexsize: |
255274719dc1
pure: write a really lazy version of pure indexObject
Maciej Fijalkowski <fijall@gmail.com>
parents:
28861
diff
changeset
|
103 s, = struct.unpack('>i', |
255274719dc1
pure: write a really lazy version of pure indexObject
Maciej Fijalkowski <fijall@gmail.com>
parents:
28861
diff
changeset
|
104 self._data[off + indexfirst:off + sizeint + indexfirst]) |
255274719dc1
pure: write a really lazy version of pure indexObject
Maciej Fijalkowski <fijall@gmail.com>
parents:
28861
diff
changeset
|
105 if lgt is not None: |
255274719dc1
pure: write a really lazy version of pure indexObject
Maciej Fijalkowski <fijall@gmail.com>
parents:
28861
diff
changeset
|
106 self._offsets[count] = off |
255274719dc1
pure: write a really lazy version of pure indexObject
Maciej Fijalkowski <fijall@gmail.com>
parents:
28861
diff
changeset
|
107 count += 1 |
255274719dc1
pure: write a really lazy version of pure indexObject
Maciej Fijalkowski <fijall@gmail.com>
parents:
28861
diff
changeset
|
108 off += indexsize + s |
255274719dc1
pure: write a really lazy version of pure indexObject
Maciej Fijalkowski <fijall@gmail.com>
parents:
28861
diff
changeset
|
109 if off != len(self._data): |
255274719dc1
pure: write a really lazy version of pure indexObject
Maciej Fijalkowski <fijall@gmail.com>
parents:
28861
diff
changeset
|
110 raise ValueError("corrupted data") |
255274719dc1
pure: write a really lazy version of pure indexObject
Maciej Fijalkowski <fijall@gmail.com>
parents:
28861
diff
changeset
|
111 return count |
14421
639f26cab2f5
pure parsers: properly detect corrupt index files
Augie Fackler <durin42@gmail.com>
parents:
14064
diff
changeset
|
112 |
29133
255274719dc1
pure: write a really lazy version of pure indexObject
Maciej Fijalkowski <fijall@gmail.com>
parents:
28861
diff
changeset
|
113 def __delitem__(self, i): |
34331
531332502568
style: always use `x is not None` instead of `not x is None`
Alex Gaynor <agaynor@mozilla.com>
parents:
32372
diff
changeset
|
114 if not isinstance(i, slice) or not i.stop == -1 or i.step is not None: |
29133
255274719dc1
pure: write a really lazy version of pure indexObject
Maciej Fijalkowski <fijall@gmail.com>
parents:
28861
diff
changeset
|
115 raise ValueError("deleting slices only supports a:-1 with step 1") |
39217
5961517fd2a8
index: rename _fix_index() since it no longer fixes the index
Martin von Zweigbergk <martinvonz@google.com>
parents:
39216
diff
changeset
|
116 i = i.start |
5961517fd2a8
index: rename _fix_index() since it no longer fixes the index
Martin von Zweigbergk <martinvonz@google.com>
parents:
39216
diff
changeset
|
117 self._check_index(i) |
29133
255274719dc1
pure: write a really lazy version of pure indexObject
Maciej Fijalkowski <fijall@gmail.com>
parents:
28861
diff
changeset
|
118 if i < self._lgt: |
255274719dc1
pure: write a really lazy version of pure indexObject
Maciej Fijalkowski <fijall@gmail.com>
parents:
28861
diff
changeset
|
119 self._offsets = self._offsets[:i] |
255274719dc1
pure: write a really lazy version of pure indexObject
Maciej Fijalkowski <fijall@gmail.com>
parents:
28861
diff
changeset
|
120 self._lgt = i |
255274719dc1
pure: write a really lazy version of pure indexObject
Maciej Fijalkowski <fijall@gmail.com>
parents:
28861
diff
changeset
|
121 self._extra = [] |
255274719dc1
pure: write a really lazy version of pure indexObject
Maciej Fijalkowski <fijall@gmail.com>
parents:
28861
diff
changeset
|
122 else: |
255274719dc1
pure: write a really lazy version of pure indexObject
Maciej Fijalkowski <fijall@gmail.com>
parents:
28861
diff
changeset
|
123 self._extra = self._extra[:i - self._lgt] |
7700
f410c552fa15
pure Python implementation of parsers.c
Martin Geisler <mg@daimi.au.dk>
parents:
diff
changeset
|
124 |
29133
255274719dc1
pure: write a really lazy version of pure indexObject
Maciej Fijalkowski <fijall@gmail.com>
parents:
28861
diff
changeset
|
125 def _calculate_index(self, i): |
255274719dc1
pure: write a really lazy version of pure indexObject
Maciej Fijalkowski <fijall@gmail.com>
parents:
28861
diff
changeset
|
126 return self._offsets[i] |
7700
f410c552fa15
pure Python implementation of parsers.c
Martin Geisler <mg@daimi.au.dk>
parents:
diff
changeset
|
127 |
29133
255274719dc1
pure: write a really lazy version of pure indexObject
Maciej Fijalkowski <fijall@gmail.com>
parents:
28861
diff
changeset
|
128 def parse_index2(data, inline): |
255274719dc1
pure: write a really lazy version of pure indexObject
Maciej Fijalkowski <fijall@gmail.com>
parents:
28861
diff
changeset
|
129 if not inline: |
255274719dc1
pure: write a really lazy version of pure indexObject
Maciej Fijalkowski <fijall@gmail.com>
parents:
28861
diff
changeset
|
130 return IndexObject(data), None |
255274719dc1
pure: write a really lazy version of pure indexObject
Maciej Fijalkowski <fijall@gmail.com>
parents:
28861
diff
changeset
|
131 return InlinedIndexObject(data, inline), (0, data) |
7700
f410c552fa15
pure Python implementation of parsers.c
Martin Geisler <mg@daimi.au.dk>
parents:
diff
changeset
|
132 |
f410c552fa15
pure Python implementation of parsers.c
Martin Geisler <mg@daimi.au.dk>
parents:
diff
changeset
|
133 def parse_dirstate(dmap, copymap, st): |
f410c552fa15
pure Python implementation of parsers.c
Martin Geisler <mg@daimi.au.dk>
parents:
diff
changeset
|
134 parents = [st[:20], st[20: 40]] |
17425
e95ec38f86b0
fix wording and not-completely-trivial spelling errors and bad docstrings
Mads Kiilerich <mads@kiilerich.com>
parents:
14995
diff
changeset
|
135 # dereference fields so they will be local in loop |
7945
94d7e14cfa42
pure/parsers: fix circular imports, import mercurial modules properly
Matt Mackall <mpm@selenic.com>
parents:
7873
diff
changeset
|
136 format = ">cllll" |
94d7e14cfa42
pure/parsers: fix circular imports, import mercurial modules properly
Matt Mackall <mpm@selenic.com>
parents:
7873
diff
changeset
|
137 e_size = struct.calcsize(format) |
7700
f410c552fa15
pure Python implementation of parsers.c
Martin Geisler <mg@daimi.au.dk>
parents:
diff
changeset
|
138 pos1 = 40 |
f410c552fa15
pure Python implementation of parsers.c
Martin Geisler <mg@daimi.au.dk>
parents:
diff
changeset
|
139 l = len(st) |
f410c552fa15
pure Python implementation of parsers.c
Martin Geisler <mg@daimi.au.dk>
parents:
diff
changeset
|
140 |
f410c552fa15
pure Python implementation of parsers.c
Martin Geisler <mg@daimi.au.dk>
parents:
diff
changeset
|
141 # the inner loop |
f410c552fa15
pure Python implementation of parsers.c
Martin Geisler <mg@daimi.au.dk>
parents:
diff
changeset
|
142 while pos1 < l: |
f410c552fa15
pure Python implementation of parsers.c
Martin Geisler <mg@daimi.au.dk>
parents:
diff
changeset
|
143 pos2 = pos1 + e_size |
f410c552fa15
pure Python implementation of parsers.c
Martin Geisler <mg@daimi.au.dk>
parents:
diff
changeset
|
144 e = _unpack(">cllll", st[pos1:pos2]) # a literal here is faster |
f410c552fa15
pure Python implementation of parsers.c
Martin Geisler <mg@daimi.au.dk>
parents:
diff
changeset
|
145 pos1 = pos2 + e[4] |
f410c552fa15
pure Python implementation of parsers.c
Martin Geisler <mg@daimi.au.dk>
parents:
diff
changeset
|
146 f = st[pos2:pos1] |
f410c552fa15
pure Python implementation of parsers.c
Martin Geisler <mg@daimi.au.dk>
parents:
diff
changeset
|
147 if '\0' in f: |
f410c552fa15
pure Python implementation of parsers.c
Martin Geisler <mg@daimi.au.dk>
parents:
diff
changeset
|
148 f, c = f.split('\0') |
f410c552fa15
pure Python implementation of parsers.c
Martin Geisler <mg@daimi.au.dk>
parents:
diff
changeset
|
149 copymap[f] = c |
f410c552fa15
pure Python implementation of parsers.c
Martin Geisler <mg@daimi.au.dk>
parents:
diff
changeset
|
150 dmap[f] = e[:4] |
f410c552fa15
pure Python implementation of parsers.c
Martin Geisler <mg@daimi.au.dk>
parents:
diff
changeset
|
151 return parents |
18567
194e63c1ccb9
dirstate: move pure python dirstate packing to pure/parsers.py
Siddharth Agarwal <sid0@fb.com>
parents:
17425
diff
changeset
|
152 |
194e63c1ccb9
dirstate: move pure python dirstate packing to pure/parsers.py
Siddharth Agarwal <sid0@fb.com>
parents:
17425
diff
changeset
|
153 def pack_dirstate(dmap, copymap, pl, now): |
194e63c1ccb9
dirstate: move pure python dirstate packing to pure/parsers.py
Siddharth Agarwal <sid0@fb.com>
parents:
17425
diff
changeset
|
154 now = int(now) |
28861
86db5cb55d46
pycompat: switch to util.stringio for py3 compat
timeless <timeless@mozdev.org>
parents:
27339
diff
changeset
|
155 cs = stringio() |
18567
194e63c1ccb9
dirstate: move pure python dirstate packing to pure/parsers.py
Siddharth Agarwal <sid0@fb.com>
parents:
17425
diff
changeset
|
156 write = cs.write |
194e63c1ccb9
dirstate: move pure python dirstate packing to pure/parsers.py
Siddharth Agarwal <sid0@fb.com>
parents:
17425
diff
changeset
|
157 write("".join(pl)) |
194e63c1ccb9
dirstate: move pure python dirstate packing to pure/parsers.py
Siddharth Agarwal <sid0@fb.com>
parents:
17425
diff
changeset
|
158 for f, e in dmap.iteritems(): |
194e63c1ccb9
dirstate: move pure python dirstate packing to pure/parsers.py
Siddharth Agarwal <sid0@fb.com>
parents:
17425
diff
changeset
|
159 if e[0] == 'n' and e[3] == now: |
194e63c1ccb9
dirstate: move pure python dirstate packing to pure/parsers.py
Siddharth Agarwal <sid0@fb.com>
parents:
17425
diff
changeset
|
160 # The file was last modified "simultaneously" with the current |
194e63c1ccb9
dirstate: move pure python dirstate packing to pure/parsers.py
Siddharth Agarwal <sid0@fb.com>
parents:
17425
diff
changeset
|
161 # write to dirstate (i.e. within the same second for file- |
194e63c1ccb9
dirstate: move pure python dirstate packing to pure/parsers.py
Siddharth Agarwal <sid0@fb.com>
parents:
17425
diff
changeset
|
162 # systems with a granularity of 1 sec). This commonly happens |
194e63c1ccb9
dirstate: move pure python dirstate packing to pure/parsers.py
Siddharth Agarwal <sid0@fb.com>
parents:
17425
diff
changeset
|
163 # for at least a couple of files on 'update'. |
194e63c1ccb9
dirstate: move pure python dirstate packing to pure/parsers.py
Siddharth Agarwal <sid0@fb.com>
parents:
17425
diff
changeset
|
164 # The user could change the file without changing its size |
19652
187bf2dde7c1
pack_dirstate: only invalidate mtime for files written in the last second
Siddharth Agarwal <sid0@fb.com>
parents:
18567
diff
changeset
|
165 # within the same second. Invalidate the file's mtime in |
18567
194e63c1ccb9
dirstate: move pure python dirstate packing to pure/parsers.py
Siddharth Agarwal <sid0@fb.com>
parents:
17425
diff
changeset
|
166 # dirstate, forcing future 'status' calls to compare the |
19652
187bf2dde7c1
pack_dirstate: only invalidate mtime for files written in the last second
Siddharth Agarwal <sid0@fb.com>
parents:
18567
diff
changeset
|
167 # contents of the file if the size is the same. This prevents |
187bf2dde7c1
pack_dirstate: only invalidate mtime for files written in the last second
Siddharth Agarwal <sid0@fb.com>
parents:
18567
diff
changeset
|
168 # mistakenly treating such files as clean. |
21809
e250b8300e6e
parsers: inline fields of dirstate values in C version
Siddharth Agarwal <sid0@fb.com>
parents:
19652
diff
changeset
|
169 e = dirstatetuple(e[0], e[1], e[2], -1) |
18567
194e63c1ccb9
dirstate: move pure python dirstate packing to pure/parsers.py
Siddharth Agarwal <sid0@fb.com>
parents:
17425
diff
changeset
|
170 dmap[f] = e |
194e63c1ccb9
dirstate: move pure python dirstate packing to pure/parsers.py
Siddharth Agarwal <sid0@fb.com>
parents:
17425
diff
changeset
|
171 |
194e63c1ccb9
dirstate: move pure python dirstate packing to pure/parsers.py
Siddharth Agarwal <sid0@fb.com>
parents:
17425
diff
changeset
|
172 if f in copymap: |
194e63c1ccb9
dirstate: move pure python dirstate packing to pure/parsers.py
Siddharth Agarwal <sid0@fb.com>
parents:
17425
diff
changeset
|
173 f = "%s\0%s" % (f, copymap[f]) |
194e63c1ccb9
dirstate: move pure python dirstate packing to pure/parsers.py
Siddharth Agarwal <sid0@fb.com>
parents:
17425
diff
changeset
|
174 e = _pack(">cllll", e[0], e[1], e[2], e[3], len(f)) |
194e63c1ccb9
dirstate: move pure python dirstate packing to pure/parsers.py
Siddharth Agarwal <sid0@fb.com>
parents:
17425
diff
changeset
|
175 write(e) |
194e63c1ccb9
dirstate: move pure python dirstate packing to pure/parsers.py
Siddharth Agarwal <sid0@fb.com>
parents:
17425
diff
changeset
|
176 write(f) |
194e63c1ccb9
dirstate: move pure python dirstate packing to pure/parsers.py
Siddharth Agarwal <sid0@fb.com>
parents:
17425
diff
changeset
|
177 return cs.getvalue() |