root/trunk/txt/txt.c

//
//                     TxWin, Textmode Windowing Library
//
//   Original code Copyright (c) 1995-2005 Fsys Software and Jan van Wijk
//
// ==========================================================================
//
// This file contains Original Code and/or Modifications of Original Code as
// defined in and that are subject to the GNU Lesser General Public License.
// You may not use this file except in compliance with the License.
// BY USING THIS FILE YOU AGREE TO ALL TERMS AND CONDITIONS OF THE LICENSE.
// A copy of the License is provided with the Original Code and Modifications,
// and is also available at http://www.dfsee.com/txwin/lgpl.htm
//
// This library is free software; you can redistribute it and/or modify
// it under the terms of the GNU Lesser General Public License as published
// by the Free Software Foundation; either version 2.1 of the License,
// or (at your option) any later version.
//
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
// See the GNU Lesser General Public License for more details.
//
// You should have received a copy of the GNU Lesser General Public License
// along with this library; (lgpl.htm) if not, write to the Free Software
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
//
// Questions on TxWin licensing can be directed to: txwin@fsys.nl
//
// ==========================================================================
//
// TX-library and TXWindowing test program
//
// Author: J. van Wijk
//

#include <txlib.h>                              // TX library interface

#include <fcntl.h>                              // low-level I/O

#include <txtver.h>                             // TXT version info
#include <txtwin.h>                             // windowed entry point
#include <txt.h>                                // TXT navigation and defs

#if defined (DUMP)
#define TXT_TRACE      "TXTSTTRACE"             // Trace startup values
#endif

#define TXT_STARTCMD    "say Hello to the TXT test program"


TXTINF      txt_anchor =
{
   FALSE,                                       // batch-mode disabled
   TRUE,                                        // dialogs will be used
   TXAO_NORMAL,                                 // normal verbosity
   TXAE_CONFIRM,                                // confirmed quit on errors
   0,                                           // overall return-code
   80, 22,                                      // visible screen area
   FALSE,                                       // auto quit on fdisk/setboot
   TRUE,                                        // reg confirm required
   FALSE,                                       // running in classic mode
   NULL,                                        // SB buffer
   0,                                           // SB size
   0,                                           // scroll-buffer window handle
   0,                                           // command handling window
   FALSE,                                       // no automatic menu at start
   TRUE,                                        // automatic pulldown drop
   0,                                           // default drop-down menu
   0,                                           // worklevel
   NULL,                                        // selection list, Color schemes
   #if defined (DOS32)
      FALSE,                                    // Windows-9x DosBox detected
   #endif
};

TXTINF       *txta  = &txt_anchor;              // TXT anchor block

static  char *separator;

