<?xml version='1.0'?>
<xsl:stylesheet  xmlns:xsl="http://www.w3.org/1999/XSL/Transform" version="1.0">
<xsl:output indent="yes"/>
<xsl:template match="/">

<nta>
	<!--Declaracion de las variables globales, en este caso van a ser canales, relojes...-->
		<declaration>
			<xsl:text>urgent chan </xsl:text>
			<urgent>
			<xsl:text>urgent_chan, </xsl:text>
			</urgent>
			<xsl:text>chan </xsl:text>
			<canales>
			<xsl:call-template name="variable_canal"/>
			</canales>			
						
			<xsl:text>int [0,1] </xsl:text>
			<boolean>			
		    <xsl:call-template name="variable_boolean"/>
			</boolean>
		  	
		  	<xsl:text>int </xsl:text>
			<int>
			<xsl:call-template name="variable_int"/>
			</int>
		  			
			<xsl:text>clock </xsl:text>
			<reloj>
			<xsl:call-template name="variable_reloj"/>
			</reloj>
						
		</declaration>
		
		<xsl:variable name="nombre_proceso" select="'System'"/>
			
		<!--Sólo existe una plantilla principal en el sistema-->
		<template>
			<name>
				<xsl:value-of select="'System'"/>
			</name>				
								

<!--################################Nodos##########################################-->
<xsl:for-each select="//choreography">

	  <!--Siempre existe un location para excepciones-->
	  <xsl:element name="location">
		<xsl:attribute name="id">Exception</xsl:attribute>
		<name>
			<xsl:attribute name="id">Exception</xsl:attribute>
	  	</name>
	  </xsl:element>

	  <xsl:for-each select="child::*">
	     
	  	 <!--################################NoAction##########################################-->
			<xsl:if test="(name()='noAction')">
				<xsl:call-template name="noAct">
				</xsl:call-template>
		 	</xsl:if>
		 	
		 <!--################################Fail##########################################-->
			<xsl:if test="(name()='fail')">
				<xsl:call-template name="fail">
				</xsl:call-template>
		 	</xsl:if>
		 
		 <!--NO HAY ASSIGN AQUÍ PARA NO CONFUNDIR CON LAS ASIGNACIONES INICIALES-->
		 	
		 <!--################################Interaction##########################################-->
			<xsl:if test="(name()='interaction')">
				<xsl:call-template name="int">			   		
				</xsl:call-template>
		 	</xsl:if>
										
		 <!--###############################Workunit##############################################-->
	    	<xsl:if test="(name()='workunit')">
	    		<xsl:call-template name="work">
			   		<xsl:with-param name="nombre_proceso"><xsl:value-of select="$nombre_proceso"/></xsl:with-param>			   		
				</xsl:call-template>
	    	</xsl:if>
	    	
	    <!--###############################Sequence###############################################-->
			<xsl:if test="name()='sequence'">
				<xsl:call-template name="seq">
	                <xsl:with-param name="nombre_proceso"><xsl:value-of select="$nombre_proceso"/></xsl:with-param>	                
	            </xsl:call-template>
	        </xsl:if>
	        
	    <!--###############################Choice#################################################-->
	        <xsl:if test="name()='choice'">	        	
   				<xsl:call-template name="cho">
   					<xsl:with-param name="nombre_proceso"><xsl:value-of select="$nombre_proceso"/></xsl:with-param>
   				</xsl:call-template>
   			</xsl:if>
   		
   		<!--###############################Parallel#################################################-->
	        <xsl:if test="name()='parallel'">
   				<xsl:call-template name="par">
   					<xsl:with-param name="nombre_proceso"><xsl:value-of select="$nombre_proceso"/></xsl:with-param>   					
   				</xsl:call-template>
   			</xsl:if>	
   			
	  </xsl:for-each>
	  
	  <!--También se tienen que añadir los nodos de las excepciones-->
	  <xsl:for-each select="exceptionBlock/workunit/sequence">
	  
	  	 <!--Marcar comienzo-->
		 <EXCEPTION>
		 
		 <!--Atributo con la excepción con la que se corresponde-->
		 <xsl:attribute name="name">exception_<xsl:value-of select="position()-1"/></xsl:attribute>
	     
	  	 <!--################################NoAction##########################################-->
			<xsl:if test="(name()='noAction')">
				<xsl:call-template name="noAct">
				</xsl:call-template>
		 	</xsl:if>
		 	
		 <!--################################Fail##########################################-->
			<xsl:if test="(name()='fail')">
				<xsl:call-template name="fail">
				</xsl:call-template>
		 	</xsl:if>
		 
		 <!--######################ASSIGN###################################################-->
				<xsl:if test="(name()='assign')">
					<xsl:call-template name="assign">
					</xsl:call-template>
			 	</xsl:if>
		 	
		 <!--################################Interaction##########################################-->
			<xsl:if test="(name()='interaction')">
				<xsl:call-template name="int">			   		
				</xsl:call-template>
		 	</xsl:if>
										
		 <!--###############################Workunit##############################################-->
	    	<xsl:if test="(name()='workunit')">
	    		<xsl:call-template name="work">
			   		<xsl:with-param name="nombre_proceso"><xsl:value-of select="$nombre_proceso"/></xsl:with-param>			   		
				</xsl:call-template>
	    	</xsl:if>
	    	
	    <!--###############################Sequence###############################################-->
			<xsl:if test="name()='sequence'">
				<xsl:call-template name="seq">
	                <xsl:with-param name="nombre_proceso"><xsl:value-of select="$nombre_proceso"/></xsl:with-param>	                
	            </xsl:call-template>
	        </xsl:if>
	        
	    <!--###############################Choice#################################################-->
	        <xsl:if test="name()='choice'">	        	
   				<xsl:call-template name="cho">
   					<xsl:with-param name="nombre_proceso"><xsl:value-of select="$nombre_proceso"/></xsl:with-param>
   				</xsl:call-template>
   			</xsl:if>
   		
   		<!--###############################Parallel#################################################-->
	        <xsl:if test="name()='parallel'">
   				<xsl:call-template name="par">
   					<xsl:with-param name="nombre_proceso"><xsl:value-of select="$nombre_proceso"/></xsl:with-param>   					
   				</xsl:call-template>
   			</xsl:if>
   			
   		 <!--Marcar final-->
		 </EXCEPTION>
   			
	  </xsl:for-each>	  		  
	  
</xsl:for-each>
<!--################################Fin nodos##########################################-->


<!--################################Transiciones#######################################-->

<xsl:for-each select="//choreography">

	<xsl:for-each select="child::*">	
	
	<!--################################NoAction##########################################-->		
    <xsl:if test="(name()='noAction')">   				
			<xsl:call-template name="noAct_trans"></xsl:call-template>		
    </xsl:if>
    
    <!--################################Fail##########################################-->		
    <xsl:if test="(name()='fail')">   				
			<xsl:call-template name="fail_trans"></xsl:call-template>		
    </xsl:if>
    
    <!--NO HAY ASSIGN AQUÍ PARA NO CONFUNDIR CON LAS ASIGNACIONES INICIALES-->
	
	<!--################################Interaction##########################################-->		
    <xsl:if test="(name()='interaction')">   				
			<xsl:call-template name="inter_trans"></xsl:call-template>		
    </xsl:if>
    
    <!--################################Workunit#############################################-->
    <xsl:if test="name()='workunit'">   			
    	<xsl:call-template name="work_trans"><xsl:with-param name="nombre_proceso"><xsl:value-of select="$nombre_proceso"/></xsl:with-param>
    	</xsl:call-template>
    </xsl:if>
    
    <!--################################Sequence#############################################-->	 
    <xsl:if test="name()='sequence'">
   		<xsl:call-template name="seq_trans"><xsl:with-param name="nombre_proceso"><xsl:value-of select="$nombre_proceso"/></xsl:with-param>
   		</xsl:call-template>
   	</xsl:if>
   	
   	<!--###############################choice#################################################-->
   	<xsl:if test="name()='choice'">   		
   		<xsl:call-template name="cho_trans">
	   		<xsl:with-param name="nombre_proceso"><xsl:value-of select="$nombre_proceso"/></xsl:with-param>	   			   		
   		</xsl:call-template>
   	</xsl:if>
   	
   	<!--###############################PARALLEL#################################################-->
   	<xsl:if test="name()='parallel'">
   		<xsl:call-template name="par_trans">
   			<xsl:with-param name="nombre_proceso"><xsl:value-of select="$nombre_proceso"/></xsl:with-param>   			
   		</xsl:call-template>
   	</xsl:if>
   	
   	</xsl:for-each>
   	
   	<!--También se tienen que añadir las transiciones de las excepciones-->
	<xsl:for-each select="exceptionBlock/workunit/sequence">
		
		<!--Marcar comienzo-->
		<EXCEPTION><xsl:attribute name="name">exception_<xsl:value-of select="position()-1"/></xsl:attribute></EXCEPTION>
		 
		<!--Atributo con la excepción con la que se corresponde-->
		<xsl:attribute name="name">exception_<xsl:value-of select="position()-1"/></xsl:attribute>
	
		<!--################################NoAction##########################################-->		
	    <xsl:if test="(name()='noAction')">   				
				<xsl:call-template name="noAct_trans"></xsl:call-template>		
	    </xsl:if>
	    
	    <!--################################Fail##########################################-->		
	    <xsl:if test="(name()='fail')">   				
				<xsl:call-template name="fail_trans"></xsl:call-template>		
	    </xsl:if>
	    
	    <!--################################Assign##########################################-->
	    <xsl:if test="(name()='assign')">   				
			    <xsl:call-template name="assign_trans"></xsl:call-template>		
        </xsl:if>
		
		<!--################################Interaction##########################################-->		
	    <xsl:if test="(name()='interaction')">   				
				<xsl:call-template name="inter_trans"></xsl:call-template>		
	    </xsl:if>
	    
	    <!--################################Workunit#############################################-->
	    <xsl:if test="name()='workunit'">   			
	    	<xsl:call-template name="work_trans"><xsl:with-param name="nombre_proceso"><xsl:value-of select="$nombre_proceso"/></xsl:with-param>
	    	</xsl:call-template>
	    </xsl:if>
	    
	    <!--################################Sequence#############################################-->	 
	    <xsl:if test="name()='sequence'">
	   		<xsl:call-template name="seq_trans"><xsl:with-param name="nombre_proceso"><xsl:value-of select="$nombre_proceso"/></xsl:with-param>
	   		</xsl:call-template>
	   	</xsl:if>
	   	
	   	<!--###############################choice#################################################-->
	   	<xsl:if test="name()='choice'">   		
	   		<xsl:call-template name="cho_trans">
		   		<xsl:with-param name="nombre_proceso"><xsl:value-of select="$nombre_proceso"/></xsl:with-param>	   			   		
	   		</xsl:call-template>
	   	</xsl:if>
	   	
	   	<!--###############################PARALLEL#################################################-->
	   	<xsl:if test="name()='parallel'">
	   		<xsl:call-template name="par_trans">
	   			<xsl:with-param name="nombre_proceso"><xsl:value-of select="$nombre_proceso"/></xsl:with-param>   			
	   		</xsl:call-template>
	   	</xsl:if>
	   	
	   	<!--Marcar final-->
		<EXCEPTION><xsl:attribute name="name">exception_<xsl:value-of select="position()-1"/></xsl:attribute></EXCEPTION>	
    
	</xsl:for-each>

