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