mirrors/neovim
1
0
Fork 0
mirror of https://github.com/neovim/neovim.git synced 2025-09-28 05:58:33 +00:00
Code Issues Packages Projects Releases Wiki Activity

Merge pull request #34394 from bfredl/shadamem

Browse Source 
refactor(shada): A shada entry is a shada entry
This commit is contained in:
bfredl
2025-08-13 10:19:25 +02:00
committed by GitHub
parent 35be59cc7b 5e1c35509e
commit b70a6f3f3e
1 changed files with 166 additions and 228 deletions
Download Patch File Download Diff File Expand all files Collapse all files

220
src/nvim/shada.c
View File

@@ -230,6 +230,10 @@ enum SRNIFlags {
/// Structure defining a single ShaDa file entry /// Structure defining a single ShaDa file entry
typedef struct { typedef struct {
ShadaEntryType type; ShadaEntryType type;
// If the entry was read from file, string data will be allocated and needs to be freed.
// Entries can also be constructed from nvim internal data structures (like registers)
// and reference their allocated strings. then shada code must not attempt to free these.
bool can_free_entry;
Timestamp timestamp; Timestamp timestamp;
union { union {
Dict header; Dict header;
@@ -279,7 +283,6 @@ typedef struct {
/// One entry in sized linked list /// One entry in sized linked list
typedef struct hm_llist_entry { typedef struct hm_llist_entry {
ShadaEntry data; ///< Entry data. ShadaEntry data; ///< Entry data.
bool can_free_entry; ///< True if data can be freed.
struct hm_llist_entry *next; ///< Pointer to next entry or NULL. struct hm_llist_entry *next; ///< Pointer to next entry or NULL.
struct hm_llist_entry *prev; ///< Pointer to previous entry or NULL. struct hm_llist_entry *prev; ///< Pointer to previous entry or NULL.
} HMLListEntry; } HMLListEntry;
@@ -308,16 +311,10 @@ typedef struct {
uint8_t history_type; uint8_t history_type;
} HistoryMergerState; } HistoryMergerState;
/// ShadaEntry structure that knows whether it should be freed
typedef struct {
ShadaEntry data; ///< ShadaEntry data.
bool can_free_entry; ///< True if entry can be freed.
} PossiblyFreedShadaEntry;
/// Structure that holds one file marks. /// Structure that holds one file marks.
typedef struct { typedef struct {
PossiblyFreedShadaEntry marks[NLOCALMARKS]; ///< All file marks. ShadaEntry marks[NLOCALMARKS]; ///< All file marks.
PossiblyFreedShadaEntry changes[JUMPLISTSIZE]; ///< All file changes. ShadaEntry changes[JUMPLISTSIZE]; ///< All file changes.
size_t changes_size; ///< Number of changes occupied. size_t changes_size; ///< Number of changes occupied.
ShadaEntry *additional_marks; ///< All marks with unknown names. ShadaEntry *additional_marks; ///< All marks with unknown names.
size_t additional_marks_size; ///< Size of the additional_marks array. size_t additional_marks_size; ///< Size of the additional_marks array.
@@ -329,14 +326,14 @@ typedef struct {
/// Before actually writing most of the data is read to this structure. /// Before actually writing most of the data is read to this structure.
typedef struct { typedef struct {
HistoryMergerState hms[HIST_COUNT]; ///< Structures for history merging. HistoryMergerState hms[HIST_COUNT]; ///< Structures for history merging.
PossiblyFreedShadaEntry global_marks[NMARKS]; ///< Named global marks. ShadaEntry global_marks[NMARKS]; ///< Named global marks.
PossiblyFreedShadaEntry numbered_marks[EXTRA_MARKS]; ///< Numbered marks. ShadaEntry numbered_marks[EXTRA_MARKS]; ///< Numbered marks.
PossiblyFreedShadaEntry registers[NUM_SAVED_REGISTERS]; ///< All registers. ShadaEntry registers[NUM_SAVED_REGISTERS]; ///< All registers.
PossiblyFreedShadaEntry jumps[JUMPLISTSIZE]; ///< All dumped jumps. ShadaEntry jumps[JUMPLISTSIZE]; ///< All dumped jumps.
size_t jumps_size; ///< Number of jumps occupied. size_t jumps_size; ///< Number of jumps occupied.
PossiblyFreedShadaEntry search_pattern; ///< Last search pattern. ShadaEntry search_pattern; ///< Last search pattern.
PossiblyFreedShadaEntry sub_search_pattern; ///< Last s/ search pattern. ShadaEntry sub_search_pattern; ///< Last s/ search pattern.
PossiblyFreedShadaEntry replacement; ///< Last s// replacement string. ShadaEntry replacement; ///< Last s// replacement string.
Set(cstr_t) dumped_variables; ///< Names of already dumped variables. Set(cstr_t) dumped_variables; ///< Names of already dumped variables.
PMap(cstr_t) file_marks; ///< All file marks. PMap(cstr_t) file_marks; ///< All file marks.
} WriteMergerState; } WriteMergerState;
@@ -468,10 +465,8 @@ static inline void hmll_remove(HMLList *const hmll, HMLListEntry *const hmll_ent
hmll_entry->prev->next = hmll_entry->next; hmll_entry->prev->next = hmll_entry->next;
} }
hmll->num_entries--; hmll->num_entries--;
if (hmll_entry->can_free_entry) {
shada_free_shada_entry(&hmll_entry->data); shada_free_shada_entry(&hmll_entry->data);
} }
}
/// Insert entry to the linked list /// Insert entry to the linked list
/// ///
@@ -480,8 +475,7 @@ static inline void hmll_remove(HMLList *const hmll, HMLListEntry *const hmll_ent
/// to insert at the first entry. /// to insert at the first entry.
/// @param[in] data Data to insert. /// @param[in] data Data to insert.
/// @param[in] can_free_entry True if data can be freed. /// @param[in] can_free_entry True if data can be freed.
static inline void hmll_insert(HMLList *const hmll, HMLListEntry *hmll_entry, const ShadaEntry data, static inline void hmll_insert(HMLList *const hmll, HMLListEntry *hmll_entry, const ShadaEntry data)
const bool can_free_entry)
FUNC_ATTR_NONNULL_ARG(1) FUNC_ATTR_NONNULL_ARG(1)
{ {
if (hmll->num_entries == hmll->size) { if (hmll->num_entries == hmll->size) {
@@ -503,7 +497,6 @@ static inline void hmll_insert(HMLList *const hmll, HMLListEntry *hmll_entry, co
hmll->free_entry = NULL; hmll->free_entry = NULL;
} }
target_entry->data = data; target_entry->data = data;
target_entry->can_free_entry = can_free_entry;
bool new_item = false; bool new_item = false;
ptr_t *val = pmap_put_ref(cstr_t)(&hmll->contained_entries, data.data.history_item.string, ptr_t *val = pmap_put_ref(cstr_t)(&hmll->contained_entries, data.data.history_item.string,
NULL, &new_item); NULL, &new_item);
@@ -639,6 +632,7 @@ static const void *shada_hist_iter(const void *const iter, const uint8_t history
*hist = (ShadaEntry) { .type = kSDItemMissing }; *hist = (ShadaEntry) { .type = kSDItemMissing };
} else { } else {
*hist = (ShadaEntry) { *hist = (ShadaEntry) {
.can_free_entry = zero,
.type = kSDItemHistoryEntry, .type = kSDItemHistoryEntry,
.timestamp = hist_he.timestamp, .timestamp = hist_he.timestamp,
.data = { .data = {
@@ -670,15 +664,13 @@ static const void *shada_hist_iter(const void *const iter, const uint8_t history
/// @param[in] do_iter Determines whether Neovim own history should /// @param[in] do_iter Determines whether Neovim own history should
/// be used. Must be true only if inserting /// be used. Must be true only if inserting
/// entry from current Neovim history. /// entry from current Neovim history.
/// @param[in] can_free_entry True if entry can be freed. static void hms_insert(HistoryMergerState *const hms_p, const ShadaEntry entry, const bool do_iter)
static void hms_insert(HistoryMergerState *const hms_p, const ShadaEntry entry, const bool do_iter,
const bool can_free_entry)
FUNC_ATTR_NONNULL_ALL FUNC_ATTR_NONNULL_ALL
{ {
if (do_iter) { if (do_iter) {
while (hms_p->last_hist_entry.type != kSDItemMissing while (hms_p->last_hist_entry.type != kSDItemMissing
&& hms_p->last_hist_entry.timestamp < entry.timestamp) { && hms_p->last_hist_entry.timestamp < entry.timestamp) {
hms_insert(hms_p, hms_p->last_hist_entry, false, hms_p->reading); hms_insert(hms_p, hms_p->last_hist_entry, false);
if (hms_p->iter == NULL) { if (hms_p->iter == NULL) {
hms_p->last_hist_entry.type = kSDItemMissing; hms_p->last_hist_entry.type = kSDItemMissing;
break; break;
@@ -697,11 +689,8 @@ static void hms_insert(HistoryMergerState *const hms_p, const ShadaEntry entry,
hmll_remove(hmll, existing_entry); hmll_remove(hmll, existing_entry);
} else if (!do_iter && entry.timestamp == existing_entry->data.timestamp) { } else if (!do_iter && entry.timestamp == existing_entry->data.timestamp) {
// Prefer entry from the current Neovim instance. // Prefer entry from the current Neovim instance.
if (existing_entry->can_free_entry) {
shada_free_shada_entry(&existing_entry->data); shada_free_shada_entry(&existing_entry->data);
}
existing_entry->data = entry; existing_entry->data = entry;
existing_entry->can_free_entry = can_free_entry;
// Previous key was freed above, as part of freeing the ShaDa entry. // Previous key was freed above, as part of freeing the ShaDa entry.
*key_alloc = entry.data.history_item.string; *key_alloc = entry.data.history_item.string;
return; return;
@@ -716,7 +705,7 @@ static void hms_insert(HistoryMergerState *const hms_p, const ShadaEntry entry,
break; break;
} }
} }
hmll_insert(hmll, insert_after, entry, can_free_entry); hmll_insert(hmll, insert_after, entry);
} }
/// Initialize the history merger /// Initialize the history merger
@@ -747,7 +736,7 @@ static inline void hms_insert_whole_neovim_history(HistoryMergerState *const hms
FUNC_ATTR_NONNULL_ALL FUNC_ATTR_NONNULL_ALL
{ {
while (hms_p->last_hist_entry.type != kSDItemMissing) { while (hms_p->last_hist_entry.type != kSDItemMissing) {
hms_insert(hms_p, hms_p->last_hist_entry, false, hms_p->reading); hms_insert(hms_p, hms_p->last_hist_entry, false);
if (hms_p->iter == NULL) { if (hms_p->iter == NULL) {
break; break;
} }
@@ -1051,8 +1040,7 @@ static void shada_read(FileDescriptor *const sd_reader, const int flags)
shada_free_shada_entry(&cur_entry); shada_free_shada_entry(&cur_entry);
break; break;
} }
hms_insert(hms + cur_entry.data.history_item.histtype, cur_entry, true, hms_insert(hms + cur_entry.data.history_item.histtype, cur_entry, true);
true);
// Do not free shada entry: its allocated memory was saved above. // Do not free shada entry: its allocated memory was saved above.
break; break;
case kSDItemRegister: case kSDItemRegister:
@@ -1595,16 +1583,12 @@ shada_pack_entry_error:
/// @param[in] entry Entry written. /// @param[in] entry Entry written.
/// @param[in] max_kbyte Maximum size of an item in KiB. Zero means no /// @param[in] max_kbyte Maximum size of an item in KiB. Zero means no
/// restrictions. /// restrictions.
static inline ShaDaWriteResult shada_pack_pfreed_entry(PackerBuffer *const packer, static inline ShaDaWriteResult shada_pack_pfreed_entry(PackerBuffer *const packer, ShadaEntry entry,
PossiblyFreedShadaEntry entry,
const size_t max_kbyte) const size_t max_kbyte)
FUNC_ATTR_NONNULL_ALL FUNC_ATTR_ALWAYS_INLINE FUNC_ATTR_NONNULL_ALL FUNC_ATTR_ALWAYS_INLINE
{ {
ShaDaWriteResult ret = kSDWriteSuccessful; ShaDaWriteResult ret = shada_pack_entry(packer, entry, max_kbyte);
ret = shada_pack_entry(packer, entry.data, max_kbyte); shada_free_shada_entry(&entry);
if (entry.can_free_entry) {
shada_free_shada_entry(&entry.data);
}
return ret; return ret;
} }
@@ -1725,19 +1709,7 @@ static const char *shada_format_entry(const ShadaEntry entry)
break; break;
#undef FORMAT_MARK_ENTRY #undef FORMAT_MARK_ENTRY
} }
return ret; ret[1] = (entry.can_free_entry ? 'T' : 'F');
}
/// Format possibly freed shada entry for debugging purposes
///
/// @param[in] entry ShaDa entry to format.
///
/// @return string representing ShaDa entry in a static buffer.
static const char *shada_format_pfreed_entry(const PossiblyFreedShadaEntry pfs_entry)
FUNC_ATTR_WARN_UNUSED_RESULT FUNC_ATTR_UNUSED FUNC_ATTR_NONNULL_RET
{
char *ret = (char *)shada_format_entry(pfs_entry.data);
ret[1] = (pfs_entry.can_free_entry ? 'T' : 'F');
return ret; return ret;
} }
@@ -1762,17 +1734,15 @@ static inline ShaDaWriteResult shada_read_when_writing(FileDescriptor *const sd_
#define COMPARE_WITH_ENTRY(wms_entry_, entry) \ #define COMPARE_WITH_ENTRY(wms_entry_, entry) \
do { \ do { \
PossiblyFreedShadaEntry *const wms_entry = (wms_entry_); \ ShadaEntry *const wms_entry = (wms_entry_); \
if (wms_entry->data.type != kSDItemMissing) { \ if (wms_entry->type != kSDItemMissing) { \
if (wms_entry->data.timestamp >= (entry).timestamp) { \ if (wms_entry->timestamp >= (entry).timestamp) { \
shada_free_shada_entry(&(entry)); \ shada_free_shada_entry(&entry); \
break; \ break; \
} \ } \
if (wms_entry->can_free_entry) { \ shada_free_shada_entry(wms_entry); \
shada_free_shada_entry(&wms_entry->data); \
} \ } \
} \ *wms_entry = entry; \
*wms_entry = pfs_entry; \
} while (0) } while (0)
while ((srni_ret = shada_read_next_item(sd_reader, &entry, srni_flags, while ((srni_ret = shada_read_next_item(sd_reader, &entry, srni_flags,
@@ -1792,10 +1762,6 @@ static inline ShaDaWriteResult shada_read_when_writing(FileDescriptor *const sd_
case kSDReadStatusMalformed: case kSDReadStatusMalformed:
continue; continue;
} }
const PossiblyFreedShadaEntry pfs_entry = {
.can_free_entry = true,
.data = entry,
};
switch (entry.type) { switch (entry.type) {
case kSDItemMissing: case kSDItemMissing:
break; break;
@@ -1821,8 +1787,7 @@ static inline ShaDaWriteResult shada_read_when_writing(FileDescriptor *const sd_
break; break;
} }
if (wms->hms[entry.data.history_item.histtype].hmll.size != 0) { if (wms->hms[entry.data.history_item.histtype].hmll.size != 0) {
hms_insert(&wms->hms[entry.data.history_item.histtype], entry, true, hms_insert(&wms->hms[entry.data.history_item.histtype], entry, true);
true);
} else { } else {
shada_free_shada_entry(&entry); shada_free_shada_entry(&entry);
} }
@@ -1849,7 +1814,7 @@ static inline ShaDaWriteResult shada_read_when_writing(FileDescriptor *const sd_
// Completely ignore numbered mark names, make a list sorted by // Completely ignore numbered mark names, make a list sorted by
// timestamp. // timestamp.
for (size_t i = ARRAY_SIZE(wms->numbered_marks); i > 0; i--) { for (size_t i = ARRAY_SIZE(wms->numbered_marks); i > 0; i--) {
ShadaEntry wms_entry = wms->numbered_marks[i - 1].data; ShadaEntry wms_entry = wms->numbered_marks[i - 1];
if (wms_entry.type != kSDItemGlobalMark) { if (wms_entry.type != kSDItemGlobalMark) {
continue; continue;
} }
@@ -1868,7 +1833,7 @@ static inline ShaDaWriteResult shada_read_when_writing(FileDescriptor *const sd_
if (wms_entry.timestamp >= entry.timestamp) { if (wms_entry.timestamp >= entry.timestamp) {
processed_mark = true; processed_mark = true;
if (i < ARRAY_SIZE(wms->numbered_marks)) { if (i < ARRAY_SIZE(wms->numbered_marks)) {
replace_numbered_mark(wms, i, pfs_entry); replace_numbered_mark(wms, i, entry);
} else { } else {
shada_free_shada_entry(&entry); shada_free_shada_entry(&entry);
} }
@@ -1876,7 +1841,7 @@ static inline ShaDaWriteResult shada_read_when_writing(FileDescriptor *const sd_
} }
} }
if (!processed_mark) { if (!processed_mark) {
replace_numbered_mark(wms, 0, pfs_entry); replace_numbered_mark(wms, 0, entry);
} }
} else { } else {
const int idx = mark_global_index(entry.data.filemark.name); const int idx = mark_global_index(entry.data.filemark.name);
@@ -1887,10 +1852,9 @@ static inline ShaDaWriteResult shada_read_when_writing(FileDescriptor *const sd_
} }
// Global or numbered mark. // Global or numbered mark.
PossiblyFreedShadaEntry *mark ShadaEntry *mark = idx < 26 ? &wms->global_marks[idx] : &wms->numbered_marks[idx - 26];
= idx < 26 ? &wms->global_marks[idx] : &wms->numbered_marks[idx - 26];
if (mark->data.type == kSDItemMissing) { if (mark->type == kSDItemMissing) {
if (namedfm[idx].fmark.timestamp >= entry.timestamp) { if (namedfm[idx].fmark.timestamp >= entry.timestamp) {
shada_free_shada_entry(&entry); shada_free_shada_entry(&entry);
break; break;
@@ -1928,18 +1892,18 @@ static inline ShaDaWriteResult shada_read_when_writing(FileDescriptor *const sd_
filemarks->additional_marks[filemarks->additional_marks_size - 1] = filemarks->additional_marks[filemarks->additional_marks_size - 1] =
entry; entry;
} else { } else {
PossiblyFreedShadaEntry *const wms_entry = &filemarks->marks[idx]; ShadaEntry *const wms_entry = &filemarks->marks[idx];
bool set_wms = true; bool set_wms = true;
if (wms_entry->data.type != kSDItemMissing) { if (wms_entry->type != kSDItemMissing) {
if (wms_entry->data.timestamp >= entry.timestamp) { if (wms_entry->timestamp >= entry.timestamp) {
shada_free_shada_entry(&entry); shada_free_shada_entry(&entry);
break; break;
} }
if (wms_entry->can_free_entry) { if (wms_entry->can_free_entry) {
if (*key == wms_entry->data.data.filemark.fname) { if (*key == wms_entry->data.filemark.fname) {
*key = entry.data.filemark.fname; *key = entry.data.filemark.fname;
} }
shada_free_shada_entry(&wms_entry->data); shada_free_shada_entry(wms_entry);
} }
} else { } else {
FOR_ALL_BUFFERS(buf) { FOR_ALL_BUFFERS(buf) {
@@ -1956,30 +1920,27 @@ static inline ShaDaWriteResult shada_read_when_writing(FileDescriptor *const sd_
} }
} }
if (set_wms) { if (set_wms) {
*wms_entry = pfs_entry; *wms_entry = entry;
} }
} }
} else { } else {
int i; int i;
for (i = (int)filemarks->changes_size; i > 0; i--) { for (i = (int)filemarks->changes_size; i > 0; i--) {
const PossiblyFreedShadaEntry jl_entry = filemarks->changes[i - 1]; const ShadaEntry jl_entry = filemarks->changes[i - 1];
if (jl_entry.data.timestamp <= (entry).timestamp) { if (jl_entry.timestamp <= (entry).timestamp) {
if (marks_equal(jl_entry.data.data.filemark.mark, entry.data.filemark.mark)) { if (marks_equal(jl_entry.data.filemark.mark, entry.data.filemark.mark)) {
i = -1; i = -1;
} }
break; break;
} }
} }
if (i > 0 && filemarks->changes_size == JUMPLISTSIZE) { if (i > 0 && filemarks->changes_size == JUMPLISTSIZE) {
if (filemarks->changes[0].can_free_entry) { shada_free_shada_entry(&filemarks->changes[0]);
shada_free_shada_entry(&filemarks->changes[0].data);
}
} }
i = marklist_insert(filemarks->changes, sizeof(*filemarks->changes), i = marklist_insert(filemarks->changes, sizeof(*filemarks->changes),
(int)filemarks->changes_size, i); (int)filemarks->changes_size, i);
if (i != -1) { if (i != -1) {
filemarks->changes[i] = (PossiblyFreedShadaEntry) { .can_free_entry = true, filemarks->changes[i] = entry;
.data = entry };
if (filemarks->changes_size < JUMPLISTSIZE) { if (filemarks->changes_size < JUMPLISTSIZE) {
filemarks->changes_size++; filemarks->changes_size++;
} }
@@ -1993,28 +1954,26 @@ static inline ShaDaWriteResult shada_read_when_writing(FileDescriptor *const sd_
; ;
int i; int i;
for (i = (int)wms->jumps_size; i > 0; i--) { for (i = (int)wms->jumps_size; i > 0; i--) {
const PossiblyFreedShadaEntry jl_entry = wms->jumps[i - 1]; const ShadaEntry jl_entry = wms->jumps[i - 1];
if (jl_entry.data.timestamp <= entry.timestamp) { if (jl_entry.timestamp <= entry.timestamp) {
if (marks_equal(jl_entry.data.data.filemark.mark, entry.data.filemark.mark) if (marks_equal(jl_entry.data.filemark.mark, entry.data.filemark.mark)
&& strcmp(jl_entry.data.data.filemark.fname, entry.data.filemark.fname) == 0) { && strcmp(jl_entry.data.filemark.fname, entry.data.filemark.fname) == 0) {
i = -1; i = -1;
} }
break; break;
} }
} }
if (i > 0 && wms->jumps_size == JUMPLISTSIZE) { if (i > 0 && wms->jumps_size == JUMPLISTSIZE) {
if (wms->jumps[0].can_free_entry) { shada_free_shada_entry(&wms->jumps[0]);
shada_free_shada_entry(&wms->jumps[0].data);
}
} }
i = marklist_insert(wms->jumps, sizeof(*wms->jumps), (int)wms->jumps_size, i); i = marklist_insert(wms->jumps, sizeof(*wms->jumps), (int)wms->jumps_size, i);
if (i != -1) { if (i != -1) {
wms->jumps[i] = (PossiblyFreedShadaEntry) { .can_free_entry = true, .data = entry }; wms->jumps[i] = entry;
if (wms->jumps_size < JUMPLISTSIZE) { if (wms->jumps_size < JUMPLISTSIZE) {
wms->jumps_size++; wms->jumps_size++;
} }
} else { } else {
shada_free_shada_entry(&(entry)); shada_free_shada_entry(&entry);
} }
break; break;
} }
@@ -2083,7 +2042,7 @@ static inline ShadaEntry shada_get_buflist(Set(ptr_t) *const removable_bufs)
return buflist_entry; return buflist_entry;
} }
/// Save search pattern to PossiblyFreedShadaEntry /// Save search pattern to ShadaEntry
/// ///
/// @param[out] ret_pse Location where result will be saved. /// @param[out] ret_pse Location where result will be saved.
/// @param[in] get_pattern Function used to get pattern. /// @param[in] get_pattern Function used to get pattern.
@@ -2095,7 +2054,7 @@ static inline ShadaEntry shada_get_buflist(Set(ptr_t) *const removable_bufs)
/// @param[in] search_highlighted True if search pattern was highlighted by /// @param[in] search_highlighted True if search pattern was highlighted by
/// &hlsearch and this information should be /// &hlsearch and this information should be
/// saved. /// saved.
static inline void add_search_pattern(PossiblyFreedShadaEntry *const ret_pse, static inline void add_search_pattern(ShadaEntry *const ret_pse,
const SearchPatternGetter get_pattern, const SearchPatternGetter get_pattern,
const bool is_substitute_pattern, const bool search_last_used, const bool is_substitute_pattern, const bool search_last_used,
const bool search_highlighted) const bool search_highlighted)
@@ -2105,9 +2064,8 @@ static inline void add_search_pattern(PossiblyFreedShadaEntry *const ret_pse,
SearchPattern pat; SearchPattern pat;
get_pattern(&pat); get_pattern(&pat);
if (pat.pat != NULL) { if (pat.pat != NULL) {
*ret_pse = (PossiblyFreedShadaEntry) { *ret_pse = (ShadaEntry) {
.can_free_entry = false, .can_free_entry = false,
.data = {
.type = kSDItemSearchPattern, .type = kSDItemSearchPattern,
.timestamp = pat.timestamp, .timestamp = pat.timestamp,
.data = { .data = {
@@ -2133,7 +2091,6 @@ static inline void add_search_pattern(PossiblyFreedShadaEntry *const ret_pse,
} }
}, },
.additional_data = pat.additional_data, .additional_data = pat.additional_data,
}
}; };
} }
} }
@@ -2158,9 +2115,8 @@ static inline void shada_initialize_registers(WriteMergerState *const wms, int m
if (limit_reg_lines && reg.y_size > (size_t)max_reg_lines) { if (limit_reg_lines && reg.y_size > (size_t)max_reg_lines) {
continue; continue;
} }
wms->registers[op_reg_index(name)] = (PossiblyFreedShadaEntry) { wms->registers[op_reg_index(name)] = (ShadaEntry) {
.can_free_entry = false, .can_free_entry = false,
.data = {
.type = kSDItemRegister, .type = kSDItemRegister,
.timestamp = reg.timestamp, .timestamp = reg.timestamp,
.data = { .data = {
@@ -2174,7 +2130,6 @@ static inline void shada_initialize_registers(WriteMergerState *const wms, int m
} }
}, },
.additional_data = reg.additional_data, .additional_data = reg.additional_data,
}
}; };
} while (reg_iter != NULL); } while (reg_iter != NULL);
} }
@@ -2188,22 +2143,20 @@ static inline void shada_initialize_registers(WriteMergerState *const wms, int m
/// @param[in] idx Index at which new mark should be placed. /// @param[in] idx Index at which new mark should be placed.
/// @param[in] entry New mark. /// @param[in] entry New mark.
static inline void replace_numbered_mark(WriteMergerState *const wms, const size_t idx, static inline void replace_numbered_mark(WriteMergerState *const wms, const size_t idx,
const PossiblyFreedShadaEntry entry) const ShadaEntry entry)
FUNC_ATTR_NONNULL_ALL FUNC_ATTR_ALWAYS_INLINE FUNC_ATTR_NONNULL_ALL FUNC_ATTR_ALWAYS_INLINE
{ {
if (ARRAY_LAST_ENTRY(wms->numbered_marks).can_free_entry) { shada_free_shada_entry(&ARRAY_LAST_ENTRY(wms->numbered_marks));
shada_free_shada_entry(&ARRAY_LAST_ENTRY(wms->numbered_marks).data);
}
for (size_t i = idx; i < ARRAY_SIZE(wms->numbered_marks) - 1; i++) { for (size_t i = idx; i < ARRAY_SIZE(wms->numbered_marks) - 1; i++) {
if (wms->numbered_marks[i].data.type == kSDItemGlobalMark) { if (wms->numbered_marks[i].type == kSDItemGlobalMark) {
wms->numbered_marks[i].data.data.filemark.name = (char)('0' + (int)i + 1); wms->numbered_marks[i].data.filemark.name = (char)('0' + (int)i + 1);
} }
} }
memmove(wms->numbered_marks + idx + 1, wms->numbered_marks + idx, memmove(wms->numbered_marks + idx + 1, wms->numbered_marks + idx,
sizeof(wms->numbered_marks[0]) sizeof(wms->numbered_marks[0])
* (ARRAY_SIZE(wms->numbered_marks) - 1 - idx)); * (ARRAY_SIZE(wms->numbered_marks) - 1 - idx));
wms->numbered_marks[idx] = entry; wms->numbered_marks[idx] = entry;
wms->numbered_marks[idx].data.data.filemark.name = (char)('0' + (int)idx); wms->numbered_marks[idx].data.filemark.name = (char)('0' + (int)idx);
} }
/// Find buffers ignored due to their location. /// Find buffers ignored due to their location.
@@ -2458,9 +2411,8 @@ static ShaDaWriteResult shada_write(FileDescriptor *const sd_writer,
SubReplacementString sub; SubReplacementString sub;
sub_get_replacement(&sub); sub_get_replacement(&sub);
if (sub.sub != NULL) { // Don't store empty replacement string if (sub.sub != NULL) { // Don't store empty replacement string
wms->replacement = (PossiblyFreedShadaEntry) { wms->replacement = (ShadaEntry) {
.can_free_entry = false, .can_free_entry = false,
.data = {
.type = kSDItemSubString, .type = kSDItemSubString,
.timestamp = sub.timestamp, .timestamp = sub.timestamp,
.data = { .data = {
@@ -2469,7 +2421,6 @@ static ShaDaWriteResult shada_write(FileDescriptor *const sd_writer,
} }
}, },
.additional_data = sub.additional_data, .additional_data = sub.additional_data,
}
}; };
} }
} }
@@ -2499,9 +2450,8 @@ static ShaDaWriteResult shada_write(FileDescriptor *const sd_writer,
} }
fname = buf->b_ffname; fname = buf->b_ffname;
} }
const PossiblyFreedShadaEntry pf_entry = { const ShadaEntry entry = {
.can_free_entry = false, .can_free_entry = false,
.data = {
.type = kSDItemGlobalMark, .type = kSDItemGlobalMark,
.timestamp = fm.fmark.timestamp, .timestamp = fm.fmark.timestamp,
.data = { .data = {
@@ -2512,12 +2462,11 @@ static ShaDaWriteResult shada_write(FileDescriptor *const sd_writer,
} }
}, },
.additional_data = fm.fmark.additional_data, .additional_data = fm.fmark.additional_data,
},
}; };
if (ascii_isdigit(name)) { if (ascii_isdigit(name)) {
replace_numbered_mark(wms, digit_mark_idx++, pf_entry); replace_numbered_mark(wms, digit_mark_idx++, entry);
} else { } else {
wms->global_marks[mark_global_index(name)] = pf_entry; wms->global_marks[mark_global_index(name)] = entry;
} }
} while (global_mark_iter != NULL); } while (global_mark_iter != NULL);
} }
@@ -2552,9 +2501,8 @@ static ShaDaWriteResult shada_write(FileDescriptor *const sd_writer,
if (name == NUL) { if (name == NUL) {
break; break;
} }
filemarks->marks[mark_local_index(name)] = (PossiblyFreedShadaEntry) { filemarks->marks[mark_local_index(name)] = (ShadaEntry) {
.can_free_entry = false, .can_free_entry = false,
.data = {
.type = kSDItemLocalMark, .type = kSDItemLocalMark,
.timestamp = fm.timestamp, .timestamp = fm.timestamp,
.data = { .data = {
@@ -2565,7 +2513,6 @@ static ShaDaWriteResult shada_write(FileDescriptor *const sd_writer,
} }
}, },
.additional_data = fm.additional_data, .additional_data = fm.additional_data,
}
}; };
if (fm.timestamp > filemarks->greatest_timestamp) { if (fm.timestamp > filemarks->greatest_timestamp) {
filemarks->greatest_timestamp = fm.timestamp; filemarks->greatest_timestamp = fm.timestamp;
@@ -2573,9 +2520,8 @@ static ShaDaWriteResult shada_write(FileDescriptor *const sd_writer,
} while (local_marks_iter != NULL); } while (local_marks_iter != NULL);
for (int i = 0; i < buf->b_changelistlen; i++) { for (int i = 0; i < buf->b_changelistlen; i++) {
const fmark_T fm = buf->b_changelist[i]; const fmark_T fm = buf->b_changelist[i];
filemarks->changes[i] = (PossiblyFreedShadaEntry) { filemarks->changes[i] = (ShadaEntry) {
.can_free_entry = false, .can_free_entry = false,
.data = {
.type = kSDItemChange, .type = kSDItemChange,
.timestamp = fm.timestamp, .timestamp = fm.timestamp,
.data = { .data = {
@@ -2585,7 +2531,6 @@ static ShaDaWriteResult shada_write(FileDescriptor *const sd_writer,
} }
}, },
.additional_data = fm.additional_data, .additional_data = fm.additional_data,
}
}; };
if (fm.timestamp > filemarks->greatest_timestamp) { if (fm.timestamp > filemarks->greatest_timestamp) {
filemarks->greatest_timestamp = fm.timestamp; filemarks->greatest_timestamp = fm.timestamp;
@@ -2606,9 +2551,8 @@ static ShaDaWriteResult shada_write(FileDescriptor *const sd_writer,
// Update numbered marks: replace '0 mark with the current position, // Update numbered marks: replace '0 mark with the current position,
// remove '9 and shift all other marks. Skip if f0 in 'shada'. // remove '9 and shift all other marks. Skip if f0 in 'shada'.
if (dump_global_marks && !ignore_buf(curbuf, &removable_bufs) && curwin->w_cursor.lnum != 0) { if (dump_global_marks && !ignore_buf(curbuf, &removable_bufs) && curwin->w_cursor.lnum != 0) {
replace_numbered_mark(wms, 0, (PossiblyFreedShadaEntry) { replace_numbered_mark(wms, 0, (ShadaEntry) {
.can_free_entry = false, .can_free_entry = false,
.data = {
.type = kSDItemGlobalMark, .type = kSDItemGlobalMark,
.timestamp = os_time(), .timestamp = os_time(),
.data = { .data = {
@@ -2619,7 +2563,6 @@ static ShaDaWriteResult shada_write(FileDescriptor *const sd_writer,
} }
}, },
.additional_data = NULL, .additional_data = NULL,
},
}); });
} }
@@ -2627,7 +2570,7 @@ static ShaDaWriteResult shada_write(FileDescriptor *const sd_writer,
#define PACK_WMS_ARRAY(wms_array) \ #define PACK_WMS_ARRAY(wms_array) \
do { \ do { \
for (size_t i_ = 0; i_ < ARRAY_SIZE(wms_array); i_++) { \ for (size_t i_ = 0; i_ < ARRAY_SIZE(wms_array); i_++) { \
if ((wms_array)[i_].data.type != kSDItemMissing) { \ if ((wms_array)[i_].type != kSDItemMissing) { \
if (shada_pack_pfreed_entry(&packer, (wms_array)[i_], max_kbyte) \ if (shada_pack_pfreed_entry(&packer, (wms_array)[i_], max_kbyte) \
== kSDWriteFailed) { \ == kSDWriteFailed) { \
ret = kSDWriteFailed; \ ret = kSDWriteFailed; \
@@ -2648,7 +2591,7 @@ static ShaDaWriteResult shada_write(FileDescriptor *const sd_writer,
} }
#define PACK_WMS_ENTRY(wms_entry) \ #define PACK_WMS_ENTRY(wms_entry) \
do { \ do { \
if ((wms_entry).data.type != kSDItemMissing) { \ if ((wms_entry).type != kSDItemMissing) { \
if (shada_pack_pfreed_entry(&packer, wms_entry, max_kbyte) \ if (shada_pack_pfreed_entry(&packer, wms_entry, max_kbyte) \
== kSDWriteFailed) { \ == kSDWriteFailed) { \
ret = kSDWriteFailed; \ ret = kSDWriteFailed; \
@@ -2700,10 +2643,7 @@ static ShaDaWriteResult shada_write(FileDescriptor *const sd_writer,
if (dump_one_history[i]) { if (dump_one_history[i]) {
hms_insert_whole_neovim_history(&wms->hms[i]); hms_insert_whole_neovim_history(&wms->hms[i]);
HMS_ITER(&wms->hms[i], cur_entry, { HMS_ITER(&wms->hms[i], cur_entry, {
if (shada_pack_pfreed_entry(&packer, (PossiblyFreedShadaEntry) { if (shada_pack_pfreed_entry(&packer, cur_entry->data, max_kbyte) == kSDWriteFailed) {
.data = cur_entry->data,
.can_free_entry = cur_entry->can_free_entry,
}, max_kbyte) == kSDWriteFailed) {
ret = kSDWriteFailed; ret = kSDWriteFailed;
break; break;
} }
@@ -2954,7 +2894,7 @@ int shada_read_everything(const char *const fname, const bool forceit, const boo
static void shada_free_shada_entry(ShadaEntry *const entry) static void shada_free_shada_entry(ShadaEntry *const entry)
{ {
if (entry == NULL) { if (entry == NULL || !entry->can_free_entry) {
return; return;
} }
switch (entry->type) { switch (entry->type) {
@@ -3196,6 +3136,7 @@ shada_read_next_item_start:
const size_t length = (size_t)length_u64; const size_t length = (size_t)length_u64;
entry->timestamp = (Timestamp)timestamp_u64; entry->timestamp = (Timestamp)timestamp_u64;
entry->can_free_entry = true; // all allocations are owned by the entry
if (type_u64 == 0) { if (type_u64 == 0) {
// kSDItemUnknown cannot possibly pass that far because it is -1 and that // kSDItemUnknown cannot possibly pass that far because it is -1 and that
@@ -3613,8 +3554,7 @@ static bool shada_removable(const char *name)
/// location. /// location.
/// ///
/// @return number of jumplist entries /// @return number of jumplist entries
static inline size_t shada_init_jumps(PossiblyFreedShadaEntry *jumps, static inline size_t shada_init_jumps(ShadaEntry *jumps, Set(ptr_t) *const removable_bufs)
Set(ptr_t) *const removable_bufs)
{ {
// Initialize jump list // Initialize jump list
size_t jumps_size = 0; size_t jumps_size = 0;
@@ -3640,9 +3580,8 @@ static inline size_t shada_init_jumps(PossiblyFreedShadaEntry *jumps,
if (fname == NULL) { if (fname == NULL) {
continue; continue;
} }
jumps[jumps_size++] = (PossiblyFreedShadaEntry) { jumps[jumps_size++] = (ShadaEntry) {
.can_free_entry = false, .can_free_entry = false,
.data = {
.type = kSDItemJump, .type = kSDItemJump,
.timestamp = fm.fmark.timestamp, .timestamp = fm.fmark.timestamp,
.data = { .data = {
@@ -3653,7 +3592,6 @@ static inline size_t shada_init_jumps(PossiblyFreedShadaEntry *jumps,
} }
}, },
.additional_data = fm.fmark.additional_data, .additional_data = fm.fmark.additional_data,
}
}; };
} while (jump_iter != NULL); } while (jump_iter != NULL);
return jumps_size; return jumps_size;
@@ -3669,7 +3607,7 @@ String shada_encode_regs(void)
shada_initialize_registers(wms, -1); shada_initialize_registers(wms, -1);
PackerBuffer packer = packer_string_buffer(); PackerBuffer packer = packer_string_buffer();
for (size_t i = 0; i < ARRAY_SIZE(wms->registers); i++) { for (size_t i = 0; i < ARRAY_SIZE(wms->registers); i++) {
if (wms->registers[i].data.type == kSDItemRegister) { if (wms->registers[i].type == kSDItemRegister) {
if (kSDWriteFailed if (kSDWriteFailed
== shada_pack_pfreed_entry(&packer, wms->registers[i], 0)) { == shada_pack_pfreed_entry(&packer, wms->registers[i], 0)) {
abort(); abort();
@@ -3688,7 +3626,7 @@ String shada_encode_jumps(void)
{ {
Set(ptr_t) removable_bufs = SET_INIT; Set(ptr_t) removable_bufs = SET_INIT;
find_removable_bufs(&removable_bufs); find_removable_bufs(&removable_bufs);
PossiblyFreedShadaEntry jumps[JUMPLISTSIZE]; ShadaEntry jumps[JUMPLISTSIZE];
size_t jumps_size = shada_init_jumps(jumps, &removable_bufs); size_t jumps_size = shada_init_jumps(jumps, &removable_bufs);
PackerBuffer packer = packer_string_buffer(); PackerBuffer packer = packer_string_buffer();
for (size_t i = 0; i < jumps_size; i++) { for (size_t i = 0; i < jumps_size; i++) {