From 683cf46f327851c062ad92e2651bf5294ba2d068 Mon Sep 17 00:00:00 2001 From: Michael Date: Sun, 2 Feb 2020 17:16:03 -0800 Subject: [PATCH 1/4] add new templates --- mesonbuild/templates/cstemplates.py | 126 +++++++++++++++++ mesonbuild/templates/cudatemplates.py | 177 ++++++++++++++++++++++++ mesonbuild/templates/javatemplates.py | 129 +++++++++++++++++ mesonbuild/templates/mesontemplates.py | 51 +++++++ mesonbuild/templates/objcpptemplates.py | 156 +++++++++++++++++++++ 5 files changed, 639 insertions(+) create mode 100644 mesonbuild/templates/cstemplates.py create mode 100644 mesonbuild/templates/cudatemplates.py create mode 100644 mesonbuild/templates/javatemplates.py create mode 100644 mesonbuild/templates/mesontemplates.py create mode 100644 mesonbuild/templates/objcpptemplates.py diff --git a/mesonbuild/templates/cstemplates.py b/mesonbuild/templates/cstemplates.py new file mode 100644 index 000000000..baf2e8e9a --- /dev/null +++ b/mesonbuild/templates/cstemplates.py @@ -0,0 +1,126 @@ +# Copyright 2019 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 re + + +hello_cs_template = '''using System; + +public class {class_name} {{ + const String PROJECT_NAME = "{project_name}"; + + static int Main(String[] args) {{ + if (args.Length > 0) {{ + System.Console.WriteLine(String.Format("{project_name} takes no arguments..")); + return 1; + }} + Console.WriteLine(String.Format("This is project {{0}}.", PROJECT_NAME)); + return 0; + }} +}} + +''' + +hello_cs_meson_template = '''project('{project_name}', 'cs', + version : '{version}', + default_options : ['warning_level=3']) + +exe = executable('{exe_name}', '{source_name}', + install : true) + +test('basic', exe) +''' + +lib_cs_template = ''' +public class {class_name} {{ + private const int number = 6; + + public int get_number() {{ + return number; + }} +}} + +''' + +lib_cs_test_template = '''using System; + +public class {class_test} {{ + static int Main(String[] args) {{ + if (args.Length > 0) {{ + System.Console.WriteLine("{project_name} takes no arguments.."); + return 1; + }} + {class_name} c = new {class_name}(); + Boolean result = true; + return result.CompareTo(c.get_number() != 6); + }} +}} + +''' + +lib_cs_meson_template = '''project('{project_name}', 'cs', + version : '{version}', + default_options : ['warning_level=3']) + +stlib = shared_library('{lib_name}', '{source_file}', + install : true, +) + +test_exe = executable('{test_exe_name}', '{test_source_file}', + link_with : stlib) +test('{test_name}', test_exe) + +# Make this library usable as a Meson subproject. +{ltoken}_dep = declare_dependency( + include_directories: include_directories('.'), + link_with : stlib) + +''' + + +def create_exe_cs_sample(project_name, project_version): + lowercase_token = re.sub(r'[^a-z0-9]', '_', project_name.lower()) + uppercase_token = lowercase_token.upper() + class_name = uppercase_token[0] + lowercase_token[1:] + source_name = uppercase_token[0] + lowercase_token[1:] + '.cs' + open(source_name, 'w').write(hello_cs_template.format(project_name=project_name, + class_name=class_name)) + open('meson.build', 'w').write(hello_cs_meson_template.format(project_name=project_name, + exe_name=project_name, + source_name=source_name, + version=project_version)) + + +def create_lib_cs_sample(project_name, version): + lowercase_token = re.sub(r'[^a-z0-9]', '_', project_name.lower()) + uppercase_token = lowercase_token.upper() + class_name = uppercase_token[0] + lowercase_token[1:] + class_test = uppercase_token[0] + lowercase_token[1:] + '_test' + project_test = lowercase_token + '_test' + lib_cs_name = uppercase_token[0] + lowercase_token[1:] + '.cs' + test_cs_name = uppercase_token[0] + lowercase_token[1:] + '_test.cs' + kwargs = {'utoken': uppercase_token, + 'ltoken': lowercase_token, + 'class_test': class_test, + 'class_name': class_name, + 'source_file': lib_cs_name, + 'test_source_file': test_cs_name, + 'test_exe_name': project_test, + 'project_name': project_name, + 'lib_name': lowercase_token, + 'test_name': lowercase_token, + 'version': version, + } + open(lib_cs_name, 'w').write(lib_cs_template.format(**kwargs)) + open(test_cs_name, 'w').write(lib_cs_test_template.format(**kwargs)) + open('meson.build', 'w').write(lib_cs_meson_template.format(**kwargs)) diff --git a/mesonbuild/templates/cudatemplates.py b/mesonbuild/templates/cudatemplates.py new file mode 100644 index 000000000..d083fe89d --- /dev/null +++ b/mesonbuild/templates/cudatemplates.py @@ -0,0 +1,177 @@ +# Copyright 2019 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 re + + +hello_cuda_template = '''#include + +#define PROJECT_NAME "{project_name}" + +int main(int argc, char **argv) {{ + if(argc != 1) {{ + std::cout << argv[0] << "takes no arguments.\\n"; + return 1; + }} + std::cout << "This is project " << PROJECT_NAME << ".\\n"; + return 0; +}} +''' + +hello_cuda_meson_template = '''project('{project_name}', 'cpp', + version : '{version}', + default_options : ['warning_level=3', + 'cpp_std=c++14']) + +exe = executable('{exe_name}', '{source_name}', + install : true) + +test('basic', exe) +''' + +lib_h_template = '''#pragma once +#if defined _WIN32 || defined __CYGWIN__ + #ifdef BUILDING_{utoken} + #define {utoken}_PUBLIC __declspec(dllexport) + #else + #define {utoken}_PUBLIC __declspec(dllimport) + #endif +#else + #ifdef BUILDING_{utoken} + #define {utoken}_PUBLIC __attribute__ ((visibility ("default"))) + #else + #define {utoken}_PUBLIC + #endif +#endif + +namespace {namespace} {{ + +class {utoken}_PUBLIC {class_name} {{ + +public: + {class_name}(); + int get_number() const; + +private: + + int number; + +}}; + +}} + +''' + +lib_cuda_template = '''#include <{header_file}> + +namespace {namespace} {{ + +{class_name}::{class_name}() {{ + number = 6; +}} + +int {class_name}::get_number() const {{ + return number; +}} + +}} +''' + +lib_cuda_test_template = '''#include <{header_file}> +#include + +int main(int argc, char **argv) {{ + if(argc != 1) {{ + std::cout << argv[0] << " takes no arguments.\\n"; + return 1; + }} + {namespace}::{class_name} c; + return c.get_number() != 6; +}} +''' + +lib_cuda_meson_template = '''project('{project_name}', 'cuda', + version : '{version}', + default_options : ['warning_level=3']) + +# These arguments are only used to build the shared library +# not the executables that use the library. +lib_args = ['-DBUILDING_{utoken}'] + +shlib = shared_library('{lib_name}', '{source_file}', + install : true, + cpp_args : lib_args, + gnu_symbol_visibility : 'hidden', +) + +test_exe = executable('{test_exe_name}', '{test_source_file}', + link_with : shlib) +test('{test_name}', test_exe) + +# Make this library usable as a Meson subproject. +{ltoken}_dep = declare_dependency( + include_directories: include_directories('.'), + link_with : shlib) + +# Make this library usable from the system's +# package manager. +install_headers('{header_file}', subdir : '{header_dir}') + +pkg_mod = import('pkgconfig') +pkg_mod.generate( + name : '{project_name}', + filebase : '{ltoken}', + description : 'Meson sample project.', + subdirs : '{header_dir}', + libraries : shlib, + version : '{version}', +) +''' + + +def create_exe_cuda_sample(project_name, project_version): + lowercase_token = re.sub(r'[^a-z0-9]', '_', project_name.lower()) + source_name = lowercase_token + '.cu' + open(source_name, 'w').write(hello_cuda_template.format(project_name=project_name)) + open('meson.build', 'w').write(hello_cuda_meson_template.format(project_name=project_name, + exe_name=lowercase_token, + source_name=source_name, + version=project_version)) + + +def create_lib_cuda_sample(project_name, version): + lowercase_token = re.sub(r'[^a-z0-9]', '_', project_name.lower()) + uppercase_token = lowercase_token.upper() + class_name = uppercase_token[0] + lowercase_token[1:] + namespace = lowercase_token + lib_h_name = lowercase_token + '.h' + lib_cuda_name = lowercase_token + '.cu' + test_cuda_name = lowercase_token + '_test.cu' + kwargs = {'utoken': uppercase_token, + 'ltoken': lowercase_token, + 'header_dir': lowercase_token, + 'class_name': class_name, + 'namespace': namespace, + 'header_file': lib_h_name, + 'source_file': lib_cuda_name, + 'test_source_file': test_cuda_name, + 'test_exe_name': lowercase_token, + 'project_name': project_name, + 'lib_name': lowercase_token, + 'test_name': lowercase_token, + 'version': version, + } + open(lib_h_name, 'w').write(lib_h_template.format(**kwargs)) + open(lib_cuda_name, 'w').write(lib_cuda_template.format(**kwargs)) + open(test_cuda_name, 'w').write(lib_cuda_test_template.format(**kwargs)) + open('meson.build', 'w').write(lib_cuda_meson_template.format(**kwargs)) diff --git a/mesonbuild/templates/javatemplates.py b/mesonbuild/templates/javatemplates.py new file mode 100644 index 000000000..e8a8c15b4 --- /dev/null +++ b/mesonbuild/templates/javatemplates.py @@ -0,0 +1,129 @@ +# Copyright 2019 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 re + + +hello_java_template = ''' + +public class {class_name} {{ + final static String PROJECT_NAME = "{project_name}"; + + public static void main (String args[]) {{ + if(args.length != 0) {{ + System.out.println(args + " takes no arguments."); + System.exit(0); + }} + System.out.println("This is project " + PROJECT_NAME + "."); + System.exit(0); + }} +}} + +''' + +hello_java_meson_template = '''project('{project_name}', 'java', + version : '{version}', + default_options : ['warning_level=3']) + +exe = jar('{exe_name}', '{source_name}', + main_class : '{exe_name}', + install : true) + +test('basic', exe) +''' + +lib_java_template = ''' + +public class {class_name} {{ + final static int number = 6; + + public final int get_number() {{ + return number; + }} +}} + +''' + +lib_java_test_template = ''' + +public class {class_test} {{ + public static void main (String args[]) {{ + if(args.length != 0) {{ + System.out.println(args + " takes no arguments."); + System.exit(1); + }} + + {class_name} c = new {class_name}(); + Boolean result = true; + System.exit(result.compareTo(c.get_number() != 6)); + }} +}} + +''' + +lib_java_meson_template = '''project('{project_name}', 'java', + version : '{version}', + default_options : ['warning_level=3']) + +jarlib = jar('{class_name}', '{source_file}', + main_class : '{class_name}', + install : true, +) + +test_jar = jar('{class_test}', '{test_source_file}', + main_class : '{class_test}', + link_with : jarlib) +test('{test_name}', test_jar) + +# Make this library usable as a Meson subproject. +{ltoken}_dep = declare_dependency( + include_directories: include_directories('.'), + link_with : jarlib) +''' + + +def create_exe_java_sample(project_name, project_version): + lowercase_token = re.sub(r'[^a-z0-9]', '_', project_name.lower()) + uppercase_token = lowercase_token.upper() + class_name = uppercase_token[0] + lowercase_token[1:] + source_name = uppercase_token[0] + lowercase_token[1:] + '.java' + open(source_name, 'w').write(hello_java_template.format(project_name=project_name, + class_name=class_name)) + open('meson.build', 'w').write(hello_java_meson_template.format(project_name=project_name, + exe_name=class_name, + source_name=source_name, + version=project_version)) + + +def create_lib_java_sample(project_name, version): + lowercase_token = re.sub(r'[^a-z0-9]', '_', project_name.lower()) + uppercase_token = lowercase_token.upper() + class_name = uppercase_token[0] + lowercase_token[1:] + class_test = uppercase_token[0] + lowercase_token[1:] + '_test' + lib_java_name = uppercase_token[0] + lowercase_token[1:] + '.java' + test_java_name = uppercase_token[0] + lowercase_token[1:] + '_test.java' + kwargs = {'utoken': uppercase_token, + 'ltoken': lowercase_token, + 'class_test': class_test, + 'class_name': class_name, + 'source_file': lib_java_name, + 'test_source_file': test_java_name, + 'test_exe_name': lowercase_token, + 'project_name': project_name, + 'lib_name': lowercase_token, + 'test_name': lowercase_token, + 'version': version, + } + open(lib_java_name, 'w').write(lib_java_template.format(**kwargs)) + open(test_java_name, 'w').write(lib_java_test_template.format(**kwargs)) + open('meson.build', 'w').write(lib_java_meson_template.format(**kwargs)) diff --git a/mesonbuild/templates/mesontemplates.py b/mesonbuild/templates/mesontemplates.py new file mode 100644 index 000000000..f9dd442bd --- /dev/null +++ b/mesonbuild/templates/mesontemplates.py @@ -0,0 +1,51 @@ +# Copyright 2019 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. + +meson_executable_template = '''project('{project_name}', '{language}', + version : '{version}', + default_options : [{default_options}]) + +executable('{executable}', + {sourcespec},{depspec} + install : true) +''' + +def create_meson_build(options): + if options.type != 'executable': + raise SystemExit('\nGenerating a meson.build file from existing sources is\n' + 'supported only for project type "executable".\n' + 'Run meson init in an empty directory to create a sample project.') + default_options = ['warning_level=3'] + if options.language == 'cpp': + # This shows how to set this very common option. + default_options += ['cpp_std=c++14'] + # If we get a meson.build autoformatter one day, this code could + # be simplified quite a bit. + formatted_default_options = ', '.join("'{}'".format(x) for x in default_options) + sourcespec = ',\n '.join("'{}'".format(x) for x in options.srcfiles) + depspec = '' + if options.deps: + depspec = '\n dependencies : [\n ' + depspec += ',\n '.join("dependency('{}')".format(x) + for x in options.deps.split(',')) + depspec += '],' + content = meson_executable_template.format(project_name=options.name, + language=options.language, + version=options.version, + executable=options.executable, + sourcespec=sourcespec, + depspec=depspec, + default_options=formatted_default_options) + open('meson.build', 'w').write(content) + print('Generated meson.build file:\n\n' + content) diff --git a/mesonbuild/templates/objcpptemplates.py b/mesonbuild/templates/objcpptemplates.py new file mode 100644 index 000000000..329a568ff --- /dev/null +++ b/mesonbuild/templates/objcpptemplates.py @@ -0,0 +1,156 @@ +# Copyright 2019 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 re + + +lib_h_template = '''#pragma once +#if defined _WIN32 || defined __CYGWIN__ + #ifdef BUILDING_{utoken} + #define {utoken}_PUBLIC __declspec(dllexport) + #else + #define {utoken}_PUBLIC __declspec(dllimport) + #endif +#else + #ifdef BUILDING_{utoken} + #define {utoken}_PUBLIC __attribute__ ((visibility ("default"))) + #else + #define {utoken}_PUBLIC + #endif +#endif + +int {utoken}_PUBLIC {function_name}(); + +''' + +lib_objcpp_template = '''#import <{header_file}> + +/* This function will not be exported and is not + * directly callable by users of this library. + */ +int internal_function() {{ + return 0; +}} + +int {function_name}() {{ + return internal_function(); +}} +''' + +lib_objcpp_test_template = '''#import <{header_file}> +#import + +int main(int argc, char **argv) {{ + if(argc != 1) {{ + std::cout << argv[0] << " takes no arguments." << std::endl; + return 1; + }} + return {function_name}(); +}} +''' + +lib_objcpp_meson_template = '''project('{project_name}', 'objcpp', + version : '{version}', + default_options : ['warning_level=3']) + +# These arguments are only used to build the shared library +# not the executables that use the library. +lib_args = ['-DBUILDING_{utoken}'] + +shlib = shared_library('{lib_name}', '{source_file}', + install : true, + objcpp_args : lib_args, + gnu_symbol_visibility : 'hidden', +) + +test_exe = executable('{test_exe_name}', '{test_source_file}', + link_with : shlib) +test('{test_name}', test_exe) + +# Make this library usable as a Meson subproject. +{ltoken}_dep = declare_dependency( + include_directories: include_directories('.'), + link_with : shlib) + +# Make this library usable from the system's +# package manager. +install_headers('{header_file}', subdir : '{header_dir}') + +pkg_mod = import('pkgconfig') +pkg_mod.generate( + name : '{project_name}', + filebase : '{ltoken}', + description : 'Meson sample project.', + subdirs : '{header_dir}', + libraries : shlib, + version : '{version}', +) +''' + +hello_objcpp_template = '''#import + +#define PROJECT_NAME "{project_name}" + +int main(int argc, char **argv) {{ + if(argc != 1) {{ + std::cout << argv[0] << " takes no arguments." << std::endl; + return 1; + }} + std::cout << "This is project " << PROJECT_NAME << "." << std::endl; + return 0; +}} +''' + +hello_objcpp_meson_template = '''project('{project_name}', 'objcpp', + version : '{version}', + default_options : ['warning_level=3']) + +exe = executable('{exe_name}', '{source_name}', + install : true) + +test('basic', exe) +''' + +def create_exe_objcpp_sample(project_name, project_version): + lowercase_token = re.sub(r'[^a-z0-9]', '_', project_name.lower()) + source_name = lowercase_token + '.mm' + open(source_name, 'w').write(hello_objcpp_template.format(project_name=project_name)) + open('meson.build', 'w').write(hello_objcpp_meson_template.format(project_name=project_name, + exe_name=lowercase_token, + source_name=source_name, + version=project_version)) + +def create_lib_objcpp_sample(project_name, version): + lowercase_token = re.sub(r'[^a-z0-9]', '_', project_name.lower()) + uppercase_token = lowercase_token.upper() + function_name = lowercase_token[0:3] + '_func' + lib_h_name = lowercase_token + '.h' + lib_objcpp_name = lowercase_token + '.mm' + test_objcpp_name = lowercase_token + '_test.mm' + kwargs = {'utoken': uppercase_token, + 'ltoken': lowercase_token, + 'header_dir': lowercase_token, + 'function_name': function_name, + 'header_file': lib_h_name, + 'source_file': lib_objcpp_name, + 'test_source_file': test_objcpp_name, + 'test_exe_name': lowercase_token, + 'project_name': project_name, + 'lib_name': lowercase_token, + 'test_name': lowercase_token, + 'version': version, + } + open(lib_h_name, 'w').write(lib_h_template.format(**kwargs)) + open(lib_objcpp_name, 'w').write(lib_objcpp_template.format(**kwargs)) + open(test_objcpp_name, 'w').write(lib_objcpp_test_template.format(**kwargs)) + open('meson.build', 'w').write(lib_objcpp_meson_template.format(**kwargs)) From bbc2745dccc40761989a3e1efbe5a69eea0bc77e Mon Sep 17 00:00:00 2001 From: Michael Date: Sun, 2 Feb 2020 17:16:32 -0800 Subject: [PATCH 2/4] update the init command --- mesonbuild/minit.py | 136 ++++++++++++++++++++++++++------------------ 1 file changed, 80 insertions(+), 56 deletions(-) diff --git a/mesonbuild/minit.py b/mesonbuild/minit.py index 79741e5bd..5f28f5818 100644 --- a/mesonbuild/minit.py +++ b/mesonbuild/minit.py @@ -22,13 +22,24 @@ from mesonbuild.environment import detect_ninja from mesonbuild.templates.ctemplates import (create_exe_c_sample, create_lib_c_sample) from mesonbuild.templates.cpptemplates import (create_exe_cpp_sample, create_lib_cpp_sample) +from mesonbuild.templates.cstemplates import (create_exe_cs_sample, create_lib_cs_sample) +from mesonbuild.templates.cudatemplates import (create_exe_cuda_sample, create_lib_cuda_sample) from mesonbuild.templates.objctemplates import (create_exe_objc_sample, create_lib_objc_sample) +from mesonbuild.templates.objcpptemplates import (create_exe_objcpp_sample, create_lib_objcpp_sample) from mesonbuild.templates.dlangtemplates import (create_exe_d_sample, create_lib_d_sample) +from mesonbuild.templates.javatemplates import (create_exe_java_sample, create_lib_java_sample) from mesonbuild.templates.fortrantemplates import (create_exe_fortran_sample, create_lib_fortran_sample) from mesonbuild.templates.rusttemplates import (create_exe_rust_sample, create_lib_rust_sample) +''' +there is currently only one meson template at this time. +''' +from mesonbuild.templates.mesontemplates import create_meson_build + FORTRAN_SUFFIXES = ['.f', '.for', '.F', '.f90', '.F90'] +UNREACHABLE_CODE = 'Unreachable code' + info_message = '''Sample project created. To build it run the following commands: @@ -37,53 +48,89 @@ ninja -C builddir ''' def create_sample(options): + ''' + Based on what arguments are passed we check for a match in language + then check for project type and create new Meson samples project. + ''' if options.language == 'c': if options.type == 'executable': create_exe_c_sample(options.name, options.version) elif options.type == 'library': create_lib_c_sample(options.name, options.version) else: - raise RuntimeError('Unreachable code') + raise RuntimeError(UNREACHABLE_CODE) elif options.language == 'cpp': if options.type == 'executable': create_exe_cpp_sample(options.name, options.version) elif options.type == 'library': create_lib_cpp_sample(options.name, options.version) else: - raise RuntimeError('Unreachable code') + raise RuntimeError(UNREACHABLE_CODE) + elif options.language == 'cs': + if options.type == 'executable': + create_exe_cs_sample(options.name, options.version) + elif options.type == 'library': + create_lib_cs_sample(options.name, options.version) + else: + raise RuntimeError(UNREACHABLE_CODE) + elif options.language == 'cuda': + if options.type == 'executable': + create_exe_cuda_sample(options.name, options.version) + elif options.type == 'library': + create_lib_cuda_sample(options.name, options.version) + else: + raise RuntimeError(UNREACHABLE_CODE) elif options.language == 'd': if options.type == 'executable': create_exe_d_sample(options.name, options.version) elif options.type == 'library': create_lib_d_sample(options.name, options.version) else: - raise RuntimeError('Unreachable code') + raise RuntimeError(UNREACHABLE_CODE) elif options.language == 'fortran': if options.type == 'executable': create_exe_fortran_sample(options.name, options.version) elif options.type == 'library': create_lib_fortran_sample(options.name, options.version) else: - raise RuntimeError('Unreachable code') + raise RuntimeError(UNREACHABLE_CODE) elif options.language == 'rust': if options.type == 'executable': create_exe_rust_sample(options.name, options.version) elif options.type == 'library': create_lib_rust_sample(options.name, options.version) else: - raise RuntimeError('Unreachable code') + raise RuntimeError(UNREACHABLE_CODE) elif options.language == 'objc': if options.type == 'executable': create_exe_objc_sample(options.name, options.version) elif options.type == 'library': create_lib_objc_sample(options.name, options.version) else: - raise RuntimeError('Unreachable code') + raise RuntimeError(UNREACHABLE_CODE) + elif options.language == 'objcpp': + if options.type == 'executable': + create_exe_objcpp_sample(options.name, options.version) + elif options.type == 'library': + create_lib_objcpp_sample(options.name, options.version) + else: + raise RuntimeError(UNREACHABLE_CODE) + elif options.language == 'java': + if options.type == 'executable': + create_exe_java_sample(options.name, options.version) + elif options.type == 'library': + create_lib_java_sample(options.name, options.version) + else: + raise RuntimeError(UNREACHABLE_CODE) else: - raise RuntimeError('Unreachable code') + raise RuntimeError(UNREACHABLE_CODE) print(info_message) def autodetect_options(options, sample: bool = False): + ''' + Here we autodetect options for args not passed in so don't have to + think about it. + ''' if not options.name: options.name = Path().resolve().stem if not re.match('[a-zA-Z_][a-zA-Z0-9]*', options.name) and sample: @@ -101,7 +148,7 @@ def autodetect_options(options, sample: bool = False): if not options.srcfiles: srcfiles = [] for f in (f for f in Path().iterdir() if f.is_file()): - if f.suffix in (['.cc', '.cpp', '.c', '.d', '.m', '.rs'] + FORTRAN_SUFFIXES): + if f.suffix in (['.c', '.cc', '.cpp', '.cs', '.cu', '.d', '.m', '.mm', '.rs', '.java'] + FORTRAN_SUFFIXES): srcfiles.append(f) if not srcfiles: raise SystemExit('No recognizable source files found.\n' @@ -111,11 +158,17 @@ def autodetect_options(options, sample: bool = False): options.srcfiles = [Path(f) for f in options.srcfiles] if not options.language: for f in options.srcfiles: + if f.suffix == '.c': + options.language = 'c' + break if f.suffix in ('.cc', '.cpp'): options.language = 'cpp' break - if f.suffix == '.c': - options.language = 'c' + if f.suffix in '.cs': + options.language = 'cs' + break + if f.suffix == '.cu': + options.language = 'cuda' break if f.suffix == '.d': options.language = 'd' @@ -129,66 +182,37 @@ def autodetect_options(options, sample: bool = False): if f.suffix == '.m': options.language = 'objc' break + if f.suffix == '.mm': + options.language = 'objcpp' + break + if f.suffix == '.java': + options.language = 'java' + break if not options.language: raise SystemExit("Can't autodetect language, please specify it with -l.") print("Detected language: " + options.language) - -meson_executable_template = '''project('{project_name}', '{language}', - version : '{version}', - default_options : [{default_options}]) - -executable('{executable}', - {sourcespec},{depspec} - install : true) -''' - -def create_meson_build(options): - if options.type != 'executable': - raise SystemExit('\nGenerating a meson.build file from existing sources is\n' - 'supported only for project type "executable".\n' - 'Run meson init in an empty directory to create a sample project.') - default_options = ['warning_level=3'] - if options.language == 'cpp': - # This shows how to set this very common option. - default_options += ['cpp_std=c++14'] - # If we get a meson.build autoformatter one day, this code could - # be simplified quite a bit. - formatted_default_options = ', '.join("'{}'".format(x) for x in default_options) - sourcespec = ',\n '.join("'{}'".format(x) for x in options.srcfiles) - depspec = '' - if options.deps: - depspec = '\n dependencies : [\n ' - depspec += ',\n '.join("dependency('{}')".format(x) - for x in options.deps.split(',')) - depspec += '],' - content = meson_executable_template.format(project_name=options.name, - language=options.language, - version=options.version, - executable=options.executable, - sourcespec=sourcespec, - depspec=depspec, - default_options=formatted_default_options) - open('meson.build', 'w').write(content) - print('Generated meson.build file:\n\n' + content) - def add_arguments(parser): - parser.add_argument("srcfiles", metavar="sourcefile", nargs="*", - help="source files. default: all recognized files in current directory") + ''' + Here we add args for that the user can passed when making a new + Meson project. + ''' + parser.add_argument("srcfiles", metavar="sourcefile", nargs="*", help="source files. default: all recognized files in current directory") parser.add_argument("-n", "--name", help="project name. default: name of current directory") parser.add_argument("-e", "--executable", help="executable name. default: project name") parser.add_argument("-d", "--deps", help="dependencies, comma-separated") - parser.add_argument("-l", "--language", choices=['c', 'cpp', 'd', 'fortran', 'rust', 'objc'], + parser.add_argument("-l", "--language", choices=['c', 'cpp', 'cs', 'cuda', 'd', 'fortran', 'java', 'rust', 'objc', 'objcpp'], help="project language. default: autodetected based on source files") parser.add_argument("-b", "--build", help="build after generation", action='store_true') parser.add_argument("--builddir", help="directory for build", default='build') - parser.add_argument("-f", "--force", action="store_true", - help="force overwrite of existing files and directories.") - parser.add_argument('--type', default='executable', - choices=['executable', 'library']) + parser.add_argument("-f", "--force", action="store_true", help="force overwrite of existing files and directories.") + parser.add_argument('--type', default='executable', choices=['executable', 'library']) parser.add_argument('--version', default='0.1') def run(options) -> int: + ''' + Here we generate the new Meson sample project. + ''' if not glob('*'): autodetect_options(options, sample=True) if not options.language: From ec12b39658bfc26da8d66c54d077c09acf141636 Mon Sep 17 00:00:00 2001 From: Michael Date: Sun, 2 Feb 2020 17:18:57 -0800 Subject: [PATCH 3/4] add feature note --- docs/markdown/snippets/more_meson_sample_templates.md | 6 ++++++ 1 file changed, 6 insertions(+) create mode 100644 docs/markdown/snippets/more_meson_sample_templates.md diff --git a/docs/markdown/snippets/more_meson_sample_templates.md b/docs/markdown/snippets/more_meson_sample_templates.md new file mode 100644 index 000000000..e10da9cd6 --- /dev/null +++ b/docs/markdown/snippets/more_meson_sample_templates.md @@ -0,0 +1,6 @@ +## More new sample Meson templates for (`Java`, `Cuda`, and more) + +Meson now ships with predefined project templates for `Java`, +`Cuda`, `Objective-C++`, and `C#`, we provided with associated +values for corresponding languages, avalable for both library, +and executable. From b2b7fca320156b6375cc69eed6621bedccef3827 Mon Sep 17 00:00:00 2001 From: Michael Date: Sun, 2 Feb 2020 17:19:42 -0800 Subject: [PATCH 4/4] update test_templates in run_unittests.py --- run_unittests.py | 24 +++++++++++++++++++++--- 1 file changed, 21 insertions(+), 3 deletions(-) diff --git a/run_unittests.py b/run_unittests.py index cf4095514..78bdc68f6 100755 --- a/run_unittests.py +++ b/run_unittests.py @@ -3118,16 +3118,29 @@ int main(int argc, char **argv) { langs.append('cpp') except EnvironmentException: pass + try: + env.detect_cs_compiler(MachineChoice.HOST) + langs.append('cs') + except EnvironmentException: + pass try: env.detect_d_compiler(MachineChoice.HOST) langs.append('d') except EnvironmentException: pass + try: + env.detect_java_compiler(MachineChoice.HOST) + langs.append('java') + except EnvironmentException: + pass + try: + env.detect_cuda_compiler(MachineChoice.HOST) + langs.append('cuda') + except EnvironmentException: + pass try: env.detect_fortran_compiler(MachineChoice.HOST) - if is_windows() or platform.machine().lower() != 'e2k': - # Elbrus Fortran compiler can't generate debug information - langs.append('fortran') + langs.append('fortran') except EnvironmentException: pass try: @@ -3135,6 +3148,11 @@ int main(int argc, char **argv) { langs.append('objc') except EnvironmentException: pass + try: + env.detect_objcpp_compiler(MachineChoice.HOST) + langs.append('objcpp') + except EnvironmentException: + pass # FIXME: omitting rust as Windows AppVeyor CI finds Rust but doesn't link correctly for lang in langs: