#

# Copyright (c) 2006-2009 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_meta

import raptor_utilities

import raptor_version

import raptor_xml

import filter_list

import sys

import types

import time

import re

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:

	epocroot = os.environ["EPOCROOT"].replace("\\","/")

else:

	if 'linux' in hostplatform:

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

		os.environ["EPOCROOT"] = epocroot

	else:

		epocroot = "/"

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

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 ComponentGroup(object):

	""" 	Some components that should be built togther 

		e.g. a Layer in the system definition. 

	""" 

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

		self.components = componentlist

		self.name = name

	def __iter__(self):

		return iter(self.components)

	def __getitem__(self,x):

		if isinstance(x, slice):

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

		return self.components[x]

	def __setitem__(self,k, v):

		self.components[k] = v

	def __len__(self):

		return len(self.components)

	def extend(self, c):

		self.components.extend(c)

	def append(self, c):

		self.components.append(c)

	def GenerateSpecs(self, genericspecs, configs):

		"""Return a build spec hierarchy for a ComponentGroup. This involves parsing the component MetaData (bld.infs, mmps). 

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

		Returns a tuple consisting of a list of specification objects and a list of dependency files

		that relate to these specs.

		"""

		self.specs = []

		self.specs.extend(genericspecs)

		self.configs = configs

		self.dependencies = set()

		metaReader = None

		if len (self.components):

			try:

				# create a MetaReader that is aware of the list of

				# configurations that we are trying to build.

				metaReader = raptor_meta.MetaReader(build, configs)

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

				# hierarchy suitable for all the configurations we are using.

				self.specs.extend(metaReader.ReadBldInfFiles(self.components,build.doExportOnly))

			except raptor_meta.MetaDataError, e:

				log.Error(e.Text)

		log.Info("Buildable specification group '%s'", name)

		build.AttachSpecs(self.specs)

		# Get a unique list of the dependency files that were created

		if metaReader:

			for c in metaReader.BuildPlatforms:

				self.dependencies.update(c["METADEPS"])

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

		if len(self.specs) <= 0:

			return None

		if named:

			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)

		engine.Write(makefile, self.specs, self.configs)

		return makefile

	def GenerateMetadataSpecs(self, configs):

		# insert the start time into the Makefile name?

		self.configs = build.GetConfig("build").GenerateBuildUnits()

		# 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"

		nc = len(self.components)

		number_blocks = 16

		block_size = (nc / number_blocks) + 1

		component_blocks = []

		spec_nodes = []

		b = 0

		while b < nc:

			component_blocks.append(self.components[b:b+block_size])

			b += block_size

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

			component_blocks.pop()

		loop_number = 0

		for block in component_blocks:

			loop_number += 1

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

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

			configList = " ".join([c.name for c in configs])

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

			try:

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

			except Exception,e:

				# print "couldn't unlink %s: %s" %(componentMakefileName, str(e))

				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))

			# 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)

		## possibly some error handling here?

		self.specs = spec_nodes

class BuildCompleteException(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

	M_VERSION = 2	

	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

		# things to initialise

		self.args = []

		self.componentGroups = []

		self.orderComponentGroups = False

		self.commandlineComponents = []

		self.systemModel = None

		self.systemDefinitionFile = None

		self.systemDefinitionRequestedLayers = []

		self.systemDefinitionOrderLayers = False

		self.specGroups = {}

		self.configNames = []

		self.configsToBuild = set()

		self.makeOptions = []

		self.maker = None

		self.debugOutput = False

		self.doExportOnly = False

		self.noBuild = False

		self.noDependInclude = False

		self.projects = set()

		self.cache = raptor_cache.Cache(self)

		self.override = {env: str(self.home)}

		self.targets = []

		self.defaultTargets = []

		self.doCheck = False

		self.doWhat = False

		self.doParallelParsing = False

		self.mission = Raptor.M_BUILD

		# what platform and filesystem are we running on?

		self.filesystem = raptor_utilities.getOSFileSystem()

		self.toolset = None

		self.starttime = time.time()

		self.timestring = time.strftime("%Y-%m-%d-%H-%M-%S")

		self.fatalErrorState = False

	def AddConfigList(self, configPathList):

		# this function converts cmd line option into a list

		# and prepends it to default config.

		self.configPath = generic_path.NormalisePathList(configPathList.split(os.pathsep)) + self.configPath

		return True

	def AddConfigName(self, name):

		self.configNames.append(name)

		return True

	def RunQuietly(self, TrueOrFalse):

		self.quiet = TrueOrFalse

		return True

	def SetCheck(self, TrueOrFalse):

		self.doCheck = TrueOrFalse

		return True

	def SetWhat(self, TrueOrFalse):

		self.doWhat = TrueOrFalse

		return True

	def SetEnv(self, name, value):

		self.override[name] = value

	def AddTarget(self, target):

		if self.doCheck or self.doWhat:

			self.Warn("ignoring target %s because --what or --check is specified.\n", target)

		else:

			self.targets.append(target)

	def AddSourceTarget(self, filename):

		# source targets are sanitised and then added as if they were a "normal" makefile target

		# in addition they have a default, empty, top-level target assigned in order that they can

		# be presented to any generated makefile without error

		sourceTarget = generic_path.Path(filename).Absolute()

		sourceTarget = 'SOURCETARGET_' + raptor_utilities.sanitise(str(sourceTarget))

		self.AddTarget(sourceTarget)

		self.defaultTargets.append(sourceTarget)

		return True

	def SetSysDefFile(self, filename):

		self.systemDefinitionFile = generic_path.Path(filename)

		return True

	def SetSysDefBase(self, path):

		self.systemDefinitionBase = generic_path.Path(path)

		return True

	def AddSysDefLayer(self, layer):

		self.systemDefinitionRequestedLayers.append(layer)

		return True

	def SetSysDefOrderLayers(self, TrueOrFalse):

		self.systemDefinitionOrderLayers = TrueOrFalse

		return True

	def AddBuildInfoFile(self, filename):

		bldinf = generic_path.Path(filename).Absolute()

		self.commandlineComponents.append(bldinf)

		return True

	def SetTopMakefile(self, filename):

		self.topMakefile = generic_path.Path(filename)

		return True

	def SetDebugOutput(self, TrueOrFalse):

		self.debugOutput = TrueOrFalse

		return True

	def SetExportOnly(self, TrueOrFalse):

		self.doExportOnly = TrueOrFalse

		return True

	def SetNoBuild(self, TrueOrFalse):

		self.noBuild = TrueOrFalse

		return True

	def SetNoDependInclude(self, TrueOrFalse):

		self.noDependInclude = TrueOrFalse

		return True

	def SetKeepGoing(self, TrueOrFalse):

		self.keepGoing = TrueOrFalse

		return True

	def SetLogFileName(self, logfile):

		if logfile == "-":

			self.logFileName = None  # stdout

		else:

			self.logFileName = generic_path.Path(logfile)

		return True

	def SetMakeEngine(self, makeEngine):

		self.makeEngine = makeEngine

		return True

	def AddMakeOption(self, makeOption):

		self.makeOptions.append(makeOption)

		return True

	def SetJobs(self, numberOfJobs):

		try:

			self.jobs = int(numberOfJobs)

		except ValueError:

			self.jobs = 0

		if self.jobs < 1:

			self.Warn("The number of jobs (%s) must be a positive integer\n", numberOfJobs)

			self.jobs = 1

			return False

		return True

	def SetTries(self, numberOfTries):

		try:

			self.tries = int(numberOfTries)

		except ValueError:

			self.tries = 0

		if self.tries < 1:

			self.Warn("The number of tries (%s) must be a positive integer\n", numberOfTries)

			self.tries = 1

			return False

		return True

	def SetToolCheck(self, type):

		type = type.lower()

		toolcheck_types= [ "forced", "on", "off" ]

		if type in toolcheck_types:

			self.toolcheck=type

		else:

			self.Warn("toolcheck option must be one of: %s" % toolcheck_types)

			return False

		return True

	def SetParallelParsing(self, type):

		type = type.lower()

		if type == "on":

			self.doParallelParsing = True

		elif type == "off":

			self.doParallelParsing = False

		else:

			self.Warn(" parallel parsing option must be either 'on' or 'off' (was %s)"  % type)

			return False

		return True

	def AddProject(self, projectName):

		self.projects.add(projectName.lower())

		return True

	def FilterList(self, value):

		self.filterList = value

		return True

	def IgnoreOsDetection(self, value):

		self.ignoreOsDetection = value

		return True