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