#

# Copyright (c) 2006-2010 Nokia Corporation and/or its subsidiary(-ies).

# All rights reserved.

# This component and the accompanying materials are made available

# under the terms of the License "Eclipse Public License v1.0"

# which accompanies this distribution, and is available

# at the URL "http://www.eclipse.org/legal/epl-v10.html".

#

# Initial Contributors:

# Nokia Corporation - initial contribution.

#

# Contributors:

#

# Description:

# raptor module

# This module represents the running Raptor program. Raptor is started

# either by calling the Main() function, which creates an instance of

# the raptor.Raptor class and calls its methods to perform a build based

# on command-line parameters, or by explicitly creating a raptor.Raptor

# instance and calling its methods to set-up and perform a build.

#

name = "sbs"			# the public name for the raptor build tool

env  = "SBS_HOME"		# the environment variable that locates us

xml  = "sbs_init.xml"	# the primary initialisation file

env2 = "HOME"		 	# the environment variable that locates the user

xml2 = ".sbs_init.xml"	# the override initialisation file

import generic_path

import os

import raptor_cache

import raptor_cli

import raptor_data

import raptor_make

import raptor_makefile

import raptor_meta

import raptor_timing

import raptor_utilities

import raptor_version

import raptor_xml

import filter_list

import sys

import types

import time

import traceback

import pluginbox

from xml.sax.saxutils import escape

if not "HOSTPLATFORM" in os.environ or not "HOSTPLATFORM_DIR" in os.environ:

	print "Error: HOSTPLATFORM and HOSTPLATFORM_DIR must be set in the environment (this is usually done automatically by the startup script)."

	sys.exit(1)

hostplatform = os.environ["HOSTPLATFORM"].split(" ")

hostplatform_dir = os.environ["HOSTPLATFORM_DIR"]

# defaults can use EPOCROOT

if "EPOCROOT" in os.environ:

	incoming_epocroot = os.environ["EPOCROOT"]

	epocroot = incoming_epocroot.replace("\\","/")

else:

	if 'win' in hostplatform:

		incoming_epocroot = os.sep

		epocroot = "/"

		os.environ["EPOCROOT"] = os.sep

	else:

		epocroot=os.environ['HOME'] + os.sep + "epocroot"

		os.environ["EPOCROOT"] = epocroot

		incoming_epocroot = epocroot

if "SBS_BUILD_DIR" in os.environ:

	sbs_build_dir = os.environ["SBS_BUILD_DIR"]

else:

	sbs_build_dir = (epocroot + "/epoc32/build").replace("//","/")

# only use default XML from the epoc32 tree if it exists

defaultSystemConfig = "lib/config"

epoc32UserConfigDir = generic_path.Join(epocroot, "epoc32/sbs_config")

if epoc32UserConfigDir.isDir():

	defaultSystemConfig = str(epoc32UserConfigDir) + os.pathsep + defaultSystemConfig

# parameters that can be overriden by the sbs_init.xml file

# or by the command-line.

defaults = {

		"allowCommandLineOverrides" : True,

		"CLI" : "raptor_cli",

		"buildInformation" : generic_path.Path("bld.inf"),

		"defaultConfig" : "default",

		"jobs": 4,

		"keepGoing": False,

		"logFileName" : generic_path.Join(sbs_build_dir,"Makefile.%TIME.log"),

		"makeEngine" : "make",

		"preferBuildInfoToSystemDefinition" : False,

		"pruneDuplicateMakefiles": True,

		"quiet" : False,

		"systemConfig" :  defaultSystemConfig,

		"systemDefinition" : generic_path.Path("System_Definition.xml"),

		"systemDefinitionBase" : generic_path.Path("."),

		"systemFLM" : generic_path.Path("lib/flm"),

		"systemPlugins" : generic_path.Path("python/plugins"),

		"topMakefile" : generic_path.Join(sbs_build_dir,"Makefile"),

		"tries": 1,

		"writeSingleMakefile": True,

		"ignoreOsDetection": False,

		"toolcheck": "on",

		"filterList": "filterterminal,filterlogfile"

		}

class ModelNode(object):

	""" Represents any node in a a tree of build information

	    e.g. a tree of bld.infs, mmps and finally things like resource blocks and string table blocks.

	    This is before they are produced into "build" specs.

	"""

	def __init__(self, id, parent = None):

		self.id = id

		self.type = type

		self.specs = []

		self.deps = []

		self.children = set()

		self.unfurled = False

		self.parent = parent

	# Allow one to make a set

	def __hash__(self):

		return hash(self.id)

	def __cmp__(self,other):

		return cmp(self.id, other)

	def __iter__(self):

		return iter(self.children)

	def __getitem__(self,x):

		if isinstance(x, slice):

			return self.children[x.start:x.stop]

		return self.children[x]

	def __setitem__(self,k, v):

		self.children[k] = v

	def __len__(self):

		return len(self.children)

	def add(self, item):

		return self.children.add(item)

	def isunfurled(self, c):

		return self.unfurled == False

	def unfurl(self, build):

		"""Find any children of this node by processing it, produces specs"""

		pass

	def unfurl_all(self, build):

		"""Unfurl self and all children - preparatory e.g for realisation"""

		if not self.unfurled:

			self.unfurl(build)

		self.realise_exports(build) # permit communication of dependencies between children

		for c in self.children:

			c.unfurl_all(build)

	def realise_exports(self, build):

		"""Do the things that are needed such that we can fully unfurl all

		   sibling nodes.  i.e. this step is here to "take care" of the dependencies

		   between siblings.

		"""

		pass

	def realise_makefile(self, build, specs):

		makefilename_base = build.topMakefile

		if self.name is not None:

			makefile = generic_path.Path(str(makefilename_base) + "_" + raptor_utilities.sanitise(self.name))

		else:

			makefile = generic_path.Path(str(makefilename_base))

		# insert the start time into the Makefile name?

		makefile.path = makefile.path.replace("%TIME", build.timestring)

		build.InfoDiscovery(object_type = "layers", count = 1)

		build.InfoStartTime(object_type = "layer", task = "parse",

				key = str(makefile.path))

		makefileset = build.maker.Write(makefile, specs, build.buildUnitsToBuild)

		build.InfoEndTime(object_type = "layer", task = "parse",

				key = str(makefile.path))

		return makefileset

	def realise(self, build):

		"""Give the spec trees to the make engine and actually

		"build" the product represented by this model node"""

		# Must ensure that all children are unfurled at this point

		self.unfurl_all(build)

		sp = self.specs

		build.AssertBuildOK()

		m = self.realise_makefile(build, sp)

		build.InfoStartTime(object_type = "layer", task = "build",

				key = (str(m.directory) + "/" + str(m.filenamebase)))

		result = build.Make(m)

		build.InfoEndTime(object_type = "layer", task = "build",

				key = (str(m.directory) + "/" + str(m.filenamebase)))

		return result

class Project(ModelNode):

	"""A project or, in symbian-speak, an MMP

	"""

	def __init__(self, filename, parent = None):

		super(Project,self).__init__(filename, parent = parent)

		# Assume that components are specified in mmp files for now

		# One day that tyranny might end.

		self.mmp_name = str(generic_path.Path.Absolute(filename))

		self.id = self.mmp_name

		self.unfurled = False

	def makefile(self, makefilename_base, engine, named = False):

		"""Makefiles for individual mmps not feasible at the moment"""

		pass 

		# Cannot, currently, "unfurl an mmp" directly but do want

		# to be able to simulate the overall recursive unfurling of a build.

