sys/vfs/hammer2: Remove obsolete comment on HAMMER2_RESOLVE_RDONLY
[dragonfly.git] / bin / ed / buf.c
1 /* buf.c: This file contains the scratch-file buffer routines for the
2    ed line editor. */
3 /*-
4  * Copyright (c) 1993 Andrew Moore, Talke Studio.
5  * All rights reserved.
6  *
7  * Redistribution and use in source and binary forms, with or without
8  * modification, are permitted provided that the following conditions
9  * are met:
10  * 1. Redistributions of source code must retain the above copyright
11  *    notice, this list of conditions and the following disclaimer.
12  * 2. Redistributions in binary form must reproduce the above copyright
13  *    notice, this list of conditions and the following disclaimer in the
14  *    documentation and/or other materials provided with the distribution.
15  *
16  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
17  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
18  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
19  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
20  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
21  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
22  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
23  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
24  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
25  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
26  * SUCH DAMAGE.
27  *
28  * @(#)buf.c,v 1.4 1994/02/01 00:34:35 alm Exp
29  * $FreeBSD: head/bin/ed/buf.c 241737 2012-10-19 14:49:42Z ed $
30  */
31
32 #include <sys/file.h>
33 #include <sys/stat.h>
34
35 #include "ed.h"
36
37
38 static FILE *sfp;                       /* scratch file pointer */
39 static off_t sfseek;                    /* scratch file position */
40 static int seek_write;                  /* seek before writing */
41 static line_t buffer_head;              /* incore buffer */
42
43 /* get_sbuf_line: get a line of text from the scratch file; return pointer
44    to the text */
45 char *
46 get_sbuf_line(line_t *lp)
47 {
48         static char *sfbuf = NULL;      /* buffer */
49         static int sfbufsz = 0;         /* buffer size */
50
51         int len, ct;
52
53         if (lp == &buffer_head)
54                 return NULL;
55         seek_write = 1;                         /* force seek on write */
56         /* out of position */
57         if (sfseek != lp->seek) {
58                 sfseek = lp->seek;
59                 if (fseeko(sfp, sfseek, SEEK_SET) < 0) {
60                         fprintf(stderr, "%s\n", strerror(errno));
61                         errmsg = "cannot seek temp file";
62                         return NULL;
63                 }
64         }
65         len = lp->len;
66         REALLOC(sfbuf, sfbufsz, len + 1, NULL);
67         if ((ct = fread(sfbuf, sizeof(char), len, sfp)) <  0 || ct != len) {
68                 fprintf(stderr, "%s\n", strerror(errno));
69                 errmsg = "cannot read temp file";
70                 return NULL;
71         }
72         sfseek += len;                          /* update file position */
73         sfbuf[len] = '\0';
74         return sfbuf;
75 }
76
77
78 /* put_sbuf_line: write a line of text to the scratch file and add a line node
79    to the editor buffer;  return a pointer to the end of the text */
80 const char *
81 put_sbuf_line(const char *cs)
82 {
83         line_t *lp;
84         int len, ct;
85         const char *s;
86
87         if ((lp = (line_t *) malloc(sizeof(line_t))) == NULL) {
88                 fprintf(stderr, "%s\n", strerror(errno));
89                 errmsg = "out of memory";
90                 return NULL;
91         }
92         /* assert: cs is '\n' terminated */
93         for (s = cs; *s != '\n'; s++)
94                 ;
95         if (s - cs >= LINECHARS) {
96                 errmsg = "line too long";
97                 free(lp);
98                 return NULL;
99         }
100         len = s - cs;
101         /* out of position */
102         if (seek_write) {
103                 if (fseeko(sfp, (off_t)0, SEEK_END) < 0) {
104                         fprintf(stderr, "%s\n", strerror(errno));
105                         errmsg = "cannot seek temp file";
106                         free(lp);
107                         return NULL;
108                 }
109                 sfseek = ftello(sfp);
110                 seek_write = 0;
111         }
112         /* assert: SPL1() */
113         if ((ct = fwrite(cs, sizeof(char), len, sfp)) < 0 || ct != len) {
114                 sfseek = -1;
115                 fprintf(stderr, "%s\n", strerror(errno));
116                 errmsg = "cannot write temp file";
117                 free(lp);
118                 return NULL;
119         }
120         lp->len = len;
121         lp->seek  = sfseek;
122         add_line_node(lp);
123         sfseek += len;                  /* update file position */
124         return ++s;
125 }
126
127
128 /* add_line_node: add a line node in the editor buffer after the current line */
129 void
130 add_line_node(line_t *lp)
131 {
132         line_t *cp;
133
134         cp = get_addressed_line_node(current_addr);                             /* this get_addressed_line_node last! */
135         INSQUE(lp, cp);
136         addr_last++;
137         current_addr++;
138 }
139
140
141 /* get_line_node_addr: return line number of pointer */
142 long
143 get_line_node_addr(line_t *lp)
144 {
145         line_t *cp = &buffer_head;
146         long n = 0;
147
148         while (cp != lp && (cp = cp->q_forw) != &buffer_head)
149                 n++;
150         if (n && cp == &buffer_head) {
151                 errmsg = "invalid address";
152                 return ERR;
153          }
154          return n;
155 }
156
157
158 /* get_addressed_line_node: return pointer to a line node in the editor buffer */
159 line_t *
160 get_addressed_line_node(long n)
161 {
162         static line_t *lp = &buffer_head;
163         static long on = 0;
164
165         SPL1();
166         if (n > on)
167                 if (n <= (on + addr_last) >> 1)
168                         for (; on < n; on++)
169                                 lp = lp->q_forw;
170                 else {
171                         lp = buffer_head.q_back;
172                         for (on = addr_last; on > n; on--)
173                                 lp = lp->q_back;
174                 }
175         else
176                 if (n >= on >> 1)
177                         for (; on > n; on--)
178                                 lp = lp->q_back;
179                 else {
180                         lp = &buffer_head;
181                         for (on = 0; on < n; on++)
182                                 lp = lp->q_forw;
183                 }
184         SPL0();
185         return lp;
186 }
187
188 static char sfn[15] = "";                       /* scratch file name */
189
190 /* open_sbuf: open scratch file */
191 int
192 open_sbuf(void)
193 {
194         int fd;
195         int u;
196
197         isbinary = newline_added = 0;
198         u = umask(077);
199         strcpy(sfn, "/tmp/ed.XXXXXX");
200         if ((fd = mkstemp(sfn)) == -1 ||
201             (sfp = fdopen(fd, "w+")) == NULL) {
202                 if (fd != -1)
203                         close(fd);
204                 perror(sfn);
205                 errmsg = "cannot open temp file";
206                 umask(u);
207                 return ERR;
208         }
209         umask(u);
210         return 0;
211 }
212
213
214 /* close_sbuf: close scratch file */
215 int
216 close_sbuf(void)
217 {
218         if (sfp) {
219                 if (fclose(sfp) < 0) {
220                         fprintf(stderr, "%s: %s\n", sfn, strerror(errno));
221                         errmsg = "cannot close temp file";
222                         return ERR;
223                 }
224                 sfp = NULL;
225                 unlink(sfn);
226         }
227         sfseek = seek_write = 0;
228         return 0;
229 }
230
231
232 /* quit: remove_lines scratch file and exit */
233 void
234 quit(int n)
235 {
236         if (sfp) {
237                 fclose(sfp);
238                 unlink(sfn);
239         }
240         exit(n);
241 }
242
243
244 static unsigned char ctab[256];         /* character translation table */
245
246 /* init_buffers: open scratch buffer; initialize line queue */
247 void
248 init_buffers(void)
249 {
250         int i = 0;
251
252         /* Read stdin one character at a time to avoid i/o contention
253            with shell escapes invoked by nonterminal input, e.g.,
254            ed - <<EOF
255            !cat
256            hello, world
257            EOF */
258         setbuffer(stdin, stdinbuf, 1);
259
260         /* Ensure stdout is line buffered. This avoids bogus delays
261            of output if stdout is piped through utilities to a terminal. */
262         setvbuf(stdout, NULL, _IOLBF, 0);
263         if (open_sbuf() < 0)
264                 quit(2);
265         REQUE(&buffer_head, &buffer_head);
266         for (i = 0; i < 256; i++)
267                 ctab[i] = i;
268 }
269
270
271 /* translit_text: translate characters in a string */
272 char *
273 translit_text(char *s, int len, int from, int to)
274 {
275         static int i = 0;
276
277         unsigned char *us;
278
279         ctab[i] = i;                    /* restore table to initial state */
280         ctab[i = from] = to;
281         for (us = (unsigned char *) s; len-- > 0; us++)
282                 *us = ctab[*us];
283         return s;
284 }