head	1.25;
access;
symbols;
locks
	shettich:1.25; strict;
comment	@ * @;


1.25
date	95.12.06.20.59.41;	author jromine;	state Exp;
branches;
next	1.24;

1.24
date	93.08.20.15.48.14;	author jromine;	state Exp;
branches;
next	1.23;

1.23
date	93.06.12.06.46.16;	author jromine;	state Exp;
branches;
next	1.22;

1.22
date	93.02.26.21.56.37;	author jromine;	state Exp;
branches;
next	1.21;

1.21
date	92.12.15.00.20.22;	author jromine;	state Exp;
branches;
next	1.20;

1.20
date	92.11.24.18.06.01;	author jromine;	state Exp;
branches;
next	1.19;

1.19
date	92.11.09.17.53.13;	author jromine;	state Exp;
branches;
next	1.18;

1.18
date	92.11.05.17.02.34;	author jromine;	state Exp;
branches;
next	1.17;

1.17
date	92.10.26.22.49.45;	author jromine;	state Exp;
branches;
next	1.16;

1.16
date	92.02.09.07.11.55;	author jromine;	state Exp;
branches;
next	1.15;

1.15
date	92.01.31.21.49.21;	author jromine;	state Exp;
branches;
next	1.14;

1.14
date	92.01.24.18.09.25;	author jromine;	state Exp;
branches;
next	1.13;

1.13
date	92.01.23.23.10.58;	author jromine;	state Exp;
branches;
next	1.12;

1.12
date	91.01.09.22.34.45;	author mh;	state Exp;
branches;
next	1.11;

1.11
date	90.12.27.17.19.03;	author mh;	state Exp;
branches;
next	1.10;

1.10
date	90.04.05.15.30.45;	author sources;	state Exp;
branches;
next	1.9;

1.9
date	90.04.05.14.44.48;	author sources;	state Exp;
branches;
next	1.8;

1.8
date	90.03.23.15.16.29;	author sources;	state Exp;
branches;
next	1.7;

1.7
date	90.03.23.14.38.52;	author sources;	state Exp;
branches;
next	1.6;

1.6
date	90.03.13.15.41.41;	author sources;	state Exp;
branches;
next	1.5;

1.5
date	90.02.21.16.03.22;	author sources;	state Exp;
branches;
next	1.4;

1.4
date	90.02.21.15.58.58;	author sources;	state Exp;
branches;
next	1.3;

1.3
date	90.02.06.16.34.54;	author sources;	state Exp;
branches;
next	1.2;

1.2
date	90.02.06.13.02.35;	author sources;	state Exp;
branches;
next	1.1;

1.1
date	90.01.30.10.44.13;	author sources;	state Exp;
branches;
next	;


desc
@@


1.25
log
@x.400 fixes from mtr
@
text
@/* formatsbr.c - format string interpretation */
#ifndef	lint
static char ident[] = "@@(#)$Id: formatsbr.c,v 1.24 1993/08/20 15:48:14 jromine Exp jromine $";
#endif	/* lint */

#include "../h/mh.h"
#include "../h/addrsbr.h"
#include "../h/formatsbr.h"
#include "../zotnet/tws.h"
#include "../h/fmtcompile.h"
#include <ctype.h>
#include <stdio.h>
#include <sys/types.h>
#include <sys/stat.h>

/*  */


#define	NFMTS	MAXARGS
#define QUOTE '\\'

static char  *formats = 0;
extern char *formataddr ();	/* hook for custom address formatting */
#ifdef	LBL
struct msgs *fmt_current_folder; /* current folder (set by main program) */
#endif

static normalize();
static int   get_x400_comp();

extern int fmt_norm;		/* defined in sbr/formatdef.c = AD_NAME */
struct mailname fmt_mnull;


long	time ();

/*  */

/* MAJOR HACK:	See MHCHANGES for discussion */

char  *new_fs (form, format, def)
register char  *form,
               *format,
               *def;
{
    struct stat st;
    register    FILE *fp;

    if (formats)
	free (formats);

    if (form) {
	if ((fp = fopen (libpath (form), "r")) == NULL)
	    adios (form, "unable to open format file");

	if (fstat (fileno (fp), &st) == NOTOK)
	    adios (form, "unable to stat format file");

	if ((formats = malloc ((unsigned) st.st_size + 1)) == NULLCP)
	    adios (form, "unable to allocate space for format");

	if (read (fileno(fp), formats, (int) st.st_size) != st.st_size)
	    adios (form, "error reading format file");

	formats[st.st_size] = '\0';

	(void) fclose (fp);
    }
    else {
	formats = getcpy (format ? format : def);
    }

    normalize (formats);

    return formats;
}

/*  */

static  normalize (cp)
register char  *cp;
{
    register char  *dp;

    for (dp = cp; *cp; cp++)
	if (*cp != QUOTE)
	    *dp++ = *cp;
	else
	    switch (*++cp) {
#define	grot(y,z) case y: *dp++ = z; break;
		grot ('b', '\b');
		grot ('f', '\f');
		grot ('n', '\n');
		grot ('r', '\r');
		grot ('t', '\t');

		case '\n':
		    break;

		case 0: 
		    cp--;	/* fall */
		default: 
		    *dp++ = *cp;
		    break;
	    }

    *dp = 0;
}

/*  */
/*
 * test if string "sub" appears anywhere in string "str"
 * (case insensitive).
 */

static int match (str, sub)
register char  *str,
               *sub;
{
    register int    c1;
    register int    c2;
    register char   *s1;
    register char   *s2;

#ifdef LOCALE
    while (c1 = *sub) {
	c1 = (isalpha(c1) && isupper(c1)) ? tolower(c1) : c1;
	while ((c2 = *str++) && c1 != ((isalpha(c2) && isupper(c2)) ? tolower(c2) : c2))
	    ;
	if (! c2)
	    return 0;
	s1 = sub + 1; s2 = str;
	while ((c1 = *s1++) && ((isalpha(c1) && isupper(c1)) ? tolower(c1) : c1) == ((isalpha(c2 =*s2++) && isupper(c2)) ? tolower(c2) : c2))
	    ;
	if (! c1)
	    return 1;
    }
#else
    while (c1 = *sub) {
	while ((c2 = *str++) && (c1 | 040) != (c2 | 040))
	    ;
	if (! c2)
	    return 0;
	s1 = sub + 1; s2 = str;
	while ((c1 = *s1++) && (c1 | 040) == (*s2++ | 040))
	    ;
	if (! c1)
	    return 1;
    }
#endif
    return 1;
}
/*  */

/* macros to format data */

#define PUTDF(cp, num, wid, fill) if (cp + wid < ep){\
		if((i = (num))<0) i = -(num);\
		if((c = (wid))<0) c = -c;\
		sp = cp + c;\
		do {\
		    *--sp = (i % 10) + '0';\
		    i /= 10;\
		} while (i > 0 && sp > cp);\
		if (i > 0)\
		    *sp = '?';\
		else if ((num) < 0 && sp > cp)\
		    *--sp = '-';\
		while (sp > cp)\
		    *--sp = fill;\
		cp += c;\
		}
#define PUTD(cp, num) if (cp < ep){\
		if((i = (num))==0) *cp++ = '0';\
		else {\
		    if((i = (num))<0) \
			*cp++ = '-', i = -(num);\
		    c = 10;\
		    while (c <= i) \
			c *= 10;\
		    while (cp < ep && c > 1) {\
			c /= 10;\
			*cp++ = (i / c) + '0';\
			i %= c;\
			}\
		    }\
		}
#ifdef LOCALE
#define PUTSF(cp, str, wid, fill) {\
		ljust = 0;\
		if ((i = (wid)) < 0) {\
			i = -i;\
			ljust++;\
		}\
		if (sp = (str)) {\
			if (ljust) {\
				c = strlen(sp);\
				if (c > i)\
					sp += c - i;\
				else {\
					while( --i >= c && cp < ep)\
						*cp++ = fill;\
					i++;\
				}\
			} else {\
			    while ((c = *sp) && (iscntrl(c) || isspace(c)))\
				sp++;\
			}\
			while ((c = *sp++) && --i >= 0 && cp < ep)\
				if (isgraph(c)) \
				    *cp++ = c;\
				else {\
					while ((c = *sp) && (iscntrl(c) || isspace(c)))\
						sp++;\
					    *cp++ = ' ';\
				}\
		}\
		if (!ljust)\
		while( --i >= 0 && cp < ep)\
		    *cp++ = fill;\
	}
#define PUTS(cp, str) {\
		if (sp = (str)) {\
		    while ((c = *sp) && (iscntrl(c) || isspace(c)))\
			sp++;\
		    while((c = *sp++) && cp < ep)\
			if (isgraph(c)) \
			    *cp++ = c;\
			else {\
			    while ((c = *sp) && (iscntrl(c) || isspace(c)))\
				sp++;\
			    *cp++ = ' ';\
			}\
		}\
	}
#else /* LOCALE */
#define PUTSF(cp, str, wid, fill) {\
		ljust = 0;\
		if ((i = (wid)) < 0) {\
			i = -i;\
			ljust++;\
		}\
		if (sp = (str)) {\
			if (ljust) {\
				c = strlen(sp);\
				if (c > i)\
					sp += c - i;\
				else {\
					while( --i >= c && cp < ep)\
						*cp++ = fill;\
					i++;\
				}\
			} else {\
		    while ((c = *sp) && c <= 32)\
			sp++;\
			}\
			while ((c = *sp++) && --i >= 0 && cp < ep)\
				if (c > 32) \
			    *cp++ = c;\
			else {\
					while ((c = *sp) && c <= 32)\
				sp++;\
			    *cp++ = ' ';\
			}\
		}\
		if (!ljust)\
		while( --i >= 0 && cp < ep)\
		    *cp++ = fill;\
		}
