W3C

XSL Dönüşümleri (XSLT) Sürüm 1.0

W3C Önergesi 16 Kasım 1999

Bu sürüm:
http://www.w3.org/TR/1999/REC-xslt-19991116
(XML ve HTML biçimleri mevcuttur.)
Son sürüm:
http://www.w3.org/TR/xslt
Önceki Sürümler:
http://www.w3.org/TR/1999/PR-xslt-19991008
http://www.w3.org/1999/08/WD-xslt-19990813
http://www.w3.org/1999/07/WD-xslt-19990709
http://www.w3.org/TR/1999/WD-xslt-19990421
http://www.w3.org/TR/1998/WD-xsl-19981216
http://www.w3.org/TR/1998/WD-xsl-19980818
Yayına hazırlayan:
James Clark <[email protected]>

Bu çeviri:
Tek sayfalık HTML, çok sayfalı HTML ve XML biçimleri mevcuttur.
Çeviren:
Nilgün Belma Bugüner <>, 25 Haziran 2007

Bu çeviri de diğer belirtim çevirileri gibi bilgilendirici mahiyettedir, hiçbir bağlamda belirleyici değildir. Bu belge anadili Türkçe olan Genel ağ kullanıcılarının bu belirtim hakkında fikir edinebilmelerini sağlamak amacıyla Türkçeye çevrilmiştir. Bu belirtimin belirleyici tek sürümü W3C tarafından yayımlanan İngilizce sürümüdür.


Özet

Bu belirtim, XML belgeleri başka XML belgelere dönüştürmekte kullanılan bir dil olan XSLT'nin sözdizimini ve anlamlandırmasını tanımlar.

XSLT, XML için bir biçembent (İng: stylesheet) dili olan XSL'nin bir parçası olarak kullanılmak üzere tasarlanmıştır. XSL, biçimleme belirtmek için XSLT'ye ilaveten bir XML söz varlığına sahiptir. XSL, bir XML belgenin, biçimleme söz varlığını kullanan başka bir XML belgeye nasıl dönüştürüleceğini açıklayan XSLT'yi kullanarak XML belgenin biçemini belirtir.

XSLT, ayrıca, XSL'den bağımsız olarak kullanmak için de tasarlanmışsa da bir genel amaçlı XML dönüşüm dili olarak düşünülmemiştir. Daha çok, asıl olarak XSLT XSL'nin parçası olarak kullanıldığında gereken dönüşüm çeşitleri için tasarlanmıştır.

Belgenin Durumu

Bu belge W3C üyeleri ve diğer ilgili taraflarca gözden geçirilmiş ve W3C Yönetimi tarafından bir W3C Önergesi olarak onaylanmıştır. Kararlı bir belge olup başka belgelerden uyulması gerekli bir kaynak olarak atıfta bulunarak veya bir başvuru malzemesi olarak kullanılabilir. W3C'nin Önergedeki rolü, belirtime dikkatleri çekmek ve geniş bir alanda kullanımını yaygınlaştırmaktır. Bu, Web'in işlevselliğini ve birlikte çalışabilirliğini arttırmaktadır.

Bu belgede tespit edilmiş hatalar http://www.w3.org/1999/11/REC-xslt-19991116-errata adresinde listelenmiştir. Bunlardan 2 Kasım 2005'e (E39'a) kadar bilinen hatalarla ilgili değişiklikler çeviriye yansıtılmıştır.

Bu belirtimle ilgili yorumlar [email protected] adresine gönderilebilir; yorum arşivleri de mevcuttur. XSL'nin, XSLT'yi de içererek halka açık tartışma alanı olarak XSL-List eposta listesi vardır.

Bu belirtimin İngilizce sürümü uyulması gerekli tek sürümdür. Bununla birlikte bu belgenin (bilgilendirici mahiyette) çevirileri de mevcuttur.

W3C Önergelerinin ve diğer teknik belgelerinin bir listesi http://www.w3.org/TR adresinde bulunabilir.

Bu belirtim W3C Biçem etkinliğinin bir parçası olarak üretilmiştir.

İçindekiler

1 Giriş
2 Biçembent Yapısı
    2.1 XSLT İsim-alanı
    2.2 stylesheet Elemanı
    2.3 Birebir Hedef Eleman olarak Biçembent
    2.4 Nitelikli Adlar
    2.5 İleriye Uyumlu İşlem
    2.6 Biçembentlerin Birleştirilmesi
          2.6.1 Biçembentlerin İçerilmesi
          2.6.2 Biçembent İthali
    2.7 Gömülü Biçembentler
3 Veri Modeli
    3.1 Kök Düğümün Çocukları
    3.2 Temel Tanım-yeri
    3.3 Çözümlenmemiş Öğeler
    3.4 Boşluk Ayıklama
    3.5 XML Sürümü
4 İfadeler
5 Örneklenim Kuralları
    5.1 İşlem Modeli
    5.2 Örüntüler
    5.3 Örneklenim Kurallarının Tanımlanması
    5.4 Örneklenim Kurallarının Uygulanması
    5.5 Şablon Kuralları için Uyuşmazlıkların Çözümlenmesi
    5.6 Örneklenim Kurallarının Geçerli Kılınması
    5.7 Kipler
    5.8 Yerleşik Örneklenim Kuralları
6 İsimli Örneklenimler
7 Hedef Ağacın Oluşturulması
    7.1 Elemanların ve Özniteliklerin Oluşturulması
          7.1.1 Birebir Hedef Elemanlar
          7.1.2 Elemanların xsl:element ile Oluşturulması
          7.1.3 Özniteliklerin xsl:attribute ile Oluşturulması
          7.1.4 İsimli Öznitelik Kümeleri
    7.2 Metin Oluşturma
    7.3 İşlem Yönergelerinin Oluşturulması
    7.4 Açıklamaların Oluşturulması
    7.5 Kopyalama
    7.6 Üretilen Metnin Hesaplanması
          7.6.1 Metnin xsl:value-of ile Üretilmesi
          7.6.2 Öznitelik Değeri Örneklenimleri
    7.7 Numaralama
          7.7.1 Sayıdan Dizgeye Dönüşüm Öznitelikleri
8 Yineleme
9 Koşullu İşlem
    9.1 xsl:if ile Koşullu İşlem
    9.2 xsl:choose ile Koşullu İşlem
10 Sıralama
11 Değişkenler ve Değergeçler
    11.1 Hedef Ağaç Bölümleri
    11.2 Değişken ve Değergeçlerin Değerleri
    11.3 Değişken ve Değergeçlerin Değerlerinin xsl:copy-of ile Kullanımı
    11.4 Tepe-Seviyeden Değişkenler ve Değergeçler
    11.5 Örneklenimlerin içinde Değişkenler ve Değergeçler
    11.6 Değergeçlerin Örneklenimlere Aktarılması
12 Ek İşlevler
    12.1 Çok Kaynaklı Belgeler
    12.2 Anahtarlar
    12.3 Sayı Biçimleme
    12.4 Çeşitli Ek İşlevler
13 İletiler
14 Eklentiler
    14.1 Eklenti Elemanlar
    14.2 Eklenti İşlevler
15 Son Çare
16 Çıktı
    16.1 XML Çıktılama Yöntemi
    16.2 HTML Çıktılama Yöntemi
    16.3 Metin Çıktılama Yöntemi
    16.4 Çıktı Önceleniminin İptal Edilmesi
17 Uyumluluk
18 Gösterim

Ekler

A Kaynakça
    A.1 Uyulması Gerekenler
    A.2 Diğerleri
B Elemanların Özet Sözdizimleri
C XSLT Biçembentlerinde DTD Bölümü (Bilgilendirici)
D Örnekler (Bilgilendirici)
    D.1 Belge Örneği
    D.2 Veri Örneği
E Teşekkür (Bilgilendirici)
F Önerge Adaylığından beri Değişenler (Bilgilendirici)
G XSLT'nin gelecek sümlerinde ele alınacak özellikler (Bilgilendirici)


1 Giriş

Bu belirtim, XSLT dilinin sözdizimini ve anlamlandırmasını tanımlar. XSLT dilinde bir dönüşüm, XSLT tarafından tanımlanmış olsun olmasın bütün elemanları içererek, [XML Adları] veya [XML Adları 1.1] İsim-alanları Önergesine uygun ve iyi biçimlenmiş bir [XML] veya [XML 1.1] belge olarak ifadesini bulur. Kolaylık olsun diye, XML 1.0 ve XML Adları 1.0 Önergelerine atıf yapılmıştır. Bu bakımdan, tek biçimli tanım-yeri başvuruları kullanılmışsa da uluslararası tanım-yeri başvuruları da ayrıca desteklenebilir. Bazı durumlarda XML 1.0 ve XML 1.1 tanımları tamamen aynı olabilir. XSLT tarafından tanımlanmış elemanlar belli bir XML isim-alanına karşılık olmakla diğerlerinden ayrılırlar (bkz, XSLT İsim-alanı); bu belirtimde bu isim-alanından XSLT isim-alanı olarak bahsedilecektir. Bu belirtim aynı zamanda, XSLT isim-alanı sözdiziminin ve anlamlandırmasının bir tanımıdır.

XSLT'de ifadesini bulan bir dönüşüm, bir kaynak ağacı bir hedef ağaca dönüştürecek kuralları açıklar. Dönüşüm, örüntüler örneklerle ilişkilendirilerek elde edilir. Bir örüntü kaynak ağacındaki elemanlarla eşleşirken, bir örnek hedef ağacın elemanlarını oluşturur. Hedef ağaç, kaynak ağaçtan ayrıdır. Hedef ağacın yapısı kaynak ağacın yapısından tamamen farklı olabilir. Hedef ağaç oluşturulurken, kaynak ağaçtaki elemanlar süzülebilir, yeni bir sırayla dizilebilir ve hatta ağaca tamamen keyfi bir yapı eklenebilir.

XSLT'de ifadesini bulan dönüşüme biçembent (İng: stylesheet) denir. Çünkü, XSLT'nin XSL biçimleme söz varlığına dönüştüğü durumda dönüşüm bir biçembent (biçem demeti) olarak iş görür.

Bu belge bir XSLT biçembendinin bir XML belgesi ile nasıl ilişkilendirileceğini açıklamaz. XSL işlemcilerinin [XML Stylesheet]'te açıklanan mekanizmayı desteklemeleri önerilir. Bu veya herhangi bir başka mekanizma, bir XML belgeye aynı anda uygulanacak bir XSLT biçembent silsilesinden oluştuğunda, etkisi, silsileyi oluşturan üyeleri aynı sırayla içeren (bkz, Biçembent İthali) tek bir biçembendin uygulanmasına eşit olmalıdır.

Bir biçembent, örneklenim kurallarından oluşan bir küme içerir. Bir örneklenim kuralı iki parçadan oluşur: kaynak ağacındaki düğümlere karşılık olan bir örüntü ve hedef ağacın biçimlenecek parçasının biçimleme örneğini içeren bir örneklenim (İng: template). Bu, bir biçembendin kaynak ağaç yapıları birbirine benzeyen geniş bir belge sınıfına uygulanabilmesini mümkün kılar.

Bir örneklenim, hedef ağacın bir bölümünü oluşturacak belli bir kaynak eleman için bir örneklenimdir. Bir örneklenim, hedef eleman yapısını birebir belirten elemanlar içerebileceği gibi, hedef ağaç yapısını oluşturacak yönergeler olarak XSLT isim-alanındaki elemanları da içerebilir. Bir örneklenim işleme sokulduğunda, içerdiği her yönerge yorumlanır ve oluşturacağı hedef ağaç bölümüyle değiştirilir. Yönergeler astsal kaynak elemanlarını seçebilir ve işleyebilir. Bir astsal elemanın işlenmesi, uygun örneklenim kuralının bulunması ve bu kuraldaki örneklenimin işleme sokularak hedef ağacın bir bölümünün oluşturulması anlamına gelir. Elemanların sadece bir yönergenin yorumlanmasıyla seçildikleri takdirde işleme sokulabileceğine dikkat ediniz. Hedef ağaç, kök düğümü için hazırlanmış örneklenim kuralı bulunup onun örneklenimi işleme sokularak oluşturulur.

Uygun örneklenim kuralını bulma işleminde, birden fazla örneklenim kuralı belirtilen elemanla eşleşen örüntüye sahip olabilir. Ancak, sadece bir örneklenim kuralı uygulanacaktır. Hangi örneklenim kuralının uygulanacağına karar verme yöntemi Şablon Kuralları için Uyuşmazlıkların Çözümlenmesi bölümünde açıklanmıştır.

Bir örneklenim tek başına oldukça güçlü sayılır: az veya çok karmaşıklıkta yapılar oluşturabilir; kaynak ağacın çeşitli yerlerindeki dizge değerlerini çekip çıkarabilir; elemanların kaynak ağaçta yer alışlarına bağlı olarak yinelenen yapılar üretebilir. Basit dönüşümler bakımından, hedef ağacın yapısı kaynak ağacın yapısından bağımsız olduğunda, bir biçembent çoğunlukla kaynak ağacın tamamı için işlem yapan tek bir örneklenimden meydana gelir. İçeriği verilerden oluşan XML belgeler üzerindeki dönüşümler çoğunlukla bu türdendir (bkz, Veri Örneği). XSLT bu tür biçembentler için basitleştirilmiş bir sözdizimi sağlar (bkz, Birebir Hedef Eleman olarak Biçembent).

Bir örneklenim işleme sokulduğunda daima bir geçerli düğüm ve bir geçerli düğüm listesi ile ilgili olarak işlem yapar. Geçerli düğüm daima geçerli düğüm listesinin bir üyesidir. XSLT'deki işlemlerin çoğu geçerli düğüme göredir. Pek az yönerge geçerli düğüm listesini veya geçerli düğümü değiştirir (bkz, Örneklenim Kuralları ve Yineleme); bu yönergeler işlem yaptığı sırada, geçerli düğüm listesi yerini yeni düğüm listesine bırakır; yani yeni listenin her üyesi geçerli düğüm haline gelir; yönergenin işi bittiğinde geçerli düğüm listesi veya geçerli düğüm tekrar yönerge öncesinde geçerli olan düğüm listesi ve düğüm olur.

XSLT metin üretmek ve koşullu işlemler için eleman seçerken [XPath] tarafından tanımlanmış ifade dilini kullanır.

XSLT, dili genişletmek için kullanıcı tarafından değiştirilerek kullanılmak üzere iki özellik sağlar, biri örneklenimlerde kullanılan yönerge elemanları kümesini, diğeri XPath ifadelerinde kullanılan işlev kümesini genişletir. Bu özelliklerin her ikisi de XML isim-alanlarına dayandırılmıştır. XSLT'nin bu sürümü bu özellikleri gerçeklemek için bir mekanizma tanımlamamıştır (bkz, Eklentiler).

Not:
XSL Çalışma Grubu böyle bir mekanizmayı bu belirtimin ileriki sürümlerinde veya ayrı bir belirtimde tanımlamayı düşünmektedir.

XSLT tarafından tanımlanmış elemanların sözdizimlerini belirleyen eleman sözdizimi gösterim özeti Gösterim bölümünde açıklanmıştır.

XSLT biçembentleri için MIME ortam türleri olarak text/xml ve application/xml [RFC2376] kullanılmalıdır. Özellikle XSLT biçembentleri için kayda geçirilmiş bir ortam türü olduğunda, bu ortam türü de kullanılabilir.

2 Biçembent Yapısı

2.1 XSLT İsim-alanı

XSLT isim-alanı tanımı http://www.w3.org/1999/XSL/Transformadresinde bulunmaktadır.

Not:
Adresin içindeki 1999 ibaresi, bu tanım-yerinin (URI) W3C tarafından tahsis edildiği yılı belirtir. XSLT'nin kullanılmakta olan sürümünü göstermez (kullanılmakta olan XSLT sürümü özniteliklerle belirtilir (bkz, stylesheet Elemanı ve Birebir Hedef Eleman olarak Biçembent).

XSLT işlemcileri bu isim-alanındaki elemanları ve öznitelikleri tanımak için XML isim-alanları mekanizmasını [XML Adları] kullanmalıdır. XSLT isim-alanındaki elemanlar sadece biçembent içinde tanınırlar, kaynak belge içinde tanınmazlar. XSLT tarafından tanımlanmış elemanların tam listesi Elemanların Özet Sözdizimleri bölümündedir. Üreticiler XSLT isim-alanını yeni elemanlar ve öznitelikler ekleyerek genişletmemelidirler. Böyle bir genişletme yapılacaksa, bu ayrı bir isim-alanında yapılmalıdır. Ek yönerge elemanları için kullanılacak bir isim-alanı Eklenti Elemanlar bölümünde belirtilmiş olan eleman ekleme mekanizmasına göre tanımlanmalıdır.

Bu belirtimde, XSLT isim-alanındaki elemanlara atıfta bulunmak için xsl: öneki kullanılmıştır. Ancak, XSLT biçembentleri, XSLT isim-alanının tanım-yerine (URI) önek belirten bir isim-alanı bildirimi yaparak başka bir önek kullanmakta özgürdürler.

XSLT isim-alanındaki bir eleman XSLT isim-alanında bulunmayan bir özniteliği, boş olmayan bir isim-alanı tanım-yerine sahip öznitelik genişletilmiş ismi belirterek içerebilir. Böyle özniteliklerin varlığı, XSLT elemanlarının ve işlevlerinin bu belgede tanımlanmış davranışını değiştirmemelidir. Bu bakımdan, bir XSLT işlemci böyle öznitelikleri yoksaymakta daima özgürdür ve isim-alanı tanım-yerini bulamıyorsa bunları bir hata vermeksizin yoksaymalıdır. Bu tür özniteliklerle, örneğin, eşsiz tanıtıcılar, eniyileme ipuçları veya belgeleme içerilebilir.

XSLT isim-alanından bir eleman için, bu belgede o eleman için tanımlananlardan başka, boş isim-alanı tanım-yeri belirten genişletilmiş isimli özniteliklere sahip olmak bir hatadır.

Not:
XSLT eleman, öznitelik ve işlev isimleri için kullanılmakta olan uzlaşımlar şunlardır: isimler küçük harflerden oluşur, sözcükleri ayırmak için tire imleri ve XML veya HTML gibi alakalı bir dilin sözdiziminde yeralmak kaydıyla kısaltmalar kullanılabilir.

2.2 stylesheet Elemanı

<xsl:stylesheet
  id = id
  extension-element-prefixes = dizgecikler
  exclude-result-prefixes = dizgecikler
  version = sayı >
  <!-- İçeriği: (<xsl:import>*, tepe-seviyeden-elemanlar) -->
</xsl:stylesheet>
eleman
<xsl:transform
  id = id
  extension-element-prefixes = dizgecikler
  exclude-result-prefixes = dizgecikler
  version = sayı >
  <!-- İçeriği: (<xsl:import>*, tepe-seviyeden-elemanlar) -->
</xsl:transform>
eleman

Bir biçembent, bir XML belgede bir xsl:stylesheet elemanı tarafından ifade edilir. xsl:transform elemanı xsl:stylesheet elemanının yerine (eşanlamlı) kullanmak içindir.

Bir xsl:stylesheet elemanı, biçembendin gerekirdiği XSLT sürümünün belirtildiği bir version özniteliğine sahip olmak zorundadır ve XSLT'nin bu sürümü için değeri 1.0 olmalıdır. Değer 1.0 olmadığı takdirde, ileriye uyumlu işlem kipi etkin olur (bkz, İleriye Uyumlu İşlem).

xsl:stylesheet elemanı şu elemanları içerebilir:

Bir xsl:stylesheet elemanının çocuğu olan bir elemana tepe-seviyeden eleman denir.

Bu örnekte bir biçembendin yapısı gösterilmiştir. Üç nokta imleri (...) içeriği veya öznitelik değerini betimler. Bu örnek olası elemanların her birinden sadece bir tane içeriyorsa da biçembentler bu elemanların birden fazlasını içerebileceği gibi hiç içermeyebilir de.

<xsl:stylesheet version="1.0"
                xmlns:xsl="http://www.w3.org/1999/XSL/Transform">
  <xsl:import href="..."/>

  <xsl:include href="..."/>

  <xsl:strip-space elements="..."/>

  <xsl:preserve-space elements="..."/>

  <xsl:output method="..."/>

  <xsl:key name="..." match="..." use="..."/>

  <xsl:decimal-format name="..."/>

  <xsl:namespace-alias stylesheet-prefix="..." result-prefix="..."/>

  <xsl:attribute-set name="...">
    ...
  </xsl:attribute-set>

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

  <xsl:param name="...">...</xsl:param>

  <xsl:template match="...">
    ...
  </xsl:template>

  <xsl:template name="...">
    ...
  </xsl:template>

</xsl:stylesheet>

xsl:stylesheetelemanının çocuklarının yer alış sırası hata takibi ve xsl:import elemanları dışında önemsizdir. Kullanıcılar elemanları istedikleri sırada kullanmakta özgürdürler ve biçembent oluşturma araçları, elemanların yer alış sırası üzerinde bir denetime sahip olmamalıdır.

Bundan başka, xsl:stylesheet elemanı XSLT isim-alanında bulunmayan elemanlar (isim-alanının tanım-yerine (URI) önek belirten bir isim-alanı bildirimi yaparak ve bu öneki isminde içererek) içerebilir. Bu tür üst seviyeden elemanların varlığı, XSLT elemanlarının ve işlevlerinin bu belgede tanımlanmış davranışını değiştirmemelidir; örneğin, çelişkileri çözümlemede farklı kuralların kullanıldığı xsl:apply-templates'ler belirten bu türden bir üst seviyeden elemana izin verilmemelidir. Dolayısıyla, bir XSLT işlemci bu türden üst seviyeden elemanları yoksaymakta daima özgürdür ve isim-alanı tanım-yerini bulamıyorsa bunları bir hata vermeksizin yoksaymalıdır. Bu tür elemanlar şunlar için gerekebilir:

  • Ek elemanlar veya ek işlevler tarafından kullanılan bilgiler (bkz, Eklentiler),
  • hedef ağaçta yapılacaklarla ilgili bilgiler,
  • kaynak ağacın nasıl temin edileceği bilgisi,
  • biçembentle ilgili temel veriler,
  • biçembentle ilgili belgeleme.

2.3 Birebir Hedef Eleman olarak Biçembent

Basitleştirilmiş sözdizimi, bir biçembentin kök düğüme denk gelen tek bir örneklenimle oluşturulmasını mümkün kılar. Yani, biçembentin kendisi hedef elemandan oluşabilir (bkz, Birebir Hedef Elemanlar). Böyle bir biçembent, içeriği birebir hedef eleman olan bir örneklenim kuralını içeren xsl:stylesheet elemanlı bir biçembente eşdeğerdir; örneklenim kuralı / örüntüsü ile eşleşir. Örneğin,

<html xsl:version="1.0"
      xmlns:xsl="http://www.w3.org/1999/XSL/Transform"
      xmlns="http://www.w3.org/TR/xhtml1/strict">
  <head>
    <title>Harcama Raporu Hülâsası</title>
  </head>
  <body>
    <p>Toplam Miktar: <xsl:value-of select="harcama-raporu/toplam"/></p>
  </body>
</html>

ile

<xsl:stylesheet version="1.0"
                xmlns:xsl="http://www.w3.org/1999/XSL/Transform"
                xmlns="http://www.w3.org/TR/xhtml1/strict">
<xsl:template match="/">
<html>
  <head>
    <title>Harcama Raporu Hülâsası</title>
  </head>
  <body>
    <p>Toplam Miktar: <xsl:value-of select="harcama-raporu/toplam"/></p>
  </body>
</html>
</xsl:template>
</xsl:stylesheet>

eşdeğerdir.

Bir biçembendin belge elemanı olan bir birebir hedef eleman, biçembendin gerektirdiği XSLT sürümünü belirten bir xsl:version özniteliğine sahip olmak zorundadır. XSLT'nin bu sürümü için bu değer 1.0 olup değer bir Sayı olmalıdır. Diğer birebir hedef elemanlar ayrıca birer xsl:version özniteliğine sahip olabilir. xsl:version özniteliğinin değeri 1.0 olmadığı takdirde, ileriye uyumlu işlem kipi etkin olur (bkz, İleriye Uyumlu İşlem).

Bir biçembent olarak kullanıldığında bir birebir hedef elemanın içeriği, biçembendin içinde kullanılandakinden farklı değildir. Bu bakımdan, bir biçembent olarak kullanılmış olan bir birebir hedef eleman tepe-seviyeden elemanlar içeremez.

Bazı durumlarda, sistemin bir XML belgenin bir XSLT biçembendi olarak bir XSLT işlemcisi tarafından işlenmesinin gerektiğini anlamasının tek yolu XML belgenin kendisini incelemesi olabilir. Basitleştirilmiş sözdiziminin kullanılması bu süreci daha da zorlaştıracaktır.

Not:
Örneğin, başka XML dili (BXD) diye bir dilin belge elemanı üzerinde, XML belgenin bir BXD işlemcisi tarafından işlenmesi gereken bir BXD belgesi olduğunu belirten, bir bxd:version özniteliği kullanmış olsun. Eğer bir belge hem bxd:version hem de xsl:version özniteliklerine sahipse belgenin bir BXD işlemci tarafından mı yoksa bir XSLT işlemci tarafından mı işleneceği belli olmayacaktır.

Diğer taraftan, böyle bir durumda, XSLT biçembendinde basitleştirilmiş sözdiziminin kullanılmaması gerekir. Bu durum, örneğin, içeriğini işlemek için iletinin MIME ortam türüne bakan bir alıcıya, bir XSLT biçembendinin text/xml veya application/xml MIME ortam türünde bir ileti olarak aktarıldığı bir durum olarak karşımıza çıkabilir.

2.4 Nitelikli Adlar

Bir dahili XSLT nesnesinin ismi, özellikle bir isimli örneklenim (İsimli Örneklenimler), bir kip (Kipler), bir öznitelik kümesi (İsimli Öznitelik Kümeleri), bir anahtar (Anahtarlar), bir onluk sayı biçimi (Sayı Biçimleme), bir değişken veya değergeç (Değişkenler ve Değergeçler) birer NitelAd olarak belirtilir. Eğer nitelikli ad bir öneke sahipse, önek bir tanım-yeri başvurusuna genişletilir; bu tanım-yerine başvurusuna genişletme işlemi, ismin yer aldığı öznitelik üzerinden etkili olan isim-alan bildirimleri kullanılarak yapılır. Genişletilmiş isim ismin yerel kısmı ile nesne ismi olarak kullanılan ve boş olabilen bir tanım-yeri başvurusundan oluşur. Öntanımlı isim-alanı öneksiz isimler için kullanılMAZ.

2.5 İleriye Uyumlu İşlem

Bir eleman ileriye uyumlu kipi kendisi, öznitelikleri, astsalları için şunlardan birinin varlığı halinde etkinleştirir:

  • Eleman, version özniteliği 1.0'dan farklı bir xsl:stylesheet elemanıdır.
  • Eleman, xsl:version özniteliği 1.0'dan farklı bir değerde olan bir birebir hedef elemandır.

Değeri 1.0 olan bir xsl:version özniteliğine sahip bir birebir hedef eleman ileriye uyumlu kipi kendisi, öznitelikleri, astsalları ve astsallarının öznitelikleri için etkinleştirmeyecektir.

Eğer bir eleman ileriye uyumlu kipte işlem yapıyorsa:

  • Eleman, bir tepe-seviyeden elemansa ve XSLT 1.0 böyle elemanlara tepe seviyeden elemanlar olarak izin vermiyorsa, eleman içeriğiyle birlikte yoksayılmalıdır.

  • Eleman bir örneklenim içindeyse ve XSLT 1.0 böyle elemanların bir örneklenim içinde bulunmasına izin vermiyorsa, eleman işleme sokulamadığı takdirde bir hata oluşmalı, aksi takdirde XSLT, eleman için Son Çare bölümünde belirtildiği gibi bir son çareye başvurmalıdır.

  • Eleman, XSLT 1.0 tarafından bir elemanın sahip olmasına izin verilmeyen bir özniteliğe sahipse ya da XSLT 1.0 tarafından bir seçimlik özniteliğin sahip olmasına izin verilmeyen bir değere sahip bir özniteliğe sahipse, öznitelik yoksayılmalıdır.

Bu bakımlardan, bir XSLT işlemci aşağıdaki biçembenti, bu belirtimde tanımlanmamış bir XSLT isim-alanından elemanlar içerse bile hatasız işleyebilmelidir.

<xsl:stylesheet version="1.1"
                xmlns:xsl="http://www.w3.org/1999/XSL/Transform">
  <xsl:template match="/">
    <xsl:choose>
      <xsl:when test="system-property('xsl:version') >= 1.1">
        <xsl:yeni-heyecan-verici-1.1-özelliği/>
      </xsl:when>
      <xsl:otherwise>
        <html>
        <head>
          <title>XSLT 1.1 gerekli</title>
        </head>
        <body>
          <p>Bu biçembent XSLT 1.1 gerektiriyor.</p>
        </body>
        </html>
      </xsl:otherwise>
    </xsl:choose>
  </xsl:template>
</xsl:stylesheet>

Not:
Eğer bir biçembent sürümü 1.0'dan sonraki bir XSLT'ye ait bir tepe seviyeden elemana son derece bağımlıysa, biçembent, XSLT'nin daha erken sürümlerini gerçekleyen XSLT işlemcilerin tepe seviyeden elemanları sessizce yoksaymayacağından emin olmak için bir xsl:message elemanını terminate="yes" özniteliği ile kullanabilir (bkz, İletiler). Örnek:

<xsl:stylesheet version="1.5"
                xmlns:xsl="http://www.w3.org/1999/XSL/Transform">

  <xsl:etkili-yeni-1.1-bildirimi/>

  <xsl:template match="/">
    <xsl:choose>
      <xsl:when test="system-property('xsl:version') &lt; 1.1">
        <xsl:message terminate="yes">
          <xsl:text>Bu biçembent XSLT 1.1 gerektiriyor.</xsl:text>
        </xsl:message>
      </xsl:when>
      <xsl:otherwise>
        ...
      </xsl:otherwise>
    </xsl:choose>
  </xsl:template>
  ...
</xsl:stylesheet>

