Merge lp:~alan-griffiths/miral/add-symbols-map into lp:miral

[Alan Griffiths]

Add symbols map to ensure we only publish public symbols from libmiral

[Alexandros Frantzis (afrantzis)]

Looks good.

review: Approve

=== modified file 'miral/CMakeLists.txt'
--- miral/CMakeLists.txt	2016-07-28 08:33:19 +0000
+++ miral/CMakeLists.txt	2016-08-02 09:11:08 +0000
@@ -1,7 +1,15 @@
 pkg_check_modules(MIRSERVER mirserver>=0.20 REQUIRED)
 
+set(MIRAL_ABI 1)
+set(symbol_map ${CMAKE_CURRENT_SOURCE_DIR}/symbols.map)
+
 include_directories(include SYSTEM ${MIRSERVER_INCLUDE_DIRS})
 
+add_library(miral-internal STATIC
+    basic_window_manager.cpp            basic_window_manager.h window_manager_tools_implementation.h
+    mru_window_list.cpp                 mru_window_list.h
+)
+
 add_library(miral SHARED
     active_outputs.cpp                  ${CMAKE_SOURCE_DIR}/include/miral/active_outputs.h
     application.cpp                     ${CMAKE_SOURCE_DIR}/include/miral/application.h
@@ -17,9 +25,7 @@
     window_management_options.cpp       ${CMAKE_SOURCE_DIR}/include/miral/window_management_options.h
     window_specification.cpp            ${CMAKE_SOURCE_DIR}/include/miral/window_specification.h
     internal_client.cpp                 ${CMAKE_SOURCE_DIR}/include/miral/internal_client.h
-    mru_window_list.cpp                 mru_window_list.h
     set_window_managment_policy.cpp     ${CMAKE_SOURCE_DIR}/include/miral/set_window_managment_policy.h
-    basic_window_manager.cpp            basic_window_manager.h window_manager_tools_implementation.h
     window_management_policy.cpp        ${CMAKE_SOURCE_DIR}/include/miral/window_management_policy.h
     window_manager_tools.cpp            ${CMAKE_SOURCE_DIR}/include/miral/window_manager_tools.h
                                         ${CMAKE_SOURCE_DIR}/include/miral/stream_specification.h
@@ -32,9 +38,16 @@
         ${MIRCLIENT_LDFLAGS}
         ${MIRCOMMON_LDFLAGS}
     PRIVATE
+        miral-internal
         ${MIRSERVER_LDFLAGS}
 )
 
+set_target_properties(miral
+        PROPERTIES
+        SOVERSION ${MIRAL_ABI}
+        LINK_FLAGS "-Wl,--exclude-libs=ALL -Wl,--version-script,${symbol_map}"
+)
+
 set(LIBDIR "${CMAKE_INSTALL_PREFIX}/lib")
 set(INCLUDEDIR "${CMAKE_INSTALL_PREFIX}/include/miral")
 

=== added file 'miral/symbols.map'
--- miral/symbols.map	1970-01-01 00:00:00 +0000
+++ miral/symbols.map	2016-08-02 09:11:08 +0000
@@ -0,0 +1,271 @@
+MIRAL_0.1 {
+global:
+  extern "C++" {
+    miral::ActiveOutputsListener::?ActiveOutputsListener*;
+    miral::ActiveOutputsListener::ActiveOutputsListener*;
+    miral::ActiveOutputsListener::advise_output_begin*;
+    miral::ActiveOutputsListener::advise_output_create*;
+    miral::ActiveOutputsListener::advise_output_delete*;
+    miral::ActiveOutputsListener::advise_output_end*;
+    miral::ActiveOutputsListener::advise_output_update*;
+    miral::ActiveOutputsListener::operator*;
+    miral::ActiveOutputsMonitor::?ActiveOutputsMonitor*;
+    miral::ActiveOutputsMonitor::ActiveOutputsMonitor*;
+    miral::ActiveOutputsMonitor::add_listener*;
+    miral::ActiveOutputsMonitor::delete_listener*;
+    miral::ActiveOutputsMonitor::for_each_output*;
+    miral::ActiveOutputsMonitor::operator*;
+    miral::ApplicationAuthorizer::?ApplicationAuthorizer*;
+    miral::ApplicationAuthorizer::ApplicationAuthorizer*;
+    miral::ApplicationAuthorizer::operator*;
+    miral::ApplicationCredentials::ApplicationCredentials*;
+    miral::ApplicationCredentials::gid*;
+    miral::ApplicationCredentials::pid*;
+    miral::ApplicationCredentials::uid*;
+    miral::ApplicationInfo::?ApplicationInfo*;
+    miral::ApplicationInfo::ApplicationInfo*;
+    miral::ApplicationInfo::add_window*;
+    miral::ApplicationInfo::application*;
+    miral::ApplicationInfo::operator*;
+    miral::ApplicationInfo::remove_window*;
+    miral::ApplicationInfo::userdata*;
+    miral::ApplicationInfo::windows*;
+    miral::BasicSetApplicationAuthorizer::?BasicSetApplicationAuthorizer*;
+    miral::BasicSetApplicationAuthorizer::BasicSetApplicationAuthorizer*;
+    miral::BasicSetApplicationAuthorizer::operator*;
+    miral::BasicSetApplicationAuthorizer::the_application_authorizer*;
+    miral::CanonicalWindowManagerPolicy::CanonicalWindowManagerPolicy*;
+    miral::CanonicalWindowManagerPolicy::advise_focus_gained*;
+    miral::CanonicalWindowManagerPolicy::handle_modify_window*;
+    miral::CanonicalWindowManagerPolicy::handle_raise_window*;
+    miral::CanonicalWindowManagerPolicy::handle_window_ready*;
+    miral::CanonicalWindowManagerPolicy::place_new_surface*;
+    miral::InternalClientLauncher::?InternalClientLauncher*;
+    miral::InternalClientLauncher::InternalClientLauncher*;
+    miral::InternalClientLauncher::launch*;
+    miral::InternalClientLauncher::operator*;
+    miral::MirRunner::MirRunner*;
+    miral::MirRunner::run_with*;
+    miral::Output::?Output*;
+    miral::Output::Output*;
+    miral::Output::connected*;
+    miral::Output::extents*;
+    miral::Output::form_factor*;
+    miral::Output::is_same_output*;
+    miral::Output::operator*;
+    miral::Output::orientation*;
+    miral::Output::physical_size_mm*;
+    miral::Output::pixel_format*;
+    miral::Output::power_mode*;
+    miral::Output::refresh_rate*;
+    miral::Output::scale*;
+    miral::Output::type*;
+    miral::Output::used*;
+    miral::Output::valid*;
+    miral::QuitOnCtrlAltBkSp::operator*;
+    miral::SetWindowManagmentPolicy::?SetWindowManagmentPolicy*;
+    miral::SetWindowManagmentPolicy::SetWindowManagmentPolicy*;
+    miral::SetWindowManagmentPolicy::operator*;
+    miral::StartupInternalClient::?StartupInternalClient*;
+    miral::StartupInternalClient::StartupInternalClient*;
+    miral::StartupInternalClient::operator*;
+    miral::Window::?Window*;
+    miral::Window::Window*;
+    miral::Window::application*;
+    miral::Window::hide*;
+    miral::Window::input_area_contains*;
+    miral::Window::move_to*;
+    miral::Window::operator*;
+    miral::Window::request_client_surface_close*;
+    miral::Window::resize*;
+    miral::Window::set_alpha*;
+    miral::Window::set_state*;
+    miral::Window::show*;
+    miral::Window::size*;
+    miral::Window::surface_id*;
+    miral::Window::top_left*;
+    miral::WindowInfo::?WindowInfo*;
+    miral::WindowInfo::WindowInfo*;
+    miral::WindowInfo::add_child*;
+    miral::WindowInfo::can_be_active*;
+    miral::WindowInfo::can_morph_to*;
+    miral::WindowInfo::children*;
+    miral::WindowInfo::constrain_resize*;
+    miral::WindowInfo::has_height_inc*;
+    miral::WindowInfo::has_max_aspect*;
+    miral::WindowInfo::has_min_aspect*;
+    miral::WindowInfo::has_name*;
+    miral::WindowInfo::has_output_id*;
+    miral::WindowInfo::has_width_inc*;
+    miral::WindowInfo::height_inc*;
+    miral::WindowInfo::is_visible*;
+    miral::WindowInfo::max_aspect*;
+    miral::WindowInfo::max_height*;
+    miral::WindowInfo::max_width*;
+    miral::WindowInfo::min_aspect*;
+    miral::WindowInfo::min_height*;
+    miral::WindowInfo::min_width*;
+    miral::WindowInfo::must_have_parent*;
+    miral::WindowInfo::must_not_have_parent*;
+    miral::WindowInfo::name*;
+    miral::WindowInfo::needs_titlebar*;
+    miral::WindowInfo::operator*;
+    miral::WindowInfo::output_id*;
+    miral::WindowInfo::parent*;
+    miral::WindowInfo::preferred_orientation*;
+    miral::WindowInfo::remove_child*;
+    miral::WindowInfo::restore_rect*;
+    miral::WindowInfo::state*;
+    miral::WindowInfo::type*;
+    miral::WindowInfo::userdata*;
+    miral::WindowInfo::width_inc*;
+    miral::WindowInfo::window*;
+    miral::WindowManagementPolicy::?WindowManagementPolicy*;
+    miral::WindowManagementPolicy::WindowManagementPolicy*;
+    miral::WindowManagementPolicy::advise_begin*;
+    miral::WindowManagementPolicy::advise_delete_app*;
+    miral::WindowManagementPolicy::advise_delete_window*;
+    miral::WindowManagementPolicy::advise_end*;
+    miral::WindowManagementPolicy::advise_focus_gained*;
+    miral::WindowManagementPolicy::advise_focus_lost*;
+    miral::WindowManagementPolicy::advise_move_to*;
+    miral::WindowManagementPolicy::advise_new_app*;
+    miral::WindowManagementPolicy::advise_new_window*;
+    miral::WindowManagementPolicy::advise_raise*;
+    miral::WindowManagementPolicy::advise_resize*;
+    miral::WindowManagementPolicy::advise_state_change*;
+    miral::WindowManagementPolicy::operator*;
+    miral::WindowManagerOptions::WindowManagerOptions*;
+    miral::WindowManagerOptions::operator*;
+    miral::WindowManagerTools::?WindowManagerTools*;
+    miral::WindowManagerTools::WindowManagerTools*;
+    miral::WindowManagerTools::active_display*;
+    miral::WindowManagerTools::active_window*;
+    miral::WindowManagerTools::count_applications*;
+    miral::WindowManagerTools::drag_active_window*;
+    miral::WindowManagerTools::find_application*;
+    miral::WindowManagerTools::focus_next_application*;
+    miral::WindowManagerTools::focus_next_within_application*;
+    miral::WindowManagerTools::for_each_application*;
+    miral::WindowManagerTools::info_for*;
+    miral::WindowManagerTools::invoke_under_lock*;
+    miral::WindowManagerTools::kill_active_application*;
+    miral::WindowManagerTools::modify_window*;
+    miral::WindowManagerTools::operator*;
+    miral::WindowManagerTools::place_and_size*;
+    miral::WindowManagerTools::raise_tree*;
+    miral::WindowManagerTools::select_active_window*;
+    miral::WindowManagerTools::set_state*;
+    miral::WindowManagerTools::window_at*;
+    miral::WindowSpecification::?WindowSpecification*;
+    miral::WindowSpecification::WindowSpecification*;
+    miral::WindowSpecification::aux_rect*;
+    miral::WindowSpecification::buffer_usage*;
+    miral::WindowSpecification::content_id*;
+    miral::WindowSpecification::edge_attachment*;
+    miral::WindowSpecification::height_inc*;
+    miral::WindowSpecification::input_mode*;
+    miral::WindowSpecification::input_shape*;
+    miral::WindowSpecification::max_aspect*;
+    miral::WindowSpecification::max_height*;
+    miral::WindowSpecification::max_width*;
+    miral::WindowSpecification::min_aspect*;
+    miral::WindowSpecification::min_height*;
+    miral::WindowSpecification::min_width*;
+    miral::WindowSpecification::name*;
+    miral::WindowSpecification::operator*;
+    miral::WindowSpecification::output_id*;
+    miral::WindowSpecification::parent*;
+    miral::WindowSpecification::pixel_format*;
+    miral::WindowSpecification::preferred_orientation*;
+    miral::WindowSpecification::shell_chrome*;
+    miral::WindowSpecification::size*;
+    miral::WindowSpecification::state*;
+    miral::WindowSpecification::streams*;
+    miral::WindowSpecification::top_left*;
+    miral::WindowSpecification::type*;
+    miral::WindowSpecification::update*;
+    miral::WindowSpecification::width_inc*;
+    miral::display_configuration_options*;
+    miral::equivalent_display_area*;
+    miral::kill*;
+    miral::operator*;
+    miral::toolkit::Connection::Connection*;
+    non-virtual?thunk?to?miral::ActiveOutputsListener::?ActiveOutputsListener*;
+    non-virtual?thunk?to?miral::ActiveOutputsListener::advise_output_begin*;
+    non-virtual?thunk?to?miral::ActiveOutputsListener::advise_output_create*;
+    non-virtual?thunk?to?miral::ActiveOutputsListener::advise_output_delete*;
+    non-virtual?thunk?to?miral::ActiveOutputsListener::advise_output_end*;
+    non-virtual?thunk?to?miral::ActiveOutputsListener::advise_output_update*;
+    non-virtual?thunk?to?miral::ApplicationAuthorizer::?ApplicationAuthorizer*;
+    non-virtual?thunk?to?miral::CanonicalWindowManagerPolicy::advise_focus_gained*;
+    non-virtual?thunk?to?miral::CanonicalWindowManagerPolicy::handle_modify_window*;
+    non-virtual?thunk?to?miral::CanonicalWindowManagerPolicy::handle_raise_window*;
+    non-virtual?thunk?to?miral::CanonicalWindowManagerPolicy::handle_window_ready*;
+    non-virtual?thunk?to?miral::CanonicalWindowManagerPolicy::place_new_surface*;
+    non-virtual?thunk?to?miral::WindowManagementPolicy::?WindowManagementPolicy*;
+    non-virtual?thunk?to?miral::WindowManagementPolicy::advise_begin*;
+    non-virtual?thunk?to?miral::WindowManagementPolicy::advise_delete_app*;
+    non-virtual?thunk?to?miral::WindowManagementPolicy::advise_delete_window*;
+    non-virtual?thunk?to?miral::WindowManagementPolicy::advise_end*;
+    non-virtual?thunk?to?miral::WindowManagementPolicy::advise_focus_gained*;
+    non-virtual?thunk?to?miral::WindowManagementPolicy::advise_focus_lost*;
+    non-virtual?thunk?to?miral::WindowManagementPolicy::advise_move_to*;
+    non-virtual?thunk?to?miral::WindowManagementPolicy::advise_new_app*;
+    non-virtual?thunk?to?miral::WindowManagementPolicy::advise_new_window*;
+    non-virtual?thunk?to?miral::WindowManagementPolicy::advise_raise*;
+    non-virtual?thunk?to?miral::WindowManagementPolicy::advise_resize*;
+    non-virtual?thunk?to?miral::WindowManagementPolicy::advise_state_change*;
+    typeinfo?for?miral::ActiveOutputsListener;
+    typeinfo?for?miral::ActiveOutputsMonitor;
+    typeinfo?for?miral::ApplicationAuthorizer;
+    typeinfo?for?miral::ApplicationCredentials;
+    typeinfo?for?miral::ApplicationInfo;
+    typeinfo?for?miral::BasicSetApplicationAuthorizer;
+    typeinfo?for?miral::CanonicalWindowManagerPolicy;
+    typeinfo?for?miral::InternalClientLauncher;
+    typeinfo?for?miral::MirRunner;
+    typeinfo?for?miral::Output;
+    typeinfo?for?miral::Output::PhysicalSizeMM;
+    typeinfo?for?miral::QuitOnCtrlAltBkSp;
+    typeinfo?for?miral::SetWindowManagmentPolicy;
+    typeinfo?for?miral::StartupInternalClient;
+    typeinfo?for?miral::StreamSpecification;
+    typeinfo?for?miral::Window;
+    typeinfo?for?miral::WindowInfo;
+    typeinfo?for?miral::WindowManagementPolicy;
+    typeinfo?for?miral::WindowManagerOption;
+    typeinfo?for?miral::WindowManagerOptions;
+    typeinfo?for?miral::WindowManagerTools;
+    typeinfo?for?miral::WindowSpecification;
+    typeinfo?for?miral::WindowSpecification::AspectRatio;
+    typeinfo?for?miral::toolkit::Connection;
+    typeinfo?for?miral::toolkit::SurfaceSpec;
+    vtable?for?miral::ActiveOutputsListener;
+    vtable?for?miral::ActiveOutputsMonitor;
+    vtable?for?miral::ApplicationAuthorizer;
+    vtable?for?miral::ApplicationCredentials;
+    vtable?for?miral::ApplicationInfo;
+    vtable?for?miral::BasicSetApplicationAuthorizer;
+    vtable?for?miral::CanonicalWindowManagerPolicy;
+    vtable?for?miral::InternalClientLauncher;
+    vtable?for?miral::MirRunner;
+    vtable?for?miral::Output;
+    vtable?for?miral::Output::PhysicalSizeMM;
+    vtable?for?miral::QuitOnCtrlAltBkSp;
+    vtable?for?miral::SetWindowManagmentPolicy;
+    vtable?for?miral::StartupInternalClient;
+    vtable?for?miral::StreamSpecification;
+    vtable?for?miral::Window;
+    vtable?for?miral::WindowInfo;
+    vtable?for?miral::WindowManagementPolicy;
+    vtable?for?miral::WindowManagerOption;
+    vtable?for?miral::WindowManagerOptions;
+    vtable?for?miral::WindowManagerTools;
+    vtable?for?miral::WindowSpecification;
+    vtable?for?miral::WindowSpecification::AspectRatio;
+    vtable?for?miral::toolkit::Connection;
+    vtable?for?miral::toolkit::SurfaceSpec;
+  };
+local: *;
+};

=== added file 'scripts/process_doxygen_xml.py'
--- scripts/process_doxygen_xml.py	1970-01-01 00:00:00 +0000
+++ scripts/process_doxygen_xml.py	2016-08-02 09:11:08 +0000
@@ -0,0 +1,194 @@
+#! /usr/bin/python
+from xml.dom import minidom
+from sys import argv
+
+helptext = \
+"""This script processes the XML generated by "make doc" and produces summary information
+on symbols that libmiral intends to make public.
+
+To use:
+
+1. Go to your build folder and run "make doc"
+2. Create symbols.map by running "../scripts/process_doxygen_xml.py doc/xml/*.xml > ../miral/symbols.map\""""
+
+debug = False
+
+def get_text(node):
+    rc = []
+    for node in node.childNodes:
+        if node.nodeType == node.TEXT_NODE:
+            rc.append(node.data)
+        elif node.nodeType == node.ELEMENT_NODE:
+            rc.append(get_text(node))
+    return ''.join(rc)
+
+def get_text_for_element(parent, tagname):
+    rc = []
+    nodes = parent.getElementsByTagName(tagname);
+    for node in nodes : rc.append(get_text(node))
+    return ''.join(rc)
+
+def get_file_location(node):
+    for node in node.childNodes:
+        if node.nodeType == node.ELEMENT_NODE and node.tagName == 'location':
+            return node.attributes['file'].value
+    if debug: print 'no location in:', node
+    return None
+    
+def has_element(node, tagname):
+    for node in node.childNodes:
+        if node.nodeType == node.ELEMENT_NODE and node.tagName in tagname:
+            return True
+    return False
+
+def print_attribs(node, attribs):
+    for attrib in attribs : print ' ', attrib, '=', node.attributes[attrib].value
+
+def concat_text_from_tags(parent, tagnames):
+    rc = []
+    for tag in tagnames : rc.append(get_text_for_element(parent, tag))
+    return ''.join(rc)
+    
+def print_location(node):
+    print ' ', 'location', '=', get_file_location(node)
+
+def get_attribs(node):
+    kind = node.attributes['kind'].value
+    static = node.attributes['static'].value
+    prot =  node.attributes['prot'].value
+    return (kind, static, prot)
+
+# Special cases for publishing anyway:
+publish_special_cases = {}
+
+component_map = {}
+symbols = {'public' : set(), 'private' : set()}
+
+def report(publish, symbol):
+    symbol = symbol.replace('~', '?')
+
+    if symbol in publish_special_cases: publish = True
+
+    if publish: symbols['public'].add(symbol)
+    else:       symbols['private'].add(symbol)
+
+    if not debug: return
+    if publish: print '  PUBLISH: {}'.format(symbol)
+    else      : print 'NOPUBLISH: {}'.format(symbol)
+
+def print_report():
+    print 'MIRAL_0.1 {'
+    print 'global:'
+    print '  extern "C++" {'
+    for symbol in sorted(symbols['public']): print '    {};'.format(symbol)
+    print '  };'
+    print 'local: *;'
+    print '};'
+
+def print_debug_info(node, attributes):
+    if not debug: return
+    print
+    print_attribs(node, attributes)
+    print_location(node)
+
+def find_physical_component(location_file):
+    path_elements = location_file.split('/')
+    found = False
+    for element in path_elements:
+        if found: return element
+        found = element in ['include', 'src']
+    if debug: print 'no component in:', location_file
+    return None
+    
+def parse_member_def(context_name, node, is_class):
+    (kind, static, prot) = get_attribs(node)
+    
+    if kind in ['enum', 'typedef']: return
+    if has_element(node, ['templateparamlist']): return
+    if kind in ['function'] and node.attributes['inline'].value == 'yes': return
+    
+    name = concat_text_from_tags(node, ['name'])
+    if name in ['__attribute__']:
+        if debug: print '  ignoring doxygen mis-parsing:', concat_text_from_tags(node, ['argsstring'])
+        return
+
+    if name.startswith('operator'): name = 'operator'
+    if not context_name == None: symbol = context_name + '::' + name
+    else: symbol = name
+
+    publish = True
+
+    is_function = kind == 'function'
+    if publish: publish = kind != 'define'
+    if publish and is_class: publish = is_function or static == 'yes'
+    if publish and prot == 'private':
+        if is_function: publish = node.attributes['virt'].value == 'virtual'
+        else: publish =  False
+
+    if publish and has_element(node, ['argsstring']): 
+        publish = not get_text_for_element(node, 'argsstring').endswith('=0')
+    
+    if is_function: print_debug_info(node, ['kind', 'prot', 'static', 'virt'])
+    else: print_debug_info(node, ['kind', 'prot', 'static'])
+    if debug: print '  is_class:', is_class
+    report(publish, symbol + '*')
+    if is_function and node.attributes['virt'].value == 'virtual': report(publish,
+                                                                          'non-virtual?thunk?to?' + symbol + '*')
+
+def parse_compound_defs(xmldoc):
+    compounddefs = xmldoc.getElementsByTagName('compounddef') 
+    for node in compounddefs:
+        kind = node.attributes['kind'].value
+
+        if kind in ['page', 'file', 'example', 'union']: continue
+
+        if kind in ['group']: 
+            for member in node.getElementsByTagName('memberdef') : 
+                parse_member_def(None, member, False)
+            continue
+
+        if kind in ['namespace']: 
+            symbol = concat_text_from_tags(node, ['compoundname'])
+            for member in node.getElementsByTagName('memberdef') : 
+                parse_member_def(symbol, member, False)
+            continue
+        
+        file = get_file_location(node)
+        if debug: print '  from file:', file 
+        if '/examples/' in file or '/test/' in file or '[generated]' in file or '[STL]' in file:
+            continue
+
+        if has_element(node, ['templateparamlist']): continue
+
+        symbol = concat_text_from_tags(node, ['compoundname'])
+        
+        publish = True
+
+        if publish: 
+            if kind in ['class', 'struct']:
+                prot =  node.attributes['prot'].value
+                publish = prot != 'private'
+                print_debug_info(node, ['kind', 'prot'])
+                report(publish, 'vtable?for?' + symbol)
+                report(publish, 'typeinfo?for?' + symbol)
+
+        if publish: 
+            for member in node.getElementsByTagName('memberdef') : 
+                parse_member_def(symbol, member, kind in ['class', 'struct'])
+
+if __name__ == "__main__":
+    if len(argv) == 1 or '-h' in argv or '--help' in argv:
+        print helptext
+        exit()
+
+    for arg in argv[1:]:
+        try:
+            if debug: print 'Processing:', arg
+            xmldoc = minidom.parse(arg)
+            parse_compound_defs(xmldoc)
+        except Exception as error:
+            print 'Error:', arg, error
+
+    if debug: print 'Processing complete'
+
+    print_report()

=== modified file 'test/CMakeLists.txt'
--- test/CMakeLists.txt	2016-08-01 11:48:04 +0000
+++ test/CMakeLists.txt	2016-08-02 09:11:08 +0000
@@ -17,6 +17,7 @@
     ${GMOCK_LIBRARY}
     ${GMOCK_MAIN_LIBRARY}
     miral
+    miral-internal
 )
 
 add_dependencies(miral-test GMock)