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