Generally use NULL instead of explicitly casting 0 to some pointer type (part2).
[dragonfly.git] / usr.bin / ee / ee.c
1 /*
2  |      ee (easy editor)
3  |
4  |      An easy to use, simple screen oriented editor.
5  |
6  |      written by Hugh Mahon
7  |
8  |      THIS MATERIAL IS PROVIDED "AS IS".  THERE ARE
9  |      NO WARRANTIES OF ANY KIND WITH REGARD TO THIS
10  |      MATERIAL, INCLUDING, BUT NOT LIMITED TO, THE
11  |      IMPLIED WARRANTIES OF MERCHANTABILITY AND
12  |      FITNESS FOR A PARTICULAR PURPOSE.  Neither
13  |      Hewlett-Packard nor Hugh Mahon shall be liable
14  |      for errors contained herein, nor for
15  |      incidental or consequential damages in
16  |      connection with the furnishing, performance or
17  |      use of this material.  Neither Hewlett-Packard
18  |      nor Hugh Mahon assumes any responsibility for
19  |      the use or reliability of this software or
20  |      documentation.  This software and
21  |      documentation is totally UNSUPPORTED.  There
22  |      is no support contract available.  Hewlett-
23  |      Packard has done NO Quality Assurance on ANY
24  |      of the program or documentation.  You may find
25  |      the quality of the materials inferior to
26  |      supported materials.
27  |
28  |      This software is not a product of Hewlett-Packard, Co., or any 
29  |      other company.  No support is implied or offered with this software.
30  |      You've got the source, and you're on your own.
31  |
32  |      This software may be distributed under the terms of Larry Wall's 
33  |      Artistic license, a copy of which is included in this distribution. 
34  |
35  |      This notice must be included with this software and any derivatives.
36  |
37  |      This editor was purposely developed to be simple, both in 
38  |      interface and implementation.  This editor was developed to 
39  |      address a specific audience: the user who is new to computers 
40  |      (especially UNIX).
41  |      
42  |      ee is not aimed at technical users; for that reason more 
43  |      complex features were intentionally left out.  In addition, 
44  |      ee is intended to be compiled by people with little computer 
45  |      experience, which means that it needs to be small, relatively 
46  |      simple in implementation, and portable.
47  |
48  |      This software and documentation contains
49  |      proprietary information which is protected by
50  |      copyright.  All rights are reserved.
51  *
52  * $FreeBSD: src/usr.bin/ee/ee.c,v 1.16.2.6 2002/05/11 16:33:06 mp Exp $
53  * $DragonFly: src/usr.bin/ee/ee.c,v 1.5 2008/10/16 01:52:32 swildner Exp $
54  */
55
56 char *ee_copyright_message = 
57 "Copyright (c) 1986, 1990, 1991, 1992, 1993, 1994, 1995, 1996 Hugh Mahon ";
58
59 char *ee_long_notice[] = {
60         "This software and documentation contains", 
61         "proprietary information which is protected by", 
62         "copyright.  All rights are reserved."
63         };
64
65 char *version = "@(#) ee, version 1.4.1";
66
67 #ifdef NCURSE
68 #include "new_curse.h"
69 #elif HAS_NCURSES
70 #include <ncurses.h>
71 #else
72 #include <curses.h>
73 #endif
74
75 #ifdef HAS_CTYPE
76 #include <ctype.h>
77 #endif
78 #include <err.h>
79 #include <errno.h>
80 #include <fcntl.h>
81 #include <paths.h>
82 #include <pwd.h>
83 #include <signal.h>
84 #include <sys/types.h>
85 #include <sys/stat.h>
86 #ifdef HAS_SYS_WAIT
87 #include <sys/wait.h>
88 #endif
89 #ifdef HAS_STDARG
90 #include <stdarg.h>
91 #endif
92 #ifdef HAS_STDLIB
93 #include <stdlib.h>
94 #endif
95 #include <string.h>
96 #ifdef HAS_UNISTD
97 #include <unistd.h>
98 #endif
99
100 #ifndef NO_CATGETS
101 #include <locale.h>
102 #include <nl_types.h>
103
104 nl_catd catalog;
105 #else
106 #define catgetlocal(a, b) (b)
107 #endif /* NO_CATGETS */
108
109 #ifndef SIGCHLD
110 #define SIGCHLD SIGCLD
111 #endif
112
113 #define TAB 9
114 #define max(a, b)       (a > b ? a : b)
115 #define min(a, b)       (a < b ? a : b)
116
117 /*
118  |      defines for type of data to show in info window
119  */
120
121 #define CONTROL_KEYS 1
122 #define COMMANDS     2
123
124 struct text {
125         unsigned char *line;            /* line of characters           */
126         int line_number;                /* line number                  */
127         int line_length;        /* actual number of characters in the line */
128         int max_length; /* maximum number of characters the line handles */
129         struct text *next_line;         /* next line of text            */
130         struct text *prev_line;         /* previous line of text        */
131         };
132
133 struct text *first_line;        /* first line of current buffer         */
134 struct text *dlt_line;          /* structure for info on deleted line   */
135 struct text *curr_line;         /* current line cursor is on            */
136 struct text *tmp_line;          /* temporary line pointer               */
137 struct text *srch_line;         /* temporary pointer for search routine */
138
139 struct files {          /* structure to store names of files to be edited*/
140         unsigned char *name;            /* name of file                         */
141         struct files *next_name;
142         };
143
144 struct files *top_of_stack = NULL;
145
146 int d_wrd_len;                  /* length of deleted word               */
147 int position;                   /* offset in bytes from begin of line   */
148 int scr_pos;                    /* horizontal position                  */
149 int scr_vert;                   /* vertical position on screen          */
150 int scr_horz;                   /* horizontal position on screen        */
151 int tmp_vert, tmp_horz;
152 int input_file;                 /* indicate to read input file          */
153 int recv_file;                  /* indicate reading a file              */
154 int edit;                       /* continue executing while true        */
155 int gold;                       /* 'gold' function key pressed          */
156 int fildes;                     /* file descriptor                      */
157 int case_sen;                   /* case sensitive search flag           */
158 int last_line;                  /* last line for text display           */
159 int last_col;                   /* last column for text display         */
160 int horiz_offset = 0;           /* offset from left edge of text        */
161 int clear_com_win;              /* flag to indicate com_win needs clearing */
162 int text_changes = FALSE;       /* indicate changes have been made to text */
163 int get_fd;                     /* file descriptor for reading a file   */
164 int info_window = TRUE;         /* flag to indicate if help window visible */
165 int info_type = CONTROL_KEYS;   /* flag to indicate type of info to display */
166 int expand_tabs = TRUE;         /* flag for expanding tabs              */
167 int right_margin = 0;           /* the right margin                     */
168 int observ_margins = TRUE;      /* flag for whether margins are observed */
169 int shell_fork;
170 int temp_stdin;                 /* temporary storage for stdin          */
171 int temp_stdout;                /* temp storage for stdout descriptor   */
172 int temp_stderr;                /* temp storage for stderr descriptor   */
173 int pipe_out[2];                /* pipe file desc for output            */
174 int pipe_in[2];                 /* pipe file descriptors for input      */
175 int out_pipe;                   /* flag that info is piped out          */
176 int in_pipe;                    /* flag that info is piped in           */
177 int formatted = FALSE;          /* flag indicating paragraph formatted  */
178 int auto_format = FALSE;        /* flag for auto_format mode            */
179 int restricted = FALSE;         /* flag to indicate restricted mode     */
180 int nohighlight = FALSE;        /* turns off highlighting               */
181 int eightbit = TRUE;            /* eight bit character flag             */
182 int local_LINES = 0;            /* copy of LINES, to detect when win resizes */
183 int local_COLS = 0;             /* copy of COLS, to detect when win resizes  */
184 int curses_initialized = FALSE; /* flag indicating if curses has been started*/
185 int emacs_keys_mode = FALSE;    /* mode for if emacs key binings are used    */
186 int ee_chinese = FALSE;         /* allows handling of multi-byte characters  */
187                                 /* by checking for high bit in a byte the    */
188                                 /* code recognizes a two-byte character      */
189                                 /* sequence                                  */
190
191 unsigned char *point;           /* points to current position in line   */
192 unsigned char *srch_str;        /* pointer for search string            */
193 unsigned char *u_srch_str;      /* pointer to non-case sensitive search */
194 unsigned char *srch_1;          /* pointer to start of suspect string   */
195 unsigned char *srch_2;          /* pointer to next character of string  */
196 unsigned char *srch_3;
197 unsigned char *in_file_name = NULL;     /* name of input file           */
198 char *tmp_file; /* temporary file name                  */
199 unsigned char *d_char;          /* deleted character                    */
200 unsigned char *d_word;          /* deleted word                         */
201 unsigned char *d_line;          /* deleted line                         */
202 char in_string[513];    /* buffer for reading a file            */
203 unsigned char *print_command = "lpr";   /* string to use for the print command  */
204 unsigned char *start_at_line = NULL;    /* move to this line at start of session*/
205 const char count_text_default[] = "===============================================================================";
206 int count_text_len = sizeof(count_text_default);        /* length of the line above     */
207 char count_text[sizeof(count_text_default)];    /* buffer for current position display  */
208 int in;                         /* input character                      */
209
210 FILE *temp_fp;                  /* temporary file pointer               */
211 FILE *bit_bucket;               /* file pointer to /dev/null            */
212
213 char *table[] = { 
214         "^@", "^A", "^B", "^C", "^D", "^E", "^F", "^G", "^H", "\t", "^J", 
215         "^K", "^L", "^M", "^N", "^O", "^P", "^Q", "^R", "^S", "^T", "^U", 
216         "^V", "^W", "^X", "^Y", "^Z", "^[", "^\\", "^]", "^^", "^_"
217         };
218
219 WINDOW *com_win;
220 WINDOW *text_win;
221 WINDOW *help_win;
222 WINDOW *info_win;
223 WINDOW *count_win;
224
225 /*
226  |      The following structure allows menu items to be flexibly declared.
227  |      The first item is the string describing the selection, the second 
228  |      is the address of the procedure to call when the item is selected,
229  |      and the third is the argument for the procedure.
230  |
231  |      For those systems with i18n, the string should be accompanied by a
232  |      catalog number.  The 'int *' should be replaced with 'void *' on 
233  |      systems with that type.
234  |
235  |      The first menu item will be the title of the menu, with NULL 
236  |      parameters for the procedure and argument, followed by the menu items.
237  |
238  |      If the procedure value is NULL, the menu item is displayed, but no 
239  |      procedure is called when the item is selected.  The number of the 
240  |      item will be returned.  If the third (argument) parameter is -1, no 
241  |      argument is given to the procedure when it is called.
242  */
243
244 struct menu_entries {
245         char *item_string;
246         int (*procedure)(struct menu_entries *);
247         struct menu_entries *ptr_argument;
248         int (*iprocedure)(int);
249         void (*nprocedure)(void);
250         int argument;
251         };
252
253 int main(int argc, char *argv[]);
254 unsigned char *resiz_line(int factor, struct text *rline, int rpos);
255 void insert(int character);
256 void delete(int disp);
257 void scanline(unsigned char *pos);
258 int tabshift(int temp_int);
259 int out_char(WINDOW *window, int character, int column);
260 int len_char(int character, int column);
261 void draw_line(int vertical, int horiz, unsigned char *ptr, int t_pos, int length);
262 void insert_line(int disp);
263 struct text *txtalloc(void);
264 struct files *name_alloc(void);
265 unsigned char *next_word(unsigned char *string);
266 void prev_word(void);
267 void control(void);
268 void emacs_control(void);
269 void bottom(void);
270 void top(void);
271 void nextline(void);
272 void prevline(void);
273 void left(int disp);
274 void right(int disp);
275 void find_pos(void);
276 void up(void);
277 void down(void);
278 void function_key(void);
279 void print_buffer(void);
280 void command_prompt(void);
281 void command(char *cmd_str1);
282 int scan(char *line, int offset, int column);
283 char *get_string(char *prompt, int advance);
284 int compare(char *string1, char *string2, int sensitive);
285 void goto_line(char *cmd_str);
286 void midscreen(int line, unsigned char *pnt);
287 void get_options(int numargs, char *arguments[]);
288 void check_fp(void);
289 void get_file(char *file_name);
290 void get_line(int length, unsigned char *in_string, int *append);
291 void draw_screen(void);
292 void finish(void);
293 int quit(int noverify);
294 void edit_abort(int arg);
295 void delete_text(void);
296 int write_file(char *file_name, int warn_if_exists);
297 int search(int display_message);
298 void search_prompt(void);
299 void del_char(void);
300 void undel_char(void);
301 void del_word(void);
302 void undel_word(void);
303 void del_line(void);
304 void undel_line(void);
305 void adv_word(void);
306 void move_rel(char *direction, int lines);
307 void eol(void);
308 void bol(void);
309 void adv_line(void);
310 void sh_command(char *string);
311 void set_up_term(void);
312 void resize_check(void);
313 int menu_op(struct menu_entries *);
314 void paint_menu(struct menu_entries menu_list[], int max_width, int max_height, int list_size, int top_offset, WINDOW *menu_win, int off_start, int vert_size);
315 void help(void);
316 void paint_info_win(void);
317 void no_info_window(void);
318 void create_info_window(void);
319 int file_op(int arg);
320 void shell_op(void);
321 void leave_op(void);
322 void redraw(void);
323 int Blank_Line(struct text *test_line);
324 void Format(void);
325 void ee_init(void);
326 void dump_ee_conf(void);
327 void echo_string(char *string);
328 void spell_op(void);
329 void ispell_op(void);
330 int first_word_len(struct text *test_line);
331 void Auto_Format(void);
332 void modes_op(void);
333 char *is_in_string(char *string, char *substring);
334 char *resolve_name(char *name);
335 int restrict_mode(void);
336 int unique_test(char *string, char *list[]);
337 void renumber_lines(struct text *firstline, int startnumber);
338 void strings_init(void);
339
340 /*
341  |      allocate space here for the strings that will be in the menu
342  */
343
344 struct menu_entries modes_menu[] = {
345         {"", NULL, NULL, NULL, NULL, 0},        /* title                */
346         {"", NULL, NULL, NULL, NULL, -1},       /* 1. tabs to spaces    */
347         {"", NULL, NULL, NULL, NULL, -1},       /* 2. case sensitive search*/
348         {"", NULL, NULL, NULL, NULL, -1},       /* 3. margins observed  */
349         {"", NULL, NULL, NULL, NULL, -1},       /* 4. auto-paragraph    */
350         {"", NULL, NULL, NULL, NULL, -1},       /* 5. eightbit characters*/
351         {"", NULL, NULL, NULL, NULL, -1},       /* 6. info window       */
352         {"", NULL, NULL, NULL, NULL, -1},       /* 7. emacs key bindings*/
353         {"", NULL, NULL, NULL, NULL, -1},       /* 8. right margin      */
354         {"", NULL, NULL, NULL, NULL, -1},       /* 9. chinese text      */
355         {"", NULL, NULL, NULL, dump_ee_conf, -1}, /* 10. save editor config */
356         {NULL, NULL, NULL, NULL, NULL, -1}      /* terminator           */
357         };
358
359 char *mode_strings[11]; 
360
361 #define NUM_MODES_ITEMS 10
362
363 struct menu_entries config_dump_menu[] = {
364         {"", NULL, NULL, NULL, NULL, 0}, 
365         {"", NULL, NULL, NULL, NULL, -1},
366         {"", NULL, NULL, NULL, NULL, -1},
367         {NULL, NULL, NULL, NULL, NULL, -1}
368         };
369
370 struct menu_entries leave_menu[] = {
371         {"", NULL, NULL, NULL, NULL, -1}, 
372         {"", NULL, NULL, NULL, finish, -1}, 
373         {"", NULL, NULL, quit, NULL, TRUE}, 
374         {NULL, NULL, NULL, NULL, NULL, -1}
375         };
376
377 #define READ_FILE 1
378 #define WRITE_FILE 2
379 #define SAVE_FILE 3
380
381 struct menu_entries file_menu[] = {
382         {"", NULL, NULL, NULL, NULL, -1},
383         {"", NULL, NULL, file_op, NULL, READ_FILE},
384         {"", NULL, NULL, file_op, NULL, WRITE_FILE},
385         {"", NULL, NULL, file_op, NULL, SAVE_FILE},
386         {"", NULL, NULL, NULL, print_buffer, -1},
387         {NULL, NULL, NULL, NULL, NULL, -1}
388         };
389
390 struct menu_entries search_menu[] = {
391         {"", NULL, NULL, NULL, NULL, 0}, 
392         {"", NULL, NULL, NULL, search_prompt, -1},
393         {"", NULL, NULL, search, NULL, TRUE},
394         {NULL, NULL, NULL, NULL, NULL, -1}
395         };
396
397 struct menu_entries spell_menu[] = {
398         {"", NULL, NULL, NULL, NULL, -1}, 
399         {"", NULL, NULL, NULL, spell_op, -1},
400         {"", NULL, NULL, NULL, ispell_op, -1},
401         {NULL, NULL, NULL, NULL, NULL, -1}
402         };
403
404 struct menu_entries misc_menu[] = {
405         {"", NULL, NULL, NULL, NULL, -1}, 
406         {"", NULL, NULL, NULL, Format, -1},
407         {"", NULL, NULL, NULL, shell_op, -1}, 
408         {"", menu_op, spell_menu, NULL, NULL, -1}, 
409         {NULL, NULL, NULL, NULL, NULL, -1}
410         };
411
412 struct menu_entries main_menu[] = {
413         {"", NULL, NULL, NULL, NULL, -1}, 
414         {"", NULL, NULL, NULL, leave_op, -1}, 
415         {"", NULL, NULL, NULL, help, -1},
416         {"", menu_op, file_menu, NULL, NULL, -1}, 
417         {"", NULL, NULL, NULL, redraw, -1}, 
418         {"", NULL, NULL, NULL, modes_op, -1}, 
419         {"", menu_op, search_menu, NULL, NULL, -1}, 
420         {"", menu_op, misc_menu, NULL, NULL, -1}, 
421         {NULL, NULL, NULL, NULL, NULL, -1}
422         };
423
424 char *help_text[23];
425 char *control_keys[5];
426
427 char *emacs_help_text[22];
428 char *emacs_control_keys[5];
429
430 char *command_strings[5];
431 char *commands[32];
432 char *init_strings[22];
433
434 #define MENU_WARN 1
435
436 #define max_alpha_char 36
437
438 /*
439  |      Declarations for strings for localization
440  */
441
442 char *com_win_message;          /* to be shown in com_win if no info window */
443 char *no_file_string;
444 char *ascii_code_str;
445 char *printer_msg_str;
446 char *command_str;
447 char *file_write_prompt_str;
448 char *file_read_prompt_str;
449 char *char_str;
450 char *unkn_cmd_str;
451 char *non_unique_cmd_msg;
452 char *line_num_str;
453 char *line_len_str;
454 char *current_file_str;
455 char *usage0;
456 char *usage1;
457 char *usage2;
458 char *usage3;
459 char *usage4;
460 char *file_is_dir_msg;
461 char *new_file_msg;
462 char *cant_open_msg;
463 char *open_file_msg;
464 char *file_read_fin_msg;
465 char *reading_file_msg;
466 char *read_only_msg;
467 char *file_read_lines_msg;
468 char *save_file_name_prompt;
469 char *file_not_saved_msg;
470 char *changes_made_prompt;
471 char *yes_char;
472 char *file_exists_prompt;
473 char *create_file_fail_msg;
474 char *writing_file_msg;
475 char *file_written_msg;
476 char *searching_msg;
477 char *str_not_found_msg;
478 char *search_prompt_str;
479 char *exec_err_msg;
480 char *continue_msg;
481 char *menu_cancel_msg;
482 char *menu_size_err_msg;
483 char *press_any_key_msg;
484 char *shell_prompt;
485 char *formatting_msg;
486 char *shell_echo_msg;
487 char *spell_in_prog_msg;
488 char *margin_prompt;
489 char *restricted_msg;
490 char *ON;
491 char *OFF;
492 char *HELP;
493 char *WRITE;
494 char *READ;
495 char *LINE;
496 char *FILE_str;
497 char *CHARACTER;
498 char *REDRAW;
499 char *RESEQUENCE;
500 char *AUTHOR;
501 char *VERSION;
502 char *CASE;
503 char *NOCASE;
504 char *EXPAND;
505 char *NOEXPAND;
506 char *Exit_string;
507 char *QUIT_string;
508 char *INFO;
509 char *NOINFO;
510 char *MARGINS;
511 char *NOMARGINS;
512 char *AUTOFORMAT;
513 char *NOAUTOFORMAT;
514 char *Echo;
515 char *PRINTCOMMAND;
516 char *RIGHTMARGIN;
517 char *HIGHLIGHT;
518 char *NOHIGHLIGHT;
519 char *EIGHTBIT;
520 char *NOEIGHTBIT;
521 char *EMACS_string;
522 char *NOEMACS_string;
523 char *conf_dump_err_msg;
524 char *conf_dump_success_msg;
525 char *conf_not_saved_msg;
526 char *ree_no_file_msg;
527 char *cancel_string;
528 char *menu_too_lrg_msg;
529 char *more_above_str, *more_below_str;
530
531 char *chinese_cmd, *nochinese_cmd;
532
533 #ifndef __STDC__
534 #ifndef HAS_STDLIB
535 extern char *malloc();
536 extern char *realloc();
537 extern char *getenv();
538 FILE *fopen();                  /* declaration for open function        */
539 #endif /* HAS_STDLIB */
540 #endif /* __STDC__ */
541
542 int
543 main(int argc, char **argv)             /* beginning of main program            */
544 {
545         int counter;
546
547         for (counter = 1; counter < 24; counter++)
548                 signal(counter, SIG_IGN);
549
550         signal(SIGCHLD, SIG_DFL);
551         signal(SIGSEGV, SIG_DFL);
552         signal(SIGINT, edit_abort);
553         signal(SIGHUP, edit_abort);
554
555         d_char = malloc(3);     /* provide a buffer for multi-byte chars */
556         d_word = malloc(150);
557         *d_word = (char) NULL;
558         d_line = NULL;
559         dlt_line = txtalloc();
560         dlt_line->line = d_line;
561         dlt_line->line_length = 0;
562         curr_line = first_line = txtalloc();
563         curr_line->line = point = malloc(10);
564         curr_line->line_length = 1;
565         curr_line->max_length = 10;
566         curr_line->prev_line = NULL;
567         curr_line->next_line = NULL;
568         curr_line->line_number  = 1;
569         srch_str = NULL;
570         u_srch_str = NULL;
571         position = 1;
572         scr_pos =0;
573         scr_vert = 0;
574         scr_horz = 0;
575         bit_bucket = fopen(_PATH_DEVNULL, "w");
576         edit = TRUE;
577         gold = case_sen = FALSE;
578         shell_fork = TRUE;
579         strings_init();
580         ee_init();
581         if (argc > 0 )
582                 get_options(argc, argv);
583         set_up_term();
584         if (right_margin == 0)
585                 right_margin = COLS - 1;
586         if (top_of_stack == NULL)
587         {
588                 if (restrict_mode())
589                 {
590                         wmove(com_win, 0, 0);
591                         werase(com_win);
592                         wprintw(com_win, ree_no_file_msg);
593                         wrefresh(com_win);
594                         edit_abort(0);
595                 }
596                 wprintw(com_win, no_file_string);
597                 wrefresh(com_win);
598         }
599         else
600                 check_fp();
601
602         clear_com_win = TRUE;
603
604         while(edit) 
605         {
606                 if (info_window)
607                 {
608                         snprintf(count_text, count_text_len, "L: %d C: %d %s", \
609                                 curr_line->line_number, scr_horz + 1, count_text_default);
610                         wmove(count_win, 0, 0);
611                         if (!nohighlight)
612                                 wstandout(count_win);
613                         wprintw(count_win, count_text);
614                         wstandend(count_win);
615                         wnoutrefresh(count_win);
616                 }
617
618                 wnoutrefresh(text_win);
619                 doupdate();
620                 in = wgetch(text_win);
621                 if (in == -1)
622                         continue;
623
624                 resize_check();
625
626                 if (clear_com_win)
627                 {
628                         clear_com_win = FALSE;
629                         wmove(com_win, 0, 0);
630                         werase(com_win);
631                         if (!info_window)
632                         {
633                                 wprintw(com_win, "%s", com_win_message);
634                         }
635                         wrefresh(com_win);
636                 }
637
638                 if (in > 255)
639                         function_key();
640                 else if ((in == '\10') || (in == 127))
641                 {
642                         in = 8;         /* make sure key is set to backspace */
643                         delete(TRUE);
644                 }
645                 else if ((in > 31) || (in == 9))
646                         insert(in);
647                 else if ((in >= 0) && (in <= 31))
648                 {
649                         if (emacs_keys_mode)
650                                 emacs_control();
651                         else
652                                 control();
653                 }
654         }
655         return(0);
656 }
657
658 /* factor: resize factor */
659 /* rline: position in line */
660 unsigned char *
661 resiz_line(int factor, struct text *rline, int rpos)
662 /* resize the line to length + factor*/
663 {
664         unsigned char *rpoint;
665         int resiz_var;
666  
667         rline->max_length += factor;
668         rpoint = rline->line = realloc(rline->line, rline->max_length );
669         for (resiz_var = 1 ; (resiz_var < rpos) ; resiz_var++)
670                 rpoint++;
671         return(rpoint);
672 }
673
674 void 
675 insert(int character)           /* insert character into line           */
676 {
677         int counter;
678         int value;
679         unsigned char *temp;    /* temporary pointer                    */
680         unsigned char *temp2;   /* temporary pointer                    */
681
682         if ((character == '\011') && (expand_tabs))
683         {
684                 counter = len_char('\011', scr_horz);
685                 for (; counter > 0; counter--)
686                         insert(' ');
687                 if (auto_format)
688                         Auto_Format();
689                 return;
690         }
691         text_changes = TRUE;
692         if ((curr_line->max_length - curr_line->line_length) < 5)
693                 point = resiz_line(10, curr_line, position);
694         curr_line->line_length++;
695         temp = point;
696         counter = position;
697         while (counter < curr_line->line_length)        /* find end of line */
698         {
699                 counter++;
700                 temp++;
701         }
702         temp++;                 /* increase length of line by one       */
703         while (point < temp)
704         {
705                 temp2=temp - 1;
706                 *temp= *temp2;  /* shift characters over by one         */
707                 temp--;
708         }
709         *point = character;     /* insert new character                 */
710         wclrtoeol(text_win);
711         if (((character >= 0) && (character < ' ')) || (character >= 127)) /* check for TAB character*/
712         {
713                 scr_pos = scr_horz += out_char(text_win, character, scr_horz);
714                 point++;
715                 position++;
716         }
717         else
718         {
719                 waddch(text_win, character);
720                 scr_pos = ++scr_horz;
721                 point++;
722                 position ++;
723         }
724
725         if ((observ_margins) && (right_margin < scr_pos))
726         {
727                 counter = position;
728                 while (scr_pos > right_margin)
729                         prev_word();
730                 if (scr_pos == 0)
731                 {
732                         while (position < counter)
733                                 right(TRUE);
734                 }
735                 else
736                 {
737                         counter -= position;
738                         insert_line(TRUE);
739                         for (value = 0; value < counter; value++)
740                                 right(TRUE);
741                 }
742         }
743
744         if ((scr_horz - horiz_offset) > last_col)
745         {
746                 horiz_offset += 8;
747                 midscreen(scr_vert, point);
748         }
749
750         if ((auto_format) && (character == ' ') && (!formatted))
751                 Auto_Format();
752         else if ((character != ' ') && (character != '\t'))
753                 formatted = FALSE;
754
755         draw_line(scr_vert, scr_horz, point, position, curr_line->line_length);
756 }
757
758 void 
759 delete(int disp)                        /* delete character             */
760 {
761         unsigned char *tp;
762         unsigned char *temp2;
763         struct text *temp_buff;
764         int temp_vert;
765         int temp_pos;
766         int del_width = 1;
767
768         if (point != curr_line->line)   /* if not at beginning of line  */
769         {
770                 text_changes = TRUE;
771                 temp2 = tp = point;
772                 if ((ee_chinese) && (position >= 2) && (*(point - 2) > 127))
773                 {
774                         del_width = 2;
775                 }
776                 tp -= del_width;
777                 point -= del_width;
778                 position -= del_width;
779                 temp_pos = position;
780                 curr_line->line_length -= del_width;
781                 if ((*tp < ' ') || (*tp >= 127))        /* check for TAB */
782                         scanline(tp);
783                 else
784                         scr_horz -= del_width;
785                 scr_pos = scr_horz;
786                 if (in == 8)
787                 {
788                         if (del_width == 1)
789                                 *d_char = *point; /* save deleted character  */
790                         else
791                         {
792                                 d_char[0] = *point;
793                                 d_char[1] = *(point + 1);
794                         }
795                         d_char[del_width] = (unsigned char) NULL;
796                 }
797                 while (temp_pos <= curr_line->line_length)
798                 {
799                         temp_pos++;
800                         *tp = *temp2;
801                         tp++;
802                         temp2++;
803                 }
804                 if (scr_horz < horiz_offset)
805                 {
806                         horiz_offset -= 8;
807                         midscreen(scr_vert, point);
808                 }
809         }
810         else if (curr_line->prev_line != NULL)
811         {
812                 text_changes = TRUE;
813                 left(disp);                     /* go to previous line  */
814                 temp_buff = curr_line->next_line;
815                 point = resiz_line(temp_buff->line_length, curr_line, position);
816                 if (temp_buff->next_line != NULL)
817                         temp_buff->next_line->prev_line = curr_line;
818                 curr_line->next_line = temp_buff->next_line;
819                 renumber_lines(curr_line->next_line, curr_line->line_number + 1);
820                 temp2 = temp_buff->line;
821                 if (in == 8)
822                 {
823                         d_char[0] = '\n';
824                         d_char[1] = (unsigned char) NULL;
825                 }
826                 tp = point;
827                 temp_pos = 1;
828                 while (temp_pos < temp_buff->line_length)
829                 {
830                         curr_line->line_length++;
831                         temp_pos++;
832                         *tp = *temp2;
833                         tp++;
834                         temp2++;
835                 }
836                 *tp = (char) NULL;
837                 free(temp_buff->line);
838                 free(temp_buff);
839                 temp_buff = curr_line;
840                 temp_vert = scr_vert;
841                 scr_pos = scr_horz;
842                 if (scr_vert < last_line)
843                 {
844                         wmove(text_win, scr_vert + 1, 0);
845                         wdeleteln(text_win);
846                 }
847                 while ((temp_buff != NULL) && (temp_vert < last_line))
848                 {
849                         temp_buff = temp_buff->next_line;
850                         temp_vert++;
851                 }
852                 if ((temp_vert == last_line) && (temp_buff != NULL))
853                 {
854                         tp = temp_buff->line;
855                         wmove(text_win, last_line,0);
856                         wclrtobot(text_win);
857                         draw_line(last_line, 0, tp, 1, temp_buff->line_length);
858                         wmove(text_win, scr_vert, (scr_horz - horiz_offset));
859                 }
860         }
861         draw_line(scr_vert, scr_horz, point, position, curr_line->line_length);
862         formatted = FALSE;
863 }
864
865 void 
866 scanline(unsigned char *pos)    /* find the proper horizontal position for the pointer  */
867 {
868         int temp;
869         unsigned char *ptr;
870
871         ptr = curr_line->line;
872         temp = 0;
873         while (ptr < pos)
874         {
875                 if (*ptr <= 8)
876                         temp += 2;
877                 else if (*ptr == 9)
878                         temp += tabshift(temp);
879                 else if ((*ptr >= 10) && (*ptr <= 31))
880                         temp += 2;
881                 else if ((*ptr >= 32) && (*ptr < 127))
882                         temp++;
883                 else if (*ptr == 127)
884                         temp += 2;
885                 else if (!eightbit)
886                         temp += 5;
887                 else
888                         temp++;
889                 ptr++;
890         }
891         scr_horz = temp;
892         if ((scr_horz - horiz_offset) > last_col)
893         {
894                 horiz_offset = (scr_horz - (scr_horz % 8)) - (COLS - 8);
895                 midscreen(scr_vert, point);
896         }
897         else if (scr_horz < horiz_offset)
898         {
899                 horiz_offset = max(0, (scr_horz - (scr_horz % 8)));
900                 midscreen(scr_vert, point);
901         }
902 }
903
904 int 
905 tabshift(int temp_int)          /* give the number of spaces to shift   */
906 {
907         int leftover;
908
909         leftover = ((temp_int + 1) % 8);
910         if (leftover == 0)
911                 return (1);
912         else
913                 return (9 - leftover);
914 }
915
916 int 
917 out_char(WINDOW *window, int character, int column)
918 /* output non-printing character */
919 {
920         int i1, i2;
921         unsigned char *string;
922         char string2[8];
923
924         if (character == TAB)
925         {
926                 i1 = tabshift(column);
927                 for (i2 = 0; 
928                   (i2 < i1) && (((column+i2+1)-horiz_offset) < last_col); i2++)
929                 {
930                         waddch(window, ' ');
931                 }
932                 return(i1);
933         }
934         else if ((character >= '\0') && (character < ' '))
935         {
936                 string = table[(int) character];
937         }
938         else if ((character < 0) || (character >= 127))
939         {
940                 if (character == 127)
941                         string = "^?";
942                 else if (!eightbit)
943                 {
944                         sprintf(string2, "<%d>", (character < 0) ? (character + 256) : character);
945                         string = string2;
946                 }
947                 else
948                 {
949                         waddch(window, (unsigned char)character );
950                         return(1);
951                 }
952         }
953         else
954         {
955                 waddch(window, (unsigned char)character);
956                 return(1);
957         }
958         for (i2 = 0; (string[i2] != (char) NULL) && (((column+i2+1)-horiz_offset) < last_col); i2++)
959                 waddch(window, string[i2]);
960         return(strlen(string));
961 }
962
963 /* column: the column must be known to provide spacing for tabs */
964 int
965 len_char(int character, int column)     /* return the length of the character   */
966 {
967         int length;
968
969         if (character == '\t')
970                 length = tabshift(column);
971         else if ((character >= 0) && (character < 32))
972                 length = 2;
973         else if ((character >= 32) && (character <= 126))
974                 length = 1;
975         else if (character == 127)
976                 length = 2;
977         else if (((character > 126) || (character < 0)) && (!eightbit))
978                 length = 5;
979         else
980                 length = 1;
981
982         return(length);
983 }
984
985 /*
986 vertical: current vertical position on screen
987 horiz:  current horizontal position on screen
988 ptr:    pointer to line
989 t_pos:  current position (offset in bytes) from bol
990 length: length (in bytes) of line
991 */
992 void
993 draw_line(int vertical, int horiz, unsigned char *ptr, int t_pos, int length)
994 /* redraw line from current position */
995 {
996         int d;          /* partial length of special or tab char to display  */
997         unsigned char *temp;    /* temporary pointer to position in line             */
998         int abs_column; /* offset in screen units from begin of line         */
999         int column;     /* horizontal position on screen                     */
1000         int row;        /* vertical position on screen                       */
1001         int posit;      /* temporary position indicator within line          */
1002
1003         abs_column = horiz;
1004         column = horiz - horiz_offset;
1005         row = vertical;
1006         temp = ptr;
1007         d = 0;
1008         posit = t_pos;
1009         if (column < 0)
1010         {
1011                 wmove(text_win, row, 0);
1012                 wclrtoeol(text_win);
1013         }
1014         while (column < 0)
1015         {
1016                 d = len_char(*temp, abs_column);
1017                 abs_column += d;
1018                 column += d;
1019                 posit++;
1020                 temp++;
1021         }
1022         wmove(text_win, row, column);
1023         wclrtoeol(text_win);
1024         while ((posit < length) && (column <= last_col))
1025         {
1026                 if ((*temp < 32) || (*temp >= 127))
1027                 {
1028                         column += len_char(*temp, abs_column);
1029                         abs_column += out_char(text_win, *temp, abs_column);
1030                 }
1031                 else
1032                 {
1033                         abs_column++;
1034                         column++;
1035                         waddch(text_win, *temp);
1036                 }
1037                 posit++;
1038                 temp++;
1039         }
1040         if (column < last_col)
1041                 wclrtoeol(text_win);
1042         wmove(text_win, vertical, (horiz - horiz_offset));
1043 }
1044
1045 void 
1046 insert_line(int disp)                   /* insert new line              */
1047 {
1048         int temp_pos;
1049         int temp_pos2;
1050         unsigned char *temp;
1051         unsigned char *extra;
1052         struct text *temp_nod;
1053
1054         text_changes = TRUE;
1055         wmove(text_win, scr_vert, (scr_horz - horiz_offset));
1056         wclrtoeol(text_win);
1057         temp_nod= txtalloc();
1058         temp_nod->line = extra= malloc(10);
1059         temp_nod->line_length = 1;
1060         temp_nod->max_length = 10;
1061         temp_nod->next_line = curr_line->next_line;
1062         renumber_lines(temp_nod, curr_line->line_number + 1);
1063         if (temp_nod->next_line != NULL)
1064                 temp_nod->next_line->prev_line = temp_nod;
1065         temp_nod->prev_line = curr_line;
1066         curr_line->next_line = temp_nod;
1067         temp_pos2 = position;
1068         temp = point;
1069         if (temp_pos2 < curr_line->line_length)
1070         {
1071                 temp_pos = 1;
1072                 while (temp_pos2 < curr_line->line_length)
1073                 {
1074                         if ((temp_nod->max_length - temp_nod->line_length)< 5)
1075                                 extra = resiz_line(10, temp_nod, temp_pos);
1076                         temp_nod->line_length++;
1077                         temp_pos++;
1078                         temp_pos2++;
1079                         *extra= *temp;
1080                         extra++;
1081                         temp++;
1082                 }
1083                 temp=point;
1084                 *temp = (char) NULL;
1085                 temp = resiz_line((1 - temp_nod->line_length), curr_line, position);
1086                 curr_line->line_length = 1 + temp - curr_line->line;
1087         }
1088         curr_line->line_length = position;
1089         curr_line = temp_nod;
1090         *extra = (char) NULL;
1091         position = 1;
1092         point= curr_line->line;
1093         if (disp)
1094         {
1095                 if (scr_vert < last_line)
1096                 {
1097                         scr_vert++;
1098                         wclrtoeol(text_win);
1099                         wmove(text_win, scr_vert, 0);
1100                         winsertln(text_win);
1101                 }
1102                 else
1103                 {
1104                         wmove(text_win, 0,0);
1105                         wdeleteln(text_win);
1106                         wmove(text_win, last_line,0);
1107                         wclrtobot(text_win);
1108                 }
1109                 scr_pos = scr_horz = 0;
1110                 if (horiz_offset)
1111                 {
1112                         horiz_offset = 0;
1113                         midscreen(scr_vert, point);
1114                 }
1115                 draw_line(scr_vert, scr_horz, point, position,
1116                         curr_line->line_length);
1117         }
1118 }
1119
1120 struct text *txtalloc(void)             /* allocate space for line structure    */
1121 {
1122         return((struct text *) malloc(sizeof( struct text)));
1123 }
1124
1125 struct files *name_alloc(void)  /* allocate space for file name list node */
1126 {
1127         return((struct files *) malloc(sizeof( struct files)));
1128 }
1129
1130 unsigned char *next_word(unsigned char *string)
1131 /* move to next word in string */
1132 {
1133         while ((*string != (char) NULL) && ((*string != 32) && (*string != 9)))
1134                 string++;
1135         while ((*string != (char) NULL) && ((*string == 32) || (*string == 9)))
1136                 string++;
1137         return(string);
1138 }
1139
1140 void 
1141 prev_word(void) /* move to start of previous word in text       */
1142 {
1143         if (position != 1)
1144         {
1145                 if ((position != 1) && ((point[-1] == ' ') || (point[-1] == '\t')))
1146                 {       /* if at the start of a word    */
1147                         while ((position != 1) && ((*point != ' ') && (*point != '\t')))
1148                                 left(TRUE);
1149                 }
1150                 while ((position != 1) && ((*point == ' ') || (*point == '\t')))
1151                         left(TRUE);
1152                 while ((position != 1) && ((*point != ' ') && (*point != '\t')))
1153                         left(TRUE);
1154                 if ((position != 1) && ((*point == ' ') || (*point == '\t')))
1155                         right(TRUE);
1156         }
1157         else
1158                 left(TRUE);
1159 }
1160
1161 void 
1162 control(void)                   /* use control for commands             */
1163 {
1164         char *string;
1165
1166         if (in == 1)            /* control a    */
1167         {
1168                 string = get_string(ascii_code_str, TRUE);
1169                 if (*string != (char) NULL)
1170                 {
1171                         in = atoi(string);
1172                         wmove(text_win, scr_vert, (scr_horz - horiz_offset));
1173                         insert(in);
1174                 }
1175                 free(string);
1176         }
1177         else if (in == 2)       /* control b    */
1178                 bottom();
1179         else if (in == 3)       /* control c    */
1180         {
1181                 command_prompt();
1182         }
1183         else if (in == 4)       /* control d    */
1184                 down();
1185         else if (in == 5)       /* control e    */
1186                 search_prompt();
1187         else if (in == 6)       /* control f    */
1188                 undel_char();
1189         else if (in == 7)       /* control g    */
1190                 bol();
1191         else if (in == 8)       /* control h    */
1192                 delete(TRUE);
1193         else if (in == 9)       /* control i    */
1194                 ;
1195         else if (in == 10)      /* control j    */
1196                 insert_line(TRUE);
1197         else if (in == 11)      /* control k    */
1198                 del_char();
1199         else if (in == 12)      /* control l    */
1200                 left(TRUE);
1201         else if (in == 13)      /* control m    */
1202                 insert_line(TRUE);
1203         else if (in == 14)      /* control n    */
1204                 move_rel("d", max(5, (last_line - 5)));
1205         else if (in == 15)      /* control o    */
1206                 eol();
1207         else if (in == 16)      /* control p    */
1208                 move_rel("u", max(5, (last_line - 5)));
1209         else if (in == 17)      /* control q    */
1210                 ;
1211         else if (in == 18)      /* control r    */
1212                 right(TRUE);
1213         else if (in == 19)      /* control s    */
1214                 ;
1215         else if (in == 20)      /* control t    */
1216                 top();
1217         else if (in == 21)      /* control u    */
1218                 up();
1219         else if (in == 22)      /* control v    */
1220                 undel_word();
1221         else if (in == 23)      /* control w    */
1222                 del_word();
1223         else if (in == 24)      /* control x    */
1224                 search(TRUE);
1225         else if (in == 25)      /* control y    */
1226                 del_line();
1227         else if (in == 26)      /* control z    */
1228                 undel_line();
1229         else if (in == 27)      /* control [ (escape)   */
1230         {
1231                 menu_op(main_menu);
1232         }       
1233 }
1234
1235 /*
1236  |      Emacs control-key bindings
1237  */
1238
1239 void 
1240 emacs_control(void)
1241 {
1242         char *string;
1243
1244         if (in == 1)            /* control a    */
1245                 bol();
1246         else if (in == 2)       /* control b    */
1247                 left(TRUE);
1248         else if (in == 3)       /* control c    */
1249         {
1250                 command_prompt();
1251         }
1252         else if (in == 4)       /* control d    */
1253                 del_char();
1254         else if (in == 5)       /* control e    */
1255                 eol();
1256         else if (in == 6)       /* control f    */
1257                 right(TRUE);
1258         else if (in == 7)       /* control g    */
1259                 move_rel("u", max(5, (last_line - 5)));
1260         else if (in == 8)       /* control h    */
1261                 delete(TRUE);
1262         else if (in == 9)       /* control i    */
1263                 ;
1264         else if (in == 10)      /* control j    */
1265                 undel_char();
1266         else if (in == 11)      /* control k    */
1267                 del_line();
1268         else if (in == 12)      /* control l    */
1269                 undel_line();
1270         else if (in == 13)      /* control m    */
1271                 insert_line(TRUE);
1272         else if (in == 14)      /* control n    */
1273                 down();
1274         else if (in == 15)      /* control o    */
1275         {
1276                 string = get_string(ascii_code_str, TRUE);
1277                 if (*string != (char) NULL)
1278                 {
1279                         in = atoi(string);
1280                         wmove(text_win, scr_vert, (scr_horz - horiz_offset));
1281                         insert(in);
1282                 }
1283                 free(string);
1284         }
1285         else if (in == 16)      /* control p    */
1286                 up();
1287         else if (in == 17)      /* control q    */
1288                 ;
1289         else if (in == 18)      /* control r    */
1290                 undel_word();
1291         else if (in == 19)      /* control s    */
1292                 ;
1293         else if (in == 20)      /* control t    */
1294                 top();
1295         else if (in == 21)      /* control u    */
1296                 bottom();
1297         else if (in == 22)      /* control v    */
1298                 move_rel("d", max(5, (last_line - 5)));
1299         else if (in == 23)      /* control w    */
1300                 del_word();
1301         else if (in == 24)      /* control x    */
1302                 search(TRUE);
1303         else if (in == 25)      /* control y    */
1304                 search_prompt();
1305         else if (in == 26)      /* control z    */
1306                 adv_word();
1307         else if (in == 27)      /* control [ (escape)   */
1308         {
1309                 menu_op(main_menu);
1310         }       
1311 }
1312
1313 void 
1314 bottom(void)                    /* go to bottom of file                 */
1315 {
1316         while (curr_line->next_line != NULL)
1317                 curr_line = curr_line->next_line;
1318         point = curr_line->line;
1319         if (horiz_offset)
1320                 horiz_offset = 0;
1321         position = 1;
1322         midscreen(last_line, point);
1323         scr_pos = scr_horz;
1324 }
1325
1326 void 
1327 top(void)                               /* go to top of file                    */
1328 {
1329         while (curr_line->prev_line != NULL)
1330                 curr_line = curr_line->prev_line;
1331         point = curr_line->line;
1332         if (horiz_offset)
1333                 horiz_offset = 0;
1334         position = 1;
1335         midscreen(0, point);
1336         scr_pos = scr_horz;
1337 }
1338
1339 void 
1340 nextline(void)                  /* move pointers to start of next line  */
1341 {
1342         curr_line = curr_line->next_line;
1343         point = curr_line->line;
1344         position = 1;
1345         if (scr_vert == last_line)
1346         {
1347                 wmove(text_win, 0,0);
1348                 wdeleteln(text_win);
1349                 wmove(text_win, last_line,0);
1350                 wclrtobot(text_win);
1351                 draw_line(last_line,0,point,1,curr_line->line_length);
1352         }
1353         else
1354                 scr_vert++;
1355 }
1356
1357 void 
1358 prevline(void)                  /* move pointers to start of previous line*/
1359 {
1360         curr_line = curr_line->prev_line;
1361         point = curr_line->line;
1362         position = 1;
1363         if (scr_vert == 0)
1364         {
1365                 winsertln(text_win);
1366                 draw_line(0,0,point,1,curr_line->line_length);
1367         }
1368         else
1369                 scr_vert--;
1370         while (position < curr_line->line_length)
1371         {
1372                 position++;
1373                 point++;
1374         }
1375 }
1376
1377 void 
1378 left(int disp)                          /* move left one character      */
1379 {
1380         if (point != curr_line->line)   /* if not at begin of line      */
1381         {
1382                 if ((ee_chinese) && (position >= 2) && (*(point - 2) > 127))
1383                 {
1384                         point--;
1385                         position--;
1386                 }
1387                 point--;
1388                 position--;
1389                 scanline(point);
1390                 wmove(text_win, scr_vert, (scr_horz - horiz_offset));
1391                 scr_pos = scr_horz;
1392         }
1393         else if (curr_line->prev_line != NULL)
1394         {
1395                 if (!disp)
1396                 {
1397                         curr_line = curr_line->prev_line;
1398                         point = curr_line->line + curr_line->line_length;
1399                         position = curr_line->line_length;
1400                         return;
1401                 }
1402                 position = 1;
1403                 prevline();
1404                 scanline(point);
1405                 scr_pos = scr_horz;
1406                 wmove(text_win, scr_vert, (scr_horz - horiz_offset));
1407         }
1408 }
1409
1410 void 
1411 right(int disp)                         /* move right one character     */
1412 {
1413         if (position < curr_line->line_length)
1414         {
1415                 if ((ee_chinese) && (*point > 127) && 
1416                     ((curr_line->line_length - position) >= 2))
1417                 {
1418                         point++;
1419                         position++;
1420                 }
1421                 point++;
1422                 position++;
1423                 scanline(point);
1424                 wmove(text_win, scr_vert, (scr_horz - horiz_offset));
1425                 scr_pos = scr_horz;
1426         }
1427         else if (curr_line->next_line != NULL)
1428         {
1429                 if (!disp)
1430                 {
1431                         curr_line = curr_line->next_line;
1432                         point = curr_line->line;
1433                         position = 1;
1434                         return;
1435                 }
1436                 nextline();
1437                 scr_pos = scr_horz = 0;
1438                 if (horiz_offset)
1439                 {
1440                         horiz_offset = 0;
1441                         midscreen(scr_vert, point);
1442                 }
1443                 wmove(text_win, scr_vert, (scr_horz - horiz_offset));
1444                 position = 1;   
1445         }
1446 }
1447
1448 void 
1449 find_pos(void)          /* move to the same column as on other line     */
1450 {
1451         scr_horz = 0;
1452         position = 1;
1453         while ((scr_horz < scr_pos) && (position < curr_line->line_length))
1454         {
1455                 if (*point == 9)
1456                         scr_horz += tabshift(scr_horz);
1457                 else if (*point < ' ')
1458                         scr_horz += 2;
1459                 else if ((ee_chinese) && (*point > 127) && 
1460                     ((curr_line->line_length - position) >= 2))
1461                 {
1462                         scr_horz += 2;
1463                         point++;
1464                         position++;
1465                 }
1466                 else
1467                         scr_horz++;
1468                 position++;
1469                 point++;
1470         }
1471         if ((scr_horz - horiz_offset) > last_col)
1472         {
1473                 horiz_offset = (scr_horz - (scr_horz % 8)) - (COLS - 8);
1474                 midscreen(scr_vert, point);
1475         }
1476         else if (scr_horz < horiz_offset)
1477         {
1478                 horiz_offset = max(0, (scr_horz - (scr_horz % 8)));
1479                 midscreen(scr_vert, point);
1480         }
1481         wmove(text_win, scr_vert, (scr_horz - horiz_offset));
1482 }
1483
1484 void 
1485 up(void)                                        /* move up one line             */
1486 {
1487         if (curr_line->prev_line != NULL)
1488         {
1489                 prevline();
1490                 point = curr_line->line;
1491                 find_pos();
1492         }
1493 }
1494
1495 void 
1496 down(void)                                      /* move down one line           */
1497 {
1498         if (curr_line->next_line != NULL)
1499         {
1500                 nextline();
1501                 find_pos();
1502         }
1503 }
1504
1505 void 
1506 function_key(void)                              /* process function key         */
1507 {
1508         if (in == KEY_LEFT)
1509                 left(TRUE);
1510         else if (in == KEY_RIGHT)
1511                 right(TRUE);
1512         else if (in == KEY_HOME)
1513                 bol();
1514         else if (in == KEY_END)
1515                 eol();
1516         else if ( in == KEY_UP)
1517                 up();
1518         else if (in == KEY_DOWN)
1519                 down();
1520         else if (in == KEY_NPAGE)
1521                 move_rel("d", max( 5, (last_line - 5)));
1522         else if (in == KEY_PPAGE)
1523                 move_rel("u", max(5, (last_line - 5)));
1524         else if (in == KEY_DL)
1525                 del_line();
1526         else if (in == KEY_DC)
1527                 del_char();
1528         else if (in == KEY_BACKSPACE)
1529                 delete(TRUE);
1530         else if (in == KEY_IL)
1531         {               /* insert a line before current line    */
1532                 insert_line(TRUE);
1533                 left(TRUE);
1534         }
1535         else if (in == KEY_F(1))
1536                 gold = !gold;
1537         else if (in == KEY_F(2))
1538         {
1539                 if (gold)
1540                 {
1541                         gold = FALSE;
1542                         undel_line();
1543                 }
1544                 else
1545                         undel_char();
1546         }
1547         else if (in == KEY_F(3))
1548         {
1549                 if (gold)
1550                 {
1551                         gold = FALSE;
1552                         undel_word();
1553                 }
1554                 else
1555                         del_word();
1556         }
1557         else if (in == KEY_F(4))
1558         {
1559                 if (gold)
1560                 {
1561                         gold = FALSE;
1562                         paint_info_win();
1563                         midscreen(scr_vert, point);
1564                 }
1565                 else
1566                         adv_word();
1567         }
1568         else if (in == KEY_F(5))
1569         {
1570                 if (gold)
1571                 {
1572                         gold = FALSE;
1573                         search_prompt();
1574                 }
1575                 else
1576                         search(TRUE);
1577         }
1578         else if (in == KEY_F(6))
1579         {
1580                 if (gold)
1581                 {
1582                         gold = FALSE;
1583                         bottom();
1584                 }
1585                 else
1586                         top();
1587         }
1588         else if (in == KEY_F(7))
1589         {
1590                 if (gold)
1591                 {
1592                         gold = FALSE;
1593                         eol();
1594                 }
1595                 else
1596                         bol();
1597         }
1598         else if (in == KEY_F(8))
1599         {
1600                 if (gold)
1601                 {
1602                         gold = FALSE;
1603                         command_prompt();
1604                 } 
1605                 else
1606                         adv_line();
1607         }
1608 }
1609
1610 void 
1611 print_buffer(void)
1612 {
1613         char buffer[256];
1614
1615         sprintf(buffer, ">!%s", print_command);
1616         wmove(com_win, 0, 0);
1617         wclrtoeol(com_win);
1618         wprintw(com_win, printer_msg_str, print_command);
1619         wrefresh(com_win);
1620         command(buffer);
1621 }
1622
1623 void 
1624 command_prompt(void)
1625 {
1626         char *cmd_str;
1627         int result;
1628
1629         info_type = COMMANDS;
1630         paint_info_win();
1631         cmd_str = get_string(command_str, TRUE);
1632         if ((result = unique_test(cmd_str, commands)) != 1)
1633         {
1634                 werase(com_win);
1635                 wmove(com_win, 0, 0);
1636                 if (result == 0)
1637                         wprintw(com_win, unkn_cmd_str, cmd_str);
1638                 else
1639                         wprintw(com_win, non_unique_cmd_msg);
1640
1641                 wrefresh(com_win);
1642
1643                 info_type = CONTROL_KEYS;
1644                 paint_info_win();
1645
1646                 if (cmd_str != NULL)
1647                         free(cmd_str);
1648                 return;
1649         }
1650         command(cmd_str);
1651         wrefresh(com_win);
1652         wmove(text_win, scr_vert, (scr_horz - horiz_offset));
1653         info_type = CONTROL_KEYS;
1654         paint_info_win();
1655         if (cmd_str != NULL)
1656                 free(cmd_str);
1657 }
1658
1659 void 
1660 command(char *cmd_str1)         /* process commands from keyboard       */
1661 {
1662         char *cmd_str2 = NULL;
1663         char *cmd_str = cmd_str1;
1664
1665         clear_com_win = TRUE;
1666         if (compare(cmd_str, HELP, FALSE))
1667                 help();
1668         else if (compare(cmd_str, WRITE, FALSE))
1669         {
1670                 if (restrict_mode())
1671                 {
1672                         return;
1673                 }
1674                 cmd_str = next_word(cmd_str);
1675                 if (*cmd_str == (char) NULL)
1676                 {
1677                         cmd_str = cmd_str2 = get_string(file_write_prompt_str, TRUE);
1678                 }
1679                 tmp_file = resolve_name(cmd_str);
1680                 write_file(tmp_file, 1);
1681                 if (tmp_file != cmd_str)
1682                         free(tmp_file);
1683         }
1684         else if (compare(cmd_str, READ, FALSE))
1685         {
1686                 if (restrict_mode())
1687                 {
1688                         return;
1689                 }
1690                 cmd_str = next_word(cmd_str);
1691                 if (*cmd_str == (char) NULL)
1692                 {
1693                         cmd_str = cmd_str2 = get_string(file_read_prompt_str, TRUE);
1694                 }
1695                 tmp_file = cmd_str;
1696                 recv_file = TRUE;
1697                 tmp_file = resolve_name(cmd_str);
1698                 check_fp();
1699                 if (tmp_file != cmd_str)
1700                         free(tmp_file);
1701         }
1702         else if (compare(cmd_str, LINE, FALSE))
1703         {
1704                 wmove(com_win, 0, 0);
1705                 wclrtoeol(com_win);
1706                 wprintw(com_win, line_num_str, curr_line->line_number);
1707                 wprintw(com_win, line_len_str, curr_line->line_length);
1708         }
1709         else if (compare(cmd_str, FILE_str, FALSE))
1710         {
1711                 wmove(com_win, 0, 0);
1712                 wclrtoeol(com_win);
1713                 if (in_file_name == NULL)
1714                         wprintw(com_win, no_file_string);
1715                 else
1716                         wprintw(com_win, current_file_str, in_file_name);
1717         }
1718         else if ((*cmd_str >= '0') && (*cmd_str <= '9'))
1719                 goto_line(cmd_str);
1720         else if (compare(cmd_str, CHARACTER, FALSE))
1721         {
1722                 wmove(com_win, 0, 0);
1723                 wclrtoeol(com_win);
1724                 wprintw(com_win, char_str, *point);
1725         }
1726         else if (compare(cmd_str, REDRAW, FALSE))
1727                 redraw();
1728         else if (compare(cmd_str, RESEQUENCE, FALSE))
1729         {
1730                 tmp_line = first_line->next_line;
1731                 while (tmp_line != NULL)
1732                 {
1733                 tmp_line->line_number = tmp_line->prev_line->line_number + 1;
1734                         tmp_line = tmp_line->next_line;
1735                 }
1736         }
1737         else if (compare(cmd_str, AUTHOR, FALSE))
1738         {
1739                 wmove(com_win, 0, 0);
1740                 wclrtoeol(com_win);
1741                 wprintw(com_win, "written by Hugh Mahon");
1742         }
1743         else if (compare(cmd_str, VERSION, FALSE))
1744         {
1745                 wmove(com_win, 0, 0);
1746                 wclrtoeol(com_win);
1747                 wprintw(com_win, "%s", version);
1748         }
1749         else if (compare(cmd_str, CASE, FALSE))
1750                 case_sen = TRUE;
1751         else if (compare(cmd_str, NOCASE, FALSE))
1752                 case_sen = FALSE;
1753         else if (compare(cmd_str, EXPAND, FALSE))
1754                 expand_tabs = TRUE;
1755         else if (compare(cmd_str, NOEXPAND, FALSE))
1756                 expand_tabs = FALSE;
1757         else if (compare(cmd_str, Exit_string, FALSE))
1758                 finish();
1759         else if (compare(cmd_str, chinese_cmd, FALSE))
1760         {
1761                 ee_chinese = TRUE;
1762 #ifdef NCURSE
1763                 nc_setattrib(A_NC_BIG5);
1764 #endif /* NCURSE */
1765         }
1766         else if (compare(cmd_str, nochinese_cmd, FALSE))
1767         {
1768                 ee_chinese = FALSE;
1769 #ifdef NCURSE
1770                 nc_clearattrib(A_NC_BIG5);
1771 #endif /* NCURSE */
1772         }
1773         else if (compare(cmd_str, QUIT_string, FALSE))
1774                 quit(0);
1775         else if (*cmd_str == '!')
1776         {
1777                 cmd_str++;
1778                 if ((*cmd_str == ' ') || (*cmd_str == 9))
1779                         cmd_str = next_word(cmd_str);
1780                 sh_command(cmd_str);
1781         }
1782         else if ((*cmd_str == '<') && (!in_pipe))
1783         {
1784                 in_pipe = TRUE;
1785                 shell_fork = FALSE;
1786                 cmd_str++;
1787                 if ((*cmd_str == ' ') || (*cmd_str == '\t'))
1788                         cmd_str = next_word(cmd_str);
1789                 command(cmd_str);
1790                 in_pipe = FALSE;
1791                 shell_fork = TRUE;
1792         }
1793         else if ((*cmd_str == '>') && (!out_pipe))
1794         {
1795                 out_pipe = TRUE;
1796                 cmd_str++;
1797                 if ((*cmd_str == ' ') || (*cmd_str == '\t'))
1798                         cmd_str = next_word(cmd_str);
1799                 command(cmd_str);
1800                 out_pipe = FALSE;
1801         }
1802         else
1803         {
1804                 wmove(com_win, 0, 0);
1805                 wclrtoeol(com_win);
1806                 wprintw(com_win, unkn_cmd_str, cmd_str);
1807         }
1808         if (cmd_str2 != NULL)
1809                 free(cmd_str2);
1810 }
1811
1812 int 
1813 scan(char *line, int offset, int column)
1814 /* determine horizontal position for get_string */
1815 {
1816         char *stemp;
1817         int i;
1818         int j;
1819
1820         stemp = line;
1821         i = 0;
1822         j = column;
1823         while (i < offset)
1824         {
1825                 i++;
1826                 j += len_char(*stemp, j);
1827                 stemp++;
1828         }
1829         return(j);
1830 }
1831
1832 /*
1833 prompt: string containing user prompt message
1834 advance: if true, skip leading spaces and tabs
1835 */
1836 char *
1837 get_string(char *prompt, int advance)
1838 /* read string from input on command line */
1839 {
1840         char *string;
1841         char *tmp_string;
1842         char *nam_str;
1843         char *g_point;
1844         int tmp_int;
1845         int g_horz, g_position, g_pos;
1846         int esc_flag;
1847
1848         g_point = tmp_string = malloc(512);
1849         wmove(com_win,0,0);
1850         wclrtoeol(com_win);
1851         waddstr(com_win, prompt);
1852         wrefresh(com_win);
1853         nam_str = tmp_string;
1854         clear_com_win = TRUE;
1855         g_horz = g_position = scan(prompt, strlen(prompt), 0);
1856         g_pos = 0;
1857         do
1858         {
1859                 esc_flag = FALSE;
1860                 in = wgetch(com_win);
1861                 if (in == -1)
1862                         continue;
1863                 if (((in == 8) || (in == 127) || (in == KEY_BACKSPACE)) && (g_pos > 0))
1864                 {
1865                         tmp_int = g_horz;
1866                         g_pos--;
1867                         g_horz = scan(g_point, g_pos, g_position);
1868                         tmp_int = tmp_int - g_horz;
1869                         for (; 0 < tmp_int; tmp_int--)
1870                         {
1871                                 if ((g_horz+tmp_int) < (last_col - 1))
1872                                 {
1873                                         waddch(com_win, '\010');
1874                                         waddch(com_win, ' ');
1875                                         waddch(com_win, '\010');
1876                                 }
1877                         }
1878                         nam_str--;
1879                 }
1880                 else if ((in != 8) && (in != 127) && (in != '\n') && (in != '\r') && (in < 256))
1881                 {
1882                         if (in == '\026')       /* control-v, accept next character verbatim    */
1883                         {                       /* allows entry of ^m, ^j, and ^h       */
1884                                 esc_flag = TRUE;
1885                                 in = wgetch(com_win);
1886                                 if (in == -1)
1887                                         continue;
1888                         }
1889                         *nam_str = in;
1890                         g_pos++;
1891                         if (((in < ' ') || (in > 126)) && (g_horz < (last_col - 1)))
1892                                 g_horz += out_char(com_win, in, g_horz);
1893                         else
1894                         {
1895                                 g_horz++;
1896                                 if (g_horz < (last_col - 1))
1897                                         waddch(com_win, in);
1898                         }
1899                         nam_str++;
1900                 }
1901                 wrefresh(com_win);
1902                 if (esc_flag)
1903                         in = (char) NULL;
1904         } while ((in != '\n') && (in != '\r'));
1905         *nam_str = (char) NULL;
1906         nam_str = tmp_string;
1907         if (((*nam_str == ' ') || (*nam_str == 9)) && (advance))
1908                 nam_str = next_word(nam_str);
1909         string = malloc(strlen(nam_str) + 1);
1910         strcpy(string, nam_str);
1911         free(tmp_string);
1912         wrefresh(com_win);
1913         return(string);
1914 }
1915
1916 int 
1917 compare(char *string1, char *string2, int sensitive) /* compare two strings */
1918 {
1919         char *strng1;
1920         char *strng2;
1921         int tmp;
1922         int equal;
1923
1924         strng1 = string1;
1925         strng2 = string2;
1926         tmp = 0;
1927         if ((strng1 == NULL) || (strng2 == NULL) || (*strng1 == (char) NULL) || (*strng2 == (char) NULL))
1928                 return(FALSE);
1929         equal = TRUE;
1930         while (equal)
1931         {
1932                 if (sensitive)
1933                 {
1934                         if (*strng1 != *strng2)
1935                                 equal = FALSE;
1936                 }
1937                 else
1938                 {
1939                         if (toupper(*strng1) != toupper(*strng2))
1940                                 equal = FALSE;
1941                 }
1942                 strng1++;
1943                 strng2++;
1944                 if ((*strng1 == (char) NULL) || (*strng2 == (char) NULL) || (*strng1 == ' ') || (*strng2 == ' '))
1945                         break;
1946                 tmp++;
1947         }
1948         return(equal);
1949 }
1950
1951 void 
1952 goto_line(char *cmd_str)
1953 {
1954         int number;
1955         int i;
1956         char *ptr;
1957         char *direction = NULL;
1958         struct text *t_line;
1959
1960         ptr = cmd_str;
1961         i= 0;
1962         while ((*ptr >='0') && (*ptr <= '9'))
1963         {
1964                 i= i * 10 + (*ptr - '0');
1965                 ptr++;
1966         }
1967         number = i;
1968         i = 0;
1969         t_line = curr_line;
1970         while ((t_line->line_number > number) && (t_line->prev_line != NULL))
1971         {
1972                 i++;
1973                 t_line = t_line->prev_line;
1974                 direction = "u";
1975         }
1976         while ((t_line->line_number < number) && (t_line->next_line != NULL))
1977         {
1978                 i++;
1979                 direction = "d";
1980                 t_line = t_line->next_line;
1981         }
1982         if ((i < 30) && (i > 0))
1983         {
1984                 move_rel(direction, i);
1985         }
1986         else
1987         {
1988                 curr_line = t_line;
1989                 point = curr_line->line;
1990                 position = 1;
1991                 midscreen((last_line / 2), point);
1992                 scr_pos = scr_horz;
1993         }
1994         wmove(com_win, 0, 0);
1995         wclrtoeol(com_win);
1996         wprintw(com_win, line_num_str, curr_line->line_number);
1997         wmove(text_win, scr_vert, (scr_horz - horiz_offset));
1998 }
1999
2000 void 
2001 midscreen(int line, unsigned char *pnt)
2002 /* put current line in middle of screen */
2003 {
2004         struct text *mid_line;
2005         int i;
2006
2007         line = min(line, last_line);
2008         mid_line = curr_line;
2009         for (i = 0; ((i < line) && (curr_line->prev_line != NULL)); i++)
2010                 curr_line = curr_line->prev_line;
2011         scr_vert = scr_horz = 0;
2012         wmove(text_win, 0, 0);
2013         draw_screen();
2014         scr_vert = i;
2015         curr_line = mid_line;
2016         scanline(pnt);
2017         wmove(text_win, scr_vert, (scr_horz - horiz_offset));
2018 }
2019
2020 void 
2021 get_options(int numargs, char **arguments)
2022 /* get arguments from command line */
2023 {
2024         char *buff;
2025         int count;
2026         struct files *temp_names = NULL;
2027         char *name;
2028         char *ptr;
2029
2030         /*
2031          |      see if editor was invoked as 'ree' (restricted mode)
2032          */
2033
2034         if (!(name = strrchr(arguments[0], '/')))
2035                 name = arguments[0];
2036         else
2037                 name++;
2038         if (!strcmp(name, "ree"))
2039                 restricted = TRUE;
2040
2041         top_of_stack = NULL;
2042         input_file = FALSE;
2043         recv_file = FALSE;
2044         count = 1;
2045         while (count < numargs)
2046         {
2047                 buff = arguments[count];
2048                 if (!strcmp("-i", buff))
2049                 {
2050                         info_window = FALSE;
2051                 }
2052                 else if (!strcmp("-e", buff))
2053                 {
2054                         expand_tabs = FALSE;
2055                 }
2056                 else if (!strcmp("-h", buff))
2057                 {
2058                         nohighlight = TRUE;
2059                 }
2060                 else if (!strcmp("-?", buff))
2061                 {
2062                         fprintf(stderr, usage0, arguments[0]);
2063                         fprintf(stderr, usage1);
2064                         fprintf(stderr, usage2);
2065                         fprintf(stderr, usage3);
2066                         fprintf(stderr, usage4);
2067                         exit(1);
2068                 }
2069                 else if (*buff == '+')
2070                 {
2071                         buff++;
2072                         start_at_line = buff;
2073                 }
2074
2075                 else
2076                 {
2077                         if (top_of_stack == NULL)
2078                         {
2079                                 temp_names = top_of_stack = name_alloc();
2080                         }
2081                         else
2082                         {
2083                                 temp_names->next_name = name_alloc();
2084                                 temp_names = temp_names->next_name;
2085                         }
2086                         ptr = temp_names->name = malloc(strlen(buff) + 1);
2087                         while (*buff != (char) NULL)
2088                         {
2089                                 *ptr = *buff;
2090                                 buff++;
2091                                 ptr++;
2092                         }
2093                         *ptr = (char) NULL;
2094                         temp_names->next_name = NULL;
2095                         input_file = TRUE;
2096                         recv_file = TRUE;
2097                 }
2098                 count++;
2099         }
2100 }
2101
2102 void 
2103 check_fp(void)          /* open or close files according to flags */
2104 {
2105         int line_num;
2106         int temp;
2107         struct stat buf;
2108
2109         clear_com_win = TRUE;
2110         tmp_vert = scr_vert;
2111         tmp_horz = scr_horz;
2112         tmp_line = curr_line;
2113         if (input_file)
2114         {
2115                 in_file_name = tmp_file = top_of_stack->name;
2116                 top_of_stack = top_of_stack->next_name;
2117         }
2118         temp = stat(tmp_file, &buf);
2119         buf.st_mode &= ~07777;
2120         if ((temp != -1) && (buf.st_mode != 0100000) && (buf.st_mode != 0))
2121         {
2122                 wprintw(com_win, file_is_dir_msg, tmp_file);
2123                 wrefresh(com_win);
2124                 if (input_file)
2125                 {
2126                         quit(0);
2127                         return;
2128                 }
2129                 else
2130                         return;
2131         }
2132         if ((get_fd = open(tmp_file, O_RDONLY)) == -1)
2133         {
2134                 wmove(com_win, 0, 0);
2135                 wclrtoeol(com_win);
2136                 if (input_file)
2137                         wprintw(com_win, new_file_msg, tmp_file);
2138                 else
2139                         wprintw(com_win, cant_open_msg, tmp_file);
2140                 wrefresh(com_win);
2141                 wmove(text_win, scr_vert, (scr_horz - horiz_offset));
2142                 wrefresh(text_win);
2143                 recv_file = FALSE;
2144                 input_file = FALSE;
2145                 return;
2146         }
2147         else
2148                 get_file(tmp_file);
2149
2150         recv_file = FALSE;
2151         line_num = curr_line->line_number;
2152         scr_vert = tmp_vert;
2153         scr_horz = tmp_horz;
2154         if (input_file)
2155                 curr_line= first_line;
2156         else
2157                 curr_line = tmp_line;
2158         point = curr_line->line;
2159         draw_screen();
2160         if (input_file)
2161         {
2162                 input_file = FALSE;
2163                 if (start_at_line != NULL)
2164                 {
2165                         line_num = atoi(start_at_line) - 1;
2166                         move_rel("d", line_num);
2167                         line_num = 0;
2168                         start_at_line = NULL;
2169                 }
2170         }
2171         else
2172         {
2173                 wmove(com_win, 0, 0);
2174                 wclrtoeol(com_win);
2175                 text_changes = TRUE;
2176                 if ((tmp_file != NULL) && (*tmp_file != (char) NULL))
2177                         wprintw(com_win, file_read_fin_msg, tmp_file);
2178         }
2179         wrefresh(com_win);
2180         wmove(text_win, scr_vert, (scr_horz - horiz_offset));
2181         wrefresh(text_win);
2182 }
2183
2184 void 
2185 get_file(char *file_name) /* read specified file into current buffer */
2186 {
2187         int can_read;           /* file has at least one character      */
2188         int length;             /* length of line read by read          */
2189         int append;             /* should text be appended to current line */
2190         struct text *temp_line;
2191         char ro_flag = FALSE;
2192
2193         if (recv_file)          /* if reading a file                    */
2194         {
2195                 wmove(com_win, 0, 0);
2196                 wclrtoeol(com_win);
2197                 wprintw(com_win, reading_file_msg, file_name);
2198                 if (access(file_name, 2))       /* check permission to write */
2199                 {
2200                         if ((errno == ENOTDIR) || (errno == EACCES) || (errno == EROFS) || (errno == ETXTBSY) || (errno == EFAULT))
2201                         {
2202                                 wprintw(com_win, read_only_msg);
2203                                 ro_flag = TRUE;
2204                         }
2205                 }
2206                 wrefresh(com_win);
2207         }
2208         if (curr_line->line_length > 1) /* if current line is not blank */
2209         {
2210                 insert_line(FALSE);
2211                 left(FALSE);
2212                 append = FALSE;
2213         }
2214         else
2215                 append = TRUE;
2216         can_read = FALSE;               /* test if file has any characters  */
2217         while (((length = read(get_fd, in_string, 512)) != 0) && (length != -1))
2218         {
2219                 can_read = TRUE;  /* if set file has at least 1 character   */
2220                 get_line(length, in_string, &append);
2221         }
2222         if ((can_read) && (curr_line->line_length == 1))
2223         {
2224                 temp_line = curr_line->prev_line;
2225                 temp_line->next_line = curr_line->next_line;
2226                 if (temp_line->next_line != NULL)
2227                         temp_line->next_line->prev_line = temp_line;
2228                 if (curr_line->line != NULL)
2229                         free(curr_line->line);
2230                 free(curr_line);
2231                 curr_line = temp_line;
2232         }
2233         if (input_file) /* if this is the file to be edited display number of lines     */
2234         {
2235                 wmove(com_win, 0, 0);
2236                 wclrtoeol(com_win);
2237                 wprintw(com_win, file_read_lines_msg, in_file_name, curr_line->line_number);
2238                 if (ro_flag)
2239                         wprintw(com_win, read_only_msg);
2240                 wrefresh(com_win);
2241         }
2242         else if (can_read)      /* not input_file and file is non-zero size */
2243                 text_changes = TRUE;
2244
2245         if (recv_file)          /* if reading a file                    */
2246         {
2247                 in = EOF;
2248         }
2249 }
2250
2251 /*
2252 length: length of string read by read
2253 in_string: string read by read
2254 append: TRUE if must append more text to end of current line
2255 */
2256 void
2257 get_line(int length, unsigned char *in_string, int *append)
2258 /* read string and split into lines */
2259 {
2260         unsigned char *str1;
2261         unsigned char *str2;
2262         int num;                /* offset from start of string          */
2263         int char_count;         /* length of new line (or added portion */
2264         int temp_counter;       /* temporary counter value              */
2265         struct text *tline;     /* temporary pointer to new line        */
2266         int first_time;         /* if TRUE, the first time through the loop */
2267
2268         str2 = in_string;
2269         num = 0;
2270         first_time = TRUE;
2271         while (num < length)
2272         {
2273                 if (!first_time)
2274                 {
2275                         if (num < length)
2276                         {
2277                                 str2++;
2278                                 num++;
2279                         }
2280                 }
2281                 else
2282                         first_time = FALSE;
2283                 str1 = str2;
2284                 char_count = 1;
2285                 /* find end of line     */
2286                 while ((*str2 != '\n') && (num < length))
2287                 {
2288                         str2++;
2289                         num++;
2290                         char_count++;
2291                 }
2292                 if (!(*append)) /* if not append to current line, insert new one */
2293                 {
2294                         tline = txtalloc();     /* allocate data structure for next line */
2295                         tline->next_line = curr_line->next_line;
2296                         renumber_lines(tline, curr_line->line_number + 1);
2297                         tline->prev_line = curr_line;
2298                         curr_line->next_line = tline;
2299                         if (tline->next_line != NULL)
2300                                 tline->next_line->prev_line = tline;
2301                         curr_line = tline;
2302                         curr_line->line = point = (unsigned char *) malloc(char_count);
2303                         curr_line->line_length = char_count;
2304                         curr_line->max_length = char_count;
2305                 }
2306                 else
2307                 {
2308                         point = resiz_line(char_count, curr_line, curr_line->line_length); 
2309                         curr_line->line_length += (char_count - 1);
2310                 }
2311                 for (temp_counter = 1; temp_counter < char_count; temp_counter++)
2312                 {
2313                         *point = *str1;
2314                         point++;
2315                         str1++;
2316                 }
2317                 *point = (char) NULL;
2318                 *append = FALSE;
2319                 if ((num == length) && (*str2 != '\n'))
2320                         *append = TRUE;
2321         }
2322 }
2323
2324 void 
2325 draw_screen(void)               /* redraw the screen from current postion       */
2326 {
2327         struct text *temp_line;
2328         unsigned char *line_out;
2329         int temp_vert;
2330
2331         temp_line = curr_line;
2332         temp_vert = scr_vert;
2333         wclrtobot(text_win);
2334         while ((temp_line != NULL) && (temp_vert <= last_line))
2335         {
2336                 line_out = temp_line->line;
2337                 draw_line(temp_vert, 0, line_out, 1, temp_line->line_length);
2338                 temp_vert++;
2339                 temp_line = temp_line->next_line;
2340         }
2341         wmove(text_win, temp_vert, 0);
2342         wmove(text_win, scr_vert, (scr_horz - horiz_offset));
2343 }
2344
2345 void 
2346 finish(void)    /* prepare to exit edit session */
2347 {
2348         char *file_name = in_file_name;
2349
2350         /*
2351          |      changes made here should be reflected in the 'save' 
2352          |      portion of file_op()
2353          */
2354
2355         if ((file_name == NULL) || (*file_name == (char) NULL))
2356                 file_name = get_string(save_file_name_prompt, TRUE);
2357
2358         if ((file_name == NULL) || (*file_name == (char) NULL))
2359         {
2360                 wmove(com_win, 0, 0);
2361                 wprintw(com_win, file_not_saved_msg);
2362                 wclrtoeol(com_win);
2363                 wrefresh(com_win);
2364                 clear_com_win = TRUE;
2365                 return;
2366         }
2367
2368         tmp_file = resolve_name(file_name);
2369         if (tmp_file != file_name)
2370         {
2371                 free(file_name);
2372                 file_name = tmp_file;
2373         }
2374
2375         if (write_file(file_name, 1))
2376         {
2377                 text_changes = FALSE;
2378                 quit(0);
2379         }
2380 }
2381
2382 int 
2383 quit(int noverify)              /* exit editor                  */
2384 {
2385         char *ans;
2386
2387         touchwin(text_win);
2388         wrefresh(text_win);
2389         if ((text_changes) && (!noverify))
2390         {
2391                 ans = get_string(changes_made_prompt, TRUE);
2392                 if (toupper(*ans) == toupper(*yes_char))
2393                         text_changes = FALSE;
2394                 else
2395                         return(0);
2396                 free(ans);
2397         }
2398         if (top_of_stack == NULL)
2399         {
2400                 if (info_window)
2401                         wrefresh(info_win);
2402                 wrefresh(com_win);
2403                 resetty();
2404                 endwin();
2405                 putchar('\n');
2406                 exit(0);
2407         }
2408         else
2409         {
2410                 delete_text();
2411                 recv_file = TRUE;
2412                 input_file = TRUE;
2413                 check_fp();
2414                 text_changes = FALSE;
2415         }
2416         return(0);
2417 }
2418
2419 void 
2420 edit_abort(int arg)
2421 {
2422         wrefresh(com_win);
2423         resetty();
2424         endwin();
2425         putchar('\n');
2426         exit(1);
2427 }
2428
2429 void 
2430 delete_text(void)
2431 {
2432         while (curr_line->next_line != NULL)
2433                 curr_line = curr_line->next_line;
2434         while (curr_line != first_line)
2435         {
2436                 free(curr_line->line);
2437                 curr_line = curr_line->prev_line;
2438                 free(curr_line->next_line);
2439         }
2440         curr_line->next_line = NULL;
2441         *curr_line->line = (char) NULL;
2442         curr_line->line_length = 1;
2443         curr_line->line_number = 1;
2444         point = curr_line->line;
2445         scr_pos = scr_vert = scr_horz = 0;
2446         position = 1;
2447 }
2448
2449 int 
2450 write_file(char *file_name, int warn_if_exists)
2451 {
2452         char cr;
2453         char *tmp_point;
2454         struct text *out_line;
2455         int lines, charac;
2456         int temp_pos;
2457         int write_flag = TRUE;
2458
2459         charac = lines = 0;
2460         if (warn_if_exists &&
2461             ((in_file_name == NULL) || strcmp(in_file_name, file_name)))
2462         {
2463                 if ((temp_fp = fopen(file_name, "r")))
2464                 {
2465                         tmp_point = get_string(file_exists_prompt, TRUE);
2466                         if (toupper(*tmp_point) == toupper(*yes_char))
2467                                 write_flag = TRUE;
2468                         else 
2469                                 write_flag = FALSE;
2470                         fclose(temp_fp);
2471                         free(tmp_point);
2472                 }
2473         }
2474
2475         clear_com_win = TRUE;
2476
2477         if (write_flag)
2478         {
2479                 if ((temp_fp = fopen(file_name, "w")) == NULL)
2480                 {
2481                         clear_com_win = TRUE;
2482                         wmove(com_win,0,0);
2483                         wclrtoeol(com_win);
2484                         wprintw(com_win, create_file_fail_msg, file_name);
2485                         wrefresh(com_win);
2486                         return(FALSE);
2487                 }
2488                 else
2489                 {
2490                         wmove(com_win,0,0);
2491                         wclrtoeol(com_win);
2492                         wprintw(com_win, writing_file_msg, file_name);
2493                         wrefresh(com_win);
2494                         cr = '\n';
2495                         out_line = first_line;
2496                         while (out_line != NULL)
2497                         {
2498                                 temp_pos = 1;
2499                                 tmp_point= out_line->line;
2500                                 while (temp_pos < out_line->line_length)
2501                                 {
2502                                         putc(*tmp_point, temp_fp);
2503                                         tmp_point++;
2504                                         temp_pos++;
2505                                 }
2506                                 charac += out_line->line_length;
2507                                 out_line = out_line->next_line;
2508                                 putc(cr, temp_fp);
2509                                 lines++;
2510                         }
2511                         fclose(temp_fp);
2512                         wmove(com_win,0,0);
2513                         wclrtoeol(com_win);
2514                         wprintw(com_win, file_written_msg, file_name, lines, charac);
2515                         wrefresh(com_win);
2516                         return(TRUE);
2517                 }
2518         }
2519         else
2520                 return(FALSE);
2521 }
2522
2523 int 
2524 search(int display_message) /* search for string in srch_str */
2525 {
2526         int lines_moved;
2527         int iter;
2528         int found;
2529
2530         if ((srch_str == NULL) || (*srch_str == (char) NULL))
2531                 return(FALSE);
2532         if (display_message)
2533         {
2534                 wmove(com_win, 0, 0);
2535                 wclrtoeol(com_win);
2536                 wprintw(com_win, searching_msg);
2537                 wrefresh(com_win);
2538                 clear_com_win = TRUE;
2539         }
2540         lines_moved = 0;
2541         found = FALSE;
2542         srch_line = curr_line;
2543         srch_1 = point;
2544         if (position < curr_line->line_length)
2545                 srch_1++;
2546         iter = position + 1;
2547         while ((!found) && (srch_line != NULL))
2548         {
2549                 while ((iter < srch_line->line_length) && (!found))
2550                 {
2551                         srch_2 = srch_1;
2552                         if (case_sen)   /* if case sensitive            */
2553                         {
2554                                 srch_3 = srch_str;
2555                         while ((*srch_2 == *srch_3) && (*srch_3 != (char) NULL))
2556                                 {
2557                                         found = TRUE;
2558                                         srch_2++;
2559                                         srch_3++;
2560                                 }       /* end while    */
2561                         }
2562                         else            /* if not case sensitive        */
2563                         {
2564                                 srch_3 = u_srch_str;
2565                         while ((toupper(*srch_2) == *srch_3) && (*srch_3 != (char) NULL))
2566                                 {
2567                                         found = TRUE;
2568                                         srch_2++;
2569                                         srch_3++;
2570                                 }
2571                         }       /* end else     */
2572                         if (!((*srch_3 == (char) NULL) && (found)))
2573                         {
2574                                 found = FALSE;
2575                                 if (iter < srch_line->line_length)
2576                                         srch_1++;
2577                                 iter++;
2578                         }
2579                 }
2580                 if (!found)
2581                 {
2582                         srch_line = srch_line->next_line;
2583                         if (srch_line != NULL)
2584                                 srch_1 = srch_line->line;
2585                         iter = 1;
2586                         lines_moved++;
2587                 }
2588         }
2589         if (found)
2590         {
2591                 if (display_message)
2592                 {
2593                         wmove(com_win, 0, 0);
2594                         wclrtoeol(com_win);
2595                         wrefresh(com_win);
2596                 }
2597                 if (lines_moved == 0)
2598                 {
2599                         while (position < iter)
2600                                 right(TRUE);
2601                 }
2602                 else
2603                 {
2604                         if (lines_moved < 30)
2605                         {
2606                                 move_rel("d", lines_moved);
2607                                 while (position < iter)
2608                                         right(TRUE);
2609                         }
2610                         else 
2611                         {
2612                                 curr_line = srch_line;
2613                                 point = srch_1;
2614                                 position = iter;
2615                                 scanline(point);
2616                                 scr_pos = scr_horz;
2617                                 midscreen((last_line / 2), point);
2618                         }
2619                 }
2620         }
2621         else
2622         {
2623                 if (display_message)
2624                 {
2625                         wmove(com_win, 0, 0);
2626                         wclrtoeol(com_win);
2627                         wprintw(com_win, str_not_found_msg, srch_str);
2628                         wrefresh(com_win);
2629                 }
2630                 wmove(text_win, scr_vert,(scr_horz - horiz_offset));
2631         }
2632         return(found);
2633 }
2634
2635 void 
2636 search_prompt(void) /* prompt and read search string (srch_str) */
2637 {
2638         if (srch_str != NULL)
2639                 free(srch_str);
2640         if ((u_srch_str != NULL) && (*u_srch_str != (char) NULL))
2641                 free(u_srch_str);
2642         srch_str = get_string(search_prompt_str, FALSE);
2643         gold = FALSE;
2644         srch_3 = srch_str;
2645         srch_1 = u_srch_str = malloc(strlen(srch_str) + 1);
2646         while (*srch_3 != (char) NULL)
2647         {
2648                 *srch_1 = toupper(*srch_3);
2649                 srch_1++;
2650                 srch_3++;
2651         }
2652         *srch_1 = (char) NULL;
2653         search(TRUE);
2654 }
2655
2656 void 
2657 del_char(void) /* delete current character */
2658 {
2659         in = 8;  /* backspace */
2660         if (position < curr_line->line_length)  /* if not end of line   */
2661         {
2662                 if ((ee_chinese) && (*point > 127) && 
2663                     ((curr_line->line_length - position) >= 2))
2664                 {
2665                         point++;
2666                         position++;
2667                 }
2668                 position++;
2669                 point++;
2670                 scanline(point);
2671                 delete(TRUE);
2672         }
2673         else
2674         {
2675                 right(FALSE);
2676                 delete(FALSE);
2677         }
2678 }
2679
2680 void 
2681 undel_char(void) /* undelete last deleted character */
2682 {
2683         if (d_char[0] == '\n')  /* insert line if last del_char deleted eol */
2684                 insert_line(TRUE);
2685         else
2686         {
2687                 in = d_char[0];
2688                 insert(in);
2689                 if (d_char[1] != (unsigned char) NULL)
2690                 {
2691                         in = d_char[1];
2692                         insert(in);
2693                 }
2694         }
2695 }
2696
2697 void 
2698 del_word(void) /* delete word in front of cursor */
2699 {
2700         int tposit;
2701         int difference;
2702         unsigned char *d_word2;
2703         unsigned char *d_word3;
2704         unsigned char tmp_char[3];
2705
2706         if (d_word != NULL)
2707                 free(d_word);
2708         d_word = malloc(curr_line->line_length);
2709         tmp_char[0] = d_char[0];
2710         tmp_char[1] = d_char[1];
2711         tmp_char[2] = d_char[2];
2712         d_word3 = point;
2713         d_word2 = d_word;
2714         tposit = position;
2715         while ((tposit < curr_line->line_length) && 
2716                                 ((*d_word3 != ' ') && (*d_word3 != '\t')))
2717         {
2718                 tposit++;
2719                 *d_word2 = *d_word3;
2720                 d_word2++;
2721                 d_word3++;
2722         }
2723         while ((tposit < curr_line->line_length) && 
2724                                 ((*d_word3 == ' ') || (*d_word3 == '\t')))
2725         {
2726                 tposit++;
2727                 *d_word2 = *d_word3;
2728                 d_word2++;
2729                 d_word3++;
2730         }
2731         *d_word2 = (char) NULL;
2732         d_wrd_len = difference = d_word2 - d_word;
2733         d_word2 = point;
2734         while (tposit < curr_line->line_length)
2735         {
2736                 tposit++;
2737                 *d_word2 = *d_word3;
2738                 d_word2++;
2739                 d_word3++;
2740         }
2741         curr_line->line_length -= difference;
2742         *d_word2 = (char) NULL;
2743         draw_line(scr_vert, scr_horz,point,position,curr_line->line_length);
2744         d_char[0] = tmp_char[0];
2745         d_char[1] = tmp_char[1];
2746         d_char[2] = tmp_char[2];
2747         text_changes = TRUE;
2748         formatted = FALSE;
2749 }
2750
2751 void 
2752 undel_word(void) /* undelete last deleted word */
2753 {
2754         int temp;
2755         int tposit;
2756         unsigned char *tmp_old_ptr;
2757         unsigned char *tmp_space;
2758         unsigned char *tmp_ptr;
2759         unsigned char *d_word_ptr;
2760
2761         /*
2762          |      resize line to handle undeleted word
2763          */
2764         if ((curr_line->max_length - (curr_line->line_length + d_wrd_len)) < 5)
2765                 point = resiz_line(d_wrd_len, curr_line, position);
2766         tmp_ptr = tmp_space = malloc(curr_line->line_length + d_wrd_len);
2767         d_word_ptr = d_word;
2768         temp = 1;
2769         /*
2770          |      copy d_word contents into temp space
2771          */
2772         while (temp <= d_wrd_len)
2773         {
2774                 temp++;
2775                 *tmp_ptr = *d_word_ptr;
2776                 tmp_ptr++;
2777                 d_word_ptr++;
2778         }
2779         tmp_old_ptr = point;
2780         tposit = position;
2781         /*
2782          |      copy contents of line from curent position to eol into 
2783          |      temp space
2784          */
2785         while (tposit < curr_line->line_length)
2786         {
2787                 temp++;
2788                 tposit++;
2789                 *tmp_ptr = *tmp_old_ptr;
2790                 tmp_ptr++;
2791                 tmp_old_ptr++;
2792         }
2793         curr_line->line_length += d_wrd_len;
2794         tmp_old_ptr = point;
2795         *tmp_ptr = (char) NULL;
2796         tmp_ptr = tmp_space;
2797         tposit = 1;
2798         /*
2799          |      now copy contents from temp space back to original line
2800          */
2801         while (tposit < temp)
2802         {
2803                 tposit++;
2804                 *tmp_old_ptr = *tmp_ptr;
2805                 tmp_ptr++;
2806                 tmp_old_ptr++;
2807         }
2808         *tmp_old_ptr = (char) NULL;
2809         free(tmp_space);
2810         draw_line(scr_vert, scr_horz, point, position, curr_line->line_length);
2811 }
2812
2813 void 
2814 del_line(void) /* delete from cursor to end of line */
2815 {
2816         unsigned char *dl1;
2817         unsigned char *dl2;
2818         int tposit;
2819
2820         if (d_line != NULL)
2821                 free(d_line);
2822         d_line = malloc(curr_line->line_length);
2823         dl1 = d_line;
2824         dl2 = point;
2825         tposit = position;
2826         while (tposit < curr_line->line_length)
2827         {
2828                 *dl1 = *dl2;
2829                 dl1++;
2830                 dl2++;
2831                 tposit++;
2832         }
2833         dlt_line->line_length = 1 + tposit - position;
2834         *dl1 = (char) NULL;
2835         *point = (char) NULL;
2836         curr_line->line_length = position;
2837         wclrtoeol(text_win);
2838         if (curr_line->next_line != NULL)
2839         {
2840                 right(FALSE);
2841                 delete(FALSE);
2842         }
2843         text_changes = TRUE;
2844 }
2845
2846 void 
2847 undel_line(void) /* undelete last deleted line */
2848 {
2849         unsigned char *ud1;
2850         unsigned char *ud2;
2851         int tposit;
2852
2853         if (dlt_line->line_length == 0)
2854                 return;
2855
2856         insert_line(TRUE);
2857         left(TRUE);
2858         point = resiz_line(dlt_line->line_length, curr_line, position);
2859         curr_line->line_length += dlt_line->line_length - 1;
2860         ud1 = point;
2861         ud2 = d_line;
2862         tposit = 1;
2863         while (tposit < dlt_line->line_length)
2864         {
2865                 tposit++;
2866                 *ud1 = *ud2;
2867                 ud1++;
2868                 ud2++;
2869         }
2870         *ud1 = (char) NULL;
2871         draw_line(scr_vert, scr_horz,point,position,curr_line->line_length);
2872 }
2873
2874 void 
2875 adv_word(void) /* advance to next word */
2876 {
2877 while ((position < curr_line->line_length) && ((*point != 32) && (*point != 9)))
2878                 right(TRUE);
2879 while ((position < curr_line->line_length) && ((*point == 32) || (*point == 9)))
2880                 right(TRUE);
2881 }
2882
2883 void 
2884 move_rel(char *direction, int lines)    /* move relative to current line        */
2885 {
2886         int i;
2887         char *tmp;
2888
2889         if (*direction == 'u')
2890         {
2891                 scr_pos = 0;
2892                 while (position > 1)
2893                         left(TRUE);
2894                 for (i = 0; i < lines; i++)
2895                 {
2896                         up();
2897                 }
2898                 if ((last_line > 5) && ( scr_vert < 4))
2899                 {
2900                         tmp = point;
2901                         tmp_line = curr_line;
2902                         for (i= 0;(i<5)&&(curr_line->prev_line != NULL); i++)
2903                         {
2904                                 up();
2905                         }
2906                         scr_vert = scr_vert + i;
2907                         curr_line = tmp_line;
2908                         point = tmp;
2909                         scanline(point);
2910                 }
2911         }
2912         else
2913         {
2914                 if ((position != 1) && (curr_line->next_line != NULL))
2915                 {
2916                         nextline();
2917                         scr_pos = scr_horz = 0;
2918                         if (horiz_offset)
2919                         {
2920                                 horiz_offset = 0;
2921                                 midscreen(scr_vert, point);
2922                         }
2923                 }
2924                 else
2925                         adv_line();
2926                 for (i = 1; i < lines; i++)
2927                 {
2928                         down();
2929                 }
2930                 if ((last_line > 10) && (scr_vert > (last_line - 5)))
2931                 {
2932                         tmp = point;
2933                         tmp_line = curr_line;
2934                         for (i=0; (i<5) && (curr_line->next_line != NULL); i++)
2935                         {
2936                                 down();
2937                         }
2938                         scr_vert = scr_vert - i;
2939                         curr_line = tmp_line;
2940                         point = tmp;
2941                         scanline(point);
2942                 }
2943         }
2944         wmove(text_win, scr_vert, (scr_horz - horiz_offset));
2945 }
2946
2947 void 
2948 eol(void)                               /* go to end of line                    */
2949 {
2950         if (position < curr_line->line_length)
2951         {
2952                 while (position < curr_line->line_length)
2953                         right(TRUE);
2954         }
2955         else if (curr_line->next_line != NULL)
2956         {
2957                 right(TRUE);
2958                 while (position < curr_line->line_length)
2959                         right(TRUE);
2960         }
2961 }
2962
2963 void 
2964 bol(void)                               /* move to beginning of line    */
2965 {
2966         if (point != curr_line->line)
2967         {
2968                 while (point != curr_line->line)
2969                         left(TRUE);
2970         }
2971         else if (curr_line->prev_line != NULL)
2972         {
2973                 scr_pos = 0;
2974                 up();
2975         }
2976 }
2977
2978 void 
2979 adv_line(void)  /* advance to beginning of next line    */
2980 {
2981         if ((point != curr_line->line) || (scr_pos > 0))
2982         {
2983                 while (position < curr_line->line_length)
2984                         right(TRUE);
2985                 right(TRUE);
2986         }
2987         else if (curr_line->next_line != NULL)
2988         {
2989                 scr_pos = 0;
2990                 down();
2991         }
2992 }
2993
2994 /* string: string containing user command */
2995 void 
2996 sh_command(char *string)        /* execute shell command                        */
2997 {
2998         char *temp_point;
2999         char *last_slash;
3000         char *path;             /* directory path to executable         */
3001         int parent;             /* zero if child, child's pid if parent */
3002         int value;
3003         int return_val;
3004         struct text *line_holder;
3005
3006         if (restrict_mode())
3007         {
3008                 return;
3009         }
3010
3011         if (!(path = getenv("SHELL")))
3012                 path = "/bin/sh";
3013         last_slash = temp_point = path;
3014         while (*temp_point != (char) NULL)
3015         {
3016                 if (*temp_point == '/')
3017                         last_slash = ++temp_point;
3018                 else
3019                         temp_point++;
3020         }
3021
3022         /*
3023          |      if in_pipe is true, then output of the shell operation will be 
3024          |      read by the editor, and curses doesn't need to be turned off
3025          */
3026
3027         if (!in_pipe)
3028         {
3029                 keypad(com_win, FALSE);
3030                 keypad(text_win, FALSE);
3031                 echo();
3032                 nl();
3033                 noraw();
3034                 resetty();
3035
3036 #ifndef NCURSE
3037                 endwin();
3038 #endif
3039         }
3040
3041         if (in_pipe)
3042         {
3043                 pipe(pipe_in);          /* create a pipe        */
3044                 parent = fork();
3045                 if (!parent)            /* if the child         */
3046                 {
3047 /*
3048  |  child process which will fork and exec shell command (if shell output is
3049  |  to be read by editor)
3050  */
3051                         in_pipe = FALSE;
3052 /*
3053  |  redirect stdout to pipe
3054  */
3055                         temp_stdout = dup(1);
3056                         close(1);
3057                         dup(pipe_in[1]);
3058 /*
3059  |  redirect stderr to pipe
3060  */
3061                         temp_stderr = dup(2);
3062                         close(2);
3063                         dup(pipe_in[1]);
3064                         close(pipe_in[1]);
3065                         /*
3066                          |      child will now continue down 'if (!in_pipe)' 
3067                          |      path below
3068                          */
3069                 }
3070                 else  /* if the parent  */
3071                 {
3072 /*
3073  |  prepare editor to read from the pipe
3074  */
3075                         signal(SIGCHLD, SIG_IGN);
3076                         line_holder = curr_line;
3077                         tmp_vert = scr_vert;
3078                         close(pipe_in[1]);
3079                         get_fd = pipe_in[0];
3080                         get_file("");
3081                         close(pipe_in[0]);
3082                         scr_vert = tmp_vert;
3083                         scr_horz = scr_pos = 0;
3084                         position = 1;
3085                         curr_line = line_holder;
3086                         point = curr_line->line;
3087                         out_pipe = FALSE;
3088                         signal(SIGCHLD, SIG_DFL);
3089 /*
3090  |  since flag "in_pipe" is still TRUE, the path which waits for the child 
3091  |  process to die will be avoided.
3092  |  (the pipe is closed, no more output can be expected)
3093  */
3094                 }
3095         }
3096         if (!in_pipe)
3097         {
3098                 signal(SIGINT, SIG_IGN);
3099                 if (out_pipe)
3100                 {
3101                         pipe(pipe_out);
3102                 }
3103 /*
3104  |  fork process which will exec command
3105  */
3106                 parent = fork();   
3107                 if (!parent)            /* if the child */
3108                 {
3109                         if (shell_fork)
3110                                 putchar('\n');
3111                         if (out_pipe)
3112                         {
3113 /*
3114  |  prepare the child process (soon to exec a shell command) to read from the 
3115  |  pipe (which will be output from the editor's buffer)
3116  */
3117                                 close(0);
3118                                 dup(pipe_out[0]);
3119                                 close(pipe_out[0]);
3120                                 close(pipe_out[1]);
3121                         }
3122                         for (value = 1; value < 24; value++)
3123                                 signal(value, SIG_DFL);
3124                         execl(path, last_slash, "-c", string, NULL);
3125                         errx(1, exec_err_msg, path);
3126                 }
3127                 else    /* if the parent        */
3128                 {
3129                         if (out_pipe)
3130                         {
3131 /*
3132  |  output the contents of the buffer to the pipe (to be read by the 
3133  |  process forked and exec'd above as stdin)
3134  */
3135                                 close(pipe_out[0]);
3136                                 line_holder = first_line;
3137                                 while (line_holder != NULL)
3138                                 {
3139                                         write(pipe_out[1], line_holder->line, (line_holder->line_length-1));
3140                                         write(pipe_out[1], "\n", 1);
3141                                         line_holder = line_holder->next_line;
3142                                 }
3143                                 close(pipe_out[1]);
3144                                 out_pipe = FALSE;
3145                         }
3146                         do
3147                         {
3148                                 return_val = wait(NULL);
3149                         }
3150                         while ((return_val != parent) && (return_val != -1));
3151 /*
3152  |  if this process is actually the child of the editor, exit.  Here's how it 
3153  |  works:
3154  |  The editor forks a process.  If output must be sent to the command to be 
3155  |  exec'd another process is forked, and that process (the child's child) 
3156  |  will exec the command.  In this case, "shell_fork" will be FALSE.  If no 
3157  |  output is to be performed to the shell command, "shell_fork" will be TRUE.
3158  |  If this is the editor process, shell_fork will be true, otherwise this is 
3159  |  the child of the edit process.
3160  */
3161                         if (!shell_fork)
3162                                 exit(0);
3163                 }
3164                 signal(SIGINT, edit_abort);
3165         }
3166         if (shell_fork)
3167         {
3168                 printf("%s", continue_msg);
3169                 fflush(stdout);
3170                 while ((in = getchar()) != '\n')
3171                         ;
3172         }
3173
3174         if (!in_pipe)
3175         {
3176                 fixterm();
3177                 noecho();
3178                 nonl();
3179                 raw();
3180                 keypad(text_win, TRUE);
3181                 keypad(com_win, TRUE);
3182                 if (info_window)
3183                         clearok(info_win, TRUE);
3184         }
3185
3186         redraw();
3187 }
3188
3189 void 
3190 set_up_term(void)               /* set up the terminal for operating with ae    */
3191 {
3192         if (!curses_initialized)
3193         {
3194                 initscr();
3195                 savetty();
3196                 noecho();
3197                 raw();
3198                 nonl();
3199                 curses_initialized = TRUE;
3200         }
3201
3202         if (((LINES > 15) && (COLS >= 80)) && info_window)
3203                 last_line = LINES - 8;
3204         else
3205         {
3206                 info_window = FALSE;
3207                 last_line = LINES - 2;
3208         }
3209
3210         idlok(stdscr, TRUE);
3211         com_win = newwin(1, COLS, (LINES - 1), 0);
3212         keypad(com_win, TRUE);
3213         idlok(com_win, TRUE);
3214         wrefresh(com_win);
3215         if (!info_window)
3216                 text_win = newwin((LINES - 1), COLS, 0, 0);
3217         else
3218                 text_win = newwin((LINES - 7), COLS, 6, 0);
3219         keypad(text_win, TRUE);
3220         idlok(text_win, TRUE);
3221         wrefresh(text_win);
3222         help_win = newwin((LINES - 1), COLS, 0, 0);
3223         keypad(help_win, TRUE);
3224         idlok(help_win, TRUE);
3225         if (info_window)
3226         {
3227                 info_type = CONTROL_KEYS;
3228                 info_win = newwin(5, COLS, 0, 0);
3229                 werase(info_win);
3230                 paint_info_win();
3231                 count_win = newwin(1, COLS, 5, 0);
3232                 leaveok(count_win, TRUE);
3233                 wrefresh(count_win);
3234         }
3235
3236         last_col = COLS - 1;
3237         local_LINES = LINES;
3238         local_COLS = COLS;
3239
3240 #ifdef NCURSE
3241         if (ee_chinese)
3242                 nc_setattrib(A_NC_BIG5);
3243 #endif /* NCURSE */
3244
3245 }
3246
3247 void 
3248 resize_check(void)
3249 {
3250         if ((LINES == local_LINES) && (COLS == local_COLS))
3251                 return;
3252
3253         if (info_window)
3254                 delwin(info_win);
3255         delwin(text_win);
3256         delwin(com_win);
3257         delwin(help_win);
3258         delwin(count_win);
3259         set_up_term();
3260         redraw();
3261         wrefresh(text_win);
3262 }
3263
3264 static char item_alpha[] = "abcdefghijklmnopqrstuvwxyz0123456789 ";
3265
3266 int 
3267 menu_op(struct menu_entries *menu_list)
3268 {
3269         WINDOW *temp_win;
3270         int max_width, max_height;
3271         int x_off, y_off;
3272         int counter;
3273         int length;
3274         int input;
3275         int temp = 0;
3276         int list_size;
3277         int top_offset;         /* offset from top where menu items start */
3278         int vert_pos;           /* vertical position                      */
3279         int vert_size;          /* vertical size for menu list item display */
3280         int off_start = 1;      /* offset from start of menu items to start display */
3281
3282
3283         /*
3284          |      determine number and width of menu items
3285          */
3286
3287         list_size = 1;
3288         while (menu_list[list_size + 1].item_string != NULL)
3289                 list_size++;
3290         max_width = 0;
3291         for (counter = 0; counter <= list_size; counter++)
3292         {
3293                 if ((length = strlen(menu_list[counter].item_string)) > max_width)
3294                         max_width = length;
3295         }
3296         max_width += 3;
3297         max_width = max(max_width, strlen(menu_cancel_msg));
3298         max_width = max(max_width, max(strlen(more_above_str), strlen(more_below_str)));
3299         max_width += 6;
3300
3301         /*
3302          |      make sure that window is large enough to handle menu
3303          |      if not, print error message and return to calling function
3304          */
3305
3306         if (max_width > COLS)
3307         {
3308                 wmove(com_win, 0, 0);
3309                 werase(com_win);
3310                 wprintw(com_win, menu_too_lrg_msg);
3311                 wrefresh(com_win);
3312                 clear_com_win = TRUE;
3313                 return(0);
3314         }
3315
3316         top_offset = 0;
3317
3318         if (list_size > LINES)
3319         {
3320                 max_height = LINES;
3321                 if (max_height > 11)
3322                         vert_size = max_height - 8;
3323                 else
3324                         vert_size = max_height;
3325         }
3326         else
3327         {
3328                 vert_size = list_size;
3329                 max_height = list_size;
3330         }
3331
3332         if (LINES >= (vert_size + 8))
3333         {
3334                 if (menu_list[0].argument != MENU_WARN)
3335                         max_height = vert_size + 8;
3336                 else
3337                         max_height = vert_size + 7;
3338                 top_offset = 4;
3339         }
3340         x_off = (COLS - max_width) / 2;
3341         y_off = (LINES - max_height - 1) / 2;
3342         temp_win = newwin(max_height, max_width, y_off, x_off);
3343         keypad(temp_win, TRUE);
3344
3345         paint_menu(menu_list, max_width, max_height, list_size, top_offset, temp_win, off_start, vert_size);
3346
3347         counter = 1;
3348         vert_pos = 0;
3349         do
3350         {
3351                 if (off_start > 2)
3352                         wmove(temp_win, (1 + counter + top_offset - off_start), 3);
3353                 else
3354                         wmove(temp_win, (counter + top_offset - off_start), 3);
3355
3356                 wrefresh(temp_win);
3357                 input = wgetch(temp_win);
3358
3359                 if (((tolower(input) >= 'a') && (tolower(input) <= 'z')) || 
3360                     ((input >= '0') && (input <= '9')))
3361                 {
3362                         if ((tolower(input) >= 'a') && (tolower(input) <= 'z'))
3363                         {
3364                                 temp = 1 + tolower(input) - 'a';
3365                         }
3366                         else if ((input >= '0') && (input <= '9'))
3367                         {
3368                                 temp = (2 + 'z' - 'a') + (input - '0');
3369                         }
3370
3371                         if (temp <= list_size)
3372                         {
3373                                 input = '\n';
3374                                 counter = temp;
3375                         }
3376                 }
3377                 else
3378                 {               
3379                         switch (input)
3380                         {
3381                                 case ' ':       /* space        */
3382                                 case '\004':    /* ^d, down     */
3383                                 case KEY_RIGHT:
3384                                 case KEY_DOWN:
3385                                         counter++;
3386                                         if (counter > list_size)
3387                                                 counter = 1;
3388                                         break;
3389                                 case '\010':    /* ^h, backspace*/
3390                                 case '\025':    /* ^u, up       */
3391                                 case 127:       /* ^?, delete   */
3392                                 case KEY_BACKSPACE:
3393                                 case KEY_LEFT:
3394                                 case KEY_UP:
3395                                         counter--;
3396                                         if (counter == 0)
3397                                                 counter = list_size;
3398                                         break;
3399                                 case '\033':    /* escape key   */
3400                                         if (menu_list[0].argument != MENU_WARN)
3401                                                 counter = 0;
3402                                         break;
3403                                 case '\014':    /* ^l           */
3404                                 case '\022':    /* ^r, redraw   */
3405                                         paint_menu(menu_list, max_width, max_height, 
3406                                                 list_size, top_offset, temp_win, 
3407                                                 off_start, vert_size);
3408                                         break;
3409                                 default:
3410                                         break;
3411                         }
3412                 }
3413         
3414                 if (((list_size - off_start) >= (vert_size - 1)) && 
3415                         (counter > (off_start + vert_size - 3)) && 
3416                                 (off_start > 1))
3417                 {
3418                         if (counter == list_size)
3419                                 off_start = (list_size - vert_size) + 2;
3420                         else
3421                                 off_start++;
3422
3423                         paint_menu(menu_list, max_width, max_height, 
3424                                    list_size, top_offset, temp_win, off_start, 
3425                                    vert_size);
3426                 }
3427                 else if ((list_size != vert_size) && 
3428                                 (counter > (off_start + vert_size - 2)))
3429                 {
3430                         if (counter == list_size)
3431                                 off_start = 2 + (list_size - vert_size);
3432                         else if (off_start == 1)
3433                                 off_start = 3;
3434                         else
3435                                 off_start++;
3436
3437                         paint_menu(menu_list, max_width, max_height, 
3438                                    list_size, top_offset, temp_win, off_start, 
3439                                    vert_size);
3440                 }
3441                 else if (counter < off_start)
3442                 {
3443                         if (counter <= 2)
3444                                 off_start = 1;
3445                         else
3446                                 off_start = counter;
3447
3448                         paint_menu(menu_list, max_width, max_height, 
3449                                    list_size, top_offset, temp_win, off_start, 
3450                                    vert_size);
3451                 }
3452         }
3453         while ((input != '\r') && (input != '\n') && (counter != 0));
3454
3455         werase(temp_win);
3456         wrefresh(temp_win);
3457         delwin(temp_win);
3458
3459         if ((menu_list[counter].procedure != NULL) || 
3460             (menu_list[counter].iprocedure != NULL) || 
3461             (menu_list[counter].nprocedure != NULL))
3462         {
3463                 if (menu_list[counter].argument != -1)
3464                         (*menu_list[counter].iprocedure)(menu_list[counter].argument);
3465                 else if (menu_list[counter].ptr_argument != NULL)
3466                         (*menu_list[counter].procedure)(menu_list[counter].ptr_argument);
3467                 else
3468                         (*menu_list[counter].nprocedure)();
3469         }
3470
3471         if (info_window)
3472                 paint_info_win();
3473         redraw();
3474
3475         return(counter);
3476 }
3477
3478 void 
3479 paint_menu(struct menu_entries *menu_list, int max_width, int max_height,
3480            int list_size, int top_offset, WINDOW *menu_win, int off_start,
3481            int vert_size)
3482 {
3483         int counter, temp_int;
3484
3485         werase(menu_win);
3486
3487         /*
3488          |      output top and bottom portions of menu box only if window 
3489          |      large enough 
3490          */
3491
3492         if (max_height > vert_size)
3493         {
3494                 wmove(menu_win, 1, 1);
3495                 if (!nohighlight)
3496                         wstandout(menu_win);
3497                 waddch(menu_win, '+');
3498                 for (counter = 0; counter < (max_width - 4); counter++)
3499                         waddch(menu_win, '-');
3500                 waddch(menu_win, '+');
3501
3502                 wmove(menu_win, (max_height - 2), 1);
3503                 waddch(menu_win, '+');
3504                 for (counter = 0; counter < (max_width - 4); counter++)
3505                         waddch(menu_win, '-');
3506                 waddch(menu_win, '+');
3507                 wstandend(menu_win);
3508                 wmove(menu_win, 2, 3);
3509                 waddstr(menu_win, menu_list[0].item_string);
3510                 wmove(menu_win, (max_height - 3), 3);
3511                 if (menu_list[0].argument != MENU_WARN)
3512                         waddstr(menu_win, menu_cancel_msg);
3513         }
3514         if (!nohighlight)
3515                 wstandout(menu_win);
3516
3517         for (counter = 0; counter < (vert_size + top_offset); counter++)
3518         {
3519                 if (top_offset == 4)
3520                 {
3521                         temp_int = counter + 2;
3522                 }
3523                 else
3524                         temp_int = counter;
3525
3526                 wmove(menu_win, temp_int, 1);
3527                 waddch(menu_win, '|');
3528                 wmove(menu_win, temp_int, (max_width - 2));
3529                 waddch(menu_win, '|');
3530         }
3531         wstandend(menu_win);
3532
3533         if (list_size > vert_size)
3534         {
3535                 if (off_start >= 3)
3536                 {
3537                         temp_int = 1;
3538                         wmove(menu_win, top_offset, 3);
3539                         waddstr(menu_win, more_above_str);
3540                 }
3541                 else
3542                         temp_int = 0;
3543
3544                 for (counter = off_start; 
3545                         ((temp_int + counter - off_start) < (vert_size - 1));
3546                                 counter++)
3547                 {
3548                         wmove(menu_win, (top_offset + temp_int + 
3549                                                 (counter - off_start)), 3);
3550                         if (list_size > 1)
3551                                 wprintw(menu_win, "%c) ", item_alpha[min((counter - 1), max_alpha_char)]);
3552                         waddstr(menu_win, menu_list[counter].item_string);
3553                 }
3554
3555                 wmove(menu_win, (top_offset + (vert_size - 1)), 3);
3556
3557                 if (counter == list_size)
3558                 {
3559                         if (list_size > 1)
3560                                 wprintw(menu_win, "%c) ", item_alpha[min((counter - 1), max_alpha_char)]);
3561                         wprintw(menu_win, menu_list[counter].item_string);
3562                 }
3563                 else
3564                         wprintw(menu_win, more_below_str);
3565         }
3566         else
3567         {
3568                 for (counter = 1; counter <= list_size; counter++)
3569                 {
3570                         wmove(menu_win, (top_offset + counter - 1), 3);
3571                         if (list_size > 1)
3572                                 wprintw(menu_win, "%c) ", item_alpha[min((counter - 1), max_alpha_char)]);
3573                         waddstr(menu_win, menu_list[counter].item_string);
3574                 }
3575         }
3576 }
3577
3578 void 
3579 help(void)
3580 {
3581         int counter;
3582
3583         werase(help_win);
3584         clearok(help_win, TRUE);
3585         for (counter = 0; counter < 22; counter++)
3586         {
3587                 wmove(help_win, counter, 0);
3588                 waddstr(help_win, (emacs_keys_mode) ? 
3589                         emacs_help_text[counter] : help_text[counter]);
3590         }
3591         wrefresh(help_win);
3592         werase(com_win);
3593         wmove(com_win, 0, 0);
3594         wprintw(com_win, press_any_key_msg);
3595         wrefresh(com_win);
3596         counter = wgetch(com_win);
3597         werase(com_win);
3598         wmove(com_win, 0, 0);
3599         werase(help_win);
3600         wrefresh(help_win);
3601         wrefresh(com_win);
3602         redraw();
3603 }
3604
3605 void 
3606 paint_info_win(void)
3607 {
3608         int counter;
3609
3610         if (!info_window)
3611                 return;
3612
3613         werase(info_win);
3614         for (counter = 0; counter < 5; counter++)
3615         {
3616                 wmove(info_win, counter, 0);
3617                 wclrtoeol(info_win);
3618                 if (info_type == CONTROL_KEYS)
3619                         waddstr(info_win, (emacs_keys_mode) ? 
3620                           emacs_control_keys[counter] : control_keys[counter]);
3621                 else if (info_type == COMMANDS)
3622                         waddstr(info_win, command_strings[counter]);
3623         }
3624         wrefresh(info_win);
3625 }
3626
3627 void 
3628 no_info_window(void)
3629 {
3630         if (!info_window)
3631                 return;
3632         delwin(info_win);
3633         delwin(text_win);
3634         info_window = FALSE;
3635         last_line = LINES - 2;
3636         text_win = newwin((LINES - 1), COLS, 0, 0);
3637         keypad(text_win, TRUE);
3638         idlok(text_win, TRUE);
3639         clearok(text_win, TRUE);
3640         midscreen(scr_vert, point);
3641         wrefresh(text_win);
3642         clear_com_win = TRUE;
3643 }
3644
3645 void 
3646 create_info_window(void)
3647 {
3648         if (info_window)
3649                 return;
3650         last_line = LINES - 8;
3651         delwin(text_win);
3652         text_win = newwin((LINES - 7), COLS, 6, 0);
3653         keypad(text_win, TRUE);
3654         idlok(text_win, TRUE);
3655         werase(text_win);
3656         info_window = TRUE;
3657         info_win = newwin(5, COLS, 0, 0);
3658         werase(info_win);
3659         info_type = CONTROL_KEYS;
3660         midscreen(min(scr_vert, last_line), point);
3661         clearok(info_win, TRUE);
3662         paint_info_win();
3663         count_win = newwin(1, COLS, 5, 0);
3664         leaveok(count_win, TRUE);
3665         wrefresh(count_win);
3666         wrefresh(text_win);
3667         clear_com_win = TRUE;
3668 }
3669
3670 int 
3671 file_op(int arg)
3672 {
3673         char *string;
3674         int flag;
3675
3676         if (restrict_mode())
3677         {
3678                 return(0);
3679         }
3680
3681         if (arg == READ_FILE)
3682         {
3683                 string = get_string(file_read_prompt_str, TRUE);
3684                 recv_file = TRUE;
3685                 tmp_file = resolve_name(string);
3686                 check_fp();
3687                 if (tmp_file != string)
3688                         free(tmp_file);
3689                 free(string);
3690         }
3691         else if (arg == WRITE_FILE)
3692         {
3693                 string = get_string(file_write_prompt_str, TRUE);
3694                 tmp_file = resolve_name(string);
3695                 write_file(tmp_file, 1);
3696                 if (tmp_file != string)
3697                         free(tmp_file);
3698                 free(string);
3699         }
3700         else if (arg == SAVE_FILE)
3701         {
3702         /*
3703          |      changes made here should be reflected in finish()
3704          */
3705
3706                 if (in_file_name)
3707                         flag = TRUE;
3708                 else
3709                         flag = FALSE;
3710
3711                 string = in_file_name;
3712                 if ((string == NULL) || (*string == (char) NULL))
3713                         string = get_string(save_file_name_prompt, TRUE);
3714                 if ((string == NULL) || (*string == (char) NULL))
3715                 {
3716                         wmove(com_win, 0, 0);
3717                         wprintw(com_win, file_not_saved_msg);
3718                         wclrtoeol(com_win);
3719                         wrefresh(com_win);
3720                         clear_com_win = TRUE;
3721                         return(0);
3722                 }
3723                 if (!flag)
3724                 {
3725                         tmp_file = resolve_name(string);
3726                         if (tmp_file != string)
3727                         {
3728                                 free(string);
3729                                 string = tmp_file;
3730                         }
3731                 }
3732                 if (write_file(string, 1))
3733                 {
3734                         in_file_name = string;
3735                         text_changes = FALSE;
3736                 }
3737                 else if (!flag)
3738                         free(string);
3739         }
3740         return(0);
3741 }
3742
3743 void 
3744 shell_op(void)
3745 {
3746         char *string;
3747
3748         if (((string = get_string(shell_prompt, TRUE)) != NULL) && 
3749                         (*string != (char) NULL))
3750         {
3751                 sh_command(string);
3752                 free(string);
3753         }
3754 }
3755
3756 void 
3757 leave_op(void)
3758 {
3759         if (text_changes)
3760         {
3761                 menu_op(leave_menu);
3762         }
3763         else
3764                 quit(TRUE);
3765 }
3766
3767 void 
3768 redraw(void)
3769 {
3770         if (info_window)
3771         {
3772                 clearok(info_win, TRUE);
3773                 paint_info_win();
3774         }
3775         else
3776                 clearok(text_win, TRUE);
3777         midscreen(scr_vert, point);
3778 }
3779
3780 /*
3781  |      The following routines will "format" a paragraph (as defined by a 
3782  |      block of text with blank lines before and after the block).
3783  */
3784
3785 int 
3786 Blank_Line(struct text *test_line)
3787 /* test if line has any non-space characters */
3788 {
3789         unsigned char *line;
3790         int length;
3791         
3792         if (test_line == NULL)
3793                 return(TRUE);
3794
3795         length = 1;
3796         line = test_line->line;
3797
3798         /*
3799          |      To handle troff/nroff documents, consider a line with a 
3800          |      period ('.') in the first column to be blank.  To handle mail 
3801          |      messages with included text, consider a line with a '>' blank.
3802          */
3803
3804         if ((*line == '.') || (*line == '>'))
3805                 return(TRUE);
3806
3807         while (((*line == ' ') || (*line == '\t')) && (length < test_line->line_length))
3808         {
3809                 length++;
3810                 line++;
3811         }
3812         if (length != test_line->line_length)
3813                 return(FALSE);
3814         else
3815                 return(TRUE);
3816 }
3817
3818 void 
3819 Format(void)    /* format the paragraph according to set margins        */
3820 {
3821         int string_count;
3822         int offset;
3823         int temp_case;
3824         int status;
3825         int tmp_af;
3826         int counter;
3827         unsigned char *line;
3828         unsigned char *tmp_srchstr;
3829         unsigned char *temp1, *temp2;
3830         unsigned char *temp_dword;
3831         unsigned char temp_d_char[3];
3832
3833         temp_d_char[0] = d_char[0];
3834         temp_d_char[1] = d_char[1];
3835         temp_d_char[2] = d_char[2];
3836
3837 /*
3838  |      if observ_margins is not set, or the current line is blank, 
3839  |      do not format the current paragraph
3840  */
3841
3842         if ((!observ_margins) || (Blank_Line(curr_line)))
3843                 return;
3844
3845 /*
3846  |      save the currently set flags, and clear them
3847  */
3848
3849         wmove(com_win, 0, 0);
3850         wclrtoeol(com_win);
3851         wprintw(com_win, formatting_msg);
3852         wrefresh(com_win);
3853
3854 /*
3855  |      get current position in paragraph, so after formatting, the cursor 
3856  |      will be in the same relative position
3857  */
3858
3859         tmp_af = auto_format;
3860         auto_format = FALSE;
3861         offset = position;
3862         if (position != 1)
3863                 prev_word();
3864         temp_dword = d_word;
3865         d_word = NULL;
3866         temp_case = case_sen;
3867         case_sen = TRUE;
3868         tmp_srchstr = srch_str;
3869         temp2 = srch_str = (unsigned char *) malloc(1 + curr_line->line_length - position);
3870         if ((*point == ' ') || (*point == '\t'))
3871                 adv_word();
3872         offset -= position;
3873         counter = position;
3874         line = temp1 = point;
3875         while ((*temp1 != (char) NULL) && (*temp1 != ' ') && (*temp1 != '\t') && (counter < curr_line->line_length))
3876         {
3877                 *temp2 = *temp1;
3878                 temp2++;
3879                 temp1++;
3880                 counter++;
3881         }
3882         *temp2 = (char) NULL;
3883         if (position != 1)
3884                 bol();
3885         while (!Blank_Line(curr_line->prev_line))
3886                 bol();
3887         string_count = 0;
3888         status = TRUE;
3889         while ((line != point) && (status))
3890         {
3891                 status = search(FALSE);
3892                 string_count++;
3893         }
3894
3895         wmove(com_win, 0, 0);
3896         wclrtoeol(com_win);
3897         wprintw(com_win, formatting_msg);
3898         wrefresh(com_win);
3899
3900 /*
3901  |      now get back to the start of the paragraph to start formatting
3902  */
3903
3904         if (position != 1)
3905                 bol();
3906         while (!Blank_Line(curr_line->prev_line))
3907                 bol();
3908
3909         observ_margins = FALSE;
3910
3911 /*
3912  |      Start going through lines, putting spaces at end of lines if they do 
3913  |      not already exist.  Append lines together to get one long line, and 
3914  |      eliminate spacing at begin of lines.
3915  */
3916
3917         while (!Blank_Line(curr_line->next_line))
3918         {
3919                 eol();
3920                 left(TRUE);
3921                 if (*point != ' ')
3922                 {
3923                         right(TRUE);
3924                         insert(' ');
3925                 }
3926                 else
3927                         right(TRUE);
3928                 del_char();
3929                 if ((*point == ' ') || (*point == '\t'))
3930                         del_word();
3931         }
3932
3933 /*
3934  |      Now there is one long line.  Eliminate extra spaces within the line
3935  |      after the first word (so as not to blow away any indenting the user 
3936  |      may have put in).
3937  */
3938
3939         bol();
3940         adv_word();
3941         while (position < curr_line->line_length)
3942         {
3943                 if ((*point == ' ') && (*(point + 1) == ' '))
3944                         del_char();
3945                 else
3946                         right(TRUE);
3947         }
3948
3949 /*
3950  |      Now make sure there are two spaces after a '.'.
3951  */
3952
3953         bol();
3954         while (position < curr_line->line_length)
3955         {
3956                 if ((*point == '.') && (*(point + 1) == ' '))
3957                 {
3958                         right(TRUE);
3959                         insert(' ');
3960                         insert(' ');
3961                         while (*point == ' ')
3962                                 del_char();
3963                 }
3964                 right(TRUE);
3965         }
3966
3967         observ_margins = TRUE;
3968         bol();
3969
3970         wmove(com_win, 0, 0);
3971         wclrtoeol(com_win);
3972         wprintw(com_win, formatting_msg);
3973         wrefresh(com_win);
3974
3975 /*
3976  |      create lines between margins
3977  */
3978
3979         while (position < curr_line->line_length)
3980         {
3981                 while ((scr_pos < right_margin) && (position < curr_line->line_length))
3982                         right(TRUE);
3983                 if (position < curr_line->line_length)
3984                 {
3985                         prev_word();
3986                         if (position == 1)
3987                                 adv_word();
3988                         insert_line(TRUE);
3989                 }
3990         }
3991
3992 /*
3993  |      go back to begin of paragraph, put cursor back to original position
3994  */
3995
3996         bol();
3997         while (!Blank_Line(curr_line->prev_line))
3998                 bol();
3999
4000 /*
4001  |      find word cursor was in
4002  */
4003
4004         while ((status) && (string_count > 0))
4005         {
4006                 search(FALSE);
4007                 string_count--;
4008         }
4009
4010 /*
4011  |      offset the cursor to where it was before from the start of the word
4012  */
4013
4014         while (offset > 0)
4015         {
4016                 offset--;
4017                 right(TRUE);
4018         }
4019
4020 /*
4021  |      reset flags and strings to what they were before formatting
4022  */
4023
4024         if (d_word != NULL)
4025                 free(d_word);
4026         d_word = temp_dword;
4027         case_sen = temp_case;
4028         free(srch_str);
<