> 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/20-how-does-expandafter-work-from-basic-principles-to-exploring-tex-s-source-code.md). # \expandafter nasıl çalışır: Temel ilkelerden TeX'in kaynak kodunu keşfetmeye [Bölüm 1](/latex/tr/derinlemesine-makaleler/19-how-does-expandafter-work-an-introduction-to-tex-tokens.md) [Bölüm 2](/latex/tr/derinlemesine-makaleler/22-how-does-expandafter-work-the-meaning-of-expansion.md) [Bölüm 3](/latex/tr/derinlemesine-makaleler/21-how-does-expandafter-work-tex-uses-temporary-token-lists.md) [Bölüm 4](/latex/tr/derinlemesine-makaleler/20-how-does-expandafter-work-from-basic-principles-to-exploring-tex-s-source-code.md) [Bölüm 5](/latex/tr/derinlemesine-makaleler/17-how-does-expandafter-work-a-detailed-macro-case-study.md) [Bölüm 6](/latex/tr/derinlemesine-makaleler/18-how-does-expandafter-work-a-detailed-study-of-consecutive-expandafter-commands.md) ## Giriş Artık, tam bir inceleme için gerekli arka plan konularını ele aldık `\\expandafter`: * TeX belirteçlerinin temelleri ve nasıl hesaplandıkları; * TeX’in genişleme sürecinin ardındaki ilkeler; * TeX’in belge işleme sırasında geçici belirteç listelerini kullanması/oluşturması; * TeX’in birden çok giriş kaynağını (geçici belirteç listeleri dahil) nasıl kullandığı ve onlarla nasıl “hokkabazlık yaptığı”. Bu makalede, TeX’in temelindeki mekanizmaları açıklamak için bu konuları/kavramları bir araya getireceğiz `\\expandafter` komutu: kısaca, nasıl çalıştığı. ## Ve böylece, \\\expandafter Arkasındaki fikir `\\expandafter` bir komutun (belirtecin) normalde TeX’in yapacağı zamandan önce genişletilmeye zorlanmasıdır. İki belirteç verildiğinde, $$\mathrm{T\_1}$$ ve $$\mathrm{T\_2}$$ nin eylemi `\\expandafter` $$\mathrm{T\_1T\_2}$$ TeX’in işlemesine yol açar $$\mathrm{T\_1}\text{<}$$genişlemesi $$\mathrm{T\_2}\text{>}$$, burada $$\text{<}\dots\text{>}$$ bir belirteçler listesini gösterir. TeX, ... öğesini önceden genişletir, böylece belirteç $$\mathrm{T\_2}$$ önceden $$\mathrm{T\_1}$$ (örn. bir ilkel komut ya da bir makro), ... genişlemesinden doğan belirteçleri görür ya da bunlar üzerinde işlem yapabilir. $$\mathrm{T\_2}$$. Eğer belirteç $$\mathrm{T\_2}$$ aktif olmayan bir karakter ya da (çoğu) ilkel komutlar gibi genişletilemeyen bir öğeyi temsil ediyorsa, ... eylemi `\\expandafter` hiçbir şeyi değiştirmez: TeX belirteçleri $$\mathrm{T\_1T\_2}$$ normal şekilde işlemeye devam ederdi. ### \\\expandafter kullanımına giriş Eğer ... kullanmadıysanız `\\expandafter`, işte onu ilkel komutla kullanmaya bir örnek `\\uppercase{...}`. Ana `.tex` giriş dosyamızın adını büyük harflerle dizmek istediğimizi varsayalım. Aşağıdaki TeX ilkel komutlarını biliyor olabiliriz: * `\\uppercase`: adı üstünde yaptığı gibi, karakter belirteçlerini büyük harf karşılıklarına dönüştürür (varsa); * `\\jobname`: gördüğümüz gibi, ana `.tex` dosyasında. TeX dosyamızın adının `mycode.tex` olduğunu varsayarsak, şunu beklememiz makul olurdu `\\uppercase{\\jobname}` şunu dizsin diye `MYCODE`. Ama hayır, şunu diziyor `mycode` küçük harflerle. Ne “yanlış” gitti? Eğer ... genel kullanımını şu şekilde yazarsak `\\uppercase` olarak ``` \\uppercase{} ``` şunu söyleyebiliriz ki `\\uppercase` içinden bakar `` ve yalnızca *karakter belirteçleri* üzerinde işlem yapacaktır (büyük/küçük harf değişimi), bunları ``: tüm karakter olmayan belirteçler *yok sayılır* çünkü `\\uppercase` karakter olmayan belirteçlerin içinde ne olduğunu ya da neyi temsil ettiğini görmek için onlara “içeri bakmayacaktır” (genişletmeyecektir). Bir belirteç basitçe bir tamsayı değeri olduğundan, yapması gereken tek şey, ... içindeki her bir belirtecin sayısal değerinin, bir karakter belirtecini gösteren değer aralığına girip girmediğini kontrol etmek için belirteç listesine bakmaktır. Bu arada, `\\uppercase` yapması gereken tek şey, ... içindeki her belirtecin sayısal değerinin `` değer aralığına girip girmediğini kontrol etmek için ... belirteç listesine bakmaktır. Bu arada, `\\uppercase` ayrıca *aktif karakterlerin de harf durumunu değiştirir* böylece büyük harfli bir aktif karakter oluşturur; ancak o hâlâ aktif olduğundan tanımlı da olması gerekir, aksi takdirde TeX bir hata üretir: `Tanımsız kontrol dizisi`, ama konudan sapıyoruz... Örneğin, yalnızca metin olan bir makro tanımlasak bile ``` \\def\\foo{some lower-case text} ``` sonra `\\uppercase{\\foo}` yine de şunu dizer `some lower-case text` ve şunu değil `SOME LOWER-CASE TEXT` umduğumuz gibi; bunun nedeni basitçe `\\uppercase` eyleminin `\\foo` neyi temsil ettiğini belirlemeye çalışmamasıdır: onu bir komut belirteci olarak görür ve `\\foo` ile yaptığı gibi onu yok sayar `\\jobname`. ### Bunu nasıl düzeltebiliriz? \\\expandafter kurtarıcı olsun Dosya adının büyük harfli bir sürümünü dizmek için, TeX’i `\\uppercase{\\jobname}` onu genişlemesiyle (bir karakter belirteçleri dizisi) değiştirmeye zorlayarak `\\jobname` önce *önce* `\\uppercase` işe koyulur. Bir kez daha, genişleme `\\jobname` belirteci (komutu) kaldırmak ve onu genişlemesinin sonucu ile değiştirmek için kullanılıyor (karakter belirteçleri içeren bir belirteç listesi). Dolayısıyla, şunu yazarsak ``` \\uppercase\\expandafter{\\jobname} ``` o zaman işe yarar: `MYCODE` dizilirdi. Olan şu ki TeX işlemeye başlar `\\uppercase` ve hemen zorunlu açılış süslü parantez karakterini (`{`); ancak TeX bir `\\expandafter` komut algılar ve bu da onun dikkatini geçici olarak `\\expandafter{\\jobname}`. Eğer ... ile örneğimizi karşılaştırırsak `\\expandafter` $$\mathrm{T\_1T\_2}$$ ile `\\expandafter{\\jobname}` görebiliriz * $$\mathrm{T\_1} =\space$$`{`belirteç * $$\mathrm{T\_2} =\space$$`\\jobname`belirteç Burada `{`belirteç ve `\\jobname`belirteç TeX tarafından hesaplanan belirteç değerlerine atıfta bulunuruz—alt simge gösterimi belirteç TeX’in tamsayı belirteçler dünyasında çalıştığını kendimize hatırlatmak için kullanılır. Yazmak `\\uppercase\\expandafter{\\jobname}` işe yarar çünkü, ana hatlarıyla (ayrıntılar birazdan), `\\expandafter` TeX’in aşağıdaki görevleri yapmasına neden olur: 1. açılış `{`belirteç; 2. bir sonraki belirteci oku: `\\jobname`belirteç. TeX, ... olduğunu tanır `\\jobname`belirteç genişletilebilir bir komutu temsil ettiğini ve onu genişlettiğini. `\\jobname`belirteç yerine genişlemesi gelir—bir dizi karakter belirteci; 3. genişlettikten sonra `\\jobname` komutu, TeX `{`$$\_\mathrm{token}$$ “girişi geri” koyar ve `\\jobname` genişlemesinden doğan belirteç listesini kullanır `\\uppercase{`belirteç`<\\jobname genişlemesi>`belirteç listesi (karakterler)`}`, ve bu da istediğimiz sonucu üretir. Aşağıdaki diyagram TeX’in nasıl işlediğini gösterir `\\uppercase\\expandafter{\\jobname}`—işlem akışını takip etmek için grafiği alttan okuyup yukarı doğru ilerleyin. ![\\\expandafter nasıl çalışır](/files/c6a9fa63c2652c1826be25526202f67ad42c0642) Aşağıdaki notlar işlemenin çeşitli aşamalarını açıklar. 1. TeX işlemeye başlar `\\uppercase` ve zorunlu açılış süslü parantez karakterini (`{`) kontrol eder, ancak bir `\\expandafter` komutunu. 2. Eğer ... ile örneğimizi karşılaştırırsak `\\expandafter` $$\mathrm{T\_1T\_2}$$ girdiğimiz `\\expandafter{\\jobname}` görebiliriz $$\mathrm{T\_1} =$$`{`belirteç ve $$\mathrm{T\_2} =$$`\\jobname`belirteç. Burada alt simge belirteç TeX’in tamsayı belirteç değerlerini işlediğini göstermek için kullanacağız. 3. `\\expandafter` okur, ardından geçici olarak saklar, `{`belirteç bir iç değişkende o tamsayı belirteç değerini saklayarak. Daha sonra TeX, `\\jobname` komutunu. 4. `\\expandafter` bir sonraki belirteci okur, `\\jobname`belirteç, ve `\\jobname` komutunu. 5. nın genişlemesini yapar `\\jobname` bir geçici belirteç listesi oluşturur; bu liste, ... temsil eden bir dizi karakter belirteci içerir `.tex` dosya adı. ... tarafından üretilen tüm karakter belirteçlerinin `\\jobname` kategori kodu 12 kullanılarak hesaplandığını unutmayın. 6. Bir kez `\\jobname` genişletildikten sonra TeX, 3. adımda saklanan belirteci (`{`belirteç) yeniden ekler ve onu girdiye geri koyar. TeX bunu, içeren başka bir belirteç listesi oluşturarak yapar *tek* `{`belirteç 7. TeX artık işlemeyi bitirmiştir `\\expandafter`, bu da TeX girdisinin kaynakları olarak kullanılmaya hazır iki belirteç listesi oluşturur. TeX şimdi tekrar işlemeye döner `\\uppercase` ama girdisini öyle yapılandırmıştır ki `\\expandafter` tarafından oluşturulan iki belirteç listesi `\\uppercase`—şimdi `\\uppercase{`belirteç`<\\jobname genişlemesi>`belirteç listesi (karakterler)`}`. `\\uppercase` şimdi bir karakter belirteçleri dizisi görür ve istediğimiz sonucu üretebilir. 8. tarafından üretilen tüm karakter belirteçleri okunduktan sonra `\\jobname`, TeX önceki giriş kaynağına (bizim `.tex` dosyamız) geri döner; buradan bir sonraki belirteci okuyacaktır: kapanış `}` tarafından işlenecek belirteçler listesini sonlandırmak için gereken `\\uppercase`. ### \\\expandafter ve dahili belirteç listeleri Geçici belirteç listeleri *hayati* bir öğedir `\\expandafter`’nin işleme davranışının: bu belirteç listelerinin kullanımını ve varlığını anlamak, ... nasıl `\\expandafter` özellikle art arda birden fazla `\\expandafter` komut kullanan, daha karmaşık belirteç işleme biçimleri elde etmek için yazılan ya da anlaşılan makroları açıklığa kavuşturmaya yardımcı olabilir: `\\expandafter\\expandafter\\expandafter...` Davranışının bir diğer önemli öğesi `\\expandafter`özellikle art arda birden fazla `\\expandafter` komutla, ... kullanımıdır *özyineleme* (TeX yazılımının içinde)—bu konuyu bu yazının ilerleyen bölümünde ele alacağız. Geçici belirteç listelerini daha iyi anlamamıza yardımcı olmak için ... bir örneğe daha bakacağız `\\expandafter`, bu kez `\\the` komutunu. #### \\\expandafter ve dahili belirteç listeleri: örnek 2 Bu örnekte ... nasıl kullanılabildiğini göreceğiz `\\expandafter` bir token register içinde saklanan belirteçleri etkilemek için `\\toks` komutu aracılığıyla. Kullanacağımız TeX ilkel komutları şunlardır: * `**\\count** *kayıt*=*sayı*`: değeri saklamak için kullanılan bir TeX ilkel komutu `*sayı*` TeX içindeki `*kayıt*`; * `**\\toks** *kayıt*={*belirteç listesi*}`: saklamak için kullanılan bir TeX ilkel komutu `*belirteç listesi*` belirteç kaydedicisi konumuna `*kayıt*`—bir belirteç dizisini daha sonra kullanılmak üzere saklar; * `**\\the** *belirteç*`: işleyen genişletilebilir bir TeX ilkel komutudur `*belirteç*`, ancak tam sonuçlar işlenen `*belirteç*` öğenin doğasına bağlıdır. `\\the` birkaç kullanım alanına sahiptir: bunlardan biri TeX parametresinde ya da değişkeninde (örn. bir kayıt) saklanan değeri dizmektir. \the'nin diğer kullanımları `\\the` token register içinde saklanan belirteçlerin bir kopyasını eklemeyi içerir. Burada, \the'yi `\\the` değerini dizmek için kullanacağız `\\count` kayıt. Değeri saklamak için aşağıdaki TeX koduyla başlayacağız `12345` TeX’in `\\count` kaydında `99`: ``` \\count99=12345 ``` Eğer ... içinde saklanan değeri dizmek istersek `\\count99` şunu kullanabiliriz `\\the\\count99` (veya `\\number\\count99`). Sonra `\\toks` komutunu kullanarak belirteç kaydedicisine bazı belirteçler saklayacağız `99`: ``` \\toks99={\\the\\count99 } ``` Belirteç kaydedicisinde saklanan belirteçler listesi `99` şunları içerirdi: | | | | ----------------------- | --------------------------------------------------------------------------------------------------------------------- | | **TeX belirteç değeri** | **Temsil edilen öğe** | | 5382 | `\\the` | | 7885 | `\\count` | | 3129 | `9` (kategori kodu 12 ile karakter kodu 57), bunun sonucunda bir belirteç değeri $$256 \times 12 + 57 = 3129$$ | | 3129 | `9` (kategori kodu 12 ile karakter kodu 57), bunun sonucunda bir belirteç değeri $$256 \times 12 + 57 = 3129$$ | | 2592 | `` (kategori kodu 10 ile karakter kodu 32), bunun sonucunda bir belirteç değeri $$256 \times 10 + 32 = 2592$$ | Şunu not edin: \toks99 tarafından oluşturulan belirteç listesi `\\toks99` yapar *yapmaz* içindeki gerçek veri değerini `\\count99` çünkü `\\toks` \\\toks komutu genişleme gerçekleştirmez: sadece belirteçler oluşturur ve onları saklar. Örneğimizde, `\\the` genişletilmez `\\count99`; burada `\\the` sadece bir belirtece dönüştürülür (değer 5382) ve belirteç listesine kaydedilir. Eğer `\\toks99` belirteç listesi, içinde saklanan veriyi temsil eden belirteçler içermesini istiyorsak `\\count99` saklanan veriyi temsil eden `\\toks` bize bu belirteçleri oluşturacak (erişilebilir kılacak) bir yol gerekir ki `\\expandafter` komutu onlara erişebilsin. Ve elbette ``` \\toks99=\\expandafter{\\the\\count99 } ``` eylemi/işlenmesi `\\toks` komutunun “beklemeye alınması” olacakken `\\expandafter` genişlemesini (zorla) sağlar `\\the` bu da sırayla `\\count` üzerinde işlem yaparak `\\count99`içinde saklanan veriyi temsil eden karakter belirteçleri içeren geçici bir belirteç listesi oluşturur. Küçük ama önemli bir nokta, `` sayılardan sonraki `99`karakteridir: bu `` karakteri, sayısal bir miktar aranırken TeX’in tarama sürecini sonlandırır. Burada, `\\expandafter` eylemi `\\jobname` oldukça 1. Oku ve açılış `{`belirteç. 2. bir sonraki belirteci oku, `\\the`belirteç, bu genişletilebilir bir komutu temsil eder, bu yüzden TeX onu genişletir. `\\expandafter` genişlemeye zorlar `\\the` bu da sonra `\\count99` içinde saklanan veriyi dönüştürmek için `\\count` kaydında `99` (12345 sayısı) geçici bir belirteç listesine. Bu liste, sayı basamaklarını temsil eden karakter belirteçleri içerecektir `1`, `2`, `3`, `4` ve `5`—kategori kodu 12 olan karakter belirteçleri. 3. ... genişletip işledikten sonra `\\the`, TeX `{`belirteç “girişi geri” koyar ve ... den doğan belirteç listesini kullanır `\\the\\count99` genişlemesinden doğan belirteç listesini kullanır `\\toks99={`belirteç`<\\the\\count99 genişlemesi>`belirteç listesi (karakterler)`}` ve bu da istediğimiz sonucu üretir. Bu olay dizisi aşağıdaki diyagramda özetlenmiştir—işlem akışını takip etmek için grafiği alttan okuyup yukarı doğru ilerleyin. ![\\\expandafter nasıl çalışır](/files/a256aad065c0ad272b986d26978aef4573eff2c8) 1. TeX işlemeye başlar `\\toks`; isteğe bağlı `=` işaretini görür, ardından zorunlu açılış süslü parantez karakterini (`{`, ya da kategori kodu 1 olan herhangi bir karakteri) kontrol eder; bu, bir belirteç listesinin başlangıcını gösterir. Ancak TeX bir `\\expandafter` komutu algılar ve bunun yerine onu yürütmeye devam eder. 2. Eğer ... ile örneğimizi karşılaştırırsak `\\expandafter` $$\mathrm{T\_1T\_2}$$ girdiğimiz `\\expandafter{\\the\\count99 }` görebiliriz $$\mathrm{T\_1} =$$ `{`belirteç ve $$\mathrm{T\_2} =$$ `\\thebelirteç`. 3. `\\expandafter` okur, ardından geçici olarak saklar, `{`belirteç (TeX o tamsayı belirteç değerini geçici olarak bir iç değişkende saklar). Daha sonra TeX, ... işledikten sonra o belirteci girdiye geri ekleyecektir `\\the` 4. `\\expandafter` bir sonraki belirteci okur, `\\the`belirteç ve onu genişletir. 5. nın genişlemesini yapar `\\the` bir geçici belirteç listesi oluşturur `\\count99`—bu belirteç listesi, ... içinde saklanan veri değerini temsil eden bir dizi karakter belirteci içerir `\\count` kaydında `99`. 6. Bir kez `\\the` genişletildikten sonra TeX, 3. adımda saklanan belirteci (`{`belirteç) ve o belirteci girdiye geri koyar. TeX bunu, başka bir belirteç listesi oluşturarak yapar; bunun içinde *tek* belirteç `{`belirteç. 7. TeX artık işlemeyi bitirmiştir `\\expandafter` ve sonraki giriş kaynakları olarak kullanılmaya hazır iki belirteç listesi üretmiş olur. TeX, tekrar işlemeye döner `\\toks99=` ama artık TeX girdisini öyle yapılandırmıştır ki `\\expandafter` tarafından oluşturulan iki belirteç listesi `\\toks`—şimdi `{`belirteç`<\\the\\count99 genişlemesi>`belirteç listesi (karakterler)`}`. `\\toks` beş karakter belirtecin dizisini erişebilir ve saklayabilir; bunlar veri değerini (`12345`) temsil eder `\\count99`: istediğimiz sonuç. 8. ... tarafından üretilen tüm karakter belirteçleri okunduktan sonra `\\the\\count99`, TeX önceki giriş kaynağına (bizim `.tex` dosyamız) geri döner; buradan bir sonraki belirteci okuyacaktır: kapanış `}` ... tarafından kaydedilecek belirteçler listesini sonlandırmak için gereken `\\toks99={...}`. ## \\\expandafter gerçekten nasıl çalışır Bu bölümde TeX’in içine “düşük seviyeden” bakacağız: ... davranışını uygulayan TeX kaynak kodunu/fonksiyonlarını inceleyeceğiz `\\expandafter`. Ayrıntılar sözde-C kodu ile ifade edilmiştir, ancak diğer programlama dillerine aşina olan herkes için anlaşılır olmalıdır. Aşağıdaki açıklamalı diyagram TeX’in ... nasıl uyguladığını açıklar `\\expandafter` daha büyük bir işlevin parçası olarak `expand()`—TeX’in genişleme işlemesini yönlendiren çekirdek işlev. ... uygulamaya ayrılan bölüm içinde `\\expandafter` görebiliriz [*özyinelemeli* davranış](https://en.wikipedia.org/wiki/Recursion) işlevine yapılan başka bir çağrının `expand()` fonksiyonu, okunan ikinci belirteci işlemek için kullanıldığı $$\mathrm{T\_2}$$, ... durumları için $$\mathrm{T\_2}$$ genişletilebilirdir. Bu kod Knuth’un TeX motorunda görünse de, bu grafiğin ortaya koyduğu temel ilkeler tüm TeX motorları için geçerlidir. ![TeX içinde \\\expandafter nasıl çalışır](/files/ff94d97614997be8fe98fa2c6e402ab47489232c) İlk görev `expand()` genişletilecek komutun bir makro mu yoksa bir ilkel komut mu olduğunu belirlemektir; çünkü makroların, ... adlı bir işlev tarafından ele alınan özel bir genişleme süreci vardır `macrocall()`. Eğer genişletilecek komut bir ilkel komutsa, `expand()` işlevi, mevcut komut kodu değerini (küresel değişken içinde saklanan `curcmd`) kullanarak hangi özel ilkel komutun işlenmesi gerektiğini belirler. Bu ayrıntıları `expand()`: ``` void expand(void) { //curcmd bir küresel değişkendir if(curcmd != macro) // curcmd < 111 { switch(curcmd) { case \expandafter: // \expandafter T1T2 komutunu işle { gettoken(); // T1 belirtecini oku t = curtok; // T1 belirtecini t yerel değişkeninde sakla gettoken(); // T2 belirtecini oku if(curcmd > 100) // T2 belirteci genişletilebilir mi? expand(); // Evet! T2 genişletilebilir: // T2'nin genişletmesini gerçekleştirerek // expand()'a özyinelemeli bir fonksiyon çağrısı yaparak aksi halde backinput(); // T2 genişletilebilir değil: o belirteci koy // daha sonra yeniden okunmak üzere girdiye geri curtok = t ; // curtok genel değişkenini T1'in kaydedilmiş değerine geri yükle backinput() ; // T1 belirtecini girdiye geri koy // T2'nin genişletilmesinden doğan belirteçlerin önüne } break; // Diğer genişletilebilir komutları işleme kodu case “metne dönüştür” komutu: // \number, \string, \romannumeral, // \meaning, \fontname, \jobname // Hepsi curcmd'nin aynı değerini paylaşır break; case \noexpand: // Sonraki belirtecin genişletilmesini engelle ... break; case \csname: // Bir kontrol dizisi adı oluştur. ... break; case \the: // Bazı belirteçler ekle .... break; case “\if... test komutu” : // TeX'in koşul ifadelerinden birini işle: // \if, \ifcat, \ifnum, \ifdim, \ifodd, \ifvmode, // \ifhmode, \ifmmode, \ifinner, \ifvoid, // \ifhbox, \ifvbox, \ifx, \ifeof, \iftrue, \iffalse, // \ifcase, \ifdefined, \ifcsname, \iffontchar ... break; case “\fi veya \else”: // Geçerli koşulu sonlandır ... break; // ve TeX çekirdeği tarafından desteklenen diğer genişletilebilir ilkel komutlar için de benzerleri // TeX işleyicisi } }else // Genişletilebilir bir ilkel değil: bu bir makrodur { macrocall() } //... daha fazla kod kaldırıldı } ``` ### TeX'in genel değişkenlere olan sevgisi Belki de yaşını ve tasarlandığı dönemi yansıtarak, TeX'in kaynak kodu sözde [genel değişkenler](https://en.wikipedia.org/wiki/Global_variable)—aslında bunlardan yüzlercesi vardır. Doğaları gereği, genel değişkenler TeX kaynak kodunun herhangi bir yerinden değiştirilebilir/düzenlenebilir; Knuth'un TeX'inde bu, 25.000'den fazla kod satırı ve yüzlerce işlev içeren tek ve büyük bir dosyadır. TeX'in nasıl çalıştığını anlamak her zaman kolay bir iş değildir... İşlemek için `\\expandafter`, TeX şu adlı bir işlev kullanarak geçerli girdisinden belirteçleri okur: `gettoken()` bu işlevin eylemi, bir belirteç oluşturmak ve TeX'in kaynak kodu boyunca kullanılan birkaç önemli genel değişkenin değerini ayarlamaktır. Bu işlevin eylemiyle güncellenen bu tür iki değişken, `gettoken()`, uygulanmasında kullanılır `\\expandafter`: * `curtok`: (geçerli belirteç) az önce okunan belirtecin tamsayı değeri; * `curcmd`: (geçerli komut kodu) belirtecin temsil ettiği komutun (veya karakterin) komut kodu `curtok`. İşlenirken `\\expandafter`$$\mathrm{T\_1T\_2}$$ TeX belirteci okur $$\mathrm{T\_1}$$ ve değerini (bir tamsayı) geçici olarak adlı bir yerel değişkende saklar `t`. Ardından TeX şunu okur: $$\mathrm{T\_2}$$ ve o belirtecin genişletilebilir bir komutu temsil edip etmediğini kontrol eder—komut kodunun (`curcmd`) > 100 olup olmadığına bakarak. Eğer öyleyse, TeX'in tarafından temsil edilen komutu genişletmesi gerekir $$\mathrm{T\_2}$$ ve şu işleve bir çağrı daha yapar `expand()`: bu, bir örneğidir *özyineleme* çünkü `expand()` işlevin kendisini çağırmasıdır. Genişletmenin özyinelemeli doğasının farkında olmak, özellikle ... kullanırken, yardımcı olabilir `\\expandafter`, `\\expandafter` komutlar—yani, `\\expandafter\\expandafter\\expandafter...` etkilerini gerçekleştirirler. Eğer belirteç $$\mathrm{T\_2}$$ genişletilebilirse, genişletme gerçekleşir ve şu işleve yapılan özyinelemeli çağrı `expand()` döndüğünde, şu işlevin uygulamasındaki kod `\\expandafter` belirteci yeniden ekler $$\mathrm{T\_1}$$ girdiye geri. Genel değişken `curtok` kaydedilmiş belirtecin değerine yeniden atanır—yerel değişken `t`, bu da belirtecin değeridir $$\mathrm{T\_1}$$—ve şu işlev çağrılır `backinput().` #### backinput() işlevi Adından da anlaşılacağı gibi, bu işlev bir belirteci “girdiye geri” koyar. Bunu yapmak için TeX, genel değişkenin geçerli değerini kullanır `curtok` tek bir belirteç içeren bir belirteç listesi oluşturmak için (tamsayı değeri şu değişken tarafından sağlanır `curtok`). TeX ayrıca, uygun zamanda bu tek belirteçli listenin TeX tarafından sonraki girdi işleme sürecinin bir parçası olarak yeniden okunmasını sağlamak üzere girdi işlemesini düzenler. Dikkat edin: belirteç $$\mathrm{T\_1}$$ yeniden eklenir *genişletme tamamlandıktan sonra*, bu da TeX'in yeniden eklenen belirteci okuyacağını garanti eder *önce* şunun genişletilmesinden doğan belirteçleri okurken $$\mathrm{T\_2}$$. ### Makroları işleme: macrocall() işlevi Daha önce tartışıldığı gibi, tüm makrolar bazı ilkel komutlarla birlikte genişletilebilir ve tüm genişletme işlemleri şu işlev üzerinden geçer `expand()` işlevi. Ancak, `expand()` kullanmaya dikkat eder `curcmd` (geçerli komut) değerini, genişletilebilir ilkeller ile makroları ayırt etmek için kullanır; çünkü makro genişletme süreci şu adlı özel bir işlev tarafından ele alınır `macrocall()`. Makrolar özel bir genişletme sürecine ihtiyaç duyar; çünkü makro argümanları ve ayırıcı belirteçler çok belirli ve titiz bir şekilde taranmalıdır; bu nedenle bu süreç, bunu yapmak için tasarlanmış bir işleve devredilir: `macrocall()`. #### Makro genişletme vs. makro yürütme Makro *genişletme* makro *yürütme*: bir makronun genişletilmesi, TeX'in makroyu elde etmek için gerçekleştirdiği yürütme öncesi süreçtir *yürütmeye hazır*. Bir makronun “yürütülmesi”, TeX'in o makronun tanımında (yerine geçen metin) ve argümanlarında (parametreler) bulunan belirteçleri etkin olarak okuyup işlemesi sırasında gerçekleşir. #### Makro genişletme Bir makroyu genişletmek için TeX önce makronun argüman alıp almadığını kontrol eder; eğer alıyorsa, `macrocall()` makronun argümanları olacak belirteçleri bulmak için girdiyi büyük bir dikkatle tarar. Bu süreç, kullanıcının girdisinde makronun özgün tanımında kullanılan herhangi bir ayırıcı belirteci kontrol etmeyi de içerir—bir makro çağrısında kullanılan belirteç deseni, saklanan tanımda bulunan belirteç desenine tam olarak uymalıdır. Ancak ayırıcı olarak kullanılan belirteçler TeX tarafından basitçe atılır: bunlar özünde, TeX'in makronun argümanları olacak gerçek belirteçleri belirlemek için kullandığı bir tür “noktalama işaretidir”—yani kullanıcının makro tarafından işlenmesini amaçladığı belirteçlerdir. Ayırıcı belirteçler hakkında daha fazla bilgi için bkz. [TeX makroları gerçekte nasıl çalışır](/latex/tr/daha-fazla-konu/22-how-tex-macros-actually-work-part-4.md). Her parametre için (`#1, #2...#9`) makronun özgün tanımında bulunuyorsa, TeX gerçek makro çağrısını tarayarak kullanıcının sağladığı hangi belirteçlerin hangi parametre için olduğunu belirler (yani makronun argümanlarını oluşturur). Bu süreç, her makro argümanı için bir mini belirteç listesi olmak üzere bir veya daha fazla mini belirteç listesi üretir. Herhangi bir makro argümanı algılandıktan ve bunların belirteç listeleri hazırlandıktan sonra, TeX belleğinde saklanan makronun tanımını (yerine geçen metin) alır ve girdi işlemesini, TeX daha fazla belirteç okumaya/işlemeye hazır olduğunda bunları makronun yerine geçen metinden okuyacak şekilde düzenler; böylece makroyu yürütür. Uygun noktada, makro yürütülürken, makro argümanlarını temsil eden belirteç listeleri makronun yerine geçen metnindeki doğru konuma yerleştirilir. Yine, bir makro komutunun genişletilmesi *kaldırmak* o makro komutunu (belirteci) girdiden ve *yerine koymak* onun yerine makronun yerine geçen metni olarak saklanan belirteç listesini koymak demektir. TeX'in makro işlemeye derinlemesine bakış için altı bölümlük makale serisine bakın [TeX makroları gerçekte nasıl çalışır?](/latex/tr/daha-fazla-konu/01-a-six-part-series-how-do-tex-macros-actually-work.md) [Bölüm 1](/latex/tr/derinlemesine-makaleler/19-how-does-expandafter-work-an-introduction-to-tex-tokens.md) [Bölüm 2](/latex/tr/derinlemesine-makaleler/22-how-does-expandafter-work-the-meaning-of-expansion.md) [Bölüm 3](/latex/tr/derinlemesine-makaleler/21-how-does-expandafter-work-tex-uses-temporary-token-lists.md) [Bölüm 4](/latex/tr/derinlemesine-makaleler/20-how-does-expandafter-work-from-basic-principles-to-exploring-tex-s-source-code.md) [Bölüm 5](/latex/tr/derinlemesine-makaleler/17-how-does-expandafter-work-a-detailed-macro-case-study.md) [Bölüm 6](/latex/tr/derinlemesine-makaleler/18-how-does-expandafter-work-a-detailed-study-of-consecutive-expandafter-commands.md) --- # 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/20-how-does-expandafter-work-from-basic-principles-to-exploring-tex-s-source-code.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.