C++ convert_string函数代码示例

void SzbaseWrapper::set_prober_address( const std::string& address , unsigned port )
{
	Szbase::GetObject()->SetProberAddress(
			convert_string(base_name) ,
			convert_string(address) ,
			boost::lexical_cast<std::wstring>(port) );
}

int main (int argc, char *argv [])
{
    int
        index = 0;
    byte
        key     [8],
        value   [8],
        result  [8],
        tst_buf [8];

    while (test_value [index][0] != '\0')
      {
        convert_string (key   , test_value[index++]);
        convert_string (value , test_value[index++]);
        convert_string (result, test_value[index++]);
        memcpy (tst_buf, value, 8);
        if (crypt_encode ((byte *)tst_buf, 8, CRYPT_DES, (byte *) key))
          {
            if (memcmp (tst_buf, result, 8) != 0)
                printf ("Error : line %d -> bad result\n",index/3);
            else
                putchar ('.');
          }
        else
            printf ("\nEncrypt return FALSE\n");

      }
    return (EXIT_SUCCESS);
}

/* @builtin-bind { 'V', builtin_contextualdefunlibrary }, */
int builtin_contextualdefunlibrary(interpreter* interp) {
  int status;
  string cxt;

  /* Get subcommand */
  ++interp->ip;
  if (!is_ip_valid(interp)) {
    print_error("Expected subcommand");
    return 0;
  }

  switch (curr(interp)) {
  case 's':
    cxt = convert_string("@=");
    cxt = append_cstr(cxt, current_context);
    cxt = append_cstr(cxt, "\n");
    break;

  case 'e':
    cxt = convert_string("@=*");
    cxt = append_cstr(cxt, get_context_extension(current_context));
    cxt = append_cstr(cxt, "\n");
    break;

  default:
    print_error("Unknown subcommand");
    return 0;
  }

  status = builtin_defunlibrary_common(interp, cxt, 'D');
  free(cxt);
  return status;
}

int main(int argc, char *argv[])
{
    cmdname = "";
    arg1 = NULL;
    arg1len = 0;
    arg2 = NULL;
    arg2len = 0;

    if (argv[1]) {
	cmdname = "open";
	arg1 = argv[1];
        do_command();
	cmdname =  "";
	arg1 = NULL;
    }

    switch (argc) {
	case 1:
	case 2:
	    
	    while ((cmdname = tdb_getline("tdb> "))) {
		arg2 = arg1 = NULL;
		if ((arg1 = strchr((const char *)cmdname,' ')) != NULL) {
		    arg1++;
		    arg2 = arg1;
		    while (*arg2) {
			if (*arg2 == ' ') {
			    *arg2++ = '\0';
			    break;
			}
			if ((*arg2++ == '\\') && (*arg2 == ' ')) {
			    arg2++;
			}
		    }
		}
		if (arg1) arg1 = convert_string(arg1,&arg1len);
		if (arg2) arg2 = convert_string(arg2,&arg2len);
		if (do_command()) break;
	    }
	    break;
	case 5:
	    arg2 = convert_string(argv[4],&arg2len);
	case 4:
	    arg1 = convert_string(argv[3],&arg1len);
	case 3:
	    cmdname = argv[2];
	default:
	    do_command();
	    break;
    }

    if (tdb) tdb_close(tdb);

    return 0;
}

void
seahorse_gpgme_uid_set_userid (SeahorseGpgmeUid *self, gpgme_user_id_t userid)
{
	SeahorsePgpUid *base;
	GObject *obj;
	gpgme_user_id_t uid;
	gchar *string;
	gint index, i;
	
	g_return_if_fail (SEAHORSE_IS_GPGME_UID (self));
	g_return_if_fail (userid);
	
	if (self->pv->userid)
		g_return_if_fail (seahorse_gpgme_uid_is_same (self, userid));
	
	/* Make sure that this userid is in the pubkey */
	index = -1;
	for (i = 0, uid = self->pv->pubkey->uids; uid; ++i, uid = uid->next) {
		if(userid == uid) {
			index = i;
			break;
		}
	}
	
	g_return_if_fail (index >= 0);
	
	self->pv->userid = userid;
	self->pv->gpgme_index = index;
	
	obj = G_OBJECT (self);
	g_object_freeze_notify (obj);
	g_object_notify (obj, "userid");
	g_object_notify (obj, "gpgme_index");
	
	base = SEAHORSE_PGP_UID (self);

	string = convert_string (userid->comment);
	seahorse_pgp_uid_set_comment (base, string);
	g_free (string);

	string = convert_string (userid->email);
	seahorse_pgp_uid_set_email (base, string);
	g_free (string);

	string = convert_string (userid->name);
	seahorse_pgp_uid_set_name (base, string);
	g_free (string);

	realize_signatures (self);

	seahorse_pgp_uid_set_validity (base, seahorse_gpgme_convert_validity (userid->validity));

	g_object_thaw_notify (obj);
}

