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
  53 #include <sys/cdefs.h>
  54 __FBSDID("$FreeBSD$");
  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 #if defined(__STDC__) || defined(__cplusplus)
 226 #define P_(s) s
 227 #else
 228 #define P_(s) ()
 229 #endif
 230
 231
 232 /*
 233  |      The following structure allows menu items to be flexibly declared.
 234  |      The first item is the string describing the selection, the second
 235  |      is the address of the procedure to call when the item is selected,
 236  |      and the third is the argument for the procedure.
 237  |
 238  |      For those systems with i18n, the string should be accompanied by a
 239  |      catalog number.  The 'int *' should be replaced with 'void *' on
 240  |      systems with that type.
 241  |
 242  |      The first menu item will be the title of the menu, with NULL
 243  |      parameters for the procedure and argument, followed by the menu items.
 244  |
 245  |      If the procedure value is NULL, the menu item is displayed, but no
 246  |      procedure is called when the item is selected.  The number of the
 247  |      item will be returned.  If the third (argument) parameter is -1, no
 248  |      argument is given to the procedure when it is called.
 249  */
 250
 251 struct menu_entries {
 252         char *item_string;
 253         int (*procedure)P_((struct menu_entries *));
 254         struct menu_entries *ptr_argument;
 255         int (*iprocedure)P_((int));
 256         void (*nprocedure)P_((void));
 257         int argument;
 258         };
 259
 260 int main P_((int argc, char *argv[]));
 261 unsigned char *resiz_line P_((int factor, struct text *rline, int rpos));
 262 void insert P_((int character));
 263 void delete P_((int disp));
 264 void scanline P_((unsigned char *pos));
 265 int tabshift P_((int temp_int));
 266 int out_char P_((WINDOW *window, int character, int column));
 267 int len_char P_((int character, int column));
 268 void draw_line P_((int vertical, int horiz, unsigned char *ptr, int t_pos, int length));
 269 void insert_line P_((int disp));
 270 struct text *txtalloc P_((void));
 271 struct files *name_alloc P_((void));
 272 unsigned char *next_word P_((unsigned char *string));
 273 void prev_word P_((void));
 274 void control P_((void));
 275 void emacs_control P_((void));
 276 void bottom P_((void));
 277 void top P_((void));
 278 void nextline P_((void));
 279 void prevline P_((void));
 280 void left P_((int disp));
 281 void right P_((int disp));
 282 void find_pos P_((void));
 283 void up P_((void));
 284 void down P_((void));
 285 void function_key P_((void));
 286 void print_buffer P_((void));
 287 void command_prompt P_((void));
 288 void command P_((char *cmd_str1));
 289 int scan P_((char *line, int offset, int column));
 290 char *get_string P_((char *prompt, int advance));
 291 int compare P_((char *string1, char *string2, int sensitive));
 292 void goto_line P_((char *cmd_str));
 293 void midscreen P_((int line, unsigned char *pnt));
 294 void get_options P_((int numargs, char *arguments[]));
 295 void check_fp P_((void));
 296 void get_file P_((char *file_name));
 297 void get_line P_((int length, unsigned char *in_string, int *append));
 298 void draw_screen P_((void));
 299 void finish P_((void));
 300 int quit P_((int noverify));
 301 void edit_abort P_((int arg));
 302 void delete_text P_((void));
 303 int write_file P_((char *file_name));
 304 int search P_((int display_message));
 305 void search_prompt P_((void));
 306 void del_char P_((void));
 307 void undel_char P_((void));
 308 void del_word P_((void));
 309 void undel_word P_((void));
 310 void del_line P_((void));
 311 void undel_line P_((void));
 312 void adv_word P_((void));
 313 void move_rel P_((char *direction, int lines));
 314 void eol P_((void));
 315 void bol P_((void));
 316 void adv_line P_((void));
 317 void sh_command P_((char *string));
 318 void set_up_term P_((void));
 319 void resize_check P_((void));
 320 int menu_op P_((struct menu_entries *));
 321 void paint_menu P_((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));
 322 void help P_((void));
 323 void paint_info_win P_((void));
 324 void no_info_window P_((void));
 325 void create_info_window P_((void));
 326 int file_op P_((int arg));
 327 void shell_op P_((void));
 328 void leave_op P_((void));
 329 void redraw P_((void));
 330 int Blank_Line P_((struct text *test_line));
 331 void Format P_((void));
 332 void ee_init P_((void));
 333 void dump_ee_conf P_((void));
 334 void echo_string P_((char *string));
 335 void spell_op P_((void));
 336 void ispell_op P_((void));
 337 int first_word_len P_((struct text *test_line));
 338 void Auto_Format P_((void));
 339 void modes_op P_((void));
 340 char *is_in_string P_((char *string, char *substring));
 341 char *resolve_name P_((char *name));
 342 int restrict_mode P_((void));
 343 int unique_test P_((char *string, char *list[]));
 344 void renumber_lines P_((struct text *firstline, int startnumber));
 345 void strings_init P_((void));
 346
 347 #undef P_
 348 /*
 349  |      allocate space here for the strings that will be in the menu
 350  */
 351
 352 struct menu_entries modes_menu[] = {
 353         {"", NULL, NULL, NULL, NULL, 0},        /* title                */
 354         {"", NULL, NULL, NULL, NULL, -1},       /* 1. tabs to spaces    */
 355         {"", NULL, NULL, NULL, NULL, -1},       /* 2. case sensitive search*/
 356         {"", NULL, NULL, NULL, NULL, -1},       /* 3. margins observed  */
 357         {"", NULL, NULL, NULL, NULL, -1},       /* 4. auto-paragraph    */
 358         {"", NULL, NULL, NULL, NULL, -1},       /* 5. eightbit characters*/
 359         {"", NULL, NULL, NULL, NULL, -1},       /* 6. info window       */
 360         {"", NULL, NULL, NULL, NULL, -1},       /* 7. emacs key bindings*/
 361         {"", NULL, NULL, NULL, NULL, -1},       /* 8. right margin      */
 362         {"", NULL, NULL, NULL, NULL, -1},       /* 9. chinese text      */
 363         {"", NULL, NULL, NULL, dump_ee_conf, -1}, /* 10. save editor config */
 364         {NULL, NULL, NULL, NULL, NULL, -1}      /* terminator           */
 365         };
 366
 367 char *mode_strings[11];
 368
 369 #define NUM_MODES_ITEMS 10
 370
 371 struct menu_entries config_dump_menu[] = {
 372         {"", NULL, NULL, NULL, NULL, 0},
 373         {"", NULL, NULL, NULL, NULL, -1},
 374         {"", NULL, NULL, NULL, NULL, -1},
 375         {NULL, NULL, NULL, NULL, NULL, -1}
 376         };
 377
 378 struct menu_entries leave_menu[] = {
 379         {"", NULL, NULL, NULL, NULL, -1},
 380         {"", NULL, NULL, NULL, finish, -1},
 381         {"", NULL, NULL, quit, NULL, TRUE},
 382         {NULL, NULL, NULL, NULL, NULL, -1}
 383         };
 384
 385 #define READ_FILE 1
 386 #define WRITE_FILE 2
 387 #define SAVE_FILE 3
 388
 389 struct menu_entries file_menu[] = {
 390         {"", NULL, NULL, NULL, NULL, -1},
 391         {"", NULL, NULL, file_op, NULL, READ_FILE},
 392         {"", NULL, NULL, file_op, NULL, WRITE_FILE},
 393         {"", NULL, NULL, file_op, NULL, SAVE_FILE},
 394         {"", NULL, NULL, NULL, print_buffer, -1},
 395         {NULL, NULL, NULL, NULL, NULL, -1}
 396         };
 397
 398 struct menu_entries search_menu[] = {
 399         {"", NULL, NULL, NULL, NULL, 0},
 400         {"", NULL, NULL, NULL, search_prompt, -1},
 401         {"", NULL, NULL, search, NULL, TRUE},
 402         {NULL, NULL, NULL, NULL, NULL, -1}
 403         };
 404
 405 struct menu_entries spell_menu[] = {
 406         {"", NULL, NULL, NULL, NULL, -1},
 407         {"", NULL, NULL, NULL, spell_op, -1},
 408         {"", NULL, NULL, NULL, ispell_op, -1},
 409         {NULL, NULL, NULL, NULL, NULL, -1}
 410         };
 411
 412 struct menu_entries misc_menu[] = {
 413         {"", NULL, NULL, NULL, NULL, -1},
 414         {"", NULL, NULL, NULL, Format, -1},
 415         {"", NULL, NULL, NULL, shell_op, -1},
 416         {"", menu_op, spell_menu, NULL, NULL, -1},
 417         {NULL, NULL, NULL, NULL, NULL, -1}
 418         };
 419
 420 struct menu_entries main_menu[] = {
 421         {"", NULL, NULL, NULL, NULL, -1},
 422         {"", NULL, NULL, NULL, leave_op, -1},
 423         {"", NULL, NULL, NULL, help, -1},
 424         {"", menu_op, file_menu, NULL, NULL, -1},
 425         {"", NULL, NULL, NULL, redraw, -1},
 426         {"", NULL, NULL, NULL, modes_op, -1},
 427         {"", menu_op, search_menu, NULL, NULL, -1},
 428         {"", menu_op, misc_menu, NULL, NULL, -1},
 429         {NULL, NULL, NULL, NULL, NULL, -1}
 430         };
 431
 432 char *help_text[23];
 433 char *control_keys[5];
 434
 435 char *emacs_help_text[22];
 436 char *emacs_control_keys[5];
 437
 438 char *command_strings[5];
 439 char *commands[32];
 440 char *init_strings[22];
 441
 442 #define MENU_WARN 1
 443
 444 #define max_alpha_char 36
 445
 446 /*
 447  |      Declarations for strings for localization
 448  */
 449
 450 char *com_win_message;          /* to be shown in com_win if no info window */
 451 char *no_file_string;
 452 char *ascii_code_str;
 453 char *printer_msg_str;
 454 char *command_str;
 455 char *file_write_prompt_str;
 456 char *file_read_prompt_str;
 457 char *char_str;
 458 char *unkn_cmd_str;
 459 char *non_unique_cmd_msg;
 460 char *line_num_str;
 461 char *line_len_str;
 462 char *current_file_str;
 463 char *usage0;
 464 char *usage1;
 465 char *usage2;
 466 char *usage3;
 467 char *usage4;
 468 char *file_is_dir_msg;
 469 char *new_file_msg;
 470 char *cant_open_msg;
 471 char *open_file_msg;
 472 char *file_read_fin_msg;
 473 char *reading_file_msg;
 474 char *read_only_msg;
 475 char *file_read_lines_msg;
 476 char *save_file_name_prompt;
 477 char *file_not_saved_msg;
 478 char *changes_made_prompt;
 479 char *yes_char;
 480 char *file_exists_prompt;
 481 char *create_file_fail_msg;
 482 char *writing_file_msg;
 483 char *file_written_msg;
 484 char *searching_msg;
 485 char *str_not_found_msg;
 486 char *search_prompt_str;
 487 char *exec_err_msg;
 488 char *continue_msg;
 489 char *menu_cancel_msg;
 490 char *menu_size_err_msg;
 491 char *press_any_key_msg;
 492 char *shell_prompt;
 493 char *formatting_msg;
 494 char *shell_echo_msg;
 495 char *spell_in_prog_msg;
 496 char *margin_prompt;
 497 char *restricted_msg;
 498 char *ON;
 499 char *OFF;
 500 char *HELP;
 501 char *WRITE;
 502 char *READ;
 503 char *LINE;
 504 char *FILE_str;
 505 char *CHARACTER;
 506 char *REDRAW;
 507 char *RESEQUENCE;
 508 char *AUTHOR;
 509 char *VERSION;
 510 char *CASE;
 511 char *NOCASE;
 512 char *EXPAND;
 513 char *NOEXPAND;
 514 char *Exit_string;
 515 char *QUIT_string;
 516 char *INFO;
 517 char *NOINFO;
 518 char *MARGINS;
 519 char *NOMARGINS;
 520 char *AUTOFORMAT;
 521 char *NOAUTOFORMAT;
 522 char *Echo;
 523 char *PRINTCOMMAND;
 524 char *RIGHTMARGIN;
 525 char *HIGHLIGHT;
 526 char *NOHIGHLIGHT;
 527 char *EIGHTBIT;
 528 char *NOEIGHTBIT;
 529 char *EMACS_string;
 530 char *NOEMACS_string;
 531 char *conf_dump_err_msg;
 532 char *conf_dump_success_msg;
 533 char *conf_not_saved_msg;
 534 char *ree_no_file_msg;
 535 char *cancel_string;
 536 char *menu_too_lrg_msg;
 537 char *more_above_str, *more_below_str;
 538
 539 char *chinese_cmd, *nochinese_cmd;
 540
 541
 542 int
 543 main(argc, argv)                /* beginning of main program            */
 544 int argc;
 545 char *argv[];
 546 {
 547         /* Always read from (and write to) a terminal. */
 548         if (!isatty(STDIN_FILENO) || !isatty(STDOUT_FILENO)) {
 549                 fprintf(stderr, "ee's standard input and output must be a terminal\n");
 550                 exit(1);
 551         }
 552
 553         signal(SIGCHLD, SIG_DFL);
 554         signal(SIGSEGV, SIG_DFL);
 555         signal(SIGINT, edit_abort);
 556         signal(SIGHUP, edit_abort);
 557
 558         d_char = malloc(3);     /* provide a buffer for multi-byte chars */
 559         d_word = malloc(150);
 560         *d_word = (char) NULL;
 561         d_line = NULL;
 562         dlt_line = txtalloc();
 563         dlt_line->line = d_line;
 564         dlt_line->line_length = 0;
 565         curr_line = first_line = txtalloc();
 566         curr_line->line = point = malloc(10);
 567         curr_line->line_length = 1;
 568         curr_line->max_length = 10;
 569         curr_line->prev_line = NULL;
 570         curr_line->next_line = NULL;
 571         curr_line->line_number  = 1;
 572         srch_str = NULL;
 573         u_srch_str = NULL;
 574         position = 1;
 575         scr_pos =0;
 576         scr_vert = 0;
 577         scr_horz = 0;
 578         bit_bucket = fopen(_PATH_DEVNULL, "w");
 579         edit = TRUE;
 580         gold = case_sen = FALSE;
 581         shell_fork = TRUE;
 582         strings_init();
 583         ee_init();
 584         if (argc > 0 )
 585                 get_options(argc, argv);
 586         set_up_term();
 587         if (right_margin == 0)
 588                 right_margin = COLS - 1;
 589         if (top_of_stack == NULL)
 590         {
 591                 if (restrict_mode())
 592                 {
 593                         wmove(com_win, 0, 0);
 594                         werase(com_win);
 595                         wprintw(com_win, ree_no_file_msg);
 596                         wrefresh(com_win);
 597                         edit_abort(0);
 598                 }
 599                 wprintw(com_win, no_file_string);
 600                 wrefresh(com_win);
 601         }
 602         else
 603                 check_fp();
 604
 605         clear_com_win = TRUE;
 606
 607         while(edit)
 608         {
 609                 if (info_window)
 610                 {
 611                         snprintf(count_text, count_text_len, "L: %d C: %d %s", \
 612                                 curr_line->line_number, scr_horz + 1, count_text_default);
 613                         wmove(count_win, 0, 0);
 614                         if (!nohighlight)
 615                                 wstandout(count_win);
 616                         wprintw(count_win, count_text);
 617                         wstandend(count_win);
 618                         wnoutrefresh(count_win);
 619                 }
 620
 621                 wnoutrefresh(text_win);
 622                 doupdate();
 623                 in = wgetch(text_win);
 624                 if (in == -1)
 625                         continue;
 626
 627                 resize_check();
 628
 629                 if (clear_com_win)
 630                 {
 631                         clear_com_win = FALSE;
 632                         wmove(com_win, 0, 0);
 633                         werase(com_win);
 634                         if (!info_window)
 635                         {
 636                                 wprintw(com_win, "%s", com_win_message);
 637                         }
 638                         wrefresh(com_win);
 639                 }
 640
 641                 if (in > 255)
 642                         function_key();
 643                 else if ((in == '\10') || (in == 127))
 644                 {
 645                         in = 8;         /* make sure key is set to backspace */
 646                         delete(TRUE);
 647                 }
 648                 else if ((in > 31) || (in == 9))
 649                         insert(in);
 650                 else if ((in >= 0) && (in <= 31))
 651                 {
 652                         if (emacs_keys_mode)
 653                                 emacs_control();
 654                         else
 655                                 control();
 656                 }
 657         }
 658         return(0);
 659 }
 660
 661 unsigned char *
 662 resiz_line(factor, rline, rpos) /* resize the line to length + factor*/
 663 int factor;             /* resize factor                                */
 664 struct text *rline;     /* position in line                             */
 665 int rpos;
 666 {
 667         unsigned char *rpoint;
 668         int resiz_var;
 669
 670         rline->max_length += factor;
 671         rpoint = rline->line = realloc(rline->line, rline->max_length );
 672         for (resiz_var = 1 ; (resiz_var < rpos) ; resiz_var++)
 673                 rpoint++;
 674         return(rpoint);
 675 }
 676
 677 void
 678 insert(character)               /* insert character into line           */
 679 int character;                  /* new character                        */
 680 {
 681         int counter;
 682         int value;
 683         unsigned char *temp;    /* temporary pointer                    */
 684         unsigned char *temp2;   /* temporary pointer                    */
 685
 686         if ((character == '\011') && (expand_tabs))
 687         {
 688                 counter = len_char('\011', scr_horz);
 689                 for (; counter > 0; counter--)
 690                         insert(' ');
 691                 if (auto_format)
 692                         Auto_Format();
 693                 return;
 694         }
 695         text_changes = TRUE;
 696         if ((curr_line->max_length - curr_line->line_length) < 5)
 697                 point = resiz_line(10, curr_line, position);
 698         curr_line->line_length++;
 699         temp = point;
 700         counter = position;
 701         while (counter < curr_line->line_length)        /* find end of line */
 702         {
 703                 counter++;
 704                 temp++;
 705         }
 706         temp++;                 /* increase length of line by one       */
 707         while (point < temp)
 708         {
 709                 temp2=temp - 1;
 710                 *temp= *temp2;  /* shift characters over by one         */
 711                 temp--;
 712         }
 713         *point = character;     /* insert new character                 */
 714         wclrtoeol(text_win);
 715         if (((character >= 0) && (character < ' ')) || (character >= 127)) /* check for TAB character*/
 716         {
 717                 scr_pos = scr_horz += out_char(text_win, character, scr_horz);
 718                 point++;
 719                 position++;
 720         }
 721         else
 722         {
 723                 waddch(text_win, character);
 724                 scr_pos = ++scr_horz;
 725                 point++;
 726                 position ++;
 727         }
 728
 729         if ((observ_margins) && (right_margin < scr_pos))
 730         {
 731                 counter = position;
 732                 while (scr_pos > right_margin)
 733                         prev_word();
 734                 if (scr_pos == 0)
 735                 {
 736                         while (position < counter)
 737                                 right(TRUE);
 738                 }
 739                 else
 740                 {
 741                         counter -= position;
 742                         insert_line(TRUE);
 743                         for (value = 0; value < counter; value++)
 744                                 right(TRUE);
 745                 }
 746         }
 747
 748         if ((scr_horz - horiz_offset) > last_col)
 749         {
 750                 horiz_offset += 8;
 751                 midscreen(scr_vert, point);
 752         }
 753
 754         if ((auto_format) && (character == ' ') && (!formatted))
 755                 Auto_Format();
 756         else if ((character != ' ') && (character != '\t'))
 757                 formatted = FALSE;
 758
 759         draw_line(scr_vert, scr_horz, point, position, curr_line->line_length);
 760 }
 761
 762 void
 763 delete(disp)                    /* delete character             */
 764 int disp;
 765 {
 766         unsigned char *tp;
 767         unsigned char *temp2;
 768         struct text *temp_buff;
 769         int temp_vert;
 770         int temp_pos;
 771         int del_width = 1;
 772
 773         if (point != curr_line->line)   /* if not at beginning of line  */
 774         {
 775                 text_changes = TRUE;
 776                 temp2 = tp = point;
 777                 if ((ee_chinese) && (position >= 2) && (*(point - 2) > 127))
 778                 {
 779                         del_width = 2;
 780                 }
 781                 tp -= del_width;
 782                 point -= del_width;
 783                 position -= del_width;
 784                 temp_pos = position;
 785                 curr_line->line_length -= del_width;
 786                 if ((*tp < ' ') || (*tp >= 127))        /* check for TAB */
 787                         scanline(tp);
 788                 else
 789                         scr_horz -= del_width;
 790                 scr_pos = scr_horz;
 791                 if (in == 8)
 792                 {
 793                         if (del_width == 1)
 794                                 *d_char = *point; /* save deleted character  */
 795                         else
 796                         {
 797                                 d_char[0] = *point;
 798                                 d_char[1] = *(point + 1);
 799                         }
 800                         d_char[del_width] = (unsigned char) NULL;
 801                 }
 802                 while (temp_pos <= curr_line->line_length)
 803                 {
 804                         temp_pos++;
 805                         *tp = *temp2;
 806                         tp++;
 807                         temp2++;
 808                 }
 809                 if (scr_horz < horiz_offset)
 810                 {
 811                         horiz_offset -= 8;
 812                         midscreen(scr_vert, point);
 813                 }
 814         }
 815         else if (curr_line->prev_line != NULL)
 816         {
 817                 text_changes = TRUE;
 818                 left(disp);                     /* go to previous line  */
 819                 temp_buff = curr_line->next_line;
 820                 point = resiz_line(temp_buff->line_length, curr_line, position);
 821                 if (temp_buff->next_line != NULL)
 822                         temp_buff->next_line->prev_line = curr_line;
 823                 curr_line->next_line = temp_buff->next_line;
 824                 renumber_lines(curr_line->next_line, curr_line->line_number + 1);
 825                 temp2 = temp_buff->line;
 826                 if (in == 8)
 827                 {
 828                         d_char[0] = '\n';
 829                         d_char[1] = (unsigned char) NULL;
 830                 }
 831                 tp = point;
 832                 temp_pos = 1;
 833                 while (temp_pos < temp_buff->line_length)
 834                 {
 835                         curr_line->line_length++;
 836                         temp_pos++;
 837                         *tp = *temp2;
 838                         tp++;
 839                         temp2++;
 840                 }
 841                 *tp = (char) NULL;
 842                 free(temp_buff->line);
 843                 free(temp_buff);
 844                 temp_buff = curr_line;
 845                 temp_vert = scr_vert;
 846                 scr_pos = scr_horz;
 847                 if (scr_vert < last_line)
 848                 {
 849                         wmove(text_win, scr_vert + 1, 0);
 850                         wdeleteln(text_win);
 851                 }
 852                 while ((temp_buff != NULL) && (temp_vert < last_line))
 853                 {
 854                         temp_buff = temp_buff->next_line;
 855                         temp_vert++;
 856                 }
 857                 if ((temp_vert == last_line) && (temp_buff != NULL))
 858                 {
 859                         tp = temp_buff->line;
 860                         wmove(text_win, last_line,0);
 861                         wclrtobot(text_win);
 862                         draw_line(last_line, 0, tp, 1, temp_buff->line_length);
 863                         wmove(text_win, scr_vert, (scr_horz - horiz_offset));
 864                 }
 865         }
 866         draw_line(scr_vert, scr_horz, point, position, curr_line->line_length);
 867         formatted = FALSE;
 868 }
 869
 870 void
 871 scanline(pos)   /* find the proper horizontal position for the pointer  */
 872 unsigned char *pos;
 873 {
 874         int temp;
 875         unsigned char *ptr;
 876
 877         ptr = curr_line->line;
 878         temp = 0;
 879         while (ptr < pos)
 880         {
 881                 if (*ptr <= 8)
 882                         temp += 2;
 883                 else if (*ptr == 9)
 884                         temp += tabshift(temp);
 885                 else if ((*ptr >= 10) && (*ptr <= 31))
 886                         temp += 2;
 887                 else if ((*ptr >= 32) && (*ptr < 127))
 888                         temp++;
 889                 else if (*ptr == 127)
 890                         temp += 2;
 891                 else if (!eightbit)
 892                         temp += 5;
 893                 else
 894                         temp++;
 895                 ptr++;
 896         }
 897         scr_horz = temp;
 898         if ((scr_horz - horiz_offset) > last_col)
 899         {
 900                 horiz_offset = (scr_horz - (scr_horz % 8)) - (COLS - 8);
 901                 midscreen(scr_vert, point);
 902         }
 903         else if (scr_horz < horiz_offset)
 904         {
 905                 horiz_offset = max(0, (scr_horz - (scr_horz % 8)));
 906                 midscreen(scr_vert, point);
 907         }
 908 }
 909
 910 int
 911 tabshift(temp_int)              /* give the number of spaces to shift   */
 912 int temp_int;
 913 {
 914         int leftover;
 915
 916         leftover = ((temp_int + 1) % 8);
 917         if (leftover == 0)
 918                 return (1);
 919         else
 920                 return (9 - leftover);
 921 }
 922
 923 int
 924 out_char(window, character, column)     /* output non-printing character */
 925 WINDOW *window;
 926 char character;
 927 int column;
 928 {
 929         int i1, i2;
 930         unsigned char *string;
 931         char string2[8];
 932
 933         if (character == TAB)
 934         {
 935                 i1 = tabshift(column);
 936                 for (i2 = 0;
 937                   (i2 < i1) && (((column+i2+1)-horiz_offset) < last_col); i2++)
 938                 {
 939                         waddch(window, ' ');
 940                 }
 941                 return(i1);
 942         }
 943         else if ((character >= '\0') && (character < ' '))
 944         {
 945                 string = table[(int) character];
 946         }
 947         else if ((character < 0) || (character >= 127))
 948         {
 949                 if (character == 127)
 950                         string = "^?";
 951                 else if (!eightbit)
 952                 {
 953                         sprintf(string2, "<%d>", (character < 0) ? (character + 256) : character);
 954                         string = string2;
 955                 }
 956                 else
 957                 {
 958                         waddch(window, (unsigned char)character );
 959                         return(1);
 960                 }
 961         }
 962         else
 963         {
 964                 waddch(window, (unsigned char)character);
 965                 return(1);
 966         }
 967         for (i2 = 0; (string[i2] != (char) NULL) && (((column+i2+1)-horiz_offset) < last_col); i2++)
 968                 waddch(window, string[i2]);
 969         return(strlen(string));
 970 }
 971
 972 int
 973 len_char(character, column)     /* return the length of the character   */
 974 char character;
 975 int column;     /* the column must be known to provide spacing for tabs */
 976 {
 977         int length;
 978
 979         if (character == '\t')
 980                 length = tabshift(column);
 981         else if ((character >= 0) && (character < 32))
 982                 length = 2;
 983         else if ((character >= 32) && (character <= 126))
 984                 length = 1;
 985         else if (character == 127)
 986                 length = 2;
 987         else if (((character > 126) || (character < 0)) && (!eightbit))
 988                 length = 5;
 989         else
 990                 length = 1;
 991
 992         return(length);
 993 }
 994
 995 void
 996 draw_line(vertical, horiz, ptr, t_pos, length)  /* redraw line from current position */
 997 int vertical;   /* current vertical position on screen          */
 998 int horiz;      /* current horizontal position on screen        */
 999 unsigned char *ptr;     /* pointer to line                              */
