|
375
|
1 /* readtokens.c -- Functions for reading tokens from an input stream. |
|
|
2 Copyright (C) 1990-1991 Jim Meyering. |
|
|
3 |
|
|
4 This program is free software; you can redistribute it and/or modify |
|
|
5 it under the terms of the GNU General Public License as published by |
|
|
6 the Free Software Foundation; either version 2, or (at your option) |
|
|
7 any later version. |
|
|
8 |
|
|
9 This program is distributed in the hope that it will be useful, |
|
|
10 but WITHOUT ANY WARRANTY; without even the implied warranty of |
|
|
11 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
|
|
12 GNU General Public License for more details. |
|
|
13 |
|
|
14 You should have received a copy of the GNU General Public License |
|
|
15 along with this program; if not, write to the Free Software |
|
|
16 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. |
|
|
17 |
|
|
18 Written by Jim Meyering. */ |
|
|
19 |
|
|
20 /* This almost supercedes xreadline stuff -- using delim="\n" |
|
|
21 gives the same functionality, except that these functions |
|
|
22 would never return empty lines. |
|
|
23 |
|
|
24 To Do: |
|
|
25 - To allow '\0' as a delimiter, I will have to change |
|
|
26 interfaces to permit specification of delimiter-string |
|
|
27 length. |
|
|
28 */ |
|
|
29 |
|
|
30 #ifdef HAVE_CONFIG_H |
|
|
31 #include <config.h> |
|
|
32 #endif |
|
|
33 |
|
|
34 #include <stdio.h> |
|
|
35 |
|
|
36 #ifdef STDC_HEADERS |
|
|
37 #include <stdlib.h> |
|
|
38 #endif |
|
|
39 |
|
|
40 #if defined (STDC_HEADERS) || defined(HAVE_STRING_H) |
|
|
41 #include <string.h> |
|
|
42 /* An ANSI string.h and pre-ANSI memory.h might conflict. */ |
|
|
43 #if !defined (STDC_HEADERS) && defined (HAVE_MEMORY_H) |
|
|
44 #include <memory.h> |
|
|
45 #endif /* not STDC_HEADERS and HAVE_MEMORY_H */ |
|
|
46 #else /* not STDC_HEADERS and not HAVE_STRING_H */ |
|
|
47 #include <strings.h> |
|
|
48 /* memory.h and strings.h conflict on some systems. */ |
|
|
49 #endif /* not STDC_HEADERS and not HAVE_STRING_H */ |
|
|
50 |
|
|
51 #include "readtokens.h" |
|
|
52 #include "xalloc.h" |
|
|
53 |
|
|
54 #define STREQ(a,b) ((a) == (b) || ((a) && (b) && *(a) == *(b) \ |
|
|
55 && strcmp(a, b) == 0)) |
|
|
56 |
|
|
57 /* Initialize a tokenbuffer. */ |
|
|
58 |
|
|
59 void |
|
|
60 init_tokenbuffer (token_buffer *tokenbuffer) |
|
|
61 { |
|
|
62 tokenbuffer->size = INITIAL_TOKEN_LENGTH; |
|
|
63 tokenbuffer->buffer = ((char *) xmalloc (INITIAL_TOKEN_LENGTH)); |
|
|
64 } |
|
|
65 |
|
|
66 /* Read a token from `stream' into `tokenbuffer'. |
|
|
67 Upon return, the token is in tokenbuffer->buffer and |
|
|
68 has a trailing '\0' instead of the original delimiter. |
|
|
69 The function value is the length of the token not including |
|
|
70 the final '\0'. When EOF is reached (i.e. on the call |
|
|
71 after the last token is read), -1 is returned and tokenbuffer |
|
|
72 isn't modified. |
|
|
73 |
|
|
74 This function will work properly on lines containing NUL bytes |
|
|
75 and on files that aren't newline-terminated. */ |
|
|
76 |
|
|
77 long |
|
|
78 readtoken (FILE *stream, const char *delim, int n_delim, |
|
|
79 token_buffer *tokenbuffer) |
|
|
80 { |
|
|
81 char *p; |
|
|
82 int c, i, n; |
|
|
83 static const char *saved_delim = NULL; |
|
|
84 static char isdelim[256]; |
|
|
85 int same_delimiters; |
|
|
86 |
|
|
87 if (delim == NULL && saved_delim == NULL) |
|
|
88 abort (); |
|
|
89 |
|
|
90 same_delimiters = 0; |
|
|
91 if (delim != saved_delim && saved_delim != NULL) |
|
|
92 { |
|
|
93 same_delimiters = 1; |
|
|
94 for (i = 0; i < n_delim; i++) |
|
|
95 { |
|
|
96 if (delim[i] != saved_delim[i]) |
|
|
97 { |
|
|
98 same_delimiters = 0; |
|
|
99 break; |
|
|
100 } |
|
|
101 } |
|
|
102 } |
|
|
103 |
|
|
104 if (!same_delimiters) |
|
|
105 { |
|
|
106 const char *t; |
|
|
107 saved_delim = delim; |
|
|
108 for (i = 0; i < sizeof (isdelim); i++) |
|
|
109 isdelim[i] = 0; |
|
|
110 for (t = delim; *t; t++) |
|
|
111 isdelim[(unsigned int) *t] = 1; |
|
|
112 } |
|
|
113 |
|
|
114 p = tokenbuffer->buffer; |
|
|
115 n = tokenbuffer->size; |
|
|
116 i = 0; |
|
|
117 |
|
|
118 /* FIXME: don't fool with this caching BS. Use strchr instead. */ |
|
|
119 /* skip over any leading delimiters */ |
|
|
120 for (c = getc (stream); c >= 0 && isdelim[c]; c = getc (stream)) |
|
|
121 { |
|
|
122 /* empty */ |
|
|
123 } |
|
|
124 |
|
|
125 for (;;) |
|
|
126 { |
|
|
127 if (i >= n) |
|
|
128 { |
|
|
129 n = 3 * (n / 2 + 1); |
|
|
130 p = xrealloc (p, (unsigned int) n); |
|
|
131 } |
|
|
132 if (c < 0) |
|
|
133 { |
|
|
134 if (i == 0) |
|
|
135 return (-1); |
|
|
136 p[i] = 0; |
|
|
137 break; |
|
|
138 } |
|
|
139 if (isdelim[c]) |
|
|
140 { |
|
|
141 p[i] = 0; |
|
|
142 break; |
|
|
143 } |
|
|
144 p[i++] = c; |
|
|
145 c = getc (stream); |
|
|
146 } |
|
|
147 |
|
|
148 tokenbuffer->buffer = p; |
|
|
149 tokenbuffer->size = n; |
|
|
150 return (i); |
|
|
151 } |
|
|
152 |
|
|
153 /* Return a NULL-terminated array of pointers to tokens |
|
|
154 read from `stream.' The number of tokens is returned |
|
|
155 as the value of the function. |
|
|
156 All storage is obtained through calls to malloc(); |
|
|
157 |
|
|
158 %%% Question: is it worth it to do a single |
|
|
159 %%% realloc() of `tokens' just before returning? */ |
|
|
160 |
|
|
161 int |
|
|
162 readtokens (FILE *stream, int projected_n_tokens, |
|
|
163 const char *delim, int n_delim, |
|
|
164 char ***tokens_out, long **token_lengths) |
|
|
165 { |
|
|
166 token_buffer tb, *token = &tb; |
|
|
167 int token_length; |
|
|
168 char **tokens; |
|
|
169 long *lengths; |
|
|
170 int sz; |
|
|
171 int n_tokens; |
|
|
172 |
|
|
173 n_tokens = 0; |
|
|
174 if (projected_n_tokens > 0) |
|
|
175 projected_n_tokens++; /* add one for trailing NULL pointer */ |
|
|
176 else |
|
|
177 projected_n_tokens = 64; |
|
|
178 sz = projected_n_tokens; |
|
|
179 tokens = (char **) xmalloc (sz * sizeof (char *)); |
|
|
180 lengths = (long *) xmalloc (sz * sizeof (long)); |
|
|
181 |
|
|
182 init_tokenbuffer (token); |
|
|
183 for (;;) |
|
|
184 { |
|
|
185 char *tmp; |
|
|
186 token_length = readtoken (stream, delim, n_delim, token); |
|
|
187 if (n_tokens >= sz) |
|
|
188 { |
|
|
189 sz *= 2; |
|
|
190 tokens = (char **) xrealloc (tokens, sz * sizeof (char *)); |
|
|
191 lengths = (long *) xrealloc (lengths, sz * sizeof (long)); |
|
|
192 } |
|
|
193 |
|
|
194 if (token_length < 0) |
|
|
195 { |
|
|
196 /* don't increment n_tokens for NULL entry */ |
|
|
197 tokens[n_tokens] = NULL; |
|
|
198 lengths[n_tokens] = -1; |
|
|
199 break; |
|
|
200 } |
|
|
201 tmp = (char *) xmalloc ((token_length + 1) * sizeof (char)); |
|
|
202 lengths[n_tokens] = token_length; |
|
|
203 tokens[n_tokens] = strncpy (tmp, token->buffer, |
|
|
204 (unsigned) (token_length + 1)); |
|
|
205 n_tokens++; |
|
|
206 } |
|
|
207 |
|
|
208 free (token->buffer); |
|
|
209 *tokens_out = tokens; |
|
|
210 if (token_lengths != NULL) |
|
|
211 *token_lengths = lengths; |
|
|
212 return n_tokens; |
|
|
213 } |
