Fix patching of enums in default arguments for C++03

Given the following code

    namespace ns
    {
        enum color {red, green, blue};
        void test( color arg=blue );
    }

CastXML produces a fully qualified name for the default argument -
`::ns::color::blue`.

While this default argument string is valid for C++11 and later, and
indeed required if `color` were a scoped enumeration, the default
argument is invalid for C++03 code.

Prior to C++11, enumerator names were added to the enclosing scope, so
they could not be qualified using the enum-name. Hence, for C++03, the
default argument needs to be patched to say `::ns::blue`.

Change-Id: I72c5d4fc53c5b5dc6f5fa38d10cb5484ba3bf85a

Cherry-picked from the develop branch

Author: praetorian20

pygccxml/parser/patcher.py

@@ -10,9 +10,10 @@
 
 class default_argument_patcher_t(object):
 
-    def __init__(self, enums):
+    def __init__(self, enums, cxx_std):
         object.__init__(self)
         self.__enums = enums
+        self.__cxx_std = cxx_std
 
     def __call__(self, decl):
         for arg in decl.arguments:
@@ -54,8 +55,12 @@ def __is_unqualified_enum(self, func, arg):
     def __fix_unqualified_enum(self, func, arg):
         type_ = declarations.remove_reference(declarations.remove_cv(arg.type))
         enum_type = declarations.enum_declaration(type_)
+        if self.__cxx_std.is_cxx11_or_greater:
+            qualifier_decl_string = enum_type.decl_string
+        else:
+            qualifier_decl_string = enum_type.parent.decl_string
         return self.__join_names(
-            enum_type.parent.decl_string,
+            qualifier_decl_string,
             arg.default_value.split('::')[-1])
 
     def __is_invalid_integral(self, func, arg):
@@ -92,19 +97,25 @@ def __fix_invalid_integral(self, func, arg):
             pass
 
         # may be we deal with enum
+        # CastXML qualifies the enum value with enum type, so split the
+        # argument and use only the enum value
+        enum_value = arg.default_value.split('::')[-1]
         parent = func.parent
         while parent:
-            found = self.__find_enum(parent, arg.default_value)
+            found = self.__find_enum(parent, enum_value)
             if found:
                 if declarations.is_fundamental(arg.type) and ' ' in \
                         arg.type.decl_string:
                     template = '(%s)(%s)'
                 else:
                     template = '%s(%s)'
+                if self.__cxx_std.is_cxx11_or_greater:
+                    qualifier_decl_string = found.decl_string
+                else:
+                    qualifier_decl_string = found.parent.decl_string
                 return template % (arg.type.decl_string,
-                                   self.__join_names(
-                                       found.parent.decl_string,
-                                       arg.default_value))
+                                   self.__join_names(qualifier_decl_string,
+                                                     enum_value))
             else:
                 parent = parent.parent
 
@@ -132,7 +143,7 @@ def __fix_invalid_integral(self, func, arg):
 
     def __find_enum(self, scope, default_value):
         # this algorithm could be improved: it could take into account
-        # 1. unnamed namespaced
+        # 1. unnamed namespace
         # 2. location within files
 
         for enum in self.__enums:
@@ -221,8 +232,8 @@ def __call__(self, decl):
 _casting_oper_patcher_ = casting_operator_patcher_t()
 
 
-def fix_calldef_decls(decls, enums):
-    default_arg_patcher = default_argument_patcher_t(enums)
+def fix_calldef_decls(decls, enums, cxx_std):
+    default_arg_patcher = default_argument_patcher_t(enums, cxx_std)
     # decls should be flat list of all declarations, you want to apply patch on
     for decl in decls:
         default_arg_patcher(decl)

pygccxml/parser/source_reader.py

@@ -93,6 +93,7 @@ def __init__(self, config, cache=None, decl_factory=None, join_decls=True):
         self.__join_decls = join_decls
         self.__search_directories = []
         self.__config = config
