src/common/mgutils.c

   1 /*
   2  * Claws Mail -- a GTK based, lightweight, and fast e-mail client
   3  * Copyright (C) 2001-2015 Match Grun and the Claws Mail team
   4  *
   5  * This program is free software; you can redistribute it and/or modify
   6  * it under the terms of the GNU General Public License as published by
   7  * the Free Software Foundation; either version 3 of the License, or
   8  * (at your option) any later version.
   9  *
  10  * This program is distributed in the hope that it will be useful,
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13  * GNU General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU General Public License
  16  * along with this program. If not, see <http://www.gnu.org/licenses/>.
  17  */
  18
  19 /*
  20  * Definitions for generic functions.
  21  */
  22
  23 #include "config.h"
  24
  25 #include <glib.h>
  26 #include <stdio.h>
  27 #include <string.h>
  28 #include <ctype.h>
  29
  30 #include "mgutils.h"
  31
  32 /*
  33 * Dump linked list of character strings (for debug).
  34 */
  35 void mgu_print_list( GSList *list, FILE *stream ) {
  36         GSList *node = list;
  37         while( node ) {
  38                 int r = fprintf( stream, "\t- >%s<\n", (gchar *)node->data );
  39                 if (r < 0) {
  40                         perror("fprintf");
  41                         break;
  42                 }
  43                 node = g_slist_next( node );
  44         }
  45 }
  46
  47 /*
  48 * Dump linked list of character strings (for debug).
  49 */
  50 void mgu_print_dlist( GList *list, FILE *stream ) {
  51         GList *node = list;
  52         while( node ) {
  53                 int r = fprintf( stream, "\t- >%s<\n", (gchar *)node->data );
  54                 if (r < 0) {
  55                         perror("fprintf");
  56                         break;
  57                 }
  58                 node = g_list_next( node );
  59         }
  60 }
  61
  62 /*
  63 * Coalesce linked list of characaters into one long string.
  64 */
  65 gchar *mgu_list_coalesce( GSList *list ) {
  66         gchar *str = NULL;
  67         gchar *buf = NULL;
  68         gchar *start = NULL;
  69         GSList *node = NULL;
  70         gint len;
  71
  72         if( ! list ) return NULL;
  73
  74         /* Calculate maximum length of text */
  75         len = 0;
  76         node = list;
  77         while( node ) {
  78                 str = node->data;
  79                 len += 1 + strlen( str );
  80                 node = g_slist_next( node );
  81         }
  82
  83         /* Create new buffer. */
  84         buf = g_new0( gchar, len+1 );
  85         start = buf;
  86         node = list;
  87         while( node ) {
  88                 str = node->data;
  89                 len = strlen( str );
  90                 strcpy( start, str );
  91                 start += len;
  92                 node = g_slist_next( node );
  93         }
  94         return buf;
  95 }
  96
  97 /*
  98 * Replace existing string with new string.
  99 */
 100 gchar *mgu_replace_string( gchar *str, const gchar *value ) {
 101         g_free( str );
 102         if( value ) {
 103                 str = g_strdup( value );
 104                 g_strstrip( str );
 105         }
 106         else {
 107                 str = NULL;
 108         }
 109         return str;
 110 }
 111
 112 /*
 113 * Test and reformat an email address.
 114 * Enter:  address.
 115 * Return: Address, or NULL if address is empty.
 116 * Note: Leading and trailing white space is removed.
 117 */
 118 gchar *mgu_email_check_empty( gchar *address ) {
 119         gchar *retVal = NULL;
 120         if( address ) {
 121                 retVal = g_strdup( address );
 122                 retVal = g_strstrip( retVal );
 123                 if( *retVal == '\0' ) {
 124                         g_free( retVal );
 125                         retVal = NULL;
 126                 }
 127         }
 128         return retVal;
 129 }
 130
 131 /*
 132 * Parse string into linked list. Whitespace is used as a delimiter in parsing.
 133 * Strings are parsed until maxTokens - 1 is reached. The remainder of the
 134 * input string is copied into last element of list.
 135 * Enter: line      String to parse.
 136 *        maxTokens Maximum number of tokens to parse.
 137 *        tokenCnt  If arg supplied, update with count of number of token parsed.
 138 * Return: Linked list. The list contents should be g_free'd and list should
 139 * freed when done.
 140 */
 141 GList *mgu_parse_string( gchar *line, const gint maxTokens, gint *tokenCnt ) {
 142         gchar *ptr, *pStart, *pFound, *str;
 143         gint  args = 0;
 144         GList *list = NULL;
 145         gboolean done = FALSE;
 146
 147         if( tokenCnt ) *tokenCnt = 0;
 148         if( line == NULL ) return NULL;
 149         if( maxTokens < 1 ) return NULL;
 150
 151         ptr = line;
 152         while( ! done ) {
 153                 args++;
 154                 /* Skip over leading spaces */
 155                 while( *ptr ) {
 156                         if( ! isspace( *ptr ) ) break;
 157                         ptr++;
 158                 }
 159
 160                 /* Find terminating space */
 161                 pFound = NULL;
 162                 pStart = ptr;
 163                 while( *ptr ) {
 164                         if( isspace( *ptr ) ) {
 165                                 pFound = pStart;
 166                                 break;
 167                         }
 168                         ptr++;
 169                 }
 170
 171                 if( pFound ) {
 172                         if( args == maxTokens ) {
 173                                 /* Rest of string */
 174                                 str = g_strdup( pStart );
 175                                 done = TRUE;
 176                         }
 177                         else {
 178                                 /* Extract part of string */
 179                                 str = g_strndup( pStart, ptr - pFound );
 180                         }
 181                 }
 182                 else {
 183                         /* Nothing there - treat as rest of string */
 184                         str = g_strdup( pStart );
 185                         done = TRUE;
 186                 }
 187                 list = g_list_append( list, str );
 188         }
 189         if( tokenCnt ) *tokenCnt = args;
 190         return list;
 191 }
 192
 193 /*
 194  * Unescape characters by removing backslash character from input string.
 195  * Enter: str String to process.
 196  */
 197 void mgu_str_unescape( gchar *str ) {
 198         gchar *p;
 199         gint ilen;
 200
 201         p = str;
 202         while( *p ) {
 203                 if( *p == '\\' ) {
 204                         ilen = strlen( p + 1 );
 205                         memmove( p, p + 1, ilen );
 206                 }
 207                 p++;
 208         }
 209 }
 210
 211 /*
 212  * Replace leading and trailing characters (eg, quotes) in input string
 213  * with spaces. Only matching non-blank characters that appear at both
 214  * start and end of string are replaces. Control characters are also
 215  * replaced with spaces.
 216  * Enter: str    String to process.
 217  *        chlea  Lead character to remove.
 218  *        chtail Matching trailing character.
 219  */
 220 void mgu_str_ltc2space( gchar *str, gchar chlead, gchar chtail ) {
 221         gchar *as;
 222         gchar *ae;
 223
 224         /* Search forwards for first non-space match */
 225         as = str;
 226         ae = -1 + str + strlen( str );
 227         while( as < ae ) {
 228                 if( *as != ' ' ) {
 229                         if( *as == chlead ) {
 230                                 /* Search backwards from end for match */
 231                                 while( ae > as ) {
 232                                         if( *ae != ' ' ) {
 233                                                 if( *ae == chtail ) {
 234                                                         *as = ' ';
 235                                                         *ae = ' ';
 236                                                         return;
 237                                                 }
 238                                                 if( *ae < 32 ) {
 239                                                         *ae = ' ';
 240                                                 }
 241                                                 else if( *ae == 127 ) {
 242                                                         *ae = ' ';
 243                                                 }
 244                                                 else {
 245                                                         return;
 246                                                 }
 247                                         }
 248                                         ae--;
 249                                 }
 250                         }
 251                         if( *as < 32 ) {
 252                                 *as = ' ';
 253                         }
 254                         else if( *as == 127 ) {
 255                                 *as = ' ';
 256                         }
 257                         else {
 258                                 return;
 259                         }
 260                 }
 261                 as++;
 262         }
 263         return;
 264 }
 265
 266 /*
 267  * Return reference to longest entry in the specified linked list.
 268  * It is assumed that the list contains only gchar objects.
 269  * Enter:  list List of gchar strings to examine.
 270  * Return: Reference to longest entry, or NULL if nothing found.
 271  */
 272 gchar *mgu_slist_longest_entry( GSList *list ) {
 273         GSList *node;
 274         gchar *name = NULL;
 275         gint iLen = 0, iLenT = 0;
 276
 277         node = list;
 278         while( node ) {
 279                 if( name == NULL ) {
 280                         name = node->data;
 281                         iLen = strlen( name );
 282                 }
 283                 else {
 284                         iLenT = strlen( node->data );
 285                         if( iLenT > iLen ) {
 286                                 name = node->data;
 287                                 iLen = iLenT;
 288                         }
 289                 }
 290                 node = g_slist_next( node );
 291         }
 292         return name;
 293 }
 294
 295 /*
 296 * End of Source.
 297 */