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

static void get_real_name(TALLOC_CTX *mem_ctx, struct smbcli_state *cli,			  char **long_name, char **short_name){	const char *mask;	struct masktest_state state;	if (cli->transport->negotiate.protocol <= PROTOCOL_LANMAN1) {		mask = "//masktest//*.*";	} else {		mask = "//masktest//*";	}	f_info_hit = false;	state.mem_ctx = mem_ctx;	smbcli_list_new(cli->tree, mask,			FILE_ATTRIBUTE_HIDDEN | FILE_ATTRIBUTE_DIRECTORY,			RAW_SEARCH_DATA_BOTH_DIRECTORY_INFO,			listfn, &state);	if (f_info_hit) {		*short_name = talloc_strdup(mem_ctx, last_hit.short_name);		strlower(*short_name);		*long_name = talloc_strdup(mem_ctx, last_hit.long_name);		strlower(*long_name);	}	if (*short_name == '/0') {		*short_name = talloc_strdup(mem_ctx, *long_name);	}}

int psr_number_from_name(char *psrname)/* Returns the pulsar number of psrname from the database *//* This number can be from zero to the total number       *//* of pulsars minus 1.  This way you can use this number  *//* as an index from the result of collect_psrparams().    *//* Return -1 if no pulsar is found.                       */{   int ii, psrnumber = -1;   char *matchname, jname[13], bname[9];   matchname = strlower(psrname);   if (matchname[0] == 'j' || matchname[0] == 'b')      matchname++;   /* Read the database if needed */   if (!have_database)      np = read_database();   /* Search for the J-name, the B-name, or the alias */   for (ii = 0; ii < np; ii++) {      strncpy(jname, pulsardata[ii].jname, 13);      strncpy(bname, pulsardata[ii].bname, 9);      if (!strcmp(strlower(jname), matchname) ||          !strcmp(strlower(bname), matchname) ||          !strcmp(pulsardata[ii].alias, matchname)) {         psrnumber = ii;         break;      }   }   /* Return the pulsar number */   return psrnumber;}

struct passwd *Get_Pwnam(char *user,BOOL allow_change){  fstring user2;  int last_char;  int usernamelevel = lp_usernamelevel();  struct passwd *ret;    if (!user || !(*user))    return(NULL);  StrnCpy(user2,user,sizeof(user2)-1);  if (!allow_change) {    user = &user2[0];  }  ret = _Get_Pwnam(user);  if (ret)    return(ret);  strlower(user);  ret = _Get_Pwnam(user);  if (ret)    return(ret);  strupper(user);  ret = _Get_Pwnam(user);  if (ret)    return(ret);  /* Try with first letter capitalised. */  if (strlen(user) > 1)    strlower(user+1);    ret = _Get_Pwnam(user);  if (ret)    return(ret);  /* try with last letter capitalised */  strlower(user);  last_char = strlen(user)-1;  user[last_char] = toupper(user[last_char]);  ret = _Get_Pwnam(user);  if (ret)    return(ret);  /* Try all combinations up to usernamelevel. */  strlower(user);  ret = uname_string_combinations(user, _Get_Pwnam, usernamelevel);  if (ret)    return(ret);  if (allow_change)    fstrcpy(user,user2);  return(NULL);}

/****************************************************************************a wrapper for getpwnam() that tries with all lower and all upper case if the initial name fails. Also tried with first letter capitalised****************************************************************************/struct passwd *Get_Pwnam (const char *a_user){    fstring user;    int last_char;    int usernamelevel = lp_usernamelevel ();    struct passwd *ret;    if (!a_user || !(*a_user))        return (NULL);    StrnCpy (user, a_user, sizeof (user) - 1);    ret = _Get_Pwnam (user);    if (ret)        return (ret);    strlower (user);    ret = _Get_Pwnam (user);    if (ret)        return (ret);    strupper (user);    ret = _Get_Pwnam (user);    if (ret)        return (ret);    /* try with first letter capitalised */    if (strlen (user) > 1)        strlower (user + 1);    ret = _Get_Pwnam (user);    if (ret)        return (ret);    /* try with last letter capitalised */    strlower (user);    last_char = strlen (user) - 1;    user[last_char] = toupper (user[last_char]);    ret = _Get_Pwnam (user);    if (ret)        return (ret);    /* try all combinations up to usernamelevel */    strlower (user);    ret = uname_string_combinations (user, _Get_Pwnam, usernamelevel);    if (ret)        return (ret);    return (NULL);}

extern char *ini_get(ini_t * self, char *section, char *var){	dict_t *vars;	assert(self && section && var);	strlower(section);	strlower(var);	if (!(vars = dict_get(self->sections, section)))		return NULL;	return dict_get(vars, var);}

void run_interactive_loop(geonames_by_token_func geonames_func,                          int max_results,                          process_geoname_id_func process_func) {    char q[MAX_QUERY_LENGTH];    debug("Ready to serve/n");    for (;;) {        int i;        vector_t tokens;        geoname_indices_t geonames;        if (!fgets(q, sizeof q, stdin))            break;        strlower(strtrim(q));        if (!*q) {            puts("");            continue;        }        tokens = strsplit(q, " /t");        geonames = process_query(tokens, max_results, geonames_func);        for (i = 0; i != vector_size(geonames); ++i)            process_func(geoname_idx(geonames, i));        puts("");        vector_free(tokens);        vector_free(geonames);    }}

/* Get the extension of the file to be processed */int get_target_extension(t_session *session) {	char *last_slash;#ifdef CIFS	check_free(session->extension);	session->extension = NULL;#endif	if ((last_slash = strrchr(session->file_on_disk, '/')) == NULL) {		return -1;	}	if ((session->extension = strrchr(last_slash, '.')) != NULL) {		session->extension++;	} else {		session->extension = session->host->no_extension_as;	}#ifdef CIFS	if (session->extension != NULL) {		if ((session->extension = strdup(session->extension)) == NULL) {			return -1;		}		strlower(session->extension);	}#endif	return 0;}

/* Check if the domain name given in the parameter is one * of the locally configured domain names. * Returns 1 if yes and -1 otherwise */int is_domain_local(str* domain){	str tmp;	/* Make a temporary copy, domain name comparisons are always	 * case insensitive	 */	tmp.s = pkg_malloc(domain->len);	if (!tmp.s) {		ERR("No memory left/n");		return -1;	}	memcpy(tmp.s, domain->s, domain->len);	tmp.len = domain->len;	strlower(&tmp);	if (!db_mode) {		switch(db_get_did(0, &tmp)) {		case 1:  goto found;		default: goto not_found;		}	} else {		if (hash_lookup(0, *active_hash, &tmp) == 1) goto found;		else goto not_found;	} found:	pkg_free(tmp.s);	return 1; not_found:	pkg_free(tmp.s);	return -1;}

void v_macro(char *str, MNEMONIC *dummy){    STRLIST *base;    int defined = 0;    STRLIST **slp, *sl;    MACRO *mac;    /* slp, mac: might be used uninitialised */    MNEMONIC   *mne;    unsigned int i;    char buf[MAXLINE];    int skipit = !(Ifstack->xtrue && Ifstack->acctrue);        strlower(str);    if (skipit) {        defined = 1;    } else {        defined = (findmne(str) != NULL);        if (F_listfile && ListMode)            outlistfile("");    }    if (!defined) {        base = NULL;        slp = &base;        mac = (MACRO *)permalloc(sizeof(MACRO));        i = hash1(str);        mac->next = (MACRO *)MHash[i];        mac->vect = v_execmac;        mac->name = strcpy(permalloc(strlen(str)+1), str);        mac->flags = MF_MACRO;        MHash[i] = (MNEMONIC *)mac;    }    while (fgets(buf, MAXLINE, pIncfile->fi)) {        const char *comment;                if (Xdebug)            printf("%08lx %s/n", (unsigned long) pIncfile, buf);                ++pIncfile->lineno;                        comment = cleanup(buf, true);                mne = parse(buf);        if (Av[1][0]) {            if (mne && mne->flags & MF_ENDM) {                if (!defined)                    mac->strlist = base;                return;            }        }        if (!skipit && F_listfile && ListMode)            outlistfile(comment);        if (!defined) {            sl = (STRLIST *)permalloc(STRLISTSIZE+1+strlen(buf));            strcpy(sl->buf, buf);            *slp = sl;            slp = &sl->next;        }    }    asmerr( ERROR_PREMATURE_EOF, true, NULL );}

char_t *websUrlType(char_t *url, char_t *buf, int charCnt){	sym_t	*sp;	char_t	*ext, *parsebuf;	a_assert(url && *url);	a_assert(buf && charCnt > 0);	if (url == NULL || *url == '/0') {		gstrcpy(buf, T("text/plain"));		return buf;	}	if (websUrlParse(url, &parsebuf, NULL, NULL, NULL, NULL, NULL, 			NULL, &ext) < 0) {		gstrcpy(buf, T("text/plain"));		return buf;	}	strlower(ext);/* *	Lookup the mime type symbol table to find the relevant content type */	if ((sp = symLookup(websMime, ext)) != NULL) {		gstrncpy(buf, sp->content.value.string, charCnt);	} else {		gstrcpy(buf, T("text/plain"));	}	bfree(B_L, parsebuf);	return buf;}

/* * Add a new domain name to did */static int domain_add(domain_t* d, str* domain, unsigned int flags){	str* p1;	unsigned int* p2;	str dom;	if (!d || !domain) {		ERR("Invalid parameter value/n");		return -1;	}	dom.s = shm_malloc(domain->len);	if (!dom.s) goto error;	memcpy(dom.s, domain->s, domain->len);	dom.len = domain->len;	strlower(&dom);	p1 = (str*)shm_realloc(d->domain, sizeof(str) * (d->n + 1));	if (!p1) goto error;	p2 = (unsigned int*)shm_realloc(d->flags,									sizeof(unsigned int) * (d->n + 1));	if (!p2) goto error;	d->domain = p1;	d->domain[d->n] = dom;	d->flags = p2;	d->flags[d->n] = flags;	d->n++;	return 0; error:	ERR("Unable to add new domain name (out of memory)/n");	if (dom.s) shm_free(dom.s);	return -1;}

int main(int argc, char **argv){	URL_FILE *handle;	char buffer[BUFSIZE];	if(argc > 1)		strcpy(BASE,argv[1]);	else {		fprintf(stderr, "Usage: %s BaseURL/n",argv[0]);		exit(1);	}			handle = url_fopen(BASE, "r");	if (!handle) {		fprintf(stderr,"couldn't url_fopen() %s/n", BASE);		return 2;	}	while(!url_feof(handle)) {		url_fgets(buffer,sizeof(buffer),handle);		strlower(buffer);		fputs(buffer,stdout);		char *cur, link[BUFSIZE], full_link[BUFSIZE];		cur = buffer;		while ((cur = nextURL(cur)) != NULL) {			getURL(cur, link, BUFSIZE-1);			normalise(link, full_link, BUFSIZE-1);			printf("%s/n",full_link);			cur += strlen(link);		}	}	url_fclose(handle);	return 0;}

/** * @brief Parse a @a decoration definition. * *        Syntax: decoration=enable|disable * * @param in definition to be analyzed * * @return 0 (ok) or 1 (error) */static int item_decoration(char *in){    if (!window_item("decoration"))        return 1;    if (in_window("video"))        return 1;    if (in_window("playbar"))        return 1;    if (in_window("menu"))        return 1;    strlower(in);    if (strcmp(in, "enable") != 0 && strcmp(in, "disable") != 0) {        skin_error(MSGTR_SKIN_UnknownParameter, in);        return 1;    }    skin->mainDecoration = (strcmp(in, "enable") == 0);    mp_msg(MSGT_GPLAYER, MSGL_DBG2, "[skin]    decoration: %s/n", in);    return 0;}

intnametonum(char *s){	char *p;	int i, lo, hi, m, rv;	s = estrdup(s);	strlower(s);	for(p=s; *p; p++)		if(*p=='_')			*p = ' ';	currentmap(0);	rlock(&maplock);	lo = 0;	hi = map->nel;	while(hi-lo > 1){		m = (lo+hi)/2;		i = strcmp(s, map->el[m].s);		if(i < 0)			hi = m;		else			lo = m;	}	if(hi-lo == 1 && strcmp(s, map->el[lo].s)==0)		rv = map->el[lo].n;	else		rv = -1;	runlock(&maplock);	free(s);	return rv;}

/*********************************************************Join a domain.**********************************************************/static int join_domain(char *domain, char *remote){	pstring remote_machine;	fstring trust_passwd;	unsigned char orig_trust_passwd_hash[16];	BOOL ret;	pstrcpy(remote_machine, remote ? remote : "");	fstrcpy(trust_passwd, global_myname);	strlower(trust_passwd);	E_md4hash( (uchar *)trust_passwd, orig_trust_passwd_hash);	/* Ensure that we are not trying to join a	   domain if we are locally set up as a domain	   controller. */	if(strequal(remote, global_myname)) {		fprintf(stderr, "Cannot join domain %s as the domain controller name is our own. We cannot be a domain controller for a domain and also be a domain member./n", domain);		return 1;	}	/*	 * Create the machine account password file.	 */	if(!trust_password_lock( domain, global_myname, True)) {		fprintf(stderr, "Unable to open the machine account password file for /machine %s in domain %s./n", global_myname, domain); 		return 1;	}

/* * Check if domain is local */static int is_local(struct sip_msg* msg, char* fp, char* s2){    str domain, tmp;    if (get_str_fparam(&domain, msg, (fparam_t*)fp) != 0) {	ERR("Unable to get domain to check/n");	return -1;    }    tmp.s = pkg_malloc(domain.len);    if (!tmp.s) {	ERR("No memory left/n");	return -1;    }    memcpy(tmp.s, domain.s, domain.len);    tmp.len = domain.len;    strlower(&tmp);        if (!db_mode) {	switch(db_get_did(0, &tmp)) {	case 1:  goto found;	default: goto not_found;	}    } else {	if (hash_lookup(0, *active_hash, &tmp) == 1) goto found;	else goto not_found;    } found:    pkg_free(tmp.s);    return 1; not_found:    pkg_free(tmp.s);    return -1;}

/* *  column_names = statement:columns() */static int statement_columns(lua_State *L) {    statement_t *statement = (statement_t *)luaL_checkudata(L, 1, DBD_ORACLE_STATEMENT);    int rc;    bindparams_t *bind;    char errbuf[100];    int errcode;    int i;    int d = 1;    if (!statement->stmt) {        luaL_error(L, DBI_ERR_INVALID_STATEMENT);        return 0;    }    statement_fetch_metadata(L, statement);        lua_newtable(L);    for (i = 0; i < statement->num_columns; i++) {	const char *name = strlower(statement->bind[i].name);	LUA_PUSH_ARRAY_STRING(d, name);    }    return 1;}

int ADZ_libIsValidDiskFile(HXCFLOPPYEMULATOR* floppycontext,char * imgfile){	int pathlen;	char * filepath;	floppycontext->hxc_printf(MSG_DEBUG,"ADZ_libIsValidDiskFile %s",imgfile);	if(imgfile)	{		pathlen=strlen(imgfile);		if(pathlen!=0)		{			filepath=malloc(pathlen+1);			if(filepath!=0)			{				sprintf(filepath,"%s",imgfile);				strlower(filepath);								if((strstr( filepath,".adz" )!=NULL) || (strstr( filepath,".adf.gz" )!=NULL))				{					floppycontext->hxc_printf(MSG_DEBUG,"ADZ file !");					free(filepath);					return LOADER_ISVALID;				}				else				{					floppycontext->hxc_printf(MSG_DEBUG,"non ADZ file !");					free(filepath);					return LOADER_BADFILE;				}			}		}	}		return LOADER_BADPARAMETER;}

int	my_parser(t_scene *scene, t_parser *parser, int i){  char	*otab[6];  ptr	which_object[6];  init_functab(otab, which_object);  i = 0;  while (i < 5)    {      if (strcmp(otab[i], strlower(parser->tab[parser->n])) == 0)	{	  if ((i == 1 || i == 2) && parser->k != 3)	    parser->k = parser->k + i;	  (*which_object[i++])(scene, parser);	  i = 6;	}      i++;    }  if (i == 6)    {      printf("%s: unknown object line %d./n", parser->tab[0], parser->line);      exit(EXIT_FAILURE);    }  return (parser->k);}

static int get_did(str* did, str* domain){    str tmp;    domain_t* d;    unsigned int track;        track = 0;        if (!db_mode) {	ERR("lookup_domain only works in cache mode/n");	return -1;    }        tmp.s = pkg_malloc(domain->len);    if (!tmp.s) {	ERR("No memory left/n");	return -1;    }    memcpy(tmp.s, domain->s, domain->len);    tmp.len = domain->len;    strlower(&tmp);        if (hash_lookup(&d, *active_hash, &tmp) == 1) {	*did = d->did;	pkg_free(tmp.s);	return 1;    } else {	pkg_free(tmp.s);	return -1;    }}

static char getFunction(std::string const& name) {  std::string id = strlower(name);  if (id == "table") return funcTable;  if (id == "min") return funcMin;  if (id == "max") return funcMax;  return '(';}