/*  028  11-Jan-87  ovview.c

        Copyright (c) 1987 by Blue Sky Software.  All rights reserved.
*/

#include <stdio.h>
#include <fcntl.h>
#include <sys/types.h>
#include <sys/stat.h>
#include "ov.h"

#define H_bar (0xcd)
#define V_bar (179)

#define Vnextch(fh) ((curp < endp) ? *curp++ : vnextch(fh))  /* speed up */
#define Vprevch(fh) ((curp > bufp) ? *--curp : vprevch(fh))  /* buffer access */

extern unsigned char far *curp;                /* current char position */
extern unsigned char far *bufp, far *endp;     /* buffer begin/end pointers */

static int (*mark_func)();             /* pointer to marker function */
static int nlines;                     /* # lines displayed on screen */
static unsigned char ascmode;          /* true means ascii mode display */
static unsigned char bitmask;          /* for 7 or 8 bit display mode */
static int inf;                        /* handle for file being viewed */
static int margin;                     /* margin for right/left scrolling */
static long tos;                       /* top of screen offset in file */
static long markers[5];                /* marker positions  */

/* function delcarations created by -Zg option - ALTCALL added
   NOTE: anything called by menu routine cannot be ALTCALL */

/*global*/  int view(void);
/*global*/  int view_move(int );
static int view_exit(void), view_down(void), view_up(void), view_next(void);
static int view_prev(void), view_tof(void), view_eof(void);
static int view_right(void), view_left(void), view_set(void), view_goto(void);
static int do_mark(void), setmark(void), gomark(void), ALTCALL view_line(void);
static int ALTCALL fmt_asc_line(char *,int *), ALTCALL fmt_hex_line(char *,int *);
static int view_7bit(void), view_8bit(void), view_asc(void), view_hex(void);
static int ALTCALL align(void);
static int ALTCALL backup(int );
static int ALTCALL peol(void);
static int ALTCALL nsol(void);
static int ALTCALL more2view(void);

static struct key_ent {        /* table mapping movement keys to function */
   int key;
   int (*func)();
} key2func[] = { { DOWN, view_next }, { UP, view_prev }, { PGDN, view_down },
   { PGUP, view_up }, { HOME, view_tof }, { END, view_eof },
   { RIGHT, view_right }, { LEFT, view_left } };

#define NMOVKEYS (8)

extern MENU_STATE curmenu;
extern MENU top_file_menu[], *top_menu;

static char setgo[] = "Set/Goto marker";

static MENU mark_menu[] = {
   { "1", setgo, do_mark, NULL },
   { "2", setgo, do_mark, NULL },
   { "3", setgo, do_mark, NULL },
   { "4", setgo, do_mark, NULL },
   { "5", setgo, do_mark, NULL },
   { NULL, NULL, NULL, NULL }
};


MENU top_view_menu[] = {
   { "Dwn", "Page down in the file", view_down, NULL },
   { "Up", "Page up in the file", view_up, NULL },
   { "Nxt", "Advance one line", view_next, NULL },
   { "Prv", "Backup one line", view_prev, NULL },
   { "TOF", "Goto Top Of File", view_tof, NULL },
   { "EOF", "Goto End Of File", view_eof, NULL },
   { "Rght", "Scroll right 8 characters", view_right, NULL },
   { "Left", "Scroll left 8 characters", view_left, NULL },
   { "Set", "Set marker at current position", view_set, mark_menu },
   { "Goto", "Goto set marker position", view_goto, mark_menu },
   { "Ascii", "View file as ASCII characters", view_asc, NULL },
   { "Hex", "View file in hexadecimal", view_hex, NULL },
   { "7bit", "View low 7 bits of each character", view_7bit, NULL },
   { "8bit", "View all 8 bits of each character", view_8bit, NULL },
   { "Quit", "Return to file display", view_exit, top_file_menu },
   { NULL, NULL, NULL, NULL }
};

extern WINDOW cw;
extern char *cantopen;
extern FILE_ENT files[];
extern unsigned char view_display, restricted;

int ALTCALL vbuf_init(int );           /* declarations for buffer routines */
int ALTCALL vbuf_free(void);
unsigned long ALTCALL vtell(void);
int ALTCALL vseek(int ,long ), ALTCALL vnextch(int ), ALTCALL vprevch(int );

#define view_seek(off) vseek(inf,off)


/******************************************************************************
 **                             V I E W                                      **
 *****************************************************************************/

view() {               /* view the current file at the terminal */

   int i;
   register char *fn;
   register FILE_ENT *fp;

   /* don't try to view file if its empty */

   fp = &files[cw.curidx];             /* a couple of quick pointers */

   if (fp->size == 0)
      show_error(0,8,1,"This file is empty!");

   bitmask = 0xff;             /* defaults: 8 bit, ascii, left edge */
   ascmode = TRUE;
   margin = 0;

   /* open the file to be viewed, error out if can't open */

   if ((inf = open((fn = fname(fp)),O_RDONLY|O_BINARY)) == -1) {
      free(fn);
      show_error(1,8,3,cantopen,fp->name,": ");
   }

   savescreen();               /* save current display image */
   restricted = TRUE;          /* disable special file commands */
   view_display = TRUE;        /* yes, we are viewing */

   for (i = 0; i < 5; i++)     /* set markers to TOF */
      markers[i] = 0L;

   vbuf_init(inf);             /* initialize view buffer system */

   center_text(FIRST_VROW-1,fn); /* show file name */
   free(fn);

   view_down();                /* display the first screen of file data */

   top_menu = top_view_menu;   /* setup the view menu as the main menu */
}


/******************************************************************************
 **                        V I E W _ E X I T                                 **
 *****************************************************************************/

static int
view_exit() {          /* exit the view display, return to file display */

   close(inf);                 /* close file */
   vbuf_free();                /* release memory */
   top_menu = top_file_menu;   /* restore file menu as main */

   restricted = FALSE;         /* all commands are enabled */
   view_display = FALSE;       /* not viewing */

   restorescreen();            /* redisplay prior screen image */
}


/******************************************************************************
 **                        V I E W _ D O W N                                 **
 *****************************************************************************/

static int
view_down() {          /* page down into the view buffer/file */

   register int i;

   if (!more2view())           /* nothing to do if no more data to view */
      return;

   nlines = 0;                 /* no lines displayed yet */
   tos = vtell();              /* remember where top of screen is */

   /* display up to a screen full of file data, clear the screen as we go */

   for (i = 0; i < VIEW_ROWS; i++) {
      gotorc(i+FIRST_VROW,0);          /* position to line */
      if (view_line())                 /* display a single line */
         nlines++;                     /* count lines displayed */
   }
}


/******************************************************************************
 **                        V I E W _ U P                                     **
 *****************************************************************************/

static int
view_up() {            /* page up into the view buffer */

   long curoff;

   /* back two screen's worth, or to the top line in memory and use
      view_down() to display the screen - only display if we really
      backed up (might be at TOF) */

   curoff = vtell();                   /* where we were */
   view_seek(tos);                     /* quickly to top of screen */
   if (backup(VIEW_ROWS))              /* try to backup another screen */
      view_down();                     /* display prior screen if backed up */
   else
      view_seek(curoff);               /* must be tof, back to where we were */
}


/******************************************************************************
 **                        V I E W _ N E X T                                 **
 *****************************************************************************/

static int
view_next() {          /* display the next line in the buffer/file */

   long curoff;

   if (!more2view())           /* nothing to do if no more data to view */
      return;

   /* set the new top of screen location */

   if (ascmode) {                      /* ascii mode display? */
      curoff = vtell();                /* save where we are */
      view_seek(tos);                  /* to top of screen  */
      nsol();                          /* to start of next line */
      tos = vtell();                   /* its the new top of screen */
      view_seek(curoff);               /* back to bottom of screen */

   } else                              /* hex mode */
     tos += 16;                        /* tos is just the next hex line */

   /* scroll the screen up one line to make room for the new line at bottom */

   delete_line(FIRST_VROW,VIEW_ROWS-1);

   gotorc(FIRST_VROW+VIEW_ROWS-1,0);   /* cursor to the last display line */

   view_line();                        /* display the line */
}


/******************************************************************************
 **                        V I E W _ P R E V                                 **
 *****************************************************************************/

static int
view_prev() {          /* display the previous line in the buffer */

   long curoff;

   curoff = vtell();                   /* where we are now */
   view_seek(tos);                     /* old top of screen */
   if (backup(1)) {                    /* can we backup another line */
      tos = vtell();                           /* if so, its new tos */
      insert_line(FIRST_VROW+1,VIEW_ROWS-1);   /* insert a blank line */
      gotorc(FIRST_VROW,0);                    /* cursor to first line */
      view_line();                             /* display the line */
      view_seek(curoff);                       /* back to old bottom */
      if (nlines < VIEW_ROWS)                  /* is a full screen displayed? */
         nlines++;                             /* no, one more displyed now */
      else
         backup(1);                            /* yes, back one line */

   } else                      /* couldn't backup, must be tof */
      view_seek(curoff);
}


/******************************************************************************
 **                        V I E W _ T O F                                   **
 *****************************************************************************/

static int
view_tof() {           /* backup and display the top of the file */

   view_seek(0L);              /* just go to top of file */
   view_down();                /* and display a screen */
}


/******************************************************************************
 **                        V I E W _ E O F                                   **
 *****************************************************************************/

static int
view_eof() {           /* display the end of the file */

   view_seek(files[cw.curidx].size);       /* seek to eof */
   backup(VIEW_ROWS);                      /* backup a screen full */
   view_down();                            /* display a screen full */
}


/******************************************************************************
 **                        V I E W _ M O V E                                 **
 *****************************************************************************/

view_move(mov_cmd)     /* move around the view buffer/file in response to */
int mov_cmd;           /* single key commands when viewing a file */
{

   register int i;

   /* basically, we just map the special keys to the same functions
      performed by the menu options */

   for (i = 0; i < NMOVKEYS; i++)
      if (mov_cmd == key2func[i].key) {
         (*key2func[i].func)();
         break;
      }
}


/*****************************************************************************
                 V I E W _ S E T / G O T O / M A R K
 *****************************************************************************/

static int
view_set() {           /* prepare to set a marker to current position */

   mark_func = setmark;        /* use the setmark routine later */
}

static int
view_goto() {          /* prepare to goto a marker position */

   mark_func = gomark;         /* use the gomark routine later */
}

static int
do_mark() {            /* set or goto a marker position */

   (*mark_func)();
}

static int
setmark() {            /* set a marker position */

   markers[curmenu.current_selection] = tos;
}

static int
gomark() {             /* goto a marker position */

   tos = markers[curmenu.current_selection];   /* where tos should be */
   align();                                    /* start at begining of line */
   view_down();                                /* display screen full */
}


/*****************************************************************************
                           V I E W _ L I N E
 *****************************************************************************/

static int ALTCALL
view_line() {          /* display a single line of the file */

   int col, ch;
   char line[SCREEN_COLS+1];

   if (ascmode)                /* format the line as ascii or hex data */
      ch = fmt_asc_line(line,&col);
   else
      ch = fmt_hex_line(line,&col);

   disp_str(line);                     /* make one call to display line */

   if (col < margin+SCREEN_COLS-1)     /* clear if < full line displayed */
      clr_eol();

   return(ch != EOF || col);   /* return true if something displayed */
}


/*****************************************************************************
                         F M T _ A S C _ L I N E
 ****************************************************************************/

static int ALTCALL
fmt_asc_line(op,colp)  /* format an ascii line for display */
char *op;
int *colp;
{
   register int ch, col = 0;
   int i, endcol = margin + SCREEN_COLS;

   while ((ch = Vnextch(inf)) != EOF && (ch = ch & bitmask) != '\n')
      if (ch == '\t') {
         for (i = 8 - (col & 7); i; i--, col++)
            if (col >= margin && col < endcol)
               *op++ = ' ';
       } else
          if (ch != '\r' && ch != '\0') {
              if (col >= margin && col < endcol)
                  *op++ = ch;
             col++;
          }

   *op = '\0';                 /* null terminate it for disp_str */

   *colp = col;                /* tell caller the # cloumns */
   return(ch);                 /* and if EOF was reached */
}


/******************************************************************************
                          F M T _ H E X _L I N E
 *****************************************************************************/

static int ALTCALL
fmt_hex_line(op,colp)  /* format a hex line for later display */
register char *op;
int *colp;
{
   int ch, ach, j;
   register int i;
   char offstr[9], *ap;
   static char bin2hex[] = "0123456789ABCDEF";

   /* test if there is anything to format */

   if (vnextch(inf) == EOF) {
      *colp = 0;
      *op = '\0';
      return(EOF);
   } else
      vprevch(inf);

   /* format data offset into buffer */

   ultoa(vtell(),offstr,16);           /* offset to hex */
   j = strlen(offstr);
   for (i = 6 - j; i > 0; i--)         /* zero fill */
      *op++ = '0';
   if (j <= 6)                         /* don't use more than 6 digits */
     strcpy(op,offstr);
   else
     strcpy(op,offstr+j-6);

   strupr(op);                         /* ultoa leaves A-F in lower case */

   strcat(op,"  ");                    /* go beyond the offset */
   op += strlen(op);

   ap = op + 53;                       /* where ascii data starts */
   *ap++ = V_bar;                      /* might as well do it now */

   /* setup data in hex (and ascii) */

   for (i = 16; i; i--) {              /* at most 16 bytes to fmt */

      ch = Vnextch(inf);               /* next char from file */
      if (ch == EOF)                   /* done? */
         break;

      *op++ = bin2hex[(ch >> 4) & 0x0f];       /* hexalate it */
      *op++ = bin2hex[ch & 0x0f];
      *op++ = ' ';

      if (((i+3) & 3) == 0)            /* extra spacer every 4 bytes */
         *op++ = ' ';

      if ((ach = ch & bitmask) < ' ')  /* do the ascii char, '.' if ctrl ch */
         *ap++ = '.';
      else
         *ap++ = ach;
   }

   /* blank fill if EOF was reached */

   for ( ; i; i--) {           /* i is # chars to blank fill */
      strncpy(op,"   ",3);
      op += 3;
      if (((i+3) & 3) == 0)
         *op++ = ' ';
      *ap++ = ' ';
   }

   *op++ = ' ';                /* up to ascii data */

   *ap++ = V_bar;              /* closing bar at end */
   *ap = '\0';                 /* The Terminator */

   *colp = 74;                 /* tell call how many columns */
   return(ch);                 /* and if EOF was reached */
}


/*****************************************************************************
                      V I E W _ R I G H T / L E F T
 *****************************************************************************/

static int
view_right() {         /* scroll right 8 characters */

   margin += 8;
   view_current();
   disp_margin();
}

static int
view_left() {          /* scroll left 8 characters */

   if (margin >= 8) {
      margin -= 8;
      view_current();
      disp_margin();
   }
}

static int
disp_margin() {        /* display the viewing margins */

   char marstr[11];

   if (margin) {

      itoa(margin,marstr,10);
      disp_msg(2,"COL: ",marstr);

   } else              /* must have just gone to 0 */

      clr_msg();
}


/*****************************************************************************
                            V I E W _ n B I T
 *****************************************************************************/

static int
view_7bit() {          /* display data using low order 7 bits */

   if (bitmask != 0x7f) {
      bitmask = 0x7f;
      view_current();
   }
}

static int
view_8bit() {          /* display data using all 8 bits per char */

   if (bitmask != 0xff) {
      bitmask = 0xff;
      view_current();
   }
}

static int
view_current() {       /* redisplay the current screen */

      view_seek(tos);
      view_down();
}


/*****************************************************************************
                           V I E W _ A S C
 *****************************************************************************/

static int
view_asc() {           /* set ascii mode display */

   if (!ascmode) {                    /* only need to change if in hex mode */
      ascmode = TRUE;                 /* set ascii mode */
      align();                        /* make sure were at begining of line */
      view_down();                       /* redisplay in ascii format */
   }
}


/*****************************************************************************
                          V I E W _ H E X
 *****************************************************************************/

static int
view_hex() {           /* set hex mode display */

   if (ascmode) {                     /* only need to change if in ascii mode */
      ascmode = FALSE;                /* set hex mode */
      align();                        /* make sure were at begining of line */
      view_down();                    /* redisplay in ascii format */
   }
}


/*****************************************************************************
                                A L I G N
 *****************************************************************************/

static int ALTCALL
align() {              /* align tos to be at the start of a line */

   if (ascmode) {              /* ascii mode? */

      view_seek(tos);                 /* backup to current top of screen */
      if (backup(1))                  /* make sure were at the start of */
         nsol();                      /*   the current line */

   } else {                    /* hex mode */

      tos &= ~((long) 0x0f);          /* force a paragraph boundry */
      view_seek(tos);                 /* backup to current top of screen */
   }
}

/*****************************************************************************
                                B A C K U P
 *****************************************************************************/

static int ALTCALL
backup(todo)           /* backup todo lines from current position */
int todo;
{
   register int i;
   int part, bytes;
   unsigned long off, lines;

    /* backup in hex mode */

    if (!ascmode) {                    /* different if in hex mode */
       off = vtell();                  /* current loc in file */
       lines = off >> 4;               /* # full hex display lines above */
       part = (bytes = off & (long) 0x0f) > 0; /* may be partial line if at eof */
       if (todo > lines + part) {              /* more todo than are? */
          view_seek(0L);                       /* just goto tof */
          return(lines + part);                /* went back this # lines */
       } else {
          view_seek(off - (((todo - part) << 4)+bytes)); /* backup todo lines */
          return(todo);
       }
    }

    /* backup in ascii mode */

    /* special case backing up from EOF - there may or may not be a \n
       at the end of the last line */

    if (vnextch(inf) == EOF) {         /* at end of file? */
       vprevch(inf);                   /*   always backup at least one char */
       i = 1;                          /*   we will backup 1 line here      */
       if (peol() == '\n')             /*   goto start of prev line         */
          vnextch(inf);
    } else {           /* not at EOF, setup for loop down below */
       i = 0;
       vprevch(inf);
    }

    /* backup todo ascii lines, 1 line may have been done above */

    for ( ; i < todo; i++) {
      if (peol() == EOF)               /* goto end of prev line */
         break;
      if (peol() == '\n')              /* end of prev prev line */
         vnextch(inf);                 /* start of prev line    */
   }

   return(i);          /* tell caller how many ascii lines backed up */
}

static int ALTCALL
peol() {       /* move to end of prev line */

   register int ch;

   while ((ch = Vprevch(inf)) != '\n' && ch != EOF) ;  /* end of prev line */
   return(ch);
}

static int ALTCALL
nsol() {       /* move to start of next line */

   register int ch;

   while ((ch = Vnextch(inf)) != '\n' && ch != EOF) ;  /* start of next line */
   return(ch);
}


/*****************************************************************************
                            M O R E 2 V I E W
 *****************************************************************************/

static int ALTCALL
more2view() {          /* return true if more data to view */

   return(vtell() < files[cw.curidx].size);
}