/************************************************************************

 *

 * driver.cpp - definitions of the test driver

 *

 * $Id: driver.cpp 290009 2005-09-18 23:28:26Z sebor $

 *

 ************************************************************************

 *

 * Copyright (c) 1994-2005 Quovadx,  Inc., acting through its  Rogue Wave

 * Software division. Licensed under the Apache License, Version 2.0 (the

 * "License");  you may  not use this file except  in compliance with the

 * License.    You    may   obtain   a   copy   of    the   License    at

 * http://www.apache.org/licenses/LICENSE-2.0.    Unless   required    by

 * applicable law  or agreed to  in writing,  software  distributed under

 * the License is distributed on an "AS IS" BASIS,  WITHOUT WARRANTIES OR

 * CONDITIONS OF  ANY KIND, either  express or implied.  See  the License

 * for the specific language governing permissions  and limitations under

 * the License.

 *

 **************************************************************************/

// expand _TEST_EXPORT macros

#define _RWSTD_TEST_SRC

#include "opt_diags.h"

#include "opt_lines.h"

#include "opt_trace.h"

#include "opt_types.h"

#include <cmdopt.h>    // for rw_setopts()

#include <printf.h>    // for rw_snprintfa()

#include <assert.h>    // for assert

#include <setjmp.h>    // for longjmp, setjmp, ...

#include <stdarg.h>    // for va_list

#include <stdio.h>     // for fileno, fprintf

#include <stdlib.h>    // for free

#include <string.h>    // for strchr, strcpy

#include"std_log_result.h"

#define LOG_FILENAME_LINE __FILE__, __LINE__

#if !defined (_WIN32) && !defined (_WIN64)

#  include <unistd.h>    // for isatty

// declare fileno in case it's not declared (for strict ANSI conformance)

extern "C" {

}   // extern "C"

#else

   // no isatty on Windoze

#  define _RWSTD_NO_ISATTY

#endif   // _WIN{32,64}

// expand _TEST_EXPORT macros

#define _RWSTD_TEST_SRC

#include <driver.h>

/************************************************************************/

#define RW_TEST_STRSTR(x)   #x

#define RW_TEST_STR(x)      RW_TEST_STRSTR(x)

#ifndef RW_TEST_COMPILER

#  if defined (__DECCXX__)

#    define RW_TEST_COMPILER "Compaq C++, __DECCXX__ = " \

            RW_TEST_STR (__DECCXX__)

#  elif defined (__INTEL_COMPILER)

#    if defined (__EDG_VERSION__)

#      define RW_TEST_ICC_EDG_VER \

              ", __EDG_VERSION__ = "  RW_TEST_STR (__EDG_VERSION__)

#    else

#      define RW_TEST_ICC_EDG_VER ""

#    endif

#    if defined (_MSC_VER)

#      define RW_TEST_COMPILER "Intel C++, __INTEL_COMPILER = " \

              RW_TEST_STR (__INTEL_COMPILER) ", _MSC_VER = " \

              RW_TEST_STR (_MSC_VER) \

              RW_TEST_ICC_EDG_VER

#    elif defined (__INTEL_COMPILER_BUILD_DATE)

#      define RW_TEST_COMPILER "Intel C++, __INTEL_COMPILER = " \

              RW_TEST_STR (__INTEL_COMPILER) \

              ", __INTEL_COMPILER_BUILD_DATE = " \

              RW_TEST_STR (__INTEL_COMPILER_BUILD_DATE) \

              RW_TEST_ICC_EDG_VER

#    else

#      define RW_TEST_COMPILER "Intel C++, __INTEL_COMPILER = " \

              RW_TEST_STR (__INTEL_COMPILER) \

              RW_TEST_ICC_EDG_VER

#    endif

#  elif defined (__GNUC__)

#    if defined (__VERSION__)

#      define RW_TEST_GCC_VER ", __VERSION__ = \"" __VERSION__ "\""

#    else

#      define RW_TEST_GCC_VER ""

#    endif

#    if defined (__GNUC_PATCHLEVEL__)

#      define RW_TEST_COMPILER "gcc "            \

              RW_TEST_STR (__GNUC__) "."         \

              RW_TEST_STR (__GNUC_MINOR__) "."   \

              RW_TEST_STR (__GNUC_PATCHLEVEL__)  \

              RW_TEST_GCC_VER

#    else

#      define RW_TEST_COMPILER "gcc " \

              RW_TEST_STR (__GNUC__) "." RW_TEST_STR (__GNUC_MINOR__) 

              RW_TEST_GCC_VER

#    endif

#  elif defined (_COMPILER_VERSION) && defined (__sgi)

