mirrors/neovim
1
0
Fork 0
mirror of https://github.com/neovim/neovim.git synced 2025-10-06 01:46:29 +00:00
Code Issues Packages Projects Releases Wiki Activity

Remove long_u: put_bytes(): Refactor.

Browse Source 
Remove all long_u instances due to put_bytes() function.

First, function signature is changed this way:
- nr  : long_u --> uintmax_t
    uintmax_t is chosen so that invocations can use any unsigned integer
    type (including size_t) without needing to cast.
- len : int    --> unsigned int
    This is to pass the size in bytes of the previous param, thus an
    unsigned int is enough. All invocations use positive integer
    literals, so change is safe without the need for casts.

Then, function implementation is adapted accordingly.

Last, all invocation points are refactored this way:
- Refactor types to minimize casts.
- Inline declarations (C99 style) in containing function.

All this changes were done with -Wconversion temporarily activated for
spell.c and undo.c, so that we can assert changes are type-safe and do
not introduce any warnings to that respect.
This commit is contained in:
Eliseo Martínez
2014-12-21 12:36:16 +01:00
parent 59985523b8
commit d2745a59f8
3 changed files with 161 additions and 194 deletions
Download Patch File Download Diff File Expand all files Collapse all files

13
src/nvim/misc2.c
View File

@@ -501,15 +501,12 @@ char *read_string(FILE *fd, size_t cnt)
return (char *)str;
}
/*
* Write a number to file "fd", MSB first, in "len" bytes.
*/
int put_bytes(FILE *fd, long_u nr, int len)
/// Write a number to file "fd", MSB first, in "len" bytes.
/// @return OK/FAIL.
int put_bytes(FILE *fd, uintmax_t number, unsigned int len)
{
int i;
for (i = len - 1; i >= 0; --i)
if (putc((int)(nr >> (i * 8)), fd) == EOF)
for (unsigned int i = len - 1; i < len; --i)
if (putc((int)(number >> (i * 8)), fd) == EOF)
return FAIL;
return OK;
}

264
src/nvim/spell.c
View File

