Sebenta XML 2015

Tecnologia XML
XML by Example
Lus Ferreira
verso 3.0
Setembro 2014
XML
A verso 3.0 deste documento apresenta:
Algumas correces ortogrficas
Processamento de XML em plataformas especficas;
Comparao entre XML e Json
Lus Ferreira - IPCA-EST 2014
ndice
ISI
ndice
Figuras .............................................................................................................................................................. 8
Tabelas ........................................................................................................................................................... 10
PARTE I XML E DTD

Apresentao ................................................................................................................................................. 13
Estrutura de um documento XML ................................................................................................................... 14
Markup .............................................................................................................................................................. 14
Elementos .......................................................................................................................................................... 14
Hierarquia de elementos ................................................................................................................................... 15
Atributos............................................................................................................................................................ 15
Parsing ............................................................................................................................................................... 16
Modelar documentos ........................................................................................................................................ 16
Referncias a Entidades .................................................................................................................................... 16
Comentrios ...................................................................................................................................................... 17
Processing Instructions (PI) ............................................................................................................................... 17
Declarao XML ou Prolog ................................................................................................................................ 17
Declarao de Markup ...................................................................................................................................... 18
Seces CDATA .................................................................................................................................................. 18
Visualizao de um documento XML ................................................................................................................ 19
Definies de Tipos de Documentos (DTD) ..................................................................................................... 21
Definies de Tipos de Elementos ................................................................................................................ 22
Definies de Listas de Atributos .................................................................................................................. 23
Definies de Entidades ................................................................................................................................ 24
Associar um DTD a um XML .......................................................................................................................... 26
Identificao da linguagem ........................................................................................................................... 27
Vlidos versus Correcto ................................................................................................................................ 27
Resumo .......................................................................................................................................................... 27
Exemplo de um documento XML ...................................................................................................................... 27
Exemplo de um documento DTD ...................................................................................................................... 28
Bibliografia ..................................................................................................................................................... 28
XML
ndice
Exerccios resolvidos .......................................................................................................................................29

Exerccios propostos .......................................................................................................................................30
PARTE II - XSD
Introduo ......................................................................................................................................................35
Tipos de Dados em XML Schemas ...................................................................................................................35
Simple Types ................................................................................................................................................. 35
Enumerao ............................................................................................................................................. 38
Padres (pattern) ..................................................................................................................................... 40
Espaos em branco (whiteSpaces) ........................................................................................................... 41
Tipos complexos (complexType) ................................................................................................................... 41
Elementos vazios: ..................................................................................................................................... 43
Resumindo: ....................................................................................................................................................... 45
Bibliografia: ....................................................................................................................................................46
Exerccios resolvidos .......................................................................................................................................47
Exerccios propostos .......................................................................................................................................53
PARTE III - XSL

Introduo ......................................................................................................................................................57
XSLT ................................................................................................................................................................57
Como se processa o XML com XSL ................................................................................................................ 57
Texto versus Instrues XSLT ........................................................................................................................ 58
XPath ................................................................................................................................................................. 59
Tipos de valores e nodos .......................................................................................................................... 61
Expresses ................................................................................................................................................ 62
Tutorial XPath ............................................................................................................................................... 72
Lidar com elementos ................................................................................................................................ 72
Lidar com Atributos .................................................................................................................................. 73
Lidar com elementos Pai ....................................................................................................................... 73
ndice
ISI
Navegao ................................................................................................................................................ 73
Indexao de Conjuntos de nodos............................................................................................................ 73
Operaes sobre conjuntos ...................................................................................................................... 74
XML StyleSheets ................................................................................................................................................ 74
xsl:stylesheet ................................................................................................................................................. 74
Referenciar uma StyleSheet ..................................................................................................................... 75
Templates ................................................................................................................................................. 76
Templates por omisso ............................................................................................................................ 77
Exemplo de StyleSheet (I) ......................................................................................................................... 79
Exemplo de StyleSheet (II) ........................................................................................................................ 81
Pattern Matching .......................................................................................................................................... 83
Nodo Raz .................................................................................................................................................. 84
Nodo Elemento ......................................................................................................................................... 84
Nodos Texto .............................................................................................................................................. 85
Matching condicional ............................................................................................................................... 85
Expresses XSLT essenciais ............................................................................................................................... 86
<xsl:value-of> ................................................................................................................................................ 86
<xsl:apply-templates/> ................................................................................................................................. 88
Tutorial XSLT ...................................................................................................................................................... 92
<xsl:value-of> ................................................................................................................................................ 92
<xsl:template> .............................................................................................................................................. 93
<xsl:for-each> ................................................................................................................................................ 94
not ................................................................................................................................................................. 95
<xsl:if> ........................................................................................................................................................... 97
<xsl:choose> .................................................................................................................................................. 99
<xsl:sort> ..................................................................................................................................................... 100
<xsl:element> .............................................................................................................................................. 101
<xsl:number> .............................................................................................................................................. 103
<xsl:param> ................................................................................................................................................. 104
<xsl:variable> .............................................................................................................................................. 105
6
XML
ndice
<xsl:call-template>...................................................................................................................................... 106
document() ................................................................................................................................................. 108
Mltiplos XML/StyleSheets ............................................................................................................................. 112
PARTE IV XSL APLICADO

XML e outras tecnologias ................................................................................................................................ 121
PHP e XML................................................................................................................................................... 121
XSL com JAVA .............................................................................................................................................. 126
XSL com JavaScript ...................................................................................................................................... 127
XSL com C# .................................................................................................................................................. 131
XML e CSS ................................................................................................................................................... 135
Outros exemplos de XML Stylesheets ............................................................................................................. 138
Desenhar uma tabela HTML ....................................................................................................................... 139
Gerar CSV .................................................................................................................................................... 141
Gerar WML ................................................................................................................................................. 143
Gerar XML ................................................................................................................................................... 145
Caso de Estudo .............................................................................................................................................146
Exemplo 1 Gesto de Actividades ao Ar Livre .............................................................................................. 146
Concluso .....................................................................................................................................................155
Bibliografia ...................................................................................................................................................157
Livros e Outros ................................................................................................................................................ 157
Revistas ........................................................................................................................................................... 157
Web sites......................................................................................................................................................... 157
ANEXO ..........................................................................................................................................................159
Expresses Regulares em XML Schemas ......................................................................................................... 159
Classes de caracteres .................................................................................................................................. 159
Subtraco de Classes de caracteres .......................................................................................................... 160
Alternncia.................................................................................................................................................. 160
Agrupamentos ............................................................................................................................................ 161
Ocorrncias ................................................................................................................................................. 161
Figuras
ISI
Exemplos ..................................................................................................................................................... 161
Figuras
Figura 1 - Hierarquia num documento XML .......................................................................................................... 15
Figura 2 - Processo de transformao via XSL ....................................................................................................... 58
Figura 3 - rvore XML ............................................................................................................................................ 61
Figura 4 - rvore XML ............................................................................................................................................ 64
Figura 5 - Nodo de Contexto .................................................................................................................................. 64
Figura 6 - Todos os descendentes C ....................................................................................................................... 64
Figura 7 - Filhos E do elemento C .......................................................................................................................... 65
Figura 8 - Elementos F filhos de E .......................................................................................................................... 65
Figura 9 - Axes em XPath ....................................................................................................................................... 66
Figura 10 - Resultado de aplicao de uma StyleSheet ......................................................................................... 80
Figura 11 - Resultado de aplicao de uma xsl ...................................................................................................... 81
Figura 12 - Lista de Contactos (I) ........................................................................................................................... 90
Figura 13 - Lista de Contactos (II) .......................................................................................................................... 91
Figura 14 - Exemplo de Aplicao de Multiplos XSL ............................................................................................ 115
Figura 15 - Exemplo PHP/XML: Login................................................................................................................... 121
Figura 16 - Resultado PHP/XSL............................................................................................................................. 126
Figura 17 - Frontend de Gesto do CV ................................................................................................................. 128
Figura 18 - Estrutura de um CV em XML .............................................................................................................. 129
Figura 19 - Dicionrio de termos em XML ........................................................................................................... 130
Figura 20 - Transformao de CV com Javascript ................................................................................................ 130
Figura 21- Estrutura XML de um livro .................................................................................................................. 131
Figura 22 - Classes envolvidas no processamento XML com C# .......................................................................... 133
Figura 23 - Navegar em XML com C# ................................................................................................................... 133
Figura 24 Seleco das seces pertendidas do Livro ...................................................................................... 134
Figura 25 - Preparar Navigator do XML em C# .................................................................................................... 134
XML
Tabelas
Figura 26 - Livro em HTML ................................................................................................................................... 135

Figura 27 - Aplicao de uma CSS a um HTML .................................................................................................... 136
Figura 28 - Aplicao de CSS a um documento XML ........................................................................................... 138
Figura 29 - Exemplo de aplicao de XSLT a XML ................................................................................................ 141
Figura 30 - Emulador de WML ............................................................................................................................. 145
Figura 31 Caso de Estudo: Resultado da aplicao de percursos.xsl ................................................................ 150
Figura 32 - Caso de Estudo: Resultado da aplicao de todospercursos.xsl ........................................................ 151
Figura 33 - Caso de Estudo: Resultado da aplicao de percursoscaminhadas.xsl ............................................. 152
Figura 34 - Caso de Estudo: Resultado da aplicao de bttcaminhadas.xsl ........................................................ 153
Tabelas
ISI
Tabelas
Tabela 1 - Documento XML ................................................................................................................................... 60
Tabela 2 - Abreviao de Axes ............................................................................................................................... 66
Tabela 3 Funes particulares ............................................................................................................................ 67
Tabela 4 - XML StyleSheet indevidamente estruturada ........................................................................................ 83
Tabela 5- Exemplo de Registo XML ...................................................................................................................... 116
Tabela 6 - Exemplo de Template com document() .............................................................................................. 116
10
PARTE I
XML - Extensible Markup Language
DTD Document Type Definition
XML
Apresentao
Apresentao
O XML (Extensible Markup Language) foi criado a partir do Standard Generalized Markup Language (SGML),
procurando evitar o carcter pesado e complexo que caracteriza este standard. Surge fundamentalmente
para descrever a estrutura (dos dados) de documentos. Em XML, os dados, o formato e a estrutura dos
documentos so anotados de forma separada. As regras que controlam a escrita de documentos XML assentam
nos Document Type Definition (DTD) ou XML Schemas (XSD).
Um documento que respeite a norma XML1.0 dever ser construdo baseado em restries sintcticas que
incluem elementos, definies de NameSpaces, atributos, processing instructions (PI), comentrios e texto.
Seguidamente cada um destes elementos sumariamente apresentado.
Breve aluso histrica
Primeiros passos nos anos 60 (GML - Generalized Markup Language)
1980 SGML - for Standard Generalized Markup Language (1986 ISO-Standard ISO 8879)
Desde 1996 - Chama-se Extensible Markup Language (XML)
Pontos fortes do XML
Adaptao: A adaptao infinita. Marcaes personalizadas podem ser criadas para qualquer
necessidade.
Manuteno: o XML fcil de manter. Ela contm somente idias e marcaes. Folhas de estilos e
links vm em separado e no embebidas no documento.
Simplicidade: o XML simples. O XML vai directo ao contexto.
Portabilidade: o XML de fcil portabilidade. A razo da sua existncia e expano fora da sua
portabilidade. O mesmo aconteceu com o html no seu incio.
Objectivos no desenvolvimento do XML

A especificao do XML primou pelos seguintes objetivos:
Teria que ser fcil usar o XML na Internet;
O XML deveria suportar uma grande variedade de aplicaes;
O XML deveria ser compatvel com SGML;
Deveria ser fcil escrever programas que processem documentos XML;
O nmero de recursos opcionais em XML deveria ser mantido num mnimo absoluto, idealmente zero;
Os documentos XML deveriam ser legveis pelos seres humanos e razoavelmente claros;
O projecto XML deveria ser preparado rapidamente;
13
Estrutura de um documento XML
XML
O projecto XML deveria ser formal e conciso;
Os documentos XML deveriam ser fceis de serem criados;
A conciso na marcao em XML de mnima importncia.
Como definido o XML?

O XML definido pelas seguintes especificaes:
Extensible Markup Language (XML) 1.0: define a sintaxe do XML;
XML Pointer Language (XPointer) e XML Linking Language (XLink): define um padro para
representar os links entre os recursos. Alm dos links simples, como a tag <A> da HTML, o XML possui
mecanismos para ligar recursos mltiplos e diferentes. A XPointer descreve como enderear um
recurso, e o XLink descreve como associar dois ou mais recursos;
Extensible Style Language (XSL): define a linguagem de folhas de estilos padro para o XML.
XML ou Json?
(em desenvolvimento)
Markup
Markup representa o conjunto das marcas ou anotaes utilizadas num documento XML e define a forma de
identificar as distintas partes ou dados de um documento. So essencialmente Elementos. O exemplo seguinte
define uma instncia do elemento trilho.
<trilho>Soajo Castrejo</trilho>
Elementos
Elementos so unidades bem identificadas que definem o essencial de um documento XML. Devem ter um
identificador (nome do elemento) expressivo, comeado por uma letra, underscore (_) ou dois-pontos (:).
Podem tambm conter dgitos (0,19), pontos (.) ou traos (-). Os whitespaces (espao, tabs e CR/LF)
devem ser evitados a no ser na estruturao da escrita do XML.
Maisculas e minsculas so distintas, no existe limitao para o tamanho do nome e no existe nenhum
conjunto pr-definido de nomes de elementos. Um elemento pode conter texto ou outros elementos (sub14
XML
elementos). Possuem uma marca de incio (start-tag) e uma marca de fim (end-tag) de elemento (excepto nos
elementos vazios, nos quais existe uma nica marca, <trilho/>, por exemplo). Entre as duas marcas est o
contedo (texto) desse elemento. A ordem e a precedncia tm de ser respeitadas
Hierarquia de elementos
Como vimos antes, um elemento ao possuir outros elementos constitui uma hierarquia. O topo dessa
hierarquia identificado como a raiz (root). O elemento root de um documento XML constitui o topo de todos
os elementos existentes nesse documento, sendo por isso nico. Cada elemento pode ser anotado com um
conjunto de atributos, cuja a ordem no obrigatria.
Ficha
poca
Nome
Distncia
Tipo
Actividade
Responsvel
Contacto
Datas
Data
Tcnicos
Tcnico
Figura 1 - Hierarquia num documento XML

contexto que leva muitas vezes a representar um documento XML numa estrutura de rvore invertida.
Atributos
Atributos so pares de valores nomeados que ocorrem dentro das marcas de incio aps o nome do elemento.
Por exemplo, o seguinte excerto xml
15
XML
<trilho id=1>Soajo Castrejo </trilho>

nome do atributo (id) valor do atributo (1)
define o elemento trilho com um atributo id cujo valor 1. Em XML, todos os valores de atributos devem
estar entre aspas. Cada elemento pode possuir um ou mais atributos, em qualquer ordem, mas no se podem
repetir dentro do mesmo elemento.
Parsing
O conceito de Parsing est associado necessidade de interpretar o contedo de documentos. No contexto do
XML, o parsing consiste no processo da interpretao do XML no sentido de identificar e distinguir as marcas (o
markup) dos contedos (dados) do documento. Assim tambm possvel verificar a existncia de erros (ex.
sintcticos).
Modelar documentos
Os documentos com estrutura idntica ou similar devem possuir o mesmo tipo de elementos de forma a
constiturem um modelo. Um modelo de documento, para alm de identificar o conjunto de elementos a
utilizar, define um conjunto de regras, quais os elementos permitidos, quais os opcionais, qual a ordem e grau
de ocorrncia, que atributos possuem, etc. Estas regras so armazenadas em ficheiros (no obrigatrios) ditos
validadores. Exemplos destes ficheiros so os Document Type definition (DTD ) e os XML Schemas (XSD). Um
parser responsabiliza-se ento por averiguar se um documento XML respeita ( vlido) as regras explcitas num
documento tipo DTD ou XSD. Mais frente voltaremos a este assunto.
Referncias a Entidades
Na introduo de contedo de um documento XML, poder acontecer, nomeadamente em textos
matemticos, a necessidade de inserir smbolos como o >, <, etc. A fim de evitar confuso com os caracteres <
e > que identificam as marcas XML, estes caracteres tm de ser apresentados de forma particular. Em XML, so
usadas entidades para representar estes caracteres especiais. As entidades podem tambm ser usadas para
referenciar um texto frequentemente repetido ou alterado ou includo no contedo de arquivos externos.
Cada entidade deve ter um nome nico. Para usar uma entidade, referencia-se pelo nome, com & e terminam
com um ponto-e-vrgula (&nome_entidade;).
Por exemplo, a entidade < insere o caracter < no documento. A cadeia de caracteres <element> pode
ser representada num documento XML como <<element>.
16
XML
Para inserir caracteres que no podem ser digitados directamente pelo teclado (caracteres Unicode), utilizamse referncias a caracter, utilizando uma das seguintes formas: referncias decimais, ℞ ou referncias
hexadecimais, ℞. Ambas se referem ao caracter Unicode nmero U+211E. A tabela seguinte resume
algumas das referncias possveis:
>
>
<
<
&
&
'
"
&
referncia a um caracter em decimal
&
referncia a um caracter em hexadecimal
&#160
non-breaking space

em HTML
Comentrios
Tal como acontece com o HTML, os comentrios iniciam com <!- e terminam com
-->. Os comentrios no so processados.

Processing Instructions (PI)

Algumas aplicaes necessitam de executar determinados processos nos documentos XML. Neste sentido,
criaram-se as Processing Instructions (PI), representadas pelos smbolos <? e ?> e o contedo so a palavra
chave (importante para a aplicao), um espao e a instruo. Um exemplo destas instrues o Prolog (ou
Declarao XML) dos documentos XML, ie, a primeira linha de qualquer documento xml, na qual se define,
entre outros a verso do XML a ser utilizado.
Declarao XML ou Prolog

Uma declarao
(tecnicamente designado por Prolog) uma PI para informao importante sobre o
documento XML. A palavra chave xml (<?xml ?>). Se existir, esta declarao dever ser escrita no
incio do documento. Vejamos alguns exemplos possveis:
17
XML
<?xml version=1.0?>
<?xml version=1.0 encoding=iso-8859-1?> <!- Portugus-->
<?xml version=1.0 encoding=UTF-8 standalone=yes?>
Pode conter vrios parmetros:
parmetro version (verso do XML)
parmetro opcional encoding (esquema de codificao de caracteres Portugus: iso-8859-1 )
parmetro optional standalone (No caso exista um conjunto externo de definies)
Declarao de Markup
A declarao de markup ou Declarao do Tipo de Documento, utilizada para identificar importantes
caractersticas do documento, para criar comentrios, reutilizar partes do documento (entities), para identificar
o DTD ou mesmo cri-lo. A declarao faz-se com os limitadores <! e >. Alguns exemplos possveis:
<!DOCTYPE trilhos SYSTEM trilhos.dtd>
<!DOCTYPE receita SYSTEM http://www.xpto.com/receita.dtd>
<!DOCTYPE receita SYSTEM http://www.xpto.com/receita.dtd
[
<!ENTITY html Hypertext Markup Language>

<!ENTITY xml Extensible Markup Language>
]
>
Seces CDATA
Num documento XML, uma seco CDATA permite a utilizao de caracteres especiais, como so o caso da
acentuao, pontuao dos textos, ou os prprios caracteres < e >. Muito til na escrita portuguesa. O seguinte
exemplo mostra isso mesmo:
<!CDATA[
*p = &q;
b = (i <= 3);
]]>
Outro exemplo:
<MarkupSample>
Isto um exemplo correcto de uso XMl com <![CDATA[<tags>]]
</MarkupSample>
18
XML
Entre o incio da seco, <![CDATA[, e o fim da seo, ]]>, todos os caracteres so passados directamente
para a aplicao, sem qualquer interpretao. A nica cadeia de caracteres que no pode ocorrer numa seco
CDATA "]]>".
Visualizao de um documento XML

O seguinte documento est escrito em HTML:
<html>
<body>
<h1>Rhubarb Cobbler</h1>
<h2>Maggie.Herrick@bbs.mhv.net</h2>
<h3>Wed, 14 Jun 95</h3>
<font face="arial,Helvetica">
Rhubarb Cobbler made with bananas as the main
sweetener.<br>
It was delicious. Basicly it was
<p>
<table border=1>
<tr><td> 2 1/2 cups <td> diced rhubarb
<tr><td> 2 tablespoons <td> sugar
<tr><td> 2 <td> fairly ripe bananas
<tr><td> 1/4 teaspoon <td> cinnamon
<tr><td> dash of <td> nutmeg
</table>
<p>
Combine all and use as cobbler, pie, or crisp.<br>
Related recipes: <a href="#GardenQuiche">Garden Quiche</a>
</font>
</body>
</html>
Cuja representao num browser resulta no seguinte aspecto:
19
XML
O mesmo documento em XML poderia ser descrito da seguinte forma:

<?xml version="1.0" encoding="iso-8859-1"?>
<recipe id="117" category="dessert">
<title>Rhubarb Cobbler</title>
<author><email>Maggie.Herrick@bbs.mhv.net</email></aut
hor>
<date>Wed, 14 Jun 95</date>
<description>
Rhubarb Cobbler made with bananas as the main sweetener.
It was delicious.
</description>
<ingredients>
<item><amount>2 1/2 cups</amount><type>dicedrhubarb
</type></item>
<item><amount>2
tablespoons</amount><type>sugar</type></item>
<item><amount>2</amount><type>fairly ripe
bananas</type></item>
<item><amount>1/4
teaspoon</amount><type>cinnamon</type></item>
<item><amount>dash
of</amount><type>nutmeg</type></item>
</ingredients>
<preparation>
Combine all and use as cobbler, pie, or crisp.
</preparation>
<related url="#GardenQuiche">Garden Quiche</related>
</recipe>
Cuja representao num browser resultaria no seguinte:
20
XML
Definies de Tipos de Documentos (DTD)