#define PUTS(cp, str) {\
		if (sp = (str)) {\
		    while ((c = *sp) && c <= 32)\
			sp++;\
		    while( (c = *sp++) && cp < ep)\
			if ( c > 32 ) \
			    *cp++ = c;\
			else {\
			    while ( (c = *sp) && c <= 32 )\
				sp++;\
			    *cp++ = ' ';\
			}\
		}\
		}
#endif


static char *lmonth[] = { "January",  "February","March",   "April",
			  "May",      "June",    "July",    "August",
			  "September","October", "November","December" };

static char *get_x400_friendly (mbox, buffer)
char   *mbox,
       *buffer;
{
    char    given[BUFSIZ],
	    surname[BUFSIZ];

    if (mbox == NULLCP)
	return NULLCP;
    if (*mbox == '"')
	mbox++;
    if (*mbox != '/')
	return NULLCP;

    if (get_x400_comp (mbox, "/PN=", buffer)) {
	for (mbox = buffer; mbox = index (mbox, '.'); )
	    *mbox++ = ' ';

	return buffer;
    }

    if (!get_x400_comp (mbox, "/S=", surname))
	return NULLCP;

    if (get_x400_comp (mbox, "/G=", given))
	(void) sprintf (buffer, "%s %s", given, surname);
    else
	(void) strcpy (buffer, surname);

    return buffer;
}

static int get_x400_comp (mbox, key, buffer)
char   *mbox,
       *key,
       *buffer;
{
    int	    idx;
    char   *cp;

    if ((idx = stringdex (key, mbox)) < 0
	    || !(cp = index (mbox += idx + strlen (key), '/')))
	return 0;

    (void) sprintf (buffer, "%*.*s", cp - mbox, cp - mbox, mbox);
    return 1;
}

