diff --git a/dtool/src/cppparser/cppBison.yxx b/dtool/src/cppparser/cppBison.yxx index 58165f4d3e..702ce929d8 100644 --- a/dtool/src/cppparser/cppBison.yxx +++ b/dtool/src/cppparser/cppBison.yxx @@ -239,6 +239,7 @@ pop_struct() { %token KW_BOOL %token KW_CATCH %token KW_CHAR +%token KW_WCHAR_T %token KW_CLASS %token KW_CONST %token KW_DELETE @@ -346,7 +347,7 @@ pop_struct() { /* Precedence rules. */ -%left IDENTIFIER TYPENAME_IDENTIFIER TYPEDEFNAME KW_ENUM ELLIPSIS KW_OPERATOR KW_TYPENAME KW_INT KW_SHORT KW_UNSIGNED KW_SIGNED KW_LONG KW_FLOAT KW_DOUBLE KW_CHAR KW_BOOL +%left IDENTIFIER TYPENAME_IDENTIFIER TYPEDEFNAME KW_ENUM ELLIPSIS KW_OPERATOR KW_TYPENAME KW_INT KW_SHORT KW_UNSIGNED KW_SIGNED KW_LONG KW_FLOAT KW_DOUBLE KW_CHAR KW_WCHAR_T KW_BOOL %left '{' ',' ';' @@ -1908,6 +1909,10 @@ simple_int_type: | KW_CHAR { $$ = new CPPSimpleType(CPPSimpleType::T_char); +} + | KW_WCHAR_T +{ + $$ = new CPPSimpleType(CPPSimpleType::T_wchar_t); } | KW_SHORT { @@ -2046,7 +2051,7 @@ element: | SCOPE | PLUSPLUS | MINUSMINUS | TIMESEQUAL | DIVIDEEQUAL | MODEQUAL | PLUSEQUAL | MINUSEQUAL | OREQUAL | ANDEQUAL | XOREQUAL | LSHIFTEQUAL | RSHIFTEQUAL - | KW_BOOL | KW_CATCH | KW_CHAR | KW_CLASS | KW_CONST + | KW_BOOL | KW_CATCH | KW_CHAR | KW_WCHAR_T | KW_CLASS | KW_CONST | KW_DELETE | KW_DOUBLE | KW_DYNAMIC_CAST | KW_ELSE | KW_ENUM | KW_EXTERN | KW_EXPLICIT | KW_FALSE | KW_FLOAT | KW_FRIEND | KW_FOR | KW_GOTO @@ -2273,6 +2278,12 @@ const_expr: CPPType *type = CPPType::new_type(new CPPSimpleType(CPPSimpleType::T_char)); $$ = new CPPExpression(CPPExpression::construct_op(type, $3)); +} + | KW_WCHAR_T '(' optional_const_expr_comma ')' +{ + CPPType *type = + CPPType::new_type(new CPPSimpleType(CPPSimpleType::T_wchar_t)); + $$ = new CPPExpression(CPPExpression::construct_op(type, $3)); } | KW_BOOL '(' optional_const_expr_comma ')' { diff --git a/dtool/src/cppparser/cppPreprocessor.cxx b/dtool/src/cppparser/cppPreprocessor.cxx index 5734626b65..e35013cbb5 100644 --- a/dtool/src/cppparser/cppPreprocessor.cxx +++ b/dtool/src/cppparser/cppPreprocessor.cxx @@ -1911,6 +1911,7 @@ check_keyword(const string &name) { if (name == "bool") return KW_BOOL; if (name == "catch") return KW_CATCH; if (name == "char") return KW_CHAR; + if (name == "wchar_t") return KW_WCHAR_T; if (name == "class") return KW_CLASS; if (name == "const") return KW_CONST; if (name == "delete") return KW_DELETE; diff --git a/dtool/src/cppparser/cppSimpleType.cxx b/dtool/src/cppparser/cppSimpleType.cxx index c8cfd72a92..865d793352 100644 --- a/dtool/src/cppparser/cppSimpleType.cxx +++ b/dtool/src/cppparser/cppSimpleType.cxx @@ -111,6 +111,10 @@ output(ostream &out, int, CPPScope *, bool) const { out << "char"; break; + case T_wchar_t: + out << "wchar_t"; + break; + case T_int: out << "int"; break; diff --git a/dtool/src/cppparser/cppSimpleType.h b/dtool/src/cppparser/cppSimpleType.h index de1e22aca7..9a1d5cc559 100644 --- a/dtool/src/cppparser/cppSimpleType.h +++ b/dtool/src/cppparser/cppSimpleType.h @@ -32,6 +32,7 @@ public: enum Type { T_bool, T_char, + T_wchar_t, // Not strictly a builtin type, but we pretend. T_int, T_float, T_double, diff --git a/dtool/src/interrogate/interfaceMaker.cxx b/dtool/src/interrogate/interfaceMaker.cxx index 07a538151c..c0a010dc74 100644 --- a/dtool/src/interrogate/interfaceMaker.cxx +++ b/dtool/src/interrogate/interfaceMaker.cxx @@ -283,12 +283,19 @@ remap_parameter(CPPType *struct_type, CPPType *param_type) { // convert basic_string's to atomic strings. if (struct_type == (CPPType *)NULL || - !TypeManager::is_basic_string_char(struct_type)) { + !(TypeManager::is_basic_string_char(struct_type) || + TypeManager::is_basic_string_wchar(struct_type))) { if (TypeManager::is_basic_string_char(param_type)) { return new ParameterRemapBasicStringToString(param_type); } else if (TypeManager::is_const_ref_to_basic_string_char(param_type)) { return new ParameterRemapBasicStringRefToString(param_type); + + } else if (TypeManager::is_basic_string_wchar(param_type)) { + return new ParameterRemapBasicWStringToWString(param_type); + + } else if (TypeManager::is_const_ref_to_basic_string_wchar(param_type)) { + return new ParameterRemapBasicWStringRefToWString(param_type); } } } diff --git a/dtool/src/interrogate/interfaceMakerPythonNative.cxx b/dtool/src/interrogate/interfaceMakerPythonNative.cxx index 53feb51ff0..9c0c3cbc6d 100755 --- a/dtool/src/interrogate/interfaceMakerPythonNative.cxx +++ b/dtool/src/interrogate/interfaceMakerPythonNative.cxx @@ -1826,7 +1826,8 @@ int GetParnetDepth(CPPType *type) int answer = 0; // printf(" %s\n",type->get_local_name().c_str()); - if (TypeManager::is_basic_string_char(type)) { + if (TypeManager::is_basic_string_char(type)) { + } else if (TypeManager::is_basic_string_wchar(type)) { } else if (TypeManager::is_bool(type)) { } else if (TypeManager::is_unsigned_longlong(type)) { } else if (TypeManager::is_longlong(type)) { @@ -2011,9 +2012,18 @@ void InterfaceMakerPythonNative::write_function_instance(ostream &out, Interface indent(out,indent_level+4)<< "char *" << param_name; format_specifiers += "s"; parameter_list += ", &" + param_name; - } - else - { + + } else if (TypeManager::is_wstring(orig_type)) { + indent(out,indent_level+4) << "Py_UNICODE *" << param_name + << "_str; int " << param_name << "_len"; + format_specifiers += "u#"; + parameter_list += ", &" + param_name + + "_str, &" + param_name + "_len"; + pexpr_string = "basic_string(" + + param_name + "_str, " + + param_name + "_len)"; + + } else { indent(out,indent_level+4) << "char *" << param_name << "_str; int " << param_name << "_len"; format_specifiers += "s#"; @@ -2284,6 +2294,11 @@ void InterfaceMakerPythonNative::pack_return_value(ostream &out, int indent_leve indent(out, indent_level) << "return PyString_FromString(" << return_expr << ");\n"; + } else if (TypeManager::is_wstring(orig_type)) { + indent(out, indent_level) + << "return PyUnicode_FromWideChar(" + << return_expr << ".data(), (int)" << return_expr << ".length());\n"; + } else { indent(out, indent_level) << "return PyString_FromStringAndSize(" @@ -2669,6 +2684,10 @@ bool InterfaceMakerPythonNative::isCppTypeLegal(CPPType *in_ctype) { return true; } + else if(TypeManager::is_basic_string_wchar(type)) + { + return true; + } else if(TypeManager::is_simple(type)) { return true; diff --git a/dtool/src/interrogate/interfaceMakerPythonSimple.cxx b/dtool/src/interrogate/interfaceMakerPythonSimple.cxx index 16fc1fbba2..53a625691d 100644 --- a/dtool/src/interrogate/interfaceMakerPythonSimple.cxx +++ b/dtool/src/interrogate/interfaceMakerPythonSimple.cxx @@ -268,6 +268,16 @@ void InterfaceMakerPythonSimple::write_function_instance(ostream &out, Interface format_specifiers += "s"; parameter_list += ", &" + param_name; + } else if (TypeManager::is_wstring(orig_type)) { + out << "Py_UNICODE *" << param_name + << "_str; int " << param_name << "_len"; + format_specifiers += "u#"; + parameter_list += ", &" + param_name + + "_str, &" + param_name + "_len"; + pexpr_string = "basic_string(" + + param_name + "_str, " + + param_name + "_len)"; + } else { out << "char *" << param_name << "_str; int " << param_name << "_len"; @@ -449,6 +459,11 @@ pack_return_value(ostream &out, int indent_level, indent(out, indent_level) << "return PyString_FromString(" << return_expr << ");\n"; + } else if (TypeManager::is_wstring(orig_type)) { + indent(out, indent_level) + << "return PyUnicode_FromWideChar(" + << return_expr << ".data(), (int)" << return_expr << ".length());\n"; + } else { indent(out, indent_level) << "return PyString_FromStringAndSize(" diff --git a/dtool/src/interrogate/interrogateBuilder.cxx b/dtool/src/interrogate/interrogateBuilder.cxx index 41ab2e5998..1c720a7cf8 100644 --- a/dtool/src/interrogate/interrogateBuilder.cxx +++ b/dtool/src/interrogate/interrogateBuilder.cxx @@ -1737,6 +1737,7 @@ get_type(CPPType *type, bool global) { if (global) { itype._flags |= InterrogateType::F_global; } + InterrogateDatabase::get_ptr()->add_type(index, itype); } @@ -1840,6 +1841,10 @@ define_atomic_type(InterrogateType &itype, CPPSimpleType *cpptype) { itype._atomic_token = AT_char; break; + case CPPSimpleType::T_wchar_t: + itype._atomic_token = AT_int; + break; + case CPPSimpleType::T_int: if ((cpptype->_flags & CPPSimpleType::F_longlong) != 0) { itype._atomic_token = AT_longlong; diff --git a/dtool/src/interrogate/parameterRemapBasicStringRefToString.cxx b/dtool/src/interrogate/parameterRemapBasicStringRefToString.cxx index c02c916af0..61a0a2216d 100644 --- a/dtool/src/interrogate/parameterRemapBasicStringRefToString.cxx +++ b/dtool/src/interrogate/parameterRemapBasicStringRefToString.cxx @@ -52,3 +52,38 @@ string ParameterRemapBasicStringRefToString:: get_return_expr(const string &expression) { return "(" + expression + ").c_str()"; } + +//////////////////////////////////////////////////////////////////// +// Function: ParameterRemapBasicWStringRefToWString::Constructor +// Access: Public +// Description: +//////////////////////////////////////////////////////////////////// +ParameterRemapBasicWStringRefToWString:: +ParameterRemapBasicWStringRefToWString(CPPType *orig_type) : + ParameterRemapToWString(orig_type) +{ +} + +//////////////////////////////////////////////////////////////////// +// Function: ParameterRemapBasicWStringRefToWString::pass_parameter +// Access: Public, Virtual +// Description: Outputs an expression that converts the indicated +// variable from the original type to the new type, for +// passing into the actual C++ function. +//////////////////////////////////////////////////////////////////// +void ParameterRemapBasicWStringRefToWString:: +pass_parameter(ostream &out, const string &variable_name) { + out << variable_name; +} + +//////////////////////////////////////////////////////////////////// +// Function: ParameterRemapBasicWStringRefToWString::get_return_expr +// Access: Public, Virtual +// Description: Returns an expression that evalutes to the +// appropriate value type for returning from the +// function, given an expression of the original type. +//////////////////////////////////////////////////////////////////// +string ParameterRemapBasicWStringRefToWString:: +get_return_expr(const string &expression) { + return "(" + expression + ").c_str()"; +} diff --git a/dtool/src/interrogate/parameterRemapBasicStringRefToString.h b/dtool/src/interrogate/parameterRemapBasicStringRefToString.h index e7b1608d16..7ca34373a1 100644 --- a/dtool/src/interrogate/parameterRemapBasicStringRefToString.h +++ b/dtool/src/interrogate/parameterRemapBasicStringRefToString.h @@ -36,4 +36,17 @@ public: virtual string get_return_expr(const string &expression); }; +//////////////////////////////////////////////////////////////////// +// Class : ParameterRemapBasicWStringRefToWString +// Description : Maps a const reference to a basic_string to an +// atomic string. +//////////////////////////////////////////////////////////////////// +class ParameterRemapBasicWStringRefToWString : public ParameterRemapToWString { +public: + ParameterRemapBasicWStringRefToWString(CPPType *orig_type); + + virtual void pass_parameter(ostream &out, const string &variable_name); + virtual string get_return_expr(const string &expression); +}; + #endif diff --git a/dtool/src/interrogate/parameterRemapBasicStringToString.cxx b/dtool/src/interrogate/parameterRemapBasicStringToString.cxx index b5b0aac7c5..4bba6bbe59 100644 --- a/dtool/src/interrogate/parameterRemapBasicStringToString.cxx +++ b/dtool/src/interrogate/parameterRemapBasicStringToString.cxx @@ -69,3 +69,54 @@ string ParameterRemapBasicStringToString:: get_return_expr(const string &expression) { return "string_holder.c_str()"; } + +//////////////////////////////////////////////////////////////////// +// Function: ParameterRemapBasicWStringToWString::Constructor +// Access: Public +// Description: +//////////////////////////////////////////////////////////////////// +ParameterRemapBasicWStringToWString:: +ParameterRemapBasicWStringToWString(CPPType *orig_type) : + ParameterRemapToString(orig_type) +{ +} + +//////////////////////////////////////////////////////////////////// +// Function: ParameterRemapBasicWStringToWString::pass_parameter +// Access: Public, Virtual +// Description: Outputs an expression that converts the indicated +// variable from the original type to the new type, for +// passing into the actual C++ function. +//////////////////////////////////////////////////////////////////// +void ParameterRemapBasicWStringToWString:: +pass_parameter(ostream &out, const string &variable_name) { + out << variable_name; +} + +//////////////////////////////////////////////////////////////////// +// Function: ParameterRemapBasicWStringToWString::prepare_return_expr +// Access: Public, Virtual +// Description: This will be called immediately before +// get_return_expr(). It outputs whatever lines the +// remapper needs to the function to set up its return +// value, e.g. to declare a temporary variable or +// something. It should return the modified expression. +//////////////////////////////////////////////////////////////////// +string ParameterRemapBasicWStringToWString:: +prepare_return_expr(ostream &out, int indent_level, const string &expression) { + InterfaceMaker::indent(out, indent_level) + << "static wstring string_holder = " << expression << ";\n"; + return "string_holder"; +} + +//////////////////////////////////////////////////////////////////// +// Function: ParameterRemapBasicWStringToWString::get_return_expr +// Access: Public, Virtual +// Description: Returns an expression that evalutes to the +// appropriate value type for returning from the +// function, given an expression of the original type. +//////////////////////////////////////////////////////////////////// +string ParameterRemapBasicWStringToWString:: +get_return_expr(const string &expression) { + return "string_holder.c_str()"; +} diff --git a/dtool/src/interrogate/parameterRemapBasicStringToString.h b/dtool/src/interrogate/parameterRemapBasicStringToString.h index 661a21961a..ae87f623cb 100644 --- a/dtool/src/interrogate/parameterRemapBasicStringToString.h +++ b/dtool/src/interrogate/parameterRemapBasicStringToString.h @@ -38,4 +38,19 @@ public: virtual string get_return_expr(const string &expression); }; +//////////////////////////////////////////////////////////////////// +// Class : ParameterRemapBasicWStringToWString +// Description : Maps a concrete basic_string to an atomic +// string. +//////////////////////////////////////////////////////////////////// +class ParameterRemapBasicWStringToWString : public ParameterRemapToString { +public: + ParameterRemapBasicWStringToWString(CPPType *orig_type); + + virtual void pass_parameter(ostream &out, const string &variable_name); + virtual string prepare_return_expr(ostream &out, int indent_level, + const string &expression); + virtual string get_return_expr(const string &expression); +}; + #endif diff --git a/dtool/src/interrogate/parameterRemapToString.cxx b/dtool/src/interrogate/parameterRemapToString.cxx index 0beaf9e733..2e9c0103ff 100644 --- a/dtool/src/interrogate/parameterRemapToString.cxx +++ b/dtool/src/interrogate/parameterRemapToString.cxx @@ -73,3 +73,58 @@ bool ParameterRemapToString:: new_type_is_atomic_string() { return true; } + +//////////////////////////////////////////////////////////////////// +// Function: ParameterRemapToWString::Constructor +// Access: Public +// Description: +//////////////////////////////////////////////////////////////////// +ParameterRemapToWString:: +ParameterRemapToWString(CPPType *orig_type) : + ParameterRemap(orig_type) +{ + static CPPType *char_star_type = (CPPType *)NULL; + if (char_star_type == (CPPType *)NULL) { + char_star_type = parser.parse_type("const wchar_t *"); + } + + _new_type = char_star_type; +} + +//////////////////////////////////////////////////////////////////// +// Function: ParameterRemapToWString::pass_parameter +// Access: Public, Virtual +// Description: Outputs an expression that converts the indicated +// variable from the original type to the new type, for +// passing into the actual C++ function. +//////////////////////////////////////////////////////////////////// +void ParameterRemapToWString:: +pass_parameter(ostream &out, const string &variable_name) { + out << variable_name; +} + +//////////////////////////////////////////////////////////////////// +// Function: ParameterRemapToWString::get_return_expr +// Access: Public, Virtual +// Description: Returns an expression that evalutes to the +// appropriate value type for returning from the +// function, given an expression of the original type. +//////////////////////////////////////////////////////////////////// +string ParameterRemapToWString:: +get_return_expr(const string &expression) { + return expression; +} + +//////////////////////////////////////////////////////////////////// +// Function: ParameterRemapToWString::new_type_is_atomic_string +// Access: Public, Virtual +// Description: Returns true if the type represented by the +// conversion is now the atomic string type. We have to +// have this crazy method for representing atomic +// string, because there's no such type in C (and hence +// no corresponding CPPType *). +//////////////////////////////////////////////////////////////////// +bool ParameterRemapToWString:: +new_type_is_atomic_string() { + return true; +} diff --git a/dtool/src/interrogate/parameterRemapToString.h b/dtool/src/interrogate/parameterRemapToString.h index ed272d0fd7..94982a0e42 100644 --- a/dtool/src/interrogate/parameterRemapToString.h +++ b/dtool/src/interrogate/parameterRemapToString.h @@ -43,4 +43,24 @@ public: virtual bool new_type_is_atomic_string(); }; +//////////////////////////////////////////////////////////////////// +// Class : ParameterRemapToWString +// Description : A base class for several different remapping types +// that convert to an atomic string class. +// +// The atomic string class is represented in the C +// interface as a (const wchar_t *). Other interfaces +// may be able to represent it differently, subverting +// the code defined here. +//////////////////////////////////////////////////////////////////// +class ParameterRemapToWString : public ParameterRemap { +public: + ParameterRemapToWString(CPPType *orig_type); + + virtual void pass_parameter(ostream &out, const string &variable_name); + virtual string get_return_expr(const string &expression); + + virtual bool new_type_is_atomic_string(); +}; + #endif diff --git a/dtool/src/interrogate/typeManager.cxx b/dtool/src/interrogate/typeManager.cxx index f62864eebd..e7a7b9491a 100644 --- a/dtool/src/interrogate/typeManager.cxx +++ b/dtool/src/interrogate/typeManager.cxx @@ -91,9 +91,9 @@ is_assignable(CPPType *type) { // don't get setters synthesized for them. If you want a setter, // write it yourself. - // We'll make an exception for basic_string, however, since - // this is nearly an atomic type. - if (is_basic_string_char(type)) { + // We'll make an exception for the string types, however, since + // these are nearly an atomic type. + if (is_basic_string_char(type) || is_basic_string_wchar(type)) { return true; } @@ -472,6 +472,84 @@ is_const_ref_to_basic_string_char(CPPType *type) { } } +//////////////////////////////////////////////////////////////////// +// Function: TypeManager::is_basic_string_wchar +// Access: Public, Static +// Description: Returns true if the type is basic_string. This +// is the standard C++ wide string class. +//////////////////////////////////////////////////////////////////// +bool TypeManager:: +is_basic_string_wchar(CPPType *type) { + CPPType *string_type = get_basic_string_wchar_type(); + if (string_type != (CPPType *)NULL && + string_type->get_local_name(&parser) == type->get_local_name(&parser)) { + return true; + } + + switch (type->get_subtype()) { + case CPPDeclaration::ST_const: + return is_basic_string_wchar(type->as_const_type()->_wrapped_around); + + default: + break; + } + + return false; +} + +//////////////////////////////////////////////////////////////////// +// Function: TypeManager::is_const_basic_string_wchar +// Access: Public, Static +// Description: Returns true if the indicated type is a const wrapper +// around basic_string. +//////////////////////////////////////////////////////////////////// +bool TypeManager:: +is_const_basic_string_wchar(CPPType *type) { + switch (type->get_subtype()) { + case CPPDeclaration::ST_const: + return is_basic_string_wchar(type->as_const_type()->_wrapped_around); + + default: + return false; + } +} + +//////////////////////////////////////////////////////////////////// +// Function: TypeManager::is_const_ref_to_basic_string_wchar +// Access: Public, Static +// Description: Returns true if the indicated type is a const +// reference to basic_string. +//////////////////////////////////////////////////////////////////// +bool TypeManager:: +is_const_ref_to_basic_string_wchar(CPPType *type) { + switch (type->get_subtype()) { + case CPPDeclaration::ST_reference: + return is_const_basic_string_wchar(type->as_reference_type()->_pointing_at); + + default: + return false; + } +} + +//////////////////////////////////////////////////////////////////// +// Function: TypeManager::is_wstring +// Access: Public, Static +// Description: Returns true if the type is basic_string, or +// a const reference to it. +//////////////////////////////////////////////////////////////////// +bool TypeManager:: +is_wstring(CPPType *type) { + switch (type->get_subtype()) { + case CPPDeclaration::ST_reference: + return is_const_basic_string_wchar(type->as_reference_type()->_pointing_at); + + default: + break; + } + + return is_basic_string_wchar(type); +} + //////////////////////////////////////////////////////////////////// // Function: TypeManager::is_bool // Access: Public, Static @@ -524,6 +602,7 @@ is_integer(CPPType *type) { return (simple_type->_type == CPPSimpleType::T_bool || simple_type->_type == CPPSimpleType::T_char || + simple_type->_type == CPPSimpleType::T_wchar_t || simple_type->_type == CPPSimpleType::T_int); } } @@ -555,6 +634,7 @@ is_unsigned_integer(CPPType *type) { return ((simple_type->_type == CPPSimpleType::T_bool || simple_type->_type == CPPSimpleType::T_char || + simple_type->_type == CPPSimpleType::T_wchar_t || simple_type->_type == CPPSimpleType::T_int) && (simple_type->_flags & CPPSimpleType::F_unsigned) != 0); } @@ -1217,6 +1297,23 @@ get_basic_string_char_type() { return type; } +//////////////////////////////////////////////////////////////////// +// Function: TypeManager::get_basic_string_wchar_type +// Access: Public, Static +// Description: Returns a CPPType that represents basic_string, +// or NULL if the type is unknown. +//////////////////////////////////////////////////////////////////// +CPPType *TypeManager:: +get_basic_string_wchar_type() { + static bool got_type = false; + static CPPType *type = (CPPType *)NULL; + if (!got_type) { + type = parser.parse_type("basic_string"); + got_type = true; + } + return type; +} + //////////////////////////////////////////////////////////////////// // Function: TypeManager::get_reference_count_type // Access: Public, Static diff --git a/dtool/src/interrogate/typeManager.h b/dtool/src/interrogate/typeManager.h index f58720f2ad..994253fa8b 100644 --- a/dtool/src/interrogate/typeManager.h +++ b/dtool/src/interrogate/typeManager.h @@ -68,6 +68,10 @@ public: static bool is_basic_string_char(CPPType *type); static bool is_const_basic_string_char(CPPType *type); static bool is_const_ref_to_basic_string_char(CPPType *type); + static bool is_basic_string_wchar(CPPType *type); + static bool is_const_basic_string_wchar(CPPType *type); + static bool is_const_ref_to_basic_string_wchar(CPPType *type); + static bool is_wstring(CPPType *type); static bool is_bool(CPPType *type); static bool is_integer(CPPType *type); static bool is_unsigned_integer(CPPType *type); @@ -101,6 +105,7 @@ public: static CPPType *wrap_const_reference(CPPType *type); static CPPType *get_basic_string_char_type(); + static CPPType *get_basic_string_wchar_type(); static CPPType *get_reference_count_type(); static CPPType *get_void_type(); static CPPType *get_int_type(); diff --git a/dtool/src/parser-inc/stdtypedefs.h b/dtool/src/parser-inc/stdtypedefs.h index b04c39e367..440b2b732e 100644 --- a/dtool/src/parser-inc/stdtypedefs.h +++ b/dtool/src/parser-inc/stdtypedefs.h @@ -35,7 +35,6 @@ namespace std { } #endif typedef int ptrdiff_t; -typedef int wchar_t; typedef unsigned int uint; typedef unsigned long ulong; diff --git a/panda/src/express/textEncoder.I b/panda/src/express/textEncoder.I index 77c53d36a7..30aa8ad847 100644 --- a/panda/src/express/textEncoder.I +++ b/panda/src/express/textEncoder.I @@ -473,7 +473,7 @@ lower(const string &source, TextEncoder::Encoding encoding) { //////////////////////////////////////////////////////////////////// // Function: TextEncoder::set_wtext -// Access: Public +// Access: Published // Description: Changes the text that is stored in the encoder. // Subsequent calls to get_wtext() will return this same // string, while get_text() will return the encoded @@ -489,7 +489,7 @@ set_wtext(const wstring &wtext) { //////////////////////////////////////////////////////////////////// // Function: TextEncoder::get_wtext -// Access: Public +// Access: Published // Description: Returns the text associated with the TextEncoder, as // a wide-character string. //////////////////////////////////////////////////////////////////// @@ -504,7 +504,7 @@ get_wtext() const { //////////////////////////////////////////////////////////////////// // Function: TextEncoder::append_wtext -// Access: Public +// Access: Published // Description: Appends the indicates string to the end of the stored // wide-character text. //////////////////////////////////////////////////////////////////// @@ -516,7 +516,7 @@ append_wtext(const wstring &wtext) { //////////////////////////////////////////////////////////////////// // Function: TextEncoder::encode_wtext -// Access: Public +// Access: Published // Description: Encodes a wide-text string into a single-char string, // according to the current encoding. //////////////////////////////////////////////////////////////////// @@ -527,7 +527,7 @@ encode_wtext(const wstring &wtext) const { //////////////////////////////////////////////////////////////////// // Function: TextEncoder::decode_text -// Access: Public +// Access: Published // Description: Returns the given wstring decoded to a single-byte // string, via the current encoding system. //////////////////////////////////////////////////////////////////// diff --git a/panda/src/express/textEncoder.cxx b/panda/src/express/textEncoder.cxx index 40ddbb1779..bbd2358ccb 100644 --- a/panda/src/express/textEncoder.cxx +++ b/panda/src/express/textEncoder.cxx @@ -62,7 +62,7 @@ make_lower() { //////////////////////////////////////////////////////////////////// // Function: TextEncoder::get_wtext_as_ascii -// Access: Public +// Access: Published // Description: Returns the text associated with the node, converted // as nearly as possible to a fully-ASCII // representation. This means replacing accented @@ -105,7 +105,7 @@ get_wtext_as_ascii() const { //////////////////////////////////////////////////////////////////// // Function: TextEncoder::encode_wchar -// Access: Public, Static +// Access: Published, Static // Description: Encodes a single wide char into a one-, two-, or // three-byte string, according to the given encoding // system. @@ -161,7 +161,7 @@ encode_wchar(wchar_t ch, TextEncoder::Encoding encoding) { //////////////////////////////////////////////////////////////////// // Function: TextEncoder::encode_wtext -// Access: Public, Static +// Access: Published, Static // Description: Encodes a wide-text string into a single-char string, // according to the given encoding. //////////////////////////////////////////////////////////////////// @@ -178,7 +178,7 @@ encode_wtext(const wstring &wtext, TextEncoder::Encoding encoding) { //////////////////////////////////////////////////////////////////// // Function: TextEncoder::decode_text -// Access: Public, Static +// Access: Published, Static // Description: Returns the given wstring decoded to a single-byte // string, via the given encoding system. //////////////////////////////////////////////////////////////////// diff --git a/panda/src/express/textEncoder.h b/panda/src/express/textEncoder.h index 25b54373fb..8ed7b054c0 100644 --- a/panda/src/express/textEncoder.h +++ b/panda/src/express/textEncoder.h @@ -87,9 +87,8 @@ PUBLISHED: INLINE static string lower(const string &source); INLINE static string lower(const string &source, Encoding encoding); -public: - // Direct support for wide-character strings. Not publishable for - // now (until we add support for wstring to interrogate). + // Direct support for wide-character strings. Now publishable with + // the new wstring support in interrogate. INLINE void set_wtext(const wstring &wtext); INLINE const wstring &get_wtext() const; INLINE void append_wtext(const wstring &text); diff --git a/panda/src/pgui/pgEntry.I b/panda/src/pgui/pgEntry.I index d49a399fee..5ad94b1591 100644 --- a/panda/src/pgui/pgEntry.I +++ b/panda/src/pgui/pgEntry.I @@ -425,7 +425,7 @@ get_erase_event() const { //////////////////////////////////////////////////////////////////// // Function: PGEntry::set_wtext -// Access: Public +// Access: Published // Description: Changes the text currently displayed within the // entry. //////////////////////////////////////////////////////////////////// @@ -439,7 +439,7 @@ set_wtext(const wstring &wtext) { //////////////////////////////////////////////////////////////////// // Function: PGEntry::get_wtext -// Access: Public +// Access: Published // Description: Returns the text currently displayed within the // entry. //////////////////////////////////////////////////////////////////// diff --git a/panda/src/pgui/pgEntry.h b/panda/src/pgui/pgEntry.h index 0a9d0dd445..3a83433586 100644 --- a/panda/src/pgui/pgEntry.h +++ b/panda/src/pgui/pgEntry.h @@ -120,7 +120,6 @@ PUBLISHED: INLINE string get_type_event() const; INLINE string get_erase_event() const; -public: INLINE void set_wtext(const wstring &wtext); INLINE const wstring &get_wtext() const; diff --git a/panda/src/text/textAssembler.h b/panda/src/text/textAssembler.h index 4963971712..aac909e8d3 100644 --- a/panda/src/text/textAssembler.h +++ b/panda/src/text/textAssembler.h @@ -19,7 +19,7 @@ #ifndef TEXTASSEMBLER_H #define TEXTASSEMBLER_H -#ifndef CPPPARSER // interrogate has a bit of trouble with wstring. +#ifndef CPPPARSER // interrogate has a bit of trouble with wstring iterators. #include "pandabase.h" diff --git a/panda/src/text/textFont.h b/panda/src/text/textFont.h index 6b404890e1..2765461b66 100644 --- a/panda/src/text/textFont.h +++ b/panda/src/text/textFont.h @@ -56,9 +56,6 @@ PUBLISHED: virtual void write(ostream &out, int indent_level) const; public: - wstring wordwrap_to(const wstring &text, float wordwrap_width, - bool preserve_trailing_whitespace); - virtual bool get_glyph(int character, const TextGlyph *&glyph)=0; protected: diff --git a/panda/src/text/textNode.I b/panda/src/text/textNode.I index b3641ef875..27b45a2ab2 100644 --- a/panda/src/text/textNode.I +++ b/panda/src/text/textNode.I @@ -1202,6 +1202,46 @@ calc_width(const string &line) const { return calc_width(decode_text(line)); } +//////////////////////////////////////////////////////////////////// +// Function: TextNode::set_wtext +// Access: Published +// Description: Changes the text that is displayed under the +// TextNode, with a wide text. This automatically sets +// the string reported by get_text() to the 8-bit +// encoded version of the same string. +//////////////////////////////////////////////////////////////////// +INLINE void TextNode:: +set_wtext(const wstring &wtext) { + TextEncoder::set_wtext(wtext); + invalidate_with_measure(); +} + +//////////////////////////////////////////////////////////////////// +// Function: TextNode::append_wtext +// Access: Published +// Description: Appends the indicates string to the end of the stored +// wide-character text. +//////////////////////////////////////////////////////////////////// +INLINE void TextNode:: +append_wtext(const wstring &wtext) { + TextEncoder::append_wtext(wtext); + invalidate_with_measure(); +} + +//////////////////////////////////////////////////////////////////// +// Function: TextNode::get_wordwrapped_wtext +// Access: Published +// Description: Returns a wstring that represents the contents of the +// text, as it has been formatted by wordwrap rules. +// This will not contain any embedded special characters +// like \1 or \3. +//////////////////////////////////////////////////////////////////// +INLINE wstring TextNode:: +get_wordwrapped_wtext() const { + check_measure(); + return _assembler.get_wordwrapped_wtext(); +} + //////////////////////////////////////////////////////////////////// // Function: TextNode::get_left // Access: Published @@ -1345,46 +1385,6 @@ force_update() { check_rebuild(); } -//////////////////////////////////////////////////////////////////// -// Function: TextNode::set_wtext -// Access: Public -// Description: Changes the text that is displayed under the -// TextNode, with a wide text. This automatically sets -// the string reported by get_text() to the 8-bit -// encoded version of the same string. -//////////////////////////////////////////////////////////////////// -INLINE void TextNode:: -set_wtext(const wstring &wtext) { - TextEncoder::set_wtext(wtext); - invalidate_with_measure(); -} - -//////////////////////////////////////////////////////////////////// -// Function: TextNode::append_wtext -// Access: Public -// Description: Appends the indicates string to the end of the stored -// wide-character text. -//////////////////////////////////////////////////////////////////// -INLINE void TextNode:: -append_wtext(const wstring &wtext) { - TextEncoder::append_wtext(wtext); - invalidate_with_measure(); -} - -//////////////////////////////////////////////////////////////////// -// Function: TextNode::get_wordwrapped_wtext -// Access: Public -// Description: Returns a wstring that represents the contents of the -// text, as it has been formatted by wordwrap rules. -// This will not contain any embedded special characters -// like \1 or \3. -//////////////////////////////////////////////////////////////////// -INLINE wstring TextNode:: -get_wordwrapped_wtext() const { - check_measure(); - return _assembler.get_wordwrapped_wtext(); -} - //////////////////////////////////////////////////////////////////// // Function: TextNode::invalidate_no_measure // Access: Private diff --git a/panda/src/text/textNode.cxx b/panda/src/text/textNode.cxx index bb4ce1457d..30d3dbc225 100644 --- a/panda/src/text/textNode.cxx +++ b/panda/src/text/textNode.cxx @@ -146,6 +146,26 @@ calc_width(int character) const { return _assembler.calc_width(character, *this); } +//////////////////////////////////////////////////////////////////// +// Function: TextNode::calc_width +// Access: Published +// Description: Returns the width of a line of text of arbitrary +// characters. The line should not include the newline +// character or any embedded control characters like \1 +// or \3. +//////////////////////////////////////////////////////////////////// +float TextNode:: +calc_width(const wstring &line) const { + float width = 0.0f; + + wstring::const_iterator si; + for (si = line.begin(); si != line.end(); ++si) { + width += calc_width(*si); + } + + return width; +} + //////////////////////////////////////////////////////////////////// // Function: TextNode::output // Access: Public, Virtual @@ -346,26 +366,6 @@ generate() { return root; } -//////////////////////////////////////////////////////////////////// -// Function: TextNode::calc_width -// Access: Public -// Description: Returns the width of a line of text of arbitrary -// characters. The line should not include the newline -// character or any embedded control characters like \1 -// or \3. -//////////////////////////////////////////////////////////////////// -float TextNode:: -calc_width(const wstring &line) const { - float width = 0.0f; - - wstring::const_iterator si; - for (si = line.begin(); si != line.end(); ++si) { - width += calc_width(*si); - } - - return width; -} - //////////////////////////////////////////////////////////////////// // Function: TextNode::get_unsafe_to_apply_attribs // Access: Public, Virtual diff --git a/panda/src/text/textNode.h b/panda/src/text/textNode.h index 045cc38588..9652e214ee 100644 --- a/panda/src/text/textNode.h +++ b/panda/src/text/textNode.h @@ -193,6 +193,13 @@ PUBLISHED: float calc_width(int character) const; INLINE float calc_width(const string &line) const; + // Direct support for wide-character strings. + INLINE void set_wtext(const wstring &wtext); + INLINE void append_wtext(const wstring &text); + + INLINE wstring get_wordwrapped_wtext() const; + float calc_width(const wstring &line) const; + virtual void output(ostream &out) const; virtual void write(ostream &out, int indent_level = 0) const; @@ -215,13 +222,6 @@ PUBLISHED: INLINE void force_update(); public: - // Direct support for wide-character strings. - INLINE void set_wtext(const wstring &wtext); - INLINE void append_wtext(const wstring &text); - - INLINE wstring get_wordwrapped_wtext() const; - float calc_width(const wstring &line) const; - // From parent class PandaNode virtual int get_unsafe_to_apply_attribs() const; virtual void apply_attribs_to_vertices(const AccumulatedAttribs &attribs,