@@ -287,6 +287,7 @@
#include <assert.h>
#include <errno.h>
#include <inttypes.h>
#include <limits.h>
#include <stdbool.h>
#include <string.h>
#include <stdlib.h>
@@ -6594,25 +6595,13 @@ static int rep_compare(const void *s1, const void *s2)
}
// Write the Vim .spl file "fname".
// Return FAIL or OK;
// Return OK/FAIL.
static int write_vim_spell(spellinfo_T *spin, char_u *fname)
{
FILE *fd;
int regionmask;
int round;
wordnode_T *tree;
int nodecount;
int i;
int l;
garray_T *gap;
fromto_T *ftp;
char_u *p;
int rr;
int retval = OK;
size_t fwv = 1; // collect return value of fwrite() to avoid
// warnings from picky compiler
int regionmask;
fd = mch_fopen((char *)fname, "w");
FILE *fd = mch_fopen((char *)fname, "w");
if (fd == NULL) {
EMSG2(_(e_notopen), fname);
return FAIL;
@@ -6620,7 +6609,7 @@ static int write_vim_spell(spellinfo_T *spin, char_u *fname)
// <HEADER>: <fileID> <versionnr>
// <fileID>
fwv &= fwrite(VIMSPELLMAGIC, VIMSPELLMAGICL, (size_t)1, fd);
size_t fwv = fwrite(VIMSPELLMAGIC, VIMSPELLMAGICL, 1, fd);
if (fwv != (size_t)1)
// Catch first write error, don't try writing more.
goto theend;
@@ -6633,10 +6622,9 @@ static int write_vim_spell(spellinfo_T *spin, char_u *fname)
if (spin->si_info != NULL) {
putc(SN_INFO, fd); // <sectionID>
putc(0, fd); // <sectionflags>
i = (int)STRLEN(spin->si_info);
put_bytes(fd, (long_u)i, 4); // <sectionlen>
fwv &= fwrite(spin->si_info, (size_t)i, (size_t)1, fd); // <infotext>
size_t i = STRLEN(spin->si_info);
put_bytes(fd, i, 4); // <sectionlen>
fwv &= fwrite(spin->si_info, i, 1, fd); // <infotext>
}
// SN_REGION: <regionname> ...
@@ -6644,9 +6632,9 @@ static int write_vim_spell(spellinfo_T *spin, char_u *fname)
if (spin->si_region_count > 1) {
putc(SN_REGION, fd); // <sectionID>
putc(SNF_REQUIRED, fd); // <sectionflags>
l = spin->si_region_count * 2;
put_bytes(fd, (long_u)l, 4); // <sectionlen>
fwv &= fwrite(spin->si_region_name, (size_t)l, (size_t)1, fd);
size_t l = (size_t)spin->si_region_count * 2;
put_bytes(fd, l, 4); // <sectionlen>
fwv &= fwrite(spin->si_region_name, l, 1, fd);
// <regionname> ...
regionmask = (1 << spin->si_region_count) - 1;
} else
@@ -6669,17 +6657,17 @@ static int write_vim_spell(spellinfo_T *spin, char_u *fname)
putc(SNF_REQUIRED, fd); // <sectionflags>
// Form the <folchars> string first, we need to know its length.
l = 0;
for (i = 128; i < 256; ++i) {
size_t l = 0;
for (size_t i = 128; i < 256; ++i) {
if (has_mbyte)
l += mb_char2bytes(spelltab.st_fold[i], folchars + l);
l += (size_t)mb_char2bytes(spelltab.st_fold[i], folchars + l);
else
folchars[l++] = spelltab.st_fold[i];
}
put_bytes(fd, (long_u)(1 + 128 + 2 + l), 4); // <sectionlen>
put_bytes(fd, 1 + 128 + 2 + l, 4); // <sectionlen>
fputc(128, fd); // <charflagslen>
for (i = 128; i < 256; ++i) {
for (size_t i = 128; i < 256; ++i) {
flags = 0;
if (spelltab.st_isw[i])
flags |= CF_WORD;
@@ -6688,8 +6676,8 @@ static int write_vim_spell(spellinfo_T *spin, char_u *fname)
fputc(flags, fd); // <charflags>
}
put_bytes(fd, (long_u)l, 2); // <folcharslen>
fwv &= fwrite(folchars, (size_t)l, (size_t)1, fd); // <folchars>
put_bytes(fd, l, 2); // <folcharslen>
fwv &= fwrite(folchars, l, 1, fd); // <folchars>
}
// SN_MIDWORD: <midword>
@@ -6697,9 +6685,9 @@ static int write_vim_spell(spellinfo_T *spin, char_u *fname)
putc(SN_MIDWORD, fd); // <sectionID>
putc(SNF_REQUIRED, fd); // <sectionflags>
i = (int)STRLEN(spin->si_midword);
put_bytes(fd, (long_u)i, 4); // <sectionlen>
fwv &= fwrite(spin->si_midword, (size_t)i, (size_t)1, fd);
size_t i = STRLEN(spin->si_midword);
put_bytes(fd, i, 4); // <sectionlen>
fwv &= fwrite(spin->si_midword, i, 1, fd);
// <midword>
}
@@ -6708,8 +6696,8 @@ static int write_vim_spell(spellinfo_T *spin, char_u *fname)
putc(SN_PREFCOND, fd); // <sectionID>
putc(SNF_REQUIRED, fd); // <sectionflags>
l = write_spell_prefcond(NULL, &spin->si_prefcond);
put_bytes(fd, (long_u)l, 4); // <sectionlen>
size_t l = (size_t)write_spell_prefcond(NULL, &spin->si_prefcond);
put_bytes(fd, l, 4); // <sectionlen>
write_spell_prefcond(fd, &spin->si_prefcond);
}
@@ -6721,7 +6709,8 @@ static int write_vim_spell(spellinfo_T *spin, char_u *fname)
// round 1: SN_REP section
// round 2: SN_SAL section (unless SN_SOFO is used)
// round 3: SN_REPSAL section
for (round = 1; round <= 3; ++round) {
for (unsigned int round = 1; round <= 3; ++round) {
garray_T *gap;
if (round == 1)
gap = &spin->si_rep;
else if (round == 2) {
@@ -6741,45 +6730,47 @@ static int write_vim_spell(spellinfo_T *spin, char_u *fname)
qsort(gap->ga_data, (size_t)gap->ga_len,
sizeof(fromto_T), rep_compare);
i = round == 1 ? SN_REP : (round == 2 ? SN_SAL : SN_REPSAL);
int i = round == 1 ? SN_REP : (round == 2 ? SN_SAL : SN_REPSAL);
putc(i, fd); // <sectionID>
// This is for making suggestions, section is not required.
putc(0, fd); // <sectionflags>
// Compute the length of what follows.
l = 2; // count <repcount> or <salcount>
for (int i = 0; i < gap->ga_len; ++i) {
ftp = &((fromto_T *)gap->ga_data)[i];
l += 1 + (int)STRLEN(ftp->ft_from); // count <*fromlen> and <*from>
l += 1 + (int)STRLEN(ftp->ft_to); // count <*tolen> and <*to>
size_t l = 2; // count <repcount> or <salcount>
assert(gap->ga_len >= 0);
for (size_t i = 0; i < (size_t)gap->ga_len; ++i) {
fromto_T *ftp = &((fromto_T *)gap->ga_data)[i];
l += 1 + STRLEN(ftp->ft_from); // count <*fromlen> and <*from>
l += 1 + STRLEN(ftp->ft_to); // count <*tolen> and <*to>
}
if (round == 2)
++l; // count <salflags>
put_bytes(fd, (long_u)l, 4); // <sectionlen>
++l; // count <salflags>
put_bytes(fd, l, 4); // <sectionlen>
if (round == 2) {
i = 0;
int i = 0;
if (spin->si_followup)
i |= SAL_F0LLOWUP;
if (spin->si_collapse)
i |= SAL_COLLAPSE;
if (spin->si_rem_accents)
i |= SAL_REM_ACCENTS;
putc(i, fd); // <salflags>
putc(i, fd); // <salflags>
}
put_bytes(fd, (long_u)gap->ga_len, 2); // <repcount> or <salcount>
for (int i = 0; i < gap->ga_len; ++i) {
put_bytes(fd, (uintmax_t)gap->ga_len, 2); // <repcount> or <salcount>
for (size_t i = 0; i < (size_t)gap->ga_len; ++i) {
// <rep> : <repfromlen> <repfrom> <reptolen> <repto>
// <sal> : <salfromlen> <salfrom> <saltolen> <salto>
ftp = &((fromto_T *)gap->ga_data)[i];
for (rr = 1; rr <= 2; ++rr) {
p = rr == 1 ? ftp->ft_from : ftp->ft_to;
l = (int)STRLEN(p);
putc(l, fd);
fromto_T *ftp = &((fromto_T *)gap->ga_data)[i];
for (unsigned int rr = 1; rr <= 2; ++rr) {
char_u *p = rr == 1 ? ftp->ft_from : ftp->ft_to;
l = STRLEN(p);
assert(l < INT_MAX);
putc((int)l, fd);
if (l > 0)
fwv &= fwrite(p, l, (size_t)1, fd);
fwv &= fwrite(p, l, 1, fd);
}
}
@@ -6791,16 +6782,15 @@ static int write_vim_spell(spellinfo_T *spin, char_u *fname)
putc(SN_SOFO, fd); // <sectionID>
putc(0, fd); // <sectionflags>
l = (int)STRLEN(spin->si_sofofr);
put_bytes(fd, (long_u)(l + STRLEN(spin->si_sofoto) + 4), 4);
// <sectionlen>
size_t l = STRLEN(spin->si_sofofr);
put_bytes(fd, l + STRLEN(spin->si_sofoto) + 4, 4); // <sectionlen>
put_bytes(fd, (long_u)l, 2); // <sofofromlen>
fwv &= fwrite(spin->si_sofofr, l, (size_t)1, fd); // <sofofrom>
put_bytes(fd, l, 2); // <sofofromlen>
fwv &= fwrite(spin->si_sofofr, l, 1, fd); // <sofofrom>
l = (int)STRLEN(spin->si_sofoto);
put_bytes(fd, (long_u)l, 2); // <sofotolen>
fwv &= fwrite(spin->si_sofoto, l, (size_t)1, fd); // <sofoto>
l = STRLEN(spin->si_sofoto);
put_bytes(fd, l, 2); // <sofotolen>
fwv &= fwrite(spin->si_sofoto, l, 1, fd); // <sofoto>
}
// SN_WORDS: <word> ...
@@ -6811,22 +6801,22 @@ static int write_vim_spell(spellinfo_T *spin, char_u *fname)
// round 1: count the bytes
// round 2: write the bytes
for (round = 1; round <= 2; ++round) {
int todo;
int len = 0;
for (unsigned int round = 1; round <= 2; ++round) {
size_t todo;
size_t len = 0;
hashitem_T *hi;
todo = (int)spin->si_commonwords.ht_used;
todo = spin->si_commonwords.ht_used;
for (hi = spin->si_commonwords.ht_array; todo > 0; ++hi)
if (!HASHITEM_EMPTY(hi)) {
l = (int)STRLEN(hi->hi_key) + 1;
size_t l = STRLEN(hi->hi_key) + 1;
len += l;
if (round == 2) // <word>
fwv &= fwrite(hi->hi_key, (size_t)l, (size_t)1, fd);
fwv &= fwrite(hi->hi_key, l, 1, fd);
--todo;
}
if (round == 1)
put_bytes(fd, (long_u)len, 4); // <sectionlen>
put_bytes(fd, len, 4); // <sectionlen>
}
}
@@ -6835,10 +6825,9 @@ static int write_vim_spell(spellinfo_T *spin, char_u *fname)
if (!GA_EMPTY(&spin->si_map)) {
putc(SN_MAP, fd); // <sectionID>
putc(0, fd); // <sectionflags>
l = spin->si_map.ga_len;
put_bytes(fd, (long_u)l, 4); // <sectionlen>
fwv &= fwrite(spin->si_map.ga_data, (size_t)l, (size_t)1, fd);
// <mapstr>
size_t l = (size_t)spin->si_map.ga_len;
put_bytes(fd, l, 4); // <sectionlen>
fwv &= fwrite(spin->si_map.ga_data, l, 1, fd); // <mapstr>
}
// SN_SUGFILE: <timestamp>
@@ -6851,7 +6840,7 @@ static int write_vim_spell(spellinfo_T *spin, char_u *fname)
|| (spin->si_sofofr != NULL && spin->si_sofoto != NULL))) {
putc(SN_SUGFILE, fd); // <sectionID>
putc(0, fd); // <sectionflags>
put_bytes(fd, (long_u)8, 4); // <sectionlen>
put_bytes(fd, 8, 4); // <sectionlen>
// Set si_sugtime and write it to the file.
spin->si_sugtime = time(NULL);
@@ -6864,7 +6853,7 @@ static int write_vim_spell(spellinfo_T *spin, char_u *fname)
if (spin->si_nosplitsugs) {
putc(SN_NOSPLITSUGS, fd); // <sectionID>
putc(0, fd); // <sectionflags>
put_bytes(fd, (long_u)0, 4); // <sectionlen>
put_bytes(fd, 0, 4); // <sectionlen>
}
// SN_COMPOUND: compound info.
@@ -6874,28 +6863,27 @@ static int write_vim_spell(spellinfo_T *spin, char_u *fname)
putc(SN_COMPOUND, fd); // <sectionID>
putc(0, fd); // <sectionflags>
l = (int)STRLEN(spin->si_compflags);
for (int i = 0; i < spin->si_comppat.ga_len; ++i) {
l += (int)STRLEN(((char_u **)(spin->si_comppat.ga_data))[i]) + 1;
size_t l = STRLEN(spin->si_compflags);
assert(spin->si_comppat.ga_len >= 0);
for (size_t i = 0; i < (size_t)spin->si_comppat.ga_len; ++i) {
l += STRLEN(((char_u **)(spin->si_comppat.ga_data))[i]) + 1;
}
put_bytes(fd, (long_u)(l + 7), 4); // <sectionlen>
put_bytes(fd, l + 7, 4); // <sectionlen>
putc(spin->si_compmax, fd); // <compmax>
putc(spin->si_compminlen, fd); // <compminlen>
putc(spin->si_compsylmax, fd); // <compsylmax>
putc(0, fd); // for Vim 7.0b compatibility
putc(spin->si_compoptions, fd); // <compoptions>
put_bytes(fd, (long_u)spin->si_comppat.ga_len, 2);
// <comppatcount>
for (int i = 0; i < spin->si_comppat.ga_len; ++i) {
p = ((char_u **)(spin->si_comppat.ga_data))[i];
put_bytes(fd, (uintmax_t)spin->si_comppat.ga_len, 2); // <comppatcount>
for (size_t i = 0; i < (size_t)spin->si_comppat.ga_len; ++i) {
char_u *p = ((char_u **)(spin->si_comppat.ga_data))[i];
assert(STRLEN(p) < INT_MAX);
putc((int)STRLEN(p), fd); // <comppatlen>
fwv &= fwrite(p, (size_t)STRLEN(p), (size_t)1, fd);
// <comppattext>
fwv &= fwrite(p, STRLEN(p), 1, fd); // <comppattext>
}
// <compflags>
fwv &= fwrite(spin->si_compflags, (size_t)STRLEN(spin->si_compflags),
(size_t)1, fd);
fwv &= fwrite(spin->si_compflags, STRLEN(spin->si_compflags), 1, fd);
}
// SN_NOBREAK: NOBREAK flag
@@ -6904,7 +6892,7 @@ static int write_vim_spell(spellinfo_T *spin, char_u *fname)
putc(0, fd); // <sectionflags>
// It's empty, the presence of the section flags the feature.
put_bytes(fd, (long_u)0, 4); // <sectionlen>
put_bytes(fd, 0, 4); // <sectionlen>
}
// SN_SYLLABLE: syllable info.
@@ -6914,10 +6902,9 @@ static int write_vim_spell(spellinfo_T *spin, char_u *fname)
putc(SN_SYLLABLE, fd); // <sectionID>
putc(0, fd); // <sectionflags>
l = (int)STRLEN(spin->si_syllable);
put_bytes(fd, (long_u)l, 4); // <sectionlen>
fwv &= fwrite(spin->si_syllable, (size_t)l, (size_t)1, fd);
// <syllable>
size_t l = STRLEN(spin->si_syllable);
put_bytes(fd, l, 4); // <sectionlen>
fwv &= fwrite(spin->si_syllable, l, 1, fd); // <syllable>
}
// end of <SECTIONS>
@@ -6926,7 +6913,8 @@ static int write_vim_spell(spellinfo_T *spin, char_u *fname)
// <LWORDTREE> <KWORDTREE> <PREFIXTREE>
spin->si_memtot = 0;
for (round = 1; round <= 3; ++round) {
for (unsigned int round = 1; round <= 3; ++round) {
wordnode_T *tree;
if (round == 1)
tree = spin->si_foldroot->wn_sibling;
else if (round == 2)
@@ -6940,11 +6928,12 @@ static int write_vim_spell(spellinfo_T *spin, char_u *fname)
// Count the number of nodes. Needed to be able to allocate the
// memory when reading the nodes. Also fills in index for shared
// nodes.
nodecount = put_node(NULL, tree, 0, regionmask, round == 3);
size_t nodecount = (size_t)put_node(NULL, tree, 0, regionmask, round == 3);
// number of nodes in 4 bytes
put_bytes(fd, (long_u)nodecount, 4); // <nodecount>
spin->si_memtot += nodecount + nodecount * sizeof(int);
put_bytes(fd, nodecount, 4); // <nodecount>
assert(nodecount + nodecount * sizeof(int) < INT_MAX);
spin->si_memtot += (int)(nodecount + nodecount * sizeof(int));
// Write the nodes.
(void)put_node(fd, tree, 0, regionmask, round == 3);
@@ -7002,11 +6991,6 @@ put_node (
bool prefixtree // true for PREFIXTREE
)
{
int newindex = idx;
int siblingcount = 0;
wordnode_T *np;
int flags;
// If "node" is zero the tree is empty.
if (node == NULL)
return 0;
@@ -7015,7 +6999,8 @@ put_node (
node->wn_u1.index = idx;
// Count the number of siblings.
for (np = node; np != NULL; np = np->wn_sibling)
int siblingcount = 0;
for (wordnode_T *np = node; np != NULL; np = np->wn_sibling)
++siblingcount;
// Write the sibling count.
@@ -7023,7 +7008,7 @@ put_node (
putc(siblingcount, fd); // <siblingcount>
// Write each sibling byte and optionally extra info.
for (np = node; np != NULL; np = np->wn_sibling) {
for (wordnode_T *np = node; np != NULL; np = np->wn_sibling) {
if (np->wn_byte == 0) {
if (fd != NULL) {
// For a NUL byte (end of word) write the flags etc.
@@ -7039,10 +7024,10 @@ put_node (
putc(np->wn_flags, fd); // <pflags>
}
putc(np->wn_affixID, fd); // <affixID>
put_bytes(fd, (long_u)np->wn_region, 2); // <prefcondnr>
put_bytes(fd, (uintmax_t)np->wn_region, 2); // <prefcondnr>
} else {
// For word trees we write the flag/region items.
flags = np->wn_flags;
int flags = np->wn_flags;
if (regionmask != 0 && np->wn_region != regionmask)
flags |= WF_REGION;
if (np->wn_affixID != 0)
@@ -7054,7 +7039,7 @@ put_node (
if (np->wn_flags >= 0x100) {
putc(BY_FLAGS2, fd); // <byte>
putc(flags, fd); // <flags>
putc((unsigned)flags >> 8, fd); // <flags2>
putc((int)((unsigned)flags >> 8), fd); // <flags2>
} else {
putc(BY_FLAGS, fd); // <byte>
putc(flags, fd); // <flags>
@@ -7071,9 +7056,8 @@ put_node (
&& np->wn_child->wn_u2.wnode != node) {
// The child is written elsewhere, write the reference.
if (fd != NULL) {
putc(BY_INDEX, fd); // <byte>
// <nodeidx>
put_bytes(fd, (long_u)np->wn_child->wn_u1.index, 3);
putc(BY_INDEX, fd); // <byte>
put_bytes(fd, (uintmax_t)np->wn_child->wn_u1.index, 3); // <nodeidx>
}
} else if (np->wn_child->wn_u2.wnode == NULL)
// We will write the child below and give it an index.
@@ -7089,10 +7073,10 @@ put_node (
// Space used in the array when reading: one for each sibling and one for
// the count.
newindex += siblingcount + 1;
int newindex = idx + siblingcount + 1;
// Recursively dump the children of each sibling.
for (np = node; np != NULL; np = np->wn_sibling)
for (wordnode_T *np = node; np != NULL; np = np->wn_sibling)
if (np->wn_byte != 0 && np->wn_child->wn_u2.wnode == node)
newindex = put_node(fd, np->wn_child, newindex, regionmask,
prefixtree);
@@ -7440,16 +7424,8 @@ static int bytes2offset(char_u **pp)
// Write the .sug file in "fname".
static void sug_write(spellinfo_T *spin, char_u *fname)
{
FILE *fd;
wordnode_T *tree;
int nodecount;
int wcount;
char_u *line;
linenr_T lnum;
int len;
// Create the file. Note that an existing file is silently overwritten!
fd = mch_fopen((char *)fname, "w");
FILE *fd = mch_fopen((char *)fname, "w");
if (fd == NULL) {
EMSG2(_(e_notopen), fname);
return;
@@ -7471,7 +7447,7 @@ static void sug_write(spellinfo_T *spin, char_u *fname)
// <SUGWORDTREE>
spin->si_memtot = 0;
tree = spin->si_foldroot->wn_sibling;
wordnode_T *tree = spin->si_foldroot->wn_sibling;
// Clear the index and wnode fields in the tree.
clear_node(tree);
@@ -7479,28 +7455,31 @@ static void sug_write(spellinfo_T *spin, char_u *fname)
// Count the number of nodes. Needed to be able to allocate the
// memory when reading the nodes. Also fills in index for shared
// nodes.
nodecount = put_node(NULL, tree, 0, 0, false);
size_t nodecount = (size_t)put_node(NULL, tree, 0, 0, false);
// number of nodes in 4 bytes
put_bytes(fd, (long_u)nodecount, 4); // <nodecount>
spin->si_memtot += nodecount + nodecount * sizeof(int);
put_bytes(fd, nodecount, 4); // <nodecount>
assert(nodecount + nodecount * sizeof(int) < INT_MAX);
spin->si_memtot += (int)(nodecount + nodecount * sizeof(int));
// Write the nodes.
(void)put_node(fd, tree, 0, 0, false);
// <SUGTABLE>: <sugwcount> <sugline> ...
wcount = spin->si_spellbuf->b_ml.ml_line_count;
put_bytes(fd, (long_u)wcount, 4); // <sugwcount>
linenr_T wcount = spin->si_spellbuf->b_ml.ml_line_count;
assert(wcount >= 0);
put_bytes(fd, (uintmax_t)wcount, 4); // <sugwcount>
for (lnum = 1; lnum <= (linenr_T)wcount; ++lnum) {
for (linenr_T lnum = 1; lnum <= wcount; ++lnum) {
// <sugline>: <sugnr> ... NUL
line = ml_get_buf(spin->si_spellbuf, lnum, FALSE);
len = (int)STRLEN(line) + 1;
if (fwrite(line, (size_t)len, (size_t)1, fd) == 0) {
char_u *line = ml_get_buf(spin->si_spellbuf, lnum, FALSE);
size_t len = STRLEN(line) + 1;
if (fwrite(line, len, 1, fd) == 0) {
EMSG(_(e_write));
goto theend;
}
spin->si_memtot += len;
assert((size_t)spin->si_memtot + len <= INT_MAX);
spin->si_memtot += (int)len;
}
// Write another byte to check for errors.
@@ -8286,31 +8265,30 @@ static bool spell_iswordp_w(int *p, win_T *wp)
// When "fd" is NULL only count the length of what is written.
static int write_spell_prefcond(FILE *fd, garray_T *gap)
{
char_u *p;
int len;
int totlen;
size_t x = 1; // collect return value of fwrite()
assert(gap->ga_len >= 0);
if (fd != NULL)
put_bytes(fd, (long_u)gap->ga_len, 2); // <prefcondcnt>
totlen = 2 + gap->ga_len; // length of <prefcondcnt> and <condlen> bytes
put_bytes(fd, (uintmax_t)gap->ga_len, 2); // <prefcondcnt>
size_t totlen = 2 + (size_t)gap->ga_len; // <prefcondcnt> and <condlen> bytes
size_t x = 1; // collect return value of fwrite()
for (int i = 0; i < gap->ga_len; ++i) {
// <prefcond> : <condlen> <condstr>
p = ((char_u **)gap->ga_data)[i];
char_u *p = ((char_u **)gap->ga_data)[i];
if (p != NULL) {
len = (int)STRLEN(p);
size_t len = STRLEN(p);
if (fd != NULL) {
fputc(len, fd);
x &= fwrite(p, (size_t)len, (size_t)1, fd);
assert(len <= INT_MAX);
fputc((int)len, fd);
x &= fwrite(p, len, 1, fd);
}
totlen += len;
} else if (fd != NULL)
fputc(0, fd);
}
return totlen;
assert(totlen <= INT_MAX);
return (int)totlen;
}
// Case-fold "str[len]" into "buf[buflen]". The result is NUL terminated.

78
src/nvim/undo.c
View File

@@ -715,42 +715,40 @@ static void u_free_uhp(u_header_T *uhp)
static int serialize_header(FILE *fp, buf_T *buf, char_u *hash)
{
int len;
/* Start writing, first the magic marker and undo info version. */
if (fwrite(UF_START_MAGIC, (size_t)UF_START_MAGIC_LEN, (size_t)1, fp) != 1)
if (fwrite(UF_START_MAGIC, UF_START_MAGIC_LEN, 1, fp) != 1)
return FAIL;
put_bytes(fp, (long_u)UF_VERSION, 2);
put_bytes(fp, UF_VERSION, 2);
/* Write a hash of the buffer text, so that we can verify it is still the
* same when reading the buffer text. */
if (fwrite(hash, (size_t)UNDO_HASH_SIZE, (size_t)1, fp) != 1)
if (fwrite(hash, UNDO_HASH_SIZE, 1, fp) != 1)
return FAIL;
/* buffer-specific data */
put_bytes(fp, (long_u)buf->b_ml.ml_line_count, 4);
len = buf->b_u_line_ptr != NULL ? (int)STRLEN(buf->b_u_line_ptr) : 0;
put_bytes(fp, (long_u)len, 4);
put_bytes(fp, (uintmax_t)buf->b_ml.ml_line_count, 4);
size_t len = buf->b_u_line_ptr ? STRLEN(buf->b_u_line_ptr) : 0;
put_bytes(fp, len, 4);
if (len > 0 && fwrite(buf->b_u_line_ptr, len, 1, fp) != 1)
return FAIL;
put_bytes(fp, (long_u)buf->b_u_line_lnum, 4);
put_bytes(fp, (long_u)buf->b_u_line_colnr, 4);
put_bytes(fp, (uintmax_t)buf->b_u_line_lnum, 4);
put_bytes(fp, (uintmax_t)buf->b_u_line_colnr, 4);
/* Undo structures header data */
put_header_ptr(fp, buf->b_u_oldhead);
put_header_ptr(fp, buf->b_u_newhead);
put_header_ptr(fp, buf->b_u_curhead);
put_bytes(fp, (long_u)buf->b_u_numhead, 4);
put_bytes(fp, (long_u)buf->b_u_seq_last, 4);
put_bytes(fp, (long_u)buf->b_u_seq_cur, 4);
put_bytes(fp, (uintmax_t)buf->b_u_numhead, 4);
put_bytes(fp, (uintmax_t)buf->b_u_seq_last, 4);
put_bytes(fp, (uintmax_t)buf->b_u_seq_cur, 4);
put_time(fp, buf->b_u_time_cur);
/* Optional fields. */
putc(4, fp);
putc(UF_LAST_SAVE_NR, fp);
put_bytes(fp, (long_u)buf->b_u_save_nr_last, 4);
put_bytes(fp, (uintmax_t)buf->b_u_save_nr_last, 4);
putc(0, fp); /* end marker */
@@ -759,22 +757,19 @@ static int serialize_header(FILE *fp, buf_T *buf, char_u *hash)
static int serialize_uhp(FILE *fp, buf_T *buf, u_header_T *uhp)
{
int i;
u_entry_T *uep;
if (put_bytes(fp, (long_u)UF_HEADER_MAGIC, 2) == FAIL)
if (put_bytes(fp, UF_HEADER_MAGIC, 2) == FAIL)
return FAIL;
put_header_ptr(fp, uhp->uh_next.ptr);
put_header_ptr(fp, uhp->uh_prev.ptr);
put_header_ptr(fp, uhp->uh_alt_next.ptr);
put_header_ptr(fp, uhp->uh_alt_prev.ptr);
put_bytes(fp, uhp->uh_seq, 4);
put_bytes(fp, (uintmax_t)uhp->uh_seq, 4);
serialize_pos(uhp->uh_cursor, fp);
put_bytes(fp, (long_u)uhp->uh_cursor_vcol, 4);
put_bytes(fp, (long_u)uhp->uh_flags, 2);
put_bytes(fp, (uintmax_t)uhp->uh_cursor_vcol, 4);
put_bytes(fp, (uintmax_t)uhp->uh_flags, 2);
/* Assume NMARKS will stay the same. */
for (i = 0; i < NMARKS; ++i)
for (size_t i = 0; i < NMARKS; ++i)
serialize_pos(uhp->uh_namedm[i], fp);
serialize_visualinfo(&uhp->uh_visual, fp);
put_time(fp, uhp->uh_time);
@@ -782,17 +777,17 @@ static int serialize_uhp(FILE *fp, buf_T *buf, u_header_T *uhp)
/* Optional fields. */
putc(4, fp);
putc(UHP_SAVE_NR, fp);
put_bytes(fp, (long_u)uhp->uh_save_nr, 4);
put_bytes(fp, (uintmax_t)uhp->uh_save_nr, 4);
putc(0, fp); /* end marker */
/* Write all the entries. */
for (uep = uhp->uh_entry; uep != NULL; uep = uep->ue_next) {
put_bytes(fp, (long_u)UF_ENTRY_MAGIC, 2);
for (u_entry_T *uep = uhp->uh_entry; uep; uep = uep->ue_next) {
put_bytes(fp, UF_ENTRY_MAGIC, 2);
if (serialize_uep(fp, buf, uep) == FAIL)
return FAIL;
}
put_bytes(fp, (long_u)UF_ENTRY_END_MAGIC, 2);
put_bytes(fp, UF_ENTRY_END_MAGIC, 2);
return OK;
}
@@ -875,16 +870,13 @@ static u_header_T *unserialize_uhp(FILE *fp, char_u *file_name)
*/
static int serialize_uep(FILE *fp, buf_T *buf, u_entry_T *uep)
{
int i;
size_t len;
put_bytes(fp, (long_u)uep->ue_top, 4);
put_bytes(fp, (long_u)uep->ue_bot, 4);
put_bytes(fp, (long_u)uep->ue_lcount, 4);
put_bytes(fp, (long_u)uep->ue_size, 4);
for (i = 0; i < uep->ue_size; ++i) {
len = STRLEN(uep->ue_array[i]);
if (put_bytes(fp, (long_u)len, 4) == FAIL)
put_bytes(fp, (uintmax_t)uep->ue_top, 4);
put_bytes(fp, (uintmax_t)uep->ue_bot, 4);
put_bytes(fp, (uintmax_t)uep->ue_lcount, 4);
put_bytes(fp, (uintmax_t)uep->ue_size, 4);
for (size_t i = 0; i < (size_t)uep->ue_size; ++i) {
size_t len = STRLEN(uep->ue_array[i]);
if (put_bytes(fp, len, 4) == FAIL)
return FAIL;
if (len > 0 && fwrite(uep->ue_array[i], len, 1, fp) != 1)
return FAIL;
@@ -938,9 +930,9 @@ static u_entry_T *unserialize_uep(FILE *fp, int *error, char_u *file_name)
*/
static void serialize_pos(pos_T pos, FILE *fp)
{
put_bytes(fp, (long_u)pos.lnum, 4);
put_bytes(fp, (long_u)pos.col, 4);
put_bytes(fp, (long_u)pos.coladd, 4);
put_bytes(fp, (uintmax_t)pos.lnum, 4);
put_bytes(fp, (uintmax_t)pos.col, 4);
put_bytes(fp, (uintmax_t)pos.coladd, 4);
}
/*
@@ -966,8 +958,8 @@ static void serialize_visualinfo(visualinfo_T *info, FILE *fp)
{
serialize_pos(info->vi_start, fp);
serialize_pos(info->vi_end, fp);
put_bytes(fp, (long_u)info->vi_mode, 4);
put_bytes(fp, (long_u)info->vi_curswant, 4);
put_bytes(fp, (uintmax_t)info->vi_mode, 4);
put_bytes(fp, (uintmax_t)info->vi_curswant, 4);
}
/*
@@ -987,7 +979,7 @@ static void unserialize_visualinfo(visualinfo_T *info, FILE *fp)
* pointers when reading. */
static void put_header_ptr(FILE *fp, u_header_T *uhp)
{
put_bytes(fp, (long_u)(uhp != NULL ? uhp->uh_seq : 0), 4);
put_bytes(fp, (uintmax_t)(uhp != NULL ? uhp->uh_seq : 0), 4);
}
/*
@@ -1178,7 +1170,7 @@ void u_write_undo(char_u *name, int forceit, buf_T *buf, char_u *hash)
uhp = uhp->uh_next.ptr;
}
if (put_bytes(fp, (long_u)UF_HEADER_END_MAGIC, 2) == OK)
if (put_bytes(fp, UF_HEADER_END_MAGIC, 2) == OK)
write_ok = true;
#ifdef U_DEBUG
if (headers_written != buf->b_u_numhead) {