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

#!/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()