mcabber: comparison mcabber/mcabber/hbuf.c

equal deleted inserted replaced

-:0dc317b5599d
+:ffd0e57e9563
 time_t timestamp;
 unsigned mucnicklen;
 guint  flags;
 gpointer xep184;
 } prefix;
-} hbuf_block;
+} hbuf_block_t;
 //  do_wrap(p_hbuf, first_hbuf_elt, width)
 // Wrap hbuf lines with the specified width.
 // '\n' are handled by this routine (they are removed and persistent lines
 // Let's add non-persistent blocs if necessary
 // - If there are '\n' in the string
 // - If length > width (and width != 0)
 while (curr_elt) {
-hbuf_block *hbuf_b_curr, *hbuf_b_prev;
+hbuf_block_t *hbuf_b_curr, *hbuf_b_prev;
 char *c, *end;
 char *br = NULL; // break pointer
 char *cr = NULL; // CR pointer
 unsigned int cur_w = 0;
 // We want to break where we can find a space char or a CR
-hbuf_b_curr = (hbuf_block*)(curr_elt->data);
+hbuf_b_curr = (hbuf_block_t*)(curr_elt->data);
 hbuf_b_prev = hbuf_b_curr;
 c = hbuf_b_curr->ptr;
 while (*c && (!width || cur_w <= width)) {
 if (*c == '\n') {
 else
 br = next_char(br);
 end = hbuf_b_curr->ptr_end;
 hbuf_b_curr->ptr_end = br;
 // Create another block
-hbuf_b_curr = g_new0(hbuf_block, 1);
+hbuf_b_curr = g_new0(hbuf_block_t, 1);
 // The block must be persistent after a CR
 if (cr) {
 hbuf_b_curr->ptr    = hbuf_b_prev->ptr_end + 1; // == cr+1
 hbuf_b_curr->flags  = HBB_FLAG_PERSISTENT;
 } else {
 unsigned mucnicklen, gpointer xep184)
 {
 GList *curr_elt;
 char *line;
 guint hbb_blocksize, textlen;
-hbuf_block *hbuf_block_elt;
+hbuf_block_t *hbuf_block_elt;
 if (!text) return;
 prefix_flags |= (xep184 ? HBB_PREFIX_RECEIPT : 0);
 textlen = strlen(text);
 hbb_blocksize = MAX(textlen+1, HBB_BLOCKSIZE);
-hbuf_block_elt = g_new0(hbuf_block, 1);
+hbuf_block_elt = g_new0(hbuf_block_t, 1);
 hbuf_block_elt->prefix.timestamp  = timestamp;
 hbuf_block_elt->prefix.flags      = prefix_flags;
 hbuf_block_elt->prefix.mucnicklen = mucnicklen;
 hbuf_block_elt->prefix.xep184     = xep184;
 if (!*p_hbuf) {
 return;
 }
 hbuf_block_elt->flags  = HBB_FLAG_ALLOC | HBB_FLAG_PERSISTENT;
 hbuf_block_elt->ptr_end_alloc = hbuf_block_elt->ptr + hbb_blocksize;
 } else {
-hbuf_block *hbuf_b_prev;
+hbuf_block_t *hbuf_b_prev;
 // Set p_hbuf to the end of the list, to speed up history loading
 // (or CPU time will be used by g_list_last() for each line)
 *p_hbuf = g_list_last(*p_hbuf);
 hbuf_b_prev = (*p_hbuf)->data;
 hbuf_block_elt->ptr    = hbuf_b_prev->ptr_end;
 hbuf_block_elt->ptr  = g_new0(char, hbb_blocksize);
 hbuf_block_elt->ptr_end_alloc = hbuf_block_elt->ptr + hbb_blocksize;
 // XXX We should check the return value.
 } else {
 GList *hbuf_head, *hbuf_elt;
-hbuf_block *hbuf_b_elt;
+hbuf_block_t *hbuf_b_elt;
 guint n = 0;
 hbuf_head = g_list_first(*p_hbuf);
 // We need at least 2 allocated blocks
 if (maxhbufblocks == 1)
 maxhbufblocks = 2;
 // Let's count the number of allocated areas
 for (hbuf_elt = hbuf_head; hbuf_elt; hbuf_elt = g_list_next(hbuf_elt)) {
-hbuf_b_elt = (hbuf_block*)(hbuf_elt->data);
+hbuf_b_elt = (hbuf_block_t*)(hbuf_elt->data);
 if (hbuf_b_elt->flags & HBB_FLAG_ALLOC)
 n++;
 }
 // If we can't allocate a new area, reuse the previous block(s)
 if (n < maxhbufblocks) {
 char *allocated_block = NULL;
 char *end_of_allocated_block = NULL;
 while (n >= maxhbufblocks) {
 int start_of_block = 1;
 for (hbuf_elt = hbuf_head; hbuf_elt; hbuf_elt = hbuf_head) {
-hbuf_b_elt = (hbuf_block*)(hbuf_elt->data);
+hbuf_b_elt = (hbuf_block_t*)(hbuf_elt->data);
 if (hbuf_b_elt->flags & HBB_FLAG_ALLOC) {
 if (start_of_block-- == 0)
 break;
 if (n == maxhbufblocks) {
 allocated_block = hbuf_b_elt->ptr;
 //  hbuf_free()
 // Destroys all hbuf list.
 void hbuf_free(GList **p_hbuf)
 {
-hbuf_block *hbuf_b_elt;
+hbuf_block_t *hbuf_b_elt;
 GList *hbuf_elt;
 GList *first_elt = g_list_first(*p_hbuf);
 for (hbuf_elt = first_elt; hbuf_elt; hbuf_elt = g_list_next(hbuf_elt)) {
-hbuf_b_elt = (hbuf_block*)(hbuf_elt->data);
+hbuf_b_elt = (hbuf_block_t*)(hbuf_elt->data);
 if (hbuf_b_elt->flags & HBB_FLAG_ALLOC) {
 g_free(hbuf_b_elt->ptr);
 }
 g_free(hbuf_b_elt);
 }
 // Rebuild all hbuf list, with the new width.
 // If width == 0, lines are not wrapped.
 void hbuf_rebuild(GList **p_hbuf, unsigned int width)
 {
 GList *first_elt, *curr_elt, *next_elt;
-hbuf_block *hbuf_b_curr, *hbuf_b_next;
+hbuf_block_t *hbuf_b_curr, *hbuf_b_next;
 // *p_hbuf needs to be the head of the list
 first_elt = *p_hbuf = g_list_first(*p_hbuf);
 // #1 Remove non-persistent blocks (ptr_end should be updated!)
 while (curr_elt) {
 next_elt = g_list_next(curr_elt);
 // Last element?
 if (!next_elt)
 break;
-hbuf_b_curr = (hbuf_block*)(curr_elt->data);
+hbuf_b_curr = (hbuf_block_t*)(curr_elt->data);
-hbuf_b_next = (hbuf_block*)(next_elt->data);
+hbuf_b_next = (hbuf_block_t*)(next_elt->data);
 // Is next line not-persistent?
 if (!(hbuf_b_next->flags & HBB_FLAG_PERSISTENT)) {
 hbuf_b_curr->ptr_end = hbuf_b_next->ptr_end;
 g_free(hbuf_b_next);
 curr_elt = g_list_delete_link(curr_elt, next_elt);
 // This function is used for example when resizing a buffer.  If the top of the
 // screen is on a non-persistent block, then a screen resize could destroy this
 // line...
 GList *hbuf_previous_persistent(GList *l_line)
 {
-hbuf_block *hbuf_b_elt;
+hbuf_block_t *hbuf_b_elt;
 while (l_line) {
-hbuf_b_elt = (hbuf_block*)l_line->data;
+hbuf_b_elt = (hbuf_block_t*)l_line->data;
 if (hbuf_b_elt->flags & HBB_FLAG_PERSISTENT &&
 (hbuf_b_elt->flags & ~HBB_PREFIX_READMARK))
 return l_line;
 l_line = g_list_previous(l_line);
 }
 // Note: The caller should free the array, the hbb_line pointers and the
 // text pointers after use.
 hbb_line **hbuf_get_lines(GList *hbuf, unsigned int n)
 {
 unsigned int i;
-hbuf_block *blk;
+hbuf_block_t *blk;
 guint last_persist_prefixflags = 0;
 GList *last_persist;  // last persistent flags
 hbb_line **array, **array_elt;
 hbb_line *prev_array_elt = NULL;
 // we need to look at the last non-null prefix, which should be the first
 // line of the message.  We also need to check if there's a readmark flag
 // somewhere in the message.
 last_persist = hbuf_previous_persistent(hbuf);
 while (last_persist) {
-blk = (hbuf_block*)last_persist->data;
+blk = (hbuf_block_t*)last_persist->data;
 if ((blk->flags & HBB_FLAG_PERSISTENT) && blk->prefix.flags) {
 // This can be either the beginning of the message,
 // or a persistent line with a readmark flag (or both).
 if (blk->prefix.flags & ~HBB_PREFIX_READMARK) { // First message line
 last_persist_prefixflags |= blk->prefix.flags;
 for (i = 0 ; i < n ; i++) {
 if (hbuf) {
 int maxlen;
-blk = (hbuf_block*)(hbuf->data);
+blk = (hbuf_block_t*)(hbuf->data);
 maxlen = blk->ptr_end - blk->ptr;
 *array_elt = (hbb_line*)g_new(hbb_line, 1);
 (*array_elt)->timestamp  = blk->prefix.timestamp;
 (*array_elt)->flags      = blk->prefix.flags;
 (*array_elt)->mucnicklen = blk->prefix.mucnicklen;
 //  hbuf_search(hbuf, direction, string)
 // Look backward/forward for a line containing string in the history buffer
 // Search starts at hbuf, and goes forward if direction == 1, backward if -1
 GList *hbuf_search(GList *hbuf, int direction, const char *string)
 {
-hbuf_block *blk;
+hbuf_block_t *blk;
 for (;;) {
 if (direction > 0)
 hbuf = g_list_next(hbuf);
 else
 hbuf = g_list_previous(hbuf);
 if (!hbuf) break;
-blk = (hbuf_block*)(hbuf->data);
+blk = (hbuf_block_t*)(hbuf->data);
 // XXX blk->ptr is (maybe) not really correct, because the match should
 // not be after ptr_end.  We should check that...
 if (strcasestr(blk->ptr, string))
 break;
 }
 //  hbuf_jump_date(hbuf, t)
 // Return a pointer to the first line after date t in the history buffer
 GList *hbuf_jump_date(GList *hbuf, time_t t)
 {
-hbuf_block *blk;
+hbuf_block_t *blk;
 hbuf = g_list_first(hbuf);
 for ( ; hbuf && g_list_next(hbuf); hbuf = g_list_next(hbuf)) {
-blk = (hbuf_block*)(hbuf->data);
+blk = (hbuf_block_t*)(hbuf->data);
 if (blk->prefix.timestamp >= t) break;
 }
 return hbuf;
 }
 //  hbuf_jump_readmark(hbuf)
 // Return a pointer to the line following the readmark
 // or NULL if no mark was found.
 GList *hbuf_jump_readmark(GList *hbuf)
 {
-hbuf_block *blk;
+hbuf_block_t *blk;
 GList *r = NULL;
 hbuf = g_list_last(hbuf);
 for ( ; hbuf; hbuf = g_list_previous(hbuf)) {
-blk = (hbuf_block*)(hbuf->data);
+blk = (hbuf_block_t*)(hbuf->data);
 if (blk->prefix.flags & HBB_PREFIX_READMARK)
 return r;
 if ((blk->flags & HBB_FLAG_PERSISTENT) &&
 (blk->prefix.flags & ~HBB_PREFIX_READMARK))
 r = hbuf;
 //  hbuf_dump_to_file(hbuf, filename)
 // Save the buffer to a file.
 void hbuf_dump_to_file(GList *hbuf, const char *filename)
 {
-hbuf_block *blk;
+hbuf_block_t *blk;
 hbb_line line;
 guint last_persist_prefixflags = 0;
 guint prefixwidth;
 char pref[96];
 FILE *fp;
 prefixwidth = MIN(prefixwidth, sizeof pref);
 for (hbuf = g_list_first(hbuf); hbuf; hbuf = g_list_next(hbuf)) {
 int maxlen;
-blk = (hbuf_block*)(hbuf->data);
+blk = (hbuf_block_t*)(hbuf->data);
 maxlen = blk->ptr_end - blk->ptr;
 memset(&line, 0, sizeof(line));
 line.timestamp  = blk->prefix.timestamp;
 line.flags      = blk->prefix.flags;
 //  hbuf_remove_receipt(hbuf, xep184)
 // Remove the Receipt Flag for the message with the given xep184 id
 // Returns TRUE if it was found and removed, otherwise FALSE
 gboolean hbuf_remove_receipt(GList *hbuf, gconstpointer xep184)
 {
-hbuf_block *blk;
+hbuf_block_t *blk;
 hbuf = g_list_last(hbuf);
 for ( ; hbuf; hbuf = g_list_previous(hbuf)) {
-blk = (hbuf_block*)(hbuf->data);
+blk = (hbuf_block_t*)(hbuf->data);
 if (!g_strcmp0(blk->prefix.xep184, xep184)) {
 g_free(blk->prefix.xep184);
 blk->prefix.xep184 = NULL;
 blk->prefix.flags ^= HBB_PREFIX_RECEIPT;
 return TRUE;
 // Set/Reset the readmark Flag
 // If action is TRUE, set a mark to the latest line,
 // if action is FALSE, remove a previous readmark flag.
 void hbuf_set_readmark(GList *hbuf, gboolean action)
 {
-hbuf_block *blk;
+hbuf_block_t *blk;
 if (!hbuf) return;
 hbuf = hbuf_previous_persistent(g_list_last(hbuf));
 if (action) {
 // Add a readmark flag
-blk = (hbuf_block*)(hbuf->data);
+blk = (hbuf_block_t*)(hbuf->data);
 blk->prefix.flags |= HBB_PREFIX_READMARK;
 // Shift hbuf in order to remove previous flags
 // (maybe it can be optimized out, if there's no risk
 //  we have several marks)
 hbuf = g_list_previous(hbuf);
 }
 // Remove old mark
 for ( ; hbuf; hbuf = g_list_previous(hbuf)) {
-blk = (hbuf_block*)(hbuf->data);
+blk = (hbuf_block_t*)(hbuf->data);
 if (blk->prefix.flags & HBB_PREFIX_READMARK) {
 blk->prefix.flags &= ~HBB_PREFIX_READMARK;
 break;
 }
 }
 //  hbuf_remove_trailing_readmark(hbuf)
 // Unset the buffer readmark if it is on the last line
 void hbuf_remove_trailing_readmark(GList *hbuf)
 {
-hbuf_block *blk;
+hbuf_block_t *blk;
 if (!hbuf) return;
 hbuf = g_list_last(hbuf);
-blk = (hbuf_block*)(hbuf->data);
+blk = (hbuf_block_t*)(hbuf->data);
 blk->prefix.flags &= ~HBB_PREFIX_READMARK;
 }
 //  hbuf_get_blocks_number()
-// Returns the number of allocated hbuf_block's.
+// Returns the number of allocated hbuf_block_t's.
 guint hbuf_get_blocks_number(GList *hbuf)
 {
-hbuf_block *hbuf_b_elt;
+hbuf_block_t *hbuf_b_elt;
 guint count = 0U;
 for (hbuf = g_list_first(hbuf); hbuf; hbuf = g_list_next(hbuf)) {
-hbuf_b_elt = (hbuf_block*)(hbuf->data);
+hbuf_b_elt = (hbuf_block_t*)(hbuf->data);
 if (hbuf_b_elt->flags & HBB_FLAG_ALLOC)
 count++;
 }
 return count;
 }

changeset 2337	ffd0e57e9563
parent 2268	f5402d705f67