home *** CD-ROM | disk | FTP | other *** search
/ Source Code 1992 March / Source_Code_CD-ROM_Walnut_Creek_March_1992.iso / usenet / altsrcs / 2 / 2880 / random.c
Encoding:
C/C++ Source or Header  |  1991-02-28  |  30.0 KB  |  1,164 lines
  1. /*
  2. *              Assorted commands.
  3. * The file contains the command
  4. * processors for a large assortment of unrelated
  5. * commands. The only thing they have in common is
  6. * that they are all command processors.
  7. */
  8.  
  9. #include    "def.h"
  10.  
  11. char    backdel ();
  12. bool    fill_out ();
  13. void    bad_key ();
  14.  
  15.  
  16.  
  17. extern    char    MSG_sh_pos[];
  18. extern    char    MSG_sh_pos1[];
  19. extern    char    MSG_f_str[];
  20. extern    char    MSG_3u[];
  21. extern    char    MSG_5u[];
  22. extern    char    MSG_lu[];
  23. extern    char    MSG_03u[];
  24. extern    char    MSG_05u[];
  25. extern    char    MSG_010lu[];
  26. extern    char    MSG_lnk[];
  27. extern    char    MSG_unlink[];
  28. extern    char    MSG_link[];
  29. extern    char    MSG_bad_key[];
  30. extern    char    MSG_esc[];
  31. extern    char    MSG_ctl_x[];
  32. extern    char    MSG_ctl[];
  33. extern    char    MSG_key_code[];
  34. extern    char    char_str[];
  35.  
  36. #if RUNCHK
  37. extern    char    ERR_rnd_1[];
  38. extern    char    ERR_rnd_2[];
  39. extern    char    ERR_rnd_3[];
  40. extern    char    ERR_rnd_4[];
  41. extern    char    MSG_rnd_5[];
  42. extern    char    ERR_rnd_6[];
  43. extern    char    ERR_rnd_7[];
  44. #endif
  45. #include    "lintfunc.dec"
  46.  
  47. extern  ROW_FMT ascii_fmt;
  48. extern  ROW_FMT ebcdic_fmt;
  49. extern  ROW_FMT binary_8_fmt;
  50. extern  ROW_FMT binary_16_fmt;
  51. extern  ROW_FMT binary_32_fmt;
  52. extern  ROW_FMT octal_8_fmt;
  53. extern  ROW_FMT octal_16_fmt;
  54. extern  ROW_FMT octal_32_fmt;
  55. extern  ROW_FMT decimal_8_fmt;
  56. extern  ROW_FMT decimal_16_fmt;
  57. extern  ROW_FMT decimal_32_fmt;
  58. extern  ROW_FMT hex_8_fmt;
  59. extern  ROW_FMT hex_16_fmt;
  60. extern  ROW_FMT hex_32_fmt;
  61.  
  62. extern  bool    read_pat_mode;
  63. extern  bool    dont_repeat;
  64.  
  65. char    dec_chr_ok ();
  66. ulong   get_long ();
  67.  
  68. /*
  69. * Display a bunch of useful information about
  70. * the current location of dot and mark.
  71. * The position of the dot and mark and the difference between them.
  72. * The total buffer size is displayed.
  73. * This is normally bound to "C-X =".
  74. */
  75. bool showcpos (f, n, k)
  76. {
  77.  
  78.     A32     dotoff,
  79.             markoff,
  80.             fsize,
  81.             bsize;
  82.     char    buf[80], buf1[80];
  83.  
  84.     dotoff = curwp -> w_dotp -> l_file_offset;
  85.     dotoff += curwp -> w_doto;
  86.  
  87.     if (curwp -> w_markp != NULL)
  88.         {
  89.         markoff = curwp -> w_markp -> l_file_offset;
  90.         markoff += curwp -> w_marko;
  91.         }
  92.  
  93.     bsize = curwp -> w_bufp -> b_linep -> l_bp -> l_file_offset;
  94.     bsize += curwp -> w_bufp -> b_linep -> l_bp -> l_used;
  95.     fsize = curbp -> b_file_size;
  96.  
  97.     if (curwp -> w_markp != NULL)
  98.         {
  99.         /* build format string */
  100.         sprintf (buf1, MSG_sh_pos, R_POS_FMT(curwp), R_POS_FMT(curwp), 
  101.                                 R_POS_FMT(curwp), R_POS_FMT(curwp)); 
  102.         sprintf (buf, buf1, dotoff, markoff, bsize, fsize);
  103.         }
  104.     else
  105.         {
  106.         /* build format string */
  107.         sprintf (buf1, MSG_sh_pos1, R_POS_FMT(curwp), R_POS_FMT(curwp), 
  108.                                 R_POS_FMT(curwp)); 
  109.         sprintf (buf, buf1, dotoff, bsize, fsize);
  110.         }
  111.  
  112.     sprintf (&buf[strlen(buf)], MSG_f_str, curbp -> b_fname);
  113.     writ_echo (buf);
  114.  
  115.     return (TRUE);
  116. }
  117.  
  118.  
  119. /*
  120. * Twiddle the two characters on either side of
  121. * dot. If dot is at the end of the line twiddle the
  122. * two characters before it. Return with an error if dot
  123. * is at the beginning of line; it seems to be a bit
  124. * pointless to make this work. This fixes up a very
  125. * common typo with a single stroke. Normally bound
  126. * to "C-T". This always works within a line, so
  127. * "WFEDIT" is good enough.
  128. */
  129. bool twiddle ()
  130. {
  131.  
  132.     register    LINE * dotp;
  133.     register short  doto;
  134.     register int    cl;
  135.     register int    cr;
  136.     char    b_per_u,
  137.             f_buf[4],
  138.             s_buf[4],
  139.             i;
  140.  
  141.     dotp = curwp -> w_dotp;
  142.     doto = curwp -> w_doto;
  143.     b_per_u = curwp -> w_fmt_ptr -> r_b_per_u;
  144.  /* try to move back one unit */
  145.     if (!move_ptr (curwp, (long) - b_per_u, TRUE, TRUE, TRUE))
  146.         {
  147.         curwp -> w_dotp = dotp; /* if fail then restore dot and quit */
  148.         curwp -> w_doto = doto;
  149.         ttbeep ();
  150.         return (FALSE);
  151.         }
  152.  /* pick up first unit byte by byte */
  153.     for (i = 0; i < b_per_u; i++)
  154.         {
  155.         f_buf[i] = DOT_CHAR(curwp);
  156.         move_ptr (curwp, 1L, TRUE, FALSE, TRUE);
  157.         }
  158.  /* move to the end of the second unit */
  159.     if (!move_ptr (curwp, (long) (b_per_u - 1), TRUE, FALSE, TRUE))
  160.         {
  161.         curwp -> w_dotp = dotp; /* if fail then restore dot and quit */
  162.         curwp -> w_doto = doto;
  163.         ttbeep ();
  164.         return (FALSE);
  165.         }
  166.  /* pick up second unit (reverse order) and deposit second unit */
  167.     for (i = 0; i < b_per_u; i++)
  168.         {
  169.         s_buf[i] = DOT_CHAR(curwp);
  170.         DOT_CHAR(curwp) = f_buf[b_per_u - 1 - i];
  171.         move_ptr (curwp, -1L, TRUE, FALSE, TRUE);
  172.         }
  173.  /* deposit first unit */
  174.     for (i = 0; i < b_per_u; i++)
  175.         {
  176.         DOT_CHAR(curwp) = s_buf[i];
  177.         move_ptr (curwp, -1L, TRUE, FALSE, TRUE);
  178.         }
  179.     curwp -> w_dotp = dotp;
  180.     curwp -> w_doto = doto;
  181.     lchange (WFHARD);
  182.     return (TRUE);
  183. }
  184.  
  185. /*
  186. * Quote the next character, and
  187. * insert it into the buffer. All the characters
  188. * are taken literally.
  189. * The character
  190. * is always read, even if it is inserted 0 times, for
  191. * regularity.
  192. */
  193. bool quote (f, n, k)
  194. {
  195.  
  196.     register int    s;
  197.     register int    c;
  198.  
  199.     if (kbdmop != NULL)
  200.         c = *kbdmop++;
  201.     else
  202.         {
  203.         c = ttgetc ();
  204.         if (kbdmip != NULL)
  205.             {
  206.             if (kbdmip > &kbdm[NKBDM - 4])
  207.                 {
  208.                 ctrlg (FALSE, 0, KRANDOM);
  209.                 return (ABORT);
  210.                 }
  211.  
  212.             *kbdmip++ = c;
  213.             }
  214.  
  215.         }
  216.  
  217.     if (n < 0)
  218.         return (FALSE);
  219.     if (n == 0)
  220.         return (TRUE);
  221.  
  222.     return (linsert (n, c));
  223. }
  224.  
  225. /*
  226. * Toggle the insert mode.  Insert mode is used only in ASCII or EBCDIC modes.
  227. */
  228. bool insert_toggle ()    /* toggle routine for selfinsert */
  229. {
  230.     register    WINDOW * wp;
  231.  
  232.     if (curbp -> b_flag & BFSLOCK)
  233.         return (TRUE);
  234.     
  235.     if (read_pat_mode)
  236.         dont_repeat = TRUE;
  237.  
  238.     insert_mode = !insert_mode;
  239.     for (wp = wheadp; wp; wp = wp -> w_wndp)
  240.         wp -> w_flag |= WFMODE; /* force mode line update */
  241.     return (TRUE);
  242. }
  243.  
  244. /*
  245. * Ordinary text characters are bound to this function,
  246. * which inserts them into the buffer. Characters marked as control
  247. * characters (using the CTRL flag) may be remapped to their ASCII
  248. * equivalent. This makes TAB (C-I) work right, and also makes the
  249. * world look reasonable if a control character is bound to this
  250. * this routine by hand. Any META or CTLX flags on the character
  251. * are discarded. 
  252. * 
  253. *   Edit the unit under the cursor.
  254. *   Check that the character is valid for the current display mode.
  255. */
  256.  
  257. bool selfinsert (f, n, k)
  258. {
  259.  
  260.     register int    c;
  261.     register int    s;
  262.     char    edt_buf[4],
  263.             i_chr,
  264.             b_per_u,
  265.             u_offs,
  266.             u_roffs,
  267.             bit_shf,
  268.             bit_mask,
  269.             i;
  270.     LINE    * l_ptr;
  271.     short   d_offs;
  272.     int     bytes,
  273.             temp_int;
  274.     long    dot_shf,
  275.             l_mask,
  276.             l_val;
  277.     char    text_buf[12];
  278.     static char max_dec_8[] = "255";
  279.     static char max_dec_16[] = "65535";
  280.     static char max_dec_32[] = "4294967295";
  281.     int        cur_col;
  282.  
  283.     bool intel;
  284.  
  285.     if (n < 0)
  286.         {
  287.         ttbeep ();
  288.         return (FALSE);
  289.         }
  290.     if (n == 0)
  291.         {
  292.         ttbeep ();
  293.         return (TRUE);
  294.         }
  295.     c = k & KCHAR;
  296.     if ((k & KCTRL) != 0 && c >= '@' && c <= '_')/* ASCII-ify.           */
  297.         c -= '@';
  298.     b_per_u = curwp -> w_fmt_ptr -> r_b_per_u;
  299.     u_offs = curwp -> w_unit_offset;
  300.     u_roffs = curwp -> w_fmt_ptr -> r_chr_per_u - u_offs - 1;
  301.     intel = curwp -> w_intel_mode;
  302.  
  303.     cur_col = ttcol;
  304.  
  305.     switch (curwp -> w_fmt_ptr -> r_type)
  306.         {
  307.         case EBCDIC: 
  308.             c = to_ebcdic (c);  /* convert ASCII to EBCDIC */
  309.         case ASCII: 
  310.             if ((insert_mode) || (DOT_POS(curwp) == BUF_SIZE(curwp)))
  311.                 {
  312.                 s = linsert (n, c);
  313.                 if (read_pat_mode)
  314.                     forwchar (0, 1, KRANDOM);/* advance the cursor */
  315.                 }
  316.             else
  317.                 s = lreplace (n, c);
  318.             break;
  319.  
  320.         case HEX: 
  321.             if ((c >= '0') && (c <= '9'))
  322.                 {
  323.                 i_chr = c - '0';/* convert to binary */
  324.                 }
  325.             else
  326.                 if ((c >= 'A') && (c <= 'F'))
  327.                     {
  328.                     i_chr = c - 'A' + 10;/* convert to binary */
  329.                     }
  330.                 else
  331.                     if ((c >= 'a') && (c <= 'f'))
  332.                         {
  333.                         i_chr = c - 'a' + 10;/* convert to binary */
  334.                         }
  335.                     else
  336.                         {
  337.                         bad_key (k);
  338.                         return (FALSE);
  339.                         }
  340.             fill_out (); /* expand buffer if necessary */
  341.  
  342.         /* position dot to byte to be altered */
  343.             if (intel)
  344.                 dot_shf = u_roffs >> 1;
  345.             else
  346.                 dot_shf = u_offs >> 1;
  347.  
  348.             /* save dot position for later */
  349.             l_ptr = curwp -> w_dotp;
  350.             d_offs = curwp -> w_doto;
  351.             move_ptr (curwp, dot_shf, TRUE, FALSE, TRUE);
  352.  
  353.             if (u_offs & 1)
  354.                 {               /* lower nibble in byte */
  355.                 i_chr &= 0x0f;
  356.                 DOT_CHAR(curwp) &= 0xf0;
  357.                 DOT_CHAR(curwp) |= i_chr;
  358.                 }
  359.             else
  360.                 {               /* upper nibble in byte */
  361.                 i_chr <<= 4;
  362.                 i_chr &= 0xf0;
  363.                 DOT_CHAR(curwp) &= 0x0f;
  364.                 DOT_CHAR(curwp) |= i_chr;
  365.                 }
  366.  
  367.         /* restore dot position */
  368.             curwp -> w_dotp = l_ptr;
  369.             curwp -> w_doto = d_offs;
  370.             forwchar (0, 1, KRANDOM);/* advance the cursor */
  371.             break;
  372.  
  373.         case BINARY: 
  374.             if ((c != '0') && (c != '1'))
  375.                 {
  376.                 bad_key (k);
  377.                 return (FALSE);
  378.                 }
  379.  
  380.         /* position dot to byte to be altered */
  381.             if (intel)
  382.                 dot_shf = u_roffs >> 3;
  383.             else
  384.                 dot_shf = u_offs >> 3;
  385.  
  386.             fill_out (); /* expand buffer if necessary */
  387.  
  388.             /* save dot position for later */
  389.             l_ptr = curwp -> w_dotp;
  390.             d_offs = curwp -> w_doto;
  391.             move_ptr (curwp, dot_shf, TRUE, FALSE, TRUE);
  392.  
  393.             bit_shf = u_roffs & 0x07;
  394.  
  395.             if (c == '0')
  396.                 {
  397.                 DOT_CHAR(curwp) &= ~(1 << bit_shf);
  398.                 }
  399.             else
  400.                 {
  401.                 DOT_CHAR(curwp) |= 1 << bit_shf;
  402.                 }
  403.  
  404.         /* restore dot position */
  405.             curwp -> w_dotp = l_ptr;
  406.             curwp -> w_doto = d_offs;
  407.             forwchar (0, 1, KRANDOM);/* advance the cursor */
  408.             break;
  409.  
  410.         case OCTAL: 
  411.             if (c < '0')
  412.                 {
  413.                 bad_key (k);
  414.                 return (FALSE);
  415.                 }
  416.             else
  417.                 if ((c > '1') && (u_offs == 0) &&
  418.                         ((curwp -> w_fmt_ptr -> r_size) == WORDS))
  419.                     {
  420.                     bad_key (k);
  421.                     return (FALSE);
  422.                     }
  423.                 else
  424.                     if ((c > '3') && (u_offs == 0))
  425.                         {
  426.                         bad_key (k);
  427.                         return (FALSE);
  428.                         }
  429.                     else
  430.                         if (c > '7')
  431.                             {
  432.                             bad_key (k);
  433.                             return (FALSE);
  434.                             }
  435.  
  436.             dot_shf = (c - '0') & 7;/* get binary value */
  437.             l_mask = 7;         /* create bit mask */
  438.  
  439.             dot_shf <<= (u_roffs * 3);
  440.             l_mask <<= (u_roffs * 3);
  441.  
  442.             fill_out (); /* expand buffer if necessary */
  443.  
  444.             /* save dot position for later */
  445.             l_ptr = curwp -> w_dotp;
  446.             d_offs = curwp -> w_doto;
  447.  
  448.         /* position dot to the byte to be altered */
  449.             if (intel)
  450.                 {
  451.                 for (i = 0; i < b_per_u; i++)
  452.                     {
  453.                     DOT_CHAR(curwp) &= ~((D8) l_mask & 0xff);
  454.                     DOT_CHAR(curwp) |= (D8) dot_shf & 0xff;
  455.                     l_mask >>= 8;
  456.                     dot_shf >>= 8;
  457.                     move_ptr (curwp, 1L, TRUE, FALSE, TRUE);
  458.                     }
  459.                 }
  460.             else
  461.                 {
  462.                 move_ptr (curwp, (long) (b_per_u - 1), TRUE, FALSE, TRUE);
  463.                                 /* move to last byte */
  464.                 for (i = 0; i < b_per_u; i++)
  465.                     {
  466.                     DOT_CHAR(curwp) &= ~((D8) l_mask & 0xff);
  467.                     DOT_CHAR(curwp) |= (D8) dot_shf & 0xff;
  468.                     l_mask >>= 8;
  469.                     dot_shf >>= 8;
  470.                     move_ptr (curwp, -1L, TRUE, FALSE, TRUE);/* step back one byte */
  471.                     }
  472.                 }
  473.  
  474.         /* restore dot position */
  475.             curwp -> w_dotp = l_ptr;
  476.             curwp -> w_doto = d_offs;
  477.             forwchar (0, 1, KRANDOM);/* advance the cursor */
  478.             break;
  479.  
  480.         case DECIMAL: 
  481.             fill_out (); /* expand buffer if necessary */
  482.  
  483.             /* save dot position for later */
  484.             l_ptr = curwp -> w_dotp;
  485.             d_offs = curwp -> w_doto;
  486.  
  487.             bytes = fill_buf (curwp, l_ptr, d_offs, edt_buf, b_per_u);
  488.         /* if last unit is not full and must be extended */
  489.             for (; bytes < b_per_u; bytes++)
  490.                 {
  491.                 edt_buf[3] = edt_buf[2];/* shuffle bytes down */
  492.                 edt_buf[2] = edt_buf[1];
  493.                 edt_buf[1] = edt_buf[0];
  494.                 edt_buf[0] = 0;
  495.                 }
  496.             switch (curwp -> w_fmt_ptr -> r_size)
  497.                 {
  498.                 case BYTES: 
  499.                     sprintf (text_buf, MSG_03u, (int) (edt_buf[0] & 0xff));
  500.                     if (!dec_chr_ok (text_buf, max_dec_8, c, u_offs))
  501.                         {
  502.                         bad_key (k);
  503.                         return (TRUE);  /* TRUE so that mask will be same len */
  504.                         }
  505.                     sscanf (text_buf, MSG_3u, &i);/* convert back to binary */
  506.                     l_val = (long) i & 0xff;
  507.                     break;
  508.  
  509.                 case WORDS: 
  510.                     l_val = get_int (edt_buf);/* do intel swap */
  511.                     sprintf (text_buf, MSG_05u, (int) (l_val & 0xFFFF));
  512.                     if (!dec_chr_ok (text_buf, max_dec_16, c, u_offs))
  513.                         {
  514.                         bad_key (k);
  515.                         return (TRUE);  /* TRUE so that mask will be same len */
  516.                         }
  517.                     sscanf (text_buf, MSG_5u, &temp_int);
  518.                                 /* convert back to binary */
  519.                     l_val = get_int ((char *) & temp_int);/* do intel swap */
  520.                     break;
  521.  
  522.                 case DWORDS: 
  523.                     l_val = get_long (edt_buf);/* do intel swap */
  524.                     sprintf (text_buf, MSG_010lu, l_val);
  525.                     if (!dec_chr_ok (text_buf, max_dec_32, c, u_offs))
  526.                         {
  527.                         bad_key (k);
  528.                         return (TRUE);  /* TRUE so that mask will be same len */
  529.                         }
  530.                     sscanf (text_buf, MSG_lu, &l_val);
  531.                                 /* convert back to binary */
  532.                     l_val = get_long ((char *) & l_val);/* do intel swap */
  533.                     break;
  534. #if RUNCHK
  535.                 default:
  536.                     writ_echo (ERR_rnd_2);
  537.                     break;
  538. #endif
  539.                 }
  540.             DOT_CHAR(curwp) = (char) l_val & 0xff;
  541.             for (i = 1; i < b_per_u; i++)
  542.                 {
  543.                 l_val >>= 8;
  544.                 move_ptr (curwp, 1L, TRUE, FALSE, TRUE);/* step forward one byte */
  545.                 DOT_CHAR(curwp) = (char) l_val & 0xff;
  546.                 }
  547.  
  548.         /* restore dot position */
  549.             curwp -> w_dotp = l_ptr;
  550.             curwp -> w_doto = d_offs;
  551.             forwchar (0, 1, KRANDOM);/* advance the cursor */
  552.             break;
  553.  
  554. #if RUNCHK
  555.         default:
  556.             writ_echo (ERR_rnd_3);
  557.             break;
  558. #endif
  559.         }
  560.     /* if cursor has wrapped to the next line then previous line
  561.         will not be refreshed with WFEDIT so do a WFHARD */
  562.     if (cur_col > get_curcol(curwp))
  563.         lchange (WFHARD);
  564.     else
  565.         lchange (WFEDIT);
  566.  
  567.     return (TRUE);
  568. }
  569.  
  570. /*
  571. *   Insert one unit of zeros at the current dot position.
  572. */
  573. bool    insertunit (f, n, k)
  574. {
  575.     lchange (WFEDIT);
  576.     linsert ((R_B_PER_U(curwp) * n), 0);
  577.     return (TRUE);
  578. }
  579.  
  580. /* 
  581. *   Increase the size of the buffer if necessary.
  582. *   If dot is at the byte after the last full unit
  583. *   then add enough bytes to the buffer to create 
  584. *   a full unit at the end.
  585. */  
  586.  
  587. bool    fill_out ()
  588. {
  589.     long    buf_size, dot_pos, l_val, last_unit;   
  590.     int     b_per_u;    
  591.     char    stat, shift;   
  592.     int     insert_val;
  593.  
  594.     buf_size = BUF_SIZE(curwp);
  595.     dot_pos = DOT_POS(curwp);
  596.     b_per_u = R_B_PER_U(curwp);
  597.     shift = curwp -> w_disp_shift;       
  598.     stat = TRUE;    
  599.     insert_val = 0;
  600.     last_unit = buf_size & ~((long)(b_per_u - 1));
  601.     /* there is an even number of units step back one */
  602.     if (last_unit == buf_size)
  603.         last_unit -= b_per_u;
  604.     last_unit += shift;
  605.  
  606.     /* if dot is one byte past the end of the buffer */
  607.     if (dot_pos > last_unit)
  608.         {
  609.         insert_val = b_per_u;
  610.         }
  611.  
  612.     /* if dot is pointed at the end of the buffer */
  613.     else if (dot_pos == last_unit)
  614.         {
  615.         insert_val = b_per_u - (buf_size - last_unit);
  616.         }
  617.  
  618.     /* if insert is necessary then do it */
  619.     if (insert_val != 0)
  620.         {
  621.         lchange (WFHARD);
  622.         move_ptr (curwp, buf_size, TRUE, FALSE, FALSE); /* move dot to end */
  623.         stat = linsert (insert_val, 0);
  624.         move_ptr (curwp, dot_pos, TRUE, TRUE, FALSE); /* put dot back */
  625.         }
  626.     return (stat);
  627. }
  628.  
  629. /*
  630. *   This checks that an entered character is ok
  631. *   for the position given.
  632. */
  633.  
  634. char    dec_chr_ok (char_buf, max_str, chr, pos)
  635.  
  636. char    chr,
  637.         pos,
  638.        *char_buf,
  639.        *max_str;
  640.  
  641. {
  642.     char    i;
  643.  
  644.     if ((chr < '0') || (chr > '9'))
  645.         return (FALSE);
  646.  
  647.     char_buf[pos] = chr;        /* insert typed char */
  648.  
  649.  /* check if number is too big */
  650.     for (i = 0; max_str[i] != 0; i++)
  651.         {
  652.         if (char_buf[i] < max_str[i])
  653.             break;              /* if char is smaller then must be ok */
  654.  
  655.         if (char_buf[i] > max_str[i])
  656.             return (FALSE);     /* val is too large; ERROR */
  657.         }
  658.     return (TRUE);
  659. }
  660.  
  661. /*
  662. * Set the rest of the variables for the mode change.
  663. */
  664. void    set_mode_vars ()
  665. {
  666.     curwp -> w_disp_shift = 0;  /* shift to 0 when changing mode */
  667.     curwp -> w_unit_offset = 0; /* go to end of unit */
  668.     /* if we are in the middle of a search then use the proper format struc */
  669.     if (read_pat_mode)
  670.         curwp -> w_fmt_ptr = curwp -> w_fmt_ptr -> r_srch_fmt;
  671.         
  672.     wind_on_dot (curwp);
  673.     curwp -> w_flag = WFHARD;
  674.     update ();
  675. }
  676.  
  677. /*
  678. * Change the display mode to ASCII.
  679. * The default binding is META C-A.
  680. */
  681. bool    asciimode ()
  682. {
  683.     curwp -> w_fmt_ptr = &ascii_fmt;
  684.     set_mode_vars ();
  685.     return (TRUE);
  686. }
  687.  
  688. /*
  689. * Change the display mode to EBCDIC.
  690. * The default binding is META C-E.
  691. */
  692. bool    ebcdicmode ()
  693. {
  694.     curwp -> w_fmt_ptr = &ebcdic_fmt;
  695.     set_mode_vars ();
  696.     return (TRUE);
  697. }
  698.  
  699. /*
  700. * Change the display mode to DECIMAL.
  701. * The default binding is META C-D.
  702. */
  703. bool    decimalmode ()
  704. {
  705.     switch (curwp -> w_fmt_ptr -> r_size)
  706.         {
  707.         case BYTES: 
  708.             curwp -> w_fmt_ptr = &decimal_8_fmt;
  709.             break;
  710.         case WORDS: 
  711.             curwp -> w_fmt_ptr = &decimal_16_fmt;
  712.             break;
  713.  
  714.         case DWORDS: 
  715.             curwp -> w_fmt_ptr = &decimal_32_fmt;
  716.             break;
  717. #if RUNCHK
  718.         default:
  719.             writ_echo (ERR_rnd_4);
  720.             break;
  721. #endif
  722.         }
  723.     set_mode_vars ();
  724.     return (TRUE);
  725. }
  726.  
  727. /*
  728. * Change the display mode to HEXADECIMAL.
  729. * The default binding is META C-H.
  730. */
  731. bool    hexmode ()
  732. {
  733.     switch (curwp -> w_fmt_ptr -> r_size)
  734.         {
  735.         case BYTES: 
  736.             curwp -> w_fmt_ptr = &hex_8_fmt;
  737.             break;
  738.         case WORDS: 
  739.             curwp -> w_fmt_ptr = &hex_16_fmt;
  740.             break;
  741.         case DWORDS: 
  742.             curwp -> w_fmt_ptr = &hex_32_fmt;
  743.             break;
  744. #if RUNCHK
  745.         default:
  746.             writ_echo (MSG_rnd_5);
  747.             break;
  748. #endif
  749.         }
  750.     set_mode_vars ();
  751.     return (TRUE);
  752. }
  753.  
  754. /*
  755. * Change the display mode to OCTAL.
  756. * The default binding is META C-O.
  757. */
  758. bool    octalmode ()
  759. {
  760.     switch (curwp -> w_fmt_ptr -> r_size)
  761.         {
  762.         case BYTES: 
  763.             curwp -> w_fmt_ptr = &octal_8_fmt;
  764.             break;
  765.  
  766.         case WORDS: 
  767.             curwp -> w_fmt_ptr = &octal_16_fmt;
  768.             break;
  769.  
  770.         case DWORDS: 
  771.             curwp -> w_fmt_ptr = &octal_32_fmt;
  772.             break;
  773. #if RUNCHK
  774.         default:
  775.             writ_echo (ERR_rnd_6);
  776.             break;
  777. #endif
  778.         }
  779.     set_mode_vars ();
  780.     return (TRUE);
  781. }
  782.  
  783. /*
  784. * Change the display mode to BINARY.
  785. * The default binding is META C-B.
  786. */
  787. bool    binarymode ()
  788. {
  789.     switch (curwp -> w_fmt_ptr -> r_size)
  790.         {
  791.         case BYTES: 
  792.             curwp -> w_fmt_ptr = &binary_8_fmt;
  793.             break;
  794.         case WORDS: 
  795.             curwp -> w_fmt_ptr = &binary_16_fmt;
  796.             break;
  797.         case DWORDS: 
  798.             curwp -> w_fmt_ptr = &binary_32_fmt;
  799.             break;
  800. #if RUNCHK
  801.         default:
  802.             writ_echo (ERR_rnd_7);
  803.             break;
  804. #endif
  805.         }
  806.     set_mode_vars ();
  807.     return (TRUE);
  808. }
  809.  
  810. /*
  811. * Change the display shift.
  812. * Circularly rotate through display shift of 0 through 3.
  813. * This value is used to shift the display by the designated number of bytes.
  814. * This is used to cause WORD and DWORD values to be calculated
  815. * from the correct offset.
  816. */
  817. bool dispshift (f, n, k)
  818. {
  819.     char    mode,
  820.             size;
  821.  
  822.     if (read_pat_mode)
  823.         return (TRUE);  /* no shift is allowed in search mode */    
  824.  
  825.     mode = curwp -> w_fmt_ptr -> r_type;
  826.     size = curwp -> w_fmt_ptr -> r_size;
  827.  
  828.     if (((mode == HEX) ||
  829.                 (mode == DECIMAL) ||
  830.                 (mode == BINARY) ||
  831.                 (mode == OCTAL)) &&
  832.             (size != BYTES))
  833.         {
  834.         if ((size == WORDS) &&
  835.                 (curwp -> w_disp_shift >= 1))
  836.             {                   /* roll over on words */
  837.             curwp -> w_disp_shift = 0;
  838.             }
  839.         else
  840.             if ((size == DWORDS) &&
  841.                     (curwp -> w_disp_shift >= 3))
  842.                 {               /* roll over on double words */
  843.                 curwp -> w_disp_shift = 0;
  844.                 }
  845.             else
  846.                 {
  847.                 curwp -> w_disp_shift++;/* increment shift */
  848.                 }
  849.         }
  850.     else
  851.         {
  852.         curwp -> w_disp_shift = 0;/* set to no shift */
  853.         }
  854.     move_ptr (curwp, 0L, TRUE, TRUE, TRUE);
  855.     wind_on_dot (curwp);
  856.     curwp -> w_flag = WFHARD;   /* force full window refresh */
  857.     return (TRUE);
  858. }
  859.  
  860. /*
  861. * Delete forward. This is real
  862. * easy, because the basic delete routine does
  863. * all of the work. Watches for negative arguments,
  864. * and does the right thing. If any argument is
  865. * present, it kills rather than deletes, to prevent
  866. * loss of text if typed with a big argument.
  867. * Normally bound to "C-D".
  868. */
  869. char    forwdel (f, n, k)
  870. {
  871.     char    s;
  872.  
  873.     if (n < 0)
  874.         return (backdel (f, -n, KRANDOM));
  875.     
  876.     s = FALSE;
  877.     if (R_SIZE(curwp) == BYTES)
  878.         {
  879.         if (f != FALSE)
  880.             {
  881.         /* Really a kill.       */
  882.             if ((lastflag & CFKILL) == 0)
  883.                 kdelete ();
  884.             thisflag |= CFKILL;
  885.             }
  886.         s = ldelete (n, f);
  887.         curwp -> w_unit_offset = 0;
  888.         }
  889.     return (s);
  890. }
  891.  
  892.  
  893. /*
  894. * Delete backwards. This is quite easy too,
  895. * because it's all done with other functions. Just
  896. * move the cursor back, and delete forwards.
  897. * Like delete forward, this actually does a kill
  898. * if presented with an argument.
  899. */
  900. char    backdel (f, n, k)
  901. {
  902.  
  903.     int     u_off;
  904.     char    s;
  905.  
  906.     if (n < 0)
  907.         return (forwdel (f, -n, KRANDOM));
  908.  
  909.     s = FALSE;
  910.     if (R_SIZE(curwp) == BYTES)
  911.         {
  912.         u_off = curwp -> w_unit_offset;
  913.         curwp -> w_unit_offset = 0;
  914.         if ((s = backchar (f, n * R_CHR_PER_U(curwp), KRANDOM)) == TRUE)
  915.             {
  916.             s = ldelete (n, f);
  917.             if (f != FALSE)
  918.                 {
  919.                 /* Really a kill.       */
  920.                 if ((lastflag & CFKILL) == 0)
  921.                     kdelete ();
  922.                 thisflag |= CFKILL;
  923.                 }
  924.             }
  925.         curwp -> w_unit_offset = u_off;
  926.         }
  927.     return (s);
  928. }
  929.  
  930.  
  931. /*
  932. * Change the size of the display unit to BYTE.
  933. * Adjust byte shift to the allowable range.
  934. * Normally bound to "META-1".
  935. */
  936. bool dispsize1 ()
  937. {
  938.     curwp -> w_disp_shift = 0;  /* shift to 0 when changing size */
  939.     curwp -> w_unit_offset = 0; /* go to end of unit */
  940.  
  941.     switch (R_TYPE(curwp))
  942.         {
  943.         case OCTAL: 
  944.             curwp -> w_fmt_ptr = &octal_8_fmt;
  945.             break;
  946.  
  947.         case DECIMAL: 
  948.             curwp -> w_fmt_ptr = &decimal_8_fmt;
  949.             break;
  950.  
  951.         case HEX: 
  952.             curwp -> w_fmt_ptr = &hex_8_fmt;
  953.             break;
  954.  
  955.         case BINARY: 
  956.             curwp -> w_fmt_ptr = &binary_8_fmt;
  957.             break;
  958.  
  959.         default:
  960.             return (TRUE);
  961.             break;
  962.         }
  963.  
  964.     /* if we are in the middle of a search then use the proper format struc */
  965.     if (read_pat_mode)
  966.         curwp -> w_fmt_ptr = curwp -> w_fmt_ptr -> r_srch_fmt;
  967.         
  968.     move_ptr (curwp, 0L, TRUE, TRUE, TRUE);
  969.     wind_on_dot (curwp);
  970.     curwp -> w_flag = WFHARD;
  971.     update ();
  972.     return (TRUE);
  973. }
  974.  
  975. /*
  976. * Change the size of the display unit to WORD.
  977. * Adjust byte shift to the allowable range.
  978. * Normally bound to "META-2".
  979. */
  980. bool dispsize2 ()
  981. {
  982.     curwp -> w_disp_shift = 0;  /* shift to 0 when changing size */
  983.     curwp -> w_unit_offset = 0; /* go to end of unit */
  984.  
  985.     switch (R_TYPE(curwp))
  986.         {
  987.         case OCTAL: 
  988.             curwp -> w_fmt_ptr = &octal_16_fmt;
  989.             break;
  990.  
  991.         case DECIMAL: 
  992.             curwp -> w_fmt_ptr = &decimal_16_fmt;
  993.             break;
  994.  
  995.         case HEX: 
  996.             curwp -> w_fmt_ptr = &hex_16_fmt;
  997.             break;
  998.  
  999.         case BINARY: 
  1000.             curwp -> w_fmt_ptr = &binary_16_fmt;
  1001.             break;
  1002.  
  1003.         default:
  1004.             return (TRUE);
  1005.             break;
  1006.         }
  1007.  
  1008.     /* if we are in the middle of a search then use the proper format struc */
  1009.     if (read_pat_mode)
  1010.         curwp -> w_fmt_ptr = curwp -> w_fmt_ptr -> r_srch_fmt;
  1011.         
  1012.     move_ptr (curwp, 0L, TRUE, TRUE, TRUE);
  1013.     wind_on_dot (curwp);
  1014.     curwp -> w_flag = WFHARD;
  1015.     update ();
  1016.     return (TRUE);
  1017. }
  1018.  
  1019. /*
  1020. * Change the size of the display unit to DOUBLE WORD.
  1021. * Adjust byte shift to the allowable range.
  1022. * Normally bound to "META-4".
  1023. */
  1024. bool dispsize4 ()
  1025. {
  1026.     curwp -> w_disp_shift = 0;  /* shift to 0 when changing size */
  1027.     curwp -> w_unit_offset = 0; /* go to end of unit */
  1028.  
  1029.     switch (R_TYPE(curwp))
  1030.         {
  1031.         case OCTAL: 
  1032.             curwp -> w_fmt_ptr = &octal_32_fmt;
  1033.             break;
  1034.  
  1035.         case DECIMAL: 
  1036.             curwp -> w_fmt_ptr = &decimal_32_fmt;
  1037.             break;
  1038.  
  1039.         case HEX: 
  1040.             curwp -> w_fmt_ptr = &hex_32_fmt;
  1041.             break;
  1042.  
  1043.         case BINARY: 
  1044.             curwp -> w_fmt_ptr = &binary_32_fmt;
  1045.             break;
  1046.  
  1047.         default:
  1048.             return (TRUE);
  1049.             break;
  1050.         }
  1051.  
  1052.     /* if we are in the middle of a search then use the proper format struc */
  1053.     if (read_pat_mode)
  1054.         curwp -> w_fmt_ptr = curwp -> w_fmt_ptr -> r_srch_fmt;
  1055.         
  1056.     move_ptr (curwp, 0L, TRUE, TRUE, TRUE);
  1057.     wind_on_dot (curwp);
  1058.     curwp -> w_flag = WFHARD;
  1059.     update ();
  1060.     return (TRUE);
  1061. }
  1062.  
  1063. /*
  1064. * Display byte swaped.   This command causes the bytes
  1065. * that are displayed in WORD and DWORD mode to be swaped
  1066. * in the way that the INTEL microprocessors do it.
  1067. */
  1068. bool dispswapbyte (f, n, k)
  1069. {
  1070.     if ((curwp -> w_fmt_ptr -> r_size) == BYTES)
  1071.         return (TRUE);
  1072.  
  1073.     if (curwp -> w_intel_mode)
  1074.         curwp -> w_intel_mode = FALSE;
  1075.     else
  1076.         curwp -> w_intel_mode = TRUE;
  1077.  
  1078.     curwp -> w_flag = WFHARD;
  1079.     update ();
  1080.     return (TRUE);
  1081. }
  1082.  
  1083. /*
  1084. * Yank text back from the kill buffer. This
  1085. * is really easy. All of the work is done by the
  1086. * standard insert routines. All you do is run the loop,
  1087. * and check for errors. 
  1088. * An attempt has been made to fix the cosmetic bug
  1089. * associated with a yank when dot is on the top line of
  1090. * the window (nothing moves, because all of the new
  1091. * text landed off screen).
  1092. */
  1093. bool yank (f, n, k)
  1094. {
  1095.     register int    c;
  1096.     register int    i;
  1097.     register    LINE * lp;
  1098.  
  1099.     if (n < 0)
  1100.         return (FALSE);
  1101.     while (n--)
  1102.         {
  1103.         i = 0;
  1104.         while ((c = kremove (i)) >= 0)
  1105.             {
  1106.             if (linsert (1, c) == FALSE)
  1107.                 return (FALSE);
  1108.             ++i;
  1109.             }
  1110.         }
  1111.     curwp -> w_flag |= WFHARD;
  1112.     return (TRUE);
  1113. }
  1114.  
  1115. /*
  1116. *   Link windows.   pvr
  1117. *   This function toggles the window linking function.
  1118. *   When linking is enabled all windows that look at 
  1119. *   the same buffer will be forced to have the same 
  1120. *   dot position.   Each window is then moved to be
  1121. *   positioned on the dot.   Thus when a user moves
  1122. *   arround a buffer all other views into that buffer 
  1123. *   will follow.
  1124. */
  1125.  
  1126. bool linkwind ()
  1127.  
  1128. {
  1129.     char    buf[80];
  1130.  
  1131.     if (curwp -> w_bufp -> b_flag & BFLINK)
  1132.         {
  1133.         curwp -> w_bufp -> b_flag &= ~(BFLINK & 0xff);
  1134.         sprintf (buf, MSG_lnk, curwp -> w_bufp -> b_bname, MSG_unlink);
  1135.         }
  1136.     else
  1137.         {
  1138.         curwp -> w_bufp -> b_flag |= BFLINK;
  1139.         sprintf (buf, MSG_lnk, curwp -> w_bufp -> b_bname, MSG_link);
  1140.         }
  1141.     writ_echo (buf);
  1142.     return (TRUE);
  1143. }
  1144. /*
  1145. *   Print all bad keys to the screen and beep 
  1146. */
  1147. void    bad_key (key)
  1148. int     key;
  1149.     {
  1150.     char    buf[80], buf1[40];
  1151.  
  1152.     ttbeep ();
  1153.     sprintf (buf, MSG_bad_key);
  1154.     if (key & KMETA)
  1155.         sprintf (&buf[strlen (buf)], MSG_esc);
  1156.     if (key & KCTLX)
  1157.         sprintf (&buf[strlen (buf)], MSG_ctl_x);
  1158.     if (key & KCTRL)
  1159.         sprintf (&buf[strlen (buf)], MSG_ctl);
  1160.     sprintf (buf1, MSG_key_code, char_str, R_BYTE_FMT(curwp));
  1161.     sprintf (&buf[strlen (buf)], buf1, (key & KCHAR), key);
  1162.     writ_echo (buf);
  1163.     }
  1164.