curses 1.6.1 → 1.7.0

data/vendor/PDCursesMod/tests/vt0.c

@@ -0,0 +1,472 @@
+#define _XOPEN_SOURCE 600
+#include <stdio.h>
+#include <stdlib.h>
+#include <assert.h>
+#include <string.h>
+#include <unistd.h>
+#include <ctype.h>
+#include <errno.h>
+#include <fcntl.h>
+#include <termios.h>
+#include <sys/types.h>
+#include <sys/ioctl.h>
+#include <sys/wait.h>
+#include "curses.h"
+#include "../common/xlates.h"
+
+/* (Very) primitive *nix terminal emulator using PDCursesMod.  Could
+use PDCurses instead,  with minor changes required for color handling.
+Other implementations of curses would probably work as well.
+
+   We set up a pseudoterminal (pty).  Much of this comes from
+
+https://learning.oreilly.com/library/view/the-linux-programming/9781593272203/xhtml/ch64.xhtml
+
+   In this program,  we start a child process (by default,  /bin/bash -i).
+The parent process connects to its stdin and stdout,  initializes curses,
+and enters a loop.  If a character is received via getch( ),  it's
+written to the child's stdin.  If characters are read from the child's
+stdout,  we add them to the screen via addch( ).
+
+   Note,  too,  that this is _not_ a full-fledged terminal emulator
+(though I think it could be turned into one).  It handles the escape
+sequence for setting the window title and a few escape sequences to
+delete characters,  set colors,  and so on.  You could call this a VT0
+emulator... hence the file name.
+
+   It works decently on SDLn,  x11new,  and Linux framebuffer/DRM.
+
+   I could imagine something similar allowing us to build a Windows console.
+*/
+
+int     PDC_mbtowc(wchar_t *, const char *, size_t);
+
+/* Many VTn control sequences have a series of integer parameters,  separated
+by colons or semicolons.  get_param( ) evaluates and returns one such parameter,
+advancing the pointer to the next parameter (if any),  and returning -1 if
+we've run out of parameters (or hit an error).        */
+
+static int get_param( const char **iptr)
+{
+   const char *tptr = *iptr;
+   int rval;
+
+   if( !isdigit( *tptr))
+      rval = -1;
+   else
+      {
+      rval = *tptr++ - '0';
+      while( isdigit( *tptr))
+         rval = rval * 10 + *tptr++ - '0';
+      if( *tptr == ':' || *tptr == ';')
+         tptr++;
+      }
+   *iptr = tptr;
+   return( rval);
+}
+
+static int _get_color_idx( const int ival)
+{
+   assert( ival >= 0 && ival < 8);
+#if COLOR_RED == 1
+   return( ival);
+#else                      /* bits are in reversed order */
+   return( ((ival & 1) << 2) | (ival & 2) | (ival >> 2));
+#endif
+}
+
+static int verbose = 0;
+
+int create_term( const char* szCommand, const char **args,
+                 const char **environ)
+{
+   const int master_fd = posix_openpt( O_RDWR | O_NOCTTY);
+   int pid_child;
+
+   if( master_fd < 0)
+      {
+      perror( "couldn't open pseudoterminal");
+      return -1;
+      }
+
+   if( -1 == grantpt( master_fd) || -1 == unlockpt( master_fd))
+      {
+      close( master_fd);
+      return -1;
+      }
+
+   pid_child = fork();
+   if( !pid_child)    /* child continues here */
+      {
+      char *name = ptsname( master_fd);
+      int term_fd;
+      struct termios term;
+
+      if (setsid() == -1)
+         return( -1);
+      term_fd = open( name, O_RDWR);
+      if( -1 == term_fd)
+         return( -2);
+#ifdef TIOCSCTTY                 /* acquire controlling tty on BSD */
+      if (ioctl( term_fd, TIOCSCTTY, 0) == -1)
+         return( -3);
+#endif
+
+      tcgetattr( term_fd, &term);
+      term.c_oflag &= ~OPOST;
+      term.c_iflag &= ~ICRNL;
+      tcsetattr( term_fd, TCSANOW, &term);
+
+      /* redirect stdin,  stdout,  stderr  */
+      if( -1 == dup2( term_fd, STDIN_FILENO)
+           || -1 == dup2( term_fd, STDOUT_FILENO)
+           || -1 == dup2( term_fd, STDERR_FILENO))
+         exit(errno);
+
+      execve(szCommand, (char * const *) args, (char * const *)environ);
+
+      /* if we get here at all, an error occurred, but we are */
+      /* in the child process, so just exit                   */
+      perror( "Child process failed");
+      exit( -1);
+      }
+  else if( pid_child > 0)        /* parent continues here */
+      {
+      int wait_status;
+      SCREEN *screen_pointer = newterm(NULL, stdout, stdin);
+      struct winsize ws;
+
+      /* close unused file descriptors, these are for child only : */
+      fcntl( master_fd, F_SETFL, O_NONBLOCK);
+
+      nocbreak( );
+      noecho( );
+      clear( );
+      keypad(stdscr, TRUE);
+      start_color( );
+      use_default_colors( );
+      addstr( "Welcome to PDCursesModTerm!\n");
+      setbuf( stdout, NULL);
+      raw( );
+      scrollok( stdscr, TRUE);
+      refresh( );
+      timeout( 20);
+      ws.ws_row = ws.ws_col = 0;
+
+      while( waitpid( pid_child, &wait_status, WNOHANG) >= 0)
+         {
+         char nChar;
+         int ch;
+
+         if( ws.ws_row != LINES ||  ws.ws_col != COLS)
+            {
+            ws.ws_row = LINES;
+            ws.ws_col = COLS;
+            ioctl( master_fd, TIOCSWINSZ, &ws);
+            }
+         while( 1 == read( master_fd, &nChar, 1))
+            {
+            if( nChar != 27)
+               {
+               static int buffsize = 0;
+
+               if( !(nChar & 0x80))
+                  {
+                  if( nChar != 7)      /* Ctrl-G = 'bell' */
+                     addch( nChar);
+                  buffsize = 0;
+                  }
+               else
+                  {
+                  static char utf8_bytes[5];
+                  wchar_t result;
+
+                  assert( buffsize < 5);
+                  utf8_bytes[buffsize++] = nChar;
+                  if( PDC_mbtowc( &result, utf8_bytes, buffsize) > 0)
+                     {
+                     addch( (chtype)result);
+                     buffsize = 0;
+                     }
+                  }
+               }
+            else if( 1 == read( master_fd, &nChar, 1))
+               {
+               char buff[200];
+               size_t i = 0;
+
+               switch( nChar)
+                  {
+                  case '[' :            /* Control Sequence Introducer (CSI) */
+                     {
+                     while( i < sizeof( buff) - 1
+                            && 1 == read( master_fd, buff + i, 1))
+                        {
+                        i++;
+                        if( buff[i - 1] >= '@')    /* valid CSI sequence */
+                           {
+                           int param = atoi( buff + ((*buff == '?') ? 1 : 0));
+
+                           buff[i] = '\0';
+                           switch( buff[i - 1])
+                              {
+                              case 'h':
+                                 if( *buff == '?')
+                                    switch( param)
+                                       {
+                                       case 47:   /* use alt screen buff */
+                                             /* should actually save current screen... */
+                                           scrollok( stdscr, FALSE);
+                                           break;
+                                       }
+                                 break;
+                              case 'l':
+                                 if( *buff == '?')
+                                    switch( param)
+                                       {
+                                       case 47:   /* use normal screen buff */
+                                           clear( );
+                                           move( 0, 0);
+                                           scrollok( stdscr, TRUE);
+                                           break;
+                                       }
+                                 break;
+                              case 'H':
+                                 {
+                                 int row = 1, col = 1;
+
+                                 sscanf( buff, "%d;%d", &row, &col);
+                                 move( row - 1, col - 1);
+                                 }
+                                 break;
+                              case 'G':         /* cursor absolute posn */
+                              case 'C':         /* cursor forward */
+                              case 'D':         /* cursor backward */
+                                 {
+                                 int col = -1;
+
+                                 if( !param)
+                                    param = 1;
+                                 if( buff[i - 1] == 'G')
+                                    col = param - 1;
+                                 else if( buff[i - 1] == 'C')
+                                    col = getcurx( stdscr) + param;
+                                 else if( buff[i - 1] == 'D')
+                                    col = getcurx( stdscr) - param;
+                                 if( col < 0)
+                                    col = 0;
+                                 else if( col > getmaxx( stdscr) - 1)
+                                    col = getmaxx( stdscr) - 1;
+                                 move( getcury( stdscr), col);
+                                 }
+                                 break;
+                              case 'K':
+                                 clrtoeol( );
+                                 break;
+                              case 'J':
+                                 switch( buff[i - 2])
+                                    {
+                                    case '1':
+                                       /* erase above... TBD */
+                                       break;
+                                    case '2':
+                                       clear( );
+                                       break;
+                                    default:
+                                       clrtobot( );
+                                       break;
+                                    }
+                                 break;
+                              case 'P':
+                              case 'X':
+                                 {
+                                 if( param < 1)
+                                    param = 1;
+                                 while( param--)
+                                    delch( );
+                                 }
+                                 break;
+                              case 'm':       /* color(s)/attribute(s) */
+                                 {
+                                 int ival;
+                                 const char *tptr = buff;
+                                 static int fg = -1, bg = -1;
+                                 const int old_bg = bg, old_fg = fg;
+
+                                 if( *buff == 'm')
+                                    strcpy( buff, "0m");
+                                 while( (ival = get_param( &tptr)) >= 0)
+                                    {
+                                    const attr_t att[9] = { A_BOLD, A_DIM, A_ITALIC,
+                                                A_UNDERLINE, A_BLINK, 0, A_REVERSE,
+                                                A_INVIS, A_STRIKEOUT };
+
+                                    if( !ival)
+                                       {
+                                       attrset( 0);
+                                       fg = bg = -1;
+                                       }
+                                    else if( ival < 10)
+                                       attron( att[ival - 1]);
+                                    else if( ival < 22)
+                                       ;            /* shouldn't happen */
+                                    else if( ival < 30)
+                                       attroff( att[ival - 21]);
+                                    else if( ival < 38)
+                                       fg = _get_color_idx( ival - 30);
+                                    else if( ival == 38 || ival == 48)   /* true-color handling */
+                                       {
+                                       const int val2 = get_param( &tptr);
+                                       const int val3 = get_param( &tptr);
+                                       int new_idx = -1;
+
+                                       if( val2 == 5 && val3 >= 0)
+                                          new_idx = val3;   /* color selected by index */
+                                       else if( val2 == 2 && val3 >= 0)
+                                          {
+                                          const int val4 = get_param( &tptr);
+                                          const int val5 = get_param( &tptr);
+
+                                          new_idx = val3  | (val4 << 8) | (val5 << 16);
+                                          new_idx += 256;
+                                          }
+                                       if( new_idx >= 0)
+                                          {
+                                          if( ival == 38)
+                                             fg = new_idx;
+                                          else
+                                             bg = new_idx;
+                                          }
+                                       }
+                                    else if( ival == 39)
+                                       fg = -1;            /* foreground to default */
+                                    else if( ival < 48)
+                                       bg = _get_color_idx( ival - 40);
+                                    else if( ival == 49)
+                                       bg = -1;            /* foreground to default */
+                                    }
+                                 if( fg != old_fg || bg != old_bg)
+                                    {
+                                    const int pair_idx = (fg == -1 && bg == -1) ? 0 :
+                                                 alloc_pair( fg, bg);
+
+                                    color_set( pair_idx, NULL);
+                                    }
+                                 }
+                                 break;
+                              default:
+                                 if( verbose)
+                                    fprintf( stderr, "Unused CSI '%s'\n", buff);
+                                 break;
+                              }
+                              break;
+                           i = 0;      /* reset for another possible sequence */
+                           }
+                        }
+                     }
+                     break;
+                  case ']' :            /* Operating System Command (OSC) */
+                     if( 1 == read( master_fd, &nChar, 1))
+                        {
+                        switch( nChar)
+                           {
+                           case '0':      /* set window/icon title */
+                           case '1':      /* set icon label */
+                           case '2':      /* set window title */
+                              if( 1 == read( master_fd, &nChar, 1) && nChar == ';')
+                                 {
+                                 char title[255];
+
+                                 while( i < sizeof( title) &&
+                                           1 == read( master_fd, title + i, 1))
+                                    if( '\a' == title[i])
+                                       {
+                                       title[i] = '\0';
+                                       PDC_set_title( title);
+                                       break;
+                                       }
+                                    else
+                                       i++;
+                                 }
+                               break;
+                           default:
+                               if( verbose)
+                                  fprintf( stderr, "Unused OSC\n");
+                               while( 1 == read( master_fd, &nChar, 1))
+                                 ;
+                               break;
+                           }
+                        }
+                     break;
+                  case '(':         /* designate character set : not used yet */
+                     if( read( master_fd, &nChar, 1) == 1)
+                        if( nChar == '%' || nChar == '"' || nChar == '&')
+                           {
+                           int n_read = read( master_fd, &nChar, 1);
+
+                           assert( 1 == n_read);
+                           }
+                     if( verbose)
+                        fprintf( stderr, "Charset '%c' (not used)\n", nChar);
+                     break;
+                  default:
+                     break;
+                  }
+               }
+            }
+         refresh( );
+         while( ERR != (ch = getch( )))
+            {
+            if( ch == KEY_BACKSPACE)
+               ch = 8;
+            if( ch > 0 && ch < 127)
+               {
+               nChar = (char)ch;
+               if( !write( master_fd, &nChar, 1))
+                  exit( -1);
+               }
+            else for( size_t i = 0; i < sizeof( xlates) / sizeof( xlates[0]); i++)
+               if( xlates[i].key_code == ch)
+                  {
+                  nChar = 27;
+                  if( !write( master_fd, &nChar, 1))
+                     exit( -1);
+                  if( !write( master_fd, xlates[i].xlation, strlen( xlates[i].xlation)))
+                     exit( -1);
+                  break;
+                  }
+            }
+         }
+
+      endwin();
+                             /* Not really needed,  but ensures Valgrind  */
+      delscreen( screen_pointer);          /* says all memory was freed */
+      }
+   else                   /* pid_child < 0;  the fork failed */
+      {
+      }
+  return pid_child;
+}
+
+
+int main( int argc, const char **argv)
+{
+   extern const char **environ;
+
+   if( argc > 1 && !strcmp( argv[1], "-d"))
+      {
+      verbose = 1;
+      argv[1] = NULL;
+      argv++;
+      argc--;
+      }
+   if( argc < 2)
+      {
+      static const char *arguments[4] = { NULL, "/bin/bash", "-i", NULL };
+
+      argv = arguments;
+      }
+   create_term( argv[1], &argv[1], environ);
+
+   return( 0);
+}

