parse_crashdo.cpp

Go to the documentation of this file.

/* This file is part of Cloudy and is copyright (C)1978-2013 by Gary J. Ferland and
 * others.  For conditions of distribution and use see copyright notice in license.txt */
/*ParseCrashDo any of several tests to check that the code can crash */
#include "cddefines.h"
#include "parser.h"
 
#ifdef _MSC_VER
        /* disable warning about undefined vars being used - one of the tests shall do exactly that */
#       pragma warning( disable : 4700 )
        /* disable warning about division by zero */
#       pragma warning( disable : 4756 )
        /*      disable warning that conditional expression is constant, true or false in if */
#       pragma warning( disable : 4127 )
#endif
 
#ifdef __INTEL_COMPILER
#       pragma warning( disable : 592 )
#endif
 
#ifdef __clang__
#       pragma clang diagnostic ignored "-Wuninitialized"
#endif
 
#ifdef __GNUC_EXCL__
#       pragma GCC diagnostic ignored "-Wuninitialized"
#       if ( __GNUC__ > 4 ) || ( __GNUC__ == 4 && __GNUC_MINOR__ >= 7 )
#       pragma GCC diagnostic ignored "-Wmaybe-uninitialized"
#       endif
#endif
 
/* this is size of array used in array bounds exceeded crash test */
const int ARR_SIZE = 10;
 
/* static variable used in undefined and bounds tests */
static double ar2[ARR_SIZE];
 
// force optimization off; any level of optimization will kill the 
// functionality of this routine
#if defined(_MSC_VER) || defined(__ICC)
#pragma optimize("", off)
#elif defined(__PGI)
#pragma global opt=0
#elif defined(__HP_aCC)
#pragma OPT_LEVEL 0
#endif
 
