The world's most popular open source database

MySQL 5.1: mysql/src/5.1-dbg/include/my_dbug.h File Reference

mysql/src/5.1-dbg/include/my_dbug.h File Reference

This graph shows which files directly or indirectly include this file:


Defines
#define	DBUG_ENTER(a)
#define	DBUG_LEAVE _db_return_ (__LINE__, &_db_func_, &_db_file_, &_db_level_)
#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)
#define	DBUG_EXECUTE_IF(keyword, a1) do {if (_db_strict_keyword_ (keyword)) { a1 } } while(0)
#define	DBUG_EVALUATE(keyword, a1, a2) (_db_keyword_(0,(keyword)) ? (a1) : (a2))
#define	DBUG_EVALUATE_IF(keyword, a1, a2) (_db_strict_keyword_((keyword)) ? (a1) : (a2))
#define	DBUG_PRINT(keyword, arglist) do {_db_pargs_(__LINE__,keyword); _db_doprnt_ arglist;} while(0)
#define	DBUG_PUSH(a1) _db_push_ (a1)
#define	DBUG_POP() _db_pop_ ()
#define	DBUG_SET(a1) _db_set_ (0, (a1))
#define	DBUG_SET_INITIAL(a1) _db_set_init_ (a1)
#define	DBUG_PROCESS(a1) _db_process_(a1)
#define	DBUG_FILE _db_fp_()
#define	DBUG_SETJMP(a1) (_db_setjmp_ (), setjmp (a1))
#define	DBUG_LONGJMP(a1, a2) (_db_longjmp_ (), longjmp (a1, a2))
#define	DBUG_DUMP(keyword, a1, a2) _db_dump_(__LINE__,keyword,a1,a2)
#define	DBUG_END() _db_end_ ()
#define	DBUG_LOCK_FILE _db_lock_file_()
#define	DBUG_UNLOCK_FILE _db_unlock_file_()
#define	DBUG_ASSERT(A) assert(A)
#define	DBUG_EXPLAIN(buf, len) _db_explain_(0, (buf),(len))
#define	DBUG_EXPLAIN_INITIAL(buf, len) _db_explain_init_((buf),(len))
Functions
int	_db_keyword_ (struct _db_code_state_ cs, const char keyword)
int	_db_strict_keyword_ (const char *keyword)
int	_db_explain_ (struct _db_code_state_ cs, char buf, int len)
int	_db_explain_init_ (char *buf, int len)
void	_db_setjmp_ (void)
void	_db_longjmp_ (void)
void	_db_process_ (const char *name)
void	_db_push_ (const char *control)
void	_db_pop_ (void)
void	_db_set_ (struct _db_code_state_ cs, const char control)
void	_db_set_init_ (const char *control)
void	_db_enter_ (const char _func_, const char _file_, uint _line_, const char _sfunc_, const char _sfile_, uint _slevel_, char **)
void	_db_return_ (uint _line_, const char _sfunc_, const char _sfile_, uint *_slevel_)
void	_db_pargs_ (uint _line_, const char *keyword)
void _db_doprnt_	_VARARGS ((const char *format,...))
void	_db_dump_ (uint _line_, const char keyword, const char memory, uint length)
void	_db_end_ (void)
void	_db_lock_file_ (void)
void	_db_unlock_file_ (void)
FILE *	_db_fp_ (void)

Define Documentation

#define DBUG_ASSERT ( A ) assert(A)

Definition at line 80 of file my_dbug.h.

#define DBUG_DUMP	(	keyword,
		a1,
		a2	)	_db_dump_(__LINE__,keyword,a1,a2)

#define DBUG_END ( ) _db_end_ ()

Definition at line 77 of file my_dbug.h.

Referenced by my_end().

#define DBUG_ENTER ( a )

Value:

const char *_db_func_, *_db_file_; uint _db_level_; \
        char **_db_framep_; \
        _db_enter_ (a,__FILE__,__LINE__,&_db_func_,&_db_file_,&_db_level_, \
                    &_db_framep_)

Definition at line 50 of file my_dbug.h.

#define DBUG_EVALUATE	(	keyword,
		a1,
		a2	)	(_db_keyword_(0,(keyword)) ? (a1) : (a2))

Definition at line 62 of file my_dbug.h.

#define DBUG_EVALUATE_IF	(	keyword,
		a1,
		a2	)	(_db_strict_keyword_((keyword)) ? (a1) : (a2))

Definition at line 64 of file my_dbug.h.

#define DBUG_EXECUTE	(	keyword,
		a1		)	do {if (_db_keyword_(0, (keyword))) { a1 }} while(0)

#define DBUG_EXECUTE_IF	(	keyword,
		a1		)	do {if (_db_strict_keyword_ (keyword)) { a1 } } while(0)

Definition at line 60 of file my_dbug.h.

Referenced by Format_description_log_event::Format_description_log_event(), ha_commit_trans(), make_global_read_lock_block_commit(), mi_delete(), mi_open(), mi_update(), mi_write(), MYSQL_BIN_LOG::write(), and write_huff_tree().

#define DBUG_EXPLAIN	(	buf,
		len		)	_db_explain_(0, (buf),(len))

Definition at line 81 of file my_dbug.h.

Referenced by sys_var_thd_dbug::value_ptr().

#define DBUG_EXPLAIN_INITIAL	(	buf,
		len		)	_db_explain_init_((buf),(len))

Definition at line 82 of file my_dbug.h.

Referenced by sys_var_thd_dbug::value_ptr().

#define DBUG_FILE _db_fp_()

#define DBUG_LEAVE _db_return_ (__LINE__, &_db_func_, &_db_file_, &_db_level_)

Definition at line 54 of file my_dbug.h.

Referenced by main().

#define DBUG_LOCK_FILE _db_lock_file_()

Definition at line 78 of file my_dbug.h.

Referenced by print_plan(), print_quick(), print_rowid(), print_where(), TEST_filesort(), and TEST_join().

#define DBUG_LONGJMP	(	a1,
		a2		)	(_db_longjmp_ (), longjmp (a1, a2))

Definition at line 75 of file my_dbug.h.

#define DBUG_POP ( ) _db_pop_ ()

Definition at line 69 of file my_dbug.h.

Referenced by filesort(), get_one_option(), mysql_server_end(), ndb_thread_wrapper(), sys_var_thd_dbug::set_default(), and sys_var_thd_dbug::update().

#define DBUG_PRINT	(	keyword,
		arglist		)	do {_db_pargs_(__LINE__,keyword); _db_doprnt_ arglist;} while(0)

Definition at line 66 of file my_dbug.h.

#define DBUG_PROCESS ( a1 ) _db_process_(a1)

Definition at line 72 of file my_dbug.h.

Referenced by main(), and my_init().

#define DBUG_PUSH ( a1 ) _db_push_ (a1)

Definition at line 68 of file my_dbug.h.

Referenced by filesort(), get_one_option(), get_options(), libmysql_init(), main(), mysql_debug(), ndb_std_get_one_option(), static_get_options(), and sys_var_thd_dbug::update().

#define DBUG_RETURN ( a1 ) do {DBUG_LEAVE; return(a1);} while(0)

Definition at line 56 of file my_dbug.h.

#define DBUG_SET ( a1 ) _db_set_ (0, (a1))

Definition at line 70 of file my_dbug.h.

Referenced by get_one_option().

#define DBUG_SET_INITIAL ( a1 ) _db_set_init_ (a1)

Definition at line 71 of file my_dbug.h.

Referenced by get_one_option(), and sys_var_thd_dbug::update().

#define DBUG_SETJMP ( a1 ) (_db_setjmp_ (), setjmp (a1))

