void bipartGraphDestroy(bpGraph_t* pGraph)
{
vtNode_t *currentNode1, *tempNode1;
vtNode_t *currentNode2, *tempNode2;
currentNode1 = pGraph->vpVpertsP1;
currentNode2 = pGraph->vpVpertsP2;
while(currentNode1 != NULL)
{
destroyList(currentNode1->sub_linkedlist);
tempNode1 = currentNode1;
currentNode1 = currentNode1->next;
safeFree(tempNode1, sizeof(vtNode_t));
tempNode1 = NULL;
}
while(currentNode2 != NULL)
{
destroyList(currentNode2->sub_linkedlist);
tempNode2 = currentNode2;
currentNode2 = currentNode2->next;
safeFree(tempNode2, sizeof(vtNode_t));
tempNode2 = NULL;
}
pGraph->vpVpertsP1 = NULL;
pGraph->vpVpertsP2 = NULL;
pGraph->vertNum1 = 0;
pGraph->vertNum2 = 0;
safeFree(pGraph, sizeof(bpGraph_t));
} /* end of bipartGraphDestroy() */
int deleteNode(linkedList_t *pList, int element)
{
llNode_t *pCurrNode = pList->pHead, *pPrevNode = NULL;
if (pCurrNode != NULL) {
/** If head is the deleted node. */
if (pCurrNode->element == element) {
pList->pHead = pCurrNode->pNext;
safeFree(pCurrNode, sizeof(llNode_t));
pList->size -= 1;
return SUCCESS;
}
pPrevNode = pCurrNode;
pCurrNode = pCurrNode->pNext;
}
while (pCurrNode != NULL) {
if (pCurrNode->element == element) {
pPrevNode->pNext = pCurrNode->pNext;
safeFree(pCurrNode, sizeof(llNode_t));
pList->size -= 1;
return SUCCESS;
}
pPrevNode = pCurrNode;
pCurrNode = pCurrNode->pNext;
}
/* Can't find element. */
return FAILED;
} /* end of deleteNode() */
void bipartGraphDestroy(bpGraph_t* pGraph)
{
int i;
/* free the existence arrays */
safeFree(pGraph->vVertExistP1, sizeof(char) * pGraph->vertNum1);
safeFree(pGraph->vVertExistP2, sizeof(char) * pGraph->vertNum2);
/* free the linked lists */
for (i = 0; i < pGraph->vertNum1; ++i) {
if (pGraph->vpVertsP1[i] != NULL) {
destroyList(pGraph->vpVertsP1[i]);
}
}
for (i = 0; i < pGraph->vertNum2; ++i) {
if (pGraph->vpVertsP2[i] != NULL) {
destroyList(pGraph->vpVertsP2[i]);
}
}
/* free the arrays */
safeFree(pGraph->vpVertsP1, sizeof(linkedList_t*) * pGraph->vertNum1);
safeFree(pGraph->vpVertsP2, sizeof(linkedList_t*) * pGraph->vertNum2);
/* free the graph itself */
safeFree(pGraph, sizeof(bpGraph_t));
/* make sure we can't accidentally use graph */
pGraph = NULL;
} /* end of bipartGraphDestroy() */
int bipartGraphDeleteVertex(bpGraph_t* pGraph, int vertId, int partite)
{
/* TODO: Implement me! */
vtNode_t *currentNode = NULL, *previousNode = NULL;
vtNode_t *tempNode = NULL;
if (partite == 1) {
currentNode = pGraph->vpVpertsP1;
while(currentNode != NULL) {
if (currentNode->element == vertId) {
if(previousNode == NULL)
{
destroyList(currentNode->sub_linkedlist);
tempNode = currentNode;
pGraph->vpVpertsP1 = currentNode->next;
safeFree(tempNode, sizeof(vtNode_t));
}
else
{
destroyList(currentNode->sub_linkedlist);
tempNode = currentNode;
previousNode->next = currentNode->next;
safeFree(tempNode, sizeof(vtNode_t));
}
deleteSublistNode(pGraph, vertId, 2);
return SUCCESS;
}
previousNode = currentNode;
currentNode = currentNode->next;
}
return FAILED;
}else if (partite == 2) {
currentNode = pGraph->vpVpertsP2;
while(currentNode != NULL) {
if (currentNode->element == vertId) {
if(previousNode == NULL)
{
destroyList(currentNode->sub_linkedlist);
tempNode = currentNode;
pGraph->vpVpertsP2 = currentNode->next;
safeFree(tempNode, sizeof(vtNode_t));
}
else
{
destroyList(currentNode->sub_linkedlist);
tempNode = currentNode;
previousNode->next = currentNode->next;
safeFree(tempNode, sizeof(vtNode_t));
}
deleteSublistNode(pGraph, vertId, 1);
return SUCCESS;
}
previousNode = currentNode;
currentNode = currentNode->next;
}
return FAILED;
}
/* TODO: Replace placeholder. */
return ERROR_VALUE;
} /* end of bipartGraphDeleteVertex() */
SP_MimeMailbox :: ~SP_MimeMailbox()
{
safeFree( mMailbox );
safeFree( mDomain );
safeFree( mName );
safeFree( mRoute );
mMailbox = mDomain = mName = mRoute = mNull;
}
int main(){
int *pi;
pi = (int*)malloc(sizeof(int));
*pi = 5;
printf("Before: %p\n", pi);
safeFree(pi);
printf("After: %p\n", pi);
safeFree(pi);
return(EXIT_SUCCESS);
}
void bipartGraphDestroy(bpGraph_t* pGraph)
{
/* TODO: Implement me! */
int i;
safeFree(pGraph->vVertExistP1, sizeof(pGraph->vertNum1 * sizeof(char)));
safeFree(pGraph->vVertExistP2, sizeof(pGraph->vertNum2 * sizeof(char)));
for (i = 0; i < pGraph->vertNum1; ++i)
{
safeFree(pGraph->vpVertsP1[i], sizeof(pGraph->vertNum2 * sizeof(int)));
}
for (i = 0; i < pGraph->vertNum2; ++i)
{
safeFree(pGraph->vpVertsP2[i], sizeof(pGraph->vertNum1 * sizeof(int)));
}
safeFree(pGraph->vpVertsP1, sizeof(pGraph->vertNum1 * sizeof(int *)));
safeFree(pGraph->vpVertsP2, sizeof(pGraph->vertNum2 * sizeof(int *)));
safeFree(pGraph->subCount1, sizeof(pGraph->vertNum1 * sizeof(int)));
safeFree(pGraph->subCount2, sizeof(pGraph->vertNum2 * sizeof(int)));
safeFree(pGraph, sizeof(bpGraph_t));
pGraph = NULL;
} /* end of bipartGraphDestroy() */
void bipartGraphDestroy(bpGraph_t* pGraph)
{
/* this function checks for NULL */
destroyTree(pGraph->adjTreeP1);
destroyTree(pGraph->adjTreeP2);
safeFree(pGraph->vertExistsP1, pGraph->numVertsP1 * sizeof(char));
safeFree(pGraph->vertExistsP2, pGraph->numVertsP2 * sizeof(char));
safeFree(pGraph, sizeof(bpGraph_t));
} /* end of bipartGraphDestroy() */
void destroyList(linkedList_t *pList)
{
llNode_t *pCurrNode = pList->pHead;
while (pCurrNode != NULL) {
llNode_t *pTempNode = pCurrNode->pNext;
safeFree(pCurrNode, sizeof(llNode_t));
pCurrNode = NULL;
pCurrNode = pTempNode;
}
pList->pHead = NULL;
pList->size = 0;
safeFree(pList, sizeof(linkedList_t));
} /* end of destroyList() */
void test_safeFree_NULL(){
int *memory001;
memory001=NULL;
safeFree(memory001);
}
void test_safeSummary(){
char *fa;
//fa=safeMalloc(20);
safeFree(fa);
safeSummary();
}
int respondToClientBySendingAGeneratedDirectoryList(struct AmmServer_Instance * instance,struct HTTPTransaction * transaction,char * servefile)
{
// We need to generate and serve a directory listing..!
strncpy(servefile,instance->webserver_root,MAX_FILE_PATH);
strncat(servefile,transaction->incomingHeader.resource,MAX_FILE_PATH);
ReducePathSlashes_Inplace(servefile);
unsigned long sendSize = 0;
char * replyBody = GenerateDirectoryPage(servefile,transaction->incomingHeader.resource,&sendSize);
if (replyBody !=0)
{
//If Directory_listing enabled and directory is ok , send the generated site
SendMemoryBlockAsFile(instance,"dir.html",transaction,replyBody ,sendSize);
if (replyBody !=0) { safeFree(replyBody,sendSize /*It just cleans the populated part of the buffer*/); }
logSuccess(instance,transaction,200,servefile);
} else
{
//If Directory listing disabled or directory is not ok send a 404
SendErrorFile(instance,transaction,404);
logError(instance,transaction,404,servefile);
return 0;
}
return 1;
}
/* Remark by Christoph: what about using evaluateConstantExpressionToInterval ? */
int mpfi_set_node( sollya_mpfi_t r, node * c, mp_prec_t prec) {
sollya_mpfi_t rr;
sollya_mpfi_t *rrr;
node *cc;
sollya_mpfi_t dummy;
/* mp_prec_t prec;*/
/* prec = getToolPrecision();*/
sollya_mpfi_init2(rr,prec);
sollya_mpfi_init2(dummy,prec);
rrr=safeMalloc(sizeof(sollya_mpfi_t));
sollya_mpfi_init2(*rrr,prec);
if (c!=NULL){
cc=simplifyTreeErrorfree(c);
switch (accessThruMemRef(cc)->nodeType){
case PI_CONST: sollya_mpfi_const_pi(rr);
break;
case CONSTANT:sollya_mpfi_set_fr(rr,*(accessThruMemRef(cc)->value));
break;
default: auto_diff(rrr,c,dummy,0); sollya_mpfi_set(rr, *rrr);
break;
}
free_memory(cc);
}
else sollya_mpfi_set_ui(rr,0);
sollya_mpfi_set(r,rr);
sollya_mpfi_clear(rr);
sollya_mpfi_clear(dummy);
sollya_mpfi_clear(*rrr);
safeFree(rrr);
return 0;
}
Fsm * fsmCreate (uint32 states, uint32 events, uint32 q_size,
uint32 state, fsmFuncPtr * action_table) {
Fsm * fsm;
/////////////////////////////////////////////////////////////////
// Create the fsm structure
fsm = (void*)safeMalloc(sizeof (Fsm));
if (fsm == NULL) {
SYS_ERROR (ERR_SERIAL_INIT_FAILED | 2);
return (Fsm *)ERROR;
}
fsm->q_events = fifo32Create(q_size);
if (fsm->q_events == NULL) {
safeFree (fsm);
SYS_ERROR (ERR_SERIAL_INIT_FAILED | 4);
return (Fsm *)ERROR;
}
fsm->state = state;
fsm->actions = action_table;
fsm->n_states = states;
fsm->n_events = events;
fsm->object_id = OBJID_FSM;
fsm->not_object_id = ~OBJID_FSM;
return fsm;
}
void bipartGraphDestroy(bpGraph_t* pGraph)
{
/* TODO: Implement me! */
destroyTree(pGraph->vpVertsP1);
destroyTree(pGraph->vpVertsP2);
safeFree(pGraph, sizeof(bpGraph_t));
pGraph = NULL;
} /* end of bipartGraphDestroy() */
void SP_MimeMailbox :: setDomain( const char * domain )
{
if( 0 == strcmp( domain, "unspecified-domain" ) ) domain = NULL;
char * tmp = mDomain;
mDomain = domain ? strdup( domain ) : mNull;
safeFree( tmp );
}
void bipartGraphDestroy(bpGraph_t* pGraph)
{
/* TODO: Implement me! */
int i;
safeFree(pGraph->vVertExistP1, sizeof(char) * pGraph->vertNum1);
safeFree(pGraph->vVertExistP2, sizeof(char) * pGraph->vertNum2);
for (i = 0; i < pGraph->vertNum1; ++i) {
if (pGraph->vpVertsP1[i] != NULL) {
safeFree(pGraph->vpVertsP1[i], sizeof(char) * pGraph->vertNum2);
}
}
safeFree(pGraph->vpVertsP1, sizeof(char) * pGraph->vertNum1);
for (i = 0; i < pGraph->vertNum2; ++i) {
if (pGraph->vpVertsP2[i] != NULL) {
safeFree(pGraph->vpVertsP2[i], sizeof(char) * pGraph->vertNum1);
}
}
safeFree(pGraph->vpVertsP2, sizeof(char) * pGraph->vertNum2);
safeFree(pGraph, sizeof(bpGraph_t));
/* make sure we can't accidentally use graph */
pGraph = NULL;
} /* end of bipartGraphDestroy() */
void bipartGraphDestroy(bpGraph_t* pGraph)
{
/* Destroy each partite tree */
destroyTree(*pGraph->vertices1);
destroyTree(*pGraph->vertices2);
/* Free the graph struct */
safeFree(pGraph, sizeof(pGraph));
} /* end of bipartGraphDestroy() */
/*wrapper to get directly the coeffs in the chebyshev basis up to degree n-1 (first n coeffs)
and a bound for the remaining polynomial,from a polynomial in the monomial basis(given by a pointer to node),
over a given interval x*/
void getNChebCoeffsFromPolynomial(sollya_mpfi_t *coeffs, sollya_mpfi_t bound, node *f, sollya_mpfi_t x, int n, int boundLevel){
sollya_mpfi_t **c, *r;
int d,i;
mp_prec_t prec;
prec=sollya_mpfi_get_prec(coeffs[0]);
c= (sollya_mpfi_t **)safeMalloc(sizeof(sollya_mpfi_t*));
getChebCoeffsFromPolynomial(c, &d, f, x, prec);
if (d<=n) {
for(i=0;i<d;i++)
sollya_mpfi_set(coeffs[i],(*c)[i]);
for(i=d;i<n;i++)
sollya_mpfi_set_ui(coeffs[i],0);
sollya_mpfi_set_ui(bound,0);
}
else{
/*in r we store only the upper part of the polynomial*/
/*r = [0, 0 ...., 0, c_n, ..., c_{d-1}] */
r = (sollya_mpfi_t *)safeMalloc((d)*sizeof(sollya_mpfi_t));
for(i=0; i < d; i++){
sollya_mpfi_init2(r[i], prec);
sollya_mpfi_set_ui(r[i],0);
}
for(i=0;i<n;i++)
sollya_mpfi_set(coeffs[i],(*c)[i]);
for(i=n;i<d;i++)
sollya_mpfi_set(r[i],(*c)[i]);
chebPolynomialBound(bound, d, r, boundLevel);
/*cleaning r*/
for(i=0; i < d; i++)
sollya_mpfi_clear(r[i]);
safeFree(r);
}
/*cleaning*/
for (i=0;i<d;i++){
sollya_mpfi_clear((*c)[i]);
}
safeFree(*c);
safeFree(c);
}
void bipartGraphDestroy(bpGraph_t* pGraph)
{
/* free the vertex list */
destroyVList(pGraph->vertices1);
destroyVList(pGraph->vertices2);
/* free the graph itself */
safeFree(pGraph, sizeof(bpGraph_t));
/* make sure we can't accidentally use graph */
pGraph = NULL;
} /* end of bipartGraphDestroy() */
/*Returns in chebCoeffs the coeffs of the finite Chebyshev basis expansion
of the polynomial p of degree n-1, over [-1,1];
The coefficients in monomial basis of p are in *p
This algorithm uses simply euclidean division.
*/
void getPolyCoeffsChebBasis(sollya_mpfi_t *chebCoeffs, sollya_mpfi_t *p, int n){
sollya_mpfi_t *pAux, temp;
mpz_t *chebMatrix;
int i,j;
mp_prec_t prec;
prec = sollya_mpfi_get_prec(chebCoeffs[0]);
pAux=safeMalloc((n)*sizeof(sollya_mpfi_t));
for (i=0;i<n;i++){
sollya_mpfi_init2(pAux[i],prec);
sollya_mpfi_set(pAux[i], p[i]);
}
chebMatrix=(mpz_t *)safeMalloc((n*n)*sizeof(mpz_t));
for (i=0;i<n*n;i++){
mpz_init2(chebMatrix[i],prec);
}
getChebPolyCoeffs(chebMatrix, n, prec);
sollya_mpfi_init2(temp,prec);
for(i=n-1; i>=0;i--){
mpfi_div_z(chebCoeffs[i],pAux[i],chebMatrix[i*n+i]);
for(j=i-1;j>=0;j--){
mpfi_mul_z(temp,chebCoeffs[i],chebMatrix[i*n+j]);
mpfi_sub(pAux[j],pAux[j],temp);
}
}
for (i=0;i<n;i++){
sollya_mpfi_clear(pAux[i]);
}
safeFree(pAux);
for (i=0;i<n*n;i++){
mpz_clear(chebMatrix[i]);
}
safeFree(chebMatrix);
sollya_mpfi_clear(temp);
}
void getChebMatrix(sollya_mpfi_t**chebMatrix, int n, mp_prec_t prec){
int i,j;
sollya_mpfi_t *chebPoints;
sollya_mpfi_t intrval;
sollya_mpfi_t temp;
/*mp_prec_t prec;*/
/*prec = getToolPrecision();*/
sollya_mpfi_init2(temp, prec);
chebPoints=safeMalloc((n)*sizeof(sollya_mpfi_t));
for (i=0;i<n;i++){
sollya_mpfi_init2(chebPoints[i],prec);
}
sollya_mpfi_init2(intrval,prec);
sollya_mpfi_interv_si(intrval,-1,1);
getChebyshevPoints(chebPoints, n, intrval);
*chebMatrix= (sollya_mpfi_t *)safeMalloc((n*n)*sizeof(sollya_mpfi_t));
for (i=0;i<n;i++){
for (j=0;j<n;j++){
sollya_mpfi_init2((*chebMatrix)[i*n+j],prec);
}
}
for (i=0;i<n;i++){
sollya_mpfi_set_ui((*chebMatrix)[i],1);
}
for (i=0;i<n;i++){
sollya_mpfi_set((*chebMatrix)[i+n],chebPoints[i]);
}
for (i=2;i<n;i++){
for (j=0;j<n;j++){
sollya_mpfi_mul(temp,(*chebMatrix)[(i-1)*n+j], (*chebMatrix)[n+j]);
sollya_mpfi_mul_ui(temp,temp,2);
sollya_mpfi_sub((*chebMatrix)[i*n+j],temp,(*chebMatrix)[(i-2)*n+j]);
}
}
sollya_mpfi_clear(intrval);
sollya_mpfi_clear(temp);
for (i=0;i<n;i++){
sollya_mpfi_clear(chebPoints[i]);
}
safeFree(chebPoints);
}
SP_MimeGroup :: ~SP_MimeGroup()
{
SP_MimeMailboxVector::iterator iter = mList.begin();
for( ; mList.end() != iter; ++iter ) {
delete (*iter);
}
mList.clear();
safeFree( mName );
mName = NULL;
}
/*Returns in c the coeffs in the monomial basis for the polynomial p(a*x+b), where:
-- a and b are mpfi_s
-- polynomial p of degree n-1 given by the monomial coefficients stored as mpfi_s in *p*/
void getTranslatedPolyCoeffs(sollya_mpfi_t *c, sollya_mpfi_t *p, int n, sollya_mpfi_t a, sollya_mpfi_t b){
sollya_mpfi_t *pAux, temp, pow, alpha, evalP;
int i;
mp_prec_t prec;
prec =sollya_mpfi_get_prec(c[0]);
pAux=safeMalloc((n)*sizeof(sollya_mpfi_t));
sollya_mpfi_init2(temp,prec);
sollya_mpfi_init2(pow,prec);
sollya_mpfi_init2(alpha,prec);
sollya_mpfi_init2(evalP,prec);
for (i=0;i<n;i++){
sollya_mpfi_init2(pAux[i],prec);
sollya_mpfi_set(pAux[i], p[i]);
}
/*do the transformation : P(a*x+b) = \sum p_i*a^i *(x+b/a)^i*/
for (i=0;i<n;i++){
sollya_mpfi_set_ui(pow,i);
sollya_mpfi_pow(temp, a,pow);
sollya_mpfi_mul(pAux[i], pAux[i],temp);
}
sollya_mpfi_div(alpha, b,a);
/*do the translation from P(x+alpha) --> Q(x)*/
/*P(x+alpha)= \sum P^{(i)}(alpha)/i! *x^i */
/*we have to compute the first n-1 derivatives in alpha: P(alpha), P'(alpha), ..., P^(n-1)(alpha)*/
/*evaluate P in alpha, P is of degree n-1*/
symbolic_poly_evaluation_horner(evalP, pAux,alpha,n-1);
sollya_mpfi_set(c[0],evalP);
mpfi_set_ui(temp, 1);
for(i=1;i<n;i++){
symbolic_poly_diff(pAux, pAux, n-i); /*differentiate in place pAux*/
symbolic_poly_evaluation_horner(evalP, pAux,alpha,n-i-1);/*evaluate P^(i)(alpha)*/
sollya_mpfi_mul_ui(temp,temp,i);
sollya_mpfi_div(c[i],evalP, temp);
}
for (i=0;i<n;i++){
sollya_mpfi_clear(pAux[i]);
}
safeFree(pAux);
sollya_mpfi_clear(temp);
sollya_mpfi_clear(pow);
sollya_mpfi_clear(alpha);
sollya_mpfi_clear(evalP);
}
void config_init(){
if(config_init_status == 1)
return;
config_init_status = 1;
FILE *fp;
long len;
char *data;
fp = fopen("config.json", "rb");
if (fp == NULL)
return;
fseek(fp, 0, SEEK_END);
len = ftell(fp);
fseek(fp, 0, SEEK_SET);
data= (char*) safeMalloc(len + 1);
fread(data, 1, len, fp);
fclose(fp);
cJSON *json = cJSON_Parse(data);
cJSON *subitem = json->child;
safeFree(data);
while (subitem){
if(subitem->type == cJSON_String)
config_add(subitem->string, subitem->valuestring);
if(subitem->type == cJSON_Number){
sprintf(data, "%d", subitem->valueint);
config_add(subitem->string, data);
}
if(subitem->type == cJSON_True)
config_add(subitem->string, "1");
if(subitem->type == cJSON_False)
config_add(subitem->string, "0");
subitem = subitem->next;
}
cJSON_Delete(json);
}
/*
-------------- -------------- -------------- -------------- -------------- --------------
-------------- -------------- -------------- -------------- -------------- --------------
The rest are easy , read / write operations
-------------- -------------- -------------- -------------- -------------- --------------
-------------- -------------- -------------- -------------- -------------- --------------
*/
char * astringReadFileToMemory(const char * filename,unsigned int *length )
{
*length = 0;
FILE * pFile = fopen ( filename , "rb" );
if (pFile==0)
{
fprintf(stderr,RED "AmmServer_ReadFileToMemory failed\n" NORMAL);
fprintf(stderr,RED "Could not read file %s \n" NORMAL,filename);
return 0;
}
// obtain file size:
fseek (pFile , 0 , SEEK_END);
unsigned long lSize = ftell (pFile);
rewind (pFile);
// allocate memory to contain the whole file:
unsigned long bufferSize = sizeof(char)*(lSize+1);
char * buffer = (char*) malloc (bufferSize);
if (buffer == 0 )
{
fprintf(stderr,RED "Could not allocate enough memory for file %s \n" NORMAL,filename);
fclose(pFile);
return 0;
}
// copy the file into the buffer:
size_t result = fread (buffer,1,lSize,pFile);
if (result != lSize)
{
safeFree(buffer,bufferSize);
fprintf(stderr,RED "Could not read the whole file onto memory %s \n" NORMAL,filename);
fclose(pFile);
return 0;
}
/* the whole file is now loaded in the memory buffer. */
// terminate
fclose (pFile);
buffer[lSize]=0; //Null Terminate Buffer!
*length = (unsigned int) lSize;
return buffer;
}
/*Wrapper that returns the coeffs
of the interpolation polynomial of f at chebpoints
*/
void getChebCoeffsFromFunction(sollya_mpfi_t* coeffs, sollya_mpfi_t * chebPoints, sollya_mpfi_t * chebMatrix,node *f,int n){
sollya_mpfi_t *fValues ;
int i;
mp_prec_t prec;
prec = sollya_mpfi_get_prec(coeffs[0]);
fValues=safeMalloc((n+1)*sizeof(sollya_mpfi_t));
for (i=0;i<=n;i++){
sollya_mpfi_init2(fValues[i],prec);
}
getFunctionValues(fValues, chebPoints,f,n);
getChebCoeffs(coeffs,chebMatrix,fValues,n);
for (i=0;i<=n;i++){
sollya_mpfi_clear(fValues[i]);
}
safeFree(fValues);
}
static TDHS_INLINE THD* init_THD(char* db, const void *stack_bottom,
bool need_write) {
THD *thd = NULL;
my_thread_init();
thd = new THD;
if (thd == NULL) {
my_thread_end();
return NULL;
}
thd->thread_stack = (char*) stack_bottom;
easy_debug_log("TDHS:thread_stack = %p sizeof(THD)=%zu sizeof(mtx)=%zu ",
thd->thread_stack, sizeof(THD), sizeof(LOCK_thread_count));
thd->store_globals();
thd->system_thread = static_cast<enum_thread_type>(1 << 30UL);
const NET v = { 0 };
thd->net = v;
if (need_write) {
//for write
#if MYSQL_VERSION_ID >= 50505
thd->variables.option_bits |= OPTION_BIN_LOG;
#else
thd->options |= OPTION_BIN_LOG;
#endif
}
//for db
safeFree(thd->db);
thd->db = db;
my_pthread_setspecific_ptr(THR_THD, thd);
tdhs_mysql_mutex_lock(&LOCK_thread_count);
thd->thread_id = thread_id++;
threads.append(thd);
++thread_count;
tdhs_mysql_mutex_unlock(&LOCK_thread_count);
return thd;
}
void SP_MimeGroup :: setName( const char * name )
{
char * tmp = mName;
mName = name ? strdup( name ) : mNull;
safeFree( tmp );
}
void SP_MimeMailbox :: setRoute( const char * route )
{
char * tmp = mRoute;
mRoute = route ? strdup( route ) : mNull;
safeFree( tmp );
}
