diff options
Diffstat (limited to 'src')
| -rw-r--r-- | src/nvim/misc2.c | 13 | ||||
| -rw-r--r-- | src/nvim/spell.c | 264 | ||||
| -rw-r--r-- | src/nvim/undo.c | 78 |
3 files changed, 161 insertions, 194 deletions
diff --git a/src/nvim/misc2.c b/src/nvim/misc2.c index e6531ee1b2..d624f52879 100644 --- a/src/nvim/misc2.c +++ b/src/nvim/misc2.c @@ -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; } diff --git a/src/nvim/spell.c b/src/nvim/spell.c index 4759b4efa6..b8713909b8 100644 --- a/src/nvim/spell.c +++ b/src/nvim/spell.c @@ -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. diff --git a/src/nvim/undo.c b/src/nvim/undo.c index 9a3da5bcdb..0dddfe703e 100644 --- a/src/nvim/undo.c +++ b/src/nvim/undo.c @@ -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) { |