</xsl:for-each>
<!--################################Fin transiciones###################################-->

</template>				


<!--################################Definición de las plantillas para los parallel###################################-->

<xsl:for-each select="//choreography">
		
	<xsl:for-each select="descendant::parallel">
		
		<xsl:variable name="id" select="count(preceding::parallel) + count(ancestor::parallel)"/>		
		
		<template>
			
		<name>
			<!--Nombre de la plantilla con el identificador del paralel-->
			<xsl:text>Par_</xsl:text><xsl:value-of select="$nombre_proceso"/><xsl:value-of select="$id"/>
		</name>		
				
		<!--################################Location##########################################-->
		
		<!--Siempre existe un location para excepciones-->
		<xsl:element name="location">
			<xsl:attribute name="id">Exception</xsl:attribute>
			<name>
				<xsl:attribute name="id">Exception</xsl:attribute>
			</name>
		</xsl:element>	
		
		<!--Se añade un location de inicio (también es de finalización)-->
		<xsl:element name="location">	
			
			<xsl:attribute name="id">Init_Parallel<xsl:value-of select="$id"/></xsl:attribute>
			<xsl:attribute name="type">Parallel</xsl:attribute>
			<name>
				<xsl:attribute name="id">Init_Parallel<xsl:value-of select="$id"/></xsl:attribute>
			</name>
		</xsl:element>
		
		<PARALLEL>
		<xsl:attribute name="id"><xsl:value-of select="$id"/></xsl:attribute>
		
		<xsl:variable name="pos" select="position()"/>
		
		<xsl:for-each select="child::*[position()=2]">		
							
	 	    <!--######################Si como hijo tiene un NOACTION######################-->
			<xsl:if test="(name()='noAction')">
				<xsl:call-template name="noAct">
				</xsl:call-template>
		 	</xsl:if>
		 	
		 	<!--######################Si como hijo tiene un FAIL######################-->
			<xsl:if test="(name()='fail')">
				<xsl:call-template name="fail">
				</xsl:call-template>
		 	</xsl:if>
		 	
		 	<!--######################Si como hijo tiene un ASSIGN######################-->
				<xsl:if test="(name()='assign')">
					<xsl:call-template name="assign">
					</xsl:call-template>
			 	</xsl:if>
			
			<!--######################Si como hijo tiene un INTERACTION#####################-->
			<xsl:if test="name()='interaction'">
			  <xsl:call-template name="int">            
	          </xsl:call-template>
			</xsl:if>
			
			<!--######################Si como hijo tiene un SEQUENCE######################-->
			<xsl:if test="name()='sequence'">			
				<xsl:call-template name="seq">
	                <xsl:with-param name="nombre_proceso"><xsl:value-of select="$nombre_proceso"/></xsl:with-param>	                
	            </xsl:call-template>									
			</xsl:if>
			
			<!--######################Si como hijo tiene un WORKUNIT#####################-->
			<xsl:if test="name()='workunit'">
			  <xsl:call-template name="work">
	            <xsl:with-param name="nombre_proceso"><xsl:value-of select="$nombre_proceso"/></xsl:with-param>
	          </xsl:call-template>
			</xsl:if>	
			
			<!--######################Si como hijo tiene un CHOICE#####################-->
			<xsl:if test="name()='choice'">			
				<xsl:call-template name="cho">
					<xsl:with-param name="nombre_proceso"><xsl:value-of select="$nombre_proceso"/></xsl:with-param>
				</xsl:call-template>
			</xsl:if>
			
			<!--######################Si como hijo tiene un PARALLEL#####################-->
			<xsl:if test="name()='parallel'">
			  <xsl:call-template name="par">
	            <xsl:with-param name="nombre_proceso"><xsl:value-of select="$nombre_proceso"/></xsl:with-param>
	          </xsl:call-template>
			</xsl:if>		
			
			<xsl:text> </xsl:text>
		</xsl:for-each>
		
		</PARALLEL>
		
	   	<!--################################Fin Location##########################################-->
		   		
		   		
		<!--################################Transiciones##########################################-->
		   		
   		<!--Transición del location inicial al primer elemento-->	
		<transition>
		
			<label kind="synchronisation">
				<!--Accion de sincronizacion de tipo ? para que se sincronice al comenzar-->
				<xsl:text>parallel</xsl:text><xsl:value-of select="$id"/>			
				<xsl:text>?</xsl:text>
			</label>
			
			<!--Elemento source-->
			<xsl:element name="source">			
				<xsl:attribute name="ref">Init_Parallel<xsl:value-of select="$id"/></xsl:attribute>
			</xsl:element>
			
			<!--Elemento target-->
			<xsl:element name="target">
				<xsl:attribute name="ref"></xsl:attribute>
			</xsl:element>
				
		</transition>
		
		<xsl:for-each select="child::*[position()=2]">
					   		
			 <xsl:if test="(name()='noAction')">   				
					<xsl:call-template name="noAct_trans"></xsl:call-template>		
		     </xsl:if>
			
			 <xsl:if test="(name()='fail')">   				
					<xsl:call-template name="fail_trans"></xsl:call-template>		
		     </xsl:if>
		     
		     <xsl:if test="(name()='assign')">   				
					<xsl:call-template name="assign_trans"></xsl:call-template>		
		     </xsl:if>
		
			 <xsl:if test="name()='interaction'">
			    <xsl:call-template name="inter_trans"></xsl:call-template>		 
			 </xsl:if>
		
			 <xsl:if test="name()='workunit'">
			 	<xsl:call-template name="work_trans"><xsl:with-param name="nombre_proceso"><xsl:value-of select="$nombre_proceso"/></xsl:with-param>
			 	</xsl:call-template>
			 </xsl:if>
			 
			 <xsl:if test="name()='sequence'">			
				<xsl:call-template name="seq_trans">
		            <xsl:with-param name="nombre_proceso"><xsl:value-of select="$nombre_proceso"/></xsl:with-param>
		        </xsl:call-template>									
			 </xsl:if>
			 
			 <xsl:if test="name()='choice'">
			 	<xsl:call-template name="cho_trans">
				 	<xsl:with-param name="nombre_proceso"><xsl:value-of select="$nombre_proceso"/></xsl:with-param>
		   		</xsl:call-template>
			 </xsl:if>
			 
			 <xsl:if test="name()='parallel'">
		   	 	<xsl:call-template name="par_trans">
		   	 		<xsl:with-param name="nombre_proceso"><xsl:value-of select="$nombre_proceso"/></xsl:with-param>
		   	 	</xsl:call-template>
		   	 	
		   	 </xsl:if>		   	
			 
		</xsl:for-each>
		
		<!--Transición del último elemento al location inicial-->	
		<transition>
		
			<label kind="synchronisation">
				<!--Accion de sincronizacion de tipo ? para que se sincronice al comenzar-->
				<xsl:text>parallel</xsl:text><xsl:value-of select="$id"/>			
				<xsl:text>?</xsl:text>
			</label>
			
			<!--Elemento source-->
			<xsl:element name="source">			
				<xsl:attribute name="ref"></xsl:attribute>
			</xsl:element>
			
			<!--Elemento target-->
			<xsl:element name="target">
				<xsl:attribute name="ref">Init_Parallel<xsl:value-of select="$id"/></xsl:attribute>				
			</xsl:element>
				
		</transition>
		
		<!--################################Fin Transiciones##########################################-->
		
		</template>
				
	</xsl:for-each>
	
</xsl:for-each>	

<!--################################Plantilla para sincronizaciones urgentes###################################-->
<template>
			
	<name>
		<!--Nombre de la plantilla-->
		<xsl:text>Urgent_</xsl:text><xsl:value-of select="$nombre_proceso"/>
	</name>		
		
<!--################################Location##########################################-->

<!--Se añade un location de inicio (también es de finalización) para sincronizar-->
<xsl:element name="location">	
	
	<xsl:attribute name="id">Urgent</xsl:attribute>	
	<name>
		<xsl:attribute name="id">Urgent</xsl:attribute>
	</name>
</xsl:element>
<!--################################Fin Location##########################################-->
   		
   		
<!--################################Transition##########################################-->
   		