/*ParseCrashDo any of several tests to check that the code can crash */
void ParseCrashDo(Parser &p)
{
        double ar1, br1;
        bool lgCrash = false;
 
        DEBUG_ENTRY( "ParseCrashDo()" );
 
        /* div by 0 to get crash as check on FP environment */
        if( p.nMatch("ZERO") )
        {
                fprintf(ioQQQ," I will now div by 0 to get crash.  Hold on.\n");
                fprintf(ioQQQ," If the next line says \"I am still alive - something is wrong ....\" then there are problems.\n");
                fflush(ioQQQ);
                ar1 = 1. / ZeroNum;
                fprintf(ioQQQ," I am still alive - something is wrong, result is %e\n",
                        ar1);
                lgCrash = true;
        }
 
        /* use some undefined numbers */
        else if( p.nMatch("UNDE") )
        {
                if( p.nMatch("STAT") )
                {
                        fprintf(ioQQQ," Now I will now use an undefined static variable.  Hold on.\n");
                        fprintf(ioQQQ," This should never fail since the compiler should have automatically initialized it to zero.\n");
                        fflush(ioQQQ);
                        /*lint -e530 ar2 not initialized */
                        ar2[0] *= 1e-10;
                        /*lint +e530 ar2 not initialized */
 
                        fprintf(ioQQQ," I am still alive, this is the expected result. The "
                                "result of the multiplication of undefined by 1e-10 is "
                                "%e\n", ar2[0] );
                        fflush(ioQQQ);
                }
                else if( p.nMatch("STAC") || p.nMatch("AUTO") )
                {
                        double A_variable_which_SHOULD_be_used_uninitialized;
                        fprintf(ioQQQ," Now I will now use an undefined variable off the stack.  Hold on.\n");
                        fprintf(ioQQQ," If the next line says \"I am still alive - something is wrong ....\" then there are problems.\n");
                        fflush(ioQQQ);
                        /*lint -e530 a not initialized */
                        A_variable_which_SHOULD_be_used_uninitialized *= 1e-10f;
                        /*lint +e530 a not initialized */
 
                        fprintf(ioQQQ," I am still alive - something is wrong, the result of the multiplication of undefined by 1e-10 is %e\n", A_variable_which_SHOULD_be_used_uninitialized );
                        fflush(ioQQQ);
                }
                else 
                {
                        double *aa = (double*)MALLOC(3*sizeof(double));
                        fprintf(ioQQQ," I will now use an undefined variable off the heap obtained with malloc.  Hold on.\n");
                        /* MyIsnan is guaranteed not to crash on FPE */
                        if( MyIsnan( aa[1] ) )
                                fprintf(ioQQQ," The malloc'ed memory was set to NaN.\n" );
                        else
                                fprintf(ioQQQ," The malloc'ed memory was NOT initialized by MyMalloc.\n" );
                        fprintf(ioQQQ," If the next line says \"I am still alive - something is wrong ....\" then there are problems.\n");
                        fflush(ioQQQ);
                        /*lint -e530 aa[1] not initialized */
                        aa[1] *= 1e-10;
                        /*lint +e530 aa[1] not initialized */
                        fprintf(ioQQQ," I am still alive - something is wrong, the result of the multiplication of undefined by 1e-10 is %e\n", aa[1] );
                        fflush(ioQQQ);
                        free( aa );
                }
                lgCrash = true;
        }
 
        /* make overflow to get crash as check on FP environment */
        else if( p.nMatch("OVER") && p.nMatch("LONG") )
        { 
                long lng;
                fprintf(ioQQQ," I will now make long overflow to get crash.  Hold on.\n");
                fprintf(ioQQQ," If the next line says \"I am still alive - something is wrong ....\" then there are problems.\n");
                fflush(ioQQQ);
                lng = (long)(LONG_MAX*sqrt(1e6));
                fprintf(ioQQQ," I am still alive - something is wrong, the result was %li\n",
                        lng);
                lgCrash = true;
        }
 
        /* make overflow to get crash as check on FP environment */
        else if( p.nMatch("OVER") )
        { 
                ar1 = 1e-20; 
                fprintf(ioQQQ," I will now make floating point overflow to get crash.  Hold on.\n");
                fprintf(ioQQQ," If the next line says \"I am still alive - something is wrong ....\" then there are problems.\n");
                fflush(ioQQQ);
                br1 = DBL_MAX / ar1;
                fprintf(ioQQQ," I am still alive - something is wrong, the result was %e\n",
                        br1);
                lgCrash = true;
        }
 
        /* assert false test to get crash as check on environment */
        else if( p.nMatch("ASSE") )
        { 
                fprintf(ioQQQ," I will now assert that a false statement is true to get a crash.\n\n");
                fprintf(ioQQQ," The correct behavior is for the statement \"PROBLEM DISASTER An assert has been thrown, this is bad\" to be printed, followed by lots more scary looking messages.\n\n");
                fprintf(ioQQQ," If the next line says \"I am still alive - the assert macro is not working ....\" then there are problems.\n\n");
                fflush(ioQQQ);
                ASSERT( DBL_MAX <  ZeroNum );
                fprintf(ioQQQ," I am still alive - the assert macro is not working in this executable.\n");
                lgCrash = true;
        }
 
        /* assert ratios of zeros (NaN) to get crash as check on environment */
        else if( p.nMatch(" NAN") )
        { 
                ar1 = 0.;
                fprintf(ioQQQ," I will now make invalid operation (div 0 by 0) to get crash.  Hold on.\n");
                fprintf(ioQQQ," If the next line says \"I am still alive - something is wrong ....\" then there are problems.\n");
                fflush(ioQQQ);
                br1 = ar1 / ZeroNum;
                fprintf(ioQQQ," I am still alive - something is wrong, the result was %e\n",
                        br1);
                lgCrash = true;
        }
 
        /* assert that the set_NaN routine works properly for floats */
        else if( p.nMatch("SETN") && p.nMatch("FLOA") )
        {
                sys_float f;
                fprintf(ioQQQ," I will now initialize a float to a signaling NaN. This should never crash!\n");
                set_NaN(f);
                fprintf(ioQQQ," Initialization finished. I will now perform an operation on this variable.  Hold on.\n");
                fprintf(ioQQQ," If the next line says \"I am still alive - something is wrong ....\" then there are problems.\n");
                fflush(ioQQQ);
                f *= 2.f;
                fprintf(ioQQQ," I am still alive - something is wrong, the result was %e\n",
                        f);
                lgCrash = true;
        }
 
        /* assert that the set_NaN routine works properly for doubles */
        else if( p.nMatch("SETN") )
        {
                double d;
                fprintf(ioQQQ," I will now initialize a double to a signaling NaN. This should never crash!\n");
                set_NaN(d);
                fprintf(ioQQQ," Initialization finished. I will now perform an operation on this variable.  Hold on.\n");
                fprintf(ioQQQ," If the next line says \"I am still alive - something is wrong ....\" then there are problems.\n");
                fflush(ioQQQ);
                d *= 2.;
                fprintf(ioQQQ," I am still alive - something is wrong, the result was %e\n",
                        d);
                lgCrash = true;
        }
 
        /* test what happens with an array index out of bounds
         * two options, low for [<0] and high for [>limit] */
        else if( p.nMatch("BOUN") )
        {
                double x;
 
                /* read offset */
                x = p.FFmtRead();
                if( p.lgEOL() && p.nMatch(" LOW" ) )
                        x = -2.;
                if( p.lgEOL() && p.nMatch("HIGH" ) )
                        x = 2.;
 
                /* if x >= 0 (which includes default case where x is no entered)
                 * i will be x beyond the end of the array, or x before the start */
                long int i = ( x >= 0. ) ? (long)(x+0.5) + ARR_SIZE : (long)(x-0.5);
 
                /* must turn off PCLint detection of logical errors in this block */
                if( p.nMatch("STAT") )
                {
                        fprintf(ioQQQ," I will now access static array element ar2[%ld].  Hold on.\n", i );
                        fprintf(ioQQQ," If the next line says \"I am still alive - something is wrong\" then there are problems.\n");
                        fflush(ioQQQ);
                        ar2[i] = 1e-10;
 
                        fprintf(ioQQQ," I am still alive - something is wrong\n" );
                        fflush(ioQQQ);
                }
                else if( p.nMatch("STAC") || p.nMatch("AUTO") )
                {
                        double a[ARR_SIZE];
                        fprintf(ioQQQ," I will now access automatic array element a[%ld].  Hold on.\n", i );
                        fprintf(ioQQQ," If the next line says \"I am still alive - something is wrong\" then there are problems.\n");
                        fflush(ioQQQ);
                        a[i] = 1e-10;
 
                        fprintf(ioQQQ," I am still alive - something is wrong, return value was %.2e\n", a[i] );
                        fflush(ioQQQ);
                }
                else if( p.nMatch("HEAP") )
                {
                        int *ibound;            
                        ibound = ((int *)MALLOC( ARR_SIZE*sizeof(int) ));
                        fprintf(ioQQQ," I will now access malloced heap array element ibound[%ld].  Hold on.\n", i );
                        fprintf(ioQQQ," If the next line says \"I am still alive - something is wrong\" then there are problems.\n");
                        fflush(ioQQQ);
                        ibound[i] = 1;
                        fprintf(ioQQQ," I am still alive - something is wrong, return value is %i\n" , ibound[i] );
                        fflush(ioQQQ);
                        free(ibound);
                }
                else if( p.nMatch("MULT") )
                {
                        /* this tests the multi_arr class testing which occurs if the 
                         * macro BOUNDS_CHECK is set at compile time */
                        multi_arr<double,2> b;
                        b.reserve(3);
                        for( int j=0; j < 3; j++ )
                                b.reserve(j,ARR_SIZE+j);
                        b.alloc();
                        if( p.nMatch("ITER") )
                        {
                                fprintf(ioQQQ," I will now access multi_arr array element *b.ptr(0,%ld).  Hold on.\n", i );
                                fprintf(ioQQQ," If the next line says \"I am still alive - something is wrong\" then there are problems.\n\n");
                                fflush(ioQQQ);
                                md2i p = b.ptr(0,i);
                                *p = 2.;
                                fprintf(ioQQQ," I am still alive - something is wrong, return value is %g\n", *p );
                                fflush(ioQQQ);
                        }
                        else
                        {
                                fprintf(ioQQQ," I will now access multi_arr array element b[0][%ld].  Hold on.\n", i );
                                fprintf(ioQQQ," If the next line says \"I am still alive - something is wrong\" then there are problems.\n\n");
                                fflush(ioQQQ);
                                b[0][i] = 2.;
                                fprintf(ioQQQ," I am still alive - something is wrong, return value is %g\n" , b[0][i] );
                                fflush(ioQQQ);
                        }
                        b.clear();
                }
                else
                {
                        fprintf(ioQQQ," The CRASH BOUNDS command has four different tests.  One must be specified\n" );
                        fprintf(ioQQQ," The HEAP option tests a malloc/'d array - this tests valgrind or purify.\n");
                        fprintf(ioQQQ," The STATIC option tests a static declared array, and the STACK or AUTO option tests an automatic array - these test pgcc.\n");
                        fprintf(ioQQQ," The MULTI option tests if bounds checking is enabled in the multi_arr class (i.e., if the preprocessor macro BOUNDS_CHECK has been set).\n" );
                        fprintf(ioQQQ," All have a number as an optional argument, the array element to be accessed.\n");
                        fflush(ioQQQ);
                }
                lgCrash = true;
        }
 
        /* test the isnan function */
        else if( p.nMatch("ISNA") )
        {
                if( p.nMatch("FLOA") )
                {
                        sys_float ff;
                        fprintf(ioQQQ," I will now set a float to SNaN. This should never crash!\n" );
                        set_NaN( ff );
                        fprintf(ioQQQ," I will now test this variable with the isnan function\n" );
                        fprintf(ioQQQ," The correct behavior is for the statement \"PROBLEM DISASTER An assert has been thrown, this is bad\" to be printed, followed by lots more scary looking messages.\n\n");
                        fprintf(ioQQQ," If the next line says \"I am still alive - something is wrong\" then there are problems.\n");
                        ASSERT( !isnan( ff ) );
                        fprintf(ioQQQ," I am still alive - something is wrong, value is %e\n", ff );
                }
                else
                {
                        double dd;
                        fprintf(ioQQQ," I will now set a double to SNaN. This should never crash!\n" );
                        set_NaN( dd );
                        fprintf(ioQQQ," I will now test this variable with the isnan function\n" );
                        fprintf(ioQQQ," The correct behavior is for the statement \"PROBLEM DISASTER An assert has been thrown, this is bad\" to be printed, followed by lots more scary looking messages.\n\n");
                        fprintf(ioQQQ," If the next line says \"I am still alive - something is wrong\" then there are problems.\n");
                        ASSERT( !isnan( dd ) );
                        fprintf(ioQQQ," I am still alive - something is wrong, value is %e\n", dd );
                }
        }
 
        /* test if a C++ exception is caught */
        else if( p.nMatch("EXCE") )
        {
                fprintf(ioQQQ," I will now throw a C++ exception of type out_of_range()\n" );
                fprintf(ioQQQ," The correct behavior is for the statement \"DISASTER - An out_of_range exception was caught, what() = Cloudy Test. Bailing out...\" to be printed.\n\n");
                fprintf(ioQQQ," If you get any other message, the exception was not caught correctly.\n\n");
                throw out_of_range( "Cloudy Test" );
                fprintf(ioQQQ," If you see this statement, the exception did not terminate the program.\n" );
        }
 
        else
        {
                fprintf(ioQQQ,
                        "Crash option not found - valid options are ZERO, UNDEfined,"
                        " OVERflow, ASSErt, _NAN, SETNan, BOUNds, ISNAn, and EXCEption.\nSorry.\n");
                lgCrash = true;
        }
 
        if( lgCrash )
        {
                cdEXIT(EXIT_FAILURE);
        }
}