> For the complete documentation index, see [llms.txt](https://ayakaleaf-pro.ayaka.space/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://ayakaleaf-pro.ayaka.space/latex/tr/derinlemesine-makaleler/54-what-is-a-tex-token-list.md). # TeX belirteç listesi nedir ## Peki, "TeX belirteç listesi" tam olarak nedir? Bir [önceki makale](/latex/tr/derinlemesine-makaleler/53-what-is-a-tex-token.md)—bunun da bir parçası [düşük düzeyli TeX teknikleri serisi](/latex/tr/derinlemesine-makaleler/01-a-new-series-of-articles-tex-tokens-and-related-concepts-but-why-and-how.md)—TeX'in sizin `.tex` dosyanızı yeni belirteçler oluşturmak için taradığı süreçleri inceledik: bir TeX belirtecinin temel niteliğini ve TeX'in bunları nasıl oluşturduğunu ele aldık (bkz. ["TeX belirteci" nedir?](/latex/tr/derinlemesine-makaleler/53-what-is-a-tex-token.md)). Bu devam makalesinde şuna göz atıyoruz: *belirteç listesi*leri: nedirler ve TeX motorları bunları nasıl oluşturur/kullanır? Belirteç listelerini anlamak zor olabilir çünkü TeX'in iç işleyişinin derinliklerinde saklanırlar: bu ayrıntılar kullanıcıdan gizlenmiştir—gerçi günümüzde LuaTeX ile daha gelişmiş programlama yaparsanız bu her zaman doğru değildir. Ancak şimdilik, belirteç listelerini TeX'in bir dizi tamsayı değerini saklama yöntemi olarak düşünebilirsiniz; her tamsayı, TeX'in girdi dosyanızdan okuduğu bir karakterden veya komuttan türetilmiş bir belirteçtir. Belirteç listeleri, TeX'in iç işleyişinde, genellikle şaşırtıcı biçimlerde, örneğin şu tür komutların iç işleyişinde merkezi bir rol oynar: `\\uppercase` ve `\lowercase`. Belirteç listelerinin özellikle önemli bir kullanımı, makroları saklamak ve yürütmektir; bu serinin gelecekteki bir makalesinde ayrıntılı olarak inceleyeceğimiz bir konu. ### TeX girdisini dosyalardan ve belirteç listelerinden alır TeX motorlarının üç girdi kaynağı vardır—bunlardan ikisini biliyor olabilirsiniz: * diskte saklanan fiziksel metin dosyaları; * bir kullanıcının terminale (komut satırına) yazdığı metin; ancak girdiyi okumanın/edinmenin üçüncü bir yolu da vardır: belirteç listeleri! Belirteç listeleri, gerçekte, TeX'in işlemlerinin bir parçası olarak kullandığı dahili bir veri depolama olanağıdır. TeX'in belirteç listeleri önceden oluşturulmuş belirteçler için bir “depolama olanağı” işlevi gördüğünden, TeX'in onları başka bir girdi kaynağı olarak yeniden kullanabilmesi mantıklıdır. Sonraki girdisini belirli bir belirteç listesinden alması gerektiğinde (veya TeX'e bunu yapması söylendiğinde), TeX fiziksel bir dosyadan girdi okumayı geçici olarak durdurur (yani, *yeni belirteçler*) oluşturmayı) ve girdisini şuradan almaya geçer: *mevcut belirteçler*: belirteç listesinin saklandığı bellek içi konum. Açıkça, bir belirteç listesinde belirteçlerin taranması + oluşturulması işlemi zaten gerçekleşmiştir; dolayısıyla TeX'in yalnızca listedeki her belirtece bakıp her biriyle ne yapacağına karar vermesi gerekir. Kısa bir örnek olarak, düşük düzeyli (TeX ilkel) `\\toks` komutu, TeX'in daha sonra yeniden kullanmak üzere belleğe kaydettiği bir belirteç listesi oluşturmanızı sağlar: ```latex \toks100={Hello} ``` Bu belirteçleri geri almak için (yani TeX'e onları sonraki girdi kaynağı olarak ele almasını söylemek için) şöyle bir komut verirsiniz: ```latex \the\toks100 ``` Bu, TeX'in girdi dosyanızdan yeni belirteçler oluşturmaktan, sonraki girdisini bu belirteçlerin (şunun tarafından oluşturulan `\\toks`) saklandığı yerden—sözde bir *belirteç yazmacı* —almaya geçmesine neden olur; bu, yalnızca TeX'in bildiği dahili bir bellek konumudur (burada 100 numaralı yazmaçtır). Ayrıca, belirteç listeleri bir dizi TeX komutu tarafından anında, dahili olarak oluşturulabilir. Bir örnek şu komuttur: `\\jobname` Bu, TeX'in işlediği ana dosyanın adındaki her karakter için bir belirteç olmak üzere bir dizi karakter belirteci üretir. Başka bir örnek de `\string` komutudur; örneğin ```latex \string\mymacro ``` addaki her harf için bir dizi karakter belirteci üretir `\mymacro`—başlangıçtaki `\` karakteri de dahil. Bu makalenin sonunda bazı “belirteç üreten komutlara” daha yakından bakacağız. ## Belirteç listesi: Benzetmeyle açıklama Programlama geçmişiniz ve/veya bilgisayar bilimi konusunda bir miktar bilginiz yoksa, “belirteç listeleri” biraz belirsiz bir kavram ve belki de biraz kafa karıştırıcı olabilir. Ancak TeX/LaTeX makroları yazmada yetkinleşmek istiyorsanız TeX belirteçleri, belirteç listeleri ve kategori kodları (`\catcode`) gibi konuları iyi anlamak son derece yararlı olacaktır. Bu bölümde, bir TeX belirteç listesinin temel fikirlerini/ilkelerini açıklamak/göstermek için bir benzetme kullanacağız: TeX'in belirteçleri bellekte nasıl sakladığını. Bunu okumaya zaman ayırmaya değer çünkü belirteç listeleri TeX'in *temel* bir yönüdür ve biraz daha ayrıntılı anlaşılmaya değerdir. ### Belirteç listeleri: Bir benzetme (düşünce deneyi) TeX belirteç listelerini anlamaya temel sağlamak için bir “düşünce deneyi” üzerinde çalışacağız. Yüzlerce kutu gibi büyük bir kap kümesine erişiminiz olduğunu hayal edin—düşünce deneyimizdeki kapları tanımlamak için “kutu” terimini düşünemeyiz veya kullanamayız çünkü elbette “kutu”, TeX'te buradaki tartışmamızla hiç ilgisi olmayan çok özel bir anlama sahiptir. Bu nedenle kaplarımıza “Teneke Kutular” diyeceğiz; her Teneke Kutu: * dış yüzeyinde basılı benzersiz bir kimlik numarasına sahiptir; * (dahili olarak) iki bölmeye ayrılmıştır. Bu iki bölme şu şekilde tasarlanmıştır: * sol taraftaki bölme, Teneke Kutunun içine koymak istediğiniz öğeyi tutar; * sağ taraftaki bölme, üzerine tek bir sayı yazabileceğiniz bir kâğıt parçasını tutmak üzere tasarlanmıştır: başka bir Teneke Kutuyu tanımlayan sayı. ![test](/files/a93c99dfe01d6ca4b4d6d1667ae5fa69841aedf3) Diyelim ki 5 öğelik bir koleksiyonunuz var ve bu öğe koleksiyonunu bu Teneke Kutularda saklamak istiyorsunuz; ancak ne yazık ki her Teneke Kutu, saklamak istediğiniz türden yalnızca 1 öğe tutabilir. Basitlik için, 5 renkli daire saklamak istediğimizi varsayalım: ![{{{alt}}}](/files/629991c6d7e029ec1e00965a74afc2f493a7fef7) Ayrıca, bu öğeleri depolama sisteminizden (Teneke Kutular) geri almaya gittiğinizde, bu öğeler *gerekir* belirli bir sırayla—saklandıkları sırayla—geri alınmalı/bulunmalıdır: bu sıra korunmalıdır. Bunu nasıl başarabilirsiniz? Her Teneke Kutunun şu özelliklerinden yararlanabiliriz: * dışına iliştirilmiş benzersiz bir kimlik numarası vardır; * 2 bölmesi vardır—bunlardan yalnızca 1'ini öğemizi tutmak için kullanacağız, diğeri üzerinde başka bir Teneke Kutunun numarası yazılı bir kâğıt parçasını içerir. Her Teneke Kutunun boş olduğunu varsayacağız—ancak belirli bir Teneke Kutuyu açıp boş olup olmadığını kontrol etmenize hiçbir şey engel değildir; boş değilse, boş bir Teneke Kutu bulana kadar bir sonrakini deneyin. Yapabileceğimiz şey şöyledir. İlk öğemizi (koyu yeşil daire) Teneke Kutularımızdan birine (örneğin, Teneke Kutu 124) koyar ve bu ilk Teneke Kutunun numarasını not ederiz—ilk Teneke Kutunun hangi numaraya sahip olduğu önemli değildir, önemli olan tek şey onu bir yere yazıp daha sonra kullanmak üzere saklamamızdır. ![{{{alt}}}](/files/5d92f234791fcd9155838b531fc48d0ef41bb8cd) İkinci bir Teneke Kutu bulun—herhangi bir Teneke Kutu numarası (örneğin, Teneke Kutu 432)—ve numarasını not edin. Bu ikinci Teneke Kutunun numarasını (432) bir kâğıt parçasına yazın ve bu notu *ilk Teneke Kutunun içine* (Teneke Kutu 124) koyun. İkinci öğemizi (açık yeşil daire) ikinci Teneke Kutunun içine yerleştiririz. Böylece şu anda aşağıdaki durumdayız: * ilk Teneke Kutunun 124 numara olduğunu (ilk öğemizi içerdiğini) belirten—bir Teneke Kutuda saklanmayan—yazılı bir not; * Teneke Kutu 124'ün içine, sonraki öğenin Teneke Kutu 432'de bulunacağını belirten başka bir not ekledik. Özünde, *bağladık* ilk iki Teneke Kutumuzu: nereden başlayacağımızı (Teneke Kutu 124) ve Teneke Kutu 124'teki bir notun bize sonraki öğeyi hangi Teneke Kutunun içerdiğini (Teneke Kutu 432) söylediğini biliyoruz. ![{{{alt}}}](/files/db32ef33f389db4f479f3e75680af93615ded1c4) Ardından üçüncü bir Teneke Kutu bulur, numarasını (örneğin, Teneke Kutu 543) bir kâğıda yazar ve bunu *ikinci* Teneke Kutunun (numara 432) içine koyarız. Daha sonra üçüncü öğemizi (kırmızı daire) üçüncü Teneke Kutunun içine yerleştiririz. Artık üç Teneke Kutuyu şu sırayla bağladık: başlangıç noktamız, Teneke Kutu 124 (koyu yeşil daire) → Teneke Kutu 432 (açık yeşil daire)→ Teneke Kutu 543 (kırmızı daire) →… ![{{{alt}}}](/files/027b6760e5e6ba170fbf312c2e8f1ceba812df77) Son iki öğe (açık mavi ve koyu mavi daireler) için bu işlemi, Teneke Kutu 213'ü (açık mavi daire) ve Teneke Kutu 102'yi (koyu mavi daire) kullanarak tekrarlayın. ![{{{alt}}}](/files/a5ab4a76198a732b5a07e6eb466aabdf6e05e2fb) Artık 5 Teneke Kutunun tümü birbirine bağlıdır (her Teneke Kutunun sayısal tanımlayıcısı kullanılarak) ve her Teneke Kutuyu sırayla ziyaret edip öğemizi çıkararak ve sonraki öğemizi hangi Teneke Kutunun içerdiğini söyleyen nota bakarak sakladığımız tüm öğeleri—doğru sırayla—geri alabiliriz. ### Listemizdeki son öğeye (Teneke Kutu 102) ne olacak? Neden özellikle bununla ilgilenmeliyiz? Şimdiye kadar her öğeyi, sonraki öğeyi hangi Teneke Kutunun içerdiğini söyleyen bir notla birlikte bir Teneke Kutuda sakladık: listemizdeki son öğe için bu not ne demelidir—çünkü sonraki Teneke Kutu yoktur. Son öğeye (Teneke Kutuya) ulaştığımızda, bu Teneke Kutunun (son öğeyi içeren) listemizdeki son öğe olduğu açık olmalıdır—başka bir Teneke Kutu aramamız gerekmez çünkü yoktur. Bunu yapmanın bir yolu, son Teneke Kutumuzun (102) içine “özel” bir Teneke Kutu numarası koymaktır. Gerçek bir Teneke Kutunun numarası olmayan benzersiz bir sayı seçtiğimiz sürece istediğimiz herhangi bir numarayı kullanabiliriz—örneğin “Teneke Kutu -1”, “Teneke Kutu 0”: “Teneke Kutu -1” veya “Teneke Kutu 0” vb. ifadesinin hemen aramayı bırakmamızı söylediğini bildiğimiz sürece fark etmez; daha fazla Teneke Kutu aramamıza gerek yoktur çünkü bu sonuncusudur ve dolayısıyla geri alınacak başka öğe yoktur. ### “Öğeler” ve “Teneke Kutular”dan belirteçlere ve TeX'e Şimdi benzetmemizden TeX'in gerçekliğine daha yakın bir açıklamaya geçmemiz gerekiyor. İlk olarak, hayali Teneke Kutularımızda farklı renklerde daireler saklamak yerine, bu Teneke Kutuların TeX belirteçlerini, yani basit tamsayıları sakladığını düşünebileceğimiz açık olmalıdır. Bu, benzetmemizi yazılım (TeX) alanına aktarmanın daha kolay kısmıdır. Peki bölmeli fiziksel numaralı Teneke Kutularımızın yazılım eşdeğeri ne olabilir? Programlama kavramlarına fazla dalmak istemiyoruz, ancak “Teneke Kutularımızı”, uygun bir depolama biriminde “paketlenmiş” birkaç baytlık bilgisayar belleğini temsil ediyor gibi düşünebilirsiniz. Benzetmemizde her Teneke Kutu için sayısal bir tanımlayıcı kullanılması, her küçük bellek paketinin bulunduğu bilgisayar belleği içindeki konum olarak düşünülebilir. TeX'in kendisinde bu küçük depolama paketlerine “bellek sözcükleri” denir—bu terim TeX'in oluşturulduğu zamanı/dönemi (1970'ler) yansıtır. Bu “bellek sözcükleri”, TeX içinde kullanılan temel yapı taşıdır, ancak burada bunları daha ayrıntılı incelememize gerek yoktur—daha fazla ayrıntı isteyenler şu konudaki bir makaleye başvurabilir: [yazarın kişisel blogu](http://www.readytext.co.uk/?p=3537). Bilgisayar programlama terimleriyle, tartıştığımız şeye [*bağlı liste*](https://en.wikipedia.org/wiki/Linked_list)denir: bir TeX belirteç listesi, TeX'in şu adla anılan depolama kapsayıcılarından oluşturulmuş bağlantılı bir listedir: *bellek sözcükleri* burada her bellek sözcüğü şunları saklamak için kullanılabilir: * a *değer*: belirtecin değeri (bir tamsayı); * a *bağlantı*: listemizde sonraki belirteci içeren bir sonraki bellek sözcüğünün bellek konumu. ## TeX belirteç listelerini nerede kullanır? Her yerde! Bu doğrudur çünkü bir TeX/LaTeX makro tanımı (örneğin bir LaTeX komutu), belirteç listesinin (biraz özelleştirilmiş) biçimi olarak saklanır—makro parametrelerini eşleştirmeyle vb. ilgili, “standart” belirteç listelerinde görmediğiniz belirteçleri içerdiği anlamında özelleştirilmiştir. Bunun için endişelenmeyin çünkü bu ayrıntıları gelecekteki bir makalede ele alacağız. ### Örnek bir makro Bir makro üç bölümden oluşuyor olarak düşünülebilir: ``` \def\{} ``` Şuna dikkat edin: `\def` yerine şunu kullanabilirdiniz: `\edef`, `\gdef` ya da `\xdef`. **LaTeX kullanıcılarına not**: Burada makroları ham, düşük düzeyli TeX komutları (adı verilen *ilkellerinden*) kullanarak tanımlıyoruz. LaTeX kullanıcıları, LaTeX'in `\newcommand` aracılığıyla makro oluşturmaya daha aşina olacaktır (bu da kendisi bir makrodur). TeX'ten bir makro oluşturmasını (tanımlamasını) istediğinizde, şunu temsil eden bir belirteç oluşturur: `` ve bir *belirteç listesi* birleşik olanı temsil eden `` ve ``. TeX, şunu temsil eden belirtecin `` tanımını temsil eden belirteç listesine (`` ve ``). Örneğin, eğer `\mymacro` şöyle: ```latex \def\mymacro abc #1 defz{I typed "#1"!} ``` Bileşenlerinin şunlar olduğunu görebiliriz: * `` = `mymacro` * `` = `abc #1 defz` * `` = `"#1" yazdım!` Örneğin, şunu çağırabilirsiniz: `\mymacro` şöyle: ```latex \mymacro abc THIS TEXT defz ``` bu da şununla sonuçlanır: `"THIS TEXT" yazdım!` dizilmesiyle— `abc` ve `defz` ise *yapmaz* dizilir. `abc` ve `defz` şu amaçla kullanılan karakter belirteci dizileridir: *sınırlamak* makro parametresini `#1` ve makro çağrınız TeX tarafından başarıyla işlendiğinde emilir ve atılır. Şunu tanımladığınızda: `\mymacro`, saklanan içindeki belirteç örüntüsü, TeX'in şunları belirlemek için kullanabileceği bir “şablon” görevi görür: * girdinizdeki hangi belirteçlerin sınırlayıcı belirteçler olduğunu; * girdinizdeki hangi belirteçlerin gerçekten makronuzun parametrelerini oluşturduğunu (burada, şunun için kullandığınız: `#1` şu çağrınızda: `\mymacro`). Şunu çağırmanız gerekir: `\mymacro` bir `` onu tanımlamak için kullanılanlarla aynı sınırlayıcıları içerecek şekilde—buna aynı kategori kodlarına sahip karakter sınırlayıcıları kullanmak da dahildir. Şuradaki sınırlayıcılar: `` çağırmak için kullanılan `\mymacro` onu tanımlamak için kullanılanlardan (bellekte saklanan “şablondan”) farklıysa, TeX oldukça şaşırabilir—işlemeye çalıştığında `\mymacro` belleğinde kaydettiği “şablonu” eşleştiremez. TeX, bir makro çağırdığınızı gördüğünde yeni belirteçler oluşturmak için girdi metninizi tarar ve bunları belirteç belirteç, makronuzun tanımının parçası olarak saklanan belirteç listesi `` şablonuyla eşleştirmeye çalışır. Girdi metninizde kullanılan sınırlayıcılar, “şablonda” saklananlarla eşleşmeyen bir dizi belirteçle sonuçlanırsa TeX genellikle bir hata verir. TeX çok titizdir—karakter belirteçlerinin karakter kodu ve kategori kodunun birleşimi olduğunu unutmayın: bir karakterin kategori kodunu değiştirirseniz, o karakterden kaynaklanan farklı bir belirteç değeri elde edersiniz. Diyelim ki şunun kategori kodunu değiştirdik: `z` örneğin 12'ye—normalde 11'dir—ve makromuzu şöyle çağırmayı denedik: ```latex \catcode`z=12 \mymacro abc THIS TEXT defz more text here... ``` Bu sefer çalışmayacaktır çünkü şunun kategori kodu: `z` değiştirilmiştir. Şuna benzer bir hata görürsünüz: ```latex Kaçak argüman? THIS TEXT defz ! \mymacro tamamlanmadan önce paragraf sona erdi. \par s.22 ``` TeX şunu okuyup taradığında: `z` içine `defz` onu, şunun sonunu oluşturuyor olarak tanıyamaz: `\mymacro`’nin `` girdi dosyanızda kullanılan. Bu hatalı olanı görene kadar `z` TeX ilk 3 karakteri doğru şekilde eşleştirmişti: `def` ama şu `z` (kategori kodu 12 ile) TeX'in taramasını aksatır. Şunun `z` biz *tanımladığımızda* `\mymacro`: kategori kodunun 11 olduğunu varsayarsak, bu, şunun tanımının parçası olarak (yani “şablonun” parçası olarak) 256×11 + 122 = 2938 belirteç değerinin saklanmasına yol açar. `\mymacro`’nin tanımı. Ancak kategori kodu 12 olduğunda, `z` artık 256×12 + 122 = 3194 belirteç değeri oluşturacaktır. Girdinizden okunan belirteç değeri (şunun için `z`) (değer 3194), saklanan içindeki `z`-belirteciyle eşleşmediği için `` belirteç listesi şablonu (değer 2938), TeX girdinizi taramayı sürdürecektir. TeX, makronuzdan sonraki metni (*burada daha fazla metin* ...) ek belirteçler aramak için taramayı sürdürecek—saklanan şablonu girdinizde bulduğu belirteçlerle eşleştirmeye çalışacaktır. Büyük olasılıkla doğru belirteç örüntüsünü bulamayacak ve TeX girdinizin “ötesine geçerek” ek belirteçler oluşturmak için fazladan metni hatalı şekilde okuduğunda hatalar oluşacaktır—bu ek belirteçler bu noktada okunmamalıydı ve neredeyse kesinlikle hata üretecektir. Bunu gelecekteki bir makalede daha ayrıntılı ele alacağız. ## Belirteç listelerinin diğer kullanımları Belirteç listeleri oluşturmak/saklamak için kullanılan diğer komutlar şunları içerir: ```latex \toks={...} \everypar={...} \everymath={...} \everydisplay={...} \everyhbox={...} \everyvbox={...} \output={...} \everyjob={...} \everycr={...} \errhelp={...} ``` Bu komutların her biri, ‘{...}’ küme parantezleri içindeki karakterlerden ve komutlardan bir belirteç listesi oluşturur ve bu belirteç listesi belirli koşullarda yeniden kullanılmak üzere tasarlanmıştır. Örneğin, `\everypar={...}` TeX'in yeni bir paragrafa başlamadan hemen önce girdiye eklediği bir belirteç kümesi (bir belirteç listesi) oluşturur ve saklar. ## Belirteç listelerinin gizli kullanımları: örnekler Bu son bölümde, belirteç listelerinin beklemeyebileceğiniz şekillerde kullanılmasına dair bazı pratik örneklere bakacağız. ### Örnek 1: \uppercase{...} ve \lowercase{....}—geçici belirteç listeleri Belirteç listeleri üretmek için açık komutlara ek olarak, TeX'in bazı özel işlemler yapmak üzere gizli ve geçici bir dahili belirteç listesi ürettiği durumlar vardır. TeX girdi karakterlerinizi/komutlarınızı okuduğunda/işlediğinde bunların belirteçlere dönüştürüldüğünü unutmayın: TeX motorlarının çalıştığı temel yapı taşı. İyi bir örnek şu komutlardır: `\\uppercase{...}` ya da `\lowercase{...}` çünkü işlemleri ilk karşılaşmada oldukça kafa karıştırıcı olabilir. Ne yaptıklarını—TeX'in daha derinlerinde ve kullanıcı için görünmez biçimde—anladığınızda, işlemlerini kavramak çok daha kolaylaşır. Diyelim ki büyük harfe çevirmek istediğiniz basit bir harf diziniz var—örneğin abcde'yi ABCDE'ye dönüştürmek. TeX'in `\\uppercase` komutuyla: ```latex \uppercase{abcde} ``` komutuyla TeX şunu çıktılar: `ABCDE`. Şimdi basit harf dizimizi daha sonra kullanmak üzere saklamak istediğimizi varsayalım—yani onları hemen çıktılamak istemiyoruz, bu yüzden TeX'in verileri kaydetmek için yalnızca *dahili* mekanizmasını—harici (dosya) mekanizmasını değil—kullanacağız: bir belirteç listesi kullanın. Bunu ya bir makro oluşturarak ya da açık bir belirteç listesi komutu kullanarak yapabiliriz: ```latex \toks100={abcde} \def\mychars{abcde} ``` Sonra, bir noktada, harf dizinizi yeniden kullanmak ancak bu kez büyük harfle kullanmak isteyebilirsiniz; bu yüzden şunu denersiniz: ```latex \uppercase{\the\toks100} ``` ve ```latex \uppercase{\mychars} ``` Ama ne yazık ki bunların hiçbiri çalışmaz. Neden? ### Gizli belirteç listeleri! Komutların nasıl olduğunu anlamak için `\\uppercase{...}` `\lowercase{...}` gerçekte çalıştığını anlamak için TeX'in iç işleyişine göz atmam gerekti; dolayısıyla aşağıdaki açıklama buna dayanır. TeX, şunlardan birini algıladığında: `\uppercase{}` ya da `\lowercase{}` girdinizde, TeX'in yaptığı ilk şey, `` açılış ‘{’ ve kapanış ‘}’ arasında bulunan `\\uppercase{...}` ya da `\lowercase{...}` komutlarını takip eden malzemeden (geçici) dahili bir belirteç listesi oluşturmaktır—bu geçici belirteç listesi TeX'in içindedir. Kritik bir nokta ve şunun nasıl olduğunu anlamanın merkezinde yer alan: `\uppercase{}` ve `\lowercase{}` gerçekte çalıştığı, `` içinde bulunan herhangi bir komut veya makronun *genişletilmiş*yürütülmemesidir: TeX'in yaptığı tek şey, arasına yerleştirilen karakterlerden ve komutlardan belirteçler üretmektir `{...}`. Şunun işlemi sırasında: `\uppercase{}` ya da `\lowercase{}` küme parantezleri arasındaki hiçbir şey yürütülmez: yalnızca belirteçlere dönüştürülür. Sonrasında `` içinde `{...}` bir (geçici) belirteç listesine dönüştürüldükten sonra, TeX bu listedeki her belirteci yeniden ziyaret eder ve bunun bir *karakteri* belirteci mi yoksa bir *komut* belirteci mi olduğunu test eder (belirtecin sayısal değerini kullanarak). TeX bir karakter belirteci algılarsa, karakterin büyük/küçük harf durumunu ayarlamak için bu belirteci değiştirir (şunun işlenip işlenmediğine göre `\\uppercase` ya da `\lowercase` ). TeX herhangi bir komut belirtecini basitçe yok sayar ve neyi temsil ettiklerini veya içerdiklerini görmek için komut belirteçlerinin “içine bakmaz” (örneğin karakterler içeren bir makro)—bunlar atlanır: yalnızca karakter belirteçleri gerçekten işlenir/büyük-küçük harf değiştirme işlemlerinden etkilenir. Dolayısıyla örneğin, şöyle bir TeX komutu verirsek: `\uppercase{abcde}` TeX şundan bir belirteç listesi oluşturacaktır: `abcde` yalnızca karakter belirteçleri içerir: bunların tümü A, B, C, D ve E'yi temsil eden değiştirilmiş bir dizi belirteç oluşturmak üzere ayarlanır. Bu değiştirilmiş belirteçler TeX'in girdi işleyicisine geri beslenir ve sonuç olarak `ABCDE` dizilir. Ancak karakterlerimizi *bir makro içinde*—örneğin `\def\mychars{abcde}`—sakladıysak ve onları şöyle büyük harfe çevirmeye çalışırsak: ```latex \uppercase{\mychars} ``` o zaman başarısız olur ve bekleyebileceğiniz gibi ABCDE değil, abcde dizilir. Ardından karakterlerimizi şöyle bir belirteç listesinde saklamayı denersek: `\toks0={abcde}` ve şunu yaparsak: `\uppercase{\the\toks0}` o zaman, bir kez daha, `\\uppercase` başarısız olur çünkü belirteç listesi tamamen şundan etkilenmeyen belirteçlerden oluşacaktır: `\\uppercase`. Makromuz örneğini ele alırsak, `\mychars`, TeX girdide şunu algıladıktan sonra: `\\uppercase` TeX, şunun anlamını arar: `\\uppercase` ve onu işler; şundan geçici bir belirteç listesi oluşturur: `{\mychars}`. Açıkça, bu geçici belirteç listesi bir karakter belirteci değil, makro komutumuzu temsil eden tek bir belirteç içerir `\mychars`: dolayısıyla, şunu yürütme amacıyla: `\\uppercase`, bu belirteç yok sayılır—`\mychars` bir karakter belirtecini temsil etmez. Ancak yukarıda belirtildiği üzere, `\\uppercase` işini tamamladıktan sonra, geçici belirteç listesi (şunun eylemiyle oluşturulan `\\uppercase`) TeX'in tam girdi işleme (tarama) mekanizmasına geri beslenir. TeX bu belirteç listesini yeniden okuduğunda, bizim `\mychars` makromuzu temsil eden bir belirteç algılar; TeX bunu yürütür (genişletir) ve abcde'yi dizmek için bir dizi karakter üretir—hala küçük harftir çünkü bir makronun içine “sarılmışlardı” ve dolayısıyla şunun eylemlerine görünmezlerdi: `\\uppercase`. TeX, şunun için oluşturulan geçici belirteç listesini yeniden inceledikten sonra: `\\uppercase{...}` ya da `\lowercase{...}`, karakter belirteçlerini işledikten sonra, bu geçici belirteç listesini girdi kaynağı olarak kullanmaya geçer: karakterleri (işlenmiş karakter belirteçlerini) dizerek ve komutları ve makroları yürüterek. ### Bu nasıl düzeltilebilir? Çünkü `\\uppercase{...}` ya da `\lowercase{...}` yalnızca karakter belirteçleri üzerinde işlem yapacağından, makromuzda bulunan karakterleri `\mychars` (veya bir `\\toks` yazmacında bulunan) `\\uppercase{...}` ya da `\lowercase{...}` üzerinde işlem yapmadan önce “paketinden çıkarmaya zorlama” yoluna ihtiyacımız vardır. “Paketinden çıkarma” ile aslında TeX'in şu sürecini kastediyoruz: *genişletme*: * bir TeX/LaTeX komutunu şununla değiştirmek *dizisiyle* belirteçler *bu komutun kaynaklandığı* (*örneğin bir makronun*) *oluştuğu,* ya da * bir komutun tasarlandığı belirteç dizisini üreten *üretmek*. Belirteç üreten bir komut örneği şudur: `\\jobname`, işlenen ana TeX dosyasının adını temsil eden bir dizi karakter belirteci üretir. #### Daha düşük düzeyli sihir: scantoks(..., ...) Burada gerçekten TeX'in iç işleyişinin daha karanlık bazı köşelerini araştırıyoruz; bu nedenle ayrıntılardan hoşlanmıyorsanız bu bölümü görmezden gelebilirsiniz… TeX şunu algıladıktan sonra: `\\uppercase` ya da `\lowercase` girdi akışında, adı verilen dahili bir işlevi yürütür: `scantoks(..., ...)` görevi açılış ‘{’ ile kapanış ‘}’ arasındaki öğeleri kullanarak belirteç listesini üretmektir—tartışıldığı üzere, bu belirteç listesi daha sonra karakter durumunu gerektiği gibi değiştirmek için herhangi bir karakter belirtecini algılamak (ardından ayarlamak) üzere incelenir. Şuna başvurduğumuza dikkat edin: `scantoks(..., ...)` TeX motorlarının kaynak koduna yerleşik dahili işlev olarak—burada, bir denetim dizisinin adı olarak bahsedilmemektedir. Çalışmasının bir parçası olarak, `scantoks(..., ...)` oluşturmakta olduğu belirteç listesini genişletmesi veya genişletmemesi talimatı verilebilir ve şunun için: `\\uppercase` ve (`\lowercase`) belirteçleri genişletmez: yalnızca oluşturur ve bir belirteç listesine koyar. Şunun yapması gereken ilk işlerden biri: `scantoks(..., ...)` bir açılış ‘{’ işareti (veya kategori kodu `\catcode` 1 olan herhangi bir karakter) olup olmadığını kontrol etmektir; çünkü kullanıcının bir sözdizimi hatası yapmadığından ve açılış ‘{’ işaretini (veya kategori kodu 1 olan herhangi bir karakteri) unutmadığından emin olmalıdır—çünkü belirteçleştirilecek bir öğe listesinin başlangıcını sınırlamak için kategori kodu 1 olan bir karakter gerekir. Ve işte püf noktası: açılış ‘{’ işareti arama görevi, `scantoks(..., ...)` ögesinin TeX'in genişletme sürecini çalıştırmasını tetikler; bu da aşağıdaki örneklerin çalışacağı anlamına gelir: ```latex \let\ob={ \uppercase\ob abcde} \def\obb{\ob} \uppercase\obb xyz} ``` Şunun örneğini ele alırsak: `\obb`, bir makro olarak, bir *genişletilebilir komuttur* olarak tanınır ve TeX tarafından ( `scantoks(..., ...)` işlevi aracılığıyla) açılış küme parantezi (kategori kodu 1 olan herhangi bir karakter) arayışında gerektiği gibi genişletilir. Bunun anlamı, “`\\expandafter` püf noktası”nı, karakterlerimizi makromuzun sınırlarından “paketinden çıkarmak”—yani onu genişletmek—amacımıza ulaşmak için kullanabilmemizdir. Şuna dikkat edin: `\\expandafter` de bir *genişletilebilir komuttur*olma kategorisine girer, bu nedenle TeX burada onu işler ve açılış ‘{’ işareti (veya kategori kodu 1 olan herhangi bir karakter) aramanın parçası olarak işini yapmasına izin verir. Dolayısıyla, şunu tanımlarsanız: ```latex \toks0={abcde} \def\mychars{abcde} ``` Ve şunu yaparsanız: ```latex \uppercase\expandafter{\mychars} \uppercase\expandafter{\the\toks0} ``` her iki durumda da artık ABCDE'nin dizildiğini görürsünüz çünkü `\\expandafter` şunun “paketinden çıkarılmasına” (genişletilmesine) neden olur: `\mychars` ve `\the\toks0`—her ikisi de şununla sonuçlanır: `\\uppercase` büyük/küçük harf durumunu değiştirmek üzere işleyebilecekleri bir karakter belirteç akışı görmesi. ### Örnek 2: \string—daha fazla geçici belirteç listesi TeX dahili olarak şunu sınıflandırır: `\string` sözde “dönüştürme” komutlarından biri olarak: “metne dönüştürme” işlemini gerçekleştirir. Bu `\string` komut, bir belirteci insan tarafından okunabilir bir metin sürümüne dönüştürmek için tasarlanmıştır—yani, o belirtecin başlangıçta oluşturulduğu insan tarafından okunabilir karakter dizgisini dizgiye döker. Örneğin `\string\hello` şu karakterleri içeren geçici bir belirteç listesi oluşturur: \\, h, e, l, l, o — evet, başlangıçtaki ‘\’ bile dahil. Bu belirteç listesi oluşturulduktan sonra TeX tarafından yeniden okunur ve “ komutunun metni`\hello`” dizgiye dökülür—evet, doğru yazıtipini seçerseniz ‘\’ de dahil… TeX’in normalde bir komut belirteci oluşturmak için tarayıcısını tetiklemek üzere kullanılan kaçış karakterini nasıl/neden dizgiye dökebildiğini merak edebilirsiniz: burada neden bunu yapmıyor? Cevap kategori kodlarıyla ilgilidir: normalde, bir ‘\’ karakterinin catcode’u 0’dır (kaçış karakteri) fakat `\string` kendi iç belirteç listesini oluşturduğunda biraz farklı bir şey yapar. Bir karakter-belirteç listesi oluşturduğunda, boşluk karakterine catcode 10 atanmış olmak üzere boşluk karakteri dışındaki tüm karakterlere kategori kodu 12 atar—hatırlayın, karakter belirteçleri 256 x catcode + ASCII değerinden hesaplanır. Dolayısıyla, TeX geçici belirteç listesini yeniden okuduğunda (girdi aldığında) ki bu liste `\string` şundan oluşturulmuştur `\hello`, TeX *bir kaçış karakteri görmez* çünkü ‘\’ için belirteç catcode 12 ile hesaplanmıştı, 0 ile değil: TeX sadece ‘\’ karakterini sıradan bir karakter gibi ele alır ve onu dizgiye döker. Sıkı anlamda konuşursak, muhtemelen TeX’in girişte kaçış karakterlerini algıladığında onlar için aslında bir belirteç oluşturmadığını belirtmeliyiz. Catcode’u 0 olan bir karakteri tanıdıktan sonra, o karakter yalnızca bir kontrol dizisi belirteci oluşturmayı “tetiklemek” için kullanılır: TeX’in bunu yapmasını tetikledikten sonra kaçış karakteri işini yapmış olur ve artık dikkate alınmaz. ### Teknik not adlı bir komut `\showtokens{...}` (e-TeX motoru tarafından tanıtılmıştır) belirteç listelerini gösterebilir (günlük dosyasında). e-TeX kılavuzundan: > Komut `\showtokens{}` belirteç listesini görüntüler ve `\show` ya da `\showthe` tarafından görüntülenemeyen niceliklerin görüntülenmesine izin verir, örn.: > > ```latex > \showtokens\expandafter{\jobname} > ``` ## Sonuç olarak TeX kaynak kodunun 291. bölümünde (bkz. sayfa 122, [TeX: The Program](https://www.amazon.co.uk/Computers-Typesetting-TeX-Program-TEX/dp/0201134373)) Knuth bir belirteç listesini şöyle tanımlar: > “Bir belirteç listesi, mem içinde tek sözcüklük düğümlerin tek bağlı bir listesidir; burada her sözcük bir belirteç ve bir bağlantı içerir. Makro tanımları, çıktı-rutin tanımları, işaretler, `\write` metinler ve birkaç başka şey TeX tarafından belirteç listeleri biçiminde hatırlanır; bunların önünde genellikle ‘token\_ref\_count’ alanında bir başvuru sayacı bulunan bir düğüm yer alır.” İlk okumada bunu anlamak kolay olmamış olabilir, ancak umarız şimdi biraz daha anlamlı gelmiştir. --- # Agent Instructions This documentation is published with GitBook. GitBook is the documentation platform designed so that both humans and AI agents can read, navigate, and reason over technical content effectively. Learn more at gitbook.com. ## Querying This Documentation If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question. Perform an HTTP GET request on the current page URL with the `ask` query parameter, and the optional `goal` query parameter: ``` GET https://ayakaleaf-pro.ayaka.space/latex/tr/derinlemesine-makaleler/54-what-is-a-tex-token-list.md?ask=&goal= ``` `ask` is the immediate question: it should be specific, self-contained, and written in natural language. `goal` is optional and describes the broader end goal you are ultimately trying to accomplish on behalf of the user. GitBook uses it to tailor the answer towards what is most useful for that goal. The response will contain a direct answer to the question and relevant excerpts and sources from the documentation. Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.