c9eef2d697
Most tools used for compliance and SBOM generation use SPDX identifiers This change brings us a step closer to an easy SBOM generation. Signed-off-by: Alin Jerpelea <alin.jerpelea@sony.com>
1675 lines
47 KiB
C
1675 lines
47 KiB
C
/****************************************************************************
|
||
* tools/configure.c
|
||
*
|
||
* SPDX-License-Identifier: Apache-2.0
|
||
*
|
||
* Licensed to the Apache Software Foundation (ASF) under one or more
|
||
* contributor license agreements. See the NOTICE file distributed with
|
||
* this work for additional information regarding copyright ownership. The
|
||
* ASF licenses this file to you 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.
|
||
*
|
||
****************************************************************************/
|
||
|
||
/****************************************************************************
|
||
* Included Files
|
||
****************************************************************************/
|
||
|
||
#include <sys/stat.h>
|
||
|
||
#include <stdint.h>
|
||
#include <stdbool.h>
|
||
#include <stdio.h>
|
||
#include <stdlib.h>
|
||
#include <stdarg.h>
|
||
#include <unistd.h>
|
||
#include <fcntl.h>
|
||
#include <string.h>
|
||
#include <dirent.h>
|
||
#include <libgen.h>
|
||
#include <errno.h>
|
||
|
||
#include "cfgparser.h"
|
||
|
||
/****************************************************************************
|
||
* Pre-processor Definitions
|
||
****************************************************************************/
|
||
|
||
#define BUFFER_SIZE 1024
|
||
|
||
#ifdef WIN32
|
||
# define strndup(x, y) strdup(x)
|
||
#endif
|
||
|
||
#define HOST_NOCHANGE 0
|
||
#define HOST_LINUX 1
|
||
#define HOST_MACOS 2
|
||
#define HOST_WINDOWS 3
|
||
#define HOST_BSD 4
|
||
|
||
#define WINDOWS_NATIVE 1
|
||
#define WINDOWS_CYGWIN 2
|
||
#define WINDOWS_MSYS 3
|
||
|
||
/****************************************************************************
|
||
* Private Function Prototypes
|
||
****************************************************************************/
|
||
|
||
static void show_usage(const char *progname, int exitcode);
|
||
static void dumpcfgs(void);
|
||
static void debug(const char *fmt, ...);
|
||
static void parse_args(int argc, char **argv);
|
||
static int run_make(const char *arg);
|
||
static bool filecmp(const char *f1, const char *f2);
|
||
static bool check_directory(const char *directory);
|
||
static void verify_directory(const char *directory);
|
||
static bool verify_optiondir(const char *directory);
|
||
static bool verify_file(const char *path);
|
||
static void find_topdir(void);
|
||
typedef void (*config_callback)(const char *boarddir, const char *archname,
|
||
const char *chipname, const char *boardname,
|
||
const char *configname, void *data);
|
||
static void config_search(const char *boarddir,
|
||
config_callback callback, void *data);
|
||
static void archname_callback(const char *boarddir, const char *archname,
|
||
const char *chipname, const char *boardname,
|
||
const char *configname, void *data);
|
||
static void find_archname(void);
|
||
static void enumerate_callback(const char *boarddir, const char *archname,
|
||
const char *chipname, const char *boardname,
|
||
const char *configname, void *data);
|
||
static void enumerate_configs(void);
|
||
static void check_configdir(void);
|
||
static void check_configured(void);
|
||
static void read_configfile(void);
|
||
static void read_versionfile(void);
|
||
static void get_verstring(void);
|
||
static bool verify_appdir(const char *appdir);
|
||
static void check_appdir(void);
|
||
static void check_configuration(void);
|
||
static void copy_file(const char *srcpath,
|
||
const char *destpath, mode_t mode);
|
||
static void substitute(char *str, int ch1, int ch2);
|
||
static char *double_appdir_backslashes(char *old_appdir);
|
||
static void copy_optional(void);
|
||
static void enable_feature(const char *destconfig, const char *varname);
|
||
static void disable_feature(const char *destconfig, const char *varname);
|
||
static void set_host(const char *destconfig);
|
||
static void configure(void);
|
||
static void refresh(void);
|
||
static void save_original_config(void);
|
||
|
||
/****************************************************************************
|
||
* Private Data
|
||
****************************************************************************/
|
||
|
||
#ifdef CONFIG_WINDOWS_NATIVE
|
||
static char g_delim = '\\'; /* Delimiter to use when forming paths */
|
||
static bool g_winpaths = true; /* True: Windows style paths */
|
||
#else
|
||
static char g_delim = '/'; /* Delimiter to use when forming paths */
|
||
static bool g_winpaths = false; /* False: POSIX style paths */
|
||
#endif
|
||
static bool g_debug = false; /* Enable debug output */
|
||
static bool g_enforce = false; /* Enfore distclean */
|
||
static bool g_distclean = false; /* Distclean if configured */
|
||
|
||
static const char *g_appdir = NULL; /* Relative path to the application directory */
|
||
static const char *g_archdir = NULL; /* Name of architecture subdirectory */
|
||
static const char *g_chipdir = NULL; /* Name of chip subdirectory */
|
||
static const char *g_boarddir = NULL; /* Name of board subdirectory */
|
||
static char *g_configdir = NULL; /* Name of configuration subdirectory */
|
||
|
||
static char *g_topdir = NULL; /* Full path to top-level NuttX build directory */
|
||
static char *g_apppath = NULL; /* Full path to the application directory */
|
||
static char *g_configtop = NULL; /* Full path to the top-level configuration directory */
|
||
static char *g_configpath = NULL; /* Full path to the configuration sub-directory */
|
||
static char *g_scriptspath = NULL; /* Full path to the scripts sub-directory */
|
||
static char *g_verstring = "0.0"; /* Version String */
|
||
|
||
static char *g_srcdefconfig = NULL; /* Source defconfig file */
|
||
static char *g_srcmakedefs = NULL; /* Source Make.defs file */
|
||
|
||
static char **g_makeargv = NULL; /* Arguments pass to make */
|
||
|
||
static bool g_winnative = false; /* True: Windows native configuration */
|
||
static bool g_oldnative = false; /* True: Was Windows native configuration */
|
||
static bool g_needapppath = true; /* Need to add app path to the .config file */
|
||
|
||
static uint8_t g_host = HOST_NOCHANGE;
|
||
static uint8_t g_windows = WINDOWS_CYGWIN;
|
||
|
||
static char g_buffer[BUFFER_SIZE]; /* Scratch buffer for forming full paths */
|
||
|
||
static struct variable_s *g_configvars = NULL;
|
||
static struct variable_s *g_versionvars = NULL;
|
||
|
||
/* Optional configuration files */
|
||
|
||
static const char *g_optfiles[] =
|
||
{
|
||
".gdbinit",
|
||
".cproject",
|
||
".project"
|
||
};
|
||
|
||
#define N_OPTFILES (sizeof(g_optfiles) / sizeof(const char *))
|
||
|
||
/****************************************************************************
|
||
* Private Functions
|
||
****************************************************************************/
|
||
|
||
static void show_usage(const char *progname, int exitcode)
|
||
{
|
||
fprintf(stderr, "\nUSAGE: %s [-d] [-E] [-e] [-b|f] [-L] [-l|m|c|g|n|B] "
|
||
"[-a <app-dir>] <board-name>:<config-name> [make-opts]\n",
|
||
progname);
|
||
fprintf(stderr, "\nUSAGE: %s [-h]\n", progname);
|
||
fprintf(stderr, "\nWhere:\n");
|
||
fprintf(stderr, " -d:\n");
|
||
fprintf(stderr, " Enables debug output\n");
|
||
fprintf(stderr, " -E:\n");
|
||
fprintf(stderr, " Enforce distclean if already configured\n");
|
||
fprintf(stderr, " -e:\n");
|
||
fprintf(stderr, " Performs distclean if configuration changed\n");
|
||
fprintf(stderr, " -b:\n");
|
||
#ifdef CONFIG_WINDOWS_NATIVE
|
||
fprintf(stderr, " Informs the tool that it should use Windows style\n");
|
||
fprintf(stderr, " paths like C:\\Program Files instead of POSIX\n");
|
||
fprintf(stderr, " style paths are used like /usr/local/bin. Windows\n");
|
||
fprintf(stderr, " style paths are used by default.\n");
|
||
#else
|
||
fprintf(stderr, " Informs the tool that it should use Windows style\n");
|
||
fprintf(stderr, " paths like C:\\Program Files. By default, POSIX\n");
|
||
fprintf(stderr, " style paths like /usr/local/bin are used.\n");
|
||
#endif
|
||
fprintf(stderr, " -f:\n");
|
||
#ifdef CONFIG_WINDOWS_NATIVE
|
||
fprintf(stderr, " Informs the tool that it should use POSIX style\n");
|
||
fprintf(stderr, " paths like /usr/local/bin. By default, Windows\n");
|
||
fprintf(stderr, " style paths like C:\\Program Files are used.\n");
|
||
#else
|
||
fprintf(stderr, " Informs the tool that it should use POSIX style\n");
|
||
fprintf(stderr, " paths like /usr/local/bin instead of Windows\n");
|
||
fprintf(stderr, " style paths like C:\\Program Files are used.\n");
|
||
fprintf(stderr, " POSIX style paths are used by default.\n");
|
||
#endif
|
||
fprintf(stderr, " [-l|m|c|g|n]\n");
|
||
fprintf(stderr, " Selects the host environment.\n");
|
||
fprintf(stderr, " -l Selects the Linux (l) host environment.\n");
|
||
fprintf(stderr, " -m Selects the macOS (m) host environment.\n");
|
||
fprintf(stderr, " -B Selects the *BSD (B) host environment.\n");
|
||
fprintf(stderr, " -c Selects the Windows Cygwin (c) environment.\n");
|
||
fprintf(stderr, " -g Selects the Windows MinGW/MSYS environment.\n");
|
||
fprintf(stderr, " -n Selects the Windows native (n) environment.\n");
|
||
fprintf(stderr, " Default: Use host setup in the defconfig file.\n");
|
||
fprintf(stderr, " Default Windows: Cygwin.\n");
|
||
fprintf(stderr, " -L:\n");
|
||
fprintf(stderr, " Lists all available configurations.\n");
|
||
fprintf(stderr, " -a <app-dir>:\n");
|
||
fprintf(stderr, " Informs the configuration tool where the\n");
|
||
fprintf(stderr, " application build directory. This is a relative\n");
|
||
fprintf(stderr, " path from the top-level NuttX build directory.\n");
|
||
fprintf(stderr, " But default, this tool will look in the usual\n");
|
||
fprintf(stderr, " places to locate the application directory:\n");
|
||
fprintf(stderr, " ..%capps or\n", g_delim);
|
||
fprintf(stderr, " ..%capps-xx.yy where xx.yy is the version number.\n",
|
||
g_delim);
|
||
fprintf(stderr, " <board-name>:\n");
|
||
fprintf(stderr, " Identifies the board. This must correspond to a\n");
|
||
fprintf(stderr, " board directory under nuttx%cboards%c.\n",
|
||
g_delim, g_delim);
|
||
fprintf(stderr, " <config-name>:\n");
|
||
fprintf(stderr, " Identifies the specific configuration for the\n");
|
||
fprintf(stderr, " selected <board-name>. This must correspond to\n");
|
||
fprintf(stderr, " a sub-directory under the board directory at\n");
|
||
fprintf(stderr, " under nuttx%cboards%c<board-name>%cconfigs%c.\n",
|
||
g_delim, g_delim, g_delim, g_delim);
|
||
fprintf(stderr, " [make-opts]:\n");
|
||
fprintf(stderr, " Options directly pass to make\n");
|
||
fprintf(stderr, " -h:\n");
|
||
fprintf(stderr, " Prints this message and exits.\n");
|
||
exit(exitcode);
|
||
}
|
||
|
||
static void dumpcfgs(void)
|
||
{
|
||
find_topdir();
|
||
snprintf(g_buffer, BUFFER_SIZE, "%s%cboards", g_topdir, g_delim);
|
||
verify_directory(g_buffer);
|
||
g_configtop = strdup(g_buffer);
|
||
enumerate_configs();
|
||
free(g_configtop);
|
||
exit(EXIT_SUCCESS);
|
||
}
|
||
|
||
static void debug(const char *fmt, ...)
|
||
{
|
||
va_list ap;
|
||
|
||
if (g_debug)
|
||
{
|
||
va_start(ap, fmt);
|
||
vprintf(fmt, ap);
|
||
va_end(ap);
|
||
}
|
||
}
|
||
|
||
static void parse_args(int argc, char **argv)
|
||
{
|
||
char *ptr;
|
||
int ch;
|
||
|
||
/* Parse command line options */
|
||
|
||
while ((ch = getopt(argc, argv, "a:bcdEefghLlmBnu")) > 0)
|
||
{
|
||
switch (ch)
|
||
{
|
||
case 'a' :
|
||
g_appdir = optarg;
|
||
break;
|
||
|
||
case 'b' :
|
||
g_delim = '\\';
|
||
g_winpaths = false;
|
||
break;
|
||
|
||
case 'c' :
|
||
g_host = HOST_WINDOWS;
|
||
g_windows = WINDOWS_CYGWIN;
|
||
break;
|
||
|
||
case 'd' :
|
||
g_debug = true;
|
||
break;
|
||
|
||
case 'E' :
|
||
g_enforce = true;
|
||
break;
|
||
|
||
case 'e' :
|
||
g_distclean = true;
|
||
break;
|
||
|
||
case 'f' :
|
||
g_delim = '/';
|
||
g_winpaths = true;
|
||
break;
|
||
|
||
case 'g' :
|
||
g_host = HOST_WINDOWS;
|
||
g_windows = WINDOWS_MSYS;
|
||
break;
|
||
|
||
case 'h' :
|
||
show_usage(argv[0], EXIT_SUCCESS);
|
||
|
||
case 'L' :
|
||
dumpcfgs();
|
||
|
||
case 'l' :
|
||
g_host = HOST_LINUX;
|
||
break;
|
||
|
||
case 'm' :
|
||
g_host = HOST_MACOS;
|
||
break;
|
||
|
||
case 'B' :
|
||
g_host = HOST_BSD;
|
||
break;
|
||
|
||
case 'n' :
|
||
g_host = HOST_WINDOWS;
|
||
g_windows = WINDOWS_NATIVE;
|
||
break;
|
||
|
||
case '?' :
|
||
fprintf(stderr, "ERROR: Unrecognized option: %c\n", optopt);
|
||
show_usage(argv[0], EXIT_FAILURE);
|
||
|
||
case ':' :
|
||
fprintf(stderr, "ERROR: Missing option argument, option: %c\n",
|
||
optopt);
|
||
show_usage(argv[0], EXIT_FAILURE);
|
||
|
||
default:
|
||
fprintf(stderr, "ERROR: Unexpected option: %c\n", ch);
|
||
show_usage(argv[0], EXIT_FAILURE);
|
||
}
|
||
}
|
||
|
||
/* There should be exactly one argument following the options */
|
||
|
||
if (optind >= argc)
|
||
{
|
||
fprintf(stderr, "ERROR: Missing <board-name>:<config-name>\n");
|
||
show_usage(argv[0], EXIT_FAILURE);
|
||
}
|
||
|
||
/* The required option should be the board directory name and the
|
||
* configuration directory name separated by ':', '/' or '\'. Any are
|
||
* acceptable in this context. Or using the custom board relative or
|
||
* absolute path directly here.
|
||
*/
|
||
|
||
g_boarddir = argv[optind];
|
||
optind++;
|
||
|
||
if (!verify_optiondir(g_boarddir))
|
||
{
|
||
ptr = strchr(g_boarddir, ':');
|
||
if (ptr == NULL)
|
||
{
|
||
ptr = strchr(g_boarddir, '/');
|
||
if (!ptr)
|
||
{
|
||
ptr = strchr(g_boarddir, '\\');
|
||
}
|
||
}
|
||
|
||
if (ptr == NULL)
|
||
{
|
||
fprintf(stderr, "ERROR: Invalid <board-name>:<config-name>\n");
|
||
show_usage(argv[0], EXIT_FAILURE);
|
||
}
|
||
|
||
*ptr++ = '\0';
|
||
g_configdir = ptr;
|
||
}
|
||
else
|
||
{
|
||
/* custom board case with relative or absolute path */
|
||
|
||
g_configpath = strdup(g_boarddir);
|
||
}
|
||
|
||
/* The left arguments will pass to make */
|
||
|
||
g_makeargv = &argv[optind];
|
||
}
|
||
|
||
static int run_make(const char *arg)
|
||
{
|
||
char **argv;
|
||
|
||
snprintf(g_buffer, BUFFER_SIZE, "make %s", arg);
|
||
|
||
for (argv = g_makeargv; *argv; argv++)
|
||
{
|
||
strncat(g_buffer, " ", BUFFER_SIZE - 1);
|
||
strncat(g_buffer, *argv, BUFFER_SIZE - 1);
|
||
}
|
||
|
||
return system(g_buffer);
|
||
}
|
||
|
||
static bool filecmp(const char *f1, const char *f2)
|
||
{
|
||
FILE *stream1;
|
||
FILE *stream2;
|
||
char ch1;
|
||
char ch2;
|
||
|
||
stream1 = fopen(f1, "r");
|
||
stream2 = fopen(f2, "r");
|
||
|
||
if (stream1 == NULL || stream2 == NULL)
|
||
{
|
||
return false;
|
||
}
|
||
|
||
do
|
||
{
|
||
ch1 = fgetc(stream1);
|
||
ch2 = fgetc(stream2);
|
||
|
||
if (ch1 != ch2)
|
||
{
|
||
return false;
|
||
}
|
||
}
|
||
while (ch1 != EOF && ch2 != EOF);
|
||
|
||
fclose(stream1);
|
||
fclose(stream2);
|
||
|
||
return true;
|
||
}
|
||
|
||
static bool check_directory(const char *directory)
|
||
{
|
||
struct stat buf;
|
||
|
||
if (stat(directory, &buf) < 0)
|
||
{
|
||
debug("stat of %s failed: %s\n", directory, strerror(errno));
|
||
return false;
|
||
}
|
||
|
||
if (!S_ISDIR(buf.st_mode))
|
||
{
|
||
debug("%s exists but is not a directory\n", directory);
|
||
return false;
|
||
}
|
||
|
||
return true;
|
||
}
|
||
|
||
static void verify_directory(const char *directory)
|
||
{
|
||
struct stat buf;
|
||
|
||
if (stat(directory, &buf) < 0)
|
||
{
|
||
fprintf(stderr, "ERROR: stat of %s failed: %s\n",
|
||
directory, strerror(errno));
|
||
exit(EXIT_FAILURE);
|
||
}
|
||
|
||
if (!S_ISDIR(buf.st_mode))
|
||
{
|
||
fprintf(stderr, "ERROR: %s exists but is not a directory\n",
|
||
directory);
|
||
exit(EXIT_FAILURE);
|
||
}
|
||
}
|
||
|
||
static bool verify_optiondir(const char *directory)
|
||
{
|
||
struct stat buf;
|
||
|
||
if (stat(directory, &buf) < 0)
|
||
{
|
||
/* It may be okay if the directory does not exist */
|
||
|
||
/* It may be okay if the file does not exist */
|
||
|
||
int errcode = errno;
|
||
if (errcode == ENOENT)
|
||
{
|
||
debug("verify_optiondir: stat of %s failed: %s\n",
|
||
directory, strerror(errno));
|
||
return false;
|
||
}
|
||
else
|
||
{
|
||
fprintf(stderr, "ERROR: stat of %s failed: %s\n",
|
||
directory, strerror(errno));
|
||
exit(EXIT_FAILURE);
|
||
}
|
||
}
|
||
|
||
if (!S_ISDIR(buf.st_mode))
|
||
{
|
||
fprintf(stderr, "ERROR: %s exists but is not a directory\n",
|
||
directory);
|
||
exit(EXIT_FAILURE);
|
||
}
|
||
|
||
return true;
|
||
}
|
||
|
||
static bool verify_file(const char *path)
|
||
{
|
||
struct stat buf;
|
||
|
||
if (stat(path, &buf) < 0)
|
||
{
|
||
/* It may be okay if the file does not exist */
|
||
|
||
int errcode = errno;
|
||
if (errcode == ENOENT)
|
||
{
|
||
debug("verify_file: stat of %s failed: %s\n",
|
||
path, strerror(errno));
|
||
return false;
|
||
}
|
||
else
|
||
{
|
||
fprintf(stderr, "ERROR: stat of %s failed: %s\n",
|
||
path, strerror(errno));
|
||
exit(EXIT_FAILURE);
|
||
}
|
||
}
|
||
|
||
if (!S_ISREG(buf.st_mode))
|
||
{
|
||
fprintf(stderr, "ERROR: %s exists but is not a regular file\n", path);
|
||
exit(EXIT_FAILURE);
|
||
}
|
||
|
||
return true;
|
||
}
|
||
|
||
static void find_topdir(void)
|
||
{
|
||
char *currdir;
|
||
|
||
/* Get and verify the top-level NuttX directory */
|
||
|
||
/* First get the current directory. We expect this to be either
|
||
* the nuttx root directory or the tools subdirectory.
|
||
*/
|
||
|
||
if (getcwd(g_buffer, BUFFER_SIZE) == NULL)
|
||
{
|
||
fprintf(stderr, "ERROR: getcwd failed: %s\n", strerror(errno));
|
||
exit(EXIT_FAILURE);
|
||
}
|
||
|
||
/* Assume that we are in the tools sub-directory and the directory above
|
||
* is the nuttx root directory.
|
||
*/
|
||
|
||
currdir = strdup(g_buffer);
|
||
g_topdir = strdup(dirname(g_buffer));
|
||
|
||
debug("get_topdir: Checking parent directory: %s\n", g_topdir);
|
||
verify_directory(g_topdir);
|
||
|
||
/* Check if the current directory is the nuttx root directory.
|
||
* If so, then the tools directory should be a sub-directory.
|
||
*/
|
||
|
||
snprintf(g_buffer, BUFFER_SIZE, "%s%ctools", currdir, g_delim);
|
||
debug("get_topdir: Checking topdir/tools=%s\n", g_buffer);
|
||
if (check_directory(g_buffer))
|
||
{
|
||
/* There is a tools sub-directory under the current directory.
|
||
* We must have already been in the nuttx root directory. We
|
||
* will find out for sure in later tests.
|
||
*/
|
||
|
||
free(g_topdir);
|
||
g_topdir = currdir;
|
||
}
|
||
else
|
||
{
|
||
/* Yes, we are probably in the tools/ sub-directory */
|
||
|
||
free(currdir);
|
||
if (chdir(g_topdir) < 0)
|
||
{
|
||
fprintf(stderr, "ERROR: Failed to ch to %s\n", g_topdir);
|
||
exit(EXIT_FAILURE);
|
||
}
|
||
}
|
||
}
|
||
|
||
static void config_search(const char *boarddir,
|
||
config_callback callback, void *data)
|
||
{
|
||
DIR *dir;
|
||
struct dirent *dp;
|
||
struct stat buf;
|
||
char *parent;
|
||
char *child;
|
||
|
||
/* Skip over any leading '/' or '\\'. This happens on the first second
|
||
* call because the starting boarddir is ""
|
||
*/
|
||
|
||
if (boarddir[0] == g_delim)
|
||
{
|
||
boarddir++;
|
||
}
|
||
|
||
/* Get the full directory path and open it */
|
||
|
||
snprintf(g_buffer, BUFFER_SIZE, "%s%c%s", g_configtop, g_delim, boarddir);
|
||
dir = opendir(g_buffer);
|
||
if (!dir)
|
||
{
|
||
fprintf(stderr, "ERROR: Could not open %s: %s\n",
|
||
g_buffer, strerror(errno));
|
||
return;
|
||
}
|
||
|
||
/* Make a copy of the path to the directory */
|
||
|
||
parent = strdup(g_buffer);
|
||
|
||
/* Visit each entry in the directory */
|
||
|
||
while ((dp = readdir(dir)) != NULL)
|
||
{
|
||
/* Ignore directory entries that start with '.' */
|
||
|
||
if (dp->d_name[0] == '.')
|
||
{
|
||
continue;
|
||
}
|
||
|
||
/* Get a properly terminated copy of d_name (if d_name is long it may
|
||
* not include a NUL terminator.
|
||
*/
|
||
|
||
child = strndup(dp->d_name, NAME_MAX);
|
||
|
||
/* Get the full path to d_name and stat the file/directory */
|
||
|
||
snprintf(g_buffer, BUFFER_SIZE, "%s%c%s", parent, g_delim, child);
|
||
if (stat(g_buffer, &buf) < 0)
|
||
{
|
||
fprintf(stderr, "ERROR: stat of %s failed: %s\n",
|
||
g_buffer, strerror(errno));
|
||
free(child);
|
||
continue;
|
||
}
|
||
|
||
/* If it is a directory, then recurse */
|
||
|
||
if (S_ISDIR(buf.st_mode))
|
||
{
|
||
char *tmppath;
|
||
snprintf(g_buffer, BUFFER_SIZE, "%s%c%s",
|
||
boarddir, g_delim, child);
|
||
tmppath = strdup(g_buffer);
|
||
config_search(tmppath, callback, data);
|
||
free(tmppath);
|
||
}
|
||
|
||
/* If it is a regular file named 'defconfig' then we have found a
|
||
* configuration directory. We could terminate the search in this case
|
||
* because we do not expect sub-directories within configuration
|
||
* directories.
|
||
*/
|
||
|
||
else if (S_ISREG(buf.st_mode) && strcmp("defconfig", child) == 0)
|
||
{
|
||
char *archname;
|
||
char *chipname;
|
||
char *boardname;
|
||
char *configname;
|
||
char *delim;
|
||
|
||
/* Get the board directory near the beginning of the 'boarddir':
|
||
* <archdir>/<chipdir>/<boarddir>/configs/<configdir>
|
||
*/
|
||
|
||
/* Make a modifiable copy */
|
||
|
||
strncpy(g_buffer, boarddir, BUFFER_SIZE - 1);
|
||
|
||
/* Save the <archdir> */
|
||
|
||
archname = g_buffer;
|
||
|
||
delim = strchr(g_buffer, g_delim);
|
||
if (delim == NULL)
|
||
{
|
||
debug("ERROR: delimiter not found in path: %s\n", boarddir);
|
||
}
|
||
else
|
||
{
|
||
/* Save the <chipdir> */
|
||
|
||
*delim = '\0';
|
||
chipname = delim + 1;
|
||
|
||
delim = strchr(chipname, g_delim);
|
||
if (delim == NULL)
|
||
{
|
||
debug("ERROR: delimiter not found in path: %s\n",
|
||
chipname);
|
||
}
|
||
else
|
||
{
|
||
/* Save the <boardir> */
|
||
|
||
*delim = '\0';
|
||
boardname = delim + 1;
|
||
|
||
delim = strchr(boardname, g_delim);
|
||
if (delim == NULL)
|
||
{
|
||
debug("ERROR: delimiter not found in path: %s\n",
|
||
boardname);
|
||
}
|
||
else
|
||
{
|
||
/* Save the <configdir> */
|
||
|
||
*delim = '\0';
|
||
delim = strrchr(delim + 1, g_delim);
|
||
if (delim == NULL)
|
||
{
|
||
debug("ERROR: directory not found in path: %s\n",
|
||
boardname);
|
||
}
|
||
else
|
||
{
|
||
configname = delim + 1;
|
||
callback(boarddir, archname, chipname,
|
||
boardname, configname, data);
|
||
}
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
free(child);
|
||
}
|
||
|
||
free(parent);
|
||
closedir(dir);
|
||
}
|
||
|
||
static void archname_callback(const char *boarddir, const char *archname,
|
||
const char *chipname, const char *boardname,
|
||
const char *configname, void *data)
|
||
{
|
||
if (strcmp(g_boarddir, boardname) == 0 &&
|
||
strcmp(g_configdir, configname) == 0)
|
||
{
|
||
g_archdir = strdup(archname);
|
||
g_chipdir = strdup(chipname);
|
||
}
|
||
}
|
||
|
||
static void find_archname(void)
|
||
{
|
||
config_search("", archname_callback, NULL);
|
||
if (g_archdir == NULL || g_chipdir == NULL)
|
||
{
|
||
g_archdir = "unknown";
|
||
g_chipdir = "unknown";
|
||
}
|
||
}
|
||
|
||
static void enumerate_callback(const char *boarddir, const char *archname,
|
||
const char *chipname, const char *boardname,
|
||
const char *configname, void *data)
|
||
{
|
||
fprintf(stderr, " %s:%s\n", boardname, configname);
|
||
}
|
||
|
||
static void enumerate_configs(void)
|
||
{
|
||
fprintf(stderr, "Options for <board-name>:<config-name> include:\n\n");
|
||
config_search("", enumerate_callback, NULL);
|
||
}
|
||
|
||
static void check_configdir(void)
|
||
{
|
||
if (g_configpath && verify_optiondir(g_configpath))
|
||
{
|
||
/* Get the path to the custom board scripts directory */
|
||
|
||
snprintf(g_buffer, BUFFER_SIZE, "%s%c..%c..%cscripts",
|
||
g_configpath, g_delim, g_delim, g_delim);
|
||
if (verify_optiondir(g_buffer))
|
||
{
|
||
g_scriptspath = strdup(g_buffer);
|
||
}
|
||
}
|
||
else
|
||
{
|
||
/* Get the path to the top level configuration directory: boards/ */
|
||
|
||
snprintf(g_buffer, BUFFER_SIZE, "%s%cboards", g_topdir, g_delim);
|
||
debug("check_configdir: Checking configtop=%s\n", g_buffer);
|
||
|
||
verify_directory(g_buffer);
|
||
g_configtop = strdup(g_buffer);
|
||
|
||
/* Get and verify the path to the selected configuration:
|
||
* boards/<archdir>/<chipdir>/<boarddir>/configs/<configdir>
|
||
*/
|
||
|
||
find_archname();
|
||
|
||
snprintf(g_buffer, BUFFER_SIZE, "%s%cboards%c%s%c%s%c%s%cconfigs%c%s",
|
||
g_topdir, g_delim, g_delim, g_archdir, g_delim, g_chipdir,
|
||
g_delim, g_boarddir, g_delim, g_delim, g_configdir);
|
||
debug("check_configdir: Checking configpath=%s\n", g_buffer);
|
||
|
||
if (!verify_optiondir(g_buffer))
|
||
{
|
||
fprintf(stderr, "ERROR: No configuration at %s\n", g_buffer);
|
||
fprintf(stderr, "Run tools/configure -L"
|
||
" to list available configurations.\n");
|
||
exit(EXIT_FAILURE);
|
||
}
|
||
|
||
g_configpath = strdup(g_buffer);
|
||
|
||
/* Get and verify the path to the scripts directory:
|
||
* boards/<archdir>/<chipdir>/<boarddir>/scripts
|
||
*/
|
||
|
||
snprintf(g_buffer, BUFFER_SIZE, "%s%cboards%c%s%c%s%c%s%cscripts",
|
||
g_topdir, g_delim, g_delim, g_archdir, g_delim,
|
||
g_chipdir, g_delim, g_boarddir, g_delim);
|
||
debug("check_configdir: Checking scripts path=%s\n", g_buffer);
|
||
|
||
g_scriptspath = NULL;
|
||
if (verify_optiondir(g_buffer))
|
||
{
|
||
g_scriptspath = strdup(g_buffer);
|
||
}
|
||
}
|
||
}
|
||
|
||
static void check_configured(void)
|
||
{
|
||
/* If we are already configured then there will be a .config and
|
||
* a Make.defs file in the top-level directory.
|
||
*/
|
||
|
||
snprintf(g_buffer, BUFFER_SIZE, "%s%c.config", g_topdir, g_delim);
|
||
debug("check_configured: Checking %s\n", g_buffer);
|
||
|
||
if (!verify_file(g_buffer))
|
||
{
|
||
return;
|
||
}
|
||
|
||
if (g_enforce)
|
||
{
|
||
run_make("distclean");
|
||
}
|
||
else
|
||
{
|
||
char *defcfgpath = NULL;
|
||
|
||
snprintf(g_buffer, BUFFER_SIZE, "%s%cdefconfig",
|
||
g_configpath, g_delim);
|
||
defcfgpath = strdup(g_buffer);
|
||
|
||
snprintf(g_buffer, BUFFER_SIZE, "%s%cdefconfig",
|
||
g_topdir, g_delim);
|
||
|
||
if (filecmp(g_buffer, defcfgpath))
|
||
{
|
||
fprintf(stderr, "No configuration change.\n");
|
||
free(defcfgpath);
|
||
exit(EXIT_SUCCESS);
|
||
}
|
||
else
|
||
{
|
||
free(defcfgpath);
|
||
if (g_distclean)
|
||
{
|
||
run_make("distclean");
|
||
}
|
||
else
|
||
{
|
||
fprintf(stderr, "Already configured!\n");
|
||
fprintf(stderr, "Please 'make distclean' and try again.\n");
|
||
exit(EXIT_FAILURE);
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
static void read_configfile(void)
|
||
{
|
||
FILE *stream;
|
||
|
||
snprintf(g_buffer, BUFFER_SIZE, "%s%cdefconfig", g_configpath, g_delim);
|
||
stream = fopen(g_buffer, "r");
|
||
if (!stream)
|
||
{
|
||
fprintf(stderr, "ERROR: failed to open %s for reading: %s\n",
|
||
g_buffer, strerror(errno));
|
||
exit(EXIT_FAILURE);
|
||
}
|
||
|
||
parse_file(stream, &g_configvars);
|
||
fclose(stream);
|
||
}
|
||
|
||
static void read_versionfile(void)
|
||
{
|
||
FILE *stream;
|
||
|
||
snprintf(g_buffer, BUFFER_SIZE, "%s%c.version", g_topdir, g_delim);
|
||
stream = fopen(g_buffer, "r");
|
||
if (!stream)
|
||
{
|
||
/* It may not be an error if there is no .version file */
|
||
|
||
debug("Failed to open %s for reading: %s\n",
|
||
g_buffer, strerror(errno));
|
||
}
|
||
else
|
||
{
|
||
parse_file(stream, &g_versionvars);
|
||
fclose(stream);
|
||
}
|
||
}
|
||
|
||
static void get_verstring(void)
|
||
{
|
||
struct variable_s *var;
|
||
|
||
if (g_versionvars)
|
||
{
|
||
var = find_variable("CONFIG_VERSION_STRING", g_versionvars);
|
||
if (var && var->val)
|
||
{
|
||
g_verstring = strdup(var->val);
|
||
}
|
||
}
|
||
|
||
debug("get_verstring: Version string=%s\n", g_verstring);
|
||
}
|
||
|
||
static bool verify_appdir(const char *appdir)
|
||
{
|
||
/* Does this directory exist? */
|
||
|
||
snprintf(g_buffer, BUFFER_SIZE, "%s%c%s", g_topdir, g_delim, appdir);
|
||
debug("verify_appdir: Checking apppath=%s\n", g_buffer);
|
||
if (verify_optiondir(g_buffer))
|
||
{
|
||
/* Yes.. Use this application directory path */
|
||
|
||
g_appdir = strdup(appdir);
|
||
g_apppath = strdup(g_buffer);
|
||
return true;
|
||
}
|
||
|
||
debug("verify_appdir: apppath=%s does not exist\n", g_buffer);
|
||
return false;
|
||
}
|
||
|
||
static void check_appdir(void)
|
||
{
|
||
char tmp[16];
|
||
|
||
/* Get and verify the full path to the application directory */
|
||
|
||
/* Was the appdir provided on the command line? */
|
||
|
||
debug("check_appdir: Command line appdir=%s\n",
|
||
g_appdir ? g_appdir : "<null>");
|
||
|
||
if (!g_appdir)
|
||
{
|
||
/* If no application directory was provided on the command line and we
|
||
* are switching between a windows native host and some other host then
|
||
* ignore any path to the apps/ directory in the defconfig file. It
|
||
* will most certainly not be in a usable form.
|
||
*/
|
||
|
||
if (g_winnative == g_oldnative)
|
||
{
|
||
/* No, was the path provided in the configuration? */
|
||
|
||
struct variable_s *var =
|
||
find_variable("CONFIG_APPS_DIR", g_configvars);
|
||
|
||
if (var != NULL)
|
||
{
|
||
debug("check_appdir: Config file appdir=%s\n",
|
||
var->val ? var->val : "<null>");
|
||
|
||
/* Yes.. does this directory exist? */
|
||
|
||
if (var->val && verify_appdir(var->val))
|
||
{
|
||
/* We are using the CONFIG_APPS_DIR setting already in the
|
||
* defconfig file.
|
||
*/
|
||
|
||
g_needapppath = false;
|
||
return;
|
||
}
|
||
}
|
||
}
|
||
|
||
/* Now try some canned locations */
|
||
|
||
/* Try ../apps-xx.yy where xx.yy is the version string */
|
||
|
||
snprintf(tmp, 16, "..%capps-%s", g_delim, g_verstring);
|
||
debug("check_appdir: Try appdir=%s\n", tmp);
|
||
if (verify_appdir(tmp))
|
||
{
|
||
return;
|
||
}
|
||
|
||
/* Try ../apps with no version */
|
||
|
||
snprintf(tmp, 16, "..%capps", g_delim);
|
||
debug("check_appdir: Try appdir=%s\n", tmp);
|
||
if (verify_appdir(tmp))
|
||
{
|
||
return;
|
||
}
|
||
|
||
/* Try ../apps-xx.yy where xx.yy are the NuttX version number */
|
||
|
||
fprintf(stderr, "ERROR: Could not find the path to the appdir\n");
|
||
exit(EXIT_FAILURE);
|
||
}
|
||
else if (!verify_appdir(g_appdir))
|
||
{
|
||
fprintf(stderr, "ERROR: Command line path to appdir does not exist\n");
|
||
exit(EXIT_FAILURE);
|
||
}
|
||
}
|
||
|
||
static void check_configuration(void)
|
||
{
|
||
struct variable_s *var;
|
||
|
||
/* Check if this is a Windows native configuration */
|
||
|
||
var = find_variable("CONFIG_WINDOWS_NATIVE", g_configvars);
|
||
if (var && var->val && strcmp("y", var->val) == 0)
|
||
{
|
||
debug("check_configuration: Windows native configuration\n");
|
||
g_oldnative = true;
|
||
}
|
||
|
||
/* If we are going to some host other than windows native or to a windows
|
||
* native host, then don't ignore what is in the defconfig file.
|
||
*/
|
||
|
||
if (g_host == HOST_NOCHANGE)
|
||
{
|
||
/* Use whatever we found in the configuration file */
|
||
|
||
g_winnative = g_oldnative;
|
||
}
|
||
else if (g_host == HOST_WINDOWS && g_windows == WINDOWS_NATIVE)
|
||
{
|
||
/* The new configuration is windows native */
|
||
|
||
g_winnative = true;
|
||
}
|
||
|
||
/* All configurations must provide a defconfig and Make.defs file */
|
||
|
||
snprintf(g_buffer, BUFFER_SIZE, "%s%cdefconfig", g_configpath, g_delim);
|
||
debug("check_configuration: Checking %s\n", g_buffer);
|
||
if (!verify_file(g_buffer))
|
||
{
|
||
fprintf(stderr, "ERROR: No configuration in %s\n", g_configpath);
|
||
fprintf(stderr, " No defconfig file found.\n");
|
||
fprintf(stderr, "Run tools/configure -L"
|
||
" to list available configurations.\n");
|
||
exit(EXIT_FAILURE);
|
||
}
|
||
|
||
g_srcdefconfig = strdup(g_buffer);
|
||
|
||
/* Try the Make.defs file */
|
||
|
||
snprintf(g_buffer, BUFFER_SIZE, "%s%cMake.defs", g_configpath, g_delim);
|
||
debug("check_configuration: Checking %s\n", g_buffer);
|
||
if (!verify_file(g_buffer))
|
||
{
|
||
/* An alternative location is the scripts/ directory */
|
||
|
||
if (g_scriptspath != NULL)
|
||
{
|
||
snprintf(g_buffer, BUFFER_SIZE, "%s%cMake.defs",
|
||
g_scriptspath, g_delim);
|
||
debug("check_configuration: Checking %s\n", g_buffer);
|
||
if (!verify_file(g_buffer))
|
||
{
|
||
/* Let’s check if there is a script in the common directory */
|
||
|
||
snprintf(g_buffer, BUFFER_SIZE,
|
||
"%s%c..%c..%c..%ccommon%cscripts%cMake.defs",
|
||
g_configpath, g_delim, g_delim, g_delim, g_delim,
|
||
g_delim, g_delim);
|
||
if (!verify_file(g_buffer))
|
||
{
|
||
fprintf(stderr, "ERROR: No Make.defs file found\n");
|
||
fprintf(stderr, "Run tools/configure -L"
|
||
" to list available configurations.\n");
|
||
exit(EXIT_FAILURE);
|
||
}
|
||
}
|
||
}
|
||
else
|
||
{
|
||
fprintf(stderr, "ERROR: No Make.defs file in %s\n", g_configpath);
|
||
fprintf(stderr, "Run tools/configure -L"
|
||
" to list available configurations.\n");
|
||
exit(EXIT_FAILURE);
|
||
}
|
||
}
|
||
|
||
g_srcmakedefs = strdup(g_buffer);
|
||
}
|
||
|
||
static void copy_file(const char *srcpath,
|
||
const char *destpath, mode_t mode)
|
||
{
|
||
int nbytesread;
|
||
int nbyteswritten;
|
||
int rdfd;
|
||
int wrfd;
|
||
|
||
/* Open the source file for reading */
|
||
|
||
rdfd = open(srcpath, O_RDONLY);
|
||
if (rdfd < 0)
|
||
{
|
||
fprintf(stderr, "ERROR: Failed to open %s for reading: %s\n",
|
||
srcpath, strerror(errno));
|
||
exit(EXIT_FAILURE);
|
||
}
|
||
|
||
/* Now open the destination for writing */
|
||
|
||
wrfd = open(destpath, O_WRONLY | O_CREAT | O_TRUNC, mode);
|
||
if (wrfd < 0)
|
||
{
|
||
fprintf(stderr, "ERROR: Failed to open %s for writing: %s\n",
|
||
destpath, strerror(errno));
|
||
exit(EXIT_FAILURE);
|
||
}
|
||
|
||
/* Now copy the file */
|
||
|
||
for (; ; )
|
||
{
|
||
do
|
||
{
|
||
nbytesread = read(rdfd, g_buffer, BUFFER_SIZE);
|
||
if (nbytesread == 0)
|
||
{
|
||
/* End of file */
|
||
|
||
close(rdfd);
|
||
close(wrfd);
|
||
return;
|
||
}
|
||
else if (nbytesread < 0)
|
||
{
|
||
/* EINTR is not an error (but will still stop the copy) */
|
||
|
||
fprintf(stderr, "ERROR: Read failure: %s\n", strerror(errno));
|
||
exit(EXIT_FAILURE);
|
||
}
|
||
}
|
||
while (nbytesread <= 0);
|
||
|
||
do
|
||
{
|
||
nbyteswritten = write(wrfd, g_buffer, nbytesread);
|
||
if (nbyteswritten >= 0)
|
||
{
|
||
nbytesread -= nbyteswritten;
|
||
}
|
||
else
|
||
{
|
||
/* EINTR is not an error (but will still stop the copy) */
|
||
|
||
fprintf(stderr, "ERROR: Write failure: %s\n", strerror(errno));
|
||
exit(EXIT_FAILURE);
|
||
}
|
||
}
|
||
while (nbytesread > 0);
|
||
}
|
||
}
|
||
|
||
static void substitute(char *str, int ch1, int ch2)
|
||
{
|
||
for (; *str; str++)
|
||
{
|
||
if (*str == ch1)
|
||
{
|
||
*str = ch2;
|
||
}
|
||
}
|
||
}
|
||
|
||
static char *double_appdir_backslashes(char *old_appdir)
|
||
{
|
||
char *new_appdir = NULL;
|
||
char *p_old = NULL;
|
||
char *p_new = NULL;
|
||
int oldlen = 0;
|
||
int occurrences = 0;
|
||
int alloclen = 0;
|
||
|
||
p_old = old_appdir;
|
||
while ((p_old = strchr(p_old, '\\')) != NULL)
|
||
{
|
||
occurrences++;
|
||
p_old++;
|
||
}
|
||
|
||
if (occurrences != 0)
|
||
{
|
||
oldlen = strlen(old_appdir);
|
||
alloclen = oldlen + occurrences + sizeof((char) '\0');
|
||
new_appdir = malloc(alloclen);
|
||
|
||
if (new_appdir != NULL)
|
||
{
|
||
p_old = old_appdir;
|
||
p_new = new_appdir;
|
||
while (oldlen)
|
||
{
|
||
if (*p_old != '\\')
|
||
{
|
||
*p_new++ = *p_old;
|
||
}
|
||
else
|
||
{
|
||
*p_new++ = '\\';
|
||
*p_new++ = '\\';
|
||
}
|
||
|
||
++p_old;
|
||
--oldlen;
|
||
}
|
||
|
||
*p_new = '\0';
|
||
}
|
||
}
|
||
else
|
||
{
|
||
new_appdir = strdup(old_appdir);
|
||
}
|
||
|
||
return new_appdir;
|
||
}
|
||
|
||
static void copy_optional(void)
|
||
{
|
||
int i;
|
||
|
||
for (i = 0; i < N_OPTFILES; i++)
|
||
{
|
||
snprintf(g_buffer, BUFFER_SIZE, "%s%c%s",
|
||
g_configpath, g_delim, g_optfiles[i]);
|
||
|
||
if (verify_file(g_buffer))
|
||
{
|
||
char *optsrc = strdup(g_buffer);
|
||
|
||
snprintf(g_buffer, BUFFER_SIZE, "%s%c%s",
|
||
g_topdir, g_delim, g_optfiles[i]);
|
||
|
||
debug("copy_optional: Copying from %s to %s\n", optsrc, g_buffer);
|
||
copy_file(optsrc, g_buffer, 0644);
|
||
|
||
free(optsrc);
|
||
}
|
||
}
|
||
}
|
||
|
||
static void enable_feature(const char *destconfig, const char *varname)
|
||
{
|
||
int ret;
|
||
|
||
snprintf(g_buffer, BUFFER_SIZE,
|
||
"kconfig-tweak --file %s --enable %s",
|
||
destconfig, varname);
|
||
|
||
ret = system(g_buffer);
|
||
|
||
#ifdef WEXITSTATUS
|
||
if (ret < 0 || WEXITSTATUS(ret) != 0)
|
||
#else
|
||
if (ret < 0)
|
||
#endif
|
||
{
|
||
fprintf(stderr, "ERROR: Failed to enable %s\n", varname);
|
||
fprintf(stderr, " command: %s\n", g_buffer);
|
||
exit(EXIT_FAILURE);
|
||
}
|
||
}
|
||
|
||
static void disable_feature(const char *destconfig, const char *varname)
|
||
{
|
||
int ret;
|
||
|
||
snprintf(g_buffer, BUFFER_SIZE,
|
||
"kconfig-tweak --file %s --disable %s",
|
||
destconfig, varname);
|
||
|
||
ret = system(g_buffer);
|
||
|
||
#ifdef WEXITSTATUS
|
||
if (ret < 0 || WEXITSTATUS(ret) != 0)
|
||
#else
|
||
if (ret < 0)
|
||
#endif
|
||
{
|
||
fprintf(stderr, "ERROR: Failed to disable %s\n", varname);
|
||
fprintf(stderr, " command: %s\n", g_buffer);
|
||
exit(EXIT_FAILURE);
|
||
}
|
||
}
|
||
|
||
/* Select the host build development environment */
|
||
|
||
static void set_host(const char *destconfig)
|
||
{
|
||
switch (g_host)
|
||
{
|
||
case HOST_LINUX:
|
||
{
|
||
printf(" Select the Linux host\n");
|
||
|
||
enable_feature(destconfig, "CONFIG_HOST_LINUX");
|
||
disable_feature(destconfig, "CONFIG_HOST_WINDOWS");
|
||
disable_feature(destconfig, "CONFIG_HOST_MACOS");
|
||
disable_feature(destconfig, "CONFIG_HOST_BSD");
|
||
|
||
disable_feature(destconfig, "CONFIG_WINDOWS_NATIVE");
|
||
disable_feature(destconfig, "CONFIG_WINDOWS_CYGWIN");
|
||
disable_feature(destconfig, "CONFIG_WINDOWS_MSYS");
|
||
disable_feature(destconfig, "CONFIG_WINDOWS_OTHER");
|
||
|
||
enable_feature(destconfig, "CONFIG_SIM_X8664_SYSTEMV");
|
||
disable_feature(destconfig, "CONFIG_SIM_X8664_MICROSOFT");
|
||
}
|
||
break;
|
||
|
||
case HOST_MACOS:
|
||
{
|
||
printf(" Select the macOS host\n");
|
||
|
||
disable_feature(destconfig, "CONFIG_HOST_LINUX");
|
||
disable_feature(destconfig, "CONFIG_HOST_WINDOWS");
|
||
disable_feature(destconfig, "CONFIG_HOST_BSD");
|
||
enable_feature(destconfig, "CONFIG_HOST_MACOS");
|
||
|
||
disable_feature(destconfig, "CONFIG_WINDOWS_NATIVE");
|
||
disable_feature(destconfig, "CONFIG_WINDOWS_CYGWIN");
|
||
disable_feature(destconfig, "CONFIG_WINDOWS_MSYS");
|
||
disable_feature(destconfig, "CONFIG_WINDOWS_OTHER");
|
||
|
||
enable_feature(destconfig, "CONFIG_SIM_X8664_SYSTEMV");
|
||
disable_feature(destconfig, "CONFIG_SIM_X8664_MICROSOFT");
|
||
}
|
||
break;
|
||
|
||
case HOST_BSD:
|
||
{
|
||
printf(" Select the BSD host\n");
|
||
|
||
disable_feature(destconfig, "CONFIG_HOST_LINUX");
|
||
disable_feature(destconfig, "CONFIG_HOST_WINDOWS");
|
||
disable_feature(destconfig, "CONFIG_HOST_MACOS");
|
||
enable_feature(destconfig, "CONFIG_HOST_BSD");
|
||
|
||
disable_feature(destconfig, "CONFIG_WINDOWS_NATIVE");
|
||
disable_feature(destconfig, "CONFIG_WINDOWS_CYGWIN");
|
||
disable_feature(destconfig, "CONFIG_WINDOWS_MSYS");
|
||
disable_feature(destconfig, "CONFIG_WINDOWS_OTHER");
|
||
|
||
enable_feature(destconfig, "CONFIG_SIM_X8664_SYSTEMV");
|
||
disable_feature(destconfig, "CONFIG_SIM_X8664_MICROSOFT");
|
||
}
|
||
break;
|
||
|
||
case HOST_WINDOWS:
|
||
{
|
||
enable_feature(destconfig, "CONFIG_HOST_WINDOWS");
|
||
disable_feature(destconfig, "CONFIG_HOST_LINUX");
|
||
disable_feature(destconfig, "CONFIG_HOST_MACOS");
|
||
disable_feature(destconfig, "CONFIG_HOST_BSD");
|
||
|
||
disable_feature(destconfig, "CONFIG_WINDOWS_OTHER");
|
||
|
||
enable_feature(destconfig, "CONFIG_SIM_X8664_MICROSOFT");
|
||
disable_feature(destconfig, "CONFIG_SIM_X8664_SYSTEMV");
|
||
|
||
switch (g_windows)
|
||
{
|
||
case WINDOWS_CYGWIN:
|
||
printf(" Select Windows/Cygwin host\n");
|
||
enable_feature(destconfig, "CONFIG_WINDOWS_CYGWIN");
|
||
disable_feature(destconfig, "CONFIG_WINDOWS_MSYS");
|
||
disable_feature(destconfig, "CONFIG_WINDOWS_NATIVE");
|
||
break;
|
||
|
||
case WINDOWS_MSYS:
|
||
printf(" Select Windows/MSYS host\n");
|
||
disable_feature(destconfig, "CONFIG_WINDOWS_CYGWIN");
|
||
enable_feature(destconfig, "CONFIG_WINDOWS_MSYS");
|
||
disable_feature(destconfig, "CONFIG_WINDOWS_NATIVE");
|
||
break;
|
||
|
||
case WINDOWS_NATIVE:
|
||
printf(" Select Windows native host\n");
|
||
disable_feature(destconfig, "CONFIG_WINDOWS_CYGWIN");
|
||
disable_feature(destconfig, "CONFIG_WINDOWS_MSYS");
|
||
enable_feature(destconfig, "CONFIG_EXPERIMENTAL");
|
||
enable_feature(destconfig, "CONFIG_WINDOWS_NATIVE");
|
||
break;
|
||
|
||
default:
|
||
fprintf(stderr,
|
||
"ERROR: Unrecognized windows configuration: %d\n",
|
||
g_windows);
|
||
exit(EXIT_FAILURE);
|
||
}
|
||
}
|
||
break;
|
||
|
||
case HOST_NOCHANGE:
|
||
break;
|
||
|
||
default:
|
||
{
|
||
fprintf(stderr, "ERROR: Unrecognized host configuration: %d\n",
|
||
g_host);
|
||
exit(EXIT_FAILURE);
|
||
}
|
||
}
|
||
}
|
||
|
||
static void configure(void)
|
||
{
|
||
char *destconfig;
|
||
|
||
/* Copy the defconfig to toplevel */
|
||
|
||
snprintf(g_buffer, BUFFER_SIZE, "%s%cdefconfig", g_topdir, g_delim);
|
||
copy_file(g_srcdefconfig, g_buffer, 0644);
|
||
|
||
/* Copy the defconfig file as .config */
|
||
|
||
snprintf(g_buffer, BUFFER_SIZE, "%s%c.config", g_topdir, g_delim);
|
||
destconfig = strdup(g_buffer);
|
||
debug("configure: Copying from %s to %s\n", g_srcdefconfig, destconfig);
|
||
copy_file(g_srcdefconfig, destconfig, 0644);
|
||
|
||
/* Copy the Make.defs file as Make.defs */
|
||
|
||
snprintf(g_buffer, BUFFER_SIZE, "%s%cMake.defs", g_topdir, g_delim);
|
||
debug("configure: Copying from %s to %s\n", g_srcmakedefs, g_buffer);
|
||
copy_file(g_srcmakedefs, g_buffer, 0644);
|
||
|
||
/* Copy optional files */
|
||
|
||
copy_optional();
|
||
|
||
/* Select the host build development environment */
|
||
|
||
set_host(destconfig);
|
||
|
||
/* If we did not use the CONFIG_APPS_DIR that was in the defconfig config
|
||
* file, then append the correct application information to the tail of the
|
||
* .config file
|
||
*/
|
||
|
||
if (g_needapppath)
|
||
{
|
||
FILE *stream;
|
||
char *appdir = strdup(g_appdir);
|
||
char *boardcfg = strdup(g_boarddir);
|
||
|
||
/* One complexity is if we are using Windows paths, but the
|
||
* configuration needs POSIX paths (or vice versa).
|
||
*/
|
||
|
||
if (g_winpaths != g_winnative)
|
||
{
|
||
/* Not the same */
|
||
|
||
if (g_winpaths)
|
||
{
|
||
/* Using Windows paths, but the configuration wants POSIX
|
||
* paths.
|
||
*/
|
||
|
||
substitute(appdir, '\\', '/');
|
||
}
|
||
else
|
||
{
|
||
/* Using POSIX paths, but the configuration wants Windows
|
||
* paths.
|
||
*/
|
||
|
||
substitute(appdir, '/', '\\');
|
||
}
|
||
}
|
||
|
||
/* Looks like prebuilt winnative kconfig-conf interprets "..\apps" as
|
||
* "..apps" (possibly '\a' as escape-sequence) so expand winnative path
|
||
* to double-backslashed variant "..\\apps".
|
||
*/
|
||
|
||
if (g_winnative)
|
||
{
|
||
char *tmp_appdir = double_appdir_backslashes(appdir);
|
||
if (NULL == tmp_appdir)
|
||
{
|
||
fprintf(stderr,
|
||
"ERROR: Failed to double appdir backslashes\n");
|
||
exit(EXIT_FAILURE);
|
||
}
|
||
|
||
free(appdir);
|
||
appdir = tmp_appdir;
|
||
}
|
||
|
||
/* Open the file for appending */
|
||
|
||
stream = fopen(destconfig, "a");
|
||
if (!stream)
|
||
{
|
||
fprintf(stderr,
|
||
"ERROR: Failed to open %s for append mode: %s\n",
|
||
destconfig, strerror(errno));
|
||
exit(EXIT_FAILURE);
|
||
}
|
||
|
||
fprintf(stream, "\n# Application configuration\n\n");
|
||
fprintf(stream, "CONFIG_APPS_DIR=\"%s\"\n", appdir);
|
||
|
||
substitute(boardcfg, '\\', '/');
|
||
fprintf(stream, "CONFIG_BASE_DEFCONFIG=\"%s\"\n", boardcfg);
|
||
|
||
fclose(stream);
|
||
free(appdir);
|
||
}
|
||
|
||
free(destconfig);
|
||
}
|
||
|
||
static void refresh(void)
|
||
{
|
||
int ret;
|
||
|
||
printf(" Refreshing...\n");
|
||
fflush(stdout);
|
||
|
||
ret = run_make("olddefconfig");
|
||
putchar('\n');
|
||
|
||
#ifdef WEXITSTATUS
|
||
if (ret < 0 || WEXITSTATUS(ret) != 0)
|
||
#else
|
||
if (ret < 0)
|
||
#endif
|
||
{
|
||
fprintf(stderr, "ERROR: Failed to refresh configurations\n");
|
||
fprintf(stderr, " kconfig-conf --olddefconfig Kconfig\n");
|
||
}
|
||
}
|
||
|
||
static void save_original_config(void)
|
||
{
|
||
snprintf(g_buffer, BUFFER_SIZE, "%s%c.config", g_topdir, g_delim);
|
||
char *source_config = strdup(g_buffer);
|
||
snprintf(g_buffer, BUFFER_SIZE, "%s%c.config.orig", g_topdir, g_delim);
|
||
char *dest_config = strdup(g_buffer);
|
||
|
||
FILE *src_file = fopen(source_config, "r");
|
||
FILE *dest_file = fopen(dest_config, "w");
|
||
|
||
if (src_file == NULL || dest_file == NULL)
|
||
{
|
||
fprintf(stderr, "ERROR: Failed to open files\n");
|
||
exit(EXIT_FAILURE);
|
||
}
|
||
|
||
debug("save_original_config: Copying from %s to %s\n",
|
||
source_config, dest_config);
|
||
|
||
while (fgets(g_buffer, BUFFER_SIZE, src_file) != NULL)
|
||
{
|
||
if (strstr(g_buffer, "CONFIG_BASE_DEFCONFIG") == NULL)
|
||
{
|
||
fputs(g_buffer, dest_file);
|
||
}
|
||
}
|
||
|
||
fclose(src_file);
|
||
fclose(dest_file);
|
||
}
|
||
|
||
/****************************************************************************
|
||
* Public Functions
|
||
****************************************************************************/
|
||
|
||
int main(int argc, char **argv, char **envp)
|
||
{
|
||
debug("main: Checking arguments\n");
|
||
parse_args(argc, argv);
|
||
|
||
debug("main: Checking NuttX Directories\n");
|
||
find_topdir();
|
||
check_configdir();
|
||
check_configured();
|
||
|
||
debug("main: Reading the configuration/version files\n");
|
||
read_configfile();
|
||
read_versionfile();
|
||
get_verstring();
|
||
|
||
debug("main: Checking Configuration Directory\n");
|
||
check_configuration();
|
||
|
||
debug("main: Checking Application Directories\n");
|
||
check_appdir();
|
||
debug("main: Using apppath=%s\n", g_apppath ? g_apppath : "<null>");
|
||
|
||
debug("main: Configuring\n");
|
||
configure();
|
||
|
||
debug("main: Refresh configuration\n");
|
||
refresh();
|
||
|
||
debug("main: Save original configuration\n");
|
||
save_original_config();
|
||
return EXIT_SUCCESS;
|
||
}
|