400390110. Transformaciones XSL

Para que funcione bien el código cuando se envía para que se ejecute en ordenadores remotos, necesitamos hacer una serie de asunciones en lo que concierne a la disponibilidad de ciertas configuraciones y entornos de hardware y de software. La independencia de la plataforma es así una cuestión importante. Para abordarlo, uno de los enfoque es suministrar una máquina abstracta para que el código compilado se ejecute en ella, y para garantizar que todos los usuarios remotos que quieren ejecutar los programas que se hacen llegar de forma remota tienen instalado ese entorno. Java y .NET son ejemplos de este enfoque.

No obstante, la instalación de entornos de este tipo en ordenadores clientes requiere importantes recursos. Si nos centramos en ejecutar código insertado en páginas web (páginas web dinámicas con scripting en el lado del cliente) disponemos de lenguajes scripting – JavaScript and VBScript— que son soportados por navegadores de web. Pero estos lenguajes padecen problemas de compatibilidad y estandarización. Un script en javaScript tiene que estar escrito en más de una versión si va a funcionar en distintos navegadores sin problemas. Otros, como VBScript, tienen soporte sólo en un número limitado de navegadores.

Otro enfoque más para ejecutar código en el lado del cliente utiliza applets de Java, que nos dan las funciones de un lenguaje de programación a escala completa (Java). Aún así, las applets de Java necesitan el Entorno de Runtime de Java, que consume recursos sustanciales en el lado del cliente.

Pero los navegadores tienen instalado otro tipo de procesador de lenguajes —Extensible Stylesheet Language Transformations (XSLT). Las hojas de estilos XSLT se aplican a documentos XML, fundamentalmente para generar páginas XHTML para su presentación en los navegadores. Así, XSLT ayuda a separar el contenido (dentro de los documentos XML) de la presentación (documentos XHTML). Como tal, XSLT apenas es un lenguaje scripting, aunque sí tiene suficientes características como para hacer que sea adecuado para la implementación de la semántica operacional de un lenguaje imperativo.

XIM es un lenguaje de programación basado en XML, con características de control imperativas, tales como asignación y bucles, y un intérprete escrito en XSLT. Los programas XIM pueden empaquetarse así con un procesador XIM (como una hoja de estilo XSLT) y ser enviados al cliente para su ejecución. En el presente artículo vamos a definir el lenguaje y a examinar su implementación de la semántica operacional en XSLT. Para mostrar la utilidad del código de empaquetado con su motor de ejecución, vamos a presentar una aplicación web que acepta las elecciones del usuario, obtiene parámetros para la operación solicitada y genera un programa XIM que hace la computación, y envía el programa – junto con su intérprete- al cliente para su ejecución.

Las implicaciones derivadas de este enfoque son significativas. En principio, no necesitamos restringirnos a los lenguajes de programación en el lado del cliente. Ni necesitamos hacer asunciones sobre la disponibilidad de ciertos entornos en el lado del cliente – aparte del procesador XSLT, que tiene ya soporte en todos los navegadores web importantes. Esto nos da libertad para elegir cualquier lenguaje de programación, siempre y cuando su procesador pueda ser empaquetado y enviado con él al cliente.

Una posible aplicación de esta idea está en la especificación de la semántica de los servicios web. Se puede enviar al cliente una expresión lambda, en una sintaxis adecuada basada en XML, que denota el significado del servicio, junto con una máquina de reducción lambda para ejecutarla. El cliente entonces o analiza o ejecuta la expresión lambda para ver si encaja con los requisitos deseados. Todo esto puede hacerse sin ninguna carga computacional en el lado del servidor.

Otra aplicación de esta idea tiene que ver con la computación distribuida, en la que se le proporcionan a un servidor los parámetros de una operación, que a su vez genera un programa que corresponde a la operación especificada y a los parámetros suministrados, empaqueta juntos el programa y el procesador de su lenguaje, y los envía al cliente para su ejecución.

El lenguaje Imperativo Mínimo XIM

Podemos considerar un programa XIM como la representación abstracta de un árbol de sintaxis de un programa escrito en un lenguaje de alto nivel imperativo y concreto con variables tipo float, expresiones que tienen operadores aritméticos, las normales expresiones Booleanas, una sentencia de asignación, un constructor condicional (if-then-else), y un constructor de iteración (while). La sintaxis formal de XIM se especifica usando un Esquema XML (disponible online; véase «Resource Center,» página 5, de la versión americana de DDJ). Los constructores XIM son sencillos. Cada elemento de sentencia en XIM tiene un atributo @seq, que actúa como la dirección simbólica del elemento.

El atributo @next nos da la dirección de la siguiente instrucción a ejecutar. En constructores y , los atributos @true_next (@false_next) determinan el flujo de control cuando la condición es true (false). Los valores de estos atributos se generan de forma automática, usando XSLT, antes de que se inicie la ejecución. El listado número 1 es un programa XIM que computa 5!, y que demuestra el uso de los constructores de asignación y while. El listado número dos es el mismo programa en pseudo-código.



