mc/mhl/mhl_string.c

/* Micro helper library - strings

   Copyright (C) 2009 Free Software Foundation, Inc.

   Written by:
   2009 Enrico Weigelt
   2009 Slava Zanko
   2009 Patrick Winnertz


   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., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.  
 */

#include <string.h>
#include "../mhl/mhl_string.h"

/* ---------------------------------------------------------------------------- */
inline char *
mhl_str_reverse (char *ptr)
{
    if (!ptr)
	return NULL;		// missing string
    if (!(ptr[0] && ptr[1]))
	return ptr;		// empty or 1-ch string

    size_t _sz = strlen (ptr);
    char *start = ptr;
    char *end = ptr + _sz - 1;

    while (start < end)
    {
	char c = *start;
	*start = *end;
	*end = c;
	start++;
	end--;
    }

    return ptr;
}

/* ---------------------------------------------------------------------------- */
inline char *
__mhl_str_concat_hlp (const char *base, ...)
{
    static const char *arg_ptr[__STR_CONCAT_MAX];
    static size_t arg_sz[__STR_CONCAT_MAX];
    int count = 0;
    size_t totalsize = 0;

    // first pass: scan through the params and count string sizes
    va_list par;

    if (base)
    {
	arg_ptr[0] = base;
	arg_sz[0] = totalsize = strlen (base);
	count = 1;
    }

    va_list args;
    va_start (args, base);
    char *a;
    // note: we use ((char*)(1)) as terminator - NULL is a valid argument !
    while ((a = va_arg (args, char *)) != (char *) 1)
    {
	//      printf("a=%u\n", a);
	if (a)
	{
	    arg_ptr[count] = a;
	    arg_sz[count] = strlen (a);
	    totalsize += arg_sz[count];
	    count++;
	}
    }

    if (!count)
	return mhl_str_dup ("");

    // now as we know how much to copy, allocate the buffer
    char *buffer = (char *) mhl_mem_alloc_u (totalsize + 2);
    char *current = buffer;
    int x = 0;
    for (x = 0; x < count; x++)
    {
	memcpy (current, arg_ptr[x], arg_sz[x]);
	current += arg_sz[x];
    }

    *current = 0;
    return buffer;
}

/* ---------------------------------------------------------------------------- */
inline void
mhl_str_toupper (char *str)
{
    /*
       FIXME: need to upper miltibyte strings... utf-8 for example. 
       And after UPPER byte-lenght of wide string may change.
       This mean, need to create new string.
     */
    if (str)
	for (; *str; str++)
	    *str = toupper (*str);
}

/* ---------------------------------------------------------------------------- */
inline char *
mhl_str_trim (char *str)
{
    if (!str)
	return NULL;		// NULL string ?! bail out.

    // find the first non-space
    char *start;
    for (start = str; ((*str) && (!isspace (*str))); str++);

    // only spaces ?
    if (!(*str))
    {
	*str = 0;
	return str;
    }

    // get the size (cannot be empty - catched above)
    size_t _sz = strlen (str);

    // find the proper end
    char *end;
    for (end = (str + _sz - 1); ((end > str) && (isspace (*end))); end--);
    end[1] = 0;			// terminate, just to be sure

    // if we have no leading spaces, just trucate
    if (start == str)
    {
	end++;
	*end = 0;
	return str;
    }


    // if it' only one char, dont need memmove for that    
    if (start == end)
    {
	str[0] = *start;
	str[1] = 0;
	return str;
    }

    // by here we have a (non-empty) region between start end end 
    memmove (str, start, (end - start + 1));
    return str;
}

/* ---------------------------------------------------------------------------- */