<?xml version="1.0"?>

 <!DOCTYPE XSLT  [

      <!ENTITY AZ  "ABCDEFGHIJKLMNOPQRSTUVWXYZ">

      <!ENTITY az  "abcdefghijklmnopqrstuvwxyz">

 ]>

 <xsl:stylesheet  xmlns:xsl="http://www.w3.org/1999/XSL/Transform" version="1.0"  xmlns:s="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" xmlns:date="http://exslt.org/dates-and-times" exclude-result-prefixes="date exslt"

		xmlns:exslt="http://exslt.org/common">

	<xsl:param name="xml-stylesheet"/><!-- set to default stylesheet-->

	<xsl:param name="Verbose" select="0"/><!-- Verbosity level of messages. Set to 1 (or higher) to get runtime comments-->

	<xsl:param name="Origin-attr">old_model</xsl:param>

	<xsl:output method="xml" cdata-section-elements="script s:script" indent="yes"/>

	  <xsl:key name="named" match="*" use="@name"/>

<!-- ====== Computed values ============= -->

<xsl:variable name="Version">

	<xsl:choose>

		<xsl:when test="/model/@ver"><xsl:value-of select="/model/@ver"/></xsl:when>

		<xsl:when test="/model/@deps"><xsl:value-of select="document(/model/@deps,.)/SystemModelDeps/@version"/></xsl:when>

		<xsl:when test="count(/model/sysdef/info[@type='s12'])=1">

			<xsl:value-of select="document(/model/sysdef/info[@type='s12']/@href,.)/Schedule12/@OS_version"/>

		</xsl:when>

	</xsl:choose>

</xsl:variable>

<!-- for merging: -->

<xsl:variable name="filter-nodes" select="//filter[not(@accept or @reject) and @select and @display]"/>

	<!--  @value is optional, but should be set unless select=* -->

<xsl:variable name="filter-in"> <!--comma-separated list of filters to accept -->

	<xsl:text>,</xsl:text>

	<xsl:if test="not($filter-nodes) and //filter[@accept|@reject]">

		<xsl:value-of  select="concat($Version,',')"/> <!-- the version number -->

	</xsl:if>

	<xsl:for-each select="//filter[@accept]"><xsl:value-of select="@accept"/>,</xsl:for-each>

	<xsl:for-each select="//filter[@reject]">!<xsl:value-of select="@reject"/>,</xsl:for-each>

</xsl:variable>

<xsl:variable name="ignore" select="//ignore"/>

<xsl:variable name="abbrevs" select="document(/model/layout/info/@href,/)/display-names//abbrev"/> <!-- the abbreviations list -->

<xsl:variable name="simple-filters" select="not(function-available('exslt:node-set'))"/>

<!-- ====== Error checking ============= -->

<!--  start error checking -->

<xsl:template match="SystemDefinition/@schema" mode="check">

	<!-- warning if schema is less than 1.4 -->

	<xsl:if test="substring-before(.,'.') &lt; 1 or (substring-before(.,'.')=1 and substring-before(substring-after(.,'.'),'.') &lt; 4)">

		<xsl:call-template name="Caller-Warning"><xsl:with-param name="text">using old System Definition schema (<xsl:value-of select="."/>)</xsl:with-param></xsl:call-template>

	</xsl:if>

<!--	<xsl:if test="starts-with(.,'1.4.')">

		<xsl:call-template name="Caller-Note"><xsl:with-param name="text">using backwards compatible System Definition schema (<xsl:value-of select="."/>)</xsl:with-param></xsl:call-template>

	</xsl:if> -->

	<xsl:if test="substring-before(.,'.') &gt; 2">

		<xsl:call-template name="Critical-Error"><xsl:with-param name="text">using incompatible System Definition schema (<xsl:value-of select="."/>)</xsl:with-param></xsl:call-template>

	</xsl:if>

</xsl:template>

<xsl:template match="*" mode="check"/>

<xsl:template match="block[ancestor::layer/@levels]|lsubblock[ancestor::layer/@levels] | logicalset[ancestor::layer/@levels]|logicalsubset[ancestor::layer/@levels]" mode="check">

	<xsl:variable name="levels"><xsl:text> </xsl:text><xsl:apply-templates mode="layernames" select="."/><xsl:text> </xsl:text></xsl:variable>	

	<xsl:for-each select="module | collection">

	<xsl:if test="not(contains($levels,concat(' ',@level,' ')))">

		<xsl:call-template name="Caller-Error"><xsl:with-param name="text">Invalid level: <xsl:value-of select="@level"/> in <xsl:value-of select="@name"/></xsl:with-param></xsl:call-template>

	</xsl:if>

	</xsl:for-each>

</xsl:template>

<xsl:template name="Caller-Debug"><xsl:param name="text"/>

	<xsl:if test="$Verbose &gt; 5"><xsl:message>&#xa;Note: <xsl:value-of select="$text"/></xsl:message></xsl:if>

</xsl:template>

<xsl:template name="Caller-Note"><xsl:param name="text"/>

	<xsl:message>&#xa;Note: <xsl:value-of select="$text"/></xsl:message>

</xsl:template>

<xsl:template name="Caller-Warning"><xsl:param name="text"/>

	<xsl:message>&#xa;Warning: <xsl:value-of select="$text"/></xsl:message>

</xsl:template>

<xsl:template name="Caller-Error"><xsl:param name="text"/>

	<xsl:message>&#xa;Error: <xsl:value-of select="$text"/></xsl:message>

</xsl:template>

<xsl:template name="Critical-Error"><xsl:param name="text"/>

	<xsl:message terminate="yes">&#xa;Error: <xsl:value-of select="$text"/></xsl:message>

</xsl:template>

<!--- ==================== merge ==================== -->

<!-- merge is used this is called on a model file -->

<xsl:template match="@*" mode="copyroot" priority="-1"><xsl:copy-of select="."/></xsl:template>

<xsl:template match="@detail" mode="copyroot">

	<xsl:choose>

		<xsl:when test=".='module'"><xsl:attribute name="detail">collection</xsl:attribute></xsl:when>

		<xsl:when test=".='logicalsubset'"><xsl:attribute name="detail">subblock</xsl:attribute></xsl:when>

		<xsl:when test=".='logicalset'"><xsl:attribute name="detail">block</xsl:attribute></xsl:when>

		<xsl:otherwise><xsl:copy-of select="."/></xsl:otherwise>

	</xsl:choose>

</xsl:template>

<xsl:template match="@revision[../@revision-type='date' and contains(.,'%') and function-available('date:month-abbreviation')]" mode="copyroot">

<xsl:attribute name="revision"><xsl:call-template name="format-date"/></xsl:attribute>

</xsl:template>

