Platon Technologies
neprihlásený Prihlásiť Registrácia
SlovakEnglish
open source software development oslavujeme 10 rokov vývoja otvoreného softvéru! Piatok, 29. marec 2024

Súbor: [Platon] / dead / mail2sms / strdyn.c (stiahnutie)

Revízia 1.1, Mon Nov 12 16:10:05 2001 UTC (22 years, 4 months ago) by host8

Added some files.

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

#include "strdyn.h"

/* function from libplaton/str/strplus.c */
int strcnt_sepstr(const char *str, const char *substr) {
    register char *s;
    register int count, substr_size;

    substr_size = strlen(substr);

    for (count = 0; ; count++) {
        if ((s = strstr(str, substr)) == NULL)
            break;
        else
            str += (s - str) + substr_size;
    }

    return count;
}

void strdyn_free(char **ar) {
    register int i;

    for (i = 0; ar[i] != NULL; i++)
        free(ar[i]);

    free(ar);
}

int strdyn_get_size(char **ar) {
    register int i;

    for (i = 0; ar[i] != NULL; i++)
        ;

    return i;
}

char **strdyn_create(void) {
    register char **ar;

    if ((ar = (char **) malloc(1 * sizeof(char *))) == NULL)
        return NULL;

    ar[0] = NULL;

    return ar;
}

char **strdyn_create_va(char *s1, ...) {
    register char **ar;

    if ((ar = strdyn_create()) == NULL)
        return NULL;

    if (s1 != NULL) {
        register char *s;
        va_list ap;

        if ((ar = strdyn_add(ar, s1)) == NULL)
            return NULL;

        va_start(ap, s1);

        while ((s = va_arg(ap, char *)) != NULL)
            if ((ar = strdyn_add(ar, s)) == NULL)
                return NULL;

        va_end(ap);
    }

    return ar;
}

char **strdyn_add(char **ar, const char *s) {
    register int count;

    if (ar == NULL)
        if ((ar = strdyn_create()) == NULL)
            return NULL;

    count = strdyn_get_size(ar);

    if ((ar = (char **) realloc(ar, (count + 2) * sizeof(char *))) == NULL)
        return NULL;

    ar[count] = strdup(s);
    ar[count + 1] = NULL;

    return ar;
}

char **strdyn_add_va(char **ar, ...) {
    register char *s;
    va_list ap;

    if (ar == NULL)
        if ((ar = strdyn_create()) == NULL)
            return NULL;

    va_start(ap, ar);

    while ((s = va_arg(ap, char *)) != NULL)
        if ((ar = strdyn_add(ar, s)) == NULL)
            return NULL;

    va_end(ap);

    return ar;
}

char **strdyn_add_ar(char **ar, char * const *s_ar) {
    register int k;

    for (k = 0; s_ar[k] != NULL; k++) {
        if ((ar = strdyn_add(ar, s_ar[k])) == NULL)
            return NULL;
    }

    return ar;
}

char **strdyn_duplicate(char **ar) {
    register int i;
    register char **new_ar;

    if ((new_ar = (char**) malloc((strdyn_get_size(ar) + 1)
                                    * sizeof(char*))) == NULL)
        return NULL;

    for (i = 0; ar[i] != NULL; i++)
        new_ar[i] = strdup(ar[i]);

    new_ar[i] = NULL;

    return new_ar;
}

char **strdyn_remove_empty(char **ar) {
    register int i, j;

    for (i = 0; ar[i] != NULL; ) {

        if (strlen(ar[i]) == 0) {
            free(ar[i]);

            for (j = i; ar[j] != NULL; j++)
                ar[j] = ar[j + 1];
        }
        else
            i++;
    }

    if ((ar = (char**) realloc(ar, (i + 1) * sizeof(char*))) == NULL)
        return NULL;

    return ar;
}

char **strdyn_explode_chr(char *str, char sep) {
    char sep_str[2];

    sep_str[0] = sep;
    sep_str[1] = '\0';

    return strdyn_explode_str(str, sep_str);
}

char **strdyn_explode2_chr(char *str, char sep) {

    return strdyn_remove_empty(strdyn_explode_chr(str, sep));
}

char **strdyn_explode_str(char *str, char *sep) {
    register char **ar;
    register char *s;
    register int ar_size, s_size, sep_size, i;

    if (str == NULL || sep == NULL)
        return NULL;

    ar_size = strcnt_sepstr(str, sep);

    if ((ar = (char**) malloc((ar_size + 2) * sizeof(char*))) == NULL)
        return NULL;

    sep_size = strlen(sep);

    for (s = str, i = 0; i < ar_size; i++, s += s_size + sep_size) {

        s_size = strstr(s, sep) - s;

        if ((ar[i] = (char*) malloc((s_size + 1) * sizeof(char))) == NULL)
            return NULL;

        strncpy(ar[i], s, s_size);
        ar[i][s_size] = '\0';
    }

    if ((ar[ar_size] = strdup(s)) == NULL)
        return NULL;

    ar[ar_size + 1] = NULL;

    return ar;

}

char **strdyn_explode2_str(char *str, char *sep) {

    return strdyn_remove_empty(strdyn_explode_str(str, sep));
}

char *strdyn_implode_chr(char **ar, char sep) {
    char sep_str[2];

    sep_str[0] = sep;
    sep_str[1] = '\0';

    return strdyn_implode_str(ar, sep_str);
}