Eğer bir ifade ileriye uyumlu kipte işlem yapan bir öznitelikte bulunuyorsa, XSLT işlemci ifadedeki bazı hatalar için şöyle davranmalıdır:

  • Eğer ifade XPath dilbilgisine göre izin verilen sözdizimine uygun değilse, ifade gerçekten değerlendirilemedikçe bir hata üretilmemelidir.

  • Eğer ifade XSLT kütüphanesinin bir parçası olmayan ve ismi öneksiz olan bir işlevi çağırıyorsa, işlev gerçekten çağrılamadıkça bir hata üretilmemelidir.

  • Eğer ifade bir işlevi, XSLT tarafından izin verilmeyen sayıda argümanla veya XSLT tarafından izin verilmeyen türdeki argümanlarla çağırıyorsa, işlev gerçekten çağrılamadıkça bir hata üretilmemelidir.

2.6 Biçembentlerin Birleştirilmesi

XSLT biçembentlerin birleştirilmesi için iki mekanizmaya sahiptir:

  • Anlamsallıkları değişmeksizin biçembentlerin birleştirilebilmelerini mümkün kılan içerme mekanizması ve
  • her biçembentin diğerlerinin yukarısına gelecek şekilde birleştirilmesini mümkün kılan ithal mekanizması.

2.6.1 Biçembentlerin İçerilmesi

<!-- Grubu: tepe-seviyeden-eleman -->
<xsl:include
  href = tanım-yeri-başvurusu />
eleman

Bir XSLT biçembendi başka bir XSLT biçembendini bir xsl:include elemanı kullanarak içerebilir. xsl:include elemanı, değeri içerilecek biçembendin tanım-yerine bir başvuru olan bir href özniteliğine sahiptir. Göreli bir tanım-yeri xsl:include elemanını içeren biçembendin tanım-yerine göre çözümlenir (bkz, Temel Tanım-yeri).

xsl:include elemanına sadece tepe-seviyeden bir eleman olarak izin verilir.

İçerme işlemi XML ağaç seviyesinde gerçekleşir. href özniteliğinin değeriyle yeri belirlenen kaynak bir XML belge olarak ele alınır ve bu belgedeki xsl:stylesheet elemanının çocukları xsl:include elemanının yerine yerleştirilirler. İçerilen örneklenim kuralları ve tanımları işlem sırasını fiilen etkilemezler.

İçerilen biçembent Birebir Hedef Eleman olarak Biçembent bölümünde açıklanan basitleştirilmiş sözdizimini kullanıyor olabilir ve böyle bir durumda biçembent eşdeğer xsl:stylesheet elemanı ile aynı şekilde ele alınır.

Bir biçembendin doğrudan veya dolaylı kendi kendini içeriyor olması bir hatadır.

Not:
Defalarca içerilen bir biçembent tanımların tekrarı sebebiyle hatalara yol açabilir. Böyle çoklu içerimler dolaylı olduklarında daha az belirgin olurlar. Örneğin, B ve C biçembendleri A biçembendini içeriyorsa ve D biçembendi de hem B hem de C biçembendini içeriyorsa, A biçembendi, D biçembendi tarafından dolaylı olarak iki kere içerilmiş olacaktır. B, C ve D biçembentlerinin herbiri bağımsız biçembentler olarak kullanılıyorsa, B biçembendindeki A biçembendinin içerilmesi dışındaki herşeyi bir B' biçembendine aktararak ve benzer bir işlemi C biçembendi içinde yaptıktan sonra D biçembendini A, B' ve C' biçembentlerini içerecek şekilde değiştirerek hatadan kurtulmak mümkün olabilir.

2.6.2 Biçembent İthali

<xsl:import
  href = tanım-yeri-başvurusu />
eleman

Bir XSLT biçembendi başka bir XSLT biçembendini bir xsl:import elemanı kullanarak ithal edebilir. İthal edilen biçembentteki örneklenim kurallarının ve tanımlarının ithal eden biçembenttekilerin önüne geçmesi dışında ithal işlemi içerme işlemine (bkz, Biçembentlerin İçerilmesi) benzer; işlem aşağıda daha ayrıntılı olarak açıklanmıştır. xsl:import elemanı, değeri ithal edilecek biçembendin tanım-yerine bir başvuru olan bir href özniteliğine sahiptir. Göreli bir tanım-yeri xsl:import elemanını içeren biçembendin tanım-yerine göre çözümlenir (bkz, Temel Tanım-yeri).

xsl:import elemanına sadece tepe-seviyeden bir eleman olarak izin verilir.

xsl:import elemanının çocukları, bir xsl:stylesheet elemanının diğer bütün çocuklarının ve varsa xsl:include elemanlarının herbirinin çocuklarının öncesine geçmelidir. xsl:include bir biçembendi içermek üzere kullanıldığında, içerilen belgedeki xsl:import elemanları yine yukarıya ama, içeren belgedeki xsl:import elemanlarının sonrasına gider. Örnek:

<xsl:stylesheet version="1.0"
                xmlns:xsl="http://www.w3.org/1999/XSL/Transform">
  <xsl:import href="article.xsl"/>
  <xsl:import href="bigfont.xsl"/>
  <xsl:attribute-set name="note-style">
    <xsl:attribute name="font-style">italic</xsl:attribute>
  </xsl:attribute-set>
</xsl:stylesheet>

xsl:import elemanları içeren bir biçembentin işlenmesi sırasında karşılaşılan xsl:stylesheet elemanları bir ithal ağaç olarak ele alınır. İthal ağaçtaki her xsl:stylesheet elemanı, içerdiği her xsl:import elemanı için bir ithal çocuğa sahip olur. xsl:include elemanları ithal ağaç oluşturulmadan önce çözümlenir. İthal ağaçtaki bir xsl:stylesheet elemanına, ithal ağacın çocuğu olarak işleme alınacak bir xsl:stylesheet elemanından önce ziyaret edilmiş diğer bir xsl:stylesheet elemanından daha düşük bir ithal önceliği tanınır. (Türkçesi, bir sülaledeki bir evlatlığın öz evlatları evlatlıklarından sonra ziyaret edilir.) Her tanımın ve örneklenim kuralının ithal önceliği kendini içeren xsl:stylesheet elemanına göre belirlenir.

Varsayalım,

  • A biçembendi sırasıyla B ve C biçembentlerini ithal etmiş olsun;
  • B biçembenti D'yi
  • C biçembendi de E'yi ithal etmiş olsun.

İthal önceliği sırası D, B, E, C, A olacaktır.

Not:
xsl:import elemanlarının herhangi bir tanım veya örneklenim kuralından önce kullanılması gerektiğinden, ithal edilen biçembentleri xsl:import elemanına rastlandığı noktada işleme sokan bir gerçeklenim, tanımlara ve örneklenim kurallarına artan ithal önceliğiyle rastlayacaktır.

Genel olarak, daha yüksek önceliğe sahip bir tanım veya örneklenim kuralı, daha düşük ithal önceliğine sahip bir tanım veya örneklenim kuralından öncelikli olur. Bu, her tanım veya örneklenim kuralı çeşidi için ayrı ayrı tanımlanır.

Bir biçembendin doğrudan veya dolaylı kendi kendini ithal ediyor olması bir hatadır. Bundan kaçınmak için, belli bir tanım-yeri ile bir biçembendin birden fazla yerde ithal edilmesi durumunda, biçembent özel olarak ele alınmaz. İthal ağaç, ithal edildiği her noktada ayrı bir xsl:stylesheet'e sahip olur.

Not:
Eğer xsl:apply-imports kullanılmışsa (bkz, Örneklenim Kurallarının Geçerli Kılınması), davranış, biçembendin sadece en yüksek ithal öncelikli yerde ithal edilmesi durumundakinden farklı olabilir.

2.7 Gömülü Biçembentler

Normalde bir biçembent, belge elemanı xsl:stylesheet elemanı olan eksiksiz bir XML belgedir. Buna rağmen, bir XSLT biçembenti başka bir kaynağa da gömülebilir. İki çeşit gömülüm mümkündür:

  • XSLT biçembendi XML olmayan bir kaynağa gömülebilir veya
  • XML belgenin belge elemanı xsl:stylesheet elemanı olmaksızın biçembent bir XML kaynağa gömülebilir.

İkinci şeklini kolaylaştırmak için, xsl:stylesheet elemanının eşsiz bir betimleyici içeren bir ID özniteliğine sahip olması mümkün kılınmıştır.

Not:
Böyle bir özniteliğin XPath id işlevi ile kullanılabilmesi için gerçekten de ID türünden bir öznitelik olarak DTD'de bildirilmiş olması gerekir.

Aşağıdaki örnekte xml-stylesheet işlem yönergesinin [XML Stylesheet] bir belgenin kendi biçembendini içermesini mümkün kılmak için nasıl kullanılabileceği gösterilmiştir. Tanım-yeri başvurusunda xsl:stylesheet elemanının yeri olarak bölüm betimleyicili bir göreli tanım-yeri kullanılmıştır:

<?xml-stylesheet type="text/xml" href="#style1"?>
<!DOCTYPE doc SYSTEM "doc.dtd">
<doc>
<head>

<xsl:stylesheet id="style1"
                version="1.0"
                xmlns:xsl="http://www.w3.org/1999/XSL/Transform"
                xmlns:fo="http://www.w3.org/1999/XSL/Format">

<xsl:import href="doc.xsl"/>

<xsl:template match="id('foo')">
  <fo:block font-weight="bold">
    <xsl:apply-templates/>
  </fo:block>
</xsl:template>

<xsl:template match="xsl:stylesheet">
  <!-- ignore -->
</xsl:template>

</xsl:stylesheet>

</head>
<body>
<para id="foo">
...
</para>
</body>
</doc>

Not:
Bir biçembent, ister uygulansın, ister içerilsin, ister ithal edilsin bir belgeye gömüldüğü takdirde yoksayılacak bir xsl:stylesheet elemanı belirtilmiş bir örneklenim kuralının varlığını gerektirir.

3 Veri Modeli

XSLT tarafından kullanılan veri modeli, bu bölümdeki açıklananlar dışında XPath veri modeli ile aynıdır. XSLT aynı veri modelini kullanan kaynak, hedef ve biçembent belgeleri üzerinde işlem yapar. Aynı ağaca sahip herhangi iki XML belge XSLT'ye göre aynı belgedir.

Biçembentteki işlem yönergeleri ve açıklamalar yoksayılır: biçembent, ağacında ne işlem yönergesi (İng: processing instruction) ne de açıklama varmış gibi ele alınır.

3.1 Kök Düğümün Çocukları

Kök düğümün çocukları üzerindeki normal kısıtlamalar hedef ağaç için esnetilir. Hedef ağacın çocukları bir eleman düğümü için olası herhangi bir sırada olabilir. Özellikle, metin düğümü çocuklara sahip olabileceği gibi istenen sayıda eleman düğümü çocuğa sahip olabilir. xsl:output yöntemi (bkz, Çıktı) XML çıktı için kullanıldığında hedef ağacın iyi biçimlenmiş bir XML belgesi olması gerekmeyebilir; yine de, çıktı daima iyi biçimlenmiş haricen çözümlenebilir bir öğe olacaktır.

Kaynak ağacı iyi biçimlenmiş bir XML belge çözümlenerek oluşturulduğunda, kaynak ağacın kök düğümü, bir metin düğümüne sahip olmamak ve tek bir çocuk elemana sahip olmak gibi normal kısıtlamaları kendiliğinden yerine getirecektir. Kaynak ağacı, DOM kullanımı gibi başka bir yöntemle oluşturulduğunda geçerli kısıtlamalar kaynak ağaç için hedef ağaçtaki kadar esnektir.

3.2 Temel Tanım-yeri

Her düğümün kendisiyle ilişkili tanım-yerine o düğümün temel tanım-yeri denir ve göreli tanım-yerlerini mutlak tanım-yerleri haline getirmek için öznitelik değerlerini çözümlemekte kullanılır. Eğer bir eleman veya işlem yönergesi harici bir öğe içinde yer alıyorsa, bu elemanın veya işlem yönergesinin temel tanım-yeri harici öğenin tanım-yeri olur; aksi takdirde, temel tanım-yeri, belgenin tanım-yeridir. Belge düğümünün temel tanım-yeri belge öğesinin tanım-yeridir. Bir metin, açıklama, öznitelik veya bir isim-alanı düğümümünün temel tanım-yeri ise, ebeveyn düğümün temel tanım-yeridir.

3.3 Çözümlenmemiş Öğeler

Kök düğüm, belgenin DTD'sinde bildirilmiş her çözümlenmemiş öğe için tanım-yeri veren bir eşleme sahiptir. Tanım-yeri, öğe bildiriminde belirtilen sistem betimleyici ve genel betimleyiciden üretilir. XSLT işlemci, tanım-yerini üretmek için sistem betimleyicide belirtilen tanım-yerini bırakıp genel betimleyiciyi kullanabilir. Eğer XSLT işlemci tanım-yerini üretmek için genel betimleyiciyi kullanmıyorsa, sistem betimleyiciyi kullanmalıdır; eğer sistem betimleyici bir göreli tanım-yeri ise, temel tanım-yeri [RFC2396] olarak öğe bildirimini içeren kaynağın tanım-yerini kullanarak onu bir mutlak tanım-yeri olarak çözümlemelidir.

3.4 Boşluk Ayıklama

Kaynak belge veya biçembent belgesi için ağaç oluşturulup, XSLT tarafından bir şekilde işleme sokulmadan önce bazı metin düğümleri ayıklanabilir. Bir metin düğümü salt boşluk karakterlerini içeriyor olmadıkça asla ayıklanamaz. Metin düğümünün ayıklanması metin düğümünü ağaçtan siler. Ayıklama işleminde boşlukları korunması gereken elemanların isimlerinden oluşan bir küme girdi olarak alınır. Ayıklama işlemi biçembentlerin ve kaynak belgelerin her ikisine de uygulanır, ancak boşlukları korunması gereken elemanlar saptanırken uygulama farklı olur.

Aşağıdakilerin herhangi biri uygulanabiliyorsa bir metin düğümü korunur:

  • Metin düğümünün ebeveyninin eleman ismi boşlukları korunması gereken eleman isimleri arasındadır.

  • Metin düğümü en azından bir tane boşluk olmayan karakter içeriyordur. XML'deki gibi, bir boşluk karakteri #x20, #x9, #xD veya #xA olabilir.

  • Metin düğümünün bir üstsel elemanı preserve değerli bir xml:space özniteliğine sahiptir ve üstsel elemanları arasında default değerli xml:space özniteliğine sahip eleman hiç yoktur.

Aksi takdirde, metin düğümü ayıklanır.

xml:space öznitelikleri ağaçtan ayıklanmaz.

Not:
Eğer bir birebir hedef elemanda bir xml:space özniteliği belirtilmişse, bu uygulanır ve sonuç özniteliği içerir.

Biçembentler bakımından, boşlukları korunması gereken eleman isimleri kümesi sadece xsl:text içerir.

<!-- Grubu: tepe-seviyeden-eleman -->
<xsl:strip-space
  elements = dizgecikler />
eleman
<!-- Grubu: tepe-seviyeden-eleman -->
<xsl:preserve-space
  elements = dizgecikler />
eleman

Kaynak belgeler için, boşlukları korunması gereken eleman isimleri tepe-seviyeden elemanlar olan xsl:strip-space ve xsl:preserve-space ile belirtilir. Bir eleman isminin boşlukları korunması gereken isimler arasında bulunup bulunmadığı en iyi xsl:strip-space veya xsl:preserve-space elemanlarında belirtilmiş isimlerden saptanır. Bir eleman isminin boşlukları korunması gereken isimler arasında bulunması için gerek ve yeter koşul, bir xsl:preserve-space elemanında belirtilen isimlerden biri ile bir eşleşmenin varlığıdır. xsl:strip-space ve xsl:preserve-space elemanların ikisi de değeri boşluk ayraçlı AdSınaması listesi olan birer elements özniteliğine sahiptir; Bir elemanın bir xsl:strip-space veya xsl:preserve-space ile eşleşmesi AdSınamalarından biri ile eşleşmesi demektir. Bir elemanın bir AdSınaması ile eşleşmesi için gerek ve yeter koşul, AdSınamasının bir XPath düğüm sınaması olarak eleman için doğru olmasıdır. Birden fazla xsl:strip-space ve xsl:preserve-space elemanı ile eşleşme olduğu takdirde, en iyi eşleşen eleman, en iyi eşleşen AdSınaması saptanarak bulunur. Bu saptama örneklenim kurallarındaki yöntemle aynıdır:

Eğer bu yöntemle geriye birden fazla eşleşme kalırsa bu bir hatadır. Bir XSLT işlemci hatayı bildirebilir; eğer bildirmiyorsa, kalan eşleşmeler arasından biçembentte sona doğru yer alanını seçerek hatayı ortadan kaldırmalıdır.

3.5 XML Sürümü

Veri modeli, bir XML 1.0 belgeyi ([XML] ve [XML Adları] ile uyumlu) veya bir XML 1.1 belgeyi ([XML 1.1] ve [XML Adları 1.1] ile uyumlu) ifade edebilecek ve ikisi arasında bir ayrım yapmayacak yetenektedir. Bu bakımdan, ilke olarak, XSLT 1.0 bu XML sürümlerinden biri ile kullanılabilir; farklılık sadece, dönüşüme özel sınırların dışında, ya veri modeli metinsel XML'den (çözümlenerek) oluşturulurken ya da metinsel XML veri modelinden üretilirken (sırayla denk düşürerek) ortaya çıkar.

Veri modelinin oluşturulması bu belirtimin kapsamı dışındadır, dolayısıyla bir XSLT işlemcinin girdiyi bir XML 1.0 veya XML 1.1 belgeden ya da her ikisinden de kabul etmesi ile ilgili bir gereksinim yer almaz. Bu belge XML 1.0 veya XML 1.1 belgeleri çıktılama yeteneğini tanımlar. Ve yine, bir XSLT işlemcinin XML sürümlerinden birini veya ikisini de desteklemesi ile ilgili bir gereksinim yer almaz.

Kaynak belge ister XML 1.0 ister XML 1.1 olsun veri modeli aynı olduğundan, XSLT işleminin anlambilgisi kaynak belgenin XML sürümüne bağlı değildir. İlke olarak, tek bir dönüşümde kullanılan tüm girdi ve çıktı belgelerinin aynı XML sürümüne uygun olmasını gerektiren bir sebep yoktur.

4 İfadeler

XSLT, XPath [XPath] tarafından tanımlanmış ifade dilini kullanır. XSLT'de ifadeler aşağıdaki amaçlar dahil çeşitli amaçlarla kullanılırlar:

Bir ifade bir XPath İfade sözdizimi ile eşleşmelidir.

İfadeler, XSLT tarafından tanımlanmış elemanların belirli özniteliklerinin değerlerinde ve öznitelik değeri örneklenimlerinde kaşlı ayraçların arasında karşımıza çıkarlar.

XSLT'de bağımsız (başka bir ifadenin parçası olmayan) bir ifadenin bağlamı şöyle oluşur:

5 Örneklenim Kuralları

5.1 İşlem Modeli

Bir kaynak düğümleri listesi işlendiğinde hedef ağacın bir bölümü oluşturulmuş olur. Hedef ağacı oluşturmak için kök düğümü içeren ana listeyi işlemek gerekir. Bir kaynak düğümleri listesi, ana listenin her üyesi sırayla işlenerek oluşturulan hedef ağaç yapısına eklenerek işlenir. Bir düğüm ise, düğümle eşleşen örüntülere sahip tüm örneklenim kuralları bulunarak ve bunların en uygunu seçilerek işlenir; seçilen kuralın örneklenimi, kaynak düğüm geçerli düğüm olarak, kaynak düğüm listesi geçerli düğüm listesi olarak ele alınarak örneklenir. Bir örneklenim genelde, işlem için ek kaynak düğümü listesini seçmekte kullanılan yönergelerden oluşur. Eşleştirme, örnekleme ve seçim işlemleri işlem için seçilecek kaynak düğümü kalmayıncaya kadar ardışık olarak sürer.

Gerçeklenimler, kaynak belgeyi, bu işlem modeli kullanılarak elde edilen sonucun aynısını üretecek şekilde işleyecek yöntemi seçmekte özgürdürler.

5.2 Örüntüler

Örneklenim kuralları düğümlerle bir örüntü aracılığıyla özdeşleşir. Örüntüler, örneklenim kurallarından başka, numaralama (Numaralama) ve anahtar bildirimi (Anahtarlar) için de kullanılırlar. Bir örüntü, bir düğüme uygulanacak koşul kümesini belirtir. Bu koşulları yerine getiren bir düğüm örüntüyle eşleşir; yerine getirmiyorsa eşleşmez. Örüntü sözdizimi, ifade sözdiziminin bir alt kümesidir. Özellikle, belli şartları sağladığı takdirde bir konumsal yol örüntü olarak kullanılabilir. Bir ifade ayrıca, daima düğüm kümesi türünde bir nesne olarak değerlendirilen bir örüntüdür. Bir düğüm, bir örüntünün belli bir bağlamla ilgili bir ifade olarak değerlendirilmesinin sonucunda elde edilen düğüm kümesinin bir üyesiyse, düğüm örüntüyle eşleşir; sözkonusu bağlam, bu düğüm veya üstsellerinden birinin eşleştiği bağlamsal düğümlerdir.

