| --- jsonnet.cpp 2020-09-09 12:15:33.687539042 +0000 |
| +++ write_helper.cpp 2020-09-25 15:38:37.317147682 +0000 |
| @@ -14,559 +14,125 @@ |
| limitations under the License. |
| */ |
| |
| -#include <cassert> |
| -#include <cstdlib> |
| -#include <cstring> |
| +// We need two functions defined in jsonnet.cpp file, used for writing output |
| +// (multiple files and yaml streams) -- with minor changes (e.x. return type). |
| |
| -#include <exception> |
| #include <fstream> |
| #include <iostream> |
| -#include <list> |
| #include <map> |
| -#include <sstream> |
| -#include <string> |
| #include <vector> |
| |
| -#include "utils.h" |
| +#include "contrib/jsonnet/jsonnet_helper.h" |
| |
| -extern "C" { |
| -#include <libjsonnet.h> |
| -} |
| - |
| -#ifdef _WIN32 |
| -const char PATH_SEP = ';'; |
| -#else |
| -const char PATH_SEP = ':'; |
| -#endif |
| - |
| -void version(std::ostream &o) |
| -{ |
| - o << "Jsonnet commandline interpreter " << jsonnet_version() << std::endl; |
| -} |
| - |
| -void usage(std::ostream &o) |
| -{ |
| - version(o); |
| - o << "\n"; |
| - o << "jsonnet {<option>} <filename>\n"; |
| - o << "\n"; |
| - o << "Available options:\n"; |
| - o << " -h / --help This message\n"; |
| - o << " -e / --exec Treat filename as code\n"; |
| - o << " -J / --jpath <dir> Specify an additional library search dir (right-most wins)\n"; |
| - o << " -o / --output-file <file> Write to the output file rather than stdout\n"; |
| - o << " -m / --multi <dir> Write multiple files to the directory, list files on stdout\n"; |
| - o << " -y / --yaml-stream Write output as a YAML stream of JSON documents\n"; |
| - o << " -S / --string Expect a string, manifest as plain text\n"; |
| - o << " -s / --max-stack <n> Number of allowed stack frames\n"; |
| - o << " -t / --max-trace <n> Max length of stack trace before cropping\n"; |
| - o << " --gc-min-objects <n> Do not run garbage collector until this many\n"; |
| - o << " --gc-growth-trigger <n> Run garbage collector after this amount of object growth\n"; |
| - o << " --version Print version\n"; |
| - o << "Available options for specifying values of 'external' variables:\n"; |
| - o << "Provide the value as a string:\n"; |
| - o << " -V / --ext-str <var>[=<val>] If <val> is omitted, get from environment var <var>\n"; |
| - o << " --ext-str-file <var>=<file> Read the string from the file\n"; |
| - o << "Provide a value as Jsonnet code:\n"; |
| - o << " --ext-code <var>[=<code>] If <code> is omitted, get from environment var <var>\n"; |
| - o << " --ext-code-file <var>=<file> Read the code from the file\n"; |
| - o << "Available options for specifying values of 'top-level arguments':\n"; |
| - o << "Provide the value as a string:\n"; |
| - o << " -A / --tla-str <var>[=<val>] If <val> is omitted, get from environment var <var>\n"; |
| - o << " --tla-str-file <var>=<file> Read the string from the file\n"; |
| - o << "Provide a value as Jsonnet code:\n"; |
| - o << " --tla-code <var>[=<code>] If <code> is omitted, get from environment var <var>\n"; |
| - o << " --tla-code-file <var>=<file> Read the code from the file\n"; |
| - o << "Environment variables:\n"; |
| - o << "JSONNET_PATH is a colon (semicolon on Windows) separated list of directories added\n"; |
| - o << "in reverse order before the paths specified by --jpath (i.e. left-most wins)\n"; |
| - o << "E.g. JSONNET_PATH=a:b jsonnet -J c -J d is equivalent to:\n"; |
| - o << "JSONNET_PATH=d:c:a:b jsonnet\n"; |
| - o << "jsonnet -J b -J a -J c -J d\n"; |
| - o << "\n"; |
| - o << "In all cases:\n"; |
| - o << "<filename> can be - (stdin)\n"; |
| - o << "Multichar options are expanded e.g. -abc becomes -a -b -c.\n"; |
| - o << "The -- option suppresses option processing for subsequent arguments.\n"; |
| - o << "Note that since filenames and jsonnet programs can begin with -, it is advised to\n"; |
| - o << "use -- if the argument is unknown, e.g. jsonnet -- \"$FILENAME\"."; |
| - o << std::endl; |
| -} |
| - |
| -/** Class for representing configuration read from command line flags. */ |
| -struct JsonnetConfig { |
| - std::vector<std::string> inputFiles; |
| - std::string outputFile; |
| - bool filenameIsCode; |
| - |
| - // EVAL flags |
| - bool evalMulti; |
| - bool evalStream; |
| - std::string evalMultiOutputDir; |
| - |
| - JsonnetConfig() |
| - : filenameIsCode(false), |
| - evalMulti(false), |
| - evalStream(false) |
| - { |
| - } |
| -}; |
| - |
| -bool get_var_val(const std::string &var_val, std::string &var, std::string &val) |
| -{ |
| - size_t eq_pos = var_val.find_first_of('=', 0); |
| - if (eq_pos == std::string::npos) { |
| - var = var_val; |
| - const char *val_cstr = ::getenv(var.c_str()); |
| - if (val_cstr == nullptr) { |
| - std::cerr << "ERROR: environment variable " << var << " was undefined." << std::endl; |
| - return false; |
| - } |
| - val = val_cstr; |
| - } else { |
| - var = var_val.substr(0, eq_pos); |
| - val = var_val.substr(eq_pos + 1, std::string::npos); |
| - } |
| - return true; |
| -} |
| - |
| -bool get_var_file(const std::string &var_file, const std::string &imp, std::string &var, std::string &val) |
| -{ |
| - size_t eq_pos = var_file.find_first_of('=', 0); |
| - if (eq_pos == std::string::npos) { |
| - std::cerr << "ERROR: argument not in form <var>=<file> \"" << var_file << "\"." |
| - << std::endl; |
| - return false; |
| - } |
| - var = var_file.substr(0, eq_pos); |
| - const std::string path = var_file.substr(eq_pos + 1, std::string::npos); |
| - |
| - size_t b, e; |
| - val.erase().append(imp).append(" @'"); |
| - // duplicate all the single quotes in @path to make a quoted string |
| - for (b = 0; (e = path.find("'", b)) != std::string::npos; b = e + 1) { |
| - val.append(path.substr(b, e - b + 1)).push_back('\''); |
| +/** Writes output files for multiple file output */ |
| +bool write_multi_output_files(char *output, const std::string &output_dir, bool show_output_file_names) { |
| + // If multiple file output is used, then iterate over each string from |
| + // the sequence of strings returned by jsonnet_evaluate_snippet_multi, |
| + // construct pairs of filename and content, and write each output file. |
| + std::map<std::string, std::string> r; |
| + for (const char *c = output; *c != '\0';) { |
| + const char *filename = c; |
| + const char *c2 = c; |
| + while (*c2 != '\0') ++c2; |
| + ++c2; |
| + const char *json = c2; |
| + while (*c2 != '\0') ++c2; |
| + ++c2; |
| + c = c2; |
| + r[filename] = json; |
| + } |
| + |
| + std::ostream *o; |
| + std::ofstream f; |
| + |
| + o = &std::cout; |
| + |
| + for (const auto &pair : r) { |
| + const std::string &new_content = pair.second; |
| + const std::string &filename = output_dir + pair.first; |
| + if (show_output_file_names) { |
| + (*o) << filename << std::endl; |
| } |
| - val.append(path.substr(b)).push_back('\''); |
| - |
| - return true; |
| -} |
| - |
| -enum ArgStatus { |
| - ARG_CONTINUE, |
| - ARG_SUCCESS, |
| - ARG_FAILURE, |
| -}; |
| - |
| -/** Parse the command line arguments, configuring the Jsonnet VM context and |
| - * populating the JsonnetConfig. |
| - */ |
| -static ArgStatus process_args(int argc, const char **argv, JsonnetConfig *config, JsonnetVm *vm) |
| -{ |
| - auto args = simplify_args(argc, argv); |
| - std::vector<std::string> remaining_args; |
| - |
| - unsigned i = 0; |
| - |
| - for (; i < args.size(); ++i) { |
| - const std::string &arg = args[i]; |
| - if (arg == "-h" || arg == "--help") { |
| - usage(std::cout); |
| - return ARG_SUCCESS; |
| - } else if (arg == "-v" || arg == "--version") { |
| - version(std::cout); |
| - return ARG_SUCCESS; |
| - } else if (arg == "-e" || arg == "--exec") { |
| - config->filenameIsCode = true; |
| - } else if (arg == "-o" || arg == "--output-file") { |
| - std::string output_file = next_arg(i, args); |
| - if (output_file.length() == 0) { |
| - std::cerr << "ERROR: -o argument was empty string" << std::endl; |
| - return ARG_FAILURE; |
| - } |
| - config->outputFile = output_file; |
| - } else if (arg == "--") { |
| - // All subsequent args are not options. |
| - while ((++i) < args.size()) |
| - remaining_args.push_back(args[i]); |
| - break; |
| - } else if (arg == "-s" || arg == "--max-stack") { |
| - long l = strtol_check(next_arg(i, args)); |
| - if (l < 1) { |
| - std::cerr << "ERROR: invalid --max-stack value: " << l << std::endl; |
| - return ARG_FAILURE; |
| - } |
| - jsonnet_max_stack(vm, l); |
| - } else if (arg == "-J" || arg == "--jpath") { |
| - std::string dir = next_arg(i, args); |
| - if (dir.length() == 0) { |
| - std::cerr << "ERROR: -J argument was empty string" << std::endl; |
| - return ARG_FAILURE; |
| - } |
| - if (dir[dir.length() - 1] != '/') { |
| - dir += '/'; |
| - } |
| - jsonnet_jpath_add(vm, dir.c_str()); |
| - } else if (arg == "-V" || arg == "--ext-str") { |
| - std::string var, val; |
| - if (!get_var_val(next_arg(i, args), var, val)) |
| - return ARG_FAILURE; |
| - jsonnet_ext_var(vm, var.c_str(), val.c_str()); |
| - } else if (arg == "-E" || arg == "--var" || arg == "--env") { |
| - // TODO(dcunnin): Delete this in a future release. |
| - std::cerr << "WARNING: jsonnet eval -E, --var and --env are deprecated," |
| - << " please use -V or --ext-str." << std::endl; |
| - std::string var, val; |
| - if (!get_var_val(next_arg(i, args), var, val)) |
| - return ARG_FAILURE; |
| - jsonnet_ext_var(vm, var.c_str(), val.c_str()); |
| - } else if (arg == "--ext-str-file") { |
| - std::string var, val; |
| - if (!get_var_file(next_arg(i, args), "importstr", var, val)) |
| - return ARG_FAILURE; |
| - jsonnet_ext_code(vm, var.c_str(), val.c_str()); |
| - } else if (arg == "-F" || arg == "--file") { |
| - // TODO(dcunnin): Delete this in a future release. |
| - std::cerr << "WARNING: jsonnet eval -F and --file are deprecated," |
| - << " please use --ext-str-file." << std::endl; |
| - std::string var, val; |
| - if (!get_var_file(next_arg(i, args), "importstr", var, val)) |
| - return ARG_FAILURE; |
| - jsonnet_ext_code(vm, var.c_str(), val.c_str()); |
| - } else if (arg == "--ext-code") { |
| - std::string var, val; |
| - if (!get_var_val(next_arg(i, args), var, val)) |
| - return ARG_FAILURE; |
| - jsonnet_ext_code(vm, var.c_str(), val.c_str()); |
| - } else if (arg == "--code-var" || arg == "--code-env") { |
| - // TODO(dcunnin): Delete this in a future release. |
| - std::cerr << "WARNING: jsonnet eval --code-var and --code-env are deprecated," |
| - << " please use --ext-code." << std::endl; |
| - std::string var, val; |
| - if (!get_var_val(next_arg(i, args), var, val)) |
| - return ARG_FAILURE; |
| - jsonnet_ext_code(vm, var.c_str(), val.c_str()); |
| - } else if (arg == "--ext-code-file") { |
| - std::string var, val; |
| - if (!get_var_file(next_arg(i, args), "import", var, val)) |
| - return ARG_FAILURE; |
| - jsonnet_ext_code(vm, var.c_str(), val.c_str()); |
| - } else if (arg == "--code-file") { |
| - // TODO(dcunnin): Delete this in a future release. |
| - std::cerr << "WARNING: jsonnet eval --code-file is deprecated," |
| - << " please use --ext-code-file." << std::endl; |
| - std::string var, val; |
| - if (!get_var_file(next_arg(i, args), "import", var, val)) |
| - return ARG_FAILURE; |
| - jsonnet_ext_code(vm, var.c_str(), val.c_str()); |
| - } else if (arg == "-A" || arg == "--tla-str") { |
| - std::string var, val; |
| - if (!get_var_val(next_arg(i, args), var, val)) |
| - return ARG_FAILURE; |
| - jsonnet_tla_var(vm, var.c_str(), val.c_str()); |
| - } else if (arg == "--tla-str-file") { |
| - std::string var, val; |
| - if (!get_var_file(next_arg(i, args), "importstr", var, val)) |
| - return ARG_FAILURE; |
| - jsonnet_tla_code(vm, var.c_str(), val.c_str()); |
| - } else if (arg == "--tla-code") { |
| - std::string var, val; |
| - if (!get_var_val(next_arg(i, args), var, val)) |
| - return ARG_FAILURE; |
| - jsonnet_tla_code(vm, var.c_str(), val.c_str()); |
| - } else if (arg == "--tla-code-file") { |
| - std::string var, val; |
| - if (!get_var_file(next_arg(i, args), "import", var, val)) |
| - return ARG_FAILURE; |
| - jsonnet_tla_code(vm, var.c_str(), val.c_str()); |
| - |
| - } else if (arg == "--gc-min-objects") { |
| - long l = strtol_check(next_arg(i, args)); |
| - if (l < 0) { |
| - std::cerr << "ERROR: invalid --gc-min-objects value: " << l << std::endl; |
| - return ARG_FAILURE; |
| - } |
| - jsonnet_gc_min_objects(vm, l); |
| - } else if (arg == "-t" || arg == "--max-trace") { |
| - long l = strtol_check(next_arg(i, args)); |
| - if (l < 0) { |
| - std::cerr << "ERROR: invalid --max-trace value: " << l << std::endl; |
| - return ARG_FAILURE; |
| - } |
| - jsonnet_max_trace(vm, l); |
| - } else if (arg == "--gc-growth-trigger") { |
| - std::string num = next_arg(i, args); |
| - char *ep; |
| - double v = std::strtod(num.c_str(), &ep); |
| - if (*ep != '\0' || num.length() == 0) { |
| - std::cerr << "ERROR: invalid number \"" << num << "\"" << std::endl; |
| - return ARG_FAILURE; |
| - } |
| - if (v < 0) { |
| - std::cerr << "ERROR: invalid --gc-growth-trigger \"" << num << "\"" |
| - << std::endl; |
| - return ARG_FAILURE; |
| - } |
| - jsonnet_gc_growth_trigger(vm, v); |
| - } else if (arg == "-m" || arg == "--multi") { |
| - config->evalMulti = true; |
| - std::string output_dir = next_arg(i, args); |
| - if (output_dir.length() == 0) { |
| - std::cerr << "ERROR: -m argument was empty string" << std::endl; |
| - return ARG_FAILURE; |
| - } |
| - if (output_dir[output_dir.length() - 1] != '/') { |
| - output_dir += '/'; |
| - } |
| - config->evalMultiOutputDir = output_dir; |
| - } else if (arg == "-y" || arg == "--yaml-stream") { |
| - config->evalStream = true; |
| - } else if (arg == "-S" || arg == "--string") { |
| - jsonnet_string_output(vm, 1); |
| - } else if (arg.length() > 1 && arg[0] == '-') { |
| - std::cerr << "ERROR: unrecognized argument: " << arg << std::endl; |
| - return ARG_FAILURE; |
| - } else { |
| - remaining_args.push_back(args[i]); |
| + { |
| + std::ifstream exists(filename.c_str()); |
| + if (exists.good()) { |
| + std::string existing_content; |
| + existing_content.assign(std::istreambuf_iterator<char>(exists), |
| + std::istreambuf_iterator<char>()); |
| + if (existing_content == new_content) { |
| + // Do not bump the timestamp on the file if its content is |
| + // the same. This may trigger other tools (e.g. make) to do |
| + // unnecessary work. |
| + continue; |
| } |
| + } |
| } |
| - |
| - const char *want = config->filenameIsCode ? "code" : "filename"; |
| - if (remaining_args.size() == 0) { |
| - std::cerr << "ERROR: must give " << want << "\n" << std::endl; |
| - usage(std::cerr); |
| - return ARG_FAILURE; |
| - } |
| - |
| - if (remaining_args.size() > 1) { |
| - std::string filename = remaining_args[0]; |
| - std::cerr << "ERROR: only one " << want << " is allowed\n" << std::endl; |
| - return ARG_FAILURE; |
| - } |
| - config->inputFiles = remaining_args; |
| - return ARG_CONTINUE; |
| -} |
| - |
| -/** Writes output files for multiple file output */ |
| -static bool write_multi_output_files(JsonnetVm *vm, char *output, const std::string &output_dir, |
| - const std::string &output_file) |
| -{ |
| - // If multiple file output is used, then iterate over each string from |
| - // the sequence of strings returned by jsonnet_evaluate_snippet_multi, |
| - // construct pairs of filename and content, and write each output file. |
| - std::map<std::string, std::string> r; |
| - for (const char *c = output; *c != '\0';) { |
| - const char *filename = c; |
| - const char *c2 = c; |
| - while (*c2 != '\0') |
| - ++c2; |
| - ++c2; |
| - const char *json = c2; |
| - while (*c2 != '\0') |
| - ++c2; |
| - ++c2; |
| - c = c2; |
| - r[filename] = json; |
| - } |
| - jsonnet_realloc(vm, output, 0); |
| - |
| - std::ostream *o; |
| std::ofstream f; |
| - |
| - if (output_file.empty()) { |
| - o = &std::cout; |
| - } else { |
| - f.open(output_file.c_str()); |
| - if (!f.good()) { |
| - std::string msg = "Writing to output file: " + output_file; |
| - perror(msg.c_str()); |
| - return false; |
| - } |
| - o = &f; |
| + f.open(filename.c_str()); |
| + if (!f.good()) { |
| + std::string msg = "Opening output file: " + filename; |
| + perror(msg.c_str()); |
| + return false; |
| + } |
| + f << new_content; |
| + f.close(); |
| + if (!f.good()) { |
| + std::string msg = "Writing to output file: " + filename; |
| + perror(msg.c_str()); |
| + return false; |
| } |
| + } |
| |
| - for (const auto &pair : r) { |
| - const std::string &new_content = pair.second; |
| - const std::string &filename = output_dir + pair.first; |
| - (*o) << filename << std::endl; |
| - { |
| - std::ifstream exists(filename.c_str()); |
| - if (exists.good()) { |
| - std::string existing_content; |
| - existing_content.assign(std::istreambuf_iterator<char>(exists), |
| - std::istreambuf_iterator<char>()); |
| - if (existing_content == new_content) { |
| - // Do not bump the timestamp on the file if its content is |
| - // the same. This may trigger other tools (e.g. make) to do |
| - // unnecessary work. |
| - continue; |
| - } |
| - } |
| - } |
| - std::ofstream f; |
| - f.open(filename.c_str()); |
| - if (!f.good()) { |
| - std::string msg = "Opening output file: " + filename; |
| - perror(msg.c_str()); |
| - return false; |
| - } |
| - f << new_content; |
| - f.close(); |
| - if (!f.good()) { |
| - std::string msg = "Writing to output file: " + filename; |
| - perror(msg.c_str()); |
| - return false; |
| - } |
| - } |
| + std::cout.flush(); |
| |
| - if (output_file.empty()) { |
| - std::cout.flush(); |
| - } else { |
| - f.close(); |
| - if (!f.good()) { |
| - std::string msg = "Writing to output file: " + output_file; |
| - perror(msg.c_str()); |
| - return false; |
| - } |
| - } |
| - return true; |
| + return true; |
| } |
| |
| /** Writes output files for YAML stream output */ |
| -static bool write_output_stream(JsonnetVm *vm, char *output, const std::string &output_file) |
| -{ |
| - std::ostream *o; |
| - std::ofstream f; |
| - |
| - if (output_file.empty()) { |
| - o = &std::cout; |
| - } else { |
| - f.open(output_file.c_str()); |
| - if (!f.good()) { |
| - std::string msg = "Writing to output file: " + output_file; |
| - perror(msg.c_str()); |
| - return false; |
| - } |
| - o = &f; |
| - } |
| - |
| - // If YAML stream output is used, then iterate over each string from |
| - // the sequence of strings returned by jsonnet_evaluate_snippet_stream, |
| - // and add the --- and ... as defined by the YAML spec. |
| - std::vector<std::string> r; |
| - for (const char *c = output; *c != '\0';) { |
| - const char *json = c; |
| - while (*c != '\0') |
| - ++c; |
| - ++c; |
| - r.emplace_back(json); |
| - } |
| - jsonnet_realloc(vm, output, 0); |
| - for (const auto &str : r) { |
| - (*o) << "---\n"; |
| - (*o) << str; |
| - } |
| - if (r.size() > 0) |
| - (*o) << "...\n"; |
| - o->flush(); |
| - |
| - if (output_file.empty()) { |
| - std::cout.flush(); |
| - } else { |
| - f.close(); |
| - if (!f.good()) { |
| - std::string msg = "Writing to output file: " + output_file; |
| - perror(msg.c_str()); |
| - return false; |
| - } |
| +bool write_output_stream(char *output, const std::string &output_file) { |
| + std::ostream *o; |
| + std::ofstream f; |
| + |
| + if (output_file.empty()) { |
| + o = &std::cout; |
| + } else { |
| + f.open(output_file.c_str()); |
| + if (!f.good()) { |
| + std::string msg = "Writing to output file: " + output_file; |
| + perror(msg.c_str()); |
| + return false; |
| + } |
| + o = &f; |
| + } |
| + |
| + // If YAML stream output is used, then iterate over each string from |
| + // the sequence of strings returned by jsonnet_evaluate_snippet_stream, |
| + // and add the --- and ... as defined by the YAML spec. |
| + std::vector<std::string> r; |
| + for (const char *c = output; *c != '\0';) { |
| + const char *json = c; |
| + while (*c != '\0') ++c; |
| + ++c; |
| + r.emplace_back(json); |
| + } |
| + |
| + for (const auto &str : r) { |
| + (*o) << "---\n"; |
| + (*o) << str; |
| + } |
| + if (r.size() > 0) (*o) << "...\n"; |
| + o->flush(); |
| + |
| + if (output_file.empty()) { |
| + std::cout.flush(); |
| + } else { |
| + f.close(); |
| + if (!f.good()) { |
| + std::string msg = "Writing to output file: " + output_file; |
| + perror(msg.c_str()); |
| + return false; |
| } |
| + } |
| |
| - return true; |
| -} |
| - |
| -int main(int argc, const char **argv) |
| -{ |
| - try { |
| - JsonnetVm *vm = jsonnet_make(); |
| - JsonnetConfig config; |
| - if (const char *jsonnet_path_env = getenv("JSONNET_PATH")) { |
| - std::list<std::string> jpath; |
| - std::istringstream iss(jsonnet_path_env); |
| - std::string path; |
| - while (std::getline(iss, path, PATH_SEP)) { |
| - jpath.push_front(path); |
| - } |
| - for (const std::string &path : jpath) { |
| - jsonnet_jpath_add(vm, path.c_str()); |
| - } |
| - } |
| - ArgStatus arg_status = process_args(argc, argv, &config, vm); |
| - if (arg_status != ARG_CONTINUE) { |
| - jsonnet_destroy(vm); |
| - return arg_status == ARG_SUCCESS ? EXIT_SUCCESS : EXIT_FAILURE; |
| - } |
| - |
| - // Evaluate input Jsonnet and handle any errors from Jsonnet VM. |
| - int error; |
| - char *output; |
| - assert(config.inputFiles.size() == 1); |
| - |
| - // Read input file. |
| - std::string input; |
| - if (!read_input(config.filenameIsCode, &config.inputFiles[0], &input)) { |
| - jsonnet_destroy(vm); |
| - return EXIT_FAILURE; |
| - } |
| - |
| - if (config.evalMulti) { |
| - output = jsonnet_evaluate_snippet_multi( |
| - vm, config.inputFiles[0].c_str(), input.c_str(), &error); |
| - } else if (config.evalStream) { |
| - output = jsonnet_evaluate_snippet_stream( |
| - vm, config.inputFiles[0].c_str(), input.c_str(), &error); |
| - } else { |
| - output = jsonnet_evaluate_snippet( |
| - vm, config.inputFiles[0].c_str(), input.c_str(), &error); |
| - } |
| - |
| - if (error) { |
| - std::cerr << output; |
| - jsonnet_realloc(vm, output, 0); |
| - jsonnet_destroy(vm); |
| - return EXIT_FAILURE; |
| - } |
| - |
| - // Write output JSON. |
| - if (config.evalMulti) { |
| - if (!write_multi_output_files( |
| - vm, output, config.evalMultiOutputDir, config.outputFile)) { |
| - jsonnet_destroy(vm); |
| - return EXIT_FAILURE; |
| - } |
| - } else if (config.evalStream) { |
| - if (!write_output_stream(vm, output, config.outputFile)) { |
| - jsonnet_destroy(vm); |
| - return EXIT_FAILURE; |
| - } |
| - } else { |
| - bool successful = write_output_file(output, config.outputFile); |
| - jsonnet_realloc(vm, output, 0); |
| - if (!successful) { |
| - jsonnet_destroy(vm); |
| - return EXIT_FAILURE; |
| - } |
| - } |
| - |
| - jsonnet_destroy(vm); |
| - return EXIT_SUCCESS; |
| - |
| - } catch (const std::bad_alloc &) { |
| - // Avoid further allocation attempts |
| - fputs("Internal out-of-memory error (please report this)\n", stderr); |
| - } catch (const std::exception &e) { |
| - std::cerr << "Internal error (please report this): " << e.what() << std::endl; |
| - } catch (...) { |
| - std::cerr << "An unknown exception occurred (please report this)." << std::endl; |
| - } |
| - return EXIT_FAILURE; |
| + return true; |
| } |
