luc14n0/glib
1
0
Fork 0
mirror of https://gitlab.gnome.org/GNOME/glib.git synced 2024-12-25 06:56:14 +01:00
Code Issues Packages Projects Releases Wiki Activity

Fix a bunch of typos in header comments. (#102422, Morten Welinder)

Browse Source 
2003-02-06  Matthias Clasen  <maclas@gmx.de>

	* glib/gmessages.h:
	* glib/gmem.h:
	* glib/ghash.h:
	* glib/gasyncqueue.h:
	* glib/garray.h:
	* glib/ghook.h:
	* glib/gtypes.h: Fix a bunch of typos in header comments.
	(#102422, Morten Welinder)
This commit is contained in:
Matthias Clasen 2003-02-06 19:57:14 +00:00 committed by Matthias Clasen
parent 5d48d565e3
commit 7802271bf0
7 changed files with 25 additions and 26 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

9
glib/garray.h
View File

@ -53,9 +53,9 @@ struct _GPtrArray
guint len;
};
/* Resizable arrays, remove fills any cleared spot and shortens the
/* Resizable arrays. remove fills any cleared spot and shortens the
* array, while preserving the order. remove_fast will distort the
* order by moving the last element to the position of the removed
* order by moving the last element to the position of the removed.
*/
#define g_array_append_val(a,v) g_array_append_vals (a, &(v), 1)
@ -95,9 +95,8 @@ void g_array_sort_with_data (GArray *array,
gpointer user_data);
/* Resizable pointer array. This interface is much less complicated
* than the above. Add appends appends a pointer. Remove fills any
* cleared spot and shortens the array. remove_fast will again distort
* order.
* than the above. Add appends a pointer. Remove fills any cleared
* spot and shortens the array. remove_fast will again distort order.
*/
#define g_ptr_array_index(array,index_) ((array)->pdata)[index_]
GPtrArray* g_ptr_array_new (void);

24
glib/gasyncqueue.h
View File

@ -39,9 +39,9 @@ typedef struct _GAsyncQueue GAsyncQueue;
/* Get a new GAsyncQueue with the ref_count 1 */
GAsyncQueue* g_async_queue_new (void);
/* Lock and unlock an GAsyncQueue, all functions lock the queue for
/* Lock and unlock a GAsyncQueue. All functions lock the queue for
* themselves, but in certain cirumstances you want to hold the lock longer,
* thus you lock the queue, call the *_unlocked functions and unlock it again
* thus you lock the queue, call the *_unlocked functions and unlock it again.
*/
void g_async_queue_lock (GAsyncQueue *queue);
void g_async_queue_unlock (GAsyncQueue *queue);
@ -52,39 +52,39 @@ void g_async_queue_unlock (GAsyncQueue *queue);
* lock (g_async_queue_unref) and one to call, when you already hold
* the lock (g_async_queue_unref_and_unlock). After that however, you
* don't hold the lock anymore and the Queue might in fact be
* destroyed, if you unrefed to zero */
* destroyed, if you unrefed to zero. */
void g_async_queue_ref (GAsyncQueue *queue);
void g_async_queue_ref_unlocked (GAsyncQueue *queue);
void g_async_queue_unref (GAsyncQueue *queue);
void g_async_queue_unref_and_unlock (GAsyncQueue *queue);
/* Push data into the async queue. Must not be NULL */
/* Push data into the async queue. Must not be NULL. */
void g_async_queue_push (GAsyncQueue *queue,
gpointer data);
void g_async_queue_push_unlocked (GAsyncQueue *queue,
gpointer data);
/* Pop data from the async queue, when no data is there, the thread is blocked
* until data arrives */
/* Pop data from the async queue. When no data is there, the thread is blocked
* until data arrives. */
gpointer g_async_queue_pop (GAsyncQueue *queue);
gpointer g_async_queue_pop_unlocked (GAsyncQueue *queue);
/* Try to pop data, NULL is returned in case of empty queue */
/* Try to pop data. NULL is returned in case of empty queue. */
gpointer g_async_queue_try_pop (GAsyncQueue *queue);
gpointer g_async_queue_try_pop_unlocked (GAsyncQueue *queue);
/* Wait for data until at maximum until end_time is reached, NULL is returned
* in case of empty queue*/
/* Wait for data until at maximum until end_time is reached. NULL is returned
* in case of empty queue. */
gpointer g_async_queue_timed_pop (GAsyncQueue *queue,
GTimeVal *end_time);
gpointer g_async_queue_timed_pop_unlocked (GAsyncQueue *queue,
GTimeVal *end_time);
/* Return the length of the queue, negative values mean, that threads
* are waiting, positve values mean, that there are entries in the
/* Return the length of the queue. Negative values mean that threads
* are waiting, positve values mean that there are entries in the
* queue. Actually this function returns the length of the queue minus
* the number of waiting threads, g_async_queue_length == 0 could also
* mean 'n' entries in the queue and 'n' thread waiting, such can
* mean 'n' entries in the queue and 'n' thread waiting. Such can
* happen due to locking of the queue or due to scheduling. */
gint g_async_queue_length (GAsyncQueue *queue);
gint g_async_queue_length_unlocked (GAsyncQueue *queue);

6
glib/ghash.h
View File

@ -92,10 +92,10 @@ gboolean g_int_equal (gconstpointer v,
gconstpointer v2);
guint g_int_hash (gconstpointer v);
/* This "hash" function will just return the key's adress as an
* unsigned integer. Useful for hashing on plain adresses or
/* This "hash" function will just return the key's address as an
* unsigned integer. Useful for hashing on plain addresses or
* simple integer values.
* passing NULL into g_hash_table_new() as GHashFunc has the
* Passing NULL into g_hash_table_new() as GHashFunc has the
* same effect as passing g_direct_hash().
*/
guint g_direct_hash (gconstpointer v) G_GNUC_CONST;

2
glib/ghook.h
View File

@ -98,7 +98,7 @@ struct _GHook
/* --- prototypes --- */
/* callback mainenance functions */
/* callback maintenance functions */
void g_hook_list_init (GHookList *hook_list,
guint hook_size);
void g_hook_list_clear (GHookList *hook_list);

6
glib/gmem.h
View File

@ -122,11 +122,11 @@ void g_mem_profile (void);
* want to know what's going on inside do you?)
*/
/* ALLOC_ONLY MemChunk's can only allocate memory. The free operation
* is interpreted as a no op. ALLOC_ONLY MemChunk's save 4 bytes per
/* ALLOC_ONLY MemChunks can only allocate memory. The free operation
* is interpreted as a no op. ALLOC_ONLY MemChunks save 4 bytes per
* atom. (They are also useful for lists which use MemChunk to allocate
* memory but are also part of the MemChunk implementation).
* ALLOC_AND_FREE MemChunk's can allocate and free memory.
* ALLOC_AND_FREE MemChunks can allocate and free memory.
*/
#define G_ALLOC_ONLY 1

2
glib/gmessages.h
View File

@ -39,7 +39,7 @@
G_BEGIN_DECLS
/* calculate a string size, guarranteed to fit format + args.
/* calculate a string size, guaranteed to fit format + args.
*/
gsize g_printf_string_upper_bound (const gchar* format,
va_list args);

2
glib/gtypes.h
View File

@ -330,7 +330,7 @@ typedef union _GDoubleIEEE754 GDoubleIEEE754;
typedef union _GFloatIEEE754 GFloatIEEE754;
#define G_IEEE754_FLOAT_BIAS (127)
#define G_IEEE754_DOUBLE_BIAS (1023)
/* multiply with base2 exponent to get base10 exponent (nomal numbers) */
/* multiply with base2 exponent to get base10 exponent (normal numbers) */
#define G_LOG_2_BASE_10 (0.30102999566398119521)
#if G_BYTE_ORDER == G_LITTLE_ENDIAN
union _GFloatIEEE754