http://invisible-island.net/ncurses/ncurses.faq (slang)

Pre-color curses headers

#ifndef __CURSES_LOADED
#define __CURSES_LOADED 1
/****************************************************************************
**
**  <curses.h> - Curses screen management functions
**
*****************************************************************************
**  Header is nonstandard
*****************************************************************************
**
**  Copyright Digital Equipment Corporation 1993, 1995. All rights reserved.
**
**  Restricted Rights: Use, duplication, or disclosure by the U.S.
**  Government is subject to restrictions as set forth in subparagraph
**  (c) (1) (ii) of DFARS 252.227-7013, or in FAR 52.227-19, or in FAR
**  52.227-14 Alt. III, as applicable.
**
**  This software is proprietary to and embodies the confidential
**  technology of Digital Equipment Corporation. Possession, use, or
**  copying of this software and media is authorized only pursuant to a
**  valid written license from Digital or an authorized sublicensor.
**
******************************************************************************
*/
 
#pragma __nostandard
 
 
/*
**  Using __VMS_CURSES implies _VMS_CURSES 
*/
#if defined(__VMS_CURSES) && !defined(_VMS_CURSES)
#   define _VMS_CURSES 1
#endif
 
 
/*
**  Using __BSD44_CURSES implies _BSD44_CURSES 
*/
#if defined(__BSD44_CURSES) && !defined(_BSD44_CURSES)
#   define _BSD44_CURSES 1
#endif
 
 
/*
**  Default to _VMS_CURSES
*/
#if !defined(_BSD44_CURSES) && !defined(_VMS_CURSES)
#   define _VMS_CURSES 1
#endif
 
