C++ copystring函数代码示例

void FMetaTable::CopyMeta (const FMetaTable *other)
{
	const FMetaData *meta_src;
	FMetaData **meta_dest;

	FreeMeta ();

	meta_src = other->Meta;
	meta_dest = &Meta;
	while (meta_src != NULL)
	{
		FMetaData *newmeta = new FMetaData (meta_src->Type, meta_src->ID);
		switch (meta_src->Type)
		{
		case META_String:
			newmeta->Value.String = copystring (meta_src->Value.String);
			break;
		default:
			newmeta->Value = meta_src->Value;
			break;
		}
		*meta_dest = newmeta;
		meta_dest = &newmeta->Next;
		meta_src = meta_src->Next;
	}
	*meta_dest = NULL;
}

static boolean odberrorroutine (bigstring bs, ptrvoid refcon) {
#pragma unused (refcon)

	copystring (bs, bserror);
	
	return (false); /*consume the error*/
	} /*odberrorroutine*/

char *ReadString (uint8_t **stream)
{
	char *string = *((char **)stream);

	*stream += strlen (string) + 1;
	return copystring (string);
}

static boolean compareforcopyvisit (hdlheadrecord hnode, ptrvoid refcon) {
	
	bigstring bs, bsnode;
	ptrdraginfo draginfo = (ptrdraginfo) refcon;
	
	if (hnode == (*draginfo).hcompare)
		return (true);
	
	opgetheadstring (hnode, bsnode);
	
	opgetheadstring ((*draginfo).hcompare, bs);
	
	if (!equalidentifiers (bsnode, bs)) 
		return (true);
	
	copystring (BIGSTRING ("\x06" "CanÕt "), bs);
	
	pushstring (pcommand, bs);
	
	pushstring (BIGSTRING ("\x35" " because there are two or more selected items named Ò"), bs);
	
	pushstring (bsnode, bs);
	
	pushstring (BIGSTRING ("\x02" "Ó."), bs);
	
	alertdialog (bs);
	
	return (false); /*stop both traversals*/
	} /*compareforcopyvisit*/

void backup(char *name, char *backupname)
{
    string backupfile;
    copystring(backupfile, findfile(backupname, "wb"));
    remove(backupfile);
    rename(findfile(name, "wb"), backupfile);
}

char * expandEnv( char* in ) {
    char * out = in;
    int i;
    int possibleEnv = 0;
    int envStart;
    for (i = 0; i < strlen(out); i++) {
        if( out[i] == '$' ) {
            envStart = i;
        }
        if( out[i] == '{' && i == envStart+1 ) {
            possibleEnv = 1;
        }
        if( out[i] == '}' && possibleEnv ) {
            char temp[5000];
            char * envVar;

            memcpy( temp, &out[envStart], i-envStart+1 );
            temp[i-envStart+1] = '\0';
            copystring( envVar, temp );
            envVar = envVar + 2;
            envVar[i-envStart-2] = '\0';
            
            out = replace( out, temp, getenv(envVar) );
        }
    
    }
    return out;
}

static boolean minimessage (bigstring bs, boolean flbackgroundmsg) {
#pragma unused (flbackgroundmsg)

	copystring (bs, (**minidata).bsmsg);
	
	return (minidrawmsg ());
	} /*minimessage*/

 void Client::loadScene(const char* name) {
     if(load_world(name)) {
         copystring(clientmap, name);
     }
     CubeJ::MsgDataType<CubeJ::MSG_SND_SCENEINFO> data(clientmap, getworldsize(), getmapversion());
     SendMessage(data);
 }

boolean resolveHashTable(bigstring bsnodetype, bigstring bsadrnodepath) {
	bigstring bsname;
	hdlhashtable ht;
	hdlhashnode hn;
	tyvaluerecord iconvalue;
	boolean flexpanded = false;
	boolean fllookup = false;
	
	pushhashtable (roottable);
	
	disablelangerror ();
	
	flexpanded = langexpandtodotparams (bsadrnodepath, &ht, bsname);
	enablelangerror ();
	pophashtable ();
	
	fllookup = hashtablelookup (ht, bsnodetype, &iconvalue, &hn);

	if (fllookup && iconvalue.valuetype == addressvaluetype) {
		copystring(*iconvalue.data.stringvalue, bsadrnodepath);
		return resolveHashTable(bsnodetype, bsadrnodepath);
	}

	return fllookup;
}