Uma das particularidades do XML a possibilidade de se atribuirem quaisquer nomes para as marcas a utilizar,
ie, existe total liberdade de nomear as marcas de acordo com o contexto, o idioma, etc. Por outro lado, para
uma dada aplicao, poder no ser significativo que marcas ocorram numa ordem arbitrria. Observe-se o
seguinte exemplo.
<nome>Text</nome><percurso id="Um" tipo="caminhada" grau="1"><distancia
units="Text">Text</distancia><dificuldade>Text</dificuldade>
Qual o significado deste documento? Embora sintacticamente correcto, este documento no oferece grande
clarividncia naquilo que descreve. Seria bom conseguir definir algumas restries na sequncia e
aninhamento das marcas que se utilizam. Como apresentado antes, isto conseguido atravs de um DTD
Document Type Definition ou XML XSchema (abordado noutro documento desta srie).
Mais genericamente, um DTD corresponde a meta-informao que rege o nome das marcas passveis de
utilizar, as suas possveis sequncias e aninhamentos, os valores dos seus atributos e seus tipos e padres, os
nomes de arquivos externos que podem ser referenciados e se eles podem ou no conter XML, o formato de
algum dado (no-XML) externo que pode ser referenciado e as entidades que podem ser encontradas.
H quatro tipos de definies em XML: definies de tipos de elementos, declaraes de listas de atributos,
definies de entidades e definies de notaes.
21
XML
Definies de Tipos de Elementos

