util.c

Go to the documentation of this file.

/*
 * luau (Lib Update/Auto-Update): Simple Update Library
 * Copyright (C) 2003  David Eklund
 *
 * - This library is free software; you can redistribute it and/or             -
 * - modify it under the terms of the GNU Lesser General Public                -
 * - License as published by the Free Software Foundation; either              -
 * - version 2.1 of the License, or (at your option) any later version.        -
 * -                                                                           -
 * - This library 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         -
 * - Lesser General Public License for more details.                           -
 * -                                                                           -
 * - You should have received a copy of the GNU Lesser General Public          -
 * - License along with this library; if not, write to the Free Software       -
 * - Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA -
 */

#ifdef HAVE_CONFIG_H
#  include <config.h>
#endif

#include <stdio.h>
#include <stdlib.h>
#include <stdarg.h>
#include <string.h>
#include <math.h>

#include <sys/types.h>
#include <sys/stat.h>
#include <unistd.h>
#include <ctype.h>

#include <glib.h>
#include <zlib.h>

#include "gcontainer.h"
#include "error.h"
#include "util.h"

#ifdef WITH_DMALLOC
#  include <dmalloc.h>
#endif

#ifdef WITH_LEAKBUG
#  include <leakbug.h>
#endif


inline int
lutil_streq(const char *str1, const char *str2) {
        return (strcmp(str1, str2) == 0);
}

inline int
lutil_strcaseeq(const char *str1, const char *str2) {
        return (strcasecmp(str1, str2) == 0);
}


char *
lutil_createString(int length) {
        char *str = g_malloc(length+1);
        str[0] = '\0';
        return str;
}

char *
lutil_vstrcreate(const char *src1, ...) {
        va_list ap;
        int size;
        char *temp, *dest;
        
        size = strlen(src1);
        dest = g_malloc(size+1); /*lutil_createString(size);*/
        if (dest == NULL) {
                ERROR("Couldn't allocate memory for new string: out of memory?");
                return NULL;
        }
        strcpy(dest, src1);
        
        va_start(ap, src1);
        
        while (1) {
                temp = va_arg(ap, char *);
                
                if (temp == NULL) {
                        break;
                } else {
                        size += strlen(temp)+1;
                        dest = (char*) g_realloc(dest, size);
                        strcat(dest, temp);
                }
        }

        va_end(ap);
        
        return dest;
}

char *
lutil_mprintf(const char *template, ...) {
        va_list ap;
        char *str;
        
        va_start(ap, template);
        str = lutil_valistToString(template, ap);
        va_end(ap);
        
        return str;
}

/*
char *
lutil_vstrjoin(const char *delim, const char *src1, ...) {
        va_list ap;
        int size, delimLen;
        char *arg, *dest;
        
        size = strlen(src1)+1;
        delimLen = strlen(delim);
        
        dest = lutil_createString(size);
        strcpy(dest, src1);
        
        va_start(ap, src1);
        while (1) {
                arg = va_arg(ap, char *);
                
                
                if (arg == NULL) {
                        break;
                } else {
                        size += strlen(arg)+delimLen;
                        dest = (char*) g_realloc(dest, size);
                        strcat(dest, delim);
                        strcat(dest, arg);
                }
        }

        va_end(ap);
        
        return dest;
}
*/

char *
lutil_strjoin(const char *delim, const GContainer *strings) {
        GIterator iter;
        int size, delimLen;
        char *currStr, *dest;
        
        if (strings == NULL) {
                dest = g_strdup("(null)");
                return dest;
        } else if (strings->len == 0) {
                return g_strdup("");
        } else if (strings->len == 1) {
                currStr = g_container_index(strings, 0);
                return g_strdup(currStr);
        } else {
                g_container_get_iter(&iter, strings);
                currStr = g_iterator_next(&iter);
                
                delimLen = strlen(delim);
                size = strlen(currStr) + 1;
                dest = lutil_createString(size);
                strcpy(dest, currStr);
                        
                while (g_iterator_hasNext(&iter)) {
                        currStr = g_iterator_next(&iter);
                        size += strlen(currStr) + delimLen;
                        dest = g_realloc(dest, size*sizeof(char));
                        strcat(dest, delim);
                        strcat(dest, currStr);
                }
        }
        
        return dest;
}

GContainer *
lutil_gsplit(const char *delim, const char *str) {
        GContainer *result;
        char *copy, *tok, *holder;
        
        if (str == NULL) {
                DBUGOUT("Null pointer passed to luau_gsplit");
                return g_container_new(GCONT_PTR_ARRAY);
        }
        
        result = g_container_new(GCONT_PTR_ARRAY);
        if (str[0] != '\0') {
                copy = g_strdup(str);
                
                tok = strtok_r(copy, delim, &holder);
                tok = g_strdup(tok);
                g_container_add(result, tok);
                
                while ((tok = strtok_r(NULL, delim, &holder)) != NULL) {
                        tok = g_strdup(tok);
                        g_container_add(result, tok);
                }
                 
                g_free(copy);
        }
        
        return result;
}

char *
lutil_valistToString(const char *template, va_list args) {
        char *curr, test[1];
        int len;
        
        len = vsnprintf(test, 1, template, args);
        curr = lutil_createString(len+1);
        vsnprintf(curr, len+1, template, args);
        
        return curr;
}

gboolean
lutil_findString(const GContainer *array, const char *string) {
        GIterator iter;
        const char *curr;
        gboolean found = FALSE;
        
        g_container_get_iter(&iter, array);
        while (g_iterator_hasNext(&iter)) {
                curr = g_iterator_next(&iter);
                if (lutil_streq(curr, string)) {
                        found = TRUE;
                        break;
                }
        }
        
        return found;
}

void
lutil_printIndented(int indent, int length, const char *string) {
        char *curr, *prev, *newString, *lastSpace;
        int i;
        
        if (indent >= length)
                indent = 0;
        
        newString = g_strdup(string);
        lastSpace = prev = curr = newString;
        while (*curr != '\0') {
                for (i = 0; i < indent; ++i)
                        printf(" ");
                
                while (*curr != '\0' && i < length+1) {
                        if (*curr == '\n') {
                                lastSpace = curr;
                                break;
                        } else if (isblank(*curr)) {
                                lastSpace = curr;
                        }
                        ++i;
                        ++curr;
                }
                
                if (*curr != '\0') {
                        if (lastSpace == prev) { /* Found a string longer than indent-length characters */
                                while (! isblank(*curr))
                                        ++curr;
                                lastSpace = curr;
                        }
                        *lastSpace = '\0';
                        lastSpace++;
                        curr = lastSpace;
                }
                
                printf("%s\n", prev);
                
                prev = lastSpace;
        }
        
        g_free(newString);
}

gboolean
lutil_isCompletelyBlank(const char *input) {
        int i, len;
        gboolean blank = TRUE;
        
        if (input == NULL)
                return TRUE;
        else {
                len = strlen(input);
                
                for (i = 0; i < len; i++) {
                        if (!isspace(input[i])) {
                                blank = FALSE;
                                break;
                        }
                }
        }
        
        return blank;
}

void
lutil_strToLower(char *str) {
        int i, len;
        
        len = strlen(str);
        for (i = 0; i < len; ++i)
                str[i] = tolower(str[i]);
}

void
lutil_strToUpper(char *str) {
        int i, len;
        
        len = strlen(str);
        for (i = 0; i < len; ++i)
                str[i] = toupper(str[i]);
}

gboolean
lutil_containsAlpha(const char *str) {
        int len, i;
        
        if (str != NULL) {
                len = strlen(str);
                for (i = 0; i < len; ++i) {
                        if (isalpha(str[i]))
                                return TRUE;
                }
        }
        
        return FALSE;
}