Definition at line 74 of file my_dbug.h.

#define DBUG_UNLOCK_FILE _db_unlock_file_()

Definition at line 79 of file my_dbug.h.

Referenced by print_plan(), print_quick(), print_rowid(), print_where(), TEST_filesort(), and TEST_join().

#define DBUG_VOID_RETURN do {DBUG_LEAVE; return;} while(0)

Definition at line 57 of file my_dbug.h.

Function Documentation

void _db_dump_	(	uint	_line_,
		const char *	keyword,
		const char *	memory,
		uint	length
	)

Definition at line 1161 of file dbug.c.

References _db_keyword_(), _dig_vec_upper, dbug_flush(), DoPrefix(), _db_code_state_::func, get_code_state_or_return, Indent(), INDENT, _db_code_state_::level, _db_code_state_::locked, max, min, settings::out_file, pos(), pthread_mutex_lock, _db_code_state_::stack, and TRACING.

01162 {
01163   int pos;
01164   char dbuff[90];
01165 
01166   CODE_STATE *cs=0;
01167   get_code_state_or_return;
01168 
01169   if (_db_keyword_(cs, (char*) keyword))
01170   {
01171     if (!cs->locked)
01172       pthread_mutex_lock(&THR_LOCK_dbug);
01173     DoPrefix(cs, _line_);
01174     if (TRACING)
01175     {
01176       Indent(cs, cs->level + 1);
01177       pos= min(max(cs->level-cs->stack->sub_level,0)*INDENT,80);
01178     }
01179     else
01180     {
01181       fprintf(cs->stack->out_file, "%s: ", cs->func);
01182     }
01183     sprintf(dbuff,"%s: Memory: 0x%lx  Bytes: (%d)\n",
01184             keyword,(ulong) memory, length);
01185     (void) fputs(dbuff,cs->stack->out_file);
01186 
01187     pos=0;
01188     while (length-- > 0)
01189     {
01190       uint tmp= *((unsigned char*) memory++);
01191       if ((pos+=3) >= 80)
01192       {
01193         fputc('\n',cs->stack->out_file);
01194         pos=3;
01195       }
01196       fputc(_dig_vec_upper[((tmp >> 4) & 15)], cs->stack->out_file);
01197       fputc(_dig_vec_upper[tmp & 15], cs->stack->out_file);
01198       fputc(' ',cs->stack->out_file);
01199     }
01200     (void) fputc('\n',cs->stack->out_file);
01201     dbug_flush(cs);
01202   }
01203 }

Here is the call graph for this function:

void _db_end_ ( void )

Definition at line 1473 of file dbug.c.

References FreeState(), get_code_state_or_return, init_settings, settings::next, NULL, and _db_code_state_::stack.

01474 {
01475   struct settings *discard;
01476   CODE_STATE *cs=0;
01477 
01478   get_code_state_or_return;
01479 
01480   while((discard= cs->stack) != NULL) {
01481     if(discard == &init_settings)
01482       break;
01483     cs->stack= discard->next;
01484     FreeState (cs, discard);
01485   }
01486 }

Here is the call graph for this function:

void _db_enter_	(	const char *	_func_,
		const char *	_file_,
		uint	_line_,
		const char **	_sfunc_,
		const char **	_sfile_,
		uint *	_slevel_,
		char ***
	)

int _db_explain_	(	struct _db_code_state_ *	cs,
		char *	buf,
		int	len
	)

Definition at line 831 of file dbug.c.

References DEBUGGING, settings::delay, DEPTH_ON, FILE_ON, settings::flags, FLUSH_ON_WRITE, settings::functions, get_code_state_or_return, settings::keywords, LINE_ON, settings::maxdepth, MAXDEPTH, settings::name, NUMBER_ON, op_bool_to_buf, op_int_to_buf, op_intf_to_buf, op_list_to_buf, op_str_to_buf, OPEN_APPEND, settings::out_file, settings::p_functions, PID_ON, PROCESS_ON, settings::processes, PROFILING, SANITY_CHECK_ON, _db_code_state_::stack, start(), settings::sub_level, TIMESTAMP_ON, and TRACING.

