summaryrefslogtreecommitdiffstats
path: root/token822.c
diff options
context:
space:
mode:
Diffstat (limited to 'token822.c')
-rw-r--r--token822.c513
1 files changed, 513 insertions, 0 deletions
diff --git a/token822.c b/token822.c
new file mode 100644
index 0000000..48a4388
--- /dev/null
+++ b/token822.c
@@ -0,0 +1,513 @@
1#include "stralloc.h"
2#include "alloc.h"
3#include "str.h"
4#include "token822.h"
5#include "gen_allocdefs.h"
6
7static struct token822 comma = { TOKEN822_COMMA };
8
9void token822_reverse(ta)
10token822_alloc *ta;
11{
12 int i;
13 int n;
14 struct token822 temp;
15
16 n = ta->len - 1;
17 for (i = 0;i + i < n;++i)
18 {
19 temp = ta->t[i];
20 ta->t[i] = ta->t[n - i];
21 ta->t[n - i] = temp;
22 }
23}
24
25GEN_ALLOC_ready(token822_alloc,struct token822,t,len,a,i,n,x,30,token822_ready)
26GEN_ALLOC_readyplus(token822_alloc,struct token822,t,len,a,i,n,x,30,token822_readyplus)
27GEN_ALLOC_append(token822_alloc,struct token822,t,len,a,i,n,x,30,token822_readyplus,token822_append)
28
29static int needspace(t1,t2)
30int t1;
31int t2;
32{
33 if (!t1) return 0;
34 if (t1 == TOKEN822_COLON) return 1;
35 if (t1 == TOKEN822_COMMA) return 1;
36 if (t2 == TOKEN822_LEFT) return 1;
37 switch(t1)
38 {
39 case TOKEN822_ATOM: case TOKEN822_LITERAL:
40 case TOKEN822_QUOTE: case TOKEN822_COMMENT:
41 switch(t2)
42 {
43 case TOKEN822_ATOM: case TOKEN822_LITERAL:
44 case TOKEN822_QUOTE: case TOKEN822_COMMENT:
45 return 1;
46 }
47 }
48 return 0;
49}
50
51static int atomok(ch)
52char ch;
53{
54 switch(ch)
55 {
56 case ' ': case '\t': case '\r': case '\n':
57 case '(': case '[': case '"':
58 case '<': case '>': case ';': case ':':
59 case '@': case ',': case '.':
60 return 0;
61 }
62 return 1;
63}
64
65static void atomcheck(t)
66struct token822 *t;
67{
68 int i;
69 char ch;
70 for (i = 0;i < t->slen;++i)
71 {
72 ch = t->s[i];
73 if ((ch < 32) || (ch > 126) || (ch == ')') || (ch == ']') || (ch == '\\'))
74 {
75 t->type = TOKEN822_QUOTE;
76 return;
77 }
78 }
79}
80
81int token822_unparse(sa,ta,linelen)
82stralloc *sa;
83token822_alloc *ta;
84unsigned int linelen;
85{
86 struct token822 *t;
87 int len;
88 int ch;
89 int i;
90 int j;
91 int lasttype;
92 int newtype;
93 char *s;
94 char *lineb;
95 char *linee;
96
97 len = 0;
98 lasttype = 0;
99 for (i = 0;i < ta->len;++i)
100 {
101 t = ta->t + i;
102 newtype = t->type;
103 if (needspace(lasttype,newtype))
104 ++len;
105 lasttype = newtype;
106 switch(newtype)
107 {
108 case TOKEN822_COMMA:
109 len += 3; break;
110 case TOKEN822_AT: case TOKEN822_DOT: case TOKEN822_LEFT: case TOKEN822_RIGHT:
111 case TOKEN822_SEMI: case TOKEN822_COLON:
112 ++len; break;
113 case TOKEN822_ATOM: case TOKEN822_QUOTE: case TOKEN822_LITERAL: case TOKEN822_COMMENT:
114 if (t->type != TOKEN822_ATOM) len += 2;
115 for (j = 0;j < t->slen;++j)
116 switch(ch = t->s[j])
117 {
118 case '"': case '[': case ']': case '(': case ')':
119 case '\\': case '\r': case '\n': ++len;
120 default: ++len;
121 }
122 break;
123 }
124 }
125 len += 2;
126
127 if (!stralloc_ready(sa,len))
128 return -1;
129
130 s = sa->s;
131 lineb = s;
132 linee = 0;
133
134 lasttype = 0;
135 for (i = 0;i < ta->len;++i)
136 {
137 t = ta->t + i;
138 newtype = t->type;
139 if (needspace(lasttype,newtype))
140 *s++ = ' ';
141 lasttype = newtype;
142 switch(newtype)
143 {
144 case TOKEN822_COMMA:
145 *s++ = ',';
146#define NSUW \
147 s[0] = '\n'; s[1] = ' '; \
148 if (linee && (!linelen || (s - lineb <= linelen))) \
149 { while (linee < s) { linee[0] = linee[2]; ++linee; } linee -= 2; } \
150 else { if (linee) lineb = linee + 1; linee = s; s += 2; }
151 NSUW
152 break;
153 case TOKEN822_AT: *s++ = '@'; break;
154 case TOKEN822_DOT: *s++ = '.'; break;
155 case TOKEN822_LEFT: *s++ = '<'; break;
156 case TOKEN822_RIGHT: *s++ = '>'; break;
157 case TOKEN822_SEMI: *s++ = ';'; break;
158 case TOKEN822_COLON: *s++ = ':'; break;
159 case TOKEN822_ATOM: case TOKEN822_QUOTE: case TOKEN822_LITERAL: case TOKEN822_COMMENT:
160 if (t->type == TOKEN822_QUOTE) *s++ = '"';
161 if (t->type == TOKEN822_LITERAL) *s++ = '[';
162 if (t->type == TOKEN822_COMMENT) *s++ = '(';
163 for (j = 0;j < t->slen;++j)
164 switch(ch = t->s[j])
165 {
166 case '"': case '[': case ']': case '(': case ')':
167 case '\\': case '\r': case '\n': *s++ = '\\';
168 default: *s++ = ch;
169 }
170 if (t->type == TOKEN822_QUOTE) *s++ = '"';
171 if (t->type == TOKEN822_LITERAL) *s++ = ']';
172 if (t->type == TOKEN822_COMMENT) *s++ = ')';
173 break;
174 }
175 }
176 NSUW
177 --s;
178 sa->len = s - sa->s;
179 return 1;
180}
181
182int token822_unquote(sa,ta)
183stralloc *sa;
184token822_alloc *ta;
185{
186 struct token822 *t;
187 int len;
188 int i;
189 int j;
190 char *s;
191
192 len = 0;
193 for (i = 0;i < ta->len;++i)
194 {
195 t = ta->t + i;
196 switch(t->type)
197 {
198 case TOKEN822_COMMA: case TOKEN822_AT: case TOKEN822_DOT: case TOKEN822_LEFT:
199 case TOKEN822_RIGHT: case TOKEN822_SEMI: case TOKEN822_COLON:
200 ++len; break;
201 case TOKEN822_LITERAL:
202 len += 2;
203 case TOKEN822_ATOM: case TOKEN822_QUOTE:
204 len += t->slen;
205 }
206 }
207
208 if (!stralloc_ready(sa,len))
209 return -1;
210
211 s = sa->s;
212
213 for (i = 0;i < ta->len;++i)
214 {
215 t = ta->t + i;
216 switch(t->type)
217 {
218 case TOKEN822_COMMA: *s++ = ','; break;
219 case TOKEN822_AT: *s++ = '@'; break;
220 case TOKEN822_DOT: *s++ = '.'; break;
221 case TOKEN822_LEFT: *s++ = '<'; break;
222 case TOKEN822_RIGHT: *s++ = '>'; break;
223 case TOKEN822_SEMI: *s++ = ';'; break;
224 case TOKEN822_COLON: *s++ = ':'; break;
225 case TOKEN822_ATOM: case TOKEN822_QUOTE: case TOKEN822_LITERAL:
226 if (t->type == TOKEN822_LITERAL) *s++ = '[';
227 for (j = 0;j < t->slen;++j)
228 *s++ = t->s[j];
229 if (t->type == TOKEN822_LITERAL) *s++ = ']';
230 break;
231 case TOKEN822_COMMENT: break;
232 }
233 }
234 sa->len = s - sa->s;
235 return 1;
236}
237
238int token822_parse(ta,sa,buf)
239token822_alloc *ta;
240stralloc *sa;
241stralloc *buf;
242{
243 int i;
244 int salen;
245 int level;
246 struct token822 *t;
247 int numtoks;
248 int numchars;
249 char *cbuf;
250
251 salen = sa->len;
252
253 numchars = 0;
254 numtoks = 0;
255 for (i = 0;i < salen;++i)
256 switch(sa->s[i])
257 {
258 case '.': case ',': case '@': case '<': case '>': case ':': case ';':
259 ++numtoks; break;
260 case ' ': case '\t': case '\r': case '\n': break;
261 case ')': case ']': return 0;
262 /* other control chars and non-ASCII chars are also bad, in theory */
263 case '(':
264 level = 1;
265 while (level)
266 {
267 if (++i >= salen) return 0;
268 switch(sa->s[i])
269 {
270 case '(': ++level; break;
271 case ')': --level; break;
272 case '\\': if (++i >= salen) return 0;
273 default: ++numchars;
274 }
275 }
276 ++numtoks;
277 break;
278 case '"':
279 level = 1;
280 while (level)
281 {
282 if (++i >= salen) return 0;
283 switch(sa->s[i])
284 {
285 case '"': --level; break;
286 case '\\': if (++i >= salen) return 0;
287 default: ++numchars;
288 }
289 }
290 ++numtoks;
291 break;
292 case '[':
293 level = 1;
294 while (level)
295 {
296 if (++i >= salen) return 0;
297 switch(sa->s[i])
298 {
299 case ']': --level; break;
300 case '\\': if (++i >= salen) return 0;
301 default: ++numchars;
302 }
303 }
304 ++numtoks;
305 break;
306 default:
307 do
308 {
309 if (sa->s[i] == '\\') if (++i >= salen) break;
310 ++numchars;
311 if (++i >= salen)
312 break;
313 }
314 while (atomok(sa->s[i]));
315 --i;
316 ++numtoks;
317 }
318
319 if (!token822_ready(ta,numtoks))
320 return -1;
321 if (!stralloc_ready(buf,numchars))
322 return -1;
323 cbuf = buf->s;
324 ta->len = numtoks;
325
326 t = ta->t;
327 for (i = 0;i < salen;++i)
328 switch(sa->s[i])
329 {
330 case '.': t->type = TOKEN822_DOT; ++t; break;
331 case ',': t->type = TOKEN822_COMMA; ++t; break;
332 case '@': t->type = TOKEN822_AT; ++t; break;
333 case '<': t->type = TOKEN822_LEFT; ++t; break;
334 case '>': t->type = TOKEN822_RIGHT; ++t; break;
335 case ':': t->type = TOKEN822_COLON; ++t; break;
336 case ';': t->type = TOKEN822_SEMI; ++t; break;
337 case ' ': case '\t': case '\r': case '\n': break;
338 case '(':
339 t->type = TOKEN822_COMMENT; t->s = cbuf; t->slen = 0;
340 level = 1;
341 while (level)
342 {
343 ++i; /* assert: < salen */
344 switch(sa->s[i])
345 {
346 case '(': ++level; break;
347 case ')': --level; break;
348 case '\\': ++i; /* assert: < salen */
349 default: *cbuf++ = sa->s[i]; ++t->slen;
350 }
351 }
352 ++t;
353 break;
354 case '"':
355 t->type = TOKEN822_QUOTE; t->s = cbuf; t->slen = 0;
356 level = 1;
357 while (level)
358 {
359 ++i; /* assert: < salen */
360 switch(sa->s[i])
361 {
362 case '"': --level; break;
363 case '\\': ++i; /* assert: < salen */
364 default: *cbuf++ = sa->s[i]; ++t->slen;
365 }
366 }
367 ++t;
368 break;
369 case '[':
370 t->type = TOKEN822_LITERAL; t->s = cbuf; t->slen = 0;
371 level = 1;
372 while (level)
373 {
374 ++i; /* assert: < salen */
375 switch(sa->s[i])
376 {
377 case ']': --level; break;
378 case '\\': ++i; /* assert: < salen */
379 default: *cbuf++ = sa->s[i]; ++t->slen;
380 }
381 }
382 ++t;
383 break;
384 default:
385 t->type = TOKEN822_ATOM; t->s = cbuf; t->slen = 0;
386 do
387 {
388 if (sa->s[i] == '\\') if (++i >= salen) break;
389 *cbuf++ = sa->s[i]; ++t->slen;
390 if (++i >= salen)
391 break;
392 }
393 while (atomok(sa->s[i]));
394 atomcheck(t);
395 --i;
396 ++t;
397 }
398 return 1;
399}
400
401static int gotaddr(taout,taaddr,callback)
402token822_alloc *taout;
403token822_alloc *taaddr;
404int (*callback)();
405{
406 int i;
407
408 if (callback(taaddr) != 1)
409 return 0;
410
411 if (!token822_readyplus(taout,taaddr->len))
412 return 0;
413
414 for (i = 0;i < taaddr->len;++i)
415 taout->t[taout->len++] = taaddr->t[i];
416
417 taaddr->len = 0;
418 return 1;
419}
420
421int token822_addrlist(taout,taaddr,ta,callback)
422token822_alloc *taout;
423token822_alloc *taaddr;
424token822_alloc *ta;
425int (*callback)();
426{
427 struct token822 *t;
428 struct token822 *beginning;
429 int ingroup;
430 int wordok;
431
432 taout->len = 0;
433 taaddr->len = 0;
434
435 if (!token822_readyplus(taout,1)) return -1;
436 if (!token822_readyplus(taaddr,1)) return -1;
437
438 ingroup = 0;
439 wordok = 1;
440
441 beginning = ta->t + 2;
442 t = ta->t + ta->len - 1;
443
444 /* rfc 822 address lists are easy to parse from right to left */
445
446#define FLUSH if (taaddr->len) if (!gotaddr(taout,taaddr,callback)) return -1;
447#define FLUSHCOMMA if (taaddr->len) { \
448if (!gotaddr(taout,taaddr,callback)) return -1; \
449if (!token822_append(taout,&comma)) return -1; }
450#define ADDRLEFT if (!token822_append(taaddr,t--)) return -1;
451#define OUTLEFT if (!token822_append(taout,t--)) return -1;
452
453 while (t >= beginning)
454 {
455 switch(t->type)
456 {
457 case TOKEN822_SEMI:
458 FLUSHCOMMA
459 if (ingroup) return 0;
460 ingroup = 1;
461 wordok = 1;
462 break;
463 case TOKEN822_COLON:
464 FLUSH
465 if (!ingroup) return 0;
466 ingroup = 0;
467 while ((t >= beginning) && (t->type != TOKEN822_COMMA))
468 OUTLEFT
469 if (t >= beginning)
470 OUTLEFT
471 wordok = 1;
472 continue;
473 case TOKEN822_RIGHT:
474 FLUSHCOMMA
475 OUTLEFT
476 while ((t >= beginning) && (t->type != TOKEN822_LEFT))
477 ADDRLEFT
478 /* important to use address here even if it's empty: <> */
479 if (!gotaddr(taout,taaddr,callback)) return -1;
480 if (t < beginning) return 0;
481 OUTLEFT
482 while ((t >= beginning) && ((t->type == TOKEN822_COMMENT) || (t->type == TOKEN822_ATOM) || (t->type == TOKEN822_QUOTE) || (t->type == TOKEN822_AT) || (t->type == TOKEN822_DOT)))
483 OUTLEFT
484 wordok = 0;
485 continue;
486 case TOKEN822_ATOM: case TOKEN822_QUOTE: case TOKEN822_LITERAL:
487 if (!wordok)
488 FLUSHCOMMA
489 wordok = 0;
490 ADDRLEFT
491 continue;
492 case TOKEN822_COMMENT:
493 /* comment is lexically a space; shouldn't affect wordok */
494 break;
495 case TOKEN822_COMMA:
496 FLUSH
497 wordok = 1;
498 break;
499 default:
500 wordok = 1;
501 ADDRLEFT
502 continue;
503 }
504 OUTLEFT
505 }
506 FLUSH
507 ++t;
508 while (t > ta->t)
509 if (!token822_append(taout,--t)) return -1;
510
511 token822_reverse(taout);
512 return 1;
513}
generated by cgit v1.2.3 (git 2.25.1) at 2026-01-11 20:32:18 +0000