ermyth/src/string.C

/*
 * Copyright © 2005 Atheme Development Group
 * Rights to this code are documented in doc/pod/license.pod.
 *
 * String functions.
 */

static char const rcsid[] = "$Id: string.C,v 1.5 2007-08-30 19:56:26 pippijn Exp $";

#include "atheme.h"
#include <common/string.h>

char *
sstrdup (char const * const s)
{
  char *t;
  size_t len;

  if (s == NULL)
    return NULL;

  t = salloc<char> (len = strlen (s) + 1);

  strlcpy (t, s, len);
  return t;
}

char *
sstrndup (char const *s, int len)
{
  char *t;

  if (s == NULL)
    return NULL;

  t = salloc<char> (len + 1);

  strlcpy (t, s, len);
  return t;
}

void
assign (char *dst, char const *src, size_t maxlen)
{
  if (!src)
    src = "";

  size_t len = strlen (src);

  if (len >= maxlen - 1)
    {
      if (maxlen <= 4)
        {
          memset (dst, '.', maxlen - 1);
          dst [maxlen - 1] = 0;
        }
      else
        {
          memcpy (dst, src, maxlen - 4);
          memcpy (dst + maxlen - 4, "...", 4);
        }
    }
  else
    memcpy (dst, src, len + 1);
}

#ifndef HAVE_STRLCAT
/* These functions are taken from Linux. */
size_t
strlcat (char *dest, char const *src, size_t count)
{
  size_t dsize = strlen (dest);
  size_t len = strlen (src);
  size_t res = dsize + len;

  dest += dsize;
  count -= dsize;
  if (len >= count)
    len = count - 1;
  memcpy (dest, src, len);
  dest[len] = 0;
  return res;
}
#endif

#ifndef HAVE_STRLCPY
size_t
strlcpy (char *dest, char const *src, size_t size)
{
  size_t ret = strlen (src);

  if (size)
    {
      size_t len = (ret >= size) ? size - 1 : ret;
      memcpy (dest, src, len);
      dest[len] = '\0';
    }
  return ret;
}
#endif

/* removes unwanted chars from a line */
char const *
strip (char *line)
{
  char *c = 0;

  if (line)
    {
      if ((c = strchr (line, '\n')))
        *c = '\0';
      if ((c = strchr (line, '\r')))
        *c = '\0';
      if ((c = strchr (line, '\1')))
        *c = '\0';
    }

  return c;
}

int
dynstr::add (char c)
{
  if (length - pos <= 1)
    {
      size_t new_size = std::max (length * 2, pos + 9);
      length = new_size;
      m_rep = new char[new_size];
    }
  m_rep[pos] = c;
  m_rep[++pos] = '\0';

  return length;
}

int
dynstr::add (char const *src, size_t len)
{
  if (length - pos <= len)
    {
      size_t new_size = std::max (length * 2, pos + len + 8);
      length = new_size;
      m_rep = new char[new_size];
    }
  memcpy (m_rep + pos, src, len);
  pos += len;
  m_rep[pos] = '\0';

  return len;
}
Revision:	1.6
Committed:	Wed Sep 5 11:23:15 2007 UTC (19 years, 1 month ago) by pippijn
Content type:	text/plain
Branch:	MAIN
Changes since 1.5:	+33 -1 lines
Log Message:	removed GPLed code and put license back to BSD
#	User	Rev	Content
1	pippijn	1.1	/*
2			* Copyright © 2005 Atheme Development Group
3	pippijn	1.2	* Rights to this code are documented in doc/pod/license.pod.
4	pippijn	1.1	*
5			* String functions.
6			*/
7
8	pippijn	1.6	static char const rcsid[] = "$Id: string.C,v 1.5 2007-08-30 19:56:26 pippijn Exp $";
9	pippijn	1.1
10	pippijn	1.4	#include "atheme.h"
11	pippijn	1.6	#include <common/string.h>
12	pippijn	1.4
13			char *
14			sstrdup (char const * const s)
15			{
16			char *t;
17			size_t len;
18
19			if (s == NULL)
20			return NULL;
21
22	pippijn	1.5	t = salloc<char> (len = strlen (s) + 1);
23	pippijn	1.4
24			strlcpy (t, s, len);
25			return t;
26			}
27
28			char *
29			sstrndup (char const *s, int len)
30			{
31			char *t;
32
33			if (s == NULL)
34			return NULL;
35	pippijn	1.1
36	pippijn	1.5	t = salloc<char> (len + 1);
37	pippijn	1.4
38			strlcpy (t, s, len);
39			return t;
40			}
41	pippijn	1.1
42			void
43			assign (char dst, char const src, size_t maxlen)
44			{
45			if (!src)
46			src = "";
47
48			size_t len = strlen (src);
49
50			if (len >= maxlen - 1)
51			{
52			if (maxlen <= 4)
53			{
54			memset (dst, '.', maxlen - 1);
55			dst [maxlen - 1] = 0;
56			}
57			else
58			{
59			memcpy (dst, src, maxlen - 4);
60			memcpy (dst + maxlen - 4, "...", 4);
61			}
62			}
63			else
64			memcpy (dst, src, len + 1);
65			}
66
67			#ifndef HAVE_STRLCAT
68			/* These functions are taken from Linux. */
69			size_t
70			strlcat (char dest, char const src, size_t count)
71			{
72			size_t dsize = strlen (dest);
73			size_t len = strlen (src);
74			size_t res = dsize + len;
75
76			dest += dsize;
77			count -= dsize;
78			if (len >= count)
79			len = count - 1;
80			memcpy (dest, src, len);
81			dest[len] = 0;
82			return res;
83			}
84			#endif
85
86			#ifndef HAVE_STRLCPY
87			size_t
88			strlcpy (char dest, char const src, size_t size)
89			{
90			size_t ret = strlen (src);
91
92			if (size)
93			{
94			size_t len = (ret >= size) ? size - 1 : ret;
95			memcpy (dest, src, len);
96			dest[len] = '\0';
97			}
98			return ret;
99			}
100			#endif
101
102			/* removes unwanted chars from a line */
103			char const *
104			strip (char *line)
105			{
106			char *c = 0;
107
108			if (line)
109			{
110			if ((c = strchr (line, '\n')))
111			*c = '\0';
112			if ((c = strchr (line, '\r')))
113			*c = '\0';
114			if ((c = strchr (line, '\1')))
115			*c = '\0';
116			}
117
118			return c;
119			}
120	pippijn	1.6
121			int
122			dynstr::add (char c)
123			{
124			if (length - pos <= 1)
125			{
126			size_t new_size = std::max (length * 2, pos + 9);
127			length = new_size;
128			m_rep = new char[new_size];
129			}
130			m_rep[pos] = c;
131			m_rep[++pos] = '\0';
132
133			return length;
134			}
135
136			int
137			dynstr::add (char const *src, size_t len)
138			{
139			if (length - pos <= len)
140			{
141			size_t new_size = std::max (length * 2, pos + len + 8);
142			length = new_size;
143			m_rep = new char[new_size];
144			}
145			memcpy (m_rep + pos, src, len);
146			pos += len;
147			m_rep[pos] = '\0';
148
149			return len;
150			}