Refactored builtin options to a dictionary and created a new default …

…library target type.

backends.py

@@ -68,7 +68,7 @@ def get_target_filename(self, target):
         return filename
 
     def get_target_dir(self, target):
-        if self.environment.coredata.layout == 'mirror':
+        if self.environment.coredata.get_builtin_option('layout') == 'mirror':
             dirname = target.get_subdir()
         else:
             dirname = 'meson-out'
@@ -208,16 +208,16 @@ def get_pch_include_args(self, compiler, target):
     def generate_basic_compiler_args(self, target, compiler):
         commands = []
         commands += compiler.get_always_args()
-        if self.environment.coredata.buildtype != 'plain':
-            commands += compiler.get_warn_args(self.environment.coredata.warning_level)
+        if self.environment.coredata.get_builtin_option('buildtype') != 'plain':
+            commands += compiler.get_warn_args(self.environment.coredata.get_builtin_option('warning_level'))
         commands += compiler.get_option_compile_args(self.environment.coredata.compiler_options)
         commands += self.build.get_global_args(compiler)
         commands += self.environment.coredata.external_args[compiler.get_language()]
         commands += target.get_extra_args(compiler.get_language())
-        commands += compiler.get_buildtype_args(self.environment.coredata.buildtype)
-        if self.environment.coredata.coverage:
+        commands += compiler.get_buildtype_args(self.environment.coredata.get_builtin_option('buildtype'))
+        if self.environment.coredata.get_builtin_option('coverage'):
             commands += compiler.get_coverage_args()
-        if self.environment.coredata.werror:
+        if self.environment.coredata.get_builtin_option('werror'):
             commands += compiler.get_werror_args()
         if isinstance(target, build.SharedLibrary):
             commands += compiler.get_pic_args()
@@ -302,9 +302,10 @@ def generate_pkgconfig_files(self):
             outdir = self.environment.scratch_dir
             fname = os.path.join(outdir, p.filebase + '.pc')
             ofile = open(fname, 'w')
-            ofile.write('prefix=%s\n' % self.environment.get_coredata().prefix)
-            ofile.write('libdir=${prefix}/%s\n' % self.environment.get_coredata().libdir)
-            ofile.write('includedir=${prefix}/%s\n\n' % self.environment.get_coredata().includedir)
+            coredata = self.environment.get_coredata()
+            ofile.write('prefix=%s\n' % coredata.get_builtin_option('prefix'))
+            ofile.write('libdir=${prefix}/%s\n' % coredata.get_builtin_option('libdir'))
+            ofile.write('includedir=${prefix}/%s\n\n' % coredata.get_builtin_option('includedir'))
             ofile.write('Name: %s\n' % p.name)
             if len(p.description) > 0:
                 ofile.write('Description: %s\n' % p.description)

coredata.py

@@ -44,22 +44,8 @@ def __init__(self, options):
         self.test_guid = str(uuid.uuid4()).upper()
         self.target_guids = {}
         self.version = version
-        self.prefix = options.prefix
-        self.libdir = options.libdir
-        self.bindir = options.bindir
-        self.includedir = options.includedir
-        self.datadir = options.datadir
-        self.mandir = options.mandir
-        self.localedir = options.localedir
-        self.backend = options.backend
-        self.buildtype = options.buildtype
-        self.strip = options.strip
-        self.use_pch = options.use_pch
-        self.unity = options.unity
-        self.coverage = options.coverage
-        self.warning_level = options.warning_level
-        self.werror = options.werror
-        self.layout = options.layout
+        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
@@ -76,35 +62,36 @@ def __init__(self, options):
         self.ext_libs = {}
         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
+
     def get_builtin_option(self, optname):
-        if optname == 'buildtype':
-            return self.buildtype
-        if optname == 'strip':
-            return self.strip
-        if optname == 'coverage':
-            return self.coverage
-        if optname == 'pch':
-            return self.use_pch
-        if optname == 'unity':
-            return self.unity
-        if optname == 'prefix':
-            return self.prefix
-        if optname == 'libdir':
-            return self.libdir
-        if optname == 'bindir':
-            return self.bindir
-        if optname == 'includedir':
-            return self.includedir
-        if optname == 'datadir':
-            return self.datadir
-        if optname == 'mandir':
-            return self.mandir
-        if optname == 'localedir':
-            return self.localedir
-        if optname == 'layout':
-            return self.layout
+        if optname in self.builtin_options:
+            return self.builtin_options[optname]
         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
+        else:
+            raise RuntimeError('Tried to set unknown builtin option %s' % optname)
+
 def load(filename):
     obj = pickle.load(open(filename, 'rb'))
     if not isinstance(obj, CoreData):

environment.py

@@ -543,22 +543,22 @@ def get_object_suffix(self):
         return self.object_suffix
 
     def get_prefix(self):
