Turned builtin options into proper objects.

5 files changed, 123 insertions, 119 deletions

diff --git a/compilers.py b/compilers.py
index 85b57b3..862a4f0 100644
--- a/compilers.py
+++ b/compilers.py
@@ -17,6 +17,7 @@ import tempfile
 import mesonlib
 import mlog
 from coredata import MesonException
+import coredata
 
 """This file contains the data files of all compilers Meson knows
 about. To support a new compiler, add its information below.
@@ -1017,7 +1018,7 @@ class VisualStudioCCompiler(CCompiler):
         return []
 
     def get_options(self):
-        return {'c_winlibs' : mesonlib.UserStringArrayOption('c_winlibs',
+        return {'c_winlibs' : coredata.UserStringArrayOption('c_winlibs',
                                                              'Windows libs to link against.',
                                                              msvc_winlibs)
                 }
@@ -1056,11 +1057,11 @@ class VisualStudioCPPCompiler(VisualStudioCCompiler):
             raise EnvironmentException('Executables created by C++ compiler %s are not runnable.' % self.name_string())
 
     def get_options(self):
-        return {'cpp_eh' : mesonlib.UserComboOption('cpp_eh',
+        return {'cpp_eh' : coredata.UserComboOption('cpp_eh',
                                                     'C++ exception handling type.',
                                                     ['none', 'a', 's', 'sc'],
                                                     'sc'),
-                'cpp_winlibs' : mesonlib.UserStringArrayOption('cpp_winlibs',
+                'cpp_winlibs' : coredata.UserStringArrayOption('cpp_winlibs',
                                                                'Windows libs to link against.',
                                                                msvc_winlibs)
                 }
@@ -1129,12 +1130,12 @@ class GnuCCompiler(CCompiler):
         return super().can_compile(filename) or filename.split('.')[-1].lower() == 's' # Gcc can do asm, too.
 
     def get_options(self):
-        opts = {'c_std' : mesonlib.UserComboOption('c_std', 'C language standard to use',
+        opts = {'c_std' : coredata.UserComboOption('c_std', 'C language standard to use',
                                                    ['none', 'c89', 'c99', 'c11', 'gnu89', 'gnu99', 'gnu11'],
                                                    'c11')}
         if self.gcc_type == GCC_MINGW:
             opts.update({
-                'c_winlibs': mesonlib.UserStringArrayOption('c_winlibs', 'Standard Win libraries to link against',
+                'c_winlibs': coredata.UserStringArrayOption('c_winlibs', 'Standard Win libraries to link against',
                                                             gnu_winlibs),
                 })
         return opts
@@ -1240,7 +1241,7 @@ class ClangCCompiler(CCompiler):
         return ['-include-pch', os.path.join (pch_dir, self.get_pch_name (header))]
 
     def get_options(self):
-        return {'c_std' : mesonlib.UserComboOption('c_std', 'C language standard to use',
+        return {'c_std' : coredata.UserComboOption('c_std', 'C language standard to use',
                                                    ['none', 'c89', 'c99', 'c11'],
                                                    'c11')}
 
@@ -1282,12 +1283,12 @@ class GnuCPPCompiler(CPPCompiler):
         return get_gcc_soname_args(self.gcc_type, shlib_name, path, soversion)
 
     def get_options(self):
-        opts = {'cpp_std' : mesonlib.UserComboOption('cpp_std', 'C language standard to use',
+        opts = {'cpp_std' : coredata.UserComboOption('cpp_std', 'C language standard to use',
                                                      ['none', 'c++03', 'c++11', 'c++1y'],
                                                      'c++11')}
         if self.gcc_type == GCC_MINGW:
             opts.update({
-                'cpp_winlibs': mesonlib.UserStringArrayOption('c_winlibs', 'Standard Win libraries to link against',
+                'cpp_winlibs': coredata.UserStringArrayOption('c_winlibs', 'Standard Win libraries to link against',
                                                               gnu_winlibs),
                 })
         return opts
@@ -1328,7 +1329,7 @@ class ClangCPPCompiler(CPPCompiler):
         return ['-include-pch', os.path.join (pch_dir, self.get_pch_name (header))]
 
     def get_options(self):
-        return {'cpp_std' : mesonlib.UserComboOption('cpp_std', 'C++ language standard to use',
+        return {'cpp_std' : coredata.UserComboOption('cpp_std', 'C++ language standard to use',
                                                    ['none', 'c++03', 'c++11', 'c++1y'],
                                                    'c++11')}
 
diff --git a/coredata.py b/coredata.py
index fb6b0b6..86a64f9 100644
--- a/coredata.py
+++ b/coredata.py
@@ -16,6 +16,11 @@ import pickle, os, uuid
 
 version = '0.27.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,
@@ -31,8 +36,90 @@ builtin_options = {'buildtype': 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):
+        super().__init__()
+        self.name = name
+        self.description = description
+
+    def parse_string(self, valuestring):
+        return valuestring
+
+class UserStringOption(UserOption):
+    def __init__(self, name, description, value):
+        super().__init__(name, description)
+        self.set_value(value)
+
+    def set_value(self, newvalue):
+        if not isinstance(newvalue, str):
+            raise MesonException('Value "%s" for string option "%s" is not a string.' % (str(newvalue), self.name))
+        self.value = newvalue
+
+class UserBooleanOption(UserOption):
+    def __init__(self, name, description, value):
+        super().__init__(name, description)
+        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)
+        self.choices = 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):
+        super().__init__(name, description)
+        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.
@@ -63,32 +150,32 @@ class CoreData():
         self.modules = {}
 
     def init_builtins(self, options):
-        self.builtin_options['prefix'] = options.prefix
-        self.builtin_options['libdir'] = options.libdir
-        self.builtin_options['bindir'] = options.bindir
-        self.builtin_options['includedir'] = options.includedir
-        self.builtin_options['datadir'] = options.datadir
-        self.builtin_options['mandir'] = options.mandir
-        self.builtin_options['localedir'] = options.localedir
-        self.builtin_options['backend'] = options.backend
-        self.builtin_options['buildtype'] = options.buildtype
-        self.builtin_options['strip'] = options.strip
-        self.builtin_options['use_pch'] = options.use_pch
-        self.builtin_options['unity'] = options.unity
-        self.builtin_options['coverage'] = options.coverage
-        self.builtin_options['warning_level'] = options.warning_level
-        self.builtin_options['werror'] = options.werror
-        self.builtin_options['layout'] = options.layout
-        self.builtin_options['default_library'] = options.default_library
+        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]
+            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] = value
+            self.builtin_options[optname].set_value(value)
         else:
             raise RuntimeError('Tried to set unknown builtin option %s' % optname)
 
@@ -120,7 +207,3 @@ forbidden_target_names = {'clean': None,
                           'install': None,
                           'build.ninja': None,
                          }
-
-class MesonException(Exception):
-    def __init__(self, *args, **kwargs):
-        Exception.__init__(self, *args, **kwargs)
diff --git a/meson.py b/meson.py
index 17c1e9e..a9e5c70 100755
--- a/meson.py
+++ b/meson.py
@@ -22,14 +22,11 @@ import build
 import platform
 import mlog, coredata
 
-from coredata import MesonException
-
-parser = argparse.ArgumentParser()
+from coredata import MesonException, build_types, layouts, warning_levels, libtypelist
 
 backendlist = ['ninja', 'vs2010', 'xcode']
-build_types = ['plain', 'debug', 'debugoptimized', 'release']
-layouts = ['mirror', 'flat']
-warning_levels = ['1', '2', '3']
+
+parser = argparse.ArgumentParser()
 
 default_warning = '2'
 
@@ -68,7 +65,7 @@ parser.add_argument('--werror', action='store_true', dest='werror', default=Fals
                     help='Treat warnings as errors')
 parser.add_argument('--layout', choices=layouts, dest='layout', default='mirror',\
                     help='Build directory layout.')
-parser.add_argument('--default-library', choices=['shared', 'static'], dest='default_library',
+parser.add_argument('--default-library', choices=libtypelist, dest='default_library',
                     default='static', help='Default library type.')
 parser.add_argument('--warnlevel', default=default_warning, dest='warning_level', choices=warning_levels,\
                     help='Level of compiler warnings to use (larger is more, default is %(default)s)')
diff --git a/mesonlib.py b/mesonlib.py
index f422095..bb69632 100644
--- a/mesonlib.py
+++ b/mesonlib.py
@@ -264,80 +264,3 @@ def stringlistify(item):
         if not isinstance(i, str):
             raise MesonException('List item not a string.')
     return item
-
-class UserOption:
-    def __init__(self, name, description):
-        super().__init__()
-        self.name = name
-        self.description = description
-
-    def parse_string(self, valuestring):
-        return valuestring
-
-class UserStringOption(UserOption):
-    def __init__(self, name, description, value):
-        super().__init__(name, description)
-        self.set_value(value)
-
-    def set_value(self, newvalue):
-        if not isinstance(newvalue, str):
-            raise MesonException('Value "%s" for string option "%s" is not a string.' % (str(newvalue), self.name))
-        self.value = newvalue
-
-class UserBooleanOption(UserOption):
-    def __init__(self, name, description, value):
-        super().__init__(name, description)
-        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)
-        self.choices = 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):
-        super().__init__(name, description)
-        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
diff --git a/optinterpreter.py b/optinterpreter.py
index d66aa1f..f106326 100644
--- a/optinterpreter.py
+++ b/optinterpreter.py
@@ -40,11 +40,11 @@ class OptionException(coredata.MesonException):
 optname_regex = re.compile('[^a-zA-Z0-9_-]')
 
 def StringParser(name, description, kwargs):
-    return mesonlib.UserStringOption(name, description,
+    return coredata.UserStringOption(name, description,
                                      kwargs.get('value', ''))
 
 def BooleanParser(name, description, kwargs):
-    return mesonlib.UserBooleanOption(name, description, kwargs.get('value', True))
+    return coredata.UserBooleanOption(name, description, kwargs.get('value', True))
 
 def ComboParser(name, description, kwargs):
     if 'choices' not in kwargs:
@@ -55,7 +55,7 @@ def ComboParser(name, description, kwargs):
     for i in choices:
         if not isinstance(i, str):
             raise OptionException('Combo choice elements must be strings.')
-    return mesonlib.UserComboOption(name, description, choices, kwargs.get('value', choices[0]))
+    return coredata.UserComboOption(name, description, choices, kwargs.get('value', choices[0]))
 
 option_types = {'string' : StringParser,
                 'boolean' : BooleanParser,