bfa209dfa5
Only re-enable exceptions for the modules that do CONFIG+=exceptions in qmake Change-Id: I9f19078adbdc1b8fa3d4102fb51a099e7e35522e Reviewed-by: Simon Hausmann <simon.hausmann@qt.io>
1896 lines
70 KiB
Python
Executable File
1896 lines
70 KiB
Python
Executable File
#!/usr/bin/env python3
|
|
#############################################################################
|
|
##
|
|
## Copyright (C) 2018 The Qt Company Ltd.
|
|
## Contact: https://www.qt.io/licensing/
|
|
##
|
|
## This file is part of the plugins of the Qt Toolkit.
|
|
##
|
|
## $QT_BEGIN_LICENSE:GPL-EXCEPT$
|
|
## Commercial License Usage
|
|
## Licensees holding valid commercial Qt licenses may use this file in
|
|
## accordance with the commercial license agreement provided with the
|
|
## Software or, alternatively, in accordance with the terms contained in
|
|
## a written agreement between you and The Qt Company. For licensing terms
|
|
## and conditions see https://www.qt.io/terms-conditions. For further
|
|
## information use the contact form at https://www.qt.io/contact-us.
|
|
##
|
|
## GNU General Public License Usage
|
|
## Alternatively, this file may be used under the terms of the GNU
|
|
## General Public License version 3 as published by the Free Software
|
|
## Foundation with exceptions as appearing in the file LICENSE.GPL3-EXCEPT
|
|
## included in the packaging of this file. Please review the following
|
|
## information to ensure the GNU General Public License requirements will
|
|
## be met: https://www.gnu.org/licenses/gpl-3.0.html.
|
|
##
|
|
## $QT_END_LICENSE$
|
|
##
|
|
#############################################################################
|
|
|
|
|
|
from __future__ import annotations
|
|
|
|
from argparse import ArgumentParser
|
|
import copy
|
|
import xml.etree.ElementTree as ET
|
|
from itertools import chain
|
|
import os.path
|
|
import re
|
|
import io
|
|
import typing
|
|
|
|
from sympy.logic import (simplify_logic, And, Or, Not,)
|
|
import pyparsing as pp
|
|
from helper import _set_up_py_parsing_nicer_debug_output
|
|
_set_up_py_parsing_nicer_debug_output(pp)
|
|
|
|
from helper import map_qt_library, map_3rd_party_library, is_known_3rd_party_library, \
|
|
featureName, map_platform, find_library_info_for_target, generate_find_package_info, \
|
|
LibraryMapping
|
|
|
|
from shutil import copyfile
|
|
from special_case_helper import SpecialCaseHandler
|
|
|
|
|
|
def _parse_commandline():
|
|
parser = ArgumentParser(description='Generate CMakeLists.txt files from .'
|
|
'pro files.')
|
|
parser.add_argument('--debug', dest='debug', action='store_true',
|
|
help='Turn on all debug output')
|
|
parser.add_argument('--debug-parser', dest='debug_parser',
|
|
action='store_true',
|
|
help='Print debug output from qmake parser.')
|
|
parser.add_argument('--debug-parse-result', dest='debug_parse_result',
|
|
action='store_true',
|
|
help='Dump the qmake parser result.')
|
|
parser.add_argument('--debug-parse-dictionary',
|
|
dest='debug_parse_dictionary', action='store_true',
|
|
help='Dump the qmake parser result as dictionary.')
|
|
parser.add_argument('--debug-pro-structure', dest='debug_pro_structure',
|
|
action='store_true',
|
|
help='Dump the structure of the qmake .pro-file.')
|
|
parser.add_argument('--debug-full-pro-structure',
|
|
dest='debug_full_pro_structure', action='store_true',
|
|
help='Dump the full structure of the qmake .pro-file '
|
|
'(with includes).')
|
|
parser.add_argument('--debug-special-case-preservation',
|
|
dest='debug_special_case_preservation', action='store_true',
|
|
help='Show all git commands and file copies.')
|
|
|
|
parser.add_argument('--is-example', action='store_true',
|
|
dest="is_example",
|
|
help='Treat the input .pro file as an example.')
|
|
parser.add_argument('-s', '--skip-special-case-preservation',
|
|
dest='skip_special_case_preservation', action='store_true',
|
|
help='Skips behavior to reapply '
|
|
'special case modifications (requires git in PATH)')
|
|
parser.add_argument('-k', '--keep-temporary-files',
|
|
dest='keep_temporary_files', action='store_true',
|
|
help='Don\'t automatically remove CMakeLists.gen.txt and other '
|
|
'intermediate files.')
|
|
|
|
parser.add_argument('files', metavar='<.pro/.pri file>', type=str,
|
|
nargs='+', help='The .pro/.pri file to process')
|
|
|
|
return parser.parse_args()
|
|
|
|
|
|
def process_qrc_file(target: str, filepath: str, base_dir: str = '') -> str:
|
|
assert(target)
|
|
resource_name = os.path.splitext(os.path.basename(filepath))[0]
|
|
base_dir = os.path.join('' if base_dir == '.' else base_dir, os.path.dirname(filepath))
|
|
|
|
tree = ET.parse(filepath)
|
|
root = tree.getroot()
|
|
assert(root.tag == 'RCC')
|
|
|
|
output = ''
|
|
|
|
resource_count = 0
|
|
for resource in root:
|
|
assert(resource.tag == 'qresource')
|
|
lang = resource.get('lang', '')
|
|
prefix = resource.get('prefix', '')
|
|
|
|
full_resource_name = resource_name + (str(resource_count) if resource_count > 0 else '')
|
|
|
|
files: typing.Dict[str, str] = {}
|
|
for file in resource:
|
|
path = file.text
|
|
assert path
|
|
|
|
# Get alias:
|
|
alias = file.get('alias', '')
|
|
files[path] = alias
|
|
|
|
sorted_files = sorted(files.keys())
|
|
|
|
assert(sorted_files)
|
|
|
|
for source in sorted_files:
|
|
alias = files[source]
|
|
if alias:
|
|
full_source = os.path.join(base_dir, source)
|
|
output += 'set_source_files_properties("{}"\n' \
|
|
' PROPERTIES alias "{}")\n'.format(full_source, alias)
|
|
|
|
params = ''
|
|
if lang:
|
|
params += ' LANG "{}"'.format(lang)
|
|
if prefix:
|
|
params += ' PREFIX "{}"'.format(prefix)
|
|
if base_dir:
|
|
params += ' BASE "{}"'.format(base_dir)
|
|
output += 'add_qt_resource({} "{}"{} FILES\n {})\n'.format(target, full_resource_name,
|
|
params,
|
|
'\n '.join(sorted_files))
|
|
|
|
resource_count += 1
|
|
|
|
return output
|
|
|
|
|
|
def fixup_linecontinuation(contents: str) -> str:
|
|
# Remove all line continuations, aka a backslash followed by
|
|
# a newline character with an arbitrary amount of whitespace
|
|
# between the backslash and the newline.
|
|
# This greatly simplifies the qmake parsing grammar.
|
|
contents = re.sub(r'([^\t ])\\[ \t]*\n', '\\1 ', contents)
|
|
contents = re.sub(r'\\[ \t]*\n', '', contents)
|
|
return contents
|
|
|
|
|
|
def fixup_comments(contents: str) -> str:
|
|
# Get rid of completely commented out lines.
|
|
# So any line which starts with a '#' char and ends with a new line
|
|
# will be replaced by a single new line.
|
|
#
|
|
# This is needed because qmake syntax is weird. In a multi line
|
|
# assignment (separated by backslashes and newlines aka
|
|
# # \\\n ), if any of the lines are completely commented out, in
|
|
# principle the assignment should fail.
|
|
#
|
|
# It should fail because you would have a new line separating
|
|
# the previous value from the next value, and the next value would
|
|
# not be interpreted as a value, but as a new token / operation.
|
|
# qmake is lenient though, and accepts that, so we need to take
|
|
# care of it as well, as if the commented line didn't exist in the
|
|
# first place.
|
|
|
|
contents = re.sub(r'\n#[^\n]*?\n', '\n', contents, re.DOTALL)
|
|
return contents
|
|
|
|
|
|
def spaces(indent: int) -> str:
|
|
return ' ' * indent
|
|
|
|
|
|
def trim_leading_dot(file: str) -> str:
|
|
while file.startswith('./'):
|
|
file = file[2:]
|
|
return file
|
|
|
|
|
|
def map_to_file(f: str, scope: Scope, *, is_include: bool = False) -> str:
|
|
assert('$$' not in f)
|
|
|
|
if f.startswith('${'): # Some cmake variable is prepended
|
|
return f
|
|
|
|
base_dir = scope.currentdir if is_include else scope.basedir
|
|
f = os.path.join(base_dir, f)
|
|
|
|
return trim_leading_dot(f)
|
|
|
|
|
|
def handle_vpath(source: str, base_dir: str, vpath: typing.List[str]) -> str:
|
|
assert('$$' not in source)
|
|
|
|
if not source:
|
|
return ''
|
|
|
|
if not vpath:
|
|
return source
|
|
|
|
if os.path.exists(os.path.join(base_dir, source)):
|
|
return source
|
|
|
|
variable_pattern = re.compile(r'\$\{[A-Za-z0-9_]+\}')
|
|
match = re.match(variable_pattern, source)
|
|
if match:
|
|
# a complex, variable based path, skipping validation
|
|
# or resolving
|
|
return source
|
|
|
|
for v in vpath:
|
|
fullpath = os.path.join(v, source)
|
|
if os.path.exists(fullpath):
|
|
return trim_leading_dot(os.path.relpath(fullpath, base_dir))
|
|
|
|
print(' XXXX: Source {}: Not found.'.format(source))
|
|
return '{}-NOTFOUND'.format(source)
|
|
|
|
|
|
class Operation:
|
|
def __init__(self, value: typing.Union[typing.List[str], str]):
|
|
if isinstance(value, list):
|
|
self._value = value
|
|
else:
|
|
self._value = [str(value), ]
|
|
|
|
def process(self, key: str, input: typing.List[str],
|
|
transformer: typing.Callable[[typing.List[str]], typing.List[str]]) -> typing.List[str]:
|
|
assert(False)
|
|
|
|
def __repr__(self):
|
|
assert(False)
|
|
|
|
def _dump(self):
|
|
if not self._value:
|
|
return '<NOTHING>'
|
|
|
|
if not isinstance(self._value, list):
|
|
return '<NOT A LIST>'
|
|
|
|
result = []
|
|
for i in self._value:
|
|
if not i:
|
|
result.append('<NONE>')
|
|
else:
|
|
result.append(str(i))
|
|
return '"' + '", "'.join(result) + '"'
|
|
|
|
|
|
class AddOperation(Operation):
|
|
def process(self, key: str, input: typing.List[str],
|
|
transformer: typing.Callable[[typing.List[str]], typing.List[str]]) -> typing.List[str]:
|
|
return input + transformer(self._value)
|
|
|
|
def __repr__(self):
|
|
return '+({})'.format(self._dump())
|
|
|
|
|
|
class UniqueAddOperation(Operation):
|
|
def process(self, key: str, input: typing.List[str],
|
|
transformer: typing.Callable[[typing.List[str]], typing.List[str]]) -> typing.List[str]:
|
|
result = input
|
|
for v in transformer(self._value):
|
|
if v not in result:
|
|
result.append(v)
|
|
return result
|
|
|
|
def __repr__(self):
|
|
return '*({})'.format(self._dump())
|
|
|
|
|
|
class SetOperation(Operation):
|
|
def process(self, key: str, input: typing.List[str],
|
|
transformer: typing.Callable[[typing.List[str]], typing.List[str]]) -> typing.List[str]:
|
|
values = [] # typing.List[str]
|
|
for v in self._value:
|
|
if v != '$${}'.format(key):
|
|
values.append(v)
|
|
else:
|
|
values += input
|
|
|
|
if transformer:
|
|
return list(transformer(values))
|
|
else:
|
|
return values
|
|
|
|
def __repr__(self):
|
|
return '=({})'.format(self._dump())
|
|
|
|
|
|
class RemoveOperation(Operation):
|
|
def __init__(self, value):
|
|
super().__init__(value)
|
|
|
|
def process(self, key: str, input: typing.List[str],
|
|
transformer: typing.Callable[[typing.List[str]], typing.List[str]]) -> typing.List[str]:
|
|
input_set = set(input)
|
|
value_set = set(self._value)
|
|
result = []
|
|
|
|
# Add everything that is not going to get removed:
|
|
for v in input:
|
|
if v not in value_set:
|
|
result += [v,]
|
|
|
|
# Add everything else with removal marker:
|
|
for v in transformer(self._value):
|
|
if v not in input_set:
|
|
result += ['-{}'.format(v), ]
|
|
|
|
return result
|
|
|
|
def __repr__(self):
|
|
return '-({})'.format(self._dump())
|
|
|
|
|
|
class Scope(object):
|
|
|
|
SCOPE_ID: int = 1
|
|
|
|
def __init__(self, *,
|
|
parent_scope: typing.Optional[Scope],
|
|
file: typing.Optional[str] = None, condition: str = '',
|
|
base_dir: str = '',
|
|
operations: typing.Mapping[str, typing.List[Operation]] = {
|
|
'QT_SOURCE_TREE': [SetOperation(['${PROJECT_SOURCE_DIR}'])],
|
|
'QT_BUILD_TREE': [SetOperation(['${PROJECT_BUILD_DIR}'])],
|
|
}) -> None:
|
|
if parent_scope:
|
|
parent_scope._add_child(self)
|
|
else:
|
|
self._parent = None # type: typing.Optional[Scope]
|
|
|
|
self._basedir = base_dir
|
|
if file:
|
|
self._currentdir = os.path.dirname(file)
|
|
if not self._currentdir:
|
|
self._currentdir = '.'
|
|
if not self._basedir:
|
|
self._basedir = self._currentdir
|
|
|
|
self._scope_id = Scope.SCOPE_ID
|
|
Scope.SCOPE_ID += 1
|
|
self._file = file
|
|
self._condition = map_condition(condition)
|
|
self._children = [] # type: typing.List[Scope]
|
|
self._included_children = [] # type: typing.List[Scope]
|
|
self._operations = copy.deepcopy(operations)
|
|
self._visited_keys = set() # type: typing.Set[str]
|
|
self._total_condition = None # type: typing.Optional[str]
|
|
|
|
def __repr__(self):
|
|
return '{}:{}:{}:{}:{}'.format(self._scope_id,
|
|
self._basedir, self._currentdir,
|
|
self._file, self._condition or '<TRUE>')
|
|
|
|
def reset_visited_keys(self):
|
|
self._visited_keys = set()
|
|
|
|
def merge(self, other: 'Scope') -> None:
|
|
assert self != other
|
|
self._included_children.append(other)
|
|
|
|
@property
|
|
def scope_debug(self) -> bool:
|
|
merge = self.get_string('PRO2CMAKE_SCOPE_DEBUG').lower()
|
|
return merge == '1' or merge == 'on' or merge == 'yes' or merge == 'true'
|
|
|
|
@property
|
|
def parent(self) -> typing.Optional[Scope]:
|
|
return self._parent
|
|
|
|
@property
|
|
def basedir(self) -> str:
|
|
return self._basedir
|
|
|
|
@property
|
|
def currentdir(self) -> str:
|
|
return self._currentdir
|
|
|
|
def can_merge_condition(self):
|
|
if self._condition == 'else':
|
|
return False
|
|
if self._operations:
|
|
return False
|
|
|
|
child_count = len(self._children)
|
|
if child_count == 0 or child_count > 2:
|
|
return False
|
|
assert child_count != 1 or self._children[0]._condition != 'else'
|
|
return child_count == 1 or self._children[1]._condition == 'else'
|
|
|
|
def settle_condition(self):
|
|
new_children: typing.List[Scope] = []
|
|
for c in self._children:
|
|
c.settle_condition()
|
|
|
|
if c.can_merge_condition():
|
|
child = c._children[0]
|
|
child._condition = '({}) AND ({})'.format(c._condition, child._condition)
|
|
new_children += c._children
|
|
else:
|
|
new_children.append(c)
|
|
self._children = new_children
|
|
|
|
@staticmethod
|
|
def FromDict(parent_scope: typing.Optional['Scope'],
|
|
file: str, statements, cond: str = '', base_dir: str = '') -> Scope:
|
|
scope = Scope(parent_scope=parent_scope, file=file, condition=cond, base_dir=base_dir)
|
|
for statement in statements:
|
|
if isinstance(statement, list): # Handle skipped parts...
|
|
assert not statement
|
|
continue
|
|
|
|
operation = statement.get('operation', None)
|
|
if operation:
|
|
key = statement.get('key', '')
|
|
value = statement.get('value', [])
|
|
assert key != ''
|
|
|
|
if operation == '=':
|
|
scope._append_operation(key, SetOperation(value))
|
|
elif operation == '-=':
|
|
scope._append_operation(key, RemoveOperation(value))
|
|
elif operation == '+=':
|
|
scope._append_operation(key, AddOperation(value))
|
|
elif operation == '*=':
|
|
scope._append_operation(key, UniqueAddOperation(value))
|
|
else:
|
|
print('Unexpected operation "{}" in scope "{}".'
|
|
.format(operation, scope))
|
|
assert(False)
|
|
|
|
continue
|
|
|
|
condition = statement.get('condition', None)
|
|
if condition:
|
|
Scope.FromDict(scope, file,
|
|
statement.get('statements'), condition,
|
|
scope.basedir)
|
|
|
|
else_statements = statement.get('else_statements')
|
|
if else_statements:
|
|
Scope.FromDict(scope, file, else_statements,
|
|
'else', scope.basedir)
|
|
continue
|
|
|
|
loaded = statement.get('loaded')
|
|
if loaded:
|
|
scope._append_operation('_LOADED', UniqueAddOperation(loaded))
|
|
continue
|
|
|
|
option = statement.get('option', None)
|
|
if option:
|
|
scope._append_operation('_OPTION', UniqueAddOperation(option))
|
|
continue
|
|
|
|
included = statement.get('included', None)
|
|
if included:
|
|
scope._append_operation('_INCLUDED',
|
|
UniqueAddOperation(included))
|
|
continue
|
|
|
|
scope.settle_condition()
|
|
|
|
if scope.scope_debug:
|
|
print('..... [SCOPE_DEBUG]: Created scope {}:'.format(scope))
|
|
scope.dump(indent=1)
|
|
print('..... [SCOPE_DEBUG]: <<END OF SCOPE>>')
|
|
return scope
|
|
|
|
def _append_operation(self, key: str, op: Operation) -> None:
|
|
if key in self._operations:
|
|
self._operations[key].append(op)
|
|
else:
|
|
self._operations[key] = [op, ]
|
|
|
|
@property
|
|
def file(self) -> str:
|
|
return self._file or ''
|
|
|
|
@property
|
|
def generated_cmake_lists_path(self) -> str:
|
|
assert self.basedir
|
|
return os.path.join(self.basedir, 'CMakeLists.gen.txt')
|
|
|
|
@property
|
|
def original_cmake_lists_path(self) -> str:
|
|
assert self.basedir
|
|
return os.path.join(self.basedir, 'CMakeLists.txt')
|
|
|
|
@property
|
|
def condition(self) -> str:
|
|
return self._condition
|
|
|
|
@property
|
|
def total_condition(self) -> typing.Optional[str]:
|
|
return self._total_condition
|
|
|
|
@total_condition.setter
|
|
def total_condition(self, condition: str) -> None:
|
|
self._total_condition = condition
|
|
|
|
def _add_child(self, scope: 'Scope') -> None:
|
|
scope._parent = self
|
|
self._children.append(scope)
|
|
|
|
@property
|
|
def children(self) -> typing.List['Scope']:
|
|
result = list(self._children)
|
|
for include_scope in self._included_children:
|
|
result += include_scope.children
|
|
return result
|
|
|
|
def dump(self, *, indent: int = 0) -> None:
|
|
ind = ' ' * indent
|
|
print('{}Scope "{}":'.format(ind, self))
|
|
if self.total_condition:
|
|
print('{} Total condition = {}'.format(ind, self.total_condition))
|
|
print('{} Keys:'.format(ind))
|
|
keys = self._operations.keys()
|
|
if not keys:
|
|
print('{} -- NONE --'.format(ind))
|
|
else:
|
|
for k in sorted(keys):
|
|
print('{} {} = "{}"'
|
|
.format(ind, k, self._operations.get(k, [])))
|
|
print('{} Children:'.format(ind))
|
|
if not self._children:
|
|
print('{} -- NONE --'.format(ind))
|
|
else:
|
|
for c in self._children:
|
|
c.dump(indent=indent + 1)
|
|
print('{} Includes:'.format(ind))
|
|
if not self._included_children:
|
|
print('{} -- NONE --'.format(ind))
|
|
else:
|
|
for c in self._included_children:
|
|
c.dump(indent=indent + 1)
|
|
|
|
def dump_structure(self, *, type: str = 'ROOT', indent: int = 0) -> None:
|
|
print('{}{}: {}'.format(spaces(indent), type, self))
|
|
for i in self._included_children:
|
|
i.dump_structure(type='INCL', indent=indent + 1)
|
|
for i in self._children:
|
|
i.dump_structure(type='CHLD', indent=indent + 1)
|
|
|
|
@property
|
|
def keys(self):
|
|
return self._operations.keys()
|
|
|
|
@property
|
|
def visited_keys(self):
|
|
return self._visited_keys
|
|
|
|
def _evalOps(self, key: str,
|
|
transformer: typing.Optional[typing.Callable[[Scope, typing.List[str]], typing.List[str]]],
|
|
result: typing.List[str], *, inherrit: bool = False) \
|
|
-> typing.List[str]:
|
|
self._visited_keys.add(key)
|
|
|
|
# Inherrit values from above:
|
|
if self._parent and inherrit:
|
|
result = self._parent._evalOps(key, transformer, result)
|
|
|
|
if transformer:
|
|
op_transformer = lambda files: transformer(self, files)
|
|
else:
|
|
op_transformer = lambda files: files
|
|
|
|
for op in self._operations.get(key, []):
|
|
result = op.process(key, result, op_transformer)
|
|
|
|
for ic in self._included_children:
|
|
result = list(ic._evalOps(key, transformer, result))
|
|
|
|
return result
|
|
|
|
def get(self, key: str, *, ignore_includes: bool = False, inherrit: bool = False) -> typing.List[str]:
|
|
|
|
is_same_path = self.currentdir == self.basedir
|
|
|
|
if key == 'PWD':
|
|
if is_same_path:
|
|
return ['${CMAKE_CURRENT_SOURCE_DIR}']
|
|
else:
|
|
return ['${CMAKE_CURRENT_SOURCE_DIR}/' + os.path.relpath(self.currentdir, self.basedir),]
|
|
if key == 'OUT_PWD':
|
|
if is_same_path:
|
|
return ['${CMAKE_CURRENT_BUILD_DIR}']
|
|
else:
|
|
return ['${CMAKE_CURRENT_BUILD_DIR}/' + os.path.relpath(self.currentdir, self.basedir),]
|
|
|
|
return self._evalOps(key, None, [], inherrit=inherrit)
|
|
|
|
def get_string(self, key: str, default: str = '') -> str:
|
|
v = self.get(key)
|
|
if len(v) == 0:
|
|
return default
|
|
assert len(v) == 1
|
|
return v[0]
|
|
|
|
def _map_files(self, files: typing.List[str], *,
|
|
use_vpath: bool = True, is_include: bool = False) -> typing.List[str]:
|
|
|
|
expanded_files = [] # type: typing.List[str]
|
|
for f in files:
|
|
r = self._expand_value(f)
|
|
expanded_files += r
|
|
|
|
mapped_files = list(map(lambda f: map_to_file(f, self, is_include=is_include), expanded_files))
|
|
|
|
if use_vpath:
|
|
result = list(map(lambda f: handle_vpath(f, self.basedir, self.get('VPATH', inherrit=True)), mapped_files))
|
|
else:
|
|
result = mapped_files
|
|
|
|
# strip ${CMAKE_CURRENT_SOURCE_DIR}:
|
|
result = list(map(lambda f: f[28:] if f.startswith('${CMAKE_CURRENT_SOURCE_DIR}/') else f, result))
|
|
|
|
# strip leading ./:
|
|
result = list(map(lambda f: trim_leading_dot(f), result))
|
|
|
|
return result
|
|
|
|
def get_files(self, key: str, *, use_vpath: bool = False,
|
|
is_include: bool = False) -> typing.List[str]:
|
|
transformer = lambda scope, files: scope._map_files(files, use_vpath=use_vpath, is_include=is_include)
|
|
return list(self._evalOps(key, transformer, []))
|
|
|
|
def _expand_value(self, value: str) -> typing.List[str]:
|
|
result = value
|
|
pattern = re.compile(r'\$\$\{?([A-Za-z_][A-Za-z0-9_]*)\}?')
|
|
match = re.search(pattern, result)
|
|
while match:
|
|
old_result = result
|
|
if match.group(0) == value:
|
|
return self.get(match.group(1))
|
|
|
|
replacement = self.get(match.group(1))
|
|
replacement_str = replacement[0] if replacement else ''
|
|
result = result[:match.start()] \
|
|
+ replacement_str \
|
|
+ result[match.end():]
|
|
|
|
if result == old_result:
|
|
return [result,] # Do not go into infinite loop
|
|
|
|
match = re.search(pattern, result)
|
|
return [result,]
|
|
|
|
def expand(self, key: str) -> typing.List[str]:
|
|
value = self.get(key)
|
|
result: typing.List[str] = []
|
|
assert isinstance(value, list)
|
|
for v in value:
|
|
result += self._expand_value(v)
|
|
return result
|
|
|
|
def expandString(self, key: str) -> str:
|
|
result = self._expand_value(self.get_string(key))
|
|
assert len(result) == 1
|
|
return result[0]
|
|
|
|
@property
|
|
def TEMPLATE(self) -> str:
|
|
return self.get_string('TEMPLATE', 'app')
|
|
|
|
def _rawTemplate(self) -> str:
|
|
return self.get_string('TEMPLATE')
|
|
|
|
@property
|
|
def TARGET(self) -> str:
|
|
return self.get_string('TARGET') \
|
|
or os.path.splitext(os.path.basename(self.file))[0]
|
|
|
|
@property
|
|
def _INCLUDED(self) -> typing.List[str]:
|
|
return self.get('_INCLUDED')
|
|
|
|
|
|
class QmakeParser:
|
|
def __init__(self, *, debug: bool = False) -> None:
|
|
self.debug = debug
|
|
self._Grammar = self._generate_grammar()
|
|
|
|
def _generate_grammar(self):
|
|
# Define grammar:
|
|
pp.ParserElement.setDefaultWhitespaceChars(' \t')
|
|
|
|
def add_element(name: str, value: pp.ParserElement):
|
|
nonlocal self
|
|
if self.debug:
|
|
value.setName(name)
|
|
value.setDebug()
|
|
return value
|
|
|
|
EOL = add_element('EOL', pp.Suppress(pp.LineEnd()))
|
|
Else = add_element('Else', pp.Keyword('else'))
|
|
Identifier = add_element('Identifier', pp.Word(pp.alphas + '_',
|
|
bodyChars=pp.alphanums+'_-./'))
|
|
BracedValue = add_element('BracedValue',
|
|
pp.nestedExpr(
|
|
ignoreExpr=pp.quotedString |
|
|
pp.QuotedString(quoteChar='$(',
|
|
endQuoteChar=')',
|
|
escQuote='\\',
|
|
unquoteResults=False)
|
|
).setParseAction(lambda s, l, t: ['(', *t[0], ')']))
|
|
|
|
Substitution \
|
|
= add_element('Substitution',
|
|
pp.Combine(pp.Literal('$')
|
|
+ (((pp.Literal('$') + Identifier
|
|
+ pp.Optional(pp.nestedExpr()))
|
|
| (pp.Literal('(') + Identifier + pp.Literal(')'))
|
|
| (pp.Literal('{') + Identifier + pp.Literal('}'))
|
|
| (pp.Literal('$') + pp.Literal('{')
|
|
+ Identifier + pp.Optional(pp.nestedExpr())
|
|
+ pp.Literal('}'))
|
|
| (pp.Literal('$') + pp.Literal('[') + Identifier
|
|
+ pp.Literal(']'))
|
|
))))
|
|
LiteralValuePart = add_element('LiteralValuePart',
|
|
pp.Word(pp.printables, excludeChars='$#{}()'))
|
|
SubstitutionValue \
|
|
= add_element('SubstitutionValue',
|
|
pp.Combine(pp.OneOrMore(Substitution
|
|
| LiteralValuePart
|
|
| pp.Literal('$'))))
|
|
Value \
|
|
= add_element('Value',
|
|
pp.NotAny(Else | pp.Literal('}') | EOL) \
|
|
+ (pp.QuotedString(quoteChar='"', escChar='\\')
|
|
| SubstitutionValue
|
|
| BracedValue))
|
|
|
|
Values = add_element('Values', pp.ZeroOrMore(Value)('value'))
|
|
|
|
Op = add_element('OP',
|
|
pp.Literal('=') | pp.Literal('-=') | pp.Literal('+=') \
|
|
| pp.Literal('*='))
|
|
|
|
Key = add_element('Key', Identifier)
|
|
|
|
Operation = add_element('Operation', Key('key') + Op('operation') + Values('value'))
|
|
CallArgs = add_element('CallArgs', pp.nestedExpr())
|
|
|
|
def parse_call_args(results):
|
|
out = ''
|
|
for item in chain(*results):
|
|
if isinstance(item, str):
|
|
out += item
|
|
else:
|
|
out += "(" + parse_call_args(item) + ")"
|
|
return out
|
|
|
|
CallArgs.setParseAction(parse_call_args)
|
|
|
|
Load = add_element('Load', pp.Keyword('load') + CallArgs('loaded'))
|
|
Include = add_element('Include', pp.Keyword('include') + CallArgs('included'))
|
|
Option = add_element('Option', pp.Keyword('option') + CallArgs('option'))
|
|
|
|
# ignore the whole thing...
|
|
DefineTestDefinition = add_element(
|
|
'DefineTestDefinition',
|
|
pp.Suppress(pp.Keyword('defineTest') + CallArgs
|
|
+ pp.nestedExpr(opener='{', closer='}', ignoreExpr=pp.LineEnd())))
|
|
|
|
# ignore the whole thing...
|
|
ForLoop = add_element(
|
|
'ForLoop',
|
|
pp.Suppress(pp.Keyword('for') + CallArgs
|
|
+ pp.nestedExpr(opener='{', closer='}', ignoreExpr=pp.LineEnd())))
|
|
|
|
# ignore the whole thing...
|
|
ForLoopSingleLine = add_element(
|
|
'ForLoopSingleLine',
|
|
pp.Suppress(pp.Keyword('for') + CallArgs + pp.Literal(':') + pp.SkipTo(EOL)))
|
|
|
|
# ignore the whole thing...
|
|
FunctionCall = add_element('FunctionCall', pp.Suppress(Identifier + pp.nestedExpr()))
|
|
|
|
Scope = add_element('Scope', pp.Forward())
|
|
|
|
Statement = add_element('Statement',
|
|
pp.Group(Load | Include | Option | ForLoop | ForLoopSingleLine
|
|
| DefineTestDefinition | FunctionCall | Operation))
|
|
StatementLine = add_element('StatementLine', Statement + (EOL | pp.FollowedBy('}')))
|
|
StatementGroup = add_element('StatementGroup',
|
|
pp.ZeroOrMore(StatementLine | Scope | pp.Suppress(EOL)))
|
|
|
|
Block = add_element('Block',
|
|
pp.Suppress('{') + pp.Optional(EOL)
|
|
+ StatementGroup + pp.Optional(EOL)
|
|
+ pp.Suppress('}') + pp.Optional(EOL))
|
|
|
|
ConditionEnd = add_element('ConditionEnd',
|
|
pp.FollowedBy((pp.Optional(pp.White())
|
|
+ (pp.Literal(':')
|
|
| pp.Literal('{')
|
|
| pp.Literal('|')))))
|
|
|
|
ConditionPart1 = add_element('ConditionPart1',
|
|
(pp.Optional('!') + Identifier + pp.Optional(BracedValue)))
|
|
ConditionPart2 = add_element('ConditionPart2', pp.CharsNotIn('#{}|:=\\\n'))
|
|
ConditionPart = add_element(
|
|
'ConditionPart',
|
|
(ConditionPart1 ^ ConditionPart2) + ConditionEnd)
|
|
|
|
ConditionOp = add_element('ConditionOp', pp.Literal('|') ^ pp.Literal(':'))
|
|
ConditionWhiteSpace = add_element('ConditionWhiteSpace',
|
|
pp.Suppress(pp.Optional(pp.White(' '))))
|
|
|
|
ConditionRepeated = add_element('ConditionRepeated',
|
|
pp.ZeroOrMore(ConditionOp
|
|
+ ConditionWhiteSpace + ConditionPart))
|
|
|
|
Condition = add_element('Condition', pp.Combine(ConditionPart + ConditionRepeated))
|
|
Condition.setParseAction(lambda x: ' '.join(x).strip().replace(':', ' && ').strip(' && '))
|
|
|
|
# Weird thing like write_file(a)|error() where error() is the alternative condition
|
|
# which happens to be a function call. In this case there is no scope, but our code expects
|
|
# a scope with a list of statements, so create a fake empty statement.
|
|
ConditionEndingInFunctionCall = add_element(
|
|
'ConditionEndingInFunctionCall', pp.Suppress(ConditionOp) + FunctionCall
|
|
+ pp.Empty().setParseAction(lambda x: [[]])
|
|
.setResultsName('statements'))
|
|
|
|
SingleLineScope = add_element('SingleLineScope',
|
|
pp.Suppress(pp.Literal(':'))
|
|
+ pp.Group(Block | (Statement + EOL))('statements'))
|
|
MultiLineScope = add_element('MultiLineScope', Block('statements'))
|
|
|
|
SingleLineElse = add_element('SingleLineElse',
|
|
pp.Suppress(pp.Literal(':'))
|
|
+ (Scope | Block | (Statement + pp.Optional(EOL))))
|
|
MultiLineElse = add_element('MultiLineElse', Block)
|
|
ElseBranch = add_element('ElseBranch', pp.Suppress(Else) + (SingleLineElse | MultiLineElse))
|
|
|
|
# Scope is already add_element'ed in the forward declaration above.
|
|
Scope <<= \
|
|
pp.Group(Condition('condition')
|
|
+ (SingleLineScope | MultiLineScope | ConditionEndingInFunctionCall)
|
|
+ pp.Optional(ElseBranch)('else_statements'))
|
|
|
|
Grammar = StatementGroup('statements')
|
|
Grammar.ignore(pp.pythonStyleComment())
|
|
|
|
return Grammar
|
|
|
|
def parseFile(self, file: str):
|
|
print('Parsing \"{}\"...'.format(file))
|
|
try:
|
|
with open(file, 'r') as file_fd:
|
|
contents = file_fd.read()
|
|
|
|
old_contents = contents
|
|
contents = fixup_linecontinuation(contents)
|
|
contents = fixup_comments(contents)
|
|
|
|
if old_contents != contents:
|
|
print('Warning: Fixed line continuation in .pro-file!\n'
|
|
' Position information in Parsing output might be wrong!')
|
|
result = self._Grammar.parseString(contents, parseAll=True)
|
|
except pp.ParseException as pe:
|
|
print(pe.line)
|
|
print(' '*(pe.col-1) + '^')
|
|
print(pe)
|
|
raise pe
|
|
return result
|
|
|
|
|
|
def parseProFile(file: str, *, debug=False):
|
|
parser = QmakeParser(debug=debug)
|
|
return parser.parseFile(file)
|
|
|
|
|
|
def map_condition(condition: str) -> str:
|
|
# Some hardcoded cases that are too bothersome to generalize.
|
|
condition = re.sub(r'^qtConfig\(opengl\(es1\|es2\)\?\)$',
|
|
r'QT_FEATURE_opengl OR QT_FEATURE_opengles2 OR QT_FEATURE_opengles3',
|
|
condition)
|
|
condition = re.sub(r'^qtConfig\(opengl\.\*\)$', r'QT_FEATURE_opengl', condition)
|
|
condition = re.sub(r'^win\*$', r'win', condition)
|
|
|
|
def gcc_version_handler(match_obj: re.Match):
|
|
operator = match_obj.group(1)
|
|
version_type = match_obj.group(2)
|
|
if operator == 'equals':
|
|
operator = 'STREQUAL'
|
|
elif operator == 'greaterThan':
|
|
operator = 'STRGREATER'
|
|
elif operator == 'lessThan':
|
|
operator = 'STRLESS'
|
|
|
|
version = match_obj.group(3)
|
|
return '(QT_COMPILER_VERSION_{} {} {})'.format(version_type, operator, version)
|
|
|
|
# TODO: Possibly fix for other compilers.
|
|
pattern = r'(equals|greaterThan|lessThan)\(QT_GCC_([A-Z]+)_VERSION,[ ]*([0-9]+)\)'
|
|
condition = re.sub(pattern, gcc_version_handler, condition)
|
|
|
|
# TODO: the current if(...) replacement makes the parentheses
|
|
# unbalanced when there are nested expressions.
|
|
# Need to fix this either with pypi regex recursive regexps,
|
|
# using pyparsing, or some other proper means of handling
|
|
# balanced parentheses.
|
|
condition = re.sub(r'\bif\s*\((.*?)\)', r'\1', condition)
|
|
|
|
condition = re.sub(r'\bisEmpty\s*\((.*?)\)', r'\1_ISEMPTY', condition)
|
|
condition = re.sub(r'\bcontains\s*\((.*?),\s*"?(.*?)"?\)',
|
|
r'\1___contains___\2', condition)
|
|
condition = re.sub(r'\bequals\s*\((.*?),\s*"?(.*?)"?\)',
|
|
r'\1___equals___\2', condition)
|
|
condition = re.sub(r'\bisEqual\s*\((.*?),\s*"?(.*?)"?\)',
|
|
r'\1___equals___\2', condition)
|
|
condition = re.sub(r'\s*==\s*', '___STREQUAL___', condition)
|
|
condition = re.sub(r'\bexists\s*\((.*?)\)', r'EXISTS \1', condition)
|
|
|
|
pattern = r'CONFIG\((debug|release),debug\|release\)'
|
|
match_result = re.match(pattern, condition)
|
|
if match_result:
|
|
build_type = match_result.group(1)
|
|
if build_type == 'debug':
|
|
build_type = 'Debug'
|
|
elif build_type == 'release':
|
|
build_type = 'Release'
|
|
condition = re.sub(pattern, '(CMAKE_BUILD_TYPE STREQUAL {})'.format(build_type), condition)
|
|
|
|
condition = condition.replace('*', '_x_')
|
|
condition = condition.replace('.$$', '__ss_')
|
|
condition = condition.replace('$$', '_ss_')
|
|
|
|
condition = condition.replace('!', 'NOT ')
|
|
condition = condition.replace('&&', ' AND ')
|
|
condition = condition.replace('|', ' OR ')
|
|
|
|
cmake_condition = ''
|
|
for part in condition.split():
|
|
# some features contain e.g. linux, that should not be
|
|
# turned upper case
|
|
feature = re.match(r"(qtConfig|qtHaveModule)\(([a-zA-Z0-9_-]+)\)",
|
|
part)
|
|
if feature:
|
|
if (feature.group(1) == "qtHaveModule"):
|
|
part = 'TARGET {}'.format(map_qt_library(feature.group(2)))
|
|
else:
|
|
feature_name = featureName(feature.group(2))
|
|
if feature_name.startswith('system_') and is_known_3rd_party_library(feature_name[7:]):
|
|
part = 'ON'
|
|
elif feature == 'dlopen':
|
|
part = 'ON'
|
|
else:
|
|
part = 'QT_FEATURE_' + feature_name
|
|
else:
|
|
part = map_platform(part)
|
|
|
|
part = part.replace('true', 'ON')
|
|
part = part.replace('false', 'OFF')
|
|
cmake_condition += ' ' + part
|
|
return cmake_condition.strip()
|
|
|
|
|
|
def handle_subdir(scope: Scope, cm_fh: typing.IO[str], *,
|
|
indent: int = 0, is_example: bool=False) -> None:
|
|
ind = ' ' * indent
|
|
for sd in scope.get_files('SUBDIRS'):
|
|
if os.path.isdir(sd):
|
|
cm_fh.write('{}add_subdirectory({})\n'.format(ind, sd))
|
|
elif os.path.isfile(sd):
|
|
subdir_result = parseProFile(sd, debug=False)
|
|
subdir_scope \
|
|
= Scope.FromDict(scope, sd,
|
|
subdir_result.asDict().get('statements'),
|
|
'', scope.basedir)
|
|
|
|
do_include(subdir_scope)
|
|
cmakeify_scope(subdir_scope, cm_fh, indent=indent, is_example=is_example)
|
|
elif sd.startswith('-'):
|
|
cm_fh.write('{}### remove_subdirectory'
|
|
'("{}")\n'.format(ind, sd[1:]))
|
|
else:
|
|
print(' XXXX: SUBDIR {} in {}: Not found.'.format(sd, scope))
|
|
|
|
for c in scope.children:
|
|
cond = c.condition
|
|
if cond == 'else':
|
|
cm_fh.write('\n{}else()\n'.format(ind))
|
|
elif cond:
|
|
cm_fh.write('\n{}if({})\n'.format(ind, cond))
|
|
|
|
handle_subdir(c, cm_fh, indent=indent + 1, is_example=is_example)
|
|
|
|
if cond:
|
|
cm_fh.write('{}endif()\n'.format(ind))
|
|
|
|
|
|
def sort_sources(sources: typing.List[str]) -> typing.List[str]:
|
|
to_sort = {} # type: typing.Dict[str, typing.List[str]]
|
|
for s in sources:
|
|
if s is None:
|
|
continue
|
|
|
|
dir = os.path.dirname(s)
|
|
base = os.path.splitext(os.path.basename(s))[0]
|
|
if base.endswith('_p'):
|
|
base = base[:-2]
|
|
sort_name = os.path.join(dir, base)
|
|
|
|
array = to_sort.get(sort_name, [])
|
|
array.append(s)
|
|
|
|
to_sort[sort_name] = array
|
|
|
|
lines = []
|
|
for k in sorted(to_sort.keys()):
|
|
lines.append(' '.join(sorted(to_sort[k])))
|
|
|
|
return lines
|
|
|
|
|
|
def _map_libraries_to_cmake(libraries: typing.List[str],
|
|
known_libraries: typing.Set[str]) -> typing.List[str]:
|
|
result = [] # type: typing.List[str]
|
|
is_framework = False
|
|
|
|
for l in libraries:
|
|
if l == '-framework':
|
|
is_framework = True
|
|
continue
|
|
if is_framework:
|
|
l = '${FW%s}' % l
|
|
if l.startswith('-l'):
|
|
l = l[2:]
|
|
|
|
if l.startswith('-'):
|
|
l = '# Remove: {}'.format(l[1:])
|
|
else:
|
|
l = map_3rd_party_library(l)
|
|
|
|
if not l or l in result or l in known_libraries:
|
|
continue
|
|
|
|
result.append(l)
|
|
is_framework = False
|
|
|
|
return result
|
|
|
|
|
|
def extract_cmake_libraries(scope: Scope, *, known_libraries: typing.Set[str]=set()) \
|
|
-> typing.Tuple[typing.List[str], typing.List[str]]:
|
|
public_dependencies = [] # type: typing.List[str]
|
|
private_dependencies = [] # type: typing.List[str]
|
|
|
|
for key in ['QMAKE_USE', 'LIBS',]:
|
|
public_dependencies += scope.expand(key)
|
|
for key in ['QMAKE_USE_PRIVATE', 'QMAKE_USE_FOR_PRIVATE', 'LIBS_PRIVATE',]:
|
|
private_dependencies += scope.expand(key)
|
|
|
|
for key in ['QT_FOR_PRIVATE',]:
|
|
private_dependencies += [map_qt_library(q) for q in scope.expand(key)]
|
|
|
|
for key in ['QT',]:
|
|
# Qt public libs: These may include FooPrivate in which case we get
|
|
# a private dependency on FooPrivate as well as a public dependency on Foo
|
|
for lib in scope.expand(key):
|
|
mapped_lib = map_qt_library(lib)
|
|
|
|
if mapped_lib.endswith('Private'):
|
|
private_dependencies.append(mapped_lib)
|
|
public_dependencies.append(mapped_lib[:-7])
|
|
else:
|
|
public_dependencies.append(mapped_lib)
|
|
|
|
return (_map_libraries_to_cmake(public_dependencies, known_libraries),
|
|
_map_libraries_to_cmake(private_dependencies, known_libraries))
|
|
|
|
|
|
def write_header(cm_fh: typing.IO[str], name: str,
|
|
typename: str, *, indent: int = 0):
|
|
cm_fh.write('{}###########################################'
|
|
'##########################\n'.format(spaces(indent)))
|
|
cm_fh.write('{}## {} {}:\n'.format(spaces(indent), name, typename))
|
|
cm_fh.write('{}###########################################'
|
|
'##########################\n\n'.format(spaces(indent)))
|
|
|
|
|
|
def write_scope_header(cm_fh: typing.IO[str], *, indent: int = 0):
|
|
cm_fh.write('\n{}## Scopes:\n'.format(spaces(indent)))
|
|
cm_fh.write('{}###########################################'
|
|
'##########################\n'.format(spaces(indent)))
|
|
|
|
|
|
def write_list(cm_fh: typing.IO[str], entries: typing.List[str],
|
|
cmake_parameter: str,
|
|
indent: int = 0, *,
|
|
header: str = '', footer: str = ''):
|
|
if not entries:
|
|
return
|
|
|
|
ind = spaces(indent)
|
|
extra_indent = ''
|
|
|
|
if header:
|
|
cm_fh.write('{}{}'.format(ind, header))
|
|
extra_indent += ' '
|
|
if cmake_parameter:
|
|
cm_fh.write('{}{}{}\n'.format(ind, extra_indent, cmake_parameter))
|
|
extra_indent += ' '
|
|
for s in sort_sources(entries):
|
|
cm_fh.write('{}{}{}\n'.format(ind, extra_indent, s))
|
|
if footer:
|
|
cm_fh.write('{}{}\n'.format(ind, footer))
|
|
|
|
|
|
def write_source_file_list(cm_fh: typing.IO[str], scope, cmake_parameter: str,
|
|
keys: typing.List[str], indent: int = 0, *,
|
|
header: str = '', footer: str = ''):
|
|
# collect sources
|
|
sources: typing.List[str] = []
|
|
for key in keys:
|
|
sources += scope.get_files(key, use_vpath=True)
|
|
|
|
write_list(cm_fh, sources, cmake_parameter, indent, header=header, footer=footer)
|
|
|
|
|
|
def write_all_source_file_lists(cm_fh: typing.IO[str], scope: Scope, header: str, *,
|
|
indent: int = 0, footer: str = '',
|
|
extra_keys: typing.Optional[typing.List[str]] = None):
|
|
if extra_keys is None:
|
|
extra_keys = []
|
|
write_source_file_list(cm_fh, scope, header,
|
|
['SOURCES', 'HEADERS', 'OBJECTIVE_SOURCES', 'NO_PCH_SOURCES', 'FORMS'] + extra_keys,
|
|
indent, footer=footer)
|
|
|
|
|
|
def write_defines(cm_fh: typing.IO[str], scope: Scope, cmake_parameter: str, *,
|
|
indent: int = 0, footer: str = ''):
|
|
defines = scope.expand('DEFINES')
|
|
defines += [d[2:] for d in scope.expand('QMAKE_CXXFLAGS') if d.startswith('-D')]
|
|
defines = [d.replace('=\\\\\\"$$PWD/\\\\\\"',
|
|
'="${CMAKE_CURRENT_SOURCE_DIR}/"') for d in defines]
|
|
|
|
write_list(cm_fh, defines, cmake_parameter, indent, footer=footer)
|
|
|
|
|
|
def write_include_paths(cm_fh: typing.IO[str], scope: Scope, cmake_parameter: str, *,
|
|
indent: int = 0, footer: str = ''):
|
|
includes = [i.rstrip('/') or ('/') for i in scope.get_files('INCLUDEPATH')]
|
|
|
|
write_list(cm_fh, includes, cmake_parameter, indent, footer=footer)
|
|
|
|
|
|
def write_compile_options(cm_fh: typing.IO[str], scope: Scope, cmake_parameter: str, *,
|
|
indent: int = 0, footer: str = ''):
|
|
compile_options = [d for d in scope.expand('QMAKE_CXXFLAGS') if not d.startswith('-D')]
|
|
|
|
write_list(cm_fh, compile_options, cmake_parameter, indent, footer=footer)
|
|
|
|
|
|
def write_library_section(cm_fh: typing.IO[str], scope: Scope, *,
|
|
indent: int = 0, known_libraries: typing.Set[str]=set()):
|
|
(public_dependencies, private_dependencies) \
|
|
= extract_cmake_libraries(scope, known_libraries=known_libraries)
|
|
|
|
write_list(cm_fh, private_dependencies, 'LIBRARIES', indent + 1)
|
|
write_list(cm_fh, public_dependencies, 'PUBLIC_LIBRARIES', indent + 1)
|
|
|
|
|
|
def write_autogen_section(cm_fh: typing.IO[str], scope: Scope, *,
|
|
indent: int = 0):
|
|
forms = scope.get_files('FORMS')
|
|
if forms:
|
|
write_list(cm_fh, ['uic'], 'ENABLE_AUTOGEN_TOOLS', indent)
|
|
|
|
|
|
def write_sources_section(cm_fh: typing.IO[str], scope: Scope, *,
|
|
indent: int = 0, known_libraries=set()):
|
|
ind = spaces(indent)
|
|
|
|
# mark RESOURCES as visited:
|
|
scope.get('RESOURCES')
|
|
|
|
write_all_source_file_lists(cm_fh, scope, 'SOURCES', indent=indent + 1)
|
|
|
|
write_source_file_list(cm_fh, scope, 'DBUS_ADAPTOR_SOURCES', ['DBUS_ADAPTORS',], indent + 1)
|
|
dbus_adaptor_flags = scope.expand('QDBUSXML2CPP_ADAPTOR_HEADER_FLAGS')
|
|
if dbus_adaptor_flags:
|
|
cm_fh.write('{} DBUS_ADAPTOR_FLAGS\n'.format(ind))
|
|
cm_fh.write('{} "{}"\n'.format(ind, '" "'.join(dbus_adaptor_flags)))
|
|
|
|
write_source_file_list(cm_fh, scope, 'DBUS_INTERFACE_SOURCES', ['DBUS_INTERFACES',], indent + 1)
|
|
dbus_interface_flags = scope.expand('QDBUSXML2CPP_INTERFACE_HEADER_FLAGS')
|
|
if dbus_interface_flags:
|
|
cm_fh.write('{} DBUS_INTERFACE_FLAGS\n'.format(ind))
|
|
cm_fh.write('{} "{}"\n'.format(ind, '" "'.join(dbus_interface_flags)))
|
|
|
|
write_defines(cm_fh, scope, 'DEFINES', indent=indent + 1)
|
|
|
|
write_include_paths(cm_fh, scope, 'INCLUDE_DIRECTORIES', indent=indent + 1)
|
|
|
|
write_library_section(cm_fh, scope, indent=indent, known_libraries=known_libraries)
|
|
|
|
write_compile_options(cm_fh, scope, 'COMPILE_OPTIONS', indent=indent + 1)
|
|
|
|
write_autogen_section(cm_fh, scope, indent=indent + 1)
|
|
|
|
link_options = scope.get('QMAKE_LFLAGS')
|
|
if link_options:
|
|
cm_fh.write('{} LINK_OPTIONS\n'.format(ind))
|
|
for lo in link_options:
|
|
cm_fh.write('{} "{}"\n'.format(ind, lo))
|
|
|
|
moc_options = scope.get('QMAKE_MOC_OPTIONS')
|
|
if moc_options:
|
|
cm_fh.write('{} MOC_OPTIONS\n'.format(ind))
|
|
for mo in moc_options:
|
|
cm_fh.write('{} "{}"\n'.format(ind, mo))
|
|
|
|
|
|
def is_simple_condition(condition: str) -> bool:
|
|
return ' ' not in condition \
|
|
or (condition.startswith('NOT ') and ' ' not in condition[4:])
|
|
|
|
|
|
def write_ignored_keys(scope: Scope, indent: str) -> str:
|
|
result = ''
|
|
ignored_keys = scope.keys - scope.visited_keys
|
|
for k in sorted(ignored_keys):
|
|
if k == '_INCLUDED' or k == 'TARGET' or k == 'QMAKE_DOCS' or k == 'QT_SOURCE_TREE' \
|
|
or k == 'QT_BUILD_TREE' or k == 'TRACEPOINT_PROVIDER':
|
|
# All these keys are actually reported already
|
|
continue
|
|
values = scope.get(k)
|
|
value_string = '<EMPTY>' if not values \
|
|
else '"' + '" "'.join(scope.get(k)) + '"'
|
|
result += '{}# {} = {}\n'.format(indent, k, value_string)
|
|
|
|
if result:
|
|
result = '\n#### Keys ignored in scope {}:\n{}'.format(scope, result)
|
|
|
|
return result
|
|
|
|
|
|
def _iterate_expr_tree(expr, op, matches):
|
|
assert expr.func == op
|
|
keepers = ()
|
|
for arg in expr.args:
|
|
if arg in matches:
|
|
matches = tuple(x for x in matches if x != arg)
|
|
elif arg == op:
|
|
(matches, extra_keepers) = _iterate_expr_tree(arg, op, matches)
|
|
keepers = (*keepers, *extra_keepers)
|
|
else:
|
|
keepers = (*keepers, arg)
|
|
return matches, keepers
|
|
|
|
|
|
def _simplify_expressions(expr, op, matches, replacement):
|
|
for arg in expr.args:
|
|
expr = expr.subs(arg, _simplify_expressions(arg, op, matches,
|
|
replacement))
|
|
|
|
if expr.func == op:
|
|
(to_match, keepers) = tuple(_iterate_expr_tree(expr, op, matches))
|
|
if len(to_match) == 0:
|
|
# build expression with keepers and replacement:
|
|
if keepers:
|
|
start = replacement
|
|
current_expr = None
|
|
last_expr = keepers[-1]
|
|
for repl_arg in keepers[:-1]:
|
|
current_expr = op(start, repl_arg)
|
|
start = current_expr
|
|
top_expr = op(start, last_expr)
|
|
else:
|
|
top_expr = replacement
|
|
|
|
expr = expr.subs(expr, top_expr)
|
|
|
|
return expr
|
|
|
|
|
|
def _simplify_flavors_in_condition(base: str, flavors, expr):
|
|
''' Simplify conditions based on the knownledge of which flavors
|
|
belong to which OS. '''
|
|
base_expr = simplify_logic(base)
|
|
false_expr = simplify_logic('false')
|
|
for flavor in flavors:
|
|
flavor_expr = simplify_logic(flavor)
|
|
expr = _simplify_expressions(expr, And, (base_expr, flavor_expr,),
|
|
flavor_expr)
|
|
expr = _simplify_expressions(expr, Or, (base_expr, flavor_expr),
|
|
base_expr)
|
|
expr = _simplify_expressions(expr, And, (Not(base_expr), flavor_expr,),
|
|
false_expr)
|
|
return expr
|
|
|
|
|
|
def _simplify_os_families(expr, family_members, other_family_members):
|
|
for family in family_members:
|
|
for other in other_family_members:
|
|
if other in family_members:
|
|
continue # skip those in the sub-family
|
|
|
|
f_expr = simplify_logic(family)
|
|
o_expr = simplify_logic(other)
|
|
|
|
expr = _simplify_expressions(expr, And, (f_expr, Not(o_expr)), f_expr)
|
|
expr = _simplify_expressions(expr, And, (Not(f_expr), o_expr), o_expr)
|
|
expr = _simplify_expressions(expr, And, (f_expr, o_expr), simplify_logic('false'))
|
|
return expr
|
|
|
|
|
|
def _recursive_simplify(expr):
|
|
''' Simplify the expression as much as possible based on
|
|
domain knowledge. '''
|
|
input_expr = expr
|
|
|
|
# Simplify even further, based on domain knowledge:
|
|
windowses = ('WIN32', 'WINRT')
|
|
apples = ('APPLE_OSX', 'APPLE_UIKIT', 'APPLE_IOS',
|
|
'APPLE_TVOS', 'APPLE_WATCHOS',)
|
|
bsds = ('FREEBSD', 'OPENBSD', 'NETBSD',)
|
|
androids = ('ANDROID', 'ANDROID_EMBEDDED')
|
|
unixes = ('APPLE', *apples, 'BSD', *bsds, 'LINUX',
|
|
*androids, 'HAIKU',
|
|
'INTEGRITY', 'VXWORKS', 'QNX', 'WASM')
|
|
|
|
unix_expr = simplify_logic('UNIX')
|
|
win_expr = simplify_logic('WIN32')
|
|
false_expr = simplify_logic('false')
|
|
true_expr = simplify_logic('true')
|
|
|
|
expr = expr.subs(Not(unix_expr), win_expr) # NOT UNIX -> WIN32
|
|
expr = expr.subs(Not(win_expr), unix_expr) # NOT WIN32 -> UNIX
|
|
|
|
# UNIX [OR foo ]OR WIN32 -> ON [OR foo]
|
|
expr = _simplify_expressions(expr, Or, (unix_expr, win_expr,), true_expr)
|
|
# UNIX [AND foo ]AND WIN32 -> OFF [AND foo]
|
|
expr = _simplify_expressions(expr, And, (unix_expr, win_expr,), false_expr)
|
|
|
|
expr = _simplify_flavors_in_condition('WIN32', ('WINRT',), expr)
|
|
expr = _simplify_flavors_in_condition('APPLE', apples, expr)
|
|
expr = _simplify_flavors_in_condition('BSD', bsds, expr)
|
|
expr = _simplify_flavors_in_condition('UNIX', unixes, expr)
|
|
expr = _simplify_flavors_in_condition('ANDROID', ('ANDROID_EMBEDDED',), expr)
|
|
|
|
# Simplify families of OSes against other families:
|
|
expr = _simplify_os_families(expr, ('WIN32', 'WINRT'), unixes)
|
|
expr = _simplify_os_families(expr, androids, unixes)
|
|
expr = _simplify_os_families(expr, ('BSD', *bsds), unixes)
|
|
|
|
for family in ('HAIKU', 'QNX', 'INTEGRITY', 'LINUX', 'VXWORKS'):
|
|
expr = _simplify_os_families(expr, (family,), unixes)
|
|
|
|
# Now simplify further:
|
|
expr = simplify_logic(expr)
|
|
|
|
while expr != input_expr:
|
|
input_expr = expr
|
|
expr = _recursive_simplify(expr)
|
|
|
|
return expr
|
|
|
|
|
|
def simplify_condition(condition: str) -> str:
|
|
input_condition = condition.strip()
|
|
|
|
# Map to sympy syntax:
|
|
condition = ' ' + input_condition + ' '
|
|
condition = condition.replace('(', ' ( ')
|
|
condition = condition.replace(')', ' ) ')
|
|
|
|
tmp = ''
|
|
while tmp != condition:
|
|
tmp = condition
|
|
|
|
condition = condition.replace(' NOT ', ' ~ ')
|
|
condition = condition.replace(' AND ', ' & ')
|
|
condition = condition.replace(' OR ', ' | ')
|
|
condition = condition.replace(' ON ', ' true ')
|
|
condition = condition.replace(' OFF ', ' false ')
|
|
|
|
try:
|
|
# Generate and simplify condition using sympy:
|
|
condition_expr = simplify_logic(condition)
|
|
condition = str(_recursive_simplify(condition_expr))
|
|
|
|
# Map back to CMake syntax:
|
|
condition = condition.replace('~', 'NOT ')
|
|
condition = condition.replace('&', 'AND')
|
|
condition = condition.replace('|', 'OR')
|
|
condition = condition.replace('True', 'ON')
|
|
condition = condition.replace('False', 'OFF')
|
|
except:
|
|
# sympy did not like our input, so leave this condition alone:
|
|
condition = input_condition
|
|
|
|
return condition or 'ON'
|
|
|
|
|
|
def recursive_evaluate_scope(scope: Scope, parent_condition: str = '',
|
|
previous_condition: str = '') -> str:
|
|
current_condition = scope.condition
|
|
total_condition = current_condition
|
|
if total_condition == 'else':
|
|
assert previous_condition, \
|
|
"Else branch without previous condition in: %s" % scope.file
|
|
total_condition = 'NOT ({})'.format(previous_condition)
|
|
if parent_condition:
|
|
if not total_condition:
|
|
total_condition = parent_condition
|
|
else:
|
|
total_condition = '({}) AND ({})'.format(parent_condition,
|
|
total_condition)
|
|
|
|
scope.total_condition = simplify_condition(total_condition)
|
|
|
|
prev_condition = ''
|
|
for c in scope.children:
|
|
prev_condition = recursive_evaluate_scope(c, total_condition,
|
|
prev_condition)
|
|
|
|
return current_condition
|
|
|
|
|
|
def map_to_cmake_condition(condition: typing.Optional[str]) -> str:
|
|
condition = re.sub(r'\bQT_ARCH___equals___([a-zA-Z_0-9]*)',
|
|
r'(TEST_architecture_arch STREQUAL "\1")', condition or '')
|
|
condition = re.sub(r'\bQT_ARCH___contains___([a-zA-Z_0-9]*)',
|
|
r'(TEST_architecture_arch STREQUAL "\1")', condition or '')
|
|
return condition
|
|
|
|
|
|
def write_resources(cm_fh: typing.IO[str], target: str, scope: Scope, indent: int = 0):
|
|
vpath = scope.expand('VPATH')
|
|
|
|
# Handle QRC files by turning them into add_qt_resource:
|
|
resources = scope.get_files('RESOURCES')
|
|
qrc_output = ''
|
|
if resources:
|
|
qrc_only = True
|
|
for r in resources:
|
|
if r.endswith('.qrc'):
|
|
qrc_output += process_qrc_file(target, r, scope.basedir)
|
|
else:
|
|
qrc_only = False
|
|
|
|
if not qrc_only:
|
|
print(' XXXX Ignoring non-QRC file resources.')
|
|
|
|
if qrc_output:
|
|
cm_fh.write('\n# Resources:\n')
|
|
for line in qrc_output.split('\n'):
|
|
cm_fh.write(' ' * indent + line + '\n')
|
|
|
|
|
|
def write_extend_target(cm_fh: typing.IO[str], target: str,
|
|
scope: Scope, indent: int = 0):
|
|
ind = spaces(indent)
|
|
extend_qt_io_string = io.StringIO()
|
|
write_sources_section(extend_qt_io_string, scope)
|
|
extend_qt_string = extend_qt_io_string.getvalue()
|
|
|
|
extend_scope = '\n{}extend_target({} CONDITION {}\n' \
|
|
'{}{})\n'.format(ind, target,
|
|
map_to_cmake_condition(scope.total_condition),
|
|
extend_qt_string, ind)
|
|
|
|
if not extend_qt_string:
|
|
extend_scope = '' # Nothing to report, so don't!
|
|
|
|
cm_fh.write(extend_scope)
|
|
|
|
write_resources(cm_fh, target, scope, indent)
|
|
|
|
|
|
def flatten_scopes(scope: Scope) -> typing.List[Scope]:
|
|
result = [scope] # type: typing.List[Scope]
|
|
for c in scope.children:
|
|
result += flatten_scopes(c)
|
|
return result
|
|
|
|
|
|
def merge_scopes(scopes: typing.List[Scope]) -> typing.List[Scope]:
|
|
result = [] # type: typing.List[Scope]
|
|
|
|
# Merge scopes with their parents:
|
|
known_scopes = {} # type: typing.Mapping[str, Scope]
|
|
for scope in scopes:
|
|
total_condition = scope.total_condition
|
|
assert total_condition
|
|
if total_condition == 'OFF':
|
|
# ignore this scope entirely!
|
|
pass
|
|
elif total_condition in known_scopes:
|
|
known_scopes[total_condition].merge(scope)
|
|
else:
|
|
# Keep everything else:
|
|
result.append(scope)
|
|
known_scopes[total_condition] = scope
|
|
|
|
return result
|
|
|
|
|
|
def write_simd_part(cm_fh: typing.IO[str], target: str, scope: Scope, indent: int = 0):
|
|
simd_options = [ 'sse2', 'sse3', 'ssse3', 'sse4_1', 'sse4_2', 'aesni', 'shani', 'avx', 'avx2',
|
|
'avx512f', 'avx512cd', 'avx512er', 'avx512pf', 'avx512dq', 'avx512bw',
|
|
'avx512vl', 'avx512ifma', 'avx512vbmi', 'f16c', 'rdrnd', 'neon', 'mips_dsp',
|
|
'mips_dspr2',
|
|
'arch_haswell', 'avx512common', 'avx512core'];
|
|
for simd in simd_options:
|
|
SIMD = simd.upper();
|
|
write_source_file_list(cm_fh, scope, 'SOURCES',
|
|
['{}_HEADERS'.format(SIMD),
|
|
'{}_SOURCES'.format(SIMD),
|
|
'{}_C_SOURCES'.format(SIMD),
|
|
'{}_ASM'.format(SIMD)],
|
|
indent,
|
|
header = 'add_qt_simd_part({} SIMD {}\n'.format(target, simd),
|
|
footer = ')\n\n')
|
|
|
|
|
|
def write_main_part(cm_fh: typing.IO[str], name: str, typename: str,
|
|
cmake_function: str, scope: Scope, *,
|
|
extra_lines: typing.List[str] = [],
|
|
indent: int = 0, extra_keys: typing.List[str],
|
|
**kwargs: typing.Any):
|
|
# Evaluate total condition of all scopes:
|
|
recursive_evaluate_scope(scope)
|
|
|
|
if 'exceptions' in scope.get('CONFIG'):
|
|
extra_lines.append('EXCEPTIONS')
|
|
|
|
# Get a flat list of all scopes but the main one:
|
|
scopes = flatten_scopes(scope)
|
|
total_scopes = len(scopes)
|
|
# Merge scopes based on their conditions:
|
|
scopes = merge_scopes(scopes)
|
|
|
|
assert len(scopes)
|
|
assert scopes[0].total_condition == 'ON'
|
|
|
|
scopes[0].reset_visited_keys()
|
|
for k in extra_keys:
|
|
scopes[0].get(k)
|
|
|
|
# Now write out the scopes:
|
|
write_header(cm_fh, name, typename, indent=indent)
|
|
|
|
cm_fh.write('{}{}({}\n'.format(spaces(indent), cmake_function, name))
|
|
for extra_line in extra_lines:
|
|
cm_fh.write('{} {}\n'.format(spaces(indent), extra_line))
|
|
|
|
write_sources_section(cm_fh, scopes[0], indent=indent, **kwargs)
|
|
|
|
# Footer:
|
|
cm_fh.write('{})\n'.format(spaces(indent)))
|
|
|
|
write_resources(cm_fh, name, scope, indent)
|
|
|
|
write_simd_part(cm_fh, name, scope, indent)
|
|
|
|
ignored_keys_report = write_ignored_keys(scopes[0], spaces(indent))
|
|
if ignored_keys_report:
|
|
cm_fh.write(ignored_keys_report)
|
|
|
|
|
|
# Scopes:
|
|
if len(scopes) == 1:
|
|
return
|
|
|
|
write_scope_header(cm_fh, indent=indent)
|
|
|
|
for c in scopes[1:]:
|
|
c.reset_visited_keys()
|
|
write_extend_target(cm_fh, name, c, indent=indent)
|
|
ignored_keys_report = write_ignored_keys(c, spaces(indent))
|
|
if ignored_keys_report:
|
|
cm_fh.write(ignored_keys_report)
|
|
|
|
|
|
def write_module(cm_fh: typing.IO[str], scope: Scope, *,
|
|
indent: int = 0) -> None:
|
|
module_name = scope.TARGET
|
|
if not module_name.startswith('Qt'):
|
|
print('XXXXXX Module name {} does not start with Qt!'.format(module_name))
|
|
|
|
extra = []
|
|
if 'static' in scope.get('CONFIG'):
|
|
extra.append('STATIC')
|
|
if 'no_module_headers' in scope.get('CONFIG'):
|
|
extra.append('NO_MODULE_HEADERS')
|
|
|
|
module_config = scope.get("MODULE_CONFIG")
|
|
if len(module_config):
|
|
extra.append('QMAKE_MODULE_CONFIG {}'.format(" ".join(module_config)))
|
|
|
|
module_plugin_types = scope.get_files('MODULE_PLUGIN_TYPES')
|
|
if module_plugin_types:
|
|
extra.append('PLUGIN_TYPES {}'.format(" ".join(module_plugin_types)))
|
|
|
|
write_main_part(cm_fh, module_name[2:], 'Module', 'add_qt_module', scope,
|
|
extra_lines=extra, indent=indent,
|
|
known_libraries={}, extra_keys=[])
|
|
|
|
if 'qt_tracepoints' in scope.get('CONFIG'):
|
|
tracepoints = scope.get_files('TRACEPOINT_PROVIDER')
|
|
cm_fh.write('\n\n{}qt_create_tracepoints({} {})\n'
|
|
.format(spaces(indent), module_name[2:], ' '.join(tracepoints)))
|
|
|
|
|
|
def write_tool(cm_fh: typing.IO[str], scope: Scope, *,
|
|
indent: int = 0) -> None:
|
|
tool_name = scope.TARGET
|
|
|
|
extra = ['BOOTSTRAP'] if 'force_bootstrap' in scope.get('CONFIG') else []
|
|
|
|
write_main_part(cm_fh, tool_name, 'Tool', 'add_qt_tool', scope,
|
|
indent=indent, known_libraries={'Qt::Core', },
|
|
extra_lines=extra, extra_keys=['CONFIG'])
|
|
|
|
|
|
def write_test(cm_fh: typing.IO[str], scope: Scope, *,
|
|
indent: int = 0) -> None:
|
|
test_name = scope.TARGET
|
|
assert test_name
|
|
|
|
write_main_part(cm_fh, test_name, 'Test', 'add_qt_test', scope,
|
|
indent=indent, known_libraries={'Qt::Core', 'Qt::Test',},
|
|
extra_keys=[])
|
|
|
|
|
|
def write_binary(cm_fh: typing.IO[str], scope: Scope,
|
|
gui: bool = False, *, indent: int = 0) -> None:
|
|
binary_name = scope.TARGET
|
|
assert binary_name
|
|
|
|
extra = ['GUI',] if gui else[]
|
|
|
|
target_path = scope.get_string('target.path')
|
|
if target_path:
|
|
target_path = target_path.replace('$$[QT_INSTALL_EXAMPLES]', '${INSTALL_EXAMPLESDIR}')
|
|
extra.append('OUTPUT_DIRECTORY "{}"'.format(target_path))
|
|
if 'target' in scope.get('INSTALLS'):
|
|
extra.append('INSTALL_DIRECTORY "{}"'.format(target_path))
|
|
|
|
write_main_part(cm_fh, binary_name, 'Binary', 'add_qt_executable', scope,
|
|
extra_lines=extra, indent=indent,
|
|
known_libraries={'Qt::Core', }, extra_keys=['target.path', 'INSTALLS'])
|
|
|
|
|
|
def write_find_package_section(cm_fh: typing.IO[str],
|
|
public_libs: typing.List[str],
|
|
private_libs: typing.List[str], *, indent: int=0):
|
|
packages = [] # type: typing.List[LibraryMapping]
|
|
all_libs = public_libs + private_libs
|
|
|
|
for l in all_libs:
|
|
info = find_library_info_for_target(l)
|
|
if info and info not in packages:
|
|
packages.append(info)
|
|
|
|
ind = spaces(indent)
|
|
|
|
for p in packages:
|
|
cm_fh.write(generate_find_package_info(p, use_qt_find_package=False, indent=indent))
|
|
|
|
if packages:
|
|
cm_fh.write('\n')
|
|
|
|
|
|
def write_example(cm_fh: typing.IO[str], scope: Scope,
|
|
gui: bool = False, *, indent: int = 0) -> None:
|
|
binary_name = scope.TARGET
|
|
assert binary_name
|
|
|
|
cm_fh.write('cmake_minimum_required(VERSION 3.14)\n' +
|
|
'project({} LANGUAGES CXX)\n\n'.format(binary_name) +
|
|
'set(CMAKE_INCLUDE_CURRENT_DIR ON)\n\n' +
|
|
'set(CMAKE_AUTOMOC ON)\n' +
|
|
'set(CMAKE_AUTORCC ON)\n' +
|
|
'set(CMAKE_AUTOUIC ON)\n\n' +
|
|
'set(INSTALL_EXAMPLEDIR "examples")\n\n')
|
|
|
|
(public_libs, private_libs) = extract_cmake_libraries(scope)
|
|
write_find_package_section(cm_fh, public_libs, private_libs, indent=indent)
|
|
|
|
add_executable = 'add_executable({}'.format(binary_name);
|
|
if gui:
|
|
add_executable += ' WIN32 MACOSX_BUNDLE'
|
|
|
|
write_all_source_file_lists(cm_fh, scope, add_executable, indent=0, extra_keys=['RESOURCES'])
|
|
|
|
cm_fh.write(')\n')
|
|
|
|
write_include_paths(cm_fh, scope, 'target_include_directories({} PUBLIC'.format(binary_name),
|
|
indent=0, footer=')')
|
|
write_defines(cm_fh, scope, 'target_compile_definitions({} PUBLIC'.format(binary_name),
|
|
indent=0, footer=')')
|
|
write_list(cm_fh, private_libs, '', indent=indent,
|
|
header='target_link_libraries({} PRIVATE\n'.format(binary_name), footer=')')
|
|
write_list(cm_fh, public_libs, '', indent=indent,
|
|
header='target_link_libraries({} PUBLIC\n'.format(binary_name), footer=')')
|
|
write_compile_options(cm_fh, scope, 'target_compile_options({}'.format(binary_name),
|
|
indent=0, footer=')')
|
|
|
|
cm_fh.write('\ninstall(TARGETS {}\n'.format(binary_name) +
|
|
' RUNTIME DESTINATION "${INSTALL_EXAMPLEDIR}"\n' +
|
|
' BUNDLE DESTINATION "${INSTALL_EXAMPLEDIR}"\n' +
|
|
')\n')
|
|
|
|
|
|
def write_plugin(cm_fh, scope, *, indent: int = 0):
|
|
plugin_name = scope.TARGET
|
|
assert plugin_name
|
|
|
|
extra = []
|
|
|
|
plugin_type = scope.get_string('PLUGIN_TYPE')
|
|
if plugin_type:
|
|
extra.append('TYPE {}'.format(plugin_type))
|
|
|
|
plugin_class_name = scope.get_string('PLUGIN_CLASS_NAME')
|
|
if plugin_class_name:
|
|
extra.append('CLASS_NAME {}'.format(plugin_class_name))
|
|
|
|
write_main_part(cm_fh, plugin_name, 'Plugin', 'add_qt_plugin', scope,
|
|
indent=indent, extra_lines=extra, known_libraries={}, extra_keys=[])
|
|
|
|
|
|
def handle_app_or_lib(scope: Scope, cm_fh: typing.IO[str], *,
|
|
indent: int = 0, is_example: bool=False) -> None:
|
|
assert scope.TEMPLATE in ('app', 'lib')
|
|
|
|
is_lib = scope.TEMPLATE == 'lib'
|
|
is_plugin = any('qt_plugin' == s for s in scope.get('_LOADED'))
|
|
|
|
if is_lib or 'qt_module' in scope.get('_LOADED'):
|
|
assert not is_example
|
|
write_module(cm_fh, scope, indent=indent)
|
|
elif is_plugin:
|
|
assert not is_example
|
|
write_plugin(cm_fh, scope, indent=indent)
|
|
elif 'qt_tool' in scope.get('_LOADED'):
|
|
assert not is_example
|
|
write_tool(cm_fh, scope, indent=indent)
|
|
else:
|
|
if 'testcase' in scope.get('CONFIG') \
|
|
or 'testlib' in scope.get('CONFIG'):
|
|
assert not is_example
|
|
write_test(cm_fh, scope, indent=indent)
|
|
else:
|
|
config = scope.get('CONFIG')
|
|
gui = all(val not in config for val in ['console', 'cmdline'])
|
|
if is_example:
|
|
write_example(cm_fh, scope, gui, indent=indent)
|
|
else:
|
|
write_binary(cm_fh, scope, gui, indent=indent)
|
|
|
|
ind = spaces(indent)
|
|
write_source_file_list(cm_fh, scope, '',
|
|
['QMAKE_DOCS',],
|
|
indent,
|
|
header = 'add_qt_docs(\n',
|
|
footer = ')\n')
|
|
|
|
|
|
def cmakeify_scope(scope: Scope, cm_fh: typing.IO[str], *,
|
|
indent: int = 0, is_example: bool=False) -> None:
|
|
template = scope.TEMPLATE
|
|
if template == 'subdirs':
|
|
handle_subdir(scope, cm_fh, indent=indent, is_example=is_example)
|
|
elif template in ('app', 'lib'):
|
|
handle_app_or_lib(scope, cm_fh, indent=indent, is_example=is_example)
|
|
else:
|
|
print(' XXXX: {}: Template type {} not yet supported.'
|
|
.format(scope.file, template))
|
|
|
|
|
|
def generate_new_cmakelists(scope: Scope, *, is_example: bool=False) -> None:
|
|
print('Generating CMakeLists.gen.txt')
|
|
with open(scope.generated_cmake_lists_path, 'w') as cm_fh:
|
|
assert scope.file
|
|
cm_fh.write('# Generated from {}.\n\n'
|
|
.format(os.path.basename(scope.file)))
|
|
cmakeify_scope(scope, cm_fh, is_example=is_example)
|
|
|
|
|
|
def do_include(scope: Scope, *, debug: bool = False) -> None:
|
|
for c in scope.children:
|
|
do_include(c)
|
|
|
|
for include_file in scope.get_files('_INCLUDED', is_include=True):
|
|
if not include_file:
|
|
continue
|
|
if not os.path.isfile(include_file):
|
|
print(' XXXX: Failed to include {}.'.format(include_file))
|
|
continue
|
|
|
|
include_result = parseProFile(include_file, debug=debug)
|
|
include_scope \
|
|
= Scope.FromDict(None, include_file,
|
|
include_result.asDict().get('statements'),
|
|
'', scope.basedir) # This scope will be merged into scope!
|
|
|
|
do_include(include_scope)
|
|
|
|
scope.merge(include_scope)
|
|
|
|
|
|
def copy_generated_file_to_final_location(scope: Scope, keep_temporary_files=False) -> None:
|
|
print('Copying {} to {}'.format(scope.generated_cmake_lists_path,
|
|
scope.original_cmake_lists_path))
|
|
copyfile(scope.generated_cmake_lists_path, scope.original_cmake_lists_path)
|
|
if not keep_temporary_files:
|
|
os.remove(scope.generated_cmake_lists_path)
|
|
|
|
|
|
def main() -> None:
|
|
args = _parse_commandline()
|
|
|
|
debug_parsing = args.debug_parser or args.debug
|
|
|
|
backup_current_dir = os.getcwd()
|
|
|
|
for file in args.files:
|
|
new_current_dir = os.path.dirname(file)
|
|
file_relative_path = os.path.basename(file)
|
|
if new_current_dir:
|
|
os.chdir(new_current_dir)
|
|
|
|
parseresult = parseProFile(file_relative_path, debug=debug_parsing)
|
|
|
|
if args.debug_parse_result or args.debug:
|
|
print('\n\n#### Parser result:')
|
|
print(parseresult)
|
|
print('\n#### End of parser result.\n')
|
|
if args.debug_parse_dictionary or args.debug:
|
|
print('\n\n####Parser result dictionary:')
|
|
print(parseresult.asDict())
|
|
print('\n#### End of parser result dictionary.\n')
|
|
|
|
file_scope = Scope.FromDict(None, file_relative_path,
|
|
parseresult.asDict().get('statements'))
|
|
|
|
if args.debug_pro_structure or args.debug:
|
|
print('\n\n#### .pro/.pri file structure:')
|
|
file_scope.dump()
|
|
print('\n#### End of .pro/.pri file structure.\n')
|
|
|
|
do_include(file_scope, debug=debug_parsing)
|
|
|
|
if args.debug_full_pro_structure or args.debug:
|
|
print('\n\n#### Full .pro/.pri file structure:')
|
|
file_scope.dump()
|
|
print('\n#### End of full .pro/.pri file structure.\n')
|
|
|
|
generate_new_cmakelists(file_scope, is_example=args.is_example)
|
|
|
|
copy_generated_file = True
|
|
if not args.skip_special_case_preservation:
|
|
debug_special_case = args.debug_special_case_preservation or args.debug
|
|
handler = SpecialCaseHandler(file_scope.original_cmake_lists_path,
|
|
file_scope.generated_cmake_lists_path,
|
|
file_scope.basedir,
|
|
keep_temporary_files=args.keep_temporary_files,
|
|
debug=debug_special_case)
|
|
|
|
copy_generated_file = handler.handle_special_cases()
|
|
|
|
if copy_generated_file:
|
|
copy_generated_file_to_final_location(file_scope,
|
|
keep_temporary_files=args.keep_temporary_files)
|
|
os.chdir(backup_current_dir)
|
|
|
|
|
|
if __name__ == '__main__':
|
|
main()
|