Referenced by _db_explain_init_().

00832 {
00833   char *start=buf, *end=buf+len-4;
00834 
00835   get_code_state_or_return *buf=0;
00836 
00837   op_list_to_buf('d', cs->stack->keywords, DEBUGGING);
00838   op_int_to_buf ('D', cs->stack->delay, 0);
00839   op_list_to_buf('f', cs->stack->functions, cs->stack->functions);
00840   op_bool_to_buf('F', cs->stack->flags & FILE_ON);
00841   op_bool_to_buf('i', cs->stack->flags & PID_ON);
00842   op_list_to_buf('g', cs->stack->p_functions, PROFILING);
00843   op_bool_to_buf('L', cs->stack->flags & LINE_ON);
00844   op_bool_to_buf('n', cs->stack->flags & DEPTH_ON);
00845   op_bool_to_buf('N', cs->stack->flags & NUMBER_ON);
00846   op_str_to_buf(
00847     ((cs->stack->flags & FLUSH_ON_WRITE ? 0 : 32) |
00848      (cs->stack->flags & OPEN_APPEND ? 'A' : 'O')),
00849     cs->stack->name, cs->stack->out_file != stderr);
00850   op_list_to_buf('p', cs->stack->processes, cs->stack->processes);
00851   op_bool_to_buf('P', cs->stack->flags & PROCESS_ON);
00852   op_bool_to_buf('r', cs->stack->sub_level != 0);
00853   op_intf_to_buf('t', cs->stack->maxdepth, MAXDEPTH, TRACING);
00854   op_bool_to_buf('T', cs->stack->flags & TIMESTAMP_ON);
00855   op_bool_to_buf('S', cs->stack->flags & SANITY_CHECK_ON);
00856 
00857   *buf= '\0';
00858   return 0;
00859 
00860 overflow:
00861   *end++= '.';
00862   *end++= '.';
00863   *end++= '.';
00864   *end=   '\0';
00865   return 1;
00866 }

Here is the call graph for this function:

Here is the caller graph for this function:

int _db_explain_init_	(	char *	buf,
		int	len
	)

Definition at line 888 of file dbug.c.

References _db_explain_(), bzero, and init_settings.

00889 {
00890   CODE_STATE cs;
00891   bzero((char*) &cs,sizeof(cs));
00892   cs.stack=&init_settings;
00893   return _db_explain_(&cs, buf, len);
00894 }

Here is the call graph for this function:

FILE* _db_fp_ ( void )

Definition at line 1545 of file dbug.c.

References get_code_state_or_return, NULL, settings::out_file, and _db_code_state_::stack.

01546 {
01547   CODE_STATE *cs=0;
01548   get_code_state_or_return NULL;
01549   return cs->stack->out_file;
01550 }

int _db_keyword_	(	struct _db_code_state_ *	cs,
		const char *	keyword
	)

Definition at line 1607 of file dbug.c.

References DEBUGGING, FALSE, _db_code_state_::func, settings::functions, get_code_state_or_return, InList(), settings::keywords, _db_code_state_::level, settings::maxdepth, _db_code_state_::process, settings::processes, _db_code_state_::stack, and TRACING.

Referenced by _db_doprnt_(), _db_dump_(), and _db_strict_keyword_().

01608 {
01609   get_code_state_or_return FALSE;
01610 
01611   return (DEBUGGING &&
01612           (!TRACING || cs->level <= cs->stack->maxdepth) &&
01613           InList(cs->stack->functions, cs->func) &&
01614           InList(cs->stack->keywords, keyword) &&
01615           InList(cs->stack->processes, cs->process));
01616 }

Here is the call graph for this function:

Here is the caller graph for this function:

void _db_lock_file_ ( void )

Definition at line 2236 of file dbug.c.

References get_code_state_or_return, _db_code_state_::locked, and pthread_mutex_lock.

02237 {
02238   CODE_STATE *cs=0;
02239   get_code_state_or_return;
02240   pthread_mutex_lock(&THR_LOCK_dbug);
02241   cs->locked=1;
02242 }

void _db_longjmp_ ( void )

void _db_pargs_	(	uint	_line_,
		const char *	keyword
	)

Definition at line 1079 of file dbug.c.

References get_code_state_or_return, _db_code_state_::u_keyword, and _db_code_state_::u_line.

01080 {
01081   CODE_STATE *cs=0;
01082   get_code_state_or_return;
01083   cs->u_line= _line_;
01084   cs->u_keyword= (char*) keyword;
01085 }

void _db_pop_ ( void )

Definition at line 738 of file dbug.c.

References FreeState(), get_code_state_or_return, settings::next, NULL, and _db_code_state_::stack.

00739 {
00740   struct settings *discard;
00741   CODE_STATE *cs=0;
00742 
00743   get_code_state_or_return;
00744 
00745   discard= cs->stack;
00746   if (discard->next != NULL)
00747   {
00748     cs->stack= discard->next;
00749     FreeState(cs, discard);
00750   }
00751 }

Here is the call graph for this function:

void _db_process_ ( const char * name )

Definition at line 404 of file dbug.c.

References db_process, get_code_state_or_return, and _db_code_state_::process.

00405 {
00406   CODE_STATE *cs=0;
00407 
00408   if (!db_process)
00409     db_process= name;
00410   
00411   get_code_state_or_return;
00412   cs->process= name;
00413 }

void _db_push_ ( const char * control )

Definition at line 690 of file dbug.c.

References _db_set_(), get_code_state_or_return, and PushState().

00691 {
00692   CODE_STATE *cs=0;
00693   get_code_state_or_return;
00694   PushState(cs);
00695   _db_set_(cs, control);
00696 }

Here is the call graph for this function:

void _db_return_	(	uint	_line_,
		const char **	_sfunc_,
		const char **	_sfile_,
		uint *	_slevel_
	)

Definition at line 1010 of file dbug.c.

References _sanity(), Clock(), dbug_flush(), DoPrefix(), DoProfile(), DoTrace(), ERR_MISSING_RETURN, errno, _db_code_state_::file, settings::flags, _db_code_state_::framep, _db_code_state_::func, get_code_state_or_return, Indent(), _db_code_state_::level, _db_code_state_::locked, NULL, settings::out_file, _db_code_state_::process, settings::prof_file, PROF_XFMT, pthread_mutex_lock, SANITY_CHECK_ON, and _db_code_state_::stack.

01012 {
01013   int save_errno=errno;
01014   CODE_STATE *cs=0;
01015   get_code_state_or_return;
01016 
01017   if (cs->level != (int) *_slevel_)
01018   {
01019     if (!cs->locked)
01020       pthread_mutex_lock(&THR_LOCK_dbug);
01021     (void) fprintf(cs->stack->out_file, ERR_MISSING_RETURN, cs->process,
01022                    cs->func);
01023     dbug_flush(cs);
01024   }
01025   else
01026   {
01027 #ifdef SAFEMALLOC
01028     if (cs->stack->flags & SANITY_CHECK_ON)
01029     {
01030       if (_sanity(*_sfile_,_line_))
01031         cs->stack->flags &= ~SANITY_CHECK_ON;
01032     }
01033 #endif
01034 #ifndef THREAD
01035     if (DoProfile(cs))
01036       (void) fprintf(cs->stack->prof_file, PROF_XFMT, Clock(), cs->func);
01037 #endif
01038     if (DoTrace(cs))
01039     {
01040       if (!cs->locked)
01041         pthread_mutex_lock(&THR_LOCK_dbug);
01042       DoPrefix(cs, _line_);
01043       Indent(cs, cs->level);
01044       (void) fprintf(cs->stack->out_file, "<%s\n", cs->func);
01045       dbug_flush(cs);
01046     }
01047   }
01048   cs->level= *_slevel_-1;
01049   cs->func= *_sfunc_;
01050   cs->file= *_sfile_;
01051 #ifndef THREAD
01052   if (cs->framep != NULL)
01053     cs->framep= (char **) *cs->framep;
01054 #endif
01055   errno=save_errno;
01056 }