-        return self.coredata.prefix
+        return self.coredata.get_builtin_option('prefix')
 
     def get_libdir(self):
-        return self.coredata.libdir
+        return self.coredata.get_builtin_option('libdir')
 
     def get_bindir(self):
-        return self.coredata.bindir
+        return self.coredata.get_builtin_option('bindir')
 
     def get_includedir(self):
-        return self.coredata.includedir
+        return self.coredata.get_builtin_option('includedir')
 
     def get_mandir(self):
-        return self.coredata.mandir
+        return self.coredata.get_builtin_option('mandir')
 
     def get_datadir(self):
-        return self.coredata.datadir
+        return self.coredata.get_builtin_option('datadir')
 
     def find_library(self, libname, dirs):
         if dirs is None:

interpreter.py

@@ -855,7 +855,7 @@ def get_compiler_method(self, args, kwargs):
         raise InterpreterException('Tried to access compiler for unspecified language "%s".' % cname)
 
     def is_unity_method(self, args, kwargs):
-        return self.build.environment.coredata.unity
+        return self.build.environment.coredata.get_builtin_option('unity')
 
     def is_subproject_method(self, args, kwargs):
         return self.interpreter.is_subproject()
@@ -933,6 +933,7 @@ def build_func_dict(self):
                       'dependency' : self.func_dependency,
                       'static_library' : self.func_static_lib,
                       'shared_library' : self.func_shared_lib,
+                      'default_library' : self.func_default_library,
                       'jar' : self.func_jar,
                       'build_target': self.func_build_target,
                       'custom_target' : self.func_custom_target,
@@ -1339,9 +1340,10 @@ def parse_default_options(self, default_options):
             if '=' not in option:
                 raise InterpreterException('All default options must be of type key=value.')
             key, value = option.split('=', 1)
-            if hasattr(self.coredata, key):
+            builtin_options = self.coredata.builtin_options
+            if key in builtin_options:
                 if not hasattr(self.environment.cmd_line_options, value):
-                    setattr(self.coredata, key, value)
+                    self.coredata.set_builtin_option(key, value)
                 # If this was set on the command line, do not override.
             else:
                 newoptions = [option] + self.environment.cmd_line_options.projectoptions
@@ -1567,6 +1569,11 @@ def func_static_lib(self, node, args, kwargs):
     def func_shared_lib(self, node, args, kwargs):
         return self.build_target(node, args, kwargs, SharedLibraryHolder)
 
+    def func_default_library(self, node, args, kwargs):
+        if self.coredata.get_builtin_option('default_library') == 'shared':
+            return self.func_shared_lib(node, args, kwargs)
+        return self.func_static_lib(node, args, kwargs)
+
     def func_jar(self, node, args, kwargs):
         return self.build_target(node, args, kwargs, JarHolder)
 
@@ -2009,7 +2016,7 @@ def method_call(self, node):
         else:
             obj = self.evaluate_statement(invokable)
         method_name = node.name
-        if method_name == 'extract_objects' and self.environment.coredata.unity:
+        if method_name == 'extract_objects' and self.environment.coredata.get_builtin_option('unity'):
             raise InterpreterException('Single object files can not be extracted in Unity builds.')
         args = node.args
         if isinstance(obj, mparser.StringNode):

meson.py

@@ -68,6 +68,8 @@
                     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',
