home *** CD-ROM | disk | FTP | other *** search
/ ftp.barnyard.co.uk / 2015.02.ftp.barnyard.co.uk.tar / ftp.barnyard.co.uk / cpm / walnut-creek-CDROM / CPM / EDITOR / EDITOR.ARK / ED2.C < prev    next >
C/C++ Source or Header  |  1983-09-09  |  9KB  |  513 lines
  1. /* Screen editor:  main program -- BDS C version
  2.  *
  3.  * Source:  ed2.bds
  4.  * Version: August 8, 1982.
  5.  * Transliteration of small-C version of September 5, 1981
  6.  */
  7.  
  8. /* define globals */
  9.  
  10. #include ed.h
  11. #include bdscio.h
  12. #include ed1.ccc
  13. #include edext.cc
  14.  
  15. /* define signon message */
  16.  
  17. #define    SIGNON "BDS C Editor, version 2:  August 1982."
  18.  
  19. /* the main program dispatches the routines that
  20.  * handle the various modes.
  21.  */
  22.  
  23. #define CMNDMODE 1    /* enter command mode flag */
  24. #define INSMODE  2    /* enter insert modes flag */
  25. #define EDITMODE 3    /* enter edit mode flag */
  26. #define EXITMODE 4    /* exit editor flag */
  27.  
  28. main(argc,argv)
  29. int argc;
  30. char *argv[];
  31. {
  32. int mode;
  33.     /* fmt output by default goes to screen */
  34.     fmtassn(NO);
  35.     /* set tabs, clear the screen and sign on */
  36.     fmtset(8);
  37.     outclr();
  38.     outxy(0,SCRNL1);
  39.     message(SIGNON);
  40.     outxy(0,1);
  41.     /* clear filename [] for save(), resave() */
  42.     name("");
  43.     /* clear the main buffer */
  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,&v)) {
  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 &&
  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 &&
  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 &&
  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 && argcount == 2) {
  354.             strcpy(args,"load ");
  355.             strcat(args,sname);
  356.             startup = NO;
  357.         }
  358.         else    getcmnd(args,0);
  359.         fmtcrlf();
  360.         pmtline();
  361.         c=args [0];
  362.         if (c == EDIT1 || c==INS1) {
  363.             /* redraw screen */
  364.             if (oldline == bufln()) {
  365.                 /* get current line */
  366.                 edgetln();
  367.                 /* redraw old screen */
  368.                 bufout(topline,1,SCRNL1);
  369.                 outxy(0,ypos);
  370.             }
  371.             else {
  372.                 /* update line and screen */
  373.                 edgo(bufln(),0);
  374.             }
  375.             if (c == EDIT1) {
  376.                 return (EDITMODE);
  377.             }
  378.             else {
  379.                 return (INSMODE);
  380.             }
  381.         }
  382.         else if (tolower(args [0]) == 'g'){
  383.             argp=skipbl(args+1);
  384.             if (argp [0] == EOS) {
  385.                 edgo(oldline,0); 
  386.                 return(EDITMODE);
  387.             }
  388.             else if (number(argp,&v) == YES) {
  389.                 edgo(v,0);
  390.                 return(EDITMODE);
  391.             }
  392.             else {
  393.                 message("bad line number");
  394.             }
  395.         }
  396.         else if (lookup(args,"append")) {
  397.             append(args);
  398.         }
  399.         else if (lookup(args,"change")) {
  400.             change(args);
  401.         }
  402.         else if (lookup(args,"clear")) {
  403.             clear();
  404.         }
  405.         else if (lookup(args,"delete")) {
  406.             delete(args);
  407.         }
  408.         else if (lookup(args,"dos")) {
  409.             if (chkbuf() == YES) {
  410.                 return (EXITMODE);
  411.             }
  412.         }
  413.         else if (lookup(args,"find")) {
  414.             if ((k = find()) >= 0) {
  415.                 edgo(bufln(),k);
  416.                 return(EDITMODE);
  417.             }
  418.             else {
  419.                 /* get current line */
  420.                 bufgo(oldline);
  421.                 edgetln();
  422.                 /* stay in command mode */
  423.                 message("pattern not found");
  424.             }
  425.         }
  426.         else if (lookup(args,"list")) {
  427.             list(args);
  428.         }
  429.         else if (lookup(args,"load")) {
  430.             load(args);
  431.         }
  432.         else if (lookup(args,"name")) {
  433.             name(args);
  434.         }
  435.         else if (lookup(args,"resave")) {
  436.             resave();
  437.         }
  438.         else if (lookup(args,"save")) {
  439.             save();
  440.         }
  441.         else if (lookup(args,"search")) {
  442.             search(args);
  443.         }
  444.         else if (lookup(args,"tabs")) {
  445.             tabs(args);
  446.         }
  447.         else {
  448.             message("command not found");
  449.         }
  450.     }
  451. }
  452.  
  453. /* return YES if line starts with command */
  454.  
  455. lookup(line,command) char *line, *command;
  456. {
  457.     while(*command) {
  458.         if (tolower(*line++) != *command++) {
  459.             return(NO);
  460.         }
  461.     }
  462.     if(*line == EOS || *line == ' ' || *line == TAB) {
  463.         return(YES);
  464.     }
  465.     else {
  466.         return(NO);
  467.     }
  468. }
  469.  
  470. /* get next command into argument buffer */
  471.  
  472. getcmnd(args,offset) char *args; int offset;
  473. {
  474. int j,k;
  475. char c;
  476.     outxy(offset,outgety());
  477.     outdeol();
  478.     k=0;
  479.     while ((c=syscin()) != CR) {
  480.         if (c == EDIT1 || c == INS1) {
  481.             args [0]=c;
  482.             return;
  483.         }
  484.         if (c == DEL1 || c == LEFT1) {
  485.             if (k>0) {
  486.                 outxy(offset,outgety());
  487.                 outdeol();
  488.                 k--;
  489.                 j=0;
  490.                 while (j < k) {
  491.                     outchar(args [j++]);
  492.                 }
  493.             }
  494.         }
  495.         else if (c == ABT1) {
  496.             outxy(offset,outgety());
  497.             outdeol();
  498.             k=0;
  499.         }
  500.         else if (c != TAB && (c < 32 || c == 127)) {
  501.             /* do nothing */
  502.             continue;
  503.         }
  504.         else {
  505.             if (k+offset < SCRNW1) {
  506.                 args [k++]=c;
  507.                 outchar(c);
  508.             }
  509.         }
  510.     }
  511.     args [k]=EOS;
  512. }
  513.