bpo-36876: Re-organize the c-analyzer tool code. (gh-16841)

This is partly a cleanup of the code. It also is preparation for getting the variables from the source (cross-platform) rather than from the symbols.

The change only touches the tool (and its tests).

20 files changed, 345 insertions, 472 deletions

diff --git a/Lib/test/test_check_c_globals.py b/Lib/test/test_check_c_globals.py
index a3925f0..030debc 100644
--- a/Lib/test/test_check_c_globals.py
+++ b/Lib/test/test_check_c_globals.py
@@ -3,7 +3,7 @@ import test.test_tools
 
 test.test_tools.skip_if_missing('c-analyzer')
 with test.test_tools.imports_under_tool('c-analyzer'):
-    from c_globals.__main__ import main
+    from cpython.__main__ import main
 
 
 class ActualChecks(unittest.TestCase):
diff --git a/Lib/test/test_tools/test_c_analyzer/test_c_analyzer_common/test_known.py b/Lib/test/test_tools/test_c_analyzer/test_c_analyzer_common/test_known.py
deleted file mode 100644
index 215023d..0000000
--- a/Lib/test/test_tools/test_c_analyzer/test_c_analyzer_common/test_known.py
+++ /dev/null
@@ -1,68 +0,0 @@
-import re
-import textwrap
-import unittest
-
-from .. import tool_imports_for_tests
-with tool_imports_for_tests():
-    from c_parser.info import Variable
-    from c_analyzer_common.info import ID
-    from c_analyzer_common.known import from_file
-
-
-class FromFileTests(unittest.TestCase):
-
-    maxDiff = None
-
-    _return_read_tsv = ()
-
-    @property
-    def calls(self):
-        try:
-            return self._calls
-        except AttributeError:
-            self._calls = []
-            return self._calls
-
-    def _read_tsv(self, *args):
-        self.calls.append(('_read_tsv', args))
-        return self._return_read_tsv
-
-    def test_typical(self):
-        lines = textwrap.dedent('''
-            filename    funcname        name    kind    declaration
-            file1.c     -       var1    variable        static int
-            file1.c     func1   local1  variable        static int
-            file1.c     -       var2    variable        int
-            file1.c     func2   local2  variable        char *
-            file2.c     -       var1    variable        char *
-            ''').strip().splitlines()
-        lines = [re.sub(r'\s+', '\t', line, 4) for line in lines]
-        self._return_read_tsv = [tuple(v.strip() for v in line.split('\t'))
-                                 for line in lines[1:]]
-
-        known = from_file('spam.c', _read_tsv=self._read_tsv)
-
-        self.assertEqual(known, {
-            'variables': {v.id: v for v in [
-                Variable.from_parts('file1.c', '', 'var1', 'static int'),
-                Variable.from_parts('file1.c', 'func1', 'local1', 'static int'),
-                Variable.from_parts('file1.c', '', 'var2', 'int'),
-                Variable.from_parts('file1.c', 'func2', 'local2', 'char *'),
-                Variable.from_parts('file2.c', '', 'var1', 'char *'),
-                ]},
-            })
-        self.assertEqual(self.calls, [
-            ('_read_tsv', ('spam.c', 'filename\tfuncname\tname\tkind\tdeclaration')),
-            ])
-
-    def test_empty(self):
-        self._return_read_tsv = []
-
-        known = from_file('spam.c', _read_tsv=self._read_tsv)
-
-        self.assertEqual(known, {
-            'variables': {},
-            })
-        self.assertEqual(self.calls, [
-            ('_read_tsv', ('spam.c', 'filename\tfuncname\tname\tkind\tdeclaration')),
-            ])
diff --git a/Lib/test/test_tools/test_c_analyzer/test_c_globals/test_find.py b/Lib/test/test_tools/test_c_analyzer/test_c_globals/test_find.py
deleted file mode 100644
index 8288992..0000000
--- a/Lib/test/test_tools/test_c_analyzer/test_c_globals/test_find.py
+++ /dev/null
@@ -1,335 +0,0 @@
-import unittest
-
-from .. import tool_imports_for_tests
-with tool_imports_for_tests():
-    from c_parser import info
-    from c_globals.find import globals_from_binary, globals
-
-
-class _Base(unittest.TestCase):
-
-    maxDiff = None
-
-    @property
-    def calls(self):
-        try:
-            return self._calls
-        except AttributeError:
-            self._calls = []
-            return self._calls
-
-
-class StaticsFromBinaryTests(_Base):
-
-    _return_iter_symbols = ()
-    _return_resolve_symbols = ()
-    _return_get_symbol_resolver = None
-
-    def setUp(self):
-        super().setUp()
-
-        self.kwargs = dict(
-                _iter_symbols=self._iter_symbols,
-                _resolve=self._resolve_symbols,
-                _get_symbol_resolver=self._get_symbol_resolver,
-                )
-
-    def _iter_symbols(self, binfile, find_local_symbol):
-        self.calls.append(('_iter_symbols', (binfile, find_local_symbol)))
-        return self._return_iter_symbols
-
-    def _resolve_symbols(self, symbols, resolve):
-        self.calls.append(('_resolve_symbols', (symbols, resolve,)))
-        return self._return_resolve_symbols
-
-    def _get_symbol_resolver(self, knownvars, dirnames=None):
-        self.calls.append(('_get_symbol_resolver', (knownvars, dirnames)))
-        return self._return_get_symbol_resolver
-
-    def test_typical(self):
-        symbols = self._return_iter_symbols = ()
-        resolver = self._return_get_symbol_resolver = object()
-        variables = self._return_resolve_symbols = [
-            info.Variable.from_parts('dir1/spam.c', None, 'var1', 'int'),
-            info.Variable.from_parts('dir1/spam.c', None, 'var2', 'static int'),
-            info.Variable.from_parts('dir1/spam.c', None, 'var3', 'char *'),
-            info.Variable.from_parts('dir1/spam.c', 'func2', 'var4', 'const char *'),
-            info.Variable.from_parts('dir1/eggs.c', None, 'var1', 'static int'),
-            info.Variable.from_parts('dir1/eggs.c', 'func1', 'var2', 'static char *'),
-            ]
-        knownvars = object()
-
-        found = list(globals_from_binary('python',
-                                         knownvars=knownvars,
-                                         **self.kwargs))
-
-        self.assertEqual(found, [
-            info.Variable.from_parts('dir1/spam.c', None, 'var1', 'int'),
-            info.Variable.from_parts('dir1/spam.c', None, 'var2', 'static int'),
-            info.Variable.from_parts('dir1/spam.c', None, 'var3', 'char *'),
-            info.Variable.from_parts('dir1/eggs.c', None, 'var1', 'static int'),
-            info.Variable.from_parts('dir1/eggs.c', 'func1', 'var2', 'static char *'),
-            ])
-        self.assertEqual(self.calls, [
-            ('_iter_symbols', ('python', None)),
-            ('_get_symbol_resolver', (knownvars, None)),
-            ('_resolve_symbols', (symbols, resolver)),
-            ])
-
-#        self._return_iter_symbols = [
-#                s_info.Symbol(('dir1/spam.c', None, 'var1'), 'variable', False),
-#                s_info.Symbol(('dir1/spam.c', None, 'var2'), 'variable', False),
-#                s_info.Symbol(('dir1/spam.c', None, 'func1'), 'function', False),
-#                s_info.Symbol(('dir1/spam.c', None, 'func2'), 'function', True),
-#                s_info.Symbol(('dir1/spam.c', None, 'var3'), 'variable', False),
-#                s_info.Symbol(('dir1/spam.c', 'func2', 'var4'), 'variable', False),
-#                s_info.Symbol(('dir1/ham.c', None, 'var1'), 'variable', True),
-#                s_info.Symbol(('dir1/eggs.c', None, 'var1'), 'variable', False),
-#                s_info.Symbol(('dir1/eggs.c', None, 'xyz'), 'other', False),
-#                s_info.Symbol(('dir1/eggs.c', '???', 'var2'), 'variable', False),
-#                s_info.Symbol(('???', None, 'var_x'), 'variable', False),
-#                s_info.Symbol(('???', '???', 'var_y'), 'variable', False),
-#                s_info.Symbol((None, None, '???'), 'other', False),
-#                ]
-#        known = object()
-#
-#        globals_from_binary('python', knownvars=known, **this.kwargs)
-#        found = list(globals_from_symbols(['dir1'], self.iter_symbols))
-#
-#        self.assertEqual(found, [
-#            info.Variable.from_parts('dir1/spam.c', None, 'var1', '???'),
-#            info.Variable.from_parts('dir1/spam.c', None, 'var2', '???'),
-#            info.Variable.from_parts('dir1/spam.c', None, 'var3', '???'),
-#            info.Variable.from_parts('dir1/spam.c', 'func2', 'var4', '???'),
-#            info.Variable.from_parts('dir1/eggs.c', None, 'var1', '???'),
-#            ])
-#        self.assertEqual(self.calls, [
-#            ('iter_symbols', (['dir1'],)),
-#            ])
-#
-#    def test_no_symbols(self):
-#        self._return_iter_symbols = []
-#
-#        found = list(globals_from_symbols(['dir1'], self.iter_symbols))
-#
-#        self.assertEqual(found, [])
-#        self.assertEqual(self.calls, [
-#            ('iter_symbols', (['dir1'],)),
-#            ])
-
-    # XXX need functional test
-
-
-#class StaticFromDeclarationsTests(_Base):
-#
-#    _return_iter_declarations = ()
-#
-#    def iter_declarations(self, dirnames):
-#        self.calls.append(('iter_declarations', (dirnames,)))
-#        return iter(self._return_iter_declarations)
-#
-#    def test_typical(self):
-#        self._return_iter_declarations = [
-#            None,
-#            info.Variable.from_parts('dir1/spam.c', None, 'var1', '???'),
-#            object(),
-#            info.Variable.from_parts('dir1/spam.c', None, 'var2', '???'),
-#            info.Variable.from_parts('dir1/spam.c', None, 'var3', '???'),
-#            object(),
-#            info.Variable.from_parts('dir1/spam.c', 'func2', 'var4', '???'),
-#            object(),
-#            info.Variable.from_parts('dir1/eggs.c', None, 'var1', '???'),
-#            object(),
-#            ]
-#
-#        found = list(globals_from_declarations(['dir1'], self.iter_declarations))
-#
-#        self.assertEqual(found, [
-#            info.Variable.from_parts('dir1/spam.c', None, 'var1', '???'),
-#            info.Variable.from_parts('dir1/spam.c', None, 'var2', '???'),
-#            info.Variable.from_parts('dir1/spam.c', None, 'var3', '???'),
-#            info.Variable.from_parts('dir1/spam.c', 'func2', 'var4', '???'),
-#            info.Variable.from_parts('dir1/eggs.c', None, 'var1', '???'),
-#            ])
-#        self.assertEqual(self.calls, [
-#            ('iter_declarations', (['dir1'],)),
-#            ])
-#
-#    def test_no_declarations(self):
-#        self._return_iter_declarations = []
-#
-#        found = list(globals_from_declarations(['dir1'], self.iter_declarations))
-#
-#        self.assertEqual(found, [])
-#        self.assertEqual(self.calls, [
-#            ('iter_declarations', (['dir1'],)),
-#            ])
-
-
-#class IterVariablesTests(_Base):
-#
-#    _return_from_symbols = ()
-#    _return_from_declarations = ()
-#
-#    def _from_symbols(self, dirnames, iter_symbols):
-#        self.calls.append(('_from_symbols', (dirnames, iter_symbols)))
-#        return iter(self._return_from_symbols)
-#
-#    def _from_declarations(self, dirnames, iter_declarations):
-#        self.calls.append(('_from_declarations', (dirnames, iter_declarations)))
-#        return iter(self._return_from_declarations)
-#
-#    def test_typical(self):
-#        expected = [
-#            info.Variable.from_parts('dir1/spam.c', None, 'var1', '???'),
-#            info.Variable.from_parts('dir1/spam.c', None, 'var2', '???'),
-#            info.Variable.from_parts('dir1/spam.c', None, 'var3', '???'),
-#            info.Variable.from_parts('dir1/spam.c', 'func2', 'var4', '???'),
-#            info.Variable.from_parts('dir1/eggs.c', None, 'var1', '???'),
-#            ]
-#        self._return_from_symbols = expected
-#
-#        found = list(iter_variables(['dir1'],
-#                                  _from_symbols=self._from_symbols,
-#                                  _from_declarations=self._from_declarations))
-#
-#        self.assertEqual(found, expected)
-#        self.assertEqual(self.calls, [
-#            ('_from_symbols', (['dir1'], b_symbols.iter_symbols)),
-#            ])
-#
-#    def test_no_symbols(self):
-#        self._return_from_symbols = []
-#
-#        found = list(iter_variables(['dir1'],
-#                                  _from_symbols=self._from_symbols,
-#                                  _from_declarations=self._from_declarations))
-#
-#        self.assertEqual(found, [])
-#        self.assertEqual(self.calls, [
-#            ('_from_symbols', (['dir1'], b_symbols.iter_symbols)),
-#            ])
-#
-#    def test_from_binary(self):
-#        expected = [
-#            info.Variable.from_parts('dir1/spam.c', None, 'var1', '???'),
-#            info.Variable.from_parts('dir1/spam.c', None, 'var2', '???'),
-#            info.Variable.from_parts('dir1/spam.c', None, 'var3', '???'),
-#            info.Variable.from_parts('dir1/spam.c', 'func2', 'var4', '???'),
-#            info.Variable.from_parts('dir1/eggs.c', None, 'var1', '???'),
-#            ]
-#        self._return_from_symbols = expected
-#
-#        found = list(iter_variables(['dir1'], 'platform',
-#                                  _from_symbols=self._from_symbols,
-#                                  _from_declarations=self._from_declarations))
-#
-#        self.assertEqual(found, expected)
-#        self.assertEqual(self.calls, [
-#            ('_from_symbols', (['dir1'], b_symbols.iter_symbols)),
-#            ])
-#
-#    def test_from_symbols(self):
-#        expected = [
-#            info.Variable.from_parts('dir1/spam.c', None, 'var1', '???'),
-#            info.Variable.from_parts('dir1/spam.c', None, 'var2', '???'),
-#            info.Variable.from_parts('dir1/spam.c', None, 'var3', '???'),
-#            info.Variable.from_parts('dir1/spam.c', 'func2', 'var4', '???'),
-#            info.Variable.from_parts('dir1/eggs.c', None, 'var1', '???'),
-#            ]
-#        self._return_from_symbols = expected
-#
-#        found = list(iter_variables(['dir1'], 'symbols',
-#                                  _from_symbols=self._from_symbols,
-#                                  _from_declarations=self._from_declarations))
-#
-#        self.assertEqual(found, expected)
-#        self.assertEqual(self.calls, [
-#            ('_from_symbols', (['dir1'], s_symbols.iter_symbols)),
-#            ])
-#
-#    def test_from_declarations(self):
-#        expected = [
-#            info.Variable.from_parts('dir1/spam.c', None, 'var1', '???'),
-#            info.Variable.from_parts('dir1/spam.c', None, 'var2', '???'),
-#            info.Variable.from_parts('dir1/spam.c', None, 'var3', '???'),
-#            info.Variable.from_parts('dir1/spam.c', 'func2', 'var4', '???'),
-#            info.Variable.from_parts('dir1/eggs.c', None, 'var1', '???'),
-#            ]
-#        self._return_from_declarations = expected
-#
-#        found = list(iter_variables(['dir1'], 'declarations',
-#                                  _from_symbols=self._from_symbols,
-#                                  _from_declarations=self._from_declarations))
-#
-#        self.assertEqual(found, expected)
-#        self.assertEqual(self.calls, [
-#            ('_from_declarations', (['dir1'], declarations.iter_all)),
-#            ])
-#
-#    def test_from_preprocessed(self):
-#        expected = [
-#            info.Variable.from_parts('dir1/spam.c', None, 'var1', '???'),
-#            info.Variable.from_parts('dir1/spam.c', None, 'var2', '???'),
-#            info.Variable.from_parts('dir1/spam.c', None, 'var3', '???'),
-#            info.Variable.from_parts('dir1/spam.c', 'func2', 'var4', '???'),
-#            info.Variable.from_parts('dir1/eggs.c', None, 'var1', '???'),
-#            ]
-#        self._return_from_declarations = expected
-#
-#        found = list(iter_variables(['dir1'], 'preprocessed',
-#                                  _from_symbols=self._from_symbols,
-#                                  _from_declarations=self._from_declarations))
-#
-#        self.assertEqual(found, expected)
-#        self.assertEqual(self.calls, [
-#            ('_from_declarations', (['dir1'], declarations.iter_preprocessed)),
-#            ])
-
-
-class StaticsTest(_Base):
-
-    _return_iter_variables = None
-
-    def _iter_variables(self, kind, *, known, dirnames):
-        self.calls.append(
-                ('_iter_variables', (kind, known, dirnames)))
-        return iter(self._return_iter_variables or ())
-
-    def test_typical(self):
-        self._return_iter_variables = [
-            info.Variable.from_parts('src1/spam.c', None, 'var1', 'static const char *'),
-            info.Variable.from_parts('src1/spam.c', None, 'var1b', 'const char *'),
-            info.Variable.from_parts('src1/spam.c', 'ham', 'initialized', 'static int'),
-            info.Variable.from_parts('src1/spam.c', 'ham', 'result', 'int'),  # skipped
-            info.Variable.from_parts('src1/spam.c', None, 'var2', 'static PyObject *'),
-            info.Variable.from_parts('src1/eggs.c', 'tofu', 'ready', 'static int'),
-            info.Variable.from_parts('src1/spam.c', None, 'freelist', 'static (PyTupleObject *)[10]'),
-            info.Variable.from_parts('src1/sub/ham.c', None, 'var1', 'static const char const *'),
-            info.Variable.from_parts('src2/jam.c', None, 'var1', 'static int'),
-            info.Variable.from_parts('src2/jam.c', None, 'var2', 'static MyObject *'),
-            info.Variable.from_parts('Include/spam.h', None, 'data', 'static const int'),
-            ]
-        dirnames = object()
-        known = object()
-
-        found = list(globals(dirnames, known,
-                             kind='platform',
-                             _iter_variables=self._iter_variables,
-                             ))
-
-        self.assertEqual(found, [
-            info.Variable.from_parts('src1/spam.c', None, 'var1', 'static const char *'),
-            info.Variable.from_parts('src1/spam.c', None, 'var1b', 'const char *'),
-            info.Variable.from_parts('src1/spam.c', 'ham', 'initialized', 'static int'),
-            info.Variable.from_parts('src1/spam.c', None, 'var2', 'static PyObject *'),
-            info.Variable.from_parts('src1/eggs.c', 'tofu', 'ready', 'static int'),
-            info.Variable.from_parts('src1/spam.c', None, 'freelist', 'static (PyTupleObject *)[10]'),
-            info.Variable.from_parts('src1/sub/ham.c', None, 'var1', 'static const char const *'),
-            info.Variable.from_parts('src2/jam.c', None, 'var1', 'static int'),
-            info.Variable.from_parts('src2/jam.c', None, 'var2', 'static MyObject *'),
-            info.Variable.from_parts('Include/spam.h', None, 'data', 'static const int'),
-            ])
-        self.assertEqual(self.calls, [
-            ('_iter_variables', ('platform', known, dirnames)),
-            ])
diff --git a/Lib/test/test_tools/test_c_analyzer/test_c_symbols/__init__.py b/Lib/test/test_tools/test_c_analyzer/test_common/__init__.py
index bc502ef..bc502ef 100644
--- a/Lib/test/test_tools/test_c_analyzer/test_c_symbols/__init__.py
+++ b/Lib/test/test_tools/test_c_analyzer/test_common/__init__.py
diff --git a/Lib/test/test_tools/test_c_analyzer/test_c_analyzer_common/test_files.py b/Lib/test/test_tools/test_c_analyzer/test_common/test_files.py
index 6d14aea..0c97d2a 100644
--- a/Lib/test/test_tools/test_c_analyzer/test_c_analyzer_common/test_files.py
+++ b/Lib/test/test_tools/test_c_analyzer/test_common/test_files.py
@@ -3,7 +3,7 @@ import unittest
 
 from .. import tool_imports_for_tests
 with tool_imports_for_tests():
