#include "openscad.h"

#include "version.h"

#ifdef _WIN32

#include <fcntl.h>

#include <io.h>

#include <cassert>

#endif

#include <libintl.h>

#include <array>

#include <boost/algorithm/string/case_conv.hpp>

#include <boost/algorithm/string/classification.hpp>

#include <boost/algorithm/string/join.hpp>

#include <boost/algorithm/string/predicate.hpp>

#include <boost/algorithm/string/split.hpp>

#include <boost/dll/runtime_symbol_info.hpp>

#include <boost/lexical_cast.hpp>

#include <boost/lexical_cast/bad_lexical_cast.hpp>

#include <boost/optional/optional.hpp>

#include <boost/program_options/options_description.hpp>

#include <boost/program_options/parsers.hpp>

#include <boost/program_options/positional_options.hpp>

#include <boost/program_options/value_semantic.hpp>

#include <boost/program_options/variables_map.hpp>

#include <boost/range/adaptor/transformed.hpp>

#include <boost/range/iterator_range_core.hpp>

#include <clocale>

#include <cstddef>

#include <cstdlib>

#include <exception>

#include <filesystem>

#include <fstream>

#include <iomanip>

#include <ios>

#include <iostream>

#include <istream>

#include <iterator>

#include <map>

#include <memory>

#include <ostream>

#include <sstream>

#include <stdexcept>

#include <string>

#include <tuple>

#include <unordered_map>

#include <utility>

#include <vector>

#ifdef ENABLE_CGAL

#include <CGAL/assertions.h>

#include <CGAL/assertions_behaviour.h>

#endif

#include "Feature.h"

#include "LibraryInfo.h"

#include "RenderStatistic.h"

#include "core/AST.h"

#include "core/BuiltinContext.h"

#include "core/Builtins.h"

#include "core/CSGTreeEvaluator.h"

#include "core/Context.h"

#include "core/EvaluationSession.h"

#include "core/RenderVariables.h"

#include "core/ScopeContext.h"

#include "core/Settings.h"

#include "core/customizer/CommentParser.h"

#include "core/customizer/ParameterObject.h"

#include "core/customizer/ParameterSet.h"

#include "core/node.h"

#include "core/parsersettings.h"

#include "geometry/Geometry.h"

#include "geometry/GeometryEvaluator.h"

#include "geometry/GeometryUtils.h"

#include "geometry/PolySet.h"

#include "glview/Camera.h"

#include "glview/ColorMap.h"

#include "glview/OffscreenView.h"

#include "glview/RenderSettings.h"

#include "handle_dep.h"

#include "io/export.h"

#include "openscad_gui.h"

#include "openscad_mimalloc.h"

#include "platform/PlatformUtils.h"

#include "utils/StackCheck.h"

#include "utils/exceptions.h"

#include "utils/printutils.h"

#ifdef ENABLE_PYTHON

#include "python/python_public.h"

#endif

namespace po = boost::program_options;

namespace fs = std::filesystem;

std::string commandline_commands;

std::string arg_colorscheme;

namespace {

bool arg_info = false;

} // namespace

class Echostream

};

struct AnimateArgs {

};

struct CommandLine {

};

namespace {

#ifndef OPENSCAD_NOGUI

bool useGUI()

}

#endif // OPENSCAD_NOGUI

bool checkAndExport(const std::shared_ptr<const Geometry>& root_geom, unsigned dimensions,

}

void help(const char *arg0, const po::options_description& desc, bool failure = false)

}

template <std::size_t size>

void help_export(const std::array<const Settings::SettingsEntryBase *, size>& options)

}

void help_export()

}

void version()

}

int info()

}

template <typename F>

bool with_output(const bool is_stdout, const std::string& filename, const F& f,

}

AnimateArgs get_animate(const po::variables_map& vm)

}

Camera get_camera(const po::variables_map& vm)

}

int do_export(const CommandLine& cmd, const RenderVariables& render_variables, FileFormat export_format,

SourceFile *root_file)