Bazı örüntü örnekleri:

  • para örüntüsü herhangi bir para elemanıyla eşleşir

  • * örüntüsü herhangi bir elemanla eşleşir

  • chapter|appendix örüntüsü herhangi bir chapter veya appendix elemanıyla eşleşir

  • olist/item örüntüsü ebeveyni olist olan herhangi bir item elemanıyla eşleşir

  • appendix//para örüntüsü üstseli appendix olan herhangi bir para elemanıyla ile eşleşir

  • / örüntüsü sadece kök düğümle eşleşir

  • text() örüntüsü herhangi bir metin düğümü ile eşleşir

  • processing-instruction() örüntüsü herhangi bir işlem yönergesi ile eşleşir

  • node() örüntüsü bir öznitelik düğümü veya kök düğüm olmayan herhangi bir düğümle eşleşir

  • id("W11") örüntüsü eşsiz ID'si W11 olan elemanla eşleşir

  • para[1] örüntüsü ilk para çocukla eşleşir

  • *[position()=1 and self::para] örüntüsü çocuklardan para türündekilerin ilkiyle eşleşir

  • para[last()=1] örüntüsü sonuncu para çocukla eşleşir

  • items/item[position()>1] örüntüsü ebeveynleri items olan item elemanlarından ilki hariç hepsiyle eşleşir

  • item[position() mod 2 = 1] örüntüsü çift numaralı item çocuklarla eşleşir

  • div[@class="appendix"]//p örüntüsü appendix değerli bir class özniteliğine sahip div üstseli olan herhangi bir p elemanıyla eşleşir

  • @* örüntüsü herhangi bir öznitelikle eşleşir

  • @class örüntüsü herhangi bir class özniteliği ile eşleşir

  • *[@class] örüntüsü class özniteliğine sahip herhangi bir elemanla eşleşir

  • code[starts-with(normalize-space(text()), 'xsl:')] örüntüsü metin düğümünün normalleştirilmiş değeri 'xsl:' dizgesi ile başlayan herhangi bir code elemanıyla eşleşir (Ç.N. - Bu örüntü, bu belirtimin XML belgesini XHTML'ye dönüştürmekte kullanılan örneklenimlerden birinde kullanılmıştır.)

Bir örüntünün Örüntü sözdizimi ile eşleşmesi gerekir. Bir Örüntü, | imleriyle ayrılmış konumsal yol örüntülerinden oluşur. Bir konumsal yol örüntüsü, konumlarının her birinde child veya attribute dallarının kullanıldığı bir konumsal yoldur. descendant-or-self dalının kullanımının gerekli olmadığı yerlerde // veya / işleci kullanılabilir. Konumsal yol örüntüleri ayrıca, bir dizgesel sabit argümana sahip id veya key işlev çağrıları ile başlayabilir. Bir örüntüdeki dayanaklarda da bir konumsal yoldaki dayanaklarda olduğu gibi keyfî ifadeler kullanılabilir.

Örüntüler
[1]   Örüntü   ::=   KonumsalYolÖrüntüsü
| Örüntü '|' KonumsalYolÖrüntüsü
[2]   KonumsalYolÖrüntüsü   ::=   '/' GöreliYolÖrüntüsü?
| IdKeyÖrüntüsü (('/' | '//') GöreliYolÖrüntüsü)?
| '//'? GöreliYolÖrüntüsü
[3]   IdKeyÖrüntüsü   ::=   'id' '(' DizgeselSabit ')'
| 'key' '(' DizgeselSabit ',' DizgeselSabit ')'
[4]   GöreliYolÖrüntüsü   ::=   KonumÖrüntüsü
| GöreliYolÖrüntüsü '/' KonumÖrüntüsü
| GöreliYolÖrüntüsü '//' KonumÖrüntüsü
[5]   KonumÖrüntüsü   ::=    ÇocukVeyaÖznitelikBelirteci DüğümSınaması Dayanak*
[6]   ÇocukVeyaÖznitelikBelirteci   ::=   KısaKonumBelirteci
| ('child' | 'attribute') '::'

Bir örüntünün bir düğümle eşleşmesi için gerek ve yeter koşul, örüntünün bir ifade olarak değerlendirildiği olası bir bağlamda, düğümün bu değerlendirme sonucunda elde edilen düğüm kümesinin bir üyesi olmasıdır. Bir düğüm eşleştiği takdirde, olası bağlamlar, bu düğümün veya bir üstselinin eşleştiği bir bağlamsal düğüme ve bu bağlamsal düğümü içeren bir bağlamsal düğüm listesine sahip bağlamlar olur.

Örneğin, p örüntüsü herhangi bir p elemanı ile eşleşir; p ifadesi, bağlamsal düğüm olarak p'nin ebeveyni ile değerlendirilirse, elde edilen düğüm kümesi p elemanını üyesi olarak içerecektir.

Not:
Bu örüntü, p elemanı belge elemanı olsa bile elemanla eşleşir, çünkü belge elemanının ebeveyni kök düğümdür.

Örüntülerin anlambilgisi dolaylı olarak ifade değerlendirme kuralları ile belirtiliyor olsa da, bir örüntünün ne anlam geldiğini ifade değerlendirme kurallarıyla düşünmeksizin doğrudan doğruya anlamak daha kolaydır. Bir örüntüde | imi seçenekleri belirtir; eğer bir örüntüde bir veya daha fazla sayıda | imi ile ayrılmış seçenek varsa, seçeneklerden birinin eşleşmesi halinde örüntü eşleşmiş olur.

/ veya // ayraçları ile ayrılmış çok sayıda KonumÖrüntüsüden oluşmuş bir örüntü sağdan sola doğru eşleşir. Örüntünün eşleşmesi için en sağdaki KonumÖrüntüsünün düğümle eşleşip örüntünün kalanının da uygun bir elemanla eşleşmesi yeterlidir; uygun eleman, ayraç olarak // kullanılmışsa düğümün üstsellerden biri, / kullanılmışsa düğümün ebeveyni olacaktır.

Çocuk dal kullanan bir KonumÖrüntüsü, eğer DüğümSınamasının sonucu düğüm için doğruysa ve düğüm bir öznitelik düğümü ise eşleşir.

İfade [] içerdiği takdirde, KonumÖrüntüsündeki ilk Dayanakİfadesi bağlamsal düğüm olarak düğümle ve eşleştirilecek düğüm bir öznitelik düğümü olmadıkça, DüğümSınaması bağlamsal düğüm listesi olarak bağlamsal düğümün kardeşleri ile eşleşecek şekilde değerlendirilir; eşleştirilecek düğüm bir öznitelik düğümü olduğu takdirde, bağlamsal düğüm listesi, tamamen, eşleşen öznitelikle aynı düğümde olan özniteliklerden oluşur ve bu AdSınaması ile eşleşir.

Örneğin, bu ifadenin,

appendix//ulist/item[position()=1]

bir düğümle eşleşmesi için gerek ve yeter koşullar şunlardır:

  • item DüğümSınaması düğüm için doğru olmalı ve düğüm bir öznitelik olmamalıdır; başka bir deyişle düğüm bir item elemanı olmalıdır.

  • position()=1 Dayanakİfadesinin bağlamsal düğüm olarak düğümle ve bağlamsal düğüm listesi olarak düğümün item kardeşleriyle değerlendirilmesinin sonucu doğru olmalıdır.

  • düğümün appendix//ulist ile eşleşen bir ebeveyni olmalıdır; ebeveyn, appendix üstsele sahip bir ulist elemanı ise bu doğru olacaktır.

5.3 Örneklenim Kurallarının Tanımlanması

<!-- Grubu: tepe-seviyeden-eleman -->
<xsl:template
  match = örüntü
  name = nitelikli-ad
  priority = sayı
  mode = nitelikli-ad >
  <!-- İçeriği: (<xsl:param>*, örneklenim) -->
</xsl:template>
eleman

Bir örneklenim kuralı xsl:template elemanı ile belirtilir. match özniteliği, kuralın uygulanacağı kaynak düğüm ya da düğümleri tanımlayan bir Örüntüdür. match özniteliği xsl:template elemanı bir name özniteliğine sahip olmadıkça gereklidir (İsimli Örneklenimler bölümüne bakınız). match özniteliğinin değer olarak bir DeğişkenGönderimi içermesi bir hatadır. xsl:template elemanının içeriği, örneklenim kuralı uygulandığında nesnelleşmiş olacak olan örneklenimdir.

Örneğin bir XML belge şunu içersin:

Bu <emph>önemli</emph> bir noktadır.

Aşağıdaki örneklenim kuralı emph elemanı ile eşleşir ve font-weight özniteliğinin değeri bold olan bir fo:inline-sequence biçimleme nesnesini üretir.

<xsl:template match="emph">
  <fo:inline-sequence font-weight="bold">
    <xsl:apply-templates/>
  </fo:inline-sequence>
</xsl:template>

Not:
Bu belgedeki örneklerde, [XSL]'de tanımlanmış olan biçimleme nesnelerinin isim-alanı olan http://www.w3.org/1999/XSL/Format için fo: öneki kullanılmıştır.

Biraz sonra açıklanacağı gibi xsl:apply-templates elemanı kaynak elemanın çocuklarını peşpeşe işleyecektir.

5.4 Örneklenim Kurallarının Uygulanması

<!-- Grubu: yönerge -->
<xsl:apply-templates
  select = düğüm-kümesi-ifadesi
  mode = nitelikli-ad >
  <!-- İçeriği: (<xsl:sort> | <xsl:with-param>) -->
</xsl:apply-templates>
eleman

Bu örnek bir chapter elemanı için bir blok oluşturup ardından çocukları işler.

<xsl:template match="chapter">
  <fo:block>
    <xsl:apply-templates/>
  </fo:block>
</xsl:template>

select özniteliğinin yokluğunda xsl:apply-templates yönergesi geçerli düğümün tüm çocuklarını, metin düğümleri de dahil olmak üzere işler. Bununla birlikte, Boşluk Ayıklama bölümünde belirtildiği gibi ayıklanan metin düğümleri işlenmeyecektir. Eğer bir eleman için boşluk düğümlerinin ayıklanması etkin kılınmamışsa, eleman içeriğindeki bütün boşluk karakterleri metin olarak işlenecektir ve bu bakımdan position işlevi tarafından döndürülen bir çocuk elemanın yakınlık derecesi saptanırken, çocuk elemanların arasındaki boşluklar da sayılacaktır.

select özniteliğinde belirtilecek bir ifadeyle, tüm çocukların değil de sadece seçilen çocukların işlenmesi sağlanabilir. select özniteliğinin değeri bir ifadedir. İfade bir düğüm kümesiyle sonuçlanacak şekilde değerlendirilmelidir. Seçilen düğüm kümesi, bir sıralama (Sıralama) belirtilmemişse belgedeki sıraya göre işlenecektir. Aşağıdaki örnekte, yazar-grubu'nun tüm yazar çocukları işlenmektedir:

<xsl:template match="yazar-grubu">
  <fo:inline-sequence>
    <xsl:apply-templates select="yazar"/>
  </fo:inline-sequence>
</xsl:template>

Aşağıdaki örnekte ise, yazar-grubu'nun yazar çocuklarının tüm verilen-ad'ları işlenmektedir:

<xsl:template match="yazar-grubu">
  <fo:inline-sequence>
    <xsl:apply-templates select="yazar/verilen-ad"/>
  </fo:inline-sequence>
</xsl:template>

Bu örnekte, book elemanının tüm heading astsalları işlenir:

<xsl:template match="book">
  <fo:block>
    <xsl:apply-templates select=".//heading"/>
  </fo:block>
</xsl:template>

Ayrıca, geçerli düğümün astsalı olmayan elemanları da işlemek mümkündür. Bu örnekte ekip çocuklara ve personel torunlara sahip bir bölüm ele alınmaktadır. Bir personelin bölümü bulunmakta ve bölüm'ün ekip çocukları işleme sokulmaktadır:

<xsl:template match="personel">
  <fo:block>
    <xsl:apply-templates select="name"/> ismindeki çalışanımız
    <xsl:apply-templates select="ancestor::bölüm/ekip"/> ekibindedir.
  </fo:block>
</xsl:template>

Basit bir baştan sıralama yapmak için tek bir örüntünün içinde çok sayıda xsl:apply-templates elemanı kullanılabilir. Aşağıdaki örnekte iki HTML tablosu oluşturulmaktadır. İlk tablo yurtiçi satışlarla, ikinci tablo yurtdışı satışlarla doldurulmaktadır.

<xsl:template match="ürün">
  <table>
    <xsl:apply-templates select="satışlar/yurtiçi"/>
  </table>
  <table>
    <xsl:apply-templates select="satışlar/yurtdışı"/>
  </table>
</xsl:template>

Not:
Biri diğerinin astsalı olan iki astsalla eşleşim mümkündür. Bu özel bir durum olarak ele alınmaz: her iki astsal normal olarak işlenir. Şöyle bir kaynak belgemiz olsun:

<doc><div><div></div></div></doc>

Bu kuralla,

<xsl:template match="doc">
  <xsl:apply-templates select=".//div"/>
</xsl:template>

hem dış div hem de iç div işlenecektir.

Not:
Genellikle, xsl:apply-templates sadece geçerli düğümün astsal düğümlerini işlemekte kullanılır. xsl:apply-templates'in böyle kullanımı bitmeyen işlem döngüleriyle sonuçlanamaz. Bununla birlikte, xsl:apply-templates geçerli düğümün astsalları olmayan elemanları işlemek için kullanıldığında bitmeyen döngülere yol açılması olasıdır. Örnek:

<xsl:template match="foo">
  <xsl:apply-templates select="."/>
</xsl:template>

Gerçeklenimler böyle döngüleri bazı durumlarda saptayabilir, fakat bir biçembentin bir gerçeklenimin saptayamadığı bitmeyen döngülere girme olasılığı mevcuttur. Bu bir hizmet reddi şeklinde bir güvenlik açığını yol açabilir.

5.5 Şablon Kuralları için Uyuşmazlıkların Çözümlenmesi

Bir kaynak düğümün birden fazla örneklenim kuralı ile eşleşmesi olasıdır.Kullanılacak örneklenim kuralı şöyle belirlenir:

  1. Önce tüm eşleşen kurallardan düşük ithal önceliğine sahip olanlar elenir.

  2. Sonra, kalan eşleşen kurallardan düşük işlem önceliğine sahip olanlar elenir. Bir örneklenim kuralının işlem önceliği o örneklenim kuralı üzerinde priority özniteliği ile belirtilir. Değeri bir gerçel sayı (pozitif veya negatif) olmalı ve isteğe bağlı bir eksi imi (-) ile öncelenmiş olarak Sayı sözdizimi ile eşleşmelidir. Öntanımlı işlem önceliği şöyle hesaplanır:

    Bu bakımdan, en bilinen örüntü çeşidinin (bir düğümü belli bir tür veya genişletilmiş isimle sınayan) işlem önceliği 0'dır. Sonraki en özel örüntü çeşidinin (bir düğümü belli bir isim-alanındaki belli bir tür veya genişletilmiş isimle sınayan) işlem önceliği -0.25'tir. Bundan daha az özel (düğümleri sadece belli bir türle sınayan) örüntülerin işlem önceliği -0.5'tir. En bilinen örüntü çeşidinden daha özel örüntülerin işlem önceliği ise 0.5'tir.

Eğer bu elemeden geriye birden fazla eşleşmiş örneklenim kuralı kalıyorsa bu bir hatadır. Bir XSLT işlemci hatayı raporlayabilir; eğer raporlamıyorsa, kalanlardan biçembentte daha sonlarda yer alan örneklenim kuralını seçerek hatadan kurtulmalıdır.

5.6 Örneklenim Kurallarının Geçerli Kılınması

<!-- Grubu: yönerge -->
<xsl:apply-imports />
eleman

İthal edilmiş bir biçembentteki bir örneklenim kuralını geçersiz kılmak için kullanılmış bir örneklenim kuralı (bkz, Şablon Kuralları için Uyuşmazlıkların Çözümlenmesi) geçersiz kılınan örneklenim kuralını xsl:apply-imports elemanını kullanarak çağırabilir.

Bir biçembentin işlenmesi sırasında, herhangi bir anda tek bir geçerli örneklenim kuralı vardır. Bir örneklenim kuralı örüntü eşleştirerek her seçilişinde, kuralın örnekleniminin nesnelleştirilmesi için geçerli örneklenim kuralı haline gelir. Bir xsl:for-each elemanı işleme sokulduğunda geçerli örneklenim kuralı xsl:for-each elemanının içeriğinin nesnelleştirilmesi için tanımsız hale gelir.

xsl:apply-imports elemanı sadece, geçerli örneklenim kuralını içeren biçembente ithal edilmiş olan örneklenim kuralının kullanılarak geçerli düğümün işlenmesini sağlar; düğüm geçerli örneklenim kuralının kipinde işlenir. Geçerli örneklenim kuralı tanımsızken xsl:apply-imports nesnelleştirme için kullanılmaya çalışılırsa bu bir hatadır.

Örneğin, doc.xsl biçembenti example elemanları için şöyle bir örneklenim kuralı içeriyor olsun:

<xsl:template match="example">
  <pre><xsl:apply-templates/></pre>
</xsl:template>

Başka bir biçembent de doc.xsl'i ithal edip example elemanını şöyle ele alıyor olsun:

<xsl:import href="doc.xsl"/>

<xsl:template match="example">
  <div style="border: solid red">
     <xsl:apply-imports/>
  </div>
</xsl:template>

Dönüşümün birleşik etkisi bir example elemanını şu biçime getirir:

<div style="border: solid red"><pre>...</pre></div>

5.7 Kipler

Kipler bir elemanın her seferinde farklı bir sonuç üretmek üzere defalarca işlenmesini mümkün kılar.

xsl:template ve xsl:apply-templates elemanlarının ikisi de isteğe bağlı bir mode özniteliğine sahiptir. mode özniteliğinin değeri bir NitelAd olup Nitelikli Adlar bölümünde açıklandığı gibi yorumlanır. Eğer bir xsl:template elemanı bir match özniteliğine sahip değilse bir mode özniteliğine sahip olmamalıdır. Eğer bir xsl:apply-templates elemanı bir mode özniteliğine sahipse sadece kendi mode özniteliğinin değeriyle aynı mode özniteliğine sahip xsl:template elemanlarındaki örneklenim kuralları uygulanır; eğer bir xsl:apply-templates elemanı bir mode özniteliğine sahip değilse sadece mode özniteliğine sahip olmayan xsl:template elemanlarındaki örneklenim kuralları uygulanır.

5.8 Yerleşik Örneklenim Kuralları

Biçembentte örtük bir örneklenim kuralıyla eşleşen başarılı bir örüntünün yokluğunda işlemlerin ardışık olarak sürmesini sağlayan bir yerleşik örneklenim kuralı vardır. Bu örneklenim kuralı hem eleman düğümlerine hem de kök düğüme uygulanır. Yerleşik örneklenim kuralının eşdeğeri şöyle birşey olurdu:

<xsl:template match="*|/">
  <xsl:apply-templates/>
</xsl:template>

Ayrıca, her kip için de benzer şekilde, biçembentte örtük bir örneklenim kuralıyla eşleşen başarılı bir örüntünün yokluğunda işlemlerin ardışık olarak sürmesini sağlayan bir yerleşik örneklenim kuralı vardır. Bu örneklenim kuralı hem eleman düğümlerine hem de kök düğüme uygulanır. Örneğin, m kipi için yerleşik örneklenim kuralının eşdeğeri şöyle birşey olurdu:

<xsl:template match="*|/" mode="m">
  <xsl:apply-templates mode="m"/>
</xsl:template>

Ayrıca, metin ve öznitelik düğümleri için metinlerin kopyalanmasını sağlayan bir yerleşik örneklenim kuralı vardır:

<xsl:template match="text()|@*">
  <xsl:value-of select="."/>
</xsl:template>

İşlem yönergeleri ve açıklamalar için olan yerleşik örneklenim kuralı hiçbir şey yapmaz:

<xsl:template match="processing-instruction()|comment()"/>

İsim-alanı düğümleri için olan yerleşik örneklenim kuralı da hiçbir şey yapmaz. Bir isim-alanı düğümüyle eşleşen bir örüntü olmayacağı için isim-alanı düğümlerine uygulanan yegane örneklenim kuralı bu yerleşik örneklenim kuralıdır.

Yerleşik örneklenim kuralları biçembentten önce örtük olarak ithal edilmişler gibi ele alınırlar, dolayısıyla tüm diğer örneklenim kurallarından daha düşük ithal önceliğine sahip olurlar. Bu bakımdan biçembent yazarları bir yerleşik örneklenim kuralını biçimbente açıkça bir örneklenim kuralı ekleyerek geçersiz kılabilirler.

6 İsimli Örneklenimler

<!-- Grubu: yönerge -->
<xsl:call-template
  name = nitelikli-ad >
  <!-- İçeriği: <xsl:with-param>* -->
</xsl:call-template>
eleman

Örneklenimler isimleriyle çağrılabilirler. Bir xsl:template elemanı bir name özniteliği ile birlikte bir isimli örneklenim belirtir. name özniteliğinin değeri bir NitelAd olup Nitelikli Adlar bölümünde açıklandığı gibi yorumlanır. Bir xsl:template elemanının name özniteliğine ek olarak bir de match özniteliği olabilir ama bu gerekli değildir. xsl:call-template elemanı bir örneklenimi ismiyle çağırmak için kullanılır; çağrılacak örneklenimi belirtmek için name özniteliğinin kullanımı zorunludur. xsl:apply-templates elemanının aksine, xsl:call-template geçerli düğümü veya geçerli düğüm listesini değiştirmez.

Bir xsl:call-template elemanı tarafından çağrıldığında match, mode ve priority özniteliklerinin xsl:template üzerinde bir etkisi yoktur. Benzer şekilde, xsl:template elemanı xsl:apply-templates elemanı tarafından çağrıldığında name özniteliğinin bir önemi yoktur.

Bir biçembentin aynı ithal önceliğine sahip birden fazla aynı isimde örneklenime sahip olması bir hatadır.

7 Hedef Ağacın Oluşturulması

Bu bölümde hedef ağaç üzerinde düğümleri doğrudan oluşturan yönergeler açıklanmaktadır.

7.1 Elemanların ve Özniteliklerin Oluşturulması

7.1.1 Birebir Hedef Elemanlar

Bir örneklenimde, XSLT isim-alanına ait olmadığı gibi bir ek eleman da (bkz, Eklenti Elemanlar) olmayan bir eleman aynı genişletilmiş isimle bir eleman düğümü oluşturmak üzere nesnelleştirilir. Elemanın içeriği, oluşturulan eleman düğümünün içeriğini vermek için nesnelleştiren bir örneklenimdir. Oluşturulan eleman düğümü, biçembent ağacındaki eleman düğümünde mevcut ancak isimleri XSLT isim-alanından olmayan öznitelik düğümlerine sahip olacaktır.

Oluşturulan eleman düğümü, ayrıca biçembent ağacındaki eleman düğümünde mevcut olan isim-alanı düğümlerinin bir kopyasına sahip olacaktır; kopyanın içinde, dizgesel değeri XSLT isim-alanı tanım-yeri (http://www.w3.org/1999/XSL/Transform), eklenti isim-alanı olarak bildirilmiş bir isim-alanı tanım-yeri (bkz, Eklenti Elemanlar) veya dışlanmış bir isim-alanı olarak belirtilmiş bir isim-alanı tanım-yeri olan isim-alanı düğümleri olmayacaktır. Bir isim-alanı tanım-yeri, xsl:stylesheet elemanının exclude-result-prefixes özniteliği veya birebir hedef elemanın xsl:exclude-result-prefixes özniteliği kullanılarak, dışlanmış bir isim-alanı olarak belirtilir. Bu özniteliklerin ikisinin de değeri boş karakter ayraçlı isim-alanı önekleri listesidir. Öneklerin her birine bağlı isim-alanları birer dışlanmış isim-alanı olarak belirtilmiş olur. exclude-result-prefixes veya xsl:exclude-result-prefixes özniteliğini taşıyan eleman üzerinde öneke bağlı bir isim-alanının olmayışı bir hatadır. Öntanımlı isim-alanı, isim-alanı önekleri listesine #default dizgesi dahil edilerek dışlanmış bir isim-alanı olarak belirtilebilir. Bir isim-alanının dışlanmış bir isim-alanı olarak atanması, exclude-result-prefixes veya xsl:exclude-result-prefixes özniteliğini taşıyan eleman biçembendin kök düğümü olmak üzere, biçembentin alt ağacı içinde etkilidir; kökü bir xsl:stylesheet elemanı olan bir alt ağaç, xsl:stylesheet elemanının çocukları tarafından içerilmiş veya ithal edilmiş bir biçembent içermez.

Not:
Bir biçembent, bir isim-alanı bildirimini sadece kaynak ağacını adreslemek amacıyla kullandığı zaman, önekin exclude-result-prefixes özniteliğinde belirtilmesi hedef ağaçta gereksiz isim-alanı bildirimlerini ortadan kaldıracaktır.

Bir birebir hedef elemanın bir özniteliğinin değeri bir öznitelik değeri örneklenimi olarak yorumlanır: kaşlı ayraçlar ({}) içinde belirtilmiş ifadeler içerir.

Biçembent ağacında, hedef ağaçta bir isim-alanı tanım-yeri belirtmek için kullanılan bir isim-alanı tanım-yerine birebir isim-alanı tanım-yeri denir. Bu şunlara uygulanır:

  • biçembentte bir birebir hedef elemanın genişletilmiş isminde bir isim-alanı tanım-yerine,

  • biçembentte bir birebir hedef elemanında belirtilen bir özniteliğin genişletilmiş isminde bir isim-alanı tanım-yerine,

  • biçembentte bir birebir hedef elemanındaki bir isim-alanı düğümünün dizgesel değerine.

<!-- Grubu: tepe-seviyeden-eleman -->
<xsl:namespace-alias
  stylesheet-prefix = önek | "#default"
  result-prefix = önek | "#default" />
eleman

Bir biçembent xsl:namespace-alias elemanını başka bir isim-alanı tanım-yeri için takma ad olan bir isim-alanı tanım yerini bildirmek için kullanabilir. Bir birebir isim-alanı tanım-yeri başka bir isim-alanı tanım-yeri için bir takma ad olarak bildirildiğinde, hedef ağaçtaki isim-alanı tanım-yeri, birebir isim-alanı tanım-yerinin kendisi için değil onun için bir takma ad olacağı isim-alanı tanım-yeri olacaktır. xsl:namespace-alias elemanı, result-prefix özniteliği tarafından belirtilen öneke bağlı isim-alanı tanım-yeri için bir takma ad olan stylesheet-prefix özniteliği tarafından belirtilen öneke bağlı isim-alanı tanım-yerini bildirir. Bu bakımdan, stylesheet-prefix özniteliği biçembentte görünecek isim-alanı tanım-yerini, result-prefix özniteliği ise hedef ağaçta görünecek diğerinin karşılığı olan isim-alanı tanım-yerini belirtir. Öntanımlı isim-alanı (xmlns ile bildirilen) bir önek yerine #default kullanılarak belirtilebilir. Eğer bir isim-alanı tanım-yeri çok sayıda isim-alanı tanım-yeri için bir takma ad olarak bildirilmişse ithal önceliği en yüksek bildirim kullanılır. Birden fazla böyle bildirim olması bir hatadır. Bir XSLT işlemci hatayı bildirebilir; eğer bildirmiyorsa, en yüksek ithal öncelikli bildirimler arasından biçembendin sonlarına doğru yer alan birini seçerek hatadan kurtulmalıdır.

Birebir hedef elemanlar XSLT isim-alanı tanım-yerini kullanan eleman, öznitelik veya isim-alanı düğümleri oluşturmak için kullanıldıklarında, biçembendin bir takma ad kullanması gerekir. Örneğin,

<xsl:stylesheet
  version="1.0"
  xmlns:xsl="http://www.w3.org/1999/XSL/Transform"
  xmlns:fo="http://www.w3.org/1999/XSL/Format"
  xmlns:axsl="http://www.w3.org/1999/XSL/TransformAlias">

<xsl:namespace-alias stylesheet-prefix="axsl" result-prefix="xsl"/>

<xsl:template match="/">
  <axsl:stylesheet>
    <xsl:apply-templates/>
  </axsl:stylesheet>
</xsl:template>

<xsl:template match="block">
  <axsl:template match="{.}">
     <fo:block><axsl:apply-templates/></fo:block>
  </axsl:template>
</xsl:template>

</xsl:stylesheet>

biçembendi aşağıdaki biçimdeki bir belgeden bir biçembent üretecektir:

<elements>
<block>p</block>
<block>h1</block>
<block>h2</block>
<block>h3</block>
<block>h4</block>
</elements>

Not:
XSLT isim-alanı tanım-yerinden başka isim-alanları için de takma adlar kullanmak gerekli olabilir. Örneğin, sayısal imzalarla iş yapılan bir isim-alanına ait olan birebir sonuç elemanlar, XSLT biçembentlerinin genel amaçlı güvenlik yazılımları tarafından kötü kullanımına sebep olabilir; isim-alanı için bir takma ad kullanımı böyle bir kötü kullanım olasılığını ortadan kaldıracaktır.

7.1.2 Elemanların xsl:element ile Oluşturulması

<!-- Grubu: yönerge -->
<xsl:element
  name = { nitelikli-ad }
  namespace = { tanım-yeri-başvurusu }
  use-attribute-sets = nitelikli-adlar >
  <!-- İçeriği: örneklenim -->
</xsl:element>
eleman

xsl:element elemanı hesaplanmış bir isimle bir eleman oluşturmayı mümkün kılar. Oluşturulacak elemanın genişletilmiş ismi, zorunlu olan name ile seçimlik olan namespace öznitelikleri ile belirtilir. xsl:element elemanının içeriği oluşturulan elemanın çocukları ve öznitelikleri için bir örneklenimdir.

name özniteliği bir öznitelik değeri örneklenimi olarak yorumlanır. Öznitelik değeri örnekleniminin nesnelleştirilmesinin sonucu olan dizgenin bir NitelAd olmaması bir hatadır. Bir XSLT işlemci hatayı raporlayabilir; raporlamıyorsa, xsl:element elemanının nesnelleştirilmesinin sonucunu, baştaki öznitelik düğümleri hariç, xsl:element elemanının içeriğinin nesnelleştirilmesiyle oluşturulan düğüm silsilesi yaparak hatayı ortadan kaldırmalıdır. namespace özniteliği kullanılmamışsa, NitelAd, xsl:element elemanı için etkili olan isim-alanı bildirimleri (öntanımlı isim-alanı bildirimi dahil) kullanılarak bir genişletilmiş isme genişletilir.

Eğer namespace özniteliği kullanılmışsa, o da ayrıca bir öznitelik değeri örneklenimi olarak yorumlanır. Öznitelik değeri örnekleniminin nesnelleştirilmesinin sonucu olan dizge bir tanım-yeri başvurusu olmalıdır. Dizgenin sözdizimsel olarak geçerli bir tanım-yeri başvurusu olmaması bir hata değildir. Eğer dizge boşsa, elemanın genişletilmiş ismi tanımsız isim-alanı tanım-yerine sahip olur. Aksi takdirde, dizge, oluşturulan elemanın genişletilmiş isminin isim-alanı tanım-yeri olarak kullanılır. NitelAd'ın yerel kısmı, oluşturulan elemanın genişletilmiş isminin yerel kısmı olarak kullanılan name özniteliği tarafından belirtilir.

XSLT işlemciler, oluşturulan elemanın XML olarak çıktılanması için kullanılan öneki seçerken, name özniteliğinde belirtilen NitelAdın önekini kullanılır yapabilirler; yine de,bunun böyle olması gerekli değildir.

7.1.3 Özniteliklerin xsl:attribute ile Oluşturulması

<!-- Grubu: yönerge -->
<xsl:attribute
  name = { nitelikli-ad }
  namespace = { tanım-yeri-başvurusu } >
  <!-- İçeriği: örneklenim -->
</xsl:attribute>
eleman

xsl:attribute elemanı biçembentteki birebir hedef elemanlar veya xsl:element gibi yönergeler tarafından oluşturulan hedef elemanlara öznitelikler eklemek için kullanılır. Özniteliğin genişletilmiş ismi belirtilmesi zorunlu name özniteliği ile seçimlik namespace özniteliği tarafından oluşturulur. Bir xsl:attribute elemanının nesnelleştirilmesi, hedef eleman düğümüne bir öznitelik düğümü ekler. xsl:attribute elemanının içeriği oluşturulan özniteliğin değeri için bir örneklenimdir.

name özniteliği bir öznitelik değeri örneklenimi olarak yorumlanır. Öznitelik değeri örnekleniminin nesnelleştirilmesinin sonucu olan dizgenin bir NitelAd olmaması veya xmlns dizgesi olması bir hatadır. Bir XSLT işlemci hatayı raporlayabilir; raporlamıyorsa, özniteliği hedef ağaca eklemeyerek hatayı ortadan kaldırmalıdır. namespace özniteliği kullanılmamışsa, NitelAd, xsl:attribute elemanı için etkili olan isim-alanı bildirimleri (öntanımlı isim-alanı bildirimi hariç) kullanılarak bir genişletilmiş isme genişletilir.

Eğer namespace özniteliği kullanılmışsa, o da ayrıca bir öznitelik değeri örneklenimi olarak yorumlanır. Öznitelik değeri örnekleniminin nesnelleştirilmesinin sonucu olan dizge bir tanım-yeri başvurusu olmalıdır. Dizgenin sözdizimsel olarak geçerli bir tanım-yeri başvurusu olmaması bir hata değildir. Eğer dizge boşsa, özniteliğin genişletilmiş ismi tanımsız isim-alanı tanım-yerine sahip olur. Aksi takdirde, dizge, oluşturulan özniteliğin genişletilmiş isminin isim-alanı tanım-yeri olarak kullanılır. NitelAd'ın yerel kısmı, oluşturulan özniteliğin genişletilmiş isminin yerel kısmı olarak kullanılan name özniteliği tarafından belirtilir.

XSLT işlemciler, oluşturulan özniteliğin XML olarak çıktılanması için kullanılan öneki seçerken, name özniteliğinde belirtilen NitelAdın önekini kullanılır yapabilirler; yine de,bunun böyle olması gerekli değildir. Bu bakımdan,

<xsl:attribute name="xmlns:xsl" namespace="herneyse">
  http://www.w3.org/1999/XSL/Transform
</xsl:attribute>

hatalı olmasa da, bu işlem çıktıda bir isim-alanı bildirimi ile sonuçlanmayacaktır.

Bir özniteliğin bir elemana eklenmesi elemanın mevcut özniteliklerinden genişletilmiş ismi aynı olanını değiştirir.

Aşağıdakilerin hepsi hata ile sonuçlanır:

  • Bir elemana çocukları eklendikten sonra bir özniteliğin eklenmesi; gerçeklenimler bu hatayı bildirebilir ya da özniteliği yoksayabilirler.

  • Bir özniteliğin bir eleman olmayan bir düğüme eklenmesi; gerçeklenimler bu hatayı bildirebilir ya da özniteliği yoksayabilirler.

  • xsl:attribute elemanının nesnelleştirilmesi sırasında metin düğümlerinden farklı düğümlerin oluşturulması; gerçeklenimler bu hatayı bildirebilir ya da hatalı düğümleri içerikleriyle birlikte yoksayabilirler.

Not:
Bir xsl:attribute elemanı satırsonu içeren bir metin düğümü içeriyorsa, XML çıktının bir karakter gönderimi içermesi gerekir. Örneğin,

<xsl:attribute name="a">x
y</xsl:attribute>

kodu şu çıktıyı üretecektir:

a="x&#xA;y"

(veya eşdeğeri bir karakter gönderimi ile). XML çıktı asla şöyle olamaz:

a="x
y"

XML 1.0'ın öznitelik değerlerindeki satırsonu karakterlerini boşluk olarak normalleştirmesi fakat satır sonu karakterlerine yapılan gönderimleri normalleştirmemesi sebebiyle bu böyledir. Veri modelindeki öznitelik değerleri normalleştirme sonrası öznitelik değerleri olarak gösterilir. Eğer bir satırsonu karakteri çıktılanan ağaçtaki bir öznitelik değerinde bir karakter gönderimi olarak değilde kendisi olarak yer alıyorsa, ağaçtaki öznitelik değeri bir satırsonu değil de bir boşluk içerecek şekilde XML'in yeniden çözümlenerek ağacın doğru olarak çıktılanması gerekir.

7.1.4 İsimli Öznitelik Kümeleri

<!-- Grubu: tepe-seviyeden-eleman -->
<xsl:attribute-set
  name = nitelikli-ad
  use-attribute-sets = nitelikli-adlar >
  <!-- İçeriği: <xsl:attribute>* -->
</xsl:attribute-set>
eleman

xsl:attribute-set elemanı bir isimli öznitelik kümesi tanımlar. name özniteliği öznitelik kümesinin ismini belirtir. name özniteliğinin değeri bir NitelAd olup Nitelikli Adlar bölümünde açıklandığı gibi yorumlanır. xsl:attribute-set elemanının içeriği kümedeki öznitelikleri belirten sıfır veya daha fazla sayıda xsl:attribute elemanından oluşur.

Öznitelik kümeleri, bir xsl:element, xsl:copy (bkz, Kopyalama) veya xsl:attribute-set elemanının use-attribute-sets özniteliğinde belirtilerek kullanılırlar. use-attribute-sets özniteliğinin değeri öznitelik kümesi isimlerinin boşluk ayraçlı listesidir. Belirtilen her isim, Nitelikli Adlar bölümünde açıklandığı gibi yorumlanan birer NitelAd olarak belirtilir. Bir use-attribute-sets özniteliğinin belirtilmesi, özniteliğe sahip elemanın içeriğinin başlangıcında isimli öznitelik kümelerinin her birindeki özniteliklerin her biri için (use-attribute-sets özniteliğinde belirtilen öznitelik isimleriyle aynı sırada) bir xsl:attribute elemanı belirtilmesine eşdeğerdir. use-attribute-sets özniteliklerinin xsl:attribute-set elemanlarında doğrudan veya dolaylı olarak kendilerini öznitelik kümesi olarak kullanmaları bir hatadır.

Öznitelik kümeleri ayrıca bir birebir hedef elemanda da bir xsl:use-attribute-sets özniteliği belirterek kullanılabilir. xsl:use-attribute-sets özniteliğinin değeri öznitelik kümesi isimlerinin boşluk ayraçlı bir listesidir. xsl:use-attribute-sets özniteliği tarafından belirtilen xsl:attribute elemanlarından sonra ama asıl xsl:attribute elemanlarından önce yer alan xsl:attribute elemanları tarafından belirtilmiş gibi ele alınan birebir hedef elemanın kendi üzerindeki öznitelikler tarafından belirtilen ek kurallarla birlikte xsl:element üzerindeki use-attribute-sets özniteliği ile xsl:use-attribute-sets özniteliği aynı etkiye sahiptir. Bu bakımdan, bir birebir hedef eleman için, bir xsl:use-attribute-sets özniteliğinde isimleri bulunan öznitelik kümelerindeki öznitelikler önce (ama kümelerin listede yer alış sırasına uygun olarak) eklenecektir; ardından birebir hedef elemanda belirtilen öznitelikler eklenecek; son olarak da, xsl:attribute elemanları tarafından belirtilen öznitelikler eklenecektir. Bir özniteliğin bir elemana eklenmesi, bu elemanın aynı isimdeki mevcut özniteliğini değiştirdiğinden, bu, öznitelik kümelerinde belirtilen öznitelikler, birebir hedef elemanın kendisinde belirtilen öznitelikler tarafından geçersiz kılınabilirler anlamına gelir.

Bir xsl:attribute-set elemanınındaki xsl:attribute elemanlarının her birindeki örneklenimler, öznitelik kümesinin her kullanılışında yeniden nesnelleştirilir; nesnelleştirme, aynı geçerli düğüm ve geçerli düğüm listesi kullanılarak, nesnelleştirme için use-attribute-sets veya xsl:use-attribute-sets özniteliğini taşıyan eleman kullanılıyormuş gibi yapılır. Bununla birlikte, hangi değişken bağıntısının görünür (bkz, Değişkenler ve Değergeçler) olduğunu belirleyen use-attribute-sets veya xsl:use-attribute-sets özniteliğini taşıyan elemandan ziyade biçembentteki xsl:attribute elemanının konumudur; bu bakımdan, sadece tepe-seviyeden xsl:variable ve xsl:param elemanları ile bildirilen değişken ve değergeçler görünürdür.

Aşağıdaki örnekte title-style isimli bir öznitelik kümesi oluşturulmakta ve bir örneklenim kuralında kullanılmaktadır:

<xsl:template match="chapter/heading">
  <fo:block quadding="start" xsl:use-attribute-sets="title-style">
    <xsl:apply-templates/>
  </fo:block>
</xsl:template>

<xsl:attribute-set name="title-style">
  <xsl:attribute name="font-size">12pt</xsl:attribute>
  <xsl:attribute name="font-weight">bold</xsl:attribute>
</xsl:attribute-set>

Bir özniteliğin aynı genişletilmiş isimle çok sayıda tanımı varsa bunlar birleştirilir. Yüksek ithal önceliğine sahip bir öznitelik, düşük ithal önceliğindeki bir özniteliğe göre önceliklidir. Aynı genişletilmiş isimle aynı özniteliği içeren iki öznitelik kümesinin, aynı genişletilmiş isim ve aynı öznitelikle daha yüksek ithal öncelikli bir üçüncünün yokluğunda aynı ithal önceliğine sahip olması bir hatadır. Bir XSLT işlemci bu hatayı raporlayabilir; raporlamıyorsa, biçembentin sonuna doğru yer alan tanımlar arasından daha yüksek işlem önceliğine sahip olanını seçerek hatayı ortadan kaldırabilir. Bir öznitelik kümesinde belirtilen özniteliklerin yeri kümedeki öznitelikler bir birleşmeye konu olduklarında önem kazanır; öznitelik kümeleri kullanılırken bunun bir önemi yoktur. Bir xsl:attribute-set elemanının use-attribute-sets özniteliğinde yer alan her öznitelik kümesi ismi için, aynı isimdeki bir öznitelik kümesinin bütün tanımlarının, use-attribute-sets özniteliği, eşdeğeri olan xsl:attribute çocuk elemanlarıyla değiştirilmeden önce birleştirilmesi gerekir. Bir xsl:attribute-set elemanının use-attribute-sets özniteliğinin eşdeğeri olan xsl:attribute çocuk elemanlarıyla, bu xsl:attribute-set elemanı, aynı genişletilmiş isimli başka bir xsl:attribute-set elemanı ile birleştirilmeden önce değiştirilmesi gerekir. xsl:attribute-set elemanları aynı genişletilmiş isimli olanlarla birleştirildiğinde, bir use-attribute-sets özniteliğine değiştirilmek için eklenen her xsl:attribute çocuk elemanı, biçembentte gerçekten bir çocuk eleman olarak belirtilmiş gibi ele alınır.

7.2 Metin Oluşturma

Bir örneklenim ayrıca metin düğümleri de içerebilir. Bir örneklenimdeki her metin düğümünün boşluk karakterleri Boşluk Ayıklama bölümünde belirtildiği gibi ayıklandıktan sonra kalan dizgeyle hedef ağaçtaki metin düğümü oluşturulur. Bitişik metin düğümleri hedef ağaçta kendiliğinden birleşir.

Metnin ağaç seviyesinde işlendiğine dikkat ediniz. Bu bakımdan, bir örneklenimdeki &lt; imlenimi biçembent ağacında < karakterini içeren bir metin düğümüyle gösterilecektir. Bu, hedef ağaç bir XML belge olarak çıktılandığında, hedef ağaçta (&lt; imlenimi -veya eşdeğeri karakter gönderimi- ile gösterilecek olan) < karakterini içeren bir metin düğümü oluşturacaktır (Çıktı Önceleniminin İptal Edilmesi bölümünde belirtildiği gibi çıktı öncelenimi iptal edilmiş olmadıkça).

<!-- Grubu: yönerge -->
<xsl:text
  disable-output-escaping = "yes" | "no" >
  <!-- İçeriği: #PCDATA -->
</xsl:text>
eleman

Dizgesel sabit veri karakterleri bir xsl:text elemanında satır katlamaya konu olabilir. Satır katlama, boşluk karakterleri ayıklanarak (bkz, Boşluk Ayıklama) değiştirilebilir fakat karakterlerin XSLT işlemci tarafından sonradan nasıl elde edileceğine bir etkisi yoktur.

Not:
xml:lang ve xml:space öznitelikleri XSLT tarafından özel olarak ele alınmaz. Özellikle,

  • hedefte, xml:lang veya xml:space özniteliklerinin üretmesi gerekeni belirtmek doğrudan doğruya biçembent yazarının sorumluluğundadır;

  • XSLT isim-alanındaki bir elemanda xml:lang veya xml:space özniteliğinin belirtilmesi bu özniteliklerin hedefte de yer almasına sebep olmayacaktır.

7.3 İşlem Yönergelerinin Oluşturulması

<!-- Grubu: yönerge -->
<xsl:processing-instruction
  name = { kısa-ad } >
  <!-- İçeriği: örneklenim -->
</xsl:processing-instruction>
eleman

xsl:processing-instruction elemanı, bir işlem yönergesi düğümü oluşturmak için nesnelleştirilir. xsl:processing-instruction elemanının içeriği işlem yönergesi düğümünün dizgesel değeri için bir örneklenimdir. xsl:processing-instruction elemanının, işlem yönergesi düğümünün ismini belirtmek için kullanımı zorunlu olan bir name özniteliği vardır. name özniteliğinin değeri bir öznitelik değeri örneklenimi olarak yorumlanır.

Örneğin, bu:

<xsl:processing-instruction name="xml-stylesheet">
  href="book.css" type="text/css"
</xsl:processing-instruction>

şu işlem yönergesini oluşturacaktır:

<?xml-stylesheet href="book.css" type="text/css"?>

name özniteliğinin nesnelleştirilmesinin sonucu olan dizgenin hem bir KısaAd hem de bir PIHedefi olmaması bir hatadır. Bir XSLT işlemci bu hatayı raporlayabilir; raporlamıyorsa, işlem yönergesini hedef ağaca ekleyerek hatayı ortadan kaldırabilir.

Not:
Bu, xsl:processing-instruction elemanının bir XML bildirimi çıktılamakta kullanılamaması demektir. Yerine xsl:output elemanı kullanılmalıdır (bkz, Çıktı).

xsl:processing-instruction içeriğinin nesnelleştirilmesinin metin düğümünden farklı bir düğüm oluşturması bir hatadır. Bir XSLT işlemci bu hatayı raporlayabilir; raporlamıyorsa, hatalı düğümleri içerikleriyle birlikte yoksayarak hatayı ortadan kaldırabilir.

xsl:processing-instruction içeriğinin nesnelleştirilme sonucunun ?> dizgesini içermesi bir hatadır. Bir XSLT işlemci bu hatayı raporlayabilir; raporlamıyorsa, ? karakteri ile > karakteri arasına bir boşluk yerleştirerek hatayı ortadan kaldırabilir.

7.4 Açıklamaların Oluşturulması

<!-- Grubu: yönerge -->
<xsl:comment>
  <!-- İçeriği: örneklenim -->
</xsl:comment>
eleman

xsl:comment elemanı hedef ağaçta bir açıklama oluşturmak için nesnelleştirilir. xsl:comment elemanının içeriği, açıklama düğümünün dizgesel değeri için bir örneklenimdir.

Örneğin, bu:

<xsl:comment>This file is automatically generated. Do not edit!</xsl:comment>

şu açıklamayı üretecektir:

<!--This file is automatically generated. Do not edit!-->

xsl:comment içeriğinin nesnelleştirilmesinin metin düğümünden farklı bir düğüm oluşturması bir hatadır. Bir XSLT işlemci bu hatayı raporlayabilir; raporlamıyorsa, hatalı düğümleri içerikleriyle birlikte yoksayarak hatayı ortadan kaldırabilir.

xsl:comment içeriğinin nesnelleştirilme sonucunun -- dizgesini içermesi bir hatadır. Bir XSLT işlemci bu hatayı raporlayabilir; raporlamıyorsa, - karakterlerinin arasına bir boşluk yerleştirerek hatayı ortadan kaldırabilir.

7.5 Kopyalama

<!-- Grubu: yönerge -->
<xsl:copy
  use-attribute-sets = nitelikli-adlar >
  <!-- İçeriği: örneklenim -->
</xsl:copy>
eleman

xsl:copy elemanı, geçerli düğümün kopyalanmasını kolaylaştıran bir yol sağlar. xsl:copy elemanının nesnelleştirilmesi, geçerli düğümün bir kopyasını oluşturur. Geçerli düğümün isim-alanı düğümleri de kendiliğinden kopyalanır, fakat öznitelikler ve düğümün çocukları kendiliklerinden kopyalanmazlar. xsl:copy elemanının içeriği, oluşturulan düğümün öznitelikleri ve çocukları için bir örneklenimdir; içerik sadece özniteliklerin ve çocukların sahip olabileceği türdeki düğümler için nesnelleştirilir (örn, kök düğüm ve eleman düğümleri için).

xsl:copy elemanı bir use-attribute-sets özniteliğine sahip olabilir (bkz, İsimli Öznitelik Kümeleri). Bu sadece eleman düğümleri kopyalanırken kullanılır.

Kök düğüm özel olarak ele alınır, çünkü hedef ağacın kök düğümü örtük olarak oluşturulur. Geçerli düğüm, kök düğüm olduğu takdirde, xsl:copy bir kök düğüm oluşturmayacak, sadece içerik örneklenimini kullanacaktır.

Örneğin, özdeşlik dönüşümü xsl:copy kullanılarak şöyle yazılabilir:

<xsl:template match="@*|node()">
  <xsl:copy>
    <xsl:apply-templates select="@*|node()"/>
  </xsl:copy>
</xsl:template>

Geçerli düğüm bir öznitelik olduğunda, geçerli düğümle aynı isimde bir öznitelik oluşturmak için xsl:attribute kullanmak bir hata olsaydı, xsl:copy kullanmak da bir hata olurdu (bkz, Özniteliklerin xsl:attribute ile Oluşturulması).

Aşağıdaki örnekte, xml:lang özniteliklerinin nasıl kolayca kaynaktan hedefe kopyalanabileceği gösterilmiştir. Bir biçembent şöyle bir isimli örneklenim tanımlasaydı:

<xsl:template name="apply-templates-copy-lang">
 <xsl:for-each select="@xml:lang">
   <xsl:copy/>
 </xsl:for-each>
 <xsl:apply-templates/>
</xsl:template>

xml:lang özniteliği kopyalanmak istendiği takdirde, bunun yerine:

<xsl:apply-templates/>

bu daha basit olurdu:

<xsl:call-template name="apply-templates-copy-lang"/>

Geçerli düğüm bir isim-alanı düğümü olduğu takdirde, kopyalama işlemi, hedef ağaçta içerilen düğüme bir isim-alanı düğümü ekler. Bunun içerildiği düğümün bir eleman olmaması bir hatadır; gerçeklenimler hatayı raporlayabilir veya isim-alanı düğümünü yoksayabilir. Bir isim-alanı düğümünü bir elemana çocuklarını veya özniteliklerini eklendikten sonra eklemek bir hatadır; gerçeklenimler hatayı raporlayabilir veya isim-alanı düğümünü yoksayabilir. Bir isim-alanı düğümünü, aynı isimde bir isim-alanına zaten sahip olan bir elemana eklemek, her iki isim-alanı düğümü aynı dizgesel değere sahip olmadıkça (bu durumda yineleme yok sayılır), bir hatadır. Bir isim-alanı düğümünü bir elemana eklemek, eğer isim-alanı düğümünün ismi tanımsızsa ve eleman bir tanımsız isim-alanı tanım-yerine sahipse, bir hatadır.

7.6 Üretilen Metnin Hesaplanması

Bir örneklenim içinde, xsl:value-of elemanı üretilen metni hesaplamakta kullanılabilir; örneğin, metni kaynak ağaçtan çekip çıkarmak veya bir değişkene bir değer yerleştirmek için kullanılabilir. xsl:value-of elemanı bunu, select özniteliğine değer olarak belirtilen bir ifade ile yapar. İfadeler ayrıca, birebir hedef elemanların öznitelikleri içinde kaşlı ayraçlarla ({}) sarmalanarak kullanılabilir.

7.6.1 Metnin xsl:value-of ile Üretilmesi

<!-- Grubu: yönerge -->
<xsl:value-of
  select = dizgesel-ifade
  disable-output-escaping = "yes" | "no" />
eleman

xsl:value-of elemanı hedef ağaçta bir metin düğümü oluşturmak için nesnelleştirilir. Belirtilmesi zorunlu olan select özniteliği bir ifade olup değerlendirilmesiyle elde edilen nesne string işlevi çağrılmış gibi bir dizgeye dönüştürülür. Bu dizge oluşturulan metin düğümünün dizgesel değerini belirtir. Dizge boşsa bir metin düğümü oluşturulmaz. Oluşturulan metin düğümü bitişik metin düğümü komşuları ile birleşir.

xsl:copy-of elemanı bir düğüm kümesini bir dizgeye dönüştürmeksizin hedef ağaca kopyalamak için kullanılabilir. Daha fazla bilgi için Değişken ve Değergeçlerin Değerlerinin xsl:copy-of ile Kullanımı bölümüne bakınız.

Aşağıdaki örnekte, adı ve soyadı özniteliklerine sahip kişi elemanından bir HTML paragrafı oluşturulmaktadır. Paragraf geçerli düğümün adı ve soyadı özniteliklerinin değerleri arasında bir boşluk karakteri içerecektir.

<xsl:template match="kişi">
  <p>
   <xsl:value-of select="@adı"/>
   <xsl:text> </xsl:text>
   <xsl:value-of select="@soyadı"/>
  </p>
</xsl:template>

Başka bir örnek olarak aşağıda aynı paragraf kişi elemanının adı ve soyadı çocuk elemanlarının dizgesel değerleri ile oluşturulmaktadır.

<xsl:template match="kişi">
  <p>
   <xsl:value-of select="adı"/>
   <xsl:text> </xsl:text>
   <xsl:value-of select="soyadı"/>
  </p>
</xsl:template>

Aşağıdaki örnekte, her işlem elemanı için metnin başına işlemin güvenlik seviyesini belirten bir paragraf yerleştirilmektedir. Burada, işleme uygulanacak güvenlik seviyesinin işlem elemanının kendisindeki veya bir üstselindeki güvenlik özniteliğinden elde edildiği kabul edilmektedir. Eğer birden fazla güvenlik özniteliği belirtilmişse işleme en yakın elemanın güvenlik özniteliğinin değeri kullanılmaktadır.

<xsl:template match="işlem">
  <fo:block>
    <xsl:value-of select="ancestor-or-self::*[@güvenlik][1]/@güvenlik"/>
  </fo:block>
  <xsl:apply-templates/>
</xsl:template>

7.6.2 Öznitelik Değeri Örneklenimleri

Bir öznitelik değeri örneklenimi olarak yorumlanan bir öznitelik değerinde, örneğin, bir birebir hedef elemanın bir özniteliğinin değeri olarak, bir ifade kaşlı ayraçlar ({}) arasında kullanılabilir. Öznitelik değeri örneklenimi, kaşlı ayraçlarla birlikte ifadenin yerine, ifadenin değerlendirilme sonucunun string işlevi çağrılmış gibi bir dizgeye dönüştürülmesiyle elde edilen dizge yerleştirilerek nesnelleştirilir. Bir XSLT biçembendinde bir öznitelik değerindeki kaşlı ayraçların, öznitelik özellikle, bir öznitelik değeri örneklenimi olarak yorumlanan bir öznitelik olmadıkça özel bir anlamı yoktur; eleman sözdizimi özetinde, böyle özniteliklerin değeri kaşlı ayraçlarla sarmalanır.

Not:
Tüm öznitelikler birer öznitelik değeri örneklenimi olarak yorumlanmaz. Değeri bir ifade veya örüntü olan öznitelikler, tepe-seviyeden elemanların öznitelikleri ve isimli XSLT nesnelerine atıfta bulunan öznitelikler öznitelik değeri örneklenimi olarak yorumlanmaz. Ek olarak, xmlns öznitelikleri de öznitelik değeri örneklenimi olarak yorumlanmaz; çünkü yorumlansaydı XML İsim-alanları Önergesi ile uyumluluk sağlanamazdı.

Aşağıdaki örnekte, kaynak içeriğindeki photograph elemanından bir img hedef elemanı oluşturulmaktadır; img elemanının src özniteliğinin değeri image-dir değişkeninin değerinden ve photograph elemanının href çocuğunun dizgesel değerinden hesaplanmakta; width özniteliğinin değeri ise, photograph elemanının size çocuğunun width özniteliğinin değerinden hesaplanmaktadır:

<xsl:variable name="image-dir">/images</xsl:variable>

<xsl:template match="photograph">
<img src="{$image-dir}/{href}" width="{size/@width}"/>
</xsl:template>

biçembendi ile

<photograph>
  <href>headquarters.jpg</href>
  <size width="300"/>
</photograph>

kaynak içeriğinden hedef ağaçta

<img src="/images/headquarters.jpg" width="300"/>

düğümü elde edilmektedir.

Bir öznitelik değeri örneklenimi nesnelleştirildiğinde, ifadeyi sarmalayan kaşlı ayraçlar çifter çifter ise bunlar birer kaşlı ayraç olarak ele alınır. Bir öznitelik değeri örnekleniminin ifadesi içinde bir kapatan kaşlı ayracın yer alıp, ifadenin dışında kapatan kaşlı ayracın bulunmaması bir hatadır. Bir ifadedeki bir DizgeselSabit içinde yer alan bir kapatan kaşlı ayraç ifadeyi sonlandıran kaşlı ayraç olarak ele alınmaz.

İfadelerin içindeki kaşlı ayraçlar tanınmazlar. Örneğin, buna

<a href="#{id({@ref})/title}">

izin verilmez. Yerine bunu kullanın:

<a href="#{id(@ref)/title}">

7.7 Numaralama

<!-- Grubu: yönerge -->
<xsl:number
  level = "single" | "multiple" | "any"
  count = örüntü
  from = örüntü
  value = sayısal-ifade
  format = { dizge }
  lang = { ad-dizgeciği }
  letter-value = { "alphabetic" | "traditional" }
  grouping-separator = { karakter }
  grouping-size = { sayı } />
eleman

xsl:number elemanı hedef ağaca biçimli bir numara yerleştirmek için kullanılır. Yerleştirilecek numara bir ifade tarafından belirtilir. Bu ifadeyi value özniteliği içerir. İfadenin değerlendirilmesinin sonucu olan nesne number işlevi çağrılmış gibi bir sayıya dönüştürülür. Sayının NaN, sonsuz veya 0.5'ten küçük olması bir hatadır; bir XSLT işlemci bu hatayı raporlayabilir; raporlamıyorsa, sayıyı string işlevi çağrılmış gibi dizgeye dönüştürüp hedef ağaca yerleştirerek hatayı ortadan kaldırmalıdır. Aksi takdirde, sayı bir tamsayıya yuvarlanır ve Sayıdan Dizgeye Dönüşüm Öznitelikleri bölümünde belirtilen öznitelikler kullanılarak bir dizgeye dönüştürülür; bu bağlamda, bu özniteliklerin her birinin değeri, bir öznitelik değeri örneklenimi olarak yorumlanır. Dönüşümden sonra, elde edilen dizge hedef ağaca yerleştirilir. Örneğin, aşağıda sıralı bir listenin üyeleri numaralanmaktadır:

<xsl:template match="items">
  <xsl:for-each select="item">
    <xsl:sort select="."/>
    <p>
      <xsl:number value="position()" format="1. "/>
      <xsl:value-of select="."/>
    </p>
  </xsl:for-each>
</xsl:template>

Eğer value özniteliği belirtilmezse, xsl:number elemanı geçerli düğümün kaynak ağacındaki konumuna karşılık gelen sayıyı bir numara olarak hedef ağaca yerleştirir. Aşağıdaki öznitelikler geçerli düğümün nasıl numaralanacağını denetler:

  • level özniteliğinde kaynak ağacın hangi seviyelerde ele alınacağı belirtilir; değer olarak single, multiple veya any belirtilebilir. single değeri öntanımlı değerdir.

  • count özniteliğinin değeri, bu seviyelerdeki hangi düğümlerin sayılacağını belirten bir örüntüdür. count özniteliği belirtilmezse, geçerli düğümle aynı türdeki düğümle eşleşen örüntü öntanımlı değerdir; eğer geçerli düğüm bir genişletilmiş isme sahipse, öntanımlı örüntü geçerli düğümle aynı genişletilmiş isme sahip düğümle eşleşecektir.

  • from özniteliğinin değeri, sayımın nereden başlatılacağını belirten bir örüntüdür.

Ek olarak, Sayıdan Dizgeye Dönüşüm Öznitelikleri bölümünde belirtilen öznitelikler, value özniteliğinin belirtilmesi halinde sayıyı dizgeye dönüştürmek için kullanılırlar.

xsl:number elemanı önce level, count ve from özniteliklerini kullanarak bir liste oluşturur:

  • level="single" olduğu takdirde, count örüntüsü ile eşleşen ancestor-or-self dalındaki ilk düğüme gidilir ve count örüntüsü ile eşleşen üstselin büyük kardeşinin numarası artı bir değerini içeren tek üyeli bir liste oluşturulur. Eğer böyle bir üstsel yoksa, boş liste oluşur. Eğer from özniteliği belirtilmişse, sadece, from örüntüsüyle eşleşen en yakın üstselin astsalları olan üstseller araştırılır. Burada büyük kardeşlerle, preceding-sibling dalı kastedilmektedir.

  • level="multiple" olduğu takdirde, geçerli düğümün, sırada kendisinin de bulunduğu, tüm üstsellerinin belge sırasına göre bir listesi oluşturulur; sonra, bu listeden count örüntüsü ile eşleşen düğümler seçilir; ardından, listenin her düğümüne, count örüntüsü ile eşleşen düğümün büyük kardeşinin numarası artı bir değeri eşlenir. Eğer from özniteliği belirtilmişse, sadece, from örüntüsüyle eşleşen en yakın üstselin astsalları olan üstseller araştırılır. Burada büyük kardeşlerle, preceding-sibling dalı kastedilmektedir.

  • level="any" olduğu takdirde, geçerli düğümü içeren kümeye ait olan düğümler artı count örüntüsü ile eşleşen düğümler artı belgedeki sıraya göre geçerli düğümden önce yer alan her seviyeden (isim-alanı ve öznitelik düğümleri hariç) tüm düğümlerin sayısı toplamını içeren tek üyeli bir liste oluşturulur (başka bir deyişle, preceding ve ancestor-or-self dallarının üyelerinin hepsi). Hiç eşleşen düğüm yoksa, boş liste oluşur. from özniteliği belirtilmişse, sadece geçerli düğümden önceki ilk düğümden sonraki düğümlerin from örüntüsü ile eşleştiği varsayılır.

Bundan sonra, numara listesi Sayıdan Dizgeye Dönüşüm Öznitelikleri bölümünde belirtilen öznitelikler kullanılarak bir dizgeye dönüştürülür; bu bağlamda, bu özniteliklerin her birinin değeri, bir öznitelik değeri örneklenimi olarak yorumlanır. Dönüşümden sonra, elde edilen dizge hedef ağaca yerleştirilir.

Aşağıda numaralı bir listenin üyeleri numaralanmaktadır:

<xsl:template match="ol/item">
  <fo:block>
    <xsl:number/><xsl:text>. </xsl:text><xsl:apply-templates/>
  </fo:block>
<xsl:template>

Aşağıdaki iki kural başlık elemanlarını numaralayacaktır. Anabölüm ve ekbölümlerden oluşan bir belgede, anabölümlerin ve ekbölümlerin bölümlere, bu bölümlerinde altbölümlere sahip olduğu düşünülerek, anabölümler 1, 2, 3; ekbölümler A, B, C; anabölüm bölümleri 1.1, 1.2, 1.3; ve ekbölüm bölümlerinin de A.1, A.2, A.3 biçiminde numaralanacakları düşünülmüştür.

<xsl:template match="başlık">
  <fo:block>
     <xsl:number level="multiple"
                 count="anabölüm|bölüm|altbölüm"
                 format="1.1 "/>
     <xsl:apply-templates/>
  </fo:block>
</xsl:template>

<xsl:template match="ekbölüm//başlık" priority="1">
  <fo:block>
     <xsl:number level="multiple"
                 count="ekbölüm|bölüm|altbölüm"
                 format="A.1 "/>
     <xsl:apply-templates/>
  </fo:block>
</xsl:template>

Aşağıdaki örnekte bir anabölüm içindeki notlar numaralanmaktadır:

<xsl:template match="not">
  <fo:block>
     <xsl:number level="any" from="anabölüm" format="(1) "/>
     <xsl:apply-templates/>
  </fo:block>
</xsl:template>

Aşağıdaki örnekte HTML'deki H4 elemanları üç parçalı bir madde başlığı ile numaralanmaktadır:

<xsl:template match="H4">
 <fo:block>
   <xsl:number level="any" from="H1" count="H2"/>
   <xsl:text>.</xsl:text>
   <xsl:number level="any" from="H2" count="H3"/>
   <xsl:text>.</xsl:text>
   <xsl:number level="any" from="H3" count="H4"/>
   <xsl:text> </xsl:text>
   <xsl:apply-templates/>
 </fo:block>
</xsl:template>

7.7.1 Sayıdan Dizgeye Dönüşüm Öznitelikleri

Aşağıdaki öznitelikler bir numara listesinin dizgeye dönüşümünü denetlemekte kullanılırlar. Numaralar sıfırdan büyük tamsayılardır. Özniteliklerin hepsi isteğe bağlıdır.

Ana öznitelik format olup öntanımlı değeri 1'dir. format özniteliği bir dizgecik dizisine bölünmüştür; buradaki her dizgecik ya olası en çok sayıda abecesayısal karakterden ya da olası en çok sayıda abecesayısal olmayan karakterden oluşur. Abecesayısal, Unicode kategorileri Nd, Nl, No, Lu, Ll, Lt, Lm veya Lo olan karakterler anlamındadır. Abecesayısal dizgecikler (biçim dizgecikleri) listedeki her numara için kullanılacak biçimi belirtirler. Eğer ilk dizgecik bir abecesayısal olmayan dizgecikse, oluşturulacak dizge bu dizgecikle başlar; eğer son dizgecik bir abecesayısal olmayan dizgecikse, oluşturulacak dizge bu dizgecikle biter. İki biçim dizgesi arasında yer alan abecesayısal olmayan dizgecikler, listedeki numaraları birbirine bağlamakta kullanılan ayraçlardır. n'inci biçim dizgesi listedeki n'inci numarayı biçimlemekte kullanılır. Eğer biçim dizgeciklerinden daha fazla numara varsa, son biçim dizgeciği kalan numaraları biçimlemekte kullanılır. Hiç biçim dizgeciği yoksa, bütün numaraları biçimlemek için biçim dizgeciği olarak 1 kullanılır. Biçim dizgeciği 1 sayısını göstermekte kullanılacak dizgeciği belirtir. İlkinden sonraki her numara, önceki numaradan ayraç dizgeciği ile ayrılır. Bir ayraç dizgeciği yoksa . (nokta) kullanılır.

Biçim dizgecikleri, HTML 4.0'daki OL elemanının type özniteliği için izin verilen değerlerin bir üstkümesidir ve şöyle yorumlanır:

  • Eğer bir biçim dizgeciğinin son karakterinin onluk rakam değeri 1 (Unicode karakter varlığı veritabanında belirtildiği gibi) ise ve sondan önceki karakterlerin Unicode değeri son karakterin Unicode değerinden 1 azsa o zaman bu dizgeciğe göre biçimlenen herhangi bir sayının onluk gösterimi en az biçim dizgeciği uzunluğundadır. Bu bakımdan, 1 biçim dizgeciği 1 2 ... 10 11 12 ... dizisini üretirken, 01 biçim dizgeciği 01 02 ... 09 10 11 12 ... 99 100 101 dizisini üretecektir.

  • A biçim dizgeciği A B C ... Z AA AB AC... dizisini üretir.

  • a biçim dizgeciği a b c ... z aa ab ac... dizisini üretir.

  • i biçim dizgeciği i ii iii iv v vi vii viii ix x ... dizisini üretir.

  • I biçim dizgeciği I II III IV V VI VII VIII IX X ... dizisini üretir.

  • Bunlar dışında herhangi bir biçim dizgeciği o dizgecikle başlayan bir dizi üretir. Bu numaralama dizisini desteklemeyen gerçeklenimler 1 biçim dizgeciğini kullanmalıdır.

Bir abecesayısal dizi numaralanırken, lang özniteliği hangi dilin elifbasının kullanılacağını belirtir; xml:lang [XML] ile aynı aralıktaki değerler kullanılır; hiç lang değeri belirtilmemişse, dil, sistem ortamından saptanır. Gerçeklenimciler hangi dili desteklediklerini belgelemelidirler.

Not:
Gerçeklenimciler belli bir dilde nasıl numaralama yapılacağına ilişkin herhangi bir kabulde bulunmamalıdırlar ve desteklemek istedikleri dilleri gerektiği gibi araştırmalıdırlar. Çoğu dilin numaralama uzlaşımları İngilizce'dekinden çok farklıdır.

letter-value özniteliği, harflerin kullanıldığı numaralama dizileri arasındaki belirsizliği ortadan kaldırır. Çoğu dilde, harflerin kullanıldığı numaralama dizileri başlıca iki çeşittir. Birinde, harflere abecesel sıraya göre sayısal değer atanırken, diğerinde sayısal değerler dildeki geleneksel anlamlandırmaya göre atanırlar. İngilizce'de bu iki çeşide ait biçim dizgecikleri a ve i'dir. Bazı dillerde dizilerin ilk üyesi aynıdır ve dolayısıyla biçim dizgeciği tek başına belirleyici olmaz. alphabetic değeri abecesel sıralamayı, traditional değeri ise diğer sıralamayı belirtir. Eğer letter-value özniteliği belirtilmemişse, belirsizliğin nasıl çözümleneceği gerçeklenime bağlıdır.

Not:
İki uyumlu XSLT işlemcisinin bir sayıyı tamamen aynı dizgeye dönüştürmemesi olasıdır. Bazı XSLT işlemci bazı dilleri desteklemeyebilir. Bundan başka, belli bir dildeki biçim çeşitlemelerini gerçekleştirecek dönüşümleri belirtmek için xsl:number öznitelikleri yeterli olmayabilir. Gerçeklenimler, bunun için xsl:number üzerinde gerçeklenime özgü isim-alanlı öznitelikler kullanabilirler.

grouping-separator özniteliği onluk numaralama dizilerinde gruplama ayracı (binler ayracı gibi) olarak kullanılacak bir ayraç belirtilebilmesini ve isteğe bağlı olan grouping-size özniteliği ise ile gruplama miktarının (normalde 3'tür) belirtilebilmesini mümkün kılar. Örneğin, grouping-separator="," ve grouping-size="3" belirtimi 1,000,000 biçiminde bir sayı üretecektir. Bu ikisinden biri tek başına kullanılırsa yoksayılır.

Bazı dönüşüm belirtimi örnekleri:

  • format="&#x30A2;" Katakana numaralaması belirtir

  • format="&#x30A4;" Katakana numaralamasını "iroha" sıralamasıyla belirtir

  • format="&#x0E51;" Tay rakamlı numaralama belirtir

  • format="&#x05D0;" letter-value="traditional" İbranice "geleneksel" numaralama belirtir

  • format="&#x10D0;" letter-value="traditional" Gürcü tarzı numaralama belirtir

  • format="&#x03B1;" letter-value="traditional" "klasik" Yunan numaralaması belirtir

  • format="&#x0430;" letter-value="traditional" eski Slav tarzı numaralama belirtir

8 Yineleme

<!-- Grubu: yönerge -->
<xsl:for-each
  select = düğüm-kümesi-ifadesi >
  <!-- İçeriği: (<xsl:sort>*, örneklenim) -->
</xsl:for-each>
eleman

Sonucun düzenli bir yapıda olacağı biliniyorsa, örneklenimde doğrudan düğümleri seçmek daha kullanışlıdır. xsl:for-each yönergesi, select özniteliğinde belirtilen ifadeye göre seçilen her düğümü nesnelleştiren bir örneklenim içerir. select özniteliğinin kullanılması zorunludur. İfadeden bir düğüm kümesi elde edilmelidir. Örneklenim seçilen düğümleri birer geçerli düğüm olarak, tamamını da bir geçerli düğüm listesi olarak nesnelleştirir. Bir sıralama belirtilmedikçe düğümler belgedeki sıralarına göre işlenirler (bkz, Sıralama).

Örneğin, bir XML belge şu yapıda olsun:

<müşteriler>
  <müşteri>
    <isim>...</isim>
    <sipariş>...</sipariş>
    <sipariş>...</sipariş>
  </müşteri>
  <müşteri>
    <isim>...</isim>
    <sipariş>...</sipariş>
    <sipariş>...</sipariş>
  </müşteri>
</customers>

Aşağıdaki kod her müşteri elemanı için bir satır bulunan bir tablo içeren bir HTML belge oluşturacaktır:

<xsl:template match="/">
  <html>
    <head>
      <title>Müşteriler</title>
    </head>
    <body>
      <table>
        <tbody>
          <xsl:for-each select="müşteriler/müşteri">
            <tr>
              <th>
                <xsl:apply-templates select="isim"/>
              </th>
              <xsl:for-each select="sipariş">
                <td>
                  <xsl:apply-templates/>
                </td>
              </xsl:for-each>
            </tr>
          </xsl:for-each>
        </tbody>
      </table>
    </body>
  </html>
</xsl:template>

9 Koşullu İşlem

XSLT'de bir örneklenim içinde koşullu işlemi destekleyen iki yönerge vardır: xsl:if ve xsl:choose. xsl:if yönergesi basit if-then koşullu işlemi içindir; xsl:choose yönergesi ise çeşitli olasılıklardan birinin seçilebilmesini sağlar.

9.1 xsl:if ile Koşullu İşlem

<!-- Grubu: yönerge -->
<xsl:if
  test = mantıksal-ifade >
  <!-- İçeriği: örneklenim -->
</xsl:if>
eleman

xsl:if elemanı ifade belirtmekte kullanılan bir test özniteliğine sahiptir. İfade değerlendirildikten sonra elde edilen sonuç boolean işlevinin yaptığı gibi bir mantıksal değere dönüştürülür. Eğer sonuç doğruysa, elemanının içeriğindeki örneklenim nesnelleştirilir; aksi takdirde, hiçbir şey yapılmaz. Aşağıdaki örnekte, bir isim grubundaki isimler bir virgül ayraçlı liste haline getirilmektedir:

<xsl:template match="isimlistesi/isim">
  <xsl:apply-templates/>
  <xsl:if test="not(position()=last())">, </xsl:if>
</xsl:template>

Bu örnekte bir tablonun satırları birer atlayarak sarıya boyanmaktadır:

<xsl:template match="item">
  <tr>
    <xsl:if test="position() mod 2 = 0">
       <xsl:attribute name="bgcolor">yellow</xsl:attribute>
    </xsl:if>
    <xsl:apply-templates/>
  </tr>
</xsl:template>

9.2 xsl:choose ile Koşullu İşlem

<!-- Grubu: yönerge -->
<xsl:choose>
  <!-- İçeriği: (<xsl:when>+ | <xsl:otherwise>?) -->
</xsl:choose>
eleman
<xsl:when
  test = mantıksal-ifade >
  <!-- İçeriği: örneklenim -->
</xsl:when>
eleman
<xsl:otherwise>
  <!-- İçeriği: örneklenim -->
</xsl:otherwise>
eleman

xsl:choose elemanı bir miktar olasılık arasından uygun olanını seçer. Bir veya daha fazla sayıda xsl:when elemanı ile varlığı isteği bağlı olan xsl:otherwise elemanını içerebilir. Her xsl:when elemanının bir ifade belirtmekte kullanılan tek bir test özniteliği vardır. xsl:when ve xsl:otherwise elemanlarının içerikleri birer örneklenimdir. Bir xsl:choose elemanı işleme sokulduğunda, xsl:when elemanlarının içerdiği ifadeler sırayla değerlendirilip elde edilen sonuçlar boolean işlevinin yaptığı gibi birer mantıksal değere dönüştürülerek denenir. xsl:when elemanlarından doğru sonucu veren ilkinin içeriği nesnelleştirilir, diğerlerine bakılmaz. Eğer hiçbir xsl:when elemanı doğru sonuç vermemişse, xsl:otherwise elemanının içeriği nesnelleştirilir. Eğer hiçbir xsl:when elemanı doğru sonuç vermemişse ve xsl:otherwise elemanı da yoksa hiçbir nesnelleştirme yapılmaz.

Aşağıdaki örnekte, alt listeleri de olan sıralı bir listenin üyeleri, alt liste derinliğine bağlı olarak arap rakamları, harfler ve yunan rakamları kullanılarak numaralanmaktadır:

<xsl:template match="orderedlist/listitem">
  <fo:list-item indent-start='2pi'>
    <fo:list-item-label>
      <xsl:variable name="level"
                    select="count(ancestor::orderedlist) mod 3"/>
      <xsl:choose>
        <xsl:when test='$level=1'>
          <xsl:number format="i"/>
        </xsl:when>
        <xsl:when test='$level=2'>
          <xsl:number format="a"/>
        </xsl:when>
        <xsl:otherwise>
          <xsl:number format="1"/>
        </xsl:otherwise>
      </xsl:choose>
      <xsl:text>. </xsl:text>
    </fo:list-item-label>
    <fo:list-item-body>
      <xsl:apply-templates/>
    </fo:list-item-body>
  </fo:list-item>
</xsl:template>

10 Sıralama

<xsl:sort
  select = dizgesel-ifade
  lang = { ad-dizgeciği }
  data-type = { "text" | "number" | nitelikli-ad-ama-kısa-ad-değil }
  order = { "ascending" | "descending" }
  case-order = { "upper-first" | "lower-first" } />
eleman

Sıralama, bir xsl:apply-templates veya xsl:for-each elemanının çocukları olarak xsl:sort elemanları kullanılarak belirtilir. İlk xsl:sort birincil sıralama anahtarını, ikincisi ikincil olanını belirtir ve bu böyle çoğaltılabilir. Bir xsl:apply-templates veya xsl:for-each elemanının çocukları olarak bir veya daha fazla sayıda xsl:sort elemanı olduğu takdirde, seçilen düğümler belgedeki sıralarına göre değil, sıralama anahtarları ile belirtilen sıraya göre işlenirler. xsl:sort elemanları xsl:for-each elemanında kullanıldıklarında, ilk çocuklar olmalıdırlar. Bir örneklenimin xsl:apply-templates veya xsl:for-each elemanı tarafından nesnelleştirilmesi halinde, geçerli düğüm listesinin düğümleri xsl:sort elemanları tarafından belirtilen sıraya göre sıralanırlar.

xsl:sort elemanının bir ifade belirtmekte kullanılan bir select özniteliği vardır. İşlenen her düğüm için, düğüm geçerli düğüm kabul edilerek ve işlenen bütün düğümler için, belgedeki sırasıyla bu düğümlerin tamamı geçerli düğüm listesi kabul edilerek ifade değerlendirilir. Elde edilen nesne string işlevinin yaptığı gibi bir dizgeye dönüştürülür; bu dizge düğüm için sıralama anahtarı olarak kullanılır. select özniteliğini öntanımlı değeri . olup, sıralama anahtarı olarak geçerli düğümün dizgesel değerinin kullanılmasına sebep olur.

Bu dizge düğüm için bir sıralama anahtarı işlevini görür. Aşağıdaki isteğe bağlı öznitelikler xsl:sort üzerinde sıralama anahtarları listesinin nasıl sıralanacağını denetlerler; bu özniteliklerin değerleri birer öznitelik değeri örneklenimi olarak yorumlanır.

Not:
İki uyumlu XSLT işlemcinin tamamen aynı sıralamayı yapmaması olasıdır. Bazı XSLT işlemciler bazı dilleri desteklemeyebilir. Bundan başka, bazı diller için xsl:sort öznitelikleriyle elde edilemeyecek kadar çeşitli sıralamalar olası olabilir; örneğin, Japonca'da sıralamanın Hiragana mı yoksa Katakana mı olacağı gibi. XSLT'nin ileri sürümlerinde bu olasılıklar üzerinde denetim sağlayacak ek öznitelikler sağlanabilir. Gerçeklenimler ayrıca, bunun için xsl:sort üzerinde gerçeklenime özel isim-alanlı öznitelikler kullanabilirler.

Not:
Gerçeklenimcilerin uluslararası sıralama hakkında bilgi edinmek için [UNICODE TR10]'u incelemeleri önerilir.

Sıralama kararlı olmalıdır: sıralı düğüm listesinde sıralama anahtarı belirtilmiş her alt listenin üyelerinin belgedeki sıraya göre eş sırada ele alınmaları gerekir.

Örneğin, şu biçimde düzenlenmiş bir çalışanlar veritabanımız olsun:

<çalışanlar>
  <çalışan>
    <isim>
      <önadı>James</önadı>
      <soyadı>Clark</soyadı>
    </isim>
    ...
  </çalışan>
</çalışanlar>

İsme göre sıralı çalışanlar listesini üretecek kod şöyle olurdu:

<xsl:template match="çalışanlar">
  <ul>
    <xsl:apply-templates select="çalışan">
      <xsl:sort select="isim/soyadı"/>
      <xsl:sort select="isim/önadı"/>
    </xsl:apply-templates>
  </ul>
</xsl:template>

<xsl:template match="çalışan">
  <li>
    <xsl:value-of select="isim/önadı"/>
    <xsl:text> </xsl:text>
    <xsl:value-of select="isim/soyadı"/>
  </li>
</xsl:template>

11 Değişkenler ve Değergeçler

<!-- Grubu: tepe-seviyeden-eleman -->
<!-- Grubu: yönerge -->
<xsl:variable
  name = nitelikli-ad
  select = ifade >
  <!-- İçeriği: örneklenim -->
</xsl:variable>
eleman
<!-- Grubu: tepe-seviyeden-eleman -->
<xsl:param
  name = nitelikli-ad
  select = ifade >
  <!-- İçeriği: örneklenim -->
</xsl:param>
eleman

Bir değişken bir değere atanmış bir isimdir. Bir değişken atanmış bir değer ifadelerden elde edilen herhangi bir türde nesne olabilir. Değişken atamakta kullanılabilen iki eleman vardır: xsl:variable ve xsl:param. Farkları, xsl:param elemanının değişkene sadece bir öntanımlı değer atamasıdır; xsl:param elemanının yer aldığı örneklenim veya biçembent çağrıldığında değergeçler kullanıldıkları yerlere öntanımlı değer geçirirler.

xsl:variable ve xsl:param elemanlarının ikisinin de değişkenin ismi olarak kullanıldığından belirtilmesi zorunlu birer name özniteliği vardır. name özniteliğinin değeri Nitelikli Adlar bölümünde açıklandığı gibi bir NitelAda genişletilir.

Bu değişken atama elemanlarından herhangi biri için, içinde atamanın görünür olduğu bir biçembent ağacı bölümü mevcuttur. Bir ifadenin etki alanındaki değişken atamaları, bu ifadenin yer aldığı biçembentte değişkenin görünür olduğu yerdeki atamalardan oluşur.

11.1 Hedef Ağaç Bölümleri

Değişkenler ifade diline yeni bir veri türü ekler. Bu yeni türe hedef ağaç bölümü adı verilir. Bir değişken dört temel XPath türünden (dizge, sayı, mantıksal değer ve düğüm kümesi) başka bir hedef ağaç bölümü türünde de atanabilir. Bir hedef ağaç bölümü, hedef ağacın bir bölümü olarak ifade edilir ve tek bir kök düğüm içeren bir düğüm kümesine eşdeğer tarzda ele alınır. Bununla birlikte, bir hedef ağaç bölümünde izin verilen işlemler bir düğüm kümesinde izin verilen işlemlerin bir altkümesidir. Böyle bir işleme sadece bir dizge üzerinde izin verilen bir işlemse izin verilir (dizge üzerindeki ilk işlem, dizgeyi bir mantıksal değere veya sayıya dönüştürme işlemi olabilir). Özellikle, hedef ağaç bölümü üzerinde /, // ve [] işleçlerinin kullanımına izin verilmez. Bir hedef ağaç bölümünde izin verilen işlemlerden biri her uygulanışında, eşdeğeri bir düğüm kümesinde uygulandığı gibi uygulanır.

Bir hedef ağaç bölümü hedef ağaca kopyalanırken (bkz, Değişken ve Değergeçlerin Değerlerinin xsl:copy-of ile Kullanımı), eşdeğer düğüm kümesinde kök düğümün çocukları olan tüm düğümler hedef ağaca aynı sırayla kopyalanırlar.

İfadeler, hedef ağaç bölümü türündeki değerleri sadece, hedef ağaç bölümü türündeki değişkenlere atıfta bulunarak veya bir hedef ağaç bölümü döndüren bir eklenti işlevini çağırarak ya da değeri bir hedef ağaç bölümü olan bir sistem gerecini getirerek döndürürler.

11.2 Değişken ve Değergeçlerin Değerleri

Bir değişken atama elemanı bir değişken değerini üç yoldan biriyle belirtebilir.

  • Değişken atama elemanı bir select özniteliğine sahipse, bu özniteliğin değeri, değerlendirilmesinin sonucunda değişkenin değeri haline gelecek olan bir nesnenin elde edileceği bir ifade olmalıdır. Bu durumda, değişken atama elemanının içeriği boş olmalıdır.

  • Değişken atama elemanı bir select özniteliğine sahip değilse ve eleman boş olmayan bir içeriğe sahipse (yani, değişken atama elemanı bir veya daha fazla sayıda çocuk elemana sahipse), değeri değişken atama elemanının içeriği belirler. Değişken atama elemanının içeriği, değişkenin değerini vermek üzere nesnelleştirilecek olan örneklenimdir. Değeri, çocukları örneklenimin nesnelleştirilmesiyle üretilen düğümlerden oluşan tek bir kök düğüm içeren bir düğüm kümesine eşdeğer bir hedef ağaç bölümüdür. Hedef ağaç bölümündeki düğümlerin temel tanım-yeri (URI), değişken atama elemanının temel tanım-yeridir.

    Örneklenim nesnelleştirilerek elde edilen düğümlerin bir üyesinin bir öznitelik düğümü veya bir isim-alanı düğümü olması, bir kök düğüm böyle bir çocuk düğüme sahip olamayacağından, bir hatadır. Bir XSLT işlemci bu hatayı raporlayabilir; raporlamıyorsa, öznitelik veya isim-alanı düğümünü hedef ağaca eklemeyerek hatayı ortadan kaldırabilir.

  • Değişken atama elemanı boş bir içeriğe sahipse ve bir select özniteliği de belirtilmemişse, değişkenin değeri bir boş dizge olacaktır. Bu bakımdan,

    <xsl:variable name="x"/>

    buna eşdeğerdir:

    <xsl:variable name="x" select="''"/>

Not:
Bir değişken, düğümleri konumlarına göre seçmek için kullanılmışsa, aşağıdakini yapmamak konusunda dikkatli olunmalıdır:

<xsl:variable name="n">2</xsl:variable>
...
<xsl:value-of select="item[$n]"/>

Bu örneklenim, ilk item elemanının değerini çıktılayacaktır. Sebebi, n değişkeninin bir sayıya değil bir hedef ağaç bölümüne atanmış olmasıdır. Şöyle,

<xsl:variable name="n" select="2"/>
...
<xsl:value-of select="item[$n]"/>

veya şöyle yapılabilirdi:

<xsl:variable name="n">2</xsl:variable>
...
<xsl:value-of select="item[position()=$n]"/>

Not:
Boş bir düğüm kümesini bir değergeçe öntanımlı değer olarak atamanın tek uygun yolu şudur:

<xsl:param name="x" select="/.."/>

11.3 Değişken ve Değergeçlerin Değerlerinin xsl:copy-of ile Kullanımı

<!-- Grubu: yönerge -->
<xsl:copy-of
  select = ifade />
eleman

xsl:copy-of elemanı hedef ağaca bir hedef ağaç bölümü yerleştirmekte kullanılabilir ve bunu yapmak için xsl:value-of elemanının yaptığı gibi (bkz, Metnin xsl:value-of ile Üretilmesi) önce bir dizgeye dönüşüm gerekmez. Bir ifade içeren bir select özniteliğinin belirtilmesi zorunludur. İfadenin değerlendirme sonucunun bir hedef ağaç bölümü olması durumunda, bölümün tümü hedef ağaca kopyalanır. Sonucun bir düğüm kümesi olması durumunda ise, kümenin düğümleri belgedeki sıralarına göre hedef ağaca kopyalanırlar; bir eleman düğümünün kopyalanması, elemanın kendinden başka, isim-alanı düğümlerinin, öznitelik düğümlerinin ve elemanın çocuk düğümlerinin de kopyalanmasına sebep olur; bir kök düğüm ise, çocuklarının kopyalanmasıyla kopyalanmış olur. Bir öznitelik veya isim-alanının kopyalanmasında, xsl:copy ile kopyalamada geçerli olan kurallar burada da aynen geçerlidir (bkz, Kopyalama). Sonucun ne bir düğüm kümesi ne de hedef ağaç bölümü olması durumunda, tıpkı xsl:value-of elemanının yaptığı gibi, sonuç bir dizgeye dönüştürüldükten sonra hedef ağaca yerleştirilir.

11.4 Tepe-Seviyeden Değişkenler ve Değergeçler

xsl:variable ve xsl:param elemanlarının her ikisi de tepe-seviyeden elemanlar olabilir. Bir tepe-seviyeden değişken atama elemanı, her yerde (başka bir atama tarafından geçersiz kılınmadıkça) görünür olan bir genel değişken bildirir. Bir tepe-seviyeden xsl:param elemanı biçembende bir değergeç bildirir; XSLT, biçembente değergeç aktarımı ile ilgili bir mekanizma tanımlamaz. Bir biçembent aynı isme sahip birden fazla değişken ataması içeriyorsa, ithal önceliği en yüksek atama kullanılır. Bir biçembendin aynı ithal önceliği ile aynı isme atama yapan birden fazla değişken ataması içermesi bir hatadır. Tepe seviyede, değişken değeri belirten bir ifade veya örneklenim, kaynak belgenin kök düğümünü işlemekte kullanılan bağlama eşdeğer bir bağlamla değerlendirilir: geçerli düğüm kaynak belgenin kök düğümü olup geçerli düğüm kümesi kaynak belgenin sadece kök düğümünü içeren bir listedir. Eğer bir örneklenim veya ifade bir y genel değişkenine atıf yapan bir x genel değişkeni belirtiyorsa, y değişkeninin değerinin x değişkeninin değerinden önce hesaplanması gerekir. Tüm genel değişken tanımları açısından bunun olması olanaksızsa bu bir hatadır; başka bir deyişle, atamanın bitmeyen bir döngüye yol açabilecek şekilde hesaplanması bir hatadır.

Burada, bir öznitelik değeri örnekleniminden atıfta bulunulan para-font-size isimli bir genel değişken bildirilmektedir:

<xsl:variable name="para-font-size">12pt</xsl:variable>

<xsl:template match="para">
 <fo:block font-size="{$para-font-size}">
   <xsl:apply-templates/>
 </fo:block>
</xsl:template>

11.5 Örneklenimlerin içinde Değişkenler ve Değergeçler

xsl:variable ve xsl:param elemanlarına tepe seviyede izin verildiği gibi örneklenimlerin içinde de izin verilir. xsl:variable elemanına, bir örneklenimin içinde bir yönergeye izin verilen her yerde izin verilir. Bu durumda, atama, xsl:fallback yönergeleri hariç tüm küçük kardeşlerin astsallarına görünür olacaktır. Atamanın xsl:variable elemanının kendisi için görünür olmayacağına dikkat ediniz.

xsl:param elemanına bir xsl:template elemanının başlangıcında bir çocuk olarak bulunmasına izin verilir. Bu bağlamda, atama, xsl:fallback yönergeleri hariç tüm küçük kardeşlerin astsallarına görünür olacaktır. Atamanın xsl:param elemanının kendisi için görünür olmayacağına dikkat ediniz.

Eğer bir atamanın görünür olduğu yerde başka bir atama yer alıyorsa ve bu atamalar aynı isme yapılmışsa, yeni atama o bağlamda eskisini geçersiz bırakır. Aynı örneklenim içinde xsl:variable veya xsl:param elemanlarınca yapılmış atamaların birbirlerini geçersizleştirmeleri bir hatadır. Bir örneklenim içinde, xsl:variable veya xsl:param elemanlarınca yapılmış atamaların tepe-seviyeden yapılmış atamaları geçersizleştirmeleri hata değildir. Bu durumda, bir tepe-seviyeden atama, başka bir atamanın kendisini geçersizleştirdiği bir biçembent bölümünde görünür olmayacaktır. Bu bakımdan şu bir hatadır:

<xsl:template name="foo">
  <xsl:param name="x" select="1"/>
  <xsl:variable name="x" select="2"/>
</xsl:template>

Ama, buna izin verilir:

<xsl:param name="x" select="1"/>

<xsl:template name="foo">
  <xsl:variable name="x" select="2"/>
</xsl:template>

Not:
Bir örneklenim içindeki bir xsl:variable elemanının Java dilindeki en yakın eşdeğeri, ilklendiricili bir nihai yerel değişken bildirimidir. Örneğin,

<xsl:variable name="x" select="'value'"/>

ile

final Object x = "value";

aynı anlambilgisine sahiptir. XSLT, böyle bir Java atama işlecinin bir eşdeğerini sağlamaz:

x = "value";

Çünkü bir belgeyi başından sonuna kadar, betik benzeri bir yöntemden başka bir yöntemle işleyen bir gerçeklenimi oluşturmak daha zor olurdu.

11.6 Değergeçlerin Örneklenimlere Aktarılması

<xsl:with-param
  name = nitelikli-ad
  select = ifade >
  <!-- İçeriği: örneklenim -->
</xsl:with-param>
eleman

Değergeçler örneklenimlere xsl:with-param elemanı kullanılarak aktarılırlar. Belirtilmesi zorunlu olan name özniteliği değergeçin (atamanın değerini değiştirdiği değişken) ismini belirtir. name özniteliğinin değeri Nitelikli Adlar bölümünde belirtildiği gibi yorumlanan bir NitelAddır. xsl:with-param elemanına xsl:call-template ve xsl:apply-templates elemanlarının her ikisinde de izin verilir. Bir xsl:call-template veya xsl:apply-templates elemanının birden fazla aynı isimli xsl:with-param elemanı içermesi bir hatadır. Değergeç değeri xsl:variable ve xsl:param elemanlarında kullanılan yöntemle belirtilir. xsl:with-param ile belirtilen değerin hesaplanmasında kullanılan geçerli düğüm ve geçerli düğüm listesi, içinde kullanıldığı xsl:call-template veya xsl:apply-templates elemanlarınınkilerle aynıdır. x için bir xsl:param elemanına sahip olmayan bir örneklenime bir x değergecini aktarmak hata değildir; değergeç basitçe yoksayılır.

Bu örnekte, sayı biçimini denetleyen bir değergeçe sahip numbered-block isminde bir örneklenim, değergeçine değer aktarılarak çağrılmaktadır:

<xsl:template name="numbered-block">
  <xsl:param name="format">1. </xsl:param>
  <fo:block>
    <xsl:number format="{$format}"/>
    <xsl:apply-templates/>
  </fo:block>
</xsl:template>

<xsl:template match="ol//ol/li">
  <xsl:call-template name="numbered-block">
    <xsl:with-param name="format">a. </xsl:with-param>
  </xsl:call-template>
</xsl:template>

12 Ek İşlevler

Bu bölümde temel XPath işlev kütüphanesine ek olarak XSLT'ye özgü işlevlere yer verilmiştir. Bu ek işlevlerin bazıları ayrıca, biçembentte tepe-seviyeden elemanlar tarafından belirtilen bilgileri de kullanıma sokarlar; bu bölümde bu işlevler ayrıca açıklanacaktır.

12.1 Çok Kaynaklı Belgeler

düğüm-kümesi document(nesne, düğüm-kümesi?)
İşlev

document işlevi asıl kaynak belgeden başka XML belgelere de erişimi mümkün kılar.

document işlevi tek bir argümana sahipse ve bu argüman da bir düğüm kümesi ise, sonuç, belirtilen düğüm kümesinin her düğümü için, düğümün kendi dizgesel değerinin document işlevinin ilk argümanı, düğümün üyesi olduğu düğüm kümesinin ikinci argümanı olduğu document çağrılarının sonuçlarının birleşimidir.

document işlevi iki argümana sahipse ve ilk argüman bir düğüm kümesi ise, sonuç, belirtilen düğüm kümesinin her düğümü için, düğümün dizgesel değerinin document işlevinin ilk argümanı, ikinci argümanın yine ikinci argümanı olduğu document çağrılarının sonuçlarının birleşimidir.

document işlevine aktarılan ilk argümanın bir düğüm kümesi olmaması halinde, ilk argüman string işlevinin yaptığı gibi bir dizgeye dönüştürülür ve bu dizge bir tanım-yeri (URI) başvurusu olarak ele alınır; Bu tanım-yeri ile tanımlanan özkaynak alınıp getirilir. Bu algetir işleminin sonucu olan veri bir XML belge olarak çözümlenir ve veri modeline uygun ber ağaç oluşturulur (bkz, Veri Modeli). Özkaynağın alınıp getirilmesi ile ilgili bir hata oluşmuşsa, XSLT işlemci hatayı raporlayabilir, raporlamıyorsa, bir boş düğüm kümesi döndürerek hatayı ortadan kaldırabilir. Özkaynağın alınıp getirilmesi ile ilgili olası tek hata çeşidi XSLT işlemcinin tanım-yeri tarafından kullanılan tanım-yeri şemasını desteklemeyişidir. Bir XSLT işlemcinin her tanım-yeri şemasını desteklemesi gerekmez. XSLT işlemcinin belgeleri, XSLT işlemcinin hangi tanım-yeri şemalarını desteklediğini açıklamalıdır.

Eğer tanım-yeri başvurusu bir bölüm betimleyici (adresin sonunda yer alan ve # imi ile başlayan dizgecik) içermiyorsa, belgenin sadece kök düğümünü içeren bir düğüm kümesi döner. Eğer tanım-yeri başvurusu bir bölüm betimleyici içeriyorsa, tanım-yeri başvurusunun bölüm betimleyicisi tarafından betimlenen ağaçtaki düğümleri içeren bir düğüm kümesi döner. Bölüm betimleyicinin ifade ettiği anlam, tanım-yerinden alınıp getirilen özkaynağın ortam türüne bağımlıdır. Eğer bölüm betimleyicinin işlenmesi ile ilgili bir hata oluşmuşsa, XSLT işlemci hatayı raporlayabilir, raporlamıyorsa, bir boş düğüm kümesi döndürerek hatayı ortadan kaldırabilir. Olası hatalar şunlar olabilir:

  • Bölüm betimleyici bir XSLT düğüm kümesi tarafından ifade edilemeyecek şeyleri betimliyordur (örneğin, bir metin düğümündeki bir karakter aralığı).

  • XSLT işlemci tanım-yerinden alınıp getirilen özkaynağın ortam türüne özgü bölüm betimleyiciyi desteklemiyordur. Bir XSLT işlemcinin her ortam türünü desteklemesi gerekmez. XSLT işlemcinin belgeleri, XSLT işlemcinin hangi ortam türlerini desteklediğini açıklamalıdır.

Özkaynağın alınıp getirilmesinin sonucu olan veri algetir işleminin sonucunun ortam türünden bağımsız olarak bir XML belge olarak çözümlenir; eğer tepe seviye ortam türü text ise, ortam türünün text/xml olduğu durumda uygulanan yöntemle çözümlenir; aksi takdirde, application/xml ortam türüne özgü yöntemle çözümlenir.

Not:
Tepe-seviyeden bir xml ortam türü olmadığından text/xml veya application/xml ortam türünde olmayan veri yine de fiilen XML olabilir.

Tanım-yeri başvurusu göreli olabilir. İkinci argümandaki düğüm kümesinde, belgedeki sıraya göre ilk olan düğümün temel tanım-yeri (bkz, Temel Tanım-yeri), göreli tanım yerlerini mutlak tanım yerine dönüştürmek için temel tanım-yeri olarak kullanılır. İkinci argümanda boş düğüm kümesi ile göreli tanım-yeri belirtmek bir hatadır. XSLT işlemci hatayı raporlayabilir, raporlamıyorsa, bir boş düğüm kümesi döndürerek hatayı ortadan kaldırabilir. Eğer ikinci argüman hiç belirtilmemişse, biçembentte document işlevinin çağrıldığı ifadeyi içeren düğüm öntanımlı değerdir. Göreli tanım-yeri başvurusunun çözümlenmesini sağlaması nedeniyle, sıfır uzunluktaki bir tanım-yeri başvurusunun belgeye bir başvuru oluşuna dikkat ediniz; bu bakımdan, document("") ifadesi biçembendin kök düğümüne karşılıktır; biçembendin ağaç gösterimi, biçembendi kaynak belgenin başında içeren XML belgeyle tamamen aynıdır.

Eğer iki belge aynı tanım-yerine sahipse bunlar aynı belge olarak ele alınır. Karşılaştırma için kullanılan tanım-yeri, göreli tanım-yerlerini çözümlemekte kullanılan ve bir bölüm betimleyici içermeyen mutlak tanım-yeridir. Eğer ikisi de aynı belgeye aitse iki kök düğüm aynı kök düğüm olarak ele alınır. Bu bakımdan aşağıdaki ifade daima doğru sonuç verecektir:

generate-id(document("foo.xml"))=generate-id(document("foo.xml"))

document işlevi, bir düğüm kümesinin birden fazla belgeden düğümler içermesini olasılığını arttırır. Böyle bir düğüm kümesi ile aynı belgedeki iki düğümün göreli belge sırası XPath [XPath] tarafından tanımlanmış normal belge sırası olacaktır. İki düğümün farklı belgelerdeki göreli belge sırası, bu iki düğümü içeren belgelerin gerçeklenime bağımlı sıralamasına göre saptanır. Sürekli olarak aynı sonucu vermek dışında gerçeklenimlerin belgeleri nasıl sıralayacağıyla ilgili bir kısıtlama yoktur: Bir gerçeklenim, aynı belge kümesi için daima aynı sıralamayı yapmak zorundadır.

12.2 Anahtarlar

Anahtarlar, belgelerde örtük bir çapraz başvuru yapısıyla çalışma imkanı verir. XML'deki ID, IDREF ve IDREFS öznitelik türleri XML belgelerin kendi çapraz başvurularını doğrudan oluşturabilmeleri için bir mekanizma sağlar. XSLT bunu XPath id işlevi üzerinden destekler. Bununla birlikte bu mekanizmanın bazı gereklilikleri vardır:

  • ID türündeki öznitelikler örneğin DTD gibi bir yerde bildirilmelidir. Eğer bir ID özniteliği bir ID türünden öznitelik olarak sadece harici bir DTD altkümesinde bildirilmişse, bu öznitelik sadece, eğer XML işlemci bu harici DTD altkümesini okursa bir ID türünde öznitelik olarak tanınacaktır. Ancak, XML Önergesi, XML işlemcilerin harici DTD altkümelerini okumasını bir zorunluluk değil, bir öneri olarak belirtir.

  • Bir belge eşsiz ID'lerin tek bir kümesine sahip olabilir. Ayrı ayrı bağımsız eşsiz ID kümeleri olamaz.

  • Bir elemanın ID'si sadece bir öznitelikte belirtilebilir; elemanın içeriğinde veya bir çocuk eleman tarafından belirtilemez.

  • Bir ID bir XML adı olmak zorundadır. Örneğin, boşluk içeremez.

  • Bir eleman en çok bir ID'ye sahip olabilir.

  • Belli bir ID'ye en çok bir eleman sahip olabilir.

Bu gerekliliklerden dolayı XML belgeler, ID/IDREF/IDREFS öznitelikleriyle açıkça belirtilmese bile bir çapraz başvuru yapısına sahip olurlar.

Bir anahtar şu üçlemeye sahiptir:

  1. anahtarın sahibi olan düğüm

  2. anahtarın ismi (bir genişletilmiş isim)

  3. anahtarı değeri (bir dizge)

Bir biçembentte her belge için anahtar kümesi xsl:key elemanı kullanılarak bildirilir. Bu anahtar kümesi, x diye bir düğüme, y diye bir isme ve z diye bir değere sahipse, x düğümünün z değerli bir y anahtarı olduğundan bahsedebiliriz.

Bu bakımdan, bir anahtar, bir XML ID'sinin sınırlamalarına konu olmayan genelleştirilmiş bir ID çeşididir:

  • Anahtarlar bir biçembentte xsl:key elemanları kullanılarak bildirilirler.

  • Bir anahtarın değerinden başka bir de ismi vardır; her anahtar ismi betimleyici uzayından bağımsız, ayrı bir isim olarak düşünülebilir.

  • Bir isimli anahtar değeri bir eleman için, uygun herhangi bir yerde belirtilebilir; örneğin bir öznitelikte, bir çocuk elemanda veya içerikte belirtilebilir. Belli bir isimli anahtar için bulunacak değerin yerini belirtmek için bir XPath ifadesi kullanılır.

  • Bir anahtarın değeri keyfi bir dizge olabilir; bir XML adı olmak zorunda değildir.

  • Bir belgede aynı düğümün farklı anahtar değerleri için aynı isimde çok sayıda anahtarı olabilir.

  • Bir belgede aynı anahtar ismine ve aynı anahtar değerine sahip çok sayıda farklı düğüm olabilir.

<!-- Grubu: tepe-seviyeden-eleman -->
<xsl:key
  name = nitelikli-ad
  match = örüntü
  use = ifade />
eleman

xsl:key elemanı anahtarları bildirmek için kullanılır. name özniteliği ile anahtarın ismi belirtilir. name özniteliğinin değeri, Nitelikli Adlar bölümünde açıklandığı gibi yorumlanan bir NitelAd olmalıdır. match özniteliği bir Örüntü olup, bir xsl:key elemanı, belirtilen bu örüntüyle eşleşen düğümlerin anahtarları hakkında bilgi verir. use özniteliği anahtarın değerini belirten bir ifade olup, örüntüyle eşleşen her düğüm için bir kere değerlendirilir. Eğer sonuç bir düğüm kümesi ise, düğüm kümesindeki her düğümün belirtilen isimde, değeri düğümün dizgesel değeri olan bir anahtarı olur; aksi takdirde, sonuç bir dizgeye dönüştürülür ve örüntüyle eşleşen düğümün belirtilen isimde değeri bu dizge olan bir anahtarı olur. Bu bakımdan, bir x düğümünün y isminde ve z değerinde bir anahtara sahip olması için bir xsl:key elemanının sağlaması gerek ve yeter koşullar şunlardır:

  • x düğümü, xsl:key elemanının match özniteliğinde belirtilen örüntüyle eşleşir;

  • xsl:key elemanının name özniteliğinin değeri y'ye eşit olup,

  • xsl:key elemanının use özniteliğinde belirtilen ifade, bir u nesnesinden elde edilen bir geçerli düğüm listesindeki geçerli düğüm olarak x düğümüyle değerlendirildiğinde, z, ya u'nun string işlevinin yaptığı gibi bir dizgeye dönüştürülmesinin sonucuna eşittir ya da u bir düğüm kümesi olup, z değeri de u'daki düğümlerin bir veya daha fazlasının dizgesel değerine eşittir.

Ayrıca, belli bir düğümle eşleşen birden fazla xsl:key elemanı olabileceğini de aklınızdan çıkarmayın; böyle xsl:key elemanlarının hepsi aynı ithal önceliğine sahip olmasalar bile kullanılırlar.

use veya match özniteliğinin değer olarak bir DeğişkenGönderimi veya bir key işlev çağrısı içermesi bir hatadır.

düğüm-kümesi key(dizge, nesne)
İşlev

key işlevi ID'ler için id işlevinin yaptığını anahtarlar için yapar. İlk argüman anahtarın ismini belirtir. Argümanın değeri Nitelikli Adlar bölümünde açıklandığı gibi yorumlanan bir NitelAd olmalıdır. İkinci argüman bir düğüm kümesi olduğunda, sonuç, bu düğüm kümesindeki her düğümün dizgesel değerine key işlevinin uygulanmasından elde edilen sonuçlarının birleşimi olacaktır. İkinci argüman herhangi bir başka türde bir değer içerdiğinde, argüman string işlevinin yaptığı gibi bir dizgeye dönüştürülür; bu durumda, işlevden dönen sonuç, değeri bu dizgeye eşit bir isimli anahtara sahip bağlamsal düğümle aynı belgedeki düğümleri içeren bir düğüm kümesi olur.

Örnek:
Örneğin, şöyle bir bildirim olsun:

<xsl:key name="idkey" match="div" use="@id"/>

key('idkey', @ref) ifadesi, id(@ref) ifadesinin sonucu olan düğüm kümesi ile döner; XML kaynak belgesinde özniteliğin ID türünde şöyle bildirilmiş olduğu,

<!ATTLIST div id ID #IMPLIED>

ve geçerli düğümün ref özniteliğinin herhangi bir boşluk karakteri içermediği varsayımıyla.

Örnek:
Bir işlev kütüphanesini açıklayan bir belgemiz olduğunu ve işlevleri tanımlamak için bir prototype elemanı kullanıldığını varsayalım.

<prototype name="key" return-type="düğüm-kümesi">
<arg type="dizge"/>
<arg type="nesne"/>
</prototype>

İşlev isimlerinden bu tanıma atıfta bulunmak için de function elemanı kullanılıyor olsun.

<function>key</function>

Buradan hareketle biçembent gönderimlerle tanımlar arasındaki hiper bağları şöyle üretecektir:

<xsl:key name="func" match="prototype" use="@name"/>

<xsl:template match="function">
<b>
  <a href="#{generate-id(key('func',.))}">
    <xsl:apply-templates/>
  </a>
</b>
</xsl:template>

<xsl:template match="prototype">
<p><a name="{generate-id()}">
<b>Function: </b>
...
</a></p>
</xsl:template>

Örnek: (çevirmenden)

Bu anahtarlar konusu bu işin en zor anlaşılan kısmıdır. Yukarıdakine benzer ama yukarıdakinden her bakımdan daha yararlı olacağını umduğum bir örneği vermek istiyorum.

Bir belirtim belgemiz olsun. Belgede bahsedilen sabitlerden bazılarının tanımları varken bazıları sadece birer dizgesel sabit olsun. Tanımları olanların isimleri belgede geçtikçe (<literal>sabit</literal> gibi) bu isimler bu tanımlara aynı zamanda birer hiper bağ olsun, tanımları olmayanların da birer sabit oldukları belli olsun, istiyoruz.

<xsl:template match="literal">
  <xsl:variable name="idx" select="concat('value-def-', text())"/>
  <xsl:variable name="targets" select="key('ids', $idx)"/>

  <xsl:choose>
    <xsl:when test="count($targets) > 0">
      <a href="#{$idx}">
        <code><xsl:apply-templates/></code>
      </a>
    </xsl:when>
    <xsl:otherwise>
      <tt><xsl:apply-templates/></tt>
    </xsl:otherwise>
  </xsl:choose>
</xsl:template>

Örneklenimin ilk yönergesinde bir değişken ataması yapılıyor. $idx değişkenine, literal elemanının içeriğinden bir ID değeri oluşturup bunu atıyoruz. İkinci yönergedeki değişken atamasında ise $idx değişkenine atadığımız ID değerini içeren düğümleri $ids değişkeninin değerinden alıp $targets değişkenine atıyoruz. Tabii bunu yapabilmek için biçembentin başlarında şöyle bir yönergemiz olması gerek (bu anahtar, belgede birer id özniteliğine sahip bütün elemanları toplayıp $ids değişkenine atar):

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

xsl:when elemanında aradığımız ID'ye sahip eleman var mı acaba diye bir sınama yapıyoruz. Varsa, XML belgedeki <literal>sabit</literal> yerine XHTML belgeye sabitin tanımını işaret eden bir hiper bağ yerleştiriyoruz (bu bağ için gereken ID değerini bildiğimiz için bir önceki örnekte olduğu gibi bir ID üretmemiz gerekmiyor). Yoksa, içeriğini bir dizgesel sabit olduğunu vurgulayacak bir imlenimin (tt) içine alıyoruz.

key işlevi daima geçerli düğümle aynı belgede yer alan düğümleri döndürür; bir anahtarı başka bir belgeden almak için önce geçerli düğümün değiştirilmesi gerekir.

Örnek:
Bir belgenin <bibref>XSLT</bibref> biçiminde kaynakça girdilerine atıfta bulunduğunu ve bu kaynakçanın da bib.xml adlı ayrı bir XML belgede girdilerinin şöyle bir veri modeliyle tutulduğunu varsayalım:

<entry name="XSLT">...</entry>

Bu durumda biçembent bibref elemanlarını dönüştürmek için şu kodları içerebilirdi:

<xsl:key name="bib" match="entry" use="@name"/>

<xsl:template match="bibref">
  <xsl:variable name="name" select="."/>
  <xsl:for-each select="document('bib.xml')">
    <xsl:apply-templates select="key('bib',$name)"/>
  </xsl:for-each>
</xsl:template>

12.3 Sayı Biçimleme

dizge format-number(sayı, dizge, dizge?)
İşlev

format-number işlevi birinci argümanında belirtilen sayıyı ikinci argümanında belirtilen biçim örüntüsü dizgesini kullanarak bir dizgeye dönüştürür. Üçüncü argümanda onluk sayı biçimi belirtilir, üçüncü argümanın yokluğunda öntanımlı onluk sayı biçimi kullanılır. Biçim örüntüsü dizgesi JDK 1.1 DecimalFormat sınıfı tarafından belirtilen sözdizimine sahiptir. Biçim örüntüsü dizgesinin gösterimi yerelleştirilebilir: onluk biçim örüntüdeki karakterlerin hangilerinin ne anlama geldiğini belirler (yerelleştirilmeyen tırnak karakteri hariç). Biçim örüntüsü sent imini (#x00A4) içeremez; Bu özellik için destek JDK 1.1'e ilk sürümünden sonra eklenmiştir. Onluk biçim ismi Nitelikli Adlar bölümünde açıklandığı gibi yorumlanan bir NitelAd olmalıdır. Biçembendin onluk biçimin genişletilmiş isimli bir bildirimini içermemesi bir hatadır.

Not:
Gerçeklenimlerin ne JDK 1.1 kullanması ne de Java dilinde geliştirme yapmaları gereklidir.

Not:
Biçembentler yuvarlamayı denetim altına almak için XPath'daki diğer oluşumları kullanabilirler.

<!-- Grubu: tepe-seviyeden-eleman -->
<xsl:decimal-format
  name = nitelikli-ad
  decimal-separator = karakter
  grouping-separator = karakter
  infinity = dizge
  minus-sign = karakter
  NaN = dizge
  percent = karakter
  per-mille = karakter
  zero-digit = karakter
  digit = karakter
  pattern-separator = karakter />
eleman

xsl:decimal-format elemanı, format-number işlevi tarafından kullanılan bir biçim örüntüsünün yorumlanışını denetleyen bir onluk biçim bildirir. name özniteliği belirtilmişse, eleman isimli bir onluk biçim belirtir. name özniteliğinin değeri Nitelikli Adlar bölümünde açıklandığı gibi yorumlanan bir NitelAd olmalıdır. Öntanımlı onluk biçim bildirimi yapmak veya tüm öznitelikler (öntanımlılar dahil) için aynı değerle bildirilmiş olmadıkça aynı isimde birden fazla onluk biçim bildirimi yapmak (ithal öncelikleri farklı olsa bile) bir hatadır. Eğer bir biçembent bir öntanımlı onluk biçim bildirimi içermiyorsa, özniteliksiz xsl:decimal-format elemanına eşdeğer bir bildirim uygulanır.

xsl:decimal-format elemanının diğer öznitelikleri JDK 1.1 DecimalFormatSymbols sınıfındaki yöntemlere karşılıktır. Her get/set çiftine karşılık xsl:decimal-format elemanı için tanımlanmış bir öznitelik vardır.

Aşağıdaki öznitelikler hem biçim örüntüsündeki karakterlerin yorumlanışını denetler hem de sayının biçimlenmesi sonucu elde edilebilen karakterleri belirtirler:

  • decimal-separator özniteliği ondalık ayraç olarak kullanılacak karakteri (Türkçe için virgüldür) belirtir; öntanımlı değer nokta (.) karakteridir.

  • grouping-separator özniteliği bölükleme için kullanılan (Türkçe için noktadır) karakteri belirtir (binler bölükleri gibi); öntanımlı değer virgül (,) karakteridir.

  • percent özniteliği yüzde imi olarak kullanılacak karakteri (Türkçe için de % karakteridir ama sayının ardına değil önüne konur) belirtir; öntanımlı değer yüzde (%) karakteridir.

  • per-mille özniteliği her-milde-bir karakteri olarak kullanılacak karakteri; öntanımlı değer Unicode her-milde-bir (#x2030) karakteridir.

  • zero-digit özniteliği sıfır ratamı olarak kullanılacak karakteri belirtir; öntanımlı değer sıfır (0) rakamıdır.

Aşağıdaki öznitelikler biçim örüntüsündeki karakterlerin yorumlanışını denetlerler:

  • digit özniteliğinde biçim örüntüsünde rakam ifade eden karakter belirtilir; öntanımlı değer diyez (#) karakteridir.

  • pattern-separator özniteliğinde pozitif ve negatif alt örüntüleri ayırmakta kullanılan karakter belirtilir; öntanımlı değer noktalı virgül (;) karakteridir.

Aşağıdaki öznitelikler biçimlenmiş sayıda yer alan karakterleri veya dizgeleri belirtmekte kullanılır:

  • infinity özniteliğinde sonsuzluğu belirtmekte kullanılan dizge belirtilir; öntanımlı değer Infinity dizgesidir.

  • NaN özniteliğinde NaN (Not-a-Number: bir-Sayı-Değil) değerini belirtmekte kullanılan dizge belirtilir; öntanımlı değer NaN dizgesidir.

  • minus-sign özniteliğinde eksi imi olarak kullanılacak karakter belirtilir; öntanımlı değer tire (-, #x2D) karakteridir.

12.4 Çeşitli Ek İşlevler

düğüm-kümesi current()
İşlev

current işlevi, tek üyesi geçerli düğüm olan bir düğüm kümesi ile döner. Son tahlilde (başka bir ifadenin içinde yer almayan bir ifadede), geçerli düğüm daima bağlamsal düğümle aynıdır. Bu bakımdan,

<xsl:value-of select="current()"/>

ile

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

aynı anlama gelir. Bununla birlikte, köşeli ayraçlar içindeki geçerli düğüm bağlamsal düğümden farklı bir düğüm olacaktır. Örneğin,

<xsl:apply-templates select="//glossary/item[@name=current()/@ref]"/>

ebeveynleri glossary elemanları olup, değerleri geçerli düğümün ref özniteliğinin değerine eşit olan birer name özniteliğine sahip tüm item elemanlarını işleyecektir. Aşağıdaki yönerge bunu yapmaz:

<xsl:apply-templates select="//glossary/item[@name=./@ref]"/>

yönergesi

<xsl:apply-templates select="//glossary/item[@[email protected]]"/>

ile aynı anlama gelir. Bunlar, ebeveynleri glossary elemanları olup, name ve ref özniteliklerinin değerleri aynı olan tüm item elemanlarını işleyecektir.

current işlevini bir Örüntü içinde kullanmak bir hatadır.

Çevirmenin notu:
Geçerli düğümü bir değişkene atayıp işlevin yerine bu değişkeni köşeli ayraçlar içinde kullanmak da istenen sonucu verecektir.
dizge unparsed-entity-uri(dizge)
İşlev

unparsed-entity-uri işlevi, bağlamsal düğümle aynı belgede ismiyle belirtilmiş bir çözümlenmemiş öğenin tanım-yerini döndürür (bkz, Çözümlenmemiş Öğeler). Böyle bir öğe yoksa boş dizgeyle döner.

dizge generate-id(düğüm-kümesi?)
İşlev

generate-id işlevi argümanında belirtilen düğüm kümesinin belgedeki sıraya göre ilk rastlanılan düğümünü eşsiz olarak betimleyen bir dizge ile döner. Eşsiz betimleyici bir ASCII harf ile başlamalı ve ASCII abecesayısal karakterlerinden oluşmalıdır. Bir gerçeklenim, aynı düğüm için daima aynı betimleyiciyi ve farklı düğümler için farklı betimleyicileri üretecek herhangi bir yöntemi seçmekte özgürdür. Bir gerçeklenim her dönüşümde aynı betimleyicileri üretmek zorunda değildir. Üretilmiş bir eşsiz betimleyicinin belgedeki mevcut (bu üretimin sonucu olmayan) eşsiz betimleyicilerden farklı olmak zorunda değildir. Eğer işleve belirtilen düğüm kümesi boşsa işlev boş dizge döndürür. Hiç argüman belirtilmemişse, bağlamsal düğüm öntanımlıdır.

nesne system-property(dizge)
İşlev

Argüman bir NitelAd olarak değerlendirilecek bir dizge olmalıdır. Bu NitelAd ifadenin etki alanındaki isim-alanı bildirimleri kullanılarak bir isme genişletilir. system-property işlevi bu isim tarafından betimlenen sistem gerecinin değeri olan nesne ile döner. Böyle bir sistem gereci yoksa boş dizge döner.

Gerçeklenimlerin aşağıdaki sistem gereçlerini hepsi XSLT isim-alanında yer alacak şekilde sağlamalıdırlar:

  • xsl:version, işlemci tarafından gerçeklenmiş XSLT sürümünü belirten bir sayı; bu sayı bu belirtimin gerçeklenimi için 1.0 olmalıdır.
  • xsl:vendor, XSLT işlemcinin üreticisini tanıtan bir dizge.
  • xsl:vendor-url, XSLT işlemcinin üreticisinin adresini içeren bir dizge; genellikle üreticinin ev sayfasının adresidir.

Üreticilerin XSLT isim-alanında başka sistem gereci tanımlamaması gerekir.

13 İletiler

<!-- Grubu: yönerge -->
<xsl:message
  terminate = "yes" | "no" >
  <!-- İçeriği: örneklenim -->
</xsl:message>
eleman

xsl:message yönergesi XSLT işlemcisine özgü bir yöntemle bir ileti gönderir. xsl:message yönergesinin içeriği bir örneklenimdir. xsl:message, bir XML bölümünü oluşturacak içerik nesnelleştirilerek nesnelleştirilir. Bu XML bölümü iletinin içeriğidir.

Not:
Bir XSLT işlemci xsl:message yönergesini bir uyarı kutusu ortaya çıkararak veya bir günlük dosyasına yazarak (ya da bir konsol çıktısı olarak) gerçekleştirebilir.

Eğer terminate özniteliği yes diye bir değere sahipse, XSLT işlemcinin iletiyi gönderdikten sonra işlemi sonlandırması gerekir. Özniteliğin öntanımlı değeri no'dur.

Yerelleştirmenin uygun tek yolu, yerelleştirilmiş bilgiyi (ileti metni, vs.) bir XML belgeye koymaktır (biçembente ek bir girdi dosyası haline gelmek üzere).

Örnek:
Bir XML belgedeki Türkçe iletilerin resources/tr.xml dosyasında şu biçimde tutulduğunu varsayalım:

<messages>
  <message name="problem">Bir cisim yaklaşıyor.</message>
  <message name="error">Bir sorun saptandı.</message>
</messages>

Bu veri modelinden hareketle bir biçembentte aşağıdaki gibi bir yerelleştirme yaklaşımında bulunulabilir:

<xsl:param name="lang" select="'tr'"/>
<xsl:variable name="messages"
  select="document(concat('resources/', $lang, '.xml'))/messages"/>

<xsl:template name="localized-message">
  <xsl:param name="name"/>
  <xsl:message>
    <xsl:value-of select="$messages/message[@name=$name]"/>
  </xsl:message>
</xsl:template>

<xsl:template name="problem">
  <xsl:call-template name="localized-message"/>
    <xsl:with-param name="name">problem</xsl:with-param>
  </xsl:call-template>
</xsl:template>

14 Eklentiler

XSLT iki çeşit eklentiye izin verir: eklenti elemanlar ve eklenti işlevler.

XSLT'nin bu sürümü eklentilerin gerçeklenimlerini tanımlayan bir mekanizma sağlamaz. Bu yüzden, bir XSLT biçembendinin XSLT işlemciler arasında taşınabilir olması gerekiyorsa, böyle eklentileri kullanmaması gerekir. XSLT, bir XSLT biçembendinin, bir XSLT işlemcinin belli bir eklentiye desteği olup olmadığını saptamasını, eğer yoksa ne olacağını belirtilmesini sağlayacak mekanizmaları sağlar. Eğer bir XSLT biçembendi bu mekanizmaları kullanmakta dikkatliyse, eklentilerin getirilerinden yararlanması mümkün olacak ve herhangi bir XSLT gerçeklenimi ile hala çalışabilecektir.

14.1 Eklenti Elemanlar

Eleman eklenti mekanizması isim-alanlarının eklenti isim-alanları olarak tasarlanmasını mümkün kılar. Bir isim-alanı bir eklenti isim-alanı olarak tasarlanmışsa ve bu isim-alanından bir eleman bir örneklenimde yer alıyorsa, bu eleman bir birebir hedef eleman olmaktan ziyade bir yönerge olarak ele alınır. İsim-alanı yönergenin anlambilgisini belirler.

Not:
Bir xsl:stylesheet elemanının çocuğu olmayan bir eleman bir örneklenimde yer almayacağından XSLT-dışı tepe-seviyeden elemanlar burada tanımlanan eklenti elemanlarından sayılmazlar ve bu bölümdeki hiçbir şey onlara uygulanmaz.

Bir isim-alanı, bir eklenti isim-alanı olarak xsl:stylesheet elemanının extension-element-prefixes özniteliği veya bir birebir hedef elemanın xsl:extension-element-prefixes özniteliği ya da eklenti elemanı kullanılarak belirtilebilir. Bu özniteliklerin ikisi de önekleri boşluk ayraçlı bir liste olarak kabul ederler. Bu öneklerin herbiri bir eklenti isim-alanı olarak atanır. extension-element-prefixes veya xsl:extension-element-prefixes özniteliğinde belirtilmiş bir önek için bir isim-alanı bildiriminin olmaması bir hatadır. Öntanımlı isim-alanı (xmlns ile bildirilen) önek listesinde #default ismiyle bir eklenti isim-alanı olarak belirtilebilir. Bir isim-alanının eklente isim-alanı olarak atanması extension-element-prefixes veya xsl:extension-element-prefixes özniteliğinin kullanıldığı elemanın kökü olduğu alt ağaçta etkilidir; bir xsl:stylesheet elemanının kökü olduğu bir alt ağaç ithal edilmiş veya içerilmiş bir biçembent içermez.

Eğer bir XSLT işlemci belli bir eklenti elemanının gerçeklenimine sahip değilse, element-available işlevi bu eleman ismi için olumsuz sonuç döndürmelidir. Böyle bir eklenti elemanı nesnelleştirildiğinde XSLT işlemci Son Çare bölümünde bahsedildiği gibi bir son çareye başvurmalıdır. Bir XSLT işlemci bir örneklenim gerçeklenmemiş bir eklenti elemanı içermekte olduğundan böyle bir durumda sadece bir hata rapor etmekle kalmamalıdır.

Eğer bir XSLT işlemci belli bir eklenti elemanının gerçeklenimine sahipse, element-available işlevi bu eleman ismi için olumlu sonuç döndürmelidir.

14.2 Eklenti İşlevler

Eğer bir İşlevÇağrısı ifadesindeki bir İşlevAdı bir KısaAd değilse (yani, bir ikinokta imi içeriyorsa), bir eklenti işlev çağrısı olarak ele alınır. İşlevAdı değerlendirme bağlamındaki isim-alanı bildirimi killanılarık bir isme genişletilir.

Eğer bir XSLT işlemci belli bir eklenti işlevinin gerçeklenimine sahip değilse, function-available işlevi bu eleman ismi için olumsuz sonuç döndürmelidir. Böyle bir eklenti işliv bir ifade içinde kullanılmış ve bu işlev çağrılmışsa, XSLT işlemci bunu bir hata olarak bildirmelidir. Bir XSLT işlemci bir ifade gerçeklenmemiş bir eklenti işlev içermekte olduğundan böyle bir durumda sadece bir hata rapor etmekle kalmamalıdır.

Eğer bir XSLT işlemci belli bir eklenti işlevinin gerçeklenimine sahipse, function-available işlevi bu eleman ismi için olumlu sonuç döndürmelidir. Böyle bir eklenti çağrılmışsa, XSLT işlemci işlevi argümanlarıyla birlikte gerçeklenime aktarmalı ve ve gerçekleniminin döndürdüğü sonucu işlev çağrısının sonucu olarak döndürmelidir.

15 Son Çare

<!-- Grubu: yönerge -->
<xsl:fallback>
  <!-- İçeriği: örneklenim -->
</xsl:fallback>
eleman

Normalde, bir xsl:fallback elemanı nesnelleştirmesi hiçbir şey yapmaz. Ancak, bir XSLT işlemci bir yönerge elemanı için bir son çareye başvurma durumunda kalırsa ve o yönerge elemanının bir veya daha fazla sayıda xsl:fallback çocuğu varsa, bu xsl:fallback çocuklarının her birinin sırayla nesnelleştirilmesi gerekir; aksi takdirde, bir hata bildirimi yapılmalıdır. xsl:fallback elemanının içeriği bir örneklenimdir.

Eğer belli bir işlev veya eleman kullanılabilir değilse bir biçembentin nasıl davranacağını denetlemek için aşağıdaki işlevler xsl:choose ve xsl:if yönergeleriyle kullanılabilir.

mantıksal-değer element-available(dizge)
İşlev

Argüman bir NitelAd olarak değerlendirilmeli ve ifade etki alanındaki isim-alanı bildirimi kullanılarak bir genişletilmiş isime genişletilmeidir. Eğer etki alanında bir öntanımlı isim-alanı varsa, NitelAdın öneksiz bir isim olarak yorumlanmasında kullanılır. element-available işlevinin doğru sonucunu döndürmesi için gerek ve yeter koşul genişletilmiş ismin bir yönerge ismi olmasıdır. Eğer genişletilmiş ismin isim-alanı tanım-yeri, XSLT'ninkiyle aynıysa bu isim XSLT tarafından tanımlanmış bir elemana ait demektir. Aksi takdirde, bir eklenti elemandır. Eğer genişletilmiş ismin isim-alanı tanım-yeri tanımsızsa, element-available işlevi olumsuz sonuç döndürecektir.

mantıksal-değer function-available(dizge)
İşlev

Argüman bir NitelAd olarak değerlendirilmeli ve ifade etki alanındaki isim-alanı bildirimi kullanılarak bir genişletilmiş isime genişletilmeidir. function-available işlevinin doğru sonucunu döndürmesi için gerek ve yeter koşul genişletilmiş ismin işlev kütüphanesindeki bir işlevin ismi olmasıdır. Eğer genişletilmiş isim tanımlı bir isim-alanına sahipse, isim bir eklenti işleve ati demektir, aksi takdirde XPath vya XSLT tarafından tanımlanmış bir işleve aittir.

16 Çıktı

<!-- Grubu: tepe-seviyeden-eleman -->
<xsl:output
  method = "xml" | "html" | "text" | nitelikli-ad-ama-kısa-ad-değil
  version = ad-dizgeciği
  encoding = dizge
  omit-xml-declaration = "yes" | "no"
  standalone = "yes" | "no"
  doctype-public = dizge
  doctype-system = dizge
  cdata-section-elements = nitelikli-adlar
  indent = "yes" | "no"
  media-type = dizge />
eleman

Bir XSLT işlemci hedef ağacı bir bayt dizisi olarak çıktılayabilir (böyle olması gerekmese bile; Uyumluluk bölümüne bakınız). xsl:output elemanı biçembent yazarına hedef ağacın nasıl çıktılanmasını istediğini belirtebilme imkanı verir. Eğer bir XSLT işlemci hedef ağacı çıktılıyorsa, bu, xsl:output elemanı tarafından belirtilmiş demektir; ancak bunun böyle olması gerekli değildir.

xsl:output elemanına sadece bir tepe-seviyeden eleman olarak izin verilir.

The method özniteliğinde hedef ağacın çıktılanma yöntemi belirtilir. Değer bir NitelAd olmalıdır. Eğer bu NitelAd bir önek içermiyorsa, bu belgede belirtilmiş yöntemlerden biri olarak ele alınır ve xml, html veya text değerlerinden biri olmalıdır. Eğer bu NitelAd bir önek içeriyorsa, Nitelikli Adlar bölümünde açıklandığı gibi bir genişletilmiş isime genişletilir; genişletilmiş isim çıktılama yöhtemini belirtir; bu durumdaki davranışın ne olacağı bu belgede belirtilmemiştir.

method özniteliği için öntanımlı davranış şöyle seçilir. Eğer,

öntanımlı çıktılama yöntemi html olacaktır; aksi takdirde xml'dir. Öntanımlı çıktılama yöntemi eğer bir xsl:output elemanı belirtilmemişse veya xsl:output elemanı method özniteliksiz belirtilmişse kullanılmalıdır.

xsl:output elemanının diğer öznitelikleri çıktılama yönteminin parametreleridir. Şu özniteliklere izin verilir:

Her özniteliğin her çıktılama yöntemi için anlamı ayrı ayrı çıktılama yöntemlerinin açıklamalarında açıklanacaktır. Çıktılama yöntemi açıklamalarında yer verilmemiş öznitelikler o çıktılama yöntemi için uygulanabilir değillerdir.

Bir biçembent çık sayıda xsl:output elemanı içerebileceği gibi, ithal ettiği veya içerdiği biçembentlerin her birinde de çok sayıda xsl:output elemanı olabilir. Bir biçembentte yer alan tüm xsl:output elemanları tek bir etkin xsl:output elemanı olarak birleştirilir. cdata-section-elements özniteliği için etkili değer belirtilmiş değerlerin birleşimidir. Diğer öznitelikler için etkili değer, en yüksek ithal önceliği ile belirtilmiş olan değerdir. Bir öznitelik için böyle birden fazla değerin varlığı bir hatadır. Bir XSKLT işlemci hatalı raporlayabilir, raporlamıyorsa, biçembentte son yer alan değeri kullanarak hatadan kurtulmalıdır. Özniteliklerin öntanımlı değerleri xsl:output elemanları birleştirildikten sonra saptanır; farklı çıktılama yöntemleri için bazı özniteliklerin öntanımlı değerleri farklı olabilir.

16.1 XML Çıktılama Yöntemi

xml çıktılama yöntemi, hedef ağacı bir iyi biçimli XML harici genel çözümlü öğe olarak çıktılar. Eğer hedef ağcın kök düğümü tek bir çocuk elemana sahipse ve hiç metin düğümü çocuğu yoksa, öğenin ayrıca iyi biçimli XML belge öğesi olması gerekir. Şunun gibi sıradan bir XML belge sarmalayıcı içindeki bir öğeye atıfta bulunurken,

<?xml version="xml-sürümü"?>
<!DOCTYPE doc [
<!ENTITY e SYSTEM "öğenin-yeri">
]>
<doc>&e;</doc>

öğenin-yeri ile öğenin dosya sistemindeki yeri, xml-sürümü ile de öğenin XML sürümü belirtiliyorsa, atıfta bulunulan elemanın bir bütün olarak [XML Adları] veya [XML Adları 1.1] ile uyumlu bir iyi biçimli XML belge olması gerekir. Ek olarak, yeni ağaç, öğenin Veri Modeli bölümünde belirtildiği gibi bir XML belge olarak çözümlenmesiyle oluşmuşsa, belge elemanı kaldırıldıktan sonra, onun çocuklarını kök düğümün çocukları yaparak oluşturulan yeni ağaç aşağıdaki olasılıkların dışında hedef ağaçla aynı olacaktır:

  • Öznitelik ve isim-alanı düğümlerinin sırası iki ağaçta farklı olabilir.

  • yeni ağaç, hedef ağaçta mevcut olmayan isim-alanı düğümleri içerebilir.

    Not:
    Bir XSLT işlemci hedef ağacın XML olarak çıktılanması durumunda isim-alanı bildirimlerini eklemek ihtiyacı duyabilir.

  • Düğümlerin temel tanım-yerleri iki ağaçta farklı olabilir.

Eğer XSLT işlemci, doctype-system özniteliği sebebiyle bir belge türü bildirimli veya standalone özniteliği sebebiyle tekbaşına belge bildirimli çıktılama yapıyorsa, çıktının bir iyi biçimli XML belge olması ve yukarıdaki gereksinimlerin, herhangi bir sarmalayıcı olmaksızın, DTD'yi işleme sokmayan bir XML işlemci kullanılarak belgenin doğrudan çözümlenmesiyle oluşturulan ağaca uygulanması gerekir.

Not:
DTD'nin işlenmesi, öznitelik öntanımlaması sebebiyle, ağaçta ek özniteliklerin yer almasına sebep olabilir.

version özniteliği hedef ağacı çıktılarken kullanılacak XML sürümünü belirtmek için kullanılır. Eğer XSLT işlemci bu XML sürümünü desteklemiyorsa, desteklediği XMl sürümünü kullanmalıdır. Eğer çıktı xML bildirimini içerecekse, bu bildirimde XSLT işlemcinin desteklediği sürüm numarasına karşı düşen çıktılama yapılmalıdır. Öntanımlı değer 1.0'dır. Eğer değer 1.1 ise ve XSLT işlemci XML 1.1 ve XML 1.1 için İsim-alanlarını destekliyorsa, çıktıya aşağıdaki kısıtlamalar uygulanır:

  • Bildirimsiz önekler yer almamalıdır

  • Unicode normalleştirmesi yer almamalıdır.

encoding özniteliğiyle hedef ağacı çıktılamakta kullanılacak karakter kodlaması tercihi belirtilir. XSLT işlemcilerinin UTF-8 ve UTF-16 değerlerini kabul etmeleri gerekir. Diğer değerler için, eğer XSLT işlemci bunları desteklemiyorsa bunu hata olarak raporlayabiyir, raporlamıyorsa, UTF-8 veya UTF-16 kodlanmış çıktılama yapmalıdır. XSLT işlemci, [XML] ve [XML 1.1] önergelerinin KodlamaAdı sözdizimi ile eşleşmeyen kodlama isimlerini kullanmaması gerekir. encoding özniteliği kullanılmamışsa, XSLT işlemcinin UTF-8 veya UTF-16 kodlanmış çıktılama yapması gerekir.

Hedef ağacın, XSLT işlemcinin çıktılama için kullandığı kodlamada bulunmayan bir karakteri içermesi olasıdır. Bu durumda, eğer karakter XML'in karakter gönderimlerini tanıdığı bir bağlamda yer alıyorsa (örn, bir öznitelik değerinde veya bir metin düğümünde), karakterin bir karakter gönderimi olarak çıktılanması gerekir; aksi takdirde (örn, karakter bir eleman isminde yer alıyorsa), XSLT işlemci hatayı raporlamalıdır.

Eğer indent özniteliği yes değeri ile kullanılmışsa, xml çıktılama yöntemi, sonucun göze hoş görünecek şekilde girintilenmesi için hedef ağaçta mevcut boşluk karakterlerine ek olarak (muhtemelen biçembent ve kaynak belgedeki boşluk ayıklamaya uygun olarak), ek boşluklar çıktılayabilir; eğer özniteliğin değeri olarak no belirtilmişse, ilave bir boşluk çıktılanmayacaktır. Öntanımlı değer no'dur. xml çıktılama yöntemi ek boşlukları çıktılamak için bir algoritma kullanmalıdır; bu algoritma, boşluklar çıktıdan ayıklanırken, sadece xsl:text elemanlarından oluşan boşlukları korunacak elemanlar listesiyle Boşluk Ayıklama bölümünde açıklandığı gibi ayıklanıyorsa, ek boşlukların çıktılanması ile çıktılanmaması arasında bir fark olmayacak şekilde çıktılamayı sağlamalıdır.

Not:
Karışık içerikli eleman türleri içeren belge türleri için indent="yes" kullanmak iyi sonuç vermeyecektir.

cdata-section-elements özniteliği boşluk ayraçlı olarak NitelAdlardan oluşan bir liste içerebilir. Her NitelAd yer aldığı xsl:output elemanında etkili olan isim-alanı bildirimleri kullanılarak bir genişletilmiş isme genişletilir; eğer bir öntanımlı isim-alanı varsa, öneksiz NitelAdlar kullanılır. Genişletme işlemi çok sayıda xsl:output elemanı tek bir xsl:output elemanı olarak birleştirilmeden önce yapılır. Eğer bir metin düğümünün ebeveyninin genişletilmiş ismi bu listenin bir üyesiyse, metin düğümü bir CDATA bölümü olarak çıktılanacaktır. Örneğin,

<xsl:output cdata-section-elements="example"/>

yönergesi, biçembentte

<example>&lt;foo></example>

veya

<example><![CDATA[<foo>]]></example>

olarak yer alan bir birebir hedef elemanının şöyle çıktılanmasına sebep olacaktır:

<example><![CDATA[<foo>]]></example>

Eğer metin düğümü ]]> dizgesini içeriyorsa, açık olan CDATA bölümü ]] karakterlerinden sonra kapanır ve > karakterinden önce yenisi açılır. Örneğin, bir birebir hedef elemanı biçembentte şöyle yer alıyor olsun:

<example>]]&gt;</example>

Bunun çıktısı şöyle olurdu:

<example><![CDATA[]]]]><![CDATA[>]]></example>