+        self.__cxx_std = utils.cxx_standard(config.cflags)
         self.__search_directories.append(config.working_directory)
         self.__search_directories.extend(config.include_paths)
         if not cache:
@@ -163,30 +164,12 @@ def __create_command_line_castxml(self, source_file, xmlfile):
             # On mac or linux, use gcc or clang (the flag is the same)
             cmd.append('--castxml-cc-gnu ')
 
-            # Check for -std=xx flags passed to the compiler.
-            # A regex could be used but this is a moving target.
-            # See c++1z for example. It is preferable to have a defined
-            # list of what is allowed. http://clang.llvm.org/cxx_status.html
-            #
-            # Version 98 and 03 are only there in the case somebody is using
-            # these flags; this is the equivalent to not passing these flags.
-            standards = [
-                "-std=c++98",
-                "-std=c++03",
-                "-std=c++11",
-                "-std=c++14",
-                "-std=c++1z"]
-
-            std_flag = ""
-            for standard in standards:
-                if standard in self.__config.cflags:
-                    std_flag = " " + standard + " "
-
-            # A -std= flag was passed, but is not in the list
-            if "-std=" in self.__config.cflags and std_flag == "":
-                raise(RuntimeError("Unknown -std=c++xx flag used !"))
-
-            if std_flag != "":
+            if self.__cxx_std.is_implicit:
+                std_flag = ''
+            else:
+                std_flag = ' ' + self.__cxx_std.stdcxx + ' '
+
+            if std_flag:
                 cmd.append(
                     '"(" ' + self.__config.compiler_path + std_flag + '")"')
             else:
@@ -502,7 +485,8 @@ def __parse_xml_file(self, xml_file):
         # void ddd(){ typedef typename X::Y YY;}
         # if I will fail on this bug next time, the right way to fix it may be
         # different
