<?xml version='1.0'?>

<xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform">
	<xsl:output method="xml" indent="yes" doctype-public="-//Uppaal Team//DTD Flat System 1.0//EN" doctype-system="http://www.docs.uu.se/docs/rtmv/uppaal/xml/flat-1_0.dtd"/>
<xsl:template match="/">
<nta>
<declaration>

	<xsl:value-of select="//declaration"/>	

</declaration>

 <xsl:for-each select="nta/template"> 
  
 <template>
 <name>
   <xsl:value-of select="name"/>
 </name>
 
 <!--Declaración de las variables locales-->
 <declaration>
 	<xsl:value-of select="declaration"/>
 </declaration>
 
 <xsl:for-each select="location"> 
      
  <xsl:element name="location">
   <xsl:attribute name="id">
    <xsl:value-of select="@id"/>	
   </xsl:attribute>
    <name><xsl:value-of select="@id"/></name> 
    
    <!--Añadir las invariantes (por el momento se quitan las del parallel)-->
    <xsl:if test="label[@kind='invariant' and not(contains(.,'var_parallel'))]">
    
    	<label kind="invariant">
    	    
	    <xsl:for-each select="label[@kind='invariant']">
	    	
	    	
	    	<xsl:if test="position()=1">
		    		    
				<xsl:text>(</xsl:text><xsl:value-of select="."/><xsl:text>)</xsl:text>
			    
			</xsl:if>
			
			<xsl:if test="position()!=1">
		    	
				<xsl:text> and (</xsl:text><xsl:value-of select="."/><xsl:text>)</xsl:text>
			    
			</xsl:if>
				    
	    </xsl:for-each>
	    
	    </label>
    
    </xsl:if>    
      
  </xsl:element>

  </xsl:for-each>
  
  <!--Se debe indicar cual es el nodo inicial, que será aquel que aparezca justo despues de Exception-->
  <xsl:for-each select="location[preceding-sibling::*[1]/@id='Exception']">  
  	<init>
  	<xsl:attribute name="ref">
		<xsl:value-of select="@id"/>
	</xsl:attribute>
	</init>
  </xsl:for-each>
  
  <!--En el caso de la plantilla para la sincronización urgente el nodo inicial será el llamado 'Urgent'-->
  <xsl:for-each select="location[@id='Urgent']">  
  	<init>
  	<xsl:attribute name="ref">
		<xsl:value-of select="@id"/>
	</xsl:attribute>
	</init>
  </xsl:for-each>
  
  <!--Se deben añadir transiciones de los inicios de los CHOICE a Exception cuando sea necesario-->
  <xsl:for-each select="location[child::choice_invariant]">  
  	
	<transition>
	
		 <xsl:element name="source">
	      <xsl:attribute name="ref">
	        <xsl:value-of  select="@id"/>			     
	      </xsl:attribute>
		 </xsl:element>
		 
		 <xsl:element name="target">
		  <xsl:attribute name="ref">
		    <xsl:value-of select="'Exception'"/>
		  </xsl:attribute>
		 </xsl:element>
		 
		 <!--Se debe añadir un assignment a 1 por cada variable de los parallel en que esté contenido-->
		 <xsl:if test="contains(label,'var_parallel') and contains(label,'==')">
		 
		 <label kind="assignment">
		 
	   		<xsl:for-each select="label[contains(.,'var_parallel') and contains(.,'==')]"> 
    	
    		<xsl:if test="position()=1">
    		
    			<xsl:value-of select="substring-before(.,'==')"/><xsl:text>=1</xsl:text>
    		
    		</xsl:if>
    		
    		<xsl:if test="position()!=1">
    		
    			<xsl:text>,</xsl:text><xsl:value-of select="substring-before(.,'==')"/><xsl:text>=1</xsl:text>
    		
    		</xsl:if>
    	
    		</xsl:for-each>
	   	 </label>
	   	 
	   	 </xsl:if>
		 
		 <label kind="guard">
	   		<xsl:for-each select="choice_invariant/inv"> 
    	
    		<xsl:if test="not(position()=last())">
    		
    			<xsl:text>(</xsl:text><xsl:value-of select="translate(.,'&lt;=','==')"/><xsl:text>) and </xsl:text>
    		
    		</xsl:if>
    		
    		<xsl:if test="position()=last()">
    		
    			<xsl:text>(</xsl:text><xsl:value-of select="translate(.,'&lt;=','==')"/><xsl:text>)</xsl:text>
    		
    		</xsl:if>
    	
    	</xsl:for-each>
	   	 </label>		   	
		   		
	</transition>
	
  </xsl:for-each>
  
  <!--Se deben añadir transiciones de los nodos de los PARALLEL a Exception cuando sea necesario-->
  <xsl:for-each select="location/label[contains(.,'var_parallel') and contains(.,'==')]">
  
	<transition>
	
		 <xsl:element name="source">
	      <xsl:attribute name="ref">
	        <xsl:value-of  select="../@id"/>			     
	      </xsl:attribute>
		 </xsl:element>
		 
		 <xsl:element name="target">
		  <xsl:attribute name="ref">
		    <xsl:value-of select="'Exception'"/>
		  </xsl:attribute>
		 </xsl:element>
		 
		 <label kind="guard">
	   		<xsl:value-of select="concat(substring-before(.,'=='),'==1')"/>
	   	 </label>
	   	 
	   	 <label kind="synchronisation">
			<!--Accion de sincronizacion de tipo !-->
			<xsl:text>urgent_chan</xsl:text>
			<xsl:text>!</xsl:text>
		</label>
		   		
	</transition>
	
  </xsl:for-each>
  
  <!--Para cada transición se debe mirar si tiene guarda para llamar a la plantilla de los or-->
  <xsl:for-each select="transition">
  
  	<!--Si no tiene guarda-->
  	<xsl:if test="not(label[@kind='guard'])">
  		
  		<transition>
  		
  			 <xsl:element name="source">
		      <xsl:attribute name="ref">
		        <xsl:value-of  select="source/@ref"/>			     
		      </xsl:attribute>
			 </xsl:element>
			 
			 <xsl:element name="target">
			  <xsl:attribute name="ref">
			    <xsl:value-of select="target/@ref"/>
			  </xsl:attribute>
			 </xsl:element>
			 
			 <!--Asignación de valores a las variables-->   
			 <xsl:for-each select="label">
			 
			 	<xsl:if test="@kind='assignment'">
			    
				 	<label kind="assignment">
				   		<xsl:value-of select="."/>
				   	</label>
			   	
			   	</xsl:if>
			   	
			   	<xsl:if test="@kind='synchronisation'">
			    
				 	<label kind="synchronisation">
				   		<xsl:value-of select="."/>
				   	</label>
			   	
			   	</xsl:if>
			   		
			 </xsl:for-each>
  		
  		</transition>
  	
  	</xsl:if>
  	
  	<!--Si tiene guarda-->
  	<xsl:if test="label[@kind='guard']">
	  	<xsl:call-template name="guarda_or_modificado">
			<xsl:with-param name="guard" select="normalize-space(label[@kind='guard']/.)"/>
		</xsl:call-template>
	</xsl:if>
  
  </xsl:for-each>
  
  </template>  
  
 </xsl:for-each>
<instantiation></instantiation>
<system>
 <xsl:value-of select="//system"/>
</system>
</nta>
</xsl:template>


<!--PLANTILLA PARA MODIFICAR LAS GUARDAS QUITANDO LOS OR Y PONIÉNDOLOS EN MÚLTIPLES GUARDAS-->
<xsl:template name="guarda_or_modificado">
<xsl:param name="guard" select="@guard"/>

<!--Llevar cualquier or de la expresión lo más hacia afuera posible mediante la propiedad distributiva-->

<!--En primer lugar se debe mirar si es una expresión que contenga or y que no sea dentro de otra palabra-->
<xsl:if test="contains($guard,' or ') or contains($guard,')or(') or contains($guard,')or ') or contains($guard,' or(')">

	<!--Ver cual es el or (u ors) más externos (número de paréntesis mínimo abiertos antes sin cerrar)-->	
	<xsl:call-template name="or_mas_externo">
		<xsl:with-param name="guard" select="$guard"/>
		<xsl:with-param name="guard_actual" select="$guard"/>
		<xsl:with-param name="guard_seleccion" select="$guard"/>
		<xsl:with-param name="n_abiertos" select="'-1'"/>
		<xsl:with-param name="or_mismo_nivel" select="'1'"/>
	</xsl:call-template>
	
