Example #1
0
	def register_classes(args):
		logging.info("--------Registering Host Platforms--------")
		Core.host_classes = Factory.register_subclasses(HostPlatform, os.path.join(Core.install_path, HOST_PLATFORMS_CLASSPATH))
		logging.info("-> Registered %i platform(s)---------" % len(Core.host_classes))


		# pick the hostplatform that matches this machine
		HostPlatform.create_platform(Core.host_classes)

		logging.info("--------Registering Target Platforms--------")
		Core.target_classes = Factory.register_subclasses(TargetPlatform, os.path.join(Core.install_path, TARGET_PLATFORMS_CLASSPATH))
		logging.info("-> Registered %i platform(s)---------" % len(Core.target_classes))

		logging.info("--------Registering Compilers--------")
		Core.compiler_classes = Factory.register_subclasses(Compiler, os.path.join(Core.install_path, COMPILERS_CLASSPATH))
		logging.info("-> Registered %i driver(s)---------" % len(Core.compiler_classes))

		# instance the target platform
		TargetPlatform.create(args, Core.target_classes, Core.compiler_classes, HostPlatform.instance)


		logging.info("--------Registering Drivers--------")
		Core.driver_classes = Factory.register_subclasses(Driver, os.path.join(Core.install_path, DRIVERS_CLASSPATH))
		logging.info("-> Registered %i driver(s)---------" % len(Core.driver_classes))

		# pick which driver to use
		Driver.create_driver_for_platform(args, TargetPlatform.instance, Core.driver_classes)

		# after classes have been registered and the TargetPlatform, Driver are instanced
		# load the Attributes config
		Attributes.load_schema(Core.config, TargetPlatform.instance)

		if Core.config.has_key("driver_data"):
			Driver.instance.post_load_driver_schema(Core.config["driver_data"])

		logging.info("--------Registering Serializable classes--------")
		for subclass in Serializable.__subclasses__():
			Serializable.register_class(subclass)


		Core.supported_architectures = []
		for architecture in Architecture.enum_keys:
			if TargetPlatform.compiler.supports_build_architecture(Language.CPP, architecture):
				Core.supported_architectures.append(architecture)
			else:
				logging.info('Does not support arch: {}'.format(architecture))
Example #2
0
def main():
	Core.startup()


	Environment.instance = Environment()

	FileManager.instance = FileManager()

	# load the file and any options it may contain

	if len(sys.argv) < 2:
		raise Exception("No build file specified.")


	if len(sys.argv) > 1 and os.path.exists(sys.argv[1]):
		buildfile = BuildFile(sys.argv[1])
	else:
		raise Exception("Build file: \"%s\" does not exist!" % sys.argv[1])

	p = argparse.ArgumentParser(prog="pegasus")

	p.add_argument(
		"-q",
		dest="quiet",
		help="Log to a file, don't output to stdout",
		action="store_true",
		default=False
	)

	# position arguments
	p.add_argument("build_file", help="Target build file")

	# setup commands
	p_cmd = p.add_subparsers(
		dest="command",
		title="Commands",
		description="Available Commands"
	)

	p_list = p_cmd.add_parser(
		"list",
		help="List all products in the build file"
	)
	p_list.set_defaults(target_platform=None, command_callback=handle_list)

	p_generate = p_cmd.add_parser(
		"generate",
		help="Generate projects for product(s)"
	)
	p_generate.set_defaults(
		command_callback=handle_action,
		use_cache=False,
		action_name="generate"
	)
	add_common_options(buildfile, p_generate)

	p_build = p_cmd.add_parser("build", help="Build the project")
	p_build.set_defaults(
		command_callback=handle_action,
		use_cache=True,
		action_name="build"
	)
	add_common_options(buildfile, p_build)

	p_clean = p_cmd.add_parser("clean", help="Clean the project")
	p_clean.set_defaults(
		command_callback=handle_action,
		use_cache=True,
		action_name="clean"
	)
	add_common_options(buildfile, p_clean)

	p_distclean = p_cmd.add_parser(
		"distclean",
		help="Purge directories of generated files"
	)
	p_distclean.set_defaults(
		command_callback=handle_action,
		use_cache=True,
		action_name="distclean"
	)
	add_common_options(buildfile, p_distclean)

	args = p.parse_args()

	# setup environment
	Environment.get().use_cache = \
		args.use_cache if hasattr(args, "use_cache") else False

	# register classes (HostPlatforms, Drivers)
	Core.register_classes(args)

	logging.info("HostPlatform is %s" % HostPlatform.get())
	logging.info("TargetPlatform is %s" % TargetPlatform.get())
	logging.info("Compiler is %s, version: %s" % (
		TargetPlatform.get_compiler_name(),
		TargetPlatform.compiler.get_version())
	)


	# run command
	args.command_callback(args)

	if not Environment.get().use_cache:
		BuildCache.save_caches()
Example #3
0
def handle_list(args):
	logging.info(
		"System info for %s, %s" % (pegasus.__name__, pegasus.__version__)
	)
	logging.info("")

	logging.info("-- (%i) Architectures --" % (len(Architecture.enum_keys)))
	for key in Architecture.enum_keys:
		logging.info("\t%s" % key)
	logging.info("")

	logging.info("-- (%i) Languages --" % (len(Language.enum_keys)))
	for key in Language.enum_keys:
		logging.info("\t%s" % key)
	logging.info("")

	logging.info(
		"-- (%i) Host Platforms --" % (len(HostPlatform.__subclasses__()))
	)
	for d in HostPlatform.__subclasses__():
		logging.info("\t%s" % d.__name__)
	logging.info("")

	logging.info(
		"-- (%i) Target Platforms --" % (len(TargetPlatform.__subclasses__()))
	)
	for d in TargetPlatform.__subclasses__():
		logging.info("\t%s" % d.__name__)
	logging.info("")

	logging.info("-- (%i) Compilers --" % (len(Compiler.__subclasses__())))
	for d in Compiler.__subclasses__():
		logging.info("\t%s" % d.__name__)
	logging.info("")

	logging.info("-- (%i) Drivers --" % (len(Core.driver_classes)))
	for d in Core.driver_classes:
		logging.info("\t%s" % d.__name__)
	logging.info("")

	buildfile = BuildFile(args.build_file)

	# need to mockup a parser here:
	parser = argparse.ArgumentParser()
	buildfile.execute("arguments", parser)
	args = parser.parse_args("")

	global_params = Attributes()

	products = buildfile.get_products(
		args=args,
		host_platform=HostPlatform,
		target_platform=TargetPlatform.instance,
		global_params=global_params
	)

	if not products or type(products[0]) is not Product:
		raise Exception(
			"BuildFile returned an invalid value for products()!"
		)

	logging.info(
		"Listing products for build file '%s' and platform '%s'" % \
			(buildfile.abs_buildfile_path, HostPlatform.get())
	)
	logging.info("")

	logging.info("-- (%i) Products --" % len(products))
	for p in products:
		logging.info("\t\"%s\": %s" % (p.name, p.output))