1000 int t_pos;      /* current position (offset in bytes) from bol  */
1001 int length;     /* length (in bytes) of line                    */
1002 {
1003         int d;          /* partial length of special or tab char to display  */
1004         unsigned char *temp;    /* temporary pointer to position in line             */
1005         int abs_column; /* offset in screen units from begin of line         */
1006         int column;     /* horizontal position on screen                     */
1007         int row;        /* vertical position on screen                       */
1008         int posit;      /* temporary position indicator within line          */
1009
1010         abs_column = horiz;
1011         column = horiz - horiz_offset;
1012         row = vertical;
1013         temp = ptr;
1014         d = 0;
1015         posit = t_pos;
1016         if (column < 0)
1017         {
1018                 wmove(text_win, row, 0);
1019                 wclrtoeol(text_win);
1020         }
1021         while (column < 0)
1022         {
1023                 d = len_char(*temp, abs_column);
1024                 abs_column += d;
1025                 column += d;
1026                 posit++;
1027                 temp++;
1028         }
1029         wmove(text_win, row, column);
1030         wclrtoeol(text_win);
1031         while ((posit < length) && (column <= last_col))
1032         {
1033                 if ((*temp < 32) || (*temp >= 127))
1034                 {
1035                         column += len_char(*temp, abs_column);
1036                         abs_column += out_char(text_win, *temp, abs_column);
1037                 }
1038                 else
1039                 {
1040                         abs_column++;
1041                         column++;
1042                         waddch(text_win, *temp);
1043                 }
1044                 posit++;
1045                 temp++;
1046         }
1047         if (column < last_col)
1048                 wclrtoeol(text_win);
1049         wmove(text_win, vertical, (horiz - horiz_offset));
1050 }
1051
1052 void
1053 insert_line(disp)                       /* insert new line              */
1054 int disp;
1055 {
1056         int temp_pos;
1057         int temp_pos2;
1058         unsigned char *temp;
1059         unsigned char *extra;
1060         struct text *temp_nod;
1061
1062         text_changes = TRUE;
1063         wmove(text_win, scr_vert, (scr_horz - horiz_offset));
1064         wclrtoeol(text_win);
1065         temp_nod= txtalloc();
1066         temp_nod->line = extra= malloc(10);
1067         temp_nod->line_length = 1;
1068         temp_nod->max_length = 10;
1069         temp_nod->next_line = curr_line->next_line;
1070         renumber_lines(temp_nod, curr_line->line_number + 1);
1071         if (temp_nod->next_line != NULL)
1072                 temp_nod->next_line->prev_line = temp_nod;
1073         temp_nod->prev_line = curr_line;
1074         curr_line->next_line = temp_nod;
1075         temp_pos2 = position;
1076         temp = point;
1077         if (temp_pos2 < curr_line->line_length)
1078         {
1079                 temp_pos = 1;
1080                 while (temp_pos2 < curr_line->line_length)
1081                 {
1082                         if ((temp_nod->max_length - temp_nod->line_length)< 5)
1083                                 extra = resiz_line(10, temp_nod, temp_pos);
1084                         temp_nod->line_length++;
1085                         temp_pos++;
1086                         temp_pos2++;
1087                         *extra= *temp;
1088                         extra++;
1089                         temp++;
1090                 }
1091                 temp=point;
1092                 *temp = (char) NULL;
1093                 temp = resiz_line((1 - temp_nod->line_length), curr_line, position);
1094                 curr_line->line_length = 1 + temp - curr_line->line;
1095         }
1096         curr_line->line_length = position;
1097         curr_line = temp_nod;
1098         *extra = (char) NULL;
1099         position = 1;
1100         point= curr_line->line;
1101         if (disp)
1102         {
1103                 if (scr_vert < last_line)
1104                 {
1105                         scr_vert++;
1106                         wclrtoeol(text_win);
1107                         wmove(text_win, scr_vert, 0);
1108                         winsertln(text_win);
1109                 }
1110                 else
1111                 {
1112                         wmove(text_win, 0,0);
1113                         wdeleteln(text_win);
1114                         wmove(text_win, last_line,0);
1115                         wclrtobot(text_win);
1116                 }
1117                 scr_pos = scr_horz = 0;
1118                 if (horiz_offset)
1119                 {
1120                         horiz_offset = 0;
1121                         midscreen(scr_vert, point);
1122                 }
1123                 draw_line(scr_vert, scr_horz, point, position,
1124                         curr_line->line_length);
1125         }
1126 }
1127
1128 struct text *txtalloc()         /* allocate space for line structure    */
1129 {
1130         return((struct text *) malloc(sizeof( struct text)));
1131 }
1132
1133 struct files *name_alloc()      /* allocate space for file name list node */
1134 {
1135         return((struct files *) malloc(sizeof( struct files)));
1136 }
1137
1138 unsigned char *next_word(string)                /* move to next word in string          */
1139 unsigned char *string;
1140 {
1141         while ((*string != (char) NULL) && ((*string != 32) && (*string != 9)))
1142                 string++;
1143         while ((*string != (char) NULL) && ((*string == 32) || (*string == 9)))
1144                 string++;
1145         return(string);
1146 }
1147
1148 void
1149 prev_word()     /* move to start of previous word in text       */
1150 {
1151         if (position != 1)
1152         {
1153                 if ((position != 1) && ((point[-1] == ' ') || (point[-1] == '\t')))
1154                 {       /* if at the start of a word    */
1155                         while ((position != 1) && ((*point != ' ') && (*point != '\t')))
1156                                 left(TRUE);
1157                 }
1158                 while ((position != 1) && ((*point == ' ') || (*point == '\t')))
1159                         left(TRUE);
1160                 while ((position != 1) && ((*point != ' ') && (*point != '\t')))
1161                         left(TRUE);
1162                 if ((position != 1) && ((*point == ' ') || (*point == '\t')))
1163                         right(TRUE);
1164         }
1165         else
1166                 left(TRUE);
1167 }
1168
1169 void
1170 control()                       /* use control for commands             */
1171 {
1172         char *string;
1173
1174         if (in == 1)            /* control a    */
1175         {
1176                 string = get_string(ascii_code_str, TRUE);
1177                 if (*string != (char) NULL)
1178                 {
1179                         in = atoi(string);
1180                         wmove(text_win, scr_vert, (scr_horz - horiz_offset));
1181                         insert(in);
1182                 }
1183                 free(string);
1184         }
1185         else if (in == 2)       /* control b    */
1186                 bottom();
1187         else if (in == 3)       /* control c    */
1188         {
1189                 command_prompt();
1190         }
1191         else if (in == 4)       /* control d    */
1192                 down();
1193         else if (in == 5)       /* control e    */
1194                 search_prompt();
1195         else if (in == 6)       /* control f    */
1196                 undel_char();
1197         else if (in == 7)       /* control g    */
1198                 bol();
1199         else if (in == 8)       /* control h    */
1200                 delete(TRUE);
1201         else if (in == 9)       /* control i    */
1202                 ;
1203         else if (in == 10)      /* control j    */
1204                 insert_line(TRUE);
1205         else if (in == 11)      /* control k    */
1206                 del_char();
1207         else if (in == 12)      /* control l    */
1208                 left(TRUE);
1209         else if (in == 13)      /* control m    */
1210                 insert_line(TRUE);
1211         else if (in == 14)      /* control n    */
1212                 move_rel("d", max(5, (last_line - 5)));
1213         else if (in == 15)      /* control o    */
1214                 eol();
1215         else if (in == 16)      /* control p    */
1216                 move_rel("u", max(5, (last_line - 5)));
1217         else if (in == 17)      /* control q    */
1218                 ;
1219         else if (in == 18)      /* control r    */
1220                 right(TRUE);
1221         else if (in == 19)      /* control s    */
1222                 ;
1223         else if (in == 20)      /* control t    */
1224                 top();
1225         else if (in == 21)      /* control u    */
1226                 up();
1227         else if (in == 22)      /* control v    */
1228                 undel_word();
1229         else if (in == 23)      /* control w    */
1230                 del_word();
1231         else if (in == 24)      /* control x    */
1232                 search(TRUE);
1233         else if (in == 25)      /* control y    */
1234                 del_line();
1235         else if (in == 26)      /* control z    */
1236                 undel_line();
1237         else if (in == 27)      /* control [ (escape)   */
1238         {
1239                 menu_op(main_menu);
1240         }
1241 }
1242
1243 /*
1244  |      Emacs control-key bindings
1245  */
1246
1247 void
1248 emacs_control()
1249 {
1250         char *string;
1251
1252         if (in == 1)            /* control a    */
1253                 bol();
1254         else if (in == 2)       /* control b    */
1255                 left(TRUE);
1256         else if (in == 3)       /* control c    */
1257         {
1258                 command_prompt();
1259         }
1260         else if (in == 4)       /* control d    */
1261                 del_char();
1262         else if (in == 5)       /* control e    */
1263                 eol();
1264         else if (in == 6)       /* control f    */
1265                 right(TRUE);
1266         else if (in == 7)       /* control g    */
1267                 move_rel("u", max(5, (last_line - 5)));
1268         else if (in == 8)       /* control h    */
1269                 delete(TRUE);
1270         else if (in == 9)       /* control i    */
1271                 ;
1272         else if (in == 10)      /* control j    */
1273                 undel_char();
1274         else if (in == 11)      /* control k    */
1275                 del_line();
1276         else if (in == 12)      /* control l    */
1277                 undel_line();
1278         else if (in == 13)      /* control m    */
1279                 insert_line(TRUE);
1280         else if (in == 14)      /* control n    */
1281                 down();
1282         else if (in == 15)      /* control o    */
1283         {
1284                 string = get_string(ascii_code_str, TRUE);
1285                 if (*string != (char) NULL)
1286                 {
1287                         in = atoi(string);
1288                         wmove(text_win, scr_vert, (scr_horz - horiz_offset));
1289                         insert(in);
1290                 }
1291                 free(string);
1292         }
1293         else if (in == 16)      /* control p    */
1294                 up();
1295         else if (in == 17)      /* control q    */
1296                 ;
1297         else if (in == 18)      /* control r    */
1298                 undel_word();
1299         else if (in == 19)      /* control s    */
1300                 ;
1301         else if (in == 20)      /* control t    */
1302                 top();
1303         else if (in == 21)      /* control u    */
1304                 bottom();
1305         else if (in == 22)      /* control v    */
1306                 move_rel("d", max(5, (last_line - 5)));
1307         else if (in == 23)      /* control w    */
1308                 del_word();
1309         else if (in == 24)      /* control x    */
1310                 search(TRUE);
1311         else if (in == 25)      /* control y    */
1312                 search_prompt();
1313         else if (in == 26)      /* control z    */
1314                 adv_word();
1315         else if (in == 27)      /* control [ (escape)   */
1316         {
1317                 menu_op(main_menu);
1318         }
1319 }
1320
1321 void
1322 bottom()                        /* go to bottom of file                 */
1323 {
1324         while (curr_line->next_line != NULL)
1325                 curr_line = curr_line->next_line;
1326         point = curr_line->line;
1327         if (horiz_offset)
1328                 horiz_offset = 0;
1329         position = 1;
1330         midscreen(last_line, point);
1331         scr_pos = scr_horz;
1332 }
1333
1334 void
1335 top()                           /* go to top of file                    */
1336 {
1337         while (curr_line->prev_line != NULL)
1338                 curr_line = curr_line->prev_line;
1339         point = curr_line->line;
1340         if (horiz_offset)
1341                 horiz_offset = 0;
1342         position = 1;
1343         midscreen(0, point);
1344         scr_pos = scr_horz;
1345 }
1346
1347 void
1348 nextline()                      /* move pointers to start of next line  */
1349 {
1350         curr_line = curr_line->next_line;
1351         point = curr_line->line;
1352         position = 1;
1353         if (scr_vert == last_line)
1354         {
1355                 wmove(text_win, 0,0);
1356                 wdeleteln(text_win);
1357                 wmove(text_win, last_line,0);
1358                 wclrtobot(text_win);
1359                 draw_line(last_line,0,point,1,curr_line->line_length);
1360         }
1361         else
1362                 scr_vert++;
1363 }
1364
1365 void
1366 prevline()                      /* move pointers to start of previous line*/
1367 {
1368         curr_line = curr_line->prev_line;
1369         point = curr_line->line;
1370         position = 1;
1371         if (scr_vert == 0)
1372         {
1373                 winsertln(text_win);
1374                 draw_line(0,0,point,1,curr_line->line_length);
1375         }
1376         else
1377                 scr_vert--;
1378         while (position < curr_line->line_length)
1379         {
1380                 position++;
1381                 point++;
1382         }
1383 }
1384
1385 void
1386 left(disp)                              /* move left one character      */
1387 int disp;
1388 {
1389         if (point != curr_line->line)   /* if not at begin of line      */
1390         {
1391                 if ((ee_chinese) && (position >= 2) && (*(point - 2) > 127))
1392                 {
1393                         point--;
1394                         position--;
1395                 }
1396                 point--;
1397                 position--;
1398                 scanline(point);
1399                 wmove(text_win, scr_vert, (scr_horz - horiz_offset));
1400                 scr_pos = scr_horz;
1401         }
1402         else if (curr_line->prev_line != NULL)
1403         {
1404                 if (!disp)
1405                 {
1406                         curr_line = curr_line->prev_line;
1407                         point = curr_line->line + curr_line->line_length;
1408                         position = curr_line->line_length;
1409                         return;
1410                 }
1411                 position = 1;
1412                 prevline();
1413                 scanline(point);
1414                 scr_pos = scr_horz;
1415                 wmove(text_win, scr_vert, (scr_horz - horiz_offset));
1416         }
1417 }
1418
1419 void
1420 right(disp)                             /* move right one character     */
1421 int disp;
1422 {
1423         if (position < curr_line->line_length)
1424         {
1425                 if ((ee_chinese) && (*point > 127) &&
1426                     ((curr_line->line_length - position) >= 2))
1427                 {
1428                         point++;
1429                         position++;
1430                 }
1431                 point++;
1432                 position++;
1433                 scanline(point);
1434                 wmove(text_win, scr_vert, (scr_horz - horiz_offset));
1435                 scr_pos = scr_horz;
1436         }
1437         else if (curr_line->next_line != NULL)
1438         {
1439                 if (!disp)
1440                 {
1441                         curr_line = curr_line->next_line;
1442                         point = curr_line->line;
1443                         position = 1;
1444                         return;
1445                 }
1446                 nextline();
1447                 scr_pos = scr_horz = 0;
1448                 if (horiz_offset)
1449                 {
1450                         horiz_offset = 0;
1451                         midscreen(scr_vert, point);
1452                 }
1453                 wmove(text_win, scr_vert, (scr_horz - horiz_offset));
1454                 position = 1;
1455         }
1456 }
1457
1458 void
1459 find_pos()              /* move to the same column as on other line     */
1460 {
1461         scr_horz = 0;
1462         position = 1;
1463         while ((scr_horz < scr_pos) && (position < curr_line->line_length))
1464         {
1465                 if (*point == 9)
1466                         scr_horz += tabshift(scr_horz);
1467                 else if (*point < ' ')
1468                         scr_horz += 2;
1469                 else if ((ee_chinese) && (*point > 127) &&
1470                     ((curr_line->line_length - position) >= 2))
1471                 {
1472                         scr_horz += 2;
1473                         point++;
1474                         position++;
1475                 }
1476                 else
1477                         scr_horz++;
1478                 position++;
1479                 point++;
1480         }
1481         if ((scr_horz - horiz_offset) > last_col)
1482         {
1483                 horiz_offset = (scr_horz - (scr_horz % 8)) - (COLS - 8);
1484                 midscreen(scr_vert, point);
1485         }
1486         else if (scr_horz < horiz_offset)
1487         {
1488                 horiz_offset = max(0, (scr_horz - (scr_horz % 8)));
1489                 midscreen(scr_vert, point);
1490         }
1491         wmove(text_win, scr_vert, (scr_horz - horiz_offset));
1492 }
1493
1494 void
1495 up()                                    /* move up one line             */
1496 {
1497         if (curr_line->prev_line != NULL)
1498         {
1499                 prevline();
1500                 point = curr_line->line;
1501                 find_pos();
1502         }
1503 }
1504
1505 void
1506 down()                                  /* move down one line           */
1507 {
1508         if (curr_line->next_line != NULL)
1509         {
1510                 nextline();
1511                 find_pos();
1512         }
1513 }
1514
1515 void
1516 function_key()                          /* process function key         */
1517 {
1518         if (in == KEY_LEFT)
1519                 left(TRUE);
1520         else if (in == KEY_RIGHT)
1521                 right(TRUE);
1522         else if (in == KEY_HOME)
1523                 bol();
1524         else if (in == KEY_END)
1525                 eol();
1526         else if ( in == KEY_UP)
1527                 up();
1528         else if (in == KEY_DOWN)
1529                 down();
1530         else if (in == KEY_NPAGE)
1531                 move_rel("d", max( 5, (last_line - 5)));
1532         else if (in == KEY_PPAGE)
1533                 move_rel("u", max(5, (last_line - 5)));
1534         else if (in == KEY_DL)
1535                 del_line();
1536         else if (in == KEY_DC)
1537                 del_char();
1538         else if (in == KEY_BACKSPACE)
1539                 delete(TRUE);
1540         else if (in == KEY_IL)
1541         {               /* insert a line before current line    */
1542                 insert_line(TRUE);
1543                 left(TRUE);
1544         }
1545         else if (in == KEY_F(1))
1546                 gold = !gold;
1547         else if (in == KEY_F(2))
1548         {
1549                 if (gold)
1550                 {
1551                         gold = FALSE;
1552                         undel_line();
1553                 }
1554                 else
1555                         undel_char();
1556         }
1557         else if (in == KEY_F(3))
1558         {
1559                 if (gold)
1560                 {
1561                         gold = FALSE;
1562                         undel_word();
1563                 }
1564                 else
1565                         del_word();
1566         }
1567         else if (in == KEY_F(4))
1568         {
1569                 if (gold)
1570                 {
1571                         gold = FALSE;
1572                         paint_info_win();
1573                         midscreen(scr_vert, point);
1574                 }
1575                 else
1576                         adv_word();
1577         }
1578         else if (in == KEY_F(5))
1579         {
1580                 if (gold)
1581                 {
1582                         gold = FALSE;
1583                         search_prompt();
1584                 }
1585                 else
1586                         search(TRUE);
1587         }
1588         else if (in == KEY_F(6))
1589         {
1590                 if (gold)
1591                 {
1592                         gold = FALSE;
1593                         bottom();
1594                 }
1595                 else
1596                         top();
1597         }
1598         else if (in == KEY_F(7))
1599         {
1600                 if (gold)
1601                 {
1602                         gold = FALSE;
1603                         eol();
1604                 }
1605                 else
1606                         bol();
1607         }
1608         else if (in == KEY_F(8))
1609         {
1610                 if (gold)
1611                 {
1612                         gold = FALSE;
1613                         command_prompt();
1614                 }
1615                 else
1616                         adv_line();
1617         }
1618 }
1619
1620 void
1621 print_buffer()
1622 {
1623         char buffer[256];
1624
1625         sprintf(buffer, ">!%s", print_command);
1626         wmove(com_win, 0, 0);
1627         wclrtoeol(com_win);
1628         wprintw(com_win, printer_msg_str, print_command);
1629         wrefresh(com_win);
1630         command(buffer);
1631 }
1632
1633 void
1634 command_prompt()
1635 {
1636         char *cmd_str;
1637         int result;
1638
1639         info_type = COMMANDS;
1640         paint_info_win();
1641         cmd_str = get_string(command_str, TRUE);
1642         if ((result = unique_test(cmd_str, commands)) != 1)
1643         {
1644                 werase(com_win);
1645                 wmove(com_win, 0, 0);
1646                 if (result == 0)
1647                         wprintw(com_win, unkn_cmd_str, cmd_str);
1648                 else
1649                         wprintw(com_win, non_unique_cmd_msg);
1650
1651                 wrefresh(com_win);
1652
1653                 info_type = CONTROL_KEYS;
1654                 paint_info_win();
1655
1656                 if (cmd_str != NULL)
1657                         free(cmd_str);
1658                 return;
1659         }
1660         command(cmd_str);
1661         wrefresh(com_win);
1662         wmove(text_win, scr_vert, (scr_horz - horiz_offset));
1663         info_type = CONTROL_KEYS;
1664         paint_info_win();
1665         if (cmd_str != NULL)
1666                 free(cmd_str);
1667 }
1668
1669 void
1670 command(cmd_str1)               /* process commands from keyboard       */
1671 char *cmd_str1;
1672 {
1673         char *cmd_str2 = NULL;
1674         char *cmd_str = cmd_str1;
1675
1676         clear_com_win = TRUE;
1677         if (compare(cmd_str, HELP, FALSE))
1678                 help();
1679         else if (compare(cmd_str, WRITE, FALSE))
1680         {
1681                 if (restrict_mode())
1682                 {
1683                         return;
1684                 }
1685                 cmd_str = next_word(cmd_str);
1686                 if (*cmd_str == (char) NULL)
1687                 {
1688                         cmd_str = cmd_str2 = get_string(file_write_prompt_str, TRUE);
1689                 }
1690                 tmp_file = resolve_name(cmd_str);
1691                 write_file(tmp_file);
1692                 if (tmp_file != cmd_str)
1693                         free(tmp_file);
1694         }
1695         else if (compare(cmd_str, READ, FALSE))
1696         {
1697                 if (restrict_mode())
1698                 {
1699                         return;
1700                 }
1701                 cmd_str = next_word(cmd_str);
1702                 if (*cmd_str == (char) NULL)
1703                 {
1704                         cmd_str = cmd_str2 = get_string(file_read_prompt_str, TRUE);
1705                 }
1706                 tmp_file = cmd_str;
1707                 recv_file = TRUE;
1708                 tmp_file = resolve_name(cmd_str);
1709                 check_fp();
1710                 if (tmp_file != cmd_str)
1711                         free(tmp_file);
1712         }
1713         else if (compare(cmd_str, LINE, FALSE))
1714         {
1715                 wmove(com_win, 0, 0);
1716                 wclrtoeol(com_win);
1717                 wprintw(com_win, line_num_str, curr_line->line_number);
1718                 wprintw(com_win, line_len_str, curr_line->line_length);
1719         }
1720         else if (compare(cmd_str, FILE_str, FALSE))
1721         {
1722                 wmove(com_win, 0, 0);
1723                 wclrtoeol(com_win);
1724                 if (in_file_name == NULL)
1725                         wprintw(com_win, no_file_string);
1726                 else
1727                         wprintw(com_win, current_file_str, in_file_name);
1728         }
1729         else if ((*cmd_str >= '0') && (*cmd_str <= '9'))
1730                 goto_line(cmd_str);
1731         else if (compare(cmd_str, CHARACTER, FALSE))
1732         {
1733                 wmove(com_win, 0, 0);
1734                 wclrtoeol(com_win);
1735                 wprintw(com_win, char_str, *point);
1736         }
1737         else if (compare(cmd_str, REDRAW, FALSE))
1738                 redraw();
1739         else if (compare(cmd_str, RESEQUENCE, FALSE))
1740         {
1741                 tmp_line = first_line->next_line;
1742                 while (tmp_line != NULL)
1743                 {
1744                 tmp_line->line_number = tmp_line->prev_line->line_number + 1;
1745                         tmp_line = tmp_line->next_line;
1746                 }
1747         }
1748         else if (compare(cmd_str, AUTHOR, FALSE))
1749         {
1750                 wmove(com_win, 0, 0);
1751                 wclrtoeol(com_win);
1752                 wprintw(com_win, "written by Hugh Mahon");
1753         }
1754         else if (compare(cmd_str, VERSION, FALSE))
1755         {
1756                 wmove(com_win, 0, 0);
1757                 wclrtoeol(com_win);
1758                 wprintw(com_win, "%s", version);
1759         }
1760         else if (compare(cmd_str, CASE, FALSE))
1761                 case_sen = TRUE;
1762         else if (compare(cmd_str, NOCASE, FALSE))
1763                 case_sen = FALSE;
1764         else if (compare(cmd_str, EXPAND, FALSE))
1765                 expand_tabs = TRUE;
1766         else if (compare(cmd_str, NOEXPAND, FALSE))
1767                 expand_tabs = FALSE;
1768         else if (compare(cmd_str, Exit_string, FALSE))
1769                 finish();
1770         else if (compare(cmd_str, chinese_cmd, FALSE))
1771         {
1772                 ee_chinese = TRUE;
1773 #ifdef NCURSE
1774                 nc_setattrib(A_NC_BIG5);
1775 #endif /* NCURSE */
1776         }
1777         else if (compare(cmd_str, nochinese_cmd, FALSE))
1778         {
1779                 ee_chinese = FALSE;
1780 #ifdef NCURSE
1781                 nc_clearattrib(A_NC_BIG5);
1782 #endif /* NCURSE */
1783         }
1784         else if (compare(cmd_str, QUIT_string, FALSE))
1785                 quit(0);
1786         else if (*cmd_str == '!')
1787         {
1788                 cmd_str++;
1789                 if ((*cmd_str == ' ') || (*cmd_str == 9))
1790                         cmd_str = next_word(cmd_str);
1791                 sh_command(cmd_str);
1792         }
1793         else if ((*cmd_str == '<') && (!in_pipe))
1794         {
1795                 in_pipe = TRUE;
1796                 shell_fork = FALSE;
1797                 cmd_str++;
1798                 if ((*cmd_str == ' ') || (*cmd_str == '\t'))
1799                         cmd_str = next_word(cmd_str);
1800                 command(cmd_str);
1801                 in_pipe = FALSE;
1802                 shell_fork = TRUE;
1803         }
1804         else if ((*cmd_str == '>') && (!out_pipe))
1805         {
1806                 out_pipe = TRUE;
1807                 cmd_str++;
1808                 if ((*cmd_str == ' ') || (*cmd_str == '\t'))
1809                         cmd_str = next_word(cmd_str);
1810                 command(cmd_str);
1811                 out_pipe = FALSE;
1812         }
1813         else
1814         {
1815                 wmove(com_win, 0, 0);
1816                 wclrtoeol(com_win);
1817                 wprintw(com_win, unkn_cmd_str, cmd_str);
1818         }
1819         if (cmd_str2 != NULL)
1820                 free(cmd_str2);
1821 }
1822
1823 int
1824 scan(line, offset, column)      /* determine horizontal position for get_string */
1825 char *line;
1826 int offset;
1827 int column;
1828 {
1829         char *stemp;
1830         int i;
1831         int j;
1832
1833         stemp = line;
1834         i = 0;
1835         j = column;
1836         while (i < offset)
1837         {
1838                 i++;
1839                 j += len_char(*stemp, j);
1840                 stemp++;
1841         }
1842         return(j);
1843 }
1844
1845 char *
1846 get_string(prompt, advance)     /* read string from input on command line */
1847 char *prompt;           /* string containing user prompt message        */
1848 int advance;            /* if true, skip leading spaces and tabs        */
1849 {
1850         char *string;
1851         char *tmp_string;
1852         char *nam_str;
1853         char *g_point;
1854         int tmp_int;
1855         int g_horz, g_position, g_pos;
1856         int esc_flag;
1857
1858         g_point = tmp_string = malloc(512);
1859         wmove(com_win,0,0);
1860         wclrtoeol(com_win);
1861         waddstr(com_win, prompt);
1862         wrefresh(com_win);
1863         nam_str = tmp_string;
1864         clear_com_win = TRUE;
1865         g_horz = g_position = scan(prompt, strlen(prompt), 0);
1866         g_pos = 0;
1867         do
1868         {
1869                 esc_flag = FALSE;
1870                 in = wgetch(com_win);
1871                 if (in == -1)
1872                         continue;
1873                 if (((in == 8) || (in == 127) || (in == KEY_BACKSPACE)) && (g_pos > 0))
1874                 {
1875                         tmp_int = g_horz;
1876                         g_pos--;
1877                         g_horz = scan(g_point, g_pos, g_position);
1878                         tmp_int = tmp_int - g_horz;
1879                         for (; 0 < tmp_int; tmp_int--)
1880                         {
1881                                 if ((g_horz+tmp_int) < (last_col - 1))
1882                                 {
1883                                         waddch(com_win, '\010');
1884                                         waddch(com_win, ' ');
1885                                         waddch(com_win, '\010');
1886                                 }
1887                         }
1888                         nam_str--;
1889                 }
1890                 else if ((in != 8) && (in != 127) && (in != '\n') && (in != '\r') && (in < 256))
1891                 {
1892                         if (in == '\026')       /* control-v, accept next character verbatim    */
1893                         {                       /* allows entry of ^m, ^j, and ^h       */
1894                                 esc_flag = TRUE;
1895                                 in = wgetch(com_win);
1896                                 if (in == -1)
1897                                         continue;
1898                         }
1899                         *nam_str = in;
1900                         g_pos++;
1901                         if (((in < ' ') || (in > 126)) && (g_horz < (last_col - 1)))
1902                                 g_horz += out_char(com_win, in, g_horz);
1903                         else
1904                         {
1905                                 g_horz++;
1906                                 if (g_horz < (last_col - 1))
1907                                         waddch(com_win, in);
1908                         }
1909                         nam_str++;
1910                 }
1911                 wrefresh(com_win);
1912                 if (esc_flag)
1913                         in = (char) NULL;
1914         } while ((in != '\n') && (in != '\r'));
1915         *nam_str = (char) NULL;
1916         nam_str = tmp_string;
1917         if (((*nam_str == ' ') || (*nam_str == 9)) && (advance))
1918                 nam_str = next_word(nam_str);
1919         string = malloc(strlen(nam_str) + 1);
1920         strcpy(string, nam_str);
1921         free(tmp_string);
1922         wrefresh(com_win);
1923         return(string);
1924 }
1925
1926 int
1927 compare(string1, string2, sensitive)    /* compare two strings  */
1928 char *string1;
1929 char *string2;
1930 int sensitive;
1931 {
1932         char *strng1;
1933         char *strng2;
1934         int tmp;
1935         int equal;
1936
1937         strng1 = string1;
1938         strng2 = string2;
1939         tmp = 0;
1940         if ((strng1 == NULL) || (strng2 == NULL) || (*strng1 == (char) NULL) || (*strng2 == (char) NULL))
1941                 return(FALSE);
1942         equal = TRUE;
1943         while (equal)
1944         {
1945                 if (sensitive)
1946                 {
1947                         if (*strng1 != *strng2)
1948                                 equal = FALSE;
1949                 }
1950                 else
1951                 {
1952                         if (toupper(*strng1) != toupper(*strng2))
1953                                 equal = FALSE;
1954                 }
1955                 strng1++;
1956                 strng2++;
1957                 if ((*strng1 == (char) NULL) || (*strng2 == (char) NULL) || (*strng1 == ' ') || (*strng2 == ' '))
1958                         break;
1959                 tmp++;
1960         }
1961         return(equal);
1962 }
1963
1964 void
1965 goto_line(cmd_str)
1966 char *cmd_str;
1967 {
1968         int number;
1969         int i;
1970         char *ptr;
1971         char *direction = NULL;
1972         struct text *t_line;
1973
1974         ptr = cmd_str;
1975         i= 0;
1976         while ((*ptr >='0') && (*ptr <= '9'))
1977         {
1978                 i= i * 10 + (*ptr - '0');
1979                 ptr++;
1980         }
1981         number = i;
1982         i = 0;
1983         t_line = curr_line;
1984         while ((t_line->line_number > number) && (t_line->prev_line != NULL))
1985         {
1986                 i++;
1987                 t_line = t_line->prev_line;
1988                 direction = "u";
1989         }
1990         while ((t_line->line_number < number) && (t_line->next_line != NULL))
1991         {
1992                 i++;
1993                 direction = "d";
1994                 t_line = t_line->next_line;
1995         }
1996         if ((i < 30) && (i > 0))
1997         {
1998                 move_rel(direction, i);
1999         }
2000         else
2001         {
2002                 curr_line = t_line;
2003                 point = curr_line->line;
2004                 position = 1;
2005                 midscreen((last_line / 2), point);
2006                 scr_pos = scr_horz;
2007         }
2008         wmove(com_win, 0, 0);
2009         wclrtoeol(com_win);
2010         wprintw(com_win, line_num_str, curr_line->line_number);
2011         wmove(text_win, scr_vert, (scr_horz - horiz_offset));
2012 }
2013
2014 void
2015 midscreen(line, pnt)    /* put current line in middle of screen */
2016 int line;
2017 unsigned char *pnt;
2018 {
2019         struct text *mid_line;
2020         int i;
2021
2022         line = min(line, last_line);
2023         mid_line = curr_line;
2024         for (i = 0; ((i < line) && (curr_line->prev_line != NULL)); i++)
2025                 curr_line = curr_line->prev_line;
2026         scr_vert = scr_horz = 0;
2027         wmove(text_win, 0, 0);
2028         draw_screen();
2029         scr_vert = i;
2030         curr_line = mid_line;
2031         scanline(pnt);
2032         wmove(text_win, scr_vert, (scr_horz - horiz_offset));
2033 }
2034
2035 void
2036 get_options(numargs, arguments) /* get arguments from command line      */
2037 int numargs;
2038 char *arguments[];
2039 {
2040         char *buff;
2041         int count;
2042         struct files *temp_names = NULL;
2043         char *name;
2044         char *ptr;
2045         int no_more_opts = FALSE;
2046
2047         /*
2048          |      see if editor was invoked as 'ree' (restricted mode)
2049          */
2050
2051         if (!(name = strrchr(arguments[0], '/')))
2052                 name = arguments[0];
2053         else
2054                 name++;
2055         if (!strcmp(name, "ree"))
2056                 restricted = TRUE;
2057
2058         top_of_stack = NULL;
2059         input_file = FALSE;
2060         recv_file = FALSE;
2061         count = 1;
2062         while ((count < numargs) && (!no_more_opts))
2063         {
2064                 buff = arguments[count];
2065                 if (!strcmp("-i", buff))
2066                 {
2067                         info_window = FALSE;
2068                 }
2069                 else if (!strcmp("-e", buff))
2070                 {
2071                         expand_tabs = FALSE;
2072                 }
2073                 else if (!strcmp("-h", buff))
2074                 {
2075                         nohighlight = TRUE;
2076                 }
2077                 else if (!strcmp("-?", buff))
2078                 {
2079                         fprintf(stderr, usage0, arguments[0]);
2080                         fprintf(stderr, usage1);
2081                         fprintf(stderr, usage2);
2082                         fprintf(stderr, usage3);
2083                         fprintf(stderr, usage4);
2084                         exit(1);
2085                 }
2086                 else if (*buff == '+')
2087                 {
2088                         buff++;
2089                         start_at_line = buff;
2090                 }
2091                 else if (!(strcmp("--", buff)))
2092                         no_more_opts = TRUE;
2093                 else
2094                 {
2095                         count--;
2096                         no_more_opts = TRUE;
2097                 }
2098                 count++;
2099         }
2100         while (count < numargs)
2101         {
2102                 buff = arguments[count];
2103                 if (top_of_stack == NULL)
2104                 {
2105                         temp_names = top_of_stack = name_alloc();
2106                 }
2107                 else
2108                 {
2109                         temp_names->next_name = name_alloc();
2110                         temp_names = temp_names->next_name;
2111                 }
2112                 ptr = temp_names->name = malloc(strlen(buff) + 1);
2113                 while (*buff != (char) NULL)
2114                 {
2115                         *ptr = *buff;
2116                         buff++;
2117                         ptr++;
2118                 }
2119                 *ptr = (char) NULL;
2120                 temp_names->next_name = NULL;
2121                 input_file = TRUE;
2122                 recv_file = TRUE;
2123                 count++;
2124         }
2125 }
2126
2127 void
2128 check_fp()              /* open or close files according to flags */
2129 {
2130         int line_num;
2131         int temp;
2132         struct stat buf;
2133
2134         clear_com_win = TRUE;
2135         tmp_vert = scr_vert;
2136         tmp_horz = scr_horz;
2137         tmp_line = curr_line;
2138         if (input_file)
2139         {
2140                 in_file_name = tmp_file = top_of_stack->name;
2141                 top_of_stack = top_of_stack->next_name;
2142         }
2143         temp = stat(tmp_file, &buf);
2144         buf.st_mode &= ~07777;
2145         if ((temp != -1) && (buf.st_mode != 0100000) && (buf.st_mode != 0))
2146         {
2147                 wprintw(com_win, file_is_dir_msg, tmp_file);
2148                 wrefresh(com_win);
2149                 if (input_file)
2150                 {
2151                         quit(0);
2152                         return;
2153                 }
2154                 else
2155                         return;
2156         }
2157         if ((get_fd = open(tmp_file, O_RDONLY)) == -1)
2158         {
2159                 wmove(com_win, 0, 0);
2160                 wclrtoeol(com_win);
2161                 if (input_file)
2162                         wprintw(com_win, new_file_msg, tmp_file);
2163                 else
2164                         wprintw(com_win, cant_open_msg, tmp_file);
2165                 wrefresh(com_win);
2166                 wmove(text_win, scr_vert, (scr_horz - horiz_offset));
2167                 wrefresh(text_win);
2168                 recv_file = FALSE;
2169                 input_file = FALSE;
2170                 return;
2171         }
2172         else
2173                 get_file(tmp_file);
2174
2175         recv_file = FALSE;
2176         line_num = curr_line->line_number;
2177         scr_vert = tmp_vert;
2178         scr_horz = tmp_horz;
2179         if (input_file)
2180                 curr_line= first_line;
2181         else
2182                 curr_line = tmp_line;
2183         point = curr_line->line;
2184         draw_screen();
2185         if (input_file)
2186         {
2187                 input_file = FALSE;
2188                 if (start_at_line != NULL)
2189                 {
2190                         line_num = atoi(start_at_line) - 1;
2191                         move_rel("d", line_num);
2192                         line_num = 0;
2193                         start_at_line = NULL;
2194                 }
2195         }
2196         else
2197         {
2198                 wmove(com_win, 0, 0);
2199                 wclrtoeol(com_win);
2200                 text_changes = TRUE;
2201                 if ((tmp_file != NULL) && (*tmp_file != (char) NULL))
2202                         wprintw(com_win, file_read_fin_msg, tmp_file);
2203         }
2204         wrefresh(com_win);
2205         wmove(text_win, scr_vert, (scr_horz - horiz_offset));
2206         wrefresh(text_win);
2207 }
2208
2209 void
2210 get_file(file_name)     /* read specified file into current buffer      */
2211 char *file_name;
2212 {
2213         int can_read;           /* file has at least one character      */
2214         int length;             /* length of line read by read          */
2215         int append;             /* should text be appended to current line */
2216         struct text *temp_line;
2217         char ro_flag = FALSE;
2218
2219         if (recv_file)          /* if reading a file                    */
2220         {
2221                 wmove(com_win, 0, 0);
2222                 wclrtoeol(com_win);
2223                 wprintw(com_win, reading_file_msg, file_name);
2224                 if (access(file_name, 2))       /* check permission to write */
2225                 {
2226                         if ((errno == ENOTDIR) || (errno == EACCES) || (errno == EROFS) || (errno == ETXTBSY) || (errno == EFAULT))
2227                         {
2228                                 wprintw(com_win, read_only_msg);
2229                                 ro_flag = TRUE;
2230                         }
2231                 }
2232                 wrefresh(com_win);
2233         }
2234         if (curr_line->line_length > 1) /* if current line is not blank */
2235         {
2236                 insert_line(FALSE);
2237                 left(FALSE);
2238                 append = FALSE;
2239         }
2240         else
2241                 append = TRUE;
2242         can_read = FALSE;               /* test if file has any characters  */
2243         while (((length = read(get_fd, in_string, 512)) != 0) && (length != -1))
2244         {
2245                 can_read = TRUE;  /* if set file has at least 1 character   */
2246                 get_line(length, in_string, &append);
2247         }
2248         if ((can_read) && (curr_line->line_length == 1))
2249         {
2250                 temp_line = curr_line->prev_line;
2251                 temp_line->next_line = curr_line->next_line;
2252                 if (temp_line->next_line != NULL)
2253                         temp_line->next_line->prev_line = temp_line;
2254                 if (curr_line->line != NULL)
2255                         free(curr_line->line);
2256                 free(curr_line);
2257                 curr_line = temp_line;
2258         }
2259         if (input_file) /* if this is the file to be edited display number of lines     */
2260         {
2261                 wmove(com_win, 0, 0);
2262                 wclrtoeol(com_win);
2263                 wprintw(com_win, file_read_lines_msg, in_file_name, curr_line->line_number);
2264                 if (ro_flag)
2265                         wprintw(com_win, read_only_msg);
2266                 wrefresh(com_win);
2267         }
2268         else if (can_read)      /* not input_file and file is non-zero size */
2269                 text_changes = TRUE;
2270
2271         if (recv_file)          /* if reading a file                    */
2272         {
2273                 in = EOF;
2274         }
2275 }
2276
2277 void
2278 get_line(length, in_string, append)     /* read string and split into lines */
2279 int length;             /* length of string read by read                */
2280 unsigned char *in_string;       /* string read by read                          */
2281 int *append;    /* TRUE if must append more text to end of current line */
2282 {
2283         unsigned char *str1;
2284         unsigned char *str2;
2285         int num;                /* offset from start of string          */
2286         int char_count;         /* length of new line (or added portion */
2287         int temp_counter;       /* temporary counter value              */
2288         struct text *tline;     /* temporary pointer to new line        */
2289         int first_time;         /* if TRUE, the first time through the loop */
2290
2291         str2 = in_string;
2292         num = 0;
2293         first_time = TRUE;
2294         while (num < length)
2295         {
2296                 if (!first_time)
2297                 {
2298                         if (num < length)
2299                         {
2300                                 str2++;
2301                                 num++;
2302                         }
2303                 }
2304                 else
2305                         first_time = FALSE;
2306                 str1 = str2;
2307                 char_count = 1;
2308                 /* find end of line     */
2309                 while ((*str2 != '\n') && (num < length))
2310                 {
2311                         str2++;
2312                         num++;
2313                         char_count++;
2314                 }
2315                 if (!(*append)) /* if not append to current line, insert new one */
2316                 {
2317                         tline = txtalloc();     /* allocate data structure for next line */
2318                         tline->next_line = curr_line->next_line;
2319                         renumber_lines(tline, curr_line->line_number + 1);
2320                         tline->prev_line = curr_line;
2321                         curr_line->next_line = tline;
2322                         if (tline->next_line != NULL)
2323                                 tline->next_line->prev_line = tline;
2324                         curr_line = tline;
2325                         curr_line->line = point = (unsigned char *) malloc(char_count);
2326                         curr_line->line_length = char_count;
2327                         curr_line->max_length = char_count;
2328                 }
2329                 else
2330                 {
2331                         point = resiz_line(char_count, curr_line, curr_line->line_length);
2332                         curr_line->line_length += (char_count - 1);
2333                 }
2334                 for (temp_counter = 1; temp_counter < char_count; temp_counter++)
2335                 {
2336                         *point = *str1;
2337                         point++;
2338                         str1++;
2339                 }
2340                 *point = (char) NULL;
2341                 *append = FALSE;
2342                 if ((num == length) && (*str2 != '\n'))
2343                         *append = TRUE;
2344         }
2345 }
2346
2347 void
2348 draw_screen()           /* redraw the screen from current postion       */
2349 {
2350         struct text *temp_line;
2351         unsigned char *line_out;
2352         int temp_vert;
2353
2354         temp_line = curr_line;
2355         temp_vert = scr_vert;
2356         wclrtobot(text_win);
2357         while ((temp_line != NULL) && (temp_vert <= last_line))
2358         {
2359                 line_out = temp_line->line;
2360                 draw_line(temp_vert, 0, line_out, 1, temp_line->line_length);
2361                 temp_vert++;
2362                 temp_line = temp_line->next_line;
2363         }
2364         wmove(text_win, temp_vert, 0);
2365         wmove(text_win, scr_vert, (scr_horz - horiz_offset));
2366 }
2367
2368 void
2369 finish()        /* prepare to exit edit session */
2370 {
2371         char *file_name = in_file_name;
2372
2373         /*
2374          |      changes made here should be reflected in the 'save'
2375          |      portion of file_op()
2376          */
2377
2378         if ((file_name == NULL) || (*file_name == (char) NULL))
2379                 file_name = get_string(save_file_name_prompt, TRUE);
2380
2381         if ((file_name == NULL) || (*file_name == (char) NULL))
2382         {
2383                 wmove(com_win, 0, 0);
2384                 wprintw(com_win, file_not_saved_msg);
2385                 wclrtoeol(com_win);
2386                 wrefresh(com_win);
2387                 clear_com_win = TRUE;
2388                 return;
2389         }
2390
2391         tmp_file = resolve_name(file_name);
2392         if (tmp_file != file_name)
2393         {
2394                 free(file_name);
2395                 file_name = tmp_file;
2396         }
2397
2398         if (write_file(file_name))
2399         {
2400                 text_changes = FALSE;
2401                 quit(0);
2402         }
2403 }
2404
2405 int
2406 quit(noverify)          /* exit editor                  */
2407 int noverify;
2408 {
2409         char *ans;
2410
2411         touchwin(text_win);
2412         wrefresh(text_win);
2413         if ((text_changes) && (!noverify))
2414         {
2415                 ans = get_string(changes_made_prompt, TRUE);
2416                 if (toupper(*ans) == toupper(*yes_char))
2417                         text_changes = FALSE;
2418                 else
2419                         return(0);
2420                 free(ans);
2421         }
2422         if (top_of_stack == NULL)
2423         {
2424                 if (info_window)
2425                         wrefresh(info_win);
2426                 wrefresh(com_win);
2427                 resetty();
2428                 endwin();
2429                 putchar('\n');
2430                 exit(0);
2431         }
2432         else
2433         {
2434                 delete_text();
2435                 recv_file = TRUE;
2436                 input_file = TRUE;
2437                 check_fp();
2438                 text_changes = FALSE;
2439         }
2440         return(0);
2441 }
2442
2443 void
2444 edit_abort(arg)
2445 int arg;
2446 {
2447         wrefresh(com_win);
2448         resetty();
2449         endwin();
2450         putchar('\n');
2451         exit(1);
2452 }
2453
2454 void
2455 delete_text()
2456 {
2457         while (curr_line->next_line != NULL)
2458                 curr_line = curr_line->next_line;
2459         while (curr_line != first_line)
2460         {
2461                 free(curr_line->line);
2462                 curr_line = curr_line->prev_line;
2463                 free(curr_line->next_line);
2464         }
2465         curr_line->next_line = NULL;
2466         *curr_line->line = (char) NULL;
2467         curr_line->line_length = 1;
2468         curr_line->line_number = 1;
2469         point = curr_line->line;
2470         scr_pos = scr_vert = scr_horz = 0;
2471         position = 1;
2472 }
2473
2474 int
2475 write_file(file_name)
2476 char *file_name;
2477 {
2478         char cr;
2479         char *tmp_point;
2480         struct text *out_line;
2481         int lines, charac;
2482         int temp_pos;
2483         int write_flag = TRUE;
2484
2485         charac = lines = 0;
2486         if ((in_file_name == NULL) || strcmp(in_file_name, file_name))
2487         {
2488                 if ((temp_fp = fopen(file_name, "r")))
2489                 {
2490                         tmp_point = get_string(file_exists_prompt, TRUE);
2491                         if (toupper(*tmp_point) == toupper(*yes_char))
2492                                 write_flag = TRUE;
2493                         else
2494                                 write_flag = FALSE;
2495                         fclose(temp_fp);
2496                         free(tmp_point);
2497                 }
2498         }
2499
2500         clear_com_win = TRUE;
2501
2502         if (write_flag)
2503         {
2504                 if ((temp_fp = fopen(file_name, "w")) == NULL)
2505                 {
2506                         clear_com_win = TRUE;
2507                         wmove(com_win,0,0);
2508                         wclrtoeol(com_win);
2509                         wprintw(com_win, create_file_fail_msg, file_name);
2510                         wrefresh(com_win);
2511                         return(FALSE);
2512                 }
2513                 else
2514                 {
2515                         wmove(com_win,0,0);
2516                         wclrtoeol(com_win);
2517                         wprintw(com_win, writing_file_msg, file_name);
2518                         wrefresh(com_win);
2519                         cr = '\n';
2520                         out_line = first_line;
2521                         while (out_line != NULL)
2522                         {
2523                                 temp_pos = 1;
2524                                 tmp_point= out_line->line;
2525                                 while (temp_pos < out_line->line_length)
2526                                 {
2527                                         putc(*tmp_point, temp_fp);
2528                                         tmp_point++;
2529                                         temp_pos++;
2530                                 }
2531                                 charac += out_line->line_length;
2532                                 out_line = out_line->next_line;
2533                                 putc(cr, temp_fp);
2534                                 lines++;
2535                         }
2536                         fclose(temp_fp);
2537                         wmove(com_win,0,0);
2538                         wclrtoeol(com_win);
2539                         wprintw(com_win, file_written_msg, file_name, lines, charac);
2540                         wrefresh(com_win);
2541                         return(TRUE);
2542                 }
2543         }
2544         else
2545                 return(FALSE);
2546 }
2547
2548 int
2549 search(display_message)         /* search for string in srch_str        */
2550 int display_message;
2551 {
2552         int lines_moved;
2553         int iter;
2554         int found;
2555
2556         if ((srch_str == NULL) || (*srch_str == (char) NULL))
2557                 return(FALSE);
2558         if (display_message)
2559         {
2560                 wmove(com_win, 0, 0);
2561                 wclrtoeol(com_win);
2562                 wprintw(com_win, searching_msg);
2563                 wrefresh(com_win);
2564                 clear_com_win = TRUE;
2565         }
2566         lines_moved = 0;
2567         found = FALSE;
2568         srch_line = curr_line;
2569         srch_1 = point;
2570         if (position < curr_line->line_length)
2571                 srch_1++;
2572         iter = position + 1;
2573         while ((!found) && (srch_line != NULL))
2574         {
2575                 while ((iter < srch_line->line_length) && (!found))
2576                 {
2577                         srch_2 = srch_1;
2578                         if (case_sen)   /* if case sensitive            */
2579                         {
2580                                 srch_3 = srch_str;
2581                         while ((*srch_2 == *srch_3) && (*srch_3 != (char) NULL))
2582                                 {
2583                                         found = TRUE;
2584                                         srch_2++;
2585                                         srch_3++;
2586                                 }       /* end while    */
2587                         }
2588                         else            /* if not case sensitive        */
2589                         {
2590                                 srch_3 = u_srch_str;
2591                         while ((toupper(*srch_2) == *srch_3) && (*srch_3 != (char) NULL))
2592                                 {
2593                                         found = TRUE;
2594                                         srch_2++;
2595                                         srch_3++;
2596                                 }
2597                         }       /* end else     */
2598                         if (!((*srch_3 == (char) NULL) && (found)))
2599                         {
2600                                 found = FALSE;
2601                                 if (iter < srch_line->line_length)
2602                                         srch_1++;
2603                                 iter++;
2604                         }
2605                 }
2606                 if (!found)
2607                 {
2608                         srch_line = srch_line->next_line;
2609                         if (srch_line != NULL)
2610                                 srch_1 = srch_line->line;
2611                         iter = 1;
2612                         lines_moved++;
2613                 }
2614         }
2615         if (found)
2616         {
2617                 if (display_message)
2618                 {
2619                         wmove(com_win, 0, 0);
2620                         wclrtoeol(com_win);
2621                         wrefresh(com_win);
2622                 }
2623                 if (lines_moved == 0)
2624                 {
2625                         while (position < iter)
2626                                 right(TRUE);
2627                 }
2628                 else
2629                 {
2630                         if (lines_moved < 30)
2631                         {
2632                                 move_rel("d", lines_moved);
2633                                 while (position < iter)
2634                                         right(TRUE);
2635                         }
2636                         else
2637                         {
2638                                 curr_line = srch_line;
2639                                 point = srch_1;
2640                                 position = iter;
2641                                 scanline(point);
2642                                 scr_pos = scr_horz;
2643                                 midscreen((last_line / 2), point);
2644                         }
2645                 }
2646         }
2647         else
2648         {
2649                 if (display_message)
2650                 {
2651                         wmove(com_win, 0, 0);
2652                         wclrtoeol(com_win);
2653                         wprintw(com_win, str_not_found_msg, srch_str);
2654                         wrefresh(com_win);
2655                 }
2656                 wmove(text_win, scr_vert,(scr_horz - horiz_offset));
2657         }
2658         return(found);
2659 }
2660
2661 void
2662 search_prompt()         /* prompt and read search string (srch_str)     */
2663 {
2664         if (srch_str != NULL)
2665                 free(srch_str);
2666         if ((u_srch_str != NULL) && (*u_srch_str != (char) NULL))
2667                 free(u_srch_str);
2668         srch_str = get_string(search_prompt_str, FALSE);
2669         gold = FALSE;
2670         srch_3 = srch_str;
2671         srch_1 = u_srch_str = malloc(strlen(srch_str) + 1);
2672         while (*srch_3 != (char) NULL)
2673         {
2674                 *srch_1 = toupper(*srch_3);
2675                 srch_1++;
2676                 srch_3++;
2677         }
2678         *srch_1 = (char) NULL;
2679         search(TRUE);
2680 }
2681
2682 void
2683 del_char()                      /* delete current character     */
2684 {
2685         in = 8;  /* backspace */
2686         if (position < curr_line->line_length)  /* if not end of line   */
2687         {
2688                 if ((ee_chinese) && (*point > 127) &&
2689                     ((curr_line->line_length - position) >= 2))
2690                 {
2691                         point++;
2692                         position++;
2693                 }
2694                 position++;
2695                 point++;
2696                 scanline(point);
2697                 delete(TRUE);
2698         }
2699         else
2700         {
2701                 right(FALSE);
2702                 delete(FALSE);
2703         }
2704 }
2705
2706 void
2707 undel_char()                    /* undelete last deleted character      */
2708 {
2709         if (d_char[0] == '\n')  /* insert line if last del_char deleted eol */
2710                 insert_line(TRUE);
2711         else
2712         {
2713                 in = d_char[0];
2714                 insert(in);
2715                 if (d_char[1] != (unsigned char) NULL)
2716                 {
2717                         in = d_char[1];
2718                         insert(in);
2719                 }
2720         }
2721 }
2722
2723 void
2724 del_word()                      /* delete word in front of cursor       */
2725 {
2726         int tposit;
2727         int difference;
2728         unsigned char *d_word2;
2729         unsigned char *d_word3;
2730         unsigned char tmp_char[3];
2731
2732         if (d_word != NULL)
2733                 free(d_word);
2734         d_word = malloc(curr_line->line_length);
2735         tmp_char[0] = d_char[0];
2736         tmp_char[1] = d_char[1];
2737         tmp_char[2] = d_char[2];
2738         d_word3 = point;
2739         d_word2 = d_word;
2740         tposit = position;
2741         while ((tposit < curr_line->line_length) &&
2742                                 ((*d_word3 != ' ') && (*d_word3 != '\t')))
2743         {
2744                 tposit++;
2745                 *d_word2 = *d_word3;
2746                 d_word2++;
2747                 d_word3++;
2748         }
2749         while ((tposit < curr_line->line_length) &&
2750                                 ((*d_word3 == ' ') || (*d_word3 == '\t')))
2751         {
2752                 tposit++;
2753                 *d_word2 = *d_word3;
2754                 d_word2++;
2755                 d_word3++;
2756         }
2757         *d_word2 = (char) NULL;
2758         d_wrd_len = difference = d_word2 - d_word;
2759         d_word2 = point;
2760         while (tposit < curr_line->line_length)
2761         {
2762                 tposit++;
2763                 *d_word2 = *d_word3;
2764                 d_word2++;
2765                 d_word3++;
2766         }
2767         curr_line->line_length -= difference;
2768         *d_word2 = (char) NULL;
2769         draw_line(scr_vert, scr_horz,point,position,curr_line->line_length);
2770         d_char[0] = tmp_char[0];
2771         d_char[1] = tmp_char[1];
2772         d_char[2] = tmp_char[2];
2773         text_changes = TRUE;
2774         formatted = FALSE;
2775 }
2776
2777 void
2778 undel_word()            /* undelete last deleted word           */
2779 {
2780         int temp;
2781         int tposit;
2782         unsigned char *tmp_old_ptr;
2783         unsigned char *tmp_space;
2784         unsigned char *tmp_ptr;
2785         unsigned char *d_word_ptr;
2786
2787         /*
2788          |      resize line to handle undeleted word
2789          */
2790         if ((curr_line->max_length - (curr_line->line_length + d_wrd_len)) < 5)
2791                 point = resiz_line(d_wrd_len, curr_line, position);
2792         tmp_ptr = tmp_space = malloc(curr_line->line_length + d_wrd_len);
2793         d_word_ptr = d_word;
2794         temp = 1;
2795         /*
2796          |      copy d_word contents into temp space
2797          */
2798         while (temp <= d_wrd_len)
2799         {
2800                 temp++;
2801                 *tmp_ptr = *d_word_ptr;
2802                 tmp_ptr++;
2803                 d_word_ptr++;
2804         }
2805         tmp_old_ptr = point;
2806         tposit = position;
2807         /*
2808          |      copy contents of line from curent position to eol into
2809          |      temp space
2810          */
2811         while (tposit < curr_line->line_length)
2812         {
2813                 temp++;
2814                 tposit++;
2815                 *tmp_ptr = *tmp_old_ptr;
2816                 tmp_ptr++;
2817                 tmp_old_ptr++;
2818         }
2819         curr_line->line_length += d_wrd_len;
2820         tmp_old_ptr = point;
2821         *tmp_ptr = (char) NULL;
2822         tmp_ptr = tmp_space;
2823         tposit = 1;
2824         /*
2825          |      now copy contents from temp space back to original line
2826          */
2827         while (tposit < temp)
2828         {
2829                 tposit++;
2830                 *tmp_old_ptr = *tmp_ptr;
2831                 tmp_ptr++;
2832                 tmp_old_ptr++;
2833         }
2834         *tmp_old_ptr = (char) NULL;
2835         free(tmp_space);
2836         draw_line(scr_vert, scr_horz, point, position, curr_line->line_length);
2837 }
2838
2839 void
2840 del_line()                      /* delete from cursor to end of line    */
2841 {
2842         unsigned char *dl1;
2843         unsigned char *dl2;
2844         int tposit;
2845
2846         if (d_line != NULL)
2847                 free(d_line);
2848         d_line = malloc(curr_line->line_length);
2849         dl1 = d_line;
2850         dl2 = point;
2851         tposit = position;
2852         while (tposit < curr_line->line_length)
2853         {
2854                 *dl1 = *dl2;
2855                 dl1++;
2856                 dl2++;
2857                 tposit++;
2858         }
2859         dlt_line->line_length = 1 + tposit - position;
2860         *dl1 = (char) NULL;
2861         *point = (char) NULL;
2862         curr_line->line_length = position;
2863         wclrtoeol(text_win);
2864         if (curr_line->next_line != NULL)
2865         {
2866                 right(FALSE);
2867                 delete(FALSE);
2868         }
2869         text_changes = TRUE;
2870 }
2871
2872 void
2873 undel_line()                    /* undelete last deleted line           */
2874 {
2875         unsigned char *ud1;
2876         unsigned char *ud2;
2877         int tposit;
2878
2879         if (dlt_line->line_length == 0)
2880                 return;
2881
2882         insert_line(TRUE);
2883         left(TRUE);
2884         point = resiz_line(dlt_line->line_length, curr_line, position);
2885         curr_line->line_length += dlt_line->line_length - 1;
2886         ud1 = point;
2887         ud2 = d_line;
2888         tposit = 1;
2889         while (tposit < dlt_line->line_length)
2890         {
2891                 tposit++;
2892                 *ud1 = *ud2;
2893                 ud1++;
2894                 ud2++;
2895         }
2896         *ud1 = (char) NULL;
2897         draw_line(scr_vert, scr_horz,point,position,curr_line->line_length);
2898 }
2899
2900 void
2901 adv_word()                      /* advance to next word         */
2902 {
2903 while ((position < curr_line->line_length) && ((*point != 32) && (*point != 9)))
2904                 right(TRUE);
2905 while ((position < curr_line->line_length) && ((*point == 32) || (*point == 9)))
2906                 right(TRUE);
2907 }
2908
2909 void
2910 move_rel(direction, lines)      /* move relative to current line        */
2911 char *direction;
2912 int lines;
2913 {
2914         int i;
2915         char *tmp;
2916
2917         if (*direction == 'u')
2918         {
2919                 scr_pos = 0;
2920                 while (position > 1)
2921                         left(TRUE);
2922                 for (i = 0; i < lines; i++)
2923                 {
2924                         up();
2925                 }
2926                 if ((last_line > 5) && ( scr_vert < 4))
2927                 {
2928                         tmp = point;
2929                         tmp_line = curr_line;
2930                         for (i= 0;(i<5)&&(curr_line->prev_line != NULL); i++)
2931                         {
2932                                 up();
2933                         }
2934                         scr_vert = scr_vert + i;
2935                         curr_line = tmp_line;
2936                         point = tmp;
2937                         scanline(point);
2938                 }
2939         }
2940         else
2941         {
2942                 if ((position != 1) && (curr_line->next_line != NULL))
2943                 {
2944                         nextline();
2945                         scr_pos = scr_horz = 0;
2946                         if (horiz_offset)
2947                         {
2948                                 horiz_offset = 0;
2949                                 midscreen(scr_vert, point);
2950                         }
2951                 }
2952                 else
2953                         adv_line();
2954                 for (i = 1; i < lines; i++)
2955                 {
2956                         down();
2957                 }
2958                 if ((last_line > 10) && (scr_vert > (last_line - 5)))
2959                 {
2960                         tmp = point;
2961                         tmp_line = curr_line;
2962                         for (i=0; (i<5) && (curr_line->next_line != NULL); i++)
2963                         {
2964                                 down();
2965                         }
2966                         scr_vert = scr_vert - i;
2967                         curr_line = tmp_line;
2968                         point = tmp;
2969                         scanline(point);
2970                 }
2971         }
2972         wmove(text_win, scr_vert, (scr_horz - horiz_offset));
2973 }
2974
2975 void
2976 eol()                           /* go to end of line                    */
2977 {
2978         if (position < curr_line->line_length)
2979         {
2980                 while (position < curr_line->line_length)
2981                         right(TRUE);
2982         }
2983         else if (curr_line->next_line != NULL)
2984         {
2985                 right(TRUE);
2986                 while (position < curr_line->line_length)
2987                         right(TRUE);
2988         }
2989 }
2990
2991 void
2992 bol()                           /* move to beginning of line    */
2993 {
2994         if (point != curr_line->line)
2995         {
2996                 while (point != curr_line->line)
2997                         left(TRUE);
2998         }
2999         else if (curr_line->prev_line != NULL)
3000         {
3001                 scr_pos = 0;
3002                 up();
3003         }
3004 }
3005
3006 void
3007 adv_line()      /* advance to beginning of next line    */
3008 {
3009         if ((point != curr_line->line) || (scr_pos > 0))
3010         {
3011                 while (position < curr_line->line_length)
3012                         right(TRUE);
3013                 right(TRUE);
3014         }
3015         else if (curr_line->next_line != NULL)
3016         {
3017                 scr_pos = 0;
3018                 down();
3019         }
3020 }
3021
3022 void
3023 sh_command(string)      /* execute shell command                        */
3024 char *string;           /* string containing user command               */
3025 {
3026         char *temp_point;
3027         char *last_slash;
3028         char *path;             /* directory path to executable         */
3029         int parent;             /* zero if child, child's pid if parent */
3030         int value;
3031         int return_val;
3032         struct text *line_holder;
3033
3034         if (restrict_mode())
3035         {
3036                 return;
3037         }
3038
3039         if (!(path = getenv("SHELL")))
3040                 path = "/bin/sh";
3041         last_slash = temp_point = path;
3042         while (*temp_point != (char) NULL)
3043         {
3044                 if (*temp_point == '/')
3045                         last_slash = ++temp_point;
3046                 else
3047                         temp_point++;
3048         }
3049
3050         /*
3051          |      if in_pipe is true, then output of the shell operation will be
3052          |      read by the editor, and curses doesn't need to be turned off
3053          */
3054
3055         if (!in_pipe)
3056         {
3057                 keypad(com_win, FALSE);
3058                 keypad(text_win, FALSE);
3059                 echo();
3060                 nl();
3061                 noraw();
3062                 resetty();
3063
3064 #ifndef NCURSE
3065                 endwin();
3066 #endif
3067         }
3068
3069         if (in_pipe)
3070         {
3071                 pipe(pipe_in);          /* create a pipe        */
3072                 parent = fork();
3073                 if (!parent)            /* if the child         */
3074                 {
3075 /*
3076  |  child process which will fork and exec shell command (if shell output is
3077  |  to be read by editor)
3078  */
3079                         in_pipe = FALSE;
3080 /*
3081  |  redirect stdout to pipe
3082  */
3083                         temp_stdout = dup(1);
3084                         close(1);
3085                         dup(pipe_in[1]);
3086 /*
3087  |  redirect stderr to pipe
3088  */
3089                         temp_stderr = dup(2);
3090                         close(2);
3091                         dup(pipe_in[1]);
3092                         close(pipe_in[1]);
3093                         /*
3094                          |      child will now continue down 'if (!in_pipe)'
3095                          |      path below
3096                          */
3097                 }
3098                 else  /* if the parent  */
3099                 {
3100 /*
3101  |  prepare editor to read from the pipe
3102  */
3103                         signal(SIGCHLD, SIG_IGN);
3104                         line_holder = curr_line;
3105                         tmp_vert = scr_vert;
3106                         close(pipe_in[1]);
3107                         get_fd = pipe_in[0];
3108                         get_file("");
3109                         close(pipe_in[0]);
3110                         scr_vert = tmp_vert;
3111                         scr_horz = scr_pos = 0;
3112                         position = 1;
3113                         curr_line = line_holder;
3114                         point = curr_line->line;
3115                         out_pipe = FALSE;
3116                         signal(SIGCHLD, SIG_DFL);
3117 /*
3118  |  since flag "in_pipe" is still TRUE, the path which waits for the child
3119  |  process to die will be avoided.
3120  |  (the pipe is closed, no more output can be expected)
3121  */
3122                 }
3123         }
3124         if (!in_pipe)
3125         {
3126                 signal(SIGINT, SIG_IGN);
3127                 if (out_pipe)
3128                 {
3129                         pipe(pipe_out);
3130                 }
3131 /*
3132  |  fork process which will exec command
3133  */
3134                 parent = fork();
3135                 if (!parent)            /* if the child */
3136                 {
3137                         if (shell_fork)
3138                                 putchar('\n');
3139                         if (out_pipe)
3140                         {
3141 /*
3142  |  prepare the child process (soon to exec a shell command) to read from the
3143  |  pipe (which will be output from the editor's buffer)
3144  */
3145                                 close(0);
3146                                 dup(pipe_out[0]);
3147                                 close(pipe_out[0]);
3148                                 close(pipe_out[1]);
3149                         }
3150                         for (value = 1; value < 24; value++)
3151                                 signal(value, SIG_DFL);
3152                         execl(path, last_slash, "-c", string, (char *)NULL);
3153                         errx(1, exec_err_msg, path);
3154                 }
3155                 else    /* if the parent        */
3156                 {
3157                         if (out_pipe)
3158                         {
3159 /*
3160  |  output the contents of the buffer to the pipe (to be read by the
3161  |  process forked and exec'd above as stdin)
3162  */
3163                                 close(pipe_out[0]);
3164                                 line_holder = first_line;
3165                                 while (line_holder != NULL)
3166                                 {
3167                                         write(pipe_out[1], line_holder->line, (line_holder->line_length-1));
3168                                         write(pipe_out[1], "\n", 1);
3169                                         line_holder = line_holder->next_line;
3170                                 }
3171                                 close(pipe_out[1]);
3172                                 out_pipe = FALSE;
3173                         }
3174                         do
3175                         {
3176                                 return_val = wait((int *) 0);
3177                         }
3178                         while ((return_val != parent) && (return_val != -1));
3179 /*
3180  |  if this process is actually the child of the editor, exit.  Here's how it
3181  |  works:
3182  |  The editor forks a process.  If output must be sent to the command to be
3183  |  exec'd another process is forked, and that process (the child's child)
3184  |  will exec the command.  In this case, "shell_fork" will be FALSE.  If no
3185  |  output is to be performed to the shell command, "shell_fork" will be TRUE.
3186  |  If this is the editor process, shell_fork will be true, otherwise this is
3187  |  the child of the edit process.
3188  */
3189                         if (!shell_fork)
3190                                 exit(0);
3191                 }
3192                 signal(SIGINT, edit_abort);
3193         }
3194         if (shell_fork)
3195         {
3196                 printf("%s", continue_msg);
3197                 fflush(stdout);
3198                 while ((in = getchar()) != '\n')
3199                         ;
3200         }
3201
3202         if (!in_pipe)
3203         {
3204                 fixterm();
3205                 noecho();
3206                 nonl();
3207                 raw();
3208                 keypad(text_win, TRUE);
3209                 keypad(com_win, TRUE);
3210                 if (info_window)
3211                         clearok(info_win, TRUE);
3212         }
3213
3214         redraw();
3215 }
3216
3217 void
3218 set_up_term()           /* set up the terminal for operating with ae    */
3219 {
3220         if (!curses_initialized)
3221         {
3222                 initscr();
3223                 savetty();
3224                 noecho();
3225                 raw();
3226                 nonl();
3227                 curses_initialized = TRUE;
3228         }
3229
3230         if (((LINES > 15) && (COLS >= 80)) && info_window)
3231                 last_line = LINES - 8;
3232         else
3233         {
3234                 info_window = FALSE;
3235                 last_line = LINES - 2;
3236         }
3237
3238         idlok(stdscr, TRUE);
3239         com_win = newwin(1, COLS, (LINES - 1), 0);
3240         keypad(com_win, TRUE);
3241         idlok(com_win, TRUE);
3242         wrefresh(com_win);
3243         if (!info_window)
3244                 text_win = newwin((LINES - 1), COLS, 0, 0);
3245         else
3246                 text_win = newwin((LINES - 7), COLS, 6, 0);
3247         keypad(text_win, TRUE);
3248         idlok(text_win, TRUE);
3249         wrefresh(text_win);
3250         help_win = newwin((LINES - 1), COLS, 0, 0);
3251         keypad(help_win, TRUE);
3252         idlok(help_win, TRUE);
3253         if (info_window)
3254         {
3255                 info_type = CONTROL_KEYS;
3256                 info_win = newwin(5, COLS, 0, 0);
3257                 werase(info_win);
3258                 paint_info_win();
3259                 count_win = newwin(1, COLS, 5, 0);
3260                 leaveok(count_win, TRUE);
3261                 wrefresh(count_win);
3262         }
3263
3264         last_col = COLS - 1;
3265         local_LINES = LINES;
3266         local_COLS = COLS;
3267
3268 #ifdef NCURSE
3269         if (ee_chinese)
3270                 nc_setattrib(A_NC_BIG5);
3271 #endif /* NCURSE */
3272
3273 }
3274
3275 void
3276 resize_check()
3277 {
3278         if ((LINES == local_LINES) && (COLS == local_COLS))
3279                 return;
3280
3281         if (info_window)
3282                 delwin(info_win);
3283         delwin(text_win);
3284         delwin(com_win);
3285         delwin(help_win);
3286         delwin(count_win);
3287         set_up_term();
3288         redraw();
3289         wrefresh(text_win);
3290 }
3291
3292 static char item_alpha[] = "abcdefghijklmnopqrstuvwxyz0123456789 ";
3293
3294 int
3295 menu_op(menu_list)
3296 struct menu_entries menu_list[];
3297 {
3298         WINDOW *temp_win;
3299         int max_width, max_height;
3300         int x_off, y_off;
3301         int counter;
3302         int length;
3303         int input;
3304         int temp = 0;
3305         int list_size;
3306         int top_offset;         /* offset from top where menu items start */
3307         int vert_pos;           /* vertical position                      */
3308         int vert_size;          /* vertical size for menu list item display */
3309         int off_start = 1;      /* offset from start of menu items to start display */
3310
3311
3312         /*
3313          |      determine number and width of menu items
3314          */
3315
3316         list_size = 1;
3317         while (menu_list[list_size + 1].item_string != NULL)
3318                 list_size++;
3319         max_width = 0;
3320         for (counter = 0; counter <= list_size; counter++)
3321         {
3322                 if ((length = strlen(menu_list[counter].item_string)) > max_width)
3323                         max_width = length;
3324         }
3325         max_width += 3;
3326         max_width = max(max_width, strlen(menu_cancel_msg));
3327         max_width = max(max_width, max(strlen(more_above_str), strlen(more_below_str)));
3328         max_width += 6;
3329
3330         /*
3331          |      make sure that window is large enough to handle menu
3332          |      if not, print error message and return to calling function
3333          */
3334
3335         if (max_width > COLS)
3336         {
3337                 wmove(com_win, 0, 0);
3338                 werase(com_win);
3339                 wprintw(com_win, menu_too_lrg_msg);
3340                 wrefresh(com_win);
3341                 clear_com_win = TRUE;
3342                 return(0);
3343         }
3344
3345         top_offset = 0;
3346
3347         if (list_size > LINES)
3348         {
3349                 max_height = LINES;
3350                 if (max_height > 11)
3351                         vert_size = max_height - 8;
3352                 else
3353                         vert_size = max_height;
3354         }
3355         else
3356         {
3357                 vert_size = list_size;
3358                 max_height = list_size;
3359         }
3360
3361         if (LINES >= (vert_size + 8))
3362         {
3363                 if (menu_list[0].argument != MENU_WARN)
3364                         max_height = vert_size + 8;
3365                 else
3366                         max_height = vert_size + 7;
3367                 top_offset = 4;
3368         }
3369         x_off = (COLS - max_width) / 2;
3370         y_off = (LINES - max_height - 1) / 2;
3371         temp_win = newwin(max_height, max_width, y_off, x_off);
3372         keypad(temp_win, TRUE);
3373
3374         paint_menu(menu_list, max_width, max_height, list_size, top_offset, temp_win, off_start, vert_size);
3375
3376         counter = 1;
3377         vert_pos = 0;
3378         do
3379         {
3380                 if (off_start > 2)
3381                         wmove(temp_win, (1 + counter + top_offset - off_start), 3);
3382                 else
3383                         wmove(temp_win, (counter + top_offset - off_start), 3);
3384
3385                 wrefresh(temp_win);
3386                 input = wgetch(temp_win);
3387
3388                 if (((tolower(input) >= 'a') && (tolower(input) <= 'z')) ||
3389                     ((input >= '0') && (input <= '9')))
3390                 {
3391                         if ((tolower(input) >= 'a') && (tolower(input) <= 'z'))
3392                         {
3393                                 temp = 1 + tolower(input) - 'a';
3394                         }
3395                         else if ((input >= '0') && (input <= '9'))
3396                         {
3397                                 temp = (2 + 'z' - 'a') + (input - '0');
3398                         }
3399
3400                         if (temp <= list_size)
3401                         {
3402                                 input = '\n';
3403                                 counter = temp;
3404                         }
3405                 }
3406                 else
3407                 {
3408                         switch (input)
3409                         {
3410                                 case ' ':       /* space        */
3411                                 case '\004':    /* ^d, down     */
3412                                 case KEY_RIGHT:
3413                                 case KEY_DOWN:
3414                                         counter++;
3415                                         if (counter > list_size)
3416                                                 counter = 1;
3417                                         break;
3418                                 case '\010':    /* ^h, backspace*/
3419                                 case '\025':    /* ^u, up       */
3420                                 case 127:       /* ^?, delete   */
3421                                 case KEY_BACKSPACE:
3422                                 case KEY_LEFT:
3423                                 case KEY_UP:
3424                                         counter--;
3425                                         if (counter == 0)
3426                                                 counter = list_size;
3427                                         break;
3428                                 case '\033':    /* escape key   */
3429                                         if (menu_list[0].argument != MENU_WARN)
3430                                                 counter = 0;
3431                                         break;
3432                                 case '\014':    /* ^l           */
3433                                 case '\022':    /* ^r, redraw   */
3434                                         paint_menu(menu_list, max_width, max_height,
3435                                                 list_size, top_offset, temp_win,
3436                                                 off_start, vert_size);
3437                                         break;
3438                                 default:
3439                                         break;
3440                         }
3441                 }
3442
3443                 if (((list_size - off_start) >= (vert_size - 1)) &&
3444                         (counter > (off_start + vert_size - 3)) &&
3445                                 (off_start > 1))
3446                 {
3447                         if (counter == list_size)
3448                                 off_start = (list_size - vert_size) + 2;
3449                         else
3450                                 off_start++;
3451
3452                         paint_menu(menu_list, max_width, max_height,
3453                                    list_size, top_offset, temp_win, off_start,
3454                                    vert_size);
3455                 }
3456                 else if ((list_size != vert_size) &&
3457                                 (counter > (off_start + vert_size - 2)))
3458                 {
3459                         if (counter == list_size)
3460                                 off_start = 2 + (list_size - vert_size);
3461                         else if (off_start == 1)
3462                                 off_start = 3;
3463                         else
3464                                 off_start++;
3465
3466                         paint_menu(menu_list, max_width, max_height,
3467                                    list_size, top_offset, temp_win, off_start,
3468                                    vert_size);
3469                 }
3470                 else if (counter < off_start)
3471                 {
3472                         if (counter <= 2)
3473                                 off_start = 1;
3474                         else
3475                                 off_start = counter;
3476
3477                         paint_menu(menu_list, max_width, max_height,
3478                                    list_size, top_offset, temp_win, off_start,
3479                                    vert_size);
3480                 }
3481         }
3482         while ((input != '\r') && (input != '\n') && (counter != 0));
3483
3484         werase(temp_win);
3485         wrefresh(temp_win);
3486         delwin(temp_win);
3487
3488         if ((menu_list[counter].procedure != NULL) ||
3489             (menu_list[counter].iprocedure != NULL) ||
3490             (menu_list[counter].nprocedure != NULL))
3491         {
3492                 if (menu_list[counter].argument != -1)
3493                         (*menu_list[counter].iprocedure)(menu_list[counter].argument);
3494                 else if (menu_list[counter].ptr_argument != NULL)
3495                         (*menu_list[counter].procedure)(menu_list[counter].ptr_argument);
3496                 else
3497                         (*menu_list[counter].nprocedure)();
3498         }
3499
3500         if (info_window)
3501                 paint_info_win();
3502         redraw();
3503
3504         return(counter);
3505 }
3506
3507 void
3508 paint_menu(menu_list, max_width, max_height, list_size, top_offset, menu_win,
3509            off_start, vert_size)
3510 struct menu_entries menu_list[];
3511 int max_width, max_height, list_size, top_offset;
3512 WINDOW *menu_win;
3513 int off_start, vert_size;
3514 {
3515         int counter, temp_int;
3516
3517         werase(menu_win);
3518
3519         /*
3520          |      output top and bottom portions of menu box only if window
3521          |      large enough
3522          */
3523
3524         if (max_height > vert_size)
3525         {
3526                 wmove(menu_win, 1, 1);
3527                 if (!nohighlight)
3528                         wstandout(menu_win);
3529                 waddch(menu_win, '+');
3530                 for (counter = 0; counter < (max_width - 4); counter++)
3531                         waddch(menu_win, '-');
3532                 waddch(menu_win, '+');
3533
3534                 wmove(menu_win, (max_height - 2), 1);
3535                 waddch(menu_win, '+');
3536                 for (counter = 0; counter < (max_width - 4); counter++)
3537                         waddch(menu_win, '-');
3538                 waddch(menu_win, '+');
3539                 wstandend(menu_win);
3540                 wmove(menu_win, 2, 3);
3541                 waddstr(menu_win, menu_list[0].item_string);
3542                 wmove(menu_win, (max_height - 3), 3);
3543                 if (menu_list[0].argument != MENU_WARN)
3544                         waddstr(menu_win, menu_cancel_msg);
3545         }
3546         if (!nohighlight)
3547                 wstandout(menu_win);
3548
3549         for (counter = 0; counter < (vert_size + top_offset); counter++)
3550         {
3551                 if (top_offset == 4)
3552                 {
3553                         temp_int = counter + 2;
3554                 }
3555                 else
3556                         temp_int = counter;
3557
3558                 wmove(menu_win, temp_int, 1);
3559                 waddch(menu_win, '|');
3560                 wmove(menu_win, temp_int, (max_width - 2));
3561                 waddch(menu_win, '|');
3562         }
3563         wstandend(menu_win);
3564
3565         if (list_size > vert_size)
3566         {
3567                 if (off_start >= 3)
3568                 {
3569                         temp_int = 1;
3570                         wmove(menu_win, top_offset, 3);
3571                         waddstr(menu_win, more_above_str);
3572                 }
3573                 else
3574                         temp_int = 0;
3575
3576                 for (counter = off_start;
3577                         ((temp_int + counter - off_start) < (vert_size - 1));
3578                                 counter++)
3579                 {
3580                         wmove(menu_win, (top_offset + temp_int +
3581                                                 (counter - off_start)), 3);
3582                         if (list_size > 1)
3583                                 wprintw(menu_win, "%c) ", item_alpha[min((counter - 1), max_alpha_char)]);
3584                         waddstr(menu_win, menu_list[counter].item_string);
3585                 }
3586
3587                 wmove(menu_win, (top_offset + (vert_size - 1)), 3);
3588
3589                 if (counter == list_size)
3590                 {
3591                         if (list_size > 1)
3592                                 wprintw(menu_win, "%c) ", item_alpha[min((counter - 1), max_alpha_char)]);
3593                         wprintw(menu_win, menu_list[counter].item_string);
3594                 }
3595                 else
3596                         wprintw(menu_win, more_below_str);
3597         }
3598         else
3599         {
3600                 for (counter = 1; counter <= list_size; counter++)
3601                 {
3602                         wmove(menu_win, (top_offset + counter - 1), 3);
3603                         if (list_size > 1)
3604                                 wprintw(menu_win, "%c) ", item_alpha[min((counter - 1), max_alpha_char)]);
3605                         waddstr(menu_win, menu_list[counter].item_string);
3606                 }
3607         }
3608 }
3609
3610 void
3611 help()
3612 {
3613         int counter;
3614
3615         werase(help_win);
3616         clearok(help_win, TRUE);
3617         for (counter = 0; counter < 22; counter++)
3618         {
3619                 wmove(help_win, counter, 0);
3620                 waddstr(help_win, (emacs_keys_mode) ?
3621                         emacs_help_text[counter] : help_text[counter]);
3622         }
3623         wrefresh(help_win);
3624         werase(com_win);
3625         wmove(com_win, 0, 0);
3626         wprintw(com_win, press_any_key_msg);
3627         wrefresh(com_win);
3628         counter = wgetch(com_win);
3629         werase(com_win);
3630         wmove(com_win, 0, 0);
3631         werase(help_win);
3632         wrefresh(help_win);
3633         wrefresh(com_win);
3634         redraw();
3635 }
3636
3637 void
3638 paint_info_win()
3639 {
3640         int counter;
3641
3642         if (!info_window)
3643                 return;
3644
3645         werase(info_win);
3646         for (counter = 0; counter < 5; counter++)
3647         {
3648                 wmove(info_win, counter, 0);
3649                 wclrtoeol(info_win);
3650                 if (info_type == CONTROL_KEYS)
3651                         waddstr(info_win, (emacs_keys_mode) ?
3652                           emacs_control_keys[counter] : control_keys[counter]);
3653                 else if (info_type == COMMANDS)
3654                         waddstr(info_win, command_strings[counter]);
3655         }
3656         wrefresh(info_win);
3657 }
3658
3659 void
3660 no_info_window()
3661 {
3662         if (!info_window)
3663                 return;
3664         delwin(info_win);
3665         delwin(text_win);
3666         info_window = FALSE;
3667         last_line = LINES - 2;
3668         text_win = newwin((LINES - 1), COLS, 0, 0);
3669         keypad(text_win, TRUE);
3670         idlok(text_win, TRUE);
3671         clearok(text_win, TRUE);
3672         midscreen(scr_vert, point);
3673         wrefresh(text_win);
3674         clear_com_win = TRUE;
3675 }
3676
3677 void
3678 create_info_window()
3679 {
3680         if (info_window)
3681                 return;
3682         last_line = LINES - 8;
3683         delwin(text_win);
3684         text_win = newwin((LINES - 7), COLS, 6, 0);
3685         keypad(text_win, TRUE);
3686         idlok(text_win, TRUE);
3687         werase(text_win);
3688         info_window = TRUE;
3689         info_win = newwin(5, COLS, 0, 0);
3690         werase(info_win);
3691         info_type = CONTROL_KEYS;
3692         midscreen(min(scr_vert, last_line), point);
3693         clearok(info_win, TRUE);
3694         paint_info_win();
3695         count_win = newwin(1, COLS, 5, 0);
3696         leaveok(count_win, TRUE);
3697         wrefresh(count_win);
3698         wrefresh(text_win);
3699         clear_com_win = TRUE;
3700 }
3701
3702 int
3703 file_op(arg)
3704 int arg;
3705 {
3706         char *string;
3707         int flag;
3708
3709         if (restrict_mode())
3710         {
3711                 return(0);
3712         }
3713
3714         if (arg == READ_FILE)
3715         {
3716                 string = get_string(file_read_prompt_str, TRUE);
3717                 recv_file = TRUE;
3718                 tmp_file = resolve_name(string);
3719                 check_fp();
3720                 if (tmp_file != string)
3721                         free(tmp_file);
3722                 free(string);
3723         }
3724         else if (arg == WRITE_FILE)
3725         {
3726                 string = get_string(file_write_prompt_str, TRUE);
3727                 tmp_file = resolve_name(string);
3728                 write_file(tmp_file);
3729                 if (tmp_file != string)
3730                         free(tmp_file);
3731                 free(string);
3732         }
3733         else if (arg == SAVE_FILE)
3734         {
3735         /*
3736          |      changes made here should be reflected in finish()
3737          */
3738
3739                 if (in_file_name)
3740                         flag = TRUE;
3741                 else
3742                         flag = FALSE;
3743
3744                 string = in_file_name;
3745                 if ((string == NULL) || (*string == (char) NULL))
3746                         string = get_string(save_file_name_prompt, TRUE);
3747                 if ((string == NULL) || (*string == (char) NULL))
3748                 {
3749                         wmove(com_win, 0, 0);
3750                         wprintw(com_win, file_not_saved_msg);
3751                         wclrtoeol(com_win);
3752                         wrefresh(com_win);
3753                         clear_com_win = TRUE;
3754                         return(0);
3755                 }
3756                 if (!flag)
3757                 {
3758                         tmp_file = resolve_name(string);
3759                         if (tmp_file != string)
3760                         {
3761                                 free(string);
3762                                 string = tmp_file;
3763                         }
3764                 }
3765                 if (write_file(string))
3766                 {
3767                         in_file_name = string;
3768                         text_changes = FALSE;
3769                 }
3770                 else if (!flag)
3771                         free(string);
3772         }
3773         return(0);
3774 }
3775
3776 void
3777 shell_op()
3778 {
3779         char *string;
3780
3781         if (((string = get_string(shell_prompt, TRUE)) != NULL) &&
3782                         (*string != (char) NULL))
3783         {
3784                 sh_command(string);
3785                 free(string);
3786         }
3787 }
3788
3789 void
3790 leave_op()
3791 {
3792         if (text_changes)
3793         {
3794                 menu_op(leave_menu);
3795         }
3796         else
3797                 quit(TRUE);
3798 }
3799
3800 void
3801 redraw()
3802 {
3803         if (info_window)
3804         {
3805                 clearok(info_win, TRUE);
3806                 paint_info_win();
3807         }
3808         else
3809                 clearok(text_win, TRUE);
3810         midscreen(scr_vert, point);
3811 }
3812
3813 /*
3814  |      The following routines will "format" a paragraph (as defined by a
3815  |      block of text with blank lines before and after the block).
3816  */
3817
3818 int
3819 Blank_Line(test_line)   /* test if line has any non-space characters    */
3820 struct text *test_line;
3821 {
3822         unsigned char *line;
3823         int length;
3824
3825         if (test_line == NULL)
3826                 return(TRUE);
3827
3828         length = 1;
3829         line = test_line->line;
3830
3831         /*
3832          |      To handle troff/nroff documents, consider a line with a
3833          |      period ('.') in the first column to be blank.  To handle mail
3834          |      messages with included text, consider a line with a '>' blank.
3835          */
3836
3837         if ((*line == '.') || (*line == '>'))
3838                 return(TRUE);
3839
3840         while (((*line == ' ') || (*line == '\t')) && (length < test_line->line_length))
3841         {
3842                 length++;
3843                 line++;
3844         }
3845         if (length != test_line->line_length)
3846                 return(FALSE);
3847         else
3848                 return(TRUE);
3849 }
3850
3851 void
3852 Format()        /* format the paragraph according to set margins        */
3853 {
3854         int string_count;
3855         int offset;
3856         int temp_case;
3857         int status;
3858         int tmp_af;
3859         int counter;
3860         unsigned char *line;
3861         unsigned char *tmp_srchstr;
3862         unsigned char *temp1, *temp2;
3863         unsigned char *temp_dword;
3864         unsigned char temp_d_char[3];
3865
3866         temp_d_char[0] = d_char[0];
3867         temp_d_char[1] = d_char[1];
3868         temp_d_char[2] = d_char[2];
3869
3870 /*
3871  |      if observ_margins is not set, or the current line is blank,
3872  |      do not format the current paragraph
3873  */
3874
3875         if ((!observ_margins) || (Blank_Line(curr_line)))
3876                 return;
3877
3878 /*
3879  |      save the currently set flags, and clear them
3880  */
3881
3882         wmove(com_win, 0, 0);
3883         wclrtoeol(com_win);
3884         wprintw(com_win, formatting_msg);
3885         wrefresh(com_win);
3886
3887 /*
3888  |      get current position in paragraph, so after formatting, the cursor
3889  |      will be in the same relative position
3890  */
3891
3892         tmp_af = auto_format;
3893         auto_format = FALSE;
3894         offset = position;
3895         if (position != 1)
3896                 prev_word();
3897         temp_dword = d_word;
3898         d_word = NULL;
3899         temp_case = case_sen;
3900         case_sen = TRUE;
3901         tmp_srchstr = srch_str;
3902         temp2 = srch_str = (unsigned char *) malloc(1 + curr_line->line_length - position);
3903         if ((*point == ' ') || (*point == '\t'))
3904                 adv_word();
3905         offset -= position;
3906         counter = position;
3907         line = temp1 = point;
3908         while ((*temp1 != (char) NULL) && (*temp1 != ' ') && (*temp1 != '\t') && (counter < curr_line->line_length))
3909         {
3910                 *temp2 = *temp1;
3911                 temp2++;
3912                 temp1++;
3913                 counter++;
3914         }
3915         *temp2 = (char) NULL;
3916         if (position != 1)
3917                 bol();
3918         while (!Blank_Line(curr_line->prev_line))
3919                 bol();
3920         string_count = 0;
3921         status = TRUE;
3922         while ((line != point) && (status))
3923         {
3924                 status = search(FALSE);
3925                 string_count++;
3926         }
3927
3928         wmove(com_win, 0, 0);
3929         wclrtoeol(com_win);
3930         wprintw(com_win, formatting_msg);
3931         wrefresh(com_win);
3932
3933 /*
3934  |      now get back to the start of the paragraph to start formatting
3935  */
3936
3937         if (position != 1)
3938                 bol();
3939         while (!Blank_Line(curr_line->prev_line))
3940                 bol();
3941
3942         observ_margins = FALSE;
3943
3944 /*
3945  |      Start going through lines, putting spaces at end of lines if they do
3946  |      not already exist.  Append lines together to get one long line, and
3947  |      eliminate spacing at begin of lines.
3948  */
3949
3950         while (!Blank_Line(curr_line->next_line))
3951         {
3952                 eol();
3953                 left(TRUE);
3954                 if (*point != ' ')
3955                 {
3956                         right(TRUE);
3957                         insert(' ');
3958                 }
3959                 else
3960                         right(TRUE);
3961                 del_char();
3962                 if ((*point == ' ') || (*point == '\t'))
3963                         del_word();
3964         }
3965
3966 /*
3967  |      Now there is one long line.  Eliminate extra spaces within the line
3968  |      after the first word (so as not to blow away any indenting the user
3969  |      may have put in).
3970  */
3971
3972         bol();
3973         adv_word();
3974         while (position < curr_line->line_length)
3975         {
3976                 if ((*point == ' ') && (*(point + 1) == ' '))
3977                         del_char();
3978                 else
3979                         right(TRUE);
3980         }
3981
3982 /*
3983  |      Now make sure there are two spaces after a '.'.
3984  */
3985
3986         bol();
3987         while (position < curr_line->line_length)
3988         {
3989                 if ((*point == '.') && (*(point + 1) == ' '))
3990                 {
3991                         right(TRUE);
3992                         insert(' ');
3993                         insert(' ');
3994                         while (*point == ' ')
3995                                 del_char();
3996                 }
3997                 right(TRUE);
3998         }
3999
4000         observ_margins = TRUE;
4001         bol();
4002
4003         wmove(com_win, 0, 0);
4004         wclrtoeol(com_win);
4005         wprintw(com_win, formatting_msg);
4006         wrefresh(com_win);
4007
4008 /*
4009  |      create lines between margins
4010  */
4011
4012         while (position < curr_line->line_length)
4013         {
4014                 while ((scr_pos < right_margin) && (position < curr_line->line_length))
4015                         right(TRUE);
4016                 if (position < curr_line->line_length)
4017                 {
4018                         prev_word();
4019                         if (position == 1)
4020                                 adv_word();
4021                         insert_line(TRUE);
4022                 }
4023         }
4024
4025 /*
4026  |      go back to begin of paragraph, put cursor back to original position
4027  */
4028
4029         bol();
4030         while (!Blank_Line(curr_line->prev_line))
4031                 bol();
4032
4033 /*
4034  |      find word cursor was in
4035  */
4036
4037         while ((status) && (string_count > 0))
4038         {
4039                 search(FALSE);
4040                 string_count--;
4041         }
4042
4043 /*
4044  |      offset the cursor to where it was before from the start of the word
4045  */
4046
4047         while (offset > 0)
4048         {
4049                 offset--;
4050                 right(TRUE);
4051         }
4052
4053 /*
4054  |      reset flags and strings to what they were before formatting
4055  */
4056
4057         if (d_word != NULL)
4058                 free(d_word);
4059         d_word = temp_dword;
4060         case_sen = temp_case;
4061         free(srch_str);
4062         srch_str = tmp_srchstr;
4063         d_char[0] = temp_d_char[0];
4064         d_char[1] = temp_d_char[1];
4065         d_char[2] = temp_d_char[2];
4066         auto_format = tmp_af;
4067
4068         midscreen(scr_vert, point);
4069         werase(com_win);
4070         wrefresh(com_win);
4071 }
4072
4073 unsigned char *init_name[3] = {
4074         "/usr/share/misc/init.ee",
4075         NULL,
4076         ".init.ee"
4077         };
4078
4079 void
4080 ee_init()       /* check for init file and read it if it exists */
4081 {
4082         FILE *init_file;
4083         unsigned char *string;
4084         unsigned char *str1;
4085         unsigned char *str2;
4086         char *home;
4087         int counter;
4088         int temp_int;
4089
4090         string = getenv("HOME");
4091         if (!string)
4092             string = "/root"; /* Set to reasonable default so we don't crash */
4093         str1 = home = malloc(strlen(string)+10);
4094         strcpy(home, string);
4095         strcat(home, "/.init.ee");
4096         init_name[1] = home;
4097         string = malloc(512);
4098
4099         for (counter = 0; counter < 3; counter++)
4100         {
4101                 if (!(access(init_name[counter], 4)))
4102                 {
4103                         init_file = fopen(init_name[counter], "r");
4104                         while ((str2 = fgets(string, 512, init_file)) != NULL)
4105                         {
4106                                 str1 = str2 = string;
4107                                 while (*str2 != '\n')
4108                                         str2++;
4109                                 *str2 = (char) NULL;
4110
4111                                 if (unique_test(string, init_strings) != 1)
4112                                         continue;
4113
4114                                 if (compare(str1, CASE, FALSE))
4115                                         case_sen = TRUE;
4116                                 else if (compare(str1, NOCASE, FALSE))
4117                                         case_sen = FALSE;
4118                                 else if (compare(str1, EXPAND, FALSE))
4119                                         expand_tabs = TRUE;
4120                                 else if (compare(str1, NOEXPAND, FALSE))
4121                                         expand_tabs = FALSE;
4122                                 else if (compare(str1, INFO, FALSE))
4123                                         info_window = TRUE;
4124                                 else if (compare(str1, NOINFO, FALSE))
4125                                         info_window = FALSE;
4126                                 else if (compare(str1, MARGINS, FALSE))
4127                                         observ_margins = TRUE;
4128                                 else if (compare(str1, NOMARGINS, FALSE))
4129                                         observ_margins = FALSE;
4130                                 else if (compare(str1, AUTOFORMAT, FALSE))
4131                                 {
4132                                         auto_format = TRUE;
4133                                         observ_margins = TRUE;
4134                                 }
4135                                 else if (compare(str1, NOAUTOFORMAT, FALSE))
4136                                         auto_format = FALSE;
4137                                 else if (compare(str1, Echo, FALSE))
4138                                 {
4139                                         str1 = next_word(str1);
4140                                         if (*str1 != (char) NULL)
4141                                                 echo_string(str1);
4142                                 }
4143                                 else if (compare(str1, PRINTCOMMAND, FALSE))
4144                                 {
4145                                         str1 = next_word(str1);
4146                                         print_command = malloc(strlen(str1)+1);
4147                                         strcpy(print_command, str1);
4148                                 }
4149                                 else if (compare(str1, RIGHTMARGIN, FALSE))
4150                                 {
4151                                         str1 = next_word(str1);
4152                                         if ((*str1 >= '0') && (*str1 <= '9'))
4153                                         {
4154                                                 temp_int = atoi(str1);
4155                                                 if (temp_int > 0)
4156                                                         right_margin = temp_int;
4157                                         }
4158                                 }
4159                                 else if (compare(str1, HIGHLIGHT, FALSE))
4160                                         nohighlight = FALSE;
4161                                 else if (compare(str1, NOHIGHLIGHT, FALSE))
4162                                         nohighlight = TRUE;
4163                                 else if (compare(str1, EIGHTBIT, FALSE))
4164                                         eightbit = TRUE;
4165                                 else if (compare(str1, NOEIGHTBIT, FALSE))
4166                                 {
4167                                         eightbit = FALSE;
4168                                         ee_chinese = FALSE;
4169                                 }
4170                                 else if (compare(str1, EMACS_string, FALSE))
4171                                         emacs_keys_mode = TRUE;
4172                                 else if (compare(str1, NOEMACS_string, FALSE))
4173                                         emacs_keys_mode = FALSE;
4174                                 else if (compare(str1, chinese_cmd, FALSE))
4175                                 {
4176                                         ee_chinese = TRUE;
4177                                         eightbit = TRUE;
4178                                 }
4179                                 else if (compare(str1, nochinese_cmd, FALSE))
4180                                         ee_chinese = FALSE;
4181                         }
4182                         fclose(init_file);
4183                 }
4184         }
4185         free(string);
4186         free(home);
4187
4188         string = getenv("LANG");
4189         if (string != NULL)
4190         {
4191                 if (strcmp(string, "zh_TW.big5") == 0)
4192                 {
4193                         ee_chinese = TRUE;
4194                         eightbit = TRUE;
4195                 }
4196         }
4197 }
4198
4199 /*
4200  |      Save current configuration to .init.ee file in the current directory.
4201  */
4202
4203 void
4204 dump_ee_conf()
4205 {
4206         FILE *init_file;
4207         FILE *old_init_file = NULL;
4208         char *file_name = ".init.ee";
4209         char *home_dir =  "~/.init.ee";
4210         char buffer[512];
4211         struct stat buf;
4212         char *string;
4213         int length;
4214         int option = 0;
4215
4216         if (restrict_mode())
4217         {
4218                 return;
4219         }
4220
4221         option = menu_op(config_dump_menu);
4222
4223         werase(com_win);
4224         wmove(com_win, 0, 0);
4225
4226         if (option == 0)
4227         {
4228                 wprintw(com_win, conf_not_saved_msg);
4229                 wrefresh(com_win);
4230                 return;
4231         }
4232         else if (option == 2)
4233                 file_name = resolve_name(home_dir);
4234
4235         /*
4236          |      If a .init.ee file exists, move it to .init.ee.old.
4237          */
4238
4239         if (stat(file_name, &buf) != -1)
4240         {
4241                 sprintf(buffer, "%s.old", file_name);
4242                 unlink(buffer);
4243                 link(file_name, buffer);
4244                 unlink(file_name);
4245                 old_init_file = fopen(buffer, "r");
4246         }
4247
4248         init_file = fopen(file_name, "w");
4249         if (init_file == NULL)
4250         {
4251                 wprintw(com_win, conf_dump_err_msg);
4252                 wrefresh(com_win);
4253                 return;
4254         }
4255
4256         if (old_init_file != NULL)
4257         {
4258                 /*
4259                  |      Copy non-configuration info into new .init.ee file.
4260                  */
4261                 while ((string = fgets(buffer, 512, old_init_file)) != NULL)
4262                 {
4263                         length = strlen(string);
4264                         string[length - 1] = (char) NULL;
4265
4266                         if (unique_test(string, init_strings) == 1)
4267                         {
4268                                 if (compare(string, Echo, FALSE))
4269                                 {
4270                                         fprintf(init_file, "%s\n", string);
4271                                 }
4272                         }
4273                         else
4274                                 fprintf(init_file, "%s\n", string);
4275                 }
4276
4277                 fclose(old_init_file);
4278         }
4279
4280         fprintf(init_file, "%s\n", case_sen ? CASE : NOCASE);
4281         fprintf(init_file, "%s\n", expand_tabs ? EXPAND : NOEXPAND);
4282         fprintf(init_file, "%s\n", info_window ? INFO : NOINFO );
4283         fprintf(init_file, "%s\n", observ_margins ? MARGINS : NOMARGINS );
4284         fprintf(init_file, "%s\n", auto_format ? AUTOFORMAT : NOAUTOFORMAT );
4285         fprintf(init_file, "%s %s\n", PRINTCOMMAND, print_command);
4286         fprintf(init_file, "%s %d\n", RIGHTMARGIN, right_margin);
4287         fprintf(init_file, "%s\n", nohighlight ? NOHIGHLIGHT : HIGHLIGHT );
4288         fprintf(init_file, "%s\n", eightbit ? EIGHTBIT : NOEIGHTBIT );
4289         fprintf(init_file, "%s\n", emacs_keys_mode ? EMACS_string : NOEMACS_string );
4290         fprintf(init_file, "%s\n", ee_chinese ? chinese_cmd : nochinese_cmd );
4291
4292         fclose(init_file);
4293
4294         wprintw(com_win, conf_dump_success_msg, file_name);
4295         wrefresh(com_win);
4296
4297         if ((option == 2) && (file_name != home_dir))
4298         {
4299                 free(file_name);
4300         }
4301 }
4302
4303 void
4304 echo_string(string)     /* echo the given string        */
4305 char *string;
4306 {
4307         char *temp;
4308         int Counter;
4309
4310                 temp = string;
4311                 while (*temp != (char) NULL)
4312                 {
4313                         if (*temp == '\\')
4314                         {
4315                                 temp++;
4316                                 if (*temp == 'n')
4317                                         putchar('\n');
4318                                 else if (*temp == 't')
4319                                         putchar('\t');
4320                                 else if (*temp == 'b')
4321                                         putchar('\b');
4322                                 else if (*temp == 'r')
4323                                         putchar('\r');
4324                                 else if (*temp == 'f')
4325                                         putchar('\f');
4326                                 else if ((*temp == 'e') || (*temp == 'E'))
4327                                         putchar('\033');        /* escape */
4328                                 else if (*temp == '\\')
4329                                         putchar('\\');
4330                                 else if (*temp == '\'')
4331                                         putchar('\'');
4332                                 else if ((*temp >= '0') && (*temp <= '9'))
4333                                 {
4334                                         Counter = 0;
4335                                         while ((*temp >= '0') && (*temp <= '9'))
4336                                         {
4337                                                 Counter = (8 * Counter) + (*temp - '0');
4338                                                 temp++;
4339                                         }
4340                                         putchar(Counter);
4341                                         temp--;
4342                                 }
4343                                 temp++;
4344                         }
4345                         else
4346                         {
4347                                 putchar(*temp);
4348                                 temp++;
4349                         }
4350                 }
4351
4352         fflush(stdout);
4353 }
4354
4355 void
4356 spell_op()      /* check spelling of words in the editor        */
4357 {
4358         if (restrict_mode())
4359         {
4360                 return;
4361         }
4362         top();                  /* go to top of file            */
4363         insert_line(FALSE);     /* create two blank lines       */
4364         insert_line(FALSE);
4365         top();
4366         command(shell_echo_msg);
4367         adv_line();
4368         wmove(com_win, 0, 0);
4369         wprintw(com_win, spell_in_prog_msg);
4370         wrefresh(com_win);
4371         command("<>!spell");    /* send contents of buffer to command 'spell'
4372                                    and read the results back into the editor */
4373 }
4374
4375 void
4376 ispell_op()
4377 {
4378         char name[128];
4379         char string[256];
4380         int pid;
4381
4382         if (restrict_mode())
4383         {
4384                 return;
4385         }
4386         pid = getpid();
4387         sprintf(name, "/tmp/ee.%d", pid);
4388         if (write_file(name))
4389         {
4390                 sprintf(string, "ispell %s", name);
4391                 sh_command(string);
4392                 delete_text();
4393                 tmp_file = name;
4394                 recv_file = TRUE;
4395                 check_fp();
4396                 unlink(name);
4397         }
4398 }
4399
4400 int
4401 first_word_len(test_line)
4402 struct text *test_line;
4403 {
4404         int counter;
4405         unsigned char *pnt;
4406
4407         if (test_line == NULL)
4408                 return(0);
4409
4410         pnt = test_line->line;
4411         if ((pnt == NULL) || (*pnt == (char) NULL) ||
4412             (*pnt == '.') || (*pnt == '>'))
4413                 return(0);
4414
4415         if ((*pnt == ' ') || (*pnt == '\t'))
4416         {
4417                 pnt = next_word(pnt);
4418         }
4419
4420         if (*pnt == (char) NULL)
4421                 return(0);
4422
4423         counter = 0;
4424         while ((*pnt != (char) NULL) && ((*pnt != ' ') && (*pnt != '\t')))
4425         {
4426                 pnt++;
4427                 counter++;
4428         }
4429         while ((*pnt != (char) NULL) && ((*pnt == ' ') || (*pnt == '\t')))
4430         {
4431                 pnt++;
4432                 counter++;
4433         }
4434         return(counter);
4435 }
4436
4437 void
4438 Auto_Format()   /* format the paragraph according to set margins        */
4439 {
4440         int string_count;
4441         int offset;
4442         int temp_case;
4443         int word_len;
4444         int temp_dwl;
4445         int tmp_d_line_length;
4446         int leave_loop = FALSE;
4447         int status;
4448         int counter;
4449         char not_blank;
4450         unsigned char *line;
4451         unsigned char *tmp_srchstr;
4452         unsigned char *temp1, *temp2;
4453         unsigned char *temp_dword;
4454         unsigned char temp_d_char[3];
4455         unsigned char *tmp_d_line;
4456
4457
4458         temp_d_char[0] = d_char[0];
4459         temp_d_char[1] = d_char[1];
4460         temp_d_char[2] = d_char[2];
4461
4462 /*
4463  |      if observ_margins is not set, or the current line is blank,
4464  |      do not format the current paragraph
4465  */
4466
4467         if ((!observ_margins) || (Blank_Line(curr_line)))
4468                 return;
4469
4470 /*
4471  |      get current position in paragraph, so after formatting, the cursor
4472  |      will be in the same relative position
4473  */
4474
4475         tmp_d_line = d_line;
4476         tmp_d_line_length = dlt_line->line_length;
4477         d_line = NULL;
4478         auto_format = FALSE;
4479         offset = position;
4480         if ((position != 1) && ((*point == ' ') || (*point == '\t') || (position == curr_line->line_length) || (*point == (char) NULL)))
4481                 prev_word();
4482         temp_dword = d_word;
4483         temp_dwl = d_wrd_len;
4484         d_wrd_len = 0;
4485         d_word = NULL;
4486         temp_case = case_sen;
4487         case_sen = TRUE;
4488         tmp_srchstr = srch_str;
4489         temp2 = srch_str = (unsigned char *) malloc(1 + curr_line->line_length - position);
4490         if ((*point == ' ') || (*point == '\t'))
4491                 adv_word();
4492         offset -= position;
4493         counter = position;
4494         line = temp1 = point;
4495         while ((*temp1 != (char) NULL) && (*temp1 != ' ') && (*temp1 != '\t') && (counter < curr_line->line_length))
4496         {
4497                 *temp2 = *temp1;
4498                 temp2++;
4499                 temp1++;
4500                 counter++;
4501         }
4502         *temp2 = (char) NULL;
4503         if (position != 1)
4504                 bol();
4505         while (!Blank_Line(curr_line->prev_line))
4506                 bol();
4507         string_count = 0;
4508         status = TRUE;
4509         while ((line != point) && (status))
4510         {
4511                 status = search(FALSE);
4512                 string_count++;
4513         }
4514
4515 /*
4516  |      now get back to the start of the paragraph to start checking
4517  */
4518
4519         if (position != 1)
4520                 bol();
4521         while (!Blank_Line(curr_line->prev_line))
4522                 bol();
4523
4524 /*
4525  |      Start going through lines, putting spaces at end of lines if they do
4526  |      not already exist.  Check line length, and move words to the next line
4527  |      if they cross the margin.  Then get words from the next line if they
4528  |      will fit in before the margin.
4529  */
4530
4531         counter = 0;
4532
4533         while (!leave_loop)
4534         {
4535                 if (position != curr_line->line_length)
4536                         eol();
4537                 left(TRUE);
4538                 if (*point != ' ')
4539                 {
4540                         right(TRUE);
4541                         insert(' ');
4542                 }
4543                 else
4544                         right(TRUE);
4545
4546                 not_blank = FALSE;
4547
4548                 /*
4549                  |      fill line if first word on next line will fit
4550                  |      in the line without crossing the margin
4551                  */
4552
4553                 while ((curr_line->next_line != NULL) &&
4554                        ((word_len = first_word_len(curr_line->next_line)) > 0)
4555                         && ((scr_pos + word_len) < right_margin))
4556                 {
4557                         adv_line();
4558                         if ((*point == ' ') || (*point == '\t'))
4559                                 adv_word();
4560                         del_word();
4561                         if (position != 1)
4562                                 bol();
4563
4564                         /*
4565                          |      We know this line was not blank before, so
4566                          |      make sure that it doesn't have one of the
4567                          |      leading characters that indicate the line
4568                          |      should not be modified.
4569                          |
4570                          |      We also know that this character should not
4571                          |      be left as the first character of this line.
4572                          */
4573
4574                         if ((Blank_Line(curr_line)) &&
4575                             (curr_line->line[0] != '.') &&
4576                             (curr_line->line[0] != '>'))
4577                         {
4578                                 del_line();
4579                                 not_blank = FALSE;
4580                         }
4581                         else
4582                                 not_blank = TRUE;
4583
4584                         /*
4585                          |   go to end of previous line
4586                          */
4587                         left(TRUE);
4588                         undel_word();
4589                         eol();
4590                         /*
4591                          |   make sure there's a space at the end of the line
4592                          */
4593                         left(TRUE);
4594                         if (*point != ' ')
4595                         {
4596                                 right(TRUE);
4597                                 insert(' ');
4598                         }
4599                         else
4600                                 right(TRUE);
4601                 }
4602
4603                 /*
4604                  |      make sure line does not cross right margin
4605                  */
4606
4607                 while (right_margin <= scr_pos)
4608                 {
4609                         prev_word();
4610                         if (position != 1)
4611                         {
4612                                 del_word();
4613                                 if (Blank_Line(curr_line->next_line))
4614                                         insert_line(TRUE);
4615                                 else
4616                                         adv_line();
4617                                 if ((*point == ' ') || (*point == '\t'))
4618                                         adv_word();
4619                                 undel_word();
4620                                 not_blank = TRUE;
4621                                 if (position != 1)
4622                                         bol();
4623                                 left(TRUE);
4624                         }
4625                 }
4626
4627                 if ((!Blank_Line(curr_line->next_line)) || (not_blank))
4628                 {
4629                         adv_line();
4630                         counter++;
4631                 }
4632                 else
4633                         leave_loop = TRUE;
4634         }
4635
4636 /*
4637  |      go back to begin of paragraph, put cursor back to original position
4638  */
4639
4640         if (position != 1)
4641                 bol();
4642         while ((counter-- > 0) || (!Blank_Line(curr_line->prev_line)))
4643                 bol();
4644
4645 /*
4646  |      find word cursor was in
4647  */
4648
4649         status = TRUE;
4650         while ((status) && (string_count > 0))
4651         {
4652                 status = search(FALSE);
4653                 string_count--;
4654         }
4655
4656 /*
4657  |      offset the cursor to where it was before from the start of the word
4658  */
4659
4660         while (offset > 0)
4661         {
4662                 offset--;
4663                 right(TRUE);
4664         }
4665
4666         if ((string_count > 0) && (offset < 0))
4667         {
4668                 while (offset < 0)
4669                 {
4670                         offset++;
4671                         left(TRUE);
4672                 }
4673         }
4674
4675 /*
4676  |      reset flags and strings to what they were before formatting
4677  */
4678
4679         if (d_word != NULL)
4680                 free(d_word);
4681         d_word = temp_dword;
4682         d_wrd_len = temp_dwl;
4683         case_sen = temp_case;
4684         free(srch_str);
4685         srch_str = tmp_srchstr;
4686         d_char[0] = temp_d_char[0];
4687         d_char[1] = temp_d_char[1];
4688         d_char[2] = temp_d_char[2];
4689         auto_format = TRUE;
4690         dlt_line->line_length = tmp_d_line_length;
4691         d_line = tmp_d_line;
4692
4693         formatted = TRUE;
4694         midscreen(scr_vert, point);
4695 }
4696
4697 void
4698 modes_op()
4699 {
4700         int ret_value;
4701         int counter;
4702         char *string;
4703
4704         do
4705         {
4706                 sprintf(modes_menu[1].item_string, "%s %s", mode_strings[1],
4707                                         (expand_tabs ? ON : OFF));
4708                 sprintf(modes_menu[2].item_string, "%s %s", mode_strings[2],
4709                                         (case_sen ? ON : OFF));
4710                 sprintf(modes_menu[3].item_string, "%s %s", mode_strings[3],
4711                                         (observ_margins ? ON : OFF));
4712                 sprintf(modes_menu[4].item_string, "%s %s", mode_strings[4],
4713                                         (auto_format ? ON : OFF));
4714                 sprintf(modes_menu[5].item_string, "%s %s", mode_strings[5],
4715                                         (eightbit ? ON : OFF));
4716                 sprintf(modes_menu[6].item_string, "%s %s", mode_strings[6],
4717                                         (info_window ? ON : OFF));
4718                 sprintf(modes_menu[7].item_string, "%s %s", mode_strings[7],
4719                                         (emacs_keys_mode ? ON : OFF));
4720                 sprintf(modes_menu[8].item_string, "%s %d", mode_strings[8],
4721                                         right_margin);
4722                 sprintf(modes_menu[9].item_string, "%s %s", mode_strings[9],
4723                                         (ee_chinese ? ON : OFF));
4724
4725                 ret_value = menu_op(modes_menu);
4726
4727                 switch (ret_value)
4728                 {
4729                         case 1:
4730                                 expand_tabs = !expand_tabs;
4731                                 break;
4732                         case 2:
4733                                 case_sen = !case_sen;
4734                                 break;
4735                         case 3:
4736                                 observ_margins = !observ_margins;
4737                                 break;
4738                         case 4:
4739                                 auto_format = !auto_format;
4740                                 if (auto_format)
4741                                         observ_margins = TRUE;
4742                                 break;
4743                         case 5:
4744                                 eightbit = !eightbit;
4745                                 if (!eightbit)
4746                                         ee_chinese = FALSE;
4747 #ifdef NCURSE
4748                                 if (ee_chinese)
4749                                         nc_setattrib(A_NC_BIG5);
4750                                 else
4751                                         nc_clearattrib(A_NC_BIG5);
4752 #endif /* NCURSE */
4753
4754                                 redraw();
4755                                 wnoutrefresh(text_win);
4756                                 break;
4757                         case 6:
4758                                 if (info_window)
4759                                         no_info_window();
4760                                 else
4761                                         create_info_window();
4762                                 break;
4763                         case 7:
4764                                 emacs_keys_mode = !emacs_keys_mode;
4765                                 if (info_window)
4766                                         paint_info_win();
4767                                 break;
4768                         case 8:
4769                                 string = get_string(margin_prompt, TRUE);
4770                                 if (string != NULL)
4771                                 {
4772                                         counter = atoi(string);
4773                                         if (counter > 0)
4774                                                 right_margin = counter;
4775                                         free(string);
4776                                 }
4777                                 break;
4778                         case 9:
4779                                 ee_chinese = !ee_chinese;
4780                                 if (ee_chinese != FALSE)
4781                                         eightbit = TRUE;
4782 #ifdef NCURSE
4783                                 if (ee_chinese)
4784                                         nc_setattrib(A_NC_BIG5);
4785                                 else
4786                                         nc_clearattrib(A_NC_BIG5);
4787 #endif /* NCURSE */
4788                                 redraw();
4789                                 break;
4790                         default:
4791                                 break;
4792                 }
4793         }
4794         while (ret_value != 0);
4795 }
4796
4797 char *
4798 is_in_string(string, substring) /* a strchr() look-alike for systems without
4799                                    strchr() */
4800 char * string, *substring;
4801 {
4802         char *full, *sub;
4803
4804         for (sub = substring; (sub != NULL) && (*sub != (char)NULL); sub++)
4805         {
4806                 for (full = string; (full != NULL) && (*full != (char)NULL);
4807                                 full++)
4808                 {
4809                         if (*sub == *full)
4810                                 return(full);
4811                 }
4812         }
4813         return(NULL);
4814 }
4815
4816 /*
4817  |      handle names of the form "~/file", "~user/file",
4818  |      "$HOME/foo", "~/$FOO", etc.
4819  */
4820
4821 char *
4822 resolve_name(name)
4823 char *name;
4824 {
4825         char long_buffer[1024];
4826         char short_buffer[128];
4827         char *buffer;
4828         char *slash;
4829         char *tmp;
4830         char *start_of_var;
4831         int offset;
4832         int index;
4833         int counter;
4834         struct passwd *user;
4835
4836         if (name[0] == '~')
4837         {
4838                 if (name[1] == '/')
4839                 {
4840                         index = getuid();
4841                         user = (struct passwd *) getpwuid(index);
4842                         slash = name + 1;
4843                 }
4844                 else
4845                 {
4846                         slash = strchr(name, '/');
4847                         if (slash == NULL)
4848                                 return(name);
4849                         *slash = (char) NULL;
4850                         user = (struct passwd *) getpwnam((name + 1));
4851                         *slash = '/';
4852                 }
4853                 if (user == NULL)
4854                 {
4855                         return(name);
4856                 }
4857                 buffer = malloc(strlen(user->pw_dir) + strlen(slash) + 1);
4858                 strcpy(buffer, user->pw_dir);
4859                 strcat(buffer, slash);
4860         }
4861         else
4862                 buffer = name;
4863
4864         if (is_in_string(buffer, "$"))
4865         {
4866                 tmp = buffer;
4867                 index = 0;
4868
4869                 while ((*tmp != (char) NULL) && (index < 1024))
4870                 {
4871
4872                         while ((*tmp != (char) NULL) && (*tmp != '$') &&
4873                                 (index < 1024))
4874                         {
4875                                 long_buffer[index] = *tmp;
4876                                 tmp++;
4877                                 index++;
4878                         }
4879
4880                         if ((*tmp == '$') && (index < 1024))
4881                         {
4882                                 counter = 0;
4883                                 start_of_var = tmp;
4884                                 tmp++;
4885                                 if (*tmp == '{') /* } */        /* bracketed variable name */
4886                                 {
4887                                         tmp++;                          /* { */
4888                                         while ((*tmp != (char) NULL) &&
4889                                                 (*tmp != '}') &&
4890                                                 (counter < 128))
4891                                         {
4892                                                 short_buffer[counter] = *tmp;
4893                                                 counter++;
4894                                                 tmp++;
4895                                         }                       /* { */
4896                                         if (*tmp == '}')
4897                                                 tmp++;
4898                                 }
4899                                 else
4900                                 {
4901                                         while ((*tmp != (char) NULL) &&
4902                                                (*tmp != '/') &&
4903                                                (*tmp != '$') &&
4904                                                (counter < 128))
4905                                         {
4906                                                 short_buffer[counter] = *tmp;
4907                                                 counter++;
4908                                                 tmp++;
4909                                         }
4910                                 }
4911                                 short_buffer[counter] = (char) NULL;
4912                                 if ((slash = getenv(short_buffer)) != NULL)
4913                                 {
4914                                         offset = strlen(slash);
4915                                         if ((offset + index) < 1024)
4916                                                 strcpy(&long_buffer[index], slash);
4917                                         index += offset;
4918                                 }
4919                                 else
4920                                 {
4921                                         while ((start_of_var != tmp) && (index < 1024))
4922                                         {
4923                                                 long_buffer[index] = *start_of_var;
4924                                                 start_of_var++;
4925                                                 index++;
4926                                         }
4927                                 }
4928                         }
4929                 }
4930
4931                 if (index == 1024)
4932                         return(buffer);
4933                 else
4934                         long_buffer[index] = (char) NULL;
4935
4936                 if (name != buffer)
4937                         free(buffer);
4938                 buffer = malloc(index + 1);
4939                 strcpy(buffer, long_buffer);
4940         }
4941
4942         return(buffer);
4943 }
4944
4945 int
4946 restrict_mode()
4947 {
4948         if (!restricted)
4949                 return(FALSE);
4950
4951         wmove(com_win, 0, 0);
4952         wprintw(com_win, restricted_msg);
4953         wclrtoeol(com_win);
4954         wrefresh(com_win);
4955         clear_com_win = TRUE;
4956         return(TRUE);
4957 }
4958
4959 /*
4960  |      The following routine tests the input string against the list of
4961  |      strings, to determine if the string is a unique match with one of the
4962  |      valid values.
4963  */
4964
4965 int
4966 unique_test(string, list)
4967 char *string;
4968 char *list[];
4969 {
4970         int counter;
4971         int num_match;
4972         int result;
4973
4974         num_match = 0;
4975         counter = 0;
4976         while (list[counter] != NULL)
4977         {
4978                 result = compare(string, list[counter], FALSE);
4979                 if (result)
4980                         num_match++;
4981                 counter++;
4982         }
4983         return(num_match);
4984 }
4985
4986 void
4987 renumber_lines(firstline, startnumber)
4988 struct text *firstline;
4989 int startnumber;
4990 {
4991         struct text *lineptr;
4992         int i;
4993
4994         i = startnumber;
4995         for (lineptr = firstline; lineptr != NULL; lineptr = lineptr->next_line)
4996                 lineptr->line_number = i++;
4997 }
4998
4999 #ifndef NO_CATGETS
5000 /*
5001  |      Get the catalog entry, and if it got it from the catalog,
5002  |      make a copy, since the buffer will be overwritten by the
5003  |      next call to catgets().
5004  */
5005
5006 char *
5007 catgetlocal(number, string)
5008 int number;
5009 char *string;
5010 {
5011         char *temp1;
5012         char *temp2;
5013
5014         temp1 = catgets(catalog, 1, number, string);
5015         if (temp1 != string)
5016         {
5017                 temp2 = malloc(strlen(temp1) + 1);
5018                 strcpy(temp2, temp1);
5019                 temp1 = temp2;
5020         }
5021         return(temp1);
5022 }
5023 #endif /* NO_CATGETS */
5024
5025 /*
5026  |      The following is to allow for using message catalogs which allow
5027  |      the software to be 'localized', that is, to use different languages
5028  |      all with the same binary.  For more information, see your system
5029  |      documentation, or the X/Open Internationalization Guide.
5030  */
5031
5032 void
5033 strings_init()
5034 {
5035         int counter;
5036
5037 #ifndef NO_CATGETS
5038         setlocale(LC_ALL, "");
5039         catalog = catopen("ee", NL_CAT_LOCALE);
5040 #endif /* NO_CATGETS */
5041
5042         modes_menu[0].item_string = catgetlocal( 1, "modes menu");
5043         mode_strings[1]  = catgetlocal( 2, "tabs to spaces       ");
5044         mode_strings[2]  = catgetlocal( 3, "case sensitive search");
5045         mode_strings[3]  = catgetlocal( 4, "margins observed     ");
5046         mode_strings[4]  = catgetlocal( 5, "auto-paragraph format");
5047         mode_strings[5]  = catgetlocal( 6, "eightbit characters  ");
5048         mode_strings[6]  = catgetlocal( 7, "info window          ");
5049         mode_strings[8]  = catgetlocal( 8, "right margin         ");
5050         leave_menu[0].item_string  = catgetlocal( 9, "leave menu");
5051         leave_menu[1].item_string  = catgetlocal( 10, "save changes");
5052         leave_menu[2].item_string  = catgetlocal( 11, "no save");
5053         file_menu[0].item_string  = catgetlocal( 12, "file menu");
5054         file_menu[1].item_string  = catgetlocal( 13, "read a file");
5055         file_menu[2].item_string  = catgetlocal( 14, "write a file");
5056         file_menu[3].item_string  = catgetlocal( 15, "save file");
5057         file_menu[4].item_string  = catgetlocal( 16, "print editor contents");
5058         search_menu[0].item_string = catgetlocal( 17, "search menu");
5059         search_menu[1].item_string = catgetlocal( 18, "search for ...");
5060         search_menu[2].item_string = catgetlocal( 19, "search");
5061         spell_menu[0].item_string = catgetlocal( 20, "spell menu");
5062         spell_menu[1].item_string = catgetlocal( 21, "use 'spell'");
5063         spell_menu[2].item_string = catgetlocal( 22, "use 'ispell'");
5064         misc_menu[0].item_string = catgetlocal( 23, "miscellaneous menu");
5065         misc_menu[1].item_string = catgetlocal( 24, "format paragraph");
5066         misc_menu[2].item_string = catgetlocal( 25, "shell command");
5067         misc_menu[3].item_string = catgetlocal( 26, "check spelling");
5068         main_menu[0].item_string  = catgetlocal( 27, "main menu");
5069         main_menu[1].item_string  = catgetlocal( 28, "leave editor");
5070         main_menu[2].item_string  = catgetlocal( 29, "help");
5071         main_menu[3].item_string  = catgetlocal( 30, "file operations");
5072         main_menu[4].item_string  = catgetlocal( 31, "redraw screen");
5073         main_menu[5].item_string  = catgetlocal( 32, "settings");
5074         main_menu[6].item_string  = catgetlocal( 33, "search");
5075         main_menu[7].item_string  = catgetlocal( 34, "miscellaneous");
5076         help_text[0] = catgetlocal( 35, "Control keys:                                                              ");
5077         help_text[1] = catgetlocal( 36, "^a ascii code           ^i tab                  ^r right                   ");
5078         help_text[2] = catgetlocal( 37, "^b bottom of text       ^j newline              ^t top of text             ");
5079         help_text[3] = catgetlocal( 38, "^c command              ^k delete char          ^u up                      ");
5080         help_text[4] = catgetlocal( 39, "^d down                 ^l left                 ^v undelete word           ");
5081         help_text[5] = catgetlocal( 40, "^e search prompt        ^m newline              ^w delete word             ");
5082         help_text[6] = catgetlocal( 41, "^f undelete char        ^n next page            ^x search                  ");
5083         help_text[7] = catgetlocal( 42, "^g begin of line        ^o end of line          ^y delete line             ");
5084         help_text[8] = catgetlocal( 43, "^h backspace            ^p prev page            ^z undelete line           ");
5085         help_text[9] = catgetlocal( 44, "^[ (escape) menu        ESC-Enter: exit ee                                 ");
5086         help_text[10] = catgetlocal( 45, "                                                                           ");
5087         help_text[11] = catgetlocal( 46, "Commands:                                                                  ");
5088         help_text[12] = catgetlocal( 47, "help    : get this info                 file    : print file name          ");
5089         help_text[13] = catgetlocal( 48, "read    : read a file                   char    : ascii code of char       ");
5090         help_text[14] = catgetlocal( 49, "write   : write a file                  case    : case sensitive search    ");
5091         help_text[15] = catgetlocal( 50, "exit    : leave and save                nocase  : case insensitive search  ");
5092         help_text[16] = catgetlocal( 51, "quit    : leave, no save                !cmd    : execute \"cmd\" in shell   ");
5093         help_text[17] = catgetlocal( 52, "line    : display line #                0-9     : go to line \"#\"           ");
5094         help_text[18] = catgetlocal( 53, "expand  : expand tabs                   noexpand: do not expand tabs         ");
5095         help_text[19] = catgetlocal( 54, "                                                                             ");
5096         help_text[20] = catgetlocal( 55, "  ee [+#] [-i] [-e] [-h] [file(s)]                                            ");
5097         help_text[21] = catgetlocal( 56, "+# :go to line #  -i :no info window  -e : don't expand tabs  -h :no highlight");
5098         control_keys[0] = catgetlocal( 57, "^[ (escape) menu  ^e search prompt  ^y delete line    ^u up     ^p prev page  ");
5099         control_keys[1] = catgetlocal( 58, "^a ascii code     ^x search         ^z undelete line  ^d down   ^n next page  ");
5100         control_keys[2] = catgetlocal( 59, "^b bottom of text ^g begin of line  ^w delete word    ^l left                 ");
5101         control_keys[3] = catgetlocal( 60, "^t top of text    ^o end of line    ^v undelete word  ^r right                ");
5102         control_keys[4] = catgetlocal( 61, "^c command        ^k delete char    ^f undelete char      ESC-Enter: exit ee  ");
5103         command_strings[0] = catgetlocal( 62, "help : get help info  |file  : print file name         |line : print line # ");
5104         command_strings[1] = catgetlocal( 63, "read : read a file    |char  : ascii code of char      |0-9 : go to line \"#\"");
5105         command_strings[2] = catgetlocal( 64, "write: write a file   |case  : case sensitive search   |exit : leave and save ");
5106         command_strings[3] = catgetlocal( 65, "!cmd : shell \"cmd\"    |nocase: ignore case in search   |quit : leave, no save");
5107         command_strings[4] = catgetlocal( 66, "expand: expand tabs   |noexpand: do not expand tabs                           ");
5108         com_win_message = catgetlocal( 67, "    press Escape (^[) for menu");
5109         no_file_string = catgetlocal( 68, "no file");
5110         ascii_code_str = catgetlocal( 69, "ascii code: ");
5111         printer_msg_str = catgetlocal( 70, "sending contents of buffer to \"%s\" ");
5112         command_str = catgetlocal( 71, "command: ");
5113         file_write_prompt_str = catgetlocal( 72, "name of file to write: ");
5114         file_read_prompt_str = catgetlocal( 73, "name of file to read: ");
5115         char_str = catgetlocal( 74, "character = %d");
5116         unkn_cmd_str = catgetlocal( 75, "unknown command \"%s\"");
5117         non_unique_cmd_msg = catgetlocal( 76, "entered command is not unique");
5118         line_num_str = catgetlocal( 77, "line %d  ");
5119         line_len_str = catgetlocal( 78, "length = %d");
5120         current_file_str = catgetlocal( 79, "current file is \"%s\" ");
5121         usage0 = catgetlocal( 80, "usage: %s [-i] [-e] [-h] [+line_number] [file(s)]\n");
5122         usage1 = catgetlocal( 81, "       -i   turn off info window\n");
5123         usage2 = catgetlocal( 82, "       -e   do not convert tabs to spaces\n");
5124         usage3 = catgetlocal( 83, "       -h   do not use highlighting\n");
5125         file_is_dir_msg = catgetlocal( 84, "file \"%s\" is a directory");
5126         new_file_msg = catgetlocal( 85, "new file \"%s\"");
5127         cant_open_msg = catgetlocal( 86, "can't open \"%s\"");
5128         open_file_msg = catgetlocal( 87, "file \"%s\", %d lines");
5129         file_read_fin_msg = catgetlocal( 88, "finished reading file \"%s\"");
5130         reading_file_msg = catgetlocal( 89, "reading file \"%s\"");
5131         read_only_msg = catgetlocal( 90, ", read only");
5132         file_read_lines_msg = catgetlocal( 91, "file \"%s\", %d lines");
5133         save_file_name_prompt = catgetlocal( 92, "enter name of file: ");
5134         file_not_saved_msg = catgetlocal( 93, "no filename entered: file not saved");
5135         changes_made_prompt = catgetlocal( 94, "changes have been made, are you sure? (y/n [n]) ");
5136         yes_char = catgetlocal( 95, "y");
5137         file_exists_prompt = catgetlocal( 96, "file already exists, overwrite? (y/n) [n] ");
5138         create_file_fail_msg = catgetlocal( 97, "unable to create file \"%s\"");
5139         writing_file_msg = catgetlocal( 98, "writing file \"%s\"");
5140         file_written_msg = catgetlocal( 99, "\"%s\" %d lines, %d characters");
5141         searching_msg = catgetlocal( 100, "           ...searching");
5142         str_not_found_msg = catgetlocal( 101, "string \"%s\" not found");
5143         search_prompt_str = catgetlocal( 102, "search for: ");
5144         exec_err_msg = catgetlocal( 103, "could not exec %s");
5145         continue_msg = catgetlocal( 104, "press return to continue ");
5146         menu_cancel_msg = catgetlocal( 105, "press Esc to cancel");
5147         menu_size_err_msg = catgetlocal( 106, "menu too large for window");
5148         press_any_key_msg = catgetlocal( 107, "press any key to continue ");
5149         shell_prompt = catgetlocal( 108, "shell command: ");
5150         formatting_msg = catgetlocal( 109, "...formatting paragraph...");
5151         shell_echo_msg = catgetlocal( 110, "<!echo 'list of unrecognized words'; echo -=-=-=-=-=-");
5152         spell_in_prog_msg = catgetlocal( 111, "sending contents of edit buffer to 'spell'");
5153         margin_prompt = catgetlocal( 112, "right margin is: ");
5154         restricted_msg = catgetlocal( 113, "restricted mode: unable to perform requested operation");
5155         ON = catgetlocal( 114, "ON");
5156         OFF = catgetlocal( 115, "OFF");
5157         HELP = catgetlocal( 116, "HELP");
5158         WRITE = catgetlocal( 117, "WRITE");
5159         READ = catgetlocal( 118, "READ");
5160         LINE = catgetlocal( 119, "LINE");
5161         FILE_str = catgetlocal( 120, "FILE");
5162         CHARACTER = catgetlocal( 121, "CHARACTER");
5163         REDRAW = catgetlocal( 122, "REDRAW");
5164         RESEQUENCE = catgetlocal( 123, "RESEQUENCE");
5165         AUTHOR = catgetlocal( 124, "AUTHOR");
5166         VERSION = catgetlocal( 125, "VERSION");
5167         CASE = catgetlocal( 126, "CASE");
5168         NOCASE = catgetlocal( 127, "NOCASE");
5169         EXPAND = catgetlocal( 128, "EXPAND");
5170         NOEXPAND = catgetlocal( 129, "NOEXPAND");
5171         Exit_string = catgetlocal( 130, "EXIT");
5172         QUIT_string = catgetlocal( 131, "QUIT");
5173         INFO = catgetlocal( 132, "INFO");
5174         NOINFO = catgetlocal( 133, "NOINFO");
5175         MARGINS = catgetlocal( 134, "MARGINS");
5176         NOMARGINS = catgetlocal( 135, "NOMARGINS");
5177         AUTOFORMAT = catgetlocal( 136, "AUTOFORMAT");
5178         NOAUTOFORMAT = catgetlocal( 137, "NOAUTOFORMAT");
5179         Echo = catgetlocal( 138, "ECHO");
5180         PRINTCOMMAND = catgetlocal( 139, "PRINTCOMMAND");
5181         RIGHTMARGIN = catgetlocal( 140, "RIGHTMARGIN");
5182         HIGHLIGHT = catgetlocal( 141, "HIGHLIGHT");
5183         NOHIGHLIGHT = catgetlocal( 142, "NOHIGHLIGHT");
5184         EIGHTBIT = catgetlocal( 143, "EIGHTBIT");
5185         NOEIGHTBIT = catgetlocal( 144, "NOEIGHTBIT");
5186         /*
5187          |      additions
5188          */
5189         mode_strings[7] = catgetlocal( 145, "emacs key bindings   ");
5190         emacs_help_text[0] = help_text[0];
5191         emacs_help_text[1] = catgetlocal( 146, "^a beginning of line    ^i tab                  ^r restore word            ");
5192         emacs_help_text[2] = catgetlocal( 147, "^b back 1 char          ^j undel char           ^t begin of file           ");
5193         emacs_help_text[3] = catgetlocal( 148, "^c command              ^k delete line          ^u end of file             ");
5194         emacs_help_text[4] = catgetlocal( 149, "^d delete char          ^l undelete line        ^v next page               ");
5195         emacs_help_text[5] = catgetlocal( 150, "^e end of line          ^m newline              ^w delete word             ");
5196         emacs_help_text[6] = catgetlocal( 151, "^f forward 1 char       ^n next line            ^x search                  ");
5197         emacs_help_text[7] = catgetlocal( 152, "^g go back 1 page       ^o ascii char insert    ^y search prompt           ");
5198         emacs_help_text[8] = catgetlocal( 153, "^h backspace            ^p prev line            ^z next word               ");
5199         emacs_help_text[9] = help_text[9];
5200         emacs_help_text[10] = help_text[10];
5201         emacs_help_text[11] = help_text[11];
5202         emacs_help_text[12] = help_text[12];
5203         emacs_help_text[13] = help_text[13];
5204         emacs_help_text[14] = help_text[14];
5205         emacs_help_text[15] = help_text[15];
5206         emacs_help_text[16] = help_text[16];
5207         emacs_help_text[17] = help_text[17];
5208         emacs_help_text[18] = help_text[18];
5209         emacs_help_text[19] = help_text[19];
5210         emacs_help_text[20] = help_text[20];
5211         emacs_help_text[21] = help_text[21];
5212         emacs_control_keys[0] = catgetlocal( 154, "^[ (escape) menu ^y search prompt ^k delete line    ^p prev line  ^g prev page");
5213         emacs_control_keys[1] = catgetlocal( 155, "^o ascii code    ^x search        ^l undelete line  ^n next line  ^v next page");
5214         emacs_control_keys[2] = catgetlocal( 156, "^u end of file   ^a begin of line ^w delete word    ^b back char  ^z next word");
5215         emacs_control_keys[3] = catgetlocal( 157, "^t begin of file ^e end of line   ^r restore word   ^f forward char           ");
5216         emacs_control_keys[4] = catgetlocal( 158, "^c command       ^d delete char   ^j undelete char              ESC-Enter: exit");
5217         EMACS_string = catgetlocal( 159, "EMACS");
5218         NOEMACS_string = catgetlocal( 160, "NOEMACS");
5219         usage4 = catgetlocal( 161, "       +#   put cursor at line #\n");
5220         conf_dump_err_msg = catgetlocal( 162, "unable to open .init.ee for writing, no configuration saved!");
5221         conf_dump_success_msg = catgetlocal( 163, "ee configuration saved in file %s");
5222         modes_menu[10].item_string = catgetlocal( 164, "save editor configuration");
5223         config_dump_menu[0].item_string = catgetlocal( 165, "save ee configuration");
5224         config_dump_menu[1].item_string = catgetlocal( 166, "save in current directory");
5225         config_dump_menu[2].item_string = catgetlocal( 167, "save in home directory");
5226         conf_not_saved_msg = catgetlocal( 168, "ee configuration not saved");
5227         ree_no_file_msg = catgetlocal( 169, "must specify a file when invoking ree");
5228         menu_too_lrg_msg = catgetlocal( 180, "menu too large for window");
5229         more_above_str = catgetlocal( 181, "^^more^^");
5230         more_below_str = catgetlocal( 182, "VVmoreVV");
5231         mode_strings[9] = catgetlocal( 183, "16 bit characters    ");
5232         chinese_cmd = catgetlocal( 184, "16BIT");
5233         nochinese_cmd = catgetlocal( 185, "NO16BIT");
5234
5235         commands[0] = HELP;
5236         commands[1] = WRITE;
5237         commands[2] = READ;
5238         commands[3] = LINE;
5239         commands[4] = FILE_str;
5240         commands[5] = REDRAW;
5241         commands[6] = RESEQUENCE;
5242         commands[7] = AUTHOR;
5243         commands[8] = VERSION;
5244         commands[9] = CASE;
5245         commands[10] = NOCASE;
5246         commands[11] = EXPAND;
5247         commands[12] = NOEXPAND;
5248         commands[13] = Exit_string;
5249         commands[14] = QUIT_string;
5250         commands[15] = "<";
5251         commands[16] = ">";
5252         commands[17] = "!";
5253         commands[18] = "0";
5254         commands[19] = "1";
5255         commands[20] = "2";
5256         commands[21] = "3";
5257         commands[22] = "4";
5258         commands[23] = "5";
5259         commands[24] = "6";
5260         commands[25] = "7";
5261         commands[26] = "8";
5262         commands[27] = "9";
5263         commands[28] = CHARACTER;
5264         commands[29] = chinese_cmd;
5265         commands[30] = nochinese_cmd;
5266         commands[31] = NULL;
5267         init_strings[0] = CASE;
5268         init_strings[1] = NOCASE;
5269         init_strings[2] = EXPAND;
5270         init_strings[3] = NOEXPAND;
5271         init_strings[4] = INFO;
5272         init_strings[5] = NOINFO;
5273         init_strings[6] = MARGINS;
5274         init_strings[7] = NOMARGINS;
5275         init_strings[8] = AUTOFORMAT;
5276         init_strings[9] = NOAUTOFORMAT;
5277         init_strings[10] = Echo;
5278         init_strings[11] = PRINTCOMMAND;
5279         init_strings[12] = RIGHTMARGIN;
5280         init_strings[13] = HIGHLIGHT;
5281         init_strings[14] = NOHIGHLIGHT;
5282         init_strings[15] = EIGHTBIT;
5283         init_strings[16] = NOEIGHTBIT;
5284         init_strings[17] = EMACS_string;
5285         init_strings[18] = NOEMACS_string;
5286         init_strings[19] = chinese_cmd;
5287         init_strings[20] = nochinese_cmd;
5288         init_strings[21] = NULL;
5289
5290         /*
5291          |      allocate space for strings here for settings menu
5292          */
5293
5294         for (counter = 1; counter < NUM_MODES_ITEMS; counter++)
5295         {
5296                 modes_menu[counter].item_string = malloc(80);
5297         }
5298
5299 #ifndef NO_CATGETS
5300         catclose(catalog);
5301 #endif /* NO_CATGETS */
5302 }
5303