source: tags/ms_r18q1/CORE/arb_string.h

#ifndef ARB_STRING_H
#define ARB_STRING_H

#ifndef ARB_MEM_H
#include "arb_mem.h"
#endif
#ifndef ARB_ASSERT_H
#include "arb_assert.h"
#endif
#ifndef _GLIBCXX_CSTRING
#include <cstring>
#endif

inline char *ARB_strdup(const char *str) {
    char *dup = strdup(str);
    if (!dup) arb_mem::failed_to_allocate(strlen(str));
    return dup;
}

inline char *ARB_strduplen(const char *p, unsigned len) {
    // fast replacement for strdup, if len is known
    if (p) {
        char *neu;

        arb_assert(strlen(p) == len);
        // Note: Common reason for failure: a zero-char was manually printed by a GBS_global_string...-function

        ARB_alloc(neu, len+1);
        memcpy(neu, p, len+1);
        return neu;
    }
    return NULp;
}

inline char *ARB_strpartdup(const char *start, const char *end) {
    /* strdup of a part of a string (including 'start' and 'end')
     * 'end' may point behind end of string -> copy only till zero byte
     * if 'start' is NULp   -> return NULp
     * if 'end'   is NULp   -> copy whole string
     * if 'end'=('start'-1) -> return ""
     * if 'end'<('start'-1) -> return NULp
     */

    char *result;
    if (start && end) {
        int len = end-start+1;

        if (len >= 0) {
            const char *eos = (const char *)memchr(start, 0, len);

            if (eos) len = eos-start;
            ARB_alloc(result, len+1);
            memcpy(result, start, len);
            result[len] = 0;
        }
        else {
            result = NULp;
        }
    }
    else { // end = 0 -> return copy of complete string
        result = nulldup(start);
    }

    return result;
}

inline char *ARB_strndup(const char *start, int len) {
    return start ? ARB_strpartdup(start, start+len-1) : NULp;
}


const char *ARB_date_string(void);
const char *ARB_dateTime_suffix(void);
const char *ARB_keep_string(char *str);

#else
#error arb_string.h included twice
#endif /* ARB_STRING_H */