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

voidcreatealiastable(void){    aliastab = newhashtable(23);    aliastab->hash        = hasher;    aliastab->emptytable  = NULL;    aliastab->filltable   = NULL;    aliastab->addnode     = addhashnode;    aliastab->getnode     = gethashnode;    aliastab->getnode2    = gethashnode2;    aliastab->removenode  = removehashnode;    aliastab->disablenode = disablehashnode;    aliastab->enablenode  = enablehashnode;    aliastab->freenode    = freealiasnode;    aliastab->printnode   = printaliasnode;#ifdef ZSH_HASH_DEBUG    aliastab->printinfo   = printhashtabinfo;    aliastab->tablename   = ztrdup("aliastab");#endif    /* add the default aliases */    aliastab->addnode(aliastab, ztrdup("run-help"), createaliasnode(ztrdup("man"), 0));    aliastab->addnode(aliastab, ztrdup("which-command"), createaliasnode(ztrdup("whence"), 0));}

voidhashdir(char **dirp){    Cmdnam cn;    DIR *dir;    char *fn;    if (isrelative(*dirp) || !(dir = opendir(unmeta(*dirp))))	return;    while ((fn = zreaddir(dir))) {	/* Ignore `.' and `..'. */	if (fn[0] == '.' &&	    (fn[1] == '/0' ||	     (fn[1] == '.' && fn[2] == '/0')))	    continue;#ifndef WINNT	if (!cmdnamtab->getnode(cmdnamtab, fn)) {	    cn = (Cmdnam) zcalloc(sizeof *cn);	    cn->flags = 0;	    cn->u.name = dirp;	    cmdnamtab->addnode(cmdnamtab, ztrdup(fn), cn);	}#else	if (!cmdnamtab->getnode(cmdnamtab, fn)) {	    char *fext;	    fext = fn;	    while(*fext++)		;	    while((fext >fn )&& (*fext != '.'))		fext--;	    if ( (fext == fn) /*no extension */		    || is_pathext(fext+1) ) {		cn = (Cmdnam) zcalloc(sizeof *cn);		cn->flags = 0;		cn->u.name = dirp;		cmdnamtab->addnode(cmdnamtab, ztrdup(fn), cn);		/*if (fext != fn && !strnicmp(fext+1,"exe",3)) */		*fext = 0;		cn = (Cmdnam) zcalloc(sizeof *cn);		cn->flags = 0;		cn->u.name = dirp;		cmdnamtab->addnode(cmdnamtab, ztrdup(fn), cn);	    }#ifdef ZSH_HASH_DEBUG	    printhashtabinfo(cmdnamtab);#endif /* ZSH_HASH_DEBUG */	}#endif /* WINNT */    }    closedir(dir);}

mod_export char *zlegetline(int *ll, int *cs){    if (zlemetaline != NULL) {	*ll = zlemetall;	*cs = zlemetacs;	return ztrdup(zlemetaline);    }    if (zleline)	return zlelineasstring(zleline, zlell, zlecs, ll, cs, 0);    *ll = *cs = 0;    return ztrdup("");}

voidsetline(char *s, int flags){    char *scp;    UNMETACHECK();    if (flags & ZSL_COPY)	scp = ztrdup(s);    else	scp = s;    /*     * TBD: we could make this more efficient by passing the existing     * allocated line to stringaszleline.     */    free(zleline);    zleline = stringaszleline(scp, 0, &zlell, &linesz, NULL);    if ((flags & ZSL_TOEND) && (zlecs = zlell) && invicmdmode())	DECCS();    else if (zlecs > zlell)	zlecs = zlell;    CCRIGHT();    if (flags & ZSL_COPY)	free(scp);}

static voidsetpmmapfiles(Param pm, HashTable ht){    int i;    HashNode hn;    /* just to see if I've understood what's happening */    DPUTS(pm != mapfile_pm, "BUG: setpmmapfiles called for wrong param");    if (!ht)	return;    if (!(pm->flags & PM_READONLY))	for (i = 0; i < ht->hsize; i++)	    for (hn = ht->nodes[i]; hn; hn = hn->next) {		struct value v;		v.isarr = v.inv = v.start = 0;		v.end = -1;		v.arr = NULL;		v.pm = (Param) hn;		setpmmapfile(v.pm, ztrdup(getstrvalue(&v)));	    }    deleteparamtable(ht);}

static voidset_compstate(UNUSED(Param pm), HashTable ht){    struct compparam *cp;    Param *pp;    HashNode hn;    int i;    struct value v;    char *str;    if (!ht)        return;    for (i = 0; i < ht->hsize; i++)	for (hn = ht->nodes[i]; hn; hn = hn->next)	    for (cp = compkparams,		 pp = compkpms; cp->name; cp++, pp++)		if (!strcmp(hn->nam, cp->name)) {		    v.isarr = v.flags = v.start = 0;		    v.end = -1;		    v.arr = NULL;		    v.pm = (Param) hn;		    if (cp->type == PM_INTEGER)			*((zlong *) cp->var) = getintvalue(&v);		    else if ((str = getstrvalue(&v))) {			zsfree(*((char **) cp->var));			*((char **) cp->var) = ztrdup(str);		    }		    (*pp)->node.flags &= ~PM_UNSET;		    break;		}    deleteparamtable(ht);}

mod_export Cpatterncp_cpattern_element(Cpattern o){    Cpattern n = zalloc(sizeof(struct cpattern));    n->next = NULL;    n->tp = o->tp;    switch (o->tp)    {    case CPAT_CCLASS:    case CPAT_NCLASS:    case CPAT_EQUIV:	n->u.str = ztrdup(o->u.str);	break;    case CPAT_CHAR:	n->u.chr = o->u.chr;	break;    default:	/* just to keep compiler quiet */	break;    }    return n;}

voidcreatereswdtable(void){    Reswd rw;    reswdtab = newhashtable(23);    reswdtab->hash        = hasher;    reswdtab->emptytable  = NULL;    reswdtab->filltable   = NULL;    reswdtab->addnode     = addhashnode;    reswdtab->getnode     = gethashnode;    reswdtab->getnode2    = gethashnode2;    reswdtab->removenode  = NULL;    reswdtab->disablenode = disablehashnode;    reswdtab->enablenode  = enablehashnode;    reswdtab->freenode    = NULL;    reswdtab->printnode   = printreswdnode;#ifdef ZSH_HASH_DEBUG    reswdtab->printinfo   = printhashtabinfo;    reswdtab->tablename   = ztrdup("reswdtab");#endif    for (rw = reswds; rw->nam; rw++)	reswdtab->addnode(reswdtab, rw->nam, rw);}

voidcreatebuiltintable(void){    Builtin bn;    builtintab = newhashtable(85);    builtintab->hash        = hasher;    builtintab->emptytable  = NULL;    builtintab->filltable   = NULL;    builtintab->addnode     = addhashnode;    builtintab->getnode     = gethashnode;    builtintab->getnode2    = gethashnode2;    builtintab->removenode  = NULL;    builtintab->disablenode = disablehashnode;    builtintab->enablenode  = enablehashnode;    builtintab->freenode    = NULL;    builtintab->printnode   = printbuiltinnode;#ifdef ZSH_HASH_DEBUG    builtintab->printinfo   = printhashtabinfo;    builtintab->tablename   = ztrdup("builtintab");#endif    for (bn = builtins; bn->nam; bn++)	builtintab->addnode(builtintab, bn->nam, bn);}

static intdomove(char *nam, MoveFunc movefn, char *p, char *q, int flags){    struct stat st;    char *pbuf, *qbuf;    pbuf = ztrdup(unmeta(p));    qbuf = unmeta(q);    if(flags & MV_NODIRS) {	errno = EISDIR;	if(lstat(pbuf, &st) || S_ISDIR(st.st_mode)) {	    zwarnnam(nam, "%s: %e", p, errno);	    zsfree(pbuf);	    return 1;	}    }    if(!lstat(qbuf, &st)) {	int doit = flags & MV_FORCE;	if(S_ISDIR(st.st_mode)) {	    zwarnnam(nam, "%s: cannot overwrite directory", q);	    zsfree(pbuf);	    return 1;	} else if(flags & MV_INTERACTIVE) {	    nicezputs(nam, stderr);	    fputs(": replace `", stderr);	    nicezputs(q, stderr);	    fputs("'? ", stderr);	    fflush(stderr);	    if(!ask()) {		zsfree(pbuf);		return 0;	    }	    doit = 1;	} else if((flags & MV_ASKNW) &&		!S_ISLNK(st.st_mode) &&		access(qbuf, W_OK)) {	    nicezputs(nam, stderr);	    fputs(": replace `", stderr);	    nicezputs(q, stderr);	    fprintf(stderr, "', overriding mode %04o? ",		mode_to_octal(st.st_mode));	    fflush(stderr);	    if(!ask()) {		zsfree(pbuf);		return 0;	    }	    doit = 1;	}	if(doit && !(flags & MV_ATOMIC))	    unlink(qbuf);    }    if(movefn(pbuf, qbuf)) {	zwarnnam(nam, "%s: %e", p, errno);	zsfree(pbuf);	return 1;    }    zsfree(pbuf);    return 0;}

/** * This function will be called whenever the prompt is drawn by the zle. * Sets the zsh global variable 'prompt' which is equivalent to the env * PROMPT / PS1. */static void rift_prompt(void){  const char* rw_prompt = rwcli_get_prompt();  if (rw_prompt) {    zfree(prompt, 0);    prompt = ztrdup(rw_prompt);  }}

mod_export voidmakesuffixstr(char *f, char *s, int n){    if (f) {	zsfree(suffixfunc);	suffixfunc = ztrdup(f);	suffixfunclen = n;    } else if (s) {	int inv, i, z = 0;	ZLE_STRING_T ws, lasts, wptr;	if (*s == '^' || *s == '!') {	    inv = 1;	    s++;	} else	    inv = 0;	s = getkeystring(s, &i, GETKEYS_SUFFIX, &z);	s = metafy(s, i, META_USEHEAP);	ws = stringaszleline(s, 0, &i, NULL, NULL);	if (z)	    suffixnoinslen = inv ? 0 : n;	else if (inv) {	    /*	     * negative match, /- wasn't present, so it *should*	     * have this suffix length	     */	    suffixnoinslen = n;	}	lasts = wptr = ws;	while (i) {	    if (i >= 3 && wptr[1] == ZWC('-')) {		ZLE_CHAR_T str[2];		if (wptr > lasts)		    addsuffix(inv ? SUFTYP_NEGSTR : SUFTYP_POSSTR, 0,			      lasts, wptr - lasts, n);		str[0] = *wptr;		str[1] = wptr[2];		addsuffix(inv ? SUFTYP_NEGRNG : SUFTYP_POSRNG, 0,			  str, 2, n);		wptr += 3;		i -= 3;		lasts = wptr;	    } else {		wptr++;		i--;	    }	}	if (wptr > lasts)	    addsuffix(inv ? SUFTYP_NEGSTR : SUFTYP_POSSTR, 0,		      lasts, wptr - lasts, n);	free(ws);    } else	makesuffix(n);}

Thingyrthingy(char *nam){    Thingy t = (Thingy) thingytab->getnode2(thingytab, nam);    if(!t)	thingytab->addnode(thingytab, ztrdup(nam), t = makethingynode());    return refthingy(t);}

voidinsertlastword(void){    int n;    char *s, *t;    int len;    Histent he;/* multiple calls will now search back through the history, pem */    static char *lastinsert;    static int lasthist, lastpos;    int evhist = curhist - 1, save;    if (lastinsert) {	int lastlen = ztrlen(lastinsert);	int pos = cs;	if (lastpos <= pos &&	    lastlen == pos - lastpos &&	    memcmp(lastinsert, (char *)&line[lastpos], lastlen) == 0) {	    evhist = --lasthist;	    cs = lastpos;	    foredel(pos - cs);	}	zsfree(lastinsert);	lastinsert = NULL;    }    if (!(he = quietgethist(evhist)) || !he->nwords) {	feep();	return;    }    if (zmult > 0) {	n = he->nwords - (zmult - 1);    } else {	n = 1 - zmult;    }    if (n < 1 || n > he->nwords) {	feep();	return;    }    s = he->text + he->words[2*n-2];    t = he->text + he->words[2*n-1];    save = *t;    *t = '/0';			/* ignore trailing whitespace */    lasthist = evhist;    lastpos = cs;    lastinsert = ztrdup(s);    spaceinline(len = ztrlen(s));    while (len--) {	line[cs++] = *s == Meta ? *++s ^ 32 : *s;	s++;    }    *t = save;}

voidcreatealiastables(void){    /* Table for regular and global aliases */    aliastab = newhashtable(23, "aliastab", NULL);    createaliastable(aliastab);    /* add the default aliases */    aliastab->addnode(aliastab, ztrdup("run-help"), createaliasnode(ztrdup("man"), 0));    aliastab->addnode(aliastab, ztrdup("which-command"), createaliasnode(ztrdup("whence"), 0));    /* Table for suffix aliases --- make this smaller */    sufaliastab = newhashtable(11, "sufaliastab", NULL);    createaliastable(sufaliastab);}

static voidsetpmmapfile(Param pm, char *value){    int fd = -1, len;    char *name = ztrdup(pm->nam);#ifdef USE_MMAP    caddr_t mmptr;#else    FILE *fout;#endif    /*     * First unmetafy the value, and the name since we don't     * where it's been.     */    unmetafy(name, &len);    unmetafy(value, &len);    /* Open the file for writing */#ifdef USE_MMAP    if (!(pm->flags & PM_READONLY) &&	(fd = open(name, O_RDWR|O_CREAT|O_NOCTTY, 0666)) >= 0 &&	(mmptr = (caddr_t)mmap((caddr_t)0, len, PROT_READ | PROT_WRITE,			       MMAP_ARGS, fd, (off_t)0)) != (caddr_t)-1) {	/*	 * First we need to make sure the file is long enough for	 * when we msync.  On AIX, at least, we just get zeroes otherwise.	 */	ftruncate(fd, len);	memcpy(mmptr, value, len);#ifndef MS_SYNC#define MS_SYNC 0#endif	msync(mmptr, len, MS_SYNC);	/*	 * Then we need to truncate again, since mmap() always maps complete	 * pages.  Honestly, I tried it without, and you need both.	 */	ftruncate(fd, len);	munmap(mmptr, len);    }#else /* don't USE_MMAP */    /* can't be bothered to do anything too clever here */    if ((fout = fopen(name, "w"))) {	while (len--)	    putc(*value++, fout);	fclose(fout);    }#endif /* USE_MMAP */    if (fd >= 0)	close(fd);    free(name);    free(value);}

mod_export voidmakesuffixstr(char *f, char *s, int n){    if (f) {	zsfree(suffixfunc);	suffixfunc = ztrdup(f);	suffixfunclen = n;    } else if (s) {	int inv, i, z = 0;	ZLE_STRING_T ws, lasts, wptr;	if (*s == '^' || *s == '!') {	    inv = 1;	    s++;	} else	    inv = 0;	s = getkeystring(s, &i, GETKEYS_SUFFIX, &z);	s = metafy(s, i, META_USEHEAP);	ws = stringaszleline(s, 0, &i, NULL, NULL);	/* Remove suffix on uninsertable characters if  /- was given *	 * and the character class wasn't negated -- or vice versa.  */	suffixnoinsrem = z ^ inv;	suffixlen = n;	lasts = wptr = ws;	while (i) {	    if (i >= 3 && wptr[1] == ZWC('-')) {		ZLE_CHAR_T str[2];		if (wptr > lasts)		    addsuffix(inv ? SUFTYP_NEGSTR : SUFTYP_POSSTR, 0,			      lasts, wptr - lasts, n);		str[0] = *wptr;		str[1] = wptr[2];		addsuffix(inv ? SUFTYP_NEGRNG : SUFTYP_POSRNG, 0,			  str, 2, n);		wptr += 3;		i -= 3;		lasts = wptr;	    } else {		wptr++;		i--;	    }	}	if (wptr > lasts)	    addsuffix(inv ? SUFTYP_NEGSTR : SUFTYP_POSSTR, 0,		      lasts, wptr - lasts, n);	free(ws);    } else	makesuffix(n);}

intsetup_(UNUSED(Module m)){    hasperm = 0;    comprpms = compkpms = NULL;    compwords = compredirs = NULL;    compprefix = compsuffix = compiprefix = compisuffix = 	compqiprefix = compqisuffix =	compcontext = compparameter = compredirect = compquote =	compquoting = comprestore = complist = compinsert =	compexact = compexactstr = comppatmatch = comppatinsert =	complastprompt = comptoend = compoldlist = compoldins =	compvared = compqstack = NULL;    complastprefix = ztrdup("");    complastsuffix = ztrdup("");    complistmax = 0;    hascompmod = 1;    return 0;}

voidhashdir(char **dirp){    Cmdnam cn;    DIR *dir;    char *fn;#if defined(_WIN32) || defined(__CYGWIN__)    char *exe;#endif /* _WIN32 || _CYGWIN__ */    if (isrelative(*dirp) || !(dir = opendir(unmeta(*dirp))))	return;    while ((fn = zreaddir(dir, 1))) {	if (!cmdnamtab->getnode(cmdnamtab, fn)) {	    cn = (Cmdnam) zshcalloc(sizeof *cn);	    cn->flags = 0;	    cn->u.name = dirp;	    cmdnamtab->addnode(cmdnamtab, ztrdup(fn), cn);	}#if defined(_WIN32) || defined(__CYGWIN__)	/* Hash foo.exe as foo, since when no real foo exists, foo.exe	   will get executed by DOS automatically.  This quiets	   spurious corrections when CORRECT or CORRECT_ALL is set. */	if ((exe = strrchr(fn, '.')) &&	    (exe[1] == 'E' || exe[1] == 'e') &&	    (exe[2] == 'X' || exe[2] == 'x') &&	    (exe[3] == 'E' || exe[3] == 'e') && exe[4] == 0) {	    *exe = 0;	    if (!cmdnamtab->getnode(cmdnamtab, fn)) {		cn = (Cmdnam) zshcalloc(sizeof *cn);		cn->flags = 0;		cn->u.name = dirp;		cmdnamtab->addnode(cmdnamtab, ztrdup(fn), cn);	    }	}#endif /* _WIN32 || __CYGWIN__ */    }    closedir(dir);}

mod_export voidaddsuffixstring(int tp, int flags, char *chars, int lensuf){    int slen, alloclen;    ZLE_STRING_T suffixstr;    /* string needs to be writable... I've been regretting this for years.. */    chars = ztrdup(chars);    suffixstr = stringaszleline(chars, 0, &slen, &alloclen, NULL);    addsuffix(tp, flags, suffixstr, slen, lensuf);    zfree(suffixstr, alloclen);    zsfree(chars);}

static voidunsetpmmapfile(Param pm, UNUSED(int exp)){    /* Unlink the file given by pm->nam */    char *fname = ztrdup(pm->nam);    int dummy;    unmetafy(fname, &dummy);    if (!(pm->flags & PM_READONLY))	unlink(fname);    free(fname);}

voidacceptlineanddownhistory(void){    char *s;    if (!(s = zle_get_event(histline + 1))) {	feep();	return;    }    pushnode(bufstack, ztrdup(s));    done = 1;    stackhist = histline + 1;}

intsetup_(UNUSED(Module m)){    char **bpaste;    /* Set up editor entry points */    zle_entry_ptr = zle_main_entry;    zle_load_state = 1;    /* initialise the thingies */    init_thingies();    lbindk = NULL;    /* miscellaneous initialisations */    stackhist = stackcs = -1;    kungetbuf = (char *) zalloc(kungetsz = 32);    comprecursive = 0;    rdstrs = NULL;    /* initialise the keymap system */    init_keymaps();    varedarg = NULL;    incompfunc = incompctlfunc = hascompmod = 0;    hascompwidgets = 0;    clwords = (char **) zshcalloc((clwsize = 16) * sizeof(char *));    bpaste = zshcalloc(3*sizeof(char *));    bpaste[0] = ztrdup("/033[?2004h");    bpaste[1] = ztrdup("/033[?2004l");    /* Intended to be global, no WARNCREATEGLOBAL check. */    assignaparam("zle_bracketed_paste", bpaste, 0);    return 0;}

voidpushline(void){    int n = zmult;    if (n < 0)	return;    pushnode(bufstack, metafy((char *) line, ll, META_DUP));    while (--n)	pushnode(bufstack, ztrdup(""));    stackcs = cs;    *line = '/0';    ll = cs = 0;    clearlist = 1;}

static zlongget_cursor(UNUSED(Param pm)){    if (zlemetaline != NULL) {	/* A lot of work for one number, but still... */	ZLE_STRING_T tmpline;	int tmpcs, tmpll, tmpsz;	char *tmpmetaline = ztrdup(zlemetaline);	tmpline = stringaszleline(tmpmetaline, zlemetacs,				  &tmpll, &tmpsz, &tmpcs);	free(tmpmetaline);	free(tmpline);	return tmpcs;    }    return zlecs;}

voidset_default_colour_sequences(void){    fg_bg_sequences[COL_SEQ_FG].start = ztrdup(TC_COL_FG_START);    fg_bg_sequences[COL_SEQ_FG].end = ztrdup(TC_COL_FG_END);    fg_bg_sequences[COL_SEQ_FG].def = ztrdup(TC_COL_FG_DEFAULT);    fg_bg_sequences[COL_SEQ_BG].start = ztrdup(TC_COL_BG_START);    fg_bg_sequences[COL_SEQ_BG].end = ztrdup(TC_COL_BG_END);    fg_bg_sequences[COL_SEQ_BG].def = ztrdup(TC_COL_BG_DEFAULT);}

static intbin_strftime(char *nam, char **argv, Options ops, int func){    int result = 1;    char *tz = getsparam("TZ");    startparamscope();    if (tz && *tz) {	Param pm = createparam("TZ", PM_LOCAL|PM_SCALAR|PM_EXPORTED);	if (pm)	    pm->level = locallevel; /* because createparam() doesn't */	setsparam("TZ", ztrdup(tz));    }    result = output_strftime(nam, argv, ops, func);    endparamscope();    return result;}

voidacceptandinfernexthistory(void){    int t0;    char *s;    done = 1;    for (t0 = histline - 2;; t0--) {	if (!(s = qgetevent(t0)))	    return;	if (!metadiffer(s, (char *) line, ll))	    break;    }    if (!(s = qgetevent(t0 + 1)))	return;    pushnode(bufstack, ztrdup(s));    stackhist = t0 + 1;}

static char *get_contents(char *fname){    int fd;#ifdef USE_MMAP    caddr_t mmptr;    struct stat sbuf;#endif    char *val;    unmetafy(fname = ztrdup(fname), &fd);#ifdef USE_MMAP    if ((fd = open(fname, O_RDONLY | O_NOCTTY)) < 0 ||	fstat(fd, &sbuf) ||	(mmptr = (caddr_t)mmap((caddr_t)0, sbuf.st_size, PROT_READ,			       MMAP_ARGS, fd, (off_t)0)) == (caddr_t)-1) {	if (fd >= 0)	    close(fd);	free(fname);	return NULL;    }    /*     * Sadly, we need to copy the thing even if metafying doesn't     * change it.  We just don't know when we might get a chance to     * munmap it, otherwise.     */    val = metafy((char *)mmptr, sbuf.st_size, META_HEAPDUP);    munmap(mmptr, sbuf.st_size);    close(fd);#else /* don't USE_MMAP */    val = NULL;    if ((fd = open(fname, O_RDONLY | O_NOCTTY)) >= 0) {	LinkList ll;	if ((ll = readoutput(fd, 1)))	    val = peekfirst(ll);    }#endif /* USE_MMAP */    free(fname);    return val;}

voidfillnameddirtable(HashTable ht){#ifndef WINNT    if (!allusersadded) {	struct passwd *pw; 	setpwent(); 	/* loop through the password file/database *	 * and add all entries returned.           */	while ((pw = getpwent()) && !errflag)	    adduserdir(ztrdup(pw->pw_name), pw->pw_dir, ND_USERNAME, 1); 	endpwent();	allusersadded = 1;    }#endif /* WINNT */    return;}