static xml_data_node *add_child(xml_data_node *parent, const char *name, const char *value)
{
	xml_data_node **pnode;
	xml_data_node *node;

	/* new element: create a new node */
	node = (xml_data_node *)malloc(sizeof(*node));
	if (node == nullptr)
		return nullptr;

	/* initialize the members */
	node->next = nullptr;
	node->parent = parent;
	node->child = nullptr;
	node->name = copystring_lower(name);
	if (node->name == nullptr)
	{
		free(node);
		return nullptr;
	}
	node->value = copystring(value);
	if (node->value == nullptr && value != nullptr)
	{
		free((void *)node->name);
		free(node);
		return nullptr;
	}
	node->attribute = nullptr;

	/* add us to the end of the list of siblings */
	for (pnode = &parent->child; *pnode; pnode = &(*pnode)->next) { }
	*pnode = node;

	return node;
}

void FBaseCVar::SetGenericRep (UCVarValue value, ECVarType type)
{
	if ((Flags & CVAR_NOSET) && m_DoNoSet)
	{
		return;
	}
	else if ((Flags & CVAR_LATCH) && gamestate != GS_FULLCONSOLE && gamestate != GS_STARTUP)
	{
		FLatchedValue latch;

		latch.Variable = this;
		latch.Type = type;
		if (type != CVAR_String)
			latch.Value = value;
		else
			latch.Value.String = copystring(value.String);
		LatchedValues.Push (latch);
	}
	else if ((Flags & CVAR_SERVERINFO) && gamestate != GS_STARTUP && !demoplayback)
	{
		if (netgame && !players[consoleplayer].settings_controller)
		{
			Printf ("Only setting controllers can change %s\n", Name);
			return;
		}
		D_SendServerInfoChange (this, value, type);
	}
	else
	{
		ForceSet (value, type);
	}
}

int FStringTable::LoadLanguage (DWORD code, bool exactMatch, BYTE *start, BYTE *end)
{
	const DWORD orMask = exactMatch ? 0 : MAKE_ID(0,0,0xff,0);
	int count = 0;

	code |= orMask;

	while (start < end)
	{
		const DWORD langLen = LELONG(*(DWORD *)&start[4]);

		if (((*(DWORD *)start) | orMask) == code)
		{
			start[3] = 1;

			const BYTE *probe = start + 8;

			while (probe < start + langLen)
			{
				int index = probe[0] | (probe[1]<<8);

				if (Strings[index] == NULL)
				{
					Strings[index] = copystring ((const char *)(probe + 2));
					++count;
				}
				probe += 3 + strlen ((const char *)(probe + 2));
			}
		}

		start += langLen + 8;
		start += (4 - (ptrdiff_t)start) & 3;
	}
	return count;
}

char *path(const char *s, bool copy)
{
    static string tmp;
    copystring(tmp, s);
    path(tmp);
    return tmp;
}

    static int next(lua_State * L)
    {
        directory_iterator * self = reinterpret_cast<directory_iterator *>(luaL_checkudata(L, 1, MT));
        if(!self->m_dir) return 0;
        struct dirent * entry = readdir(self->m_dir);
        if(!entry) return 0;
        
        char file[1024];
        copystring(file, self->m_dir_path, sizeof(file));
        concatstring(file, "/", sizeof(file));
        concatstring(file, entry->d_name, sizeof(file));
	    
        struct stat info;
        if (stat(file, &info)) return 0;
        
        unsigned char file_type = DT_UNKNOWN;
        if (S_ISREG(info.st_mode))       file_type = DT_REG;
        else if (S_ISDIR(info.st_mode))  file_type = DT_DIR;
        else if (S_ISFIFO(info.st_mode)) file_type = DT_FIFO;
        else if (S_ISLNK(info.st_mode))  file_type = DT_LNK;
        else if (S_ISBLK(info.st_mode))  file_type = DT_BLK;
        else if (S_ISCHR(info.st_mode))  file_type = DT_CHR;
        else if (S_ISSOCK(info.st_mode)) file_type = DT_SOCK;
	
        lua_pushinteger(L, file_type);
        lua_pushstring(L, entry->d_name);
        
        return 2;
    }

 void setdefaultvalue()
 {
     const char *p = defaultvalueexp;
     char *r = executeret(p);
     copystring(input.buf, r ? r : "");
     if(r) delete[] r;
 }