home *** CD-ROM | disk | FTP | other *** search
/ Usenet 1994 January / usenetsourcesnewsgroupsinfomagicjanuary1994.iso / sources / unix / volume7 / rvi / part4 / rv_where.c < prev    next >
Encoding:
C/C++ Source or Header  |  1986-11-30  |  6.1 KB  |  368 lines
  1. #include "rv.h"
  2. #include <ctype.h>
  3.  
  4. void
  5. read_where_mod(cmd, specified_count, cmd_count)
  6. /*
  7.  * Read in where modifier, override old count if specified
  8.  */
  9. INT    cmd;              /* Previous cmd_character */
  10. boolean    specified_count;  /* TRUE if count was specified  */
  11. INT    cmd_count;      /* Command count, default 1 */
  12. {
  13.     INT    c;
  14.     INT    count;
  15.     void    where_mod();
  16.  
  17.     if (read_cmd(&c, &count)) {
  18.         specified_count = TRUE;
  19.         cmd_count = count;
  20.     }
  21.     /*
  22.      * Doubled character means single line (internally stored as '\0')
  23.      */
  24.     if (c == cmd)
  25.         c = '\0';
  26.     where_mod(c, specified_count, cmd_count, FALSE);
  27. }
  28.  
  29.  
  30. void
  31. where_mod(c, specified_count, cmd_count, cmdflag)
  32. /*
  33.  * Set the (row,col) pairs to cover the range of text specified by
  34.  * the where modifier.  The caller gets the pairs via the screen structure.
  35.  *
  36.  * Screen structure,
  37.  *
  38.  *    sc->sc_firstline    First line # of range
  39.  *    sc->sc_firstcol        First column # of range
  40.  *
  41.  *    sc->sc_lastline        Last line # of range
  42.  *    sc->sc_lastcol        Last column # of range
  43.  *
  44.  *    sc->sc_validcol        If column # if valid (otherwise
  45.  *                the range covers whole lines)
  46.  */
  47. INT    c;            /* Command character */
  48. boolean    specified_count;    /* TRUE if count was specified */
  49. INT    cmd_count;        /* Command count, default 1*/
  50. boolean    cmdflag;        /* TRUE if this is a cursor movement command */
  51. {
  52.     register struct    sc_screen *sc;
  53.     boolean forward_back(), word_search(), search();
  54.     static    INT    last_searchdir = 1;
  55.  
  56.     sc = &screen;
  57.     sc->sc_firstline = sc->sc_lineno;
  58.     sc->sc_firstcol = sc->sc_column;
  59.     sc->sc_lastline = sc->sc_lineno;
  60.     sc->sc_lastcol = sc->sc_column;
  61.     sc->sc_validcol = TRUE;
  62.  
  63.     switch (c) {
  64.  
  65. case 'h':
  66. case '\b':
  67. #ifdef USG
  68. case KEY_LEFT:
  69. #endif
  70.     /*
  71.      * Left cursor
  72.      */
  73.     sc->sc_firstcol -= cmd_count;
  74.     sc->sc_lastcol--;
  75.     break;
  76.  
  77. case 'l':
  78. case ' ':
  79. #ifdef USG
  80. case KEY_RIGHT:
  81. #endif
  82.     /*
  83.      * Right cursor
  84.      */
  85.     sc->sc_lastcol += cmd_count-1;
  86.     break;
  87.  
  88.  
  89. case 'k':
  90. case '-':
  91. case CTRL(P):
  92. #ifdef USG
  93. case KEY_UP:
  94. #endif
  95.     /*
  96.      * Up cursor
  97.      */
  98.     sc->sc_validcol = FALSE;
  99.     sc->sc_firstline -= cmd_count;
  100.     break;
  101.  
  102. case 'j':
  103. case '\n':
  104. case '\r':
  105. case '+':
  106. case CTRL(N):
  107. #ifdef USG
  108. case KEY_DOWN:
  109. #endif
  110.     /*
  111.      * Down cursor
  112.      */
  113.     sc->sc_validcol = FALSE;
  114.     sc->sc_lastline += cmd_count;
  115.     break;
  116.  
  117. case '\0':
  118.     /*
  119.      * Repeated character (line count)
  120.      */
  121.     sc->sc_validcol = FALSE;
  122.     sc->sc_lastline += cmd_count-1;
  123.     break;
  124.  
  125. case '0':
  126.     /*
  127.      * Beginning of line
  128.      */
  129.     sc->sc_lastcol--;
  130.     sc->sc_firstcol = 0;
  131.     break;
  132.  
  133. case '^':
  134. case '_':
  135.     /*
  136.      * First nonwhite char
  137.      */
  138.     sc->sc_lastcol--;
  139.     sc->sc_firstcol = 0;
  140.     while (isspace(sc->sc_curline->li_text[sc->sc_firstcol]) &&
  141.             sc->sc_firstcol != sc->sc_lastcol)
  142.         sc->sc_firstcol++;
  143.     if (sc->sc_firstcol > sc->sc_lastcol)
  144.         sc->sc_lastcol = sc->sc_firstcol;
  145.     break;
  146.  
  147. case '$':
  148.     /*
  149.      * End of line
  150.      */
  151.     sc->sc_lastcol = sc->sc_curline->li_width-1;
  152.     break;
  153.  
  154. case ',': 
  155. case ';':
  156. case 'f':
  157. case 'F':
  158. case 't':
  159. case 'T':
  160.     /*
  161.      * Search for character forward and backward
  162.      */
  163.     if (!forward_back(c, cmd_count))
  164.         goto error;
  165.     break;
  166.     
  167. case 'w':
  168. case 'W':
  169. case 'b':
  170. case 'B':
  171. case 'e':
  172. case 'E':
  173.     /*
  174.      * Go to the next word
  175.      */
  176.     if (!word_search(c, cmd_count, cmdflag))
  177.         goto error;
  178.     break;
  179.  
  180. case 'H':
  181. #ifdef USG
  182. case KEY_HOME:
  183. #endif
  184.     /*
  185.      * Home line
  186.      */
  187.     sc->sc_validcol = FALSE;
  188.     sc->sc_firstline = sc->sc_lineno - (sc->sc_curline-sc->sc_topline) +
  189.         cmd_count-1;
  190.     break;
  191.  
  192. case 'L':
  193. #ifdef USG
  194. case KEY_LL:
  195. #endif
  196.     /*
  197.      * Last line
  198.      */
  199.     sc->sc_validcol = FALSE;
  200.     sc->sc_lastline = sc->sc_lineno + (sc->sc_botline-sc->sc_curline) -
  201.         cmd_count+1;
  202.     break;
  203.  
  204. case 'G':
  205.     /*
  206.      * Goto line #
  207.      */
  208.     sc->sc_validcol = FALSE;
  209.     if (!specified_count)
  210.         cmd_count = file.fi_numlines;
  211.     if (cmd_count < sc->sc_lineno)
  212.         sc->sc_firstline = cmd_count;
  213.     else
  214.         sc->sc_lastline = cmd_count;
  215.     break;
  216.  
  217. case '|':
  218.     /*
  219.      * Goto column #
  220.      */
  221.     cmd_count = file_column(sc->sc_curline->li_text, cmd_count-1);
  222.     if (cmd_count == sc->sc_column)
  223.         goto error;
  224.     if (cmd_count < sc->sc_column)
  225.         sc->sc_firstcol = cmd_count;
  226.     else
  227.         sc->sc_lastcol = cmd_count;
  228.     break;
  229.  
  230. case '\'':
  231.     /*
  232.      * Goto mark
  233.      */
  234.     c = getch();
  235.     xmit_ed("'%c\n", c);
  236.     xmit_sync();
  237.     xmit_ed(".=\n");
  238.     if (recv_sync(FALSE)) {
  239.         char buf[32];
  240.  
  241.         sc->sc_validcol = FALSE;
  242.         fgets(buf, 31, file.fi_fpin);
  243.         if ((c = atoi(buf)) > 0)
  244.             if (c < sc->sc_lineno)
  245.                 sc->sc_firstline = c;
  246.             else
  247.                 sc->sc_lastline = c;
  248.     } else
  249.         goto error;
  250.     break;
  251.     
  252. case '/':
  253.     /*
  254.      * Search forward
  255.      */
  256.     mvaddch(LINES-1, 0, '/');
  257.     last_searchdir = 1;
  258.     if (!search(1, rv_getline(), cmdflag)) {
  259.         errflag = 1;
  260.         return;
  261.     }
  262.     errflag = cmdflag;
  263.     break;
  264.  
  265. case '?':
  266.     /*
  267.      * Search backward
  268.      */
  269.     mvaddch(LINES-1, 0, '?');
  270.     last_searchdir = -1;
  271.     if (!search(-1, rv_getline(), cmdflag)) {
  272.         errflag = 1;
  273.         return;
  274.     }
  275.     errflag = cmdflag;
  276.     break;
  277.  
  278. case 'N':
  279.     /*
  280.      * Reverse last search
  281.      */
  282.     if (!search(last_searchdir > 0 ? -1 : 1, "", cmdflag)) {
  283.         errflag = 1;
  284.         return;
  285.     }
  286.     errflag = cmdflag;
  287.     break;
  288.  
  289. case 'n':
  290.     /*
  291.      * Repeat last search
  292.      */
  293.     if (!search(last_searchdir, "", cmdflag)) {
  294.         errflag = 1;
  295.         return;
  296.     }
  297.     errflag = cmdflag;
  298.     break;
  299.  
  300. case '[':
  301.     /*
  302.      * Search backward for C function
  303.      */
  304.     if (getch() != '[' || !search(-1, "^{", cmdflag)) {
  305.         move(LINES-1, 0);
  306.         clrtoeol();
  307.         move_cursor(sc->sc_lineno, sc->sc_column);
  308.         goto error;
  309.     }
  310.     errflag = cmdflag;
  311.     break;
  312.  
  313. case ']':
  314.     /*
  315.      * Search forward for C function
  316.      */
  317.     if (getch() != ']' || !search(1, "^{", cmdflag)) {
  318.         move(LINES-1, 0);
  319.         clrtoeol();
  320.         move_cursor(sc->sc_lineno, sc->sc_column);
  321.         goto error;
  322.     }
  323.     errflag = cmdflag;
  324.     break;
  325.  
  326.  
  327. default:
  328.     /*
  329.      * Unknown where modifier
  330.      */
  331.     goto error;
  332.  
  333.  
  334.     }  /* End of switch */
  335.  
  336.     if (errflag)
  337.         return;
  338.     /*
  339.      * Consistency checks
  340.      */
  341.     if (sc->sc_validcol) {
  342.         if (sc->sc_firstcol < 0) {
  343.             if (sc->sc_column == 0)
  344.                 goto error;
  345.             sc->sc_firstcol = 0;
  346.         }
  347.         if (sc->sc_lastcol < 0) 
  348.             goto error;
  349.         if (sc->sc_firstline == sc->sc_lineno)
  350.             if (sc->sc_firstcol >= sc->sc_curline->li_width)
  351.                 goto error;
  352.         if (sc->sc_lastline == sc->sc_lineno)
  353.             if (sc->sc_lastcol >= sc->sc_curline->li_width) {
  354.                 if (sc->sc_column == sc->sc_curline->li_width)
  355.                     goto error;
  356.                 sc->sc_lastcol = sc->sc_curline->li_width;
  357.             }
  358.     }
  359.     if (sc->sc_firstline > 0 && sc->sc_firstline <= file.fi_numlines &&
  360.         sc->sc_lastline > 0 &&  sc->sc_lastline <= file.fi_numlines)
  361.         return;
  362.  
  363. error:
  364.     errflag = 1;
  365.     flash();
  366.     return;
  367. }
  368.