static int check_dos_char_slowly(smb_ucs2_t c)
{
	char buf[10];
	smb_ucs2_t c2 = 0;
	int len1, len2;
	len1 = convert_string(CH_UCS2, CH_DOS, &c, 2, buf, sizeof(buf),False);
	if (len1 == 0) return 0;
	len2 = convert_string(CH_DOS, CH_UCS2, buf, len1, &c2, 2,False);
	if (len2 != 2) return 0;
	return (c == c2);
}

std::string SzbaseWrapper::get_data( const std::string& param ,
                                     const std::string& from ,
                                     const std::string& to ,
                                     ValueType value_type ,
                                     TimeType time_type ,
                                     ProbeType pt ) const
throw( szbase_init_error, szbase_error )
{
    std::ostringstream ss;

    TParam* tparam = IPKContainer::GetObject()->GetParam( convert_string( base_name + ":" + param ) );
    if( !tparam )
        throw szbase_error( "Param " + param + ", does not exist." );

    try {
        switch (time_type) {
        case TimeType::NANOSECOND:
            ::get_data<sz4::nanosecond_time_t>( base , tparam ,
                                                from , to ,
                                                value_type , pt.get_szarp_pt() ,
                                                ss );
            break;
        case TimeType::SECOND:
            ::get_data<sz4::second_time_t>    ( base , tparam ,
                                                from , to ,
                                                value_type , pt.get_szarp_pt() ,
                                                ss );
            break;
        }
    } catch ( sz4::exception& e ) {
        throw szbase_error( "Cannot get data for param " + param + ": " + e.what() );
    }

    return ss.str();
}

 BOOL smbldap_get_single_attribute (LDAP * ldap_struct, LDAPMessage * entry,
				    const char *attribute, char *value,
				    int max_len)
{
	char **values;
	
	if ( !attribute )
		return False;
		
	value[0] = '\0';

	if ((values = ldap_get_values (ldap_struct, entry, attribute)) == NULL) {
		DEBUG (10, ("smbldap_get_single_attribute: [%s] = [<does not exist>]\n", attribute));
		
		return False;
	}
	
	if (convert_string(CH_UTF8, CH_UNIX,values[0], -1, value, max_len, False) == (size_t)-1) {
		DEBUG(1, ("smbldap_get_single_attribute: string conversion of [%s] = [%s] failed!\n", 
			  attribute, values[0]));
		ldap_value_free(values);
		return False;
	}
	
	ldap_value_free(values);
#ifdef DEBUG_PASSWORDS
	DEBUG (100, ("smbldap_get_single_attribute: [%s] = [%s]\n", attribute, value));
#endif	
	return True;
}

NTSTATUS ndr_push_charset(struct ndr_push *ndr, int ndr_flags, const char *var,
			  uint32_t length, uint8_t byte_mul, charset_t chset)
{
	ssize_t ret, required;

	if (NDR_BE(ndr) && chset == CH_UTF16) {
		chset = CH_UTF16BE;
	}

	required = byte_mul * length;
	
	NDR_PUSH_NEED_BYTES(ndr, required);
	ret = convert_string(CH_UNIX, chset, 
			     var, strlen(var),
			     ndr->data+ndr->offset, required, False);
	if (ret == -1) {
		return ndr_push_error(ndr, NDR_ERR_CHARCNV, 
				      "Bad character conversion");
	}

	/* Make sure the remaining part of the string is filled with zeroes */
	if (ret < required) {
		memset(ndr->data+ndr->offset+ret, 0, required-ret);
	}

	ndr->offset += required;

	return NT_STATUS_OK;
}

