Renamed meson package to mesonbuild so that we can have a script named meson in the same toplevel dir.

1 files changed, 222 insertions, 0 deletions

diff --git a/mesonbuild/coredata.py b/mesonbuild/coredata.py
new file mode 100644
index 000000000..5b1102c1e
--- /dev/null
+++ b/mesonbuild/coredata.py
@@ -0,0 +1,222 @@
+# Copyright 2012-2015 The Meson development team
+
+# 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 pickle, os, uuid
+
+version = '0.29.0-research'
+
+build_types = ['plain', 'debug', 'debugoptimized', 'release']
+layouts = ['mirror', 'flat']
+warning_levels = ['1', '2', '3']
+libtypelist = ['shared', 'static']
+
+builtin_options = {'buildtype': True,
+                   'strip': True,
+                   'coverage': True,
+                   'pch': True,
+                   'unity': True,
+                   'prefix': True,
+                   'libdir' : True,
+                   'bindir' : True,
+                   'includedir' : True,
+                   'datadir' : True,
+                   'mandir' : True,
+                   'localedir' : True,
+                   'werror' : True,
+                   'warning_level': True,
+                   'layout' : True,
+                   'default_library': True,
+                  }
+
+class MesonException(Exception):
+    def __init__(self, *args, **kwargs):
+        Exception.__init__(self, *args, **kwargs)
+
+class UserOption:
+    def __init__(self, name, description, choices):
+        super().__init__()
+        self.name = name
+        self.choices = choices
+        self.description = description
+
+    def parse_string(self, valuestring):
+        return valuestring
+
+class UserStringOption(UserOption):
+    def __init__(self, name, description, value, choices=None):
+        super().__init__(name, description, choices)
+        self.set_value(value)
+
+    def validate(self, value):
+        if not isinstance(value, str):
+            raise MesonException('Value "%s" for string option "%s" is not a string.' % (str(newvalue), self.name))
+        if self.name == 'prefix' and not os.path.isabs(value):
+            raise MesonException('Prefix option must be an absolute path.')
+        if self.name in ('libdir', 'bindir', 'includedir', 'datadir', 'mandir', 'localedir') \
+            and os.path.isabs(value):
+            raise MesonException('Option %s must not be an absolute path.' % self.name)
+
+    def set_value(self, newvalue):
+        self.validate(newvalue)
+        self.value = newvalue
+
+class UserBooleanOption(UserOption):
+    def __init__(self, name, description, value):
+        super().__init__(name, description, '[true, false]')
+        self.set_value(value)
+
+    def tobool(self, thing):
+        if isinstance(thing, bool):
+            return thing
+        if thing.lower() == 'true':
+            return True
+        if thing.lower() == 'false':
+            return False
+        raise MesonException('Value %s is not boolean (true or false).' % thing)
+
+    def set_value(self, newvalue):
+        self.value = self.tobool(newvalue)
+
+    def parse_string(self, valuestring):
+        if valuestring == 'false':
+            return False
+        if valuestring == 'true':
+            return True
+        raise MesonException('Value "%s" for boolean option "%s" is not a boolean.' % (valuestring, self.name))
+
+class UserComboOption(UserOption):
+    def __init__(self, name, description, choices, value):
+        super().__init__(name, description, choices)
+        if not isinstance(self.choices, list):
+            raise MesonException('Combo choices must be an array.')
+        for i in self.choices:
+            if not isinstance(i, str):
+                raise MesonException('Combo choice elements must be strings.')
+        self.set_value(value)
+
+    def set_value(self, newvalue):
+        if newvalue not in self.choices:
+            optionsstring = ', '.join(['"%s"' % (item,) for item in self.choices])
+            raise MesonException('Value "%s" for combo option "%s" is not one of the choices. Possible choices are: %s.' % (newvalue, self.name, optionsstring))
+        self.value = newvalue
+
+class UserStringArrayOption(UserOption):
+    def __init__(self, name, description, value, **kwargs):
+        super().__init__(name, description, kwargs.get('choices', []))
+        self.set_value(value)
+
+    def set_value(self, newvalue):
+        if isinstance(newvalue, str):
+            if not newvalue.startswith('['):
+                raise MesonException('Valuestring does not define an array: ' + newvalue)
+            newvalue = eval(newvalue, {}, {}) # Yes, it is unsafe.
+        if not isinstance(newvalue, list):
+            raise MesonException('String array value is not an array.')
+        for i in newvalue:
+            if not isinstance(i, str):
+                raise MesonException('String array element not a string.')
+        self.value = newvalue
+
+# This class contains all data that must persist over multiple
+# invocations of Meson. It is roughly the same thing as
+# cmakecache.
+
+class CoreData():
+
+    def __init__(self, options):
+        self.guid = str(uuid.uuid4()).upper()
+        self.test_guid = str(uuid.uuid4()).upper()
+        self.regen_guid = str(uuid.uuid4()).upper()
+        self.target_guids = {}
+        self.version = version
+        self.builtin_options = {}
+        self.init_builtins(options)
+        self.user_options = {}
+        self.compiler_options = {}
+        self.external_args = {} # These are set from "the outside" with e.g. mesonconf
+        self.external_link_args = {}
+        if options.cross_file is not None:
+            self.cross_file = os.path.join(os.getcwd(), options.cross_file)
+        else:
+            self.cross_file = None
+
+        self.compilers = {}
+        self.cross_compilers = {}
+        self.deps = {}
+        self.ext_progs = {}
+        self.modules = {}
+
+    def init_builtins(self, options):
+        self.builtin_options['prefix'] = UserStringOption('prefix', 'Installation prefix', options.prefix)
+        self.builtin_options['libdir'] = UserStringOption('libdir', 'Library dir', options.libdir)
+        self.builtin_options['bindir'] = UserStringOption('bindir', 'Executable dir', options.bindir)
+        self.builtin_options['includedir'] = UserStringOption('includedir', 'Include dir', options.includedir)
+        self.builtin_options['datadir'] = UserStringOption('datadir', 'Data directory', options.datadir)
+        self.builtin_options['mandir'] = UserStringOption('mandir', 'Man page dir', options.mandir)
+        self.builtin_options['localedir'] = UserStringOption('localedir', 'Locale dir', options.localedir)
+        self.builtin_options['backend'] = UserStringOption('backend', 'Backend to use', options.backend)
+        self.builtin_options['buildtype'] = UserComboOption('buildtype', 'Build type', build_types, options.buildtype)
+        self.builtin_options['strip'] = UserBooleanOption('strip', 'Strip on install', options.strip)
+        self.builtin_options['use_pch'] = UserBooleanOption('use_pch', 'Use precompiled headers', options.use_pch)
+        self.builtin_options['unity'] = UserBooleanOption('unity', 'Unity build', options.unity)
+        self.builtin_options['coverage'] = UserBooleanOption('coverage', 'Enable coverage', options.coverage)
+        self.builtin_options['warning_level'] = UserComboOption('warning_level', 'Warning level', warning_levels, options.warning_level)
+        self.builtin_options['werror'] = UserBooleanOption('werror', 'Warnings are errors', options.werror)
+        self.builtin_options['layout'] = UserComboOption('layout', 'Build dir layout', layouts, options.layout)
+        self.builtin_options['default_library'] = UserComboOption('default_library', 'Default_library type', libtypelist, options.default_library)
+
+    def get_builtin_option(self, optname):
+        if optname in self.builtin_options:
+            return self.builtin_options[optname].value
+        raise RuntimeError('Tried to get unknown builtin option %s' % optname)
+
+    def set_builtin_option(self, optname, value):
+        if optname in self.builtin_options:
+            self.builtin_options[optname].set_value(value)
+        else:
+            raise RuntimeError('Tried to set unknown builtin option %s' % optname)
+
+    def is_builtin_option(self, optname):
+        return optname in self.builtin_options
+
+def load(filename):
+    obj = pickle.load(open(filename, 'rb'))
+    if not isinstance(obj, CoreData):
+        raise RuntimeError('Core data file is corrupted.')
+    if obj.version != version:
+        raise RuntimeError('Build tree has been generated with Meson version %s, which is incompatible with current version %s.'%
+                           (obj.version, version))
+    return obj
+
+def save(obj, filename):
+    if obj.version != version:
+        raise RuntimeError('Fatal version mismatch corruption.')
+    pickle.dump(obj, open(filename, 'wb'))
+
+forbidden_target_names = {'clean': None,
+                          'clean-gcno': None,
+                          'clean-gcda': None,
+                          'coverage-text': None,
+                          'coverage-xml': None,
+                          'coverage-html': None,
+                          'phony': None,
+                          'PHONY': None,
+                          'all': None,
+                          'test': None,
+                          'test-valgrind': None,
+                          'test-': None,
+                          'benchmark': None,
+                          'install': None,
+                          'build.ninja': None,
+                         }