data/vendor/PDCursesMod/vt/CMakeLists.txt

@@ -0,0 +1,35 @@
+cmake_minimum_required(VERSION 3.11)
+
+if(NOT CMAKE_BUILD_TYPE)
+    set(CMAKE_BUILD_TYPE "MinSizeRel" CACHE STRING "Choose the type of build, options are: Debug, Release, or MinSizeRel." FORCE)
+    message(STATUS "No build type specified, defaulting to MinSizeRel.")
+endif()
+
+PROJECT(vt VERSION "${PROJECT_VERSION}" LANGUAGES C)
+
+INCLUDE(project_common)
+
+if(DOS)
+    string(APPEND CMAKE_C_FLAGS " -DDOS")
+endif()
+
+if(WATCOM)
+    if(WATCOM_DOS16)
+        string(APPEND CMAKE_C_FLAGS " -ml")  # memory model: options are large (-ml), memdium (-mm), small (-ms)
+    else()
+        string(APPEND CMAKE_C_FLAGS " -mf")  # memory model: options are flat (-mf), large (-ml), memdium (-mm), small (-ms)
+    endif()
+endif()
+
+demo_app(../demos firework)
+demo_app(../demos ozdemo)
+demo_app(../demos newtest WIN32)
+demo_app(../demos ptest)
+demo_app(../demos rain)
+demo_app(../demos testcurs)
+demo_app(../demos tuidemo)
+demo_app(../demos worm)
+demo_app(../demos xmas)
+
+
+SET(CPACK_COMPONENTS_ALL applications)

