home *** CD-ROM | disk | FTP | other *** search
/ Source Code 1994 March / Source_Code_CD-ROM_Walnut_Creek_March_1994.iso / compsrcs / misc / volume28 / tin / part10 < prev    next >
Encoding:
Text File  |  1992-02-22  |  50.4 KB  |  2,262 lines
  1. Newsgroups: comp.sources.misc
  2. From: iain%estevax.uucp@unido.Informatik.Uni-Dortmund.DE (Iain Lea)
  3. Subject:  v28i054:  tin - threaded full screen newsreader v1.1, Part10/11
  4. Message-ID: <1992Feb18.043951.13475@sparky.imd.sterling.com>
  5. X-Md4-Signature: b0824f74a338be8f8333cce08accf43b
  6. Date: Tue, 18 Feb 1992 04:39:51 GMT
  7. Approved: kent@sparky.imd.sterling.com
  8.  
  9. Submitted-by: iain%estevax.uucp@unido.Informatik.Uni-Dortmund.DE (Iain Lea)
  10. Posting-number: Volume 28, Issue 54
  11. Archive-name: tin/part10
  12. Environment: BSD, SCO, ISC, SUNOS, SYSVR3, SYSVR4, ULTRIX, XENIX
  13. Supersedes: tin: Volume 23, Issue 15-23
  14.  
  15. #!/bin/sh
  16. # this is tin.shar.10 (part 10 of tin1.1)
  17. # do not concatenate these parts, unpack them in order with /bin/sh
  18. # file signal.c continued
  19. #
  20. if test ! -r _shar_seq_.tmp; then
  21.     echo 'Please unpack part 1 first!'
  22.     exit 1
  23. fi
  24. (read Scheck
  25.  if test "$Scheck" != 10; then
  26.     echo Please unpack part "$Scheck" next!
  27.     exit 1
  28.  else
  29.     exit 0
  30.  fi
  31. ) < _shar_seq_.tmp || exit 1
  32. if test ! -f _shar_wnt_.tmp; then
  33.     echo 'x - still skipping signal.c'
  34. else
  35. echo 'x - continuing file signal.c'
  36. sed 's/^X//' << 'SHAR_EOF' >> 'signal.c' &&
  37. X        fprintf (stderr, "%s: send a bug report to %s\n",
  38. X            progname, BUG_REPORT_ADDRESS);
  39. X    }
  40. X    fflush (stderr);
  41. X    exit (1);
  42. }
  43. X
  44. X
  45. void set_win_size (num_lines, num_cols)
  46. X    int *num_lines;
  47. X    int *num_cols;
  48. {
  49. #ifdef TIOCGWINSZ
  50. X    char buf[64];
  51. X    int old_lines, old_cols;
  52. X    struct winsize win;
  53. X
  54. X    if (debug) {
  55. X        old_lines = *num_lines;
  56. X        old_cols = *num_cols;
  57. X    }
  58. #endif
  59. X
  60. X    init_screen_array (FALSE);        /* deallocate screen array */
  61. X
  62. #ifdef TIOCGWINSZ
  63. X    if (ioctl (0, TIOCGWINSZ, &win) == 0) {
  64. X        if (win.ws_row != 0) {
  65. X            *num_lines = win.ws_row - 1;
  66. X        }
  67. X        if (win.ws_col != 0) {
  68. X            *num_cols = win.ws_col;
  69. X        }
  70. X    }
  71. X
  72. X    if (debug) {
  73. X        sprintf (buf, "RESIZED lines %d to %d  cols %d to %d",
  74. X            old_lines, *num_lines, old_cols, *num_cols);
  75. X        info_message (buf);
  76. X    }
  77. #endif
  78. X
  79. X    init_screen_array (TRUE);        /* allocate screen array for resize */
  80. X
  81. X    if (show_author == SHOW_FROM_BOTH) {
  82. X        max_subj = (*num_cols / 2) - 2;
  83. X    } else {
  84. X        max_subj = (*num_cols / 2) + 5;
  85. X    }
  86. X    max_from = (*num_cols - max_subj) - 17;
  87. X    RIGHT_POS = *num_cols - 18;
  88. X    MORE_POS  = *num_cols - 15;
  89. X    NOTESLINES = *num_lines - INDEX_TOP - 1;
  90. X    if (NOTESLINES <= 0) {
  91. X        NOTESLINES = 1;
  92. X    }
  93. }
  94. X
  95. X
  96. void set_signals_art ()
  97. {
  98. #ifdef SIGTSTP
  99. X    if (do_sigtstp) {
  100. #ifdef POSIX_JOB_CONTROL
  101. X        sigemptyset (&art_act.sa_mask);
  102. X        art_act.sa_flags = SA_RESTART | SA_RESETHAND;
  103. X        art_act.sa_handler = art_suspend;
  104. X        sigaction (SIGTSTP, &art_act, 0L);
  105. #else
  106. X        signal (SIGTSTP, art_suspend);
  107. #endif
  108. X    }
  109. #endif
  110. X
  111. #ifdef SIGWINCH
  112. X    signal (SIGWINCH, art_resize);
  113. #endif
  114. }
  115. X
  116. X
  117. void set_signals_group ()
  118. {
  119. #ifdef SIGTSTP
  120. X    if (do_sigtstp) {
  121. #ifdef POSIX_JOB_CONTROL
  122. X        sigemptyset (&group_act.sa_mask);
  123. X        group_act.sa_flags = SA_RESTART | SA_RESETHAND;
  124. X        group_act.sa_handler = group_suspend;
  125. X        sigaction (SIGTSTP, &group_act, 0L);
  126. #else
  127. X        signal (SIGTSTP, group_suspend);
  128. #endif
  129. X    }
  130. #endif
  131. X
  132. #ifdef SIGWINCH
  133. X    signal (SIGWINCH, group_resize);
  134. #endif
  135. }
  136. X
  137. X
  138. void set_signals_page ()
  139. {
  140. #ifdef SIGTSTP
  141. X    if (do_sigtstp) {
  142. #ifdef POSIX_JOB_CONTROL
  143. X        sigemptyset (&page_act.sa_mask);
  144. X        page_act.sa_flags = SA_RESTART | SA_RESETHAND;
  145. X        page_act.sa_handler = page_suspend;
  146. X        sigaction (SIGTSTP, &page_act, 0L);
  147. #else
  148. X        signal (SIGTSTP, page_suspend);
  149. #endif
  150. X    }
  151. #endif
  152. X
  153. #ifdef SIGWINCH
  154. X    signal (SIGWINCH, page_resize);
  155. #endif
  156. }
  157. X
  158. X
  159. void set_signals_select ()
  160. {
  161. #ifdef SIGTSTP
  162. X    if (do_sigtstp) {
  163. #ifdef POSIX_JOB_CONTROL
  164. X        sigemptyset (&select_act.sa_mask);
  165. X        select_act.sa_flags = SA_RESTART | SA_RESETHAND;
  166. X        select_act.sa_handler = select_suspend;
  167. X        sigaction (SIGTSTP, &select_act, 0L);
  168. #else
  169. X        signal (SIGTSTP, select_suspend);
  170. #endif
  171. X    }
  172. #endif
  173. X
  174. #ifdef SIGWINCH
  175. X    signal (SIGWINCH, select_resize);
  176. #endif
  177. }
  178. X
  179. X
  180. void set_signals_thread ()
  181. {
  182. #ifdef SIGTSTP
  183. X    if (do_sigtstp) {
  184. #ifdef POSIX_JOB_CONTROL
  185. X        sigemptyset (&thread_act.sa_mask);
  186. X        thread_act.sa_flags = SA_RESTART | SA_RESETHAND;
  187. X        thread_act.sa_handler = thread_suspend;
  188. X        sigaction (SIGTSTP, &thread_act, 0L);
  189. #else
  190. X        signal (SIGTSTP, thread_suspend);
  191. #endif
  192. X    }
  193. #endif
  194. X
  195. #ifdef SIGWINCH
  196. X    signal (SIGWINCH, thread_resize);
  197. #endif
  198. }
  199. X
  200. X
  201. #ifdef SIGTSTP
  202. X
  203. /* ARGSUSED0 */
  204. void art_suspend (sig)
  205. X    int sig;
  206. {
  207. X    char buf[LEN];
  208. X    
  209. X    Raw (FALSE);
  210. X    putchar ('\n');
  211. X
  212. #ifdef POSIX_JOB_CONTROL
  213. X    sigsetmask(0);
  214. #else
  215. X    signal(SIGTSTP, SIG_DFL);
  216. #ifdef BSD
  217. X    sigsetmask (sigblock(0) & ~(1 << (SIGTSTP -1)));
  218. #endif
  219. #endif
  220. X
  221. X    kill (0, SIGTSTP);
  222. X
  223. #ifdef POSIX_JOB_CONTROL
  224. X    sigemptyset (&art_act.sa_mask);
  225. X    art_act.sa_flags = SA_RESTART | SA_RESETHAND;
  226. X    art_act.sa_handler = art_suspend;
  227. X    sigaction (SIGTSTP, &art_act, 0L);
  228. #else
  229. X    signal (SIGTSTP, art_suspend);
  230. #endif
  231. X
  232. X    if (! update) {
  233. X        mail_setup ();
  234. X    
  235. X        Raw (TRUE);
  236. X
  237. X        ClearScreen ();
  238. X        sprintf (buf, txt_group, glob_art_group);
  239. X        wait_message (buf);
  240. X    }
  241. }
  242. X
  243. X
  244. /* ARGSUSED0 */
  245. void main_suspend (sig)
  246. X    int sig;
  247. {
  248. X    Raw (FALSE);
  249. X    putchar ('\n');
  250. X
  251. #ifdef POSIX_JOB_CONTROL
  252. X    sigsetmask(0);
  253. #else
  254. X    signal(SIGTSTP, SIG_DFL);
  255. #ifdef BSD
  256. X    sigsetmask (sigblock(0) & ~(1 << (SIGTSTP -1)));
  257. #endif
  258. #endif
  259. X
  260. X    kill (0, SIGTSTP);
  261. X
  262. #ifdef POSIX_JOB_CONTROL
  263. X    sigemptyset (&main_act.sa_mask);
  264. X    main_act.sa_flags = SA_RESTART | SA_RESETHAND;
  265. X    main_act.sa_handler = main_suspend;
  266. X    sigaction (SIGTSTP, &main_act, 0L);
  267. #else
  268. X    signal (SIGTSTP, main_suspend);
  269. #endif
  270. X
  271. X    mail_setup ();
  272. X    if (! update) {
  273. X        Raw (TRUE);
  274. X    }
  275. }
  276. X
  277. X
  278. /* ARGSUSED0 */
  279. void select_suspend (sig)
  280. X    int sig;
  281. {
  282. X
  283. X    Raw (FALSE);
  284. X
  285. #ifdef POSIX_JOB_CONTROL
  286. X    sigsetmask(0);
  287. #else
  288. X    signal(SIGTSTP, SIG_DFL);
  289. #ifdef BSD
  290. X    sigsetmask (sigblock(0) & ~(1 << (SIGTSTP -1)));
  291. #endif
  292. #endif
  293. X
  294. X    kill (0, SIGTSTP);
  295. X
  296. #ifdef POSIX_JOB_CONTROL
  297. X    sigemptyset (&select_act.sa_mask);
  298. X    select_act.sa_flags = SA_RESTART | SA_RESETHAND;
  299. X    select_act.sa_handler = select_suspend;
  300. X    sigaction (SIGTSTP, &select_act, 0L);
  301. #else
  302. X    signal (SIGTSTP, select_suspend);
  303. #endif
  304. X
  305. X    if (! update) {
  306. X        Raw (TRUE);
  307. X    }
  308. X
  309. #ifndef USE_CLEARSCREEN
  310. X    ClearScreen ();
  311. #endif
  312. X    mail_setup ();
  313. X    group_selection_page ();
  314. }
  315. X
  316. X
  317. /* ARGSUSED0 */
  318. void group_suspend (sig)
  319. X    int sig;
  320. {
  321. X    Raw (FALSE);
  322. X    putchar ('\n');
  323. X
  324. #ifdef POSIX_JOB_CONTROL
  325. X    sigsetmask(0);
  326. #else
  327. X    signal(SIGTSTP, SIG_DFL);
  328. #ifdef BSD
  329. X    sigsetmask (sigblock(0) & ~(1 << (SIGTSTP -1)));
  330. #endif
  331. #endif
  332. X
  333. X    kill (0, SIGTSTP);
  334. X
  335. #ifdef POSIX_JOB_CONTROL
  336. X    sigemptyset (&group_act.sa_mask);
  337. X    group_act.sa_flags = SA_RESTART | SA_RESETHAND;
  338. X    group_act.sa_handler = group_suspend;
  339. X    sigaction (SIGTSTP, &group_act, 0L);
  340. #else
  341. X    signal (SIGTSTP, group_suspend);
  342. #endif
  343. X
  344. X    if (! update) {
  345. X        Raw (TRUE);
  346. X    }
  347. X    
  348. #ifndef USE_CLEARSCREEN
  349. X    ClearScreen ();
  350. #endif
  351. X    mail_setup ();
  352. X    show_group_page (glob_group);
  353. }
  354. X
  355. X
  356. /* ARGSUSED0 */
  357. void page_suspend (sig)
  358. X    int sig;
  359. {
  360. X
  361. X    Raw (FALSE);
  362. X    putchar ('\n');
  363. X
  364. #ifdef POSIX_JOB_CONTROL
  365. X    sigsetmask(0);
  366. #else
  367. X    signal(SIGTSTP, SIG_DFL);
  368. #ifdef BSD
  369. X    sigsetmask (sigblock(0) & ~(1 << (SIGTSTP -1)));
  370. #endif
  371. #endif
  372. X
  373. X    kill (0, SIGTSTP);
  374. X
  375. #ifdef POSIX_JOB_CONTROL
  376. X    sigemptyset (&page_act.sa_mask);
  377. X    page_act.sa_flags = SA_RESTART | SA_RESETHAND;
  378. X    page_act.sa_handler = page_suspend;
  379. X    sigaction (SIGTSTP, &page_act, 0L);
  380. #else
  381. X    signal (SIGTSTP, page_suspend);
  382. #endif
  383. X
  384. X    mail_setup ();
  385. X
  386. X    if (! update) {
  387. X        Raw (TRUE);
  388. X    }
  389. X    
  390. #ifndef USE_CLEARSCREEN
  391. X    ClearScreen ();
  392. #endif
  393. X    redraw_page (glob_respnum, glob_page_group);
  394. }
  395. X
  396. X
  397. /* ARGSUSED0 */
  398. void thread_suspend (sig)
  399. X    int sig;
  400. {
  401. X    Raw (FALSE);
  402. X    putchar ('\n');
  403. X
  404. #ifdef POSIX_JOB_CONTROL
  405. X    sigsetmask (0);
  406. #else
  407. X    signal (SIGTSTP, SIG_DFL);
  408. #ifdef BSD
  409. X    sigsetmask (sigblock(0) & ~(1 << (SIGTSTP -1)));
  410. #endif
  411. #endif
  412. X
  413. X    kill (0, SIGTSTP);
  414. X
  415. #ifdef POSIX_JOB_CONTROL
  416. X    sigemptyset (&thread_act.sa_mask);
  417. X    thread_act.sa_flags = SA_RESTART | SA_RESETHAND;
  418. X    thread_act.sa_handler = thread_suspend;
  419. X    sigaction (SIGTSTP, &thread_act, 0L);
  420. #else
  421. X    signal (SIGTSTP, thread_suspend);
  422. #endif
  423. X
  424. X    if (! update) {
  425. X        Raw (TRUE);
  426. X    }
  427. X    
  428. #ifndef USE_CLEARSCREEN
  429. X    ClearScreen ();
  430. #endif
  431. X    mail_setup ();
  432. X    show_thread_page ();
  433. }
  434. X
  435. X
  436. /* ARGSUSED0 */
  437. void rcfile_suspend (sig)
  438. X    int sig;
  439. {
  440. X    Raw (FALSE);
  441. X    putchar ('\n');
  442. X
  443. #ifdef POSIX_JOB_CONTROL
  444. X    sigsetmask(0);
  445. #else
  446. X    signal(SIGTSTP, SIG_DFL);
  447. #ifdef BSD
  448. X    sigsetmask (sigblock(0) & ~(1 << (SIGTSTP -1)));
  449. #endif
  450. #endif
  451. X
  452. X    kill (0, SIGTSTP);
  453. X
  454. #ifdef POSIX_JOB_CONTROL
  455. X    sigemptyset (&rcfile_act.sa_mask);
  456. X    rcfile_act.sa_flags = SA_RESTART | SA_RESETHAND;
  457. X    rcfile_act.sa_handler = rcfile_suspend;
  458. X    sigaction (SIGTSTP, &rcfile_act, 0L);
  459. #else
  460. X    signal (SIGTSTP, rcfile_suspend);
  461. #endif
  462. X
  463. X    Raw (TRUE);
  464. X    show_rcfile_menu ();    
  465. }
  466. X
  467. #endif /* SIGTSTP */    
  468. X
  469. X
  470. #ifdef SIGWINCH
  471. X
  472. /* ARGSUSED0 */
  473. void art_resize (sig)
  474. X    int sig;
  475. {
  476. X    char buf[LEN];
  477. X
  478. X    info_message (txt_resizing_window);
  479. X    set_win_size (&LINES, &COLS);
  480. X    signal (SIGWINCH, art_resize);
  481. X
  482. X    ClearScreen ();
  483. X    sprintf (buf, txt_group, glob_art_group);
  484. X    wait_message (buf);
  485. }
  486. X
  487. X
  488. /* ARGSUSED0 */
  489. void main_resize (sig)
  490. X    int sig;
  491. {
  492. X    info_message (txt_resizing_window);
  493. X    set_win_size (&LINES, &COLS);
  494. X    signal (SIGWINCH, main_resize);
  495. }
  496. X
  497. X
  498. /* ARGSUSED0 */
  499. void select_resize (sig)
  500. X    int sig;
  501. {
  502. X    info_message (txt_resizing_window);
  503. X    set_win_size (&LINES, &COLS);
  504. X    signal (SIGWINCH, select_resize);
  505. X    
  506. #ifndef USE_CLEARSCREEN
  507. X    ClearScreen ();
  508. #endif
  509. X    group_selection_page ();
  510. }
  511. X
  512. X
  513. /* ARGSUSED0 */
  514. void group_resize (sig)
  515. X    int sig;
  516. {
  517. X    info_message (txt_resizing_window);
  518. X    set_win_size (&LINES, &COLS);
  519. X    signal (SIGWINCH, group_resize);
  520. X    
  521. #ifndef USE_CLEARSCREEN
  522. X    ClearScreen ();
  523. #endif
  524. X    show_group_page (glob_group);
  525. }
  526. X
  527. X
  528. /* ARGSUSED0 */
  529. void page_resize (sig)
  530. X    int sig;
  531. {
  532. X    info_message (txt_resizing_window);
  533. X    set_win_size (&LINES, &COLS);
  534. X    signal (SIGWINCH, page_resize);
  535. X    
  536. #ifndef USE_CLEARSCREEN
  537. X    ClearScreen ();
  538. #endif
  539. X    redraw_page (glob_respnum, glob_page_group);
  540. }
  541. X
  542. X
  543. /* ARGSUSED0 */
  544. void thread_resize (sig)
  545. X    int sig;
  546. {
  547. X    info_message (txt_resizing_window);
  548. X    set_win_size (&LINES, &COLS);
  549. X    signal (SIGWINCH, thread_resize);
  550. X    
  551. #ifndef USE_CLEARSCREEN
  552. X    ClearScreen ();
  553. #endif
  554. X    show_thread_page ();
  555. }
  556. X
  557. #endif /* SIGWINCH */    
  558. X
  559. SHAR_EOF
  560. echo 'File signal.c is complete' &&
  561. chmod 0600 signal.c ||
  562. echo 'restore of signal.c failed'
  563. Wc_c="`wc -c < 'signal.c'`"
  564. test 10822 -eq "$Wc_c" ||
  565.     echo 'signal.c: original size 10822, current size' "$Wc_c"
  566. rm -f _shar_wnt_.tmp
  567. fi
  568. # ============= thread.c ==============
  569. if test -f 'thread.c' -a X"$1" != X"-c"; then
  570.     echo 'x - skipping thread.c (File already exists)'
  571.     rm -f _shar_wnt_.tmp
  572. else
  573. > _shar_wnt_.tmp
  574. echo 'x - extracting thread.c (Text)'
  575. sed 's/^X//' << 'SHAR_EOF' > 'thread.c' &&
  576. /*
  577. X *  Project   : tin - a threaded Netnews reader
  578. X *  Module    : thread.c
  579. X *  Author    : I.Lea
  580. X *  Created   : 01-04-91
  581. X *  Updated   : 08-02-92
  582. X *  Notes     :
  583. X *  Copyright : (c) Copyright 1991-92 by Iain Lea
  584. X *                You may  freely  copy or  redistribute  this software,
  585. X *              so  long as there is no profit made from its use, sale
  586. X *              trade or  reproduction.  You may not change this copy-
  587. X *              right notice, and it must be included in any copy made
  588. X */
  589. X
  590. #include    "tin.h"
  591. X
  592. extern int index_point;
  593. int threaded_on_subject;
  594. static int top_thread = 0;
  595. static int thread_index_point = 0;
  596. static int thread_basenote = 0;
  597. static int thread_respnum = 0;
  598. static int first_thread_on_screen = 0;
  599. static int last_thread_on_screen = 0;
  600. X
  601. X
  602. /*
  603. X * show current thread. If threaded on Subject: show
  604. X *   <respnum> <name>    <respnum> <name>
  605. X * If threaded on Archive-name: show
  606. X *   <respnum> <subject> <name>
  607. X */
  608. X 
  609. int show_thread (respnum, group, group_path)
  610. X    int respnum;
  611. X    char *group;
  612. X    char *group_path;
  613. {
  614. X    int ch;
  615. X    int flag, i, index, n;
  616. X    int scroll_lines;
  617. X    int    thread_marked_unread;
  618. X
  619. X    thread_respnum = respnum;
  620. X    thread_basenote = which_thread (thread_respnum);
  621. X    top_thread = num_of_responses (thread_basenote);
  622. X
  623. X    if (debug) {
  624. X        sprintf (msg, "THREAD respnum=[%d]  basenote=[%d]  num=[%d]",
  625. X            thread_respnum, thread_basenote, top_thread);
  626. X        info_message (msg);
  627. X        sleep (2);
  628. X    }
  629. X
  630. X    if (top_thread <= 0) {
  631. X        info_message (txt_no_resps_in_thread);
  632. X        return FALSE;
  633. X    }
  634. X
  635. X    if (arts[thread_respnum].archive != (char *) 0) {
  636. X        threaded_on_subject = FALSE;
  637. X    } else {
  638. X        threaded_on_subject = TRUE;
  639. X    }
  640. X
  641. X    if (space_mode) {
  642. X        if (i = new_responses (thread_basenote)) {
  643. X            for (n=0, i = thread_basenote; i >= 0 ; i = arts[i].thread, n++) {
  644. X                if (arts[i].unread == ART_UNREAD) {
  645. X                    thread_index_point = n;
  646. X                    break;
  647. X                }
  648. X            }
  649. X        } else {
  650. X            thread_index_point = top_thread;
  651. X        }
  652. X    } else {
  653. X        thread_index_point = top_thread;
  654. X    }
  655. X
  656. X    if (thread_index_point < 0) {
  657. X        thread_index_point = 0;
  658. X    }
  659. X
  660. X    show_thread_page ();
  661. X
  662. X    while (TRUE) {
  663. X        ch = (char) ReadCh();
  664. X
  665. X        if (ch >= '0' && ch <= '9') {    /* 0 goes to basenote */
  666. X            prompt_thread_num (ch);
  667. X        } else switch (ch) {
  668. X            case ESC:    /* common arrow keys */
  669. X                switch (get_arrow_key ()) {
  670. X                    case KEYMAP_UP:
  671. X                        goto thread_up;
  672. X
  673. X                    case KEYMAP_DOWN:
  674. X                        goto thread_down;
  675. X
  676. X                    case KEYMAP_PAGE_UP:
  677. X                        goto thread_page_up;
  678. X
  679. X                    case KEYMAP_PAGE_DOWN:
  680. X                        goto thread_page_down;
  681. X
  682. X                    case KEYMAP_HOME:
  683. X                        if (thread_index_point != 0) {
  684. X                            thread_index_point = 0;
  685. X                            show_thread_page ();
  686. X                        }
  687. X                        break;
  688. X                    
  689. X                    case KEYMAP_END:
  690. X                        goto end_of_thread;
  691. X                }
  692. X                break;
  693. X
  694. X            case '$':    /* show last page of threads */
  695. end_of_thread:            
  696. X                if (thread_index_point != top_thread) {
  697. X                    thread_index_point = top_thread;
  698. X                    show_thread_page ();
  699. X                }
  700. X                break;
  701. X                
  702. X            case '\r':
  703. X            case '\n':    /* read current article within thread */
  704. X                n = choose_response (thread_basenote, thread_index_point);
  705. X                n = show_page (n, group, group_path);
  706. X                if (n == thread_basenote) {
  707. X                    show_thread_page ();
  708. X                } else {
  709. X                    index_point = n;    
  710. X                    goto thread_done;
  711. X                }
  712. X                break;
  713. X
  714. X            case '\t':
  715. X                 space_mode = TRUE;
  716. X                if (thread_index_point == 0) {
  717. X                    n = thread_respnum;
  718. X                } else {
  719. X                    n = choose_response (thread_basenote, thread_index_point);
  720. X                }
  721. X                index = thread_index_point;
  722. X                for (i = n ; i != -1 ; i = arts[i].thread) {
  723. X                    if (arts[i].unread == ART_UNREAD) {
  724. X                        n = show_page (i, group, group_path);
  725. X                        break;
  726. X                    }
  727. X                    index++;
  728. X                }
  729. X                if (n == thread_basenote) {
  730. X                    thread_index_point = index;
  731. X                    show_thread_page ();
  732. X                } else {
  733. X                    index_point = which_thread (n);    
  734. X                    goto thread_done;
  735. X                }
  736. X                break;
  737. X    
  738. X            case ' ':            /* page down */
  739. X            case ctrl('D'):        /* vi style */
  740. X            case ctrl('V'):        /* emacs style */
  741. thread_page_down:
  742. X                if (thread_index_point == top_thread)
  743. X                    break;
  744. X
  745. X                erase_thread_arrow ();
  746. X                scroll_lines = (full_page_scroll ? NOTESLINES : NOTESLINES / 2);
  747. X                thread_index_point = ((thread_index_point + scroll_lines) /
  748. X                                    scroll_lines) * scroll_lines;
  749. X                if (thread_index_point > top_thread) {
  750. X                    thread_index_point = (top_thread / scroll_lines) * scroll_lines;
  751. X                    if (thread_index_point < top_thread) {
  752. X                        thread_index_point = top_thread;
  753. X                    }
  754. X                }
  755. X                if (thread_index_point < first_thread_on_screen ||
  756. X                    thread_index_point >= last_thread_on_screen) {
  757. X                    show_thread_page ();
  758. X                } else {
  759. X                    draw_thread_arrow ();
  760. X                }
  761. X                break;
  762. X
  763. X            case ctrl('L'):        /* redraw screen */
  764. X            case ctrl('R'):
  765. X            case ctrl('W'):
  766. #ifndef USE_CLEARSCREEN
  767. X                ClearScreen ();
  768. #endif
  769. X                show_thread_page ();
  770. X                break;
  771. X
  772. X            case ctrl('N'):
  773. X            case 'j':        /* line down */
  774. thread_down:
  775. X                if (thread_index_point + 1 > top_thread)
  776. X                    break;
  777. /*
  778. X                if (thread_index_point + 1 >= top_thread)
  779. X                    break;
  780. */
  781. X
  782. X                if (thread_index_point + 1 > last_thread_on_screen) {
  783. /*
  784. X                if (thread_index_point + 1 >= last_thread_on_screen) {
  785. */
  786. #ifndef USE_CLEARSCREEN
  787. X                    erase_thread_arrow ();
  788. #endif                    
  789. X                    thread_index_point++;
  790. X                    show_thread_page ();
  791. X                } else {
  792. X                    erase_thread_arrow ();
  793. X                    thread_index_point++;
  794. X                    draw_thread_arrow ();
  795. X                }
  796. X                break;
  797. X
  798. X            case ctrl('P'):
  799. X            case 'k':        /* line up */
  800. thread_up:
  801. X                if (! thread_index_point)
  802. X                    break;
  803. X
  804. X                if (thread_index_point <= first_thread_on_screen) {
  805. X                    thread_index_point--;
  806. X                    show_thread_page ();
  807. X                } else {
  808. X                    erase_thread_arrow ();
  809. X                    thread_index_point--;
  810. X                    draw_thread_arrow ();
  811. X                }
  812. X                break;
  813. X
  814. X            case ctrl('U'):        /* page up */
  815. X            case 'b':
  816. thread_page_up:
  817. #ifndef USE_CLEARSCREEN
  818. X                clear_message ();
  819. #endif
  820. X                erase_thread_arrow ();
  821. X                scroll_lines = (full_page_scroll ? NOTESLINES : NOTESLINES / 2);
  822. X                if ((n = thread_index_point % scroll_lines) > 0) {
  823. X                    thread_index_point = thread_index_point - n;
  824. X                } else {
  825. X                    thread_index_point = ((thread_index_point - scroll_lines) / scroll_lines) * scroll_lines;
  826. X                }
  827. X                if (thread_index_point < 0) {
  828. X                    thread_index_point = 0;
  829. X                }
  830. X                if (thread_index_point < first_thread_on_screen
  831. X                || thread_index_point >= last_thread_on_screen)
  832. X                    show_thread_page ();
  833. X                else
  834. X                    draw_thread_arrow ();
  835. X                break;
  836. X
  837. X            case 'h':    /* help */
  838. X                show_info_page (HELP_INFO, help_thread, txt_thread_com);
  839. X                show_thread_page ();
  840. X                break;
  841. X
  842. X            case 'I':    /* toggle inverse video */
  843. X                toggle_inverse_video ();
  844. X                show_thread_page ();
  845. X                break;
  846. X
  847. X            case 'i':    /* return */
  848. X            case 'q':
  849. X            case 't':
  850. X                goto thread_done;
  851. X
  852. X            case 'K':    /* mark thread as read */
  853. X                for (i = (int) base[thread_basenote] ; i != -1 ; i = arts[i].thread) {
  854. X                    arts[i].unread = ART_READ;
  855. X                }
  856. X                goto thread_done;
  857. X                break;
  858. X
  859. X            case 'v':    /* version */
  860. X                info_message (cvers);
  861. X                break;
  862. X
  863. X            case 'z':    /* mark article as unread */
  864. X                if (thread_index_point == 0) {
  865. X                    n = thread_respnum;
  866. X                } else {
  867. X                    n = choose_response (thread_basenote, thread_index_point);
  868. X                }
  869. X                if (n >= 0) {
  870. X                    arts[n].unread = ART_UNREAD;
  871. X                    show_thread_page ();
  872. X                    info_message (txt_art_marked_as_unread);
  873. X                }
  874. X                break;
  875. X
  876. X            case 'Z':    /* mark thread as unread */
  877. X                for (i = (int) base[thread_basenote] ; i != -1 ; i = arts[i].thread) {
  878. X                    arts[i].unread = ART_UNREAD;
  879. X                }
  880. X                show_thread_page ();
  881. X                info_message (txt_thread_marked_as_unread);
  882. X                break;
  883. X                
  884. X            default:
  885. X                info_message (txt_bad_command);
  886. X        }
  887. X    }
  888. X
  889. thread_done:
  890. /*
  891. X    fix_new_highest (sav_groupnum);
  892. X    update_newsrc (group, my_group[sav_groupnum], FALSE);
  893. */
  894. X    clear_note_area ();
  895. X    return TRUE;
  896. }
  897. X
  898. X
  899. void show_thread_page ()
  900. {
  901. X    extern int index_point;
  902. X    char buf[LEN];
  903. X    char new_resps[8];
  904. X    char resps[8];
  905. X    char from[LEN];
  906. X    char subject[LEN];
  907. X    int col, i, j, n;
  908. X    static int index = 0;
  909. X    int len_from;
  910. X    int len_subj;
  911. X
  912. X    set_signals_thread ();
  913. X    
  914. X    ClearScreen ();
  915. X
  916. X    if (threaded_on_subject) {
  917. X        sprintf (msg, "Thread (%s)", arts[thread_respnum].subject);
  918. X    } else {
  919. X        sprintf (msg, "List Thread (%d of %d)", index_point+1, top_base);
  920. X    }
  921. X    show_title (msg);
  922. X
  923. X    MoveCursor (INDEX_TOP, 0);
  924. X    if (thread_index_point > top_thread) {
  925. X        thread_index_point = top_thread - 1;
  926. X    }
  927. X
  928. X    if (NOTESLINES <= 0) {
  929. X        first_thread_on_screen = 0;
  930. X    } else {
  931. X        first_thread_on_screen = (thread_index_point / NOTESLINES) * NOTESLINES;
  932. X        if (first_thread_on_screen < 0) {
  933. X            first_thread_on_screen = 0;
  934. X        }
  935. X    }
  936. X
  937. X    last_thread_on_screen = first_thread_on_screen + NOTESLINES;
  938. X
  939. X    if (last_thread_on_screen >= top_thread) {
  940. X        last_thread_on_screen = top_thread;
  941. X        first_thread_on_screen = (top_thread / NOTESLINES) * NOTESLINES;
  942. X
  943. X        if (first_thread_on_screen == last_thread_on_screen ||
  944. X            first_thread_on_screen < 0) {
  945. X            if (first_thread_on_screen < 0) {
  946. X                first_thread_on_screen = 0;
  947. X            } else {
  948. X                first_thread_on_screen = last_thread_on_screen - NOTESLINES;
  949. X            }
  950. X        }
  951. X    }
  952. X
  953. X    if (top_thread == 0) {
  954. X        first_thread_on_screen = 0;
  955. X        last_thread_on_screen = 0;
  956. X    }
  957. X
  958. X    index = choose_response (thread_basenote, thread_index_point);
  959. X
  960. if (debug) {
  961. sprintf (msg, "first=[%d] last=[%d] index=[%d] thread_index_point=[%d]",
  962. X    first_thread_on_screen, last_thread_on_screen,
  963. X    index, thread_index_point);
  964. info_message (msg);
  965. sleep (2);
  966. MoveCursor (INDEX_TOP, 0);
  967. }
  968. X
  969. X    for (j=0, i = first_thread_on_screen; j < NOTESLINES && i <= last_thread_on_screen; i++, j++) {
  970. X        if (i == 0) {
  971. X            index = thread_respnum;
  972. X        } else {
  973. X            if ((index = next_response (index)) == -1) {
  974. X                break;
  975. X            }
  976. X        }
  977. X
  978. X        if (arts[index].tagged) {
  979. X            sprintf (new_resps, "%3d", arts[index].tagged);
  980. X        } else if (arts[index].unread == ART_UNREAD) {
  981. X            sprintf (new_resps, "  %c", UNREAD_ART_MARK);
  982. X        } else {
  983. X            strcpy (new_resps, "   ");
  984. X        }
  985. X
  986. X        get_author (TRUE, index, from);
  987. X
  988. X        if (draw_arrow_mark) {
  989. X            if (threaded_on_subject) {
  990. X                printf ("  %4d%3s  %s\r\n", i, new_resps, from);
  991. X            } else {
  992. X                my_strncpy (subject, arts[index].subject, max_subj);
  993. X                printf ("  %4d%3s  %-*s   %-*s\r\n",
  994. X                    i, new_resps, max_subj, subject, max_from, from);
  995. X            }
  996. X        } else {
  997. X            if (threaded_on_subject) {
  998. X                sprintf (screen[j].col, "  %4d%3s  %-*s\r\n", i, new_resps, max_subj+max_from+5, from);
  999. X            } else {
  1000. X                my_strncpy (subject, arts[index].subject, max_subj+2);
  1001. X                sprintf (screen[j].col, "  %4d%3s  %-*s   %-*s\r\n",
  1002. X                    i, new_resps, max_subj+2, subject, max_from, from);
  1003. X            }
  1004. X            printf ("%s", screen[j].col);
  1005. X        }
  1006. X    }
  1007. X
  1008. #ifndef USE_CLEARSCREEN
  1009. X    CleartoEOS ();
  1010. #endif
  1011. X
  1012. X    if (last_thread_on_screen == top_thread) {
  1013. X        info_message (txt_end_of_thread);
  1014. X    }
  1015. X
  1016. X    draw_thread_arrow ();
  1017. }
  1018. X
  1019. X
  1020. void draw_thread_arrow ()
  1021. {
  1022. X    draw_arrow (INDEX_TOP + (thread_index_point-first_thread_on_screen));
  1023. }
  1024. X
  1025. X
  1026. void erase_thread_arrow ()
  1027. {
  1028. X    erase_arrow (INDEX_TOP + (thread_index_point-first_thread_on_screen));
  1029. }
  1030. X
  1031. X
  1032. int prompt_thread_num (ch)
  1033. X    char ch;
  1034. {
  1035. X    int num;
  1036. X
  1037. X    clear_message ();
  1038. X
  1039. X    if ((num = prompt_num (ch, txt_read_art)) == -1) {
  1040. X        clear_message ();
  1041. X        return FALSE;
  1042. X    }
  1043. X
  1044. X    if (num >= top_thread)
  1045. X        num = top_thread - 1;
  1046. X
  1047. X    if (num >= first_thread_on_screen
  1048. X    &&  num < last_thread_on_screen) {
  1049. X        erase_thread_arrow ();
  1050. X        thread_index_point = num;
  1051. X        draw_thread_arrow ();
  1052. X    } else {
  1053. #ifndef USE_CLEARSCREEN
  1054. X        erase_thread_arrow ();
  1055. #endif        
  1056. X        thread_index_point = num;
  1057. X        show_thread_page ();
  1058. X    }
  1059. X    return TRUE;
  1060. }
  1061. X
  1062. /*
  1063. X *  Return the number of unread articles there are within a thread
  1064. X */
  1065. X
  1066. int new_responses (thread)
  1067. X    int thread;
  1068. {
  1069. X    int i;
  1070. X    int sum = 0;
  1071. X
  1072. X    for (i = (int) base[thread]; i >= 0; i = arts[i].thread) {
  1073. X        if (arts[i].unread) {
  1074. X            sum++;
  1075. X        }
  1076. X    }
  1077. X    
  1078. X    return sum;
  1079. }
  1080. X
  1081. /*
  1082. X *  Which base note (an index into base[]) does a respnum
  1083. X *  (an index into arts[]) corresponsd to?
  1084. X *
  1085. X *  In other words, base[] points to an entry in arts[] which is
  1086. X *  the head of a thread, linked with arts[].thread.  For any q: arts[q],
  1087. X *  find i such that base[i]->arts[n]->arts[o]->...->arts[q]
  1088. X */
  1089. X
  1090. int which_thread (n)
  1091. X    int n;
  1092. {
  1093. X    register int i, j;
  1094. X
  1095. X    for (i = 0; i < top_base; i++) {
  1096. X        for (j = (int) base[i] ; j >= 0 ; j = arts[j].thread) {
  1097. X            if (j == n) {
  1098. X                return i;
  1099. X            }
  1100. X        }
  1101. X    }
  1102. X
  1103. X    sprintf (msg, "%d", n);
  1104. X    error_message (txt_cannot_find_base_art, msg);
  1105. X    return -1;
  1106. }
  1107. X
  1108. /*
  1109. X *  Find how deep in a thread a response is.  Start counting at zero
  1110. X */
  1111. X
  1112. int which_response (n)
  1113. X    int n;
  1114. {
  1115. X    int i, j;
  1116. X    int num = 0;
  1117. X
  1118. X    i = which_thread (n);
  1119. X
  1120. X    for (j = (int) base[i]; j != -1; j = arts[j].thread)
  1121. X        if (j == n)
  1122. X            break;
  1123. X        else
  1124. X            num++;
  1125. X
  1126. X    return num;
  1127. }
  1128. X
  1129. /*
  1130. X *  Given an index into base[], find the number of responses for
  1131. X *  that basenote
  1132. X */
  1133. X
  1134. int num_of_responses (n)
  1135. X    int n;
  1136. {
  1137. X    int i;
  1138. X    int oldi = -3;
  1139. X    int sum = 0;
  1140. X
  1141. X    assert (n < top_base);
  1142. X
  1143. X    for (i = (int) base[n]; i != -1; i = arts[i].thread) {
  1144. X        assert (i != -2);
  1145. X        assert (i != oldi);
  1146. X        oldi = i;
  1147. X        sum++;
  1148. X    }
  1149. X
  1150. X    return sum - 1;
  1151. }
  1152. X
  1153. /*
  1154. X *  Find the next response.  Go to the next basenote if there
  1155. X *  are no more responses in this thread
  1156. X */
  1157. X
  1158. int next_response (n)
  1159. X    int n;
  1160. {
  1161. X    int i;
  1162. X
  1163. X    if (arts[n].thread >= 0)
  1164. X        return arts[n].thread;
  1165. X
  1166. X    i = which_thread (n) + 1;
  1167. X
  1168. X    if (i >= top_base)
  1169. X        return -1;
  1170. X
  1171. X    return (int) base[i];
  1172. }
  1173. X
  1174. /*
  1175. X *  Given a respnum (index into arts[]), find the respnum of the
  1176. X *  next basenote
  1177. X */
  1178. X
  1179. int next_thread (n)
  1180. X    int n;
  1181. {
  1182. X    int i;
  1183. X
  1184. X    i = which_thread (n) + 1;
  1185. X    if (i >= top_base)
  1186. X        return -1;
  1187. X
  1188. X    return (int) base[i];
  1189. }
  1190. X
  1191. /*
  1192. X *  Find the previous response.  Go to the last response in the previous
  1193. X *  thread if we go past the beginning of this thread.
  1194. X */
  1195. X
  1196. int prev_response (n)
  1197. X    int n;
  1198. {
  1199. X    int resp;
  1200. X    int i;
  1201. X
  1202. X    resp = which_response (n);
  1203. X
  1204. X    if (resp > 0)
  1205. X        return choose_response (which_thread (n), resp-1);
  1206. X
  1207. X    i = which_thread (n) - 1;
  1208. X
  1209. X    if (i < 0)
  1210. X        return -1;
  1211. X
  1212. X    return choose_response (i, num_of_responses (i));
  1213. }
  1214. X
  1215. /*
  1216. X *  return response number n from thread i
  1217. X */
  1218. X
  1219. int choose_response (i, n)
  1220. X    int i;
  1221. X    int n;
  1222. {
  1223. X    int j;
  1224. X
  1225. X    j = (int) base[i];
  1226. X
  1227. X    while (n-- && arts[j].thread >= 0) {
  1228. X        j = arts[j].thread;
  1229. X    }
  1230. X
  1231. X    return j;
  1232. }
  1233. X
  1234. /*
  1235. X *  Find the next unread response in this group 
  1236. X */
  1237. X
  1238. int next_unread (n)
  1239. X    int n;
  1240. {
  1241. X    while (n >= 0) {
  1242. X        if (arts[n].unread == ART_UNREAD) {
  1243. X            return n;
  1244. X        }
  1245. X        n = next_response (n);
  1246. X    }
  1247. X
  1248. X    return -1;
  1249. }
  1250. X
  1251. X
  1252. /*
  1253. X *  Find the previous unread response in this thread
  1254. X */
  1255. X
  1256. int prev_unread (n)
  1257. X    int n;
  1258. {
  1259. X    while (n >= 0) {
  1260. X        if (arts[n].unread == ART_UNREAD) {
  1261. X            return n;
  1262. X        }
  1263. X        n = prev_response (n);
  1264. X    }
  1265. X
  1266. X    return -1;
  1267. }
  1268. SHAR_EOF
  1269. chmod 0600 thread.c ||
  1270. echo 'restore of thread.c failed'
  1271. Wc_c="`wc -c < 'thread.c'`"
  1272. test 14120 -eq "$Wc_c" ||
  1273.     echo 'thread.c: original size 14120, current size' "$Wc_c"
  1274. rm -f _shar_wnt_.tmp
  1275. fi
  1276. # ============= wildmat.c ==============
  1277. if test -f 'wildmat.c' -a X"$1" != X"-c"; then
  1278.     echo 'x - skipping wildmat.c (File already exists)'
  1279.     rm -f _shar_wnt_.tmp
  1280. else
  1281. > _shar_wnt_.tmp
  1282. echo 'x - extracting wildmat.c (Text)'
  1283. sed 's/^X//' << 'SHAR_EOF' > 'wildmat.c' &&
  1284. /*  $Revision: 1.5 $
  1285. **
  1286. **  Do shell-style pattern matching for ?, \, [], and * characters.
  1287. **  Might not be robust in face of malformed patterns; e.g., "foo[a-"
  1288. **  could cause a segmentation violation.  It is 8bit clean.
  1289. **
  1290. **  Written by Rich $alz, mirror!rs, Wed Nov 26 19:03:17 EST 1986.
  1291. **  Rich $alz is now <rsalz@bbn.com>.
  1292. **  April, 1991:  Replaced mutually-recursive calls with in-line code
  1293. **  for the star character.
  1294. **
  1295. **  Special thanks to Lars Mathiesen <thorinn@diku.dk> for the ABORT code.
  1296. **  This can greatly speed up failing wildcard patterns.  For example:
  1297. **    pattern: -*-*-*-*-*-*-12-*-*-*-m-*-*-*
  1298. **    text 1:     -adobe-courier-bold-o-normal--12-120-75-75-m-70-iso8859-1
  1299. **    text 2:     -adobe-courier-bold-o-normal--12-120-75-75-X-70-iso8859-1
  1300. **  Text 1 matches with 51 calls, while text 2 fails with 54 calls.  Without
  1301. **  the ABORT, then it takes 22310 calls to fail.  Ugh.  The following
  1302. **  explanation is from Lars:
  1303. **  The precondition that must be fulfilled is that DoMatch will consume
  1304. **  at least one character in text.  This is true if *p is neither '*' nor
  1305. **  '\0'.)  The last return has ABORT instead of FALSE to avoid quadratic
  1306. **  behaviour in cases like pattern "*a*b*c*d" with text "abcxxxxx".  With
  1307. **  FALSE, each star-loop has to run to the end of the text; with ABORT
  1308. **  only the last one does.
  1309. **
  1310. **  Once the control of one instance of DoMatch enters the star-loop, that
  1311. **  instance will return either TRUE or ABORT, and any calling instance
  1312. **  will therefore return immediately after (without calling recursively
  1313. **  again).  In effect, only one star-loop is ever active.  It would be
  1314. **  possible to modify the code to maintain this context explicitly,
  1315. **  eliminating all recursive calls at the cost of some complication and
  1316. **  loss of clarity (and the ABORT stuff seems to be unclear enough by
  1317. **  itself).  I think it would be unwise to try to get this into a
  1318. **  released version unless you have a good test data base to try it out
  1319. **  on.
  1320. */
  1321. X
  1322. #define TRUE            1
  1323. #define FALSE            0
  1324. #define ABORT            -1
  1325. X
  1326. X
  1327. X    /* What character marks an inverted character class? */
  1328. #define NEGATE_CLASS        '^'
  1329. X    /* Is "*" a common pattern? */
  1330. #define OPTIMIZE_JUST_STAR
  1331. X    /* Do tar(1) matching rules, which ignore a trailing slash? */
  1332. #undef MATCH_TAR_PATTERN
  1333. X
  1334. X
  1335. /*
  1336. **  Match text and p, return TRUE, FALSE, or ABORT.
  1337. */
  1338. static int
  1339. DoMatch(text, p)
  1340. X    register char    *text;
  1341. X    register char    *p;
  1342. {
  1343. X    register int    last;
  1344. X    register int    matched;
  1345. X    register int    reverse;
  1346. X
  1347. X    for ( ; *p; text++, p++) {
  1348. X    if (*text == '\0' && *p != '*')
  1349. X        return ABORT;
  1350. X    switch (*p) {
  1351. X    case '\\':
  1352. X        /* Literal match with following character. */
  1353. X        p++;
  1354. X        /* FALLTHROUGH */
  1355. X    default:
  1356. X        if (*text != *p)
  1357. X        return FALSE;
  1358. X        continue;
  1359. X    case '?':
  1360. X        /* Match anything. */
  1361. X        continue;
  1362. X    case '*':
  1363. X        while (*++p == '*')
  1364. X        /* Consecutive stars act just like one. */
  1365. X        continue;
  1366. X        if (*p == '\0')
  1367. X        /* Trailing star matches everything. */
  1368. X        return TRUE;
  1369. X        while (*text)
  1370. X        if ((matched = DoMatch(text++, p)) != FALSE)
  1371. X            return matched;
  1372. X        return ABORT;
  1373. X    case '[':
  1374. X        reverse = p[1] == NEGATE_CLASS ? TRUE : FALSE;
  1375. X        if (reverse)
  1376. X        /* Inverted character class. */
  1377. X        p++;
  1378. X        matched = FALSE;
  1379. X        if (p[1] == ']' || p[1] == '-')
  1380. X        if (*++p == *text)
  1381. X            matched = TRUE;
  1382. X        for (last = *p; *++p && *p != ']'; last = *p)
  1383. X        /* This next line requires a good C compiler. */
  1384. X        if (*p == '-' && p[1] != ']'
  1385. X            ? *text <= *++p && *text >= last : *text == *p)
  1386. X            matched = TRUE;
  1387. X        if (matched == reverse)
  1388. X        return FALSE;
  1389. X        continue;
  1390. X    }
  1391. X    }
  1392. X
  1393. #ifdef    MATCH_TAR_PATTERN
  1394. X    if (*text == '/')
  1395. X    return TRUE;
  1396. #endif    /* MATCH_TAR_ATTERN */
  1397. X    return *text == '\0';
  1398. }
  1399. X
  1400. X
  1401. /*
  1402. **  User-level routine.  Returns TRUE or FALSE.
  1403. */
  1404. int
  1405. wildmat(text, p)
  1406. X    char    *text;
  1407. X    char    *p;
  1408. {
  1409. #ifdef    OPTIMIZE_JUST_STAR
  1410. X    if (p[0] == '*' && p[1] == '\0')
  1411. X    return TRUE;
  1412. #endif    /* OPTIMIZE_JUST_STAR */
  1413. X    return DoMatch(text, p) == TRUE;
  1414. }
  1415. X
  1416. X
  1417. X
  1418. #ifdef    TEST
  1419. #include <stdio.h>
  1420. X
  1421. /* Yes, we use gets not fgets.  Sue me. */
  1422. extern char    *gets();
  1423. X
  1424. X
  1425. main()
  1426. {
  1427. X    char     p[80];
  1428. X    char     text[80];
  1429. X
  1430. X    printf("Wildmat tester.  Enter pattern, then strings to test.\n");
  1431. X    printf("A blank line gets prompts for a new pattern; a blank pattern\n");
  1432. X    printf("exits the program.\n");
  1433. X
  1434. X    for ( ; ; ) {
  1435. X    printf("\nEnter pattern:  ");
  1436. X    (void)fflush(stdout);
  1437. X    if (gets(p) == NULL || p[0] == '\0')
  1438. X        break;
  1439. X    for ( ; ; ) {
  1440. X        printf("Enter text:  ");
  1441. X        (void)fflush(stdout);
  1442. X        if (gets(text) == NULL)
  1443. X        exit(0);
  1444. X        if (text[0] == '\0')
  1445. X        /* Blank line; go back and get a new pattern. */
  1446. X        break;
  1447. X        printf("      %s\n", wildmat(text, p) ? "YES" : "NO");
  1448. X    }
  1449. X    }
  1450. X
  1451. X    exit(0);
  1452. X    /* NOTREACHED */
  1453. }
  1454. #endif    /* TEST */
  1455. SHAR_EOF
  1456. chmod 0600 wildmat.c ||
  1457. echo 'restore of wildmat.c failed'
  1458. Wc_c="`wc -c < 'wildmat.c'`"
  1459. test 4749 -eq "$Wc_c" ||
  1460.     echo 'wildmat.c: original size 4749, current size' "$Wc_c"
  1461. rm -f _shar_wnt_.tmp
  1462. fi
  1463. # ============= tin.h ==============
  1464. if test -f 'tin.h' -a X"$1" != X"-c"; then
  1465.     echo 'x - skipping tin.h (File already exists)'
  1466.     rm -f _shar_wnt_.tmp
  1467. else
  1468. > _shar_wnt_.tmp
  1469. echo 'x - extracting tin.h (Text)'
  1470. sed 's/^X//' << 'SHAR_EOF' > 'tin.h' &&
  1471. /*
  1472. X *  Project   : tin - a threaded Netnews reader
  1473. X *  Module    : tin.h
  1474. X *  Author    : R.Skrenta / I.Lea
  1475. X *  Created   : 01-04-91
  1476. X *  Updated   : 21-01-92
  1477. X *  Notes     : #include files, #defines & struct's
  1478. X *  Copyright : (c) Copyright 1991-92 by Rich Skrenta & Iain Lea
  1479. X *              You may  freely  copy or  redistribute  this software,
  1480. X *              so  long as there is no profit made from its use, sale
  1481. X *              trade or  reproduction.  You may not change this copy-
  1482. X *              right notice, and it must be included in any copy made
  1483. X */
  1484. X
  1485. #include    <stdio.h>
  1486. #include    <signal.h>
  1487. #include    <sys/types.h>
  1488. #include    <pwd.h>
  1489. #ifndef MINIX
  1490. #    include    <memory.h>
  1491. #endif
  1492. #include    <ctype.h>
  1493. #include    <time.h>
  1494. #include    <sys/stat.h>
  1495. X
  1496. #ifdef BSD
  1497. #    include    <strings.h>
  1498. #else
  1499. #    include    <string.h>
  1500. #    ifndef MINIX
  1501. #        include    <malloc.h>
  1502. #    else
  1503. #        include    <stdlib.h>
  1504. #    endif
  1505. #endif
  1506. X
  1507. #ifdef SCO_UNIX
  1508. #    include    <sys/streams.h>
  1509. #    include    <sys/ptem.h>
  1510. #endif
  1511. X
  1512. #ifdef M_XENIX
  1513. #    include    <prototypes.h>
  1514. #endif
  1515. X
  1516. #if defined(SIGWINCH) || defined(SINIX)
  1517. #    include    <sys/ioctl.h>
  1518. #    ifdef AUTO_RESIZE
  1519. #        include    <sys/ttold.h>        /* needed for resizing under an xterm */
  1520. #    endif
  1521. #endif
  1522. X
  1523. #if __STDC__
  1524. #    define    SIGTYPE    void
  1525. #else
  1526. #    define    SIGTYPE    int
  1527. #endif
  1528. X
  1529. #ifndef SPOOLDIR
  1530. #    define        SPOOLDIR    "/usr/spool/news"
  1531. #endif
  1532. #ifndef LIBDIR
  1533. #    define        LIBDIR        "/usr/lib/news"
  1534. #endif
  1535. #ifndef INEWSDIR
  1536. #    define        INEWSDIR    LIBDIR
  1537. #endif
  1538. X
  1539. #define        DEFAULT_SHELL    "/bin/sh"
  1540. X
  1541. #ifdef BSD
  1542. #    define        DEFAULT_EDITOR    "/usr/ucb/vi"
  1543. #    define        DEFAULT_MAILER    "/bin/rmail"
  1544. #    define        DEFAULT_MAILBOX    "/usr/spool/mail"
  1545. #    define        DEFAULT_PRINTER    "/usr/ucb/lpr"
  1546. #    define        DEFAULT_SUM        "sum"
  1547. #    ifndef USE_LONG_FILENAMES
  1548. #        define USE_LONG_FILENAMES
  1549. #    endif
  1550. #    define        DEFAULT_ACTIVE_NUM    1600    /* initial size of active array */
  1551. #    define        DEFAULT_ARTICLE_NUM    400        /* initial size of art array */ 
  1552. #else
  1553. #    ifdef M_XENIX
  1554. #        define        DEFAULT_EDITOR    "/bin/vi"
  1555. #        define        DEFAULT_MAILBOX    "/usr/spool/mail"
  1556. #    else
  1557. #        define        DEFAULT_EDITOR    "/usr/bin/vi"
  1558. #        define        DEFAULT_MAILBOX    "/usr/mail"
  1559. #    endif
  1560. #    ifdef NCR
  1561. #        define        DEFAULT_MAILER    "/usr/bin/mailx"
  1562. #    endif
  1563. #    ifdef RS6000
  1564. #        define        DEFAULT_PRINTER    "/bin/lp"
  1565. #    endif
  1566. #    ifdef UNIXPC
  1567. #        define        DEFAULT_MAILER    "/bin/rmail"
  1568. #    endif
  1569. #    ifdef SINIX
  1570. #        define        DEFAULT_MAILER    "/bin/rmail"
  1571. #        define        DEFAULT_PRINTER    "/bin/lpr"
  1572. #        ifndef USE_LONG_FILENAMES
  1573. #            define USE_LONG_FILENAMES
  1574. #        endif
  1575. #    endif
  1576. #    ifndef DEFAULT_MAILER
  1577. #        define        DEFAULT_MAILER    "/usr/bin/mail"
  1578. #    endif
  1579. #    ifndef DEFAULT_PRINTER
  1580. #        define        DEFAULT_PRINTER    "/usr/bin/lp"
  1581. #    endif
  1582. #    define        DEFAULT_SUM        "sum -r"
  1583. #    define        DEFAULT_ACTIVE_NUM    400        /* initial size of active array */
  1584. #    define        DEFAULT_ARTICLE_NUM    200        /* initial size of art array */ 
  1585. #endif
  1586. X
  1587. #ifdef USE_LONG_FILENAMES
  1588. #    define        LONG_PATH_PART    "part"
  1589. #    define        LONG_PATH_PATCH    "patch"
  1590. #else
  1591. #    define        LONG_PATH_PART    ""
  1592. #    define        LONG_PATH_PATCH    "p"
  1593. #endif
  1594. X
  1595. #ifdef LOG_USER
  1596. #    define        LOG_USER_FILE    "/tmp/.tin_log" 
  1597. #endif
  1598. X
  1599. #define        DEFAULT_KILL_NUM    10        /* initial size of kill array */ 
  1600. #define        DEFAULT_SAVE_NUM    10        /* initial size of save array */ 
  1601. X
  1602. #define        RCDIR            ".tin"
  1603. #define        RCFILE            "tinrc"
  1604. #define        INDEXDIR        ".index"
  1605. #define        KILLFILE        "kill"
  1606. #define        POSTFILE        "posted"
  1607. #define        UNTHREADFILE    "unthread"
  1608. #define        DEFAULT_MAILDIR    "Mail"
  1609. X
  1610. /*
  1611. #define BUG_REPORT_ADDRESS    "iain@estevax.uucp"
  1612. */
  1613. #define BUG_REPORT_ADDRESS    "iain%estevax.uucp@unido.Informatik.Uni-Dortmund.DE"
  1614. X
  1615. #ifdef TRUE
  1616. #    undef TRUE
  1617. #    define        TRUE        1
  1618. #else    
  1619. #    define        TRUE        1
  1620. #endif
  1621. X
  1622. #ifdef FALSE
  1623. #    undef FALSE
  1624. #    define        FALSE        0
  1625. #else    
  1626. #    define        FALSE        0
  1627. #endif
  1628. X
  1629. #define        LEN                1024
  1630. #define        MODULO_COUNT_NUM    5
  1631. #define        HEADER_LEN        1024
  1632. #define        TABLE_SIZE        1409
  1633. #define        MAX_PAGES        1000
  1634. #define        ctrl(c)            ((c) & 0x1F)
  1635. X
  1636. #define        DEFAULT_COMMENT    ": "    /* used when by follow-ups & replys */
  1637. #ifndef UNREAD_ART_MARK
  1638. #    define        UNREAD_ART_MARK    '+'        /* used to show that an art is unread */
  1639. #endif
  1640. X
  1641. #ifdef USE_INVERSE_HACK
  1642. #    define        BLANK_SELECT_COLS        60
  1643. #    define        BLANK_GROUP_COLS        2
  1644. #    define        BLANK_PAGE_COLS            2
  1645. #else
  1646. #    define        BLANK_SELECT_COLS        58
  1647. #    define        BLANK_GROUP_COLS        0
  1648. #    define        BLANK_PAGE_COLS            0
  1649. #endif
  1650. X
  1651. #define        SCREEN_READ_UNREAD        6        /* position for "  +" / "   " */
  1652. #define        DEFAULT_COLS            132        /* used when updating indexes */
  1653. #define        INDEX_TOP                2
  1654. X
  1655. /*
  1656. X *  used by get_arrow_key()
  1657. X */
  1658. X
  1659. #define        KEYMAP_UNKNOWN            0
  1660. #define        KEYMAP_UP                1
  1661. #define        KEYMAP_DOWN                2
  1662. #define        KEYMAP_PAGE_UP            3
  1663. #define        KEYMAP_PAGE_DOWN        4
  1664. #define        KEYMAP_HOME                5
  1665. #define        KEYMAP_END                6
  1666. X
  1667. /*
  1668. X *  used by feed.c - feed_articles()
  1669. X */
  1670. X 
  1671. #define        SELECT_LEVEL            1
  1672. #define        GROUP_LEVEL                2
  1673. #define        PAGE_LEVEL                3
  1674. X
  1675. #define        FEED_MAIL                1
  1676. #define        FEED_PIPE                2
  1677. #define        FEED_PRINT                3
  1678. #define        FEED_SAVE                4
  1679. X
  1680. /*
  1681. X *  used in art.c & rcfile.c
  1682. X */
  1683. X 
  1684. #define        SORT_BY_NOTHING            0        /* sort types on arts[] array */
  1685. #define        SORT_BY_SUBJ_DESCEND    1
  1686. #define        SORT_BY_SUBJ_ASCEND        2
  1687. #define        SORT_BY_FROM_DESCEND    3
  1688. #define        SORT_BY_FROM_ASCEND        4
  1689. #define        SORT_BY_DATE_DESCEND    5
  1690. #define        SORT_BY_DATE_ASCEND        6
  1691. X
  1692. #define        SHOW_FROM_NONE            0
  1693. #define        SHOW_FROM_ADDR            1
  1694. #define        SHOW_FROM_NAME            2
  1695. #define        SHOW_FROM_BOTH            3
  1696. X
  1697. /*
  1698. X *  used in help.c
  1699. X */
  1700. X
  1701. #define        HELP_INFO                0
  1702. #define        POST_INFO                1
  1703. X
  1704. /*
  1705. X *  used in save.c
  1706. X */
  1707. X
  1708. #define        CHECK_ANY_NEWS            0
  1709. #define        START_ANY_NEWS            1
  1710. #define        MAIL_ANY_NEWS            2
  1711. #define        SAVE_ANY_NEWS            3
  1712. X
  1713. /*
  1714. X *  used in help.c
  1715. X */
  1716. X
  1717. #define        HEADER_TO                0
  1718. #define        HEADER_SUBJECT            1
  1719. X
  1720. /*
  1721. X *  used in page.c & post.c
  1722. X */
  1723. X
  1724. #define        POSTED_NONE            0
  1725. #define        POSTED_REDRAW            1
  1726. #define        POSTED_OK            2
  1727. X
  1728. /*
  1729. X *  Assertion verifier
  1730. X */
  1731. X
  1732. #if __STDC__
  1733. #    define    assert(p)    if(! (p)) asfail(__FILE__, __LINE__, #p); else
  1734. #else
  1735. #    define    assert(p)    if(! (p)) asfail(__FILE__, __LINE__, "p"); else
  1736. #endif
  1737. X
  1738. #define        ESC        27
  1739. #if defined(BSD) || defined(MINIX)
  1740. #    define        CR        '\r'
  1741. #else
  1742. #    define        CR        10
  1743. #endif
  1744. X
  1745. /*
  1746. X * return codes for change_rcfile ()
  1747. X */
  1748. X
  1749. #define        NO_KILLING        0
  1750. #define        KILLING            1
  1751. X
  1752. /*
  1753. X *  art.thread
  1754. X */
  1755. X
  1756. #define        ART_NORMAL        -1
  1757. #define        ART_EXPIRED        -2
  1758. X
  1759. /*
  1760. X *  art.unread
  1761. X */
  1762. X
  1763. #define        ART_READ        0
  1764. #define        ART_UNREAD        1
  1765. #define        ART_WILL_RETURN    2
  1766. X
  1767. /*
  1768. X * used by group_t & my_group[]
  1769. X */
  1770. X 
  1771. #define        UNSUBSCRIBED    0x01    /* haven't put in my_group[] yet */
  1772. #define        SUBSCRIBED        0x02    /* subscribed to */
  1773. X
  1774. /*
  1775. X * kill_type used in struct kill_t
  1776. X */
  1777. X 
  1778. #define KILL_SUBJ    1
  1779. #define KILL_FROM    2
  1780. #define KILL_BOTH    3
  1781. X
  1782. /*
  1783. X * used in feed.c & save.c
  1784. X */
  1785. X 
  1786. #define POST_PROC_NONE            0
  1787. #define POST_PROC_SHAR            1
  1788. #define POST_PROC_UUDECODE        2
  1789. #define POST_PROC_UUD_LST_ZOO    3
  1790. #define POST_PROC_UUD_EXT_ZOO    4
  1791. X
  1792. /*
  1793. X *  struct article_t - article header
  1794. X *
  1795. X *  article.artnum:
  1796. X *    article number in spool directory for group
  1797. X *
  1798. X *  article.thread:
  1799. X *    initially -1
  1800. X *    points to another arts[] (struct article_t): zero and up
  1801. X *    -2 means article has expired (wasn't found in file search
  1802. X *    of spool directory for the group)
  1803. X *
  1804. X *  article.inthread:
  1805. X *    FALSE for the first article in a thread, TRUE for all
  1806. X *    following articles in thread
  1807. X *
  1808. X *  article.unread:
  1809. X *    boolean, has this article been read or not
  1810. X *
  1811. X *  article.date
  1812. X *  date: line used for sorting articles by date order
  1813. X *
  1814. X *  article.archive:
  1815. X *    archive name used in *source* groups
  1816. X *
  1817. X *  article.part:
  1818. X *    part no. of archive
  1819. X *
  1820. X *  article.patch:
  1821. X *    patch no. of archive
  1822. X *
  1823. X *  article.killed:
  1824. X *    boolean, has this article been killed
  1825. X *
  1826. X *  article.tagged:
  1827. X *    boolean, has this article been tagged for saving or not
  1828. X */
  1829. X
  1830. struct article_t {
  1831. X    long artnum;
  1832. X    char *subject;    /* Subject: line from mail header */
  1833. X    char *from;        /* From: line from mail header (address) */
  1834. X    char *name;        /* From: line from mail header (full name) */
  1835. X    int thread;
  1836. X    int inthread;
  1837. X    int unread;        /* 0 = read, 1 = unread, 2 = will return */
  1838. X    char date[16];    /* Date: line from mail header */
  1839. X    char *archive;    /* Archive-name: line from mail header */
  1840. X    char *part;        /* part no. of archive */
  1841. X    char *patch;    /* patch no. of archive */
  1842. X    int killed;        /* 0 = not killed, 1 = killed */
  1843. X    int tagged;        /* 0 = not tagged, 1 = tagged */
  1844. };
  1845. X
  1846. /*
  1847. X *  struct group_t - newsgroup info from active file
  1848. X */
  1849. X
  1850. struct group_t {
  1851. X    char *name;
  1852. X    long max;
  1853. X    long min;
  1854. X    char moderated;
  1855. X    int next;        /* next active entry in hash chain */
  1856. X    int flag;
  1857. X    int read;        /* marked TRUE if group was entered during session */
  1858. X    int thread;        /* marked FALSE if group is not to be threaded */
  1859. };
  1860. X
  1861. /*
  1862. X *  used in hashstr.c
  1863. X */
  1864. X 
  1865. struct hashnode {
  1866. X    char *s;                        /* the string we're saving */
  1867. X    struct hashnode *next;            /* chain for spillover */
  1868. };
  1869. X
  1870. /*
  1871. X *  used in kill.c
  1872. X */
  1873. X 
  1874. struct kill_t {
  1875. X    int kill_type;
  1876. X    long kill_group;
  1877. X    char *kill_subj;
  1878. X    char *kill_from;
  1879. };
  1880. X
  1881. struct save_t {
  1882. X    char *subject;
  1883. X    char *dir;
  1884. X    char *file;
  1885. X    char *archive;
  1886. X    char *part;
  1887. X    char *patch;
  1888. X    int index;    
  1889. X    int saved;    
  1890. X    int is_mailbox;    
  1891. };
  1892. X
  1893. struct screen_t {
  1894. X    char *col;
  1895. };
  1896. X
  1897. struct posted_t {
  1898. X    char date[10];
  1899. X    char group[80];
  1900. X    char subj[120];
  1901. };
  1902. X
  1903. /*
  1904. X *  function prototypes    & extern definitions    
  1905. X */ 
  1906. X
  1907. #include    "patchlev.h"
  1908. #include    "extern.h"
  1909. #include    "proto.h"
  1910. SHAR_EOF
  1911. chmod 0600 tin.h ||
  1912. echo 'restore of tin.h failed'
  1913. Wc_c="`wc -c < 'tin.h'`"
  1914. test 8937 -eq "$Wc_c" ||
  1915.     echo 'tin.h: original size 8937, current size' "$Wc_c"
  1916. rm -f _shar_wnt_.tmp
  1917. fi
  1918. # ============= extern.h ==============
  1919. if test -f 'extern.h' -a X"$1" != X"-c"; then
  1920.     echo 'x - skipping extern.h (File already exists)'
  1921.     rm -f _shar_wnt_.tmp
  1922. else
  1923. > _shar_wnt_.tmp
  1924. echo 'x - extracting extern.h (Text)'
  1925. sed 's/^X//' << 'SHAR_EOF' > 'extern.h' &&
  1926. /*
  1927. X *  Project   : tin - a threaded Netnews reader
  1928. X *  Module    : lang.h
  1929. X *  Author    : I.Lea
  1930. X *  Created   : 01-04-91
  1931. X *  Updated   : 08-02-92
  1932. X *  Notes     :
  1933. X *  Copyright : (c) Copyright 1991-92 by Iain Lea
  1934. X *              You may  freely  copy or  redistribute  this software,
  1935. X *              so  long as there is no profit made from its use, sale
  1936. X *              trade or  reproduction.  You may not change this copy-
  1937. X *              right notice, and it must be included in any copy made
  1938. X */
  1939. X
  1940. extern char *help_group[];
  1941. extern char *help_page[];
  1942. extern char *help_select[];
  1943. extern char *help_thread[];
  1944. extern char active_file[LEN];
  1945. extern char add_addr[LEN];
  1946. extern char art_search_string[LEN];
  1947. extern char article[LEN];
  1948. extern char author_search_string[LEN];
  1949. extern char bug_addr[LEN];
  1950. extern char cvers[LEN];
  1951. extern char dead_article[LEN];
  1952. extern char default_mail_address[LEN];
  1953. extern char default_pipe_command[LEN];
  1954. extern char default_post_subject[LEN];
  1955. extern char default_regex_pattern[LEN];
  1956. extern char default_save_file[LEN];
  1957. extern char default_shell_command[LEN];
  1958. extern char delgroups[LEN];
  1959. extern char group_search_string[LEN];
  1960. extern char homedir[LEN];
  1961. extern char indexdir[LEN];
  1962. extern char killfile[LEN];
  1963. extern char killfrom[LEN];
  1964. extern char killsubj[LEN];
  1965. extern char mail_news_user[LEN];
  1966. extern char mailbox[LEN];
  1967. extern char maildir[LEN];
  1968. extern char mailer[LEN];
  1969. extern char msg[LEN];
  1970. extern char my_org[LEN];
  1971. extern char newnewsrc[LEN];
  1972. extern char newsrc[LEN];
  1973. extern char nntp_server[LEN];
  1974. extern char page_header[LEN];
  1975. extern char postfile[LEN];
  1976. extern char printer[LEN];
  1977. extern char cmd_line_printer[LEN];
  1978. extern char proc_ch_default;                /* set in change_rcfile () */
  1979. extern char progname[LEN];
  1980. extern char rcdir[LEN];
  1981. extern char rcfile[LEN];
  1982. extern char redirect_output[LEN];
  1983. extern char reply_to[LEN];
  1984. extern char savedir[LEN];
  1985. extern char sig[LEN];
  1986. extern char signature[LEN];
  1987. extern char spooldir[LEN];
  1988. extern char subject_search_string[LEN];
  1989. extern char txt_help_bug_report[LEN];
  1990. extern char unthreadfile[LEN];
  1991. extern char userid[LEN];
  1992. X
  1993. extern char txt_group[];
  1994. extern char txt_cannot_open_art[];
  1995. extern char txt_indexing[];
  1996. extern char txt_indexing_num[];
  1997. extern char txt_corrupt_index[];
  1998. extern char txt_checking_for_news[];
  1999. extern char txt_there_is_no_news[];
  2000. extern char txt_killing_arts[];
  2001. extern char txt_unkilling_arts[];
  2002. extern char txt_art_thread_regex_tag[];
  2003. extern char txt_post_process_type[];
  2004. extern char txt_feed_pattern[];
  2005. extern char txt_no_command[];
  2006. extern char txt_piping[];
  2007. extern char txt_cannot_post[];
  2008. extern char txt_tagged_art[];
  2009. extern char txt_untagged_art[];
  2010. extern char txt_inverse_on[];
  2011. extern char txt_inverse_off[];
  2012. extern char txt_subscribed_to[];
  2013. extern char txt_unsubscribed_to[];
  2014. extern char txt_mark_all_read[];
  2015. extern char txt_no_more_groups[];
  2016. extern char txt_no_prev_group[];
  2017. extern char txt_no_arts[];
  2018. extern char txt_no_groups[];
  2019. extern char txt_end_of_thread[];
  2020. extern char txt_end_of_arts[];
  2021. extern char txt_end_of_groups[];
  2022. extern char txt_no_next_unread_art[];
  2023. extern char txt_no_prev_unread_art[];
  2024. extern char txt_no_last_message[];
  2025. extern char txt_bad_command[];
  2026. extern char txt_you_have_mail[];
  2027. extern char txt_type_h_for_help[];
  2028. extern char txt_read_art[];
  2029. extern char txt_author_search_forwards[];
  2030. extern char txt_author_search_backwards[];
  2031. extern char txt_search_forwards[];
  2032. extern char txt_search_backwards[];
  2033. extern char txt_no_search_string[];
  2034. extern char txt_no_match[];
  2035. extern char txt_post_subject[];
  2036. extern char txt_no_subject[];
  2037. extern char txt_cannot_open[];
  2038. extern char txt_posting[];
  2039. extern char txt_art_posted[];
  2040. extern char txt_art_rejected[];
  2041. extern char txt_abort_edit_post[];
  2042. extern char txt_index_page_com[];
  2043. extern char txt_thread_com[];
  2044. extern char txt_help_i_4[];
  2045. extern char txt_help_ctrl_k[];
  2046. extern char txt_help_ctrl_l[];
  2047. extern char txt_help_ctrl_d[];
  2048. extern char txt_help_i_cr[];
  2049. extern char txt_help_i_tab[];
  2050. extern char txt_help_d[];
  2051. extern char txt_help_l[];
  2052. extern char txt_help_m[];
  2053. extern char txt_help_M[];
  2054. extern char txt_help_a[];
  2055. extern char txt_help_sel_c[];
  2056. extern char txt_help_c[];
  2057. extern char txt_help_g[];
  2058. extern char txt_help_I[];
  2059. extern char txt_help_K[];
  2060. extern char txt_help_t_K[];
  2061. extern char txt_help_j[];
  2062. extern char txt_help_i_n[];
  2063. extern char txt_help_i_p[];
  2064. extern char txt_help_q[];
  2065. extern char txt_help_s[];
  2066. extern char txt_help_S[];
  2067. extern char txt_help_t[];
  2068. extern char txt_help_T[];
  2069. extern char txt_help_u[];
  2070. extern char txt_help_U[];
  2071. extern char txt_help_v[];
  2072. extern char txt_help_w[];
  2073. extern char txt_help_i_search[];
  2074. extern char txt_help_thread[];
  2075. #ifndef NO_SHELL_ESCAPE
  2076. extern char txt_help_shell[];
  2077. #endif
  2078. extern char txt_help_dash[];
  2079. extern char txt_save_pattern[];
  2080. extern char txt_saved_pattern_to[];
  2081. extern char txt_saved_to_mailbox[];
  2082. extern char txt_switch_on_kill_art_menu[];
  2083. extern char txt_post_history_menu[];
  2084. extern char txt_hit_space_for_more[];
  2085. extern char txt_kill_menu[];
  2086. extern char txt_kill_subject[];
  2087. extern char txt_kill_from[];
  2088. extern char txt_kill_text[];
  2089. extern char txt_kill_text_type[];
  2090. extern char txt_kill_group[];
  2091. extern char txt_help_kill_subject[];
  2092. extern char txt_help_kill_from[];
  2093. extern char txt_help_kill_text[];
  2094. extern char txt_help_kill_text_type[];
  2095. extern char txt_help_kill_group[];
  2096. extern char txt_abort_edit_save_killfile[];
  2097. extern char txt_quit[];
  2098. extern char txt_art_unavailable[];
  2099. extern char txt_art_marked_as_unread[];
  2100. extern char txt_thread_marked_as_unread[];
  2101. extern char txt_begin_of_art[];
  2102. extern char txt_next_resp[];
  2103. extern char txt_last_resp[];
  2104. extern char txt_more_percent[];
  2105. extern char txt_more[];
  2106. extern char txt_thread_x_of_n[];
  2107. extern char txt_art[];
  2108. extern char txt_resp_x_of_n[];
  2109. extern char txt_no_resp[];
  2110. extern char txt_1_resp[];
  2111. extern char txt_x_resp[];
  2112. extern char txt_s_at_s[];
  2113. extern char txt_thread_resp_page[];
  2114. extern char txt_thread_page[];
  2115. extern char txt_read_resp[];
  2116. extern char txt_art_pager_com[];
  2117. extern char txt_help_p_0[];
  2118. extern char txt_help_p_4[];
  2119. extern char txt_help_p_cr[];
  2120. extern char txt_help_p_tab[];
  2121. extern char txt_help_b[];
  2122. extern char txt_help_C[];
  2123. extern char txt_help_bug[];
  2124. extern char txt_help_p_f[];
  2125. extern char txt_help_ctrl_h[];
  2126. extern char txt_help_h[];
  2127. extern char txt_help_p_i[];
  2128. extern char txt_help_p_k[];
  2129. extern char txt_help_p_m[];
  2130. extern char txt_help_p_n[];
  2131. extern char txt_help_o[];
  2132. extern char txt_help_p_p[];
  2133. extern char txt_help_p_r[];
  2134. extern char txt_help_p_s[];
  2135. extern char txt_help_p_z[];
  2136. extern char txt_help_p_ctrl_r[];
  2137. extern char txt_help_p_g[];
  2138. extern char txt_help_p_d[];
  2139. extern char txt_help_pipe[];
  2140. extern char txt_help_p_search[];
  2141. extern char txt_mail_art_to[];
  2142. extern char txt_no_mail_address[];
  2143. extern char txt_abort_edit_send[];
  2144. extern char txt_abort_edit_cancel[];
  2145. extern char txt_cancelling[];
  2146. extern char txt_art_cancelled[];
  2147. extern char txt_mailing_to[];
  2148. extern char txt_message_sent[];
  2149. extern char txt_command_failed_s[];
  2150. extern char txt_in_art_you_write[];
  2151. extern char txt_resp_to_poster[];
  2152. extern char txt_resp_redirect[];
  2153. extern char txt_continue[];
  2154. extern char txt_writes[];
  2155. extern char txt_writes_name[];
  2156. extern char txt_save_filename[];
  2157. extern char txt_art_not_saved[];
  2158. extern char txt_no_filename[];
  2159. extern char txt_saving[];
  2160. extern char txt_art_saved_to[];
  2161. extern char txt_thread_not_saved[];
  2162. extern char txt_thread_saved_to_many[];
  2163. extern char txt_thread_saved_to[];
  2164. extern char txt_pipe_to_command[];
  2165. extern char txt_command_failed[];
  2166. extern char txt_printing[];
  2167. extern char txt_printed[];
  2168. extern char txt_append_to_file[];
  2169. extern char txt_hit_any_key[];
  2170. extern char txt_nntp_not_enabled[];
  2171. extern char txt_recompile_with_nntp_option[];
  2172. extern char txt_not_in_active_file[];
  2173. extern char txt_screen_init_failed[];
  2174. extern char txt_bad_active_file[];
  2175. extern char txt_creating_newsrc[];
  2176. extern char txt_reading_active_file[];
  2177. extern char txt_cannot_find_base_art[];
  2178. extern char txt_out_of_memory[];
  2179. extern char txt_rename_error[];
  2180. extern char txt_shell_escape[];
  2181. extern char txt_connecting[];
  2182. extern char txt_cannot_get_nntp_server_name[];
  2183. extern char txt_server_name_in_file_env_var[];
  2184. extern char txt_failed_to_connect_to_server[];
  2185. extern char txt_rejected_by_nntpserver[];
  2186. extern char txt_connection_to_server_broken[];
  2187. extern char txt_stuff_nntp_cannot_open[];
  2188. extern char txt_nntp_to_fp_cannot_reopen[];
  2189. extern char txt_nntp_to_fd_cannot_reopen[];
  2190. extern char txt_toggled_rot13[];
  2191. extern char txt_no_arts_posted[];
  2192. extern char txt_post_an_article[];
  2193. extern char txt_post_a_followup[];
  2194. extern char txt_mail_bug_report[];
  2195. extern char txt_reply_to_author[];
  2196. extern char txt_opt_autosave[];
  2197. extern char txt_opt_save_separate[];
  2198. extern char txt_opt_mark_saved_read[];
  2199. extern char txt_opt_kill_articles[];
  2200. extern char txt_opt_show_author[];
  2201. extern char txt_opt_draw_arrow[];
  2202. extern char txt_opt_post_process[];
  2203. extern char txt_opt_print_header[];
  2204. extern char txt_opt_pos_first_unread[];
  2205. extern char txt_opt_page_scroll[];
  2206. extern char txt_opt_catchup_groups[];
  2207. extern char txt_opt_thread_arts[];
  2208. extern char txt_opt_show_only_unread[];
  2209. extern char txt_opt_process_type[];
  2210. extern char txt_opt_sort_type[];
  2211. extern char txt_show_from_none[];
  2212. extern char txt_show_from_addr[];
  2213. extern char txt_show_from_name[];
  2214. extern char txt_show_from_both[];
  2215. extern char txt_post_process_none[];
  2216. extern char txt_post_process_sh[];
  2217. extern char txt_post_process_uudecode[];
  2218. extern char txt_post_process_uud_lst_zoo[];
  2219. extern char txt_post_process_uud_ext_zoo[];
  2220. extern char txt_sort_by_nothing[];
  2221. extern char txt_sort_by_subj_descend[];
  2222. extern char txt_sort_by_subj_ascend[];
  2223. extern char txt_sort_by_from_descend[];
  2224. extern char txt_sort_by_from_ascend[];
  2225. extern char txt_sort_by_date_descend[];
  2226. extern char txt_sort_by_date_ascend[];
  2227. extern char txt_opt_savedir[];
  2228. extern char txt_opt_maildir[];
  2229. extern char txt_opt_printer[];
  2230. extern char txt_options_menu[];
  2231. extern char txt_help_autosave[];
  2232. extern char txt_help_save_separate[];
  2233. extern char txt_help_print_header[];
  2234. extern char txt_help_pos_first_unread[];
  2235. extern char txt_help_show_author[];
  2236. extern char txt_help_draw_arrow[];
  2237. extern char txt_help_kill_articles[];
  2238. extern char txt_help_mark_saved_read[];
  2239. extern char txt_help_page_scroll[];
  2240. extern char txt_help_catchup_groups[];
  2241. extern char txt_help_thread_arts[];
  2242. extern char txt_help_show_only_unread[];
  2243. SHAR_EOF
  2244. true || echo 'restore of extern.h failed'
  2245. fi
  2246. echo 'End of tin1.1 part 10'
  2247. echo 'File extern.h is continued in part 11'
  2248. echo 11 > _shar_seq_.tmp
  2249. exit 0
  2250.  
  2251. --
  2252. NAME   Iain Lea
  2253. EMAIL  iain%estevax.uucp@unido.Informatik.Uni-Dortmund.DE
  2254. SNAIL  Bruecken Strasse 12, 8500 Nuernberg 90, Germany
  2255. PHONE  +49-911-331963 (home)  +49-911-3089-407 (work)
  2256. -- 
  2257.  Dr. med. dipl.-math Dieter Becker           Tel.: (0 / +49) 6841 - 16 3046
  2258.  Medizinische Universitaets- und Poliklinik  Fax.: (0 / +49) 6841 - 16 3369
  2259.  Innere Medizin III                         
  2260.  D - 6650 Homburg / Saar                     Email: becker@med-in.uni-sb.de
  2261. exit 0 # Just in case...
  2262.