</xsl:if>

<!--Si no contiene ningún or no se tiene que hacer nada-->
<xsl:if test="not(contains($guard,' or ')) and not(contains($guard,')or(')) and not(contains($guard,')or ')) and not(contains($guard,' or('))">

	 <!--Dejar el valor de la guarda actual como está actualmente en una transición propia-->
	 <transition>
  		
		 <xsl:element name="source">
	      <xsl:attribute name="ref">
	        <xsl:value-of  select="source/@ref"/>			     
	      </xsl:attribute>
		 </xsl:element>
		 
		 <xsl:element name="target">
		  <xsl:attribute name="ref">
		    <xsl:value-of select="target/@ref"/>
		  </xsl:attribute>
		 </xsl:element>
		 
		 <!--Asignación de valores a las variables-->   
		 <xsl:for-each select="label">
		 
		 	<xsl:if test="@kind='assignment'">
		    
			 	<label kind="assignment">
			   		<xsl:value-of select="."/>
			   	</label>
		   	
		   	</xsl:if>
		   	
		   	<xsl:if test="@kind='synchronisation'">
		    
			 	<label kind="synchronisation">
			   		<xsl:value-of select="."/>
			   	</label>
		   	
		   	</xsl:if>
		   		
		 </xsl:for-each>
		 
		 <label kind="guard">
	   		<xsl:value-of select="$guard"/>
	   	 </label>		 	 
	
	</transition>
	 

</xsl:if>

</xsl:template>

<!--PLANTILLA PARA VER CUAL ES EL OR MÁS EXTERNO-->
<xsl:template name="or_mas_externo">
<xsl:param name="guard" select="@guard"/>
<xsl:param name="guard_actual" select="@guard_actual"/>
<xsl:param name="guard_seleccion" select="@guard_seleccion"/>
<xsl:param name="n_abiertos" select="@n_abiertos"/>
<xsl:param name="or_mismo_nivel" select="@or_mismo_nivel"/>

<!--Ver si el primer or que encontramos es parte del nombre de una variable y no una disyunción-->
<xsl:if test="contains($guard_actual,'or') and not(starts-with(normalize-space(substring-after($guard_actual,'or')),'('))">

	<!--Llamar a la misma plantilla con la guarda actual a partir del or-->
	<xsl:call-template name="or_mas_externo">
		<xsl:with-param name="guard" select="$guard"/>
		<xsl:with-param name="guard_actual" select="substring-after($guard_actual,'or')"/>
		<xsl:with-param name="guard_seleccion" select="$guard_seleccion"/>
		<xsl:with-param name="n_abiertos" select="$n_abiertos"/>
		<xsl:with-param name="or_mismo_nivel" select="$or_mismo_nivel"/>
	</xsl:call-template>
	
</xsl:if>

<!--Si el primer or que encontramos es una disyunción se debe ver el número de paréntesis abiertos y si es menor que cualquier otro que se haya encontrado anteriormente-->
<xsl:if test="contains($guard_actual,'or') and (starts-with(normalize-space(substring-after($guard_actual,'or')),'('))">

	<!--Llamar a la plantilla que se encargue de contar los paréntesis abiertos con la guarda actual a partir del or-->
	<xsl:call-template name="or_contar_parentesis">
		<xsl:with-param name="guard" select="$guard"/>
		<xsl:with-param name="guard_actual" select="substring-after($guard_actual,'or')"/>
		<xsl:with-param name="guard_seleccion" select="$guard_seleccion"/>
		<xsl:with-param name="n_abiertos" select="$n_abiertos"/>
		<xsl:with-param name="or_mismo_nivel" select="$or_mismo_nivel"/>
		<xsl:with-param name="n_abiertos_actual" select="'0'"/>
		<xsl:with-param name="guard_before" select="substring($guard,1,string-length($guard) - string-length(substring-after($guard_actual,'or')))"/>
	</xsl:call-template>
	
</xsl:if>

<!--Si ya no queda ningún or por procesar-->
<xsl:if test="not(contains($guard_actual,'or'))">
	
	<!--Se debe ir modificando la expresión hasta llevar el or (u ors) al nivel más exterior posible-->
		
	<!--Si el or (o los ors) no está dentro de ningún paréntesis, entonces se debe directamente mirar las subexpresiones-->
	<xsl:if test="$n_abiertos = 0">
	
		<xsl:if test="$or_mismo_nivel = 1">
		
			<!--Llamar a la función para cada una de las subexpresiones-->			
			<xsl:variable name = "pri_sub" select = "normalize-space(substring($guard,1,string-length($guard) - string-length($guard_seleccion)))"/>
					
			<!--Se debe quitar el paréntesis inicial y final al llamar a la función para ambas componentes-->
			<xsl:call-template name="guarda_or_modificado">
				<xsl:with-param name="guard" select="substring(normalize-space(substring($pri_sub,1,string-length($pri_sub)-2)),2,string-length(normalize-space(substring($pri_sub,1,string-length($pri_sub)-2)))-2)"/>		
			</xsl:call-template>
			
			<xsl:call-template name="guarda_or_modificado">
				<xsl:with-param name="guard" select="substring(normalize-space($guard_seleccion),2,string-length(normalize-space($guard_seleccion))-2)"/>
			</xsl:call-template>
		
		</xsl:if>
		
		<xsl:if test="$or_mismo_nivel > 1">
		
			<!--Llamar a la función para la primera subexpresión quitando los paréntesis y para la segunda subexpresión sin quitarlos-->
			<xsl:variable name = "pri_sub" select = "normalize-space(substring($guard,1,string-length($guard) - string-length($guard_seleccion)))"/>
					
			<!--Se debe quitar el paréntesis inicial y final al llamar a la función para la primera parte-->
			<xsl:call-template name="guarda_or_modificado">
				<xsl:with-param name="guard" select="substring(normalize-space(substring($pri_sub,1,string-length($pri_sub)-2)),2,string-length(normalize-space(substring($pri_sub,1,string-length($pri_sub)-2)))-2)"/>		
			</xsl:call-template>
			
			<xsl:call-template name="guarda_or_modificado">
				<xsl:with-param name="guard" select="normalize-space($guard_seleccion)"/>
			</xsl:call-template>
		
		</xsl:if>
			
	</xsl:if>
	
	<!--Si el or (o los ors) están dentro de algún paréntesis se deben mirar las subexpresiones para modificarlas y sacar el or más fuera-->
	<xsl:if test="$n_abiertos > 0">
		
		<xsl:if test="$or_mismo_nivel = 1">
		
			<!--En primer lugar se debe ver que dos subexpresiones está separando el or-->
		
			<xsl:variable name = "pri_sub" select = "normalize-space(substring($guard,1,string-length($guard) - string-length($guard_seleccion)))"/>
			
			<!--Cadenas de caracteres anteriores y posteriores al or-->
			<xsl:variable name = "cad_ant" select = "normalize-space(substring($pri_sub,1,string-length($pri_sub)-2))"/>
			<xsl:variable name = "cad_post" select = "$guard_seleccion"/>
			
			<!--Expresiones anterior y posterior afectadas por el or-->			
			<xsl:variable name = "exp_ant">
				
				<xsl:call-template name="sub_ant">
					<xsl:with-param name="guard" select="$cad_ant"/>						
				</xsl:call-template>
				
			</xsl:variable>			
			
			<xsl:variable name = "exp_post">
			
				<xsl:call-template name="sub_post">
					<xsl:with-param name="guard" select="$cad_post"/>
					<xsl:with-param name="guard_actual" select="substring-after($cad_post,')')"/>
				</xsl:call-template>
			
			</xsl:variable>
			
			<!--Cadena anterior a la expresion anterior al or-->
			<xsl:variable name = "cad_exp_ant_aux" select = "normalize-space(substring($cad_ant,1,string-length($cad_ant) - string-length($exp_ant)))"/>
			<xsl:variable name = "cad_exp_ant" select = "normalize-space(substring($cad_exp_ant_aux,1,string-length($cad_exp_ant_aux)-1))"/>
			<xsl:variable name = "cad_exp_post_aux" select = "normalize-space(substring($cad_post,string-length($exp_post) + 2,string-length($cad_post) - string-length($exp_post)))"/>
			<xsl:variable name = "cad_exp_post" select = "normalize-space(substring($cad_exp_post_aux,2,string-length($cad_exp_post_aux)-1))"/>
						
			
			<!--Ver si la expresión anterior acaba en and para aplicar la propiedad distributiva-->
			
			<xsl:if test="($cad_exp_ant != '') and (substring($cad_exp_ant,string-length($cad_exp_ant) - 2,3) = 'and')">							
			
				<!--Ver cual es la cadena anterior al and-->
				<xsl:variable name = "cad_ant_and" select = "normalize-space(substring($cad_exp_ant,1,string-length($cad_exp_ant)-3))"/>
												
				<!--Expresion anterior al and-->
				<xsl:variable name = "exp_ant_and">
					
					<xsl:text>(</xsl:text>
					<xsl:call-template name="sub_ant_and">
						<xsl:with-param name="guard" select="$cad_ant_and"/>
					</xsl:call-template>
					<xsl:text>)</xsl:text>
				
				</xsl:variable>	
				
				<!--Ver cual es cadena anterior a la expresion anterior al and-->
				<xsl:variable name = "cad_exp_ant_and" select = "normalize-space(substring($cad_ant_and,1,string-length($cad_ant_and) - string-length($exp_ant_and)))"/>

				<!--Se debe mirar si existen más and al mismo nivel antes o después-->
								
				<xsl:if test="(substring($cad_exp_ant_and,string-length($cad_exp_ant_and) - 2,3) = 'and') or (starts-with($cad_exp_post,'and'))">
					
					<xsl:variable name = "new_exp">	
						<xsl:value-of select="$cad_exp_ant_and"/><xsl:text>(</xsl:text>
						<xsl:text>(</xsl:text>
						<xsl:value-of select="$exp_ant_and"/>
						<xsl:text> and </xsl:text>
						<xsl:value-of select="$exp_ant"/>
						<xsl:text>) or (</xsl:text>
						<xsl:value-of select="$exp_ant_and"/>
						<xsl:text> and </xsl:text>
						<xsl:value-of select="$exp_post"/>
						<xsl:text>)</xsl:text>
						<xsl:text>)</xsl:text>
						<xsl:value-of select="$cad_exp_post"/>
					</xsl:variable>				
					
					<xsl:call-template name="or_mas_externo">
						<xsl:with-param name="guard" select="$new_exp"/>
						<xsl:with-param name="guard_actual" select="$new_exp"/>
						<xsl:with-param name="guard_seleccion" select="$new_exp"/>
						<xsl:with-param name="n_abiertos" select="'-1'"/>
						<xsl:with-param name="or_mismo_nivel" select="'1'"/>
					</xsl:call-template>
				
				</xsl:if>
				
				<xsl:if test="not((substring($cad_exp_ant_and,string-length($cad_exp_ant_and) - 2,3) = 'and') or (starts-with($cad_exp_post,'and')))">
					
					<xsl:variable name = "new_exp">	
						<xsl:value-of select="$cad_exp_ant_and"/><xsl:text>(</xsl:text>
						<xsl:value-of select="$exp_ant_and"/>
						<xsl:text> and </xsl:text>
						<xsl:value-of select="$exp_ant"/>
						<xsl:text>) or (</xsl:text>
						<xsl:value-of select="$exp_ant_and"/>
						<xsl:text> and </xsl:text>
						<xsl:value-of select="$exp_post"/>
						<xsl:text>)</xsl:text>
						<xsl:value-of select="$cad_exp_post"/>
					</xsl:variable>				
					
					<xsl:call-template name="or_mas_externo">
						<xsl:with-param name="guard" select="$new_exp"/>
						<xsl:with-param name="guard_actual" select="$new_exp"/>
						<xsl:with-param name="guard_seleccion" select="$new_exp"/>
						<xsl:with-param name="n_abiertos" select="'-1'"/>
						<xsl:with-param name="or_mismo_nivel" select="'1'"/>
					</xsl:call-template>
				
				</xsl:if>
											
			</xsl:if>
			
			<!--Si la expresión anterior no acaba en and ver si la expresión posterior comienza por and para aplicar la propiedad distributiva-->
			
			<xsl:if test="not(($cad_exp_ant != '') and (substring($cad_exp_ant,string-length($cad_exp_ant) - 2,3) = 'and')) and (($cad_exp_post != '') and (starts-with($cad_exp_post,'and')))">
			
				<!--Ver cual es la cadena posterior al and-->
				<xsl:variable name = "cad_post_and" select = "normalize-space(substring-after($cad_exp_post,'and'))"/>
				
				<!--Expresion posterior al and-->
				<xsl:variable name = "exp_post_and">
					
					<xsl:call-template name="sub_post">
						<xsl:with-param name="guard" select="$cad_post_and"/>
						<xsl:with-param name="guard_actual" select="substring-after($cad_post_and,')')"/>
					</xsl:call-template>
					
				</xsl:variable>
				
				<!--Ver cual es cadena posterior a la expresion posterior al and-->
				<xsl:variable name = "cad_exp_post_and" select = "normalize-space(substring($cad_post_and,string-length($exp_post_and) + 1,string-length($cad_post_and) - string-length($exp_post_and)))"/>
				
				<!--Se debe mirar si existen más and al mismo nivel después-->
								
				<xsl:if test="starts-with($cad_exp_post_and,'and')">
				
					<xsl:variable name = "new_exp">
						<xsl:value-of select="$cad_exp_ant"/>
						<xsl:text>(</xsl:text>
						<xsl:text>(</xsl:text>
						<xsl:value-of select="$exp_ant"/>
						<xsl:text> and </xsl:text>
						<xsl:value-of select="$exp_post_and"/>
						<xsl:text>) or (</xsl:text>
						<xsl:value-of select="$exp_post"/>
						<xsl:text> and </xsl:text>
						<xsl:value-of select="$exp_post_and"/>
						<xsl:text>)</xsl:text>
						<xsl:text>)</xsl:text>
						<xsl:value-of select="$cad_exp_post_and"/>
					</xsl:variable>
				
					<xsl:call-template name="or_mas_externo">
						<xsl:with-param name="guard" select="$new_exp"/>
						<xsl:with-param name="guard_actual" select="$new_exp"/>
						<xsl:with-param name="guard_seleccion" select="$new_exp"/>
						<xsl:with-param name="n_abiertos" select="'-1'"/>
						<xsl:with-param name="or_mismo_nivel" select="'1'"/>
					</xsl:call-template>
					
				</xsl:if>
				
				<xsl:if test="not(starts-with($cad_exp_post_and,'and'))">
				
					<xsl:variable name = "new_exp">
						<xsl:value-of select="$cad_exp_ant"/>
						<xsl:text>(</xsl:text>						
						<xsl:value-of select="$exp_ant"/>
						<xsl:text> and </xsl:text>
						<xsl:value-of select="$exp_post_and"/>
						<xsl:text>) or (</xsl:text>
						<xsl:value-of select="$exp_post"/>
						<xsl:text> and </xsl:text>
						<xsl:value-of select="$exp_post_and"/>						
						<xsl:text>)</xsl:text>
						<xsl:value-of select="$cad_exp_post_and"/>
					</xsl:variable>
				
					<xsl:call-template name="or_mas_externo">
						<xsl:with-param name="guard" select="$new_exp"/>
						<xsl:with-param name="guard_actual" select="$new_exp"/>
						<xsl:with-param name="guard_seleccion" select="$new_exp"/>
						<xsl:with-param name="n_abiertos" select="'-1'"/>
						<xsl:with-param name="or_mismo_nivel" select="'1'"/>
					</xsl:call-template>
					
				</xsl:if>
							
			</xsl:if>

		</xsl:if>
		
		<xsl:if test="$or_mismo_nivel > 1">					
			
			<!--Ver si justo después del paréntesis que cierra la expresión derecha del or existe otro or-->
			<xsl:variable name = "guard_seleccion_or">
					
				<xsl:call-template name="ver_post_nor">
					<xsl:with-param name="guard" select="substring-after($guard_seleccion,'(')"/>
					<xsl:with-param name="par_open" select="'1'"/>
				</xsl:call-template>
				
			</xsl:variable>			
			
			<!--Ver si justo después del primer paréntesis cerrrado existe otro or-->
			<xsl:if test="starts-with(normalize-space($guard_seleccion_or),'or')">
				
				<!--Si se trata del caso de varios or al mismo nivel dentro del mismo paréntesis se debe realizar una combinación con todas las expresiones a ese nivel-->
				
				<!--En primer lugar se debe ver que dos subexpresiones está separando el or-->
		
				<xsl:variable name = "pri_sub" select = "normalize-space(substring($guard,1,string-length($guard) - string-length($guard_seleccion)))"/>
				
				<!--Cadenas de caracteres anteriores y posteriores a los or-->
				<xsl:variable name = "cad_ant" select = "normalize-space(substring($pri_sub,1,string-length($pri_sub)-2))"/>
				<xsl:variable name = "cad_post" select = "$guard_seleccion"/>				
								
				<!--Cadena anterior a la expresion anterior al or-->
				<xsl:variable name = "exp_ant">
					
					<xsl:call-template name="sub_ant">
						<xsl:with-param name="guard" select="$cad_ant"/>						
					</xsl:call-template>
					
				</xsl:variable>
				<xsl:variable name = "cad_exp_ant_aux" select = "normalize-space(substring($cad_ant,1,string-length($cad_ant) - string-length($exp_ant)))"/>
				<xsl:variable name = "cad_exp_ant" select = "normalize-space(substring($cad_exp_ant_aux,1,string-length($cad_exp_ant_aux)-1))"/>
				
				<!--Cadena posterior a la expresion posterior al último or-->
				<xsl:variable name = "cad_exp_post">
					
					<xsl:call-template name="sub_post_nor">
						<xsl:with-param name="guard" select="$cad_post"/>						
					</xsl:call-template>
					
				</xsl:variable>
								
				<!--Cadena con todos los or de ese nivel (quitando paréntesis inicial y final)-->
				<xsl:variable name = "cad_or_aux1" select = "normalize-space(substring($guard,string-length($cad_exp_ant)+1,string-length($guard) - string-length($cad_exp_ant)))"/>
				<xsl:variable name = "cad_or_aux2" select = "normalize-space(substring($cad_or_aux1,1,string-length($cad_or_aux1) - string-length($cad_exp_post)))"/>
				<xsl:variable name = "cad_or" select = "substring($cad_or_aux2,2,string-length($cad_or_aux2) - 2)"/>
				
				<!--Ver si la expresión anterior acaba en and para aplicar la propiedad distributiva-->
			
				<xsl:if test="($cad_exp_ant != '') and (substring($cad_exp_ant,string-length($cad_exp_ant) - 2,3) = 'and')">
					
					<!--Ver cual es la cadena anterior al and-->
					<xsl:variable name = "cad_ant_and" select = "normalize-space(substring($cad_exp_ant,1,string-length($cad_exp_ant)-3))"/>
													
					<!--Expresion anterior al and-->
					<xsl:variable name = "exp_ant_and">
						
						<xsl:text>(</xsl:text>
						<xsl:call-template name="sub_ant_and">
							<xsl:with-param name="guard" select="$cad_ant_and"/>
						</xsl:call-template>
						<xsl:text>)</xsl:text>
					
					</xsl:variable>						
										
					<!--Ver cual es cadena anterior a la expresion anterior al and-->
					<xsl:variable name = "cad_exp_ant_and" select = "normalize-space(substring($cad_ant_and,1,string-length($cad_ant_and) - string-length($exp_ant_and)))"/>					
						
					<!--Se debe mirar si existen más and al mismo nivel antes o después-->
									
					<xsl:if test="(substring($cad_exp_ant_and,string-length($cad_exp_ant_and) - 2,3) = 'and') or (starts-with(normalize-space($cad_exp_post),'and'))">
					
						<xsl:variable name = "new_exp">	
							<xsl:value-of select="$cad_exp_ant_and"/>
							<xsl:text>(</xsl:text>							
							<xsl:call-template name="m_or">
								<xsl:with-param name="exp_and" select="$exp_ant_and"/>
								<xsl:with-param name="exp_m_or" select="$cad_or"/>								
							</xsl:call-template>
							<xsl:text>)</xsl:text>
							<xsl:value-of select="$cad_exp_post"/>
						</xsl:variable>
						
						<xsl:call-template name="or_mas_externo">
							<xsl:with-param name="guard" select="$new_exp"/>
							<xsl:with-param name="guard_actual" select="$new_exp"/>
							<xsl:with-param name="guard_seleccion" select="$new_exp"/>
							<xsl:with-param name="n_abiertos" select="'-1'"/>
							<xsl:with-param name="or_mismo_nivel" select="'1'"/>
						</xsl:call-template>
					
					</xsl:if>
					
					<xsl:if test="not((substring($cad_exp_ant_and,string-length($cad_exp_ant_and) - 2,3) = 'and') or (starts-with(normalize-space($cad_exp_post),'and')))">
					
						<xsl:variable name = "new_exp">	
							<xsl:value-of select="$cad_exp_ant_and"/>
							<xsl:call-template name="m_or">
								<xsl:with-param name="exp_and" select="$exp_ant_and"/>
								<xsl:with-param name="exp_m_or" select="$cad_or"/>								
							</xsl:call-template>
							<xsl:value-of select="$cad_exp_post"/>
						</xsl:variable>										
												
						<xsl:call-template name="or_mas_externo">
							<xsl:with-param name="guard" select="$new_exp"/>
							<xsl:with-param name="guard_actual" select="$new_exp"/>
							<xsl:with-param name="guard_seleccion" select="$new_exp"/>
							<xsl:with-param name="n_abiertos" select="'-1'"/>
							<xsl:with-param name="or_mismo_nivel" select="'1'"/>
						</xsl:call-template>
					
					</xsl:if>
												
				</xsl:if>
				
				<!--Si la expresión anterior no acaba en and ver si la expresión posterior comienza por and para aplicar la propiedad distributiva-->
			
				<xsl:if test="not(($cad_exp_ant != '') and (substring($cad_exp_ant,string-length($cad_exp_ant) - 2,3) = 'and')) and (($cad_exp_post != '') and (starts-with(normalize-space($cad_exp_post),'and')))">
					
					<!--Ver cual es la cadena posterior al and-->
					<xsl:variable name = "cad_post_and" select = "normalize-space(substring-after($cad_exp_post,'and'))"/>
					
					<!--Expresion posterior al and-->
					<xsl:variable name = "exp_post_and">
						
						<xsl:call-template name="sub_post">
							<xsl:with-param name="guard" select="$cad_post_and"/>
							<xsl:with-param name="guard_actual" select="substring-after($cad_post_and,')')"/>
						</xsl:call-template>
						
					</xsl:variable>
					
					<!--Ver cual es cadena posterior a la expresion posterior al and-->
					<xsl:variable name = "cad_exp_post_and" select = "normalize-space(substring($cad_post_and,string-length($exp_post_and) + 1,string-length($cad_post_and) - string-length($exp_post_and)))"/>
					
					<!--Se debe mirar si existen más and al mismo nivel después-->
									
					<xsl:if test="starts-with($cad_exp_post_and,'and')">
						
						<xsl:variable name = "new_exp">
							<xsl:value-of select="$cad_exp_ant"/>
							<xsl:text>(</xsl:text>
							<xsl:call-template name="m_or">
								<xsl:with-param name="exp_and" select="$exp_post_and"/>
								<xsl:with-param name="exp_m_or" select="$cad_or"/>								
							</xsl:call-template>
							<xsl:text>)</xsl:text>
							<xsl:value-of select="$cad_exp_post_and"/>
						</xsl:variable>
						
						<xsl:call-template name="or_mas_externo">
							<xsl:with-param name="guard" select="$new_exp"/>
							<xsl:with-param name="guard_actual" select="$new_exp"/>
							<xsl:with-param name="guard_seleccion" select="$new_exp"/>
							<xsl:with-param name="n_abiertos" select="'-1'"/>
							<xsl:with-param name="or_mismo_nivel" select="'1'"/>
						</xsl:call-template>
						
					</xsl:if>
					
					<xsl:if test="not(starts-with($cad_exp_post_and,'and'))">
					
						<xsl:variable name = "new_exp">
							<xsl:value-of select="$cad_exp_ant"/>
							<xsl:call-template name="m_or">
								<xsl:with-param name="exp_and" select="$exp_post_and"/>
								<xsl:with-param name="exp_m_or" select="$cad_or"/>
							</xsl:call-template>
							<xsl:value-of select="$cad_exp_post_and"/>
						</xsl:variable>
					
						<xsl:call-template name="or_mas_externo">
							<xsl:with-param name="guard" select="$new_exp"/>
							<xsl:with-param name="guard_actual" select="$new_exp"/>
							<xsl:with-param name="guard_seleccion" select="$new_exp"/>
							<xsl:with-param name="n_abiertos" select="'-1'"/>
							<xsl:with-param name="or_mismo_nivel" select="'1'"/>
						</xsl:call-template>
						
					</xsl:if>
								
				</xsl:if>
						
			</xsl:if>
			
			<xsl:if test="not(starts-with(normalize-space($guard_seleccion_or),'or'))">
				
				<!--Si no se trata del caso de varios or al mismo nivel dentro del mismo paréntesis se procesa el primero y nos olvidamos de los demás-->
			
				<!--En primer lugar se debe ver que dos subexpresiones está separando el or-->
		
				<xsl:variable name = "pri_sub" select = "normalize-space(substring($guard,1,string-length($guard) - string-length($guard_seleccion)))"/>
				
				<!--Cadenas de caracteres anteriores y posteriores al or-->
				<xsl:variable name = "cad_ant" select = "normalize-space(substring($pri_sub,1,string-length($pri_sub)-2))"/>
				<xsl:variable name = "cad_post" select = "$guard_seleccion"/>
				
				<!--Expresiones anterior y posterior afectadas por el or-->			
				<xsl:variable name = "exp_ant">
					
					<xsl:call-template name="sub_ant">
						<xsl:with-param name="guard" select="$cad_ant"/>						
					</xsl:call-template>
					
				</xsl:variable>			
				
				<xsl:variable name = "exp_post">
				
					<xsl:call-template name="sub_post">
						<xsl:with-param name="guard" select="$cad_post"/>
						<xsl:with-param name="guard_actual" select="substring-after($cad_post,')')"/>
					</xsl:call-template>
				
				</xsl:variable>
				
				<!--Cadena anterior a la expresion anterior al or-->
				<xsl:variable name = "cad_exp_ant_aux" select = "normalize-space(substring($cad_ant,1,string-length($cad_ant) - string-length($exp_ant)))"/>
				<xsl:variable name = "cad_exp_ant" select = "normalize-space(substring($cad_exp_ant_aux,1,string-length($cad_exp_ant_aux)-1))"/>
				<xsl:variable name = "cad_exp_post_aux" select = "normalize-space(substring($cad_post,string-length($exp_post) + 2,string-length($cad_post) - string-length($exp_post)))"/>
				<xsl:variable name = "cad_exp_post" select = "normalize-space(substring($cad_exp_post_aux,2,string-length($cad_exp_post_aux)-1))"/>
				
				<!--Ver si la expresión anterior acaba en and para aplicar la propiedad distributiva-->
				
				<xsl:if test="($cad_exp_ant != '') and (substring($cad_exp_ant,string-length($cad_exp_ant) - 2,3) = 'and')">							
				
					<!--Ver cual es la cadena anterior al and-->
					<xsl:variable name = "cad_ant_and" select = "normalize-space(substring($cad_exp_ant,1,string-length($cad_exp_ant)-3))"/>
													
					<!--Expresion anterior al and-->
					<xsl:variable name = "exp_ant_and">
						
						<xsl:text>(</xsl:text>
						<xsl:call-template name="sub_ant_and">
							<xsl:with-param name="guard" select="$cad_ant_and"/>
						</xsl:call-template>
						<xsl:text>)</xsl:text>
					
					</xsl:variable>	
					
					<!--Ver cual es cadena anterior a la expresion anterior al and-->
					<xsl:variable name = "cad_exp_ant_and" select = "normalize-space(substring($cad_ant_and,1,string-length($cad_ant_and) - string-length($exp_ant_and)))"/>
	
					<!--Se debe mirar si existen más and al mismo nivel antes o después-->
									
					<xsl:if test="(substring($cad_exp_ant_and,string-length($cad_exp_ant_and) - 2,3) = 'and') or (starts-with($cad_exp_post,'and'))">
						
						<xsl:variable name = "new_exp">	
							<xsl:value-of select="$cad_exp_ant_and"/><xsl:text>(</xsl:text>
							<xsl:text>(</xsl:text>
							<xsl:value-of select="$exp_ant_and"/>
							<xsl:text> and </xsl:text>
							<xsl:value-of select="$exp_ant"/>
							<xsl:text>) or (</xsl:text>
							<xsl:value-of select="$exp_ant_and"/>
							<xsl:text> and </xsl:text>
							<xsl:value-of select="$exp_post"/>
							<xsl:text>)</xsl:text>
							<xsl:text>)</xsl:text>
							<xsl:value-of select="$cad_exp_post"/>
						</xsl:variable>				
						
						<xsl:call-template name="or_mas_externo">
							<xsl:with-param name="guard" select="$new_exp"/>
							<xsl:with-param name="guard_actual" select="$new_exp"/>
							<xsl:with-param name="guard_seleccion" select="$new_exp"/>
							<xsl:with-param name="n_abiertos" select="'-1'"/>
							<xsl:with-param name="or_mismo_nivel" select="'1'"/>
						</xsl:call-template>
					
					</xsl:if>
					
					<xsl:if test="not((substring($cad_exp_ant_and,string-length($cad_exp_ant_and) - 2,3) = 'and') or (starts-with($cad_exp_post,'and')))">
						
						<xsl:variable name = "new_exp">	
							<xsl:value-of select="$cad_exp_ant_and"/><xsl:text>(</xsl:text>
							<xsl:value-of select="$exp_ant_and"/>
							<xsl:text> and </xsl:text>
							<xsl:value-of select="$exp_ant"/>
							<xsl:text>) or (</xsl:text>
							<xsl:value-of select="$exp_ant_and"/>
							<xsl:text> and </xsl:text>
							<xsl:value-of select="$exp_post"/>
							<xsl:text>)</xsl:text>
							<xsl:value-of select="$cad_exp_post"/>
						</xsl:variable>				
						
						<xsl:call-template name="or_mas_externo">
							<xsl:with-param name="guard" select="$new_exp"/>
							<xsl:with-param name="guard_actual" select="$new_exp"/>
							<xsl:with-param name="guard_seleccion" select="$new_exp"/>
							<xsl:with-param name="n_abiertos" select="'-1'"/>
							<xsl:with-param name="or_mismo_nivel" select="'1'"/>
						</xsl:call-template>
					
					</xsl:if>
												
				</xsl:if>
				
				<!--Si la expresión anterior no acaba en and ver si la expresión posterior comienza por and para aplicar la propiedad distributiva-->
				
				<xsl:if test="not(($cad_exp_ant != '') and (substring($cad_exp_ant,string-length($cad_exp_ant) - 2,3) = 'and')) and (($cad_exp_post != '') and (starts-with($cad_exp_post,'and')))">
				
					<!--Ver cual es la cadena posterior al and-->
					<xsl:variable name = "cad_post_and" select = "normalize-space(substring-after($cad_exp_post,'and'))"/>
					
					<!--Expresion posterior al and-->
					<xsl:variable name = "exp_post_and">
						
						<xsl:call-template name="sub_post">
							<xsl:with-param name="guard" select="$cad_post_and"/>
							<xsl:with-param name="guard_actual" select="substring-after($cad_post_and,')')"/>
						</xsl:call-template>
						
					</xsl:variable>
					
					<!--Ver cual es cadena posterior a la expresion posterior al and-->
					<xsl:variable name = "cad_exp_post_and" select = "normalize-space(substring($cad_post_and,string-length($exp_post_and) + 1,string-length($cad_post_and) - string-length($exp_post_and)))"/>
					
					<!--Se debe mirar si existen más and al mismo nivel después-->
									
					<xsl:if test="starts-with($cad_exp_post_and,'and')">
					
						<xsl:variable name = "new_exp">
							<xsl:value-of select="$cad_exp_ant"/>
							<xsl:text>(</xsl:text>
							<xsl:text>(</xsl:text>
							<xsl:value-of select="$exp_ant"/>
							<xsl:text> and </xsl:text>
							<xsl:value-of select="$exp_post_and"/>
							<xsl:text>) or (</xsl:text>
							<xsl:value-of select="$exp_post"/>
							<xsl:text> and </xsl:text>
							<xsl:value-of select="$exp_post_and"/>
							<xsl:text>)</xsl:text>
							<xsl:text>)</xsl:text>
							<xsl:value-of select="$cad_exp_post_and"/>
						</xsl:variable>
					
						<xsl:call-template name="or_mas_externo">
							<xsl:with-param name="guard" select="$new_exp"/>
							<xsl:with-param name="guard_actual" select="$new_exp"/>
							<xsl:with-param name="guard_seleccion" select="$new_exp"/>
							<xsl:with-param name="n_abiertos" select="'-1'"/>
							<xsl:with-param name="or_mismo_nivel" select="'1'"/>
						</xsl:call-template>
						
					</xsl:if>
					
					<xsl:if test="not(starts-with($cad_exp_post_and,'and'))">
					
						<xsl:variable name = "new_exp">
							<xsl:value-of select="$cad_exp_ant"/>
							<xsl:text>(</xsl:text>						
							<xsl:value-of select="$exp_ant"/>
							<xsl:text> and </xsl:text>
							<xsl:value-of select="$exp_post_and"/>
							<xsl:text>) or (</xsl:text>
							<xsl:value-of select="$exp_post"/>
							<xsl:text> and </xsl:text>
							<xsl:value-of select="$exp_post_and"/>						
							<xsl:text>)</xsl:text>
							<xsl:value-of select="$cad_exp_post_and"/>
						</xsl:variable>
					
						<xsl:call-template name="or_mas_externo">
							<xsl:with-param name="guard" select="$new_exp"/>
							<xsl:with-param name="guard_actual" select="$new_exp"/>
							<xsl:with-param name="guard_seleccion" select="$new_exp"/>
							<xsl:with-param name="n_abiertos" select="'-1'"/>
							<xsl:with-param name="or_mismo_nivel" select="'1'"/>
						</xsl:call-template>
						
					</xsl:if>
								
				</xsl:if>
			
			</xsl:if>
		
		</xsl:if>
			
	</xsl:if>
		
</xsl:if>

</xsl:template>

<!--PLANTILLA PARA VER LOS PARÉNTESIS ABIERTOS SIN CERRAR QUE APARECEN ANTES DEL OR ACTUAL-->
<xsl:template name="or_contar_parentesis">
<xsl:param name="guard" select="@guard"/>
<xsl:param name="guard_actual" select="@guard_actual"/>
<xsl:param name="guard_seleccion" select="@guard_seleccion"/>
<xsl:param name="n_abiertos" select="@n_abiertos"/>
<xsl:param name="or_mismo_nivel" select="@or_mismo_nivel"/>
<xsl:param name="n_abiertos_actual" select="@n_abiertos_actual"/>
<xsl:param name="guard_before" select="@guard_before"/>

<!--Ver si la expresión todavía contiene paréntesis abiertos y cerrados-->
<xsl:if test="contains($guard_before,'(') and contains($guard_before,')')">

	<!--Ver si está primero el paréntesis abierto o el paréntesis cerrado-->
	<xsl:if test="string-length(substring-before($guard_before,'(')) &lt; string-length(substring-before($guard_before,')'))">
		<xsl:call-template name="or_contar_parentesis">
			<xsl:with-param name="guard" select="$guard"/>
			<xsl:with-param name="guard_actual" select="$guard_actual"/>
			<xsl:with-param name="guard_seleccion" select="$guard_seleccion"/>
			<xsl:with-param name="n_abiertos" select="$n_abiertos"/>
			<xsl:with-param name="or_mismo_nivel" select="$or_mismo_nivel"/>
			<xsl:with-param name="n_abiertos_actual" select="$n_abiertos_actual + 1"/>
			<xsl:with-param name="guard_before" select="substring-after($guard_before,'(')"/>
		</xsl:call-template>
	</xsl:if>
		
	<xsl:if test="string-length(substring-before($guard_before,'(')) &gt; string-length(substring-before($guard_before,')'))">		
		<xsl:call-template name="or_contar_parentesis">
			<xsl:with-param name="guard" select="$guard"/>
			<xsl:with-param name="guard_actual" select="$guard_actual"/>
			<xsl:with-param name="guard_seleccion" select="$guard_seleccion"/>
			<xsl:with-param name="n_abiertos" select="$n_abiertos"/>
			<xsl:with-param name="or_mismo_nivel" select="$or_mismo_nivel"/>
			<xsl:with-param name="n_abiertos_actual" select="$n_abiertos_actual - 1"/>
			<xsl:with-param name="guard_before" select="substring-after($guard_before,')')"/>
		</xsl:call-template>
	</xsl:if>
	
</xsl:if>

<!--Ver si la expresión todavía contiene paréntesis abiertos y no cerrados-->
<xsl:if test="contains($guard_before,'(') and not(contains($guard_before,')'))">

	<xsl:call-template name="or_contar_parentesis">
		<xsl:with-param name="guard" select="$guard"/>
		<xsl:with-param name="guard_actual" select="$guard_actual"/>
		<xsl:with-param name="guard_seleccion" select="$guard_seleccion"/>
		<xsl:with-param name="n_abiertos" select="$n_abiertos"/>
		<xsl:with-param name="or_mismo_nivel" select="$or_mismo_nivel"/>
		<xsl:with-param name="n_abiertos_actual" select="$n_abiertos_actual + 1"/>
		<xsl:with-param name="guard_before" select="substring-after($guard_before,'(')"/>
	</xsl:call-template>
	
</xsl:if>


<!--Ver si la expresión todavía contiene paréntesis cerrados y no abiertos-->
<xsl:if test="contains($guard_before,')') and not(contains($guard_before,'('))">

	<xsl:call-template name="or_contar_parentesis">
		<xsl:with-param name="guard" select="$guard"/>
		<xsl:with-param name="guard_actual" select="$guard_actual"/>
		<xsl:with-param name="guard_seleccion" select="$guard_seleccion"/>
		<xsl:with-param name="n_abiertos" select="$n_abiertos"/>
		<xsl:with-param name="or_mismo_nivel" select="$or_mismo_nivel"/>
		<xsl:with-param name="n_abiertos_actual" select="$n_abiertos_actual - 1"/>
		<xsl:with-param name="guard_before" select="substring-after($guard_before,')')"/>
	</xsl:call-template>
	
