summaryrefslogtreecommitdiff
path: root/pith/filter.c
diff options
context:
space:
mode:
authorEduardo Chappa <echappa@gmx.com>2013-02-03 00:59:38 -0700
committerEduardo Chappa <echappa@gmx.com>2013-02-03 00:59:38 -0700
commit094ca96844842928810f14844413109fc6cdd890 (patch)
treee60efbb980f38ba9308ccb4fb2b77b87bbc115f3 /pith/filter.c
downloadalpine-094ca96844842928810f14844413109fc6cdd890.tar.xz
Initial Alpine Version
Diffstat (limited to 'pith/filter.c')
-rw-r--r--pith/filter.c11305
1 files changed, 11305 insertions, 0 deletions
diff --git a/pith/filter.c b/pith/filter.c
new file mode 100644
index 00000000..b8712b23
--- /dev/null
+++ b/pith/filter.c
@@ -0,0 +1,11305 @@
+#if !defined(lint) && !defined(DOS)
+static char rcsid[] = "$Id: filter.c 1266 2009-07-14 18:39:12Z hubert@u.washington.edu $";
+#endif
+
+/*
+ * ========================================================================
+ * Copyright 2006-2008 University of Washington
+ * Copyright 2013 Eduardo Chappa
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * ========================================================================
+ */
+
+/*======================================================================
+ filter.c
+
+ This code provides a generalized, flexible way to allow
+ piping of data thru filters. Each filter is passed a structure
+ that it will use to hold its static data while it operates on
+ the stream of characters that are passed to it. After processing
+ it will either return or call the next filter in
+ the pipe with any character (or characters) it has ready to go. This
+ means some terminal type of filter has to be the last in the
+ chain (i.e., one that writes the passed char someplace, but doesn't
+ call another filter).
+
+ See below for more details.
+
+ The motivation is to handle MIME decoding, richtext conversion,
+ iso_code stripping and anything else that may come down the
+ pike (e.g., PEM) in an elegant fashion. mikes (920811)
+
+ TODO:
+ reasonable error handling
+
+ ====*/
+
+
+#include "../pith/headers.h"
+#include "../pith/filter.h"
+#include "../pith/conf.h"
+#include "../pith/store.h"
+#include "../pith/color.h"
+#include "../pith/escapes.h"
+#include "../pith/pipe.h"
+#include "../pith/status.h"
+#include "../pith/string.h"
+#include "../pith/util.h"
+#include "../pith/url.h"
+#include "../pith/init.h"
+#include "../pith/help.h"
+#include "../pico/keydefs.h"
+
+#ifdef _WINDOWS
+#include "../pico/osdep/mswin.h"
+#endif
+
+
+/*
+ * Internal prototypes
+ */
+int gf_so_writec(int);
+int gf_so_readc(unsigned char *);
+int gf_freadc(unsigned char *);
+int gf_freadc_locale(unsigned char *);
+int gf_freadc_getchar(unsigned char *, void *);
+int gf_fwritec(int);
+int gf_fwritec_locale(int);
+#ifdef _WINDOWS
+int gf_freadc_windows(unsigned char *);
+#endif /* _WINDOWS */
+int gf_preadc(unsigned char *);
+int gf_preadc_locale(unsigned char *);
+int gf_preadc_getchar(unsigned char *, void *);
+int gf_pwritec(int);
+int gf_pwritec_locale(int);
+int gf_sreadc(unsigned char *);
+int gf_sreadc_locale(unsigned char *);
+int gf_sreadc_getchar(unsigned char *, void *);
+int gf_swritec(int);
+int gf_swritec_locale(int);
+void gf_terminal(FILTER_S *, int);
+void gf_error(char *);
+char *gf_filter_puts(char *);
+void gf_filter_eod(void);
+
+void gf_8bit_put(FILTER_S *, int);
+
+
+
+/*
+ * System specific options
+ */
+#ifdef _WINDOWS
+#define CRLF_NEWLINES
+#endif
+
+
+/*
+ * Hooks for callers to adjust behavior
+ */
+char *(*pith_opt_pretty_var_name)(char *);
+char *(*pith_opt_pretty_feature_name)(char *, int);
+
+
+/*
+ * pointer to first function in a pipe, and pointer to last filter
+ */
+FILTER_S *gf_master = NULL;
+static gf_io_t last_filter;
+static char *gf_error_string;
+static long gf_byte_count;
+static jmp_buf gf_error_state;
+
+
+#define GF_NOOP 0x01 /* flags used by generalized */
+#define GF_EOD 0x02 /* filters */
+#define GF_DATA 0x04 /* See filter.c for more */
+#define GF_ERROR 0x08 /* details */
+#define GF_RESET 0x10
+
+
+/*
+ * A list of states used by the various filters. Reused in many filters.
+ */
+#define DFL 0
+#define EQUAL 1
+#define HEX 2
+#define WSPACE 3
+#define CCR 4
+#define CLF 5
+#define TOKEN 6
+#define TAG 7
+#define HANDLE 8
+#define HDATA 9
+#define ESC 10
+#define ESCDOL 11
+#define ESCPAR 12
+#define EUC 13
+#define BOL 14
+#define FL_QLEV 15
+#define FL_STF 16
+#define FL_SIG 17
+#define STOP_DECODING 18
+#define SPACECR 19
+
+
+
+/*
+ * Macros to reduce function call overhead associated with calling
+ * each filter for each byte filtered, and to minimize filter structure
+ * dereferences. NOTE: "queuein" has to do with putting chars into the
+ * filter structs data queue. So, writing at the queuein offset is
+ * what a filter does to pass processed data out of itself. Ditto for
+ * queueout. This explains the FI --> queueout init stuff below.
+ */
+#define GF_QUE_START(F) (&(F)->queue[0])
+#define GF_QUE_END(F) (&(F)->queue[GF_MAXBUF - 1])
+
+#define GF_IP_INIT(F) ip = (F) ? &(F)->queue[(F)->queuein] : NULL
+#define GF_IP_INIT_GLO(F) (*ipp) = (F) ? &(F)->queue[(F)->queuein] : NULL
+#define GF_EIB_INIT(F) eib = (F) ? GF_QUE_END(F) : NULL
+#define GF_EIB_INIT_GLO(F) (*eibp) = (F) ? GF_QUE_END(F) : NULL
+#define GF_OP_INIT(F) op = (F) ? &(F)->queue[(F)->queueout] : NULL
+#define GF_EOB_INIT(F) eob = (F) ? &(F)->queue[(F)->queuein] : NULL
+
+#define GF_IP_END(F) (F)->queuein = ip - GF_QUE_START(F)
+#define GF_IP_END_GLO(F) (F)->queuein = (unsigned char *)(*ipp) - (unsigned char *)GF_QUE_START(F)
+#define GF_OP_END(F) (F)->queueout = op - GF_QUE_START(F)
+
+#define GF_INIT(FI, FO) unsigned char *GF_OP_INIT(FI); \
+ unsigned char *GF_EOB_INIT(FI); \
+ unsigned char *GF_IP_INIT(FO); \
+ unsigned char *GF_EIB_INIT(FO);
+
+#define GF_CH_RESET(F) (op = eob = GF_QUE_START(F), \
+ (F)->queueout = (F)->queuein = 0)
+
+#define GF_END(FI, FO) (GF_OP_END(FI), GF_IP_END(FO))
+
+#define GF_FLUSH(F) ((GF_IP_END(F), (*(F)->f)((F), GF_DATA), \
+ GF_IP_INIT(F), GF_EIB_INIT(F)) ? 1 : 0)
+#define GF_FLUSH_GLO(F) ((GF_IP_END_GLO(F), (*(F)->f)((F), GF_DATA), \
+ GF_IP_INIT_GLO(F), GF_EIB_INIT_GLO(F)) ? 1 : 0)
+
+#define GF_PUTC(F, C) ((int)(*ip++ = (C), (ip >= eib) ? GF_FLUSH(F) : 1))
+#define GF_PUTC_GLO(F, C) ((int)(*(*ipp)++ = (C), ((*ipp) >= (*eibp)) ? GF_FLUSH_GLO(F) : 1))
+
+/*
+ * Introducing the *_GLO macros for use in splitting the big macros out
+ * into functions (wrap_flush, wrap_eol). The reason we need a
+ * separate macro is because of the vars ip, eib, op, and eob, which are
+ * set up locally in a call to GF_INIT. To preserve these variables
+ * in the new functions, we now pass pointers to these four vars. Each
+ * of these new functions expects the presence of pointer vars
+ * ipp, eibp, opp, and eobp.
+ */
+
+#define GF_GETC(F, C) ((op < eob) ? (((C) = *op++), 1) : GF_CH_RESET(F))
+
+#define GF_COLOR_PUTC(F, C) { \
+ char *p; \
+ char cb[RGBLEN+1]; \
+ GF_PUTC_GLO((F)->next, TAG_EMBED); \
+ GF_PUTC_GLO((F)->next, TAG_FGCOLOR); \
+ strncpy(cb, color_to_asciirgb((C)->fg), sizeof(cb)); \
+ cb[sizeof(cb)-1] = '\0'; \
+ p = cb; \
+ for(; *p; p++) \
+ GF_PUTC_GLO((F)->next, *p); \
+ GF_PUTC_GLO((F)->next, TAG_EMBED); \
+ GF_PUTC_GLO((F)->next, TAG_BGCOLOR); \
+ strncpy(cb, color_to_asciirgb((C)->bg), sizeof(cb)); \
+ cb[sizeof(cb)-1] = '\0'; \
+ p = cb; \
+ for(; *p; p++) \
+ GF_PUTC_GLO((F)->next, *p); \
+ }
+
+/*
+ * Generalized getc and putc routines. provided here so they don't
+ * need to be re-done elsewhere to
+ */
+
+/*
+ * pointers to objects to be used by the generic getc and putc
+ * functions
+ */
+static struct gf_io_struct {
+ FILE *file;
+ PIPE_S *pipe;
+ char *txtp;
+ unsigned long n;
+ int flags;
+ CBUF_S cb;
+} gf_in, gf_out;
+
+#define GF_SO_STACK struct gf_so_stack
+static GF_SO_STACK {
+ STORE_S *so;
+ GF_SO_STACK *next;
+} *gf_so_in, *gf_so_out;
+
+
+
+/*
+ * Returns 1 if pc will write into a PicoText object, 0 otherwise.
+ *
+ * The purpose of this routine is so that we can avoid setting SIGALARM
+ * when writing into a PicoText object, because that type of object uses
+ * unprotected malloc/free/realloc, which can't be interrupted.
+ */
+int
+pc_is_picotext(gf_io_t pc)
+{
+ return(pc == gf_so_writec && gf_so_out && gf_so_out->so &&
+ gf_so_out->so->src == ExternalText);
+}
+
+
+
+/*
+ * setup to use and return a pointer to the generic
+ * getc function
+ */
+void
+gf_set_readc(gf_io_t *gc, void *txt, long unsigned int len, SourceType src, int flags)
+{
+ gf_in.n = len;
+ gf_in.flags = flags;
+ gf_in.cb.cbuf[0] = '\0';
+ gf_in.cb.cbufp = gf_in.cb.cbuf;
+ gf_in.cb.cbufend = gf_in.cb.cbuf;
+
+ if(src == FileStar){
+ gf_in.file = (FILE *)txt;
+ fseek(gf_in.file, 0L, 0);
+#ifdef _WINDOWS
+ *gc = (flags & READ_FROM_LOCALE) ? gf_freadc_windows
+ : gf_freadc;
+#else /* UNIX */
+ *gc = (flags & READ_FROM_LOCALE) ? gf_freadc_locale
+ : gf_freadc;
+#endif /* UNIX */
+ }
+ else if(src == PipeStar){
+ gf_in.pipe = (PIPE_S *)txt;
+ *gc = gf_preadc;
+ *gc = (flags & READ_FROM_LOCALE) ? gf_preadc_locale
+ : gf_preadc;
+ }
+ else{
+ gf_in.txtp = (char *)txt;
+ *gc = (flags & READ_FROM_LOCALE) ? gf_sreadc_locale
+ : gf_sreadc;
+ }
+}
+
+
+/*
+ * setup to use and return a pointer to the generic
+ * putc function
+ */
+void
+gf_set_writec(gf_io_t *pc, void *txt, long unsigned int len, SourceType src, int flags)
+{
+ gf_out.n = len;
+ gf_out.flags = flags;
+ gf_out.cb.cbuf[0] = '\0';
+ gf_out.cb.cbufp = gf_out.cb.cbuf;
+ gf_out.cb.cbufend = gf_out.cb.cbuf;
+
+ if(src == FileStar){
+ gf_out.file = (FILE *)txt;
+#ifdef _WINDOWS
+ *pc = gf_fwritec;
+#else /* UNIX */
+ *pc = (flags & WRITE_TO_LOCALE) ? gf_fwritec_locale
+ : gf_fwritec;
+#endif /* UNIX */
+ }
+ else if(src == PipeStar){
+ gf_out.pipe = (PIPE_S *)txt;
+ *pc = (flags & WRITE_TO_LOCALE) ? gf_pwritec_locale
+ : gf_pwritec;
+ }
+ else{
+ gf_out.txtp = (char *)txt;
+ *pc = (flags & WRITE_TO_LOCALE) ? gf_swritec_locale
+ : gf_swritec;
+ }
+}
+
+
+/*
+ * setup to use and return a pointer to the generic
+ * getc function
+ */
+void
+gf_set_so_readc(gf_io_t *gc, STORE_S *so)
+{
+ GF_SO_STACK *sp = (GF_SO_STACK *) fs_get(sizeof(GF_SO_STACK));
+
+ sp->so = so;
+ sp->next = gf_so_in;
+ gf_so_in = sp;
+ *gc = gf_so_readc;
+}
+
+
+void
+gf_clear_so_readc(STORE_S *so)
+{
+ GF_SO_STACK *sp;
+
+ if((sp = gf_so_in) != NULL){
+ if(so == sp->so){
+ gf_so_in = gf_so_in->next;
+ fs_give((void **) &sp);
+ }
+ else
+ panic("Programmer botch: Can't unstack store readc");
+ }
+ else
+ panic("Programmer botch: NULL store clearing store readc");
+}
+
+
+/*
+ * setup to use and return a pointer to the generic
+ * putc function
+ */
+void
+gf_set_so_writec(gf_io_t *pc, STORE_S *so)
+{
+ GF_SO_STACK *sp = (GF_SO_STACK *) fs_get(sizeof(GF_SO_STACK));
+
+ sp->so = so;
+ sp->next = gf_so_out;
+ gf_so_out = sp;
+ *pc = gf_so_writec;
+}
+
+
+void
+gf_clear_so_writec(STORE_S *so)
+{
+ GF_SO_STACK *sp;
+
+ if((sp = gf_so_out) != NULL){
+ if(so == sp->so){
+ gf_so_out = gf_so_out->next;
+ fs_give((void **) &sp);
+ }
+ else
+ panic("Programmer botch: Can't unstack store writec");
+ }
+ else
+ panic("Programmer botch: NULL store clearing store writec");
+}
+
+
+/*
+ * put the character to the object previously defined
+ */
+int
+gf_so_writec(int c)
+{
+ return(so_writec(c, gf_so_out->so));
+}
+
+
+/*
+ * get a character from an object previously defined
+ */
+int
+gf_so_readc(unsigned char *c)
+{
+ return(so_readc(c, gf_so_in->so));
+}
+
+
+/* get a character from a file */
+/* assumes gf_out struct is filled in */
+int
+gf_freadc(unsigned char *c)
+{
+ int rv = 0;
+
+ do {
+ errno = 0;
+ clearerr(gf_in.file);
+ rv = fread(c, sizeof(unsigned char), (size_t)1, gf_in.file);
+ } while(!rv && ferror(gf_in.file) && errno == EINTR);
+
+ return(rv);
+}
+
+
+int
+gf_freadc_locale(unsigned char *c)
+{
+ return(generic_readc_locale(c, gf_freadc_getchar, (void *) gf_in.file, &gf_in.cb));
+}
+
+
+/*
+ * This is just to make it work with generic_readc_locale.
+ */
+int
+gf_freadc_getchar(unsigned char *c, void *extraarg)
+{
+ FILE *file;
+ int rv = 0;
+
+ file = (FILE *) extraarg;
+
+ do {
+ errno = 0;
+ clearerr(file);
+ rv = fread(c, sizeof(unsigned char), (size_t)1, file);
+ } while(!rv && ferror(file) && errno == EINTR);
+
+ return(rv);
+}
+
+
+/*
+ * Put a character to a file.
+ * Assumes gf_out struct is filled in.
+ * Returns 1 on success, <= 0 on failure.
+ */
+int
+gf_fwritec(int c)
+{
+ unsigned char ch = (unsigned char)c;
+ int rv = 0;
+
+ do
+ rv = fwrite(&ch, sizeof(unsigned char), (size_t)1, gf_out.file);
+ while(!rv && ferror(gf_out.file) && errno == EINTR);
+
+ return(rv);
+}
+
+
+/*
+ * The locale version converts from UTF-8 to user's locale charset
+ * before writing the characters.
+ */
+int
+gf_fwritec_locale(int c)
+{
+ int rv = 1;
+ int i, outchars;
+ unsigned char obuf[MAX(MB_LEN_MAX,32)];
+
+ if((outchars = utf8_to_locale(c, &gf_out.cb, obuf, sizeof(obuf))) != 0){
+ for(i = 0; i < outchars; i++)
+ if(gf_fwritec(obuf[i]) != 1){
+ rv = 0;
+ break;
+ }
+ }
+
+ return(rv);
+}
+
+
+#ifdef _WINDOWS
+/*
+ * Read unicode characters from windows filesystem and return
+ * them as a stream of UTF-8 characters. The stream is assumed
+ * opened so that it will know how to put together the unicode.
+ *
+ * (This is totally untested, copied loosely from so_file_readc_windows
+ * which may or may not be appropriate.)
+ */
+int
+gf_freadc_windows(unsigned char *c)
+{
+ int rv = 0;
+ UCS ucs;
+
+ /* already got some from previous call? */
+ if(gf_in.cb.cbufend > gf_in.cb.cbuf){
+ *c = *gf_in.cb.cbufp;
+ gf_in.cb.cbufp++;
+ rv++;
+ if(gf_in.cb.cbufp >= gf_in.cb.cbufend){
+ gf_in.cb.cbufend = gf_in.cb.cbuf;
+ gf_in.cb.cbufp = gf_in.cb.cbuf;
+ }
+
+ return(rv);
+ }
+
+ if(gf_in.file){
+ /* windows only so second arg is ignored */
+ ucs = read_a_wide_char(gf_in.file, NULL);
+ rv = (ucs == CCONV_EOF) ? 0 : 1;
+ }
+
+ if(rv){
+ /*
+ * Now we need to convert the UCS character to UTF-8
+ * and dole out the UTF-8 one char at a time.
+ */
+ gf_in.cb.cbufend = utf8_put(gf_in.cb.cbuf, (unsigned long) ucs);
+ gf_in.cb.cbufp = gf_in.cb.cbuf;
+ if(gf_in.cb.cbufend > gf_in.cb.cbuf){
+ *c = *gf_in.cb.cbufp;
+ gf_in.cb.cbufp++;
+ if(gf_in.cb.cbufp >= gf_in.cb.cbufend){
+ gf_in.cb.cbufend = gf_in.cb.cbuf;
+ gf_in.cb.cbufp = gf_in.cb.cbuf;
+ }
+ }
+ else
+ *c = '?';
+ }
+
+ return(rv);
+}
+#endif /* _WINDOWS */
+
+
+int
+gf_preadc(unsigned char *c)
+{
+ return(pipe_readc(c, gf_in.pipe));
+}
+
+
+int
+gf_preadc_locale(unsigned char *c)
+{
+ return(generic_readc_locale(c, gf_preadc_getchar, (void *) gf_in.pipe, &gf_in.cb));
+}
+
+
+/*
+ * This is just to make it work with generic_readc_locale.
+ */
+int
+gf_preadc_getchar(unsigned char *c, void *extraarg)
+{
+ PIPE_S *pipe;
+
+ pipe = (PIPE_S *) extraarg;
+
+ return(pipe_readc(c, pipe));
+}
+
+
+/*
+ * Put a character to a pipe.
+ * Assumes gf_out struct is filled in.
+ * Returns 1 on success, <= 0 on failure.
+ */
+int
+gf_pwritec(int c)
+{
+ return(pipe_writec(c, gf_out.pipe));
+}
+
+
+/*
+ * The locale version converts from UTF-8 to user's locale charset
+ * before writing the characters.
+ */
+int
+gf_pwritec_locale(int c)
+{
+ int rv = 1;
+ int i, outchars;
+ unsigned char obuf[MAX(MB_LEN_MAX,32)];
+
+ if((outchars = utf8_to_locale(c, &gf_out.cb, obuf, sizeof(obuf))) != 0){
+ for(i = 0; i < outchars; i++)
+ if(gf_pwritec(obuf[i]) != 1){
+ rv = 0;
+ break;
+ }
+ }
+
+ return(rv);
+}
+
+
+/* get a character from a string, return nonzero if things OK */
+/* assumes gf_out struct is filled in */
+int
+gf_sreadc(unsigned char *c)
+{
+ return((gf_in.n) ? *c = *(gf_in.txtp)++, gf_in.n-- : 0);
+}
+
+
+int
+gf_sreadc_locale(unsigned char *c)
+{
+ return(generic_readc_locale(c, gf_sreadc_getchar, NULL, &gf_in.cb));
+}
+
+
+int
+gf_sreadc_getchar(unsigned char *c, void *extraarg)
+{
+ /*
+ * extraarg is ignored and gf_sreadc just uses globals instead.
+ * That's ok as long as we don't call it more than once at a time.
+ */
+ return(gf_sreadc(c));
+}
+
+
+/*
+ * Put a character to a string.
+ * Assumes gf_out struct is filled in.
+ * Returns 1 on success, <= 0 on failure.
+ */
+int
+gf_swritec(int c)
+{
+ return((gf_out.n) ? *(gf_out.txtp)++ = c, gf_out.n-- : 0);
+}
+
+
+/*
+ * The locale version converts from UTF-8 to user's locale charset
+ * before writing the characters.
+ */
+int
+gf_swritec_locale(int c)
+{
+ int rv = 1;
+ int i, outchars;
+ unsigned char obuf[MAX(MB_LEN_MAX,32)];
+
+ if((outchars = utf8_to_locale(c, &gf_out.cb, obuf, sizeof(obuf))) != 0){
+ for(i = 0; i < outchars; i++)
+ if(gf_swritec(obuf[i]) != 1){
+ rv = 0;
+ break;
+ }
+ }
+
+ return(rv);
+}
+
+
+/*
+ * output the given string with the given function
+ */
+int
+gf_puts(register char *s, gf_io_t pc)
+{
+ while(*s != '\0')
+ if(!(*pc)((unsigned char)*s++))
+ return(0); /* ERROR putting char ! */
+
+ return(1);
+}
+
+
+/*
+ * output the given string with the given function
+ */
+int
+gf_nputs(register char *s, long int n, gf_io_t pc)
+{
+ while(n--)
+ if(!(*pc)((unsigned char)*s++))
+ return(0); /* ERROR putting char ! */
+
+ return(1);
+}
+
+
+/*
+ * Read a stream of multi-byte characters from the
+ * user's locale charset and return a stream of
+ * UTF-8 characters, one at a time. The input characters
+ * are obtained by using the get_a_char function.
+ *
+ * Args c -- the returned octet
+ * get_a_char -- function to get a single octet of the multibyte
+ * character. The first arg of that function is the
+ * returned value and the second arg is for the
+ * functions use. The second arg is replaced with
+ * extraarg when it is called.
+ * extraarg -- The second arg to get_a_char.
+ * cb -- Storage area for state between calls to this func.
+ */
+int
+generic_readc_locale(unsigned char *c,
+ int (*get_a_char)(unsigned char *, void *),
+ void *extraarg,
+ CBUF_S *cb)
+{
+ unsigned long octets_so_far = 0, remaining_octets;
+ unsigned char *inputp;
+ unsigned char ch;
+ UCS ucs;
+ unsigned char inputbuf[20];
+ int rv = 0;
+ int got_one = 0;
+
+ /* already got some from previous call? */
+ if(cb->cbufend > cb->cbuf){
+ *c = *cb->cbufp;
+ cb->cbufp++;
+ rv++;
+ if(cb->cbufp >= cb->cbufend){
+ cb->cbufend = cb->cbuf;
+ cb->cbufp = cb->cbuf;
+ }
+
+ return(rv);
+ }
+
+ memset(inputbuf, 0, sizeof(inputbuf));
+ if((*get_a_char)(&ch, extraarg) == 0)
+ return(0);
+
+ inputbuf[octets_so_far++] = ch;
+
+ while(!got_one){
+ remaining_octets = octets_so_far;
+ inputp = inputbuf;
+ ucs = mbtow(ps_global->input_cs, &inputp, &remaining_octets);
+ switch(ucs){
+ case CCONV_BADCHAR:
+ return(rv);
+
+ case CCONV_NEEDMORE:
+/*
+ * Do we need to do something with the characters we've
+ * collected that don't form a valid UCS character?
+ * Probably need to try discarding them one at a time
+ * from the front instead of just throwing them all out.
+ */
+ if(octets_so_far >= sizeof(inputbuf))
+ return(rv);
+
+ if((*get_a_char)(&ch, extraarg) == 0)
+ return(rv);
+
+ inputbuf[octets_so_far++] = ch;
+ break;
+
+ default:
+ /* got a good UCS-4 character */
+ got_one++;
+ break;
+ }
+ }
+
+ /*
+ * Now we need to convert the UCS character to UTF-8
+ * and dole out the UTF-8 one char at a time.
+ */
+ rv++;
+ cb->cbufend = utf8_put(cb->cbuf, (unsigned long) ucs);
+ cb->cbufp = cb->cbuf;
+ if(cb->cbufend > cb->cbuf){
+ *c = *cb->cbufp;
+ cb->cbufp++;
+ if(cb->cbufp >= cb->cbufend){
+ cb->cbufend = cb->cbuf;
+ cb->cbufp = cb->cbuf;
+ }
+ }
+ else
+ *c = '?';
+
+ return(rv);
+}
+
+
+/*
+ * Start of generalized filter routines
+ */
+
+/*
+ * initializing function to make sure list of filters is empty.
+ */
+void
+gf_filter_init(void)
+{
+ FILTER_S *flt, *fltn = gf_master;
+
+ while((flt = fltn) != NULL){ /* free list of old filters */
+ fltn = flt->next;
+ fs_give((void **)&flt);
+ }
+
+ gf_master = NULL;
+ gf_error_string = NULL; /* clear previous errors */
+ gf_byte_count = 0L; /* reset counter */
+}
+
+
+
+/*
+ * link the given filter into the filter chain
+ */
+void
+gf_link_filter(filter_t f, void *data)
+{
+ FILTER_S *new, *tail;
+
+#ifdef CRLF_NEWLINES
+ /*
+ * If the system's native EOL convention is CRLF, then there's no
+ * point in passing data thru a filter that's not doing anything
+ */
+ if(f == gf_nvtnl_local || f == gf_local_nvtnl)
+ return;
+#endif
+
+ new = (FILTER_S *)fs_get(sizeof(FILTER_S));
+ memset(new, 0, sizeof(FILTER_S));
+
+ new->f = f; /* set the function pointer */
+ new->opt = data; /* set any optional parameter data */
+ (*f)(new, GF_RESET); /* have it setup initial state */
+
+ if((tail = gf_master) != NULL){ /* or add it to end of existing */
+ while(tail->next) /* list */
+ tail = tail->next;
+
+ tail->next = new;
+ }
+ else /* attach new struct to list */
+ gf_master = new; /* start a new list */
+}
+
+
+/*
+ * terminal filter, doesn't call any other filters, typically just does
+ * something with the output
+ */
+void
+gf_terminal(FILTER_S *f, int flg)
+{
+ if(flg == GF_DATA){
+ GF_INIT(f, f);
+
+ while(op < eob)
+ if((*last_filter)(*op++) <= 0) /* generic terminal filter */
+ gf_error(errno ? error_description(errno) : "Error writing pipe");
+
+ GF_CH_RESET(f);
+ }
+ else if(flg == GF_RESET)
+ errno = 0; /* prepare for problems */
+}
+
+
+/*
+ * set some outside gf_io_t function to the terminal function
+ * for example: a function to write a char to a file or into a buffer
+ */
+void
+gf_set_terminal(gf_io_t f) /* function to set generic filter */
+
+{
+ last_filter = f;
+}
+
+
+/*
+ * common function for filter's to make it known that an error
+ * has occurred. Jumps back to gf_pipe with error message.
+ */
+void
+gf_error(char *s)
+{
+ /* let the user know the error passed in s */
+ gf_error_string = s;
+ longjmp(gf_error_state, 1);
+}
+
+
+/*
+ * The routine that shoves each byte through the chain of
+ * filters. It sets up error handling, and the terminal function.
+ * Then loops getting bytes with the given function, and passing
+ * it on to the first filter in the chain.
+ */
+char *
+gf_pipe(gf_io_t gc, gf_io_t pc)
+ /* how to get a character */
+{
+ unsigned char c;
+
+ dprint((4, "-- gf_pipe: "));
+
+ /*
+ * set up for any errors a filter may encounter
+ */
+ if(setjmp(gf_error_state)){
+ dprint((4, "ERROR: %s\n",
+ gf_error_string ? gf_error_string : "NULL"));
+ return(gf_error_string); /* */
+ }
+
+ /*
+ * set and link in the terminal filter
+ */
+ gf_set_terminal(pc);
+ gf_link_filter(gf_terminal, NULL);
+
+ /*
+ * while there are chars to process, send them thru the pipe.
+ * NOTE: it's necessary to enclose the loop below in a block
+ * as the GF_INIT macro calls some automatic var's into
+ * existence. It can't be placed at the start of gf_pipe
+ * because its useful for us to be called without filters loaded
+ * when we're just being used to copy bytes between storage
+ * objects.
+ */
+ {
+ GF_INIT(gf_master, gf_master);
+
+ while((*gc)(&c)){
+ gf_byte_count++;
+
+#ifdef _WINDOWS
+ if(!(gf_byte_count & 0x3ff))
+ /* Under windows we yield to allow event processing.
+ * Progress display is handled throught the alarm()
+ * mechinism.
+ */
+ mswin_yield ();
+#endif
+
+ GF_PUTC(gf_master, c & 0xff);
+ }
+
+ /*
+ * toss an end-of-data marker down the pipe to give filters
+ * that have any buffered data the opportunity to dump it
+ */
+ (void) GF_FLUSH(gf_master);
+ (*gf_master->f)(gf_master, GF_EOD);
+ }
+
+ dprint((4, "done.\n"));
+ return(NULL); /* everything went OK */
+}
+
+
+/*
+ * return the number of bytes piped so far
+ */
+long
+gf_bytes_piped(void)
+{
+ return(gf_byte_count);
+}
+
+
+/*
+ * filter the given input with the given command
+ *
+ * Args: cmd -- command string to execute
+ * prepend -- string to prepend to filtered input
+ * source_so -- storage object containing data to be filtered
+ * pc -- function to write filtered output with
+ * aux_filters -- additional filters to pass data thru after "cmd"
+ *
+ * Returns: NULL on sucess, reason for failure (not alloc'd!) on error
+ */
+char *
+gf_filter(char *cmd, char *prepend, STORE_S *source_so, gf_io_t pc,
+ FILTLIST_S *aux_filters, int disable_reset,
+ void (*pipecb_f)(PIPE_S *, int, void *))
+{
+ unsigned char c, obuf[MAX(MB_LEN_MAX,32)];
+ int flags, outchars, i;
+ char *errstr = NULL, buf[MAILTMPLEN];
+ PIPE_S *fpipe;
+ CBUF_S cb;
+#ifdef NON_BLOCKING_IO
+ int n;
+#endif
+
+ dprint((4, "so_filter: \"%s\"\n", cmd ? cmd : "?"));
+
+ gf_filter_init();
+
+ /*
+ * After coming back from user's pipe command we need to convert
+ * the output from the pipe back to UTF-8.
+ */
+ if(ps_global->keyboard_charmap && strucmp("UTF-8", ps_global->keyboard_charmap))
+ gf_link_filter(gf_utf8, gf_utf8_opt(ps_global->keyboard_charmap));
+
+ for( ; aux_filters && aux_filters->filter; aux_filters++)
+ gf_link_filter(aux_filters->filter, aux_filters->data);
+
+ gf_set_terminal(pc);
+ gf_link_filter(gf_terminal, NULL);
+
+ cb.cbuf[0] = '\0';
+ cb.cbufp = cb.cbuf;
+ cb.cbufend = cb.cbuf;
+
+ /*
+ * Spawn filter feeding it data, and reading what it writes.
+ */
+ so_seek(source_so, 0L, 0);
+ flags = PIPE_WRITE | PIPE_READ | PIPE_NOSHELL |
+ (!disable_reset ? PIPE_RESET : 0);
+
+ if((fpipe = open_system_pipe(cmd, NULL, NULL, flags, 0, pipecb_f, pipe_report_error)) != NULL){
+
+#ifdef NON_BLOCKING_IO
+
+ if(fcntl(fileno(fpipe->in.f), F_SETFL, NON_BLOCKING_IO) == -1)
+ errstr = "Can't set up non-blocking IO";
+
+ if(prepend && (fputs(prepend, fpipe->out.f) == EOF
+ || fputc('\n', fpipe->out.f) == EOF))
+ errstr = error_description(errno);
+
+ while(!errstr){
+ /* if the pipe can't hold a K we're sunk (too bad PIPE_MAX
+ * isn't ubiquitous ;).
+ */
+ for(n = 0; !errstr && fpipe->out.f && n < 1024; n++)
+ if(!so_readc(&c, source_so)){
+ fclose(fpipe->out.f);
+ fpipe->out.f = NULL;
+ }
+ else{
+ /*
+ * Got a UTF-8 character from source_so.
+ * We need to convert it to the user's locale charset
+ * and then send the result to the pipe.
+ */
+ if((outchars = utf8_to_locale((int) c, &cb, obuf, sizeof(obuf))) != 0)
+ for(i = 0; i < outchars && !errstr; i++)
+ if(fputc(obuf[i], fpipe->out.f) == EOF)
+ errstr = error_description(errno);
+ }
+
+ /*
+ * Note: We clear errno here and test below, before ferror,
+ * because *some* stdio implementations consider
+ * EAGAIN and EWOULDBLOCK equivalent to EOF...
+ */
+ errno = 0;
+ clearerr(fpipe->in.f); /* fix from <cananian@cananian.mit.edu> */
+
+ while(!errstr && fgets(buf, sizeof(buf), fpipe->in.f))
+ errstr = gf_filter_puts(buf);
+
+ /* then fgets failed! */
+ if(!errstr && !(errno == EAGAIN || errno == EWOULDBLOCK)){
+ if(feof(fpipe->in.f)) /* nothing else interesting! */
+ break;
+ else if(ferror(fpipe->in.f)) /* bummer. */
+ errstr = error_description(errno);
+ }
+ else if(errno == EAGAIN || errno == EWOULDBLOCK)
+ clearerr(fpipe->in.f);
+ }
+
+#else /* !NON_BLOCKING_IO */
+
+ if(prepend && (pipe_puts(prepend, fpipe) == EOF
+ || pipe_putc('\n', fpipe) == EOF))
+ errstr = error_description(errno);
+
+ /*
+ * Well, do the best we can, and hope the pipe we're writing
+ * doesn't fill up before we start reading...
+ */
+ while(!errstr && so_readc(&c, source_so))
+ if((outchars = utf8_to_locale((int) c, &cb, obuf, sizeof(obuf))) != 0)
+ for(i = 0; i < outchars && !errstr; i++)
+ if(pipe_putc(obuf[i], fpipe) == EOF)
+ errstr = error_description(errno);
+
+ if(pipe_close_write(fpipe))
+ errstr = _("Pipe command returned error.");
+
+ while(!errstr && pipe_gets(buf, sizeof(buf), fpipe))
+ errstr = gf_filter_puts(buf);
+
+#endif /* !NON_BLOCKING_IO */
+
+ if(close_system_pipe(&fpipe, NULL, pipecb_f) && !errstr)
+ errstr = _("Pipe command returned error.");
+
+ gf_filter_eod();
+ }
+ else
+ errstr = _("Error setting up pipe command.");
+
+ return(errstr);
+}
+
+
+/*
+ * gf_filter_puts - write the given string down the filter's pipe
+ */
+char *
+gf_filter_puts(register char *s)
+{
+ GF_INIT(gf_master, gf_master);
+
+ /*
+ * set up for any errors a filter may encounter
+ */
+ if(setjmp(gf_error_state)){
+ dprint((4, "ERROR: gf_filter_puts: %s\n",
+ gf_error_string ? gf_error_string : "NULL"));
+ return(gf_error_string);
+ }
+
+ while(*s)
+ GF_PUTC(gf_master, (*s++) & 0xff);
+
+ GF_END(gf_master, gf_master);
+ return(NULL);
+}
+
+
+/*
+ * gf_filter_eod - flush pending data filter's input queue and deliver
+ * the GF_EOD marker.
+ */
+void
+gf_filter_eod(void)
+{
+ GF_INIT(gf_master, gf_master);
+ (void) GF_FLUSH(gf_master);
+ (*gf_master->f)(gf_master, GF_EOD);
+}
+
+
+/*
+ * END OF PIPE SUPPORT ROUTINES, BEGINNING OF FILTERS
+ *
+ * Filters MUST use the specified interface (pointer to filter
+ * structure, the unsigned character buffer in that struct, and a
+ * cmd flag), and pass each resulting octet to the next filter in the
+ * chain. Only the terminal filter need not call another filter.
+ * As a result, filters share a pretty general structure.
+ * Typically three main conditionals separate initialization from
+ * data from end-of-data command processing.
+ *
+ * Lastly, being character-at-a-time, they're a little more complex
+ * to write than filters operating on buffers because some state
+ * must typically be kept between characters. However, for a
+ * little bit of complexity here, much convenience is gained later
+ * as they can be arbitrarily chained together at run time and
+ * consume few resources (especially memory or disk) as they work.
+ * (NOTE 951005: even less cpu now that data between filters is passed
+ * via a vector.)
+ *
+ * A few notes about implementing filters:
+ *
+ * - A generic filter template looks like:
+ *
+ * void
+ * gf_xxx_filter(f, flg)
+ * FILTER_S *f;
+ * int flg;
+ * {
+ * GF_INIT(f, f->next); // def's var's to speed queue drain
+ *
+ * if(flg == GF_DATA){
+ * register unsigned char c;
+ *
+ * while(GF_GETC(f, c)){ // macro taking data off input queue
+ * // operate on c and pass it on here
+ * GF_PUTC(f->next, c); // macro writing output queue
+ * }
+ *
+ * GF_END(f, f->next); // macro to sync pointers/offsets
+ * //WARNING: DO NOT RETURN BEFORE ALL INCOMING DATA'S PROCESSED
+ * }
+ * else if(flg == GF_EOD){
+ * // process any buffered data here and pass it on
+ * GF_FLUSH(f->next); // flush pending data to next filter
+ * (*f->next->f)(f->next, GF_EOD);
+ * }
+ * else if(flg == GF_RESET){
+ * // initialize any data in the struct here
+ * }
+ * }
+ *
+ * - Any free storage allocated during initialization (typically tied
+ * to the "line" pointer in FILTER_S) is the filter's responsibility
+ * to clean up when the GF_EOD command comes through.
+ *
+ * - Filter's must pass GF_EOD they receive on to the next
+ * filter in the chain so it has the opportunity to flush
+ * any buffered data.
+ *
+ * - All filters expect NVT end-of-lines. The idea is to prepend
+ * or append either the gf_local_nvtnl or gf_nvtnl_local
+ * os-dependant filters to the data on the appropriate end of the
+ * pipe for the task at hand.
+ *
+ * - NOTE: As of 951004, filters no longer take their input as a single
+ * char argument, but rather get data to operate on via a vector
+ * representing the input queue in the FILTER_S structure.
+ *
+ */
+
+
+
+/*
+ * BASE64 TO BINARY encoding and decoding routines below
+ */
+
+
+/*
+ * BINARY to BASE64 filter (encoding described in rfc1341)
+ */
+void
+gf_binary_b64(FILTER_S *f, int flg)
+{
+ static char *v =
+ "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+ GF_INIT(f, f->next);
+
+ if(flg == GF_DATA){
+ register unsigned char c;
+ register unsigned char t = f->t;
+ register long n = f->n;
+
+ while(GF_GETC(f, c)){
+
+ switch(n++){
+ case 0 : case 3 : case 6 : case 9 : case 12: case 15: case 18:
+ case 21: case 24: case 27: case 30: case 33: case 36: case 39:
+ case 42: case 45:
+ GF_PUTC(f->next, v[c >> 2]);
+ /* byte 1: high 6 bits (1) */
+ t = c << 4; /* remember high 2 bits for next */
+ break;
+
+ case 1 : case 4 : case 7 : case 10: case 13: case 16: case 19:
+ case 22: case 25: case 28: case 31: case 34: case 37: case 40:
+ case 43:
+ GF_PUTC(f->next, v[(t|(c>>4)) & 0x3f]);
+ t = c << 2;
+ break;
+
+ case 2 : case 5 : case 8 : case 11: case 14: case 17: case 20:
+ case 23: case 26: case 29: case 32: case 35: case 38: case 41:
+ case 44:
+ GF_PUTC(f->next, v[(t|(c >> 6)) & 0x3f]);
+ GF_PUTC(f->next, v[c & 0x3f]);
+ break;
+ }
+
+ if(n == 45){ /* start a new line? */
+ GF_PUTC(f->next, '\015');
+ GF_PUTC(f->next, '\012');
+ n = 0L;
+ }
+ }
+
+ f->n = n;
+ f->t = t;
+ GF_END(f, f->next);
+ }
+ else if(flg == GF_EOD){ /* no more data */
+ switch (f->n % 3) { /* handle trailing bytes */
+ case 0: /* no trailing bytes */
+ break;
+
+ case 1:
+ GF_PUTC(f->next, v[(f->t) & 0x3f]);
+ GF_PUTC(f->next, '='); /* byte 3 */
+ GF_PUTC(f->next, '='); /* byte 4 */
+ break;
+
+ case 2:
+ GF_PUTC(f->next, v[(f->t) & 0x3f]);
+ GF_PUTC(f->next, '='); /* byte 4 */
+ break;
+ }
+
+ /* end with CRLF */
+ if(f->n){
+ GF_PUTC(f->next, '\015');
+ GF_PUTC(f->next, '\012');
+ }
+
+ (void) GF_FLUSH(f->next);
+ (*f->next->f)(f->next, GF_EOD);
+ }
+ else if(flg == GF_RESET){
+ dprint((9, "-- gf_reset binary_b64\n"));
+ f->n = 0L;
+ }
+}
+
+
+
+/*
+ * BASE64 to BINARY filter (encoding described in rfc1341)
+ */
+void
+gf_b64_binary(FILTER_S *f, int flg)
+{
+ static char v[] = {65,65,65,65,65,65,65,65,65,65,65,65,65,65,65,65,
+ 65,65,65,65,65,65,65,65,65,65,65,65,65,65,65,65,
+ 65,65,65,65,65,65,65,65,65,65,65,62,65,65,65,63,
+ 52,53,54,55,56,57,58,59,60,61,65,65,65,64,65,65,
+ 65, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9,10,11,12,13,14,
+ 15,16,17,18,19,20,21,22,23,24,25,65,65,65,65,65,
+ 65,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,
+ 41,42,43,44,45,46,47,48,49,50,51,65,65,65,65,65};
+ GF_INIT(f, f->next);
+
+ if(flg == GF_DATA){
+ register unsigned char c;
+ register unsigned char t = f->t;
+ register int n = (int) f->n;
+ register int state = f->f1;
+
+ while(GF_GETC(f, c)){
+
+ if(state){
+ state = 0;
+ if (c != '=') {
+ gf_error("Illegal '=' in base64 text");
+ /* NO RETURN */
+ }
+ }
+
+ /* in range, and a valid value? */
+ if((c & ~0x7f) || (c = v[c]) > 63){
+ if(c == 64){
+ switch (n++) { /* check quantum position */
+ case 2:
+ state++; /* expect an equal as next char */
+ break;
+
+ case 3:
+ n = 0L; /* restart quantum */
+ break;
+
+ default: /* impossible quantum position */
+ gf_error("Internal base64 decoder error");
+ /* NO RETURN */
+ }
+ }
+ }
+ else{
+ switch (n++) { /* install based on quantum position */
+ case 0: /* byte 1: high 6 bits */
+ t = c << 2;
+ break;
+
+ case 1: /* byte 1: low 2 bits */
+ GF_PUTC(f->next, (t|(c >> 4)));
+ t = c << 4; /* byte 2: high 4 bits */
+ break;
+
+ case 2: /* byte 2: low 4 bits */
+ GF_PUTC(f->next, (t|(c >> 2)));
+ t = c << 6; /* byte 3: high 2 bits */
+ break;
+
+ case 3:
+ GF_PUTC(f->next, t | c);
+ n = 0L; /* reinitialize mechanism */
+ break;
+ }
+ }
+ }
+
+ f->f1 = state;
+ f->t = t;
+ f->n = n;
+ GF_END(f, f->next);
+ }
+ else if(flg == GF_EOD){
+ (void) GF_FLUSH(f->next);
+ (*f->next->f)(f->next, GF_EOD);
+ }
+ else if(flg == GF_RESET){
+ dprint((9, "-- gf_reset b64_binary\n"));
+ f->n = 0L; /* quantum position */
+ f->f1 = 0; /* state holder: equal seen? */
+ }
+}
+
+
+
+
+/*
+ * QUOTED-PRINTABLE ENCODING AND DECODING filters below.
+ * encoding described in rfc1341
+ */
+
+#define GF_MAXLINE 80 /* good buffer size */
+
+/*
+ * default action for QUOTED-PRINTABLE to 8BIT decoder
+ */
+#define GF_QP_DEFAULT(f, c) { \
+ if((c) == ' '){ \
+ state = WSPACE; \
+ /* reset white space! */ \
+ (f)->linep = (f)->line; \
+ *((f)->linep)++ = ' '; \
+ } \
+ else if((c) == '='){ \
+ state = EQUAL; \
+ } \
+ else \
+ GF_PUTC((f)->next, (c)); \
+ }
+
+
+/*
+ * QUOTED-PRINTABLE to 8BIT filter
+ */
+void
+gf_qp_8bit(FILTER_S *f, int flg)
+{
+
+ GF_INIT(f, f->next);
+
+ if(flg == GF_DATA){
+ register unsigned char c;
+ register int state = f->f1;
+
+ while(GF_GETC(f, c)){
+
+ switch(state){
+ case DFL : /* default case */
+ default:
+ GF_QP_DEFAULT(f, c);
+ break;
+
+ case CCR : /* non-significant space */
+ state = DFL;
+ if(c == '\012')
+ continue; /* go on to next char */
+
+ GF_QP_DEFAULT(f, c);
+ break;
+
+ case EQUAL :
+ if(c == '\015'){ /* "=\015" is a soft EOL */
+ state = CCR;
+ break;
+ }
+
+ if(c == '='){ /* compatibility clause for old guys */
+ GF_PUTC(f->next, '=');
+ state = DFL;
+ break;
+ }
+
+ if(!isxdigit((unsigned char)c)){ /* must be hex! */
+ /*
+ * First character after '=' not a hex digit.
+ * This ain't right, but we're going to treat it as
+ * plain old text instead of an '=' followed by hex.
+ * In other words, they forgot to encode the '='.
+ * Before 4.60 we just bailed with an error here, but now
+ * we keep going as long as we are just displaying
+ * the result (and not saving it or something).
+ *
+ * Wait! The users don't like that. They want to be able
+ * to use it even if it might be wrong. So just plow
+ * ahead even if displaying.
+ *
+ * Better have this be a constant string so that if we
+ * get multiple instances of it in a single message we
+ * can avoid the too many error messages problem. It
+ * better be the same message as the one a few lines
+ * below, as well.
+ *
+ * Turn off decoding after encountering such an error and
+ * just dump the rest of the text as is.
+ */
+ state = STOP_DECODING;
+ GF_PUTC(f->next, '=');
+ GF_PUTC(f->next, c);
+ q_status_message(SM_ORDER,3,3,
+ _("Warning: Non-hexadecimal character in QP encoding!"));
+
+ dprint((2, "gf_qp_8bit: warning: non-hex char in QP encoding: char \"%c\" (%d) follows =\n", c, c));
+ break;
+ }
+
+ if (isdigit ((unsigned char)c))
+ f->t = c - '0';
+ else
+ f->t = c - (isupper((unsigned char)c) ? 'A' - 10 : 'a' - 10);
+
+ f->f2 = c; /* store character in case we have to
+ back out in !isxdigit below */
+
+ state = HEX;
+ break;
+
+ case HEX :
+ state = DFL;
+ if(!isxdigit((unsigned char)c)){ /* must be hex! */
+ state = STOP_DECODING;
+ GF_PUTC(f->next, '=');
+ GF_PUTC(f->next, f->f2);
+ GF_PUTC(f->next, c);
+ q_status_message(SM_ORDER,3,3,
+ _("Warning: Non-hexadecimal character in QP encoding!"));
+
+ dprint((2, "gf_qp_8bit: warning: non-hex char in QP encoding: char \"%c\" (%d) follows =%c\n", c, c, f->f2));
+ break;
+ }
+
+ if (isdigit((unsigned char)c))
+ c -= '0';
+ else
+ c -= (isupper((unsigned char)c) ? 'A' - 10 : 'a' - 10);
+
+ GF_PUTC(f->next, c + (f->t << 4));
+ break;
+
+ case WSPACE :
+ if(c == ' '){ /* toss it in with other spaces */
+ if(f->linep - f->line < GF_MAXLINE)
+ *(f->linep)++ = ' ';
+ break;
+ }
+
+ state = DFL;
+ if(c == '\015'){ /* not our white space! */
+ f->linep = f->line; /* reset buffer */
+ GF_PUTC(f->next, '\015');
+ break;
+ }
+
+ /* the spaces are ours, write 'em */
+ f->n = f->linep - f->line;
+ while((f->n)--)
+ GF_PUTC(f->next, ' ');
+
+ GF_QP_DEFAULT(f, c); /* take care of 'c' in default way */
+ break;
+
+ case STOP_DECODING :
+ GF_PUTC(f->next, c);
+ break;
+ }
+ }
+
+ f->f1 = state;
+ GF_END(f, f->next);
+ }
+ else if(flg == GF_EOD){
+ fs_give((void **)&(f->line));
+ (void) GF_FLUSH(f->next);
+ (*f->next->f)(f->next, GF_EOD);
+ }
+ else if(flg == GF_RESET){
+ dprint((9, "-- gf_reset qp_8bit\n"));
+ f->f1 = DFL;
+ f->linep = f->line = (char *)fs_get(GF_MAXLINE * sizeof(char));
+ }
+}
+
+
+
+/*
+ * USEFUL MACROS TO HELP WITH QP ENCODING
+ */
+
+#define QP_MAXL 75 /* 76th place only for continuation */
+
+/*
+ * Macro to test and wrap long quoted printable lines
+ */
+#define GF_8BIT_WRAP(f) { \
+ GF_PUTC((f)->next, '='); \
+ GF_PUTC((f)->next, '\015'); \
+ GF_PUTC((f)->next, '\012'); \
+ }
+
+/*
+ * write a quoted octet in QUOTED-PRINTABLE encoding, adding soft
+ * line break if needed.
+ */
+#define GF_8BIT_PUT_QUOTE(f, c) { \
+ if(((f)->n += 3) > QP_MAXL){ \
+ GF_8BIT_WRAP(f); \
+ (f)->n = 3; /* set line count */ \
+ } \
+ GF_PUTC((f)->next, '='); \
+ GF_PUTC((f)->next, HEX_CHAR1(c)); \
+ GF_PUTC((f)->next, HEX_CHAR2(c)); \
+ }
+
+/*
+ * just write an ordinary octet in QUOTED-PRINTABLE, wrapping line
+ * if needed.
+ */
+#define GF_8BIT_PUT(f, c) { \
+ if((++(f->n)) > QP_MAXL){ \
+ GF_8BIT_WRAP(f); \
+ f->n = 1L; \
+ } \
+ if(f->n == 1L && c == '.'){ \
+ GF_8BIT_PUT_QUOTE(f, c); \
+ f->n = 3; \
+ } \
+ else \
+ GF_PUTC(f->next, c); \
+ }
+
+
+/*
+ * default action for 8bit to quoted printable encoder
+ */
+#define GF_8BIT_DEFAULT(f, c) if((c) == ' '){ \
+ state = WSPACE; \
+ } \
+ else if(c == '\015'){ \
+ state = CCR; \
+ } \
+ else if(iscntrl(c & 0x7f) || (c == 0x7f) \
+ || (c & 0x80) || (c == '=')){ \
+ GF_8BIT_PUT_QUOTE(f, c); \
+ } \
+ else{ \
+ GF_8BIT_PUT(f, c); \
+ }
+
+
+/*
+ * 8BIT to QUOTED-PRINTABLE filter
+ */
+void
+gf_8bit_qp(FILTER_S *f, int flg)
+{
+ short dummy_dots = 0, dummy_dmap = 1;
+ GF_INIT(f, f->next);
+
+ if(flg == GF_DATA){
+ register unsigned char c;
+ register int state = f->f1;
+
+ while(GF_GETC(f, c)){
+
+ /* keep track of "^JFrom " */
+ Find_Froms(f->t, dummy_dots, f->f2, dummy_dmap, c);
+
+ switch(state){
+ case DFL : /* handle ordinary case */
+ GF_8BIT_DEFAULT(f, c);
+ break;
+
+ case CCR : /* true line break? */
+ state = DFL;
+ if(c == '\012'){
+ GF_PUTC(f->next, '\015');
+ GF_PUTC(f->next, '\012');
+ f->n = 0L;
+ }
+ else{ /* nope, quote the CR */
+ GF_8BIT_PUT_QUOTE(f, '\015');
+ GF_8BIT_DEFAULT(f, c); /* and don't forget about c! */
+ }
+ break;
+
+ case WSPACE:
+ state = DFL;
+ if(c == '\015' || f->t){ /* handle the space */
+ GF_8BIT_PUT_QUOTE(f, ' ');
+ f->t = 0; /* reset From flag */
+ }
+ else
+ GF_8BIT_PUT(f, ' ');
+
+ GF_8BIT_DEFAULT(f, c); /* handle 'c' in the default way */
+ break;
+ }
+ }
+
+ f->f1 = state;
+ GF_END(f, f->next);
+ }
+ else if(flg == GF_EOD){
+ switch(f->f1){
+ case CCR :
+ GF_8BIT_PUT_QUOTE(f, '\015'); /* write the last cr */
+ break;
+
+ case WSPACE :
+ GF_8BIT_PUT_QUOTE(f, ' '); /* write the last space */
+ break;
+ }
+
+ (void) GF_FLUSH(f->next);
+ (*f->next->f)(f->next, GF_EOD);
+ }
+ else if(flg == GF_RESET){
+ dprint((9, "-- gf_reset 8bit_qp\n"));
+ f->f1 = DFL; /* state from last character */
+ f->f2 = 1; /* state of "^NFrom " bitmap */
+ f->t = 0;
+ f->n = 0L; /* number of chars in current line */
+ }
+}
+
+/*
+ * This filter converts characters in one character set (the character
+ * set of a message, for example) to another (the user's character set).
+ */
+void
+gf_convert_8bit_charset(FILTER_S *f, int flg)
+{
+ static unsigned char *conv_table = NULL;
+ GF_INIT(f, f->next);
+
+ if(flg == GF_DATA){
+ register unsigned char c;
+
+ while(GF_GETC(f, c)){
+ GF_PUTC(f->next, conv_table ? conv_table[c] : c);
+ }
+
+ GF_END(f, f->next);
+ }
+ else if(flg == GF_EOD){
+ (void) GF_FLUSH(f->next);
+ (*f->next->f)(f->next, GF_EOD);
+ }
+ else if(flg == GF_RESET){
+ dprint((9, "-- gf_reset convert_8bit_charset\n"));
+ conv_table = (f->opt) ? (unsigned char *) (f->opt) : NULL;
+
+ }
+}
+
+
+typedef struct _utf8c_s {
+ void *conv_table;
+ int report_err;
+} UTF8C_S;
+
+
+/*
+ * This filter converts characters in UTF-8 to an 8-bit or 16-bit charset.
+ * Characters missing from the destination set, and invalid UTF-8 sequences,
+ * will be converted to "?".
+ */
+void
+gf_convert_utf8_charset(FILTER_S *f, int flg)
+{
+ static unsigned short *conv_table = NULL;
+ static int report_err = 0;
+ register int more = f->f2;
+ register long u = f->n;
+
+ /*
+ * "more" is the number of subsequent octets needed to complete a character,
+ * it is stored in f->f2.
+ * "u" is the accumulated Unicode character, it is stored in f->n
+ */
+
+ GF_INIT(f, f->next);
+
+ if(flg == GF_DATA){
+ register unsigned char c;
+
+ while(GF_GETC(f, c)){
+ if(!conv_table){ /* can't do much if no conversion table */
+ GF_PUTC(f->next, c);
+ }
+ /* UTF-8 continuation? */
+ else if((c > 0x7f) && (c < 0xc0)){
+ if(more){
+ u <<= 6; /* shift current value by 6 bits */
+ u |= c & 0x3f;
+ if (!--more){ /* last octet? */
+ if(u >= 0xffff || (u = conv_table[u]) == NOCHAR){
+ /*
+ * non-BMP character or a UTF-8 character
+ * which is not representable in the
+ * charset we're converting to.
+ */
+ c = '?';
+ if(report_err){
+ if(f->opt)
+ fs_give((void **) &f->opt);
+
+ /* TRANSLATORS: error while translating from one
+ character set to another, for example from UTF-8
+ to ISO-2022-JP or something like that. */
+ gf_error(_("translation error"));
+ /* NO RETURN */
+ }
+ }
+ else{
+ if(u > 0xff){
+ c = (unsigned char) (u >> 8);
+ GF_PUTC(f->next, c);
+ }
+
+ c = (unsigned char) u & 0xff;
+ }
+
+ GF_PUTC(f->next, c);
+ }
+ }
+ else{ /* continuation when not in progress */
+ GF_PUTC(f->next, '?');
+ }
+ }
+ else{
+ if(more){ /* incomplete UTF-8 character */
+ GF_PUTC(f->next, '?');
+ more = 0;
+ }
+ if(c < 0x80){ /* U+0000 - U+007f */
+ GF_PUTC(f->next, c);
+ }
+ else if(c < 0xe0){ /* U+0080 - U+07ff */
+ u = c & 0x1f; /* first 5 bits of 12 */
+ more = 1;
+ }
+ else if(c < 0xf0){ /* U+1000 - U+ffff */
+ u = c & 0x0f; /* first 4 bits of 16 */
+ more = 2;
+ }
+ /* in case we ever support non-BMP Unicode */
+ else if (c < 0xf8){ /* U+10000 - U+10ffff */
+ u = c & 0x07; /* first 3 bits of 20.5 */
+ more = 3;
+ }
+#if 0 /* ISO 10646 not in Unicode */
+ else if (c < 0xfc){ /* ISO 10646 20000 - 3ffffff */
+ u = c & 0x03; /* first 2 bits of 26 */
+ more = 4;
+ }
+ else if (c < 0xfe){ /* ISO 10646 4000000 - 7fffffff */
+ u = c & 0x03; /* first 2 bits of 26 */
+ more = 5;
+ }
+#endif
+ else{ /* not in Unicode */
+ GF_PUTC(f->next, '?');
+ }
+ }
+ }
+
+ f->f2 = more;
+ f->n = u;
+ GF_END(f, f->next);
+ }
+ else if(flg == GF_EOD){
+ (void) GF_FLUSH(f->next);
+ if(f->opt)
+ fs_give((void **) &f->opt);
+
+ (*f->next->f)(f->next, GF_EOD);
+ }
+ else if(flg == GF_RESET){
+ dprint((9, "-- gf_reset convert_utf8_charset\n"));
+ conv_table = ((UTF8C_S *) f->opt)->conv_table;
+ report_err = ((UTF8C_S *) f->opt)->report_err;
+ f->f2 = 0;
+ f->n = 0L;
+ }
+}
+
+
+void *
+gf_convert_utf8_charset_opt(void *table, int report_err)
+{
+ UTF8C_S *utf8c;
+
+ utf8c = (UTF8C_S *) fs_get(sizeof(UTF8C_S));
+ utf8c->conv_table = table;
+ utf8c->report_err = report_err;
+ return((void *) utf8c);
+}
+
+
+/*
+ * ISO-2022-JP to EUC (on Unix) or Shift-JIS (on PC) filter
+ *
+ * The routine is call ..._to_euc but it is really to either euc (unix Pine)
+ * or to Shift-JIS (if PC-Pine).
+ */
+void
+gf_2022_jp_to_euc(FILTER_S *f, int flg)
+{
+ register unsigned char c;
+ register int state = f->f1;
+
+ /*
+ * f->t lit means we're in middle of decoding a sequence of characters.
+ * f->f2 keeps track of first character of pair for Shift-JIS.
+ * f->f1 is the state.
+ */
+
+ GF_INIT(f, f->next);
+
+ if(flg == GF_DATA){
+ while(GF_GETC(f, c)){
+ switch(state){
+ case ESC: /* saw ESC */
+ if(!f->t && c == '$')
+ state = ESCDOL;
+ else if(f->t && c == '(')
+ state = ESCPAR;
+ else{
+ GF_PUTC(f->next, '\033');
+ GF_PUTC(f->next, c);
+ state = DFL;
+ }
+
+ break;
+
+ case ESCDOL: /* saw ESC $ */
+ if(c == 'B' || c == '@'){
+ state = EUC;
+ f->t = 1; /* filtering into euc */
+ f->f2 = -1; /* first character of pair */
+ }
+ else{
+ GF_PUTC(f->next, '\033');
+ GF_PUTC(f->next, '$');
+ GF_PUTC(f->next, c);
+ state = DFL;
+ }
+
+ break;
+
+ case ESCPAR: /* saw ESC ( */
+ if(c == 'B' || c == 'J' || c == 'H'){
+ state = DFL;
+ f->t = 0; /* done filtering */
+ }
+ else{
+ GF_PUTC(f->next, '\033'); /* Don't set hibit for */
+ GF_PUTC(f->next, '('); /* escape sequences, which */
+ GF_PUTC(f->next, c); /* this appears to be. */
+ }
+
+ break;
+
+ case EUC: /* filtering into euc */
+ if(c == '\033')
+ state = ESC;
+ else{
+#ifdef _WINDOWS /* Shift-JIS */
+ c &= 0x7f; /* 8-bit can't win */
+ if (f->f2 >= 0){ /* second of a pair? */
+ int rowOffset = (f->f2 < 95) ? 112 : 176;
+ int cellOffset = (f->f2 % 2) ? ((c > 95) ? 32 : 31)
+ : 126;
+
+ GF_PUTC(f->next, ((f->f2 + 1) >> 1) + rowOffset);
+ GF_PUTC(f->next, c + cellOffset);
+ f->f2 = -1; /* restart */
+ }
+ else if(c > 0x20 && c < 0x7f)
+ f->f2 = c; /* first of pair */
+ else{
+ GF_PUTC(f->next, c); /* write CTL as itself */
+ f->f2 = -1;
+ }
+#else /* EUC */
+ GF_PUTC(f->next, (c > 0x20 && c < 0x7f) ? c | 0x80 : c);
+#endif
+ }
+
+ break;
+
+ case DFL:
+ default:
+ if(c == '\033')
+ state = ESC;
+ else
+ GF_PUTC(f->next, c);
+
+ break;
+ }
+ }
+
+ f->f1 = state;
+ GF_END(f, f->next);
+ }
+ else if(flg == GF_EOD){
+ switch(state){
+ case ESC:
+ GF_PUTC(f->next, '\033');
+ break;
+
+ case ESCDOL:
+ GF_PUTC(f->next, '\033');
+ GF_PUTC(f->next, '$');
+ break;
+
+ case ESCPAR:
+ GF_PUTC(f->next, '\033'); /* Don't set hibit for */
+ GF_PUTC(f->next, '('); /* escape sequences. */
+ break;
+ }
+
+ (void) GF_FLUSH(f->next);
+ (*f->next->f)(f->next, GF_EOD);
+ }
+ else if(flg == GF_RESET){
+ dprint((9, "-- gf_reset jp_to_euc\n"));
+ f->f1 = DFL; /* state */
+ f->t = 0; /* not translating to euc */
+ }
+}
+
+
+/*
+ * EUC (on Unix) or Shift-JIS (on PC) to ISO-2022-JP filter
+ */
+void
+gf_native8bitjapanese_to_2022_jp(FILTER_S *f, int flg)
+{
+#ifdef _WINDOWS
+ gf_sjis_to_2022_jp(f, flg);
+#else
+ gf_euc_to_2022_jp(f, flg);
+#endif
+}
+
+
+void
+gf_euc_to_2022_jp(FILTER_S *f, int flg)
+{
+ register unsigned char c;
+
+ /*
+ * f->t lit means we've sent the start esc seq but not the end seq.
+ * f->f2 keeps track of first character of pair for Shift-JIS.
+ */
+
+ GF_INIT(f, f->next);
+
+ if(flg == GF_DATA){
+ while(GF_GETC(f, c)){
+ if(f->t){
+ if(c & 0x80){
+ GF_PUTC(f->next, c & 0x7f);
+ }
+ else{
+ GF_PUTC(f->next, '\033');
+ GF_PUTC(f->next, '(');
+ GF_PUTC(f->next, 'B');
+ GF_PUTC(f->next, c);
+ f->f2 = -1;
+ f->t = 0;
+ }
+ }
+ else{
+ if(c & 0x80){
+ GF_PUTC(f->next, '\033');
+ GF_PUTC(f->next, '$');
+ GF_PUTC(f->next, 'B');
+ GF_PUTC(f->next, c & 0x7f);
+ f->t = 1;
+ }
+ else{
+ GF_PUTC(f->next, c);
+ }
+ }
+ }
+
+ GF_END(f, f->next);
+ }
+ else if(flg == GF_EOD){
+ if(f->t){
+ GF_PUTC(f->next, '\033');
+ GF_PUTC(f->next, '(');
+ GF_PUTC(f->next, 'B');
+ f->t = 0;
+ f->f2 = -1;
+ }
+
+ (void) GF_FLUSH(f->next);
+ (*f->next->f)(f->next, GF_EOD);
+ }
+ else if(flg == GF_RESET){
+ dprint((9, "-- gf_reset euc_to_jp\n"));
+ f->t = 0;
+ f->f2 = -1;
+ }
+}
+
+void
+gf_sjis_to_2022_jp(FILTER_S *f, int flg)
+{
+ register unsigned char c;
+
+ /*
+ * f->t lit means we've sent the start esc seq but not the end seq.
+ * f->f2 keeps track of first character of pair for Shift-JIS.
+ */
+
+ GF_INIT(f, f->next);
+
+ if(flg == GF_DATA){
+ while(GF_GETC(f, c)){
+ if(f->t){
+ if(f->f2 >= 0){ /* second of a pair? */
+ int adjust = c < 159;
+ int rowOffset = f->f2 < 160 ? 112 : 176;
+ int cellOffset = adjust ? (c > 127 ? 32 : 31) : 126;
+
+ GF_PUTC(f->next, ((f->f2 - rowOffset) << 1) - adjust);
+ GF_PUTC(f->next, c - cellOffset);
+ f->f2 = -1;
+ }
+ else if(c & 0x80){
+ f->f2 = c; /* remember first of pair */
+ }
+ else{
+ GF_PUTC(f->next, '\033');
+ GF_PUTC(f->next, '(');
+ GF_PUTC(f->next, 'B');
+ GF_PUTC(f->next, c);
+ f->f2 = -1;
+ f->t = 0;
+ }
+ }
+ else{
+ if(c & 0x80){
+ GF_PUTC(f->next, '\033');
+ GF_PUTC(f->next, '$');
+ GF_PUTC(f->next, 'B');
+ f->f2 = c;
+ f->t = 1;
+ }
+ else{
+ GF_PUTC(f->next, c);
+ }
+ }
+ }
+
+ GF_END(f, f->next);
+ }
+ else if(flg == GF_EOD){
+ if(f->t){
+ GF_PUTC(f->next, '\033');
+ GF_PUTC(f->next, '(');
+ GF_PUTC(f->next, 'B');
+ f->t = 0;
+ f->f2 = -1;
+ }
+
+ (void) GF_FLUSH(f->next);
+ (*f->next->f)(f->next, GF_EOD);
+ }
+ else if(flg == GF_RESET){
+ dprint((9, "-- gf_reset sjis_to_jp\n"));
+ f->t = 0;
+ f->f2 = -1;
+ }
+}
+
+
+
+/*
+ * Various charset to UTF-8 Translation filter
+ */
+
+/*
+ * utf8 conversion options
+ */
+typedef struct _utf8_s {
+ CHARSET *charset;
+ unsigned long ucsc;
+} UTF8_S;
+
+#define UTF8_BLOCK 1024
+#define UTF8_EOB(f) ((f)->line + (f)->f2 - 1)
+#define UTF8_ADD(f, c) \
+ { \
+ if(p >= eobuf){ \
+ f->f2 += UTF8_BLOCK; \
+ fs_resize((void **)&f->line, \
+ (size_t) f->f2 * sizeof(char)); \
+ eobuf = UTF8_EOB(f); \
+ p = eobuf - UTF8_BLOCK; \
+ } \
+ *p++ = c; \
+ }
+#define GF_UTF8_FLUSH(f) { \
+ register long n; \
+ SIZEDTEXT intext, outtext; \
+ intext.data = (unsigned char *) f->line; \
+ intext.size = p - f->line; \
+ memset(&outtext, 0, sizeof(SIZEDTEXT)); \
+ if(!((UTF8_S *) f->opt)->charset){ \
+ for(n = 0; n < intext.size; n++) \
+ GF_PUTC(f->next, (intext.data[n] & 0x80) ? '?' : intext.data[n]); \
+ } \
+ else if(utf8_text_cs(&intext, ((UTF8_S *) f->opt)->charset, &outtext, NULL, NULL)){ \
+ for(n = 0; n < outtext.size; n++) \
+ GF_PUTC(f->next, outtext.data[n]); \
+ if(outtext.data && intext.data != outtext.data) \
+ fs_give((void **) &outtext.data); \
+ } \
+ else{ \
+ for(n = 0; n < intext.size; n++) \
+ GF_PUTC(f->next, '?'); \
+ } \
+ }
+
+
+/*
+ * gf_utf8 - text in specified charset to to UTF-8 filter
+ * Process line-at-a-time rather than character
+ * because ISO-2022-JP. Call utf8_text_cs by hand
+ * rather than utf8_text to reduce the cost of
+ * utf8_charset() for each line.
+ */
+void
+gf_utf8(FILTER_S *f, int flg)
+{
+ register char *p = f->linep;
+ register char *eobuf = UTF8_EOB(f);
+ GF_INIT(f, f->next);
+
+ if(flg == GF_DATA){
+ register int state = f->f1;
+ register unsigned char c;
+
+ while(GF_GETC(f, c)){
+
+ switch(state){
+ case CCR :
+ state = DFL;
+ if(c == '\012'){
+ GF_UTF8_FLUSH(f);
+ p = f->line;
+ GF_PUTC(f->next, '\015');
+ GF_PUTC(f->next, '\012');
+ }
+ else{
+ UTF8_ADD(f, '\015');
+ UTF8_ADD(f, c);
+ }
+
+ break;
+
+ default :
+ if(c == '\015'){
+ state = CCR;
+ }
+ else
+ UTF8_ADD(f, c);
+ }
+ }
+
+ f->f1 = state;
+ GF_END(f, f->next);
+ }
+ else if(flg == GF_EOD){
+
+ if(p != f->line)
+ GF_UTF8_FLUSH(f);
+
+ fs_give((void **) &f->line);
+ fs_give((void **) &f->opt);
+ (void) GF_FLUSH(f->next);
+ (*f->next->f)(f->next, GF_EOD);
+ }
+ else if(GF_RESET){
+ dprint((9, "-- gf_reset utf8\n"));
+ f->f1 = DFL;
+ f->f2 = UTF8_BLOCK; /* input buffer length */
+ f->line = p = (char *) fs_get(f->f2 * sizeof(char));
+ }
+
+ f->linep = p;
+}
+
+
+void *
+gf_utf8_opt(char *charset)
+{
+ UTF8_S *utf8;
+
+ utf8 = (UTF8_S *) fs_get(sizeof(UTF8_S));
+
+ utf8->charset = (CHARSET *) utf8_charset(charset);
+
+ /*
+ * When we get 8-bit non-ascii characters but it is supposed to
+ * be ascii we want it to turn into question marks, not
+ * just behave as if it is UTF-8 which is what happens
+ * with ascii because there is no translation table.
+ * So we need to catch the ascii special case here.
+ */
+ if(utf8->charset && utf8->charset->type == CT_ASCII)
+ utf8->charset = NULL;
+
+ return((void *) utf8);
+}
+
+
+/*
+ * RICHTEXT-TO-PLAINTEXT filter
+ */
+
+/*
+ * option to be used by rich2plain (NOTE: if this filter is ever
+ * used more than once in a pipe, all instances will have the same
+ * option value)
+ */
+
+
+/*----------------------------------------------------------------------
+ richtext to plaintext filter
+
+ Args: f --
+ flg --
+
+ This basically removes all richtext formatting. A cute hack is used
+ to get bold and underlining to work.
+ Further work could be done to handle things like centering and right
+ and left flush, but then it could no longer be done in place. This
+ operates on text *with* CRLF's.
+
+ WARNING: does not wrap lines!
+ ----*/
+void
+gf_rich2plain(FILTER_S *f, int flg)
+{
+ static int rich_bold_on = 0, rich_uline_on = 0;
+
+/* BUG: qoute incoming \255 values */
+ GF_INIT(f, f->next);
+
+ if(flg == GF_DATA){
+ register unsigned char c;
+ register int state = f->f1;
+ register int plain;
+
+ plain = f->opt ? (*(int *) f->opt) : 0;
+
+ while(GF_GETC(f, c)){
+
+ switch(state){
+ case TOKEN : /* collect a richtext token */
+ if(c == '>'){ /* what should we do with it? */
+ state = DFL; /* return to default next time */
+ *(f->linep) = '\0'; /* cap off token */
+ if(f->line[0] == 'l' && f->line[1] == 't'){
+ GF_PUTC(f->next, '<'); /* literal '<' */
+ }
+ else if(f->line[0] == 'n' && f->line[1] == 'l'){
+ GF_PUTC(f->next, '\015');/* newline! */
+ GF_PUTC(f->next, '\012');
+ }
+ else if(!strcmp("comment", f->line)){
+ (f->f2)++;
+ }
+ else if(!strcmp("/comment", f->line)){
+ f->f2 = 0;
+ }
+ else if(!strcmp("/paragraph", f->line)) {
+ GF_PUTC(f->next, '\r');
+ GF_PUTC(f->next, '\n');
+ GF_PUTC(f->next, '\r');
+ GF_PUTC(f->next, '\n');
+ }
+ else if(!plain /* gf_rich_plain */){
+ if(!strcmp(f->line, "bold")) {
+ GF_PUTC(f->next, TAG_EMBED);
+ GF_PUTC(f->next, TAG_BOLDON);
+ rich_bold_on = 1;
+ } else if(!strcmp(f->line, "/bold")) {
+ GF_PUTC(f->next, TAG_EMBED);
+ GF_PUTC(f->next, TAG_BOLDOFF);
+ rich_bold_on = 0;
+ } else if(!strcmp(f->line, "italic")) {
+ GF_PUTC(f->next, TAG_EMBED);
+ GF_PUTC(f->next, TAG_ULINEON);
+ rich_uline_on = 1;
+ } else if(!strcmp(f->line, "/italic")) {
+ GF_PUTC(f->next, TAG_EMBED);
+ GF_PUTC(f->next, TAG_ULINEOFF);
+ rich_uline_on = 0;
+ } else if(!strcmp(f->line, "underline")) {
+ GF_PUTC(f->next, TAG_EMBED);
+ GF_PUTC(f->next, TAG_ULINEON);
+ rich_uline_on = 1;
+ } else if(!strcmp(f->line, "/underline")) {
+ GF_PUTC(f->next, TAG_EMBED);
+ GF_PUTC(f->next, TAG_ULINEOFF);
+ rich_uline_on = 0;
+ }
+ }
+ /* else we just ignore the token! */
+
+ f->linep = f->line; /* reset token buffer */
+ }
+ else{ /* add char to token */
+ if(f->linep - f->line > 40){
+ /* What? rfc1341 says 40 char tokens MAX! */
+ fs_give((void **)&(f->line));
+ gf_error("Richtext token over 40 characters");
+ /* NO RETURN */
+ }
+
+ *(f->linep)++ = isupper((unsigned char)c) ? c-'A'+'a' : c;
+ }
+ break;
+
+ case CCR :
+ state = DFL; /* back to default next time */
+ if(c == '\012'){ /* treat as single space? */
+ GF_PUTC(f->next, ' ');
+ break;
+ }
+ /* fall thru to process c */
+
+ case DFL :
+ default:
+ if(c == '<')
+ state = TOKEN;
+ else if(c == '\015')
+ state = CCR;
+ else if(!f->f2) /* not in comment! */
+ GF_PUTC(f->next, c);
+
+ break;
+ }
+ }
+
+ f->f1 = state;
+ GF_END(f, f->next);
+ }
+ else if(flg == GF_EOD){
+ if((f->f1 = (f->linep != f->line)) != 0){
+ /* incomplete token!! */
+ gf_error("Incomplete token in richtext");
+ /* NO RETURN */
+ }
+
+ if(rich_uline_on){
+ GF_PUTC(f->next, TAG_EMBED);
+ GF_PUTC(f->next, TAG_ULINEOFF);
+ rich_uline_on = 0;
+ }
+ if(rich_bold_on){
+ GF_PUTC(f->next, TAG_EMBED);
+ GF_PUTC(f->next, TAG_BOLDOFF);
+ rich_bold_on = 0;
+ }
+
+ fs_give((void **)&(f->line));
+ (void) GF_FLUSH(f->next);
+ (*f->next->f)(f->next, GF_EOD);
+ }
+ else if(flg == GF_RESET){
+ dprint((9, "-- gf_reset rich2plain\n"));
+ f->f1 = DFL; /* state */
+ f->f2 = 0; /* set means we're in a comment */
+ f->linep = f->line = (char *)fs_get(45 * sizeof(char));
+ }
+}
+
+
+/*
+ * function called from the outside to set
+ * richtext filter's options
+ */
+void *
+gf_rich2plain_opt(int *plain)
+{
+ return((void *) plain);
+}
+
+
+
+/*
+ * ENRICHED-TO-PLAIN text filter
+ */
+
+#define TEF_QUELL 0x01
+#define TEF_NOFILL 0x02
+
+
+
+/*----------------------------------------------------------------------
+ enriched text to plain text filter (ala rfc1523)
+
+ Args: f -- state and input data
+ flg --
+
+ This basically removes all enriched formatting. A cute hack is used
+ to get bold and underlining to work.
+
+ Further work could be done to handle things like centering and right
+ and left flush, but then it could no longer be done in place. This
+ operates on text *with* CRLF's.
+
+ WARNING: does not wrap lines!
+ ----*/
+void
+gf_enriched2plain(FILTER_S *f, int flg)
+{
+ static int enr_uline_on = 0, enr_bold_on = 0;
+
+/* BUG: qoute incoming \255 values */
+ GF_INIT(f, f->next);
+
+ if(flg == GF_DATA){
+ register unsigned char c;
+ register int state = f->f1;
+ register int plain;
+
+ plain = f->opt ? (*(int *) f->opt) : 0;
+
+ while(GF_GETC(f, c)){
+
+ switch(state){
+ case TOKEN : /* collect a richtext token */
+ if(c == '>'){ /* what should we do with it? */
+ int off = *f->line == '/';
+ char *token = f->line + (off ? 1 : 0);
+ state = DFL;
+ *f->linep = '\0';
+ if(!strcmp("param", token)){
+ if(off)
+ f->f2 &= ~TEF_QUELL;
+ else
+ f->f2 |= TEF_QUELL;
+ }
+ else if(!strcmp("nofill", token)){
+ if(off)
+ f->f2 &= ~TEF_NOFILL;
+ else
+ f->f2 |= TEF_NOFILL;
+ }
+ else if(!plain /* gf_enriched_plain */){
+ /* Following is a cute hack or two to get
+ bold and underline on the screen.
+ See Putline0n() where these codes are
+ interpreted */
+ if(!strcmp("bold", token)) {
+ GF_PUTC(f->next, TAG_EMBED);
+ GF_PUTC(f->next, off ? TAG_BOLDOFF : TAG_BOLDON);
+ enr_bold_on = off ? 0 : 1;
+ } else if(!strcmp("italic", token)) {
+ GF_PUTC(f->next, TAG_EMBED);
+ GF_PUTC(f->next, off ? TAG_ULINEOFF : TAG_ULINEON);
+ enr_uline_on = off ? 0 : 1;
+ } else if(!strcmp("underline", token)) {
+ GF_PUTC(f->next, TAG_EMBED);
+ GF_PUTC(f->next, off ? TAG_ULINEOFF : TAG_ULINEON);
+ enr_uline_on = off ? 0 : 1;
+ }
+ }
+ /* else we just ignore the token! */
+
+ f->linep = f->line; /* reset token buffer */
+ }
+ else if(c == '<'){ /* literal '<'? */
+ if(f->linep == f->line){
+ GF_PUTC(f->next, '<');
+ state = DFL;
+ }
+ else{
+ fs_give((void **)&(f->line));
+ gf_error("Malformed Enriched text: unexpected '<'");
+ /* NO RETURN */
+ }
+ }
+ else{ /* add char to token */
+ if(f->linep - f->line > 60){ /* rfc1523 says 60 MAX! */
+ fs_give((void **)&(f->line));
+ gf_error("Malformed Enriched text: token too long");
+ /* NO RETURN */
+ }
+
+ *(f->linep)++ = isupper((unsigned char)c) ? c-'A'+'a' : c;
+ }
+ break;
+
+ case CCR :
+ if(c != '\012'){ /* treat as single space? */
+ state = DFL; /* lone cr? */
+ f->f2 &= ~TEF_QUELL;
+ GF_PUTC(f->next, '\015');
+ goto df;
+ }
+
+ state = CLF;
+ break;
+
+ case CLF :
+ if(c == '\015'){ /* treat as single space? */
+ state = CCR; /* repeat crlf's mean real newlines */
+ f->f2 |= TEF_QUELL;
+ GF_PUTC(f->next, '\r');
+ GF_PUTC(f->next, '\n');
+ break;
+ }
+ else{
+ state = DFL;
+ if(!((f->f2) & TEF_QUELL))
+ GF_PUTC(f->next, ' ');
+
+ f->f2 &= ~TEF_QUELL;
+ }
+
+ /* fall thru to take care of 'c' */
+
+ case DFL :
+ default :
+ df :
+ if(c == '<')
+ state = TOKEN;
+ else if(c == '\015' && (!((f->f2) & TEF_NOFILL)))
+ state = CCR;
+ else if(!((f->f2) & TEF_QUELL))
+ GF_PUTC(f->next, c);
+
+ break;
+ }
+ }
+
+ f->f1 = state;
+ GF_END(f, f->next);
+ }
+ else if(flg == GF_EOD){
+ if((f->f1 = (f->linep != f->line)) != 0){
+ /* incomplete token!! */
+ gf_error("Incomplete token in richtext");
+ /* NO RETURN */
+ }
+ if(enr_uline_on){
+ GF_PUTC(f->next, TAG_EMBED);
+ GF_PUTC(f->next, TAG_ULINEOFF);
+ enr_uline_on = 0;
+ }
+ if(enr_bold_on){
+ GF_PUTC(f->next, TAG_EMBED);
+ GF_PUTC(f->next, TAG_BOLDOFF);
+ enr_bold_on = 0;
+ }
+
+ /* Make sure we end with a newline so everything gets flushed */
+ GF_PUTC(f->next, '\015');
+ GF_PUTC(f->next, '\012');
+
+ fs_give((void **)&(f->line));
+
+ (void) GF_FLUSH(f->next);
+ (*f->next->f)(f->next, GF_EOD);
+ }
+ else if(flg == GF_RESET){
+ dprint((9, "-- gf_reset enriched2plain\n"));
+ f->f1 = DFL; /* state */
+ f->f2 = 0; /* set means we're in a comment */
+ f->linep = f->line = (char *)fs_get(65 * sizeof(char));
+ }
+}
+
+
+/*
+ * function called from the outside to set
+ * richtext filter's options
+ */
+void *
+gf_enriched2plain_opt(int *plain)
+{
+ return((void *) plain);
+}
+
+
+
+/*
+ * HTML-TO-PLAIN text filter
+ */
+
+
+/* OK, here's the plan:
+
+ * a universal output function handles writing chars and worries
+ * about wrapping.
+
+ * a unversal element collector reads chars and collects params
+ * and dispatches the appropriate element handler.
+
+ * element handlers are stacked. The most recently dispatched gets
+ * first crack at the incoming character stream. It passes bytes it's
+ * done with or not interested in to the next
+
+ * installs that handler as the current one collecting data...
+
+ * stacked handlers take their params from the element collector and
+ * accept chars or do whatever they need to do. Sort of a vertical
+ * piping? recursion-like? hmmm.
+
+ * at least I think this is how it'll work. tres simple, non?
+
+ */
+
+
+/*
+ * Some important constants
+ */
+#define HTML_BUF_LEN 2048 /* max scratch buffer length */
+#define MAX_ENTITY 20 /* maximum length of an entity */
+#define MAX_ELEMENT 72 /* maximum length of an element */
+#define HTML_MOREDATA 0 /* expect more entity data */
+#define HTML_ENTITY 1 /* valid entity collected */
+#define HTML_BADVALUE 0x0100 /* good data, but bad entity value */
+#define HTML_BADDATA 0x0200 /* bad data found looking for entity */
+#define HTML_LITERAL 0x0400 /* Literal character value */
+#define HTML_NEWLINE 0x010A /* hard newline */
+#define HTML_DOBOLD 0x0400 /* Start Bold display */
+#define HTML_ID_GET 0 /* indent func: return current val */
+#define HTML_ID_SET 1 /* indent func: set to absolute val */
+#define HTML_ID_INC 2 /* indent func: increment by val */
+#define HTML_HX_CENTER 0x0001
+#define HTML_HX_ULINE 0x0002
+#define RSS_ITEM_LIMIT 20 /* RSS 2.0 ITEM depth limit */
+
+
+/*
+ * Handler data, state information including function that uses it
+ */
+typedef struct handler_s {
+ FILTER_S *html_data;
+ void *element;
+ long x, y, z;
+ void *dp;
+ unsigned char *s;
+ struct handler_s *below;
+} HANDLER_S;
+
+/*
+ * Element Property structure
+ */
+typedef struct _element_properties {
+ char *element;
+ int (*handler)(HANDLER_S *, int, int);
+ unsigned blocklevel:1;
+} ELPROP_S;
+
+/*
+ * Types used to manage HTML parsing
+ */
+static void html_handoff(HANDLER_S *, int);
+
+
+/*
+ * to help manage line wrapping.
+ */
+typedef struct _wrap_line {
+ char *buf; /* buf to collect wrapped text */
+ int used, /* number of chars in buf */
+ width, /* text's width as displayed */
+ len; /* length of allocated buf */
+} WRAPLINE_S;
+
+
+/*
+ * to help manage centered text
+ */
+typedef struct _center_s {
+ WRAPLINE_S line; /* buf to assembled centered text */
+ WRAPLINE_S word; /* word being to append to Line */
+ int anchor;
+ short space;
+} CENTER_S;
+
+
+/*
+ * Collector data and state information
+ */
+typedef struct collector_s {
+ char buf[HTML_BUF_LEN]; /* buffer to collect data */
+ int len; /* length of that buffer */
+ unsigned end_tag:1; /* collecting a closing tag */
+ unsigned hit_equal:1; /* collecting right half of attrib */
+ unsigned mkup_decl:1; /* markup declaration */
+ unsigned start_comment:1; /* markup declaration comment */
+ unsigned end_comment:1; /* legit comment format */
+ unsigned hyphen:1; /* markup hyphen read */
+ unsigned badform:1; /* malformed markup element */
+ unsigned overrun:1; /* Overran buf above */
+ unsigned proc_inst:1; /* XML processing instructions */
+ unsigned empty:1; /* empty element */
+ unsigned was_quoted:1; /* basically to catch null string */
+ char quoted; /* quoted element param value */
+ char *element; /* element's collected name */
+ PARAMETER *attribs; /* element's collected attributes */
+ PARAMETER *cur_attrib; /* attribute now being collected */
+} CLCTR_S;
+
+
+/*
+ * State information for all element handlers
+ */
+typedef struct html_data {
+ HANDLER_S *h_stack; /* handler list */
+ CLCTR_S *el_data; /* element collector data */
+ CENTER_S *centered; /* struct to manage centered text */
+ int (*token)(FILTER_S *, int);
+ char quoted; /* quoted, by either ' or ", text */
+ short indent_level; /* levels of indention */
+ int in_anchor; /* text now being written to anchor */
+ int blanks; /* Consecutive blank line count */
+ int wrapcol; /* column to wrap lines on */
+ int *prefix; /* buffer containing Anchor prefix */
+ int prefix_used;
+ long line_bufsize; /* current size of the line buffer */
+ COLOR_PAIR *color;
+ struct {
+ int state; /* embedded data state */
+ char *color; /* embedded color pointer */
+ } embedded;
+ CBUF_S cb; /* utf8->ucs4 conversion state */
+ unsigned wrapstate:1; /* whether or not to wrap output */
+ unsigned li_pending:1; /* <LI> next token expected */
+ unsigned de_pending:1; /* <DT> or <DD> next token expected */
+ unsigned bold_on:1; /* currently bolding text */
+ unsigned uline_on:1; /* currently underlining text */
+ unsigned center:1; /* center output text */
+ unsigned bitbucket:1; /* Ignore input */
+ unsigned head:1; /* In doc's HEAD */
+ unsigned body:1; /* In doc's BODY */
+ unsigned alt_entity:1; /* use alternative entity values */
+ unsigned wrote:1; /* anything witten yet? */
+} HTML_DATA_S;
+
+
+/*
+ * HTML filter options
+ */
+typedef struct _html_opts {
+ char *base; /* Base URL for this html file */
+ int columns, /* Display columns (excluding margins) */
+ indent; /* Left margin */
+ HANDLE_S **handlesp; /* Head of handles */
+ htmlrisk_t warnrisk_f; /* Nasty link warning call */
+ ELPROP_S *element_table; /* markup element table */
+ RSS_FEED_S **feedp; /* hook for RSS feed response */
+ unsigned strip:1; /* Hilite TAGs allowed */
+ unsigned handles_loc:1; /* Local handles requested? */
+ unsigned showserver:1; /* Display server after anchors */
+ unsigned outputted:1; /* any */
+ unsigned no_relative_links:1; /* Disable embeded relative links */
+ unsigned related_content:1; /* Embeded related content */
+ unsigned html:1; /* Output content in HTML */
+ unsigned html_imgs:1; /* Output IMG tags in HTML content */
+} HTML_OPT_S;
+
+
+
+/*
+ * Some macros to make life a little easier
+ */
+#define WRAP_COLS(X) ((X)->opt ? ((HTML_OPT_S *)(X)->opt)->columns : 80)
+#define HTML_INDENT(X) ((X)->opt ? ((HTML_OPT_S *)(X)->opt)->indent : 0)
+#define HTML_WROTE(X) (HD(X)->wrote)
+#define HTML_BASE(X) ((X)->opt ? ((HTML_OPT_S *)(X)->opt)->base : NULL)
+#define STRIP(X) ((X)->opt && ((HTML_OPT_S *)(X)->opt)->strip)
+#define PASS_HTML(X) ((X)->opt && ((HTML_OPT_S *)(X)->opt)->html)
+#define PASS_IMAGES(X) ((X)->opt && ((HTML_OPT_S *)(X)->opt)->html_imgs)
+#define HANDLESP(X) (((HTML_OPT_S *)(X)->opt)->handlesp)
+#define DO_HANDLES(X) ((X)->opt && HANDLESP(X))
+#define HANDLES_LOC(X) ((X)->opt && ((HTML_OPT_S *)(X)->opt)->handles_loc)
+#define SHOWSERVER(X) ((X)->opt && ((HTML_OPT_S *)(X)->opt)->showserver)
+#define NO_RELATIVE(X) ((X)->opt && ((HTML_OPT_S *)(X)->opt)->no_relative_links)
+#define RELATED_OK(X) ((X)->opt && ((HTML_OPT_S *)(X)->opt)->related_content)
+#define ELEMENTS(X) (((HTML_OPT_S *)(X)->opt)->element_table)
+#define RSS_FEED(X) (*(((HTML_OPT_S *)(X)->opt)->feedp))
+#define MAKE_LITERAL(C) (HTML_LITERAL | ((C) & 0xff))
+#define IS_LITERAL(C) (HTML_LITERAL & (C))
+#define HD(X) ((HTML_DATA_S *)(X)->data)
+#define ED(X) (HD(X)->el_data)
+#define EL(X) ((ELPROP_S *) (X)->element)
+#define ASCII_ISSPACE(C) ((C) < 0x80 && isspace((unsigned char) (C)))
+#define HTML_ISSPACE(C) (IS_LITERAL(C) == 0 && ((C) == HTML_NEWLINE || ASCII_ISSPACE(C)))
+#define NEW_CLCTR(X) { \
+ ED(X) = (CLCTR_S *)fs_get(sizeof(CLCTR_S)); \
+ memset(ED(X), 0, sizeof(CLCTR_S)); \
+ HD(X)->token = html_element_collector; \
+ }
+
+#define FREE_CLCTR(X) { \
+ if(ED(X)->attribs){ \
+ PARAMETER *p; \
+ while((p = ED(X)->attribs) != NULL){ \
+ ED(X)->attribs = ED(X)->attribs->next; \
+ if(p->attribute) \
+ fs_give((void **)&p->attribute); \
+ if(p->value) \
+ fs_give((void **)&p->value); \
+ fs_give((void **)&p); \
+ } \
+ } \
+ if(ED(X)->element) \
+ fs_give((void **) &ED(X)->element); \
+ fs_give((void **) &ED(X)); \
+ HD(X)->token = NULL; \
+ }
+#define HANDLERS(X) (HD(X)->h_stack)
+#define BOLD_BIT(X) (HD(X)->bold_on)
+#define ULINE_BIT(X) (HD(X)->uline_on)
+#define CENTER_BIT(X) (HD(X)->center)
+#define HTML_FLUSH(X) { \
+ html_write(X, (X)->line, (X)->linep - (X)->line); \
+ (X)->linep = (X)->line; \
+ (X)->f2 = 0L; \
+ }
+#define HTML_BOLD(X, S) if(! STRIP(X)){ \
+ if((S)){ \
+ html_output((X), TAG_EMBED); \
+ html_output((X), TAG_BOLDON); \
+ } \
+ else if(!(S)){ \
+ html_output((X), TAG_EMBED); \
+ html_output((X), TAG_BOLDOFF); \
+ } \
+ }
+#define HTML_ULINE(X, S) \
+ if(! STRIP(X)){ \
+ if((S)){ \
+ html_output((X), TAG_EMBED); \
+ html_output((X), TAG_ULINEON); \
+ } \
+ else if(!(S)){ \
+ html_output((X), TAG_EMBED); \
+ html_output((X), TAG_ULINEOFF); \
+ } \
+ }
+#define HTML_ITALIC(X, S) \
+ if(! STRIP(X)){ \
+ if(S){ \
+ html_output((X), TAG_EMBED); \
+ html_output((X), TAG_ITALICON); \
+ } \
+ else if(!(S)){ \
+ html_output((X), TAG_EMBED); \
+ html_output((X), TAG_ITALICOFF); \
+ } \
+ }
+#define HTML_STRIKE(X, S) \
+ if(! STRIP(X)){ \
+ if(S){ \
+ html_output((X), TAG_EMBED); \
+ html_output((X), TAG_STRIKEON); \
+ } \
+ else if(!(S)){ \
+ html_output((X), TAG_EMBED); \
+ html_output((X), TAG_STRIKEOFF); \
+ } \
+ }
+#define HTML_BIG(X, S) \
+ if(! STRIP(X)){ \
+ if(S){ \
+ html_output((X), TAG_EMBED); \
+ html_output((X), TAG_BIGON); \
+ } \
+ else if(!(S)){ \
+ html_output((X), TAG_EMBED); \
+ html_output((X), TAG_BIGOFF); \
+ } \
+ }
+#define HTML_SMALL(X, S) \
+ if(! STRIP(X)){ \
+ if(S){ \
+ html_output((X), TAG_EMBED); \
+ html_output((X), TAG_SMALLON); \
+ } \
+ else if(!(S)){ \
+ html_output((X), TAG_EMBED); \
+ html_output((X), TAG_SMALLOFF); \
+ } \
+ }
+#define WRAPPED_LEN(X) ((HD(f)->centered) \
+ ? (HD(f)->centered->line.width \
+ + HD(f)->centered->word.width \
+ + ((HD(f)->centered->line.width \
+ && HD(f)->centered->word.width) \
+ ? 1 : 0)) \
+ : 0)
+#define HTML_DUMP_LIT(F, S, L) { \
+ int i, c; \
+ for(i = 0; i < (L); i++){ \
+ c = ASCII_ISSPACE((unsigned char)(S)[i]) \
+ ? (S)[i] \
+ : MAKE_LITERAL((S)[i]); \
+ HTML_TEXT(F, c); \
+ } \
+ }
+#define HTML_PROC(F, C) { \
+ if(HD(F)->token){ \
+ int i; \
+ if((i = (*(HD(F)->token))(F, C)) != 0){ \
+ if(i < 0){ \
+ HTML_DUMP_LIT(F, "<", 1); \
+ if(HD(F)->el_data->element){ \
+ HTML_DUMP_LIT(F, \
+ HD(F)->el_data->element, \
+ strlen(HD(F)->el_data->element));\
+ } \
+ if(HD(F)->el_data->len){ \
+ HTML_DUMP_LIT(F, \
+ HD(F)->el_data->buf, \
+ HD(F)->el_data->len); \
+ } \
+ HTML_TEXT(F, C); \
+ } \
+ FREE_CLCTR(F); \
+ } \
+ } \
+ else if((C) == '<'){ \
+ NEW_CLCTR(F); \
+ } \
+ else \
+ HTML_TEXT(F, C); \
+ }
+#define HTML_LINEP_PUTC(F, C) { \
+ if((F)->linep - (F)->line >= (HD(F)->line_bufsize - 1)){ \
+ size_t offset = (F)->linep - (F)->line; \
+ fs_resize((void **) &(F)->line, \
+ (HD(F)->line_bufsize * 2) * sizeof(char)); \
+ HD(F)->line_bufsize *= 2; \
+ (F)->linep = &(F)->line[offset]; \
+ } \
+ *(F)->linep++ = (C); \
+ }
+#define HTML_TEXT(F, C) switch((F)->f1){ \
+ case WSPACE : \
+ if(HTML_ISSPACE(C)) /* ignore repeated WS */ \
+ break; \
+ HTML_TEXT_OUT(F, ' '); \
+ (F)->f1 = DFL;/* stop sending chars here */ \
+ /* fall thru to process 'c' */ \
+ case DFL: \
+ if(HD(F)->bitbucket) \
+ (F)->f1 = DFL; /* no op */ \
+ else if(HTML_ISSPACE(C) && HD(F)->wrapstate) \
+ (F)->f1 = WSPACE;/* coalesce white space */ \
+ else HTML_TEXT_OUT(F, C); \
+ break; \
+ }
+#define HTML_TEXT_OUT(F, C) if(HANDLERS(F)) /* let handlers see C */ \
+ (*EL(HANDLERS(F))->handler)(HANDLERS(F),(C),GF_DATA); \
+ else \
+ html_output(F, C);
+#ifdef DEBUG
+#define HTML_DEBUG_EL(S, D) { \
+ dprint((5, "-- html %s: %s\n", \
+ S ? S : "?", \
+ (D)->element \
+ ? (D)->element : "NULL")); \
+ if(debug > 5){ \
+ PARAMETER *p; \
+ for(p = (D)->attribs; \
+ p && p->attribute; \
+ p = p->next) \
+ dprint((6, \
+ " PARM: %s%s%s\n", \
+ p->attribute \
+ ? p->attribute : "NULL",\
+ p->value ? "=" : "", \
+ p->value ? p->value : ""));\
+ } \
+ }
+#else
+#define HTML_DEBUG_EL(S, D)
+#endif
+
+#ifndef SYSTEM_PINE_INFO_PATH
+#define SYSTEM_PINE_INFO_PATH "/usr/local/lib/pine.info"
+#endif
+#define CHTML_VAR_EXPAND(S) (!strcmp(S, "PINE_INFO_PATH") \
+ ? SYSTEM_PINE_INFO_PATH : S)
+
+/*
+ * Protos for Tag handlers
+ */
+int html_head(HANDLER_S *, int, int);
+int html_base(HANDLER_S *, int, int);
+int html_title(HANDLER_S *, int, int);
+int html_body(HANDLER_S *, int, int);
+int html_a(HANDLER_S *, int, int);
+int html_br(HANDLER_S *, int, int);
+int html_hr(HANDLER_S *, int, int);
+int html_p(HANDLER_S *, int, int);
+int html_table(HANDLER_S *, int, int);
+int html_caption(HANDLER_S *, int, int);
+int html_tr(HANDLER_S *, int, int);
+int html_td(HANDLER_S *, int, int);
+int html_th(HANDLER_S *, int, int);
+int html_thead(HANDLER_S *, int, int);
+int html_tbody(HANDLER_S *, int, int);
+int html_tfoot(HANDLER_S *, int, int);
+int html_col(HANDLER_S *, int, int);
+int html_colgroup(HANDLER_S *, int, int);
+int html_b(HANDLER_S *, int, int);
+int html_u(HANDLER_S *, int, int);
+int html_i(HANDLER_S *, int, int);
+int html_em(HANDLER_S *, int, int);
+int html_strong(HANDLER_S *, int, int);
+int html_s(HANDLER_S *, int, int);
+int html_big(HANDLER_S *, int, int);
+int html_small(HANDLER_S *, int, int);
+int html_font(HANDLER_S *, int, int);
+int html_img(HANDLER_S *, int, int);
+int html_map(HANDLER_S *, int, int);
+int html_area(HANDLER_S *, int, int);
+int html_form(HANDLER_S *, int, int);
+int html_input(HANDLER_S *, int, int);
+int html_option(HANDLER_S *, int, int);
+int html_optgroup(HANDLER_S *, int, int);
+int html_button(HANDLER_S *, int, int);
+int html_select(HANDLER_S *, int, int);
+int html_textarea(HANDLER_S *, int, int);
+int html_label(HANDLER_S *, int, int);
+int html_fieldset(HANDLER_S *, int, int);
+int html_ul(HANDLER_S *, int, int);
+int html_ol(HANDLER_S *, int, int);
+int html_menu(HANDLER_S *, int, int);
+int html_dir(HANDLER_S *, int, int);
+int html_li(HANDLER_S *, int, int);
+int html_h1(HANDLER_S *, int, int);
+int html_h2(HANDLER_S *, int, int);
+int html_h3(HANDLER_S *, int, int);
+int html_h4(HANDLER_S *, int, int);
+int html_h5(HANDLER_S *, int, int);
+int html_h6(HANDLER_S *, int, int);
+int html_blockquote(HANDLER_S *, int, int);
+int html_address(HANDLER_S *, int, int);
+int html_pre(HANDLER_S *, int, int);
+int html_center(HANDLER_S *, int, int);
+int html_div(HANDLER_S *, int, int);
+int html_span(HANDLER_S *, int, int);
+int html_dl(HANDLER_S *, int, int);
+int html_dt(HANDLER_S *, int, int);
+int html_dd(HANDLER_S *, int, int);
+int html_script(HANDLER_S *, int, int);
+int html_applet(HANDLER_S *, int, int);
+int html_style(HANDLER_S *, int, int);
+int html_kbd(HANDLER_S *, int, int);
+int html_dfn(HANDLER_S *, int, int);
+int html_var(HANDLER_S *, int, int);
+int html_tt(HANDLER_S *, int, int);
+int html_samp(HANDLER_S *, int, int);
+int html_sub(HANDLER_S *, int, int);
+int html_sup(HANDLER_S *, int, int);
+int html_cite(HANDLER_S *, int, int);
+int html_code(HANDLER_S *, int, int);
+int html_ins(HANDLER_S *, int, int);
+int html_del(HANDLER_S *, int, int);
+int html_abbr(HANDLER_S *, int, int);
+
+/*
+ * Protos for RSS 2.0 Tag handlers
+ */
+int rss_rss(HANDLER_S *, int, int);
+int rss_channel(HANDLER_S *, int, int);
+int rss_title(HANDLER_S *, int, int);
+int rss_image(HANDLER_S *, int, int);
+int rss_link(HANDLER_S *, int, int);
+int rss_description(HANDLER_S *, int, int);
+int rss_ttl(HANDLER_S *, int, int);
+int rss_item(HANDLER_S *, int, int);
+
+/*
+ * Proto's for support routines
+ */
+void html_pop(FILTER_S *, ELPROP_S *);
+int html_push(FILTER_S *, ELPROP_S *);
+int html_element_collector(FILTER_S *, int);
+int html_element_flush(CLCTR_S *);
+void html_element_comment(FILTER_S *, char *);
+void html_element_output(FILTER_S *, int);
+int html_entity_collector(FILTER_S *, int, UCS *, char **);
+void html_a_prefix(FILTER_S *);
+void html_a_finish(HANDLER_S *);
+void html_a_output_prefix(FILTER_S *, int);
+void html_a_output_info(HANDLER_S *);
+void html_a_relative(char *, char *, HANDLE_S *);
+int html_href_relative(char *);
+int html_indent(FILTER_S *, int, int);
+void html_blank(FILTER_S *, int);
+void html_newline(FILTER_S *);
+void html_output(FILTER_S *, int);
+void html_output_string(FILTER_S *, char *);
+void html_output_raw_tag(FILTER_S *, char *);
+void html_output_normal(FILTER_S *, int, int);
+void html_output_flush(FILTER_S *);
+void html_output_centered(FILTER_S *, int, int);
+void html_centered_handle(int *, char *, int);
+void html_centered_putc(WRAPLINE_S *, int);
+void html_centered_flush(FILTER_S *);
+void html_centered_flush_line(FILTER_S *);
+void html_write_anchor(FILTER_S *, int);
+void html_write_newline(FILTER_S *);
+void html_write_indent(FILTER_S *, int);
+void html_write(FILTER_S *, char *, int);
+void html_putc(FILTER_S *, int);
+int html_event_attribute(char *);
+char *rss_skip_whitespace(char *s);
+ELPROP_S *element_properties(FILTER_S *, char *);
+
+
+/*
+ * Named entity table -- most from HTML 2.0 (rfc1866) plus some from
+ * W3C doc "Additional named entities for HTML"
+ */
+static struct html_entities {
+ char *name; /* entity name */
+ UCS value; /* UCS entity value */
+ char *plain; /* US-ASCII representation */
+} entity_tab[] = {
+ {"quot", 0x0022}, /* 34 - quotation mark */
+ {"amp", 0x0026}, /* 38 - ampersand */
+ {"apos", 0x0027}, /* 39 - apostrophe */
+ {"lt", 0x003C}, /* 60 - less-than sign */
+ {"gt", 0x003E}, /* 62 - greater-than sign */
+ {"nbsp", 0x00A0, " "}, /* 160 - no-break space */
+ {"iexcl", 0x00A1}, /* 161 - inverted exclamation mark */
+ {"cent", 0x00A2}, /* 162 - cent sign */
+ {"pound", 0x00A3}, /* 163 - pound sign */
+ {"curren", 0x00A4, "CUR"}, /* 164 - currency sign */
+ {"yen", 0x00A5}, /* 165 - yen sign */
+ {"brvbar", 0x00A6, "|"}, /* 166 - broken bar */
+ {"sect", 0x00A7}, /* 167 - section sign */
+ {"uml", 0x00A8, "\""}, /* 168 - diaeresis */
+ {"copy", 0x00A9, "(C)"}, /* 169 - copyright sign */
+ {"ordf", 0x00AA, "a"}, /* 170 - feminine ordinal indicator */
+ {"laquo", 0x00AB, "<<"}, /* 171 - left-pointing double angle quotation mark */
+ {"not", 0x00AC, "NOT"}, /* 172 - not sign */
+ {"shy", 0x00AD, "-"}, /* 173 - soft hyphen */
+ {"reg", 0x00AE, "(R)"}, /* 174 - registered sign */
+ {"macr", 0x00AF}, /* 175 - macron */
+ {"deg", 0x00B0, "DEG"}, /* 176 - degree sign */
+ {"plusmn", 0x00B1, "+/-"}, /* 177 - plus-minus sign */
+ {"sup2", 0x00B2}, /* 178 - superscript two */
+ {"sup3", 0x00B3}, /* 179 - superscript three */
+ {"acute", 0x00B4, "'"}, /* 180 - acute accent */
+ {"micro", 0x00B5}, /* 181 - micro sign */
+ {"para", 0x00B6}, /* 182 - pilcrow sign */
+ {"middot", 0x00B7}, /* 183 - middle dot */
+ {"cedil", 0x00B8}, /* 184 - cedilla */
+ {"sup1", 0x00B9}, /* 185 - superscript one */
+ {"ordm", 0x00BA, "o"}, /* 186 - masculine ordinal indicator */
+ {"raquo", 0x00BB, ">>"}, /* 187 - right-pointing double angle quotation mark */
+ {"frac14", 0x00BC, " 1/4"}, /* 188 - vulgar fraction one quarter */
+ {"frac12", 0x00BD, " 1/2"}, /* 189 - vulgar fraction one half */
+ {"frac34", 0x00BE, " 3/4"}, /* 190 - vulgar fraction three quarters */
+ {"iquest", 0x00BF}, /* 191 - inverted question mark */
+ {"Agrave", 0x00C0, "A"}, /* 192 - latin capital letter a with grave */
+ {"Aacute", 0x00C1, "A"}, /* 193 - latin capital letter a with acute */
+ {"Acirc", 0x00C2, "A"}, /* 194 - latin capital letter a with circumflex */
+ {"Atilde", 0x00C3, "A"}, /* 195 - latin capital letter a with tilde */
+ {"Auml", 0x00C4, "AE"}, /* 196 - latin capital letter a with diaeresis */
+ {"Aring", 0x00C5, "A"}, /* 197 - latin capital letter a with ring above */
+ {"AElig", 0x00C6, "AE"}, /* 198 - latin capital letter ae */
+ {"Ccedil", 0x00C7, "C"}, /* 199 - latin capital letter c with cedilla */
+ {"Egrave", 0x00C8, "E"}, /* 200 - latin capital letter e with grave */
+ {"Eacute", 0x00C9, "E"}, /* 201 - latin capital letter e with acute */
+ {"Ecirc", 0x00CA, "E"}, /* 202 - latin capital letter e with circumflex */
+ {"Euml", 0x00CB, "E"}, /* 203 - latin capital letter e with diaeresis */
+ {"Igrave", 0x00CC, "I"}, /* 204 - latin capital letter i with grave */
+ {"Iacute", 0x00CD, "I"}, /* 205 - latin capital letter i with acute */
+ {"Icirc", 0x00CE, "I"}, /* 206 - latin capital letter i with circumflex */
+ {"Iuml", 0x00CF, "I"}, /* 207 - latin capital letter i with diaeresis */
+ {"ETH", 0x00D0, "DH"}, /* 208 - latin capital letter eth */
+ {"Ntilde", 0x00D1, "N"}, /* 209 - latin capital letter n with tilde */
+ {"Ograve", 0x00D2, "O"}, /* 210 - latin capital letter o with grave */
+ {"Oacute", 0x00D3, "O"}, /* 211 - latin capital letter o with acute */
+ {"Ocirc", 0x00D4, "O"}, /* 212 - latin capital letter o with circumflex */
+ {"Otilde", 0x00D5, "O"}, /* 213 - latin capital letter o with tilde */
+ {"Ouml", 0x00D6, "O"}, /* 214 - latin capital letter o with diaeresis */
+ {"times", 0x00D7, "x"}, /* 215 - multiplication sign */
+ {"Oslash", 0x00D8, "O"}, /* 216 - latin capital letter o with stroke */
+ {"Ugrave", 0x00D9, "U"}, /* 217 - latin capital letter u with grave */
+ {"Uacute", 0x00DA, "U"}, /* 218 - latin capital letter u with acute */
+ {"Ucirc", 0x00DB, "U"}, /* 219 - latin capital letter u with circumflex */
+ {"Uuml", 0x00DC, "UE"}, /* 220 - latin capital letter u with diaeresis */
+ {"Yacute", 0x00DD, "Y"}, /* 221 - latin capital letter y with acute */
+ {"THORN", 0x00DE, "P"}, /* 222 - latin capital letter thorn */
+ {"szlig", 0x00DF, "ss"}, /* 223 - latin small letter sharp s (German <a href="/wiki/Eszett" title="Eszett">Eszett</a>) */
+ {"agrave", 0x00E0, "a"}, /* 224 - latin small letter a with grave */
+ {"aacute", 0x00E1, "a"}, /* 225 - latin small letter a with acute */
+ {"acirc", 0x00E2, "a"}, /* 226 - latin small letter a with circumflex */
+ {"atilde", 0x00E3, "a"}, /* 227 - latin small letter a with tilde */
+ {"auml", 0x00E4, "ae"}, /* 228 - latin small letter a with diaeresis */
+ {"aring", 0x00E5, "a"}, /* 229 - latin small letter a with ring above */
+ {"aelig", 0x00E6, "ae"}, /* 230 - latin lowercase ligature ae */
+ {"ccedil", 0x00E7, "c"}, /* 231 - latin small letter c with cedilla */
+ {"egrave", 0x00E8, "e"}, /* 232 - latin small letter e with grave */
+ {"eacute", 0x00E9, "e"}, /* 233 - latin small letter e with acute */
+ {"ecirc", 0x00EA, "e"}, /* 234 - latin small letter e with circumflex */
+ {"euml", 0x00EB, "e"}, /* 235 - latin small letter e with diaeresis */
+ {"igrave", 0x00EC, "i"}, /* 236 - latin small letter i with grave */
+ {"iacute", 0x00ED, "i"}, /* 237 - latin small letter i with acute */
+ {"icirc", 0x00EE, "i"}, /* 238 - latin small letter i with circumflex */
+ {"iuml", 0x00EF, "i"}, /* 239 - latin small letter i with diaeresis */
+ {"eth", 0x00F0, "dh"}, /* 240 - latin small letter eth */
+ {"ntilde", 0x00F1, "n"}, /* 241 - latin small letter n with tilde */
+ {"ograve", 0x00F2, "o"}, /* 242 - latin small letter o with grave */
+ {"oacute", 0x00F3, "o"}, /* 243 - latin small letter o with acute */
+ {"ocirc", 0x00F4, "o"}, /* 244 - latin small letter o with circumflex */
+ {"otilde", 0x00F5, "o"}, /* 245 - latin small letter o with tilde */
+ {"ouml", 0x00F6, "oe"}, /* 246 - latin small letter o with diaeresis */
+ {"divide", 0x00F7, "/"}, /* 247 - division sign */
+ {"oslash", 0x00F8, "o"}, /* 248 - latin small letter o with stroke */
+ {"ugrave", 0x00F9, "u"}, /* 249 - latin small letter u with grave */
+ {"uacute", 0x00FA, "u"}, /* 250 - latin small letter u with acute */
+ {"ucirc", 0x00FB, "u"}, /* 251 - latin small letter u with circumflex */
+ {"uuml", 0x00FC, "ue"}, /* 252 - latin small letter u with diaeresis */
+ {"yacute", 0x00FD, "y"}, /* 253 - latin small letter y with acute */
+ {"thorn", 0x00FE, "p"}, /* 254 - latin small letter thorn */
+ {"yuml", 0x00FF, "y"}, /* 255 - latin small letter y with diaeresis */
+ {"OElig", 0x0152, "OE"}, /* 338 - latin capital ligature oe */
+ {"oelig", 0x0153, "oe"}, /* 339 - latin small ligature oe */
+ {"Scaron", 0x0160, "S"}, /* 352 - latin capital letter s with caron */
+ {"scaron", 0x0161, "s"}, /* 353 - latin small letter s with caron */
+ {"Yuml", 0x0178, "Y"}, /* 376 - latin capital letter y with diaeresis */
+ {"fnof", 0x0192, "f"}, /* 402 - latin small letter f with hook */
+ {"circ", 0x02C6}, /* 710 - modifier letter circumflex accent */
+ {"tilde", 0x02DC, "~"}, /* 732 - small tilde */
+ {"Alpha", 0x0391}, /* 913 - greek capital letter alpha */
+ {"Beta", 0x0392}, /* 914 - greek capital letter beta */
+ {"Gamma", 0x0393}, /* 915 - greek capital letter gamma */
+ {"Delta", 0x0394}, /* 916 - greek capital letter delta */
+ {"Epsilon", 0x0395}, /* 917 - greek capital letter epsilon */
+ {"Zeta", 0x0396}, /* 918 - greek capital letter zeta */
+ {"Eta", 0x0397}, /* 919 - greek capital letter eta */
+ {"Theta", 0x0398}, /* 920 - greek capital letter theta */
+ {"Iota", 0x0399}, /* 921 - greek capital letter iota */
+ {"Kappa", 0x039A}, /* 922 - greek capital letter kappa */
+ {"Lambda", 0x039B}, /* 923 - greek capital letter lamda */
+ {"Mu", 0x039C}, /* 924 - greek capital letter mu */
+ {"Nu", 0x039D}, /* 925 - greek capital letter nu */
+ {"Xi", 0x039E}, /* 926 - greek capital letter xi */
+ {"Omicron", 0x039F}, /* 927 - greek capital letter omicron */
+ {"Pi", 0x03A0}, /* 928 - greek capital letter pi */
+ {"Rho", 0x03A1}, /* 929 - greek capital letter rho */
+ {"Sigma", 0x03A3}, /* 931 - greek capital letter sigma */
+ {"Tau", 0x03A4}, /* 932 - greek capital letter tau */
+ {"Upsilon", 0x03A5}, /* 933 - greek capital letter upsilon */
+ {"Phi", 0x03A6}, /* 934 - greek capital letter phi */
+ {"Chi", 0x03A7}, /* 935 - greek capital letter chi */
+ {"Psi", 0x03A8}, /* 936 - greek capital letter psi */
+ {"Omega", 0x03A9}, /* 937 - greek capital letter omega */
+ {"alpha", 0x03B1}, /* 945 - greek small letter alpha */
+ {"beta", 0x03B2}, /* 946 - greek small letter beta */
+ {"gamma", 0x03B3}, /* 947 - greek small letter gamma */
+ {"delta", 0x03B4}, /* 948 - greek small letter delta */
+ {"epsilon", 0x03B5}, /* 949 - greek small letter epsilon */
+ {"zeta", 0x03B6}, /* 950 - greek small letter zeta */
+ {"eta", 0x03B7}, /* 951 - greek small letter eta */
+ {"theta", 0x03B8}, /* 952 - greek small letter theta */
+ {"iota", 0x03B9}, /* 953 - greek small letter iota */
+ {"kappa", 0x03BA}, /* 954 - greek small letter kappa */
+ {"lambda", 0x03BB}, /* 955 - greek small letter lamda */
+ {"mu", 0x03BC}, /* 956 - greek small letter mu */
+ {"nu", 0x03BD}, /* 957 - greek small letter nu */
+ {"xi", 0x03BE}, /* 958 - greek small letter xi */
+ {"omicron", 0x03BF}, /* 959 - greek small letter omicron */
+ {"pi", 0x03C0}, /* 960 - greek small letter pi */
+ {"rho", 0x03C1}, /* 961 - greek small letter rho */
+ {"sigmaf", 0x03C2}, /* 962 - greek small letter final sigma */
+ {"sigma", 0x03C3}, /* 963 - greek small letter sigma */
+ {"tau", 0x03C4}, /* 964 - greek small letter tau */
+ {"upsilon", 0x03C5}, /* 965 - greek small letter upsilon */
+ {"phi", 0x03C6}, /* 966 - greek small letter phi */
+ {"chi", 0x03C7}, /* 967 - greek small letter chi */
+ {"psi", 0x03C8}, /* 968 - greek small letter psi */
+ {"omega", 0x03C9}, /* 969 - greek small letter omega */
+ {"thetasym", 0x03D1}, /* 977 - greek theta symbol */
+ {"upsih", 0x03D2}, /* 978 - greek upsilon with hook symbol */
+ {"piv", 0x03D6}, /* 982 - greek pi symbol */
+ {"ensp", 0x2002}, /* 8194 - en space */
+ {"emsp", 0x2003}, /* 8195 - em space */
+ {"thinsp", 0x2009}, /* 8201 - thin space */
+ {"zwnj", 0x200C}, /* 8204 - zero width non-joiner */
+ {"zwj", 0x200D}, /* 8205 - zero width joiner */
+ {"lrm", 0x200E}, /* 8206 - left-to-right mark */
+ {"rlm", 0x200F}, /* 8207 - right-to-left mark */
+ {"ndash", 0x2013}, /* 8211 - en dash */
+ {"mdash", 0x2014}, /* 8212 - em dash */
+ {"#8213", 0x2015, "--"}, /* 2015 - horizontal bar */
+ {"#8214", 0x2016, "||"}, /* 2016 - double vertical line */
+ {"#8215", 0x2017, "__"}, /* 2017 - double low line */
+ {"lsquo", 0x2018}, /* 8216 - left single quotation mark */
+ {"rsquo", 0x2019}, /* 8217 - right single quotation mark */
+ {"sbquo", 0x201A}, /* 8218 - single low-9 quotation mark */
+ {"ldquo", 0x201C}, /* 8220 - left double quotation mark */
+ {"rdquo", 0x201D}, /* 8221 - right double quotation mark */
+ {"bdquo", 0x201E, ",,"}, /* 8222 - double low-9 quotation mark */
+ {"#8223", 0x201F, "``"}, /* 201F - double high reversed-9 quotation mark */
+ {"dagger", 0x2020}, /* 8224 - dagger */
+ {"Dagger", 0x2021}, /* 8225 - double dagger */
+ {"bull", 0x2022, "*"}, /* 8226 - bullet */
+ {"hellip", 0x2026}, /* 8230 - horizontal ellipsis */
+ {"permil", 0x2030}, /* 8240 - per mille sign */
+ {"prime", 0x2032, "\'"}, /* 8242 - prime */
+ {"Prime", 0x2033, "\'\'"}, /* 8243 - double prime */
+ {"#8244", 0x2034, "\'\'\'"}, /* 2034 - triple prime */
+ {"lsaquo", 0x2039}, /* 8249 - single left-pointing angle quotation mark */
+ {"rsaquo", 0x203A}, /* 8250 - single right-pointing angle quotation mark */
+ {"#8252", 0x203C, "!!"}, /* 203C - double exclamation mark */
+ {"oline", 0x203E, "-"}, /* 8254 - overline */
+ {"frasl", 0x2044}, /* 8260 - fraction slash */
+ {"#8263", 0x2047, "??"}, /* 2047 - double question mark */
+ {"#8264", 0x2048, "?!"}, /* 2048 - question exclamation mark */
+ {"#8265", 0x2049, "!?"}, /* 2049 - exclamation question mark */
+ {"#8279", 0x2057, "\'\'\'\'"}, /* 2057 - quad prime */
+ {"euro", 0x20AC, "EUR"}, /* 8364 - euro sign */
+ {"image", 0x2111}, /* 8465 - black-letter capital i */
+ {"weierp", 0x2118}, /* 8472 - script capital p (<a href="/wiki/Weierstrass" title="Weierstrass">Weierstrass</a> p) */
+ {"real", 0x211C}, /* 8476 - black-letter capital r */
+ {"trade", 0x2122, "[tm]"}, /* 8482 - trademark sign */
+ {"alefsym", 0x2135}, /* 8501 - alef symbol */
+ {"larr", 0x2190}, /* 8592 - leftwards arrow */
+ {"uarr", 0x2191}, /* 8593 - upwards arrow */
+ {"rarr", 0x2192}, /* 8594 - rightwards arrow */
+ {"darr", 0x2193}, /* 8595 - downwards arrow */
+ {"harr", 0x2194}, /* 8596 - left right arrow */
+ {"crarr", 0x21B5}, /* 8629 - downwards arrow with corner leftwards */
+ {"lArr", 0x21D0}, /* 8656 - leftwards double arrow */
+ {"uArr", 0x21D1}, /* 8657 - upwards double arrow */
+ {"rArr", 0x21D2}, /* 8658 - rightwards double arrow */
+ {"dArr", 0x21D3}, /* 8659 - downwards double arrow */
+ {"hArr", 0x21D4}, /* 8660 - left right double arrow */
+ {"forall", 0x2200}, /* 8704 - for all */
+ {"part", 0x2202}, /* 8706 - partial differential */
+ {"exist", 0x2203}, /* 8707 - there exists */
+ {"empty", 0x2205}, /* 8709 - empty set */
+ {"nabla", 0x2207}, /* 8711 - nabla */
+ {"isin", 0x2208}, /* 8712 - element of */
+ {"notin", 0x2209}, /* 8713 - not an element of */
+ {"ni", 0x220B}, /* 8715 - contains as member */
+ {"prod", 0x220F}, /* 8719 - n-ary product */
+ {"sum", 0x2211}, /* 8721 - n-ary summation */
+ {"minus", 0x2212}, /* 8722 - minus sign */
+ {"lowast", 0x2217}, /* 8727 - asterisk operator */
+ {"radic", 0x221A}, /* 8730 - square root */
+ {"prop", 0x221D}, /* 8733 - proportional to */
+ {"infin", 0x221E}, /* 8734 - infinity */
+ {"ang", 0x2220}, /* 8736 - angle */
+ {"and", 0x2227}, /* 8743 - logical and */
+ {"or", 0x2228}, /* 8744 - logical or */
+ {"cap", 0x2229}, /* 8745 - intersection */
+ {"cup", 0x222A}, /* 8746 - union */
+ {"int", 0x222B}, /* 8747 - integral */
+ {"there4", 0x2234}, /* 8756 - therefore */
+ {"sim", 0x223C}, /* 8764 - tilde operator */
+ {"cong", 0x2245}, /* 8773 - congruent to */
+ {"asymp", 0x2248}, /* 8776 - almost equal to */
+ {"ne", 0x2260}, /* 8800 - not equal to */
+ {"equiv", 0x2261}, /* 8801 - identical to (equivalent to) */
+ {"le", 0x2264}, /* 8804 - less-than or equal to */
+ {"ge", 0x2265}, /* 8805 - greater-than or equal to */
+ {"sub", 0x2282}, /* 8834 - subset of */
+ {"sup", 0x2283}, /* 8835 - superset of */
+ {"nsub", 0x2284}, /* 8836 - not a subset of */
+ {"sube", 0x2286}, /* 8838 - subset of or equal to */
+ {"supe", 0x2287}, /* 8839 - superset of or equal to */
+ {"oplus", 0x2295}, /* 8853 - circled plus */
+ {"otimes", 0x2297}, /* 8855 - circled times */
+ {"perp", 0x22A5}, /* 8869 - up tack */
+ {"sdot", 0x22C5}, /* 8901 - dot operator */
+ {"lceil", 0x2308}, /* 8968 - left ceiling */
+ {"rceil", 0x2309}, /* 8969 - right ceiling */
+ {"lfloor", 0x230A}, /* 8970 - left floor */
+ {"rfloor", 0x230B}, /* 8971 - right floor */
+ {"lang", 0x2329}, /* 9001 - left-pointing angle bracket */
+ {"rang", 0x232A}, /* 9002 - right-pointing angle bracket */
+ {"loz", 0x25CA}, /* 9674 - lozenge */
+ {"spades", 0x2660}, /* 9824 - black spade suit */
+ {"clubs", 0x2663}, /* 9827 - black club suit */
+ {"hearts", 0x2665}, /* 9829 - black heart suit */
+ {"diams", 0x2666} /* 9830 - black diamond suit */
+};
+
+
+/*
+ * Table of supported elements and corresponding handlers
+ */
+static ELPROP_S html_element_table[] = {
+ {"HTML"}, /* HTML ignore if seen? */
+ {"HEAD", html_head}, /* slurp until <BODY> ? */
+ {"TITLE", html_title}, /* Document Title */
+ {"BASE", html_base}, /* HREF base */
+ {"BODY", html_body}, /* HTML BODY */
+ {"A", html_a}, /* Anchor */
+ {"ABBR", html_abbr}, /* Abbreviation */
+ {"IMG", html_img}, /* Image */
+ {"MAP", html_map}, /* Image Map */
+ {"AREA", html_area}, /* Image Map Area */
+ {"HR", html_hr, 1}, /* Horizontal Rule */
+ {"BR", html_br}, /* Line Break */
+ {"P", html_p, 1}, /* Paragraph */
+ {"OL", html_ol, 1}, /* Ordered List */
+ {"UL", html_ul, 1}, /* Unordered List */
+ {"MENU", html_menu}, /* Menu List */
+ {"DIR", html_dir}, /* Directory List */
+ {"LI", html_li}, /* ... List Item */
+ {"DL", html_dl, 1}, /* Definition List */
+ {"DT", html_dt}, /* ... Def. Term */
+ {"DD", html_dd}, /* ... Def. Definition */
+ {"I", html_i}, /* Italic Text */
+ {"EM", html_em}, /* Typographic Emphasis */
+ {"STRONG", html_strong}, /* STRONG Typo Emphasis */
+ {"VAR", html_i}, /* Variable Name */
+ {"B", html_b}, /* Bold Text */
+ {"U", html_u}, /* Underline Text */
+ {"S", html_s}, /* Strike-Through Text */
+ {"STRIKE", html_s}, /* Strike-Through Text */
+ {"BIG", html_big}, /* Big Font Text */
+ {"SMALL", html_small}, /* Small Font Text */
+ {"FONT", html_font}, /* Font display directives */
+ {"BLOCKQUOTE", html_blockquote, 1}, /* Blockquote */
+ {"ADDRESS", html_address, 1}, /* Address */
+ {"CENTER", html_center}, /* Centered Text v3.2 */
+ {"DIV", html_div, 1}, /* Document Division 3.2 */
+ {"SPAN", html_span}, /* Text Span */
+ {"H1", html_h1, 1}, /* Headings... */
+ {"H2", html_h2, 1},
+ {"H3", html_h3,1},
+ {"H4", html_h4, 1},
+ {"H5", html_h5, 1},
+ {"H6", html_h6, 1},
+ {"PRE", html_pre, 1}, /* Preformatted Text */
+ {"KBD", html_kbd}, /* Keyboard Input (NO OP) */
+ {"DFN", html_dfn}, /* Definition (NO OP) */
+ {"VAR", html_var}, /* Variable (NO OP) */
+ {"TT", html_tt}, /* Typetype (NO OP) */
+ {"SAMP", html_samp}, /* Sample Text (NO OP) */
+ {"CITE", html_cite}, /* Citation (NO OP) */
+ {"CODE", html_code}, /* Code Text (NO OP) */
+ {"INS", html_ins}, /* Text Inseted (NO OP) */
+ {"DEL", html_del}, /* Text Deleted (NO OP) */
+ {"SUP", html_sup}, /* Text Superscript (NO OP) */
+ {"SUB", html_sub}, /* Text Superscript (NO OP) */
+ {"STYLE", html_style}, /* CSS Definitions */
+
+/*----- Handlers below UNIMPLEMENTED (and won't until later) -----*/
+
+ {"FORM", html_form, 1}, /* form within a document */
+ {"INPUT", html_input}, /* One input field, options */
+ {"BUTTON", html_button}, /* Push Button */
+ {"OPTION", html_option}, /* One option within Select */
+ {"OPTION", html_optgroup}, /* Option Group Definition */
+ {"SELECT", html_select}, /* Selection from a set */
+ {"TEXTAREA", html_textarea}, /* A multi-line input field */
+ {"LABEL", html_label}, /* Control Label */
+ {"FIELDSET", html_fieldset, 1}, /* Fieldset Control Group */
+
+/*----- Handlers below NEVER TO BE IMPLEMENTED -----*/
+ {"SCRIPT", html_script}, /* Embedded scripting statements */
+ {"APPLET", NULL}, /* Embedded applet statements */
+ {"OBJECT", NULL}, /* Embedded object statements */
+ {"LINK", NULL}, /* References to external data */
+ {"PARAM", NULL}, /* Applet/Object parameters */
+
+/*----- Handlers below provide limited support for RFC 1942 Tables -----*/
+
+ {"TABLE", html_table, 1}, /* Table */
+ {"CAPTION", html_caption}, /* Table Caption */
+ {"TR", html_tr}, /* Table Table Row */
+ {"TD", html_td}, /* Table Table Data */
+ {"TH", html_th}, /* Table Table Head */
+ {"THEAD", html_thead}, /* Table Table Head */
+ {"TBODY", html_tbody}, /* Table Table Body */
+ {"TFOOT", html_tfoot}, /* Table Table Foot */
+ {"COL", html_col}, /* Table Column Attibutes */
+ {"COLGROUP", html_colgroup}, /* Table Column Group Attibutes */
+
+ {NULL, NULL}
+};
+
+
+/*
+ * Table of supported RSS 2.0 elements
+ */
+static ELPROP_S rss_element_table[] = {
+ {"RSS", rss_rss}, /* RSS 2.0 version */
+ {"CHANNEL", rss_channel}, /* RSS 2.0 Channel */
+ {"TITLE", rss_title}, /* RSS 2.0 Title */
+ {"IMAGE", rss_image}, /* RSS 2.0 Channel Image */
+ {"LINK", rss_link}, /* RSS 2.0 Channel/Item Link */
+ {"DESCRIPTION", rss_description}, /* RSS 2.0 Channel/Item Description */
+ {"ITEM", rss_item}, /* RSS 2.0 Channel ITEM */
+ {"TTL", rss_ttl}, /* RSS 2.0 Item TTL */
+ {NULL, NULL}
+};
+
+
+/*
+ * Initialize the given handler, and add it to the stack if it
+ * requests it.
+ *
+ * Returns: 1 if handler chose to get pushed on stack
+ * 0 if handler declined
+ */
+int
+html_push(FILTER_S *fd, ELPROP_S *ep)
+{
+ HANDLER_S *new;
+
+ new = (HANDLER_S *)fs_get(sizeof(HANDLER_S));
+ memset(new, 0, sizeof(HANDLER_S));
+ new->html_data = fd;
+ new->element = ep;
+ if((*ep->handler)(new, 0, GF_RESET)){ /* stack the handler? */
+ new->below = HANDLERS(fd);
+ HANDLERS(fd) = new; /* push */
+ return(1);
+ }
+
+ fs_give((void **) &new);
+ return(0);
+}
+
+
+/*
+ * Remove the most recently installed the given handler
+ * after letting it accept its demise.
+ */
+void
+html_pop(FILTER_S *fd, ELPROP_S *ep)
+{
+ HANDLER_S *tp;
+
+ for(tp = HANDLERS(fd); tp && ep != EL(tp); tp = tp->below){
+ HANDLER_S *tp2;
+ ELPROP_S *ep2;
+
+ dprint((3, "-- html error: bad nesting: given /%s expected /%s", ep->element, EL(tp)->element));
+ /* if no evidence of opening tag, ignore given closing tag */
+ for(tp2 = HANDLERS(fd); tp2 && ep != EL(tp2); tp2 = tp2->below)
+ ;
+
+ if(!tp2){
+ dprint((3, "-- html error: no opening tag for given tag /%s", ep->element));
+ return;
+ }
+
+ (void) (*EL(tp)->handler)(tp, 0, GF_EOD);
+ HANDLERS(fd) = tp->below;
+ }
+
+ if(tp){
+ (void) (*EL(tp)->handler)(tp, 0, GF_EOD); /* may adjust handler list */
+ if(tp != HANDLERS(fd)){
+ HANDLER_S *p;
+
+ for(p = HANDLERS(fd); p->below != tp; p = p->below)
+ ;
+
+ if(p)
+ p->below = tp->below; /* remove from middle of stack */
+ /* BUG: else programming botch and we should die */
+ }
+ else
+ HANDLERS(fd) = tp->below; /* pop */
+
+ fs_give((void **)&tp);
+ }
+ else{
+ /* BUG: should MAKE SURE NOT TO EMIT IT */
+ dprint((3, "-- html error: end tag without a start: %s", ep->element));
+ }
+}
+
+
+/*
+ * Deal with data passed a hander in its GF_DATA state
+ */
+static void
+html_handoff(HANDLER_S *hd, int ch)
+{
+ if(hd->below)
+ (void) (*EL(hd->below)->handler)(hd->below, ch, GF_DATA);
+ else
+ html_output(hd->html_data, ch);
+}
+
+
+/*
+ * HTML <BR> element handler
+ */
+int
+html_br(HANDLER_S *hd, int ch, int cmd)
+{
+ if(cmd == GF_RESET){
+ if(PASS_HTML(hd->html_data)){
+ html_output_raw_tag(hd->html_data, "br");
+ }
+ else{
+ html_output(hd->html_data, HTML_NEWLINE);
+ }
+ }
+
+ return(0); /* don't get linked */
+}
+
+
+/*
+ * HTML <HR> (Horizontal Rule) element handler
+ */
+int
+html_hr(HANDLER_S *hd, int ch, int cmd)
+{
+ if(cmd == GF_RESET){
+ if(PASS_HTML(hd->html_data)){
+ html_output_raw_tag(hd->html_data, "hr");
+ }
+ else{
+ int i, old_wrap, width, align;
+ PARAMETER *p;
+
+ width = WRAP_COLS(hd->html_data);
+ align = 0;
+ for(p = HD(hd->html_data)->el_data->attribs;
+ p && p->attribute;
+ p = p->next)
+ if(p->value){
+ if(!strucmp(p->attribute, "ALIGN")){
+ if(!strucmp(p->value, "LEFT"))
+ align = 1;
+ else if(!strucmp(p->value, "RIGHT"))
+ align = 2;
+ }
+ else if(!strucmp(p->attribute, "WIDTH")){
+ char *cp;
+
+ width = 0;
+ for(cp = p->value; *cp; cp++)
+ if(*cp == '%'){
+ width = (WRAP_COLS(hd->html_data)*MIN(100,width))/100;
+ break;
+ }
+ else if(isdigit((unsigned char) *cp))
+ width = (width * 10) + (*cp - '0');
+
+ width = MIN(width, WRAP_COLS(hd->html_data));
+ }
+ }
+
+ html_blank(hd->html_data, 1); /* at least one blank line */
+
+ old_wrap = HD(hd->html_data)->wrapstate;
+ HD(hd->html_data)->wrapstate = 0;
+ if((i = MAX(0, WRAP_COLS(hd->html_data) - width))
+ && ((align == 0) ? i /= 2 : (align == 2)))
+ for(; i > 0; i--)
+ html_output(hd->html_data, ' ');
+
+ for(i = 0; i < width; i++)
+ html_output(hd->html_data, '_');
+
+ html_blank(hd->html_data, 1);
+ HD(hd->html_data)->wrapstate = old_wrap;
+ }
+ }
+
+ return(0); /* don't get linked */
+}
+
+
+/*
+ * HTML <P> (paragraph) element handler
+ */
+int
+html_p(HANDLER_S *hd, int ch, int cmd)
+{
+ if(cmd == GF_DATA){
+ html_handoff(hd, ch);
+ }
+ else if(cmd == GF_RESET){
+ if(PASS_HTML(hd->html_data)){
+ html_output_raw_tag(hd->html_data, "p");
+ }
+ else{
+ /* Make sure there's at least 1 blank line */
+ html_blank(hd->html_data, 1);
+
+ /* adjust indent level if needed */
+ if(HD(hd->html_data)->li_pending){
+ html_indent(hd->html_data, 4, HTML_ID_INC);
+ HD(hd->html_data)->li_pending = 0;
+ }
+ }
+ }
+ else if(cmd == GF_EOD){
+ if(PASS_HTML(hd->html_data)){
+ html_output_string(hd->html_data, "</p>");
+ }
+ else{
+ /* Make sure there's at least 1 blank line */
+ html_blank(hd->html_data, 1);
+ }
+ }
+
+ return(1); /* GET linked */
+}
+
+
+/*
+ * HTML Table <TABLE> (paragraph) table row
+ */
+int
+html_table(HANDLER_S *hd, int ch, int cmd)
+{
+ if(cmd == GF_DATA){
+ if(PASS_HTML(hd->html_data)){
+ html_handoff(hd, ch);
+ }
+ }
+ else if(cmd == GF_RESET){
+ if(PASS_HTML(hd->html_data)){
+ html_output_raw_tag(hd->html_data, "table");
+ }
+ else
+ /* Make sure there's at least 1 blank line */
+ html_blank(hd->html_data, 0);
+ }
+ else if(cmd == GF_EOD){
+ if(PASS_HTML(hd->html_data)){
+ html_output_string(hd->html_data, "</table>");
+ }
+ else
+ /* Make sure there's at least 1 blank line */
+ html_blank(hd->html_data, 0);
+ }
+ return(PASS_HTML(hd->html_data)); /* maybe get linked */
+}
+
+
+/*
+ * HTML <CAPTION> (Table Caption) element handler
+ */
+int
+html_caption(HANDLER_S *hd, int ch, int cmd)
+{
+ if(cmd == GF_DATA){
+ html_handoff(hd, ch);
+ }
+ else if(cmd == GF_RESET){
+ if(PASS_HTML(hd->html_data)){
+ html_output_raw_tag(hd->html_data, "caption");
+ }
+ else{
+ /* turn ON the centered bit */
+ CENTER_BIT(hd->html_data) = 1;
+ }
+ }
+ else if(cmd == GF_EOD){
+ if(PASS_HTML(hd->html_data)){
+ html_output_string(hd->html_data, "</caption>");
+ }
+ else{
+ /* turn OFF the centered bit */
+ CENTER_BIT(hd->html_data) = 0;
+ }
+ }
+
+ return(1);
+}
+
+
+/*
+ * HTML Table <TR> (paragraph) table row
+ */
+int
+html_tr(HANDLER_S *hd, int ch, int cmd)
+{
+ if(cmd == GF_DATA){
+ if(PASS_HTML(hd->html_data)){
+ html_handoff(hd, ch);
+ }
+ }
+ else if(cmd == GF_RESET){
+ if(PASS_HTML(hd->html_data)){
+ html_output_raw_tag(hd->html_data, "tr");
+ }
+ else
+ /* Make sure there's at least 1 blank line */
+ html_blank(hd->html_data, 0);
+ }
+ else if(cmd == GF_EOD){
+ if(PASS_HTML(hd->html_data)){
+ html_output_string(hd->html_data, "</tr>");
+ }
+ else
+ /* Make sure there's at least 1 blank line */
+ html_blank(hd->html_data, 0);
+ }
+ return(PASS_HTML(hd->html_data)); /* maybe get linked */
+}
+
+
+/*
+ * HTML Table <TD> (paragraph) table data
+ */
+int
+html_td(HANDLER_S *hd, int ch, int cmd)
+{
+ if(cmd == GF_DATA){
+ if(PASS_HTML(hd->html_data)){
+ html_handoff(hd, ch);
+ }
+ }
+ else if(cmd == GF_RESET){
+ if(PASS_HTML(hd->html_data)){
+ html_output_raw_tag(hd->html_data, "td");
+ }
+ else{
+ PARAMETER *p;
+
+ for(p = HD(hd->html_data)->el_data->attribs;
+ p && p->attribute;
+ p = p->next)
+ if(!strucmp(p->attribute, "nowrap")
+ && (hd->html_data->f2 || hd->html_data->n)){
+ HTML_DUMP_LIT(hd->html_data, " | ", 3);
+ break;
+ }
+ }
+ }
+ else if(cmd == GF_EOD){
+ if(PASS_HTML(hd->html_data)){
+ html_output_string(hd->html_data, "</td>");
+ }
+ }
+
+ return(PASS_HTML(hd->html_data)); /* maybe get linked */
+}
+
+
+/*
+ * HTML Table <TH> (paragraph) table head
+ */
+int
+html_th(HANDLER_S *hd, int ch, int cmd)
+{
+ if(cmd == GF_DATA){
+ if(PASS_HTML(hd->html_data)){
+ html_handoff(hd, ch);
+ }
+ }
+ else if(cmd == GF_RESET){
+ if(PASS_HTML(hd->html_data)){
+ html_output_raw_tag(hd->html_data, "th");
+ }
+ else{
+ PARAMETER *p;
+
+ for(p = HD(hd->html_data)->el_data->attribs;
+ p && p->attribute;
+ p = p->next)
+ if(!strucmp(p->attribute, "nowrap")
+ && (hd->html_data->f2 || hd->html_data->n)){
+ HTML_DUMP_LIT(hd->html_data, " | ", 3);
+ break;
+ }
+ }
+ }
+ else if(cmd == GF_EOD){
+ if(PASS_HTML(hd->html_data)){
+ html_output_string(hd->html_data, "</th>");
+ }
+ }
+
+ return(PASS_HTML(hd->html_data)); /* don't get linked */
+}
+
+
+/*
+ * HTML Table <THEAD> table head
+ */
+int
+html_thead(HANDLER_S *hd, int ch, int cmd)
+{
+ if(PASS_HTML(hd->html_data)){
+ if(cmd == GF_DATA){
+ html_handoff(hd, ch);
+ }
+ else if(cmd == GF_RESET){
+ html_output_raw_tag(hd->html_data, "thead");
+ }
+ else if(cmd == GF_EOD){
+ html_output_string(hd->html_data, "</thead>");
+ }
+
+ return(1); /* GET linked */
+ }
+
+ return(0); /* don't get linked */
+}
+
+
+/*
+ * HTML Table <TBODY> table body
+ */
+int
+html_tbody(HANDLER_S *hd, int ch, int cmd)
+{
+ if(PASS_HTML(hd->html_data)){
+ if(cmd == GF_DATA){
+ html_handoff(hd, ch);
+ }
+ else if(cmd == GF_RESET){
+ html_output_raw_tag(hd->html_data, "tbody");
+ }
+ else if(cmd == GF_EOD){
+ html_output_string(hd->html_data, "</tbody>");
+ }
+
+ return(1); /* GET linked */
+ }
+
+ return(0); /* don't get linked */
+}
+
+
+/*
+ * HTML Table <TFOOT> table body
+ */
+int
+html_tfoot(HANDLER_S *hd, int ch, int cmd)
+{
+ if(PASS_HTML(hd->html_data)){
+ if(cmd == GF_DATA){
+ html_handoff(hd, ch);
+ }
+ else if(cmd == GF_RESET){
+ html_output_raw_tag(hd->html_data, "tfoot");
+ }
+ else if(cmd == GF_EOD){
+ html_output_string(hd->html_data, "</tfoot>");
+ }
+
+ return(1); /* GET linked */
+ }
+
+ return(0); /* don't get linked */
+}
+
+
+/*
+ * HTML <COL> (Table Column Attributes) element handler
+ */
+int
+html_col(HANDLER_S *hd, int ch, int cmd)
+{
+ if(cmd == GF_RESET){
+ if(PASS_HTML(hd->html_data)){
+ html_output_raw_tag(hd->html_data, "col");
+ }
+ }
+
+ return(0); /* don't get linked */
+}
+
+
+/*
+ * HTML Table <COLGROUP> table body
+ */
+int
+html_colgroup(HANDLER_S *hd, int ch, int cmd)
+{
+ if(PASS_HTML(hd->html_data)){
+ if(cmd == GF_DATA){
+ html_handoff(hd, ch);
+ }
+ else if(cmd == GF_RESET){
+ html_output_raw_tag(hd->html_data, "colgroup");
+ }
+ else if(cmd == GF_EOD){
+ html_output_string(hd->html_data, "</colgroup>");
+ }
+
+ return(1); /* GET linked */
+ }
+
+ return(0); /* don't get linked */
+}
+
+
+/*
+ * HTML <I> (italic text) element handler
+ */
+int
+html_i(HANDLER_S *hd, int ch, int cmd)
+{
+ if(cmd == GF_DATA){
+ /* include LITERAL in spaceness test! */
+ if(hd->x && !ASCII_ISSPACE((unsigned char) (ch & 0xff))){
+ HTML_ITALIC(hd->html_data, 1);
+ hd->x = 0;
+ }
+
+ html_handoff(hd, ch);
+ }
+ else if(cmd == GF_RESET){
+ hd->x = 1;
+ }
+ else if(cmd == GF_EOD){
+ if(!hd->x)
+ HTML_ITALIC(hd->html_data, 0);
+ }
+
+ return(1); /* get linked */
+}
+
+
+/*
+ * HTML <EM> element handler
+ */
+int
+html_em(HANDLER_S *hd, int ch, int cmd)
+{
+ if(cmd == GF_DATA){
+ if(!PASS_HTML(hd->html_data)){
+ /* include LITERAL in spaceness test! */
+ if(hd->x && !ASCII_ISSPACE((unsigned char) (ch & 0xff))){
+ HTML_ITALIC(hd->html_data, 1);
+ hd->x = 0;
+ }
+ }
+
+ html_handoff(hd, ch);
+ }
+ else if(cmd == GF_RESET){
+ if(PASS_HTML(hd->html_data)){
+ html_output_raw_tag(hd->html_data, "em");
+ }
+ else{
+ hd->x = 1;
+ }
+ }
+ else if(cmd == GF_EOD){
+ if(PASS_HTML(hd->html_data)){
+ html_output_string(hd->html_data, "</em>");
+ }
+ else{
+ if(!hd->x)
+ HTML_ITALIC(hd->html_data, 0);
+ }
+ }
+
+ return(1); /* get linked */
+}
+
+
+/*
+ * HTML <STRONG> element handler
+ */
+int
+html_strong(HANDLER_S *hd, int ch, int cmd)
+{
+ if(cmd == GF_DATA){
+ if(!PASS_HTML(hd->html_data)){
+ /* include LITERAL in spaceness test! */
+ if(hd->x && !ASCII_ISSPACE((unsigned char) (ch & 0xff))){
+ HTML_ITALIC(hd->html_data, 1);
+ hd->x = 0;
+ }
+ }
+
+ html_handoff(hd, ch);
+ }
+ else if(cmd == GF_RESET){
+ if(PASS_HTML(hd->html_data)){
+ html_output_raw_tag(hd->html_data, "strong");
+ }
+ else{
+ hd->x = 1;
+ }
+ }
+ else if(cmd == GF_EOD){
+ if(PASS_HTML(hd->html_data)){
+ html_output_string(hd->html_data, "</strong>");
+ }
+ else{
+ if(!hd->x)
+ HTML_ITALIC(hd->html_data, 0);
+ }
+ }
+
+ return(1); /* get linked */
+}
+
+
+/*
+ * HTML <u> (Underline text) element handler
+ */
+int
+html_u(HANDLER_S *hd, int ch, int cmd)
+{
+ if(PASS_HTML(hd->html_data)){
+ if(cmd == GF_DATA){
+ html_handoff(hd, ch);
+ }
+ else if(cmd == GF_RESET){
+ html_output_raw_tag(hd->html_data, "u");
+ }
+ else if(cmd == GF_EOD){
+ html_output_string(hd->html_data, "</u>");
+ }
+
+ return(1); /* get linked */
+ }
+
+ return(0); /* do NOT get linked */
+}
+
+
+/*
+ * HTML <b> (Bold text) element handler
+ */
+int
+html_b(HANDLER_S *hd, int ch, int cmd)
+{
+ if(cmd == GF_DATA){
+ if(!PASS_HTML(hd->html_data)){
+ /* include LITERAL in spaceness test! */
+ if(hd->x && !ASCII_ISSPACE((unsigned char) (ch & 0xff))){
+ HTML_BOLD(hd->html_data, 1);
+ hd->x = 0;
+ }
+ }
+
+ html_handoff(hd, ch);
+ }
+ else if(cmd == GF_RESET){
+ if(PASS_HTML(hd->html_data)){
+ html_output_raw_tag(hd->html_data, "b");
+ }
+ else{
+ hd->x = 1;
+ }
+ }
+ else if(cmd == GF_EOD){
+ if(PASS_HTML(hd->html_data)){
+ html_output_string(hd->html_data, "</b>");
+ }
+ else{
+ if(!hd->x)
+ HTML_BOLD(hd->html_data, 0);
+ }
+ }
+
+ return(1); /* get linked */
+}
+
+
+/*
+ * HTML <s> (strike-through text) element handler
+ */
+int
+html_s(HANDLER_S *hd, int ch, int cmd)
+{
+ if(cmd == GF_DATA){
+ if(!PASS_HTML(hd->html_data)){
+ /* include LITERAL in spaceness test! */
+ if(hd->x && !ASCII_ISSPACE((unsigned char) (ch & 0xff))){
+ HTML_STRIKE(hd->html_data, 1);
+ hd->x = 0;
+ }
+ }
+
+ html_handoff(hd, ch);
+ }
+ else if(cmd == GF_RESET){
+ if(PASS_HTML(hd->html_data)){
+ html_output_raw_tag(hd->html_data, "s");
+ }
+ else{
+ hd->x = 1;
+ }
+ }
+ else if(cmd == GF_EOD){
+ if(PASS_HTML(hd->html_data)){
+ html_output_string(hd->html_data, "</s>");
+ }
+ else{
+ if(!hd->x)
+ HTML_STRIKE(hd->html_data, 0);
+ }
+ }
+
+ return(1); /* get linked */
+}
+
+
+/*
+ * HTML <big> (BIG text) element handler
+ */
+int
+html_big(HANDLER_S *hd, int ch, int cmd)
+{
+ if(cmd == GF_DATA){
+ /* include LITERAL in spaceness test! */
+ if(hd->x && !ASCII_ISSPACE((unsigned char) (ch & 0xff))){
+ HTML_BIG(hd->html_data, 1);
+ hd->x = 0;
+ }
+
+ html_handoff(hd, ch);
+ }
+ else if(cmd == GF_RESET){
+ hd->x = 1;
+ }
+ else if(cmd == GF_EOD){
+ if(!hd->x)
+ HTML_BIG(hd->html_data, 0);
+ }
+
+ return(1); /* get linked */
+}
+
+
+/*
+ * HTML <small> (SMALL text) element handler
+ */
+int
+html_small(HANDLER_S *hd, int ch, int cmd)
+{
+ if(cmd == GF_DATA){
+ /* include LITERAL in spaceness test! */
+ if(hd->x && !ASCII_ISSPACE((unsigned char) (ch & 0xff))){
+ HTML_SMALL(hd->html_data, 1);
+ hd->x = 0;
+ }
+
+ html_handoff(hd, ch);
+ }
+ else if(cmd == GF_RESET){
+ hd->x = 1;
+ }
+ else if(cmd == GF_EOD){
+ if(!hd->x)
+ HTML_SMALL(hd->html_data, 0);
+ }
+
+ return(1); /* get linked */
+}
+
+
+/*
+ * HTML <FONT> element handler
+ */
+int
+html_font(HANDLER_S *hd, int ch, int cmd)
+{
+ if(PASS_HTML(hd->html_data)){
+ if(cmd == GF_DATA){
+ html_handoff(hd, ch);
+ }
+ else if(cmd == GF_RESET){
+ html_output_raw_tag(hd->html_data, "font");
+ }
+ else if(cmd == GF_EOD){
+ html_output_string(hd->html_data, "</font>");
+ }
+
+ return(1); /* get linked */
+ }
+
+ return(0);
+}
+
+
+/*
+ * HTML <IMG> element handler
+ */
+int
+html_img(HANDLER_S *hd, int ch, int cmd)
+{
+ PARAMETER *p;
+ char *alt = NULL, *src = NULL, *s;
+
+ if(cmd == GF_RESET){
+ if(PASS_HTML(hd->html_data)){
+ html_output_raw_tag(hd->html_data, "img");
+ }
+ else{
+ for(p = HD(hd->html_data)->el_data->attribs;
+ p && p->attribute;
+ p = p->next)
+ if(p->value && p->value[0]){
+ if(!strucmp(p->attribute, "alt"))
+ alt = p->value;
+ if(!strucmp(p->attribute, "src"))
+ src = p->value;
+ }
+
+ /*
+ * Multipart/Related Content ID pointer
+ * ONLY attached messages are recognized
+ * if we ever decide web bugs aren't a problem
+ * anymore then we might expand the scope
+ */
+ if(src
+ && DO_HANDLES(hd->html_data)
+ && RELATED_OK(hd->html_data)
+ && struncmp(src, "cid:", 4) == 0){
+ char buf[32];
+ int i, n;
+ HANDLE_S *h = new_handle(HANDLESP(hd->html_data));
+
+ h->type = IMG;
+ h->h.img.src = cpystr(src + 4);
+ h->h.img.alt = cpystr((alt) ? alt : "Attached Image");
+
+ HTML_TEXT(hd->html_data, TAG_EMBED);
+ HTML_TEXT(hd->html_data, TAG_HANDLE);
+
+ sprintf(buf, "%d", h->key);
+ n = strlen(buf);
+ HTML_TEXT(hd->html_data, n);
+ for(i = 0; i < n; i++){
+ unsigned int uic = buf[i];
+ HTML_TEXT(hd->html_data, uic);
+ }
+
+ return(0);
+ }
+ else if(alt && strlen(alt) < 256){ /* arbitrary "reasonable" limit */
+ HTML_DUMP_LIT(hd->html_data, alt, strlen(alt));
+ HTML_TEXT(hd->html_data, ' ');
+ return(0);
+ }
+ else if(src
+ && (s = strrindex(src, '/'))
+ && *++s != '\0'){
+ HTML_TEXT(hd->html_data, '[');
+ HTML_DUMP_LIT(hd->html_data, s, strlen(s));
+ HTML_TEXT(hd->html_data, ']');
+ HTML_TEXT(hd->html_data, ' ');
+ return(0);
+ }
+
+ /* text filler of last resort */
+ HTML_DUMP_LIT(hd->html_data, "[IMAGE] ", 7);
+ }
+ }
+
+ return(0); /* don't get linked */
+}
+
+
+/*
+ * HTML <MAP> (Image Map) element handler
+ */
+int
+html_map(HANDLER_S *hd, int ch, int cmd)
+{
+ if(PASS_HTML(hd->html_data) && PASS_IMAGES(hd->html_data)){
+ if(cmd == GF_DATA){
+ html_handoff(hd, ch);
+ }
+ else if(cmd == GF_RESET){
+ html_output_raw_tag(hd->html_data, "map");
+ }
+ else if(cmd == GF_EOD){
+ html_output_string(hd->html_data, "</map>");
+ }
+
+ return(1);
+ }
+
+ return(0);
+}
+
+
+/*
+ * HTML <AREA> (Image Map Area) element handler
+ */
+int
+html_area(HANDLER_S *hd, int ch, int cmd)
+{
+ if(PASS_HTML(hd->html_data) && PASS_IMAGES(hd->html_data)){
+ if(cmd == GF_DATA){
+ html_handoff(hd, ch);
+ }
+ else if(cmd == GF_RESET){
+ html_output_raw_tag(hd->html_data, "area");
+ }
+ else if(cmd == GF_EOD){
+ html_output_string(hd->html_data, "</area>");
+ }
+
+ return(1);
+ }
+
+ return(0);
+}
+
+
+/*
+ * HTML <FORM> (Form) element handler
+ */
+int
+html_form(HANDLER_S *hd, int ch, int cmd)
+{
+ if(PASS_HTML(hd->html_data)){
+ if(cmd == GF_DATA){
+ html_handoff(hd, ch);
+ }
+ else if(cmd == GF_RESET){
+ PARAMETER **pp;
+
+ /* SECURITY: make sure to redirect to new browser instance */
+ for(pp = &(HD(hd->html_data)->el_data->attribs);
+ *pp && (*pp)->attribute;
+ pp = &(*pp)->next)
+ if(!strucmp((*pp)->attribute, "target")){
+ if((*pp)->value)
+ fs_give((void **) &(*pp)->value);
+
+ (*pp)->value = cpystr("_blank");
+ }
+
+ if(!*pp){
+ *pp = (PARAMETER *)fs_get(sizeof(PARAMETER));
+ memset(*pp, 0, sizeof(PARAMETER));
+ (*pp)->attribute = cpystr("target");
+ (*pp)->value = cpystr("_blank");
+ }
+
+ html_output_raw_tag(hd->html_data, "form");
+ }
+ else if(cmd == GF_EOD){
+ html_output_string(hd->html_data, "</form>");
+ }
+ }
+ else{
+ if(cmd == GF_RESET){
+ html_blank(hd->html_data, 0);
+ HTML_DUMP_LIT(hd->html_data, "[FORM]", 6);
+ html_blank(hd->html_data, 0);
+ }
+ }
+
+ return(PASS_HTML(hd->html_data)); /* maybe get linked */
+}
+
+
+/*
+ * HTML <INPUT> (Form) element handler
+ */
+int
+html_input(HANDLER_S *hd, int ch, int cmd)
+{
+ if(PASS_HTML(hd->html_data)){
+ if(cmd == GF_RESET){
+ html_output_raw_tag(hd->html_data, "input");
+ }
+ }
+
+ return(0); /* don't get linked */
+}
+
+
+/*
+ * HTML <BUTTON> (Form) element handler
+ */
+int
+html_button(HANDLER_S *hd, int ch, int cmd)
+{
+ if(PASS_HTML(hd->html_data)){
+ if(cmd == GF_DATA){
+ html_handoff(hd, ch);
+ }
+ else if(cmd == GF_RESET){
+ html_output_raw_tag(hd->html_data, "button");
+ }
+ else if(cmd == GF_EOD){
+ html_output_string(hd->html_data, "</button>");
+ }
+
+ return(1); /* get linked */
+ }
+
+ return(0);
+}
+
+
+/*
+ * HTML <OPTION> (Form) element handler
+ */
+int
+html_option(HANDLER_S *hd, int ch, int cmd)
+{
+ if(PASS_HTML(hd->html_data)){
+ if(cmd == GF_DATA){
+ html_handoff(hd, ch);
+ }
+ else if(cmd == GF_RESET){
+ html_output_raw_tag(hd->html_data, "option");
+ }
+ else if(cmd == GF_EOD){
+ html_output_string(hd->html_data, "</option>");
+ }
+
+ return(1); /* get linked */
+ }
+
+ return(0);
+}
+
+
+/*
+ * HTML <OPTGROUP> (Form) element handler
+ */
+int
+html_optgroup(HANDLER_S *hd, int ch, int cmd)
+{
+ if(PASS_HTML(hd->html_data)){
+ if(cmd == GF_DATA){
+ html_handoff(hd, ch);
+ }
+ else if(cmd == GF_RESET){
+ html_output_raw_tag(hd->html_data, "optgroup");
+ }
+ else if(cmd == GF_EOD){
+ html_output_string(hd->html_data, "</optgroup>");
+ }
+
+ return(1); /* get linked */
+ }
+
+ return(0);
+}
+
+
+/*
+ * HTML <SELECT> (Form) element handler
+ */
+int
+html_select(HANDLER_S *hd, int ch, int cmd)
+{
+ if(PASS_HTML(hd->html_data)){
+ if(cmd == GF_DATA){
+ html_handoff(hd, ch);
+ }
+ else if(cmd == GF_RESET){
+ html_output_raw_tag(hd->html_data, "select");
+ }
+ else if(cmd == GF_EOD){
+ html_output_string(hd->html_data, "</select>");
+ }
+
+ return(1); /* get linked */
+ }
+
+ return(0);
+}
+
+
+/*
+ * HTML <TEXTAREA> (Form) element handler
+ */
+int
+html_textarea(HANDLER_S *hd, int ch, int cmd)
+{
+ if(PASS_HTML(hd->html_data)){
+ if(cmd == GF_DATA){
+ html_handoff(hd, ch);
+ }
+ else if(cmd == GF_RESET){
+ html_output_raw_tag(hd->html_data, "textarea");
+ }
+ else if(cmd == GF_EOD){
+ html_output_string(hd->html_data, "</textarea>");
+ }
+
+ return(1); /* get linked */
+ }
+
+ return(0);
+}
+
+
+/*
+ * HTML <LABEL> (Form) element handler
+ */
+int
+html_label(HANDLER_S *hd, int ch, int cmd)
+{
+ if(PASS_HTML(hd->html_data)){
+ if(cmd == GF_DATA){
+ html_handoff(hd, ch);
+ }
+ else if(cmd == GF_RESET){
+ html_output_raw_tag(hd->html_data, "label");
+ }
+ else if(cmd == GF_EOD){
+ html_output_string(hd->html_data, "</label>");
+ }
+
+ return(1); /* get linked */
+ }
+
+ return(0);
+}
+
+
+/*
+ * HTML <FIELDSET> (Form) element handler
+ */
+int
+html_fieldset(HANDLER_S *hd, int ch, int cmd)
+{
+ if(PASS_HTML(hd->html_data)){
+ if(cmd == GF_DATA){
+ html_handoff(hd, ch);
+ }
+ else if(cmd == GF_RESET){
+ html_output_raw_tag(hd->html_data, "fieldset");
+ }
+ else if(cmd == GF_EOD){
+ html_output_string(hd->html_data, "</fieldset>");
+ }
+
+ return(1); /* get linked */
+ }
+
+ return(0);
+}
+
+
+/*
+ * HTML <HEAD> element handler
+ */
+int
+html_head(HANDLER_S *hd, int ch, int cmd)
+{
+ if(cmd == GF_DATA){
+ html_handoff(hd, ch);
+ }
+ else if(cmd == GF_RESET){
+ HD(hd->html_data)->head = 1;
+ }
+ else if(cmd == GF_EOD){
+ HD(hd->html_data)->head = 0;
+ }
+
+ return(1); /* get linked */
+}
+
+
+/*
+ * HTML <BASE> element handler
+ */
+int
+html_base(HANDLER_S *hd, int ch, int cmd)
+{
+ if(cmd == GF_RESET){
+ if(HD(hd->html_data)->head && !HTML_BASE(hd->html_data)){
+ PARAMETER *p;
+
+ for(p = HD(hd->html_data)->el_data->attribs;
+ p && p->attribute && strucmp(p->attribute, "HREF");
+ p = p->next)
+ ;
+
+ if(p && p->value && !((HTML_OPT_S *)(hd->html_data)->opt)->base)
+ ((HTML_OPT_S *)(hd->html_data)->opt)->base = cpystr(p->value);
+ }
+ }
+
+ return(0); /* DON'T get linked */
+}
+
+
+/*
+ * HTML <TITLE> element handler
+ */
+int
+html_title(HANDLER_S *hd, int ch, int cmd)
+{
+ if(cmd == GF_DATA){
+ if(hd->x + 1 >= hd->y){
+ hd->y += 80;
+ fs_resize((void **)&hd->s, (size_t)hd->y * sizeof(unsigned char));
+ }
+
+ hd->s[hd->x++] = (unsigned char) ch;
+ }
+ else if(cmd == GF_RESET){
+ hd->x = 0L;
+ hd->y = 80L;
+ hd->s = (unsigned char *)fs_get((size_t)hd->y * sizeof(unsigned char));
+ }
+ else if(cmd == GF_EOD){
+ /* Down the road we probably want to give these bytes to
+ * someone...
+ */
+ hd->s[hd->x] = '\0';
+ fs_give((void **)&hd->s);
+ }
+
+ return(1); /* get linked */
+}
+
+
+/*
+ * HTML <BODY> element handler
+ */
+int
+html_body(HANDLER_S *hd, int ch, int cmd)
+{
+ if(cmd == GF_DATA){
+ html_handoff(hd, ch);
+ }
+ else if(cmd == GF_RESET){
+ if(PASS_HTML(hd->html_data)){
+ PARAMETER *p, *tp;
+ char **style = NULL, *text = NULL, *bgcolor = NULL, *pcs;
+
+ /* modify any attributes in a useful way? */
+ for(p = HD(hd->html_data)->el_data->attribs;
+ p && p->attribute;
+ p = p->next)
+ if(p->value){
+ if(!strucmp(p->attribute, "style"))
+ style = &p->value;
+ else if(!strucmp(p->attribute, "text"))
+ text = p->value;
+ /*
+ * bgcolor NOT passed since user setting takes precedence
+ *
+ else if(!strucmp(p->attribute, "bgcolor"))
+ bgcolor = p->value;
+ */
+ }
+
+ /* colors pretty much it */
+ if(text || bgcolor){
+ if(!style){
+ tp = (PARAMETER *)fs_get(sizeof(PARAMETER));
+ memset(tp, 0, sizeof(PARAMETER));
+ tp->next = HD(hd->html_data)->el_data->attribs;
+ HD(hd->html_data)->el_data->attribs = tp;
+ tp->attribute = cpystr("style");
+
+ tmp_20k_buf[0] = '\0';
+ style = &tp->value;
+ pcs = "%s%s%s%s%s";
+ }
+ else{
+ snprintf(tmp_20k_buf, SIZEOF_20KBUF, "%s", *style);
+ fs_give((void **) style);
+ pcs = "; %s%s%s%s%s";
+ }
+
+ snprintf(tmp_20k_buf + strlen(tmp_20k_buf),
+ SIZEOF_20KBUF - strlen(tmp_20k_buf),
+ pcs,
+ (text) ? "color: " : "", (text) ? text : "",
+ (text && bgcolor) ? ";" : "",
+ (bgcolor) ? "background-color: " : "", (bgcolor) ? bgcolor : "");
+ *style = cpystr(tmp_20k_buf);
+ }
+
+ html_output_raw_tag(hd->html_data, "div");
+ }
+
+ HD(hd->html_data)->body = 1;
+ }
+ else if(cmd == GF_EOD){
+ if(PASS_HTML(hd->html_data)){
+ html_output_string(hd->html_data, "</div>");
+ }
+
+ HD(hd->html_data)->body = 0;
+ }
+
+ return(1); /* get linked */
+}
+
+
+/*
+ * HTML <A> (Anchor) element handler
+ */
+int
+html_a(HANDLER_S *hd, int ch, int cmd)
+{
+ if(cmd == GF_DATA){
+ html_handoff(hd, ch);
+
+ if(hd->dp) /* remember text within anchor tags */
+ so_writec(ch, (STORE_S *) hd->dp);
+ }
+ else if(cmd == GF_RESET){
+ int i, n, x;
+ char buf[256];
+ HANDLE_S *h;
+ PARAMETER *p, *href = NULL, *name = NULL;
+
+ /*
+ * Pending Anchor!?!?
+ * space insertion/line breaking that's yet to get done...
+ */
+ if(HD(hd->html_data)->prefix){
+ dprint((2, "-- html error: nested or unterminated anchor\n"));
+ html_a_finish(hd);
+ }
+
+ /*
+ * Look for valid Anchor data vis the filter installer's parms
+ * (e.g., Only allow references to our internal URLs if asked)
+ */
+ for(p = HD(hd->html_data)->el_data->attribs;
+ p && p->attribute;
+ p = p->next)
+ if(!strucmp(p->attribute, "HREF")
+ && p->value
+ && (HANDLES_LOC(hd->html_data)
+ || struncmp(p->value, "x-alpine-", 9)
+ || struncmp(p->value, "x-pine-help", 11)
+ || p->value[0] == '#'))
+ href = p;
+ else if(!strucmp(p->attribute, "NAME"))
+ name = p;
+
+ if(DO_HANDLES(hd->html_data) && (href || name)){
+ h = new_handle(HANDLESP(hd->html_data));
+
+ /*
+ * Enhancement: we might want to get fancier and parse the
+ * href a bit further such that we can launch images using
+ * our image viewer, or browse local files or directories
+ * with our internal tools. Of course, having the jump-off
+ * point into text/html always be the defined "web-browser",
+ * just might be the least confusing UI-wise...
+ */
+ h->type = URL;
+
+ if(name && name->value)
+ h->h.url.name = cpystr(name->value);
+
+ /*
+ * Prepare to build embedded prefix...
+ */
+ HD(hd->html_data)->prefix = (int *) fs_get(64 * sizeof(int));
+ x = 0;
+
+ /*
+ * Is this something that looks like a URL? If not and
+ * we were giving some "base" string, proceed ala RFC1808...
+ */
+ if(href){
+ if(HTML_BASE(hd->html_data) && !rfc1738_scan(href->value, &n)){
+ html_a_relative(HTML_BASE(hd->html_data), href->value, h);
+ }
+ else if(!(NO_RELATIVE(hd->html_data) && html_href_relative(href->value)))
+ h->h.url.path = cpystr(href->value);
+
+ if(pico_usingcolor()){
+ char *fg = NULL, *bg = NULL, *q;
+
+ if(ps_global->VAR_SLCTBL_FORE_COLOR
+ && colorcmp(ps_global->VAR_SLCTBL_FORE_COLOR,
+ ps_global->VAR_NORM_FORE_COLOR))
+ fg = ps_global->VAR_SLCTBL_FORE_COLOR;
+
+ if(ps_global->VAR_SLCTBL_BACK_COLOR
+ && colorcmp(ps_global->VAR_SLCTBL_BACK_COLOR,
+ ps_global->VAR_NORM_BACK_COLOR))
+ bg = ps_global->VAR_SLCTBL_BACK_COLOR;
+
+ if(fg || bg){
+ COLOR_PAIR *tmp;
+
+ /*
+ * The blacks are just known good colors for testing
+ * whether the other color is good.
+ */
+ tmp = new_color_pair(fg ? fg : colorx(COL_BLACK),
+ bg ? bg : colorx(COL_BLACK));
+ if(pico_is_good_colorpair(tmp)){
+ q = color_embed(fg, bg);
+
+ for(i = 0; q[i]; i++)
+ HD(hd->html_data)->prefix[x++] = q[i];
+ }
+
+ if(tmp)
+ free_color_pair(&tmp);
+ }
+
+ if(F_OFF(F_SLCTBL_ITEM_NOBOLD, ps_global))
+ HD(hd->html_data)->prefix[x++] = HTML_DOBOLD;
+ }
+ else
+ HD(hd->html_data)->prefix[x++] = HTML_DOBOLD;
+ }
+
+ HD(hd->html_data)->prefix[x++] = TAG_EMBED;
+ HD(hd->html_data)->prefix[x++] = TAG_HANDLE;
+
+ snprintf(buf, sizeof(buf), "%ld", hd->x = h->key);
+ HD(hd->html_data)->prefix[x++] = n = strlen(buf);
+ for(i = 0; i < n; i++)
+ HD(hd->html_data)->prefix[x++] = buf[i];
+
+ HD(hd->html_data)->prefix_used = x;
+
+ hd->dp = (void *) so_get(CharStar, NULL, EDIT_ACCESS);
+ }
+ }
+ else if(cmd == GF_EOD){
+ html_a_finish(hd);
+ }
+
+ return(1); /* get linked */
+}
+
+
+void
+html_a_prefix(FILTER_S *f)
+{
+ int *prefix, n;
+
+ /* Do this so we don't visit from html_output... */
+ prefix = HD(f)->prefix;
+ HD(f)->prefix = NULL;
+
+ for(n = 0; n < HD(f)->prefix_used; n++)
+ html_a_output_prefix(f, prefix[n]);
+
+ fs_give((void **) &prefix);
+}
+
+
+/*
+ * html_a_finish - house keeping associated with end of link tag
+ */
+void
+html_a_finish(HANDLER_S *hd)
+{
+ if(DO_HANDLES(hd->html_data)){
+ if(HD(hd->html_data)->prefix){
+ if(!PASS_HTML(hd->html_data)){
+ char *empty_link = "[LINK]";
+ int i;
+
+ html_a_prefix(hd->html_data);
+ for(i = 0; empty_link[i]; i++)
+ html_output(hd->html_data, empty_link[i]);
+ }
+ }
+
+ if(pico_usingcolor()){
+ char *fg = NULL, *bg = NULL, *p;
+ int i;
+
+ if(ps_global->VAR_SLCTBL_FORE_COLOR
+ && colorcmp(ps_global->VAR_SLCTBL_FORE_COLOR,
+ ps_global->VAR_NORM_FORE_COLOR))
+ fg = ps_global->VAR_NORM_FORE_COLOR;
+
+ if(ps_global->VAR_SLCTBL_BACK_COLOR
+ && colorcmp(ps_global->VAR_SLCTBL_BACK_COLOR,
+ ps_global->VAR_NORM_BACK_COLOR))
+ bg = ps_global->VAR_NORM_BACK_COLOR;
+
+ if(F_OFF(F_SLCTBL_ITEM_NOBOLD, ps_global))
+ HTML_BOLD(hd->html_data, 0); /* turn OFF bold */
+
+ if(fg || bg){
+ COLOR_PAIR *tmp;
+
+ /*
+ * The blacks are just known good colors for testing
+ * whether the other color is good.
+ */
+ tmp = new_color_pair(fg ? fg : colorx(COL_BLACK),
+ bg ? bg : colorx(COL_BLACK));
+ if(pico_is_good_colorpair(tmp)){
+ p = color_embed(fg, bg);
+
+ for(i = 0; p[i]; i++)
+ html_output(hd->html_data, p[i]);
+ }
+
+ if(tmp)
+ free_color_pair(&tmp);
+ }
+ }
+ else
+ HTML_BOLD(hd->html_data, 0); /* turn OFF bold */
+
+ html_output(hd->html_data, TAG_EMBED);
+ html_output(hd->html_data, TAG_HANDLEOFF);
+
+ html_a_output_info(hd);
+ }
+}
+
+
+/*
+ * html_output_a_prefix - dump Anchor prefix data
+ */
+void
+html_a_output_prefix(FILTER_S *f, int c)
+{
+ switch(c){
+ case HTML_DOBOLD :
+ HTML_BOLD(f, 1);
+ break;
+
+ default :
+ html_output(f, c);
+ break;
+ }
+}
+
+
+
+/*
+ * html_a_output_info - dump possibly deceptive link info into text.
+ * phark the phishers.
+ */
+void
+html_a_output_info(HANDLER_S *hd)
+{
+ int l, risky = 0, hl = 0, tl;
+ char *url = NULL, *hn = NULL, *txt;
+ HANDLE_S *h;
+
+ /* find host anchor references */
+ if((h = get_handle(*HANDLESP(hd->html_data), (int) hd->x)) != NULL
+ && h->h.url.path != NULL
+ && (hn = rfc1738_scan(rfc1738_str(url = cpystr(h->h.url.path)), &l)) != NULL
+ && (hn = srchstr(hn,"://")) != NULL){
+
+ for(hn += 3, hl = 0; hn[hl] && hn[hl] != '/' && hn[hl] != '?'; hl++)
+ ;
+ }
+
+ if(hn && hl){
+ /*
+ * look over anchor's text to see if there's a
+ * mismatch between href target and url-ish
+ * looking text. throw a red flag if so.
+ * similarly, toss one if the target's referenced
+ * by a
+ */
+ if(hd->dp){
+ so_writec('\0', (STORE_S *) hd->dp);
+
+ if((txt = (char *) so_text((STORE_S *) hd->dp)) != NULL
+ && (txt = rfc1738_scan(txt, &tl)) != NULL
+ && (txt = srchstr(txt,"://")) != NULL){
+
+ for(txt += 3, tl = 0; txt[tl] && txt[tl] != '/' && txt[tl] != '?'; tl++)
+ ;
+
+ if(tl != hl)
+ risky++;
+ else
+ /* look for non matching text */
+ for(l = 0; l < tl && l < hl; l++)
+ if(tolower((unsigned char) txt[l]) != tolower((unsigned char) hn[l])){
+ risky++;
+ break;
+ }
+ }
+
+ so_give((STORE_S **) &hd->dp);
+ }
+
+ /* look for literal IP, anything possibly encoded or auth specifier */
+ if(!risky){
+ int digits = 1;
+
+ for(l = 0; l < hl; l++){
+ if(hn[l] == '@' || hn[l] == '%'){
+ risky++;
+ break;
+ }
+ else if(!(hn[l] == '.' || isdigit((unsigned char) hn[l])))
+ digits = 0;
+ }
+
+ if(digits)
+ risky++;
+ }
+
+ /* Insert text of link's domain */
+ if(SHOWSERVER(hd->html_data)){
+ char *q;
+ COLOR_PAIR *col = NULL, *colnorm = NULL;
+
+ html_output(hd->html_data, ' ');
+ html_output(hd->html_data, '[');
+
+ if(pico_usingcolor()
+ && ps_global->VAR_METAMSG_FORE_COLOR
+ && ps_global->VAR_METAMSG_BACK_COLOR
+ && (col = new_color_pair(ps_global->VAR_METAMSG_FORE_COLOR,
+ ps_global->VAR_METAMSG_BACK_COLOR))){
+ if(!pico_is_good_colorpair(col))
+ free_color_pair(&col);
+
+ if(col){
+ q = color_embed(col->fg, col->bg);
+
+ for(l = 0; q[l]; l++)
+ html_output(hd->html_data, q[l]);
+ }
+ }
+
+ for(l = 0; l < hl; l++)
+ html_output(hd->html_data, hn[l]);
+
+ if(col){
+ if(ps_global->VAR_NORM_FORE_COLOR
+ && ps_global->VAR_NORM_BACK_COLOR
+ && (colnorm = new_color_pair(ps_global->VAR_NORM_FORE_COLOR,
+ ps_global->VAR_NORM_BACK_COLOR))){
+ if(!pico_is_good_colorpair(colnorm))
+ free_color_pair(&colnorm);
+
+ if(colnorm){
+ q = color_embed(colnorm->fg, colnorm->bg);
+ free_color_pair(&colnorm);
+
+ for(l = 0; q[l]; l++)
+ html_output(hd->html_data, q[l]);
+ }
+ }
+
+ free_color_pair(&col);
+ }
+
+ html_output(hd->html_data, ']');
+ }
+ }
+
+ /*
+ * if things look OK so far, make sure nothing within
+ * the url looks too fishy...
+ */
+ while(!risky && hn
+ && (hn = rfc1738_scan(hn, &l)) != NULL
+ && (hn = srchstr(hn,"://")) != NULL){
+ int digits = 1;
+
+ for(hn += 3, hl = 0; hn[hl] && hn[hl] != '/' && hn[hl] != '?'; hl++){
+ /*
+ * auth spec, encoded characters, or possibly non-standard port
+ * should raise a red flag
+ */
+ if(hn[hl] == '@' || hn[hl] == '%' || hn[hl] == ':'){
+ risky++;
+ break;
+ }
+ else if(!(hn[hl] == '.' || isdigit((unsigned char) hn[hl])))
+ digits = 0;
+ }
+
+ /* dotted-dec/raw-int address should cause suspicion as well */
+ if(digits)
+ risky++;
+ }
+
+ if(risky && ((HTML_OPT_S *) hd->html_data->opt)->warnrisk_f)
+ (*((HTML_OPT_S *) hd->html_data->opt)->warnrisk_f)();
+
+ fs_give((void **) &url);
+}
+
+
+
+/*
+ * relative_url - put full url path in h based on base and relative url
+ */
+void
+html_a_relative(char *base_url, char *rel_url, HANDLE_S *h)
+{
+ size_t len;
+ char tmp[MAILTMPLEN], *p, *q;
+ char *scheme = NULL, *net = NULL, *path = NULL,
+ *parms = NULL, *query = NULL, *frag = NULL,
+ *base_scheme = NULL, *base_net_loc = NULL,
+ *base_path = NULL, *base_parms = NULL,
+ *base_query = NULL, *base_frag = NULL,
+ *rel_scheme = NULL, *rel_net_loc = NULL,
+ *rel_path = NULL, *rel_parms = NULL,
+ *rel_query = NULL, *rel_frag = NULL;
+
+ /* Rough parse of base URL */
+ rfc1808_tokens(base_url, &base_scheme, &base_net_loc, &base_path,
+ &base_parms, &base_query, &base_frag);
+
+ /* Rough parse of this URL */
+ rfc1808_tokens(rel_url, &rel_scheme, &rel_net_loc, &rel_path,
+ &rel_parms, &rel_query, &rel_frag);
+
+ scheme = rel_scheme; /* defaults */
+ net = rel_net_loc;
+ path = rel_path;
+ parms = rel_parms;
+ query = rel_query;
+ frag = rel_frag;
+ if(!scheme && base_scheme){
+ scheme = base_scheme;
+ if(!net){
+ net = base_net_loc;
+ if(path){
+ if(*path != '/'){
+ if(base_path){
+ for(p = q = base_path; /* Drop base path's tail */
+ (p = strchr(p, '/'));
+ q = ++p)
+ ;
+
+ len = q - base_path;
+ }
+ else
+ len = 0;
+
+ if(len + strlen(rel_path) < sizeof(tmp)-1){
+ if(len)
+ snprintf(path = tmp, sizeof(tmp), "%.*s", len, base_path);
+
+ strncpy(tmp + len, rel_path, sizeof(tmp)-len);
+ tmp[sizeof(tmp)-1] = '\0';
+
+ /* Follow RFC 1808 "Step 6" */
+ for(p = tmp; (p = strchr(p, '.')); )
+ switch(*(p+1)){
+ /*
+ * a) All occurrences of "./", where "." is a
+ * complete path segment, are removed.
+ */
+ case '/' :
+ if(p > tmp)
+ for(q = p; (*q = *(q+2)) != '\0'; q++)
+ ;
+ else
+ p++;
+
+ break;
+
+ /*
+ * b) If the path ends with "." as a
+ * complete path segment, that "." is
+ * removed.
+ */
+ case '\0' :
+ if(p == tmp || *(p-1) == '/')
+ *p = '\0';
+ else
+ p++;
+
+ break;
+
+ /*
+ * c) All occurrences of "<segment>/../",
+ * where <segment> is a complete path
+ * segment not equal to "..", are removed.
+ * Removal of these path segments is
+ * performed iteratively, removing the
+ * leftmost matching pattern on each
+ * iteration, until no matching pattern
+ * remains.
+ *
+ * d) If the path ends with "<segment>/..",
+ * where <segment> is a complete path
+ * segment not equal to "..", that
+ * "<segment>/.." is removed.
+ */
+ case '.' :
+ if(p > tmp + 1){
+ for(q = p - 2; q > tmp && *q != '/'; q--)
+ ;
+
+ if(*q == '/')
+ q++;
+
+ if(q + 1 == p /* no "//.." */
+ || (*q == '.' /* and "../.." */
+ && *(q+1) == '.'
+ && *(q+2) == '/')){
+ p += 2;
+ break;
+ }
+
+ switch(*(p+2)){
+ case '/' :
+ len = (p - q) + 3;
+ p = q;
+ for(; (*q = *(q+len)) != '\0'; q++)
+ ;
+
+ break;
+
+ case '\0':
+ *(p = q) = '\0';
+ break;
+
+ default:
+ p += 2;
+ break;
+ }
+ }
+ else
+ p += 2;
+
+ break;
+
+ default :
+ p++;
+ break;
+ }
+ }
+ else
+ path = ""; /* lame. */
+ }
+ }
+ else{
+ path = base_path;
+ if(!parms){
+ parms = base_parms;
+ if(!query)
+ query = base_query;
+ }
+ }
+ }
+ }
+
+ len = (scheme ? strlen(scheme) : 0) + (net ? strlen(net) : 0)
+ + (path ? strlen(path) : 0) + (parms ? strlen(parms) : 0)
+ + (query ? strlen(query) : 0) + (frag ? strlen(frag ) : 0) + 8;
+
+ h->h.url.path = (char *) fs_get(len * sizeof(char));
+ snprintf(h->h.url.path, len, "%s%s%s%s%s%s%s%s%s%s%s%s",
+ scheme ? scheme : "", scheme ? ":" : "",
+ net ? "//" : "", net ? net : "",
+ (path && *path == '/') ? "" : ((path && net) ? "/" : ""),
+ path ? path : "",
+ parms ? ";" : "", parms ? parms : "",
+ query ? "?" : "", query ? query : "",
+ frag ? "#" : "", frag ? frag : "");
+
+ if(base_scheme)
+ fs_give((void **) &base_scheme);
+
+ if(base_net_loc)
+ fs_give((void **) &base_net_loc);
+
+ if(base_path)
+ fs_give((void **) &base_path);
+
+ if(base_parms)
+ fs_give((void **) &base_parms);
+
+ if(base_query)
+ fs_give((void **) &base_query);
+
+ if(base_frag)
+ fs_give((void **) &base_frag);
+
+ if(rel_scheme)
+ fs_give((void **) &rel_scheme);
+
+ if(rel_net_loc)
+ fs_give((void **) &rel_net_loc);
+
+ if(rel_parms)
+ fs_give((void **) &rel_parms);
+
+ if(rel_query)
+ fs_give((void **) &rel_query);
+
+ if(rel_frag)
+ fs_give((void **) &rel_frag);
+
+ if(rel_path)
+ fs_give((void **) &rel_path);
+}
+
+
+/*
+ * html_href_relative - href
+ */
+int
+html_href_relative(char *url)
+{
+ int i;
+
+ if(url)
+ for(i = 0; i < 32 && url[i]; i++)
+ if(!(isalpha((unsigned char) url[i]) || url[i] == '_' || url[i] == '-')){
+ if(url[i] == ':')
+ return(FALSE);
+ else
+ break;
+ }
+
+ return(TRUE);
+}
+
+
+/*
+ * HTML <UL> (Unordered List) element handler
+ */
+int
+html_ul(HANDLER_S *hd, int ch, int cmd)
+{
+ if(cmd == GF_DATA){
+ html_handoff(hd, ch);
+ }
+ else if(cmd == GF_RESET){
+ if(PASS_HTML(hd->html_data)){
+ html_output_raw_tag(hd->html_data, "ul");
+ }
+ else{
+ HD(hd->html_data)->li_pending = 1;
+ html_blank(hd->html_data, 0);
+ }
+ }
+ else if(cmd == GF_EOD){
+ if(PASS_HTML(hd->html_data)){
+ html_output_string(hd->html_data, "</ul>");
+ }
+ else{
+ html_blank(hd->html_data, 0);
+
+ if(!HD(hd->html_data)->li_pending)
+ html_indent(hd->html_data, -4, HTML_ID_INC);
+ else
+ HD(hd->html_data)->li_pending = 0;
+ }
+ }
+
+ return(1); /* get linked */
+}
+
+
+/*
+ * HTML <OL> (Ordered List) element handler
+ */
+int
+html_ol(HANDLER_S *hd, int ch, int cmd)
+{
+ if(cmd == GF_DATA){
+ html_handoff(hd, ch);
+ }
+ else if(cmd == GF_RESET){
+ if(PASS_HTML(hd->html_data)){
+ html_output_raw_tag(hd->html_data, "ol");
+ }
+ else{
+ /*
+ * Signal that we're expecting to see <LI> as our next elemnt
+ * and set the the initial ordered count.
+ */
+ HD(hd->html_data)->li_pending = 1;
+ hd->x = 1L;
+ html_blank(hd->html_data, 0);
+ }
+ }
+ else if(cmd == GF_EOD){
+ if(PASS_HTML(hd->html_data)){
+ html_output_string(hd->html_data, "</ol>");
+ }
+ else{
+ html_blank(hd->html_data, 0);
+
+ if(!HD(hd->html_data)->li_pending)
+ html_indent(hd->html_data, -4, HTML_ID_INC);
+ else
+ HD(hd->html_data)->li_pending = 0;
+ }
+ }
+
+ return(1); /* get linked */
+}
+
+
+/*
+ * HTML <MENU> (Menu List) element handler
+ */
+int
+html_menu(HANDLER_S *hd, int ch, int cmd)
+{
+ if(cmd == GF_DATA){
+ html_handoff(hd, ch);
+ }
+ else if(cmd == GF_RESET){
+ if(PASS_HTML(hd->html_data)){
+ html_output_raw_tag(hd->html_data, "menu");
+ }
+ else{
+ HD(hd->html_data)->li_pending = 1;
+ }
+ }
+ else if(cmd == GF_EOD){
+ if(PASS_HTML(hd->html_data)){
+ html_output_string(hd->html_data, "</menu>");
+ }
+ else{
+ html_blank(hd->html_data, 0);
+
+ if(!HD(hd->html_data)->li_pending)
+ html_indent(hd->html_data, -4, HTML_ID_INC);
+ else
+ HD(hd->html_data)->li_pending = 0;
+ }
+ }
+
+ return(1); /* get linked */
+}
+
+
+/*
+ * HTML <DIR> (Directory List) element handler
+ */
+int
+html_dir(HANDLER_S *hd, int ch, int cmd)
+{
+ if(cmd == GF_DATA){
+ html_handoff(hd, ch);
+ }
+ else if(cmd == GF_RESET){
+ if(PASS_HTML(hd->html_data)){
+ html_output_raw_tag(hd->html_data, "dir");
+ }
+ else{
+ HD(hd->html_data)->li_pending = 1;
+ }
+ }
+ else if(cmd == GF_EOD){
+ if(PASS_HTML(hd->html_data)){
+ html_output_string(hd->html_data, "</dir>");
+ }
+ else{
+ html_blank(hd->html_data, 0);
+
+ if(!HD(hd->html_data)->li_pending)
+ html_indent(hd->html_data, -4, HTML_ID_INC);
+ else
+ HD(hd->html_data)->li_pending = 0;
+ }
+ }
+
+ return(1); /* get linked */
+}
+
+
+/*
+ * HTML <LI> (List Item) element handler
+ */
+int
+html_li(HANDLER_S *hd, int ch, int cmd)
+{
+ if(cmd == GF_DATA){
+ if(PASS_HTML(hd->html_data)){
+ html_handoff(hd, ch);
+ }
+ }
+ else if(cmd == GF_RESET){
+ HANDLER_S *p, *found = NULL;
+
+ /*
+ * There better be a an unordered list, ordered list,
+ * Menu or Directory handler installed
+ * or else we crap out...
+ */
+ for(p = HANDLERS(hd->html_data); p; p = p->below)
+ if(EL(p)->handler == html_ul
+ || EL(p)->handler == html_ol
+ || EL(p)->handler == html_menu
+ || EL(p)->handler == html_dir){
+ found = p;
+ break;
+ }
+
+ if(found){
+ if(PASS_HTML(hd->html_data)){
+ }
+ else{
+ char buf[8], *p;
+ int wrapstate;
+
+ /* Start a new line */
+ html_blank(hd->html_data, 0);
+
+ /* adjust indent level if needed */
+ if(HD(hd->html_data)->li_pending){
+ html_indent(hd->html_data, 4, HTML_ID_INC);
+ HD(hd->html_data)->li_pending = 0;
+ }
+
+ if(EL(found)->handler == html_ul){
+ int l = html_indent(hd->html_data, 0, HTML_ID_GET);
+
+ strncpy(buf, " ", sizeof(buf));
+ buf[1] = (l < 5) ? '*' : (l < 9) ? '+' : (l < 17) ? 'o' : '#';
+ }
+ else if(EL(found)->handler == html_ol)
+ snprintf(buf, sizeof(buf), "%2ld.", found->x++);
+ else if(EL(found)->handler == html_menu){
+ strncpy(buf, " ->", sizeof(buf));
+ buf[sizeof(buf)-1] = '\0';
+ }
+
+ html_indent(hd->html_data, -4, HTML_ID_INC);
+
+ /* So we don't munge whitespace */
+ wrapstate = HD(hd->html_data)->wrapstate;
+ HD(hd->html_data)->wrapstate = 0;
+
+ html_write_indent(hd->html_data, HD(hd->html_data)->indent_level);
+ for(p = buf; *p; p++)
+ html_output(hd->html_data, (int) *p);
+
+ HD(hd->html_data)->wrapstate = wrapstate;
+ html_indent(hd->html_data, 4, HTML_ID_INC);
+ }
+ /* else BUG: should really bitch about this */
+ }
+
+ if(PASS_HTML(hd->html_data)){
+ html_output_raw_tag(hd->html_data, "li");
+ return(1); /* get linked */
+ }
+ }
+ else if(cmd == GF_EOD){
+ if(PASS_HTML(hd->html_data)){
+ html_output_string(hd->html_data, "</li>");
+ }
+ }
+
+ return(PASS_HTML(hd->html_data)); /* DON'T get linked */
+}
+
+
+/*
+ * HTML <DL> (Definition List) element handler
+ */
+int
+html_dl(HANDLER_S *hd, int ch, int cmd)
+{
+ if(cmd == GF_DATA){
+ html_handoff(hd, ch);
+ }
+ else if(cmd == GF_RESET){
+ if(PASS_HTML(hd->html_data)){
+ html_output_raw_tag(hd->html_data, "dl");
+ }
+ else{
+ /*
+ * Set indention level for definition terms and definitions...
+ */
+ hd->x = html_indent(hd->html_data, 0, HTML_ID_GET);
+ hd->y = hd->x + 2;
+ hd->z = hd->y + 4;
+ }
+ }
+ else if(cmd == GF_EOD){
+ if(PASS_HTML(hd->html_data)){
+ html_output_string(hd->html_data, "</dl>");
+ }
+ else{
+ html_indent(hd->html_data, (int) hd->x, HTML_ID_SET);
+ html_blank(hd->html_data, 1);
+ }
+ }
+
+ return(1); /* get linked */
+}
+
+
+/*
+ * HTML <DT> (Definition Term) element handler
+ */
+int
+html_dt(HANDLER_S *hd, int ch, int cmd)
+{
+ if(PASS_HTML(hd->html_data)){
+ if(cmd == GF_DATA){
+ html_handoff(hd, ch);
+ }
+ else if(cmd == GF_RESET){
+ html_output_raw_tag(hd->html_data, "dt");
+ }
+ else if(cmd == GF_EOD){
+ html_output_string(hd->html_data, "</dt>");
+ }
+
+ return(1); /* get linked */
+ }
+
+ if(cmd == GF_RESET){
+ HANDLER_S *p;
+
+ /*
+ * There better be a Definition Handler installed
+ * or else we crap out...
+ */
+ for(p = HANDLERS(hd->html_data); p && EL(p)->handler != html_dl; p = p->below)
+ ;
+
+ if(p){ /* adjust indent level if needed */
+ html_indent(hd->html_data, (int) p->y, HTML_ID_SET);
+ html_blank(hd->html_data, 1);
+ }
+ /* BUG: else should really bitch about this */
+ }
+
+ return(0); /* DON'T get linked */
+}
+
+
+/*
+ * HTML <DD> (Definition Definition) element handler
+ */
+int
+html_dd(HANDLER_S *hd, int ch, int cmd)
+{
+ if(PASS_HTML(hd->html_data)){
+ if(cmd == GF_DATA){
+ html_handoff(hd, ch);
+ }
+ else if(cmd == GF_RESET){
+ html_output_raw_tag(hd->html_data, "dd");
+ }
+ else if(cmd == GF_EOD){
+ html_output_string(hd->html_data, "</dd>");
+ }
+
+ return(1); /* get linked */
+ }
+
+ if(cmd == GF_RESET){
+ HANDLER_S *p;
+
+ /*
+ * There better be a Definition Handler installed
+ * or else we crap out...
+ */
+ for(p = HANDLERS(hd->html_data); p && EL(p)->handler != html_dl; p = p->below)
+ ;
+
+ if(p){ /* adjust indent level if needed */
+ html_indent(hd->html_data, (int) p->z, HTML_ID_SET);
+ html_blank(hd->html_data, 0);
+ }
+ /* BUG: should really bitch about this */
+ }
+
+ return(0); /* DON'T get linked */
+}
+
+
+/*
+ * HTML <H1> (Headings 1) element handler.
+ *
+ * Bold, very-large font, CENTERED. One or two blank lines
+ * above and below. For our silly character cell's that
+ * means centered and ALL CAPS...
+ */
+int
+html_h1(HANDLER_S *hd, int ch, int cmd)
+{
+ if(cmd == GF_DATA){
+ html_handoff(hd, ch);
+ }
+ else if(cmd == GF_RESET){
+ if(PASS_HTML(hd->html_data)){
+ html_output_raw_tag(hd->html_data, "h1");
+ }
+ else{
+ /* turn ON the centered bit */
+ CENTER_BIT(hd->html_data) = 1;
+ }
+ }
+ else if(cmd == GF_EOD){
+ if(PASS_HTML(hd->html_data)){
+ html_output_string(hd->html_data, "</h1>");
+ }
+ else{
+ /* turn OFF the centered bit, add blank line */
+ CENTER_BIT(hd->html_data) = 0;
+ html_blank(hd->html_data, 1);
+ }
+ }
+
+ return(1); /* get linked */
+}
+
+
+/*
+ * HTML <H2> (Headings 2) element handler
+ */
+int
+html_h2(HANDLER_S *hd, int ch, int cmd)
+{
+ if(cmd == GF_DATA){
+ if(PASS_HTML(hd->html_data)){
+ html_handoff(hd, ch);
+ }
+ else{
+ if((hd->x & HTML_HX_ULINE) && !ASCII_ISSPACE((unsigned char) (ch & 0xff))){
+ HTML_ULINE(hd->html_data, 1);
+ hd->x ^= HTML_HX_ULINE; /* only once! */
+ }
+
+ html_handoff(hd, (ch < 128 && islower((unsigned char) ch))
+ ? toupper((unsigned char) ch) : ch);
+ }
+ }
+ else if(cmd == GF_RESET){
+ if(PASS_HTML(hd->html_data)){
+ html_output_raw_tag(hd->html_data, "h2");
+ }
+ else{
+ /*
+ * Bold, large font, flush-left. One or two blank lines
+ * above and below.
+ */
+ if(CENTER_BIT(hd->html_data)) /* stop centering for now */
+ hd->x = HTML_HX_CENTER;
+ else
+ hd->x = 0;
+
+ hd->x |= HTML_HX_ULINE;
+
+ CENTER_BIT(hd->html_data) = 0;
+ hd->y = html_indent(hd->html_data, 0, HTML_ID_SET);
+ hd->z = HD(hd->html_data)->wrapcol;
+ HD(hd->html_data)->wrapcol = WRAP_COLS(hd->html_data) - 8;
+ html_blank(hd->html_data, 1);
+ }
+ }
+ else if(cmd == GF_EOD){
+ if(PASS_HTML(hd->html_data)){
+ html_output_string(hd->html_data, "</h2>");
+ }
+ else{
+ /*
+ * restore previous centering, and indent level
+ */
+ if(!(hd->x & HTML_HX_ULINE))
+ HTML_ULINE(hd->html_data, 0);
+
+ html_indent(hd->html_data, hd->y, HTML_ID_SET);
+ html_blank(hd->html_data, 1);
+ CENTER_BIT(hd->html_data) = (hd->x & HTML_HX_CENTER) != 0;
+ HD(hd->html_data)->wrapcol = hd->z;
+ }
+ }
+
+ return(1); /* get linked */
+}
+
+
+/*
+ * HTML <H3> (Headings 3) element handler
+ */
+int
+html_h3(HANDLER_S *hd, int ch, int cmd)
+{
+ if(cmd == GF_DATA){
+ if(!PASS_HTML(hd->html_data)){
+ if((hd->x & HTML_HX_ULINE) && !ASCII_ISSPACE((unsigned char) (ch & 0xff))){
+ HTML_ULINE(hd->html_data, 1);
+ hd->x ^= HTML_HX_ULINE; /* only once! */
+ }
+ }
+
+ html_handoff(hd, ch);
+ }
+ else if(cmd == GF_RESET){
+ if(PASS_HTML(hd->html_data)){
+ html_output_raw_tag(hd->html_data, "h3");
+ }
+ else{
+ /*
+ * Italic, large font, slightly indented from the left
+ * margin. One or two blank lines above and below.
+ */
+ if(CENTER_BIT(hd->html_data)) /* stop centering for now */
+ hd->x = HTML_HX_CENTER;
+ else
+ hd->x = 0;
+
+ hd->x |= HTML_HX_ULINE;
+ CENTER_BIT(hd->html_data) = 0;
+ hd->y = html_indent(hd->html_data, 2, HTML_ID_SET);
+ hd->z = HD(hd->html_data)->wrapcol;
+ HD(hd->html_data)->wrapcol = WRAP_COLS(hd->html_data) - 8;
+ html_blank(hd->html_data, 1);
+ }
+ }
+ else if(cmd == GF_EOD){
+ if(PASS_HTML(hd->html_data)){
+ html_output_string(hd->html_data, "</h3>");
+ }
+ else{
+ /*
+ * restore previous centering, and indent level
+ */
+ if(!(hd->x & HTML_HX_ULINE))
+ HTML_ULINE(hd->html_data, 0);
+
+ html_indent(hd->html_data, hd->y, HTML_ID_SET);
+ html_blank(hd->html_data, 1);
+ CENTER_BIT(hd->html_data) = (hd->x & HTML_HX_CENTER) != 0;
+ HD(hd->html_data)->wrapcol = hd->z;
+ }
+ }
+
+ return(1); /* get linked */
+}
+
+
+/*
+ * HTML <H4> (Headings 4) element handler
+ */
+int
+html_h4(HANDLER_S *hd, int ch, int cmd)
+{
+ if(cmd == GF_DATA){
+ html_handoff(hd, ch);
+ }
+ else if(cmd == GF_RESET){
+ if(PASS_HTML(hd->html_data)){
+ html_output_raw_tag(hd->html_data, "h4");
+ }
+ else{
+ /*
+ * Bold, normal font, indented more than H3. One blank line
+ * above and below.
+ */
+ hd->x = CENTER_BIT(hd->html_data); /* stop centering for now */
+ CENTER_BIT(hd->html_data) = 0;
+ hd->y = html_indent(hd->html_data, 4, HTML_ID_SET);
+ hd->z = HD(hd->html_data)->wrapcol;
+ HD(hd->html_data)->wrapcol = WRAP_COLS(hd->html_data) - 8;
+ html_blank(hd->html_data, 1);
+ }
+ }
+ else if(cmd == GF_EOD){
+ if(PASS_HTML(hd->html_data)){
+ html_output_string(hd->html_data, "</h4>");
+ }
+ else{
+ /*
+ * restore previous centering, and indent level
+ */
+ html_indent(hd->html_data, (int) hd->y, HTML_ID_SET);
+ html_blank(hd->html_data, 1);
+ CENTER_BIT(hd->html_data) = hd->x;
+ HD(hd->html_data)->wrapcol = hd->z;
+ }
+ }
+
+ return(1); /* get linked */
+}
+
+
+/*
+ * HTML <H5> (Headings 5) element handler
+ */
+int
+html_h5(HANDLER_S *hd, int ch, int cmd)
+{
+ if(cmd == GF_DATA){
+ html_handoff(hd, ch);
+ }
+ else if(cmd == GF_RESET){
+ if(PASS_HTML(hd->html_data)){
+ html_output_raw_tag(hd->html_data, "h5");
+ }
+ else{
+ /*
+ * Italic, normal font, indented as H4. One blank line
+ * above.
+ */
+ hd->x = CENTER_BIT(hd->html_data); /* stop centering for now */
+ CENTER_BIT(hd->html_data) = 0;
+ hd->y = html_indent(hd->html_data, 6, HTML_ID_SET);
+ hd->z = HD(hd->html_data)->wrapcol;
+ HD(hd->html_data)->wrapcol = WRAP_COLS(hd->html_data) - 8;
+ html_blank(hd->html_data, 1);
+ }
+ }
+ else if(cmd == GF_EOD){
+ if(PASS_HTML(hd->html_data)){
+ html_output_string(hd->html_data, "</h5>");
+ }
+ else{
+ /*
+ * restore previous centering, and indent level
+ */
+ html_indent(hd->html_data, (int) hd->y, HTML_ID_SET);
+ html_blank(hd->html_data, 1);
+ CENTER_BIT(hd->html_data) = hd->x;
+ HD(hd->html_data)->wrapcol = hd->z;
+ }
+ }
+
+ return(1); /* get linked */
+}
+
+
+/*
+ * HTML <H6> (Headings 6) element handler
+ */
+int
+html_h6(HANDLER_S *hd, int ch, int cmd)
+{
+ if(cmd == GF_DATA){
+ html_handoff(hd, ch);
+ }
+ else if(cmd == GF_RESET){
+ if(PASS_HTML(hd->html_data)){
+ html_output_raw_tag(hd->html_data, "h6");
+ }
+ else{
+ /*
+ * Bold, indented same as normal text, more than H5. One
+ * blank line above.
+ */
+ hd->x = CENTER_BIT(hd->html_data); /* stop centering for now */
+ CENTER_BIT(hd->html_data) = 0;
+ hd->y = html_indent(hd->html_data, 8, HTML_ID_SET);
+ hd->z = HD(hd->html_data)->wrapcol;
+ HD(hd->html_data)->wrapcol = WRAP_COLS(hd->html_data) - 8;
+ html_blank(hd->html_data, 1);
+ }
+ }
+ else if(cmd == GF_EOD){
+ if(PASS_HTML(hd->html_data)){
+ html_output_string(hd->html_data, "</h6>");
+ }
+ else{
+ /*
+ * restore previous centering, and indent level
+ */
+ html_indent(hd->html_data, (int) hd->y, HTML_ID_SET);
+ html_blank(hd->html_data, 1);
+ CENTER_BIT(hd->html_data) = hd->x;
+ HD(hd->html_data)->wrapcol = hd->z;
+ }
+ }
+
+ return(1); /* get linked */
+}
+
+
+/*
+ * HTML <BlockQuote> element handler
+ */
+int
+html_blockquote(HANDLER_S *hd, int ch, int cmd)
+{
+ int j;
+#define HTML_BQ_INDENT 6
+
+ if(cmd == GF_DATA){
+ html_handoff(hd, ch);
+ }
+ else if(cmd == GF_RESET){
+ if(PASS_HTML(hd->html_data)){
+ html_output_raw_tag(hd->html_data, "blockquote");
+ }
+ else{
+ /*
+ * A typical rendering might be a slight extra left and
+ * right indent, and/or italic font. The Blockquote element
+ * causes a paragraph break, and typically provides space
+ * above and below the quote.
+ */
+ html_indent(hd->html_data, HTML_BQ_INDENT, HTML_ID_INC);
+ j = HD(hd->html_data)->wrapstate;
+ HD(hd->html_data)->wrapstate = 0;
+ html_blank(hd->html_data, 1);
+ HD(hd->html_data)->wrapstate = j;
+ HD(hd->html_data)->wrapcol -= HTML_BQ_INDENT;
+ }
+ }
+ else if(cmd == GF_EOD){
+ if(PASS_HTML(hd->html_data)){
+ html_output_string(hd->html_data, "</blockquote>");
+ }
+ else{
+ html_blank(hd->html_data, 1);
+
+ j = HD(hd->html_data)->wrapstate;
+ HD(hd->html_data)->wrapstate = 0;
+ html_indent(hd->html_data, -(HTML_BQ_INDENT), HTML_ID_INC);
+ HD(hd->html_data)->wrapstate = j;
+ HD(hd->html_data)->wrapcol += HTML_BQ_INDENT;
+ }
+ }
+
+ return(1); /* get linked */
+}
+
+
+/*
+ * HTML <Address> element handler
+ */
+int
+html_address(HANDLER_S *hd, int ch, int cmd)
+{
+ int j;
+#define HTML_ADD_INDENT 2
+
+ if(cmd == GF_DATA){
+ html_handoff(hd, ch);
+ }
+ else if(cmd == GF_RESET){
+ if(PASS_HTML(hd->html_data)){
+ html_output_raw_tag(hd->html_data, "address");
+ }
+ else{
+ /*
+ * A typical rendering might be a slight extra left and
+ * right indent, and/or italic font. The Blockquote element
+ * causes a paragraph break, and typically provides space
+ * above and below the quote.
+ */
+ html_indent(hd->html_data, HTML_ADD_INDENT, HTML_ID_INC);
+ j = HD(hd->html_data)->wrapstate;
+ HD(hd->html_data)->wrapstate = 0;
+ html_blank(hd->html_data, 1);
+ HD(hd->html_data)->wrapstate = j;
+ }
+ }
+ else if(cmd == GF_EOD){
+ if(PASS_HTML(hd->html_data)){
+ html_output_string(hd->html_data, "</address>");
+ }
+ else{
+ html_blank(hd->html_data, 1);
+
+ j = HD(hd->html_data)->wrapstate;
+ HD(hd->html_data)->wrapstate = 0;
+ html_indent(hd->html_data, -(HTML_ADD_INDENT), HTML_ID_INC);
+ HD(hd->html_data)->wrapstate = j;
+ }
+ }
+
+ return(1); /* get linked */
+}
+
+
+/*
+ * HTML <PRE> (Preformatted Text) element handler
+ */
+int
+html_pre(HANDLER_S *hd, int ch, int cmd)
+{
+ if(cmd == GF_DATA){
+ /*
+ * remove CRLF after '>' in element.
+ * We see CRLF because wrapstate is off.
+ */
+ switch(hd->y){
+ case 2 :
+ if(ch == '\012'){
+ hd->y = 3;
+ return(1);
+ }
+ else
+ html_handoff(hd, '\015');
+
+ break;
+
+ case 1 :
+ if(ch == '\015'){
+ hd->y = 2;
+ return(1);
+ }
+
+ case 3 :
+ /* passing tags? replace CRLF with <BR> to make
+ * sure hard newline survives in the end...
+ */
+ if(PASS_HTML(hd->html_data))
+ hd->y = 4; /* keep looking for CRLF */
+ else
+ hd->y = 0; /* stop looking */
+
+ break;
+
+ case 4 :
+ if(ch == '\015'){
+ hd->y = 5;
+ return(1);
+ }
+
+ break;
+
+ case 5 :
+ hd->y = 4;
+ if(ch == '\012'){
+ html_output_string(hd->html_data, "<br />");
+ return(1);
+ }
+ else
+ html_handoff(hd, '\015'); /* not CRLF, pass raw CR */
+
+ break;
+
+ default : /* zero case */
+ break;
+ }
+
+ html_handoff(hd, ch);
+ }
+ else if(cmd == GF_RESET){
+ hd->y = 1;
+ if(PASS_HTML(hd->html_data)){
+ html_output_raw_tag(hd->html_data, "pre");
+ }
+ else{
+ if(hd->html_data)
+ hd->html_data->f1 = DFL; \
+
+ html_blank(hd->html_data, 1);
+ hd->x = HD(hd->html_data)->wrapstate;
+ HD(hd->html_data)->wrapstate = 0;
+ }
+ }
+ else if(cmd == GF_EOD){
+ if(PASS_HTML(hd->html_data)){
+ html_output_string(hd->html_data, "</pre>");
+ }
+ else{
+ HD(hd->html_data)->wrapstate = (hd->x != 0);
+ html_blank(hd->html_data, 0);
+ }
+ }
+
+ return(1);
+}
+
+
+/*
+ * HTML <CENTER> (Centerd Text) element handler
+ */
+int
+html_center(HANDLER_S *hd, int ch, int cmd)
+{
+ if(cmd == GF_DATA){
+ html_handoff(hd, ch);
+ }
+ else if(cmd == GF_RESET){
+ if(PASS_HTML(hd->html_data)){
+ html_output_raw_tag(hd->html_data, "center");
+ }
+ else{
+ /* turn ON the centered bit */
+ CENTER_BIT(hd->html_data) = 1;
+ }
+ }
+ else if(cmd == GF_EOD){
+ if(PASS_HTML(hd->html_data)){
+ html_output_string(hd->html_data, "</center>");
+ }
+ else{
+ /* turn OFF the centered bit */
+ CENTER_BIT(hd->html_data) = 0;
+ }
+ }
+
+ return(1);
+}
+
+
+/*
+ * HTML <DIV> (Document Divisions) element handler
+ */
+int
+html_div(HANDLER_S *hd, int ch, int cmd)
+{
+ if(cmd == GF_DATA){
+ html_handoff(hd, ch);
+ }
+ else if(cmd == GF_RESET){
+ if(PASS_HTML(hd->html_data)){
+ html_output_raw_tag(hd->html_data, "div");
+ }
+ else{
+ PARAMETER *p;
+
+ for(p = HD(hd->html_data)->el_data->attribs;
+ p && p->attribute;
+ p = p->next)
+ if(!strucmp(p->attribute, "ALIGN")){
+ if(p->value){
+ /* remember previous values */
+ hd->x = CENTER_BIT(hd->html_data);
+ hd->y = html_indent(hd->html_data, 0, HTML_ID_GET);
+
+ html_blank(hd->html_data, 0);
+ CENTER_BIT(hd->html_data) = !strucmp(p->value, "CENTER");
+ html_indent(hd->html_data, 0, HTML_ID_SET);
+ /* NOTE: "RIGHT" not supported yet */
+ }
+ }
+ }
+ }
+ else if(cmd == GF_EOD){
+ if(PASS_HTML(hd->html_data)){
+ html_output_string(hd->html_data, "</div>");
+ }
+ else{
+ /* restore centered bit and indentiousness */
+ CENTER_BIT(hd->html_data) = hd->y;
+ html_indent(hd->html_data, hd->y, HTML_ID_SET);
+ html_blank(hd->html_data, 0);
+ }
+ }
+
+ return(1);
+}
+
+
+/*
+ * HTML <SPAN> (Text Span) element handler
+ */
+int
+html_span(HANDLER_S *hd, int ch, int cmd)
+{
+ if(PASS_HTML(hd->html_data)){
+ if(cmd == GF_DATA){
+ html_handoff(hd, ch);
+ }
+ else if(cmd == GF_RESET){
+ html_output_raw_tag(hd->html_data, "span");
+ }
+ else if(cmd == GF_EOD){
+ html_output_string(hd->html_data, "</span>");
+ }
+
+ return(1);
+ }
+
+ return(0);
+}
+
+
+/*
+ * HTML <KBD> (Text Kbd) element handler
+ */
+int
+html_kbd(HANDLER_S *hd, int ch, int cmd)
+{
+ if(PASS_HTML(hd->html_data)){
+ if(cmd == GF_DATA){
+ html_handoff(hd, ch);
+ }
+ else if(cmd == GF_RESET){
+ html_output_raw_tag(hd->html_data, "kbd");
+ }
+ else if(cmd == GF_EOD){
+ html_output_string(hd->html_data, "</kbd>");
+ }
+
+ return(1);
+ }
+
+ return(0);
+}
+
+
+/*
+ * HTML <DFN> (Text Definition) element handler
+ */
+int
+html_dfn(HANDLER_S *hd, int ch, int cmd)
+{
+ if(PASS_HTML(hd->html_data)){
+ if(cmd == GF_DATA){
+ html_handoff(hd, ch);
+ }
+ else if(cmd == GF_RESET){
+ html_output_raw_tag(hd->html_data, "dfn");
+ }
+ else if(cmd == GF_EOD){
+ html_output_string(hd->html_data, "</dfn>");
+ }
+
+ return(1);
+ }
+
+ return(0);
+}
+
+
+/*
+ * HTML <TT> (Text Tt) element handler
+ */
+int
+html_tt(HANDLER_S *hd, int ch, int cmd)
+{
+ if(PASS_HTML(hd->html_data)){
+ if(cmd == GF_DATA){
+ html_handoff(hd, ch);
+ }
+ else if(cmd == GF_RESET){
+ html_output_raw_tag(hd->html_data, "tt");
+ }
+ else if(cmd == GF_EOD){
+ html_output_string(hd->html_data, "</tt>");
+ }
+
+ return(1);
+ }
+
+ return(0);
+}
+
+
+/*
+ * HTML <VAR> (Text Var) element handler
+ */
+int
+html_var(HANDLER_S *hd, int ch, int cmd)
+{
+ if(PASS_HTML(hd->html_data)){
+ if(cmd == GF_DATA){
+ html_handoff(hd, ch);
+ }
+ else if(cmd == GF_RESET){
+ html_output_raw_tag(hd->html_data, "var");
+ }
+ else if(cmd == GF_EOD){
+ html_output_string(hd->html_data, "</var>");
+ }
+
+ return(1);
+ }
+
+ return(0);
+}
+
+
+/*
+ * HTML <SAMP> (Text Samp) element handler
+ */
+int
+html_samp(HANDLER_S *hd, int ch, int cmd)
+{
+ if(PASS_HTML(hd->html_data)){
+ if(cmd == GF_DATA){
+ html_handoff(hd, ch);
+ }
+ else if(cmd == GF_RESET){
+ html_output_raw_tag(hd->html_data, "samp");
+ }
+ else if(cmd == GF_EOD){
+ html_output_string(hd->html_data, "</samp>");
+ }
+
+ return(1);
+ }
+
+ return(0);
+}
+
+
+/*
+ * HTML <SUP> (Text Superscript) element handler
+ */
+int
+html_sup(HANDLER_S *hd, int ch, int cmd)
+{
+ if(PASS_HTML(hd->html_data)){
+ if(cmd == GF_DATA){
+ html_handoff(hd, ch);
+ }
+ else if(cmd == GF_RESET){
+ html_output_raw_tag(hd->html_data, "sup");
+ }
+ else if(cmd == GF_EOD){
+ html_output_string(hd->html_data, "</sup>");
+ }
+
+ return(1);
+ }
+
+ return(0);
+}
+
+
+/*
+ * HTML <SUB> (Text Subscript) element handler
+ */
+int
+html_sub(HANDLER_S *hd, int ch, int cmd)
+{
+ if(PASS_HTML(hd->html_data)){
+ if(cmd == GF_DATA){
+ html_handoff(hd, ch);
+ }
+ else if(cmd == GF_RESET){
+ html_output_raw_tag(hd->html_data, "sub");
+ }
+ else if(cmd == GF_EOD){
+ html_output_string(hd->html_data, "</sub>");
+ }
+
+ return(1);
+ }
+
+ return(0);
+}
+
+
+/*
+ * HTML <CITE> (Text Citation) element handler
+ */
+int
+html_cite(HANDLER_S *hd, int ch, int cmd)
+{
+ if(PASS_HTML(hd->html_data)){
+ if(cmd == GF_DATA){
+ html_handoff(hd, ch);
+ }
+ else if(cmd == GF_RESET){
+ html_output_raw_tag(hd->html_data, "cite");
+ }
+ else if(cmd == GF_EOD){
+ html_output_string(hd->html_data, "</cite>");
+ }
+
+ return(1);
+ }
+
+ return(0);
+}
+
+
+/*
+ * HTML <CODE> (Text Code) element handler
+ */
+int
+html_code(HANDLER_S *hd, int ch, int cmd)
+{
+ if(PASS_HTML(hd->html_data)){
+ if(cmd == GF_DATA){
+ html_handoff(hd, ch);
+ }
+ else if(cmd == GF_RESET){
+ html_output_raw_tag(hd->html_data, "code");
+ }
+ else if(cmd == GF_EOD){
+ html_output_string(hd->html_data, "</code>");
+ }
+
+ return(1);
+ }
+
+ return(0);
+}
+
+
+/*
+ * HTML <INS> (Text Inserted) element handler
+ */
+int
+html_ins(HANDLER_S *hd, int ch, int cmd)
+{
+ if(PASS_HTML(hd->html_data)){
+ if(cmd == GF_DATA){
+ html_handoff(hd, ch);
+ }
+ else if(cmd == GF_RESET){
+ html_output_raw_tag(hd->html_data, "ins");
+ }
+ else if(cmd == GF_EOD){
+ html_output_string(hd->html_data, "</ins>");
+ }
+
+ return(1);
+ }
+
+ return(0);
+}
+
+
+/*
+ * HTML <DEL> (Text Deleted) element handler
+ */
+int
+html_del(HANDLER_S *hd, int ch, int cmd)
+{
+ if(PASS_HTML(hd->html_data)){
+ if(cmd == GF_DATA){
+ html_handoff(hd, ch);
+ }
+ else if(cmd == GF_RESET){
+ html_output_raw_tag(hd->html_data, "del");
+ }
+ else if(cmd == GF_EOD){
+ html_output_string(hd->html_data, "</del>");
+ }
+
+ return(1);
+ }
+
+ return(0);
+}
+
+
+/*
+ * HTML <ABBR> (Text Abbreviation) element handler
+ */
+int
+html_abbr(HANDLER_S *hd, int ch, int cmd)
+{
+ if(PASS_HTML(hd->html_data)){
+ if(cmd == GF_DATA){
+ html_handoff(hd, ch);
+ }
+ else if(cmd == GF_RESET){
+ html_output_raw_tag(hd->html_data, "abbr");
+ }
+ else if(cmd == GF_EOD){
+ html_output_string(hd->html_data, "</abbr>");
+ }
+
+ return(1);
+ }
+
+ return(0);
+}
+
+
+/*
+ * HTML <SCRIPT> element handler
+ */
+int
+html_script(HANDLER_S *hd, int ch, int cmd)
+{
+ /* Link in and drop everything within on the floor */
+ return(1);
+}
+
+
+/*
+ * HTML <APPLET> element handler
+ */
+int
+html_applet(HANDLER_S *hd, int ch, int cmd)
+{
+ /* Link in and drop everything within on the floor */
+ return(1);
+}
+
+
+/*
+ * HTML <STYLE> CSS element handler
+ */
+int
+html_style(HANDLER_S *hd, int ch, int cmd)
+{
+ static STORE_S *css_stuff ;
+
+ if(PASS_HTML(hd->html_data)){
+ if(cmd == GF_DATA){
+ /* collect style settings */
+ so_writec(ch, css_stuff);
+ }
+ else if(cmd == GF_RESET){
+ if(css_stuff)
+ so_give(&css_stuff);
+
+ css_stuff = so_get(CharStar, NULL, EDIT_ACCESS);
+ }
+ else if(cmd == GF_EOD){
+ /*
+ * TODO: strip anything mischievous and pass on
+ */
+
+ so_give(&css_stuff);
+ }
+ }
+
+ return(1);
+}
+
+/*
+ * RSS 2.0 <RSS> version
+ */
+int
+rss_rss(HANDLER_S *hd, int ch, int cmd)
+{
+ if(cmd == GF_RESET){
+ PARAMETER *p;
+
+ for(p = HD(hd->html_data)->el_data->attribs;
+ p && p->attribute;
+ p = p->next)
+ if(!strucmp(p->attribute, "VERSION")){
+ if(p->value && !strucmp(p->value,"2.0"))
+ return(0); /* do not link in */
+ }
+
+ gf_error("Incompatible RSS version");
+ /* NO RETURN */
+ }
+
+ return(0); /* not linked or error means we never get here */
+}
+
+/*
+ * RSS 2.0 <CHANNEL>
+ */
+int
+rss_channel(HANDLER_S *hd, int ch, int cmd)
+{
+ if(cmd == GF_DATA){
+ html_handoff(hd, ch);
+ }
+ else if(cmd == GF_RESET){
+ RSS_FEED_S *feed;
+
+ feed = RSS_FEED(hd->html_data) = fs_get(sizeof(RSS_FEED_S));
+ memset(feed, 0, sizeof(RSS_FEED_S));
+ }
+
+ return(1); /* link in */
+}
+
+/*
+ * RSS 2.0 <TITLE>
+ */
+int
+rss_title(HANDLER_S *hd, int ch, int cmd)
+{
+ static STORE_S *title_so;
+
+ if(cmd == GF_DATA){
+ /* collect data */
+ if(title_so){
+ so_writec(ch, title_so);
+ }
+ }
+ else if(cmd == GF_RESET){
+ if(RSS_FEED(hd->html_data)){
+ /* prepare for data */
+ if(title_so)
+ so_give(&title_so);
+
+ title_so = so_get(CharStar, NULL, EDIT_ACCESS);
+ }
+ }
+ else if(cmd == GF_EOD){
+ if(title_so){
+ RSS_FEED_S *feed = RSS_FEED(hd->html_data);
+ RSS_ITEM_S *rip;
+
+ if(feed){
+ if(rip = feed->items){
+ for(; rip->next; rip = rip->next)
+ ;
+
+ if(rip->title)
+ fs_give((void **) &rip->title);
+
+ rip->title = cpystr(rss_skip_whitespace(so_text(title_so)));
+ }
+ else{
+ if(feed->title)
+ fs_give((void **) &feed->title);
+
+ feed->title = cpystr(rss_skip_whitespace(so_text(title_so)));
+ }
+ }
+
+ so_give(&title_so);
+ }
+ }
+
+ return(1); /* link in */
+}
+
+/*
+ * RSS 2.0 <IMAGE>
+ */
+int
+rss_image(HANDLER_S *hd, int ch, int cmd)
+{
+ static STORE_S *img_so;
+
+ if(cmd == GF_DATA){
+ /* collect data */
+ if(img_so){
+ so_writec(ch, img_so);
+ }
+ }
+ else if(cmd == GF_RESET){
+ if(RSS_FEED(hd->html_data)){
+ /* prepare to collect data */
+ if(img_so)
+ so_give(&img_so);
+
+ img_so = so_get(CharStar, NULL, EDIT_ACCESS);
+ }
+ }
+ else if(cmd == GF_EOD){
+ if(img_so){
+ RSS_FEED_S *feed = RSS_FEED(hd->html_data);
+
+ if(feed){
+ if(feed->image)
+ fs_give((void **) &feed->image);
+
+ feed->image = cpystr(rss_skip_whitespace(so_text(img_so)));
+ }
+
+ so_give(&img_so);
+ }
+ }
+
+ return(1); /* link in */
+}
+
+/*
+ * RSS 2.0 <LINK>
+ */
+int
+rss_link(HANDLER_S *hd, int ch, int cmd)
+{
+ static STORE_S *link_so;
+
+ if(cmd == GF_DATA){
+ /* collect data */
+ if(link_so){
+ so_writec(ch, link_so);
+ }
+ }
+ else if(cmd == GF_RESET){
+ if(RSS_FEED(hd->html_data)){
+ /* prepare to collect data */
+ if(link_so)
+ so_give(&link_so);
+
+ link_so = so_get(CharStar, NULL, EDIT_ACCESS);
+ }
+ }
+ else if(cmd == GF_EOD){
+ if(link_so){
+ RSS_FEED_S *feed = RSS_FEED(hd->html_data);
+ RSS_ITEM_S *rip;
+
+ if(feed){
+ if(rip = feed->items){
+ for(; rip->next; rip = rip->next)
+ ;
+
+ if(rip->link)
+ fs_give((void **) &rip->link);
+
+ rip->link = cpystr(rss_skip_whitespace(so_text(link_so)));
+ }
+ else{
+ if(feed->link)
+ fs_give((void **) &feed->link);
+
+ feed->link = cpystr(rss_skip_whitespace(so_text(link_so)));
+ }
+ }
+
+ so_give(&link_so);
+ }
+ }
+
+ return(1); /* link in */
+}
+
+/*
+ * RSS 2.0 <DESCRIPTION>
+ */
+int
+rss_description(HANDLER_S *hd, int ch, int cmd)
+{
+ static STORE_S *desc_so;
+
+ if(cmd == GF_DATA){
+ /* collect data */
+ if(desc_so){
+ so_writec(ch, desc_so);
+ }
+ }
+ else if(cmd == GF_RESET){
+ if(RSS_FEED(hd->html_data)){
+ /* prepare to collect data */
+ if(desc_so)
+ so_give(&desc_so);
+
+ desc_so = so_get(CharStar, NULL, EDIT_ACCESS);
+ }
+ }
+ else if(cmd == GF_EOD){
+ if(desc_so){
+ RSS_FEED_S *feed = RSS_FEED(hd->html_data);
+ RSS_ITEM_S *rip;
+
+ if(feed){
+ if(rip = feed->items){
+ for(; rip->next; rip = rip->next)
+ ;
+
+ if(rip->description)
+ fs_give((void **) &rip->description);
+
+ rip->description = cpystr(rss_skip_whitespace(so_text(desc_so)));
+ }
+ else{
+ if(feed->description)
+ fs_give((void **) &feed->description);
+
+ feed->description = cpystr(rss_skip_whitespace(so_text(desc_so)));
+ }
+ }
+
+ so_give(&desc_so);
+ }
+ }
+
+ return(1); /* link in */
+}
+
+/*
+ * RSS 2.0 <TTL> (in minutes)
+ */
+int
+rss_ttl(HANDLER_S *hd, int ch, int cmd)
+{
+ RSS_FEED_S *feed = RSS_FEED(hd->html_data);
+
+ if(cmd == GF_DATA){
+ if(isdigit((unsigned char) ch))
+ feed->ttl = ((feed->ttl * 10) + (ch - '0'));
+ }
+ else if(cmd == GF_RESET){
+ /* prepare to collect data */
+ feed->ttl = 0;
+ }
+ else if(cmd == GF_EOD){
+ }
+
+ return(1); /* link in */
+}
+
+/*
+ * RSS 2.0 <ITEM>
+ */
+int
+rss_item(HANDLER_S *hd, int ch, int cmd)
+{
+ /* BUG: verify no ITEM nesting? */
+ if(cmd == GF_RESET){
+ RSS_FEED_S *feed;
+
+ if((feed = RSS_FEED(hd->html_data)) != NULL){
+ RSS_ITEM_S **rip;
+ int n = 0;
+
+ for(rip = &feed->items; *rip; rip = &(*rip)->next)
+ if(++n > RSS_ITEM_LIMIT)
+ return(0);
+
+ *rip = fs_get(sizeof(RSS_ITEM_S));
+ memset(*rip, 0, sizeof(RSS_ITEM_S));
+ }
+ }
+
+ return(0); /* don't link in */
+}
+
+
+char *
+rss_skip_whitespace(char *s)
+{
+ for(; *s && isspace((unsigned char) *s); s++)
+ ;
+
+ return(s);
+}
+
+
+/*
+ * return the function associated with the given element name
+ */
+ELPROP_S *
+element_properties(FILTER_S *fd, char *el_name)
+{
+ register ELPROP_S *el_table = ELEMENTS(fd);
+
+ for(; el_table->element; el_table++)
+ if(!strucmp(el_name, el_table->element))
+ return(el_table);
+
+ return(NULL);
+}
+
+
+/*
+ * collect element's name and any attribute/value pairs then
+ * dispatch to the appropriate handler.
+ *
+ * Returns 1 : got what we wanted
+ * 0 : we need more data
+ * -1 : bogus input
+ */
+int
+html_element_collector(FILTER_S *fd, int ch)
+{
+ if(ch == '>'){
+ if(ED(fd)->overrun){
+ /*
+ * If problem processing, don't bother doing anything
+ * internally, just return such that none of what we've
+ * digested is displayed.
+ */
+ HTML_DEBUG_EL("too long", ED(fd));
+ return(1); /* Let it go, Jim */
+ }
+ else if(ED(fd)->mkup_decl){
+ if(ED(fd)->badform){
+ dprint((2, "-- html error: bad form: %.*s\n",
+ ED(fd)->len, ED(fd)->buf ? ED(fd)->buf : "?"));
+ /*
+ * Invalid comment -- make some guesses as
+ * to whether we should stop with this greater-than...
+ */
+ if(ED(fd)->buf[0] != '-'
+ || ED(fd)->len < 4
+ || (ED(fd)->buf[1] == '-'
+ && ED(fd)->buf[ED(fd)->len - 1] == '-'
+ && ED(fd)->buf[ED(fd)->len - 2] == '-'))
+ return(1);
+ }
+ else{
+ dprint((5, "-- html: OK: %.*s\n",
+ ED(fd)->len, ED(fd)->buf ? ED(fd)->buf : "?"));
+ if(ED(fd)->start_comment == ED(fd)->end_comment){
+ if(ED(fd)->len > 10){
+ ED(fd)->buf[ED(fd)->len - 2] = '\0';
+ html_element_comment(fd, ED(fd)->buf + 2);
+ }
+
+ return(1);
+ }
+ /* else keep collecting comment below */
+ }
+ }
+ else if(ED(fd)->proc_inst){
+ return(1); /* return without display... */
+ }
+ else if(!strucmp(ED(fd)->element,"STYLE") && ED(fd)->badform){
+ dprint((2, "-- html error: empty tag with STYLE parameter!"));
+ return(1);
+ }
+ else if(!ED(fd)->quoted || ED(fd)->badform){
+ ELPROP_S *ep;
+
+ /*
+ * We either have the whole thing or all that we could
+ * salvage from it. Try our best...
+ */
+
+ if(HD(fd)->bitbucket)
+ return(1); /* element inside chtml clause! */
+
+ if(!ED(fd)->badform && html_element_flush(ED(fd)))
+ return(1); /* return without display... */
+
+ /*
+ * If we ran into an empty tag or we don't know how to deal
+ * with it, just go on, ignoring it...
+ */
+ if(ED(fd)->element && (ep = element_properties(fd, ED(fd)->element))){
+ if(ep->handler){
+ /* dispatch the element's handler */
+ HTML_DEBUG_EL(ED(fd)->end_tag ? "POP" : "PUSH", ED(fd));
+ if(ED(fd)->end_tag){
+ html_pop(fd, ep); /* remove it's handler */
+ }
+ else{
+ /* if a block element, pop any open <p>'s */
+ if(ep->blocklevel){
+ HANDLER_S *tp;
+
+ for(tp = HANDLERS(fd); tp && EL(tp)->handler == html_p; tp = tp->below){
+ HTML_DEBUG_EL("Unclosed <P>", ED(fd));
+ html_pop(fd, EL(tp));
+ break;
+ }
+ }
+
+ /* enforce table nesting */
+ if(!strucmp(ep->element, "tr")){
+ if(!HANDLERS(fd) || (strucmp(EL(HANDLERS(fd))->element, "table") && strucmp(EL(HANDLERS(fd))->element, "tbody") && strucmp(EL(HANDLERS(fd))->element, "thead"))){
+ dprint((2, "-- html error: bad nesting for <TR>, GOT %s\n", (HANDLERS(fd)) ? EL(HANDLERS(fd))->element : "NO-HANDLERS"));
+ if(HANDLERS(fd) && !strucmp(EL(HANDLERS(fd))->element,"tr")){
+ dprint((2, "-- html error: bad nesting popping previous <TR>"));
+ html_pop(fd, EL(HANDLERS(fd)));
+ }
+ else{
+ dprint((2, "-- html error: bad nesting pusing <TABLE>"));
+ html_push(fd, element_properties(fd, "table"));
+ }
+ }
+ }
+ else if(!strucmp(ep->element, "td") || !strucmp(ep->element, "th")){
+ if(!HANDLERS(fd)){
+ dprint((2, "-- html error: bad nesting: NO HANDLERS before <TD>"));
+ html_push(fd, element_properties(fd, "table"));
+ html_push(fd, element_properties(fd, "tr"));
+ }
+ else if(strucmp(EL(HANDLERS(fd))->element, "tr")){
+ dprint((2, "-- html error: bad nesting for <TD>, GOT %s\n", EL(HANDLERS(fd))->element));
+ html_push(fd, element_properties(fd, "tr"));
+ }
+ else if(!strucmp(EL(HANDLERS(fd))->element, "td")){
+ dprint((2, "-- html error: bad nesting popping <TD>"));
+ html_pop(fd, EL(HANDLERS(fd)));
+ }
+ }
+
+ /* add it's handler */
+ if(html_push(fd, ep)){
+ if(ED(fd)->empty){
+ /* remove empty element */
+ html_pop(fd, ep);
+ }
+ }
+ }
+ }
+ else {
+ HTML_DEBUG_EL("IGNORED", ED(fd));
+ }
+ }
+ else{ /* else, empty or unrecognized */
+ HTML_DEBUG_EL("?", ED(fd));
+ }
+
+ return(1); /* all done! see, that didn't hurt */
+ }
+ }
+ else if(ch == '/' && ED(fd)->element && ED(fd)->len){
+ ED(fd)->empty = 1;
+ }
+ else
+ ED(fd)->empty = 0;
+
+ if(ED(fd)->mkup_decl){
+ if((ch &= 0xff) == '-'){
+ if(ED(fd)->hyphen){
+ ED(fd)->hyphen = 0;
+ if(ED(fd)->start_comment)
+ ED(fd)->end_comment = 1;
+ else
+ ED(fd)->start_comment = 1;
+ }
+ else
+ ED(fd)->hyphen = 1;
+ }
+ else{
+ if(ED(fd)->end_comment)
+ ED(fd)->start_comment = ED(fd)->end_comment = 0;
+
+ /*
+ * no "--" after ! or non-whitespace between comments - bad
+ */
+ if(ED(fd)->len < 2 || (!ED(fd)->start_comment
+ && !ASCII_ISSPACE((unsigned char) ch)))
+ ED(fd)->badform = 1; /* non-comment! */
+
+ ED(fd)->hyphen = 0;
+ }
+
+ /*
+ * Remember the comment for possible later processing, if
+ * it get's too long, remember first and last few chars
+ * so we know when to terminate (and throw some garbage
+ * in between when we toss out what's between.
+ */
+ if(ED(fd)->len == HTML_BUF_LEN){
+ ED(fd)->buf[2] = ED(fd)->buf[3] = 'X';
+ ED(fd)->buf[4] = ED(fd)->buf[ED(fd)->len - 2];
+ ED(fd)->buf[5] = ED(fd)->buf[ED(fd)->len - 1];
+ ED(fd)->len = 6;
+ }
+
+ ED(fd)->buf[(ED(fd)->len)++] = ch;
+ return(0); /* comments go in the bit bucket */
+ }
+ else if(ED(fd)->overrun || ED(fd)->badform){
+ return(0); /* swallow char's until next '>' */
+ }
+ else if(!ED(fd)->element && !ED(fd)->len){
+ if(ch == '/'){ /* validate leading chars */
+ ED(fd)->end_tag = 1;
+ return(0);
+ }
+ else if(ch == '!'){
+ ED(fd)->mkup_decl = 1;
+ return(0);
+ }
+ else if(ch == '?'){
+ ED(fd)->proc_inst = 1;
+ return(0);
+ }
+ else if(!isalpha((unsigned char) ch))
+ return(-1); /* can't be a tag! */
+ }
+ else if(ch == '\"' || ch == '\''){
+ if(!ED(fd)->hit_equal){
+ ED(fd)->badform = 1; /* quote in element name?!? */
+ return(0);
+ }
+
+ if(ED(fd)->quoted){
+ if(ED(fd)->quoted == (char) ch){
+ /* end of a quoted value */
+ ED(fd)->quoted = 0;
+ if(ED(fd)->len && html_element_flush(ED(fd)))
+ ED(fd)->badform = 1;
+
+ return(0); /* continue collecting chars */
+ }
+ /* ELSE fall thru writing other quoting char */
+ }
+ else{
+ ED(fd)->quoted = (char) ch;
+ ED(fd)->was_quoted = 1;
+ return(0); /* need more data */
+ }
+ }
+
+ ch &= 0xff; /* strip any "literal" high bits */
+ if(ED(fd)->quoted
+ || isalnum(ch)
+ || strchr("#-.!", ch)){
+ if(ED(fd)->len < ((ED(fd)->element || !ED(fd)->hit_equal)
+ ? HTML_BUF_LEN:MAX_ELEMENT)){
+ ED(fd)->buf[(ED(fd)->len)++] = ch;
+ }
+ else
+ ED(fd)->overrun = 1; /* flag it broken */
+ }
+ else if(ASCII_ISSPACE((unsigned char) ch) || ch == '='){
+ if((ED(fd)->len || ED(fd)->was_quoted) && html_element_flush(ED(fd))){
+ ED(fd)->badform = 1;
+ return(0); /* else, we ain't done yet */
+ }
+
+ if(!ED(fd)->hit_equal)
+ ED(fd)->hit_equal = (ch == '=');
+ }
+ else
+ ED(fd)->badform = 1; /* unrecognized data?? */
+
+ return(0); /* keep collecting */
+}
+
+
+/*
+ * Element collector found complete string, integrate it and reset
+ * internal collection buffer.
+ *
+ * Returns zero if element collection buffer flushed, error flag otherwise
+ */
+int
+html_element_flush(CLCTR_S *el_data)
+{
+ int rv = 0;
+
+ if(el_data->hit_equal){ /* adding a value */
+ el_data->hit_equal = 0;
+ if(el_data->cur_attrib){
+ if(!el_data->cur_attrib->value){
+ el_data->cur_attrib->value = cpystr(el_data->len
+ ? el_data->buf : "");
+ }
+ else{
+ dprint((2, "** element: unexpected value: %.10s...\n",
+ (el_data->len && el_data->buf) ? el_data->buf : "\"\""));
+ rv = 1;
+ }
+ }
+ else{
+ dprint((2, "** element: missing attribute name: %.10s...\n",
+ (el_data->len && el_data->buf) ? el_data->buf : "\"\""));
+ rv = 2;
+ }
+ }
+ else if(el_data->len){
+ if(!el_data->element){
+ el_data->element = cpystr(el_data->buf);
+ }
+ else{
+ PARAMETER *p = (PARAMETER *)fs_get(sizeof(PARAMETER));
+ memset(p, 0, sizeof(PARAMETER));
+ if(el_data->attribs){
+ el_data->cur_attrib->next = p;
+ el_data->cur_attrib = p;
+ }
+ else
+ el_data->attribs = el_data->cur_attrib = p;
+
+ p->attribute = cpystr(el_data->buf);
+ }
+
+ }
+
+ el_data->was_quoted = 0; /* reset collector buf and state */
+ el_data->len = 0;
+ memset(el_data->buf, 0, HTML_BUF_LEN);
+ return(rv); /* report whatever happened above */
+}
+
+
+/*
+ * html_element_comment - "Special" comment handling here
+ */
+void
+html_element_comment(FILTER_S *f, char *s)
+{
+ char *p;
+
+ while(*s && ASCII_ISSPACE((unsigned char) *s))
+ s++;
+
+ /*
+ * WARNING: "!--chtml" denotes "Conditional HTML", a UW-ism.
+ */
+ if(!struncmp(s, "chtml ", 6)){
+ s += 6;
+ if(!struncmp(s, "if ", 3)){
+ HD(f)->bitbucket = 1; /* default is failure! */
+ switch(*(s += 3)){
+ case 'P' :
+ case 'p' :
+ if(!struncmp(s + 1, "inemode=", 8)){
+ if(!strucmp(s = removing_quotes(s + 9), "function_key")
+ && F_ON(F_USE_FK, ps_global))
+ HD(f)->bitbucket = 0;
+ else if(!strucmp(s, "running"))
+ HD(f)->bitbucket = 0;
+ else if(!strucmp(s, "phone_home") && ps_global->phone_home)
+ HD(f)->bitbucket = 0;
+#ifdef _WINDOWS
+ else if(!strucmp(s, "os_windows"))
+ HD(f)->bitbucket = 0;
+#endif
+ }
+
+ break;
+
+ case '[' : /* test */
+ if((p = strindex(++s, ']')) != NULL){
+ *p = '\0'; /* tie off test string */
+ removing_leading_white_space(s);
+ removing_trailing_white_space(s);
+ if(*s == '-' && *(s+1) == 'r'){ /* readable file? */
+ for(s += 2; *s && ASCII_ISSPACE((unsigned char) *s); s++)
+ ;
+
+
+ HD(f)->bitbucket = (can_access(CHTML_VAR_EXPAND(removing_quotes(s)),
+ READ_ACCESS) != 0);
+ }
+ }
+
+ break;
+
+ default :
+ break;
+ }
+ }
+ else if(!strucmp(s, "else")){
+ HD(f)->bitbucket = !HD(f)->bitbucket;
+ }
+ else if(!strucmp(s, "endif")){
+ /* Clean up after chtml here */
+ HD(f)->bitbucket = 0;
+ }
+ }
+ else if(!HD(f)->bitbucket){
+ if(!struncmp(s, "#include ", 9)){
+ char buf[MAILTMPLEN], *bufp;
+ int len, end_of_line;
+ FILE *fp;
+
+ /* Include the named file */
+ if(!struncmp(s += 9, "file=", 5)
+ && (fp = our_fopen(CHTML_VAR_EXPAND(removing_quotes(s+5)), "r"))){
+ html_element_output(f, HTML_NEWLINE);
+
+ while(fgets(buf, sizeof(buf), fp)){
+ if((len = strlen(buf)) && buf[len-1] == '\n'){
+ end_of_line = 1;
+ buf[--len] = '\0';
+ }
+ else
+ end_of_line = 0;
+
+ for(bufp = buf; len; bufp++, len--)
+ html_element_output(f, (int) *bufp);
+
+ if(end_of_line)
+ html_element_output(f, HTML_NEWLINE);
+ }
+
+ fclose(fp);
+ html_element_output(f, HTML_NEWLINE);
+ HD(f)->blanks = 0;
+ if(f->f1 == WSPACE)
+ f->f1 = DFL;
+ }
+ }
+ else if(!struncmp(s, "#echo ", 6)){
+ if(!struncmp(s += 6, "var=", 4)){
+ char *p, buf[MAILTMPLEN];
+ ADDRESS *adr;
+ extern char datestamp[];
+
+ if(!strcmp(s = removing_quotes(s + 4), "ALPINE_VERSION")){
+ p = ALPINE_VERSION;
+ }
+ else if(!strcmp(s, "ALPINE_REVISION")){
+ p = get_alpine_revision_string(buf, sizeof(buf));
+ }
+ else if(!strcmp(s, "C_CLIENT_VERSION")){
+ p = CCLIENTVERSION;
+ }
+ else if(!strcmp(s, "ALPINE_COMPILE_DATE")){
+ p = datestamp;
+ }
+ else if(!strcmp(s, "ALPINE_TODAYS_DATE")){
+ rfc822_date(p = buf);
+ }
+ else if(!strcmp(s, "_LOCAL_FULLNAME_")){
+ p = (ps_global->VAR_LOCAL_FULLNAME
+ && ps_global->VAR_LOCAL_FULLNAME[0])
+ ? ps_global->VAR_LOCAL_FULLNAME
+ : "Local Support";
+ }
+ else if(!strcmp(s, "_LOCAL_ADDRESS_")){
+ p = (ps_global->VAR_LOCAL_ADDRESS
+ && ps_global->VAR_LOCAL_ADDRESS[0])
+ ? ps_global->VAR_LOCAL_ADDRESS
+ : "postmaster";
+ adr = rfc822_parse_mailbox(&p, ps_global->maildomain);
+ snprintf(p = buf, sizeof(buf), "%s@%s", adr->mailbox, adr->host);
+ mail_free_address(&adr);
+ }
+ else if(!strcmp(s, "_BUGS_FULLNAME_")){
+ p = (ps_global->VAR_BUGS_FULLNAME
+ && ps_global->VAR_BUGS_FULLNAME[0])
+ ? ps_global->VAR_BUGS_FULLNAME
+ : "Place to report Alpine Bugs";
+ }
+ else if(!strcmp(s, "_BUGS_ADDRESS_")){
+ p = (ps_global->VAR_BUGS_ADDRESS
+ && ps_global->VAR_BUGS_ADDRESS[0])
+ ? ps_global->VAR_BUGS_ADDRESS : "postmaster";
+ adr = rfc822_parse_mailbox(&p, ps_global->maildomain);
+ snprintf(p = buf, sizeof(buf), "%s@%s", adr->mailbox, adr->host);
+ mail_free_address(&adr);
+ }
+ else if(!strcmp(s, "CURRENT_DIR")){
+ getcwd(p = buf, sizeof(buf));
+ }
+ else if(!strcmp(s, "HOME_DIR")){
+ p = ps_global->home_dir;
+ }
+ else if(!strcmp(s, "PINE_CONF_PATH")){
+#if defined(_WINDOWS) || !defined(SYSTEM_PINERC)
+ p = "/usr/local/lib/pine.conf";
+#else
+ p = SYSTEM_PINERC;
+#endif
+ }
+ else if(!strcmp(s, "PINE_CONF_FIXED_PATH")){
+#ifdef SYSTEM_PINERC_FIXED
+ p = SYSTEM_PINERC_FIXED;
+#else
+ p = "/usr/local/lib/pine.conf.fixed";
+#endif
+ }
+ else if(!strcmp(s, "PINE_INFO_PATH")){
+ p = SYSTEM_PINE_INFO_PATH;
+ }
+ else if(!strcmp(s, "MAIL_SPOOL_PATH")){
+ p = sysinbox();
+ }
+ else if(!strcmp(s, "MAIL_SPOOL_LOCK_PATH")){
+ /* Don't put the leading /tmp/. */
+ int i, j;
+
+ p = sysinbox();
+ if(p){
+ for(j = 0, i = 0; p[i] && j < MAILTMPLEN - 1; i++){
+ if(p[i] == '/')
+ buf[j++] = '\\';
+ else
+ buf[j++] = p[i];
+ }
+ buf[j++] = '\0';
+ p = buf;
+ }
+ }
+ else if(!struncmp(s, "VAR_", 4)){
+ p = s+4;
+ if(pith_opt_pretty_var_name)
+ p = (*pith_opt_pretty_var_name)(p);
+ }
+ else if(!struncmp(s, "FEAT_", 5)){
+ p = s+5;
+ if(pith_opt_pretty_feature_name)
+ p = (*pith_opt_pretty_feature_name)(p, -1);
+ }
+ else
+ p = NULL;
+
+ if(p){
+ if(f->f1 == WSPACE){
+ html_element_output(f, ' ');
+ f->f1 = DFL; /* clear it */
+ }
+
+ while(*p)
+ html_element_output(f, (int) *p++);
+ }
+ }
+ }
+ }
+}
+
+
+void
+html_element_output(FILTER_S *f, int ch)
+{
+ if(HANDLERS(f))
+ (*EL(HANDLERS(f))->handler)(HANDLERS(f), ch, GF_DATA);
+ else
+ html_output(f, ch);
+}
+
+
+/*
+ * collect html entity and return its UCS value when done.
+ *
+ * Returns HTML_MOREDATA : we need more data
+ * HTML_ENTITY : entity collected
+ * HTML_BADVALUE : good data, but no named match or out of range
+ * HTML_BADDATA : invalid input
+ *
+ * NOTES:
+ * - entity format is "'&' tag ';'" and represents a literal char
+ * - named entities are CASE SENSITIVE.
+ * - numeric char references (where the tag is prefixed with a '#')
+ * are a char with that numbers value
+ * - numeric vals are 0-255 except for the ranges: 0-8, 11-31, 127-159.
+ */
+int
+html_entity_collector(FILTER_S *f, int ch, UCS *ucs, char **alt)
+{
+ static int len = 0;
+ static char buf[MAX_ENTITY+2];
+ int rv, i;
+
+ if(len == MAX_ENTITY){
+ rv = HTML_BADDATA;
+ }
+ else if((len == 0)
+ ? (isalpha((unsigned char) ch) || ch == '#')
+ : ((isdigit((unsigned char) ch)
+ || (isalpha((unsigned char) ch) && buf[0] != '#')))){
+ buf[len++] = ch;
+ return(HTML_MOREDATA);
+ }
+ else if(ch == ';' || ASCII_ISSPACE((unsigned char) ch)){
+ buf[len] = '\0'; /* got something! */
+ if(buf[0] == '#'){
+ *ucs = (UCS) strtoul(&buf[1], NULL, 10);
+ if(alt){
+ *alt = NULL;
+ for(i = 0; i < sizeof(entity_tab)/sizeof(struct html_entities); i++)
+ if(entity_tab[i].value == *ucs){
+ *alt = entity_tab[i].plain;
+ break;
+ }
+ }
+
+ len = 0;
+ return(HTML_ENTITY);
+ }
+ else{
+ rv = HTML_BADVALUE; /* in case of no match */
+ for(i = 0; i < sizeof(entity_tab)/sizeof(struct html_entities); i++)
+ if(strcmp(entity_tab[i].name, buf) == 0){
+ *ucs = entity_tab[i].value;
+ if(alt)
+ *alt = entity_tab[i].plain;
+
+ len = 0;
+ return(HTML_ENTITY);
+ }
+ }
+ }
+ else
+ rv = HTML_BADDATA; /* bogus input! */
+
+ if(alt){
+ buf[len] = '\0';
+ *alt = buf;
+ }
+
+ len = 0;
+ return(rv);
+}
+
+
+/*----------------------------------------------------------------------
+ HTML text to plain text filter
+
+ This basically tries to do the best it can with HTML 2.0 (RFC1866)
+ with bits of RFC 1942 (plus some HTML 3.2 thrown in as well) text
+ formatting.
+
+ ----*/
+void
+gf_html2plain(FILTER_S *f, int flg)
+{
+/* BUG: qoute incoming \255 values (see "yuml" above!) */
+ if(flg == GF_DATA){
+ register int c;
+ GF_INIT(f, f->next);
+
+ if(!HTML_WROTE(f)){
+ int ii;
+
+ for(ii = HTML_INDENT(f); ii > 0; ii--)
+ html_putc(f, ' ');
+
+ HTML_WROTE(f) = 1;
+ }
+
+ while(GF_GETC(f, c)){
+ /*
+ * First we have to collect any literal entities...
+ * that is, IF we're not already collecting one
+ * AND we're not in element's text or, if we are, we're
+ * not in quoted text. Whew.
+ */
+ if(f->t){
+ char *alt = NULL;
+ UCS ucs;
+
+ switch(html_entity_collector(f, c, &ucs, &alt)){
+ case HTML_MOREDATA: /* more data required? */
+ continue; /* go get another char */
+
+ case HTML_BADVALUE :
+ case HTML_BADDATA :
+ /* if supplied, process bogus data */
+ HTML_PROC(f, '&');
+ for(; *alt; alt++){
+ unsigned int uic = *alt;
+ HTML_PROC(f, uic);
+ }
+
+ if(c == '&' && !HD(f)->quoted){
+ f->t = '&';
+ continue;
+ }
+ else
+ f->t = 0; /* don't come back next time */
+
+ break;
+
+ default : /* thing to process */
+ f->t = 0; /* don't come back */
+
+ /*
+ * do something with UCS codepoint. If it's
+ * not displayable then use the alt version
+ * otherwise
+ * cvt UCS to UTF-8 and toss into next filter.
+ */
+ if(ucs > 127 && wcellwidth(ucs) < 0){
+ if(alt){
+ for(; *alt; alt++){
+ c = MAKE_LITERAL(*alt);
+ HTML_PROC(f, c);
+ }
+
+ continue;
+ }
+ else
+ c = MAKE_LITERAL('?');
+ }
+ else{
+ unsigned char utf8buf[8], *p1, *p2;
+
+ p2 = utf8_put(p1 = (unsigned char *) utf8buf, (unsigned long) ucs);
+ for(; p1 < p2; p1++){
+ c = MAKE_LITERAL(*p1);
+ HTML_PROC(f, c);
+ }
+
+ continue;
+ }
+
+ break;
+ }
+ }
+ else if(!PASS_HTML(f) && c == '&' && !HD(f)->quoted){
+ f->t = '&';
+ continue;
+ }
+
+ /*
+ * then we process whatever we got...
+ */
+
+ HTML_PROC(f, c);
+ }
+
+ GF_OP_END(f); /* clean up our input pointers */
+ }
+ else if(flg == GF_EOD){
+ while(HANDLERS(f)){
+ dprint((2, "-- html error: no closing tag for %s",EL(HANDLERS(f))->element));
+ html_pop(f, EL(HANDLERS(f)));
+ }
+
+ html_output(f, HTML_NEWLINE);
+ if(ULINE_BIT(f))
+ HTML_ULINE(f, ULINE_BIT(f) = 0);
+
+ if(BOLD_BIT(f))
+ HTML_BOLD(f, BOLD_BIT(f) = 0);
+
+ HTML_FLUSH(f);
+ fs_give((void **)&f->line);
+ if(HD(f)->color)
+ free_color_pair(&HD(f)->color);
+
+ fs_give(&f->data);
+ if(f->opt){
+ if(((HTML_OPT_S *)f->opt)->base)
+ fs_give((void **) &((HTML_OPT_S *)f->opt)->base);
+
+ fs_give(&f->opt);
+ }
+
+ (*f->next->f)(f->next, GF_DATA);
+ (*f->next->f)(f->next, GF_EOD);
+ }
+ else if(flg == GF_RESET){
+ dprint((9, "-- gf_reset html2plain\n"));
+ f->data = (HTML_DATA_S *) fs_get(sizeof(HTML_DATA_S));
+ memset(f->data, 0, sizeof(HTML_DATA_S));
+ /* start with flowing text */
+ HD(f)->wrapstate = !PASS_HTML(f);
+ HD(f)->wrapcol = WRAP_COLS(f);
+ f->f1 = DFL; /* state */
+ f->f2 = 0; /* chars in wrap buffer */
+ f->n = 0L; /* chars on line so far */
+ f->linep = f->line = (char *)fs_get(HTML_BUF_LEN * sizeof(char));
+ HD(f)->line_bufsize = HTML_BUF_LEN; /* initial bufsize of line */
+ HD(f)->alt_entity = (!ps_global->display_charmap
+ || strucmp(ps_global->display_charmap, "iso-8859-1"));
+ HD(f)->cb.cbufp = HD(f)->cb.cbufend = HD(f)->cb.cbuf;
+ }
+}
+
+
+
+/*
+ * html_indent - do the requested indent level function with appropriate
+ * flushing and such.
+ *
+ * Returns: indent level prior to set/increment
+ */
+int
+html_indent(FILTER_S *f, int val, int func)
+{
+ int old = HD(f)->indent_level;
+
+ /* flush pending data at old indent level */
+ switch(func){
+ case HTML_ID_INC :
+ html_output_flush(f);
+ if((HD(f)->indent_level += val) < 0)
+ HD(f)->indent_level = 0;
+
+ break;
+
+ case HTML_ID_SET :
+ html_output_flush(f);
+ HD(f)->indent_level = val;
+ break;
+
+ default :
+ break;
+ }
+
+ return(old);
+}
+
+
+
+/*
+ * html_blanks - Insert n blank lines into output
+ */
+void
+html_blank(FILTER_S *f, int n)
+{
+ /* Cap off any flowing text, and then write blank lines */
+ if(f->f2 || f->n || CENTER_BIT(f) || HD(f)->centered || WRAPPED_LEN(f))
+ html_output(f, HTML_NEWLINE);
+
+ if(HD(f)->wrapstate)
+ while(HD(f)->blanks < n) /* blanks inc'd by HTML_NEWLINE */
+ html_output(f, HTML_NEWLINE);
+}
+
+
+
+/*
+ * html_newline -- insert a newline mindful of embedded tags
+ */
+void
+html_newline(FILTER_S *f)
+{
+ html_write_newline(f); /* commit an actual newline */
+
+ if(f->n){ /* and keep track of blank lines */
+ HD(f)->blanks = 0;
+ f->n = 0L;
+ }
+ else
+ HD(f)->blanks++;
+}
+
+
+/*
+ * output the given char, handling any requested wrapping.
+ * It's understood that all whitespace handed us is written. In other
+ * words, junk whitespace is weeded out before it's given to us here.
+ *
+ */
+void
+html_output(FILTER_S *f, int ch)
+{
+ UCS uc;
+ int width;
+ void (*o_f)(FILTER_S *, int, int) = CENTER_BIT(f) ? html_output_centered : html_output_normal;
+
+ /*
+ * if ch is a control token, just pass it on, else, collect
+ * utf8-encoded characters to determine width,then feed into
+ * output routines
+ */
+ if(ch == TAG_EMBED || HD(f)->embedded.state || (ch > 0xff && IS_LITERAL(ch) == 0)){
+ (*o_f)(f, ch, 1);
+ }
+ else if(utf8_to_ucs4_oneatatime(ch & 0xff, &(HD(f)->cb), &uc, &width)){
+ unsigned char *cp;
+
+ for(cp = HD(f)->cb.cbuf; cp <= HD(f)->cb.cbufend; cp++){
+ (*o_f)(f, *cp, width);
+ width = 0; /* only count it once */
+ }
+
+ HD(f)->cb.cbufp = HD(f)->cb.cbufend = HD(f)->cb.cbuf;
+ }
+ else
+ HD(f)->cb.cbufend = HD(f)->cb.cbufp;
+ /* else do nothing until we have a full character */
+}
+
+
+void
+html_output_string(FILTER_S *f, char *s)
+{
+ for(; *s; s++)
+ html_output(f, *s);
+}
+
+
+void
+html_output_raw_tag(FILTER_S *f, char *tag)
+{
+ PARAMETER *p;
+ char *vp;
+ int i;
+
+ html_output(f, '<');
+ html_output_string(f, tag);
+ for(p = HD(f)->el_data->attribs;
+ p && p->attribute;
+ p = p->next){
+ /* SECURITY: no javascript */
+ /* PRIVACY: no img src without permission */
+ /* BUGS: no class collisions since <head> ignored */
+ if(html_event_attribute(p->attribute)
+ || !strucmp(p->attribute, "class")
+ || (!PASS_IMAGES(f) && !strucmp(tag, "img") && !strucmp(p->attribute, "src")))
+ continue;
+
+ /* PRIVACY: sniff out background images */
+ if(p->value && !PASS_IMAGES(f)){
+ if(!strucmp(p->attribute, "style")){
+ if((vp = srchstr(p->value, "background-image")) != NULL){
+ /* neuter in place */
+ vp[11] = vp[12] = vp[13] = vp[14] = vp[15] = 'X';
+ }
+ else{
+ for(vp = p->value; (vp = srchstr(vp, "background")) != NULL; vp++)
+ if(vp[10] == ' ' || vp[10] == ':')
+ for(i = 11; vp[i] && vp[i] != ';'; i++)
+ if((vp[i] == 'u' && vp[i+1] == 'r' && vp[i+2] == 'l' && vp[i+3] == '(')
+ || vp[i] == ':' || vp[i] == '/' || vp[i] == '.')
+ vp[0] = 'X';
+ }
+ }
+ else if(!strucmp(p->attribute, "background")){
+ char *ip;
+
+ for(ip = p->value; *ip && !(*ip == ':' || *ip == '/' || *ip == '.'); ip++)
+ ;
+
+ if(ip)
+ continue;
+ }
+ }
+
+ html_output(f, ' ');
+ html_output_string(f, p->attribute);
+ if(p->value){
+ html_output(f, '=');
+ html_output(f, '\"');
+ html_output_string(f, p->value);
+ html_output(f, '\"');
+ }
+ }
+
+ /* append warning to form submission */
+ if(!strucmp(tag, "form")){
+ html_output_string(f, " onsubmit=\"return window.confirm('This form is submitting information to an outside server.\\nAre you sure?');\"");
+ }
+
+ if(ED(f)->end_tag){
+ html_output(f, ' ');
+ html_output(f, '/');
+ }
+
+ html_output(f, '>');
+}
+
+
+int
+html_event_attribute(char *attr)
+{
+ int i;
+ static char *events[] = {
+ "onabort", "onblur", "onchange", "onclick", "ondblclick", "ondragdrop",
+ "onerror", "onfocus", "onkeydown", "onkeypress", "onkeyup", "onload",
+ "onmousedown", "onmousemove", "onmouseout", "onmouseover", "onmouseup", "onmove",
+ "onreset", "onresize", "onselec", "onsubmit", "onunload"
+ };
+
+ if((attr[0] == 'o' || attr[0] == 'O') && (attr[1] == 'n' || attr[1] == 'N'))
+ for(i = 0; i < sizeof(events)/sizeof(events[0]); i++)
+ if(!strucmp(attr, events[i]))
+ return(TRUE);
+
+ return(FALSE);
+}
+
+
+void
+html_output_normal(FILTER_S *f, int ch, int width)
+{
+ if(HD(f)->centered){
+ html_centered_flush(f);
+ fs_give((void **) &HD(f)->centered->line.buf);
+ fs_give((void **) &HD(f)->centered->word.buf);
+ fs_give((void **) &HD(f)->centered);
+ }
+
+ if(HD(f)->wrapstate){
+ if(ch == HTML_NEWLINE){ /* hard newline */
+ html_output_flush(f);
+ html_newline(f);
+ }
+ else
+ HD(f)->blanks = 0; /* reset blank line counter */
+
+ if(ch == TAG_EMBED){ /* takes up no space */
+ HD(f)->embedded.state = -5;
+ HTML_LINEP_PUTC(f, TAG_EMBED);
+ }
+ else if(HD(f)->embedded.state){ /* ditto */
+ if(HD(f)->embedded.state == -5){
+ /* looking for specially handled tags following TAG_EMBED */
+ if(ch == TAG_HANDLE)
+ HD(f)->embedded.state = -1; /* next ch is length */
+ else if(ch == TAG_FGCOLOR || ch == TAG_BGCOLOR){
+ if(!HD(f)->color)
+ HD(f)->color = new_color_pair(NULL, NULL);
+
+ if(ch == TAG_FGCOLOR)
+ HD(f)->embedded.color = HD(f)->color->fg;
+ else
+ HD(f)->embedded.color = HD(f)->color->bg;
+
+ HD(f)->embedded.state = RGBLEN;
+ }
+ else
+ HD(f)->embedded.state = 0; /* non-special */
+ }
+ else if(HD(f)->embedded.state > 0){
+ /* collecting up an RGBLEN color or length, ignore tags */
+ (HD(f)->embedded.state)--;
+ if(HD(f)->embedded.color)
+ *HD(f)->embedded.color++ = ch;
+
+ if(HD(f)->embedded.state == 0 && HD(f)->embedded.color){
+ *HD(f)->embedded.color = '\0';
+ HD(f)->embedded.color = NULL;
+ }
+ }
+ else if(HD(f)->embedded.state < 0){
+ HD(f)->embedded.state = ch; /* number of embedded chars */
+ }
+ else{
+ (HD(f)->embedded.state)--;
+ if(HD(f)->embedded.color)
+ *HD(f)->embedded.color++ = ch;
+
+ if(HD(f)->embedded.state == 0 && HD(f)->embedded.color){
+ *HD(f)->embedded.color = '\0';
+ HD(f)->embedded.color = NULL;
+ }
+ }
+
+ HTML_LINEP_PUTC(f, ch);
+ }
+ else if(HTML_ISSPACE(ch)){
+ html_output_flush(f);
+ }
+ else{
+ if(HD(f)->prefix)
+ html_a_prefix(f);
+
+ if((f->f2 += width) + 1 >= WRAP_COLS(f)){
+ HTML_LINEP_PUTC(f, ch & 0xff);
+ HTML_FLUSH(f);
+ html_newline(f);
+ if(HD(f)->in_anchor)
+ html_write_anchor(f, HD(f)->in_anchor);
+ }
+ else
+ HTML_LINEP_PUTC(f, ch & 0xff);
+ }
+ }
+ else{
+ if(HD(f)->prefix)
+ html_a_prefix(f);
+
+ html_output_flush(f);
+
+ switch(HD(f)->embedded.state){
+ case 0 :
+ switch(ch){
+ default :
+ /*
+ * It's difficult to both preserve whitespace and wrap at the
+ * same time so we'll do a dumb wrap at the edge of the screen.
+ * Since this shouldn't come up much in real life we'll hope
+ * it is good enough.
+ */
+ if(!PASS_HTML(f) && (f->n + width) > WRAP_COLS(f))
+ html_newline(f);
+
+ f->n += width; /* inc displayed char count */
+ HD(f)->blanks = 0; /* reset blank line counter */
+ html_putc(f, ch & 0xff);
+ break;
+
+ case TAG_EMBED : /* takes up no space */
+ html_putc(f, TAG_EMBED);
+ HD(f)->embedded.state = -2;
+ break;
+
+ case HTML_NEWLINE : /* newline handling */
+ if(!f->n)
+ break;
+
+ case '\n' :
+ html_newline(f);
+
+ case '\r' :
+ break;
+ }
+
+ break;
+
+ case -2 :
+ HD(f)->embedded.state = 0;
+ switch(ch){
+ case TAG_HANDLE :
+ HD(f)->embedded.state = -1; /* next ch is length */
+ break;
+
+ case TAG_BOLDON :
+ BOLD_BIT(f) = 1;
+ break;
+
+ case TAG_BOLDOFF :
+ BOLD_BIT(f) = 0;
+ break;
+
+ case TAG_ULINEON :
+ ULINE_BIT(f) = 1;
+ break;
+
+ case TAG_ULINEOFF :
+ ULINE_BIT(f) = 0;
+ break;
+
+ case TAG_FGCOLOR :
+ if(!HD(f)->color)
+ HD(f)->color = new_color_pair(NULL, NULL);
+
+ HD(f)->embedded.color = HD(f)->color->fg;
+ HD(f)->embedded.state = 11;
+ break;
+
+ case TAG_BGCOLOR :
+ if(!HD(f)->color)
+ HD(f)->color = new_color_pair(NULL, NULL);
+
+ HD(f)->embedded.color = HD(f)->color->bg;
+ HD(f)->embedded.state = 11;
+ break;
+
+ case TAG_HANDLEOFF :
+ ch = TAG_INVOFF;
+ HD(f)->in_anchor = 0;
+ break;
+
+ default :
+ break;
+ }
+
+ html_putc(f, ch);
+ break;
+
+ case -1 :
+ HD(f)->embedded.state = ch; /* number of embedded chars */
+ html_putc(f, ch);
+ break;
+
+ default :
+ HD(f)->embedded.state--;
+ if(HD(f)->embedded.color)
+ *HD(f)->embedded.color++ = ch;
+
+ if(HD(f)->embedded.state == 0 && HD(f)->embedded.color){
+ *HD(f)->embedded.color = '\0';
+ HD(f)->embedded.color = NULL;
+ }
+
+ html_putc(f, ch);
+ break;
+ }
+ }
+}
+
+
+/*
+ * flush any buffered chars waiting for wrapping.
+ */
+void
+html_output_flush(FILTER_S *f)
+{
+ if(f->f2){
+ if(f->n && ((int) f->n) + 1 + f->f2 > HD(f)->wrapcol)
+ html_newline(f); /* wrap? */
+
+ if(f->n){ /* text already on the line? */
+ html_putc(f, ' ');
+ f->n++; /* increment count */
+ }
+ else{
+ /* write at start of new line */
+ html_write_indent(f, HD(f)->indent_level);
+
+ if(HD(f)->in_anchor)
+ html_write_anchor(f, HD(f)->in_anchor);
+ }
+
+ f->n += f->f2;
+ HTML_FLUSH(f);
+ }
+}
+
+
+
+/*
+ * html_output_centered - managed writing centered text
+ */
+void
+html_output_centered(FILTER_S *f, int ch, int width)
+{
+ if(!HD(f)->centered){ /* new text? */
+ html_output_flush(f);
+ if(f->n) /* start on blank line */
+ html_newline(f);
+
+ HD(f)->centered = (CENTER_S *) fs_get(sizeof(CENTER_S));
+ memset(HD(f)->centered, 0, sizeof(CENTER_S));
+ /* and grab a buf to start collecting centered text */
+ HD(f)->centered->line.len = WRAP_COLS(f);
+ HD(f)->centered->line.buf = (char *) fs_get(HD(f)->centered->line.len
+ * sizeof(char));
+ HD(f)->centered->line.used = HD(f)->centered->line.width = 0;
+ HD(f)->centered->word.len = 32;
+ HD(f)->centered->word.buf = (char *) fs_get(HD(f)->centered->word.len
+ * sizeof(char));
+ HD(f)->centered->word.used = HD(f)->centered->word.width = 0;
+ }
+
+ if(ch == HTML_NEWLINE){ /* hard newline */
+ html_centered_flush(f);
+ }
+ else if(ch == TAG_EMBED){ /* takes up no space */
+ HD(f)->embedded.state = -5;
+ html_centered_putc(&HD(f)->centered->word, TAG_EMBED);
+ }
+ else if(HD(f)->embedded.state){
+ if(HD(f)->embedded.state == -5){
+ /* looking for specially handled tags following TAG_EMBED */
+ if(ch == TAG_HANDLE)
+ HD(f)->embedded.state = -1; /* next ch is length */
+ else if(ch == TAG_FGCOLOR || ch == TAG_BGCOLOR){
+ if(!HD(f)->color)
+ HD(f)->color = new_color_pair(NULL, NULL);
+
+ if(ch == TAG_FGCOLOR)
+ HD(f)->embedded.color = HD(f)->color->fg;
+ else
+ HD(f)->embedded.color = HD(f)->color->bg;
+
+ HD(f)->embedded.state = RGBLEN;
+ }
+ else
+ HD(f)->embedded.state = 0; /* non-special */
+ }
+ else if(HD(f)->embedded.state > 0){
+ /* collecting up an RGBLEN color or length, ignore tags */
+ (HD(f)->embedded.state)--;
+ if(HD(f)->embedded.color)
+ *HD(f)->embedded.color++ = ch;
+
+ if(HD(f)->embedded.state == 0 && HD(f)->embedded.color){
+ *HD(f)->embedded.color = '\0';
+ HD(f)->embedded.color = NULL;
+ }
+ }
+ else if(HD(f)->embedded.state < 0){
+ HD(f)->embedded.state = ch; /* number of embedded chars */
+ }
+ else{
+ (HD(f)->embedded.state)--;
+ if(HD(f)->embedded.color)
+ *HD(f)->embedded.color++ = ch;
+
+ if(HD(f)->embedded.state == 0 && HD(f)->embedded.color){
+ *HD(f)->embedded.color = '\0';
+ HD(f)->embedded.color = NULL;
+ }
+ }
+
+ html_centered_putc(&HD(f)->centered->word, ch);
+ }
+ else if(ASCII_ISSPACE((unsigned char) ch)){
+ if(!HD(f)->centered->space++){ /* end of a word? flush! */
+ int i;
+
+ if(WRAPPED_LEN(f) > HD(f)->wrapcol){
+ html_centered_flush_line(f);
+ /* fall thru to put current "word" on blank "line" */
+ }
+ else if(HD(f)->centered->line.width){
+ /* put space char between line and appended word */
+ html_centered_putc(&HD(f)->centered->line, ' ');
+ HD(f)->centered->line.width++;
+ }
+
+ for(i = 0; i < HD(f)->centered->word.used; i++)
+ html_centered_putc(&HD(f)->centered->line,
+ HD(f)->centered->word.buf[i]);
+
+ HD(f)->centered->line.width += HD(f)->centered->word.width;
+ HD(f)->centered->word.used = 0;
+ HD(f)->centered->word.width = 0;
+ }
+ }
+ else{
+ if(HD(f)->prefix)
+ html_a_prefix(f);
+
+ /* ch is start of next word */
+ HD(f)->centered->space = 0;
+ if(HD(f)->centered->word.width >= WRAP_COLS(f))
+ html_centered_flush(f);
+
+ html_centered_putc(&HD(f)->centered->word, ch);
+ HD(f)->centered->word.width++;
+ }
+}
+
+
+/*
+ * html_centered_putc -- add given char to given WRAPLINE_S
+ */
+void
+html_centered_putc(WRAPLINE_S *wp, int ch)
+{
+ if(wp->used + 1 >= wp->len){
+ wp->len += 64;
+ fs_resize((void **) &wp->buf, wp->len * sizeof(char));
+ }
+
+ wp->buf[wp->used++] = ch;
+}
+
+
+
+/*
+ * html_centered_flush - finish writing any pending centered output
+ */
+void
+html_centered_flush(FILTER_S *f)
+{
+ int i;
+
+ /*
+ * If word present (what about line?) we need to deal with
+ * appending it...
+ */
+ if(HD(f)->centered->word.width && WRAPPED_LEN(f) > HD(f)->wrapcol)
+ html_centered_flush_line(f);
+
+ if(WRAPPED_LEN(f)){
+ /* figure out how much to indent */
+ if((i = (WRAP_COLS(f) - WRAPPED_LEN(f))/2) > 0)
+ html_write_indent(f, i);
+
+ if(HD(f)->centered->anchor)
+ html_write_anchor(f, HD(f)->centered->anchor);
+
+ html_centered_handle(&HD(f)->centered->anchor,
+ HD(f)->centered->line.buf,
+ HD(f)->centered->line.used);
+ html_write(f, HD(f)->centered->line.buf, HD(f)->centered->line.used);
+
+ if(HD(f)->centered->word.used){
+ if(HD(f)->centered->line.width)
+ html_putc(f, ' ');
+
+ html_centered_handle(&HD(f)->centered->anchor,
+ HD(f)->centered->word.buf,
+ HD(f)->centered->word.used);
+ html_write(f, HD(f)->centered->word.buf,
+ HD(f)->centered->word.used);
+ }
+
+ HD(f)->centered->line.used = HD(f)->centered->word.used = 0;
+ HD(f)->centered->line.width = HD(f)->centered->word.width = 0;
+ }
+ else{
+ if(HD(f)->centered->word.used){
+ html_write(f, HD(f)->centered->word.buf,
+ HD(f)->centered->word.used);
+ HD(f)->centered->line.used = HD(f)->centered->word.used = 0;
+ HD(f)->centered->line.width = HD(f)->centered->word.width = 0;
+ }
+ HD(f)->blanks++; /* advance the blank line counter */
+ }
+
+ html_newline(f); /* finish the line */
+}
+
+
+/*
+ * html_centered_handle - scan the line for embedded handles
+ */
+void
+html_centered_handle(int *h, char *line, int len)
+{
+ int n;
+
+ while(len-- > 0)
+ if(*line++ == TAG_EMBED && len-- > 0)
+ switch(*line++){
+ case TAG_HANDLE :
+ if((n = *line++) >= --len){
+ *h = 0;
+ len -= n;
+ while(n--)
+ *h = (*h * 10) + (*line++ - '0');
+ }
+ break;
+
+ case TAG_HANDLEOFF :
+ case TAG_INVOFF :
+ *h = 0; /* assumption 23,342: inverse off ends tags */
+ break;
+
+ default :
+ break;
+ }
+}
+
+
+
+/*
+ * html_centered_flush_line - flush the centered "line" only
+ */
+void
+html_centered_flush_line(FILTER_S *f)
+{
+ if(HD(f)->centered->line.used){
+ int i, j;
+
+ /* hide "word" from flush */
+ i = HD(f)->centered->word.used;
+ j = HD(f)->centered->word.width;
+ HD(f)->centered->word.used = 0;
+ HD(f)->centered->word.width = 0;
+ html_centered_flush(f);
+
+ HD(f)->centered->word.used = i;
+ HD(f)->centered->word.width = j;
+ }
+}
+
+
+/*
+ * html_write_indent - write indention mindful of display attributes
+ */
+void
+html_write_indent(FILTER_S *f, int indent)
+{
+ if(! STRIP(f)){
+ if(BOLD_BIT(f)){
+ html_putc(f, TAG_EMBED);
+ html_putc(f, TAG_BOLDOFF);
+ }
+
+ if(ULINE_BIT(f)){
+ html_putc(f, TAG_EMBED);
+ html_putc(f, TAG_ULINEOFF);
+ }
+ }
+
+ f->n = indent;
+ while(indent-- > 0)
+ html_putc(f, ' '); /* indent as needed */
+
+ /*
+ * Resume any previous embedded state
+ */
+ if(! STRIP(f)){
+ if(BOLD_BIT(f)){
+ html_putc(f, TAG_EMBED);
+ html_putc(f, TAG_BOLDON);
+ }
+
+ if(ULINE_BIT(f)){
+ html_putc(f, TAG_EMBED);
+ html_putc(f, TAG_ULINEON);
+ }
+ }
+}
+
+
+/*
+ *
+ */
+void
+html_write_anchor(FILTER_S *f, int anchor)
+{
+ char buf[256];
+ int i;
+
+ html_putc(f, TAG_EMBED);
+ html_putc(f, TAG_HANDLE);
+ snprintf(buf, sizeof(buf), "%d", anchor);
+ html_putc(f, (int) strlen(buf));
+
+ for(i = 0; buf[i]; i++)
+ html_putc(f, buf[i]);
+}
+
+
+/*
+ * html_write_newline - write a newline mindful of display attributes
+ */
+void
+html_write_newline(FILTER_S *f)
+{
+ int i;
+
+ if(! STRIP(f)){ /* First tie, off any embedded state */
+ if(HD(f)->in_anchor){
+ html_putc(f, TAG_EMBED);
+ html_putc(f, TAG_INVOFF);
+ }
+
+ if(BOLD_BIT(f)){
+ html_putc(f, TAG_EMBED);
+ html_putc(f, TAG_BOLDOFF);
+ }
+
+ if(ULINE_BIT(f)){
+ html_putc(f, TAG_EMBED);
+ html_putc(f, TAG_ULINEOFF);
+ }
+
+ if(HD(f)->color && (HD(f)->color->fg[0] || HD(f)->color->bg[0])){
+ char *p;
+ int i;
+
+ p = color_embed(ps_global->VAR_NORM_FORE_COLOR,
+ ps_global->VAR_NORM_BACK_COLOR);
+ for(i = 0; i < 2 * (RGBLEN + 2); i++)
+ html_putc(f, p[i]);
+ }
+ }
+
+ html_write(f, "\015\012", 2);
+ for(i = HTML_INDENT(f); i > 0; i--)
+ html_putc(f, ' ');
+
+ if(! STRIP(f)){ /* First tie, off any embedded state */
+ if(BOLD_BIT(f)){
+ html_putc(f, TAG_EMBED);
+ html_putc(f, TAG_BOLDON);
+ }
+
+ if(ULINE_BIT(f)){
+ html_putc(f, TAG_EMBED);
+ html_putc(f, TAG_ULINEON);
+ }
+
+ if(HD(f)->color && (HD(f)->color->fg[0] || HD(f)->color->bg[0])){
+ char *p, *tfg, *tbg;
+ int i;
+ COLOR_PAIR *tmp;
+
+ tfg = HD(f)->color->fg;
+ tbg = HD(f)->color->bg;
+ tmp = new_color_pair(tfg[0] ? tfg
+ : color_to_asciirgb(ps_global->VAR_NORM_FORE_COLOR),
+ tbg[0] ? tbg
+ : color_to_asciirgb(ps_global->VAR_NORM_BACK_COLOR));
+ if(pico_is_good_colorpair(tmp)){
+ p = color_embed(tfg[0] ? tfg
+ : ps_global->VAR_NORM_FORE_COLOR,
+ tbg[0] ? tbg
+ : ps_global->VAR_NORM_BACK_COLOR);
+ for(i = 0; i < 2 * (RGBLEN + 2); i++)
+ html_putc(f, p[i]);
+ }
+
+ if(tmp)
+ free_color_pair(&tmp);
+ }
+ }
+}
+
+
+/*
+ * html_write - write given n-length string to next filter
+ */
+void
+html_write(FILTER_S *f, char *s, int n)
+{
+ GF_INIT(f, f->next);
+
+ while(n-- > 0){
+ /* keep track of attribute state? Not if last char! */
+ if(!STRIP(f) && *s == TAG_EMBED && n-- > 0){
+ GF_PUTC(f->next, TAG_EMBED);
+ switch(*++s){
+ case TAG_BOLDON :
+ BOLD_BIT(f) = 1;
+ break;
+ case TAG_BOLDOFF :
+ BOLD_BIT(f) = 0;
+ break;
+ case TAG_ULINEON :
+ ULINE_BIT(f) = 1;
+ break;
+ case TAG_ULINEOFF :
+ ULINE_BIT(f) = 0;
+ break;
+ case TAG_HANDLEOFF :
+ HD(f)->in_anchor = 0;
+ GF_PUTC(f->next, TAG_INVOFF);
+ s++;
+ continue;
+ case TAG_HANDLE :
+ if(n-- > 0){
+ int i = *++s;
+
+ GF_PUTC(f->next, TAG_HANDLE);
+ if(i <= n){
+ int anum = 0;
+ HANDLE_S *h;
+
+ n -= i;
+ GF_PUTC(f->next, i);
+ while(1){
+ anum = (anum * 10) + (*++s - '0');
+ if(--i)
+ GF_PUTC(f->next, *s);
+ else
+ break;
+ }
+
+ if(DO_HANDLES(f)
+ && (h = get_handle(*HANDLESP(f), anum)) != NULL
+ && (h->type == URL || h->type == Attach)){
+ HD(f)->in_anchor = anum;
+ }
+ }
+ }
+
+ break;
+ default:
+ break;
+ }
+ }
+
+ GF_PUTC(f->next, (*s++) & 0xff);
+ }
+
+ GF_IP_END(f->next); /* clean up next's input pointers */
+}
+
+
+/*
+ * html_putc -- actual work of writing to next filter.
+ * NOTE: Small opt not using full GF_END since our input
+ * pointers don't need adjusting.
+ */
+void
+html_putc(FILTER_S *f, int ch)
+{
+ GF_INIT(f, f->next);
+ GF_PUTC(f->next, ch & 0xff);
+ GF_IP_END(f->next); /* clean up next's input pointers */
+}
+
+
+
+/*
+ * Only current option is to turn on embedded data stripping for text
+ * bound to a printer or composer.
+ */
+void *
+gf_html2plain_opt(char *base,
+ int columns,
+ int *margin,
+ HANDLE_S **handlesp,
+ htmlrisk_t risk_f,
+ int flags)
+{
+ HTML_OPT_S *op;
+ int margin_l, margin_r;
+
+ op = (HTML_OPT_S *) fs_get(sizeof(HTML_OPT_S));
+
+ op->base = cpystr(base);
+ margin_l = (margin) ? margin[0] : 0;
+ margin_r = (margin) ? margin[1] : 0;
+ op->indent = margin_l;
+ op->columns = columns - (margin_l + margin_r);
+ op->strip = ((flags & GFHP_STRIPPED) == GFHP_STRIPPED);
+ op->handlesp = handlesp;
+ op->handles_loc = ((flags & GFHP_LOCAL_HANDLES) == GFHP_LOCAL_HANDLES);
+ op->showserver = ((flags & GFHP_SHOW_SERVER) == GFHP_SHOW_SERVER);
+ op->warnrisk_f = risk_f;
+ op->no_relative_links = ((flags & GFHP_NO_RELATIVE) == GFHP_NO_RELATIVE);
+ op->related_content = ((flags & GFHP_RELATED_CONTENT) == GFHP_RELATED_CONTENT);
+ op->html = ((flags & GFHP_HTML) == GFHP_HTML);
+ op->html_imgs = ((flags & GFHP_HTML_IMAGES) == GFHP_HTML_IMAGES);
+ op->element_table = html_element_table;
+ return((void *) op);
+}
+
+
+void *
+gf_html2plain_rss_opt(RSS_FEED_S **feedp, int flags)
+{
+ HTML_OPT_S *op;
+ int margin_l, margin_r;
+
+ op = (HTML_OPT_S *) fs_get(sizeof(HTML_OPT_S));
+ memset(op, 0, sizeof(HTML_OPT_S));
+
+ op->base = cpystr("");
+ op->element_table = rss_element_table;
+ *(op->feedp = feedp) = NULL;
+ return((void *) op);
+}
+
+void
+gf_html2plain_rss_free(RSS_FEED_S **feedp)
+{
+ if(feedp && *feedp){
+ if((*feedp)->title)
+ fs_give((void **) &(*feedp)->title);
+
+ if((*feedp)->link)
+ fs_give((void **) &(*feedp)->link);
+
+ if((*feedp)->description)
+ fs_give((void **) &(*feedp)->description);
+
+ if((*feedp)->source)
+ fs_give((void **) &(*feedp)->source);
+
+ if((*feedp)->image)
+ fs_give((void **) &(*feedp)->image);
+
+ gf_html2plain_rss_free_items(&((*feedp)->items));
+ fs_give((void **) feedp);
+ }
+}
+
+void
+gf_html2plain_rss_free_items(RSS_ITEM_S **itemp)
+{
+ if(itemp && *itemp){
+ if((*itemp)->title)
+ fs_give((void **) &(*itemp)->title);
+
+ if((*itemp)->link)
+ fs_give((void **) &(*itemp)->link);
+
+ if((*itemp)->description)
+ fs_give((void **) &(*itemp)->description);
+
+ if((*itemp)->source)
+ fs_give((void **) &(*itemp)->source);
+
+ gf_html2plain_rss_free_items(&(*itemp)->next);
+ fs_give((void **) itemp);
+ }
+}
+
+
+/* END OF HTML-TO-PLAIN text filter */
+
+/*
+ * ESCAPE CODE FILTER - remove unknown and possibly dangerous escape codes
+ * from the text stream.
+ */
+
+#define MAX_ESC_LEN 5
+
+/*
+ * the simple filter, removes unknown escape codes from the stream
+ */
+void
+gf_escape_filter(FILTER_S *f, int flg)
+{
+ register char *p;
+ GF_INIT(f, f->next);
+
+ if(flg == GF_DATA){
+ register unsigned char c;
+ register int state = f->f1;
+
+ while(GF_GETC(f, c)){
+
+ if(state){
+ if(c == '\033' || f->n == MAX_ESC_LEN){
+ f->line[f->n] = '\0';
+ f->n = 0L;
+ if(!match_escapes(f->line)){
+ GF_PUTC(f->next, '^');
+ GF_PUTC(f->next, '[');
+ }
+ else
+ GF_PUTC(f->next, '\033');
+
+ p = f->line;
+ while(*p)
+ GF_PUTC(f->next, *p++);
+
+ if(c == '\033')
+ continue;
+ else
+ state = 0; /* fall thru */
+ }
+ else{
+ f->line[f->n++] = c; /* collect */
+ continue;
+ }
+ }
+
+ if(c == '\033')
+ state = 1;
+ else
+ GF_PUTC(f->next, c);
+ }
+
+ f->f1 = state;
+ GF_END(f, f->next);
+ }
+ else if(flg == GF_EOD){
+ if(f->f1){
+ if(!match_escapes(f->line)){
+ GF_PUTC(f->next, '^');
+ GF_PUTC(f->next, '[');
+ }
+ else
+ GF_PUTC(f->next, '\033');
+ }
+
+ for(p = f->line; f->n; f->n--, p++)
+ GF_PUTC(f->next, *p);
+
+ fs_give((void **)&(f->line)); /* free temp line buffer */
+ (void) GF_FLUSH(f->next);
+ (*f->next->f)(f->next, GF_EOD);
+ }
+ else if(flg == GF_RESET){
+ dprint((9, "-- gf_reset escape\n"));
+ f->f1 = 0;
+ f->n = 0L;
+ f->linep = f->line = (char *)fs_get((MAX_ESC_LEN + 1) * sizeof(char));
+ }
+}
+
+
+
+/*
+ * CONTROL CHARACTER FILTER - transmogrify control characters into their
+ * corresponding string representations (you know, ^blah and such)...
+ */
+
+/*
+ * the simple filter transforms unknown control characters in the stream
+ * into harmless strings.
+ */
+void
+gf_control_filter(FILTER_S *f, int flg)
+{
+ GF_INIT(f, f->next);
+
+ if(flg == GF_DATA){
+ register unsigned char c;
+ register int filt_only_c0;
+
+ filt_only_c0 = f->opt ? (*(int *) f->opt) : 0;
+
+ while(GF_GETC(f, c)){
+
+ if(((c < 0x20 || c == 0x7f)
+ || (c >= 0x80 && c < 0xA0 && !filt_only_c0))
+ && !(ASCII_ISSPACE((unsigned char) c)
+ || c == '\016' || c == '\017' || c == '\033')){
+ GF_PUTC(f->next, c >= 0x80 ? '~' : '^');
+ GF_PUTC(f->next, (c == 0x7f) ? '?' : (c & 0x1f) + '@');
+ }
+ else
+ GF_PUTC(f->next, c);
+ }
+
+ GF_END(f, f->next);
+ }
+ else if(flg == GF_EOD){
+ (void) GF_FLUSH(f->next);
+ (*f->next->f)(f->next, GF_EOD);
+ }
+}
+
+
+/*
+ * function called from the outside to set
+ * control filter's option, which says to filter C0 control characters
+ * but not C1 control chars. We don't call it at all if we don't want
+ * to filter C0 chars either.
+ */
+void *
+gf_control_filter_opt(int *filt_only_c0)
+{
+ return((void *) filt_only_c0);
+}
+
+
+/*
+ * TAG FILTER - quote all TAG_EMBED characters by doubling them.
+ * This prevents the possibility of embedding other tags.
+ * We assume that this filter should only be used for something
+ * that is eventually writing to a display, which has the special
+ * knowledge of quoted TAG_EMBEDs.
+ */
+void
+gf_tag_filter(FILTER_S *f, int flg)
+{
+ GF_INIT(f, f->next);
+
+ if(flg == GF_DATA){
+ register unsigned char c;
+
+ while(GF_GETC(f, c)){
+
+ if((c & 0xff) == (TAG_EMBED & 0xff)){
+ GF_PUTC(f->next, TAG_EMBED);
+ GF_PUTC(f->next, c);
+ }
+ else
+ GF_PUTC(f->next, c);
+ }
+
+ GF_END(f, f->next);
+ }
+ else if(flg == GF_EOD){
+ (void) GF_FLUSH(f->next);
+ (*f->next->f)(f->next, GF_EOD);
+ }
+}
+
+
+/*
+ * LINEWRAP FILTER - insert CRLF's at end of nearest whitespace before
+ * specified line width
+ */
+
+
+typedef struct wrap_col_s {
+ unsigned bold:1;
+ unsigned uline:1;
+ unsigned inverse:1;
+ unsigned tags:1;
+ unsigned do_indent:1;
+ unsigned on_comma:1;
+ unsigned flowed:1;
+ unsigned delsp:1;
+ unsigned quoted:1;
+ unsigned allwsp:1;
+ unsigned hard_nl:1;
+ unsigned leave_flowed:1;
+ unsigned use_color:1;
+ unsigned hdr_color:1;
+ unsigned for_compose:1;
+ unsigned handle_soft_hyphen:1;
+ unsigned saw_soft_hyphen:1;
+ unsigned trailing_space:1;
+ unsigned char utf8buf[7];
+ unsigned char *utf8bufp;
+ COLOR_PAIR *color;
+ STORE_S *spaces;
+ short embedded,
+ space_len;
+ char *lineendp;
+ int anchor,
+ prefbrk,
+ prefbrkn,
+ quote_depth,
+ quote_count,
+ sig,
+ state,
+ wrap_col,
+ wrap_max,
+ margin_l,
+ margin_r,
+ indent;
+ char special[256];
+} WRAP_S;
+
+#define WRAP_MARG_L(F) (((WRAP_S *)(F)->opt)->margin_l)
+#define WRAP_MARG_R(F) (((WRAP_S *)(F)->opt)->margin_r)
+#define WRAP_COL(F) (((WRAP_S *)(F)->opt)->wrap_col - WRAP_MARG_R(F) - ((((WRAP_S *)(F)->opt)->leave_flowed) ? 1 : 0))
+#define WRAP_MAX_COL(F) (((WRAP_S *)(F)->opt)->wrap_max - WRAP_MARG_R(F) - ((((WRAP_S *)(F)->opt)->leave_flowed) ? 1 : 0))
+#define WRAP_INDENT(F) (((WRAP_S *)(F)->opt)->indent)
+#define WRAP_DO_IND(F) (((WRAP_S *)(F)->opt)->do_indent)
+#define WRAP_COMMA(F) (((WRAP_S *)(F)->opt)->on_comma)
+#define WRAP_FLOW(F) (((WRAP_S *)(F)->opt)->flowed)
+#define WRAP_DELSP(F) (((WRAP_S *)(F)->opt)->delsp)
+#define WRAP_FL_QD(F) (((WRAP_S *)(F)->opt)->quote_depth)
+#define WRAP_FL_QC(F) (((WRAP_S *)(F)->opt)->quote_count)
+#define WRAP_FL_SIG(F) (((WRAP_S *)(F)->opt)->sig)
+#define WRAP_HARD(F) (((WRAP_S *)(F)->opt)->hard_nl)
+#define WRAP_LV_FLD(F) (((WRAP_S *)(F)->opt)->leave_flowed)
+#define WRAP_USE_CLR(F) (((WRAP_S *)(F)->opt)->use_color)
+#define WRAP_HDR_CLR(F) (((WRAP_S *)(F)->opt)->hdr_color)
+#define WRAP_FOR_CMPS(F) (((WRAP_S *)(F)->opt)->for_compose)
+#define WRAP_HANDLE_SOFT_HYPHEN(F) (((WRAP_S *)(F)->opt)->handle_soft_hyphen)
+#define WRAP_SAW_SOFT_HYPHEN(F) (((WRAP_S *)(F)->opt)->saw_soft_hyphen)
+#define WRAP_UTF8BUF(F, C) (((WRAP_S *)(F)->opt)->utf8buf[C])
+#define WRAP_UTF8BUFP(F) (((WRAP_S *)(F)->opt)->utf8bufp)
+#define WRAP_STATE(F) (((WRAP_S *)(F)->opt)->state)
+#define WRAP_QUOTED(F) (((WRAP_S *)(F)->opt)->quoted)
+#define WRAP_TAGS(F) (((WRAP_S *)(F)->opt)->tags)
+#define WRAP_BOLD(F) (((WRAP_S *)(F)->opt)->bold)
+#define WRAP_ULINE(F) (((WRAP_S *)(F)->opt)->uline)
+#define WRAP_INVERSE(F) (((WRAP_S *)(F)->opt)->inverse)
+#define WRAP_LASTC(F) (((WRAP_S *)(F)->opt)->lineendp)
+#define WRAP_EMBED(F) (((WRAP_S *)(F)->opt)->embedded)
+#define WRAP_ANCHOR(F) (((WRAP_S *)(F)->opt)->anchor)
+#define WRAP_PB_OFF(F) (((WRAP_S *)(F)->opt)->prefbrk)
+#define WRAP_PB_LEN(F) (((WRAP_S *)(F)->opt)->prefbrkn)
+#define WRAP_ALLWSP(F) (((WRAP_S *)(F)->opt)->allwsp)
+#define WRAP_SPC_LEN(F) (((WRAP_S *)(F)->opt)->space_len)
+#define WRAP_TRL_SPC(F) (((WRAP_S *)(F)->opt)->trailing_space)
+#define WRAP_SPEC(F, C) ((WRAP_S *) (F)->opt)->special[C]
+#define WRAP_COLOR(F) (((WRAP_S *)(F)->opt)->color)
+#define WRAP_COLOR_SET(F) ((WRAP_COLOR(F)) && (WRAP_COLOR(F)->fg[0]))
+#define WRAP_SPACES(F) (((WRAP_S *)(F)->opt)->spaces)
+#define WRAP_PUTC(F,C,W) { \
+ if((F)->linep == WRAP_LASTC(F)){ \
+ size_t offset = (F)->linep - (F)->line; \
+ fs_resize((void **) &(F)->line, \
+ (2 * offset) * sizeof(char)); \
+ (F)->linep = &(F)->line[offset]; \
+ WRAP_LASTC(F) = &(F)->line[2*offset-1]; \
+ } \
+ *(F)->linep++ = (C); \
+ (F)->f2 += (W); \
+ }
+
+#define WRAP_EMBED_PUTC(F,C) { \
+ if((F)->f2){ \
+ WRAP_PUTC((F), C, 0); \
+ } \
+ else \
+ so_writec(C, WRAP_SPACES(F)); \
+}
+
+#define WRAP_COLOR_UNSET(F) { \
+ if(WRAP_COLOR_SET(F)){ \
+ WRAP_COLOR(F)->fg[0] = '\0'; \
+ } \
+ }
+
+/*
+ * wrap_flush_embed flags
+ */
+#define WFE_NONE 0 /* Nothing special */
+#define WFE_CNT_HANDLE 1 /* account for/don't write handles */
+
+
+int wrap_flush(FILTER_S *, unsigned char **, unsigned char **, unsigned char **, unsigned char **);
+int wrap_flush_embed(FILTER_S *, unsigned char **, unsigned char **,
+ unsigned char **, unsigned char **);
+int wrap_flush_s(FILTER_S *,char *, int, int, unsigned char **, unsigned char **,
+ unsigned char **, unsigned char **, int);
+int wrap_eol(FILTER_S *, int, unsigned char **, unsigned char **,
+ unsigned char **, unsigned char **);
+int wrap_bol(FILTER_S *, int, int, unsigned char **,
+ unsigned char **, unsigned char **, unsigned char **);
+int wrap_quote_insert(FILTER_S *, unsigned char **, unsigned char **,
+ unsigned char **, unsigned char **);
+
+/*
+ * the no longer simple filter, breaks lines at end of white space nearest
+ * to global "gf_wrap_width" in length
+ * It also supports margins, indents (inverse indenting, really) and
+ * flowed text (ala RFC 3676)
+ *
+ */
+void
+gf_wrap(FILTER_S *f, int flg)
+{
+ register long i;
+ GF_INIT(f, f->next);
+
+ /*
+ * f->f1 state
+ * f->line buffer where next "word" being considered is stored
+ * f->f2 width in screen cells of f->line stuff
+ * f->n width in screen cells of the part of this line committed to next
+ * filter so far
+ */
+
+ if(flg == GF_DATA){
+ register unsigned char c;
+ register int state = f->f1;
+ int width, full_character;
+
+ while(GF_GETC(f, c)){
+
+ switch(state){
+ case CCR : /* CRLF or CR in text ? */
+ state = BOL; /* either way, handle start */
+
+ if(WRAP_FLOW(f)){
+ /* wrapped line? */
+ if(f->f2 == 0 && WRAP_SPC_LEN(f) && WRAP_TRL_SPC(f)){
+ /*
+ * whack trailing space char, but be aware
+ * of embeds in space buffer. grok them just
+ * in case they contain a 0x20 value
+ */
+ if(WRAP_DELSP(f)){
+ char *sb, *sbp, *scp = NULL;
+ int x;
+
+ for(sb = sbp = (char *)so_text(WRAP_SPACES(f)); *sbp; sbp++){
+ switch(*sbp){
+ case ' ' :
+ scp = sbp;
+ break;
+
+ case TAG_EMBED :
+ sbp++;
+ switch (*sbp++){
+ case TAG_HANDLE :
+ x = (int) *sbp++;
+ if(strlen(sbp) >= x)
+ sbp += (x - 1);
+
+ break;
+
+ case TAG_FGCOLOR :
+ case TAG_BGCOLOR :
+ if(strlen(sbp) >= RGBLEN)
+ sbp += (RGBLEN - 1);
+
+ break;
+
+ default :
+ break;
+ }
+
+ break;
+
+ default :
+ break;
+ }
+ }
+
+ /* replace space buf without trailing space char */
+ if(scp){
+ STORE_S *ns = so_get(CharStar, NULL, EDIT_ACCESS);
+
+ *scp++ = '\0';
+ WRAP_SPC_LEN(f)--;
+ WRAP_TRL_SPC(f) = 0;
+
+ so_puts(ns, sb);
+ so_puts(ns, scp);
+
+ so_give(&WRAP_SPACES(f));
+ WRAP_SPACES(f) = ns;
+ }
+ }
+ }
+ else{ /* fixed line */
+ WRAP_HARD(f) = 1;
+ wrap_flush(f, &ip, &eib, &op, &eob);
+ wrap_eol(f, 0, &ip, &eib, &op, &eob);
+
+ /*
+ * When we get to a real end of line, we don't need to
+ * remember what the special color was anymore because
+ * we aren't going to be changing back to it. We unset it
+ * so that we don't keep resetting the color to normal.
+ */
+ WRAP_COLOR_UNSET(f);
+ }
+
+ if(c == '\012'){ /* get c following LF */
+ break;
+ }
+ /* else c is first char of new line, fall thru */
+ }
+ else{
+ wrap_flush(f, &ip, &eib, &op, &eob);
+ wrap_eol(f, 0, &ip, &eib, &op, &eob);
+ WRAP_COLOR_UNSET(f); /* see note above */
+ if(c == '\012'){
+ break;
+ }
+ /* else fall thru to deal with beginning of line */
+ }
+
+ case BOL :
+ if(WRAP_FLOW(f)){
+ if(c == '>'){
+ WRAP_FL_QC(f) = 1; /* init it */
+ state = FL_QLEV; /* go collect it */
+ }
+ else {
+ /* if EMBEDed, process it and return here */
+ if(c == (unsigned char) TAG_EMBED){
+ WRAP_EMBED_PUTC(f, TAG_EMBED);
+ WRAP_STATE(f) = state;
+ state = TAG;
+ continue;
+ }
+
+ /* quote level change implies new paragraph */
+ if(WRAP_FL_QD(f)){
+ WRAP_FL_QD(f) = 0;
+ if(WRAP_HARD(f) == 0){
+ WRAP_HARD(f) = 1;
+ wrap_flush(f, &ip, &eib, &op, &eob);
+ wrap_eol(f, 0, &ip, &eib, &op, &eob);
+ WRAP_COLOR_UNSET(f); /* see note above */
+ }
+ }
+
+ if(WRAP_HARD(f)){
+ wrap_bol(f, 0, 1, &ip, &eib, &op,
+ &eob); /* write quoting prefix */
+ WRAP_HARD(f) = 0;
+ }
+
+ switch (c) {
+ case '\015' : /* a blank line? */
+ wrap_flush(f, &ip, &eib, &op, &eob);
+ state = CCR; /* go collect it */
+ break;
+
+ case ' ' : /* space stuffed */
+ state = FL_STF; /* just eat it */
+ break;
+
+ case '-' : /* possible sig-dash */
+ WRAP_FL_SIG(f) = 1; /* init state */
+ state = FL_SIG; /* go collect it */
+ break;
+
+ default :
+ state = DFL; /* go back to normal */
+ goto case_dfl; /* handle c like DFL case */
+ }
+ }
+ }
+ else{
+ state = DFL;
+ if(WRAP_COMMA(f) && c == TAB){
+ wrap_bol(f, 1, 0, &ip, &eib, &op,
+ &eob); /* convert to normal indent */
+ break;
+ }
+
+ wrap_bol(f,0,0, &ip, &eib, &op, &eob);
+ goto case_dfl; /* handle c like DFL case */
+ }
+
+ break;
+
+ case FL_QLEV :
+ if(c == '>'){ /* another level */
+ WRAP_FL_QC(f)++;
+ }
+ else {
+ /* if EMBEDed, process it and return here */
+ if(c == (unsigned char) TAG_EMBED){
+ WRAP_EMBED_PUTC(f, TAG_EMBED);
+ WRAP_STATE(f) = state;
+ state = TAG;
+ continue;
+ }
+
+ /* quote level change signals new paragraph */
+ if(WRAP_FL_QC(f) != WRAP_FL_QD(f)){
+ WRAP_FL_QD(f) = WRAP_FL_QC(f);
+ if(WRAP_HARD(f) == 0){ /* add hard newline */
+ WRAP_HARD(f) = 1; /* hard newline */
+ wrap_flush(f, &ip, &eib, &op, &eob);
+ wrap_eol(f, 0, &ip, &eib, &op, &eob);
+ WRAP_COLOR_UNSET(f); /* see note above */
+ }
+ }
+
+ if(WRAP_HARD(f)){
+ wrap_bol(f,0,1, &ip, &eib, &op, &eob);
+ WRAP_HARD(f) = 0;
+ }
+
+ switch (c) {
+ case '\015' : /* a blank line? */
+ wrap_flush(f, &ip, &eib, &op, &eob);
+ state = CCR; /* go collect it */
+ break;
+
+ case ' ' : /* space-stuffed! */
+ state = FL_STF; /* just eat it */
+ break;
+
+ case '-' : /* sig dash? */
+ WRAP_FL_SIG(f) = 1;
+ state = FL_SIG;
+ break;
+
+ default : /* something else */
+ state = DFL;
+ goto case_dfl; /* handle c like DFL */
+ }
+ }
+
+ break;
+
+ case FL_STF : /* space stuffed */
+ switch (c) {
+ case '\015' : /* a blank line? */
+ wrap_flush(f, &ip, &eib, &op, &eob);
+ state = CCR; /* go collect it */
+ break;
+
+ case (unsigned char) TAG_EMBED : /* process TAG data */
+ WRAP_EMBED_PUTC(f, TAG_EMBED);
+ WRAP_STATE(f) = state; /* and return */
+ state = TAG;
+ continue;
+
+ case '-' : /* sig dash? */
+ WRAP_FL_SIG(f) = 1;
+ WRAP_ALLWSP(f) = 0;
+ state = FL_SIG;
+ break;
+
+ default : /* something else */
+ state = DFL;
+ goto case_dfl; /* handle c like DFL */
+ }
+
+ break;
+
+ case FL_SIG : /* sig-dash collector */
+ switch (WRAP_FL_SIG(f)){ /* possible sig-dash? */
+ case 1 :
+ if(c != '-'){ /* not a sigdash */
+ if((f->n + WRAP_SPC_LEN(f) + 1) > WRAP_COL(f)){
+ wrap_flush_embed(f, &ip, &eib, &op,
+ &eob); /* note any embedded*/
+ wrap_eol(f, 1, &ip, &eib,
+ &op, &eob); /* plunk down newline */
+ wrap_bol(f, 1, 1, &ip, &eib,
+ &op, &eob); /* write any prefix */
+ }
+
+ WRAP_PUTC(f,'-', 1); /* write what we got */
+
+ WRAP_FL_SIG(f) = 0;
+ state = DFL;
+ goto case_dfl;
+ }
+
+ /* don't put anything yet until we know to wrap or not */
+ WRAP_FL_SIG(f) = 2;
+ break;
+
+ case 2 :
+ if(c != ' '){ /* not a sigdash */
+ WRAP_PUTC(f, '-', 1);
+ if((f->n + WRAP_SPC_LEN(f) + 2) > WRAP_COL(f)){
+ wrap_flush_embed(f, &ip, &eib, &op,
+ &eob); /* note any embedded*/
+ wrap_eol(f, 1, &ip, &eib,
+ &op, &eob); /* plunk down newline */
+ wrap_bol(f, 1, 1, &ip, &eib, &op,
+ &eob); /* write any prefix */
+ }
+
+ WRAP_PUTC(f,'-', 1); /* write what we got */
+
+ WRAP_FL_SIG(f) = 0;
+ state = DFL;
+ goto case_dfl;
+ }
+
+ /* don't put anything yet until we know to wrap or not */
+ WRAP_FL_SIG(f) = 3;
+ break;
+
+ case 3 :
+ if(c == '\015'){ /* success! */
+ /* known sigdash, newline if soft nl */
+ if(WRAP_SPC_LEN(f)){
+ wrap_flush(f, &ip, &eib, &op, &eob);
+ wrap_eol(f, 0, &ip, &eib, &op, &eob);
+ wrap_bol(f, 0, 1, &ip, &eib, &op, &eob);
+ }
+ WRAP_PUTC(f,'-',1);
+ WRAP_PUTC(f,'-',1);
+ WRAP_PUTC(f,' ',1);
+
+ state = CCR;
+ break;
+ }
+ else{
+ WRAP_FL_SIG(f) = 4; /* possible success */
+ }
+
+ case 4 :
+ switch(c){
+ case (unsigned char) TAG_EMBED :
+ /*
+ * At this point we're almost 100% sure that we've got
+ * a sigdash. Putc it (adding newline if previous
+ * was a soft nl) so we get it the right color
+ * before we store this new embedded stuff
+ */
+ if(WRAP_SPC_LEN(f)){
+ wrap_flush(f, &ip, &eib, &op, &eob);
+ wrap_eol(f, 0, &ip, &eib, &op, &eob);
+ wrap_bol(f, 0, 1, &ip, &eib, &op, &eob);
+ }
+ WRAP_PUTC(f,'-',1);
+ WRAP_PUTC(f,'-',1);
+ WRAP_PUTC(f,' ',1);
+
+ WRAP_FL_SIG(f) = 5;
+ break;
+
+ case '\015' : /* success! */
+ /*
+ * We shouldn't get here, but in case we do, we have
+ * not yet put the sigdash
+ */
+ if(WRAP_SPC_LEN(f)){
+ wrap_flush(f, &ip, &eib, &op, &eob);
+ wrap_eol(f, 0, &ip, &eib, &op, &eob);
+ wrap_bol(f, 0, 1, &ip, &eib, &op, &eob);
+ }
+ WRAP_PUTC(f,'-',1);
+ WRAP_PUTC(f,'-',1);
+ WRAP_PUTC(f,' ',1);
+
+ state = CCR;
+ break;
+
+ default : /* that's no sigdash! */
+ /* write what we got but didn't put yet */
+ WRAP_PUTC(f,'-', 1);
+ WRAP_PUTC(f,'-', 1);
+ WRAP_PUTC(f,' ', 1);
+
+ WRAP_FL_SIG(f) = 0;
+ wrap_flush(f, &ip, &eib, &op, &eob);
+ WRAP_SPC_LEN(f) = 1;
+ state = DFL; /* set normal state */
+ goto case_dfl; /* and go do "c" */
+ }
+
+ break;
+
+ case 5 :
+ WRAP_STATE(f) = FL_SIG; /* come back here */
+ WRAP_FL_SIG(f) = 6; /* and seek EOL */
+ WRAP_EMBED_PUTC(f, TAG_EMBED);
+ state = TAG; /* process embed */
+ goto case_tag;
+
+ case 6 :
+ /*
+ * at this point we've already putc the sigdash in case 4
+ */
+ switch(c){
+ case (unsigned char) TAG_EMBED :
+ WRAP_FL_SIG(f) = 5;
+ break;
+
+ case '\015' : /* success! */
+ state = CCR;
+ break;
+
+ default : /* that's no sigdash! */
+ /*
+ * probably never reached (fake sigdash with embedded
+ * stuff) but if this did get reached, then we
+ * might have accidentally disobeyed a soft nl
+ */
+ WRAP_FL_SIG(f) = 0;
+ wrap_flush(f, &ip, &eib, &op, &eob);
+ WRAP_SPC_LEN(f) = 1;
+ state = DFL; /* set normal state */
+ goto case_dfl; /* and go do "c" */
+ }
+
+ break;
+
+
+ default :
+ dprint((2, "-- gf_wrap: BROKEN FLOW STATE: %d\n",
+ WRAP_FL_SIG(f)));
+ WRAP_FL_SIG(f) = 0;
+ state = DFL; /* set normal state */
+ goto case_dfl; /* and go process "c" */
+ }
+
+ break;
+
+ case_dfl :
+ case DFL :
+ /*
+ * This was just if(WRAP_SPEC(f, c)) before the change to add
+ * the == 0 test. This isn't quite right, either. We should really
+ * be looking for special characters in the UCS characters, not
+ * in the incoming stream of UTF-8. It is not right to
+ * call this on bytes that are in the middle of a UTF-8 character,
+ * hence the == 0 test which restricts it to the first byte
+ * of a character. This isn't right, either, but it's closer.
+ * Also change the definition of WRAP_SPEC so that isspace only
+ * matches ascii characters, which will never be in the middle
+ * of a UTF-8 multi-byte character.
+ */
+ if((WRAP_UTF8BUFP(f) - &WRAP_UTF8BUF(f, 0)) == 0 && WRAP_SPEC(f, c)){
+ WRAP_SAW_SOFT_HYPHEN(f) = 0;
+ switch(c){
+ default :
+ if(WRAP_QUOTED(f))
+ break;
+
+ if(f->f2){ /* any non-lwsp to flush? */
+ if(WRAP_COMMA(f)){
+ /* remember our second best break point */
+ WRAP_PB_OFF(f) = f->linep - f->line;
+ WRAP_PB_LEN(f) = f->f2;
+ break;
+ }
+ else
+ wrap_flush(f, &ip, &eib, &op, &eob);
+ }
+
+ switch(c){ /* remember separator */
+ case ' ' :
+ WRAP_SPC_LEN(f)++;
+ WRAP_TRL_SPC(f) = 1;
+ so_writec(' ',WRAP_SPACES(f));
+ break;
+
+ case TAB :
+ {
+ int i = (int) f->n + WRAP_SPC_LEN(f);
+
+ do
+ WRAP_SPC_LEN(f)++;
+ while(++i & 0x07);
+
+ so_writec(TAB,WRAP_SPACES(f));
+ WRAP_TRL_SPC(f) = 0;
+ }
+
+ break;
+
+ default : /* some control char? */
+ WRAP_SPC_LEN(f) += 2;
+ WRAP_TRL_SPC(f) = 0;
+ break;
+ }
+
+ continue;
+
+ case '\"' :
+ WRAP_QUOTED(f) = !WRAP_QUOTED(f);
+ break;
+
+ case '\015' : /* already has newline? */
+ state = CCR;
+ continue;
+
+ case '\012' : /* bare LF in text? */
+ wrap_flush(f, &ip, &eib, &op, &eob); /* they must've */
+ wrap_eol(f, 0, &ip, &eib, &op, &eob); /* meant */
+ wrap_bol(f,1,1, &ip, &eib, &op, &eob); /* newline... */
+ continue;
+
+ case (unsigned char) TAG_EMBED :
+ WRAP_EMBED_PUTC(f, TAG_EMBED);
+ WRAP_STATE(f) = state;
+ state = TAG;
+ continue;
+
+ case ',' :
+ if(!WRAP_QUOTED(f)){
+ /* handle this special case in general code below */
+ if(f->n + WRAP_SPC_LEN(f) + f->f2 + 1 > WRAP_MAX_COL(f)
+ && WRAP_ALLWSP(f) && WRAP_PB_OFF(f))
+ break;
+
+ if(f->n + WRAP_SPC_LEN(f) + f->f2 + 1 > WRAP_COL(f)){
+ if(WRAP_ALLWSP(f)) /* if anything visible */
+ wrap_flush(f, &ip, &eib, &op,
+ &eob); /* ... blat buf'd chars */
+
+ wrap_eol(f, 1, &ip, &eib, &op,
+ &eob); /* plunk down newline */
+ wrap_bol(f, 1, 1, &ip, &eib, &op,
+ &eob); /* write any prefix */
+ }
+
+ WRAP_PUTC(f, ',', 1); /* put out comma */
+ wrap_flush(f, &ip, &eib, &op,
+ &eob); /* write buf'd chars */
+ continue;
+ }
+
+ break;
+ }
+ }
+ else if(WRAP_HANDLE_SOFT_HYPHEN(f)
+ && (WRAP_UTF8BUFP(f) - &WRAP_UTF8BUF(f, 0)) == 1
+ && WRAP_UTF8BUF(f, 0) == 0xC2 && c == 0xAD){
+ /*
+ * This is a soft hyphen. If there is enough space for
+ * a real hyphen to fit on the line here then we can
+ * flush everything up to before the soft hyphen,
+ * and simply remember that we saw a soft hyphen.
+ * If it turns out that we can't fit the next piece in
+ * then wrap_eol will append a real hyphen to the line.
+ * If we can fit another piece in it will be because we've
+ * reached the next break point. At that point we'll flush
+ * everything but won't include the unneeded hyphen. We erase
+ * the fact that we saw this soft hyphen because it have
+ * become irrelevant.
+ *
+ * If the hyphen is the character that puts us over the edge
+ * we go through the else case.
+ */
+
+ /* erase this soft hyphen character from buffer */
+ WRAP_UTF8BUFP(f) = &WRAP_UTF8BUF(f, 0);
+
+ if((f->n + WRAP_SPC_LEN(f) + f->f2 + 1) <= WRAP_COL(f)){
+ if(f->f2) /* any non-lwsp to flush? */
+ wrap_flush(f, &ip, &eib, &op, &eob);
+
+ /* remember that we saw the soft hyphen */
+ WRAP_SAW_SOFT_HYPHEN(f) = 1;
+ }
+ else{
+ /*
+ * Everything up to the hyphen fits, otherwise it
+ * would have already been flushed the last time
+ * through the loop. But the hyphen won't fit. So
+ * we need to go back to the last line break and
+ * break there instead. Then start a new line with
+ * the buffered up characters and the soft hyphen.
+ */
+ wrap_flush_embed(f, &ip, &eib, &op, &eob);
+ wrap_eol(f, 1, &ip, &eib, &op,
+ &eob); /* plunk down newline */
+ wrap_bol(f,1,1, &ip, &eib, &op,
+ &eob); /* write any prefix */
+
+ /*
+ * Now we're in the same situation as we would have
+ * been above except we're on a new line. Try to
+ * flush out the characters seen up to the hyphen.
+ */
+ if((f->n + WRAP_SPC_LEN(f) + f->f2 + 1) <= WRAP_COL(f)){
+ if(f->f2) /* any non-lwsp to flush? */
+ wrap_flush(f, &ip, &eib, &op, &eob);
+
+ /* remember that we saw the soft hyphen */
+ WRAP_SAW_SOFT_HYPHEN(f) = 1;
+ }
+ else
+ WRAP_SAW_SOFT_HYPHEN(f) = 0;
+ }
+
+ continue;
+ }
+
+ full_character = 0;
+
+ {
+ unsigned char *inputp;
+ unsigned long remaining_octets;
+ UCS ucs;
+
+ if(WRAP_UTF8BUFP(f) < &WRAP_UTF8BUF(f, 0) + 6){ /* always true */
+
+ *WRAP_UTF8BUFP(f)++ = c;
+ remaining_octets = WRAP_UTF8BUFP(f) - &WRAP_UTF8BUF(f, 0);
+ if(remaining_octets == 1 && isascii(WRAP_UTF8BUF(f, 0))){
+ full_character++;
+ if(c == TAB){
+ int i = (int) f->n;
+
+ while(i & 0x07)
+ i++;
+
+ width = i - f->n;
+ }
+ else if(c < 0x80 && iscntrl((unsigned char) c))
+ width = 2;
+ else
+ width = 1;
+ }
+ else{
+ inputp = &WRAP_UTF8BUF(f, 0);
+ ucs = (UCS) utf8_get(&inputp, &remaining_octets);
+ switch(ucs){
+ case U8G_ENDSTRG: /* incomplete character, wait */
+ case U8G_ENDSTRI: /* incomplete character, wait */
+ width = 0;
+ break;
+
+ default:
+ if(ucs & U8G_ERROR || ucs == UBOGON){
+ /*
+ * None of these cases is supposed to happen. If it
+ * does happen then the input stream isn't UTF-8
+ * so something is wrong. Writechar will treat
+ * each octet in the input buffer as a separate
+ * error character and print a '?' for each,
+ * so the width will be the number of octets.
+ */
+ width = WRAP_UTF8BUFP(f) - &WRAP_UTF8BUF(f, 0);
+ full_character++;
+ }
+ else{
+ /* got a character */
+ width = wcellwidth(ucs);
+ full_character++;
+
+ if(width < 0){
+ /*
+ * This happens when we have a UTF-8 character that
+ * we aren't able to print in our locale. For example,
+ * if the locale is setup with the terminal
+ * expecting ISO-8859-1 characters then there are
+ * lots of UTF-8 characters that can't be printed.
+ * Print a '?' instead.
+ */
+ width = 1;
+ }
+ }
+
+ break;
+ }
+ }
+ }
+ else{
+ /*
+ * This cannot happen because an error would have
+ * happened at least by character #6. So if we get
+ * here there is a bug in utf8_get().
+ */
+ if(WRAP_UTF8BUFP(f) == &WRAP_UTF8BUF(f, 0) + 6){
+ *WRAP_UTF8BUFP(f)++ = c;
+ }
+
+ /*
+ * We could possibly do some more sophisticated
+ * resynchronization here, but we aren't doing
+ * anything in Writechar so it wouldn't match up
+ * with that anyway. Just figure each character will
+ * end up being printed as a ? character.
+ */
+ width = WRAP_UTF8BUFP(f) - &WRAP_UTF8BUF(f, 0);
+ full_character++;
+ }
+ }
+
+ if(WRAP_ALLWSP(f)){
+ /*
+ * Nothing is visible yet but the first word may be too long
+ * all by itself. We need to break early.
+ */
+ if(f->n + WRAP_SPC_LEN(f) + f->f2 + width > WRAP_MAX_COL(f)){
+ /*
+ * A little reaching behind the curtain here.
+ * if there's at least a preferable break point, use
+ * it and stuff what's left back into the wrap buffer.
+ * The "nwsp" latch is used to skip leading whitespace
+ * The second half of the test prevents us from wrapping
+ * at the preferred break point in the case that it
+ * is so early in the line that it doesn't help.
+ * That is, the width of the indent is even more than
+ * the width of the first part before the preferred
+ * break point. An example would be breaking after
+ * "To:" when the indent is 4 which is > 3.
+ */
+ if(WRAP_PB_OFF(f) && WRAP_PB_LEN(f) >= WRAP_INDENT(f)){
+ char *p1 = f->line + WRAP_PB_OFF(f);
+ char *p2 = f->linep;
+ char c2;
+ int nwsp = 0, left_after_wrap;
+
+ left_after_wrap = f->f2 - WRAP_PB_LEN(f);
+
+ f->f2 = WRAP_PB_LEN(f);
+ f->linep = p1;
+
+ wrap_flush(f, &ip, &eib, &op, &eob); /* flush shortened buf */
+
+ /* put back rest of characters */
+ while(p1 < p2){
+ c2 = *p1++;
+ if(!(c2 == ' ' || c2 == '\t') || nwsp){
+ WRAP_PUTC(f, c2, 0);
+ nwsp = 1;
+ }
+ else
+ left_after_wrap--; /* wrong if a tab! */
+ }
+
+ f->f2 = MAX(left_after_wrap, 0);
+
+ wrap_eol(f, 1, &ip, &eib, &op,
+ &eob); /* plunk down newline */
+ wrap_bol(f,1,1, &ip, &eib, &op,
+ &eob); /* write any prefix */
+
+ /*
+ * What's this for?
+ * If we do the less preferable break point at
+ * the space we don't want to lose the fact that
+ * we might be able to break at this comma for
+ * the next one.
+ */
+ if(full_character && c == ','){
+ WRAP_PUTC(f, c, 1);
+ wrap_flush(f, &ip, &eib, &op, &eob);
+ WRAP_UTF8BUFP(f) = &WRAP_UTF8BUF(f, 0);
+ }
+ }
+ else{
+ wrap_flush(f, &ip, &eib, &op, &eob);
+
+ wrap_eol(f, 1, &ip, &eib, &op,
+ &eob); /* plunk down newline */
+ wrap_bol(f,1,1, &ip, &eib, &op,
+ &eob); /* write any prefix */
+ }
+ }
+ }
+ else if((f->n + WRAP_SPC_LEN(f) + f->f2 + width) > WRAP_COL(f)){
+ wrap_flush_embed(f, &ip, &eib, &op, &eob);
+ wrap_eol(f, 1, &ip, &eib, &op,
+ &eob); /* plunk down newline */
+ wrap_bol(f,1,1, &ip, &eib, &op,
+ &eob); /* write any prefix */
+ }
+
+ /*
+ * Commit entire multibyte UTF-8 character at once
+ * instead of writing partial characters into the
+ * buffer.
+ */
+ if(full_character){
+ unsigned char *q;
+
+ for(q = &WRAP_UTF8BUF(f, 0); q < WRAP_UTF8BUFP(f); q++){
+ WRAP_PUTC(f, *q, width);
+ width = 0;
+ }
+
+ WRAP_UTF8BUFP(f) = &WRAP_UTF8BUF(f, 0);
+ }
+
+ break;
+
+ case_tag :
+ case TAG :
+ WRAP_EMBED_PUTC(f, c);
+ switch(c){
+ case TAG_HANDLE :
+ WRAP_EMBED(f) = -1;
+ state = HANDLE;
+ break;
+
+ case TAG_FGCOLOR :
+ case TAG_BGCOLOR :
+ WRAP_EMBED(f) = RGBLEN;
+ state = HDATA;
+ break;
+
+ default :
+ state = WRAP_STATE(f);
+ break;
+ }
+
+ break;
+
+ case HANDLE :
+ WRAP_EMBED_PUTC(f, c);
+ WRAP_EMBED(f) = c;
+ state = HDATA;
+ break;
+
+ case HDATA :
+ if(f->f2){
+ WRAP_PUTC(f, c, 0);
+ }
+ else
+ so_writec(c, WRAP_SPACES(f));
+
+ if(!(WRAP_EMBED(f) -= 1)){
+ state = WRAP_STATE(f);
+ }
+
+ break;
+ }
+ }
+
+ f->f1 = state;
+ GF_END(f, f->next);
+ }
+ else if(flg == GF_EOD){
+ wrap_flush(f, &ip, &eib, &op, &eob);
+ if(WRAP_COLOR(f))
+ free_color_pair(&WRAP_COLOR(f));
+
+ fs_give((void **) &f->line); /* free temp line buffer */
+ so_give(&WRAP_SPACES(f));
+ fs_give((void **) &f->opt); /* free wrap widths struct */
+ (void) GF_FLUSH(f->next);
+ (*f->next->f)(f->next, GF_EOD);
+ }
+ else if(flg == GF_RESET){
+ dprint((9, "-- gf_reset wrap\n"));
+ f->f1 = BOL;
+ f->n = 0L; /* displayed length of line so far */
+ f->f2 = 0; /* displayed length of buffered chars */
+ WRAP_HARD(f) = 1; /* starting at beginning of line */
+ if(! (WRAP_S *) f->opt)
+ f->opt = gf_wrap_filter_opt(75, 80, NULL, 0, 0);
+
+ while(WRAP_INDENT(f) >= WRAP_MAX_COL(f))
+ WRAP_INDENT(f) /= 2;
+
+ f->line = (char *) fs_get(WRAP_MAX_COL(f) * sizeof(char));
+ f->linep = f->line;
+ WRAP_LASTC(f) = &f->line[WRAP_MAX_COL(f) - 1];
+
+ for(i = 0; i < 256; i++)
+ ((WRAP_S *) f->opt)->special[i] = ((i == '\"' && WRAP_COMMA(f))
+ || i == '\015'
+ || i == '\012'
+ || (i == (unsigned char) TAG_EMBED
+ && WRAP_TAGS(f))
+ || (i == ',' && WRAP_COMMA(f)
+ && !WRAP_QUOTED(f))
+ || ASCII_ISSPACE(i));
+ WRAP_SPACES(f) = so_get(CharStar, NULL, EDIT_ACCESS);
+ WRAP_UTF8BUFP(f) = &WRAP_UTF8BUF(f, 0);
+ }
+}
+
+int
+wrap_flush(FILTER_S *f, unsigned char **ipp, unsigned char **eibp,
+ unsigned char **opp, unsigned char **eobp)
+{
+ register char *s;
+ register int n;
+
+ s = (char *)so_text(WRAP_SPACES(f));
+ n = so_tell(WRAP_SPACES(f));
+ so_seek(WRAP_SPACES(f), 0L, 0);
+ wrap_flush_s(f, s, n, WRAP_SPC_LEN(f), ipp, eibp, opp, eobp, WFE_NONE);
+ so_truncate(WRAP_SPACES(f), 0L);
+ WRAP_SPC_LEN(f) = 0;
+ WRAP_TRL_SPC(f) = 0;
+ s = f->line;
+ n = f->linep - f->line;
+ wrap_flush_s(f, s, n, f->f2, ipp, eibp, opp, eobp, WFE_NONE);
+ f->f2 = 0;
+ f->linep = f->line;
+ WRAP_PB_OFF(f) = 0;
+ WRAP_PB_LEN(f) = 0;
+
+ return 0;
+}
+
+int
+wrap_flush_embed(FILTER_S *f, unsigned char **ipp, unsigned char **eibp, unsigned char **opp, unsigned char **eobp)
+{
+ register char *s;
+ register int n;
+ s = (char *)so_text(WRAP_SPACES(f));
+ n = so_tell(WRAP_SPACES(f));
+ so_seek(WRAP_SPACES(f), 0L, 0);
+ wrap_flush_s(f, s, n, 0, ipp, eibp, opp, eobp, WFE_CNT_HANDLE);
+ so_truncate(WRAP_SPACES(f), 0L);
+ WRAP_SPC_LEN(f) = 0;
+ WRAP_TRL_SPC(f) = 0;
+
+ return 0;
+}
+
+int
+wrap_flush_s(FILTER_S *f, char *s, int n, int w, unsigned char **ipp,
+ unsigned char **eibp, unsigned char **opp, unsigned char **eobp, int flags)
+{
+ f->n += w;
+
+ for(; n > 0; n--,s++){
+ if(*s == TAG_EMBED){
+ if(n-- > 0){
+ switch(*++s){
+ case TAG_BOLDON :
+ GF_PUTC_GLO(f->next,TAG_EMBED);
+ GF_PUTC_GLO(f->next,TAG_BOLDON);
+ WRAP_BOLD(f) = 1;
+ break;
+ case TAG_BOLDOFF :
+ GF_PUTC_GLO(f->next,TAG_EMBED);
+ GF_PUTC_GLO(f->next,TAG_BOLDOFF);
+ WRAP_BOLD(f) = 0;
+ break;
+ case TAG_ULINEON :
+ GF_PUTC_GLO(f->next,TAG_EMBED);
+ GF_PUTC_GLO(f->next,TAG_ULINEON);
+ WRAP_ULINE(f) = 1;
+ break;
+ case TAG_ULINEOFF :
+ GF_PUTC_GLO(f->next,TAG_EMBED);
+ GF_PUTC_GLO(f->next,TAG_ULINEOFF);
+ WRAP_ULINE(f) = 0;
+ break;
+ case TAG_INVOFF :
+ GF_PUTC_GLO(f->next,TAG_EMBED);
+ GF_PUTC_GLO(f->next,TAG_INVOFF);
+ WRAP_ANCHOR(f) = 0;
+ break;
+ case TAG_HANDLE :
+ if((flags & WFE_CNT_HANDLE) == 0)
+ GF_PUTC_GLO(f->next,TAG_EMBED);
+
+ if(n-- > 0){
+ int i = *++s;
+
+ if((flags & WFE_CNT_HANDLE) == 0)
+ GF_PUTC_GLO(f->next, TAG_HANDLE);
+
+ if(i <= n){
+ n -= i;
+
+ if((flags & WFE_CNT_HANDLE) == 0)
+ GF_PUTC_GLO(f->next, i);
+
+ WRAP_ANCHOR(f) = 0;
+ while(i-- > 0){
+ WRAP_ANCHOR(f) = (WRAP_ANCHOR(f) * 10) + (*++s-'0');
+
+ if((flags & WFE_CNT_HANDLE) == 0)
+ GF_PUTC_GLO(f->next,*s);
+ }
+
+ }
+ }
+ break;
+ case TAG_FGCOLOR :
+ if(pico_usingcolor() && n >= RGBLEN){
+ int i;
+ GF_PUTC_GLO(f->next,TAG_EMBED);
+ GF_PUTC_GLO(f->next,TAG_FGCOLOR);
+ if(!WRAP_COLOR(f))
+ WRAP_COLOR(f)=new_color_pair(NULL,NULL);
+ strncpy(WRAP_COLOR(f)->fg, s+1, RGBLEN);
+ WRAP_COLOR(f)->fg[RGBLEN]='\0';
+ i = RGBLEN;
+ n -= i;
+ while(i-- > 0)
+ GF_PUTC_GLO(f->next,
+ (*++s) & 0xff);
+ }
+ break;
+ case TAG_BGCOLOR :
+ if(pico_usingcolor() && n >= RGBLEN){
+ int i;
+ GF_PUTC_GLO(f->next,TAG_EMBED);
+ GF_PUTC_GLO(f->next,TAG_BGCOLOR);
+ if(!WRAP_COLOR(f))
+ WRAP_COLOR(f)=new_color_pair(NULL,NULL);
+ strncpy(WRAP_COLOR(f)->bg, s+1, RGBLEN);
+ WRAP_COLOR(f)->bg[RGBLEN]='\0';
+ i = RGBLEN;
+ n -= i;
+ while(i-- > 0)
+ GF_PUTC_GLO(f->next,
+ (*++s) & 0xff);
+ }
+ break;
+ default :
+ break;
+ }
+ }
+ }
+ else if(w){
+
+ if(f->n <= WRAP_MAX_COL(f)){
+ GF_PUTC_GLO(f->next, (*s) & 0xff);
+ }
+ else{
+ dprint((2, "-- gf_wrap: OVERRUN: %c\n", (*s) & 0xff));
+ }
+
+ WRAP_ALLWSP(f) = 0;
+ }
+ }
+
+ return 0;
+}
+
+int
+wrap_eol(FILTER_S *f, int c, unsigned char **ipp, unsigned char **eibp,
+ unsigned char **opp, unsigned char **eobp)
+{
+ if(WRAP_SAW_SOFT_HYPHEN(f)){
+ WRAP_SAW_SOFT_HYPHEN(f) = 0;
+ GF_PUTC_GLO(f->next, '-'); /* real hyphen */
+ }
+
+ if(c && WRAP_LV_FLD(f))
+ GF_PUTC_GLO(f->next, ' ');
+
+ if(WRAP_BOLD(f)){
+ GF_PUTC_GLO(f->next, TAG_EMBED);
+ GF_PUTC_GLO(f->next, TAG_BOLDOFF);
+ }
+
+ if(WRAP_ULINE(f)){
+ GF_PUTC_GLO(f->next, TAG_EMBED);
+ GF_PUTC_GLO(f->next, TAG_ULINEOFF);
+ }
+
+ if(WRAP_INVERSE(f) || WRAP_ANCHOR(f)){
+ GF_PUTC_GLO(f->next, TAG_EMBED);
+ GF_PUTC_GLO(f->next, TAG_INVOFF);
+ }
+
+ if(WRAP_COLOR_SET(f)){
+ char *p;
+ char cb[RGBLEN+1];
+ GF_PUTC_GLO(f->next, TAG_EMBED);
+ GF_PUTC_GLO(f->next, TAG_FGCOLOR);
+ strncpy(cb, color_to_asciirgb(ps_global->VAR_NORM_FORE_COLOR), sizeof(cb));
+ cb[sizeof(cb)-1] = '\0';
+ p = cb;
+ for(; *p; p++)
+ GF_PUTC_GLO(f->next, *p);
+ GF_PUTC_GLO(f->next, TAG_EMBED);
+ GF_PUTC_GLO(f->next, TAG_BGCOLOR);
+ strncpy(cb, color_to_asciirgb(ps_global->VAR_NORM_BACK_COLOR), sizeof(cb));
+ cb[sizeof(cb)-1] = '\0';
+ p = cb;
+ for(; *p; p++)
+ GF_PUTC_GLO(f->next, *p);
+ }
+
+ GF_PUTC_GLO(f->next, '\015');
+ GF_PUTC_GLO(f->next, '\012');
+ f->n = 0L;
+ so_truncate(WRAP_SPACES(f), 0L);
+ WRAP_SPC_LEN(f) = 0;
+ WRAP_TRL_SPC(f) = 0;
+
+ return 0;
+}
+
+int
+wrap_bol(FILTER_S *f, int ivar, int q, unsigned char **ipp, unsigned char **eibp,
+ unsigned char **opp, unsigned char **eobp)
+{
+ int n = WRAP_MARG_L(f) + (ivar ? WRAP_INDENT(f) : 0);
+
+ if(WRAP_HDR_CLR(f)){
+ char *p;
+ char cbuf[RGBLEN+1];
+ int k;
+
+ if((k = WRAP_MARG_L(f)) > 0)
+ while(k-- > 0){
+ n--;
+ f->n++;
+ GF_PUTC_GLO(f->next, ' ');
+ }
+
+ GF_PUTC_GLO(f->next, TAG_EMBED);
+ GF_PUTC_GLO(f->next, TAG_FGCOLOR);
+ strncpy(cbuf,
+ color_to_asciirgb(ps_global->VAR_HEADER_GENERAL_FORE_COLOR),
+ sizeof(cbuf));
+ cbuf[sizeof(cbuf)-1] = '\0';
+ p = cbuf;
+ for(; *p; p++)
+ GF_PUTC_GLO(f->next, *p);
+ GF_PUTC_GLO(f->next, TAG_EMBED);
+ GF_PUTC_GLO(f->next, TAG_BGCOLOR);
+ strncpy(cbuf,
+ color_to_asciirgb(ps_global->VAR_HEADER_GENERAL_BACK_COLOR),
+ sizeof(cbuf));
+ cbuf[sizeof(cbuf)-1] = '\0';
+ p = cbuf;
+ for(; *p; p++)
+ GF_PUTC_GLO(f->next, *p);
+ }
+
+ while(n-- > 0){
+ f->n++;
+ GF_PUTC_GLO(f->next, ' ');
+ }
+
+ WRAP_ALLWSP(f) = 1;
+
+ if(q)
+ wrap_quote_insert(f, ipp, eibp, opp, eobp);
+
+ if(WRAP_BOLD(f)){
+ GF_PUTC_GLO(f->next, TAG_EMBED);
+ GF_PUTC_GLO(f->next, TAG_BOLDON);
+ }
+ if(WRAP_ULINE(f)){
+ GF_PUTC_GLO(f->next, TAG_EMBED);
+ GF_PUTC_GLO(f->next, TAG_ULINEON);
+ }
+ if(WRAP_INVERSE(f)){
+ GF_PUTC_GLO(f->next, TAG_EMBED);
+ GF_PUTC_GLO(f->next, TAG_INVON);
+ }
+ if(WRAP_COLOR_SET(f)){
+ char *p;
+ if(WRAP_COLOR(f)->fg[0]){
+ char cb[RGBLEN+1];
+ GF_PUTC_GLO(f->next, TAG_EMBED);
+ GF_PUTC_GLO(f->next, TAG_FGCOLOR);
+ strncpy(cb, color_to_asciirgb(WRAP_COLOR(f)->fg), sizeof(cb));
+ cb[sizeof(cb)-1] = '\0';
+ p = cb;
+ for(; *p; p++)
+ GF_PUTC_GLO(f->next, *p);
+ }
+ if(WRAP_COLOR(f)->bg[0]){
+ char cb[RGBLEN+1];
+ GF_PUTC_GLO(f->next, TAG_EMBED);
+ GF_PUTC_GLO(f->next, TAG_BGCOLOR);
+ strncpy(cb, color_to_asciirgb(WRAP_COLOR(f)->bg), sizeof(cb));
+ cb[sizeof(cb)-1] = '\0';
+ p = cb;
+ for(; *p; p++)
+ GF_PUTC_GLO(f->next, *p);
+ }
+ }
+ if(WRAP_ANCHOR(f)){
+ char buf[64]; int i;
+ GF_PUTC_GLO(f->next, TAG_EMBED);
+ GF_PUTC_GLO(f->next, TAG_HANDLE);
+ snprintf(buf, sizeof(buf), "%d", WRAP_ANCHOR(f));
+ GF_PUTC_GLO(f->next, (int) strlen(buf));
+ for(i = 0; buf[i]; i++)
+ GF_PUTC_GLO(f->next, buf[i]);
+ }
+
+ return 0;
+}
+
+int
+wrap_quote_insert(FILTER_S *f, unsigned char **ipp, unsigned char **eibp,
+ unsigned char **opp, unsigned char **eobp)
+{
+ int j, i;
+ COLOR_PAIR *col = NULL;
+ char *prefix = NULL, *last_prefix = NULL;
+
+ if(ps_global->VAR_QUOTE_REPLACE_STRING){
+ get_pair(ps_global->VAR_QUOTE_REPLACE_STRING, &prefix, &last_prefix, 0, 0);
+ if(!prefix && last_prefix){
+ prefix = last_prefix;
+ last_prefix = NULL;
+ }
+ }
+
+ for(j = 0; j < WRAP_FL_QD(f); j++){
+ if(WRAP_USE_CLR(f)){
+ if((j % 3) == 0
+ && ps_global->VAR_QUOTE1_FORE_COLOR
+ && ps_global->VAR_QUOTE1_BACK_COLOR
+ && (col = new_color_pair(ps_global->VAR_QUOTE1_FORE_COLOR,
+ ps_global->VAR_QUOTE1_BACK_COLOR))
+ && pico_is_good_colorpair(col)){
+ GF_COLOR_PUTC(f, col);
+ }
+ else if((j % 3) == 1
+ && ps_global->VAR_QUOTE2_FORE_COLOR
+ && ps_global->VAR_QUOTE2_BACK_COLOR
+ && (col = new_color_pair(ps_global->VAR_QUOTE2_FORE_COLOR,
+ ps_global->VAR_QUOTE2_BACK_COLOR))
+ && pico_is_good_colorpair(col)){
+ GF_COLOR_PUTC(f, col);
+ }
+ else if((j % 3) == 2
+ && ps_global->VAR_QUOTE3_FORE_COLOR
+ && ps_global->VAR_QUOTE3_BACK_COLOR
+ && (col = new_color_pair(ps_global->VAR_QUOTE3_FORE_COLOR,
+ ps_global->VAR_QUOTE3_BACK_COLOR))
+ && pico_is_good_colorpair(col)){
+ GF_COLOR_PUTC(f, col);
+ }
+ if(col){
+ free_color_pair(&col);
+ col = NULL;
+ }
+ }
+
+ if(!WRAP_LV_FLD(f)){
+ if(!WRAP_FOR_CMPS(f) && ps_global->VAR_QUOTE_REPLACE_STRING && prefix){
+ for(i = 0; prefix[i]; i++)
+ GF_PUTC_GLO(f->next, prefix[i]);
+ f->n += utf8_width(prefix);
+ }
+ else if(ps_global->VAR_REPLY_STRING
+ && (!strcmp(ps_global->VAR_REPLY_STRING, ">")
+ || !strcmp(ps_global->VAR_REPLY_STRING, "\">\""))){
+ GF_PUTC_GLO(f->next, '>');
+ f->n += 1;
+ }
+ else{
+ GF_PUTC_GLO(f->next, '>');
+ GF_PUTC_GLO(f->next, ' ');
+ f->n += 2;
+ }
+ }
+ else{
+ GF_PUTC_GLO(f->next, '>');
+ f->n += 1;
+ }
+ }
+ if(j && WRAP_LV_FLD(f)){
+ GF_PUTC_GLO(f->next, ' ');
+ f->n++;
+ }
+ else if(j && last_prefix){
+ for(i = 0; last_prefix[i]; i++)
+ GF_PUTC_GLO(f->next, last_prefix[i]);
+ f->n += utf8_width(last_prefix);
+ }
+
+ if(prefix)
+ fs_give((void **)&prefix);
+ if(last_prefix)
+ fs_give((void **)&last_prefix);
+
+ return 0;
+}
+
+
+/*
+ * function called from the outside to set
+ * wrap filter's width option
+ */
+void *
+gf_wrap_filter_opt(int width, int width_max, int *margin, int indent, int flags)
+{
+ WRAP_S *wrap;
+
+ /* NOTE: variables MUST be sanity checked before they get here */
+ wrap = (WRAP_S *) fs_get(sizeof(WRAP_S));
+ memset(wrap, 0, sizeof(WRAP_S));
+ wrap->wrap_col = width;
+ wrap->wrap_max = width_max;
+ wrap->indent = indent;
+ wrap->margin_l = (margin) ? margin[0] : 0;
+ wrap->margin_r = (margin) ? margin[1] : 0;
+ wrap->tags = (GFW_HANDLES & flags) == GFW_HANDLES;
+ wrap->on_comma = (GFW_ONCOMMA & flags) == GFW_ONCOMMA;
+ wrap->flowed = (GFW_FLOWED & flags) == GFW_FLOWED;
+ wrap->leave_flowed = (GFW_FLOW_RESULT & flags) == GFW_FLOW_RESULT;
+ wrap->delsp = (GFW_DELSP & flags) == GFW_DELSP;
+ wrap->use_color = (GFW_USECOLOR & flags) == GFW_USECOLOR;
+ wrap->hdr_color = (GFW_HDRCOLOR & flags) == GFW_HDRCOLOR;
+ wrap->for_compose = (GFW_FORCOMPOSE & flags) == GFW_FORCOMPOSE;
+ wrap->handle_soft_hyphen = (GFW_SOFTHYPHEN & flags) == GFW_SOFTHYPHEN;
+
+ return((void *) wrap);
+}
+
+
+void *
+gf_url_hilite_opt(URL_HILITE_S *uh, HANDLE_S **handlesp, int flags)
+{
+ if(uh){
+ memset(uh, 0, sizeof(URL_HILITE_S));
+ uh->handlesp = handlesp;
+ uh->hdr_color = (URH_HDRCOLOR & flags) == URH_HDRCOLOR;
+ }
+
+ return((void *) uh);
+}
+
+
+#define PF_QD(F) (((PREFLOW_S *)(F)->opt)->quote_depth)
+#define PF_QC(F) (((PREFLOW_S *)(F)->opt)->quote_count)
+#define PF_SIG(F) (((PREFLOW_S *)(F)->opt)->sig)
+
+typedef struct preflow_s {
+ int quote_depth,
+ quote_count,
+ sig;
+} PREFLOW_S;
+
+/*
+ * This would normally be handled in gf_wrap. If there is a possibility
+ * that a url we want to recognize is cut in half by a soft newline we
+ * want to fix that up by putting the halves back together. We do that
+ * by deleting the soft newline and putting it all in one line. It will
+ * still get wrapped later in gf_wrap. It isn't pretty with all the
+ * goto's, but whatta ya gonna do?
+ */
+void
+gf_preflow(FILTER_S *f, int flg)
+{
+ GF_INIT(f, f->next);
+
+ if(flg == GF_DATA){
+ register unsigned char c;
+ register int state = f->f1;
+ register int pending = f->f2;
+
+ while(GF_GETC(f, c)){
+ switch(state){
+ case DFL:
+default_case:
+ switch(c){
+ case ' ':
+ state = WSPACE;
+ break;
+
+ case '\015':
+ state = CCR;
+ break;
+
+ default:
+ GF_PUTC(f->next, c);
+ break;
+ }
+
+ break;
+
+ case CCR:
+ switch(c){
+ case '\012':
+ pending = 1;
+ state = BOL;
+ break;
+
+ default:
+ GF_PUTC(f->next, '\012');
+ state = DFL;
+ goto default_case;
+ break;
+ }
+
+ break;
+
+ case WSPACE:
+ switch(c){
+ case '\015':
+ state = SPACECR;
+ break;
+
+ default:
+ GF_PUTC(f->next, ' ');
+ state = DFL;
+ goto default_case;
+ break;
+ }
+
+ break;
+
+ case SPACECR:
+ switch(c){
+ case '\012':
+ pending = 2;
+ state = BOL;
+ break;
+
+ default:
+ GF_PUTC(f->next, ' ');
+ GF_PUTC(f->next, '\012');
+ state = DFL;
+ goto default_case;
+ break;
+ }
+
+ break;
+
+ case BOL:
+ PF_QC(f) = 0;
+ if(c == '>'){ /* count quote level */
+ PF_QC(f)++;
+ state = FL_QLEV;
+ }
+ else{
+done_counting_quotes:
+ if(c == ' '){ /* eat stuffed space */
+ state = FL_STF;
+ break;
+ }
+
+done_with_stuffed_space:
+ if(c == '-'){ /* look for signature */
+ PF_SIG(f) = 1;
+ state = FL_SIG;
+ break;
+ }
+
+done_with_sig:
+ if(pending == 2){
+ if(PF_QD(f) == PF_QC(f) && PF_SIG(f) < 4){
+ /* delete pending */
+
+ PF_QD(f) = PF_QC(f);
+
+ /* suppress quotes, too */
+ PF_QC(f) = 0;
+ }
+ else{
+ /*
+ * This should have been a hard new line
+ * instead so leave out the trailing space.
+ */
+ GF_PUTC(f->next, '\015');
+ GF_PUTC(f->next, '\012');
+
+ PF_QD(f) = PF_QC(f);
+ }
+ }
+ else if(pending == 1){
+ GF_PUTC(f->next, '\015');
+ GF_PUTC(f->next, '\012');
+ PF_QD(f) = PF_QC(f);
+ }
+ else{
+ PF_QD(f) = PF_QC(f);
+ }
+
+ pending = 0;
+ state = DFL;
+ while(PF_QC(f)-- > 0)
+ GF_PUTC(f->next, '>');
+
+ switch(PF_SIG(f)){
+ case 0:
+ default:
+ break;
+
+ case 1:
+ GF_PUTC(f->next, '-');
+ break;
+
+ case 2:
+ GF_PUTC(f->next, '-');
+ GF_PUTC(f->next, '-');
+ break;
+
+ case 3:
+ case 4:
+ GF_PUTC(f->next, '-');
+ GF_PUTC(f->next, '-');
+ GF_PUTC(f->next, ' ');
+ break;
+ }
+
+ PF_SIG(f) = 0;
+ goto default_case; /* to handle c */
+ }
+
+ break;
+
+ case FL_QLEV: /* count quote level */
+ if(c == '>')
+ PF_QC(f)++;
+ else
+ goto done_counting_quotes;
+
+ break;
+
+ case FL_STF: /* eat stuffed space */
+ goto done_with_stuffed_space;
+ break;
+
+ case FL_SIG: /* deal with sig indicator */
+ switch(PF_SIG(f)){
+ case 1: /* saw '-' */
+ if(c == '-')
+ PF_SIG(f) = 2;
+ else
+ goto done_with_sig;
+
+ break;
+
+ case 2: /* saw '--' */
+ if(c == ' ')
+ PF_SIG(f) = 3;
+ else
+ goto done_with_sig;
+
+ break;
+
+ case 3: /* saw '-- ' */
+ if(c == '\015')
+ PF_SIG(f) = 4; /* it really is a sig line */
+
+ goto done_with_sig;
+ break;
+ }
+
+ break;
+ }
+ }
+
+ f->f1 = state;
+ f->f2 = pending;
+ GF_END(f, f->next);
+ }
+ else if(flg == GF_EOD){
+ fs_give((void **) &f->opt);
+ (void) GF_FLUSH(f->next);
+ (*f->next->f)(f->next, GF_EOD);
+ }
+ else if(flg == GF_RESET){
+ PREFLOW_S *pf;
+
+ pf = (PREFLOW_S *) fs_get(sizeof(*pf));
+ memset(pf, 0, sizeof(*pf));
+ f->opt = (void *) pf;
+
+ f->f1 = BOL; /* state */
+ f->f2 = 0; /* pending */
+ PF_QD(f) = 0; /* quote depth */
+ PF_QC(f) = 0; /* quote count */
+ PF_SIG(f) = 0; /* sig level */
+ }
+}
+
+
+
+
+/*
+ * LINE PREFIX FILTER - insert given text at beginning of each
+ * line
+ */
+
+
+#define GF_PREFIX_WRITE(s) { \
+ register char *p; \
+ if((p = (s)) != NULL) \
+ while(*p) \
+ GF_PUTC(f->next, *p++); \
+ }
+
+
+/*
+ * the simple filter, prepends each line with the requested prefix.
+ * if prefix is null, does nothing, and as with all filters, assumes
+ * NVT end of lines.
+ */
+void
+gf_prefix(FILTER_S *f, int flg)
+{
+ GF_INIT(f, f->next);
+
+ if(flg == GF_DATA){
+ register unsigned char c;
+ register int state = f->f1;
+ register int first = f->f2;
+
+ while(GF_GETC(f, c)){
+
+ if(first){ /* write initial prefix!! */
+ first = 0; /* but just once */
+ GF_PREFIX_WRITE((char *) f->opt);
+ }
+
+ /*
+ * State == 0 is the starting state and the usual state.
+ * State == 1 means we saw a CR and haven't acted on it yet.
+ * We are looking for a LF to get the CRLF end of line.
+ * However, we also treat bare CR and bare LF as if they
+ * were CRLF sequences. What else could it mean in text?
+ * This filter is only used for text so that is probably
+ * a reasonable interpretation of the bad input.
+ */
+ if(c == '\015'){ /* CR */
+ if(state){ /* Treat pending CR as endofline, */
+ GF_PUTC(f->next, '\015'); /* and remain in saw-a-CR state. */
+ GF_PUTC(f->next, '\012');
+ GF_PREFIX_WRITE((char *) f->opt);
+ }
+ else{
+ state = 1;
+ }
+ }
+ else if(c == '\012'){ /* LF */
+ GF_PUTC(f->next, '\015'); /* Got either a CRLF or a bare LF, */
+ GF_PUTC(f->next, '\012'); /* treat both as if a CRLF. */
+ GF_PREFIX_WRITE((char *) f->opt);
+ state = 0;
+ }
+ else{ /* any other character */
+ if(state){
+ GF_PUTC(f->next, '\015'); /* Treat pending CR as endofline. */
+ GF_PUTC(f->next, '\012');
+ GF_PREFIX_WRITE((char *) f->opt);
+ state = 0;
+ }
+
+ GF_PUTC(f->next, c);
+ }
+ }
+
+ f->f1 = state; /* save state for next chunk of data */
+ f->f2 = first;
+ GF_END(f, f->next);
+ }
+ else if(flg == GF_EOD){
+ (void) GF_FLUSH(f->next);
+ (*f->next->f)(f->next, GF_EOD);
+ }
+ else if(flg == GF_RESET){
+ dprint((9, "-- gf_reset prefix\n"));
+ f->f1 = 0;
+ f->f2 = 1; /* nothing written yet */
+ }
+}
+
+
+/*
+ * function called from the outside to set
+ * prefix filter's prefix string
+ */
+void *
+gf_prefix_opt(char *prefix)
+{
+ return((void *) prefix);
+}
+
+
+/*
+ * LINE TEST FILTER - accumulate lines and offer each to the provided
+ * test function.
+ */
+
+typedef struct _linetest_s {
+ linetest_t f;
+ void *local;
+} LINETEST_S;
+
+
+/* accumulator growth increment */
+#define LINE_TEST_BLOCK 1024
+
+#define GF_LINE_TEST_EOB(f) \
+ ((f)->line + ((f)->f2 - 1))
+
+#define GF_LINE_TEST_ADD(f, c) \
+ { \
+ if(p >= eobuf){ \
+ f->f2 += LINE_TEST_BLOCK; \
+ fs_resize((void **)&f->line, \
+ (size_t) f->f2 * sizeof(char)); \
+ eobuf = GF_LINE_TEST_EOB(f); \
+ p = eobuf - LINE_TEST_BLOCK; \
+ } \
+ *p++ = c; \
+ }
+
+#define GF_LINE_TEST_TEST(F, D) \
+ { \
+ unsigned char c; \
+ register char *cp; \
+ register int l; \
+ LT_INS_S *ins = NULL, *insp; \
+ *p = '\0'; \
+ (D) = (*((LINETEST_S *) (F)->opt)->f)((F)->n++, \
+ (F)->line, &ins, \
+ ((LINETEST_S *) (F)->opt)->local); \
+ if((D) < 2){ \
+ if((D) < 0){ \
+ if((F)->line) \
+ fs_give((void **) &(F)->line); \
+ if((F)->opt) \
+ fs_give((void **) &(F)->opt); \
+ gf_error(_("translation error")); \
+ /* NO RETURN */ \
+ } \
+ for(insp = ins, cp = (F)->line; cp < p; ){ \
+ if(insp && cp == insp->where){ \
+ if(insp->len > 0){ \
+ for(l = 0; l < insp->len; l++){ \
+ c = (unsigned char) insp->text[l]; \
+ GF_PUTC((F)->next, c); \
+ } \
+ insp = insp->next; \
+ continue; \
+ } else if(insp->len < 0){ \
+ cp -= insp->len; \
+ insp = insp->next; \
+ continue; \
+ } \
+ } \
+ GF_PUTC((F)->next, *cp); \
+ cp++; \
+ } \
+ while(insp){ \
+ for(l = 0; l < insp->len; l++){ \
+ c = (unsigned char) insp->text[l]; \
+ GF_PUTC((F)->next, c); \
+ } \
+ insp = insp->next; \
+ } \
+ gf_line_test_free_ins(&ins); \
+ } \
+ }
+
+
+
+/*
+ * this simple filter accumulates characters until a newline, offers it
+ * to the provided test function, and then passes it on. It assumes
+ * NVT EOLs.
+ */
+void
+gf_line_test(FILTER_S *f, int flg)
+{
+ register char *p = f->linep;
+ register char *eobuf = GF_LINE_TEST_EOB(f);
+ GF_INIT(f, f->next);
+
+ if(flg == GF_DATA){
+ register unsigned char c;
+ register int state = f->f1;
+
+ while(GF_GETC(f, c)){
+
+ if(state){
+ state = 0;
+ if(c == '\012'){
+ int done;
+
+ GF_LINE_TEST_TEST(f, done);
+
+ p = (f)->line;
+
+ if(done == 2) /* skip this line! */
+ continue;
+
+ GF_PUTC(f->next, '\015');
+ GF_PUTC(f->next, '\012');
+ /*
+ * if the line tester returns TRUE, it's
+ * telling us its seen enough and doesn't
+ * want to see any more. Remove ourself
+ * from the pipeline...
+ */
+ if(done){
+ if(gf_master == f){
+ gf_master = f->next;
+ }
+ else{
+ FILTER_S *fprev;
+
+ for(fprev = gf_master;
+ fprev && fprev->next != f;
+ fprev = fprev->next)
+ ;
+
+ if(fprev) /* wha??? */
+ fprev->next = f->next;
+ else
+ continue;
+ }
+
+ while(GF_GETC(f, c)) /* pass input */
+ GF_PUTC(f->next, c);
+
+ (void) GF_FLUSH(f->next); /* and drain queue */
+ fs_give((void **)&f->line);
+ fs_give((void **)&f); /* wax our data */
+ return;
+ }
+ else
+ continue;
+ }
+ else /* add CR to buffer */
+ GF_LINE_TEST_ADD(f, '\015');
+ } /* fall thru to handle 'c' */
+
+ if(c == '\015') /* newline? */
+ state = 1;
+ else
+ GF_LINE_TEST_ADD(f, c);
+ }
+
+ f->f1 = state;
+ GF_END(f, f->next);
+ }
+ else if(flg == GF_EOD){
+ int i;
+
+ GF_LINE_TEST_TEST(f, i); /* examine remaining data */
+ fs_give((void **) &f->line); /* free line buffer */
+ fs_give((void **) &f->opt); /* free test struct */
+ (void) GF_FLUSH(f->next);
+ (*f->next->f)(f->next, GF_EOD);
+ }
+ else if(flg == GF_RESET){
+ dprint((9, "-- gf_reset line_test\n"));
+ f->f1 = 0; /* state */
+ f->n = 0L; /* line number */
+ f->f2 = LINE_TEST_BLOCK; /* size of alloc'd line */
+ f->line = p = (char *) fs_get(f->f2 * sizeof(char));
+ }
+
+ f->linep = p;
+}
+
+
+/*
+ * function called from the outside to operate on accumulated line.
+ */
+void *
+gf_line_test_opt(linetest_t test_f, void *local)
+{
+ LINETEST_S *ltp;
+
+ ltp = (LINETEST_S *) fs_get(sizeof(LINETEST_S));
+ memset(ltp, 0, sizeof(LINETEST_S));
+ ltp->f = test_f;
+ ltp->local = local;
+ return((void *) ltp);
+}
+
+
+
+LT_INS_S **
+gf_line_test_new_ins(LT_INS_S **ins, char *p, char *s, int n)
+{
+ *ins = (LT_INS_S *) fs_get(sizeof(LT_INS_S));
+ if(((*ins)->len = n) > 0)
+ strncpy((*ins)->text = (char *) fs_get(n * sizeof(char)), s, n);
+ else
+ (*ins)->text = NULL;
+
+ (*ins)->where = p;
+ (*ins)->next = NULL;
+ return(&(*ins)->next);
+}
+
+
+void
+gf_line_test_free_ins(LT_INS_S **ins)
+{
+ if(ins && *ins){
+ if((*ins)->next)
+ gf_line_test_free_ins(&(*ins)->next);
+
+ if((*ins)->text)
+ fs_give((void **) &(*ins)->text);
+
+ fs_give((void **) ins);
+ }
+}
+
+
+/*
+ * PREPEND EDITORIAL FILTER - conditionally prepend output text
+ * with editorial comment
+ */
+
+typedef struct _preped_s {
+ prepedtest_t f;
+ char *text;
+} PREPED_S;
+
+
+/*
+ * gf_prepend_editorial - accumulate filtered text and prepend its
+ * output with given text
+ *
+ *
+ */
+void
+gf_prepend_editorial(FILTER_S *f, int flg)
+{
+ GF_INIT(f, f->next);
+
+ if(flg == GF_DATA){
+ register unsigned char c;
+
+ while(GF_GETC(f, c)){
+ so_writec(c, (STORE_S *) f->data);
+ }
+
+ GF_END(f, f->next);
+ }
+ else if(flg == GF_EOD){
+ unsigned char c;
+
+ if(!((PREPED_S *)(f)->opt)->f || (*((PREPED_S *)(f)->opt)->f)()){
+ char *p = ((PREPED_S *)(f)->opt)->text;
+
+ for( ; p && *p; p++)
+ GF_PUTC(f->next, *p);
+ }
+
+ so_seek((STORE_S *) f->data, 0L, 0);
+ while(so_readc(&c, (STORE_S *) f->data)){
+ GF_PUTC(f->next, c);
+ }
+
+ so_give((STORE_S **) &f->data);
+ fs_give((void **) &f->opt);
+ (void) GF_FLUSH(f->next);
+ (*f->next->f)(f->next, GF_EOD);
+ }
+ else if(flg == GF_RESET){
+ dprint((9, "-- gf_reset line_test\n"));
+ f->data = (void *) so_get(CharStar, NULL, EDIT_ACCESS);
+ }
+}
+
+
+/*
+ * function called from the outside to setup prepending editorial
+ * to output text
+ */
+void *
+gf_prepend_editorial_opt(prepedtest_t test_f, char *text)
+{
+ PREPED_S *pep;
+
+ pep = (PREPED_S *) fs_get(sizeof(PREPED_S));
+ memset(pep, 0, sizeof(PREPED_S));
+ pep->f = test_f;
+ pep->text = text;
+ return((void *) pep);
+}
+
+
+/*
+ * Network virtual terminal to local newline convention filter
+ */
+void
+gf_nvtnl_local(FILTER_S *f, int flg)
+{
+ GF_INIT(f, f->next);
+
+ if(flg == GF_DATA){
+ register unsigned char c;
+ register int state = f->f1;
+
+ while(GF_GETC(f, c)){
+ if(state){
+ state = 0;
+ if(c == '\012'){
+ GF_PUTC(f->next, '\012');
+ continue;
+ }
+ else
+ GF_PUTC(f->next, '\015');
+ /* fall thru to deal with 'c' */
+ }
+
+ if(c == '\015')
+ state = 1;
+ else
+ GF_PUTC(f->next, c);
+ }
+
+ f->f1 = state;
+ GF_END(f, f->next);
+ }
+ else if(flg == GF_EOD){
+ (void) GF_FLUSH(f->next);
+ (*f->next->f)(f->next, GF_EOD);
+ }
+ else if(flg == GF_RESET){
+ dprint((9, "-- gf_reset nvtnl_local\n"));
+ f->f1 = 0;
+ }
+}
+
+
+/*
+ * local to network newline convention filter
+ */
+void
+gf_local_nvtnl(FILTER_S *f, int flg)
+{
+ GF_INIT(f, f->next);
+
+ if(flg == GF_DATA){
+ register unsigned char c;
+
+ while(GF_GETC(f, c)){
+ if(c == '\012'){
+ GF_PUTC(f->next, '\015');
+ GF_PUTC(f->next, '\012');
+ }
+ else
+ GF_PUTC(f->next, c);
+ }
+
+ GF_END(f, f->next);
+ }
+ else if(flg == GF_EOD){
+ (void) GF_FLUSH(f->next);
+ (*f->next->f)(f->next, GF_EOD);
+ }
+ else if(GF_RESET){
+ dprint((9, "-- gf_reset local_nvtnl\n"));
+ /* no op */
+ }
+
+}
generated by cgit v1.2.3-54-g00ecf (git 2.44.0) at 2024-06-16 19:22:07 +0000