home *** CD-ROM | disk | FTP | other *** search
/ Source Code 1994 March / Source_Code_CD-ROM_Walnut_Creek_March_1994.iso / compsrcs / misc / volume35 / ee / part03 < prev    next >
Encoding:
Text File  |  1993-02-21  |  53.7 KB  |  2,212 lines
  1. Newsgroups: comp.sources.misc
  2. From: hugh@nsmdserv.cnd.hp.com (Hugh F. Mahon)
  3. Subject: v35i082:  ee - Easy Editor, a simple editor for UNIX, Part03/05
  4. Message-ID: <1993Feb22.041355.15332@sparky.imd.sterling.com>
  5. X-Md4-Signature: 3693c0f88d4971eb39e4a4006830449a
  6. Date: Mon, 22 Feb 1993 04:13:55 GMT
  7. Approved: kent@sparky.imd.sterling.com
  8.  
  9. Submitted-by: hugh@nsmdserv.cnd.hp.com (Hugh F. Mahon)
  10. Posting-number: Volume 35, Issue 82
  11. Archive-name: ee/part03
  12. Environment: SYSV, SunOS, Curses
  13.  
  14. #! /bin/sh
  15. # This is a shell archive.  Remove anything before this line, then feed it
  16. # into a shell via "sh file" or similar.  To overwrite existing files,
  17. # type "sh file -c".
  18. # Contents:  ee.c.A ee.msg
  19. # Wrapped by kent@sparky on Sat Feb 20 21:31:18 1993
  20. PATH=/bin:/usr/bin:/usr/ucb:/usr/local/bin:/usr/lbin ; export PATH
  21. echo If this archive is complete, you will see the following message:
  22. echo '          "shar: End of archive 3 (of 5)."'
  23. if test -f 'ee.c.A' -a "${1}" != "-c" ; then 
  24.   echo shar: Will not clobber existing file \"'ee.c.A'\"
  25. else
  26.   echo shar: Extracting \"'ee.c.A'\" \(45319 characters\)
  27.   sed "s/^X//" >'ee.c.A' <<'END_OF_FILE'
  28. X/*
  29. X |    ee (easy editor)
  30. X |
  31. X |    An easy to use, simple screen oriented editor.
  32. X |
  33. X |    written by Hugh Mahon
  34. X |
  35. X |    THIS MATERIAL IS PROVIDED "AS IS".  THERE ARE
  36. X |    NO WARRANTIES OF ANY KIND WITH REGARD TO THIS
  37. X |    MATERIAL, INCLUDING, BUT NOT LIMITED TO, THE
  38. X |    IMPLIED WARRANTIES OF MERCHANTABILITY AND
  39. X |    FITNESS FOR A PARTICULAR PURPOSE.  Neither
  40. X |    Hewlett-Packard nor Hugh Mahon shall be liable
  41. X |    for errors contained herein, nor for
  42. X |    incidental or consequential damages in
  43. X |    connection with the furnishing, performance or
  44. X |    use of this material.  Neither Hewlett-Packard
  45. X |    nor Hugh Mahon assumes any responsibility for
  46. X |    the use or reliability of this software or
  47. X |    documentation.  This software and
  48. X |    documentation is totally UNSUPPORTED.  There
  49. X |    is no support contract available.  Hewlett-
  50. X |    Packard has done NO Quality Assurance on ANY
  51. X |    of the program or documentation.  You may find
  52. X |    the quality of the materials inferior to
  53. X |    supported materials.
  54. X |
  55. X |    This software is not a product of Hewlett-Packard, Co., or any 
  56. X |    other company.  No support is implied or offered with this software.
  57. X |    You've got the source, and you're on your own.
  58. X |
  59. X |    This software is for free distribution, and is not to be sold, or 
  60. X |    otherwise traded for value without the expressed, written consent of 
  61. X |    the author.  Likewise, any derivatives of this software cannot be 
  62. X |    sold or traded without the consent of the author.  
  63. X |
  64. X |    This notice must be included with this software and any derivatives.
  65. X |
  66. X |    This editor was purposely developed to be simple, both in 
  67. X |    interface and implementation.  This editor was developed to 
  68. X |    address a specific audience: the user who is new to computers 
  69. X |    (especially UNIX).
  70. X |    
  71. X |    ee is not aimed at technical users; for that reason more 
  72. X |    complex features were intentionally left out.  In addition, 
  73. X |    ee is intended to be compiled by people with little computer 
  74. X |    experience, which means that it needs to be small, relatively 
  75. X |    simple in implementation, and portable.
  76. X |
  77. X |    This software and documentation contains
  78. X |    proprietary information which is protected by
  79. X |    copyright.  All rights are reserved.
  80. X |
  81. X |    $Header: /users/hugh/tmp/old_ae/ee.c,v 1.65 1993/02/19 05:00:07 hugh Exp $
  82. X |
  83. X */
  84. X
  85. Xchar *ee_copyright_message = 
  86. X"Copyright (c) 1986, 1990, 1991, 1992, 1993 Hugh Mahon ";
  87. X
  88. Xchar *ee_long_notice[] = {
  89. X    "This software and documentation contains", 
  90. X    "proprietary information which is protected by", 
  91. X    "copyright.  All rights are reserved."
  92. X    };
  93. X
  94. Xchar *version = "@(#) ee, version 1.2.2 $Revision: 1.65 $";
  95. X
  96. X#ifdef NCURSE
  97. X#include "new_curse.h"
  98. X#else
  99. X#include <curses.h>
  100. X#endif
  101. X
  102. X#include <signal.h>
  103. X#include <fcntl.h>
  104. X#include <sys/types.h>
  105. X#include <sys/stat.h>
  106. X#include <errno.h>
  107. X#include <string.h>
  108. X#include <pwd.h>
  109. X
  110. X#ifndef NO_CATGETS
  111. X#include <locale.h>
  112. X#include <nl_types.h>
  113. X
  114. Xnl_catd catalog;
  115. X#else
  116. X#define catgetlocal(a, b) (b)
  117. X#endif /* NO_CATGETS */
  118. X
  119. X#ifndef SIGCHLD
  120. X#define SIGCHLD SIGCLD
  121. X#endif
  122. X
  123. X#define TAB 9
  124. X#define max(a, b)    (a > b ? a : b)
  125. X#define min(a, b)    (a < b ? a : b)
  126. X
  127. X/*
  128. X |    defines for type of data to show in info window
  129. X */
  130. X
  131. X#define CONTROL_KEYS 1
  132. X#define COMMANDS     2
  133. X
  134. Xextern char *malloc();
  135. Xextern char *realloc();
  136. Xextern char *getenv();
  137. X
  138. Xchar *get_string();
  139. Xchar *resolve_name();
  140. X
  141. Xstruct text {
  142. X    char *line;            /* line of characters        */
  143. X    int line_number;        /* line number            */
  144. X    int line_length;    /* actual number of characters in the line */
  145. X    int max_length;    /* maximum number of characters the line handles */
  146. X    struct text *next_line;        /* next line of text        */
  147. X    struct text *prev_line;        /* previous line of text    */
  148. X    };
  149. X
  150. Xstruct text *first_line;    /* first line of current buffer        */
  151. Xstruct text *dlt_line;        /* structure for info on deleted line    */
  152. Xstruct text *curr_line;        /* current line cursor is on        */
  153. Xstruct text *tmp_line;        /* temporary line pointer        */
  154. Xstruct text *srch_line;        /* temporary pointer for search routine */
  155. X
  156. Xstruct text *txtalloc();    /* procedure to allocate space for each line */
  157. X
  158. Xstruct files {        /* structure to store names of files to be edited*/
  159. X    char *name;        /* name of file                */
  160. X    struct files *next_name;
  161. X    };
  162. X
  163. Xstruct files *name_alloc();
  164. Xstruct files *top_of_stack = NULL;
  165. X
  166. Xint d_wrd_len;            /* length of deleted word        */
  167. Xint position;            /* offset in bytes from begin of line    */
  168. Xint scr_pos;            /* horizontal position            */
  169. Xint scr_vert;            /* vertical position on screen        */
  170. Xint scr_horz;            /* horizontal position on screen    */
  171. Xint tmp_vert, tmp_horz;
  172. Xint input_file;            /* indicate to read input file        */
  173. Xint recv_file;            /* indicate reading a file        */
  174. Xint edit;            /* continue executing while true    */
  175. Xint gold;            /* 'gold' function key pressed        */
  176. Xint fildes;            /* file descriptor            */
  177. Xint case_sen;            /* case sensitive search flag        */
  178. Xint last_line;            /* last line for text display        */
  179. Xint last_col;            /* last column for text display        */
  180. Xint horiz_offset = 0;        /* offset from left edge of text    */
  181. Xint clear_com_win;        /* flag to indicate com_win needs clearing */
  182. Xint text_changes = FALSE;    /* indicate changes have been made to text */
  183. Xint get_fd;            /* file descriptor for reading a file    */
  184. Xint info_window = TRUE;        /* flag to indicate if help window visible */
  185. Xint info_type = CONTROL_KEYS;    /* flag to indicate type of info to display */
  186. Xint expand_tabs = TRUE;        /* flag for expanding tabs        */
  187. Xint right_margin = 0;        /* the right margin             */
  188. Xint observ_margins = TRUE;    /* flag for whether margins are observed */
  189. Xint shell_fork;
  190. Xint temp_stdin;            /* temporary storage for stdin        */
  191. Xint temp_stdout;        /* temp storage for stdout descriptor    */
  192. Xint temp_stderr;        /* temp storage for stderr descriptor    */
  193. Xint pipe_out[2];        /* pipe file desc for output        */
  194. Xint pipe_in[2];            /* pipe file descriptors for input    */
  195. Xint out_pipe;            /* flag that info is piped out        */
  196. Xint in_pipe;            /* flag that info is piped in        */
  197. Xint formatted = FALSE;        /* flag indicating paragraph formatted    */
  198. Xint auto_format = FALSE;    /* flag for auto_format mode        */
  199. Xint restricted = FALSE;        /* flag to indicate restricted mode    */
  200. Xint nohighlight = FALSE;    /* turns off highlighting        */
  201. Xint eightbit = TRUE;        /* eight bit character flag        */
  202. X
  203. Xchar *point;            /* points to current position in line    */
  204. Xchar *srch_str;            /* pointer for search string        */
  205. Xchar *u_srch_str;        /* pointer to non-case sensitive search    */
  206. Xchar *srch_1;            /* pointer to start of suspect string    */
  207. Xchar *srch_2;            /* pointer to next character of string    */
  208. Xchar *srch_3;
  209. Xchar *in_file_name = NULL;    /* name of input file            */
  210. Xchar *tmp_file;            /* temporary file name            */
  211. Xchar d_char;            /* deleted character            */
  212. Xchar *d_word;            /* deleted word                */
  213. Xchar *d_line;            /* deleted line                */
  214. Xchar in_string[513];        /* buffer for reading a file        */
  215. Xchar *print_command = "lp";    /* string to use for the print command     */
  216. Xint in;                /* input character            */
  217. X
  218. XFILE *temp_fp;            /* temporary file pointer        */
  219. XFILE *bit_bucket;        /* file pointer to /dev/null        */
  220. XFILE *fopen();            /* declaration for open function    */
  221. X
  222. Xchar *table[] = { 
  223. X    "^@", "^A", "^B", "^C", "^D", "^E", "^F", "^G", "^H", "\t", "^J", 
  224. X    "^K", "^L", "^M", "^N", "^O", "^P", "^Q", "^R", "^S", "^T", "^U", 
  225. X    "^V", "^W", "^X", "^Y", "^Z", "^[", "^\\", "^]", "^^", "^_"
  226. X    };
  227. X
  228. XWINDOW *com_win;
  229. XWINDOW *text_win;
  230. XWINDOW *help_win;
  231. XWINDOW *info_win;
  232. X
  233. X/*
  234. X |    Declare addresses for routines referenced in menus below.
  235. X */
  236. X
  237. Xint help();
  238. Xint menu_op();
  239. Xint file_op();
  240. Xint search_prompt();
  241. Xint search();
  242. Xint finish();
  243. Xint quit();
  244. Xint shell_op();
  245. Xint leave_op();
  246. Xint no_info_window();
  247. Xint create_info_window();
  248. Xint redraw();
  249. Xint Format();
  250. Xint modes_op();
  251. Xint spell_op();
  252. Xint ispell_op();
  253. Xint print_buffer();
  254. X
  255. X/*
  256. X |    The following structure allows menu items to be flexibly declared.
  257. X |    The first item is the string describing the selection, the second 
  258. X |    is the address of the procedure to call when the item is selected,
  259. X |    and the third is the argument for the procedure.
  260. X |
  261. X |    For those systems with i18n, the string should be accompanied by a
  262. X |    catalog number.  The 'int *' should be replaced with 'void *' on 
  263. X |    systems with that type.
  264. X |
  265. X |    The first menu item will be the title of the menu, with NULL 
  266. X |    parameters for the procedure and argument, followed by the menu items.
  267. X |
  268. X |    If the procedure value is NULL, the menu item is displayed, but no 
  269. X |    procedure is called when the item is selected.  The number of the 
  270. X |    item will be returned.  If the third (argument) parameter is -1, no 
  271. X |    argument is given to the procedure when it is called.
  272. X */
  273. X
  274. Xstruct menu_entries {
  275. X    char *item_string;
  276. X    int (*procedure)();
  277. X    unsigned int argument;
  278. X    };
  279. X
  280. X/*
  281. X |    allocate space here for the strings that will be in the menu
  282. X */
  283. X
  284. Xstruct menu_entries modes_menu[] = {
  285. X    {"", NULL, NULL}, 
  286. X    {"                                                                      ", NULL, -1}, 
  287. X    {"                                                                      ", NULL, -1}, 
  288. X    {"                                                                      ", NULL, -1}, 
  289. X    {"                                                                      ", NULL, -1}, 
  290. X    {"                                                                      ", NULL, -1}, 
  291. X    {"                                                                      ", NULL, -1}, 
  292. X    {"                                                                      ", NULL, -1}, 
  293. X    {NULL, NULL, -1}
  294. X    };
  295. X
  296. Xint modes_initialized = FALSE;
  297. X
  298. Xchar *mode_strings[8]; 
  299. X
  300. Xstruct menu_entries leave_menu[] = {
  301. X    {"", NULL, -1}, 
  302. X    {"", finish, -1}, 
  303. X    {"", quit, TRUE}, 
  304. X    {NULL, NULL, -1}
  305. X    };
  306. X
  307. X#define READ_FILE 1
  308. X#define WRITE_FILE 2
  309. X#define SAVE_FILE 3
  310. X
  311. Xstruct menu_entries file_menu[] = {
  312. X    {"", NULL, -1},
  313. X    {"", file_op, READ_FILE},
  314. X    {"", file_op, WRITE_FILE},
  315. X    {"", file_op, SAVE_FILE},
  316. X    {"", print_buffer, -1},
  317. X    {NULL, NULL, -1}
  318. X    };
  319. X
  320. Xstruct menu_entries search_menu[] = {
  321. X    {"", NULL, NULL}, 
  322. X    {"", search_prompt, -1},
  323. X    {"", search, TRUE},
  324. X    {NULL, NULL, -1}
  325. X    };
  326. X
  327. Xstruct menu_entries spell_menu[] = {
  328. X    {"", NULL, -1}, 
  329. X    {"", spell_op, -1},
  330. X    {"", ispell_op, -1},
  331. X    {NULL, NULL, -1}
  332. X    };
  333. X
  334. Xstruct menu_entries misc_menu[] = {
  335. X    {"", NULL, -1}, 
  336. X    {"", Format, -1},
  337. X    {"", shell_op, -1}, 
  338. X    {"", menu_op, (int)spell_menu}, 
  339. X    {NULL, NULL, -1}
  340. X    };
  341. X
  342. Xstruct menu_entries main_menu[] = {
  343. X    {"", NULL, -1}, 
  344. X    {"", leave_op, -1}, 
  345. X    {"", help, -1},
  346. X    {"", menu_op, (int)file_menu}, 
  347. X    {"", redraw, -1}, 
  348. X    {"", modes_op, -1}, 
  349. X    {"", menu_op, (int)search_menu}, 
  350. X    {"", menu_op, (int)misc_menu}, 
  351. X    {NULL, NULL, -1}
  352. X    };
  353. X
  354. Xchar *help_text[22];
  355. X
  356. Xchar *control_keys[5];
  357. X
  358. Xchar *command_strings[5];
  359. Xchar *commands[30];
  360. Xchar *init_strings[18];
  361. X
  362. Xint abort();
  363. X
  364. X/*
  365. X |    Declarations for strings for localization
  366. X */
  367. X
  368. Xchar *com_win_message;        /* to be shown in com_win if no info window */
  369. Xchar *no_file_string;
  370. Xchar *ascii_code_str;
  371. Xchar *printer_msg_str;
  372. Xchar *command_str;
  373. Xchar *file_write_prompt_str;
  374. Xchar *file_read_prompt_str;
  375. Xchar *char_str;
  376. Xchar *unkn_cmd_str;
  377. Xchar *non_unique_cmd_msg;
  378. Xchar *line_num_str;
  379. Xchar *line_len_str;
  380. Xchar *current_file_str;
  381. Xchar *usage0;
  382. Xchar *usage1;
  383. Xchar *usage2;
  384. Xchar *usage3;
  385. Xchar *file_is_dir_msg;
  386. Xchar *new_file_msg;
  387. Xchar *cant_open_msg;
  388. Xchar *open_file_msg;
  389. Xchar *file_read_fin_msg;
  390. Xchar *reading_file_msg;
  391. Xchar *read_only_msg;
  392. Xchar *file_read_lines_msg;
  393. Xchar *save_file_name_prompt;
  394. Xchar *file_not_saved_msg;
  395. Xchar *changes_made_prompt;
  396. Xchar *yes_char;
  397. Xchar *file_exists_prompt;
  398. Xchar *create_file_fail_msg;
  399. Xchar *writing_file_msg;
  400. Xchar *file_written_msg;
  401. Xchar *searching_msg;
  402. Xchar *str_not_found_msg;
  403. Xchar *search_prompt_str;
  404. Xchar *exec_err_msg;
  405. Xchar *continue_msg;
  406. Xchar *menu_cancel_msg;
  407. Xchar *menu_size_err_msg;
  408. Xchar *press_any_key_msg;
  409. Xchar *shell_prompt;
  410. Xchar *formatting_msg;
  411. Xchar *shell_echo_msg;
  412. Xchar *spell_in_prog_msg;
  413. Xchar *margin_prompt;
  414. Xchar *restricted_msg;
  415. Xchar *ON;
  416. Xchar *OFF;
  417. Xchar *HELP;
  418. Xchar *WRITE;
  419. Xchar *READ;
  420. Xchar *LINE;
  421. Xchar *FILE_str;
  422. Xchar *CHARACTER;
  423. Xchar *REDRAW;
  424. Xchar *RESEQUENCE;
  425. Xchar *AUTHOR;
  426. Xchar *VERSION;
  427. Xchar *CASE;
  428. Xchar *NOCASE;
  429. Xchar *EXPAND;
  430. Xchar *NOEXPAND;
  431. Xchar *Exit_string;
  432. Xchar *QUIT_string;
  433. Xchar *INFO;
  434. Xchar *NOINFO;
  435. Xchar *MARGINS;
  436. Xchar *NOMARGINS;
  437. Xchar *AUTOFORMAT;
  438. Xchar *NOAUTOFORMAT;
  439. Xchar *Echo;
  440. Xchar *PRINTCOMMAND;
  441. Xchar *RIGHTMARGIN;
  442. Xchar *HIGHLIGHT;
  443. Xchar *NOHIGHLIGHT;
  444. Xchar *EIGHTBIT;
  445. Xchar *NOEIGHTBIT;
  446. X
  447. Xmain(argc, argv)        /* beginning of main program        */
  448. Xint argc;
  449. Xchar *argv[];
  450. X{
  451. X    int counter;
  452. X
  453. X    for (counter = 1; counter < 24; counter++)
  454. X        signal(counter, SIG_IGN);
  455. X
  456. X    signal(SIGCHLD, SIG_DFL);
  457. X    signal(SIGSEGV, SIG_DFL);
  458. X    signal(SIGINT, abort);
  459. X
  460. X    d_char = 0;
  461. X    d_word = malloc(150);
  462. X    *d_word = NULL;
  463. X    d_line = NULL;
  464. X    dlt_line = txtalloc();
  465. X    dlt_line->line = d_line;
  466. X    curr_line = first_line = txtalloc();
  467. X    curr_line->line = point = malloc(10);
  468. X    curr_line->line_length = 1;
  469. X    curr_line->max_length = 10;
  470. X    curr_line->prev_line = NULL;
  471. X    curr_line->next_line = NULL;
  472. X    curr_line->line_number  = 1;
  473. X    srch_str = NULL;
  474. X    u_srch_str = NULL;
  475. X    position = 1;
  476. X    scr_pos =0;
  477. X    scr_vert = 0;
  478. X    scr_horz = 0;
  479. X    bit_bucket = fopen("/dev/null", "w");
  480. X    edit = TRUE;
  481. X    gold = case_sen = FALSE;
  482. X    shell_fork = TRUE;
  483. X    strings_init();
  484. X    ee_init();
  485. X    if (argc > 0 )
  486. X        get_options(argc, argv);
  487. X    set_up_term();
  488. X    if (right_margin == 0)
  489. X        right_margin = COLS - 1;
  490. X    if (top_of_stack == NULL)
  491. X    {
  492. X        wprintw(com_win, no_file_string);
  493. X        wrefresh(com_win);
  494. X    }
  495. X    else
  496. X        check_fp();
  497. X
  498. X    clear_com_win = TRUE;
  499. X
  500. X    while(edit) 
  501. X    {
  502. X        wrefresh(text_win);
  503. X        in = wgetch(text_win);
  504. X        if (in == -1)
  505. X            exit(0);
  506. X
  507. X        if (clear_com_win)
  508. X        {
  509. X            clear_com_win = FALSE;
  510. X            wmove(com_win, 0, 0);
  511. X            werase(com_win);
  512. X            if (!info_window)
  513. X            {
  514. X                wprintw(com_win, "%s", com_win_message);
  515. X            }
  516. X            wrefresh(com_win);
  517. X        }
  518. X
  519. X        if (in > 255)
  520. X            function_key();
  521. X        else if ((in == '\10') || (in == 127))
  522. X            delete(TRUE);
  523. X        else if ((in > 31) || (in == 9))
  524. X            insert(in);
  525. X        else if ((in >= 0) && (in <= 31))
  526. X            control();
  527. X    }
  528. X}
  529. X
  530. Xchar *resiz_line(factor, rline, rpos)    /* resize the line to length + factor*/
  531. Xint factor;        /* resize factor                */
  532. Xstruct text *rline;    /* position in line                */
  533. Xint rpos;
  534. X{
  535. X    char *rpoint;
  536. X    int resiz_var;
  537. X 
  538. X    rline->max_length += factor;
  539. X    rpoint = rline->line = realloc(rline->line, rline->max_length );
  540. X    for (resiz_var = 1 ; (resiz_var < rpos) ; resiz_var++)
  541. X        rpoint++;
  542. X    return(rpoint);
  543. X}
  544. X
  545. Xinsert(character)        /* insert character into line        */
  546. Xint character;            /* new character            */
  547. X{
  548. X    int counter;
  549. X    int value;
  550. X    char *temp;        /* temporary pointer            */
  551. X    char *temp2;        /* temporary pointer            */
  552. X
  553. X    if ((character == '\011') && (expand_tabs))
  554. X    {
  555. X        counter = len_char('\011', scr_horz);
  556. X        for (; counter > 0; counter--)
  557. X            insert(' ');
  558. X        if (auto_format)
  559. X            Auto_Format();
  560. X        return;
  561. X    }
  562. X    text_changes = TRUE;
  563. X    if ((curr_line->max_length - curr_line->line_length) < 5)
  564. X        point = resiz_line(10, curr_line, position);
  565. X    curr_line->line_length++;
  566. X    temp = point;
  567. X    counter = position;
  568. X    while (counter < curr_line->line_length)    /* find end of line */
  569. X    {
  570. X        counter++;
  571. X        temp++;
  572. X    }
  573. X    temp++;            /* increase length of line by one    */
  574. X    while (point < temp)
  575. X    {
  576. X        temp2=temp - 1;
  577. X        *temp= *temp2;    /* shift characters over by one        */
  578. X        temp--;
  579. X    }
  580. X    *point = character;    /* insert new character            */
  581. X    wclrtoeol(text_win);
  582. X    if (((character >= 0) && (character < ' ')) || (character >= 127)) /* check for TAB character*/
  583. X    {
  584. X        scr_pos = scr_horz += out_char(text_win, character, scr_horz);
  585. X        point++;
  586. X        position++;
  587. X    }
  588. X    else
  589. X    {
  590. X        waddch(text_win, character);
  591. X        scr_pos = ++scr_horz;
  592. X        point++;
  593. X        position ++;
  594. X    }
  595. X
  596. X    if ((observ_margins) && (right_margin < scr_pos))
  597. X    {
  598. X        counter = position;
  599. X        while (scr_pos > right_margin)
  600. X            prev_word();
  601. X        if (scr_pos == 0)
  602. X        {
  603. X            while (position < counter)
  604. X                right(TRUE);
  605. X        }
  606. X        else
  607. X        {
  608. X            counter -= position;
  609. X            insert_line(TRUE);
  610. X            for (value = 0; value < counter; value++)
  611. X                right(TRUE);
  612. X        }
  613. X    }
  614. X
  615. X    if ((scr_horz - horiz_offset) > last_col)
  616. X    {
  617. X        horiz_offset += 8;
  618. X        midscreen(scr_vert, point);
  619. X    }
  620. X
  621. X    if ((auto_format) && (character == ' ') && (!formatted))
  622. X        Auto_Format();
  623. X    else if ((character != ' ') && (character != '\t'))
  624. X        formatted = FALSE;
  625. X
  626. X    draw_line(scr_vert, scr_horz, point, position, curr_line->line_length);
  627. X}
  628. X
  629. Xdelete(disp)            /* delete character        */
  630. Xint disp;
  631. X{
  632. X    char *tp;
  633. X    char *temp2;
  634. X    struct text *temp_buff;
  635. X    int temp_vert;
  636. X    int temp_pos;
  637. X
  638. X    if (point != curr_line->line)    /* if not at beginning of line    */
  639. X    {
  640. X        text_changes = TRUE;
  641. X        temp2 = tp = point;
  642. X        tp--;
  643. X        point--;
  644. X        if ((*tp >= '\000') && (*tp < ' '))    /* check for TAB    */
  645. X            scanline(tp);
  646. X        else
  647. X            --scr_horz;
  648. X        scr_pos = scr_horz;
  649. X        if (in == 8)
  650. X            d_char = *point;    /* save deleted character  */
  651. X        temp_pos = --position;
  652. X        curr_line->line_length--;
  653. X        while (temp_pos <= curr_line->line_length)
  654. X        {
  655. X            temp_pos++;
  656. X            *tp= *temp2;
  657. X            tp++;
  658. X            temp2++;
  659. X        }
  660. X        if (scr_horz < horiz_offset)
  661. X        {
  662. X            horiz_offset -= 8;
  663. X            midscreen(scr_vert, point);
  664. X        }
  665. X    }
  666. X    else if (curr_line->prev_line != NULL)
  667. X    {
  668. X        text_changes = TRUE;
  669. X        left(disp);            /* go to previous line    */
  670. X        temp_buff = curr_line->next_line;
  671. X        point = resiz_line(temp_buff->line_length, curr_line, position);
  672. X        if (temp_buff->next_line != NULL)
  673. X            temp_buff->next_line->prev_line = curr_line;
  674. X        curr_line->next_line = temp_buff->next_line;
  675. X        temp2 = temp_buff->line;
  676. X        if (in == 8)
  677. X            d_char = '\n';
  678. X        tp = point;
  679. X        temp_pos = 1;
  680. X        while (temp_pos < temp_buff->line_length)
  681. X        {
  682. X            curr_line->line_length++;
  683. X            temp_pos++;
  684. X            *tp = *temp2;
  685. X            tp++;
  686. X            temp2++;
  687. X        }
  688. X        *tp = NULL;
  689. X        free(temp_buff->line);
  690. X        free(temp_buff);
  691. X        temp_buff = curr_line;
  692. X        temp_vert = scr_vert;
  693. X        scr_pos = scr_horz;
  694. X        if (scr_vert < last_line)
  695. X        {
  696. X            wmove(text_win, scr_vert + 1, 0);
  697. X            wdeleteln(text_win);
  698. X        }
  699. X        while ((temp_buff != NULL) && (temp_vert < last_line))
  700. X        {
  701. X            temp_buff = temp_buff->next_line;
  702. X            temp_vert++;
  703. X        }
  704. X        if ((temp_vert == last_line) && (temp_buff != NULL))
  705. X        {
  706. X            tp = temp_buff->line;
  707. X            wmove(text_win, last_line,0);
  708. X            wclrtobot(text_win);
  709. X            draw_line(last_line, 0, tp, 1, temp_buff->line_length);
  710. X            wmove(text_win, scr_vert, (scr_horz - horiz_offset));
  711. X        }
  712. X    }
  713. X    draw_line(scr_vert, scr_horz, point, position, curr_line->line_length);
  714. X    formatted = FALSE;
  715. X}
  716. X
  717. Xscanline(pos)    /* find the proper horizontal position for the pointer    */
  718. Xchar *pos;
  719. X{
  720. X    int temp;
  721. X    char *ptr;
  722. X
  723. X    ptr = curr_line->line;
  724. X    temp = 0;
  725. X    while (ptr < pos)
  726. X    {
  727. X        if ((*ptr >= 0) && (*ptr <= 8))
  728. X            temp += 2;
  729. X        else if (*ptr == 9)
  730. X            temp += tabshift(temp);
  731. X        else if ((*ptr >= 10) && (*ptr <= 31))
  732. X            temp += 2;
  733. X        else if ((*ptr >= 32) && (*ptr < 127))
  734. X            temp++;
  735. X        else if (*ptr == 127)
  736. X            temp += 2;
  737. X        else if (!eightbit)
  738. X            temp += 5;
  739. X        else
  740. X            temp++;
  741. X        ptr++;
  742. X    }
  743. X    scr_horz = temp;
  744. X    if ((scr_horz - horiz_offset) > last_col)
  745. X    {
  746. X        horiz_offset = (scr_horz - (scr_horz % 8)) - (COLS - 8);
  747. X        midscreen(scr_vert, point);
  748. X    }
  749. X    else if (scr_horz < horiz_offset)
  750. X    {
  751. X        horiz_offset = max(0, (scr_horz - (scr_horz % 8)));
  752. X        midscreen(scr_vert, point);
  753. X    }
  754. X}
  755. X
  756. Xint tabshift(temp_int)        /* give the number of spaces to shift    */
  757. Xint temp_int;
  758. X{
  759. X    int leftover;
  760. X
  761. X    leftover = ((temp_int + 1) % 8);
  762. X    if (leftover == 0)
  763. X        return (1);
  764. X    else
  765. X        return (9 - leftover);
  766. X}
  767. X
  768. Xout_char(window, character, column)    /* output non-printing character */
  769. XWINDOW *window;
  770. Xchar character;
  771. Xint column;
  772. X{
  773. X    int i1, i2;
  774. X    char *string;
  775. X    char string2[8];
  776. X
  777. X    if (character == TAB)
  778. X    {
  779. X        i1 = tabshift(column);
  780. X        for (i2 = 0; 
  781. X          (i2 < i1) && (((column+i2+1)-horiz_offset) < last_col); i2++)
  782. X        {
  783. X            waddch(window, ' ');
  784. X        }
  785. X        return(i1);
  786. X    }
  787. X    else if ((character >= '\0') && (character < ' '))
  788. X    {
  789. X        string = table[character];
  790. X    }
  791. X    else if ((character < 0) || (character >= 127))
  792. X    {
  793. X        if (character == 127)
  794. X            string = "^?";
  795. X        else if (!eightbit)
  796. X        {
  797. X            sprintf(string2, "<%d>", (character < 0) ? (character + 256) : character);
  798. X            string = string2;
  799. X        }
  800. X        else
  801. X        {
  802. X            waddch(window, character);
  803. X            return(1);
  804. X        }
  805. X    }
  806. X    else
  807. X    {
  808. X        waddch(window, character);
  809. X        return(1);
  810. X    }
  811. X    for (i2 = 0; (string[i2] != NULL) && (((column+i2+1)-horiz_offset) < last_col); i2++)
  812. X        waddch(window, string[i2]);
  813. X    return(strlen(string));
  814. X}
  815. X
  816. Xlen_char(character, column)    /* return the length of the character    */
  817. Xchar character;
  818. Xint column;    /* the column must be known to provide spacing for tabs    */
  819. X{
  820. X    int length;
  821. X
  822. X    if (character == '\t')
  823. X        length = tabshift(column);
  824. X    else if ((character >= 0) && (character < 32))
  825. X        length = 2;
  826. X    else if ((character >= 32) && (character <= 126))
  827. X        length = 1;
  828. X    else if (character == 127)
  829. X        length = 2;
  830. X    else if (((character > 126) || (character < 0)) && (!eightbit))
  831. X        length = 5;
  832. X    else
  833. X        length = 1;
  834. X
  835. X    return(length);
  836. X}
  837. X
  838. Xdraw_line(vertical, horiz, ptr, t_pos, length)    /* redraw line from current position */
  839. Xint vertical;    /* current vertical position on screen        */
  840. Xint horiz;    /* current horizontal position on screen    */
  841. Xchar *ptr;    /* pointer to line                */
  842. Xint t_pos;    /* current position (offset in bytes) from bol    */
  843. Xint length;    /* length (in bytes) of line            */
  844. X{
  845. X    int d;        /* partial length of special or tab char to display  */
  846. X    char *temp;    /* temporary pointer to position in line         */
  847. X    int abs_column;    /* offset in screen units from begin of line         */
  848. X    int column;    /* horizontal position on screen             */
  849. X    int row;    /* vertical position on screen                 */
  850. X    int posit;    /* temporary position indicator within line         */
  851. X
  852. X    abs_column = horiz;
  853. X    column = horiz - horiz_offset;
  854. X    row = vertical;
  855. X    temp = ptr;
  856. X    d = 0;
  857. X    posit = t_pos;
  858. X    if (column < 0)
  859. X    {
  860. X        wmove(text_win, row, 0);
  861. X        wclrtoeol(text_win);
  862. X    }
  863. X    while (column < 0)
  864. X    {
  865. X        d = len_char(*temp, abs_column);
  866. X        abs_column += d;
  867. X        column += d;
  868. X        posit++;
  869. X        temp++;
  870. X    }
  871. X    wmove(text_win, row, column);
  872. X    wclrtoeol(text_win);
  873. X    while ((posit < length) && (column <= last_col))
  874. X    {
  875. X        if ((*temp < 32) || (*temp == 127))
  876. X        {
  877. X            column += len_char(*temp, abs_column);
  878. X            abs_column += out_char(text_win, *temp, abs_column);
  879. X        }
  880. X        else
  881. X        {
  882. X            abs_column++;
  883. X            column++;
  884. X            waddch(text_win, *temp);
  885. X        }
  886. X        posit++;
  887. X        temp++;
  888. X    }
  889. X    if (column < last_col)
  890. X        wclrtoeol(text_win);
  891. X    wmove(text_win, vertical, (horiz - horiz_offset));
  892. X}
  893. X
  894. Xinsert_line(disp)            /* insert new line        */
  895. Xint disp;
  896. X{
  897. X    int temp_pos;
  898. X    int temp_pos2;
  899. X    char *temp;
  900. X    char *extra;
  901. X    struct text *temp_nod;
  902. X
  903. X    text_changes = TRUE;
  904. X    wmove(text_win, scr_vert, (scr_horz - horiz_offset));
  905. X    wclrtoeol(text_win);
  906. X    temp_nod= txtalloc();
  907. X    temp_nod->line = extra= malloc(10);
  908. X    temp_nod->line_length = 1;
  909. X    temp_nod->max_length = 10;
  910. X    temp_nod->line_number = curr_line->line_number + 1;
  911. X    temp_nod->next_line = curr_line->next_line;
  912. X    if (temp_nod->next_line != NULL)
  913. X        temp_nod->next_line->prev_line = temp_nod;
  914. X    temp_nod->prev_line = curr_line;
  915. X    curr_line->next_line = temp_nod;
  916. X    temp_pos2 = position;
  917. X    temp = point;
  918. X    if (temp_pos2 < curr_line->line_length)
  919. X    {
  920. X        temp_pos = 1;
  921. X        while (temp_pos2 < curr_line->line_length)
  922. X        {
  923. X            if ((temp_nod->max_length - temp_nod->line_length)< 5)
  924. X                extra = resiz_line(10, temp_nod, temp_pos);
  925. X            temp_nod->line_length++;
  926. X            temp_pos++;
  927. X            temp_pos2++;
  928. X            *extra= *temp;
  929. X            extra++;
  930. X            temp++;
  931. X        }
  932. X        temp=point;
  933. X        *temp= NULL;
  934. X        temp = resiz_line((1 - temp_nod->line_length), curr_line, position);
  935. X        curr_line->line_length = 1 + temp - curr_line->line;
  936. X    }
  937. X    curr_line->line_length = position;
  938. X    curr_line = temp_nod;
  939. X    *extra = NULL;
  940. X    position = 1;
  941. X    point= curr_line->line;
  942. X    if (disp)
  943. X    {
  944. X        if (scr_vert < last_line)
  945. X        {
  946. X            scr_vert++;
  947. X            wclrtoeol(text_win);
  948. X            wmove(text_win, scr_vert, 0);
  949. X            winsertln(text_win);
  950. X        }
  951. X        else
  952. X        {
  953. X            wmove(text_win, 0,0);
  954. X            wdeleteln(text_win);
  955. X            wmove(text_win, last_line,0);
  956. X            wclrtobot(text_win);
  957. X        }
  958. X        scr_pos = scr_horz = 0;
  959. X        if (horiz_offset)
  960. X        {
  961. X            horiz_offset = 0;
  962. X            midscreen(scr_vert, point);
  963. X        }
  964. X        draw_line(scr_vert, scr_horz, point, position,
  965. X            curr_line->line_length);
  966. X    }
  967. X}
  968. X
  969. Xstruct text *txtalloc()        /* allocate space for line structure    */
  970. X{
  971. X    return((struct text *) malloc(sizeof( struct text)));
  972. X}
  973. X
  974. Xstruct files *name_alloc()    /* allocate space for file name list node */
  975. X{
  976. X    return((struct files *) malloc(sizeof( struct files)));
  977. X}
  978. X
  979. Xchar *next_word(string)        /* move to next word in string        */
  980. Xchar *string;
  981. X{
  982. X    while ((*string != NULL) && ((*string != 32) && (*string != 9)))
  983. X        string++;
  984. X    while ((*string != NULL) && ((*string == 32) || (*string == 9)))
  985. X        string++;
  986. X    return(string);
  987. X}
  988. X
  989. Xprev_word()    /* move to start of previous word in text    */
  990. X{
  991. X    if (position != 1)
  992. X    {
  993. X        if ((position != 1) && ((point[-1] == ' ') || (point[-1] == '\t')))
  994. X        {    /* if at the start of a word    */
  995. X            while ((position != 1) && ((*point != ' ') && (*point != '\t')))
  996. X                left(TRUE);
  997. X        }
  998. X        while ((position != 1) && ((*point == ' ') || (*point == '\t')))
  999. X            left(TRUE);
  1000. X        while ((position != 1) && ((*point != ' ') && (*point != '\t')))
  1001. X            left(TRUE);
  1002. X        if ((position != 1) && ((*point == ' ') || (*point == '\t')))
  1003. X            right(TRUE);
  1004. X    }
  1005. X    else
  1006. X        left(TRUE);
  1007. X}
  1008. X
  1009. Xcontrol()            /* use control for commands        */
  1010. X{
  1011. X    char *string;
  1012. X
  1013. X    if (in == 1)        /* control a    */
  1014. X    {
  1015. X        string = get_string(ascii_code_str, TRUE);
  1016. X        if (*string != NULL)
  1017. X        {
  1018. X            in = atoi(string);
  1019. X            wmove(text_win, scr_vert, (scr_horz - horiz_offset));
  1020. X            insert(in);
  1021. X        }
  1022. X        free(string);
  1023. X    }
  1024. X    else if (in == 2)    /* control b    */
  1025. X        bottom();
  1026. X    else if (in == 3)    /* control c    */
  1027. X    {
  1028. X        command_prompt();
  1029. X    }
  1030. X    else if (in == 4)    /* control d    */
  1031. X        down();
  1032. X    else if (in == 5)    /* control e    */
  1033. X        search_prompt();
  1034. X    else if (in == 6)    /* control f    */
  1035. X        undel_char();
  1036. X    else if (in == 7)    /* control g    */
  1037. X        bol();
  1038. X    else if (in == 8)    /* control h    */
  1039. X        delete(TRUE);
  1040. X    else if (in == 9)    /* control i    */
  1041. X        ;
  1042. X    else if (in == 10)    /* control j    */
  1043. X        insert_line(TRUE);
  1044. X    else if (in == 11)    /* control k    */
  1045. X        del_char();
  1046. X    else if (in == 12)    /* control l    */
  1047. X        left(TRUE);
  1048. X    else if (in == 13)    /* control m    */
  1049. X        insert_line(TRUE);
  1050. X    else if (in == 14)    /* control n    */
  1051. X        move_rel("d", max(5, (last_line - 5)));
  1052. X    else if (in == 15)    /* control o    */
  1053. X        eol();
  1054. X    else if (in == 16)    /* control p    */
  1055. X        move_rel("u", max(5, (last_line - 5)));
  1056. X    else if (in == 17)    /* control q    */
  1057. X        ;
  1058. X    else if (in == 18)    /* control r    */
  1059. X        right(TRUE);
  1060. X    else if (in == 19)    /* control s    */
  1061. X        ;
  1062. X    else if (in == 20)    /* control t    */
  1063. X        top();
  1064. X    else if (in == 21)    /* control u    */
  1065. X        up();
  1066. X    else if (in == 22)    /* control v    */
  1067. X        undel_word();
  1068. X    else if (in == 23)    /* control w    */
  1069. X        del_word();
  1070. X    else if (in == 24)    /* control x    */
  1071. X        search(TRUE);
  1072. X    else if (in == 25)    /* control y    */
  1073. X        del_line();
  1074. X    else if (in == 26)    /* control z    */
  1075. X        undel_line();
  1076. X    else if (in == 27)    /* control [ (escape)    */
  1077. X    {
  1078. X        menu_op(main_menu);
  1079. X    }    
  1080. X}
  1081. X
  1082. Xbottom()            /* go to bottom of file            */
  1083. X{
  1084. X    while (curr_line->next_line != NULL)
  1085. X        curr_line = curr_line->next_line;
  1086. X    point = curr_line->line;
  1087. X    if (horiz_offset)
  1088. X        horiz_offset = 0;
  1089. X    position = 1;
  1090. X    midscreen(last_line, point);
  1091. X    scr_pos = scr_horz;
  1092. X}
  1093. X
  1094. Xtop()                /* go to top of file            */
  1095. X{
  1096. X    while (curr_line->prev_line != NULL)
  1097. X        curr_line = curr_line->prev_line;
  1098. X    point = curr_line->line;
  1099. X    if (horiz_offset)
  1100. X        horiz_offset = 0;
  1101. X    position = 1;
  1102. X    midscreen(0, point);
  1103. X    scr_pos = scr_horz;
  1104. X}
  1105. X
  1106. Xnextline()            /* move pointers to start of next line    */
  1107. X{
  1108. X    curr_line = curr_line->next_line;
  1109. X    point = curr_line->line;
  1110. X    position = 1;
  1111. X    if (scr_vert == last_line)
  1112. X    {
  1113. X        wmove(text_win, 0,0);
  1114. X        wdeleteln(text_win);
  1115. X        wmove(text_win, last_line,0);
  1116. X        wclrtobot(text_win);
  1117. X        draw_line(last_line,0,point,1,curr_line->line_length);
  1118. X    }
  1119. X    else
  1120. X        scr_vert++;
  1121. X}
  1122. X
  1123. Xprevline()            /* move pointers to start of previous line*/
  1124. X{
  1125. X    curr_line = curr_line->prev_line;
  1126. X    point = curr_line->line;
  1127. X    position = 1;
  1128. X    if (scr_vert == 0)
  1129. X    {
  1130. X        winsertln(text_win);
  1131. X        draw_line(0,0,point,1,curr_line->line_length);
  1132. X    }
  1133. X    else
  1134. X        scr_vert--;
  1135. X    while (position < curr_line->line_length)
  1136. X    {
  1137. X        position++;
  1138. X        point++;
  1139. X    }
  1140. X}
  1141. X
  1142. Xleft(disp)                /* move left one character    */
  1143. Xint disp;
  1144. X{
  1145. X    if (point != curr_line->line)    /* if not at begin of line    */
  1146. X    {
  1147. X        point--;
  1148. X        position--;
  1149. X        scanline(point);
  1150. X        wmove(text_win, scr_vert, (scr_horz - horiz_offset));
  1151. X        scr_pos = scr_horz;
  1152. X    }
  1153. X    else if (curr_line->prev_line != NULL)
  1154. X    {
  1155. X        if (!disp)
  1156. X        {
  1157. X            curr_line = curr_line->prev_line;
  1158. X            point = curr_line->line + curr_line->line_length;
  1159. X            position = curr_line->line_length;
  1160. X            return;
  1161. X        }
  1162. X        position = 1;
  1163. X        prevline();
  1164. X        scanline(point);
  1165. X        scr_pos = scr_horz;
  1166. X        wmove(text_win, scr_vert, (scr_horz - horiz_offset));
  1167. X    }
  1168. X}
  1169. X
  1170. Xright(disp)                /* move right one character    */
  1171. Xint disp;
  1172. X{
  1173. X    if (position < curr_line->line_length)
  1174. X    {
  1175. X        point++;
  1176. X        position++;
  1177. X        scanline(point);
  1178. X        wmove(text_win, scr_vert, (scr_horz - horiz_offset));
  1179. X        scr_pos = scr_horz;
  1180. X    }
  1181. X    else if (curr_line->next_line != NULL)
  1182. X    {
  1183. X        if (!disp)
  1184. X        {
  1185. X            curr_line = curr_line->next_line;
  1186. X            point = curr_line->line;
  1187. X            position = 1;
  1188. X            return;
  1189. X        }
  1190. X        nextline();
  1191. X        scr_pos = scr_horz = 0;
  1192. X        if (horiz_offset)
  1193. X        {
  1194. X            horiz_offset = 0;
  1195. X            midscreen(scr_vert, point);
  1196. X        }
  1197. X        wmove(text_win, scr_vert, (scr_horz - horiz_offset));
  1198. X        position = 1;    
  1199. X    }
  1200. X}
  1201. X
  1202. Xfind_pos()        /* move to the same column as on other line    */
  1203. X{
  1204. X    scr_horz = 0;
  1205. X    position = 1;
  1206. X    while ((scr_horz < scr_pos) && (position < curr_line->line_length))
  1207. X    {
  1208. X        if (*point == 9)
  1209. X            scr_horz += tabshift(scr_horz);
  1210. X        else if ((*point >= '\0') && (*point < ' '))
  1211. X            scr_horz += 2;
  1212. X        else
  1213. X            scr_horz++;
  1214. X        position++;
  1215. X        point++;
  1216. X    }
  1217. X    if ((scr_horz - horiz_offset) > last_col)
  1218. X    {
  1219. X        horiz_offset = (scr_horz - (scr_horz % 8)) - (COLS - 8);
  1220. X        midscreen(scr_vert, point);
  1221. X    }
  1222. X    else if (scr_horz < horiz_offset)
  1223. X    {
  1224. X        horiz_offset = max(0, (scr_horz - (scr_horz % 8)));
  1225. X        midscreen(scr_vert, point);
  1226. X    }
  1227. X    wmove(text_win, scr_vert, (scr_horz - horiz_offset));
  1228. X}
  1229. X
  1230. Xup()                    /* move up one line        */
  1231. X{
  1232. X    if (curr_line->prev_line != NULL)
  1233. X    {
  1234. X        prevline();
  1235. X        point = curr_line->line;
  1236. X        find_pos();
  1237. X    }
  1238. X}
  1239. X
  1240. Xdown()                    /* move down one line        */
  1241. X{
  1242. X    if (curr_line->next_line != NULL)
  1243. X    {
  1244. X        nextline();
  1245. X        find_pos();
  1246. X    }
  1247. X}
  1248. X
  1249. Xfunction_key()                /* process function key        */
  1250. X{
  1251. X    if (in == KEY_LEFT)
  1252. X        left(TRUE);
  1253. X    else if (in == KEY_RIGHT)
  1254. X        right(TRUE);
  1255. X    else if ( in == KEY_HOME)
  1256. X        top();
  1257. X    else if ( in == KEY_UP)
  1258. X        up();
  1259. X    else if (in == KEY_DOWN)
  1260. X        down();
  1261. X    else if (in == KEY_NPAGE)
  1262. X        move_rel("d", max( 5, (last_line - 5)));
  1263. X    else if (in == KEY_PPAGE)
  1264. X        move_rel("u", max(5, (last_line - 5)));
  1265. X    else if (in == KEY_DL)
  1266. X        del_line();
  1267. X    else if (in == KEY_DC)
  1268. X        del_char();
  1269. X    else if (in == KEY_BACKSPACE)
  1270. X        delete(TRUE);
  1271. X    else if (in == KEY_IL)
  1272. X    {        /* insert a line before current line    */
  1273. X        insert_line(TRUE);
  1274. X        left(TRUE);
  1275. X    }
  1276. X    else if (in == KEY_F(1))
  1277. X        gold = !gold;
  1278. X    else if (in == KEY_F(2))
  1279. X    {
  1280. X        if (gold)
  1281. X        {
  1282. X            gold = FALSE;
  1283. X            undel_line();
  1284. X        }
  1285. X        else
  1286. X            undel_char();
  1287. X    }
  1288. X    else if (in == KEY_F(3))
  1289. X    {
  1290. X        if (gold)
  1291. X        {
  1292. X            gold = FALSE;
  1293. X            undel_word();
  1294. X        }
  1295. X        else
  1296. X            del_word();
  1297. X    }
  1298. X    else if (in == KEY_F(4))
  1299. X    {
  1300. X        if (gold)
  1301. X        {
  1302. X            gold = FALSE;
  1303. X            paint_info_win();
  1304. X            midscreen(scr_vert, point);
  1305. X        }
  1306. X        else
  1307. X            adv_word();
  1308. X    }
  1309. X    else if (in == KEY_F(5))
  1310. X    {
  1311. X        if (gold)
  1312. X        {
  1313. X            gold = FALSE;
  1314. X            search_prompt();
  1315. X        }
  1316. X        else
  1317. X            search(TRUE);
  1318. X    }
  1319. X    else if (in == KEY_F(6))
  1320. X    {
  1321. X        if (gold)
  1322. X        {
  1323. X            gold = FALSE;
  1324. X            bottom();
  1325. X        }
  1326. X        else
  1327. X            top();
  1328. X    }
  1329. X    else if (in == KEY_F(7))
  1330. X    {
  1331. X        if (gold)
  1332. X        {
  1333. X            gold = FALSE;
  1334. X            eol();
  1335. X        }
  1336. X        else
  1337. X            bol();
  1338. X    }
  1339. X    else if (in == KEY_F(8))
  1340. X    {
  1341. X        if (gold)
  1342. X        {
  1343. X            gold = FALSE;
  1344. X            command_prompt();
  1345. X        } 
  1346. X        else
  1347. X            adv_line();
  1348. X    }
  1349. X}
  1350. X
  1351. Xprint_buffer()
  1352. X{
  1353. X    char buffer[256];
  1354. X
  1355. X    sprintf(buffer, ">!%s", print_command);
  1356. X    wmove(com_win, 0, 0);
  1357. X    wclrtoeol(com_win);
  1358. X    wprintw(com_win, printer_msg_str, print_command);
  1359. X    wrefresh(com_win);
  1360. X    command(buffer);
  1361. X}
  1362. X
  1363. Xcommand_prompt()
  1364. X{
  1365. X    char *cmd_str;
  1366. X    int result;
  1367. X
  1368. X    info_type = COMMANDS;
  1369. X    paint_info_win();
  1370. X    cmd_str = get_string(command_str, TRUE);
  1371. X    if ((result = unique_test(cmd_str, commands)) != 1)
  1372. X    {
  1373. X        werase(com_win);
  1374. X        wmove(com_win, 0, 0);
  1375. X        if (result == 0)
  1376. X            wprintw(com_win, unkn_cmd_str, cmd_str);
  1377. X        else
  1378. X            wprintw(com_win, non_unique_cmd_msg);
  1379. X
  1380. X        wrefresh(com_win);
  1381. X
  1382. X        info_type = CONTROL_KEYS;
  1383. X        paint_info_win();
  1384. X
  1385. X        if (cmd_str != NULL)
  1386. X            free(cmd_str);
  1387. X        return;
  1388. X    }
  1389. X    command(cmd_str);
  1390. X    wrefresh(com_win);
  1391. X    wmove(text_win, scr_vert, (scr_horz - horiz_offset));
  1392. X    info_type = CONTROL_KEYS;
  1393. X    paint_info_win();
  1394. X    if (cmd_str != NULL)
  1395. X        free(cmd_str);
  1396. X}
  1397. X
  1398. Xcommand(cmd_str1)        /* process commands from keyboard    */
  1399. Xchar *cmd_str1;
  1400. X{
  1401. X    char *cmd_str2 = NULL;
  1402. X    char *cmd_str = cmd_str1;
  1403. X
  1404. X    clear_com_win = TRUE;
  1405. X    if (compare(cmd_str, HELP, FALSE))
  1406. X        help();
  1407. X    else if (compare(cmd_str, WRITE, FALSE))
  1408. X    {
  1409. X        if (restrict_mode())
  1410. X        {
  1411. X            return;
  1412. X        }
  1413. X        cmd_str = next_word(cmd_str);
  1414. X        if (*cmd_str == NULL)
  1415. X        {
  1416. X            cmd_str = cmd_str2 = get_string(file_write_prompt_str, TRUE);
  1417. X        }
  1418. X        tmp_file = resolve_name(cmd_str);
  1419. X        if (write_file(tmp_file))
  1420. X            ;
  1421. X        if (tmp_file != cmd_str)
  1422. X            free(tmp_file);
  1423. X    }
  1424. X    else if (compare(cmd_str, READ, FALSE))
  1425. X    {
  1426. X        if (restrict_mode())
  1427. X        {
  1428. X            return;
  1429. X        }
  1430. X        cmd_str = next_word(cmd_str);
  1431. X        if (*cmd_str == NULL)
  1432. X        {
  1433. X            cmd_str = cmd_str2 = get_string(file_read_prompt_str, TRUE);
  1434. X        }
  1435. X        tmp_file = cmd_str;
  1436. X        recv_file = TRUE;
  1437. X        tmp_file = resolve_name(cmd_str);
  1438. X        check_fp();
  1439. X        if (tmp_file != cmd_str)
  1440. X            free(tmp_file);
  1441. X    }
  1442. X    else if (compare(cmd_str, LINE, FALSE))
  1443. X    {
  1444. X        wmove(com_win, 0, 0);
  1445. X        wclrtoeol(com_win);
  1446. X        wprintw(com_win, line_num_str, curr_line->line_number);
  1447. X        wprintw(com_win, line_len_str, curr_line->line_length);
  1448. X    }
  1449. X    else if (compare(cmd_str, FILE_str, FALSE))
  1450. X    {
  1451. X        wmove(com_win, 0, 0);
  1452. X        wclrtoeol(com_win);
  1453. X        wprintw(com_win, current_file_str, in_file_name);
  1454. X    }
  1455. X    else if ((*cmd_str >= '0') && (*cmd_str <= '9'))
  1456. X        goto_line(cmd_str);
  1457. X    else if (compare(cmd_str, CHARACTER, FALSE))
  1458. X    {
  1459. X        wmove(com_win, 0, 0);
  1460. X        wclrtoeol(com_win);
  1461. X        if (*point >= '\0')
  1462. X            wprintw(com_win, char_str, *point);
  1463. X        else
  1464. X            wprintw(com_win, char_str, (*point + 256));
  1465. X    }
  1466. X    else if (compare(cmd_str, REDRAW, FALSE))
  1467. X        redraw();
  1468. X    else if (compare(cmd_str, RESEQUENCE, FALSE))
  1469. X    {
  1470. X        tmp_line = first_line->next_line;
  1471. X        while (tmp_line != NULL)
  1472. X        {
  1473. X        tmp_line->line_number = tmp_line->prev_line->line_number + 1;
  1474. X            tmp_line = tmp_line->next_line;
  1475. X        }
  1476. X    }
  1477. X    else if (compare(cmd_str, AUTHOR, FALSE))
  1478. X    {
  1479. X        wmove(com_win, 0, 0);
  1480. X        wclrtoeol(com_win);
  1481. X        wprintw(com_win, "written by Hugh Mahon");
  1482. X    }
  1483. X    else if (compare(cmd_str, VERSION, FALSE))
  1484. X    {
  1485. X        wmove(com_win, 0, 0);
  1486. X        wclrtoeol(com_win);
  1487. X        wprintw(com_win, "%s", version);
  1488. X    }
  1489. X    else if (compare(cmd_str, CASE, FALSE))
  1490. X        case_sen = TRUE;
  1491. X    else if (compare(cmd_str, NOCASE, FALSE))
  1492. X        case_sen = FALSE;
  1493. X    else if (compare(cmd_str, EXPAND, FALSE))
  1494. X        expand_tabs = TRUE;
  1495. X    else if (compare(cmd_str, NOEXPAND, FALSE))
  1496. X        expand_tabs = FALSE;
  1497. X    else if (compare(cmd_str, Exit_string, FALSE))
  1498. X        finish();
  1499. X    else if (compare(cmd_str, QUIT_string, FALSE))
  1500. X        quit(0);
  1501. X    else if (*cmd_str == '!')
  1502. X    {
  1503. X        cmd_str++;
  1504. X        if ((*cmd_str == ' ') || (*cmd_str == 9))
  1505. X            cmd_str = next_word(cmd_str);
  1506. X        sh_command(cmd_str);
  1507. X    }
  1508. X    else if ((*cmd_str == '<') && (!in_pipe))
  1509. X    {
  1510. X        in_pipe = TRUE;
  1511. X        shell_fork = FALSE;
  1512. X        cmd_str++;
  1513. X        if ((*cmd_str == ' ') || (*cmd_str == '\t'))
  1514. X            cmd_str = next_word(cmd_str);
  1515. X        command(cmd_str);
  1516. X        in_pipe = FALSE;
  1517. X        shell_fork = TRUE;
  1518. X    }
  1519. X    else if ((*cmd_str == '>') && (!out_pipe))
  1520. X    {
  1521. X        out_pipe = TRUE;
  1522. X        cmd_str++;
  1523. X        if ((*cmd_str == ' ') || (*cmd_str == '\t'))
  1524. X            cmd_str = next_word(cmd_str);
  1525. X        command(cmd_str);
  1526. X        out_pipe = FALSE;
  1527. X    }
  1528. X    else
  1529. X    {
  1530. X        wmove(com_win, 0, 0);
  1531. X        wclrtoeol(com_win);
  1532. X        wprintw(com_win, unkn_cmd_str, cmd_str);
  1533. X    }
  1534. X    if (cmd_str2 != NULL)
  1535. X        free(cmd_str2);
  1536. X}
  1537. X
  1538. Xscan(line, offset, column)    /* determine horizontal position for get_string    */
  1539. Xchar *line;
  1540. Xint offset;
  1541. Xint column;
  1542. X{
  1543. X    char *stemp;
  1544. X    int i;
  1545. X    int j;
  1546. X
  1547. X    stemp = line;
  1548. X    i = 0;
  1549. X    j = column;
  1550. X    while (i < offset)
  1551. X    {
  1552. X        i++;
  1553. X        j += len_char(*stemp, j);
  1554. X        stemp++;
  1555. X    }
  1556. X    return(j);
  1557. X}
  1558. X
  1559. Xchar *get_string(prompt, advance)    /* read string from input on command line */
  1560. Xchar *prompt;        /* string containing user prompt message    */
  1561. Xint advance;        /* if true, skip leading spaces and tabs    */
  1562. X{
  1563. X    char *string;
  1564. X    char *tmp_string;
  1565. X    char *nam_str;
  1566. X    char *g_point;
  1567. X    int tmp_int;
  1568. X    int g_horz, g_position, g_pos;
  1569. X    int esc_flag;
  1570. X
  1571. X    g_point = tmp_string = malloc(512);
  1572. X    wmove(com_win,0,0);
  1573. X    wclrtoeol(com_win);
  1574. X    waddstr(com_win, prompt);
  1575. X    wrefresh(com_win);
  1576. X    nam_str = tmp_string;
  1577. X    clear_com_win = TRUE;
  1578. X    g_horz = g_position = scan(prompt, strlen(prompt), 0);
  1579. X    g_pos = 0;
  1580. X    do
  1581. X    {
  1582. X        esc_flag = FALSE;
  1583. X        in = wgetch(com_win);
  1584. X        if (in == -1)
  1585. X            exit(0);
  1586. X        if (((in == 8) || (in == 127)) && (g_pos > 0))
  1587. X        {
  1588. X            tmp_int = g_horz;
  1589. X            g_pos--;
  1590. X            g_horz = scan(g_point, g_pos, g_position);
  1591. X            tmp_int = tmp_int - g_horz;
  1592. X            for (; 0 < tmp_int; tmp_int--)
  1593. X            {
  1594. X                if ((g_horz+tmp_int) < (last_col - 1))
  1595. X                {
  1596. X                    waddch(com_win, '\010');
  1597. X                    waddch(com_win, ' ');
  1598. X                    waddch(com_win, '\010');
  1599. X                }
  1600. X            }
  1601. X            nam_str--;
  1602. X        }
  1603. X        else if ((in != 8) && (in != 127) && (in != '\n') && (in != '\r'))
  1604. X        {
  1605. X            if (in == '\026')    /* control-v, accept next character verbatim    */
  1606. X            {            /* allows entry of ^m, ^j, and ^h    */
  1607. X                esc_flag = TRUE;
  1608. X                in = wgetch(com_win);
  1609. X                if (in == -1)
  1610. X                    exit(0);
  1611. X            }
  1612. X            *nam_str = in;
  1613. X            g_pos++;
  1614. X            if (((in < ' ') || (in > 126)) && (g_horz < (last_col - 1)))
  1615. X                g_horz += out_char(com_win, in, g_horz);
  1616. X            else
  1617. X            {
  1618. X                g_horz++;
  1619. X                if (g_horz < (last_col - 1))
  1620. X                    waddch(com_win, in);
  1621. X            }
  1622. X            nam_str++;
  1623. X        }
  1624. X        wrefresh(com_win);
  1625. X        if (esc_flag)
  1626. X            in = NULL;
  1627. X    } while ((in != '\n') && (in != '\r'));
  1628. X    *nam_str = NULL;
  1629. X    nam_str = tmp_string;
  1630. X    if (((*nam_str == ' ') || (*nam_str == 9)) && (advance))
  1631. X        nam_str = next_word(nam_str);
  1632. X    string = malloc(strlen(nam_str) + 1);
  1633. X    strcpy(string, nam_str);
  1634. X    free(tmp_string);
  1635. X    wrefresh(com_win);
  1636. X    return(string);
  1637. X}
  1638. X
  1639. Xcompare(string1, string2, sensitive)    /* compare two strings    */
  1640. Xchar *string1;
  1641. Xchar *string2;
  1642. Xint sensitive;
  1643. X{
  1644. X    char *strng1;
  1645. X    char *strng2;
  1646. X    int tmp;
  1647. X    int equal;
  1648. X
  1649. X    strng1 = string1;
  1650. X    strng2 = string2;
  1651. X    tmp = 0;
  1652. X    if ((strng1 == NULL) || (strng2 == NULL) || (*strng1 == NULL) || (*strng2 == NULL))
  1653. X        return(FALSE);
  1654. X    equal = TRUE;
  1655. X    while (equal)
  1656. X    {
  1657. X        if (sensitive)
  1658. X        {
  1659. X            if (*strng1 != *strng2)
  1660. X                equal = FALSE;
  1661. X        }
  1662. X        else
  1663. X        {
  1664. X            if (toupper(*strng1) != toupper(*strng2))
  1665. X                equal = FALSE;
  1666. X        }
  1667. X        strng1++;
  1668. X        strng2++;
  1669. X        if ((*strng1 == NULL) || (*strng2 == NULL) || (*strng1 == ' ') || (*strng2 == ' '))
  1670. X            break;
  1671. X        tmp++;
  1672. X    }
  1673. X    return(equal);
  1674. X}
  1675. X
  1676. Xgoto_line(cmd_str)
  1677. Xchar *cmd_str;
  1678. X{
  1679. X    int number;
  1680. X    int i;
  1681. X    char *ptr;
  1682. X    char *direction;
  1683. X    struct text *t_line;
  1684. X
  1685. X    ptr = cmd_str;
  1686. X    i= 0;
  1687. X    while ((*ptr >='0') && (*ptr <= '9'))
  1688. X    {
  1689. X        i= i * 10 + (*ptr - '0');
  1690. X        ptr++;
  1691. X    }
  1692. X    number = i;
  1693. X    i = 0;
  1694. X    t_line = curr_line;
  1695. X    while ((t_line->line_number > number) && (t_line->prev_line != NULL))
  1696. X    {
  1697. X        i++;
  1698. X        t_line = t_line->prev_line;
  1699. X        direction = "u";
  1700. X    }
  1701. X    while ((t_line->line_number < number) && (t_line->next_line != NULL))
  1702. X    {
  1703. X        i++;
  1704. X        direction = "d";
  1705. X        t_line = t_line->next_line;
  1706. X    }
  1707. X    if ((i < 30) && (i > 0))
  1708. X    {
  1709. X        move_rel(direction, i);
  1710. X    }
  1711. X    else
  1712. X    {
  1713. X        curr_line = t_line;
  1714. X        point = curr_line->line;
  1715. X        position = 1;
  1716. X        midscreen((last_line / 2), point);
  1717. X        scr_pos = scr_horz;
  1718. X    }
  1719. X    wmove(com_win, 0, 0);
  1720. X    wclrtoeol(com_win);
  1721. X    wprintw(com_win, line_num_str, curr_line->line_number);
  1722. X    wmove(text_win, scr_vert, (scr_horz - horiz_offset));
  1723. X}
  1724. X
  1725. Xmidscreen(line, pnt)    /* put current line in middle of screen    */
  1726. Xint line;
  1727. Xchar *pnt;
  1728. X{
  1729. X    struct text *mid_line;
  1730. X    int i;
  1731. X
  1732. X    mid_line = curr_line;
  1733. X    for (i = 0; ((i < line) && (curr_line->prev_line != NULL)); i++)
  1734. X        curr_line = curr_line->prev_line;
  1735. X    scr_vert = scr_horz = 0;
  1736. X    wmove(text_win, 0, 0);
  1737. X    draw_screen();
  1738. X    scr_vert = i;
  1739. X    curr_line = mid_line;
  1740. X    scanline(pnt);
  1741. X    wmove(text_win, scr_vert, (scr_horz - horiz_offset));
  1742. X}
  1743. X
  1744. Xget_options(numargs, arguments)    /* get arguments from command line    */
  1745. Xint numargs;
  1746. Xchar *arguments[];
  1747. X{
  1748. X    char *buff;
  1749. X    int count;
  1750. X    struct files *temp_names;
  1751. X    char *name;
  1752. X    char *ptr;
  1753. X
  1754. X    /*
  1755. X     |    see if editor was invoked as 'ree' (restricted mode)
  1756. X     */
  1757. X
  1758. X    if (!(name = strrchr(arguments[0], '/')))
  1759. X        name = arguments[0];
  1760. X    else
  1761. X        name++;
  1762. X    if (!strcmp(name, "ree"))
  1763. X        restricted = TRUE;
  1764. X
  1765. X    top_of_stack = NULL;
  1766. X    input_file = FALSE;
  1767. X    recv_file = FALSE;
  1768. X    count = 1;
  1769. X    while (count < numargs)
  1770. X    {
  1771. X        buff = arguments[count];
  1772. X        if (!strcmp("-i", buff))
  1773. X        {
  1774. X            info_window = FALSE;
  1775. X        }
  1776. X        else if (!strcmp("-e", buff))
  1777. X        {
  1778. X            expand_tabs = FALSE;
  1779. X        }
  1780. X        else if (!strcmp("-h", buff))
  1781. X        {
  1782. X            nohighlight = TRUE;
  1783. X        }
  1784. X        else if (!strcmp("-?", buff))
  1785. X        {
  1786. X            fprintf(stderr, usage0, arguments[0]);
  1787. X            fprintf(stderr, usage1);
  1788. X            fprintf(stderr, usage2);
  1789. X            fprintf(stderr, usage3);
  1790. X            exit(1);
  1791. X        }
  1792. X        else
  1793. X        {
  1794. X            if (top_of_stack == NULL)
  1795. X            {
  1796. X                temp_names = top_of_stack = name_alloc();
  1797. X            }
  1798. X            else
  1799. X            {
  1800. X                temp_names->next_name = name_alloc();
  1801. X                temp_names = temp_names->next_name;
  1802. X            }
  1803. X            ptr = temp_names->name = malloc(strlen(buff) + 1);
  1804. X            while (*buff != NULL)
  1805. X            {
  1806. X                *ptr = *buff;
  1807. X                buff++;
  1808. X                ptr++;
  1809. X            }
  1810. X            *ptr = NULL;
  1811. X            temp_names->next_name = NULL;
  1812. X            input_file = TRUE;
  1813. X            recv_file = TRUE;
  1814. X        }
  1815. X        count++;
  1816. X    }
  1817. X}
  1818. X
  1819. Xcheck_fp()        /* open or close files according to flags */
  1820. X{
  1821. X    int line_num;
  1822. X    int temp;
  1823. X    struct stat buf;
  1824. X
  1825. X    clear_com_win = TRUE;
  1826. X    tmp_vert = scr_vert;
  1827. X    tmp_horz = scr_horz;
  1828. X    tmp_line = curr_line;
  1829. X    if (input_file)
  1830. X    {
  1831. X        in_file_name = tmp_file = top_of_stack->name;
  1832. X        top_of_stack = top_of_stack->next_name;
  1833. X    }
  1834. X    temp = stat(tmp_file, &buf);
  1835. X    buf.st_mode &= ~07777;
  1836. X    if ((temp != -1) && (buf.st_mode != 0100000) && (buf.st_mode != 0))
  1837. X    {
  1838. X        wprintw(com_win, file_is_dir_msg, tmp_file);
  1839. X        wrefresh(com_win);
  1840. X        if (input_file)
  1841. X            quit(0);
  1842. X        else
  1843. X            return;
  1844. X    }
  1845. X    if ((get_fd = open(tmp_file, O_RDONLY)) == -1)
  1846. X    {
  1847. X        wmove(com_win, 0, 0);
  1848. X        wclrtoeol(com_win);
  1849. X        if (input_file)
  1850. X            wprintw(com_win, new_file_msg, tmp_file);
  1851. X        else
  1852. X            wprintw(com_win, cant_open_msg, tmp_file);
  1853. X        wrefresh(com_win);
  1854. X        wmove(text_win, scr_vert, (scr_horz - horiz_offset));
  1855. X        wrefresh(text_win);
  1856. X        recv_file = FALSE;
  1857. X        input_file = FALSE;
  1858. X        return;
  1859. X    }
  1860. X    else
  1861. X        get_file(tmp_file);
  1862. X
  1863. X    recv_file = FALSE;
  1864. X    line_num = curr_line->line_number;
  1865. X    scr_vert = tmp_vert;
  1866. X    scr_horz = tmp_horz;
  1867. X    if (input_file)
  1868. X        curr_line= first_line;
  1869. X    else
  1870. X        curr_line = tmp_line;
  1871. X    point = curr_line->line;
  1872. X    draw_screen();
  1873. X    wmove(com_win, 0, 0);
  1874. X    wclrtoeol(com_win);
  1875. X    if (input_file)
  1876. X    {
  1877. X        wprintw(com_win, open_file_msg, in_file_name, line_num);
  1878. X        input_file = FALSE;
  1879. X    }
  1880. X    else
  1881. X    {
  1882. X        text_changes = TRUE;
  1883. X        if ((tmp_file != NULL) && (*tmp_file != NULL))
  1884. X            wprintw(com_win, file_read_fin_msg, tmp_file);
  1885. X    }
  1886. X    wrefresh(com_win);
  1887. X    wmove(text_win, scr_vert, (scr_horz - horiz_offset));
  1888. X    wrefresh(text_win);
  1889. X}
  1890. X
  1891. Xget_file(file_name)    /* read specified file into current buffer    */
  1892. Xchar *file_name;
  1893. X{
  1894. X    int can_read;        /* file has at least one character    */
  1895. X    int length;        /* length of line read by read        */
  1896. X    int append;        /* should text be appended to current line */
  1897. X    struct text *temp_line;
  1898. X
  1899. X    if (recv_file)        /* if reading a file            */
  1900. X    {
  1901. X        wmove(com_win, 0, 0);
  1902. X        wclrtoeol(com_win);
  1903. X        wprintw(com_win, reading_file_msg, file_name);
  1904. X        if (access(file_name, 2))    /* check permission to write */
  1905. X        {
  1906. X            if ((errno == ENOTDIR) || (errno == EACCES) || (errno == EROFS) || (errno == ETXTBSY) || (errno == EFAULT))
  1907. X                wprintw(com_win, read_only_msg);
  1908. X        }
  1909. X        wrefresh(com_win);
  1910. X    }
  1911. X    if (curr_line->line_length > 1)    /* if current line is not blank    */
  1912. X    {
  1913. X        insert_line(FALSE);
  1914. X        left(FALSE);
  1915. X        append = FALSE;
  1916. X    }
  1917. X    else
  1918. X        append = TRUE;
  1919. X    can_read = FALSE;        /* test if file has any characters  */
  1920. X    while (((length = read(get_fd, in_string, 512)) != 0) && (length != -1))
  1921. X    {
  1922. X        can_read = TRUE;  /* if set file has at least 1 character   */
  1923. X        get_line(length, in_string, &append);
  1924. X    }
  1925. X    if ((can_read) && (curr_line->line_length == 1))
  1926. X    {
  1927. X        temp_line = curr_line->prev_line;
  1928. X        temp_line->next_line = curr_line->next_line;
  1929. X        if (temp_line->next_line != NULL)
  1930. X            temp_line->next_line->prev_line = temp_line;
  1931. X        if (curr_line->line != NULL)
  1932. X            free(curr_line->line);
  1933. X        free(curr_line);
  1934. X        curr_line = temp_line;
  1935. X    }
  1936. X    if (input_file)    /* if this is the file to be edited display number of lines    */
  1937. X    {
  1938. X        wmove(com_win, 0, 0);
  1939. X        wclrtoeol(com_win);
  1940. X        wprintw(com_win, file_read_lines_msg, in_file_name, curr_line->line_number);
  1941. X        wrefresh(com_win);
  1942. X    }
  1943. X    else if (can_read)    /* not input_file and file is non-zero size */
  1944. X        text_changes = TRUE;
  1945. X
  1946. X    if (recv_file)        /* if reading a file            */
  1947. X    {
  1948. X        in = EOF;
  1949. X    }
  1950. X}
  1951. X
  1952. Xget_line(length, in_string, append)    /* read string and split into lines */
  1953. Xint length;        /* length of string read by read        */
  1954. Xchar *in_string;    /* string read by read                */
  1955. Xint *append;    /* TRUE if must append more text to end of current line    */
  1956. X{
  1957. X    char *str1;
  1958. X    char *str2;
  1959. X    int num;        /* offset from start of string        */
  1960. X    int char_count;        /* length of new line (or added portion    */
  1961. X    int temp_counter;    /* temporary counter value        */
  1962. X    struct text *tline;    /* temporary pointer to new line    */
  1963. X    int first_time;        /* if TRUE, the first time through the loop */
  1964. X
  1965. X    str2 = in_string;
  1966. X    num = 0;
  1967. X    first_time = TRUE;
  1968. X    while (num < length)
  1969. X    {
  1970. X        if (!first_time)
  1971. X        {
  1972. X            if (num < length)
  1973. X            {
  1974. X                str2++;
  1975. X                num++;
  1976. X            }
  1977. X        }
  1978. X        else
  1979. X            first_time = FALSE;
  1980. X        str1 = str2;
  1981. X        char_count = 1;
  1982. X        /* find end of line    */
  1983. X        while ((*str2 != '\n') && (num < length))
  1984. X        {
  1985. X            str2++;
  1986. X            num++;
  1987. X            char_count++;
  1988. X        }
  1989. X        if (!(*append))    /* if not append to current line, insert new one */
  1990. X        {
  1991. X            tline = txtalloc();    /* allocate data structure for next line */
  1992. X            tline->line_number = curr_line->line_number + 1;
  1993. X            tline->next_line = curr_line->next_line;
  1994. X            tline->prev_line = curr_line;
  1995. X            curr_line->next_line = tline;
  1996. X            if (tline->next_line != NULL)
  1997. X                tline->next_line->prev_line = tline;
  1998. X            curr_line = tline;
  1999. X            curr_line->line = point = (char *) malloc(char_count);
  2000. X            curr_line->line_length = char_count;
  2001. X            curr_line->max_length = char_count;
  2002. X        }
  2003. X        else
  2004. X        {
  2005. X            point = resiz_line(char_count, curr_line, curr_line->line_length); 
  2006. X            curr_line->line_length += (char_count - 1);
  2007. X        }
  2008. X        for (temp_counter = 1; temp_counter < char_count; temp_counter++)
  2009. X        {
  2010. X            *point = *str1;
  2011. X            point++;
  2012. X            str1++;
  2013. X        }
  2014. X        *point = NULL;
  2015. X        *append = FALSE;
  2016. X        if ((num == length) && (*str2 != '\n'))
  2017. X            *append = TRUE;
  2018. X    }
  2019. X}
  2020. X
  2021. END_OF_FILE
  2022.   if test 45319 -ne `wc -c <'ee.c.A'`; then
  2023.     echo shar: \"'ee.c.A'\" unpacked with wrong size!
  2024.   elif test -f 'ee.c.B'; then
  2025.     echo shar: Combining  \"'ee.c'\" \(97591 characters\)
  2026.     cat 'ee.c.A' 'ee.c.B' > 'ee.c'
  2027.     if test 97591 -ne `wc -c <'ee.c'`; then
  2028.       echo shar: \"'ee.c'\" combined with wrong size!
  2029.     else
  2030.       rm ee.c.A ee.c.B
  2031.     fi
  2032.   fi
  2033.   # end of 'ee.c.A'
  2034. fi
  2035. if test -f 'ee.msg' -a "${1}" != "-c" ; then 
  2036.   echo shar: Will not clobber existing file \"'ee.msg'\"
  2037. else
  2038.   echo shar: Extracting \"'ee.msg'\" \(5288 characters\)
  2039.   sed "s/^X//" >'ee.msg' <<'END_OF_FILE'
  2040. X$ This file contains the messages for ee ("easy editor).  See the file 
  2041. X$ ee.i18n.guide for more information
  2042. X$ 
  2043. X$set 1
  2044. X$quote "
  2045. X1 "modes menu"
  2046. X2 "tabs to spaces       "
  2047. X3 "case sensitive search"
  2048. X4 "margins observed     "
  2049. X5 "auto-paragraph format"
  2050. X6 "eightbit characters  "
  2051. X7 "info window          "
  2052. X8 "right margin         "
  2053. X9 "leave menu"
  2054. X10 "save changes"
  2055. X11 "no save"
  2056. X12 "file menu"
  2057. X13 "read a file"
  2058. X14 "write a file"
  2059. X15 "save file"
  2060. X16 "print editor contents"
  2061. X17 "search menu"
  2062. X18 "search for ..."
  2063. X19 "search"
  2064. X20 "spell menu"
  2065. X21 "use 'spell'"
  2066. X22 "use 'ispell'"
  2067. X23 "miscellaneous menu"
  2068. X24 "format paragraph"
  2069. X25 "shell command"
  2070. X26 "check spelling"
  2071. X27 "main menu"
  2072. X28 "leave editor"
  2073. X29 "help"
  2074. X30 "file operations"
  2075. X31 "redraw screen"
  2076. X32 "settings"
  2077. X33 "search"
  2078. X34 "miscellaneous"
  2079. X35 "Control keys:                                                              "
  2080. X36 "^a ascii code           ^i tab                  ^r right                   "
  2081. X37 "^b bottom of text       ^j newline              ^t top of text             "
  2082. X38 "^c command              ^k delete char          ^u up                      "
  2083. X39 "^d down                 ^l left                 ^v undelete word           "
  2084. X40 "^e search prompt        ^m newline              ^w delete word             "
  2085. X41 "^f undelete char        ^n next page            ^x search                  "
  2086. X42 "^g begin of line        ^o end of line          ^y delete line             "
  2087. X43 "^h backspace            ^p prev page            ^z undelete line           "
  2088. X44 "^[ (escape) menu                                                           "
  2089. X45 "                                                                           "
  2090. X46 "Commands:                                                                  "
  2091. X47 "help    : get this info                 file    : print file name          "
  2092. X48 "read    : read a file                   char    : ascii code of char       "
  2093. X49 "write   : write a file                  case    : case sensitive search    "
  2094. X50 "exit    : leave and save                nocase  : case insensitive search  "
  2095. X51 "quit    : leave, no save                !cmd    : execute \"cmd\" in shell   "
  2096. X52 "line    : display line #                0-9     : go to line \"#\"           "
  2097. X53 "expand  : expand tabs                   noexpand: do not expand tabs         "
  2098. X54 "                                                                             "
  2099. X55 "  ee [-i] [-e] [-h] [file(s)]                                                 "
  2100. X56 "   -i : no information window  -e : do not expand tabs   -h : no highlight "
  2101. X57 "^[ (escape) menu  ^e search prompt  ^y delete line    ^u up     ^p prev page  "
  2102. X58 "^a ascii code     ^x search         ^z undelete line  ^d down   ^n next page  "
  2103. X59 "^b bottom of text ^g begin of line  ^w delete word    ^l left                 "
  2104. X60 "^t top of text    ^o end of line    ^v undelete word  ^r right                "
  2105. X61 "^c command        ^k delete char    ^f undelete char                          "
  2106. X62 "help : get help info  |file  : print file name         |line : print line # "
  2107. X63 "read : read a file    |char  : ascii code of char      |0-9 : go to line \"#\""
  2108. X64 "write: write a file   |case  : case sensitive search   |exit : leave and save "
  2109. X65 "!cmd : shell \"cmd\"    |nocase: ignore case in search   |quit : leave, no save"
  2110. X66 "expand: expand tabs   |noexpand: do not expand tabs                           "
  2111. X67 "    press Escape (^[) for menu"
  2112. X68 "no file"
  2113. X69 "ascii code: "
  2114. X70 "sending contents of buffer to \"%s\" "
  2115. X71 "command: "
  2116. X72 "name of file to write: "
  2117. X73 "name of file to read: "
  2118. X74 "character = %d"
  2119. X75 "unknown command \"%s\""
  2120. X76 "entered command is not unique"
  2121. X77 "line %d  "
  2122. X78 "length = %d"
  2123. X79 "current file is \"%s\" "
  2124. X80 "usage: %s [-i] [-e] [-h] [file(s)]\n"
  2125. X81 "       -i   turn off info window\n"
  2126. X82 "       -e   do not convert tabs to spaces\n"
  2127. X83 "       -h   do not use highlighting\n"
  2128. X84 "file \"%s\" is a directory"
  2129. X85 "new file \"%s\""
  2130. X86 "can't open \"%s\""
  2131. X87 "file \"%s\", %d lines"
  2132. X88 "finished reading file \"%s\""
  2133. X89 "reading file \"%s\""
  2134. X90 ", read only"
  2135. X91 "file \"%s\", %d lines"
  2136. X92 "enter name of file: "
  2137. X93 "no filename entered: file not saved"
  2138. X94 "changes have been made, are you sure? (y/n [n]) "
  2139. X95 "y"
  2140. X96 "file already exists, overwrite? (y/n) [n] "
  2141. X97 "unable to create file \"%s\""
  2142. X98 "writing file \"%s\""
  2143. X99 "\"%s\" %d lines, %d characters"
  2144. X100 "           ...searching"
  2145. X101 "string \"%s\" not found"
  2146. X102 "search for: "
  2147. X103 "could not exec %s\n"
  2148. X104 "press return to continue "
  2149. X105 "press Esc to cancel"
  2150. X106 "menu too large for window"
  2151. X107 "press any key to continue "
  2152. X108 "shell command: "
  2153. X109 "...formatting paragraph..."
  2154. X110 "<!echo 'list of unrecognized words'; echo -=-=-=-=-=-"
  2155. X111 "sending contents of edit buffer to 'spell'"
  2156. X112 "right margin is: "
  2157. X113 "restricted mode: unable to perform requested operation"
  2158. X114 "ON"
  2159. X115 "OFF"
  2160. X116 "HELP"
  2161. X117 "WRITE"
  2162. X118 "READ"
  2163. X119 "LINE"
  2164. X120 "FILE"
  2165. X121 "CHARACTER"
  2166. X122 "REDRAW"
  2167. X123 "RESEQUENCE"
  2168. X124 "AUTHOR"
  2169. X125 "VERSION"
  2170. X126 "CASE"
  2171. X127 "NOCASE"
  2172. X128 "EXPAND"
  2173. X129 "NOEXPAND"
  2174. X130 "EXIT"
  2175. X131 "QUIT"
  2176. X132 "INFO"
  2177. X133 "NOINFO"
  2178. X134 "MARGINS"
  2179. X135 "NOMARGINS"
  2180. X136 "AUTOFORMAT"
  2181. X137 "NOAUTOFORMAT"
  2182. X138 "ECHO"
  2183. X139 "PRINTCOMMAND"
  2184. X140 "RIGHTMARGIN"
  2185. X141 "HIGHLIGHT"
  2186. X142 "NOHIGHLIGHT"
  2187. X143 "EIGHTBIT"
  2188. X144 "NOEIGHTBIT"
  2189. END_OF_FILE
  2190.   if test 5288 -ne `wc -c <'ee.msg'`; then
  2191.     echo shar: \"'ee.msg'\" unpacked with wrong size!
  2192.   fi
  2193.   # end of 'ee.msg'
  2194. fi
  2195. echo shar: End of archive 3 \(of 5\).
  2196. cp /dev/null ark3isdone
  2197. MISSING=""
  2198. for I in 1 2 3 4 5 ; do
  2199.     if test ! -f ark${I}isdone ; then
  2200.     MISSING="${MISSING} ${I}"
  2201.     fi
  2202. done
  2203. if test "${MISSING}" = "" ; then
  2204.     echo You have unpacked all 5 archives.
  2205.     rm -f ark[1-9]isdone
  2206. else
  2207.     echo You still must unpack the following archives:
  2208.     echo "        " ${MISSING}
  2209. fi
  2210. exit 0
  2211. exit 0 # Just in case...
  2212.