#    define RW_TEST_COMPILER "SGI MIPSpro, _COMPILER_VERSION = " \

            RW_TEST_STR (_COMPILER_VERSION)

#  elif defined (__INTEL_COMPILER)

#    if defined (_MSC_VER)

#      define RW_TEST_COMPILER "Intel C++, __INTEL_COMPILER = " \

              RW_TEST_STR (__INTEL_COMPILER) ", _MSC_VER = " \

              RW_TEST_STR (_MSC_VER)

#    else

#      define RW_TEST_COMPILER "Intel C++, __INTEL_COMPILER = " \

              RW_TEST_STR (__INTEL_COMPILER)

#    endif

#  elif defined (__EDG__)

#    define RW_TEST_COMPILER "EDG eccp, __EDG_VERSION__ = " \

            RW_TEST_STR (__EDG_VERSION__)

#  elif defined (__HP_aCC)

#    define RW_TEST_COMPILER "HP aCC, __HP_aCC = " \

            RW_TEST_STR (__HP_aCC)

#  elif defined (__IBMCPP__)

#    define RW_TEST_COMPILER "IBM VisualAge C++, __IBMCPP__ = " \

            RW_TEST_STR (__IBMCPP__)

#  elif defined (_MSC_VER)

#    define RW_TEST_COMPILER "MSVC, _MSC_VER = " \

            RW_TEST_STR (_MSC_VER)

#  elif defined (__SUNPRO_CC)

#    define RW_TEST_COMPILER "SunPro, __SUNPRO_CC = " \

            RW_TEST_STR (__SUNPRO_CC)

#  else

#    define RW_TEST_COMPILER "unknown"

#  endif

#endif

#ifndef RW_TEST_LIBSTD

#  ifdef _RWSTD_VER

#    define RW_TEST_LIBSTD "Rogue Wave C++ Standard Library, " \

            "_RWSTD_VER = " RW_TEST_STR (_RWSTD_VER)

#  elif defined (__GLIBCXX__)

#    define RW_TEST_LIBSTD "GNU C++ Standard Library, " \

            "__GLIBCXX__ = " \

            RW_TEST_STR (__GLIBCXX__)

#  elif defined (_STLPORT_VERSION)

     // check for STLport before SGI STL since STLport,

     // being derived from SGI STL, #defines both macros

#    define RW_TEST_LIBSTD "STLport, " \

            "_STLPORT_VERSION = " \

            RW_TEST_STR (_STLPORT_VERSION)

#  elif defined (__SGI_STL)

#    define RW_TEST_LIBSTD "SGI STL, " \

            "__SGI_STL = " \

            RW_TEST_STR (__SGI_STL)

#  elif defined (_YVALS)

     // is there a better way to identify the Dinkumware

     // implementation? does it have a version macro?

#    define RW_TEST_LIBSTD "Dinkum C++ Standard Library"

#  endif

#endif   // RW_TEST_LIBSTD

#ifndef RW_TEST_HARDWARE

#  if defined (__alpha__) || defined (__alpha)

#    define RW_TEST_ARCH "alpha"

#  elif defined (__amd64__) || defined (__amd64)

#    if defined (__LP64__) || defined (_LP64)

#      define RW_TEST_ARCH "amd64/LP64"

#    else

#      define RW_TEST_ARCH "amd64/ILP32"

#    endif

#  elif defined (_PA_RISC2_0)

#    define RW_TEST_ARCH "pa-risc 2.0"

#  elif defined (_PA_RISC1_0)

#    define RW_TEST_ARCH "pa-risc 1.0"

#  elif defined (__hppa)

#    define RW_TEST_ARCH "pa-risc"

#  elif defined (__pentiumpro__) || defined (__pentiumpro)

#    define RW_TEST_ARCH "pentiumpro"

#  elif defined (__pentium__) || defined (__pentium)

#    define RW_TEST_ARCH "pentium"

#  elif defined (__i486__) || defined (__i486)

#    define RW_TEST_ARCH "i486"

#  elif defined (__i386__) || defined (__i386)

#    define RW_TEST_ARCH "i386"

#  elif defined (__i586__) || defined (__i586)

#    define RW_TEST_ARCH "i586"

#  elif defined (__ia64)

#    define RW_TEST_ARCH "ia64"

#  elif defined (__mips)

#    define RW_TEST_ARCH "mips"

#  elif defined (__sparcv9)

#    define RW_TEST_ARCH "sparc-v9"

#  elif defined (__sparcv8)

#    define RW_TEST_ARCH "sparc-v8"

#  elif defined (__sparc)

#    define RW_TEST_ARCH "sparc"

