home *** CD-ROM | disk | FTP | other *** search
/ Oakland CPM Archive / oakcpm.iso / cpm / amethyst / kbdmacro.txt < prev    next >
Encoding:
Text File  |  1984-01-16  |  6.3 KB  |  218 lines
  1.     This file contains the necessary modifications to Mince in order to
  2. add Emacs like keyboard macros.  A keyboard macro is a sequence of
  3. keystokes that may be stored away and replayed as often as the user wishes.
  4. To define a macro, type "control-X (".  An 'M' will show up in the modeline
  5. as long as you are defining the macro.  Then start typing in a sequence of
  6. keystrokes to be stored away.  Notice that these keys are executed as well
  7. as stored away.  When you are finished defining the macro, type 
  8. "control-X )".  When you wish to repeat that sequence of keystrokes, hit
  9. "control-X E".  You may cause a macro invocation to be repeated a specified
  10. number of times by preceeding the "control-X E" by an argument.
  11.  
  12.     If there is an error during the macro execution, or if the user hits
  13. any key at all, the macro is immediately aborted.  The macro system will
  14. detect an error if normal execution of the command gives off a beep.  If in
  15. the middle of defining a macro, an error occurs, the definition is aborted.
  16.  
  17.     Note that the extra code to make this all work requires the
  18. compilation of LMINCE instead of MINCE.  The difference is about 2k less
  19. main memory swap space.
  20.  
  21.     What follows is a list of files and the modifications to be made in
  22. those files.  If you have any problems, I might be able to help.
  23.  
  24.         Cliff Lasser            Arpanet: (CAL@MIT-OZ)
  25.         155 Bay State Rd
  26.         Boston MA 02215
  27.         (617) 235-1515
  28.  
  29. ------------------------------------------------------------ 
  30. file: LMC.SUB  (note that the line with L2 cannot be made any longer)
  31.  
  32. cc1 m.c -e8100
  33. cc1 bindings.c -e8100
  34. cc1 comm1.c -e8100
  35. cc1 comm2.c -e8100
  36. cc1 comm3.c -e8100
  37. cc1 support.c -r10 -e8100
  38. cc1 term.c -e8100
  39. l2 lmince bindings comm1 comm2 comm3 lvbuff1 lvbuff3 lvbuff2 m -l support laterm term lutil
  40.  
  41. ------------------------------------------------------------
  42. file:MINCE.GBL 
  43.  
  44. #define macrdy    1    /* Is there a macro char ready? */
  45. #define macgetc 2    /* Get the next macro char */
  46. #define macputc 3    /* store a macro char maybe (returns input) */
  47. #define macdef 4    /* start defining a macro */
  48. #define macedef 5    /* end defining the macro */
  49. #define macdefp 6    /* are we in the middle of defining a macro? */
  50. #define macabort 7    /* quit this macro invocation */
  51. #define macinv    8    /* start invoking the macro */
  52. #define macinit 9    /* init the macro stuff */
  53. #define mackbhit 10    /* whenever the user hits a key */
  54.  
  55. ---------------------------------------------------------------------
  56. file: BINDINGS.C
  57. function finit3:
  58.     int MMacDef(), MMacEDef(), MMacInv();
  59.     functs[256+'('] = MMacDef;                /* C-X ( */
  60.     functs[256+')'] = MMacEDef;                /* C-X ) */
  61.     functs[256+'E']=functs[256+'e'] = MMacInv;    /* C-X E */
  62.  
  63. function UInit:
  64.     macro(macinit);        /* init the macro system */
  65.  
  66. ------------------------------------------------------------
  67. File: TERM.C
  68. TBell()                /* Ring the terminal bell */
  69. {
  70.     macro(macabort);
  71.     put_string(&terminal.bell);
  72.     }
  73.  
  74. TKbRdy()                /* Returns TRUE if input available */
  75. {
  76.     TKbChk();
  77.     return (macro(macrdy) || (!QEmpty(&kbdq)));
  78.     }
  79.  
  80. TGetKb()                /* Returns an input character */
  81. {
  82.     unsigned c;
  83.     while (!TKbRdy());
  84.     if (!QEmpty(&kbdq)) macro(mackbhit);  /* inform macro about user char */
  85.     if (macro(macrdy)) return (macro(macgetc));    /* get macro char */
  86.     c=QGrab(&kbdq);
  87.     macro(macputc,c);
  88.     return (c);
  89.     }
  90.  
  91. ------------------------------------------------------------
  92. file: SUPPORT.C
  93. ModeFlags()            /* Display the mode flags */
  94. {
  95. #ifdef CPM
  96.     unsigned loc, len;
  97. #else
  98.     long loc, len;
  99. #endif
  100.  
  101.     if (TKbRdy()) return;
  102.     TDisStr(TMaxRow()-2,stat_col," -");
  103.     loc=BLocation();
  104.     len=BLength(buffs[cbuff].bbuff);
  105. #ifdef CPM
  106.     if (loc<655) itot((loc*100)/len);
  107.     else if (loc<6550) itot((loc*10)/(len/10+1));
  108.     else itot(loc/(len/100+1));
  109. #else
  110.     if (len==0) len=1;
  111.     itot((int)((loc*100)/len));
  112. #endif
  113.     TPrntStr("%- ");
  114.     if (TKbRdy()) return;
  115.     TPrntChar(BModp(buffs[cbuff].bbuff) ? '*' : ' ');
  116.     TPrntChar(DelCmnd(lfunct) ? '+' : ' ');
  117.     TPrntChar(macro(macdefp) ? 'M' : ' ');    /* Are we defining a macro? */
  118.     TCLEOL();
  119.     }
  120.  
  121. ------------------------------------------------------------
  122. New file: M.C
  123. #include "mince.gbl"
  124.  
  125. /*
  126.     The functions in this file define a keyboard macro facility very
  127.     similar to that in EMACS.  At the moment only one macro can be stored
  128.     at a time.
  129.             Cliff Lasser         1/10/84    (CAL@MIT-OZ)
  130. */
  131.  
  132. macro(fnum,c)
  133. unsigned fnum,c;
  134. {
  135.     unsigned *buffer;    /* points to the macro definition (static) */
  136.     unsigned *ebuffer;    /* points to the last char of macro buffer */
  137.     unsigned *cpoint;    /* points the the current character in the def */
  138.     unsigned *epoint;    /* points to last char in current def */
  139.     unsigned *count;    /* how many times left to do this macro */
  140.     char *definingp;    /* are we currently defining a macro */
  141.     char *tpoint;
  142.  
  143.     /* here is some static storage since I can't change mince.gbl */
  144.     buffer="12345678901234567890123456789012345678901234567890";
  145.     cpoint="12"; epoint="12";
  146.     count="\0\0";
  147.     definingp="\0";
  148.     ebuffer=buffer+25;
  149.  
  150. /*    printf(" macro (%d,%d) ",fnum,c); */
  151.     switch (fnum) {
  152.     case macinit:
  153.         *cpoint=buffer; *count=0; *definingp=0;
  154.         strcpy(buffer,"\023\033"); *epoint=buffer+1;    /* control-s, escape */
  155.         return;
  156.     case macrdy:    /* is there a macro char? */
  157.         return (*count);
  158.     case macabort:
  159.         if (*definingp) {
  160.             *cpoint=*epoint=buffer; *definingp=0; modeline();
  161.             return;
  162.             }
  163.         if (*count) { *cpoint=buffer; *count=0; }
  164.         return;    /* do nothing if not invoking or defining */
  165.     case mackbhit:
  166.         if (!*definingp) macro(macabort);    /* only if invoking, abort */
  167.         return;
  168.     case macdefp:
  169.         return (*definingp);
  170.     case macdef:
  171.         *definingp=1; *cpoint=*epoint=buffer; modeline();
  172.         return;
  173.     case macedef:
  174.         *definingp=0; modeline();
  175.         return;
  176.     case macinv:
  177. /*        printf(" (arg=%d) ",arg);  */
  178.         if (*epoint == buffer) return;    /* null macro does nothing */
  179.         *count=arg;        /* do this one time */
  180.         *cpoint=buffer;
  181.         return;
  182.     case macputc:
  183.         if (!*definingp) return (c);    /* not defining. do nothing */
  184.         if (*epoint >= ebuffer) {        /* too many chars */
  185.             macro(macinit);
  186.             error("Macro too big");
  187.             modeline();
  188.             return (7);
  189.             }
  190.         tpoint=*epoint; *tpoint=c; *epoint+=1;
  191.         return (c);
  192.     case macgetc:
  193.         tpoint=*cpoint; c=*tpoint; *cpoint+=1;
  194.         if (*cpoint == *epoint) { *cpoint=buffer; *count -=1; }
  195.         return (c);
  196.     default:
  197.         error("macro sys err");
  198.     }
  199. }
  200.  
  201.  
  202. MMacDef()        /* start a macro definition */
  203. {
  204.     macro(macdef);
  205.     }
  206.  
  207. MMacEDef()    /* end a macro definition */
  208. {
  209.     macro(macedef);
  210.     }
  211.  
  212. MMacInv()        /* start a macro invocation */
  213. {
  214.     macro(macinv);
  215.     arg=0;
  216.     }
  217.  
  218.