bool CPlayer::CanKillNow() { DebugInfo("CanKillNow Start Socket=%d PID=%d",reinterpret_cast<int>(m_pClientSocket),m_PID); if ( m_pRoom ) { if ( m_RoomID == m_pRoom->GetRoomID() ) { if ( m_pTable ) { if ( m_TableID == m_pTable->GetTableID() ) { if ( m_pTable->GetTableState()==TABLE_ST_PLAYING && this->IsPlaying() ) { return false; } } else { DebugError("CPlayer::CanKillNow PID=%d,TableID=%d",m_PID,m_TableID); } } } else { DebugError("CPlayer::CanKillNow PID=%d,RoomID=%d",m_PID,m_RoomID); } } DebugInfo("CanKillNow End Socket=%d PID=%d",reinterpret_cast<int>(m_pClientSocket),m_PID); return true; }
Eigen::Matrix4f MatrixFactory::createOrthoOffCenter ( float left, float right, float bottom, float top, float near_plane, float far_plane, Handedness handedness ) const { if (handedness == Handedness::RightHanded) { } else if (handedness == Handedness::LeftHanded) { } else { DebugError("Not implemented."); } DebugError("Not implemented."); return Eigen::Matrix4f::Identity(); }
VOID CVfrCompiler::UpdateInfoForDynamicOpcode ( VOID ) { SIfrRecord *pRecord; if (!gNeedAdjustOpcode) { return; } // // Base on the original offset info to update the record list. // if (!gCIfrRecordInfoDB.IfrAdjustDynamicOpcodeInRecords()) { DebugError (NULL, 0, 1001, "Error parsing vfr file", "Can find the offset in the record."); } // // Base on the opcode binary length to recalculate the offset for each opcode. // gCIfrRecordInfoDB.IfrAdjustOffsetForRecord(); // // Base on the offset to find the binary address. // pRecord = gCIfrRecordInfoDB.GetRecordInfoFromOffset(gAdjustOpcodeOffset); while (pRecord != NULL) { pRecord->mIfrBinBuf = gCFormPkg.GetBufAddrBaseOnOffset(pRecord->mOffset); if (pRecord->mIfrBinBuf == NULL) { DebugError (NULL, 0, 0001, "Error parsing vfr file", " 0x%X. offset not allocated.", pRecord->mOffset); } pRecord = pRecord->mNext; } }
VOID CVfrCompiler::Compile ( VOID ) { FILE *pInFile = NULL; CHAR8 *InFileName = NULL; INPUT_INFO_TO_SYNTAX InputInfo; if (!IS_RUN_STATUS(STATUS_PREPROCESSED)) { goto Fail; } InFileName = (mOptions.SkipCPreprocessor == TRUE) ? mOptions.VfrFileName : mOptions.PreprocessorOutputFileName; gCVfrErrorHandle.SetInputFile (InFileName); gCVfrErrorHandle.SetWarningAsError(mOptions.WarningAsError); if ((pInFile = fopen (LongFilePath (InFileName), "r")) == NULL) { DebugError (NULL, 0, 0001, "Error opening the input file", "%s", InFileName); goto Fail; } InputInfo.CompatibleMode = mOptions.CompatibleMode; if (mOptions.HasOverrideClassGuid) { InputInfo.OverrideClassGuid = &mOptions.OverrideClassGuid; } else { InputInfo.OverrideClassGuid = NULL; } if (VfrParserStart (pInFile, &InputInfo) != 0) { goto Fail; } fclose (pInFile); pInFile = NULL; if (gCFormPkg.HavePendingUnassigned () == TRUE) { gCFormPkg.PendingAssignPrintAll (); goto Fail; } SET_RUN_STATUS (STATUS_COMPILEED); return; Fail: if (!IS_RUN_STATUS(STATUS_DEAD)) { DebugError (NULL, 0, 0003, "Error parsing", "compile error in file %s", InFileName); SET_RUN_STATUS (STATUS_FAILED); } if (pInFile != NULL) { fclose (pInFile); } }
VOID CVfrCompiler::GenRecordListFile ( VOID ) { CHAR8 *InFileName = NULL; FILE *pInFile = NULL; FILE *pOutFile = NULL; CHAR8 LineBuf[MAX_VFR_LINE_LEN]; UINT32 LineNo; InFileName = (mOptions.SkipCPreprocessor == TRUE) ? mOptions.VfrFileName : mOptions.PreprocessorOutputFileName; if (mOptions.CreateRecordListFile == TRUE) { if ((InFileName[0] == '\0') || (mOptions.RecordListFile[0] == '\0')) { return; } if ((pInFile = fopen (InFileName, "r")) == NULL) { DebugError (NULL, 0, 0001, "Error opening the input VFR preprocessor output file", InFileName); return; } if ((pOutFile = fopen (mOptions.RecordListFile, "w")) == NULL) { DebugError (NULL, 0, 0001, "Error opening the record list file", mOptions.RecordListFile); goto Err1; } fprintf (pOutFile, "//\n// VFR compiler version " VFR_COMPILER_VERSION __BUILD_VERSION "\n//\n"); LineNo = 0; while (!feof (pInFile)) { if (fgets (LineBuf, MAX_VFR_LINE_LEN, pInFile) != NULL) { fprintf (pOutFile, "%s", LineBuf); LineNo++; gCIfrRecordInfoDB.IfrRecordOutput (pOutFile, LineNo); } } fprintf (pOutFile, "\n//\n// All Opcode Record List \n//\n"); gCIfrRecordInfoDB.IfrRecordOutput (pOutFile, 0); gCVfrVarDataTypeDB.Dump(pOutFile); fclose (pOutFile); fclose (pInFile); } return; Err1: fclose (pInFile); }
static void _InitializeGlobals(int argc, char *argv[]) { char fileName[255]; _processArgs(argc, argv); MSetAllocFailFunction(_AllocFailed); if(gUseStartingNet) { gPriorNet = BNReadBIF(gStartingNetFile); if(gPriorNet == 0) { DebugError(1, "couldn't read net specified by -startFrom\n"); } gEs = BNGetExampleSpec(gPriorNet); } else { sprintf(fileName, "%s/%s.names", gSourceDirectory, gFileStem); gEs = ExampleSpecRead(fileName); DebugError(gEs == 0, "Unable to open the .names file"); gPriorNet = BNNewFromSpec(gEs); } gInitialParameterCount = BNGetNumParameters(gPriorNet); gBranchFactor = BNGetNumNodes(gPriorNet) * BNGetNumNodes(gPriorNet); if(gLimitBytes != -1) { gMaxBytesPerModel = gLimitBytes / BNGetNumNodes(gPriorNet); //gMaxBytesPerModel = gLimitBytes / gBranchFactor; DebugMessage(1, 2, "Limit models to %.4lf megs\n", gMaxBytesPerModel / (1024.0 * 1024.0)); } gCurrentNet = BNClone(gPriorNet); BNZeroCPTs(gCurrentNet); RandomInit(); /* seed */ if(gSeed != -1) { RandomSeed(gSeed); } else { gSeed = RandomRange(1, 30000); RandomSeed(gSeed); } DebugMessage(1, 1, "running with seed %d\n", gSeed); DebugMessage(1, 1, "allocation %ld\n", MGetTotalAllocation()); DebugMessage(1, 1, "initial parameters %ld\n", gInitialParameterCount); }
VOID CVfrCompiler::AppendIncludePath ( IN CHAR8 *PathStr ) { UINT32 Len = 0; CHAR8 *IncludePaths = NULL; Len = strlen (" -I ") + strlen (PathStr) + 1; if (mOptions.IncludePaths != NULL) { Len += strlen (mOptions.IncludePaths); } IncludePaths = new CHAR8[Len]; if (IncludePaths == NULL) { DebugError (NULL, 0, 4001, "Resource: memory can't be allocated", NULL); return; } IncludePaths[0] = '\0'; if (mOptions.IncludePaths != NULL) { strcat (IncludePaths, mOptions.IncludePaths); } strcat (IncludePaths, " -I "); strcat (IncludePaths, PathStr); if (mOptions.IncludePaths != NULL) { delete mOptions.IncludePaths; } mOptions.IncludePaths = IncludePaths; }
void ThreadResult::reportErr(const ErrorLogger::ErrorMessage &msg) { QMutexLocker locker(&mutex); QList<unsigned int> lines; QStringList files; for (std::list<ErrorLogger::ErrorMessage::FileLocation>::const_iterator tok = msg._callStack.begin(); tok != msg._callStack.end(); ++tok) { files << QString((*tok).getfile(false).c_str()); lines << (*tok).line; } ErrorItem item; item.file = QString(callStackToString(msg._callStack).c_str()); item.files = files; item.id = QString(msg._id.c_str()); item.lines = lines; item.summary = QString::fromStdString(msg.shortMessage()); item.message = QString::fromStdString(msg.verboseMessage()); item.severity = msg._severity; item.inconclusive = msg._inconclusive; if (msg._severity != Severity::debug) emit Error(item); else emit DebugError(item); }
void __cdecl My_Sys_SetModuleOffset(char* moduleName, void* offset) { // We should be getting qagame, but check just in case. if (!strcmp(moduleName, "qagame")) { // Despite the name, it's not the actual module, but vmMain. // We use dlinfo to get the base of the module so we can properly // initialize all the pointers relative to the base. qagame_dllentry = offset; Dl_info dlinfo; int res = dladdr(offset, &dlinfo); if (!res) { DebugError("dladdr() failed.\n", __FILE__, __LINE__, __func__); qagame = NULL; } else { qagame = dlinfo.dli_fbase; } DebugPrint("Got qagame: %#010x\n", qagame); } else DebugPrint("Unknown module: %s\n", moduleName); Sys_SetModuleOffset(moduleName, offset); if (common_initialized) { SearchVmFunctions(); HookVm(); InitializeVm(); } }
CReal Besseli(const CReal rNu, const CReal rZ) { const CReal rEp = (CReal) 10e-9; /* Define accuracy */ const CReal rY = rZ / (CReal) 2.0; CReal rReturn = (CReal) 1.0; CReal rD = (CReal) 1.0; CReal rS = (CReal) 1.0; #ifdef _DEBUG_ /* Only nu = 0 is supported right now! */ if (rNu != (CReal) 0.0) { DebugError("MatLibr: Besseli function", "The nu = ", rNu, \ " is not supported, only nu = ", 0); } #endif for (int i = 1; i <= 25 && rReturn * rEp <= rS; i++) { rD *= rY / i; rS = rD * rD; rReturn += rS; } return rReturn; }
VOID CVfrCompiler::GenBinary ( VOID ) { FILE *pFile = NULL; if (!IS_RUN_STATUS(STATUS_COMPILEED)) { goto Fail; } if (mOptions.CreateIfrPkgFile == TRUE) { if ((pFile = fopen (mOptions.PkgOutputFileName, "wb")) == NULL) { DebugError (NULL, 0, 0001, "Error opening file", mOptions.PkgOutputFileName); goto Fail; } if (gCFormPkg.BuildPkg (pFile, &gRBuffer) != VFR_RETURN_SUCCESS) { fclose (pFile); goto Fail; } fclose (pFile); } SET_RUN_STATUS (STATUS_GENBINARY); return; Fail: if (!IS_RUN_STATUS(STATUS_DEAD)) { SET_RUN_STATUS (STATUS_FAILED); } }
VOID CVfrCompiler::AppendCPreprocessorOptions ( IN CHAR8 *Options ) { UINT32 Len = 0; CHAR8 *Opt = NULL; Len = strlen (Options) + strlen (" ") + 1; if (mOptions.CPreprocessorOptions != NULL) { Len += strlen (mOptions.CPreprocessorOptions); } Opt = new CHAR8[Len]; if (Opt == NULL) { DebugError (NULL, 0, 4001, "Resource: memory can't be allocated", NULL); return; } Opt[0] = 0; if (mOptions.CPreprocessorOptions != NULL) { strcat (Opt, mOptions.CPreprocessorOptions); } strcat (Opt, " "); strcat (Opt, Options); if (mOptions.CPreprocessorOptions != NULL) { delete mOptions.CPreprocessorOptions; } mOptions.CPreprocessorOptions = Opt; }
int main(int argc, char *argv[]) { BeliefNet bn, cbn; FILE *dataFile; ExamplePtr e; long numSeen = 0; double llSum = 0; _processArgs(argc, argv); bn = _readBN(gBeliefNetFile); if(gDoSmooth) { BNSetPriorStrength(bn, gPriorStrength); BNSmoothProbabilities(bn, 1); if(DebugGetMessageLevel() > 2) { BNWriteBIF(bn, stdout); } } if(gCompareToNet) { cbn = _readBN(gCompareNetFile); if(gDoSmooth) { BNSetPriorStrength(cbn, gPriorStrength); BNSmoothProbabilities(cbn, 1); } DebugMessage(1, 0, "Structural Difference: %d\n", _GetStructuralDifference(bn, cbn)); } else { if(gStdin) { dataFile = stdin; } else { dataFile = fopen(gDataFile, "r"); DebugError(dataFile == 0, "Unable to open datafile."); } e = ExampleRead(dataFile, BNGetExampleSpec(bn)); while(e != 0) { numSeen++; llSum += BNGetLogLikelihood(bn, e); ExampleFree(e); e = ExampleRead(dataFile, BNGetExampleSpec(bn)); } DebugMessage(1, 1, "Average Log Likelihood of %s on %s is: ", gBeliefNetFile, gDataFile); DebugMessage(1, 0, "%lf\n", llSum / (double)numSeen); if(!gStdin) { fclose(dataFile); } } return 0; }
Eigen::Matrix4f MatrixFactory::createOrtho ( float width, float height, float near_plane, float far_plane, Handedness handedness ) const { if (handedness == Handedness::RightHanded) { float h = height; float w = width; // z device coordinates [0, 1] float _33 = 1 / (near_plane - far_plane); float _34 = near_plane * _33; // z device coordinates [-1, 1] //float _33 = 2 / (near_plane - far_plane); //float _34 = (near_plane + far_plane) / (near_plane - far_plane); Eigen::Matrix4f matrix; matrix << 2/w, 0, 0, 0, 0, 2/h, 0, 0, 0, 0, _33, _34, 0, 0, 0, 1; return matrix; } else if (handedness == Handedness::LeftHanded) { float h = height; float w = width; // z device coordinates [0, 1] float _33 = 1 / (far_plane - near_plane); float _34 = -near_plane * _33; // z device coordinates [-1, 1] //float _33 = 2 / (far_plane - near_plane); //float _34 = -(near_plane + far_plane) / (far_plane - near_plane); Eigen::Matrix4f matrix; matrix << 2/w, 0, 0, 0, 0, 2/h, 0, 0, 0, 0, _33, _34, 0, 0, 0, 1; return matrix; } else { DebugError("Not implemented."); return Eigen::Matrix4f::Identity(); } }
Eigen::Matrix4f MatrixFactory::createPerspectiveFov ( float near_plane, float far_plane, float aspect_ratio, float fov_vertical, Handedness handedness ) const { if (handedness == Handedness::RightHanded) { float h = 1.0f / tan(fov_vertical / 2.0f); float w = h / aspect_ratio; // z device coordinates [0, 1] float _33 = far_plane / (near_plane - far_plane); float _34 = near_plane * _33; // z device coordinates [-1, 1] //float _33 = (near_plane + far_plane) / (near_plane - far_plane); //float _34 = (2 * near_plane * far_plane) / (near_plane - far_plane); Eigen::Matrix4f matrix; matrix << w, 0, 0, 0, 0, h, 0, 0, 0, 0, _33, _34, 0, 0, -1, 0; return matrix; } else if (handedness == Handedness::LeftHanded) { float h = 1.0f / tan(fov_vertical / 2.0f); float w = h / aspect_ratio; // z device coordinates [0, 1] float _33 = far_plane / (far_plane - near_plane); float _34 = -near_plane * _33; // z device coordinates [-1, 1] //float _33 = (near_plane + far_plane) / (far_plane - near_plane); //float _34 = -(2 * near_plane * far_plane) / (far_plane - near_plane); Eigen::Matrix4f matrix; matrix << w, 0, 0, 0, 0, h, 0, 0, 0, 0, _33, _34, 0, 0, 1, 0; return matrix; } else { DebugError("Not implemented."); return Eigen::Matrix4f::Identity(); } }
VOID CVfrCompiler::Compile ( VOID ) { FILE *pInFile = NULL; CHAR8 *InFileName = NULL; if (!IS_RUN_STATUS(STATUS_PREPROCESSED)) { goto Fail; } InFileName = (mOptions.SkipCPreprocessor == TRUE) ? mOptions.VfrFileName : mOptions.PreprocessorOutputFileName; gCVfrErrorHandle.SetInputFile (InFileName); if ((pInFile = fopen (InFileName, "r")) == NULL) { DebugError (NULL, 0, 0001, "Error opening the input file", InFileName); goto Fail; } if (VfrParserStart (pInFile, mOptions.CompatibleMode) != 0) { goto Fail; } fclose (pInFile); if (gCFormPkg.HavePendingUnassigned () == TRUE) { gCFormPkg.PendingAssignPrintAll (); goto Fail; } SET_RUN_STATUS (STATUS_COMPILEED); return; Fail: if (!IS_RUN_STATUS(STATUS_DEAD)) { DebugError (NULL, 0, 0003, "Error parsing", "compile error in file %s", InFileName); SET_RUN_STATUS (STATUS_FAILED); } if (pInFile != NULL) { fclose (pInFile); } }
void CPlayer::AddMoGuiMoney(INT32 nMoney) { if ( nMoney>=0 && m_nMoGuiMoney+nMoney>=0 ) { m_nMoGuiMoney += nMoney; } else { DebugError("AddMoGuiMoney PID=%-10d m_nMoGuiMoney=%d nMoney=%d",m_PID,m_nMoGuiMoney,nMoney ); } }
void chunk::create(){ pblocks = new block[4096]; pbrightness = new brightness[4096]; //memset(pblocks, 0, sizeof(pblocks)); //memset(pbrightness, 0, sizeof(pbrightness)); #ifdef NEWORLD_DEBUG_CONSOLE_OUTPUT if (pblocks == nullptr || pbrightness == nullptr){ DebugError("Allocate memory failed!"); } #endif }
void CPlayer::OnDestroy(void) { s_State[m_PlayerState]--; if ( s_State[m_PlayerState] < 0 ) { DebugError("OnDestroy State=%d stCount=%d",m_PlayerState,s_State[m_PlayerState]); } m_PlayerState = PLAYER_ST_NONE; RecyclePlayer(this); }
void CPlayer::AddGameMoney(INT64 nMoney) { DebugInfo("AddGameMoney PID=%d GameMoney=%s AddMoney=%s",m_PID,N2S(m_nGameMoney).c_str(),N2S(nMoney).c_str()); m_nGameMoney += nMoney; if ( m_nGameMoney < 0 ) { DebugError("AddGameMoney PID=%-10d m_nGameMoney=%s nMoney=%s",m_PID,Tool::N2S(m_nGameMoney).c_str(),Tool::N2S(nMoney).c_str() ); m_nGameMoney = 0; } }
void CPlayer::DecGameMoney(INT64 nMoney) { if ( nMoney>=0 && m_nGameMoney-nMoney>=0) { m_nGameMoney -= nMoney; } else { DebugError("DecGameMoney PID=%-10d m_nGameMoney=%s nMoney=%s", m_PID,Tool::N2S(m_nGameMoney).c_str(),Tool::N2S(nMoney).c_str() ); } }
void CPlayer::AddMatchJF(INT64 nJF) { if ( nJF>=0 ) { m_nMatchJF += nJF; } else { DebugError("AddMatchJF PID=%d m_nMatchJF=%s nJF=%s", m_PID,Tool::N2S(m_nMatchJF).c_str(),Tool::N2S(nJF).c_str() ); } }
void CPlayer::AttachSocket( GameServerSocket* pcs ) { DebugInfo("AttachSocket Start old_Socket=%d new_Socket=%d",reinterpret_cast<int>(m_pClientSocket),reinterpret_cast<int>(pcs) ); if ( pcs == m_pClientSocket && pcs ) { DebugError("AttachSocket 相同的SOCKET pcs=%d",reinterpret_cast<int>(pcs) ); } m_KillTime = 0; m_SocketCloseTime = 0; m_mapRoomTime.clear(); if( this->m_pClientSocket ) { Game_MsgFlag msgFlag; msgFlag.m_Flag = msgFlag.LAND_OTHER_PLACE; msgFlag.m_nValue = pcs->GetPeerLongIp(); this->m_pClientSocket->SendMsg(msgFlag); this->m_pClientSocket->SetPlayer(NULL); this->m_pClientSocket->Stop(GetCurTime()); //this->m_pClientSocket->Close(); //this->m_pClientSocket = NULL; } if( pcs && pcs->GetConnect() ) { m_pClientSocket = pcs; pcs->SetPlayer(this); } else { DebugError("CPlayer::Attach"); assert(0); } DebugInfo("AttachSocket End"); }
Eigen::Matrix4f MatrixFactory::createPerspective ( float width, float height, float near_plane, float far_plane, Handedness handedness ) const { if (handedness == Handedness::RightHanded) { } else if (handedness == Handedness::LeftHanded) { } else { DebugError("Not implemented."); } DebugError("Not implemented."); return Eigen::Matrix4f::Identity(); }
void CPlayer::SetPlayerState( BYTE st ) { if( st != m_PlayerState ) { s_State[m_PlayerState]--; s_State[st]++; if ( s_State[m_PlayerState]<0 || s_State[st]<=0 ) { DebugError("PlayerState=%d st=%d pscount=%d stcount=%d",m_PlayerState,st,s_State[m_PlayerState],s_State[st]); } m_PlayerState = st; } }
void init(string ip, unsigned short _port) { Net::startup(); try { socketClient.connectIPv4(ip, _port); } catch (...) { DebugError("Cannot connect to the server!"); return; } threadRun = true; mutex = MutexCreate(); t = ThreadCreate(networkThread, NULL); }
HashTable *HashTableNew(int size) { HashTable* table = NULL; int i = 0; table = MNewPtr(sizeof(HashTable)); table->size = size; table->array = MNewPtr(sizeof(VoidListPtr) * size); for(i = 0; i < size; i++) { table->array[i] = VLNew(); DebugError(table->array[i] == NULL, "Failed allocate in HashTableNew"); } return table; }
Eigen::Matrix4f MatrixFactory::createLookAt ( const Eigen::Vector3f& position, const Eigen::Vector3f& direction, const Eigen::Vector3f& world_up, Handedness handedness ) const { if (handedness == Handedness::RightHanded) { Eigen::Vector3f right, up, dir; dir = -direction.normalized(); right = world_up.normalized().cross(dir).normalized(); up = dir.cross(right); Eigen::Matrix4f matrix; matrix << right.x(), right.y(), right.z(), -right.dot(position), up.x(), up.y(), up.z(), -up.dot(position), dir.x(), dir.y(), dir.z(), -dir.dot(position), 0.0f, 0.0f, 0.0f, 1.0f; return matrix; } else if (handedness == Handedness::LeftHanded) { Eigen::Vector3f right, up, dir; dir = direction.normalized(); right = world_up.normalized().cross(dir).normalized(); up = dir.cross(right); Eigen::Matrix4f matrix; matrix << right.x(), right.y(), right.z(), -right.dot(position), up.x(), up.y(), up.z(), -up.dot(position), dir.x(), dir.y(), dir.z(), -dir.dot(position), 0.0f, 0.0f, 0.0f, 1.0f; return matrix; } else { DebugError("Not implemented."); return Eigen::Matrix4f::Zero(); } }
VOID CVfrCompiler::GenCFile ( VOID ) { FILE *pFile; UINT32 Index; if (!IS_RUN_STATUS(STATUS_GENBINARY)) { goto Fail; } if (!mOptions.CreateIfrPkgFile || mOptions.CompatibleMode) { if ((pFile = fopen (mOptions.COutputFileName, "w")) == NULL) { DebugError (NULL, 0, 0001, "Error opening output C file", mOptions.COutputFileName); goto Fail; } for (Index = 0; gSourceFileHeader[Index] != NULL; Index++) { fprintf (pFile, "%s\n", gSourceFileHeader[Index]); } if (mOptions.CompatibleMode) { gCVfrBufferConfig.OutputCFile (pFile, mOptions.VfrBaseFileName); } if (gCFormPkg.GenCFile (mOptions.VfrBaseFileName, pFile, &gRBuffer) != VFR_RETURN_SUCCESS) { fclose (pFile); goto Fail; } fclose (pFile); } SET_RUN_STATUS (STATUS_FINISHED); return; Fail: if (!IS_RUN_STATUS(STATUS_DEAD)) { SET_RUN_STATUS (STATUS_FAILED); } }
void *HashTableRemove(HashTable *table, int index, int (*cmp)(const void *, const int)) { int i, found, foundIndex; VoidListPtr list; DebugError(index < 0, "Invalid index in HashTableRemove"); list = table->array[index % (table->size)]; found = 0; foundIndex = -1; for(i = 0 ; i < VLLength(list) && !found ; i++) { if((*cmp)(VLIndex(list, i), index) >= 0) { found = 1; foundIndex = i; } } if(found == 1) { return VLRemove(list, foundIndex); } else { return 0; } }