xref: /netbsd/src/usr.bin/make/str.h

/*        $NetBSD: str.h,v 1.20 2024/07/07 07:50:57 rillig Exp $      */

/*
 Copyright (c) 2021 Roland Illig <rillig@NetBSD.org>
 All rights reserved.

 Redistribution and use in source and binary forms, with or without
 modification, are permitted provided that the following conditions
 are met:

 1. Redistributions of source code must retain the above copyright
    notice, this list of conditions and the following disclaimer.
 2. Redistributions in binary form must reproduce the above copyright
    notice, this list of conditions and the following disclaimer in the
    documentation and/or other materials provided with the distribution.

 THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
 TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
 PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS
 BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
 SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
 INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
 CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 POSSIBILITY OF SUCH DAMAGE.
 */


/*
 * Memory-efficient string handling.
 */


/* A read-only string that may need to be freed after use. */
typedef struct FStr {
          const char *str;
          void *freeIt;
} FStr;

/* A read-only range of a character array, NOT null-terminated. */
typedef struct Substring {
          const char *start;
          const char *end;
} Substring;

/*
 * Builds a string, only allocating memory if the string is different from the
 * expected string.
 */
typedef struct LazyBuf {
          char *data;
          size_t len;
          size_t cap;
          const char *expected;
} LazyBuf;

/* The result of splitting a string into words. */
typedef struct Words {
          char **words;
          size_t len;
          void *freeIt;
} Words;

/* The result of splitting a string into words. */
typedef struct SubstringWords {
          Substring *words;
          size_t len;
          void *freeIt;
} SubstringWords;

typedef struct StrMatchResult {
          const char *error;
          bool matched;
} StrMatchResult;


/* Return a string that is the sole owner of str. */
MAKE_INLINE FStr
FStr_InitOwn(char *str)
{
          FStr fstr;
          fstr.str = str;
          fstr.freeIt = str;
          return fstr;
}

/* Return a string that refers to the shared str. */
MAKE_INLINE FStr
FStr_InitRefer(const char *str)
{
          FStr fstr;
          fstr.str = str;
          fstr.freeIt = NULL;
          return fstr;
}

MAKE_INLINE void
FStr_Done(FStr *fstr)
{
          free(fstr->freeIt);
#ifdef CLEANUP
          fstr->str = NULL;
          fstr->freeIt = NULL;
#endif
}


MAKE_STATIC Substring
Substring_Init(const char *start, const char *end)
{
          Substring sub;

          sub.start = start;
          sub.end = end;
          return sub;
}

MAKE_INLINE Substring
Substring_InitStr(const char *str)
{
          return Substring_Init(str, str + strlen(str));
}

MAKE_STATIC size_t
Substring_Length(Substring sub)
{
          return (size_t)(sub.end - sub.start);
}

MAKE_STATIC bool
Substring_IsEmpty(Substring sub)
{
          return sub.start == sub.end;
}

MAKE_INLINE bool
Substring_Equals(Substring sub, const char *str)
{
          size_t len = strlen(str);
          return Substring_Length(sub) == len &&
                 memcmp(sub.start, str, len) == 0;
}

MAKE_INLINE bool
Substring_Eq(Substring sub, Substring str)
{
          size_t len = Substring_Length(sub);
          return len == Substring_Length(str) &&
                 memcmp(sub.start, str.start, len) == 0;
}

MAKE_STATIC bool
Substring_HasPrefix(Substring sub, Substring prefix)
{
          return Substring_Length(sub) >= Substring_Length(prefix) &&
                 memcmp(sub.start, prefix.start, Substring_Length(prefix)) == 0;
}

MAKE_STATIC bool
Substring_HasSuffix(Substring sub, Substring suffix)
{
          size_t suffixLen = Substring_Length(suffix);
          return Substring_Length(sub) >= suffixLen &&
                 memcmp(sub.end - suffixLen, suffix.start, suffixLen) == 0;
}

/* Returns an independent, null-terminated copy of the substring. */
MAKE_STATIC FStr
Substring_Str(Substring sub)
{
          if (Substring_IsEmpty(sub))
                    return FStr_InitRefer("");
          return FStr_InitOwn(bmake_strsedup(sub.start, sub.end));
}

