home *** CD-ROM | disk | FTP | other *** search
/ Amiga GigaPD 3 / Amiga_GigaPD_v3_3of3.iso / netbsd / contrib / ados / fv151.lzh / fv / main.c < prev    next >
Text File  |  1993-06-14  |  21KB  |  966 lines
  1. /* fv is a binary file editor written by Chris Hooper (cdh@mtu.edu)
  2.  *    on 6-2-91 is has gone through many revisions since then.
  3.  *    CHRISTOPHER D. HOOPER
  4.  */
  5. #include "main.h"
  6.  
  7. #define VERSION "@(#)fv  1.51  93/06/14  cdh"
  8.  
  9. WINDOW    *main_window;
  10. WINDOW    *status_window;
  11. char    out_string[1024];
  12. FILE    *view_file;
  13. char    *buffer;
  14. int    *ibuffer;
  15. int    found;
  16. int    buf_size;
  17. int    max_buf_size    = 0;
  18. int    addis         = 0;
  19. int    chdis         = 1;
  20. int    wdis         = 1;
  21. int    ronly        = 0;
  22. int    mode        = STRING;
  23. int    wdismode    = 0;
  24. int     dirty        = 0;
  25. int    looping         = 1;
  26. int    wpline         = 0;
  27. int    caddr         = 0;
  28. int    global_type    = 0;
  29. int    global_direction = 0;
  30. int    global_num    = 0;
  31. int    marks        = 0;
  32. int    searching    = 0;
  33. int     daddr        = -1;
  34. char    global_search[MAXLEN];
  35. int    global_special[MAXLEN];
  36. int    local_search[MAX_HEX];
  37. char    markchar[MARKS];
  38. int    markpos[MARKS];
  39. extern    int size;
  40. char    *version = VERSION;
  41. char     *filename;
  42. unsigned long last_viewed;
  43. long    cursor_address;
  44. int    alignment = 4;
  45. unsigned long fend;
  46.  
  47. unsigned long file_end();
  48.  
  49. extern unsigned long file_sz[];
  50.  
  51. int main(argc, argv)
  52. int argc;
  53. char *argv[];
  54. {
  55.     char    ch;
  56.     int    index, temp;
  57.     int    write_mode = 0;
  58.     int    anum=1;
  59.  
  60.     while (*version != ' ')
  61.         version++;
  62.  
  63.     if (argc < 2) {
  64.         fprintf(stderr, "No file specified.  ");
  65.         print_usage(argv[0]);
  66.     }
  67.  
  68.     while ((anum < argc) && (*argv[anum] == '-')) {
  69.         argv[anum]++;
  70.         while (*argv[anum] != '\0') {
  71.             if (*argv[anum] == 'r')
  72.             ronly = 1;
  73.             else if (*argv[anum] == 'w') {
  74.             if (!ronly)
  75.                 write_mode = 1;
  76.             } else if (*argv[anum] == 'v')
  77.             fprintf(stdout, "%s%s\n", argv[0], version);
  78.             else if (*argv[anum] == 'V')
  79.             for (index = 0; index < 6; index++)
  80.                 fprintf(stdout, "%c%c%c%c",
  81.                     (file_sz[index] >> 24 & 255) + 64,
  82.                     (file_sz[index] >> 16 & 255) + 64,
  83.                     (file_sz[index] >> 8 & 255) + 64,
  84.                     (file_sz[index] & 255) + 64);
  85.             argv[anum]++;
  86.         }
  87.         anum++;
  88.     }
  89.  
  90.     if (anum == argc)
  91.         exit(0);
  92.  
  93.     for (index = 0; index < 6; index++)
  94.             temp ^= file_sz[index];
  95.  
  96.         if (write_mode) {
  97.             view_file = fopen(argv[anum], "r+");
  98.             if (view_file == NULL)
  99.             view_file = fopen(argv[anum], "w");
  100.             if (view_file == NULL) {
  101.             fprintf(stderr, "Error: unable to open \"%s\" for writing.\n",
  102.                 argv[anum]);
  103.             ronly = 1;
  104.             } else
  105.             fclose(view_file);
  106.         }
  107.  
  108.         if ((!ronly) && ((view_file = fopen(argv[anum], "r+")) == NULL))
  109.             ronly = 1;
  110.  
  111.         if (ronly)
  112.             fprintf(stdout, "viewing");
  113.         else
  114.             fprintf(stdout, "editing");
  115.         fprintf(stdout, " file %s\n", argv[anum]);
  116.  
  117.         if (ronly)
  118.             if ((view_file = fopen(argv[anum], "r")) == NULL) {
  119.                 fprintf(stderr, "Error: \"%s\" could not be opened.\n",
  120.                     argv[anum]);
  121.                 print_usage(argv[0]);
  122.                 exit(1);
  123.             }
  124.  
  125.         signal(SIGINT, sigint);
  126.         signal(SIGQUIT, sigint);
  127.         signal(SIGWINCH, sigwinch);
  128.  
  129.         init();
  130.  
  131.     fend = file_end() & ((unsigned long) temp ^ 0xfef1c0cb);
  132.  
  133.     if (fend < HIGH_BUF_SIZE)
  134.         max_buf_size = fend;
  135.  
  136.     if (max_buf_size == 0)
  137.         max_buf_size = HIGH_BUF_SIZE;
  138.  
  139.     ibuffer = (int *) malloc(max_buf_size + MAXLEN);
  140.     buffer    = (char *) ibuffer;
  141.  
  142. /*
  143.     wpline    = (COLS - addis * 10) / (9 * wdis + chdis * 4);
  144.     buf_size = (LINES - 1) * wpline * 4;
  145.  
  146.     main_window = newwin(LINES - 1, COLS, 1, 0);
  147.     status_window = newwin(1, COLS, 0, 0);
  148.  
  149.     leaveok(main_window, TRUE);
  150.     leaveok(status_window, TRUE);
  151.  
  152.     edit_mode();
  153. */
  154.     filename = argv[anum];
  155.  
  156.     wmove(status_window, 0, 20);
  157.     (void) sprintf(out_string, "of %s\n", filename);
  158.     waddstr(status_window, out_string);
  159.     last_viewed = caddr;
  160.  
  161.     if (!ronly) {
  162.         if (show_addr(caddr, 0)) {
  163.             caddr = last_viewed;
  164.             (void) show_addr(caddr, 1);
  165.         }
  166.         looping = edit_file();
  167.     }
  168.  
  169.     while (looping) {
  170.         if (show_addr(caddr, 0)) {
  171.             caddr = last_viewed;
  172.             (void) show_addr(caddr, 1);
  173.         }
  174.         reread:
  175.         ch = wgetch(main_window);
  176.         switch (ch) {
  177.             case 'a':
  178.             case 'A':
  179.             addis = !addis;
  180.  
  181.             temp = wpline;
  182.             wpline = (COLS - addis * 10) / (9 * wdis + chdis * 4);
  183.             buf_size = (LINES - 1) * wpline * 4;
  184.  
  185.             wmove(main_window, 0, 0);
  186.             wclrtobot(main_window);
  187.             break;
  188.             case '':
  189.             case 'b':
  190.             last_viewed = caddr;
  191.             caddr -= (buf_size / 4) * 4;
  192.             if (caddr < 0)
  193.                 caddr = 0;
  194.             break;
  195.             case 'B':
  196.             temp = buf_size;
  197.             index = 0;
  198.             while (temp) {
  199.                 temp = temp>>1;
  200.                 index++;
  201.             }
  202.             buf_size = 2<<(index-2);
  203.             wmove(main_window, buf_size / (wpline * 4), buf_size % (wpline * 4));
  204.             wclrtobot(main_window);
  205.             break;
  206.             case 'c':
  207.             chdis = !chdis;
  208.             temp = wpline;
  209.             if (chdis == 0)
  210.                 wdis = 1;
  211.             wpline = (COLS - addis * 10) / (9 * wdis + chdis * 4);
  212.             buf_size = (LINES - 1) * wpline * 4;
  213.  
  214.             wmove(main_window, 0, 0);
  215.             wclrtobot(main_window);
  216.             break;
  217.             case '':
  218.             case 'd':
  219.             last_viewed = caddr;
  220.             caddr += (buf_size / 4) * 2;
  221.             break;
  222.             case 'e':
  223.             looping = edit_file();
  224.             edit_mode();
  225.             break;
  226.             case '':
  227.             case 'f':
  228.             last_viewed = caddr;
  229.             caddr += (buf_size / 4) * 4;
  230.             break;
  231.             case 'G':
  232.             temp = ((file_end() - buf_size) / 4) * 4;
  233.             if (caddr != temp) {
  234.                 last_viewed = caddr;
  235.                 caddr = temp;
  236.             } else
  237.                 goto reread;
  238.             break;
  239.             case 'J':
  240.             case 'g':
  241.             temp = (get_jump(caddr) / 4) * 4;
  242.             edit_mode();
  243.             if (caddr != temp) {
  244.                 last_viewed = caddr;
  245.                 caddr = temp;
  246.             } else
  247.                 goto reread;
  248.             break;
  249.             case 'h':
  250.             last_viewed = caddr;
  251.             caddr -= 4;
  252.             if (caddr < 0)
  253.                 caddr = 0;
  254.             break;
  255.             case 'H':
  256.             case '':
  257.             help_me2();
  258.             touchwin(main_window);
  259.             touchwin(status_window);
  260.             refresh();
  261.             break;
  262.             case 'j':
  263.             last_viewed = caddr;
  264.             caddr += wpline * 4;
  265.             break;
  266.             case 'k':
  267.             last_viewed = caddr;
  268.             caddr -= wpline * 4;
  269.             if (caddr < 0)
  270.                 caddr = 0;
  271.             break;
  272.             case ' ':
  273.             clear();
  274.             touchwin(main_window);
  275.             touchwin(status_window);
  276.             refresh();
  277.             break;
  278.             case 'l':
  279.             last_viewed = caddr;
  280.             caddr += 4;
  281.             break;
  282.             case 'm':
  283.             set_mark(caddr);
  284.             break;
  285.             case 'N':
  286.             global_direction = !global_direction;
  287.             case 'n':
  288.             last_viewed = caddr;
  289.             caddr = (generic_search(caddr, global_direction) / 4) * 4;
  290.             edit_mode();
  291.             break;
  292.             case 'r':
  293.             break;
  294.             case 't':
  295.             wdismode = (wdismode + 1) % WDISMAX;
  296.             break;
  297.             case '':
  298.             case 'u':
  299.             last_viewed = caddr;
  300.             caddr -= (buf_size / 4) * 2;
  301.             if (caddr < 0)
  302.                 caddr = 0;
  303.             if (last_viewed == 0)
  304.                 goto reread;
  305.             break;
  306.             case 'w':
  307.             wdis = !wdis;
  308.             if (wdis == 0)
  309.                 chdis = 1;
  310.             wpline = (COLS - addis * 10) / (9 * wdis + chdis * 4);
  311.             buf_size = (LINES - 1) * wpline * 4;
  312.  
  313.             wmove(main_window, 0, 0);
  314.             wclrtobot(main_window);
  315.             break;
  316.             case 3:  /* ^C */
  317.             case 'q':
  318.             case 'Q':
  319.             case '':
  320.             case 'x':
  321.             if (dirty)
  322.                 save_changes();
  323.             looping = 0;
  324.             break;
  325.             case ' ':
  326.             temp = caddr;
  327.             caddr = last_viewed;
  328.             last_viewed = temp;
  329.             break;
  330.             case '0':
  331.             if (caddr != 0) {
  332.                 last_viewed = caddr;
  333.                 caddr = 0;
  334.             } else
  335.                 goto reread;
  336.             break;
  337.             case '\'':
  338.             temp = get_mark(caddr);
  339.             if (caddr != temp) {
  340.                 last_viewed = caddr;
  341.                 caddr = temp;
  342.             } else
  343.                 goto reread;
  344.             break;
  345.             case '+':
  346.             case '=':
  347.             wpline++;
  348.             if (wpline > (COLS - addis * 10) / (9 * wdis + chdis * 4))
  349.                 wpline = (COLS - addis * 10) / (9 * wdis + chdis * 4);
  350.             buf_size = (LINES - 1) * wpline * 4;
  351.             break;
  352.             case '-':
  353.             case '_':
  354.             wpline--;
  355.             if (wpline < 1)
  356.                 wpline = 1;
  357.             buf_size = (LINES - 1) * wpline * 4;
  358.  
  359.             wmove(main_window, 0, 0);
  360.             wclrtobot(main_window);
  361.             break;
  362.             case '/':
  363.             case '?':
  364.             last_viewed = caddr;
  365.             if (mode == STRING)
  366.                 caddr = (find_str(caddr, ch == '?') / 4) * 4;
  367.             else
  368.                 caddr = (find_hex(caddr, ch == '?') / 4) * 4;
  369.             edit_mode();
  370.             break;
  371.             case '\t':
  372.             mode = !mode;
  373.             edit_mode();
  374.             break;
  375.             default:
  376.             goto reread;
  377.         }
  378.     }
  379.  
  380.     de_init();
  381.     exit(0);
  382. }
  383.  
  384. unsigned long file_sz[] = {
  385. 0x03081209,0x13140f10,0x080512e0,0x04d2e008,0x0f0f1005,0x12cac0c0};
  386.  
  387. /************************************************************************/
  388. /*                                    */
  389. /*               Editor state machine                */
  390. /*                                    */
  391. /************************************************************************/
  392.  
  393. /* Additions to normal
  394.     ()    Screen move (Top/Bottom)
  395.     <int>    repeat next cmd <int> times
  396.     <cr>    edit location
  397.     w    write buffer to disk
  398.  
  399.    Subtractions from normal
  400.     w    word display
  401.     c    character display
  402.     +-    add/sub columns
  403.     H    help
  404. */
  405. int edit_file()
  406. {
  407.     char ch = ' ';
  408.     int looptime = 1;
  409.     int rollover=1;
  410.     int wref=0, rfile=0, cref = 0;
  411.     int temp;
  412.     int temp2;
  413.     int temp3;
  414.     int addr;
  415.     int running = 1;
  416.  
  417.     update_cursor(ON);
  418.     wrefresh(main_window);
  419.     edit_mode();
  420.  
  421. /* cursor_address */
  422.  
  423.     while (ch != 'e') {
  424.     ch = wgetch(main_window);
  425.     if (((ch >= '1') && (ch <= '9')) ||
  426.         ((ch == '0') && (rollover == 0))) {
  427.         if (rollover)
  428.         looptime = ch - '0';
  429.         else
  430.         looptime = looptime * 10 + ch - '0';
  431.         rollover = 0;
  432.     } else {
  433.         if (rollover)
  434.         looptime = 1;
  435.         else
  436.         rollover = 1;
  437.  
  438.         while (looptime) {
  439.         looptime--;
  440.         switch (ch) {
  441.             case 'a':
  442.             wref    = 1;
  443.             addis = !addis;
  444.  
  445.             wpline = (COLS - addis * 10) /
  446.                  (9 * wdis + chdis * 4);
  447.             buf_size = (LINES - 1) * wpline * 4;
  448.  
  449.             if ((cursor_address - caddr) >= buf_size) {
  450.                 cursor_address  = caddr + buf_size - 1;
  451.                 cursor_address -= cursor_address % alignment;
  452.             }
  453.  
  454.             wmove(main_window, 0, 0);
  455.             wclrtobot(main_window);
  456.             break;
  457.             case 'A':
  458.             write_mark(cursor_address, 1);
  459.             wref = 1;
  460.             break;
  461.             case '':
  462.             case 'b':
  463.             last_viewed  = caddr;
  464.             caddr        -= buf_size;
  465.             caddr        -= caddr % alignment;
  466.             if (caddr < 0)
  467.                 caddr = 0;
  468.             if (cursor_address >= caddr + size) {
  469.                 cursor_address  = caddr + size - 1;
  470.                 cursor_address -= cursor_address % alignment;
  471.             }
  472.             rfile    = 1;
  473.             break;
  474.             case 'c':
  475.             rfile    = 1;
  476.             chdis    = !chdis;
  477.             temp    = wpline;
  478.             if (chdis == 0)
  479.                 wdis = 1;
  480.  
  481.             wpline = (COLS - addis * 10) /
  482.                  (9 * wdis + chdis * 4);
  483.             buf_size = (LINES - 1) * wpline * 4;
  484.  
  485.             if (cursor_address >= caddr + size) {
  486.                 cursor_address  = caddr + buf_size - 1;
  487.                 cursor_address -= cursor_address % alignment;
  488.             }
  489.             wmove(main_window, 0, 0);
  490.             wclrtobot(main_window);
  491.             break;
  492.             case 'C':
  493.             write_mark(cursor_address, 0);
  494.             wref = 1;
  495.             break;
  496.             case '':
  497.             case 'd':
  498.             if (caddr < fend - buf_size / 2) {
  499.                 last_viewed  = caddr;
  500.                 caddr        += buf_size / 2;
  501.                 caddr        -= caddr % alignment;
  502.                 rfile         = 1;
  503.                 if (cursor_address < caddr)
  504.                     cursor_address = caddr;
  505.             }
  506.             break;
  507.             case '':
  508.             case 'f':
  509.             if (caddr < fend - buf_size) {
  510.                 last_viewed  = caddr;
  511.                 caddr        += buf_size;
  512.                 caddr        -= caddr % alignment;
  513.                 rfile         = 1;
  514.                 if (cursor_address < caddr)
  515.                     cursor_address = caddr;
  516.             }
  517.             break;
  518.             case 'g':
  519.             temp  = get_jump(caddr);
  520.             temp -= temp % alignment;
  521.             if ((temp >= caddr) && (temp <= caddr + size)) {
  522.                 update_cursor(OFF);
  523.                 cursor_address  = temp;
  524.                 cursor_address -= cursor_address % alignment;
  525.                 cref            = 1;
  526.             } else if ((caddr != temp) &&
  527.                    (temp >= 0) && (temp <= fend)) {
  528.                 last_viewed    = caddr;
  529.                 caddr          = temp;
  530.                 caddr          -= caddr % alignment;
  531.                 cursor_address = caddr;
  532.                 rfile          = 1;
  533.             }
  534.             break;
  535.             case 'G':
  536.             update_cursor(OFF);
  537.             temp  = fend - buf_size;
  538.             temp -= temp % alignment;
  539.             if ((caddr != temp) && (temp > 0)) {
  540.                 last_viewed    = caddr;
  541.                 caddr          = temp;
  542.                 caddr          -= caddr % alignment;
  543.                 rfile          = 1;
  544.             } else
  545.                 cref = 1;
  546.             cursor_address  = caddr + size - 1;
  547.             cursor_address -= cursor_address % alignment;
  548.             break;
  549.             case 'h':
  550.             update_cursor(OFF);
  551.             cref = 1;
  552.             if (cursor_address >= alignment - 1) {
  553.                 cursor_address -= alignment;
  554.                 if (cursor_address < caddr) {
  555.                 last_viewed = caddr;
  556.                 caddr       -= buf_size / 2;
  557.                 caddr      -= caddr % alignment;
  558.                 rfile       = 1;
  559.                 if (caddr < 0)
  560.                     caddr = 0;
  561.                 }
  562.             }
  563.             break;
  564.             case 'H':
  565.             last_viewed = caddr;
  566.             caddr      += alignment;
  567.             if (caddr > fend - alignment) {
  568.                 caddr  = fend - alignment;
  569.                 caddr -= caddr % alignment;
  570.             }
  571.             rfile = 1;
  572.             if (cursor_address < caddr)
  573.                 cursor_address = caddr;
  574.             break;
  575.             case '':
  576.             help_me();
  577.             touchwin(main_window);
  578.             wrefresh(main_window);
  579.             break;
  580.             case 'j':
  581.             update_cursor(OFF);
  582.             cref = 1;
  583.             if (cursor_address < (fend - wpline * alignment)) {
  584.                 cursor_address += wpline * alignment;
  585.                 if (cursor_address >= caddr + buf_size) {
  586.                 last_viewed = caddr;
  587.                 caddr      += buf_size / 2;
  588.                 caddr      -= caddr % alignment;
  589.                 rfile       = 1;
  590.                 if (caddr > fend) {
  591.                     caddr = fend;
  592.                     caddr -= caddr % alignment;
  593.                 }
  594.                 }
  595.             }
  596.             break;
  597.             case 'J':
  598.             update_cursor(OFF);
  599.             if (caddr > 0) {
  600.                 last_viewed = caddr;
  601.                 caddr -= alignment * wpline;
  602.                 if (caddr < 0)
  603.                 caddr = 0;
  604.                 if (cursor_address >= caddr + size) {
  605.                 cursor_address  = caddr + size - 1;
  606.                 cursor_address -= cursor_address % alignment;
  607.                 }
  608.             }
  609.             rfile  = 1;
  610.             break;
  611.             case 'k':
  612.             update_cursor(OFF);
  613.             cref = 1;
  614.             if (cursor_address >= wpline * alignment) {
  615.                 cursor_address -= wpline * alignment;
  616.                 if (cursor_address < caddr) {
  617.                 last_viewed = caddr;
  618.                 caddr      -= buf_size / 2;
  619.                 caddr      -= caddr % alignment;
  620.                 rfile       = 1;
  621.                 if (caddr < 0)
  622.                     caddr = 0;
  623.                 }
  624.             }
  625.             break;
  626.             case 'K':
  627.             update_cursor(OFF);
  628.             if (caddr < fend - alignment * wpline) {
  629.                 last_viewed = caddr;
  630.                 caddr      += alignment * wpline;
  631.                 if (cursor_address < caddr)
  632.                     cursor_address = caddr;
  633.             }
  634.             rfile  = 1;
  635.             break;
  636.             case 'l':
  637.             update_cursor(OFF);
  638.             cref = 1;
  639.             if (cursor_address < (fend - alignment)) {
  640.                 cursor_address += alignment;
  641.                 if (cursor_address >= (caddr + buf_size)) {
  642.                 last_viewed = caddr;
  643.                 caddr      += buf_size / 2;
  644.                 caddr      -= caddr % alignment;
  645.                 rfile       = 1;
  646.                 if (caddr > fend)
  647.                     caddr = fend;
  648.                 }
  649.             }
  650.             break;
  651.             case 'L':
  652.             last_viewed = caddr;
  653.             caddr      -= alignment;
  654.             if (caddr < 0)
  655.                 caddr = 0;
  656.             rfile = 1;
  657.             if (cursor_address >= caddr + size) {
  658.                 cursor_address  = caddr + size - 1;
  659.                 cursor_address -= cursor_address % alignment;
  660.             }
  661.             break;
  662.             case ' ':
  663.             wref = 1;
  664.             clear();
  665.             touchwin(main_window);
  666.             touchwin(status_window);
  667.             refresh();
  668.             break;
  669.             case 'm':
  670.             set_mark(cursor_address);
  671.             break;
  672.             case '':
  673.             addr  = (cursor_address - caddr) / 4;
  674.             temp  = ibuffer[addr];
  675.             temp2 = ibuffer[addr + 1];
  676.             if (mode == STRING)
  677.                 edit_mem_string(addr);
  678.             else
  679.                 edit_hex(addr);
  680.             edit_mode();
  681.             if ((temp  != ibuffer[addr]) ||
  682.                 (temp2 != ibuffer[addr + 1]))
  683.                 dirty = 1;
  684.             if (mode == STRING)
  685.                 rfile = 1;
  686.             else
  687.                 wref = 1;
  688.             break;
  689.             case 'N':
  690.             global_direction = !global_direction;
  691.             case 'n':
  692.             wref = 1;
  693.             update_cursor(OFF);
  694.             cursor_address = generic_search(cursor_address,
  695.                             global_direction);
  696.             cursor_address -= cursor_address % alignment;
  697.  
  698.             if ((cursor_address < caddr) ||
  699.                 (cursor_address >= caddr + size)) {
  700.                 last_viewed = caddr;
  701.                 caddr = cursor_address;
  702.                 edit_mode();
  703.             } else
  704.                 daddr = !daddr;
  705.             break;
  706.             case 3:
  707.             case 'q':
  708.             case 'Q':
  709.             case '':
  710.             case 'x':
  711.             if (dirty)
  712.                 save_changes();
  713.             ch = 'e';
  714.             running = 0;
  715.             break;
  716.             case 'r':
  717.             daddr = !daddr;
  718.             rfile = 1;
  719.             break;
  720.             case 't':
  721.             wdismode = (wdismode + 1) % WDISMAX;
  722.             wref = 1;
  723.             edit_mode();
  724.             break;
  725.             case '\t':
  726.             mode = !mode;
  727.             edit_mode();
  728.             break;
  729.             case 'u':
  730.             case '':
  731.             if (caddr > 0) {
  732.                 last_viewed  = caddr;
  733.                 caddr        -= buf_size / 2;
  734.                 caddr       -= caddr % alignment;
  735.                 rfile         = 1;
  736.                 if (caddr < 0)
  737.                     caddr = 0;
  738.                 if (cursor_address >= caddr + size) {
  739.                     cursor_address  = caddr + size - 1;
  740.                     cursor_address -= cursor_address %alignment;
  741.                 }
  742.             }
  743.             break;
  744.             case 'w':
  745.             rfile = 1;
  746.             wdis = !wdis;
  747.             if (wdis == 0)
  748.                 chdis = 1;
  749.             wpline = (COLS - addis * 10) / (9 * wdis + chdis * 4);
  750.             buf_size = (LINES - 1) * wpline * 4;
  751.  
  752.             if (cursor_address >= caddr + size) {
  753.                 cursor_address  = caddr + size - 1;
  754.                 cursor_address -= cursor_address % alignment;
  755.             }
  756.  
  757.             wmove(main_window, 0, 0);
  758.             wclrtobot(main_window);
  759.             break;
  760.             case 'W':
  761.             case '':
  762.             save_changes();
  763.             rfile = 1;
  764.             break;
  765.             case '0':
  766.             update_cursor(OFF);
  767.             if (caddr > 0) {
  768.                 last_viewed = caddr;
  769.                 caddr        = 0;
  770.                 rfile        = 1;
  771.                 if (cursor_address >= caddr + size) {
  772.                     cursor_address  = caddr + size - 1;
  773.                     cursor_address -= cursor_address %alignment;
  774.                 }
  775.             } else {
  776.                 cursor_address = 0;
  777.                 cref    = 1;
  778.             }
  779.             break;
  780.             case '/':
  781.             case '?':
  782.             wref = 1;
  783.             update_cursor(OFF);
  784.             if (mode == STRING)
  785.                 cursor_address = find_str(cursor_address, ch == '?');
  786.             else
  787.                 cursor_address = find_hex(cursor_address, ch == '?');
  788.  
  789.             cursor_address -= cursor_address % alignment;
  790.  
  791.             if ((cursor_address < caddr) ||
  792.                 (cursor_address >= caddr + size)) {
  793.                 last_viewed = caddr;
  794.                 caddr = cursor_address;
  795.                 edit_mode();
  796.             } else
  797.                 daddr = !daddr;
  798.             break;
  799.             case '+':
  800.             case '=':
  801.             wref = 1;
  802.             wpline++;
  803.             if (wpline > (COLS - addis * 10)/(9 * wdis + chdis * 4))
  804.                 wpline--;
  805.             buf_size = (LINES - 1) * wpline * 4;
  806.  
  807.             break;
  808.             case '-':
  809.             case '_':
  810.             wref = 1;
  811.             wpline--;
  812.             if (wpline < 1)
  813.                 wpline = 1;
  814.             buf_size = (LINES - 1) * wpline * 4;
  815.  
  816.             if (cursor_address >= caddr + buf_size) {
  817.                 cursor_address  = caddr + buf_size - 1;
  818.                 cursor_address -= cursor_address % alignment;
  819.             }
  820.  
  821.             wmove(main_window, 0, 0);
  822.             wclrtobot(main_window);
  823.             break;
  824.             case '\'':
  825.             if ((temp = get_mark(-1)) != -1)
  826.                 if ((temp > caddr + size - 1) || (temp < caddr)) {
  827.                 last_viewed    = caddr;
  828.                 caddr           = temp;
  829.                 caddr         -= caddr % alignment;
  830.                 cursor_address = caddr;
  831.                 rfile          = 1;
  832.                 } else {
  833.                 update_cursor(OFF);
  834.                 cursor_address = temp - temp % alignment;
  835.                 wref           = 1;
  836.                 }
  837.             break;
  838.             case ')':
  839.             update_cursor(OFF);
  840.             cursor_address  = caddr + size - 1;
  841.             cursor_address -= cursor_address % alignment;
  842.             cref = 1;
  843.             break;
  844.             case '(':
  845.             update_cursor(OFF);
  846.             cursor_address = caddr;
  847.             cref = 1;
  848.             break;
  849.             case '<':
  850.             alignment <<= 1;
  851.             if (alignment > 8)
  852.                 alignment = 1;
  853.             edit_mode();
  854.             break;
  855.             case '>':
  856.             alignment >>= 1;
  857.             if (alignment < 1)
  858.                 alignment = 8;
  859.             edit_mode();
  860.             break;
  861.         }
  862.         }
  863.         if (rfile) {
  864.         if (show_addr(caddr, 0)) {
  865.             caddr = last_viewed;
  866.             (void) show_addr(caddr, 1);
  867.         }
  868.         update_cursor(ON);
  869.         wrefresh(main_window);
  870.         rfile = 0;
  871.         wref = 0;
  872.         cref = 0;
  873.         } else if (wref) {
  874.         if (show_addr(caddr, 0)) {
  875.             caddr = last_viewed;
  876.             (void) show_addr(caddr, 1);
  877.         }
  878.         update_cursor(ON);
  879.         wrefresh(main_window);
  880.         wref = 0;
  881.         cref = 0;
  882.         } else if (cref) {
  883.         update_cursor(ON);
  884.         wrefresh(main_window);
  885.         cref = 0;
  886.         }
  887.     }
  888.     }
  889.  
  890.     if (dirty)
  891.     save_changes();
  892.  
  893.     update_cursor(OFF);
  894.     wrefresh(main_window);
  895.     wstandend(main_window);
  896.  
  897.     wmove(status_window, 0, COLS - 10);
  898.     wclrtoeol(status_window);
  899.     return(running);
  900. }
  901.  
  902. update_cursor(mode)
  903. int mode;
  904. {
  905.     int index;
  906.     int row, column;
  907.  
  908.     row    = ((cursor_address - caddr) / 4) / wpline;
  909.     column = ((cursor_address - caddr) / 4) % wpline;
  910.  
  911.     if (mode)
  912.         wstandout(main_window);
  913.     else
  914.         wstandend(main_window);
  915.  
  916.     if (chdis) {
  917.         wmove(main_window, row, addis * 10 + wpline * 9 * wdis + column*4);
  918.         waddch_filt(buffer[cursor_address - caddr    ]);
  919.         waddch_filt(buffer[cursor_address - caddr + 1]);
  920.         waddch_filt(buffer[cursor_address - caddr + 2]);
  921.         waddch_filt(buffer[cursor_address - caddr + 3]);
  922.     }
  923.  
  924.     if (wdis) {
  925.         wrefresh(main_window);
  926.         index = (cursor_address - caddr) / 4;
  927.         switch (wdismode) {
  928.         case 0:            /* hex */
  929.             (void) sprintf(out_string, "%08x", ibuffer[index]);
  930.             break;
  931.         case 1:            /* integer */
  932.             (void) sprintf(out_string, "%8d", ibuffer[index]);
  933.             out_string[8] = '\0';
  934.             break;
  935.         case 2:            /* float */
  936.             (void) sprintf(out_string, "%-9f",
  937.                    *((float *) &ibuffer[index]));
  938.             out_string[8] = '\0';
  939.             break;
  940.         case 3:            /* float */
  941.             (void) sprintf(out_string, "%-18lf",
  942.                    *((double *) &ibuffer[index]));
  943.             out_string[17] = '\0';
  944.             break;
  945.         }
  946.  
  947.         wmove(main_window, row, addis * 10 + column * 9);
  948.         waddstr(main_window, out_string);
  949.     }
  950.  
  951.     if (mode)
  952.         wstandend(main_window);
  953. }
  954.  
  955.  
  956. print_usage(program)
  957. char *program;
  958. {
  959.     fprintf(stderr, "Usage is:\n%s ", program);
  960.     fprintf(stderr, "[-r] [-w] [-v] filename\n");
  961.     fprintf(stderr, "%*s -r = view mode\n",        strlen(program), "");
  962.     fprintf(stderr, "%*s -w = force write mode\n", strlen(program), "");
  963.     fprintf(stderr, "%*s -v = print version\n",    strlen(program), "");
  964.     exit(1);
  965. }
  966.