Commit | Line | Data |
---|---|---|
79072805 | 1 | /* $RCSfile: str.c,v $$Revision: 4.1 $$Date: 92/08/07 18:29:26 $ |
a687059c | 2 | * |
9607fc9c | 3 | * Copyright (c) 1991-1997, Larry Wall |
a687059c | 4 | * |
d48672a2 LW |
5 | * You may distribute under the terms of either the GNU General Public |
6 | * License or the Artistic License, as specified in the README file. | |
8d063cd8 LW |
7 | * |
8 | * $Log: str.c,v $ | |
8d063cd8 LW |
9 | */ |
10 | ||
8d063cd8 | 11 | #include "EXTERN.h" |
8d063cd8 | 12 | #include "a2p.h" |
9c8d0b29 | 13 | #include "util.h" |
8d063cd8 | 14 | |
9c8d0b29 | 15 | void |
8d063cd8 LW |
16 | str_numset(str,num) |
17 | register STR *str; | |
18 | double num; | |
19 | { | |
20 | str->str_nval = num; | |
21 | str->str_pok = 0; /* invalidate pointer */ | |
22 | str->str_nok = 1; /* validate number */ | |
23 | } | |
24 | ||
25 | char * | |
26 | str_2ptr(str) | |
27 | register STR *str; | |
28 | { | |
29 | register char *s; | |
30 | ||
31 | if (!str) | |
32 | return ""; | |
33 | GROWSTR(&(str->str_ptr), &(str->str_len), 24); | |
34 | s = str->str_ptr; | |
35 | if (str->str_nok) { | |
36 | sprintf(s,"%.20g",str->str_nval); | |
37 | while (*s) s++; | |
38 | } | |
39 | *s = '\0'; | |
40 | str->str_cur = s - str->str_ptr; | |
41 | str->str_pok = 1; | |
42 | #ifdef DEBUGGING | |
43 | if (debug & 32) | |
68dc0745 | 44 | fprintf(stderr,"0x%lx ptr(%s)\n",(unsigned long)str,str->str_ptr); |
8d063cd8 LW |
45 | #endif |
46 | return str->str_ptr; | |
47 | } | |
48 | ||
49 | double | |
50 | str_2num(str) | |
51 | register STR *str; | |
52 | { | |
53 | if (!str) | |
54 | return 0.0; | |
55 | if (str->str_len && str->str_pok) | |
56 | str->str_nval = atof(str->str_ptr); | |
57 | else | |
58 | str->str_nval = 0.0; | |
59 | str->str_nok = 1; | |
60 | #ifdef DEBUGGING | |
61 | if (debug & 32) | |
68dc0745 | 62 | fprintf(stderr,"0x%lx num(%g)\n",(unsigned long)str,str->str_nval); |
8d063cd8 LW |
63 | #endif |
64 | return str->str_nval; | |
65 | } | |
66 | ||
9c8d0b29 | 67 | void |
8d063cd8 LW |
68 | str_sset(dstr,sstr) |
69 | STR *dstr; | |
70 | register STR *sstr; | |
71 | { | |
72 | if (!sstr) | |
73 | str_nset(dstr,No,0); | |
74 | else if (sstr->str_nok) | |
75 | str_numset(dstr,sstr->str_nval); | |
76 | else if (sstr->str_pok) | |
77 | str_nset(dstr,sstr->str_ptr,sstr->str_cur); | |
78 | else | |
79 | str_nset(dstr,"",0); | |
80 | } | |
81 | ||
9c8d0b29 | 82 | void |
8d063cd8 LW |
83 | str_nset(str,ptr,len) |
84 | register STR *str; | |
85 | register char *ptr; | |
86 | register int len; | |
87 | { | |
88 | GROWSTR(&(str->str_ptr), &(str->str_len), len + 1); | |
89 | bcopy(ptr,str->str_ptr,len); | |
90 | str->str_cur = len; | |
91 | *(str->str_ptr+str->str_cur) = '\0'; | |
92 | str->str_nok = 0; /* invalidate number */ | |
93 | str->str_pok = 1; /* validate pointer */ | |
94 | } | |
95 | ||
9c8d0b29 | 96 | void |
8d063cd8 LW |
97 | str_set(str,ptr) |
98 | register STR *str; | |
99 | register char *ptr; | |
100 | { | |
101 | register int len; | |
102 | ||
103 | if (!ptr) | |
104 | ptr = ""; | |
105 | len = strlen(ptr); | |
106 | GROWSTR(&(str->str_ptr), &(str->str_len), len + 1); | |
107 | bcopy(ptr,str->str_ptr,len+1); | |
108 | str->str_cur = len; | |
109 | str->str_nok = 0; /* invalidate number */ | |
110 | str->str_pok = 1; /* validate pointer */ | |
111 | } | |
112 | ||
9c8d0b29 | 113 | void |
8d063cd8 LW |
114 | str_chop(str,ptr) /* like set but assuming ptr is in str */ |
115 | register STR *str; | |
116 | register char *ptr; | |
117 | { | |
118 | if (!(str->str_pok)) | |
119 | str_2ptr(str); | |
120 | str->str_cur -= (ptr - str->str_ptr); | |
121 | bcopy(ptr,str->str_ptr, str->str_cur + 1); | |
122 | str->str_nok = 0; /* invalidate number */ | |
123 | str->str_pok = 1; /* validate pointer */ | |
124 | } | |
125 | ||
9c8d0b29 | 126 | void |
8d063cd8 LW |
127 | str_ncat(str,ptr,len) |
128 | register STR *str; | |
129 | register char *ptr; | |
130 | register int len; | |
131 | { | |
132 | if (!(str->str_pok)) | |
133 | str_2ptr(str); | |
134 | GROWSTR(&(str->str_ptr), &(str->str_len), str->str_cur + len + 1); | |
135 | bcopy(ptr,str->str_ptr+str->str_cur,len); | |
136 | str->str_cur += len; | |
137 | *(str->str_ptr+str->str_cur) = '\0'; | |
138 | str->str_nok = 0; /* invalidate number */ | |
139 | str->str_pok = 1; /* validate pointer */ | |
140 | } | |
141 | ||
9c8d0b29 | 142 | void |
8d063cd8 LW |
143 | str_scat(dstr,sstr) |
144 | STR *dstr; | |
145 | register STR *sstr; | |
146 | { | |
147 | if (!(sstr->str_pok)) | |
148 | str_2ptr(sstr); | |
149 | if (sstr) | |
150 | str_ncat(dstr,sstr->str_ptr,sstr->str_cur); | |
151 | } | |
152 | ||
9c8d0b29 | 153 | void |
8d063cd8 LW |
154 | str_cat(str,ptr) |
155 | register STR *str; | |
156 | register char *ptr; | |
157 | { | |
158 | register int len; | |
159 | ||
160 | if (!ptr) | |
161 | return; | |
162 | if (!(str->str_pok)) | |
163 | str_2ptr(str); | |
164 | len = strlen(ptr); | |
165 | GROWSTR(&(str->str_ptr), &(str->str_len), str->str_cur + len + 1); | |
166 | bcopy(ptr,str->str_ptr+str->str_cur,len+1); | |
167 | str->str_cur += len; | |
168 | str->str_nok = 0; /* invalidate number */ | |
169 | str->str_pok = 1; /* validate pointer */ | |
170 | } | |
171 | ||
172 | char * | |
173 | str_append_till(str,from,delim,keeplist) | |
174 | register STR *str; | |
175 | register char *from; | |
176 | register int delim; | |
177 | char *keeplist; | |
178 | { | |
179 | register char *to; | |
180 | register int len; | |
181 | ||
182 | if (!from) | |
183 | return Nullch; | |
184 | len = strlen(from); | |
185 | GROWSTR(&(str->str_ptr), &(str->str_len), str->str_cur + len + 1); | |
186 | str->str_nok = 0; /* invalidate number */ | |
187 | str->str_pok = 1; /* validate pointer */ | |
188 | to = str->str_ptr+str->str_cur; | |
189 | for (; *from; from++,to++) { | |
190 | if (*from == '\\' && from[1] && delim != '\\') { | |
191 | if (!keeplist) { | |
192 | if (from[1] == delim || from[1] == '\\') | |
193 | from++; | |
194 | else | |
195 | *to++ = *from++; | |
196 | } | |
a0d0e21e | 197 | else if (strchr(keeplist,from[1])) |
8d063cd8 LW |
198 | *to++ = *from++; |
199 | else | |
200 | from++; | |
201 | } | |
202 | else if (*from == delim) | |
203 | break; | |
204 | *to = *from; | |
205 | } | |
206 | *to = '\0'; | |
207 | str->str_cur = to - str->str_ptr; | |
208 | return from; | |
209 | } | |
210 | ||
211 | STR * | |
212 | str_new(len) | |
213 | int len; | |
214 | { | |
215 | register STR *str; | |
216 | ||
217 | if (freestrroot) { | |
218 | str = freestrroot; | |
219 | freestrroot = str->str_link.str_next; | |
220 | } | |
221 | else { | |
222 | str = (STR *) safemalloc(sizeof(STR)); | |
223 | bzero((char*)str,sizeof(STR)); | |
224 | } | |
225 | if (len) | |
226 | GROWSTR(&(str->str_ptr), &(str->str_len), len + 1); | |
227 | return str; | |
228 | } | |
229 | ||
230 | void | |
231 | str_grow(str,len) | |
232 | register STR *str; | |
233 | int len; | |
234 | { | |
235 | if (len && str) | |
236 | GROWSTR(&(str->str_ptr), &(str->str_len), len + 1); | |
237 | } | |
238 | ||
239 | /* make str point to what nstr did */ | |
240 | ||
241 | void | |
242 | str_replace(str,nstr) | |
243 | register STR *str; | |
244 | register STR *nstr; | |
245 | { | |
9c8d0b29 | 246 | Safefree(str->str_ptr); |
8d063cd8 LW |
247 | str->str_ptr = nstr->str_ptr; |
248 | str->str_len = nstr->str_len; | |
249 | str->str_cur = nstr->str_cur; | |
250 | str->str_pok = nstr->str_pok; | |
251 | if (str->str_nok = nstr->str_nok) | |
252 | str->str_nval = nstr->str_nval; | |
253 | safefree((char*)nstr); | |
254 | } | |
255 | ||
256 | void | |
257 | str_free(str) | |
258 | register STR *str; | |
259 | { | |
260 | if (!str) | |
261 | return; | |
262 | if (str->str_len) | |
263 | str->str_ptr[0] = '\0'; | |
264 | str->str_cur = 0; | |
265 | str->str_nok = 0; | |
266 | str->str_pok = 0; | |
267 | str->str_link.str_next = freestrroot; | |
268 | freestrroot = str; | |
269 | } | |
270 | ||
9c8d0b29 | 271 | int |
8d063cd8 LW |
272 | str_len(str) |
273 | register STR *str; | |
274 | { | |
275 | if (!str) | |
276 | return 0; | |
277 | if (!(str->str_pok)) | |
278 | str_2ptr(str); | |
279 | if (str->str_len) | |
280 | return str->str_cur; | |
281 | else | |
282 | return 0; | |
283 | } | |
284 | ||
285 | char * | |
286 | str_gets(str,fp) | |
287 | register STR *str; | |
288 | register FILE *fp; | |
289 | { | |
c2960299 AD |
290 | #if defined(USE_STDIO_PTR) && defined(STDIO_PTR_LVALUE) && defined(STDIO_CNT_LVALUE) |
291 | /* Here is some breathtakingly efficient cheating */ | |
8d063cd8 LW |
292 | |
293 | register char *bp; /* we're going to steal some values */ | |
294 | register int cnt; /* from the stdio struct and put EVERYTHING */ | |
378cc40b | 295 | register STDCHAR *ptr; /* in the innermost loop into registers */ |
8d063cd8 LW |
296 | register char newline = '\n'; /* (assuming at least 6 registers) */ |
297 | int i; | |
298 | int bpx; | |
299 | ||
44a8e56a | 300 | #if defined(VMS) |
301 | /* An ungetc()d char is handled separately from the regular | |
302 | * buffer, so we getc() it back out and stuff it in the buffer. | |
303 | */ | |
304 | i = getc(fp); | |
305 | if (i == EOF) return Nullch; | |
306 | *(--((*fp)->_ptr)) = (unsigned char) i; | |
307 | (*fp)->_cnt++; | |
308 | #endif | |
309 | ||
16d20bd9 | 310 | cnt = FILE_cnt(fp); /* get count into register */ |
8d063cd8 LW |
311 | str->str_nok = 0; /* invalidate number */ |
312 | str->str_pok = 1; /* validate pointer */ | |
313 | if (str->str_len <= cnt) /* make sure we have the room */ | |
314 | GROWSTR(&(str->str_ptr), &(str->str_len), cnt+1); | |
315 | bp = str->str_ptr; /* move these two too to registers */ | |
16d20bd9 | 316 | ptr = FILE_ptr(fp); |
8d063cd8 | 317 | for (;;) { |
378cc40b LW |
318 | while (--cnt >= 0) { |
319 | if ((*bp++ = *ptr++) == newline) | |
320 | if (bp <= str->str_ptr || bp[-2] != '\\') | |
321 | goto thats_all_folks; | |
322 | else { | |
323 | line++; | |
324 | bp -= 2; | |
325 | } | |
8d063cd8 LW |
326 | } |
327 | ||
16d20bd9 AD |
328 | FILE_cnt(fp) = cnt; /* deregisterize cnt and ptr */ |
329 | FILE_ptr(fp) = ptr; | |
44a8e56a | 330 | i = getc(fp); /* get more characters */ |
16d20bd9 AD |
331 | cnt = FILE_cnt(fp); |
332 | ptr = FILE_ptr(fp); /* reregisterize cnt and ptr */ | |
8d063cd8 LW |
333 | |
334 | bpx = bp - str->str_ptr; /* prepare for possible relocation */ | |
335 | GROWSTR(&(str->str_ptr), &(str->str_len), str->str_cur + cnt + 1); | |
336 | bp = str->str_ptr + bpx; /* reconstitute our pointer */ | |
337 | ||
338 | if (i == newline) { /* all done for now? */ | |
339 | *bp++ = i; | |
340 | goto thats_all_folks; | |
341 | } | |
342 | else if (i == EOF) /* all done for ever? */ | |
343 | goto thats_all_folks; | |
344 | *bp++ = i; /* now go back to screaming loop */ | |
345 | } | |
346 | ||
347 | thats_all_folks: | |
16d20bd9 AD |
348 | FILE_cnt(fp) = cnt; /* put these back or we're in trouble */ |
349 | FILE_ptr(fp) = ptr; | |
8d063cd8 LW |
350 | *bp = '\0'; |
351 | str->str_cur = bp - str->str_ptr; /* set length */ | |
352 | ||
c2960299 AD |
353 | #else /* USE_STDIO_PTR && STDIO_PTR_LVALUE && STDIO_CNT_LVALUE */ |
354 | /* The big, slow, and stupid way */ | |
8d063cd8 LW |
355 | |
356 | static char buf[4192]; | |
357 | ||
358 | if (fgets(buf, sizeof buf, fp) != Nullch) | |
359 | str_set(str, buf); | |
360 | else | |
361 | str_set(str, No); | |
362 | ||
c2960299 | 363 | #endif /* USE_STDIO_PTR && STDIO_PTR_LVALUE && STDIO_CNT_LVALUE */ |
8d063cd8 LW |
364 | |
365 | return str->str_cur ? str->str_ptr : Nullch; | |
366 | } | |
367 | ||
368 | void | |
369 | str_inc(str) | |
370 | register STR *str; | |
371 | { | |
372 | register char *d; | |
373 | ||
374 | if (!str) | |
375 | return; | |
376 | if (str->str_nok) { | |
377 | str->str_nval += 1.0; | |
378 | str->str_pok = 0; | |
379 | return; | |
380 | } | |
381 | if (!str->str_pok) { | |
382 | str->str_nval = 1.0; | |
383 | str->str_nok = 1; | |
384 | return; | |
385 | } | |
386 | for (d = str->str_ptr; *d && *d != '.'; d++) ; | |
387 | d--; | |
388 | if (!isdigit(*str->str_ptr) || !isdigit(*d) ) { | |
389 | str_numset(str,atof(str->str_ptr) + 1.0); /* punt */ | |
390 | return; | |
391 | } | |
392 | while (d >= str->str_ptr) { | |
393 | if (++*d <= '9') | |
394 | return; | |
395 | *(d--) = '0'; | |
396 | } | |
397 | /* oh,oh, the number grew */ | |
398 | GROWSTR(&(str->str_ptr), &(str->str_len), str->str_cur + 2); | |
399 | str->str_cur++; | |
400 | for (d = str->str_ptr + str->str_cur; d > str->str_ptr; d--) | |
401 | *d = d[-1]; | |
402 | *d = '1'; | |
403 | } | |
404 | ||
405 | void | |
406 | str_dec(str) | |
407 | register STR *str; | |
408 | { | |
409 | register char *d; | |
410 | ||
411 | if (!str) | |
412 | return; | |
413 | if (str->str_nok) { | |
414 | str->str_nval -= 1.0; | |
415 | str->str_pok = 0; | |
416 | return; | |
417 | } | |
418 | if (!str->str_pok) { | |
419 | str->str_nval = -1.0; | |
420 | str->str_nok = 1; | |
421 | return; | |
422 | } | |
423 | for (d = str->str_ptr; *d && *d != '.'; d++) ; | |
424 | d--; | |
425 | if (!isdigit(*str->str_ptr) || !isdigit(*d) || (*d == '0' && d == str->str_ptr)) { | |
426 | str_numset(str,atof(str->str_ptr) - 1.0); /* punt */ | |
427 | return; | |
428 | } | |
429 | while (d >= str->str_ptr) { | |
430 | if (--*d >= '0') | |
431 | return; | |
432 | *(d--) = '9'; | |
433 | } | |
434 | } | |
435 | ||
436 | /* make a string that will exist for the duration of the expression eval */ | |
437 | ||
438 | STR * | |
fe14fcc3 | 439 | str_mortal(oldstr) |
8d063cd8 LW |
440 | STR *oldstr; |
441 | { | |
442 | register STR *str = str_new(0); | |
443 | static long tmps_size = -1; | |
444 | ||
445 | str_sset(str,oldstr); | |
446 | if (++tmps_max > tmps_size) { | |
447 | tmps_size = tmps_max; | |
448 | if (!(tmps_size & 127)) { | |
449 | if (tmps_size) | |
450 | tmps_list = (STR**)saferealloc((char*)tmps_list, | |
451 | (tmps_size + 128) * sizeof(STR*) ); | |
452 | else | |
453 | tmps_list = (STR**)safemalloc(128 * sizeof(char*)); | |
454 | } | |
455 | } | |
456 | tmps_list[tmps_max] = str; | |
457 | return str; | |
458 | } | |
459 | ||
460 | STR * | |
461 | str_make(s) | |
462 | char *s; | |
463 | { | |
464 | register STR *str = str_new(0); | |
465 | ||
466 | str_set(str,s); | |
467 | return str; | |
468 | } | |
469 | ||
470 | STR * | |
471 | str_nmake(n) | |
472 | double n; | |
473 | { | |
474 | register STR *str = str_new(0); | |
475 | ||
476 | str_numset(str,n); | |
477 | return str; | |
478 | } |