home *** CD-ROM | disk | FTP | other *** search
/ CP/M / CPM_CDROM.iso / cpm / cpm68k / kmince.lbr / COMM3.CQ / COMM3.C
Text File  |  1986-08-29  |  11KB  |  473 lines
  1. /* -*-c,save-*- */
  2. /* COMM3.C    This is part three of the mince command set
  3.  
  4. The seller of this software hereby disclaim any and all
  5. guarantees and warranties, both express and implied.  No
  6. liability of any form shall be assumed by the seller, nor shall
  7. direct, consequential, or other damages be assumed by the seller.
  8. Any user of this software uses it at his or her own risk.
  9.  
  10. Due to the ill-defined nature of "fitness for purpose" or similar
  11. types of guarantees for this type of product, no fitness for any
  12. purpose whatsoever is claimed or implied.
  13.  
  14. The physical medium upon which the software is supplied is
  15. guaranteed for one year against any physical defect.  If it
  16. should fail, return it to the seller, and a new physical medium
  17. with a copy of the purchased software shall be sent.
  18.  
  19. The seller reserve the right to make changes, additions, and
  20. improvements to the software at any time; no guarantee is made
  21. that future versions of the software will be compatible with any
  22. other version.
  23.  
  24. The parts of this disclaimer are severable and fault found in any
  25. one part does not invalidate any other parts.
  26.  
  27.     Copyright (c) 1981 by Mark of the Unicorn
  28.     Created for version two  8/27/80  JTL
  29.     Updated to version three  1/7/81  JTL
  30.  
  31.     This file contains the Control-X  command execution
  32. routines for the mince editor. There are also a small number of
  33. subordinate routines. */
  34.  
  35. #include "mince.gbl"        /* Only when seperate files */
  36.  
  37. MLstBuffs()            /* print a list of the buffers */
  38. {
  39.     tmp= -1;
  40.     tlrow = -1;            /* forget any saved row */
  41.     for (cnt=BUFFSMAX-1; cnt>=0; --cnt) if (buffs[cnt].bbuff) {
  42.         TSetPoint(++tmp,0);
  43.         TCLEOL();
  44.         BSetMod(BScrnMrk(tmp));
  45.         TPrntStr(buffs[cnt].bname);
  46.         TSetPoint(tmp,9);
  47.         if (BModp(buffs[cnt].bbuff)) TPrntChar('*');
  48.         else TPrntChar(' ');
  49.         TPrntChar(' ');
  50. #ifdef CPM
  51.         itot(BLength(buffs[cnt].bbuff));
  52. #else
  53.         ltot(BLength(buffs[cnt].bbuff));
  54. #endif
  55.         TSetPoint(tmp,18);
  56.         TPrntStr(buffs[cnt].fname);
  57.         TKbChk();
  58.         }
  59.     TSetPoint(++tmp,0);
  60.     TCLEOL();
  61.     BSetMod(BScrnMrk(tmp));
  62.     TForce();
  63.     KbWait();
  64.     if (tmp>=divide) ModeLine();
  65.     }
  66.  
  67. MExit()                /* exit this level of the editor */
  68. {
  69.     arg=0;
  70.     tmp=FALSE;
  71.     for (cnt=BUFFSMAX-1; cnt>=0; --cnt) if (buffs[cnt].bbuff)
  72.         tmp |= BModp(buffs[cnt].bbuff);
  73.     if (tmp && !Ask("Abandon Modified Buffer(s)? ")) return;
  74.     abort=TRUE;
  75.     }
  76.  
  77. MFindFile()            /* Find a file */
  78. {
  79.     char tfname[FILMAX], tbname[BUFNAMMAX];
  80.  
  81.     arg=0;
  82.     tfname[0]=0;
  83.     do if (!GetArg("File to Find <CR>: ",CR,tfname,FILMAX)) return;
  84.         while (tfname[0]==0);
  85.     strip(tbname,tfname);
  86. #ifdef CPM
  87.     UpCase(tfname);
  88. #endif
  89.     LowCase(tbname);
  90.     for (cnt=BUFFSMAX-1; cnt>=0 && (buffs[cnt].bbuff==NULL ||
  91.         strcmp(tfname,buffs[cnt].fname)); --cnt);
  92.     TKbChk();
  93.     if (cnt<0) {
  94.         cnt=CFindBuff(tbname);
  95.         if (cnt>=0) {
  96.             if (!GetArg("Buffer Exists!  Buffer to Use <CR>: ",
  97.                 CR,tbname,BUFNAMMAX)) return;
  98.             LowCase(tbname);
  99.             cnt=CFindBuff(tbname);
  100.             ClrEcho();
  101.             }
  102.         if (cnt<0) if ((cnt=CMakeBuff(tbname,tfname))<0) return;
  103.         buffs[cnt].bmodes[0]=0;
  104.         strcpy(buffs[cnt].fname,tfname);
  105.         BSwitchTo(buffs[cnt].bbuff);
  106.         if (!BReadFile(tfname)) Echo("New File");
  107.         }
  108.     CSwitchTo(cnt);
  109.     ScrnRange();
  110.  
  111. #ifdef AUTOMODE
  112.     InitMode();
  113. #endif
  114.     }
  115.  
  116. MSetTabs()            /* Set the tab increment to arg */
  117. {
  118.     if (argp) tabincr=arg;
  119.     else tabincr=BGetCol();
  120.     if (tabincr==0) tabincr=1;
  121.     mvars[cbuff].mtab = tabincr;
  122.     arg=0;
  123.     NewDsp();            /* force redisplay */
  124.     }
  125.  
  126. MDelMode()            /* remove a mode */
  127. {
  128.     arg=0;
  129.     if (!(tmp=GetModeId("Delete Mode <CR>: "))) return;
  130.     for (cnt=MAXMODES-1; cnt>=0; --cnt)
  131.         if (tmp==buffs[cbuff].bmodes[cnt]) {
  132.             while (cnt>0 && buffs[cbuff].bmodes[cnt]) {
  133.                 buffs[cbuff].bmodes[cnt]=buffs[cbuff].bmodes[cnt-1];
  134.                 --cnt;
  135.                 }
  136.             buffs[cbuff].bmodes[cnt]='\0';
  137.             SetModes();
  138.             }
  139.     }
  140.  
  141. MFileRead()            /* read a file into the buffer */
  142. {
  143.     arg=0;
  144.     if (BModp(buffs[cbuff].bbuff) && !Ask("Clobber Modified Buffer? ")) {
  145.         ClrEcho();
  146.         return;
  147.         }
  148.     if (!GetArg("File To Read <CR>: ",CR,buffs[cbuff].fname,FILMAX))
  149.         return;
  150. #ifdef CPM
  151.     UpCase(buffs[cbuff].fname);
  152. #endif
  153.     if (!BReadFile(buffs[cbuff].fname)) Echo("New File");
  154.     else ClrEcho();
  155.     ModeLine();
  156.     }
  157.  
  158. MFileSave()            /* write the buffer to the default file */
  159. {
  160.     arg=0;
  161.     Echo("Writing...");
  162.     if (!BWriteFile(buffs[cbuff].fname)) Error("Can't open file");
  163.     else Echo ("File Written");
  164.     }
  165.  
  166. MNxtOthrWind()            /* scroll the other window down */
  167. {
  168.     if (divide>=TMaxRow()-2) return;
  169.     MSwpWind();
  170.     while (arg-- > 0) MNextPage();
  171.     MSwpWind();
  172.     }
  173.  
  174. MFileWrite()            /* write the buffer to a file */
  175. {
  176.     arg=0;
  177.     if (!GetArg("File To Write <CR>: ",CR,buffs[cbuff].fname,FILMAX)) return;
  178. #ifdef CPM
  179.     UpCase(buffs[cbuff].fname);
  180. #endif
  181.     MFileSave();
  182.     ModeLine();
  183.     }
  184.  
  185. MSwapMrk()            /* Swap the point with the mark */
  186. {
  187.     BSwapPnt(mark);
  188.     arg=0;
  189.     }
  190.  
  191. MPrvOthrWind()            /* scroll the other window up */
  192. {
  193.     if (divide>=TMaxRow()-2) return;
  194.     MSwpWind();
  195.     while (arg-- > 0) MPrevPage();
  196.     MSwpWind();
  197.     }
  198.  
  199. MSetIndent()            /* set the indent column */
  200. {
  201.     if (argp) indentcol=arg;
  202.     else indentcol=BGetCol();
  203.     Echo("Indent Column is ");
  204.     itot(indentcol);
  205.     mvars[cbuff].mindent = indentcol;
  206.     arg=0;
  207.     }
  208.  
  209. #ifdef UNIX
  210. MUnix()                /* execute a shell command */
  211. {
  212.     char cmnd_line[80];
  213.     int status;
  214.     
  215.     arg=0;
  216.     *cmnd_line='\0';
  217.     if (!GetArg("Shell Command <CR>: ",CR,cmnd_line,80)) return;
  218.     TSetPoint(TMaxRow()-1,0);
  219.     TCLEOL();
  220.     TForce();
  221.     TFini();
  222.     system(cmnd_line);
  223.     while (wait(&status) != -1);
  224.     printf("[Hit <CR> to return to Mince]");
  225.     while (getchar()!='\n');
  226.     TInit();
  227.     NewDsp();
  228.     }
  229. #endif
  230.  
  231. MPrintPos()            /* print the current position */
  232. {
  233. #ifndef CPM
  234.     long tmp;
  235. #endif
  236.  
  237.     BSwapPnt(mark);
  238.     tmp=BLocation();
  239.     BSwapPnt(mark);
  240.     Echo("Point ");
  241. #ifdef CPM
  242.     itot(BLocation());
  243. #else
  244.     ltot(BLocation());
  245. #endif
  246.     TPrntStr("   length ");
  247. #ifdef CPM
  248.     itot(BLength(buffs[cbuff].bbuff));
  249. #else
  250.     ltot(BLength(buffs[cbuff].bbuff));
  251. #endif
  252.     TPrntStr("   column ");
  253.     itot(BGetCol());
  254.     TPrntStr("   mark ");
  255. #ifdef CPM
  256.     itot(tmp);
  257. #else
  258.     ltot(tmp);
  259. #endif
  260.     TForce();
  261.     KbWait();
  262.     ClrEcho();
  263.     }
  264.  
  265. MOneWind()            /* switch to one window mode */
  266. {
  267.     if (divide>=TMaxRow()-2) return;
  268.     topp=TRUE;
  269.     BSetMod(BScrnMrk(divide));
  270.     divide=TMaxRow()-2;
  271.     BKillMrk(altstart);
  272.     BKillMrk(altpnt);
  273.     sendp=FALSE;
  274.     }
  275.  
  276. MTwoWind()            /* Switch to two window mode */
  277. {
  278.     if (divide<TMaxRow()-2) return;
  279.     divide=(TMaxRow()-2)/2;
  280.     ScrnRange();
  281.     altpnt=BCreMrk();
  282.     BSwapPnt(sstart);
  283.     altstart=BCreMrk();
  284.     BSwapPnt(sstart);
  285.     altbuff=cbuff;
  286.     ModeLine();
  287.     }
  288.  
  289. MSwitchTo()            /* switch buffers */
  290. {
  291.     int i;
  292.  
  293.     arg=0;
  294.     if (!GetArg("Switch to Buffer <CR>: ",CR,namearg,BUFNAMMAX)) return;
  295.     LowCase(namearg);
  296.     i=CFindBuff(namearg);
  297.     if (i<0 && (!Ask("Create new buffer?") ||
  298.         (i=CMakeBuff(namearg,"DELETE.ME"))<0)) return;
  299.     CSwitchTo(i);
  300.     ScrnRange();
  301.     }
  302.  
  303. MSetFill()            /* set the fill width */
  304. {
  305.     if (argp) fillwidth=arg;
  306.     else fillwidth=BGetCol();
  307.     Echo("Fill Column is ");
  308.     itot(fillwidth);
  309.     mvars[cbuff].mfill = fillwidth;
  310.     arg=0;
  311.     }
  312.  
  313. MKillBuff()            /* delete a buffer */
  314. {
  315.     int count;
  316.  
  317.     arg=0;
  318.     if (!GetArg("Delete Buffer <CR>: ",CR,namearg,BUFNAMMAX)) return;
  319.     LowCase(namearg);
  320.     if ((count=CFindBuff(namearg))<0) {
  321.         Error("Does not exist");
  322.         return;
  323.         }
  324.     if (count==cbuff) MSwitchTo();
  325.     if (count==cbuff) {
  326.         Error("Can't delete current");
  327.         return;
  328.         }
  329.     if (BModp(buffs[count].bbuff) && !Ask("Delete Modified Buffer?")) return;
  330.     if (divide<TMaxRow()-2 && count==altbuff) MOneWind();
  331.     BDelBuff(buffs[count].bbuff);
  332.     buffs[count].bbuff=NULL;
  333.     strcpy(namearg,buffs[cbuff].bname);
  334.     }
  335.  
  336. MAddMode()                /* add a mode to the list */
  337. {
  338.     arg=0;
  339.     if (!(tmp=GetModeId("Mode Name <CR>: "))) return;
  340.     for (cnt=MAXMODES-1; cnt>=0; --cnt) {
  341.         if (!buffs[cbuff].bmodes[cnt]) buffs[cbuff].bmodes[cnt]=tmp;
  342.         if (tmp==buffs[cbuff].bmodes[cnt]) {
  343.             SetModes();
  344.             return;
  345.             }
  346.         }
  347.     Error("No More Mode Room");
  348.     }
  349.     
  350. MSwpWind()            /* Switch which window we are in */
  351. {
  352.     int count;
  353.  
  354.     if (divide>=TMaxRow()-2) return;
  355.     tmp=altstart;            /* switch alt and cur screen start */
  356.     altstart=sstart;
  357.     sstart=tmp;
  358.     tmp=altpnt;            /* switch alt and cur point */
  359.     altpnt=BCreMrk();
  360.     count=cbuff;            /* switch buffers */
  361.     if (altbuff!=cbuff) CSwitchTo(altbuff);
  362.     altbuff=count;
  363.     sendp=FALSE;            /* fix up sstart, psstart, and send */
  364.     BPntToMrk(sstart);
  365.     BMove(-1);
  366.     BMrkToPnt(psstart);
  367.     BPntToMrk(tmp);        /* set new point */
  368.     BKillMrk(tmp);
  369.     topp = !topp;            /* switch top for bottom */
  370.     }
  371.  
  372. MGrowWind()            /* grow the current window */
  373. {
  374.     if (divide>=TMaxRow()-2) return;
  375.     BSetMod(BScrnMrk(divide));
  376.     divide += topp? arg : -arg;
  377.     if (divide>TMaxRow()-6) divide=TMaxRow()-6;
  378.     if (divide<3) divide=3;
  379.     ModeLine();
  380.     arg=0;
  381.     }
  382.  
  383.     /* page mode commands */
  384. MTrimWhite()
  385. {
  386.     tmark=BCreMrk();
  387.     BToStart();
  388.     while (!BIsEnd()) {
  389.         ToEndLine();
  390.         MDelWhite();
  391.         BMove(1);
  392.         }
  393.     BPntToMrk(tmark);
  394.     BKillMrk(tmark);
  395.     }
  396.  
  397. #ifdef KBMACRO
  398. /*************** keyboard macro hack *****************/
  399.  
  400. /*
  401.  * three funs: MStrtRem() - start remembering (bound to ^X-( ),
  402.  *           MStpRem()  - stop remembering (bound to ^X-) ), and
  403.  *           MExcKBMc() - execute keyboard macro (bound to ^X-e).
  404.  */
  405.  
  406. MStrtRem()
  407. {
  408.     argp = FALSE; arg = 0;
  409.     if (KBexecuting) {Error("Recursion illegal!"); abort = TRUE; return;}
  410.     if (remember) {Error("Already remembering!"); return;} 
  411.     remember = TRUE;
  412.     QInit(&kbmacro,MAXKBMACL);
  413.     Echo("Start remembering...");
  414.     }
  415. MStpRem()
  416. {
  417.     argp = FALSE; arg = 0;
  418.     if (KBexecuting) {abort = TRUE; return;}
  419.     if (!remember) {Error("Not remembering!"); return;}
  420.     remember = FALSE;
  421.     Echo("Keyboard macro defined...");
  422.     }
  423. MExcKBMc()
  424. {
  425.     int Kabort, Karg, Kargp, Kcmnd, (*Klfunct)();
  426.  
  427.     Kabort = abort;
  428.     Karg = arg;
  429.     Kargp = argp;
  430.     Kcmnd = cmnd;
  431.     Klfunct = lfunct;
  432.     KBexecuting = TRUE;
  433.     kbmacro.kbhead = kbmacro.kbtop;
  434.     GAbort = FALSE;
  435.     edit();
  436.     abort = Kabort;
  437.     arg = Karg;
  438.     argp = Kargp;
  439.     cmnd = Kcmnd;
  440.     lfunct = Klfunct;
  441.     KBexecuting = FALSE;
  442.     if (GAbort) {argp = FALSE; arg = 0;}
  443.     }
  444.  
  445. /*************** end of keyboard macro hack *****************/
  446. #endif
  447. #ifdef STRIDE
  448. /*************** Stride insert time hack ****************/
  449.  
  450. /*
  451.  * one function MInsTime() - inserts the current time into the buffer
  452.  */
  453.  
  454. #include <time.h>
  455.  
  456. MInsTime()
  457. {
  458.     static char timestr[32];
  459.     register char *p;
  460.     static REALTIME tbuff;
  461.  
  462.     gettime(&tbuff);
  463.     sprntime(timestr,&tbuff);
  464.     for (p=timestr;*p != '\0';p++) BInsert(*p);
  465.     }
  466. #endif
  467. /* END OF COMM3.C - Mince command routines */
  468.  
  469. str,&tbuff);
  470.     for (p=timestr;*p != '\0';p++) BInsert(*p);
  471.     }
  472. #endif
  473. /* END OF COMM3.C - Mince comman