You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
372 lines
13 KiB
372 lines
13 KiB
/* Distributed under the OSI-approved BSD 3-Clause License. See accompanying
|
|
file Copyright.txt or https://cmake.org/licensing for details. */
|
|
|
|
#include "cmScanDepFormat.h"
|
|
|
|
#include <cctype>
|
|
#include <cstdio>
|
|
#include <utility>
|
|
|
|
#include <cm/optional>
|
|
#include <cm/string_view>
|
|
#include <cmext/string_view>
|
|
|
|
#include <cm3p/json/reader.h>
|
|
#include <cm3p/json/value.h>
|
|
#include <cm3p/json/writer.h>
|
|
|
|
#include "cmsys/FStream.hxx"
|
|
|
|
#include "cmGeneratedFileStream.h"
|
|
#include "cmStringAlgorithms.h"
|
|
#include "cmSystemTools.h"
|
|
|
|
static bool ParseFilename(Json::Value const& val, std::string& result)
|
|
{
|
|
if (val.isString()) {
|
|
result = val.asString();
|
|
} else {
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
static Json::Value EncodeFilename(std::string const& path)
|
|
{
|
|
std::string data;
|
|
data.reserve(path.size());
|
|
|
|
for (auto const& byte : path) {
|
|
if (std::iscntrl(byte)) {
|
|
// Control characters.
|
|
data.append("\\u");
|
|
char buf[5];
|
|
std::snprintf(buf, sizeof(buf), "%04x", byte);
|
|
data.append(buf);
|
|
} else if (byte == '"' || byte == '\\') {
|
|
// Special JSON characters.
|
|
data.push_back('\\');
|
|
data.push_back(byte);
|
|
} else {
|
|
// Other data.
|
|
data.push_back(byte);
|
|
}
|
|
}
|
|
|
|
return data;
|
|
}
|
|
|
|
#define PARSE_BLOB(val, res) \
|
|
do { \
|
|
if (!ParseFilename(val, res)) { \
|
|
cmSystemTools::Error(cmStrCat("-E cmake_ninja_dyndep failed to parse ", \
|
|
arg_pp, ": invalid blob")); \
|
|
return false; \
|
|
} \
|
|
} while (0)
|
|
|
|
#define PARSE_FILENAME(val, res) \
|
|
do { \
|
|
if (!ParseFilename(val, res)) { \
|
|
cmSystemTools::Error(cmStrCat("-E cmake_ninja_dyndep failed to parse ", \
|
|
arg_pp, ": invalid filename")); \
|
|
return false; \
|
|
} \
|
|
\
|
|
if (work_directory && !work_directory->empty() && \
|
|
!cmSystemTools::FileIsFullPath(res)) { \
|
|
res = cmStrCat(*work_directory, '/', res); \
|
|
} \
|
|
} while (0)
|
|
|
|
bool cmScanDepFormat_P1689_Parse(std::string const& arg_pp,
|
|
cmScanDepInfo* info)
|
|
{
|
|
Json::Value ppio;
|
|
Json::Value const& ppi = ppio;
|
|
cmsys::ifstream ppf(arg_pp.c_str(), std::ios::in | std::ios::binary);
|
|
{
|
|
Json::Reader reader;
|
|
if (!reader.parse(ppf, ppio, false)) {
|
|
cmSystemTools::Error(cmStrCat("-E cmake_ninja_dyndep failed to parse ",
|
|
arg_pp,
|
|
reader.getFormattedErrorMessages()));
|
|
return false;
|
|
}
|
|
}
|
|
|
|
Json::Value const& version = ppi["version"];
|
|
if (version.asUInt() > 1) {
|
|
cmSystemTools::Error(cmStrCat("-E cmake_ninja_dyndep failed to parse ",
|
|
arg_pp, ": version ", version.asString()));
|
|
return false;
|
|
}
|
|
|
|
Json::Value const& rules = ppi["rules"];
|
|
if (rules.isArray()) {
|
|
if (rules.size() != 1) {
|
|
cmSystemTools::Error(cmStrCat("-E cmake_ninja_dyndep failed to parse ",
|
|
arg_pp, ": expected 1 source entry"));
|
|
return false;
|
|
}
|
|
|
|
for (auto const& rule : rules) {
|
|
cm::optional<std::string> work_directory;
|
|
Json::Value const& workdir = rule["work-directory"];
|
|
if (workdir.isString()) {
|
|
std::string wd;
|
|
PARSE_BLOB(workdir, wd);
|
|
work_directory = std::move(wd);
|
|
} else if (!workdir.isNull()) {
|
|
cmSystemTools::Error(cmStrCat("-E cmake_ninja_dyndep failed to parse ",
|
|
arg_pp,
|
|
": work-directory is not a string"));
|
|
return false;
|
|
}
|
|
|
|
if (rule.isMember("primary-output")) {
|
|
Json::Value const& primary_output = rule["primary-output"];
|
|
PARSE_FILENAME(primary_output, info->PrimaryOutput);
|
|
}
|
|
|
|
if (rule.isMember("outputs")) {
|
|
Json::Value const& outputs = rule["outputs"];
|
|
if (outputs.isArray()) {
|
|
for (auto const& output : outputs) {
|
|
std::string extra_output;
|
|
PARSE_FILENAME(output, extra_output);
|
|
|
|
info->ExtraOutputs.emplace_back(extra_output);
|
|
}
|
|
}
|
|
}
|
|
|
|
if (rule.isMember("provides")) {
|
|
Json::Value const& provides = rule["provides"];
|
|
if (!provides.isArray()) {
|
|
cmSystemTools::Error(
|
|
cmStrCat("-E cmake_ninja_dyndep failed to parse ", arg_pp,
|
|
": provides is not an array"));
|
|
return false;
|
|
}
|
|
|
|
for (auto const& provide : provides) {
|
|
cmSourceReqInfo provide_info;
|
|
|
|
Json::Value const& logical_name = provide["logical-name"];
|
|
PARSE_BLOB(logical_name, provide_info.LogicalName);
|
|
|
|
if (provide.isMember("compiled-module-path")) {
|
|
Json::Value const& compiled_module_path =
|
|
provide["compiled-module-path"];
|
|
PARSE_FILENAME(compiled_module_path,
|
|
provide_info.CompiledModulePath);
|
|
}
|
|
|
|
if (provide.isMember("unique-on-source-path")) {
|
|
Json::Value const& unique_on_source_path =
|
|
provide["unique-on-source-path"];
|
|
if (!unique_on_source_path.isBool()) {
|
|
cmSystemTools::Error(
|
|
cmStrCat("-E cmake_ninja_dyndep failed to parse ", arg_pp,
|
|
": unique-on-source-path is not a boolean"));
|
|
return false;
|
|
}
|
|
provide_info.UseSourcePath = unique_on_source_path.asBool();
|
|
} else {
|
|
provide_info.UseSourcePath = false;
|
|
}
|
|
|
|
if (provide.isMember("source-path")) {
|
|
Json::Value const& source_path = provide["source-path"];
|
|
PARSE_FILENAME(source_path, provide_info.SourcePath);
|
|
} else if (provide_info.UseSourcePath) {
|
|
cmSystemTools::Error(
|
|
cmStrCat("-E cmake_ninja_dyndep failed to parse ", arg_pp,
|
|
": source-path is missing"));
|
|
return false;
|
|
}
|
|
|
|
if (provide.isMember("is-interface")) {
|
|
Json::Value const& is_interface = provide["is-interface"];
|
|
if (!is_interface.isBool()) {
|
|
cmSystemTools::Error(
|
|
cmStrCat("-E cmake_ninja_dyndep failed to parse ", arg_pp,
|
|
": is-interface is not a boolean"));
|
|
return false;
|
|
}
|
|
provide_info.IsInterface = is_interface.asBool();
|
|
} else {
|
|
provide_info.IsInterface = true;
|
|
}
|
|
|
|
info->Provides.push_back(provide_info);
|
|
}
|
|
}
|
|
|
|
if (rule.isMember("requires")) {
|
|
Json::Value const& reqs = rule["requires"];
|
|
if (!reqs.isArray()) {
|
|
cmSystemTools::Error(
|
|
cmStrCat("-E cmake_ninja_dyndep failed to parse ", arg_pp,
|
|
": requires is not an array"));
|
|
return false;
|
|
}
|
|
|
|
for (auto const& require : reqs) {
|
|
cmSourceReqInfo require_info;
|
|
|
|
Json::Value const& logical_name = require["logical-name"];
|
|
PARSE_BLOB(logical_name, require_info.LogicalName);
|
|
|
|
if (require.isMember("compiled-module-path")) {
|
|
Json::Value const& compiled_module_path =
|
|
require["compiled-module-path"];
|
|
PARSE_FILENAME(compiled_module_path,
|
|
require_info.CompiledModulePath);
|
|
}
|
|
|
|
if (require.isMember("unique-on-source-path")) {
|
|
Json::Value const& unique_on_source_path =
|
|
require["unique-on-source-path"];
|
|
if (!unique_on_source_path.isBool()) {
|
|
cmSystemTools::Error(
|
|
cmStrCat("-E cmake_ninja_dyndep failed to parse ", arg_pp,
|
|
": unique-on-source-path is not a boolean"));
|
|
return false;
|
|
}
|
|
require_info.UseSourcePath = unique_on_source_path.asBool();
|
|
} else {
|
|
require_info.UseSourcePath = false;
|
|
}
|
|
|
|
if (require.isMember("source-path")) {
|
|
Json::Value const& source_path = require["source-path"];
|
|
PARSE_FILENAME(source_path, require_info.SourcePath);
|
|
} else if (require_info.UseSourcePath) {
|
|
cmSystemTools::Error(
|
|
cmStrCat("-E cmake_ninja_dyndep failed to parse ", arg_pp,
|
|
": source-path is missing"));
|
|
return false;
|
|
}
|
|
|
|
if (require.isMember("lookup-method")) {
|
|
Json::Value const& lookup_method = require["lookup-method"];
|
|
if (!lookup_method.isString()) {
|
|
cmSystemTools::Error(
|
|
cmStrCat("-E cmake_ninja_dyndep failed to parse ", arg_pp,
|
|
": lookup-method is not a string"));
|
|
return false;
|
|
}
|
|
|
|
std::string lookup_method_str = lookup_method.asString();
|
|
if (lookup_method_str == "by-name"_s) {
|
|
require_info.Method = LookupMethod::ByName;
|
|
} else if (lookup_method_str == "include-angle"_s) {
|
|
require_info.Method = LookupMethod::IncludeAngle;
|
|
} else if (lookup_method_str == "include-quote"_s) {
|
|
require_info.Method = LookupMethod::IncludeQuote;
|
|
} else {
|
|
cmSystemTools::Error(cmStrCat(
|
|
"-E cmake_ninja_dyndep failed to parse ", arg_pp,
|
|
": lookup-method is not a valid: ", lookup_method_str));
|
|
return false;
|
|
}
|
|
} else if (require_info.UseSourcePath) {
|
|
require_info.Method = LookupMethod::ByName;
|
|
}
|
|
|
|
info->Requires.push_back(require_info);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
bool cmScanDepFormat_P1689_Write(std::string const& path,
|
|
cmScanDepInfo const& info)
|
|
{
|
|
Json::Value ddi(Json::objectValue);
|
|
ddi["version"] = 0;
|
|
ddi["revision"] = 0;
|
|
|
|
Json::Value& rules = ddi["rules"] = Json::arrayValue;
|
|
|
|
Json::Value rule(Json::objectValue);
|
|
|
|
rule["primary-output"] = EncodeFilename(info.PrimaryOutput);
|
|
|
|
Json::Value& rule_outputs = rule["outputs"] = Json::arrayValue;
|
|
for (auto const& output : info.ExtraOutputs) {
|
|
rule_outputs.append(EncodeFilename(output));
|
|
}
|
|
|
|
Json::Value& provides = rule["provides"] = Json::arrayValue;
|
|
for (auto const& provide : info.Provides) {
|
|
Json::Value provide_obj(Json::objectValue);
|
|
auto const encoded = EncodeFilename(provide.LogicalName);
|
|
provide_obj["logical-name"] = encoded;
|
|
if (!provide.CompiledModulePath.empty()) {
|
|
provide_obj["compiled-module-path"] =
|
|
EncodeFilename(provide.CompiledModulePath);
|
|
}
|
|
|
|
if (provide.UseSourcePath) {
|
|
provide_obj["unique-on-source-path"] = true;
|
|
provide_obj["source-path"] = EncodeFilename(provide.SourcePath);
|
|
} else if (!provide.SourcePath.empty()) {
|
|
provide_obj["source-path"] = EncodeFilename(provide.SourcePath);
|
|
}
|
|
|
|
provide_obj["is-interface"] = provide.IsInterface;
|
|
|
|
provides.append(provide_obj);
|
|
}
|
|
|
|
Json::Value& reqs = rule["requires"] = Json::arrayValue;
|
|
for (auto const& require : info.Requires) {
|
|
Json::Value require_obj(Json::objectValue);
|
|
auto const encoded = EncodeFilename(require.LogicalName);
|
|
require_obj["logical-name"] = encoded;
|
|
if (!require.CompiledModulePath.empty()) {
|
|
require_obj["compiled-module-path"] =
|
|
EncodeFilename(require.CompiledModulePath);
|
|
}
|
|
|
|
if (require.UseSourcePath) {
|
|
require_obj["unique-on-source-path"] = true;
|
|
require_obj["source-path"] = EncodeFilename(require.SourcePath);
|
|
} else if (!require.SourcePath.empty()) {
|
|
require_obj["source-path"] = EncodeFilename(require.SourcePath);
|
|
}
|
|
|
|
const char* lookup_method = nullptr;
|
|
switch (require.Method) {
|
|
case LookupMethod::ByName:
|
|
// No explicit value needed for the default.
|
|
break;
|
|
case LookupMethod::IncludeAngle:
|
|
lookup_method = "include-angle";
|
|
break;
|
|
case LookupMethod::IncludeQuote:
|
|
lookup_method = "include-quote";
|
|
break;
|
|
}
|
|
if (lookup_method) {
|
|
require_obj["lookup-method"] = lookup_method;
|
|
}
|
|
|
|
reqs.append(require_obj);
|
|
}
|
|
|
|
rules.append(rule);
|
|
|
|
cmGeneratedFileStream ddif(path);
|
|
ddif << ddi;
|
|
|
|
return !!ddif;
|
|
}
|