![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to wordwrap.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Synchronet] / sbbs / src / sbbs3|
Return to wordwrap.c CVS log | Up to [Synchronet] / sbbs / src / sbbs3 |
1.1 root 1: /* $Id: wordwrap.c,v 1.6 2010/05/26 04:54:37 rswindell Exp $ */
2:
3: /****************************************************************************
4: * @format.tab-size 4 (Plain Text/Source Code File Header) *
5: * @format.use-tabs true (see http://www.synchro.net/ptsc_hdr.html) *
6: * *
7: * Copyright 2010 Rob Swindell - http://www.synchro.net/copyright.html *
8: * *
9: * This program is free software; you can redistribute it and/or *
10: * modify it under the terms of the GNU General Public License *
11: * as published by the Free Software Foundation; either version 2 *
12: * of the License, or (at your option) any later version. *
13: * See the GNU General Public License for more details: gpl.txt or *
14: * http://www.fsf.org/copyleft/gpl.html *
15: * *
16: * Anonymous FTP access to the most recent released source is available at *
17: * ftp://vert.synchro.net, ftp://cvs.synchro.net and ftp://ftp.synchro.net *
18: * *
19: * Anonymous CVS access to the development source and modification history *
20: * is available at cvs.synchro.net:/cvsroot/sbbs, example: *
21: * cvs -d :pserver:[email protected]:/cvsroot/sbbs login *
22: * (just hit return, no password is necessary) *
23: * cvs -d :pserver:[email protected]:/cvsroot/sbbs checkout src *
24: * *
25: * For Synchronet coding style and modification guidelines, see *
26: * http://www.synchro.net/source.html *
27: * *
28: * You are encouraged to submit any modifications (preferably in Unix diff *
29: * format) via e-mail to [email protected] *
30: * *
31: * Note: If this box doesn't appear square, then you need to fix your tabs. *
32: ****************************************************************************/
33:
34: #include <genwrap.h>
35: #include <stdlib.h> /* realloc */
36: #include "wordwrap.h"
37:
38: static int get_prefix(const char *text, int *bytes, int *len, int maxlen)
39: {
40: int tmp_prefix_bytes,tmp_prefix_len;
41: int expect;
42: int depth;
43:
44: *bytes=0;
45: *len=0;
46: tmp_prefix_bytes=0;
47: tmp_prefix_len=0;
48: depth=0;
49: expect=1;
50: if(text[0]!=' ')
51: expect=2;
52: while(expect) {
53: tmp_prefix_bytes++;
54: /* Skip CTRL-A codes */
55: while(text[tmp_prefix_bytes-1]=='\x01') {
56: tmp_prefix_bytes++;
57: if(text[tmp_prefix_bytes-1]=='\x01')
58: break;
59: tmp_prefix_bytes++;
60: }
61: tmp_prefix_len++;
62: if(text[tmp_prefix_bytes-1]==0 || text[tmp_prefix_bytes-1]=='\n' || text[tmp_prefix_bytes-1]=='\r')
63: break;
64: switch(expect) {
65: case 1: /* At start of possible quote (Next char should be space) */
66: if(text[tmp_prefix_bytes-1]!=' ')
67: expect=0;
68: else
69: expect++;
70: break;
71: case 2: /* At start of nick (next char should be alphanum or '>') */
72: case 3: /* At second nick initial (next char should be alphanum or '>') */
73: case 4: /* At third nick initial (next char should be alphanum or '>') */
74: if(text[tmp_prefix_bytes-1]==' ' || text[tmp_prefix_bytes-1]==0)
75: expect=0;
76: else
77: if(text[tmp_prefix_bytes-1]=='>')
78: expect=6;
79: else
80: expect++;
81: break;
82: case 5: /* After three regular chars, next HAS to be a '>') */
83: if(text[tmp_prefix_bytes-1]!='>')
84: expect=0;
85: else
86: expect++;
87: break;
88: case 6: /* At '>' next char must be a space */
89: if(text[tmp_prefix_bytes-1]!=' ')
90: expect=0;
91: else {
92: expect=1;
93: *len=tmp_prefix_len;
94: *bytes=tmp_prefix_bytes;
95: depth++;
96: /* Some editors don't put double spaces in between */
97: if(text[tmp_prefix_bytes]!=' ')
98: expect++;
99: }
100: break;
101: default:
102: expect=0;
103: break;
104: }
105: }
106: if(*bytes >= maxlen) {
107: // lprintf(LOG_CRIT, "Prefix bytes %u is larger than buffer (%u) here: %*.*s",*bytes,maxlen,maxlen,maxlen,text);
108: *bytes=maxlen-1;
109: }
110: return(depth);
111: }
112:
113: static void outbuf_append(char **outbuf, char **outp, char *append, int len, int *outlen)
114: {
115: char *p;
116:
117: /* Terminate outbuf */
118: **outp=0;
119: /* Check if there's room */
120: if(*outp - *outbuf + len < *outlen) {
121: memcpy(*outp, append, len);
122: *outp+=len;
123: return;
124: }
125: /* Not enough room, double the size. */
126: *outlen *= 2;
127: p=realloc(*outbuf, *outlen);
128: if(p==NULL) {
129: /* Can't do it. */
130: *outlen/=2;
131: return;
132: }
133: /* Set outp for new buffer */
134: *outp=p+(*outp - *outbuf);
135: *outbuf=p;
136: memcpy(*outp, append, len);
137: *outp+=len;
138: return;
139: }
140:
141: static int compare_prefix(char *old_prefix, int old_prefix_bytes, const char *new_prefix, int new_prefix_bytes)
142: {
143: int i;
144:
145: if(new_prefix_bytes != old_prefix_bytes) {
146: if(new_prefix_bytes < old_prefix_bytes) {
147: if(memcmp(old_prefix, new_prefix, new_prefix_bytes)!=0)
148: return(-1);
149: for(i=new_prefix_bytes; i<old_prefix_bytes; i++) {
150: if(!isspace((unsigned char)old_prefix[i]))
151: return(-1);
152: }
153: }
154: else {
155: if(memcmp(old_prefix, new_prefix, old_prefix_bytes)!=0)
156: return(-1);
157: for(i=old_prefix_bytes; i<new_prefix_bytes; i++) {
158: if(!isspace((unsigned char)new_prefix[i]))
159: return(-1);
160: }
161: }
162: return(0);
163: }
164: if(memcmp(old_prefix,new_prefix,new_prefix_bytes)!=0)
165: return(-1);
166:
167: return(0);
168: }
169:
170: char* wordwrap(char* inbuf, int len, int oldlen, BOOL handle_quotes)
171: {
172: int l;
173: int crcount=0;
174: long i,k,t;
175: int ocol=1;
176: int icol=1;
177: char* outbuf;
178: char* outp;
179: char* linebuf;
180: char* prefix=NULL;
181: int prefix_len=0;
182: int prefix_bytes=0;
183: int quote_count=0;
184: int old_prefix_bytes=0;
185: int outbuf_size=0;
186: int inbuf_len=strlen(inbuf);
187:
188: outbuf_size=inbuf_len*3+1;
189: if((outbuf=(char*)malloc(outbuf_size))==NULL)
190: return NULL;
191: outp=outbuf;
192:
193: if((linebuf=(char*)malloc(inbuf_len+2))==NULL) /* room for ^A codes */
194: return NULL;
195:
196: if(handle_quotes) {
197: if((prefix=(char *)malloc(inbuf_len+1))==NULL) { /* room for ^A codes */
198: free(linebuf);
199: return NULL;
200: }
201: prefix[0]=0;
202: }
203:
204: outbuf[0]=0;
205: /* Get prefix from the first line (ouch) */
206: l=0;
207: i=0;
208: if(handle_quotes && (quote_count=get_prefix(inbuf, &prefix_bytes, &prefix_len, len*2+2))!=0) {
209: i+=prefix_bytes;
210: if(prefix_len>len/3*2) {
211: /* This prefix is insane (more than 2/3rds of the new width) hack it down to size */
212: /* Since we're hacking it, we will always end up with a hardcr on this line. */
213: /* ToDo: Something prettier would be nice. */
214: sprintf(prefix," %d> ",quote_count);
215: prefix_len=strlen(prefix);
216: prefix_bytes=strlen(prefix);
217: }
218: else {
219: memcpy(prefix,inbuf,prefix_bytes);
220: /* Terminate prefix */
221: prefix[prefix_bytes]=0;
222: }
223: memcpy(linebuf,prefix,prefix_bytes);
224: l=prefix_bytes;
225: ocol=prefix_len+1;
226: icol=prefix_len+1;
227: old_prefix_bytes=prefix_bytes;
228: }
229: for(; inbuf[i]; i++) {
230: if(l>=len*2+2) {
231: l-=4;
232: linebuf[l]=0;
233: // lprintf(LOG_CRIT, "Word wrap line buffer exceeded... munging line %s",linebuf);
234: }
235: switch(inbuf[i]) {
236: case '\r':
237: crcount++;
238: break;
239: case '\n':
240: if(handle_quotes && (quote_count=get_prefix(inbuf+i+1, &prefix_bytes, &prefix_len, len*2+2))!=0) {
241: /* Move the input pointer offset to the last char of the prefix */
242: i+=prefix_bytes;
243: }
244: if(!inbuf[i+1]) { /* EOF */
245: linebuf[l++]='\r';
246: linebuf[l++]='\n';
247: outbuf_append(&outbuf, &outp, linebuf, l, &outbuf_size);
248: l=0;
249: ocol=1;
250: }
251: /* If there's a new prefix, it is a hardcr */
252: else if(compare_prefix(prefix, old_prefix_bytes, inbuf+i+1-prefix_bytes, prefix_bytes)!=0) {
253: if(prefix_len>len/3*2) {
254: /* This prefix is insane (more than 2/3rds of the new width) hack it down to size */
255: /* Since we're hacking it, we will always end up with a hardcr on this line. */
256: /* ToDo: Something prettier would be nice. */
257: sprintf(prefix," %d> ",quote_count);
258: prefix_len=strlen(prefix);
259: prefix_bytes=strlen(prefix);
260: }
261: else {
262: memcpy(prefix,inbuf+i+1-prefix_bytes,prefix_bytes);
263: /* Terminate prefix */
264: prefix[prefix_bytes]=0;
265: }
266: linebuf[l++]='\r';
267: linebuf[l++]='\n';
268: outbuf_append(&outbuf, &outp, linebuf, l, &outbuf_size);
269: memcpy(linebuf,prefix,prefix_bytes);
270: l=prefix_bytes;
271: ocol=prefix_len+1;
272: old_prefix_bytes=prefix_bytes;
273: }
274: else if(isspace((unsigned char)inbuf[i+1]) && inbuf[i+1] != '\n' && inbuf[i+1] != '\r') { /* Next line starts with whitespace. This is a "hard" CR. */
275: linebuf[l++]='\r';
276: linebuf[l++]='\n';
277: outbuf_append(&outbuf, &outp, linebuf, l, &outbuf_size);
278: l=prefix_bytes;
279: ocol=prefix_len+1;
280: }
281: else {
282: if(icol < oldlen) { /* If this line is overly long, It's impossible for the next word to fit */
283: /* k will equal the length of the first word on the next line */
284: for(k=0; inbuf[i+1+k] && (!isspace((unsigned char)inbuf[i+1+k])); k++);
285: if(icol+k+1 < oldlen) { /* The next word would have fit but isn't here. Must be a hard CR */
286: linebuf[l++]='\r';
287: linebuf[l++]='\n';
288: outbuf_append(&outbuf, &outp, linebuf, l, &outbuf_size);
289: if(prefix)
290: memcpy(linebuf,prefix,prefix_bytes);
291: l=prefix_bytes;
292: ocol=prefix_len+1;
293: }
294: else { /* Not a hard CR... add space if needed */
295: if(l<1 || !isspace((unsigned char)linebuf[l-1])) {
296: linebuf[l++]=' ';
297: ocol++;
298: }
299: }
300: }
301: else { /* Not a hard CR... add space if needed */
302: if(l<1 || !isspace((unsigned char)linebuf[l-1])) {
303: linebuf[l++]=' ';
304: ocol++;
305: }
306: }
307: }
308: icol=prefix_len+1;
309: break;
310: case '\x1f': /* Delete... meaningless... strip. */
311: break;
312: case '\b': /* Backspace... handle if possible, but don't go crazy. */
313: if(l>0) {
314: if(l>1 && linebuf[l-2]=='\x01') {
315: if(linebuf[l-1]=='\x01') {
316: ocol--;
317: icol--;
318: }
319: l-=2;
320: }
321: else {
322: l--;
323: ocol--;
324: icol--;
325: }
326: }
327: break;
328: case '\t': /* TAB */
329: linebuf[l++]=inbuf[i];
330: /* Can't ever wrap on whitespace remember. */
331: icol++;
332: ocol++;
333: while(ocol%8)
334: ocol++;
335: while(icol%8)
336: icol++;
337: break;
338: case '\x01': /* CTRL-A */
339: linebuf[l++]=inbuf[i++];
340: if(inbuf[i]!='\x01') {
341: linebuf[l++]=inbuf[i];
342: break;
343: }
344: default:
345: linebuf[l++]=inbuf[i];
346: ocol++;
347: icol++;
348: if(ocol>len && !isspace((unsigned char)inbuf[i])) { /* Need to wrap here */
349: /* Find the start of the last word */
350: k=l; /* Original next char */
351: l--; /* Move back to the last char */
352: while((!isspace((unsigned char)linebuf[l])) && l>0) /* Move back to the last non-space char */
353: l--;
354: if(l==0) { /* Couldn't wrap... must chop. */
355: l=k;
356: while(l>1 && linebuf[l-2]=='\x01' && linebuf[l-1]!='\x01')
357: l-=2;
358: if(l>0 && linebuf[l-1]=='\x01')
359: l--;
360: if(l>0)
361: l--;
362: }
363: t=l+1; /* Store start position of next line */
364: /* Move to start of whitespace */
365: while(l>0 && isspace((unsigned char)linebuf[l]))
366: l--;
367: outbuf_append(&outbuf, &outp, linebuf, l+1, &outbuf_size);
368: outbuf_append(&outbuf, &outp, "\r\n", 2, &outbuf_size);
369: /* Move trailing words to start of buffer. */
370: l=prefix_bytes;
371: if(k-t>0) /* k-1 is the last char position. t is the start of the next line position */
372: memmove(linebuf+l, linebuf+t, k-t);
373: l+=k-t;
374: /* Find new ocol */
375: for(ocol=prefix_len+1,t=prefix_bytes; t<l; t++) {
376: switch(linebuf[t]) {
377: case '\x01': /* CTRL-A */
378: t++;
379: if(linebuf[t]!='\x01')
380: break;
381: /* Fall-through */
382: default:
383: ocol++;
384: }
385: }
386: }
387: }
388: }
389: /* Trailing bits. */
390: if(l) {
391: linebuf[l++]='\r';
392: linebuf[l++]='\n';
393: outbuf_append(&outbuf, &outp, linebuf, l, &outbuf_size);
394: }
395: *outp=0;
396: /* If there were no CRs in the input, strip all CRs */
397: if(!crcount) {
398: for(inbuf=outbuf; *inbuf; inbuf++) {
399: if(*inbuf=='\r')
400: memmove(inbuf, inbuf+1, strlen(inbuf));
401: }
402: }
403: free(linebuf);
404:
405: if(prefix)
406: free(prefix);
407:
408: return outbuf;
409: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.