TheCloud/panda3d
1
0
Fork 0
mirror of https://github.com/panda3d/panda3d.git synced 2025-10-03 10:22:45 -04:00
Code Issues Packages Projects Releases Wiki Activity

operator bool () -> __nonzero__()

Browse Source
This commit is contained in:
David Rose 2009-01-20 03:17:44 +00:00
parent 0811991a8a
commit a6f4fb2377
6 changed files with 63 additions and 10 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

12
dtool/src/cppparser/cppBison.yxx
View File

@ -857,15 +857,15 @@ function_prototype:
// As an added bonus, the type of the formal_parameter will be the
// typecast type, i.e. the return type of the typecast function.
// We give all typecast operators the name "operator typecast".
// Only their return type will differentiate them. (Naturally, this
// violates actual C++ rules, but we're not an actual C++ compiler
// so we don't care. And this is the easiest way to do it.)
// We give typecast operators the name "operator typecast <name>",
// where <name> is a simple name of the type to be typecast. Use
// the method's return type to determine the full type description.
string name = "operator typecast " + $2->get_simple_name();
CPPIdentifier *ident = $1;
if (ident == NULL) {
ident = new CPPIdentifier("operator typecast", @1.file);
ident = new CPPIdentifier(name, @1.file);
} else {
ident->add_name("operator typecast");
ident->add_name(name);
}
$$ = CPPInstance::make_typecast_function
(new CPPInstance($2, $3, 0, @3.file), ident, $6, $8);

40
dtool/src/interrogate/interfaceMakerPythonNative.cxx
View File

@ -98,6 +98,7 @@ RenameSet methodRenameDictionary[] = {
{ "operator ->" , "dereference", 0 },
{ "operator <<=" , "__ilshift__", 1 },
{ "operator >>=" , "__irshift__", 1 },
{ "operator typecast bool" , "__nonzero__", 0 },
{ "print" , "Cprint", 0 },
{ "CInterval.set_t" , "_priv__cSetT", 0 },
{ NULL, NULL, -1 }
@ -214,7 +215,7 @@ std::string classNameFromCppName(const std::string &cppName)
if (badChars.find(*chr) != std::string::npos)
{
}
else if (*chr == '_')
else if (*chr == '_' || *chr == ' ')
{
nextCap = 1;
}
@ -271,14 +272,14 @@ std::string nonClassNameFromCppName(const std::string &cppName_in)
///////////////////////////////////////////////////////////////////////////////////////
std::string methodNameFromCppName(const std::string &cppName, const std::string &className) {
std::string methodName;
std::string badChars(" ");
const std::string badChars("!@#$%^&*()<>,.-=+~{}?");
int nextCap = 0;
for(std::string::const_iterator chr = cppName.begin(); chr != cppName.end(); chr++)
{
if (badChars.find(*chr) != std::string::npos)
{
}
else if (*chr == '_')
else if (*chr == '_' || *chr == ' ')
{
nextCap = 1;
}
@ -559,6 +560,16 @@ get_slotted_function_def(Object *obj, Function *func, SlottedFunctionDef &def) {
return true;
}
if (func->_ifunc.is_operator_typecast()) {
// A typecast operator. If it's a bool type, then we wrap it with
// the __nonzero__ slot method.
if (!func->_remaps.empty() && TypeManager::is_bool(func->_remaps[0]->_return_type->get_orig_type())) {
def._answer_location = "tp_as_number->nb_nonzero";
def._wrapper_type = WT_inquiry;
return true;
}
}
return false;
}
@ -1443,6 +1454,29 @@ write_module_class(ostream &out, Object *obj) {
}
break;
case WT_inquiry:
// int func(PyObject *self)
{
Function *func = rfi->first;
out << "//////////////////\n";
out << "// A wrapper function to satisfy Python's internal calling conventions. \n";
out << "// " <<ClassName<< " ..." << rfi->second._answer_location <<" = "<< methodNameFromCppName(func,export_calss_name) <<"\n";
out << "//////////////////\n";
out << "static int " << func->_name << methodNameFromCppName(func,export_calss_name) << "(PyObject *self)\n";
out << "{\n";
out << " PyObject *args = Py_BuildValue(\"()\");\n";
out << " PyObject *result = " << func->_name <<"(self, args, NULL);\n";
out << " Py_DECREF(args);\n";
out << " if (result == NULL) {\n";
out << " return -1;\n";
out << " }\n";
out << " int iresult = PyInt_AsLong(result);\n";
out << " Py_DECREF(result);\n";
out << " return iresult;\n";
out << "}\n\n";
}
break;
case WT_none:
break;
}

1
dtool/src/interrogate/interfaceMakerPythonNative.h
View File

@ -73,6 +73,7 @@ private:
WT_sequence_setitem,
WT_sequence_size,
WT_mapping_setitem,
WT_inquiry,
};
class SlottedFunctionDef {

5
dtool/src/interrogate/interrogateBuilder.cxx
View File

@ -1685,6 +1685,11 @@ get_function(CPPInstance *function, string description,
ifunction->_flags |= InterrogateFunction::F_unary_op;
}
if (ftype->_flags & CPPFunctionType::F_operator_typecast) {
// This is a special typecast operator.
ifunction->_flags |= InterrogateFunction::F_operator_typecast;
}
ifunction->_flags |= flags;
ifunction->_instances->insert(InterrogateFunction::Instances::value_type(function_signature, function));
ifunction->_expression = expression;

11
dtool/src/interrogatedb/interrogateFunction.I
View File

@ -57,6 +57,17 @@ is_unary_op() const {
return (_flags & F_unary_op) != 0;
}
////////////////////////////////////////////////////////////////////
// Function: InterrogateFunction::is_operator_typecast
// Access: Public
// Description: Returns true if the function is a special typecast
// operator, like operator bool().
////////////////////////////////////////////////////////////////////
INLINE bool InterrogateFunction::
is_operator_typecast() const {
return (_flags & F_operator_typecast) != 0;
}
////////////////////////////////////////////////////////////////////
// Function: InterrogateFunction::get_class
// Access: Public

2
dtool/src/interrogatedb/interrogateFunction.h
View File

@ -39,6 +39,7 @@ public:
INLINE bool is_virtual() const;
INLINE bool is_method() const;
INLINE bool is_unary_op() const;
INLINE bool is_operator_typecast() const;
INLINE TypeIndex get_class() const;
INLINE bool has_scoped_name() const;
@ -70,6 +71,7 @@ private:
F_getter = 0x0010,
F_setter = 0x0020,
F_unary_op = 0x0040,
F_operator_typecast = 0x0080,
};
int _flags;