home *** CD-ROM | disk | FTP | other *** search
/ Source Code 1992 March / Source_Code_CD-ROM_Walnut_Creek_March_1992.iso / usenet / altsrcs / 3 / 3445 / main.c < prev   
Encoding:
C/C++ Source or Header  |  1991-06-07  |  12.6 KB  |  534 lines
  1. /*
  2. *    BEAV is based on the source for emacs for display and keyboard handling 
  3. * functions.   The binary file handling and display formats are special
  4. * to BEAV.   There is a full manual included in this release.   There
  5. * are makefiles for unix and MSC 5.1 under DOS.   The old Wang PC is
  6. * supported.   This release is for unix.   The def_unix.h file is the
  7. * header for unix and the def_dos.h file is the header for dos.   Rename 
  8. * the appropriate .h file to def.h to convert to your os.
  9. *     I am willing to maintain BEAV and will entertain suggestions for
  10. * modifications and/or bug fixes.   I can be reached at;
  11. *
  12. *         pvr@wang.com
  13. * 
  14. * or at;
  15. * 
  16. *         Peter Reilley
  17. *         19 Heritage Cir.
  18. *         Hudson, N.H. 03051
  19. */
  20.  
  21. /*
  22. *    Bug fix log
  23. *    3/04/91        1.20        pvr
  24. *        Create new file with read/write permisions.
  25. *        Fix polled mode system hog tty bug.
  26. *        Add ANSI define for DOS.
  27. *        Define short for D16 type.
  28. *        Call ttclose on error exit.
  29. *        Limit nrow and ncol to actual array size.
  30. *        Added beavrc key binding functionallity.
  31. *        Added delete current window command.
  32. *        Support VT100 type function keys for binding.
  33. */ 
  34. /*     
  35. *
  36. *     Mainline, macro commands.
  37. */
  38. #include        "def.h"
  39.  
  40. char    execute ();
  41. void    edinit ();
  42. void    flush_all ();
  43. char    quit ();
  44. char    ctrlg ();
  45. void    _lowercase ();
  46.  
  47.  
  48. extern    char    MSG_ok[];
  49. extern    char    MSG_main[];
  50. extern    char    MSG_prog_name[];
  51. extern    char    MSG_no_mod[];
  52. extern    char    MSG_no_s_chg[];
  53. extern    char    MSG_auto_fl[];
  54. extern    char    MSG_quit[];
  55. extern    char    MSG_not_now[];
  56. extern    char    MSG_st_mac[];
  57. extern    char    MSG_end_mac[];
  58. extern    char    MSG_num_mod[];
  59. extern    char    MSG_null[];
  60.  
  61. #include    "lintfunc.dec"
  62.  
  63. int     thisflag;               /* Flags, this command      */
  64. int     lastflag;               /* Flags, last command          */
  65. int     curgoal;                /* Goal column                  */
  66. int     com_line_flags;         /* Count of cmd line switches   */
  67. BUFFER * curbp;                 /* Current buffer               */
  68. WINDOW * curwp;                 /* Current window               */
  69. BUFFER * bheadp;                /* BUFFER listhead              */
  70. WINDOW * wheadp;                /* WINDOW listhead              */
  71. BUFFER * blistp;                /* Buffer list BUFFER           */
  72. short   kbdm[NKBDM] = {(KCTLX | ')')};  /* Macro (fitz)  */
  73. short  *kbdmip;                 /* Input  for above             */
  74. short  *kbdmop;                 /* Output for above             */
  75. char    pat[NPAT];              /* Pattern                      */
  76. SYMBOL * symbol[NSHASH];        /* Symbol table listhead.       */
  77. SYMBOL * binding[NKEYS];        /* Key bindings.                */
  78. extern  ROW_FMT hex_8_fmt;
  79. extern  bool    ibm_pc, mem_map;
  80.  
  81. char   *okmsg = {MSG_ok};
  82. int     insert_mode = {TRUE};
  83. int     extend_buf = {FALSE};
  84.  
  85. extern  bool    srch_mode;
  86. extern  bool    rplc_mode;
  87. extern  char    *getenv ();
  88. int     initial_load = 0;
  89. int     flush_count = 0;
  90. int     flush_num = 500;
  91. int     auto_update = 0;
  92.  
  93. void main (argc, argv)
  94. char   *argv[];
  95. {
  96.  
  97.     register    int     c;
  98.     register    int     f;
  99.     register    int     n;
  100.     register    int     mflag;
  101.     char        bname[NBUFN];
  102.     register    char    *p;
  103.     extern      long    last_time;
  104.     long        last_second;
  105.  
  106. #if MSDOS
  107.     is_wang ();                 /* Check for computer type */   
  108. #endif
  109.     init_fmt ();                /* initialize format arrays */
  110.     strcpy (bname, MSG_main);     /* Get buffer name.     */
  111.     vtinit ();                  /* Virtual terminal.    */
  112.     keymapinit ();              /* Symbols, bindings.   */
  113.     
  114.     if (argc == 1)
  115.         {
  116.         edinit (bname);
  117.         update ();
  118.         eerase ();
  119.         }
  120.  
  121.     else
  122.         {
  123.         com_line_flags = 0;
  124.         initial_load = 1;
  125.         n = (argc - 1);         /* Load  them backwards */
  126.         if (n > com_line_flags)
  127.             {
  128. /*            _lowercase (argv[n]); */
  129.             makename (bname, argv[n]);
  130.             edinit (bname);     /* Buffers, windows.    */
  131.             update ();
  132.             readin (argv[n--], 0L, MAXPOS);
  133.             for (; n > com_line_flags; n--)
  134.                 {
  135. /*                _lowercase (argv[n]); */
  136.                 load_file (argv[n], 0L, MAXPOS);
  137.                 }
  138.             }
  139.         else
  140.             {
  141.             edinit (bname);
  142.             update ();
  143.             }
  144.  
  145.         initial_load = 0;
  146.         }
  147.  
  148.     check_extend (NULL);  /* check for extended keys */
  149.     lastflag = 0;               /* Fake last flags.     */
  150.  
  151. loop: 
  152.     update ();
  153.     c = getkey ();
  154.     if (epresf != FALSE)
  155.         {
  156.         eerase ();
  157.         update ();
  158.         }
  159.     f = FALSE;
  160.     n = 1;
  161.     if (c == (KCTRL | 'U'))
  162.         {
  163.     /* ^U, start argument.  */
  164.         f = TRUE;
  165.         n = 4;
  166.         while ((c = getkey ()) == (KCTRL | 'U'))
  167.             n *= 4;
  168.         if ((c >= '0' && c <= '9') || c == '-')
  169.             {
  170.             if (c == '-')
  171.                 {
  172.                 n = 0;
  173.                 mflag = TRUE;
  174.                 }
  175.             else
  176.                 {
  177.                 n = c - '0';
  178.                 mflag = FALSE;
  179.                 }
  180.             while ((c = getkey ()) >= '0' && c <= '9')
  181.                 n = 10 * n + c - '0';
  182.             if (mflag != FALSE)
  183.                 n = -n;
  184.             }
  185.         }
  186.     if (kbdmip != NULL)
  187.         {
  188.     /* Save macro strokes.  */
  189.         if (c != (KCTLX | ')') && kbdmip > &kbdm[NKBDM - 6])
  190.             {
  191.             ctrlg (FALSE, 0, KRANDOM);
  192.             goto loop;
  193.             }
  194.         if (f != FALSE)
  195.             {
  196.             *kbdmip++ = (KCTRL | 'U');
  197.             *kbdmip++ = n;
  198.             }
  199.         *kbdmip++ = c;
  200.         }
  201.     execute (c, f, n);          /* Do it.               */
  202.     goto loop;
  203. }
  204.  
  205.  
  206. /*
  207. * Command execution. Look up the binding in the the
  208. * binding array, and do what it says. Return a very bad status
  209. * if there is no binding, or if the symbol has a type that
  210. * is not usable (there is no way to get this into a symbol table
  211. * entry now). Also fiddle with the flags.
  212. */
  213. char    execute (c, f, n)
  214. {
  215.  
  216.     register    SYMBOL * sp;
  217.     register int    status;
  218.  
  219.     if ((sp = binding[c]) != NULL)
  220.         {
  221.         thisflag = 0;
  222.         if (sp -> s_modify & SMOD && (curbp -> b_flag & BFVIEW))
  223.             {
  224.             writ_echo (MSG_no_mod);
  225.             return (ABORT);
  226.             }
  227.         if (sp -> s_modify & SSIZE && (curbp -> b_flag & BFSLOCK))
  228.             {
  229.             writ_echo (MSG_no_s_chg);
  230.             return (ABORT);
  231.             }
  232.         if ((srch_mode  && !(sp -> s_modify & SSRCH)) ||
  233.             (rplc_mode  && !(sp -> s_modify & SRPLC)))
  234.             {
  235.             ttbeep ();
  236.             return (TRUE);
  237.             }
  238.  
  239.         status = (*sp -> s_funcp) (f, n, c);
  240.         if (sp -> s_modify & SMOD)
  241.             flush_count++;
  242.  
  243.         if (flush_count >= flush_num && auto_update)
  244.             if (!(kbdmip != NULL || kbdmop != NULL))/* not during macro */
  245.                 {
  246.                 ttbeep ();
  247.                 writ_echo (MSG_auto_fl);
  248.                 flush_all ();
  249.                 }
  250.         lastflag = thisflag;
  251.         return (status);
  252.         }
  253.     else
  254.         bad_key (c);
  255.  
  256.     lastflag = 0;
  257.     return (ABORT);
  258. }
  259.  
  260.  
  261. /*
  262. * Initialize all of the buffers
  263. * and windows. The buffer name is passed down as
  264. * an argument, because the main routine may have been
  265. * told to read in a file by default, and we want the
  266. * buffer name to be right.
  267. */
  268. void edinit (bname)
  269. char    bname[];
  270. {
  271.  
  272.     register    BUFFER * bp;
  273.     register    WINDOW * wp;
  274.  
  275.     bp = bfind (bname, TRUE);   /* Text buffer.         */
  276.     blistp = bcreate (MSG_null);      /* Special list buffer. */
  277.     wp = (WINDOW *) malloc (sizeof (WINDOW));/* Initial window.      */
  278.     if (bp == NULL || wp == NULL || blistp == NULL)
  279.         abort ();
  280.     curbp = bp;                 /* Current ones.        */
  281.     wheadp = wp;
  282.     curwp = wp;
  283.     wp -> w_wndp = NULL;        /* Initialize window.   */
  284.     wp -> w_bufp = bp;
  285.     bp -> b_nwnd = 1;           /* Displayed.           */
  286.     wp -> w_fmt_ptr = &hex_8_fmt;/* HEX 8 bit display       pvr  */
  287.     wp -> w_linep = bp -> b_linep;
  288.     wp -> w_dotp = bp -> b_linep;
  289.     wp -> w_doto = 0;           /* set dot pos  pvr */
  290.     wp -> w_markp = NULL;
  291.     wp -> w_marko = 0;
  292.     wp -> w_toprow = 0;
  293.     wp -> w_ntrows = nrow - 2;  /* 2 = mode, echo.      */
  294.     wp -> w_flag = WFMODE | WFHARD;/* Full.                */
  295.     wp -> w_intel_mode = FALSE; /* default is no byte swap     pvr  */
  296.     wp -> w_disp_shift = 0;     /* default to no byte shift    pvr  */
  297.     wp -> w_loff = 0;           /* starting line offset        pvr  */
  298.     wp -> w_unit_offset = 0;    /* dot offset from file start  pvr  */
  299. }
  300.  
  301. /*
  302. * Flush all the dirty buffers that have file names
  303. * associated with them.
  304. */
  305. void flush_all ()
  306. {
  307.     register    BUFFER * bp,
  308.                *savbp = curbp;
  309.  
  310.     for (bp = bheadp; bp != NULL; bp = bp -> b_bufp)
  311.         if (bp -> b_fname != NULL)
  312.             {
  313.             curbp = bp;         /* jam */
  314.             filesave ();
  315.             update ();
  316.             }
  317.     flush_count = 0;
  318.     writ_echo (okmsg);
  319.     curbp = savbp;
  320.     if (blistp -> b_nwnd != 0)  /* update buffer display */
  321.         listbuffers ();
  322.     update ();
  323. }
  324.  
  325.  
  326. /* call flush_all to empty the buffers
  327. * and quit
  328. */
  329. void flushnquit (f, n, k)
  330. {
  331.     flush_all ();
  332.     quit (f, n, k);
  333. }
  334.  
  335.  
  336. /*
  337. * Quit command. If an argument, always
  338. * quit. Otherwise confirm if a buffer has been
  339. * changed and not written out. Normally bound
  340. * to "C-X C-C".
  341. */
  342. char    quit (f, n, k)
  343. {
  344.  
  345.     register char   s;
  346.  
  347.     if (f != FALSE              /* Argument forces it.  */
  348.             || anycb () == FALSE/* All buffers clean.   */
  349.             || (s = eyesno (MSG_quit)) == TRUE)/* User says it's OK.   */
  350.         {
  351.  
  352.         vttidy ();
  353.         exit (GOOD);
  354.         }
  355.  
  356.     return (s);
  357. }
  358.  
  359.  
  360. /*
  361. * Begin a keyboard macro.
  362. * Error if not at the top level
  363. * in keyboard processing. Set up
  364. * variables and return.
  365. */
  366. bool ctlxlp (f, n, k)
  367. {
  368.  
  369.     if (kbdmip != NULL || kbdmop != NULL)
  370.         {
  371.  
  372.         writ_echo (MSG_not_now);
  373.         return (FALSE);
  374.         }
  375.  
  376.     writ_echo (MSG_st_mac);
  377.     kbdmip = &kbdm[0];
  378.     return (TRUE);
  379. }
  380.  
  381.  
  382. /*
  383. * End keyboard macro. Check for
  384. * the same limit conditions as the
  385. * above routine. Set up the variables
  386. * and return to the caller.
  387. */
  388. bool ctlxrp (f, n, k)
  389. {
  390.  
  391.     if (kbdmip == NULL)
  392.         {
  393.  
  394.         writ_echo (MSG_not_now);
  395.         return (FALSE);
  396.         }
  397.  
  398.     writ_echo (MSG_end_mac);
  399.     kbdmip = NULL;
  400.     return (TRUE);
  401. }
  402.  
  403.  
  404. /*
  405. * Execute a macro.
  406. * The command argument is the
  407. * number of times to loop. Quit as
  408. * soon as a command gets an error.
  409. * Return TRUE if all ok, else
  410. * FALSE.
  411. */
  412. bool ctlxe (f, n, k)
  413. {
  414.  
  415.     register int    c;
  416.     register int    af;
  417.     register int    an;
  418.     register int    s;
  419.  
  420.     if (kbdmip != NULL || kbdmop != NULL)
  421.         {
  422.  
  423.         writ_echo (MSG_not_now);
  424.         return (FALSE);
  425.         }
  426.  
  427.     if (n <= 0)
  428.         return (TRUE);
  429.     do
  430.         {
  431.  
  432.         kbdmop = &kbdm[0];
  433.         do
  434.             {
  435.  
  436.             af = FALSE;
  437.             an = 1;
  438.             if ((c = *kbdmop++) == (KCTRL | 'U'))
  439.                 {
  440.  
  441.                 af = TRUE;
  442.                 an = *kbdmop++;
  443.                 c = *kbdmop++;
  444.                 }
  445.  
  446.             s = TRUE;
  447.             }
  448.         while (c != (KCTLX | ')') && (s = execute (c, af, an)) == TRUE);
  449.         kbdmop = NULL;
  450.         }
  451.     while (s == TRUE && --n);
  452.     return (s);
  453. }
  454.  
  455.  
  456. /*
  457. * Abort.
  458. * Beep the beeper.
  459. * Kill off any keyboard macro,
  460. * etc., that is in progress.
  461. * Sometimes called as a routine,
  462. * to do general aborting of
  463. * stuff.
  464. */
  465. char    ctrlg (f, n, k)
  466. {
  467. /*    ttbeep (); */
  468.     if (kbdmip != NULL)
  469.         {
  470.         kbdm[0] = (KCTLX | ')');
  471.         kbdmip = NULL;
  472.         }
  473.     return (ABORT);
  474. }
  475.  
  476.  
  477. /*
  478. * Display the version. All this does
  479. * is copy the text in the external "version" array into
  480. * the message system, and call the message reading code.
  481. * Don't call display if there is an argument.
  482. */
  483. char    showversion (f, n, k)
  484. {
  485. static  char    *cp;
  486. char    buf[80];
  487.  
  488.     cp = version;
  489.     sprintf (buf, cp);
  490.     writ_echo (buf);
  491.     return (TRUE);
  492. }
  493.  
  494.  
  495. /* ughly to_lower function for
  496. * files read in under MSDOS setargv function
  497. */
  498. void _lowercase (s)
  499. register char  *s;
  500. {
  501.  
  502. #ifdef MSDOS
  503.     for (; *s; s++)
  504.         if (ISUPPER (*s))
  505.             *s = TOLOWER (*s);
  506. #endif
  507. }
  508.  
  509.  
  510. /* autosave control
  511. */
  512. bool autosave ()
  513. {
  514.     register    WINDOW * wp;
  515.     register int    s,
  516.                     n;
  517.     char    buf[32];
  518.  
  519.     if ((s = ereply (MSG_num_mod, buf, sizeof (buf), NULL)) == TRUE)
  520.         {
  521.  
  522.         n = atoi (buf);
  523.         if (n >= 0)
  524.             auto_update = flush_num = n;/* not 0! */
  525.         else
  526.             auto_update = 0;
  527.         }
  528.  
  529.     for (wp = wheadp; wp; wp = wp -> w_wndp)
  530.         if (wp -> w_bufp == curbp)
  531.             wp -> w_flag |= WFMODE;
  532.     return (TRUE);
  533. }
  534.