MAKE_STATIC const char *
Substring_SkipFirst(Substring sub, char ch)
{
          const char *p;

          for (p = sub.start; p != sub.end; p++)
                    if (*p == ch)
                              return p + 1;
          return sub.start;
}

MAKE_STATIC const char *
Substring_FindLast(Substring sub, char ch)
{
          const char *p;

          for (p = sub.end; p != sub.start; p--)
                    if (p[-1] == ch)
                              return p - 1;
          return NULL;
}

MAKE_STATIC Substring
Substring_Dirname(Substring pathname)
{
          const char *p;

          for (p = pathname.end; p != pathname.start; p--)
                    if (p[-1] == '/')
                              return Substring_Init(pathname.start, p - 1);
          return Substring_InitStr(".");
}

MAKE_STATIC Substring
Substring_Basename(Substring pathname)
{
          const char *p;

          for (p = pathname.end; p != pathname.start; p--)
                    if (p[-1] == '/')
                              return Substring_Init(p, pathname.end);
          return pathname;
}


MAKE_STATIC void
LazyBuf_Init(LazyBuf *buf, const char *expected)
{
          buf->data = NULL;
          buf->len = 0;
          buf->cap = 0;
          buf->expected = expected;
}

MAKE_INLINE void
LazyBuf_Done(LazyBuf *buf)
{
          free(buf->data);
}

MAKE_STATIC void
LazyBuf_Add(LazyBuf *buf, char ch)
{

          if (buf->data != NULL) {
                    if (buf->len == buf->cap) {
                              buf->cap *= 2;
                              buf->data = bmake_realloc(buf->data, buf->cap);
                    }
                    buf->data[buf->len++] = ch;

          } else if (ch == buf->expected[buf->len]) {
                    buf->len++;
                    return;

          } else {
                    buf->cap = buf->len + 16;
                    buf->data = bmake_malloc(buf->cap);
                    memcpy(buf->data, buf->expected, buf->len);
                    buf->data[buf->len++] = ch;
          }
}

MAKE_STATIC void
LazyBuf_AddStr(LazyBuf *buf, const char *str)
{
          const char *p;

          for (p = str; *p != '\0'; p++)
                    LazyBuf_Add(buf, *p);
}

MAKE_INLINE void
LazyBuf_AddSubstring(LazyBuf *buf, Substring sub)
{
          const char *p;

          for (p = sub.start; p != sub.end; p++)
                    LazyBuf_Add(buf, *p);
}

MAKE_STATIC Substring
LazyBuf_Get(const LazyBuf *buf)
{
          const char *start = buf->data != NULL ? buf->data : buf->expected;
          return Substring_Init(start, start + buf->len);
}

/*
 * Returns the content of the buffer as a newly allocated string.
 *
 * See LazyBuf_Get to avoid unnecessary memory allocations.
 */
MAKE_STATIC FStr
LazyBuf_DoneGet(LazyBuf *buf)
{
          if (buf->data != NULL) {
                    LazyBuf_Add(buf, '\0');
                    return FStr_InitOwn(buf->data);
          }
          return Substring_Str(LazyBuf_Get(buf));
}


Words Str_Words(const char *, bool);

MAKE_INLINE void
Words_Free(Words w)
{
          free(w.words);
          free(w.freeIt);
}


SubstringWords Substring_Words(const char *, bool);

MAKE_INLINE void
SubstringWords_Init(SubstringWords *w)
{
          w->words = NULL;
          w->len = 0;
          w->freeIt = NULL;
}

MAKE_INLINE void
SubstringWords_Free(SubstringWords w)
{
          free(w.words);
          free(w.freeIt);
}


char *str_concat2(const char *, const char *);
char *str_concat3(const char *, const char *, const char *);

StrMatchResult Str_Match(const char *, const char *);

void Str_Intern_Init(void);
#ifdef CLEANUP
void Str_Intern_End(void);
#endif
const char *Str_Intern(const char *);