IntenseFinance/neovim
3
0
Fork 0
mirror of https://github.com/neovim/neovim.git synced 2025-02-25 18:55:25 -06:00
Code Issues Packages Projects Releases Wiki Activity

Merge pull request #757 from elmart/remove-long_u

Browse Source 
Remove project-specific integer types: long_u. (1)
This commit is contained in:
Justin M. Keyes 2014-05-24 01:47:52 -04:00
commit f75d4bc3e1
7 changed files with 190 additions and 187 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

38
clint-files.txt
View File

@ -1,3 +1,16 @@
src/nvim/api/buffer.c
src/nvim/api/buffer.h
src/nvim/api/defs.h
src/nvim/api/helpers.c
src/nvim/api/helpers.h
src/nvim/api/tabpage.c
src/nvim/api/tabpage.h
src/nvim/api/vim.c
src/nvim/api/vim.h
src/nvim/api/window.c
src/nvim/api/window.h
src/nvim/hashtab.c
src/nvim/hashtab.h
src/nvim/indent.c
src/nvim/indent.h
src/nvim/log.c
@ -7,34 +20,23 @@ src/nvim/map.h
src/nvim/map_defs.h
src/nvim/os/env.c
src/nvim/os/event.c
src/nvim/os/event_defs.h
src/nvim/os/event.h
src/nvim/os/event_defs.h
src/nvim/os/input.c
src/nvim/os/input.h
src/nvim/os/rstream.c
src/nvim/os/rstream_defs.h
src/nvim/os/rstream.h
src/nvim/os/job.c
src/nvim/os/job_defs.h
src/nvim/os/job.h
src/nvim/os/job_defs.h
src/nvim/os/mem.c
src/nvim/os/msgpack_rpc.c
src/nvim/os/msgpack_rpc.h
src/nvim/os/os.h
src/nvim/os/rstream.c
src/nvim/os/rstream.h
src/nvim/os/rstream_defs.h
src/nvim/os/shell.c
src/nvim/os/shell.h
src/nvim/os/signal.c
src/nvim/os/signal.h
src/nvim/os/time.c
src/nvim/os/time.h
src/nvim/os/msgpack_rpc.h
src/nvim/os/msgpack_rpc.c
src/nvim/api/defs.h
src/nvim/api/buffer.h
src/nvim/api/buffer.c
src/nvim/api/helpers.h
src/nvim/api/helpers.c
src/nvim/api/tabpage.h
src/nvim/api/tabpage.c
src/nvim/api/window.h
src/nvim/api/window.c
src/nvim/api/vim.h
src/nvim/api/vim.c

1
src/nvim/CMakeLists.txt
View File

