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 |
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 |
7 | * |
8 | * $Log: str.c,v $ |
8d063cd8 |
9 | */ |
10 | |
8d063cd8 |
11 | #include "EXTERN.h" |
8d063cd8 |
12 | #include "a2p.h" |
9c8d0b29 |
13 | #include "util.h" |
8d063cd8 |
14 | |
9c8d0b29 |
15 | void |
8d063cd8 |
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 |
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 |
63 | #endif |
64 | return str->str_nval; |
65 | } |
66 | |
9c8d0b29 |
67 | void |
8d063cd8 |
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 |
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 |
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 |
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 |
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 |
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 |
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 |
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 |
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 |
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 |
290 | #if defined(USE_STDIO_PTR) && defined(STDIO_PTR_LVALUE) && defined(STDIO_CNT_LVALUE) |
291 | /* Here is some breathtakingly efficient cheating */ |
8d063cd8 |
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 |
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 |
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 |
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 |
326 | } |
327 | |
16d20bd9 |
328 | FILE_cnt(fp) = cnt; /* deregisterize cnt and ptr */ |
329 | FILE_ptr(fp) = ptr; |
44a8e56a |
330 | i = getc(fp); /* get more characters */ |
16d20bd9 |
331 | cnt = FILE_cnt(fp); |
332 | ptr = FILE_ptr(fp); /* reregisterize cnt and ptr */ |
8d063cd8 |
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 |
348 | FILE_cnt(fp) = cnt; /* put these back or we're in trouble */ |
349 | FILE_ptr(fp) = ptr; |
8d063cd8 |
350 | *bp = '\0'; |
351 | str->str_cur = bp - str->str_ptr; /* set length */ |
352 | |
c2960299 |
353 | #else /* USE_STDIO_PTR && STDIO_PTR_LVALUE && STDIO_CNT_LVALUE */ |
354 | /* The big, slow, and stupid way */ |
8d063cd8 |
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 |
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 |
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 | } |