home *** CD-ROM | disk | FTP | other *** search
/ OS/2 Shareware BBS: 5 Edit / 05-Edit.zip / vile-src.zip / vile-8.1 / opers.c < prev    next >
C/C++ Source or Header  |  1998-04-28  |  7KB  |  423 lines
  1. /*
  2.  * This file contains the command processing functions for the commands
  3.  * that take motion operators.
  4.  * written for vile: Copyright (c) 1990, 1995 by Paul Fox
  5.  *
  6.  * $Header: /usr/build/vile/vile/RCS/opers.c,v 1.62 1998/04/28 10:17:44 tom Exp $
  7.  *
  8.  */
  9.  
  10. #include    "estruct.h"
  11. #include        "edef.h"
  12. #include        "nefunc.h"
  13.  
  14. extern REGION *haveregion;
  15.  
  16. /* For the "operator" commands -- the following command is a motion, or
  17.  *  the operator itself is repeated.  All operate on regions.
  18.  */
  19. int
  20. vile_op(int f, int n, OpsFunc fn, const char *str)
  21. {
  22.     int c;
  23.     int thiskey;
  24.     int status;
  25.     const CMDFUNC *cfp;        /* function to execute */
  26.     char tok[NSTRING];        /* command incoming */
  27.     BUFFER *ourbp;
  28. #if OPT_MOUSE
  29.     WINDOW    *wp0 = curwp;
  30. #endif
  31.  
  32.     doingopcmd = TRUE;
  33.  
  34.     pre_op_dot = DOT;
  35.     ourbp = curbp;
  36.  
  37.     if (havemotion != NULL) {
  38.         cfp = havemotion;
  39.         havemotion = NULL;
  40.     } else {
  41.         mlwrite("%s operation pending...",str);
  42.         (void)update(FALSE);
  43.  
  44.         /* get the next command from the keyboard */
  45.         /* or a command line, as approp. */
  46.         if (clexec) {
  47.             macarg(tok);    /* get the next token */
  48.             if (!strcmp(tok,"lines"))
  49.                 cfp = &f_godotplus;
  50.             else
  51.                 cfp = engl2fnc(tok);
  52.         } else {
  53.             thiskey = lastkey;
  54.             c = kbd_seq();
  55.  
  56. #if OPT_MOUSE
  57.             if (curwp != wp0) {
  58.                 unkeystroke(c);
  59.                     doingopcmd = FALSE;
  60.                 return FALSE;
  61.             }
  62. #endif
  63.             /* allow second chance for entering counts */
  64.             do_repeats(&c,&f,&n);
  65.  
  66.             if (thiskey == lastkey)
  67.                 cfp = &f_godotplus;
  68.             else
  69.                 cfp = kcod2fnc(c);
  70.  
  71.         }
  72.         if (cfp)
  73.             mlerase();
  74.         else {
  75.             if (!clexec)
  76.                 lsprintf(tok, "(%d)", c);
  77.             no_such_function(tok);
  78.         }
  79.     }
  80.     if (!cfp) {
  81.         doingopcmd = FALSE;
  82.         return FALSE;
  83.     }
  84.  
  85.     if ((cfp->c_flags & MOTION) == 0) {
  86.         kbd_alarm();
  87.         doingopcmd = FALSE;
  88.         return(ABORT);
  89.     }
  90.  
  91.     /* motion is interpreted as affecting full lines */
  92.     if (regionshape == EXACT) {
  93.         if (cfp->c_flags & FL)
  94.             regionshape = FULLLINE;
  95.         if (cfp->c_flags & RECT)
  96.             regionshape = RECTANGLE;
  97.     }
  98.  
  99.     /* and execute the motion */
  100.     status = execute(cfp, f,n);
  101.  
  102.     if (status != TRUE) {
  103.         doingopcmd = FALSE;
  104.         regionshape = EXACT;
  105.         mlforce("[Motion failed]");
  106.         return FALSE;
  107.     }
  108.  
  109.     opcmd = 0;
  110.  
  111.     MK = pre_op_dot;
  112.  
  113.     /* we've successfully set up a region */
  114.     if (!fn) { /* be defensive */
  115.         mlforce("BUG -- null func pointer in operator");
  116.         status = FALSE;
  117.     } else {
  118.         status = (fn)();
  119.     }
  120.  
  121.     if (ourbp == curbp) /* in case the func switched buffers on us */
  122.         swapmark();
  123.  
  124.     if (regionshape == FULLLINE)
  125.         (void)firstnonwhite(FALSE,1);
  126.  
  127.     regionshape = EXACT;
  128.  
  129.     doingopcmd = FALSE;
  130.  
  131.     haveregion = FALSE;
  132.  
  133.     return status;
  134. }
  135.  
  136. int
  137. operdel(int f, int n)
  138. {
  139.     int    status;
  140.  
  141.     opcmd = OPDEL;
  142.     lines_deleted = 0;
  143.     status = vile_op(f, n, killregion,
  144.         regionshape == FULLLINE
  145.             ? "Delete of full lines"
  146.             : "Delete");
  147.     if (do_report(lines_deleted))
  148.         mlforce("[%d lines deleted]", lines_deleted);
  149.     return status;
  150. }
  151.  
  152. int
  153. operlinedel(int f, int n)
  154. {
  155.     regionshape = FULLLINE;
  156.     return operdel(f,n);
  157. }
  158.  
  159. static int
  160. chgreg(void)
  161. {
  162.     if (regionshape == RECTANGLE) {
  163.         return stringrect();
  164.     } else {
  165.         killregion();
  166.         if (regionshape == FULLLINE) {
  167.             if (backline(FALSE,1) == TRUE)
  168.                 /* backline returns FALSE at top of buf */
  169.                 return opendown(TRUE,1);
  170.             else
  171.                 return openup(TRUE,1);
  172.         }
  173.         return ins();
  174.     }
  175. }
  176.  
  177. int
  178. operchg(int f, int n)
  179. {
  180.     int s;
  181.  
  182.     opcmd = OPOTHER;
  183.     s = vile_op(f,n,chgreg,"Change");
  184.     if (s == TRUE) swapmark();
  185.     return s;
  186. }
  187.  
  188. int
  189. operlinechg(int f, int n)
  190. {
  191.     int s;
  192.  
  193.     regionshape = FULLLINE;
  194.     opcmd = OPOTHER;
  195.     s = vile_op(f,n,chgreg,"Change of full lines");
  196.     if (s == TRUE) swapmark();
  197.     return s;
  198. }
  199.  
  200. int
  201. operjoin(int f, int n)
  202. {
  203.     opcmd = OPOTHER;
  204.     return vile_op(f,n,joinregion,"Join");
  205. }
  206.  
  207. int
  208. operyank(int f, int n)
  209. {
  210.     MARK savedot;
  211.     int s;
  212.     savedot = DOT;
  213.     opcmd = OPDEL;
  214.     s = vile_op(f,n,yankregion,"Yank");
  215.     DOT = savedot;
  216.     return s;
  217. }
  218.  
  219. int
  220. operlineyank(int f, int n)
  221. {
  222.     MARK savedot;
  223.     int s;
  224.     savedot = DOT;
  225.     regionshape = FULLLINE;
  226.     opcmd = OPOTHER;
  227.     s = vile_op(f,n,yankregion,"Yank of full lines");
  228.     DOT = savedot;
  229.     return s;
  230. }
  231.  
  232. int
  233. operflip(int f, int n)
  234. {
  235.     opcmd = OPOTHER;
  236.     return vile_op(f,n,flipregion,"Flip case");
  237. }
  238.  
  239. int
  240. operupper(int f, int n)
  241. {
  242.     opcmd = OPOTHER;
  243.     return vile_op(f,n,upperregion,"Upper case");
  244. }
  245.  
  246. int
  247. operlower(int f, int n)
  248. {
  249.     opcmd = OPOTHER;
  250.     return vile_op(f,n,lowerregion,"Lower case");
  251. }
  252.  
  253. /*
  254.  * The shift commands are special, because vi allows an implicit repeat-count
  255.  * to be specified by repeating the '<' or '>' operators.
  256.  */
  257. static int
  258. shift_n_times(int f, int n, OpsFunc func, const char *msg)
  259. {
  260.     register int status = FALSE;
  261.  
  262.     regionshape = FULLLINE;
  263.     opcmd = OPOTHER;
  264.  
  265.     if (havemotion != NULL) {
  266.         const CMDFUNC *cfp = havemotion;
  267.         while (n-- > 0) {
  268.             havemotion = cfp;
  269.             if ((status = vile_op(FALSE,1, func, msg)) != TRUE)
  270.                 break;
  271.         }
  272.     } else
  273.         status = vile_op(f,n, func, msg);
  274.     return status;
  275. }
  276.  
  277. int
  278. operlshift(int f, int n)
  279. {
  280.     return shift_n_times(f,n,shiftlregion,"Left shift");
  281. }
  282.  
  283. int
  284. operrshift(int f, int n)
  285. {
  286.     return shift_n_times(f,n,shiftrregion,"Right shift");
  287. }
  288.  
  289. int
  290. operwrite(int f, int n)
  291. {
  292.         register int    s;
  293.         char fname[NFILEN];
  294.  
  295.     if (ukb != 0) {
  296.             if ((s=mlreply_file("Write to file: ", (TBUFF **)0,
  297.                 FILEC_WRITE|FILEC_PROMPT, fname)) != TRUE)
  298.                     return s;
  299.         return kwrite(fname,TRUE);
  300.     } else {
  301.         opcmd = OPOTHER;
  302.         return vile_op(f,n,writeregion,"File write");
  303.     }
  304. }
  305.  
  306. #if OPT_FORMAT
  307. int
  308. operformat(int f, int n)
  309. {
  310.     regionshape = FULLLINE;
  311.     opcmd = OPOTHER;
  312.     return vile_op(f,n,formatregion,"Format");
  313. }
  314. #endif
  315.  
  316. #if OPT_SHELL
  317. int
  318. operfilter(int f, int n)
  319. {
  320.     regionshape = FULLLINE;
  321.     opcmd = OPOTHER;
  322.     return vile_op(f,n,filterregion,"Filter");
  323. }
  324. #endif
  325.  
  326.  
  327. int
  328. operprint(int f, int n)
  329. {
  330.     regionshape = FULLLINE;
  331.     opcmd = OPOTHER;
  332.     return vile_op(f,n,plineregion,"Line print");
  333. }
  334.  
  335. int
  336. operpprint(int f, int n)
  337. {
  338.     regionshape = FULLLINE;
  339.     opcmd = OPOTHER;
  340.     return vile_op(f,n,pplineregion,"Line-number print");
  341. }
  342.  
  343. int
  344. operlist(int f, int n)
  345. {
  346.     regionshape = FULLLINE;
  347.     opcmd = OPOTHER;
  348.     return vile_op(f,n,llineregion,"Line list");
  349. }
  350.  
  351. int
  352. opersubst(int f, int n)
  353. {
  354.     regionshape = FULLLINE;
  355.     opcmd = OPOTHER;
  356.     return vile_op(f,n,substregion,"Substitute");
  357. }
  358.  
  359. int
  360. opersubstagain(int f, int n)
  361. {
  362.     regionshape = FULLLINE;
  363.     opcmd = OPOTHER;
  364.     return vile_op(f,n,subst_again_region,"Substitute-again");
  365. }
  366.  
  367. #if OPT_AEDIT
  368. int
  369. operentab(int f, int n)
  370. {
  371.     regionshape = FULLLINE;
  372.     opcmd = OPOTHER;
  373.     return vile_op(f,n,entab_region,"Spaces-->Tabs");
  374. }
  375. #endif
  376.  
  377. #if OPT_AEDIT
  378. int
  379. operdetab(int f, int n)
  380. {
  381.     regionshape = FULLLINE;
  382.     opcmd = OPOTHER;
  383.     return vile_op(f,n,detab_region,"Tabs-->Spaces");
  384. }
  385. #endif
  386.  
  387. #if OPT_AEDIT
  388. int
  389. opertrim(int f, int n)
  390. {
  391.     regionshape = FULLLINE;
  392.     opcmd = OPOTHER;
  393.     return vile_op(f,n,trim_region,"Trim whitespace");
  394. }
  395. #endif
  396.  
  397. #if OPT_AEDIT
  398. int
  399. operblank(int f, int n)
  400. {
  401.     opcmd = OPOTHER;
  402.     return vile_op(f,n,blank_region,"Blanking");
  403. }
  404. #endif
  405.  
  406. #if OPT_ENCRYPT
  407. int
  408. opercrypt(int f, int n)
  409. {
  410.     opcmd = OPOTHER;
  411.     return vile_op(f,n,cryptregion,"Encrypt/decrypt");
  412. }
  413. #endif
  414.  
  415. int
  416. operopenrect(int f, int n)
  417. {
  418.     opcmd = OPOTHER;
  419.     regionshape = RECTANGLE;
  420.     return vile_op(f,n,openregion,"Opening");
  421. }
  422.  
  423.