@ -37,6 +37,7 @@ set(CONV_SRCS
api.c
arabic.c
garray.c
hashtab.c
memory.c
map.c
os/env.c

213
src/nvim/hashtab.c
View File

@ -18,6 +18,7 @@
/// of the entries is empty to keep the lookup efficient (at the cost of extra
/// memory).
#include <stdbool.h>
#include <string.h>
#include "nvim/vim.h"
@ -29,12 +30,9 @@
// Magic value for algorithm that walks through the array.
#define PERTURB_SHIFT 5
static int hash_may_resize(hashtab_T *ht, int minitems);
static int hash_may_resize(hashtab_T *ht, size_t minitems);
/// Initialize an empty hash table.
///
/// @param ht
void hash_init(hashtab_T *ht)
{
// This zeroes all "ht_" entries and all the "hi_key" in "ht_smallarray".
@ -43,10 +41,10 @@ void hash_init(hashtab_T *ht)
ht->ht_mask = HT_INIT_SIZE - 1;
}
/// Free the array of a hash table. Does not free the items it contains!
/// If "ht" is not freed then you should call hash_init() next!
/// Free the array of a hash table without freeing contained values.
///
/// @param ht
/// If "ht" is not freed (after calling this) then you should call hash_init()
/// right next!
void hash_clear(hashtab_T *ht)
{
if (ht->ht_array != ht->ht_smallarray) {
@ -54,20 +52,13 @@ void hash_clear(hashtab_T *ht)
}
}
/// Free the array of a hash table and all the keys it contains. The keys must
/// have been allocated. "off" is the offset from the start of the allocate
/// memory to the location of the key (it's always positive).
/// Free the array of a hash table and all contained values.
///
/// @param ht
/// @param off
void hash_clear_all(hashtab_T *ht, int off)
/// @param off the offset from start of value to start of key (@see hashitem_T).
void hash_clear_all(hashtab_T *ht, unsigned int off)
{
long todo;
hashitem_T *hi;
todo = (long)ht->ht_used;
for (hi = ht->ht_array; todo > 0; ++hi) {
size_t todo = ht->ht_used;
for (hashitem_T *hi = ht->ht_array; todo > 0; ++hi) {
if (!HASHITEM_EMPTY(hi)) {
free(hi->hi_key - off);
todo--;
@ -76,17 +67,15 @@ void hash_clear_all(hashtab_T *ht, int off)
hash_clear(ht);
}
/// Find "key" in hashtable "ht". "key" must not be NULL.
/// Always returns a pointer to a hashitem. If the item was not found then
/// HASHITEM_EMPTY() is TRUE. The pointer is then the place where the key
/// would be added.
/// WARNING: The returned pointer becomes invalid when the hashtable is changed
/// (adding, setting or removing an item)!
/// Find item for given "key" in hashtable "ht".
///
/// @param ht
/// @param key
/// @param key The key of the looked-for item. Must not be NULL.
///
/// @return Pointer to the hashitem stored with the given key.
/// @return Pointer to the hash item corresponding to the given key.
/// If not found, then return pointer to the empty item that would be
/// used for that key.
/// WARNING: Returned pointer becomes invalid as soon as the hash table
/// is changed in any way.
hashitem_T* hash_find(hashtab_T *ht, char_u *key)
{
return hash_lookup(ht, key, hash_hash(key));
@ -94,18 +83,16 @@ hashitem_T* hash_find(hashtab_T *ht, char_u *key)
/// Like hash_find(), but caller computes "hash".
///
/// @param ht
/// @param key
/// @param hash
/// @param key The key of the looked-for item. Must not be NULL.
/// @param hash The precomputed hash for the key.
///
/// @return Pointer to the hashitem stored with the given key.
/// @return Pointer to the hashitem corresponding to the given key.
/// If not found, then return pointer to the empty item that would be
/// used for that key.
/// WARNING: Returned pointer becomes invalid as soon as the hash table
/// is changed in any way.
hashitem_T* hash_lookup(hashtab_T *ht, char_u *key, hash_T hash)
{
hash_T perturb;
hashitem_T *freeitem;
hashitem_T *hi;
unsigned idx;
#ifdef HT_DEBUG
hash_count_lookup++;
#endif // ifdef HT_DEBUG
@ -114,19 +101,18 @@ hashitem_T* hash_lookup(hashtab_T *ht, char_u *key, hash_T hash)
// - return if there is no item at all
// - skip over a removed item
// - return if the item matches
idx = (unsigned)(hash & ht->ht_mask);
hi = &ht->ht_array[idx];
hash_T idx = hash & ht->ht_mask;
hashitem_T *hi = &ht->ht_array[idx];
if (hi->hi_key == NULL) {
return hi;
}
hashitem_T *freeitem = NULL;
if (hi->hi_key == HI_KEY_REMOVED) {
freeitem = hi;
} else if ((hi->hi_hash == hash) && (STRCMP(hi->hi_key, key) == 0)) {
return hi;
} else {
freeitem = NULL;
}
// Need to search through the table to find the key. The algorithm
@ -136,7 +122,7 @@ hashitem_T* hash_lookup(hashtab_T *ht, char_u *key, hash_T hash)
// When we run into a NULL key it's clear that the key isn't there.
// Return the first available slot found (can be a slot of a removed
// item).
for (perturb = hash;; perturb >>= PERTURB_SHIFT) {
for (hash_T perturb = hash;; perturb >>= PERTURB_SHIFT) {
#ifdef HT_DEBUG
// count a "miss" for hashtab lookup
hash_count_perturb++;
@ -161,6 +147,7 @@ hashitem_T* hash_lookup(hashtab_T *ht, char_u *key, hash_T hash)
}
/// Print the efficiency of hashtable lookups.
///
/// Useful when trying different hash algorithms.
/// Called when exiting.
void hash_debug_results(void)
@ -176,12 +163,13 @@ void hash_debug_results(void)
#endif // ifdef HT_DEBUG
}
/// Add item with key "key" to hashtable "ht".
/// Add item for key "key" to hashtable "ht".
///
/// @param ht
/// @param key
/// @param key Pointer to the key for the new item. The key has to be contained
/// in the new item (@see hashitem_T). Must not be NULL.
///
/// @returns FAIL when out of memory or the key is already present.
/// @return OK if success.
/// FAIL if key already present, or out of memory.
int hash_add(hashtab_T *ht, char_u *key)
{
hash_T hash = hash_hash(key);
@ -193,16 +181,16 @@ int hash_add(hashtab_T *ht, char_u *key)
return hash_add_item(ht, hi, key, hash);
}
/// Add item "hi" with "key" to hashtable "ht". "key" must not be NULL and
/// "hi" must have been obtained with hash_lookup() and point to an empty item.
/// "hi" is invalid after this!
/// Add item "hi" for key "key" to hashtable "ht".
///
/// @param ht
/// @param hi
/// @param key
/// @param hash
/// @param hi The hash item to be used. Must have been obtained through
/// hash_lookup() and point to an empty item.
/// @param key Pointer to the key for the new item. The key has to be contained
/// in the new item (@see hashitem_T). Must not be NULL.
/// @param hash The precomputed hash value for the key.
///
/// @returns OK or FAIL (out of memory).
/// @return OK if success.
/// FAIL if out of memory.
int hash_add_item(hashtab_T *ht, hashitem_T *hi, char_u *key, hash_T hash)
{
// If resizing failed before and it fails again we can't add an item.
@ -221,13 +209,12 @@ int hash_add_item(hashtab_T *ht, hashitem_T *hi, char_u *key, hash_T hash)
return hash_may_resize(ht, 0);
}
/// Remove item "hi" from hashtable "ht". "hi" must have been obtained with
/// hash_lookup().
/// Remove item "hi" from hashtable "ht".
///
/// The caller must take care of freeing the item itself.
/// Caller must take care of freeing the item itself.
///
/// @param ht
/// @param hi
/// @param hi The hash item to be removed.
/// It must have been obtained with hash_lookup().
void hash_remove(hashtab_T *ht, hashitem_T *hi)
{
ht->ht_used--;
@ -235,44 +222,37 @@ void hash_remove(hashtab_T *ht, hashitem_T *hi)
hash_may_resize(ht, 0);
}
/// Lock a hashtable: prevent that ht_array changes.
/// Lock hashtable (prevent changes in ht_array).
///
/// Don't use this when items are to be added!
/// Must call hash_unlock() later.
///
/// @param ht
void hash_lock(hashtab_T *ht)
{
ht->ht_locked++;
}
/// Unlock a hashtable: allow ht_array changes again.
/// Table will be resized (shrink) when necessary.
/// Unlock hashtable (allow changes in ht_array again).
///
/// Table will be resized (shrunk) when necessary.
/// This must balance a call to hash_lock().
void hash_unlock(hashtab_T *ht)
{
ht->ht_locked--;
(void)hash_may_resize(ht, 0);
hash_may_resize(ht, 0);
}
/// Shrink a hashtable when there is too much empty space.
/// Grow a hashtable when there is not enough empty space.
/// Resize hastable (new size can be given or automatically computed).
///
/// @param ht
/// @param minitems minimal number of items
/// @param minitems Minimum number of items the new table should hold.
/// If zero, new size will depend on currently used items:
/// - Shrink when too much empty space.
/// - Grow when not enough empty space.
/// If non-zero, passed minitems will be used.
///
/// @returns OK or FAIL (out of memory).
static int hash_may_resize(hashtab_T *ht, int minitems)
/// @return OK if success.
/// FAIL if out of memory.
static int hash_may_resize(hashtab_T *ht, size_t minitems)
{
hashitem_T temparray[HT_INIT_SIZE];
hashitem_T *oldarray, *newarray;
hashitem_T *olditem, *newitem;
unsigned newi;
int todo;
long_u oldsize, newsize;
long_u minsize;
long_u newmask;
hash_T perturb;
// Don't resize a locked table.
if (ht->ht_locked > 0) {
return OK;
@ -288,8 +268,9 @@ static int hash_may_resize(hashtab_T *ht, int minitems)
}
#endif // ifdef HT_DEBUG
size_t minsize;
if (minitems == 0) {
// Return quickly for small tables with at least two NULL items. NULL
// Return quickly for small tables with at least two NULL items.
// items are required for the lookup to decide a key isn't there.
if ((ht->ht_filled < HT_INIT_SIZE - 1)
&& (ht->ht_array == ht->ht_smallarray)) {
@ -300,7 +281,7 @@ static int hash_may_resize(hashtab_T *ht, int minitems)
// removed items, so that they get cleaned up).
// Shrink the array when it's less than 1/5 full. When growing it is
// at least 1/4 full (avoids repeated grow-shrink operations)
oldsize = ht->ht_mask + 1;
size_t oldsize = ht->ht_mask + 1;
if ((ht->ht_filled * 3 < oldsize * 2) && (ht->ht_used > oldsize / 5)) {
return OK;
}
@ -314,16 +295,15 @@ static int hash_may_resize(hashtab_T *ht, int minitems)
}
} else {
// Use specified size.
if ((long_u)minitems < ht->ht_used) {
if (minitems < ht->ht_used) {
// just in case...
minitems = (int)ht->ht_used;
minitems = ht->ht_used;
}
// array is up to 2/3 full
minsize = minitems * 3 / 2;
}
newsize = HT_INIT_SIZE;
size_t newsize = HT_INIT_SIZE;
while (newsize < minsize) {
// make sure it's always a power of 2
newsize <<= 1;
@ -333,40 +313,37 @@ static int hash_may_resize(hashtab_T *ht, int minitems)
}
}
if (newsize == HT_INIT_SIZE) {
// Use the small array inside the hashdict structure.
newarray = ht->ht_smallarray;
if (ht->ht_array == newarray) {
// Moving from ht_smallarray to ht_smallarray! Happens when there
// are many removed items. Copy the items to be able to clean up
// removed items.
memmove(temparray, newarray, sizeof(temparray));
oldarray = temparray;
} else {
oldarray = ht->ht_array;
}
} else {
// Allocate an array.
newarray = xmalloc(sizeof(hashitem_T) * newsize);
oldarray = ht->ht_array;
}
memset(newarray, 0, (size_t)(sizeof(hashitem_T) * newsize));
bool newarray_is_small = newsize == HT_INIT_SIZE;
bool keep_smallarray = newarray_is_small
&& ht->ht_array == ht->ht_smallarray;
// Make sure that oldarray and newarray do not overlap,
// so that copying is possible.
hashitem_T temparray[HT_INIT_SIZE];
hashitem_T *oldarray = keep_smallarray
? memcpy(temparray, ht->ht_smallarray, sizeof(temparray))
: ht->ht_array;
hashitem_T *newarray = newarray_is_small
? ht->ht_smallarray
: xmalloc(sizeof(hashitem_T) * newsize);
memset(newarray, 0, sizeof(hashitem_T) * newsize);
// Move all the items from the old array to the new one, placing them in
// the right spot. The new array won't have any removed items, thus this
// is also a cleanup action.
newmask = newsize - 1;
todo = (int)ht->ht_used;
hash_T newmask = newsize - 1;
size_t todo = ht->ht_used;
for (olditem = oldarray; todo > 0; ++olditem) {
for (hashitem_T *olditem = oldarray; todo > 0; ++olditem) {
if (!HASHITEM_EMPTY(olditem)) {
// The algorithm to find the spot to add the item is identical to
// the algorithm to find an item in hash_lookup(). But we only
// need to search for a NULL key, thus it's simpler.
newi = (unsigned)(olditem->hi_hash & newmask);
newitem = &newarray[newi];
hash_T newi = olditem->hi_hash & newmask;
hashitem_T *newitem = &newarray[newi];
if (newitem->hi_key != NULL) {
for (perturb = olditem->hi_hash;; perturb >>= PERTURB_SHIFT) {
for (hash_T perturb = olditem->hi_hash;; perturb >>= PERTURB_SHIFT) {
newi = 5 * newi + perturb + 1;
newitem = &newarray[newi & newmask];
if (newitem->hi_key == NULL) {
@ -385,33 +362,29 @@ static int hash_may_resize(hashtab_T *ht, int minitems)
ht->ht_array = newarray;
ht->ht_mask = newmask;
ht->ht_filled = ht->ht_used;
ht->ht_error = FALSE;
ht->ht_error = false;
return OK;
}
/// Get the hash number for a key.
///
/// If you think you know a better hash function: Compile with HT_DEBUG set and
/// run a script that uses hashtables a lot. Vim will then print statistics
/// when exiting. Try that with the current hash algorithm and yours. The
/// lower the percentage the better.
///
/// @param key
///
/// @return Hash number for the key.
hash_T hash_hash(char_u *key)
{
hash_T hash;
char_u *p;
hash_T hash = *key;
if ((hash = *key) == 0) {
if (hash == 0) {
// Empty keys are not allowed, but we don't want to crash if we get one.
return (hash_T) 0;
}
p = key + 1;
// A simplistic algorithm that appears to do very well.
// Suggested by George Reilly.
char_u *p = key + 1;
while (*p != NUL) {
hash = hash * 101 + *p++;
}

93
src/nvim/hashtab.h
View File

@ -1,56 +1,83 @@
#ifndef NVIM_HASHTAB_H
#define NVIM_HASHTAB_H
/* Item for a hashtable. "hi_key" can be one of three values:
* NULL: Never been used
* HI_KEY_REMOVED: Entry was removed
* Otherwise: Used item, pointer to the actual key; this usually is
* inside the item, subtract an offset to locate the item.
* This reduces the size of hashitem by 1/3.
*/
#include <stdbool.h>
#include "nvim/vim.h"
/// Type for hash number (hash calculation result).
typedef size_t hash_T;
/// The address of "hash_removed" is used as a magic number
/// for hi_key to indicate a removed item.
#define HI_KEY_REMOVED &hash_removed
#define HASHITEM_EMPTY(hi) ((hi)->hi_key == NULL \
|| (hi)->hi_key == &hash_removed)
/// A hastable item.
///
/// Each item has a NUL terminated string key.
/// A key can appear only once in the table.
///
/// A hash number is computed from the key for quick lookup. When the hashes
/// of two different keys point to the same entry an algorithm is used to
/// iterate over other entries in the table until the right one is found.
/// To make the iteration work removed keys are different from entries where a
/// key was never present.
///
/// Note that this does not contain a pointer to the key and another pointer to
/// the value. Instead, it is assumed that the key is contained within the
/// value, so that you can get a pointer to the value subtracting an offset from
/// the pointer to the key.
/// This reduces the size of this item by 1/3.
typedef struct hashitem_S {
long_u hi_hash; /* cached hash number of hi_key */
/// Cached hash number for hi_key.
hash_T hi_hash;
/// Item key.
///
/// Possible values mean the following:
/// NULL : Item was never used.
/// HI_KEY_REMOVED : Item was removed.
/// (Any other pointer value) : Item is currently being used.
char_u *hi_key;
} hashitem_T;
/* The address of "hash_removed" is used as a magic number for hi_key to
* indicate a removed item. */
#define HI_KEY_REMOVED &hash_removed
#define HASHITEM_EMPTY(hi) ((hi)->hi_key == NULL || (hi)->hi_key == \
&hash_removed)
/* Initial size for a hashtable. Our items are relatively small and growing
* is expensive, thus use 16 as a start. Must be a power of 2. */
/// Initial size for a hashtable.
/// Our items are relatively small and growing is expensive, thus start with 16.
/// Must be a power of 2.
#define HT_INIT_SIZE 16
/// An array-based hashtable.
///
/// Keys are NUL terminated strings. They cannot be repeated within a table.
/// Values are of any type.
///
/// The hashtable grows to accommodate more entries when needed.
typedef struct hashtable_S {
long_u ht_mask; /* mask used for hash value (nr of items in
* array is "ht_mask" + 1) */
long_u ht_used; /* number of items used */
long_u ht_filled; /* number of items used + removed */
int ht_locked; /* counter for hash_lock() */
int ht_error; /* when set growing failed, can't add more
items before growing works */
hashitem_T *ht_array; /* points to the array, allocated when it's
not "ht_smallarray" */
hashitem_T ht_smallarray[HT_INIT_SIZE]; /* initial array */
hash_T ht_mask; /// mask used for hash value
/// (nr of items in array is "ht_mask" + 1)
size_t ht_used; /// number of items used
size_t ht_filled; /// number of items used or removed
int ht_locked; /// counter for hash_lock()
bool ht_error; /// when set growing failed, can't add more
/// items before growing works
hashitem_T *ht_array; /// points to the array, allocated when it's
/// not "ht_smallarray"
hashitem_T ht_smallarray[HT_INIT_SIZE]; /// initial array
} hashtab_T;
typedef long_u hash_T; /* Type for hi_hash */
/* hashtab.c */
// hashtab.c
void hash_init(hashtab_T *ht);
void hash_clear(hashtab_T *ht);
void hash_clear_all(hashtab_T *ht, int off);
void hash_clear_all(hashtab_T *ht, unsigned int off);
hashitem_T *hash_find(hashtab_T *ht, char_u *key);
hashitem_T *hash_lookup(hashtab_T *ht, char_u *key, hash_T hash);
void hash_debug_results(void);
int hash_add(hashtab_T *ht, char_u *key);
int hash_add_item(hashtab_T *ht, hashitem_T *hi, char_u *key,
hash_T hash);
int hash_add_item(hashtab_T *ht, hashitem_T *hi, char_u *key, hash_T hash);
void hash_remove(hashtab_T *ht, hashitem_T *hi);
void hash_lock(hashtab_T *ht);
void hash_unlock(hashtab_T *ht);
hash_T hash_hash(char_u *key);
#endif /* NVIM_HASHTAB_H */
#endif // NVIM_HASHTAB_H

4
src/nvim/memory.c
View File

@ -84,7 +84,7 @@ void *verbose_try_malloc(size_t size)
{
void *ret = try_malloc(size);
if (!ret) {
do_outofmem_msg((long_u)size);
do_outofmem_msg(size);
}
return ret;
}
@ -214,7 +214,7 @@ void *xmemdup(const void *data, size_t len)
* Avoid repeating the error message many times (they take 1 second each).
* Did_outofmem_msg is reset when a character is read.
*/
void do_outofmem_msg(long_u size)
void do_outofmem_msg(size_t size)
{
if (!did_outofmem_msg) {
/* Don't hide this message */

2
src/nvim/memory.h
View File

@ -134,7 +134,7 @@ char *xstpncpy(char *restrict dst, const char *restrict src, size_t maxlen);
void *xmemdup(const void *data, size_t len)
FUNC_ATTR_MALLOC FUNC_ATTR_WARN_UNUSED_RESULT FUNC_ATTR_NONNULL_RET;
void do_outofmem_msg(long_u size);
void do_outofmem_msg(size_t size);
void free_all_mem(void);
#endif

2
src/nvim/screen.c
View File

@ -6288,7 +6288,7 @@ retry:
|| outofmem) {
if (ScreenLines != NULL || !done_outofmem_msg) {
/* guess the size */
do_outofmem_msg((long_u)((Rows + 1) * Columns));
do_outofmem_msg((Rows + 1) * Columns);
/* Remember we did this to avoid getting outofmem messages over
* and over again. */