byacc-20141006: Adjust some forgotten things on the vendor branch.
[dragonfly.git] / contrib / byacc / mstring.c
1 /* $Id: mstring.c,v 1.6 2014/04/22 23:36:31 tom Exp $ */
2
3 #include <stdlib.h>
4 #include <stdio.h>
5 #include <stdarg.h>
6 #include <ctype.h>
7 #include <string.h>
8 #include "defs.h"
9
10 /* parameters about string length.  HEAD is the starting size and
11 ** HEAD+TAIL should be a power of two */
12 #define HEAD    24
13 #define TAIL    8
14
15 #if defined(YYBTYACC)
16
17 static char *buf_ptr;
18 static size_t buf_len;
19
20 void
21 msprintf(struct mstring *s, const char *fmt,...)
22 {
23     va_list args;
24     size_t len;
25 #ifdef HAVE_VSNPRINTF
26     int changed;
27 #endif
28
29     if (!s || !s->base)
30         return;
31
32     if (buf_len == 0)
33     {
34         buf_ptr = malloc(buf_len = 4096);
35     }
36     if (buf_ptr == 0)
37     {
38         return;
39     }
40
41 #ifdef HAVE_VSNPRINTF
42     do
43     {
44         va_start(args, fmt);
45         len = (size_t) vsnprintf(buf_ptr, buf_len, fmt, args);
46         va_end(args);
47         if ((changed = (len > buf_len)) != 0)
48         {
49             char *new_ptr = realloc(buf_ptr, (buf_len * 3) / 2);
50             if (new_ptr == 0)
51             {
52                 free(buf_ptr);
53                 buf_ptr = 0;
54                 return;
55             }
56             buf_ptr = new_ptr;
57         }
58     }
59     while (changed);
60 #else
61     va_start(args, fmt);
62     len = (size_t) vsprintf(buf_ptr, fmt, args);
63     va_end(args);
64     if (len >= buf_len)
65         return;
66 #endif
67
68     if (len > (size_t) (s->end - s->ptr))
69     {
70         char *new_base;
71         size_t cp = (size_t) (s->ptr - s->base);
72         size_t cl = (size_t) (s->end - s->base);
73         size_t nl = cl;
74         while (len > (nl - cp))
75             nl = nl + nl + TAIL;
76         if ((new_base = realloc(s->base, nl)))
77         {
78             s->base = new_base;
79             s->ptr = s->base + cp;
80             s->end = s->base + nl;
81         }
82         else
83         {
84             free(s->base);
85             s->base = 0;
86             s->ptr = 0;
87             s->end = 0;
88             return;
89         }
90     }
91     memcpy(s->ptr, buf_ptr, len);
92     s->ptr += len;
93 }
94 #endif
95
96 int
97 mputchar(struct mstring *s, int ch)
98 {
99     if (!s || !s->base)
100         return ch;
101     if (s->ptr == s->end)
102     {
103         size_t len = (size_t) (s->end - s->base);
104         if ((s->base = realloc(s->base, len + len + TAIL)))
105         {
106             s->ptr = s->base + len;
107             s->end = s->base + len + len + TAIL;
108         }
109         else
110         {
111             s->ptr = s->end = 0;
112             return ch;
113         }
114     }
115     *s->ptr++ = (char)ch;
116     return ch;
117 }
118
119 struct mstring *
120 msnew(void)
121 {
122     struct mstring *n = TMALLOC(struct mstring, 1);
123
124     if (n)
125     {
126         if ((n->base = n->ptr = MALLOC(HEAD)) != 0)
127         {
128             n->end = n->base + HEAD;
129         }
130         else
131         {
132             free(n);
133             n = 0;
134         }
135     }
136     return n;
137 }
138
139 char *
140 msdone(struct mstring *s)
141 {
142     char *r = 0;
143     if (s)
144     {
145         mputc(s, 0);
146         r = s->base;
147         free(s);
148     }
149     return r;
150 }
151
152 #if defined(YYBTYACC)
153 /* compare two strings, ignoring whitespace, except between two letters or
154 ** digits (and treat all of these as equal) */
155 int
156 strnscmp(const char *a, const char *b)
157 {
158     while (1)
159     {
160         while (isspace(*a))
161             a++;
162         while (isspace(*b))
163             b++;
164         while (*a && *a == *b)
165             a++, b++;
166         if (isspace(*a))
167         {
168             if (isalnum(a[-1]) && isalnum(*b))
169                 break;
170         }
171         else if (isspace(*b))
172         {
173             if (isalnum(b[-1]) && isalnum(*a))
174                 break;
175         }
176         else
177             break;
178     }
179     return *a - *b;
180 }
181
182 unsigned int
183 strnshash(const char *s)
184 {
185     unsigned int h = 0;
186
187     while (*s)
188     {
189         if (!isspace(*s))
190             h = (h << 5) - h + (unsigned char)*s;
191         s++;
192     }
193     return h;
194 }
195 #endif
196
197 #ifdef NO_LEAKS
198 void
199 mstring_leaks(void)
200 {
201 #if defined(YYBTYACC)
202     free(buf_ptr);
203     buf_ptr = 0;
204     buf_len = 0;
205 #endif
206 }
207 #endif