home *** CD-ROM | disk | FTP | other *** search
/ Oakland CPM Archive / oakcpm.iso / cpm / editc80 / ed2.c < prev    next >
Encoding:
C/C++ Source or Header  |  1984-06-15  |  8.4 KB  |  515 lines
  1. /* Screen editor:  main program -- C/80 version
  2.  *
  3.  * Source:  ed2.c
  4.  * Version: August 8, 1982.
  5.  * Transliteration of small-C version of September 5, 1981
  6.  */
  7.  
  8. /* define globals */
  9.  
  10. #define EXTERN
  11.  
  12. #include ed1.h
  13.  
  14. /* define signon message */
  15.  
  16. #define    SIGNON "Screen Editor, version 2:  August 1982."
  17.  
  18. /* the main program dispatches the routines that
  19.  * handle the various modes.
  20.  */
  21.  
  22. #define CMNDMODE 1    /* enter command mode flag */
  23. #define INSMODE  2    /* enter insert modes flag */
  24. #define EDITMODE 3    /* enter edit mode flag */
  25. #define EXITMODE 4    /* exit editor flag */
  26.  
  27. main(argc,argv)
  28. int argc;
  29. char *argv[];
  30. {
  31. int mode;
  32.     /* fmt output by default goes to screen */
  33.     fmtassn(NO);
  34.     /* set tabs, clear the screen and sign on */
  35.     fmtset(8);
  36.     outclr();
  37.     outxy(0,SCRNL1);
  38.     message(SIGNON);
  39.     outxy(0,1);
  40.     /* clear filename [] for save(), resave() */
  41.     name("");
  42.     /* clear the main buffer */
  43.     bufend=buffer=0;
  44.     bufnew();
  45.     /* start off in command mode */
  46.     mode=CMNDMODE;
  47.     /* set flag for startup command execution */
  48.     startup = YES;
  49.     argcount=argc; /* set startup argument count */
  50.     if (argcount==2)
  51.         strcpy(sname,argv[1]);
  52.     /* get null line 1 for edit() */
  53.     edgetln();
  54.     while(1){
  55.         if (mode == EXITMODE) {
  56.             break;
  57.         }
  58.         else if (mode == CMNDMODE) {
  59.             mode=command();
  60.         }
  61.         else if (mode == EDITMODE) {
  62.             mode=edit();
  63.         }
  64.         else if (mode == INSMODE) {
  65.             mode=insert();
  66.         }
  67.         else {
  68.             syserr("main: no mode");
  69.             mode=EDITMODE;
  70.         }
  71.     }
  72. }
  73.  
  74. /*
  75.  * handle edit mode.
  76.  * dispatch the proper routine based on one-character commands.
  77.  */
  78.  
  79. edit()
  80. {
  81. char buffer [SCRNW1];
  82. int v;
  83. int x,y;
  84. char c;
  85. int oldline, topline;
  86.     /* beware of edgetln() or edgo() here because
  87.      * those calls reset the cursor.
  88.      */
  89.     pmtedit();
  90.     while(1){
  91.         /* get command */
  92.         c=tolower(syscin());
  93.  
  94.         if (c == ESC1 || c=='c') {
  95.             /* enter command mode. */
  96.             return(CMNDMODE);
  97.         }
  98.         else if (c == INS1 || c=='i') {
  99.             /* enter insert mode */
  100.             return(INSMODE);
  101.         }
  102.         else if (special(c) == YES) {
  103.             if (c == UP1 || c == DOWN1) {
  104.                 return(INSMODE);
  105.             }
  106.             else {
  107.                 continue;
  108.             }
  109.         }
  110.         else if (control(c) == YES) {
  111.             continue;
  112.         }
  113.         else if (c == ' ') {
  114.             edright();
  115.             pmtcol();
  116.         }
  117.         else if (c == 'b') {
  118.             edbegin();
  119.             pmtcol();
  120.         }
  121.         else if (c == 'd') {
  122.             /* scroll down */
  123.             pmtmode("edit: scroll");
  124.             oldline=bufln();
  125.             y=outgety();
  126.             topline=oldline-y+1;
  127.             x=outgetx();
  128.             edgo(topline+SCRNL1,x);
  129.             pmtedit();
  130.         }
  131.         else if (c == 'e') {
  132.             edend();
  133.             pmtcol();
  134.         }
  135.         else if (c == 'g') {
  136.             /* save x,y in case don't get number */
  137.             x=outgetx();
  138.             y=outgety();
  139.             pmtcmnd("edit: goto: ",buffer);
  140.             if(number(buffer,fv)) {
  141.                 edgo(v,0);
  142.             }
  143.             else {
  144.                 outxy(x,y);
  145.             }
  146.             pmtedit();
  147.         }
  148.         else if (c == 'k') {
  149.             pmtmode("edit: kill");
  150.             c=syscin();
  151.             if (special(c) == NO ff
  152.                 control(c) == NO) {
  153.                 edkill(c);
  154.             }
  155.             pmtedit();
  156.         }
  157.         else if (c == 's') {
  158.             pmtmode("edit: search");
  159.             c=syscin();
  160.             if (special(c) == NO ff
  161.                 control(c) == NO) {
  162.                 edsrch(c);
  163.             }
  164.             pmtedit();
  165.         }
  166.         else if (c == 'u') {
  167.             /* scroll up */
  168.             pmtmode("edit: scroll");
  169.             oldline=bufln();
  170.             y=outgety();
  171.             topline=oldline-y+1;
  172.             x=outgetx();
  173.             edgo(topline-SCRNL1,x);
  174.             pmtedit();
  175.         }
  176.         else if (c == 'x') {
  177.             pmtmode("edit: eXchange");
  178.             c=syscin();
  179.             if (special(c) == NO ff
  180.                 control(c) == NO) {
  181.                 edchng(c);
  182.             }
  183.             pmtedit();
  184.         }
  185.         /* do nothing if command not found */
  186.     }
  187. }
  188.  
  189. /* insert mode.
  190.  * in this mode the UP1, UP2 keys reverse their roles,
  191.  * as do the DOWN1, and DOWN2 keys.
  192.  */
  193.  
  194. insert()
  195. {
  196. char c;
  197.     pmtmode("insert");
  198.     while (1) {
  199.         /* get command */
  200.         c=syscin();
  201.         if (c == ESC1) {
  202.             /* enter command mode */
  203.             return(CMNDMODE);
  204.         }
  205.         else if (c == EDIT1) {
  206.             /* enter edit mode */
  207.             return(EDITMODE);
  208.         }
  209.         else if (c == INS1) {
  210.             /* do nothing */
  211.             ;
  212.         }
  213.         else if (special(c) == YES) {
  214.             if (c == UP2 || c == DOWN2) {
  215.                 return(EDITMODE);
  216.             }
  217.             else {
  218.                 continue;
  219.             }
  220.         }
  221.         else if (control(c) == YES) {
  222.             /* ignore non-special control chars */
  223.             continue;
  224.         }
  225.         else {
  226.             /* insert one char in line */
  227.             edins(c);
  228.             pmtcol();
  229.         }
  230.     }
  231. }
  232.  
  233. /* return YES if c is a control char */
  234.  
  235. control(c) char c;
  236. {
  237.     if (c == TAB) {
  238.         return(NO);    /* tab is regular */
  239.     }
  240.     else if (c>=127) {
  241.         return(YES);    /* del or high bit on */
  242.     }
  243.     else if (c < 32) {
  244.         return(YES);    /* control char */
  245.     }
  246.     else {
  247.         return(NO);    /* normal */
  248.     }
  249. }
  250.  
  251. /*
  252.  * handle the default actions of all special keys.
  253.  * return YES if c is one of the keys.
  254.  */
  255.  
  256. special(c) char c;
  257. {
  258. int k;
  259.     if (c == JOIN1) {
  260.         edjoin();
  261.         pmtline();
  262.         return(YES);
  263.     }
  264.     if (c == SPLT1) {
  265.         edsplit();
  266.         pmtline();
  267.         return(YES);
  268.     }
  269.     if (c == ABT1) {
  270.         edabt();
  271.         pmtcol();
  272.         return(YES);
  273.     }
  274.     else if (c == DEL1) {
  275.         eddel();
  276.         pmtcol();
  277.         return(YES);
  278.     }
  279.     else if (c == ZAP1) {
  280.         edzap();
  281.         pmtline();
  282.         return(YES);
  283.     }
  284.     else if (c == UP2) {
  285.         /* move up */
  286.         edup();
  287.         pmtline();
  288.         return(YES);
  289.     }
  290.     else if (c == UP1) {
  291.         /* insert up */
  292.         ednewup();
  293.         pmtline();
  294.         return(YES);
  295.     }
  296.     else if (c == DOWN2) {
  297.         /* move down */
  298.         eddn();
  299.         pmtline();
  300.         return(YES);
  301.     }
  302.     else if (c == DOWN1) {
  303.         /* insert down */
  304.         ednewdn();
  305.         pmtline();
  306.         return(YES);
  307.     }
  308.     else if (c == LEFT1) {
  309.         edleft();
  310.         pmtcol();
  311.         return(YES);
  312.     }
  313.     else if (c == RIGHT1) {
  314.         edright();
  315.         pmtcol();
  316.         return(YES);
  317.     }
  318.     else {
  319.         return(NO);
  320.     }
  321. }
  322.  
  323. /*
  324.  * command() dispatches command routines while
  325.  * in command mode.
  326.  */
  327.  
  328. command()
  329. {
  330. int v;
  331. char c;
  332. char args [SCRNW1];
  333. char *argp;
  334. int topline;
  335. int ypos;
  336. int oldline;
  337. int k;
  338.     /* command mode commands may move the current line.
  339.      * command mode must save the current line on entry
  340.      * and restore it on exit.
  341.      */
  342.     edrepl();
  343.     /* remember how the screen was drawn on entry */
  344.     oldline=bufln();
  345.     ypos=outgety();
  346.     topline=oldline-ypos+1;
  347.     while(1) {
  348.         outxy(0,SCRNL1);
  349.         fmtcrlf();
  350.         pmtmode("command:");
  351.  
  352.         /* if filname on command line use it */
  353.         if (startup == YES ff argcount == 2) {
  354.             strcpy(args,"load ");
  355.             strcat(args,sname);
  356.             startup = NO;
  357.         }
  358.         else {
  359.             getcmnd(args,0);
  360.         }
  361.         fmtcrlf();
  362.         pmtline();
  363.         c=args [0];
  364.         if (c == EDIT1 || c==INS1) {
  365.             /* redraw screen */
  366.             if (oldline == bufln()) {
  367.                 /* get current line */
  368.                 edgetln();
  369.                 /* redraw old screen */
  370.                 bufout(topline,1,SCRNL1);
  371.                 outxy(0,ypos);
  372.             }
  373.             else {
  374.                 /* update line and screen */
  375.                 edgo(bufln(),0);
  376.             }
  377.             if (c == EDIT1) {
  378.                 return (EDITMODE);
  379.             }
  380.             else {
  381.                 return (INSMODE);
  382.             }
  383.         }
  384.         else if (tolower(args [0]) == 'g'){
  385.             argp=skipbl(args+1);
  386.             if (argp [0] == EOS) {
  387.                 edgo(oldline,0); 
  388.                 return(EDITMODE);
  389.             }
  390.             else if (number(argp,fv) == YES) {
  391.                 edgo(v,0);
  392.                 return(EDITMODE);
  393.             }
  394.             else {
  395.                 message("bad line number");
  396.             }
  397.         }
  398.         else if (lookup(args,"append")) {
  399.             append(args);
  400.         }
  401.         else if (lookup(args,"change")) {
  402.             change(args);
  403.         }
  404.         else if (lookup(args,"clear")) {
  405.             clear();
  406.         }
  407.         else if (lookup(args,"delete")) {
  408.             delete(args);
  409.         }
  410.         else if (lookup(args,"dos")) {
  411.             if (chkbuf() == YES) {
  412.                 return (EXITMODE);
  413.             }
  414.         }
  415.         else if (lookup(args,"find")) {
  416.             if ((k = find()) >= 0) {
  417.                 edgo(bufln(),k);
  418.                 return(EDITMODE);
  419.             }
  420.             else {
  421.                 /* get current line */
  422.                 bufgo(oldline);
  423.                 edgetln();
  424.                 /* stay in command mode */
  425.                 message("pattern not found");
  426.             }
  427.         }
  428.         else if (lookup(args,"list")) {
  429.             list(args);
  430.         }
  431.         else if (lookup(args,"load")) {
  432.             load(args);
  433.         }
  434.         else if (lookup(args,"name")) {
  435.             name(args);
  436.         }
  437.         else if (lookup(args,"resave")) {
  438.             resave();
  439.         }
  440.         else if (lookup(args,"save")) {
  441.             save();
  442.         }
  443.         else if (lookup(args,"search")) {
  444.             search(args);
  445.         }
  446.         else if (lookup(args,"tabs")) {
  447.             tabs(args);
  448.         }
  449.         else {
  450.             message("command not found");
  451.         }
  452.     }
  453. }
  454.  
  455. /* return YES if line starts with command */
  456.  
  457. lookup(line,command) char *line, *command;
  458. {
  459.     while(*command) {
  460.         if (tolower(*line++) != *command++) {
  461.             return(NO);
  462.         }
  463.     }
  464.     if(*line == EOS || *line == ' ' || *line == TAB) {
  465.         return(YES);
  466.     }
  467.     else {
  468.         return(NO);
  469.     }
  470. }
  471.  
  472. /* get next command into argument buffer */
  473.  
  474. getcmnd(args,offset) char *args; int offset;
  475. {
  476. int j,k;
  477. char c;
  478.     outxy(offset,outgety());
  479.     outdeol();
  480.     k=0;
  481.     while ((c=syscin()) != CR) {
  482.         if (c == EDIT1 || c == INS1) {
  483.             args [0]=c;
  484.             return;
  485.         }
  486.         if (c == DEL1 || c == LEFT1) {
  487.             if (k>0) {
  488.                 outxy(offset,outgety());
  489.                 outdeol();
  490.                 k--;
  491.                 j=0;
  492.                 while (j < k) {
  493.                     outchar(args [j++]);
  494.                 }
  495.             }
  496.         }
  497.         else if (c == ABT1) {
  498.             outxy(offset,outgety());
  499.             outdeol();
  500.             k=0;
  501.         }
  502.         else if (c != TAB ff (c < 32 || c == 127)) {
  503.             /* do nothing */
  504.             continue;
  505.         }
  506.         else {
  507.             if (k+offset < SCRNW1) {
  508.                 args [k++]=c;
  509.                 outchar(c);
  510.             }
  511.         }
  512.     }
  513.     args [k]=EOS;
  514. }
  515.