</xsl:if>

<!--Ver si la expresión ya no contiene paréntesis cerrados ni abiertos-->
<xsl:if test="not(contains($guard_before,')')) and not(contains($guard_before,'('))">
	
	<!--Si el número de paréntesis actual es mayor que la selección actual se sigue dejando lo que ya hubiera-->	
	<xsl:if test="($n_abiertos != -1) and ($n_abiertos &lt; $n_abiertos_actual)">	
	
		<xsl:call-template name="or_mas_externo">
			<xsl:with-param name="guard" select="$guard"/>
			<xsl:with-param name="guard_actual" select="$guard_actual"/>
			<xsl:with-param name="guard_seleccion" select="$guard_seleccion"/>
			<xsl:with-param name="n_abiertos" select="$n_abiertos"/>
			<xsl:with-param name="or_mismo_nivel" select="$or_mismo_nivel"/>
		</xsl:call-template>
	
	</xsl:if>
	
	<!--Si el número de paréntesis actual es igual a la selección actual se mantiene indicando un or más al mismo nivel-->	
	<xsl:if test="$n_abiertos = $n_abiertos_actual">
		
		<xsl:call-template name="or_mas_externo">
			<xsl:with-param name="guard" select="$guard"/>
			<xsl:with-param name="guard_actual" select="$guard_actual"/>
			<xsl:with-param name="guard_seleccion" select="$guard_seleccion"/>
			<xsl:with-param name="n_abiertos" select="$n_abiertos"/>
			<xsl:with-param name="or_mismo_nivel" select="$or_mismo_nivel + 1"/>
		</xsl:call-template>		
	
	</xsl:if>
	
	<!--Si el número de paréntesis actual es menor a la selección actual se cambia la selección antigua por la nueva selección-->	
	<xsl:if test="($n_abiertos = -1) or ($n_abiertos &gt; $n_abiertos_actual)">
	
		<xsl:call-template name="or_mas_externo">
			<xsl:with-param name="guard" select="$guard"/>
			<xsl:with-param name="guard_actual" select="$guard_actual"/>
			<xsl:with-param name="guard_seleccion" select="$guard_actual"/>
			<xsl:with-param name="n_abiertos" select="$n_abiertos_actual"/>
			<xsl:with-param name="or_mismo_nivel" select="'1'"/>
		</xsl:call-template>
	
	</xsl:if>
		
</xsl:if>

</xsl:template>

<!--PLANTILLA PARA VER LA EXPRESIÓN ANTERIOR AL OR-->
<xsl:template name="sub_ant">
<xsl:param name="guard" select="@guard"/>
	
	<!--Ver para cada uno de los paréntesis abiertos si se llega a cerrar, hasta encontrar uno que no se llegue a cerrar-->
	<xsl:call-template name="ver_ant">
		<xsl:with-param name="guard" select="substring-after($guard,'(')"/>
		<xsl:with-param name="guard_actual" select="substring-after($guard,'(')"/>
		<xsl:with-param name="par_open" select="'1'"/>			
	</xsl:call-template>

</xsl:template>

<!--PLANTILLA PARA VER SI EL PARÉNTESIS ACTUAL SE LLEGA A CERRAR-->
<xsl:template name="ver_ant">
<xsl:param name="guard" select="@guard"/>
<xsl:param name="guard_actual" select="@guard_actual"/>
<xsl:param name="par_open" select="@par_open"/>

<!--Ver si la expresión todavía contiene paréntesis abiertos y cerrados-->
<xsl:if test="contains($guard_actual,'(') and contains($guard_actual,')')">

	<!--Ver si está primero el paréntesis abierto o el paréntesis cerrado-->
	<xsl:if test="string-length(substring-before($guard_actual,'(')) &lt; string-length(substring-before($guard_actual,')'))">
		<xsl:call-template name="ver_ant">
			<xsl:with-param name="guard" select="$guard"/>
			<xsl:with-param name="guard_actual" select="substring-after($guard_actual,'(')"/>
			<xsl:with-param name="par_open" select="$par_open + 1"/>			
		</xsl:call-template>
		
	</xsl:if>
		
	<xsl:if test="string-length(substring-before($guard_actual,'(')) &gt; string-length(substring-before($guard_actual,')'))">		
	
		<xsl:variable name = "open" select = "$par_open - 1"/>
		
		<xsl:if test="$open = 0">
			
			<xsl:call-template name="sub_ant">
				<xsl:with-param name="guard" select="$guard"/>				
			</xsl:call-template>
			
		
		</xsl:if>
		
		<xsl:if test="$open > 0">
				
			<xsl:call-template name="ver_ant">
				<xsl:with-param name="guard" select="$guard"/>
				<xsl:with-param name="guard_actual" select="substring-after($guard_actual,')')"/>
				<xsl:with-param name="par_open" select="$open"/>			
			</xsl:call-template>
		
		</xsl:if>
		
	</xsl:if>
	
</xsl:if>

<!--Ver si la expresión todavía contiene paréntesis abiertos y no cerrados-->
<xsl:if test="contains($guard_actual,'(') and not(contains($guard_actual,')'))">

	<xsl:call-template name="ver_ant">
		<xsl:with-param name="guard" select="$guard"/>
		<xsl:with-param name="guard_actual" select="substring-after($guard_actual,'(')"/>
		<xsl:with-param name="par_open" select="$par_open + 1"/>			
	</xsl:call-template>
	
</xsl:if>


<!--Ver si la expresión todavía contiene paréntesis cerrados y no abiertos-->
<xsl:if test="contains($guard_actual,')') and not(contains($guard_actual,'('))">

	<xsl:variable name = "open" select = "$par_open - 1"/>
		
	<xsl:if test="$open = 0">
	
		<xsl:call-template name="sub_ant">
			<xsl:with-param name="guard" select="$guard"/>				
		</xsl:call-template>
	
	</xsl:if>
	
	<xsl:if test="$open > 0">
	
		<xsl:call-template name="ver_ant">
			<xsl:with-param name="guard" select="$guard"/>
			<xsl:with-param name="guard_actual" select="substring-after($guard_actual,')')"/>
			<xsl:with-param name="par_open" select="$open"/>			
		</xsl:call-template>
	
	</xsl:if>
	
</xsl:if>

<!--Ver si la expresión ya no contiene paréntesis cerrados ni abiertos-->
<xsl:if test="not(contains($guard_actual,')')) and not(contains($guard_actual,'('))">
	
	<!--Si se ha llegado hasta y el número de abiertos es justo uno es porque la siguiente expresión es la anterior al or-->
	<xsl:if test="$par_open = 1">
		<xsl:value-of select="normalize-space($guard)"/>
	</xsl:if>
	
	<xsl:if test="$par_open > 1">
		<xsl:call-template name="sub_ant">
			<xsl:with-param name="guard" select="$guard"/>				
		</xsl:call-template>
	</xsl:if>
		
</xsl:if>	

</xsl:template>

<!--PLANTILLA PARA VER LA EXPRESIÓN POSTERIOR AL OR-->
<xsl:template name="sub_post">
<xsl:param name="guard" select="@guard"/>
<xsl:param name="guard_actual" select="@guard_actual"/>
	
	<xsl:variable name="guard_before" select="substring($guard,1,string-length($guard) - string-length($guard_actual))"/>
	
	<!--Ver si el paréntesis que cierra es realmente el que cierra la expresión actual-->
	<xsl:call-template name="ver_post">
		<xsl:with-param name="guard" select="$guard"/>
		<xsl:with-param name="guard_actual" select="$guard_actual"/>
		<xsl:with-param name="guard_before" select="substring-after($guard_before,'(')"/>
		<xsl:with-param name="par_open" select="'1'"/>			
	</xsl:call-template>
	
</xsl:template>

<!--PLANTILLA PARA VER SI EL PARÉNTESIS ACTUAL SE LLEGA A CERRAR-->
<xsl:template name="ver_post">
<xsl:param name="guard" select="@guard"/>
<xsl:param name="guard_actual" select="@guard_actual"/>
<xsl:param name="guard_before" select="@guard_before"/>
<xsl:param name="par_open" select="@par_open"/>

<!--Ver si la expresión todavía contiene paréntesis abiertos y cerrados-->
<xsl:if test="contains($guard_before,'(') and contains($guard_before,')')">

	<!--Ver si está primero el paréntesis abierto o el paréntesis cerrado-->
	<xsl:if test="string-length(substring-before($guard_before,'(')) &lt; string-length(substring-before($guard_before,')'))">	
			
		<xsl:call-template name="ver_post">
			<xsl:with-param name="guard" select="$guard"/>
			<xsl:with-param name="guard_actual" select="$guard_actual"/>
			<xsl:with-param name="guard_before" select="substring-after($guard_before,'(')"/>
			<xsl:with-param name="par_open" select="$par_open + 1"/>
		</xsl:call-template>
		
	</xsl:if>
		
	<xsl:if test="string-length(substring-before($guard_before,'(')) &gt; string-length(substring-before($guard_before,')'))">		
	
		<xsl:variable name = "open" select = "$par_open - 1"/>
		
		<xsl:if test="$open = 0">
		
			<!--Si se ha llegado hasta aquí es porque se trata de la expresión posterior al or-->
			<xsl:value-of select="normalize-space(substring($guard,1,string-length($guard) - string-length($guard_actual)))"/>
		
		</xsl:if>
		
		<xsl:if test="$open > 0">
				
			<xsl:call-template name="ver_post">
				<xsl:with-param name="guard" select="$guard"/>
				<xsl:with-param name="guard_actual" select="$guard_actual"/>
				<xsl:with-param name="guard_before" select="substring-after($guard_before,')')"/>
				<xsl:with-param name="par_open" select="$open"/>			
			</xsl:call-template>
		
		</xsl:if>
		
	</xsl:if>
	
</xsl:if>

