flash_v2: host/tools/configtool/standalone/common/cdl

comparison host/tools/configtool/standalone/common/cdl_exec.cxx @ 105:5a0cc6c243a9 ecos-sw-2000-06-30

Merge from eCos master repository on 2000-06-30-08:18:49-BST

author	jlarmour
date	Fri, 30 Jun 2000 16:27:35 +0000
parents	95f3e12a6327
children	84e4bde58b26

comparison

equal deleted inserted replaced

-:ad66e26a9e7c
+:5a0cc6c243a9
 //
 //####DESCRIPTIONEND####
 //==========================================================================
 #ifdef _MSC_VER
-	#include <direct.h> /* for getcwd() */
+#include <direct.h> /* for getcwd() */
 #else
-	#include <unistd.h> /* for getcwd() */
+#include <unistd.h> /* for getcwd() */
 #endif
 #ifdef __CYGWIN__
-	#include <sys/cygwin.h> /* for cygwin_conv_to_win32_path() */
+#include <windows.h>
+#include <sys/cygwin.h> /* for cygwin_conv_to_win32_path() */
 #endif
 #include "build.hxx"
 #include "cdl_exec.hxx"
-cdl_exec::cdl_exec (const std::string repository_tree, const std::string savefile_name, const std::string install_tree, bool no_resolve) :
+// ----------------------------------------------------------------------------
-	pkgdata (NULL),
+bool cdl_exec::quiet            = false;
-	interp (NULL),
+bool cdl_exec::verbose          = false;
-	config (NULL) {
+bool cdl_exec::ignore_errors    = false;
-	repository = repository_tree;
-	savefile = savefile_name;
+cdl_exec::cdl_exec (const std::string repository_arg, const std::string savefile_arg,
-	install_prefix = install_tree;
+const std::string install_arg, bool no_resolve_arg)
-	CdlTransactionBody::set_inference_callback_fn (&inference_callback);
+: repository(repository_arg),
-	if (no_resolve) {
+savefile(savefile_arg),
-		CdlTransactionBody::disable_automatic_inference ();
+install_prefix(install_arg),
-	}
+no_resolve(no_resolve_arg),
-}
+pkgdata (NULL),
+interp (NULL),
-bool cdl_exec::cmd_new (const std::string cdl_hardware, const std::string cdl_template /* = "default" */, const std::string cdl_version /* = "" */) {
+config (NULL)
-	bool status = false;
+{
-	try {
-		pkgdata = CdlPackagesDatabaseBody::make (repository, &diagnostic_handler, &diagnostic_handler);
+// The inference callback does not actually do anything at present.
-		interp = CdlInterpreterBody::make ();
+// In future it may be useful for diagnostic purposes.
-		config = CdlConfigurationBody::make ("eCos", pkgdata, interp);
+CdlTransactionBody::set_inference_callback_fn (&inference_callback);
-		config->set_hardware (resolve_hardware_alias (cdl_hardware), &diagnostic_handler, &diagnostic_handler);
-		if (pkgdata->is_known_template (cdl_template) && ! cdl_version.empty ()) {
+// Automatic inference is always disabled. The inference engine
-			const std::vector<std::string> & versions = pkgdata->get_template_versions (cdl_template);
+// only gets invoked explicitly, after a suitable transaction callback
-			if (versions.end () == std::find (versions.begin (), versions.end (), cdl_version)) {
+// has been invoked. The problem here is that the transaction callback
-				throw CdlStringException ("Unknown version " + cdl_version);
+// has to report changes made by the inference engine but there is
-			}
+// no way of distinguishing between inferred values that come out of
-		}
+// savefiles and inferred values determined by the inference engine.
-		config->set_template (cdl_template, cdl_version, &diagnostic_handler, &diagnostic_handler);
+CdlTransactionBody::disable_automatic_inference ();
-		config->save (savefile);
+}
-		status = true;
-	} catch (CdlStringException exception) {
+void
-		exception_handler (exception);
+cdl_exec::set_quiet_mode(bool new_val)
-	} catch (...) {
+{
-		exception_handler ();
+quiet = new_val;
-	}
+}
-	delete_cdl_data ();
+void
-	return status;
+cdl_exec::set_verbose_mode(bool new_val)
-}
+{
+verbose = new_val;
-bool cdl_exec::cmd_target (const std::string cdl_target) {
+}
-	bool status = false;
-	try {
+void
-		pkgdata = CdlPackagesDatabaseBody::make (repository, &diagnostic_handler, &diagnostic_handler);
+cdl_exec::set_ignore_errors_mode(bool new_val)
-		interp = CdlInterpreterBody::make ();
+{
-		config = CdlConfigurationBody::load (savefile, pkgdata, interp, &diagnostic_handler, &diagnostic_handler);
+ignore_errors = new_val;
-		config->set_hardware (resolve_hardware_alias (cdl_target), &diagnostic_handler, &diagnostic_handler);
+}
-		config->save (savefile);
-		status = true;
+// ----------------------------------------------------------------------------
-	} catch (CdlStringException exception) {
+void
-		exception_handler (exception);
+cdl_exec::init(bool load_config)
-	} catch (...) {
+{
-		exception_handler ();
+pkgdata = CdlPackagesDatabaseBody::make(repository, &diagnostic_handler, &diagnostic_handler);
-	}
+interp  = CdlInterpreterBody::make();
+if (load_config) {
-	delete_cdl_data ();
+config = CdlConfigurationBody::load (savefile, pkgdata, interp, &diagnostic_handler, &diagnostic_handler);
-	return status;
+}
 }
-bool cdl_exec::cmd_template (const std::string cdl_template, const std::string cdl_version /* = "" */) {
+// ----------------------------------------------------------------------------
-	bool status = false;
+void
-	try {
+cdl_exec::delete_cdl_data ()
-		pkgdata = CdlPackagesDatabaseBody::make (repository, &diagnostic_handler, &diagnostic_handler);
+{
-		interp = CdlInterpreterBody::make ();
+if (0 != config) {
-		config = CdlConfigurationBody::load (savefile, pkgdata, interp, &diagnostic_handler, &diagnostic_handler);
+delete config;
-		if (pkgdata->is_known_template (cdl_template) && ! cdl_version.empty ()) {
+config = 0;
-			const std::vector<std::string> & versions = pkgdata->get_template_versions (cdl_template);
+}
-			if (versions.end () == std::find (versions.begin (), versions.end (), cdl_version)) {
+if (0 != interp) {
-				throw CdlStringException ("Unknown version " + cdl_version);
+delete interp;
-			}
+interp = 0;
-		}
+}
-		config->set_template (cdl_template, cdl_version, &diagnostic_handler, &diagnostic_handler);
+if (0 != pkgdata) {
-		config->save (savefile);
+delete pkgdata;
-		status = true;
+pkgdata = 0;
-	} catch (CdlStringException exception) {
+}
-		exception_handler (exception);
+}
-	} catch (...) {
-		exception_handler ();
+// ----------------------------------------------------------------------------
-	}
+bool cdl_exec::cmd_new (const std::string cdl_hardware,
+const std::string cdl_template /* = "default" */,
-	delete_cdl_data ();
+const std::string cdl_version /* = "" */)
-	return status;
+{
-}
+bool status = false;
+try {
-bool cdl_exec::cmd_export (const std::string cdl_savefile) {
+init(false);
-	bool status = false;
-	try {
+config = CdlConfigurationBody::make ("eCos", pkgdata, interp);
-		pkgdata = CdlPackagesDatabaseBody::make (repository, &diagnostic_handler, &diagnostic_handler);
-		interp = CdlInterpreterBody::make ();
+// The hardware and template should be loaded in a single transaction.
-		config = CdlConfigurationBody::load (savefile, pkgdata, interp, &diagnostic_handler, &diagnostic_handler);
+// Validating the target name etc. can be left to libcdl.
-		config->save (cdl_savefile, /* minimal = */ true);
+CdlTransaction transact = CdlTransactionBody::make(config);
-		status = true;
+config->set_hardware(transact, resolve_hardware_alias(cdl_hardware), &diagnostic_handler, &diagnostic_handler);
-	} catch (CdlStringException exception) {
+config->set_template(transact, cdl_template, cdl_version, &diagnostic_handler, &diagnostic_handler);
-		exception_handler (exception);
+transact->body();
-	} catch (...) {
+delete transact;
-		exception_handler ();
-	}
+// Unless inference has been suppressed, make sure that the
+// inference engine gets invoked and that its results get
-	delete_cdl_data ();
+// reported.
-	return status;
+if (!no_resolve) {
-}
+CdlTransactionBody::set_callback_fn(&transaction_callback);
+config->resolve_all_conflicts();
-bool cdl_exec::cmd_import (const std::string cdl_savefile) {
+}
-	bool status = false;
-	try {
+// Now report any conflicts which the inference engine could not report.
-		pkgdata = CdlPackagesDatabaseBody::make (repository, &diagnostic_handler, &diagnostic_handler);
+report_conflicts();
-		interp = CdlInterpreterBody::make ();
-		config = CdlConfigurationBody::load (savefile, pkgdata, interp, &diagnostic_handler, &diagnostic_handler);
+// A savefile should be generated/updated even if there are conflicts.
-		config->add (cdl_savefile, &diagnostic_handler, &diagnostic_handler);
+// Otherwise the user does not have a chance to edit the savefile
-		config->save (savefile);
+// and fix things.
-		status = true;
+config->save (savefile);
-	} catch (CdlStringException exception) {
+if (ignore_errors || (0 == config->get_all_conflicts().size())) {
-		exception_handler (exception);
+status = true;
-	} catch (...) {
+}
-		exception_handler ();
+} catch (CdlStringException exception) {
-	}
+exception_handler (exception);
+} catch (...) {
-	delete_cdl_data ();
+exception_handler ();
-	return status;
+}
-}
+delete_cdl_data ();
-bool cdl_exec::cmd_add (const std::vector<std::string> cdl_packages) {
+return status;
-	bool status = false;
+}
-	try {
-		pkgdata = CdlPackagesDatabaseBody::make (repository, &diagnostic_handler, &diagnostic_handler);
+// ----------------------------------------------------------------------------
-		interp = CdlInterpreterBody::make ();
+bool
-		config = CdlConfigurationBody::load (savefile, pkgdata, interp, &diagnostic_handler, &diagnostic_handler);
+cdl_exec::cmd_target (const std::string cdl_target)
-		for (unsigned int n = 0; n < cdl_packages.size (); n++) {
+{
-			config->load_package (resolve_package_alias (cdl_packages [n]), "", &diagnostic_handler, &diagnostic_handler);
+bool status = false;
-		}
+try {
-		config->save (savefile);
+init(true);
-		status = true;
+config->set_hardware (resolve_hardware_alias (cdl_target), &diagnostic_handler, &diagnostic_handler);
-	} catch (CdlStringException exception) {
+if (!no_resolve) {
-		exception_handler (exception);
+CdlTransactionBody::set_callback_fn(&transaction_callback);
-	} catch (...) {
+config->resolve_all_conflicts();
-		exception_handler ();
+}
-	}
+report_conflicts();
+config->save (savefile);
-	delete_cdl_data ();
+if (ignore_errors || (0 == config->get_all_conflicts().size())) {
-	return status;
+status = true;
 }
+} catch (CdlStringException exception) {
-bool cdl_exec::cmd_remove (const std::vector<std::string> cdl_packages) {
+exception_handler (exception);
-	unsigned int n;
+} catch (...) {
-	bool status = false;
+exception_handler ();
-	try {
+}
-		pkgdata = CdlPackagesDatabaseBody::make (repository, &diagnostic_handler, &diagnostic_handler);
-		interp = CdlInterpreterBody::make ();
+delete_cdl_data ();
-		config = CdlConfigurationBody::load (savefile, pkgdata, interp, &diagnostic_handler, &diagnostic_handler);
+return status;
-		for (n = 0; n < cdl_packages.size (); n++) {
+}
-			if (! config->lookup (resolve_package_alias (cdl_packages [n]))) {
-				throw CdlStringException ("Unknown package " + cdl_packages [n]);
+// ----------------------------------------------------------------------------
-			}
+bool
-		}
+cdl_exec::cmd_template (const std::string cdl_template, const std::string cdl_version /* = "" */)
-		for (n = 0; n < cdl_packages.size (); n++) {
+{
-			config->unload_package (resolve_package_alias (cdl_packages [n]));
+bool status = false;
-		}
+try {
-		config->save (savefile);
+init(true);
-		status = true;
+config->set_template (cdl_template, cdl_version, &diagnostic_handler, &diagnostic_handler);
-	} catch (CdlStringException exception) {
+if (!no_resolve) {
-		exception_handler (exception);
+CdlTransactionBody::set_callback_fn(&transaction_callback);
-	} catch (...) {
+config->resolve_all_conflicts();
-		exception_handler ();
+}
-	}
+report_conflicts();
+config->save (savefile);
-	delete_cdl_data ();
+if (ignore_errors || (0 == config->get_all_conflicts().size())) {
-	return status;
+status = true;
 }
+} catch (CdlStringException exception) {
-bool cdl_exec::cmd_version (const std::string cdl_version, const std::vector<std::string> cdl_packages) {
+exception_handler (exception);
-	bool status = false;
+} catch (...) {
-	try {
+exception_handler ();
-		pkgdata = CdlPackagesDatabaseBody::make (repository, &diagnostic_handler, &diagnostic_handler);
+}
-		interp = CdlInterpreterBody::make ();
-		config = CdlConfigurationBody::load (savefile, pkgdata, interp, &diagnostic_handler, &diagnostic_handler);
+delete_cdl_data ();
-		for (unsigned int n = 0; n < cdl_packages.size (); n++) {
+return status;
-			config->change_package_version (resolve_package_alias (cdl_packages [n]), cdl_version, &diagnostic_handler, &diagnostic_handler, true);
+}
-		}
-		config->save (savefile);
+// ----------------------------------------------------------------------------
-		status = true;
+bool
-	} catch (CdlStringException exception) {
+cdl_exec::cmd_export (const std::string cdl_savefile)
-		exception_handler (exception);
+{
-	} catch (...) {
+bool status = false;
-		exception_handler ();
+try {
-	}
+init(true);
+if (!no_resolve) {
-	delete_cdl_data ();
+CdlTransactionBody::set_callback_fn(&transaction_callback);
-	return status;
+config->resolve_all_conflicts();
 }
+report_conflicts();
-bool cdl_exec::cmd_tree () {
+// Exporting to another file should only happen if the
-	bool status = false;
+// configuration is conflict-free. This is different from
-	try {
+// updating the savefile.
-		pkgdata = CdlPackagesDatabaseBody::make (repository, &diagnostic_handler, &diagnostic_handler);
+if (ignore_errors || (0 == config->get_all_conflicts().size())) {
-		interp = CdlInterpreterBody::make ();
+config->save (cdl_savefile, /* minimal = */ true);
-		config = CdlConfigurationBody::load (savefile, pkgdata, interp, &diagnostic_handler, &diagnostic_handler);
+status = true;
+}
+} catch (CdlStringException exception) {
+exception_handler (exception);
+} catch (...) {
+exception_handler ();
+}
+delete_cdl_data ();
+return status;
+}
+// ----------------------------------------------------------------------------
+bool
+cdl_exec::cmd_import (const std::string cdl_savefile)
+{
+bool status = false;
+try {
+init(true);
+config->add(cdl_savefile, &diagnostic_handler, &diagnostic_handler);
+if (!no_resolve) {
+CdlTransactionBody::set_callback_fn(&transaction_callback);
+config->resolve_all_conflicts();
+}
+report_conflicts();
+config->save (savefile);
+if (ignore_errors || (0 == config->get_all_conflicts().size())) {
+status = true;
+}
+} catch (CdlStringException exception) {
+exception_handler (exception);
+} catch (...) {
+exception_handler ();
+}
+delete_cdl_data ();
+return status;
+}
+// ----------------------------------------------------------------------------
+bool
+cdl_exec::cmd_add (const std::vector<std::string> cdl_packages)
+{
+bool status = false;
+try {
+init(true);
+for (unsigned int n = 0; n < cdl_packages.size (); n++) {
+config->load_package (resolve_package_alias (cdl_packages [n]), "", &diagnostic_handler, &diagnostic_handler);
+}
+if (!no_resolve) {
+CdlTransactionBody::set_callback_fn(&transaction_callback);
+config->resolve_all_conflicts();
+}
+report_conflicts();
+config->save (savefile);
+if (ignore_errors || (0 == config->get_all_conflicts().size())) {
+status = true;
+}
+} catch (CdlStringException exception) {
+exception_handler (exception);
+} catch (...) {
+exception_handler ();
+}
+delete_cdl_data ();
+return status;
+}
+// ----------------------------------------------------------------------------
+bool
+cdl_exec::cmd_remove (const std::vector<std::string> cdl_packages)
+{
+unsigned int n;
+bool status = false;
+try {
+init(true);
+for (n = 0; n < cdl_packages.size (); n++) {
+if (! config->lookup (resolve_package_alias (cdl_packages [n]))) {
+throw CdlStringException ("Unknown package " + cdl_packages [n]);
+}
+}
+for (n = 0; n < cdl_packages.size (); n++) {
+config->unload_package (resolve_package_alias (cdl_packages [n]));
+}
+if (!no_resolve) {
+CdlTransactionBody::set_callback_fn(&transaction_callback);
+config->resolve_all_conflicts();
+}
+report_conflicts();
+config->save (savefile);
+if (ignore_errors || (0 == config->get_all_conflicts().size())) {
+status = true;
+}
+} catch (CdlStringException exception) {
+exception_handler (exception);
+} catch (...) {
+exception_handler ();
+}
+delete_cdl_data ();
+return status;
+}
+// ----------------------------------------------------------------------------
+bool
+cdl_exec::cmd_version (const std::string cdl_version, const std::vector<std::string> cdl_packages)
+{
+bool status = false;
+try {
+init(true);
+for (unsigned int n = 0; n < cdl_packages.size (); n++) {
+config->change_package_version(resolve_package_alias (cdl_packages [n]), cdl_version,
+&diagnostic_handler, &diagnostic_handler, true);
+}
+if (!no_resolve) {
+CdlTransactionBody::set_callback_fn(&transaction_callback);
+config->resolve_all_conflicts();
+}
+report_conflicts();
+config->save (savefile);
+if (ignore_errors || (0 == config->get_all_conflicts().size())) {
+status = true;
+}
+} catch (CdlStringException exception) {
+exception_handler (exception);
+} catch (...) {
+exception_handler ();
+}
+delete_cdl_data ();
+return status;
+}
+// ----------------------------------------------------------------------------
+bool
+cdl_exec::cmd_tree ()
+{
+bool status = false;
+try {
+init(true);
+if (!no_resolve) {
+CdlTransactionBody::set_callback_fn(&transaction_callback);
+config->resolve_all_conflicts();
+}
+report_conflicts();
+config->save (savefile);
+// A build tree should only be generated if there are no conflicts.
+if (ignore_errors || (0 == config->get_all_conflicts().size())) {
 #ifdef _MSC_VER
-		char cwd [_MAX_PATH + 1];
+char cwd [_MAX_PATH + 1];
 #else
-		char cwd [PATH_MAX + 1];
+char cwd [PATH_MAX + 1];
 #endif
-		getcwd (cwd, sizeof cwd);
+getcwd (cwd, sizeof cwd);
 #ifdef __CYGWIN__
-		char cwd_win32 [MAXPATHLEN + 1];
+char cwd_win32 [MAXPATHLEN + 1];
-		cygwin_conv_to_win32_path (cwd, cwd_win32);
+cygwin_conv_to_win32_path (cwd, cwd_win32);
-		generate_build_tree (config, cwd_win32, install_prefix);
+generate_build_tree (config, cwd_win32, install_prefix);
 #else
-		generate_build_tree (config, cwd, install_prefix);
+generate_build_tree (config, cwd, install_prefix);
 #endif
-		config->generate_config_headers (install_prefix.empty () ? "install/include/pkgconf" : install_prefix + "/include/pkgconf");
+config->generate_config_headers (install_prefix.empty () ? "install/include/pkgconf" : install_prefix + "/include/pkgconf");
-		status = true;
+status = true;
-	} catch (CdlStringException exception) {
+} else {
-		exception_handler (exception);
+printf("\nUnable to generate build tree, this configuration still contains conflicts.\n");
-	} catch (...) {
+printf("Either resolve the conflicts or use --ignore-errors\n");
-		exception_handler ();
+}
-	}
+} catch (CdlStringException exception) {
+exception_handler (exception);
-	delete_cdl_data ();
+} catch (...) {
-	return status;
+exception_handler ();
 }
-bool cdl_exec::cmd_list () {
+delete_cdl_data ();
-	bool status = false;
+return status;
-	try {
+}
-		pkgdata = CdlPackagesDatabaseBody::make (repository, &diagnostic_handler, &diagnostic_handler);
+// ----------------------------------------------------------------------------
-		// list the installed packages
+bool
-		std::vector<std::string> packages = pkgdata->get_packages ();
+cdl_exec::cmd_list ()
-		std::sort (packages.begin (), packages.end ());
+{
-		for (unsigned int package = 0; package < packages.size (); package++) {
+bool status = false;
-			const std::vector<std::string> & aliases = pkgdata->get_package_aliases (packages [package]);
+try {
-			printf ("Package %s (%s):\n aliases:", packages [package].c_str (), aliases [0].c_str ());
+init(false);
-			for (unsigned int alias = 1; alias < aliases.size (); alias++) {
-				printf (" %s", aliases [alias].c_str ());
+// list the installed packages
-			}
+std::vector<std::string> packages = pkgdata->get_packages ();
-			const std::vector<std::string> & versions = pkgdata->get_package_versions (packages [package]);
+std::sort (packages.begin (), packages.end ());
-			printf ("\n versions:");
+for (unsigned int package = 0; package < packages.size (); package++) {
-			for (unsigned int version = 0; version < versions.size (); version++) {
+const std::vector<std::string> & aliases = pkgdata->get_package_aliases (packages [package]);
-				printf (" %s", versions [version].c_str ());
+printf ("Package %s (%s):\n aliases:", packages [package].c_str (), aliases [0].c_str ());
-			}
+for (unsigned int alias = 1; alias < aliases.size (); alias++) {
-			printf ("\n");
+printf (" %s", aliases [alias].c_str ());
-		}
+}
+const std::vector<std::string> & versions = pkgdata->get_package_versions (packages [package]);
-		// list the available targets
+printf ("\n versions:");
-		std::vector<std::string> targets = pkgdata->get_targets ();
+for (unsigned int version = 0; version < versions.size (); version++) {
-		std::sort (targets.begin (), targets.end ());
+printf (" %s", versions [version].c_str ());
-		for (unsigned int target = 0; target < targets.size (); target++) {
+}
-			const std::vector<std::string> & aliases = pkgdata->get_target_aliases (targets [target]);
+printf ("\n");
-			printf ("Target %s (%s):\n aliases:", targets [target].c_str (), aliases [0].c_str ());
+}
-			for (unsigned int alias = 1; alias < aliases.size (); alias++) {
-				printf (" %s", aliases [alias].c_str ());
+// list the available targets
-			}
+std::vector<std::string> targets = pkgdata->get_targets ();
-			printf ("\n");
+std::sort (targets.begin (), targets.end ());
-		}
+for (unsigned int target = 0; target < targets.size (); target++) {
+const std::vector<std::string> & aliases = pkgdata->get_target_aliases (targets [target]);
-		// list the available templates
+printf ("Target %s (%s):\n aliases:", targets [target].c_str (), aliases [0].c_str ());
-		std::vector<std::string> templates = pkgdata->get_templates ();
+for (unsigned int alias = 1; alias < aliases.size (); alias++) {
-		std::sort (templates.begin (), templates.end ());
+printf (" %s", aliases [alias].c_str ());
-		for (unsigned int templ = 0; templ < templates.size (); templ++) {
+}
-			const std::vector<std::string> & versions = pkgdata->get_template_versions (templates [templ]);
+printf ("\n");
-			printf ("Template %s:\n versions:", templates [templ].c_str ());
+}
-			for (unsigned int version = 0; version < versions.size (); version++) {
-				printf (" %s", versions [version].c_str ());
+// list the available templates
-			}
+std::vector<std::string> templates = pkgdata->get_templates ();
-			printf ("\n");
+std::sort (templates.begin (), templates.end ());
-		}
+for (unsigned int templ = 0; templ < templates.size (); templ++) {
+const std::vector<std::string> & versions = pkgdata->get_template_versions (templates [templ]);
-		status = true;
+printf ("Template %s:\n versions:", templates [templ].c_str ());
-	} catch (CdlStringException exception) {
+for (unsigned int version = 0; version < versions.size (); version++) {
-		exception_handler (exception);
+printf (" %s", versions [version].c_str ());
-	} catch (...) {
+}
-		exception_handler ();
+printf ("\n");
-	}
+}
-	delete_cdl_data ();
+status = true;
-	return status;
+} catch (CdlStringException exception) {
-}
+exception_handler (exception);
+} catch (...) {
-bool cdl_exec::cmd_check () {
+exception_handler ();
-	bool status = false;
+}
-	unsigned int n;
+delete_cdl_data ();
-	try {
+return status;
-		CdlTransactionBody::disable_automatic_inference ();
+}
-		pkgdata = CdlPackagesDatabaseBody::make (repository, &diagnostic_handler, &diagnostic_handler);
-		interp = CdlInterpreterBody::make ();
+// ----------------------------------------------------------------------------
-		config = CdlConfigurationBody::load (savefile, pkgdata, interp, &diagnostic_handler, &diagnostic_handler);
+bool
-		config->save (savefile); // tidy up any manual edits
+cdl_exec::cmd_check ()
+{
-		// report current target and template
+bool status = false;
-		printf ("Target: %s\n", config->get_hardware ().c_str ());
+unsigned int n;
-		printf ("Template: %s\n", config->get_template ().c_str ());
-		std::vector<std::string> template_packages = pkgdata->get_template_packages (config->get_template ());
+try {
-		const std::vector<std::string> & hardware_packages = pkgdata->get_target_packages (config->get_hardware ());
+init(true);
-		for (n = 0; n < hardware_packages.size (); n++) {
+// check() should never invoke the inference engine. The user
-			template_packages.push_back (hardware_packages [n]);
+// wants to determine the current status, which should not
-		}
+// change.
+// However, updating the savefile is worthwhile because it
-		// report loaded packages not in the templates
+// will now contain more accurate information about the state.
-		const std::vector<CdlLoadable> & loadables = config->get_loadables ();
+config->save (savefile);
-		std::vector<std::string> added_packages;
-		std::vector<CdlLoadable>::const_iterator loadable_i;
+// report current target and template
-		for (loadable_i = loadables.begin (); loadable_i != loadables.end (); loadable_i++) {
+printf ("Target: %s\n", config->get_hardware ().c_str ());
-			const CdlNode & node = dynamic_cast<CdlNode> (* loadable_i);
+printf ("Template: %s\n", config->get_template ().c_str ());
-			if (template_packages.end () == std::find (template_packages.begin (), template_packages.end (), node->get_name ())) {
+std::vector<std::string> template_packages = pkgdata->get_template_packages (config->get_template ());
-				added_packages.push_back (node->get_name ());
+const std::vector<std::string> & hardware_packages = pkgdata->get_target_packages (config->get_hardware ());
-			}
+for (n = 0; n < hardware_packages.size (); n++) {
-		}
+template_packages.push_back (hardware_packages [n]);
-		if (added_packages.size ()) {
+}
-			printf ("Added:\n");
-		}
+// report loaded packages not in the templates
-		for (n = 0; n < added_packages.size (); n++) {
+const std::vector<CdlLoadable> & loadables = config->get_loadables ();
-			printf (" %s\n", added_packages [n].c_str ());
+std::vector<std::string> added_packages;
-		}
+std::vector<CdlLoadable>::const_iterator loadable_i;
+for (loadable_i = loadables.begin (); loadable_i != loadables.end (); loadable_i++) {
-		// report template packages not in the configuration
+const CdlNode & node = dynamic_cast<CdlNode> (* loadable_i);
-		std::vector<std::string> removed_packages;
+if (template_packages.end () == std::find (template_packages.begin (), template_packages.end (), node->get_name ())) {
-		for (n = 0; n < template_packages.size (); n++) {
+added_packages.push_back (node->get_name ());
-			if (! config->lookup (template_packages [n])) {
+}
-				removed_packages.push_back (template_packages [n]);
+}
-			}
+if (added_packages.size ()) {
-		}
+printf ("Added:\n");
-		if (removed_packages.size ()) {
+}
-			printf ("Removed:\n");
+for (n = 0; n < added_packages.size (); n++) {
-		}
+printf (" %s\n", added_packages [n].c_str ());
-		for (n = 0; n < removed_packages.size (); n++) {
+}
-			printf (" %s\n", removed_packages [n].c_str ());
-		}
+// report template packages not in the configuration
+std::vector<std::string> removed_packages;
-		// report packages of non-default version
+for (n = 0; n < template_packages.size (); n++) {
-		std::vector<CdlValuable> version_packages;
+if (! config->lookup (template_packages [n])) {
-		for (loadable_i = loadables.begin (); loadable_i != loadables.end (); loadable_i++) {
+removed_packages.push_back (template_packages [n]);
-			const CdlValuable & valuable = dynamic_cast<CdlValuable> (* loadable_i);
+}
-			if (pkgdata->get_package_versions (valuable->get_name ()) [0] != valuable->get_value ()) {
+}
-				version_packages.push_back (valuable);
+if (removed_packages.size ()) {
-			}
+printf ("Removed:\n");
-		}
+}
-		if (version_packages.size ()) {
+for (n = 0; n < removed_packages.size (); n++) {
-			printf ("Version(s):\n");
+printf (" %s\n", removed_packages [n].c_str ());
-		}
+}
-		for (n = 0; n < version_packages.size (); n++) {
-			printf (" %s %s\n", version_packages [n]->get_name ().c_str (), version_packages [n]->get_value ().c_str ());
+// report packages of non-default version
-		}
+std::vector<CdlValuable> version_packages;
+for (loadable_i = loadables.begin (); loadable_i != loadables.end (); loadable_i++) {
-		// report conflicts
+const CdlValuable & valuable = dynamic_cast<CdlValuable> (* loadable_i);
-		const std::list<CdlConflict> & conflicts = config->get_all_conflicts ();
+if (pkgdata->get_package_versions (valuable->get_name ()) [0] != valuable->get_value ()) {
-		if (conflicts.size ()) {
+version_packages.push_back (valuable);
-			printf ("%u conflict(s):\n", conflicts.size ());
+}
-		} else {
+}
-			printf ("No conflicts\n");
+if (version_packages.size ()) {
-		}
+printf ("Version(s):\n");
-		std::list<CdlConflict>::const_iterator conf_i;
+}
-		for (conf_i = conflicts.begin (); conf_i != conflicts.end (); conf_i++) { // for each conflict
+for (n = 0; n < version_packages.size (); n++) {
-			report_conflict (* conf_i);
+printf (" %s %s\n", version_packages [n]->get_name ().c_str (), version_packages [n]->get_value ().c_str ());
-		}
+}
-		status = true;
+// report conflicts
-	} catch (CdlStringException exception) {
+const std::list<CdlConflict> & conflicts = config->get_all_conflicts ();
-		exception_handler (exception);
+if (conflicts.size ()) {
-	} catch (...) {
+printf ("%u conflict(s):\n", conflicts.size ());
-		exception_handler ();
+} else {
-	}
+printf ("No conflicts\n");
+}
-	delete_cdl_data ();
+report_conflicts();
-	return status;
-}
+status = true;
+} catch (CdlStringException exception) {
-bool cdl_exec::cmd_resolve () {
+exception_handler (exception);
-	bool status = false;
+} catch (...) {
+exception_handler ();
-	try {
+}
-		pkgdata = CdlPackagesDatabaseBody::make (repository, &diagnostic_handler, &diagnostic_handler);
-		interp = CdlInterpreterBody::make ();
+delete_cdl_data ();
-		config = CdlConfigurationBody::load (savefile, pkgdata, interp, &diagnostic_handler, &diagnostic_handler);
+return status;
-		config->resolve_all_conflicts ();
+}
-		config->save (savefile);
-		status = true;
+// ----------------------------------------------------------------------------
-	} catch (CdlStringException exception) {
+bool
-		exception_handler (exception);
+cdl_exec::cmd_resolve ()
-	} catch (...) {
+{
-		exception_handler ();
+bool status = false;
-	}
+try {
-	delete_cdl_data ();
+init(true);
-	return status;
+CdlTransactionBody::set_callback_fn(&transaction_callback);
-}
+config->resolve_all_conflicts ();
+report_conflicts();
-CdlInferenceCallbackResult cdl_exec::inference_callback (CdlTransaction transaction) {
+config->save (savefile);
-	const std::vector<CdlConflict> & resolved_conflicts = transaction->get_resolved_conflicts ();
+if (ignore_errors || (0 == config->get_all_conflicts().size())) {
+status = true;
-	// report resolved conflicts
+}
-	if (resolved_conflicts.size ()) {
+} catch (CdlStringException exception) {
-		printf ("%u conflict(s) resolved:\n", resolved_conflicts.size ());
+exception_handler (exception);
-	}
+} catch (...) {
-	for (unsigned int n = 0; n < resolved_conflicts.size (); n++) {
+exception_handler ();
-		report_conflict (resolved_conflicts [n]);
+}
-	}
+delete_cdl_data ();
-	// accept all changes
+return status;
-	return CdlInferenceCallbackResult_Continue;
+}
-}
+// ----------------------------------------------------------------------------
-void cdl_exec::report_conflict (CdlConflict conflict) {
+// The inference callback. This could give some useful diagnostics, or it
-	printf (" %s:\n  %s\n", conflict->get_node ()->get_name ().c_str (), conflict->get_explanation ().c_str ());
+// could do useful things when running in some interactive mode. In batch
-}
+// mode it should not do anything.
-void cdl_exec::diagnostic_handler (std::string message) {
+CdlInferenceCallbackResult
-	printf ("%s\n", message.c_str ());
+cdl_exec::inference_callback (CdlTransaction transaction)
+{
+return CdlInferenceCallbackResult_Continue;
+}
+// ----------------------------------------------------------------------------
+// Output a message with indentation after newlines.
+static void
+dump_string(unsigned int indent, const std::string& str)
+{
+bool newline_pending = false;
+unsigned int i, j;
+for (i = 0; i < str.size(); i++) {
+if (newline_pending) {
+putchar('\n');
+if ('\n' != str[i]) {
+for (j = 0; j < indent; j++) {
+putchar(' ');
+}
+}
+newline_pending = false;
+}
+if ('\n' == str[i]) {
+newline_pending = true;
+} else {
+putchar(str[i]);
+}
+}
+if (newline_pending) {
+putchar('\n');  // But not the indentation.
+}
+}
+// ----------------------------------------------------------------------------
+// The transaction callback. This should report any changes that have been
+// made to the configuration. The amount of output depends on the verbosity
+// level selected by the user.
+//
+// 1) quiet     - no output at all
+// 2) default   - list updates done by the inference engine.
+// 3) verbose   - this does not currently add anything.
+//
+// There is no reporting of new or resolved conflicts. Resolved
+// conflicts are probably of no interest in batch mode. New conflicts
+// will be handled by report_conflicts(). There is also no information
+// given about active state changes, although arguably there should be
+// especially in the case of containers.
+void
+cdl_exec::transaction_callback(const CdlTransactionCallback& callback_data)
+{
+if (quiet) {
+return;
+}
+unsigned int i;
+for (i = 0; i < callback_data.value_changes.size(); i++) {
+CdlValuable valuable = callback_data.value_changes[i];
+if (CdlValueSource_Inferred == valuable->get_source()) {
+std::string msg = std::string("U ") + valuable->get_name() + ", new inferred value ";
+std::string value = valuable->get_value();
+if ("" == value) {
+msg += "\"\"";
+} else {
+msg += value;
+}
+msg += "\n";
+dump_string(4, msg);
+}
+}
+}
+// ----------------------------------------------------------------------------
+// Report the remaining conflicts in the configuration. These indicate
+// problems that the user should fix before going further with the
+// configuration, e.g. before generating a build tree.
+//
+// Quiet verbosity level has no effect on this, but at the verbose level
+// it is a good idea to look for a possible solution to the conflict.
+void
+cdl_exec::report_conflicts()
+{
+const std::list<CdlConflict>& all_conflicts = config->get_all_conflicts();
+std::list<CdlConflict>::const_iterator conf_i;
+for (conf_i = all_conflicts.begin(); conf_i != all_conflicts.end(); conf_i++) {
+CdlNode     node = (*conf_i)->get_node();
+std::string msg = std::string("C ") + node->get_name() + ", " + (*conf_i)->get_explanation() + "\n";
+dump_string(2, msg);
+if (verbose && (*conf_i)->resolution_implemented()) {
+// See if there is a possible solution to this conflict.
+// This involves creating a transaction, invoking the
+// inference engine, and cancelling the transaction
+// (thus making sure that nothing actually changes).
+//
+// NOTE: at some stage libcdl may keep track of solutions
+// globally. However, although it will know when a solution
+// becomes invalid it will not necessarily try to resolve
+// all global conflicts after every change, so attempting
+// to do this in a transaction may still be necessary.
+CdlTransaction transact = CdlTransactionBody::make(config);
+transact->resolve(*conf_i);
+if ((*conf_i)->has_known_solution()) {
+std::string soln_msg = "  Possible solution:\n";
+const std::vector<std::pair<CdlValuable, CdlValue> > & soln = (*conf_i)->get_solution();
+unsigned int i;
+for (i = 0; i < soln.size(); i++) {
+soln_msg += soln[i].first->get_name() + " -> " + soln[i].second.get_value() + "\n";
+}
+#if 0
+// FIXME: currently this member only works for nested sub-transactions.
+if (transact->user_confirmation_required()) {
+msg += "This change affects previous user settings.\n";
+}
+#endif
+dump_string(4, soln_msg);
+}
+transact->cancel();
+delete transact;
+}
+}
+}
+// ----------------------------------------------------------------------------
+void
+cdl_exec::diagnostic_handler (std::string message)
+{
+printf ("%s\n", message.c_str ());
 }
 void cdl_exec::exception_handler (CdlStringException exception) {
-	printf ("%s\n", exception.get_message ().c_str ());
+printf ("%s\n", exception.get_message ().c_str ());
 }
-void cdl_exec::exception_handler () {
+void
-	printf ("Unknown error\n");
+cdl_exec::exception_handler ()
-}
+{
+printf ("Unknown error\n");
-void cdl_exec::delete_cdl_data () {
+}
-	delete config;
-	config = NULL;
-	delete interp;
+// ----------------------------------------------------------------------------
-	interp = NULL;
+std::string
-	delete pkgdata;
+cdl_exec::resolve_package_alias (const std::string alias)
-	pkgdata = NULL;
+{
-}
+std::string package = alias;
-std::string cdl_exec::resolve_package_alias (const std::string alias) {
+if (! pkgdata->is_known_package (alias)) { // if the alias is not a package name
-	std::string package = alias;
+const std::vector<std::string> & packages = pkgdata->get_packages (); // get packages
+for (unsigned int n = 0; n < packages.size (); n++) { // for each package
-	if (! pkgdata->is_known_package (alias)) { // if the alias is not a package name
+const std::vector<std::string> & aliases = pkgdata->get_package_aliases (packages [n]); // get package aliases
-		const std::vector<std::string> & packages = pkgdata->get_packages (); // get packages
+if (aliases.end () != std::find (aliases.begin (), aliases.end (), alias)) { // if alias is found
-		for (unsigned int n = 0; n < packages.size (); n++) { // for each package
+package = packages [n]; // note the package
-			const std::vector<std::string> & aliases = pkgdata->get_package_aliases (packages [n]); // get package aliases
+break;
-			if (aliases.end () != std::find (aliases.begin (), aliases.end (), alias)) { // if alias is found
+}
-				package = packages [n]; // note the package
+}
-				break;
+}
-			}
+return package;
-		}
+}
-	}
-	return package;
+std::string
-}
+cdl_exec::resolve_hardware_alias (const std::string alias)
+{
-std::string cdl_exec::resolve_hardware_alias (const std::string alias) {
+std::string target = alias;
-	std::string target = alias;
+if (! pkgdata->is_known_target (alias)) { // if the alias is not a target name
-	if (! pkgdata->is_known_target (alias)) { // if the alias is not a target name
+const std::vector<std::string> & targets = pkgdata->get_targets (); // get targets
-		const std::vector<std::string> & targets = pkgdata->get_targets (); // get targets
+for (unsigned int n = 0; n < targets.size (); n++) { // for each target
-		for (unsigned int n = 0; n < targets.size (); n++) { // for each target
+const std::vector<std::string> & aliases = pkgdata->get_target_aliases (targets [n]); // get target aliases
-			const std::vector<std::string> & aliases = pkgdata->get_target_aliases (targets [n]); // get target aliases
+if (aliases.end () != std::find (aliases.begin (), aliases.end (), alias)) { // if alias is found
-			if (aliases.end () != std::find (aliases.begin (), aliases.end (), alias)) { // if alias is found
+target = targets [n]; // note the target
-				target = targets [n]; // note the target
+break;
-				break;
+}
-			}
+}
-		}
+}
-	}
+return target;
-	return target;
+}
-}

Mercurial > flash_v2

comparison host/tools/configtool/standalone/common/cdl_exec.cxx @ 105:5a0cc6c243a9 ecos-sw-2000-06-30