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

/* (re-)initialize a XDGMenuEntry storage */static void init_xdg_storage(XDGMenuEntry **xdg){	if ((*xdg)->Name)		wfree((*xdg)->Name);	if ((*xdg)->TryExec)		wfree((*xdg)->TryExec);	if ((*xdg)->Exec)		wfree((*xdg)->Exec);	if ((*xdg)->Category)		wfree((*xdg)->Category);	if ((*xdg)->Path)		wfree((*xdg)->Path);	(*xdg)->Name = NULL;	(*xdg)->TryExec = NULL;	(*xdg)->Exec = NULL;	(*xdg)->Category = NULL;	(*xdg)->Path = NULL;	(*xdg)->Flags = 0;	(*xdg)->MatchLevel = -1;}

PUBLIC int websSetUserRoles(char *username, char *roles){    WebsUser    *user;    assert(username &&*username);    if ((user = websLookupUser(username)) == 0) {        return -1;    }    wfree(user->roles);    user->roles = sclone(roles);    computeUserAbilities(user);    return 0;}

*/Wilddog_Conn_T* WD_SYSTEM _wilddog_conn_deinit(Wilddog_Repo_T*p_repo){    if( !p_repo || !p_repo->p_rp_conn )        return NULL;    /* destory list.*/    _wilddog_cm_ioctl(CM_CMD_DEINIT,p_repo->p_rp_conn->p_cm_l,0);        wfree( p_repo->p_rp_conn);    p_repo->p_rp_conn = NULL;        return NULL;

static void paintCursor(TextField * tPtr){	int cx;	WMScreen *screen = tPtr->view->screen;	int textWidth;	char *text;	if (tPtr->flags.secure)		text = makeHiddenString(strlen(tPtr->text));	else		text = tPtr->text;	cx = WMWidthOfString(tPtr->font, &(text[tPtr->viewPosition]), tPtr->cursorPosition - tPtr->viewPosition);	switch (tPtr->flags.alignment) {	case WARight:		textWidth = WMWidthOfString(tPtr->font, text, tPtr->textLen);		if (textWidth < tPtr->usableWidth)			cx += tPtr->offsetWidth + tPtr->usableWidth - textWidth + 1;		else			cx += tPtr->offsetWidth + 1;		break;	case WALeft:		cx += tPtr->offsetWidth + 1;		break;	case WAJustified:		/* not supported */	case WACenter:		textWidth = WMWidthOfString(tPtr->font, text, tPtr->textLen);		if (textWidth < tPtr->usableWidth)			cx += tPtr->offsetWidth + (tPtr->usableWidth - textWidth) / 2;		else			cx += tPtr->offsetWidth;		break;	}	/*	   XDrawRectangle(screen->display, tPtr->view->window, screen->xorGC,	   cx, tPtr->offsetWidth, 1,	   tPtr->view->size.height - 2*tPtr->offsetWidth - 1);	   printf("%d %d/n",cx,tPtr->cursorPosition);	 */	XDrawLine(screen->display, tPtr->view->window, screen->xorGC,		  cx, tPtr->offsetWidth, cx, tPtr->view->size.height - tPtr->offsetWidth - 1);	W_SetPreeditPositon(tPtr->view, cx, 0);	if (tPtr->flags.secure) {		wfree(text);	}}

WMTextField *WMCreateTextField(WMWidget * parent){	TextField *tPtr;	tPtr = wmalloc(sizeof(TextField));	tPtr->widgetClass = WC_TextField;	tPtr->view = W_CreateView(W_VIEW(parent));	if (!tPtr->view) {		wfree(tPtr);		return NULL;	}	tPtr->view->self = tPtr;	tPtr->view->delegate = &_TextFieldViewDelegate;	tPtr->view->attribFlags |= CWCursor;	tPtr->view->attribs.cursor = tPtr->view->screen->textCursor;	W_SetViewBackgroundColor(tPtr->view, tPtr->view->screen->white);	tPtr->text = wmalloc(MIN_TEXT_BUFFER);	tPtr->textLen = 0;	tPtr->bufferSize = MIN_TEXT_BUFFER;	tPtr->flags.enabled = 1;	WMCreateEventHandler(tPtr->view, ExposureMask | StructureNotifyMask | FocusChangeMask, handleEvents, tPtr);	tPtr->font = WMRetainFont(tPtr->view->screen->normalFont);	tPtr->flags.bordered = DEFAULT_BORDERED;	tPtr->flags.beveled = True;	tPtr->flags.alignment = DEFAULT_ALIGNMENT;	tPtr->offsetWidth = WMAX((tPtr->view->size.height - WMFontHeight(tPtr->font)) / 2, 1);	W_ResizeView(tPtr->view, DEFAULT_WIDTH, DEFAULT_HEIGHT);	WMCreateEventHandler(tPtr->view, EnterWindowMask | LeaveWindowMask			     | ButtonReleaseMask | ButtonPressMask | KeyPressMask | Button1MotionMask,			     handleTextFieldActionEvents, tPtr);	WMAddNotificationObserver(selectionNotification, tPtr->view,				  WMSelectionOwnerDidChangeNotification, (void *)XA_PRIMARY);	WMAddNotificationObserver(realizeObserver, tPtr, WMViewRealizedNotification, tPtr->view);	tPtr->flags.cursorOn = 1;	return tPtr;}

char *GetShortcutString(const char *shortcut){	char *buffer = NULL;	char *k;	int control = 0;	char *tmp, *text;	tmp = text = wstrdup(shortcut);	/* get modifiers */	while ((k = strchr(text, '+')) != NULL) {		int mod;		*k = 0;		mod = wXModifierFromKey(text);		if (mod < 0) {			return wstrdup("bug");		}		if (strcasecmp(text, "Meta") == 0) {			buffer = wstrappend(buffer, "M+");		} else if (strcasecmp(text, "Alt") == 0) {			buffer = wstrappend(buffer, "A+");		} else if (strcasecmp(text, "Shift") == 0) {			buffer = wstrappend(buffer, "Sh+");		} else if (strcasecmp(text, "Mod1") == 0) {			buffer = wstrappend(buffer, "M1+");		} else if (strcasecmp(text, "Mod2") == 0) {			buffer = wstrappend(buffer, "M2+");		} else if (strcasecmp(text, "Mod3") == 0) {			buffer = wstrappend(buffer, "M3+");		} else if (strcasecmp(text, "Mod4") == 0) {			buffer = wstrappend(buffer, "M4+");		} else if (strcasecmp(text, "Mod5") == 0) {			buffer = wstrappend(buffer, "M5+");		} else if (strcasecmp(text, "Control") == 0) {			control = 1;		} else {			buffer = wstrappend(buffer, text);		}		text = k + 1;	}	if (control) {		buffer = wstrappend(buffer, "^");	}	buffer = wstrappend(buffer, text);	wfree(tmp);	return buffer;}

/*    Free a socket structure */PUBLIC void socketFree(int sid){    WebsSocket  *sp;    char        buf[256];    int         i;    if ((sp = socketPtr(sid)) == NULL) {        return;    }    /*        To close a socket, remove any registered interests, set it to non-blocking so that the recv which follows won't        block, do a shutdown on it so peers on the other end will receive a FIN, then read any data not yet retrieved        from the receive buffer, and finally close it.  If these steps are not all performed RESETs may be sent to the        other end causing problems.     */    socketRegisterInterest(sid, 0);    if (sp->sock >= 0) {        socketSetBlock(sid, 0);        while (recv(sp->sock, buf, sizeof(buf), 0) > 0) {}        if (shutdown(sp->sock, SHUT_RDWR) >= 0) {            while (recv(sp->sock, buf, sizeof(buf), 0) > 0) {}        }        closesocket(sp->sock);    }    wfree(sp->ip);    wfree(sp);    socketMax = wfreeHandle(&socketList, sid);    /*        Calculate the new highest socket number     */    socketHighestFd = -1;    for (i = 0; i < socketMax; i++) {        if ((sp = socketList[i]) == NULL) {            continue;        }         socketHighestFd = max(socketHighestFd, sp->sock);    }}

static void findCopyFile(const char *dir, const char *file){	char *fullPath;	fullPath = wfindfileinarray(PixmapPath, file);	if (!fullPath) {		wwarning("Could not find file %s", file);		if (ThemePath)			(void)wrmdirhier(ThemePath);		return;	}	wcopy_file(dir, fullPath, file);	wfree(fullPath);}

voidsocket_buffer_delete(struct socket_buffer *b) {	if (b->head.msg != NULL) {		weenet_message_unref(b->head.msg);		for (size_t i=0, n=b->tail.num; i<n; ++i) {			weenet_message_unref(b->tail.slots[i]);		}	}	if (b->tail.slots != NULL) {		wfree(b->tail.slots);	}	weenet_event_monitor(b->self, 0, b->fd, WEVENT_DELETE, WEVENT_READ);	weenet_event_monitor(b->self, 0, b->fd, WEVENT_DELETE, WEVENT_WRITE);}

void WMReleasePixmap(WMPixmap * pixmap){	wassertr(pixmap != NULL);	pixmap->refCount--;	if (pixmap->refCount < 1) {		if (pixmap->pixmap)			XFreePixmap(pixmap->screen->display, pixmap->pixmap);		if (pixmap->mask)			XFreePixmap(pixmap->screen->display, pixmap->mask);		wfree(pixmap);	}}

void WMSetBrowserColumnTitle(WMBrowser * bPtr, int column, const char *title){	assert(column >= 0);	assert(column < bPtr->usedColumnCount);	if (bPtr->titles[column])		wfree(bPtr->titles[column]);	bPtr->titles[column] = wstrdup(title);	if (COLUMN_IS_VISIBLE(bPtr, column) && bPtr->flags.isTitled) {		drawTitleOfColumn(bPtr, column);	}}

/** * Map iterator to free cached entries. */static boolfree_cached(void *key, void *value, void *data){	dbmw_t *dw = data;	struct cached *entry = value;	dbmw_check(dw);	g_assert(!entry->len == !entry->data);	free_value(dw, entry, TRUE);	wfree(key, dbmw_keylen(dw, key));	WFREE(entry);	return TRUE;}

PUBLIC bool websLoginUser(Webs *wp, char *username, char *password){    assert(wp);    assert(wp->route);    assert(username);    assert(password);    if (!wp->route || !wp->route->verify) {        return 0;    }    wfree(wp->username);    wp->username = sclone(username);    wfree(wp->password);    wp->password = sclone(password);    if (!(wp->route->verify)(wp)) {        trace(2, "Password does not match");        return 0;    }    trace(2, "Login successful for %s", username);    websSetSessionVar(wp, WEBS_SESSION_USERNAME, wp->username);                                    return 1;}

/* * Function:    wrealloc * Description: Realloc the souce pointer's length. * Input:       ptr: old pointer. *              size: new length you want. * Output:      N/A * Return:      New pointer.*/void * WD_SYSTEM wrealloc(void *ptr, size_t oldSize, size_t newSize){#if defined(WILDDOG_PORT_TYPE_QUCETEL) || defined(WILDDOG_PORT_TYPE_ESP)    void* tmpPtr = NULL;#endif    if(!ptr)        return wmalloc(newSize);#if defined(WILDDOG_PORT_TYPE_QUCETEL) || defined(WILDDOG_PORT_TYPE_ESP)    tmpPtr = (void*)wmalloc(newSize);    if(!tmpPtr)    {        wfree(ptr);        return NULL;    }    memcpy(tmpPtr, ptr, oldSize > newSize? (newSize):(oldSize));    wfree(ptr);    return tmpPtr;#else    return realloc( ptr, newSize);#endif}

static void endDragProcess(WMDraggingInfo * info, Bool deposited){	WMView *view = XDND_SOURCE_VIEW(info);	WMScreen *scr = W_VIEW_SCREEN(XDND_SOURCE_VIEW(info));	/* free selection handler while view exists */	WMDeleteSelectionHandler(view, scr->xdndSelectionAtom, CurrentTime);	wfree(XDND_SELECTION_PROCS(info));	if (XDND_DRAG_CURSOR(info) != None) {		XFreeCursor(scr->display, XDND_DRAG_CURSOR(info));		XDND_DRAG_CURSOR(info) = None;	}	if (view->dragSourceProcs->endedDrag != NULL) {		/* this can destroy source view (with a "move" action for example) */		view->dragSourceProcs->endedDrag(view, &XDND_DRAG_ICON_POS(info), deposited);	}	/* clear remaining draggging infos */	wfree(XDND_SOURCE_INFO(info));	XDND_SOURCE_INFO(info) = NULL;}

void WMSetLabelText(WMLabel * lPtr, const char *text){	if (lPtr->caption)		wfree(lPtr->caption);	if (text != NULL) {		lPtr->caption = wstrdup(text);	} else {		lPtr->caption = NULL;	}	if (lPtr->view->flags.realized) {		paintLabel(lPtr);	}}

/** * Map iterator to free cached entries. */static gbooleanfree_cached(gpointer key, gpointer value, gpointer data){	dbmw_t *dw = data;	struct cached *entry = value;	dbmw_check(dw);	g_assert(!entry->len == !entry->data);	free_value(dw, entry, TRUE);	wfree(key, dbmw_keylen(dw, key));	WFREE(entry);	return TRUE;}

PUBLIC void sslFree(Webs *wp){    Nano        *np;        if (wp->ssl) {        np = wp->ssl;        if (np->handle) {            SSL_closeConnection(np->handle);            np->handle = 0;        }        wfree(np);        wp->ssl = 0;    }}

static int init_mode(int new_mode, const char *paletname) {    Uint32 mode_flags;    const SDL_VideoInfo *vi;    int las, las2;    int w = (new_mode == SVGA_MODE) ? 800 : 320;    int h = (new_mode == SVGA_MODE) ? 600 : 200;    init_video();    mode_flags = SDL_HWSURFACE | SDL_DOUBLEBUF | SDL_HWPALETTE;    if (!draw_with_vircr_mode)        mode_flags |= SDL_ANYFORMAT;    //if (wantfullscreen)     //   mode_flags |= SDL_FULLSCREEN;    if (draw_with_vircr_mode && pixel_multiplier > 1)        wfree(vircr);    pixel_multiplier = (new_mode == SVGA_MODE) ? pixel_multiplier_svga : pixel_multiplier_vga;    video_state.surface = SDL_SetVideoMode(w * pixel_multiplier, h * pixel_multiplier, 8, mode_flags);    assert(video_state.surface);    if (draw_with_vircr_mode) {        if (pixel_multiplier > 1) {            vircr = (uint8_t *) walloc(w * h);        } else {            vircr = (uint8_t *) video_state.surface->pixels;        }    }    /* else vircr is preallocated in init_video */    vi = SDL_GetVideoInfo();    video_state.haverealpalette = (vi->vfmt->palette != NULL);    dksopen(paletname);    dksread(ruutu.normaalipaletti, sizeof(ruutu.normaalipaletti));    for (las = 0; las < 256; las++)        for (las2 = 0; las2 < 3; las2++)            ruutu.paletti[las][las2] = ruutu.normaalipaletti[las][las2];    dksclose();    setpal_range(ruutu.paletti, 0, 256);    all_bitmaps_refresh();    current_mode = new_mode;    return 1;}

WMRuler *WMCreateRuler(WMWidget * parent){	Ruler *rPtr = wmalloc(sizeof(Ruler));	unsigned int w = WMWidgetWidth(parent);	rPtr->widgetClass = WC_Ruler;	rPtr->view = W_CreateView(W_VIEW(parent));	if (!rPtr->view) {		wfree(rPtr);		return NULL;	}	rPtr->view->self = rPtr;	rPtr->drawBuffer = (Pixmap) NULL;	W_ResizeView(rPtr->view, w, 40);	WMCreateEventHandler(rPtr->view, ExposureMask | StructureNotifyMask			     | EnterWindowMask | LeaveWindowMask | FocusChangeMask			     | ButtonReleaseMask | ButtonPressMask | KeyReleaseMask			     | KeyPressMask | Button1MotionMask, handleEvents, rPtr);	rPtr->view->delegate = &_RulerViewDelegate;	rPtr->fg = WMBlackColor(rPtr->view->screen);	rPtr->fgGC = WMColorGC(rPtr->fg);	rPtr->bgGC = WMColorGC(WMGrayColor(rPtr->view->screen));	rPtr->font = WMSystemFontOfSize(rPtr->view->screen, 8);	rPtr->offset = 22;	rPtr->margins.left = 22;	rPtr->margins.body = 22;	rPtr->margins.first = 42;	rPtr->margins.right = (w < 502 ? w : 502);	rPtr->margins.tabs = NULL;	rPtr->flags.whichMarker = 0;	/* none */	rPtr->flags.buttonPressed = False;	rPtr->flags.redraw = True;	rPtr->moveAction = NULL;	rPtr->releaseAction = NULL;	rPtr->pview = W_VIEW(parent);	return rPtr;}

// free the data item by using empty string// Item = the item to freevoid FreeDataItem(WIDATAITEM *Item){	wfree(&Item->Name);	wfree(&Item->Start);	wfree(&Item->End);	wfree(&Item->Unit);	wfree(&Item->Url);	wfree(&Item->Break);}

int wWorkspaceNew(WScreen *scr){	WWorkspace *wspace, **list;	int i;	if (w_global.workspace.count < MAX_WORKSPACES) {		w_global.workspace.count++;		wspace = wmalloc(sizeof(WWorkspace));		wspace->name = NULL;		wspace->clip = NULL;		if (!wspace->name) {			static const char *new_name = NULL;			static size_t name_length;			if (new_name == NULL) {				new_name = _("Workspace %i");				name_length = strlen(new_name) + 8;			}			wspace->name = wmalloc(name_length);			snprintf(wspace->name, name_length, new_name, w_global.workspace.count);		}		if (!wPreferences.flags.noclip)			wspace->clip = wDockCreate(scr, WM_CLIP, NULL);		list = wmalloc(sizeof(WWorkspace *) * w_global.workspace.count);		for (i = 0; i < w_global.workspace.count - 1; i++)			list[i] = w_global.workspace.array[i];		list[i] = wspace;		if (w_global.workspace.array)			wfree(w_global.workspace.array);		w_global.workspace.array = list;		wWorkspaceMenuUpdate(w_global.workspace.menu);		wWorkspaceMenuUpdate(w_global.clip.ws_menu);		wNETWMUpdateDesktop(scr);		WMPostNotificationName(WMNWorkspaceCreated, scr, (void *)(uintptr_t) (w_global.workspace.count - 1));		XFlush(dpy);		return w_global.workspace.count - 1;	}	return -1;}

void PropSetIconTileHint(virtual_screen *vscr, RImage *image){	static Atom imageAtom = 0;	unsigned char *tmp;	int x, y;	if (vscr->screen_ptr->info_window == None)		return;	if (!imageAtom) {		/*		 * WIDTH, HEIGHT (16 bits, MSB First)		 * array of R,G,B,A bytes		 */		imageAtom = XInternAtom(dpy, "_RGBA_IMAGE", False);	}	tmp = malloc(image->width * image->height * 4 + 4);	if (!tmp) {		wwarning("could not allocate memory to set _WINDOWMAKER_ICON_TILE hint");		return;	}	tmp[0] = image->width >> 8;	tmp[1] = image->width & 0xff;	tmp[2] = image->height >> 8;	tmp[3] = image->height & 0xff;	if (image->format == RRGBAFormat) {		memcpy(&tmp[4], image->data, image->width * image->height * 4);	} else {		char *ptr = (char *)(tmp + 4);		char *src = (char *)image->data;		for (y = 0; y < image->height; y++) {			for (x = 0; x < image->width; x++) {				*ptr++ = *src++;				*ptr++ = *src++;				*ptr++ = *src++;				*ptr++ = 255;			}		}	}	XChangeProperty(dpy, vscr->screen_ptr->info_window, w_global.atom.wmaker.icon_tile,			imageAtom, 8, PropModeReplace, tmp, image->width * image->height * 4 + 4);	wfree(tmp);}

char* MountISO(const char* path){	VIRTUAL_STORAGE_TYPE vtype = { 1, VIRTUAL_STORAGE_TYPE_VENDOR_MICROSOFT };	ATTACH_VIRTUAL_DISK_PARAMETERS vparams = {0};	DWORD r;	wchar_t wtmp[128];	ULONG size = ARRAYSIZE(wtmp);	wconvert(path);	char* ret = NULL;	PF_INIT_OR_OUT(OpenVirtualDisk, VirtDisk);	PF_INIT_OR_OUT(AttachVirtualDisk, VirtDisk);	PF_INIT_OR_OUT(GetVirtualDiskPhysicalPath, VirtDisk);	if ((mounted_handle != NULL) && (mounted_handle != INVALID_HANDLE_VALUE))		UnMountISO();	r = pfOpenVirtualDisk(&vtype, wpath, VIRTUAL_DISK_ACCESS_READ | VIRTUAL_DISK_ACCESS_GET_INFO,		OPEN_VIRTUAL_DISK_FLAG_NONE, NULL, &mounted_handle);	if (r != ERROR_SUCCESS) {		SetLastError(r);		uprintf("Could not open ISO '%s': %s", path, WindowsErrorString());		goto out;	}	vparams.Version = ATTACH_VIRTUAL_DISK_VERSION_1;	r = pfAttachVirtualDisk(mounted_handle, NULL, ATTACH_VIRTUAL_DISK_FLAG_READ_ONLY |		ATTACH_VIRTUAL_DISK_FLAG_NO_DRIVE_LETTER, 0, &vparams, NULL);	if (r != ERROR_SUCCESS) {		SetLastError(r);		uprintf("Could not mount ISO '%s': %s", path, WindowsErrorString());		goto out;	}	r = pfGetVirtualDiskPhysicalPath(mounted_handle, &size, wtmp);	if (r != ERROR_SUCCESS) {		SetLastError(r);		uprintf("Could not obtain physical path for mounted ISO '%s': %s", path, WindowsErrorString());		goto out;	}	wchar_to_utf8_no_alloc(wtmp, physical_path, sizeof(physical_path));	ret = physical_path;out:	if (ret == NULL)		UnMountISO();	wfree(path);	return ret;}

/** * This function executes the extraction process. * * @param infos Informations about the launch process. */void processAll(t_launch_infos *infos){  t_binary_image *pic;  SDL_Surface *image;  t_cc_list *cc_list;    pic = NULL;  image = NULL;  image = SDL_LoadBMP(infos->inFile);  if (image != NULL)    {       if (infos->verbose)	printf("/n >> Image %s loaded./n", infos->inFile);      pic = bitmap_to_binaryimage(image,infos->inFile);      if (pic != NULL)	{ 	  if (infos->verbose)	    printf(" >> Binarization done./n");	  cc_list = findCC(pic->matrix);	  if (cc_list != NULL)	    {	      checkIfCharacter(cc_list, pic->height, pic->width);	      if (infos->verbose)		printf(" >> Extraction of %d characters done./n", cc_list->nbcc);	      updateCC(cc_list);	      exportCC(cc_list, pic);	      	      /*traceCC(image, cc_list); */	      if (SDL_SaveBMP(image, infos->outFile) < 0)		fprintf(stderr," > SDL BMP saving error </n");	      else		if (infos->verbose)		  printf(" >> Image %s saved./n/n", infos->outFile);	      /* free_listCC(cc_list) */	      free_pic(pic);	    }	}      SDL_FreeSurface(image);    }  else    {      fprintf(stderr, " > SDL BMP Loader error </n");      wfree(infos);      exit(EXIT_FAILURE);    }}

/*    Any entry in the cgiList need to be checked to see if it has completed, and if so, process its output and clean up.    Return time till next poll. */WebsTime websCgiPoll(){    Webs    *wp;    Cgi     *cgip;    char    **ep;    int     cid, nTries;    for (cid = 0; cid < cgiMax; cid++) {        if ((cgip = cgiList[cid]) != NULL) {            wp = cgip->wp;            websCgiGatherOutput(cgip);            if (checkCgi(cgip->handle) == 0) {                /*                    We get here if the CGI process has terminated. Clean up.                 */                for (nTries = 0; (cgip->fplacemark == 0) && (nTries < 100); nTries++) {                    websCgiGatherOutput(cgip);                    /*                                           There are some cases when we detect app exit before the file is ready.                      */                    if (cgip->fplacemark == 0) {#if WINDOWS                        Sleep(10);#endif                    }                }                if (cgip->fplacemark == 0) {                    websError(wp, HTTP_CODE_INTERNAL_SERVER_ERROR, "CGI generated no output");                } else {                    trace(5, "cgi: Request complete - calling websDone");                    websDone(wp);                }                /*                    Remove the temporary re-direction files                 */                unlink(cgip->stdIn);                unlink(cgip->stdOut);                /*                    Free all the memory buffers pointed to by cgip. The stdin file name (wp->cgiStdin) gets freed as                    part of websFree().                 */                cgiMax = wfreeHandle(&cgiList, cid);                for (ep = cgip->envp; ep != NULL && *ep != NULL; ep++) {                    wfree(*ep);                }                wfree(cgip->cgiPath);                wfree(cgip->argp);                wfree(cgip->envp);                wfree(cgip->stdOut);                wfree(cgip);                websPump(wp);            }        }    }    return cgiMax ? 10 : MAXINT;}

void freeMemcacheData(void *d){    struct memcacheProcData *data = d;    if (data->command)        wstrFree(data->command);    if (data->key)        wstrFree(data->key);    if (data->keys) {        arrayEach(data->keys, freeKey);        arrayDealloc(data->keys);    }    if (data->vals)        arrayDealloc(data->vals);    wfree(d);}