Here is the call graph for this function:

void _db_set_	(	struct _db_code_state_ *	cs,
		const char *	control
	)

Definition at line 447 of file dbug.c.

References atoi(), DBUGCloseFile(), DBUGOpenFile(), DbugStrTok(), DEBUG_ON, DEBUGGING, settings::delay, DEPTH_ON, FILE_ON, settings::flags, FLUSH_ON_WRITE, FreeList(), settings::functions, functions, get_code_state_or_return, init_settings, is_shared, settings::keywords, LINE_ON, ListAdd(), ListCopy(), ListDel(), settings::maxdepth, MAXDEPTH, settings::name, settings::next, NULL, NUMBER_ON, OPEN_APPEND, OpenProfile(), settings::out_file, settings::p_functions, PID_ON, PROCESS_ON, settings::processes, settings::prof_file, PROF_FILE, PROFILE_ON, SANITY_CHECK_ON, _db_code_state_::stack, settings::sub_level, TIMESTAMP_ON, and TRACE_ON.

Referenced by _db_push_(), and _db_set_init_().

00448 {
00449   const char *end;
00450   int rel=0;
00451 
00452   get_code_state_or_return;
00453 
00454   if (control[0] == '-' && control[1] == '#')
00455     control+=2;
00456 
00457   rel= control[0] == '+' || control[0] == '-';
00458   if (!rel || (!cs->stack->out_file && !cs->stack->next))
00459   {
00460     cs->stack->flags= 0;
00461     cs->stack->delay= 0;
00462     cs->stack->maxdepth= 0;
00463     cs->stack->sub_level= 0;
00464     cs->stack->out_file= stderr;
00465     cs->stack->prof_file= NULL;
00466     cs->stack->functions= NULL;
00467     cs->stack->p_functions= NULL;
00468     cs->stack->keywords= NULL;
00469     cs->stack->processes= NULL;
00470   }
00471   else if (!cs->stack->out_file)
00472   {
00473     cs->stack->flags= cs->stack->next->flags;
00474     cs->stack->delay= cs->stack->next->delay;
00475     cs->stack->maxdepth= cs->stack->next->maxdepth;
00476     cs->stack->sub_level= cs->stack->next->sub_level;
00477     strcpy(cs->stack->name, cs->stack->next->name);
00478     cs->stack->out_file= cs->stack->next->out_file;
00479     cs->stack->prof_file= cs->stack->next->prof_file;
00480     if (cs->stack->next == &init_settings)
00481     {
00482       /* never share with the global parent - it can change under your feet */
00483       cs->stack->functions= ListCopy(init_settings.functions);
00484       cs->stack->p_functions= ListCopy(init_settings.p_functions);
00485       cs->stack->keywords= ListCopy(init_settings.keywords);
00486       cs->stack->processes= ListCopy(init_settings.processes);
00487     }
00488     else
00489     {
00490       cs->stack->functions= cs->stack->next->functions;
00491       cs->stack->p_functions= cs->stack->next->p_functions;
00492       cs->stack->keywords= cs->stack->next->keywords;
00493       cs->stack->processes= cs->stack->next->processes;
00494     }
00495   }
00496 
00497   end= DbugStrTok(control);
00498   while (1)
00499   {
00500     int c, sign= (*control == '+') ? 1 : (*control == '-') ? -1 : 0;
00501     if (sign) control++;
00502     if (!rel) sign=0;
00503     c= *control++;
00504     if (*control == ',') control++;
00505     /* XXX when adding new cases here, don't forget _db_explain_ ! */
00506     switch (c) {
00507     case 'd':
00508       if (sign < 0 && control == end)
00509       {
00510         if (!is_shared(cs->stack, keywords))
00511           FreeList(cs->stack->keywords);
00512         cs->stack->keywords=NULL;
00513         cs->stack->flags &= ~DEBUG_ON;
00514         break;
00515       }
00516       if (rel && is_shared(cs->stack, keywords))
00517         cs->stack->keywords= ListCopy(cs->stack->keywords);
00518       if (sign < 0)
00519       {
00520         if (DEBUGGING)
00521           cs->stack->keywords= ListDel(cs->stack->keywords, control, end);
00522       break;
00523       }
00524       cs->stack->keywords= ListAdd(cs->stack->keywords, control, end);
00525       cs->stack->flags |= DEBUG_ON;
00526       break;
00527     case 'D':
00528       cs->stack->delay= atoi(control);
00529       break;
00530     case 'f':
00531       if (sign < 0 && control == end)
00532       {
00533         if (!is_shared(cs->stack,functions))
00534           FreeList(cs->stack->functions);
00535         cs->stack->functions=NULL;
00536         break;
00537       }
00538       if (rel && is_shared(cs->stack,functions))
00539         cs->stack->functions= ListCopy(cs->stack->functions);
00540       if (sign < 0)
00541         cs->stack->functions= ListDel(cs->stack->functions, control, end);
00542       else
00543         cs->stack->functions= ListAdd(cs->stack->functions, control, end);
00544       break;
00545     case 'F':
00546       if (sign < 0)
00547         cs->stack->flags &= ~FILE_ON;
00548       else
00549         cs->stack->flags |= FILE_ON;
00550       break;
00551     case 'i':
00552       if (sign < 0)
00553         cs->stack->flags &= ~PID_ON;
00554       else
00555         cs->stack->flags |= PID_ON;
00556       break;
00557 #ifndef THREAD
00558     case 'g':
00559       if (OpenProfile(cs, PROF_FILE))
00560       {
00561         cs->stack->flags |= PROFILE_ON;
00562         cs->stack->p_functions= ListAdd(cs->stack->p_functions, control, end);
00563       }
00564       break;
00565 #endif
00566     case 'L':
00567       if (sign < 0)
00568         cs->stack->flags &= ~LINE_ON;
00569       else
00570         cs->stack->flags |= LINE_ON;
00571       break;
00572     case 'n':
00573       if (sign < 0)
00574         cs->stack->flags &= ~DEPTH_ON;
00575       else
00576         cs->stack->flags |= DEPTH_ON;
00577       break;
00578     case 'N':
00579       if (sign < 0)
00580         cs->stack->flags &= ~NUMBER_ON;
00581       else
00582         cs->stack->flags |= NUMBER_ON;
00583       break;
00584     case 'A':
00585     case 'O':
00586       cs->stack->flags |= FLUSH_ON_WRITE;
00587       /* fall through */
00588     case 'a':
00589     case 'o':
00590       if (sign < 0)
00591       {
00592         if (!is_shared(cs->stack, out_file))
00593           DBUGCloseFile(cs, cs->stack->out_file);
00594         cs->stack->flags &= ~FLUSH_ON_WRITE;
00595         cs->stack->out_file= stderr;
00596         break;
00597       }
00598       if (c == 'a' || c == 'A')
00599         cs->stack->flags |= OPEN_APPEND;
00600       else
00601         cs->stack->flags &= ~OPEN_APPEND;
00602       if (control != end)
00603         DBUGOpenFile(cs, control, end, cs->stack->flags & OPEN_APPEND);
00604       else
00605         DBUGOpenFile(cs, "-",0,0);
00606       break;
00607     case 'p':
00608       if (sign < 0 && control == end)
00609       {
00610         if (!is_shared(cs->stack,processes))
00611           FreeList(cs->stack->processes);
00612         cs->stack->processes=NULL;
00613         break;
00614       }
00615       if (rel && is_shared(cs->stack, processes))
00616         cs->stack->processes= ListCopy(cs->stack->processes);
00617       if (sign < 0)
00618         cs->stack->processes= ListDel(cs->stack->processes, control, end);
00619       else
00620         cs->stack->processes= ListAdd(cs->stack->processes, control, end);
00621       break;
00622     case 'P':
00623       if (sign < 0)
00624         cs->stack->flags &= ~PROCESS_ON;
00625       else
00626         cs->stack->flags |= PROCESS_ON;
00627       break;
00628     case 'r':
00629       cs->stack->sub_level= cs->level;
00630       break;
00631     case 't':
00632       if (sign < 0)
00633       {
00634         if (control != end)
00635           cs->stack->maxdepth-= atoi(control);
00636         else
00637           cs->stack->maxdepth= 0;
00638       }
00639       else
00640       {
00641         if (control != end)
00642           cs->stack->maxdepth+= atoi(control);
00643         else
00644           cs->stack->maxdepth= MAXDEPTH;
00645       }
00646       if (cs->stack->maxdepth > 0)
00647         cs->stack->flags |= TRACE_ON;
00648       else
00649         cs->stack->flags &= ~TRACE_ON;
00650       break;
00651     case 'T':
00652       if (sign < 0)
00653         cs->stack->flags &= ~TIMESTAMP_ON;
00654       else
00655         cs->stack->flags |= TIMESTAMP_ON;
00656       break;
00657     case 'S':
00658       if (sign < 0)
00659         cs->stack->flags &= ~SANITY_CHECK_ON;
00660       else
00661         cs->stack->flags |= SANITY_CHECK_ON;
00662       break;
00663     }
00664     if (!*end)
00665       break;
00666     control=end+1;
00667     end= DbugStrTok(control);
00668   }
00669 }

