[unix-history] / usr / contrib / rn / rcln.c

/* $Header: rcln.c,v 4.3.1.2 85/07/23 17:39:08 lwall Exp $
 *
 * $Log:	rcln.c,v $
 * Revision 4.3.1.2  85/07/23  17:39:08  lwall
 * Oops, was freeing a static buf on -c in checkexpired.
 * 
 * Revision 4.3.1.1  85/05/10  11:37:08  lwall
 * Branch for patches.
 * 
 * Revision 4.3  85/05/01  11:45:36  lwall
 * Baseline for release with 4.3bsd.
 * 
 */

#include "EXTERN.h"
#include "common.h"
#include "util.h"
#include "rcstuff.h"
#include "ngdata.h"
#include "INTERN.h"
#include "rcln.h"

void
rcln_init()
{
    ;
}

#ifdef CATCHUP
void
catch_up(ngx)
NG_NUM ngx;
{
    char tmpbuf[128];
    
#ifdef VERBOSE
    IF(verbose)
	printf("\nMarking %s as all read.\n",rcline[ngx]) FLUSH;
    ELSE
#endif
#ifdef TERSE
	fputs("\nMarked read\n",stdout) FLUSH;
#endif
    sprintf(tmpbuf,"%s: 1-%ld", rcline[ngx],(long)getngsize(ngx));
    free(rcline[ngx]);
    rcline[ngx] = savestr(tmpbuf);
    *(rcline[ngx] + rcnums[ngx] - 1) = '\0';
    write_rc();
}
#endif

/* add an article number to a newsgroup, if it isn't already read */

int
addartnum(artnum,ngnam)
ART_NUM artnum;
char *ngnam;
{
    register NG_NUM ngnum = find_ng(ngnam);
    register char *s, *t, *maxt = Nullch;
    ART_NUM min = 0, max = -1, lastnum = 0;
    char *mbuf;
    bool morenum;

    if (!artnum)
	return 0;
    if (ngnum == nextrcline || !rcnums[ngnum])
					/* not found in newsrc? */
	return 0;
#ifdef CACHEFIRST
    if (!abs1st[ngnum])
#else
    if (!toread[ngnum])
#endif
					/* now is a good time to trim down */
	set_toread(ngnum);		/* the list due to expires if we */
					/* have not yet. */
#ifdef DEBUGGING
    if (artnum > ngmax[ngnum] + 10	/* allow for incoming articles */
       ) {
	printf("\nCorrupt Xref line!!!  %ld --> %s(1..%ld)\n",
	    artnum,ngnam,
	    ngmax[ngnum]) FLUSH;
	paranoid = TRUE;		/* paranoia reigns supreme */
	return -1;			/* hope this was the first newsgroup */
    }
#endif

    if (toread[ngnum] == TR_BOGUS)
	return 0;
#ifdef DEBUGGING
    if (debug & DEB_XREF_MARKER) {
	printf("%ld->\n%s%c%s\n",(long)artnum,rcline[ngnum],rcchar[ngnum],
	  rcline[ngnum] + rcnums[ngnum]) FLUSH;
    }
#endif
    s = rcline[ngnum] + rcnums[ngnum];
    while (*s == ' ') s++;		/* skip spaces */
    t = s;
    while (isdigit(*s) && artnum >= (min = atol(s))) {
					/* while it might have been read */
	for (t = s; isdigit(*t); t++) ;	/* skip number */
	if (*t == '-') {		/* is it a range? */
	    t++;			/* skip to next number */
	    if (artnum <= (max = atol(t)))
		return 0;		/* it is in range => already read */
	    lastnum = max;		/* remember it */
	    maxt = t;			/* remember position in case we */
					/* want to overwrite the max */
	    while (isdigit(*t)) t++;	/* skip second number */
	}
	else {
	    if (artnum == min)		/* explicitly a read article? */
		return 0;
	    lastnum = min;		/* remember what the number was */
	    maxt = Nullch;		/* last one was not a range */
	}
	while (*t && !isdigit(*t)) t++;	/* skip comma and any spaces */
	s = t;
    }
    
    /* we have not read it, so insert the article number before s */
    
    morenum = isdigit(*s);		/* will it need a comma after? */
    *(rcline[ngnum] + rcnums[ngnum] - 1) = rcchar[ngnum];
    mbuf = safemalloc((MEM_SIZE)(strlen(s) + (s-rcline[ngnum]) + 8));
    strcpy(mbuf,rcline[ngnum]);		/* make new rc line */
    if (maxt && lastnum && artnum == lastnum+1)
    					/* can we just extend last range? */
	t = mbuf + (maxt-rcline[ngnum]);/* then overwrite previous max */
    else {
	t = mbuf + (t-rcline[ngnum]);	/* point t into new line instead */
	if (lastnum) {			/* have we parsed any line? */
	    if (!morenum)		/* are we adding to the tail? */
		*t++ = ',';		/* supply comma before */
	    if (!maxt && artnum == lastnum+1 && *(t-1) == ',')
					/* adjacent singletons? */
		*(t-1) = '-';		/* turn them into a range */
	}
    }
    if (morenum) {			/* is there more to life? */
	if (min == artnum+1) {		/* can we consolidate further? */
	    bool range_before = (*(t-1) == '-');
	    bool range_after;
	    char *nextmax;

	    for (nextmax = s; isdigit(*nextmax); nextmax++) ;
	    range_after = *nextmax++ == '-';
	    
	    if (range_before)
		*t = '\0';		/* artnum is redundant */
	    else
		sprintf(t,"%ld-",(long)artnum);/* artnum will be new min */
	    
	    if (range_after)
		s = nextmax;		/* *s is redundant */
	/*  else
		s = s */		/* *s is new max */
	}
	else
	    sprintf(t,"%ld,",(long)artnum);	/* put the number and comma */
    }
    else
	sprintf(t,"%ld",(long)artnum);	/* put the number there (wherever) */
    strcat(t,s);			/* copy remainder of line */
#ifdef DEBUGGING
    if (debug & DEB_XREF_MARKER) {
	printf("%s\n",mbuf) FLUSH;
    }
#endif
    free(rcline[ngnum]);
    rcline[ngnum] = mbuf;		/* pull the switcheroo */
    *(rcline[ngnum] + rcnums[ngnum] - 1) = '\0';
					/* wipe out : or ! */
    if (toread[ngnum] > TR_NONE)	/* lest we turn unsub into bogus */
	--toread[ngnum];
    return 0;
}

#ifdef MCHASE
/* delete an article number from a newsgroup, if it is there */

void
subartnum(artnum,ngnam)
register ART_NUM artnum;
char *ngnam;
{
    register NG_NUM ngnum = find_ng(ngnam);
    register char *s, *t;
    register ART_NUM min, max;
    char *mbuf;
    int curlen;

    if (!artnum)
	return;
    if (ngnum == nextrcline || !rcnums[ngnum])
	return;				/* not found in newsrc? */
#ifdef DEBUGGING
    if (debug & DEB_XREF_MARKER) {
	printf("%ld<-\n%s%c%s\n",(long)artnum,rcline[ngnum],rcchar[ngnum],
	  rcline[ngnum] + rcnums[ngnum]) FLUSH;
    }
#endif
    s = rcline[ngnum] + rcnums[ngnum];
    while (*s == ' ') s++;		/* skip spaces */
    
    /* a little optimization, since it is almost always the last number */
    
    for (t=s; *t; t++) ;		/* find end of string */
    curlen = t-rcline[ngnum];
    for (t--; isdigit(*t); t--) ;	/* find previous delim */
    if (*t == ',' && atol(t+1) == artnum) {
	*t = '\0';
	if (toread[ngnum] >= TR_NONE)
	    ++toread[ngnum];
#ifdef DEBUGGING
	if (debug & DEB_XREF_MARKER)
	    printf("%s%c %s\n",rcline[ngnum],rcchar[ngnum],s) FLUSH;
#endif
	return;
    }

    /* not the last number, oh well, we may need the length anyway */

    while (isdigit(*s) && artnum >= (min = atol(s))) {
					/* while it might have been read */
	for (t = s; isdigit(*t); t++) ;	/* skip number */
	if (*t == '-') {		/* is it a range? */
	    t++;			/* skip to next number */
	    max = atol(t);
	    while (isdigit(*t)) t++;	/* skip second number */
	    if (artnum <= max) {
					/* it is in range => already read */
		if (artnum == min) {
		    min++;
		    artnum = 0;
		}
		else if (artnum == max) {
		    max--;
		    artnum = 0;
		}
		*(rcline[ngnum] + rcnums[ngnum] - 1) = rcchar[ngnum];
		mbuf = safemalloc((MEM_SIZE)(curlen + (artnum?15:2)));
		*s = '\0';
		strcpy(mbuf,rcline[ngnum]);	/* make new rc line */
		s = mbuf + (s-rcline[ngnum]);
					/* point s into mbuf now */
		if (artnum) {		/* split into two ranges? */
		    prange(s,min,artnum-1);
		    s += strlen(s);
		    *s++ = ',';
		    prange(s,artnum+1,max);
		}
		else			/* only one range */
		    prange(s,min,max);
		s += strlen(s);
		strcpy(s,t);		/* copy remainder over */
#ifdef DEBUGGING
		if (debug & DEB_XREF_MARKER) {
		    printf("%s\n",mbuf) FLUSH;
		}
#endif
		free(rcline[ngnum]);
		rcline[ngnum] = mbuf;	/* pull the switcheroo */
		*(rcline[ngnum] + rcnums[ngnum] - 1) = '\0';
					/* wipe out : or ! */
		if (toread[ngnum] >= TR_NONE)
		    ++toread[ngnum];
		return;
	    }
	}
	else {
	    if (artnum == min) {	/* explicitly a read article? */
		if (*t == ',')		/* pick a comma, any comma */
		    t++;
		else if (s[-1] == ',')
		    s--;
		else if (s[-2] == ',')	/* (in case of space) */
		    s -= 2;
		strcpy(s,t);		/* no need to realloc */
		if (toread[ngnum] >= TR_NONE)
		    ++toread[ngnum];
#ifdef DEBUGGING
		if (debug & DEB_XREF_MARKER) {
		    printf("%s%c%s\n",rcline[ngnum],rcchar[ngnum],
		      rcline[ngnum] + rcnums[ngnum]) FLUSH;
		}
#endif
		return;
	    }
	}
	while (*t && !isdigit(*t)) t++;	/* skip comma and any spaces */
	s = t;
    }
}

void
prange(where,min,max)
char *where;
ART_NUM min,max;
{
    if (min == max)
	sprintf(where,"%ld",(long)min);
    else
	sprintf(where,"%ld-%ld",(long)min,(long)max);
}
#endif

/* calculate the number of unread articles for a newsgroup */

void
set_toread(ngnum)
register NG_NUM ngnum;
{
    register char *s, *c, *h;
    char tmpbuf[64], *mybuf = tmpbuf;
    char *nums;
    int length;
#ifdef CACHEFIRST
    bool virgin_ng = (!abs1st[ngnum]);
#endif
    ART_NUM ngsize = getngsize(ngnum);
    ART_NUM unread = ngsize;
    ART_NUM newmax;

#ifdef DEBUGGING
    ngmax[ngnum] = ngsize;		/* for checking out-of-range Xrefs */
#endif
    if (ngsize == TR_BOGUS) {
	printf("Warning!  Bogus newsgroup: %s\n",rcline[ngnum]) FLUSH;
	paranoid = TRUE;
	toread[ngnum] = TR_BOGUS;
	return;
    }
#ifdef CACHEFIRST
    if (virgin_ng)
#else
    if (!toread[ngnum])
#endif
    {
	sprintf(tmpbuf," 1-%ld",(long)ngsize);
	if (strNE(tmpbuf,rcline[ngnum]+rcnums[ngnum]))
	    checkexpired(ngnum,ngsize);	/* this might realloc rcline */
    }
    nums = rcline[ngnum]+rcnums[ngnum];
    length = strlen(nums);
    if (length >= 60)
	mybuf = safemalloc((MEM_SIZE)(length+5));
    strcpy(mybuf,nums);
    mybuf[length++] = ',';
    mybuf[length] = '\0';
    for (s = mybuf; isspace(*s); s++)
	    ;
    for ( ; (c = index(s,',')) != Nullch ; s = ++c) {
				    /* for each range */
	*c = '\0';			/* keep index from running off */
	if ((h = index(s,'-')) != Nullch)	/* find - in range, if any */
	    unread -= (newmax = atol(h+1)) - atol(s) + 1;
	else if (newmax = atol(s))
	    unread--;		/* recalculate length */
	if (newmax > ngsize) {	/* paranoia check */
	    unread = -1;
	    break;
	}
    }
    if (unread >= 0)		/* reasonable number? */
	toread[ngnum] = (ART_UNREAD)unread;
					/* remember how many are left */
    else {				/* SOMEONE RESET THE NEWSGROUP!!! */
	toread[ngnum] = (ART_UNREAD)ngsize;
					/* assume nothing carried over */
	printf("Warning!  Somebody reset %s--assuming nothing read.\n",
	    rcline[ngnum]) FLUSH;
	*(rcline[ngnum] + rcnums[ngnum]) = '\0';
	paranoid = TRUE;		/* enough to make a guy paranoid */
    }
    if (mybuf != tmpbuf)
	free(mybuf);
    if (rcchar[ngnum] == NEGCHAR)
	toread[ngnum] = TR_UNSUB;
}