{

auto filename_str = fs::path(cmd.output_file).generic_string();

// Avoid possibility of fs::absolute throwing when passed an empty path

auto fpath = cmd.filename.empty() ? fs::current_path() : fs::absolute(fs::path(cmd.filename));

auto fparent = fpath.parent_path();

// set CWD relative to source file

fs::current_path(fparent);

EvaluationSession session{fparent.string()};

ContextHandle<BuiltinContext> builtin_context{Context::create<BuiltinContext>(&session)};

render_variables.applyToContext(builtin_context);

#ifdef DEBUG

PRINTDB("BuiltinContext:\n%s", builtin_context->dump());

#endif

AbstractNode::resetIndexCounter();

std::shared_ptr<const FileContext> file_context;

std::shared_ptr<AbstractNode> absolute_root_node;

#ifdef ENABLE_PYTHON

if (python_result_node != NULL && python_active) {

absolute_root_node = python_result_node;

} else {

#endif

absolute_root_node = root_file->instantiate(*builtin_context, &file_context);

#ifdef ENABLE_PYTHON

}

#endif

Camera camera = cmd.camera;

if (file_context) {

camera.updateView(file_context, true);

}

// restore CWD after module instantiation finished

fs::current_path(cmd.original_path);

// Do we have an explicit root node (! modifier)?

std::shared_ptr<const AbstractNode> root_node;

const Location *nextLocation = nullptr;

if (!(root_node = find_root_tag(absolute_root_node, &nextLocation))) {

root_node = absolute_root_node;

}

if (nextLocation) {

LOG(message_group::Warning, *nextLocation, builtin_context->documentRoot(),

"More than one Root Modifier (!)");

}

Tree tree(root_node, fparent.string());

if (export_format == FileFormat::CSG) {

// https://github.com/openscad/openscad/issues/128

// When I use the csg ouptput from the command line the paths in 'import'

// statements become relative. But unfortunately they become relative to

// the current working dir and neither to the location of the input nor

// the output.

fs::current_path(fparent); // Force exported filenames to be relative to document path

with_output(cmd.is_stdout, filename_str, [&tree, root_node](std::ostream& stream) {

stream << tree.getString(*root_node, "\t") << "\n";

});

fs::current_path(cmd.original_path);

} else if (export_format == FileFormat::AST) {

fs::current_path(fparent); // Force exported filenames to be relative to document path

with_output(cmd.is_stdout, filename_str,

[root_file](std::ostream& stream) { stream << root_file->dump(""); });

fs::current_path(cmd.original_path);

} else if (export_format == FileFormat::PARAM) {

with_output(cmd.is_stdout, filename_str,

[&root_file, &fpath](std::ostream& stream) { export_param(root_file, fpath, stream); });

} else if (export_format == FileFormat::TERM) {

CSGTreeEvaluator csgRenderer(tree);

auto root_raw_term = csgRenderer.buildCSGTree(*root_node);

with_output(cmd.is_stdout, filename_str, [root_raw_term](std::ostream& stream) {

if (!root_raw_term || root_raw_term->isEmptySet()) {

stream << "No top-level CSG object\n";

} else {

stream << root_raw_term->dump() << "\n";

}

});

} else if (export_format == FileFormat::ECHO) {

// echo -> don't need to evaluate any geometry

} else {

// start measuring render time

RenderStatistic renderStatistic;

GeometryEvaluator geomevaluator(tree);

std::unique_ptr<OffscreenView> glview;

std::shared_ptr<const Geometry> root_geom;

if ((export_format == FileFormat::ECHO || export_format == FileFormat::PNG) &&

(cmd.viewOptions.renderer == RenderType::OPENCSG ||

cmd.viewOptions.renderer == RenderType::THROWNTOGETHER)) {

// OpenCSG or throwntogether png -> just render a preview

glview = prepare_preview(tree, cmd.viewOptions, camera);

if (!glview) return 1;

} else {

// Force creation of concrete geometry (mostly for testing)

// FIXME: Consider adding MANIFOLD as a valid --render argument and ViewOption, to be able to

// distinguish from CGAL

constexpr bool allownef = true;

root_geom = geomevaluator.evaluateGeometry(*tree.root(), allownef);

if (!root_geom) root_geom = std::make_shared<PolySet>(3);

if (cmd.viewOptions.renderer == RenderType::BACKEND_SPECIFIC && root_geom->getDimension() == 3) {

if (auto geomlist = std::dynamic_pointer_cast<const GeometryList>(root_geom)) {

auto flatlist = geomlist->flatten();

for (auto& child : flatlist) {

if (child.second->getDimension() == 3) {

child.second = GeometryUtils::getBackendSpecificGeometry(child.second);

}

}

root_geom = std::make_shared<GeometryList>(flatlist);

} else {

root_geom = GeometryUtils::getBackendSpecificGeometry(root_geom);

assert(root_geom != nullptr);

}

LOG("Converted to backend-specific geometry");

}

}

const std::string input_filename = cmd.is_stdin ? "<stdin>" : cmd.filename;

const int dim = fileformat::is3D(export_format) ? 3 : fileformat::is2D(export_format) ? 2 : 0;

ExportInfo exportInfo = createExportInfo(export_format, fileformat::info(export_format),

input_filename, &cmd.camera, cmd.exportOptions);

if (dim > 0 && !checkAndExport(root_geom, dim, exportInfo, cmd.is_stdout, filename_str)) {

return 1;

}

if (export_format == FileFormat::PNG) {

bool success = true;

bool const wrote = with_output(

cmd.is_stdout, filename_str,

[&success, &root_geom, &cmd, &camera, &glview](std::ostream& stream) {

if (cmd.viewOptions.renderer == RenderType::BACKEND_SPECIFIC ||

cmd.viewOptions.renderer == RenderType::GEOMETRY) {

success = export_png(root_geom, cmd.viewOptions, camera, stream);

} else {

success = export_png(*glview, stream);

}

},

std::ios::out | std::ios::binary);

if (!success || !wrote) {

return 1;

}

}

renderStatistic.printAll(root_geom, camera, cmd.summaryOptions, cmd.summaryFile);

}

return 0;

}

int cmdline(const CommandLine& cmd)

}

template <class Seq, typename ToString>

static std::string str_join(const Seq& seq, const std::string& sep, const ToString& toString)

{

return boost::algorithm::join(boost::adaptors::transform(seq, toString), sep);

}

static bool flagConvert(const std::string& str)

}

static std::tuple<std::string, std::string> simple_split(const std::string& str, const char c)

}

static CmdLineExportOptions convert_export_options(const po::variables_map& vm)

}

} // namespace

void set_render_color_scheme(const std::string& color_scheme, const bool exit_if_not_found)

}

void localization_init()

}

#ifdef Q_OS_MACOS

std::pair<std::string, std::string> customSyntax(const std::string& s)

{

if (s.find("-psn_") == 0) return {"psn", s.substr(5)};

#else

std::pair<std::string, std::string> customSyntax(const std::string&)

}

struct CommaSeparatedVector {

};

int openscad_main(int argc, char **argv)

{

#if defined(ENABLE_CGAL) && defined(USE_MIMALLOC)

// call init_mimalloc before any GMP variables are initialized. (defined in src/openscad_mimalloc.h)

init_mimalloc();

#endif

int rc = 0;

StackCheck::inst();

#ifdef Q_OS_MACOS

bool isGuiLaunched = getenv("GUI_LAUNCHED") != nullptr;

auto nslog = [](const Message& msg, void *userdata) { CocoaUtils::nslog(msg.msg, userdata); };

if (isGuiLaunched) set_output_handler(nslog, nullptr, nullptr);

#else

PlatformUtils::ensureStdIO();

#endif

#ifndef __EMSCRIPTEN__

const auto applicationPath =

weakly_canonical(boost::dll::program_location()).parent_path().generic_string();

#else

const auto applicationPath = boost::dll::fs::current_path();

#endif

PlatformUtils::registerApplicationPath(applicationPath);

#ifdef ENABLE_PYTHON

// The original name as called, not resolving links and so on. This will

// just forward everything to the python main.

const auto applicationName = fs::path(argv[0]).filename().generic_string();

if (applicationName == "python" || applicationName == "python3" ||

applicationName.rfind("python3.", 0) == 0 || applicationName == "openscad-python") {

return pythonRunArgs(argc, argv);

}

#endif

#ifdef ENABLE_CGAL

// Always throw exceptions from CGAL, so we can catch instead of crashing on bad geometry.

CGAL::set_error_behaviour(CGAL::THROW_EXCEPTION);

CGAL::set_warning_behaviour(CGAL::THROW_EXCEPTION);

#endif

Builtins::instance()->initialize();

auto original_path = fs::current_path();

std::vector<std::string> output_files;

const char *deps_output_file = nullptr;

boost::optional<FileFormat> export_format;

ViewOptions viewOptions{};

po::options_description desc("Allowed options");

// clang-format off

desc.add_options()

("export-format", po::value<std::string>(),

"overrides format of exported scad file when using option '-o', arg can be any of its supported "

"file extensions. For ASCII stl export, specify 'asciistl', and for binary stl export, specify "

"'binstl'. ASCII export is the current stl default, but binary stl is planned as the future "

"default so asciistl should be explicitly specified in scripts when needed.\n")

("o,o", po::value<std::vector<std::string>>(),

"output specified file instead of running the GUI. The file extension specifies the type: stl, "

"off, wrl, amf, 3mf, csg, dxf, svg, pdf, png, echo, ast, term, nef3, nefdbg, param, pov. May be "

"used multiple times for different exports. Use '-' for stdout.\n")

("O,O", po::value<std::vector<std::string>>(),

"pass settings value to the file export using the format section/key=value, e.g "

"export-pdf/paper-size=a3. Use --help-export to list all available settings.")

("D,D", po::value<std::vector<std::string>>(), "var=val -pre-define variables")

("p,p", po::value<std::string>(), "customizer parameter file")

("P,P", po::value<std::string>(), "customizer parameter set")

#ifdef ENABLE_EXPERIMENTAL

("enable", po::value<std::vector<std::string>>(),

("enable experimental features (specify 'all' for enabling all available features): " +

str_join(boost::make_iterator_range(Feature::begin(), Feature::end()), " | ",

[](const Feature *feature) { return feature->get_name(); }) +

"\n")

.c_str())

#endif

("help,h", "print this help message and exit")

("help-export", "print list of export parameters and values that can be set via -O")

("version,v", "print the version")

("info", "print information about the build process\n")

("camera", po::value<std::string>(),

"camera parameters when exporting png: =translate_x,y,z,rot_x,y,z,dist or "

"=eye_x,y,z,center_x,y,z")("autocenter", "adjust camera to look at object's center")

("viewall", "adjust camera to fit object")

("backend", po::value<std::string>(),

"3D rendering backend to use: 'CGAL' (old/slow) or 'Manifold' (new/fast) [default]")

("imgsize", po::value<std::string>(), "=width,height of exported png")

("render", po::value<std::string>()->implicit_value(""),

"for full geometry evaluation when exporting png")

("preview", po::value<std::string>()->implicit_value(""),

"[=throwntogether] -for ThrownTogether preview png")

("animate", po::value<unsigned>(), "export N animated frames")

("animate_sharding", po::value<std::string>(),

"Parameter <shard>/<num_shards> - Divide work into <num_shards> and only output frames for "

"<shard>. E.g. 2/5 only outputs the second 1/5 of frames. Use to parallelize work on multiple "

"cores or machines.")

("view", po::value<CommaSeparatedVector>(),

("=view options: " + boost::algorithm::join(viewOptions.names(), " | ")).c_str())

("projection", po::value<std::string>(), "=(o)rtho or (p)erspective when exporting png")

("csglimit", po::value<unsigned int>(), "=n -stop rendering at n CSG elements when exporting png")

("summary", po::value<std::vector<std::string>>(),

"enable additional render summary and statistics: all | cache | time | camera | geometry | "

"bounding-box | area")

("summary-file", po::value<std::string>(),

"output summary information in JSON format to the given file, using '-' outputs to stdout")

("colorscheme", po::value<std::string>(),

("=colorscheme: " +

str_join(ColorMap::inst()->colorSchemeNames(), " | ",

[](const std::string& colorScheme) {

return (colorScheme == ColorMap::inst()->defaultColorSchemeName() ? "*" : "") +

colorScheme;

}) +

"\n")

.c_str())

("d,d", po::value<std::string>(), "deps_file -generate a dependency file for make")

("m,m", po::value<std::string>(), "make_cmd -runs make_cmd file if file is missing")

("quiet,q", "quiet mode (don't print anything *except* errors)")

("reset-window-settings", "Reset GUI settings for window placement and fonts.")

("hardwarnings", "Stop on the first warning")

("trace-depth", po::value<unsigned int>(), "=n, maximum number of trace messages")

("trace-usermodule-parameters", po::value<std::string>(),

"=true/false, configure the output of user module parameters in a trace")

("check-parameters", po::value<std::string>(),

"=true/false, configure the parameter check for user modules and functions")

("check-parameter-ranges", po::value<std::string>(),

"=true/false, configure the parameter range check for builtin modules")

("debug", po::value<std::string>(),

"special debug info - specify 'all' or a set of source file names")

#ifdef ENABLE_PYTHON

("trust-python", "Trust python")

("python-module", po::value<std::string>(), "=module Call pip python module")

#endif

;

// clang-format on

#ifdef ENABLE_GUI_TESTS

// clang-format off

desc.add_options()("run-all-gui-tests", "special gui testing mode - run all the tests");

// clang-format on

#endif

po::options_description hidden("Hidden options");

// clang-format off

hidden.add_options()

#ifdef Q_OS_MACOS

("psn", po::value<std::string>(), "process serial number")

#endif

("input-file", po::value<std::vector<std::string>>(), "input file");

// clang-format on

po::positional_options_description p;

p.add("input-file", -1);

po::options_description all_options;

all_options.add(desc).add(hidden);

po::variables_map vm;

try {

po::store(po::command_line_parser(argc, argv)

.options(all_options)

.positional(p)

.extra_parser(customSyntax)

.run(),

vm);

} catch (const std::exception& e) { // Catches e.g. unknown options

LOG("%1$s\n", e.what());

help(argv[0], desc, true);

}

OpenSCAD::debug = "";

if (vm.count("debug")) {

OpenSCAD::debug = vm["debug"].as<std::string>();

LOG("Debug on. --debug=%1$s", OpenSCAD::debug);

}

#ifdef ENABLE_PYTHON

if (vm.count("trust-python")) {

LOG("Python Engine enabled", OpenSCAD::debug);

python_trusted = true;

}

const auto pymod = "python-module";

if (vm.count(pymod)) {

PRINTDB("Running Python Module %s", pymod);

std::vector<std::string> args;

if (vm.count("input-file")) {

args = vm["input-file"].as<std::vector<std::string>>();

}

return pythonRunModule(applicationPath, vm[pymod].as<std::string>(), args);

}

#endif // ifdef ENABLE_PYTHON

if (vm.count("quiet")) {

OpenSCAD::quiet = true;

}

if (vm.count("hardwarnings")) {

OpenSCAD::hardwarnings = true;

}

if (vm.count("traceDepth")) {

OpenSCAD::traceDepth = vm["traceDepth"].as<unsigned int>();

}