Definies de tipos de elementos identificam os nomes dos elementos e a natureza do seu contedo. Uma
declarao normal de elemento tem o seguinte formato:
<!ELEMENT percursos (contacto, tipo?, percurso+)>
Esta declarao identifica o elemento com nome percursos, com um modelo de contedo (parte entreparntesis) que define aquilo que um elemento pode conter, neste caso, um contacto, um tipo
(opcional) e vrios percurso. As vrgulas entre os nomes dos elementos indicam que eles devem ocorrer
nessa ordem. O sinal de adio aps percurso indica que ele pode ser repetido mais do que uma vez, mas
deve ocorrer pelo menos uma vez. O ponto de interrogao aps o elemento tipo? indica que ele opcional
(pode estar ausente ou ocorrer somente uma vez). Um nome sem pontuao, como contacto, deve ocorrer
somente uma vez. O quadro seguinte resume a cardinalidade que possvel representar em DTDs.
A?
A opcional
A*
Zero ou mais As
A+
Um ou mais As
A,B
Um A seguido de um B
Alm dos nomes de elementos, o smbolo especial #PCDATA reservado para indicar texto. A clusula
PCDATA significa texto interpretvel (Parsed Character Data) e aplica-se na definio de elementos.
Os elementos que contm s outros elementos so ditos como tendo contedo de elementos. Os elementos
que contm outros elementos e #PCDATA, tm contedo misto.
Por exemplo, uma definio possvel para Nome poder ser
<!ELEMENT Nome (#PCDATA | Apelido)*>
A barra vertical | indica um relacionamento "ou" e o asterisco indica que o contedo opcional (pode ocorrer
zero ou mais vezes); desta definio, portanto, Nome pode conter zero ou mais caracteres e marcas Apelido,
misturadas em qualquer ordem. Todos os modelos de contedo misto devem ter esta forma: #PCDATA deve
aparecer primeiro, todos os elementos devem ser separados por barras verticais e o grupo inteiro deve ser
opcional.
Outros dois modelos de contedo possveis so: EMPTY que indica que o elemento no possui contedo (e,
consequentemente, no necessita de ter marca de fim de elemento) e ANY que indica que qualquer contedo
22
XML
permitido. O modelo de contedo ANY pode ser til durante a anlise de documentos, mas deve ser evitado
ao mximo numa verso final de um validador.
Definies de Listas de Atributos

As definies de listas de atributos identificam os atributos que um elemento pode conter, os tipos ou valores
que podem ter e qual valor o padro. Uma declarao normal de lista de atributos representada no
seguinte exemplo:
<!ATTLIST percurso
id ID #REQUIRED
tipo (caminhada | tt | canyoning | btt) #IMPLIED
grau (1 | 2 | 3 | 4 | 5) 1 >
Neste exemplo, o elemento percurso possui trs atributos: id, que do tipo ID e obrigatrio; tipo, que
uma das quatro palavras enumeradas e no obrigatrio; e grau, que poder ser um dos cinco dgitos
apresentados e que, caso nenhum valor seja especificado, ter o valor 1.
Existem seis tipos de atributos possveis:
1. CDATA
Atributos CDATA representam um conjunto de caracteres; qualquer texto permitido. No confundir
atributos CDATA com seces CDATA.
2. ID
O valor de um atributo ID deve ser um nome. Todos os valores usados para IDs num documento so
nicos, ie, no podem ser repetidos.
3. IDREF
ou IDREFS
O valor de um atributo IDREF deve ser o valor de um nico atributo ID de algum elemento no documento. O
valor de um atributo IDREFS pode conter valores IDREF mltiplos separados por espaos em branco.
4. ENTITY
ou ENTITIES
O valor de um atributo ENTITY deve ser o nome nico de uma entidade. O valor de um atributo ENTITIES pode
conter valores de entidades mltiplos separados por espaos em branco.
5. NMTOKEN
ou NMTOKENS
23
XML
Atributos de smbolos de nome so uma forma restrita do atributo de cadeia de caracteres. Em geral, um
atributo NMTOKEN deve consistir de uma nica palavra, mas no h restries adicionais para a palavra; no
tem que estar associado com outro atributo ou declarao. O valor de um atributo NMTOKENS pode conter
valores NMTOKEN mltiplos separados por espaos em branco.
6. Uma lista de nomes
Pode especificar-se o conjunto de valores possveis de atributo. feito atravs de enumerao dos nomes
pretendidos.
H quatro valores padro possveis:
#REQUIRED
O atributo deve ter um valor explicitamente especificado em cada ocorrncia do elemento no documento.
#IMPLIED
O valor do atributo no obrigatrio, e nenhum valor padro fornecido.
"valor"
Qualquer valor vlido pode ser dado a um atributo como padro. O valor do atributo no obrigatrio.
#FIXED
"value"
Uma declarao de atributo pode especificar que um atributo tem um valor fixo. Neste caso, o atributo no
obrigatrio, mas se ele ocorrer deve ter o valor especificado. Se no estiver presente, ser dado a ele o valor
padro.
O processador XML executa a normalizao dos valores dos atributos nos valores dos atributos: as referncias
de caracter so substitudas por caracteres referenciados, referncias a entidades so resolvidas
(recursivamente) e espaos em branco so normalizados.
Definies de Entidades
As definies de entidades permitem associar um nome com algum outro fragmento de contedo. Essa
construo pode ser um pedao de texto normal, um pedao de uma declarao de tipo de documento ou uma
referncia a um documento externo que contm ou texto ou dados binrios.
<!ENTITY IPCA
"Instituto Politcnico do Cvado e do Ave">
<!ENTITY extDoc
<!ENTITY IPCAlogo
SYSTEM
"/standard/legalnotice.xml">
SYSTEM "/images/logo.gif" NDATA GIF87A>
Existem trs tipos de entidades:

Entidades Internas
24
XML
Entidades internas associam um nome com uma cadeia de caracteres ou texto literal. A definio de IPCA no
caso anterior um exemplo de entidade interna. Usando &IPCA; em qualquer lugar do documento inserir
"Instituto Politcnico do Cvado e do Ave " naquele local.
Entidades internas podem incluir referncias para outras entidades internas, mas errado elas serem
recursivas.
A especificao XML pr-define cinco entidades internas:
< produz o sinal de menor, <
> produz o sinal de maior, >
& produz o E comercial, &
' produz um apstrofo, '
" produz aspas, "
Entidades Externas
Entidades externas associam um nome com o contedo de um outro documento. Permitem ao documento
XML referenciar o contedo de um outro documento; elas contm ou texto ou dados binrios. Se elas contm
texto, o contedo do documento externo inserido no ponto de referncia e analisado como parte do
documento referente. Dados binrios no so analisados e podem somente ser referenciados num atributo;
eles so usados para referenciar figuras e outro contedo no-XML no documento.
extDoc e IPCAlogo so exemplos de entidades externas.
O uso de &extDoc; inserir o contedo do arquivo /standard/ legalnotice.xml no local da
referncia da entidade. O processador XML analisar o contedo deste arquivo como se ele ocorresse
literalmente no local.
A entidade IPCAlogo tambm uma entidade externa, mas o seu contedo binrio. A entidade
IPCAlogo pode ser usada somente como o valor de um atributo ENTITY (ou ENTITIES) (num elemento
graphic, talvez). O processador XML passar esta informao para a aplicao, mas ele no tenta processar o
contedo de /images/logo.gif.
Entidades Parmetro
Uma entidade parmetro s pode ocorrer na declarao de tipo de documento. Uma declarao de uma
entidade parmetro identificada por "% " (porcento e espao) a seguir ao seu nome na declarao. O sinal de
% tambm usado em referncias para entidades parmetro, ao invs do &. As referncias a entidade
parmetro so imediatamente expandidas na declarao de tipo de documento e o seu texto de substituio
parte da declarao, onde as referncias a entidades normais no so expandidas. Entidades parmetro no
so reconhecidas no corpo de um documento.
25
XML
No exemplo seguinte, Nome e Apelido possuem o mesmo modelo de contedo.

<!ELEMENT Nome (#PCDATA | citao)*>
<!ELEMENT Apelido (#PCDATA | citao)*>
A mesma semntica pode ser definida com a utilizao de entidades parmetro. Ou seja, a nossa definio
poderia ficar:
<!ENTITY % pessoas "#PCDATA | citao">
<!ELEMENT Nome (%pessoas;)*>
<!ELEMENT Apelido (%pessoas;)*>
Este tipo de abordagem por um lado, permite dar um nome descritivo ao contedo, por outro permite alterar o
modelo de contedo num nico local. Para posterior alterao, a tarefa ficar assim facilitada.
Associar um DTD a um XML

Caso se pretenda associar um documento DTD a um XML, permitindo que o esse documento XML seja ou no
vlido, a Declarao de Tipo de Documento (DTD) deve ser a primeira expresso a definir num documento
XML, logo aps o Prolog.
A declarao de tipo de documento identifica o elemento raiz do documento e pode conter definies
adicionais. Todos os documentos XML devem ter um elemento raiz nico que contenha todo o contedo do
documento. As definies adicionais podem vir de um DTD externo, chamado de subconjunto externo, ou ser
includo directamente no documento, o subconjunto interno, ou ambos:
<?XML version="1.0" standalone="no"?>
<!DOCTYPE percursos SYSTEM "percursos.dtd">
Este exemplo referencia o DTD externo percursos.dtd.
A fim de determinar se um documento vlido, o processador XML deve ler a declarao de tipo de
documento por completo (ambos os subconjuntos).
A regra para os processadores XML que eles devem passar por todos os caracteres que no so marcao na
aplicao. Se o processador um processador de validao, ele tambm deve informar aplicao se os
caracteres espaos em branco so significantes.
O atributo especial xml:space pode ser usado para indicar explicitamente que os espaos em branco so
significantes. Em qualquer elemento que inclua a especificao de atributo xml:space='preserve',
todos os espaos em branco naquele elemento (e dentro dos sub-elementos que no alteram explicitamente
xml:space) sero significantes.
Os nicos valores vlidos para xml:space so preserve e default. O valor default indica que o
processamento padro desejado. Num DTD, o atributo xml:space deve ser declarado como um tipo
enumerado com somente estes dois valores.
26
XML
Resumo
Identificao da linguagem
Muitas aplicaes de processamento de documentos podem beneficiar da informao sobre a linguagem
natural com a qual o documento foi escrito. O XML define o atributo xml:lang para identificar a linguagem.
Visto que o propsito deste atributo padronizar a informao entre as aplicaes, a especificao XML
tambm descreve como as linguagens devem ser identificadas.
Vlidos versus Correcto

Um documento que respeita todas as regras sintticas do XML considerado um documento Correcto. Caso
possua associado um DTD ou Xschema o documento considerado Vlido.
Resumo
Os documentos XML so compostos por marcas e contedos. Existem seis tipos de marcas que podem ocorrer
num documento XML. So elas elementos, referncias a entidades, comentrios, instrues de processamento
(PI), seces marcadas e definies de tipos de documento (DTD).
Exemplo de um documento XML

(actividade.xml)
<?xml version="1.0"?>
<!DOCTYPE actividades SYSTEM "actividade.dtd">
<actividades ano="2003" by="lufer">
<actividade id="1" tipo="caminhada">
<nome>Caminhada Sombra</nome>
<distancia units="km">8</distancia>
<dificuldade>1</dificuldade>
<epoca>Verao</epoca>
<datas>
<data>12-06</data>
<data>14-07</data>
</datas>
<track tipo="gps">waypoints_soajo.txt</track>
<tecnicos>
<nome>Lufer</nome>
</tecnicos>
</actividade>
<actividade id="3" tipo="tt">
<nome>Rota do Geres</nome>
<epoca>Primavera</epoca>
<datas>
<data>10-04</data>
</datas>
<track tipo="roadbook">roadbook_geres.txt</track>
<tecnicos>
<nome>Romeu</nome>
<nome>Lufer</nome>
</tecnicos>
27
Bibliografia
XML
</actividade>
</actividades>
Exemplo de um documento DTD

(actividade.dtd)
<!ELEMENT actividades (actividade)+>
<!ELEMENT actividade (nome,distancia,dificuldade,epoca,datas,track,tecnicos>
<!ELEMENT nome (#PCDATA)>
<!ELEMENT distancia (#PCDATA)>
<!ELEMENT epoca (#PCDATA)>
<!ELEMENT data (#PCDATA)>
<!ELEMENT datas (data+)>
<!ELEMENT tecnicos (nome+)>
<!ELEMENT track (#PCDATA)>
<!ATTLIST actividade
id ID #REQUIRED
tipo CDATA #REQUIRED>
<!ATTLIST distancia units CDATA REQUIRED>
<!ATTLIST track tipo CDATA #REQUIRED>
Bibliografia
N. Bradley, The XML-Companion, Addison Wesley, London (2002).
Dr. Thomas Meinike, TMs XML-Kurs, Merseburg (2000 - 2004).
URLs
http://www.xmlfiles.com
http://www.4guysfromrolla.com/webtech/xml.shtml
http://www.topxml.com
http://www.ipca.pt/prof/lufer/2005-2006/sia/
Outros URLs
o
The Unicode Character Code
Character Model for the World Wide Web 1.0: Fundamentals
http://www.w3.org/TR/charmod/
The XML CD BookShelf
28
http://www.unicode.org/charts/symbols.html
http://www.kerrycomputers.com/ref/xml/index.htm
XML
Exerccios resolvidos
Expresses Regulares em Perl
http://www.cs.tut.fi/%7Ejkorpela/perl/regexp.html
1.
Defina um elemento XML com o nome entrada com dois atributos:
numero com o valor 24
data com valor 02-03-2006
Resoluo
<entrada numero=24 data=02-03-2006>
...
</entrada>
2.
Represente num documento XML a hierarquia de um Livro com ndice, Captulos, Autor e Anexos. O
Autor possui um nome e um endereo.
Resoluo
<livro>
<ndice> </ndice>
<capitulos>
<capitulo> </capitulo>
<capitulo> </capitulo>
</capitulos>
<autor>
<nome> </nome>
<ender> </ender>
</autor>
</livro>
3.
Defina uma instncia de um documento XML capaz de ser validado pelo seguinte DTD:
<!ELEMENT A (B,C,D?)>
<!ELEMENT B (#PCDATA)>
<!ELEMENT C (#PCDATA)>
<!ELEMENT D (B | #PCDATA)*>
Resoluo
<A>
<B> </B>
<C> </C>
<D>
<B> </B>
<B> </B>
</D>
</A>
29
Exerccios propostos
4.
XML
Defina um documento DTD capaz de validar o exemplo actividade.xml apresentado ao longo do

documento.
Resoluo
<!ELEMENT actividade (nome, distancia, dificuldade,
datas, track, tecnicos)>
<!ATTLIST actividade
id ID #REQUIRED
tipo (caminhada | tt) #REQUIRED
>
<!ELEMENT actividades (actividade+)>
<!ATTLIST actividades
ano CDATA #REQUIRED
by CDATA #REQUIRED
>
<!ELEMENT data (#PCDATA)>
<!ELEMENT datas (data+)>
<!ELEMENT dificuldade (#PCDATA)>
<!ELEMENT distancia (#PCDATA)>
<!ATTLIST distancia units CDATA #REQUIRED>
<!ELEMENT epoca (#PCDATA)>
<!ELEMENT nome (#PCDATA)>
<!ELEMENT tecnicos (nome+)>
<!ELEMENT track (#PCDATA)>
<!ATTLIST track tipo (gps | roadbook) #REQUIRED>
epoca,
Exerccios propostos
1.
2.
Defina um documento XML capaz de descrever os seguintes conceitos:
Um veculo automvel
Uma Receita
Um catlogo de CDs
Um animal
Verifique se o seguinte documento XML bem formado. Se no for, corrija-o.

<?xml version="1.0" encoding="UTF-8"?>
<percursos by="lufer>
<contacto>
<nomeText</nome>
<email>Text</email>
<telef/>Text</telef>
</contacto>
<percurso id="Um" tipo="caminhada" grau="1">
<nome>Text</nome>
<distancia units="Text">Text<distancia>
<dificuldade>Text</dificuldade>
<epoca>Text<poca/>
<track tipo="gps">Text</track>
<percurso/>
</percursos>
30
XML
Exerccios propostos
3.
Elabore um DTD que valide o documento XML da alnea 2.
4.
Elabore um documento XML que descreva uma biblioteca. Defina tambm um documento DTD que o
certifique.
31
PARTE II
XSD - XML Schemas
XSD
Introduo
Introduo
Este documento constitui a segunda parte do documento Tecnologias XML e vai debruar-se sobre validao
de documentos XML com XML Shchemas. Na primeira parte foram abordados os conceitos fundamentais da
linguagem de Markup XML e validadores DTD.
Para complemento deste documento, recomenda-se a leitura atenta e com calma das recomendaes W3C
Recomendation sobre Xml schemas.1
Um XML Schema (doravante abreviado por XSD) mais uma forma de validar um documento XML.
Contrapondo com os Document Type Definition (DTD), os XSD so eles prprios escritos em XML e, uma vez
que sero validadores, tero de salvaguardar as condies sobre os elementos, os atributos e os contedos. Os
XSD j permitem controlar o tipo de contedo e a forma com podem ser escritos, i.e., alguma semntica passa
a ser garantida
Existem tipos de dados, expresses regulares, etc, tudo mecanismos que tornam esta
tecnologia bem mais poderosa que os DTD, mas tambm mais complexa.
Tipos de Dados em XML Schemas

Existem dois tipos de dados: simples ou complexos, respectivamente simpleType e complexType. simpleTypes
referem-se definio de regras para valores (ou contedo) que um elemento XML pode possuir. Por exemplo,
uma regra possvel poder ser: um elemento <name> s poder conter caracteres e no dgitos. Mas vejamos
com mais algum calma estes conceitos. Na prtica,
<name>Benfica</name>
vlido
<name>Porto 2007</name>
invlido
Simple Types
atomic:
tipos com valores indivisveis. Ex: 10, Palavra
list:
lista de valores atmicos separados por espaos. Ex: 10 Palavra 20
union:
valores atmicos ou lista de valores
O contedo de um simpleType pode ser:

annotation?, (restriction | list | union)
Um exemplo de simpleType com nome (SizeType)

<xsd:simpleType name="SizeType">
<xsd:restriction base="xsd:integer">
http://www.w3.org/TR/xmlschema-0/.
35
XSD
<xsd:minInclusive value="2"/>
<xsd:maxInclusive value="18"/>
</xsd:restriction>
</xsd:simpleType>
Uma referncia a este tipo:

<xsd:element name="size" type="SizeType"/>
Um exemplo de simpleType sem nome

<xsd:element name="size">
<xsd:simpleType>
</xsd:restriction>
</xsd:simpleType>
</xsd:element>
Qualquer simpleType uma restrio de um outro simpleType, dito como o seu tipo base. Um simpleType no
pode ser expandido (extended), a no ser adicionando atributos. Neste caso resulta num complexType.
O seguinte exemplo mostra um simpleType derivado do tipo atmico integer:
<xsd:pattern value="\d{1,2}"/>
</xsd:restriction>
</xsd:simpleType>
Neste caso, restringe-se SizeType a um conjunto de dois inteiros entre os valores 2 e 18.
O exemplo seguinte mostra um outro simpleType derivado de um outro tipo construdo (SizeType),
<xsd:simpleType name="MediumSizeType">
<xsd:restriction base="SizeType">
</xsd:restriction>
36
XSD
</xsd:simpleType>
Um tipo derivado tem de ser mais restrito que o seu tipo base. No exemplo seguinte tal no respeitado.
<xsd:simpleType name="SmallDSizeType">
<xsd:restriction base="SizeType">
</xsd:restriction>
</xsd:simpleType>
Sempre que se pretenda evitar que determinado regra seja restrita, deve utilizar-se activar o atributo fixed.
Somente as facetas enumeration e pattern que no podem ser fixadas2. Por exemplo,
<xsd:minInclusive value="2" fixed="true"/>
<xsd:maxInclusive value="18" fixed="true"/>
</xsd:restriction>
</xsd:simpleType>
Caso se pretenda permitir valores vazios (empty) num dado elemento (a maioria dos tipos atmicos no
permitem valores nulos). Para conseguir isto pode utilizar uma unio (union) onde refira o tipo que pretende
(tipo inteiro xsd:integer) e a string nula (). Por exemplo,
<xsd:union>
<xsd:simpleType>
<xsd:restriction base=xsd:integer>
</xsd:restriction>
</xsd:simpleType>
</xsd:simpleType>
<xsd:restriction base=xsd:string>
<xsd:enumeration value=/>
</xsd:restriction>
<xsd:simpleType>
2
Consultar http://www.w3.org/TR/xmlschema-0/#SimpleTypeFacets para mais informao sobre

facetas
37
XSD
</xsd:union>
</xsd:simpleType>
Nota:
As facetas totalDigits e fractionDigits permitem controlar o nmero mximo de dgitos de um nmero e o
mximo de dgitos na parte decimal de um nmero, respectivamente. totalDigits deve ser um nmero positivo.
fractionDigits aplica-se a nmeros decimais (xsd:decimal).
Enumerao
Permite especificar o conjunto de valores possveis para um dado elemento. O valor enumerado tem de ser
nico e tem de ser vlido para o tipo base. Veja os seguintes exemplos:
<xsd:simpleType name="SMLXSizeType">
<xsd:restriction base="xsd:token">
<xsd:enumeration value="small"/>
<xsd:enumeration value="medium"/>
<xsd:enumeration value="large"/>
<xsd:enumeration value="extra large"/>
</xsd:restriction>
</xsd:simpleType>
Restringindo uma enumerao:

<xsd:simpleType name="SMLSizeType">
<xsd:restriction base="SMLXSizeType">
</xsd:restriction>
</xsd:simpleType>
Alguma prtica sobre tudo isto

O que se passa com o seguinte exemplo?
<xsd:simpleType name="XSMLXSizeType">
<xsd:restriction base="SMLXSizeType">
<xsd:enumeration value="extra small"/>
38
XSD
<xsd:enumeration value="extra large"/>
</xsd:restriction>
</xsd:simpleType>
Trata-se de uma restrio invlida pois pretende acrescentar mais um valor que no faz parte do conjunto
inicial. Como o posso fazer ento para acrescentar mais um valor numa restrio? Atravs de um tipo union.
Vejamos:
<xsd:simpleType name="XSMLXSizeType">
<xsd:union memberTypes="SMLXSizeType">
<xsd:simpleType>
<xsd:restriction base="xsd:token">
<xsd:enumeration value="extra small"/>
</xsd:restriction>
</xsd:simpleType>
</xsd:union>
</xsd:simpleType>
Analise agora o seguinte exemplo:

<xsd:simpleType name="NewSmallDressSizeType">
<xsd:enumeration value="2"/>
</xsd:restriction>
</xsd:simpleType>
As seguintes instncias sero vlidas? Em que circunstncias que eventualmente no sero?

<size>2</size>
<size>02</size>
S no sero vlidas no caso em que o tipo base seja string, isto porque a string 2 diferente de 02.
39
XSD
Padres (pattern)
Permite restringir valores para um determinado padro, seguindo Expresses Regulares3, utilizando a faceta
xsd:pattern. No exemplo seguinte,
<xsd:simpleType name="DressSizeType">
</xsd:restriction>
</xsd:simpleType>
Uma instncia possvel poder ser:

<valor>09</valor>
<valor>12</valor>
restringe-se aos inteiros de um ou dois dgitos, compreendidos entre 2 e 18. Para restringir um pattern deve-se
usar o classificador xsd:restriction como se mostra no seguinte exemplo:
<xsd:simpleType name="SmallDressSizeType">
<xsd:restriction base="DressSizeType">
<xsd:pattern value="\d{1}"/>
</xsd:restriction>
</xsd:simpleType>
Neste caso, o tamanho agora admitido condiciona a valores com um dgito. Uma instncia possvel poder ser:
<valor>4</valor>
<valor>3</valor>
J a seguinte restrio no correcta. Porqu?

<xsd:simpleType name="LongerDressSizeType">
<xsd:restriction base="DressSizeType">
</xsd:restriction>
40
Idnticas s Expresses Regulares utilizadas em Perl Consultar Sebenta de ISI-2009

XSD
</xsd:simpleType>
Porque est a ir contra a definio do tipo base DressSizeType.
Espaos em branco (whiteSpaces)

O tratamento de espaos em branco nos contedos tipo texto merece um tratamento cuidado. A faceta
utilizada whiteSpace. Os valores possveis podem ser:
preserve: respeita os espaos existentes
replace: substitui todas as ocorrncias de tabs (#x0), linefeed (#xA) e carriage return (#xD) por um
espao simples (#x20).
collapse: Tal como em replace. Mas neste caso se existirem vrias ocorrncias consecutivas de
espaos, so colapsadas a um.
A tabela seguinte pretende mostrar a generalidade do que acontece:

String original
string
normalizedstring
token
Ola mundo
Ol mundo
Ol mundo
Ol mundo
Ol
Ol
Ol mundo
Ol mundo
Mundo
Mundo
Ol..mundo
Ol..mundo
Ol.mundo
Ol.mundo
->
->
->
Ol mundo
Ol mundo
..Ol mundo
Ol mundo
..Ol mundo
Ol mundo
..Ol mundo
Ol mundo
Tipos complexos (complexType)

Sempre que um elemento possua atributos ou elementos na sua constituio, ser um complexType. Existem
dois tipos complexos. Ambos permitem ter atributos mas um, o simpleContent, restringe conter s texto no seu
contedo enquanto que o outro, complexContent, permite tambm ter elementos4,
Vamos fazer um pequeno exerccio.
Suponhamos o seguinte simpleType e um elemento pessoa que o refere:
<xsd:simpleType name="nomeType">
Ler artigo: Understanding W3C Schema Complex Types em

http://www.xml.com/pub/a/2001/08/22/easyschema.html
4
41
XSD
<xsd:restriction base="string">
<enumeration value="lufer" />
</xsd:restriction>
</xsd:simpleType>
e seja ento o elemento nome definido como:

<xsd:element name=pessoa type=nomeType>
Uma instncia XML possvel poderia ser ento

<pessoa>lufer</pessoa>.
Se agora pretendermos colocar um atributo neste elemento, temos de decidir se queremos ou no que existam
outros elementos na sua definio. Vamos supor que no. Ento ficaria:
<xsd:complexType name="novoMeuNomeType">
< xsd:simpleContent>
< xsd:extension base="nomeType ">
< xsd:attribute name="apelido" type=" xsd:string" />
</ xsd:extension>
</ xsd:simpleContent>
</ xsd:complexType>
Agora uma instncia XML possvel poderia ser ento

<pessoa apelido=Ferreira>lufer</pessoa>.
Supondo agora que se pretendia colocar novos elementos, para alm dos atributos. Poderia ento ficar:
<xsd:complexContent>
<xsd:restriction base="xsd:anyType">
<xsd:sequence>
<xsd:element name="nome" type="string" />
<xsd:element name="clube" type="string" />
</xsd:sequence>
<xsd:attribute name="apelido" type="string" />
</xsd:restriction>
</xsd:complexContent>
</xsd:complexType>
<element name="pessoa" type=" novoMeuNomeType " />
42
XSD
Agora uma instncia XML possvel poderia ser ento

<pessoa apelido=Ferreira>
<nome>lufer</nome>
<clube>Benfica</clube>
</pessoa>.
O mesmo se pode conseguir de uma forma mais restrita:

<xsd:sequence>
<xsd:element name="nome" type="string" />
<xsd:element name="clube" type="string" />
</xsd:sequence>
</xsd:complexType>
Elementos vazios:
Numa lgica semelhante, retiram-se as regras para o contedo. UM elemento vazio no pode possuir
elementos.
</xsd:restriction>
</xsd:complexType>
Simplificando,
</xsd:complexType>
Se tambm no tiver atributos, ento resulta em:

43
XSD
</xsd:restriction>
</xsd:complexType>
<xsd:complexType name="novoMeuNomeType"/>
44
XSD
Resumindo:
Tipos de Dados intrnsecos ao XML Schema:
Imagem retirada de W3C Recommendation, em http://www.w3.org/TR/xmlschema-2/#built-in-datatypes
45
Bibliografia:
XSD
Regras para a definio de um novo tipo
Criar um novo tipo
Esse tipo ter elementos ou atributos

sim
no
complexType
simpleType
Ter elementos?
Derivado por:
sim
complexContent
(permite elementos, texto
e atributos)
Derivado por:
<restriction>
contedo?
atributos?
</restriction>
ou
<extention>
contedo?
atributos?
</extension>
<restriction>
ou
<list>
ou
<union>
no
simpleContent
(permite texto e atributos)
Derivado por:
<restriction>
<simpleType>
facetas?
atributos?
</restriction>
ou
<extention>
contedo?
atributos?
</extension>
Bibliografia:
1.
DVD da Disciplina
2.
N. Bradley, The XML-Companion, Addison Wesley, London (2002).
3.
Dr. Thomas Meinike, TMs XML-Kurs, Merseburg (2000 - 2004).
4.
URLs
46
http://www.xml.com/pub/a/2001/08/22/easyschema.html
http://www.w3c.org
http://www.xmlfiles.com
http://www.4guysfromrolla.com/webtech/xml.shtml
XSD
http://www.topxml.com
1.
Considere o seguinte documento Percursos.xml

<percursos by="Text" xmlns:xsi="http://www.w3.org/2001/XMLSchemainstance" xsi:noNamespaceSchemaLocation="Percursos.xsd">
<contacto>
<nome>Text</nome>
<email>Text</email>
<telef>Text</telef>
</contacto>
<percurso id="Um" tipo="caminhada" grau="1">
<nome>Text</nome>
<distancia units="Text">Text</distancia>
<dificuldade>Text</dificuldade>
<epoca>Text</epoca>
<track tipo="gps">Text</track>
</percurso>
</percursos>
1.1
Desenvolva o documento Percursos.xsd capaz de validar esta descrio.
Resposta possvel:
<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema"
elementFormDefault="qualified">
<!Elementos -->
<xs:element name="dificuldade" type="xs:string"/>
<xs:element name="email" type="xs:string"/>
<xs:element name="epoca" type="xs:string"/>
<xs:element name="nome" type="xs:string"/>
<xs:element name="telef" type="xs:string"/>

47
XSD
<xs:complexType name="contactoType">
<xs:sequence>
<xs:element ref="nome"/>
<xs:element ref="email"/>
<xs:element ref="telef"/>
</xs:sequence>
</xs:complexType>
<xs:complexType name="distanciaType">
<xs:simpleContent>
<xs:extension base="xs:string">
<xs:attribute name="units" type="xs:string"
use="required"/>
</xs:extension>
</xs:simpleContent>
</xs:complexType>
<xs:complexType name="percursoType">
<xs:sequence>
<xs:element ref="nome"/>
<xs:element name="distancia" type="distanciaType"/>
<xs:element ref="dificuldade"/>
<xs:element ref="epoca"/>
<xs:element name="track" type="trackType"/>
</xs:sequence>
<xs:attribute name="id" type="xs:string" use="required"/>
<xs:attribute name="tipo" type="xs:string" use="required"/>
<xs:attribute name="grau" type="xs:boolean" use="required"/>
</xs:complexType>
<xs:element name="percursos">
<xs:complexType>
<xs:sequence>
<xs:element name="contacto" type="contactoType"/>
<xs:element name="percurso" type="percursoType"/>
</xs:sequence>
<xs:attribute name="by" type="xs:string"
use="required"/>
</xs:complexType>
</xs:element>
48
XSD
<xs:complexType name="trackType">
<xs:simpleContent>
<xs:extension base="xs:string">
<xs:attribute name="tipo" type="xs:string"
use="required"/>
</xs:extension>
</xs:simpleContent>
</xs:complexType>
</xs:schema>
2.
Considere o seguinte documento contratc.xml

<Contract>
<Title>Contracto para troca de dados entre American Data, Inc. e
European Data Ltd.</Title>
<Parties>
<Contractor>
<Name>American Data, Inc.</Name>
<Address>
<Office>12 Columbus House</Office>
<Street>Columbus Avenue</Street>
<City>San Francisco</City>
<Province>
<State>CA</State>
</Province>
<Code>
<ZipCode>12345</ZipCode>
<PostCode>W1 11H</PostCode>
</Code>
<Country>USA</Country>
</Address>
<ContactMethod PreferredContact="Telephone">
<Telephone>123456789</Telephone>
</ContactMethod>
</Contractor>
<Contractee>
<Name>European Data Ltd.</Name>
<Address>
49
XSD
<Office>No 1 Queen's Gardens</Office>

<Street>Hyde Park</Street>
<City>London</City>
<Code>
<PostCode>W1 11H</PostCode>
</Code>
<Country>UK</Country>
</Address>
<ContactMethod PreferredContact="Telephone">
<Telephone>0207123456</Telephone>
</ContactMethod>
</Contractee>
</Parties>
<ContractAgreement>
<ContractBody>
<Terms>
<Term>Exchange of data relating to x,y, and z.</Term>
<Term>All accounts to be settled within 30
days</Term>
</Terms>
<Conditions>That all data is to be structured</Conditions>
<ContractText>This contract establishes...</ContractText>
</ContractBody>
<Authorisation authorisationCode="LONSF"/>
</ContractAgreement>
</Contract>
2.1
Desenvolva o documento contract.xsd capaz de validar esta descrio.
Resposta possvel:
<xsd:schema xmlns:xsd="http://www.w3.org/2000/10/XMLSchema"
elementFormDefault="unqualified">
<xsd:element name="City" type="xsd:string"/>
<xsd:element name="Conditions" type="xsd:string"/>
<xsd:element name="ContractText" type="xsd:string"/>
<xsd:element name="Name" type="xsd:string"/>
<xsd:element name="Term" type="xsd:string"/>
<xsd:complexType name="AuthorisationType">
50
XSD
<xsd:simpleContent>
<xsd:restriction base="xsd:string">
<xsd:attribute name="authorisationCode"
type="xsd:string"/>
</xsd:restriction>
</xsd:simpleContent>
</xsd:complexType>
<xsd:element name="Contract">
<xsd:complexType>
<xsd:sequence>
<xsd:element ref="Title"/>
<xsd:element name="Parties" type="PartiesType"/>
<xsd:element name="ContractAgreement"
type="ContractAgreementType"/>
</xsd:sequence>
</xsd:complexType>
</xsd:element>
<xsd:complexType name="ContractAgreementType">
<xsd:sequence>
<xsd:element name="ContractBody" type="ContractBodyType"/>
<xsd:element name="Authorisation" type="AuthorisationType"/>
</xsd:sequence>
</xsd:complexType>
<xsd:complexType name="ContractBodyType">
<xsd:sequence>
<xsd:element name="Terms" type="TermsType"
maxOccurs="unbounded"/>
<xsd:element ref="Conditions" maxOccurs="unbounded"/>
<xsd:element ref="ContractText" minOccurs="0"/>
</xsd:sequence>
</xsd:complexType>
<xsd:complexType name="ContractorType">
<xsd:sequence>
<xsd:element ref="Name"/>
<xsd:element name="Address" type="AddressType"/>
<xsd:element name="ContactMethod" type="ContactMethodType"/>
</xsd:sequence>
51
XSD
</xsd:complexType>
<xsd:complexType name="AddressType">
<xsd:sequence>
<xsd:element name="Office" type="xsd:string"/>
<xsd:element name="Street" type="xsd:string" maxOccurs="2"/>
<xsd:element name="City" type="xsd:string"/>
<xsd:element ref="Province" minOccurs="0"/>
<xsd:element name="Code" type="CodeType"/>
<xsd:element ref="Country" minOccurs="0"/>
</xsd:sequence>
</xsd:complexType>
<xsd:element name="Province">
<xsd:complexType>
<xsd:choice>
<xsd:element name="County" type="xsd:string"/>
<xsd:element name="State" type="xsd:string"/>
</xsd:choice>
</xsd:complexType>
</xsd:element>
<xsd:complexType name="CodeType">
<xsd:choice>
<xsd:element name="PostCode" type="xsd:string"/>
<xsd:element name="ZipCode" type="xsd:integer"/>
</xsd:choice>
</xsd:complexType>
<xsd:complexType name="ContactMethodType">
<xsd:annotation>
<xsd:documentation>Utilize o atributo PreferredContact
indicar o contacto preferido</xsd:documentation>
para
</xsd:annotation>
<xsd:sequence>
<xsd:element name="Email" type="xsd:string" minOccurs="0"/>
<xsd:element name="Fax" type="xsd:string" minOccurs="0"/>
<xsd:element name="Telephone" type="xsd:integer"/>
</xsd:sequence>
<xsd:attribute name="PreferredContact" type="xsd:string"/>
</xsd:complexType>
52
XSD
Exerccios propostos
<xsd:element name="Country">
<xsd:simpleType>
<xsd:restriction base="xsd:string">
<xsd:enumeration value="UK"/>
<xsd:enumeration value="USA"/>
</xsd:restriction>
</xsd:simpleType>
</xsd:element>
<xsd:complexType name="PartiesType">
<xsd:sequence>
<xsd:element name="Contractor" type="ContractorType"/>
<xsd:element name="Contractee" type="ContractorType"/>
</xsd:sequence>
</xsd:complexType>
<xsd:complexType name="TermsType">
<xsd:sequence>
<xsd:element ref="Term" maxOccurs="unbounded"/>
</xsd:sequence>
</xsd:complexType>
<xsd:element name="Title" type="xsd:string"/>
</xsd:schema>
Exerccios propostos
Defina um XML Schema para cada um dos seguintes contextos:
Um curso do IPCA
Um armazm de stocks
53
PARTE III
XSLT - XML StyleSheets Transformation
XSD
Introduo
Introduo
Este documento constitui a terceira parte deste documento Tecnologias XML. Na primeira parte foram
abordados os conceitos fundamentais da Linguagem de Markup XML e a sua validao com DTD. Na segunda
parte foi abordado a validao de documentos XML por XML Schemas. Nesta terceira parte sero abordados os
principais fundamentos da tecnologia de transformao de XML via XML StyleSheets, vulgo XSLT.
XSLT
Basicamente o XSL (conjunto de tecnologias XSLT + XSL-FO + XPath) corresponde forma tecnolgica de
processamento de documentos XML noutro tipo de documento. A estrutura de um documento XSL (muitas
vezes tambm dito documento XSLT), ao ser um documento em XML, ter de respeitar todas as regras
sintcticas inerentes a este tipo de documentos. O NameSpace associado corresponde na generalidade dos
casos ao URL: http://www.w3.org/1999/XSL/Transform. Convencionou-se utilizar xsl como prefixo.
Como se processa o XML com XSL
Um documento XML original mapeado numa estrutura em rvore. Um motor XSL percorre toda essa rvore
e vai analisando nodo a nodo com todas as instrues presentes na XML Stylesheet. O resultado ser uma nova
rvore XML que ser posteriormente serializada na aplicao final (que, por exemplo, poder ser um browser,
caso se tenha gerado HTML). A Figura 2 procura representar este processo.
Sendo a maioria dos casos aplicados a sistemas na Web (temtica a explorar mais frente), existem trs
hipteses de contextos no processamento de um documento XML atravs de uma stylesheet. O quadro
seguinte apresenta-os:
57
XSLT
XSD
Figura 2 - Processo de transformao via XSL5
Texto versus Instrues XSLT

Tal como anotado anteriormente, as instrues XSLT so necessariamente precedidas de um NameSpace
(prefixo) que, geralmente e por conveno, corresponde palavra xsl. So por isso interpretadas (e
executadas), contrapondo com o texto normal (sem o referido prefixo), que no processado. Repare-se nos
exemplos seguintes:
58
Material retirado dos acetatos da disciplina de SIA

XSD
XSLT
<font face=areal>Titulo</font>
Embora HTML visto como texto e como tal no processado
<xsl:text>Titulo</xsl:text>
Instruo XSLT. processado
Ttulo
Texto normal. No interpretado.
Analisando o seguinte exemplo de um documento XML que descreve um livro,
A execuo do seguinte template de uma stylesheet (cuja explicao detalhada vir mais frente),
daria como resultado,

O Ttulo do livro : Os Lusadas
XPath
Para entender de forma adequada como implementar uma XML stylesheet e como a aplicar a um documento
XML, essencial entender como se percorre (muitas vezes dito navega) numa rvore de num documento XML.
Tal como apresentado na primeira parte desta sebenta, um documento XML deve ser visto como estruturado
em forma de rvore invertida (Tabela 1 e Figura 3).
semelhana do que acontece com o sistema de ficheiros de vrios sistemas operativos, existem vrias regras
e alternativas de caminhar pelos diferentes caminhos (paths) entre os diferentes ficheiros (aqui elementos,
atributos ou valores). A linguagem XPath uma linguagem XML que implementa o conjunto de regras que
regem este processo e suporta os mtodos capazes de aplicar determinadas operaes sobre estes caminhos.
59
XSLT
XSD
<?xml version="1.0" encoding=iso-8859-1?>

<!DOCTYPE actividades SYSTEM "actividade.dtd">
<actividades ano="2003" by="lufer">
<actividade id="1" tipo="caminhada">
<nome>Caminhada Sombra</nome>
<epoca>Verao</epoca>
<datas>
<data>12-06</data>
<data>14-07</data>
</datas>
<track tipo="gps">waypoints_soajo.txt</track>
<tecnicos>
<nome>Lufer</nome>
</tecnicos>
</actividade>
<actividade id="3" tipo="tt">
<nome>Rota do Geres</nome>
<datas>
<data>10-04</data>
</datas>
<track tipo="roadbook">roadbook_geres.txt</track>
<tecnicos>
<nome>Romeu</nome>
<nome>Lufer</nome>
</tecnicos>
</actividade>
</actividades>
Tabela 1 - Documento XML

Por exemplo, no antigo sistema operativo Linux e fazendo a analogia com esta rvore XML, as seguintes paths
representam caminhos vlidos:
/actividades/actividade
/actividades/ano
/actividades/actividade/../by
./actividade/tecnicos/nome
J as seguintes expresses representam caminhos invlidos:
/actividade/actividades/tipo
/actividades/tipo
uma vez que, analisando a rvore do documento, deparamos com uma sequncia de elementos que no est
correcta. Por exemplo, o elemento actividade no tem nenhum descendente actividades.
60
XSD
XSLT
Figura 3 - rvore XML

O XPath6 ento utilizado para seleccionar e encontrar nodos da rvore, testar condies e calcular valores. Na
prtica representa uma linguagem de queries para processar partes de um documento XML.
Para tirar o mximo proveito do XSLT essencial ter boas noes de como definir e aplicar este tipo de
expresses XPath.
Tipos de valores e nodos

Uma vez que XPath opera sobre um documento XML, o conjunto possvel de valores ser composto por um
conjunto de nodos, valores booleanos, numricos ou strings.
Por outro lado este conjunto de nodos ser composto por todo o tipo de elementos que um documento XML
possa conter, ie, o elemento raiz (root element) e todos os nodos dos diferentes tipos possveis:
Elemento
(<a></a>)
http://www.w3.org/TR/xpath
61
XSLT
XSD
Atributo
(<a x=v>..</a>)
Comentrio
()
Processing Instruction
(<?..?>)
NameSpace
(xsl:template </xsl:templates)
Texto
(<actividade>BTT</actividade)
Nota:
elemento raiz versus nodo raiz
O elemento raiz representa todo o documento. o primeiro elemento da rvore XML. O nodo raiz
representa o acesso a todo documento.
O nodo raiz representa-se por / e o elemento raiz pelo nomo do primeiro elemento da rvore. No nosso
exemplo <actividades>..</actividades)
Expresses
Uma expresso XPath representa o percurso a percorrer na rvore XML e a aco a executar aquando a
execuo desse percurso.
Exemplo: encontrar o nome dos tcnicos das actividades do tipo BTT que so realizadas no vero:
Expresso XPath:
/actividades/actividade[@tipo=BTT and epoca=Vero]/tcnicos/nome
Para interpretar devidamente uma expresso XPath essencial ter em ateno alguns conceitos adicionais,
nomeadamente o conceito de Nodo (ou Posio) de Contexto.
Como j referimos anteriormente, uma expresso XPath deve indicar a posio na rvore XML por onde
comear (nodo de contexto) o percurso, a direco a percorrer e o critrio de seleco ou identificao. O
nodo que indica por onde comear a avaliar a expresso constitui o Nodo de Contexto, que poder ser:
O nodo corrente: o nodo na rvore origem para o qual se aplicou a expresso (acedido por .)
Um nodo qualquer: cujo nome constitui o incio da expresso XPath.
Uma posio: a posio de um nodo na lista de nodos a serem processados (acedido por
position())
62
XSD
XSLT
Indicao de tamanho : o nmero de nodos a processar na lista de nodos identificados (acedido

por last())
Um conjunto de nodos: resultante de uma seleco de vrios elementos
Convm ainda referir que, tal como acontece com a Path de um SO, os caminhos entre nodos podem ser
absolutos ou relativos.
Absolutos: comeam numa localizao conhecida como a raz (/) ou um nodo particular
(identificado por um ID)
Relativos: comeam no nodo de contexto, i.e., onde me encontro no momento.
Regras bsicas de definio de Expresses
Direco de navegao/especificao
o
Encontrar elementos por ID
Encontrar elementos prximos ou relacionados: pais, filhos, irmos, etc.
Encontrar atributos de elementos
Encontrar strings nos contedos
Qualificao
o
Testar localizaes (nos atributos, contedo e tipos)
Combinar tudo isto em vrios passos
Anatomia de uma expresso XPath

atributo
valor
/actividades/actividade[@tipo=BTT][3]>
path
nodo de teste
predicado
teste de posio
Encontra o terceiro filho do nodo corrente que:
um elemento to tipo actividade
63
XSLT
XSD
Tem um atributo tipo com valor BTT
Analisemos alguns exemplos de expresses XPath atravs do seguinte documento XML (representado em
rvore):
Figura 4 - rvore XML
Figura 5 - Nodo de Contexto

Equivale expresso /A
Figura 6 - Todos os descendentes C
64
XSD
XSLT
Equivale expresso //C
Figura 7 - Filhos E do elemento C

Identifica todos os elementos E que sejam filhos de C. Equivale expresso //C/E
Figura 8 - Elementos F filhos de E

Identifica todos os elementos F que sejam filhos de E. Equivale expresso //C/E/F
Nas primeiras verses de XPath, a um conjunto de nodos resultante da aplicao de uma expresso XPath
denominava-se Axis. Embora nas verses actuais ainda se possa utilizar essa nomenclatura (e em alguma
bibliografia ainda se utiliza), algum dos nomes de predicados (Figura 9 ) foram abreviados por expresses mais
simples7.
Neste documento vamos evitar usar a nemencaltura Axis.
65
XSLT
XSD
Figura 9 - Axes em XPath

Por exemplo, o axis /descendant-or-self::node()/ foi abreviado pela expresso //.
Expresso Axis
Expresso abreviada
self::node()
parent:node()
..
descendant-or-self::node()/
//
/child::rcp:collection/child::rcp:recipe/child::rcp:ingredient
rcp:collection/rcp:recipe/rcp:ingredient
/child::rcp:collection/child::rcp:recipe/child::rcp:ingredient/attri
rcp:collection/rcp:recipe/rcp:ingredient/
bute::amount
@amount
Tabela 2 - Abreviao de Axes
O resultado da aplicao de uma expresso XPath deriva sempre ou num conjunto de nodos ou no conjunto de
valores atmicos (numricos, boleanos, strings, tipos). Cada nodo no conjunto identificado e pode por isso
ser manipulado.
Operadores e caracteres especiais

Operador
/
Descrio
Operador Filho; selecciona o filho directo da coleco esquerda. Quando este operador
inicia a expresso, refere-se ao nodo raiz.
//
Recursivo descendente; encontra o elemento especificado
Indica o contexto corrente
Wildcard; selecciona todos os elementos descendentes do nodo indicado.
66
em qualquer nvel da rvore.
XSD
XSLT
Atributo; prefixo para um nome de atributo
@*
Atributo wildcard; encontra todos os atributos de um determinado nodo
separador de Namespace ; separa o prefixo do NameSpace do nome do elemento ou

atributo.
()
Operaes em Grupos para, explicitamente definir precedncias
[]
Aplica um padro como filtro
[]
indexador de uma coleo
Funes
Descrio
node()
Nodo corrente (pode ser elemento, texto, atributo, PI, comentrio, NameSpace)
text()
Texto do contedo do nodo corrente
comment()
Comentrio
processing-instruction()
PI - Processing Instruction (<?...?>)
name()
Nome do nodo corrente

Tabela 3 Funes particulares
Expresses Literais
Representam valores atmicos.
Exemplos:
123
123.4
Viva o Benfica
6.12E3
O Benfica o maior
67
XSLT
XSD
Entre os mais pequenos
Expresses Aritmticas
Representam expresses com valores numricos. Operadores:
+
Adio.
Subtraco.
div
diviso em vrgula-flutante
Multiplicao.
mod
Resto da diviso truncada
Exemplo: //quantidade[2]*2
Multiplica por 2 o valor do segundo elemento quantidade.
Referncia a variveis
Uma varivel define-se em XSLT (a analisar a seguir). Acede-se ao seu valor atravs do smbolo $.
Exemplos:
$total*2
($total+2)-//quantidade/[2]
Sequncia de Expresses
Para associar expresses utiliza-se o operador ,
Domnios de inteiros podem ser definidos atravs do operador to
Existem os operadores: union, intercept e except
Exemplos:
1 to 9
1,2,3,4,5,6,7,8,9
(1,2,3),4,5,6,7,(8,9)
68
XSD
XSLT
Expresses de Filtragem
Combinando operadores em predicados
O operador . Representa o nodo contexto
Exedmplo:
(10 to 40)[. mod 5 = 0 and position()>20]
d como resultado:
30,35,40
Comparao de Valores
Para comparar valores atmicos:

Operadores: eq, ne, lt, gt, ge
Exemplos:
8 eq 4+4
(//ingrediente)[1]/@nome eq farinha
Para comparao de valores gerais:

Operadores: =, !=, >, >=, <, <=
Comparar valores de atributos: < (<); <= (<=)
Exemplos:
8 = 4+4
(1,2) = (2,4)
//ingrediente/@nome = sal
Para comparar nodos:

Operadores: is, <<, >>
Utilizados para comparar nodes em termos de ordem e identidade
Exemplos:
(//receita)[2] is //receita[titulo eq Bolo de Chocolate]
69
XSLT
XSD
/coleccao << (//receita)[4]

(//receita)[4] >> (//receita)[3]
Expresses Boleanas
Operadores: and, or, not
Funes: true(), false()
Exemplos:
author[degree and award]
author[degree and not(publication)]
degree[@from != "Harvard"]
Funes8
Existe um conjunto vasto de funes agrupadas por domnio de actuao, tais como: strings, valores
numricos, valores booleanos, etc9.
Exemplos:
Funes aritmticas
abs(-23.4) = 23.4
ceiling(23.4) = 24
floor(23.4) = 23
round(23.4) = 23
round(23.5) = 24
Funes Booleanas
not(0) = true()
not(true()) = false()
not("") = true()
not((1)) = false()
8
9
70
http://www.w3.org/2004/07/xpath-functions
Consultar lista significativa de funes em http://www.stylusstudio.com/docs/v60/d_xpath86.html#wp919260
XSD
XSLT
Funes sobre strings

concat("X","ML") = "XML"
concat("X","ML"," ","book") = "XML book"
string-join(("XML","book")," ") = "XML book"
string-join(("1","2","3"),"+") = "1+2+3"
substring("XML book",5) = "book"
substring("XML book",2,4) = "ML b"
string-length("XML book") = 8
upper-case("XML book") = "XML BOOK"
lower-case("XML book") = "xml book"
Funes RegExp
contains("XML book","XML") = true()
matches("XML book","XM..[a-z]*") = true()
matches("XML book",".*Z.*") = false()
replace("XML book","XML","Web") = "Web book"
replace("XML book","[a-z]","8") = "XML 8888"
Funes de Cardinalidade
exists(()) = false()
exists((1,2,3,4)) = true()
empty(()) = true()
empty((1,2,3,4)) = false()
count((1,2,3,4)) = 4
count(//actividade) = 5
Funes de Sequncias
distinct-values((1, 2, 3, 4, 3, 2)) = (1, 2, 3, 4)
insert-before((2, 4, 6, 8), 2, (3, 5)) = (2, 3, 5, 4, 6, 8)
71
XSLT
XSD
remove((2, 4, 6, 8), 3) = (2, 4, 8)

reverse((2, 4, 6, 8)) = (8, 6, 4, 2)
subsequence((2, 4, 6, 8, 10), 2) = (4, 6, 8, 10)
subsequence((2, 4, 6, 8, 10), 2, 3) = (4, 6, 8)
Funes de coeso
xs:integer("5") = 5
xs:integer(7.0) = 7
xs:decimal(5) = 5.0
xs:decimal("4.3") = 4.3
xs:decimal("4") = 4.0
xs:double(2) = 2.0E0
xs:double(14.3) = 1.43E1
xs:boolean(0) = false()
xs:boolean("true") = true()
xs:string(17) = "17"
xs:string(1.43E1) = "14.3"
xs:string(true()) = "true"
Tutorial XPath
De seguida apresentamos um conjunto de exemplos de expresses XPath no intuito de demonstrar a
respectiva aplicabilidade sobre documentos XML. Vamos continuar a utilizar o nosso exemplo sobre
Actividades Desportivas.
Lidar com elementos
Expresso XPath
Resultado
./actividade
todos os elementos actividades disponveis na posio corrente
actividades//actividade
todos os elementos actividade algures no documento abaixo de actividades
72
XSD
XSLT
//actividade[3]
terceira actividade
Lidar com Atributos
Expresso XPath
./actividade/@tipo
Resultado
valores dos atributos tipo de todos os elementos actividade existentes a
partir da posio actual
//actividade[@tipo=BTT]
Todas as actividade cujo tipo seja BTT
Lidar com elementos Pai
Expresso XPath
Resultado
./actividade[../@ano=2003]/nome
Todos os nomes das actividade que foram realizadas no ano 2003
//epoca[.=Primavera]/../tipo
Todas os tipos de actividade realizadas na Primavera
Navegao
Expresso XPath
Resultado
/actividades/*/nome
Todos os nomes das actividade realizadas
//actividade/*
Toda a informao de cada actividade
Indexao de Conjuntos de nodos
Expresso XPath
Resultado
/actividades/actividade[3]
Informao da terceira actividade
//actividades/actividade[last()]
Informao da ltima actividade
73
XSLT
XSD
//track[@tipo="gps"]/text()
Dados GPS de todas as actividades que o possuam
Operaes sobre conjuntos
Expresso XPath
Resultado
count(//actividade)
Nmero total de actividades realizadas
sum(//actividade[@tipo=caminhada]/distancia)
Distncia Total de todas as caminhadas
//track[@tipo="gps"]/text()
Dados GPS de todas as actividades que o possuam
Estes e vrios outros exemplos sero de novo explorados aquando a explanao do conceito de XSL
Templates, no captulo que se segue.
XML StyleSheets
Falta agora perceber como estruturar ento uma XML Stylesheet e como aplicar a as expresses XPath.
xsl:stylesheet
O elemento xsl:stylesheet (ou xsl:transform) constitui a raiz de uma XML stylesheet, i.e., o primeiro elemento
aps a raiz do documento e o Prolog xml. Possui dois atributos obrigatrios: version e xmlns. Assim, a estrutura
base de uma XML Stylesheet pode ser vista como:
ou
Na essncia uma XML Stylesheet, constituda por um conjunto de Templates, que no so mais que um
conjunto de aces que sero executadas em determinados contextos.
A ttulo de exemplo, se considerarmos a seguinte XML Stylesheet (doravante abreviada somente por
stylesheet),
74
XSD
XSLT
<xsl:stylesheet xmlns:xsl="http://www.w3.org/1999/XSL/Transform">
<xsl:template match="Foo">
<Bar>Viva</Bar>
</xsl:template>
</xsl:stylesheet>
Identificamos as seguintes partes:

<?xml?>
representa o Prolog inerente a qualquer documento XML
xsl:stylesheet
representa um elemento XML e constitui o node raiz de uma stylesheet
xmlns:xsl
representa um atributo que define o prefixo xsl: a associar a um determinado

NameSpace.
"http://www.w3.org/" representa um URI. No existe contudo qualquer contacto remoto via web. Trata-se
de uma referncia local, por exemplo, para o browser saber qual verso de XSLT.
xsl:template
trata-se de um elemento XML. Representa o incio da definio de um template.

Possui o prefiso xsl logo ser processado pelo parser XSLT.
<Bar>Viva</Bar>
representa um elemento XML. Como no possui prefixo xsl, no ser processado

pelo parser XSLT e ser colocado integralmente na rvore resultante do
processamento.
Referenciar uma StyleSheet

Para associar uma Stylesheet a um documento XML, ie, permitir que possa ser processado, necessrio incluir
a seguinte instruo no documento XML:
<?xml:stylesheet type="text/xsl" href="nomeStyleSheet"?>
Por exemplo:
<?xml:stylesheet type="text/xsl" href="MyStyle.xsl"?>
<Etc>
Blah blah blah.
</Etc>
75
XSLT
XSD
Templates
Uma XML stylesheet corresponde a um conjunto de regras, definidas sob a forma de templates. Estes
templates (comparveis s funes ou mtodos na teoria das linguagens de programao), para os quais se
podero tambm definir parmetros, sero utilizados em circunstncias especficas de contexto. Um template
poder possuir texto ou instrues XSLT.
Um corpo de uma XML stylesheet possui no mnimo dois templates, que corresponde aos templates por
omisso (a ver mais frente).
Os templates so definidos com a instruo xsl:template e so compostos por uma sequncia de instrues
XSL. A estrutura normal de um template respeita a sintaxe:
<xsl:template match=...>
.........
</xsl:template>
Existem dois tipos de templates: template com nome (named template) e template com match (matched
template). Paralelamente, existem duas formas de utilizar um template: ou invocando-o pelo respectivo nome
ou aplicando-o.
Se um template tem um nome, i.e., com o atributo name, s poder ser utilizado atravs da instruo xsl:calltemplate. Caso possua um atributo match, ser utilizado de duas formas possveis: quer manualmente
atravs da instruo xsl:apply-template quer automaticamente pela prpria mquina que, ao analisar o
documento xml, vai remetendo a interpretao de cada elemento ao template que sobre ele estiver definido
(veremos melhor este conceito ao analisar vrios exemplos). Contudo, um template pode possuir os dois
atributos.
Um outro atributo pode estar presente, mode, que se aplica somente a matched templates e serve para
permitir a distino de dois templates que se apliquem em iguais circunstncias de match.
Em casos mais complexos (a no explorar neste documento) poder ter um nome e ter tambm uma condio
de match.
Basicamente um template utilizado da seguinte forma:
medida que a rvore XML original percorrida pelo processador XSLT, as regras dos templates so
verificadas. Sempre que uma regra verificada (faz-se o match) esse template executado e o
resultado da sua execuo passa para a rvore resultante.
Quando ocorre a operao apply-templates ou call-template (a analisar mais frente) num

determinado template, a execuo condicionada e o processamento salta para esses templates
assim referidos.
Analisemos os seguintes exemplos e casos particulares de templates.
76
XSD
XSLT
Templates por omisso

Os templates por omisso so assim nomeados pelo facto de constarem previamente definidos em qualquer
XML stylesheet. Tm o seguinte definio:
<xsl:template match="*|/">
<xsl:apply-templates/>
</xsl:template>
Este template percorre recursivamente a rvore inicial XML, fazendo match com o nodo raiz (/) e com todos os
restantes elementos (*). Garante-se assim que qualquer outro template existente, seja aplicado.
<xsl:template match="text()">
<xsl:value-of select="."/>
</xsl:template>
Este template faz match com nodos do tipo texto (pela instruo text()). Em cada nodo encontrado,
apresentado o respectivo contedo. Isto feito pelo operador self (.).
Uma stylesheet vazia deve ser vista como uma stylesheet que s possui definidos os templates por omisso
(que naturalmente no so visveis). Assim, a estrutura de uma stylesheet vazia (mas completa), tem a seguinte
composio:
Analisando de novo o nosso exemplo inicial de documento XML (Tabela 1, pag. 60) que descreve uma
actividade, aplicando-lhe uma stylesheet vazia (percurso.xsl), o resultado seria (tente verificar voc mesmo!):
77
XSLT
XSD
Como se pode observar, os prprios caracteres de indentao (espaos e tabs), esto presentes no documento
resultado.
Caso se pretenda anular estes templates ocultos, deve-se redefini-los. Por exemplo, a seguinte definio faz
com que eles no executem nada sobre o XML fonte:
<xsl:template match="*|/">
</xsl:template>
<xsl:template match="text()">
</xsl:template>
Nota:
Todos os caracteres no visveis (espaos, tabs, ect) so convertidos em elementos xsl:text() e so
integralmente copiados para o documento destino.
A ttulo de resumo, podemos dizer ento que:
78
XSD
XSLT
Ao aplicar uma stylesheet vazia a um documento XML:
Todos os elementos so atravessados sequencialmente
O contedo de cada elemento passado para o resultado
Os atributos no so analisados
Trata-se de um comportamento por omisso
Exemplo de StyleSheet (I)

Vejamos agora com mais detalhe aquilo que uma stylesheet executa. Considere-se o seguinte documento XML:
Considere-se agora a seguinte stylesheet:
79
XSLT
XSD
Cujo resultado de aplicao mostrado na Figura
Figura 10 - Resultado de aplicao de uma StyleSheet
Analisemos cada um dos principias passos nesta stylesheet:
Linha 6
Definio de template. Este template ser executado quando ocorrer na rvore (quando fizer
o match com) o elemento /.
Linhas 7,8
Cdigo sem prefixo xsl. No processado. copiado integralmente para o documento

destino. Trata-se obviamente de cdigo HTML mas que o parser XSL ignora.
Linha 9
<xsl:apply-templates>. Significa que o processamento dever continuar para qualquer nodo

descendente (filho) do nodo actual (/). Se qualquer outro template existir definido que se
aplique a nodos filhos de /, s aps a respectiva execuo que voltar a este template.
Linha 10
Aps aplicar os templates aos filhos de /, deve terminar correctamente o documento HTML,
ie, fechar as tags <body> e <html> que tinham sido abertas nas linhas 7 e 8.
Linha 13
Template que faz match com nomes. Significa que este template ser executado sempre
que ocorrer um elemento nomes da rvore XML. Na sua definio consta a instruo
<xsl:apply-templates> que determina que continue a serem processados os templates que se
apliquem aos elementos filhos do nodo actual (nomes), ie, aos elementos nome.
Linha 19
Template que faz match com nome. Significa que este template ser executado sempre
que ocorrer um elemento nome da rvore XML. Na essncia o que este template faz
apresentar o valor existente em cada elemento nome, como parte de um elemento <li> de
html.
Linha 21
<xsl:value-of select=text()/>. Instruo xsl que escreve o valor do elemento do nodo actual
(nome). A funo text() devolve o contedo do elemento actual.
80
XSD
XSLT
Exemplo de StyleSheet (II)

A Figura 11 mostra o resultado da aplicao de uma outra stylesheet ao nosso documento XML (pag. 60) que
descreve Actividades Desportivas.
Figura 11 - Resultado de aplicao de uma xsl

Repare-se que a stylesheet utilizada recorre a um nico template, dentro do qual todo o processamento
efectuado. uma forma possvel de implementar mas que se recomenda evitar, preterindo a estruturao em
vrios templates, tal como mostrou o exemplo anterior.
<xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform">
<xsl:output method="html" encoding="iso-8859-1"/>
<xsl:template match="/">
<html>
<head >
<link rel="stylesheet" type="text/css" href="show.css"/>
<title>Actividades></title>
</head>
<body class="bodyContent">
<table class="content" width="600" border="1" align="center" cellspacing="0"
cellpadding="0">
<tr><td colspan="5" class="BlueWho"><b>ACTIVIDADES</b></td></tr>
<tr>
<td bgcolor="yellow" class="BlueWho"><b>Actividade</b></td>
<td bgcolor="yellow" class="BlueWho"><b>Distncia</b></td>
<td bgcolor="yellow" class="BlueWho"><b>Dificuldade</b></td>
<td bgcolor="yellow" class="BlueWho"><b>poca</b></td>
<td bgcolor="yellow" class="BlueWho"><b>Responsavel</b></td>
</tr>
<tr>
81
XSLT
XSD
<td colspan="5" class="BlueWho"><b>Todo o Terreno</b></td>

</tr>
<xsl:for-each select="percursos/percurso[@tipo='tt']">
<tr>
<td class="BlueWho"><xsl:value-of select="nome"/></td>
<td class="BlueWho"><xsl:value-of select="distancia"/>
<xsl:value-of select="distancia/@units"/>
</td>
<td class="BlueWho">
<xsl:choose>
<xsl:when test="dificuldade =2">Mdia</xsl:when>
<xsl:when test="dificuldade =5">Exigente</xsl:when>
<xsl:otherwise>Fcil</xsl:otherwise>
</xsl:choose>
</td>
<td class="BlueWho"><xsl:value-of select="epoca"/></td>
<xsl:value-of select="responsavel/respnome"/><br/>
<xsl:value-of select="responsavel/contacto"/><br/>
<xsl:value-of select="responsavel/email"/>
</td>
</tr>
</xsl:for-each>
<tr>
<td colspan="5" class="BlueWho"><b>Caminhadas</b></td>
</tr>
<xsl:for-each select="percursos/percurso[@tipo='caminhada']">
<tr>
<td
class="BlueWho"><xsl:value-of select="nome"/></td>
<td
class="BlueWho"><xsl:value-of
select="distancia/@units"/></td>
select="distancia"/>
<xsl:value-of
<xsl:choose>
<xsl:when test="dificuldade = 2">Mdia</xsl:when>
</xsl:choose>
</td>
</td>
82
XSD
XSLT
</tr>
</xsl:for-each>
<tr>
<td colspan="5" class="BlueWho"><b>BTT</b></td>
</tr>
<xsl:for-each select="percursos/percurso[@tipo='btt']">
<tr>
<td
class="BlueWho"><xsl:value-of
select="distancia"/>
<xsl:value-of
<xsl:choose>
</xsl:choose>
</td>
</td>
</tr>
</xsl:for-each>
</table>
</body>
</html>
</xsl:template>
</xsl:stylesheet>
Tabela 4 - XML StyleSheet indevidamente estruturada
Pattern Matching
O pattern matching define as regras de acesso aos seguintes contextos:
Nodo raiz
Um elemento atravs do seu nome
Aos filhos de um elemento
A todos os descendentes de ujm elemento
Aos atributos de um elemento
83
XSLT
XSD
Ao valor do contedo de um elemento
Muitos dos exemplos a seguir apresentados foram analisados aquando a explanao do XPath. Na essncia, as
expresses com eles definidos so puras expresses XPath. Vejamos cada caso com algum detalhe:
Nodo Raz
<xsl:template match=/>
<!Colocar aqui o que se pretende no incio do documento resultado.
Por exemplo, se for para gerar HTML, colocar aqui as tags HTML e BODY
-->

<!Colocar aqui o que se pretende para terminar o documento resultado.
Por exemplo, se for para gerar HTML, colocar aqui as tags que fecham o
HTML e BODY -->
</xsl:template>
Exemplo:
<html><body>
</body></html>
</xsl:template>
Nodo Elemento
<xsl:template match=nomeElemento>
Exemplo:
<xsl:template match=moon>
</xsl:template>
possvel combinar vrias expresses de match com o operador | (leia-se ou):

<xsl:template match="Carro | Aviao | Motorizada">
Para identificar os filhos de um elemento:

<!Especificacoes filho de Carro-->
<xsl:template match="Carro/Especicacoes">


<xsl:template match="Carro/*">
84
XSD
XSLT
O operador * permite abstrair os elementos de determinado nvel, permitindo seleccionar

todos os netos de determinado elemento. Exemplo:
<xsl:template match="/Veiculos/*/Especicacoes">
Esta expresso far match com as Especificaes de todos os Veculos, sejam eles
Carros,
Avies ou Motorizadas.
O operador // permite identificar todos os descendentes de determinado elemento.

<!encontra todos os elementos Nome algures no documento -->
<xsl:template match="//Nome">


<xsl:template match="Vendas//Nome">
Nodos Texto
Feito atravs do operador text(). Basicamente consiste no contedo dos valores que cada nodo possui,
sejam eles elementos ou atributos.

<xsl:template match="Phone/text()">
<i><xsl:value-of select="."/></i>
</xsl:template>


<xsl:template match="Pessoa/@*">
<b><xsl:value-of select="text()"/></b>
</xsl:template>
Nota:
Os operadores text() e . Podem parecer executar o mesmo. Na realidade no. O operador text()
identifica o texto existente no nodo actual (elemento ou atributo). O operador . recursivo,
identificando o valor do actual nodo assim como de todos os que o sucedem na rvore.
Matching condicional
Muitos dos predicados XPath aplicados em templates permitem a identificao de elementos com regras de
seleco, ie, nem todos os elementos que se enquadrem numa dada expresso devero ser considerados. Isto
consegue-se atravs de indexadores no conjunto de elementos identificados. Vejamos alguns exemplos:
85
XSLT
XSD
O seguinte template identifica todos os elementos Company existentes no documento XML, apresentando o
nome (Name) de cada uma delas.
<xsl:template match="Company">
<b><xsl:value-of select="Name"/></b>
</xsl:template>
Agora, caso pretenda somente a segunda Company, a expresso XPath do template deveria ser alterada para:
<xsl:template match="Company[2]">
<b><xsl:value-of select="Name"/></b>
</xsl:template>
Este exemplo identifica somente aqueles Person que possuem o elemento NEW definido:
<xsl:template match="//Person[NEW]">
<xsl:value-of select="Name"/>
<i><xsl:value-of select="Phone"/></i>
</xsl:template>
Este outro exemplo identifica somente as Company que possuam o atributo territory definido:
<xsl:template match="Company[@territory]">
Territory: <xsl:value-of select="@territory"/>
</xsl:template>
O seguinte template faz matching com todas as pessoas (Pessoa) com Bilhete de Identidade (atributo bi) com
um dos valores apresentados.
<xsl:template match=Pessoa[@bi="P2234123" or @bi="23P25644"]'>
Este outro identifica somente as pessoas que no possuam idade (como atributo) igual a 33:
<xsl:template match=Pessoa[not(@idade="33"])'>
Expresses XSLT essenciais

De seguida apresentam-se as expresses XSLT mais utilizadas e essenciais para qualquer XMl StyleSheet.
<xsl:value-of>
Escreve para o output o valor do contedo de um elemento ou atributo.
Considere-se o seguinte exemplo:
86
XSD
XSLT
<?xml version = "1.0" ?>


<planet number="4" diameter="6747 km">
<name>Marte</name>
<moons>
<moon diameter="27.2 km">Phobos</moon>
<moon diameter="16 km">Deimos</moon>
</moons>
</planet>
E o seguinte template:
<xsl:template match="planet">
<xsl:value-of select=/>
</xsl:template>
Se a instruo <xsl:value-of /> fosse:

<xsl:value-of select=/>
Resultado
Mars Phobos Deimos
<xsl:value-of select="moons"/>
Phobos Deimos
<xsl:value-of select="moon"/>
Nada. Moon no filho de planet
<xsl:value-of select="planet"/>
Nada. Planet no filho de planet
<xsl:value-of select="@number"/>
<xsl:value-of select="@diameter"/>
6747 km
Se tivessemos o template:
<xsl:template match="planet/moons/moon">
<p>
<xsl:value-of select="."/> uma lua de
<xsl:value-of select="../../name"/>
</p>
</xsl:template>
O resultado seria:
Phobos uma lua de Marte
Deimos uma lua de Marte
87
XSLT
XSD
Isto porque o operador ../../name permite aceder ao contedo do elemento pai de moons. Neste caso, o
elemento pai de moons Marte.
Esta instruo apresenta-se em vrias formas. Desde a mais genrica, <xsl:apply-templates/>, at forma com
identificao do critrio de matching: <xsl:apply-templates select=Pessoa/>. Vejamos as diferenas:
Expresso
Significado
Determina a anlise da rvore XML sem especificar nenhum template em

particular. Na prtica, o parser XSLT continuar a sua anlise da rvore a
partir do ponto onde esta expresso foi invocada
<xsl:apply-templates select=A/>
Determina que a anlise da rvore se faa a partir do elemento A, caso

exista. Sero executados todos os templates que faam matching com o
elemento A.
<xsl:apply-templates
mode=x/>
Determina que a anlise da rvore se faa a partir do elemento A, caso

exista. Sero executados todos os templates identificados com o atributo
mode com valor x que faam matching com o elemento A .
select=A
Analisemos o seguinte exemplo. Considere-se o documento XML contacts.xml que pretende descrever os
contactos de uma empresa:
<?xml-stylesheet type="text/xsl" href="Contacts.xsl"?>

<Companies>
<Company id="C1"
territory="WEST" >
<Name>Acme Industries, Inc.</Name>

<Contacts>
<Primary>
<Person id="P1"><Name>Dave Jones</Name>
<Phone>728-2139</Phone>
<img>Phone.jpg</img></Person>
</Primary>
<Billing/>
<Sales>
<Person id="P2" >
<Name>Tina King</Name>
<Phone>728-2334</Phone></Person>
<Person id="P3"><Name>Juan Mendez</Name><img>Phone.jpg</img></Person>
</Sales>
</Contacts>
88
XSD
XSLT
</Company>
<Company
id="C2" >
<Name>Whamco International</Name>
<Contacts>
<Primary>
<Person
id="P4" >
<Name>Wanda Kalwicki</Name>
<Phone>873-9823</Phone><img>Phone.jpg</img>
</Person>
</Primary>
<Billing>
<Person id="P5">
<Name>Steve Franklin</Name>
<Phone>873-2387</Phone>
</Person>
</Billing>
<Sales>
<Person id="P6">
<Name>Earl Young</Name>
<Phone>873-3489</Phone><NEW/><img>Phoni.jpg</img>
</Person>
</Sales>
</Contacts>
</Company>
</Companies>
Considere-se agora a seguinte XML Stylesheet:
89
XSLT
XSD
Cujo resultado de a aplicar ao XML seria:
Figura 12 - Lista de Contactos (I)
Suponhamos agora retirar a condio select da instruo da linha 9. O resultado seria agora:
90
XSD
XSLT
Figura 13 - Lista de Contactos (II)

Como explicar esta diferena? Vejamos.
No primeiro caso, a expresso da linha 9 tinha a seguinte definio:
<xsl:apply-templates select="Contacts//Name"/>
O que significa que se pretende analisar somente os templates que fazem matching com os elementos Name
descendentes de Contacts. Neste caso o elemento Name correspondente ao elemento Company no
considerado. Logo, o resultado obtido (Figura 12) somente mostra os nomes dos membros das empresas (ex.
Wanda Kalwicki, Steve Franklin e Earl Young). Mas o nome da empresa (Company) no volta a ser apresentado.
No segundo caso, a expresso da linha 9 ficaria:
O que significa que se pretende aplicar todos os templates que faam matching com elementos que estejam
por baixo de Company (contexto actual). Neste caso o elemento Name de Company j considerado, assim
como todos os restantes nomes (Name) dos membros da empresa. O resultado ser ento o apresentado na
Figura 13. Repare-se que o nome da empresa apresentado duas vezes!
Caso se pretenda definir vrios templates que se apliquem no mesmo contexto de matching mas que convm
que sejam executados em circunstncias distintas, utiliza-se o atributo mode na definio de cada template.
<xsl:template match="Company">
<p>Company:

<xsl:apply-templates select="Name" mode="C"/> </p>

<xsl:apply-templates select="Contacts//Name" mode="P"/>
</xsl:template>
91
XSLT
XSD
<xsl:template match="Name" mode="P">

<li><xsl:apply-templates/></li>
</xsl:template>
<xsl:template match="Name" mode="C">

<b><xsl:apply-templates/></b>
</xsl:template>
De seguida apresentamos mais informao sobre estas e outras instrues XSLT, analisando vrios exemplos de
cdigo.
Tutorial XSLT
Nesta seco pretendemos apresentar, sob a forma de tutorial, muitos outros conceitos que, devido sua
extenso no seria possvel explicar neste documento. Referimo-nos nomeadamente a estruturas de controlo
(estruturas de deciso e ciclos), a passagem de parmetros e a utilizao de variveis.
<xsl:value-of>
XML:

<?xml:stylesheet type="text/xsl" href="livro.xsl"?>
<livro isbn="1234">
<isbn>1234</isbn>
<autores>
<autor>Benfica</autor>
<autor>Porto</autor>
</autores>
<titulo>Rua do Sobe e Desce por Entre Apertos</titulo>
<preco>738 2838</preco>
</livro>
XMl StyleSheet:
<xsl:output method="html"/>
</xsl:template>
<xsl:template match="livro">
<b><i>Titulo:</i></b><xsl:text> </xsl:text><xsl:value-of select="titulo"/><br/>
<b><i>ISBN:</i></b><xsl:text> </xsl:text><xsl:value-of select="@isbn"/>
</xsl:template>
92
XSD
XSLT
</xsl:stylesheet>
Resultado:
<xsl:template>
XMl:
<!DOCTYPE ADDRESSLIST SYSTEM "AddressList.dtd">
<?xml:stylesheet type="text/xsl" href="AddressesList.xsl"?>
<ADDRESSLIST>
<ADDRESS NAME="Miss. Ex M. Elle">
<WORK>
<STREET>22, WWW Street</STREET>
<CITY>Cambridge</CITY>
<STATE>MA</STATE>
<COUNTRY>Portugal</COUNTRY>
</WORK>
<WORK>
<STREET>44, Triple W Street</STREET>
<CITY>Cambridge</CITY>
<STATE>MA</STATE>
<COUNTRY>USA</COUNTRY>
</WORK>
</ADDRESS>
<ADDRESS NAME="Mr. Ex S. Elle">
<WORK>
<STREET>34 WWW Street</STREET>
<CITY>Palo Alto</CITY>
<STATE>CA</STATE>
</WORK>
<HOME>
<STATE>CA</STATE>
</HOME>
</ADDRESS>
<ADDRESS NAME="Mr. Ex S. Elle">
<WORK>
<STATE>CA</STATE>
<COUNTRY>POrtugal</COUNTRY>
</WORK>
<HOME>
<STATE>CA</STATE>
</HOME>
</ADDRESS>
</ADDRESSLIST>
93
XSLT
XSD
XML Stylesheet
<?xml version="1.0" encoding="ISO-8859-1"?>
<!by lufer -->
<xsl:template match="/ADDRESSLIST">
<html>
<body>
<hr/>
<h3>Endereos:</h3>
<hr/>
</body>
</html>
</xsl:template>
<xsl:template match="ADDRESS/WORK">
<b><xsl:value-of select="COUNTRY"/></b><br/>
</xsl:template>
</xsl:stylesheet>
Resultado:
<xsl:for-each>
XML:

<?xml-stylesheet type="text/xsl" href="cd.xsl"?>
<catalog>
<cd>
<title>Os Mais</title>
<artist>Marco Paulo</artist>
<country>PT</country>
<company>Columbia</company>
<price>07.90</price>
<year>1985</year>
</cd>
<cd>
<title>Eu e s Ns</title>
<artist>Paulo Marco</artist>
<country>USA</country>
<year>1988</year>
</cd>
<cd>
<title>Eu e s Ele</title>
<artist>Amlia</artist>
<country>PT</country>
94
XSD
XSLT
<year>1987</year>
</cd>
</catalog>
XML Stylesheet:

<xsl:template match="/catalog">
<html>
<body>
<h2>Os meus CDs</h2>
<table border="1">
<tr bgcolor="#9acd32">
<th align="left">Ttulo</th>
<th align="left">Artista</th>
<th align="left">Preo</th>
</tr>
<xsl:apply-templates select="cd"/>
<!ou executar directamente sem invocar outro template -->
<!-<xsl:for-each select="cd">
<xsl:sort select="title" order="ascending"/>
<tr>
<td><xsl:value-of select="title"/></td>
<td><xsl:value-of select="artist"/></td>
<td><xsl:value-of select="price"/></td>
</tr>
</xsl:for-each>
-->
</table>
</body>
</html>
</xsl:template>
<xsl:template match="cd">
<tr>
<td><xsl:value-of select="title"/></td>
<td><xsl:value-of select="artist"/></td>
<td><xsl:value-of select="price"/></td>
</tr>
</xsl:template>
</xsl:stylesheet>
Resultado:
not
XML:
95
XSLT
XSD

<!DOCTYPE Recipe SYSTEM "receita.dtd">
<?xml-stylesheet type="text/xsl" href="receita.xsl"?>
<Recipe>
<Name>Bolo Surpresa</Name>
<Description>
Excelente bolo para comer ao lanche!
</Description>
<Ingredients>
<Ingredient>
<Qty unit="caixa">1</Qty>
<Item>Batata</Item>
</Ingredient>
<Ingredient>
<Qty unit="g">500</Qty>
<Item>Aucar</Item>
</Ingredient>
<Ingredient>
<Qty unit="ml">500</Qty>
<Item>Vinho branco</Item>
</Ingredient>
<Ingredient>
<Qty unit="qb"/>
<Item optional="1">Ovos</Item>
</Ingredient>
</Ingredients>
<Instructions>
<Step>
Preparar bem e comer melhor
</Step>

</Instructions>
</Recipe>
XML StyleSheet:
<!by lufer -->
<xsl:template match="/Recipe">
<HTML>
<HEAD>
<TITLE>
</TITLE>
</HEAD>
<BODY>
<H3>
</H3>
<i>
<xsl:value-of select="Description"/>
</i>
</BODY>
</HTML>
</xsl:template>

<xsl:template match="Ingredients">
<H4>Ingredientes</H4>
<TABLE BORDER="1">
<TR BGCOLOR="#308030">
<TH>Qty</TH>
<TH>Units</TH>
<TH>Item</TH>
</TR>
<xsl:for-each select="Ingredient">
<TR>
96
XSD
XSLT
<xsl:if test='Qty[not(.="")]'>
<TD>
<xsl:value-of select="Qty"/>
</TD>
</xsl:if>
<xsl:if test='Qty[.=""]'>
<TD BGCOLOR="red"> </TD>
</xsl:if>
<TD>
<xsl:value-of select="Qty/@unit"/>
</TD>
<TD>
<xsl:value-of select="Item"/>
</TD>
</TR>
</xsl:for-each>
</TABLE>
</xsl:template>

<xsl:template match="Instructions">
<H4>Instruces</H4>
<OL>
<xsl:apply-templates select="Step"/>
</OL>
</xsl:template>
<xsl:template match="Step">
<LI>
</LI>
</xsl:template>
<xsl:template match="*" priority="-1"/>
</xsl:stylesheet>
Resultado:
<xsl:if>
XML:
<?xml-stylesheet type="text/xsl" href="Inventory.xsl"?>
<inventory>
<item>
<name>Austin</name>
<rating>7</rating>
</item>
<item>
97
XSLT
XSD
<name>Morris</name>
<rating>3</rating>
</item>
<item>
<name>Ford</name>
<rating>11</rating>
</item>
</inventory>
XML StyleSheet:
<xsl:stylesheet version="1.0"
xmlns:xsl="http://www.w3.org/1999/XSL/Transform">
<xsl:output method="html" />
<xsl:template match="/inventory">
<html>
<head>
<basefont face="Arial" size="2"/>
</head>
<body>
<ul>
<xsl:apply-templates select="item"/>

</ul>
</body>
</html>
</xsl:template>
<xsl:template match="item">
<li><xsl:value-of select="name" /></li>
<xsl:if test="rating < 5">
*
</xsl:if>
</xsl:template>
<xsl:template match="item" mode="xpto">
<xsl:for-each select="*">
<xsl:if test="name()='name'">
<b><xsl:value-of select="name()"/> :</b> <xsl:value-of select="."/>
</xsl:if>
<xsl:if test="name()='rating'">
<i><xsl:value-of
select="name()"/> :</i> <xsl:value-of
select="."/>
<br/>
</xsl:if>
</xsl:for-each>
</xsl:template>
</xsl:stylesheet>
Resultado:
98
XSD
XSLT
<xsl:choose>
XML:

<?xml-stylesheet type="text/xsl" href="Portfolio.xsl"?>
<portfolio>
<stock>
<symbol>HHDT</symbol>
<oprice>100</oprice>
<cprice>25</cprice>
</stock>
<stock>
<symbol>DFKS</symbol>
<cprice>150</cprice>
</stock>
<stock>
<symbol>NHSJ</symbol>
<oprice>20</oprice>
</stock>
<stock>
<symbol>DJSK</symbol>
<cprice>2</cprice>
</stock>
<stock>
<symbol>MDSH</symbol>
<oprice>50</oprice>
<cprice>50</cprice>
</stock>
<stock>
<symbol>TRVB</symbol>
<oprice>90</oprice>
<cprice>86</cprice>
</stock>
</portfolio>
XML StyleSheet:

<xsl:template match="/portfolio">
<html>
<head>
<basefont face="Arial" size="2"/>
</head>
<body>
<h3>Portflio:</h3>
<ul>
<xsl:apply-templates />
</ul>
</body>
</html>
</xsl:template>
<xsl:template match="stock">
<xsl:choose>

99
XSLT
XSD
<xsl:when test="(cprice - oprice) > 0">

<li><font color="blue"><xsl:value-of select="symbol" /></font> (up by
<xsl:value-of select="round(((cprice - oprice) * 100 div oprice))" />%)</li>
</xsl:when>

<xsl:when test="(cprice - oprice) < 0">
<li><font color="red"><xsl:value-of select="symbol" /></font> (down by
<xsl:value-of select="round(((cprice - oprice) * 100 div oprice) * -1)"
/>%)</li>
</xsl:when>

<xsl:otherwise>
<li><xsl:value-of select="symbol" /> (ok)</li>
</xsl:otherwise>
</xsl:choose>
</xsl:template>
</xsl:stylesheet>
Resultado:
<xsl:sort>
XML:
<?xml-stylesheet type="text/xsl" href="Loop.xsl"?>
<top_five>
<movie>
<name>Star Wars: A New Hope</name>
<cast>Mark Hamill, Carrie Fisher, Harrison Ford</cast>
<director>George Lucas</director>
<rank>1</rank>
</movie>
<movie>
<name>The Patriot</name>
<cast>Mel Gibson, Heath Ledger, Jason Isaacs</cast>
<director>Roland Emmerich</director>
<rank>5</rank>
</movie>
<movie>
<name>The Whole Nine Yards</name>
<cast>Bruce Willis, Matthew Perry</cast>
<director>Jonathan Lynn</director>
<rank>3</rank>
</movie>
<movie>
<name>Gladiator</name>
<cast>Russell Crowe, Connie Nielsen, Joaquin Phoenix</cast>
<director>Ridley Scott</director>
<rank>4</rank>
100
XSD
XSLT
</movie>
<movie>
<name>Unbreakable</name>
<cast>Bruce Willis, Samuel L. Jackson</cast>
<director>M. Night Shyamalan</director>
<rank>2</rank>
</movie>
</top_five>
XML StyleSheet:

<html>
<head>
<basefont face="Arial" size="4" />
</head>
<body>
<ol>
</ol>
</body>
</html>
</xsl:template>
<xsl:template match="top_five">
<xsl:for-each select="movie">
<xsl:sort select="name" order="descending" />
<li><xsl:value-of select="name" /></li>
<br />
<font size="2"><xsl:value-of select="cast" /> | <xsl:value-of
select="director" /> -> <xsl:value-of select="rank"/></font>
</xsl:for-each>
</xsl:template>
</xsl:stylesheet>
Resultado:
<xsl:element>
XML:
<?xml-stylesheet type="text/xsl" href="radio.xsl"?>
<tudo>
101
XSLT
XSD
<opcao>Um</opcao>
<opcao>Dois</opcao>
<opcao>Tres</opcao>
<label>BI</label>
<label>Nome</label>
<label>BI</label>
<label>Nome</label>
</tudo>
XML StyleSheet:
<?xml version='1.0' encoding='iso-8859-1' ?>

<html>
<body>
</body>
</html>
</xsl:template>

<xsl:template match="tudo">
<xsl:for-each select="opcao">
<xsl:element name="input">
<xsl:attribute name="type">
<xsl:value-of select="'radio'"/>
</xsl:attribute>
<xsl:attribute name="value">
</xsl:attribute>
<xsl:if test="text() = 'Tres'">
<xsl:attribute name="checked"/>
</xsl:if>
</xsl:element>
</xsl:for-each>
<xsl:apply-templates select="label"/>
</xsl:template>
<xsl:template match="label">
<p/>
<xsl:value-of select="text()"/>:
<xsl:element name="input">
<xsl:attribute name="type">
<xsl:value-of select="'text'"/>
</xsl:attribute>
<xsl:attribute name="size">
<xsl:value-of select="'20'"/>
</xsl:attribute>
</xsl:element>
</xsl:template>
</xsl:stylesheet>
Resultado:
102
XSD
XSLT
<xsl:number>
XML
<?xml-stylesheet type="text/xsl" href="Ingredientes.xsl"?>
<recipe>
<ingredients>
<item>Boneless chicken breasts</item>
<item>Chopped onions</item>
<item>Ginger</item>
</ingredients>
<process>
<step>Cut chicken into cubes, wash and apply lime juice and salt</step>
<step>Add ginger, garlic, chili, coriander and lime juice in a separate
bowl</step>
<step>Mix well, and add chicken to marinate for 3-4 hours</step>
<step>Place chicken pieces on skewers and barbeque</step>
<step>Remove, apply butter, and barbeque again until meat is
tender</step>
<step>Garnish with lemon and chopped onions</step>
<step>Final</step>
</process>
</recipe>
XML StyleSheet:

<html>
<body>
Preparation:
<xsl:apply-templates select="recipe/process" />
</body>
</html>
</xsl:template>
<xsl:template match="process/step">
<br/><xsl:number count="step" format="1 - " />
<xsl:value-of select="." />
</xsl:template>
</xsl:stylesheet>
Resultado:
103
XSLT
XSD
<xsl:param>
XML:

<?xml-stylesheet type="text/xsl" href="data.xsl"?>
<dias>
<data>
<dia>7</dia>
<mes>12</mes>
<ano>2006</ano>
<msg>Dezembro</msg>
</data>
<data>
<dia>7</dia>
<mes>10</mes>
<ano>2006</ano>
<msg>Outubro</msg>
</data>
</dias>
XML StyleSheet:

<xsl:stylesheet
version="1.0"
xmlns:xsl="http://www.w3.org/1999/XSL/Transform"
xmlns:fo="http://www.w3.org/1999/XSL/Format">
<xsl:param name="dia" select="7"/>
<xsl:param name="mes" select="12"/>
<xsl:param name="ano" select="2006"/>
<xsl:param name="total">

<xsl:call-template name="y">
<xsl:with-param name="mes" select="$mes"/>
</xsl:call-template>
</xsl:param>

<xsl:value-of select="$total"/>
</xsl:template>
<xsl:template name="y">
<xsl:param name="mes"/>
<xsl:variable
name="Data"
select="/dias/data[dia=$dia
ano=$ano]/msg"/>
<xsl:value-of select="$Data"/>
</xsl:template>
and
mes=$mes
and
</xsl:stylesheet>
Resultado:
104
XSD
XSLT
<xsl:variable>
XML:

<!DOCTYPE AVISOS SYSTEM "aviso.dtd">
<?xml-stylesheet type="text/xsl" href="aviso.xsl"?>
<AVISOS>
<AVISO>
<data>12_12_2003</data>
<de>Luisa</de>
<para>Paula</para>
<assunto>Tratar de tudo...</assunto>
</AVISO>
<AVISO>
<data>12_12_2002</data>
<de>Luis</de>
<para>Paulo</para>
<assunto>Ainda no foi tudo tratado</assunto>
</AVISO>
<AVISO>
<data>12_12_2002</data>
<de>Pedro</de>
<para>Paulo</para>
<assunto>Importante no esquecer</assunto>
</AVISO>
</AVISOS>
XML Stylesheet:

<xsl:variable name="lowercase" select="'abcdefghijklmnopqrstuvwxyz'" />
<xsl:variable name="uppercase" select="'ABCDEFGHIJKLMNOPQRSTUVWXYZ'" />
<xsl:variable name="Data">24-11-2009</xsl:variable>
<xsl:template match="/AVISOS">
<html>
<head>
<title>AVISOS</title>
</head>
<body class="bg">
<center><h4>AVISOS</h4>(<xsl:value-of select="$Data"/>)</center>
<table width="100%" border="1"><thead>
<th>Origem</th>
<th>Destino</th>
<th>Assunto</th>
<th>Data</th>
</thead>
<tbody>
</tbody>
<tr><td>
</td></tr>
</table>
</body>
</html>
</xsl:template>
<xsl:template match="AVISO">
<tr>
<td width="20%">
105
XSLT
XSD
<i><xsl:value-of select="translate(de, $lowercase, $uppercase)"/></i>

</td>
<td width="20%">
<xsl:value-of select="translate(para, $uppercase, $lowercase)"/>
</td>
<td width="50%"> <xsl:value-of select="assunto"/></td>
<td width="10%"> <xsl:value-of select="data"/></td>
</tr>
</xsl:template>
</xsl:stylesheet>
Resultado:
<xsl:call-template>
XML:
<?xml-stylesheet type="text/xsl" href="soccer1.xsl"?>
<results group="A">
<match>
<date>1998-06-10</date>
<team score="2">Brazil</team>
<team score="1">Scotland</team>
</match>
<match>
<date>1998-06-16</date>
<team score="0">Morocco</team>
</match>
<match>
<date>1998-06-23</date>
<team score="2">Norway</team>
</match>
<match>
<date>1998-06-10</date>
</match>
<match>
<date>1998-06-16</date>
</match>
<match>
<date>1998-06-23</date>
</match>
</results>
XMl StyleSheet:
106
XSD
XSLT
<xsl:stylesheet version="1.0"
xmlns:xsl="http://www.w3.org/1999/XSL/Transform">
<xsl:variable name="table-heading">
<tr>
<td><b>Date</b></td>
<td><b>Home Team</b></td>
<td><b>Away Team</b></td>
<td><b>Result</b></td>
</tr>
</xsl:variable>
<xsl:template name="format-date">
<xsl:param name="iso-date"/>
<xsl:variable name="months"
select="'JanFebMarAprMayJunJulAugSepOctNovDec'"/>
<xsl:value-of select="substring($iso-date, 9, 2)"/>
<xsl:text> </xsl:text>
<xsl:variable name="month" select="substring($iso-date, 6, 2)"/>
<xsl:value-of select="substring($months, ($month - 1)*3 + 1, 3)"/>
<xsl:value-of select="substring($iso-date, 1, 4)"/>
</xsl:template>
<html><body>
<h1>Matches in Group <xsl:value-of select="/*/@group"/></h1>
<xsl:apply-templates select="/results/match">
<xsl:sort select="date"/>
<xsl:sort select="team[1]"/>
</xsl:apply-templates>
</body></html>
</xsl:template>
<xsl:template match="match">
<xsl:variable name="date-out">
<xsl:call-template name="format-date">
<xsl:with-param name="iso-date" select="date"/>
</xsl:variable>
<h2><xsl:value-of select="concat(team[1], ' versus ', team[2])"/></h2>
<table bgcolor="#cccccc" border="1" cellpadding="5">
<xsl:copy-of select="$table-heading"/>
<tr>
<td><xsl:value-of select="$date-out"/></td>
<td><xsl:value-of select="team[1]"/></td>
<td><xsl:value-of select="team[2]"/></td>
<td><xsl:value-of select="concat(team[1]/@score, '-',
team[2]/@score)"/></td>
</tr>
</table>
</xsl:template>
</xsl:stylesheet>
Resultado:
107
XSLT
XSD
document()
XML:
<?xml version="1.0" ?>
<?xml-stylesheet type="text/xsl" href="Outro.xsl" ?>
<projects>
<record>
<project_family>Backlog</project_family>
<priority>1</priority>
<description>Highest Priority Backlog Project</description>
<record_id_>4</record_id_>
</record>
<record>
<description>Lowest Priority Backlog Project</description>
</record>
<record>
<project_family>Next Year</project_family>
<description>Lowest Priority New Project</description>
</record>
<record>
<project_family>Next Year</project_family>
<description>Highest Priority New Project</description>
</record>
</projects>
XML:
<tasks>
<record>
<rank>1</rank>
<description url="Project.xml">Tarefa 1</description>
<related_project>4</related_project>
</record>
<record>
<rank>4</rank>
</record>
108
XSD
XSLT
<record>
<rank>3</rank>
</record>
<record>
<rank>2</rank>
</record>
</tasks>
XML:
<?xml-stylesheet type="text/xsl" href="Project.xsl" ?>
<projects>
<record>
<description>Projecto Backlog: alta prioridade</description>
</record>
<record>
<description>Projecto Backlog: baixa prioridade</description>
</record>
<record>
<project_family>Prximo Ano</project_family>
<description>Novo Projecto: Menor Prioridade</description>
</record>
<record>
<description>Novo Projecto: Maior Prioridade</description>
</record>
</projects>
XML StyleSheet Outro.xsl:


<xsl:stylesheet version="1.0" xmlns:xsl='http://www.w3.org/1999/XSL/Transform'>
<xsl:output method="html"/>
<xsl:output encoding="ISO-8859-1"/>
<xsl:template match="/projects">
<html>
<body>
<table border="1" width="50%" cellpadding="5">
<tr>
<th>Tipo de Projecto</th>
<th>Prioridade</th>
<th>Descrio</th>
</tr>
<xsl:call-template name="gera">
<xsl:with-param name="file">Tasks.xml</xsl:with-param>
</table>
<br/>
Lista Indexada:
109
XSLT
XSD
<br/>
<xsl:call-template name="gera2">
<xsl:with-param name="filtro">2</xsl:with-param>
</body>
</html>
</xsl:template>

<xsl:template name='gera'>
<xsl:param name='file'/>
<xsl:apply-templates select='document($file)/tasks'/>
</xsl:template>

<xsl:template name='gera2'>
<xsl:param name='file'/>
<xsl:param name='filtro'/>
<tr>
<th>Tarefa</th>
<th>Ranking</th>
<th>Proj. Relacionados</th>
</tr>
select='document($file)/tasks/record[rank>$filtro]'/>
</table>
</xsl:template>

<xsl:template match="/tasks">
<h2>Lista de Projectos</h2>
<xsl:for-each select="record">
<xsl:sort data-type="number" select="rank"/>
<xsl:sort data-type="text" select="description"/>
<tr>
<td>
<xsl:value-of select="rank"/>
</td>
<td>
<xsl:value-of select="related_project"/>
</td>
<td>
<xsl:value-of select="description"/>
</td>
</tr>
</xsl:for-each>
</xsl:template>

<xsl:template match="/tasks/record">
<tr>
<td>
<a href="{description/@url}"><xsl:value-of select="description"/></a>
</td>
<td>
<xsl:value-of select="rank"/>
</td>
<td>
<xsl:value-of select="related_project"/>
</td>
</tr>
</xsl:template>
</xsl:stylesheet>
110
XSD
XSLT
XML StyleSheet Product.xsl:

<html>
<body>
<tr>
<th>Famlia</th>
<th>Prioridade</th>
<th>Descrio</th>
</tr>
<xsl:sort data-type="text" select="project_family"/>
<xsl:sort data-type="number" select="priority"/>
<tr>
<td>
<xsl:value-of select="project_family"/>
</td>
<td>
<xsl:value-of select="priority"/>
</td>
<td>
</td>
</tr>
<tr>
<td>
</td>
<td colspan="2">
Relacionado
Detalhes:<br/>
com
Projecto
<b><xsl:value-of
select="record_id_"/></b>
<xsl:call-template name="detalhe">
<xsl:with-param name="project_id"><xsl:value-of
select="record_id_"/></xsl:with-param>
</td>
</tr>
</xsl:for-each>
</table>
</body>
</html>
</xsl:template>
<xsl:template name="detalhe">
<xsl:param name="project_id"/>
<xsl:param name="file"/>
select='document($file)/tasks/record[related_project=$project_id]'/>
</xsl:template>
<xsl:value-of select="description"/> Rank: <xsl:value-of select="rank"/><BR/>
</xsl:template>
</xsl:stylesheet>
Resultado:
111
XSLT
XSD
Mltiplos XML/StyleSheets
Uma das mais importantes e interessantes capacidades de processamento de documentos XML a
possibilidade de serem processadas por vrias StylesSheets inter-relacionadas ou no. Vejamos este conceito
atravs do seguinte exemplo.
Considere-se ento o seguinte documento XML (Projects.xml):
<?xml-stylesheet type="text/xsl" href="Project.xsl" ?>
<projects>
<record>
112
XSD
XSLT
</record>
<record>
<description>Projecto Backlog: baixa prioridade</description>
</record>
<record>
<description>Novo Projecto: Menor Prioridade</description>
</record>
<record>
<description>Novo Projecto: Maior Prioridade</description>
</record>
</projects>
E a StyleSheet nele referenciada (Project.xsl):

<html>
<body>
<tr>
<th>Famlia</th>
<th>Prioridade</th>
<th>Descrio</th>
</tr>
<xsl:sort data-type="text" select="project_family"/>
<xsl:sort data-type="number" select="priority"/>
<tr>
<td>
<xsl:value-of select="project_family"/>
</td>
<td>
<xsl:value-of select="priority"/>
113
XSLT
XSD
</td>
<td>
</td>
</tr>
<tr>
<td>
</td>
<td colspan="2">
Relacionado com o Projecto <b><xsl:value-of select="record_id_"/></b> Detalhes:<br/>
<xsl:with-param name="project_id">
<xsl:value-of select="record_id_"/>
</xsl:with-param>
</td>
</tr>
</xsl:for-each>
</table>
</body>
</html>
</xsl:template>
</xsl:template>
<xsl:value-of select="description"/> Rank: <xsl:value-of select="rank"/><BR/>
</xsl:template>
</xsl:stylesheet>
O resultado da sua aplicao seria:
114
XSD
XSLT
Figura 14 - Exemplo de Aplicao de Multiplos XSL

Considere-se ainda o documento Tasks.xml que invocado na stylesheet como Detalhes:
<tasks>
<record>
<rank>1</rank>
</record>
<record>
<rank>4</rank>
</record>
<record>
<rank>3</rank>
115
XSLT
XSD
</record>
<record>
<rank>2</rank>
</record>
</tasks>
Para explicar melhor o comportamento desta sequncia de XML/XSL, recordemos o primeiro registo do nosso
documento XML (Projects.xml):
<record>
</record>
Tabela 5- Exemplo de Registo XML

Numa possvel descrio deste XML, deduz-se que o projecto BackLog de prioridade 1 e tem o registo nmero
4.
Se analisarmos agora o template detalhe da nossa StyleSheet:
</xsl:template>
Tabela 6 - Exemplo de Template com document()

Deparamos que existe a definio de dois parmetros (project_id e file) e que, partindo dos respectivos valores
se acede a um documento externo (nome no parmetro file) (com o operador document()) e se posiciona num
determinado contexto dependendo do valor do parmetro project_id.
Assim, quando invocado este template com:
<xsl:with-param name="project_id">
116
XSD
XSLT
<xsl:value-of select="record_id_"/>
</xsl:with-param>
So passados como parmetros os valores do elemento record_id e Tasks.xml, respectivamente para o

parmetro project_id e file. No registo que identificamos na Tabela 5, os valores a passar sero ento o 4 e
Tasks.xml.
Ou seja, na Tabela 6, a expresso
<xsl:apply-templates select='document($file)/tasks/record[related_project=$project_id]'/>
Resultaria ento em:

<xsl:apply-templates select='document(Tasks.xml)/tasks/record[related_project=4]'/>
O que na prtica significa aceder ao ficheiro XML Tasks.XML e aceder aos registos:
<record>
<rank>1</rank>
</record>
<record>
<rank>4</rank>
</record>
Correspondendo ento aos detalhes do projecto inicial e da a sua apresentao na tabela HTML na Figura 14.
A ttulo de resumo, o acesso a um documento externo geralmente conseguido com recurso ao mtodo
document(). Sempre que tal feito, o contexto actual passa a ser o contexto desse documento externo.
117
PARTE IV
XSL Aplicado
XSL
XML e outras tecnologias

Uma das utilizaes mais comuns do XML ocorre na gerao de pginas dinmicas em aplicaes web. O XML
consegue integrar-se facilmente com mltiplas linguagens de programao para a Web e at mesmo com as
CSS10.
A ttulo demonstrativo apresentamos de seguida a forma de processar documentos XML com a aplicao de
XML Stylesheets, recorrendo a linguagens de programao como o PHP, JAVA, C# e mesmo o JavaScript.
PHP e XML
O exemplo seguinte11 mostra como processar XML com XML Stylesheets utilizando o PHP.
Pretende-se desenvolver uma pequena aplicao que gere Currculos Pessoais. Uma vez que foi desenvolvido
em PHP4, para o executar na nova verso PHP (5.2) foi necessrio proceder a pequenas alteraes,
nomeadamente a incluso das seguintes instrues:
if ((PHP_VERSION>='5')&& extension_loaded('xsl'))
require_once('xslt-php4-to-php5.php');
Figura 15 - Exemplo PHP/XML: Login
Aps validada a autenticao (Figura 15), o utilizador confrontado com um conjunto de currculos associados
(Figura 16). A script que valida a entrada valida.php apresentada a seguir. Repare-se nas instrues PHP
10
Consultar Sebenta de Programao Web

Este exemplo foi elaborado pelos alunos 1826 e 1898, no mbito da disciplina de Sistemas de Informao
Aplicados, poca 2005-2006.
11
121
XSL
que processam o XML. Repare-se ainda na passagem do parmetro $nome para a XML Stylesheet. Tal permite
a modularizao destes mdulos.
Script valida.php
Responsvel por processar o XML com a Stylesheet.
1.
2.
3.
<?php
// Sistema de Login Simples sem resurso a Base de Dados
//alunos: 1826 e 1898
4.
5.
6.
//Para ser suportado em PHP5

if ((PHP_VERSION>='5')&& extension_loaded('xsl'))
require_once('xslt-php4-to-php5.php');
7.
8.
$nome = $_POST["login"];
$senha = $_POST["senha"];
9.
10.
11.
// Definio de Variveis
$arquivo = "users.txt";
$fd = fopen ($arquivo, "r");
12.
13.
14.
//Docs a utilizar
$xml_file = "curriculos.xml";
$xsl_file = "curriculos.xsl";
15.
16.
17.
$xh = xslt_create();
$fileBase = 'file://' . getcwd () . '/';
xslt_set_base ( $xh, $fileBase );
18.
19.
20.
21.
22.
23.
24.
25.
26.
27.
28.
29.
30.
31.
32.
33.
34.
35.
//Processamento do Doc XML

$i=0;
while ($userinfo = fscanf ($fd, "%s\t%s\t%s")) {
list ($login, $pass, $nome) = $userinfo;
if ($login == $nome && $senha == $pass) {
$params["nome"]=$nome;
//processa XML com XSL
$result = xslt_process($xh, $xml_file, $xsl_file,NULL,NULL,$params);
echo $result;
$i++;
break;
}
}
if($i == 0) {
require("erro.php");
}
xslt_free($xh);
?>
A instanciao do valor do parmetro nome feito pela instruo

$params["nome"]=$nome;
na linha 23 da script valida.php. Esse valor corresponde ao o valor inserido no campo UserName do formulrio
de autenticao, cuja recolha feita pela instruo da linha 7 da referia script.
De seguida mostra-se a XML StyleSheet que processa o documento XML. Repare-se na definio do parmetro
nome que controla a execuo do template principal.
1.
2.
3.
4.
122

<xsl:param name="nome"/>
XSL
5.

6.
7.
8.
9.
<xsl:template match="/curriculos">
<basefont face="Arial"/>
<html>
<body>
10.
11.
18.
19.
20.
21.
<div id="cabecalho" align="center">

<img src="./images/stone.gif" alt="stone" border="0" width="180"
height="150"/><br />
<p><font face="Times New Roman" size="6" color="#800000">~ Registo de Curricula
~</font></p>
<p>
<span style="font-size: 8pt">DEPARTAMENTO DE RECURSOS HUMANOS</span>
</p>
<p>
<font face="arial"><span bgcolor="silver" style="font-size: 14pt">CANDIDATOS
INSCRITOS</span></font>
</p>
</div>
<table border="0" width="40%" id="table" align="center">
<xsl:apply-templates select="curriculo[informacao_pessoal/nome=$nome]"/>
22.
23.
24.
25.
</table>
</body>
</html>
</xsl:template>
26.
27.
<xsl:template match="curriculo">
<xsl:param name="nome"/>
28.
29.
30.
31.
32.
33.
34.
35.
36.
37.
38.
<tr bgcolor="silver" align="left" style="font-size: 12pt">

<td><b>Nome</b></td><td><xsl:value-of select="informacao_pessoal/nome"/></td>
</tr>
<tr style="font-size: 10pt">
<td>Morada</td><td><xsl:value-of select="informacao_pessoal/morada/rua"/></td>
</tr>
<td>Nmero</td><td><xsl:value-of select="informacao_pessoal/morada/num"/></td>
</tr>
<td>Cdigo Postal</td><td><xsl:value-of
select="informacao_pessoal/morada/cp4"/></td>
</tr>
<td>Localidade</td><td><xsl:value-of
select="informacao_pessoal/morada/localidade"/></td>
</tr>
<td>Pas</td><td><xsl:value-of select="informacao_pessoal/morada/pais"/></td>
</tr>
<td>Telefone</td><td><xsl:value-of
select="informacao_pessoal/telefones/telefone"/></td>
</tr>
<td>Telemvel</td><td><xsl:value-of
select="informacao_pessoal/telefones/telemovel"/></td>
</tr>
<td>Email</td><td><xsl:value-of
select="informacao_pessoal/correio_electrnico"/></td>
</tr>
<td>Nacionalidade</td><td><xsl:value-of
select="informacao_pessoal/nacionalidade"/></td>
</tr>
<td><b>Experincia Profissional desde:</b></td><td><xsl:value-of
select="experiencia_profissional/empresas/empresa/data"/></td>
</tr>
12.
13.
14.
15.
16.
17.
39.
40.
41.
42.
43.
44.
45.
46.
47.
48.
49.
50.
51.
52.
53.
54.
55.
56.
57.
58.
59.
60.
123
XSL
61.
62.
63.
64.
65.
66.
67.
68.
69.
70.
71.
72.
73.
74.
75.
76.
77.
78.
79.
80.
81.
82.
83.
84.
85.
86.
87.
88.
89.
90.
91.
92.
93.
94.
95.
96.
97.
98.
99.
100.
101.
102.
103.
104.
105.
106.
107.
108.

<td>Empresa</td><td><xsl:value-of
select="experiencia_profissional/empresas/empresa/nome_emp"/></td>
</tr>
<td>Morada</td><td><xsl:value-of
select="experiencia_profissional/empresas/empresa/endereco_emp/rua"/></td>
</tr>
<td>N</td><td><xsl:value-of
select="experiencia_profissional/empresas/empresa/endereco_emp/num"/></td>
</tr>
<td>Cdigo Postal</td><td><xsl:value-of
select="experiencia_profissional/empresas/empresa/endereco_emp/cp4"/></td>
</tr>
<td>Localidade</td><td><xsl:value-of
select="experiencia_profissional/empresas/empresa/endereco_emp/localidade"/></
td>
</tr>
<td>Tipo de Empresa</td><td><xsl:value-of
select="experiencia_profissional/empresas/empresa/tipo_empresa"/></td>
</tr>
<td>Funes</td><td><xsl:value-of
select="experiencia_profissional/empresas/empresa/funcao"/></td>
</tr>
<td>Actividade responsvel</td><td><xsl:value-of
select="experiencia_profissional/empresas/empresa/actividade_resp"/></td>
</tr>
<td><b>Formao profissional:</b></td><td><xsl:value-of
select="formacao/profissional/data"/></td>
</tr>
<td>Organizao</td><td><xsl:value-of
select="formacao/profissional/nome_org"/></td>
</tr>
<td>Tipo de Organizao</td><td><xsl:value-of
select="formacao/profissional/tipo_org"/></td>
</tr>
<td>Competncia</td><td><xsl:value-of
select="formacao/profissional/competencias"/></td>
</tr>
<td><b>Formao Acadmica:</b></td><td><xsl:value-of
select="formacao/academica/data"/></td>
</tr>
<td>Nome da Organizao</td><td><xsl:value-of
select="formacao/academica/nome_org"/></td>
</tr>
<td>Tipo de Organizao</td><td><xsl:value-of
select="formacao/academica/tipo_org"/></td>
</tr>
<td>Curso</td><td><xsl:value-of select="formacao/academica/curso"/></td>
</tr>
109. </xsl:template>
110. </xsl:stylesheet>
124
XSL
Excerto do documento XML com os currculos dos candidatos:



<?xml:stylesheet type="text/xsl" href="curriculos.xsl"?>
<curriculos>

<curriculo>
<informacao_pessoal>
<nome>lufer</nome>
<morada>
<rua>Rua da Palha</rua>
<num>35</num>
<cp4>4750
<cp3>356</cp3>
</cp4>
<localidade>Ponte de Lima</localidade>
<pais>Portugal</pais>
</morada>
<telefones>
<telefone>253886598</telefone>
<telemovel>932544766</telemovel>
</telefones>
<correio_electrnico>isaias@benfica.pt</correio_electrnico>
<data_nascimento>25/12/83</data_nascimento>
<estado_civil>Solteiro</estado_civil>
<situacao_militar>regularizada</situacao_militar>
<nacionalidade>Portuguesa</nacionalidade>
</informacao_pessoal>
<experiencia_profissional>
<empresas>
<empresa>
<data>Desde Maro 2005</data>
<nome_emp>Grupo Amorim</nome_emp>
<endereco_emp>
<rua>Rua Dr. Matos Graca</rua>
<num>35</num>
<cp4>4750
<cp3>319</cp3>
</cp4>
<localidade>Braga</localidade>
</endereco_emp>
<tipo_empresa>Sector Informtico</tipo_empresa>
<funcao>Programador</funcao>
<actividade_resp>Programao em Java</actividade_resp>
</empresa>
</empresas>
</experiencia_profissional>
<formacao>
<profissional>
<data>De Setembro 2004 a Fevereiro de 2005</data>
<nome_org>Caras</nome_org>
<tipo_org>Associao</tipo_org>
<competencias>Tecnico Informatica</competencias>
</profissional>
<academica>
<data>De 1999 at 2004</data>
<nome_org>Universidade Beira Interior</nome_org>
<tipo_org>Universidade</tipo_org>
<curso>Informatica para Gesto</curso>
</academica>
</formacao>
<observacoes/>
</curriculo>
</curriculos>
A Figura seguinte mostra o resultado da aplicao da XML StyleSheet ao documento XML apresentado, neste
caso para o candidato lufer sendo apresentado o respectivo curriculum vitae.
125
XSL
Figura 16 - Resultado PHP/XSL
XSL com JAVA

O exemplo seguinte demonstra a forma de processar XML com uma XML StyleSheet, em tecnologia JAVA. So
utilizadas as bibliotecas JAXP.
import java.io.*;
/**
* Processamento de XML com XSLT em JAXP
* lufer - 2006-2007
*/
public class SimpleJaxp {
/**
* Recebe dois argumentos: o nome do ficheiro XML e o nome do
* ficheiro XSLT. O resultado escrito no stdout
*/
public static void main(String[] args)
throws javax.xml.transform.TransformerException {
if (args.length != 2) {
System.err.println("Sintaxe:");
System.err.println(" java " + SimpleJaxp.class.getName( )
+ " FicheiroXML FicheiroXSLT");
System.exit(1);
}
File xmlFile = new File(args[0]);
File xsltFile = new File(args[1]);
javax.xml.transform.Source xmlSource =
new javax.xml.transform.stream.StreamSource(xmlFile);
javax.xml.transform.Source xsltSource =
new javax.xml.transform.stream.StreamSource(xsltFile);
javax.xml.transform.Result result =
new javax.xml.transform.stream.StreamResult(System.out);
126
XSL
// cria uma instncia de TransformerFactory
javax.xml.transform.TransformerFactory transFact =
javax.xml.transform.TransformerFactory.newInstance( );
javax.xml.transform.Transformer trans =
transFact.newTransformer(xsltSource);
trans.transform(xmlSource, result);
}
Para executar deve executar os seguintes comandos:

1- set CLASSPATH=%CLASSPATH%;.
2- javac *.java
3- java SimpleJaxp teste.xml teste.xsl
XSL com JavaScript

O processamento de documentos XML em aplicaes Web (nomeadamente) pode (e recomenda-se) ser
processado no lado da aplicao cliente, i.e., no browser. O Javascript , por excelncia um dos mecanismos
que o permite. As novas frameworks Javascript como o AJAX ou JQuery, recorrem normalmente a este servio.
O processo semelhante a qualquer processamento. identificado o documento XML a processar e a XML
Stylesheet a aplicar. A aplicabilidade disto evidente uma vez que facilmente se conseguem resultados
diferentes (quer em layouts, quer em contedos), sem a necessiade de refresh da pgina em exibio no
servidor web.
O exemplo que vamos explorar demonstra isso mesmo 12. Existe a informao sobre determinado Curriculum
Vitae que se pertende visualizar num stio web (vulgo pgina web). A transformao desse curriculum para a
visualizao de apenas parte do seu contedo, determinadas partes enquadradas num determinado critrio, e
multi-idioma, so algumas das funcionalidades exploradas.
O curriculum pode ser descrito segundo o documento XML apresentado na Figura 18. Para implementar o
conjunto de funcionalidades foram desenvolvidas um conjunto de XML Stylesheets especficas.
A listagem seguinte mostra a pgina HTML (para browser Internet Explorer) que gere todo o processo. Nela
consta todo o cdigo Javascript que se encarrega de processar os documentos XML e de apresentar os
respectivos resultados. A utilizao de CSS (linha 4) e estruturao do layout em divs (linha 41) permite o
processamento de resultados de forma rpida e o refresch automtico da pgina.
A funo apply (linha 16) encarrega-se de aplicar a stylesheet pretendida ao documento original XML. Reparese na invocao desta funo com parmetros diferentes, i.e., com nomes de stylesheets diferentes (linhas 35 a
39)
12
Exemplo explorado num trabalho prtico da disciplina de ISI de 2010-2011, pelo aluno 4379 Jos Carlos.
127
XSL
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.
19.
20.
21.
22.
23.
24.
25.
26.
27.
28.
29.
30.
31.
32.
33.
34.
35.
36.
37.
38.
39.
40.
41.
42.
<html xmlns="http://www.w3.org/1999/xhtml" >

<head>
<title>CV Europass</title>
<link rel="stylesheet" type="text/css" href="style.css"/>
<script type="text/javascript" language="javascript">
var source = null;
var style = null;
var transformer = null;
function init() {
source = new ActiveXObject("MSXML2.FreeThreadedDOMDocument");
source.async = false;
source.load('cv.xml');
}
function apply(stylesheet) {
style = new ActiveXObject("MSXML2.FreeThreadedDOMDocument");
style.async = false;
style.load(stylesheet);
transformer = new ActiveXObject("MSXML2.XSLTemplate");
transformer.stylesheet = style.documentElement;
var xslproc = transformer.createProcessor();
xslproc.input = source;
xslproc.transform();
displayarea.innerHTML = xslproc.output;
}
</script>
<script
type="text/javascript"
language="javascript"
for="window"
event="onload">
init();
</script>
</head>
<body>
<button onclick="apply('cv.xsl')">CV Portugus</button>
<button onclick="apply('cv2.xsl')">CV Ingls</button>
<button onclick="apply('cvfiltros.xsl')">Filtros 1998-2005</button>
<button onclick="apply('cvfiltros2.xsl')">Filtros 2006-2008</button>
<button
onclick="apply('cvfiltros3.xsl')">Competncias
Informticas</button>
<button
onclick="javascript:top.document.location.href='xsl2pdf.php'">Gerar
PDF</button>
<div id="displayarea"></div>
</body>
</
43.
A pgina desenhada tem o aspecto apresentado na Figura 17. A cada activao dos botes so aplicadas
stylesheets diferentes. Por exemplo, ao boto CV Portugus ser aplicada a stylesheet cv.xsl e ao CV Ingls
ser aplicada a stylesheet cv2.xsl (linhas 35 e 36 da listagem anterior, respectivamente). Os resultados sero
por isso diferentes.
Figura 17 - Frontend de Gesto do CV
128
XSL
A listagem seguinte mostra a traduo da estrutura de um CV noutro idioma, utilizando um dicionrio externo
de termos (dicionario.xml - Figura 19). Repare-se no processamento de um documento XML externo atravs do
operador XPath document (linhas 9 e 15).
44.
45.
46.
47.


<xsl:variable name="file">dicionario.xml</xsl:variable>

48.
49.
50.
51.
52.


<xsl:template match="identification">
<tr>
<td class="Left">
<h3><xsl:value-of
select="document($file)//terms/term/des[@code='info']/id[@type=$idioma]"/>
</h3>
</td>
</tr>
<tr>
<td class="Left">
<xsl:value-of
select="document($file)//terms/term/des[@code='identification']/id[@type=$idio
ma]"/>
</td>
<td>
| <xsl:value-of select="lastname"/>, <xsl:value-of select="firstname"/>
</td>
</tr>
</xsl:template>
53.
54.
55.
56.
57.
58.
59.
60.
61.
62.
63.
64.
Figura 18 - Estrutura de um CV em XML
129
XSL
Figura 19 - Dicionrio de termos em XML
Alguns dos resultados do processamento podem ser analisados na Figura 20.
Figura 20 - Transformao de CV com Javascript
130
XSL
XSL com C#
C# e ASP.NET corresponde a uma das tecnologias/plataformas mais utilizadas nas aplicaes web. De seguida
iremos apresentar um exemplo semelhant de transformao de um documento XML. Neste caso o documento
XML descreve o contedo de um livro (ndice, captulos, etc.) e pretende-se tambm controlar a apresentao
do seu contedo (totalidade ou apenas parte) atravs da aplicao de uma XML StyleSheet.
Basicamente pertende-se gerar uma verso HTML do livro, cujos captulos podem ser directamente acedidos
atravs de um ndice automtico. Mas analisemos este exemplo13.
Um livro pode ser descrito de acordo com um documento XML (excerto apresentado na Figura 21). Como
possvel analisar a estruturao de um livro dinmica e uma vez conseguida permite a sua manipulao no
todo ou em partes.
Aquilo que se pretende conseguir gerar uma pgina (ou pginas) HTML com todo ou parte do contedo do
livro (Figura 26).
Para a transformao do XML no HTML (explorado com mais exemplos a seguir) foi desenvolvida uma XML
Stylesheet que possibilita o tratamento por cada seco existente no documento XML. A listagem seguinte
mostra essa stylesheet.
Figura 21- Estrutura XML de um livro
13
Exemplo explorado pelo aluno 3749 Tiago Carvalho, na disciplina de ISI de 2010-2011.
131
XSL
1. <xsl:template match="LIVRO">
2.
<html>
3.
<head>
4.
<meta http-equiv="Content-Type" content="text/html; charset=utf-8"/>
5.
</head>
6.
<body>
7.
<h1><xsl:value-of select="TITULO"/></h1><br/>
8.
<xsl:call-template name="indice"/>
9.
10.
</body>
11.
</html>
12. </xsl:template>
13. <xsl:template name="indice">
14.
<br/>
15.
<h1>NDICE</h1><br/>
16.
<xsl:for-each select="/LIVRO/*">
17.
<xsl:call-template name="indice-item"/>
18.
</xsl:for-each>
19. </xsl:template>
20. <xsl:template name="indice-item">
21. <xsl:choose>
22.
<xsl:when test="local-name()='TITULO'">
23.
</xsl:when>
24.
<xsl:when test="local-name()='CAPITULO'">
25.
<a href="#{position()}"><xsl:value-of select="local-name()"/> - <xsl:value-of
select="TITULO_CAPITULO"/></a><br/>
26.
</xsl:when>
27.
<xsl:otherwise>
28.
<a href="#{position()}"><xsl:value-of select="local-name()"/></a><br/>
29.
</xsl:otherwise>
30. </xsl:choose>
31. </xsl:template>
32. <xsl:template match="TITULO"></xsl:template>
33.
34.
35.
36.
37.
<xsl:template match="ISBN">
<br/>
<a name="{position()}"><br/></a>
<b>ISBN: </b><xsl:value-of select="."/><br/>
</xsl:template>
38.
39.
40.
41.
42.
43.
44.
45.
46.
47.
<xsl:template match="AUTOR">
<a name="{position()}"><br/></a>
<h2>Autor</h2><br/>
<b>Nome: </b><xsl:value-of select="NOME"/><br/>
<b>Data de nascimento: </b><xsl:value-of select="DATA_DE_NASCIMENTO"/><br/>
<b>Nacionalidade: </b><xsl:value-of select="NACIONALIDADE"/><br/>
<b>Gnero literrio: </b><xsl:value-of select="GENERO_LITERARIO"/><br/>
<b>Obras conhecidas: </b><xsl:value-of select="PRINCIPAIS_TRABALHOS"/><br/>
<b>Resumo: </b><xsl:value-of select="RESUMO"/><br/>
</xsl:template>
48. 
<?xml-stylesheet type="text/xsl" href="tp_csv.xsl"?>
<ptable>
<element atributo="100">
<name>Hydrogen</name>
<symbol>H</symbol>
<number>1</number>
</element>
<element>
<name>Lithium</name>
<symbol>Li</symbol>
<number>3</number>
</element>
<element>
<name>Sodium</name>
<symbol>Na</symbol>
<number>11</number>
</element>
141
XSL


</ptable>
Consideremos agora a XML StyleSheet a referenciada tp_csv.xsl:

<!by lufer -->
<xsl:output method="text" omit-xml-declaration="yes" />
<xsl:strip-space elements="*"/>
<xsl:call-template name="header"/>
</xsl:template>
<xsl:template match="//element">
<xsl:for-each select="*">
<xsl:value-of select="text()"/><xsl:text>;</xsl:text>
<xsl:if test="position()=last()"><xsl:text> </xsl:text>
</xsl:if>
</xsl:for-each>
</xsl:template>
<xsl:template name="header">
<xsl:for-each select="//element[1]/*">
<xsl:value-of select="name()"/>
<xsl:text>;</xsl:text>
<xsl:if test="position()=last()">
</xsl:if>
</xsl:for-each>
</xsl:template>
</xsl:stylesheet>
O resultado da sua aplicao seria um documento csv (tp.csv) com a seguinte informao:
Nome;Simbolo;Numero
Hydrogen;H;1
Lithium;Li;3
Sodium;Na;11
142
XSL
Para experimentar aplicar esta transformao, utilizar o utilitrio uxt da seguinte forma:
uxt tp.xml tp.xsl tp.csv
Gerar WML
Pretende-se neste exemplo mostrar a gerao de um documento WML Wireless Markup Language formato
utilizado para garantir a interaco com dispositivos mveis como so o caso dos telemveis e outros, a partir
de um documento XML.
Considere-se o seguinte documento XML:

<?xml-stylesheet type="text/xsl" href="bolsa_wml.xsl"?>
<bolsa>
<data>17-09-2008</data>
<empresa>
<nome>Altri</nome>
<estado>Desce</estado>
<cota>2,410</cota>
<hora>17:25</hora>
<varia>0,01</varia>
</empresa>
<empresa>
<nome>BCP</nome>
<cota>1,210</cota>
<hora>15,29</hora>
<varia>0,02</varia>
</empresa>
<empresa>
<nome>Brisa</nome>
<estado>Sobe</estado>
<cota>6,910</cota>
<hora>15,29</hora>
<varia>0,23</varia>
</empresa>
<empresa>
<nome>EDP</nome>
<cota>2,920</cota>
<hora>15,29</hora>
<varia>-0,03</varia>
</empresa>
<empresa>
<nome>REN</nome>
143
XSL
<cota>2,720</cota>
<hora>15,29</hora>
<varia>-0,05</varia>
</empresa>
</bolsa>
Agora a XML StyleSheet referenciada - bolsa_wml.xsl:


<xsl:output method="xml" omit-xml-declaration="yes" />
<wml>
<card id="carro" title="Cotaes na Bolsa">
<p align="center">
Cotaes na Bolsa:
</p>
<xsl:apply-templates select="bolsa/empresa"/>
<font size="-3"><xsl:value-of select="bolsa/data"/></font>
</card>
</wml>
</xsl:template>
<xsl:template match="empresa">
<b><xsl:value-of select="nome" /></b>
(<xsl:if test="estado='Desce'"><img src="dn_tend.gif"/>
</xsl:if>
<xsl:if test="estado='Sobe'">
<img src="up_tend.gif"/>
</xsl:if>
)
- <xsl:value-of select="cota" />
<br/>
</xsl:template>
</xsl:stylesheet>
O resultado da sua aplicao seria um documento WML que poder ser visualizado num emulador (Figura 30).
144
XSL
Figura 30 - Emulador de WML
Gerar XML
Pretende-se neste exemplo mostrar a gerao de um novo documento XML mas com estrutura diferente.
Embora parea estranho, trata-se de uma operao til e comum apara integrar dois sistemas que idem com
informao diferente.
Considere-se ento, por exemplo, o seguinte documento XML:
<?xml-stylesheet type="text/xsl" href="old.xsl"?>
<portfolio>
<stock>
<symbol>HHDT</symbol>
<cprice>25</cprice>
</stock>
<stock>
<symbol>NHSJ</symbol>
<oprice>20</oprice>
</stock>
</portfolio>
E a XML StyleSheet nele referenciada, old.xsl:

145
Caso de Estudo
XSL


<xsl:output method="xml"/>
<xsl:element name="portfolio">
</xsl:element>
</xsl:template>
<xsl:template match="//stock">
<xsl:element name="{symbol}">
<xsl:attribute name="oprice">
<xsl:value-of select="oprice" />
</xsl:attribute>
<xsl:attribute name="cprice">
<xsl:value-of select="cprice" />
</xsl:attribute>
</xsl:element>
</xsl:template>
</xsl:stylesheet>
O resultado da sua aplicao daria um novo documento XML equivalente ao seguinte:

<?xml version="1.0" encoding="utf-8"?>
<portfolio>
<HHDT oprice="100" cprice="25"/>
<NHSJ oprice="20" cprice="1000"/>
</portfolio>
Note-se que houve uma transformao na estrutura, trocando-se elementos por atributos.
Caso de Estudo
Vamos de seguida analisar alguns exemplos de aplicao de XSLT.
Exemplo 1 Gesto de Actividades ao Ar Livre

Considere-se o seguinte documento XML que descreve um conjunto de actividades desportivas que uma
empresa realiza. Cada actividade descrita com um conjunto de propriedades, desde o tipo de actividade,
monitor responsvel, a data de realizao, etc.





<?xml-stylesheet type="text/xsl" href="bttcaminhadas.xsl"?>
<percursos xmlns:xsi="http://www.w3.org/2000/10/XMLSchema-instance"
146
XSL
Caso de Estudo
xsi:noNamespaceSchemaLocation="percursos.xsd">
<percurso id="1" tipo="caminhada">
<nome>Soajo </nome>
<distancia units="kms"> 8 </distancia>
<dificuldade> 1 </dificuldade>
<epoca>Vero </epoca>
<track tipo="gps"> waypoints_soajo.txt </track>
<responsavel>
<respnome>Ana Silva </respnome>
<contacto>93577969 </contacto>
<email>asilva@activity.com </email>
</responsavel>
</percurso>
<percurso id="2" tipo="btt">
<nome>Muro </nome>
<dificuldade>5 </dificuldade>
<epoca>Todo o ano </epoca>
<track tipo="gps"> waypoints_muro.txt </track>
<responsavel>
<respnome>Ana Silva </respnome>
<email>asilva@activity.com </email>
</responsavel>
</percurso>
<percurso id="2" tipo="btt">
<nome>Viana-Soajo</nome>
<distancia units="kms">75 </distancia>
<track tipo="gps"> waypoints_muro.txt </track>
<responsavel>
<respnome>Lus Ferreira</respnome>
<email>lufer@ipca.pt </email>
</responsavel>
</percurso>
<percurso id="3" tipo="tt">
<nome> Gers </nome>
<dificuldade>2 </dificuldade>
<epoca>Primavera </epoca>
<track tipo="gps"> waypoints_geres.txt </track>
<responsavel>
<respnome>Lus Ferreira</respnome>
<email> lufer@ipca.pt </email>
</responsavel>
</percurso>
<percurso id="1" tipo="caminhada">
<nome>Varzea </nome>
<dificuldade> 3 </dificuldade>
<epoca>Inverno </epoca>
<track tipo="gps"> waypoints_soajo.txt </track>
<responsavel>
<respnome>lufer</respnome>
<email>lufer@activity.com </email>
</responsavel>
</percurso>
</percursos>
Como se pode verficar no incio deste documento, existe uma especificao de regras de validao quer por um
DTD, quer por um XML Schema (no so necessrios os dois, basta um deles!). Apresentmo-los em seguida:
DTD:
147
Caso de Estudo
XSL
<DOCTYPE percursos SYSTEM "percurso.dtd">

<!ELEMENT
<!ELEMENT
<!ATTLIST
<!ELEMENT
<!ELEMENT
<!ELEMENT
<1ATTLIST
<!ELEMENT
<!ELEMENT
<!ELEMENT
<!ATTLIST
<!ELEMENT
<!ELEMENT
<!ELEMENT
percursos (percurso)+>
percurso (nome,distancia,dificuldade,epoca,track,responsavel)>
percurso id CDATA #REQUIRED tipo CDATA #REQUIRED>
responsavel (respnome,contacto,email)>
nome (#PCDATA)>
distancia (#PCDATA)>
distancia units CDATA #REQUIRED>
dificuldade (#PCDATA)>
epoca (#PCDATA)>
track (#PCDATA)>
track tipo CDATA #REQUIRED>
respnome (#PCDATA)
contacto (#PCDATA)>
email (#PCDATA)>
XSD:
<xsd:schema:xsd="http://www.w3.org/2001/XML Schema":elementFromDefault="qualified">
<xsd:element
<xsd:element
<xsd:element
<xsd:element
<xsd:element
<xsd:element
<xsd:element
<xsd:element
<xsd:element
<xsd:element
<xsd:element
name="percursos" type="percursos_type"/>
name:"percurso" type="percurso_type"/>
name="nome" type="xsd:string"/>
name="distancia" type="distancia_type"/>
name="dificuldade" type="xsd:integer"/>
name="epoca" type="xsd:string"/>
name="track" type="track_type"/>
name="responsavel" type="responsavel_type"/>
name="nome" type="xsd:string"/>
name="contacto" type="xsd:string"/>
name="email" type="xsd:string"/>
<xsd:ComplexType name="percursos_type">
<xsd:sequence>
<xsd:element ref="percurso" minOccus="1" maxOccurs="unbounded"/>
</xsd:sequence>
</xsd:compexType>
<xsd:ComplexType name="percurso_type">
<xsd:sequence>
<xsd:element ref="nome"/>
<xsd:element ref="distancia"/>
<xsd:element ref="dificuldade"/>
<xsd:element ref="epoca"/>
<xsd:element ref="track"/>
<xsd:element ref="responsavel"/>
</xsd:sequence>
<xsd:attribute name="id" type="xsd:string" use:"required"/>
<xsd:attribute name="tipo" type="xsd:string" use:"required"/>
</xsd:compexType>
<xsd:ComplexType name="distancia_type">
<xsd:SimpleContent>
<xsd:extension base="xsd:string">
<xsd:attribute name="units" type="xsd:string" use:"required"/>
</xsd:extension base>
</xsd:SimpleContent>
</xsd:ComplexType>
<xsd:ComplexType name="track_type"/>
<xsd:SimpleContent>
<xsd:extension base="xsd:string">
<xsd:attribute name="tipo" type="xsd:string" use:"required"/>
</xsd:extension base>
</xsd:SimpleContent>
</xsd:ComplexType>
<xsd:ComplexType name="responsavel_type"/>
<xsd:sequence>
<xsd:element ref="respnome"/>
<xsd:element ref="contacto"/>
<xsd:element ref="email"/>
148
XSL
Caso de Estudo
</xsd:sequence>
</xsd:ComplexType>
</schema>
Vejamos agora um conjunto de XML StyleSheets e o respectivo resultado da sua aplicao:

percursos .xsl

<xsl:output method="html" encoding="iso-8859-1"/>
<html>
<head >
<link rel="stylesheet" type="text/css" href="show.css"/>
<title>Actividades></title>
</head>
<body class="bodyContent">
<table class="content" width="600" border="1" align="center" cellspacing="0"
cellpadding="0">
<tr><td colspan="5" class="BlueWho"><b>ACTIVIDADES</b></td></tr>
<tr>
<td bgcolor="yellow" class="BlueWho"><b>Actividade</b></td>
<td bgcolor="yellow" class="BlueWho"><b>Distncia</b></td>
<td bgcolor="yellow" class="BlueWho"><b>Dificuldade</b></td>
<td bgcolor="yellow" class="BlueWho"><b>poca</b></td>
<td bgcolor="yellow" class="BlueWho"><b>Responsavel</b></td>
</tr>
<tr>
<td colspan="5" class="BlueWho"><b>Todo o Terreno</b></td>
</tr>
<xsl:for-each select="percursos/percurso[@tipo='tt']">
<tr>
<td class="BlueWho"><xsl:value-of select="distancia"/> <xsl:value-of
<xsl:choose>
<xsl:when test="dificuldade =2">Mdia</xsl:when>
</xsl:choose>
</td>
</td>
</tr>
</xsl:for-each>
<tr>
<td colspan="5" class="BlueWho"><b>Caminhadas</b></td>
</tr>
<tr>
<xsl:choose>
</xsl:choose>
</td>
149
Caso de Estudo
XSL
</td>
</tr>
</xsl:for-each>
<tr>
<td colspan="5" class="BlueWho"><b>BTT</b></td>
</tr>
<tr>
<xsl:choose>
</xsl:choose>
</td>
</td>
</tr>
</xsl:for-each>
</table>
</body>
</html>
</xsl:template>
</xsl:stylesheet>
Trata-se de uma listagem geral de todas as actividades, agrupadas por Tipo de actividade e apresentadas com
recurso a uma CSS. O resultadoa da sua aplicao seria:
Figura 31 Caso de Estudo: Resultado da aplicao de percursos.xsl
Considere-se agora uma outra XML StyleSheet que pretende identificar somente as actividades, sem qualquer
tratamento nem mesmo agrupamento.
150
XSL
Caso de Estudo
todospercursos.xsl
<xsl:stylesheet xmlns:xsl="http://www.w3.org/1999/XSL/Transform" version="1.0">
<xsl:output method="html" omit-xml-declaration="yes"/>
<HTML>
<BODY class="content">
<TABLE BORDER="1">
<TR>
<TD><b>Nome</b></TD>
<TD><b>Distancia</b></TD>
<TD><b>Dificuldade</b></TD>
<TD><b>Tipo</b></TD>
<TD><b>Epoca - <xsl:value-of
select="/percursos/percurso[0]/distancia"/></b></TD>
</TR>
<xsl:for-each select="percursos/percurso">
<TR>
<TD><xsl:value-of select="nome"/></TD>
<TD><xsl:value-of select="distancia"/><xsl:value-of
select="@units"/></TD>
<TD><xsl:value-of select="dificuldade"/></TD>
<TD><xsl:value-of select="@tipo"/></TD>
<TD><xsl:value-of select="epoca"/></TD>
</TR>
</xsl:for-each>
</TABLE>
</BODY>
</HTML>
</xsl:template>
</xsl:stylesheet>
Figura 32 - Caso de Estudo: Resultado da aplicao de todospercursos.xsl
Vejamos agora uma outra XML StyleSheet que pretende identificar somente as actividades de um determinado
tipo, neste caso Caminhadas.
percursoscaminhadas.xsl
<xsl:stylesheet xmlns:xsl="http://www.w3.org/1999/XSL/Transform" version="1.0">
<xsl:output method="html" omit-xml-declaration="yes"/>
<HTML>
<TABLE BORDER="1">
<TR>
<TD><b>Nome</b></TD>
151
Caso de Estudo
XSL
<TD><b>Distancia</b></TD>
<TD><b>Dificuldade</b></TD>
<TD><b>Tipo</b></TD>
<TD><b>Epoca</b></TD>
</TR>
<TR>
<TD><xsl:value-of select="nome"/></TD>
<TD><xsl:value-of select="distancia"/><xsl:value-of
select="@units"/></TD>
<TD><xsl:value-of select="dificuldade"/></TD>
<TD><xsl:value-of select="@tipo"/></TD>
<TD><xsl:value-of select="epoca"/></TD>
</TR>
</xsl:for-each>
<TR>
<TD>Distncia total: <xsl:value-of
select="sum(percursos/percurso[@tipo='caminhada']/distancia)"/></TD>
</TR>
</TABLE>
</BODY>
</HTML>
</xsl:template>
</xsl:stylesheet>
Figura 33 - Caso de Estudo: Resultado da aplicao de percursoscaminhadas.xsl

Repare-se que apresentado no final o total de kilmetros a percorrer em todas as caminhadas.
Vejamos agora uma outra XML StyleSheet que pretende identificar somente as distncias de um conjunto de
actividades. Neste caso Caminhadas e BTT.
bttcaminhadas.xsl
<xsl:stylesheet xmlns:xsl="http://www.w3.org/TR/WD-xsl">
<HTML>
<TABLE BORDER="1">
<TR><td><b>Distncias</b></td></TR>
<TR><td><b>Caminhadas:</b></td></TR>
<TR>
<TD><xsl:value-of select="distancia"/> <xsl:value-of
select="distancia/@units"/></TD>
</TR>
</xsl:for-each>
<TR><td><b>BTT:</b></td></TR>
<TR>
<TD><xsl:value-of select="distancia"/> <xsl:value-of
select="distancia/@units"/></TD>
</TR>
</xsl:for-each>
152
XSL
Caso de Estudo
</TABLE>
</BODY>
</HTML>
</xsl:template>
</xsl:stylesheet>
Cujo resultado da sua aplicao seria:
Figura 34 - Caso de Estudo: Resultado da aplicao de bttcaminhadas.xsl
Em jeito de comentrio final deste Caso de Estudo, anotar que neste caso de estudo se pode constatar que
possvel, facilmente, redefinir a forma e formato com que se pretende apresentar os dados (neste caso em
formato XML), sem contudo os ter que alterar. Esta uma particularidade da tecnologia XML/XSLT.
153
XML
Concluso
Concluso
A elaborao deste documento pretendeu acima de tudo expor o que de mais relevante existe volta da
tecnologia XML. Viu-se que essencial saber como escrever correctamente um documento XML; essencial
definir mecanismos que validem essa escrita, tanto em regras sintticas como de estrutura e contedo.
Falamos ento de DTD e XML Schemas. Viu-se tambm que qualquer documento XML armazenado numa
estrutura de dados tipo rvore invertida e sobre a qual necessrio e possvel intervir com operaes do tipo,
alterar posies de elementos, alterar contedos, inserir ou remover elementos, atributos ou contedos, etc.
Aqui aplicavam-se regras XPAth que garante que todos os processos de navegao e interveno na referida
rvore sejam feitos segundo regras bem definidas.
Por fim, analisou-se com detalhe operaes de transformao sobre documentos XML, desde filtragem de
informao at converso dos dados originais em qualque outro formato pretendido. Analisamos para isso o
XML StyleSheet Transformation XSLT, uma parte do XSL.
Procurou-se desde o incio apoiar todas as explanaes com recurso a exemplos prticos, simples e objectivos.
Restou o facto de no ter sido abordado a forma como uma rvore XML pode ser manipulada em memria
atravs de DOM (ou eventuamente SAX) mas que se recomenda a sua anlise. Vrias tecnologias Web como o
Javascript, AJAX, etc., lidam necessariamente com DOM. A Sebenta da disciplina de Programao para a Web
aborda com mais detalhe esta temtica. Recomenda-se por isso a sua consulta.
155
XML
Bibliografia
Bibliografia
Livros e Outros
Beginning XSLT 2.0: : From Novice to Professional, Jeni Tennison, Apress, 2005
XSLT and XPath On The Edge, Jeni Tennison, John Wiley & Sons, 2001
XML Professional Skills Development, Application Developers Training Company and AppDev
Products Company, 2008
Sebenta da disciplina de Programao Web, Lus Ferreira, 2008
Sebenta da disciplina de Integrao de Sistemas de Informao, Lus Ferreira, 2009
Revistas
XML Developer. Pinnacle Publishing, http://www.pinnaclepublishing.com
XML Magazine. Fawcette Technical Publications, http://www.xmlmag.com
Web sites
http://www.jenitennison.com/xslt/index.html
W3C: http://www.w3.org
http://www.dpawson.co.uk/xsl/xslfaq.html
XSL-List: http://www.mulberrytech.com/xsl/xsl-list/index.html
VBXML: http://www.vbxml.com
Unofficial MSXML XSLT FAQ: http://www.netcrucible.com/xslt/msxmlfaq.htm
Jeni Tennisons XML site: http://www.jenitennison.com
XPath Quick Reference - http://www.stylusstudio.com/docs/v60/d_xpath86.html#wp919260
157
XML
ANEXO
ANEXO
Expresses Regulares em XML Schemas

Como vimos anteriormente o XML Schema recorre utilizao de Expresses Regulares na definio dos
padres na faceta xsd:pattern. (pgina 40) dos SimpleTypes. Tambm referimos que as expresses regulares
utilizadas so idnticas s utilizadas na linguagem Perl 16,1718, embora aqui sejam bem mais limitadas e aplicadas
a todo o contedo do documento XML e no somente restrito a determinado pargrafo ou linha. Isto explica a
no existncia dos meta-caracteres ^ (como incio de linha) e $ (como fim de linha) como acontece em Perl. O
meta-caractere ^ contudo utilizado na definio de excepes tipo [^0-9] (excepto dgitos).
As Expresses Regulares so tambm utilizadas em XPath e XQuery, temticas a explorar na terceira parte
desta sebenta.
Em XML Schema, as Expresses Regulares suportam:
Classes de caracteres
Subtraco de Classes de caracteres
Agrupamentos
Alternncia
Ocorrncias
Classes de caracteres
Classe
Descrio
Alternativa
\d
dgitos
[0-9]
\w
caracteres de texto
[a-zA-Z0-9_]
\s
espao, tab ou line break
\D
negar \d
[^\d]
\S
negar \s
[^\s]
16
http://www.perldoc.com/perl5.6/pod/perlre.html
Recomenda-se a consulta da Sebenta da disciplina de ISI (2009)
18
Consultar tambm http://www.regular-expressions.info/xml.html
17
159
ANEXO
XML
\W
negar \w
[^\w]
\i
qualquer carcter inicial de um nome XML
[_:A-Za-z]
\c
qualquer caractere que possa seguir o primeiro
[-._:A-Za-z0-9]
caractere de um nome XML

\C e \I
.
negao de \c e \i
qualquer caractere excepto o new line
\b
encontra separadores de palavras (espaos, etc.)
\B
encontra tudo menos separadores de palavras
Exemplos:
\i\c*
- encontra nomes do gnero xml:schema
<\i\c*\s*>
- encontra uma tag XML de abertura sem atributos
</\i\c*\s*>
- encontra qualquer tag XML de encerramento
<\i\c*(\s+\i\c*\s*=\s*("[^"]*"|'[^']*'))*\s*>
- encontra uma tag XML de abertura com atributos
Subtraco de Classes de caracteres

Permite encontrar determinado caractere que se encontra numa classe e no se encontra noutra. A sintaxe :
[class-[subtract]]
Exemplo:
[a-z-[aeiuo]]
- encontra toda as consoantes (no vogais)
[0-9-[0-6-[0-3]]] - encontra os dgitos 0-3 e 7-9
Alternncia
Permite especificar um conjunto de valores a pesquisar. A sintaxe :
exp1 | exp2 | exp3 | | expn
160
XSL
ANEXO
Exemplo:
Dia|Day
- encontra as palavras Dia ou Day
Agrupamentos
Permite especificar ocorrncias num conjunto de expresses regulares. Sobre elas possvel aplicar operadores
de repetio.
Ocorrncias
Permite especificar a repetio (ou quantificar) pretendida sobre determinada expresso regular.
Quantificador
*
+
?
{n}
{n,}
{n,m}
Descrio
Zero ou mais vezes.
Uma ou mais vezes.
Opcional, ie, zero ou uma vez.
Ocorrer exactamente n vezes
Ocorre pelo menos n vezes
Ocorre pelo menos n vezes e no mais do que m vezes.
Exemplos:
<[A-Za-z][A-Za-z0-9]*>
- encontra tags HTML sem atributos
(AB)+C
- encontra expresses tipo ABC ou ABABC ou ABABABC
{0,}
- o mesmo que *
{1,}
- o mesmo que +
\b[1-9][0-9]{3}\b
- encontra um nmero entre 1000 e 9999
Nov(embro)?
- encontra as palavras Nov e Novembro
Exemplos
161
ANEXO
XML
Expresso
Encontra
Chapter \d
Chapter 0, Chapter 1, Chapter 2 ....
Chapter\s\d
Chapter seguido de caractere em branco (espao, tab, newline, etc.), seguido de um dgito
Chapter\s\w
Chapter seguido de caractere em branco (espao, tab, newline, etc.), seguido de um caractere
palavra (XML 1.0 Letter or Digit)
Española
Espaola
a*x
x, ax, aax, aaax ....
a?x
ax, x
a+x
ax, aax, aaax ....
(a|b)+x
ax, bx, aax, abx, bax, bbx, aaax, aabx, abax, abbx, baax, babx, bbax, bbbx, aaaax ....
[abcde]x
ax, bx, cx, dx, ex
[a-e]x
ax, bx, cx, dx, ex
[\-ae]x
-x, ax, ex
[ae\-]x
ax, ex, -x
[^0-9]x
Qualquer caractere no digito seguido da letra x
\Dx
Qualquer caractere no digito seguido da letra x
.x
qualquer caracteres seguido da letra x
.*abc.*
1x2abc, abc1x2, z3456abcblablabla ....
ab{2}x
abbx
ab{2,4}x
abbx, abbbx, abbbbx
ab{2,}x
abbx, abbbx, abbbbx ....
(ab){2}x
ababx
162

Sebenta XML 2015

Enviado por

Dados do documento

Descrição original:

Título original

Direitos autorais

Formatos disponíveis

Compartilhar este documento

Compartilhar ou incorporar documento

Opções de compartilhamento

Você considera este documento útil?

Este conteúdo é inapropriado?

Direitos autorais:

Formatos disponíveis

Sebenta XML 2015

Enviado por

Direitos autorais:

Formatos disponíveis

Tecnologia XML

Lus Ferreira - IPCA-EST 2014

PARTE I XML E DTD

Lus Ferreira - IPCA-EST 2014

Exerccios resolvidos .......................................................................................................................................29

PARTE III - XSL

Lus Ferreira - IPCA-EST 2014

Lus Ferreira - IPCA-EST 2014

PARTE IV XSL APLICADO

Exemplos ..................................................................................................................................................... 161

Lus Ferreira - IPCA-EST 2014

Figura 26 - Livro em HTML ................................................................................................................................... 135

Lus Ferreira - IPCA-EST 2014

Lus Ferreira - IPCA-EST 2014

Primeiros passos nos anos 60 (GML - Generalized Markup Language)

Desde 1996 - Chama-se Extensible Markup Language (XML)

Pontos fortes do XML

Simplicidade: o XML simples. O XML vai directo ao contexto.

Objectivos no desenvolvimento do XML

Teria que ser fcil usar o XML na Internet;

O XML deveria suportar uma grande variedade de aplicaes;

O XML deveria ser compatvel com SGML;

Deveria ser fcil escrever programas que processem documentos XML;

O projecto XML deveria ser preparado rapidamente;

Lus Ferreira - IPCA-EST 2014

Estrutura de um documento XML

O projecto XML deveria ser formal e conciso;

Os documentos XML deveriam ser fceis de serem criados;

A conciso na marcao em XML de mnima importncia.

Como definido o XML?

Extensible Markup Language (XML) 1.0: define a sintaxe do XML;

Estrutura de um documento XML

Lus Ferreira - IPCA-EST 2014

Estrutura de um documento XML

Figura 1 - Hierarquia num documento XML

Lus Ferreira - IPCA-EST 2014

Estrutura de um documento XML

<trilho id=1>Soajo Castrejo </trilho>

Lus Ferreira - IPCA-EST 2014

Estrutura de um documento XML

referncia a um caracter em decimal

referncia a um caracter em hexadecimal

Processing Instructions (PI)

Declarao XML ou Prolog

(tecnicamente designado por Prolog) uma PI para informao importante sobre o

Estrutura de um documento XML

parmetro version (verso do XML)

parmetro opcional encoding (esquema de codificao de caracteres Portugus: iso-8859-1 )

parmetro optional standalone (No caso exista um conjunto externo de definies)

<!ENTITY html Hypertext Markup Language>

Lus Ferreira - IPCA-EST 2014

Estrutura de um documento XML

Visualizao de um documento XML

Cuja representao num browser resulta no seguinte aspecto:

Lus Ferreira - IPCA-EST 2014

Estrutura de um documento XML

O mesmo documento em XML poderia ser descrito da seguinte forma:

Cuja representao num browser resultaria no seguinte:

Lus Ferreira - IPCA-EST 2014

Definies de Tipos de Documentos (DTD)

Definies de Tipos de Documentos (DTD)

Lus Ferreira - IPCA-EST 2014