Eğer metin düğümü hedef ağacı çıktılamakta kullanılan karakter kodlaması ile gösterilemeyecek bir karakter içeriyorsa, açık olan CDATA bölümü bu karakterden önce kapatılmalı, karakter bir karakter veya öğe gönderimi olarak çıktılandıktan sonra metnin kalanı için yeni bir CDATA bölümü açılmalıdır.

CDATA bölümleri, cdata-section-elements özniteliğinde açıkça CDATA bölümü olarak çıktılanmak üzere belirtilmiş olan metin düğümleri haricinde kullanılmamalıdır.

xml çıktılama yönteminin, omit-xml-declaration özniteliği yes değeri ile kullanılmış olmadıkça bir XML bildirimi çıktılaması gereklidir. XML bildirimi hem hem sürüm bilgisi hem de karakter kodlaması belirtimini içermelidir. Eğer standalone özniteliği belirtilmişse, bir tekbaşına belge bildiriminin de standalone özniteliğinde belirtilen değerle XML bildiriminde yer alması gerekir. Aksi takdirde, XML bildirimi bir tekbaşına belge bildirimi içermemelidir. Bu kural, hem XML bildirimine (bir belge öğesinin başında bulunur) hem de metin bildirimine (bir harici genel çözümlü öğenin başında bulunur) uygulanır.

