home *** CD-ROM | disk | FTP | other *** search
/ Usenet 1994 October / usenetsourcesnewsgroupsinfomagicoctober1994disk2.iso / misc / volume30 / tin / part14 / search.c < prev    next >
C/C++ Source or Header  |  1992-05-20  |  7KB  |  401 lines
  1. /*
  2.  *  Project   : tin - a threaded Netnews reader
  3.  *  Module    : search.c
  4.  *  Author    : I.Lea & R.Skrenta
  5.  *  Created   : 01-04-91
  6.  *  Updated   : 13-03-92
  7.  *  Notes     :
  8.  *  Copyright : (c) Copyright 1991-92 by Iain Lea & Rich Skrenta
  9.  *              You may  freely  copy or  redistribute  this software,
  10.  *              so  long as there is no profit made from its use, sale
  11.  *              trade or  reproduction.  You may not change this copy-
  12.  *              right notice, and it must be included in any copy made
  13.  */
  14.  
  15. #include    "tin.h"
  16.  
  17. extern FILE *note_fp;
  18. extern int cur_groupnum;
  19. extern int first_group_on_screen;
  20. extern int last_group_on_screen;
  21. extern int first_subj_on_screen;
  22. extern int last_subj_on_screen;
  23. extern int index_point;
  24. extern int note_line;
  25. extern int note_page;
  26. extern int note_end;
  27. extern long note_mark[MAX_PAGES];
  28.  
  29. /*
  30.  * last search patterns
  31.  */
  32.  
  33. char default_author_search[LEN];
  34. char default_group_search[LEN];
  35. char default_subject_search[LEN];
  36. char default_art_search[LEN];
  37.  
  38.  
  39. /*
  40.  *  group.c & page.c
  41.  */
  42.  
  43. int search_author (only_unread, current_art, forward)
  44.     int only_unread;
  45.     int current_art;
  46.     int forward;
  47. {
  48.     char buf[LEN];
  49.     char buf2[LEN];
  50.     int i, patlen;
  51.  
  52.     clear_message ();
  53.  
  54.     if (forward) {
  55.         sprintf (buf2, txt_author_search_forwards, default_author_search);
  56.     } else {
  57.         sprintf (buf2, txt_author_search_backwards, default_author_search);
  58.     }
  59.     
  60.     if (! prompt_string (buf2, buf)) {
  61.         return -1;
  62.     }
  63.     
  64.     if (strlen (buf)) {
  65.         strcpy (default_author_search, buf);
  66.     } else {
  67.         if (default_author_search[0]) {
  68.             strcpy (buf, default_author_search);
  69.         } else {
  70.             info_message (txt_no_search_string);    
  71.             return -1;
  72.         }
  73.     }
  74.  
  75.     wait_message (txt_searching);
  76.  
  77.     make_lower (default_author_search, buf);
  78.  
  79.     patlen = strlen (default_author_search);
  80.  
  81.     i = current_art;
  82.  
  83.     do {
  84.         if (forward) {
  85.             i = next_response (i);
  86.             if (i < 0)
  87.                 i = base[0];
  88.         } else {
  89.             i = prev_response (i);
  90.             if (i < 0)
  91.                 i = base[top_base - 1] + 
  92.                     num_of_responses (top_base - 1);
  93.         }
  94.  
  95.         if (only_unread && arts[i].unread != ART_UNREAD) {
  96.             continue;
  97.         }
  98.             
  99.         if (arts[i].name == (char *) 0) {
  100.             make_lower (arts[i].from, buf2);
  101.         } else {
  102.             sprintf (msg, "%s (%s)", arts[i].from, arts[i].name);
  103.             make_lower (msg, buf2);
  104.         }
  105.  
  106.         if (str_str (buf2, buf, patlen) != 0) {
  107.             clear_message ();
  108.             return i;
  109.         }
  110.     } while (i != current_art);
  111.  
  112.     info_message (txt_no_match);
  113.     return -1;
  114. }
  115.  
  116. /*
  117.  * select.c
  118.  */
  119.  
  120. void search_group (forward)
  121.     int forward;
  122. {
  123.     char buf[LEN];
  124.     char buf2[LEN];
  125.     int i, patlen;
  126.  
  127.     clear_message ();
  128.  
  129.     if (forward) {
  130.         sprintf (buf2, txt_search_forwards, default_group_search);
  131.     } else {
  132.         sprintf (buf2, txt_search_backwards, default_group_search);
  133.     }
  134.  
  135.     if (! prompt_string (buf2, buf)) {
  136.         return;
  137.     }
  138.  
  139.     if (strlen (buf)) {
  140.         strcpy (default_group_search, buf);
  141.     } else {
  142.         if (default_group_search[0]) {
  143.             strcpy (buf, default_group_search);
  144.         } else {
  145.             info_message (txt_no_search_string);    
  146.             return;
  147.         }
  148.     }
  149.  
  150.     wait_message (txt_searching);
  151.  
  152.     make_lower (default_group_search, buf);
  153.  
  154.     patlen = strlen (default_group_search);
  155.  
  156.     i = cur_groupnum;
  157.  
  158.     do {
  159.         if (forward)
  160.             i++;
  161.         else
  162.             i--;
  163.  
  164.         if (i >= group_top)
  165.             i = 0;
  166.         if (i < 0)
  167.             i = group_top - 1;
  168.  
  169.         make_lower (active[my_group[i]].name, buf2);
  170.  
  171.         if (str_str (buf2, buf, patlen) != 0) {
  172.             if (i >= first_group_on_screen
  173.             &&  i < last_group_on_screen) {
  174.                 clear_message ();
  175.                 erase_group_arrow ();
  176.                 cur_groupnum = i;
  177.                 draw_group_arrow ();
  178.             } else {
  179.                 cur_groupnum = i;
  180.                 group_selection_page ();
  181.             }
  182.             return;
  183.         }
  184.     } while (i != cur_groupnum);
  185.  
  186.     info_message (txt_no_match);
  187. }
  188.  
  189. /*
  190.  * group.c
  191.  */
  192.  
  193. void search_subject (forward, group)
  194.     int forward;
  195.     char *group;
  196. {
  197.     char buf[LEN];
  198.     char buf2[LEN];
  199.     int i, j, patlen;
  200.  
  201.     if (index_point < 0) {
  202.         info_message (txt_no_arts);
  203.         return;
  204.     }
  205.     
  206.     clear_message ();
  207.  
  208.     if (forward) {
  209.         sprintf (buf2, txt_search_forwards, default_subject_search);
  210.     } else {
  211.         sprintf (buf2, txt_search_backwards, default_subject_search);
  212.     }
  213.  
  214.     if (! prompt_string (buf2, buf)) {
  215.         return;
  216.     }
  217.  
  218.     if (strlen (buf)) {
  219.         strcpy (default_subject_search, buf);
  220.     } else {
  221.         if (default_subject_search[0]) {
  222.             strcpy (buf, default_subject_search);
  223.         } else {
  224.             info_message (txt_no_search_string);    
  225.             return;
  226.         }
  227.     }
  228.  
  229.     wait_message (txt_searching);
  230.  
  231.     make_lower (default_subject_search, buf);
  232.  
  233.     patlen = strlen (default_subject_search);
  234.  
  235.     i = index_point;
  236.  
  237.     do {
  238.         if (forward)
  239.             i++;
  240.         else
  241.             i--;
  242.  
  243.         if (i >= top_base)
  244.             i = 0;
  245.         if (i < 0)
  246.             i = top_base - 1;
  247.  
  248.         j = (int) base[i];
  249.  
  250.         make_lower (arts[j].subject, buf2);
  251.  
  252.         if (str_str (buf2, buf, patlen) != 0) {
  253.             if (i >= first_subj_on_screen
  254.                 &&  i < last_subj_on_screen) {
  255.                 clear_message ();
  256.                 erase_subject_arrow ();
  257.                 index_point = i;
  258.                 draw_subject_arrow ();
  259.             } else {
  260.                 index_point = i;
  261.                 show_group_page (group);
  262.             }
  263.             return;
  264.         }
  265.     } while (i != index_point);
  266.  
  267.     info_message (txt_no_match);
  268. }
  269.  
  270. /*
  271.  *  page.c (search article body)
  272.  */
  273.  
  274. int search_article (forward)
  275.     int forward;
  276. {
  277.     char buf[LEN];
  278.     char buf2[LEN];
  279.     char string[LEN];
  280.     char pattern[LEN];
  281.     char *p, *q;
  282.     int ctrl_L;
  283.     int i, j, patlen;
  284.     int orig_note_end;
  285.     int orig_note_page;
  286.  
  287.     clear_message ();
  288.  
  289.     if (forward) {
  290.         sprintf (buf2, txt_search_forwards, default_art_search);
  291.     } else {
  292.         sprintf (buf2, txt_search_backwards, default_art_search);
  293.     }
  294.  
  295.     if (! prompt_string (buf2, buf)) {
  296.         return FALSE;
  297.     }
  298.  
  299.     if (strlen (buf)) {
  300.         strcpy (default_art_search, buf);
  301.     } else {
  302.         if (default_art_search[0]) {
  303.             strcpy (buf, default_art_search);
  304.         } else {
  305.             info_message (txt_no_search_string);    
  306.             return FALSE;
  307.         }
  308.     }
  309.  
  310.     wait_message (txt_searching);
  311.     
  312.     make_lower (default_art_search, pattern);
  313.  
  314.     patlen = strlen (default_art_search);
  315.  
  316.     /*
  317.      *  save current position in article
  318.      */
  319.     orig_note_end = note_end;
  320.     orig_note_page = note_page;
  321.     
  322.     while (! note_end) {
  323.         note_line = 1;
  324.         ctrl_L = FALSE;
  325.  
  326.         if (note_page == 0) {
  327.             note_line += 4;
  328.         } else {
  329.             note_line += 2;
  330.         }
  331.         while (note_line < LINES) {
  332.             if (fgets (buf, sizeof buf, note_fp) == NULL) {
  333.                 note_end = TRUE;
  334.                 break;
  335.             }
  336.             buf[LEN-1] = '\0';
  337.             for (p = buf, q = buf2;    *p && *p != '\n' && q<&buf2[LEN]; p++) {
  338.                 if (*p == '\b' && q > buf2) {
  339.                     q--;
  340.                 } else if (*p == '\f') {        /* ^L */
  341.                     *q++ = '^';
  342.                     *q++ = 'L';
  343.                     ctrl_L = TRUE;
  344.                 } else if (*p == '\t') {
  345.                     i = q - buf2;
  346.                     j = (i|7) + 1;
  347.  
  348.                     while (i++ < j) {
  349.                         *q++ = ' ';
  350.                     }
  351.                 } else if (((*p) & 0xFF) < ' ') {
  352.                     *q++ = '^';
  353.                     *q++ = ((*p) & 0xFF) + '@';
  354.                 } else {
  355.                     *q++ = *p;
  356.                 }
  357.             }
  358.             *q = '\0';
  359.  
  360.             make_lower (buf2, string);
  361.  
  362.             if (str_str (string, pattern, patlen) != 0) {
  363.                 fseek (note_fp, note_mark[note_page], 0);
  364.                 return TRUE;
  365.             }
  366.  
  367.             note_line += ((int) strlen(buf2) / COLS) + 1;
  368.  
  369.             if (ctrl_L) {
  370.                 break;
  371.             }
  372.         }
  373.         if (! note_end) {
  374.             note_mark[++note_page] = ftell (note_fp);
  375.         }
  376.     }
  377.  
  378.     note_end = orig_note_end;
  379.     note_page = orig_note_page;
  380.     fseek (note_fp, note_mark[note_page], 0);
  381.     info_message (txt_no_match);
  382.     return FALSE;
  383. }
  384.  
  385.  
  386. void make_lower (s, t)
  387.     char *s;
  388.     char *t;
  389. {
  390.  
  391.     while (*s) {
  392.         if (isupper(*s))
  393.             *t = tolower(*s);
  394.         else
  395.             *t = *s;
  396.         s++;
  397.         t++;
  398.     }
  399.     *t = 0;
  400. }
  401.