struct format *
fmtscan (format, scanl, width, dat)
	struct format *format;
	char	*scanl;
	int	width;
	int	dat[];
{
    register char	*cp = scanl;
    register char	*ep = scanl + width - 1;
    register struct format *fmt = format;
    register char	*str = NULLCP;
    register int	value = 0;
    register char	*sp;
    register int	i;
    register int	c;
    register struct comp *comp;
    register struct tws *tws;
    register struct mailname *mn;
    int ljust;
    long l;
    char        *savestr;
    char	buffer[BUFSIZ];

    while (cp < ep) {
	switch (fmt->f_type) {

	case FT_COMP:
	    PUTS (cp, fmt->f_comp->c_text);
	    break;
	case FT_COMPF:
	    PUTSF (cp, fmt->f_comp->c_text, fmt->f_width, fmt->f_fill);
	    break;

	case FT_LIT:
	    sp = fmt->f_text;
	    while( (c = *sp++) && cp < ep)
		*cp++ = c;
	    break;
	case FT_LITF:
	    sp = fmt->f_text;
	    ljust = 0;
	    i = fmt->f_width;
	    if (i < 0) {
		i = -i;
		ljust++;		/* XXX should do something with this */
	    }
	    while( (c = *sp++) && --i >= 0 && cp < ep)
		*cp++ = c;
	    while( --i >= 0 && cp < ep)
		*cp++ = fmt->f_fill;
	    break;

	case FT_STR:
	    PUTS (cp, str);
	    break;
	case FT_STRF:
	    PUTSF (cp, str, fmt->f_width, fmt->f_fill);
	    break;
	case FT_STRFW:
	    adios (NULLCP, "internal error (FT_STRFW)");

	case FT_NUM:
	    PUTD (cp, value);
	    break;
	case FT_NUMF:
	    PUTDF (cp, value, fmt->f_width, fmt->f_fill);
	    break;

	case FT_CHAR:
	    *cp++ = fmt->f_char;
	    break;

	case FT_DONE:
	    goto finished;

	case FT_IF_S:
	    if (!(value = (str && *str))) {
		fmt += fmt->f_skip;
		continue;
	    }
	    break;

	case FT_IF_S_NULL:
	    if (!(value = (str == NULLCP || *str == 0))) {
		fmt += fmt->f_skip;
		continue;
	    }
	    break;

	case FT_IF_V_EQ:
	    if (value != fmt->f_value) {
		fmt += fmt->f_skip;
		continue;
	    }
	    break;

	case FT_IF_V_NE:
	    if (value == fmt->f_value) {
		fmt += fmt->f_skip;
		continue;
	    }
	    break;

	case FT_IF_V_GT:
	    if (value <= fmt->f_value) {
		fmt += fmt->f_skip;
		continue;
	    }
	    break;

	case FT_IF_MATCH:
	    if (!(value = (str && match (str, fmt->f_text)))) {
		fmt += fmt->f_skip;
		continue;
	    }
	    break;

	case FT_V_MATCH:
	    if (str)
		value = match (str, fmt->f_text);
	    else
		value = 0;
	    break;

	case FT_IF_AMATCH:
	    if (!(value = (str && uprf (str, fmt->f_text)))) {
		fmt += fmt->f_skip;
		continue;
	    }
	    break;

	case FT_V_AMATCH:
	    value = uprf (str, fmt->f_text);
	    break;

	case FT_S_NONNULL:
	    value = (str != NULLCP && *str != 0);
	    break;

	case FT_S_NULL:
	    value = (str == NULLCP || *str == 0);
	    break;

	case FT_V_EQ:
	    value = (fmt->f_value == value);
	    break;

	case FT_V_NE:
	    value = (fmt->f_value != value);
	    break;

	case FT_V_GT:
	    value = (fmt->f_value > value);
	    break;

	case FT_GOTO:
	    fmt += fmt->f_skip;
	    continue;

	case FT_NOP:
	    break;

	case FT_LS_COMP:
	    str = fmt->f_comp->c_text;
	    break;
	case FT_LS_LIT:
	    str = fmt->f_text;
	    break;
	case FT_LS_GETENV:
	    if (!(str = getenv (fmt->f_text)))
		str = "";
	    break;
	case FT_LS_MFIND:
	    if (!(str = m_find (fmt->f_text)))
		str = "";
	    break;
	case FT_LS_TRIM:
	    if (str) {
		    register char *xp;

		    (void) strcpy(buffer, str);
		    str = buffer;
		    while (isspace(*str))
			    str++;
		    ljust = 0;
		    if ((i = fmt->f_width) < 0) {
			    i = -i;
			    ljust++;
		    }

		    if (!ljust && i > 0 && strlen(str) > i)
			    str[i] = '\0';
		    xp = str;
		    xp += strlen(str) - 1;
		    while (xp > str && isspace(*xp))
			    *xp-- = '\0';
		    if (ljust && i > 0 && strlen(str) > i)
			str += strlen(str) - i;
	    }
	    break;

	case FT_LV_COMPFLAG:
	    value = fmt->f_comp->c_flags;
	    break;
	case FT_LV_COMP:
	    value = (comp = fmt->f_comp)->c_text ? atoi(comp->c_text) : 0;
	    break;
	case FT_LV_LIT:
	    value = fmt->f_value;
	    break;
	case FT_LV_DAT:
	    value = dat[fmt->f_value];
	    break;
	case FT_LV_STRLEN:
	    value = strlen(str);
	    break;
	case FT_LV_CHAR_LEFT:
	    value = width - (cp - scanl);
	    break;
	case FT_LV_PLUS_L:
	    value += fmt->f_value;
	    break;
	case FT_LV_MINUS_L:
	    value = fmt->f_value - value;
	    break;
	case FT_LV_DIVIDE_L:
	    if (fmt->f_value)
		value = value / fmt->f_value;
	    else
		value = 0;
	    break;
	case FT_LV_MODULO_L:
	    if (fmt->f_value)
		value = value % fmt->f_value;
	    else
		value = 0;
	    break;
	case FT_SAVESTR:
	    savestr = str;
	    break;

	case FT_LV_SEC:
	    value = fmt->f_comp->c_tws->tw_sec;
	    break;
	case FT_LV_MIN:
	    value = fmt->f_comp->c_tws->tw_min;
	    break;
	case FT_LV_HOUR:
	    value = fmt->f_comp->c_tws->tw_hour;
	    break;
	case FT_LV_MDAY:
	    value = fmt->f_comp->c_tws->tw_mday;
	    break;
	case FT_LV_MON:
	    value = fmt->f_comp->c_tws->tw_mon + 1;
	    break;
	case FT_LS_MONTH:
	    str = tw_moty[fmt->f_comp->c_tws->tw_mon];
	    break;
	case FT_LS_LMONTH:
	    str = lmonth[fmt->f_comp->c_tws->tw_mon];
	    break;
	case FT_LS_ZONE:
	    str = dtwszone (fmt->f_comp->c_tws);
	    break;
	case FT_LV_YEAR:
#ifndef	YEARMOD
	    value = fmt->f_comp->c_tws->tw_year;
#else	/* YEARMOD */
	    value = (fmt->f_comp->c_tws->tw_year) % 100;
#endif	/* YEARMOD */
	    break;
	case FT_LV_WDAY:
	    if (!(((tws = fmt->f_comp->c_tws)->tw_flags) & (TW_SEXP|TW_SIMP)))
		set_dotw (tws);
	    value = tws->tw_wday;
	    break;
	case FT_LS_DAY:
	    if (!(((tws = fmt->f_comp->c_tws)->tw_flags) & (TW_SEXP|TW_SIMP)))
		set_dotw (tws);
	    str = tw_dotw[tws->tw_wday];
	    break;
	case FT_LS_WEEKDAY:
	    if (!(((tws = fmt->f_comp->c_tws)->tw_flags) & (TW_SEXP|TW_SIMP)))
		set_dotw (tws);
	    str = tw_ldotw[tws->tw_wday];
	    break;
	case FT_LV_YDAY:
	    value = fmt->f_comp->c_tws->tw_yday;
	    break;
	case FT_LV_ZONE:
	    value = fmt->f_comp->c_tws->tw_zone;
	    break;
	case FT_LV_CLOCK:
	    if ((value = fmt->f_comp->c_tws->tw_clock) == 0)
		value = twclock(fmt->f_comp->c_tws);
	    break;
	case FT_LV_RCLOCK:
	    if ((value = fmt->f_comp->c_tws->tw_clock) == 0)
		value = twclock(fmt->f_comp->c_tws);
	    value = time((long *) 0) - value;
	    break;
	case FT_LV_DAYF:
	    if (!(((tws = fmt->f_comp->c_tws)->tw_flags) & (TW_SEXP|TW_SIMP)))
		set_dotw (tws);
	    switch (fmt->f_comp->c_tws->tw_flags & TW_SDAY) {
		case TW_SEXP:
		    value = 1; break;
		case TW_SIMP:
		    value = 0; break;
		default:
		    value = -1; break;
	    }
	case FT_LV_ZONEF:
	    if ((fmt->f_comp->c_tws->tw_flags & TW_SZONE) == TW_SZEXP)
		    value = 1;
	    else
		    value = -1;
	    break;
	case FT_LV_DST:
	    value = fmt->f_comp->c_tws->tw_flags & TW_DST;
	    break;
	case FT_LS_822DATE:
	    str = dasctime ( fmt->f_comp->c_tws , TW_ZONE);
	    break;
	case FT_LS_PRETTY:
	    str = dasctime ( fmt->f_comp->c_tws, TW_NULL);
	    break;

	case FT_LS_PERS:
	    str = fmt->f_comp->c_mn->m_pers;
	    break;
	case FT_LS_MBOX:
	    str = fmt->f_comp->c_mn->m_mbox;
	    break;
	case FT_LS_HOST:
	    str = fmt->f_comp->c_mn->m_host;
	    break;
	case FT_LS_PATH:
	    str = fmt->f_comp->c_mn->m_path;
	    break;
	case FT_LS_GNAME:
	    str = fmt->f_comp->c_mn->m_gname;
	    break;
	case FT_LS_NOTE:
	    str = fmt->f_comp->c_mn->m_note;
	    break;
	case FT_LS_822ADDR:
	    str = adrformat( fmt->f_comp->c_mn );
	    break;
	case FT_LV_HOSTTYPE:
	    value = fmt->f_comp->c_mn->m_type;
	    break;
	case FT_LV_INGRPF:
	    value = fmt->f_comp->c_mn->m_ingrp;
	    break;
	case FT_LV_NOHOSTF:
	    value = fmt->f_comp->c_mn->m_nohost;
	    break;
	case FT_LS_ADDR:
	case FT_LS_FRIENDLY:
#ifdef BERK
	    str = fmt->f_comp->c_mn->m_mbox;
#else	/* not BERK */
	    if ((mn = fmt -> f_comp -> c_mn) == &fmt_mnull) {
		str = fmt -> f_comp -> c_text;
		break;
	    }
	    if (fmt -> f_type == FT_LS_ADDR)
		goto unfriendly;
	    if (!(str = mn -> m_pers)
		    && (!(str = get_x400_friendly (mn -> m_mbox, buffer)))) {
		if (str = mn -> m_note) {
		    (void) strcpy (buffer, str);
		    str = buffer;
		    if (*str == '(')
			str++;
		    sp = str + strlen (str) - 1;
		    if (*sp == ')') {
			*sp-- = '\0';
			while (sp >= str)
			    if (*sp == ' ')
				*sp-- = '\0';
			    else
				break;
		    }
		    if (*str)
			break;
		}	    

unfriendly: ;
		switch (mn -> m_type) {
		    case LOCALHOST:
		        str = mn -> m_mbox;
			break;
		    case UUCPHOST:
			(void) sprintf (str = buffer, "%s!%s",
					mn -> m_host, mn -> m_mbox);
			break;
		    default:
			if (mn -> m_mbox)
			    (void) sprintf (str= buffer, "%s@@%s", mn -> m_mbox,
					    mn -> m_host);
			else
			    str = mn -> m_text;
			break;
		}
	    }
#endif	/* BERK */
	    break;

	case FT_LOCALDATE:
	    comp = fmt->f_comp;
	    if ((l = comp->c_tws->tw_clock) == 0)
		l = twclock(comp->c_tws);
	    tws = dlocaltime(&l);
	    *comp->c_tws = *tws;
	    break;

	case FT_GMTDATE:
	    comp = fmt->f_comp;
	    if ((l = comp->c_tws->tw_clock) == 0)
		l = twclock(comp->c_tws);
	    tws = dgmtime(&l);
	    *comp->c_tws = *tws;
	    break;

	case FT_PARSEDATE:
	    comp = fmt->f_comp;
	    if ((sp = comp->c_text) && (tws = dparsetime(sp))) {
		*comp->c_tws = *tws;
		comp->c_flags = 0;
	    } else if (comp->c_flags >= 0) {
		bzero ((char *) comp -> c_tws, sizeof *comp -> c_tws);
		comp->c_flags = 1;
	    }
	    break;

	case FT_FORMATADDR:
	    /* hook for custom address list formatting (see replsbr.c) */
	    str = formataddr (savestr, str);
	    break;

	case FT_PUTADDR:
	    /* output the str register as an address component,
	     * splitting it into multiple lines if necessary.  The
	     * value reg. contains the max line length.  The lit.
	     * field may contain a string to prepend to the result
	     * (e.g., "To: ")
	     */
	    {
	    register char *lp = str;
	    register int indent;
	    register int wid = value;
	    register int len = strlen (str);
	    register char *lastb;

	    sp = fmt->f_text;
	    indent = strlen (sp);
	    wid -= indent;
	    while( (c = *sp++) && cp < ep)
		*cp++ = c;
	    while (len > wid) {
		/* try to break at a comma; failing that, break at a
		 * space, failing that, just split the line.
		 */
		lastb = 0; sp = lp + wid;
		while (sp > lp && (c = *--sp) != ',') {
		    if (! lastb && isspace(c))
			lastb = sp - 1;
		}
		if (sp == lp)
		    if (! (sp = lastb))
			sp = lp + wid - 1;
		len -= sp - lp + 1;
		while (cp < ep && lp <= sp)
		    *cp++ = *lp++;
		*cp++ = '\n';
		for (i=indent; cp < ep && i > 0; i--)
		    *cp++ = ' ';
		while (isspace(*lp))
		    lp++, len--;
	    }
	    PUTS (cp, lp);
	    }
	    break;

	case FT_PARSEADDR:
	    comp = fmt->f_comp;
	    if (comp->c_mn != &fmt_mnull)
		mnfree (comp->c_mn);
	    if ((sp = comp->c_text) && (sp = getname(sp)) &&
		(mn = getm (sp, NULLCP, 0, fmt_norm, NULLCP))) {
		comp->c_mn = mn;
		while (getname(""))
		    ;
	    } else {
		while (getname(""))		/* XXX */
		    ;
		comp->c_mn = &fmt_mnull;
	    }
	    break;
	    
	case FT_MYMBOX:
	    /*
	     * if there's no component, we say true.  Otherwise we
	     * say "true" only if we can parse the address and it
	     * matches one of our addresses.
	     */
	    comp = fmt->f_comp;
	    if (comp->c_mn != &fmt_mnull)
		mnfree (comp->c_mn);
	    if ((sp = comp->c_text) && (sp = getname(sp)) &&
		(mn = getm (sp, NULLCP, 0, AD_NAME, NULLCP))) {
		comp->c_mn = mn;
		comp->c_flags = ismymbox(mn);
		while (sp = getname(sp))
		    if (comp->c_flags == 0 &&
			(mn = getm (sp, NULLCP, 0, AD_NAME, NULLCP)))
			comp->c_flags |= ismymbox(mn);
	    } else {
		while (getname(""))		/* XXX */
		    ;
		comp->c_flags = (comp->c_text == 0);
		comp->c_mn = &fmt_mnull;
	    }
	    break;

	case FT_ADDTOSEQ:
#ifdef	LBL
	    /* If we're working on a folder (as opposed to a file), add the
	     * current msg to sequence given in literal field.  Don't
	     * disturb string or value registers.
	     */
	    if (fmt_current_folder)
		    (void)m_seqadd(fmt_current_folder, fmt->f_text, dat[0], -1);
#endif
	    break;
	}
	fmt++;
    }
#ifndef JLR
    finished:;
    if (cp[-1] != '\n')
	*cp++ = '\n';
    *cp   = 0;
    return ((struct format *)0);
#else	/* JLR */
    if (cp[-1] != '\n')
	*cp++ = '\n';
    while (fmt->f_type != FT_DONE)
	fmt++;

    finished:;    
    *cp = '\0';
    return (fmt -> f_value ? ++fmt : (struct format *)0);

#endif /* JLR */
}
@


