The type system converter variable replacement was moved to a single method.

Such a method is safer than the previous that used only a regular
expression, because now it tries to build a meta type for the type
found in the user's custom code.

Reviewed by Luciano Wolf <luciano.wolf@openbossa.org>
Reviewed by Renato Araújo <renato.filho@openbossa.org>

2 files changed, 77 insertions, 30 deletions

diff --git a/generator/shibokengenerator.cpp b/generator/shibokengenerator.cpp
index ff7ad4b5b..5563f0510 100644
--- a/generator/shibokengenerator.cpp
+++ b/generator/shibokengenerator.cpp
@@ -48,7 +48,6 @@ QHash<QString, QString> ShibokenGenerator::m_formatUnits = QHash<QString, QStrin
 QHash<QString, QString> ShibokenGenerator::m_tpFuncs = QHash<QString, QString>();
 QStringList ShibokenGenerator::m_knownPythonTypes = QStringList();
 
-
 static QString resolveScopePrefix(const AbstractMetaClass* scope, const QString& value)
 {
     if (!scope)
@@ -77,6 +76,15 @@ ShibokenGenerator::ShibokenGenerator() : Generator()
         ShibokenGenerator::initKnownPythonTypes();
 
     m_metaTypeFromStringCache = AbstractMetaTypeCache();
+
+    m_typeSystemConvName[TypeSystemCheckFunction]         = "checkType";
+    m_typeSystemConvName[TypeSystemIsConvertibleFunction] = "isConvertible";
+    m_typeSystemConvName[TypeSystemToCppFunction]         = "toCpp";
+    m_typeSystemConvName[TypeSystemToPythonFunction]      = "toPython";
+    m_typeSystemConvRegEx[TypeSystemCheckFunction]         = QRegExp("%CHECKTYPE\\[([^\\[]*)\\]");
+    m_typeSystemConvRegEx[TypeSystemIsConvertibleFunction] = QRegExp("%ISCONVERTIBLE\\[([^\\[]*)\\]");
+    m_typeSystemConvRegEx[TypeSystemToCppFunction]         = QRegExp("%CONVERTTOCPP\\[([^\\[]*)\\]");
+    m_typeSystemConvRegEx[TypeSystemToPythonFunction]      = QRegExp("%CONVERTTOPYTHON\\[([^\\[]*)\\]");
 }
 
 ShibokenGenerator::~ShibokenGenerator()
