blob: 40bf4c9b951fc4315ab78296e14966c2f892adec [file] [log] [blame]
/* 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 <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_depends 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_depends failed to parse ", arg_pp, \
": invalid filename")); \
return false; \
} \
\
if (!cmSystemTools::FileIsFullPath(res)) { \
res = cmStrCat(work_directory, '/', res); \
} \
} while (0)
bool cmScanDepFormat_P1689_Parse(std::string const& arg_pp, cmSourceInfo* 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_depends failed to parse ",
arg_pp,
reader.getFormattedErrorMessages()));
return false;
}
}
Json::Value const& version = ppi["version"];
if (version.asUInt() != 0) {
cmSystemTools::Error(cmStrCat("-E cmake_ninja_depends 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_depends failed to parse ",
arg_pp, ": expected 1 source entry"));
return false;
}
for (auto const& rule : rules) {
Json::Value const& workdir = rule["work-directory"];
if (!workdir.isString()) {
cmSystemTools::Error(
cmStrCat("-E cmake_ninja_depends failed to parse ", arg_pp,
": work-directory is not a string"));
return false;
}
std::string work_directory;
PARSE_BLOB(workdir, work_directory);
Json::Value const& depends = rule["depends"];
if (depends.isArray()) {
std::string depend_filename;
for (auto const& depend : depends) {
PARSE_FILENAME(depend, depend_filename);
info->Includes.push_back(depend_filename);
}
}
if (rule.isMember("future-compile")) {
Json::Value const& future_compile = rule["future-compile"];
if (future_compile.isMember("outputs")) {
Json::Value const& outputs = future_compile["outputs"];
if (outputs.isArray()) {
if (outputs.empty()) {
cmSystemTools::Error(
cmStrCat("-E cmake_ninja_depends failed to parse ", arg_pp,
": expected at least one 1 output"));
return false;
}
PARSE_FILENAME(outputs[0], info->PrimaryOutput);
}
}
if (future_compile.isMember("provides")) {
Json::Value const& provides = future_compile["provides"];
if (provides.isArray()) {
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);
} else {
provide_info.CompiledModulePath =
cmStrCat(provide_info.LogicalName, ".mod");
}
info->Provides.push_back(provide_info);
}
}
}
if (future_compile.isMember("requires")) {
Json::Value const& reqs = future_compile["requires"];
if (reqs.isArray()) {
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);
}
info->Requires.push_back(require_info);
}
}
}
}
}
}
return true;
}
bool cmScanDepFormat_P1689_Write(std::string const& path,
std::string const& input,
cmSourceInfo 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["work-directory"] =
EncodeFilename(cmSystemTools::GetCurrentWorkingDirectory());
Json::Value& inputs = rule["inputs"] = Json::arrayValue;
inputs.append(EncodeFilename(input));
Json::Value& rule_outputs = rule["outputs"] = Json::arrayValue;
rule_outputs.append(EncodeFilename(path));
Json::Value& depends = rule["depends"] = Json::arrayValue;
for (auto const& include : info.Includes) {
depends.append(EncodeFilename(include));
}
Json::Value& future_compile = rule["future-compile"] = Json::objectValue;
Json::Value& outputs = future_compile["outputs"] = Json::arrayValue;
outputs.append(info.PrimaryOutput);
Json::Value& provides = future_compile["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"] = encoded;
} else {
provide_obj["compiled-module-path"] =
EncodeFilename(provide.CompiledModulePath);
}
// TODO: Source file tracking. See below.
provides.append(provide_obj);
}
Json::Value& reqs = future_compile["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"] = encoded;
} else {
require_obj["compiled-module-path"] =
EncodeFilename(require.CompiledModulePath);
}
// TODO: Source filename inclusion. Requires collating with the provides
// filenames (as a sanity check if available on both sides).
reqs.append(require_obj);
}
rules.append(rule);
cmGeneratedFileStream ddif(path);
ddif << ddi;
return !!ddif;
}