mined(1): Fix alignment issue on strict alignment architectures.
[dragonfly.git] / bin / mined / mined1.c
CommitLineData
f5812cdf
MD
1/*
2 * Copyright (c) 1987,1997, Prentice Hall
3 * All rights reserved.
4 *
5 * Redistribution and use of the MINIX operating system in source and
6 * binary forms, with or without modification, are permitted provided
7 * that the following conditions are met:
8 *
9 * * Redistributions of source code must retain the above copyright
10 * notice, this list of conditions and the following disclaimer.
11 *
12 * * Redistributions in binary form must reproduce the above
13 * copyright notice, this list of conditions and the following
14 * disclaimer in the documentation and/or other materials provided
15 * with the distribution.
16 *
17 * * Neither the name of Prentice Hall nor the names of the software
18 * authors or contributors may be used to endorse or promote
19 * products derived from this software without specific prior
20 * written permission.
21 *
22 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS, AUTHORS, AND
23 * CONTRIBUTORS ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES,
24 * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
25 * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
26 * IN NO EVENT SHALL PRENTICE HALL OR ANY AUTHORS OR CONTRIBUTORS BE
27 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
28 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
29 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
30 * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
31 * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
32 * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
33 * EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
34 *
35 * [original code from minix codebase]
f5812cdf 36 */
4f73fc56
MD
37/*
38 * Part one of the mined editor.
39 */
40
f5812cdf
MD
41/*
42 * Ported to FreeBSD by Andrzej Bialecki <abial@freebsd.org>, Oct 1998
43 *
44 * Added a help screen, and remapped some of the wildest keybindings...
45 */
46
4f73fc56
MD
47/*
48 * Author: Michiel Huisjes.
49 *
50 * 1. General remarks.
51 *
52 * Mined is a screen editor designed for the MINIX operating system.
53 * It is meant to be used on files not larger than 50K and to be fast.
54 * When mined starts up, it reads the file into its memory to minimize
55 * disk access. The only time that disk access is needed is when certain
56 * save, write or copy commands are given.
57 *
58 * Mined has the style of Emacs or Jove, that means that there are no modes.
59 * Each character has its own entry in an 256 pointer to function array,
60 * which is called when that character is typed. Only ASCII characters are
61 * connected with a function that inserts that character at the current
62 * location in the file. Two execptions are <linefeed> and <tab> which are
63 * inserted as well. Note that the mapping between commands and functions
64 * called is implicit in the table. Changing the mapping just implies
65 * changing the pointers in this table.
66 *
67 * The display consists of SCREENMAX + 1 lines and XMAX + 1 characters. When
68 * a line is larger (or gets larger during editing) than XBREAK characters,
69 * the line is either shifted SHIFT_SIZE characters to the left (which means
70 * that the first SHIFT_SIZE characters are not printed) or the end of the
71 * line is marked with the SHIFT_MARK character and the rest of the line is
72 * not printed. A line can never exceed MAX_CHARS characters. Mined will
73 * always try to keep the cursor on the same line and same (relative)
74 * x-coordinate if nothing changed. So if you scroll one line up, the cursor
75 * stays on the same line, or when you move one line down, the cursor will
76 * move to the same place on the line as it was on the previous.
77 * Every character on the line is available for editing including the
78 * linefeed at the the of the line. When the linefeed is deleted, the current
79 * line and the next line are joined. The last character of the file (which
80 * is always a linefeed) can never be deleted.
81 * The bottomline (as indicated by YMAX + 1) is used as a status line during
82 * editing. This line is usually blank or contains information mined needs
83 * during editing. This information (or rather questions) is displayed in
84 * reverse video.
85 *
86 * The terminal modes are changed completely. All signals like start/stop,
87 * interrupt etc. are unset. The only signal that remains is the quit signal.
88 * The quit signal (^\) is the general abort signal for mined. Typing a ^\
89 * during searching or when mined is asking for filenames, etc. will abort
90 * the function and mined will return to the main loop. Sending a quit
91 * signal during the main loop will abort the session (after confirmation)
92 * and the file is not (!) saved.
93 * The session will also be aborted when an unrecoverable error occurs. E.g
94 * when there is no more memory available. If the file has been modified,
95 * mined will ask if the file has to be saved or not.
96 * If there is no more space left on the disk, mined will just give an error
97 * message and continue.
98 *
99 * The number of system calls are minized. This is done to keep the editor
100 * as fast as possible. I/O is done in SCREEN_SIZE reads/writes. Accumulated
101 * output is also flushed at the end of each character typed.
102 *
103 * 2. Regular expressions
104 *
105 * Mined has a build in regular expression matcher, which is used for
106 * searching and replace routines. A regular expression consists of a
107 * sequence of:
108 *
109 * 1. A normal character matching that character.
110 * 2. A . matching any character.
111 * 3. A ^ matching the begin of a line.
112 * 4. A $ (as last character of the pattern) mathing the end of a line.
113 * 5. A \<character> matching <character>.
114 * 6. A number of characters enclosed in [] pairs matching any of these
115 * characters. A list of characters can be indicated by a '-'. So
116 * [a-z] matches any letter of the alphabet. If the first character
117 * after the '[' is a '^' then the set is negated (matching none of
118 * the characters).
119 * A ']', '^' or '-' can be escaped by putting a '\' in front of it.
120 * Of course this means that a \ must be represented by \\.
121 * 7. If one of the expressions as described in 1-6 is followed by a
122 * '*' than that expressions matches a sequence of 0 or more of
123 * that expression.
124 *
125 * Parsing of regular expression is done in two phases. In the first phase
126 * the expression is compiled into a more comprehensible form. In the second
127 * phase the actual matching is done. For more details see 3.6.
128 *
129 *
130 * 3. Implementation of mined.
131 *
132 * 3.1 Data structures.
133 *
134 * The main data structures are as follows. The whole file is kept in a
135 * double linked list of lines. The LINE structure looks like this:
136 *
137 * typedef struct Line {
138 * struct Line *next;
139 * struct Line *prev;
140 * char *text;
141 * unsigned char shift_count;
142 * } LINE;
143 *
144 * Each line entry contains a pointer to the next line, a pointer to the
145 * previous line and a pointer to the text of that line. A special field
146 * shift_count contains the number of shifts (in units of SHIFT_SIZE)
147 * that is performed on that line. The total size of the structure is 7
148 * bytes so a file consisting of 1000 empty lines will waste a lot of
149 * memory. A LINE structure is allocated for each line in the file. After
150 * that the number of characters of the line is counted and sufficient
151 * space is allocated to store them (including a linefeed and a '\0').
152 * The resulting address is assigned to the text field in the structure.
153 *
154 * A special structure is allocated and its address is assigned to the
155 * variable header as well as the variable tail. The text field of this
156 * structure is set to NIL_PTR. The tail->prev of this structure points
157 * to the last LINE of the file and the header->next to the first LINE.
158 * Other LINE *variables are top_line and bot_line which point to the
159 * first line resp. the last line on the screen.
160 * Two other variables are important as well. First the LINE *cur_line,
161 * which points to the LINE currently in use and the char *cur_text,
162 * which points to the character at which the cursor stands.
163 * Whenever an ASCII character is typed, a new line is build with this
164 * character inserted. Then the old data space (pointed to by
165 * cur_line->text) is freed, data space for the new line is allocated and
166 * assigned to cur_line->text.
167 *
168 * Two global variables called x and y represent the x and y coordinates
169 * from the cursor. The global variable nlines contains the number of
170 * lines in the file. Last_y indicates the maximum y coordinate of the
171 * screen (which is usually SCREENMAX).
172 *
173 * A few strings must be initialized by hand before compiling mined.
174 * These string are enter_string, which is printed upon entering mined,
175 * rev_video (turn on reverse video), normal_video, rev_scroll (perform a
176 * reverse scroll) and pos_string. The last string should hold the
177 * absolute position string to be printed for cursor motion. The #define
178 * X_PLUS and Y_PLUS should contain the characters to be added to the
179 * coordinates x and y (both starting at 0) to finish cursor positioning.
180 *
181 * 3.2 Starting up.
182 *
183 * Mined can be called with or without argument and the function
184 * load_file () is called with these arguments. load_file () checks
185 * if the file exists if it can be read and if it is writable and
186 * sets the writable flag accordingly. If the file can be read,
187 * load_file () reads a line from the file and stores this line into
188 * a structure by calling install_line () and line_insert () which
189 * installs the line into the double linked list, until the end of the
190 * file is reached.
191 * Lines are read by the function get_line (), which buffers the
192 * reading in blocks of SCREEN_SIZE. Load_file () also initializes the
193 * LINE *variables described above.
194 *
195 * 3.3 Moving around.
196 *
197 * Several commands are implemented for moving through the file.
198 * Moving up (UP), down (DN) left (LF) and right (RT) are done by the
199 * arrow keys. Moving one line below the screen scrolls the screen one
200 * line up. Moving one line above the screen scrolls the screen one line
201 * down. The functions forward_scroll () and reverse_scroll () take care
202 * of that.
203 * Several other move functions exist: move to begin of line (BL), end of
204 * line (EL) top of screen (HIGH), bottom of screen (LOW), top of file
205 * (HO), end of file (EF), scroll one page down (PD), scroll one page up
206 * (PU), scroll one line down (SD), scroll one line up (SU) and move to a
207 * certain line number (GOTO).
208 * Two functions called MN () and MP () each move one word further or
209 * backwards. A word is a number of non-blanks seperated by a space, a
210 * tab or a linefeed.
211 *
212 * 3.4 Modifying text.
213 *
214 * The modifying commands can be separated into two modes. The first
215 * being inserting text, and the other deleting text. Two functions are
216 * created for these purposes: insert () and delete (). Both are capable
217 * of deleting or inserting large amounts of text as well as one
218 * character. Insert () must be given the line and location at which
219 * the text must be inserted. Is doesn't make any difference whether this
220 * text contains linefeeds or not. Delete () must be given a pointer to
221 * the start line, a pointer from where deleting should start on that
222 * line and the same information about the end position. The last
223 * character of the file will never be deleted. Delete () will make the
224 * necessary changes to the screen after deleting, but insert () won't.
225 * The functions for modifying text are: insert one char (S), insert a
226 * file (file_insert (fd)), insert a linefeed and put cursor back to
227 * end of line (LIB), delete character under the cursor (DCC), delete
228 * before cursor (even linefeed) (DPC), delete next word (DNW), delete
229 * previous word (DPC) and delete to end of line (if the cursor is at
230 * a linefeed delete line) (DLN).
231 *
232 * 3.5 Yanking.
233 *
234 * A few utilities are provided for yanking pieces of text. The function
235 * MA () marks the current position in the file. This is done by setting
236 * LINE *mark_line and char *mark_text to the current position. Yanking
237 * of text can be done in two modes. The first mode just copies the text
238 * from the mark to the current position (or visa versa) into a buffer
239 * (YA) and the second also deletes the text (DT). Both functions call
240 * the function set_up () with the delete flag on or off. Set_up ()
241 * checks if the marked position is still a valid one (by using
242 * check_mark () and legal ()), and then calls the function yank () with
243 * a start and end position in the file. This function copies the text
244 * into a scratch_file as indicated by the variable yank_file. This
245 * scratch_file is made uniq by the function scratch_file (). At the end
246 * of copying yank will (if necessary) delete the text. A global flag
247 * called yank_status keeps track of the buffer (or file) status. It is
248 * initialized on NOT_VALID and set to EMPTY (by set_up ()) or VALID (by
249 * yank ()). Several things can be done with the buffer. It can be
250 * inserted somewhere else in the file (PT) or it can be copied into
251 * another file (WB), which will be prompted for.
252 *
253 * 3.6 Search and replace routines.
254 *
255 * Searching for strings and replacing strings are done by regular
256 * expressions. For any expression the function compile () is called
257 * with as argument the expression to compile. Compile () returns a
258 * pointer to a structure which looks like this:
259 *
260 * typedef struct regex {
261 * union {
262 * char *err_mess;
263 * int *expression;
264 * } result;
265 * char status;
266 * char *start_ptr;
267 * char *end_ptr;
268 * } REGEX;
269 *
270 * If something went wrong during compiling (e.g. an illegal expression
271 * was given), the function reg_error () is called, which sets the status
272 * field to REG_ERROR and the err_mess field to the error message. If the
273 * match must be anchored at the beginning of the line (end of line), the
274 * status field is set to BEGIN_LINE (END_LINE). If none of these special
275 * cases are true, the field is set to 0 and the function finished () is
276 * called. Finished () allocates space to hold the compiled expression
277 * and copies this expression into the expression field of the union
278 * (bcopy ()). Matching is done by the routines match() and line_check().
279 * Match () takes as argument the REGEX *program, a pointer to the
280 * startposition on the current line, and a flag indicating FORWARD or
281 * REVERSE search. Match () checks out the whole file until a match is
282 * found. If match is found it returns a pointer to the line in which the
283 * match was found else it returns a NIL_LINE. Line_check () takes the
284 * same arguments, but return either MATCH or NO_MATCH.
285 * During checking, the start_ptr and end_ptr fields of the REGEX
286 * structure are assigned to the start and end of the match.
287 * Both functions try to find a match by walking through the line
288 * character by character. For each possibility, the function
289 * check_string () is called with as arguments the REGEX *program and the
290 * string to search in. It starts walking through the expression until
291 * the end of the expression or the end of the string is reached.
292 * Whenever a * is encountered, this position of the string is marked,
293 * the maximum number of matches are performed and the function star ()
294 * is called in order to try to find the longest match possible. Star ()
295 * takes as arguments the REGEX program, the current position of the
296 * string, the marked position and the current position of the expression
297 * Star () walks from the current position of the string back to the
298 * marked position, and calls string_check () in order to find a match.
299 * It returns MATCH or NO_MATCH, just as string_check () does.
300 * Searching is now easy. Both search routines (forward (SF) and
301 * backwards search (SR)) call search () with an apropiate message and a
302 * flag indicating FORWARD or REVERSE search. Search () will get an
303 * expression from the user by calling get_expression(). Get_expression()
304 * returns a pointer to a REGEX structure or NIL_REG upon errors and
305 * prompts for the expression. If no expression if given, the previous is
306 * used instead. After that search will call match (), and if a match is
307 * found, we can move to that place in the file by the functions find_x()
308 * and find_y () which will find display the match on the screen.
309 * Replacing can be done in two ways. A global replace (GR) or a line
310 * replace (LR). Both functions call change () with a message an a flag
311 * indicating global or line replacement. Change () will prompt for the
312 * expression and for the replacement. Every & in the replacement pattern
313 * means substitute the match instead. An & can be escaped by a \. When
314 * a match is found, the function substitute () will perform the
315 * substitution.
316 *
317 * 3.6 Miscellaneous commands.
318 *
319 * A few commands haven't be discussed yet. These are redraw the screen
320 * (RD) fork a shell (SH), print file status (FS), write file to disc
321 * (WT), insert a file at current position (IF), leave editor (XT) and
322 * visit another file (VI). The last two functions will check if the file
323 * has been modified. If it has, they will ask if you want to save the
324 * file by calling ask_save ().
325 * The function ESC () will repeat a command n times. It will prompt for
326 * the number. Aborting the loop can be done by sending the ^\ signal.
327 *
328 * 3.7 Utility functions.
329 *
330 * Several functions exists for internal use. First allocation routines:
331 * alloc (bytes) and newline () will return a pointer to free data space
332 * if the given size. If there is no more memory available, the function
333 * panic () is called.
334 * Signal handling: The only signal that can be send to mined is the
335 * SIGQUIT signal. This signal, functions as a general abort command.
336 * Mined will abort if the signal is given during the main loop. The
337 * function abort_mined () takes care of that.
338 * Panic () is a function with as argument a error message. It will print
339 * the message and the error number set by the kernel (errno) and will
340 * ask if the file must be saved or not. It resets the terminal
341 * (raw_mode ()) and exits.
342 * String handling routines like copy_string(to, from), length_of(string)
343 * and build_string (buffer, format, arg1, arg2, ...). The latter takes
344 * a description of the string out out the format field and puts the
345 * result in the buffer. (It works like printf (3), but then into a
346 * string). The functions status_line (string1, string2), error (string1,
347 * string2), clear_status () and bottom_line () all print information on
348 * the status line.
349 * Get_string (message, buffer) reads a string and getchar () reads one
350 * character from the terminal.
351 * Num_out ((long) number) prints the number into a 11 digit field
352 * without leading zero's. It returns a pointer to the resulting string.
353 * File_status () prints all file information on the status line.
354 * Set_cursor (x, y) prints the string to put the cursor at coordinates
355 * x and y.
356 * Output is done by four functions: writeline(fd,string), clear_buffer()
357 * write_char (fd, c) and flush_buffer (fd). Three defines are provided
358 * to write on filedescriptor STD_OUT (terminal) which is used normally:
359 * string_print (string), putchar (c) and flush (). All these functions
360 * use the global I/O buffer screen and the global index for this array
361 * called out_count. In this way I/O can be buffered, so that reads or
362 * writes can be done in blocks of SCREEN_SIZE size.
363 * The following functions all handle internal line maintenance. The
364 * function proceed (start_line, count) returns the count'th line after
365 * start_line. If count is negative, the count'th line before the
366 * start_line is returned. If header or tail is encountered then that
367 * will be returned. Display (x, y, start_line, count) displays count
368 * lines starting at coordinates [x, y] and beginning at start_line. If
369 * the header or tail is encountered, empty lines are displayed instead.
370 * The function reset (head_line, ny) reset top_line, last_y, bot_line,
371 * cur_line and y-coordinate. This is not a neat way to do the
372 * maintenance, but it sure saves a lot of code. It is usually used in
373 * combination with display ().
374 * Put_line(line, offset, clear_line), prints a line (skipping characters
375 * according to the line->shift_size field) until XBREAK - offset
376 * characters are printed or a '\n' is encountered. If clear_line is
377 * TRUE, spaces are printed until XBREAK - offset characters.
378 * Line_print (line) is a #define from put_line (line, 0, TRUE).
379 * Moving is done by the functions move_to (x, y), move_addres (address)
380 * and move (x, adress, y). This function is the most important one in
381 * mined. New_y must be between 0 and last_y, new_x can be about
382 * anything, address must be a pointer to an character on the current
383 * line (or y). Move_to () first adjust the y coordinate together with
384 * cur_line. If an address is given, it finds the corresponding
385 * x-coordinate. If an new x-coordinate was given, it will try to locate
386 * the corresponding character. After that it sets the shift_count field
387 * of cur_line to an apropiate number according to new_x. The only thing
388 * left to do now is to assign the new values to cur_line, cur_text, x
389 * and y.
390 *
391 * 4. Summary of commands.
392 *
393 * CURSOR MOTION
394 * up-arrow Move cursor 1 line up. At top of screen, reverse scroll
395 * down-arrow Move cursor 1 line down. At bottom, scroll forward.
396 * left-arrow Move cursor 1 character left or to end of previous line
397 * right-arrow Move cursor 1 character right or to start of next line
398 * CTRL-A Move cursor to start of current line
399 * CTRL-Z Move cursor to end of current line
400 * CTRL-^ Move cursor to top of screen
401 * CTRL-_ Move cursor to bottom of screen
402 * CTRL-F Forward to start of next word (even to next line)
403 * CTRL-B Backward to first character of previous word
404 *
405 * SCREEN MOTION
406 * Home key Move cursor to first character of file
407 * End key Move cursor to last character of file
408 * PgUp Scroll backward 1 page. Bottom line becomes top line
409 * PgD Scroll backward 1 page. Top line becomes bottom line
410 * CTRL-D Scroll screen down one line (reverse scroll)
411 * CTRL-U Scroll screen up one line (forward scroll)
412 *
413 * MODIFYING TEXT
414 * ASCII char Self insert character at cursor
415 * tab Insert tab at cursor
416 * backspace Delete the previous char (left of cursor), even line feed
417 * Del Delete the character under the cursor
418 * CTRL-N Delete next word
419 * CTRL-P Delete previous word
420 * CTRL-O Insert line feed at cursor and back up 1 character
421 * CTRL-T Delete tail of line (cursor to end); if empty, delete line
422 * CTRL-@ Set the mark (remember the current location)
423 * CTRL-K Delete text from the mark to current position save on file
424 * CTRL-C Save the text from the mark to the current position
425 * CTRL-Y Insert the contents of the save file at current position
426 * CTRL-Q Insert the contents of the save file into a new file
427 * CTRL-G Insert a file at the current position
428 *
429 * MISCELLANEOUS
5ce3bad5 430 * CTRL-L Erase and redraw the screen
4f73fc56
MD
431 * CTRL-V Visit file (read a new file); complain if old one changed
432 * CTRL-W Write the current file back to the disk
433 * numeric + Search forward (prompt for regular expression)
434 * numeric - Search backward (prompt for regular expression)
435 * numeric 5 Print the current status of the file
436 * CTRL-R (Global) Replace str1 by str2 (prompts for each string)
5ce3bad5 437 * [UNASS] (Line) Replace string1 by string2
4f73fc56
MD
438 * CTRL-S Fork off a shell and wait for it to finish
439 * CTRL-X EXIT (prompt if file modified)
440 * CTRL-] Go to a line. Prompts for linenumber
441 * CTRL-\ Abort whatever editor was doing and start again
442 * escape key Repeat a command count times; (prompts for count)
443 */
444
445/* ======================================================================== *
446 * Utilities *
447 * ======================================================================== */
448
449#include "mined.h"
450#include <signal.h>
451#include <termios.h>
452#include <limits.h>
453#include <errno.h>
454#include <sys/wait.h>
455#include <sys/ioctl.h>
4f73fc56 456#include <stdarg.h>
8ecf459d 457#include <stdlib.h>
4f73fc56 458
4f73fc56
MD
459int ymax = YMAX;
460int screenmax = SCREENMAX;
461
462
463/*
464 * Print file status.
465 */
8ecf459d
SW
466void
467FS(int u __unused)
4f73fc56
MD
468{
469 fstatus(file_name[0] ? "" : "[buffer]", -1L);
470}
471
472/*
473 * Visit (edit) another file. If the file has been modified, ask the user if
474 * he wants to save it.
475 */
8ecf459d
SW
476void
477VI(int u __unused)
4f73fc56
MD
478{
479 char new_file[LINE_LEN]; /* Buffer to hold new file name */
480
481 if (modified == TRUE && ask_save() == ERRORS)
902ec341 482 return;
4f73fc56
MD
483
484/* Get new file name */
485 if (get_file("Visit file:", new_file) == ERRORS)
902ec341 486 return;
4f73fc56
MD
487
488/* Free old linked list, initialize global variables and load new file */
489 initialize();
490#ifdef UNIX
491 tputs(CL, 0, _putchar);
492#else
493 string_print (enter_string);
494#endif /* UNIX */
495 load_file(new_file[0] == '\0' ? NIL_PTR : new_file);
496}
497
498/*
499 * Write file in core to disc.
500 */
8ecf459d
SW
501int
502WT(void)
4f73fc56 503{
8ecf459d
SW
504 LINE *line;
505 long count = 0L; /* Nr of chars written */
4f73fc56
MD
506 char file[LINE_LEN]; /* Buffer for new file name */
507 int fd; /* Filedescriptor of file */
508
509 if (modified == FALSE) {
510 error ("Write not necessary.", NIL_PTR);
511 return FINE;
512 }
513
514/* Check if file_name is valid and if file can be written */
515 if (file_name[0] == '\0' || writable == FALSE) {
902ec341
SW
516 if (get_file("Enter file name:", file) != FINE)
517 return ERRORS;
518 copy_string(file_name, file); /* Save file name */
4f73fc56
MD
519 }
520 if ((fd = creat(file_name, 0644)) < 0) { /* Empty file */
902ec341
SW
521 error("Cannot create ", file_name);
522 writable = FALSE;
523 return ERRORS;
4f73fc56
MD
524 }
525 else
902ec341 526 writable = TRUE;
4f73fc56
MD
527
528 clear_buffer();
529
530 status_line("Writing ", file_name);
531 for (line = header->next; line != tail; line = line->next) {
532 if (line->shift_count & DUMMY) {
533 if (line->next == tail && line->text[0] == '\n')
534 continue;
535 }
902ec341
SW
536 if (writeline(fd, line->text) == ERRORS) {
537 count = -1L;
538 break;
539 }
540 count += (long) length_of(line->text);
4f73fc56
MD
541 }
542
543 if (count > 0L && flush_buffer(fd) == ERRORS)
902ec341 544 count = -1L;
4f73fc56 545
1f0f7b35 546 close(fd);
4f73fc56
MD
547
548 if (count == -1L)
902ec341 549 return ERRORS;
4f73fc56
MD
550
551 modified = FALSE;
552 rpipe = FALSE; /* File name is now assigned */
553
554/* Display how many chars (and lines) were written */
555 fstatus("Wrote", count);
556 return FINE;
557}
558
559/* Call WT and discard value returned. */
8ecf459d
SW
560void
561XWT(int u __unused)
4f73fc56 562{
8ecf459d 563 WT();
4f73fc56
MD
564}
565
566
567
568/*
569 * Call an interactive shell.
570 */
8ecf459d
SW
571void
572SH(int u __unused)
4f73fc56 573{
8ecf459d 574 int w;
4f73fc56 575 int pid, status;
8ecf459d 576 const char *shell;
4f73fc56
MD
577
578 if ((shell = getenv("SHELL")) == NIL_PTR) shell = "/bin/sh";
579
580 switch (pid = fork()) {
902ec341
SW
581 case -1: /* Error */
582 error("Cannot fork.", NIL_PTR);
583 return;
584 case 0: /* This is the child */
585 set_cursor(0, ymax);
586 putchar('\n');
587 flush();
588 raw_mode(OFF);
4f73fc56
MD
589 if (rpipe) { /* Fix stdin */
590 close (0);
591 if (open("/dev/tty", 0) < 0)
592 exit (126);
593 }
902ec341
SW
594 execl(shell, shell, NULL);
595 exit(127); /* Exit with 127 */
596 default : /* This is the parent */
597 signal(SIGINT, SIG_IGN);
598 signal(SIGQUIT, SIG_IGN);
599 do {
600 w = wait(&status);
601 } while (w != -1 && w != pid);
4f73fc56
MD
602 }
603
604 raw_mode(ON);
8ecf459d 605 RD(0);
4f73fc56
MD
606
607 if ((status >> 8) == 127) /* Child died with 127 */
902ec341 608 error("Cannot exec ", shell);
4f73fc56 609 else if ((status >> 8) == 126)
902ec341 610 error("Cannot open /dev/tty as fd #0", NIL_PTR);
4f73fc56
MD
611}
612
613/*
614 * Proceed returns the count'th line after `line'. When count is negative
615 * it returns the count'th line before `line'. When the next (previous)
616 * line is the tail (header) indicating EOF (tof) it stops.
617 */
8ecf459d
SW
618LINE *
619proceed(LINE *line, int count)
4f73fc56
MD
620{
621 if (count < 0)
902ec341
SW
622 while (count++ < 0 && line != header)
623 line = line->prev;
4f73fc56 624 else
902ec341
SW
625 while (count-- > 0 && line != tail)
626 line = line->next;
4f73fc56
MD
627 return line;
628}
629
630/*
631 * Show concatenation of s1 and s2 on the status line (bottom of screen)
632 * If revfl is TRUE, turn on reverse video on both strings. Set stat_visible
633 * only if bottom_line is visible.
634 */
8ecf459d
SW
635int
636bottom_line(FLAG revfl, const char *s1, const char *s2, char *inbuf,
637 FLAG statfl)
4f73fc56
MD
638{
639 int ret = FINE;
640 char buf[LINE_LEN];
8ecf459d 641 char *p = buf;
4f73fc56
MD
642
643 *p++ = ' ';
644 if (s1 != NIL_PTR)
3641b7ca 645 while ((*p = *s1++) != 0)
4f73fc56
MD
646 p++;
647 if (s2 != NIL_PTR)
3641b7ca 648 while ((*p = *s2++) != 0)
4f73fc56
MD
649 p++;
650 *p++ = ' ';
651 *p++ = 0;
652
653 if (revfl == ON && stat_visible == TRUE)
654 clear_status ();
655 set_cursor(0, ymax);
656 if (revfl == ON) { /* Print rev. start sequence */
657#ifdef UNIX
902ec341 658 tputs(SO, 0, _putchar);
4f73fc56 659#else
902ec341 660 string_print(rev_video);
4f73fc56 661#endif /* UNIX */
902ec341 662 stat_visible = TRUE;
4f73fc56
MD
663 }
664 else /* Used as clear_status() */
902ec341 665 stat_visible = FALSE;
4f73fc56
MD
666
667 string_print(buf);
902ec341 668
4f73fc56 669 if (inbuf != NIL_PTR)
902ec341 670 ret = input(inbuf, statfl);
4f73fc56
MD
671
672 /* Print normal video */
673#ifdef UNIX
674 tputs(SE, 0, _putchar);
675 tputs(CE, 0, _putchar);
676#else
677 string_print(normal_video);
678 string_print(blank_line); /* Clear the rest of the line */
679#endif /* UNIX */
680 if (inbuf != NIL_PTR)
902ec341 681 set_cursor(0, ymax);
4f73fc56 682 else
902ec341 683 set_cursor(x, y); /* Set cursor back to old position */
4f73fc56
MD
684 flush(); /* Perform the actual write */
685 if (ret != FINE)
902ec341 686 clear_status();
4f73fc56
MD
687 return ret;
688}
689
690/*
691 * Count_chars() count the number of chars that the line would occupy on the
692 * screen. Counting starts at the real x-coordinate of the line.
693 */
8ecf459d
SW
694int
695count_chars(LINE *line)
4f73fc56 696{
8ecf459d
SW
697 int cnt = get_shift(line->shift_count) * -SHIFT_SIZE;
698 char *textp = line->text;
4f73fc56
MD
699
700/* Find begin of line on screen */
701 while (cnt < 0) {
902ec341
SW
702 if (is_tab(*textp++))
703 cnt = tab(cnt);
704 else
705 cnt++;
4f73fc56
MD
706 }
707
708/* Count number of chars left */
709 cnt = 0;
710 while (*textp != '\n') {
902ec341
SW
711 if (is_tab(*textp++))
712 cnt = tab(cnt);
713 else
714 cnt++;
4f73fc56
MD
715 }
716 return cnt;
717}
718
719/*
720 * Move to coordinates nx, ny at screen. The caller must check that scrolling
721 * is not needed.
722 * If new_x is lower than 0 or higher than XBREAK, move_to() will check if
723 * the line can be shifted. If it can it sets(or resets) the shift_count field
724 * of the current line accordingly.
725 * Move also sets cur_text to the right char.
726 * If we're moving to the same x coordinate, try to move the the x-coordinate
727 * used on the other previous call.
728 */
8ecf459d
SW
729void
730move(int new_x, char *new_address, int new_y)
4f73fc56 731{
8ecf459d 732 LINE *line = cur_line; /* For building new cur_line */
4f73fc56
MD
733 int shift = 0; /* How many shifts to make */
734 static int rel_x = 0; /* Remember relative x position */
735 int tx = x;
736
737/* Check for illegal values */
738 if (new_y < 0 || new_y > last_y)
902ec341 739 return;
4f73fc56
MD
740
741/* Adjust y-coordinate and cur_line */
742 if (new_y < y)
902ec341 743 while (y != new_y) {
f5812cdf
MD
744 if(line->shift_count>0) {
745 line->shift_count=0;
746 move_to(0,y);
747 string_print(blank_line);
748 line_print(line);
749 }
902ec341
SW
750 y--;
751 line = line->prev;
752 }
4f73fc56 753 else
902ec341 754 while (y != new_y) {
f5812cdf
MD
755 if(line->shift_count>0) {
756 line->shift_count=0;
757 move_to(0,y);
758 string_print(blank_line);
759 line_print(line);
760 }
902ec341
SW
761 y++;
762 line = line->next;
763 }
4f73fc56
MD
764
765/* Set or unset relative x-coordinate */
766 if (new_address == NIL_PTR) {
902ec341 767 new_address = find_address(line, (new_x == x) ? rel_x : new_x , &tx);
4f73fc56
MD
768 if (new_x != x)
769 rel_x = tx;
902ec341 770 new_x = tx;
4f73fc56 771 }
f5812cdf 772 else {
902ec341 773 rel_x = new_x = find_x(line, new_address);
f5812cdf 774 }
4f73fc56
MD
775
776/* Adjust shift_count if new_x lower than 0 or higher than XBREAK */
777 if (new_x < 0 || new_x >= XBREAK) {
902ec341
SW
778 if (new_x > XBREAK || (new_x == XBREAK && *new_address != '\n'))
779 shift = (new_x - XBREAK) / SHIFT_SIZE + 1;
780 else {
781 shift = new_x / SHIFT_SIZE;
4f73fc56
MD
782 if (new_x % SHIFT_SIZE)
783 shift--;
902ec341
SW
784 }
785
786 if (shift != 0) {
787 line->shift_count += shift;
788 new_x = find_x(line, new_address);
789 set_cursor(0, y);
790 line_print(line);
791 rel_x = new_x;
792 }
4f73fc56
MD
793 }
794
795/* Assign and position cursor */
796 x = new_x;
797 cur_text = new_address;
798 cur_line = line;
799 set_cursor(x, y);
800}
801
802/*
803 * Find_x() returns the x coordinate belonging to address.
804 * (Tabs are expanded).
805 */
8ecf459d
SW
806int
807find_x(LINE *line, char *address)
4f73fc56 808{
8ecf459d
SW
809 char *textp = line->text;
810 int nx = get_shift(line->shift_count) * -SHIFT_SIZE;
4f73fc56
MD
811
812 while (textp != address && *textp != '\0') {
902ec341
SW
813 if (is_tab(*textp++)) /* Expand tabs */
814 nx = tab(nx);
815 else
816 nx++;
4f73fc56
MD
817 }
818 return nx;
819}
820
821/*
822 * Find_address() returns the pointer in the line with offset x_coord.
823 * (Tabs are expanded).
824 */
8ecf459d
SW
825char *
826find_address(LINE *line, int x_coord, int *old_x)
4f73fc56 827{
8ecf459d
SW
828 char *textp = line->text;
829 int tx = get_shift(line->shift_count) * -SHIFT_SIZE;
4f73fc56
MD
830
831 while (tx < x_coord && *textp != '\n') {
902ec341
SW
832 if (is_tab(*textp)) {
833 if (*old_x - x_coord == 1 && tab(tx) > x_coord)
834 break; /* Moving left over tab */
835 else
836 tx = tab(tx);
837 }
838 else
839 tx++;
840 textp++;
4f73fc56 841 }
902ec341 842
4f73fc56
MD
843 *old_x = tx;
844 return textp;
845}
846
847/*
848 * Length_of() returns the number of characters int the string `string'
849 * excluding the '\0'.
850 */
8ecf459d
SW
851int
852length_of(char *string)
4f73fc56 853{
8ecf459d 854 int count = 0;
4f73fc56
MD
855
856 if (string != NIL_PTR) {
902ec341
SW
857 while (*string++ != '\0')
858 count++;
4f73fc56
MD
859 }
860 return count;
861}
862
863/*
864 * Copy_string() copies the string `from' into the string `to'. `To' must be
865 * long enough to hold `from'.
866 */
8ecf459d
SW
867void
868copy_string(char *to, const char *from)
4f73fc56 869{
3641b7ca 870 while ((*to++ = *from++) != 0)
902ec341 871 ;
4f73fc56
MD
872}
873
874/*
875 * Reset assigns bot_line, top_line and cur_line according to `head_line'
876 * which must be the first line of the screen, and an y-coordinate,
877 * which will be the current y-coordinate (if it isn't larger than last_y)
878 */
8ecf459d
SW
879void
880reset(LINE *head_line, int screen_y)
4f73fc56 881{
8ecf459d 882 LINE *line;
4f73fc56
MD
883
884 top_line = line = head_line;
885
886/* Search for bot_line (might be last line in file) */
887 for (last_y = 0; last_y < nlines - 1 && last_y < screenmax
888 && line->next != tail; last_y++)
902ec341 889 line = line->next;
4f73fc56
MD
890
891 bot_line = line;
892 y = (screen_y > last_y) ? last_y : screen_y;
893
894/* Set cur_line according to the new y value */
895 cur_line = proceed(top_line, y);
896}
897
898/*
899 * Set cursor at coordinates x, y.
900 */
8ecf459d
SW
901void
902set_cursor(int nx, int ny)
4f73fc56
MD
903{
904#ifdef UNIX
4f73fc56
MD
905 tputs(tgoto(CM, nx, ny), 0, _putchar);
906#else
8ecf459d 907 char text_buf[10];
4f73fc56 908
8ecf459d
SW
909 build_string(text_buf, pos_string, ny+1, nx+1);
910 string_print(text_buf);
4f73fc56
MD
911#endif /* UNIX */
912}
913
914/*
915 * Routine to open terminal when mined is used in a pipeline.
916 */
8ecf459d
SW
917void
918open_device(void)
4f73fc56
MD
919{
920 if ((input_fd = open("/dev/tty", 0)) < 0)
921 panic("Cannot open /dev/tty for read");
922}
923
924/*
925 * Getchar() reads one character from the terminal. The character must be
926 * masked with 0377 to avoid sign extension.
927 */
8ecf459d
SW
928int
929getchar(void)
4f73fc56
MD
930{
931#ifdef UNIX
932 return (_getchar() & 0377);
933#else
934 char c;
935
936 if (read(input_fd, &c, 1) != 1 && quit == FALSE)
902ec341 937 panic("Can't read one char from fd #0");
4f73fc56
MD
938
939 return c & 0377;
940#endif /* UNIX */
941}
942
943/*
944 * Display() shows count lines on the terminal starting at the given
945 * coordinates. When the tail of the list is encountered it will fill the
946 * rest of the screen with blank_line's.
947 * When count is negative, a backwards print from `line' will be done.
948 */
8ecf459d
SW
949void
950display(int x_coord, int y_coord, LINE *line, int count)
4f73fc56
MD
951{
952 set_cursor(x_coord, y_coord);
953
954/* Find new startline if count is negative */
955 if (count < 0) {
902ec341
SW
956 line = proceed(line, count);
957 count = -count;
4f73fc56
MD
958 }
959
960/* Print the lines */
961 while (line != tail && count-- >= 0) {
f5812cdf 962 line->shift_count=0;
902ec341
SW
963 line_print(line);
964 line = line->next;
4f73fc56
MD
965 }
966
967/* Print the blank lines (if any) */
968 if (loading == FALSE) {
969 while (count-- >= 0) {
970#ifdef UNIX
971 tputs(CE, 0, _putchar);
972#else
973 string_print(blank_line);
974#endif /* UNIX */
975 putchar('\n');
976 }
977 }
978}
979
980/*
902ec341 981 * Write_char does a buffered output.
4f73fc56 982 */
8ecf459d
SW
983int
984write_char(int fd, char c)
4f73fc56
MD
985{
986 screen [out_count++] = c;
987 if (out_count == SCREEN_SIZE) /* Flush on SCREEN_SIZE chars */
902ec341 988 return flush_buffer(fd);
4f73fc56
MD
989 return FINE;
990}
991
992/*
993 * Writeline writes the given string on the given filedescriptor.
994 */
8ecf459d
SW
995int
996writeline(int fd, const char *text)
4f73fc56
MD
997{
998 while(*text)
902ec341
SW
999 if (write_char(fd, *text++) == ERRORS)
1000 return ERRORS;
4f73fc56
MD
1001 return FINE;
1002}
1003
1004/*
1005 * Put_line print the given line on the standard output. If offset is not zero
1006 * printing will start at that x-coordinate. If the FLAG clear_line is TRUE,
1007 * then (screen) line will be cleared when the end of the line has been
1008 * reached.
8ecf459d
SW
1009 *
1010 * parameter
1011 * line: Line to print
1012 * offset: Offset to start
1013 * clear_line: Clear to eoln if TRUE
4f73fc56 1014 */
8ecf459d
SW
1015void
1016put_line(LINE *line, int offset, FLAG clear_line)
4f73fc56 1017{
8ecf459d
SW
1018 char *textp = line->text;
1019 int count = get_shift(line->shift_count) * -SHIFT_SIZE;
4f73fc56
MD
1020 int tab_count; /* Used in tab expansion */
1021
1022/* Skip all chars as indicated by the offset and the shift_count field */
1023 while (count < offset) {
902ec341
SW
1024 if (is_tab(*textp++))
1025 count = tab(count);
1026 else
1027 count++;
4f73fc56
MD
1028 }
1029
1030 while (*textp != '\n' && count < XBREAK) {
902ec341
SW
1031 if (is_tab(*textp)) { /* Expand tabs to spaces */
1032 tab_count = tab(count);
1033 while (count < XBREAK && count < tab_count) {
1034 count++;
1035 putchar(' ');
1036 }
1037 textp++;
1038 }
1039 else {
4f73fc56
MD
1040 if (*textp >= '\01' && *textp <= '\037') {
1041#ifdef UNIX
1042 tputs(SO, 0, _putchar);
1043#else
1044 string_print (rev_video);
1045#endif /* UNIX */
902ec341 1046 putchar(*textp++ + '\100');
4f73fc56
MD
1047#ifdef UNIX
1048 tputs(SE, 0, _putchar);
1049#else
1050 string_print (normal_video);
1051#endif /* UNIX */
1052 }
1053 else
902ec341
SW
1054 putchar(*textp++);
1055 count++;
1056 }
4f73fc56
MD
1057 }
1058
1059/* If line is longer than XBREAK chars, print the shift_mark */
1060 if (count == XBREAK && *textp != '\n')
902ec341 1061 putchar(textp[1]=='\n' ? *textp : SHIFT_MARK);
4f73fc56
MD
1062
1063/* Clear the rest of the line is clear_line is TRUE */
1064 if (clear_line == TRUE) {
1065#ifdef UNIX
902ec341 1066 tputs(CE, 0, _putchar);
4f73fc56
MD
1067#else
1068 string_print(blank_line);
1069#endif /* UNIX */
902ec341 1070 putchar('\n');
4f73fc56
MD
1071 }
1072}
1073
1074/*
1075 * Flush the I/O buffer on filedescriptor fd.
1076 */
8ecf459d
SW
1077int
1078flush_buffer(int fd)
4f73fc56
MD
1079{
1080 if (out_count <= 0) /* There is nothing to flush */
902ec341 1081 return FINE;
4f73fc56
MD
1082#ifdef UNIX
1083 if (fd == STD_OUT) {
902ec341
SW
1084 printf("%.*s", out_count, screen);
1085 _flush();
4f73fc56
MD
1086 }
1087 else
1088#endif /* UNIX */
1089 if (write(fd, screen, out_count) != out_count) {
902ec341
SW
1090 bad_write(fd);
1091 return ERRORS;
4f73fc56
MD
1092 }
1093 clear_buffer(); /* Empty buffer */
1094 return FINE;
1095}
1096
1097/*
1098 * Bad_write() is called when a write failed. Notify the user.
1099 */
8ecf459d
SW
1100void
1101bad_write(int fd)
4f73fc56
MD
1102{
1103 if (fd == STD_OUT) /* Cannot write to terminal? */
902ec341
SW
1104 exit(1);
1105
4f73fc56
MD
1106 clear_buffer();
1107 build_string(text_buffer, "Command aborted: %s (File incomplete)",
902ec341
SW
1108 (errno == ENOSPC || errno == -ENOSPC) ?
1109 "No space on device" : "Write error");
4f73fc56
MD
1110 error(text_buffer, NIL_PTR);
1111}
1112
1113/*
1114 * Catch the SIGQUIT signal (^\) send to mined. It turns on the quitflag.
1115 */
8ecf459d
SW
1116void
1117catch(int sig __unused)
4f73fc56
MD
1118{
1119/* Reset the signal */
1120 signal(SIGQUIT, catch);
1121 quit = TRUE;
1122}
1123
1124/*
1125 * Abort_mined() will leave mined. Confirmation is asked first.
1126 */
8ecf459d
SW
1127void
1128abort_mined(void)
4f73fc56
MD
1129{
1130 quit = FALSE;
1131
1132/* Ask for confirmation */
1133 status_line("Really abort? ", NIL_PTR);
1134 if (getchar() != 'y') {
902ec341
SW
1135 clear_status();
1136 return;
4f73fc56
MD
1137 }
1138
1139/* Reset terminal */
1140 raw_mode(OFF);
1141 set_cursor(0, ymax);
1142 putchar('\n');
1143 flush();
1144#ifdef UNIX
1145 abort();
1146#else
1147 exit(1);
1148#endif /* UNIX */
1149}
1150
1151#define UNDEF _POSIX_VDISABLE
1152
1153/*
1154 * Set and reset tty into CBREAK or old mode according to argument `state'. It
1155 * also sets all signal characters (except for ^\) to UNDEF. ^\ is caught.
1156 */
8ecf459d
SW
1157void
1158raw_mode(FLAG state)
4f73fc56
MD
1159{
1160 static struct termios old_tty;
1161 static struct termios new_tty;
1162
1163 if (state == OFF) {
902ec341
SW
1164 tcsetattr(input_fd, TCSANOW, &old_tty);
1165 return;
4f73fc56
MD
1166 }
1167
1168/* Save old tty settings */
1169 tcgetattr(input_fd, &old_tty);
1170
1171/* Set tty to CBREAK mode */
1172 tcgetattr(input_fd, &new_tty);
1173 new_tty.c_lflag &= ~(ICANON|ECHO|ECHONL);
ad3031a0 1174 new_tty.c_iflag &= ~(IXON|IXOFF|ISIG);
4f73fc56 1175
ad3031a0 1176/* Unset remaining signal chars, leave only SIGQUIT set to ^\ */
4f73fc56
MD
1177 new_tty.c_cc[VINTR] = new_tty.c_cc[VSUSP] = UNDEF;
1178 new_tty.c_cc[VQUIT] = '\\' & 037;
1179 signal(SIGQUIT, catch); /* Which is caught */
1180
1181 tcsetattr(input_fd, TCSANOW, &new_tty);
1182}
1183
1184/*
1185 * Panic() is called with an error number and a message. It is called when
1186 * something unrecoverable has happened.
1187 * It writes the message to the terminal, resets the tty and exits.
1188 * Ask the user if he wants to save his file.
1189 */
8ecf459d
SW
1190void
1191panic(const char *message)
4f73fc56 1192{
4f73fc56
MD
1193#ifdef UNIX
1194 tputs(CL, 0, _putchar);
1195 build_string(text_buffer, "%s\nError code %d\n", message, errno);
1196#else
1197 build_string(text_buffer, "%s%s\nError code %d\n", enter_string, message, errno);
1198#endif /* UNIX */
8ecf459d 1199 write(STD_OUT, text_buffer, length_of(text_buffer));
4f73fc56
MD
1200
1201 if (loading == FALSE)
902ec341 1202 XT(0); /* Check if file can be saved */
4f73fc56 1203 else
902ec341 1204 unlink(yank_file);
4f73fc56
MD
1205 raw_mode(OFF);
1206
1207#ifdef UNIX
1208 abort();
1209#else
1210 exit(1);
1211#endif /* UNIX */
1212}
1213
c74c7be5 1214void *
8ecf459d 1215alloc(int bytes)
4f73fc56
MD
1216{
1217 char *p;
1218
1219 p = malloc((unsigned) bytes);
1220 if (p == NIL_PTR) {
1221 if (loading == TRUE)
1222 panic("File too big.");
1223 panic("Out of memory.");
1224 }
1225 return(p);
1226}
1227
8ecf459d
SW
1228void
1229free_space(char *p)
4f73fc56
MD
1230{
1231 free(p);
1232}
1233
1234/* ======================================================================== *
1235 * Main loops *
1236 * ======================================================================== */
1237
1238/* The mapping between input codes and functions. */
1239
8ecf459d 1240void (*key_map[256])(int) = { /* map ASCII characters to functions */
5ce3bad5
MD
1241 /* 000-017 */ MA, BL, MP, YA, SD, EL, MN, IF, DPC, S, S, DT, RD, S, DNW,LIB,
1242 /* 020-037 */ DPW, WB, GR, SH, DLN, SU, VI, XWT, XT, PT, ST, ESC, I, GOTO,
4f73fc56
MD
1243 HIGH, LOW,
1244 /* 040-057 */ S, S, S, S, S, S, S, S, S, S, S, S, S, S, S, S,
1245 /* 060-077 */ S, S, S, S, S, S, S, S, S, S, S, S, S, S, S, S,
1246 /* 100-117 */ S, S, S, S, S, S, S, S, S, S, S, S, S, S, S, S,
1247 /* 120-137 */ S, S, S, S, S, S, S, S, S, S, S, S, S, S, S, S,
1248 /* 140-157 */ S, S, S, S, S, S, S, S, S, S, S, S, S, S, S, S,
1249 /* 160-177 */ S, S, S, S, S, S, S, S, S, S, S, S, S, S, S, DCC,
1250 /* 200-217 */ S, S, S, S, S, S, S, S, S, S, S, S, S, S, S, S,
1251 /* 220-237 */ S, S, S, S, S, S, S, S, S, S, S, S, S, S, S, S,
1252 /* 240-257 */ S, S, S, S, S, S, S, S, S, S, S, S, S, S, S, S,
1253 /* 260-277 */ S, S, S, S, S, S, S, S, S, S, S, S, S, S, S, S,
1254 /* 300-317 */ S, S, S, S, S, S, S, S, S, S, S, S, S, S, S, S,
1255 /* 320-337 */ S, S, S, S, S, S, S, S, S, S, S, S, S, S, S, S,
1256 /* 340-357 */ S, S, S, S, S, S, S, S, S, S, S, S, S, S, S, S,
1257 /* 360-377 */ S, S, S, S, S, S, S, S, S, S, S, S, S, S, S, S,
1258};
1259
1260int nlines; /* Number of lines in file */
1261LINE *header; /* Head of line list */
1262LINE *tail; /* Last line in line list */
1263LINE *cur_line; /* Current line in use */
1264LINE *top_line; /* First line of screen */
1265LINE *bot_line; /* Last line of screen */
1266char *cur_text; /* Current char on current line in use */
1267int last_y; /* Last y of screen. Usually SCREENMAX */
1268char screen[SCREEN_SIZE]; /* Output buffer for "writes" and "reads" */
1269
1270int x, y; /* x, y coordinates on screen */
1271FLAG modified = FALSE; /* Set when file is modified */
1272FLAG stat_visible; /* Set if status_line is visible */
1273FLAG writable; /* Set if file cannot be written */
1274FLAG loading; /* Set if we are loading a file. */
1275FLAG quit = FALSE; /* Set when quit character is typed */
1276FLAG rpipe = FALSE; /* Set if file should be read from stdin */
1277int input_fd = 0; /* Fd for command input */
1278int out_count; /* Index in output buffer */
1279char file_name[LINE_LEN]; /* Name of file in use */
1280char text_buffer[MAX_CHARS]; /* Buffer for modifying text */
1281
1282/* Escape sequences. */
1283#ifdef UNIX
1284char *CE, *VS, *SO, *SE, *CL, *AL, *CM;
1285#else
8ecf459d
SW
1286const char *enter_string = "\033[H\033[J"; /* String printed on entering mined */
1287const char *pos_string = "\033[%d;%dH"; /* Absolute cursor position */
1288const char *rev_scroll = "\033M"; /* String for reverse scrolling */
1289const char *rev_video = "\033[7m"; /* String for starting reverse video */
1290const char *normal_video = "\033[m"; /* String for leaving reverse video */
1291const char *blank_line = "\033[K"; /* Clear line to end */
4f73fc56
MD
1292#endif /* UNIX */
1293
902ec341 1294/*
4f73fc56
MD
1295 * Yank variables.
1296 */
1297FLAG yank_status = NOT_VALID; /* Status of yank_file */
1298char yank_file[] = "/tmp/mined.XXXXXX";
1299long chars_saved; /* Nr of chars in buffer */
1300
1301/*
1302 * Initialize is called when a another file is edited. It free's the allocated
1303 * space and sets modified back to FALSE and fixes the header/tail pointer.
1304 */
8ecf459d
SW
1305void
1306initialize(void)
4f73fc56 1307{
8ecf459d 1308 LINE *line, *next_line;
4f73fc56
MD
1309
1310/* Delete the whole list */
1311 for (line = header->next; line != tail; line = next_line) {
902ec341
SW
1312 next_line = line->next;
1313 free_space(line->text);
1314 free_space((char*)line);
4f73fc56
MD
1315 }
1316
1317/* header and tail should point to itself */
1318 line->next = line->prev = line;
1319 x = y = 0;
1320 rpipe = modified = FALSE;
1321}
1322
1323/*
1324 * Basename() finds the absolute name of the file out of a given path_name.
1325 */
8ecf459d
SW
1326char *
1327basename(char *path)
4f73fc56 1328{
8ecf459d
SW
1329 char *ptr = path;
1330 char *last = NIL_PTR;
4f73fc56
MD
1331
1332 while (*ptr != '\0') {
902ec341
SW
1333 if (*ptr == '/')
1334 last = ptr;
1335 ptr++;
4f73fc56
MD
1336 }
1337 if (last == NIL_PTR)
902ec341 1338 return path;
4f73fc56 1339 if (*(last + 1) == '\0') { /* E.g. /usr/tmp/pipo/ */
902ec341
SW
1340 *last = '\0';
1341 return basename(path);/* Try again */
4f73fc56
MD
1342 }
1343 return last + 1;
1344}
1345
1346/*
1347 * Load_file loads the file `file' into core. If file is a NIL_PTR or the file
1348 * couldn't be opened, just some initializations are done, and a line consisting
1349 * of a `\n' is installed.
1350 */
8ecf459d
SW
1351void
1352load_file(const char *file)
4f73fc56 1353{
8ecf459d
SW
1354 LINE *line = header;
1355 int len;
4f73fc56
MD
1356 long nr_of_chars = 0L;
1357 int fd = -1; /* Filedescriptor for file */
1358
1359 nlines = 0; /* Zero lines to start with */
1360
1361/* Open file */
1362 writable = TRUE; /* Benefit of the doubt */
1363 if (file == NIL_PTR) {
1364 if (rpipe == FALSE)
902ec341 1365 status_line("No file.", NIL_PTR);
4f73fc56
MD
1366 else {
1367 fd = 0;
1368 file = "standard input";
1369 }
1370 file_name[0] = '\0';
1371 }
1372 else {
902ec341
SW
1373 copy_string(file_name, file); /* Save file name */
1374 if (access(file, 0) < 0) /* Cannot access file. */
1375 status_line("New file ", file);
1376 else if ((fd = open(file, 0)) < 0)
1377 status_line("Cannot open ", file);
1378 else if (access(file, 2) != 0) /* Set write flag */
1379 writable = FALSE;
4f73fc56
MD
1380 }
1381
1382/* Read file */
1383 loading = TRUE; /* Loading file, so set flag */
1384
1385 if (fd >= 0) {
902ec341
SW
1386 status_line("Reading ", file);
1387 while ((len = get_line(fd, text_buffer)) != ERRORS) {
1388 line = line_insert(line, text_buffer, len);
1389 nr_of_chars += (long) len;
1390 }
1391 if (nlines == 0) /* The file was empty! */
1392 line = line_insert(line, "\n", 1);
1393 clear_buffer(); /* Clear output buffer */
1394 cur_line = header->next;
1395 fstatus("Read", nr_of_chars);
1396 close(fd); /* Close file */
4f73fc56
MD
1397 }
1398 else /* Just install a "\n" */
902ec341 1399 line_insert(line, "\n", 1);
4f73fc56
MD
1400
1401 reset(header->next, 0); /* Initialize pointers */
1402
1403/* Print screen */
1404 display (0, 0, header->next, last_y);
1405 move_to (0, 0);
1406 flush(); /* Flush buffer */
1407 loading = FALSE; /* Stop loading, reset flag */
1408}
1409
1410
1411/*
1412 * Get_line reads one line from filedescriptor fd. If EOF is reached on fd,
1413 * get_line() returns ERRORS, else it returns the length of the string.
1414 */
8ecf459d
SW
1415int
1416get_line(int fd, char *buffer)
4f73fc56
MD
1417{
1418 static char *last = NIL_PTR;
1419 static char *current = NIL_PTR;
1420 static int read_chars;
8ecf459d 1421 char *cur_pos = current;
4f73fc56
MD
1422 char *begin = buffer;
1423
1424 do {
902ec341
SW
1425 if (cur_pos == last) {
1426 if ((read_chars = read(fd, screen, SCREEN_SIZE)) <= 0)
1427 break;
1428 last = &screen[read_chars];
1429 cur_pos = screen;
1430 }
4f73fc56
MD
1431 if (*cur_pos == '\0')
1432 *cur_pos = ' ';
1433 } while ((*buffer++ = *cur_pos++) != '\n');
1434
1435 current = cur_pos;
1436 if (read_chars <= 0) {
902ec341
SW
1437 if (buffer == begin)
1438 return ERRORS;
1439 if (*(buffer - 1) != '\n') {
1440 if (loading == TRUE) /* Add '\n' to last line of file */
1441 *buffer++ = '\n';
1442 else {
1443 *buffer = '\0';
1444 return NO_LINE;
1445 }
8ecf459d 1446 }
4f73fc56
MD
1447 }
1448
1449 *buffer = '\0';
1450 return buffer - begin;
1451}
1452
1453/*
1454 * Install_line installs the buffer into a LINE structure It returns a pointer
1455 * to the allocated structure.
1456 */
8ecf459d
SW
1457LINE *
1458install_line(const char *buffer, int length)
4f73fc56 1459{
8ecf459d 1460 LINE *new_line = (LINE *) alloc(sizeof(LINE));
4f73fc56
MD
1461
1462 new_line->text = alloc(length + 1);
1463 new_line->shift_count = 0;
1464 copy_string(new_line->text, buffer);
1465
1466 return new_line;
1467}
1468
902ec341 1469int
8ecf459d 1470main(int argc, char *argv[])
4f73fc56
MD
1471{
1472/* mined is the Minix editor. */
1473
8ecf459d 1474 int index; /* Index in key table */
4f73fc56
MD
1475 struct winsize winsize;
1476
1477#ifdef UNIX
1478 get_term();
1479 tputs(VS, 0, _putchar);
1480 tputs(CL, 0, _putchar);
1481#else
1482 string_print(enter_string); /* Hello world */
1483#endif /* UNIX */
1484 if (ioctl(STD_OUT, TIOCGWINSZ, &winsize) == 0 && winsize.ws_row != 0) {
1485 ymax = winsize.ws_row - 1;
1486 screenmax = ymax - 1;
1487 }
1488
1489 if (!isatty(0)) { /* Reading from pipe */
1490 if (argc != 1) {
1491 write(2, "Cannot find terminal.\n", 22);
1492 exit (1);
1493 }
1494 rpipe = TRUE;
1495 modified = TRUE; /* Set modified so he can write */
1496 open_device();
1497 }
1498
1499 raw_mode(ON); /* Set tty to appropriate mode */
1500
1501 header = tail = (LINE *) alloc(sizeof(LINE)); /* Make header of list*/
1502 header->text = NIL_PTR;
1503 header->next = tail->prev = header;
1504
1505/* Load the file (if any) */
1506 if (argc < 2)
902ec341 1507 load_file(NIL_PTR);
4f73fc56 1508 else {
902ec341
SW
1509 get_file(NIL_PTR, argv[1]); /* Truncate filename */
1510 load_file(argv[1]);
4f73fc56
MD
1511 }
1512
1513 /* Main loop of the editor. */
1514 for (;;) {
902ec341
SW
1515 index = getchar();
1516 if (stat_visible == TRUE)
1517 clear_status();
1518 if (quit == TRUE)
1519 abort_mined();
1520 else { /* Call the function for this key */
1521 (*key_map[index])(index);
1522 flush(); /* Flush output (if any) */
1523 if (quit == TRUE)
1524 quit = FALSE;
1525 }
4f73fc56
MD
1526 }
1527 /* NOTREACHED */
1528}
1529
1530/* ======================================================================== *
1531 * Miscellaneous *
1532 * ======================================================================== */
1533
1534/*
1535 * Redraw the screen
1536 */
8ecf459d
SW
1537void
1538RD(int u __unused)
4f73fc56
MD
1539{
1540/* Clear screen */
1541#ifdef UNIX
1542 tputs(VS, 0, _putchar);
1543 tputs(CL, 0, _putchar);
1544#else
1545 string_print(enter_string);
1546#endif /* UNIX */
1547
1548/* Print first page */
1549 display(0, 0, top_line, last_y);
1550
1551/* Clear last line */
1552 set_cursor(0, ymax);
1553#ifdef UNIX
1554 tputs(CE, 0, _putchar);
1555#else
1556 string_print(blank_line);
1557#endif /* UNIX */
1558 move_to(x, y);
1559}
1560
1561/*
1562 * Ignore this keystroke.
1563 */
8ecf459d
SW
1564void
1565I(int u __unused)
4f73fc56
MD
1566{
1567}
1568
1569/*
1570 * Leave editor. If the file has changed, ask if the user wants to save it.
1571 */
8ecf459d
SW
1572void
1573XT(int u __unused)
4f73fc56
MD
1574{
1575 if (modified == TRUE && ask_save() == ERRORS)
902ec341 1576 return;
4f73fc56
MD
1577
1578 raw_mode(OFF);
1579 set_cursor(0, ymax);
1580 putchar('\n');
1581 flush();
8ecf459d 1582 unlink(yank_file); /* Might not be necessary */
4f73fc56
MD
1583 exit(0);
1584}
1585
8ecf459d
SW
1586static void
1587(*escfunc(int c))(int)
4f73fc56
MD
1588{
1589#if (CHIP == M68000)
1590#ifndef COMPAT
1591 int ch;
1592#endif
1593#endif
1594 if (c == '[') {
1595 /* Start of ASCII escape sequence. */
1596 c = getchar();
1597#if (CHIP == M68000)
1598#ifndef COMPAT
1599 if ((c >= '0') && (c <= '9')) ch = getchar();
1600 /* ch is either a tilde or a second digit */
1601#endif
1602#endif
1603 switch (c) {
1604 case 'H': return(HO);
1605 case 'A': return(UP);
1606 case 'B': return(DN);
1607 case 'C': return(RT);
1608 case 'D': return(LF);
1609#if (CHIP == M68000)
1610#ifndef COMPAT
1611 /* F1 = ESC [ 1 ~ */
1612 /* F2 = ESC [ 2 ~ */
1613 /* F3 = ESC [ 3 ~ */
1614 /* F4 = ESC [ 4 ~ */
1615 /* F5 = ESC [ 5 ~ */
1616 /* F6 = ESC [ 6 ~ */
1617 /* F7 = ESC [ 17 ~ */
1618 /* F8 = ESC [ 18 ~ */
902ec341
SW
1619 case '1':
1620 switch (ch) {
4f73fc56 1621 case '~': return(SF);
8ecf459d
SW
1622 case '7': getchar(); return(MA);
1623 case '8': getchar(); return(CTL);
4f73fc56
MD
1624 }
1625 case '2': return(SR);
1626 case '3': return(PD);
1627 case '4': return(PU);
1628 case '5': return(FS);
1629 case '6': return(EF);
1630#endif
1631#endif
1632#if (CHIP == INTEL)
f5812cdf
MD
1633#ifdef ASSUME_CONS25
1634 case 'G': return(PD);
1635 case 'I': return(PU);
1636 case 'F': return(EF);
1637 /* F1 - help */
1638 case 'M': return(HLP);
1639 /* F2 - file status */
1640 case 'N': return(FS);
1641 /* F3 - search fwd */
1642 case 'O': return(SF);
1643 /* Shift-F3 - search back */
1644 case 'a':return(SR);
1645 /* F4 - global replace */
1646 case 'P': return(GR);
1647 /* Shift-F4 - line replace */
1648 case 'b': return(LR);
1649#else
4f73fc56
MD
1650 case 'G': return(FS);
1651 case 'S': return(SR);
1652 case 'T': return(SF);
1653 case 'U': return(PD);
1654 case 'V': return(PU);
1655 case 'Y': return(EF);
f5812cdf 1656#endif
4f73fc56
MD
1657#endif
1658 }
1659 return(I);
1660 }
4bb7b1ff
MD
1661#ifdef ASSUME_XTERM
1662 if (c == 'O') {
1663 /* Start of ASCII function key escape sequence. */
1664 switch (getchar()) {
1665 case 'P': return(HLP); /* F1 */
1666 case 'Q': return(FS); /* F2 */
1667 case 'R': return(SF); /* F3 */
1668 case 'S': return(GR); /* F4 */
1669 case '2':
1670 switch (getchar()) {
1671 case 'R': return(SR); /* shift-F3 */
1672 }
1673 break;
1674 }
1675 }
1676#endif
4f73fc56
MD
1677#if (CHIP == M68000)
1678#ifdef COMPAT
1679 if (c == 'O') {
1680 /* Start of ASCII function key escape sequence. */
1681 switch (getchar()) {
1682 case 'P': return(SF);
1683 case 'Q': return(SR);
1684 case 'R': return(PD);
1685 case 'S': return(PU);
1686 case 'T': return(FS);
1687 case 'U': return(EF);
1688 case 'V': return(MA);
1689 case 'W': return(CTL);
1690 }
1691 }
1692#endif
1693#endif
1694 return(I);
1695}
1696
1697/*
902ec341 1698 * ESC() wants a count and a command after that. It repeats the
4f73fc56
MD
1699 * command count times. If a ^\ is given during repeating, stop looping and
1700 * return to main loop.
1701 */
8ecf459d
SW
1702void
1703ESC(int u __unused)
4f73fc56 1704{
8ecf459d
SW
1705 int count = 0;
1706 void (*func)(int);
4f73fc56
MD
1707 int index;
1708
1709 index = getchar();
1710 while (index >= '0' && index <= '9' && quit == FALSE) {
902ec341
SW
1711 count *= 10;
1712 count += index - '0';
1713 index = getchar();
4f73fc56
MD
1714 }
1715 if (count == 0) {
1716 count = 1;
1717 func = escfunc(index);
1718 } else {
1719 func = key_map[index];
1720 if (func == ESC)
1721 func = escfunc(getchar());
1722 }
1723
1724 if (func == I) { /* Function assigned? */
902ec341
SW
1725 clear_status();
1726 return;
4f73fc56
MD
1727 }
1728
1729 while (count-- > 0 && quit == FALSE) {
902ec341
SW
1730 if (stat_visible == TRUE)
1731 clear_status();
1732 (*func)(index);
1733 flush();
4f73fc56
MD
1734 }
1735
1736 if (quit == TRUE) /* Abort has been given */
902ec341 1737 error("Aborted", NIL_PTR);
4f73fc56
MD
1738}
1739
1740/*
1741 * Ask the user if he wants to save his file or not.
1742 */
8ecf459d
SW
1743int
1744ask_save(void)
4f73fc56 1745{
8ecf459d 1746 int c;
4f73fc56
MD
1747
1748 status_line(file_name[0] ? basename(file_name) : "[buffer]" ,
1749 " has been modified. Save? (y/n)");
1750
1751 while((c = getchar()) != 'y' && c != 'n' && quit == FALSE) {
902ec341
SW
1752 ring_bell();
1753 flush();
4f73fc56
MD
1754 }
1755
1756 clear_status();
1757
1758 if (c == 'y')
902ec341 1759 return WT();
4f73fc56
MD
1760
1761 if (c == 'n')
902ec341 1762 return FINE;
4f73fc56
MD
1763
1764 quit = FALSE; /* Abort character has been given */
1765 return ERRORS;
1766}
1767
1768/*
1769 * Line_number() finds the line number we're on.
1770 */
8ecf459d
SW
1771int
1772line_number(void)
4f73fc56 1773{
8ecf459d
SW
1774 LINE *line = header->next;
1775 int count = 1;
4f73fc56
MD
1776
1777 while (line != cur_line) {
902ec341
SW
1778 count++;
1779 line = line->next;
4f73fc56 1780 }
902ec341 1781
4f73fc56
MD
1782 return count;
1783}
902ec341 1784
4f73fc56
MD
1785/*
1786 * Display a line telling how many chars and lines the file contains. Also tell
1787 * whether the file is readonly and/or modified.
8ecf459d
SW
1788 *
1789 * parameter
1790 * count: Contains number of characters in file
4f73fc56 1791 */
8ecf459d
SW
1792void
1793file_status(const char *message, long count, char *file, int lines,
1794 FLAG writefl, FLAG changed)
4f73fc56 1795{
8ecf459d 1796 LINE *line;
4f73fc56
MD
1797 char msg[LINE_LEN + 40];/* Buffer to hold line */
1798 char yank_msg[LINE_LEN];/* Buffer for msg of yank_file */
1799
1800 if (count < 0) /* Not valid. Count chars in file */
902ec341
SW
1801 for (line = header->next; line != tail; line = line->next)
1802 count += length_of(line->text);
4f73fc56
MD
1803
1804 if (yank_status != NOT_VALID) /* Append buffer info */
902ec341 1805 build_string(yank_msg, " Buffer: %D char%s.", chars_saved,
4f73fc56
MD
1806 (chars_saved == 1L) ? "" : "s");
1807 else
902ec341 1808 yank_msg[0] = '\0';
4f73fc56
MD
1809
1810 build_string(msg, "%s %s%s%s %d line%s %D char%s.%s Line %d", message,
902ec341
SW
1811 (rpipe == TRUE && *message != '[') ? "standard input" : basename(file),
1812 (changed == TRUE) ? "*" : "",
1813 (writefl == FALSE) ? " (Readonly)" : "",
1814 lines, (lines == 1) ? "" : "s",
4f73fc56
MD
1815 count, (count == 1L) ? "" : "s",
1816 yank_msg, line_number());
1817
1818 if (length_of(msg) + 1 > LINE_LEN - 4) {
902ec341
SW
1819 msg[LINE_LEN - 4] = SHIFT_MARK; /* Overflow on status line */
1820 msg[LINE_LEN - 3] = '\0';
4f73fc56
MD
1821 }
1822 status_line(msg, NIL_PTR); /* Print the information */
1823}
1824
1825/*
1826 * Build_string() prints the arguments as described in fmt, into the buffer.
1827 * %s indicates an argument string, %d indicated an argument number.
1828 */
8ecf459d
SW
1829void
1830build_string(char *buf, const char *fmt, ...)
4f73fc56 1831{
4f73fc56 1832 va_list argptr;
8ecf459d 1833 const char *scanp;
4f73fc56 1834
4f73fc56 1835 va_start(argptr, fmt);
4f73fc56
MD
1836
1837 while (*fmt) {
902ec341
SW
1838 if (*fmt == '%') {
1839 fmt++;
1840 switch (*fmt++) {
1841 case 's' :
1842 scanp = va_arg(argptr, char *);
1843 break;
1844 case 'd' :
1845 scanp = num_out((long) va_arg(argptr, int));
1846 break;
1847 case 'D' :
1848 scanp = num_out((long) va_arg(argptr, long));
1849 break;
1850 default :
1851 scanp = "";
1852 }
1853 while ((*buf++ = *scanp++) != 0)
1854 ;
1855 buf--;
1856 }
1857 else
1858 *buf++ = *fmt++;
4f73fc56
MD
1859 }
1860 va_end(argptr);
1861 *buf = '\0';
1862}
1863
1864/*
1865 * Output an (unsigned) long in a 10 digit field without leading zeros.
1866 * It returns a pointer to the first digit in the buffer.
1867 */
8ecf459d
SW
1868char *
1869num_out(long number)
4f73fc56
MD
1870{
1871 static char num_buf[11]; /* Buffer to build number */
8ecf459d
SW
1872 long digit; /* Next digit of number */
1873 long pow = 1000000000L; /* Highest ten power of long */
4f73fc56
MD
1874 FLAG digit_seen = FALSE;
1875 int i;
1876
1877 for (i = 0; i < 10; i++) {
902ec341
SW
1878 digit = number / pow; /* Get next digit */
1879 if (digit == 0L && digit_seen == FALSE && i != 9)
1880 num_buf[i] = ' ';
1881 else {
1882 num_buf[i] = '0' + (char) digit;
1883 number -= digit * pow; /* Erase digit */
1884 digit_seen = TRUE;
1885 }
1886 pow /= 10L; /* Get next digit */
4f73fc56
MD
1887 }
1888 for (i = 0; num_buf[i] == ' '; i++) /* Skip leading spaces */
902ec341 1889 ;
4f73fc56
MD
1890 return (&num_buf[i]);
1891}
1892
1893/*
1894 * Get_number() read a number from the terminal. The last character typed in is
1895 * returned. ERRORS is returned on a bad number. The resulting number is put
1896 * into the integer the arguments points to.
1897 */
8ecf459d
SW
1898int
1899get_number(const char *message, int *result)
4f73fc56 1900{
8ecf459d
SW
1901 int index;
1902 int count = 0;
4f73fc56
MD
1903
1904 status_line(message, NIL_PTR);
1905
1906 index = getchar();
1907 if (quit == FALSE && (index < '0' || index > '9')) {
902ec341
SW
1908 error("Bad count", NIL_PTR);
1909 return ERRORS;
4f73fc56
MD
1910 }
1911
1912/* Convert input to a decimal number */
1913 while (index >= '0' && index <= '9' && quit == FALSE) {
902ec341
SW
1914 count *= 10;
1915 count += index - '0';
1916 index = getchar();
4f73fc56
MD
1917 }
1918
1919 if (quit == TRUE) {
902ec341
SW
1920 clear_status();
1921 return ERRORS;
4f73fc56
MD
1922 }
1923
1924 *result = count;
1925 return index;
1926}
1927
1928/*
1929 * Input() reads a string from the terminal. When the KILL character is typed,
1930 * it returns ERRORS.
1931 */
8ecf459d
SW
1932int
1933input(char *inbuf, FLAG clearfl)
4f73fc56 1934{
8ecf459d
SW
1935 char *ptr;
1936 char c; /* Character read */
4f73fc56
MD
1937
1938 ptr = inbuf;
1939
1940 *ptr = '\0';
1941 while (quit == FALSE) {
902ec341
SW
1942 flush();
1943 switch (c = getchar()) {
1944 case '\b' : /* Erase previous char */
1945 if (ptr > inbuf) {
1946 ptr--;
4f73fc56 1947#ifdef UNIX
902ec341 1948 tputs(SE, 0, _putchar);
4f73fc56 1949#else
902ec341 1950 string_print(normal_video);
4f73fc56 1951#endif /* UNIX */
902ec341
SW
1952 if (is_tab(*ptr))
1953 string_print(" \b\b\b \b\b");
1954 else
1955 string_print(" \b\b \b");
4f73fc56 1956#ifdef UNIX
902ec341 1957 tputs(SO, 0, _putchar);
4f73fc56 1958#else
902ec341 1959 string_print(rev_video);
4f73fc56 1960#endif /* UNIX */
902ec341
SW
1961 string_print(" \b");
1962 *ptr = '\0';
1963 }
1964 else
1965 ring_bell();
1966 break;
1967 case '\n' : /* End of input */
1968 /* If inbuf is empty clear status_line */
1969 return (ptr == inbuf && clearfl == TRUE) ? NO_INPUT :FINE;
1970 default : /* Only read ASCII chars */
1971 if ((c >= ' ' && c <= '~') || c == '\t') {
1972 *ptr++ = c;
1973 *ptr = '\0';
1974 if (c == '\t')
1975 string_print("^I");
1976 else
1977 putchar(c);
1978 string_print(" \b");
1979 }
1980 else
1981 ring_bell();
1982 }
4f73fc56
MD
1983 }
1984 quit = FALSE;
1985 return ERRORS;
1986}
1987
1988/*
902ec341 1989 * Get_file() reads a filename from the terminal. Filenames longer than
4f73fc56
MD
1990 * FILE_LENGHT chars are truncated.
1991 */
8ecf459d
SW
1992int
1993get_file(const char *message, char *file)
4f73fc56
MD
1994{
1995 char *ptr;
8ecf459d 1996 int ret = FINE;
4f73fc56
MD
1997
1998 if (message == NIL_PTR || (ret = get_string(message, file, TRUE)) == FINE) {
902ec341
SW
1999 if (length_of((ptr = basename(file))) > NAME_MAX)
2000 ptr[NAME_MAX] = '\0';
4f73fc56
MD
2001 }
2002 return ret;
2003}
2004
2005/* ======================================================================== *
2006 * UNIX I/O Routines *
2007 * ======================================================================== */
2008
2009#ifdef UNIX
2010#undef putchar
2011
8ecf459d
SW
2012int
2013_getchar(void)
4f73fc56
MD
2014{
2015 char c;
2016
2017 if (read(input_fd, &c, 1) != 1 && quit == FALSE)
2018 panic ("Cannot read 1 byte from input");
2019 return c & 0377;
2020}
2021
8ecf459d
SW
2022void
2023_flush(void)
4f73fc56 2024{
8ecf459d 2025 fflush(stdout);
4f73fc56
MD
2026}
2027
8ecf459d
SW
2028void
2029_putchar(char c)
4f73fc56 2030{
8ecf459d 2031 write_char(STD_OUT, c);
4f73fc56
MD
2032}
2033
8ecf459d
SW
2034void
2035get_term(void)
4f73fc56
MD
2036{
2037 static char termbuf[50];
4f73fc56
MD
2038 char *loc = termbuf;
2039 char entry[1024];
2040
2041 if (tgetent(entry, getenv("TERM")) <= 0) {
902ec341
SW
2042 printf("Unknown terminal.\n");
2043 exit(1);
4f73fc56
MD
2044 }
2045
2046 AL = tgetstr("al", &loc);
2047 CE = tgetstr("ce", &loc);
2048 VS = tgetstr("vs", &loc);
2049 CL = tgetstr("cl", &loc);
2050 SO = tgetstr("so", &loc);
2051 SE = tgetstr("se", &loc);
2052 CM = tgetstr("cm", &loc);
2053 ymax = tgetnum("li") - 1;
2054 screenmax = ymax - 1;
2055
2056 if (!CE || !SO || !SE || !CL || !AL || !CM) {
902ec341
SW
2057 printf("Sorry, no mined on this type of terminal\n");
2058 exit(1);
4f73fc56
MD
2059 }
2060}
2061#endif /* UNIX */