void asCVariableScope::Reset()
{
isBreakScope = false;
isContinueScope = false;
for( asUINT n = 0; n < variables.GetLength(); n++ )
if( variables[n] )
{
DELETE(variables[n],sVariable);
}
variables.SetLength(0);
}
ADMVideoMPD3Dlow::~ADMVideoMPD3Dlow()
{
DELETE(_param);
delete _uncompressed;
delete _stored;
delete [] Line;
Line=NULL;
_param=NULL;
_uncompressed=NULL;
_stored=NULL;
}
void QGVector::clear() // clear vector
{
if ( vec ) {
for ( uint i=0; i<len; i++ ) { // delete each item
if ( vec[i] )
deleteItem( vec[i] );
}
DELETE(vec);
vec = 0;
len = numItems = 0;
}
}
void RedisReply::Clear()
{
type = 0;
integer = 0;
double_value = 0;
str.clear();
DELETE(elements);
if (self_pool && NULL != pool)
{
pool->Clear();
}
}
/**
* postSort() runs after sorting has been performed. For ZendArray, postSort()
* handles rewiring the linked list according to the results of the sort. Also,
* if resetKeys is true, postSort() will renumber the keys 0 thru n-1.
*/
void ZendArray::postSort(Bucket** buffer, bool resetKeys) {
uint last = m_size-1;
m_pListHead = buffer[0];
m_pListTail = buffer[last];
m_pos = (ssize_t)m_pListHead;
Bucket* b = buffer[0];
b->pListLast = NULL;
if (resetKeys) {
memset(m_arBuckets, 0, tableSize() * sizeof(Bucket*));
for (uint i = 0; i < last; ++i) {
Bucket* bNext = buffer[i+1];
b->pListNext = bNext;
bNext->pListLast = b;
if (b->hasStrKey() && b->skey->decRefCount() == 0) {
DELETE(StringData)(b->skey);
}
b->setIntKey(i);
uint nIndex = (i & m_nTableMask);
CONNECT_TO_BUCKET_LIST(b, m_arBuckets[nIndex]);
SET_ARRAY_BUCKET_HEAD(m_arBuckets, nIndex, b);
b = bNext;
}
if (b->hasStrKey() && b->skey->decRefCount() == 0) {
DELETE(StringData)(b->skey);
}
b->setIntKey(last);
uint nIndex = (last & m_nTableMask);
CONNECT_TO_BUCKET_LIST(b, m_arBuckets[nIndex]);
SET_ARRAY_BUCKET_HEAD(m_arBuckets, nIndex, b);
m_nNextFreeElement = m_size;
} else {
for (uint i = 0; i < last; ++i) {
Bucket* bNext = buffer[i+1];
b->pListNext = bNext;
bNext->pListLast = b;
b = bNext;
}
}
b->pListNext = NULL;
}
JILError JCLSetGlobalOptions(JILState* pVM, const JILChar* pOptionString)
{
JILError err = JIL_No_Exception;
JCLString* pStr;
JCLString* pToken;
JCLOption* pOptions;
JCLState* _this;
if( (_this = pVM->vmpCompiler) == NULL )
return JIL_ERR_No_Compiler;
pStr = NEW(JCLString);
pToken = NEW(JCLString);
JCLSetString(pToken, pOptionString);
pOptions = GetGlobalOptions(_this);
while( !JCLAtEnd(pToken) )
{
// copy up to separator into pStr
JCLSpanExcluding(pToken, ",;", pStr);
// trim any spaces
JCLTrim(pStr);
// something left?
if( JCLGetLength(pStr) )
{
// have option object parse it
err = pOptions->ParseOption(pOptions, pStr, JILHandleRuntimeOptions, pVM);
// handle warnings and errors
if( err )
goto exit;
}
// skip the separator(s)
JCLSpanIncluding(pToken, ",;", pStr);
}
exit:
DELETE(pStr);
DELETE(pToken);
return err;
}
/* =============================================================================
* rbtree_delete
* -- Returns TRUE if key exists
* =============================================================================
*/
bool_t
rbtree_delete (rbtree_t* r, void* key)
{
node_t* node = NULL;
node = LOOKUP(r, key);
if (node != NULL) {
node = DELETE(r, node);
}
if (node != NULL) {
releaseNode(node);
}
return ((node != NULL) ? TRUE : FALSE);
}
ASTNode* CNFMgr::doRenameITE(const ASTNode& varphi, ClauseList* defs)
{
ASTNode psi;
//########################################
// step 1, old "RepLit" code
//########################################
ostringstream oss;
oss << "cnf" << "{" << varphi.GetNodeNum() << "}";
psi = bm->CreateSymbol(oss.str().c_str(),varphi.GetIndexWidth(),varphi.GetValueWidth());
//########################################
// step 3, recurse over children
//########################################
convertFormulaToCNF(varphi[0], defs);
convertTermForCNF(varphi[1], defs);
ASTNode t1 = *(info[varphi[1]]->termforcnf);
convertTermForCNF(varphi[2], defs);
ASTNode t2 = *(info[varphi[2]]->termforcnf);
//########################################
// step 4, add def clauses
//########################################
ClauseList* cl1 = SINGLETON(bm->CreateNode(EQ, psi, t1));
ClauseList* cl2 = ClauseList::PRODUCT(*(info[varphi[0]]->clausesneg), *cl1);
DELETE(cl1);
defs->insert(cl2);
ClauseList* cl3 = SINGLETON(bm->CreateNode(EQ, psi, t2));
ClauseList* cl4 = ClauseList::PRODUCT(*(info[varphi[0]]->clausespos), *cl3);
DELETE(cl3);
defs->insert(cl4);
return ASTNodeToASTNodePtr(psi);
}//End of doRenameITE()
RedisDumpFile* Slave::GetNewRedisDumpFile()
{
DELETE(m_rdb);
std::string dump_file_path = m_serv->m_cfg.home + "/repl";
char tmp[dump_file_path.size() + 100];
uint32 now = time(NULL);
sprintf(tmp, "%s/temp-%u-%u.rdb", dump_file_path.c_str(), getpid(), now);
NEW(m_rdb, RedisDumpFile);
m_rdb->Init(m_serv->m_db);
m_rdb->OpenWriteFile(tmp);
INFO_LOG("[Slave]Create redis dump file:%s", tmp);
return m_rdb;
}
int sp_devices_length() {
int length = 0;
sp_db *th = NEW(sp_db);
if (th && th->m_DB &&
SQLITE_OK != sqlite3_exec(th->m_DB,
"SELECT COUNT(id) as length FROM devices",
&sp_devices_length_callback,
(void *)&length, 0)) {
length = 0;
}
DELETE(th);
return length;
}
void LoadOperMOTD()
{
ConfigReader* conf = new ConfigReader(ServerInstance);
std::string filename;
filename = conf->ReadValue("opermotd","file",0);
if (opermotd)
{
delete opermotd;
opermotd = NULL;
}
opermotd = new FileReader(ServerInstance, filename);
DELETE(conf);
}
void ZendArray::onSetEvalScalar() {
for (Bucket *p = m_pListHead; p; p = p->pListNext) {
StringData *key = p->skey;
if (p->hasStrKey() && !key->isStatic()) {
StringData *skey= StringData::GetStaticString(key);
if (key && key->decRefCount() == 0) {
DELETE(StringData)(key);
}
p->skey = skey;
}
p->data.setEvalScalar();
}
}
void ReadConfig()
{
ConfigReader* MyConf = new ConfigReader(ServerInstance);
allowchans.clear();
for (int i = 0; i < MyConf->Enumerate("allowchannel"); i++)
{
std::string txt;
txt = MyConf->ReadValue("allowchannel", "name", i);
irc::string channel = txt.c_str();
allowchans[channel] = 1;
}
DELETE(MyConf);
}
HOT_FUNC_HPHP
void ZendArray::erase(Bucket ** prev, bool updateNext /* = false */) {
if (prev == NULL)
return;
Bucket * p = *prev;
bool nextElementUnsetInsideForeachByReference = false;
if (p) {
*prev = p->pNext;
if (p->pListLast) {
p->pListLast->pListNext = p->pListNext;
} else {
/* Deleting the head of the list */
ASSERT(m_pListHead == p);
m_pListHead = p->pListNext;
}
if (p->pListNext) {
p->pListNext->pListLast = p->pListLast;
} else {
ASSERT(m_pListTail == p);
m_pListTail = p->pListLast;
}
if (m_pos == (ssize_t)p) {
m_pos = (ssize_t)p->pListNext;
}
int sz = m_strongIterators.size();
for (int i = 0; i < sz; ++i) {
if (m_strongIterators.get(i)->pos == (ssize_t)p) {
nextElementUnsetInsideForeachByReference = true;
m_strongIterators.get(i)->pos = (ssize_t)p->pListNext;
if (!(m_strongIterators.get(i)->pos)) {
// Record that there is a strong iterator out there
// that is past the end
m_flag |= StrongIteratorPastEnd;
}
}
}
m_size--;
// Match PHP 5.3.1 semantics
if ((uint64)p->ikey == (uint64)(m_nNextFreeElement - 1) &&
(p->ikey == 0x7fffffffffffffffLL || updateNext)) {
--m_nNextFreeElement;
}
DELETE(Bucket)(p);
}
if (nextElementUnsetInsideForeachByReference) {
if (RuntimeOption::EnableHipHopErrors) {
raise_warning("The next element was unset inside foreach by reference. "
"This may lead to unexpeced results.");
}
}
}
int32 main()
{
CTest *p1, *p2, *p3;
char* pch1;
CMemMgr* pclMemMgr = TSingleton<CMemMgr>::Instance();
TSingleton<CMutexMgr>::Instance()->Init();
pclMemMgr.Init();
pclMemMgr.Dump(NULL);
NEW(p1, CTest, 1, 1);
NEW(p2, CTest, 2, 2);
NEW(p3, CTest, 3, 3);
p1->print();
p2->print();
p3->print();
pclMemMgr.Dump(NULL);
DELETE(p1);
MALLOC(pch1, char, 10);
p2->print();
p3->print();
pclMemMgr.Dump(NULL);
FREE(pch1);
DELETE(p2);
DELETE(p3);
pclMemMgr.Dump(NULL);
pthread_t m_resumeThreadId;
pthread_create(&m_resumeThreadId, 0, ResumeMemTask, 0);
pthread_t m_monitorThreadId;
pthread_create(&m_monitorThreadId, 0, MonitorMemTask, 0);
while(1) sleep(10);
return 0;
}
int LMDBEngine::DiscardBatchWrite()
{
LMDBContext& holder = m_ctx_local.GetValue();
holder.batch_write--;
if (holder.batch_write == 0)
{
CheckPointOperation* ck = new CheckPointOperation(holder.cond);
m_write_queue.Push(ck);
NotifyBackgroundThread();
ck->Wait();
DELETE(ck);
}
return 0;
}
void OnCleanup(int target_type, void* item)
{
if(target_type == TYPE_USER)
{
userrec* user = (userrec*)item;
BlockedMessage* m;
user->GetExt("amsgblock", m);
if(m)
{
DELETE(m);
user->Shrink("amsgblock");
}
}
}
void CDlnaFrame::Release()
{
CListPlugin::iterator itbegin = m_ListPlugin.begin();
CListPlugin::iterator itend = m_ListPlugin.end();
for (itbegin;itbegin!=itend;++itbegin)
{
CPlugIn *pPlugin = (CPlugIn*)(*itbegin);
/*if(pPlugin->pHandle)
dlclose(pPlugin->pHandle);*/
DELETE(pPlugin);
}
m_ListPlugin.clear();
}
void MainTest::deletePost()
{
auto count = FROM(db.posts())
WHERE(Post::idField() == postId)
DELETE();
QTEST_ASSERT(count == 1);
count = FROM(db.posts())
WHERE(Post::idField() == postId)
COUNT();
QTEST_ASSERT(count == 0);
}
void CNFMgr::reduceMemoryFootprintNeg(const ASTNode& varphi)
{
CNFInfo* x = info[varphi];
if (sharesNeg(*x) == 1)
{
DELETE(x->clausesneg);
x->clausesneg = NULL;
if (x->clausespos == NULL)
{
delete x;
info.erase(varphi);
}
}
} //End of reduceMemoryFootprintNeg()
/*
in :
- attribute is the attribute that is tested in the node that's going to be created
out :
- the non-leaf node
*/
static struct node_t *new_node(const struct attribute_t *attribute)
{
int i;
struct node_t *ret = malloc(sizeof(*ret));
ret->nb_children = attribute->l_tab;
ret->children = malloc(sizeof(*ret->children) * ret->nb_children);
for(i = 0; i < ret->nb_children; ++i)
ret->children[i] = NULL;
ret->attribute_values = malloc(sizeof(*ret->attribute_values) * ret->nb_children);
for(i = 0; i < ret->nb_children; ++i)
DELETE(ret->attribute_values[i]);
strcpy(ret->property.name_attribute, attribute->property);
return ret;
}
void CHandleOutSearch::SendRequest(const TDesC8& aUrl)
{
DELETE(iCurUrl);
iCurUrl=aUrl.Alloc();
if(CheckTemp())
{
iState=EHttpOutSearch;
iHttpManager.SendGetRequest(*this,aUrl,EHttpOutSearch);
}
else
{
iObserver.HandleResponseEvent(0,EHttpOutSearch);
}
}
/**
* SceneNode deconstructor.
* @param node The node to free.
* \memberof SceneNode
*/
void SceneNode_0SceneNode(SceneNode *node) {
DEBUG_M("Entering function...");
assert(node);
#warning ['TODO']: Free SceneNode memory recusivly, right now it leaks...
DEBUG_H("Deleting mesh...");
DELETE(node->mesh);
node->mesh = NULL;
DEBUG_H("Deleting Child node...");
DELETE(node->child);
DEBUG_H("Deleting next node...");
DELETE(node->next);
DEBUG_H("Deleting rotations...");
List_DeleteData(node->rotations);
DELETE(node->rotations);
node->rotations = NULL;
DEBUG_H("Deleting self...");
free(node);
}
int Ardb::LastDB(DBID& db)
{
int ret = -1;
Iterator* iter = NewIterator(ARDB_GLOBAL_DB);
if (NULL != iter && iter->Valid())
{
//Skip last KEY_END entry
iter->Prev();
}
if (NULL != iter && iter->Valid())
{
Slice tmpkey = iter->Key();
KeyObject* kk = decode_key(tmpkey, NULL);
if (NULL != kk)
{
db = kk->db;
ret = 0;
}
DELETE(kk);
}
DELETE(iter);
return ret;
}
Document *
populate(getc_func getc, void* ctx, int flags)
{
Cstring line;
Document *a = new_Document();
int c;
int pandoc = 0;
if ( !a ) return 0;
a->tabstop = (flags & MKD_TABSTOP) ? 4 : TABSTOP;
CREATE(line);
while ( (c = (*getc)(ctx)) != EOF ) {
if ( c == '\n' ) {
if ( pandoc != EOF && pandoc < 3 ) {
if ( S(line) && (T(line)[0] == '%') )
pandoc++;
else
pandoc = EOF;
}
queue(a, &line);
S(line) = 0;
}
else if ( isprint(c) || isspace(c) || (c & 0x80) )
EXPAND(line) = c;
}
if ( S(line) )
queue(a, &line);
DELETE(line);
if ( (pandoc == 3) && !(flags & (MKD_NOHEADER|MKD_STRICT)) ) {
/* the first three lines started with %, so we have a header.
* clip the first three lines out of content and hang them
* off header.
*/
Line *headers = T(a->content);
a->title = headers; header_dle(a->title);
a->author= headers->next; header_dle(a->author);
a->date = headers->next->next; header_dle(a->date);
T(a->content) = headers->next->next->next;
}
return a;
}
void f() {
int *a = new int(5); // expected-note2 {{allocated with 'new' here}}
delete[] a; // expected-warning {{'delete[]' applied to a pointer that was allocated with 'new'; did you mean 'delete'?}}
int *b = new int;
delete b;
int *c{new int}; // expected-note {{allocated with 'new' here}}
int *d{new int[1]}; // expected-note2 {{allocated with 'new[]' here}}
delete [ ] c; // expected-warning {{'delete[]' applied to a pointer that was allocated with 'new'; did you mean 'delete'?}}
// CHECK: fix-it:"{{.*}}":{[[@LINE-1]]:9-[[@LINE-1]]:17}:""
delete d; // expected-warning {{'delete' applied to a pointer that was allocated with 'new[]'; did you mean 'delete[]'?}}
// CHECK: fix-it:"{{.*}}":{[[@LINE-1]]:9-[[@LINE-1]]:9}:"[]"
DELETE_ARRAY(a); // expected-warning {{'delete[]' applied to a pointer that was allocated with 'new'; did you mean 'delete'?}}
DELETE(d); // expected-warning {{'delete' applied to a pointer that was allocated with 'new[]'; did you mean 'delete[]'?}}
}
node Delete_Element(tree t, node Parent, void * data, int *H, int * found, void * found_data)
{
node Temp;
if(!Parent)
{
printf("\n datarmation does not exist");
return(Parent);
}
else
{
if (t->comp(data, Parent->data) < 0)
{
Parent->left = Delete_Element(t, Parent->left, data, H, found, found_data);
if(*H)
Parent = Balance_Right_Heavy(Parent, H);
}
else if(t->comp(data, Parent->data) > 0)
{
Parent->right = Delete_Element(t, Parent->right, data, H, found, found_data);
if(*H)
Parent = Balance_Left_Heavy(Parent, H);
}
else
{
*found = 1;
*((int*)found_data) = (int) Parent->data;
Temp= Parent;
if(Temp->right == NULL)
{
Parent = Temp->left;
*H = T;
free(Temp);
}
else if(Temp->left == NULL)
{
Parent = Temp->right;
*H = T;
free(Temp);
}
else
{
Temp->left = DELETE(Temp->left, Temp, H);
if(*H)
Parent = Balance_Right_Heavy(Parent, H);
}
}
}
return(Parent);
}
CSearchResultView::~CSearchResultView()
{
DELETE(iTitle);
DELETE(iInSearch);
DELETE(iShowInfo);
DELETE(iShowGrade);
DELETE(iUrl);
DELETE(iTempBuf);
}
//From MOperationObserver
void CHandleOutSearch::OperationEvent(TInt aEventType,const TDesC& aEventData,TInt aType)
{
TInt eventType=aEventType;
if(aEventType==EHttpNoError)
{
if(aType==EHttpOutSearch)
{
::WriteFile(iFileName,aEventData);
this->HandlePageWml();
}
else if(aType==EHttpOutSearchError)
{
DELETE(iErrorInfo);
iErrorInfo=aEventData.Alloc();
DELETE(iBuf);
iBuf=aEventData.Alloc();
eventType=EHttpContentError;
}
}
else
{
DELETE(iBuf);
iBuf=aEventData.Alloc();
}
if(aType!=EHttpOutSearchKeyWord)
{
if(iContentError)
{
iObserver.HandleResponseEvent(EHttpContentError,aType);
iContentError=EFalse;
}
else
iObserver.HandleResponseEvent(eventType,aType);
}
}
void
m4_delete (m4 *context)
{
size_t i;
assert (context);
if (context->symtab)
m4_symtab_delete (context->symtab);
if (context->syntax)
m4_syntax_delete (context->syntax);
/* debug_file should have been reset to stdout or stderr, both of
which are closed later. */
assert (context->debug_file == stderr || context->debug_file == stdout);
obstack_free (&context->trace_messages, NULL);
if (context->search_path)
{
m4__search_path *path = context->search_path->list;
while (path)
{
m4__search_path *stale = path;
path = path->next;
DELETE (stale->dir); /* Cast away const. */
free (stale);
}
free (context->search_path);
}
for (i = 0; i < context->stacks_count; i++)
{
assert (context->arg_stacks[i].refcount == 0
&& context->arg_stacks[i].argcount == 0);
if (context->arg_stacks[i].args)
{
obstack_free (context->arg_stacks[i].args, NULL);
free (context->arg_stacks[i].args);
obstack_free (context->arg_stacks[i].argv, NULL);
free (context->arg_stacks[i].argv);
}
}
free (context->arg_stacks);
free (context);
}
