[unix-history] / usr / contrib / jove / buf.c

/*************************************************************************
 * This program is copyright (C) 1985, 1986 by Jonathan Payne.  It is    *
 * provided to you without charge for use only on a licensed Unix        *
 * system.  You may copy JOVE provided that this notice is included with *
 * the copy.  You may not sell copies of this program or versions        *
 * modified for use on microcomputer systems, unless the copies are      *
 * included with a Unix system distribution and the source is provided.  *
 *************************************************************************/

/* Contains commands that deal with creating, selecting, killing and
   listing buffers, and buffer modes, and find-file, etc. */

#include "jove.h"

#include <sys/stat.h>

char	*Mainbuf = "Main",
	*NoName = "Sans un nom!";

Buffer	*world = 0,		/* First in the list */
	*curbuf = 0,
	*lastbuf = 0;	/* Last buffer we were in so we have a default
			   buffer during a select buffer. */

/* Toggle BIT in the current buffer's minor mode flags.  If argument is
   supplied, a positive one always turns on the mode and zero argument
   always turns it off. */

TogMinor(bit)
{
	if (exp_p) {
		if (exp == 0)
			curbuf->b_minor &= ~bit;
		else
			curbuf->b_minor |= bit;
	} else
		curbuf->b_minor ^= bit;
	UpdModLine++;
}

/* Creates a new buffer, links it at the end of the buffer chain, and
   returns it. */

static Buffer *
buf_alloc()
{
	register Buffer	*b,
			*lastbp;

	lastbp = 0;
	for (b = world; b != 0; lastbp = b, b = b->b_next)
		;

	b = (Buffer *) emalloc(sizeof (Buffer));
	if (lastbp)
		lastbp->b_next = b;
	else
		world = b;
	b->b_first = 0;
	b->b_next = 0;

	return b;
}

/* Makes a buffer and initializes it.  Obsolete.  Used to take two
   arguments, a buffer name and a file name. */

static Buffer *
mak_buf()
{
	register Buffer	*newb;
	register int	i;

	newb = buf_alloc();
	newb->b_fname = 0;
	newb->b_name = NoName;
	set_ino(newb);
	newb->b_marks = 0;
	newb->b_themark = 0;		/* Index into markring */
	/* No marks yet */
	for (i = 0; i < NMARKS; i++)
		newb->b_markring[i] = 0;
	newb->b_modified = 0;
	newb->b_type = B_FILE;  /* File until proven SCRATCH */
	newb->b_ntbf = 0;
	newb->b_minor = 0;
	newb->b_major = TEXT;
	newb->b_first = 0;
	initlist(newb);
	return newb;
}

ReNamBuf()
{
	register char	*new = 0,
			*prompt = ProcFmt,
			*second = "%s already exists; new name? ";

	for (;;) {
		new = ask((char *) 0, prompt, new);
		if (!buf_exists(new))
			break;
		prompt = second;
	}
	setbname(curbuf, new);
}

FindFile()
{
	register char	*name;
	char	fnamebuf[FILESIZE];

	name = ask_file(curbuf->b_fname, fnamebuf);
	SetABuf(curbuf);
	SetBuf(do_find(curwind, name, 0));
}

static
mkbuflist(bnamp)
register char	**bnamp;
{
	register Buffer	*b;

	for (b = world; b != 0; b = b->b_next)
		if (b->b_name != 0)
			*bnamp++ = b->b_name;
	*bnamp = 0;
}

char *
ask_buf(def)
Buffer	*def;
{
	char	*bnames[100];
	register char	*bname;
	register int	offset;
	char	prompt[100];

	if (def != 0 && def->b_name != 0)
		sprintf(prompt, ": %f (default %s) ", def->b_name);
	else
		sprintf(prompt, ProcFmt);
	mkbuflist(bnames);
	offset = complete(bnames, prompt, RET_STATE);
	if (offset == EOF)
		complain((char *) 0);
	if (offset == ORIGINAL)
		bname = Minibuf;
	else if (offset == NULLSTRING) {
		if (def)
			bname = def->b_name;
		else
			complain((char *) 0);
	} else if (offset < 0)
		complain((char *) 0);
	else
		bname = bnames[offset];

	return bname;
}

