2007-01-03 [wwp] 2.6.1cvs102
[claws.git] / src / html.c
1 /*
2  * Sylpheed -- a GTK+ based, lightweight, and fast e-mail client
3  * Copyright (C) 1999-2007 Hiroyuki Yamamoto and the Claws Mail team
4  *
5  * This program is free software; you can redistribute it and/or modify
6  * it under the terms of the GNU General Public License as published by
7  * the Free Software Foundation; either version 2 of the License, or
8  * (at your option) any later version.
9  *
10  * This program is distributed in the hope that it will be useful,
11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
13  * GNU General Public License for more details.
14  *
15  * You should have received a copy of the GNU General Public License
16  * along with this program; if not, write to the Free Software
17  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
18  */
19
20 #include <glib.h>
21 #include <stdio.h>
22 #include <string.h>
23 #include <ctype.h>
24
25 #include "html.h"
26 #include "codeconv.h"
27 #include "utils.h"
28
29 #define SC_HTMLBUFSIZE  8192
30 #define HR_STR          "------------------------------------------------"
31
32 typedef struct _SC_HTMLSymbol   SC_HTMLSymbol;
33
34 struct _SC_HTMLSymbol
35 {
36         gchar *const key;
37         gchar *const val;
38 };
39
40 static SC_HTMLSymbol symbol_list[] = {
41         {"&lt;", "\74"},
42         {"&gt;", "\76"},
43         {"&amp;", "\46"},
44         {"&quot;", "\42"},
45         {"&lsquo;", "\47"},
46         {"&rsquo;", "\47"},
47         {"&ldquo;", "\42"},
48         {"&rdquo;", "\42"},
49         {"&laquo;", "\302\253"},
50         {"&raquo;", "\302\273"},
51         {"&nbsp;", "\40"},
52         {"&trade;", "\50\124\115\51"},
53         {"&hellip;", "\56\56\56"},
54         {"&bull;", "\52"},
55         {"&ndash;", "\55"},
56         {"&mdash;", "\55\55"},
57         {"&euro;", "\105\125\122"},
58         {"&cent;", "\302\242"},
59         {"&pound;", "\302\243"},
60         {"&curren;", "\302\244"},
61         {"&yen;", "\302\245"},
62         {"&copy;", "\302\251"},
63         {"&reg;", "\302\256"},
64         {"&iquest;", "\302\277"},
65         {"&iexcl;", "\302\241"}
66 };
67
68 static SC_HTMLSymbol ascii_symbol_list[] = {
69         {"&iexcl;" , "\302\241"},
70         {"&brvbar;", "\302\246"},
71         {"&copy;"  , "\302\251"},
72         {"&laquo;" , "\302\253"},
73         {"&reg;"   , "\302\256"},
74
75         {"&sup2;"  , "\302\262"},
76         {"&sup3;"  , "\302\263"},
77         {"&acute;" , "\302\264"},
78         {"&cedil;" , "\302\270"},
79         {"&sup1;"  , "\302\271"},
80         {"&raquo;" , "\302\273"},
81         {"&frac14;", "\302\274"},
82         {"&frac12;", "\302\275"},
83         {"&frac34;", "\302\276"},
84         {"&iquest;", "\302\277"},
85
86         {"&Agrave;", "\303\200"},
87         {"&Aacute;", "\303\201"},
88         {"&Acirc;" , "\303\202"},
89         {"&Atilde;", "\303\203"},
90         {"&AElig;" , "\303\206"},
91         {"&Egrave;", "\303\210"},
92         {"&Eacute;", "\303\211"},
93         {"&Ecirc;" , "\303\212"},
94         {"&Igrave;", "\303\214"},
95         {"&Iacute;", "\303\215"},
96         {"&Icirc;" , "\303\216"},
97
98         {"&Ntilde;", "\303\221"},
99         {"&Ograve;", "\303\222"},
100         {"&Oacute;", "\303\223"},
101         {"&Ocirc;" , "\303\224"},
102         {"&Otilde;", "\303\225"},
103         {"&Ugrave;", "\303\231"},
104         {"&Uacute;", "\303\232"},
105         {"&Ucirc;" , "\303\233"},
106         {"&Yacute;", "\303\235"},
107
108         {"&agrave;", "\303\240"},
109         {"&aacute;", "\303\241"},
110         {"&acirc;" , "\303\242"},
111         {"&atilde;", "\303\243"},
112         {"&aelig;" , "\303\246"},
113         {"&egrave;", "\303\250"},
114         {"&eacute;", "\303\251"},
115         {"&ecirc;" , "\303\252"},
116         {"&igrave;", "\303\254"},
117         {"&iacute;", "\303\255"},
118         {"&icirc;" , "\303\256"},
119
120         {"&ntilde;", "\303\261"},
121         {"&ograve;", "\303\262"},
122         {"&oacute;", "\303\263"},
123         {"&ocirc;" , "\303\264"},
124         {"&otilde;", "\303\265"},
125         {"&ugrave;", "\303\271"},
126         {"&uacute;", "\303\272"},
127         {"&ucirc;" , "\303\273"},
128         {"&yacute;", "\303\275"}
129 };
130
131 typedef struct _SC_HTMLAltSymbol        SC_HTMLAltSymbol;
132
133 struct _SC_HTMLAltSymbol
134 {
135         gint key;
136         gchar *const val;
137 };
138
139 /* http://www.w3schools.com/html/html_entitiesref.asp */
140 static SC_HTMLAltSymbol alternate_symbol_list[] = {
141         {  96, "\140"},                    /* backtick */
142         { 153, "\50\124\115\51"},  /* trademark */
143         { 161, "\302\241"},        /* inverted exclamation mark &iexcl */
144         { 162, "\302\242"},        /* cent (currency) &cent */
145         { 163, "\302\243"},        /* pound (currency) &pound */
146         { 164, "\342\202\254"},    /* currency sign &curren */
147         { 165, "\302\245"},        /* yen (currency) &yen */
148         { 169, "\302\251"},        /* copyright sign &copy */
149         { 174, "\302\256"},        /* registered sign &reg */
150         { 191, "\302\277"},        /* inverted question mark &iquest */
151         { 338, "\117\105"},        /* capital ligature OE &OElig */
152         { 339, "\157\145"},        /* small ligature OE &oelig */
153         { 352, NULL},                      /* capital S w/caron &Scaron */
154         { 353, NULL},                      /* small S w/caron &scaron */
155         { 376, NULL},                      /* cap Y w/ diaeres &Yuml */
156         { 710, "\136"},                    /* circumflex accent &circ */
157         { 732, "\176"},                    /* small tilde &tilde */
158         {8194, "\40"},                     /* en space &ensp */
159         {8195, "\40"},                     /* em space &emsp */
160         {8201, "\40"},                     /* thin space &thinsp */
161         {8204, NULL},                      /* zero width non-joiner &zwnj */
162         {8205, NULL},                      /* zero width joiner &zwj */
163         {8206, NULL},                      /* l-t-r mark &lrm */
164         {8207, NULL},                      /* r-t-l mark &rlm */
165         {8211, "\55"},                     /* en dash &ndash */
166         {8212, "\55\55"},                  /* em dash &mdash */
167         {8216, "\47"},                     /* l single quot mark &lsquo */
168         {8217, "\47"},                     /* r single quot mark &rsquo */
169         {8218, "\54"},                     /* single low-9 quot &sbquo */
170         {8220, "\134"},                    /* l double quot mark &ldquo */
171         {8221, "\134"},                    /* r double quot mark &rdquo */
172         {8222, "\42"},                     /* double low-9 quot &bdquo */
173         {8224, NULL},                      /* dagger &dagger */
174         {8225, NULL},                      /* double dagger &Dagger */
175         {8226, "\52"},                     /* bullet &bull */
176         {8230, "\56\56\56"},       /* horizontal ellipsis &hellip */
177         {8240, "\45\157"},                 /* per mile &permil */
178         {8249, "\74"},                     /* l-pointing angle quot &lsaquo */
179         {8250, "\76"},                     /* r-pointing angle quot &rsaquo */
180         {8364, "\105\125\122"},    /* euro &euro */
181         {8482, "\50\124\115\51"}   /* trademark &trade */
182 };
183
184 static GHashTable *default_symbol_table;
185 static GHashTable *alternate_symbol_table;
186
187 static SC_HTMLState sc_html_read_line   (SC_HTMLParser  *parser);
188 static void sc_html_append_char                 (SC_HTMLParser  *parser,
189                                          gchar           ch);
190 static void sc_html_append_str                  (SC_HTMLParser  *parser,
191                                          const gchar    *str,
192                                          gint            len);
193 static SC_HTMLState sc_html_parse_tag   (SC_HTMLParser  *parser);
194 static void sc_html_parse_special               (SC_HTMLParser  *parser);
195 static void sc_html_get_parenthesis             (SC_HTMLParser  *parser,
196                                          gchar          *buf,
197                                          gint            len);
198
199
200 SC_HTMLParser *sc_html_parser_new(FILE *fp, CodeConverter *conv)
201 {
202         SC_HTMLParser *parser;
203
204         g_return_val_if_fail(fp != NULL, NULL);
205         g_return_val_if_fail(conv != NULL, NULL);
206
207         parser = g_new0(SC_HTMLParser, 1);
208         parser->fp = fp;
209         parser->conv = conv;
210         parser->str = g_string_new(NULL);
211         parser->buf = g_string_new(NULL);
212         parser->bufp = parser->buf->str;
213         parser->state = SC_HTML_NORMAL;
214         parser->href = NULL;
215         parser->newline = TRUE;
216         parser->empty_line = TRUE;
217         parser->space = FALSE;
218         parser->pre = FALSE;
219
220 #define SYMBOL_TABLE_ADD(table, list) \
221 { \
222         gint i; \
223  \
224         for (i = 0; i < sizeof(list) / sizeof(list[0]); i++) \
225                 g_hash_table_insert(table, list[i].key, list[i].val); \
226 }
227 #define SYMBOL_TABLE_REF_ADD(table, list) \
228 { \
229         gint i; \
230  \
231         for (i = 0; i < sizeof(list) / sizeof(list[0]); i++) \
232                 g_hash_table_insert(table, &list[i].key, list[i].val); \
233 }
234
235         if (!default_symbol_table) {
236                 default_symbol_table =
237                         g_hash_table_new(g_str_hash, g_str_equal);
238                 SYMBOL_TABLE_ADD(default_symbol_table, symbol_list);
239                 SYMBOL_TABLE_ADD(default_symbol_table, ascii_symbol_list);
240         }
241         if (!alternate_symbol_table) {
242                 alternate_symbol_table =
243                         g_hash_table_new(g_int_hash, g_int_equal);
244                 SYMBOL_TABLE_REF_ADD(alternate_symbol_table, alternate_symbol_list);
245         }
246
247 #undef SYMBOL_TABLE_ADD
248 #undef SYMBOL_TABLE_REF_ADD
249
250         parser->symbol_table = default_symbol_table;
251         parser->alt_symbol_table = alternate_symbol_table;
252
253         return parser;
254 }
255
256 void sc_html_parser_destroy(SC_HTMLParser *parser)
257 {
258         g_string_free(parser->str, TRUE);
259         g_string_free(parser->buf, TRUE);
260         g_free(parser->href);
261         g_free(parser);
262 }
263
264 gchar *sc_html_parse(SC_HTMLParser *parser)
265 {
266         parser->state = SC_HTML_NORMAL;
267         g_string_truncate(parser->str, 0);
268
269         if (*parser->bufp == '\0') {
270                 g_string_truncate(parser->buf, 0);
271                 parser->bufp = parser->buf->str;
272                 if (sc_html_read_line(parser) == SC_HTML_EOF)
273                         return NULL;
274         }
275
276         while (*parser->bufp != '\0') {
277                 switch (*parser->bufp) {
278                 case '<': {
279                         SC_HTMLState st;
280                         st = sc_html_parse_tag(parser);
281                         /* when we see an href, we need to flush the str
282                          * buffer.  Then collect all the chars until we
283                          * see the end anchor tag
284                          */
285                         if (SC_HTML_HREF_BEG == st || SC_HTML_HREF == st)
286                                 return parser->str->str;
287                         } 
288                         break;
289                 case '&':
290                         sc_html_parse_special(parser);
291                         break;
292                 case ' ':
293                 case '\t':
294                 case '\r':
295                 case '\n':
296                         if (parser->bufp[0] == '\r' && parser->bufp[1] == '\n')
297                                 parser->bufp++;
298
299                         if (!parser->pre) {
300                                 if (!parser->newline)
301                                         parser->space = TRUE;
302
303                                 parser->bufp++;
304                                 break;
305                         }
306                         /* fallthrough */
307                 default:
308                         sc_html_append_char(parser, *parser->bufp++);
309                 }
310         }
311
312         return parser->str->str;
313 }
314
315 static SC_HTMLState sc_html_read_line(SC_HTMLParser *parser)
316 {
317         gchar buf[SC_HTMLBUFSIZE];
318         gchar buf2[SC_HTMLBUFSIZE];
319         gint index;
320
321         if (fgets(buf, sizeof(buf), parser->fp) == NULL) {
322                 parser->state = SC_HTML_EOF;
323                 return SC_HTML_EOF;
324         }
325
326         if (conv_convert(parser->conv, buf2, sizeof(buf2), buf) < 0) {
327                 index = parser->bufp - parser->buf->str;
328
329                 conv_utf8todisp(buf2, sizeof(buf2), buf);
330                 g_string_append(parser->buf, buf2);
331
332                 parser->bufp = parser->buf->str + index;
333
334                 return SC_HTML_CONV_FAILED;
335         }
336
337         index = parser->bufp - parser->buf->str;
338
339         g_string_append(parser->buf, buf2);
340
341         parser->bufp = parser->buf->str + index;
342
343         return SC_HTML_NORMAL;
344 }
345
346 static void sc_html_append_char(SC_HTMLParser *parser, gchar ch)
347 {
348         GString *str = parser->str;
349
350         if (!parser->pre && parser->space) {
351                 g_string_append_c(str, ' ');
352                 parser->space = FALSE;
353         }
354
355         g_string_append_c(str, ch);
356
357         parser->empty_line = FALSE;
358         if (ch == '\n') {
359                 parser->newline = TRUE;
360                 if (str->len > 1 && str->str[str->len - 2] == '\n')
361                         parser->empty_line = TRUE;
362         } else
363                 parser->newline = FALSE;
364 }
365
366 static void sc_html_append_str(SC_HTMLParser *parser, const gchar *str, gint len)
367 {
368         GString *string = parser->str;
369
370         if (!parser->pre && parser->space) {
371                 g_string_append_c(string, ' ');
372                 parser->space = FALSE;
373         }
374
375         if (len == 0) return;
376         if (len < 0)
377                 g_string_append(string, str);
378         else {
379                 gchar *s;
380                 Xstrndup_a(s, str, len, return);
381                 g_string_append(string, s);
382         }
383
384         parser->empty_line = FALSE;
385         if (string->len > 0 && string->str[string->len - 1] == '\n') {
386                 parser->newline = TRUE;
387                 if (string->len > 1 && string->str[string->len - 2] == '\n')
388                         parser->empty_line = TRUE;
389         } else
390                 parser->newline = FALSE;
391 }
392
393 static SC_HTMLTag *sc_html_get_tag(const gchar *str)
394 {
395         SC_HTMLTag *tag;
396         gchar *tmp;
397         guchar *tmpp;
398
399         g_return_val_if_fail(str != NULL, NULL);
400
401         if (*str == '\0' || *str == '!') return NULL;
402
403         Xstrdup_a(tmp, str, return NULL);
404
405         tag = g_new0(SC_HTMLTag, 1);
406
407         for (tmpp = tmp; *tmpp != '\0' && !g_ascii_isspace(*tmpp); tmpp++)
408                 ;
409
410         if (*tmpp == '\0') {
411                 g_strdown(tmp);
412                 tag->name = g_strdup(tmp);
413                 return tag;
414         } else {
415                 *tmpp++ = '\0';
416                 g_strdown(tmp);
417                 tag->name = g_strdup(tmp);
418         }
419
420         while (*tmpp != '\0') {
421                 SC_HTMLAttr *attr;
422                 gchar *attr_name;
423                 gchar *attr_value;
424                 gchar *p;
425                 gchar quote;
426
427                 while (g_ascii_isspace(*tmpp)) tmpp++;
428                 attr_name = tmpp;
429
430                 while (*tmpp != '\0' && !g_ascii_isspace(*tmpp) &&
431                        *tmpp != '=')
432                         tmpp++;
433                 if (*tmpp != '\0' && *tmpp != '=') {
434                         *tmpp++ = '\0';
435                         while (g_ascii_isspace(*tmpp)) tmpp++;
436                 }
437
438                 if (*tmpp == '=') {
439                         *tmpp++ = '\0';
440                         while (g_ascii_isspace(*tmpp)) tmpp++;
441
442                         if (*tmpp == '"' || *tmpp == '\'') {
443                                 /* name="value" */
444                                 quote = *tmpp;
445                                 tmpp++;
446                                 attr_value = tmpp;
447                                 if ((p = strchr(attr_value, quote)) == NULL) {
448                                         g_warning("sc_html_get_tag(): syntax error in tag: '%s'\n", str);
449                                         return tag;
450                                 }
451                                 tmpp = p;
452                                 *tmpp++ = '\0';
453                                 while (g_ascii_isspace(*tmpp)) tmpp++;
454                         } else {
455                                 /* name=value */
456                                 attr_value = tmpp;
457                                 while (*tmpp != '\0' && !g_ascii_isspace(*tmpp)) tmpp++;
458                                 if (*tmpp != '\0')
459                                         *tmpp++ = '\0';
460                         }
461                 } else
462                         attr_value = "";
463
464                 g_strchomp(attr_name);
465                 g_strdown(attr_name);
466                 attr = g_new(SC_HTMLAttr, 1);
467                 attr->name = g_strdup(attr_name);
468                 attr->value = g_strdup(attr_value);
469                 tag->attr = g_list_append(tag->attr, attr);
470         }
471
472         return tag;
473 }
474
475 static void sc_html_free_tag(SC_HTMLTag *tag)
476 {
477         if (!tag) return;
478
479         g_free(tag->name);
480         while (tag->attr != NULL) {
481                 SC_HTMLAttr *attr = (SC_HTMLAttr *)tag->attr->data;
482                 g_free(attr->name);
483                 g_free(attr->value);
484                 g_free(attr);
485                 tag->attr = g_list_remove(tag->attr, tag->attr->data);
486         }
487         g_free(tag);
488 }
489
490 static SC_HTMLState sc_html_parse_tag(SC_HTMLParser *parser)
491 {
492         gchar buf[SC_HTMLBUFSIZE];
493         SC_HTMLTag *tag;
494
495         sc_html_get_parenthesis(parser, buf, sizeof(buf));
496
497         tag = sc_html_get_tag(buf);
498
499         parser->state = SC_HTML_UNKNOWN;
500         if (!tag) return SC_HTML_UNKNOWN;
501
502         if (!strcmp(tag->name, "br")) {
503                 parser->space = FALSE;
504                 sc_html_append_char(parser, '\n');
505                 parser->state = SC_HTML_BR;
506         } else if (!strcmp(tag->name, "a")) {
507                 GList *cur;
508                 for (cur = tag->attr; cur != NULL; cur = cur->next) {
509                         if (cur->data && !strcmp(((SC_HTMLAttr *)cur->data)->name, "href")) {
510                                 g_free(parser->href);
511                                 parser->href = g_strdup(((SC_HTMLAttr *)cur->data)->value);
512                                 parser->state = SC_HTML_HREF_BEG;
513                                 break;
514                         }
515                 }
516         } else if (!strcmp(tag->name, "/a")) {
517                 parser->state = SC_HTML_HREF;
518         } else if (!strcmp(tag->name, "p")) {
519                 parser->space = FALSE;
520                 if (!parser->empty_line) {
521                         parser->space = FALSE;
522                         if (!parser->newline) sc_html_append_char(parser, '\n');
523                         sc_html_append_char(parser, '\n');
524                 }
525                 parser->state = SC_HTML_PAR;
526         } else if (!strcmp(tag->name, "pre")) {
527                 parser->pre = TRUE;
528                 parser->state = SC_HTML_PRE;
529         } else if (!strcmp(tag->name, "/pre")) {
530                 parser->pre = FALSE;
531                 parser->state = SC_HTML_NORMAL;
532         } else if (!strcmp(tag->name, "hr")) {
533                 if (!parser->newline) {
534                         parser->space = FALSE;
535                         sc_html_append_char(parser, '\n');
536                 }
537                 sc_html_append_str(parser, HR_STR "\n", -1);
538                 parser->state = SC_HTML_HR;
539         } else if (!strcmp(tag->name, "div")    ||
540                    !strcmp(tag->name, "ul")     ||
541                    !strcmp(tag->name, "li")     ||
542                    !strcmp(tag->name, "table")  ||
543                    !strcmp(tag->name, "tr")     ||
544                    (tag->name[0] == 'h' && g_ascii_isdigit(tag->name[1]))) {
545                 if (!parser->newline) {
546                         parser->space = FALSE;
547                         sc_html_append_char(parser, '\n');
548                 }
549                 parser->state = SC_HTML_NORMAL;
550         } else if (!strcmp(tag->name, "/table") ||
551                    (tag->name[0] == '/' &&
552                     tag->name[1] == 'h' &&
553                     g_ascii_isdigit(tag->name[1]))) {
554                 if (!parser->empty_line) {
555                         parser->space = FALSE;
556                         if (!parser->newline) sc_html_append_char(parser, '\n');
557                         sc_html_append_char(parser, '\n');
558                 }
559                 parser->state = SC_HTML_NORMAL;
560         } else if (!strcmp(tag->name, "/div")   ||
561                    !strcmp(tag->name, "/ul")    ||
562                    !strcmp(tag->name, "/li")) {
563                 if (!parser->newline) {
564                         parser->space = FALSE;
565                         sc_html_append_char(parser, '\n');
566                 }
567                 parser->state = SC_HTML_NORMAL;
568                         }
569
570         sc_html_free_tag(tag);
571
572         return parser->state;
573 }
574
575 static void sc_html_parse_special(SC_HTMLParser *parser)
576 {
577         gchar symbol_name[9];
578         gint n;
579         const gchar *val;
580
581         parser->state = SC_HTML_UNKNOWN;
582         g_return_if_fail(*parser->bufp == '&');
583
584         /* &foo; */
585         for (n = 0; parser->bufp[n] != '\0' && parser->bufp[n] != ';'; n++)
586                 ;
587         if (n > 7 || parser->bufp[n] != ';') {
588                 /* output literal `&' */
589                 sc_html_append_char(parser, *parser->bufp++);
590                 parser->state = SC_HTML_NORMAL;
591                 return;
592         }
593         strncpy2(symbol_name, parser->bufp, n + 2);
594         parser->bufp += n + 1;
595
596         if ((val = g_hash_table_lookup(parser->symbol_table, symbol_name))
597             != NULL) {
598                 sc_html_append_str(parser, val, -1);
599                 parser->state = SC_HTML_NORMAL;
600                 return;
601         } else if (symbol_name[1] == '#' && g_ascii_isdigit(symbol_name[2])) {
602                 gint ch;
603
604                 ch = atoi(symbol_name + 2);
605                 if ((ch > 0 && ch <= 127) ||
606                     (ch >= 128 && ch <= 255 &&
607                      parser->conv->charset == C_ISO_8859_1)) {
608                         sc_html_append_char(parser, ch);
609                         parser->state = SC_HTML_NORMAL;
610                         return;
611                 } else {
612                         const gchar *symb = g_hash_table_lookup(parser->alt_symbol_table, &ch);
613                         if (symb) {
614                                 sc_html_append_str(parser, symb, -1);
615                                 parser->state = SC_HTML_NORMAL;
616                                 return;
617                         }
618                 }
619         }
620
621         sc_html_append_str(parser, symbol_name, -1);
622 }
623
624 static void sc_html_get_parenthesis(SC_HTMLParser *parser, gchar *buf, gint len)
625 {
626         gchar *p;
627
628         buf[0] = '\0';
629         g_return_if_fail(*parser->bufp == '<');
630
631         /* ignore comment / CSS / script stuff */
632         if (!strncmp(parser->bufp, "<!--", 4)) {
633                 parser->bufp += 4;
634                 while ((p = strstr(parser->bufp, "-->")) == NULL)
635                         if (sc_html_read_line(parser) == SC_HTML_EOF) return;
636                 parser->bufp = p + 3;
637                 return;
638         }
639         if (!g_ascii_strncasecmp(parser->bufp, "<style", 6)) {
640                 parser->bufp += 6;
641                 while ((p = strcasestr(parser->bufp, "</style>")) == NULL)
642                         if (sc_html_read_line(parser) == SC_HTML_EOF) return;
643                 parser->bufp = p + 8;
644                 return;
645         }
646         if (!g_ascii_strncasecmp(parser->bufp, "<script", 7)) {
647                 parser->bufp += 7;
648                 while ((p = strcasestr(parser->bufp, "</script>")) == NULL)
649                         if (sc_html_read_line(parser) == SC_HTML_EOF) return;
650                 parser->bufp = p + 9;
651                 return;
652         }
653
654         parser->bufp++;
655         while ((p = strchr(parser->bufp, '>')) == NULL)
656                 if (sc_html_read_line(parser) == SC_HTML_EOF) return;
657
658         strncpy2(buf, parser->bufp, MIN(p - parser->bufp + 1, len));
659         g_strstrip(buf);
660         parser->bufp = p + 1;
661 }