Mercurial > ~mikael > mcabber > hg
view mcabber/src/hbuf.c @ 1197:6f602d3270a4
Add /pgp [-]force
With this command it becomes possible to enforce PGP encryption without
checking if the remote client has PGP support. It can be used to send
encrypted offline messages too.
author | Mikael Berthe <mikael@lilotux.net> |
---|---|
date | Fri, 27 Apr 2007 00:37:57 +0200 |
parents | 5be2408a6534 |
children | e802ec0c02d2 |
line wrap: on
line source
/* * hbuf.c -- History buffer implementation * * Copyright (C) 2005, 2006 Mikael Berthe <bmikael@lists.lilotux.net> * * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation; either version 2 of the License, or (at * your option) any later version. * * This program is distributed in the hope that it will be useful, but * WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU * General Public License for more details. * * You should have received a copy of the GNU General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 * USA */ #include <string.h> #include "hbuf.h" #include "utils.h" #include "utf8.h" /* This is a private structure type */ typedef struct { char *ptr; char *ptr_end; // beginning of the block char *ptr_end_alloc; // end of the current persistent block guchar flags; // XXX This should certainly be a pointer, and be allocated only when needed // (for ex. when HBB_FLAG_PERSISTENT is set). struct { // hbuf_line_info time_t timestamp; guint flags; } prefix; } hbuf_block; // 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 // are created). // All hbuf elements are processed, starting from first_hbuf_elt. static inline void do_wrap(GList **p_hbuf, GList *first_hbuf_elt, unsigned int width) { GList *curr_elt = first_hbuf_elt; // 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; 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_prev = hbuf_b_curr; c = hbuf_b_curr->ptr; while (*c && (!width || cur_w <= width)) { if (*c == '\n') { br = cr = c; *c = 0; break; } if (iswblank(get_char(c))) br = c; cur_w += get_char_width(c); c = next_char(c); } if (cr || (*c && cur_w > width)) { if (!br || br == hbuf_b_curr->ptr) br = c; 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); // 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 { hbuf_b_curr->ptr = hbuf_b_prev->ptr_end; // == br hbuf_b_curr->flags = 0; } hbuf_b_curr->ptr_end = end; hbuf_b_curr->ptr_end_alloc = hbuf_b_prev->ptr_end_alloc; // This is OK because insert_before(NULL) == append(): *p_hbuf = g_list_insert_before(*p_hbuf, curr_elt->next, hbuf_b_curr); } curr_elt = g_list_next(curr_elt); } } // hbuf_add_line(p_hbuf, text, prefix_flags, width, maxhbufblocks) // Add a line to the given buffer. If width is not null, then lines are // wrapped at this length. // maxhbufblocks is the maximum number of hbuf blocks we can allocate. If // null, there is no limit. If non-null, it should be >= 2. // // Note 1: Splitting according to width won't work if there are tabs; they // should be expanded before. // Note 2: width does not include the ending \0. void hbuf_add_line(GList **p_hbuf, const char *text, time_t timestamp, guint prefix_flags, guint width, guint maxhbufblocks) { GList *curr_elt; char *line; hbuf_block *hbuf_block_elt; if (!text) return; hbuf_block_elt = g_new0(hbuf_block, 1); hbuf_block_elt->prefix.timestamp = timestamp; hbuf_block_elt->prefix.flags = prefix_flags; if (!*p_hbuf) { hbuf_block_elt->ptr = g_new(char, HBB_BLOCKSIZE); 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; // 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->flags = HBB_FLAG_PERSISTENT; hbuf_block_elt->ptr_end_alloc = hbuf_b_prev->ptr_end_alloc; } *p_hbuf = g_list_append(*p_hbuf, hbuf_block_elt); if (strlen(text) >= HBB_BLOCKSIZE) { // Too long text = "[ERR:LINE_TOO_LONG]"; hbuf_block_elt->prefix.flags |= HBB_PREFIX_INFO; } if (hbuf_block_elt->ptr + strlen(text) >= hbuf_block_elt->ptr_end_alloc) { // Too long for the current allocated bloc, we need another one if (!maxhbufblocks) { // No limit, let's allocate a new block hbuf_block_elt->ptr = g_new0(char, HBB_BLOCKSIZE); } else { GList *hbuf_head, *hbuf_elt; hbuf_block *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); 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) { hbuf_block_elt->ptr = g_new0(char, HBB_BLOCKSIZE); } else { // Let's use an old block, and free the extra blocks if needed char *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); if (hbuf_b_elt->flags & HBB_FLAG_ALLOC) { if (start_of_block-- == 0) break; if (n == maxhbufblocks) allocated_block = hbuf_b_elt->ptr; else g_free(hbuf_b_elt->ptr); } g_free(hbuf_b_elt); hbuf_head = *p_hbuf = g_list_delete_link(hbuf_head, hbuf_elt); } n--; /* --- */ } memset(allocated_block, 0, HBB_BLOCKSIZE); hbuf_block_elt->ptr = allocated_block; } } hbuf_block_elt->flags = HBB_FLAG_ALLOC | HBB_FLAG_PERSISTENT; hbuf_block_elt->ptr_end_alloc = hbuf_block_elt->ptr + HBB_BLOCKSIZE; } line = hbuf_block_elt->ptr; // Ok, now we can copy the text.. strcpy(line, text); hbuf_block_elt->ptr_end = line + strlen(line) + 1; curr_elt = g_list_last(*p_hbuf); // Wrap lines and handle CRs ('\n') do_wrap(p_hbuf, curr_elt, width); } // hbuf_free() // Destroys all hbuf list. void hbuf_free(GList **p_hbuf) { hbuf_block *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); if (hbuf_b_elt->flags & HBB_FLAG_ALLOC) { g_free(hbuf_b_elt->ptr); } g_free(hbuf_b_elt); } g_list_free(first_elt); *p_hbuf = NULL; } // hbuf_rebuild() // 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; // *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!) curr_elt = first_elt; 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_next = (hbuf_block*)(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); } else curr_elt = next_elt; } // #2 Go back to head and create non-persistent blocks when needed if (width) do_wrap(p_hbuf, first_elt, width); } // hbuf_previous_persistent() // Returns the previous persistent block (line). If the given line is // persistent, then it is returned. // 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; while (l_line) { hbuf_b_elt = (hbuf_block*)l_line->data; if (hbuf_b_elt->flags & HBB_FLAG_PERSISTENT) return l_line; l_line = g_list_previous(l_line); } return NULL; } // hbuf_get_lines(hbuf, n) // Returns an array of n hbb_line pointers // (The first line will be the line currently pointed by hbuf) // 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; guchar last_persist_prefixflags = 0; GList *last_persist; // last persistent flags hbb_line **array, **array_elt; // To be able to correctly highlight multi-line messages, // we need to look at the last non-null prefix, which should be the first // line of the message. last_persist = hbuf_previous_persistent(hbuf); while (last_persist) { blk = (hbuf_block*)last_persist->data; if ((blk->flags & HBB_FLAG_PERSISTENT) && blk->prefix.flags) { last_persist_prefixflags = blk->prefix.flags; break; } last_persist = g_list_previous(last_persist); } array = g_new0(hbb_line*, n); array_elt = array; for (i = 0 ; i < n ; i++) { if (hbuf) { int maxlen; blk = (hbuf_block*)(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)->text = g_strndup(blk->ptr, maxlen); if ((blk->flags & HBB_FLAG_PERSISTENT) && blk->prefix.flags) { last_persist_prefixflags = blk->prefix.flags; } else { // Propagate highlighting flag (*array_elt)->flags |= last_persist_prefixflags & HBB_PREFIX_HLIGHT; } hbuf = g_list_next(hbuf); } else break; array_elt++; } return array; } // 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; for (;;) { if (direction > 0) hbuf = g_list_next(hbuf); else hbuf = g_list_previous(hbuf); if (!hbuf) break; blk = (hbuf_block*)(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; } return hbuf; } // 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 = g_list_first(hbuf); for ( ; hbuf && g_list_next(hbuf); hbuf = g_list_next(hbuf)) { blk = (hbuf_block*)(hbuf->data); if (blk->prefix.timestamp >= t) break; } return hbuf; } // hbuf_jump_percent(hbuf, pc) // Return a pointer to the line at % pc of the history buffer GList *hbuf_jump_percent(GList *hbuf, int pc) { guint hlen; hbuf = g_list_first(hbuf); hlen = g_list_length(hbuf); return g_list_nth(hbuf, pc*hlen/100); } /* vim: set expandtab cindent cinoptions=>2\:2(0: For Vim users... */