char *strdyn_implode2_chr(char **ar, char sep) {
    register char **new_ar;
    register char *s;

    new_ar = strdyn_remove_empty(strdyn_duplicate(ar));

    s = strdyn_implode_chr(new_ar, sep);

    strdyn_free(new_ar);

    return s;
}

char *strdyn_implode_str(char **ar, char *sep) {
    register int i, str_size, sep_size;
    register char *str, *s;

    sep_size = strlen(sep);

    for (i = 0, str_size = 0; ar[i] != NULL; )
        str_size += strlen(ar[i++]) + sep_size;

    if ((str = (char*) malloc(str_size * sizeof(char))) == NULL)
        return NULL;

    for (i = 0,    s = str; ar[i] != NULL; i++) {
        strcpy(s, ar[i]);
        s += strlen(ar[i]);

        if (ar[i + 1] != NULL)
            strcpy(s, sep);
        s += sep_size;
    }

    return str;
}

char *strdyn_implode2_str(char **ar, char *str) {
    register char **new_ar;
    register char *s;

    new_ar = strdyn_remove_empty(strdyn_duplicate(ar));

    s = strdyn_implode_str(new_ar, str);

    strdyn_free(new_ar);

    return s;
}

char **strdyn_conjunct(char **ar1, char **ar2) {
    register int i;
    register char **ar;

    if ((ar = strdyn_create()) == NULL)
        return NULL;

    for (i = 0; ar2[i] != NULL; i++) {
        if (! strdyn_compare(ar1, ar2[i])) {
            if ((ar = strdyn_add(ar, ar2[i])) == NULL)
                return NULL;
        }
    }

    return ar;
}

char **strdyn_consolide(char **ar1, char **ar2) {
    register int i;
    register char **ar;

    if ((ar = strdyn_create()) == NULL)
        return NULL;

    for (i = 0; ar1[i] != NULL; i++) {
        if (strdyn_compare(ar, ar1[i])) {
            if ((ar = strdyn_add(ar, ar1[i])) == NULL)
                return NULL;
        }
    }

    for (i = 0; ar2[i] != NULL; i++) {
        if (strdyn_compare(ar, ar2[i])) {
            if ((ar = strdyn_add(ar, ar2[i])) == NULL)
                return NULL;
        }
    }

    return ar;
}

int strdyn_search(char **ar, char *s) {
    register int i;

    for (i = 0; ar[i] != NULL; i++)
        if (! strcmp(ar[i], s))
            return i;

    return -1;
}

int strdyn_compare(char **ar, char *s) {
    return strdyn_search(ar, s) < 0 ? -1 : 0;
}

int strdyn_compare_all(char **ar, char *s) {
    register int i;

    for (i = 0; ar[i] != NULL; i++)
        if (strcmp(ar[i], s))
            return -1;

    return 0;
}

#if defined(SELF) || defined(SELFTEST) || defined(SELF_STRDYN)

#define TESTSTR1 "___AAA_BBBB__C_DaDaD____"
#define TESTSEP1 '_'
#define TESTSEP2 "__"

int main(void) {

    register int i;
    char **ar1, **ar2, **ar_join, **ar_intersect;
    char *s;

    ar2 = strdyn_create_va("A", "B", "C", "D", NULL);

    i = 0;
    while (ar2[i] != NULL) {
        printf("ar2[%d] = \"%s\"\n", i, ar2[i]);
        i++;
    }

    printf("strdyn_explode2_chr(\"%s\", '%c') = ar1\n", TESTSTR1, TESTSEP1);
    ar1 = strdyn_explode2_chr(TESTSTR1, TESTSEP1);

    puts("strdyn_free(ar1)");
    strdyn_free(ar1);

    printf("strdyn_explode_str(\"%s\", \"%s\") = ar1\n", TESTSTR1, TESTSEP2);
    ar1 = strdyn_explode_str(TESTSTR1, TESTSEP2);

    for (i = 0; ar1[i] != NULL; i++)
        printf("ar1[%d] = \"%s\"\n", i, ar1[i]);

    s = strdyn_implode2_chr(ar1, TESTSEP1);
    printf("strdyn_implode2_chr(ar1, '%c') = \"%s\"\n", TESTSEP1, s);

    puts("free(s)");
    free(s);

    s = strdyn_implode2_str(ar1, TESTSEP2);
    printf("strdyn_implode2_str(ar1, \"%s\") = \"%s\"\n", TESTSEP2, s);

    puts("free(s)");
    free(s);

    ar_join = strdyn_join(ar1, ar2);
    ar_intersect = strdyn_intersect(ar1, ar2);

    i = 0;
    while (ar_join[i] != NULL) {
        printf("ar_join[%d] = \"%s\"\n", i, ar_join[i]);
        i++;
    }

    i = 0;
    while (ar_intersect[i] != NULL) {
        printf("ar_intersect[%d] = \"%s\"\n", i, ar_intersect[i]);
        i++;
    }

    puts("strdyn_free(ar1)");
    strdyn_free(ar1);

    puts("strdyn_free(ar2)");
    strdyn_free(ar2);

    puts("strdyn_free(ar_join)");
    strdyn_free(ar_join);

    puts("strdyn_free(ar_intersect)");
    strdyn_free(ar_intersect);


    return 0;
}

#endif



Platon Group <platon@platon.sk> http://platon.sk/
Copyright © 2002-2006 Platon Group
Stránka používa redakčný systém Metafox
Na začiatok