Initial import of the CDE 2.1.30 sources from the Open Group.

cde/programs/dtterm/tests/shared/Imakefile

@@ -0,0 +1,58 @@
+XCOMM $XConsortium: Imakefile /main/8 1996/10/09 14:10:48 drk $
+
+       INCLUDES = -I. -I$(DTINCLUDESRC) 
+LOCAL_INCLUDES  = -I$(TOP)/lib/
+LOCAL_LIBRARIES = $(SYNLIB) $(XEXT) $(XLIB)
+SYS_LIBRARIES = -lm
+
+
+EXTRA_DEFINES = -DLOG -DSYNLIB
+
+XCOMMifdef HPArchitecture
+EXTRA_DEFINES = -DLOG -DSYNLIB
+#endif
+#if defined(HPOSFArchitecture)
+#endif
+
+#if defined(ApolloArchitecture)
+EXTRA_DEFINES = -Dapollo -D_CMDINV
+#if defined(SHLIB)
+   LOCAL_LIBRARIES = -A inlib,$(XLIB)
+#endif
+#endif
+
+#if defined(SunArchitecture)
+SYS_LIBRARIES = -lm -ldl -lgen -lC
+#endif
+
+#if defined(USLArchitecture)
+SYS_LIBRARIES = -lm -ldl -lgen
+#endif
+
+#if defined(UXPArchitecture)
+SYS_LIBRARIES = -lm -ldl -lgen
+#endif
+
+SRCS = synfunc.c \
+       esclib.c \
+       qalib.c
+       
+OBJS = synfunc.o \
+       esclib.o \
+       qalib.o
+
+NormalLibraryObjectRule()
+
+
+NormalLibraryTarget(termtest,$(OBJS))
+
+
+saber_src: $(SRCS) 
+	XCOMM setopt load_flags $(CFLAGS)
+        XCOMM load $(SRCS) $(LOCAL_LIBRARIES)
+
+unsaber_src:
+        XCOMM unload $(SRCS)
+
+
+

cde/programs/dtterm/tests/shared/README

@@ -0,0 +1,3 @@
+/* $XConsortium: README /main/2 1996/07/15 14:29:27 drk $ */
+
+

cde/programs/dtterm/tests/shared/common.h

@@ -0,0 +1,7 @@
+/* $XConsortium: common.h /main/3 1995/10/31 11:59:55 rswiston $ */
+#define  NULLCHAR         '\0'
+#define  BLANK            ' '
+
+typedef enum {
+   DECModeSet=1, DECModeReset=2, DECModeSave=3, DECModeRestore=4
+} DECModeType;

cde/programs/dtterm/tests/shared/escbase.h

@@ -0,0 +1,104 @@
+/* $XConsortium: escbase.h /main/3 1995/10/31 12:00:08 rswiston $ */
+
+/** ANSI Escape sequences */
+#define  HOME_UP              "\033[H"
+
+#define  ERASE_FROM_CUR       "\033[J"
+#define  ERASE_TO_CUR         "\033[1J"
+#define  ERASE_ALL            "\033[2J"
+#define  CLEAR_DISP           ERASE_ALL
+#define  ERASE_LN_FROM_CUR    "\033[K"
+#define  ERASE_LN_TO_CUR      "\033[1K"
+#define  ERASE_LN_ALL         "\033[2K"
+#define  ERASE_N_CHAR         "\033[%dX"
+
+#define  CURSOR_UP            "\033[A"
+#define  CURSOR_N_UP          "\033[%dA"
+#define  CURSOR_DOWN          "\033[B"
+#define  CURSOR_N_DOWN        "\033[%dB"
+#define  CURSOR_N_FORW        "\033[%dC"
+#define  CURSOR_N_BACK        "\033[%dD"
+#define  GOTO_X_Y             "\033[%d;%dH"
+#define  GOTO_X_Y_HVP         "\033[%d;%df"
+#define  INDEX                "\033D"
+#define  REVERSEINDEX         "\033M"
+#define  NEXTLINE             "\033E"
+#define  CURSOR_N_PREV_LINE   "\033[%dF"
+#define  CURSOR_N_COLUMN      "\033[%dG"
+
+
+#define  INSERT_N_LINE        "\033[%dL"
+#define  INSERT_N_BLANK       "\033[%d@"
+#define  DELETE_N_LINE        "\033[%dM"
+#define  DELETE_N_CHAR        "\033[%dP"
+
+#define  INSERT_MODE          "\033[4h"
+#define  REPLACE_MODE         "\033[4l"
+
+#define  CUR_POSN_STAT        "\033[6n"
+#define  CUR_POSN_RPT         "\033[%d;%dR"
+#define  TERMINAL_STAT        "\033[5n"
+#define  TERMINAL_GOOD        "\033[0n"
+#define  TERMINAL_BAD         "\033[3n"
+
+#define  CLEAR_CUR_TAB        "\033[g"
+#define  CLEAR_ALL_TABS       "\033[3g"
+#define  SET_TAB              "\033H"
+
+
+#define  SAVE_CURSOR          "\0337"
+#define  RESTORE_CURSOR       "\0338"
+#define  APPLN_KEYPAD         "\033="
+#define  NORMAL_KEYPAD        "\033>"
+
+
+#define  NORMAL               "\033[0m"
+#define  BOLD                 "\033[1m"
+#define  UNDERSCORE           "\033[4m"
+#define  BLINK                "\033[5m"
+#define  INVERSE              "\033[7m"
+
+
+#define  SET_SCROLL_REGN      "\033[%d;%dr"
+
+/*** DEC Private Mode Set (DECSET) ***/
+
+#define  APPL_CUR_KEYS        "\033[?1h"
+#define  COLUMN_132           "\033[?3h"
+#define  SMOOTH_SCROLL        "\033[?4h"
+#define  REVERSE_VIDEO        "\033[?5h"
+#define  ORIGIN_MODE          "\033[?6h"
+#define  WRAP_MODE            "\033[?7h"
+#define  MARGIN_BELL          "\033[?44h"
+#define  REVERSE_WRAP         "\033[?45h"
+#define  START_LOGGING        "\033[?46h"
+
+#define  NORMAL_CUR_KEYS      "\033[?1l"
+#define  COLUMN_80            "\033[?3l"
+#define  JUMP_SCROLL          "\033[?4l"
+#define  NORMAL_VIDEO         "\033[?5l"
+#define  CURSOR_MODE          "\033[?6l"
+#define  NO_WRAP_MODE         "\033[?7l"
+#define  NO_MARGIN_BELL       "\033[?44l"
+#define  NO_REVERSE_WRAP      "\033[?45l"
+#define  STOP_LOGGING         "\033[?46l"
+
+#define  SAVE_CUR_KEYS           "\033[?1s"
+#define  SAVE_COLUMN_TYPE        "\033[?3s"
+#define  SAVE_SCROLL_TYPE        "\033[?4s"
+#define  SAVE_VIDEO_TYPE         "\033[?5s"
+#define  SAVE_SCREEN_MODE        "\033[?6s"
+#define  SAVE_WRAP_MODE          "\033[?7s"
+#define  SAVE_MARGIN_BELL_TYPE   "\033[?44s"
+#define  SAVE_REVERSE_WRAP_TYPE  "\033[?45s"
+#define  SAVE_LOGGING_TYPE       "\033[?46s"
+
+#define  REST_CUR_KEYS           "\033[?1r"
+#define  REST_COLUMN_TYPE        "\033[?3r"
+#define  REST_SCROLL_TYPE        "\033[?4r"
+#define  REST_VIDEO_TYPE         "\033[?5r"
+#define  REST_SCREEN_MODE        "\033[?6r"
+#define  REST_WRAP_MODE          "\033[?7r"
+#define  REST_MARGIN_BELL_TYPE   "\033[?44r"
+#define  REST_REVERSE_WRAP_TYPE  "\033[?45r"
+#define  REST_LOGGING_TYPE       "\033[?46r"