Scanner::token_t Def::
extract_string_array (std::string  *str,
                      std::wstring *wstr,
                      std::size_t   nelems)
{
    assert (0 != str);
    assert (0 != wstr);

    Scanner::token_t tok;

    for (std::size_t i = 0; i != nelems; ++i) {

        tok = scanner_.next_token ();

        if (tok.token != Scanner::tok_string) {
            issue_diag (W_MISSING, false, &tok, "expected string");
            break;
        }

        str  [i] = convert_string (tok.name);
        wstr [i] = convert_wstring (tok);
    }

    return tok;
}

static int32_t constdb_load(FILE * file_stm, void * db_mem, int32_t db_size) {
   const_t * db = (const_t *) db_mem;
   int32_t cnt = DB_BEGIN;
   char buf[BUF_SIZE];
   char fld[BUF_SIZE];
   int32_t read_buf = 0;
   int32_t read_fld = 0;
   int32_t data_fld = 0;

   while(fgets(buf, BUF_SIZE, file_stm) != NULL) {
      read_buf = 0;
      read_fld = 0;
      data_fld = 0;

      while(1) {
         /* check if delimiter for field */
         if(isspace(buf[read_buf]) || buf[read_buf] == ',' || buf[read_buf] == '\0') {
            fld[read_fld] = '\0';
            switch(data_fld) {
               case 0: db[cnt].name = convert_string(fld); break;
               case 1:  
                  /* constant can be represented as hexadecimal or decimal */
                  if(strlen(fld) > 2 && fld[0] == '0' && fld[1] == 'x')
                     db[cnt].value = convert_integer(fld, 16);
                  else
                     db[cnt].value = convert_integer(fld, 10);
                  break;
               case 2: db[cnt].type = convert_integer(fld, 10); break;
               default: fprintf(stdout,"warn: constdb_load; invalid field column %s in %s", fld, buf); break;
            }
            read_fld = 0;
            data_fld++;

            /* skip all other whitespace */
            while(isspace(buf[read_buf+1]) && buf[read_buf+1] != '\0') read_buf++;
         } else {
            fld[read_fld] = buf[read_buf];
            read_fld++;
         }

         /* finish reading the item */
         if(buf[read_buf] == '\0' || buf[read_buf] == '\n') break;
         read_buf++;
      }

      /* check for missing fields */
      if(data_fld < CONST_COLUMNS_MIN || data_fld > CONST_COLUMNS_MAX) 
         fprintf(stdout,"warn: constdb_load; missing field expected %d < %d < %d %s", 
            CONST_COLUMNS_MIN, data_fld, CONST_COLUMNS_MAX, buf);

      cnt++;

      /* check for exceed size of allocated memory */
      if(cnt > db_size) {
         fprintf(stdout,"warn: constdb_load; exceeding the size of the database; %d < %d.\n%s\n", db_size, cnt, buf);
         exit(EXIT_FAILURE);
      }
   }
   return cnt;
}

// botsafe bprintf
void safe_bprintf (int printlevel, char *fmt, ...)
{
int i;
char bigbuffer[0x10000];
char bigbuffer2[0x10000];
int  len;
va_list  argptr;
edict_t *cl_ent;

va_start (argptr,fmt);
len = vsprintf (bigbuffer,fmt,argptr);
va_end (argptr);


if (dedicated->value)
{
	convert_string(bigbuffer, 128, 255, -128, bigbuffer2); // green -> white
	gi.cprintf(NULL, printlevel, bigbuffer2);
}

// This is to be compatible with Eraser (ACE)
//for (i=0; i<num_players; i++)
//{
// Ridah, changed this so CAM works
for (i=0 ; i<maxclients->value ; i++)
{
	cl_ent = g_edicts + 1 + i;
 
  if (cl_ent->inuse && !cl_ent->bot_client  && cl_ent->client->pers.in_game)
  if (G_EntExists(cl_ent))
	  gi.cprintf(cl_ent, printlevel, bigbuffer);
}

}

