2 * Copyright (c) 1987,1997, Prentice Hall
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:
9 * * Redistributions of source code must retain the above copyright
10 * notice, this list of conditions and the following disclaimer.
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.
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
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.
35 * [original code from minix codebase]
36 * $DragonFly: src/bin/mined/mined1.c,v 1.6 2005/04/29 09:14:50 joerg Exp $*
39 * Part one of the mined editor.
43 * Ported to FreeBSD by Andrzej Bialecki <abial@freebsd.org>, Oct 1998
45 * Added a help screen, and remapped some of the wildest keybindings...
49 * Author: Michiel Huisjes.
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.
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.
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
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.
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.
104 * 2. Regular expressions
106 * Mined has a build in regular expression matcher, which is used for
107 * searching and replace routines. A regular expression consists of a
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
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
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.
131 * 3. Implementation of mined.
133 * 3.1 Data structures.
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:
138 * typedef struct Line {
142 * unsigned char shift_count;
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.
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.
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).
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.
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
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.
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
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
213 * 3.4 Modifying text.
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).
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.
254 * 3.6 Search and replace routines.
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:
261 * typedef struct regex {
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
318 * 3.6 Miscellaneous commands.
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.
329 * 3.7 Utility functions.
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
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
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
392 * 4. Summary of commands.
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
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)
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
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)
446 /* ======================================================================== *
448 * ======================================================================== */
455 #include <sys/wait.h>
456 #include <sys/ioctl.h>
464 int screenmax = SCREENMAX;
472 fstatus(file_name[0] ? "" : "[buffer]", -1L);
476 * Visit (edit) another file. If the file has been modified, ask the user if
477 * he wants to save it.
481 char new_file[LINE_LEN]; /* Buffer to hold new file name */
483 if (modified == TRUE && ask_save() == ERRORS)
486 /* Get new file name */
487 if (get_file("Visit file:", new_file) == ERRORS)
490 /* Free old linked list, initialize global variables and load new file */
493 tputs(CL, 0, _putchar);
495 string_print (enter_string);
497 load_file(new_file[0] == '\0' ? NIL_PTR : new_file);
501 * Write file in core to disc.
506 register long count = 0L; /* Nr of chars written */
507 char file[LINE_LEN]; /* Buffer for new file name */
508 int fd; /* Filedescriptor of file */
510 if (modified == FALSE) {
511 error ("Write not necessary.", NIL_PTR);
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)
519 copy_string(file_name, file); /* Save file name */
521 if ((fd = creat(file_name, 0644)) < 0) { /* Empty file */
522 error("Cannot create ", file_name);
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')
537 if (writeline(fd, line->text) == ERRORS) {
541 count += (long) length_of(line->text);
544 if (count > 0L && flush_buffer(fd) == ERRORS)
553 rpipe = FALSE; /* File name is now assigned */
555 /* Display how many chars (and lines) were written */
556 fstatus("Wrote", count);
560 /* Call WT and discard value returned. */
569 * Call an interactive shell.
577 if ((shell = getenv("SHELL")) == NIL_PTR) shell = "/bin/sh";
579 switch (pid = fork()) {
581 error("Cannot fork.", NIL_PTR);
583 case 0: /* This is the child */
588 if (rpipe) { /* Fix stdin */
590 if (open("/dev/tty", 0) < 0)
593 execl(shell, shell, (char *) 0);
594 exit(127); /* Exit with 127 */
595 default : /* This is the parent */
596 signal(SIGINT, SIG_IGN);
597 signal(SIGQUIT, SIG_IGN);
600 } while (w != -1 && w != pid);
606 if ((status >> 8) == 127) /* Child died with 127 */
607 error("Cannot exec ", shell);
608 else if ((status >> 8) == 126)
609 error("Cannot open /dev/tty as fd #0", NIL_PTR);
613 * Proceed returns the count'th line after `line'. When count is negative
614 * it returns the count'th line before `line'. When the next (previous)
615 * line is the tail (header) indicating EOF (tof) it stops.
617 LINE *proceed(line, count)
622 while (count++ < 0 && line != header)
625 while (count-- > 0 && line != tail)
631 * Show concatenation of s1 and s2 on the status line (bottom of screen)
632 * If revfl is TRUE, turn on reverse video on both strings. Set stat_visible
633 * only if bottom_line is visible.
635 int bottom_line(revfl, s1, s2, inbuf, statfl)
643 register char *p = buf;
655 if (revfl == ON && stat_visible == TRUE)
658 if (revfl == ON) { /* Print rev. start sequence */
660 tputs(SO, 0, _putchar);
662 string_print(rev_video);
666 else /* Used as clear_status() */
667 stat_visible = FALSE;
671 if (inbuf != NIL_PTR)
672 ret = input(inbuf, statfl);
674 /* Print normal video */
676 tputs(SE, 0, _putchar);
677 tputs(CE, 0, _putchar);
679 string_print(normal_video);
680 string_print(blank_line); /* Clear the rest of the line */
682 if (inbuf != NIL_PTR)
685 set_cursor(x, y); /* Set cursor back to old position */
686 flush(); /* Perform the actual write */
693 * Count_chars() count the number of chars that the line would occupy on the
694 * screen. Counting starts at the real x-coordinate of the line.
696 int count_chars(line)
699 register int cnt = get_shift(line->shift_count) * -SHIFT_SIZE;
700 register char *textp = line->text;
702 /* Find begin of line on screen */
704 if (is_tab(*textp++))
710 /* Count number of chars left */
712 while (*textp != '\n') {
713 if (is_tab(*textp++))
722 * Move to coordinates nx, ny at screen. The caller must check that scrolling
724 * If new_x is lower than 0 or higher than XBREAK, move_to() will check if
725 * the line can be shifted. If it can it sets(or resets) the shift_count field
726 * of the current line accordingly.
727 * Move also sets cur_text to the right char.
728 * If we're moving to the same x coordinate, try to move the the x-coordinate
729 * used on the other previous call.
731 void move(new_x, new_address, new_y)
736 register LINE *line = cur_line; /* For building new cur_line */
737 int shift = 0; /* How many shifts to make */
738 static int rel_x = 0; /* Remember relative x position */
741 /* Check for illegal values */
742 if (new_y < 0 || new_y > last_y)
745 /* Adjust y-coordinate and cur_line */
748 if(line->shift_count>0) {
751 string_print(blank_line);
759 if(line->shift_count>0) {
762 string_print(blank_line);
769 /* Set or unset relative x-coordinate */
770 if (new_address == NIL_PTR) {
771 new_address = find_address(line, (new_x == x) ? rel_x : new_x , &tx);
777 rel_x = new_x = find_x(line, new_address);
780 /* Adjust shift_count if new_x lower than 0 or higher than XBREAK */
781 if (new_x < 0 || new_x >= XBREAK) {
782 if (new_x > XBREAK || (new_x == XBREAK && *new_address != '\n'))
783 shift = (new_x - XBREAK) / SHIFT_SIZE + 1;
785 shift = new_x / SHIFT_SIZE;
786 if (new_x % SHIFT_SIZE)
791 line->shift_count += shift;
792 new_x = find_x(line, new_address);
799 /* Assign and position cursor */
801 cur_text = new_address;
807 * Find_x() returns the x coordinate belonging to address.
808 * (Tabs are expanded).
810 int find_x(line, address)
814 register char *textp = line->text;
815 register int nx = get_shift(line->shift_count) * -SHIFT_SIZE;
817 while (textp != address && *textp != '\0') {
818 if (is_tab(*textp++)) /* Expand tabs */
827 * Find_address() returns the pointer in the line with offset x_coord.
828 * (Tabs are expanded).
830 char *find_address(line, x_coord, old_x)
835 register char *textp = line->text;
836 register int tx = get_shift(line->shift_count) * -SHIFT_SIZE;
838 while (tx < x_coord && *textp != '\n') {
839 if (is_tab(*textp)) {
840 if (*old_x - x_coord == 1 && tab(tx) > x_coord)
841 break; /* Moving left over tab */
855 * Length_of() returns the number of characters int the string `string'
856 * excluding the '\0'.
858 int length_of(string)
859 register char *string;
861 register int count = 0;
863 if (string != NIL_PTR) {
864 while (*string++ != '\0')
871 * Copy_string() copies the string `from' into the string `to'. `To' must be
872 * long enough to hold `from'.
874 void copy_string(to, from)
878 while (*to++ = *from++)
883 * Reset assigns bot_line, top_line and cur_line according to `head_line'
884 * which must be the first line of the screen, and an y-coordinate,
885 * which will be the current y-coordinate (if it isn't larger than last_y)
887 void reset(head_line, screen_y)
893 top_line = line = head_line;
895 /* Search for bot_line (might be last line in file) */
896 for (last_y = 0; last_y < nlines - 1 && last_y < screenmax
897 && line->next != tail; last_y++)
901 y = (screen_y > last_y) ? last_y : screen_y;
903 /* Set cur_line according to the new y value */
904 cur_line = proceed(top_line, y);
908 * Set cursor at coordinates x, y.
910 void set_cursor(nx, ny)
914 extern char *tgoto();
916 tputs(tgoto(CM, nx, ny), 0, _putchar);
918 char text_buffer[10];
920 build_string(text_buffer, pos_string, ny+1, nx+1);
921 string_print(text_buffer);
926 * Routine to open terminal when mined is used in a pipeline.
930 if ((input_fd = open("/dev/tty", 0)) < 0)
931 panic("Cannot open /dev/tty for read");
935 * Getchar() reads one character from the terminal. The character must be
936 * masked with 0377 to avoid sign extension.
941 return (_getchar() & 0377);
945 if (read(input_fd, &c, 1) != 1 && quit == FALSE)
946 panic("Can't read one char from fd #0");
953 * Display() shows count lines on the terminal starting at the given
954 * coordinates. When the tail of the list is encountered it will fill the
955 * rest of the screen with blank_line's.
956 * When count is negative, a backwards print from `line' will be done.
958 void display(x_coord, y_coord, line, count)
959 int x_coord, y_coord;
963 set_cursor(x_coord, y_coord);
965 /* Find new startline if count is negative */
967 line = proceed(line, count);
971 /* Print the lines */
972 while (line != tail && count-- >= 0) {
978 /* Print the blank lines (if any) */
979 if (loading == FALSE) {
980 while (count-- >= 0) {
982 tputs(CE, 0, _putchar);
984 string_print(blank_line);
992 * Write_char does a buffered output.
994 int write_char(fd, c)
998 screen [out_count++] = c;
999 if (out_count == SCREEN_SIZE) /* Flush on SCREEN_SIZE chars */
1000 return flush_buffer(fd);
1005 * Writeline writes the given string on the given filedescriptor.
1007 int writeline(fd, text)
1009 register char *text;
1012 if (write_char(fd, *text++) == ERRORS)
1018 * Put_line print the given line on the standard output. If offset is not zero
1019 * printing will start at that x-coordinate. If the FLAG clear_line is TRUE,
1020 * then (screen) line will be cleared when the end of the line has been
1023 void put_line(line, offset, clear_line)
1024 LINE *line; /* Line to print */
1025 int offset; /* Offset to start */
1026 FLAG clear_line; /* Clear to eoln if TRUE */
1028 register char *textp = line->text;
1029 register int count = get_shift(line->shift_count) * -SHIFT_SIZE;
1030 int tab_count; /* Used in tab expansion */
1032 /* Skip all chars as indicated by the offset and the shift_count field */
1033 while (count < offset) {
1034 if (is_tab(*textp++))
1040 while (*textp != '\n' && count < XBREAK) {
1041 if (is_tab(*textp)) { /* Expand tabs to spaces */
1042 tab_count = tab(count);
1043 while (count < XBREAK && count < tab_count) {
1050 if (*textp >= '\01' && *textp <= '\037') {
1052 tputs(SO, 0, _putchar);
1054 string_print (rev_video);
1056 putchar(*textp++ + '\100');
1058 tputs(SE, 0, _putchar);
1060 string_print (normal_video);
1069 /* If line is longer than XBREAK chars, print the shift_mark */
1070 if (count == XBREAK && *textp != '\n')
1071 putchar(textp[1]=='\n' ? *textp : SHIFT_MARK);
1073 /* Clear the rest of the line is clear_line is TRUE */
1074 if (clear_line == TRUE) {
1076 tputs(CE, 0, _putchar);
1078 string_print(blank_line);
1085 * Flush the I/O buffer on filedescriptor fd.
1087 int flush_buffer(fd)
1090 if (out_count <= 0) /* There is nothing to flush */
1093 if (fd == STD_OUT) {
1094 printf("%.*s", out_count, screen);
1099 if (write(fd, screen, out_count) != out_count) {
1103 clear_buffer(); /* Empty buffer */
1108 * Bad_write() is called when a write failed. Notify the user.
1113 if (fd == STD_OUT) /* Cannot write to terminal? */
1117 build_string(text_buffer, "Command aborted: %s (File incomplete)",
1118 (errno == ENOSPC || errno == -ENOSPC) ?
1119 "No space on device" : "Write error");
1120 error(text_buffer, NIL_PTR);
1124 * Catch the SIGQUIT signal (^\) send to mined. It turns on the quitflag.
1129 /* Reset the signal */
1130 signal(SIGQUIT, catch);
1135 * Abort_mined() will leave mined. Confirmation is asked first.
1141 /* Ask for confirmation */
1142 status_line("Really abort? ", NIL_PTR);
1143 if (getchar() != 'y') {
1148 /* Reset terminal */
1150 set_cursor(0, ymax);
1160 #define UNDEF _POSIX_VDISABLE
1163 * Set and reset tty into CBREAK or old mode according to argument `state'. It
1164 * also sets all signal characters (except for ^\) to UNDEF. ^\ is caught.
1166 void raw_mode(state)
1169 static struct termios old_tty;
1170 static struct termios new_tty;
1173 tcsetattr(input_fd, TCSANOW, &old_tty);
1177 /* Save old tty settings */
1178 tcgetattr(input_fd, &old_tty);
1180 /* Set tty to CBREAK mode */
1181 tcgetattr(input_fd, &new_tty);
1182 new_tty.c_lflag &= ~(ICANON|ECHO|ECHONL);
1183 new_tty.c_iflag &= ~(IXON|IXOFF|ISIG);
1185 /* Unset remaining signal chars, leave only SIGQUIT set to ^\ */
1186 new_tty.c_cc[VINTR] = new_tty.c_cc[VSUSP] = UNDEF;
1187 new_tty.c_cc[VQUIT] = '\\' & 037;
1188 signal(SIGQUIT, catch); /* Which is caught */
1190 tcsetattr(input_fd, TCSANOW, &new_tty);
1194 * Panic() is called with an error number and a message. It is called when
1195 * something unrecoverable has happened.
1196 * It writes the message to the terminal, resets the tty and exits.
1197 * Ask the user if he wants to save his file.
1200 register char *message;
1202 extern char yank_file[];
1205 tputs(CL, 0, _putchar);
1206 build_string(text_buffer, "%s\nError code %d\n", message, errno);
1208 build_string(text_buffer, "%s%s\nError code %d\n", enter_string, message, errno);
1210 (void) write(STD_OUT, text_buffer, length_of(text_buffer));
1212 if (loading == FALSE)
1213 XT(); /* Check if file can be saved */
1215 (void) unlink(yank_file);
1230 p = malloc((unsigned) bytes);
1232 if (loading == TRUE)
1233 panic("File too big.");
1234 panic("Out of memory.");
1245 /* ======================================================================== *
1247 * ======================================================================== */
1249 /* The mapping between input codes and functions. */
1251 void (*key_map[256])() = { /* map ASCII characters to functions */
1252 /* 000-017 */ MA, BL, MP, YA, SD, EL, MN, IF, DPC, S, S, DT, RD, S, DNW,LIB,
1253 /* 020-037 */ DPW, WB, GR, SH, DLN, SU, VI, XWT, XT, PT, ST, ESC, I, GOTO,
1255 /* 040-057 */ S, S, S, S, S, S, S, S, S, S, S, S, S, S, S, S,
1256 /* 060-077 */ S, S, S, S, S, S, S, S, S, S, S, S, S, S, S, S,
1257 /* 100-117 */ S, S, S, S, S, S, S, S, S, S, S, S, S, S, S, S,
1258 /* 120-137 */ S, S, S, S, S, S, S, S, S, S, S, S, S, S, S, S,
1259 /* 140-157 */ S, S, S, S, S, S, S, S, S, S, S, S, S, S, S, S,
1260 /* 160-177 */ S, S, S, S, S, S, S, S, S, S, S, S, S, S, S, DCC,
1261 /* 200-217 */ S, S, S, S, S, S, S, S, S, S, S, S, S, S, S, S,
1262 /* 220-237 */ S, S, S, S, S, S, S, S, S, S, S, S, S, S, S, S,
1263 /* 240-257 */ S, S, S, S, S, S, S, S, S, S, S, S, S, S, S, S,
1264 /* 260-277 */ S, S, S, S, S, S, S, S, S, S, S, S, S, S, S, S,
1265 /* 300-317 */ S, S, S, S, S, S, S, S, S, S, S, S, S, S, S, S,
1266 /* 320-337 */ S, S, S, S, S, S, S, S, S, S, S, S, S, S, S, S,
1267 /* 340-357 */ S, S, S, S, S, S, S, S, S, S, S, S, S, S, S, S,
1268 /* 360-377 */ S, S, S, S, S, S, S, S, S, S, S, S, S, S, S, S,
1271 int nlines; /* Number of lines in file */
1272 LINE *header; /* Head of line list */
1273 LINE *tail; /* Last line in line list */
1274 LINE *cur_line; /* Current line in use */
1275 LINE *top_line; /* First line of screen */
1276 LINE *bot_line; /* Last line of screen */
1277 char *cur_text; /* Current char on current line in use */
1278 int last_y; /* Last y of screen. Usually SCREENMAX */
1279 char screen[SCREEN_SIZE]; /* Output buffer for "writes" and "reads" */
1281 int x, y; /* x, y coordinates on screen */
1282 FLAG modified = FALSE; /* Set when file is modified */
1283 FLAG stat_visible; /* Set if status_line is visible */
1284 FLAG writable; /* Set if file cannot be written */
1285 FLAG loading; /* Set if we are loading a file. */
1286 FLAG quit = FALSE; /* Set when quit character is typed */
1287 FLAG rpipe = FALSE; /* Set if file should be read from stdin */
1288 int input_fd = 0; /* Fd for command input */
1289 int out_count; /* Index in output buffer */
1290 char file_name[LINE_LEN]; /* Name of file in use */
1291 char text_buffer[MAX_CHARS]; /* Buffer for modifying text */
1293 /* Escape sequences. */
1295 char *CE, *VS, *SO, *SE, *CL, *AL, *CM;
1297 char *enter_string = "\033[H\033[J"; /* String printed on entering mined */
1298 char *pos_string = "\033[%d;%dH"; /* Absolute cursor position */
1299 char *rev_scroll = "\033M"; /* String for reverse scrolling */
1300 char *rev_video = "\033[7m"; /* String for starting reverse video */
1301 char *normal_video = "\033[m"; /* String for leaving reverse video */
1302 char *blank_line = "\033[K"; /* Clear line to end */
1308 FLAG yank_status = NOT_VALID; /* Status of yank_file */
1309 char yank_file[] = "/tmp/mined.XXXXXX";
1310 long chars_saved; /* Nr of chars in buffer */
1313 * Initialize is called when a another file is edited. It free's the allocated
1314 * space and sets modified back to FALSE and fixes the header/tail pointer.
1318 register LINE *line, *next_line;
1320 /* Delete the whole list */
1321 for (line = header->next; line != tail; line = next_line) {
1322 next_line = line->next;
1323 free_space(line->text);
1324 free_space((char*)line);
1327 /* header and tail should point to itself */
1328 line->next = line->prev = line;
1330 rpipe = modified = FALSE;
1334 * Basename() finds the absolute name of the file out of a given path_name.
1336 char *basename(path)
1339 register char *ptr = path;
1340 register char *last = NIL_PTR;
1342 while (*ptr != '\0') {
1347 if (last == NIL_PTR)
1349 if (*(last + 1) == '\0') { /* E.g. /usr/tmp/pipo/ */
1351 return basename(path);/* Try again */
1357 * Load_file loads the file `file' into core. If file is a NIL_PTR or the file
1358 * couldn't be opened, just some initializations are done, and a line consisting
1359 * of a `\n' is installed.
1361 void load_file(file)
1364 register LINE *line = header;
1366 long nr_of_chars = 0L;
1367 int fd = -1; /* Filedescriptor for file */
1369 nlines = 0; /* Zero lines to start with */
1372 writable = TRUE; /* Benefit of the doubt */
1373 if (file == NIL_PTR) {
1375 status_line("No file.", NIL_PTR);
1378 file = "standard input";
1380 file_name[0] = '\0';
1383 copy_string(file_name, file); /* Save file name */
1384 if (access(file, 0) < 0) /* Cannot access file. */
1385 status_line("New file ", file);
1386 else if ((fd = open(file, 0)) < 0)
1387 status_line("Cannot open ", file);
1388 else if (access(file, 2) != 0) /* Set write flag */
1393 loading = TRUE; /* Loading file, so set flag */
1396 status_line("Reading ", file);
1397 while ((len = get_line(fd, text_buffer)) != ERRORS) {
1398 line = line_insert(line, text_buffer, len);
1399 nr_of_chars += (long) len;
1401 if (nlines == 0) /* The file was empty! */
1402 line = line_insert(line, "\n", 1);
1403 clear_buffer(); /* Clear output buffer */
1404 cur_line = header->next;
1405 fstatus("Read", nr_of_chars);
1406 (void) close(fd); /* Close file */
1408 else /* Just install a "\n" */
1409 (void) line_insert(line, "\n", 1);
1411 reset(header->next, 0); /* Initialize pointers */
1414 display (0, 0, header->next, last_y);
1416 flush(); /* Flush buffer */
1417 loading = FALSE; /* Stop loading, reset flag */
1422 * Get_line reads one line from filedescriptor fd. If EOF is reached on fd,
1423 * get_line() returns ERRORS, else it returns the length of the string.
1425 int get_line(fd, buffer)
1427 register char *buffer;
1429 static char *last = NIL_PTR;
1430 static char *current = NIL_PTR;
1431 static int read_chars;
1432 register char *cur_pos = current;
1433 char *begin = buffer;
1436 if (cur_pos == last) {
1437 if ((read_chars = read(fd, screen, SCREEN_SIZE)) <= 0)
1439 last = &screen[read_chars];
1442 if (*cur_pos == '\0')
1444 } while ((*buffer++ = *cur_pos++) != '\n');
1447 if (read_chars <= 0) {
1448 if (buffer == begin)
1450 if (*(buffer - 1) != '\n')
1451 if (loading == TRUE) /* Add '\n' to last line of file */
1460 return buffer - begin;
1464 * Install_line installs the buffer into a LINE structure It returns a pointer
1465 * to the allocated structure.
1467 LINE *install_line(buffer, length)
1471 register LINE *new_line = (LINE *) alloc(sizeof(LINE));
1473 new_line->text = alloc(length + 1);
1474 new_line->shift_count = 0;
1475 copy_string(new_line->text, buffer);
1485 /* mined is the Minix editor. */
1487 register int index; /* Index in key table */
1488 struct winsize winsize;
1492 tputs(VS, 0, _putchar);
1493 tputs(CL, 0, _putchar);
1495 string_print(enter_string); /* Hello world */
1497 if (ioctl(STD_OUT, TIOCGWINSZ, &winsize) == 0 && winsize.ws_row != 0) {
1498 ymax = winsize.ws_row - 1;
1499 screenmax = ymax - 1;
1502 if (!isatty(0)) { /* Reading from pipe */
1504 write(2, "Cannot find terminal.\n", 22);
1508 modified = TRUE; /* Set modified so he can write */
1512 raw_mode(ON); /* Set tty to appropriate mode */
1514 header = tail = (LINE *) alloc(sizeof(LINE)); /* Make header of list*/
1515 header->text = NIL_PTR;
1516 header->next = tail->prev = header;
1518 /* Load the file (if any) */
1522 (void) get_file(NIL_PTR, argv[1]); /* Truncate filename */
1526 /* Main loop of the editor. */
1529 if (stat_visible == TRUE)
1533 else { /* Call the function for this key */
1534 (*key_map[index])(index);
1535 flush(); /* Flush output (if any) */
1543 /* ======================================================================== *
1545 * ======================================================================== */
1554 tputs(VS, 0, _putchar);
1555 tputs(CL, 0, _putchar);
1557 string_print(enter_string);
1560 /* Print first page */
1561 display(0, 0, top_line, last_y);
1563 /* Clear last line */
1564 set_cursor(0, ymax);
1566 tputs(CE, 0, _putchar);
1568 string_print(blank_line);
1574 * Ignore this keystroke.
1581 * Leave editor. If the file has changed, ask if the user wants to save it.
1585 if (modified == TRUE && ask_save() == ERRORS)
1589 set_cursor(0, ymax);
1592 (void) unlink(yank_file); /* Might not be necessary */
1596 void (*escfunc(c))()
1599 #if (CHIP == M68000)
1605 /* Start of ASCII escape sequence. */
1607 #if (CHIP == M68000)
1609 if ((c >= '0') && (c <= '9')) ch = getchar();
1610 /* ch is either a tilde or a second digit */
1614 case 'H': return(HO);
1615 case 'A': return(UP);
1616 case 'B': return(DN);
1617 case 'C': return(RT);
1618 case 'D': return(LF);
1619 #if (CHIP == M68000)
1621 /* F1 = ESC [ 1 ~ */
1622 /* F2 = ESC [ 2 ~ */
1623 /* F3 = ESC [ 3 ~ */
1624 /* F4 = ESC [ 4 ~ */
1625 /* F5 = ESC [ 5 ~ */
1626 /* F6 = ESC [ 6 ~ */
1627 /* F7 = ESC [ 17 ~ */
1628 /* F8 = ESC [ 18 ~ */
1631 case '~': return(SF);
1632 case '7': (void) getchar(); return(MA);
1633 case '8': (void) getchar(); return(CTL);
1635 case '2': return(SR);
1636 case '3': return(PD);
1637 case '4': return(PU);
1638 case '5': return(FS);
1639 case '6': return(EF);
1643 #ifdef ASSUME_CONS25
1644 case 'G': return(PD);
1645 case 'I': return(PU);
1646 case 'F': return(EF);
1648 case 'M': return(HLP);
1649 /* F2 - file status */
1650 case 'N': return(FS);
1651 /* F3 - search fwd */
1652 case 'O': return(SF);
1653 /* Shift-F3 - search back */
1654 case 'a':return(SR);
1655 /* F4 - global replace */
1656 case 'P': return(GR);
1657 /* Shift-F4 - line replace */
1658 case 'b': return(LR);
1660 case 'G': return(FS);
1661 case 'S': return(SR);
1662 case 'T': return(SF);
1663 case 'U': return(PD);
1664 case 'V': return(PU);
1665 case 'Y': return(EF);
1673 /* Start of ASCII function key escape sequence. */
1674 switch (getchar()) {
1675 case 'P': return(HLP); /* F1 */
1676 case 'Q': return(FS); /* F2 */
1677 case 'R': return(SF); /* F3 */
1678 case 'S': return(GR); /* F4 */
1680 switch (getchar()) {
1681 case 'R': return(SR); /* shift-F3 */
1687 #if (CHIP == M68000)
1690 /* Start of ASCII function key escape sequence. */
1691 switch (getchar()) {
1692 case 'P': return(SF);
1693 case 'Q': return(SR);
1694 case 'R': return(PD);
1695 case 'S': return(PU);
1696 case 'T': return(FS);
1697 case 'U': return(EF);
1698 case 'V': return(MA);
1699 case 'W': return(CTL);
1708 * ESC() wants a count and a command after that. It repeats the
1709 * command count times. If a ^\ is given during repeating, stop looping and
1710 * return to main loop.
1714 register int count = 0;
1715 register void (*func)();
1719 while (index >= '0' && index <= '9' && quit == FALSE) {
1721 count += index - '0';
1726 func = escfunc(index);
1728 func = key_map[index];
1730 func = escfunc(getchar());
1733 if (func == I) { /* Function assigned? */
1738 while (count-- > 0 && quit == FALSE) {
1739 if (stat_visible == TRUE)
1745 if (quit == TRUE) /* Abort has been given */
1746 error("Aborted", NIL_PTR);
1750 * Ask the user if he wants to save his file or not.
1756 status_line(file_name[0] ? basename(file_name) : "[buffer]" ,
1757 " has been modified. Save? (y/n)");
1759 while((c = getchar()) != 'y' && c != 'n' && quit == FALSE) {
1772 quit = FALSE; /* Abort character has been given */
1777 * Line_number() finds the line number we're on.
1781 register LINE *line = header->next;
1782 register int count = 1;
1784 while (line != cur_line) {
1793 * Display a line telling how many chars and lines the file contains. Also tell
1794 * whether the file is readonly and/or modified.
1796 void file_status(message, count, file, lines, writefl, changed)
1798 register long count; /* Contains number of characters in file */
1801 FLAG writefl, changed;
1803 register LINE *line;
1804 char msg[LINE_LEN + 40];/* Buffer to hold line */
1805 char yank_msg[LINE_LEN];/* Buffer for msg of yank_file */
1807 if (count < 0) /* Not valid. Count chars in file */
1808 for (line = header->next; line != tail; line = line->next)
1809 count += length_of(line->text);
1811 if (yank_status != NOT_VALID) /* Append buffer info */
1812 build_string(yank_msg, " Buffer: %D char%s.", chars_saved,
1813 (chars_saved == 1L) ? "" : "s");
1817 build_string(msg, "%s %s%s%s %d line%s %D char%s.%s Line %d", message,
1818 (rpipe == TRUE && *message != '[') ? "standard input" : basename(file),
1819 (changed == TRUE) ? "*" : "",
1820 (writefl == FALSE) ? " (Readonly)" : "",
1821 lines, (lines == 1) ? "" : "s",
1822 count, (count == 1L) ? "" : "s",
1823 yank_msg, line_number());
1825 if (length_of(msg) + 1 > LINE_LEN - 4) {
1826 msg[LINE_LEN - 4] = SHIFT_MARK; /* Overflow on status line */
1827 msg[LINE_LEN - 3] = '\0';
1829 status_line(msg, NIL_PTR); /* Print the information */
1833 * Build_string() prints the arguments as described in fmt, into the buffer.
1834 * %s indicates an argument string, %d indicated an argument number.
1837 void build_string(char *buf, char *fmt, ...)
1840 void build_string(buf, fmt, va_alist)
1849 va_start(argptr, fmt);
1859 scanp = va_arg(argptr, char *);
1862 scanp = num_out((long) va_arg(argptr, int));
1865 scanp = num_out((long) va_arg(argptr, long));
1870 while (*buf++ = *scanp++)
1882 * Output an (unsigned) long in a 10 digit field without leading zeros.
1883 * It returns a pointer to the first digit in the buffer.
1885 char *num_out(number)
1888 static char num_buf[11]; /* Buffer to build number */
1889 register long digit; /* Next digit of number */
1890 register long pow = 1000000000L; /* Highest ten power of long */
1891 FLAG digit_seen = FALSE;
1894 for (i = 0; i < 10; i++) {
1895 digit = number / pow; /* Get next digit */
1896 if (digit == 0L && digit_seen == FALSE && i != 9)
1899 num_buf[i] = '0' + (char) digit;
1900 number -= digit * pow; /* Erase digit */
1903 pow /= 10L; /* Get next digit */
1905 for (i = 0; num_buf[i] == ' '; i++) /* Skip leading spaces */
1907 return (&num_buf[i]);
1911 * Get_number() read a number from the terminal. The last character typed in is
1912 * returned. ERRORS is returned on a bad number. The resulting number is put
1913 * into the integer the arguments points to.
1915 int get_number(message, result)
1920 register int count = 0;
1922 status_line(message, NIL_PTR);
1925 if (quit == FALSE && (index < '0' || index > '9')) {
1926 error("Bad count", NIL_PTR);
1930 /* Convert input to a decimal number */
1931 while (index >= '0' && index <= '9' && quit == FALSE) {
1933 count += index - '0';
1947 * Input() reads a string from the terminal. When the KILL character is typed,
1948 * it returns ERRORS.
1950 int input(inbuf, clearfl)
1955 register char c; /* Character read */
1960 while (quit == FALSE) {
1962 switch (c = getchar()) {
1963 case '\b' : /* Erase previous char */
1967 tputs(SE, 0, _putchar);
1969 string_print(normal_video);
1972 string_print(" \b\b\b \b\b");
1974 string_print(" \b\b \b");
1976 tputs(SO, 0, _putchar);
1978 string_print(rev_video);
1980 string_print(" \b");
1986 case '\n' : /* End of input */
1987 /* If inbuf is empty clear status_line */
1988 return (ptr == inbuf && clearfl == TRUE) ? NO_INPUT :FINE;
1989 default : /* Only read ASCII chars */
1990 if ((c >= ' ' && c <= '~') || c == '\t') {
1997 string_print(" \b");
2008 * Get_file() reads a filename from the terminal. Filenames longer than
2009 * FILE_LENGHT chars are truncated.
2011 int get_file(message, file)
2012 char *message, *file;
2017 if (message == NIL_PTR || (ret = get_string(message, file, TRUE)) == FINE) {
2018 if (length_of((ptr = basename(file))) > NAME_MAX)
2019 ptr[NAME_MAX] = '\0';
2024 /* ======================================================================== *
2025 * UNIX I/O Routines *
2026 * ======================================================================== */
2035 if (read(input_fd, &c, 1) != 1 && quit == FALSE)
2036 panic ("Cannot read 1 byte from input");
2042 (void) fflush(stdout);
2048 (void) write_char(STD_OUT, c);
2053 static char termbuf[50];
2054 extern char *tgetstr(), *getenv();
2055 char *loc = termbuf;
2058 if (tgetent(entry, getenv("TERM")) <= 0) {
2059 printf("Unknown terminal.\n");
2063 AL = tgetstr("al", &loc);
2064 CE = tgetstr("ce", &loc);
2065 VS = tgetstr("vs", &loc);
2066 CL = tgetstr("cl", &loc);
2067 SO = tgetstr("so", &loc);
2068 SE = tgetstr("se", &loc);
2069 CM = tgetstr("cm", &loc);
2070 ymax = tgetnum("li") - 1;
2071 screenmax = ymax - 1;
2073 if (!CE || !SO || !SE || !CL || !AL || !CM) {
2074 printf("Sorry, no mined on this type of terminal\n");