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