cde/programs/dtterm/tests/shared/esclib.c

@@ -0,0 +1,459 @@
+/* $XConsortium: esclib.c /main/3 1995/10/31 12:00:21 rswiston $ */
+#include <stdio.h>
+#include "escbase.h"
+#include "common.h"
+
+extern char *READTEST();
+
+#define  ESC_STR_LEN      20
+
+void HomeUp()
+{
+    WRITETEST(HOME_UP);
+}
+
+void ClearScreen()
+{
+  char Str[ESC_STR_LEN];
+    sprintf(Str, "%s%s", HOME_UP, CLEAR_DISP);
+    WRITETEST(Str);
+}
+
+void CursorUp(HowMuch)
+int HowMuch;
+{
+  char Str[10];
+   if (HowMuch == 0) return;
+   sprintf(Str, CURSOR_N_UP, HowMuch);
+   WRITETEST(Str);
+}
+
+void CursorDown(HowMuch)
+int HowMuch;
+{
+  char Str[10];
+   if (HowMuch == 0) return;
+   sprintf(Str, CURSOR_N_DOWN, HowMuch);
+   WRITETEST(Str);
+}
+
+void CursorForward(HowMuch)
+int HowMuch;
+{
+  char Str[10];
+   if (HowMuch == 0) return;
+   sprintf(Str, CURSOR_N_FORW, HowMuch);
+   WRITETEST(Str);
+}
+
+void CursorBack(HowMuch)
+int HowMuch;
+{
+  char Str[10];
+   if (HowMuch == 0) return;
+   sprintf(Str, CURSOR_N_BACK, HowMuch);
+   WRITETEST(Str);
+}
+
+void CursorPrevLine(HowMuch)
+int HowMuch;
+{
+  char Str[10];
+   if (HowMuch == 0) return;
+   sprintf(Str, CURSOR_N_PREV_LINE, HowMuch);
+   WRITETEST(Str);
+}
+
+void CursorColumn(HowMuch)
+int HowMuch;
+{
+  char Str[10];
+   if (HowMuch == 0) return;
+   sprintf(Str, CURSOR_N_COLUMN, HowMuch);
+   WRITETEST(Str);
+}
+
+void GetCursorPosn(X, Y)
+int *X, *Y;
+    /* expected ESC sequence is of the form Esc[n1;n2R */
+{
+  char  *Ptr, Line[5], Col[5];
+  int i, j;
+    WRITETEST(CUR_POSN_STAT);
+    Ptr = READTEST("R");
+    i = 2; j = 0;  
+    while (Ptr[i] != ';') {Line[j] = Ptr[i]; i++; j++;}
+    Line[j++] = NULLCHAR;
+    i++; j = 0; 
+    while (Ptr[i] != 'R') {Col[j] = Ptr[i]; i++; j++;}
+    Col[j++] = NULLCHAR;
+    *Y = atoi(Line); *X = atoi(Col);
+}
+
+int CheckTermStatus()
+    /* return 1 if term is in proper status else 0 */
+{
+  char  *Ptr;
+    WRITETEST(TERMINAL_STAT);
+    Ptr = READTEST("n");
+    if (strcmp(Ptr, TERMINAL_GOOD) == 0) return(0);
+    else return(-1);
+}
+
+void AbsoluteGoToXY(X, Y)
+int X, Y;
+{
+  char Str[ESC_STR_LEN];
+    sprintf(Str, GOTO_X_Y, Y, X);
+    WRITETEST(Str);
+}
+
+void AbsoluteGoToXY_HVP(X, Y)
+int X, Y;
+{
+  char Str[ESC_STR_LEN];
+    sprintf(Str, GOTO_X_Y_HVP, Y, X);
+    WRITETEST(Str);
+}
+
+void RelativeGoToXY(CurrX, CurrY, X, Y)
+int CurrX, CurrY, X, Y;
+{
+    if (X < CurrX) CursorBack((CurrX - X));
+    else CursorForward((X - CurrX));
+    if (Y < CurrY) CursorUp((CurrY - Y));
+    else CursorDown((Y - CurrY));
+}
+
+void Index()
+{
+    WRITETEST(INDEX); 
+}
+
+
+void ReverseIndex()
+{
+    WRITETEST(REVERSEINDEX); 
+}
+
+
+void NextLine()
+{
+    WRITETEST(NEXTLINE); 
+}
+
+void InsertLines(Howmany)
+int Howmany;
+{
+  char Str[10];
+   if (Howmany == 0) return;
+   sprintf(Str, INSERT_N_LINE, Howmany);
+   WRITETEST(Str);
+}
+
+void InsertBlanks(Howmany)
+int Howmany;
+{
+  char Str[10];
+   if (Howmany == 0) return;
+   sprintf(Str, INSERT_N_BLANK, Howmany);
+   WRITETEST(Str);
+}
+
+void DeleteLines(Howmany)
+int Howmany;
+{
+  char Str[10];
+   if (Howmany == 0) return;
+   sprintf(Str, DELETE_N_LINE, Howmany);
+   WRITETEST(Str);
+}
+
+
+void DeleteChars(Howmany)
+int Howmany;
+{
+  char Str[10];
+   if (Howmany == 0) return;
+   sprintf(Str, DELETE_N_CHAR, Howmany);
+   WRITETEST(Str);
+}
+
+void SetInsertMode()
+{
+    WRITETEST(INSERT_MODE);
+}
+
+
+void SetReplaceMode()
+{
+    WRITETEST(REPLACE_MODE);
+}
+
+void GetWinSize(Lines, Cols)
+int *Lines, *Cols;
+{
+    AbsoluteGoToXY(999, 999);
+    GetCursorPosn(Cols, Lines);
+}
+
+/*** TabFunctions  ***/
+
+void ClearAllTabs()
+{
+    WRITETEST(CLEAR_ALL_TABS);
+}
+
+void ClearCurTab()
+{
+    WRITETEST(CLEAR_CUR_TAB);
+}
+
+void SetTab()
+{
+    WRITETEST(SET_TAB);
+}
+
+
+void EraseLnFromCur()
+{
+    WRITETEST(ERASE_LN_FROM_CUR);
+}
+
+
+void EraseLnToCur()
+{
+    WRITETEST(ERASE_LN_TO_CUR);
+}
+
+void EraseLnAll()
+{
+    WRITETEST(ERASE_LN_ALL);
+}
+
+
+void EraseScrFromCur()
+{
+    WRITETEST(ERASE_FROM_CUR);
+}
+
+
+void EraseScrToCur()
+{
+    WRITETEST(ERASE_TO_CUR);
+}
+
+void EraseScrAll()
+{
+    WRITETEST(ERASE_ALL);
+}
+
+void EraseChars(Howmany)
+int Howmany;
+{
+  char Str[10];
+   if (Howmany == 0) return;
+   sprintf(Str, ERASE_N_CHAR, Howmany);
+   WRITETEST(Str);
+}
+
+
+void SetApplnKeyPad()
+{
+    WRITETEST(APPLN_KEYPAD);
+}
+
+void SetNormalKeyPad()
+{
+    WRITETEST(NORMAL_KEYPAD);
+}
+
+void SetDispNormal()
+{
+    WRITETEST(NORMAL);
+}
+
+void SetDispBold()
+{
+    WRITETEST(BOLD);
+}
+
+void SetDispUnderscore()
+{
+    WRITETEST(UNDERSCORE);
+}
+
+void SetDispBlink()
+{
+    WRITETEST(BLINK);
+}
+
+void SetDispInverse()
+{
+    WRITETEST(INVERSE);
+}
+
+void SaveCursor()
+{
+    WRITETEST(SAVE_CURSOR);
+}
+
+
+void RestoreCursor()
+{
+    WRITETEST(RESTORE_CURSOR);
+}
+
+void SetScrollRegn(Top, Bottom)
+int Top, Bottom;
+{
+  char Str[ESC_STR_LEN];
+    sprintf(Str, SET_SCROLL_REGN, Top, Bottom);
+    WRITETEST(Str);
+}
+
+
+void SetCursorKeys(DECMode)
+DECModeType DECMode;
+{
+    switch(DECMode) {
+      case DECModeSet:
+        WRITETEST(APPL_CUR_KEYS); break;
+      case DECModeReset:
+        WRITETEST(NORMAL_CUR_KEYS); break;
+      case DECModeSave:
+        WRITETEST(SAVE_CUR_KEYS); break;
+      case DECModeRestore:
+        WRITETEST(REST_CUR_KEYS); break;
+    }
+}
+
+void SetColumnWidth(DECMode)
+DECModeType DECMode;
+{
+    switch(DECMode) {
+      case DECModeSet:
+        WRITETEST(COLUMN_80); break;
+      case DECModeReset:
+        WRITETEST(COLUMN_132); break;
+      case DECModeSave:
+        WRITETEST(SAVE_COLUMN_TYPE); break;
+      case DECModeRestore:
+        WRITETEST(REST_COLUMN_TYPE); break;
+    }
+}
+
+void SetScrollType(DECMode)
+DECModeType DECMode;
+{
+    switch(DECMode) {
+      case DECModeSet:
+        WRITETEST(SMOOTH_SCROLL); break;
+      case DECModeReset:
+        WRITETEST(JUMP_SCROLL); break;
+      case DECModeSave:
+        WRITETEST(SAVE_SCROLL_TYPE); break;
+      case DECModeRestore:
+        WRITETEST(REST_SCROLL_TYPE); break;
+    }
+}
+
+void SetVideoType(DECMode)
+DECModeType DECMode;
+{
+    switch(DECMode) {
+      case DECModeSet:
+        WRITETEST(REVERSE_VIDEO); break;
+      case DECModeReset:
+        WRITETEST(NORMAL_VIDEO); break;
+      case DECModeSave:
+        WRITETEST(SAVE_VIDEO_TYPE); break;
+      case DECModeRestore:
+        WRITETEST(REST_VIDEO_TYPE); break;
+    }
+}
+
+void SetOriginMode(DECMode)
+DECModeType DECMode;
+{
+    switch(DECMode) {
+      case DECModeSet:
+        WRITETEST(ORIGIN_MODE); break;
+      case DECModeReset:
+        WRITETEST(CURSOR_MODE); break;
+      case DECModeSave:
+        WRITETEST(SAVE_SCREEN_MODE); break;
+      case DECModeRestore:
+        WRITETEST(REST_SCREEN_MODE); break;
+    }
+}
+
+void SetWrapMode(DECMode)
+DECModeType DECMode;
+{
+    switch(DECMode) {
+      case DECModeSet:
+        WRITETEST(WRAP_MODE); break;
+      case DECModeReset:
+        WRITETEST(NO_WRAP_MODE); break;
+      case DECModeSave:
+        WRITETEST(SAVE_WRAP_MODE); break;
+      case DECModeRestore:
+        WRITETEST(REST_WRAP_MODE); break;
+    }
+}
+
+void SetMarginBell(DECMode)
+DECModeType DECMode;
+{
+    switch(DECMode) {
+      case DECModeSet:
+        WRITETEST(MARGIN_BELL); break;
+      case DECModeReset:
+        WRITETEST(NO_MARGIN_BELL); break;
+      case DECModeSave:
+        WRITETEST(SAVE_MARGIN_BELL_TYPE); break;
+      case DECModeRestore:
+        WRITETEST(REST_MARGIN_BELL_TYPE); break;
+    }
+}
+
+void SetReverseWrap(DECMode)
+DECModeType DECMode;
+{
+    switch(DECMode) {
+      case DECModeSet:
+        WRITETEST(REVERSE_WRAP); break;
+      case DECModeReset:
+        WRITETEST(NO_REVERSE_WRAP); break;
+      case DECModeSave:
+        WRITETEST(SAVE_REVERSE_WRAP_TYPE); break;
+      case DECModeRestore:
+        WRITETEST(REST_REVERSE_WRAP_TYPE); break;
+    }
+}
+
+void SetLoggingMode(DECMode)
+DECModeType DECMode;
+{
+    switch(DECMode) {
+      case DECModeSet:
+        WRITETEST(START_LOGGING); break;
+      case DECModeReset:
+        WRITETEST(STOP_LOGGING); break;
+      case DECModeSave:
+        WRITETEST(SAVE_LOGGING_TYPE); break;
+      case DECModeRestore:
+        WRITETEST(REST_LOGGING_TYPE); break;
+    }
+}
+
+#define  BACKSPACE        010
+
+void BackSpace(HowMany)
+int HowMany;
+{
+  int i; char Str[20];
+    for (i=0; i < HowMany-1; i++) 
+      {sprintf(Str, "%c", BACKSPACE); WRITETEST(Str);}
+}

