Conversion de string c++ --> V8::String

Version imprimable

Bonjour a tous,

je suis en train de passer une de mes DLL en Unicode.
Malheureusement j'ai quelque problème avec la librairie Google V8.

Voici le code qui me pose problème:
Code:

1 2 3 4 std::string newScript=addWrapper(source); const char* tabSource=newScript.c_str(); ScriptData* scriptData= v8::ScriptData::PreCompile(tabSource,(int)strlen(tabSource));
Donc ici le code ne gère pas l'unicode. Voici donc ma nouvelle version:
Code:

1 2 3 4 5 6 7 basic_string<TCHAR> newScript=addWrapper(source); const TCHAR* tabSource=newScript.c_str(); //Handle< String > tmp=String::New(newScript); Handle< String > tmp=String::New(newScript.c_str()); ScriptData* scriptData= v8::ScriptData::PreCompile(tmp); //ScriptData* scriptData= v8::ScriptData::PreCompile(tabSource,(int)_tcslen(tabSource));
Quelque soit mes essaie, mon compilo me retourne :
error C2665: 'v8::String::New' : none of the 2 overloads could convert all the argument types

Donc savez vous comment convertir des wstring vers des v8::Handle< String > ou V8::String ou etc....

Je vous remercie d'avance pour votre aide ;)

EDIT: une solution:
Code:

1 2 3 4 5 6 7 8 9 10 11 12 v8::Local<String> convertStdStringToV8String(basic_string<TCHAR> in) { #ifdef _UNICODE const wchar_t* tabIn=in.c_str(); return String::New((uint16_t*)tabIn,(int)in.length()); #endif #ifndef _UNICODE return String::New(in.c_str(),(int)in.length()); #endif }

16/01/2013, 16h38
hannibal.76

Bon je ré-ouvre le sujet car malheureusement la conversion ne fonctionne pas.
A l’exécution, je me retrouve avec des valeurs totalement folle.

Donc savez vous comment convertir une wstring en v8::Local<String> ?
Je vous remercie par avance pour votre aide ;)

je suppose qu'un V8::String est une chaine UNICODE ? Essaie ce bout de code :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
V8::String convert( std::string const & p_strIn, std::locale const & loc = std::locale() )
{
	typedef typename std::codecvt< wchar_t, char, std::mbstate_t > facet_type;
	typedef typename facet_type::result result_type;
 
	std::mbstate_t l_state = std::mbstate_t();
	result_type l_result;
	std::vector< wchar_t > l_buffer( p_strIn.size() );
	char const * l_pEndIn = NULL;
	wchar_t * l_pEndOut = NULL;
 
	l_result = std::use_facet< facet_type >( loc).in( l_state, p_strIn.data(), p_strIn.data() + p_strIn.length(), l_pEndIn, &l_buffer.front(), &l_buffer.front() + l_buffer.size(), l_pEndOut );
 
	return V8::String( std::wstring( &l_buffer.front(), l_pEndOut ).c_str() );
}

Ca semble barbare (ça l'est même peut-être un peu) mais c'est la manière multiplateforme de convertir une chaine de ANSI vers UNICODE.
Si ça ne fonctionne pas tu peux essayer le bout de code suivant :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
std::wstring Str :: to_wstr( String const & p_str )
{
	std::wstring l_strReturn( p_str.size(), '\0' );
	std::wostringstream l_wstream;
	std::ctype< char > const & l_ctfacet = std::use_facet< std::ctype< char > >( l_wstream.getloc() );
 
	if( p_str.size() > 0 )
	{
//		l_ctfacet.widen( p_str.data(), p_str.data() + p_str.size(), & l_strReturn.front() );
		l_ctfacet.widen( p_str.data(), p_str.data() + p_str.size(), & l_strReturn[0] );
	}
 
	return l_strReturn;
}

16/01/2013, 17h25
hannibal.76

Oui, durant mes recherches j'ai vue que les chaines V8 sont sois ANSI soit UCS2.
Mon problème n'est pas de convertir une chaine en unicode, mes chaines sont déjà unicode

Code:

basic_string<TCHAR> --> (dans mon cas) --> basic_string<wchar_t> --> wstring

Donc pas de soucis pour avoir les chaines unicode.
Par contre pas moyen d'avoir une chaine V8 convenable

Apparemment il serait possible via ceci de faire la conversion vers du ASCII :

Code:

1
2
3
4
const char* stringArgToCStr(const v8::Local<v8::Value> arg) { 
    v8::String::AsciiValue str(arg); 
    return *str; 
  }

Je suppose que ceci est possible :

Code:

1
2
3
4
const wchar_t * stringArgToCWStr(const v8::Local<v8::Value> arg) { 
    v8::String::Utf8Value str(arg); 
    return *str;
  }

EDIT :

J'ai trouvé ceci :

Code:

1
2
3
4
5
6
7
8
static std::wstring GetWString(v8::Handle<v8::String> str)
{
  uint16_t* buf = new uint16_t[str->Length()+1];
  str->Write(buf);
  std::wstring value = reinterpret_cast<wchar_t*>(buf);
  delete [] buf;
  return value;
}

Bon les conversions ne semble plus posé de problème.
Voici les deux fonctions de conversion

Merci pour ton aide ;)

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
v8::Local<String> convertStdStringToV8String(basic_string<TCHAR> in)
 {
	#ifdef _UNICODE
		 const wchar_t* tabIn=in.c_str();
		 return String::New((uint16_t*)tabIn,(int)in.length());
	#else
		const char* tabIn=in.c_str();
		return String::New(tabIn,(int)in.length());
	#endif
 }
 
basic_string<TCHAR> convertV8StringToStdString(v8::Local<v8::String> str )
{
	#ifdef _UNICODE
		//basic_string<TCHAR>((LPCWSTR) *str)
		uint16_t* buf = new uint16_t[str->Length()+1];
		str->Write(buf);
		basic_string<wchar_t> value = reinterpret_cast<wchar_t*>(buf);
		delete [] buf;
		return value;
	#else
		String::AsciiValue ascii(str);
		basic_string<char> tmp=basic_string<char>(*ascii);
		return tmp;
	#endif
}

juste une proposition

Concernant la conversion d'un wstring en un v8::string et reciproquement, on pourrait faire:

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

/**
 * @fn static v8::Handle<v8::String> GetV8String (const std::wstring)
 * @param la wide string à convertir en v8 string
 * @brief convertit la wide string en v8 string
 * @return renvoit la v8 string
 */


// Convertir un wide string en un V8 string.

static v8::Handle<v8::String> GetV8String(const std::wstring & str)
{
  std::string tmpStr = WideToUTF8(str);
  return v8::String::New(tmpStr.c_str(), tmpStr.length());
}

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

/**
 * @fn static std::wstring GetWString (const v8::Handle<v8::String>)
 * @param la v8 string à convertir en Wide string
 * @brief convertit la v8 string en Widestring
 * @return renvoit la wide string
 */


// Convertir un V8 string en  un wide string.
static std::wstring GetWString(v8::Handle<v8::String> str)
{
  // on alloue au buffer une taille len
  size_t len = str->Length()*4;
  char* buf = new char[len];
  int newlen = str->WriteUtf8(buf, len);
  std::wstring value;
  UTF8ToWide(buf, newlen, &value);
  delete [] buf;
  return value;
}