Eğer doctype-system özniteliği belirtilmişse, xml çıktılama yöntemi, ilk elemandan hemen önce bir belge türü bildirimi çıktılayacaktır. <!DOCTYPE'i takibeden isim ilk elemanın ismiyle aynı olmak zorundudır. Bir de doctype-public özniteliği belirtilmişse, xml çıktılama yöntemi, bir PUBLIC ile bunu izleyen bir genel betimleyici ve bir sistem betimleyicisi çıktılayacaktır; aksi takdirde, bir SYSTEM ile bunu izleyen bir sistem betimleyicisi çıktılayacaktır. Dahili altküme boş olmalıdır. doctype-system özniteliği belirtilmiş olmadığı takdirde, doctype-public özniteliği yok sayılmalıdır.

media-type özniteliği xml çıktılama yöntemi için uygulanabilir olup öntanımlı değeri text/xml'dir.

16.2 HTML Çıktılama Yöntemi

html çıktılama yöntemi hedef ağacı HTML olarak çıktılar; örnek:

<xsl:stylesheet version="1.0"
                xmlns:xsl="http://www.w3.org/1999/XSL/Transform">

<xsl:output method="html"/>

<xsl:template match="/">
  <html>
   <xsl:apply-templates/>
  </html>
</xsl:template>

...

</xsl:stylesheet>

version özniteliği ile HTML sürümü belirtilir ve öntanımlı değeri 4.0 olup, çıktının HTML 4.0 [HTML] önergesi ile uyumlu olacağını belirtir.

html çıktılama yöntemi, genişletilmiş ismi tanımsız bir isim-alanı tanım-yerine sahip olmadıkça bir elemanı xml çıktılama yönteminden farklı bir biçimde çıktılamamalıdır; genişletilmiş ismi tanımlı bir isim-alanı tanım-yerine sahip bir eleman XML olarak çıktılanmalıdır. Eğer bir elemanın genişletilmiş ismi tanımsız isim-alanı tanım-yerine sahipse, ancak genişletilmiş ismin yerel kısmı bir HTML eleman olarak tanınmıyorsa, span gibi bir satıriçi eleman olarak boş olmayacak şekilde çıktılanmalıdır.

html çıktılama yöntemi, boş elemanlar için bir bitiş etiketi çıktılamamalıdır. HTML 4.0 için boş elemanlar, area, base, basefont, br, col, frame, hr, img, input, isindex, link, meta ve param elemanlarıdır. Örneğin bir eleman biçembette <br/> veya <br></br> biçiminde yazılmışsa, çıktı <br> olacaktır.

html çıktılama yöntemi, HTML elemanlarının isimlerini harf büyüklüğüne duyarsız biçimde algılamalıdır. Örneğin, br, BR veya Br HTML için br elemanı olup bitiş elemanı olmaksızın çıktılanmalıdır.

html çıktılama yöntemi, script ve style elemanlarının içeriği için önceleme uygulamamalıdır. Örneğen bir biçembentte bir birebir hedef eleman şöyle yer alıyor olsun:

<script>if (a &lt; b) foo()</script>

veya

<script><![CDATA[if (a < b) foo()]]></script>

için çıktı şöyle olacaktır:

<script>if (a < b) foo()</script>

html çıktılama yöntemi, öznitelik değerlerinde yer alan < karakterlerini öncelememelidir.

Eğer indent özniteliğini değeri yes ise, html çıktılama yöntemi, HTML tarayıcısının çıktıyı oluşturma yöntemini değiştirmediği sürece hedef ağaca çıktılanan boşluk karakterlerine ekleme yapabileceği gibi bunları silebilir de.

html çıktılama yöntemi, HTML 4.0 Önergesinin B 2.1 ek bölümünde önerilen yöntemi kullanarak tanım-yeri (URI) öznitelik değerlerindeki ASCII olmayan karakterleri öncelemelidir.

html çıktılama yöntemi, bir karakteri, eğer çıktılama yönteminde kullanılan HTML sürümünde tanımlıysa, bir karakter öğesi gönderimi kullanarak çıktılayabilir.

html çıktılama yöntemi, işlem yönergelerini ?> ile değil, > ile sonlandırmalıdır.

html çıktılama yöntemi, mantıksal değerli öznitelikleri (değerleri olarak kendi isimleri verilmiş öznitelikler) kısaltılmış biçimde çıktılamalıdır. Örneğin başlangıç etiketi,

<OPTION selected="selected">

biçiminde yazılmışsa, bunun çıktısı şöyle olurdu:

<OPTION selected>