/* make sure expired articles are marked as read */

void
checkexpired(ngnum,ngsize)
register NG_NUM ngnum;
ART_NUM ngsize;
{
    register ART_NUM a1st = getabsfirst(ngnum,ngsize);
    register char *s, *t;
    register ART_NUM num, lastnum = 0;
    char *mbuf, *newnum;

    if (a1st<=1)
	return;
#ifdef DEBUGGING
    if (debug & DEB_XREF_MARKER) {
	printf("1-%ld->\n%s%c%s\n",(long)(a1st-1),rcline[ngnum],rcchar[ngnum],
	  rcline[ngnum] + rcnums[ngnum]) FLUSH;
    }
#endif
    for (s = rcline[ngnum] + rcnums[ngnum]; isspace(*s); s++);
    while (*s && (num = atol(s)) <= a1st) {
	while (isdigit(*s)) s++;
	while (*s && !isdigit(*s)) s++;
	lastnum = num;
    }
    if (*s) {
	if (s[-1] == '-') {			/* landed in a range? */
	    if (lastnum != 1)
		sprintf(rcline[ngnum]+rcnums[ngnum]," 1-%s",s);
	    goto ret;
	}
    }
    /* s now points to what should follow first range */
    if (s - rcline[ngnum] > rcnums[ngnum] + 10) 
	mbuf = rcline[ngnum];
    else {
	mbuf = safemalloc((MEM_SIZE)(rcnums[ngnum] + strlen(s) + 10));
	strcpy(mbuf,rcline[ngnum]);
    }
    newnum = t = mbuf+rcnums[ngnum];
    sprintf(t," 1-%ld",(long)(a1st - (lastnum != a1st)));
    if (*s) {
	t += strlen(t);
	*t++ = ',';
	strcpy(t,s);
    }
    if (mbuf == rcline[ngnum]) {
	rcline[ngnum] = saferealloc(rcline[ngnum],
	    (MEM_SIZE)(rcnums[ngnum] + strlen(newnum) + 1));
    }
    else {
	if (!checkflag)
	    free(rcline[ngnum]);
	rcline[ngnum] = mbuf;
    }

ret:;		/* semicolon in case DEBUGGING undefined */
#ifdef DEBUGGING
    if (debug & DEB_XREF_MARKER) {
	printf("%s%c%s\n",rcline[ngnum],rcchar[ngnum],
	  rcline[ngnum] + rcnums[ngnum]) FLUSH;
    }
#endif
}
Commit	Line	Data
aa875b17 C	1	/* $Header: rcln.c,v 4.3.1.2 85/07/23 17:39:08 lwall Exp $
	2	*
	3	* $Log: rcln.c,v $
	4	* Revision 4.3.1.2 85/07/23 17:39:08 lwall
	5	* Oops, was freeing a static buf on -c in checkexpired.
	6	*
	7	* Revision 4.3.1.1 85/05/10 11:37:08 lwall
	8	* Branch for patches.
	9	*
	10	* Revision 4.3 85/05/01 11:45:36 lwall
	11	* Baseline for release with 4.3bsd.
	12	*
	13	*/
	14
	15	#include "EXTERN.h"
	16	#include "common.h"
	17	#include "util.h"
	18	#include "rcstuff.h"
	19	#include "ngdata.h"
	20	#include "INTERN.h"
	21	#include "rcln.h"
	22
	23	void
	24	rcln_init()
	25	{
	26	;
	27	}
	28
	29	#ifdef CATCHUP
	30	void
	31	catch_up(ngx)
	32	NG_NUM ngx;
	33	{
	34	char tmpbuf[128];
	35
	36	#ifdef VERBOSE
	37	IF(verbose)
	38	printf("\nMarking %s as all read.\n",rcline[ngx]) FLUSH;
	39	ELSE
	40	#endif
	41	#ifdef TERSE
	42	fputs("\nMarked read\n",stdout) FLUSH;
	43	#endif
	44	sprintf(tmpbuf,"%s: 1-%ld", rcline[ngx],(long)getngsize(ngx));
	45	free(rcline[ngx]);
	46	rcline[ngx] = savestr(tmpbuf);
	47	*(rcline[ngx] + rcnums[ngx] - 1) = '\0';
	48	write_rc();
	49	}
	50	#endif
	51
	52	/* add an article number to a newsgroup, if it isn't already read */
	53
	54	int
	55	addartnum(artnum,ngnam)
	56	ART_NUM artnum;
	57	char *ngnam;
	58	{
	59	register NG_NUM ngnum = find_ng(ngnam);
	60	register char s, t, *maxt = Nullch;
	61	ART_NUM min = 0, max = -1, lastnum = 0;
	62	char *mbuf;
	63	bool morenum;
	64
65	if (!artnum)
66	return 0;
67	if (ngnum == nextrcline \|\| !rcnums[ngnum])
68	/* not found in newsrc? */
69	return 0;
70	#ifdef CACHEFIRST
71	if (!abs1st[ngnum])
72	#else
73	if (!toread[ngnum])
74	#endif
75	/* now is a good time to trim down */
76	set_toread(ngnum); /* the list due to expires if we */
77	/* have not yet. */
78	#ifdef DEBUGGING
79	if (artnum > ngmax[ngnum] + 10 /* allow for incoming articles */
80	) {
81	printf("\nCorrupt Xref line!!! %ld --> %s(1..%ld)\n",
82	artnum,ngnam,
83	ngmax[ngnum]) FLUSH;
84	paranoid = TRUE; /* paranoia reigns supreme */
85	return -1; /* hope this was the first newsgroup */
86	}
87	#endif
88
89	if (toread[ngnum] == TR_BOGUS)
90	return 0;
91	#ifdef DEBUGGING
92	if (debug & DEB_XREF_MARKER) {
93	printf("%ld->\n%s%c%s\n",(long)artnum,rcline[ngnum],rcchar[ngnum],
94	rcline[ngnum] + rcnums[ngnum]) FLUSH;
95	}
96	#endif
97	s = rcline[ngnum] + rcnums[ngnum];
98	while (s == ' ') s++; / skip spaces */
99	t = s;
100	while (isdigit(*s) && artnum >= (min = atol(s))) {
101	/* while it might have been read */
102	for (t = s; isdigit(t); t++) ; / skip number */
103	if (t == '-') { / is it a range? */
104	t++; /* skip to next number */
105	if (artnum <= (max = atol(t)))
106	return 0; /* it is in range => already read */
107	lastnum = max; /* remember it */
108	maxt = t; /* remember position in case we */
109	/* want to overwrite the max */
110	while (isdigit(t)) t++; / skip second number */
111	}
112	else {
113	if (artnum == min) /* explicitly a read article? */
114	return 0;
115	lastnum = min; /* remember what the number was */
116	maxt = Nullch; /* last one was not a range */
117	}
118	while (t && !isdigit(t)) t++; /* skip comma and any spaces */
119	s = t;
120	}
121
122	/* we have not read it, so insert the article number before s */
123
124	morenum = isdigit(s); / will it need a comma after? */
125	*(rcline[ngnum] + rcnums[ngnum] - 1) = rcchar[ngnum];
126	mbuf = safemalloc((MEM_SIZE)(strlen(s) + (s-rcline[ngnum]) + 8));
127	strcpy(mbuf,rcline[ngnum]); /* make new rc line */
128	if (maxt && lastnum && artnum == lastnum+1)
129	/* can we just extend last range? */
130	t = mbuf + (maxt-rcline[ngnum]);/* then overwrite previous max */
131	else {
132	t = mbuf + (t-rcline[ngnum]); /* point t into new line instead */
133	if (lastnum) { /* have we parsed any line? */
134	if (!morenum) /* are we adding to the tail? */
135	t++ = ','; / supply comma before */
136	if (!maxt && artnum == lastnum+1 && *(t-1) == ',')
137	/* adjacent singletons? */
138	(t-1) = '-'; / turn them into a range */
139	}
140	}
141	if (morenum) { /* is there more to life? */
142	if (min == artnum+1) { /* can we consolidate further? */
143	bool range_before = (*(t-1) == '-');
144	bool range_after;
145	char *nextmax;
146
147	for (nextmax = s; isdigit(*nextmax); nextmax++) ;
148	range_after = *nextmax++ == '-';
149
150	if (range_before)
151	t = '\0'; / artnum is redundant */
152	else
153	sprintf(t,"%ld-",(long)artnum);/* artnum will be new min */
154
155	if (range_after)
156	s = nextmax; /* s is redundant /
157	/* else
158	s = s / / s is new max /
159	}
160	else
161	sprintf(t,"%ld,",(long)artnum); /* put the number and comma */
162	}
163	else
164	sprintf(t,"%ld",(long)artnum); /* put the number there (wherever) */
165	strcat(t,s); /* copy remainder of line */
166	#ifdef DEBUGGING
167	if (debug & DEB_XREF_MARKER) {
168	printf("%s\n",mbuf) FLUSH;
169	}
170	#endif
171	free(rcline[ngnum]);
172	rcline[ngnum] = mbuf; /* pull the switcheroo */
173	*(rcline[ngnum] + rcnums[ngnum] - 1) = '\0';
174	/* wipe out : or ! */
175	if (toread[ngnum] > TR_NONE) /* lest we turn unsub into bogus */
176	--toread[ngnum];
177	return 0;
178	}
179
180	#ifdef MCHASE
181	/* delete an article number from a newsgroup, if it is there */
182
183	void
184	subartnum(artnum,ngnam)
185	register ART_NUM artnum;
186	char *ngnam;
187	{
188	register NG_NUM ngnum = find_ng(ngnam);
189	register char s, t;
190	register ART_NUM min, max;
191	char *mbuf;
192	int curlen;
193
194	if (!artnum)
195	return;
196	if (ngnum == nextrcline \|\| !rcnums[ngnum])
197	return; /* not found in newsrc? */
198	#ifdef DEBUGGING
199	if (debug & DEB_XREF_MARKER) {
200	printf("%ld<-\n%s%c%s\n",(long)artnum,rcline[ngnum],rcchar[ngnum],
201	rcline[ngnum] + rcnums[ngnum]) FLUSH;
202	}
203	#endif
204	s = rcline[ngnum] + rcnums[ngnum];
205	while (s == ' ') s++; / skip spaces */
206
207	/* a little optimization, since it is almost always the last number */
208
209	for (t=s; t; t++) ; / find end of string */
210	curlen = t-rcline[ngnum];
211	for (t--; isdigit(t); t--) ; / find previous delim */
212	if (*t == ',' && atol(t+1) == artnum) {
213	*t = '\0';
214	if (toread[ngnum] >= TR_NONE)
215	++toread[ngnum];
216	#ifdef DEBUGGING
217	if (debug & DEB_XREF_MARKER)
218	printf("%s%c %s\n",rcline[ngnum],rcchar[ngnum],s) FLUSH;
219	#endif
220	return;
221	}
222
223	/* not the last number, oh well, we may need the length anyway */
224
225	while (isdigit(*s) && artnum >= (min = atol(s))) {
226	/* while it might have been read */
227	for (t = s; isdigit(t); t++) ; / skip number */
228	if (t == '-') { / is it a range? */
229	t++; /* skip to next number */
230	max = atol(t);
231	while (isdigit(t)) t++; / skip second number */
232	if (artnum <= max) {
233	/* it is in range => already read */
234	if (artnum == min) {
235	min++;
236	artnum = 0;
237	}
238	else if (artnum == max) {
239	max--;
240	artnum = 0;
241	}
242	*(rcline[ngnum] + rcnums[ngnum] - 1) = rcchar[ngnum];
243	mbuf = safemalloc((MEM_SIZE)(curlen + (artnum?15:2)));
244	*s = '\0';
245	strcpy(mbuf,rcline[ngnum]); /* make new rc line */
246	s = mbuf + (s-rcline[ngnum]);
247	/* point s into mbuf now */
248	if (artnum) { /* split into two ranges? */
249	prange(s,min,artnum-1);
250	s += strlen(s);
251	*s++ = ',';
252	prange(s,artnum+1,max);
253	}
254	else /* only one range */
255	prange(s,min,max);
256	s += strlen(s);
257	strcpy(s,t); /* copy remainder over */
258	#ifdef DEBUGGING
259	if (debug & DEB_XREF_MARKER) {
260	printf("%s\n",mbuf) FLUSH;
261	}
262	#endif
263	free(rcline[ngnum]);
264	rcline[ngnum] = mbuf; /* pull the switcheroo */
265	*(rcline[ngnum] + rcnums[ngnum] - 1) = '\0';
266	/* wipe out : or ! */
267	if (toread[ngnum] >= TR_NONE)
268	++toread[ngnum];
269	return;
270	}
271	}
272	else {
273	if (artnum == min) { /* explicitly a read article? */
274	if (t == ',') / pick a comma, any comma */
275	t++;
276	else if (s[-1] == ',')
277	s--;
278	else if (s[-2] == ',') /* (in case of space) */
279	s -= 2;
280	strcpy(s,t); /* no need to realloc */
281	if (toread[ngnum] >= TR_NONE)
282	++toread[ngnum];
283	#ifdef DEBUGGING
284	if (debug & DEB_XREF_MARKER) {
285	printf("%s%c%s\n",rcline[ngnum],rcchar[ngnum],
286	rcline[ngnum] + rcnums[ngnum]) FLUSH;
287	}
288	#endif
289	return;
290	}
291	}
292	while (t && !isdigit(t)) t++; /* skip comma and any spaces */
293	s = t;
294	}
295	}
296
297	void
298	prange(where,min,max)
299	char *where;
300	ART_NUM min,max;
301	{
302	if (min == max)
303	sprintf(where,"%ld",(long)min);
304	else
305	sprintf(where,"%ld-%ld",(long)min,(long)max);
306	}
307	#endif
308
309	/* calculate the number of unread articles for a newsgroup */
310
311	void
312	set_toread(ngnum)
313	register NG_NUM ngnum;
314	{
315	register char s, c, *h;
316	char tmpbuf[64], *mybuf = tmpbuf;
317	char *nums;
318	int length;
319	#ifdef CACHEFIRST
320	bool virgin_ng = (!abs1st[ngnum]);
321	#endif
322	ART_NUM ngsize = getngsize(ngnum);
323	ART_NUM unread = ngsize;
324	ART_NUM newmax;
325
326	#ifdef DEBUGGING
327	ngmax[ngnum] = ngsize; /* for checking out-of-range Xrefs */
328	#endif
329	if (ngsize == TR_BOGUS) {
330	printf("Warning! Bogus newsgroup: %s\n",rcline[ngnum]) FLUSH;
331	paranoid = TRUE;
332	toread[ngnum] = TR_BOGUS;
333	return;
334	}
335	#ifdef CACHEFIRST
336	if (virgin_ng)
337	#else
338	if (!toread[ngnum])
339	#endif
340	{
341	sprintf(tmpbuf," 1-%ld",(long)ngsize);
342	if (strNE(tmpbuf,rcline[ngnum]+rcnums[ngnum]))
343	checkexpired(ngnum,ngsize); /* this might realloc rcline */
344	}
345	nums = rcline[ngnum]+rcnums[ngnum];
346	length = strlen(nums);
347	if (length >= 60)
348	mybuf = safemalloc((MEM_SIZE)(length+5));
349	strcpy(mybuf,nums);
350	mybuf[length++] = ',';
351	mybuf[length] = '\0';
352	for (s = mybuf; isspace(*s); s++)
353	;
354	for ( ; (c = index(s,',')) != Nullch ; s = ++c) {
355	/* for each range */
356	c = '\0'; / keep index from running off */
357	if ((h = index(s,'-')) != Nullch) /* find - in range, if any */
358	unread -= (newmax = atol(h+1)) - atol(s) + 1;
359	else if (newmax = atol(s))
360	unread--; /* recalculate length */
361	if (newmax > ngsize) { /* paranoia check */
362	unread = -1;
363	break;
364	}
365	}
366	if (unread >= 0) /* reasonable number? */
367	toread[ngnum] = (ART_UNREAD)unread;
368	/* remember how many are left */
369	else { /* SOMEONE RESET THE NEWSGROUP!!! */
370	toread[ngnum] = (ART_UNREAD)ngsize;
371	/* assume nothing carried over */
372	printf("Warning! Somebody reset %s--assuming nothing read.\n",
373	rcline[ngnum]) FLUSH;
374	*(rcline[ngnum] + rcnums[ngnum]) = '\0';
375	paranoid = TRUE; /* enough to make a guy paranoid */
376	}
377	if (mybuf != tmpbuf)
378	free(mybuf);
379	if (rcchar[ngnum] == NEGCHAR)
380	toread[ngnum] = TR_UNSUB;
381	}
382
383	/* make sure expired articles are marked as read */
384
385	void
386	checkexpired(ngnum,ngsize)
387	register NG_NUM ngnum;
388	ART_NUM ngsize;
389	{
390	register ART_NUM a1st = getabsfirst(ngnum,ngsize);
391	register char s, t;
392	register ART_NUM num, lastnum = 0;
393	char mbuf, newnum;
394
395	if (a1st<=1)
396	return;
397	#ifdef DEBUGGING
398	if (debug & DEB_XREF_MARKER) {
399	printf("1-%ld->\n%s%c%s\n",(long)(a1st-1),rcline[ngnum],rcchar[ngnum],
400	rcline[ngnum] + rcnums[ngnum]) FLUSH;
401	}
402	#endif
403	for (s = rcline[ngnum] + rcnums[ngnum]; isspace(*s); s++);
404	while (*s && (num = atol(s)) <= a1st) {
405	while (isdigit(*s)) s++;
406	while (s && !isdigit(s)) s++;
407	lastnum = num;
408	}
409	if (*s) {
410	if (s[-1] == '-') { /* landed in a range? */
411	if (lastnum != 1)
412	sprintf(rcline[ngnum]+rcnums[ngnum]," 1-%s",s);
413	goto ret;
414	}
415	}
416	/* s now points to what should follow first range */
417	if (s - rcline[ngnum] > rcnums[ngnum] + 10)
418	mbuf = rcline[ngnum];
419	else {
420	mbuf = safemalloc((MEM_SIZE)(rcnums[ngnum] + strlen(s) + 10));
421	strcpy(mbuf,rcline[ngnum]);
422	}
423	newnum = t = mbuf+rcnums[ngnum];
424	sprintf(t," 1-%ld",(long)(a1st - (lastnum != a1st)));
425	if (*s) {
426	t += strlen(t);
427	*t++ = ',';
428	strcpy(t,s);
429	}
430	if (mbuf == rcline[ngnum]) {
431	rcline[ngnum] = saferealloc(rcline[ngnum],
432	(MEM_SIZE)(rcnums[ngnum] + strlen(newnum) + 1));
433	}
434	else {
435	if (!checkflag)
436	free(rcline[ngnum]);
437	rcline[ngnum] = mbuf;
438	}
439
440	ret:; /* semicolon in case DEBUGGING undefined */
441	#ifdef DEBUGGING
442	if (debug & DEB_XREF_MARKER) {
443	printf("%s%c%s\n",rcline[ngnum],rcchar[ngnum],
444	rcline[ngnum] + rcnums[ngnum]) FLUSH;
445	}
446	#endif
447	}
448