#ifndef __CRTL_VER
#   define __CRTL_VER __VMS_VER
#endif
 
 
/*
**  BSD Curses is only available on OpenVMS Alpha as of OpenVMS V7.0.
**
**  While this may appear to be an incompatible change, the number of
**  problems discovered in the BSD Curses package shipped as part of the DEC
**  C RTL in versions of OpenVMS prior to V7.0 has led us to conclude that a
**  correct program could not be built using it.  We have changed the
**  default to be _VMS_CURSES for those applications which are targetting
**  systems prior to OpenVMS V7.0 and also utilize curses functions.
**
*/
#if defined(_BSD44_CURSES) && defined(__VAX)
#   error " BSD 4.4 Curses package not yet available on OpenVMS VAX"
#endif
#if defined(_BSD44_CURSES) && (__CRTL_VER < 70000000)
#   error " BSD 4.4 Curses package not available on OpenVMS Alpha before V7.0"
#endif
 
 
/*
**  Disable the following messages prior to including the header files.
*/
#pragma __message __save
#pragma __message __disable (__MISALGNDSTRCT)
#pragma __message __disable (__MISALGNDMEM)
#pragma __message __disable (__MACROEXT)
 
 
/*
**  Perform includes necessary for each of the curses packages.  This is done
**  here because we do not want to use any #pragmas prior to the includes.
*/
#ifdef _VMS_CURSES 
#   include <ssdef.h>
#   include <stdio.h>
#   if !(__DECC_MODE_COMMON) && !(__DECC_MODE_STRICT)
#      include <smgdef.h>
#   endif
#else
#   include <ints.h>
#   include <stdio.h>
#   include <string.h>
#endif
 
 
#ifdef __cplusplus
    extern "C" {
#endif
 
 
/*
**  Ensure that regardless of user /pointer_size usage, we begin processing
**  using a short pointer context.
*/
#if __INITIAL_POINTER_SIZE
#   if (__CRTL_VER < 70000000) || !defined __ALPHA
#      error " Pointer size usage not permitted before OpenVMS Alpha V7.0"
#   endif
#   pragma __pointer_size __save
#   pragma __pointer_size 32
#endif
 
 
/*
**  All structures should be member aligned on natural boundaries
*/
#pragma __member_alignment __save
#pragma __member_alignment
 
 
/*
**  Definitions common to both _VMS_CURSES and _BSD44_CURSES
*/
#define  ERR  (0)   /*  Error return    */
#define  OK   (1)   /*  Success return  */
 
#ifndef TRUE
#   define  TRUE  (1)
#endif
 
#ifndef FALSE
#   define  FALSE (0)
#endif
 
 
/*
**  Define macros which give the user the correct dereferencing of global
**  variables defined in the DEC C RTL
*/
#ifdef __ALPHA
#   define  LINES      decc$ga_LINES
#   define  COLS       decc$ga_COLS
#   define  stdscr     decc$ga_stdscr
#   define  curscr     decc$ga_curscr
#else
#   define  LINES      (*decc$ga_LINES)
#   define  COLS       (*decc$ga_COLS)
#   define  stdscr     (*decc$ga_stdscr)
#   define  curscr     (*decc$ga_curscr)
#endif
 
#ifdef _VMS_CURSES
#   ifdef __ALPHA
#      define  stdkb   decc$ga_stdkb
#      define  stdpb   decc$ga_stdpb
#   else
#      define  stdkb   (*decc$ga_stdkb)
#      define  stdpb   (*decc$ga_stdpb)
#   endif
#endif

#ifdef _VMS_CURSES 
/**********************************************************/
/*      Header file for _VMS_CURSES (VAX and Alpha)       */
/**********************************************************/
 
/*
**  
*/
#define reg register
 
 
/*
** 
*/
#define _SUBWIN     0001
#define _ENDLINE    0002
#define _FULLWIN    0004
#define _SCROLLWIN  0010
#define _FLUSH      0020
#define _STANDOUT   0200
 
 
/*
**  Values used in lower byte of the _win_st _flags structure
*/
#define _BLINK         4  /* SMG$M_BLINK     */
#define _BOLD          1  /* SMG$M_BOLD      */
#define _REVERSE       2  /* SMG$M_REVERSE   */
#define _UNDERLINE     8  /* SMG$M_UNDERLINE */
 
 
/*
**  Values used in the _flags field in the _kb_st structure
*/
#define _NOECHO      001
#define _NONL        002
#define _NOCRMODE    004
#define _NORAW       010
 
 
/*
**  Buffer size used by SMG routines
*/
#define SMG_BUFSIZ   512
 
 
/*
**  Define a _win_st structure
*/
#pragma __member_alignment __save
#pragma __nomember_alignment __word
 
struct _win_st {
    int    _cur_y, _cur_x;
    int    _max_y, _max_x;
    int    _beg_y, _beg_x;
 
    /*
    **  Low byte of _flags contains rendition and the upper byte are
    **  values such as _ENDLINE, _SCROLLWIN etc (see above)
    */
    short  _flags;
    char   _clear, _leave, _scroll, _wrap;
    char   **_y;
    short  *_firstch,  *_lastch;
    struct _win_st *_next, *_parent, *_child;
    int    _id;
};
#pragma __member_alignment __restore
 
 
/*
**  Define a _kb_st structure
*/
 
struct _kb_st {
 
    /*
    **  Identifier of the keyboard.  Passed to SMG.
    */
    int  _id;
 
    /*
    **  Flags can be raw, break etc... 
    */
    unsigned char _flags;    
 
    /*
    **  Descriptor use for input
    */
    struct {
        unsigned short length;
        unsigned char type;
#   ifdef __cplusplus
            unsigned char _class;
#       else
            unsigned char class;
#       endif
        char  *address;
    } _buffer_desc;
 
    /*
    **  The number of bytes read in but not yet returned to the
    **  application.  An example of this is using RAW mode where
    **  several characters are read in on a single getch, but the
    **  application must call getch several times to get each one.
    */
    int  _count;
 
    /*
    **  Pointer to next byte to return to user.  This may or may not be
    **  equal to the address field in the above descriptor when input
    **  is buffered.
    */
    char  *_ptr;
};
 
 
/*
**  Define a _pb_st structure
*/
#if !(__DECC_MODE_COMMON) && !(__DECC_MODE_STRICT)
    struct _pb_st {
        int  _id;
        int  _rows, _cols;
        union smgdef *_attr;
        int  _attr_size;
    };
#endif
 
#define _KEYBOARD   struct _kb_st
#define  WINDOW     struct _win_st
#define _PASTEBOARD struct _pb_st
 
 
/*
**  Curses external declarations
*/
#pragma __extern_model __save
#pragma __extern_model __strict_refdef
 
extern  WINDOW *     curscr;    /* Current screen         */
extern  WINDOW *     stdscr;    /* Standard screen        */
extern  int          COLS;      /* Columns on the screen  */
extern  int          LINES;     /* Lines on the screen    */
extern _KEYBOARD *   stdkb;     /* Standard keyboard      */
extern _PASTEBOARD * stdpb;     /* Standard pasteboard    */
 
#pragma __extern_model __restore
 
 
/*
**  The following non-stdscr functions are defined as macros which use the w
**  form of the functions, passing stdscr as the first argument.
*/
#define  addch(ch)              waddch (stdscr,ch)
#define  addstr(s)              waddstr (stdscr,s)
#define  clear()                wclear (stdscr)
#define  clrattr(a)             wclrattr (stdscr,a)
#define  clrtobot()             wclrtobot (stdscr)
#define  clrtoeol()             wclrtoeol (stdscr)
#define  delch()                wdelch (stdscr)
#define  deleteln()             wdeleteln (stdscr)
#define  erase()                werase (stdscr)
#define  getch()                wgetch (stdscr)
#define  getstr(s)              wgetstr (stdscr,s)
#define  inch()                 winch (stdscr)
#define  insch(c)               winsch (stdscr,c)
#define  insertln()             winsertln (stdscr)
#define  insstr(s)              winsstr (stdscr,s)
#define  move(y,x)              wmove (stdscr,y,x)
#define  refresh()              wrefresh (stdscr)
#define  setattr(a)             wsetattr (stdscr,a)
#define  standout()             wstandout (stdscr)
#define  standend()             wstandend (stdscr)
 
#define  mvaddch(y,x,ch)        mvwaddch (stdscr,y,x,ch)
#define  mvgetch(y,x)           mvwgetch (stdscr,y,x)
#define  mvaddstr(y,x,str)      mvwaddstr (stdscr,y,x,str)
#define  mvinsstr(y,x,str)      mvwinsstr (stdscr,y,x,str)
#define  mvgetstr(y,x,str)      mvwgetstr (stdscr,y,x,str)
#define  mvinch(y,x)            mvwinch (stdscr,y,x)
#define  mvdelch(y,x)           mvwdelch (stdscr,y,x)
#define  mvinsch(y,x,ch)        mvwinsch (stdscr,y,x,ch)
#define  mvdeleteln(y,x)        mvwdeleteln (stdscr,y,x)
#define  mvcur(ly,lx,ny,nx)     wmove (stdscr,ny,nx)
 
#define  mvwaddch(win,y,x,ch)   (wmove(win,y,x)==ERR ? ERR : waddch(win,ch))
#define  mvwgetch(win,y,x)      (wmove(win,y,x)==ERR ? ERR : wgetch(win))
#define  mvwinsstr(win,y,x,str) (wmove(win,y,x)==ERR ? ERR : winsstr(win,str))
#define  mvwgetstr(win,y,x,str) (wmove(win,y,x)==ERR ? ERR : wgetstr(win,str))
#define  mvwinch(win,y,x)       (wmove(win,y,x)==ERR ? ERR : winch(win))
#define  mvwdelch(win,y,x)      (wmove(win,y,x)==ERR ? ERR : wdelch(win))
#define  mvwinsch(win,y,x,ch)   (wmove(win,y,x)==ERR ? ERR : winsch(win,ch))
#define  mvwdeleteln(win,y,x)   (wmove(win,y,x)==ERR ? ERR : wdeleteln(win))
 
#define  clearok(win,bf)        (win->_clear = bf)
#define  leaveok(win,bf)        (win->_leave = bf)
#define  scrollok(win,bf)       (win->_scroll = bf)
#define  wrapok(win,bf)         (win->_wrap = bf)
 
#define  flushok(win,bf)        (bf ? win->_flags |= _FLUSH : (win->_flags &= ~_FLUSH))
 
#define  getyx(win,y,x)         y = win->_cur_y, x = win->_cur_x
 
 
/*
**  Terminal input mode macros
*/
#define  echo()     (stdkb->_flags &= ~_NOECHO)
#define  noecho()   (stdkb->_flags |=  _NOECHO)
 
#define  raw()      (stdkb->_flags &= ~_NORAW)
#define  noraw()    (stdkb->_flags |=  _NORAW)
 
#define  nl()       (stdkb->_flags &= ~_NONL)
#define  nonl()     (stdkb->_flags |=  _NONL)
 
#define  crmode()   ((stdkb->_flags &= ~_NOCRMODE), nonl())
#define  nocrmode()  (stdkb->_flags |=  _NOCRMODE)
 
 
/*
**  Create 'private' typedefs that are sensitive to pointer size and must
**  use short pointers.  These typedefs are used when refering to these
**  types when in 64 bit pointer context.
*/
#ifndef __WINDOW_PTR32
#   define __WINDOW_PTR32
    typedef WINDOW * __WINDOW_ptr32;
#endif
 
 
/*
**  We are done defining things which must always be short pointers.  If
**  the user has used /pointer_size=short or /pointer_size=long, we will
**  allow long pointers to be used in function calls.
*/
#if __INITIAL_POINTER_SIZE
#   pragma __pointer_size 64
#endif
 
 
/*
**  The DEC C RTL always allocates WINDOW structure in 32 bit memory.
*/
__WINDOW_ptr32 initscr (void);
__WINDOW_ptr32 newwin  (int __numlines, int __numcols, int __begin_y, int __begin_x);
__WINDOW_ptr32 subwin  (WINDOW *__win, int __numlines, int __numcols, int __begin_y, int __begin_x);
 
 
/*
**  The following functions have two interfaces, one for 32 and one for 64 bit
**  pointers.
*/
#if __INITIAL_POINTER_SIZE == 32
#   pragma __pointer_size 32
#endif
 
    char *longname (char *termbuf, char *__name);
 
#if __INITIAL_POINTER_SIZE
#   pragma __pointer_size 32
    char *_longname32 (char *termbuf, char *__name);
 
#   pragma __pointer_size 64
    char *_longname64 (char *termbuf, char *__name);
#endif
 
 
/*
**  Function prototypes
*/
int      box        (WINDOW *__win, char __vert, char __hor);
int      delwin     (WINDOW *__win);
int      endwin     (void);
int      mvwaddstr  (WINDOW *__win, int __vert, int __horz, char *__str );
int      mvwin      (WINDOW *__win, int __st_row, int __st_col);
int      overlay    (WINDOW *__win1, WINDOW *__win2);
int      overwrite  (WINDOW *__win1, WINDOW *__win2);
int      printw     (char *__format_spec, ...);
int      scanw      (char *__format_spec, ...);
int      scroll     (WINDOW *__win);
int      touchwin   (WINDOW *__win);
int      waddch     (WINDOW *__win, char __ch);
int      waddstr    (WINDOW *__win, char *__str);
int      wclear     (WINDOW *__win);
int      wclrattr   (WINDOW *__win, int __attr);
int      wclrtobot  (WINDOW *__win);
int      wclrtoeol  (WINDOW *__win);
int      wdelch     (WINDOW *__win);
int      wdeleteln  (WINDOW *__win);
int      werase     (WINDOW *__win);
int      wgetch     (WINDOW *__win);
int      wgetstr    (WINDOW *__win, char *__str);
char     winch      (WINDOW *__win);
int      winsch     (WINDOW *__win, char __ch);
int      winsertln  (WINDOW *__win);
int      winsstr    (WINDOW *, const char *);   /*  OpenVMS extension  */
int      wmove      (WINDOW *__win, int __y, int __x);
int      wprintw    (WINDOW *__win, char *__format_spec, ...);
int      wrefresh   (WINDOW *__win);
int      wscanw     (WINDOW *__win, char *__format_spec, ...);
int      wsetattr   (WINDOW *__win, int __attr);
int      wstandend  (WINDOW *__win);
int      wstandout  (WINDOW *__win);
 
 
#endif  /*  _VMS_CURSES  */

#ifdef _BSD44_CURSES
/**********************************************************/
/*      Header file for _BSD44_CURSES (Alpha Only)        */
/**********************************************************/
/*                                                        */
/*   Documentation on the 4.4BSD curses package can be    */
/*   found in:                                            */
/*                                                        */
/*     "Screen Updating and Cursor Movement               */
/*      Optimization: A Library Package"                  */
/*                                                        */
/*      by Kenneth C.R.C. Arnold                          */
/*                                                        */
/**********************************************************/
 
/*
** Pointers to termcap fields used by BSD curses package
*/
#define  AE   decc$ga_bsd_ae
#define  AL   decc$ga_bsd_al 
#define  al   decc$ga_bsd_al2
#define  AS   decc$ga_bsd_as
#define  AM   decc$ga_bsd_am 
#define  BC   decc$ga_bsd_bc 
#define  BS   decc$ga_bsd_bs 
#define  BT   decc$ga_bsd_bt 
#define  CA   decc$ga_bsd_ca 
#define  CD   decc$ga_bsd_cd 
#define  CE   decc$ga_bsd_ce 
#define  CL   decc$ga_bsd_cl 
#define  CM   decc$ga_bsd_cm 
#define  CR   decc$ga_bsd_cr 
#define  CS   decc$ga_bsd_cs 
#define  DA   decc$ga_bsd_da 
#define  DB   decc$ga_bsd_db 
#define  DC   decc$ga_bsd_dc 
#define  DL   decc$ga_bsd_dl 
#define  dl   decc$ga_bsd_dl2
#define  DM   decc$ga_bsd_dm 
#define  DO   decc$ga_bsd_do 
#define  ED   decc$ga_bsd_ed 
#define  EI   decc$ga_bsd_ei 
#define  EO   decc$ga_bsd_eo 
#define  GT   decc$ga_bsd_gt 
#define  HC   decc$ga_bsd_hc 
#define  HO   decc$ga_bsd_ho 
#define  HZ   decc$ga_bsd_hz 
#define  IC   decc$ga_bsd_ic 
#define  IM   decc$ga_bsd_im 
#define  IN   decc$ga_bsd_in 
#define  IP   decc$ga_bsd_ip 
#define  K0   decc$ga_bsd_k0 
#define  K1   decc$ga_bsd_k1 
#define  K2   decc$ga_bsd_k2 
#define  K3   decc$ga_bsd_k3 
#define  K4   decc$ga_bsd_k4 
#define  K5   decc$ga_bsd_k5 
#define  K6   decc$ga_bsd_k6 
#define  K7   decc$ga_bsd_k7 
#define  K8   decc$ga_bsd_k8 
#define  K9   decc$ga_bsd_k9 
#define  KD   decc$ga_bsd_kd 
#define  KE   decc$ga_bsd_ke 
#define  KH   decc$ga_bsd_kh 
#define  KL   decc$ga_bsd_kl 
#define  KR   decc$ga_bsd_kr 
#define  KS   decc$ga_bsd_ks 
#define  KU   decc$ga_bsd_ku 
#define  LL   decc$ga_bsd_ll 
#define  MA   decc$ga_bsd_ma 
#define  MB   decc$ga_bsd_mb 
#define  MD   decc$ga_bsd_md
#define  ME   decc$ga_bsd_me
#define  MI   decc$ga_bsd_mi 
#define  MR   decc$ga_bsd_mr
#define  MS   decc$ga_bsd_ms 
#define  NC   decc$ga_bsd_nc 
#define  ND   decc$ga_bsd_nd 
#define  NL   decc$ga_bsd_nl 
#define  NS   decc$ga_bsd_ns 
#define  OS   decc$ga_bsd_os 
#define  PC   decc$ga_bsd_pc 
#define  RC   decc$ga_bsd_rc 
#define  SC   decc$ga_bsd_sc 
#define  SE   decc$ga_bsd_se 
#define  SF   decc$ga_bsd_sf 
#define  sf   decc$ga_bsd_sf2
#define  SO   decc$ga_bsd_so 
#define  SR   decc$ga_bsd_sr 
#define  sr   decc$ga_bsd_sr2
#define  TA   decc$ga_bsd_ta 
#define  TE   decc$ga_bsd_te 
#define  TI   decc$ga_bsd_ti 
#define  UC   decc$ga_bsd_uc 
#define  UE   decc$ga_bsd_ue 
#define  UL   decc$ga_bsd_ul 
#define  UP   decc$ga_bsd_up 
#define  US   decc$ga_bsd_us 
#define  VB   decc$ga_bsd_vb 
#define  VE   decc$ga_bsd_ve 
#define  VS   decc$ga_bsd_vs 
#define  XB   decc$ga_bsd_xb 
#define  XN   decc$ga_bsd_xn 
#define  XS   decc$ga_bsd_xs 
#define  XT   decc$ga_bsd_xt 
#define  XX   decc$ga_bsd_xx 
 
 
/*
**  Possible params to specific termcap fields
*/
#define  AL_PARM      decc$ga_bsd_al_parm 
#define  DL_PARM      decc$ga_bsd_dl_parm 
#define  DOWN_PARM    decc$ga_bsd_down_parm 
#define  LEFT_PARM    decc$ga_bsd_left_parm 
#define  RIGHT_PARM   decc$ga_bsd_right_parm 
#define  UP_PARM      decc$ga_bsd_up_parm 
 
 
/*
**  BSD boolean fields
*/
#define  UPPERCASE    decc$ga_bsd_uppercase 
#define  NONL         decc$ga_bsd_nonl 
 
#define  Def_term     decc$ga_bsd_def_term 
#define  My_term      decc$ga_bsd_my_term
 
#define  __unctrl     decc$ga_bsd__unctrl
#define  __unctrllen  decc$ga_bsd__unctrllen
#define  ttytype      decc$ga_bsd_ttytype
 
 
/*
**  The following #defines and #includes are present for backward
**  compatibility only.  They should not be used in future code.
**
**  START BACKWARD COMPATIBILITY ONLY.
*/
#ifndef _CURSES_PRIVATE
#   define  bool char
#   define  reg register
#   define  _BSD_VA_LIST_ ...
#   define  _puts(s) tputs(s,0,__cputchar)
#   define  _putchar(c) __cputchar(c)
#   define  crmode() cbreak()
#   define  nocrmode() nocbreak()
 
#   ifndef ____U_INT
#   define ____U_INT
    typedef unsigned int __u_int;
#   endif
 
#   if !defined __U_INT && !defined _DECC_V4_SOURCE
#   define __U_INT
    typedef unsigned int u_int;
#   endif
 
 
#endif
 
extern char  GT;         /*  Gtty indicates tabs            */
extern char  NONL;       /*  Term can't hack LF doing a CR  */
extern char  UPPERCASE;  /*  Terminal is uppercase only     */
extern int   My_term;    /*  Use Def_term regardless        */
extern char *Def_term;   /*  Default terminal type          */
 
/*
**  Termcap capabilities
*/
extern char  AM,BS,CA,DA,EO,HC,IN,MI,MS,NC,NS,OS,PC,UL,XB,XN,XT,XS,XX;
 
extern char *AE,*AL,*AS,*BC,*BT,*CD,*CE,*CL,*CM,*CR,*CS,*DC,*DL,*DM,*DO,*ED,*EI,
            *K0,*K1,*K2,*K3,*K4,*K5,*K6,*K7,*K8,*K9,*HO,*IC,*IM,*IP,*KD,*KE,*KH,
            *KL,*KR,*KS,*KU,*LL,*MA,*MB,*MD,*ME,*MR,*ND,*NL,*RC,*SC,*SE,*SF,*SO,
            *SR,*TA,*TE,*TI,*UC,*UE,*UP,*US,*VB,*VS,*VE,*al,*dl,*sf,*sr,
            *AL_PARM,*DL_PARM,*UP_PARM,*DOWN_PARM,*LEFT_PARM,*RIGHT_PARM;
 
/* END BACKWARD COMPATIBILITY ONLY. */
 
 
/*
**  8-bit ASCII characters
*/
#define unctrl(c)      __unctrl[(c) & 0xff]
#define unctrllen(ch)  __unctrllen[(ch) & 0xff]
 
extern char *__unctrl[256];      /* Control strings         */
extern char  __unctrllen[256];   /* Control strings length  */
 
 
/*
**  A window is an array of __LINE structures pointed to by the 'lines'
**  pointer.  A line is an array of __LDATA structures pointed to by
**  the 'line' pointer.
**
**  IMPORTANT:  the __LDATA structure must NOT induce any padding,so
**  if new fields are added -- padding fields with *constant values*
**  should ensure that the compiler will not generate any padding when
**  storing an array of __LDATA structures.  This is to enable
**  consistent use of memcmp,and memcpy for comparing and copying
**  arrays.
*/
typedef struct {
    char ch;     /* the actual character    */
    char attr;   /* attributes of character */
} __LDATA;
 
#define __LDATASIZE (sizeof(__LDATA))
 
#define  A_STANDOUT      0x01    /* For wattron,wattroff,wattrset     */
#define  A_UNDERLINE     0x02
#define  A_REVERSE       0x04
#define  A_BLINK         0x08
#define  A_BOLD          0x10
#define  A_DIM           A_BOLD  /* dim not avaiable, make it bold    */
#define  A_ALTCHARSET    0x20    /* Use alternate character set       */
#define  A_NORMAL        0x00
 
#define  __STANDOUT A_STANDOUT   /* Added characters are standout.    */
 
typedef struct {
    size_t *firstchp, *lastchp;  /* First and last chngd columns ptrs */
    __LDATA *line;               /* Pointer to the line text.         */
    size_t firstch, lastch;      /* First and last changed columns.   */
    __u_int flags;
    __u_int hash;                /* Hash value for the line.          */
} __LINE;
 
#define  __ISDIRTY     0x01      /* Line is dirty.                    */
#define  __ISPASTEOL   0x02      /* Cursor is past end of line        */
#define  __FORCEPAINT  0x04      /* Force a repaint of the line       */
 
 
/* 
**  Although fields within the window structure should never be changed
**  by application code, some of the fields are useful for applications
**  to have read access to.
**
**  BSD 4.4 code removed the "_" from structure member names so for
**  upward compatability, defines of the names including the underscore
**  have been made.
*/
typedef struct __window {
 
    struct __window *nextp;  /* Subwindows list and parent             */
    struct __window *orig;   /*                                        */
    __LINE **lines;          /* Array of pointers to the lines         */
    __LINE  *lspace;         /* line space (for cleanup)               */
    __LDATA *wspace;         /* window space (for cleanup)             */
    size_t begy, begx;       /* Window home                            */
    size_t cury, curx;       /* Current y, x coordinates               */
    size_t maxy, maxx;       /* Maximum values for cury, curx          */
    __u_int flags;
    __u_int w_nodelay;       /* non-blocking used with nodelay routine */
    short ch_off;            /* x offset for firstch/lastch.           */
    char attrs;              /* character attributes for new char      */
                             /* See __LDATA section for valid values   */
} WINDOW;
 
 
/*
**
*/
#define  _begy       begy
#define  _begx       begx
#define  _cury       cury
#define  _curx       curx
#define  _maxy       maxy
#define  _maxx       maxx
#define  _flags      flags
#define  _attrs      attrs
 
 
/*
**  Curses external declarations
*/
extern  WINDOW *     curscr;    /* Current screen         */
extern  WINDOW *     stdscr;    /* Standard screen        */
extern  int          COLS;      /* Columns on the screen  */
extern  int          LINES;     /* Lines on the screen    */
extern  char *       ttytype;   /* Full name of terminal  */
 
 
/*
**
*/
#define  __ENDLINE    0x001      /* End of screen                 */
#define  __FLUSH      0x002      /* Fflush(stdout) after refresh  */
#define  __FULLLINE   0x004      /* Line width = terminal width   */
#define  __FULLWIN    0x008      /* Window is a screen            */
#define  __IDLINE     0x010      /* Insert/delete sequences       */
#define  __SCROLLWIN  0x020      /* Last char will scroll window  */
#define  __SCROLLOK   0x040      /* Scrolling ok                  */
#define  __CLEAROK    0x080      /* Clear on next refresh         */
#define  __WSTANDOUT  0x100      /* Standout (attributes) window  */
#define  __LEAVEOK    0x200      /* If curser left                */ 
 
 
/*
**  Standard screen pseudo functions
**
**  Original BSD 4.4 sources with a check for decc$$scr_is_tty added
**
**  The following non-stdscr functions are defined as macros which use the w
**  form of the functions, passing stdscr as the first argument.
*/
extern unsigned decc$$scr_is_tty;
 
#define  addbytes(s,n)           (!decc$$scr_is_tty ? ERR : __waddbytes(stdscr,s,n,(stdscr->attrs == A_NORMAL) ? 0 : 1))
#define  addch(ch)               (!decc$$scr_is_tty ? ERR : waddch(stdscr,ch))
#define  addnstr(s,n)            (!decc$$scr_is_tty ? ERR : waddnstr(stdscr,s,n))
#define  addstr(s)               (!decc$$scr_is_tty ? ERR : __waddbytes(stdscr,s,strlen(s),(stdscr->attrs == A_NORMAL) ? 0 : 1))
#define  attron(at)              (!decc$$scr_is_tty ? ERR : wattron(stdscr,at))
#define  attroff(at)             (!decc$$scr_is_tty ? ERR : wattroff(stdscr,at))
#define  attrset(at)             (!decc$$scr_is_tty ? ERR : wattrset(stdscr,at))
#define  clear()                 (!decc$$scr_is_tty ? ERR : wclear(stdscr))
#define  clrattr(at)             (!decc$$scr_is_tty ? ERR : wclrattr(stdscr,at))
#define  clrtobot()              (!decc$$scr_is_tty ? ERR : wclrtobot(stdscr))
#define  clrtoeol()              (!decc$$scr_is_tty ? ERR : wclrtoeol(stdscr))
#define  delch()                 (!decc$$scr_is_tty ? ERR : wdelch(stdscr))
#define  deleteln()              (!decc$$scr_is_tty ? ERR : wdeleteln(stdscr))
#define  erase()                 (!decc$$scr_is_tty ? ERR : werase(stdscr))
#define  getch()                 wgetch(stdscr)
#define  getstr(s)               wgetstr(stdscr,s)
#define  inch()                  (!decc$$scr_is_tty ? ERR : winch(stdscr))
#define  insch(ch)               (!decc$$scr_is_tty ? ERR : winsch(stdscr,ch))
 
 
/*
**  Digital only extension to BSD
*/
#define  insstr(s)               (!decc$$scr_is_tty ? ERR : winsstr (stdscr,s))
#define  insertln()              (!decc$$scr_is_tty ? ERR : winsertln(stdscr))
#define  move(y,x)               (!decc$$scr_is_tty ? ERR : wmove(stdscr,y,x))
#define  refresh()               (!decc$$scr_is_tty ? ERR : wrefresh(stdscr))
#define  setattr(at)             (!decc$$scr_is_tty ? ERR : wsetattr(stdscr,at))
#define  standend()              (!decc$$scr_is_tty ? ERR : wstandend(stdscr))
#define  standout()              (!decc$$scr_is_tty ? ERR : wstandout(stdscr))
#define  waddbytes(w,s,n)        (!decc$$scr_is_tty ? ERR : __waddbytes(w,s,n,(w->attrs == A_NORMAL) ? 0 : 1))
#define  waddstr(w,s)            (!decc$$scr_is_tty ? ERR : __waddbytes(w,s,strlen(s),(w->attrs == A_NORMAL) ? 0 : 1))
 
 
/*
**  Standard screen plus movement pseudo functions
*/
#define  mvaddbytes(y,x,s,n)     (!decc$$scr_is_tty ? ERR : mvwaddbytes(stdscr,y,x,s,n))
#define  mvaddch(y,x,ch)         (!decc$$scr_is_tty ? ERR : mvwaddch(stdscr,y,x,ch))
#define  mvaddnstr(y,x,s,n)      (!decc$$scr_is_tty ? ERR : mvwaddnstr(stdscr,y,x,s,n))
#define  mvaddstr(y,x,s)         (!decc$$scr_is_tty ? ERR : mvwaddstr(stdscr,y,x,s))
#define  mvdelch(y,x)            (!decc$$scr_is_tty ? ERR : mvwdelch(stdscr,y,x))
#define  mvgetch(y,x)            (!decc$$scr_is_tty ? ERR : mvwgetch(stdscr,y,x))
#define  mvgetstr(y,x,s)         (!decc$$scr_is_tty ? ERR : mvwgetstr(stdscr,y,x,s))
#define  mvinch(y,x)             (!decc$$scr_is_tty ? ERR : mvwinch(stdscr,y,x))
#define  mvinsch(y,x,c)          (!decc$$scr_is_tty ? ERR : mvwinsch(stdscr,y,x,c))
 
 
/*
**  Digital only extension to BSD
*/
#define  mvinsstr(y,x,s)         (!decc$$scr_is_tty ? ERR : mvwinsstr (stdscr,y,x,s))
#define  mvwaddbytes(w,y,x,s,n)  (wmove(w,y,x) == ERR ? ERR : __waddbytes(w,s,n,(w->attrs == A_NORMAL) ? 0 : 1))
#define  mvwaddch(w,y,x,ch)      (wmove(w,y,x) == ERR ? ERR : waddch(w,ch))
#define  mvwaddnstr(w,y,x,s,n)   (wmove(w,y,x) == ERR ? ERR : waddnstr(w,s,n))
#define  mvwaddstr(w,y,x,s)      (wmove(w,y,x) == ERR ? ERR : __waddbytes(w,s,strlen(s),(w->attrs == A_NORMAL) ? 0 : 1))
#define  mvwdelch(w,y,x)         (wmove(w,y,x) == ERR ? ERR : wdelch(w))
#define  mvwgetch(w,y,x)         (wmove(w,y,x) == ERR ? ERR : wgetch(w))
#define  mvwgetstr(w,y,x,s)      (wmove(w,y,x) == ERR ? ERR : wgetstr(w,s))
#define  mvwinch(w,y,x)          (wmove(w,y,x) == ERR ? ERR : winch(w))
#define  mvwinsch(w,y,x,c)       (wmove(w,y,x) == ERR ? ERR : winsch(w,c))
 
 
/*
**  Digital only extension to BSD
*/
#define  mvwinsstr(w,y,x,s)      (wmove(w,y,x)==ERR ? ERR : winsstr(w,s))
 
 
/*
**  Psuedo functions
*/
#define  clearok(w,bf)           ((bf) ? ((w)->flags |= __CLEAROK) : ((w)->flags &= ~__CLEAROK))
#define  flushok(w,bf)           ((bf) ? ((w)->flags |= __FLUSH) : ((w)->flags &= ~__FLUSH))
#define  getyx(w,y,x)            (y) = (w)->cury,(x) = (w)->curx
#define  leaveok(w,bf)           ((bf) ? ((w)->flags |= __LEAVEOK) : ((w)->flags &= ~__LEAVEOK))
#define  scrollok(w,bf)          ((bf) ? ((w)->flags |= __SCROLLOK) : ((w)->flags &= ~__SCROLLOK))
#define  winch(w)                ((w)->lines[(w)->cury]->line[(w)->curx].ch & 0177)
 
 
/*
**  Create 'private' typedefs that are sensitive to pointer size and must
**  use short pointers.  These typedefs are used when refering to these
**  types when in 64 bit pointer context.
*/
#ifndef __WINDOW_PTR32
#   define __WINDOW_PTR32
    typedef WINDOW * __WINDOW_ptr32;
#endif
 
#ifndef __CHAR_PTR32
#   define __CHAR_PTR32
    typedef char * __char_ptr32;
#endif
 
 
/*
**  Create 'private' typedefs that are sensitive to pointer size and must
**  use long pointers.  These typedefs are used when refering to these
**  types when in 32 bit pointer context.
*/
#if __INITIAL_POINTER_SIZE
#   pragma __pointer_size 64
#endif
 
#ifndef __CHAR_PTR64
#   define __CHAR_PTR64
    typedef char * __char_ptr64;
#endif
 
 
/*
**  Switch back to 32-bit pointer size to define those functions which
**  are resticted to 32-bit pointers.
*/
#if __INITIAL_POINTER_SIZE
#   pragma __pointer_size 32
#endif
 
 
/*
**  The callback routines for tputs is always a 32 bit address.
*/
typedef void (*__tputs_callback) (int);
 
 
/*
**  Define macros for mapping to decc$ entry points
*/
#define  fullname(p1,p2)   decc$bsd_fullname(p1,p2)
#define  getcap(p1)        decc$bsd_getcap(p1)
#define  longname(p1,p2)   decc$bsd_longname(p1,p2)
#define  tgetstr(p1,p2)    decc$bsd_tgetstr(p1,p2)
 
 
/*
**  The following functions are restricted to 32 bit pointers.  If you
**  have a need to use the 64 bit interface, the names of the procedures
**  to call are function prototyped in the 64 bit section and have
**  names of the form decc$_bsd_fullname64.
*/
char  *fullname (char *, char *);
char  *getcap   (char *);
char  *longname (char *, char *);
char  *tgetstr  (__char_ptr64, char **);
 
 
/*
**  We are done defining things which must always be short pointers.  If
**  the user has used /pointer_size=short or /pointer_size=long, we will
**  allow long pointers to be used in function calls.
*/
#if __INITIAL_POINTER_SIZE
#   pragma __pointer_size 64
#endif
 
 
/*
**  Define the 64 bit specific interfaces for those users needing access to
**  them.  There is no "transparent" way to access these.  Compiling with
**  the /pointer_size=64 qualifier does not automatically call these.
*/
#if __INITIAL_POINTER_SIZE
    char  *decc$_bsd_fullname64  (char *, char *);
    char  *decc$_bsd_getcap64    (char *);
    char  *decc$_bsd_longname64  (char *, char *);
    char  *decc$_bsd_tgetstr64   (char *, char **);
#endif
 
 
/*
**  Define macros for mapping to decc$ entry points
*/
#define  __cputchar                decc$bsd__cputchar
#define  __waddbytes(p1,p2,p3,p4)  decc$bsd__waddbytes(p1,p2,p3,p4)
#define  baudrate(p1)              decc$bsd_baudrate(p1)
#define  box(p1,p2,p3)             decc$bsd_box(p1,p2,p3)
#define  cbreak()                  decc$bsd_cbreak()
#define  delwin(p1)                decc$bsd_delwin(p1)
#define  echo()                    decc$bsd_echo()
#define  endwin                    decc$bsd_endwin
#define  erasechar()               decc$bsd_erasechar()
#define  gettmode()                decc$bsd_gettmode()
#define  idlok(p1,p2)              decc$bsd_idlok(p1,p2)
#define  initscr()                 decc$bsd_initscr()
#define  killchar()                decc$bsd_killchar()
#define  mvwin(p1,p2,p3)           decc$bsd_mvwin(p1,p2,p3)
#define  nl()                      decc$bsd_nl()
#define  nocbreak()                decc$bsd_nocbreak()
#define  nodelay(p1,p2)            decc$bsd_nodelay(p1,p2)
#define  noecho()                  decc$bsd_noecho()
#define  nonl()                    decc$bsd_nonl()
#define  noraw()                   decc$bsd_noraw()
#define  overlay(p1,p2)            decc$bsd_overlay(p1,p2)
#define  overwrite(p1,p2)          decc$bsd_overwrite(p1,p2)
#define  raw()                     decc$bsd_raw()
#define  resetty()                 decc$bsd_resetty()
#define  savetty()                 decc$bsd_savetty()
#define  scroll(p1)                decc$bsd_scroll(p1)
#define  setterm(p1)               decc$bsd_setterm(p1)
#define  tgetent(p1,p2)            decc$bsd_tgetent(p1,p2)
#define  tgetflag(p1)              decc$bsd_tgetflag(p1)
#define  tgetnum(p1)               decc$bsd_tgetnum(p1)
#define  tgoto(p1,p2,p3)           decc$bsd_tgoto(p1,p2,p3)
#define  touchwin(p1)              decc$bsd_touchwin(p1)
#define  tputs(p1,p2,p3)           decc$bsd_tputs(p1,p2,p3)
#define  waddch(p1,p2)             decc$bsd_waddch(p1,p2)
#define  wattroff(p1,p2)           decc$bsd_wattroff(p1,p2)
#define  wattron(p1,p2)            decc$bsd_wattron(p1,p2)
#define  wattrset(p1,p2)           decc$bsd_wattrset(p1,p2)
#define  wclear(p1)                decc$bsd_wclear(p1)
#define  wclrattr(p1,p2)           decc$bsd_wclrattr(p1,p2)
#define  wclrtobot(p1)             decc$bsd_wclrtobot(p1)
#define  wclrtoeol(p1)             decc$bsd_wclrtoeol(p1)
#define  wdelch(p1)                decc$bsd_wdelch(p1)
#define  wdeleteln(p1)             decc$bsd_wdeleteln(p1)
#define  werase(p1)                decc$bsd_werase(p1)
#define  wgetch(p1)                decc$bsd_wgetch(p1)
#define  wgetstr(p1,p2)            decc$bsd_wgetstr(p1,p2)
#define  winsch(p1,p2)             decc$bsd_winsch(p1,p2)
#define  winsertln(p1)             decc$bsd_winsertln(p1)
#define  winsstr(p1,p2)            decc$bsd_winsstr(p1,p2)
#define  wmove(p1,p2,p3)           decc$bsd_wmove(p1,p2,p3)
#define  wrefresh(p1)              decc$bsd_wrefresh(p1)
#define  wsetattr(p1,p2)           decc$bsd_wsetattr(p1,p2)
#define  wstandend(p1)             decc$bsd_wstandend(p1)
#define  wstandout(p1)             decc$bsd_wstandout(p1)
 
#define  mvcur(p1,p2,p3,p4)        decc$bsd_mvcur(p1,p2,p3,p4)
#define  newwin(p1,p2,p3,p4)       decc$bsd_newwin(p1,p2,p3,p4)
#define  subwin(p1,p2,p3,p4,p5)    decc$bsd_subwin(p1,p2,p3,p4,p5)
#define  touchline(p1,p2,p3,p4)    decc$bsd_touchline(p1,p2,p3,p4)
#define  touchoverlap(p1,p2)       decc$bsd_touchoverlap(p1,p2)
#define  waddnstr(p1,p2,p3)        decc$bsd_waddnstr(p1,p2,p3)
 
 
/*
**  Define macros for mapping to decc$ entry points (floating point specific)
*/
#if __X_FLOAT
#   if __G_FLOAT         /* g-float */
#      define printw     decc$gxbsd_printw
#      define scanw      decc$gxbsd_scanw
#      define wprintw    decc$gxbsd_wprintw
#      define wscanw     decc$gxbsd_wscanw
#      define mvprintw   decc$gxbsd_mvprintw
#      define mvwprintw  decc$gxbsd_mvwprintw
#      define mvscanw    decc$gxbsd_mvscanw 
#      define mvwscanw   decc$gxbsd_mvwscanw
#   elif __IEEE_FLOAT    /* ieee-float */
#      define printw     decc$txbsd_printw
#      define scanw      decc$txbsd_scanw
#      define wprintw    decc$txbsd_wprintw
#      define wscanw     decc$txbsd_wscanw
#      define mvprintw   decc$txbsd_mvprintw
#      define mvwprintw  decc$txbsd_mvwprintw
#      define mvscanw    decc$txbsd_mvscanw 
#      define mvwscanw   decc$txbsd_mvwscanw
#   else                 /* d-float */
#      define printw     decc$dxbsd_printw
#      define scanw      decc$dxbsd_scanw
#      define wprintw    decc$dxbsd_wprintw
#      define wscanw     decc$dxbsd_wscanw
#      define mvprintw   decc$dxbsd_mvprintw
#      define mvwprintw  decc$dxbsd_mvwprintw
#      define mvscanw    decc$dxbsd_mvscanw 
#      define mvwscanw   decc$dxbsd_mvwscanw
#   endif
#else
#   if __G_FLOAT         /* g-float */
#      define printw     decc$bsd_printw
#      define scanw      decc$bsd_scanw
#      define wprintw    decc$bsd_wprintw
#      define wscanw     decc$bsd_wscanw
#      define mvprintw   decc$bsd_mvprintw
#      define mvwprintw  decc$bsd_mvwprintw
#      define mvscanw    decc$bsd_mvscanw 
#      define mvwscanw   decc$bsd_mvwscanw
#   elif __IEEE_FLOAT    /* ieee-float */
#      define printw     decc$tbsd_printw
#      define scanw      decc$tbsd_scanw
#      define wprintw    decc$tbsd_wprintw
#      define wscanw     decc$tbsd_wscanw
#      define mvprintw   decc$tbsd_mvprintw
#      define mvwprintw  decc$tbsd_mvwprintw
#      define mvscanw    decc$tbsd_mvscanw 
#      define mvwscanw   decc$tbsd_mvwscanw
#   else                 /* d-float */
#      define printw     decc$dbsd_printw
#      define scanw      decc$dbsd_scanw
#      define wprintw    decc$dbsd_wprintw
#      define wscanw     decc$dbsd_wscanw
#      define mvprintw   decc$dbsd_mvprintw
#      define mvwprintw  decc$dbsd_mvwprintw
#      define mvscanw    decc$dbsd_mvscanw 
#      define mvwscanw   decc$dbsd_mvwscanw
#   endif
#endif
 
 
/*
**  Public function prototypes
*/
void   __cputchar      (int);
int    __waddbytes     (WINDOW *, const char *, intint);
 
 
/*
**  The DEC C RTL always allocates WINDOW structure in 32 bit memory.
*/
__WINDOW_ptr32 initscr (void);
__WINDOW_ptr32 newwin  (intintintint);
__WINDOW_ptr32 subwin  (WINDOW *, intintintint);
 
 
/*
**  The return values of these functions are pointers to character strings
**  allocated by the CRTL and are always 32 bit addresses.
*/
__char_ptr32 wstandend (WINDOW *);
__char_ptr32 wstandout (WINDOW *);
__char_ptr32 tgoto     (char *, intint);
 
 
/*
**  Public function prototypes
*/
int      baudrate      (void);
int      box           (WINDOW *, intint);
int      cbreak        (void);
int      delwin        (WINDOW *);
int      erasechar     (void);
int      echo          (void);
int      endwin        (void);
int      gettmode      (void);
void     idlok         (WINDOW *, int);
int      killchar      (void);
int      mvcur         (intintintint);
int      mvprintw      (intintconst char *, ...);
int      mvscanw       (intintconst char *, ...);
int      mvwin         (WINDOW *, intint);
int      mvwprintw     (WINDOW *, intintconst char *, ...);
int      mvwscanw      (WINDOW *, intintconst char *, ...);
int      nl            (void);
int      nocbreak      (void);
int      nodelay       (WINDOW *, const int);      /*  OpenVMS extension  */
int      noecho        (void);
int      nonl          (void);
int      noraw         (void);
int      overlay       (WINDOW *, WINDOW *);
int      overwrite     (WINDOW *, WINDOW *);
int      printw        (const char *, ...);
int      raw           (void);
int      resetty       (void);
int      savetty       (void);
int      scanw         (const char *, ...);
int      scroll        (WINDOW *);
int      setterm       (char *);
int      touchline     (WINDOW *, intintint);
int      touchoverlap  (WINDOW *, WINDOW *);
int      touchwin      (WINDOW *);
int      waddch        (WINDOW *, int);
int      waddnstr      (WINDOW *, const char *, int);
int      wclear        (WINDOW *);
int      wclrtobot     (WINDOW *);
int      wclrtoeol     (WINDOW *);
int      wdelch        (WINDOW *);
int      wdeleteln     (WINDOW *);
int      werase        (WINDOW *);
int      wgetch        (WINDOW *);
int      wgetstr       (WINDOW *, char *);
int      winsch        (WINDOW *, int);
int      winsstr       (WINDOW *, const char *);   /*  OpenVMS extension  */
int      winsertln     (WINDOW *);
int      wmove         (WINDOW *, intint);
int      wprintw       (WINDOW *, const char *, ...);
int      wrefresh      (WINDOW *);
int      wscanw        (WINDOW *, const char *, ...);
int      wclrattr      (WINDOW *, int);
int      wsetattr      (WINDOW *, int);
int      wattron       (WINDOW *, int);
int      wattroff      (WINDOW *, int);
int      wattrset      (WINDOW *, int);
 
 
/*
**  Termcap functions
*/
int      tgetent       (char *, char *);
int      tgetnum       (char *);
int      tgetflag      (char *);
void     tputs         (char *, int, __tputs_callback);
 
 
/*
**  The following routines, savetty and resetty are left in only as stubs.
*/
int resetty();
int savetty();
 
#endif  /*  _BSD44_CURSES  */

/*
**  Restore the users pointer context
*/
#if __INITIAL_POINTER_SIZE
#   pragma __pointer_size __restore
#endif
 
#ifdef __cplusplus
    }
#endif
 
#pragma __message __restore
#pragma __member_alignment __restore
#pragma __standard
#endif /* __CURSES_LOADED */