The Meson Build System
http://mesonbuild.com/
You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
669 lines
24 KiB
669 lines
24 KiB
#!/usr/bin/python3 -tt |
|
|
|
# Copyright 2012 Jussi Pakkanen |
|
|
|
# Licensed under the Apache License, Version 2.0 (the "License"); |
|
# you may not use this file except in compliance with the License. |
|
# You may obtain a copy of the License at |
|
|
|
# http://www.apache.org/licenses/LICENSE-2.0 |
|
|
|
# Unless required by applicable law or agreed to in writing, software |
|
# distributed under the License is distributed on an "AS IS" BASIS, |
|
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
|
# See the License for the specific language governing permissions and |
|
# limitations under the License. |
|
|
|
import bparser |
|
import nodes |
|
import environment |
|
import os, sys, platform |
|
|
|
class InterpreterException(Exception): |
|
pass |
|
|
|
class InvalidCode(InterpreterException): |
|
pass |
|
|
|
class InvalidArguments(InterpreterException): |
|
pass |
|
|
|
class InterpreterObject(): |
|
|
|
def __init__(self): |
|
self.methods = {} |
|
|
|
def method_call(self, method_name, args): |
|
if method_name in self.methods: |
|
return self.methods[method_name](args) |
|
raise InvalidCode('Unknown method "%s" in object.' % method_name) |
|
|
|
# This currently returns data for the current environment. |
|
# It should return info for the target host. |
|
class Host(InterpreterObject): |
|
|
|
def __init__(self): |
|
InterpreterObject.__init__(self) |
|
self.methods.update({'pointer_size' : self.get_ptrsize_method, |
|
'name' : self.get_name_method, |
|
'is_big_endian' : self.is_big_endian_method, |
|
}) |
|
|
|
def get_ptrsize_method(self, args): |
|
if sys.maxsize > 2**32: |
|
return 64 |
|
return 32 |
|
|
|
def get_name_method(self, args): |
|
return platform.system().lower() |
|
|
|
def is_big_endian_method(self, args): |
|
return sys.byteorder != 'little' |
|
|
|
class IncludeDirs(InterpreterObject): |
|
def __init__(self, curdir, dirs): |
|
InterpreterObject.__init__(self) |
|
self.curdir = curdir |
|
self.incdirs = dirs |
|
# Fixme: check that the directories actually exist. |
|
# Also that they don't contain ".." or somesuch. |
|
|
|
def get_curdir(self): |
|
return self.curdir |
|
|
|
def get_incdirs(self): |
|
return self.incdirs |
|
|
|
class Headers(InterpreterObject): |
|
|
|
def __init__(self, sources): |
|
InterpreterObject.__init__(self) |
|
self.sources = sources |
|
self.methods.update({'set_subdir' : self.set_subdir}) |
|
self.subdir = '' |
|
|
|
def set_subdir(self, args): |
|
self.subdir = args[0] |
|
|
|
def get_subdir(self): |
|
return self.subdir |
|
|
|
def get_sources(self): |
|
return self.sources |
|
|
|
class Data(InterpreterObject): |
|
|
|
def __init__(self, subdir, sources): |
|
InterpreterObject.__init__(self) |
|
self.subdir = subdir |
|
self.sources = sources |
|
|
|
def get_subdir(self): |
|
return self.subdir |
|
|
|
def get_sources(self): |
|
return self.sources |
|
|
|
class ConfigureFile(InterpreterObject): |
|
|
|
def __init__(self, subdir, sourcename, targetname): |
|
InterpreterObject.__init__(self) |
|
self.subdir = subdir |
|
self.sourcename = sourcename |
|
self.targetname = targetname |
|
|
|
def get_sources(self): |
|
return self.sources |
|
|
|
def get_subdir(self): |
|
return self.subdir |
|
|
|
def get_source_name(self): |
|
return self.sourcename |
|
|
|
def get_target_name(self): |
|
return self.targetname |
|
|
|
class Man(InterpreterObject): |
|
|
|
def __init__(self, sources): |
|
InterpreterObject.__init__(self) |
|
self.sources = sources |
|
self.validate_sources() |
|
|
|
def validate_sources(self): |
|
for s in self.sources: |
|
num = int(s.split('.')[-1]) |
|
if num < 1 or num > 8: |
|
raise InvalidArguments('Man file must have a file extension of a number between 1 and 8') |
|
|
|
def get_sources(self): |
|
return self.sources |
|
|
|
class BuildTarget(InterpreterObject): |
|
|
|
def __init__(self, name, subdir, sources): |
|
InterpreterObject.__init__(self) |
|
self.name = name |
|
self.subdir = subdir |
|
self.sources = sources |
|
self.external_deps = [] |
|
self.include_dirs = [] |
|
self.methods.update({'add_dep': self.add_dep_method, |
|
'link' : self.link_method, |
|
'install': self.install_method, |
|
'pch' : self.pch_method, |
|
'add_include_dirs': self.add_include_dirs_method, |
|
'add_compiler_args' : self.add_compiler_args_method, |
|
}) |
|
self.link_targets = [] |
|
self.filename = 'no_name' |
|
self.need_install = False |
|
self.pch = [] |
|
self.extra_args = {} |
|
|
|
def get_subdir(self): |
|
return self.subdir |
|
|
|
def get_filename(self): |
|
return self.filename |
|
|
|
def get_extra_args(self, language): |
|
return self.extra_args.get(language, []) |
|
|
|
def get_dependencies(self): |
|
return self.link_targets |
|
|
|
def get_basename(self): |
|
return self.name |
|
|
|
def get_source_subdir(self): |
|
return self.subdir |
|
|
|
def get_sources(self): |
|
return self.sources |
|
|
|
def should_install(self): |
|
return self.need_install |
|
|
|
def has_pch(self): |
|
return len(self.pch) > 0 |
|
|
|
def get_pch(self): |
|
return self.pch |
|
|
|
def get_include_dirs(self): |
|
return self.include_dirs |
|
|
|
def add_external_dep(self, dep): |
|
if not isinstance(dep, environment.PkgConfigDependency): |
|
raise InvalidArguments('Argument is not an external dependency') |
|
self.external_deps.append(dep) |
|
|
|
def get_external_deps(self): |
|
return self.external_deps |
|
|
|
def add_dep_method(self, args): |
|
[self.add_external_dep(dep) for dep in args] |
|
|
|
def link_method(self, args): |
|
target = args[0] |
|
if not isinstance(target, StaticLibrary) and \ |
|
not isinstance(target, SharedLibrary): |
|
raise InvalidArguments('Link target is not library.') |
|
self.link_targets.append(target) |
|
|
|
def install_method(self, args): |
|
if len(args) != 0: |
|
raise InvalidArguments('Install() takes no arguments.') |
|
self.need_install = True |
|
|
|
def pch_method(self, args): |
|
if len(args) == 0: |
|
raise InvalidArguments('Pch requires arguments.') |
|
for a in args: |
|
self.pch.append(a) |
|
|
|
def add_include_dirs_method(self, args): |
|
for a in args: |
|
if not isinstance(a, IncludeDirs): |
|
raise InvalidArguments('Include directory to be added is not an include directory object.') |
|
self.include_dirs += args |
|
|
|
def add_compiler_args_method(self, args): |
|
for a in args: |
|
if not isinstance(a, str): |
|
raise InvalidArguments('A non-string passed to compiler args.') |
|
language = args[0] |
|
flags = args[1:] |
|
if language in self.extra_args: |
|
self.extra_args[language] += flags |
|
else: |
|
self.extra_args[language] = flags |
|
|
|
def get_aliaslist(self): |
|
return [] |
|
|
|
class Executable(BuildTarget): |
|
def __init__(self, name, subdir, sources, environment): |
|
BuildTarget.__init__(self, name, subdir, sources) |
|
suffix = environment.get_exe_suffix() |
|
if suffix != '': |
|
self.filename = self.name + '.' + suffix |
|
else: |
|
self.filename = self.name |
|
|
|
class StaticLibrary(BuildTarget): |
|
def __init__(self, name, subdir, sources, environment): |
|
BuildTarget.__init__(self, name, subdir, sources) |
|
prefix = environment.get_static_lib_prefix() |
|
suffix = environment.get_static_lib_suffix() |
|
self.filename = prefix + self.name + '.' + suffix |
|
|
|
|
|
class SharedLibrary(BuildTarget): |
|
def __init__(self, name, subdir, sources, environment): |
|
BuildTarget.__init__(self, name, subdir, sources) |
|
self.version = None |
|
self.soversion = None |
|
self.prefix = environment.get_shared_lib_prefix() |
|
self.suffix = environment.get_shared_lib_suffix() |
|
self.methods.update({'set_version' : self.set_version_method, |
|
'set_soversion' : self.set_soversion_method, |
|
}) |
|
|
|
def get_shbase(self): |
|
return self.prefix + self.name + '.' + self.suffix |
|
def get_filename(self): |
|
fname = self.get_shbase() |
|
if self.version is None: |
|
return fname |
|
else: |
|
return fname + '.' + self.version |
|
|
|
def set_version_method(self, args): |
|
v = args[0] |
|
if not isinstance(v, str): |
|
raise InvalidArguments('Shared library version is not a string.') |
|
self.version = v |
|
|
|
def set_soversion_method(self, args): |
|
v = args[0] |
|
if not isinstance(v, str): |
|
raise InvalidArguments('Shared library soversion is not a string.') |
|
self.soversion = v |
|
|
|
def get_aliaslist(self): |
|
aliases = [] |
|
if self.soversion is not None: |
|
aliases.append(self.get_shbase() + '.' + self.soversion) |
|
if self.version is not None: |
|
aliases.append(self.get_shbase()) |
|
return aliases |
|
|
|
class Test(InterpreterObject): |
|
def __init__(self, name, exe): |
|
InterpreterObject.__init__(self) |
|
self.name = name |
|
self.exe = exe |
|
|
|
def get_exe(self): |
|
return self.exe |
|
|
|
def get_name(self): |
|
return self.name |
|
|
|
class Interpreter(): |
|
|
|
def __init__(self, code, build): |
|
self.build = build |
|
self.ast = bparser.build_ast(code) |
|
self.sanity_check_ast() |
|
self.variables = {} |
|
self.builtin = {} |
|
self.builtin['host'] = Host() |
|
self.environment = build.environment |
|
self.build_func_dict() |
|
self.subdir = '' |
|
|
|
def build_func_dict(self): |
|
self.funcs = {'project' : self.func_project, |
|
'message' : self.func_message, |
|
'executable': self.func_executable, |
|
'find_dep' : self.func_find_dep, |
|
'static_library' : self.func_static_lib, |
|
'shared_library' : self.func_shared_lib, |
|
'add_test' : self.func_add_test, |
|
'headers' : self.func_headers, |
|
'man' : self.func_man, |
|
'subdir' : self.func_subdir, |
|
'data' : self.func_data, |
|
'configure_file' : self.func_configure_file, |
|
'include_directories' : self.func_include_directories, |
|
'add_global_arguments' : self.func_add_global_arguments, |
|
} |
|
|
|
def get_variables(self): |
|
return self.variables |
|
|
|
def sanity_check_ast(self): |
|
if not isinstance(self.ast, nodes.CodeBlock): |
|
raise InvalidCode('AST is of invalid type. Possibly a bug in the parser.') |
|
if len(self.ast.get_statements()) == 0: |
|
raise InvalidCode('No statements in code.') |
|
first = self.ast.get_statements()[0] |
|
if not isinstance(first, nodes.FunctionCall) or first.get_function_name() != 'project': |
|
raise InvalidCode('First statement must be a call to project') |
|
|
|
def run(self): |
|
self.evaluate_codeblock(self.ast) |
|
|
|
def evaluate_codeblock(self, node): |
|
if node is None: |
|
return |
|
if not isinstance(node, nodes.CodeBlock): |
|
raise InvalidCode('Line %d: Tried to execute a non-codeblock. Possibly a bug in the parser.' % node.lineno()) |
|
statements = node.get_statements() |
|
i = 0 |
|
while i < len(statements): |
|
cur = statements[i] |
|
self.evaluate_statement(cur) |
|
i += 1 # In THE FUTURE jump over blocks and stuff. |
|
|
|
def get_variable(self, varname): |
|
if varname in self.builtin: |
|
return self.builtin[varname] |
|
if varname in self.variables: |
|
return self.variables[varname] |
|
raise InvalidCode('Line %d: unknown variable "%s".' % varname) |
|
|
|
def set_variable(self, varname, variable): |
|
if varname in self.builtin: |
|
raise InvalidCode('Tried to overwrite internal variable "%s"' % varname) |
|
self.variables[varname] = variable |
|
|
|
def evaluate_statement(self, cur): |
|
if isinstance(cur, nodes.FunctionCall): |
|
return self.function_call(cur) |
|
elif isinstance(cur, nodes.Assignment): |
|
return self.assignment(cur) |
|
elif isinstance(cur, nodes.MethodCall): |
|
return self.method_call(cur) |
|
elif isinstance(cur, nodes.StringStatement): |
|
return cur |
|
elif isinstance(cur, nodes.BoolStatement): |
|
return cur |
|
elif isinstance(cur, nodes.IfStatement): |
|
return self.evaluate_if(cur) |
|
elif isinstance(cur, nodes.AtomStatement): |
|
return self.get_variable(cur.get_value()) |
|
elif isinstance(cur, nodes.Comparison): |
|
return self.evaluate_comparison(cur) |
|
elif isinstance(cur, nodes.ArrayStatement): |
|
return self.evaluate_arraystatement(cur) |
|
elif isinstance(cur, nodes.IntStatement): |
|
return cur |
|
else: |
|
raise InvalidCode("Line %d: Unknown statement." % cur.lineno()) |
|
|
|
def validate_arguments(self, args, argcount, arg_types): |
|
if argcount is not None: |
|
if argcount != len(args): |
|
raise InvalidArguments('Expected %d arguments, got %d', |
|
argcount, len(args)) |
|
for i in range(min(len(args), len(arg_types))): |
|
wanted = arg_types[i] |
|
actual = args[i] |
|
if wanted != None: |
|
if not isinstance(actual, wanted): |
|
raise InvalidArguments('Incorrect argument type.') |
|
|
|
def func_project(self, node, args): |
|
if len(args) < 2: |
|
raise InvalidArguments('Not enough arguments to project(). Needs at least the project name and one language') |
|
for a in args: |
|
if not isinstance(a, str): |
|
raise InvalidArguments('Line %d: Argument %s is not a string.' % (node.lineno(), str(a))) |
|
if self.build.project is not None: |
|
raise InvalidCode('Second call to project() on line %d.' % node.lineno()) |
|
self.build.project = args[0] |
|
print('Project name is "%s".' % self.build.project) |
|
self.add_languages(node, args[1:]) |
|
|
|
def func_message(self, node, args): |
|
self.validate_arguments(args, 1, [str]) |
|
print('Message: %s' % args[0]) |
|
|
|
def add_languages(self, node, args): |
|
for lang in args: |
|
if lang.lower() == 'c': |
|
comp = self.environment.detect_c_compiler() |
|
elif lang.lower() == 'cxx': |
|
comp = self.environment.detect_cxx_compiler() |
|
else: |
|
raise InvalidCode('Tried to use unknown language "%s".' % lang) |
|
comp.sanity_check(self.environment.get_scratch_dir()) |
|
self.build.compilers.append(comp) |
|
|
|
def func_find_dep(self, node, args): |
|
self.validate_arguments(args, 1, [str]) |
|
name = args[0] |
|
dep = environment.find_external_dependency(name) |
|
return dep |
|
|
|
def func_executable(self, node, args): |
|
return self.build_target(node, args, Executable) |
|
|
|
def func_static_lib(self, node, args): |
|
return self.build_target(node, args, StaticLibrary) |
|
|
|
def func_shared_lib(self, node, args): |
|
return self.build_target(node, args, SharedLibrary) |
|
|
|
def func_add_test(self, node, args): |
|
self.validate_arguments(args, 2, [str, Executable]) |
|
t = Test(args[0], args[1]) |
|
self.build.tests.append(t) |
|
print('Adding test "%s"' % args[0]) |
|
|
|
def func_headers(self, node, args): |
|
for a in args: |
|
if not isinstance(a, str): |
|
raise InvalidArguments('Line %d: Argument %s is not a string.' % (node.lineno(), str(a))) |
|
h = Headers(args) |
|
self.build.headers.append(h) |
|
return h |
|
|
|
def func_man(self, node, args): |
|
for a in args: |
|
if not isinstance(a, str): |
|
raise InvalidArguments('Line %d: Argument %s is not a string.' % (node.lineno(), str(a))) |
|
m = Man(args) |
|
self.build.man.append(m) |
|
return m |
|
|
|
def func_subdir(self, node, args): |
|
self.validate_arguments(args, 1, [str]) |
|
prev_subdir = self.subdir |
|
self.subdir = os.path.join(prev_subdir, args[0]) |
|
buildfilename = os.path.join(self.subdir, environment.builder_filename) |
|
code = open(os.path.join(self.environment.get_source_dir(), buildfilename)).read() |
|
assert(isinstance(code, str)) |
|
codeblock = bparser.build_ast(code) |
|
print('Going to subdirectory "%s".' % self.subdir) |
|
self.evaluate_codeblock(codeblock) |
|
self.subdir = prev_subdir |
|
|
|
def func_data(self, node, args): |
|
if len(args ) < 2: |
|
raise InvalidArguments('Line %d: Data function must have at least two arguments: name and source file(s)' % node.lineno()) |
|
for a in args: |
|
if not isinstance(a, str): |
|
raise InvalidArguments('Line %d: Argument %s is not a string.' % (node.lineno(), str(a))) |
|
data = Data(args[0], args[1:]) |
|
self.build.data.append(data) |
|
return data |
|
|
|
def func_configure_file(self, node, args): |
|
self.validate_arguments(args, 2, [str, str]) |
|
c = ConfigureFile(self.subdir, args[0], args[1]) |
|
self.build.configure_files.append(c) |
|
|
|
def func_include_directories(self, node, args): |
|
for a in args: |
|
if not isinstance(a, str): |
|
raise InvalidArguments('Line %d: Argument %s is not a string.' % (node.lineno(), str(a))) |
|
i = IncludeDirs(self.subdir, args) |
|
return i |
|
|
|
def func_add_global_arguments(self, node, args): |
|
for a in args: |
|
if not isinstance(a, str): |
|
raise InvalidArguments('Line %d: Argument %s is not a string.' % (node.lineno(), str(a))) |
|
if len(self.build.get_targets()) > 0: |
|
raise InvalidCode('Line %d: global flags can not be set once any build target is defined.' % node.lineno()) |
|
lang = args[0].lower() |
|
switches = args[1:] |
|
if lang in self.build.global_args: |
|
self.build.global_args[lang] += switches |
|
else: |
|
self.build.global_args[lang] = switches |
|
|
|
def flatten(self, args): |
|
result = [] |
|
for a in args: |
|
if isinstance(a, list): |
|
result = result + self.flatten(a) |
|
else: |
|
result.append(a) |
|
return result |
|
|
|
def build_target(self, node, args, targetclass): |
|
args = self.flatten(args) |
|
for a in args: |
|
if not isinstance(a, str): |
|
raise InvalidArguments('Line %d: Argument %s is not a string.' % (node.lineno(), str(a))) |
|
name = args[0] |
|
sources = [] |
|
for s in args[1:]: |
|
if not self.environment.is_header(s): |
|
sources.append(s) |
|
if len(sources) == 0: |
|
raise InvalidArguments('Line %d: target has no source files.' % node.lineno()) |
|
if name in self.build.targets: |
|
raise InvalidCode('Line %d: tried to create target "%s", but a target of that name already exists.' % (node.lineno(), name)) |
|
l = targetclass(name, self.subdir, sources, self.environment) |
|
self.build.targets[name] = l |
|
print('Creating build target "%s" with %d files.' % (name, len(sources))) |
|
return l |
|
|
|
def function_call(self, node): |
|
func_name = node.get_function_name() |
|
args = self.reduce_arguments(node.arguments) |
|
if func_name in self.funcs: |
|
return self.funcs[func_name](node, args) |
|
else: |
|
raise InvalidCode('Unknown function "%s".' % func_name) |
|
|
|
def is_assignable(self, value): |
|
if isinstance(value, InterpreterObject) or \ |
|
isinstance(value, environment.PkgConfigDependency) or\ |
|
isinstance(value, nodes.StringStatement) or\ |
|
isinstance(value, nodes.BoolStatement) or\ |
|
isinstance(value, nodes.IntStatement) or\ |
|
isinstance(value, list): |
|
return True |
|
return False |
|
|
|
def assignment(self, node): |
|
var_name = node.var_name |
|
if not isinstance(var_name, nodes.AtomExpression): |
|
raise InvalidArguments('Line %d: Tried to assign value to a non-variable.' % node.lineno()) |
|
var_name = var_name.get_value() |
|
value = self.evaluate_statement(node.value) |
|
if value is None: |
|
raise InvalidCode('Line %d: Can not assign None to variable.' % node.lineno()) |
|
if not self.is_assignable(value): |
|
raise InvalidCode('Line %d: Tried to assign an invalid value to variable.' % node.lineno()) |
|
self.set_variable(var_name, value) |
|
return value |
|
|
|
def reduce_arguments(self, args): |
|
assert(isinstance(args, nodes.Arguments)) |
|
reduced = [] |
|
for arg in args.arguments: |
|
if isinstance(arg, nodes.AtomExpression) or isinstance(arg, nodes.AtomStatement): |
|
r = self.get_variable(arg.value) |
|
elif isinstance(arg, nodes.StringExpression) or isinstance(arg, nodes.StringStatement): |
|
r = arg.get_value() |
|
elif isinstance(arg, nodes.FunctionCall): |
|
r = self.function_call(arg) |
|
elif isinstance(arg, nodes.MethodCall): |
|
r = self.method_call(arg) |
|
else: |
|
raise InvalidCode('Line %d: Irreducible argument.' % args.lineno()) |
|
reduced.append(r) |
|
assert(len(reduced) == len(args)) |
|
return reduced |
|
|
|
def method_call(self, node): |
|
object_name = node.object_name.get_value() |
|
method_name = node.method_name.get_value() |
|
args = node.arguments |
|
obj = self.get_variable(object_name) |
|
if not isinstance(obj, InterpreterObject): |
|
raise InvalidArguments('Line %d: variable "%s" is not callable.' % (node.lineno(), object_name)) |
|
return obj.method_call(method_name, self.reduce_arguments(args)) |
|
|
|
def evaluate_if(self, node): |
|
result = self.evaluate_statement(node.get_clause()) |
|
cond = None |
|
if isinstance(result, nodes.BoolExpression) or \ |
|
isinstance(result, nodes.BoolStatement): |
|
cond = result.get_value() |
|
if isinstance(result, bool): |
|
cond = result |
|
|
|
if cond is not None: |
|
if cond: |
|
self.evaluate_codeblock(node.get_trueblock()) |
|
else: |
|
self.evaluate_codeblock(node.get_falseblock()) |
|
else: |
|
print(node.get_clause()) |
|
print(result) |
|
raise InvalidCode('Line %d: If clause does not evaluate to true or false.' % node.lineno()) |
|
|
|
def evaluate_comparison(self, node): |
|
v1 = self.evaluate_statement(node.get_first()) |
|
v2 = self.evaluate_statement(node.get_second()) |
|
if isinstance(v1, int): |
|
val1 = v1 |
|
else: |
|
val1 = v1.get_value() |
|
if(isinstance(v2, int)): |
|
val2 = v2 |
|
else: |
|
val2 = v2.get_value() |
|
assert(type(val1) == type(val2)) |
|
if node.get_ctype() == '==': |
|
return val1 == val2 |
|
elif node.get_ctype() == '!=': |
|
return val1 != val2 |
|
else: |
|
raise InvalidCode('You broke me.') |
|
|
|
def evaluate_arraystatement(self, cur): |
|
arguments = self.reduce_arguments(cur.get_args()) |
|
return arguments |
|
|
|
if __name__ == '__main__': |
|
code = """project('myawesomeproject') |
|
message('I can haz text printed out?') |
|
language('c') |
|
prog = executable('prog', 'prog.c', 'subfile.c') |
|
dep = find_dep('gtk+-3.0') |
|
prog.add_dep(dep) |
|
""" |
|
i = Interpreter(code, environment.Environment('.', 'work area')) |
|
i.run()
|
|
|