<xsl:template match="/model">

	<xsl:if test="$xml-stylesheet!='' "> <!-- start with an optional style sheet transform -->

		<xsl:processing-instruction name="xml-stylesheet">type="text/xsl" href="<xsl:value-of select="$xml-stylesheet"/>"</xsl:processing-instruction>

	</xsl:if>

	<SystemDefinition>

		<xsl:copy-of select="document(sysdef/@href, .)/SystemDefinition/@*"/>

	<xsl:copy-of select="document(layout/info[@type='abbrev']/@href,.)/*/@xml:lang"/> <!-- copy localized language value -->

		<xsl:apply-templates select="document(@deps, .)/SystemModelDeps" mode="merge"/>

		<styling>

			<xsl:apply-templates select="@shapes | layout/info" mode="styling"/>

		</styling>

		<xsl:apply-templates select="document(sysdef/@href, .)/SystemDefinition/@schema" mode="check"/>

		  <systemModel>

			<!-- copy all attributes from all the system models and from the model element -->

			<xsl:apply-templates select="document(sysdef/@href, .)/SystemDefinition/systemModel/@*|@*|layout/@*" mode="copyroot"/>

			<xsl:if test="$Version!='' and not(@ver)">

				<xsl:attribute name="ver">

					<xsl:value-of select="$Version"/>

				</xsl:attribute>

			</xsl:if>

			<!-- special handing of revision details -->

			<xsl:choose><!-- get revision details from deps if not otherwise specified -->

				<xsl:when test="@deps and (not(@revision-type) or @revision-type='build') and not(@revision)">

					<xsl:variable name="rt" select="@revision-type"/>

					<xsl:for-each select="document(@deps,.)/SystemModelDeps[@number]">

						<xsl:if test="not($rt)">

							<xsl:attribute name="revision-type">build</xsl:attribute>

						</xsl:if>

						<xsl:attribute name="revision"><xsl:value-of select="@number"/></xsl:attribute>

					</xsl:for-each>

				</xsl:when>

				<xsl:when test="@revision-type='date' and not(@revision) and function-available('date:date-time')">

					<xsl:attribute name="revision"><xsl:value-of select="substring-before(date:date-time(),'T')"/></xsl:attribute>

				</xsl:when>

			</xsl:choose>

			<xsl:apply-templates select="layout/legend" mode="merge"/> <!-- add legend as a layer -->

			<xsl:apply-templates select="layout/logo" mode="merge"/> <!-- copy logos to use when drawing: put first so it's drawn last-->

			<xsl:choose>

				<xsl:when test="not(function-available('exslt:node-set'))">

					<!-- can't do much, don't bother filtering -->

					<xsl:apply-templates select="sysdef" mode="merge"/>

				</xsl:when>

				<xsl:otherwise>

					<xsl:for-each select="/model"> <!-- hack for xsltproc which loses the current node -->				

					<xsl:variable name="unfiltered">

							<xsl:choose>

								<xsl:when test="count(sysdef) &lt; 2"> <!-- no need to merge multi models -->

									<xsl:apply-templates select="sysdef" mode="merge"/>

								</xsl:when>

								<xsl:otherwise>

									<xsl:variable name="sysdefs">

										<xsl:for-each select="sysdef">

											<sysdef><xsl:apply-templates select="." mode="merge"/></sysdef>

										</xsl:for-each>

									</xsl:variable>

									<xsl:apply-templates select="exslt:node-set($sysdefs)/sysdef[1]" mode="override-merge">

										<xsl:with-param name="next" select="exslt:node-set($sysdefs)/sysdef[2]"/>

									</xsl:apply-templates>

								</xsl:otherwise>

							</xsl:choose>

						</xsl:variable>

						<xsl:apply-templates select="exslt:node-set($unfiltered)/*" mode="filter-for-presence"/>

					</xsl:for-each>

				</xsl:otherwise>

			</xsl:choose>

			<xsl:copy-of select="layout/layer-group"/> <!-- copy layer groups to use when drawing: put last so it's drawn first-->

		  </systemModel>

	</SystemDefinition>

</xsl:template>

<!-- merge multiple models together -->

<xsl:template match="sysdef" mode="override-merge"><xsl:param name="next"/>

	<xsl:choose>

		<xsl:when test="not($next)">

			<xsl:copy-of select="*"/>

		</xsl:when>

		<xsl:otherwise>

			<xsl:call-template name="Caller-Note"><xsl:with-param name="text">Merging with model <xsl:value-of select="1 +  count($next/preceding-sibling::sysdef)"/></xsl:with-param></xsl:call-template>			

			<xsl:variable name="cur">

					<sysdef>

						<xsl:apply-templates select="*" mode="override-merge">

							<xsl:with-param name="other" select="$next"/>

						</xsl:apply-templates>

						<xsl:apply-templates select="$next/*" mode="append">

							<xsl:with-param name="main" select="."/>

						</xsl:apply-templates>

					</sysdef>

			</xsl:variable>

			<xsl:apply-templates select="exslt:node-set($cur)/sysdef" mode="override-merge">

				<xsl:with-param name="next" select="$next/following-sibling::sysdef[1]"/>

			</xsl:apply-templates>	

		</xsl:otherwise>

	</xsl:choose>