gboolean
lutil_containsDigit(const char *str) {
        int len, i;
        
        if (str != NULL) {
                len = strlen(str);
                for (i = 0; i < len; ++i) {
                        if (isdigit(str[i]))
                                return TRUE;
                }
        }
        
        return FALSE;
}


GString *
lutil_uncompress(GString *data) {
        GString *guncompressed;
        z_stream z;
        char buffer[1025];
        int ret;
        uLongf count;
        
        guncompressed = g_string_new(""); /* sized_new(data->len); */
        
        /*count = 8000;
        printf("heeey\n");
        ret = uncompress(newbuffer, &count, data->str, data->len);
        
        if (ret != Z_OK) {
                ERROR("No worky!");
                printf("data error? %s\n", (ret == Z_DATA_ERROR) ? "yes" : "no");
        }*/
        /*guncompressed = g_string_new_len(newbuffer, 8000);*/
        /*return g_strdup(newbuffer);*/
        z.zalloc = NULL;
        z.zfree =  NULL;
        z.opaque = NULL;
        
        z.next_out  = buffer;
        z.avail_out = 1024;
        z.next_in   = data->str;
        z.avail_in  = data->len;
        ret = inflateInit2(&z, 16+MAX_WBITS);
        if (ret != Z_OK) {
                ERROR("Couldn't initialize compressed stream: %s: aborting", z.msg);
                g_string_free(guncompressed, TRUE);
                return NULL;
        }
        
        while (1) {
                ret = inflate(&z, Z_SYNC_FLUSH);
                count = 1024 - z.avail_out;
                if (count > 0)
                        g_string_append_len(guncompressed, buffer, count);
                if (ret == Z_STREAM_END)
                        break;
                else if (ret != Z_OK) {
                        ERROR("Decompression error: %s: aborting", z.msg);
                        inflateEnd(&z);
                        g_string_free(guncompressed, TRUE);
                        return NULL;
                }
        z.next_out = buffer;
        z.avail_out = 1024;
    }
        
        ret = inflateEnd(&z);
        if (ret != Z_OK)
                ERROR("Error shutting down zlib stream: %s", z.msg);
        
        return guncompressed;
}
        
        



char *
lutil_getTempFilename(void) {
        char* filename = lutil_createString(255);
        snprintf(filename, 256, "%s/.luau.%d", TEMP_DIR, getpid());
        return filename;
}

gboolean
lutil_fileExists(const char *path) {
        struct stat fileinfo;
        int ret;
        
        ret = stat(path, &fileinfo);

        /* technically this will return FALSE when some other error than 'no entity' occurs
           (such as "permission denied" or "too many symlinks"), but I think that's the
           desired behavior in this case */
        return (ret != -1);
}

gboolean
lutil_isDirectory(const char *path) {
        struct stat fileinfo;
        int ret;
        
        ret = stat(path, &fileinfo);
        if ((ret == 0) && S_ISDIR(fileinfo.st_mode))
                return TRUE;
        else
                return FALSE;
}


gint
lutil_gintCompare(gpointer p1, gpointer p2) {
        return (gint) lutil_intcmp(* (int*) p1, * (int*) p2);
}

int
lutil_intcmp(int i1, int i2) {
        if (i1 < i2)
                return -1;
        else if (i1 > i2)
                return 1;
        else
                return 0;
}

char *
lutil_sizeToString(int size, int sigfig) {
        char *newString, suffix;
        float n, base;
        int len, precision;
        
        if (size > 1024*1024) {
                suffix = 'M';
                n = (float) size / (1024*1024);
        } else if (size > 1024) {
                suffix = 'K';
                n = (float) size / 1024;
        } else {
                suffix ='b';
                n = size;
        }
        
        len = ((int) log10(n)) + 1; 
        base = pow(10, len-sigfig);
        n = ((int) (n / base)) * base;
        precision = sigfig - len;
        if (precision < 0) precision = 0;
        
        len = sigfig + 5;
        newString = lutil_createString(len);
        snprintf(newString, len, "%.*f %c", precision, n, suffix);
        
        return newString;
}

---