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

sp_errorsp_session_create(const sp_session_config *config, sp_session * *sess){  sp_session *session;  if (memcmp(config->application_key, "appkey_good", config->application_key_size))      return SP_ERROR_BAD_APPLICATION_KEY;  session = *sess = ALLOC(sp_session);  session->config.api_version       = config->api_version;  session->config.cache_location    = strclone(config->cache_location);  session->config.settings_location = strclone(config->settings_location);  session->config.user_agent        = strclone(config->user_agent);  session->config.callbacks         = ALLOC(sp_session_callbacks);  session->config.userdata          = config->userdata;  session->config.application_key   = ALLOC_N(byte, config->application_key_size);  memcpy((char *) session->config.application_key, config->application_key, config->application_key_size);  if (config->callbacks)  {    MEMCPY((sp_session_callbacks *) session->config.callbacks, config->callbacks, sp_session_callbacks);  }  // sp_session defaults  session->cache_size = 0;  // TODO: v0.0.8 (and earlier) directly call `notify_main_thread` callback here, before returning  if (config->callbacks && config->callbacks->notify_main_thread)    config->callbacks->notify_main_thread(session);  return SP_ERROR_OK;}

MCEPS::MCEPS(const MCEPS &sref) : MCControl(sref){	size = sref.size;	postscript = strclone(sref.postscript);	prolog = strclone(sref.prolog);	xscale = sref.xscale;	yscale = sref.yscale;	angle = sref.angle;	tx = sref.tx;	ty = sref.ty;	ex = sref.ex;	ey = sref.ey;	curpage = sref.curpage;	pagecount = sref.pagecount;	if (pagecount != 0)	{		pageIndex = new uint4[pagecount];		uint2 i = pagecount;		while (i--)			pageIndex[i] = sref.pageIndex[i];	}	else		pageIndex = NULL;	if (sref.image == NULL)		image = NULL;	else	{		image = new MCImage(*sref.image);		image->setparent(this);	}}

booltransaction_copy(Transaction *dst, const Transaction *src){    if (dst == src) {        // not supposed to be tried        return false;    }    dst->type = src->type;    dst->date = src->date;    if (!strclone(&dst->description, src->description)) {        return false;    }    if (!strclone(&dst->payee, src->payee)) {        return false;    }    if (!strclone(&dst->checkno, src->checkno)) {        return false;    }    if (!strclone(&dst->notes, src->notes)) {        return false;    }    dst->position = src->position;    dst->mtime = src->mtime;    dst->splitcount = src->splitcount;    dst->splits = malloc(sizeof(Split) * dst->splitcount);    memset(dst->splits, 0, sizeof(Split) * dst->splitcount);    for (unsigned int i=0; i<dst->splitcount; i++) {        if (!split_copy(&dst->splits[i], &src->splits[i])) {            return false;        }    }    _txn_reindex(dst);    return true;}

/* * cpy_hsctag * * copy an already existing hsctag * * NOTE: this is not a 100% clone: *  - tag-callbacks are disabled and have to be assigned again. *  - the occured-flag is disabled */HSCTAG *cpy_hsctag(HSCTAG * oldtag){    HSCTAG *newtag = new_hsctag(oldtag->name);    if (newtag)    {        DLNODE *nd = NULL;        /* init new tag item */        newtag->option = oldtag->option;        newtag->o_handle = NULL;        /* no handle functions */        newtag->c_handle = NULL;        newtag->occured = FALSE;        newtag->op_text = NULL;        newtag->cl_text = NULL;        newtag->attr = init_dllist(del_hscattr);        newtag->mbi = strclone(oldtag->mbi);        newtag->naw = strclone(oldtag->naw);        newtag->uri_size = NULL;        newtag->uri_stripext = NULL;        /* copy macro text */        if (oldtag->op_text)        {            newtag->op_text = init_estr(0);            estrcpy(newtag->op_text, oldtag->op_text);        }        if (oldtag->cl_text)        {            newtag->cl_text = init_estr(0);            estrcpy(newtag->cl_text, oldtag->cl_text);        }        /* copy attribute list */        nd = oldtag->attr->first;        while (nd)        {            HSCATTR *attr = (HSCATTR *) nd->data;       /* old attribute */            /* create copy of old attribute */            HSCATTR *nattr = cpy_hscattr(attr);            /* append this copy to new attr-list */            app_dlnode(newtag->attr, nattr);            /* check for special uri-attributes */            if (!upstrcmp(nattr->name, oldtag->uri_size->name))                newtag->uri_size = nattr;            if (!upstrcmp(nattr->name, oldtag->uri_stripext->name))                newtag->uri_size = nattr;        }    }    return (newtag);}

void MCOldFonttablenode::addfont(){	Boolean bold = False;	Boolean italic = False;	char *sptr;	if ((sptr = MCU_strtok(NULL, "-")) == NULL)		return;	if (strequal(sptr, "bold") || strequal(sptr, "demibold")	        || strequal(sptr, "demi"))	{		bold = True;		if (bstring[0] == '/0')		{			delete bstring;			bstring = strclone(sptr);		}	}	if ((sptr = MCU_strtok(NULL, "-")) == NULL)		return;	if (strequal(sptr, "i") || strequal(sptr, "o"))		italic = True;	if (MCU_strtok(NULL, "-") == NULL || (sptr = MCU_strtok(NULL, "-")) == NULL	        || (sptr = MCU_strtok(NULL, "-")) == NULL)		return;	uint2 size = strtol(sptr, NULL, 10);	if (bold)		if (italic)			registersize(size, bisizes, nbolditalic);		else			registersize(size, bsizes, nbold);	else		if (italic)			registersize(size, isizes, nitalic);		else			registersize(size, psizes, nplain);	if (MCU_strtok(NULL, "-") == NULL	        || MCU_strtok(NULL, "-") == NULL	        || MCU_strtok(NULL, "-") == NULL	        || MCU_strtok(NULL, "-") == NULL	        || (sptr = MCU_strtok(NULL, "-")) == NULL)		return;	sptr += strlen(sptr) + 1;	if (charset == NULL)		charset = strclone(sptr);	else		if (strequal(sptr, "iso8859-1") && !strequal(charset, "iso8859-1"))		{			delete charset;			charset = strclone(sptr);		}}

disruptor* disruptorCreate( const char* address, const char* username, int64_t sendBufferSize ){    disruptor* d = zcalloc( sizeof(disruptor) );    d->address = strclone( address );    d->username = strclone( username );    d->sendBufferSize = sendBufferSize;    if ( !startup( d ) )    {        disruptorRelease( d );        return NULL;    }    return d;}

/*** new_hscmac**** alloc & init a new hsc-macro*/HSCMAC *new_hscmac( STRPTR newname, STRPTR newtext ){    HSCMAC *newmac = (HSCMAC*) malloc( sizeof(HSCMAC) );    if (newmac) {        /* init new macity item */        newmac->name = strclone(newname);        newmac->text = strclone(newtext);    }    return (newmac);}

/*** new_hscvar**** alloc & init a new variable*/HSCVAR *new_hscvar( STRPTR newname ){    HSCVAR *newvar = (HSCVAR*) umalloc( sizeof(HSCVAR) );    if (newvar) {        /* init new varument item */        newvar->vartype   = VT_NONE;        newvar->name      = strclone( newname );        newvar->deftext   = NULL;        newvar->text      = NULL;        newvar->enumstr   = NULL;        newvar->macro_id  = 0;        newvar->varflag   = 0;        newvar->quote     = EOF;    }    if ( !( newvar->name ) ) {        del_var( (APTR) newvar );        newvar = NULL;    }    return (newvar);}

BOOL hsc_set_filename_document(HSCPRC * hp, STRPTR filename) {    BOOL ok = FALSE;    D(fprintf(stderr, DHL "document=`%s'/n", filename));    hp->filename_document = strclone(filename);    return (ok);}

sp_errorsp_playlistcontainer_add_folder(sp_playlistcontainer *pc, int index, const char *name){  sp_playlistcontainer_playlist_t start_folder;  sp_playlistcontainer_playlist_t end_folder;  sp_error error;  long folder_id = random();  start_folder.folder_id   = folder_id;  start_folder.folder_name = strclone(name);  start_folder.type        = SP_PLAYLIST_TYPE_START_FOLDER;  end_folder.folder_id   = folder_id;  end_folder.folder_name = NULL;  end_folder.type        = SP_PLAYLIST_TYPE_END_FOLDER;  error = sp_mock_playlistcontainer_insert(pc, index, start_folder);  if (error == SP_ERROR_OK)  {    error = sp_mock_playlistcontainer_insert(pc, index + 1, end_folder);  }  return error;}

Boolean MCDispatch::openenv(const char *sname, const char *env,                            char **outpath, IO_handle &stream, uint4 offset){	if ((env = MCS_getenv(env)) != NULL)	{		char *pathstring = strclone(env);		char *fullpath = new char[strlen(env) + strlen(sname) + 2];		char *eptr = pathstring;		while (eptr != NULL)		{			char *path = eptr;			eptr = strchr(eptr, ENV_SEPARATOR);			if (eptr != NULL)				*eptr++ = '/0';#ifdef _WIN32			sprintf(fullpath, "%s//%s", path, sname);#else			sprintf(fullpath, "%s/%s", path, sname);#endif			if ((stream = MCS_open(fullpath, IO_READ_MODE, True, False,			                       offset)) != NULL)			{				delete pathstring;				*outpath = fullpath;				return True;			}		}		delete pathstring;		delete fullpath;	}	return False;}

void MCCdata::CloneData(const MCCdata& cref, MCField* p_new_owner){	id = cref.id;	if (cref.data != NULL && cref.data != (void *)1)	{		if (id & COMPACT_PARAGRAPHS)			data = strclone((char *)cref.data);		else		{			MCParagraph *paragraphs = NULL;			MCParagraph *tptr = (MCParagraph *)cref.data;			do			{				// Clone the paragraph				MCParagraph *newparagraph = new (nothrow) MCParagraph(*tptr);				newparagraph->setparent(p_new_owner);								newparagraph->appendto(paragraphs);				tptr = (MCParagraph *)tptr->next();			}			while (tptr != cref.data);			data = paragraphs;		}	}	else		data = cref.data;}

/*** read_enum_str**** sidefx: modifies tmpstr*/BOOL read_enum_str( HSCVAR *var, INFILE *inpf ){    BOOL ok;    int  ch;    ok = parse_wd( inpf, "(" );        /* check for "(" */    ok &= clr_estr( tmpstr );          /* reset string */    ch = infgetc( inpf );    while ( ok && (ch!=')') && (ch!=EOF) && (ch!=CH_LF) ) {        if ( (ch!=')') && (ch!=' ') )            ok &= app_estrch( tmpstr, ch );        ch = infgetc( inpf );    };     /* check result */    if ( ok )    if ( ch == EOF )        err_eof( inpf, "reading enumerator" );    else if ( ch ==CH_LF )        err_eol( inpf );    /* store enumstr in var-struct */    if ( ok ) {        DDA( fprintf( stderr, "**   enum: %s/n", estr2str( tmpstr ) ) );        var->enumstr = strclone( estr2str( tmpstr ) );    }    return( (BOOL)(!fatal_error) );}

/* called once for each time a variable is seen */void record_var_usage(char* name) {  var_usage *cur_var = vars;  var_usage *prev;  while(cur_var != NULL && strcmp(cur_var->name, name) != 0) {    prev = cur_var;    cur_var = cur_var->next;  }  if(cur_var == NULL) {    /* var is not in our list yet */    var_usage *var = (var_usage *)malloc(sizeof(var_usage));    var->name = strclone(name);    var->usage_count = 1;    if(vars == NULL) {      vars = var;    } else {      prev->next = var;    }  }  else {    cur_var->usage_count += 1;  }}

void MCOldFontnode::buildtable(){	if (table != NULL || MCnoui)		return;	int nnames;	char **allnames = XListFonts(MCdpy, "-*-iso8859-1", MAXUINT2, &nnames);	int i;	for (i = 0 ; i < nnames ; i++)	{		char *sptr = allnames[i];		sptr++;		if (MCU_strtok(sptr, "-") == NULL)			continue;		if ((sptr = MCU_strtok(NULL, "-")) == NULL)			continue;		MCOldFonttablenode *fnptr = findtablenode(sptr);		if (fnptr == NULL)		{			fnptr = new MCOldFonttablenode;			fnptr->name = strclone(sptr);			fnptr->next = table;			table = fnptr;		}		fnptr->addfont();	}	XFreeFontNames(allnames);}

/* * arg_status * * argument handler for values that are passed * to "STATUS=..". */static STRPTR arg_status_CB(STRPTR arg){    STRPTR errmsg = NULL;    STRPTR argstr = strclone(arg);    STRPTR argold = argstr;     /* used to call ufree() */#if DEBUG    HSCPRC *hp = arg_hp;#endif    D(fprintf(stderr, DHSC "args: status=%s/n", arg));    arg = strtok(argstr, "|");    while (arg)    {        if (!upstrcmp(arg, STATUS_QUIET_STR))            disp_status = STATUS_QUIET;        else if (!upstrcmp(arg, STATUS_LINE_STR))            disp_status |= STATUS_LINE;        else if (!upstrcmp(arg, STATUS_VERSION_STR))            disp_status |= STATUS_VERSION;        else if (!upstrcmp(arg, STATUS_VERBOSE_STR))            disp_status |= STATUS_VERBOSE;        else if (!upstrcmp(arg, STATUS_FULL_STR))            disp_status = -1;        else            errmsg = "illegal argument";        arg = strtok(NULL, "|");    }    ufreestr(argold);    return (errmsg);}

/***-------------------------------------** <$LET> set a new global attribute**        or overwrite a defined one**-------------------------------------*/BOOL handle_hsc_let( INFILE *inpf, HSCTAG *tag ){    STRPTR varname = infgetw( inpf );    BOOL   ok = FALSE;    /* create copy of varname */    if ( varname )        varname = strclone( varname );    else        err_eof( inpf, "missing attribute name" );    if ( varname ) {        ok = parse_wd( inpf, ":" );        if ( ok && define_var( varname, vars, inpf, 0 ) )            ok = TRUE;        if ( ok )            ok = parse_gt( inpf );    } else        err_mem( inpf );    /* release mem */    ufreestr( varname );    /* if error occured, skip rest of tag */    if ( !ok )        skip_until_eot( inpf );    return ( ok );}

/* * new_hsctag * * alloc & init a new hsctag */HSCTAG *new_hsctag(STRPTR newid){    HSCTAG *newtag = (HSCTAG*) umalloc(sizeof(HSCTAG));    if (newtag)    {        /* init new tag item */        newtag->name = upstr(strclone(newid));  /* set id */        newtag->option = 0;        newtag->o_handle = NULL;        /* no handle functions */        newtag->c_handle = NULL;        newtag->occured = FALSE;        newtag->op_text = NULL;        newtag->cl_text = NULL;        newtag->attr = init_dllist(del_hscattr);        newtag->mbi = NULL;        newtag->naw = NULL;        newtag->uri_size = NULL;        newtag->uri_stripext = NULL;        newtag->start_fpos = NULL;        newtag->end_fpos = NULL;        if (!(newtag->name && newtag->attr))        {            del_hsctag(newtag);            newtag = NULL;        }    }    return (newtag);}

void setfieldreg(struct struct_table* structs, struct symbol_t* symbols, char* name, char* reg){	struct struct_table* str = get_struct_by_name(structs, name);	struct symbol_t* s;	char* indirect_address;	#ifdef DEBUG_ME		printf("setfieldreg %s for %s/n",reg, name);	#endif	if(str == (struct struct_table*) NULL){		printf("Could not find struct with name %s/n", name);		exit(4);	}	while(symbols != EMPTY_TABLE){		s = table_lookup(str->fields, symbols->name);		if(s != EMPTY_TABLE) {			#ifdef DEBUG_ME				printf("(setgieldreg) found symbol to update: %s, %s/n", symbols->name, reg);			#endif			asprintf(&indirect_address, "%d(%s)", symbols->offset*FIELD_OFFSET, reg);			setRegister(symbols->name, strclone(indirect_address));			s->reg = reg;		}		symbols = symbols->next;	}}

/* new_id_local: create new reference to local id  */static IDREF *new_idref(STRPTR id, INFILEPOS * fpos){    IDREF *newid = (IDREF *) umalloc(sizeof(IDREF));    newid->name = strclone(id);    newid->fpos = fpos;    return (newid);}

sp_search *mocksp_search_create(sp_error error, const char *query, const char *did_you_mean,                     int total_tracks, int num_tracks, const sp_track **tracks,                     int total_albums, int num_albums, const sp_album **albums,                     int total_artists, int num_artists, const sp_artist **artists,                     int total_playlists, int num_playlists,                     sp_search_playlist_t *playlists,                     search_complete_cb *callback, void *userdata){  sp_search *search = ALLOC(sp_search);  search->error = error;  search->query = strclone(query);  if (did_you_mean)  {    search->did_you_mean = strclone(did_you_mean);  }  search->total_tracks  = total_tracks;  search->total_artists = total_artists;  search->total_albums  = total_albums;  search->total_playlists = total_playlists;  search->num_tracks  = num_tracks;  search->num_artists = num_artists;  search->num_albums  = num_albums;  search->num_playlists = num_playlists;  search->tracks  = ALLOC_N(sp_track *, num_tracks);  search->artists = ALLOC_N(sp_artist *, num_artists);  search->albums  = ALLOC_N(sp_album *, num_artists);  search->playlists = ALLOC_N(sp_search_playlist_t, num_playlists);  MEMCPY_N(search->tracks, tracks, sp_track *, num_tracks);  MEMCPY_N(search->artists, artists, sp_artist *, num_artists);  MEMCPY_N(search->albums, albums, sp_album *, num_albums);  MEMCPY_N(search->playlists, playlists, sp_search_playlist_t, num_playlists);  search->callback = callback;  search->userdata = userdata;  return search;}

char* strtok(char* str, const char* delimiters) {    if(str != 0) { //TODO better but if you call strtok and after that strtoknc will still be a memory leak. -> Don't use strtoknc        if(fr != 0) {            free(fr);        }        fr = strclone(str);        return strtoknc(fr, delimiters);    }    return strtoknc(0, delimiters);}

struct stringbuilder* stringbuilder_append(struct stringbuilder* strbuilder,		char* string) {	if (!string)		return 0;	strbuilder->size += strlen(string);	list_append(strbuilder->strings, strclone(string));	return strbuilder;}

MCScrollbar::MCScrollbar(const MCScrollbar &sref) : MCControl(sref){	thumbpos = sref.thumbpos;	thumbsize = sref.thumbsize;	pageinc = sref.pageinc;	lineinc = sref.lineinc;	startstring = strclone(sref.startstring);	endstring = strclone(sref.endstring);	startvalue = sref.startvalue;	endvalue = sref.endvalue;	nffw = sref.nffw;	nftrailing = sref.nftrailing;	nfforce = sref.nfforce;	hover_part = WTHEME_PART_UNDEFINED;	linked_control = NULL;	m_embedded = false;}

sp_playlist *sp_mock_playlist_create(const char *name, bool is_loaded, sp_user *owner, bool is_collaborative,                       const char *description, const byte *image, bool has_pending_changes,                       unsigned int num_subscribers, sp_subscribers *subscribers, bool is_in_ram,                       sp_playlist_offline_status offline_status, int offline_download_completed,                       int num_tracks, sp_playlist_track_t *tracks){  int i;  sp_playlist *playlist = ALLOC(sp_playlist);  playlist->name = strclone(name);  playlist->is_loaded = is_loaded;  playlist->owner = owner;  playlist->is_collaborative = is_collaborative;  playlist->get_description = strclone(description);  if (image)  {    playlist->image = ALLOC_N(byte, 20);    MEMCPY_N(playlist->image, image, byte, 20);  }  playlist->has_pending_changes = has_pending_changes;  playlist->num_subscribers = num_subscribers;  playlist->subscribers     = subscribers;  playlist->is_in_ram = is_in_ram;  playlist->get_offline_status = offline_status;  playlist->get_offline_download_completed = offline_download_completed;  playlist->num_tracks = num_tracks;  playlist->tracks     = ALLOC_N(sp_playlist_track_t, num_tracks);  MEMCPY_N(playlist->tracks, tracks, sp_playlist_track_t, num_tracks);  /* private mock accessors */  playlist->autolink_tracks = false;  return playlist;}

void add_env_include_dirs(HSCPRC *hp){    STRPTR incp = getenv(ENV_HSCINCLUDE);    if(NULL != incp) {        STRPTR s = strclone(incp);        STRPTR t = strtok(s,PATHL_SEPARATOR);        hsc_add_include_directory(hp,t);        while(NULL != (t = strtok(NULL,PATHL_SEPARATOR))) {            hsc_add_include_directory(hp,t);        }        freestr(s);    }}

/*** set_vartext**** set value of a var**** params: var......var to set**         newtext..new text to set** result: value of new text set** errors: return NULL if out of mem, display error message*/STRPTR set_vartext( HSCVAR *var, STRPTR newtext ){    if ( newtext != var->text ) {        ufreestr( var->text );        var->text = NULL;        if ( newtext )            var->text = strclone( newtext );    }    return (var->text);}

/*** set_vartext**** set value of a var**** params: var......var to set**         newtext..new text to set** result: value of new text set** errors: return NULL if out of mem, display error message*/STRPTR set_vartext( HSCVAR *var, STRPTR newtext ){    ufreestr( var->text );    if ( newtext ) {        var->text = strclone( newtext );        if ( !var->text )            err_mem( NULL );    }    return (var->text);}

sp_errorsp_playlist_rename(sp_playlist *playlist, const char *new_name){  size_t length = strlen(new_name);  if (length == 0 || length > 255)  {    return SP_ERROR_INVALID_INDATA;  }  playlist->name = strclone(new_name);  return SP_ERROR_OK;}

/*** check_enumstr: check if a given value is a legal enum value*/BOOL check_enumstr( HSCVAR *var, STRPTR value, INFILE *inpf ){    STRPTR enumcp = strclone( var->enumstr ); /* clone of enumstr */    BOOL   found  = FALSE; /* flag: TRUE, if value found within enumstr */    BOOL   any    = FALSE; /* flag: TRUE, if "*" was within enumstr */    if ( enumcp ) {        STRPTR word = strtok( enumcp, "|" );        /* search for value in enumcp */        while ( word && !found ) {            if ( !strcmp( word, "*" ) )                any = TRUE;            if ( !upstrcmp( word, value ) )                found = TRUE;            word = strtok( NULL, "|" );        }        ufreestr( enumcp );        /* check result, display messages if neccessary */        if ( !found ) {            if ( !any ) {                /* unknown enum value */                message( MSG_ENUM_UNKN, inpf );                errstr( "unknown" );            } else {                /* suspicious enum value */                message( MSG_ENUM_SUSPICIOUS, inpf );                errstr( "suspicious" );            }            errstr( " value " );            errqstr( value );            errstr( " for" );            errsym( var->name );            errlf();        } else DDA( fprintf( stderr, "**   enum /"%s/" ok for %s/n",                             value, var->name ) );    } else        err_mem( inpf );    return( found );}