</xsl:template>

<xsl:template match="component/*" mode="override-merge" priority="7"><xsl:copy-of select="."/></xsl:template>

<xsl:template match="*" mode="override-merge"><xsl:param name="other"/>

	<xsl:variable name="n" select="@name"/>

	<xsl:variable name="tag" select="name()"/>

	<xsl:choose>

		<xsl:when test="$other/*[@override=$n and name()=$tag]"> 

			<!--replace this with the other one at the current location-->

			<xsl:apply-templates select="$other/*[@override=$n and name()=$tag]" mode="safe-combine">

				<xsl:with-param name="main-root" select="ancestor-or-self::sysdef"/>

			</xsl:apply-templates>

		</xsl:when>

		<xsl:when test="$other/ancestor-or-self::sysdef/descendant::*[@override=$n and name()=$tag]">

			<!-- it's overridden somewhere else (perhaps deleted)-->

			<xsl:call-template name="Caller-Note"><xsl:with-param name="text">Deleting  <xsl:value-of select="$n"/></xsl:with-param></xsl:call-template>			

		</xsl:when>

		<xsl:when test="$other/*[@rename=$n or @move=$n and name()=$tag]"> <!-- leave as is at the current location-->

			<xsl:if test="$other/*[@rename=$n or @move=$n and name()=$tag]/*">

			<xsl:call-template name="Caller-Warning"><xsl:with-param name="text">ignoring children</xsl:with-param></xsl:call-template>

			</xsl:if>

			<xsl:copy>

				<xsl:copy-of select="@*"/> <!-- own attributes -->

				<xsl:copy-of select="$other/*[@rename=$n or @move=$n and name()=$tag]/@name"/> <!-- overwrite names -->

			<!--leave as is at the current location-->					

				<xsl:apply-templates select="*[not(self::name)]"  mode="override-merge"> <!-- do not copy deprecated localised name form-->

					<xsl:with-param name="other" select="$other/ancestor-or-self::sysdef"/> <!-- use root of other, to catch any moved decendants -->

				</xsl:apply-templates>

			</xsl:copy>

		</xsl:when>

		<xsl:when test="$other/ancestor-or-self::sysdef/descendant::*[@rename=$n or @move=$n and $tag=name()]">

			<!--it's moved to elsewhere-->

			<xsl:call-template name="Caller-Note"><xsl:with-param name="text">Relocating <xsl:value-of select="$n"/></xsl:with-param></xsl:call-template>

		</xsl:when>

		<xsl:when test="$other/*[@name=$n and self::component]">

			<!--use other at the current location-->

			<xsl:copy>

				<xsl:copy-of select="$other/*[@name=$n and name()=$tag]/@*"/> <!--other's attributes -->

				<!-- should put something here to merge filters,classes properly -->

				<xsl:copy-of select="*"/> <!--current conent -->

					<xsl:variable name="this" select="."/>

				<xsl:apply-templates mode="copy-merge-content"  select="$other/*[@name=$n and name()=$tag]/*">

					<xsl:with-param name="main" select="$this"/>

				</xsl:apply-templates> <!--other's conent -->

			</xsl:copy>

		</xsl:when>

		<xsl:when test="$other/*[@name=$n and name()=$tag]"> <!-- leave as is at the current location, merge children-->

			<xsl:for-each select="$other/*[@name=$n and name()=$tag]">

				<xsl:if test="(self::module and $tag!='module') or (not(self::module) and $tag='module')   or   (self::collection and $tag!='collection') or (not(self::collection) and $tag='collection')">

					<xsl:call-template name="Critical-Error"><xsl:with-param name="text">Cannot merge <xsl:value-of select="name()"/> "<xsl:value-of select="@name"/>" with <xsl:value-of select="$tag"/> "<xsl:value-of select="$n"/>"</xsl:with-param></xsl:call-template>				

				</xsl:if>

			</xsl:for-each>

			<xsl:copy>

				<xsl:copy-of select="@*"/> <!-- own attributes -->

				<xsl:copy-of select="$other/*[@name=$n and name()=$tag]/@*"/> <!-- other's attributes -->

				<xsl:apply-templates select="*"  mode="override-merge">

					<xsl:with-param name="other" select="$other/*[@name=$n and name()=$tag]"/> <!-- use other version of this -->

				</xsl:apply-templates>

			</xsl:copy>

		</xsl:when>

		<xsl:when test="$other/ancestor-or-self::sysdef/descendant::*[@name=$n and name()=$tag]">

			<!-- it's moved to elsewhere -->

			<xsl:call-template name="Caller-Note"><xsl:with-param name="text">Relocating and merging <xsl:value-of select="$n"/></xsl:with-param></xsl:call-template>

		</xsl:when>

		<xsl:otherwise> <!--  there is no equivalent in 2nd, just copy this and descend -->

			<xsl:copy>

				<xsl:copy-of select="@*"/> <!-- own attributes -->	

				<xsl:apply-templates select="*"  mode="override-merge">

					<xsl:with-param name="other" select="$other/ancestor-or-self::sysdef"/> <!-- use root of other, to catch any moved decendants -->

				</xsl:apply-templates>

			</xsl:copy>		

		</xsl:otherwise>

	</xsl:choose>

	<!-- this won't work if the main model has nothing in the group, but that's invalid, so it's ok. -->

	<xsl:if test="position()=last() and name($other)!='sysdef'">

		<!--Check if other has stuff to append that's not already been used   -->

		<xsl:apply-templates select="$other/*" mode="append">

			<xsl:with-param name="main" select=".."/>

		</xsl:apply-templates>		

	</xsl:if>

</xsl:template>

<xsl:template mode="copy-merge-content" match="*">

<xsl:copy-of select="."/>

</xsl:template>

<xsl:template mode="copy-merge-content" match="component/*[starts-with(name(),'generator-')]"><xsl:param name="main"/>

	<xsl:variable name="self" select="."/>

	<!-- only copy if does not exist in original -->

	<xsl:if test="not($main/*[name()=name($self)])">

		<xsl:copy-of select="$self"/>

	</xsl:if>

</xsl:template>

<xsl:template mode="copy-merge-content" match="unit"><xsl:param name="main"/>

	<xsl:variable name="attr"><xsl:for-each select="@*"><xsl:value-of select="concat(name(),'=',.)"></xsl:value-of></xsl:for-each></xsl:variable>

	<xsl:variable name="exists">

		<xsl:for-each select="$main/unit">

			<xsl:variable name="attr2"><xsl:for-each select="@*"><xsl:value-of select="concat(name(),'=',.)"></xsl:value-of></xsl:for-each></xsl:variable>

			<xsl:if test="$attr2=$attr">*</xsl:if>

		</xsl:for-each>

	</xsl:variable>

	<!-- only copy if does not exist in original's units-->

	<xsl:if test="$exists=''">

		<xsl:copy-of select="."/>

	</xsl:if>

</xsl:template>

<xsl:template match="*[@override  and *]" mode="append" priority="5"><xsl:param name="main"/>

	<xsl:call-template name="Caller-Debug"><xsl:with-param name="text">Append (5) <xsl:value-of select="@name"/></xsl:with-param></xsl:call-template>	

	<xsl:variable name="n" select="@override"/>

		<!-- if override is not in main, use this -->

	<xsl:if test="@name and not($main/*[@name=$n])">

		<!--  must have a name for renaming -->

		<xsl:copy>

			<xsl:copy-of select="@*[not(name()='override' or name()='rename' or name()='move')]"/>

			<xsl:apply-templates select="*" mode="safe-combine">

				<xsl:with-param name="main-root" select="$main/ancestor-or-self::sysdef"/>

			</xsl:apply-templates>	

		</xsl:copy>

	</xsl:if>

</xsl:template>

<xsl:template match="*" mode="safe-combine" priority="-1"><xsl:param name="main-root"/>

	<xsl:copy>

		<xsl:copy-of select="@*"/>

		<xsl:apply-templates select="*"  mode="safe-combine">

			<xsl:with-param name="main-root" select="$main-root"/>

		</xsl:apply-templates>

	</xsl:copy>

</xsl:template>

<xsl:template match="*[@rename or @move]" mode="safe-combine" priority="3"><xsl:param name="main-root"/>

	<xsl:variable name="n" select="@rename | @move"/>

	<xsl:variable name="newname" select="@name"/>

	<xsl:variable name="atts" select="@*[name()!='name' and name()!='move' and name()!='rename' and name()!='override']"/> <!-- if any non-oragnisational attributes are present on the "move" item, then they should override the values in the thing being moved -->

	<xsl:variable name="other" select="ancestor-or-self::sysdef"/>

	<!-- can't merge a component with a container -->

	<xsl:for-each select="$main-root/descendant::*[@name=$n and (self::layer or self::block or self::subblock or self::logicalset or self::logicalsubset)]">

		<xsl:copy>

			<xsl:copy-of select="@*"/>

			<xsl:copy-of select="$newname"/>	

			<xsl:copy-of select="$atts"/> <!-- if any of these attributes are present on the moved collection, then use that value rather than the value in the one being moved -->

			<xsl:apply-templates select="*"  mode="override-merge"> <!-- do not copy localised name -->

				<xsl:with-param name="other" select="$other"/>

			</xsl:apply-templates>

		</xsl:copy>

	</xsl:for-each>	

</xsl:template>

<!-- can only merge a component or module with component or module -->

<xsl:template match="component[@rename or @move] | collection[@rename or @move] | module[@rename or @move]" mode="safe-combine" priority="4"><xsl:param name="main-root"/>

	<xsl:variable name="n" select="@rename | @move"/>

	<xsl:variable name="newname" select="@name"/>

	<xsl:variable name="atts" select="@*[name()!='name' and name()!='move' and name()!='rename' and name()!='override']"/> <!-- if any non-oragnisational attributes are present on the "move" item, then they should override the values in the thing being moved -->

	<xsl:variable name="tag" select="name()"/>

	<xsl:variable name="other" select="ancestor-or-self::sysdef"/>	

	<!-- can't merge a component with a container -->

	<xsl:for-each select="$main-root/descendant::*[@name=$n and $tag=name()]">

		<xsl:copy>

			<xsl:copy-of select="@*"/>

			<xsl:copy-of select="$newname"/>	

			<xsl:copy-of select="$atts"/> <!-- if any of these attributes are present on the moved collection, then use that value rather than the value in the one being moved -->

			<xsl:apply-templates select="*[not(self::name)]"  mode="override-merge"> <!-- do not copy localised name -->

				<xsl:with-param name="other" select="$other"/>

			</xsl:apply-templates>

		</xsl:copy>

	</xsl:for-each>	

</xsl:template>

<xsl:template match="*[@name]" mode="safe-combine" priority="2"><xsl:param name="main-root"/>

	<xsl:if test="@override and (@rename or @move)">

		<xsl:call-template name="Critical-Error"><xsl:with-param name="text">Error invalid combinations of attributes in <xsl:value-of select="@name"/></xsl:with-param></xsl:call-template>

	</xsl:if>

	<xsl:copy>

		<xsl:variable name="cur" select="."/>

		<xsl:copy-of select="@*[not(name()='override' or name()='rename' or name()='move')]"/>

		<!-- copy other's attributes -->

		<xsl:copy-of select="$main-root/descendant::*[@name=$cur/@name and name($cur)=name()]/@*[not(name()='override' or name()='rename' or name()='move' or name()='name')]"/>		

		<xsl:apply-templates select="*"  mode="safe-combine">

			<xsl:with-param name="main-root" select="$main-root"/>

		</xsl:apply-templates>

		<!-- now copy anything defined here -->

		<xsl:variable name="other" select="ancestor-or-self::sysdef"/>	

		<xsl:for-each select="$main-root/descendant::*[@name=$cur/@name and name($cur)=name()]">

			<xsl:apply-templates select="*[not(self::name)]"  mode="override-merge"> <!-- do not copy localised name -->

				<xsl:with-param name="other" select="$other"/>

			</xsl:apply-templates>

		</xsl:for-each>	

	</xsl:copy>

</xsl:template>

<xsl:template match="component | component/*" mode="safe-combine" priority="2">

	<!--a component is atomic: it cannot be merged. So it's always just copied.-->	

	<xsl:copy-of select="."/>

</xsl:template>

<xsl:template match="*[@override and not(@name)]" mode="safe-combine" priority="5"/> <!-- ignore component -->

<xsl:template match="*" mode="unused-merge"><xsl:param name="other"/>

	<xsl:variable name="self" select="."/>

	<xsl:if test="not($other/descendant::*[@name=$self/@name and name()=name($self)  and descendant-or-self::component])">

		<!-- not in other, so include here -->

		<xsl:copy>

			<xsl:copy-of select="@*"/>

			<xsl:apply-templates select="*"  mode="unused-merge">

				<xsl:with-param name="other" select="$other"/>

			</xsl:apply-templates>

		</xsl:copy>

	</xsl:if>

</xsl:template>

<xsl:template match="*[@name]" mode="append"><xsl:param name="main"/>

	<!--  this handles all cases where this holds the data -->

	<xsl:variable name="self" select="."/>

		<!-- if $self is not in main, use this -->

	<xsl:if test="not($main/*[@name=$self/@name])">

		<xsl:variable name="other" select="ancestor-or-self::sysdef"/>

		<xsl:for-each select="$main/ancestor-or-self::sysdef/descendant::*[@name=$self/@name and name()=name($self)  and descendant-or-self::component]">

			<xsl:call-template name="Caller-Debug"><xsl:with-param name="text">To Merge <xsl:value-of select="$self/@name"/> with these: <xsl:for-each select="*">"<xsl:value-of select="@name"/>", </xsl:for-each></xsl:with-param></xsl:call-template>	

			<xsl:copy>

				<xsl:copy-of select="@*"/>

				<xsl:apply-templates select="*"  mode="override-merge">

					<xsl:with-param name="other" select="$other"/>

				</xsl:apply-templates>

	<xsl:comment>was not here</xsl:comment>

				<xsl:apply-templates select="$other/descendant::*[@name=$self/@name and name()=name($self) and descendant-or-self::component]/*"  mode="unused-merge">

					<xsl:with-param name="other" select="$main"/>

				</xsl:apply-templates>

	<xsl:comment>end not here</xsl:comment>

			</xsl:copy>

		</xsl:for-each>

		<!-- if it does not already exist, create it and check all children -->

		<xsl:if test="not($main/ancestor-or-self::sysdef/descendant::*[@name=$self/@name and name()=name($self) and descendant-or-self::component])">

			<xsl:call-template name="Caller-Debug"><xsl:with-param name="text">Does not already exist: <xsl:value-of select="$self/@name"/> </xsl:with-param></xsl:call-template>	

			<xsl:copy>

				<xsl:copy-of select="@*"/>

				<xsl:apply-templates select="*"  mode="safe-combine">

					<xsl:with-param name="main-root" select="$main/ancestor-or-self::sysdef"/>

				</xsl:apply-templates>

			</xsl:copy>			

		</xsl:if>

	</xsl:if>