<!--Transición del location inicial a si mismo con sincronización urgente-->	
<transition>

	<label kind="synchronisation">
		<!--Accion de sincronizacion de tipo ?-->
		<xsl:text>urgent_chan</xsl:text>
		<xsl:text>?</xsl:text>
	</label>
	
	<!--Elemento source-->
	<xsl:element name="source">			
		<xsl:attribute name="ref">Urgent</xsl:attribute>
	</xsl:element>
	
	<!--Elemento target-->
	<xsl:element name="target">
		<xsl:attribute name="ref">Urgent</xsl:attribute>
	</xsl:element>
		
</transition>
<!--################################Fin Transition##########################################-->
</template>

<instantiation/>
  <system>	
	  <xsl:value-of select="'System'"/>
	  <xsl:text>;</xsl:text>
  </system>

</nta>
</xsl:template>


<!--################################Variables##########################################-->

<!--PLANTILLA PARA LAS VARIABLES DE TIPO CANAL-->
<xsl:template name="variable_canal">

	<!--Se define una variable de tipo canal por cada parallel que aparezca en la coreografía-->
	<xsl:for-each select="/descendant::parallel"> 
		<xsl:text>parallel</xsl:text><xsl:value-of select="count(preceding::parallel) + count(ancestor::parallel)"/><xsl:text>, </xsl:text>	
	</xsl:for-each>	
		
</xsl:template>

<!--PLANTILLA PARA LAS VARIABLES DE TIPO BOOLEANO-->
<xsl:template name="variable_boolean">
    
	<!--Se define una variable de tipo int[0,1] por cada variable booleana que aparezca en la coreografía-->
	<xsl:for-each select="package/choreography/variableDefinitions/variable"> 
	<xsl:if test="contains(@informationType,'boolean') or contains(@informationType,'Boolean')">
		
		<xsl:variable name="var" select="@name"/>
			
		<xsl:value-of select="$var"/>
		
		<!--Ver si existe alguna asignación inicial para esa variable-->
		<xsl:for-each select="../../assign/copy"> 
			
			<xsl:if test="target/@variable = $var ">
				
				<xsl:text>=</xsl:text>
				<xsl:value-of select="source/@expression"/>		
			
			</xsl:if>
			
		</xsl:for-each>
		
		<xsl:text>, </xsl:text>		
						
	</xsl:if>	
	</xsl:for-each>
	
	<!--Se define una variable booleana para controlar cada parallel que aparezca en la coreografía-->
	<xsl:for-each select="/descendant::parallel">		 
		<xsl:text>var_parallel</xsl:text><xsl:value-of select="count(preceding::parallel) + count(ancestor::parallel)"/>
		<xsl:text>, </xsl:text>
	</xsl:for-each>	
	
	<!--También se define una variable booleana por cada excepción que aparezca en el exception block-->
	<xsl:for-each select="package/choreography/exceptionBlock/workunit"> 	
		
		<xsl:text>exception_</xsl:text><xsl:value-of select="count(preceding-sibling::workunit)"/><xsl:text>=false</xsl:text>		
		
		<xsl:text>, </xsl:text>
	
	</xsl:for-each>
	
</xsl:template>

<!--PLANTILLA PARA LAS VARIABLES DE TIPO INT-->
<xsl:template name="variable_int">

	<!--Se define una variable de tipo int por cada variable entera que aparezca en la coreografía-->
	<xsl:for-each select="package/choreography/variableDefinitions/variable"> 	
	<xsl:if test="contains(@informationType,'int') or contains(@informationType,'Int')">
		<xsl:variable name="var" select="@name"/>
			
		<xsl:value-of select="$var"/>
		
		<!--Ver si existe alguna asignación inicial para esa variable-->	
		<xsl:for-each select="../../assign/copy"> 
			
			<xsl:if test="target/@variable = $var ">
				
				<xsl:text>=</xsl:text>
				<xsl:value-of select="source/@expression"/>		
			
			</xsl:if>
			
		</xsl:for-each>					
			
		<xsl:text>, </xsl:text>		
		
	</xsl:if>		
	</xsl:for-each>
</xsl:template>

<!--PLANTILLA PARA LAS VARIABLES DE TIPO RELOJ-->
<xsl:template name="variable_reloj">

	<!--Se define una variable de tipo clock por cada reloj que aparezca en la coreografía-->
	<xsl:for-each select="package/choreography/variableDefinitions/variable">
	<xsl:if test="contains(@informationType,'clock') or contains(@informationType,'Clock')">
		<xsl:value-of select="@name"/>
		<xsl:text>, </xsl:text>		
	</xsl:if>
	</xsl:for-each>
</xsl:template>

<!--################################Fin Variables##########################################-->



<!--################################Location Actividades##########################################-->

<!--PLANTILLA PARA LOS NOACTION-->
<xsl:template name="noAct">

<!--Se añade un location de inicio-->
<xsl:element name="location">
	<xsl:attribute name="id">Init_NoAction<xsl:value-of select="count(preceding::noAction)"/></xsl:attribute>
	<xsl:attribute name="type">noAct</xsl:attribute>
	<name>
		<xsl:attribute name="id">Init_NoAction<xsl:value-of select="count(preceding::noAction)"/></xsl:attribute>
	</name>
</xsl:element>

<!--Se añade un location de finalizacion-->
<xsl:element name="location">
	<xsl:attribute name="id">End_NoAction<xsl:value-of select="count(preceding::noAction)"/></xsl:attribute>
	<xsl:attribute name="type">noAct</xsl:attribute>
	<name>
		<xsl:attribute name="id">End_NoAction<xsl:value-of select="count(preceding::noAction)"/></xsl:attribute>
	</name>
</xsl:element>

</xsl:template>

<!--PLANTILLA PARA LOS FAIL-->
<xsl:template name="fail">

<!--Se añade un location de inicio-->
<xsl:element name="location">
	<xsl:attribute name="id">Init_Fail<xsl:value-of select="count(preceding::fail)"/></xsl:attribute>
	<xsl:attribute name="type">fail</xsl:attribute>
	<name>
		<xsl:attribute name="id">Init_Fail<xsl:value-of select="count(preceding::fail)"/></xsl:attribute>
	</name>
</xsl:element>

<!--Se añade un location de finalizacion (aunque no se alcanzará)-->
<xsl:element name="location">
	<xsl:attribute name="id">End_Fail<xsl:value-of select="count(preceding::fail)"/></xsl:attribute>
	<xsl:attribute name="type">fail</xsl:attribute>
	<name>
		<xsl:attribute name="id">End_Fail<xsl:value-of select="count(preceding::fail)"/></xsl:attribute>
	</name>
</xsl:element>

</xsl:template>

<!--PLANTILLA PARA LOS ASSIGN-->
<xsl:template name="assign">

<!--Se añade un location de inicio-->
<xsl:element name="location">
	<xsl:attribute name="id">Init_Assign<xsl:value-of select="count(preceding::assign)"/></xsl:attribute>
	<xsl:attribute name="type">assign</xsl:attribute>
	<name>
		<xsl:attribute name="id">Init_Assign<xsl:value-of select="count(preceding::assign)"/></xsl:attribute>
	</name>
</xsl:element>

<!--Se añade un location de finalizacion-->
<xsl:element name="location">
	<xsl:attribute name="id">End_Assign<xsl:value-of select="count(preceding::assign)"/></xsl:attribute>
	<xsl:attribute name="type">assign</xsl:attribute>
	<name>
		<xsl:attribute name="id">End_Assign<xsl:value-of select="count(preceding::assign)"/></xsl:attribute>
	</name>
</xsl:element>

</xsl:template>

<!--PLANTILLA PARA LAS INTERACCIONES-->
<xsl:template name="int">

<!--Se añade un location de inicio-->
<xsl:element name="location">

	<xsl:attribute name="id">Init_Interaction<xsl:value-of select="count(preceding::interaction)"/>_<xsl:value-of select="@name"/></xsl:attribute>
	<xsl:attribute name="type">interaction</xsl:attribute>

	<!--Si existe un timeout se añade un invariante-->
	<xsl:if test="timeout">
	
		<label kind='invariant'>
		
			<xsl:value-of select="normalize-space(substring-before(timeout/@time-to-complete,'&lt;='))"/><xsl:text> &lt;= </xsl:text><xsl:value-of select="normalize-space(substring-after(timeout/@time-to-complete,'&lt;=')) + 1"/>
		
		</label>
	
	</xsl:if>	
	
	<name>
		<xsl:attribute name="id">Init_Interaction<xsl:value-of select="count(preceding::interaction)"/>_<xsl:value-of select="@name"/></xsl:attribute>
	</name>
</xsl:element>

<!--Se añade un location de finalizacion-->
<xsl:element name="location">
	<xsl:attribute name="id">End_Interaction<xsl:value-of select="count(preceding::interaction)"/>_<xsl:value-of select="@name"/></xsl:attribute>
	<xsl:attribute name="type">interaction</xsl:attribute>
	<name>
		<xsl:attribute name="id">End_Interaction<xsl:value-of select="count(preceding::interaction)"/>_<xsl:value-of select="@name"/></xsl:attribute>
	</name>
</xsl:element>

</xsl:template>

<!--PLANTILLA PARA LOS SEQUENCE-->
<xsl:template name="seq">

<xsl:param name="nombre_proceso"/>

	<!--Marcar comienzo-->
	<SEQUENCE>
	
	<!--Para cada uno de los hijos del workunit-->
	<xsl:for-each select="child::*">
		
		<!--######################Si como hijo tiene un NOACTION######################-->
		<xsl:if test="(name()='noAction')">
			<xsl:call-template name="noAct">
			</xsl:call-template>
	 	</xsl:if>
	 	
	 	<!--######################Si como hijo tiene un FAIL######################-->
		<xsl:if test="(name()='fail')">
			<xsl:call-template name="fail">
			</xsl:call-template>
	 	</xsl:if>
	 	
	 	<!--######################Si como hijo tiene un ASSIGN######################-->
			<xsl:if test="(name()='assign')">
				<xsl:call-template name="assign">
				</xsl:call-template>
		 	</xsl:if>									
		
		<!--######################Si como hijo tiene un INTERACTION#####################-->
		<xsl:if test="name()='interaction'">
		  <xsl:call-template name="int">            
          </xsl:call-template>
		</xsl:if>
		
		<!--######################Si como hijo tiene un SEQUENCE######################-->
		<xsl:if test="name()='sequence'">			
			<xsl:call-template name="seq">
                <xsl:with-param name="nombre_proceso"><xsl:value-of select="$nombre_proceso"/></xsl:with-param>
            </xsl:call-template>									
		</xsl:if>
		
		<!--######################Si como hijo tiene un WORKUNIT#####################-->
		<xsl:if test="name()='workunit'">
		  <xsl:call-template name="work">
            <xsl:with-param name="nombre_proceso"><xsl:value-of select="$nombre_proceso"/></xsl:with-param>
          </xsl:call-template>
		</xsl:if>	
		
		<!--######################Si como hijo tiene un CHOICE#####################-->
		<xsl:if test="name()='choice'">			
			<xsl:call-template name="cho">
				<xsl:with-param name="nombre_proceso"><xsl:value-of select="$nombre_proceso"/></xsl:with-param>
			</xsl:call-template>
		</xsl:if>
		
		<!--######################Si como hijo tiene un PARALLEL#####################-->
		<xsl:if test="name()='parallel'">
		  <xsl:call-template name="par">
            <xsl:with-param name="nombre_proceso"><xsl:value-of select="$nombre_proceso"/></xsl:with-param>
          </xsl:call-template>
		</xsl:if>		
		
		<xsl:text> </xsl:text>

	</xsl:for-each>
	
	<!--Marcar final-->
	</SEQUENCE>
	
</xsl:template>

<!--PLANTILLA PARA LOS WORKUNIT-->
<xsl:template name="work">

<xsl:param name="nombre_proceso"/>

<!--Se añade un location de inicio-->
<xsl:element name="location">	
	
	<xsl:attribute name="id">Init_Workunit<xsl:value-of select="count(preceding::workunit) + count(ancestor::workunit)"/></xsl:attribute>
	<xsl:attribute name="type">workunit</xsl:attribute>
	<name>
		<xsl:attribute name="id">Init_Workunit<xsl:value-of select="count(preceding::workunit) + count(ancestor::workunit)"/></xsl:attribute>
	</name>
</xsl:element>

	<!--Marcar comienzo-->
	<WORKUNIT>
	
	<!--Para cada uno de los hijos del workunit-->
	<xsl:for-each select="child::*">
		
		<!--######################Si como hijo tiene un NOACTION######################-->
		<xsl:if test="(name()='noAction')">
			<xsl:call-template name="noAct">
			</xsl:call-template>
	 	</xsl:if>
	 	
	 	<!--######################Si como hijo tiene un FAIL######################-->
		<xsl:if test="(name()='fail')">
			<xsl:call-template name="fail">
			</xsl:call-template>
	 	</xsl:if>
	 	
	 	<!--######################Si como hijo tiene un ASSIGN######################-->
			<xsl:if test="(name()='assign')">
				<xsl:call-template name="assign">
				</xsl:call-template>
		 	</xsl:if>									
		
		<!--######################Si como hijo tiene un INTERACTION#####################-->
		<xsl:if test="name()='interaction'">
		  <xsl:call-template name="int">            
          </xsl:call-template>
		</xsl:if>
		
		<!--######################Si como hijo tiene un SEQUENCE######################-->
		<xsl:if test="name()='sequence'">			
			<xsl:call-template name="seq">
                <xsl:with-param name="nombre_proceso"><xsl:value-of select="$nombre_proceso"/></xsl:with-param>
            </xsl:call-template>									
		</xsl:if>
		
		<!--######################Si como hijo tiene un WORKUNIT#####################-->
		<xsl:if test="name()='workunit'">
		  <xsl:call-template name="work">
            <xsl:with-param name="nombre_proceso"><xsl:value-of select="$nombre_proceso"/></xsl:with-param>
          </xsl:call-template>
		</xsl:if>	
		
		<!--######################Si como hijo tiene un CHOICE#####################-->
		<xsl:if test="name()='choice'">			
			<xsl:call-template name="cho">
				<xsl:with-param name="nombre_proceso"><xsl:value-of select="$nombre_proceso"/></xsl:with-param>
			</xsl:call-template>
		</xsl:if>
		
		<!--######################Si como hijo tiene un PARALLEL#####################-->
		<xsl:if test="name()='parallel'">
		  <xsl:call-template name="par">
            <xsl:with-param name="nombre_proceso"><xsl:value-of select="$nombre_proceso"/></xsl:with-param>
          </xsl:call-template>
		</xsl:if>		
		
		<xsl:text> </xsl:text>

	</xsl:for-each>
	
	<!--Marcar final-->
	</WORKUNIT>
		
<!--Se añade un location de finalizacion-->
<xsl:element name="location">
	<xsl:attribute name="id">End_Workunit<xsl:value-of select="count(preceding::workunit) + count(ancestor::workunit)"/></xsl:attribute>
	<xsl:attribute name="type">workunit</xsl:attribute>
	<name>
		<xsl:attribute name="id">End_Workunit<xsl:value-of select="count(preceding::workunit) + count(ancestor::workunit)"/></xsl:attribute>
	</name>
</xsl:element>

</xsl:template>

<!--PLANTILLA PARA LOS CHOICE-->
<xsl:template name="cho">

<xsl:param name="nombre_proceso"/>

<!--Se añade un location de inicio-->
<xsl:element name="location">	
	
	<xsl:attribute name="id">Init_Choice<xsl:value-of select="count(preceding::choice) + count(ancestor::choice)"/></xsl:attribute>
	<xsl:attribute name="type">Choice</xsl:attribute>
	<name>
		<xsl:attribute name="id">Init_Choice<xsl:value-of select="count(preceding::choice) + count(ancestor::choice)"/></xsl:attribute>
	</name>
</xsl:element>

<!--Variable con el identificador del choice-->
<xsl:variable name="choice_id" select="count(preceding::choice) + count(ancestor::choice)"/>

<!--Marcar comienzo-->
<CHOICE>

<xsl:for-each select="child::*">
	
	<!--Se deja marcado donde empieza cada uno de los hijos-->	
	<CHOICECHILDIN>
		<xsl:attribute name="id"><xsl:value-of select="$choice_id"/></xsl:attribute>
		<xsl:attribute name="hijo"><xsl:value-of select="position()"/></xsl:attribute>
	</CHOICECHILDIN>	
			
	<!--######################Si como hijo tiene un NOACTION######################-->
	<xsl:if test="(name()='noAction')">
		<xsl:call-template name="noAct">
		</xsl:call-template>
 	</xsl:if>
 	
 	<!--######################No puede tener un FAIL como hijo######################-->
	
 	
 	<!--######################Si como hijo tiene un ASSIGN######################-->
		<xsl:if test="(name()='assign')">
			<xsl:call-template name="assign">
			</xsl:call-template>
	 	</xsl:if>									
	
	<!--######################Si como hijo tiene un INTERACTION#####################-->
	<xsl:if test="name()='interaction'">
	  <xsl:call-template name="int">            
      </xsl:call-template>
	</xsl:if>
	
	<!--######################Si como hijo tiene un SEQUENCE######################-->
	<xsl:if test="name()='sequence'">			
		<xsl:call-template name="seq">
            <xsl:with-param name="nombre_proceso"><xsl:value-of select="$nombre_proceso"/></xsl:with-param>
        </xsl:call-template>									
	</xsl:if>
	
	<!--######################Si como hijo tiene un WORKUNIT#####################-->
	<xsl:if test="name()='workunit'">
	  <xsl:call-template name="work">
        <xsl:with-param name="nombre_proceso"><xsl:value-of select="$nombre_proceso"/></xsl:with-param>
      </xsl:call-template>
	</xsl:if>	
	
	<!--######################No puede tener un CHOICE como hijo#####################-->
	
	
	<!--######################No puede tener un PARALLEL como hijo#####################-->		
	
	<xsl:text> </xsl:text>
		
	<!--Se deja marcado donde acaba cada uno de los hijos-->	
	<CHOICECHILDOUT>
		<xsl:attribute name="id"><xsl:value-of select="$choice_id"/></xsl:attribute>
		<xsl:attribute name="hijo"><xsl:value-of select="position()"/></xsl:attribute>
	</CHOICECHILDOUT>
	
</xsl:for-each>

<!--Marcar final-->
</CHOICE>

<!--Se añade un location de fin-->
<xsl:element name="location">	
	
	<xsl:attribute name="id">End_Choice<xsl:value-of select="count(preceding::choice) + count(ancestor::choice)"/></xsl:attribute>
	<xsl:attribute name="type">Choice</xsl:attribute>
	<name>
		<xsl:attribute name="id">End_Choice<xsl:value-of select="count(preceding::choice) + count(ancestor::choice)"/></xsl:attribute>
	</name>
</xsl:element>
	
</xsl:template>

<!--PLANTILLA PARA LOS PARALLEL-->
<xsl:template name="par">

<xsl:param name="nombre_proceso"/>

<!--Se añade un location de inicio del parallel-->
<xsl:element name="location">	
	
	<xsl:attribute name="id">Init_Parallel<xsl:value-of select="count(preceding::parallel) + count(ancestor::parallel)"/></xsl:attribute>
	<xsl:attribute name="type">Parallel</xsl:attribute>
	<name>
		<xsl:attribute name="id">Init_Parallel<xsl:value-of select="count(preceding::parallel) + count(ancestor::parallel)"/></xsl:attribute>
	</name>
</xsl:element>

<!--Marcar comienzo-->
<PARALLEL>
<xsl:attribute name="id"><xsl:value-of select="count(preceding::parallel) + count(ancestor::parallel)"/></xsl:attribute>

<xsl:for-each select="child::*[position()=1]">
				
    <!--######################Si como hijo tiene un NOACTION######################-->
	<xsl:if test="(name()='noAction')">
		<xsl:call-template name="noAct">
		</xsl:call-template>
 	</xsl:if>
 	
 	<!--######################Si como hijo tiene un FAIL######################-->
	<xsl:if test="(name()='fail')">
		<xsl:call-template name="fail">
		</xsl:call-template>
 	</xsl:if>
 	
 	<!--######################Si como hijo tiene un ASSIGN######################-->
		<xsl:if test="(name()='assign')">
			<xsl:call-template name="assign">
			</xsl:call-template>
	 	</xsl:if>									
	
	<!--######################Si como hijo tiene un INTERACTION#####################-->
	<xsl:if test="name()='interaction'">
	  <xsl:call-template name="int">            
      </xsl:call-template>
	</xsl:if>
	
	<!--######################Si como hijo tiene un SEQUENCE######################-->
	<xsl:if test="name()='sequence'">			
		<xsl:call-template name="seq">
            <xsl:with-param name="nombre_proceso"><xsl:value-of select="$nombre_proceso"/></xsl:with-param>
        </xsl:call-template>									
	</xsl:if>
	
	<!--######################Si como hijo tiene un WORKUNIT#####################-->
	<xsl:if test="name()='workunit'">
	  <xsl:call-template name="work">
        <xsl:with-param name="nombre_proceso"><xsl:value-of select="$nombre_proceso"/></xsl:with-param>
      </xsl:call-template>
	</xsl:if>	
	
	<!--######################Si como hijo tiene un CHOICE#####################-->
	<xsl:if test="name()='choice'">			
		<xsl:call-template name="cho">
			<xsl:with-param name="nombre_proceso"><xsl:value-of select="$nombre_proceso"/></xsl:with-param>
		</xsl:call-template>
	</xsl:if>
	
	<!--######################Si como hijo tiene un PARALLEL#####################-->
	<xsl:if test="name()='parallel'">
	  <xsl:call-template name="par">
        <xsl:with-param name="nombre_proceso"><xsl:value-of select="$nombre_proceso"/></xsl:with-param>
      </xsl:call-template>
	</xsl:if>		
	
	<xsl:text> </xsl:text>
</xsl:for-each>

<!--Marcar final-->
</PARALLEL>

<!--Se añade un location de finalización del parallel-->
<xsl:element name="location">	
	
	<xsl:attribute name="id">End_Parallel<xsl:value-of select="count(preceding::parallel) + count(ancestor::parallel)"/></xsl:attribute>
	<xsl:attribute name="type">Parallel</xsl:attribute>
	<name>
		<xsl:attribute name="id">End_Parallel<xsl:value-of select="count(preceding::parallel) + count(ancestor::parallel)"/></xsl:attribute>
	</name>
</xsl:element>

</xsl:template>

<!--################################Fin Location Actividades##########################################-->






<!--################################Transitions Actividades##########################################-->

<!--PLANTILLA PARA TRANSICIONES DE LOS NOACTION-->
<xsl:template name="noAct_trans">

	<transition>
	
	<!--Elemento source-->
	<xsl:element name="source">			
		<xsl:attribute name="ref">Init_NoAction<xsl:value-of select="count(preceding::noAction)"/></xsl:attribute>
	</xsl:element>
	
	<!--Elemento target-->
	<xsl:element name="target">
		<xsl:attribute name="ref">End_NoAction<xsl:value-of select="count(preceding::noAction)"/></xsl:attribute>
	</xsl:element>				
			
	</transition>
	
</xsl:template>

<!--PLANTILLA PARA TRANSICIONES DE LOS FAIL-->
<xsl:template name="fail_trans">

	<transition>
	
	<label kind="synchronisation">
		<!--Accion de sincronizacion de tipo !-->
		<xsl:text>urgent_chan</xsl:text>
		<xsl:text>!</xsl:text>
	</label>
	
	<!--Elemento source-->
	<xsl:element name="source">			
		<xsl:attribute name="ref">Init_Fail<xsl:value-of select="count(preceding::fail)"/></xsl:attribute>
	</xsl:element>
	
	<!--Elemento target-->
	<xsl:element name="target">
		<xsl:attribute name="ref">Exception</xsl:attribute>
	</xsl:element>				
			
	</transition>
	
</xsl:template>

<!--PLANTILLA PARA TRANSICIONES DE LOS ASSIGN-->
<xsl:template name="assign_trans">

	<transition>
	
	<!--Elemento para la asignación de la variable-->	
	<label kind="assignment">
		
		<!--Obtener el valor target y el valor source-->
								
		<xsl:value-of select="copy/target/@variable"/><xsl:text>=</xsl:text>
		
		<!--Si se trata de una variable-->
		<xsl:if test="copy/source/@variable">
			<xsl:value-of select="copy/source/@variable"/>
		</xsl:if>
		
		<!--Si se trata de una expresion-->
		<xsl:if test="copy/source/@expression">
			<xsl:value-of select="copy/source/@expression"/>
		</xsl:if>
		
	</label>
	
	<!--Elemento source-->
	<xsl:element name="source">			
		<xsl:attribute name="ref">Init_Assign<xsl:value-of select="count(preceding::assign)"/></xsl:attribute>
	</xsl:element>
	
	<!--Elemento target-->
	<xsl:element name="target">
		<xsl:attribute name="ref">End_Assign<xsl:value-of select="count(preceding::assign)"/></xsl:attribute>
	</xsl:element>				
			
	</transition>
	
</xsl:template>

<!--PLANTILLA PARA TRANSICIONES DE LAS INTERACCIONES-->
<xsl:template name="inter_trans">	
		
	<!--Si existe un timeout se debe añadir una transición para cuando se exceda el valor-->
	<xsl:if test="timeout">
	
		<xsl:variable name="time_res" select="timeout/@time-to-complete"/>		
	
		<transition>
		
		<!--Elemento para la guarda del timeout-->	
		<label kind="guard">
			
			<!--Obtener el valor del timeout y sumarle 1-->
			<xsl:value-of select="normalize-space(substring-before(timeout/@time-to-complete,'&lt;='))"/><xsl:text> == </xsl:text><xsl:value-of select="normalize-space(substring-after(timeout/@time-to-complete,'&lt;=')) + 1"/>
			
		</label>
		
		<!--Si hay una excepción que trata este timeout se debe poner su variable booleana correspondiente a true-->
		<xsl:for-each select="//package/choreography/exceptionBlock/workunit">
		
			<xsl:if test="contains(translate(substring-before(substring-after(@guard,'hasExceptionOccurred('),')'),' ',''),translate($time_res,' ',''))">
			
				<label kind="assignment">
				
					<xsl:text>exception_</xsl:text><xsl:value-of select="count(preceding-sibling::workunit)"/><xsl:text>=true</xsl:text>
				
				</label>
		
			</xsl:if>
			
		</xsl:for-each>
		
		<!--Elemento source-->
		<xsl:element name="source">			
			<xsl:attribute name="ref">Init_Interaction<xsl:value-of select="count(preceding::interaction)"/>_<xsl:value-of select="@name"/></xsl:attribute>
		</xsl:element>
		
		<!--Elemento target-->
		<xsl:element name="target">
			<xsl:attribute name="ref">Exception</xsl:attribute>
		</xsl:element>				
				
		</transition>
		
	</xsl:if>
	
	<!--Si puede generar una excepción la transición se debe generar una transición a exception-->
	<xsl:if test="exchange/@faultName">
	
		<xsl:variable name="excep_var" select="substring-after(exchange/@faultName,'ExchangeException')"/>
	
		<transition>
				
		<!--Se debe poner su variable booleana correspondiente a true-->
		<xsl:for-each select="//package/choreography/exceptionBlock/workunit">
		
			<xsl:if test="contains(translate(substring-before(substring-after(@guard,'hasExceptionOccurred('),')'),' ',''),translate($excep_var,' ',''))">
			
				<label kind="assignment">
				
					<xsl:text>exception_</xsl:text><xsl:value-of select="count(preceding-sibling::workunit)"/><xsl:text>=true</xsl:text>
				
				</label>
		
			</xsl:if>
			
		</xsl:for-each>
		
		<!--Elemento source-->
		<xsl:element name="source">			
			<xsl:attribute name="ref">Init_Interaction<xsl:value-of select="count(preceding::interaction)"/>_<xsl:value-of select="@name"/></xsl:attribute>
		</xsl:element>
		
		<!--Elemento target-->
		<xsl:element name="target">
			<xsl:attribute name="ref">Exception</xsl:attribute>
		</xsl:element>				
				
		</transition>
		
	</xsl:if>
	
	<transition>
	
	<!--Si existe un timeout se debe añadir una guarda a la transición-->
	<xsl:if test="timeout">
	
		<label kind="guard">
			
			<!--Obtener el valor-->
			<xsl:value-of select="timeout/@time-to-complete"/>
			
		</label>	
		
	</xsl:if>
	
	<!--Si existen actualizaciones de variables se deben añadir las asignaciones-->
	
	<xsl:for-each select="record">
	
		<label kind="assignment">
			
			<!--Obtener el valor-->
			<xsl:value-of select="target/@variable"/>=<xsl:value-of select="source/@variable"/>
			
		</label>	
		
	</xsl:for-each>
	
	<!--Si existe un intercambio de variables se debe añadir a las asignaciones-->
	
	<xsl:for-each select="exchange[@action='request']">
	
		<xsl:if test="send and receive">		
	
		<label kind="assignment">
			
			<xsl:value-of select="receive/@variable"/>=<xsl:value-of select="send/@variable"/>
			
		</label>
		
		</xsl:if>
		
	</xsl:for-each>
		
	<!--Elemento source-->
	<xsl:element name="source">			
		<xsl:attribute name="ref">Init_Interaction<xsl:value-of select="count(preceding::interaction)"/>_<xsl:value-of select="@name"/></xsl:attribute>
	</xsl:element>
	
	<!--Elemento target-->
	<xsl:element name="target">
		<xsl:attribute name="ref">End_Interaction<xsl:value-of select="count(preceding::interaction)"/>_<xsl:value-of select="@name"/></xsl:attribute>
	</xsl:element>				
			
	</transition>
	
</xsl:template>

<!--PLANTILLA PARA TRANSICIONES DE LOS SEQUENCE-->
<xsl:template name="seq_trans">

	<xsl:param name="nombre_proceso"/>
		
	<xsl:for-each select="child::*">
	
	 <xsl:if test="(name()='noAction')">   				
			<xsl:call-template name="noAct_trans"></xsl:call-template>		
     </xsl:if>
	
	 <xsl:if test="(name()='fail')">   				
			<xsl:call-template name="fail_trans"></xsl:call-template>		
     </xsl:if>
     
     <xsl:if test="(name()='assign')">   				
			<xsl:call-template name="assign_trans"></xsl:call-template>		
     </xsl:if>

	 <xsl:if test="name()='interaction'">
	    <xsl:call-template name="inter_trans"></xsl:call-template>		 
	 </xsl:if>

	 <xsl:if test="name()='workunit'">
	 	<xsl:call-template name="work_trans"><xsl:with-param name="nombre_proceso"><xsl:value-of select="$nombre_proceso"/></xsl:with-param>
	 	</xsl:call-template>		 
	 	
	 </xsl:if>
	 
	 <xsl:if test="name()='sequence'">			
		<xsl:call-template name="seq_trans">
            <xsl:with-param name="nombre_proceso"><xsl:value-of select="$nombre_proceso"/></xsl:with-param>
        </xsl:call-template>									
	 </xsl:if>
	 
	 <xsl:if test="name()='choice'">
	 	<xsl:call-template name="cho_trans">
		 	<xsl:with-param name="nombre_proceso"><xsl:value-of select="$nombre_proceso"/></xsl:with-param>
   		</xsl:call-template>
	 </xsl:if>
	 
	 <xsl:if test="name()='parallel'">
   	 	<xsl:call-template name="par_trans">
   	 		<xsl:with-param name="nombre_proceso"><xsl:value-of select="$nombre_proceso"/></xsl:with-param>
   	 	</xsl:call-template>
   	 	
   	 </xsl:if>
	 
	</xsl:for-each>
	
</xsl:template>

<!--PLANTILLA PARA TRANSICIONES DE LOS WORKUNIT-->
<xsl:template name="work_trans">

	<xsl:param name="nombre_proceso"/>	
	
	<xsl:variable name="repeticion" select="@repeat"/>
	<xsl:variable name="restriccion" select="@guard"/>	
	
	
	<!--Si existe guarda y el workunit no es bloqueante se debe añadir la transición al final con la guarda negada, a no ser que se encuentre dentro de un CHOICE-->
	<xsl:if test="$restriccion!='' and @block='false' and name(parent::*)!='choice'">
	
		<transition>
		
			<label kind="guard">			
				
				<xsl:call-template name="guarda_salida_invertida"><xsl:with-param name="guard" select="$restriccion"/></xsl:call-template>
				
			</label>
			
			<!--Elemento source-->
			<xsl:element name="source">			
				<xsl:attribute name="ref">Init_Workunit<xsl:value-of select="count(preceding::workunit) + count(ancestor::workunit)"/></xsl:attribute>
			</xsl:element>
			
			<!--Elemento target (por el momento queda vacio)-->
			<xsl:element name="target">
				<xsl:attribute name="ref">End_Workunit<xsl:value-of select="count(preceding::workunit) + count(ancestor::workunit)"/></xsl:attribute>
			</xsl:element>				
				
		</transition>
		
	</xsl:if>
	
	<!--Transición de Init al primer elemento-->	
	<transition>
	
	<!--Si existe una guarda se debe añadir a la transición-->
	<xsl:if test="$restriccion!=''">
	
		<label kind="guard">
			
			<xsl:call-template name="guarda_salida"><xsl:with-param name="guard" select="$restriccion"/></xsl:call-template>
			
		</label>	
		
	</xsl:if>		
		
	<!--Elemento source-->
	<xsl:element name="source">			
		<xsl:attribute name="ref">Init_Workunit<xsl:value-of select="count(preceding::workunit) + count(ancestor::workunit)"/></xsl:attribute>
	</xsl:element>
	
	<!--Elemento target-->
	<xsl:element name="target">
		<xsl:attribute name="ref"></xsl:attribute>
	</xsl:element>				
			
	</transition>
	
	<!--Marcar comienzo-->
	<WORKUNITIN>
		<xsl:attribute name="id"><xsl:value-of select="count(preceding::workunit) + count(ancestor::workunit)"/></xsl:attribute>
		<xsl:attribute name="repeat"><xsl:value-of select="$repeticion"/></xsl:attribute>
		<xsl:attribute name="restriccion"><xsl:value-of select="$restriccion"/></xsl:attribute>
	</WORKUNITIN>
	
	<xsl:for-each select="child::*">
	
	 <xsl:if test="(name()='noAction')">   				
			<xsl:call-template name="noAct_trans"></xsl:call-template>		
     </xsl:if>
	
	 <xsl:if test="(name()='fail')">   				
			<xsl:call-template name="fail_trans"></xsl:call-template>		
     </xsl:if>
     
     <xsl:if test="(name()='assign')">   				
			<xsl:call-template name="assign_trans"></xsl:call-template>		
     </xsl:if>

	 <xsl:if test="name()='interaction'">
	    <xsl:call-template name="inter_trans"></xsl:call-template>		 
	 </xsl:if>

	 <xsl:if test="name()='workunit'">
	 	<xsl:call-template name="work_trans"><xsl:with-param name="nombre_proceso"><xsl:value-of select="$nombre_proceso"/></xsl:with-param>
	 	</xsl:call-template>		 
	 	
	 </xsl:if>
	 
	 <xsl:if test="name()='sequence'">			
		<xsl:call-template name="seq_trans">
            <xsl:with-param name="nombre_proceso"><xsl:value-of select="$nombre_proceso"/></xsl:with-param>
        </xsl:call-template>									
	 </xsl:if>
	 
	 <xsl:if test="name()='choice'">
	 	<xsl:call-template name="cho_trans">
		 	<xsl:with-param name="nombre_proceso"><xsl:value-of select="$nombre_proceso"/></xsl:with-param>
   		</xsl:call-template>
	 </xsl:if>
	 
	 <xsl:if test="name()='parallel'">
   		<xsl:call-template name="par_trans">
   			<xsl:with-param name="nombre_proceso"><xsl:value-of select="$nombre_proceso"/></xsl:with-param>   			
   		</xsl:call-template>
   		
   	</xsl:if>
	 
	</xsl:for-each>
	
	<!--Marcar final-->
	<WORKUNITOUT>
		<xsl:attribute name="id"><xsl:value-of select="count(preceding::workunit) + count(ancestor::workunit)"/></xsl:attribute>
		<xsl:attribute name="repeat"><xsl:value-of select="$repeticion"/></xsl:attribute>
		<xsl:attribute name="restriccion"><xsl:value-of select="$restriccion"/></xsl:attribute>
	</WORKUNITOUT>
	
	<!--Transición de último elemento a End-->	
	<transition>
	
	<!--Si existe un repeat se debe añadir a la transición negado-->
	<xsl:if test="$repeticion!=''">
	
		<label kind="guard">
			
			<xsl:call-template name="guarda_salida_invertida"><xsl:with-param name="guard" select="$repeticion"/></xsl:call-template>
			
		</label>	
		
	</xsl:if>		
		
	<!--Elemento source-->
	<xsl:element name="source">			
		<xsl:attribute name="ref"></xsl:attribute>
	</xsl:element>
	
	<!--Elemento target-->
	<xsl:element name="target">
		<xsl:attribute name="ref">End_Workunit<xsl:value-of select="count(preceding::workunit) + count(ancestor::workunit)"/></xsl:attribute>
	</xsl:element>				
			
	</transition>
			
</xsl:template>

<!--PLANTILLA PARA TRANSICIONES DEL CHOICE-->
<xsl:template name="cho_trans">

	<xsl:param name="nombre_proceso"/>

	<!--Variable con el identificador del choice-->
	<xsl:variable name="choice_id" select="count(preceding::choice) + count(ancestor::choice)"/>	
	
	<xsl:for-each select="child::*">
	
		<!--Transición de Init al primer elemento de cada hijo-->	
		<transition>		
					
		<!--Elemento source-->
		<xsl:element name="source">			
			<xsl:attribute name="ref">Init_Choice<xsl:value-of select="$choice_id"/></xsl:attribute>
		</xsl:element>
		
		<!--Elemento target-->
		<xsl:element name="target">
			<xsl:attribute name="ref"></xsl:attribute>
		</xsl:element>				
				
		</transition>
	 
		 <!--Marcar comienzo cada uno de los hijos del choice-->
		 <CHOICECHILDIN>
			<xsl:attribute name="id"><xsl:value-of select="$choice_id"/></xsl:attribute>
			<xsl:attribute name="hijo"><xsl:value-of select="position()"/></xsl:attribute>
		</CHOICECHILDIN>
		 
		 <xsl:if test="(name()='noAction')">   				
			<xsl:call-template name="noAct_trans"></xsl:call-template>		
	     </xsl:if>
		
		 <!--NO PUEDE SER UN FAIL-->
	     
	     <xsl:if test="(name()='assign')">   				
				<xsl:call-template name="assign_trans"></xsl:call-template>		
	     </xsl:if>
	
		 <xsl:if test="name()='interaction'">
		    <xsl:call-template name="inter_trans"></xsl:call-template>		 
		 </xsl:if>
	
		 <xsl:if test="name()='workunit'">
		 	<xsl:call-template name="work_trans"><xsl:with-param name="nombre_proceso"><xsl:value-of select="$nombre_proceso"/></xsl:with-param>
		 	</xsl:call-template>
		 </xsl:if>
		 
		 <xsl:if test="name()='sequence'">			
			<xsl:call-template name="seq_trans">
	            <xsl:with-param name="nombre_proceso"><xsl:value-of select="$nombre_proceso"/></xsl:with-param>
	        </xsl:call-template>									
		 </xsl:if>
		 
		<!--NO PUEDE SER UN CHOICE-->
     	
     	<!--NO PUEDE SER UN PARALLEL-->
     	
	   	 
	   	<!--Marcar final cada uno de los hijos del choice-->
	   	<CHOICECHILDOUT>
		 <xsl:attribute name="id"><xsl:value-of select="$choice_id"/></xsl:attribute>
		 <xsl:attribute name="hijo"><xsl:value-of select="position()"/></xsl:attribute>
		</CHOICECHILDOUT>
		 
		<!--Transición del ultimo elemento de cada hijo al End-->	
		<transition>
		
		<label kind="synchronisation">
			<!--Accion de sincronizacion de tipo !-->
			<xsl:text>urgent_chan</xsl:text>
			<xsl:text>!</xsl:text>
		</label>
					
		<!--Elemento source-->
		<xsl:element name="source">			
			<xsl:attribute name="ref"></xsl:attribute>			
		</xsl:element>
		
		<!--Elemento target-->
		<xsl:element name="target">
			<xsl:attribute name="ref">End_Choice<xsl:value-of select="$choice_id"/></xsl:attribute>
		</xsl:element>				
				
		</transition>
	 
	 </xsl:for-each>
	 		  	 	