1
0
5




var fact <-- 1 var last <-- 0 var nb <-- 5 begin last <-- nb while (last>1) do
fact <-- fact*last last <-- last-1 end while end
Listado número2

Semántica Operacional de XIM en XSLT

La semántica operacional especifica el significado de un programa en un lenguaje fuente dándole normas sobre cómo cambia el estado de una máquina abstracta (o real) en cada constructor del lenguaje fuente. Los estados de la máquina abstracta pueden representarse como parejas < code, memory > (denominadas "configuraciones"), en los que el código representa la computación restante, y memory es el contenido actual de la memoria de la máquina abstracta.

Una función de transición especifica la transición de una configuración de la máquina a la siguiente. La función de transición define la semántica operacional del lenguaje y puede actuar también como su intérprete. Al usar XSLT para especificar la semántica operacional de los lenguajes de programación, una configuración consiste en memoria, programa y valor actual del “contador de programas”, todo dentro del documento XML. La función de transición se especifica como plantillas XSLT.

Una hoja de estilos XSLT implementa la semántica operacional de XIM. Antes de iniciar la ejecución, la hoja de estilos transforma el programa XIM para prepararlo para la interpretación. En primer lugar se introduce el “contador de programas” como una variable del programa, y se insertan direcciones simbólicas en las instrucciones como atributos @seq . A continuación se establecen los valores en los atributos @next, @true_next de las instrucciones y se insertan en el código.

Estos atributos especifican la dirección de la siguiente instrucción a ejecutar, como en las gramáticas de atributos que se usan en la compilación dirigida a la sintaxis. Tras la fase de inicialización, se aplican otras plantillas al programa XIM transformado para ejecutarlo. La aplicación de las plantillas es un proceso iterativo, que se detiene cuando la instrucción siguiente es el elemento .

La plantilla de nivel alto (disponible online) de la hoja de estilos se corresponde con la raíz y realiza la aplicación de las plantillas para la inicialización e interpretación. Las plantillas para insertar el contador de programas y para invocar la plantilla del Secuenciador (disponible online) insertan el “contador de programas” como una variable XIM denominada PC y direcciones simbólicas como atributos @seq.

La plantilla del Secuenciador (disponible online) logra la inserción de las direcciones simbólicas mediante el uso del elemento de XSLT. Los valores de los atributos @next, @true_next, y @false_next son insertados a continuación por las plantillas que realizan el análisis caso a caso de un nodo dado para establecer su tipo, inspeccionar su posición relativa a otras instrucciones, y establecer la información sobre el flujo de control como direcciones de saltos según corresponda.

La plantilla para la implementación de los pasos iterativos es Interpret y la plantilla para determinar el tipo de instrucción en curso e invocar la plantilla correspondiente para su ejecución es Execute; ambas plantillas están disponibles online. La plantilla de asignación (disponible también online) recibe una sentencia de asignación como un sub-árbol XML en el parámetro $c. La plantilla además tiene acceso al documento XML como un todo a través del parámetro $prg, El nombre de la variable del programa al que se le va a asignar el nuevo valor es copiado en la variable $varname XSLT. Se recrea todo el elemento del documento XML para reflejar el valor actualizado de la variable, además del valor actualizado del "contador del programa" de la variable PC.

La plantilla Constructor (disponible online) controla la ejecución de las sentencias y . La instrucción, que es un constructor o viene al parámetro $c y el código del programa como un todo viene al parámetro $prg. Se determina el valor verdad de la condición y se asigna a la variable $condition de XSLT. Y después se copia el elemento , con todos sus hijos excepto el PC. Se actualiza el valor de la variable PC dependiendo del valor verdad de $condition. Cuando es "true," se asigna el valor del atributo @true_next del hijo del nodo de contexto a la variable PC. Cuando no lo es, se le asigna el valor del atributo @false_next.

La plantilla de Evaluar (disponible online), toma un parámetro $n que tiene un sub-árbol XML que representa una expresión. Las figuras 1 y 2 son, respectivamente, expresiones aritméticas y booleanas. Esta plantilla tiene además acceso a todo el programa XIM en el parámetro $p. Primero comprueba si el parámetro entrante es un literal numérico (), una variable (), o una expresión compleja ( or ). Si la expresión entrante del parámetro $n es una , devuelve el contenido del elemento . Si es un elemento (un valor r), se devuelve el valor del elemento referenciado por
Si la expresión de entrada es o , se establece el tipo de operación necesaria desde el atributo @opname. Los valores positivos en el atributo @opname para el elemento son *, +, -, /, intdiv, y mod, en tanto que las opciones para son or, and, not, lt, gt, eq, ne, ge, y le, que tienen sus significados convencionales.

Figura 1: Una expresión aritmética y su correspondiente código XIM.