1.24
log
@small patch to make funny X.400 addresses look better  /mtr
@
text
@d3 1
a3 1
static char ident[] = "@@(#)$Id: formatsbr.c,v 1.23 1993/06/12 06:46:16 jromine Exp jromine $";
d709 22
a730 18
	    if ((str = mn -> m_pers) == NULL)
	        if ((str = mn -> m_note)) {
	            (void) strcpy (buffer, str);
	            str = buffer;
	            if (*str == '(')
	            	str++;
	            sp = str + strlen(str) - 1;
	            if (*sp == ')') {
	            	*sp-- = '\0';
	        	while (sp >= str)
	            	    if (*sp == ' ')
	            		*sp-- = '\0';
	            	    else
	            		break;
	            }
	        } else if (!(str = get_x400_friendly (mn -> m_mbox, buffer))) {
	unfriendly: ;
		  switch (mn -> m_type) {
d732 1
a732 1
			str = mn -> m_mbox;
d735 1
a735 1
			(void) sprintf (buffer, "%s!%s",
a736 1
			str = buffer;
d739 3
a741 5
			if (mn -> m_mbox) {
			    (void) sprintf (buffer, "%s@@%s",
					    mn -> m_mbox, mn -> m_host);
			    str= buffer;
			}
a744 1
		  }
d746 1
@


1.23
log
@add %(profile xxx) to return m_find(xxx)
@
text
@d3 1
a3 1
static char ident[] = "@@(#)$Id: formatsbr.c,v 1.22 1993/02/26 21:56:37 jromine Exp jromine $";
d307 1
a307 1
	    *mbox++ = 0;
@


1.22
log
@386BSD/BSD44
@
text
@d3 1
a3 1
static char ident[] = "@@(#)$Id: formatsbr.c,v 1.21 1992/12/15 00:20:22 jromine Exp jromine $";
d509 4
@


1.21
log
@endif sugar
@
text
@d3 1
a3 1
static char ident[] = "@@(#)$Id: formatsbr.c,v 1.20 1992/11/24 18:06:01 jromine Exp jromine $";
d62 1
a62 1
	if (read (fileno(fp), formats, st.st_size) != st.st_size)
@


1.20
log
@add decl
@
text
@d3 2
a4 2
static char ident[] = "@@(#)$Id: formatsbr.c,v 1.19 1992/11/09 17:53:13 jromine Exp jromine $";
#endif	lint
d698 1
a698 1
#else not BERK
d742 1
a742 1
#endif BERK
@


1.19
log
@add YEARMOD to force 2-digit years
@
text
@d3 1
a3 1
static char ident[] = "@@(#)$Id: formatsbr.c,v 1.18 1992/11/05 17:02:34 jromine Exp jromine $";
d29 1
@


1.18
log
@try to be friendly with x400 rfc987 addresses
@
text
@d3 1
a3 1
static char ident[] = "@@(#)$Id: formatsbr.c,v 1.17 1992/10/26 22:49:45 jromine Exp jromine $";
d600 1
d602 3
@


1.17
log
@LOCALE
@
text
@d3 1
a3 1
static char ident[] = "@@(#)$Id: formatsbr.c,v 1.16 1992/02/09 07:11:55 jromine Exp jromine $";
d290 6
d297 41
d715 1
a715 1
	        } else {
@


1.16
log
@put Van Jacobson "addtoseq" option under "options LBL"
make sure combined "if"s set value (for later testing)
add modulo function
@
text
@d3 1
a3 1
static char ident[] = "@@(#)$Id: formatsbr.c,v 1.15 1992/01/31 21:49:21 jromine Exp $";
d124 1
d126 13
d149 1
d187 1
d205 48
d283 1
@


1.15
log
@kerberos
@
text
@d3 1
a3 1
static char ident[] = "@@(#)$Id: formatsbr.c,v 1.14 1992/01/24 18:09:25 jromine Exp jromine $";
d24 1
a24 1
#ifdef	VAN
d302 1
a302 1
	    if (str == NULLCP || *str == 0) {
d309 1
a309 1
	    if (str != NULLCP && *str != 0) {
d337 1
a337 1
	    if (!str || !match (str, fmt->f_text)) {
d345 1
a345 1
	    value = match (str, fmt->f_text);
d351 1
a351 1
	    if (!str || !uprf (str, fmt->f_text)) {
d453 6
a744 1
#ifdef	VAN
d746 1
d753 1
a754 1
#endif
@


1.14
log
@move fmt_norm to formatdef.c for shared libs
@
text
@d3 1
a3 1
static char ident[] = "@@(#)$Id: formatsbr.c,v 1.13 1992/01/23 23:10:58 jromine Exp jromine $";
d99 1
a99 1
		case NULL: 
d106 1
a106 1
    *dp = NULL;
d302 1
a302 1
	    if (str == NULLCP || *str == NULL) {
d309 1
a309 1
	    if (str != NULLCP && *str != NULL) {
d362 1
a362 1
	    value = (str != NULLCP && *str != NULL);
d366 1
a366 1
	    value = (str == NULLCP || *str == NULL);
d756 1
a756 1
    *cp   = NULL;
@


1.13
log
@new formatsbr changes under JLR
@
text
@d3 1
a3 1
static char ident[] = "@@(#)$Id: formatsbr.c,v 1.12 1991/01/09 22:34:45 mh Exp jromine $";
d30 1
a30 1
int	fmt_norm = AD_NAME;
@


1.12
log
@allow %-n(trim) to right-justify and length limit
jlr
@
text
@d3 1
a3 1
static char ident[] = "@@(#)$Id: formatsbr.c,v 1.11 90/12/27 17:19:03 mh Exp Locker: mh $";
d226 1
d394 4
d752 1
d757 12
a768 1
    return (value);
@


1.11
log
@add "addr" address format.
jlr
@
text
@d3 1
a3 1
static char ident[] = "@@(#)$Id: formatsbr.c,v 1.10 90/04/05 15:30:45 sources Exp Locker: mh $";
d404 1
a404 1
			    ljust++;	/* XXX should do something with this */
d407 1
a407 1
		    if (i > 0 && strlen(str) > i)
d413 2
@


1.10
log
@add ID
@
text
@d3 1
a3 1
static char ident[] = "@@(#)$Id:$";
d564 1
d573 2
d590 3
a592 2
	        } else
		switch (mn -> m_type) {
d610 1
@


1.9
log
@add ID
@
text
@d3 1
a3 1
static char ident[] = "$Id:";
@


1.8
log
@remove JLR ifdef around fix
@
text
@d2 3
@


1.7
log
@make friendly just return text if unparseable
@
text
@a692 1
#ifdef	JLR
a694 1
#endif	JLR
a716 1
#ifdef	JLR
a718 1
#endif	JLR
@


1.6
log
@horrible fix for bad address parsing
@
text
@d565 4
a568 1
	    mn = fmt -> f_comp -> c_mn;
@


1.5
log
@Fixes from Van Jacobson
@
text
@d689 5
a693 1
	    } else
d695 1
d716 4
@


1.4
log
@checkpoint
@
text
@d134 1
a201 1

d223 1
a223 1
fmtscan(format, scanl, width, dat)
d525 1
a525 1
	    str = dasctime(fmt->f_comp->c_tws, TW_ZONE);
d528 1
a528 1
	    str = dasctime(fmt->f_comp->c_tws, TW_NULL);
d716 1
d725 1
@


1.3
log
@make "friendly" more friendly -- it'll pick up "(full name)" now.
@
text
@d21 3
a133 1
/*  */
d139 2
a140 1
		sp = cp + wid;\
d151 1
a151 1
		cp += wid;\
d169 5
a173 1
		i = (wid);\
d175 10
d187 3
a189 2
		    while( (c = *sp++) && --i >= 0 && cp < ep)\
			if ( c > 32 ) \
d192 1
a192 1
			    while ( (c = *sp) && c <= 32 )\
d197 1
d201 1
d223 1
a223 1
fmtscan (format, scanl, width, dat)
d240 2
d245 1
a245 1
    for (;;) {
d261 7
a267 1
	    sp = fmt->f_text; i = fmt->f_width;
d333 1
a333 1
	    if (! match (str, fmt->f_text)) {
d340 1
d342 2
d347 1
a347 1
	    if (! uprf (str, fmt->f_text)) {
d390 3
d394 19
d437 6
d515 5
d521 1
a521 1
	case FT_LV_TZONEF:
d525 1
a525 1
	    str = dasctime ( fmt->f_comp->c_tws , TW_ZONE);
d528 1
a528 1
	    str = dasctime ( fmt->f_comp->c_tws, TW_NULL);
d604 16
d706 4
a709 2
		while (getname(""))
		    ;
d714 9
@


1.2
log
@ANSI Compilance
@
text
@d503 15
@


1.1
log
@Initial revision
@
text
@d22 2
d83 6
a88 6
#define	grot(x)	case 'x': *dp++ = '\x'; break;
		    grot (b);
		    grot (f);
		    grot (n);
		    grot (r);
		    grot (t);
@