source: text.c @ 099597c

release-1.10release-1.8release-1.9
Last change on this file since 099597c was 4d24650, checked in by David Benjamin <davidben@mit.edu>, 14 years ago
Make owl_text_indent return a new string You can't really use it correctly as it is.
  • Property mode set to 100644
File size: 7.5 KB
Line 
1#include <stdio.h>
2#include <string.h>
3#include <stdlib.h>
4#include <ctype.h>
5#include "owl.h"
6
7/* Returns a copy of 'in' with each line indented 'n'
8 * characters. Result must be freed with owl_free. */
9char *owl_text_indent(const char *in, int n)
10{
11  const char *ptr1, *ptr2, *last;
12  GString *out = g_string_new("");
13  int i;
14
15  last=in+strlen(in)-1;
16  ptr1=in;
17  while (ptr1<=last) {
18    for (i=0; i<n; i++) {
19      g_string_append_c(out, ' ');
20    }
21    ptr2=strchr(ptr1, '\n');
22    if (!ptr2) {
23      g_string_append(out, ptr1);
24      break;
25    } else {
26      g_string_append_len(out, ptr1, ptr2-ptr1+1);
27    }
28    ptr1=ptr2+1;
29  }
30  return g_string_free(out, false);
31}
32
33int owl_text_num_lines(const char *in)
34{
35  int lines, i;
36
37  lines=0;
38  for (i=0; in[i]!='\0'; i++) {
39    if (in[i]=='\n') lines++;
40  }
41
42  /* if the last char wasn't a \n there's one more line */
43  if (i>0 && in[i-1]!='\n') lines++;
44
45  return(lines);
46}
47
48
49/* caller must free the return */
50char *owl_text_htmlstrip(const char *in)
51{
52  const char *ptr1, *end, *ptr2, *ptr3;
53  char *out, *out2;
54
55  out=owl_malloc(strlen(in)+30);
56  strcpy(out, "");
57
58  ptr1=in;
59  end=in+strlen(in);
60 
61  while(ptr1<end) {
62    /* look for an open bracket */
63    ptr2=strchr(ptr1, '<');
64
65    /* if none, copy in from here to end and exit */
66    if (ptr2==NULL) {
67      strcat(out, ptr1);
68      break;
69    }
70
71    /* otherwise copy in everything before the open bracket */
72    if (ptr2>ptr1) {
73      strncat(out, ptr1, ptr2-ptr1);
74    }
75
76    /* find the close bracket */
77    ptr3=strchr(ptr2, '>');
78   
79    /* if there is no close, copy as you are and exit */
80    if (!ptr3) {
81      strcat(out, ptr2);
82      break;
83    }
84
85    /* look for things we know */
86    if (!strncasecmp(ptr2, "<BODY", 5) ||
87        !strncasecmp(ptr2, "<FONT", 5) ||
88        !strncasecmp(ptr2, "<HTML", 5) ||
89        !strncasecmp(ptr2, "</FONT", 6) ||
90        !strncasecmp(ptr2, "</HTML", 6) ||
91        !strncasecmp(ptr2, "</BODY", 6)) {
92
93      /* advance to beyond the angle brakcet and go again */
94      ptr1=ptr3+1;
95      continue;
96    }
97    if (!strncasecmp(ptr2, "<BR>", 4)) {
98      strcat(out, "\n");
99      ptr1=ptr3+1;
100      continue;
101    }
102
103    /* if it wasn't something we know, copy to the > and  go again */
104    strncat(out, ptr2, ptr3-ptr2+1);
105    ptr1=ptr3+1;
106  }
107
108  out2=owl_text_substitute(out, "&lt;", "<");
109  owl_free(out);
110  out=owl_text_substitute(out2, "&gt;", ">");
111  owl_free(out2);
112  out2=owl_text_substitute(out, "&amp;", "&");
113  owl_free(out);
114  out=owl_text_substitute(out2, "&quot;", "\"");
115  owl_free(out2);
116  out2=owl_text_substitute(out, "&nbsp;", " ");
117  owl_free(out);
118  out=owl_text_substitute(out2, "&ensp;", "  ");
119  owl_free(out2);
120  out2=owl_text_substitute(out, "&emsp;", "   ");
121  owl_free(out);
122  out=owl_text_substitute(out2, "&endash;", "--");
123  owl_free(out2);
124  out2=owl_text_substitute(out, "&emdash;", "---");
125  owl_free(out);
126
127  return(out2);
128}
129
130/* Caller must free return */
131char *owl_text_expand_tabs(const char *in)
132{
133  int len = 0;
134  const char *p = in;
135  char *ret, *out;
136  int col;
137
138  col = 0;
139  while(*p) {
140    gunichar c = g_utf8_get_char(p);
141    const char *q = g_utf8_next_char(p);
142    switch (c) {
143    case '\t':
144      do { len++; col++; } while (col % OWL_TAB_WIDTH);
145      p = q;
146      continue;
147    case '\n':
148      col = 0;
149      break;
150    default:
151      col += mk_wcwidth(c);
152      break;
153    }
154    len += q - p;
155    p = q;
156  }
157
158  ret = owl_malloc(len + 1);
159
160  p = in;
161  out = ret;
162
163  col = 0;
164  while(*p) {
165    gunichar c = g_utf8_get_char(p);
166    const char *q = g_utf8_next_char(p);
167    switch (c) {
168    case '\t':
169      do {*(out++) = ' '; col++; } while (col % OWL_TAB_WIDTH);
170      p = q;
171      continue;
172    case '\n':
173      col = 0;
174      break;
175    default:
176      col += mk_wcwidth(c);
177      break;
178    }
179    memcpy(out, p, q - p);
180    out += q - p;
181    p = q;
182  }
183
184  *out = 0;
185
186  return ret;
187}
188
189/* caller must free the return */
190char *owl_text_wordwrap(const char *in, int col)
191{
192  char *out;
193  int cur, lastspace, len, lastnewline;
194
195  out=owl_strdup(in);
196  len=strlen(in);
197  cur=0;
198  lastspace=-1;
199  lastnewline=-1;
200
201  while (cur<(len-1)) {
202    if (out[cur]==' ') {
203      lastspace=cur;
204      cur++;
205      continue;
206    } else if (out[cur]=='\n') {
207      lastnewline=cur;
208      cur++;
209      continue;
210    }
211
212    /* do we need to wrap? */
213    if ( (cur-(lastnewline+1)) > col ) {
214      if (lastspace==-1 ||
215          (lastnewline>0 && (lastspace<=lastnewline))) {
216        /* we can't help, sorry */
217        cur++;
218        continue;
219      }
220
221      /* turn the last space into a newline */
222      out[lastspace]='\n';
223      lastnewline=lastspace;
224      lastspace=-1;
225      cur++;
226      continue;
227    }
228
229    cur++;
230    continue;
231  }
232  return(out);
233}
234
235/* this modifies 'in' */
236void owl_text_wordunwrap(char *in)
237{
238  int i, j;
239
240  j=strlen(in);
241  for (i=0; i<j; i++) {
242    if ( (in[i]=='\n') &&
243         ((i>0) && (i<(j-1))) &&
244         (in[i-1]!='\n') &&
245         (in[i+1]!='\n') )
246      in[i]=' ';
247  }
248}
249
250/* return 1 if a string is only whitespace, otherwise 0 */
251int only_whitespace(const char *s)
252{
253  if (g_utf8_validate(s,-1,NULL)) {
254    const char *p;
255    for(p = s; p[0]; p=g_utf8_next_char(p)) {
256      if (!g_unichar_isspace(g_utf8_get_char(p))) return 0;
257    }
258  }
259  else {
260    int i;
261    for (i=0; s[i]; i++) {
262      if (!isspace((int) s[i])) return(0);
263    }
264  }
265  return(1);
266}
267
268/* Return a string with any occurances of 'from' replaced with 'to'.
269 * Does not currently handle backslash quoting, but may in the future.
270 * Caller must free returned string.
271 */
272char *owl_text_substitute(const char *in, const char *from, const char *to)
273{
274 
275  char *out;
276  int   outlen, tolen, fromlen, inpos=0, outpos=0;
277
278  if (!*from) return owl_strdup(in);
279
280  outlen = strlen(in)+1;
281  tolen  = strlen(to);
282  fromlen  = strlen(from);
283  out = owl_malloc(outlen);
284
285  while (in[inpos]) {
286    if (!strncmp(in+inpos, from, fromlen)) {
287      outlen += tolen;
288      out = owl_realloc(out, outlen);
289      strcpy(out+outpos, to);
290      inpos += fromlen;
291      outpos += tolen;
292    } else {
293      out[outpos] = in[inpos];
294      inpos++; outpos++;
295    }
296  }
297  out[outpos] = '\0';
298  return(out);
299}
300
301/* replace all instances of character a in buff with the character
302 * b.  buff must be null terminated.
303 */
304void owl_text_tr(char *buff, char a, char b)
305{
306  int i;
307
308  owl_function_debugmsg("In: %s", buff);
309  for (i=0; buff[i]!='\0'; i++) {
310    if (buff[i]==a) buff[i]=b;
311  }
312  owl_function_debugmsg("Out: %s", buff);
313}
314
315/* Return a string which is like 'in' except that every instance of
316 * any character in 'toquote' found in 'in' is preceeded by the string
317 * 'quotestr'.  For example, owl_text_quote(in, "+*.", "\") would
318 * place a backslash before every '+', '*' or '.' in 'in'.  It is
319 * permissable for a character in 'quotestr' to be in 'toquote'.
320 * On success returns the string, on error returns NULL.
321 */
322char *owl_text_quote(const char *in, const char *toquote, const char *quotestr)
323{
324  int i, x, r, place, escape;
325  int in_len, toquote_len, quotestr_len;
326  char *out;
327
328  in_len=strlen(in);
329  toquote_len=strlen(toquote);
330  quotestr_len=strlen(quotestr);
331  place=0;
332  escape = 0;
333  for (i=0; i<in_len; i++) {
334    if(strchr(toquote, in[i]) != NULL)
335      escape++;
336  }
337  out = owl_malloc(in_len + quotestr_len*escape+1);
338  for (i=0; i<in_len; i++) {
339
340    /* check if it's a character that needs quoting */
341    for (x=0; x<toquote_len; x++) {
342      if (in[i]==toquote[x]) {
343        /* quote it */
344        for (r=0; r<quotestr_len; r++) {
345          out[place+r]=quotestr[r];
346        }
347        place+=quotestr_len;
348        break;
349      }
350    }
351
352    /* either way, we now copy over the character */
353    out[place]=in[i];
354    place++;
355  }
356  out[place]='\0';
357  return(out);
358}
Note: See TracBrowser for help on using the repository browser.