-    from c_analyzer_common.files import (
+    from c_analyzer.common.files import (
             iter_files, _walk_tree, glob_tree,
             )
 
diff --git a/Lib/test/test_tools/test_c_analyzer/test_c_analyzer_common/test_info.py b/Lib/test/test_tools/test_c_analyzer/test_common/test_info.py
index 2d38671..69dbb58 100644
--- a/Lib/test/test_tools/test_c_analyzer/test_c_analyzer_common/test_info.py
+++ b/Lib/test/test_tools/test_c_analyzer/test_common/test_info.py
@@ -4,7 +4,10 @@ import unittest
 from ..util import PseudoStr, StrProxy, Object
 from .. import tool_imports_for_tests
 with tool_imports_for_tests():
-    from c_analyzer_common.info import ID
+    from c_analyzer.common.info import (
+            UNKNOWN,
+            ID,
+            )
 
 
 class IDTests(unittest.TestCase):
diff --git a/Lib/test/test_tools/test_c_analyzer/test_c_globals/test_show.py b/Lib/test/test_tools/test_c_analyzer/test_common/test_show.py
index ce1dad8..91ca2f3 100644
--- a/Lib/test/test_tools/test_c_analyzer/test_c_globals/test_show.py
+++ b/Lib/test/test_tools/test_c_analyzer/test_common/test_show.py
@@ -2,8 +2,10 @@ import unittest
 
 from .. import tool_imports_for_tests
 with tool_imports_for_tests():
-    from c_parser import info
-    from c_globals.show import basic
+    from c_analyzer.variables import info
+    from c_analyzer.common.show import (
+            basic,
+            )
 
 
 TYPICAL = [
diff --git a/Lib/test/test_tools/test_c_analyzer/test_c_parser/__init__.py b/Lib/test/test_tools/test_c_analyzer/test_cpython/__init__.py
index bc502ef..bc502ef 100644
--- a/Lib/test/test_tools/test_c_analyzer/test_c_parser/__init__.py
+++ b/Lib/test/test_tools/test_c_analyzer/test_cpython/__init__.py
diff --git a/Lib/test/test_tools/test_c_analyzer/test_c_globals/test___main__.py b/Lib/test/test_tools/test_c_analyzer/test_cpython/test___main__.py
index 5f52c58..6d69ed7 100644
--- a/Lib/test/test_tools/test_c_analyzer/test_c_globals/test___main__.py
+++ b/Lib/test/test_tools/test_c_analyzer/test_cpython/test___main__.py
@@ -3,12 +3,13 @@ import unittest
 
 from .. import tool_imports_for_tests
 with tool_imports_for_tests():
-    from c_analyzer_common import SOURCE_DIRS
-    from c_analyzer_common.known import DATA_FILE as KNOWN_FILE
-    from c_parser import info
-    import c_globals as cg
-    from c_globals.supported import IGNORED_FILE
-    from c_globals.__main__ import cmd_check, cmd_show, parse_args, main
+    from c_analyzer.variables import info
+    from cpython import SOURCE_DIRS
+    from cpython.supported import IGNORED_FILE
+    from cpython.known import DATA_FILE as KNOWN_FILE
+    from cpython.__main__ import (
+            cmd_check, cmd_show, parse_args, main,
+            )
 
 
 TYPICAL = [
@@ -46,6 +47,8 @@ class CMDBase(unittest.TestCase):
 
     maxDiff = None
 
+#    _return_known_from_file = None
+#    _return_ignored_from_file = None
     _return_find = ()
 
     @property
@@ -56,8 +59,16 @@ class CMDBase(unittest.TestCase):
             self._calls = []
             return self._calls
 
-    def _find(self, *args):
-        self.calls.append(('_find', args))
+#    def _known_from_file(self, *args):
+#        self.calls.append(('_known_from_file', args))
+#        return self._return_known_from_file or {}
+#
+#    def _ignored_from_file(self, *args):
+#        self.calls.append(('_ignored_from_file', args))
+#        return self._return_ignored_from_file or {}
+
+    def _find(self, known, ignored, skip_objects=False):
+        self.calls.append(('_find', (known, ignored, skip_objects)))
         return self._return_find
 
     def _show(self, *args):
@@ -78,41 +89,35 @@ class CheckTests(CMDBase):
                   _print=self._print,
                   )
 
-        self.assertEqual(self.calls[0], (
-            '_find', (
-                SOURCE_DIRS,
-                KNOWN_FILE,
-                IGNORED_FILE,
-                ),
-            ))
+        self.assertEqual(
+                self.calls[0],
+                ('_find', (KNOWN_FILE, IGNORED_FILE, False)),
+                )
 
     def test_all_supported(self):
         self._return_find = [(v, s) for v, s in TYPICAL if s]
         dirs = ['src1', 'src2', 'Include']
 
         cmd_check('check',
-                 dirs,
-                 ignored='ignored.tsv',
-                 known='known.tsv',
-                 _find=self._find,
-                 _show=self._show,
-                 _print=self._print,
-                 )
+                  known='known.tsv',
+                  ignored='ignored.tsv',
+                  _find=self._find,
+                  _show=self._show,
+                  _print=self._print,
+                  )
 
         self.assertEqual(self.calls, [
-            ('_find', (dirs, 'known.tsv', 'ignored.tsv')),
+            ('_find', ('known.tsv', 'ignored.tsv', False)),
             #('_print', ('okay',)),
             ])
 
     def test_some_unsupported(self):
         self._return_find = TYPICAL
-        dirs = ['src1', 'src2', 'Include']
 
         with self.assertRaises(SystemExit) as cm:
             cmd_check('check',
-                      dirs,
-                      ignored='ignored.tsv',
                       known='known.tsv',
+                      ignored='ignored.tsv',
                       _find=self._find,
                       _show=self._show,
                       _print=self._print,
@@ -120,7 +125,7 @@ class CheckTests(CMDBase):
 
         unsupported = [v for v, s in TYPICAL if not s]
         self.assertEqual(self.calls, [
-            ('_find', (dirs, 'known.tsv', 'ignored.tsv')),
+            ('_find', ('known.tsv', 'ignored.tsv', False)),
             ('_print', ('ERROR: found unsupported global variables',)),
             ('_print', ()),
             ('_show', (sorted(unsupported),)),
@@ -140,20 +145,15 @@ class ShowTests(CMDBase):
                  _print=self._print,
                  )
 
-        self.assertEqual(self.calls[0], (
-            '_find', (
-                SOURCE_DIRS,
-                KNOWN_FILE,
-                IGNORED_FILE,
-                ),
-            ))
+        self.assertEqual(
+                self.calls[0],
+                ('_find', (KNOWN_FILE, IGNORED_FILE, False)),
+                )
 
     def test_typical(self):
         self._return_find = TYPICAL
-        dirs = ['src1', 'src2', 'Include']
 
         cmd_show('show',
-                 dirs,
                  known='known.tsv',
                  ignored='ignored.tsv',
                  _find=self._find,
@@ -164,7 +164,7 @@ class ShowTests(CMDBase):
         supported = [v for v, s in TYPICAL if s]
         unsupported = [v for v, s in TYPICAL if not s]
         self.assertEqual(self.calls, [
-            ('_find', (dirs, 'known.tsv', 'ignored.tsv')),
+            ('_find', ('known.tsv', 'ignored.tsv', False)),
             ('_print', ('supported:',)),
             ('_print', ('----------',)),
             ('_show', (sorted(supported),)),
@@ -201,7 +201,7 @@ class ParseArgsTests(unittest.TestCase):
         self.assertEqual(cmdkwargs, {
             'ignored': IGNORED_FILE,
             'known': KNOWN_FILE,
-            'dirs': SOURCE_DIRS,
+            #'dirs': SOURCE_DIRS,
             })
 
     def test_check_full_args(self):
@@ -209,16 +209,16 @@ class ParseArgsTests(unittest.TestCase):
             'check',
             '--ignored', 'spam.tsv',
             '--known', 'eggs.tsv',
-            'dir1',
-            'dir2',
-            'dir3',
+            #'dir1',
+            #'dir2',
+            #'dir3',
             ])
 
         self.assertEqual(cmd, 'check')
         self.assertEqual(cmdkwargs, {
             'ignored': 'spam.tsv',
             'known': 'eggs.tsv',
-            'dirs': ['dir1', 'dir2', 'dir3']
+            #'dirs': ['dir1', 'dir2', 'dir3']
             })
 
     def test_show_no_args(self):
@@ -230,7 +230,7 @@ class ParseArgsTests(unittest.TestCase):
         self.assertEqual(cmdkwargs, {
             'ignored': IGNORED_FILE,
             'known': KNOWN_FILE,
-            'dirs': SOURCE_DIRS,
+            #'dirs': SOURCE_DIRS,
             'skip_objects': False,
             })
 
@@ -239,16 +239,16 @@ class ParseArgsTests(unittest.TestCase):
             'show',
             '--ignored', 'spam.tsv',
             '--known', 'eggs.tsv',
-            'dir1',
-            'dir2',
-            'dir3',
+            #'dir1',
+            #'dir2',
+            #'dir3',
             ])
 
         self.assertEqual(cmd, 'show')
         self.assertEqual(cmdkwargs, {
             'ignored': 'spam.tsv',
             'known': 'eggs.tsv',
-            'dirs': ['dir1', 'dir2', 'dir3'],
+            #'dirs': ['dir1', 'dir2', 'dir3'],
             'skip_objects': False,
             })
 
diff --git a/Lib/test/test_tools/test_c_analyzer/test_c_globals/test_functional.py b/Lib/test/test_tools/test_c_analyzer/test_cpython/test_functional.py
index 9279790..9279790 100644
--- a/Lib/test/test_tools/test_c_analyzer/test_c_globals/test_functional.py
+++ b/Lib/test/test_tools/test_c_analyzer/test_cpython/test_functional.py
diff --git a/Lib/test/test_tools/test_c_analyzer/test_c_globals/test_supported.py b/Lib/test/test_tools/test_c_analyzer/test_cpython/test_supported.py
index 1e7d40e..a244b97 100644
--- a/Lib/test/test_tools/test_c_analyzer/test_c_globals/test_supported.py
+++ b/Lib/test/test_tools/test_c_analyzer/test_cpython/test_supported.py
@@ -4,9 +4,11 @@ import unittest
 
 from .. import tool_imports_for_tests
 with tool_imports_for_tests():
-    from c_analyzer_common.info import ID
-    from c_parser import info
-    from c_globals.supported import is_supported, ignored_from_file
+    from c_analyzer.common.info import ID
+    from c_analyzer.variables.info import Variable
+    from cpython.supported import (
+            is_supported, ignored_from_file,
+            )
 
 
 class IsSupportedTests(unittest.TestCase):
@@ -14,8 +16,8 @@ class IsSupportedTests(unittest.TestCase):
     @unittest.expectedFailure
     def test_supported(self):
         statics = [
-                info.StaticVar('src1/spam.c', None, 'var1', 'const char *'),
-                info.StaticVar('src1/spam.c', None, 'var1', 'int'),
+                Variable('src1/spam.c', None, 'var1', 'const char *'),
+                Variable('src1/spam.c', None, 'var1', 'int'),
                 ]
         for static in statics:
             with self.subTest(static):
@@ -26,8 +28,8 @@ class IsSupportedTests(unittest.TestCase):
     @unittest.expectedFailure
     def test_not_supported(self):
         statics = [
-                info.StaticVar('src1/spam.c', None, 'var1', 'PyObject *'),
-                info.StaticVar('src1/spam.c', None, 'var1', 'PyObject[10]'),
+                Variable('src1/spam.c', None, 'var1', 'PyObject *'),
+                Variable('src1/spam.c', None, 'var1', 'PyObject[10]'),
                 ]
         for static in statics:
             with self.subTest(static):
diff --git a/Lib/test/test_tools/test_c_analyzer/test_c_globals/__init__.py b/Lib/test/test_tools/test_c_analyzer/test_parser/__init__.py
index bc502ef..bc502ef 100644
--- a/Lib/test/test_tools/test_c_analyzer/test_c_globals/__init__.py
+++ b/Lib/test/test_tools/test_c_analyzer/test_parser/__init__.py
diff --git a/Lib/test/test_tools/test_c_analyzer/test_c_parser/test_declarations.py b/Lib/test/test_tools/test_c_analyzer/test_parser/test_declarations.py
index b68744e..674fcb1 100644
--- a/Lib/test/test_tools/test_c_analyzer/test_c_parser/test_declarations.py
+++ b/Lib/test/test_tools/test_c_analyzer/test_parser/test_declarations.py
@@ -3,9 +3,9 @@ import unittest
 
 from .. import tool_imports_for_tests
 with tool_imports_for_tests():
-    from c_parser.declarations import (
+    from c_analyzer.parser.declarations import (
         iter_global_declarations, iter_local_statements,
-        parse_func, parse_var, parse_compound,
+        parse_func, _parse_var, parse_compound,
         iter_variables,
         )
 
@@ -515,7 +515,7 @@ class ParseVarTests(TestCaseBase):
             ])
         for stmt, expected in tests:
             with self.subTest(stmt):
-                name, vartype = parse_var(stmt)
+                name, vartype = _parse_var(stmt)
 
                 self.assertEqual((name, vartype), expected)
 
diff --git a/Lib/test/test_tools/test_c_analyzer/test_c_parser/test_preprocessor.py b/Lib/test/test_tools/test_c_analyzer/test_parser/test_preprocessor.py
index 89e1557..56a1c9c 100644
--- a/Lib/test/test_tools/test_c_analyzer/test_c_parser/test_preprocessor.py
+++ b/Lib/test/test_tools/test_c_analyzer/test_parser/test_preprocessor.py
@@ -6,7 +6,7 @@ import sys
 from ..util import wrapped_arg_combos, StrProxy
 from .. import tool_imports_for_tests
 with tool_imports_for_tests():
-    from c_parser.preprocessor import (
+    from c_analyzer.parser.preprocessor import (
         iter_lines,
         # directives
         parse_directive, PreprocessorDirective,
diff --git a/Lib/test/test_tools/test_c_analyzer/test_c_analyzer_common/__init__.py b/Lib/test/test_tools/test_c_analyzer/test_symbols/__init__.py
index bc502ef..bc502ef 100644
--- a/Lib/test/test_tools/test_c_analyzer/test_c_analyzer_common/__init__.py
+++ b/Lib/test/test_tools/test_c_analyzer/test_symbols/__init__.py
diff --git a/Lib/test/test_tools/test_c_analyzer/test_c_symbols/test_info.py b/Lib/test/test_tools/test_c_analyzer/test_symbols/test_info.py
index e029dcf..1282a89 100644
--- a/Lib/test/test_tools/test_c_analyzer/test_c_symbols/test_info.py
+++ b/Lib/test/test_tools/test_c_analyzer/test_symbols/test_info.py
@@ -4,8 +4,8 @@ import unittest
 from ..util import PseudoStr, StrProxy, Object
 from .. import tool_imports_for_tests
 with tool_imports_for_tests():
-    from c_analyzer_common.info import ID
-    from c_symbols.info import Symbol
+    from c_analyzer.common.info import ID
+    from c_analyzer.symbols.info import Symbol
 
 
 class SymbolTests(unittest.TestCase):
diff --git a/Lib/test/test_tools/test_c_analyzer/test_variables/__init__.py b/Lib/test/test_tools/test_c_analyzer/test_variables/__init__.py
new file mode 100644
index 0000000..bc502ef
--- /dev/null
+++ b/Lib/test/test_tools/test_c_analyzer/test_variables/__init__.py
@@ -0,0 +1,6 @@
+import os.path
+from test.support import load_package_tests
+
+
+def load_tests(*args):
+    return load_package_tests(os.path.dirname(__file__), *args)
diff --git a/Lib/test/test_tools/test_c_analyzer/test_variables/test_find.py b/Lib/test/test_tools/test_c_analyzer/test_variables/test_find.py
new file mode 100644
index 0000000..7a13cf3
--- /dev/null
+++ b/Lib/test/test_tools/test_c_analyzer/test_variables/test_find.py
@@ -0,0 +1,124 @@
+import unittest
+
+from .. import tool_imports_for_tests
+with tool_imports_for_tests():
+    from c_analyzer.variables import info
+    from c_analyzer.variables.find import (
+            vars_from_binary,
+            )
+
+
+class _Base(unittest.TestCase):
+
+    maxDiff = None
+
+    @property
+    def calls(self):
+        try:
+            return self._calls
+        except AttributeError:
+            self._calls = []
+            return self._calls
+
+
+class VarsFromBinaryTests(_Base):
+
+    _return_iter_vars = ()
+    _return_get_symbol_resolver = None
+
+    def setUp(self):
+        super().setUp()
+
+        self.kwargs = dict(
+                _iter_vars=self._iter_vars,
+                _get_symbol_resolver=self._get_symbol_resolver,
+                )
+
+    def _iter_vars(self, binfile, resolve, handle_id):
+        self.calls.append(('_iter_vars', (binfile, resolve, handle_id)))
+        return [(v, v.id) for v in self._return_iter_vars]
+
+    def _get_symbol_resolver(self, known=None, dirnames=(), *,
+                             handle_var,
+                             filenames=None,
+                             check_filename=None,
+                             perfilecache=None,
+                             ):
+        self.calls.append(('_get_symbol_resolver',
+                           (known, dirnames, handle_var, filenames,
+                            check_filename, perfilecache)))
+        return self._return_get_symbol_resolver
+
+    def test_typical(self):
+        resolver = self._return_get_symbol_resolver = object()
+        variables = self._return_iter_vars = [
+            info.Variable.from_parts('dir1/spam.c', None, 'var1', 'int'),
+            info.Variable.from_parts('dir1/spam.c', None, 'var2', 'static int'),
+            info.Variable.from_parts('dir1/spam.c', None, 'var3', 'char *'),
+            info.Variable.from_parts('dir1/spam.c', 'func2', 'var4', 'const char *'),
+            info.Variable.from_parts('dir1/eggs.c', None, 'var1', 'static int'),
+            info.Variable.from_parts('dir1/eggs.c', 'func1', 'var2', 'static char *'),
+            ]
+        known = object()
+        filenames = object()
+
+        found = list(vars_from_binary('python',
+                                      known=known,
+                                      filenames=filenames,
+                                      **self.kwargs))
+
+        self.assertEqual(found, [
+            info.Variable.from_parts('dir1/spam.c', None, 'var1', 'int'),
+            info.Variable.from_parts('dir1/spam.c', None, 'var2', 'static int'),
+            info.Variable.from_parts('dir1/spam.c', None, 'var3', 'char *'),
+            info.Variable.from_parts('dir1/spam.c', 'func2', 'var4', 'const char *'),
+            info.Variable.from_parts('dir1/eggs.c', None, 'var1', 'static int'),
+            info.Variable.from_parts('dir1/eggs.c', 'func1', 'var2', 'static char *'),
+            ])
+        self.assertEqual(self.calls, [
+            ('_get_symbol_resolver', (filenames, known, info.Variable.from_id, None, None, {})),
+            ('_iter_vars', ('python', resolver, None)),
+            ])
+
+#        self._return_iter_symbols = [
+#                s_info.Symbol(('dir1/spam.c', None, 'var1'), 'variable', False),
+#                s_info.Symbol(('dir1/spam.c', None, 'var2'), 'variable', False),
+#                s_info.Symbol(('dir1/spam.c', None, 'func1'), 'function', False),
+#                s_info.Symbol(('dir1/spam.c', None, 'func2'), 'function', True),
+#                s_info.Symbol(('dir1/spam.c', None, 'var3'), 'variable', False),
+#                s_info.Symbol(('dir1/spam.c', 'func2', 'var4'), 'variable', False),
+#                s_info.Symbol(('dir1/ham.c', None, 'var1'), 'variable', True),
+#                s_info.Symbol(('dir1/eggs.c', None, 'var1'), 'variable', False),
+#                s_info.Symbol(('dir1/eggs.c', None, 'xyz'), 'other', False),
+#                s_info.Symbol(('dir1/eggs.c', '???', 'var2'), 'variable', False),
+#                s_info.Symbol(('???', None, 'var_x'), 'variable', False),
+#                s_info.Symbol(('???', '???', 'var_y'), 'variable', False),
+#                s_info.Symbol((None, None, '???'), 'other', False),
+#                ]
+#        known = object()
+#
+#        vars_from_binary('python', knownvars=known, **this.kwargs)
+#        found = list(globals_from_symbols(['dir1'], self.iter_symbols))
+#
+#        self.assertEqual(found, [
+#            info.Variable.from_parts('dir1/spam.c', None, 'var1', '???'),
+#            info.Variable.from_parts('dir1/spam.c', None, 'var2', '???'),
+#            info.Variable.from_parts('dir1/spam.c', None, 'var3', '???'),
+#            info.Variable.from_parts('dir1/spam.c', 'func2', 'var4', '???'),
+#            info.Variable.from_parts('dir1/eggs.c', None, 'var1', '???'),
+#            ])
+#        self.assertEqual(self.calls, [
+#            ('iter_symbols', (['dir1'],)),
+#            ])
+#
+#    def test_no_symbols(self):
+#        self._return_iter_symbols = []
+#
+#        found = list(globals_from_symbols(['dir1'], self.iter_symbols))
+#
+#        self.assertEqual(found, [])
+#        self.assertEqual(self.calls, [
+#            ('iter_symbols', (['dir1'],)),
+#            ])
+
+    # XXX need functional test
diff --git a/Lib/test/test_tools/test_c_analyzer/test_c_parser/test_info.py b/Lib/test/test_tools/test_c_analyzer/test_variables/test_info.py
index d1a966c..d424d8e 100644
--- a/Lib/test/test_tools/test_c_analyzer/test_c_parser/test_info.py
+++ b/Lib/test/test_tools/test_c_analyzer/test_variables/test_info.py
@@ -4,10 +4,10 @@ import unittest
 from ..util import PseudoStr, StrProxy, Object
 from .. import tool_imports_for_tests
 with tool_imports_for_tests():
-    from c_analyzer_common.info import ID, UNKNOWN
-    from c_parser.info import (
-        normalize_vartype, Variable,
-        )
+    from c_analyzer.common.info import UNKNOWN, ID
+    from c_analyzer.variables.info import (
+            normalize_vartype, Variable
+            )
 
 
 class NormalizeVartypeTests(unittest.TestCase):
diff --git a/Lib/test/test_tools/test_c_analyzer/test_variables/test_known.py b/Lib/test/test_tools/test_c_analyzer/test_variables/test_known.py
new file mode 100644
index 0000000..49ff45c
--- /dev/null
+++ b/Lib/test/test_tools/test_c_analyzer/test_variables/test_known.py
@@ -0,0 +1,139 @@
+import re
+import textwrap
+import unittest
+
+from .. import tool_imports_for_tests
+with tool_imports_for_tests():
+    from c_analyzer.common.info import ID
+    from c_analyzer.variables.info import Variable
+    from c_analyzer.variables.known import (
+            read_file,
+            from_file,
+            )
+
+class _BaseTests(unittest.TestCase):
+
+    maxDiff = None
+
+    @property
+    def calls(self):
+        try:
+            return self._calls
+        except AttributeError:
+            self._calls = []
+            return self._calls
+
+
+class ReadFileTests(_BaseTests):
+
+    _return_read_tsv = ()
+
+    def _read_tsv(self, *args):
+        self.calls.append(('_read_tsv', args))
+        return self._return_read_tsv
+
+    def test_typical(self):
+        lines = textwrap.dedent('''
+            filename    funcname        name    kind    declaration
+            file1.c     -       var1    variable        static int
+            file1.c     func1   local1  variable        static int
+            file1.c     -       var2    variable        int
+            file1.c     func2   local2  variable        char *
+            file2.c     -       var1    variable        char *
+            ''').strip().splitlines()
+        lines = [re.sub(r'\s+', '\t', line, 4) for line in lines]
+        self._return_read_tsv = [tuple(v.strip() for v in line.split('\t'))
+                                 for line in lines[1:]]
+
+        known = list(read_file('known.tsv', _read_tsv=self._read_tsv))
+
+        self.assertEqual(known, [
+            ('variable', ID('file1.c', '', 'var1'), 'static int'),
+            ('variable', ID('file1.c', 'func1', 'local1'), 'static int'),
+            ('variable', ID('file1.c', '', 'var2'), 'int'),
+            ('variable', ID('file1.c', 'func2', 'local2'), 'char *'),
+            ('variable', ID('file2.c', '', 'var1'), 'char *'),
+            ])
+        self.assertEqual(self.calls, [
+            ('_read_tsv',
+             ('known.tsv', 'filename\tfuncname\tname\tkind\tdeclaration')),
+            ])
+
+    def test_empty(self):
+        self._return_read_tsv = []
+
+        known = list(read_file('known.tsv', _read_tsv=self._read_tsv))
+
+        self.assertEqual(known, [])
+        self.assertEqual(self.calls, [
+            ('_read_tsv', ('known.tsv', 'filename\tfuncname\tname\tkind\tdeclaration')),
+            ])
+
+
+class FromFileTests(_BaseTests):
+
+    _return_read_file = ()
+    _return_handle_var = ()
+
+    def _read_file(self, infile):
+        self.calls.append(('_read_file', (infile,)))
+        return iter(self._return_read_file)
+
+    def _handle_var(self, varid, decl):
+        self.calls.append(('_handle_var', (varid, decl)))
+        var = self._return_handle_var.pop(0)
+        return var
+
+    def test_typical(self):
+        expected = [
+            Variable.from_parts('file1.c', '', 'var1', 'static int'),
+            Variable.from_parts('file1.c', 'func1', 'local1', 'static int'),
+            Variable.from_parts('file1.c', '', 'var2', 'int'),
+            Variable.from_parts('file1.c', 'func2', 'local2', 'char *'),
+            Variable.from_parts('file2.c', '', 'var1', 'char *'),
+            ]
+        self._return_read_file = [('variable', v.id, v.vartype)
+                                  for v in expected]
+#            ('variable', ID('file1.c', '', 'var1'), 'static int'),
+#            ('variable', ID('file1.c', 'func1', 'local1'), 'static int'),
+#            ('variable', ID('file1.c', '', 'var2'), 'int'),
+#            ('variable', ID('file1.c', 'func2', 'local2'), 'char *'),
+#            ('variable', ID('file2.c', '', 'var1'), 'char *'),
+#            ]
+        self._return_handle_var = list(expected)  # a copy
+
+        known = from_file('known.tsv',
+                          handle_var=self._handle_var,
+                          _read_file=self._read_file,
+                          )
+
+        self.assertEqual(known, {
+            'variables': {v.id: v for v in expected},
+            })
+#                Variable.from_parts('file1.c', '', 'var1', 'static int'),
+#                Variable.from_parts('file1.c', 'func1', 'local1', 'static int'),
+#                Variable.from_parts('file1.c', '', 'var2', 'int'),
+#                Variable.from_parts('file1.c', 'func2', 'local2', 'char *'),
+#                Variable.from_parts('file2.c', '', 'var1', 'char *'),
+#                ]},
+#            })
+        self.assertEqual(self.calls, [
+            ('_read_file', ('known.tsv',)),
+            *[('_handle_var', (v.id, v.vartype))
+              for v in expected],
+            ])
+
+    def test_empty(self):
+        self._return_read_file = []
+
+        known = from_file('known.tsv',
+                          handle_var=self._handle_var,
+                          _read_file=self._read_file,
+                          )
+
+        self.assertEqual(known, {
+            'variables': {},
+            })
+        self.assertEqual(self.calls, [
+            ('_read_file', ('known.tsv',)),
+            ])