projects/dstress: dstress.c annotate

annotate dstress.c @ 1630:d0efa3ae5522 default tip

run/mini/naked_asm5: New x86_64 ABI passes the arguments in reverse order.

author	David Nadlinger <code@klickverbot.at>
date	Sat, 23 Apr 2011 22:57:32 +0200
parents	c6ef09dfba4d
children

rev	line source
438 27039d5cbe81 partial cleanup for Windows(dmc) thomask parents: 437 diff changeset	1 /*
27039d5cbe81 partial cleanup for Windows(dmc) thomask parents: 437 diff changeset	2 * core test tool for the DStress test suite
251 6cd84461e17b enabled new "dstress.c" test tool thomask parents: diff changeset	3 * http://dstress.kuehne.cn
6cd84461e17b enabled new "dstress.c" test tool thomask parents: diff changeset	4 *
940 dddc404783c9 added basic Windows support to crashRun.c thomask parents: 922 diff changeset	5 * Copyright (C)
dddc404783c9 added basic Windows support to crashRun.c thomask parents: 922 diff changeset	6 * 2005, 2006 Thomas Kuehne <thomas@kuehne.cn>
1389 669688cd3395 fixed typos thomask parents: 1264 diff changeset	7 * 2005 Carlos Santander (Windows files)
669688cd3395 fixed typos thomask parents: 1264 diff changeset	8 * 2005 Stewart Gordon <smjg_1998@yahoo.com> (Windows crashRun)
251 6cd84461e17b enabled new "dstress.c" test tool thomask parents: diff changeset	9 *
6cd84461e17b enabled new "dstress.c" test tool thomask parents: diff changeset	10 * This program is free software; you can redistribute it and/or modify
6cd84461e17b enabled new "dstress.c" test tool thomask parents: diff changeset	11 * it under the terms of the GNU General Public License as published by
6cd84461e17b enabled new "dstress.c" test tool thomask parents: diff changeset	12 * the Free Software Foundation; either version 2 of the License, or
6cd84461e17b enabled new "dstress.c" test tool thomask parents: diff changeset	13 * (at your option) any later version.
6cd84461e17b enabled new "dstress.c" test tool thomask parents: diff changeset	14 *
6cd84461e17b enabled new "dstress.c" test tool thomask parents: diff changeset	15 * This program is distributed in the hope that it will be useful,
6cd84461e17b enabled new "dstress.c" test tool thomask parents: diff changeset	16 * but WITHOUT ANY WARRANTY; without even the implied warranty of
6cd84461e17b enabled new "dstress.c" test tool thomask parents: diff changeset	17 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
6cd84461e17b enabled new "dstress.c" test tool thomask parents: diff changeset	18 * GNU General Public License for more details.
6cd84461e17b enabled new "dstress.c" test tool thomask parents: diff changeset	19 *
6cd84461e17b enabled new "dstress.c" test tool thomask parents: diff changeset	20 * You should have received a copy of the GNU General Public License
6cd84461e17b enabled new "dstress.c" test tool thomask parents: diff changeset	21 * along with this program; if not, write to the Free Software
6cd84461e17b enabled new "dstress.c" test tool thomask parents: diff changeset	22 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
6cd84461e17b enabled new "dstress.c" test tool thomask parents: diff changeset	23 *
6cd84461e17b enabled new "dstress.c" test tool thomask parents: diff changeset	24 * $HeadURL$
6cd84461e17b enabled new "dstress.c" test tool thomask parents: diff changeset	25 * $Date$
6cd84461e17b enabled new "dstress.c" test tool thomask parents: diff changeset	26 * $Author$
6cd84461e17b enabled new "dstress.c" test tool thomask parents: diff changeset	27 *
438 27039d5cbe81 partial cleanup for Windows(dmc) thomask parents: 437 diff changeset	28 */
251 6cd84461e17b enabled new "dstress.c" test tool thomask parents: diff changeset	29
704 3e690f0d2cbf documentation maintenance for dstress.c thomask parents: 703 diff changeset	30 /* Beware: the code doesn't care about freeing allocated memory etc. ... */
432 db4b6169a99d 1) implemented checkRuntimeErrorMessage thomask parents: 429 diff changeset	31
251 6cd84461e17b enabled new "dstress.c" test tool thomask parents: diff changeset	32 #include <stdlib.h>
6cd84461e17b enabled new "dstress.c" test tool thomask parents: diff changeset	33 #include <stdio.h>
6cd84461e17b enabled new "dstress.c" test tool thomask parents: diff changeset	34 #include <string.h>
6cd84461e17b enabled new "dstress.c" test tool thomask parents: diff changeset	35 #include <errno.h>
681 be27bc9d0d28 gentoo fixes thomask parents: 676 diff changeset	36 #include <ctype.h>
251 6cd84461e17b enabled new "dstress.c" test tool thomask parents: diff changeset	37
734 d4edcc124e64 added Torture capabilities thomask parents: 710 diff changeset	38 /* number's choice: XOR and printf :) */
d4edcc124e64 added Torture capabilities thomask parents: 710 diff changeset	39 #define MODE_RUN (0x10000)
981 f410034559af fixed buffer size to include the length of the torture elements thomask parents: 977 diff changeset	40 #define MODE_NORUN (0x01000)
f410034559af fixed buffer size to include the length of the torture elements thomask parents: 977 diff changeset	41 #define MODE_COMPILE (0x00100)
f410034559af fixed buffer size to include the length of the torture elements thomask parents: 977 diff changeset	42 #define MODE_NOCOMPILE (0x00010)
f410034559af fixed buffer size to include the length of the torture elements thomask parents: 977 diff changeset	43 #define MODE_TORTURE (0x00002)
251 6cd84461e17b enabled new "dstress.c" test tool thomask parents: diff changeset	44
734 d4edcc124e64 added Torture capabilities thomask parents: 710 diff changeset	45 #define RES_BASE_MASK (0xFFFFFF0)
d4edcc124e64 added Torture capabilities thomask parents: 710 diff changeset	46 #define RES_PASS (0x1000000)
981 f410034559af fixed buffer size to include the length of the torture elements thomask parents: 977 diff changeset	47 #define RES_XFAIL (0x0100000)
f410034559af fixed buffer size to include the length of the torture elements thomask parents: 977 diff changeset	48 #define RES_XPASS (0x0010000)
f410034559af fixed buffer size to include the length of the torture elements thomask parents: 977 diff changeset	49 #define RES_FAIL (0x0001000)
f410034559af fixed buffer size to include the length of the torture elements thomask parents: 977 diff changeset	50 #define RES_ERROR (0x0000100)
f410034559af fixed buffer size to include the length of the torture elements thomask parents: 977 diff changeset	51 #define RES_UNTESTED (0x0000010)
f410034559af fixed buffer size to include the length of the torture elements thomask parents: 977 diff changeset	52 #define RES_BAD_GDB (0x0000004)
f410034559af fixed buffer size to include the length of the torture elements thomask parents: 977 diff changeset	53 #define RES_BAD_MSG (0x0000002)
490 d091ff903fa4 added crashRun for POSIX systems thomask parents: 476 diff changeset	54
499 0434764d4a66 removed redundancy in the output thomask parents: 493 diff changeset	55 #if defined(__GNU_LIBRARY__) \|\| defined(__GLIBC__)
697 fbee62becd2c partial repos review thomask parents: 693 diff changeset	56 #define USE_POSIX 1
251 6cd84461e17b enabled new "dstress.c" test tool thomask parents: diff changeset	57 #endif
6cd84461e17b enabled new "dstress.c" test tool thomask parents: diff changeset	58
685 4f97e51515d8 ported dstress.c to OpenBsd thomask parents: 681 diff changeset	59 #if defined(linux) \|\| defined(__FreeBSD__) \|\| defined(__OpenBSD__)
697 fbee62becd2c partial repos review thomask parents: 693 diff changeset	60 #define USE_POSIX 1
251 6cd84461e17b enabled new "dstress.c" test tool thomask parents: diff changeset	61 #endif
6cd84461e17b enabled new "dstress.c" test tool thomask parents: diff changeset	62
273 68b883fe4fad added BSD support to the test framework thomask* parents: 261 diff changeset	63 #if defined(__APPLE__) && defined(__MACH__)
697 fbee62becd2c partial repos review thomask parents: 693 diff changeset	64 #define USE_POSIX 1
273 68b883fe4fad added BSD support to the test framework thomask* parents: 261 diff changeset	65 #endif
68b883fe4fad added BSD support to the test framework thomask* parents: 261 diff changeset	66
888 a995eae8e75c blind: partial merger of Stewart's crashRun for Windows thomask parents: 881 diff changeset	67 #if defined(WIN) \|\| defined(WIN32) \|\| defined(WIN64)
633 653cbe20c878 updated location of tmp files thomask parents: 622 diff changeset	68 #define USE_WINDOWS 1
653cbe20c878 updated location of tmp files thomask parents: 622 diff changeset	69 #endif
339 a74c84e75682 added error line tests (__DSTRESS_ELINE__ / __DSTRESS_EFILE__) thomask parents: 292 diff changeset	70
704 3e690f0d2cbf documentation maintenance for dstress.c thomask parents: 703 diff changeset	71 /* prefere USE_POSIX over USE_WINDOWS if both APIs are detected */
339 a74c84e75682 added error line tests (__DSTRESS_ELINE__ / __DSTRESS_EFILE__) thomask parents: 292 diff changeset	72 #ifdef USE_POSIX
254 a39162afcc94 MSWindows port of "dstress.c" thomask parents: 251 diff changeset	73
251 6cd84461e17b enabled new "dstress.c" test tool thomask parents: diff changeset	74 #include <sys/types.h>
6cd84461e17b enabled new "dstress.c" test tool thomask parents: diff changeset	75 #include <sys/stat.h>
6cd84461e17b enabled new "dstress.c" test tool thomask parents: diff changeset	76 #include <fcntl.h>
6cd84461e17b enabled new "dstress.c" test tool thomask parents: diff changeset	77 #include <unistd.h>
620 03ad4005cd8e POSIX only: added __GDB_SCRIPT__ and __GDB__PATTERN__ support thomask parents: 499 diff changeset	78 #include <regex.h>
734 d4edcc124e64 added Torture capabilities thomask parents: 710 diff changeset	79 #include <limits.h>
490 d091ff903fa4 added crashRun for POSIX systems thomask parents: 476 diff changeset	80
904 67e77ee70d66 minor OpenBSD and Windows fixes thomask parents: 902 diff changeset	81 /* not every STDLIB propperly supports C99's "%z" for printf formating */
67e77ee70d66 minor OpenBSD and Windows fixes thomask parents: 902 diff changeset	82 /* (I just love those non-conforming headers...) */
67e77ee70d66 minor OpenBSD and Windows fixes thomask parents: 902 diff changeset	83 #undef ZU
67e77ee70d66 minor OpenBSD and Windows fixes thomask parents: 902 diff changeset	84
67e77ee70d66 minor OpenBSD and Windows fixes thomask parents: 902 diff changeset	85 #if !defined(ZU) && defined(SSIZE_MAX)
67e77ee70d66 minor OpenBSD and Windows fixes thomask parents: 902 diff changeset	86 #if defined(INT_MAX) && SSIZE_MAX == INT_MAX
67e77ee70d66 minor OpenBSD and Windows fixes thomask parents: 902 diff changeset	87 #define ZU "%u"
67e77ee70d66 minor OpenBSD and Windows fixes thomask parents: 902 diff changeset	88 #elif defined(LONG_MAX) && SSIZE_MAX == LONG_MAX
67e77ee70d66 minor OpenBSD and Windows fixes thomask parents: 902 diff changeset	89 #define ZU "%lu"
67e77ee70d66 minor OpenBSD and Windows fixes thomask parents: 902 diff changeset	90 #elif defined(LLONG_MAX) && SSIZE_MAX == LLONG_MAX
67e77ee70d66 minor OpenBSD and Windows fixes thomask parents: 902 diff changeset	91 #define ZU "%llu"
67e77ee70d66 minor OpenBSD and Windows fixes thomask parents: 902 diff changeset	92 #elif defined(SHRT_MAX) && SSIZE_MAX == SHRT_MAX
67e77ee70d66 minor OpenBSD and Windows fixes thomask parents: 902 diff changeset	93 #define ZU "%hu"
67e77ee70d66 minor OpenBSD and Windows fixes thomask parents: 902 diff changeset	94 #endif
67e77ee70d66 minor OpenBSD and Windows fixes thomask parents: 902 diff changeset	95 #endif /* SSIZE_MAX */
67e77ee70d66 minor OpenBSD and Windows fixes thomask parents: 902 diff changeset	96
67e77ee70d66 minor OpenBSD and Windows fixes thomask parents: 902 diff changeset	97 #if !defined(ZU) && defined(SIZE_T_MAX)
67e77ee70d66 minor OpenBSD and Windows fixes thomask parents: 902 diff changeset	98 #if defined(UINT_MAX) && SIZE_T_MAX == UINT_MAX
734 d4edcc124e64 added Torture capabilities thomask parents: 710 diff changeset	99 #define ZU "%u"
904 67e77ee70d66 minor OpenBSD and Windows fixes thomask parents: 902 diff changeset	100 #elif defined(ULONG_MAX) && SIZE_T_MAX == ULONG_MAX
734 d4edcc124e64 added Torture capabilities thomask parents: 710 diff changeset	101 #define ZU "%lu"
904 67e77ee70d66 minor OpenBSD and Windows fixes thomask parents: 902 diff changeset	102 #elif defined(ULLONG_MAX) && SIZE_T_MAX == ULLONG_MAX
67e77ee70d66 minor OpenBSD and Windows fixes thomask parents: 902 diff changeset	103 #define ZU "%llu"
67e77ee70d66 minor OpenBSD and Windows fixes thomask parents: 902 diff changeset	104 #elif defined(USHRT_MAX) && SIZE_T_MAX == USHRT_MAX
734 d4edcc124e64 added Torture capabilities thomask parents: 710 diff changeset	105 #define ZU "%hu"
904 67e77ee70d66 minor OpenBSD and Windows fixes thomask parents: 902 diff changeset	106 #endif
67e77ee70d66 minor OpenBSD and Windows fixes thomask parents: 902 diff changeset	107 #endif /* SIZE_T_MAX */
67e77ee70d66 minor OpenBSD and Windows fixes thomask parents: 902 diff changeset	108
67e77ee70d66 minor OpenBSD and Windows fixes thomask parents: 902 diff changeset	109 #ifndef ZU
67e77ee70d66 minor OpenBSD and Windows fixes thomask parents: 902 diff changeset	110 #include <stdint.h>
922 95160f4d06f8 minimized memory leaks in repeatedly called functions thomask parents: 904 diff changeset	111 #undef ZU
904 67e77ee70d66 minor OpenBSD and Windows fixes thomask parents: 902 diff changeset	112 #ifdef PTRDIFF_MAX
67e77ee70d66 minor OpenBSD and Windows fixes thomask parents: 902 diff changeset	113 #if defined(INT_MAX) && PTRDIFF_MAX == INT_MAX
67e77ee70d66 minor OpenBSD and Windows fixes thomask parents: 902 diff changeset	114 #define ZU "%u"
67e77ee70d66 minor OpenBSD and Windows fixes thomask parents: 902 diff changeset	115 #elif defined(LONG_MAX) && PTRDIFF_MAX == LONG_MAX
67e77ee70d66 minor OpenBSD and Windows fixes thomask parents: 902 diff changeset	116 #define ZU "%lu"
67e77ee70d66 minor OpenBSD and Windows fixes thomask parents: 902 diff changeset	117 #elif defined(LLONG_MAX) && PTRDIFF_MAX == LLONG_MAX
67e77ee70d66 minor OpenBSD and Windows fixes thomask parents: 902 diff changeset	118 #define ZU "%llu"
67e77ee70d66 minor OpenBSD and Windows fixes thomask parents: 902 diff changeset	119 #elif defined(SHRT_MAX) && PTRDIFF_MAX == SHRT_MAX
67e77ee70d66 minor OpenBSD and Windows fixes thomask parents: 902 diff changeset	120 #define ZU "%hu"
67e77ee70d66 minor OpenBSD and Windows fixes thomask parents: 902 diff changeset	121 #endif
67e77ee70d66 minor OpenBSD and Windows fixes thomask parents: 902 diff changeset	122 #endif
67e77ee70d66 minor OpenBSD and Windows fixes thomask parents: 902 diff changeset	123 #endif /* PTRDIFF_MAX */
67e77ee70d66 minor OpenBSD and Windows fixes thomask parents: 902 diff changeset	124
67e77ee70d66 minor OpenBSD and Windows fixes thomask parents: 902 diff changeset	125 #ifndef ZU
734 d4edcc124e64 added Torture capabilities thomask parents: 710 diff changeset	126 #error what is the size of a pointer?
d4edcc124e64 added Torture capabilities thomask parents: 710 diff changeset	127 #endif
904 67e77ee70d66 minor OpenBSD and Windows fixes thomask parents: 902 diff changeset	128
490 d091ff903fa4 added crashRun for POSIX systems thomask parents: 476 diff changeset	129 #else
633 653cbe20c878 updated location of tmp files thomask parents: 622 diff changeset	130 #ifdef USE_WINDOWS
490 d091ff903fa4 added crashRun for POSIX systems thomask parents: 476 diff changeset	131
986 c6f4a1d57892 added VS2005 support thomask parents: 985 diff changeset	132 #include <process.h>
c6f4a1d57892 added VS2005 support thomask parents: 985 diff changeset	133 typedef int pid_t;
c6f4a1d57892 added VS2005 support thomask parents: 985 diff changeset	134
490 d091ff903fa4 added crashRun for POSIX systems thomask parents: 476 diff changeset	135 #include <windows.h>
685 4f97e51515d8 ported dstress.c to OpenBsd thomask parents: 681 diff changeset	136 #define snprintf _snprintf
697 fbee62becd2c partial repos review thomask parents: 693 diff changeset	137 #ifndef INVALID_FILE_SIZE
704 3e690f0d2cbf documentation maintenance for dstress.c thomask parents: 703 diff changeset	138 #define INVALID_FILE_SIZE (-1)
742 5906350b5048 fixed misplaced #endif for Windows systems thomask parents: 734 diff changeset	139 #endif
734 d4edcc124e64 added Torture capabilities thomask parents: 710 diff changeset	140
d4edcc124e64 added Torture capabilities thomask parents: 710 diff changeset	141 /* not every STDLIB supports C99's "%z" for printf formating */
746 0e3682dad93a fixed windows part of dstress.c thomask parents: 742 diff changeset	142 #ifdef WIN32
734 d4edcc124e64 added Torture capabilities thomask parents: 710 diff changeset	143 #define ZU "%u"
d4edcc124e64 added Torture capabilities thomask parents: 710 diff changeset	144 #else
746 0e3682dad93a fixed windows part of dstress.c thomask parents: 742 diff changeset	145 #ifdef WIN64
734 d4edcc124e64 added Torture capabilities thomask parents: 710 diff changeset	146 #define ZU "%llu"
d4edcc124e64 added Torture capabilities thomask parents: 710 diff changeset	147 #else
d4edcc124e64 added Torture capabilities thomask parents: 710 diff changeset	148 #error what is the size of a pointer?
d4edcc124e64 added Torture capabilities thomask parents: 710 diff changeset	149 #endif
d4edcc124e64 added Torture capabilities thomask parents: 710 diff changeset	150 #endif
d4edcc124e64 added Torture capabilities thomask parents: 710 diff changeset	151
633 653cbe20c878 updated location of tmp files thomask parents: 622 diff changeset	152 #else
704 3e690f0d2cbf documentation maintenance for dstress.c thomask parents: 703 diff changeset	153 #error neither POSIX nor MSWindows API detected
633 653cbe20c878 updated location of tmp files thomask parents: 622 diff changeset	154 #endif /* USE_WINDOWS else */
490 d091ff903fa4 added crashRun for POSIX systems thomask parents: 476 diff changeset	155 #endif /* USE_POSIX else */
d091ff903fa4 added crashRun for POSIX systems thomask parents: 476 diff changeset	156
734 d4edcc124e64 added Torture capabilities thomask parents: 710 diff changeset	157 #define TORTURE_PREFIX "torture-"
697 fbee62becd2c partial repos review thomask parents: 693 diff changeset	158
704 3e690f0d2cbf documentation maintenance for dstress.c thomask parents: 703 diff changeset	159 #ifdef USE_POSIX
1628 c6ef09dfba4d add mini test set from ldc project Moritz Warning <moritzwarning@web.de> parents: 1627 diff changeset	160 #define CRASH_RUN "./crashRun 10 256"
971 8da09834526d * Valgrind support is now part of dstress.c instead of crashRun.c thomask parents: 968 diff changeset	161 #ifdef USE_VALGRIND
8da09834526d * Valgrind support is now part of dstress.c instead of crashRun.c thomask parents: 968 diff changeset	162 #define VALGRIND "valgrind --leak-check=no -q --suppressions=valgrind.suppress"
8da09834526d * Valgrind support is now part of dstress.c instead of crashRun.c thomask parents: 968 diff changeset	163 #else
991 fc296bd82895 fixed Valgrind exclusion bug thomask parents: 986 diff changeset	164 #define VALGRIND NULL
971 8da09834526d * Valgrind support is now part of dstress.c instead of crashRun.c thomask parents: 968 diff changeset	165 #endif
734 d4edcc124e64 added Torture capabilities thomask parents: 710 diff changeset	166 #define TMP_DIR "./obj"
971 8da09834526d * Valgrind support is now part of dstress.c instead of crashRun.c thomask parents: 968 diff changeset	167 #define RM_DIR "rm -rf"
704 3e690f0d2cbf documentation maintenance for dstress.c thomask parents: 703 diff changeset	168 #else
633 653cbe20c878 updated location of tmp files thomask parents: 622 diff changeset	169 #ifdef USE_WINDOWS
991 fc296bd82895 fixed Valgrind exclusion bug thomask parents: 986 diff changeset	170 #define VALGRIND NULL
734 d4edcc124e64 added Torture capabilities thomask parents: 710 diff changeset	171 #define TMP_DIR ".\\obj"
986 c6f4a1d57892 added VS2005 support thomask parents: 985 diff changeset	172 #define RM_DIR "rd /sq"
633 653cbe20c878 updated location of tmp files thomask parents: 622 diff changeset	173 #else
704 3e690f0d2cbf documentation maintenance for dstress.c thomask parents: 703 diff changeset	174 #error OS dependent file names not defined
633 653cbe20c878 updated location of tmp files thomask parents: 622 diff changeset	175 #endif
653cbe20c878 updated location of tmp files thomask parents: 622 diff changeset	176 #endif
653cbe20c878 updated location of tmp files thomask parents: 622 diff changeset	177
971 8da09834526d * Valgrind support is now part of dstress.c instead of crashRun.c thomask parents: 968 diff changeset	178 char* tmp_dir;
8da09834526d * Valgrind support is now part of dstress.c instead of crashRun.c thomask parents: 968 diff changeset	179
888 a995eae8e75c blind: partial merger of Stewart's crashRun for Windows thomask parents: 881 diff changeset	180 #ifdef USE_WINDOWS
a995eae8e75c blind: partial merger of Stewart's crashRun for Windows thomask parents: 881 diff changeset	181 HANDLE originalStdout, originalStderr;
a995eae8e75c blind: partial merger of Stewart's crashRun for Windows thomask parents: 881 diff changeset	182 #endif
a995eae8e75c blind: partial merger of Stewart's crashRun for Windows thomask parents: 881 diff changeset	183
734 d4edcc124e64 added Torture capabilities thomask parents: 710 diff changeset	184 const char* torture[] = {
981 f410034559af fixed buffer size to include the length of the torture elements thomask parents: 977 diff changeset	185 /* 0 args */
734 d4edcc124e64 added Torture capabilities thomask parents: 710 diff changeset	186 "",
746 0e3682dad93a fixed windows part of dstress.c thomask parents: 742 diff changeset	187
981 f410034559af fixed buffer size to include the length of the torture elements thomask parents: 977 diff changeset	188 /* 1 args */
f410034559af fixed buffer size to include the length of the torture elements thomask parents: 977 diff changeset	189 "-g",
f410034559af fixed buffer size to include the length of the torture elements thomask parents: 977 diff changeset	190 "-inline",
f410034559af fixed buffer size to include the length of the torture elements thomask parents: 977 diff changeset	191 "-fPIC",
f410034559af fixed buffer size to include the length of the torture elements thomask parents: 977 diff changeset	192 "-O",
f410034559af fixed buffer size to include the length of the torture elements thomask parents: 977 diff changeset	193 "-release",
746 0e3682dad93a fixed windows part of dstress.c thomask parents: 742 diff changeset	194
981 f410034559af fixed buffer size to include the length of the torture elements thomask parents: 977 diff changeset	195 /* 2 args */
f410034559af fixed buffer size to include the length of the torture elements thomask parents: 977 diff changeset	196 "-g -inline",
f410034559af fixed buffer size to include the length of the torture elements thomask parents: 977 diff changeset	197 "-g -fPIC",
f410034559af fixed buffer size to include the length of the torture elements thomask parents: 977 diff changeset	198 "-g -O",
f410034559af fixed buffer size to include the length of the torture elements thomask parents: 977 diff changeset	199 "-g -release",
f410034559af fixed buffer size to include the length of the torture elements thomask parents: 977 diff changeset	200 "-inline -fPIC",
f410034559af fixed buffer size to include the length of the torture elements thomask parents: 977 diff changeset	201 "-inline -O",
f410034559af fixed buffer size to include the length of the torture elements thomask parents: 977 diff changeset	202 "-inline -release",
f410034559af fixed buffer size to include the length of the torture elements thomask parents: 977 diff changeset	203 "-fPIC -O",
f410034559af fixed buffer size to include the length of the torture elements thomask parents: 977 diff changeset	204 "-fPIC -release",
734 d4edcc124e64 added Torture capabilities thomask parents: 710 diff changeset	205 "-O -release",
746 0e3682dad93a fixed windows part of dstress.c thomask parents: 742 diff changeset	206
981 f410034559af fixed buffer size to include the length of the torture elements thomask parents: 977 diff changeset	207 /* 3 args */
f410034559af fixed buffer size to include the length of the torture elements thomask parents: 977 diff changeset	208 "-g -inline -fPIC",
f410034559af fixed buffer size to include the length of the torture elements thomask parents: 977 diff changeset	209 "-g -inline -O",
f410034559af fixed buffer size to include the length of the torture elements thomask parents: 977 diff changeset	210 "-g -inline -release",
f410034559af fixed buffer size to include the length of the torture elements thomask parents: 977 diff changeset	211 "-g -fPIC -O",
f410034559af fixed buffer size to include the length of the torture elements thomask parents: 977 diff changeset	212 "-g -fPIC -release",
f410034559af fixed buffer size to include the length of the torture elements thomask parents: 977 diff changeset	213 "-g -O -release",
f410034559af fixed buffer size to include the length of the torture elements thomask parents: 977 diff changeset	214 "-inline -fPIC -O",
f410034559af fixed buffer size to include the length of the torture elements thomask parents: 977 diff changeset	215 "-inline -fPIC -release",
f410034559af fixed buffer size to include the length of the torture elements thomask parents: 977 diff changeset	216 "-inline -O -release",
734 d4edcc124e64 added Torture capabilities thomask parents: 710 diff changeset	217 "-fPIC -O -release",
d4edcc124e64 added Torture capabilities thomask parents: 710 diff changeset	218
981 f410034559af fixed buffer size to include the length of the torture elements thomask parents: 977 diff changeset	219 /* 4 args */
f410034559af fixed buffer size to include the length of the torture elements thomask parents: 977 diff changeset	220 "-g -inline -fPIC -O",
f410034559af fixed buffer size to include the length of the torture elements thomask parents: 977 diff changeset	221 "-g -inline -fPIC -release",
734 d4edcc124e64 added Torture capabilities thomask parents: 710 diff changeset	222 "-g -fPIC -O -release",
d4edcc124e64 added Torture capabilities thomask parents: 710 diff changeset	223 "-inline -fPIC -O -release",
d4edcc124e64 added Torture capabilities thomask parents: 710 diff changeset	224
981 f410034559af fixed buffer size to include the length of the torture elements thomask parents: 977 diff changeset	225 /* 5 args */
f410034559af fixed buffer size to include the length of the torture elements thomask parents: 977 diff changeset	226 "-g -inline -fPIC -O -release",
f410034559af fixed buffer size to include the length of the torture elements thomask parents: 977 diff changeset	227
f410034559af fixed buffer size to include the length of the torture elements thomask parents: 977 diff changeset	228 /* 4 args - ommitted */
f410034559af fixed buffer size to include the length of the torture elements thomask parents: 977 diff changeset	229 "-g -inline -O -release"
734 d4edcc124e64 added Torture capabilities thomask parents: 710 diff changeset	230 };
d4edcc124e64 added Torture capabilities thomask parents: 710 diff changeset	231
d4edcc124e64 added Torture capabilities thomask parents: 710 diff changeset	232 /* secure malloc */
d4edcc124e64 added Torture capabilities thomask parents: 710 diff changeset	233 void *xmalloc(size_t size){
d4edcc124e64 added Torture capabilities thomask parents: 710 diff changeset	234 void *p = malloc(size);
d4edcc124e64 added Torture capabilities thomask parents: 710 diff changeset	235 if (p == NULL){
d4edcc124e64 added Torture capabilities thomask parents: 710 diff changeset	236 fprintf(stderr, "Failed to allocate " ZU " bytes!\n", size);
d4edcc124e64 added Torture capabilities thomask parents: 710 diff changeset	237 exit(EXIT_FAILURE);
d4edcc124e64 added Torture capabilities thomask parents: 710 diff changeset	238 }
d4edcc124e64 added Torture capabilities thomask parents: 710 diff changeset	239 return p;
620 03ad4005cd8e POSIX only: added __GDB_SCRIPT__ and __GDB__PATTERN__ support thomask parents: 499 diff changeset	240 }
734 d4edcc124e64 added Torture capabilities thomask parents: 710 diff changeset	241 #define malloc xmalloc
620 03ad4005cd8e POSIX only: added __GDB_SCRIPT__ and __GDB__PATTERN__ support thomask parents: 499 diff changeset	242
734 d4edcc124e64 added Torture capabilities thomask parents: 710 diff changeset	243 /* secure calloc */
d4edcc124e64 added Torture capabilities thomask parents: 710 diff changeset	244 void* xcalloc(size_t members, size_t size){
d4edcc124e64 added Torture capabilities thomask parents: 710 diff changeset	245 void* ptr = calloc(members, size);
d4edcc124e64 added Torture capabilities thomask parents: 710 diff changeset	246 if(ptr == NULL){
d4edcc124e64 added Torture capabilities thomask parents: 710 diff changeset	247 fprintf(stderr, "Failed to allocate " ZU " elements"
d4edcc124e64 added Torture capabilities thomask parents: 710 diff changeset	248 "(" ZU " bytes each)!\n", members, size);
d4edcc124e64 added Torture capabilities thomask parents: 710 diff changeset	249 exit(EXIT_FAILURE);
d4edcc124e64 added Torture capabilities thomask parents: 710 diff changeset	250 }
d4edcc124e64 added Torture capabilities thomask parents: 710 diff changeset	251 return ptr;
d4edcc124e64 added Torture capabilities thomask parents: 710 diff changeset	252 }
d4edcc124e64 added Torture capabilities thomask parents: 710 diff changeset	253 #define calloc xcalloc
d4edcc124e64 added Torture capabilities thomask parents: 710 diff changeset	254
d4edcc124e64 added Torture capabilities thomask parents: 710 diff changeset	255
d4edcc124e64 added Torture capabilities thomask parents: 710 diff changeset	256 void printResult(int result, int modus, char* case_file, FILE* stream){
d4edcc124e64 added Torture capabilities thomask parents: 710 diff changeset	257 char* msg = NULL;
d4edcc124e64 added Torture capabilities thomask parents: 710 diff changeset	258 #ifdef DEBUG
d4edcc124e64 added Torture capabilities thomask parents: 710 diff changeset	259 fprintf(stderr, "case: %s, modus: %x, result: %x\n", case_file, modus,
d4edcc124e64 added Torture capabilities thomask parents: 710 diff changeset	260 result);
d4edcc124e64 added Torture capabilities thomask parents: 710 diff changeset	261 #endif
d4edcc124e64 added Torture capabilities thomask parents: 710 diff changeset	262
d4edcc124e64 added Torture capabilities thomask parents: 710 diff changeset	263 if(result & RES_PASS){
d4edcc124e64 added Torture capabilities thomask parents: 710 diff changeset	264 msg = "PASS: ";
d4edcc124e64 added Torture capabilities thomask parents: 710 diff changeset	265 }else if(result & RES_XFAIL){
d4edcc124e64 added Torture capabilities thomask parents: 710 diff changeset	266 msg = "XFAIL:";
d4edcc124e64 added Torture capabilities thomask parents: 710 diff changeset	267 }else if(result & RES_XPASS){
d4edcc124e64 added Torture capabilities thomask parents: 710 diff changeset	268 msg = "XPASS:";
d4edcc124e64 added Torture capabilities thomask parents: 710 diff changeset	269 }else if(result & RES_FAIL){
d4edcc124e64 added Torture capabilities thomask parents: 710 diff changeset	270 msg = "FAIL: ";
d4edcc124e64 added Torture capabilities thomask parents: 710 diff changeset	271 }else if(result & RES_ERROR){
d4edcc124e64 added Torture capabilities thomask parents: 710 diff changeset	272 msg = "ERROR:";
d4edcc124e64 added Torture capabilities thomask parents: 710 diff changeset	273 }
d4edcc124e64 added Torture capabilities thomask parents: 710 diff changeset	274
d4edcc124e64 added Torture capabilities thomask parents: 710 diff changeset	275 fprintf(stream, "%s\t%s%s%s\n", msg, case_file,
d4edcc124e64 added Torture capabilities thomask parents: 710 diff changeset	276 (result & RES_BAD_MSG) ? " [bad error message]" : "",
d4edcc124e64 added Torture capabilities thomask parents: 710 diff changeset	277 (result & RES_BAD_GDB) ? " [bad debugger message]" : "");
620 03ad4005cd8e POSIX only: added __GDB_SCRIPT__ and __GDB__PATTERN__ support thomask parents: 499 diff changeset	278 }
03ad4005cd8e POSIX only: added __GDB_SCRIPT__ and __GDB__PATTERN__ support thomask parents: 499 diff changeset	279
03ad4005cd8e POSIX only: added __GDB_SCRIPT__ and __GDB__PATTERN__ support thomask parents: 499 diff changeset	280 char* strip(char* buffer){
697 fbee62becd2c partial repos review thomask parents: 693 diff changeset	281 char* tmp = NULL;
685 4f97e51515d8 ported dstress.c to OpenBsd thomask parents: 681 diff changeset	282
620 03ad4005cd8e POSIX only: added __GDB_SCRIPT__ and __GDB__PATTERN__ support thomask parents: 499 diff changeset	283 if(buffer!=NULL){
03ad4005cd8e POSIX only: added __GDB_SCRIPT__ and __GDB__PATTERN__ support thomask parents: 499 diff changeset	284 while(isspace(buffer[0])){
03ad4005cd8e POSIX only: added __GDB_SCRIPT__ and __GDB__PATTERN__ support thomask parents: 499 diff changeset	285 buffer++;
03ad4005cd8e POSIX only: added __GDB_SCRIPT__ and __GDB__PATTERN__ support thomask parents: 499 diff changeset	286 }
03ad4005cd8e POSIX only: added __GDB_SCRIPT__ and __GDB__PATTERN__ support thomask parents: 499 diff changeset	287
622 7acb8b34c87a - fixed diagnostic 3/3 thomask parents: 620 diff changeset	288 for(tmp=buffer+strlen(buffer)-1; isspace(tmp[0]); tmp=buffer+strlen(buffer)-1){
620 03ad4005cd8e POSIX only: added __GDB_SCRIPT__ and __GDB__PATTERN__ support thomask parents: 499 diff changeset	289 tmp[0]='\x00';
03ad4005cd8e POSIX only: added __GDB_SCRIPT__ and __GDB__PATTERN__ support thomask parents: 499 diff changeset	290 }
03ad4005cd8e POSIX only: added __GDB_SCRIPT__ and __GDB__PATTERN__ support thomask parents: 499 diff changeset	291 }
03ad4005cd8e POSIX only: added __GDB_SCRIPT__ and __GDB__PATTERN__ support thomask parents: 499 diff changeset	292 return buffer;
03ad4005cd8e POSIX only: added __GDB_SCRIPT__ and __GDB__PATTERN__ support thomask parents: 499 diff changeset	293 }
03ad4005cd8e POSIX only: added __GDB_SCRIPT__ and __GDB__PATTERN__ support thomask parents: 499 diff changeset	294
734 d4edcc124e64 added Torture capabilities thomask parents: 710 diff changeset	295 unsigned int genTempFileNameCount;
d4edcc124e64 added Torture capabilities thomask parents: 710 diff changeset	296 char* genTempFileName(){
d4edcc124e64 added Torture capabilities thomask parents: 710 diff changeset	297 char* back;
d4edcc124e64 added Torture capabilities thomask parents: 710 diff changeset	298 size_t len;
d4edcc124e64 added Torture capabilities thomask parents: 710 diff changeset	299
971 8da09834526d * Valgrind support is now part of dstress.c instead of crashRun.c thomask parents: 968 diff changeset	300 len = strlen(tmp_dir) + 128;
1206 d88a87712de1 fixed dstress.c for C++ compilers thomask parents: 1003 diff changeset	301 back = (char*) malloc(len);
746 0e3682dad93a fixed windows part of dstress.c thomask parents: 742 diff changeset	302
0e3682dad93a fixed windows part of dstress.c thomask parents: 742 diff changeset	303 #ifdef USE_POSIX
971 8da09834526d * Valgrind support is now part of dstress.c instead of crashRun.c thomask parents: 968 diff changeset	304 snprintf(back, len, "%s/t%x-%x-%x.tmp", tmp_dir, getpid(), rand(), ++genTempFileNameCount);
746 0e3682dad93a fixed windows part of dstress.c thomask parents: 742 diff changeset	305 #else
971 8da09834526d * Valgrind support is now part of dstress.c instead of crashRun.c thomask parents: 968 diff changeset	306 snprintf(back, len, "%s\\t%x-%x-%x.tmp", tmp_dir, getpid(), rand(), ++genTempFileNameCount);
746 0e3682dad93a fixed windows part of dstress.c thomask parents: 742 diff changeset	307 #endif
734 d4edcc124e64 added Torture capabilities thomask parents: 710 diff changeset	308
d4edcc124e64 added Torture capabilities thomask parents: 710 diff changeset	309 return back;
d4edcc124e64 added Torture capabilities thomask parents: 710 diff changeset	310 }
d4edcc124e64 added Torture capabilities thomask parents: 710 diff changeset	311
620 03ad4005cd8e POSIX only: added __GDB_SCRIPT__ and __GDB__PATTERN__ support thomask parents: 499 diff changeset	312 /* cleanup "/" versus "\" in filenames */
03ad4005cd8e POSIX only: added __GDB_SCRIPT__ and __GDB__PATTERN__ support thomask parents: 499 diff changeset	313 char* cleanPathSeperator(char* filename){
697 fbee62becd2c partial repos review thomask parents: 693 diff changeset	314 char* pos = NULL;
620 03ad4005cd8e POSIX only: added __GDB_SCRIPT__ and __GDB__PATTERN__ support thomask parents: 499 diff changeset	315 #ifdef USE_POSIX
03ad4005cd8e POSIX only: added __GDB_SCRIPT__ and __GDB__PATTERN__ support thomask parents: 499 diff changeset	316 for(pos=strchr(filename, '\\'); pos; pos=strchr(filename, '\\')){
03ad4005cd8e POSIX only: added __GDB_SCRIPT__ and __GDB__PATTERN__ support thomask parents: 499 diff changeset	317 *pos='/';
03ad4005cd8e POSIX only: added __GDB_SCRIPT__ and __GDB__PATTERN__ support thomask parents: 499 diff changeset	318 }
03ad4005cd8e POSIX only: added __GDB_SCRIPT__ and __GDB__PATTERN__ support thomask parents: 499 diff changeset	319 #else
633 653cbe20c878 updated location of tmp files thomask parents: 622 diff changeset	320 #if USE_WINDOWS
620 03ad4005cd8e POSIX only: added __GDB_SCRIPT__ and __GDB__PATTERN__ support thomask parents: 499 diff changeset	321 for(pos=strchr(filename, '/'); pos; pos=strchr(filename, '/')){
03ad4005cd8e POSIX only: added __GDB_SCRIPT__ and __GDB__PATTERN__ support thomask parents: 499 diff changeset	322 *pos='\\';
03ad4005cd8e POSIX only: added __GDB_SCRIPT__ and __GDB__PATTERN__ support thomask parents: 499 diff changeset	323 }
03ad4005cd8e POSIX only: added __GDB_SCRIPT__ and __GDB__PATTERN__ support thomask parents: 499 diff changeset	324 #else
03ad4005cd8e POSIX only: added __GDB_SCRIPT__ and __GDB__PATTERN__ support thomask parents: 499 diff changeset	325
922 95160f4d06f8 minimized memory leaks in repeatedly called functions thomask parents: 904 diff changeset	326 #error no cleanPathSeperator implementation available for this system
620 03ad4005cd8e POSIX only: added __GDB_SCRIPT__ and __GDB__PATTERN__ support thomask parents: 499 diff changeset	327
633 653cbe20c878 updated location of tmp files thomask parents: 622 diff changeset	328 #endif /* USE_WINDOWS else */
620 03ad4005cd8e POSIX only: added __GDB_SCRIPT__ and __GDB__PATTERN__ support thomask parents: 499 diff changeset	329 #endif /* USE_POSIX else */
03ad4005cd8e POSIX only: added __GDB_SCRIPT__ and __GDB__PATTERN__ support thomask parents: 499 diff changeset	330 return filename;
03ad4005cd8e POSIX only: added __GDB_SCRIPT__ and __GDB__PATTERN__ support thomask parents: 499 diff changeset	331 }
490 d091ff903fa4 added crashRun for POSIX systems thomask parents: 476 diff changeset	332
902 58966fea59f7 preparing parallel build thomask parents: 888 diff changeset	333 char* loadFile(char* filename, size_t* len){
490 d091ff903fa4 added crashRun for POSIX systems thomask parents: 476 diff changeset	334 #ifdef USE_POSIX
697 fbee62becd2c partial repos review thomask parents: 693 diff changeset	335 char* back;
251 6cd84461e17b enabled new "dstress.c" test tool thomask parents: diff changeset	336 struct stat fileInfo;
6cd84461e17b enabled new "dstress.c" test tool thomask parents: diff changeset	337 int file = open(filename, O_RDONLY);
697 fbee62becd2c partial repos review thomask parents: 693 diff changeset	338
fbee62becd2c partial repos review thomask parents: 693 diff changeset	339 back = NULL;
fbee62becd2c partial repos review thomask parents: 693 diff changeset	340
251 6cd84461e17b enabled new "dstress.c" test tool thomask parents: diff changeset	341 if(errno == 0 && file != 0 && file != -1){
6cd84461e17b enabled new "dstress.c" test tool thomask parents: diff changeset	342 if(0==fstat(file, &fileInfo)){
1206 d88a87712de1 fixed dstress.c for C++ compilers thomask parents: 1003 diff changeset	343 back = (char*) malloc(fileInfo.st_size+1);
251 6cd84461e17b enabled new "dstress.c" test tool thomask parents: diff changeset	344 fileInfo.st_size = read(file, back, fileInfo.st_size);
440 dc186d1266ba fixed handling of empty files thomask parents: 439 diff changeset	345 if(fileInfo.st_size>=0){
697 fbee62becd2c partial repos review thomask parents: 693 diff changeset	346 *(back+fileInfo.st_size) = '\x00';
902 58966fea59f7 preparing parallel build thomask parents: 888 diff changeset	347 *len = fileInfo.st_size;
251 6cd84461e17b enabled new "dstress.c" test tool thomask parents: diff changeset	348 }else{
436 5e210bace0f1 added "File not found" clause thomask parents: 432 diff changeset	349 back = NULL;
902 58966fea59f7 preparing parallel build thomask parents: 888 diff changeset	350 *len = 0;
251 6cd84461e17b enabled new "dstress.c" test tool thomask parents: diff changeset	351 }
6cd84461e17b enabled new "dstress.c" test tool thomask parents: diff changeset	352 }
6cd84461e17b enabled new "dstress.c" test tool thomask parents: diff changeset	353 close(file);
6cd84461e17b enabled new "dstress.c" test tool thomask parents: diff changeset	354 }
436 5e210bace0f1 added "File not found" clause thomask parents: 432 diff changeset	355
5e210bace0f1 added "File not found" clause thomask parents: 432 diff changeset	356 if(back){
5e210bace0f1 added "File not found" clause thomask parents: 432 diff changeset	357 return back;
5e210bace0f1 added "File not found" clause thomask parents: 432 diff changeset	358 }
5e210bace0f1 added "File not found" clause thomask parents: 432 diff changeset	359
620 03ad4005cd8e POSIX only: added __GDB_SCRIPT__ and __GDB__PATTERN__ support thomask parents: 499 diff changeset	360 fprintf(stderr, "File not found \"%s\" (%s)\n", filename, strerror(errno));
436 5e210bace0f1 added "File not found" clause thomask parents: 432 diff changeset	361 exit(EXIT_FAILURE);
620 03ad4005cd8e POSIX only: added __GDB_SCRIPT__ and __GDB__PATTERN__ support thomask parents: 499 diff changeset	362 #else /* USE_POSIX */
633 653cbe20c878 updated location of tmp files thomask parents: 622 diff changeset	363 #ifdef USE_WINDOWS
734 d4edcc124e64 added Torture capabilities thomask parents: 710 diff changeset	364 /* @todo@ check for 32bit/64bit */
697 fbee62becd2c partial repos review thomask parents: 693 diff changeset	365 char* back;
254 a39162afcc94 MSWindows port of "dstress.c" thomask parents: 251 diff changeset	366 DWORD size, numread;
a39162afcc94 MSWindows port of "dstress.c" thomask parents: 251 diff changeset	367 HANDLE file=CreateFile(filename, GENERIC_READ, FILE_SHARE_READ, NULL,
a39162afcc94 MSWindows port of "dstress.c" thomask parents: 251 diff changeset	368 OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL \| FILE_FLAG_SEQUENTIAL_SCAN, NULL);
697 fbee62becd2c partial repos review thomask parents: 693 diff changeset	369
fbee62becd2c partial repos review thomask parents: 693 diff changeset	370 back = NULL;
fbee62becd2c partial repos review thomask parents: 693 diff changeset	371 size = 0;
fbee62becd2c partial repos review thomask parents: 693 diff changeset	372 numread = 0;
254 a39162afcc94 MSWindows port of "dstress.c" thomask parents: 251 diff changeset	373 if (file != INVALID_HANDLE_VALUE){
a39162afcc94 MSWindows port of "dstress.c" thomask parents: 251 diff changeset	374 size = GetFileSize(file, NULL);
a39162afcc94 MSWindows port of "dstress.c" thomask parents: 251 diff changeset	375 if (size != INVALID_FILE_SIZE){
a39162afcc94 MSWindows port of "dstress.c" thomask parents: 251 diff changeset	376 back=malloc((size+1)*sizeof(char));
292 7e28d437d6d7 fixed Windows loadFile return code bug thomask parents: 273 diff changeset	377 if (ReadFile(file,back,size,&numread,NULL) == 1){
7e28d437d6d7 fixed Windows loadFile return code bug thomask parents: 273 diff changeset	378 if (numread==size){
697 fbee62becd2c partial repos review thomask parents: 693 diff changeset	379 *(back+size) = '\x00';
904 67e77ee70d66 minor OpenBSD and Windows fixes thomask parents: 902 diff changeset	380 *len = size;
292 7e28d437d6d7 fixed Windows loadFile return code bug thomask parents: 273 diff changeset	381 }else{
438 27039d5cbe81 partial cleanup for Windows(dmc) thomask parents: 437 diff changeset	382 back = NULL;
904 67e77ee70d66 minor OpenBSD and Windows fixes thomask parents: 902 diff changeset	383 *len = 0;
292 7e28d437d6d7 fixed Windows loadFile return code bug thomask parents: 273 diff changeset	384 }
7e28d437d6d7 fixed Windows loadFile return code bug thomask parents: 273 diff changeset	385 }else{
438 27039d5cbe81 partial cleanup for Windows(dmc) thomask parents: 437 diff changeset	386 back = NULL;
904 67e77ee70d66 minor OpenBSD and Windows fixes thomask parents: 902 diff changeset	387 *len = 0;
292 7e28d437d6d7 fixed Windows loadFile return code bug thomask parents: 273 diff changeset	388 }
254 a39162afcc94 MSWindows port of "dstress.c" thomask parents: 251 diff changeset	389 }
a39162afcc94 MSWindows port of "dstress.c" thomask parents: 251 diff changeset	390 CloseHandle(file);
a39162afcc94 MSWindows port of "dstress.c" thomask parents: 251 diff changeset	391 }
438 27039d5cbe81 partial cleanup for Windows(dmc) thomask parents: 437 diff changeset	392 if(back){
27039d5cbe81 partial cleanup for Windows(dmc) thomask parents: 437 diff changeset	393 errno = 0;
27039d5cbe81 partial cleanup for Windows(dmc) thomask parents: 437 diff changeset	394 return back;
27039d5cbe81 partial cleanup for Windows(dmc) thomask parents: 437 diff changeset	395 }
27039d5cbe81 partial cleanup for Windows(dmc) thomask parents: 437 diff changeset	396
27039d5cbe81 partial cleanup for Windows(dmc) thomask parents: 437 diff changeset	397 fprintf(stderr, "File not found \"%s\"\n", filename);
27039d5cbe81 partial cleanup for Windows(dmc) thomask parents: 437 diff changeset	398 exit(EXIT_FAILURE);
633 653cbe20c878 updated location of tmp files thomask parents: 622 diff changeset	399 #else /* USE_WINDOWS */
339 a74c84e75682 added error line tests (__DSTRESS_ELINE__ / __DSTRESS_EFILE__) thomask parents: 292 diff changeset	400
707 5ba45899cddd minor infrastructure fixes thomask parents: 704 diff changeset	401 #error no loadFile implementation present
361 0147a35cbeb7 dif. fixes 5 thomask parents: 340 diff changeset	402
633 653cbe20c878 updated location of tmp files thomask parents: 622 diff changeset	403 #endif /* USE_WINDOWS */
339 a74c84e75682 added error line tests (__DSTRESS_ELINE__ / __DSTRESS_EFILE__) thomask parents: 292 diff changeset	404 #endif /* USE_POSIX else */
490 d091ff903fa4 added crashRun for POSIX systems thomask parents: 476 diff changeset	405 }
339 a74c84e75682 added error line tests (__DSTRESS_ELINE__ / __DSTRESS_EFILE__) thomask parents: 292 diff changeset	406
620 03ad4005cd8e POSIX only: added __GDB_SCRIPT__ and __GDB__PATTERN__ support thomask parents: 499 diff changeset	407 void writeFile(const char* filename, const char* content){
697 fbee62becd2c partial repos review thomask parents: 693 diff changeset	408 size_t len;
fbee62becd2c partial repos review thomask parents: 693 diff changeset	409 FILE* file;
fbee62becd2c partial repos review thomask parents: 693 diff changeset	410
fbee62becd2c partial repos review thomask parents: 693 diff changeset	411 len = strlen(content);
fbee62becd2c partial repos review thomask parents: 693 diff changeset	412 errno = 0;
fbee62becd2c partial repos review thomask parents: 693 diff changeset	413 file = fopen(filename, "w+");
620 03ad4005cd8e POSIX only: added __GDB_SCRIPT__ and __GDB__PATTERN__ support thomask parents: 499 diff changeset	414
03ad4005cd8e POSIX only: added __GDB_SCRIPT__ and __GDB__PATTERN__ support thomask parents: 499 diff changeset	415 if(errno == 0 && file != NULL){
03ad4005cd8e POSIX only: added __GDB_SCRIPT__ and __GDB__PATTERN__ support thomask parents: 499 diff changeset	416 if((fwrite(content, sizeof(char), len, file) != len) \|\| (errno != 0)){
03ad4005cd8e POSIX only: added __GDB_SCRIPT__ and __GDB__PATTERN__ support thomask parents: 499 diff changeset	417 fprintf(stderr, "failed to write file \"%s\" (%s)\n", filename, strerror(errno));
03ad4005cd8e POSIX only: added __GDB_SCRIPT__ and __GDB__PATTERN__ support thomask parents: 499 diff changeset	418 exit(EXIT_FAILURE);
03ad4005cd8e POSIX only: added __GDB_SCRIPT__ and __GDB__PATTERN__ support thomask parents: 499 diff changeset	419 }
03ad4005cd8e POSIX only: added __GDB_SCRIPT__ and __GDB__PATTERN__ support thomask parents: 499 diff changeset	420 if(fclose(file) \|\| (errno != 0)){
03ad4005cd8e POSIX only: added __GDB_SCRIPT__ and __GDB__PATTERN__ support thomask parents: 499 diff changeset	421 fprintf(stderr, "failed to close file \"%s\" (%s)\n", filename, strerror(errno));
03ad4005cd8e POSIX only: added __GDB_SCRIPT__ and __GDB__PATTERN__ support thomask parents: 499 diff changeset	422 exit(EXIT_FAILURE);
03ad4005cd8e POSIX only: added __GDB_SCRIPT__ and __GDB__PATTERN__ support thomask parents: 499 diff changeset	423 }
03ad4005cd8e POSIX only: added __GDB_SCRIPT__ and __GDB__PATTERN__ support thomask parents: 499 diff changeset	424 return;
438 27039d5cbe81 partial cleanup for Windows(dmc) thomask parents: 437 diff changeset	425 }
499 0434764d4a66 removed redundancy in the output thomask parents: 493 diff changeset	426
620 03ad4005cd8e POSIX only: added __GDB_SCRIPT__ and __GDB__PATTERN__ support thomask parents: 499 diff changeset	427 fprintf(stderr, "couldn't open file \"%s\" for writing (%s)\n", filename, strerror(errno));
03ad4005cd8e POSIX only: added __GDB_SCRIPT__ and __GDB__PATTERN__ support thomask parents: 499 diff changeset	428 exit(EXIT_FAILURE);
438 27039d5cbe81 partial cleanup for Windows(dmc) thomask parents: 437 diff changeset	429 }
27039d5cbe81 partial cleanup for Windows(dmc) thomask parents: 437 diff changeset	430
499 0434764d4a66 removed redundancy in the output thomask parents: 493 diff changeset	431 /* query the environment for the compiler name */
697 fbee62becd2c partial repos review thomask parents: 693 diff changeset	432 char* getCompiler(void){
339 a74c84e75682 added error line tests (__DSTRESS_ELINE__ / __DSTRESS_EFILE__) thomask parents: 292 diff changeset	433 char* back = getenv("DMD");
704 3e690f0d2cbf documentation maintenance for dstress.c thomask parents: 703 diff changeset	434
3e690f0d2cbf documentation maintenance for dstress.c thomask parents: 703 diff changeset	435 if(back==NULL){
3e690f0d2cbf documentation maintenance for dstress.c thomask parents: 703 diff changeset	436 back = "dmd";
3e690f0d2cbf documentation maintenance for dstress.c thomask parents: 703 diff changeset	437 }
3e690f0d2cbf documentation maintenance for dstress.c thomask parents: 703 diff changeset	438
620 03ad4005cd8e POSIX only: added __GDB_SCRIPT__ and __GDB__PATTERN__ support thomask parents: 499 diff changeset	439 return strip(cleanPathSeperator(back));
03ad4005cd8e POSIX only: added __GDB_SCRIPT__ and __GDB__PATTERN__ support thomask parents: 499 diff changeset	440 }
03ad4005cd8e POSIX only: added __GDB_SCRIPT__ and __GDB__PATTERN__ support thomask parents: 499 diff changeset	441
03ad4005cd8e POSIX only: added __GDB_SCRIPT__ and __GDB__PATTERN__ support thomask parents: 499 diff changeset	442 /* query the environment for the debugger name */
697 fbee62becd2c partial repos review thomask parents: 693 diff changeset	443 char* getGDB(void){
620 03ad4005cd8e POSIX only: added __GDB_SCRIPT__ and __GDB__PATTERN__ support thomask parents: 499 diff changeset	444 char* back = getenv("GDB");
704 3e690f0d2cbf documentation maintenance for dstress.c thomask parents: 703 diff changeset	445
3e690f0d2cbf documentation maintenance for dstress.c thomask parents: 703 diff changeset	446 if(back==NULL){
3e690f0d2cbf documentation maintenance for dstress.c thomask parents: 703 diff changeset	447 back = "gdb";
3e690f0d2cbf documentation maintenance for dstress.c thomask parents: 703 diff changeset	448 }
3e690f0d2cbf documentation maintenance for dstress.c thomask parents: 703 diff changeset	449
620 03ad4005cd8e POSIX only: added __GDB_SCRIPT__ and __GDB__PATTERN__ support thomask parents: 499 diff changeset	450 return strip(cleanPathSeperator(back));
339 a74c84e75682 added error line tests (__DSTRESS_ELINE__ / __DSTRESS_EFILE__) thomask parents: 292 diff changeset	451 }
a74c84e75682 added error line tests (__DSTRESS_ELINE__ / __DSTRESS_EFILE__) thomask parents: 292 diff changeset	452
734 d4edcc124e64 added Torture capabilities thomask parents: 710 diff changeset	453 char* getTortureBlock(void){
d4edcc124e64 added Torture capabilities thomask parents: 710 diff changeset	454 char* back = getenv("DSTRESS_TORTURE_BLOCK");
d4edcc124e64 added Torture capabilities thomask parents: 710 diff changeset	455
d4edcc124e64 added Torture capabilities thomask parents: 710 diff changeset	456 if(back!=NULL){
d4edcc124e64 added Torture capabilities thomask parents: 710 diff changeset	457 back = strip(back);
d4edcc124e64 added Torture capabilities thomask parents: 710 diff changeset	458 if(strlen(back)<1){
d4edcc124e64 added Torture capabilities thomask parents: 710 diff changeset	459 back = NULL;
d4edcc124e64 added Torture capabilities thomask parents: 710 diff changeset	460 }
d4edcc124e64 added Torture capabilities thomask parents: 710 diff changeset	461 }
d4edcc124e64 added Torture capabilities thomask parents: 710 diff changeset	462
d4edcc124e64 added Torture capabilities thomask parents: 710 diff changeset	463 return back;
d4edcc124e64 added Torture capabilities thomask parents: 710 diff changeset	464 }
d4edcc124e64 added Torture capabilities thomask parents: 710 diff changeset	465
499 0434764d4a66 removed redundancy in the output thomask parents: 493 diff changeset	466 /* extract the FIRST occurance of a given TAG until the next linebreak */
339 a74c84e75682 added error line tests (__DSTRESS_ELINE__ / __DSTRESS_EFILE__) thomask parents: 292 diff changeset	467 char* getCaseFlag(const char* data, const char* tag){
a74c84e75682 added error line tests (__DSTRESS_ELINE__ / __DSTRESS_EFILE__) thomask parents: 292 diff changeset	468 char* begin;
a74c84e75682 added error line tests (__DSTRESS_ELINE__ / __DSTRESS_EFILE__) thomask parents: 292 diff changeset	469 char* end1;
a74c84e75682 added error line tests (__DSTRESS_ELINE__ / __DSTRESS_EFILE__) thomask parents: 292 diff changeset	470 char* end2;
a74c84e75682 added error line tests (__DSTRESS_ELINE__ / __DSTRESS_EFILE__) thomask parents: 292 diff changeset	471 char* back;
438 27039d5cbe81 partial cleanup for Windows(dmc) thomask parents: 437 diff changeset	472
697 fbee62becd2c partial repos review thomask parents: 693 diff changeset	473 begin = NULL;
fbee62becd2c partial repos review thomask parents: 693 diff changeset	474 end1 = NULL;
fbee62becd2c partial repos review thomask parents: 693 diff changeset	475 end2 = NULL;
fbee62becd2c partial repos review thomask parents: 693 diff changeset	476 back = NULL;
fbee62becd2c partial repos review thomask parents: 693 diff changeset	477
339 a74c84e75682 added error line tests (__DSTRESS_ELINE__ / __DSTRESS_EFILE__) thomask parents: 292 diff changeset	478 if(data!=NULL && tag!=NULL){
a74c84e75682 added error line tests (__DSTRESS_ELINE__ / __DSTRESS_EFILE__) thomask parents: 292 diff changeset	479 begin = strstr(data, tag);
a74c84e75682 added error line tests (__DSTRESS_ELINE__ / __DSTRESS_EFILE__) thomask parents: 292 diff changeset	480 if(begin!=NULL){
a74c84e75682 added error line tests (__DSTRESS_ELINE__ / __DSTRESS_EFILE__) thomask parents: 292 diff changeset	481 begin = begin+strlen(tag);
a74c84e75682 added error line tests (__DSTRESS_ELINE__ / __DSTRESS_EFILE__) thomask parents: 292 diff changeset	482 end1 = strstr(begin, "\n");
a74c84e75682 added error line tests (__DSTRESS_ELINE__ / __DSTRESS_EFILE__) thomask parents: 292 diff changeset	483 end2 = strstr(begin, "\r");
a74c84e75682 added error line tests (__DSTRESS_ELINE__ / __DSTRESS_EFILE__) thomask parents: 292 diff changeset	484 if(end2!=NULL && ((end1!=NULL && end2<end1) \|\| end1==NULL)){
a74c84e75682 added error line tests (__DSTRESS_ELINE__ / __DSTRESS_EFILE__) thomask parents: 292 diff changeset	485 end1=end2;
a74c84e75682 added error line tests (__DSTRESS_ELINE__ / __DSTRESS_EFILE__) thomask parents: 292 diff changeset	486 }
a74c84e75682 added error line tests (__DSTRESS_ELINE__ / __DSTRESS_EFILE__) thomask parents: 292 diff changeset	487 if(end1==NULL){
a74c84e75682 added error line tests (__DSTRESS_ELINE__ / __DSTRESS_EFILE__) thomask parents: 292 diff changeset	488 end1 = begin + strlen(begin);
a74c84e75682 added error line tests (__DSTRESS_ELINE__ / __DSTRESS_EFILE__) thomask parents: 292 diff changeset	489 }
1206 d88a87712de1 fixed dstress.c for C++ compilers thomask parents: 1003 diff changeset	490 back = (char*) malloc(end1-begin+1);
339 a74c84e75682 added error line tests (__DSTRESS_ELINE__ / __DSTRESS_EFILE__) thomask parents: 292 diff changeset	491 strncpy(back, begin, end1-begin);
697 fbee62becd2c partial repos review thomask parents: 693 diff changeset	492 back[end1-begin]='\x00';
968 8b6d2dcf9954 * fixed new line escapes in GDB_SCRIPT thomask parents: 959 diff changeset	493 return strip(back);
339 a74c84e75682 added error line tests (__DSTRESS_ELINE__ / __DSTRESS_EFILE__) thomask parents: 292 diff changeset	494 }
a74c84e75682 added error line tests (__DSTRESS_ELINE__ / __DSTRESS_EFILE__) thomask parents: 292 diff changeset	495 }
a74c84e75682 added error line tests (__DSTRESS_ELINE__ / __DSTRESS_EFILE__) thomask parents: 292 diff changeset	496
1206 d88a87712de1 fixed dstress.c for C++ compilers thomask parents: 1003 diff changeset	497 back = (char*) malloc(1);
971 8da09834526d * Valgrind support is now part of dstress.c instead of crashRun.c thomask parents: 968 diff changeset	498 back[0] = 0;
8da09834526d * Valgrind support is now part of dstress.c instead of crashRun.c thomask parents: 968 diff changeset	499 return back;
339 a74c84e75682 added error line tests (__DSTRESS_ELINE__ / __DSTRESS_EFILE__) thomask parents: 292 diff changeset	500 }
a74c84e75682 added error line tests (__DSTRESS_ELINE__ / __DSTRESS_EFILE__) thomask parents: 292 diff changeset	501
499 0434764d4a66 removed redundancy in the output thomask parents: 493 diff changeset	502 /* check compile-time error messages */
922 95160f4d06f8 minimized memory leaks in repeatedly called functions thomask parents: 904 diff changeset	503 int checkErrorMessage(const char* file, const char* line, const char* buffer){
339 a74c84e75682 added error line tests (__DSTRESS_ELINE__ / __DSTRESS_EFILE__) thomask parents: 292 diff changeset	504
a74c84e75682 added error line tests (__DSTRESS_ELINE__ / __DSTRESS_EFILE__) thomask parents: 292 diff changeset	505 char* dmd;
a74c84e75682 added error line tests (__DSTRESS_ELINE__ / __DSTRESS_EFILE__) thomask parents: 292 diff changeset	506 char* gdc;
697 fbee62becd2c partial repos review thomask parents: 693 diff changeset	507 size_t len;
fbee62becd2c partial repos review thomask parents: 693 diff changeset	508 int back;
339 a74c84e75682 added error line tests (__DSTRESS_ELINE__ / __DSTRESS_EFILE__) thomask parents: 292 diff changeset	509
697 fbee62becd2c partial repos review thomask parents: 693 diff changeset	510 dmd = NULL;
fbee62becd2c partial repos review thomask parents: 693 diff changeset	511 gdc = NULL;
fbee62becd2c partial repos review thomask parents: 693 diff changeset	512 len = 0;
fbee62becd2c partial repos review thomask parents: 693 diff changeset	513 back = 0;
339 a74c84e75682 added error line tests (__DSTRESS_ELINE__ / __DSTRESS_EFILE__) thomask parents: 292 diff changeset	514
a74c84e75682 added error line tests (__DSTRESS_ELINE__ / __DSTRESS_EFILE__) thomask parents: 292 diff changeset	515 /* clean arguments */
922 95160f4d06f8 minimized memory leaks in repeatedly called functions thomask parents: 904 diff changeset	516 if(file && !file[0]){
95160f4d06f8 minimized memory leaks in repeatedly called functions thomask parents: 904 diff changeset	517 file = NULL;
339 a74c84e75682 added error line tests (__DSTRESS_ELINE__ / __DSTRESS_EFILE__) thomask parents: 292 diff changeset	518 }
438 27039d5cbe81 partial cleanup for Windows(dmc) thomask parents: 437 diff changeset	519
922 95160f4d06f8 minimized memory leaks in repeatedly called functions thomask parents: 904 diff changeset	520 if(line && !line[0]){
95160f4d06f8 minimized memory leaks in repeatedly called functions thomask parents: 904 diff changeset	521 line = NULL;
339 a74c84e75682 added error line tests (__DSTRESS_ELINE__ / __DSTRESS_EFILE__) thomask parents: 292 diff changeset	522 }
438 27039d5cbe81 partial cleanup for Windows(dmc) thomask parents: 437 diff changeset	523
339 a74c84e75682 added error line tests (__DSTRESS_ELINE__ / __DSTRESS_EFILE__) thomask parents: 292 diff changeset	524 /* gen patterns*/
a74c84e75682 added error line tests (__DSTRESS_ELINE__ / __DSTRESS_EFILE__) thomask parents: 292 diff changeset	525 if(file!=NULL){
a74c84e75682 added error line tests (__DSTRESS_ELINE__ / __DSTRESS_EFILE__) thomask parents: 292 diff changeset	526 if(line!=NULL){
770 1a8a4d885f79 fixed patters to find secondary hits thomask parents: 746 diff changeset	527 len = strlen(file)+strlen(line)+3;
1206 d88a87712de1 fixed dstress.c for C++ compilers thomask parents: 1003 diff changeset	528 dmd = (char*) malloc(len);
685 4f97e51515d8 ported dstress.c to OpenBsd thomask parents: 681 diff changeset	529 snprintf(dmd, len, "%s(%s)", file, line);
4f97e51515d8 ported dstress.c to OpenBsd thomask parents: 681 diff changeset	530
1206 d88a87712de1 fixed dstress.c for C++ compilers thomask parents: 1003 diff changeset	531 gdc = (char*) malloc(--len);
770 1a8a4d885f79 fixed patters to find secondary hits thomask parents: 746 diff changeset	532 snprintf(gdc, len, "%s:%s", file, line);
339 a74c84e75682 added error line tests (__DSTRESS_ELINE__ / __DSTRESS_EFILE__) thomask parents: 292 diff changeset	533 }else{
685 4f97e51515d8 ported dstress.c to OpenBsd thomask parents: 681 diff changeset	534 len = strlen(file)+2;
1206 d88a87712de1 fixed dstress.c for C++ compilers thomask parents: 1003 diff changeset	535 dmd = (char*) malloc(len);
685 4f97e51515d8 ported dstress.c to OpenBsd thomask parents: 681 diff changeset	536 snprintf(dmd, len, "%s(", file);
622 7acb8b34c87a - fixed diagnostic 3/3 thomask parents: 620 diff changeset	537
1206 d88a87712de1 fixed dstress.c for C++ compilers thomask parents: 1003 diff changeset	538 gdc = (char*) malloc(len);
685 4f97e51515d8 ported dstress.c to OpenBsd thomask parents: 681 diff changeset	539 snprintf(gdc, len, "%s:", file);
339 a74c84e75682 added error line tests (__DSTRESS_ELINE__ / __DSTRESS_EFILE__) thomask parents: 292 diff changeset	540 }
a74c84e75682 added error line tests (__DSTRESS_ELINE__ / __DSTRESS_EFILE__) thomask parents: 292 diff changeset	541 }else if(line!=NULL){
770 1a8a4d885f79 fixed patters to find secondary hits thomask parents: 746 diff changeset	542 len = strlen(line)+3;
1206 d88a87712de1 fixed dstress.c for C++ compilers thomask parents: 1003 diff changeset	543 dmd = (char*) malloc(len);
770 1a8a4d885f79 fixed patters to find secondary hits thomask parents: 746 diff changeset	544 snprintf(dmd, len, "(%s)", line);
622 7acb8b34c87a - fixed diagnostic 3/3 thomask parents: 620 diff changeset	545
1206 d88a87712de1 fixed dstress.c for C++ compilers thomask parents: 1003 diff changeset	546 gdc = (char*) malloc(--len);
770 1a8a4d885f79 fixed patters to find secondary hits thomask parents: 746 diff changeset	547 snprintf(gdc, len, ":%s", line);
339 a74c84e75682 added error line tests (__DSTRESS_ELINE__ / __DSTRESS_EFILE__) thomask parents: 292 diff changeset	548 }else{
432 db4b6169a99d 1) implemented checkRuntimeErrorMessage thomask parents: 429 diff changeset	549 return 1;
339 a74c84e75682 added error line tests (__DSTRESS_ELINE__ / __DSTRESS_EFILE__) thomask parents: 292 diff changeset	550 }
a74c84e75682 added error line tests (__DSTRESS_ELINE__ / __DSTRESS_EFILE__) thomask parents: 292 diff changeset	551
438 27039d5cbe81 partial cleanup for Windows(dmc) thomask parents: 437 diff changeset	552 /* specific error messages */
676 f90958db522d extended debug output thomask parents: 639 diff changeset	553 #ifdef DEBUG
f90958db522d extended debug output thomask parents: 639 diff changeset	554 fprintf(stderr, "pattern(dmd):\t%s\n", dmd);
f90958db522d extended debug output thomask parents: 639 diff changeset	555 fprintf(stderr, "pattern(gdc):\t%s\n", gdc);
f90958db522d extended debug output thomask parents: 639 diff changeset	556 #endif
251 6cd84461e17b enabled new "dstress.c" test tool thomask parents: diff changeset	557
339 a74c84e75682 added error line tests (__DSTRESS_ELINE__ / __DSTRESS_EFILE__) thomask parents: 292 diff changeset	558 if( (dmd!=NULL && strstr(buffer, dmd))
a74c84e75682 added error line tests (__DSTRESS_ELINE__ / __DSTRESS_EFILE__) thomask parents: 292 diff changeset	559 \|\| (gdc!=NULL && strstr(buffer, gdc))
a74c84e75682 added error line tests (__DSTRESS_ELINE__ / __DSTRESS_EFILE__) thomask parents: 292 diff changeset	560 \|\| (dmd==NULL && gdc==NULL)){
a74c84e75682 added error line tests (__DSTRESS_ELINE__ / __DSTRESS_EFILE__) thomask parents: 292 diff changeset	561 back=1;
a74c84e75682 added error line tests (__DSTRESS_ELINE__ / __DSTRESS_EFILE__) thomask parents: 292 diff changeset	562 }
a74c84e75682 added error line tests (__DSTRESS_ELINE__ / __DSTRESS_EFILE__) thomask parents: 292 diff changeset	563
922 95160f4d06f8 minimized memory leaks in repeatedly called functions thomask parents: 904 diff changeset	564 free(dmd);
95160f4d06f8 minimized memory leaks in repeatedly called functions thomask parents: 904 diff changeset	565 free(gdc);
95160f4d06f8 minimized memory leaks in repeatedly called functions thomask parents: 904 diff changeset	566
339 a74c84e75682 added error line tests (__DSTRESS_ELINE__ / __DSTRESS_EFILE__) thomask parents: 292 diff changeset	567 return back;
a74c84e75682 added error line tests (__DSTRESS_ELINE__ / __DSTRESS_EFILE__) thomask parents: 292 diff changeset	568 }
a74c84e75682 added error line tests (__DSTRESS_ELINE__ / __DSTRESS_EFILE__) thomask parents: 292 diff changeset	569
922 95160f4d06f8 minimized memory leaks in repeatedly called functions thomask parents: 904 diff changeset	570 int checkRuntimeErrorMessage(const char* file, const char* line, const char* buffer){
438 27039d5cbe81 partial cleanup for Windows(dmc) thomask parents: 437 diff changeset	571 /* PhobosLong dir/file.d(2)
490 d091ff903fa4 added crashRun for POSIX systems thomask parents: 476 diff changeset	572 * Phobos package.module(2)
438 27039d5cbe81 partial cleanup for Windows(dmc) thomask parents: 437 diff changeset	573 */
432 db4b6169a99d 1) implemented checkRuntimeErrorMessage thomask parents: 429 diff changeset	574
db4b6169a99d 1) implemented checkRuntimeErrorMessage thomask parents: 429 diff changeset	575 char* phobos;
db4b6169a99d 1) implemented checkRuntimeErrorMessage thomask parents: 429 diff changeset	576 char* phobosLong;
db4b6169a99d 1) implemented checkRuntimeErrorMessage thomask parents: 429 diff changeset	577
922 95160f4d06f8 minimized memory leaks in repeatedly called functions thomask parents: 904 diff changeset	578 const char* begin;
95160f4d06f8 minimized memory leaks in repeatedly called functions thomask parents: 904 diff changeset	579 const char* end;
685 4f97e51515d8 ported dstress.c to OpenBsd thomask parents: 681 diff changeset	580 size_t len;
432 db4b6169a99d 1) implemented checkRuntimeErrorMessage thomask parents: 429 diff changeset	581
db4b6169a99d 1) implemented checkRuntimeErrorMessage thomask parents: 429 diff changeset	582 int back=0;
db4b6169a99d 1) implemented checkRuntimeErrorMessage thomask parents: 429 diff changeset	583
697 fbee62becd2c partial repos review thomask parents: 693 diff changeset	584 phobos = NULL;
fbee62becd2c partial repos review thomask parents: 693 diff changeset	585 phobosLong = NULL;
fbee62becd2c partial repos review thomask parents: 693 diff changeset	586
fbee62becd2c partial repos review thomask parents: 693 diff changeset	587 begin = NULL;
fbee62becd2c partial repos review thomask parents: 693 diff changeset	588 end = NULL;
fbee62becd2c partial repos review thomask parents: 693 diff changeset	589 len = 0;
fbee62becd2c partial repos review thomask parents: 693 diff changeset	590
432 db4b6169a99d 1) implemented checkRuntimeErrorMessage thomask parents: 429 diff changeset	591 /* clean arguments */
922 95160f4d06f8 minimized memory leaks in repeatedly called functions thomask parents: 904 diff changeset	592 if(file && !file[0]){
95160f4d06f8 minimized memory leaks in repeatedly called functions thomask parents: 904 diff changeset	593 file = NULL;
432 db4b6169a99d 1) implemented checkRuntimeErrorMessage thomask parents: 429 diff changeset	594 }
438 27039d5cbe81 partial cleanup for Windows(dmc) thomask parents: 437 diff changeset	595
922 95160f4d06f8 minimized memory leaks in repeatedly called functions thomask parents: 904 diff changeset	596 if(line && !line[0]){
95160f4d06f8 minimized memory leaks in repeatedly called functions thomask parents: 904 diff changeset	597 line = NULL;
432 db4b6169a99d 1) implemented checkRuntimeErrorMessage thomask parents: 429 diff changeset	598 }
438 27039d5cbe81 partial cleanup for Windows(dmc) thomask parents: 437 diff changeset	599
432 db4b6169a99d 1) implemented checkRuntimeErrorMessage thomask parents: 429 diff changeset	600 /* gen patterns*/
db4b6169a99d 1) implemented checkRuntimeErrorMessage thomask parents: 429 diff changeset	601 if(file!=NULL){
db4b6169a99d 1) implemented checkRuntimeErrorMessage thomask parents: 429 diff changeset	602 if(line!=NULL){
922 95160f4d06f8 minimized memory leaks in repeatedly called functions thomask parents: 904 diff changeset	603 len = strlen(file)+strlen(line)+3;
1206 d88a87712de1 fixed dstress.c for C++ compilers thomask parents: 1003 diff changeset	604 phobos = (char*) malloc(len);
438 27039d5cbe81 partial cleanup for Windows(dmc) thomask parents: 437 diff changeset	605 begin=strrchr(file,'/');
27039d5cbe81 partial cleanup for Windows(dmc) thomask parents: 437 diff changeset	606 if(begin){
432 db4b6169a99d 1) implemented checkRuntimeErrorMessage thomask parents: 429 diff changeset	607 begin++;
db4b6169a99d 1) implemented checkRuntimeErrorMessage thomask parents: 429 diff changeset	608 }else{
438 27039d5cbe81 partial cleanup for Windows(dmc) thomask parents: 437 diff changeset	609 begin=strrchr(file,'\\');
27039d5cbe81 partial cleanup for Windows(dmc) thomask parents: 437 diff changeset	610 if(begin){
27039d5cbe81 partial cleanup for Windows(dmc) thomask parents: 437 diff changeset	611 begin++;
27039d5cbe81 partial cleanup for Windows(dmc) thomask parents: 437 diff changeset	612 }else{
27039d5cbe81 partial cleanup for Windows(dmc) thomask parents: 437 diff changeset	613 begin=file;
27039d5cbe81 partial cleanup for Windows(dmc) thomask parents: 437 diff changeset	614 }
432 db4b6169a99d 1) implemented checkRuntimeErrorMessage thomask parents: 429 diff changeset	615 }
439 edb0923c9159 cleanup for Linux(gcc) thomask parents: 438 diff changeset	616 end=strrchr(file,'.');
edb0923c9159 cleanup for Linux(gcc) thomask parents: 438 diff changeset	617 strncat(phobos, begin, end-begin);
685 4f97e51515d8 ported dstress.c to OpenBsd thomask parents: 681 diff changeset	618 snprintf(phobos, len, "%.*s(%s)",
4f97e51515d8 ported dstress.c to OpenBsd thomask parents: 681 diff changeset	619 (int)(end-begin), begin,
4f97e51515d8 ported dstress.c to OpenBsd thomask parents: 681 diff changeset	620 line);
432 db4b6169a99d 1) implemented checkRuntimeErrorMessage thomask parents: 429 diff changeset	621
1206 d88a87712de1 fixed dstress.c for C++ compilers thomask parents: 1003 diff changeset	622 phobosLong = (char*) malloc(len);
685 4f97e51515d8 ported dstress.c to OpenBsd thomask parents: 681 diff changeset	623 snprintf(phobosLong, len, "%s(%s)", file, line);
432 db4b6169a99d 1) implemented checkRuntimeErrorMessage thomask parents: 429 diff changeset	624 }else{
685 4f97e51515d8 ported dstress.c to OpenBsd thomask parents: 681 diff changeset	625 len = strlen(file)+2;
1206 d88a87712de1 fixed dstress.c for C++ compilers thomask parents: 1003 diff changeset	626 phobos = (char*) malloc(len);
438 27039d5cbe81 partial cleanup for Windows(dmc) thomask parents: 437 diff changeset	627 begin=strrchr(file,'/');
27039d5cbe81 partial cleanup for Windows(dmc) thomask parents: 437 diff changeset	628 if(begin){
432 db4b6169a99d 1) implemented checkRuntimeErrorMessage thomask parents: 429 diff changeset	629 begin++;
db4b6169a99d 1) implemented checkRuntimeErrorMessage thomask parents: 429 diff changeset	630 }else{
438 27039d5cbe81 partial cleanup for Windows(dmc) thomask parents: 437 diff changeset	631 begin=strrchr(file,'\\');
27039d5cbe81 partial cleanup for Windows(dmc) thomask parents: 437 diff changeset	632 if(begin){
27039d5cbe81 partial cleanup for Windows(dmc) thomask parents: 437 diff changeset	633 begin++;
27039d5cbe81 partial cleanup for Windows(dmc) thomask parents: 437 diff changeset	634 }else{
27039d5cbe81 partial cleanup for Windows(dmc) thomask parents: 437 diff changeset	635 begin=file;
27039d5cbe81 partial cleanup for Windows(dmc) thomask parents: 437 diff changeset	636 }
432 db4b6169a99d 1) implemented checkRuntimeErrorMessage thomask parents: 429 diff changeset	637 }
439 edb0923c9159 cleanup for Linux(gcc) thomask parents: 438 diff changeset	638 end=strrchr(file,'.');
685 4f97e51515d8 ported dstress.c to OpenBsd thomask parents: 681 diff changeset	639 snprintf(phobos, len, "%.*s(", (int)(end-begin), begin);
432 db4b6169a99d 1) implemented checkRuntimeErrorMessage thomask parents: 429 diff changeset	640
1206 d88a87712de1 fixed dstress.c for C++ compilers thomask parents: 1003 diff changeset	641 phobosLong = (char*) malloc(len);
685 4f97e51515d8 ported dstress.c to OpenBsd thomask parents: 681 diff changeset	642 snprintf(phobosLong, len, "%s(", file);
432 db4b6169a99d 1) implemented checkRuntimeErrorMessage thomask parents: 429 diff changeset	643 }
db4b6169a99d 1) implemented checkRuntimeErrorMessage thomask parents: 429 diff changeset	644 }else if(line!=NULL){
685 4f97e51515d8 ported dstress.c to OpenBsd thomask parents: 681 diff changeset	645 len = strlen(line)+3;
1206 d88a87712de1 fixed dstress.c for C++ compilers thomask parents: 1003 diff changeset	646 phobos = (char*) malloc(len);
685 4f97e51515d8 ported dstress.c to OpenBsd thomask parents: 681 diff changeset	647 snprintf(phobos, len, "(%s)", line);
438 27039d5cbe81 partial cleanup for Windows(dmc) thomask parents: 437 diff changeset	648
432 db4b6169a99d 1) implemented checkRuntimeErrorMessage thomask parents: 429 diff changeset	649 phobosLong=NULL;
db4b6169a99d 1) implemented checkRuntimeErrorMessage thomask parents: 429 diff changeset	650 }else{
db4b6169a99d 1) implemented checkRuntimeErrorMessage thomask parents: 429 diff changeset	651 return 1;
db4b6169a99d 1) implemented checkRuntimeErrorMessage thomask parents: 429 diff changeset	652 }
db4b6169a99d 1) implemented checkRuntimeErrorMessage thomask parents: 429 diff changeset	653
438 27039d5cbe81 partial cleanup for Windows(dmc) thomask parents: 437 diff changeset	654 /* specific error messages */
432 db4b6169a99d 1) implemented checkRuntimeErrorMessage thomask parents: 429 diff changeset	655
676 f90958db522d extended debug output thomask parents: 639 diff changeset	656 #ifdef DEBUG
f90958db522d extended debug output thomask parents: 639 diff changeset	657 fprintf(stderr, "pattern(phobosShort):\t%s\n", phobos);
f90958db522d extended debug output thomask parents: 639 diff changeset	658 fprintf(stderr, "pattern(phobosLong):\t%s\n", phobosLong);
f90958db522d extended debug output thomask parents: 639 diff changeset	659 #endif
f90958db522d extended debug output thomask parents: 639 diff changeset	660
432 db4b6169a99d 1) implemented checkRuntimeErrorMessage thomask parents: 429 diff changeset	661 if( (phobos && strstr(buffer, phobos))
db4b6169a99d 1) implemented checkRuntimeErrorMessage thomask parents: 429 diff changeset	662 \|\| (phobosLong && strstr(buffer, phobosLong)))
db4b6169a99d 1) implemented checkRuntimeErrorMessage thomask parents: 429 diff changeset	663 {
db4b6169a99d 1) implemented checkRuntimeErrorMessage thomask parents: 429 diff changeset	664 back=1;
db4b6169a99d 1) implemented checkRuntimeErrorMessage thomask parents: 429 diff changeset	665 }
438 27039d5cbe81 partial cleanup for Windows(dmc) thomask parents: 437 diff changeset	666
922 95160f4d06f8 minimized memory leaks in repeatedly called functions thomask parents: 904 diff changeset	667 free(phobos);
95160f4d06f8 minimized memory leaks in repeatedly called functions thomask parents: 904 diff changeset	668 if(phobosLong){
95160f4d06f8 minimized memory leaks in repeatedly called functions thomask parents: 904 diff changeset	669 free(phobosLong);
95160f4d06f8 minimized memory leaks in repeatedly called functions thomask parents: 904 diff changeset	670 }
95160f4d06f8 minimized memory leaks in repeatedly called functions thomask parents: 904 diff changeset	671
438 27039d5cbe81 partial cleanup for Windows(dmc) thomask parents: 437 diff changeset	672 return back;
339 a74c84e75682 added error line tests (__DSTRESS_ELINE__ / __DSTRESS_EFILE__) thomask parents: 292 diff changeset	673 }
a74c84e75682 added error line tests (__DSTRESS_ELINE__ / __DSTRESS_EFILE__) thomask parents: 292 diff changeset	674
490 d091ff903fa4 added crashRun for POSIX systems thomask parents: 476 diff changeset	675 int hadExecCrash(const char* buffer){
620 03ad4005cd8e POSIX only: added __GDB_SCRIPT__ and __GDB__PATTERN__ support thomask parents: 499 diff changeset	676 if(strstr(buffer, "Segmentation fault")
03ad4005cd8e POSIX only: added __GDB_SCRIPT__ and __GDB__PATTERN__ support thomask parents: 499 diff changeset	677 \|\| strstr(buffer, "Internal error")
499 0434764d4a66 removed redundancy in the output thomask parents: 493 diff changeset	678 \|\| strstr(buffer, "gcc.gnu.org/bugs")
774 eb7dc8747fa7 added Stewart's crash indicators thomask parents: 770 diff changeset	679 \|\| strstr(buffer, "EXIT CODE: signal")
eb7dc8747fa7 added Stewart's crash indicators thomask parents: 770 diff changeset	680 \|\| strstr(buffer, "Assertion failure")
968 8b6d2dcf9954 * fixed new line escapes in GDB_SCRIPT thomask parents: 959 diff changeset	681 \|\| strstr(buffer, "Access Violation")
8b6d2dcf9954 * fixed new line escapes in GDB_SCRIPT thomask parents: 959 diff changeset	682 \|\| strstr(buffer, "Invalid read of size")
8b6d2dcf9954 * fixed new line escapes in GDB_SCRIPT thomask parents: 959 diff changeset	683 \|\| strstr(buffer, "Conditional jump or move depends on uninitialised value")
8b6d2dcf9954 * fixed new line escapes in GDB_SCRIPT thomask parents: 959 diff changeset	684 \|\| strstr(buffer, "Use of uninitialised value of size"))
490 d091ff903fa4 added crashRun for POSIX systems thomask parents: 476 diff changeset	685 {
d091ff903fa4 added crashRun for POSIX systems thomask parents: 476 diff changeset	686 return 1;
d091ff903fa4 added crashRun for POSIX systems thomask parents: 476 diff changeset	687 }
d091ff903fa4 added crashRun for POSIX systems thomask parents: 476 diff changeset	688 return 0;
d091ff903fa4 added crashRun for POSIX systems thomask parents: 476 diff changeset	689 }
d091ff903fa4 added crashRun for POSIX systems thomask parents: 476 diff changeset	690
999 69f95c134121 added conditional result capabilities thomask parents: 998 diff changeset	691 int conditionalResult(const char* buffer){
69f95c134121 added conditional result capabilities thomask parents: 998 diff changeset	692 if(strstr(buffer, "DSTRESS{XFAIL}")){
69f95c134121 added conditional result capabilities thomask parents: 998 diff changeset	693 return RES_XFAIL;
69f95c134121 added conditional result capabilities thomask parents: 998 diff changeset	694 }else if(strstr(buffer, "DSTRESS{XPASS}")){
69f95c134121 added conditional result capabilities thomask parents: 998 diff changeset	695 return RES_XPASS;
69f95c134121 added conditional result capabilities thomask parents: 998 diff changeset	696 }else if(strstr(buffer, "DSTRESS{FAIL}")){
69f95c134121 added conditional result capabilities thomask parents: 998 diff changeset	697 return RES_FAIL;
69f95c134121 added conditional result capabilities thomask parents: 998 diff changeset	698 }else if(strstr(buffer, "DSTRESS{PASS}")){
69f95c134121 added conditional result capabilities thomask parents: 998 diff changeset	699 return RES_PASS;
69f95c134121 added conditional result capabilities thomask parents: 998 diff changeset	700 }else if(strstr(buffer, "DSTRESS{ERROR}")){
69f95c134121 added conditional result capabilities thomask parents: 998 diff changeset	701 return RES_ERROR;
69f95c134121 added conditional result capabilities thomask parents: 998 diff changeset	702 }else{
69f95c134121 added conditional result capabilities thomask parents: 998 diff changeset	703 return 0;
69f95c134121 added conditional result capabilities thomask parents: 998 diff changeset	704 }
69f95c134121 added conditional result capabilities thomask parents: 998 diff changeset	705
69f95c134121 added conditional result capabilities thomask parents: 998 diff changeset	706 }
69f95c134121 added conditional result capabilities thomask parents: 998 diff changeset	707
499 0434764d4a66 removed redundancy in the output thomask parents: 493 diff changeset	708 /* system call with time-out */
734 d4edcc124e64 added Torture capabilities thomask parents: 710 diff changeset	709 int crashRun(const char* cmd, char** logFile){
746 0e3682dad93a fixed windows part of dstress.c thomask parents: 742 diff changeset	710
697 fbee62becd2c partial repos review thomask parents: 693 diff changeset	711 size_t len;
fbee62becd2c partial repos review thomask parents: 693 diff changeset	712 char* buffer;
922 95160f4d06f8 minimized memory leaks in repeatedly called functions thomask parents: 904 diff changeset	713 int back;
986 c6f4a1d57892 added VS2005 support thomask parents: 985 diff changeset	714 #ifdef USE_WINDOWS
c6f4a1d57892 added VS2005 support thomask parents: 985 diff changeset	715 PROCESS_INFORMATION processInfo;
c6f4a1d57892 added VS2005 support thomask parents: 985 diff changeset	716 STARTUPINFO startupInfo;
c6f4a1d57892 added VS2005 support thomask parents: 985 diff changeset	717 SECURITY_ATTRIBUTES sa = {
c6f4a1d57892 added VS2005 support thomask parents: 985 diff changeset	718 sizeof(SECURITY_ATTRIBUTES), NULL, TRUE
c6f4a1d57892 added VS2005 support thomask parents: 985 diff changeset	719 };
c6f4a1d57892 added VS2005 support thomask parents: 985 diff changeset	720 HANDLE tLogFile;
c6f4a1d57892 added VS2005 support thomask parents: 985 diff changeset	721 unsigned long exitCode;
c6f4a1d57892 added VS2005 support thomask parents: 985 diff changeset	722 int timeLeft = 600; /* time limit in iterations of WFX loop */
c6f4a1d57892 added VS2005 support thomask parents: 985 diff changeset	723 #endif
697 fbee62becd2c partial repos review thomask parents: 693 diff changeset	724
734 d4edcc124e64 added Torture capabilities thomask parents: 710 diff changeset	725 *logFile = genTempFileName();
746 0e3682dad93a fixed windows part of dstress.c thomask parents: 742 diff changeset	726 #ifdef USE_POSIX
1264 b3d4452d48ac added DMD-0.177's results thomask parents: 1206 diff changeset	727 len = 40 + strlen(CRASH_RUN) + strlen(cmd) + strlen(*logFile);
1206 d88a87712de1 fixed dstress.c for C++ compilers thomask parents: 1003 diff changeset	728 buffer = (char*) malloc(len);
697 fbee62becd2c partial repos review thomask parents: 693 diff changeset	729
1264 b3d4452d48ac added DMD-0.177's results thomask parents: 1206 diff changeset	730 snprintf(buffer, len, "%s %s 2>&1 \| head -n 200 > %s", CRASH_RUN, cmd, *logFile);
697 fbee62becd2c partial repos review thomask parents: 693 diff changeset	731
490 d091ff903fa4 added crashRun for POSIX systems thomask parents: 476 diff changeset	732 system(buffer);
922 95160f4d06f8 minimized memory leaks in repeatedly called functions thomask parents: 904 diff changeset	733 free(buffer);
95160f4d06f8 minimized memory leaks in repeatedly called functions thomask parents: 904 diff changeset	734
902 58966fea59f7 preparing parallel build thomask parents: 888 diff changeset	735 buffer=loadFile(*logFile, &len);
490 d091ff903fa4 added crashRun for POSIX systems thomask parents: 476 diff changeset	736
902 58966fea59f7 preparing parallel build thomask parents: 888 diff changeset	737 /* @todo@ use: len */
490 d091ff903fa4 added crashRun for POSIX systems thomask parents: 476 diff changeset	738 if(strstr(buffer, "EXIT CODE: 0")){
922 95160f4d06f8 minimized memory leaks in repeatedly called functions thomask parents: 904 diff changeset	739 back = EXIT_SUCCESS;
490 d091ff903fa4 added crashRun for POSIX systems thomask parents: 476 diff changeset	740 }else if(strstr(buffer, "EXIT CODE: 256")
1391 5b177d79b7d6 added i686-apple-darwin8-gdc-4.0.1 timeout marker thomask parents: 1389 diff changeset	741 \|\| strstr(buffer, "EXIT CODE: timeout") \|\| strstr(buffer, "Cputime limit exceeded"))
490 d091ff903fa4 added crashRun for POSIX systems thomask parents: 476 diff changeset	742 {
922 95160f4d06f8 minimized memory leaks in repeatedly called functions thomask parents: 904 diff changeset	743 back = EXIT_FAILURE;
490 d091ff903fa4 added crashRun for POSIX systems thomask parents: 476 diff changeset	744 }else{
922 95160f4d06f8 minimized memory leaks in repeatedly called functions thomask parents: 904 diff changeset	745 back = RAND_MAX;
490 d091ff903fa4 added crashRun for POSIX systems thomask parents: 476 diff changeset	746 }
922 95160f4d06f8 minimized memory leaks in repeatedly called functions thomask parents: 904 diff changeset	747 free(buffer);
95160f4d06f8 minimized memory leaks in repeatedly called functions thomask parents: 904 diff changeset	748
95160f4d06f8 minimized memory leaks in repeatedly called functions thomask parents: 904 diff changeset	749 return back;
888 a995eae8e75c blind: partial merger of Stewart's crashRun for Windows thomask parents: 881 diff changeset	750 #elif defined USE_WINDOWS
a995eae8e75c blind: partial merger of Stewart's crashRun for Windows thomask parents: 881 diff changeset	751 memset(&processInfo, 0, sizeof(PROCESS_INFORMATION));
a995eae8e75c blind: partial merger of Stewart's crashRun for Windows thomask parents: 881 diff changeset	752 memset(&startupInfo, 0, sizeof(STARTUPINFO));
a995eae8e75c blind: partial merger of Stewart's crashRun for Windows thomask parents: 881 diff changeset	753 startupInfo.cb = sizeof(STARTUPINFO);
a995eae8e75c blind: partial merger of Stewart's crashRun for Windows thomask parents: 881 diff changeset	754
a995eae8e75c blind: partial merger of Stewart's crashRun for Windows thomask parents: 881 diff changeset	755 tLogFile = CreateFile(*logFile, GENERIC_WRITE,
a995eae8e75c blind: partial merger of Stewart's crashRun for Windows thomask parents: 881 diff changeset	756 0, &sa, CREATE_ALWAYS, FILE_FLAG_WRITE_THROUGH, NULL);
a995eae8e75c blind: partial merger of Stewart's crashRun for Windows thomask parents: 881 diff changeset	757
a995eae8e75c blind: partial merger of Stewart's crashRun for Windows thomask parents: 881 diff changeset	758 if (tLogFile == NULL) {
a995eae8e75c blind: partial merger of Stewart's crashRun for Windows thomask parents: 881 diff changeset	759 printf("ERROR: could not open log file");
a995eae8e75c blind: partial merger of Stewart's crashRun for Windows thomask parents: 881 diff changeset	760 return RAND_MAX;
a995eae8e75c blind: partial merger of Stewart's crashRun for Windows thomask parents: 881 diff changeset	761 }
a995eae8e75c blind: partial merger of Stewart's crashRun for Windows thomask parents: 881 diff changeset	762
a995eae8e75c blind: partial merger of Stewart's crashRun for Windows thomask parents: 881 diff changeset	763 SetStdHandle(STD_OUTPUT_HANDLE, tLogFile);
a995eae8e75c blind: partial merger of Stewart's crashRun for Windows thomask parents: 881 diff changeset	764 SetStdHandle(STD_ERROR_HANDLE, originalStdout);
a995eae8e75c blind: partial merger of Stewart's crashRun for Windows thomask parents: 881 diff changeset	765
a995eae8e75c blind: partial merger of Stewart's crashRun for Windows thomask parents: 881 diff changeset	766 if (!CreateProcess(NULL, (char*) cmd, NULL, NULL, TRUE, 0, NULL, NULL,
a995eae8e75c blind: partial merger of Stewart's crashRun for Windows thomask parents: 881 diff changeset	767 &startupInfo, &processInfo)) {
a995eae8e75c blind: partial merger of Stewart's crashRun for Windows thomask parents: 881 diff changeset	768 void *message;
a995eae8e75c blind: partial merger of Stewart's crashRun for Windows thomask parents: 881 diff changeset	769
a995eae8e75c blind: partial merger of Stewart's crashRun for Windows thomask parents: 881 diff changeset	770 FormatMessageA(FORMAT_MESSAGE_ALLOCATE_BUFFER
a995eae8e75c blind: partial merger of Stewart's crashRun for Windows thomask parents: 881 diff changeset	771 \| FORMAT_MESSAGE_FROM_SYSTEM, NULL, GetLastError(), 0,
a995eae8e75c blind: partial merger of Stewart's crashRun for Windows thomask parents: 881 diff changeset	772 (char*) &message, 0, NULL);
490 d091ff903fa4 added crashRun for POSIX systems thomask parents: 476 diff changeset	773
888 a995eae8e75c blind: partial merger of Stewart's crashRun for Windows thomask parents: 881 diff changeset	774 SetStdHandle(STD_OUTPUT_HANDLE, originalStdout);
a995eae8e75c blind: partial merger of Stewart's crashRun for Windows thomask parents: 881 diff changeset	775 SetStdHandle(STD_ERROR_HANDLE, originalStderr);
a995eae8e75c blind: partial merger of Stewart's crashRun for Windows thomask parents: 881 diff changeset	776 CloseHandle(tLogFile);
a995eae8e75c blind: partial merger of Stewart's crashRun for Windows thomask parents: 881 diff changeset	777
902 58966fea59f7 preparing parallel build thomask parents: 888 diff changeset	778 /* this should never happen */
888 a995eae8e75c blind: partial merger of Stewart's crashRun for Windows thomask parents: 881 diff changeset	779 fprintf(stderr, "ERROR running %s:\n", cmd);
a995eae8e75c blind: partial merger of Stewart's crashRun for Windows thomask parents: 881 diff changeset	780 fprintf(stderr, "%s\n", message);
a995eae8e75c blind: partial merger of Stewart's crashRun for Windows thomask parents: 881 diff changeset	781 LocalFree((HLOCAL) message);
a995eae8e75c blind: partial merger of Stewart's crashRun for Windows thomask parents: 881 diff changeset	782 return RAND_MAX;
a995eae8e75c blind: partial merger of Stewart's crashRun for Windows thomask parents: 881 diff changeset	783 }
a995eae8e75c blind: partial merger of Stewart's crashRun for Windows thomask parents: 881 diff changeset	784
902 58966fea59f7 preparing parallel build thomask parents: 888 diff changeset	785 /* wait for exit */
888 a995eae8e75c blind: partial merger of Stewart's crashRun for Windows thomask parents: 881 diff changeset	786 while (TRUE) {
a995eae8e75c blind: partial merger of Stewart's crashRun for Windows thomask parents: 881 diff changeset	787 GetExitCodeProcess(processInfo.hProcess, &exitCode);
a995eae8e75c blind: partial merger of Stewart's crashRun for Windows thomask parents: 881 diff changeset	788 if (exitCode == 0x103) {
a995eae8e75c blind: partial merger of Stewart's crashRun for Windows thomask parents: 881 diff changeset	789 if (--timeLeft == 0) {
a995eae8e75c blind: partial merger of Stewart's crashRun for Windows thomask parents: 881 diff changeset	790 TerminateProcess(processInfo.hProcess, EXIT_FAILURE);
a995eae8e75c blind: partial merger of Stewart's crashRun for Windows thomask parents: 881 diff changeset	791 SetStdHandle(STD_OUTPUT_HANDLE, originalStdout);
a995eae8e75c blind: partial merger of Stewart's crashRun for Windows thomask parents: 881 diff changeset	792 SetStdHandle(STD_ERROR_HANDLE, originalStderr);
a995eae8e75c blind: partial merger of Stewart's crashRun for Windows thomask parents: 881 diff changeset	793 CloseHandle(tLogFile);
a995eae8e75c blind: partial merger of Stewart's crashRun for Windows thomask parents: 881 diff changeset	794 printf("EXIT CODE: timeout\n");
a995eae8e75c blind: partial merger of Stewart's crashRun for Windows thomask parents: 881 diff changeset	795 Sleep(100);
a995eae8e75c blind: partial merger of Stewart's crashRun for Windows thomask parents: 881 diff changeset	796 return RAND_MAX;
a995eae8e75c blind: partial merger of Stewart's crashRun for Windows thomask parents: 881 diff changeset	797 }
a995eae8e75c blind: partial merger of Stewart's crashRun for Windows thomask parents: 881 diff changeset	798 Sleep(100);
a995eae8e75c blind: partial merger of Stewart's crashRun for Windows thomask parents: 881 diff changeset	799 } else {
a995eae8e75c blind: partial merger of Stewart's crashRun for Windows thomask parents: 881 diff changeset	800 SetStdHandle(STD_OUTPUT_HANDLE, originalStdout);
a995eae8e75c blind: partial merger of Stewart's crashRun for Windows thomask parents: 881 diff changeset	801 SetStdHandle(STD_ERROR_HANDLE, originalStderr);
a995eae8e75c blind: partial merger of Stewart's crashRun for Windows thomask parents: 881 diff changeset	802
a995eae8e75c blind: partial merger of Stewart's crashRun for Windows thomask parents: 881 diff changeset	803 CloseHandle(tLogFile);
a995eae8e75c blind: partial merger of Stewart's crashRun for Windows thomask parents: 881 diff changeset	804
a995eae8e75c blind: partial merger of Stewart's crashRun for Windows thomask parents: 881 diff changeset	805 printf("EXIT CODE: %i\n", exitCode);
a995eae8e75c blind: partial merger of Stewart's crashRun for Windows thomask parents: 881 diff changeset	806 return exitCode;
a995eae8e75c blind: partial merger of Stewart's crashRun for Windows thomask parents: 881 diff changeset	807 }
a995eae8e75c blind: partial merger of Stewart's crashRun for Windows thomask parents: 881 diff changeset	808 }
a995eae8e75c blind: partial merger of Stewart's crashRun for Windows thomask parents: 881 diff changeset	809
a995eae8e75c blind: partial merger of Stewart's crashRun for Windows thomask parents: 881 diff changeset	810 #else /* USE_WINDOWS */
704 3e690f0d2cbf documentation maintenance for dstress.c thomask parents: 703 diff changeset	811 #error comment me out, if your test cases produce neither eternal loops nor Access Violations
746 0e3682dad93a fixed windows part of dstress.c thomask parents: 742 diff changeset	812
0e3682dad93a fixed windows part of dstress.c thomask parents: 742 diff changeset	813 len = 10 + strlen(cmd) + strlen(*logFile);
0e3682dad93a fixed windows part of dstress.c thomask parents: 742 diff changeset	814 buffer = malloc(len);
0e3682dad93a fixed windows part of dstress.c thomask parents: 742 diff changeset	815
0e3682dad93a fixed windows part of dstress.c thomask parents: 742 diff changeset	816 snprintf(buffer, len, "%s > %s 2>&1", cmd, *logFile);
0e3682dad93a fixed windows part of dstress.c thomask parents: 742 diff changeset	817
0e3682dad93a fixed windows part of dstress.c thomask parents: 742 diff changeset	818 int i = system(buffer);
902 58966fea59f7 preparing parallel build thomask parents: 888 diff changeset	819 printf("EXIT CODE: %i\n", i);
746 0e3682dad93a fixed windows part of dstress.c thomask parents: 742 diff changeset	820
697 fbee62becd2c partial repos review thomask parents: 693 diff changeset	821 return i;
490 d091ff903fa4 added crashRun for POSIX systems thomask parents: 476 diff changeset	822 #endif /* USE_POSIX else */
d091ff903fa4 added crashRun for POSIX systems thomask parents: 476 diff changeset	823 }
d091ff903fa4 added crashRun for POSIX systems thomask parents: 476 diff changeset	824
734 d4edcc124e64 added Torture capabilities thomask parents: 710 diff changeset	825 int target_compile(int modus, char* compiler, char* arguments, char* case_file,
d4edcc124e64 added Torture capabilities thomask parents: 710 diff changeset	826 char* error_file, char* error_line)
d4edcc124e64 added Torture capabilities thomask parents: 710 diff changeset	827 {
d4edcc124e64 added Torture capabilities thomask parents: 710 diff changeset	828 size_t bufferLen;
d4edcc124e64 added Torture capabilities thomask parents: 710 diff changeset	829 char* buffer;
d4edcc124e64 added Torture capabilities thomask parents: 710 diff changeset	830 int res;
d4edcc124e64 added Torture capabilities thomask parents: 710 diff changeset	831 int testResult;
d4edcc124e64 added Torture capabilities thomask parents: 710 diff changeset	832 int good_error;
d4edcc124e64 added Torture capabilities thomask parents: 710 diff changeset	833 char* logFile;
d4edcc124e64 added Torture capabilities thomask parents: 710 diff changeset	834
d4edcc124e64 added Torture capabilities thomask parents: 710 diff changeset	835 bufferLen = 0;
d4edcc124e64 added Torture capabilities thomask parents: 710 diff changeset	836 buffer = NULL;
d4edcc124e64 added Torture capabilities thomask parents: 710 diff changeset	837 res = -1;
d4edcc124e64 added Torture capabilities thomask parents: 710 diff changeset	838 testResult = -1;
d4edcc124e64 added Torture capabilities thomask parents: 710 diff changeset	839 good_error = 0;
d4edcc124e64 added Torture capabilities thomask parents: 710 diff changeset	840 logFile = NULL;
d4edcc124e64 added Torture capabilities thomask parents: 710 diff changeset	841
d4edcc124e64 added Torture capabilities thomask parents: 710 diff changeset	842 if(!(modus & MODE_COMPILE) && !(modus & MODE_NOCOMPILE)){
d4edcc124e64 added Torture capabilities thomask parents: 710 diff changeset	843 fprintf(stderr, "BUG: badly handled mode %i (->compile)\n",
d4edcc124e64 added Torture capabilities thomask parents: 710 diff changeset	844 modus);
d4edcc124e64 added Torture capabilities thomask parents: 710 diff changeset	845 exit(EXIT_FAILURE);
d4edcc124e64 added Torture capabilities thomask parents: 710 diff changeset	846 }
d4edcc124e64 added Torture capabilities thomask parents: 710 diff changeset	847
d4edcc124e64 added Torture capabilities thomask parents: 710 diff changeset	848 /* gen command */
971 8da09834526d * Valgrind support is now part of dstress.c instead of crashRun.c thomask parents: 968 diff changeset	849 bufferLen = strlen(compiler) + strlen(arguments) + strlen(tmp_dir)
734 d4edcc124e64 added Torture capabilities thomask parents: 710 diff changeset	850 + strlen(case_file) + 21;
1206 d88a87712de1 fixed dstress.c for C++ compilers thomask parents: 1003 diff changeset	851 buffer = (char*) malloc(bufferLen);
734 d4edcc124e64 added Torture capabilities thomask parents: 710 diff changeset	852 snprintf(buffer, bufferLen, "%s %s ", compiler, arguments);
d4edcc124e64 added Torture capabilities thomask parents: 710 diff changeset	853
d4edcc124e64 added Torture capabilities thomask parents: 710 diff changeset	854 if(NULL == strstr(buffer, "-od")){
d4edcc124e64 added Torture capabilities thomask parents: 710 diff changeset	855 snprintf(buffer, bufferLen, "%s %s -od%s -c %s",
971 8da09834526d * Valgrind support is now part of dstress.c instead of crashRun.c thomask parents: 968 diff changeset	856 compiler, arguments, tmp_dir, case_file);
734 d4edcc124e64 added Torture capabilities thomask parents: 710 diff changeset	857 }else{
d4edcc124e64 added Torture capabilities thomask parents: 710 diff changeset	858 snprintf(buffer, bufferLen, "%s %s -c %s",
d4edcc124e64 added Torture capabilities thomask parents: 710 diff changeset	859 compiler, arguments, case_file);
d4edcc124e64 added Torture capabilities thomask parents: 710 diff changeset	860 }
d4edcc124e64 added Torture capabilities thomask parents: 710 diff changeset	861
d4edcc124e64 added Torture capabilities thomask parents: 710 diff changeset	862 /* test */
d4edcc124e64 added Torture capabilities thomask parents: 710 diff changeset	863 if(modus & MODE_COMPILE){
902 58966fea59f7 preparing parallel build thomask parents: 888 diff changeset	864 printf("compile: %s\n", buffer);
734 d4edcc124e64 added Torture capabilities thomask parents: 710 diff changeset	865 }else{
902 58966fea59f7 preparing parallel build thomask parents: 888 diff changeset	866 printf("nocompile: %s\n", buffer);
734 d4edcc124e64 added Torture capabilities thomask parents: 710 diff changeset	867 }
d4edcc124e64 added Torture capabilities thomask parents: 710 diff changeset	868 res = crashRun(buffer, &logFile);
922 95160f4d06f8 minimized memory leaks in repeatedly called functions thomask parents: 904 diff changeset	869 free(buffer);
734 d4edcc124e64 added Torture capabilities thomask parents: 710 diff changeset	870
d4edcc124e64 added Torture capabilities thomask parents: 710 diff changeset	871 /* diagnostic */
902 58966fea59f7 preparing parallel build thomask parents: 888 diff changeset	872 buffer = loadFile(logFile, &bufferLen);
58966fea59f7 preparing parallel build thomask parents: 888 diff changeset	873 printf("%.*s\n", (int)bufferLen, buffer);
734 d4edcc124e64 added Torture capabilities thomask parents: 710 diff changeset	874 remove(logFile);
922 95160f4d06f8 minimized memory leaks in repeatedly called functions thomask parents: 904 diff changeset	875 free(logFile);
734 d4edcc124e64 added Torture capabilities thomask parents: 710 diff changeset	876 good_error = checkErrorMessage(error_file, error_line, buffer);
d4edcc124e64 added Torture capabilities thomask parents: 710 diff changeset	877
999 69f95c134121 added conditional result capabilities thomask parents: 998 diff changeset	878 testResult = conditionalResult(buffer);
69f95c134121 added conditional result capabilities thomask parents: 998 diff changeset	879
69f95c134121 added conditional result capabilities thomask parents: 998 diff changeset	880 if(testResult){
69f95c134121 added conditional result capabilities thomask parents: 998 diff changeset	881 /* conditional result */
69f95c134121 added conditional result capabilities thomask parents: 998 diff changeset	882 }else if(hadExecCrash(buffer)){
734 d4edcc124e64 added Torture capabilities thomask parents: 710 diff changeset	883 testResult = RES_ERROR;
d4edcc124e64 added Torture capabilities thomask parents: 710 diff changeset	884 }else if(modus & MODE_COMPILE){
d4edcc124e64 added Torture capabilities thomask parents: 710 diff changeset	885 if(res == EXIT_SUCCESS){
d4edcc124e64 added Torture capabilities thomask parents: 710 diff changeset	886 testResult = RES_PASS;
d4edcc124e64 added Torture capabilities thomask parents: 710 diff changeset	887 }else if(res == EXIT_FAILURE){
d4edcc124e64 added Torture capabilities thomask parents: 710 diff changeset	888 testResult = RES_FAIL \| (good_error ? 0 : RES_BAD_MSG);
d4edcc124e64 added Torture capabilities thomask parents: 710 diff changeset	889 }else{
d4edcc124e64 added Torture capabilities thomask parents: 710 diff changeset	890 testResult = RES_ERROR \| (good_error ? 0 : RES_BAD_MSG);
d4edcc124e64 added Torture capabilities thomask parents: 710 diff changeset	891 }
d4edcc124e64 added Torture capabilities thomask parents: 710 diff changeset	892 }else{
d4edcc124e64 added Torture capabilities thomask parents: 710 diff changeset	893 if(res == EXIT_FAILURE){
d4edcc124e64 added Torture capabilities thomask parents: 710 diff changeset	894 if(good_error){
d4edcc124e64 added Torture capabilities thomask parents: 710 diff changeset	895 testResult = RES_XFAIL;
d4edcc124e64 added Torture capabilities thomask parents: 710 diff changeset	896 }else{
d4edcc124e64 added Torture capabilities thomask parents: 710 diff changeset	897 testResult = RES_FAIL \| RES_BAD_MSG;
d4edcc124e64 added Torture capabilities thomask parents: 710 diff changeset	898 }
d4edcc124e64 added Torture capabilities thomask parents: 710 diff changeset	899 }else if(res == EXIT_SUCCESS){
d4edcc124e64 added Torture capabilities thomask parents: 710 diff changeset	900 testResult = RES_XPASS;
d4edcc124e64 added Torture capabilities thomask parents: 710 diff changeset	901 }else{
d4edcc124e64 added Torture capabilities thomask parents: 710 diff changeset	902 testResult = RES_ERROR;
d4edcc124e64 added Torture capabilities thomask parents: 710 diff changeset	903 }
d4edcc124e64 added Torture capabilities thomask parents: 710 diff changeset	904 }
d4edcc124e64 added Torture capabilities thomask parents: 710 diff changeset	905
922 95160f4d06f8 minimized memory leaks in repeatedly called functions thomask parents: 904 diff changeset	906 free(buffer);
95160f4d06f8 minimized memory leaks in repeatedly called functions thomask parents: 904 diff changeset	907
734 d4edcc124e64 added Torture capabilities thomask parents: 710 diff changeset	908 return testResult;
d4edcc124e64 added Torture capabilities thomask parents: 710 diff changeset	909 }
d4edcc124e64 added Torture capabilities thomask parents: 710 diff changeset	910
d4edcc124e64 added Torture capabilities thomask parents: 710 diff changeset	911 int target_run(int modus, char* compiler, char* arguments, char* case_file,
d4edcc124e64 added Torture capabilities thomask parents: 710 diff changeset	912 char* error_file, char* error_line
d4edcc124e64 added Torture capabilities thomask parents: 710 diff changeset	913 #ifdef REG_EXTENDED
d4edcc124e64 added Torture capabilities thomask parents: 710 diff changeset	914 , char* gdb, char* gdb_script, regex_t* gdb_pattern
d4edcc124e64 added Torture capabilities thomask parents: 710 diff changeset	915 #endif
d4edcc124e64 added Torture capabilities thomask parents: 710 diff changeset	916 )
d4edcc124e64 added Torture capabilities thomask parents: 710 diff changeset	917 {
d4edcc124e64 added Torture capabilities thomask parents: 710 diff changeset	918 size_t bufferLen;
d4edcc124e64 added Torture capabilities thomask parents: 710 diff changeset	919 char* buffer;
d4edcc124e64 added Torture capabilities thomask parents: 710 diff changeset	920 int res;
d4edcc124e64 added Torture capabilities thomask parents: 710 diff changeset	921 int testResult;
d4edcc124e64 added Torture capabilities thomask parents: 710 diff changeset	922 int good_error;
d4edcc124e64 added Torture capabilities thomask parents: 710 diff changeset	923 char* logFile;
d4edcc124e64 added Torture capabilities thomask parents: 710 diff changeset	924 char* gdb_scripter;
d4edcc124e64 added Torture capabilities thomask parents: 710 diff changeset	925 int good_gdb;
d4edcc124e64 added Torture capabilities thomask parents: 710 diff changeset	926
d4edcc124e64 added Torture capabilities thomask parents: 710 diff changeset	927 bufferLen = 0;
d4edcc124e64 added Torture capabilities thomask parents: 710 diff changeset	928 buffer = NULL;
d4edcc124e64 added Torture capabilities thomask parents: 710 diff changeset	929 res = -1;
d4edcc124e64 added Torture capabilities thomask parents: 710 diff changeset	930 testResult = -1;
d4edcc124e64 added Torture capabilities thomask parents: 710 diff changeset	931 good_error = 0;
d4edcc124e64 added Torture capabilities thomask parents: 710 diff changeset	932 logFile = NULL;
d4edcc124e64 added Torture capabilities thomask parents: 710 diff changeset	933 good_gdb = 0;
d4edcc124e64 added Torture capabilities thomask parents: 710 diff changeset	934 gdb_scripter = NULL;
d4edcc124e64 added Torture capabilities thomask parents: 710 diff changeset	935
d4edcc124e64 added Torture capabilities thomask parents: 710 diff changeset	936 if(!(modus & MODE_RUN) && !(modus & MODE_NORUN)){
d4edcc124e64 added Torture capabilities thomask parents: 710 diff changeset	937 fprintf(stderr, "BUG: badly handled mode %i (->run)\n", modus);
d4edcc124e64 added Torture capabilities thomask parents: 710 diff changeset	938 exit(EXIT_FAILURE);
d4edcc124e64 added Torture capabilities thomask parents: 710 diff changeset	939 }
746 0e3682dad93a fixed windows part of dstress.c thomask parents: 742 diff changeset	940
734 d4edcc124e64 added Torture capabilities thomask parents: 710 diff changeset	941 /* gen command */
d4edcc124e64 added Torture capabilities thomask parents: 710 diff changeset	942
971 8da09834526d * Valgrind support is now part of dstress.c instead of crashRun.c thomask parents: 968 diff changeset	943 bufferLen = strlen(compiler) + strlen(arguments) + strlen(tmp_dir)
734 d4edcc124e64 added Torture capabilities thomask parents: 710 diff changeset	944 + strlen(case_file) * 2 + 64;
1206 d88a87712de1 fixed dstress.c for C++ compilers thomask parents: 1003 diff changeset	945 buffer = (char*) malloc(bufferLen);
734 d4edcc124e64 added Torture capabilities thomask parents: 710 diff changeset	946 snprintf(buffer, bufferLen, "%s %s ", compiler, arguments);
d4edcc124e64 added Torture capabilities thomask parents: 710 diff changeset	947
d4edcc124e64 added Torture capabilities thomask parents: 710 diff changeset	948 if(NULL == strstr(buffer, "-od")){
d4edcc124e64 added Torture capabilities thomask parents: 710 diff changeset	949 if(NULL == strstr(buffer, "-of")){
d4edcc124e64 added Torture capabilities thomask parents: 710 diff changeset	950 snprintf(buffer, bufferLen,
d4edcc124e64 added Torture capabilities thomask parents: 710 diff changeset	951 "%s %s -od%s -of%s.exe %s",
971 8da09834526d * Valgrind support is now part of dstress.c instead of crashRun.c thomask parents: 968 diff changeset	952 compiler, arguments, tmp_dir, case_file,
734 d4edcc124e64 added Torture capabilities thomask parents: 710 diff changeset	953 case_file);
d4edcc124e64 added Torture capabilities thomask parents: 710 diff changeset	954 }else{
d4edcc124e64 added Torture capabilities thomask parents: 710 diff changeset	955 snprintf(buffer, bufferLen,
d4edcc124e64 added Torture capabilities thomask parents: 710 diff changeset	956 "%s %s -od%s %s",
971 8da09834526d * Valgrind support is now part of dstress.c instead of crashRun.c thomask parents: 968 diff changeset	957 compiler, arguments, tmp_dir, case_file);
734 d4edcc124e64 added Torture capabilities thomask parents: 710 diff changeset	958 }
d4edcc124e64 added Torture capabilities thomask parents: 710 diff changeset	959 }else if(NULL == strstr(buffer, "-of")){
d4edcc124e64 added Torture capabilities thomask parents: 710 diff changeset	960 snprintf(buffer, bufferLen,
d4edcc124e64 added Torture capabilities thomask parents: 710 diff changeset	961 "%s %s -of%s.exe %s",
d4edcc124e64 added Torture capabilities thomask parents: 710 diff changeset	962 compiler, arguments, case_file, case_file);
d4edcc124e64 added Torture capabilities thomask parents: 710 diff changeset	963 }else{
d4edcc124e64 added Torture capabilities thomask parents: 710 diff changeset	964 snprintf(buffer, bufferLen, "%s %s %s",
d4edcc124e64 added Torture capabilities thomask parents: 710 diff changeset	965 compiler, arguments, case_file);
d4edcc124e64 added Torture capabilities thomask parents: 710 diff changeset	966 }
d4edcc124e64 added Torture capabilities thomask parents: 710 diff changeset	967
d4edcc124e64 added Torture capabilities thomask parents: 710 diff changeset	968 /* test 1/3 - compile */
d4edcc124e64 added Torture capabilities thomask parents: 710 diff changeset	969 if(modus & MODE_RUN){
902 58966fea59f7 preparing parallel build thomask parents: 888 diff changeset	970 printf("run: %s\n", buffer);
734 d4edcc124e64 added Torture capabilities thomask parents: 710 diff changeset	971 }else{
902 58966fea59f7 preparing parallel build thomask parents: 888 diff changeset	972 printf("norun: %s\n", buffer);
734 d4edcc124e64 added Torture capabilities thomask parents: 710 diff changeset	973 }
d4edcc124e64 added Torture capabilities thomask parents: 710 diff changeset	974 res = crashRun(buffer, &logFile);
922 95160f4d06f8 minimized memory leaks in repeatedly called functions thomask parents: 904 diff changeset	975 free(buffer);
734 d4edcc124e64 added Torture capabilities thomask parents: 710 diff changeset	976
d4edcc124e64 added Torture capabilities thomask parents: 710 diff changeset	977 /* diagnostic 1/3 */
902 58966fea59f7 preparing parallel build thomask parents: 888 diff changeset	978 buffer = loadFile(logFile, &bufferLen);
58966fea59f7 preparing parallel build thomask parents: 888 diff changeset	979 printf("%.*s", (int)bufferLen, buffer);
734 d4edcc124e64 added Torture capabilities thomask parents: 710 diff changeset	980 remove(logFile);
922 95160f4d06f8 minimized memory leaks in repeatedly called functions thomask parents: 904 diff changeset	981 free(logFile);
746 0e3682dad93a fixed windows part of dstress.c thomask parents: 742 diff changeset	982
734 d4edcc124e64 added Torture capabilities thomask parents: 710 diff changeset	983 if(modus & MODE_RUN){
d4edcc124e64 added Torture capabilities thomask parents: 710 diff changeset	984 good_error = checkErrorMessage(error_file, error_line,
d4edcc124e64 added Torture capabilities thomask parents: 710 diff changeset	985 buffer);
d4edcc124e64 added Torture capabilities thomask parents: 710 diff changeset	986 }else{
d4edcc124e64 added Torture capabilities thomask parents: 710 diff changeset	987 good_error = 1;
d4edcc124e64 added Torture capabilities thomask parents: 710 diff changeset	988 }
d4edcc124e64 added Torture capabilities thomask parents: 710 diff changeset	989
999 69f95c134121 added conditional result capabilities thomask parents: 998 diff changeset	990 testResult = conditionalResult(buffer);
734 d4edcc124e64 added Torture capabilities thomask parents: 710 diff changeset	991 if(hadExecCrash(buffer)){
922 95160f4d06f8 minimized memory leaks in repeatedly called functions thomask parents: 904 diff changeset	992 free(buffer);
734 d4edcc124e64 added Torture capabilities thomask parents: 710 diff changeset	993 return RES_ERROR;
922 95160f4d06f8 minimized memory leaks in repeatedly called functions thomask parents: 904 diff changeset	994 }else{
95160f4d06f8 minimized memory leaks in repeatedly called functions thomask parents: 904 diff changeset	995 free(buffer);
999 69f95c134121 added conditional result capabilities thomask parents: 998 diff changeset	996 if(testResult){
69f95c134121 added conditional result capabilities thomask parents: 998 diff changeset	997 return testResult;
69f95c134121 added conditional result capabilities thomask parents: 998 diff changeset	998 }else if((res == EXIT_FAILURE) && good_error){
922 95160f4d06f8 minimized memory leaks in repeatedly called functions thomask parents: 904 diff changeset	999 return RES_FAIL;
95160f4d06f8 minimized memory leaks in repeatedly called functions thomask parents: 904 diff changeset	1000 }else if(res!=EXIT_SUCCESS){
95160f4d06f8 minimized memory leaks in repeatedly called functions thomask parents: 904 diff changeset	1001 return RES_ERROR \| (good_error ? 0 : RES_BAD_MSG);
95160f4d06f8 minimized memory leaks in repeatedly called functions thomask parents: 904 diff changeset	1002 }
734 d4edcc124e64 added Torture capabilities thomask parents: 710 diff changeset	1003 }
d4edcc124e64 added Torture capabilities thomask parents: 710 diff changeset	1004
d4edcc124e64 added Torture capabilities thomask parents: 710 diff changeset	1005 /* test 2/3 - run */
985 d3038d8cb01c by-pass for Valgrind bugs thomask parents: 981 diff changeset	1006 if((modus & MODE_NORUN) && (strstr(case_file, "/asm_")
991 fc296bd82895 fixed Valgrind exclusion bug thomask parents: 986 diff changeset	1007 \|\| strstr(case_file, "\\asm_")
fc296bd82895 fixed Valgrind exclusion bug thomask parents: 986 diff changeset	1008 \|\| (case_file == strstr(case_file, "asm_"))))
985 d3038d8cb01c by-pass for Valgrind bugs thomask parents: 981 diff changeset	1009 {
d3038d8cb01c by-pass for Valgrind bugs thomask parents: 981 diff changeset	1010 /* Valgrind doesn't support privileged instructions */
d3038d8cb01c by-pass for Valgrind bugs thomask parents: 981 diff changeset	1011 goto no_valgrind;
991 fc296bd82895 fixed Valgrind exclusion bug thomask parents: 986 diff changeset	1012 }else if(strstr(case_file, "/asm_") \|\| strstr(case_file, "\\asm_")
fc296bd82895 fixed Valgrind exclusion bug thomask parents: 986 diff changeset	1013 \|\| (case_file == strstr(case_file, "asm_")))
fc296bd82895 fixed Valgrind exclusion bug thomask parents: 986 diff changeset	1014 {
985 d3038d8cb01c by-pass for Valgrind bugs thomask parents: 981 diff changeset	1015 /* FIXME asm workaround due to Valgrind bugs (mainly SSE3) */
d3038d8cb01c by-pass for Valgrind bugs thomask parents: 981 diff changeset	1016 goto no_valgrind;
991 fc296bd82895 fixed Valgrind exclusion bug thomask parents: 986 diff changeset	1017 }else if(VALGRIND){
971 8da09834526d * Valgrind support is now part of dstress.c instead of crashRun.c thomask parents: 968 diff changeset	1018 bufferLen = strlen(VALGRIND) + strlen(case_file) + 8;
1206 d88a87712de1 fixed dstress.c for C++ compilers thomask parents: 1003 diff changeset	1019 buffer = (char*) malloc(bufferLen);
971 8da09834526d * Valgrind support is now part of dstress.c instead of crashRun.c thomask parents: 968 diff changeset	1020 snprintf(buffer, bufferLen, "%s %s.exe", VALGRIND, case_file);
8da09834526d * Valgrind support is now part of dstress.c instead of crashRun.c thomask parents: 968 diff changeset	1021 }else{
985 d3038d8cb01c by-pass for Valgrind bugs thomask parents: 981 diff changeset	1022 no_valgrind:
971 8da09834526d * Valgrind support is now part of dstress.c instead of crashRun.c thomask parents: 968 diff changeset	1023 bufferLen = strlen(case_file) + 8;
1206 d88a87712de1 fixed dstress.c for C++ compilers thomask parents: 1003 diff changeset	1024 buffer = (char*) malloc(bufferLen);
971 8da09834526d * Valgrind support is now part of dstress.c instead of crashRun.c thomask parents: 968 diff changeset	1025 snprintf(buffer, bufferLen, "%s.exe", case_file);
8da09834526d * Valgrind support is now part of dstress.c instead of crashRun.c thomask parents: 968 diff changeset	1026 }
902 58966fea59f7 preparing parallel build thomask parents: 888 diff changeset	1027 printf("%s\n", buffer);
734 d4edcc124e64 added Torture capabilities thomask parents: 710 diff changeset	1028 res=crashRun(buffer, &logFile);
999 69f95c134121 added conditional result capabilities thomask parents: 998 diff changeset	1029 testResult = conditionalResult(buffer);
69f95c134121 added conditional result capabilities thomask parents: 998 diff changeset	1030 if(testResult){
69f95c134121 added conditional result capabilities thomask parents: 998 diff changeset	1031 free(buffer);
69f95c134121 added conditional result capabilities thomask parents: 998 diff changeset	1032 return testResult;
69f95c134121 added conditional result capabilities thomask parents: 998 diff changeset	1033 }
922 95160f4d06f8 minimized memory leaks in repeatedly called functions thomask parents: 904 diff changeset	1034 free(buffer);
734 d4edcc124e64 added Torture capabilities thomask parents: 710 diff changeset	1035
d4edcc124e64 added Torture capabilities thomask parents: 710 diff changeset	1036 /* diagnostic 2/3 */
902 58966fea59f7 preparing parallel build thomask parents: 888 diff changeset	1037 buffer = loadFile(logFile, &bufferLen);
58966fea59f7 preparing parallel build thomask parents: 888 diff changeset	1038 printf("%.*s\n", (int) bufferLen, buffer);
734 d4edcc124e64 added Torture capabilities thomask parents: 710 diff changeset	1039 remove(logFile);
922 95160f4d06f8 minimized memory leaks in repeatedly called functions thomask parents: 904 diff changeset	1040 free(logFile);
734 d4edcc124e64 added Torture capabilities thomask parents: 710 diff changeset	1041
d4edcc124e64 added Torture capabilities thomask parents: 710 diff changeset	1042 if(modus & MODE_NORUN){
d4edcc124e64 added Torture capabilities thomask parents: 710 diff changeset	1043 good_error = checkRuntimeErrorMessage(error_file, error_line,
d4edcc124e64 added Torture capabilities thomask parents: 710 diff changeset	1044 buffer);
d4edcc124e64 added Torture capabilities thomask parents: 710 diff changeset	1045 }else{
d4edcc124e64 added Torture capabilities thomask parents: 710 diff changeset	1046 good_error = 1;
d4edcc124e64 added Torture capabilities thomask parents: 710 diff changeset	1047 }
d4edcc124e64 added Torture capabilities thomask parents: 710 diff changeset	1048
d4edcc124e64 added Torture capabilities thomask parents: 710 diff changeset	1049 #ifdef REG_EXTENDED
968 8b6d2dcf9954 * fixed new line escapes in GDB_SCRIPT thomask parents: 959 diff changeset	1050 if(((res==EXIT_SUCCESS && (modus & MODE_RUN))
1003 ab5680607b8d fixed GDB-Valgrind interaction thomask parents: 999 diff changeset	1051 \|\|(res != EXIT_FAILURE && (modus & MODE_NORUN)))
968 8b6d2dcf9954 * fixed new line escapes in GDB_SCRIPT thomask parents: 959 diff changeset	1052 && gdb_script != NULL)
8b6d2dcf9954 * fixed new line escapes in GDB_SCRIPT thomask parents: 959 diff changeset	1053 {
999 69f95c134121 added conditional result capabilities thomask parents: 998 diff changeset	1054 testResult = conditionalResult(buffer);
69f95c134121 added conditional result capabilities thomask parents: 998 diff changeset	1055 if(testResult){
69f95c134121 added conditional result capabilities thomask parents: 998 diff changeset	1056 return testResult;
69f95c134121 added conditional result capabilities thomask parents: 998 diff changeset	1057 }
69f95c134121 added conditional result capabilities thomask parents: 998 diff changeset	1058
922 95160f4d06f8 minimized memory leaks in repeatedly called functions thomask parents: 904 diff changeset	1059 free(buffer);
734 d4edcc124e64 added Torture capabilities thomask parents: 710 diff changeset	1060 good_gdb = 0;
d4edcc124e64 added Torture capabilities thomask parents: 710 diff changeset	1061 /* test 3/3 - gdb */
d4edcc124e64 added Torture capabilities thomask parents: 710 diff changeset	1062 gdb_scripter = genTempFileName();
d4edcc124e64 added Torture capabilities thomask parents: 710 diff changeset	1063 writeFile(gdb_scripter, gdb_script);
d4edcc124e64 added Torture capabilities thomask parents: 710 diff changeset	1064 bufferLen = strlen(gdb) + strlen(case_file)
d4edcc124e64 added Torture capabilities thomask parents: 710 diff changeset	1065 + strlen(gdb_scripter) + 20;
1206 d88a87712de1 fixed dstress.c for C++ compilers thomask parents: 1003 diff changeset	1066 buffer = (char*) malloc(bufferLen);
734 d4edcc124e64 added Torture capabilities thomask parents: 710 diff changeset	1067 snprintf(buffer, bufferLen, "%s %s.exe < %s",
d4edcc124e64 added Torture capabilities thomask parents: 710 diff changeset	1068 gdb, case_file, gdb_scripter);
902 58966fea59f7 preparing parallel build thomask parents: 888 diff changeset	1069 printf("%s\n", buffer);
734 d4edcc124e64 added Torture capabilities thomask parents: 710 diff changeset	1070 if(EXIT_SUCCESS==crashRun(buffer, &logFile)){
d4edcc124e64 added Torture capabilities thomask parents: 710 diff changeset	1071 /* diagnostic 3/3 */
902 58966fea59f7 preparing parallel build thomask parents: 888 diff changeset	1072 buffer = loadFile(logFile, &bufferLen);
58966fea59f7 preparing parallel build thomask parents: 888 diff changeset	1073 printf("%.*s\n", (int)bufferLen, buffer);
734 d4edcc124e64 added Torture capabilities thomask parents: 710 diff changeset	1074 good_gdb = (regexec(gdb_pattern, buffer, 0, NULL, 0)==0);
d4edcc124e64 added Torture capabilities thomask parents: 710 diff changeset	1075 }
d4edcc124e64 added Torture capabilities thomask parents: 710 diff changeset	1076 remove(logFile);
d4edcc124e64 added Torture capabilities thomask parents: 710 diff changeset	1077 remove(gdb_scripter);
d4edcc124e64 added Torture capabilities thomask parents: 710 diff changeset	1078 }else{
d4edcc124e64 added Torture capabilities thomask parents: 710 diff changeset	1079 good_gdb = 1;
d4edcc124e64 added Torture capabilities thomask parents: 710 diff changeset	1080 }
746 0e3682dad93a fixed windows part of dstress.c thomask parents: 742 diff changeset	1081 #else
0e3682dad93a fixed windows part of dstress.c thomask parents: 742 diff changeset	1082 good_gdb = 1;
902 58966fea59f7 preparing parallel build thomask parents: 888 diff changeset	1083 #endif /* REG_EXTENDED else */
734 d4edcc124e64 added Torture capabilities thomask parents: 710 diff changeset	1084
999 69f95c134121 added conditional result capabilities thomask parents: 998 diff changeset	1085 testResult = conditionalResult(buffer);
69f95c134121 added conditional result capabilities thomask parents: 998 diff changeset	1086 if(testResult){
69f95c134121 added conditional result capabilities thomask parents: 998 diff changeset	1087 return testResult;
69f95c134121 added conditional result capabilities thomask parents: 998 diff changeset	1088 }
69f95c134121 added conditional result capabilities thomask parents: 998 diff changeset	1089
734 d4edcc124e64 added Torture capabilities thomask parents: 710 diff changeset	1090 if(modus & MODE_RUN){
d4edcc124e64 added Torture capabilities thomask parents: 710 diff changeset	1091 if(hadExecCrash(buffer)){
746 0e3682dad93a fixed windows part of dstress.c thomask parents: 742 diff changeset	1092 testResult = RES_ERROR;
734 d4edcc124e64 added Torture capabilities thomask parents: 710 diff changeset	1093 }else if((res==EXIT_SUCCESS) && good_gdb){
d4edcc124e64 added Torture capabilities thomask parents: 710 diff changeset	1094 testResult = RES_PASS;
d4edcc124e64 added Torture capabilities thomask parents: 710 diff changeset	1095 }else if((res==EXIT_FAILURE) && good_error && good_gdb){
d4edcc124e64 added Torture capabilities thomask parents: 710 diff changeset	1096 testResult = RES_FAIL;
d4edcc124e64 added Torture capabilities thomask parents: 710 diff changeset	1097 }else{
d4edcc124e64 added Torture capabilities thomask parents: 710 diff changeset	1098 testResult = RES_ERROR \| (good_error ? 0 : RES_BAD_MSG)
d4edcc124e64 added Torture capabilities thomask parents: 710 diff changeset	1099 \| (good_gdb ? 0 : RES_BAD_GDB);
d4edcc124e64 added Torture capabilities thomask parents: 710 diff changeset	1100 }
d4edcc124e64 added Torture capabilities thomask parents: 710 diff changeset	1101 }else{
d4edcc124e64 added Torture capabilities thomask parents: 710 diff changeset	1102 if(res==EXIT_SUCCESS){
d4edcc124e64 added Torture capabilities thomask parents: 710 diff changeset	1103 testResult = RES_XPASS;
d4edcc124e64 added Torture capabilities thomask parents: 710 diff changeset	1104 }else if(good_error && good_gdb){
d4edcc124e64 added Torture capabilities thomask parents: 710 diff changeset	1105 testResult = RES_XFAIL;
d4edcc124e64 added Torture capabilities thomask parents: 710 diff changeset	1106 }else{
d4edcc124e64 added Torture capabilities thomask parents: 710 diff changeset	1107 testResult = RES_FAIL \| (good_error ? 0 : RES_BAD_MSG)
d4edcc124e64 added Torture capabilities thomask parents: 710 diff changeset	1108 \| (good_gdb ? 0 : RES_BAD_GDB);
d4edcc124e64 added Torture capabilities thomask parents: 710 diff changeset	1109 }
d4edcc124e64 added Torture capabilities thomask parents: 710 diff changeset	1110 }
922 95160f4d06f8 minimized memory leaks in repeatedly called functions thomask parents: 904 diff changeset	1111 free(buffer);
734 d4edcc124e64 added Torture capabilities thomask parents: 710 diff changeset	1112
d4edcc124e64 added Torture capabilities thomask parents: 710 diff changeset	1113 return testResult;
d4edcc124e64 added Torture capabilities thomask parents: 710 diff changeset	1114 }
254 a39162afcc94 MSWindows port of "dstress.c" thomask parents: 251 diff changeset	1115
251 6cd84461e17b enabled new "dstress.c" test tool thomask parents: diff changeset	1116 int main(int argc, char* arg[]){
746 0e3682dad93a fixed windows part of dstress.c thomask parents: 742 diff changeset	1117
438 27039d5cbe81 partial cleanup for Windows(dmc) thomask parents: 437 diff changeset	1118 char* compiler; /* the compiler - from enviroment flag "DMD" */
339 a74c84e75682 added error line tests (__DSTRESS_ELINE__ / __DSTRESS_EFILE__) thomask parents: 292 diff changeset	1119 char* cmd_arg_case; /* additional arguments - from the testcase file */
620 03ad4005cd8e POSIX only: added __GDB_SCRIPT__ and __GDB__PATTERN__ support thomask parents: 499 diff changeset	1120 char* buffer; /* general purpose buffer */
685 4f97e51515d8 ported dstress.c to OpenBsd thomask parents: 681 diff changeset	1121 size_t bufferLen;
734 d4edcc124e64 added Torture capabilities thomask parents: 710 diff changeset	1122 int index;
438 27039d5cbe81 partial cleanup for Windows(dmc) thomask parents: 437 diff changeset	1123 int modus; /* test modus: RUN NORUN COMPILE NOCOMPILE */
27039d5cbe81 partial cleanup for Windows(dmc) thomask parents: 437 diff changeset	1124 char* case_file;
734 d4edcc124e64 added Torture capabilities thomask parents: 710 diff changeset	1125 int case_result;
d4edcc124e64 added Torture capabilities thomask parents: 710 diff changeset	1126 int torture_result[sizeof(torture)/sizeof(char*)];
d4edcc124e64 added Torture capabilities thomask parents: 710 diff changeset	1127 char* torture_block_global;
d4edcc124e64 added Torture capabilities thomask parents: 710 diff changeset	1128 char* torture_block_case;
d4edcc124e64 added Torture capabilities thomask parents: 710 diff changeset	1129 char* torture_require;
339 a74c84e75682 added error line tests (__DSTRESS_ELINE__ / __DSTRESS_EFILE__) thomask parents: 292 diff changeset	1130 char* error_file; /* expected sourcefile containing the error */
a74c84e75682 added error line tests (__DSTRESS_ELINE__ / __DSTRESS_EFILE__) thomask parents: 292 diff changeset	1131 char* error_line; /* expected error line */
620 03ad4005cd8e POSIX only: added __GDB_SCRIPT__ and __GDB__PATTERN__ support thomask parents: 499 diff changeset	1132 char* gdb; /* the debugger - from environment flag "GDB" */
03ad4005cd8e POSIX only: added __GDB_SCRIPT__ and __GDB__PATTERN__ support thomask parents: 499 diff changeset	1133 char* gdb_script; /* gdb command sequence */
03ad4005cd8e POSIX only: added __GDB_SCRIPT__ and __GDB__PATTERN__ support thomask parents: 499 diff changeset	1134 char* gdb_pattern_raw; /* POSIX regexp expected in GDB's output */
03ad4005cd8e POSIX only: added __GDB_SCRIPT__ and __GDB__PATTERN__ support thomask parents: 499 diff changeset	1135 #ifdef REG_EXTENDED
03ad4005cd8e POSIX only: added __GDB_SCRIPT__ and __GDB__PATTERN__ support thomask parents: 499 diff changeset	1136 regex_t* gdb_pattern;
03ad4005cd8e POSIX only: added __GDB_SCRIPT__ and __GDB__PATTERN__ support thomask parents: 499 diff changeset	1137 #endif
438 27039d5cbe81 partial cleanup for Windows(dmc) thomask parents: 437 diff changeset	1138
697 fbee62becd2c partial repos review thomask parents: 693 diff changeset	1139 compiler = NULL;
fbee62becd2c partial repos review thomask parents: 693 diff changeset	1140 cmd_arg_case = NULL;
fbee62becd2c partial repos review thomask parents: 693 diff changeset	1141 buffer = NULL;
fbee62becd2c partial repos review thomask parents: 693 diff changeset	1142 bufferLen = 0;
fbee62becd2c partial repos review thomask parents: 693 diff changeset	1143 modus = -1;
fbee62becd2c partial repos review thomask parents: 693 diff changeset	1144 case_file = NULL;
734 d4edcc124e64 added Torture capabilities thomask parents: 710 diff changeset	1145 torture_block_global = NULL;
d4edcc124e64 added Torture capabilities thomask parents: 710 diff changeset	1146 torture_block_case = NULL;
d4edcc124e64 added Torture capabilities thomask parents: 710 diff changeset	1147 torture_require = NULL;
697 fbee62becd2c partial repos review thomask parents: 693 diff changeset	1148 error_file = NULL;
fbee62becd2c partial repos review thomask parents: 693 diff changeset	1149 error_line = NULL;
fbee62becd2c partial repos review thomask parents: 693 diff changeset	1150 gdb = NULL;
fbee62becd2c partial repos review thomask parents: 693 diff changeset	1151 gdb_script = NULL;
fbee62becd2c partial repos review thomask parents: 693 diff changeset	1152 gdb_pattern_raw = NULL;
fbee62becd2c partial repos review thomask parents: 693 diff changeset	1153 #ifdef REG_EXTENDED
fbee62becd2c partial repos review thomask parents: 693 diff changeset	1154 gdb_pattern = NULL;
fbee62becd2c partial repos review thomask parents: 693 diff changeset	1155 #endif
fbee62becd2c partial repos review thomask parents: 693 diff changeset	1156
251 6cd84461e17b enabled new "dstress.c" test tool thomask parents: diff changeset	1157 /* check arguments */
6cd84461e17b enabled new "dstress.c" test tool thomask parents: diff changeset	1158 if(argc != 3){
438 27039d5cbe81 partial cleanup for Windows(dmc) thomask parents: 437 diff changeset	1159 err:
902 58966fea59f7 preparing parallel build thomask parents: 888 diff changeset	1160 fprintf(stderr, "DStress test executer (revision 1083)\n"
58966fea59f7 preparing parallel build thomask parents: 888 diff changeset	1161 "Copyright by Thomas Kuehne <thomas@kuehne.cn> 2005, 2006\n"
704 3e690f0d2cbf documentation maintenance for dstress.c thomask parents: 703 diff changeset	1162 "\n");
3e690f0d2cbf documentation maintenance for dstress.c thomask parents: 703 diff changeset	1163
734 d4edcc124e64 added Torture capabilities thomask parents: 710 diff changeset	1164 if(argc!=0){
704 3e690f0d2cbf documentation maintenance for dstress.c thomask parents: 703 diff changeset	1165 fprintf(stderr,
3e690f0d2cbf documentation maintenance for dstress.c thomask parents: 703 diff changeset	1166 "%s <run\|norun\|compile\|nocompile> <source>\n",
3e690f0d2cbf documentation maintenance for dstress.c thomask parents: 703 diff changeset	1167 arg[0]);
734 d4edcc124e64 added Torture capabilities thomask parents: 710 diff changeset	1168 }else{
704 3e690f0d2cbf documentation maintenance for dstress.c thomask parents: 703 diff changeset	1169 fprintf(stderr,
3e690f0d2cbf documentation maintenance for dstress.c thomask parents: 703 diff changeset	1170 "dstress <run\|norun\|compile\|nocompile>"
3e690f0d2cbf documentation maintenance for dstress.c thomask parents: 703 diff changeset	1171 " <source>\n");
734 d4edcc124e64 added Torture capabilities thomask parents: 710 diff changeset	1172 }
704 3e690f0d2cbf documentation maintenance for dstress.c thomask parents: 703 diff changeset	1173
734 d4edcc124e64 added Torture capabilities thomask parents: 710 diff changeset	1174 fprintf(stderr, "\n"
704 3e690f0d2cbf documentation maintenance for dstress.c thomask parents: 703 diff changeset	1175 "== eniroment settings (usually $NAME or %%NAME%%) ==\n"
3e690f0d2cbf documentation maintenance for dstress.c thomask parents: 703 diff changeset	1176 "* DMD - compiler (including standard arguments)\n"
734 d4edcc124e64 added Torture capabilities thomask parents: 710 diff changeset	1177 "* GDB - debugger (including standard arguments)\n");
d4edcc124e64 added Torture capabilities thomask parents: 710 diff changeset	1178 fprintf(stderr, "\n"
704 3e690f0d2cbf documentation maintenance for dstress.c thomask parents: 703 diff changeset	1179 "== case setting (line in the case source) ==\n"
3e690f0d2cbf documentation maintenance for dstress.c thomask parents: 703 diff changeset	1180 "* __DSTRESS_DFLAGS__ - additional compiler arguments\n"
3e690f0d2cbf documentation maintenance for dstress.c thomask parents: 703 diff changeset	1181 "only evaluated if it is a \"nocompile\" or \"norun\" test:\n"
3e690f0d2cbf documentation maintenance for dstress.c thomask parents: 703 diff changeset	1182 "* __DSTRESS_ELINE__ - expected source line to throw an error message\n"
3e690f0d2cbf documentation maintenance for dstress.c thomask parents: 703 diff changeset	1183 "* __DSTRESS_EFILE__ - expected source file to throw an error message\n"
734 d4edcc124e64 added Torture capabilities thomask parents: 710 diff changeset	1184 " (defaults to the case file)\n");
d4edcc124e64 added Torture capabilities thomask parents: 710 diff changeset	1185 fprintf(stderr,
704 3e690f0d2cbf documentation maintenance for dstress.c thomask parents: 703 diff changeset	1186 "only evaluated if it is a \"run\" or \"norun\" test:\n"
3e690f0d2cbf documentation maintenance for dstress.c thomask parents: 703 diff changeset	1187 "* __GDB_SCRIPT__ - command sequence to feed to the debugger\n"
3e690f0d2cbf documentation maintenance for dstress.c thomask parents: 703 diff changeset	1188 " (use \\n to encode a line break)\n"
3e690f0d2cbf documentation maintenance for dstress.c thomask parents: 703 diff changeset	1189 "* __GDB_PATTERN__ - expected regular expression in the debugger's\n"
734 d4edcc124e64 added Torture capabilities thomask parents: 710 diff changeset	1190 " output\n");
d4edcc124e64 added Torture capabilities thomask parents: 710 diff changeset	1191 fprintf(stderr, "\n"
704 3e690f0d2cbf documentation maintenance for dstress.c thomask parents: 703 diff changeset	1192 "== note ==\n"
710 8cba64b24615 fixed typo thomask parents: 707 diff changeset	1193 "* the current directory is required to contain the sub-directory \"obj\"\n"
704 3e690f0d2cbf documentation maintenance for dstress.c thomask parents: 703 diff changeset	1194 " (used for temporary files)\n"
3e690f0d2cbf documentation maintenance for dstress.c thomask parents: 703 diff changeset	1195 );
438 27039d5cbe81 partial cleanup for Windows(dmc) thomask parents: 437 diff changeset	1196 exit(EXIT_FAILURE);
251 6cd84461e17b enabled new "dstress.c" test tool thomask parents: diff changeset	1197 }
438 27039d5cbe81 partial cleanup for Windows(dmc) thomask parents: 437 diff changeset	1198
734 d4edcc124e64 added Torture capabilities thomask parents: 710 diff changeset	1199 modus = 0;
d4edcc124e64 added Torture capabilities thomask parents: 710 diff changeset	1200 if(0==strncmp(arg[1], TORTURE_PREFIX, strlen(TORTURE_PREFIX))){
d4edcc124e64 added Torture capabilities thomask parents: 710 diff changeset	1201 modus \|= MODE_TORTURE;
d4edcc124e64 added Torture capabilities thomask parents: 710 diff changeset	1202 arg[1] += strlen(TORTURE_PREFIX);
d4edcc124e64 added Torture capabilities thomask parents: 710 diff changeset	1203 }
704 3e690f0d2cbf documentation maintenance for dstress.c thomask parents: 703 diff changeset	1204 if(0==strcmp(arg[1], "run")){
734 d4edcc124e64 added Torture capabilities thomask parents: 710 diff changeset	1205 modus \|= MODE_RUN;
704 3e690f0d2cbf documentation maintenance for dstress.c thomask parents: 703 diff changeset	1206 }else if(0==strcmp(arg[1], "norun")){
734 d4edcc124e64 added Torture capabilities thomask parents: 710 diff changeset	1207 modus \|= MODE_NORUN;
704 3e690f0d2cbf documentation maintenance for dstress.c thomask parents: 703 diff changeset	1208 }else if(0==strcmp(arg[1], "compile")){
734 d4edcc124e64 added Torture capabilities thomask parents: 710 diff changeset	1209 modus \|= MODE_COMPILE;
704 3e690f0d2cbf documentation maintenance for dstress.c thomask parents: 703 diff changeset	1210 }else if(0==strcmp(arg[1], "nocompile")){
734 d4edcc124e64 added Torture capabilities thomask parents: 710 diff changeset	1211 modus \|= MODE_NOCOMPILE;
251 6cd84461e17b enabled new "dstress.c" test tool thomask parents: diff changeset	1212 }else{
6cd84461e17b enabled new "dstress.c" test tool thomask parents: diff changeset	1213 goto err;
6cd84461e17b enabled new "dstress.c" test tool thomask parents: diff changeset	1214 }
6cd84461e17b enabled new "dstress.c" test tool thomask parents: diff changeset	1215
6cd84461e17b enabled new "dstress.c" test tool thomask parents: diff changeset	1216 /* gen flags */
902 58966fea59f7 preparing parallel build thomask parents: 888 diff changeset	1217 case_file = cleanPathSeperator(arg[2]);
251 6cd84461e17b enabled new "dstress.c" test tool thomask parents: diff changeset	1218 compiler = getCompiler();
620 03ad4005cd8e POSIX only: added __GDB_SCRIPT__ and __GDB__PATTERN__ support thomask parents: 499 diff changeset	1219 gdb = getGDB();
734 d4edcc124e64 added Torture capabilities thomask parents: 710 diff changeset	1220 torture_block_global = getTortureBlock();
902 58966fea59f7 preparing parallel build thomask parents: 888 diff changeset	1221 buffer = loadFile(case_file, &bufferLen);
58966fea59f7 preparing parallel build thomask parents: 888 diff changeset	1222 bufferLen = 0;
438 27039d5cbe81 partial cleanup for Windows(dmc) thomask parents: 437 diff changeset	1223
968 8b6d2dcf9954 * fixed new line escapes in GDB_SCRIPT thomask parents: 959 diff changeset	1224 cmd_arg_case = cleanPathSeperator(getCaseFlag(buffer, "__DSTRESS_DFLAGS__"));
339 a74c84e75682 added error line tests (__DSTRESS_ELINE__ / __DSTRESS_EFILE__) thomask parents: 292 diff changeset	1225 error_line = getCaseFlag(buffer, "__DSTRESS_ELINE__");
968 8b6d2dcf9954 * fixed new line escapes in GDB_SCRIPT thomask parents: 959 diff changeset	1226 error_file = cleanPathSeperator(getCaseFlag(buffer, "__DSTRESS_EFILE__"));
620 03ad4005cd8e POSIX only: added __GDB_SCRIPT__ and __GDB__PATTERN__ support thomask parents: 499 diff changeset	1227 gdb_script = getCaseFlag(buffer, "__GDB_SCRIPT__");
03ad4005cd8e POSIX only: added __GDB_SCRIPT__ and __GDB__PATTERN__ support thomask parents: 499 diff changeset	1228 gdb_pattern_raw = getCaseFlag(buffer, "__GDB_PATTERN__");
734 d4edcc124e64 added Torture capabilities thomask parents: 710 diff changeset	1229 torture_block_case = getCaseFlag(buffer, "__DSTRESS_TORTURE_BLOCK__");
d4edcc124e64 added Torture capabilities thomask parents: 710 diff changeset	1230 torture_require = getCaseFlag(buffer, "__DSTRESS_TORTURE_REQUIRE__");
620 03ad4005cd8e POSIX only: added __GDB_SCRIPT__ and __GDB__PATTERN__ support thomask parents: 499 diff changeset	1231
922 95160f4d06f8 minimized memory leaks in repeatedly called functions thomask parents: 904 diff changeset	1232 free(buffer);
95160f4d06f8 minimized memory leaks in repeatedly called functions thomask parents: 904 diff changeset	1233
971 8da09834526d * Valgrind support is now part of dstress.c instead of crashRun.c thomask parents: 968 diff changeset	1234 /* tmp_dir */
8da09834526d * Valgrind support is now part of dstress.c instead of crashRun.c thomask parents: 968 diff changeset	1235 if(!cmd_arg_case \|\| !cmd_arg_case[0]){
8da09834526d * Valgrind support is now part of dstress.c instead of crashRun.c thomask parents: 968 diff changeset	1236 tmp_dir = TMP_DIR;
8da09834526d * Valgrind support is now part of dstress.c instead of crashRun.c thomask parents: 968 diff changeset	1237 }else{
8da09834526d * Valgrind support is now part of dstress.c instead of crashRun.c thomask parents: 968 diff changeset	1238 pid_t pid;
8da09834526d * Valgrind support is now part of dstress.c instead of crashRun.c thomask parents: 968 diff changeset	1239 pid = getpid();
8da09834526d * Valgrind support is now part of dstress.c instead of crashRun.c thomask parents: 968 diff changeset	1240 bufferLen = strlen(TMP_DIR) + 4 + sizeof(pid_t) * 4;
1206 d88a87712de1 fixed dstress.c for C++ compilers thomask parents: 1003 diff changeset	1241 buffer = (char*) malloc(bufferLen);
971 8da09834526d * Valgrind support is now part of dstress.c instead of crashRun.c thomask parents: 968 diff changeset	1242 snprintf(buffer, bufferLen, "%s/_%X", TMP_DIR, pid);
8da09834526d * Valgrind support is now part of dstress.c instead of crashRun.c thomask parents: 968 diff changeset	1243 tmp_dir = cleanPathSeperator(buffer);
8da09834526d * Valgrind support is now part of dstress.c instead of crashRun.c thomask parents: 968 diff changeset	1244 if(mkdir(tmp_dir, 0770)){
8da09834526d * Valgrind support is now part of dstress.c instead of crashRun.c thomask parents: 968 diff changeset	1245 fprintf(stderr, "failed to create tmp dir: %s (%d, %s)\n",
8da09834526d * Valgrind support is now part of dstress.c instead of crashRun.c thomask parents: 968 diff changeset	1246 tmp_dir, errno, strerror(errno));
8da09834526d * Valgrind support is now part of dstress.c instead of crashRun.c thomask parents: 968 diff changeset	1247 return EXIT_FAILURE;
8da09834526d * Valgrind support is now part of dstress.c instead of crashRun.c thomask parents: 968 diff changeset	1248 }
8da09834526d * Valgrind support is now part of dstress.c instead of crashRun.c thomask parents: 968 diff changeset	1249 }
8da09834526d * Valgrind support is now part of dstress.c instead of crashRun.c thomask parents: 968 diff changeset	1250
620 03ad4005cd8e POSIX only: added __GDB_SCRIPT__ and __GDB__PATTERN__ support thomask parents: 499 diff changeset	1251 /* set implicit source file */
03ad4005cd8e POSIX only: added __GDB_SCRIPT__ and __GDB__PATTERN__ support thomask parents: 499 diff changeset	1252 if(strcmp(error_line, "")!=0 && strcmp(error_file, "")==0){
03ad4005cd8e POSIX only: added __GDB_SCRIPT__ and __GDB__PATTERN__ support thomask parents: 499 diff changeset	1253 error_file=case_file;
03ad4005cd8e POSIX only: added __GDB_SCRIPT__ and __GDB__PATTERN__ support thomask parents: 499 diff changeset	1254 }
03ad4005cd8e POSIX only: added __GDB_SCRIPT__ and __GDB__PATTERN__ support thomask parents: 499 diff changeset	1255
03ad4005cd8e POSIX only: added __GDB_SCRIPT__ and __GDB__PATTERN__ support thomask parents: 499 diff changeset	1256 /* gdb pattern */
03ad4005cd8e POSIX only: added __GDB_SCRIPT__ and __GDB__PATTERN__ support thomask parents: 499 diff changeset	1257 #ifdef REG_EXTENDED
03ad4005cd8e POSIX only: added __GDB_SCRIPT__ and __GDB__PATTERN__ support thomask parents: 499 diff changeset	1258 if(gdb_pattern_raw!=NULL && gdb_pattern_raw[0]!='\x00'){
03ad4005cd8e POSIX only: added __GDB_SCRIPT__ and __GDB__PATTERN__ support thomask parents: 499 diff changeset	1259
1206 d88a87712de1 fixed dstress.c for C++ compilers thomask parents: 1003 diff changeset	1260 gdb_pattern = (regex_t*) malloc(sizeof(regex_t));
922 95160f4d06f8 minimized memory leaks in repeatedly called functions thomask parents: 904 diff changeset	1261 if(regcomp(gdb_pattern, gdb_pattern_raw, REG_EXTENDED \| REG_NOSUB)){
704 3e690f0d2cbf documentation maintenance for dstress.c thomask parents: 703 diff changeset	1262 fprintf(stderr, "failed to compile regular expression:"
3e690f0d2cbf documentation maintenance for dstress.c thomask parents: 703 diff changeset	1263 "\n\t%s\n", gdb_pattern_raw);
620 03ad4005cd8e POSIX only: added __GDB_SCRIPT__ and __GDB__PATTERN__ support thomask parents: 499 diff changeset	1264 exit(EXIT_FAILURE);
03ad4005cd8e POSIX only: added __GDB_SCRIPT__ and __GDB__PATTERN__ support thomask parents: 499 diff changeset	1265 }else if(gdb_script==NULL){
03ad4005cd8e POSIX only: added __GDB_SCRIPT__ and __GDB__PATTERN__ support thomask parents: 499 diff changeset	1266 fprintf(stderr, "GDB pattern without GDB script\n");
03ad4005cd8e POSIX only: added __GDB_SCRIPT__ and __GDB__PATTERN__ support thomask parents: 499 diff changeset	1267 exit(EXIT_FAILURE);
03ad4005cd8e POSIX only: added __GDB_SCRIPT__ and __GDB__PATTERN__ support thomask parents: 499 diff changeset	1268 }
03ad4005cd8e POSIX only: added __GDB_SCRIPT__ and __GDB__PATTERN__ support thomask parents: 499 diff changeset	1269 }else{
03ad4005cd8e POSIX only: added __GDB_SCRIPT__ and __GDB__PATTERN__ support thomask parents: 499 diff changeset	1270 gdb_pattern = NULL;
03ad4005cd8e POSIX only: added __GDB_SCRIPT__ and __GDB__PATTERN__ support thomask parents: 499 diff changeset	1271 }
03ad4005cd8e POSIX only: added __GDB_SCRIPT__ and __GDB__PATTERN__ support thomask parents: 499 diff changeset	1272
03ad4005cd8e POSIX only: added __GDB_SCRIPT__ and __GDB__PATTERN__ support thomask parents: 499 diff changeset	1273 /* gdb script */
03ad4005cd8e POSIX only: added __GDB_SCRIPT__ and __GDB__PATTERN__ support thomask parents: 499 diff changeset	1274 if(gdb_script!=NULL && gdb_script[0]!='\x00'){
03ad4005cd8e POSIX only: added __GDB_SCRIPT__ and __GDB__PATTERN__ support thomask parents: 499 diff changeset	1275 if(gdb_pattern==NULL){
03ad4005cd8e POSIX only: added __GDB_SCRIPT__ and __GDB__PATTERN__ support thomask parents: 499 diff changeset	1276 fprintf(stderr, "GDB script without GDB pattern\n");
03ad4005cd8e POSIX only: added __GDB_SCRIPT__ and __GDB__PATTERN__ support thomask parents: 499 diff changeset	1277 exit(EXIT_FAILURE);
03ad4005cd8e POSIX only: added __GDB_SCRIPT__ and __GDB__PATTERN__ support thomask parents: 499 diff changeset	1278 }
03ad4005cd8e POSIX only: added __GDB_SCRIPT__ and __GDB__PATTERN__ support thomask parents: 499 diff changeset	1279 buffer=gdb_script;
03ad4005cd8e POSIX only: added __GDB_SCRIPT__ and __GDB__PATTERN__ support thomask parents: 499 diff changeset	1280 for(; *buffer; buffer++){
03ad4005cd8e POSIX only: added __GDB_SCRIPT__ and __GDB__PATTERN__ support thomask parents: 499 diff changeset	1281 if(buffer[0]=='\\'){
03ad4005cd8e POSIX only: added __GDB_SCRIPT__ and __GDB__PATTERN__ support thomask parents: 499 diff changeset	1282 if(buffer[1]=='n'){
03ad4005cd8e POSIX only: added __GDB_SCRIPT__ and __GDB__PATTERN__ support thomask parents: 499 diff changeset	1283 buffer[0]=' ';
03ad4005cd8e POSIX only: added __GDB_SCRIPT__ and __GDB__PATTERN__ support thomask parents: 499 diff changeset	1284 buffer[1]='\n';
03ad4005cd8e POSIX only: added __GDB_SCRIPT__ and __GDB__PATTERN__ support thomask parents: 499 diff changeset	1285 }
03ad4005cd8e POSIX only: added __GDB_SCRIPT__ and __GDB__PATTERN__ support thomask parents: 499 diff changeset	1286 buffer++;
03ad4005cd8e POSIX only: added __GDB_SCRIPT__ and __GDB__PATTERN__ support thomask parents: 499 diff changeset	1287 }
03ad4005cd8e POSIX only: added __GDB_SCRIPT__ and __GDB__PATTERN__ support thomask parents: 499 diff changeset	1288 }
03ad4005cd8e POSIX only: added __GDB_SCRIPT__ and __GDB__PATTERN__ support thomask parents: 499 diff changeset	1289
685 4f97e51515d8 ported dstress.c to OpenBsd thomask parents: 681 diff changeset	1290 bufferLen = strlen(gdb_script)+11;
1206 d88a87712de1 fixed dstress.c for C++ compilers thomask parents: 1003 diff changeset	1291 buffer = (char*) malloc(bufferLen);
685 4f97e51515d8 ported dstress.c to OpenBsd thomask parents: 681 diff changeset	1292 snprintf(buffer, bufferLen, "%s\n\nquit\ny\n\n", gdb_script);
4f97e51515d8 ported dstress.c to OpenBsd thomask parents: 681 diff changeset	1293 gdb_script=buffer;
922 95160f4d06f8 minimized memory leaks in repeatedly called functions thomask parents: 904 diff changeset	1294 }else if(gdb_script){
95160f4d06f8 minimized memory leaks in repeatedly called functions thomask parents: 904 diff changeset	1295 free(gdb_script);
95160f4d06f8 minimized memory leaks in repeatedly called functions thomask parents: 904 diff changeset	1296 gdb_script = NULL;
620 03ad4005cd8e POSIX only: added __GDB_SCRIPT__ and __GDB__PATTERN__ support thomask parents: 499 diff changeset	1297 }
03ad4005cd8e POSIX only: added __GDB_SCRIPT__ and __GDB__PATTERN__ support thomask parents: 499 diff changeset	1298
03ad4005cd8e POSIX only: added __GDB_SCRIPT__ and __GDB__PATTERN__ support thomask parents: 499 diff changeset	1299 #else
03ad4005cd8e POSIX only: added __GDB_SCRIPT__ and __GDB__PATTERN__ support thomask parents: 499 diff changeset	1300
704 3e690f0d2cbf documentation maintenance for dstress.c thomask parents: 703 diff changeset	1301 if(gdb_script && strlen(gdb_script)){
3e690f0d2cbf documentation maintenance for dstress.c thomask parents: 703 diff changeset	1302 if(gdb_pattern_raw && strlen(gdb_pattern_raw)){
734 d4edcc124e64 added Torture capabilities thomask parents: 710 diff changeset	1303 fprintf(stderr, "WARNING: GDB/regex support inactive\n");
704 3e690f0d2cbf documentation maintenance for dstress.c thomask parents: 703 diff changeset	1304 }else{
734 d4edcc124e64 added Torture capabilities thomask parents: 710 diff changeset	1305 fprintf(stderr, "GDB script without GDB pattern\n");
704 3e690f0d2cbf documentation maintenance for dstress.c thomask parents: 703 diff changeset	1306 exit(EXIT_FAILURE);
3e690f0d2cbf documentation maintenance for dstress.c thomask parents: 703 diff changeset	1307 }
620 03ad4005cd8e POSIX only: added __GDB_SCRIPT__ and __GDB__PATTERN__ support thomask parents: 499 diff changeset	1308 }else if(gdb_pattern_raw && strlen(gdb_pattern_raw)){
734 d4edcc124e64 added Torture capabilities thomask parents: 710 diff changeset	1309 fprintf(stderr, "GDB pattern without GDB script\n");
620 03ad4005cd8e POSIX only: added __GDB_SCRIPT__ and __GDB__PATTERN__ support thomask parents: 499 diff changeset	1310 exit(EXIT_FAILURE);
03ad4005cd8e POSIX only: added __GDB_SCRIPT__ and __GDB__PATTERN__ support thomask parents: 499 diff changeset	1311 }
03ad4005cd8e POSIX only: added __GDB_SCRIPT__ and __GDB__PATTERN__ support thomask parents: 499 diff changeset	1312
03ad4005cd8e POSIX only: added __GDB_SCRIPT__ and __GDB__PATTERN__ support thomask parents: 499 diff changeset	1313 #endif /* REG_EXTENDED else */
03ad4005cd8e POSIX only: added __GDB_SCRIPT__ and __GDB__PATTERN__ support thomask parents: 499 diff changeset	1314
493 1418f225a81e disabled debug output thomask parents: 490 diff changeset	1315 #ifdef DEBUG
902 58966fea59f7 preparing parallel build thomask parents: 888 diff changeset	1316 fprintf(stderr, "case : \"%s\"\n", case_file);
438 27039d5cbe81 partial cleanup for Windows(dmc) thomask parents: 437 diff changeset	1317 fprintf(stderr, "compiler: \"%s\"\n", compiler);
27039d5cbe81 partial cleanup for Windows(dmc) thomask parents: 437 diff changeset	1318 fprintf(stderr, "DFLAGS C: \"%s\"\n", cmd_arg_case);
27039d5cbe81 partial cleanup for Windows(dmc) thomask parents: 437 diff changeset	1319 fprintf(stderr, "ELINE : \"%s\"\n", error_line);
27039d5cbe81 partial cleanup for Windows(dmc) thomask parents: 437 diff changeset	1320 fprintf(stderr, "EFILE : \"%s\"\n", error_file);
734 d4edcc124e64 added Torture capabilities thomask parents: 710 diff changeset	1321 #ifdef REG_EXTENDED
620 03ad4005cd8e POSIX only: added __GDB_SCRIPT__ and __GDB__PATTERN__ support thomask parents: 499 diff changeset	1322 fprintf(stderr, "GDB Scri: \"%s\"\n", gdb_script);
03ad4005cd8e POSIX only: added __GDB_SCRIPT__ and __GDB__PATTERN__ support thomask parents: 499 diff changeset	1323 fprintf(stderr, "GDB Patt: \"%s\"\n", gdb_pattern_raw);
438 27039d5cbe81 partial cleanup for Windows(dmc) thomask parents: 437 diff changeset	1324 #endif
734 d4edcc124e64 added Torture capabilities thomask parents: 710 diff changeset	1325 fprintf(stderr, "block G : \"%s\"\n", torture_block_global);
d4edcc124e64 added Torture capabilities thomask parents: 710 diff changeset	1326 fprintf(stderr, "block C : \"%s\"\n", torture_block_case);
d4edcc124e64 added Torture capabilities thomask parents: 710 diff changeset	1327 fprintf(stderr, "modus : %x\n", modus);
d4edcc124e64 added Torture capabilities thomask parents: 710 diff changeset	1328 #endif
685 4f97e51515d8 ported dstress.c to OpenBsd thomask parents: 681 diff changeset	1329
251 6cd84461e17b enabled new "dstress.c" test tool thomask parents: diff changeset	1330
734 d4edcc124e64 added Torture capabilities thomask parents: 710 diff changeset	1331 /* let's get serious */
888 a995eae8e75c blind: partial merger of Stewart's crashRun for Windows thomask parents: 881 diff changeset	1332 #ifdef USE_WINDOWS
902 58966fea59f7 preparing parallel build thomask parents: 888 diff changeset	1333 originalStdout = GetStdHandle(STD_OUTPUT_HANDLE);
58966fea59f7 preparing parallel build thomask parents: 888 diff changeset	1334 originalStderr = GetStdHandle(STD_ERROR_HANDLE);
888 a995eae8e75c blind: partial merger of Stewart's crashRun for Windows thomask parents: 881 diff changeset	1335 #endif
339 a74c84e75682 added error line tests (__DSTRESS_ELINE__ / __DSTRESS_EFILE__) thomask parents: 292 diff changeset	1336
734 d4edcc124e64 added Torture capabilities thomask parents: 710 diff changeset	1337 if(modus & MODE_TORTURE){
746 0e3682dad93a fixed windows part of dstress.c thomask parents: 742 diff changeset	1338 if((modus & (MODE_COMPILE \| MODE_NOCOMPILE))
734 d4edcc124e64 added Torture capabilities thomask parents: 710 diff changeset	1339 && (modus & (MODE_RUN \| MODE_NORUN)))
d4edcc124e64 added Torture capabilities thomask parents: 710 diff changeset	1340 {
d4edcc124e64 added Torture capabilities thomask parents: 710 diff changeset	1341 fprintf(stderr, "BUG: unhandled torture modus %x\n", modus);
902 58966fea59f7 preparing parallel build thomask parents: 888 diff changeset	1342 exit(EXIT_FAILURE);
734 d4edcc124e64 added Torture capabilities thomask parents: 710 diff changeset	1343 }else if(!(modus & (MODE_COMPILE \| MODE_NOCOMPILE \| MODE_RUN \| MODE_NORUN))){
d4edcc124e64 added Torture capabilities thomask parents: 710 diff changeset	1344 fprintf(stderr, "BUG: unhandled torture modus %x\n", modus);
902 58966fea59f7 preparing parallel build thomask parents: 888 diff changeset	1345 exit(EXIT_FAILURE);
251 6cd84461e17b enabled new "dstress.c" test tool thomask parents: diff changeset	1346 }
6cd84461e17b enabled new "dstress.c" test tool thomask parents: diff changeset	1347
734 d4edcc124e64 added Torture capabilities thomask parents: 710 diff changeset	1348 bufferLen = strlen(torture[(sizeof(torture) / sizeof(char*))-1])
981 f410034559af fixed buffer size to include the length of the torture elements thomask parents: 977 diff changeset	1349 + 128 + strlen(cmd_arg_case) + 3;
746 0e3682dad93a fixed windows part of dstress.c thomask parents: 742 diff changeset	1350
734 d4edcc124e64 added Torture capabilities thomask parents: 710 diff changeset	1351 if(torture_block_case!=NULL && strlen(torture_block_case)<1){
d4edcc124e64 added Torture capabilities thomask parents: 710 diff changeset	1352 torture_block_case=NULL;
676 f90958db522d extended debug output thomask parents: 639 diff changeset	1353 }
746 0e3682dad93a fixed windows part of dstress.c thomask parents: 742 diff changeset	1354
1206 d88a87712de1 fixed dstress.c for C++ compilers thomask parents: 1003 diff changeset	1355 buffer = (char*) malloc(bufferLen);
734 d4edcc124e64 added Torture capabilities thomask parents: 710 diff changeset	1356 for(index=0; index < sizeof(torture)/sizeof(char*); index++){
d4edcc124e64 added Torture capabilities thomask parents: 710 diff changeset	1357 if((torture_block_global && strstr(torture[index], torture_block_global))
d4edcc124e64 added Torture capabilities thomask parents: 710 diff changeset	1358 \|\| (torture_block_case && strstr(torture[index], torture_block_case))
959 f4fc739bbaaf fixed handling of __DSTRESS_TORTURE_REQUIRE__ thomask parents: 940 diff changeset	1359 \|\| (torture_require && !strstr(torture[index], torture_require)))
734 d4edcc124e64 added Torture capabilities thomask parents: 710 diff changeset	1360 {
d4edcc124e64 added Torture capabilities thomask parents: 710 diff changeset	1361 torture_result[index]=RES_UNTESTED;
d4edcc124e64 added Torture capabilities thomask parents: 710 diff changeset	1362 continue;
d4edcc124e64 added Torture capabilities thomask parents: 710 diff changeset	1363 }
746 0e3682dad93a fixed windows part of dstress.c thomask parents: 742 diff changeset	1364
734 d4edcc124e64 added Torture capabilities thomask parents: 710 diff changeset	1365 buffer[0]=0;
d4edcc124e64 added Torture capabilities thomask parents: 710 diff changeset	1366 snprintf(buffer, bufferLen, "%s %s", torture[index], cmd_arg_case);
746 0e3682dad93a fixed windows part of dstress.c thomask parents: 742 diff changeset	1367
734 d4edcc124e64 added Torture capabilities thomask parents: 710 diff changeset	1368 if(modus & (MODE_COMPILE \| MODE_NOCOMPILE)){
d4edcc124e64 added Torture capabilities thomask parents: 710 diff changeset	1369 torture_result[index] = target_compile(modus,
d4edcc124e64 added Torture capabilities thomask parents: 710 diff changeset	1370 compiler, buffer, case_file,
d4edcc124e64 added Torture capabilities thomask parents: 710 diff changeset	1371 error_file, error_line);
d4edcc124e64 added Torture capabilities thomask parents: 710 diff changeset	1372 }else if(modus & (MODE_RUN \| MODE_NORUN)){
d4edcc124e64 added Torture capabilities thomask parents: 710 diff changeset	1373 torture_result[index] = target_run(modus,
d4edcc124e64 added Torture capabilities thomask parents: 710 diff changeset	1374 compiler, buffer, case_file,
d4edcc124e64 added Torture capabilities thomask parents: 710 diff changeset	1375 error_file, error_line
d4edcc124e64 added Torture capabilities thomask parents: 710 diff changeset	1376 #ifdef REG_EXTENDED
d4edcc124e64 added Torture capabilities thomask parents: 710 diff changeset	1377 , gdb, gdb_script, gdb_pattern
d4edcc124e64 added Torture capabilities thomask parents: 710 diff changeset	1378 #endif
d4edcc124e64 added Torture capabilities thomask parents: 710 diff changeset	1379 );
d4edcc124e64 added Torture capabilities thomask parents: 710 diff changeset	1380 }
438 27039d5cbe81 partial cleanup for Windows(dmc) thomask parents: 437 diff changeset	1381
902 58966fea59f7 preparing parallel build thomask parents: 888 diff changeset	1382 printf("Torture-Sub-%i/" ZU "-", index+1,
734 d4edcc124e64 added Torture capabilities thomask parents: 710 diff changeset	1383 sizeof(torture)/sizeof(char*));
d4edcc124e64 added Torture capabilities thomask parents: 710 diff changeset	1384 printResult(torture_result[index], modus, case_file,
902 58966fea59f7 preparing parallel build thomask parents: 888 diff changeset	1385 stdout);
58966fea59f7 preparing parallel build thomask parents: 888 diff changeset	1386 printf("--------\n");
685 4f97e51515d8 ported dstress.c to OpenBsd thomask parents: 681 diff changeset	1387 }
251 6cd84461e17b enabled new "dstress.c" test tool thomask parents: diff changeset	1388 }else{
998 94714c219f3b fixed handling of __DSTRESS_TORTURE_REQUIRE__ for non-torture tests thomask parents: 991 diff changeset	1389 if(torture_require && torture_require[0]){
971 8da09834526d * Valgrind support is now part of dstress.c instead of crashRun.c thomask parents: 968 diff changeset	1390 if(!cmd_arg_case \|\| !cmd_arg_case[0]){
998 94714c219f3b fixed handling of __DSTRESS_TORTURE_REQUIRE__ for non-torture tests thomask parents: 991 diff changeset	1391 cmd_arg_case = torture_require;
968 8b6d2dcf9954 * fixed new line escapes in GDB_SCRIPT thomask parents: 959 diff changeset	1392 }else{
971 8da09834526d * Valgrind support is now part of dstress.c instead of crashRun.c thomask parents: 968 diff changeset	1393 bufferLen = strlen(cmd_arg_case);
8da09834526d * Valgrind support is now part of dstress.c instead of crashRun.c thomask parents: 968 diff changeset	1394 bufferLen += strlen(torture_require);
8da09834526d * Valgrind support is now part of dstress.c instead of crashRun.c thomask parents: 968 diff changeset	1395 bufferLen += 2;
1206 d88a87712de1 fixed dstress.c for C++ compilers thomask parents: 1003 diff changeset	1396 buffer = (char*) malloc(bufferLen);
971 8da09834526d * Valgrind support is now part of dstress.c instead of crashRun.c thomask parents: 968 diff changeset	1397 snprintf(buffer, bufferLen, "%s %s", cmd_arg_case, torture_require);
8da09834526d * Valgrind support is now part of dstress.c instead of crashRun.c thomask parents: 968 diff changeset	1398 cmd_arg_case = buffer;
968 8b6d2dcf9954 * fixed new line escapes in GDB_SCRIPT thomask parents: 959 diff changeset	1399 }
8b6d2dcf9954 * fixed new line escapes in GDB_SCRIPT thomask parents: 959 diff changeset	1400 }
734 d4edcc124e64 added Torture capabilities thomask parents: 710 diff changeset	1401 if(modus & (MODE_RUN \| MODE_NORUN)){
d4edcc124e64 added Torture capabilities thomask parents: 710 diff changeset	1402 case_result = target_run(modus, compiler, cmd_arg_case,
d4edcc124e64 added Torture capabilities thomask parents: 710 diff changeset	1403 case_file, error_file, error_line
d4edcc124e64 added Torture capabilities thomask parents: 710 diff changeset	1404 #ifdef REG_EXTENDED
d4edcc124e64 added Torture capabilities thomask parents: 710 diff changeset	1405 , gdb, gdb_script, gdb_pattern
d4edcc124e64 added Torture capabilities thomask parents: 710 diff changeset	1406 #endif
d4edcc124e64 added Torture capabilities thomask parents: 710 diff changeset	1407 );
880 fdb649fc5b8d changed output format of non-torture runs thomask parents: 774 diff changeset	1408 }else if(modus & (MODE_COMPILE \| MODE_NOCOMPILE)){
734 d4edcc124e64 added Torture capabilities thomask parents: 710 diff changeset	1409 case_result = target_compile(modus, compiler,
d4edcc124e64 added Torture capabilities thomask parents: 710 diff changeset	1410 cmd_arg_case, case_file, error_file,
d4edcc124e64 added Torture capabilities thomask parents: 710 diff changeset	1411 error_line);
881 996d9134bf80 added flag safeguard thomask parents: 880 diff changeset	1412 }else{
996d9134bf80 added flag safeguard thomask parents: 880 diff changeset	1413 fprintf(stderr, "BUG: unhandled non-torture modus %x\n", modus);
902 58966fea59f7 preparing parallel build thomask parents: 888 diff changeset	1414 exit(EXIT_FAILURE);
734 d4edcc124e64 added Torture capabilities thomask parents: 710 diff changeset	1415 }
904 67e77ee70d66 minor OpenBSD and Windows fixes thomask parents: 902 diff changeset	1416
902 58966fea59f7 preparing parallel build thomask parents: 888 diff changeset	1417 printf("Torture-Sub-1/" ZU "-",
880 fdb649fc5b8d changed output format of non-torture runs thomask parents: 774 diff changeset	1418 sizeof(torture)/sizeof(char*));
fdb649fc5b8d changed output format of non-torture runs thomask parents: 774 diff changeset	1419 printResult(case_result, modus, case_file, stdout);
251 6cd84461e17b enabled new "dstress.c" test tool thomask parents: diff changeset	1420 }
734 d4edcc124e64 added Torture capabilities thomask parents: 710 diff changeset	1421
971 8da09834526d * Valgrind support is now part of dstress.c instead of crashRun.c thomask parents: 968 diff changeset	1422 if(strcmp(TMP_DIR, tmp_dir)){
8da09834526d * Valgrind support is now part of dstress.c instead of crashRun.c thomask parents: 968 diff changeset	1423 bufferLen = strlen(tmp_dir);
8da09834526d * Valgrind support is now part of dstress.c instead of crashRun.c thomask parents: 968 diff changeset	1424 bufferLen += strlen(RM_DIR);
8da09834526d * Valgrind support is now part of dstress.c instead of crashRun.c thomask parents: 968 diff changeset	1425 bufferLen += 2;
1206 d88a87712de1 fixed dstress.c for C++ compilers thomask parents: 1003 diff changeset	1426 buffer = (char*) malloc(bufferLen);
971 8da09834526d * Valgrind support is now part of dstress.c instead of crashRun.c thomask parents: 968 diff changeset	1427 snprintf(buffer, bufferLen, "%s %s", RM_DIR, tmp_dir);
8da09834526d * Valgrind support is now part of dstress.c instead of crashRun.c thomask parents: 968 diff changeset	1428 system(buffer);
8da09834526d * Valgrind support is now part of dstress.c instead of crashRun.c thomask parents: 968 diff changeset	1429 }
902 58966fea59f7 preparing parallel build thomask parents: 888 diff changeset	1430 exit(EXIT_SUCCESS);
251 6cd84461e17b enabled new "dstress.c" test tool thomask parents: diff changeset	1431 }

Mercurial > projects > dstress

annotate dstress.c @ 1630:d0efa3ae5522 default tip