time_t SzbaseWrapper::get_latest(
			const std::string& param ,
			ProbeType type ) const
	throw( szbase_init_error, szbase_get_value_error )
{
	if( !SzbaseWrapper::is_initialized() )
		throw szbase_init_error("Szbase not initialized");

	bool ok;
	std::wstring error;

	/**
	 * It looks like szbase has different aruments for "search all" in
	 * case of 10sec and other probles
	 */
	time_t start = type == ProbeType( ProbeType::Type::LIVE ) ?
		-1 :
		std::numeric_limits<time_t>::max();

	auto t = Szbase::GetObject()->Search( 
			convert_string( base_name + ":" + param ) ,
			start , time_t(-1) , -1 ,
			type.get_szarp_pt() , ok , error );

	if( !ok )
		throw szbase_get_value_error("Cannot get latest time of param " + param + ": " + SC::S2A(error) );

	/**
	 * Round by hand because Szbase::Search returns probes rounded to 
	 * either 10min or 10sec, not to exact pt
	 */
	return round( t , type );
}

void html_form_control(struct part *p, struct form_control *fc)
{
	if (!p->data) {
		/*destroy_fc(fc);
		mem_free(fc);*/
		add_to_list(p->uf, fc);
		return;
	}
	fc->g_ctrl_num = g_ctrl_num++;
	if (fc->type == FC_TEXT || fc->type == FC_PASSWORD || fc->type == FC_TEXTAREA) {
		unsigned char *dv = convert_string(convert_table, fc->default_value, strlen(fc->default_value));
		if (dv) {
			mem_free(fc->default_value);
			fc->default_value = dv;
		}
		/*
		for (i = 0; i < fc->nvalues; i++) if ((dv = convert_string(convert_table, fc->values[i], strlen(fc->values[i])))) {
			mem_free(fc->values[i]);
			fc->values[i] = dv;
		}
		*/
	}
	if (fc->type == FC_TEXTAREA) {
		unsigned char *p;
		for (p = fc->default_value; p[0]; p++) if (p[0] == '\r') {
			if (p[1] == '\n') memmove(p, p + 1, strlen(p)), p--;
			else p[0] = '\n';
		}
	}
	add_to_list(p->data->forms, fc);
}

static void
render_rss_item(struct dom_renderer *renderer, struct dom_node *item)
{
	struct rss_renderer *rss = renderer->data;
	struct dom_string *title  = get_rss_text(item, RSS_ELEMENT_TITLE);
	struct dom_string *link   = get_rss_text(item, RSS_ELEMENT_LINK);
	struct dom_string *author = get_rss_text(item, RSS_ELEMENT_AUTHOR);
	struct dom_string *date   = get_rss_text(item, RSS_ELEMENT_PUBDATE);

	if (item->data.element.type == RSS_ELEMENT_ITEM) {
		Y(renderer)++;
		X(renderer) = 0;
	}

	if (title && is_dom_string_set(title)) {
		if (item->data.element.type == RSS_ELEMENT_CHANNEL) {
			unsigned char *str;

			str = convert_string(renderer->convert_table,
					     title->string, title->length,
					     renderer->document->options.cp,
					     CSM_DEFAULT, NULL, NULL, NULL);
			if (str)
				renderer->document->title = str;
		}
		render_dom_text(renderer, &rss->styles[RSS_STYLE_TITLE],
				title->string, title->length);
	}

	if (link && is_dom_string_set(link)) {
		X(renderer)++;
		add_dom_link(renderer, "[link]", 6, link->string, link->length);
	}

	/* New line, and indent */
	Y(renderer)++;
	X(renderer) = 0;

	if (author && is_dom_string_set(author)) {
		render_dom_text(renderer, &rss->styles[RSS_STYLE_AUTHOR],
				author->string, author->length);
	}

	if (date && is_dom_string_set(date)) {
		if (author && is_dom_string_set(author)) {
			render_dom_text(renderer, &rss->styles[RSS_STYLE_AUTHOR_DATE_SEP],
					" - ", 3);
		}

		render_dom_text(renderer, &rss->styles[RSS_STYLE_DATE],
				date->string, date->length);
	}

	if ((author && is_dom_string_set(author))
	    || (date && is_dom_string_set(date))) {
		/* New line, and indent */
		Y(renderer)++;
		X(renderer) = 0;
	}
}