BufSelect()
{
	register char	*bname;

	bname = ask_buf(lastbuf);
	SetABuf(curbuf);
	SetBuf(do_select(curwind, bname));
}

static
defb_wind(b)
register Buffer *b;
{
	register Window	*w = fwind;
	char	*alt;

	if (lastbuf == b || lastbuf == 0) {
		lastbuf = 0;
		alt = (b->b_next != 0) ? b->b_next->b_name : Mainbuf;
	} else
		alt = lastbuf->b_name;

	do {
		if (w->w_bufp == b) {
			if (one_windp())
				(void) do_select(w, alt);
			else {
				register Window	*save = w->w_next;

				del_wind(w);
				w = save->w_prev;
			}
		}				
		w = w->w_next;
	} while (w != fwind);
}

Buffer *
getNMbuf()
{
	register Buffer	*delbuf;
	register char	*bname;

	bname = ask_buf(curbuf);
	if ((delbuf = buf_exists(bname)) == 0)
		complain("[No such buffer]");
	if (delbuf->b_modified)
		confirm("%s modified, are you sure? ", bname);
	return delbuf;
}

BufErase()
{
	register Buffer	*delbuf;

	if (delbuf = getNMbuf()) {
		initlist(delbuf);
		delbuf->b_modified = 0;
	}
}

static
kill_buf(delbuf)
register Buffer	*delbuf;
{
	register Buffer	*b,
			*lastb = 0;
	extern Buffer	*perr_buf;

#ifdef IPROCS
	pbuftiedp(delbuf);	/* Make sure buffer is not tied to a process */
#endif
	for (b = world; b != 0; lastb = b, b = b->b_next)
		if (b == delbuf)
			break;
	if (lastb)
		lastb->b_next = delbuf->b_next;
	else
		world = delbuf->b_next;

#define okay_free(ptr)	if (ptr) free(ptr)

	lfreelist(delbuf->b_first);
	okay_free(delbuf->b_name);
	okay_free(delbuf->b_fname);
	free((char *) delbuf);

	if (delbuf == lastbuf)
		SetABuf(curbuf);
	if (perr_buf == delbuf) {
		ErrFree();
		perr_buf = 0;
	}
	defb_wind(delbuf);
	if (curbuf == delbuf)
		SetBuf(curwind->w_bufp);
}

/* offer to kill some buffers */

KillSome()
{
	register Buffer	*b,
			*next;
	Buffer	*oldb;
	register char	*y_or_n;

	for (b = world; b != 0; b = next) {
		next = b->b_next;
		y_or_n = ask("No", "Kill %s? ", b->b_name);
		if (Upper(*y_or_n) != 'Y')
			continue;
		if (IsModified(b)) {
			y_or_n = ask("No", "%s modified; should I save it? ", b->b_name);
			if (Upper(*y_or_n) == 'Y') {
				oldb = curbuf;
				SetBuf(b);
				SaveFile();
				SetBuf(oldb);
			}
		}
		kill_buf(b);
	}
}

BufKill()
{
	Buffer	*b;

	if ((b = getNMbuf()) == 0)
		return;
	kill_buf(b);
}

static char *
line_cnt(b, buf)
register Buffer	*b;
char	*buf;
{
	register int	nlines = 0;
	register Line	*lp;

	for (lp = b->b_first; lp != 0; lp = lp->l_next, nlines++)
		;
	sprintf(buf, "%d", nlines);
	return buf;
}

static char	*TypeNames[] = {
	0,
	"Scratch",
	"File",
	"Process",
	"I-process"
};

BufList()
{
	register char	*format = "%-2s %-5s %-11s %-1s %-*s  %-s";
	register Buffer	*b;
	int	bcount = 1,		/* To give each buffer a number */
		buf_width = 11;
	char	nbuf[10];
	extern int	ModCount;

	for (b = world; b != 0; b = b->b_next)
		buf_width = max(buf_width, strlen(b->b_name));

	TOstart("Buffer list", TRUE);	/* true means auto-newline */

	Typeout("(* means buffer needs saving)");
	Typeout("(+ means file hasn't been read yet)");
	Typeout(NullStr);
	Typeout(format, "NO", "Lines", "Type", NullStr, buf_width, "Name", "File");
	Typeout(format, "--", "-----", "----", NullStr, buf_width, "----", "----");
	for (b = world; b != 0; b = b->b_next) {
		Typeout(format, itoa(bcount++),
				line_cnt(b, nbuf),
				TypeNames[b->b_type],
				IsModified(b) ? "*" :
					 b->b_ntbf ? "+" : NullStr,
				buf_width,
				/* For the * (variable length field) */
				b->b_name,
				filename(b));

		if (TOabort)
			break;
	}
	TOstop();
}

bufname(b)
register Buffer	*b;
{
	char	tmp[100],
		*cp;
	int	try = 1;

	if (b->b_fname == 0)
		complain("[No file name]");
	cp = basename(b->b_fname);
	strcpy(tmp, cp);
	while (buf_exists(tmp)) {
		sprintf(tmp, "%s.%d", cp, try);
		try++;
	}
	setbname(b, tmp);
}

initlist(b)
register Buffer	*b;
{
	lfreelist(b->b_first);
	b->b_first = b->b_dot = b->b_last = 0;
	(void) listput(b, b->b_first);
	
	SavLine(b->b_dot, NullStr);
	b->b_char = 0;
	AllMarkSet(b, b->b_dot, 0);
	if (b == curbuf)
		getDOT();
}

/* Returns pointer to buffer with name NAME, or if NAME is a string of digits
   returns the buffer whose number equals those digits.  Otherwise, returns
   0. */

Buffer *
buf_exists(name)
register char	*name;
{
	register Buffer	*bp;
	register int	n;

	if (name == 0)
		return 0;

	for (bp = world; bp != 0; bp = bp->b_next)
		if (strcmp(bp->b_name, name) == 0)
			return bp;

	/* Doesn't match any names.  Try for a buffer number... */

	if ((n = chr_to_int(name, 10, 1)) > 0) {
		for (bp = world; n > 1; bp = bp->b_next) {
			if (bp == 0)
				break;
			--n;
		}
		return bp;
	}

	return 0;
}

/* Returns buffer pointer with a file name NAME, if one exists.  Stat's the
   file and compares inodes, in case NAME is a link, as well as the actual
   characters that make up the file name. */

Buffer *
file_exists(name)
register char	*name;
{
	struct stat	stbuf;
	register struct stat	*s = &stbuf;
	register Buffer	*b = 0;
	char	fnamebuf[FILESIZE];

	if (name) {
		PathParse(name, fnamebuf);
		if (stat(fnamebuf, s) == -1)
			s->st_ino = 0;
		for (b = world; b != 0; b = b->b_next) {
			if ((b->b_ino != 0 && b->b_ino == s->st_ino) ||
			    (strcmp(b->b_fname, fnamebuf) == 0))
				break;
		}
	}
	return b;
}

char *
ralloc(obj, size)
register char	*obj;
{
	register char	*new;

	if (obj)
		new = realloc(obj, (unsigned) size);
	if (new == 0 || !obj)
		new = emalloc(size);
	return new;
}

setbname(b, name)
register Buffer	*b;
register char	*name;
{
	UpdModLine++;	/* Kludge ... but speeds things up considerably */
	if (name) {
		if (b->b_name == NoName)
			b->b_name = 0;
		b->b_name = ralloc(b->b_name, strlen(name) + 1);
		strcpy(b->b_name, name);
	} else
		b->b_name = 0;
}

