Chiebot-Mirror
/
meson
mirror of https://github.com/mesonbuild/meson.git
8
0
Fork 0
Code Issues Projects Releases Wiki Activity

add new templates

Browse Source
pull/6573/head
Michael 5 years ago
parent 31f00c11d3
commit 683cf46f32
5 changed files with 639 additions and 0 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Split View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 126
      mesonbuild/templates/cstemplates.py
  2. 177
      mesonbuild/templates/cudatemplates.py
  3. 129
      mesonbuild/templates/javatemplates.py
  4. 51
      mesonbuild/templates/mesontemplates.py
  5. 156
      mesonbuild/templates/objcpptemplates.py

126
mesonbuild/templates/cstemplates.py
Unescape View File

@ -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))

177
mesonbuild/templates/cudatemplates.py
Unescape View File

@ -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 <iostream>
#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 <iostream>
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))

129
mesonbuild/templates/javatemplates.py
Unescape View File

@ -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))

51
mesonbuild/templates/mesontemplates.py
Unescape View File

@ -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)

156
mesonbuild/templates/objcpptemplates.py
Unescape View File

@ -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 <iostream>
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 <iostream>
#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))
Write Preview
Loading…
Cancel
Save