home *** CD-ROM | disk | FTP | other *** search
/ CP/M / CPM_CDROM.iso / cpm / cpm68k / kmince.lbr / COMM2.CQ / COMM2.C
Text File  |  1986-08-29  |  6KB  |  330 lines
  1. /* COMM2.C    This is part two of the mince command set
  2.  
  3. The seller of this software hereby disclaim any and all
  4. guarantees and warranties, both express and implied.  No
  5. liability of any form shall be assumed by the seller, nor shall
  6. direct, consequential, or other damages be assumed by the seller.
  7. Any user of this software uses it at his or her own risk.
  8.  
  9. Due to the ill-defined nature of "fitness for purpose" or similar
  10. types of guarantees for this type of product, no fitness for any
  11. purpose whatsoever is claimed or implied.
  12.  
  13. The physical medium upon which the software is supplied is
  14. guaranteed for one year against any physical defect.  If it
  15. should fail, return it to the seller, and a new physical medium
  16. with a copy of the purchased software shall be sent.
  17.  
  18. The seller reserve the right to make changes, additions, and
  19. improvements to the software at any time; no guarantee is made
  20. that future versions of the software will be compatible with any
  21. other version.
  22.  
  23. The parts of this disclaimer are severable and fault found in any
  24. one part does not invalidate any other parts.
  25.  
  26.     Copyright (c) 1981 by Mark of the Unicorn
  27.     Created for version two  8/27/80  JTL
  28.     Updated to version three  1/7/81  JTL
  29.  
  30.     This file contains the Meta command execution routines for
  31. the mince editor. There are also a small number of subordinate
  32. routines. */
  33.  
  34. #include "mince.gbl"        /* Only when seperate files */
  35.  
  36. MDelELin()            /* delete entire line */
  37. {
  38.     tmark=BCreMrk();
  39.     ToBegLine();
  40.     KillToMrk(tmark,BACKWARD);
  41.     NLSrch();
  42.     lfunct = &MDelELin;
  43.     KillToMrk(tmark,FORWARD);
  44.     BKillMrk(tmark);
  45.     }
  46.  
  47. MQryRplc()            /* Query replace string */
  48. {
  49.     DoReplace(TRUE);
  50.     }
  51.  
  52. MMakeDel()            /* make the previous command a kill */
  53. {
  54.     }
  55.  
  56. MToStart()            /* move to the begining of the buffer */
  57. {
  58.     BMrkToPnt(mark);
  59.     BToStart();
  60.     }
  61.  
  62. MToEnd()                /* move to the end of the buffer  */
  63. {
  64.     BMrkToPnt(mark);
  65.     BToEnd();
  66.     }
  67.  
  68. MBSent()                /* move backwards one sentence */
  69. {
  70.     BWord();
  71.     ToSentEnd(BACKWARD);
  72.     if (!BIsStart()) ToWhite(FORWARD);
  73.     ToNotWhite(FORWARD);
  74.     }
  75.     
  76. BWord()                /* Move backwards a word of text */
  77. {
  78.     int IsToken();
  79.  
  80.     MoveTo(IsToken,BACKWARD);
  81.     MovePast(IsToken,BACKWARD);
  82.     }
  83.  
  84. MCapWord()            /* capitalize word */
  85. {
  86.     ToWord();
  87.     if (BIsEnd()) return;
  88.     BInsert(toupper(Buff()));
  89.     BDelete(1);
  90.     if (IsToken()) MLowWord();
  91.     }
  92.     
  93. MDelWord()            /* delete the current word */
  94. {
  95.     tmark=BCreMrk();
  96.     FWord();
  97.     KillToMrk(tmark,FORWARD);
  98.     BKillMrk(tmark);
  99.     }
  100.  
  101. MFSent()                /* move forward a sentence */
  102. {
  103.     FWord();
  104.     ToSentEnd(FORWARD);
  105.     }
  106.  
  107. FWord()                /* Move foward a word of text */
  108. {
  109.     int IsToken();
  110.  
  111.     MoveTo(IsToken,FORWARD);
  112.     MovePast(IsToken,FORWARD);
  113.     }
  114.     
  115. MMrkPara()            /* set point and mark around paragraph */
  116. {
  117.     BMove(-1);
  118.     MFPara();
  119.     BMrkToPnt(mark);
  120.     MBPara();
  121.     }
  122.  
  123. MDelSent()            /* delete sentence */
  124. {
  125.     int tmpmrk;
  126.  
  127.     tmpmrk=BCreMrk();
  128.     if (arg==0) MBSent();
  129.     else MFSent();
  130.     KillToMrk(tmpmrk,arg!=0);
  131.     BKillMrk(tmpmrk);
  132.     }
  133.  
  134. MLowWord()            /* lowercase a word */
  135. {
  136.     ToWord();
  137.     while (!BIsEnd() && IsToken()) {
  138.         BInsert(tolower(Buff()));
  139.         BDelete(1);
  140.         TKbChk();
  141.         }
  142.     }
  143.     
  144. MFillPara()            /* fill paragraph */
  145. {
  146.     int IsWhite();
  147.  
  148.     if (argp) fillwidth=arg;
  149.     arg=0;
  150.     tmark=BCreMrk();
  151.     BMove(-1);
  152.     MFPara();
  153.     BMove(-1);
  154.     if (BIsEnd() || IsGray()) {
  155.         BPntToMrk(tmark);
  156.         BKillMrk(tmark);
  157.         return;
  158.         }
  159.     BMove(1);
  160.     tmp=BCreMrk();
  161.     MBPara();
  162.  
  163.     while (BIsBefore(tmp)) {
  164.         ToWhite(FORWARD);
  165.         if (BGetCol() > fillwidth) {
  166.             ToWhite(BACKWARD);
  167.             MDelWhite();
  168.             BInsert(NL);
  169.             SIndent(indentcol);
  170.             ToWhite(FORWARD);
  171.             }
  172.         MovePast(IsWhite,FORWARD);
  173.         if (IsNL() && BIsBefore(tmp)) {
  174.             BDelete(1);
  175.             MDelWhite();
  176.             BInsert(' ');
  177.             }
  178.         }
  179.  
  180.     BPntToMrk(tmark);
  181.     BKillMrk(tmark);
  182.     BKillMrk(tmp);
  183.     }
  184.  
  185. MReplace()            /* replace string */
  186. {
  187.     DoReplace(FALSE);
  188.     }
  189.  
  190. MCntrLine()            /* center the line */
  191. {
  192.     if (argp) fillwidth=arg;
  193.     else arg=fillwidth;
  194.     if ((arg -= indentcol) < 1) return;
  195.     ToBegLine();
  196.     MDelWhite();
  197.     ToEndLine();
  198.     tmp=BGetCol();
  199.     if (tmp<=arg) {
  200.         ToBegLine();
  201.         TIndent(indentcol+(arg-tmp)/2);
  202.         ToEndLine();
  203.         }
  204.     arg=0;
  205.     }
  206.  
  207. MSwapWord()            /* transpose words */
  208. {
  209.     int IsToken();
  210.  
  211.     MoveTo(IsToken,FORWARD);
  212.     if (BIsEnd()) return;
  213.     tmark=BCreMrk();
  214.     MovePast(IsToken,FORWARD);
  215.     tmp=BCreMrk();
  216.     BPntToMrk(tmark);
  217.     MoveTo(IsToken,BACKWARD);
  218.     BlockMove(tmark,tmp);
  219.  
  220.     MovePast(IsToken,BACKWARD);
  221.     BlockMove(tmark,tmp);
  222.     BKillMrk(tmark);
  223.     BPntToMrk(tmp);
  224.     BKillMrk(tmp);
  225.     }
  226.  
  227. MUpWord()                /* uppercase a word */
  228. {
  229.     ToWord();
  230.     while (!BIsEnd() && IsToken()) {
  231.         BInsert(toupper(Buff()));
  232.         BDelete(1);
  233.         TKbChk();
  234.         }
  235.     }
  236.     
  237. MPrevPage()            /* move to the previous page */
  238. {
  239.     BPntToMrk(sstart);
  240.     for (cnt=WHeight()-PrefLine()-2; cnt>0; --cnt) RNLSrch();
  241.     ToBegLine();
  242.     ScrnRange();
  243.     }
  244.  
  245. MCopyRgn()            /* copy region to kill buffer */
  246. {
  247.     CopyToMrk(mark,BIsBefore(mark));
  248.     }
  249.  
  250. MBPara()                /* move backward one paragraph */
  251. {
  252.     ToNotWhite(BACKWARD);
  253.     while (RNLSrch()) {
  254.         BMove(1);
  255.         if (IsParaEnd()) break;
  256.         BMove(-1);
  257.         TKbChk();
  258.         }
  259.     ToNotWhite(FORWARD);
  260.     }
  261.  
  262. MDelWhite()            /* delete spaces and tabs around point */
  263. {
  264.     while (!BIsEnd() && IsWhite()) {
  265.         BDelete(1);
  266.         TKbChk();
  267.         }
  268.     while (!BIsStart()) {
  269.         BMove(-1);
  270.         if (IsWhite()) BDelete(1);
  271.         else {
  272.             BMove(1);
  273.             break;
  274.             }
  275.         TKbChk();
  276.         }
  277.     }
  278.  
  279. MFPara()                /* move forward one paragraph */
  280. {
  281.     ToNotWhite(FORWARD);
  282.     while (NLSrch() && !IsParaEnd()) TKbChk();
  283.     ToNotWhite(BACKWARD);
  284.     }
  285.  
  286. MRDelWord()            /* delete the previous word */
  287. {
  288.     tmark=BCreMrk();
  289.     BWord();
  290.     KillToMrk(tmark,BACKWARD);
  291.     BKillMrk(tmark);
  292.     }
  293.  
  294. MNotImpl()            /* Command not implemented */
  295. {
  296.     Error("Unknown command");
  297.     arg=0;
  298.     }
  299.  
  300.     /* Fill mode commands */
  301. MFillChk()            /* check to see if we are beyond fillwidth
  302.                        and do something about it */
  303. {
  304.     if (BGetCol() < fillwidth) {
  305.         BInsert(' ');
  306.         }
  307.     else {
  308.         tmark=BCreMrk();
  309.         while (BGetCol() > fillwidth) {
  310.             ToWhite(BACKWARD);
  311.             ToNotWhite(BACKWARD);
  312.             }
  313.         MDelWhite();
  314.         tmp = !BIsAtMrk(tmark);        /* does trailing spaces */
  315.         BInsert(NL);
  316.         SIndent(indentcol);
  317.         if (tmp) {
  318.             BPntToMrk(tmark);
  319.             BInsert(' ');
  320.             }
  321.         BKillMrk(tmark);
  322.         }
  323.     }
  324.  
  325. /* END OF COMM2.C - Mince command routines */
  326. {
  327.             BPntToMrk(tmark);
  328.             BInsert(' ');
  329.             }
  330.         BKillM