cde/programs/dtterm/tests/shared/include_files.h

@@ -0,0 +1,24 @@
+/* $XConsortium: include_files.h /main/3 1995/10/31 12:00:37 rswiston $ */
+#ifndef DO_NOT_NEED_NOW
+#define DO_NOT_NEED_NOW
+#endif
+
+#ifndef _HPUX_SOURCE
+#define _HPUX_SOURCE
+#endif
+
+#include <stdio.h>
+#include <fcntl.h>
+#include <sys/ioctl.h>
+#include <termios.h>
+#include <signal.h>
+#include <ctype.h>
+#ifdef sun
+#include <string.h>
+#else
+#include <strings.h>
+#endif
+#include <unistd.h>
+
+#include "p2c.h"
+

cde/programs/dtterm/tests/shared/p2c.h

@@ -0,0 +1,397 @@
+/* $XConsortium: p2c.h /main/3 1995/10/31 12:00:53 rswiston $ */
+#ifndef P2C_H
+#define P2C_H
+
+
+/* Header file for code generated by "p2c", the Pascal-to-C translator */
+
+/* "p2c"  Copyright (C) 1989 Dave Gillespie, version 1.14.
+ * This file may be copied, modified, etc. in any way.  It is not restricted
+ * by the licence agreement accompanying p2c itself.
+ */
+
+
+#include <stdio.h>
+
+
+
+/* If the following heuristic fails, compile -DBSD=0 for non-BSD systems,
+   or -DBSD=1 for BSD systems. */
+
+#ifdef M_XENIX
+# define BSD 0
+#endif
+
+#ifdef FILE       /* a #define in BSD, a typedef in SYSV (hp-ux, at least) */
+# ifndef BSD	  /*  (a convenient, but horrible kludge!) */
+#  define BSD 1
+# endif
+#endif
+
+#ifdef BSD
+# if !BSD
+#  undef BSD
+# endif
+#endif
+
+
+#ifdef __STDC__
+# include <stddef.h>
+# include <stdlib.h>
+# define HAS_STDLIB
+# define __CAT__(a,b)a##b
+#else
+# ifndef BSD
+#  include <memory.h>
+# endif
+# include <sys/types.h>
+# define __ID__(a)a
+# define __CAT__(a,b)__ID__(a)b
+#endif
+
+
+#ifdef BSD
+# include <strings.h>
+# define memcpy(a,b,n) (bcopy(b,a,n),a)
+# define memcmp(a,b,n) bcmp(a,b,n)
+# define strchr(s,c) index(s,c)
+# define strrchr(s,c) rindex(s,c)
+#else
+# include <string.h>
+#endif
+
+#include <ctype.h>
+#include <math.h>
+#include <setjmp.h>
+#include <assert.h>
+
+
+typedef struct __p2c_jmp_buf {
+    struct __p2c_jmp_buf *next;
+    jmp_buf jbuf;
+} __p2c_jmp_buf;
+
+
+/* Warning: The following will not work if setjmp is used simultaneously.
+   This also violates the ANSI restriction about using vars after longjmp,
+   but a typical implementation of longjmp will get it right anyway. */
+
+#ifndef FAKE_TRY
+# define TRY(x)         do { __p2c_jmp_buf __try_jb;  \
+			     __try_jb.next = __top_jb;  \
+			     if (!setjmp((__top_jb = &__try_jb)->jbuf)) {
+# define RECOVER(x)	__top_jb = __try_jb.next; } else {
+# define RECOVER2(x,L)  __top_jb = __try_jb.next; } else {  \
+			     if (0) { L: __top_jb = __try_jb.next; }
+# define ENDTRY(x)      } } while (0) 
+#else
+# define TRY(x)         if (1) {
+# define RECOVER(x)     } else do {
+# define RECOVER2(x,L)  } else do { L: ;
+# define ENDTRY(x)      } while (0)
+#endif
+
+
+
+#ifdef M_XENIX  /* avoid compiler bug */
+# define SHORT_MAX  (32767)
+# define SHORT_MIN  (-32768)
+#endif
+
+
+/* The following definitions work only on twos-complement machines */
+#ifndef SHORT_MAX
+# define SHORT_MAX  (((unsigned short) -1) >> 1)
+# define SHORT_MIN  (~SHORT_MAX)
+#endif
+
+#ifndef INT_MAX
+# define INT_MAX    (((unsigned int) -1) >> 1)
+# define INT_MIN    (~INT_MAX)
+#endif
+
+#ifndef LONG_MAX
+# define LONG_MAX   (((unsigned long) -1) >> 1)
+# define LONG_MIN   (~LONG_MAX)
+#endif
+
+#ifndef SEEK_SET
+# define SEEK_SET   0
+# define SEEK_CUR   1
+# define SEEK_END   2
+#endif
+
+#ifndef EXIT_SUCCESS
+# define EXIT_SUCCESS  0
+# define EXIT_FAILURE  1
+#endif
+
+
+#define SETBITS  32
+
+
+#ifdef __STDC__
+# define Signed     signed
+# define Void       void      /* Void f() = procedure */
+# ifndef Const
+#  define Const     const
+# endif
+# ifndef Volatile
+# define Volatile  volatile
+# endif
+# define PP(x)      x         /* function prototype */
+# define PV()       (void)    /* null function prototype */
+typedef void *Anyptr;
+#else
+# define Signed
+# define Void       void
+# ifndef Const
+#  define Const
+# endif
+# ifndef Volatile
+#  define Volatile
+# endif
+# define PP(x)      ()
+# define PV()       ()
+typedef char *Anyptr;
+#endif
+
+#ifdef __GNUC__
+# define Inline     inline
+#else
+# define Inline
+#endif
+
+#define Register    register  /* Register variables */
+#define Char        char      /* Characters (not bytes) */
+
+#ifndef Static
+# define Static     static    /* Private global funcs and vars */
+#endif
+
+#ifndef Local
+# define Local      static    /* Nested functions */
+#endif
+
+typedef Signed   char schar;
+#ifndef _AIX
+typedef unsigned char uchar;
+#endif /* _AIX */
+typedef unsigned char boolean;
+
+#ifndef true
+# define true    1
+# define false   0
+#endif
+
+
+typedef struct {
+    Anyptr proc, link;
+} _PROCEDURE;
+
+#ifndef _FNSIZE
+# define _FNSIZE  120
+#endif
+
+/*  Most of the following vars were "Unsatisfied symbols at load time 
+extern Void    PASCAL_MAIN  PP( (int, Char **) );
+extern Char    **P_argv;
+extern int     P_argc;
+extern short   P_escapecode;
+extern int     P_ioresult;
+extern __p2c_jmp_buf *__top_jb;
+*/
+
+#ifdef P2C_H_PROTO   /* if you have Ansi C but non-prototyped header files */
+extern Char    *strcat      PP( (Char *, Const Char *) );
+extern Char    *strchr      PP( (Const Char *, int) );
+extern int      strcmp      PP( (Const Char *, Const Char *) );
+extern Char    *strcpy      PP( (Char *, Const Char *) );
+extern size_t   strlen      PP( (Const Char *) );
+extern Char    *strncat     PP( (Char *, Const Char *, size_t) );
+extern int      strncmp     PP( (Const Char *, Const Char *, size_t) );
+extern Char    *strncpy     PP( (Char *, Const Char *, size_t) );
+extern Char    *strrchr     PP( (Const Char *, int) );
+
+extern Anyptr   memchr      PP( (Const Anyptr, int, size_t) );
+extern Anyptr   memmove     PP( (Anyptr, Const Anyptr, size_t) );
+extern Anyptr   memset      PP( (Anyptr, int, size_t) );
+#ifndef memcpy
+extern Anyptr   memcpy      PP( (Anyptr, Const Anyptr, size_t) );
+extern int      memcmp      PP( (Const Anyptr, Const Anyptr, size_t) );
+#endif
+
+extern int      atoi        PP( (Const Char *) );
+extern double   atof        PP( (Const Char *) );
+extern long     atol        PP( (Const Char *) );
+extern double   strtod      PP( (Const Char *, Char **) );
+extern long     strtol      PP( (Const Char *, Char **, int) );
+#endif /*P2C_H_PROTO*/
+
+#ifndef HAS_STDLIB
+#ifndef _AIX
+extern Anyptr   malloc      PP( (size_t) );
+#endif /* _AIX */
+extern Void     free        PP( (Anyptr) );
+#endif /* HAS_STDLIB */
+
+extern int      _OutMem     PV();
+extern int      _CaseCheck  PV();
+extern int      _NilCheck   PV();
+extern int	_Escape     PP( (int) );
+extern int	_EscIO      PP( (int) );
+
+extern long     ipow        PP( (long, long) );
+/* strsub defined in qalib.c                                     */
+/* extern Char    *strsub      PP( (Char *, Char *, int, int) ); */
+extern Char    *strltrim    PP( (Char *) );
+extern Char    *strrtrim    PP( (Char *) );
+extern Char    *strrpt      PP( (Char *, Char *, int) );
+extern Char    *strpad      PP( (Char *, Char *, int, int) );
+
+/* strpos2 defined in qalib.c                                     */
+/*  extern int      strpos2     PP( (Char *, Char *, int) );  */
+extern long     memavail    PV();
+extern int      P_peek      PP( (FILE *) );
+extern int      P_eof       PP( (FILE *) );
+extern int      P_eoln      PP( (FILE *) );
+extern Void     P_readpaoc  PP( (FILE *, Char *, int) );
+extern Void     P_readlnpaoc PP( (FILE *, Char *, int) );
+extern long     P_maxpos    PP( (FILE *) );
+extern long    *P_setunion  PP( (long *, long *, long *) );
+extern long    *P_setint    PP( (long *, long *, long *) );
+extern long    *P_setdiff   PP( (long *, long *, long *) );
+extern long    *P_setxor    PP( (long *, long *, long *) );
+extern int      P_inset     PP( (unsigned, long *) );
+extern int      P_setequal  PP( (long *, long *) );
+extern int      P_subset    PP( (long *, long *) );
+extern long    *P_addset    PP( (long *, unsigned) );
+extern long    *P_addsetr   PP( (long *, unsigned, unsigned) );
+extern long    *P_remset    PP( (long *, unsigned) );
+extern long    *P_setcpy    PP( (long *, long *) );
+extern long    *P_expset    PP( (long *, long) );
+extern long     P_packset   PP( (long *) );
+extern int      P_getcmdline PP( (int l, int h, Char *line) );
+extern Void     TimeStamp   PP( (int *Day, int *Month, int *Year,
+				 int *Hour, int *Min, int *Sec) );
+extern Void	P_sun_argv  PP( (char *, int, int) );
+
+
+/* I/O error handling */
+#define _CHKIO(cond,ior,val,def)  ((cond) ? P_ioresult=0,(val)  \
+					  : P_ioresult=(ior),(def))
+#define _SETIO(cond,ior)          (P_ioresult = (cond) ? 0 : (ior))
+
+/* Following defines are suitable for the HP Pascal operating system */
+#define FileNotFound     10
+#define FileNotOpen      13
+#define FileWriteError   38
+#define BadInputFormat   14
+#define EndOfFile        30
+
+/* Creating temporary files */
+#if (defined(BSD) || defined(NO_TMPFILE)) && !defined(HAVE_TMPFILE)
+# define tmpfile()  (fopen(tmpnam(NULL), "w+"))
+#endif
+
+/* File buffers */
+#define FILEBUF(f,sc,type) sc int __CAT__(f,_BFLAGS);   \
+			   sc type __CAT__(f,_BUFFER)
+
+#define RESETBUF(f,type)   (__CAT__(f,_BFLAGS) = 1)
+#define SETUPBUF(f,type)   (__CAT__(f,_BFLAGS) = 0)
+
+#define GETFBUF(f,type)    (*((__CAT__(f,_BFLAGS) == 1 &&   \
+			       ((__CAT__(f,_BFLAGS) = 2),   \
+				fread(&__CAT__(f,_BUFFER),  \
+				      sizeof(type),1,(f)))),\
+			      &__CAT__(f,_BUFFER)))
+#define AGETFBUF(f,type)   ((__CAT__(f,_BFLAGS) == 1 &&   \
+			     ((__CAT__(f,_BFLAGS) = 2),   \
+			      fread(&__CAT__(f,_BUFFER),  \
+				    sizeof(type),1,(f)))),\
+			    __CAT__(f,_BUFFER))
+
+#define PUTFBUF(f,type,v)  (GETFBUF(f,type) = (v))
+#define CPUTFBUF(f,v)      (PUTFBUF(f,char,v))
+#define APUTFBUF(f,type,v) (memcpy(GETFBUF(f,type), (v),  \
+				   sizeof(__CAT__(f,_BUFFER))))
+
+#define GET(f,type)        (__CAT__(f,_BFLAGS) == 1 ?   \
+			    fread(&__CAT__(f,_BUFFER),sizeof(type),1,(f)) :  \
+			    (__CAT__(f,_BFLAGS) = 1))
+
+#define PUT(f,type)        (fwrite(&__CAT__(f,_BUFFER),sizeof(type),1,(f)),  \
+			    (__CAT__(f,_BFLAGS) = 0))
+#define CPUT(f)            (PUT(f,char))
+
+/* Memory allocation */
+#ifdef __GCC__
+# define Malloc(n)  (malloc(n) ?: (Anyptr)_OutMem())
+#else
+extern Anyptr __MallocTemp__;
+# define Malloc(n)  ((__MallocTemp__ = malloc(n)) ? __MallocTemp__ : (Anyptr)_OutMem())
+#endif
+#define FreeR(p)    (free((Anyptr)(p)))    /* used if arg is an rvalue */
+#define Free(p)     (free((Anyptr)(p)), (p)=NULL)
+
+/* sign extension */
+#define SEXT(x,n)   ((x) | -(((x) & (1L<<((n)-1))) << 1))
+
+/* packed arrays */   /* BEWARE: these are untested! */
+#define P_getbits_UB(a,i,n,L)   ((int)((a)[(i)>>(L)-(n)] >>   \
+				       (((~(i))&((1<<(L)-(n))-1)) << (n)) &  \
+				       (1<<(1<<(n)))-1))
+
+#define P_getbits_SB(a,i,n,L)   ((int)((a)[(i)>>(L)-(n)] <<   \
+				       (16 - ((((~(i))&((1<<(L)-(n))-1))+1) <<\
+					      (n)) >> (16-(1<<(n))))))
+
+#define P_putbits_UB(a,i,x,n,L) ((a)[(i)>>(L)-(n)] |=   \
+				 (x) << (((~(i))&((1<<(L)-(n))-1)) << (n)))
+
+#define P_putbits_SB(a,i,x,n,L) ((a)[(i)>>(L)-(n)] |=   \
+				 ((x) & (1<<(1<<(n)))-1) <<   \
+				 (((~(i))&((1<<(L)-(n))-1)) << (n)))
+
+#define P_clrbits_B(a,i,n,L)    ((a)[(i)>>(L)-(n)] &=   \
+				 ~( ((1<<(1<<(n)))-1) <<   \
+				   (((~(i))&((1<<(L)-(n))-1)) << (n))) )
+
+/* small packed arrays */
+#define P_getbits_US(v,i,n)     ((int)((v) >> (~(i) << (n)) & (1<<(1<<(n)))-1))
+#define P_getbits_SS(v,i,n)     ((int)((long)(v) << (32 - (((~(i))+1) << (n))) >> (32-(1<<(n)))))
+#define P_putbits_US(v,i,x,n)   ((v) |= (x) << (~(i) << (n)))
+#define P_putbits_SS(v,i,x,n)   ((v) |= ((x) & (1<<(1<<(n)))-1) << (~(i) << (n)))
+#define P_clrbits_S(v,i,n)      ((v) &= ~( ((1<<(1<<(n)))-1) << (~(i) << (n)) ))
+
+#define P_max(a,b)   ((a) > (b) ? (a) : (b))
+#define P_min(a,b)   ((a) < (b) ? (a) : (b))
+
+
+/* Fix toupper/tolower on Suns and other stupid BSD systems */
+#ifdef toupper
+# undef toupper
+# undef tolower
+# define toupper(c)   my_toupper(c)
+# define tolower(c)   my_tolower(c)
+#endif
+
+#ifndef _toupper
+# if 'A' == 65 && 'a' == 97
+#  define _toupper(c)  ((c)-'a'+'A')
+#  define _tolower(c)  ((c)-'A'+'a')
+# else
+#  define _toupper(c)  toupper(c)
+#  define _tolower(c)  tolower(c)
+# endif
+#endif
+
+
+#endif    /* P2C_H */
+
+
+
+/* End. */
+
+

