/*
 * CDDL HEADER START
 *
 * The contents of this file are subject to the terms of the
 * Common Development and Distribution License (the "License").
 * You may not use this file except in compliance with the License.
 *
 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
 * or http://www.opensolaris.org/os/licensing.
 * See the License for the specific language governing permissions
 * and limitations under the License.
 *
 * When distributing Covered Code, include this CDDL HEADER in each
 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
 * If applicable, add the following below this CDDL HEADER, with the
 * fields enclosed by brackets "[]" replaced with your own identifying
 * information: Portions Copyright [yyyy] [name of copyright owner]
 *
 * CDDL HEADER END
 */

/*
 * Copyright 2009 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 */

/*      Copyright (c) 1988 AT&T */
/*        All Rights Reserved   */

/*
 * University Copyright- Copyright (c) 1982, 1986, 1988
 * The Regents of the University of California
 * All Rights Reserved
 *
 * University Acknowledgment- Portions of this document are derived from
 * software developed by the University of California, Berkeley, and its
 * contributors.
 */

/*LINTLIBRARY*/

#include        <stdio.h>
#include        <stdlib.h>
#include        <string.h>
#include        <sys/types.h>
#include        "curses_inc.h"

#ifdef  _VR2_COMPAT_CODE
extern  char    _endwin;
#endif  /* _VR2_COMPAT_CODE */

/* 1200 is put at the 0th location since 0 is probably a mistake. */
static long baud_convert[] = {
        1200, 50, 75, 110, 134, 150, 200, 300, 600, 1200,
        1800, 2400, 4800, 9600, 19200, 38400, 57600, 76800,
        115200, 153600, 230400, 307200, 460800, 921600,
        1000000, 1152000, 1500000, 2000000, 2500000,
        3000000, 3500000, 4000000
};

static  char    isfilter = 0;
static  int     _chk_trm(void);
static  void    _forget(void);

/*
 * newscreen sets up a terminal and returns a pointer to the terminal
 * structure or NULL in case of an error.  The parameters are:
 *      type: terminal type
 *      lsize, csize, tabsize: physical sizes
 *      infptr, outfptr: input and output stdio stream file pointers
 */

SCREEN  *
newscreen(char *type, int lsize, int csize, int tabsize,
        FILE *outfptr, FILE *infptr)
{
        int             old_lines = LINES, old_cols = COLS, retcode;
#ifndef _IOFBF
        char    *sobuf;
#endif  /* _IOBUF */
        WINDOW  *old_curscr = curscr;
        SCREEN  *old = SP;
        TERMINAL        *old_term = cur_term;

#ifdef  DEBUG
        if (outf == NULL) {
                outf = fopen("trace", "w");
                if (outf == NULL) {
                        perror("trace");
                        exit(-1);
                }
                setbuf(outf, (char *)NULL);
        }

        if (outf)
                fprintf(outf, "NEWTERM(type=%s, outfptr=%x %d, infptr=%x %d) "
                    "isatty(2) %d, getenv %s\n", type, outfptr,
                    fileno(outfptr), infptr, fileno(infptr), isatty(2),
                    getenv("TERM"));
#endif  /* DEBUG */


        /* read in terminfo file */

        if (setupterm(type, fileno(outfptr), &retcode) != 0)
                goto err2;

        /* the max length of a multi-byte character */
        _csmax = (cswidth[0] > cswidth[1]+1 ?
            (cswidth[0] > cswidth[2]+1 ? cswidth[0] : cswidth[2]+1) :
            (cswidth[1] > cswidth[2] ? cswidth[1]+1 : cswidth[2]+1));
        if (_csmax > CSMAX)
                goto err2;
        /* the max length of a multi-column character */
        _scrmax = _curs_scrwidth[0] > _curs_scrwidth[1] ?
            (_curs_scrwidth[0] > _curs_scrwidth[2] ? _curs_scrwidth[0] :
            _curs_scrwidth[2]) : (_curs_scrwidth[1] > _curs_scrwidth[2] ?
            _curs_scrwidth[1] : _curs_scrwidth[2]);
        /* true multi-byte/multi-column case */
        _mbtrue = (_csmax > 1 || _scrmax > 1);

        if ((curs_errno = _chk_trm()) != -1) {
                (void) strcpy(curs_parm_err, cur_term->_termname);
                goto err2;
        }

        /* use calloc because almost everything needs to be zero */
        if ((SP = (SCREEN *) calloc(1, sizeof (SCREEN))) == NULL)
                goto err1;

        SP->term_file = outfptr;
        SP->input_file = infptr;

        /*
         * The default is echo, for upward compatibility, but we do
         * all echoing in curses to avoid problems with the tty driver
         * echoing things during critical sections.
         */

        SP->fl_echoit = 1;

        /* set some fields for cur_term structure */

        (void) typeahead(fileno(infptr));
        (void) tinputfd(fileno(infptr));

        /*
         * We use LINES instead of the SP variable and a local variable because
         * slk_init and rip_init update the LINES value and application code
         * may look at the value of LINES in the function called by rip_init.
         */

        /* LINTED */
        LINES = SP->lsize = lsize > 0 ? lsize : lines;

        /* force the output to be buffered */
#ifdef  _IOFBF
        (void) setvbuf(outfptr, (char *)NULL, _IOFBF, 0);
#else   /* _IOFBF */
        if ((sobuf = malloc(BUFSIZ)) == NULL) {
                curs_errno = CURS_BAD_MALLOC;
#ifdef  DEBUG
                strcpy(curs_parm_err, "newscreen");
#endif  /* DEBUG */
        }
        setbuf(outfptr, sobuf);
#endif  /* _IOFBF */

#ifdef  SYSV
        SP->baud = baud_convert[_BRS(PROGTTYS)];
#else   /* SYSV */
        SP->baud = baud_convert[_BR(PROGTTY)];
#endif  /* SYSV */

        /* figure out how much each terminal capability costs */
        _init_costs();

        /* initialize the array of alternate characters */
        (void) init_acs();

        SP->tcap = cur_term;

        /* set tty settings to something reasonable for us */
#ifdef  SYSV
        PROGTTYS.c_lflag &= ~ECHO;
        PROGTTYS.c_lflag |= ISIG;
        PROGTTYS.c_oflag &= ~(OCRNL|ONLCR); /* why would anyone set OCRNL? */
#else   /* SYSV */
        PROGTTY.sg_flags &= ~(RAW|ECHO|CRMOD);
#endif  /* SYSV */

        (void) cbreak();

        /* LINTED */
        COLS = SP->csize = csize > 0 ? csize : columns;
        if (tabsize == 0)
                tabsize = (init_tabs == -1) ? 8 : init_tabs;
        /* LINTED */
        SP->tsize = (short)tabsize;
#ifdef  DEBUG
        if (outf)
                fprintf(outf, "LINES = %d, COLS = %d\n", LINES, COLS);
#endif  /* DEBUG */

        if ((curscr = SP->cur_scr = newwin(LINES, COLS, 0, 0)) == NULL)
                goto err;

        SP->fl_endwin = 2;
#ifdef  _VR2_COMPAT_CODE
        _endwin = FALSE;
#endif  /* _VR2_COMPAT_CODE */
        curscr->_sync = TRUE;

        /*
         * This will tell _quick_echo(if it's ever called), whether
         * _quick_echo should let wrefresh handle everything.
         */

        if (ceol_standout_glitch || (magic_cookie_glitch >= 0) ||
            tilde_glitch || (transparent_underline && erase_overstrike)) {
                curscr->_flags |= _CANT_BE_IMMED;
        }
        if (!(SP->virt_scr = newwin(LINES, COLS, 0, 0)))
                goto err;
        _virtscr = SP->virt_scr;

        SP->virt_scr->_clear = FALSE;

        /* video mark map for cookie terminals */

        if (ceol_standout_glitch || (magic_cookie_glitch >= 0)) {
                int     i, nc;
                char    **marks;

                if ((marks = (char **)calloc((unsigned)LINES,
                    sizeof (char *))) == NULL)
                        goto err;
                SP->_mks = marks;
                nc = (COLS / BITSPERBYTE) + (COLS % BITSPERBYTE ? 1 : 0);
                if ((*marks = (char *)calloc((unsigned)nc * LINES,
                    sizeof (char))) == NULL)
                        goto err;
                for (i = LINES - 1; i-- > 0; ++marks)
                        *(marks + 1) = *marks + nc;
        }

        /* hash tables for lines */
        if ((SP->cur_hash = (int *)calloc((unsigned)2 * LINES,
            sizeof (int))) == NULL)
                goto err;
        SP->virt_hash = SP->cur_hash + LINES;

        /* adjust the screen size if soft labels and/or ripoffline are used */
        if (_slk_init)
                (*_slk_init)();
        if (_rip_init)
                (*_rip_init)();

        if ((SP->std_scr = newwin(LINES, COLS, 0, 0)) == NULL) {
                /* free all the storage allocated above and return NULL */
err:
                delscreen(SP);
                COLS = old_cols;
                curscr = old_curscr;
                LINES = old_lines;
err1:
                SP = old;

                curs_errno = CURS_BAD_MALLOC;
#ifdef  DEBUG
                strcpy(curs_parm_err, "newscreen");
#endif  /* DEBUG */

err2:
                cur_term = old_term;
                return (NULL);
        }
#ifdef  DEBUG
        if (outf)
                fprintf(outf, "SP %x, stdscr %x, curscr %x\n",
                    SP, SP->std_scr, curscr);
#endif  /* DEBUG */

        if (((SP->imode = (enter_insert_mode && exit_insert_mode)) != 0) &&
            ((SP->dmode = (enter_delete_mode && exit_delete_mode)) != 0)) {
                if (strcmp(enter_insert_mode, enter_delete_mode) == 0)
                        SP->sid_equal = TRUE;
                if (strcmp(exit_insert_mode, exit_delete_mode) == 0)
                        SP->eid_equal = TRUE;
        }
        SP->ichok = (SP->imode || insert_character || parm_ich);
        SP->dchok = (delete_character || parm_dch);

        stdscr = SP->std_scr;
        TABSIZE = SP->tsize;

        return (SP);
}

/*
 * check if terminal have capabilities to do basic cursor movements and
 * screen clearing
 */
static int
_chk_trm(void)
{
        short   error_num = -1;
#ifdef  DEBUG
        if (outf)
                fprintf(outf, "chk_trm().\n");
#endif  /* DEBUG */

        if (generic_type)
                error_num = CURS_UNKNOWN;
        else {
                if (isfilter) {
                        _forget();
                        /* Only need to move left or right on current line */
                        if (!(cursor_left || carriage_return ||
                            column_address || parm_left_cursor)) {
                                goto out_stupid;
                        }
                } else {
                        if ((hard_copy || over_strike) ||
                        /* some way to move up, down, left */
                            (!(cursor_address) &&
                            (!((cursor_up || cursor_home) && cursor_down &&
                            (cursor_left || carriage_return)))) ||
                            (!clear_screen)) {
out_stupid:
                                error_num = CURS_STUPID;
                        }
                }
        }
        return (error_num);
}

int
filter(void)
{
        isfilter = 1;
        return (OK);
}

/*
 * if (for some reason) user assumes that terminal has only one line,
 * disable all capabilities that deal with non-horizontal cursor movement
 */
static void
_forget(void)
{
        row_address = cursor_address = clear_screen = parm_down_cursor =
            cursor_up = cursor_down = NULL;
        cursor_home = carriage_return;
        lines = 1;
}