home *** CD-ROM | disk | FTP | other *** search
/ OS/2 Shareware BBS: 5 Edit / 05-Edit.zip / VILE327.ZIP / VILE327.TAR / vile3.27 / csrch.c < prev    next >
C/C++ Source or Header  |  1992-12-14  |  3KB  |  215 lines
  1. /* These functions perform vi's on-this-line character scanning functions.
  2.  *    written for vile by Paul Fox, (c)1990
  3.  *
  4.  * $Log: csrch.c,v $
  5.  * Revision 1.6  1992/12/04  09:12:25  foxharp
  6.  * deleted unused assigns
  7.  *
  8.  * Revision 1.5  1992/05/16  12:00:31  pgf
  9.  * prototypes/ansi/void-int stuff/microsoftC
  10.  *
  11.  * Revision 1.4  1991/11/01  14:38:00  pgf
  12.  * saber cleanup
  13.  *
  14.  * Revision 1.3  1991/08/07  12:35:07  pgf
  15.  * added RCS log messages
  16.  *
  17.  * revision 1.2
  18.  * date: 1991/06/25 19:52:11;
  19.  * massive data structure restructure
  20.  * 
  21.  * revision 1.1
  22.  * date: 1990/09/21 10:24:56;
  23.  * initial vile RCS revision
  24. */
  25.  
  26. #include "estruct.h"
  27. #include "edef.h"
  28.  
  29. static short lstscan;
  30. static short lstchar;
  31. #define BACK 0
  32. #define FORW 1
  33. #define DIREC 1
  34.  
  35. #define F 0
  36. #define T 2
  37. #define TYPE 2
  38.  
  39.  
  40. int
  41. fscan(f,n,c)
  42. int f,n,c;
  43. {
  44.     int i;
  45.     int doto;
  46.  
  47.     if (!f || n <= 0)
  48.         n = 1;
  49.  
  50.     lstchar = c;
  51.     lstscan = FORW;
  52.  
  53.     doto = curwp->w_dot.o;
  54.  
  55.     i = doto+1;
  56.     while(i < llength(curwp->w_dot.l)) {
  57.         if ( c == lgetc(curwp->w_dot.l,i)) {
  58.             doto = i;
  59.             n--;
  60.             if (!n) break;
  61.         }
  62.         i++;
  63.     }
  64.  
  65.     if ( i == llength(curwp->w_dot.l)) {
  66.         TTbeep();
  67.         return(FALSE);
  68.     }
  69.     if (doingopcmd)
  70.         doto++;
  71.  
  72.     curwp->w_dot.o = doto;
  73.     curwp->w_flag |= WFMOVE;
  74.     return(TRUE);
  75.             
  76. }
  77.  
  78. int
  79. bscan(f,n,c)
  80. int f,n,c;
  81. {
  82.     int i;
  83.     int doto;
  84.  
  85.     if (f || n <= 0)
  86.         n = 1;
  87.  
  88.     lstchar = c;
  89.     lstscan = BACK;
  90.  
  91.     doto = curwp->w_dot.o;
  92.  
  93.     i = doto-1;
  94.     while(i >= 0) {
  95.         if ( c == lgetc(curwp->w_dot.l,i)) {
  96.             doto = i;
  97.             n--;
  98.             if (!n) break;
  99.         }
  100.         i--;
  101.     }
  102.  
  103.     if ( i < 0 ) {
  104.         TTbeep();
  105.         return(FALSE);
  106.     }
  107.  
  108.     curwp->w_dot.o = doto;
  109.     curwp->w_flag |= WFMOVE;
  110.     return(TRUE);
  111.  
  112. }
  113.  
  114. /* f */
  115. int
  116. fcsrch(f,n)
  117. int f,n;
  118. {
  119.     register int c;
  120.  
  121.         c = kbd_key();
  122.     if (c == quotec)
  123.         c = tgetc();
  124.     else if (c == abortc)
  125.         return FALSE;
  126.     else
  127.         c = kcod2key(c);
  128.  
  129.     return(fscan(f,n,c));
  130. }
  131.  
  132. /* F */
  133. int
  134. bcsrch(f,n)
  135. int f,n;
  136. {
  137.     register int c;
  138.  
  139.         c = kbd_key();
  140.     if (c == quotec)
  141.         c = tgetc();
  142.     else if (c == abortc)
  143.         return FALSE;
  144.     else
  145.         c = kcod2key(c);
  146.  
  147.     return(bscan(f,n,c));
  148. }
  149.  
  150. /* t */
  151. int
  152. fcsrch_to(f,n)
  153. int f,n;
  154. {
  155.     int s;
  156.     s = fcsrch(f,n);
  157.     if (s == TRUE)
  158.         s = backchar(FALSE,1);
  159.     lstscan |= T;
  160.     return(s);
  161. }
  162.  
  163. /* T */
  164. int
  165. bcsrch_to(f,n)
  166. int f,n;
  167. {
  168.     int s;
  169.     s = bcsrch(f,n);
  170.     if (s == TRUE)
  171.         s = forwchar(FALSE,1);
  172.     lstscan |= T;
  173.     return(s);
  174. }
  175.  
  176. /* ; */
  177. int
  178. rep_csrch(f,n)
  179. int f,n;
  180. {
  181.     int s;
  182.     int ls = lstscan;
  183.  
  184.     if ((ls & DIREC) == FORW) {
  185.         s = fscan(f,n,lstchar);
  186.         if ((ls & TYPE) == T) {
  187.             if (s == TRUE)
  188.                 s = backchar(FALSE,1);
  189.             lstscan |= T;
  190.         }
  191.         return(s);
  192.     } else {
  193.         s = bscan(f,n,lstchar);
  194.         if ((ls & TYPE) == T) {
  195.             if (s == TRUE)
  196.                 s = forwchar(FALSE,1);
  197.             lstscan |= T;
  198.         }
  199.         return(s);
  200.     }
  201. }
  202.  
  203. /* , */
  204. int
  205. rev_csrch(f,n)
  206. int f,n;
  207. {
  208.     int s;
  209.  
  210.     lstscan ^= DIREC;
  211.     s = rep_csrch(f,n);
  212.     lstscan ^= DIREC;
  213.     return(s);
  214. }
  215.