Here is the call graph for this function:

Here is the caller graph for this function:

void _db_set_init_ ( const char * control )

Definition at line 713 of file dbug.c.

References _db_set_(), bzero, and init_settings.

00714 {
00715   CODE_STATE cs;
00716   bzero((char*) &cs,sizeof(cs));
00717   cs.stack=&init_settings;
00718   _db_set_(&cs, control);
00719 }

Here is the call graph for this function:

void _db_setjmp_ ( void )

int _db_strict_keyword_ ( const char * keyword )

Definition at line 1573 of file dbug.c.

References _db_keyword_(), DEBUGGING, FALSE, get_code_state_or_return, settings::keywords, NULL, and _db_code_state_::stack.

01574 {
01575   CODE_STATE *cs=0;
01576   get_code_state_or_return FALSE;
01577   if (!DEBUGGING || cs->stack->keywords == NULL)
01578     return FALSE;
01579   return _db_keyword_(cs, keyword);
01580 }

Here is the call graph for this function:

void _db_unlock_file_ ( void )

Definition at line 2244 of file dbug.c.

References get_code_state_or_return, _db_code_state_::locked, and pthread_mutex_unlock.

02245 {
02246   CODE_STATE *cs=0;
02247   get_code_state_or_return;
02248   cs->locked=0;
02249   pthread_mutex_unlock(&THR_LOCK_dbug);
02250 }

void _db_doprnt_ _VARARGS ( (const char *format,...) )

Generated on Sat Sep 9 01:33:51 2006 for MySQL 5.1 by

1.4.7

The world's most popular open source database

mysql/src/5.1-dbg/include/my_dbug.h File Reference

Defines

Functions

Define Documentation

Function Documentation