char *switchhelp[] =
{
   "  [global-txtst-switches]  [TXTst-multi-command]",
   "",
#if defined (DUMP)
   " -123[t][s][n] = set trace level to 123, TXTst internal function trace;",
   "                 [t]imestamp lines; trace to [s]creen too; [n]o tracefile",
#endif
   "",
   " -?            = help on TXTst commandline switches (this text)",
   " -7            = Use 7-bit ASCII only (no 'graphic' characters)",
   " -a            = switch off usage of ANSI escape characters for color",
   " -b            = batch option, automatic 'batch on' command at startup",
   " -e   or  -e-  = Include or surpress (-e-) command echo before each cmd",
   " -E:[c|i|q]    = default error strategy Confirm, Ignore or Quit",
   " -f            = frame, use a border-frame on scroll-buffer and desktop",
   " -f-           = do not use border-frames. (default NO on 80x25 screen)",
   " -l:logfile    = start logging immediately to 'logfile.log'",
   " -menu         = automatic menu at startup and after each menu-selection",
   " -O:[n|v|q|m]  = default output verbosity Normal, Verbose, Quiet, Maximum",
   " -P-           = don't use prompting and input dialog windows by default",
   " -q            = quiet option, automatic 'screen off' command at startup",
   " -Q            = quit automatically after executing specified command",
   " -Q-           = do NOT quit automatically on normally autoquiting commands",
   " -r:regfile    = registration filename with optional path and extension",
   " -S            = Shell mode, do not allow quit from TXTst (use as shell)",
   " -s:separator  = specify a command-separator character, default is '#'",
   " -t   or  -t-  = Include or surpress (-t-) timestamp before each command",
   " -scheme:name  = Window scheme: grey|3d|nobl|cmdr|half|full|white|black|dfsee",
   " -color:value  = Output colors, 0..7 add any: 0=std 1=invert 2=bright 4=blue",
   " -style:value  = Line style, 0..3: 0=std-double 1=3d 2=halfblock 3=fullblock",
   " -w   or  -w+  = use windowing, even if command would surpress that",
   " -w-           = do NOT use windowing, default is -w+ (windowing)",
   " -W:[sl]       = Screen resize dialog if screen is more than [sl] lines",
#if defined (WIN32)
   " -W:0 or  -W   = Screen resize dialog if scrollbars are present on window",
#else
   " -W:0 or  -W   = Screen resize dialog if scrollbars are likely (lines > 40)",
#endif
   "",
   " For help on TXTst commands, use the '?' command and use the <F1>",
   " key when shown at bottom line",
   "",
   NULL
};


char               *cmdhelptxt[] =
{
   " ?            [*] = Show list of generic commands with short description",
   " alloc     [size] = Allocate memory, default is in Mib, -k is Kib",
   " boot      [cold] = Reboot the system, warm or cold",
   " cd        [path] = Change current directory an current drive",
   " conf      [text] = Display confirmation dialog window with 'text'",
   " cursor [col,row] = Show, and optionally set the cursor position",
   " dlg              = pop-up a test dialog from windowed mode",
   " display          = Show display size, rows and columns",
   " help         [*] = Show list of generic commands with short description",
   " log       [file] = Log (append) to 'file' (.log); (No file => stop logging)",
   " lines   [number] = Write lines of text, for display performance tests",
   " listbox          = Start listbox test dialog window",
   " mode [x,y] [-w-] = Set screen size and windowing mode, -w- is non-windowed",
   " msgbox    [text] = Show a MessageBox with the supplied text",
   " opt  option-char = Show value for option-char as set by last 'parse'",
   " pack   in [o][m] = Compress file 'in' to [o], using method [m]",
   " parse cmd-string = Parse command string to options and arguments",
   " pdrop      [all] = Drop one or all levels of parsed commands",
   " pshow      [all] = Show one or all levels of parsed commands",
   " prompt   [quest] = Prompt for a value using the 'quest' text as question",
   " pbuf [$]s/f  [m] = Compress+Decompress string/file using method [m]",
   " prep [$]s [c][s] = Measure compress string/file [cnt] times, size [s] Kib",
   " screen  [on|off] = Switch output to the screen on or off",
   " setansi [on|off] = Set use of ANSI escape-sequences (colors) on or off",
   " sbnum            = Number lines in scroll-buffer for testing",
   " scrfile [fn] [l] = Save screen-buffer to file [fn], last [l] lines",
   " unpack in [o][m] = De-compress file 'in' to [o], using method [m]",
   " vol     [floppy] = Show all volumes, optional including floppies",
   " vols    [floppy] = Show all volumes, as a single string",
#if defined (DUMP)
   " trace [lvl]      = Set trace level for TXT internal function tracing",
#endif
#if defined (DEV32)
   " run macro        = Run a TXT macro in a .TXT file",
#else
#endif
   " q                = Quit",
   NULL
};


static  char       txtMsgTitle[] = " Test Message box ";
static  char       txtMsgText[]  =
  "This is message text to test the txwMessageBox. It has some long lines that "
  "need to be split by the Box and also some that are short enough already.\n"
  "So let us see if that works, with an empty line:\n\nAnd a last one ...";