</xsl:template>

<!--PLANTILLA PARA TRANSICIONES DEL PARALLEL-->
<xsl:template name="par_trans">
	
	<xsl:param name="nombre_proceso"/>		
	
	<!--Transición del location inicial al primer elemento-->	
	<transition>
	
		<label kind="synchronisation">
			<!--Accion de sincronizacion de tipo ! para que se sincronice al comenzar-->
			<xsl:text>parallel</xsl:text><xsl:value-of select="count(preceding::parallel) + count(ancestor::parallel)"/>
			<xsl:text>!</xsl:text>
		</label>
		
		<label kind="assignment">
		
			<!--Poner a 0 la variable booleana correspondiente al parallel-->									
			<xsl:text>var_parallel</xsl:text><xsl:value-of select="count(preceding::parallel) + count(ancestor::parallel)"/><xsl:text>=0</xsl:text>
			
		</label>
		
		<!--Elemento source-->
		<xsl:element name="source">			
			<xsl:attribute name="ref">Init_Parallel<xsl:value-of select="count(preceding::parallel) + count(ancestor::parallel)"/></xsl:attribute>
		</xsl:element>
		
		<!--Elemento target-->
		<xsl:element name="target">
			<xsl:attribute name="ref"></xsl:attribute>
		</xsl:element>
			
	</transition>
	
	<xsl:for-each select="child::*[position()=1]">
				   		
		 <xsl:if test="(name()='noAction')">   				
				<xsl:call-template name="noAct_trans"></xsl:call-template>		
	     </xsl:if>
		
		 <xsl:if test="(name()='fail')">   				
				<xsl:call-template name="fail_trans"></xsl:call-template>		
	     </xsl:if>
	     
	     <xsl:if test="(name()='assign')">   				
				<xsl:call-template name="assign_trans"></xsl:call-template>		
	     </xsl:if>
	
		 <xsl:if test="name()='interaction'">
		    <xsl:call-template name="inter_trans"></xsl:call-template>		 
		 </xsl:if>
	
		 <xsl:if test="name()='workunit'">
		 	<xsl:call-template name="work_trans"><xsl:with-param name="nombre_proceso"><xsl:value-of select="$nombre_proceso"/></xsl:with-param>
		 	</xsl:call-template>
		 	
		 </xsl:if>
		 
		 <xsl:if test="name()='sequence'">			
			<xsl:call-template name="seq_trans">
	            <xsl:with-param name="nombre_proceso"><xsl:value-of select="$nombre_proceso"/></xsl:with-param>
	        </xsl:call-template>									
		 </xsl:if>
		 
		 <xsl:if test="name()='choice'">
		 	<xsl:call-template name="cho_trans">
			 	<xsl:with-param name="nombre_proceso"><xsl:value-of select="$nombre_proceso"/></xsl:with-param>
	   		</xsl:call-template>
		 </xsl:if>
		 
		 <xsl:if test="name()='parallel'">
	   	 	<xsl:call-template name="par_trans">
	   	 		<xsl:with-param name="nombre_proceso"><xsl:value-of select="$nombre_proceso"/></xsl:with-param>
	   	 	</xsl:call-template>
	   	 	
	   	 </xsl:if>		   	
		 
	</xsl:for-each>
	
	<!--Transición del último elemento al location inicial-->	
	<transition>
	
		<label kind="synchronisation">
			<!--Accion de sincronizacion de tipo ! para que se sincronice al terminar-->
			<xsl:text>parallel</xsl:text><xsl:value-of select="count(preceding::parallel) + count(ancestor::parallel)"/>			
			<xsl:text>!</xsl:text>
		</label>
		
		<!--Elemento source-->
		<xsl:element name="source">			
			<xsl:attribute name="ref"></xsl:attribute>
		</xsl:element>
		
		<!--Elemento target-->
		<xsl:element name="target">
			<xsl:attribute name="ref">End_Parallel<xsl:value-of select="count(preceding::parallel) + count(ancestor::parallel)"/></xsl:attribute>				
		</xsl:element>
			
	</transition>	
			  	 	
</xsl:template>

<!--################################Fin Transitions Actividades##########################################-->






<!--################################Otras plantillas##########################################-->

<!--PLANTILLA PARA LAS GUARDAS DE LAS TRANSICIONES-->
<xsl:template name="guarda_salida">
<xsl:param name="guard" select="@guard"/>

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

</xsl:template>

<!--PLANTILLA PARA LAS GUARDAS DE LAS TRANSICIONES ALTERNATIVAS-->
<xsl:template name="guarda_salida_invertida">
<xsl:param name="guard" select="@guard"/>

<!--Realizar la negación recursivamente utilizando las leyes de Morgan-->

<!--En primer lugar se debe mirar si es una expresión que contenga paréntesis-->
<xsl:if test="contains($guard,'(')">

	<!--Ver si la expresión está ya negada o no-->	
	<xsl:if test="starts-with(normalize-space($guard),'not')">
		
		<xsl:call-template name="subexpresion_negada">
			<xsl:with-param name="guard" select="$guard"/>
			<xsl:with-param name="par_abiertos" select="'1'"/>
			<xsl:with-param name="cad_actual" select="substring-after($guard,'(')"/>			
		</xsl:call-template>
	</xsl:if>
	
	<xsl:if test="not(starts-with(normalize-space($guard),'not'))">
		
		<xsl:call-template name="subexpresion">
			<xsl:with-param name="guard" select="$guard"/>
			<xsl:with-param name="par_abiertos" select="'1'"/>
			<xsl:with-param name="cad_actual" select="substring-after($guard,'(')"/>
			<xsl:with-param name="es_negada" select="'false'"/>
		</xsl:call-template>
	</xsl:if>

</xsl:if>

<!--Si ya no contiene paréntesis hemos llegado al final de la recursión-->
<xsl:if test="not(contains($guard,'('))">

	 <!--Ver si se trata de alguna de las posibles expresiones relacionales-->
	 <xsl:if test="contains($guard,'&lt;=')">
	  <xsl:variable name="parametro1" select="substring-before($guard,'&lt;=')"/>			  
      <xsl:variable name="parametro2" select="substring-after($guard,'&lt;=')"/>
	   <xsl:value-of select="$parametro1"/>&gt;<xsl:value-of select="$parametro2"/>
	 </xsl:if>
	 <xsl:if test="contains($guard,'&gt;=')">
	  <xsl:variable name="parametro1" select="substring-before($guard,'&gt;=')"/>			  
      <xsl:variable name="parametro2" select="substring-after($guard,'&gt;=')"/>
	   <xsl:value-of select="$parametro1"/>&lt;<xsl:value-of select="$parametro2"/>
	 </xsl:if>
	 <xsl:if test="contains($guard,'&lt;') and not(contains($guard,'&lt;='))">
	  <xsl:variable name="parametro1" select="substring-before($guard,'&lt;')"/>			  
      <xsl:variable name="parametro2" select="substring-after($guard,'&lt;')"/>
	   <xsl:value-of select="$parametro1"/>&gt;=<xsl:value-of select="$parametro2"/>
	 </xsl:if>
	 <xsl:if test="contains($guard,'&gt;') and not(contains($guard,'&gt;='))">
	  <xsl:variable name="parametro1" select="substring-before($guard,'&gt;')"/>			  
      <xsl:variable name="parametro2" select="substring-after($guard,'&gt;')"/>
	   <xsl:value-of select="$parametro1"/>&lt;=<xsl:value-of select="$parametro2"/>
	 </xsl:if>
	 
	 <!--Ver si se trata de una expresión de desigualdad-->
	 <xsl:if test="contains($guard,'!=')">	  
	  <xsl:variable name="parametro1" select="substring-before($guard,'!=')"/>			  
      <xsl:variable name="parametro2" select="substring-after($guard,'!=')"/>
	   <xsl:value-of select="$parametro1"/>==<xsl:value-of select="$parametro2"/>
	 </xsl:if>
	 <!--Si se trata de cambiar una igualdad por una desigualdad se debe tener cuidado en el caso de que uno de los parámetros sea un relog-->
	 <xsl:if test="contains($guard,'==')">	   
	  <xsl:variable name="parametro1" select="normalize-space(substring-before($guard,'=='))"/>			  
      <xsl:variable name="parametro2" select="normalize-space(substring-after($guard,'=='))"/>
      
       <xsl:if test="//package/choreography/variableDefinitions/variable[(@name=$parametro1 or @name=$parametro2) and @informationType='tns:Clock']">        	
       	<xsl:text>(</xsl:text><xsl:value-of select="$parametro1"/>&lt;<xsl:value-of select="$parametro2"/>) or (<xsl:value-of select="$parametro1"/>&gt;<xsl:value-of select="$parametro2"/><xsl:text>)</xsl:text>
       </xsl:if>
       
       <xsl:if test="not(//package/choreography/variableDefinitions/variable[(@name=$parametro1 or @name=$parametro2) and @informationType='tns:Clock'])"> 
       	<xsl:value-of select="$parametro1"/>!=<xsl:value-of select="$parametro2"/>
       </xsl:if>
       	   
	 </xsl:if>
	 

