Rev 12258 | Rev 12884 | Go to most recent revision | Details | Compare with Previous | Last modification | View Log | RSS feed
Rev | Author | Line No. | Line |
---|---|---|---|
10 | reyssat | 1 | /* Copyright (C) 1998-2003 XIAO, Gang of Universite de Nice - Sophia Antipolis |
2 | * |
||
3 | * This program is free software; you can redistribute it and/or modify |
||
4 | * it under the terms of the GNU General Public License as published by |
||
5 | * the Free Software Foundation; either version 2 of the License, or |
||
6 | * (at your option) any later version. |
||
7 | * |
||
8 | * This program is distributed in the hope that it will be useful, |
||
9 | * but WITHOUT ANY WARRANTY; without even the implied warranty of |
||
10 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
||
11 | * GNU General Public License for more details. |
||
12 | * |
||
13 | * You should have received a copy of the GNU General Public License |
||
14 | * along with this program; if not, write to the Free Software |
||
15 | * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. |
||
16 | */ |
||
7840 | bpr | 17 | /* line input / output routines */ |
10 | reyssat | 18 | |
19 | #include <stdarg.h> |
||
8160 | bpr | 20 | #include "libwims.h" |
3717 | reyssat | 21 | |
8100 | bpr | 22 | /* copy of possibly overlapping strings, to replace strcpy which is not guaranteed in this case |
23 | and indeed produces errors particularly on 64 bits computers */ |
||
3717 | reyssat | 24 | |
8100 | bpr | 25 | void ovlstrcpy(char *dest, char *src) |
26 | { |
||
27 | memmove(dest, src, strlen(src)+1); |
||
28 | } |
||
29 | |||
10 | reyssat | 30 | #define int_buf_size 40 |
31 | |||
7840 | bpr | 32 | /* this is rapid. Output string will be erased at the next call. */ |
10 | reyssat | 33 | char *int2str(int i) |
34 | { |
||
35 | int neg,t; |
||
36 | static char int_buf[int_buf_size]; |
||
37 | int_buf[int_buf_size-1]=0; |
||
38 | neg=0; if(i<0) {neg=1;i=-i;} |
||
39 | for(t=int_buf_size-2;t>=0;) { |
||
7840 | bpr | 40 | int_buf[t--]=i%10+'0'; i/=10; |
41 | if(i==0) break; |
||
10 | reyssat | 42 | } |
43 | if(t<=0) {int_buf[0]=0; return int_buf;} /* should never occur. */ |
||
44 | if(neg) int_buf[t--]='-'; |
||
45 | t++; return int_buf+t; |
||
46 | } |
||
47 | |||
48 | void *xmalloc(size_t n) |
||
49 | { |
||
50 | void *p; |
||
51 | p=malloc(n); |
||
52 | if(p==NULL) { |
||
7840 | bpr | 53 | fprintf(stderr,"Malloc failure."); exit(1); |
10 | reyssat | 54 | } |
55 | return p; |
||
56 | } |
||
57 | |||
58 | int msleep(int ms) |
||
59 | { |
||
60 | struct timespec req, rem; |
||
61 | if(ms<=0) return 0; |
||
62 | req.tv_sec=ms/1000; req.tv_nsec=(ms%1000)*1000*1000; |
||
63 | return nanosleep(&req,&rem); |
||
64 | } |
||
65 | |||
66 | /* dos/mac to unix/linux translation */ |
||
67 | void _tolinux(char *p) |
||
68 | { |
||
69 | char *pp,*p1; |
||
70 | pp=strchr(p,13); if(pp==NULL) return; |
||
71 | for(p1=pp; *pp; pp++) { |
||
7840 | bpr | 72 | if(*pp==13) { |
73 | if(*(pp+1)=='\n' || (pp>p && *(pp-1)=='\n') || |
||
74 | (*(pp+1)=='\\' && *(pp+2)=='\n')) continue; |
||
75 | else *pp='\n'; |
||
76 | } |
||
77 | *p1++=*pp; |
||
10 | reyssat | 78 | } |
79 | *p1=0; |
||
80 | } |
||
81 | |||
3717 | reyssat | 82 | |
7840 | bpr | 83 | /* optimized and secure strcpy */ |
5456 | bpr | 84 | |
85 | /* copies src to dest, at most lim bytes. Error if more than |
||
86 | MAX_LINELEN chars would be copied, including final \0. */ |
||
87 | |||
88 | void mystrncpy(char *dest, const char *src, size_t lim) |
||
10 | reyssat | 89 | { |
12260 | bpr | 90 | if (lim){ |
91 | size_t i = strlen(src); |
||
92 | if (i >= lim) i = lim-1; |
||
93 | if (i >= MAX_LINELEN) error("cmd_output_too_long"); |
||
94 | memmove(dest,src,i); dest[i]=0; |
||
95 | } |
||
10 | reyssat | 96 | } |
97 | |||
7840 | bpr | 98 | /* find matching parenthesis. |
99 | * The entrance point should be after the opening |
||
100 | * parenthesis. |
||
101 | * Returns NULL if unmatched. |
||
102 | */ |
||
10 | reyssat | 103 | char *find_matching(char *p, char c) |
104 | { |
||
12260 | bpr | 105 | char *pp; |
106 | int parenth, brak, brace; |
||
107 | if(c=='|') { |
||
108 | for(pp=p;*pp!=0;pp++) { |
||
109 | switch(*pp) { |
||
110 | case '|': return pp; |
||
111 | case '(': { |
||
112 | pp=find_matching(pp+1,')'); |
||
113 | if(pp==NULL) return NULL; |
||
114 | break; |
||
115 | } |
||
116 | case '[': { |
||
117 | pp=find_matching(pp+1,']'); |
||
118 | if(pp==NULL) return NULL; |
||
119 | break; |
||
120 | } |
||
121 | case '{': { |
||
122 | pp=find_matching(pp+1,'}'); |
||
123 | if(pp==NULL) return NULL; |
||
124 | break; |
||
125 | } |
||
126 | case ')': |
||
127 | case ']': |
||
128 | case '}': return NULL; |
||
7840 | bpr | 129 | |
12260 | bpr | 130 | default: break; |
7840 | bpr | 131 | } |
10 | reyssat | 132 | } |
12260 | bpr | 133 | return NULL; |
134 | } |
||
135 | parenth=brak=brace=0; |
||
136 | for(pp=p; *pp!=0; pp++) { |
||
137 | switch(*pp) { |
||
138 | case '[': brak++; break; |
||
139 | case ']': brak--; break; |
||
140 | case '(': parenth++; break; |
||
141 | case ')': parenth--; break; |
||
142 | case '{': brace++; break; |
||
143 | case '}': brace--; break; |
||
144 | default: continue; |
||
10 | reyssat | 145 | } |
12260 | bpr | 146 | if(parenth<0 || brak<0 || brace<0) { |
147 | if(*pp!=c || parenth>0 || brak>0 || brace>0) return NULL; |
||
148 | else break; |
||
149 | } |
||
150 | } |
||
151 | if(*pp!=c) return NULL; |
||
152 | return pp; |
||
10 | reyssat | 153 | } |
154 | |||
7840 | bpr | 155 | /* Points to the end of the word */ |
10 | reyssat | 156 | char *find_word_end(char *p) |
157 | { |
||
12260 | bpr | 158 | while(!myisspace(*p) && *p!=0) p++; |
159 | return p; |
||
10 | reyssat | 160 | } |
161 | |||
7840 | bpr | 162 | /* Strips leading spaces */ |
10 | reyssat | 163 | char *find_word_start(char *p) |
164 | { |
||
12260 | bpr | 165 | while(myisspace(*p)) p++; |
166 | return p; |
||
10 | reyssat | 167 | } |
168 | |||
7840 | bpr | 169 | /* find a character in a string, but skipping parentheses. */ |
10 | reyssat | 170 | char *strparchr(char *p, char c) |
171 | { |
||
12260 | bpr | 172 | char *pp; |
7079 | bpr | 173 | |
12260 | bpr | 174 | for(pp=p;*pp && *pp!=c && pp-p<MAX_LINELEN; pp++) { |
175 | switch(*pp) { |
||
176 | case '(': pp=find_matching(pp+1,')'); break; |
||
177 | case '[': pp=find_matching(pp+1,']'); break; |
||
178 | case '{': pp=find_matching(pp+1,'}'); break; |
||
10 | reyssat | 179 | } |
12260 | bpr | 180 | if(pp==NULL) return NULL; |
181 | } |
||
182 | if(*pp==c) return pp; else return NULL; |
||
10 | reyssat | 183 | } |
184 | |||
7840 | bpr | 185 | /* search for string, skipping parentheses */ |
10 | reyssat | 186 | char *strparstr(char *p, char *fnd) |
187 | { |
||
12260 | bpr | 188 | char *pp, c=*fnd; |
189 | size_t n = strlen(fnd); |
||
190 | /*if(*fnd==0) return p+strlen(p);*/ |
||
191 | for(pp=p; *pp; pp++) { |
||
192 | if(*pp==c && (n==1 || strncmp(pp,fnd,n)==0)) return pp; |
||
193 | switch(*pp) { |
||
194 | case '(': pp=find_matching(pp+1,')'); break; |
||
195 | case '[': pp=find_matching(pp+1,']'); break; |
||
196 | case '{': pp=find_matching(pp+1,'}'); break; |
||
10 | reyssat | 197 | } |
12260 | bpr | 198 | if (!pp) { pp = strstr(p,fnd); if (!pp) pp = p+strlen(p); break; } |
199 | } |
||
200 | return pp; |
||
10 | reyssat | 201 | } |
7079 | bpr | 202 | |
7840 | bpr | 203 | /* Points to the end of an item */ |
10 | reyssat | 204 | char *find_item_end(char *p) |
205 | { |
||
12260 | bpr | 206 | return strparstr(p,","); |
10 | reyssat | 207 | } |
208 | |||
7840 | bpr | 209 | /* Points to the end of an item */ |
10 | reyssat | 210 | char *find_line_end(char *p) |
211 | { |
||
12260 | bpr | 212 | char *pp=strstr(p,"\n"); |
213 | if(pp==NULL) pp=p+strlen(p); |
||
214 | return pp; |
||
10 | reyssat | 215 | } |
216 | |||
217 | char *charchr(char *p,char *w) |
||
218 | { |
||
12260 | bpr | 219 | return strchr(p,w[0]); |
10 | reyssat | 220 | } |
221 | |||
7840 | bpr | 222 | /* Find first occurrence of word */ |
10 | reyssat | 223 | char *wordchr(char *p, char *w) |
224 | { |
||
12260 | bpr | 225 | char *r; int n; |
10 | reyssat | 226 | |
12260 | bpr | 227 | if(*w==0) return NULL; |
228 | n=strlen(w); |
||
229 | for(r=strstr(p,w);r!=NULL && |
||
7840 | bpr | 230 | ( (r>p && !myisspace(*(r-1))) || (!myisspace(*(r+n)) && *(r+n)!=0) ); |
12260 | bpr | 231 | r=strstr(r+1,w)){}; |
232 | return r; |
||
10 | reyssat | 233 | } |
234 | |||
7840 | bpr | 235 | /* Find first occurrence of item */ |
10 | reyssat | 236 | char *itemchr(char *p, char *w) |
237 | { |
||
12260 | bpr | 238 | char *r, *r1, *r2; int n; |
10 | reyssat | 239 | |
12260 | bpr | 240 | if(*w==0) return NULL; |
241 | n=strlen(w); |
||
242 | for(r=strstr(p,w);r!=NULL; r=strstr(r+1,w)) { |
||
243 | r1=r-1;while(r1>=p && myisspace(*r1)) r1--; |
||
244 | r2=find_word_start(r+n); |
||
245 | if((r1<p || *r1==',') && (*r2==0 || *r2==',')) return r; |
||
246 | } |
||
247 | return r; |
||
10 | reyssat | 248 | } |
249 | |||
7840 | bpr | 250 | /* Find first occurrence of line */ |
10 | reyssat | 251 | char *linechr(char *p, char *w) |
252 | { |
||
12260 | bpr | 253 | char *r; |
254 | int n; |
||
10 | reyssat | 255 | |
12260 | bpr | 256 | if(*w==0) return NULL; |
257 | n=strlen(w); |
||
258 | for(r=strstr(p,w);r!=NULL; r=strstr(r+1,w)) { |
||
259 | if((r<=p || *(r-1)=='\n') && (*(r+n)==0 || *(r+n)=='\n')) |
||
260 | break; |
||
261 | } |
||
262 | return r; |
||
10 | reyssat | 263 | } |
264 | |||
7840 | bpr | 265 | /* find a variable in a string (math expression). |
266 | * Returns the pointer or NULL. */ |
||
10 | reyssat | 267 | char *varchr(char *p, char *v) |
268 | { |
||
12260 | bpr | 269 | char *pp; int n; |
270 | if(*v==0) return NULL; |
||
271 | n=strlen(v); |
||
272 | for(pp=strstr(p,v); pp!=NULL; pp=strstr(pp+1,v)) { |
||
273 | if((pp==p || (!myisalnum(*(pp-1)) && *(pp-1)!='_')) && |
||
274 | ((!myisalnum(*(pp+n)) && *(pp+n)!='_' && *(pp+n)!='\'') |
||
275 | || *(pp+n)==0)) break; |
||
276 | } |
||
277 | return pp; |
||
10 | reyssat | 278 | } |
279 | |||
280 | int _cutit_(char *p, char *list[], int max, char *end_finder(char *pt), int tag) |
||
281 | { |
||
12260 | bpr | 282 | int i; |
283 | char *pp, *pe, *p0; |
||
284 | if(tag&1) pp=find_word_start(p); else pp=p; /* strip head space */ |
||
285 | for(i=0;i<max && *pp;i++) { |
||
286 | pe=end_finder(pp); |
||
287 | if((tag&2) && myisspace(pe[-1])) { /* strip trailing space */ |
||
288 | for(p0=pe; p0>pp && myisspace(p0[-1]); p0--); |
||
289 | if(p0<pe) *p0=0; |
||
10 | reyssat | 290 | } |
12260 | bpr | 291 | if(*pe) *pe++=0; |
292 | list[i]=pp; |
||
293 | if(tag&1) pp=find_word_start(pe); else pp=pe; |
||
294 | } |
||
295 | return i; |
||
10 | reyssat | 296 | } |
297 | |||
298 | int cutitems(char *p, char *list[], int max) |
||
299 | { |
||
12260 | bpr | 300 | return _cutit_(p,list,max,find_item_end,3); |
10 | reyssat | 301 | } |
302 | |||
303 | int cutwords(char *p, char *list[], int max) |
||
304 | { |
||
12260 | bpr | 305 | return _cutit_(find_word_start(p),list,max,find_word_end,1); |
10 | reyssat | 306 | } |
307 | |||
308 | int cutlines(char *p, char *list[], int max) |
||
309 | { |
||
12260 | bpr | 310 | return _cutit_(p,list,max,find_line_end,0); |
10 | reyssat | 311 | } |
312 | |||
313 | int cutchars(char *p, char *list[], int max) |
||
314 | { |
||
12260 | bpr | 315 | int i; char *pp; |
316 | for(i=0,pp=p;*pp && i<max;list[i++]=pp++); |
||
317 | return i; |
||
10 | reyssat | 318 | } |
319 | |||
7840 | bpr | 320 | /* strip trailing spaces; return string end. */ |
10 | reyssat | 321 | char *strip_trailing_spaces(char *p) |
322 | { |
||
12260 | bpr | 323 | char *pp; |
324 | if(*p==0) return p; |
||
325 | for(pp=p+strlen(p)-1; pp>=p && myisspace(*pp); pp--); |
||
326 | if(pp[1]) pp[1]=0; |
||
327 | return pp; |
||
10 | reyssat | 328 | } |
329 | |||
8863 | bpr | 330 | /* strip trailing spaces; return string end. */ |
331 | char *strip_trailing_spaces2(char *p) |
||
332 | { |
||
12260 | bpr | 333 | char *pp; |
334 | if(*p==0) return p; |
||
335 | for(pp=p+strlen(p)-1; pp>=p && isspace(*pp); *(pp--)=0); |
||
336 | return pp; |
||
8863 | bpr | 337 | } |
10 | reyssat | 338 | |
8863 | bpr | 339 | /* Routines for quick search of item in a list. */ |
340 | |||
7840 | bpr | 341 | /* Verify whether a list is well-ordered. For debugging uses. |
342 | * Returns 0 if order is OK, -1 otherwise. */ |
||
10 | reyssat | 343 | int verify_order(void *list, int items, size_t item_size) |
344 | { |
||
12260 | bpr | 345 | int i; char *old, **p; |
346 | p=list; old=*p; |
||
347 | for(i=item_size;i<items*item_size;i+=item_size) { |
||
348 | p=list+i; |
||
349 | if(strcmp(*p,old)<0) { |
||
350 | fprintf(stderr,"Table disorder: %s > %s",old,*p); |
||
351 | exit(1); |
||
10 | reyssat | 352 | } |
12260 | bpr | 353 | old=*p; |
354 | } |
||
355 | return 0; |
||
10 | reyssat | 356 | } |
357 | |||
8082 | bpr | 358 | /* searches a list. Returns index if found, (-1-index of insertion) if nomatch. |
7840 | bpr | 359 | * Uses binary search, list must be sorted. */ |
8082 | bpr | 360 | |
10 | reyssat | 361 | int search_list(void *list, int items, size_t item_size, const char *str) |
362 | { |
||
12260 | bpr | 363 | int i = 0; |
364 | while (items > 0){ |
||
365 | int m = items / 2, j = i + m; |
||
366 | int k = strcmp(*(char **)(list + j * item_size), str); |
||
367 | if (k == 0) return j; |
||
368 | if (k > 0) items = m; else {i = j + 1; items -= (m + 1);} |
||
369 | } |
||
370 | return ~i; |
||
10 | reyssat | 371 | } |
372 | |||
7840 | bpr | 373 | /* Returns number of lines in string p */ |
10 | reyssat | 374 | unsigned int linenum(char *p) |
375 | { |
||
12260 | bpr | 376 | int i; char *pp; |
10 | reyssat | 377 | |
12260 | bpr | 378 | /* Ending blank line will be thus removed. */ |
379 | i=strlen(p); if(i>1 && *(p+i-1)=='\n') *(p+i-1)=0; |
||
380 | if(*p=='\n') i=1; else i=0; |
||
381 | for(pp=p; pp!=NULL && *pp!=0; pp=strchr(pp+1,'\n'), i++); |
||
382 | return i; |
||
10 | reyssat | 383 | } |
384 | |||
7840 | bpr | 385 | /* Returns number of items in the list p, comma separated */ |
10 | reyssat | 386 | unsigned int itemnum(char *p) |
387 | { |
||
12260 | bpr | 388 | int i; char *pp; |
10 | reyssat | 389 | |
12260 | bpr | 390 | if(*p==0) return 0; |
391 | for(i=0,pp=p; pp==p || *(pp-1)!=0; pp=find_item_end(pp)+1, i++); |
||
392 | return i; |
||
10 | reyssat | 393 | } |
394 | |||
7840 | bpr | 395 | /* Returns number of words in string p */ |
10 | reyssat | 396 | unsigned int wordnum(char *p) |
397 | { |
||
12260 | bpr | 398 | int i; char *pp; |
7079 | bpr | 399 | |
12260 | bpr | 400 | for(i=0, pp=find_word_start(p); *pp!=0; i++) { |
401 | while(!myisspace(*pp) && *pp!=0) pp++; |
||
402 | while(myisspace(*pp)) pp++; |
||
403 | } |
||
404 | return i; |
||
10 | reyssat | 405 | } |
406 | |||
7840 | bpr | 407 | /* This is just to suppress an annoying compiler warning message. */ |
10 | reyssat | 408 | unsigned int charnum(char *p) |
409 | { |
||
12260 | bpr | 410 | return strlen(p); |
10 | reyssat | 411 | } |
412 | |||
7840 | bpr | 413 | /* find n-th line in string p */ |
10 | reyssat | 414 | char *fnd_line(char *p, int n, char bf[]) |
415 | { |
||
12260 | bpr | 416 | char *pp; |
417 | int i; |
||
7079 | bpr | 418 | |
10805 | bpr | 419 | /* |
420 | for(i=1,pp=p; pp-1!=NULL && *pp!=0 && i<n; pp=strchr(pp,'\n')+1, i++); |
||
421 | */ |
||
12260 | bpr | 422 | for(i=1,pp=p; i<n; i++) { |
423 | pp=strchr(pp,'\n'); |
||
424 | if (!pp++) { |
||
425 | fnd_position=NULL; fnd_nextpos=""; *bf=0; return bf; |
||
10 | reyssat | 426 | } |
12260 | bpr | 427 | } |
428 | fnd_position=pp; |
||
429 | for(i=0; *(pp+i)!=0 && *(pp+i)!='\n'; i++) *(bf+i)=*(pp+i); |
||
430 | *(bf+i)=0; |
||
431 | if(pp[i]=='\n') i++; |
||
432 | fnd_nextpos=pp+i; |
||
433 | return bf; |
||
10 | reyssat | 434 | } |
435 | |||
7840 | bpr | 436 | /* find n-th item in list p, comma separated */ |
10 | reyssat | 437 | char *fnd_item(char *p, int n, char bf[]) |
438 | { |
||
12260 | bpr | 439 | char *pp, *pe; |
440 | int i; |
||
10 | reyssat | 441 | |
12260 | bpr | 442 | for(i=1,pp=p; i<n && (pp==p || *(pp-1)!=0); pp=find_item_end(pp)+1, i++); |
443 | fnd_position=pp; if(pp>p && *(pp-1)==0) { |
||
444 | fnd_position=NULL; *bf=0; return bf; |
||
445 | } |
||
446 | pp=find_word_start(pp); pe=find_item_end(pp); |
||
447 | if(*pe) fnd_nextpos=pe+1; else fnd_nextpos=pe; |
||
448 | while(pe>pp && myisspace(*(pe-1))) pe--; |
||
449 | memmove(bf,pp,pe-pp); bf[pe-pp]=0; |
||
450 | return bf; |
||
10 | reyssat | 451 | } |
452 | |||
7840 | bpr | 453 | /* find n-th word in string p */ |
10 | reyssat | 454 | char *fnd_word(char *p, int n, char bf[]) |
455 | { |
||
12260 | bpr | 456 | char *pp; |
457 | int i; |
||
7079 | bpr | 458 | |
12260 | bpr | 459 | for(i=1, pp=find_word_start(p); *pp!=0 && i<n ; i++) { |
460 | while(!myisspace(*pp) && *pp!=0) pp++; |
||
461 | pp=find_word_start(pp); |
||
462 | } |
||
463 | if(*pp) fnd_position=pp; else fnd_position=NULL; |
||
464 | for(i=0; *(pp+i)!=0 && !myisspace(*(pp+i)); i++) *(bf+i)=*(pp+i); |
||
465 | fnd_nextpos=find_word_start(pp+i); |
||
466 | *(bf+i)=0; |
||
467 | return bf; |
||
10 | reyssat | 468 | } |
469 | |||
7840 | bpr | 470 | /* find n-th char in string p */ |
10 | reyssat | 471 | char *fnd_char(char *p, int n, char bf[]) |
472 | { |
||
12260 | bpr | 473 | int t; |
7079 | bpr | 474 | |
12260 | bpr | 475 | t=strlen(p); |
476 | if(n>t || n<1) {*bf=0;fnd_position=NULL; fnd_nextpos="";} |
||
477 | else { |
||
478 | *bf=*(p+n-1); *(bf+1)=0; |
||
479 | fnd_position=p+n-1;fnd_nextpos=p+n; |
||
480 | } |
||
481 | return bf; |
||
10 | reyssat | 482 | } |
483 | |||
7840 | bpr | 484 | /* Returns 1 if semicolons changed to new lines */ |
10 | reyssat | 485 | int rows2lines(char *p) |
486 | { |
||
12260 | bpr | 487 | char *pp, *p2; |
488 | int t; |
||
489 | if(strchr(p,'\n')!=NULL) return 0; |
||
490 | for(t=0, pp=p; *pp; pp++) { |
||
491 | if(*pp=='(') {p2=find_matching(pp+1,')'); if(p2!=NULL) pp=p2; continue;} |
||
492 | if(*pp=='[') {p2=find_matching(pp+1,']'); if(p2!=NULL) pp=p2; continue;} |
||
493 | if(*pp=='{') {p2=find_matching(pp+1,'}'); if(p2!=NULL) pp=p2; continue;} |
||
494 | if(*pp==';') {*pp='\n'; t++; continue;} |
||
495 | if(*pp=='&' && myisalpha(*(pp+1))) { |
||
496 | for(p2=pp+1; myisalpha(*p2) && p2-pp<14; p2++); |
||
497 | pp=p2; continue; |
||
10 | reyssat | 498 | } |
12260 | bpr | 499 | if(*pp=='&' && *(pp+1)=='#') { |
500 | for(p2=pp+2; myisdigit(*p2) && p2-pp<6; p2++); |
||
501 | pp=p2; continue; |
||
502 | } |
||
503 | } |
||
504 | return t; |
||
10 | reyssat | 505 | } |
506 | |||
507 | void lines2rows(char *p) |
||
508 | { |
||
12260 | bpr | 509 | char *pp; |
510 | strip_trailing_spaces(p); |
||
511 | for(pp=strchr(find_word_start(p),'\n'); pp!=NULL; pp=strchr(pp+1,'\n')) |
||
512 | *pp=';'; |
||
10 | reyssat | 513 | } |
514 | |||
515 | unsigned int rownum(char *p) |
||
516 | { |
||
12260 | bpr | 517 | char buf[MAX_LINELEN+1]; |
518 | snprintf(buf,sizeof(buf),"%s",p); |
||
519 | rows2lines(buf); |
||
520 | return linenum(buf); |
||
10 | reyssat | 521 | } |
522 | |||
7840 | bpr | 523 | /* find n-th row in a matrix p */ |
10 | reyssat | 524 | char *fnd_row(char *p, int n, char bf[]) |
525 | { |
||
12260 | bpr | 526 | rows2lines(p); return fnd_line(p,n,bf); |
10 | reyssat | 527 | } |
528 | |||
7840 | bpr | 529 | /* strstr but may have embedded zeros. |
530 | * Returns memory end if not found. |
||
531 | * Supposes memory ends with 0. |
||
532 | */ |
||
10 | reyssat | 533 | char *memstr(char *s1, char *s2, int len) |
534 | { |
||
12260 | bpr | 535 | char *p, *pp; |
536 | pp=s1; |
||
537 | for(p=s1; p<s1+len; p=pp) { |
||
538 | pp=strstr(p,s2); if(pp!=NULL) break; |
||
539 | pp=p+strlen(p); |
||
540 | while(pp<s1+len && *pp==0) pp++; |
||
541 | } |
||
542 | return pp; |
||
10 | reyssat | 543 | } |
544 | |||
7840 | bpr | 545 | /* Check whether parentheses are balanced in a given string. |
546 | * Returns 0 if OK. |
||
547 | */ |
||
548 | /* style=0: simple check. style<>0: strong check. */ |
||
10 | reyssat | 549 | int check_parentheses(char *p, int style) |
550 | { |
||
12260 | bpr | 551 | int i,j,k; |
552 | j=strlen(p); |
||
553 | if(j>=MAX_LINELEN) return 65535; |
||
554 | if(style!=0) { |
||
555 | char buf[MAX_LINELEN+1]; |
||
556 | char *pp, *pe, c; |
||
557 | for(pp=p;pp<p+j;pp++) { |
||
558 | switch (*pp) { |
||
559 | case ')': |
||
560 | case ']': |
||
561 | case '}': return -1; |
||
562 | case '(': c=')'; goto find; |
||
563 | case '[': c=']'; goto find; |
||
564 | case '{': c='}'; |
||
565 | find: { |
||
566 | pe=find_matching(pp+1,c); |
||
567 | if(pe==NULL) return 1; |
||
568 | memcpy(buf,pp+1,pe-pp-1); |
||
569 | buf[pe-pp-1]=0; |
||
570 | if((k=check_parentheses(buf,1))!=0) return k; |
||
571 | else pp=pe; |
||
572 | } |
||
573 | default: break; |
||
7840 | bpr | 574 | } |
10 | reyssat | 575 | } |
12260 | bpr | 576 | return 0; |
577 | } |
||
578 | for(i=k=0;i<j && k>=0;i++) { |
||
579 | if(*(p+i)=='(') k++; |
||
580 | if(*(p+i)==')') k--; |
||
581 | } |
||
582 | return k; |
||
10 | reyssat | 583 | } |
584 | |||
7840 | bpr | 585 | /* Strip enclosing pairs of parentheses */ |
10 | reyssat | 586 | void strip_enclosing_par(char *p) |
587 | { |
||
12260 | bpr | 588 | char *p1; |
589 | partest: strip_trailing_spaces(p); |
||
590 | if(*p=='(') { |
||
591 | p1=find_matching(p+1,')'); |
||
592 | if(p1 && *(p1+1)==0) { |
||
593 | *p1=0; ovlstrcpy(p,find_word_start(p+1)); |
||
594 | goto partest; |
||
10 | reyssat | 595 | } |
12260 | bpr | 596 | } |
597 | if(*p=='[') { |
||
598 | p1=find_matching(p+1,']'); |
||
599 | if(p1 && *(p1+1)==0) { |
||
600 | *p1=0; ovlstrcpy(p,find_word_start(p+1)); |
||
601 | goto partest; |
||
10 | reyssat | 602 | } |
12260 | bpr | 603 | } |
604 | if(*p=='{') { |
||
605 | p1=find_matching(p+1,'}'); |
||
606 | if(p1 && *(p1+1)==0) { |
||
607 | *p1=0; ovlstrcpy(p,find_word_start(p+1)); |
||
608 | goto partest; |
||
10 | reyssat | 609 | } |
12260 | bpr | 610 | } |
10 | reyssat | 611 | } |
612 | |||
7076 | obado | 613 | /* change all spaces into ' ', and collapse multiple occurences */ |
10 | reyssat | 614 | void singlespace(char *p) |
615 | { |
||
12260 | bpr | 616 | char *pp, *pt, *p2; |
617 | for(pp=pt=p;*pp;pp++) { |
||
618 | if(!myisspace(*pp)) {*pt++=*pp; continue; } |
||
619 | *pt++=' '; |
||
620 | for(p2=pp+1;myisspace(*p2);p2++){}; |
||
621 | pp=--p2; |
||
622 | } |
||
623 | *pt=0; |
||
10 | reyssat | 624 | } |
625 | |||
7076 | obado | 626 | /* collapses all space characters in string. */ |
10 | reyssat | 627 | void nospace(char *p) |
628 | { |
||
12260 | bpr | 629 | char *pp, *pt; |
630 | for(pp=pt=p;*pp;pp++) if(!myismspace(*pp)) *pt++=*pp; |
||
631 | *pt=0; |
||
10 | reyssat | 632 | } |
633 | |||
634 | void _spaces2_(char *p, char c) |
||
635 | { |
||
12260 | bpr | 636 | char *pp; int n; |
637 | singlespace(p); |
||
638 | n=strlen(p); if(*p==' ') {memmove(p,p+1,n);n--;} |
||
639 | if(n==0) return; |
||
640 | if(p[n-1]==' ') p[n-1]=0; |
||
641 | for(pp=strchr(p,' '); pp; pp=strchr(pp,' ')) *pp++=c; |
||
10 | reyssat | 642 | } |
7840 | bpr | 643 | /* change words to items */ |
10 | reyssat | 644 | void words2items(char *p) |
12260 | bpr | 645 | { |
646 | _spaces2_(p,','); |
||
647 | } |
||
10 | reyssat | 648 | |
7840 | bpr | 649 | /* change words to lines */ |
10 | reyssat | 650 | void words2lines(char *p) |
12260 | bpr | 651 | { |
652 | _spaces2_(p,'\n'); |
||
653 | } |
||
10 | reyssat | 654 | |
7840 | bpr | 655 | /* change lines to items */ |
10 | reyssat | 656 | void lines2items(char *p) |
657 | { |
||
12260 | bpr | 658 | char *pp; |
659 | for(pp=strchr(p,'\n'); pp; pp=strchr(pp,'\n')) *pp++=','; |
||
10 | reyssat | 660 | } |
661 | |||
7840 | bpr | 662 | /* change lines to words */ |
10 | reyssat | 663 | void lines2words(char *p) |
664 | { |
||
12260 | bpr | 665 | char *pp; |
666 | for(pp=strchr(p,'\n'); pp; pp=strchr(pp,'\n')) *pp++=' '; |
||
10 | reyssat | 667 | } |
668 | |||
7840 | bpr | 669 | /* change items to words */ |
10 | reyssat | 670 | void items2words(char *p) |
671 | { |
||
12260 | bpr | 672 | char *pp; |
673 | for(pp=strparstr(p,",");*pp;pp=strparstr(pp+1,",")) *pp=' '; |
||
10 | reyssat | 674 | } |
675 | |||
7840 | bpr | 676 | /* change items to lines */ |
10 | reyssat | 677 | void items2lines(char *p) |
678 | { |
||
12260 | bpr | 679 | char *pp; |
680 | for(pp=strparstr(p,",");*pp;pp=strparstr(pp+1,",")) *pp='\n'; |
||
10 | reyssat | 681 | } |
12258 | bpr | 682 | #pragma GCC diagnostic push |
683 | #pragma GCC diagnostic ignored "-Winvalid-source-encoding" |
||
10 | reyssat | 684 | char *acctab="çéèêëúùûüáàâäãóòôöõíìïîñýÿÇÉÈÊËÚÙÛÜÁÀÂÃÄÓÒÔÖÕÍÌÏÎÑÝ", |
685 | *deatab="ceeeeuuuuaaaaaoooooiiiinyyCEEEEUUUUAAAAAOOOOOIIIINY"; |
||
686 | |||
7840 | bpr | 687 | /* fold accented letters to unaccented */ |
10 | reyssat | 688 | void deaccent(char *p) |
689 | { |
||
12260 | bpr | 690 | char *sp; |
691 | char *v; |
||
692 | for(sp=p;*sp;sp++) { |
||
693 | if(*sp<0 && (v=strchr(acctab,*sp))!=NULL) |
||
694 | *sp=*(deatab+(v-acctab)); |
||
695 | } |
||
10 | reyssat | 696 | } |
697 | |||
698 | char *reaccents="'`\"^~"; |
||
699 | char *reaccentl="aeiouycnAEIOUYCN"; |
||
700 | char *reaccentab="\ |
||
701 | áàäâãéèëêeíìïîióòöôõúùüûuýyÿyyccccçnnnnñ\ |
||
702 | ÁÀÄÂÃÉÈËÊEÍÌÏÎIÓÒÖÔÕÚÙÜÛUÝYYYYCCCCÇNNNNÑ"; |
||
12258 | bpr | 703 | #pragma GCC diagnostic pop |
7840 | bpr | 704 | /* compose accent using symbol keys */ |
10 | reyssat | 705 | void reaccent(char *p) |
706 | { |
||
12260 | bpr | 707 | char *sp, *ap, c; |
708 | int i, k; |
||
709 | if(*p==0) return; |
||
710 | for(sp=p+1; *sp; sp++) { |
||
711 | ap=strchr(reaccents,*sp); if(ap==NULL) continue; |
||
712 | i=ap-reaccents; |
||
713 | sp--; ap=strchr(reaccentl,*sp); if(ap==NULL) {sp++; continue;} |
||
714 | k=ap-reaccentl; |
||
715 | c=reaccentab[k*strlen(reaccents)+i]; |
||
716 | if(c!=*sp) {*sp=c; ovlstrcpy(sp+1,sp+2);} |
||
717 | else sp++; |
||
718 | } |
||
10 | reyssat | 719 | } |
720 | |||
7840 | bpr | 721 | /* modify a string. Bufferlen must be at least MAX_LINELEN */ |
8086 | bpr | 722 | void string_modify1(char *start, char *bad_beg, char *bad_end, char *good,...) |
10 | reyssat | 723 | { |
12260 | bpr | 724 | char buf[MAX_LINELEN+1]; |
725 | int ln, le; |
||
726 | va_list vp; |
||
7079 | bpr | 727 | |
12260 | bpr | 728 | va_start(vp,good); |
729 | vsnprintf(buf,sizeof(buf),good,vp); va_end(vp); |
||
730 | ln=strlen(buf); le=strlen(bad_end); |
||
731 | if(ln+le+(bad_beg-start)>=MAX_LINELEN) { |
||
732 | error("string_too_long"); return; |
||
733 | } |
||
734 | if(ln!=bad_end-bad_beg) memmove(bad_beg+ln,bad_end,le+1); |
||
735 | memmove(bad_beg,buf,ln); |
||
10 | reyssat | 736 | } |
737 | |||
8861 | bpr | 738 | /* modify a string. Bufferlen must be at least MAX_LINELEN */ |
739 | void string_modify3(char *start, char *bad_beg, char *bad_end, char *good,...) |
||
740 | { |
||
12260 | bpr | 741 | char buf[MAX_LINELEN+1]; |
742 | va_list vp; |
||
8861 | bpr | 743 | |
12260 | bpr | 744 | va_start(vp,good); |
745 | vsnprintf(buf,sizeof(buf),good,vp); va_end(vp); |
||
746 | if(strlen(start)-(bad_end-bad_beg)+strlen(buf)>=MAX_LINELEN) |
||
747 | return; /* this is an error situation. */ |
||
748 | strcat(buf,bad_end); |
||
749 | ovlstrcpy(bad_beg,buf); |
||
8861 | bpr | 750 | } |
751 | |||
7840 | bpr | 752 | /* returns number of bytes written */ |
10 | reyssat | 753 | int catfile(FILE *outf, char *fn,...) |
754 | { |
||
12260 | bpr | 755 | char buf[4096]; |
756 | va_list vp; |
||
757 | int l,tot,fd; |
||
7079 | bpr | 758 | |
12260 | bpr | 759 | tot=0; |
760 | va_start(vp,fn); |
||
761 | vsnprintf(buf,sizeof(buf),fn,vp); va_end(vp); |
||
762 | fd=open(buf,O_RDONLY); if(fd==-1) return 0; |
||
763 | for(l=read(fd,buf,4096);l>0 && l<=4096; l=read(fd,buf,4096)) { |
||
764 | fwrite(buf,1,l,outf); tot+=l; |
||
765 | } |
||
766 | close(fd); |
||
767 | return tot; |
||
10 | reyssat | 768 | } |
769 | |||
7840 | bpr | 770 | /* returns -1 if error */ |
10 | reyssat | 771 | long int filelength(char *fn,...) |
772 | { |
||
12260 | bpr | 773 | char buf[MAX_FNAME+1]; |
774 | va_list vp; |
||
775 | struct stat st; |
||
776 | int l; |
||
7079 | bpr | 777 | |
12260 | bpr | 778 | va_start(vp,fn); |
779 | vsnprintf(buf,sizeof(buf),fn,vp); va_end(vp); |
||
780 | l=stat(buf,&st); if(l) return -1; |
||
781 | return st.st_size; |
||
10 | reyssat | 782 | } |
8880 | bpr | 783 | |
784 | char *parend(char *p) |
||
785 | { |
||
12260 | bpr | 786 | char *pp; int t; |
787 | t=0; for(pp=p;*pp;pp++) { |
||
788 | if(*pp=='(') t++; |
||
789 | if(*pp==')') {t--; if(t==0) return pp; if(t<0) return NULL;} |
||
790 | } |
||
791 | return NULL; |
||
8880 | bpr | 792 | } |
793 | |||
794 | char *bufprep(char *p) |
||
795 | { |
||
796 | /* singlespace(p); strip_trailing_spaces(p); return find_word_start(p); */ |
||
12260 | bpr | 797 | nospace(p); return p; |
8880 | bpr | 798 | } |