Can specify standalone command targets.

backends.py

@@ -188,6 +188,8 @@ class Backend():
     def generate_target(self, target, outfile):
         if isinstance(target, build.CustomTarget):
             self.generate_custom_target(target, outfile)
+        if isinstance(target, build.RunTarget):
+            self.generate_run_target(target, outfile)
         name = target.get_basename()
         gen_src_deps = []
         if name in self.processed_targets:

build.py

@@ -659,6 +659,30 @@ class CustomTarget:
     def get_generated_sources(self):
         return []
 
+class RunTarget:
+    def __init__(self, name, command, args, subdir):
+        self.name = name
+        self.command = command
+        self.args = args
+        self.subdir = subdir
+
+    def get_basename(self):
+        return self.name
+
+    def get_dependencies(self):
+        return []
+
+    def get_generated_sources(self):
+        return []
+
+    def get_subdir(self):
+        return self.subdir
+
+    def should_install(self):
+        return False
+
+    def get_filename(self):
+        return self.name
 class Jar(BuildTarget):
     def __init__(self, name, subdir, is_cross, sources, objects, environment, kwargs):
         super().__init__(name, subdir, is_cross, sources, objects, environment, kwargs);

interpreter.py

@@ -383,6 +383,10 @@ class CustomTargetHolder(InterpreterObject):
         gobjs = self.held_object.extract_objects(args)
         return GeneratedObjectsHolder(gobjs)
 
+class RunTargetHolder(InterpreterObject):
+    def __init__(self, name, command, args, subdir):
+        self.held_object = build.RunTarget(name, command, args, subdir)
+
 class Test(InterpreterObject):
     def __init__(self, name, exe, is_parallel, cmd_args, env):
         InterpreterObject.__init__(self)
@@ -659,6 +663,7 @@ class Interpreter():
                       'shared_library' : self.func_shared_lib,
                       'jar' : self.func_jar,
                       'custom_target' : self.func_custom_target,
+                      'run_target' : self.func_run_target,
                       'generator' : self.func_generator,
                       'test' : self.func_test,
                       'headers' : self.func_headers,
@@ -956,7 +961,6 @@ class Interpreter():
                     self.coredata.cross_compilers[lang] = cross_comp
             mlog.log('Using native %s compiler "' % lang, mlog.bold(' '.join(comp.get_exelist())), '". (%s %s)' % (comp.id, comp.version), sep='')
             if not comp.get_language() in self.coredata.external_args:
-                print('getting from envvars')
                 (ext_compile_flags, ext_link_flags) = environment.get_flags_from_envvars(comp.get_language())
                 self.coredata.external_args[comp.get_language()] = ext_compile_flags
                 self.coredata.external_link_args[comp.get_language()] = ext_link_flags
@@ -1024,7 +1028,7 @@ class Interpreter():
 
     def func_jar(self, node, args, kwargs):
         return self.build_target(node, args, kwargs, JarHolder)
-    
+
     def func_custom_target(self, node, args, kwargs):
         if len(args) != 1:
             raise InterpreterException('Incorrect number of arguments')
@@ -1040,6 +1044,24 @@ class Interpreter():
         self.build.targets[name] = tg.held_object
         return tg
 
+    def func_run_target(self, node, args, kwargs):
+        if len(args) < 2:
+            raise InterpreterException('Incorrect number of arguments')
+        for i in args:
+            if not isinstance(i, str):
+                raise InvalidArguments('Argument is not a string')
+        name = args[0]
+        if name in coredata.forbidden_target_names:
+            raise InvalidArguments('Target name "%s" is reserved for Meson\'s internal use. Please rename.'\
+                                   % name)
+        if name in self.build.targets:
+            raise InvalidCode('Tried to create target "%s", but a target of that name already exists.' % name)
+        command = args[1]
+        cmd_args = args[2:]
+        tg = RunTargetHolder(name, command, cmd_args, self.subdir)
+        self.build.targets[name] = tg.held_object
+        return tg
+
     def func_generator(self, node, args, kwargs):
         gen = GeneratorHolder(args, kwargs)
         self.generators.append(gen)

ninjabackend.py

@@ -153,6 +153,16 @@ class NinjaBackend(backends.Backend):
         elem.write(outfile)
         self.processed_targets[target.name] = True
 
+    def generate_run_target(self, target, outfile):
+        runnerscript = os.path.join(self.environment.get_script_dir(), 'commandrunner.py')
+        elem = NinjaBuildElement(target.name, 'CUSTOM_COMMAND', [])
+        cmd = [sys.executable, runnerscript, self.environment.get_source_dir(), self.environment.get_build_dir(),
+               target.subdir, target.command] + target.args
+        elem.add_item('COMMAND', cmd)
+        elem.add_item('description', 'Running external command %s.' % target.name)
+        elem.write(outfile)
+        self.processed_targets[target.name] = True
+
     def generate_po(self, outfile):
         for p in self.build.pot:
             (packagename, languages, subdir) = p

test cases/common/56 custom target/meson.build

@@ -2,7 +2,7 @@ project('custom target', 'c')
 
 python = find_program('python3')
 
-# Note that this will not add a depencency to the compiler executable.
+# Note that this will not add a dependency to the compiler executable.
 # Code will not be rebuilt if it changes.
 comp = '@0@/@1@'.format(meson.current_source_dir(), 'my_compiler.py')
 

test cases/common/58 run target/meson.build

@@ -0,0 +1,3 @@
+project('run target', 'c')
+
+run_target('mycommand', 'scripts/script.sh')

test cases/common/58 run target/scripts/script.sh

@@ -0,0 +1,5 @@
+#!/bin/sh
+
+cd "$MESON_SOURCE_ROOT"
+echo My current directory is `pwd`
+echo Build dir is at $MESON_BUILD_ROOT