</xsl:template>

<xsl:template match="component[@name]" mode="append" priority="1"><xsl:param name="main"/>

	<xsl:variable name="n" select="@name"/>

		<!-- if $n is not in main, use this -->

	<xsl:if test="not($main/*[@name=$n])">	

		<xsl:copy-of select="."/>

	</xsl:if>

</xsl:template>

<xsl:template match="*[@rename or @move]" mode="append" priority="4"><xsl:param name="main"/>

	<xsl:call-template name="Caller-Debug"><xsl:with-param name="text">Append (4) <xsl:value-of select="@name"/></xsl:with-param></xsl:call-template>	

	<xsl:variable name="n" select="@rename | @move"/>

		<!-- if $n is not in main, use this -->

	<xsl:if test="not($main/*[@name=$n])">	

		<xsl:apply-templates select="." mode="safe-combine">

			<xsl:with-param name="main-root" select="$main/ancestor-or-self::sysdef"/>

		</xsl:apply-templates>	

	</xsl:if>

</xsl:template>

<!-- merging data sources  -->

<xsl:template match="sysdef" mode="merge">

	<xsl:apply-templates select="document(@href)/SystemDefinition/systemModel/*" mode="merge">

		<xsl:with-param name="extra-files" select="info|../@deps|../@ts|../layout/info[@type and document(@href,.)/values]|../layout/display|@root"/>

	</xsl:apply-templates>

</xsl:template>

<xsl:template match="SystemModelDeps" mode="merge">

	<xsl:if test="@name or @version or @number">

		<release><xsl:copy-of select="@name | @version | @number"/></release>

	</xsl:if>

</xsl:template>

<!-- merge model with extra -->

<xsl:template match="layer" mode="merge"><xsl:param name="extra-files"/>

	<xsl:variable name="e"><xsl:call-template name="is-present"/></xsl:variable>	

	<xsl:if test="$e!=''">

		<xsl:copy><xsl:copy-of select="@*"/> 

			<xsl:variable name="name" select="@name"/>

			<xsl:copy-of select="$extra-files[self::display and @name=$name]/@*[name()!='name']"/>

			<xsl:if test="$extra-files[@type='levels']"><!-- levels hack for older models -->

				<xsl:copy-of select="document($extra-files[@type='levels']/@href,$extra-files)//layer[@name=$name]/@*[name()='levels' or name()='span']"/>

			</xsl:if>

			<xsl:apply-templates select="$extra-files[@type='extra']" mode="merge-attributes">

				<xsl:with-param name="cmp" select="."/>			

			</xsl:apply-templates>

			<xsl:if test="@name='Programming Support' and not(@span)"><xsl:attribute name="span">2</xsl:attribute></xsl:if> <!-- hack!!!!! -->

			<xsl:call-template name="abbrev"/>

		 	<xsl:apply-templates select="*" mode="merge">

				<xsl:with-param name="extra-files" select="$extra-files"/>

			</xsl:apply-templates>

		</xsl:copy>

	</xsl:if>

</xsl:template>

<!-- hack for old models -->

<xsl:template match="logicalsubset[@name='J2ME']" mode="merge" priority="5"><xsl:param name="extra-files"/>

	<xsl:apply-templates select="*" mode="merge">

		<xsl:with-param name="extra-files" select="$extra-files"/>

	</xsl:apply-templates>

</xsl:template>

<!-- update old model names, these could be done as a set of templates instead.

	I've no idea which is more efficient -->

<xsl:template match="*" mode="item-tag">

	<xsl:choose>

		<xsl:when test="self::module">collection</xsl:when>