xref: /freebsd/contrib/nvi/common/line.c (revision 3e5645b78f476816ca3b5acc28b29bbafbb9c444)
1 /*-
2  * Copyright (c) 1992, 1993, 1994
3  *	The Regents of the University of California.  All rights reserved.
4  * Copyright (c) 1992, 1993, 1994, 1995, 1996
5  *	Keith Bostic.  All rights reserved.
6  *
7  * See the LICENSE file for redistribution information.
8  */
9 
10 #include "config.h"
11 
12 #ifndef lint
13 static const char sccsid[] = "$Id: line.c,v 10.27 2015/04/03 14:17:21 zy Exp $";
14 #endif /* not lint */
15 
16 #include <sys/types.h>
17 #include <sys/queue.h>
18 #include <sys/time.h>
19 
20 #include <bitstring.h>
21 #include <errno.h>
22 #include <limits.h>
23 #include <stdio.h>
24 #include <string.h>
25 
26 #include "common.h"
27 #include "../vi/vi.h"
28 
29 static int scr_update(SCR *, recno_t, lnop_t, int);
30 
31 /*
32  * db_eget --
33  *	Front-end to db_get, special case handling for empty files.
34  *
35  * PUBLIC: int db_eget(SCR *, recno_t, CHAR_T **, size_t *, int *);
36  */
37 int
38 db_eget(
39 	SCR *sp,
40 	recno_t lno,				/* Line number. */
41 	CHAR_T **pp,				/* Pointer store. */
42 	size_t *lenp,				/* Length store. */
43 	int *isemptyp)
44 {
45 	recno_t l1;
46 
47 	if (isemptyp != NULL)
48 		*isemptyp = 0;
49 
50 	/* If the line exists, simply return it. */
51 	if (!db_get(sp, lno, 0, pp, lenp))
52 		return (0);
53 
54 	/*
55 	 * If the user asked for line 0 or line 1, i.e. the only possible
56 	 * line in an empty file, find the last line of the file; db_last
57 	 * fails loudly.
58 	 */
59 	if ((lno == 0 || lno == 1) && db_last(sp, &l1))
60 		return (1);
61 
62 	/* If the file isn't empty, fail loudly. */
63 	if ((lno != 0 && lno != 1) || l1 != 0) {
64 		db_err(sp, lno);
65 		return (1);
66 	}
67 
68 	if (isemptyp != NULL)
69 		*isemptyp = 1;
70 
71 	return (1);
72 }
73 
74 /*
75  * db_get --
76  *	Look in the text buffers for a line, followed by the cache, followed
77  *	by the database.
78  *
79  * PUBLIC: int db_get(SCR *, recno_t, u_int32_t, CHAR_T **, size_t *);
80  */
81 int
82 db_get(
83 	SCR *sp,
84 	recno_t lno,				/* Line number. */
85 	u_int32_t flags,
86 	CHAR_T **pp,				/* Pointer store. */
87 	size_t *lenp)				/* Length store. */
88 {
89 	DBT data, key;
90 	EXF *ep;
91 	TEXT *tp;
92 	recno_t l1, l2;
93 	CHAR_T *wp;
94 	size_t wlen;
95 
96 	/*
97 	 * The underlying recno stuff handles zero by returning NULL, but
98 	 * have to have an OOB condition for the look-aside into the input
99 	 * buffer anyway.
100 	 */
101 	if (lno == 0)
102 		goto err1;
103 
104 	/* Check for no underlying file. */
105 	if ((ep = sp->ep) == NULL) {
106 		ex_emsg(sp, NULL, EXM_NOFILEYET);
107 		goto err3;
108 	}
109 
110 	if (LF_ISSET(DBG_NOCACHE))
111 		goto nocache;
112 
113 	/*
114 	 * Look-aside into the TEXT buffers and see if the line we want
115 	 * is there.
116 	 */
117 	if (F_ISSET(sp, SC_TINPUT)) {
118 		l1 = ((TEXT *)TAILQ_FIRST(sp->tiq))->lno;
119 		l2 = ((TEXT *)TAILQ_LAST(sp->tiq, _texth))->lno;
120 		if (l1 <= lno && l2 >= lno) {
121 #if defined(DEBUG) && 0
122 	TRACE(sp, "retrieve TEXT buffer line %lu\n", (u_long)lno);
123 #endif
124 			for (tp = TAILQ_FIRST(sp->tiq);
125 			    tp->lno != lno; tp = TAILQ_NEXT(tp, q));
126 			if (lenp != NULL)
127 				*lenp = tp->len;
128 			if (pp != NULL)
129 				*pp = tp->lb;
130 			return (0);
131 		}
132 		/*
133 		 * Adjust the line number for the number of lines used
134 		 * by the text input buffers.
135 		 */
136 		if (lno > l2)
137 			lno -= l2 - l1;
138 	}
139 
140 	/* Look-aside into the cache, and see if the line we want is there. */
141 	if (lno == ep->c_lno) {
142 #if defined(DEBUG) && 0
143 	TRACE(sp, "retrieve cached line %lu\n", (u_long)lno);
144 #endif
145 		if (lenp != NULL)
146 			*lenp = ep->c_len;
147 		if (pp != NULL)
148 			*pp = ep->c_lp;
149 		return (0);
150 	}
151 	ep->c_lno = OOBLNO;
152 
153 nocache:
154 	/* Get the line from the underlying database. */
155 	key.data = &lno;
156 	key.size = sizeof(lno);
157 	switch (ep->db->get(ep->db, &key, &data, 0)) {
158 	case -1:
159 		goto err2;
160 	case 1:
161 err1:		if (LF_ISSET(DBG_FATAL))
162 err2:			db_err(sp, lno);
163 alloc_err:
164 err3:		if (lenp != NULL)
165 			*lenp = 0;
166 		if (pp != NULL)
167 			*pp = NULL;
168 		return (1);
169 	}
170 
171 	if (FILE2INT(sp, data.data, data.size, wp, wlen)) {
172 		if (!F_ISSET(sp, SC_CONV_ERROR)) {
173 			F_SET(sp, SC_CONV_ERROR);
174 			msgq(sp, M_ERR, "324|Conversion error on line %d", lno);
175 		}
176 		goto err3;
177 	}
178 
179 	/* Reset the cache. */
180 	if (wp != data.data) {
181 		BINC_GOTOW(sp, ep->c_lp, ep->c_blen, wlen);
182 		MEMCPY(ep->c_lp, wp, wlen);
183 	} else
184 		ep->c_lp = data.data;
185 	ep->c_lno = lno;
186 	ep->c_len = wlen;
187 
188 #if defined(DEBUG) && 0
189 	TRACE(sp, "retrieve DB line %lu\n", (u_long)lno);
190 #endif
191 	if (lenp != NULL)
192 		*lenp = wlen;
193 	if (pp != NULL)
194 		*pp = ep->c_lp;
195 	return (0);
196 }
197 
198 /*
199  * db_delete --
200  *	Delete a line from the file.
201  *
202  * PUBLIC: int db_delete(SCR *, recno_t);
203  */
204 int
205 db_delete(
206 	SCR *sp,
207 	recno_t lno)
208 {
209 	DBT key;
210 	EXF *ep;
211 
212 #if defined(DEBUG) && 0
213 	TRACE(sp, "delete line %lu\n", (u_long)lno);
214 #endif
215 	/* Check for no underlying file. */
216 	if ((ep = sp->ep) == NULL) {
217 		ex_emsg(sp, NULL, EXM_NOFILEYET);
218 		return (1);
219 	}
220 
221 	/* Update marks, @ and global commands. */
222 	if (mark_insdel(sp, LINE_DELETE, lno))
223 		return (1);
224 	if (ex_g_insdel(sp, LINE_DELETE, lno))
225 		return (1);
226 
227 	/* Log change. */
228 	log_line(sp, lno, LOG_LINE_DELETE);
229 
230 	/* Update file. */
231 	key.data = &lno;
232 	key.size = sizeof(lno);
233 	if (ep->db->del(ep->db, &key, 0) == 1) {
234 		msgq(sp, M_SYSERR,
235 		    "003|unable to delete line %lu", (u_long)lno);
236 		return (1);
237 	}
238 
239 	/* Flush the cache, update line count, before screen update. */
240 	if (lno <= ep->c_lno)
241 		ep->c_lno = OOBLNO;
242 	if (ep->c_nlines != OOBLNO)
243 		--ep->c_nlines;
244 
245 	/* File now modified. */
246 	if (F_ISSET(ep, F_FIRSTMODIFY))
247 		(void)rcv_init(sp);
248 	F_SET(ep, F_MODIFIED);
249 
250 	/* Update screen. */
251 	return (scr_update(sp, lno, LINE_DELETE, 1));
252 }
253 
254 /*
255  * db_append --
256  *	Append a line into the file.
257  *
258  * PUBLIC: int db_append(SCR *, int, recno_t, CHAR_T *, size_t);
259  */
260 int
261 db_append(
262 	SCR *sp,
263 	int update,
264 	recno_t lno,
265 	CHAR_T *p,
266 	size_t len)
267 {
268 	DBT data, key;
269 	EXF *ep;
270 	char *fp;
271 	size_t flen;
272 	int rval;
273 
274 #if defined(DEBUG) && 0
275 	TRACE(sp, "append to %lu: len %u {%.*s}\n", lno, len, MIN(len, 20), p);
276 #endif
277 	/* Check for no underlying file. */
278 	if ((ep = sp->ep) == NULL) {
279 		ex_emsg(sp, NULL, EXM_NOFILEYET);
280 		return (1);
281 	}
282 
283 	INT2FILE(sp, p, len, fp, flen);
284 
285 	/* Update file. */
286 	key.data = &lno;
287 	key.size = sizeof(lno);
288 	data.data = fp;
289 	data.size = flen;
290 	if (ep->db->put(ep->db, &key, &data, R_IAFTER) == -1) {
291 		msgq(sp, M_SYSERR,
292 		    "004|unable to append to line %lu", (u_long)lno);
293 		return (1);
294 	}
295 
296 	/* Flush the cache, update line count, before screen update. */
297 	if (lno < ep->c_lno)
298 		ep->c_lno = OOBLNO;
299 	if (ep->c_nlines != OOBLNO)
300 		++ep->c_nlines;
301 
302 	/* File now dirty. */
303 	if (F_ISSET(ep, F_FIRSTMODIFY))
304 		(void)rcv_init(sp);
305 	F_SET(ep, F_MODIFIED);
306 
307 	/* Log change. */
308 	log_line(sp, lno + 1, LOG_LINE_APPEND);
309 
310 	/* Update marks, @ and global commands. */
311 	rval = 0;
312 	if (mark_insdel(sp, LINE_INSERT, lno + 1))
313 		rval = 1;
314 	if (ex_g_insdel(sp, LINE_INSERT, lno + 1))
315 		rval = 1;
316 
317 	/*
318 	 * Update screen.
319 	 *
320 	 * XXX
321 	 * Nasty hack.  If multiple lines are input by the user, they aren't
322 	 * committed until an <ESC> is entered.  The problem is the screen was
323 	 * updated/scrolled as each line was entered.  So, when this routine
324 	 * is called to copy the new lines from the cut buffer into the file,
325 	 * it has to know not to update the screen again.
326 	 */
327 	return (scr_update(sp, lno, LINE_APPEND, update) || rval);
328 }
329 
330 /*
331  * db_insert --
332  *	Insert a line into the file.
333  *
334  * PUBLIC: int db_insert(SCR *, recno_t, CHAR_T *, size_t);
335  */
336 int
337 db_insert(
338 	SCR *sp,
339 	recno_t lno,
340 	CHAR_T *p,
341 	size_t len)
342 {
343 	DBT data, key;
344 	EXF *ep;
345 	char *fp;
346 	size_t flen;
347 	int rval;
348 
349 #if defined(DEBUG) && 0
350 	TRACE(sp, "insert before %lu: len %lu {%.*s}\n",
351 	    (u_long)lno, (u_long)len, MIN(len, 20), p);
352 #endif
353 	/* Check for no underlying file. */
354 	if ((ep = sp->ep) == NULL) {
355 		ex_emsg(sp, NULL, EXM_NOFILEYET);
356 		return (1);
357 	}
358 
359 	INT2FILE(sp, p, len, fp, flen);
360 
361 	/* Update file. */
362 	key.data = &lno;
363 	key.size = sizeof(lno);
364 	data.data = fp;
365 	data.size = flen;
366 	if (ep->db->put(ep->db, &key, &data, R_IBEFORE) == -1) {
367 		msgq(sp, M_SYSERR,
368 		    "005|unable to insert at line %lu", (u_long)lno);
369 		return (1);
370 	}
371 
372 	/* Flush the cache, update line count, before screen update. */
373 	if (lno >= ep->c_lno)
374 		ep->c_lno = OOBLNO;
375 	if (ep->c_nlines != OOBLNO)
376 		++ep->c_nlines;
377 
378 	/* File now dirty. */
379 	if (F_ISSET(ep, F_FIRSTMODIFY))
380 		(void)rcv_init(sp);
381 	F_SET(ep, F_MODIFIED);
382 
383 	/* Log change. */
384 	log_line(sp, lno, LOG_LINE_INSERT);
385 
386 	/* Update marks, @ and global commands. */
387 	rval = 0;
388 	if (mark_insdel(sp, LINE_INSERT, lno))
389 		rval = 1;
390 	if (ex_g_insdel(sp, LINE_INSERT, lno))
391 		rval = 1;
392 
393 	/* Update screen. */
394 	return (scr_update(sp, lno, LINE_INSERT, 1) || rval);
395 }
396 
397 /*
398  * db_set --
399  *	Store a line in the file.
400  *
401  * PUBLIC: int db_set(SCR *, recno_t, CHAR_T *, size_t);
402  */
403 int
404 db_set(
405 	SCR *sp,
406 	recno_t lno,
407 	CHAR_T *p,
408 	size_t len)
409 {
410 	DBT data, key;
411 	EXF *ep;
412 	char *fp;
413 	size_t flen;
414 
415 #if defined(DEBUG) && 0
416 	TRACE(sp, "replace line %lu: len %lu {%.*s}\n",
417 	    (u_long)lno, (u_long)len, MIN(len, 20), p);
418 #endif
419 	/* Check for no underlying file. */
420 	if ((ep = sp->ep) == NULL) {
421 		ex_emsg(sp, NULL, EXM_NOFILEYET);
422 		return (1);
423 	}
424 
425 	/* Log before change. */
426 	log_line(sp, lno, LOG_LINE_RESET_B);
427 
428 	INT2FILE(sp, p, len, fp, flen);
429 
430 	/* Update file. */
431 	key.data = &lno;
432 	key.size = sizeof(lno);
433 	data.data = fp;
434 	data.size = flen;
435 	if (ep->db->put(ep->db, &key, &data, 0) == -1) {
436 		msgq(sp, M_SYSERR,
437 		    "006|unable to store line %lu", (u_long)lno);
438 		return (1);
439 	}
440 
441 	/* Flush the cache, before logging or screen update. */
442 	if (lno == ep->c_lno)
443 		ep->c_lno = OOBLNO;
444 
445 	/* File now dirty. */
446 	if (F_ISSET(ep, F_FIRSTMODIFY))
447 		(void)rcv_init(sp);
448 	F_SET(ep, F_MODIFIED);
449 
450 	/* Log after change. */
451 	log_line(sp, lno, LOG_LINE_RESET_F);
452 
453 	/* Update screen. */
454 	return (scr_update(sp, lno, LINE_RESET, 1));
455 }
456 
457 /*
458  * db_exist --
459  *	Return if a line exists.
460  *
461  * PUBLIC: int db_exist(SCR *, recno_t);
462  */
463 int
464 db_exist(
465 	SCR *sp,
466 	recno_t lno)
467 {
468 	EXF *ep;
469 
470 	/* Check for no underlying file. */
471 	if ((ep = sp->ep) == NULL) {
472 		ex_emsg(sp, NULL, EXM_NOFILEYET);
473 		return (1);
474 	}
475 
476 	if (lno == OOBLNO)
477 		return (0);
478 
479 	/*
480 	 * Check the last-line number cache.  Adjust the cached line
481 	 * number for the lines used by the text input buffers.
482 	 */
483 	if (ep->c_nlines != OOBLNO)
484 		return (lno <= (F_ISSET(sp, SC_TINPUT) ?
485 		    ep->c_nlines + (((TEXT *)TAILQ_LAST(sp->tiq, _texth))->lno -
486 		    ((TEXT *)TAILQ_FIRST(sp->tiq))->lno) : ep->c_nlines));
487 
488 	/* Go get the line. */
489 	return (!db_get(sp, lno, 0, NULL, NULL));
490 }
491 
492 /*
493  * db_last --
494  *	Return the number of lines in the file.
495  *
496  * PUBLIC: int db_last(SCR *, recno_t *);
497  */
498 int
499 db_last(
500 	SCR *sp,
501 	recno_t *lnop)
502 {
503 	DBT data, key;
504 	EXF *ep;
505 	recno_t lno;
506 	CHAR_T *wp;
507 	size_t wlen;
508 
509 	/* Check for no underlying file. */
510 	if ((ep = sp->ep) == NULL) {
511 		ex_emsg(sp, NULL, EXM_NOFILEYET);
512 		return (1);
513 	}
514 
515 	/*
516 	 * Check the last-line number cache.  Adjust the cached line
517 	 * number for the lines used by the text input buffers.
518 	 */
519 	if (ep->c_nlines != OOBLNO) {
520 		*lnop = ep->c_nlines;
521 		if (F_ISSET(sp, SC_TINPUT))
522 			*lnop += ((TEXT *)TAILQ_LAST(sp->tiq, _texth))->lno -
523 			    ((TEXT *)TAILQ_FIRST(sp->tiq))->lno;
524 		return (0);
525 	}
526 
527 	key.data = &lno;
528 	key.size = sizeof(lno);
529 
530 	switch (ep->db->seq(ep->db, &key, &data, R_LAST)) {
531 	case -1:
532 alloc_err:
533 		msgq(sp, M_SYSERR, "007|unable to get last line");
534 		*lnop = 0;
535 		return (1);
536 	case 1:
537 		*lnop = 0;
538 		return (0);
539 	}
540 
541 	memcpy(&lno, key.data, sizeof(lno));
542 
543 	if (lno != ep->c_lno) {
544 		FILE2INT(sp, data.data, data.size, wp, wlen);
545 
546 		/* Fill the cache. */
547 		if (wp != data.data) {
548 			BINC_GOTOW(sp, ep->c_lp, ep->c_blen, wlen);
549 			MEMCPY(ep->c_lp, wp, wlen);
550 		} else
551 			ep->c_lp = data.data;
552 		ep->c_lno = lno;
553 		ep->c_len = wlen;
554 	}
555 	ep->c_nlines = lno;
556 
557 	/* Return the value. */
558 	*lnop = (F_ISSET(sp, SC_TINPUT) &&
559 	    ((TEXT *)TAILQ_LAST(sp->tiq, _texth))->lno > lno ?
560 	    ((TEXT *)TAILQ_LAST(sp->tiq, _texth))->lno : lno);
561 	return (0);
562 }
563 
564 /*
565  * db_rget --
566  *	Retrieve a raw line from the database.
567  *
568  * PUBLIC: int db_rget(SCR *, recno_t, char **, size_t *);
569  */
570 int
571 db_rget(
572 	SCR *sp,
573 	recno_t lno,				/* Line number. */
574 	char **pp,				/* Pointer store. */
575 	size_t *lenp)				/* Length store. */
576 {
577 	DBT data, key;
578 	EXF *ep = sp->ep;
579 	int rval;
580 
581 	/* Get the line from the underlying database. */
582 	key.data = &lno;
583 	key.size = sizeof(lno);
584 	if ((rval = ep->db->get(ep->db, &key, &data, 0)) == 0)
585 	{
586 		*lenp = data.size;
587 		*pp = data.data;
588 	}
589 
590 	return (rval);
591 }
592 
593 /*
594  * db_rset --
595  *	Store a raw line into the database.
596  *
597  * PUBLIC: int db_rset(SCR *, recno_t, char *, size_t);
598  */
599 int
600 db_rset(
601 	SCR *sp,
602 	recno_t lno,
603 	char *p,
604 	size_t len)
605 {
606 	DBT data, key;
607 	EXF *ep = sp->ep;
608 
609 	/* Update file. */
610 	key.data = &lno;
611 	key.size = sizeof(lno);
612 	data.data = p;
613 	data.size = len;
614 	return ep->db->put(ep->db, &key, &data, 0);
615 }
616 
617 /*
618  * db_err --
619  *	Report a line error.
620  *
621  * PUBLIC: void db_err(SCR *, recno_t);
622  */
623 void
624 db_err(
625 	SCR *sp,
626 	recno_t lno)
627 {
628 	msgq(sp, M_ERR,
629 	    "008|Error: unable to retrieve line %lu", (u_long)lno);
630 }
631 
632 /*
633  * scr_update --
634  *	Update all of the screens that are backed by the file that
635  *	just changed.
636  */
637 static int
638 scr_update(
639 	SCR *sp,
640 	recno_t lno,
641 	lnop_t op,
642 	int current)
643 {
644 	EXF *ep;
645 	SCR *tsp;
646 
647 	if (F_ISSET(sp, SC_EX))
648 		return (0);
649 
650 	ep = sp->ep;
651 	if (ep->refcnt != 1)
652 		TAILQ_FOREACH(tsp, sp->gp->dq, q)
653 			if (sp != tsp && tsp->ep == ep)
654 				if (vs_change(tsp, lno, op))
655 					return (1);
656 	return (current ? vs_change(sp, lno, op) : 0);
657 }
658