@@ -1253,7 +1261,7 @@ void ShibokenGenerator::processCodeSnip(QString& code, const AbstractMetaClass*
     replaceConvertToCppTypeSystemVariable(code);
 
     // replace "isConvertible" check
-    replaceConvertibleToCppTypeSystemVariable(code);
+    replaceIsConvertibleToCppTypeSystemVariable(code);
 
     // replace "checkType" check
     replaceTypeCheckTypeSystemVariable(code);
@@ -1508,28 +1516,44 @@ void ShibokenGenerator::writeCodeSnips(QTextStream& s,
     s << INDENT << "// End of code injection" << endl;
 }
 
-void ShibokenGenerator::replaceConvertToPythonTypeSystemVariable(QString& code)
-{
-    static QRegExp toPythonRegex("%CONVERTTOPYTHON\\[([^\\[]*)\\]");
-    code.replace(toPythonRegex, "Shiboken::Converter<\\1 >::toPython");
-}
-
-void ShibokenGenerator::replaceConvertToCppTypeSystemVariable(QString& code)
-{
-    static QRegExp toCppRegex("%CONVERTTOCPP\\[([^\\[]*)\\]");
-    code.replace(toCppRegex, "Shiboken::Converter<\\1 >::toCpp");
-}
-
-void ShibokenGenerator::replaceConvertibleToCppTypeSystemVariable(QString& code)
-{
-    static QRegExp isConvertibleRegex("%ISCONVERTIBLE\\[([^\\[]*)\\]");
-    code.replace(isConvertibleRegex, "Shiboken::Converter<\\1 >::isConvertible");
-}
-
-void ShibokenGenerator::replaceTypeCheckTypeSystemVariable(QString& code)
+typedef QPair<QString, QString> StringPair;
+void ShibokenGenerator::replaceConverterTypeSystemVariable(TypeSystemConverterVariable converterVariable, QString& code)
 {
-    static QRegExp checkTypeRegex("%CHECKTYPE\\[([^\\[]*)\\]");
-    code.replace(checkTypeRegex, "Shiboken::Converter<\\1 >::checkType");
+    QRegExp& regex = m_typeSystemConvRegEx[converterVariable];
+    const QString& conversionName = m_typeSystemConvName[converterVariable];
+    int pos = 0;
+    QList<StringPair> replacements;
+    while ((pos = regex.indexIn(code, pos)) != -1) {
+        pos += regex.matchedLength();
+        QStringList list = regex.capturedTexts();
+        QString conversionVar = list.first();
+        QString conversionTypeName = list.last();
+        const AbstractMetaType* conversionType = buildAbstractMetaTypeFromString(conversionTypeName);
+        QString conversion;
+        if (conversionType) {
+            switch (converterVariable) {
+                case TypeSystemCheckFunction:
+                    conversion = cpythonCheckFunction(conversionType);
+                    break;
+                case TypeSystemIsConvertibleFunction:
+                    conversion = cpythonIsConvertibleFunction(conversionType);
+                    break;
+                case TypeSystemToCppFunction:
+                    conversion = cpythonToCppConversionFunction(conversionType);
+                    break;
+                case TypeSystemToPythonFunction:
+                    conversion = cpythonToPythonConversionFunction(conversionType);
+                    break;
+                default:
+                    Q_ASSERT(false);
+            }
+        } else {
+            conversion = QString("Shiboken::Converter< %1 >::%2").arg(conversionTypeName).arg(conversionName);
+        }
+        replacements.append(qMakePair(conversionVar, conversion));
+    }
+    foreach (StringPair rep, replacements)
+        code.replace(rep.first, rep.second);
 }
 
 bool ShibokenGenerator::injectedCodeUsesCppSelf(const AbstractMetaFunction* func)
diff --git a/generator/shibokengenerator.h b/generator/shibokengenerator.h
index 6890e9203..b6d336f05 100644
--- a/generator/shibokengenerator.h
+++ b/generator/shibokengenerator.h
@@ -142,16 +142,25 @@ public:
     void processCodeSnip(QString& code, const AbstractMetaClass* context = 0);
 
     /// Replaces the %CONVERTTOPYTHON type system variable.
-    void replaceConvertToPythonTypeSystemVariable(QString& code);
-
+    inline void replaceConvertToPythonTypeSystemVariable(QString& code)
+    {
+        replaceConverterTypeSystemVariable(TypeSystemToPythonFunction, code);
+    }
     /// Replaces the %CONVERTTOCPP type system variable.
-    void replaceConvertToCppTypeSystemVariable(QString& code);
-
+    inline void replaceConvertToCppTypeSystemVariable(QString& code)
+    {
+        replaceConverterTypeSystemVariable(TypeSystemToCppFunction, code);
+    }
     /// Replaces the %ISCONVERTIBLE type system variable.
-    void replaceConvertibleToCppTypeSystemVariable(QString& code);
-
+    inline void replaceIsConvertibleToCppTypeSystemVariable(QString& code)
+    {
+        replaceConverterTypeSystemVariable(TypeSystemIsConvertibleFunction, code);
+    }
     /// Replaces the %CHECKTYPE type system variable.
-    void replaceTypeCheckTypeSystemVariable(QString& code);
+    inline void replaceTypeCheckTypeSystemVariable(QString& code)
+    {
+        replaceConverterTypeSystemVariable(TypeSystemCheckFunction, code);
+    }
 
     /**
      *   Verifies if any of the function's code injections of the "target"
@@ -443,6 +452,16 @@ protected:
     static bool pythonFunctionWrapperUsesListOfArguments(const OverloadData& overloadData);
 
     Indentor INDENT;
+
+    enum TypeSystemConverterVariable {
+        TypeSystemCheckFunction = 0,
+        TypeSystemIsConvertibleFunction,
+        TypeSystemToCppFunction,
+        TypeSystemToPythonFunction,
+        TypeSystemConverterVariables
+    };
+    void replaceConverterTypeSystemVariable(TypeSystemConverterVariable converterVariable, QString& code);
+
 private:
     bool m_useCtorHeuristic;
     bool m_userReturnValueHeuristic;
@@ -453,6 +472,10 @@ private:
 
     typedef QHash<QString, AbstractMetaType*> AbstractMetaTypeCache;
     AbstractMetaTypeCache m_metaTypeFromStringCache;
+
+    /// Type system converter variable replacement names and regular expressions.
+    QString m_typeSystemConvName[TypeSystemConverterVariables];
+    QRegExp m_typeSystemConvRegEx[TypeSystemConverterVariables];
 };
 
 #endif // SHIBOKENGENERATOR_H