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

static int priv_encdec_stub(const char *name,                            int (*func)(int flen, const unsigned char *from, unsigned char *to, RSA *rsa, int padding),                            struct expbuf_t *buf){    unsigned char *from, to[4096];    size_t flen;    size_t key_index, padding;    RSA *rsa;    int ret;    if ((from = expbuf_shift_bytes(buf, &flen)) == NULL || expbuf_shift_num(buf, &key_index) != 0 ||        expbuf_shift_num(buf, &padding) != 0) {        errno = 0;        warnf("%s: failed to parse request", name);        return -1;    }    if ((rsa = daemon_get_rsa(key_index)) == NULL) {        errno = 0;        warnf("%s: invalid key index:%zu/n", name, key_index);        return -1;    }    ret = func((int)flen, from, to, rsa, (int)padding);    expbuf_dispose(buf);    expbuf_push_num(buf, ret);    expbuf_push_bytes(buf, to, ret > 0 ? ret : 0);    return 0;}

static int parse_opt(mem_region_t *mr, const char *opt){	assert(mr);	assert(opt);	if (!strncmp(opt, "bf:", 3)) {		/* buffer size */		char *p;		mr->bufsize = strtoul(opt + 3, &p, 0);		if (*p == 'K')			mr->bufsize *= 1024;		else if (*p == 'M')			mr->bufsize *= 1024 * 1024;		else if (*p)			return -1;	} else if (!strncmp(opt, "bl:", 3)) {		/* flash block map */		if (flash_parse_map(mr, opt + 3) < 0) {			warnf("unable to parse flash block map `%s'/n", opt);			return -1;		}	} else{		warnf("unrecognized memory map option `%s'/n", opt);		return -1;	}	return 0;}

UBOOL FFileManagerWindows::InternalMove( const TCHAR* Dest, const TCHAR* Src, UBOOL Replace, UBOOL EvenIfReadOnly, UBOOL Attributes ){	MakeDirectory(*FFilename(Dest).GetPath(), TRUE);	INT Result = MoveFileExW(Src,Dest, MOVEFILE_REPLACE_EXISTING | MOVEFILE_WRITE_THROUGH);	if( !Result )	{		// If the move failed, throw a warning but retry before we throw an error		DWORD error = GetLastError();		warnf( NAME_Warning, TEXT("MoveFileExW was unable to move '%s' to '%s', retrying... (GetLastE-r-r-o-r: %d)"), Src, Dest, error );		// Wait just a little bit (i.e. a totally arbitrary amount)...		Sleep(500);		// Try again		Result = MoveFileExW(Src, Dest, MOVEFILE_REPLACE_EXISTING | MOVEFILE_WRITE_THROUGH);		if( !Result )		{			error = GetLastError();			warnf( NAME_Error, TEXT("Error moving file '%s' to '%s' (GetLastError: %d)"), Src, Dest, error );		}		else		{			warnf( NAME_Warning, TEXT("MoveFileExW recovered during retry!") );		}	}	return (Result != 0);}

/** * Constructor, initializing all member variables. It also reads .ini settings and caches them and creates the * database connection object and attempts to connect if bUseTaskPerfMemDatabase is set. */FTaskPerfMemDatabase::FTaskPerfMemDatabase(): FTaskDatabase(){#if !UDK	// Read the ini settings and store them in the struct to aid debugging.	GConfig->GetBool(TEXT("TaskPerfMemDatabase"), TEXT("bUseTaskPerfMemDatabase"	), bUseTaskPerfMemDatabase, GEngineIni);	// Only do work if task tracking is enabled.	if( bUseTaskPerfMemDatabase == TRUE )	{		// only attempt to get the data when we want to use the TaskPerfMemDatabase		verify(GConfig->GetString( TEXT("TaskPerfMemDatabase"), TEXT("ConnectionString"), ConnectionString, GEngineIni ));		verify(GConfig->GetString( TEXT("TaskPerfMemDatabase"), TEXT("RemoteConnectionIP"), RemoteConnectionIP, GEngineIni ));		verify(GConfig->GetString( TEXT("TaskPerfMemDatabase"), TEXT("RemoteConnectionStringOverride"), RemoteConnectionStringOverride, GEngineIni ));		// Create the connection object; needs to be deleted via "delete".		Connection			= FDataBaseConnection::CreateObject();		// Try to open connection to DB - this is a synchronous operation.		if( Connection->Open( *ConnectionString, *RemoteConnectionIP, *RemoteConnectionStringOverride ) == TRUE )		{			warnf(NAME_DevDataBase,TEXT("Connection to /"%s/" or /"%s/" succeeded"), *ConnectionString, *RemoteConnectionIP);		}		// Connection failed :(		else		{			warnf(NAME_DevDataBase,TEXT("Connection to /"%s/" or /"%s/" failed"), *ConnectionString, *RemoteConnectionIP);			// Only delete object - no need to close as connection failed.			delete Connection;			Connection = NULL;		}	}#endif	//#if !UDK}

static int sign_stub(struct expbuf_t *buf){    unsigned char *m, sigret[4096];    size_t type, m_len, key_index;    RSA *rsa;    unsigned siglen = 0;    int ret;    if (expbuf_shift_num(buf, &type) != 0 || (m = expbuf_shift_bytes(buf, &m_len)) == NULL ||        expbuf_shift_num(buf, &key_index) != 0) {        errno = 0;        warnf("%s: failed to parse request", __FUNCTION__);        return -1;    }    if ((rsa = daemon_get_rsa(key_index)) == NULL) {        errno = 0;        warnf("%s: invalid key index:%zu", __FUNCTION__, key_index);        return -1;    }    ret = RSA_sign((int)type, m, (unsigned)m_len, sigret, &siglen, rsa);    expbuf_dispose(buf);    expbuf_push_num(buf, ret);    expbuf_push_bytes(buf, sigret, ret == 1 ? siglen : 0);    return 0;}

/* create a local file for writing, return TRUE on success */bool tool_create_output_file(struct OutStruct *outs){  struct GlobalConfig *global = outs->config->global;  FILE *file;  if(!outs->filename || !*outs->filename) {    warnf(global, "Remote filename has no length!/n");    return FALSE;  }  if(outs->is_cd_filename) {    /* don't overwrite existing files */    file = fopen(outs->filename, "rb");    if(file) {      fclose(file);      warnf(global, "Refusing to overwrite %s: %s/n", outs->filename,            strerror(EEXIST));      return FALSE;    }  }  /* open file for writing */  file = fopen(outs->filename, "wb");  if(!file) {    warnf(global, "Failed to create the file %s: %s/n", outs->filename,          strerror(errno));    return FALSE;  }  outs->s_isreg = TRUE;  outs->fopened = TRUE;  outs->stream = file;  outs->bytes = 0;  outs->init = 0;  return TRUE;}

int qatom_main(int argc, char **argv){	enum qatom_atom { _EXPLODE=0, _COMPARE, _PRINT } action = _EXPLODE;	const char *format = QATOM_FORMAT;	depend_atom *atom;	depend_atom *atomc;	int i;	while ((i = GETOPT_LONG(QATOM, qatom, "")) != -1) {		switch (i) {		case 'F': format = optarg; break;		case 'c': action = _COMPARE; break;		case 'p': action = _PRINT; break;		COMMON_GETOPTS_CASES(qatom)		}	}	if (argc == optind)		qatom_usage(EXIT_FAILURE);	if (action == _COMPARE && (argc - optind) % 2)		err("compare needs even number of arguments");	for (i = optind; i < argc; ++i) {		atom = atom_explode(argv[i]);		if (atom == NULL) {			warnf("invalid atom: %s/n", argv[i]);			continue;		}		switch (action) {		case _COMPARE:			i++;			atomc = atom_explode(argv[i]);			if (atomc == NULL) {				warnf("invalid atom: %s/n", argv[i]);				break;			}			printf("%s %s ",					atom_to_string(atom),					booga[atom_compare(atom, atomc)]);			printf("%s/n",					atom_to_string(atomc));			atom_implode(atomc);			break;		case _EXPLODE:			qatom_printf(format, atom, verbose);			putchar('/n');			break;		case _PRINT:			printf("%s/n", atom_to_string(atom));			break;		}		atom_implode(atom);	}	return EXIT_SUCCESS;}

int tool_sockopt_cb(void *userdata, curl_socket_t curlfd, curlsocktype purpose){  struct Configurable *config = userdata;  int onoff = 1; /* this callback is only used if we ask for keepalives on the                    connection */#if defined(TCP_KEEPIDLE) || defined(TCP_KEEPINTVL)  int keepidle = (int)config->alivetime;#endif  switch(purpose) {  case CURLSOCKTYPE_IPCXN:    if(setsockopt(curlfd, SOL_SOCKET, SO_KEEPALIVE, (void *)&onoff,                  sizeof(onoff)) < 0) {      /* don't abort operation, just issue a warning */      SET_SOCKERRNO(0);      warnf(config, "Could not set SO_KEEPALIVE!/n");      return 0;    }    else {      if(config->alivetime) {#ifdef TCP_KEEPIDLE        if(setsockopt(curlfd, IPPROTO_TCP, TCP_KEEPIDLE, (void *)&keepidle,                      sizeof(keepidle)) < 0) {          /* don't abort operation, just issue a warning */          SET_SOCKERRNO(0);          warnf(config, "Could not set TCP_KEEPIDLE!/n");          return 0;        }#endif#ifdef TCP_KEEPINTVL        if(setsockopt(curlfd, IPPROTO_TCP, TCP_KEEPINTVL, (void *)&keepidle,                      sizeof(keepidle)) < 0) {          /* don't abort operation, just issue a warning */          SET_SOCKERRNO(0);          warnf(config, "Could not set TCP_KEEPINTVL!/n");          return 0;        }#endif#if !defined(TCP_KEEPIDLE) || !defined(TCP_KEEPINTVL)        warnf(config, "Keep-alive functionality somewhat crippled due to "              "missing support in your operating system!/n");#endif      }    }    break;  default:    break;  }  return 0;}

/** * Looks at the parameters and displays help based upon those parameters * * @param CmdLine the string containing the parameters for the commandlet */INT UHelpCommandlet::Main(const FString& CmdLine){	TArray<FString> Params;	TArray<FString> Ignored;	// Parse the command line into an array of strings	ParseCommandLine(*CmdLine,Params,Ignored);	// Validate the number of params passed in	if (Params.Num() >= 1)	{		// Load everything up so we can find both native and script classes		LoadAllClasses();		warnf(TEXT(""));		// Check for either "list" or "commandletname"		if (Params.Num() == 1)		{			// Check for listing all commandlets			if (appStricmp(TEXT("list"),*Params(0)) == 0)			{				ListAllCommandlets();			}			else			{				// Try to load the commandlet so we can get the help info				UClass* TheClass = LoadCommandlet(*Params(0));				if (TheClass != NULL)				{					DumpCommandletInfo(TheClass->GetDefaultObject<UCommandlet>());				}			}		}		// Must be the webhelp option		else		{			// Try to load the commandlet so we can get the URL info			UClass* TheClass = LoadCommandlet(*Params(1));			if (TheClass != NULL)			{				// Get the default object so we can look at its props				UCommandlet* DefObject = TheClass->GetDefaultObject<UCommandlet>();				if (DefObject->HelpWebLink.Len() > 0)				{					// Open a browser to the site specified in the default properties					appLaunchURL(*DefObject->HelpWebLink);				}			}		}	}	else	{		warnf(TEXT("/r/nUsage:/r/n/r/n%s"),*HelpUsage);	}	return 0;}

	/**	 * Returns the set of column names for this Recordset.  This is useful for determining  	 * what you can actually ask the record set for without having to hard code those ahead of time.  	 */  	virtual TArray<FDatabaseColumnInfo> GetColumnNames() const	{  		TArray<FDatabaseColumnInfo> Retval;  		if( !ADORecordSet->BOF || !ADORecordSet->ADOEOF ) 		{  			ADORecordSet->MoveFirst();			for( SWORD i = 0; i < ADORecordSet->Fields->Count; ++i )  			{  				_bstr_t bstrName = ADORecordSet->Fields->Item[i]->Name;  				_variant_t varValue = ADORecordSet->Fields->Item[i]->Value;  				ADODB::DataTypeEnum DataType = ADORecordSet->Fields->Item[i]->Type;  				FDatabaseColumnInfo NewInfo;  				NewInfo.ColumnName = FString((TCHAR*)_bstr_t(bstrName));  				// from http://www.w3schools.com/ado/prop_field_type.asp#datatypeenum  				switch( DataType )  				{  				case ADODB::adInteger:  				case ADODB::adBigInt:					NewInfo.DataType = DBT_INT;  					break;  				case ADODB::adSingle:  				case ADODB::adDouble:  					NewInfo.DataType = DBT_FLOAT;  					break;  				case ADODB::adWChar:				case ADODB::adVarWChar:					NewInfo.DataType = DBT_STRING;					break;				default:  					warnf( NAME_DevDataBase, TEXT("Unable to find a EDataBaseUE3Types (%s) from DODB::DataTypeEnum DataType: %d "), *NewInfo.ColumnName, static_cast<INT>(DataType) );  					NewInfo.DataType = DBT_UNKOWN;  					break;  				}  				Retval.AddItem( NewInfo );  			}  		}  		// here for debugging as this code is new.		for( INT i = 0; i < Retval.Num(); ++ i )  		{  			warnf( TEXT( "ColumnName %d: Name: %s  Type: %d"), i, *Retval(i).ColumnName, static_cast<INT>(Retval(i).DataType) );  		}  		return Retval;  	}   

/* scan a directory for Mach-O files and print when we find one */static int scanmacho_dir(const char *path){	register DIR *dir;	register struct dirent *dentry;	struct stat st_top, st;	char buf[__PAX_UTILS_PATH_MAX];	size_t pathlen = 0, len = 0;	int ret = 0;	/* make sure path exists */	if (lstat(path, &st_top) == -1) {		if (be_verbose > 2) printf("%s: does not exist/n", path);		return 1;	}	/* ok, if it isn't a directory, assume we can open it */	if (!S_ISDIR(st_top.st_mode))		return scanmacho_file(path, &st_top);	/* now scan the dir looking for fun stuff */	if ((dir = opendir(path)) == NULL) {		warnf("could not opendir %s: %s", path, strerror(errno));		return 1;	}	if (be_verbose > 1) printf("%s: scanning dir/n", path);	pathlen = strlen(path);	while ((dentry = readdir(dir))) {		if (!strcmp(dentry->d_name, ".") || !strcmp(dentry->d_name, ".."))			continue;		len = (pathlen + 1 + strlen(dentry->d_name) + 1);		if (len >= sizeof(buf)) {			warnf("Skipping '%s': len > sizeof(buf); %lu > %lu/n", path,			      (unsigned long)len, (unsigned long)sizeof(buf));			continue;		}		snprintf(buf, sizeof(buf), "%s%s%s", path, (path[pathlen-1] == '/') ? "" : "/", dentry->d_name);		if (lstat(buf, &st) != -1) {			if (S_ISREG(st.st_mode))				ret = scanmacho_file(buf, &st);			else if (dir_recurse && S_ISDIR(st.st_mode)) {				if (dir_crossmount || (st_top.st_dev == st.st_dev))					ret = scanmacho_dir(buf);			}		}	}	closedir(dir);	return ret;}

static unsigned parse_relax(const char *str){   char *copy = strdup(str);   assert(copy);   unsigned mask = 0;   char *token = strtok(copy, ",");   while (token != NULL) {      if (strcmp(token, "prefer-explicit") == 0)         mask |= RELAX_PREFER_EXPLICT;      else if (strcmp(token, "locally-static") == 0)         mask |= RELAX_LOCALLY_STATIC;      else if (strcmp(token, "generic-static") == 0) {         warnf("relax option 'generic-static' is deprecated: use "               "'locally-static' instead");         mask |= RELAX_LOCALLY_STATIC;      }      else if (strcmp(token, "universal-bound") == 0)         mask |= RELAX_UNIVERSAL_BOUND;      else if (strcmp(token, "pure-files") == 0)         mask |= RELAX_PURE_FILES;      else         fatal("invalid relax option '%s'", token);      token = strtok(NULL, ",");   }   free(copy);   return mask;}

/** * Trys to load the UClass for the commandlet that was requested * * @param CommandletName the name of the commandlet to load */static UClass* LoadCommandlet(const TCHAR* CommandletName){	// Try to find the UClass for the commandlet (works for all but script classes)	UClass* Class = FindObject<UClass>(ANY_PACKAGE,CommandletName,FALSE);	// Don't accept classes that are not commandlets...	if (!Class->IsChildOf(UCommandlet::StaticClass()))	{		Class = NULL;	}	// Name mangle by appending Commandlet	FString AppendedName(CommandletName);	AppendedName += TEXT("Commandlet");	if (Class == NULL)	{		Class = FindObject<UClass>(ANY_PACKAGE,*AppendedName,FALSE);		// Don't accept classes that are not commandlets...		if (!Class->IsChildOf(UCommandlet::StaticClass()))		{			Class = NULL;		}	}	// Let the user know that the commandlet wasn't found	if (Class == NULL)	{		warnf(TEXT("Failed to load commandlet %s"),CommandletName);	}	return Class;}

char *target_gets(target_context_t *tc, char *s, int size){	unsigned char c;	char *p = s;	assert(tc);	assert(s);	assert(size >= 0);	if (!size--)		return s;	while (size--) {		ssize_t nread = xread(tc->portfd, &c, 1);		if(nread == ERROR_VALUE) break;		if(nread == 0) break; //timeout		if (c == '/r')			++size;		else			*p++ = c;		if (c == '/n')			break;	}	*p = '/0';	/* report error lines */	if (ok_or_ng(s) < 0)		warnf("from target: %s", s);	return s;}

int target_get_response(target_context_t *tc){	char buf [LINE_LENGTH];	assert(tc);	switch (ok_or_ng(target_gets(tc, buf, sizeof buf))) {	case 1:		msg("target: +OK/n");		break;	case 2:		msg("target: +GO/n");		break;	case 0:#ifndef WIN32		warn("target didn't respond with +OK or -NG/n");                warnf("unknown response `%s'/n", buf);#endif		return -1;	case -1:		/* warning message is generated by target_gets() */		return -1;	default:		assert(0);		return -1;	}	return 0;}

const char *execute(S32 argc, const char *argv[]){#ifdef TORQUE_MULTITHREAD   if(isMainThread())   {#endif      Namespace::Entry *ent;      StringTableEntry funcName = StringTable->insert(argv[0]);      ent = Namespace::global()->lookup(funcName);      if(!ent)      {         warnf(ConsoleLogEntry::Script, "%s: Unknown command.", argv[0]);         // Clean up arg buffers, if any.         STR.clearFunctionOffset();         return "";      }      return ent->execute(argc, argv, &gEvalState);#ifdef TORQUE_MULTITHREAD   }   else   {      SimConsoleThreadExecCallback cb;      SimConsoleThreadExecEvent *evt = new SimConsoleThreadExecEvent(argc, argv, false, &cb);      Sim::postEvent(Sim::getRootGroup(), evt, Sim::getCurrentTime());            return cb.waitForResult();   }#endif}

static bool link_find_native_library(lib_t lib, tree_t unit, FILE *deps){#ifdef ENABLE_NATIVE   ident_t name = tree_ident(unit);   char *so_name = xasprintf("_%s.so", istr(name));   lib_mtime_t so_mt;   if (!lib_stat(lib, so_name, &so_mt)) {      free(so_name);      return false;   }   lib_mtime_t unit_mt = lib_mtime(lib, name);   if (unit_mt > so_mt) {      warnf("unit %s has stale native shared library", istr(name));      free(so_name);      return false;   }   if (deps != NULL) {      char path[PATH_MAX];      lib_realpath(lib, so_name, path, sizeof(path));      fprintf(deps, "%s/n", path);   }   free(so_name);   return true;#else   // ENABLE_NATIVE   return false;#endif  // ENABLE_NATIVE}

	/**	 * Executes the passed in command on the database. The caller is responsible for deleting	 * the created RecordSet.	 *	 * @param CommandString		Command to execute	 * @param RecordSet			Reference to recordset pointer that is going to hold result	 *	 * @return TRUE if execution was successful, FALSE otherwise	 */	virtual UBOOL Execute( const TCHAR* CommandString, FDataBaseRecordSet*& RecordSet )	{		// Initialize return value.		RecordSet = NULL;		try		{			// Create instance of record set.			ADODB::_RecordsetPtr ADORecordSet = NULL;			ADORecordSet.CreateInstance(__uuidof(ADODB::Recordset) );							// Execute the passed in command on the record set. The recordset returned will be in open state so you can call Get* on it directly.			ADORecordSet->Open( CommandString, _variant_t((IDispatch *) DataBaseConnection), ADODB::adOpenStatic, ADODB::adLockReadOnly, ADODB::adCmdText );			// Create record set from returned data.			RecordSet = new FADODataBaseRecordSet( ADORecordSet );		}		catch(_com_error &Error)		{			// Log error and return. This will not log if called before appInit due to use of debugf.			TCHAR* ErrorDescription = (TCHAR*) Error.Description();			warnf(NAME_DevDataBase,TEXT("Failure executing command [%s] [%s]"),CommandString,ErrorDescription);						// Delete record set if it has already been created.			delete RecordSet;			RecordSet = NULL;		}		return RecordSet != NULL;	}

bool CConfigManager::getConfig(const char* name, CConfigTable& table){	CGuard guard(m_mutex);	int ret = applySuccess;	if (strcmp(name, "All") == 0)	{		table = m_configAll;		tracef("CConfigManager::getConfig get all Configs./n");		return true;	}	if(m_configDefault[name].type() == Json::nullValue)	{		warnf("CConfigManager::getConfig '%s', but default config is not set yet!/n", name);		// 直接返回，不做默认配置替换和配置校验		table = m_configAll[name];		return table.type() != Json::nullValue;	}	table = m_configAll[name];	tracepoint();	infof("name is [%s]/n", name);	//std::cout << table << std::endl;	return table.type() != Json::nullValue;}

void dumpeasysrc(struct Configurable *config){  struct curl_slist *ptr;  char *o = config->libcurl;  if(o) {    FILE *out;    bool fopened = FALSE;    if(strcmp(o, "-")) {      out = fopen(o, "wt");      fopened = TRUE;    }    else      out = stdout;    if(!out)      warnf(config, "Failed to open %s to write libcurl code!/n", o);    else {      int i;      const char *c;      for(i=0; ((c = srchead[i]) != '/0'); i++)        fprintf(out, "%s/n", c);      /* Declare variables used for complex setopt values */      for(ptr=easysrc_decl; ptr; ptr = ptr->next)        fprintf(out, "  %s/n", ptr->data);      /* Set up complex values for setopt calls */      if(easysrc_data) {        fprintf(out, "/n");        for(ptr=easysrc_data; ptr; ptr = ptr->next)          fprintf(out, "  %s/n", ptr->data);      }      fprintf(out, "/n");      for(ptr=easysrc_code; ptr; ptr = ptr->next) {        if(ptr->data[0]) {          fprintf(out, "  %s/n", ptr->data);        }        else {          fprintf(out, "/n");        }      }      for(ptr=easysrc_clean; ptr; ptr = ptr->next)        fprintf(out, "  %s/n", ptr->data);      for(i=0; ((c = srcend[i]) != '/0'); i++)        fprintf(out, "%s/n", c);      if(fopened)        fclose(out);    }  }  easysrc_free();}

int ftpcccmethod(struct Configurable *config, const char *str){  if(curlx_raw_equal("passive", str))    return CURLFTPSSL_CCC_PASSIVE;  if(curlx_raw_equal("active", str))    return CURLFTPSSL_CCC_ACTIVE;  warnf(config, "unrecognized ftp CCC method '%s', using default/n", str);  return CURLFTPSSL_CCC_PASSIVE;}

static int shell_cmd_watch(ClientData cd, Tcl_Interp *interp,                           int objc, Tcl_Obj *const objv[]){   const char *help =      "watch - Trace changes to a signal/n"      "/n"      "Usage: watch SIGNALS.../n"      "/n"      "Prints a message every time an update occurs to a signal listed."      "/n"      "Examples:/n"      "  watch [signals {clk}]  Trace updates to all signals named clk/n";   if (show_help(objc, objv, help))      return TCL_OK;   if (objc == 1) {      warnf("nothing to watch (try -help for usage)");      return TCL_OK;   }   hash_t *decl_hash = (hash_t *)cd;   for (int i = 1; i < objc; i++) {      int length;      if (Tcl_ListObjLength(interp, objv[i], &length) != TCL_OK)         return TCL_ERROR;      for (int j = 0; j < length; j++) {         Tcl_Obj *obj;         if (Tcl_ListObjIndex(interp, objv[i], j, &obj) != TCL_OK)            return TCL_ERROR;         const char *str = Tcl_GetString(obj);         tree_t t = hash_get(decl_hash, ident_new(str));         if (t == NULL)            return tcl_error(interp, "object not found: %s", str);         if (t == NULL)            return tcl_error(interp, "object not found: %s", str);         else if (tree_kind(t) != T_SIGNAL_DECL)            return tcl_error(interp, "not a signal: %s", str);         else if (type_is_array(tree_type(t)))            return tcl_error(interp, "only scalar signals may be watched");         // TODO: make this work for arrays         slave_watch_msg_t msg = {            .index = tree_index(t)         };         slave_post_msg(SLAVE_WATCH, &msg, sizeof(msg));      }   }   return TCL_OK;}

/** * Loads all of the code packages completely (for script classes). Then iterates * through the UClass-es finding all commandlets and dumping information on them */static void ListAllCommandlets(void){	warnf(TEXT("%-40s    %s"),TEXT("Commandlet"),TEXT("Description"));	warnf(TEXT("--------------------------------------------------------------------------------"));	// Now iterate through all UClass-es looking for commandlets	for (TObjectIterator<UClass> It; It; ++It)	{		UCommandlet* DefObject = Cast<UCommandlet>(It->GetDefaultObject());		if (DefObject != NULL)		{			// Ignore commandlets that can't be created			if (It->HasAnyClassFlags(CLASS_Abstract) == FALSE)			{				const FString& Name = GetCommandletName(DefObject);				warnf(TEXT("%-40s - %s"),*Name,*DefObject->HelpDescription);			}		}	}}

long delegation(struct Configurable *config, char *str){  if(curlx_raw_equal("none", str))    return CURLGSSAPI_DELEGATION_NONE;  if(curlx_raw_equal("policy", str))    return CURLGSSAPI_DELEGATION_POLICY_FLAG;  if(curlx_raw_equal("always", str))    return CURLGSSAPI_DELEGATION_FLAG;  warnf(config, "unrecognized delegation method '%s', using none/n", str);  return CURLGSSAPI_DELEGATION_NONE;}

static mem_type_t region_type(const char *type_name){	if (!strcmp(type_name, "FLA"))		return MEMTYPE_FLASH;	if (!strcmp(type_name, "RAM"))		return MEMTYPE_RAM;	if (!strcmp(type_name, "ROM"))		return MEMTYPE_ROM;	warnf("unrecognized region type `%s'/n", type_name);	return MEMTYPE_INVALID;}	

int ftpfilemethod(struct Configurable *config, const char *str){  if(curlx_raw_equal("singlecwd", str))    return CURLFTPMETHOD_SINGLECWD;  if(curlx_raw_equal("nocwd", str))    return CURLFTPMETHOD_NOCWD;  if(curlx_raw_equal("multicwd", str))    return CURLFTPMETHOD_MULTICWD;  warnf(config, "unrecognized ftp file method '%s', using default/n", str);  return CURLFTPMETHOD_MULTICWD;}

int ftpcccmethod(struct OperationConfig *config, const char *str){  if(curl_strequal("passive", str))    return CURLFTPSSL_CCC_PASSIVE;  if(curl_strequal("active", str))    return CURLFTPSSL_CCC_ACTIVE;  warnf(config->global, "unrecognized ftp CCC method '%s', using default/n",        str);  return CURLFTPSSL_CCC_PASSIVE;}

static void *daemon_conn_thread(void *_sock_fd){    int sock_fd = (int)((char *)_sock_fd - (char *)NULL);    struct expbuf_t buf = {};    unsigned char auth_token[NEVERBLEED_AUTH_TOKEN_SIZE];    /* authenticate */    if (read_nbytes(sock_fd, &auth_token, sizeof(auth_token)) != 0) {        warnf("failed to receive authencication token from client");        goto Exit;    }    if (memcmp(auth_token, daemon_auth_token, NEVERBLEED_AUTH_TOKEN_SIZE) != 0) {        warnf("client authentication failed");        goto Exit;    }    while (1) {        char *cmd;        if (expbuf_read(&buf, sock_fd) != 0) {            if (errno != 0)                warnf("read error");            break;        }        if ((cmd = expbuf_shift_str(&buf)) == NULL) {            errno = 0;            warnf("failed to parse request");            break;        }        if (strcmp(cmd, "priv_enc") == 0) {            if (priv_enc_stub(&buf) != 0)                break;        } else if (strcmp(cmd, "priv_dec") == 0) {            if (priv_dec_stub(&buf) != 0)                break;        } else if (strcmp(cmd, "sign") == 0) {            if (sign_stub(&buf) != 0)                break;        } else if (strcmp(cmd, "load_key") == 0) {            if (load_key_stub(&buf) != 0)                break;        } else if (strcmp(cmd, "setuidgid") == 0) {            if (setuidgid_stub(&buf) != 0)                break;        } else {            warnf("unknown command:%s", cmd);            break;        }        if (expbuf_write(&buf, sock_fd) != 0) {            warnf(errno != 0 ? "write error" : "connection closed by client");            break;        }        expbuf_dispose(&buf);    }Exit:    expbuf_dispose(&buf);    close(sock_fd);    return NULL;}

static int shell_cmd_unwatch(ClientData cd, Tcl_Interp *interp,                             int objc, Tcl_Obj *const objv[]){   const char *help =      "unwatch - Stop tracing signals/n"      "/n"      "Usage: unwatch SIGNALS.../n"      "/n"      "Clears any watch callback on SIGNALS. Note this will also stop any/n"      "VCD or other waveform capture for these signals./n"      "/n"      "Examples:/n"      "  watch [signals {clk}]  Stop tracing updates to clk/n";   if (show_help(objc, objv, help))      return TCL_OK;   if (objc == 1) {      warnf("nothing to unwatch (try -help for usage)");      return TCL_OK;   }   hash_t *decl_hash = (hash_t *)cd;   // TODO: refactor this code to avoid duplication with "watch" and "show"   for (int i = 1; i < objc; i++) {      int length;      if (Tcl_ListObjLength(interp, objv[i], &length) != TCL_OK)         return TCL_ERROR;      for (int j = 0; j < length; j++) {         Tcl_Obj *obj;         if (Tcl_ListObjIndex(interp, objv[i], j, &obj) != TCL_OK)            return TCL_ERROR;         const char *str = Tcl_GetString(obj);         tree_t t = hash_get(decl_hash, ident_new(str));         if (t == NULL)            return tcl_error(interp, "object not found: %s", str);         else if (tree_kind(t) != T_SIGNAL_DECL)            return tcl_error(interp, "not a signal: %s", str);         slave_unwatch_msg_t msg = {            .index = tree_index(t)         };         slave_post_msg(SLAVE_UNWATCH, &msg, sizeof(msg));      }   }   return TCL_OK;}