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);
}
}
bool OrderWrapper::processConfirmation(OrderConfirmation &confirmation)
{
LegDetail *legOrder = getLegOrder(confirmation.getSymbolId());
if(!legOrder)
{
DEBUG_VARSHOW(_context->reqQryDebugLog(),"leg Order Found Null SymbolID:",confirmation.getSymbolId());
DEBUG_FLUSH(_context->reqQryDebugLog());
}
if(confirmation.getOrderStatus() == API2::CONSTANTS::RSP_OrderStatus_CONFIRMED)
_exchangeOrderId = _context->reqQryExchangeOrderId(legOrder->orderId);
switch(confirmation.getOrderStatus())
{
case API2::CONSTANTS::RSP_OrderStatus_CONFIRMED:
legOrder->updateOrderWrapper(confirmation.getOrderQuantity(),confirmation.getOrderPrice(),0);
case API2::CONSTANTS::RSP_OrderStatus_NEW_REJECTED:
_isPendingNew = false;break;
case API2::CONSTANTS::RSP_OrderStatus_REPLACED:
legOrder->updateOrderWrapper(confirmation.getOrderQuantity(),confirmation.getOrderPrice(),0);
case API2::CONSTANTS::RSP_OrderStatus_REPLACE_REJECTED:
_isPendingReplace = false;break;
case API2::CONSTANTS::RSP_OrderStatus_CANCELED:
case API2::CONSTANTS::RSP_OrderStatus_CANCELED_OF_IOC:
legOrder->resetOrderWrapper();
case API2::CONSTANTS::RSP_OrderStatus_CANCEL_REJECTED:
_isPendingCancel = false;break;
case API2::CONSTANTS::RSP_OrderStatus_FILLED:
if(confirmation.getLastFillQuantity() + getLastFilledQuantity() != legOrder->_lastQuantity)//PartiallyFILLed
{
legOrder->updateOrderWrapper(getLastQuantity(),legOrder->_lastQuotedPrice,confirmation.getLastFillQuantity());
break;
}
legOrder->resetOrderWrapper();
break;
}
if(strcmp(confirmation.getExchangeOrderId().c_str(),_exchangeOrderId.c_str()))
{
DEBUG_MESSAGE(_context->reqQryDebugLog(),"Mismatch in order id");
DEBUG_VARSHOW(_context->reqQryDebugLog(),"confirmation ExchangeOrderId",confirmation.getExchangeOrderId().c_str());
DEBUG_VARSHOW(_context->reqQryDebugLog(),"_exchangeOrderId",_exchangeOrderId.c_str());
return false;
}
return true;
}
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;
}
void ParseThread::ProcessDeleteTagsOfFiles(ParseRequest* req)
{
DEBUG_MESSAGE(wxString(wxT("ParseThread::ProcessDeleteTagsOfFile")));
if(req->_workspaceFiles.empty())
return;
wxString dbfile = req->getDbfile();
ITagsStoragePtr db(new TagsStorageSQLite());
db->OpenDatabase( dbfile );
db->Begin();
wxArrayString file_array;
for (size_t i=0; i<req->_workspaceFiles.size(); i++) {
wxString filename(req->_workspaceFiles.at(i).c_str(), wxConvUTF8);
db->DeleteByFileName(wxFileName(),filename, false);
file_array.Add(filename);
}
db->DeleteFromFiles(file_array);
db->Commit();
DEBUG_MESSAGE(wxString(wxT("ParseThread::ProcessDeleteTagsOfFile - completed")));
}
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 void
pop_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 player
TArray<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
*/
void
hexter_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"));
}
