Merge bk-internal.mysql.com:/home/bk/mysql-maria

into  janus.mylan:/usr/home/serg/Abk/mysql-maria

dbug/.cvsignore

-.deps
-Makefile
-Makefile.in

dbug/Makefile.am

@@ -23,19 +23,20 @@ libdbug_a_SOURCES =     dbug.c sanity.c
 EXTRA_DIST =            CMakeLists.txt example1.c example2.c example3.c \
                         user.r monty.doc dbug_add_tags.pl \
                         my_main.c main.c factorial.c dbug_analyze.c \
-						CMakeLists.txt
+			CMakeLists.txt tests.c tests-t.pl
 NROFF_INC =             example1.r example2.r example3.r main.r \
                         factorial.r output1.r output2.r output3.r \
                         output4.r output5.r
-CLEANFILES =            $(NROFF_INC) user.t user.ps
+CLEANFILES =            $(NROFF_INC) user.t user.ps tests-t
 
 
 # Must be linked with libs that are not compiled yet
-noinst_PROGRAMS =       factorial dbug_analyze
+noinst_PROGRAMS =       factorial dbug_analyze tests
 factorial_SOURCES =     my_main.c factorial.c
+tests_SOURCES = 	tests.c
 dbug_analyze_SOURCES =  dbug_analyze.c
 
-all:            user.t user.ps
+all:            user.t user.ps tests-t
 
 user.t:         user.r $(NROFF_INC)
 		-nroff -mm user.r > $@
@@ -61,5 +62,9 @@ output5.r:      factorial
 		@RM@ -f $@
 		@SED@ -e 's!\\!\\\\!g' $< > $@
 
+# a hack to have executable in builddir, not in srcdir
+tests-t:	tests-t.pl
+		cp $(srcdir)/tests-t.pl $(builddir)/tests-t
+
 # Don't update the files from bitkeeper
 %::SCCS/s.%

dbug/doinstall.sh

-
-# Warning - first line left blank for sh/csh/ksh compatibility.  Do not
-# remove it.  fnf@Unisoft
-
-# doinstall.sh --- figure out environment and do recursive make with
-# appropriate pathnames.  Works under SV or BSD.
-
-if [ -r /usr/include/search.h ]
-then
-	# System V
-	$* LLIB=/usr/lib
-else
-	# 4.2 BSD
-	$* LLIB=/usr/lib/lint
-fi

dbug/install.sh