html çıktılama yöntemi, bir öznitelik değerinde { karakterinin önünde bir & karakteri yer alıyorsa bu karakteri öncelememelidir (HTML 4.0 Önergesinin B 7.1.1 ek bölümüne bakınız). Örneğin bir biçembentte bir başlangıç etiketi şöyle yer alıyor olsun:

<BODY bgcolor='&amp;{{randomrbg}};'>

Bu örneklenim şöyle çıktılanmalıdır:

<BODY bgcolor='&{randomrbg};'>

encoding özniteliği ile tercih edilen karakter kodlaması belirtilir. Bir HEAD elemanı varsa html çıktılama yöntemi bu elemanın başlangıç etiketinin hemen ardına kullanılan karakter kodlamasının belirtildiği bir META elemanını eklemesi gerekir. Örnek:

<HEAD>
<META http-equiv="Content-Type" content="text/html; charset=EUC-JP">
...

Hedef ağacın, XSLT işlemcinin çıktılama için kullandığı karakter kodlamasında bulunmayan bir karakteri içermesi olasıdır. Eğer bu karakter, HTML'nin karakter gönderimlerini tanıdığı bir bağlamda yer alıyorsa, karakter bir karakter öğesi gönderimi olarak veya onluk sayılı karakter gönderimi olarak çıktılanmalıdır; aksi takdirde (örneğin, bir script veya style elemanında veya bir açıklamada), XSLT işlemci durumu hata olarak bildirmelidir.

Eğer doctype-public veya doctype-system öznitelikleri belirtilmişse, html çıktılama yönteminin ilk elemandan hemen önce bir belge türü bildirimi çıktılaması gerekir. Bu bildirimde, <!DOCTYPE dizgesinden sonra gelen isim HTML veya html olmalıdır. doctype-public özniteliği belirtilmişse, öznitelik değerini (genel betimleyici) PUBLIC ibaresinden sonra eklemelidir; doctype-system özniteliği de ayrıca belirtilmişse, bunun değerinin (sistem betimleyici) de genel betimleyicinin ardından çıktılanması gerekir. Eğer doctype-system özniteliği, doctype-public olmaksızın tek başına belirtilmişse, çıktılama yöntemi bu değeri SYSTEM ibaresinin ardına ekleyerek çıktılamalıdır.

media-type özniteliği de html çıktılama yönteminde uygulanabilir olup öntanımlı değeri text/html'dir.

16.3 Metin Çıktılama Yöntemi

text çıktılama yöntemi, hedef ağacı çıktıda, hedef ağaçtaki her metin düğümünün değerini belgedeki sıraya uygun olarak ve buna herhangi bir önceleme uygulamaksızın çıktılamak suretiyle oluşturur.

media-type özniteliği text çıktılama yönteminde uygulanabilir olup öntanımlı değeri text/plain'dir..

encoding özniteliği ile text çıktılama yönteminin karakter dizilerini bayt dizilerine dönüştürürken kullanacağı karakter kodlaması belirtilir. Öntanımlı değer sisteme bağlıdır. Eğer hedef ağaç, XSLT işlemcinin çıktılama için kullandığı karakter kodlamasıyla ifade edilemeyen bir karakter içeriyorsa, XSLT işlemcinin bunu bir haka olarak bildirmesi gerekir.

16.4 Çıktı Önceleniminin İptal Edilmesi

Normalde, xml çıktılama yöntemi & ve < karakterlerini (ve olası diğer karakterleri) metin düğümlerini çıktılarken önceler. Bu, çıktının iyi biçimli XML olması için gereklidir. Bununla birlikte, bazan çıktının iyi biçimli XML olarak çıktılanmaması daha uygun olabilir; örneğin, çıktı, sonradan XML'e duyarlı olmayan bir süreç tarafından iyi biçimli XML'e dönüştürüleceği düşünülen yetersiz biçimlenmiş bölümler içerebilir. Bu amaca uygun olarak, XSLT, çıktı önceleniminin iptalini mümkün kılan bir mekanizma sağlar. xsl:value-of ve xsl:text elemanlarının disable-output-escaping diye, no öntanımlı olmak üzere değer olarak sadece yes veya no kabul eden bir öznitelikleri olabilir; eğer değer yes ise, xsl:value-of veya xsl:text ile üretilen metin düğümü herhangi bir öncelenim uygulanmaksızın çıktılanacaktır. Örnek:

<xsl:text disable-output-escaping="yes">&lt;</xsl:text>

yönergesi tek bir < karakteri üretecektir.

Bir kök düğüm, öncelenim, kök düğümünün astsalları için iptal edilmiş durumda bir xsl:copy-of elemanı kullanılarak kopyalanırken (bkz Değişken ve Değergeçlerin Değerlerinin xsl:copy-of ile Kullanımı), öncelenim, metin düğümünün çıktılanan kopyası için ayrıca iptal edilmiş olmalıdır. Örnek:

<xsl:variable name="x">
  <xsl:text disable-output-escaping="yes">&lt;</xsl:text>
</xsl:variable>
<xsl:copy-of select="$x"/>

Bu örneklenim &lt; değil < çıktılayacaktır.

Bir metin düğümü için çıktı önceleniminin iptal edilmiş oluşunun hedef ağaçta metin düğümünün çıktılanması amacının dışında kullanılması bir hatadır. Bu bakımdan, bir açıklama, işlem yönergesi veya bir öznitelik düğümünü üretmek için bir xsl:value-of veya xsl:text elemanını, çıktı öncelenimini iptal ederek kullanmak bir hatadır; ayrıca, eğer hedef ağaç bölümü öncelenimin iptal edildiği bir metin düğümü içeriyorsa, bir hedef ağaç bölümünü bir sayı veya dizgeye dönüştürmek de bir hatadır. Her iki durumda da, bir XSLT işlemci htayı raporlayabilir, raporlamıyorsa, disable-output-escaping özniteliğini yoksayarak hatadan kurtulmalıdır.

disable-output-escaping özniteliği xml çıktılama yönteminden başka html çıktılama yönteminde de kullanılabilir. text çıktılama yönteminde herhangi bir çıktı öncelenimi zaten yapılmadığından, disable-output-escaping özniteliği yoksayılır.

Bir XSLT işlemcinin çıktı öncelenimini iptal edebileceği tek durum, hedef ağacın nasıl çıktılanacağını denetleyebildiği durumdur. Yine de, bu hep böyle olmayabilir. Örneğin, hedef ağaç çıktılanmak yerine başka bir hedef ağacın çıktılanmasına kaynaklık edebilir. Bu durumda XSLT işlemcinin çıktı önceleniminin iptal edilmesini desteklemesi gerekmez. Eğer bir xsl:value-of veya xsl:text elemanı çıktı öncelenimi iptal edilerek kullanılmışsa ve XSLT işlemci de bunu desteklemiyorsa, XSLT işlemci durumu hata olarak raporlayabilir, raporlamıyorsa, çıktı öncelenimini iptal etmeyerek hatadan kurtulmalıdır.

Eğer çıktı öncelenimin iptali, XSLT işlemcinin çıktılama için kullandığı kodlama tarafından desteklenmeyen bir karakter için kullanılmışsa, XSLT işlemci durumu bir hata olarak raporlayabilir, raporlamıyorsa, çıktı öncelenimini iptal etmeyerek hatadan kurtulmalıdır.

Çıktı önceleniminin iptali bütün XSLT işlemcilerle çalışmayabileceğinden ve XML için çıktı iyi biçimli olmayabileceğinden sadece başka çare yoksa kullanılmalıdır.

17 Uyumluluk

Bir uyumlu XSLT işlemci, bir biçembendi bir kaynak ağacı bir hedef ağaca bu belirtimde belirtildiği gibi dönüştürmek için kullanabilen işlemcidir. Bir uyumlu XSLT işlemciden beklenen, sonucu XML veya bir başka biçimde çıktılayabiliyor olması değildir.

Not:
XSLT işlemci üreticilerine, işlemcilerinin hedef ağacı XML olarak çıktılarken uyumlu davranmakta olduğunu doğrulayacak bir yöntem sunmaları veya hedef ağaca DOM veya SAX gibi bir standart yazılım geliştirme arayüzü üzerinden erişmeye imkan sağlamaları önemle tavsiye edilir.

Bir uyumlu XSLT işlemci, bu belgede özellikle bir XSLT işlemci tarafından bildirilmemesinin istendiği durumlar haricindeki bütün hataları bildirmesi gerekir. Bir uyumlu XSLT işlemciden beklenen, bildirdiği hatalı durumdan kurtarabilmesi değildir, ama kurtarabilirse iyi olur.

Bir uyumlu XSLT işlemci, bir biçembendin işlenmesi için gereken sistem kaynaklarının sınırları konusunda belirleyici olmayabilir.

18 Gösterim

Her XSLT tanımlı eleman türünün belirtiminde önce o eleman türünden elemanlar için bir model teşkil edecek şekilde bir sözdizimi özeti verilmiştir. Bu özet sözdizimi gösterimine anlam yükleme işlemi şöyle yapılmıştır:

A Kaynakça

A.1 Uyulması Gerekenler

XML
World Wide Web Consortium, Genişletilebilir İmlenim Dili (XML) 1.0, W3C Önergesi, Uyulması zorunlu İngilizce sürümü http://www.w3.org/TR/xml adresindedir.
XML Adları
World Wide Web Consortium, XML 1.0'da İsim-alanları, W3C Önergesi, Uyulması zorunlu İngilizce sürümü http://www.w3.org/TR/xml-names adresindedir.
XML 1.1
World Wide Web Consortium, Genişletilebilir İmlenim Dili (XML) 1.1, W3C Önergesi, Uyulması zorunlu İngilizce sürümü http://www.w3.org/TR/xml11/ adresindedir.
XML Adları 1.1
World Wide Web Consortium, XML 1.1'de İsim-alanları, W3C Önergesi, Uyulması zorunlu İngilizce sürümü http://www.w3.org/TR/xml-names11/ adresindedir.
XPath
World Wide Web Consortium, XML Adresleme Dili, W3C Önergesi, Uyulması zorunlu İngilizce sürümü http://www.w3.org/TR/xpath adresindedir.

A.2 Diğerleri

CSS2
World Wide Web Consortium. Basamaklı Biçembentler, 2. seviye (CSS2). W3C Önergesi.
DSSSL
Uluslararası Standartlaşım Örgütü, Uluslararası Elektroteknik Komisyonu. ISO/IEC 10179:1996. Belge Biçem Anlambilimi ve Belirtim Dili (DSSSL). Uluslararası Standart.
HTML
World Wide Web Consortium. HTML 4.0 Belirtimi. W3C Önergesi.
IANA
Internet Assigned Numbers Authority. Karakter Kümeleri.
RFC2278
N. Freed, J. Postel. IANA Karakter Kümesi Sicil kaydı İşlemleri. IETF RFC 2278.
RFC2376
E. Whitehead, M. Murata. XML Ortam Türleri. IETF RFC 2376.
RFC2396
T. Berners-Lee, R. Fielding ve L. Masinter. TekBiçimli Özkaynak Betimleyiciler (URI): Soysal Sözdizimi. IETF RFC 2396.
UNICODE TR10
Unicode Consortium. Unicode Teknik Rapor #10. Unicode Collation Algorithm. Unicode Technical Report.
XHTML
World Wide Web Consortium. XHTML 1.0: Genişletilebilir HiperMetin İmlenim Dili. W3C Önergesi.
XPointer
World Wide Web Consortium. XML Gösterici Dili (XPointer). W3C Çalışma Taslağı.
XML Stylesheet
World Wide Web Consortium. Biçembentlerin XML Belgelerle İlişkilendirilmesi W3C Önergesi, Uyulması zorunlu İngilizce sürümü http://www.w3.org/TR/xml-stylesheet adresindedir.
XSL
World Wide Web Consortium. Genişletilebilir Biçembent Dili (XSL). W3C Önergesi.

B Elemanların Özet Sözdizimleri

<!-- Grubu: yönerge -->
<xsl:apply-imports />
eleman
<!-- Grubu: yönerge -->
<xsl:apply-templates
  select = düğüm-kümesi-ifadesi
  mode = nitelikli-ad >
  <!-- İçeriği: (<xsl:sort> | <xsl:with-param>) -->
</xsl:apply-templates>
eleman
<!-- Grubu: yönerge -->
<xsl:attribute
  name = { nitelikli-ad }
  namespace = { tanım-yeri-başvurusu } >
  <!-- İçeriği: örneklenim -->
</xsl:attribute>
eleman
<!-- Grubu: tepe-seviyeden-eleman -->
<xsl:attribute-set
  name = nitelikli-ad
  use-attribute-sets = nitelikli-adlar >
  <!-- İçeriği: <xsl:attribute>* -->
</xsl:attribute-set>
eleman
<!-- Grubu: yönerge -->
<xsl:call-template
  name = nitelikli-ad >
  <!-- İçeriği: <xsl:with-param>* -->
</xsl:call-template>
eleman
<!-- Grubu: yönerge -->
<xsl:choose>
  <!-- İçeriği: (<xsl:when>+ | <xsl:otherwise>?) -->
</xsl:choose>
eleman
<!-- Grubu: yönerge -->
<xsl:comment>
  <!-- İçeriği: örneklenim -->
</xsl:comment>
eleman
<!-- Grubu: yönerge -->
<xsl:copy
  use-attribute-sets = nitelikli-adlar >
  <!-- İçeriği: örneklenim -->
</xsl:copy>
eleman
<!-- Grubu: yönerge -->
<xsl:copy-of
  select = ifade />
eleman
<!-- Grubu: tepe-seviyeden-eleman -->
<xsl:decimal-format
  name = nitelikli-ad
  decimal-separator = karakter
  grouping-separator = karakter
  infinity = dizge
  minus-sign = karakter
  NaN = dizge
  percent = karakter
  per-mille = karakter
  zero-digit = karakter
  digit = karakter
  pattern-separator = karakter />
eleman
<!-- Grubu: yönerge -->
<xsl:element
  name = { nitelikli-ad }
  namespace = { tanım-yeri-başvurusu }
  use-attribute-sets = nitelikli-adlar >
  <!-- İçeriği: örneklenim -->
</xsl:element>
eleman
<!-- Grubu: yönerge -->
<xsl:fallback>
  <!-- İçeriği: örneklenim -->
</xsl:fallback>
eleman
<!-- Grubu: yönerge -->
<xsl:for-each
  select = düğüm-kümesi-ifadesi >
  <!-- İçeriği: (<xsl:sort>*, örneklenim) -->
</xsl:for-each>
eleman
<!-- Grubu: yönerge -->
<xsl:if
  test = mantıksal-ifade >
  <!-- İçeriği: örneklenim -->
</xsl:if>
eleman
<xsl:import
  href = tanım-yeri-başvurusu />
eleman
<!-- Grubu: tepe-seviyeden-eleman -->
<xsl:include
  href = tanım-yeri-başvurusu />
eleman
<!-- Grubu: tepe-seviyeden-eleman -->
<xsl:key
  name = nitelikli-ad
  match = örüntü
  use = ifade />
eleman
<!-- Grubu: yönerge -->
<xsl:message
  terminate = "yes" | "no" >
  <!-- İçeriği: örneklenim -->
</xsl:message>
eleman
<!-- Grubu: tepe-seviyeden-eleman -->
<xsl:namespace-alias
  stylesheet-prefix = önek | "#default"
  result-prefix = önek | "#default" />
eleman
<!-- Grubu: yönerge -->
<xsl:number
  level = "single" | "multiple" | "any"
  count = örüntü
  from = örüntü
  value = sayısal-ifade
  format = { dizge }
  lang = { ad-dizgeciği }
  letter-value = { "alphabetic" | "traditional" }
  grouping-separator = { karakter }
  grouping-size = { sayı } />
eleman
<xsl:otherwise>
  <!-- İçeriği: örneklenim -->
</xsl:otherwise>
eleman
<!-- Grubu: tepe-seviyeden-eleman -->
<xsl:output
  method = "xml" | "html" | "text" | nitelikli-ad-ama-kısa-ad-değil
  version = ad-dizgeciği
  encoding = dizge
  omit-xml-declaration = "yes" | "no"
  standalone = "yes" | "no"
  doctype-public = dizge
  doctype-system = dizge
  cdata-section-elements = nitelikli-adlar
  indent = "yes" | "no"
  media-type = dizge />
eleman
<!-- Grubu: tepe-seviyeden-eleman -->
<xsl:param
  name = nitelikli-ad
  select = ifade >
  <!-- İçeriği: örneklenim -->
</xsl:param>
eleman
<!-- Grubu: tepe-seviyeden-eleman -->
<xsl:preserve-space
  elements = dizgecikler />
eleman
<!-- Grubu: yönerge -->
<xsl:processing-instruction
  name = { kısa-ad } >
  <!-- İçeriği: örneklenim -->
</xsl:processing-instruction>
eleman
<xsl:sort
  select = dizgesel-ifade
  lang = { ad-dizgeciği }
  data-type = { "text" | "number" | nitelikli-ad-ama-kısa-ad-değil }
  order = { "ascending" | "descending" }
  case-order = { "upper-first" | "lower-first" } />
eleman
<!-- Grubu: tepe-seviyeden-eleman -->
<xsl:strip-space
  elements = dizgecikler />
eleman
<xsl:stylesheet
  id = id
  extension-element-prefixes = dizgecikler
  exclude-result-prefixes = dizgecikler
  version = sayı >
  <!-- İçeriği: (<xsl:import>*, tepe-seviyeden-elemanlar) -->
</xsl:stylesheet>
eleman
<!-- Grubu: tepe-seviyeden-eleman -->
<xsl:template
  match = örüntü
  name = nitelikli-ad
  priority = sayı
  mode = nitelikli-ad >
  <!-- İçeriği: (<xsl:param>*, örneklenim) -->
</xsl:template>
eleman
<!-- Grubu: yönerge -->
<xsl:text
  disable-output-escaping = "yes" | "no" >
  <!-- İçeriği: #PCDATA -->
</xsl:text>
eleman
<xsl:transform
  id = id
  extension-element-prefixes = dizgecikler
  exclude-result-prefixes = dizgecikler
  version = sayı >
  <!-- İçeriği: (<xsl:import>*, tepe-seviyeden-elemanlar) -->
</xsl:transform>
eleman
<!-- Grubu: yönerge -->
<xsl:value-of
  select = dizgesel-ifade
  disable-output-escaping = "yes" | "no" />
eleman
<!-- Grubu: tepe-seviyeden-eleman -->
<!-- Grubu: yönerge -->
<xsl:variable
  name = nitelikli-ad
  select = ifade >
  <!-- İçeriği: örneklenim -->
</xsl:variable>
eleman
<xsl:when
  test = mantıksal-ifade >
  <!-- İçeriği: örneklenim -->
</xsl:when>
eleman
<xsl:with-param
  name = nitelikli-ad
  select = ifade >
  <!-- İçeriği: örneklenim -->
</xsl:with-param>
eleman

C XSLT Biçembentlerinde DTD Bölümü (Bilgilendirici)

Not:
XML 1.0 DTD'leri XML isim-alanlarını desteklemediğinden bu DTD Bölümü bilgilendirici niteliktedir ve bu bakımdan bir XSLT biçembendinde izin verilen yapıyı gerektiği gibi açıklayamaz.

Aşağıdaki öğe, belli bir hedef DTD'sinin nesnel sonucunu oluşturacak XSLT biçembentleri için bir DTD oluşturmakta kullanılabilir. Öğeye atıfta bulunmadan önce, biçembent DTD'si izin verilen hedef eleman türlerini listeleyen bir result-elements değergeç öğesi tanımlamalıdır. Örnek:

<!ENTITY % result-elements "
  | fo:inline-sequence
  | fo:block
">

Böyle hedef elemanları xsl:use-attribute-sets ve xsl:extension-element-prefixes özniteliklerine sahip olarak bildirilmelidir. Aşağıdaki öğe, result-element-atts değergecini bu amaçla bildirmektedir. XSLT'nin hedef elemanlar için izin verdiği içerik, %template; içerik modeliyle aşağıda öğede bildirilen XSLT elemanları için izin verilenlerle aynıdır. DTD, hedef DTD'nin kısıtlamalarına uygun olarak %template;'den daha kısıtlayıcı içerik modelleri kullanabilir.

XSLT isim-alanından farklı isim-alanlarındaki tepe-seviyeden elemanlara da izin vermek için DTD non-xsl-top-level diye bir değergeç öğesi tanımlayabilir.

Bu DTD'deki xsl: öneki kullanımı XSLT biçembentlerinin bu öneki kullanmaları zorunludur anlamında ele alınmamalıdır. Bu DTD'de bildirilmiş herhangi bir eleman, bu DTD'de bildirilmiş özniteliklere ek olarak isimleri xmlns'e eşit veya xmlns: ile başlayan özniteliklere sahip olabilir.

<!ENTITY % char-instructions "
  | xsl:apply-templates
  | xsl:call-template
  | xsl:apply-imports
  | xsl:for-each
  | xsl:value-of
  | xsl:copy-of
  | xsl:number
  | xsl:choose
  | xsl:if
  | xsl:text
  | xsl:copy
  | xsl:variable
  | xsl:message
  | xsl:fallback
">

<!ENTITY % instructions "
  %char-instructions;
  | xsl:processing-instruction
  | xsl:comment
  | xsl:element
  | xsl:attribute
">

<!ENTITY % char-template "
 (#PCDATA
  %char-instructions;)*
">

<!ENTITY % template "
 (#PCDATA
  %instructions;
  %result-elements;)*
">

<!-- Değeri bir tanım-yeri başvurusu olan
     bir öznitelik türü için kullanılır. -->
<!ENTITY % URI "CDATA">

<!-- Değeri bir örüntü olan bir öznitelik türü için kullanılır. -->
<!ENTITY % pattern "CDATA">

<!-- Değeri bir öznitelik değeri örneklenimi
     olan bir öznitelik türü için kullanılır. -->
<!ENTITY % avt "CDATA">

<!-- Değeri bir NitelAd olan bir öznitelik türü için kullanılır;
     önek, XSLT işlemcinin yorumladığı bir önek olacaktır. -->
<!ENTITY % qname "NMTOKEN">

<!-- %qname; gibi ama bu onların boşluk ayraçlı bir listesi. -->
<!ENTITY % qnames "NMTOKENS">

<!-- Değeri bir ifade olan bir öznitelik türü için kullanılır. -->
<!ENTITY % expr "CDATA">

<!-- Değeri tek bir karakterden oluşan
     bir öznitelik türü için kullanılır. -->
<!ENTITY % char "CDATA">

<!-- Değeri bir öncelik belirten bir
     öznitelik türü için kullanılır. -->
<!ENTITY % priority "NMTOKEN">

<!ENTITY % space-att "xml:space (default|preserve) #IMPLIED">

<!-- Bu tepe-seviyede izin verilmiş eleman listesini
     genişleten bir özelleştirme olabilir. -->
<!ENTITY % non-xsl-top-level "">

<!ENTITY % top-level "
 (xsl:import*,
  (xsl:include
  | xsl:strip-space
  | xsl:preserve-space
  | xsl:output
  | xsl:key
  | xsl:decimal-format
  | xsl:attribute-set
  | xsl:variable
  | xsl:param
  | xsl:template
  | xsl:namespace-alias
  %non-xsl-top-level;)*)
">

<!ENTITY % top-level-atts '
  extension-element-prefixes CDATA   #IMPLIED
  exclude-result-prefixes    CDATA   #IMPLIED
  id                         ID      #IMPLIED
  version                    NMTOKEN #REQUIRED
  xmlns:xsl                  CDATA   #FIXED    "http://www.w3.org/1999/XSL/Transform"
  %space-att;
'>

<!-- Bu öğe hedef elemanların ATTLIST bildirimlerinde
     kullanmak için tanımlanmıştır. -->

<!ENTITY % result-element-atts '
  xsl:extension-element-prefixes CDATA    #IMPLIED
  xsl:exclude-result-prefixes    CDATA    #IMPLIED
  xsl:use-attribute-sets         %qnames; #IMPLIED
  xsl:version                    NMTOKEN  #IMPLIED
'>

<!ELEMENT xsl:stylesheet %top-level;>
<!ATTLIST xsl:stylesheet %top-level-atts;>

<!ELEMENT xsl:transform %top-level;>
<!ATTLIST xsl:transform %top-level-atts;>

<!ELEMENT xsl:import EMPTY>
<!ATTLIST xsl:import href %URI; #REQUIRED>

<!ELEMENT xsl:include EMPTY>
<!ATTLIST xsl:include href %URI; #REQUIRED>

<!ELEMENT xsl:strip-space EMPTY>
<!ATTLIST xsl:strip-space elements CDATA #REQUIRED>

<!ELEMENT xsl:preserve-space EMPTY>
<!ATTLIST xsl:preserve-space elements CDATA #REQUIRED>

<!ELEMENT xsl:output EMPTY>
<!ATTLIST xsl:output
  method                 %qname;  #IMPLIED
  version                NMTOKEN  #IMPLIED
  encoding               CDATA    #IMPLIED
  omit-xml-declaration  (yes|no)  #IMPLIED
  standalone            (yes|no)  #IMPLIED
  doctype-public         CDATA    #IMPLIED
  doctype-system         CDATA    #IMPLIED
  cdata-section-elements %qnames; #IMPLIED
  indent                (yes|no)  #IMPLIED
  media-type             CDATA    #IMPLIED
>

<!ELEMENT xsl:key EMPTY>
<!ATTLIST xsl:key
  name    %qname;   #REQUIRED
  match   %pattern; #REQUIRED
  use     %expr;    #REQUIRED
>

<!ELEMENT xsl:decimal-format EMPTY>
<!ATTLIST xsl:decimal-format
  name               %qname; #IMPLIED
  decimal-separator  %char;  "."
  grouping-separator %char;  ","
  infinity           CDATA   "Infinity"
  minus-sign         %char;  "-"
  NaN                CDATA   "NaN"
  percent            %char;  "%"
  per-mille          %char;  "&#x2030;"
  zero-digit         %char;  "0"
  digit              %char;  "#"
  pattern-separator  %char;  ";"
>

<!ELEMENT xsl:namespace-alias EMPTY>
<!ATTLIST xsl:namespace-alias
  stylesheet-prefix CDATA #REQUIRED
  result-prefix     CDATA #REQUIRED
>

<!ELEMENT xsl:template
 (#PCDATA
  %instructions;
  %result-elements;
  | xsl:param)*
>

<!ATTLIST xsl:template
  match    %pattern;  #IMPLIED
  name     %qname;    #IMPLIED
  priority %priority; #IMPLIED
  mode     %qname;    #IMPLIED
  %space-att;
>

<!ELEMENT xsl:value-of EMPTY>
<!ATTLIST xsl:value-of
  select                  %expr;   #REQUIRED
  disable-output-escaping (yes|no) "no"
>

<!ELEMENT xsl:copy-of EMPTY>
<!ATTLIST xsl:copy-of select %expr; #REQUIRED>

<!ELEMENT xsl:number EMPTY>
<!ATTLIST xsl:number
   level  (single|multiple|any) "single"
   count  %pattern; #IMPLIED
   from   %pattern; #IMPLIED
   value  %expr;    #IMPLIED
   format %avt;     '1'
   lang   %avt;     #IMPLIED
   letter-value       %avt; #IMPLIED
   grouping-separator %avt; #IMPLIED
   grouping-size      %avt; #IMPLIED
>

<!ELEMENT xsl:apply-templates (xsl:sort|xsl:with-param)*>
<!ATTLIST xsl:apply-templates
  select %expr; "node()"
  mode %qname; #IMPLIED
>

<!ELEMENT xsl:apply-imports EMPTY>

<!-- xsl:sort, bir boşluk olmayan karakterden
     veya bir imlenimden sonra yer alamaz. -->

<!ELEMENT xsl:for-each
 (#PCDATA
  %instructions;
  %result-elements;
  | xsl:sort)*
>

<!ATTLIST xsl:for-each
  select %expr; #REQUIRED
  %space-att;
>

<!ELEMENT xsl:sort EMPTY>
<!ATTLIST xsl:sort
  select     %expr; "."
  lang       %avt;  #IMPLIED
  data-type  %avt;  "text"
  order      %avt;  "ascending"
  case-order %avt;  #IMPLIED
>

<!ELEMENT xsl:if %template;>
<!ATTLIST xsl:if
  test %expr; #REQUIRED
  %space-att;
>

<!ELEMENT xsl:choose (xsl:when+, xsl:otherwise?)>
<!ATTLIST xsl:choose %space-att;>

<!ELEMENT xsl:when %template;>
<!ATTLIST xsl:when
  test %expr; #REQUIRED
  %space-att;
>

<!ELEMENT xsl:otherwise %template;>
<!ATTLIST xsl:otherwise %space-att;>

<!ELEMENT xsl:attribute-set (xsl:attribute)*>
<!ATTLIST xsl:attribute-set
  name               %qname;  #REQUIRED
  use-attribute-sets %qnames; #IMPLIED
>

<!ELEMENT xsl:call-template (xsl:with-param)*>
<!ATTLIST xsl:call-template
  name %qname; #REQUIRED
>

<!ELEMENT xsl:with-param %template;>
<!ATTLIST xsl:with-param
  name   %qname; #REQUIRED
  select %expr;  #IMPLIED
>

<!ELEMENT xsl:variable %template;>
<!ATTLIST xsl:variable
  name   %qname; #REQUIRED
  select %expr;  #IMPLIED
>

<!ELEMENT xsl:param %template;>
<!ATTLIST xsl:param
  name   %qname; #REQUIRED
  select %expr;  #IMPLIED
>

<!ELEMENT xsl:text (#PCDATA)>
<!ATTLIST xsl:text
  disable-output-escaping (yes|no) "no"
>

<!ELEMENT xsl:processing-instruction %char-template;>
<!ATTLIST xsl:processing-instruction
  name %avt; #REQUIRED
  %space-att;
>

<!ELEMENT xsl:element %template;>
<!ATTLIST xsl:element
  name               %avt;    #REQUIRED
  namespace          %avt;    #IMPLIED
  use-attribute-sets %qnames; #IMPLIED
  %space-att;
>

<!ELEMENT xsl:attribute %char-template;>
<!ATTLIST xsl:attribute
  name      %avt; #REQUIRED
  namespace %avt; #IMPLIED
  %space-att;
>

<!ELEMENT xsl:comment %char-template;>
<!ATTLIST xsl:comment %space-att;>

<!ELEMENT xsl:copy %template;>
<!ATTLIST xsl:copy
  %space-att;
  use-attribute-sets %qnames; #IMPLIED
>

<!ELEMENT xsl:message %template;>
<!ATTLIST xsl:message
  %space-att;
  terminate (yes|no) "no"
>

<!ELEMENT xsl:fallback %template;>
<!ATTLIST xsl:fallback %space-att;>

D Örnekler (Bilgilendirici)

D.1 Belge Örneği

Bu örnekte, basit bir DTD ile uyumlu belgeleri XHTML'ye [XHTML] dönüştürmek için bir biçembent kullanımı gösterilmiştir. DTD şöyledir:

<!ELEMENT doc     (title, chapter*)>
<!ELEMENT chapter (title, (para|note)*, section*)>
<!ELEMENT section (title, (para|note)*)>
<!ELEMENT title   (#PCDATA|emph)*>
<!ELEMENT para    (#PCDATA|emph)*>
<!ELEMENT note    (#PCDATA|emph)*>
<!ELEMENT emph    (#PCDATA|emph)*>

Biçembent böyle:

<xsl:stylesheet version="1.0"
                xmlns:xsl="http://www.w3.org/1999/XSL/Transform"
                xmlns="http://www.w3.org/TR/xhtml1/strict">

<xsl:strip-space elements="doc chapter section"/>
<xsl:output
   method="xml"
   indent="yes"
   encoding="iso-8859-9"
/>

<xsl:template match="doc">
 <html>
   <head>
     <title>
       <xsl:value-of select="title"/>
     </title>
   </head>
   <body>
     <xsl:apply-templates/>
   </body>
 </html>
</xsl:template>

<xsl:template match="doc/title">
  <h1>
    <xsl:apply-templates/>
  </h1>
</xsl:template>

<xsl:template match="chapter/title">
  <h2>
    <xsl:apply-templates/>
  </h2>
</xsl:template>

<xsl:template match="section/title">
  <h3>
    <xsl:apply-templates/>
  </h3>
</xsl:template>

<xsl:template match="para">
  <p>
    <xsl:apply-templates/>
  </p>
</xsl:template>

<xsl:template match="note">
  <p class="note">
    <b>BİLGİ: </b>
    <xsl:apply-templates/>
  </p>
</xsl:template>

<xsl:template match="emph">
  <em>
    <xsl:apply-templates/>
  </em>
</xsl:template>

</xsl:stylesheet>

Kaynak belgemiz böyle olsaydı:

<!DOCTYPE doc SYSTEM "doc.dtd">
<doc>
<title>Belge Başlığı</title>
<chapter>
<title>Fasıl Başlığı</title>
<section>
<title>Bölüm Başlığı</title>
<para>Bu bir denemedir.</para>
<note>Bu bir ek bilgidir.</note>
</section>
<section>
<title>Başka Bir Bölüm Başlığı</title>
<para>Bu da <emph>başka</emph> bir DNMdir.</para>
<note>Bu bir ek malumattır.</note>
</section>
</chapter>
</doc>

Üretilecek hedef belgemiz böyle olurdu:

<?xml version="1.0" encoding="iso-8859-9"?>
<html xmlns="http://www.w3.org/TR/xhtml1/strict">
<head>
<title>Belge Başlığı</title>
</head>
<body>
<h1>Belge Başlığı</h1>
<h2>Fasıl Başlığı</h2>
<h3>Bölüm Başlığı</h3>
<p>Bu bir denemedir.</p>
<p class="note">
<b>BİLGİ: </b>Bu bir ek bilgidir.</p>
<h3>Başka Bir Bölüm Başlığı</h3>
<p>Bu da <em>başka</em> bir DNMdir.</p>
<p class="note">
<b>BİLGİ: </b>Bu ilaveten diğer bir malumattır.</p>
</body>
</html>

D.2 Veri Örneği

Bu örnekte, bir XML belge olarak tutulan veriden üç farklı biçembent kullanarak verinin üç farklı gösterimi (HTML, SVG ve VRML) elde edilmektedir.

Veri girdimiz:

<satışlar>

        <bölge id="Kuzey">
                <gelir>10</gelir>
                <artış>9</artış>
                <ikram>7</ikram>
        </bölge>

        <bölge id="Güney">
                <gelir>4</gelir>
                <artış>3</artış>
                <ikram>4</ikram>
        </bölge>

        <bölge id="Batı">
                <gelir>6</gelir>
                <artış>-1.5</artış>
                <ikram>2</ikram>
        </bölge>

</sales>

Aşağıdaki biçembent, Birebir Hedef Eleman olarak Biçembent bölümünde açıklanan basitleştirilmiş sözdizimini kullanarak veriyi HTML'ye dönüştürmek içindir:

<html xsl:version="1.0"
      xmlns:xsl="http://www.w3.org/1999/XSL/Transform"
      lang="tr">
    <head>
	<title>Bölgelere göre Satış Sonuçları</title>
    </head>
    <body>
	<table border="1">
	    <tr>
		<th>Bölge</th>
		<th>Gelir</th>
		<th>Büyüme</th>
		<th>İkramiye</th>
	    </tr>
	    <xsl:for-each select="satışlar/bölge">
		<!-- sonuçları gelire göre sırala -->
		<xsl:sort select="gelir"
			  data-type="number"
			  order="descending"/>
		<tr>
		    <td>
			<em><xsl:value-of select="@id"/></em>
		    </td>
		    <td>
			<xsl:value-of select="gelir"/>
		    </td>
		    <td>
			<!-- büyüme aslında küçülmeyse kırmızı göster -->
			<xsl:if test="artış &lt; 0">
			     <xsl:attribute name="style">
				 <xsl:text>color:red</xsl:text>
			     </xsl:attribute>
			</xsl:if>
			<xsl:value-of select="artış"/>
		    </td>
		    <td>
			<xsl:value-of select="ikram"/>
		    </td>
		</tr>
	    </xsl:for-each>
	</table>
    </body>
</html>

The HTML output is:

<html lang="en">
<head>
<meta http-equiv="Content-Type" content="text/html; charset=iso-8859-9">
<title>Bölgelere göre Satış Sonuçları</title>
</head>
<body>
<table border="1">
<tr>
<th>Bölge</th><th>Gelir</th><th>Büyüme</th><th>İkramiye</th>
</tr>
<tr>
<td><em>Kuzey</em></td><td>10</td><td>9</td><td>7</td>
</tr>
<tr>
<td><em>Batı</em></td><td>6</td><td style="color:red">-1.5</td><td>2</td>
</tr>
<tr>
<td><em>Güney</em></td><td>4</td><td>3</td><td>4</td>
</tr>
</table>
</body>
</html>

Bu biçembent veriyi SCG'ye dönüştürmek içinder:

<xsl:stylesheet version="1.0"
                xmlns:xsl="http://www.w3.org/1999/XSL/Transform"
                xmlns="http://www.w3.org/Graphics/SVG/SVG-19990812.dtd">

<xsl:output method="xml" indent="yes" media-type="image/svg"/>

<xsl:template match="/">

<svg width = "3in" height="3in">
    <g style = "stroke: #000000">
        <!-- eksenlere çiz -->
        <line x1="0" x2="150" y1="150" y2="150"/>
        <line x1="0" x2="0" y1="0" y2="150"/>
        <text x="0" y="10">Gelir</text>
        <text x="150" y="165">Bölüm</text>
        <xsl:for-each select="satışlar/bölüm">
	    <!-- bazı yararlı değişkenleri tanımlayalım -->

	    <!-- çubuğun x konumu -->
	    <xsl:variable name="pos"
	                  select="(position()*40)-30"/>

	    <!-- çubuğun yüksekliği -->
	    <xsl:variable name="height"
	                  select="gelir*10"/>

	    <!-- dikdörtgen -->
	    <rect x="{$pos}" y="{150-$height}"
                  width="20" height="{$height}"/>

	    <!-- metinsel yafta -->
	    <text x="{$pos}" y="165">
	        <xsl:value-of select="@id"/>
	    </text>

	    <!-- çubuk değeri -->
	    <text x="{$pos}" y="{145-$height}">
	        <xsl:value-of select="gelir"/>
	    </text>
        </xsl:for-each>
    </g>
</svg>

</xsl:template>
</xsl:stylesheet>

SVG çıktısı:

<svg width="3in" height="3in"
     xmlns="http://www.w3.org/Graphics/SVG/svg-19990412.dtd">
    <g style="stroke: #000000">
	<line x1="0" x2="150" y1="150" y2="150"/>
	<line x1="0" x2="0" y1="0" y2="150"/>
	<text x="0" y="10">Gelir</text>
	<text x="150" y="165">Bölüm</text>
	<rect x="10" y="50" width="20" height="100"/>
	<text x="10" y="165">Kuzey</text>
	<text x="10" y="45">10</text>
	<rect x="50" y="110" width="20" height="40"/>
	<text x="50" y="165">Güney</text>
	<text x="50" y="105">4</text>
	<rect x="90" y="90" width="20" height="60"/>
	<text x="90" y="165">Batı</text>
	<text x="90" y="85">6</text>
    </g>
</svg>

Aşağıdaki biçembent veriyi VRML'ye dönüştürmek içindir:

<xsl:stylesheet version="1.0"
                xmlns:xsl="http://www.w3.org/1999/XSL/Transform">

<!-- metni, öntanımlı karakter kümesini kullanarak
     model/vrmlmime türünde üretelim -->
<xsl:output method="text" encoding="UTF-8" media-type="model/vrml"/>

        <xsl:template match="/">#VRML V2.0 utf8

# tek bir bar elemanının externproto tanımı
EXTERNPROTO bar [
  field SFInt32 x
  field SFInt32 y
  field SFInt32 z
  field SFString name
  ]
  "http://www.vrml.org/WorkingGroups/dbwork/barProto.wrl"

# taşıyıcı çizge eksenlerini satıriçine alalım
Inline {
        url "http://www.vrml.org/WorkingGroups/dbwork/barAxes.wrl"
        }

                <xsl:for-each select="satışlar/bölüm">
bar {
        x <xsl:value-of select="gelir"/>
        y <xsl:value-of select="artış"/>
        z <xsl:value-of select="ikram"/>
        name "<xsl:value-of select="@id"/>"
        }
                </xsl:for-each>

        </xsl:template>

</xsl:stylesheet>

VRML çıktısı:

#VRML V2.0 utf8

# tek bir bar elemanının externproto tanımı
EXTERNPROTO bar [
  field SFInt32 x
  field SFInt32 y
  field SFInt32 z
  field SFString name
  ]
  "http://www.vrml.org/WorkingGroups/dbwork/barProto.wrl"

# taşıyıcı çizge eksenlerini satıriçine alalım
Inline {
        url "http://www.vrml.org/WorkingGroups/dbwork/barAxes.wrl"
        }


bar {
        x 10
        y 9
        z 7
        name "Kuzey"
        }

bar {
        x 4
        y 3
        z 4
        name "Güney"
        }

bar {
        x 6
        y -1.5
        z 2
        name "Batı"
        }

E Teşekkür (Bilgilendirici)

Bu taslağın yazımına katkıda bulunanlar:

Bu belirtim W3C XSL Çalışma Grubu (ÇG) tarafından geliştirildi ve yayımı için onaylandı. Bu belirtimin ÇG onayı tüm ÇG üyülerinin onaylarını oylarıyla belirtmelerini gerektirmez. XSL ÇG'nin şu an ki üyeleri:

F Önerge Adaylığından beri Değişenler (Bilgilendirici)

Önerge Adaylığından sonra şu değişiklikler oldu:

G XSLT'nin gelecek sümlerinde ele alınacak özellikler (Bilgilendirici)

XSLT'nin XSLT 1.0'dan sonraki sürümlerinde ele alınması düşünülen özellikler şunlardır: