Initial import from FreeBSD RELENG_4:
[dragonfly.git] / bin / ed / undo.c
1 /* undo.c: This file contains the undo routines for the ed line editor */
2 /*-
3  * Copyright (c) 1993 Andrew Moore, Talke Studio.
4  * All rights reserved.
5  *
6  * Redistribution and use in source and binary forms, with or without
7  * modification, are permitted provided that the following conditions
8  * are met:
9  * 1. Redistributions of source code must retain the above copyright
10  *    notice, this list of conditions and the following disclaimer.
11  * 2. Redistributions in binary form must reproduce the above copyright
12  *    notice, this list of conditions and the following disclaimer in the
13  *    documentation and/or other materials provided with the distribution.
14  *
15  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
16  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
17  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
18  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
19  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
20  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
21  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
22  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
23  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
24  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
25  * SUCH DAMAGE.
26  */
27
28 #ifndef lint
29 #if 0
30 static char * const rcsid = "@(#)undo.c,v 1.1 1994/02/01 00:34:44 alm Exp";
31 #else
32 static char * const rcsid =
33   "$FreeBSD: src/bin/ed/undo.c,v 1.9 1999/08/27 23:14:15 peter Exp $";
34 #endif
35 #endif /* not lint */
36
37 #include "ed.h"
38
39
40 #define USIZE 100                               /* undo stack size */
41 undo_t *ustack = NULL;                          /* undo stack */
42 long usize = 0;                                 /* stack size variable */
43 long u_p = 0;                                   /* undo stack pointer */
44
45 /* push_undo_stack: return pointer to initialized undo node */
46 undo_t *
47 push_undo_stack(type, from, to)
48         int type;
49         long from;
50         long to;
51 {
52         undo_t *t;
53
54 #if defined(sun) || defined(NO_REALLOC_NULL)
55         if (ustack == NULL &&
56             (ustack = (undo_t *) malloc((usize = USIZE) * sizeof(undo_t))) == NULL) {
57                 fprintf(stderr, "%s\n", strerror(errno));
58                 sprintf(errmsg, "out of memory");
59                 return NULL;
60         }
61 #endif
62         t = ustack;
63         if (u_p < usize ||
64             (t = (undo_t *) realloc(ustack, (usize += USIZE) * sizeof(undo_t))) != NULL) {
65                 ustack = t;
66                 ustack[u_p].type = type;
67                 ustack[u_p].t = get_addressed_line_node(to);
68                 ustack[u_p].h = get_addressed_line_node(from);
69                 return ustack + u_p++;
70         }
71         /* out of memory - release undo stack */
72         fprintf(stderr, "%s\n", strerror(errno));
73         sprintf(errmsg, "out of memory");
74         clear_undo_stack();
75         free(ustack);
76         ustack = NULL;
77         usize = 0;
78         return NULL;
79 }
80
81
82 /* USWAP: swap undo nodes */
83 #define USWAP(x,y) { \
84         undo_t utmp; \
85         utmp = x, x = y, y = utmp; \
86 }
87
88
89 long u_current_addr = -1;       /* if >= 0, undo enabled */
90 long u_addr_last = -1;          /* if >= 0, undo enabled */
91
92 /* pop_undo_stack: undo last change to the editor buffer */
93 int
94 pop_undo_stack()
95 {
96         long n;
97         long o_current_addr = current_addr;
98         long o_addr_last = addr_last;
99
100         if (u_current_addr == -1 || u_addr_last == -1) {
101                 sprintf(errmsg, "nothing to undo");
102                 return ERR;
103         } else if (u_p)
104                 modified = 1;
105         get_addressed_line_node(0);     /* this get_addressed_line_node last! */
106         SPL1();
107         for (n = u_p; n-- > 0;) {
108                 switch(ustack[n].type) {
109                 case UADD:
110                         REQUE(ustack[n].h->q_back, ustack[n].t->q_forw);
111                         break;
112                 case UDEL:
113                         REQUE(ustack[n].h->q_back, ustack[n].h);
114                         REQUE(ustack[n].t, ustack[n].t->q_forw);
115                         break;
116                 case UMOV:
117                 case VMOV:
118                         REQUE(ustack[n - 1].h, ustack[n].h->q_forw);
119                         REQUE(ustack[n].t->q_back, ustack[n - 1].t);
120                         REQUE(ustack[n].h, ustack[n].t);
121                         n--;
122                         break;
123                 default:
124                         /*NOTREACHED*/
125                         ;
126                 }
127                 ustack[n].type ^= 1;
128         }
129         /* reverse undo stack order */
130         for (n = u_p; n-- > (u_p + 1)/ 2;)
131                 USWAP(ustack[n], ustack[u_p - 1 - n]);
132         if (isglobal)
133                 clear_active_list();
134         current_addr = u_current_addr, u_current_addr = o_current_addr;
135         addr_last = u_addr_last, u_addr_last = o_addr_last;
136         SPL0();
137         return 0;
138 }
139
140
141 /* clear_undo_stack: clear the undo stack */
142 void
143 clear_undo_stack()
144 {
145         line_t *lp, *ep, *tl;
146
147         while (u_p--)
148                 if (ustack[u_p].type == UDEL) {
149                         ep = ustack[u_p].t->q_forw;
150                         for (lp = ustack[u_p].h; lp != ep; lp = tl) {
151                                 unmark_line_node(lp);
152                                 tl = lp->q_forw;
153                                 free(lp);
154                         }
155                 }
156         u_p = 0;
157         u_current_addr = current_addr;
158         u_addr_last = addr_last;
159 }