自学教程：C++ DEBUG_MESSAGE函数代码示例

void ShaderProgram::Link(){    glLinkProgram( handle_ );    GLint status;    glGetProgramiv( handle_, GL_LINK_STATUS, &status );    if( status == GL_FALSE ){        linked_ = false;        DEBUG_MESSAGE("Failed to link shader program");        GLint log_length;        glGetProgramiv( handle_, GL_INFO_LOG_LENGTH, &log_length );        if( log_length > 0 ){            char *log = new char[log_length];            GLsizei written;            glGetProgramInfoLog(handle_, log_length, &written, log);            DEBUG_MESSAGE(log);            delete[] log;        }    }else{        linked_ = true;        DEBUG_MESSAGE("Shader program linked successfully.");    }}

void GameLogic::AddObject( GameObject* n_object ){	m_objects.push_back(std::shared_ptr<GameObject>(n_object));	// sort; as finding will require a sorted set	std::sort(m_objects.begin(),m_objects.end(),		[](const std::shared_ptr<GameObject> & a, const std::shared_ptr<GameObject> & b)->bool		{			return a->GetID() < b->GetID();		});	DEBUG_MESSAGE("Added object with ID " << n_object->GetID());}

void EventGoersView::refresh(){  eventGoersModel->setQuery(    "SELECT " +     DataStore::getEventGoerUsernameColName() + ", " +    DataStore::getEventGoersIdColName() +    " FROM " + DataStore::getEventGoersTableName() +     " WHERE " + DataStore::getEventGoerStateColName() +     "=/"" + DataStore::getEventGoerInEventState() + "/";",    dataStore->getDatabaseConnection());  if(eventGoersModel->lastError().type() != QSqlError::NoError){    DEBUG_MESSAGE("Event goeres error: " <<eventGoersModel->lastError().text().toStdString())  }}

//// Called by personality handler during phase 2 to get LSDA for current frame//EXPORT uintptr_t _Unwind_GetLanguageSpecificData(struct _Unwind_Context* context){	unw_cursor_t* cursor = (unw_cursor_t*)context;	unw_proc_info_t frameInfo;	uintptr_t result = 0;	if ( unw_get_proc_info(cursor, &frameInfo) == UNW_ESUCCESS ) 		result = frameInfo.lsda;	DEBUG_PRINT_API("_Unwind_GetLanguageSpecificData(context=%p) => 0x%lX/n", context, result);	if ( result != 0 ) {		if ( *((uint8_t*)result) != 0xFF ) 			DEBUG_MESSAGE("lsda at 0x%lX does not start with 0xFF/n", result);	}	return result;}

/* * hexter_get_program * * implements DSSI (*get_program)() */const DSSI_Program_Descriptor *hexter_get_program(LADSPA_Handle handle, unsigned long index){    hexter_instance_t *instance = (hexter_instance_t *)handle;    static DSSI_Program_Descriptor pd;    DEBUG_MESSAGE(DB_DSSI, " hexter_get_program called with %lu/n", index);    if (index < 128) {        hexter_instance_set_program_descriptor(instance, &pd, 0, index);        return &pd;    }    return NULL;}

void ParseThread::ProcessIncludes(ParseRequest* req){	DEBUG_MESSAGE( wxString::Format(wxT("ProcessIncludes -> started")) ) ;        std::set<std::string> *newSet = new std::set<std::string>();	FindIncludedFiles(req, newSet);#ifdef PARSE_THREAD_DBG	std::set<std::string>::iterator iter = newSet->begin();	for(; iter != newSet->end(); iter++) {		wxString fileN((*iter).c_str(), wxConvUTF8);		DEBUG_MESSAGE( wxString::Format(wxT("ParseThread::ProcessIncludes -> %s"), fileN.c_str() ) );	}#endif	// collect the results    if ( req->_evtHandler ) {        wxCommandEvent event(wxEVT_PARSE_THREAD_SCAN_INCLUDES_DONE);        event.SetClientData(newSet);        event.SetInt((int)req->_quickRetag);        req->_evtHandler->AddPendingEvent(event);    }}

Skeleton KinectComp::GetSkeleton(unsigned long id){	if (mpKinect == NULL)	{		PrintMessage(DEBUG_MESSAGE("Can't get a handle of Kinect API").c_str());		Skeleton skel;		const Position invalidPosition(std::numeric_limits<float>::quiet_NaN()			, std::numeric_limits<float>::quiet_NaN()			, std::numeric_limits<float>::quiet_NaN());		skel.result = Skeleton::NOT_TRACKED;		skel.position = invalidPosition;		for (int i = 0; i < Skeleton::JOINT_COUNT; i++)		{			skel.joints[i] = invalidPosition;		}		return skel;	}	Skeleton skel(id);	if (mpKinect->GetSkeleton(skel, id) != API_SUCCESS)	{		PrintMessage(DEBUG_MESSAGE("Can't get skeleton").c_str());		const Position invalidPosition(std::numeric_limits<float>::quiet_NaN()			, std::numeric_limits<float>::quiet_NaN()			, std::numeric_limits<float>::quiet_NaN());		skel.userID = id;		skel.result = Skeleton::NOT_TRACKED;		skel.position = invalidPosition;		for (int i = 0; i < Skeleton::JOINT_COUNT; i++)		{			skel.joints[i] = invalidPosition;		}	}	return skel;}

	void OpenNINetwork::Release()	{#ifdef NETWORK_USE_THREAD		if( mIsServer && mIsRunning )		{			DEBUG_MESSAGE( "Stop running thread on network/n" );			assert( _thread );			mIsRunning = false;			//_thread->join();			_thread.reset();		}#endif		::closesocket( mSocketId );		::WSACleanup();	}

NTSTATUS abort_endpoint(libusb_device_t *dev, int endpoint, int timeout){  NTSTATUS status = STATUS_SUCCESS;  URB urb;  DEBUG_PRINT_NL();  DEBUG_MESSAGE("abort_endpoint(): endpoint 0x%02x/n", endpoint);  DEBUG_MESSAGE("abort_endpoint(): timeout %d/n", timeout);  memset(&urb, 0, sizeof(struct _URB_PIPE_REQUEST));  if(!dev->config.value)    {      DEBUG_ERROR("abort_endpoint(): invalid configuration 0");      return STATUS_INVALID_DEVICE_STATE;    }  if(!get_pipe_handle(dev, endpoint, &urb.UrbPipeRequest.PipeHandle))    {      DEBUG_ERROR("abort_endpoint(): getting endpoint pipe failed");      return STATUS_INVALID_PARAMETER;    }  urb.UrbHeader.Length = (USHORT) sizeof(struct _URB_PIPE_REQUEST);  urb.UrbHeader.Function = URB_FUNCTION_ABORT_PIPE;  status = call_usbd(dev, &urb, IOCTL_INTERNAL_USB_SUBMIT_URB, timeout);    if(!NT_SUCCESS(status) || !USBD_SUCCESS(urb.UrbHeader.Status))    {      DEBUG_ERROR("abort_endpoint(): request failed: status: 0x%x, "                  "urb-status: 0x%x", status, urb.UrbHeader.Status);    }    return status;}

bool ShaderImpl_DirectX9::Compile(const char *code, int type){	if (!code) return false;	LPD3DXBUFFER pCode = NULL;	LPD3DXBUFFER pError = NULL;	switch(type)	{	case Shader::TYPE_VERTEX:		{			if (D3DXCompileShader(code, strlen(code), NULL, NULL, "vs_main", "vs_2_0", 0, &pCode, &pError, &_vs_constTable) < 0)			{				DEBUG_MESSAGE((char *)pError->GetBufferPointer());				return false;			}			setupConstantData(UNIFORM_VS, _vs_constTable);			DrawManager::GetDeviceHandle()->CreateVertexShader(				reinterpret_cast<DWORD*>(pCode->GetBufferPointer()), &_vertexShader);			pCode->Release();		} return true;	case Shader::TYPE_PIXEL:		{			if (D3DXCompileShader(code, strlen(code), NULL, NULL, "ps_main", "ps_3_0", 0, &pCode, &pError, &_ps_constTable) < 0)			{				DEBUG_MESSAGE((char *)pError->GetBufferPointer());				return false;			}			setupConstantData(UNIFORM_PS, _ps_constTable);			DrawManager::GetDeviceHandle()->CreatePixelShader(				reinterpret_cast<DWORD*>(pCode->GetBufferPointer()), &_pixelShader);			pCode->Release();		} return true;	default: return false;	}}

static voidpop_input (void){  input_block *tmp = isp->prev;  switch (isp->type)    {    case INPUT_STRING:    case INPUT_MACRO:      break;    case INPUT_FILE:      if (debug_level & DEBUG_TRACE_INPUT)        {          if (tmp)            DEBUG_MESSAGE2 ("input reverted to %s, line %d",                            tmp->file, tmp->line);          else            DEBUG_MESSAGE ("input exhausted");        }      if (ferror (isp->u.u_f.fp))        {          M4ERROR ((warning_status, 0, "read error"));          if (isp->u.u_f.close)            fclose (isp->u.u_f.fp);          retcode = EXIT_FAILURE;        }      else if (isp->u.u_f.close && fclose (isp->u.u_f.fp) == EOF)        {          M4ERROR ((warning_status, errno, "error reading file"));          retcode = EXIT_FAILURE;        }      start_of_input_line = isp->u.u_f.advance;      output_current_line = -1;      break;    default:      M4ERROR ((warning_status, 0,                "INTERNAL ERROR: input stack botch in pop_input ()"));      abort ();    }  obstack_free (current_input, isp);  next = NULL; /* might be set in push_string_init () */  isp = tmp;  input_change = true;}

int readMessage(MessageContainer* container, int fd){    int result;    char readChar;        DEBUG(2, "reading fifo");    while ((result = read(fd, &readChar, 1u)) == 1u)    {        if (readChar != '/n')        {            readBuffer[readBufferPos] = readChar;            readBufferPos += 1;                        if (readBufferPos == READ_BUFFER_SIZE)            {                perror("message too long!!!");                return -1;            }        }        else        {            size_t dataLength;            unsigned char *decodedData;                        readBuffer[readBufferPos] = '/0';            DEBUG(2, "message received:");            DEBUG(2, readBuffer);                        DEBUG(3, "decoding data");            decodedData = base64_decode(readBuffer, readBufferPos, &dataLength);            memcpy((void*)container,                    (void*)decodedData,                    (dataLength <= sizeof(MessageContainer) ? dataLength : sizeof(MessageContainer)));            free(decodedData);            DEBUG_MESSAGE(3, container);                        readBufferPos = 0;            return 1;        }    }        /*if (result == -1)    {        ERROR("error reading fifo");    }*/        return result;}

static int lsapi_activate_user_ini_finally(_lsapi_activate_user_ini_ctx *ctx,                                           void* next){    int rc = SUCCESS;    fn_activate_user_ini_chain_t *fn_next = next;    DEBUG_MESSAGE("calling php_ini_activate_config()");    php_ini_activate_config(&ctx->entry->user_config, PHP_INI_PERDIR,                            PHP_INI_STAGE_HTACCESS);    if (*fn_next) {        rc = (*fn_next)(ctx, fn_next + 1);    }    return rc;}

/* Callback from the ADC device */static void ADCCallback(void *pCBParam, uint32_t Event, void *pArg){    switch (Event)    {    case ADI_ADC_EVENT_BUFFER_PROCESSED:             adi_gpio_SetHigh(LED4);             adi_gpio_SetLow(DBG_ADC_PIN);                            DEBUG_MESSAGE("%d,%d/n",cnt_samples,ADC_DataBuffer[0]);                     cnt_samples++;        break;    default:        break;    }}

/* * This function should locate every segment of EDID with understandable blocks and return * the next segment number, or zero if finished. */DEPLINT parse_edid(EdidInfo e,BYTE *d){	DEPLINT i;	if (!((d[0] == 0)||(d[0] == 2)||(d[0] == 0xF0)||(d[0x80] == 0)||(d[0x80] == 2)||(d[0x80] == 0xF0)))	{		ERROR_MESSAGE("Error: Trying to parse edid segment with no valid blocks");		// to keep from returning a strange value		segment_number[0] = 0;		segment_number_counter = 0;	}	if ((d[0]==0) && (d[1]==0xFF))	{		parse_0_block(e,d);		if (e->edid_extensions <= 1)			segment_number[0] = 0;		segment_number_counter = 0;	}	if (d[0x00]==0xF0)	{		parse_block_map(d,0x00);	}	if (d[0x80]==0xF0)	{		parse_block_map(d,0x80);	}	for (i = 0; i < 2; i++)	{		if ((d[i*0x80])==0x2)		{			DEBUG_MESSAGE("cea extension block found/n");			parse_cea_block(e,d,i*0x80);		}	}	if ((segment_number[segment_number_counter]==0)&&(e->edid_extensions>127))		return 0x40;	else		segment_number_counter++;        return segment_number[segment_number_counter-1];}

////  FUNCTION: register_window_class()////  PURPOSE: Registers the window class.//static ATOM register_window_class( HINSTANCE application_instance,                                   char const* class_name,                                   int icon_id ){    WNDCLASSEX class_data;    HANDLE new_cursor_image_handle = LoadImage(                                         application_instance,					// handle to instance                                         MAKEINTRESOURCE(IDC_EMPTY_CURSOR),		// name or identifier of the image                                         IMAGE_CURSOR,							// image type                                         32,										// desired width                                         32,										// desired height                                         LR_CREATEDIBSECTION						// load options                                     );    if ( new_cursor_image_handle == NULL )    {#ifndef NDEBUG        char * msg = NULL;        // reinterpret_cast?!?!? Don't blame me, that's how FormatMessage is defined to work...        FormatMessage( FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_IGNORE_INSERTS,                       0, GetLastError(), 0, reinterpret_cast< char * >( &msg ), 1, NULL );        std::string final_message = "LoadImage(cursor) failed: ";        final_message += msg;        final_message += "/n";        LocalFree( msg );        DEBUG_MESSAGE( final_message.c_str() );#endif        new_cursor_image_handle = LoadCursor( NULL, IDC_ARROW );    }    class_data.cbSize = sizeof(WNDCLASSEX);    class_data.style		 = CS_HREDRAW | CS_VREDRAW | CS_DBLCLKS;    class_data.lpfnWndProc	 = (WNDPROC)window_handler;    class_data.cbClsExtra	 = 0;    class_data.cbWndExtra	 = 0;    class_data.hInstance	 = application_instance;    class_data.hIcon		 = LoadIcon(application_instance, MAKEINTRESOURCE( icon_id ) );    class_data.hCursor		 = (HCURSOR)new_cursor_image_handle;    class_data.hbrBackground = 0;    class_data.lpszMenuName	 = 0;    class_data.lpszClassName = class_name;    class_data.hIconSm		 = 0;    return RegisterClassEx(&class_data);}

/****************************************************************************** * Function Name: CreateLogFile * * Inputs       : eLogFile * Outputs      : - * Returns      :  * Globals Used : - * * Description  :  *****************************************************************************/IMG_INTERNAL IMG_BOOL CreateLogFile(LogFile eLogFile, IMG_CHAR *pszFileName){	FILE     *LogFile = NULL;	IMG_BOOL  bChangedToLogFileDir = IMG_FALSE;	if (eLogFile >= LOGFILE_LAST_LOG_FILE)	{		return IMG_FALSE;	}	if(ChangeDir("logfiles"))	{		if ( MakeDir("logfiles") == 0)		{			ChangeDir("logfiles");			bChangedToLogFileDir = IMG_TRUE;		}		else		{			bChangedToLogFileDir = IMG_FALSE;		}	}	else	{		bChangedToLogFileDir = IMG_TRUE;	}	if (pszFileName)	{		LogFile = fopen(pszFileName, "wc");	}	if (bChangedToLogFileDir)	{		ChangeDir("..");	}	gLogFiles[eLogFile] = LogFile;	if (!LogFile)	{		DEBUG_MESSAGE(("CreateLogFile: Failed to create logfile /n"));		return IMG_FALSE;	}	return IMG_TRUE;}

// Returns a list of every tower owned by the given playerTArray<TowerData> AVisionDeviceReceiver::GetTowers(int32 PlayerID, bool ChangeStatus){	TArray<TowerData> Results;	if (PlayerID < 0 || PlayerID >= TowerList.Num()){		DEBUG_MESSAGE(*FString::Printf(TEXT("%d, %d"), PlayerID, TowerList.Num()));		return Results;	}    for (auto Tower : TowerList[PlayerID]){        Results.Add(Tower);        if (ChangeStatus){            if (Tower.Status == TS_New) Tower.Status = TS_Normal;			else if (Tower.Status == TS_Removed) Tower.Status = TS_Gone;			else if (Tower.Status == TS_Restored) Tower.Status = TS_Normal;        }    }    return Results;}

void ParseThread::GetFileListToParse(const wxString& filename, wxArrayString& arrFiles){	if ( !this->IsCrawlerEnabled() ) {		return;	}	{		wxCriticalSectionLocker locker( TagsManagerST::Get()->m_crawlerLocker );		wxArrayString includePaths, excludePaths;		GetSearchPaths( includePaths, excludePaths );                fcFileOpener::Instance()->ClearResults();		fcFileOpener::Instance()->ClearSearchPath();		for(size_t i=0; i<includePaths.GetCount(); i++) {			fcFileOpener::Instance()->AddSearchPath( includePaths.Item(i).mb_str(wxConvUTF8).data() );		}		for(size_t i=0; i<excludePaths.GetCount(); i++) {			fcFileOpener::Instance()->AddExcludePath(excludePaths.Item(i).mb_str(wxConvUTF8).data());		}		// Invoke the crawler		const wxCharBuffer cfile = filename.mb_str(wxConvUTF8);		// Skip binary files		if(TagsManagerST::Get()->IsBinaryFile(filename)) {			DEBUG_MESSAGE( wxString::Format(wxT("Skipping binary file %s"), filename.c_str()) );			return;		}		// Before using the 'crawlerScan' we lock it, since it is not mt-safe		crawlerScan( cfile.data() );	}	std::set<std::string> fileSet = fcFileOpener::Instance()->GetResults();	std::set<std::string>::iterator iter = fileSet.begin();	for (; iter != fileSet.end(); iter++ ) {		wxFileName fn(wxString((*iter).c_str(), wxConvUTF8));		fn.MakeAbsolute();		if ( arrFiles.Index(fn.GetFullPath()) == wxNOT_FOUND ) {			arrFiles.Add(fn.GetFullPath());		}	}}

NTSTATUS release_all_interfaces(libusb_device_t *dev, FILE_OBJECT *file_object){  int i;    DEBUG_MESSAGE("release_all_interfaces(): releasing all interfaces"                " bound to file object 0x%x", file_object);  for(i = 0; i < LIBUSB_MAX_NUMBER_OF_INTERFACES; i++)    {      if(dev->config.interfaces[i].file_object == file_object)        {          dev->config.interfaces[i].file_object = NULL;        }    }  return STATUS_SUCCESS;}

std::map< std::string, GLint > ShaderProgram::GetActiveAttribsMap() const{    std::map< std::string, GLint > active_attribs;    GLint max_length, num_attribs;    glGetProgramiv( handle_, GL_ACTIVE_ATTRIBUTES, &num_attribs );    glGetProgramiv( handle_, GL_ACTIVE_ATTRIBUTE_MAX_LENGTH, &max_length );    GLint written, size, location;    GLenum type;    GLchar* name = new char[max_length];    for( int i = 0; i < num_attribs; i++ ){        glGetActiveUniform( handle_, i, max_length, &written, &size, &type, name );        location = glGetUniformLocation( handle_, name);        active_attribs[name] = location;        DEBUG_MESSAGE("Attrib " << name << " - Location " << location);    }    return active_attribs;}

	DFORCEINLINE static bool logError(unsigned int shader, int status) {		if (!status)		{			GLint infoLen = 0;			glGetShaderiv(shader, GL_INFO_LOG_LENGTH, &infoLen);			if (infoLen > 1)			{				char* infoLog = (char*)malloc(sizeof(char) * infoLen);				glGetShaderInfoLog(shader, infoLen, NULL, infoLog);				DEBUG_MESSAGE("Error compiling shader:/n" << infoLog);				free(infoLog);			}			return false;		}		return true;	}

API2::Test2::Context::Context(API2::StrategyParameters *params):  API2::SGContext(params, "CustomTest2"),  _Instrument(NULL),  _userParams(){  API2::UserParams *customOMMParams = (API2::UserParams *)params->getInfo();  DEBUG_MESSAGE(reqQryDebugLog(), __PRETTY_FUNCTION__ );  customOMMParams->dump();  if(!setInternalParameters(customOMMParams))  {    reqAddStrategyComment(API2::CONSTANTS::RSP_StrategyComment_STRATEGY_ERROR_STATE);    reqTerminateStrategy();  }}

/* * hexter_instance_note_off * * handle a note off message */voidhexter_instance_note_off(hexter_instance_t *instance, unsigned char key,                         unsigned char rvelocity){    int i;    dx7_voice_t *voice;    hexter_instance_remove_held_key(instance, key);    for (i = 0; i < instance->max_voices; i++) {        voice = instance->voice[i];        if (instance->monophonic ? (_PLAYING(voice)) :                                   (_ON(voice) && (voice->key == key))) {            DEBUG_MESSAGE(DB_NOTE, " hexter_instance_note_off: key %d rvel %d voice %d note id %d/n", key, rvelocity, i, voice->note_id);            dx7_voice_note_off(instance, voice, key, rvelocity);        } /* if voice on */    } /* for all voices */}

/* * hexter_configure * * implements DSSI (*configure)() */char *hexter_configure(LADSPA_Handle handle, const char *key, const char *value){    hexter_instance_t *instance = (hexter_instance_t *)handle;    DEBUG_MESSAGE(DB_DSSI, " hexter_configure called with '%s' and '%s'/n", key, value);    if (strlen(key) == 8 && !strncmp(key, "patches", 7)) {        return hexter_instance_handle_patches(instance, key, value);    } else if (!strcmp(key, "edit_buffer")) {        return hexter_instance_handle_edit_buffer(instance, value);    } else if (!strcmp(key, "performance")) {  /* global performance parameters */        return hexter_instance_handle_performance(instance, value);    } else if (!strcmp(key, "monophonic")) {        return hexter_instance_handle_monophonic(instance, value);    } else if (!strcmp(key, "polyphony")) {        return hexter_instance_handle_polyphony(instance, value);#ifdef DSSI_GLOBAL_CONFIGURE_PREFIX    } else if (!strcmp(key, DSSI_GLOBAL_CONFIGURE_PREFIX "polyphony")) {#else    } else if (!strcmp(key, "global_polyphony")) {#endif        return hexter_synth_handle_global_polyphony(value);#ifdef DSSI_PROJECT_DIRECTORY_KEY    } else if (!strcmp(key, DSSI_PROJECT_DIRECTORY_KEY)) {        return NULL; /* plugin has no use for project directory key, ignore it */#endif    }    return strdup("error: unrecognized configure key");}

int readMessage(MessageContainer* container, mqd_t fd){    int result;        DEBUG(2, "reading mq");    result = mq_receive(fd, (char*)container, sizeof(MessageContainer), 0);        /*if (result == -1)    {        ERROR("error reading mq");    }    else */    if (result > 0)    {        DEBUG_MESSAGE(3, container);    }        return result;}

LRESULT CALLBACK SubClassNewWndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam){	LRESULT lResult = {0};	switch (message)	{		case MN_FINDMENUWINDOWFROMPOINT:			DEBUG_MESSAGE("[+] Triggering Vulnerability/n");			// vulnerability lies here			// this value is used as memory address without validating			lResult = -5;			break;		default:			lResult = CallWindowProc(oldWndProc, hWnd, message, wParam, lParam);			break;	}	return lResult;}

/****************************************************************************** * Function Name: DebugMessageWithLineInfo  * * Inputs       : psToken, pszFormat * Outputs      : - * Returns      : - * Globals Used : - * * Description  : Prints out a debug message with line information. *****************************************************************************/IMG_INTERNAL IMG_VOID DebugMessageWithLineInfo(Token *psToken, const IMG_CHAR *pszFormat, ...){	va_list vaArgs;	IMG_UINT32 i = 0;	IMG_CHAR acScratchBuffer[DEBUG_SCRATCH_BUFFER_SIZE];	if (!psToken)	{		DEBUG_MESSAGE(("DebugMessageWithLineInfo: Cannot dump token info, pointer is NULL/n"));		return;	}	va_start (vaArgs, pszFormat);	sprintf(acScratchBuffer, "%u:%u: ", 0, psToken->uLineNumber+1);	vsprintf (&acScratchBuffer[strlen(acScratchBuffer)], pszFormat, vaArgs);	va_end (vaArgs);	DEBUG_MESSAGE((acScratchBuffer));	while (i < (DEBUG_SCRATCH_BUFFER_SIZE - 10) && 		   psToken->pszStartOfLine[i] != '/n' && 		   psToken->pszStartOfLine[i] != '/r' && 		   psToken->pszStartOfLine[i] != '/0')	{		acScratchBuffer[i] = psToken->pszStartOfLine[i];		i++;	}	acScratchBuffer[i] = '/0';	DEBUG_MESSAGE(("%s/n", acScratchBuffer));	for (i = 0; i < psToken->uCharNumber; i++)	{		if (psToken->pszStartOfLine[i] == '/t')		{			DEBUG_MESSAGE(("/t"));		}		else		{			DEBUG_MESSAGE((" "));		}	}	DEBUG_MESSAGE(("^/n"));}