static  char       txtPromptTitle[] = " Test Prompt box ";
static  char       txtPromptText[]  =
  "This is message text to test the txwPromptBox. Fill in any value ...";



// Interactive TXT mode
static ULONG txtInteractive
(
   char               *cmdstring                // IN    initial command
);

// Interpret and execute TXTst command;
static ULONG txtSingleCommand
(
   char               *txtcmd,                  // IN    TXT command
   BOOL                echo,                    // IN    Echo command
   BOOL                quiet                    // IN    screen-off during cmd
);


int main (int argc, char *argv[]);

/*****************************************************************************/
/* Main function of the program, handle commandline-arguments                */
/*****************************************************************************/
int main (int argc, char *argv[])
{
   ULONG               rc = NO_ERROR;           // function return
   char               *exename = argv[0];       // save before INITmain

   TxINITmain( TXT_TRACE, "TXT", FALSE, 0);     // TX Init code, incl tracing
                                                // argv/argc modified if TRACE

   if (TxaExeSwitch('l'))                       // start logfile now ?
   {
      TxAppendToLogFile( TxaExeSwitchStr( 'l', "txt Logfile", "TXTest"));
   }
   if (TxaExeSwitch('?'))                       // switch help requested
   {
      TxPrint( "\nUsage: %s ", exename);
      TxShowTxt( switchhelp);
   }
   else
   {
      TXLN          ar;                         // arguments

      strcpy( ar,  TXT_STARTCMD);               // default command

      if (TxaExeSwitch('Q'))
      {
         txta->autoquit = TRUE;                 // auto quit after cmd
         txta->nowindow = TRUE;                 // default no win on autoquit
      }

      if (TxaExeSwitch('b'))
      {
         txta->batch     = TRUE;                // set global force on
      }
      separator          = TxaExeSwitchStr(    's', "SeparatorCh", "#");
      txta->eStrategy    = TxaErrorStrategy(   'E', txta->batch);
      txta->verbosity    = TxaOutputVerbosity( 'O');

      if (rc == NO_ERROR)
      {
         if (TxaExeArgc() > 1)                  // arguments given
         {
            char    qstring[3] = "?q";

            qstring[0] = separator[0];          // use current separator

            TxaGetArgString( TXA_1ST, 1, TXA_ALL, TXMAXLN, ar);
            if (strstr( ar, qstring) != NULL)
            {
               txta->nowindow = TRUE;           // don't use windowing
            }
            else if ((TxaExeArgc() > 1)  &&
                     (strnicmp( TxaExeArgv(1), "nonag", 5) == 0))
            {
               if (strnicmp( TxaExeArgv(1), "query", 5) == 0)
               {
                  txta->regconfirm = FALSE;     // no reg-nagging for now ...
               }
               if (!TxaExeSwitchUnSet('Q'))     // no -Q-
               {
                  txta->nowindow = TRUE;        // don't use windowing
                  txta->autoquit = TRUE;        // auto quit after cmd
               }
            }
         }

         if (TxaExeSwitchSet('w'))              // explicit windowing setting
         {
            if (TxaOption('w'))                 // set windowing on
            {
               txta->nowindow = FALSE;          // use windowing
            }
            else
            {
               txta->nowindow = TRUE;           // don't use windowing
            }
         }
         do
         {
            if (txta->nowindow)
            {
               txta->dialogs = FALSE;           // dialogs not supported
               txtInteractive( ar);             // non windowed interface
            }
            else
            {
               txta->dialogs = !TxaExeSwitchUnSet('P');
               txtWindowed(    ar);             // windowed interface
            }
            strcpy( ar, "display");             // new initial command

         } while (txta->retc == TX_DISPLAY_CHANGE);

         rc = txta->retc;
//       TxrRegistrationInfo( TXREG_CONFIRM_ONLY, TXT_V, txta->regconfirm);
      }
   }
   TxEXITmain(rc);                              // TX Exit code, incl tracing
}                                               // end 'main'
/*---------------------------------------------------------------------------*/


/*****************************************************************************/
// Print TXTst logo+status, do startup checks, run startup commands + profile
/*****************************************************************************/
ULONG txtStartupLogo                            // RET   Checks and firstcmd RC
(
   char               *firstcmd                 // IN    initial command
)
{
   ULONG               rc = NO_ERROR;
   FILE               *fp;
   TXTM                osd;                     // OS description string
   TXLN                msg;

   ENTER();
   TRACES(("Startup command is '%s'\n", firstcmd));

   TxPrint(  "\n  TxWindows Test program; version %s  %s\n", TXT_V, TXT_C);
   TxPrint(  " ÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍ[ www.dfsee.com"
             " ]ÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍ\n\n");

   if (TxaExeSwitch('S'))
   {
      TxPrint(  "%16.16sRun as SHELL  %s-S%s, quit and <F3> are disabled\n\n",
                "", CBC, CNN);
   }

   (void) TxOsVersion( osd);                    // get/check OS version info
   strcpy( msg, "");
   #if   defined (WIN32)
      if (strstr( osd, "Windows-9") != NULL)    // Win-9x detected
      {
         strcpy( msg, "Windows-9x is not supported by this "
                      "version of TXTst!  Use TXTDOS.EXE after "
                      "'Restart in MS-DOS mode' or use a DOS bootdisk.");
      }
   #elif defined (DOS32)
      if (strstr( osd, "DosBox") != NULL)       // Win or OS/2 DosBox (VDM)
      {
         if (strstr( osd, "Windows-9") != NULL) // Win-9x detected
         {
            txta->win9x = TRUE;

            strcpy( msg, "Running TXTDOS.EXE in a Win9x DosBox might "
                         "give unpredictable results!  Use TXTDOS.EXE after "
                         "'Restart in MS-DOS mode' or use a DOS bootdisk.");
         }
         else
         {
            sprintf( msg, "Running TXTDOS.EXE in a virtual DosBox "
                          "might give unpredictable results! Please use "
                          "the native version TXT%s.EXE when possible.",
                           (strstr( osd, "Win")) ? "WIN" : "OS2");
         }
      }
      else if (strstr( osd, "MemMgr") != NULL)  // EMM386 or other manager
      {
         strcpy( msg, "Running TXTDOS.EXE under a Memory Manager like "
                      "EMM386 or QEMM might give unpredictable results! "
                      "For maximum reliability, run without any external "
                      "memory manager (check autoexec.bat and config.sys).");
      }
   #else
      //- OS2 and LINUX versions
   #endif

   txtBEGINWORK();
   if (strlen( msg) != 0)                       // OS versus TXTst mismatch
   {
      if (txta->batch)                          // just show to screen/log
      {
         strcat( msg, "\n\n");
         TxMessage( FALSE, 5004, msg);
      }
      else                                      // interactive, confirm
      {
         strcat( msg, "\n\nDo you want to take the risk and continue with the program ? [Y/N]: ");
         if (!TxConfirm( 5004, msg))
         {
            rc = TXT_QUIT;
         }
      }
   }

   if (rc == NO_ERROR)                          // not aborted yet ...
   {
      if ((fp = fopen( TXT_PROFILE, "r")) != NULL)
      {
         TXLN             command;

         fclose( fp);
         sprintf( command, "run %s", TXT_PROFILE);
         txtMultiCommand( command, TRUE, FALSE, FALSE); // exec profile
      }

      if (strlen( firstcmd))
      {
         if (strstr( firstcmd, "about") == NULL) // no about in command
         {
            txtMultiCommand( "about -c- -P-", FALSE, FALSE, FALSE);
         }
         rc = txtMultiCommand( firstcmd, TRUE, FALSE, FALSE); // execute command
      }
   }
   txtENDWORK();
   RETURN (rc);
}                                               // end 'txtStartupLogo'
/*---------------------------------------------------------------------------*/


/*****************************************************************************/
// Use classic text mode and accept interactive display commands
/*****************************************************************************/
static ULONG txtInteractive
(
   char               *cmdstring                // IN    initial command
)
{
   ULONG               rc;
   TXLN                command;                 // txt command

   ENTER();

   rc = txtStartupLogo( cmdstring);
   while ((rc != TXT_QUIT) && !txta->autoquit)
   {
      TxPrint("%s; cmd/SN : ",  TXT_N);
      fflush( stdout);
      memset( command, 0, TXMAXLN);
      fgets(  command, TXMAXLN, stdin);         // get next command
      TxRepl( command, '\n', 0);
      TxCancelAbort();                          // reset pending abort status
      rc = txtMultiCommand( command, TRUE, TRUE, FALSE);
   }
   RETURN ( txta->retc);
}                                               // end 'txtInteractive'
/*---------------------------------------------------------------------------*/


/*****************************************************************************/
// Execute multiple txt-commands separated by # characters
/*****************************************************************************/
ULONG txtMultiCommand
(
   char               *cmdstring,               // IN    multiple command
   BOOL                echo,                    // IN    Echo  before execute
   BOOL                prompt,                  // IN    prompt after execute
   BOOL                quiet                    // IN    screen-off during cmd
)
{
   ULONG               rc = NO_ERROR;
   TXLN                cmdcopy;                 // modifyable copy
   char               *nextcmd;                 // next of multiple commands
   char               *command;                 // txt command

   ENTER();

   txtBEGINWORK();                              // signal work starting
   TRACES(("Worklevel: %lu Cmdstring: '%s'\n", txta->worklevel, cmdstring));
   if (strlen( cmdstring) != 0)                 // replace empty by space
   {
      strcpy( cmdcopy, cmdstring);
      for ( command  = cmdcopy;
           (command != NULL) && !TxAbort();     // abort from long multi
            command  = nextcmd)                 // cmds must be possible!
      {
         if ((nextcmd = strchr( command, separator[0])) != NULL)
         {
            *nextcmd = '\0';                    // remove separator
            nextcmd++;
         }
         TxCancelAbort();                       // reset pending abort status
         TRACES(("Command: '%s'  Nextcmd: '%s'\n", command, (nextcmd) ? nextcmd : ""));
         rc = txtSingleCommand( command, echo, quiet);
         if (nextcmd != NULL)
         {
            *(nextcmd -1) = separator[0];       // put separator back
         }
      }
   }
   else
   {
      rc = txtSingleCommand( " ", TRUE, FALSE); // default cmd, <ENTER>
   }
   txtENDWORK();                                // signal work done
   if ((rc == TXT_QUIT) && (TxaExeSwitch('S')))
   {
      TxPrint( "\nTXTst is running in SHELL mode, quit is not allowed ...\n");
      rc = NO_ERROR;
   }
   RETURN (rc);
}                                               // end 'txtMultiCommand'
/*---------------------------------------------------------------------------*/


/*****************************************************************************/
// Interpret and execute DHPFS command;
/*****************************************************************************/
static ULONG txtSingleCommand
(
   char               *txtcmd,                  // IN    TXT command
   BOOL                echo,                    // IN    Echo command
   BOOL                quiet                    // IN    screen-off during cmd
)
{
   ULONG               rc;
   TXLN                dc;
   int                 cc = 0;                  // command string count
   char               *c0, *c1, *c2, *c3, *c4;  // parsed command parts
   TXLN                s0, s1;                  // temporary string space
   char               *pp;                      // parameter pointers
   USHORT              ml = 0;                  // mixed string length
   USHORT              cp = 0;                  // cursor position
   ULONG               size;
   ULONG               count;
   FILE               *fi;
   int                 fh;                      // low-level file handle
   TXHANDLE            ph = 0;                  // parse handle
   BOOL                l_force   = FALSE;       // local batch-mode used
   BOOL                l_dialogs = FALSE;       // local dialogs set
   BOOL                v_dialogs;               // saved dialogs copy
   BOOL                l_errst   = FALSE;       // local error strategy
   int                 v_errst;                 // saved copy
   BOOL                l_verbo   = FALSE;       // local verbosity
   ULONG               v_verbo;                 // saved copy
   DEVICE_STATE        v_screen;                // saved copy screen state

   ENTER();

   TxaParseCommandString( txtcmd, TRUE, NULL);  // parse, free-format
   pp = TxaGetArgString( TXA_CUR, 0, 0, TXMAXLN, dc); // dc = pp => cmd from arg 0
   cc = TxaArgCount( );                         // number of parameters
   c0 = TxaArgValue(0);
   c1 = TxaArgValue(1);
   c2 = TxaArgValue(2);
   c3 = TxaArgValue(3);
   c4 = TxaArgValue(4);

   for (pp = &(dc[0]) + strlen(c0); *pp == ' '; pp++) {};

   if (TxaOption('-'))                          // option --
   {
      TxPrint("Command  : '%s'\n", dc);
      TxaShowParsedCommand( TRUE);              // option diagnostic
   }
   if (TxaOption('Q'))                          // locally forced quiet
   {
      quiet = TRUE;                             // force input parameter
   }
   if (TxaOption('B'))                          // local batch mode
   {
      if (txta->batch == FALSE)                 // no global force yet
      {
         txta->batch  =  TRUE;                  // register force globally
         l_force = TRUE;                        // use local force
      }
   }
   if ((txta->batch) || (TxaOptSet('P')))       // batch or local -P option
   {
      v_dialogs    = txta->dialogs;             // save old value
      l_dialogs    = TRUE;                      // and signal restore

      txta->dialogs = (TxaOption('P') != 0);
   }
   if (TxaOptValue('E') != NULL)                // local error strategy
   {
      v_errst = txta->eStrategy;
      l_errst = TRUE;
      txta->eStrategy = TxaErrorStrategy(   'E', txta->batch);
   }
   if (TxaOptValue('O') != NULL)                // local output verbosity
   {
      v_verbo = txta->verbosity;
      l_verbo = TRUE;
      txta->verbosity = TxaOutputVerbosity( 'O');
   }

   TRACES(("batch: %lu   eStrategy: %u    Verbosity: %lu\n",
      txta->batch, txta->eStrategy, txta->verbosity));

   if ((echo == TRUE) && (stricmp(c0, "screen" ) != 0)
                      && (stricmp(c0, "say"    ) != 0))
   {
      if (!TxaExeSwitchUnSet('e'))              // no surpress echo ?
      {
         TxPrint("%s%s version : %4.4s executing: %s%s%s\n",
                  (quiet)   ? "" : "\n",  TXT_N, TXT_V, CBG,
                  (cc == 0) ? "<Enter>" : txtcmd, CNN);
      }

      if ( (TxaExeSwitch('t') || TxaExeSwitch('q') || TxaExeSwitch('l')) &&
          (!TxaExeSwitchUnSet('t')))            // no surpress timestamp ?
      {
         time_t           tt = time( &tt);      // current date/time

         strftime( s0, TXMAXLN, "%A %d-%m-%Y %H:%M:%S", localtime( &tt));
         TxPrint( "Execute timestamp : %s\n", s0);
      }
   }

   v_screen = TxScreenState( DEVICE_TEST);
   if (quiet)
   {
      TxScreenState( DEVICE_OFF);
   }

   TRACES(("cc: %u c0:'%s' c1:'%s' c2:'%s' c3:'%s' c4:'%s' pp:'%s'\n",
            cc,    c0,     c1,     c2,     c3,     c4,     pp));

   rc = TxStdCommand();
   if ((rc == TX_PENDING) || (rc == TX_CMD_UNKNOWN))
   {
      rc = NO_ERROR;
      if      (stricmp(c0, "sep"      ) == 0)
      {
         if (cc > 1)
         {
            separator[0] = c1[0];
         }
      }
      else if (stricmp(c0, "menu"      ) == 0)
      {
         if (TxaOption('?') || (c1[0] == '?'))  // explicit help request
         {
            TxPrint("\nActivate the menu with default or selected pulldown\n");
            TxPrint("\n Usage:  %s  [pulldown-select-letter]\n\n"
                      "                f = File\n"
                      "                t = Test\n"
                      "                d = Display\n"
                      "                s = Settings\n"
                      "                h = Help\n", c0);
         }
         else
         {
            if (txta->automenu)
            {
               txta->menuOwner = TXHWND_DESKTOP;
            }
            txta->menuopen = (ULONG) c1[0];
         }
      }
      else if (stricmp(c0, "about"     ) == 0)
      {
         BOOL          plaintext;
         TX1K          about;                   // about text
         TXLN          text;                    // one line of text
         TXTS          alead;                   // leader text

         plaintext = (TxaOptUnSet('P') || (!txwIsWindow( TXHWND_DESKTOP)));
         strcpy( alead, (plaintext) ? "     " : "");
         if (!TxaOptUnSet('c'))                 // show program copyright ?
         {
            sprintf( about, "%s               Details on this "
                            "Fsys Software program\n\n%s   %s : %s %s\n",
                             alead, alead, TXT_N, TXT_V, TXT_C);
         }
         else
         {
            strcpy( about, "");
         }
         sprintf( text,  "%sUI TxWindows : %s\n", alead, txVersionString());
         strcat( about, text);
         sprintf( text,  "%s'C' compiler : ",     alead);
         strcat( about, text);
         #if defined (__WATCOMC__)
            if (__WATCOMC__ > 1100)             // must be OpenWatcom
            {
               sprintf( text, "OpenWatcom %4.2lf (c) 1988-2004: "
                               "Sybase & openwatcom.org\n",
                              ((double) ( __WATCOMC__ - 1100)) / 100);
            }
            else
            {
               sprintf( text, "Watcom C/C++ version : %4.2lf\n",
                              ((double) ( __WATCOMC__ )) / 100);
            }
         #else
            #if defined (DEV32)
               sprintf( text, "VisualAge  3.65 (c) 1991-1997: IBM Corporation\n");
            #else
               sprintf( text, "Visual C++ 5.0  (c) 1986-1997: Microsoft Corporation\n");
            #endif
         #endif
         strcat( about, text);
         sprintf( text, "%sEXE compress : ", alead);
         strcat( about, text);
         #if defined (DEV32)
            sprintf( text,    "lxLite     1.33 (c) 1996-2003: Max Alekseyev\n");
         #else
            sprintf( text,    "UPX        1.20 (c) 1996-2002: Markus Oberhumer\n");
         #endif
         strcat( about, text);
         #if defined (DOS32)
            sprintf( text,  "%sDOS extender : %s\n", alead, txDosExtVersion());
            strcat(  about, text);
         #endif
         (void) TxOsVersion( s0);               // Get operating system version
         sprintf( text,  "%sOS   version : %s\n", alead, s0);
         strcat( about, text);
         #if defined (DOS32)
            sprintf( text,  "%sDPMI version : %s\n", alead, txDosExtDpmiInfo());
            strcat(  about, text);
         #endif
/*
         if (!TxaOptUnSet('c'))                 // show program copyright and
         {                                      // short registration info ?
            sprintf( text, "\n%sRegistration : ", alead);
            strcat( about, text);
            strcat( about, TxrRegistrationString( text));
         }
         else                                   // seperate (c) and reg confirm
         {
            TxrRegistrationInfo( TXREG_DISPLAY_CONFIRM, TXT_V, txta->regconfirm);
         }
*/
         strcat( about, "\n");

         TxMessage( !(txta->batch || plaintext), 5003, about);
      }