-
-#	WARNING -- first line intentionally left blank for sh/csh/ksh
-#	compatibility.  Do not remove it!  FNF, UniSoft Systems.
-#
-#	Usage is:
-#			install <from> <to>
-#
-#	The file <to> is replaced with the file <from>, after first
-#	moving <to> to a backup file.  The backup file name is created
-#	by prepending the filename (after removing any leading pathname
-#	components) with "OLD".
-#
-#	This script is currently not real robust in the face of signals
-#	or permission problems.  It also does not do (by intention) all
-#	the things that the System V or BSD install scripts try to do
-#
-
-if [ $# -ne 2 ]
-then
-	echo  "usage: $0 <from> <to>"
-	exit 1
-fi
-
-# Now extract the dirname and basename components.  Unfortunately, BSD does
-# not have dirname, so we do it the hard way.
-
-fd=`expr $1'/' : '\(/\)[^/]*/$' \| $1'/' : '\(.*[^/]\)//*[^/][^/]*//*$' \| .`
-ff=`basename $1`
-td=`expr $2'/' : '\(/\)[^/]*/$' \| $2'/' : '\(.*[^/]\)//*[^/][^/]*//*$' \| .`
-tf=`basename $2`
-
-# Now test to make sure that they are not the same files.
-
-if [ $fd/$ff = $td/$tf ]
-then
-	echo "install: input and output are same files"
-	exit 2
-fi
-
-# Save a copy of the "to" file as a backup.
-
-if test -f $td/$tf
-then
-	if test -f $td/OLD$tf
-	then
-		rm -f $td/OLD$tf
-	fi
-	mv $td/$tf $td/OLD$tf
-	if [ $? != 0 ]
-	then
-		exit 3
-	fi
-fi
-
-# Now do the copy and return appropriate status
-
-cp $fd/$ff $td/$tf
-if [ $? != 0 ]
-then
-	exit 4
-else
-	exit 0
-fi
-

dbug/mklintlib.sh

-
-# Warning - first line left blank for sh/csh/ksh compatibility.  Do not
-# remove it.  fnf@Unisoft
-
-# mklintlib --- make a lint library, under either System V or 4.2 BSD
-#
-# usage:  mklintlib <infile> <outfile>
-#
-
-if test $# -ne 2
-then
-	echo "usage: mklintlib <infile> <outfile>"
-	exit 1
-fi
-
-if grep SIGTSTP /usr/include/signal.h >/dev/null
-then							# BSD
-	if test -r /usr/include/whoami.h		# 4.1
-	then
-		/lib/cpp -C -Dlint $1 >hlint
-		(/usr/lib/lint/lint1 <hlint >$2) 2>&1 | grep -v warning
-	else						# 4.2
-		lint -Cxxxx $1
-		mv llib-lxxxx.ln $2
-	fi
-else							# USG
-	cc -E -C -Dlint $1 | /usr/lib/lint1 -vx -Hhlint >$2
-	rm -f hlint
-fi
-exit 0							# don't kill make

dbug/qmake.cmd

-CL -I\my\include -AL -Gsm2 -FPi -DDBUG_OFF *.c
-rm \my\lib\dbug.lib
-lib.exe \my\lib\dbug dbug.obj sanity.obj;
-link /NOD /STACK:8000 main factoria,factoria,,DBUG+STRINGS+LLIBCEP+DOSCALLS;

dbug/tests-t.pl

+#!/usr/bin/perl
+
+#
+#  A driver program to test DBUG features - runs tests (shell commands)
+#  from the end of file to invoke tests.c, which does the real dbug work.
+#
+
+$exe=$0;
+
+die unless $exe =~ s/(tests)-t(\.exe)?$/$1$2 /;
+
+# load tests
+@tests=();
+while (<DATA>) {
+  if (/^% tests /) {
+    push @tests, [ $' ]
+  } else {
+    push @{$tests[$#tests]}, $_
+  }
+}
+
+# require/import instead of use - we know the plan only when tests are loaded
+require Test::More;
+import Test::More tests => scalar(@tests);
+
+for (@tests) {
+  $t=$exe . shift @$_;
+  chomp($t);
+  open F, '-|',  $t or die "open($t|): $!";
+  local $";
+  $out=join($", <F>); close(F);
+  # special cases are handled here:
+  $out =~ s/Memory: 0x[0-9A-Fa-f]+/Memory: 0x####/g if $t =~ /dump/;
+  # compare ("\n" at the beginning makes better output in case of errors)
+  is("\n$out","\n@$_", $t);
+}
+
+__DATA__
+% tests -#d
+func2: info: s=ok
+func2: info: s=ok
+=> execute
+=> evaluate: ON
+=> evaluate_if: OFF
+main: explain: dbug explained: d
+% tests -#d,ret3
+=> evaluate: OFF
+=> evaluate_if: OFF
+% tests -#d:-d,ret3
+func2: info: s=ko
+func2: info: s=ko
+=> execute
+=> evaluate: ON
+=> evaluate_if: OFF
+main: explain: dbug explained: d:-d,ret3
+% tests -#t:-d,ret3
+>main
+| >func1
+| | >func2
+| | | >func3
+| | | <func3
+| | <func2
+| <func1
+| >func2
+| | >func3
+| | <func3
+| <func2
+=> evaluate: OFF
+=> evaluate_if: OFF
+<main
+% tests -#t:d,info:-d,ret3
+>main
+| >func1
+| | >func2
+| | | >func3
+| | | <func3
+| | | info: s=ko
+| | <func2
+| <func1
+| >func2
+| | >func3
+| | <func3
+| | info: s=ko
+| <func2
+=> evaluate: OFF
+=> evaluate_if: OFF
+<main
+% tests -#t:d,info:-d,ret3:-f,func2
+>main
+| >func1
+| | | >func3
+| | | <func3
+| <func1
+| | >func3
+| | <func3
+=> evaluate: OFF
+=> evaluate_if: OFF
+<main
+% tests -#t:d,info:-d,ret3:-f,func2 d,evaluate
+=> evaluate: ON
+=> evaluate_if: OFF
+% tests -#t:d,info:-d,ret3:-f,func2 d,evaluate_if
+=> evaluate: OFF
+=> evaluate_if: ON
+% tests -#t:d:-d,ret3:-f,func2 d,evaluate_if
+=> evaluate: OFF
+=> evaluate_if: ON
+% tests -#t:d:-d,ret3:-f,func2 +d,evaluate_if
+>main
+| >func1
+| | | >func3
+| | | <func3
+| <func1
+| | >func3
+| | <func3
+=> evaluate: OFF
+=> evaluate_if: ON
+<main
+% tests -#t:d:-d,ret3:-f,func2
+>main
+| >func1
+| | | >func3
+| | | <func3
+| <func1
+| | >func3
+| | <func3
+=> execute
+=> evaluate: ON
+=> evaluate_if: OFF
+| explain: dbug explained: d:-d,ret3:f:-f,func2:t
+<main
+% tests -#t:d:-d,ret3:f:-f,func2 -#+d,dump
+>main
+| >func1
+| | | >func3
+| | | <func3
+| <func1
+| | >func3
+| | <func3
+| dump: Memory: 0x####  Bytes: (27)
+64 2C 64 75 6D 70 3A 2D 64 2C 72 65 74 33 3A 66 3A 2D 66 2C 66 75 6E 63 32 3A 
+74 
+=> evaluate: OFF
+=> evaluate_if: OFF
+<main
+% tests -#t:d:-d,ret3:f:-f,func2 +d,dump
+>main
+| >func1
+| | | >func3
+| | | <func3
+| <func1
+| | >func3
+| | <func3
+| dump: Memory: 0x####  Bytes: (27)
+64 2C 64 75 6D 70 3A 2D 64 2C 72 65 74 33 3A 66 3A 2D 66 2C 66 75 6E 63 32 3A 
+74 
+=> evaluate: OFF
+=> evaluate_if: OFF
+<main
+% tests -#t:d:-d,ret3:f:-f,func2:+d,dump
+>main
+| >func1
+| | | >func3
+| | | <func3
+| <func1
+| | >func3
+| | <func3
+| dump: Memory: 0x####  Bytes: (27)
+64 2C 64 75 6D 70 3A 2D 64 2C 72 65 74 33 3A 66 3A 2D 66 2C 66 75 6E 63 32 3A 
+74 
+=> evaluate: OFF
+=> evaluate_if: OFF
+<main
+% tests -#t:d:-d,ret3:f:-f,func2 +d,dump,explain
+>main
+| >func1
+| | | >func3
+| | | <func3
+| <func1
+| | >func3
+| | <func3
+| dump: Memory: 0x####  Bytes: (35)
+64 2C 64 75 6D 70 2C 65 78 70 6C 61 69 6E 3A 2D 64 2C 72 65 74 33 3A 66 3A 2D 
+66 2C 66 75 6E 63 32 3A 74 
+=> evaluate: OFF
+=> evaluate_if: OFF
+| explain: dbug explained: d,dump,explain:-d,ret3:f:-f,func2:t
+<main
+% tests -#t:d:-d,ret3:f:-f,func2 +d,dump,explain:P
+dbug: >main
+dbug-tests: | >func1
+dbug-tests: | | | >func3
+dbug-tests: | | | <func3
+dbug-tests: | <func1
+dbug-tests: | | >func3
+dbug-tests: | | <func3
+dbug-tests: | dump: Memory: 0x####  Bytes: (37)
+64 2C 64 75 6D 70 2C 65 78 70 6C 61 69 6E 3A 2D 64 2C 72 65 74 33 3A 66 3A 2D 
+66 2C 66 75 6E 63 32 3A 50 3A 74 
+=> evaluate: OFF
+=> evaluate_if: OFF
+dbug-tests: | explain: dbug explained: d,dump,explain:-d,ret3:f:-f,func2:P:t
+dbug-tests: <main
+% tests -#t:d:-d,ret3:f:-f,func2 +d,dump,explain:P:F
+dbug:        tests.c: >main
+dbug-tests:        tests.c: | >func1
+dbug-tests:        tests.c: | | | >func3
+dbug-tests:        tests.c: | | | <func3
+dbug-tests:        tests.c: | <func1
+dbug-tests:        tests.c: | | >func3
+dbug-tests:        tests.c: | | <func3
+dbug-tests:        tests.c: | dump: Memory: 0x####  Bytes: (39)
+64 2C 64 75 6D 70 2C 65 78 70 6C 61 69 6E 3A 2D 64 2C 72 65 74 33 3A 66 3A 2D 
+66 2C 66 75 6E 63 32 3A 46 3A 50 3A 74 
+=> evaluate: OFF
+=> evaluate_if: OFF
+dbug-tests:        tests.c: | explain: dbug explained: d,dump,explain:-d,ret3:f:-f,func2:F:P:t
+dbug-tests:        tests.c: <main
+% tests -#t:d:-d,ret3:f:-f,func2
+>main
+| >func1
+| | | >func3
+| | | <func3
+| <func1
+| | >func3
+| | <func3
+=> execute
+=> evaluate: ON
+=> evaluate_if: OFF
+| explain: dbug explained: d:-d,ret3:f:-f,func2:t
+<main
+% tests -#t:d:-d,ret3
+>main
+| >func1
+| | >func2
+| | | >func3
+| | | <func3
+| | | info: s=ko
+| | <func2
+| <func1
+| >func2
+| | >func3
+| | <func3
+| | info: s=ko
+| <func2
+=> execute
+=> evaluate: ON
+=> evaluate_if: OFF
+| explain: dbug explained: d:-d,ret3:t
+<main
+% tests -#t:d,info:-d,ret3:d,push
+>main
+| >func1
+| | >func2
+| | | >func3
+| | | <func3
+| | | info: s=ko
+| | <func2
+| <func1
+| >func2
+| | >func3
+| | <func3
+| | info: s=ko
+| <func2
+=> evaluate: OFF
+=> evaluate_if: OFF
+<main
+% tests -#d,info:-d,ret3:d,push
+func2: info: s=ko
+func2: info: s=ko
+=> evaluate: OFF
+=> evaluate_if: OFF
+<main
+% tests -#d,info:-d,ret3:d,push,explain
+func2: info: s=ko
+func2: info: s=ko
+=> evaluate: OFF
+=> evaluate_if: OFF
+| explain: dbug explained: d,info,push,explain:-d,ret3:t
+<main
+% tests -#d,info:-d,ret3:d,explain
+func2: info: s=ko
+func2: info: s=ko
+=> evaluate: OFF
+=> evaluate_if: OFF
+main: explain: dbug explained: d,info,explain:-d,ret3
+% tests -#d,info:-d,ret3:d,explain,pop
+func2: info: s=ko
+func2: info: s=ko
+=> evaluate: OFF
+=> evaluate_if: OFF
+% tests -#d,info:-d,ret3:d,explain,pop t
+>main
+| >func1
+| | >func2
+| | | >func3
+| | | <func3
+| | <func2
+| <func1
+| >func2
+| | >func3
+| | <func3
+| <func2
+=> evaluate: OFF
+=> evaluate_if: OFF
+<main
+% tests -#d,info:-d,ret3:d,explain,pop +t
+>main
+| >func1
+| | >func2
+| | | >func3
+| | | <func3
+| | | info: s=ko
+| | <func2
+| <func1
+| >func2
+| | >func3
+| | <func3
+| | info: s=ko
+| <func2
+=> evaluate: OFF
+=> evaluate_if: OFF
+main: explain: dbug explained: d,info,explain,pop:-d,ret3
+% tests -#d,info:-d,ret3:d,explain,set
+func2: info: s=ko
+func2: info: s=ko
+=> evaluate: OFF
+=> evaluate_if: OFF
+       tests.c: main: explain: dbug explained: d,info,explain,set:-d,ret3:F
+% tests -#d,info:-d,ret3:d,explain,set:t
+>main
+| >func1
+| | >func2
+| | | >func3
+| | | <func3
+| | | info: s=ko
+| | <func2
+| <func1
+| >func2
+| | >func3
+| | <func3
+| | info: s=ko
+| <func2
+=> evaluate: OFF
+=> evaluate_if: OFF
+       tests.c: | explain: dbug explained: d,info,explain,set:-d,ret3:F:t
+       tests.c: <main
+% tests t -#d,info:-d,ret3:d,explain,set:t
+>main
+| >func1
+| | >func2
+| | | >func3
+| | | <func3
+| | | info: s=ko
+| | <func2
+| <func1
+| >func2
+| | >func3
+| | <func3
+| | info: s=ko
+| <func2
+=> evaluate: OFF
+=> evaluate_if: OFF
+       tests.c: | explain: dbug explained: d,info,explain,set:-d,ret3:F:t
+       tests.c: <main
+% tests t -#d,info:-d,ret3:d,explain,set,pop
+func2: info: s=ko
+func2: info: s=ko
+=> evaluate: OFF
+=> evaluate_if: OFF
+<main

dbug/tests.c

+/*
+  A program to test DBUG features. Used by tests-t.pl
+*/
+
+#ifdef DBUG_OFF                         /* We are testing dbug */
+#undef DBUG_OFF
+#endif
+
+#include <my_global.h>  /* This includes dbug.h */
+#include <my_pthread.h>
+#include <string.h>
+
+const char *func3()
+{
+  DBUG_ENTER("func3");
+  DBUG_RETURN(DBUG_EVALUATE("ret3", "ok", "ko"));
+}
+
+void func2()
+{
+  const char *s;
+  DBUG_ENTER("func2");
+  s=func3();
+  DBUG_PRINT("info", ("s=%s", s));
+  DBUG_VOID_RETURN;
+}
+
+int func1()
+{
+  DBUG_ENTER("func1");
+  func2();
+  DBUG_RETURN(10);
+}
+
+int main (int argc, char *argv[])
+{
+  int i;
+#if defined(HAVE_PTHREAD_INIT) && defined(THREAD)
+  pthread_init();                       /* Must be called before DBUG_ENTER */
+#endif
+#ifdef THREAD
+  my_thread_global_init();
+#endif
+  dup2(1, 2);
+  for (i = 1; i < argc; i++)
+    DBUG_PUSH (argv[i]);
+  {
+    DBUG_ENTER ("main");
+    DBUG_PROCESS ("dbug-tests");
+    func1();
+    func2();
+    DBUG_EXECUTE_IF("dump",
+    {
+      char s[1000];
+      DBUG_EXPLAIN(s, sizeof(s)-1);
+      DBUG_DUMP("dump", (uchar*)s, strlen(s));
+    });
+    DBUG_EXECUTE_IF("push",  DBUG_PUSH("+t"); );
+    DBUG_EXECUTE("execute", fprintf(DBUG_FILE, "=> execute\n"); );
+    DBUG_EXECUTE_IF("set",  DBUG_SET("+F"); );
+    fprintf(DBUG_FILE, "=> evaluate: %s\n",
+            DBUG_EVALUATE("evaluate", "ON", "OFF"));
+    fprintf(DBUG_FILE, "=> evaluate_if: %s\n",
+            DBUG_EVALUATE_IF("evaluate_if", "ON", "OFF"));
+    DBUG_EXECUTE_IF("pop",  DBUG_POP(); );
+    {
+      char s[1000];
+      DBUG_EXPLAIN(s, sizeof(s)-1);
+      DBUG_PRINT("explain", ("dbug explained: %s", s));
+    }
+    DBUG_RETURN (0);
+  }
+}

dbug/vargs.h

-/******************************************************************************
- *									      *
- *				   N O T I C E				      *
- *									      *
- *		      Copyright Abandoned, 1987, Fred Fish		      *
- *									      *
- *									      *
- *	This previously copyrighted work has been placed into the  public     *
- *	domain	by  the  author  and  may be freely used for any purpose,     *
- *	private or commercial.						      *
- *									      *
- *	Because of the number of inquiries I was receiving about the  use     *
- *	of this product in commercially developed works I have decided to     *
- *	simply make it public domain to further its unrestricted use.	I     *
- *	specifically  would  be  most happy to see this material become a     *
- *	part of the standard Unix distributions by AT&T and the  Berkeley     *
- *	Computer  Science  Research Group, and a standard part of the GNU     *
- *	system from the Free Software Foundation.			      *
- *									      *
- *	I would appreciate it, as a courtesy, if this notice is  left  in     *
- *	all copies and derivative works.  Thank you.			      *
- *									      *
- *	The author makes no warranty of any kind  with	respect  to  this     *
- *	product  and  explicitly disclaims any implied warranties of mer-     *
- *	chantability or fitness for any particular purpose.		      *
- *									      *
- ******************************************************************************
- */
-
-
-/*
- *  FILE
- *
- *	vargs.h    include file for environments without varargs.h
- *
- *  SCCS
- *
- *	@(#)vargs.h	1.2	5/8/88
- *
- *  SYNOPSIS
- *
- *	#include "vargs.h"
- *
- *  DESCRIPTION
- *
- *	This file implements a varargs macro set for use in those
- *	environments where there is no system supplied varargs.  This
- *	generally works because systems which don't supply a varargs
- *	package are precisely those which don't strictly need a varargs
- *	package.  Using this one then allows us to minimize source
- *	code changes.  So in some sense, this is a "portable" varargs
- *	since it is only used for convenience, when it is not strictly
- *	needed.
- *
- */
-
-/*
- *	These macros allow us to rebuild an argument list on the stack
- *	given only a va_list.  We can use these to fake a function like
- *	vfprintf, which gets a fixed number of arguments, the last of
- *	which is a va_list, by rebuilding a stack and calling the variable
- *	argument form fprintf.	Of course this only works when vfprintf
- *	is not available in the host environment, and thus is not available
- *	for fprintf to call (which would give us an infinite loop).
- *
- *	Note that ARGS_TYPE is a long, which lets us get several bytes
- *	at a time while also preventing lots of "possible pointer alignment
- *	problem" messages from lint.  The messages are valid, because this
- *	IS nonportable, but then we should only be using it in very
- *	nonrestrictive environments, and using the real varargs where it
- *	really counts.
- *
- */
-
-#define ARG0 a0
-#define ARG1 a1
-#define ARG2 a2
-#define ARG3 a3
-#define ARG4 a4
-#define ARG5 a5
-#define ARG6 a6
-#define ARG7 a7
-#define ARG8 a8
-#define ARG9 a9
-
-#define ARGS_TYPE long
-#define ARGS_LIST ARG0,ARG1,ARG2,ARG3,ARG4,ARG5,ARG6,ARG7,ARG8,ARG9
-#define ARGS_DCL auto ARGS_TYPE ARGS_LIST
-
-/*
- *	A pointer of type "va_list" points to a section of memory
- *	containing an array of variable sized arguments of unknown
- *	number.  This pointer is initialized by the va_start
- *	macro to point to the first byte of the first argument.
- *	We can then use it to walk through the argument list by
- *	incrementing it by the size of the argument being referenced.
- */
-
-typedef char *va_list;
-
-/*
- *	The first variable argument overlays va_alist, which is
- *	nothing more than a "handle" which allows us to get the
- *	address of the first argument on the stack.  Note that
- *	by definition, the va_dcl macro includes the terminating
- *	semicolon, which makes use of va_dcl in the source code
- *	appear to be missing a semicolon.
- */
-
-#define va_dcl ARGS_TYPE va_alist;
-
-/*
- *	The va_start macro takes a variable of type "va_list" and
- *	initializes it.  In our case, it initializes a local variable
- *	of type "pointer to char" to point to the first argument on
- *	the stack.
- */
-
-#define va_start(list) list = (char *) &va_alist
-
-/*
- *	The va_end macro is a null operation for our use.
- */
-
-#define va_end(list)
-
-/*
- *	The va_arg macro is the tricky one.  This one takes
- *	a va_list as the first argument, and a type as the second
- *	argument, and returns a value of the appropriate type
- *	while advancing the va_list to the following argument.
- *	For our case, we first increment the va_list arg by the
- *	size of the type being recovered, cast the result to
- *	a pointer of the appropriate type, and then dereference
- *	that pointer as an array to get the previous arg (which
- *	is the one we wanted.
- */
-
-#define va_arg(list,type) ((type *) (list += sizeof (type)))[-1]

include/my_dbug.h

@@ -22,8 +22,7 @@ extern "C" {
 #if !defined(DBUG_OFF) && !defined(_lint)
 struct  _db_code_state_;
 extern  my_bool _dbug_on_;
-extern	my_bool _db_keyword_(struct _db_code_state_ *cs, const char *keyword);
-extern  my_bool _db_strict_keyword_(const char *keyword);
+extern	my_bool _db_keyword_(struct _db_code_state_ *, const char *, int);
 extern  int _db_explain_(struct _db_code_state_ *cs, char *buf, size_t len);
 extern  int _db_explain_init_(char *buf, size_t len);
 extern	void _db_setjmp_(void);
@@ -58,13 +57,13 @@ extern  void _db_force_flush();
 #define DBUG_RETURN(a1) do {DBUG_LEAVE; return(a1);} while(0)
 #define DBUG_VOID_RETURN do {DBUG_LEAVE; return;} while(0)
 #define DBUG_EXECUTE(keyword,a1) \
-        do {if (_db_keyword_(0, (keyword))) { a1 }} while(0)
+        do {if (_db_keyword_(0, (keyword), 0)) { a1 }} while(0)
 #define DBUG_EXECUTE_IF(keyword,a1) \
-        do {if (_db_strict_keyword_ (keyword)) { a1 } } while(0)
+        do {if (_db_keyword_(0, (keyword), 1)) { a1 }} while(0)
 #define DBUG_EVALUATE(keyword,a1,a2) \
-        (_db_keyword_(0,(keyword)) ? (a1) : (a2))
+        (_db_keyword_(0,(keyword), 0) ? (a1) : (a2))
 #define DBUG_EVALUATE_IF(keyword,a1,a2) \
-        (_db_strict_keyword_((keyword)) ? (a1) : (a2))
+        (_db_keyword_(0,(keyword), 1) ? (a1) : (a2))
 #define DBUG_PRINT(keyword,arglist) \
         do {_db_pargs_(__LINE__,keyword); _db_doprnt_ arglist;} while(0)
 #define DBUG_PUSH(a1) _db_push_ (a1)

unittest/Makefile.am

@@ -18,7 +18,7 @@ SUBDIRS      = mytap mysys examples
 EXTRA_DIST = unit.pl
 CLEANFILES = unit
 
-unittests = mytap mysys @mysql_se_unittest_dirs@  @mysql_pg_unittest_dirs@
+unittests = mytap mysys @mysql_se_unittest_dirs@  @mysql_pg_unittest_dirs@ ../dbug
 
 test:
 	perl unit.pl run $(unittests)