# SPDX-License-Identifier: Apache-2.0 # Copyright 2017 The Meson development team """Code that creates simple startup projects.""" from __future__ import annotations from pathlib import Path from enum import Enum import subprocess import shutil import sys import os import re from glob import glob import typing as T from mesonbuild import build, mesonlib, mlog from mesonbuild.coredata import FORBIDDEN_TARGET_NAMES from mesonbuild.environment import detect_ninja from mesonbuild.templates.mesontemplates import create_meson_build from mesonbuild.templates.samplefactory import sample_generator from mesonbuild.options import OptionKey if T.TYPE_CHECKING: import argparse from typing_extensions import Protocol, Literal class Arguments(Protocol): srcfiles: T.List[Path] wd: str name: str executable: str deps: str language: Literal['c', 'cpp', 'cs', 'cuda', 'd', 'fortran', 'java', 'rust', 'objc', 'objcpp', 'vala'] build: bool builddir: str force: bool type: Literal['executable', 'library'] version: str FORTRAN_SUFFIXES = {'.f', '.for', '.F', '.f90', '.F90'} LANG_SUFFIXES = {'.c', '.cc', '.cpp', '.cs', '.cu', '.d', '.m', '.mm', '.rs', '.java', '.vala'} | FORTRAN_SUFFIXES LANG_SUPPORTED = {'c', 'cpp', 'cs', 'cuda', 'd', 'fortran', 'java', 'rust', 'objc', 'objcpp', 'vala'} DEFAULT_PROJECT = 'executable' DEFAULT_VERSION = '0.1' class DEFAULT_TYPES(Enum): EXE = 'executable' LIB = 'library' INFO_MESSAGE = '''Sample project created. To build it run the following commands: meson setup builddir meson compile -C builddir ''' def create_sample(options: Arguments) -> None: ''' Based on what arguments are passed we check for a match in language then check for project type and create new Meson samples project. ''' sample_gen = sample_generator(options) if options.type == DEFAULT_TYPES['EXE'].value: sample_gen.create_executable() elif options.type == DEFAULT_TYPES['LIB'].value: sample_gen.create_library() else: raise RuntimeError('Unreachable code') print(INFO_MESSAGE) def autodetect_options(options: Arguments, sample: bool = False) -> None: ''' 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: raise SystemExit(f'Name of current directory "{options.name}" is not usable as a sample project name.\n' 'Specify a project name with --name.') print(f'Using "{options.name}" (name of current directory) as project name.') if not options.executable: options.executable = options.name print(f'Using "{options.executable}" (project name) as name of executable to build.') if options.executable in FORBIDDEN_TARGET_NAMES: raise mesonlib.MesonException(f'Executable name {options.executable!r} is reserved for Meson internal use. ' 'Refusing to init an invalid project.') if sample: # The rest of the autodetection is not applicable to generating sample projects. return if not options.srcfiles: srcfiles: T.List[Path] = [] for f in (f for f in Path().iterdir() if f.is_file()): if f.suffix in LANG_SUFFIXES: srcfiles.append(f) if not srcfiles: raise SystemExit('No recognizable source files found.\n' 'Run meson init in an empty directory to create a sample project.') options.srcfiles = srcfiles print("Detected source files: " + ' '.join(str(s) for s in 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 == '.cs': options.language = 'cs' break if f.suffix == '.cu': options.language = 'cuda' break if f.suffix == '.d': options.language = 'd' break if f.suffix in FORTRAN_SUFFIXES: options.language = 'fortran' break if f.suffix == '.rs': options.language = 'rust' break 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 f.suffix == '.vala': options.language = 'vala' break if not options.language: raise SystemExit("Can't autodetect language, please specify it with -l.") print("Detected language: " + options.language) # Note: when adding arguments, please also add them to the completion # scripts in $MESONSRC/data/shell-completions/ def add_arguments(parser: 'argparse.ArgumentParser') -> None: ''' Here we add args for that the user can passed when making a new Meson project. ''' parser.add_argument("srcfiles", metavar="sourcefile", nargs="*", type=Path, help="source files. default: all recognized files in current directory") parser.add_argument('-C', dest='wd', action=mesonlib.RealPathAction, help='directory to cd into before running') 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=sorted(LANG_SUPPORTED), help="project language. default: autodetected based on source files") parser.add_argument("-b", "--build", action='store_true', help="build after generation") parser.add_argument("--builddir", default='build', help="directory for build") parser.add_argument("-f", "--force", action="store_true", help="force overwrite of existing files and directories.") parser.add_argument('--type', default=DEFAULT_PROJECT, choices=('executable', 'library'), help=f"project type. default: {DEFAULT_PROJECT} based project") parser.add_argument('--version', default=DEFAULT_VERSION, help=f"project version. default: {DEFAULT_VERSION}") def run(options: Arguments) -> int: ''' Here we generate the new Meson sample project. ''' if not Path(options.wd).exists(): sys.exit('Project source root directory not found. Run this command in source directory root.') os.chdir(options.wd) if not glob('*'): autodetect_options(options, sample=True) if not options.language: print('Defaulting to generating a C language project.') options.language = 'c' create_sample(options) else: autodetect_options(options) if Path('meson.build').is_file() and not options.force: raise SystemExit('meson.build already exists. Use --force to overwrite.') create_meson_build(options) if options.build: if Path(options.builddir).is_dir() and options.force: print('Build directory already exists, deleting it.') shutil.rmtree(options.builddir) print('Building...') cmd = mesonlib.get_meson_command() + ['setup', options.builddir] ret = subprocess.run(cmd) if ret.returncode: raise SystemExit b = build.load(options.builddir) need_vsenv = T.cast('bool', b.environment.coredata.get_option(OptionKey('vsenv'))) vsenv_active = mesonlib.setup_vsenv(need_vsenv) if vsenv_active: mlog.log(mlog.green('INFO:'), 'automatically activated MSVC compiler environment') cmd = detect_ninja() + ['-C', options.builddir] ret = subprocess.run(cmd) if ret.returncode: raise SystemExit return 0