#  elif defined (_POWER)

#    if defined (_ARCH_PWR5)

#      define RW_TEST_ARCH "power-5"

#    elif defined (_ARCH_PWR4)

#      define RW_TEST_ARCH "power-4"

#    elif defined (_ARCH_PWR3)

#      define RW_TEST_ARCH "power-3"

#    elif defined (_ARCH_604)

#      define RW_TEST_ARCH "powerpc-604"

#    elif defined (_ARCH_603)

#      define RW_TEST_ARCH "powerpc-603"

#    elif defined (_ARCH_602)

#      define RW_TEST_ARCH "powerpc-602"

#    elif defined (_ARCH_601)

#      define RW_TEST_ARCH "powerpc-601"

#    elif defined (_ARCH_403)

#      define RW_TEST_ARCH "powerpc-403"

#    elif defined (_ARCH_PPC64)

#      define RW_TEST_ARCH "powerpc/LP64"

#    else

#      define RW_TEST_ARCH "powerpc"

#    endif

#  elif defined (_WIN64)

#    define RW_TEST_ARCH "ia64"

#  elif defined (_WIN32)

#    define RW_TEST_ARCH "i86"

#  elif defined (__x86_64__) || defined (__x86_64)

#    if defined (__LP64__) || defined (_LP64)

#      define RW_TEST_ARCH "x86_64/LP64"

#    else

#      define RW_TEST_ARCH "x86_64/ILP32"

#    endif

#  else

#    define RW_TEST_ARCH "unknown"

#  endif

#  if defined (_AIX54)

#    define RW_TEST_OS "aix-5.4 (or better)"

#  elif defined (_AIX53)

#    define RW_TEST_OS "aix-5.3"

#  elif defined (_AIX52)

#    define RW_TEST_OS "aix-5.2"

#  elif defined (_AIX51)

#    define RW_TEST_OS "aix-5.1"

#  elif defined (_AIX50)

#    define RW_TEST_OS "aix-5.0"

#  elif defined (_AIX43)

#    define RW_TEST_OS "aix-4.3"

#  elif defined (_AIX41)

#    define RW_TEST_OS "aix-4.1"

#  elif defined (_AIX32)

#    define RW_TEST_OS "aix-3.2"

#  elif defined (_AIX)

#    define RW_TEST_OS "aix"

#  elif defined (__hpux)

#    define RW_TEST_OS "hp-ux"

#  elif defined (__osf__)

#    define RW_TEST_OS "tru64-unix"

#  elif defined (__sgi) && defined (__mips)

#    define RW_TEST_OS "irix"

#  elif defined (__linux__) || defined (__linux)

     // get Linux release string (UTS_RELEASE)

#    include <linux/version.h>

#    ifndef UTS_RELEASE

#      define UTS_RELEASE "(unknown release)"

#    endif   // UTS_RELEASE

#    if defined (__ELF__)

#      define LINUX_TYPE "linux-elf"

#    else

#      define LINUX_TYPE "linux"

#    endif

#    define RW_TEST_OS LINUX_TYPE " "     \

            UTS_RELEASE " with glibc "    \

            RW_TEST_STR (__GLIBC__) "."   \

            RW_TEST_STR (__GLIBC_MINOR__)

#  elif defined (__SunOS_5_10)

#    define RW_TEST_OS "sunos-5.10"

#  elif defined (__SunOS_5_9)

#    define RW_TEST_OS "sunos-5.9"

#  elif defined (__SunOS_5_8)

#    define RW_TEST_OS "sunos-5.8"

#  elif defined (__SunOS_5_7)

#    define RW_TEST_OS "sunos-5.7"

#  elif defined (__SunOS_5_6)

#    define RW_TEST_OS "sunos-5.6"

#  elif defined (__sun__)

#    define RW_TEST_OS "sunos"

#  elif defined (_WIN64)

#    define RW_TEST_OS "win64"

#  elif defined (_WIN32)

#    define RW_TEST_OS "win32"

#  else

#    define RW_TEST_OS "unknown"

#  endif

#  define RW_TEST_HARDWARE RW_TEST_ARCH " running " RW_TEST_OS

#else

#  define RW_TEST_HARDWARE "unknown"

#endif

/************************************************************************/

// defined in printf.cpp but not declared in printf.h

_TEST_EXPORT int

rw_vasnprintf (char**, size_t*, const char*, va_list);

/************************************************************************/

// array to store the number of each type of diagnostic

static int

ndiags [N_DIAG_TYPES][2] /* = { { total, active }, ... }*/;

static FILE *ftestout;

static jmp_buf test_env;

// set to 1 after the driver has been initialized

static int driver_initialized = 0;

// set to 1 after the driver has finished running

static int driver_finished = 0;

#if 0   // disabled

// %S: severity

// %M: diagnostic

// %m: diagnostic if not empty

// %F: file name

// %f: file name if not empty

// %C: clause

// %c: clause if not empty

// %L: line number

// %l: line number if valid

// %T: text

// %t: text if not empty

static char diag_pattern [80];

#endif

// option: use CSV format (comma separated values)

static int _rw_opt_csv = 0;

static char clause_id [80];

/************************************************************************/

#define CHECK_INIT(init, func)   _rw_check_init (init, __LINE__, func)

static inline void

_rw_check_init (bool init, int line, const char *func)

{

    if (init && !driver_initialized) {

        fprintf (stderr, "%s:%d: %s: test driver already initialized\n",

                 __FILE__, line, func);

     std_log(LOG_FILENAME_LINE,"%s:%d: %s: test driver already initialized\n",

                 __FILE__, line, func);                 

        abort ();

    }

    if (!init && driver_initialized) {

        fprintf (stderr, "%s:%d: %s: test driver not initialized yet\n",

                 __FILE__, line, func);

      std_log(LOG_FILENAME_LINE,"%s:%d: %s: test driver not initialized yet\n",

                 __FILE__, line, func);                  

        abort ();

    }

    if (driver_finished) {

        fprintf (stderr, "%s:%d: %s: test finished, cannot call\n",

                 __FILE__, line, func);

     std_log(LOG_FILENAME_LINE,"%s:%d: %s: test finished, cannot call\n",

                 __FILE__, line, func);                 

    }

}

/************************************************************************/

static int

_rw_opt_brief (int argc, char *argv[])

{

    static int opt_brief;

    if (0 == argc) {

        // query mode: return the value of the option

        return opt_brief;

    }

    if (1 == argc && argv && 0 == argv [0]) {

        // help mode: set argv[0] to the text of the help message

        static const char helpstr[] = {

            "Enables brief mode.\n"

        };

        argv [0] = _RWSTD_CONST_CAST (char*, helpstr);

        return 0;

    }

    // set mode: enable the option

    opt_brief = 1;

    return 0;

}

/************************************************************************/

static int

_rw_opt_quiet (int argc, char *argv[])

{

    static int opt_quiet;

    if (0 == argc) {

        // query mode: return the value of the option

        return opt_quiet;

    }

    if (1 == argc && argv && 0 == argv [0]) {

        // help mode: set argv[0] to the text of the help message

        static const char helpstr[] = {

            "Enables quiet mode.\n"

            "In quiet mode only diagnostics with severity 7 and above are "

            "issued."

        };

        argv [0] = _RWSTD_CONST_CAST (char*, helpstr);

        return 0;

    }

    // set mode: enable the option

    _rw_diag_mask = ~((1 << 7) | (1 << 8) | (1 << 9));

    opt_quiet     = 1;

    return 0;

}

/************************************************************************/

static int

_rw_opt_verbose (int argc, char *argv[])

{

    static int opt_verbose;

    if (0 == argc) {

        // query mode: return the value of the option

        return opt_verbose;

    }

    if (1 == argc && argv && 0 == argv [0]) {

        // help mode: set argv[0] to the text of the help message

        static const char helpstr[] = {

            "Enables verbose mode.\n"

        };

        argv [0] = _RWSTD_CONST_CAST (char*, helpstr);

        return 0;

    }

    // set mode: enable the option

    opt_verbose = 1;

    return 0;

}

/************************************************************************/

static int

_rw_setopt_csv (int argc, char *argv[])

{

    if (1 == argc && argv && 0 == argv [0]) {

        static const char helpstr[] = {

            "Enables CSV (comma separated values) mode.\n"

        };

        argv [0] = _RWSTD_CONST_CAST (char*, helpstr);

        return 0;

    }

    _rw_opt_csv = 1;

    return 0;

}

/************************************************************************/

static int

_rw_opt_compat (int argc, char *argv[])

{

    static int opt_compat;

    if (0 == argc) {

        // query mode: return the value of the option

        return opt_compat;

    }

    if (1 == argc && argv && 0 == argv [0]) {

        // help mode: set argv[0] to the text of the help message

        static const char helpstr[] = {

            "Enables RWTest-format compatibility mode.\n"

        };

        argv [0] = _RWSTD_CONST_CAST (char*, helpstr);

        return 0;

    }

    // set mode: enable the option

    opt_compat = 1;

    return 0;

}

/************************************************************************/

static int

_rw_opt_no_stdout (int argc, char *argv[])

{

    static int opt_no_stdout;