use CmakeLists scope to generate te XML file

- the only difference really is, that scope (the configuration.cmake) is already passed
  to px_process_params via the argument --scope. The Paths in --scope are evaluated w.r.t
  the path to src provided via the -s /--src-path argument.
- if no --scope is proveided. the Old scheme by simply walking the full --src-path directory
  is applied

Tools/px4params/__init__.py

@@ -1 +1 @@
-__all__ = ["srcscanner", "srcparser", "xmlout", "dokuwikiout", "dokuwikirpc"]
+__all__ = ["srcscanner", "srcparser", "xmlout", "dokuwikiout", "dokuwikirpc", "cmakeparser", "scope"]

Tools/px4params/cmakeparser.py

@@ -0,0 +1,37 @@
+import re
+import codecs
+import sys
+
+class CMakeParser(object):
+    """
+    Parses provided data and stores all found paths in scope.
+    """
+    re_split_lines = re.compile(r'[\r\n]+')
+    re_comment = re.compile(r'^\#')
+    re_start = re.compile(r'set\s*\(\s*config_module_list')
+    re_end = re.compile(r'\)\s*')
+
+    def Parse(self, scope, contents):
+        """
+        Incrementally parse cmake file contents and append all found path scope
+        to scope.
+        """
+        # This code is essentially a comment-parsing grammar. "state"
+        # represents parser state. It contains human-readable state
+        # names.
+        state = None
+        for line in self.re_split_lines.split(contents):
+            line = line.strip()
+            # Ignore empty lines
+            if line == "":
+                continue
+            if self.re_comment.match(line):
+                continue
+            elif self.re_start.match(line):
+                state = "gather"
+                continue
+            elif state is not None and state == "gather":
+                if self.re_end.match(line):
+                    return True
+                scope.Add(line)
+        return False

Tools/px4params/scope.py

@@ -0,0 +1,32 @@
+import os
+import re
+
+class Scope(object):
+    """
+    Single parameter group
+    """
+    re_deep_lines = re.compile(r'.*\/.*\/')
+    def __init__(self,):
+        self.scope = set()
+
+
+    def __str__(self):
+        return self.scope.__str__()
+
+    def Add(self, scope):
+        """
+        Add Scope to set
+        """
+        self.scope.add(scope)
+
+    def Has(self, scope):
+        """
+        Check for existance
+        """
+        if len(self.scope) == 0:
+            return True
+        # Anything in the form xxxxx/yyyyy/zzzzz....
+        # is treated as xxxxx/yyyyy
+        while (self.re_deep_lines.match(scope)):
+            scope = os.path.dirname(scope)
+        return scope in self.scope

Tools/px4params/srcscanner.py

@@ -1,6 +1,7 @@
 import os
 import re
 import codecs
+import sys
 
 class SourceScanner(object):
     """
@@ -8,24 +9,25 @@ class SourceScanner(object):
     to the Parser.
     """
 
-    def ScanDir(self, srcdir, parser):
+    def ScanDir(self, srcdirs, parser):
         """
         Scans provided path and passes all found contents to the parser using
         parser.Parse method.
         """
         extensions1 = tuple([".h"])
         extensions2 = tuple([".cpp", ".c"])
-        for dirname, dirnames, filenames in os.walk(srcdir):
-            for filename in filenames:
-                if filename.endswith(extensions1):
-                    path = os.path.join(dirname, filename)
-                    if not self.ScanFile(path, parser):
-                        return False
-            for filename in filenames:
-                if filename.endswith(extensions2):
-                    path = os.path.join(dirname, filename)
-                    if not self.ScanFile(path, parser):
-                        return False
+        for srcdir in srcdirs:
+            for dirname, dirnames, filenames in os.walk(srcdir):
+                for filename in filenames:
+                    if filename.endswith(extensions1):
+                        path = os.path.join(dirname, filename)
+                        if not self.ScanFile(path, parser):
+                            return False
+                for filename in filenames:
+                    if filename.endswith(extensions2):
+                        path = os.path.join(dirname, filename)
+                        if not self.ScanFile(path, parser):
+                            return False
         return True
 
     def ScanFile(self, path, parser):