setfname(b, name)
register Buffer	*b;
register char	*name;
{
	char	wholename[FILESIZE],
		oldname[FILESIZE],
		*oldptr = oldname;
	Buffer	*save = curbuf;

	SetBuf(b);
	UpdModLine++;	/* Kludge ... but speeds things up considerably */
	if (b->b_fname == 0)
		oldptr = 0;
	else
		strcpy(oldname, b->b_fname);
	if (name) {
		PathParse(name, wholename);
		curbuf->b_fname = ralloc(curbuf->b_fname, strlen(wholename) + 1);
		strcpy(curbuf->b_fname, wholename);
	} else
		b->b_fname = 0;
	DoAutoExec(curbuf->b_fname, oldptr);
	curbuf->b_mtime = curbuf->b_ino = 0;	/* until they're known. */
	SetBuf(save);
}

set_ino(b)
register Buffer	*b;
{
	struct stat	stbuf;

	if (b->b_fname == 0 || stat(b->b_fname, &stbuf) == -1) {
		b->b_ino = 0;
		b->b_mtime = 0;
	} else {
		b->b_ino = stbuf.st_ino;
		b->b_mtime = stbuf.st_mtime;
	}
}

/* Find the file `fname' into buf and put in in window `w' */

Buffer *
do_find(w, fname, force)
register Window	*w;
register char	*fname;
{
	register Buffer	*b;

	b = file_exists(fname);
	if (b == 0) {
		b = mak_buf();
		setfname(b, fname);
		bufname(b);
		set_ino(b);
		b->b_ntbf = 1;
		if (force) {
			Buffer	*oldb = curbuf;

			SetBuf(b);	/* this'll read the file */
			SetBuf(oldb);
		}
	}
	if (w)
		tiewind(w, b);
	return b;
}

/* Set alternate buffer */

SetABuf(b)
Buffer	*b;
{
	if (b != 0)
		lastbuf = b;
}

SetBuf(newbuf)
register Buffer	*newbuf;
{
	register Buffer	*oldb = curbuf;

	if (newbuf == curbuf || newbuf == 0)
		return;

	lsave();
	curbuf = newbuf;
	getDOT();
	/* Do the read now ... */
	if (curbuf->b_ntbf)
		read_file(curbuf->b_fname, 0);

#ifdef IPROCS
	if (oldb != 0 && oldb->b_type != curbuf->b_type) {
		if (curbuf->b_type == B_IPROCESS)
			PushPBs();		/* Push process bindings */
		else if (oldb->b_type == B_IPROCESS)
			PopPBs();
	}
	assign_p();		/* Set cur_proc */
#endif
}

Buffer *
do_select(w, name)
register Window	*w;
register char	*name;
{
	register Buffer	*new;

	if ((new = buf_exists(name)) == 0) {
		new = mak_buf();
		setfname(new, (char *) 0);
		setbname(new, name);
	}
	if (w)
		tiewind(w, new);
	return new;
}
Commit	Line	Data
394a1d25 C	1	/*************************************************************************
	2	* This program is copyright (C) 1985, 1986 by Jonathan Payne. It is *
	3	* provided to you without charge for use only on a licensed Unix *
	4	* system. You may copy JOVE provided that this notice is included with *
	5	* the copy. You may not sell copies of this program or versions *
	6	* modified for use on microcomputer systems, unless the copies are *
	7	* included with a Unix system distribution and the source is provided. *
	8	*************************************************************************/
	9
	10	/* Contains commands that deal with creating, selecting, killing and
	11	listing buffers, and buffer modes, and find-file, etc. */
	12
	13	#include "jove.h"
	14
	15	#include <sys/stat.h>
	16
	17	char *Mainbuf = "Main",
	18	*NoName = "Sans un nom!";
	19
	20	Buffer world = 0, / First in the list */
	21	*curbuf = 0,
	22	lastbuf = 0; / Last buffer we were in so we have a default
	23	buffer during a select buffer. */
	24
	25	/* Toggle BIT in the current buffer's minor mode flags. If argument is
	26	supplied, a positive one always turns on the mode and zero argument
	27	always turns it off. */
	28
	29	TogMinor(bit)
	30	{
	31	if (exp_p) {
	32	if (exp == 0)
	33	curbuf->b_minor &= ~bit;
	34	else
	35	curbuf->b_minor \|= bit;
	36	} else
	37	curbuf->b_minor ^= bit;
	38	UpdModLine++;
	39	}
	40
	41	/* Creates a new buffer, links it at the end of the buffer chain, and
	42	returns it. */
	43
	44	static Buffer *
	45	buf_alloc()
	46	{
	47	register Buffer *b,
	48	*lastbp;
	49
	50	lastbp = 0;
	51	for (b = world; b != 0; lastbp = b, b = b->b_next)
	52	;
	53
	54	b = (Buffer *) emalloc(sizeof (Buffer));
	55	if (lastbp)
	56	lastbp->b_next = b;
	57	else
	58	world = b;
	59	b->b_first = 0;
	60	b->b_next = 0;
	61
	62	return b;
	63	}
	64
65	/* Makes a buffer and initializes it. Obsolete. Used to take two
66	arguments, a buffer name and a file name. */
67
68	static Buffer *
69	mak_buf()
70	{
71	register Buffer *newb;
72	register int i;
73
74	newb = buf_alloc();
75	newb->b_fname = 0;
76	newb->b_name = NoName;
77	set_ino(newb);
78	newb->b_marks = 0;
79	newb->b_themark = 0; /* Index into markring */
80	/* No marks yet */
81	for (i = 0; i < NMARKS; i++)
82	newb->b_markring[i] = 0;
83	newb->b_modified = 0;
84	newb->b_type = B_FILE; /* File until proven SCRATCH */
85	newb->b_ntbf = 0;
86	newb->b_minor = 0;
87	newb->b_major = TEXT;
88	newb->b_first = 0;
89	initlist(newb);
90	return newb;
91	}
92
93	ReNamBuf()
94	{
95	register char *new = 0,
96	*prompt = ProcFmt,
97	*second = "%s already exists; new name? ";
98
99	for (;;) {
100	new = ask((char *) 0, prompt, new);
101	if (!buf_exists(new))
102	break;
103	prompt = second;
104	}
105	setbname(curbuf, new);
106	}
107
108	FindFile()
109	{
110	register char *name;
111	char fnamebuf[FILESIZE];
112
113	name = ask_file(curbuf->b_fname, fnamebuf);
114	SetABuf(curbuf);
115	SetBuf(do_find(curwind, name, 0));
116	}
117
118	static
119	mkbuflist(bnamp)
120	register char **bnamp;
121	{
122	register Buffer *b;
123
124	for (b = world; b != 0; b = b->b_next)
125	if (b->b_name != 0)
126	*bnamp++ = b->b_name;
127	*bnamp = 0;
128	}
129
130	char *
131	ask_buf(def)
132	Buffer *def;
133	{
134	char *bnames[100];
135	register char *bname;
136	register int offset;
137	char prompt[100];
138
139	if (def != 0 && def->b_name != 0)
140	sprintf(prompt, ": %f (default %s) ", def->b_name);
141	else
142	sprintf(prompt, ProcFmt);
143	mkbuflist(bnames);
144	offset = complete(bnames, prompt, RET_STATE);
145	if (offset == EOF)
146	complain((char *) 0);
147	if (offset == ORIGINAL)
148	bname = Minibuf;
149	else if (offset == NULLSTRING) {
150	if (def)
151	bname = def->b_name;
152	else
153	complain((char *) 0);
154	} else if (offset < 0)
155	complain((char *) 0);
156	else
157	bname = bnames[offset];
158
159	return bname;
160	}
161
162	BufSelect()
163	{
164	register char *bname;
165
166	bname = ask_buf(lastbuf);
167	SetABuf(curbuf);
168	SetBuf(do_select(curwind, bname));
169	}
170
171	static
172	defb_wind(b)
173	register Buffer *b;
174	{
175	register Window *w = fwind;
176	char *alt;
177
178	if (lastbuf == b \|\| lastbuf == 0) {
179	lastbuf = 0;
180	alt = (b->b_next != 0) ? b->b_next->b_name : Mainbuf;
181	} else
182	alt = lastbuf->b_name;
183
184	do {
185	if (w->w_bufp == b) {
186	if (one_windp())
187	(void) do_select(w, alt);
188	else {
189	register Window *save = w->w_next;
190
191	del_wind(w);
192	w = save->w_prev;
193	}
194	}
195	w = w->w_next;
196	} while (w != fwind);
197	}
198
199	Buffer *
200	getNMbuf()
201	{
202	register Buffer *delbuf;
203	register char *bname;
204
205	bname = ask_buf(curbuf);
206	if ((delbuf = buf_exists(bname)) == 0)
207	complain("[No such buffer]");
208	if (delbuf->b_modified)
209	confirm("%s modified, are you sure? ", bname);
210	return delbuf;
211	}
212
213	BufErase()
214	{
215	register Buffer *delbuf;
216
217	if (delbuf = getNMbuf()) {
218	initlist(delbuf);
219	delbuf->b_modified = 0;
220	}
221	}
222
223	static
224	kill_buf(delbuf)
225	register Buffer *delbuf;
226	{
227	register Buffer *b,
228	*lastb = 0;
229	extern Buffer *perr_buf;
230
231	#ifdef IPROCS
232	pbuftiedp(delbuf); /* Make sure buffer is not tied to a process */
233	#endif
234	for (b = world; b != 0; lastb = b, b = b->b_next)
235	if (b == delbuf)
236	break;
237	if (lastb)
238	lastb->b_next = delbuf->b_next;
239	else
240	world = delbuf->b_next;
241
242	#define okay_free(ptr) if (ptr) free(ptr)
243
244	lfreelist(delbuf->b_first);
245	okay_free(delbuf->b_name);
246	okay_free(delbuf->b_fname);
247	free((char *) delbuf);
248
249	if (delbuf == lastbuf)
250	SetABuf(curbuf);
251	if (perr_buf == delbuf) {
252	ErrFree();
253	perr_buf = 0;
254	}
255	defb_wind(delbuf);
256	if (curbuf == delbuf)
257	SetBuf(curwind->w_bufp);
258	}
259
260	/* offer to kill some buffers */
261
262	KillSome()
263	{
264	register Buffer *b,
265	*next;
266	Buffer *oldb;
267	register char *y_or_n;
268
269	for (b = world; b != 0; b = next) {
270	next = b->b_next;
271	y_or_n = ask("No", "Kill %s? ", b->b_name);
272	if (Upper(*y_or_n) != 'Y')
273	continue;
274	if (IsModified(b)) {
275	y_or_n = ask("No", "%s modified; should I save it? ", b->b_name);
276	if (Upper(*y_or_n) == 'Y') {
277	oldb = curbuf;
278	SetBuf(b);
279	SaveFile();
280	SetBuf(oldb);
281	}
282	}
283	kill_buf(b);
284	}
285	}
286
287	BufKill()
288	{
289	Buffer *b;
290
291	if ((b = getNMbuf()) == 0)
292	return;
293	kill_buf(b);
294	}
295
296	static char *
297	line_cnt(b, buf)
298	register Buffer *b;
299	char *buf;
300	{
301	register int nlines = 0;
302	register Line *lp;
303
304	for (lp = b->b_first; lp != 0; lp = lp->l_next, nlines++)
305	;
306	sprintf(buf, "%d", nlines);
307	return buf;
308	}
309
310	static char *TypeNames[] = {
311	0,
312	"Scratch",
313	"File",
314	"Process",
315	"I-process"
316	};
317
318	BufList()
319	{
320	register char format = "%-2s %-5s %-11s %-1s %-s %-s";
321	register Buffer *b;
322	int bcount = 1, /* To give each buffer a number */
323	buf_width = 11;
324	char nbuf[10];
325	extern int ModCount;
326
327	for (b = world; b != 0; b = b->b_next)
328	buf_width = max(buf_width, strlen(b->b_name));
329
330	TOstart("Buffer list", TRUE); /* true means auto-newline */
331
332	Typeout("(* means buffer needs saving)");
333	Typeout("(+ means file hasn't been read yet)");
334	Typeout(NullStr);
335	Typeout(format, "NO", "Lines", "Type", NullStr, buf_width, "Name", "File");
336	Typeout(format, "--", "-----", "----", NullStr, buf_width, "----", "----");
337	for (b = world; b != 0; b = b->b_next) {
338	Typeout(format, itoa(bcount++),
339	line_cnt(b, nbuf),
340	TypeNames[b->b_type],
341	IsModified(b) ? "*" :
342	b->b_ntbf ? "+" : NullStr,
343	buf_width,
344	/* For the * (variable length field) */
345	b->b_name,
346	filename(b));
347
348	if (TOabort)
349	break;
350	}
351	TOstop();
352	}
353
354	bufname(b)
355	register Buffer *b;
356	{
357	char tmp[100],
358	*cp;
359	int try = 1;
360
361	if (b->b_fname == 0)
362	complain("[No file name]");
363	cp = basename(b->b_fname);
364	strcpy(tmp, cp);
365	while (buf_exists(tmp)) {
366	sprintf(tmp, "%s.%d", cp, try);
367	try++;
368	}
369	setbname(b, tmp);
370	}
371
372	initlist(b)
373	register Buffer *b;
374	{
375	lfreelist(b->b_first);
376	b->b_first = b->b_dot = b->b_last = 0;
377	(void) listput(b, b->b_first);
378
379	SavLine(b->b_dot, NullStr);
380	b->b_char = 0;
381	AllMarkSet(b, b->b_dot, 0);
382	if (b == curbuf)
383	getDOT();
384	}
385
386	/* Returns pointer to buffer with name NAME, or if NAME is a string of digits
387	returns the buffer whose number equals those digits. Otherwise, returns
388	0. */
389
390	Buffer *
391	buf_exists(name)
392	register char *name;
393	{
394	register Buffer *bp;
395	register int n;
396
397	if (name == 0)
398	return 0;
399
400	for (bp = world; bp != 0; bp = bp->b_next)
401	if (strcmp(bp->b_name, name) == 0)
402	return bp;
403
404	/* Doesn't match any names. Try for a buffer number... */
405
406	if ((n = chr_to_int(name, 10, 1)) > 0) {
407	for (bp = world; n > 1; bp = bp->b_next) {
408	if (bp == 0)
409	break;
410	--n;
411	}
412	return bp;
413	}
414
415	return 0;
416	}
417
418	/* Returns buffer pointer with a file name NAME, if one exists. Stat's the
419	file and compares inodes, in case NAME is a link, as well as the actual
420	characters that make up the file name. */
421
422	Buffer *
423	file_exists(name)
424	register char *name;
425	{
426	struct stat stbuf;
427	register struct stat *s = &stbuf;
428	register Buffer *b = 0;
429	char fnamebuf[FILESIZE];
430
431	if (name) {
432	PathParse(name, fnamebuf);
433	if (stat(fnamebuf, s) == -1)
434	s->st_ino = 0;
435	for (b = world; b != 0; b = b->b_next) {
436	if ((b->b_ino != 0 && b->b_ino == s->st_ino) \|\|
437	(strcmp(b->b_fname, fnamebuf) == 0))
438	break;
439	}
440	}
441	return b;
442	}
443
444	char *
445	ralloc(obj, size)
446	register char *obj;
447	{
448	register char *new;
449
450	if (obj)
451	new = realloc(obj, (unsigned) size);
452	if (new == 0 \|\| !obj)
453	new = emalloc(size);
454	return new;
455	}
456
457	setbname(b, name)
458	register Buffer *b;
459	register char *name;
460	{
461	UpdModLine++; /* Kludge ... but speeds things up considerably */
462	if (name) {
463	if (b->b_name == NoName)
464	b->b_name = 0;
465	b->b_name = ralloc(b->b_name, strlen(name) + 1);
466	strcpy(b->b_name, name);
467	} else
468	b->b_name = 0;
469	}
470
471	setfname(b, name)
472	register Buffer *b;
473	register char *name;
474	{
475	char wholename[FILESIZE],
476	oldname[FILESIZE],
477	*oldptr = oldname;
478	Buffer *save = curbuf;
479
480	SetBuf(b);
481	UpdModLine++; /* Kludge ... but speeds things up considerably */
482	if (b->b_fname == 0)
483	oldptr = 0;
484	else
485	strcpy(oldname, b->b_fname);
486	if (name) {
487	PathParse(name, wholename);
488	curbuf->b_fname = ralloc(curbuf->b_fname, strlen(wholename) + 1);
489	strcpy(curbuf->b_fname, wholename);
490	} else
491	b->b_fname = 0;
492	DoAutoExec(curbuf->b_fname, oldptr);
493	curbuf->b_mtime = curbuf->b_ino = 0; /* until they're known. */
494	SetBuf(save);
495	}
496
497	set_ino(b)
498	register Buffer *b;
499	{
500	struct stat stbuf;
501
502	if (b->b_fname == 0 \|\| stat(b->b_fname, &stbuf) == -1) {
503	b->b_ino = 0;
504	b->b_mtime = 0;
505	} else {
506	b->b_ino = stbuf.st_ino;
507	b->b_mtime = stbuf.st_mtime;
508	}
509	}
510
511	/* Find the file `fname' into buf and put in in window `w' */
512
513	Buffer *
514	do_find(w, fname, force)
515	register Window *w;
516	register char *fname;
517	{
518	register Buffer *b;
519
520	b = file_exists(fname);
521	if (b == 0) {
522	b = mak_buf();
523	setfname(b, fname);
524	bufname(b);
525	set_ino(b);
526	b->b_ntbf = 1;
527	if (force) {
528	Buffer *oldb = curbuf;
529
530	SetBuf(b); /* this'll read the file */
531	SetBuf(oldb);
532	}
533	}
534	if (w)
535	tiewind(w, b);
536	return b;
537	}
538
539	/* Set alternate buffer */
540
541	SetABuf(b)
542	Buffer *b;
543	{
544	if (b != 0)
545	lastbuf = b;
546	}
547
548	SetBuf(newbuf)
549	register Buffer *newbuf;
550	{
551	register Buffer *oldb = curbuf;
552
553	if (newbuf == curbuf \|\| newbuf == 0)
554	return;
555
556	lsave();
557	curbuf = newbuf;
558	getDOT();
559	/* Do the read now ... */
560	if (curbuf->b_ntbf)
561	read_file(curbuf->b_fname, 0);
562
563	#ifdef IPROCS
564	if (oldb != 0 && oldb->b_type != curbuf->b_type) {
565	if (curbuf->b_type == B_IPROCESS)
566	PushPBs(); /* Push process bindings */
567	else if (oldb->b_type == B_IPROCESS)
568	PopPBs();
569	}
570	assign_p(); /* Set cur_proc */
571	#endif
572	}
573
574	Buffer *
575	do_select(w, name)
576	register Window *w;
577	register char *name;
578	{
579	register Buffer *new;
580
581	if ((new = buf_exists(name)) == 0) {
582	new = mak_buf();
583	setfname(new, (char *) 0);
584	setbname(new, name);
585	}
586	if (w)
587	tiewind(w, new);
588	return new;
589	}