class Component(ModelNode):

	"""A group of projects or, in symbian-speak, a bld.inf.

	"""

	def __init__(self, filename, layername="", componentname=""):

		super(Component,self).__init__(filename)

		# Assume that components are specified in bld.inf files for now

		# One day that tyranny might end.

		self.bldinf = None # Slot for a bldinf object if we spot one later

		self.bldinf_filename = generic_path.Path.Absolute(filename)

		self.id = str(self.bldinf_filename)

		self.exportspecs = []

		self.depfiles = []

		self.unfurled = False # We can parse this

		# Extra metadata optionally supplied with system definition file gathered components

		self.layername = layername

		self.componentname = componentname

	def AddMMP(self, filename):

		self.children.add(Project(filename))

class Layer(ModelNode):

	""" Some components that should be built togther

		e.g. a Layer in the system definition.

		Components that come from system definition files can

		have extra surrounding metadata that we need to pass

		on for use in log output.

	"""

	def __init__(self, name, componentlist=[]):

		super(Layer,self).__init__(name)

		self.name = name

		for c in componentlist:

			if isinstance(c, raptor_xml.SystemModelComponent):

				# this component came from a system_definition.xml

				self.children.add(Component(c, c.GetContainerName("layer"), c.GetContainerName("component")))

			else:

				# this is a plain old bld.inf file from the command-line

				self.children.add(Component(c))

	def unfurl(self, build):

		"""Discover the children of this layer. This involves parsing the component MetaData (bld.infs, mmps).

		Takes a raptor object as a parameter (build), together with a list of Configurations.

		We currently have parsers that work on collections of components/bld.infs and that cannot

		parse at a "finer" level.  So one can't 'unfurl' an mmp at the moment.

		Returns True if the object was successfully unfurled.

		"""

		# setup all our components

		for c in self.children:

			c.specs = []

		self.configs = build.buildUnitsToBuild

		metaReader = None

		if len (self.children):

			try:

				# create a MetaReader that is aware of the list of

				# configurations that we are trying to build.

				metaReader = raptor_meta.MetaReader(build, build.buildUnitsToBuild)

				# convert the list of bld.inf files into a specification

				# hierarchy suitable for all the configurations we are using.

				self.specs = list(build.generic_specs)

				self.specs.extend(metaReader.ReadBldInfFiles(self.children, doexport = build.doExport, dobuild = not build.doExportOnly))

			except raptor_meta.MetaDataError, e:

				build.Error(e.Text)

		self.unfurled = True

	def meta_realise(self, build):

		"""Generate specs that can be used to "take care of" finding out more

		about this metaunit - i.e. one doesn't want to parse it immediately

		but to create a makefile that will parse it.

		In this case it allows bld.infs to be parsed in parallel by make."""

		# insert the start time into the Makefile name?

		self.configs = build.buildUnitsToBuild

		# Pass certain CLI flags through to the makefile-generating sbs calls

		cli_options = ""

		if build.debugOutput == True:

			cli_options += " -d"

		if build.ignoreOsDetection == True:

			cli_options += " -i"

		if build.keepGoing == True:

			cli_options += " -k"

		if build.quiet == True:

			cli_options += " -q"

		if build.noDependInclude == True:

			cli_options += " --no-depend-include"

		if build.noDependGenerate == True:

			cli_options += " --no-depend-generate"

		nc = len(self.children)

		number_blocks = build.jobs

		block_size = (nc / number_blocks) + 1

		component_blocks = []

		spec_nodes = []

		b = 0

		childlist = list(self.children)

		while b < nc:

			component_blocks.append(childlist[b:b+block_size])

			b += block_size

		while len(component_blocks[-1]) <= 0:

			component_blocks.pop()

			number_blocks -= 1

		build.Info("Parallel Parsing: bld.infs split into %d blocks\n", number_blocks)

		# Cause the binding makefiles to have the toplevel makefile's

		# name.  The bindee's have __pp appended.

		tm = build.topMakefile.Absolute()

		binding_makefiles = raptor_makefile.MakefileSet(str(tm.Dir()), build.maker.selectors, makefiles=None, filenamebase=str(tm.File()))

		build.topMakefile = generic_path.Path(str(build.topMakefile) + "_pp")

		loop_number = 0

		for block in component_blocks:

			loop_number += 1

			specNode = raptor_data.Specification("metadata_" + self.name)

			componentList = " ".join([str(c.bldinf_filename) for c in block])

			configList = " ".join([c.name for c in self.configs if c.name != "build" ])

			makefile_path = str(build.topMakefile) + "_" + str(loop_number)

			try:

				os.unlink(makefile_path) # until we have dependencies working properly

			except Exception:

				pass

			# add some basic data in a component-wide variant

			var = raptor_data.Variant()

			var.AddOperation(raptor_data.Set("COMPONENT_PATHS", componentList))

			var.AddOperation(raptor_data.Set("MAKEFILE_PATH", makefile_path))

			var.AddOperation(raptor_data.Set("CONFIGS", configList))

			var.AddOperation(raptor_data.Set("CLI_OPTIONS", cli_options))

			# Allow the flm to skip exports. Note: this parameter

			doexport_str = '1'

			if not build.doExport:

				doexport_str = ''

			var.AddOperation(raptor_data.Set("DOEXPORT", doexport_str ))

			# Pass on '-n' (if specified) to the makefile-generating sbs calls

			if build.noBuild:

				var.AddOperation(raptor_data.Set("NO_BUILD", "1"))

			specNode.AddVariant(var)

			try:

				interface = build.cache.FindNamedInterface("build.makefiles")

				specNode.SetInterface(interface)

			except KeyError:

				build.Error("Can't find flm interface 'build.makefiles' ")

			spec_nodes.append(specNode)

			binding_makefiles.addInclude(str(makefile_path)+"_all")

		build.InfoDiscovery(object_type = "layers", count = 1)

		build.InfoStartTime(object_type = "layer", task = "parse",

				key = str(build.topMakefile))

		m = self.realise_makefile(build, spec_nodes)

		m.close()

		gen_result = build.Make(m)

		build.InfoEndTime(object_type = "layer", task = "parse",

				key = str(build.topMakefile))

		build.InfoStartTime(object_type = "layer", task = "build",

				key = str(build.topMakefile))

		build.Debug("Binding Makefile base name is %s ", binding_makefiles.filenamebase)

		binding_makefiles.close()

		b = build.Make(binding_makefiles)

		build.InfoEndTime(object_type = "layer", task = "build",

				key = str(build.topMakefile))

		return b

class BuildCannotProgressException(Exception):

	pass

# raptor module classes

class Raptor(object):

	"""An instance of a running Raptor program.

	When operated from the command-line there is a single Raptor object

	created by the Main function. When operated by an IDE several Raptor

	objects may be created and operated at the same time."""

	M_BUILD = 1

	def __init__(self, home = None):

		self.DefaultSetUp(home)

	def DefaultSetUp(self, home = None):

		"revert to the default set-up state"

		self.errorCode = 0

		self.skipAll = False

		self.summary = True

		self.out = sys.stdout # Just until filters get started.

		# Create a bootstrap output system.

		self.out = filter_list.FilterList()

		if home == None:

			try:

				home = os.environ[env]

			except KeyError:

				home = os.getcwd()

		# make sure the home directory exists

		self.home = generic_path.Path(home).Absolute()

		if not self.home.isDir():

			self.Error("%s '%s' is not a directory", env, self.home)

			return

		# the set-up file location.

		# use the override "env2/xml2" if it exists

		# else use the primary "env/xml" if it exists

		# else keep the hard-coded defaults.

		self.raptorXML = self.home.Append(xml)

		if env2 in os.environ:

			sbs_init = generic_path.Join(os.environ[env2], xml2)

			if sbs_init.isFile():

				self.raptorXML = sbs_init

		# things that can be overridden by the set-up file

		for key, value in defaults.items():

			self.__dict__[key] = value