-        patcher.fix_calldef_decls(scanner_.calldefs(), scanner_.enums())
+        patcher.fix_calldef_decls(scanner_.calldefs(), scanner_.enums(),
+                                  self.__cxx_std)
         decls = [
             inst for inst in iter(
                 decls.values()) if isinstance(

pygccxml/utils/__init__.py

@@ -17,6 +17,7 @@
 from .utils import normalize_path
 from .utils import find_xml_generator
 from .utils import get_tr1
+from .utils import cxx_standard
 
 # Version of xml generator which was used.
 xml_generator = None

pygccxml/utils/utils.py

@@ -352,3 +352,94 @@ def get_tr1(name):
     if "tr1" in name:
         tr1 = "tr1::"
     return tr1
+
+
+class cxx_standard(object):
+    """Helper class for parsing the C++ standard version.
+
+    This class holds the C++ standard version the XML generator has been
+    configured with, and provides helpers functions for querying C++ standard
+    version related information.
+    """
+
+    __STD_CXX = {
+        '-std=c++98': 199711,
+        '-std=gnu++98': 199711,
+        '-std=c++03': 199711,
+        '-std=gnu++03': 199711,
+        '-std=c++0x': 201103,
+        '-std=gnu++0x': 201103,
+        '-std=c++11': 201103,
+        '-std=gnu++11': 201103,
+        '-std=c++1y': 201402,
+        '-std=gnu++1y': 201402,
+        '-std=c++14': 201402,
+        '-std=gnu++14': 201402,
+        '-std=c++1z': float('inf'),
+        '-std=gnu++1z': float('inf'),
+    }
+
+    def __init__(self, cflags):
+        """Class constructor that parses the XML generator's command line
+
+        Args:
+            cflags (str): cflags command line arguments passed to the XML
+                generator
+        """
+        super(cxx_standard, self).__init__()
+
+        self._stdcxx = None
+        self._is_implicit = False
+        for key in cxx_standard.__STD_CXX:
+            if key in cflags:
+                self._stdcxx = key
+                self._cplusplus = cxx_standard.__STD_CXX[key]
+
+        if not self._stdcxx:
+            if '-std=' in cflags:
+                raise RuntimeError('Unknown -std=c++xx flag used')
+
+            # Assume c++03 by default
+            self._stdcxx = '-std=c++03'
+            self._cplusplus = cxx_standard.__STD_CXX['-std=c++03']
+            self._is_implicit = True
+
+    @property
+    def stdcxx(self):
+        """Returns the -std=c++xx option passed to the constructor"""
+        return self._stdcxx
+
+    @property
+    def is_implicit(self):
+        """Indicates whether a -std=c++xx was specified"""
+        return self._is_implicit
+
+    @property
+    def is_cxx03(self):
+        """Returns true if -std=c++03 is being used"""
+        return self._cplusplus == cxx_standard.__STD_CXX['-std=c++03']
+
+    @property
+    def is_cxx11(self):
+        """Returns true if -std=c++11 is being used"""
+        return self._cplusplus == cxx_standard.__STD_CXX['-std=c++11']
+
+    @property
+    def is_cxx11_or_greater(self):
+        """Returns true if -std=c++11 or a newer standard is being used"""
+        return self._cplusplus >= cxx_standard.__STD_CXX['-std=c++11']
+
+    @property
+    def is_cxx14(self):
+        """Returns true if -std=c++14 is being used"""
+        return self._cplusplus == cxx_standard.__STD_CXX['-std=c++14']
+
+    @property
+    def is_cxx14_or_greater(self):
+        """Returns true if -std=c++14 or a newer standard is being used"""
+        return self._cplusplus >= cxx_standard.__STD_CXX['-std=c++14']
+
+    @property
+    def is_cxx1z(self):
+        """Returns true if -std=c++1z is being used"""
+        return self._cplusplus == cxx_standard.__STD_CXX['-std=c++1z']

unittests/data/patcher.hpp

@@ -25,6 +25,22 @@ void fix_enum3( fruit arg=orange );
 
 }
 
+#if __cplusplus >= 201103L
+namespace ns4{
+
+enum class color {red, green, blue};
+void fix_enum4( color arg=color::blue );
+
+}
+
+namespace ns5{
+
+using namespace ns4;
+void fix_enum5( color arg=color::blue );
+
+}
+#endif
+
 typedef unsigned long long ull;
 void fix_numeric( ull arg=(ull)-1 );
 
@@ -76,6 +92,13 @@ static int const DEFAULT_1 = 20;
 int fun2( int arg1=DEFAULT_1, int arg2=ns1::DEFAULT_1, long arg3=::ns1::st1::DEFAULT_2 );
 
 
+enum ACE_Log_Priority_Index
+{
+  LM_INVALID_BIT_INDEX = 32
+};
+static int log_priority_enabled(long priority_index = LM_INVALID_BIT_INDEX);
+
+
 /*struct default_arg_t{};*/
 /*default_arg_t create_default_argument();*/
 /*void double_call( default_arg_t x=create_default_argument() );*/

unittests/patcher_tester.py

@@ -19,29 +19,50 @@ def __init__(self, architecture, *args):
         parser_test_case.parser_test_case_t.__init__(self, *args)
         self.architecture = architecture
         self.global_ns = None
+        self.__cxx_std = utils.cxx_standard(self.config.cflags)
 
     def test_enum_patcher(self):
         fix_enum = self.global_ns.free_fun("fix_enum")
         default_val = fix_enum.arguments[0].default_value
-        self.assertEqual(default_val, "::ns1::ns2::apple")
+        if self.__cxx_std.is_cxx11_or_greater:
+            val = "::ns1::ns2::fruit::apple"
+        else:
+            val = "::ns1::ns2::apple"
+        self.assertEqual(default_val, val)
 
         if 32 == self.architecture or "CastXML" in utils.xml_generator:
             fix_enum2 = self.global_ns.free_fun("fix_enum2")
             default_val = fix_enum2.arguments[0].default_value
-            self.assertEqual(default_val, "::ns1::ns2::apple")
+            self.assertEqual(default_val, val)
 
             ns1 = self.global_ns.namespace("ns1")
             ns2 = ns1.namespace("ns2")
             fix_enum2 = ns2.free_fun("fix_enum2")
             default_val = fix_enum2.arguments[0].default_value
-            self.assertEqual(default_val, "::ns1::ns2::apple")
+            self.assertEqual(default_val, val)
 
             fix_enum3 = self.global_ns.free_fun("fix_enum3")
             default_val = fix_enum3.arguments[0].default_value
-            self.assertEqual(default_val, "::ns1::ns2::orange")
+            val = val.replace("apple", "orange")
+            self.assertEqual(default_val, val)
+
+            if self.__cxx_std.is_cxx11_or_greater:
+                fix_enum4 = self.global_ns.free_fun("fix_enum4")
+                default_val = fix_enum4.arguments[0].default_value
+                self.assertEqual(default_val, "::ns4::color::blue")
+
+                fix_enum5 = self.global_ns.free_fun("fix_enum5")
+                default_val = fix_enum5.arguments[0].default_value
+                self.assertEqual(default_val, "::ns4::color::blue")
 
-        # double_call = declarations.find_declaration(
-        # decls, type=declarations.free_function_t, name='double_call' )
+            lpe = self.global_ns.free_fun("log_priority_enabled")
+            default_val = lpe.arguments[0].default_value
+            if self.__cxx_std.is_cxx11_or_greater:
+                val = "(long int)" + \
+                    "(::ACE_Log_Priority_Index::LM_INVALID_BIT_INDEX)"
+            else:
+                val = "(long int)(::LM_INVALID_BIT_INDEX)"
+            self.assertEqual(default_val, val)
 
     def test_numeric_patcher(self):
         fix_numeric = self.global_ns.free_function("fix_numeric")
@@ -126,13 +147,8 @@ def test_unqualified_integral_patcher(self):
 
     def test_unnamed_enum_patcher(self):
         fix_unnamed = self.global_ns.free_fun("fix_unnamed")
-        if ("CastXML" in utils.xml_generator and
-                utils.xml_output_version >= 1.137):
-            val = "fx::unnamed"
-        else:
-            val = "int(::fx::unnamed)"
         self.assertEqual(
-            fix_unnamed.arguments[0].default_value, val)
+            fix_unnamed.arguments[0].default_value, "int(::fx::unnamed)")
 
     def test_function_call_patcher(self):
         fix_function_call = self.global_ns.free_fun("fix_function_call")
@@ -150,9 +166,8 @@ def test_function_call_patcher(self):
 
     def test_fundamental_patcher(self):
         fcall = self.global_ns.free_fun("fix_fundamental")
-        if ("CastXML" in utils.xml_generator and
-                utils.xml_output_version >= 1.137):
-            val = "fundamental::spam::eggs"
+        if self.__cxx_std.is_cxx11_or_greater:
+            val = "(unsigned int)(::fundamental::spam::eggs)"
         else:
             val = "(unsigned int)(::fundamental::eggs)"
         self.assertEqual(
@@ -163,14 +178,12 @@ def test_constructor_patcher(self):
         default_val = typedef__func.arguments[0].default_value
         if "0.9" in utils.xml_generator:
             val = "typedef_::original_name()"
-            self.assertEqual(default_val, val)
         elif "CastXML" in utils.xml_generator:
             # Most clean output, no need to patch
             val = "typedef_::alias()"
-            self.assertEqual(default_val, val)
         else:
             val = "::typedef_::alias( )"
-            self.assertEqual(default_val, val)
+        self.assertEqual(default_val, val)
         if 32 == self.architecture:
             clone_tree = self.global_ns.free_fun("clone_tree")
             default_values = []