+                    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)')
 parser.add_argument('--cross-file', default=None, dest='cross_file',

mesonconf.py

@@ -72,52 +72,55 @@ def set_options(self, options):
             if k == 'buildtype':
                 if v not in build_types:
                     raise ConfException('Invalid build type %s.' % v)
-                self.coredata.buildtype = v
+                self.coredata.set_builtin_option('buildtype', v)
             elif k == 'layout':
                 if v not in layouts:
                     raise ConfException('Invalid layout type %s.' % v)
-                self.coredata.layout = v
+                self.coredata.set_builtin_option('layout', v)
             elif k == 'warnlevel':
                 if not v in warning_levels:
                     raise ConfException('Invalid warning level %s.' % v)
-                self.coredata.warning_level = v
+                self.coredata.set_builtin_option('warning_level', v)
             elif k == 'strip':
-                self.coredata.strip = self.tobool(v)
+                self.coredata.set_builtin_option('strip', self.tobool(v))
             elif k == 'coverage':
-                v = self.tobool(v)
-                self.coredata.coverage = self.tobool(v)
+                self.coredata.set_builtin_option('coverage', self.tobool(v))
             elif k == 'pch':
-                self.coredata.use_pch = self.tobool(v)
+                self.coredata.set_builtin_option('use_pch', self.tobool(v))
             elif k == 'unity':
-                self.coredata.unity = self.tobool(v)
+                self.coredata.set_builtin_option('unity', self.tobool(v))
+            elif k == 'default_library':
+                if v != 'shared' and v != 'static':
+                    raise ConfException('Invalid value for default_library')
+                self.coredata.set_builtin_option('default_library', v)
             elif k == 'prefix':
                 if not os.path.isabs(v):
                     raise ConfException('Install prefix %s is not an absolute path.' % v)
-                self.coredata.prefix = v
+                self.coredata.set_builtin_option('prefix', v)
             elif k == 'libdir':
                 if os.path.isabs(v):
                     raise ConfException('Library dir %s must not be an absolute path.' % v)
-                self.coredata.libdir = v
+                self.coredata.set_builtin_option('libdir', v)
             elif k == 'bindir':
                 if os.path.isabs(v):
                     raise ConfException('Binary dir %s must not be an absolute path.' % v)
-                self.coredata.bindir = v
+                self.coredata.set_builtin_option('bindir',v)
             elif k == 'includedir':
                 if os.path.isabs(v):
                     raise ConfException('Include dir %s must not be an absolute path.' % v)
-                self.coredata.includedir = v
+                self.coredata.set_builtin_option('includedir', v)
             elif k == 'datadir':
                 if os.path.isabs(v):
                     raise ConfException('Data dir %s must not be an absolute path.' % v)
-                self.coredata.datadir = v
+                self.coredata.set_builtin_option('datadir', v)
             elif k == 'mandir':
                 if os.path.isabs(v):
                     raise ConfException('Man dir %s must not be an absolute path.' % v)
-                self.coredata.mandir = v
+                self.coredata.set_builtin_option('mandir', v)
             elif k == 'localedir':
                 if os.path.isabs(v):
                     raise ConfException('Locale dir %s must not be an absolute path.' % v)
-                self.coredata.localedir = v
+                self.coredata.set_builtin_option('localedir', v)
             elif k in self.coredata.user_options:
                 tgt = self.coredata.user_options[k]
                 tgt.set_value(v)
@@ -150,12 +153,13 @@ def print_conf(self):
         print('')
         print('Core options\n')
         carr = []
-        carr.append(['buildtype', 'Build type', self.coredata.buildtype])
-        carr.append(['warnlevel', 'Warning level', self.coredata.warning_level])
-        carr.append(['strip', 'Strip on install', self.coredata.strip])
-        carr.append(['coverage', 'Coverage report', self.coredata.coverage])
-        carr.append(['pch', 'Precompiled headers', self.coredata.use_pch])
-        carr.append(['unity', 'Unity build', self.coredata.unity])
+        carr.append(['buildtype', 'Build type', self.coredata.get_builtin_option('buildtype')])
+        carr.append(['warnlevel', 'Warning level', self.coredata.get_builtin_option('warning_level')])
+        carr.append(['strip', 'Strip on install', self.coredata.get_builtin_option('strip')])
+        carr.append(['coverage', 'Coverage report', self.coredata.get_builtin_option('coverage')])
+        carr.append(['pch', 'Precompiled headers', self.coredata.get_builtin_option('use_pch')])
+        carr.append(['unity', 'Unity build', self.coredata.get_builtin_option('unity')])
+        carr.append(['default_library', 'Default library type', self.coredata.get_builtin_option('default_library')])
         self.print_aligned(carr)
         print('')
         print('Compiler arguments\n')
@@ -179,13 +183,13 @@ def print_conf(self):
         print('')
         print('Directories\n')
         parr = []
-        parr.append(['prefix', 'Install prefix', self.coredata.prefix])
-        parr.append(['libdir', 'Library directory', self.coredata.libdir])
-        parr.append(['bindir', 'Binary directory', self.coredata.bindir])
-        parr.append(['includedir', 'Header directory', self.coredata.includedir])
-        parr.append(['datadir', 'Data directory', self.coredata.datadir])
-        parr.append(['mandir', 'Man page directory', self.coredata.mandir])
-        parr.append(['localedir', 'Locale file directory', self.coredata.localedir])
+        parr.append(['prefix', 'Install prefix', self.coredata.get_builtin_option('prefix')])
+        parr.append(['libdir', 'Library directory', self.coredata.get_builtin_option('libdir')])
+        parr.append(['bindir', 'Binary directory', self.coredata.get_builtin_option('bindir')])
+        parr.append(['includedir', 'Header directory', self.coredata.get_builtin_option('includedir')])
+        parr.append(['datadir', 'Data directory', self.coredata.get_builtin_option('datadir')])
+        parr.append(['mandir', 'Man page directory', self.coredata.get_builtin_option('mandir')])
+        parr.append(['localedir', 'Locale file directory', self.coredata.get_builtin_option('localedir')])
         self.print_aligned(parr)
         print('')
         if len(self.coredata.user_options) == 0: