/*
* Author: Michiel Huisjes.
- *
+ *
* 1. General remarks.
- *
+ *
* Mined is a screen editor designed for the MINIX operating system.
* It is meant to be used on files not larger than 50K and to be fast.
* When mined starts up, it reads the file into its memory to minimize
* disk access. The only time that disk access is needed is when certain
* save, write or copy commands are given.
- *
+ *
* Mined has the style of Emacs or Jove, that means that there are no modes.
* Each character has its own entry in an 256 pointer to function array,
* which is called when that character is typed. Only ASCII characters are
* inserted as well. Note that the mapping between commands and functions
* called is implicit in the table. Changing the mapping just implies
* changing the pointers in this table.
- *
+ *
* The display consists of SCREENMAX + 1 lines and XMAX + 1 characters. When
* a line is larger (or gets larger during editing) than XBREAK characters,
* the line is either shifted SHIFT_SIZE characters to the left (which means
* editing. This line is usually blank or contains information mined needs
* during editing. This information (or rather questions) is displayed in
* reverse video.
- *
+ *
* The terminal modes are changed completely. All signals like start/stop,
* interrupt etc. are unset. The only signal that remains is the quit signal.
* The quit signal (^\) is the general abort signal for mined. Typing a ^\
* The session will also be aborted when an unrecoverable error occurs. E.g
* when there is no more memory available. If the file has been modified,
* mined will ask if the file has to be saved or not.
- * If there is no more space left on the disk, mined will just give an error
+ * If there is no more space left on the disk, mined will just give an error
* message and continue.
- *
+ *
* The number of system calls are minized. This is done to keep the editor
* as fast as possible. I/O is done in SCREEN_SIZE reads/writes. Accumulated
* output is also flushed at the end of each character typed.
- *
+ *
* 2. Regular expressions
- *
+ *
* Mined has a build in regular expression matcher, which is used for
* searching and replace routines. A regular expression consists of a
* sequence of:
- *
+ *
* 1. A normal character matching that character.
* 2. A . matching any character.
* 3. A ^ matching the begin of a line.
* characters. A list of characters can be indicated by a '-'. So
* [a-z] matches any letter of the alphabet. If the first character
* after the '[' is a '^' then the set is negated (matching none of
- * the characters).
+ * the characters).
* A ']', '^' or '-' can be escaped by putting a '\' in front of it.
* Of course this means that a \ must be represented by \\.
* 7. If one of the expressions as described in 1-6 is followed by a
* '*' than that expressions matches a sequence of 0 or more of
* that expression.
- *
+ *
* Parsing of regular expression is done in two phases. In the first phase
* the expression is compiled into a more comprehensible form. In the second
* phase the actual matching is done. For more details see 3.6.
- *
- *
+ *
+ *
* 3. Implementation of mined.
- *
+ *
* 3.1 Data structures.
- *
+ *
* The main data structures are as follows. The whole file is kept in a
* double linked list of lines. The LINE structure looks like this:
- *
+ *
* typedef struct Line {
* struct Line *next;
* struct Line *prev;
* char *text;
* unsigned char shift_count;
* } LINE;
- *
+ *
* Each line entry contains a pointer to the next line, a pointer to the
* previous line and a pointer to the text of that line. A special field
* shift_count contains the number of shifts (in units of SHIFT_SIZE)
* that the number of characters of the line is counted and sufficient
* space is allocated to store them (including a linefeed and a '\0').
* The resulting address is assigned to the text field in the structure.
- *
+ *
* A special structure is allocated and its address is assigned to the
* variable header as well as the variable tail. The text field of this
* structure is set to NULL. The tail->prev of this structure points
* character inserted. Then the old data space (pointed to by
* cur_line->text) is freed, data space for the new line is allocated and
* assigned to cur_line->text.
- *
+ *
* Two global variables called x and y represent the x and y coordinates
* from the cursor. The global variable nlines contains the number of
* lines in the file. Last_y indicates the maximum y coordinate of the
* screen (which is usually SCREENMAX).
- *
+ *
* A few strings must be initialized by hand before compiling mined.
* These string are enter_string, which is printed upon entering mined,
* rev_video (turn on reverse video), normal_video, rev_scroll (perform a
* absolute position string to be printed for cursor motion. The #define
* X_PLUS and Y_PLUS should contain the characters to be added to the
* coordinates x and y (both starting at 0) to finish cursor positioning.
- *
+ *
* 3.2 Starting up.
- *
+ *
* Mined can be called with or without argument and the function
* load_file () is called with these arguments. load_file () checks
* if the file exists if it can be read and if it is writable and
- * sets the writable flag accordingly. If the file can be read,
+ * sets the writable flag accordingly. If the file can be read,
* load_file () reads a line from the file and stores this line into
* a structure by calling install_line () and line_insert () which
* installs the line into the double linked list, until the end of the
* Lines are read by the function get_line (), which buffers the
* reading in blocks of SCREEN_SIZE. Load_file () also initializes the
* LINE *variables described above.
- *
+ *
* 3.3 Moving around.
- *
+ *
* Several commands are implemented for moving through the file.
* Moving up (UP), down (DN) left (LF) and right (RT) are done by the
* arrow keys. Moving one line below the screen scrolls the screen one
* (HO), end of file (EF), scroll one page down (PD), scroll one page up
* (PU), scroll one line down (SD), scroll one line up (SU) and move to a
* certain line number (GOTO).
- * Two functions called MN () and MP () each move one word further or
+ * Two functions called MN () and MP () each move one word further or
* backwards. A word is a number of non-blanks seperated by a space, a
* tab or a linefeed.
- *
+ *
* 3.4 Modifying text.
- *
+ *
* The modifying commands can be separated into two modes. The first
* being inserting text, and the other deleting text. Two functions are
* created for these purposes: insert () and delete (). Both are capable
* before cursor (even linefeed) (DPC), delete next word (DNW), delete
* previous word (DPC) and delete to end of line (if the cursor is at
* a linefeed delete line) (DLN).
- *
+ *
* 3.5 Yanking.
- *
+ *
* A few utilities are provided for yanking pieces of text. The function
- * MA () marks the current position in the file. This is done by setting
+ * MA () marks the current position in the file. This is done by setting
* LINE *mark_line and char *mark_text to the current position. Yanking
* of text can be done in two modes. The first mode just copies the text
* from the mark to the current position (or visa versa) into a buffer
* yank ()). Several things can be done with the buffer. It can be
* inserted somewhere else in the file (PT) or it can be copied into
* another file (WB), which will be prompted for.
- *
+ *
* 3.6 Search and replace routines.
- *
+ *
* Searching for strings and replacing strings are done by regular
* expressions. For any expression the function compile () is called
* with as argument the expression to compile. Compile () returns a
* pointer to a structure which looks like this:
- *
+ *
* typedef struct regex {
* union {
* char *err_mess;
* char *start_ptr;
* char *end_ptr;
* } REGEX;
- *
+ *
* If something went wrong during compiling (e.g. an illegal expression
* was given), the function reg_error () is called, which sets the status
* field to REG_ERROR and the err_mess field to the error message. If the
* match was found else it returns a NULL. Line_check () takes the
* same arguments, but return either MATCH or NO_MATCH.
* During checking, the start_ptr and end_ptr fields of the REGEX
- * structure are assigned to the start and end of the match.
+ * structure are assigned to the start and end of the match.
* Both functions try to find a match by walking through the line
* character by character. For each possibility, the function
* check_string () is called with as arguments the REGEX *program and the
* means substitute the match instead. An & can be escaped by a \. When
* a match is found, the function substitute () will perform the
* substitution.
- *
+ *
* 3.6 Miscellaneous commands.
- *
+ *
* A few commands haven't be discussed yet. These are redraw the screen
* (RD) fork a shell (SH), print file status (FS), write file to disc
* (WT), insert a file at current position (IF), leave editor (XT) and
* file by calling ask_save ().
* The function ESC () will repeat a command n times. It will prompt for
* the number. Aborting the loop can be done by sending the ^\ signal.
- *
+ *
* 3.7 Utility functions.
- *
+ *
* Several functions exists for internal use. First allocation routines:
* alloc (bytes) and newline () will return a pointer to free data space
* if the given size. If there is no more memory available, the function
* panic () is called.
- * Signal handling: The only signal that can be send to mined is the
+ * Signal handling: The only signal that can be send to mined is the
* SIGQUIT signal. This signal, functions as a general abort command.
- * Mined will abort if the signal is given during the main loop. The
+ * Mined will abort if the signal is given during the main loop. The
* function abort_mined () takes care of that.
* Panic () is a function with as argument a error message. It will print
* the message and the error number set by the kernel (errno) and will
* of cur_line to an apropiate number according to new_x. The only thing
* left to do now is to assign the new values to cur_line, cur_text, x
* and y.
- *
+ *
* 4. Summary of commands.
- *
+ *
* CURSOR MOTION
* up-arrow Move cursor 1 line up. At top of screen, reverse scroll
* down-arrow Move cursor 1 line down. At bottom, scroll forward.
* CTRL-_ Move cursor to bottom of screen
* CTRL-F Forward to start of next word (even to next line)
* CTRL-B Backward to first character of previous word
- *
+ *
* SCREEN MOTION
* Home key Move cursor to first character of file
* End key Move cursor to last character of file
* PgD Scroll backward 1 page. Top line becomes bottom line
* CTRL-D Scroll screen down one line (reverse scroll)
* CTRL-U Scroll screen up one line (forward scroll)
- *
+ *
* MODIFYING TEXT
* ASCII char Self insert character at cursor
* tab Insert tab at cursor
* CTRL-Y Insert the contents of the save file at current position
* CTRL-Q Insert the contents of the save file into a new file
* CTRL-G Insert a file at the current position
- *
+ *
* MISCELLANEOUS
* CTRL-E Erase and redraw the screen
* CTRL-V Visit file (read a new file); complain if old one changed
*/
/* ======================================================================== *
- * Utilities *
+ * Utilities *
* ======================================================================== */
#include "mined.h"
if (modified == TRUE && ask_save() == ERRORS)
return;
-
+
/* Get new file name */
if (get_file("Visit file:", new_file) == ERRORS)
return;
stat_visible = FALSE;
string_print(buf);
-
+
if (inbuf != NULL)
ret = input(inbuf, statfl);
tx++;
textp++;
}
-
+
*old_x = tx;
return textp;
}
}
/*
- * Write_char does a buffered output.
+ * Write_char does a buffered output.
*/
int write_char(int fd, int c)
{
{
if (fd == STD_OUT) /* Cannot write to terminal? */
exit(1);
-
+
clear_buffer();
build_string(text_buffer, "Command aborted: %s (File incomplete)",
(errno == ENOSPC || errno == -ENOSPC) ?
char *blank_line = "\033[K"; /* Clear line to end */
#endif /* UNIX */
-/*
+/*
* Yank variables.
*/
FLAG yank_status = NOT_VALID; /* Status of yank_file */
}
/*
- * ESC() wants a count and a command after that. It repeats the
+ * ESC() wants a count and a command after that. It repeats the
* command count times. If a ^\ is given during repeating, stop looping and
* return to main loop.
*/
count++;
line = line->next;
}
-
+
return count;
}
-
+
/*
* Display a line telling how many chars and lines the file contains. Also tell
* whether the file is readonly and/or modified.
*/
/* ======================================================================== *
- * Move Commands *
+ * Move Commands *
* ======================================================================== */
#include "mined.h"
}
/*
- * Scroll forward one page or to eof, whatever comes first. (Bot_line becomes
+ * Scroll forward one page or to eof, whatever comes first. (Bot_line becomes
* top_line of display.) Try to leave the cursor on the same line. If this is
* not possible, leave cursor on the line halfway the page.
*/
*/
void SD(void)
{
- if (forward_scroll() != ERRORS)
+ if (forward_scroll() != ERRORS)
move_to(x, (y == 0) ? 0 : y - 1);
else
set_cursor(x, y);
/*
* DPC deletes the character on the left side of the cursor. If the cursor is
* at the beginning of the line, the last character if the previous line is
- * deleted.
+ * deleted.
*/
void DPC(void)
{
if (x == 0 && cur_line->prev == header)
return; /* Top of file */
-
+
LF(); /* Move one left */
DCC(); /* Delete character under cursor */
}
/* Copy part of line until `location' has been reached */
while (textp != location)
*bufp++ = *textp++;
-
+
/* Insert string at this location */
while (*string != '\0')
*bufp++ = *string++;
*bufp = '\0';
-
+
if (*(string - 1) == '\n') /* Insert a new line */
(void) line_insert(line, location, length_of(location));
else /* Append last part of line */
}
/* ======================================================================== *
- * Yank Commands *
+ * Yank Commands *
* ======================================================================== */
LINE *mark_line; /* For marking position. */
}
/*
- * IF() prompt for a filename and inserts the file at the current location
+ * IF() prompt for a filename and inserts the file at the current location
* in the file.
*/
void IF(void)
/* Get the file name */
if (get_file("Get and insert file:", name) != FINE)
return;
-
+
if ((fd = open(name, 0)) < 0)
error("Cannot open ", name);
else {
register int line_count = nlines; /* Nr of lines inserted */
LINE *page = cur_line;
int ret = ERRORS;
-
+
/* Get the first piece of text (might be ended with a '\n') from fd */
if (get_line(fd, line_buffer) == ERRORS)
return; /* Empty file */
/* Repeat getting lines (and inserting lines) until EOF is reached */
while ((ret = get_line(fd, line_buffer)) != ERRORS && ret != NO_LINE)
line = line_insert(line, line_buffer, ret);
-
+
if (ret == NO_LINE) { /* Last line read not ended by a '\n' */
line = line->next;
(void) insert(line, line->text, line_buffer);
register int cnt; /* Count check for read/write */
int ret = 0; /* Error check for write */
char file[LINE_LEN]; /* Output file */
-
+
/* Checkout the buffer */
if ((yank_fd = scratch_file(READ)) == ERRORS) {
error("Buffer is empty.", NULL);
/* Get file name */
if (get_file("Write buffer to file:", file) != FINE)
return;
-
+
/* Creat the new file */
if ((new_fd = creat(file, 0644)) < 0) {
error("Cannot create ", file);
}
status_line("Writing ", file);
-
+
/* Copy buffer into file */
while ((cnt = read(yank_fd, text_buffer, sizeof(text_buffer))) > 0)
if (write(new_fd, text_buffer, cnt) != cnt) {
}
/*
- * MA sets mark_line (mark_text) to the current line (text pointer).
+ * MA sets mark_line (mark_text) to the current line (text pointer).
*/
void MA(void)
{
/* Creat file to hold buffer */
if ((fd = scratch_file(WRITE)) == ERRORS)
return;
-
+
chars_saved = 0L;
lines_saved = 0;
status_line("Saving text.", NULL);
}
/* ======================================================================== *
- * Search Routines *
+ * Search Routines *
* ======================================================================== */
/*
* characters. A list of characters can be indicated by a '-'. So
* [a-z] matches any letter of the alphabet. If the first character
* after the '[' is a '^' then the set is negated (matching none of
- * the characters).
+ * the characters).
* A ']', '^' or '-' can be escaped by putting a '\' in front of it.
* 7. If one of the expressions as described in 1-6 is followed by a
* '*' than that expressions matches a sequence of 0 or more of
if (get_string(message, exp_buf, FALSE) == ERRORS)
return NULL;
-
+
if (exp_buf[0] == '\0' && typed_expression[0] == '\0') {
error("No previous expression.", NULL);
return NULL;
copy_string(mess_buf, message);
if ((program = get_expression(mess_buf)) == NULL)
return;
-
+
/* Get substitution pattern */
build_string(mess_buf, "%s %s by:", mess_buf, typed_expression);
if (get_string(mess_buf, replacement, FALSE) == ERRORS)
return;
-
+
set_cursor(0, ymax);
flush();
/* Substitute until end of file */
/*
* Substitute() replaces the match on this line by the substitute pattern
- * as indicated by the program. Every '&' in the replacement is replaced by
+ * as indicated by the program. Every '&' in the replacement is replaced by
* the original match. A \ in the replacement escapes the next character.
*/
char *substitute(LINE *line, REGEX *program, char *replacement)
/* Copy part of line until the beginning of the match */
while (linep != program->start_ptr)
*textp++ = *linep++;
-
+
/*
* Replace the match by the substitution pattern. Each occurrence of '&' is
* replaced by the original match. A \ escapes the next character.
}
/*
- * Compile compiles the pattern into a more comprehensible form and returns a
+ * Compile compiles the pattern into a more comprehensible form and returns a
* REGEX structure. If something went wrong, the status field of the structure
* is set to REG_ERROR and an error message is set into the err_mess field of
* the union. If all went well the expression is saved and the expression
* the list.
* The opcode consists of BRACKET and if necessary
* NEGATE to indicate that the list should be negated
- * and/or STAR to indicate a number of sequence of this
+ * and/or STAR to indicate a number of sequence of this
* list.
* The lower byte contains the length of the list.
*/
}
/*
- * Match gets as argument the program, pointer to place in current line to
+ * Match gets as argument the program, pointer to place in current line to
* start from and the method to search for (either FORWARD or REVERSE).
* Match() will look through the whole file until a match is found.
* NULL is returned if no match could be found.
* is found during matching, then the begin position of the string is marked
* and the maximum number of matches is performed. Then the function star()
* is called which starts to finish the match from this position of the string
- * (and expression). Check() return MATCH for a match, NO_MATCH is the string
+ * (and expression). Check() return MATCH for a match, NO_MATCH is the string
* couldn't be matched or REG_ERROR for an illegal opcode in expression.
*/
int check_string(REGEX *program, register char *string, int *expression)
default :
panic("Corrupted program in check_string()");
}
- if (star_fl)
+ if (star_fl)
return star(program, mark, string, expression);
}
if (*expression & DONE) {