cde/programs/dtterm/tests/shared/synfunc.c

@@ -0,0 +1,324 @@
+/* $XConsortium: synfunc.c /main/3 1995/10/31 12:01:30 rswiston $ */
+#include <stdio.h>
+#include <errno.h>
+#include <time.h>
+#include  "synvar.h"
+
+
+int errno;
+
+
+
+#ifdef LOG
+extern FILE *TermLog;
+#define SAVELOG  fclose(TermLog); TermLog = fopen("term.log", "a");
+#endif
+
+static TestData test;
+extern char LogStr[200];
+
+void LogTime()
+{
+  time_t Time;
+#ifdef LOG
+    time(&Time);
+    fprintf(TermLog, "%s", ctime(&Time)); 
+    SAVELOG;
+#endif
+}
+
+void LogError(Str)
+char *Str;
+{
+#ifdef LOG
+  fprintf(TermLog, "%s\n", Str); 
+  SAVELOG;
+#endif
+}
+
+
+char *MemAllocate(Size)
+int Size;
+{
+   char *P;
+     if (Size <= 0) {
+        sprintf(LogStr, "Invalid Size for memory allocation %d ", Size); 
+        LogError(LogStr); return(NULL);
+     }
+     P = (char *) calloc(Size, 1);
+     if (P == NULL) {
+        sprintf(LogStr, "No memory for allocation");
+        LogError(LogStr); return(NULL);
+     }
+     return(P);
+}
+
+void MemRelease(P)
+char *P;
+{
+    if (P == NULL) {LogError("Invalid memory address for release");return;}
+    free(P);
+}
+
+int FileExists(FileName)
+char *FileName;
+{
+    if (fopen(FileName, "r") != NULL) return(0);
+    return((int) errno);
+}
+
+
+void InitTest(argc, argv)
+int argc;
+char *argv[];
+{
+    test.display = SynOpenDisplay(NULL);
+    SynParseCommandOptions(argc, argv);
+    SynNameWindow(test.display, DefaultRootWindow(test.display), "WinRoot");
+#if 0
+    SynSetDoubleClickDelay(MULTI_CLICK_DELAY);
+#endif
+    test.waitTime = WIN_WAIT_TIME;
+}
+
+CloseTest(exitDialog)
+int exitDialog;
+{
+   Window Win;
+   SynStatus Result;
+      SynCloseDisplay(test.display);    
+}
+
+void MatchWindows(WinName, ImageFile)
+char *WinName, *ImageFile;
+{
+  int Result;
+  SynStatus SynResult;
+  char *Expected, *Actual;
+
+#ifdef SLOW
+sleep(10);
+#endif
+    if ((Result = FileExists(ImageFile)) != 0) {
+       sprintf(LogStr, "ImageFile <%s> does not exist", ImageFile);
+#if 0
+       if (Result ==  ENOENT) 
+          sprintf(LogStr, "ImageFile <%s> does not exist", ImageFile);
+       else if (Result == EACCES)  
+         sprintf(LogStr, "ImageFile <%s> permission problem ", ImageFile);
+       else LogError(LogStr, "ImageFile <%s> Unknown error ", ImageFile);
+#endif
+       LogError(LogStr);
+    }
+    Expected = MemAllocate((int) (strlen(ImageFile) + strlen(EXPECTED_SUFFIX)));
+    Actual = MemAllocate((int) (strlen(ImageFile) + strlen(ACTUAL_SUFFIX)));
+    strcpy(Expected, ImageFile); strcat(Expected, EXPECTED_SUFFIX);
+    strcpy(Actual, ImageFile); strcat(Actual, ACTUAL_SUFFIX);
+    if ((SynResult = SynCompareWindowImage(test.display, WinName, ImageFile,
+                        Expected, Actual)) != SYN_SUCCESS) {
+       sprintf(LogStr,"ImageComparison Failed ImageFile <%s> \
+          Expected <%s> Actual <%s>", ImageFile, Expected, Actual);
+       LogError(LogStr);
+    }
+    else {
+      sprintf(LogStr, "ImageComparison Success \n");
+      LogError(LogStr);
+    }
+}
+
+
+int AssignWinName(WinName, TitleName)
+char *WinName, *TitleName;
+{
+   SynStatus Result;
+   Window Win, *SelList;
+   int SelCount;
+     Result = SynNameWindowByProperty(test.display, WinName, TitleName, 
+                                       "WM_CLASS", &SelList, &SelCount);
+     if (Result == SYN_SUCCESS)
+        {sprintf(LogStr, "SynSucc SelCount %d ", SelCount); LogError(LogStr);}
+     else if (Result == SYN_NAME_COLLISION)
+        {sprintf(LogStr, "Window Collision "); LogError(LogStr);}
+     else if (Result == BAD_SYN_WINDOW)
+        {sprintf(LogStr, "SynFail");  LogError(LogStr); return(-1);}
+     return(0);
+}
+
+
+void PressKeypadKeys()
+{
+    SynClickKey(test.display, "<KP_0>");
+    SynClickKey(test.display, "<KP_1>");
+    SynClickKey(test.display, "<KP_2>");
+    SynClickKey(test.display, "<KP_3>");
+    SynClickKey(test.display, "<KP_4>");
+    SynClickKey(test.display, "<KP_5>");
+    SynClickKey(test.display, "<KP_6>");
+    SynClickKey(test.display, "<KP_7>");
+    SynClickKey(test.display, "<KP_8>");
+    SynClickKey(test.display, "<KP_9>");
+    SynClickKey(test.display, "<KP_Multiply>");
+    SynClickKey(test.display, "<KP_Divide>");
+    SynClickKey(test.display, "<KP_Add>");
+    SynClickKey(test.display, "<KP_Subtract>");
+    SynClickKey(test.display, "<KP_Separator>");
+    SynClickKey(test.display, "<KP_Tab>");
+    SynClickKey(test.display, "<KP_Decimal>");
+    SynClickKey(test.display, "<KP_Enter>");
+    SynClickKey(test.display, "<Return>");
+    SynFlushInputBuffer(test.display);
+}
+
+void PrintTermString(WinName, String)
+char *WinName, *String;
+{
+   int i;
+     SynMovePointer(test.display, WinName, "LocTerm1");
+     for (i=0; i < 5; i++) {
+       SynPrintString(test.display, String);
+       SynPrintString(test.display, "    ");
+     }
+     SynFlushInputBuffer(test.display);
+}
+
+void ExecCommand(Command)
+char *Command;
+{
+sleep(5);
+    SynMovePointer(test.display, "WinRoot", "LocTerm");
+    SynPressAndHoldKey(test.display, "<Control_L>");
+    SynPrintString(test.display, "C");
+    SynReleaseKey(test.display, "<Control_L>");
+    SynClickKey(test.display, "<Return>");
+    SynFlushInputBuffer(test.display);
+/* Above things are auxillary things and assumes intr set as ^C */
+    SynPrintString(test.display, Command);
+    SynClickKey(test.display, "<Return>");
+    SynFlushInputBuffer(test.display);
+}
+
+void ExecWinCommand(WinName, Command)
+char *WinName, *Command;
+{
+    SynMovePointer(test.display, WinName, "LocTerm1");
+    SynPressAndHoldKey(test.display, "<Control_L>");
+    SynPrintString(test.display, "C");
+    SynReleaseKey(test.display, "<Control_L>");
+    SynClickKey(test.display, "<Return>");
+    SynFlushInputBuffer(test.display);
+/* Above things are auxillary things and assumes intr set as ^C */
+    SynPrintString(test.display, Command);
+    SynClickKey(test.display, "<Return>");
+    SynFlushInputBuffer(test.display);
+}
+
+void PressPrevKey(WinName)
+char *WinName;
+{
+    SynClickKey(test.display, "<Prior>");
+    SynFlushInputBuffer(test.display);
+}
+
+void PressCtrlGKey(WinName)
+char *WinName;
+{
+    SynPressAndHoldKey(test.display, "<Control_L>");
+    SynPrintString(test.display, "G");
+    SynReleaseKey(test.display, "<Control_L>");
+    SynFlushInputBuffer(test.display);
+}
+
+void PressKeyNtimes(WinName, Key, N)
+char *WinName, *Key;
+int N;
+{
+  int i;
+    for (i=0; i < N; i++)
+      SynPrintString(test.display, Key);
+    SynFlushInputBuffer(test.display);
+}
+
+void PressBackSpace(WinName)
+char *WinName;
+{
+    SynClickKey(test.display, "<BackSpace>");
+    SynFlushInputBuffer(test.display);
+}
+
+void CloseTerm(WinName)
+char *WinName;
+{
+    SynMovePointer(test.display, WinName, "LocTerm1");
+    SynPressAndHoldKey(test.display, "<Control_L>");
+    SynPrintString(test.display, "C");
+    SynReleaseKey(test.display, "<Control_L>");
+    SynClickKey(test.display, "<Return>");
+    SynFlushInputBuffer(test.display);
+    SynPrintString(test.display, "exit");
+    SynClickKey(test.display, "<Return>");
+    SynFlushInputBuffer(test.display);
+}
+
+void JustExit(WinName)
+char *WinName;
+{
+    SynMovePointer(test.display, WinName, "LocTerm1");
+    SynPrintString(test.display, "exit");
+    SynClickKey(test.display, "<Return>");
+    SynFlushInputBuffer(test.display);
+}
+
+int WaitWinMap(WinName)
+char *WinName;
+{
+  SynStatus Result;
+    Result = SynWaitWindowMap(test.display, WinName, WIN_WAIT_TIME);
+    if (Result == SYN_TIME_OUT) 
+       {LogError("term window did not come up"); return(-1);}
+    return(0);
+}
+
+void WaitWinUnMap(WinName, WaitTime)
+char *WinName;
+long WaitTime;
+{
+  SynStatus Result;
+    Result = SynWaitWindowUnmap(test.display, WinName, WaitTime);
+    if (Result == BAD_SYN_WINDOW) LogError("Named  window does not exist");
+}
+
+void CheckCapsLock()
+{
+  int X, Y, X1, Y1;
+  unsigned int Mask;
+  Window A, B;
+    if (XQueryPointer(test.display, DefaultRootWindow((test.display)),
+                        &A, &B, &X, &Y, &X1, &Y1, &Mask) == True) {
+       if ((Mask&LockMask) == LockMask) {
+          SynClickKey(test.display, "<Caps_Lock>");
+          SynFlushInputBuffer(test.display);
+       }
+    }
+    else LogError("QueryPointer failed ");
+}
+
+void Deiconify(WinName)
+char *WinName;
+{
+     SynDoubleClickButton(test.display, "Button1", WinName, "LocTerm1");
+     SynWaitWindowMap(test.display, NULL, WIN_WAIT_TIME);
+     SynWaitWindowUnmap(test.display, NULL,WIN_WAIT_TIME);
+     SynWaitWindowUnmap(test.display, WinName, WIN_WAIT_TIME);
+}
+
+void TestMenu(WinName)
+char *WinName;
+{
+    SynMovePointer(test.display, WinName, "file");
+    SynClickButton(test.display, "Button1", WinName, "file");
+    SynMovePointer(test.display, WinName, "file");
+/*
+    SynClickButton(test.display, "Button1", WinName, "exit");
+*/
+sleep(5);
+}

cde/programs/dtterm/tests/shared/synvar.h

@@ -0,0 +1,32 @@
+/* $XConsortium: synvar.h /main/3 1995/10/31 12:01:44 rswiston $ */
+
+/******************************************************************
+ *
+ * (c) Copyright Hewlett-Packard Company, 1993.
+ *
+ ******************************************************************/
+
+#include   <stdio.h>
+#include   <X11/Xlib.h>
+#include   <synlib/synlib.h>
+
+typedef struct {
+    Display       *display;
+    int            waitTime;
+    SynFocus      *focusMap;
+} TestData, *TestDataPtr;
+
+
+#define WIN_WAIT_TIME       120
+#define MULTI_CLICK_DELAY   5
+
+#define IMAGE_DIR           "../image/"
+#define EXPECTED_SUFFIX     ".exp"
+#define ACTUAL_SUFFIX       ".act"
+
+#define NEED_LEN            256
+
+#define IMAGE_FILE_LEN      100  /* should be strlen(IMAGE_DIR) + 20 (say) */
+
+
+#define TERM_EMU            "dtterm"