<!--Ver si la expresión todavía contiene paréntesis abiertos y no cerrados-->
<xsl:if test="contains($guard_before,'(') and not(contains($guard_before,')'))">

	<xsl:call-template name="ver_post">
		<xsl:with-param name="guard" select="$guard"/>
		<xsl:with-param name="guard_actual" select="$guard_actual"/>
		<xsl:with-param name="guard_before" select="substring-after($guard_before,'(')"/>
		<xsl:with-param name="par_open" select="$par_open + 1"/>
	</xsl:call-template>
	
</xsl:if>


<!--Ver si la expresión todavía contiene paréntesis cerrados y no abiertos-->
<xsl:if test="contains($guard_before,')') and not(contains($guard_before,'('))">

	<xsl:variable name = "open" select = "$par_open - 1"/>
		
	<xsl:if test="$open = 0">
	
		<xsl:value-of select="normalize-space(substring($guard,1,string-length($guard) - string-length($guard_actual)))"/>
	
	</xsl:if>
	
	<xsl:if test="$open > 0">
	
		<xsl:call-template name="ver_post">
			<xsl:with-param name="guard" select="$guard"/>
			<xsl:with-param name="guard_actual" select="$guard_actual"/>
			<xsl:with-param name="guard_before" select="substring-after($guard_before,')')"/>
			<xsl:with-param name="par_open" select="$open"/>			
		</xsl:call-template>
	
	</xsl:if>
	
</xsl:if>

<!--Ver si la expresión ya no contiene paréntesis cerrados ni abiertos-->
<xsl:if test="not(contains($guard_before,')')) and not(contains($guard_before,'('))">

	<!--Si se ha llegado hasta aquí es porque no se ha cerrado la expresión actual y se necesita ver el siguiente paréntesis-->
	<xsl:variable name = "guard_actual_new" select = "substring-after($guard_actual,')')"/>
	<xsl:variable name = "guard_before_new" select = "substring($guard,1,string-length($guard) - string-length($guard_actual_new))"/>
		
	<!--Ver si el paréntesis que cierra es realmente el que cierra la expresión actual-->
	<xsl:call-template name="ver_post">
		<xsl:with-param name="guard" select="$guard"/>
		<xsl:with-param name="guard_actual" select="$guard_actual_new"/>
		<xsl:with-param name="guard_before" select="substring-after($guard_before_new,'(')"/>
		<xsl:with-param name="par_open" select="'1'"/>			
	</xsl:call-template>
		
</xsl:if>	

</xsl:template>

<!--PLANTILLA PARA VER LA EXPRESIÓN ANTERIOR AL AND-->
<xsl:template name="sub_ant_and">
<xsl:param name="guard" select="@guard"/>
	
	<!--Ver para cada uno de los paréntesis abiertos si se llega a cerrar, hasta encontrar uno que no se llegue a cerrar-->
	<xsl:call-template name="ver_ant">
		<xsl:with-param name="guard" select="substring-after(substring($guard,1,string-length($guard) - 1),'(')"/>
		<xsl:with-param name="guard_actual" select="substring-after(substring($guard,1,string-length($guard) - 1),'(')"/>
		<xsl:with-param name="par_open" select="'1'"/>			
	</xsl:call-template>

</xsl:template>

<!--PLANTILLA PARA VER LA CADENA POSTERIOR A LOS OR CON MÚLTIPLES OR-->
<xsl:template name="sub_post_nor">
<xsl:param name="guard" select="@guard"/>	
		
	<!--Ver si el paréntesis que cierra es realmente el que cierra la expresión actual-->
	<xsl:call-template name="ver_post_nor">
		<xsl:with-param name="guard" select="$guard"/>		
		<xsl:with-param name="par_open" select="'1'"/>			
	</xsl:call-template>
	
</xsl:template>

<!--PLANTILLA PARA VER SI EL PARÉNTESIS ACTUAL SE LLEGA A CERRAR-->
<xsl:template name="ver_post_nor">
<xsl:param name="guard" select="@guard"/>
<xsl:param name="par_open" select="@par_open"/>

<!--Ver si la expresión todavía contiene paréntesis abiertos y cerrados-->
<xsl:if test="contains($guard,'(') and contains($guard,')')">

	<!--Ver si está primero el paréntesis abierto o el paréntesis cerrado-->
	<xsl:if test="string-length(substring-before($guard,'(')) &lt; string-length(substring-before($guard,')'))">	
			
		<xsl:call-template name="ver_post_nor">
			<xsl:with-param name="guard" select="substring-after($guard,'(')"/>			
			<xsl:with-param name="par_open" select="$par_open + 1"/>
		</xsl:call-template>
		
	</xsl:if>
		
	<xsl:if test="string-length(substring-before($guard,'(')) &gt; string-length(substring-before($guard,')'))">		
	
		<xsl:variable name = "open" select = "$par_open - 1"/>
		
		<xsl:if test="$open = 0">
		
			<!--Si se ha llegado hasta aquí es porque se trata de la cadena posterior a los or-->
			<xsl:value-of select="substring-after($guard,')')"/>
		
		</xsl:if>
		
		<xsl:if test="$open > 0">
				
			<xsl:call-template name="ver_post_nor">
				<xsl:with-param name="guard" select="substring-after($guard,')')"/>				
				<xsl:with-param name="par_open" select="$open"/>			
			</xsl:call-template>
		
		</xsl:if>
		
	</xsl:if>
	
</xsl:if>

<!--Ver si la expresión todavía contiene paréntesis abiertos y no cerrados-->
<xsl:if test="contains($guard,'(') and not(contains($guard,')'))">

	<xsl:call-template name="ver_post_nor">		
		<xsl:with-param name="guard" select="substring-after($guard,'(')"/>
		<xsl:with-param name="par_open" select="$par_open + 1"/>
	</xsl:call-template>
	
</xsl:if>


<!--Ver si la expresión todavía contiene paréntesis cerrados y no abiertos-->
<xsl:if test="contains($guard,')') and not(contains($guard,'('))">

	<xsl:variable name = "open" select = "$par_open - 1"/>
		
	<xsl:if test="$open = 0">
	
		<xsl:value-of select="substring-after($guard,')')"/>
	
	</xsl:if>
	
	<xsl:if test="$open > 0">
	
		<xsl:call-template name="ver_post_nor">
			<xsl:with-param name="guard" select="substring-after($guard,')')"/>				
			<xsl:with-param name="par_open" select="$open"/>			
		</xsl:call-template>
	
	</xsl:if>
	
</xsl:if>

</xsl:template>

<!--PLANTILLA PARA GENERAR LAS EXPRESIONES CORRESPONDIENTES A APLICAR LA PROPIEDAD DISTRIBUTIVA CON MÚLTIPLES OR-->
<xsl:template name="m_or">
<xsl:param name="exp_and" select="@exp_and"/>
<xsl:param name="exp_m_or" select="@exp_m_or"/>	
	
	<!--Ver cual es la expresión posterior al cierre del primer paréntesis-->
	<xsl:variable name = "exp_post">
				
		<xsl:call-template name="ver_post_nor">
			<xsl:with-param name="guard" select="substring-after($exp_m_or,'(')"/>
				<xsl:with-param name="par_open" select="'1'"/>
		</xsl:call-template>
		
	</xsl:variable>	
	
	<!--Expresión anterior al or-->
	<xsl:variable name = "exp_ant" select = "normalize-space(substring($exp_m_or,1,string-length($exp_m_or) - string-length($exp_post)))"/>
	
	<!--Añadir a la guarda el and con la exp_and-->
	<xsl:text>(</xsl:text>
	<xsl:value-of select="$exp_ant"/>
	<xsl:text> and </xsl:text>
	<xsl:value-of select="$exp_and"/>
	<xsl:text>)</xsl:text>
	
	<!--Si la expresión posterior comienza con or hay que seguir procesando y añadir  un or a la nueva guarda-->
	<xsl:if test="starts-with(normalize-space($exp_post),'or')">
	
		<xsl:text> or </xsl:text>
		
		<!--Llamar recursivamente a la plantilla para los or restantes-->	
		<xsl:call-template name="m_or">
			<xsl:with-param name="exp_and" select="$exp_and"/>
			<xsl:with-param name="exp_m_or" select="normalize-space(substring-after($exp_post,'or'))"/>
		</xsl:call-template>
	
	</xsl:if>
	
	
</xsl:template>

</xsl:stylesheet>