</xsl:if>

</xsl:template>

<xsl:template name="subexpresion">
<xsl:param name="guard" select="@guard"/>
<xsl:param name="par_abiertos" select="@par_abiertos"/>
<xsl:param name="cad_actual" select="@cad_actual"/>
<xsl:param name="es_negada" select="@es_negada"/>

<!--Ver si lo siguiente que contiene es un paréntesis abierto o un paréntesis cerrado-->

<!--Si lo siguiente que contiene es un paréntesis cerrado se tiene que mirar si es el que cierra al primero encontrado-->
<xsl:if test="not(contains($cad_actual,'(')) or (string-length(substring-before($cad_actual,'(')) &gt; string-length(substring-before($cad_actual,')')))">

	<xsl:variable name="par_actual" select="$par_abiertos - 1"/>
	
	<!--Si el valor es 0 ya se ha llegado al final de la expresión actual-->
	<xsl:if test="$par_actual = 0">	
	
		<xsl:variable name="cad_restante" select="substring-after($cad_actual,')')"/>
		
		<!--Ver si estamos dentro de una expresión negada o no-->	
		<xsl:if test="$es_negada = 'false'">

			<xsl:variable name="cad_recursion" select="substring-before($guard,$cad_restante)"/>
			
			<xsl:if test="$cad_recursion != ''">		
			
				<!--Llamar a la función de guarda invertida para el contenido entre los paréntesis-->		
				<xsl:text>(</xsl:text><xsl:call-template name="guarda_salida_invertida"><xsl:with-param name="guard" select="substring($cad_recursion,2,string-length($cad_recursion)-2)"/></xsl:call-template><xsl:text>)</xsl:text>
			
			</xsl:if>
			
			<xsl:if test="$cad_recursion = ''">		
			
				<!--Llamar a la función de guarda invertida para el contenido entre los paréntesis-->		
				<xsl:text>(</xsl:text><xsl:call-template name="guarda_salida_invertida"><xsl:with-param name="guard" select="substring($guard,2,string-length($guard)-2)"/></xsl:call-template><xsl:text>)</xsl:text>
			
			</xsl:if>
			
		</xsl:if>
		
		<xsl:if test="$es_negada = 'true'">

			<xsl:variable name="cad_negada" select="substring-before($guard,$cad_restante)"/>
		
			<xsl:if test="$cad_negada != ''">		
				
				<!--Dejar todo lo que haya dentro del not como esté-->		
				<xsl:text>(</xsl:text><xsl:value-of select="substring($cad_negada,5,string-length($cad_negada)-5)"/><xsl:text>)</xsl:text>
			
			</xsl:if>
			
			<xsl:if test="$cad_negada = ''">		
				
				<!--Dejar todo lo que haya dentro del not como esté-->		
				<xsl:text>(</xsl:text><xsl:value-of select="substring($guard,5,string-length($guard)-5)"/><xsl:text>)</xsl:text>
			
			</xsl:if>
		
		</xsl:if>
			
		<!--Poner el and o el or opuesto a la expresión actual si quedan expresiones-->
		<xsl:if test="starts-with(normalize-space($cad_restante),'and')">
		
			<xsl:text> or </xsl:text>
									
			<!--Llamar a la función de guarda invertida para el contenido restante-->
			<xsl:call-template name="guarda_salida_invertida"><xsl:with-param name="guard" select="normalize-space(substring-after($cad_restante,'and'))"/></xsl:call-template>
		
		</xsl:if>
		
		<xsl:if test="starts-with(normalize-space($cad_restante),'or')">
		
			<xsl:text> and </xsl:text>
			
			<!--Llamar a la función de guarda invertida para el contenido restante-->
			<xsl:call-template name="guarda_salida_invertida"><xsl:with-param name="guard" select="normalize-space(substring-after($cad_restante,'or'))"/></xsl:call-template>
		
		</xsl:if>		
			
	</xsl:if>
	
	<xsl:if test="$par_actual != 0">
		
		<!--Llamada recursiva a la función-->
		<xsl:call-template name="subexpresion">
			<xsl:with-param name="guard" select="$guard"/>
			<xsl:with-param name="par_abiertos" select="$par_actual"/>
			<xsl:with-param name="cad_actual" select="substring-after($cad_actual,')')"/>
			<xsl:with-param name="es_negada" select="$es_negada"/>
		</xsl:call-template>
	
	</xsl:if>
	
</xsl:if>

<!--Si lo siguiente que contiene es un paréntesis abierto se tiene que aumentar el nivel de anidamiento-->
<xsl:if test="contains($cad_actual,'(') and (string-length(substring-before($cad_actual,'(')) &lt; string-length(substring-before($cad_actual,')')))">

	<xsl:variable name="par_actual" select="$par_abiertos + 1"/>	
		
	<xsl:if test="$par_actual != 0">	
		
		<!--Llamada recursiva a la función-->
		<xsl:call-template name="subexpresion">
			<xsl:with-param name="guard" select="$guard"/>
			<xsl:with-param name="par_abiertos" select="$par_actual"/>
			<xsl:with-param name="cad_actual" select="substring-after($cad_actual,'(')"/>
			<xsl:with-param name="es_negada" select="$es_negada"/>
		</xsl:call-template>
	
	</xsl:if>
	
</xsl:if>

</xsl:template>

<xsl:template name="subexpresion_negada">
<xsl:param name="guard" select="@guard"/>
<xsl:param name="par_abiertos" select="@par_abiertos"/>
<xsl:param name="cad_actual" select="@cad_actual"/>

<!--Ver si lo siguiente que contiene es un paréntesis abierto o un paréntesis cerrado-->

<!--Si lo siguiente que contiene es un paréntesis cerrado se tiene que mirar si es el que cierra al primero encontrado-->
<xsl:if test="not(contains($cad_actual,'(')) or (string-length(substring-before($cad_actual,'(')) &gt; string-length(substring-before($cad_actual,')')))">

	<xsl:variable name="par_actual" select="$par_abiertos - 1"/>
	
	<!--Si el valor es 0 ya se ha llegado al final de la expresión actual-->
	<xsl:if test="$par_actual = 0">	
		
		<xsl:variable name="cad_restante" select="substring-after($cad_actual,')')"/>
		<xsl:variable name="cad_negada" select="substring-before($guard,$cad_restante)"/>
		
		<xsl:if test="$cad_negada != ''">		
			
			<!--Dejar todo lo que haya dentro del not como esté-->		
			<xsl:text>(</xsl:text><xsl:value-of select="substring($cad_negada,5,string-length($cad_negada)-5)"/><xsl:text>)</xsl:text>
		
		</xsl:if>
		
		<xsl:if test="$cad_negada = ''">		
			
			<!--Dejar todo lo que haya dentro del not como esté-->		
			<xsl:text>(</xsl:text><xsl:value-of select="substring($guard,5,string-length($guard)-5)"/><xsl:text>)</xsl:text>
		
		</xsl:if>
		
		<!--Poner el and o el or opuesto a la expresión actual si quedan expresiones-->
		<xsl:if test="starts-with(normalize-space($cad_restante),'and')">		
					
			<xsl:text> or </xsl:text>
			
			<!--Llamar a la función de guarda invertida para el contenido restante-->
			<xsl:call-template name="guarda_salida_invertida"><xsl:with-param name="guard" select="normalize-space(substring-after($cad_restante,'and'))"/></xsl:call-template>
		
		</xsl:if>
		
		<xsl:if test="starts-with(normalize-space($cad_restante),'or')">		
					
			<xsl:text> and </xsl:text>
			
			<!--Llamar a la función de guarda invertida para el contenido restante-->
			<xsl:call-template name="guarda_salida_invertida"><xsl:with-param name="guard" select="normalize-space(substring-after($cad_restante,'or'))"/></xsl:call-template>
		
		</xsl:if>		
			
	</xsl:if>
	
	<xsl:if test="$par_actual != 0">
		
		<!--Llamada recursiva a la función-->
		<xsl:call-template name="subexpresion">
			<xsl:with-param name="guard" select="$guard"/>
			<xsl:with-param name="par_abiertos" select="$par_actual"/>
			<xsl:with-param name="cad_actual" select="substring-after($cad_actual,')')"/>
			<xsl:with-param name="es_negada" select="'true'"/>
		</xsl:call-template>
	
	</xsl:if>
	
</xsl:if>

<!--Si lo siguiente que contiene es un paréntesis abierto se tiene que aumentar el nivel de anidamiento-->
<xsl:if test="contains($cad_actual,'(') and (string-length(substring-before($cad_actual,'(')) &lt; string-length(substring-before($cad_actual,')')))">

	<xsl:variable name="par_actual" select="$par_abiertos + 1"/>	
		
	<xsl:if test="$par_actual != 0">
		
		<!--Llamada recursiva a la función-->
		<xsl:call-template name="subexpresion">
			<xsl:with-param name="guard" select="$guard"/>
			<xsl:with-param name="par_abiertos" select="$par_actual"/>
			<xsl:with-param name="cad_actual" select="substring-after($cad_actual,'(')"/>
			<xsl:with-param name="es_negada" select="'true'"/>
		</xsl:call-template>
	
	</xsl:if>
	
</xsl:if>

</xsl:template>

</xsl:stylesheet>