Figura 2: Una expresión booleana y su correspondiente código XIM.

Las expresiones booleanas son evaluadas totalmente de la misma forma que las expresiones aritméticas (véase el fragmento de código de la plantilla Evaluar que maneja expresiones booleanas, disponible online).

Aplicación Web de muestra

En nuestra aplicación muestra, el usuario decide la función a invocar (una de "Factorial," "Fibonacci," "IsPrime" y "nthPrime"), proporciona el parámetro, y pincha en el botón correspondiente a la operación deseada. La estructura básica del código que procesa la entrada del cliente es:
-# XmlDocumentObject <- documento XML que contiene el código XIM de la computación solicitada. -# Obtener el parámetro de entrada del usuario e insertarlo en XmlDocumentObject. -# Insertar el elemento de instrucción del procesado para que declare la hoja de estilos del intérprete. -# Guardar el documento modificado en un fichero -# Redirigir al cliente al fichero XML guardado. Primero, se carga el código XIM almacenado y “preempaquetado” para la computación solicitada (cuya única parte que falta es el valor del parámetro de entrada) en un objeto XmlDocument y se inserta el parámetro suministrado por el usuario dentro del código en el punto adecuado. Después se inserta en el código la instrucción de procesado que indica el nombre de la hoja de estilos (el intérprete XIM) a aplicar. Se almacena en un documento XML el código resultante en el objeto, y se redirige el navegador cliente a este documento XML. Para demostrar lo que pasa cuando el cliente proporciona un parámetro y hace una elección, este código procesa una solicitud “factorial”:
private void FactBtn_Click(object sender, System.EventArgs e)

XmlDocument xmlDoc=new XmlDocument();
xmlDoc.Load("c://inetpub/wwwroot/xim/fact5.xml");
XmlElement var_n=xmlDoc.CreateElement("var_declare","");
var_n.InnerText=TextBox1.Text;
var_n.SetAttribute("name","nb");
// Adding name attribute to variable element
// Appending client input as a variable to XIM code
// for factorial computation
xmlDoc.DocumentElement.FirstChild.AppendChild(var_n);
XmlProcessingInstruction newPI;
// Processing instruction to declare stylesheet name
String PItext = "type='text/xsl' href='interp.xsl'";
// Assigning the name of the interpreter
// stylesheet to processing instruction
newPI = xmlDoc.CreateProcessingInstruction
("xml-stylesheet", PItext);
// Add processing instruction node to the document
xmlDoc.InsertBefore(newPI, xmlDoc.DocumentElement);
xmlDoc.Save("c://Inetpub/wwwroot/XIM/test.xml");
// Save the modifications to the XIM code
// Redirectng the client response
// to the just created XIM file
Response.Redirect("http://194.27.78.64/XIM/test.xml");


Véase la figura 3 para el resultado de la interpretación en la máquina cliente de la función factorial, aplicada al número “20.”

Figura 3: El resultado de la computación de 20! ejecutado y mostrado en el navegador del cliente.

Trabajo relacionado

XMILE (pizza.cs.ucl.ac.uk/xmile/) es un lenguaje imperativo basado en XML. Su objetivo es mantener sincronizados los dispositivos de información móviles mediante actualizaciones sin parar su ejecución. Los programas escritos en XMILE son transferidos en forma de fuente, y a continuación interpretados en el anfitrión remoto, que tiene al intérprete implementado en Java. En el caso de XMILE, el intérprete está ya existente/instalado en los clientes. En nuestro caso, el intérprete, implementado en XSLT, es empaquetado junto con el programa.

En el libro C++/XML (New Riders Publishing, 2001), Fabio Arjona Arciniegas describe cómo compilar intérpretes para lenguajes de scripting basados en XML.

En «Towards SMIL as a Foundation for Multimodal, Multimedia Applications» (publicado en Proceedings of EUROSPEECH 2001), Jennifer L. Beckham, et al., introduce ReX, que es un sencillo lenguaje reactivo de programación basado en XML.

Superx++ (xplusplus.sourceforge.net/indexPage.htm) es un lenguaje orientado a objetos y basado en XML cuyo entorno de runtime lo desarrolla Kimanzi Mati mediante C++ .

Conclusión

El envío de código por Internet para que sea ejecutado en navegadores clientes de web representa un grado mayor de libertad del que disponemos actualmente, que es que el lenguaje disponible en los navegadores está determinado, y sólo se envían al navegador los programas escritos en ese lenguaje, y los datos a usar por dicho programa.

La posibilidad de meter juntos en un paquete el procesador de lenguaje con el programa y los datos, abre enormes posibilidades, que permiten desarrollar y usar lenguajes con fines especiales sin requerir de los usuarios finales la instalación de componentes adicionales a su navegador web. Ello elimina también en gran medida los problemas de compatibilidad que emanan de la naturaleza no estandarizada de los lenguajes scripting (y de otros) incorporados a los navegadores de web actuales.