data/vendor/PDCursesMod/vt/Makefile

@@ -0,0 +1,204 @@
+# GNU MAKE Makefile for PDCurses library for VT
+#
+# Usage: [g]make [DEBUG=Y] [WIDE=Y] [UTF8=Y] [LIBNAME=(name)]
+#                [DLLNAME=(name)] [target]
+#
+# where target can be any of:
+# [all|demos|libpdcurses.a|testcurs]...
+
+O = o
+
+ifndef PDCURSES_SRCDIR
+	PDCURSES_SRCDIR = ..
+endif
+
+osdir		= $(PDCURSES_SRCDIR)/vt
+common		= $(PDCURSES_SRCDIR)/common
+
+include $(common)/libobjs.mif
+
+RM		= rm -f
+
+CFLAGS  = -Wall -Wextra -pedantic -Werror
+ifeq ($(DEBUG),Y)
+	CFLAGS  += -g -DPDCDEBUG
+else
+	CFLAGS  += -O2
+endif
+
+ifeq ($(DOS),Y)
+	CFLAGS	+= -DDOS
+	E = .exe
+	RM = del
+endif
+
+ifeq ($(UTF8),Y)
+	CFLAGS	+= -DPDC_FORCE_UTF8
+else
+	ifeq ($(WIDE),Y)
+		CFLAGS	+= -DPDC_WIDE
+	endif
+endif
+
+ifdef CHTYPE_32
+	CFLAGS += -DCHTYPE_32
+endif
+
+ifdef CHTYPE_16
+	CFLAGS += -DCHTYPE_16
+endif
+
+ifdef _w64
+	PREFIX  = x86_64-w64-mingw32-
+	IS_WIN = Y
+endif
+
+ifdef _w32
+	PREFIX  = i686-w64-mingw32-
+	IS_WIN = Y
+endif
+
+ifdef _a64
+	PREFIX  = aarch64-w64-mingw32-
+	IS_WIN = Y
+endif
+
+ifeq ($(OS),Windows_NT)
+	IS_WIN = Y
+	RM = cmd /c del
+endif
+
+ifeq ($(IS_WIN),Y)
+	E = .exe
+endif
+
+LIBNAME=libpdcurses
+DLLNAME=pdcurses
+
+LIBFLAGS = rv
+LIBCURSES	= $(LIBNAME).a
+CC	= $(PREFIX)gcc
+LIBEXE = $(PREFIX)ar
+STRIP	= $(PREFIX)strip
+
+ifeq ($(shell uname -s),FreeBSD)
+	CC = cc
+endif
+
+TARGET_TRIPLE := $(subst -, ,$(shell $(CC) -dumpmachine))
+TARGET_ARCH   := $(word 1,$(TARGET_TRIPLE))
+TARGET_OS     := $(word 3,$(TARGET_TRIPLE))
+
+ifeq      ($(TARGET_OS),mingw32)
+else ifeq ($(TARGET_OS),cygwin)
+else ifeq ($(TARGET_OS),msdosdjgpp)
+	CFLAGS += -DDOS
+	E = .exe
+else
+	CFLAGS += -fPIC
+endif
+
+ifeq ($(DLL),Y)
+	ifeq ($(E),.exe)
+		CFLAGS += -DPDC_DLL_BUILD
+		LIBCURSES	= $(DLLNAME).dll
+		LIBEXE = $(CC)
+		LIBFLAGS = -Wl,--out-implib,$(LIBNAME).a -shared -o
+		LIBSADDED = -lwinmm
+	else
+		ifeq ($(shell uname -s),Darwin)
+			DLL_SUFFIX = .dylib
+		else
+			DLL_SUFFIX = .so
+		endif
+		LIBEXE = $(CC)
+		LIBFLAGS = -shared -o
+		LIBCURSES = lib$(DLLNAME)$(DLL_SUFFIX)
+	endif
+else
+	ifeq ($(IS_WIN),Y)
+		EXELIBS = -lwinmm
+	endif
+endif
+
+BUILD		= $(CC) $(CFLAGS) -I$(PDCURSES_SRCDIR)
+
+LINK		= $(CC)
+LDFLAGS		= $(LIBCURSES)
+RANLIB		= $(PREFIX)ranlib
+
+.PHONY: all libs clean demos tests
+
+all:	libs
+
+libs:	$(LIBCURSES)
+
+clean:
+	-$(RM) *.o trace $(LIBCURSES) $(DEMOS) $(TESTS)
+
+demos:	libs $(DEMOS)
+ifneq ($(DEBUG),Y)
+	$(STRIP) $(DEMOS)
+endif
+
+tests:	libs $(TESTS)
+ifneq ($(DEBUG),Y)
+	$(STRIP) $(TESTS)
+endif
+
+$(LIBCURSES) : $(LIBOBJS) $(PDCOBJS)
+	$(LIBEXE) $(LIBFLAGS) $@ $? $(LIBSADDED)
+ifeq ($(LIBCURSES),$(LIBNAME).a)
+	-$(RANLIB) $@
+endif
+
+$(LIBOBJS) $(PDCOBJS) : $(PDCURSES_HEADERS)
+$(DEMOS) : $(PDCURSES_CURSES_H) $(LIBCURSES)
+$(TESTS) : $(PDCURSES_CURSES_H) $(LIBCURSES)
+tui.o tuidemo.o : $(PDCURSES_CURSES_H)
+terminfo.o : $(TERM_HEADER)
+panel.o ptest: $(PANEL_HEADER)
+
+$(LIBOBJS) : %.o: $(srcdir)/%.c
+	$(BUILD) -c $<
+
+$(PDCOBJS) : %.o: $(osdir)/%.c
+	$(BUILD) -c $<
+
+$(DEMOS_EXCEPT_TUIDEMO): %$(E): $(demodir)/%.c
+	$(BUILD) $(DEMOFLAGS) -o$@ $< $(LDFLAGS) $(EXELIBS)
+
+$(TESTS): %$(E): $(testdir)/%.c
+	$(BUILD) $(DEMOFLAGS) -o$@ $< $(LDFLAGS) $(EXELIBS)
+
+tuidemo$(E) : tuidemo.o tui.o
+	$(LINK) tui.o tuidemo.o -o $@ $(LDFLAGS) $(EXELIBS)
+
+tui.o: $(demodir)/tui.c $(demodir)/tui.h
+	$(BUILD) -c $(DEMOFLAGS) $(demodir)/tui.c
+
+tuidemo.o: $(demodir)/tuidemo.c
+	$(BUILD) -c $(DEMOFLAGS) $(demodir)/tuidemo.c
+
+configure :
+	$(CC) $(CFLAGS) -o config_curses$(E) $(common)/config_curses.c
+ifdef PREFIX
+	wine config_curses$(E) -v -d.. $(CFLAGS)
+else
+	./config_curses$(E) -v -d.. $(CFLAGS)
+endif
+	rm config_curses$(E)
+
+include $(demodir)/nctests.mif
+
+install:
+ifneq ($(OS),Windows_NT)
+	cp lib$(DLLNAME).so /usr/local/lib
+	ldconfig /usr/local/lib
+endif
+
+uninstall:
+ifneq ($(OS),Windows_NT)
+	$(RM) /usr/local/lib/lib$(DLLNAME).so
+	ldconfig /usr/local/lib
+endif