Line data    Source code

       1             : /* -*- Mode: C; tab-width: 8; indent-tabs-mode: t; c-basic-offset: 8 -*- */
       2             : /* 
       3             :  * lt-utils.c
       4             :  * Copyright (C) 2011-2012 Akira TAGOH
       5             :  * 
       6             :  * Authors:
       7             :  *   Akira TAGOH  <akira@tagoh.org>
       8             :  * 
       9             :  * You may distribute under the terms of either the GNU
      10             :  * Lesser General Public License or the Mozilla Public
      11             :  * License, as specified in the README file.
      12             :  */
      13             : #ifdef HAVE_CONFIG_H
      14             : #include "config.h"
      15             : #endif
      16             : 
      17             : #include <ctype.h>
      18             : #include <stdio.h>
      19             : #include <string.h>
      20             : #include <memory.h>
      21             : #include <stdlib.h>
      22             : #include "lt-messages.h"
      23             : #include "lt-utils.h"
      24             : 
      25             : 
      26             : /*< private >*/
      27             : 
      28             : /*< public >*/
      29             : int
      30          54 : lt_strcmp0(const char *v1,
      31             :            const char *v2)
      32             : {
      33          54 :         if (!v1)
      34           0 :                 return -(v1 != v2);
      35          54 :         if (!v2)
      36           0 :                 return v1 != v2;
      37          54 :         return strcmp(v1, v2);
      38             : }
      39             : 
      40             : int
      41          22 : lt_strcasecmp(const char *s1,
      42             :               const char *s2)
      43             : {
      44             :         char c1, c2;
      45             : 
      46          22 :         lt_return_val_if_fail (s1 != NULL, 0);
      47          22 :         lt_return_val_if_fail (s2 != NULL, 0);
      48             : 
      49         106 :         while (*s1 && *s2) {
      50          62 :                 c1 = tolower(*s1);
      51          62 :                 c2 = tolower(*s2);
      52          62 :                 if (c1 != c2)
      53           0 :                         return (c1 - c2);
      54          62 :                 s1++;
      55          62 :                 s2++;
      56             :         }
      57             : 
      58          22 :         return (*s1 - *s2);
      59             : }
      60             : 
      61             : int
      62           0 : lt_strncasecmp(const char *s1,
      63             :                const char *s2,
      64             :                size_t      len)
      65             : {
      66             :         char c1, c2;
      67             : 
      68           0 :         lt_return_val_if_fail (s1 != NULL, 0);
      69           0 :         lt_return_val_if_fail (s2 != NULL, 0);
      70             : 
      71           0 :         while (len && *s1 && *s2) {
      72           0 :                 len--;
      73           0 :                 c1 = tolower(*s1);
      74           0 :                 c2 = tolower(*s2);
      75           0 :                 if (c1 != c2)
      76           0 :                         return (c1 - c2);
      77           0 :                 s1++;
      78           0 :                 s2++;
      79             :         }
      80             : 
      81           0 :         if (len)
      82           0 :                 return (*s1 - *s2);
      83             :         else
      84           0 :                 return 0;
      85             : }
      86             : 
      87             : char *
      88       35236 : lt_strlower(char *string)
      89             : {
      90             :         size_t len;
      91       35236 :         char *p = string;
      92             : 
      93       35236 :         lt_return_val_if_fail (string != NULL, NULL);
      94             : 
      95       35236 :         len = strlen(string);
      96      177642 :         while (len) {
      97      107170 :                 *p = tolower(*p);
      98      107170 :                 p++;
      99      107170 :                 len--;
     100             :         }
     101             : 
     102       35236 :         return string;
     103             : }
     104             : 
     105             : char *
     106           0 : lt_strdup_printf(const char *format,
     107             :                  ...)
     108             : {
     109             :         va_list ap;
     110             :         char *retval;
     111             : 
     112           0 :         va_start(ap, format);
     113             : 
     114           0 :         retval = lt_strdup_vprintf(format, ap);
     115             : 
     116           0 :         va_end(ap);
     117             : 
     118           0 :         return retval;
     119             : }
     120             : 
     121             : char *
     122          20 : lt_strdup_vprintf(const char *format,
     123             :                   va_list     args)
     124             : {
     125             :         char *retval, tmpbuf[ 16384 ];
     126             :         va_list ap;
     127             :         int size;
     128             : 
     129          20 :         lt_return_val_if_fail (format != NULL, NULL);
     130             : 
     131             : #ifdef _WIN32
     132             :         ap = args;
     133             : #else
     134          20 :         va_copy(ap, args);
     135             : #endif
     136             : 
     137          20 :         size = vsnprintf(tmpbuf, sizeof(tmpbuf), format, ap) + 1;
     138          20 :         if( size == 0 ) // -1 + 1
     139           0 :                 abort();
     140             : 
     141          20 :         va_end(ap);
     142             : 
     143          20 :         retval = malloc(sizeof (char) * size);
     144          20 :         if (retval) {
     145          20 :                 vsprintf(retval, format, args);
     146             :         }
     147             : 
     148          20 :         return retval;
     149             : }