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